From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from list by lists.gnu.org with archive (Exim 4.71) id 1Yob1C-0005L7-0N for mharc-grub-devel@gnu.org; Sat, 02 May 2015 13:15:58 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:44750) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Yob18-0005KO-6i for grub-devel@gnu.org; Sat, 02 May 2015 13:15:56 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1Yob14-0006ww-Td for grub-devel@gnu.org; Sat, 02 May 2015 13:15:54 -0400 Received: from mail-lb0-x234.google.com ([2a00:1450:4010:c04::234]:33073) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Yob14-0006wb-FJ for grub-devel@gnu.org; Sat, 02 May 2015 13:15:50 -0400 Received: by lbbzk7 with SMTP id zk7so81788258lbb.0 for ; Sat, 02 May 2015 10:15:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=date:from:to:cc:subject:message-id:in-reply-to:references :mime-version:content-type:content-transfer-encoding; bh=PajHFP9V/b485z2FA8fybVLZjE/tWQz2XebDImxKctI=; b=A4y+h+wgbRfBVpLkFZ01lthGyWlG4hmlEebfBg8i6DvU8hmoce/xXFHSyaRLWCKuIq DHzWeFbH6IJeQcKzaKirrNOvZLU3mBw+Ul0cf5MfZJNXJ6zhlVoCxvncRGtfjgMRp6ro Gozo0D51Vosr/YM0npT8/BoTm2uzgOlTL/bu2fQ25fEEaskDZsLr+vXhShEahb7DInce W/XW8g+pIm7PCaprMI5j5GHcvcFKf5GdU70ZpiDneTSAGu91BV4ZowQytN2p4UsdzqKb gQu1IwS4+CFAIebSEz5Fd32B1mMFD34o16TGvwU6zbgO6odQocDXgtxLUl6lJBs7eFv2 a1dw== X-Received: by 10.112.144.69 with SMTP id sk5mr12733798lbb.6.1430586949224; Sat, 02 May 2015 10:15:49 -0700 (PDT) Received: from opensuse.site (ppp91-76-14-38.pppoe.mtu-net.ru. [91.76.14.38]) by mx.google.com with ESMTPSA id 4sm2138377lai.36.2015.05.02.10.15.47 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sat, 02 May 2015 10:15:48 -0700 (PDT) Date: Sat, 2 May 2015 20:15:45 +0300 From: Andrei Borzenkov To: Jaegeuk Kim Subject: Re: [PATCH v2] F2FS support Message-ID: <20150502201545.1ac3fead@opensuse.site> In-Reply-To: <20150403224908.GB25673@jaegeuk-mac02.mot.com> References: <1427185140-41120-1-git-send-email-jaegeuk@kernel.org> <20150403224908.GB25673@jaegeuk-mac02.mot.com> X-Mailer: Claws Mail 3.11.0 (GTK+ 2.24.27; x86_64-suse-linux-gnu) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: Error: Malformed IPv6 address (bad octet value). X-Received-From: 2a00:1450:4010:c04::234 Cc: grub-devel@gnu.org, linux-f2fs-devel@lists.sourceforge.net X-BeenThere: grub-devel@gnu.org X-Mailman-Version: 2.1.14 Precedence: list Reply-To: The development of GNU GRUB List-Id: The development of GNU GRUB List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 02 May 2015 17:15:56 -0000 Sorry for delay. =D0=92 Fri, 3 Apr 2015 15:49:08 -0700 Jaegeuk Kim =D0=BF=D0=B8=D1=88=D0=B5=D1=82: >=20 > This patch changes: >=20 > * Makefile.util.def: Add f2fs.c. > * doc/grub.texi: Add f2fs description. > * grub-core/Makefile.core.def: Add f2fs module. > * grub-core/fs/f2fs.c: New file. > * tests/f2fs_test.in: New file. > * tests/util/grub-fs-tester.in: Add f2fs requirements. >=20 Drop file list, it is available from git. ... > diff --git a/grub-core/fs/f2fs.c b/grub-core/fs/f2fs.c > new file mode 100644 > index 0000000..e6b8386 > --- /dev/null > +++ b/grub-core/fs/f2fs.c > + ... > +#define JENTRY_SIZE 13 sizeof (struct grub_f2fs_nat_jent), right? ... > + > +#define NAT_ENTRY_SIZE 9 That's sizeof (struct grub_f2fs_nat_entry)? ... > +#define ver_after (a, b) ((long long)((a) - (b)) > 0) This macro is not used anywhere > +#define F2FS_NAME_LEN 255 > +#define F2FS_SLOT_LEN 8 > +#define NR_DENTRY_IN_BLOCK 214 > +#define SIZE_OF_DIR_ENTRY 11 /* by byte */ sizeof (struct grub_f2fs_dir_entry)? ... > +enum > + { > + FI_INLINE_XATTR =3D 9, > + FI_INLINE_DATA =3D 10, > + FI_INLINE_DENTRY =3D 11, > + FI_DATA_EXIST =3D 18, > + }; > + This does not match subsequent usage; you use them with i_inline, not i_flags. ... > + > +static inline int > +grub_generic_test_bit (int nr, const grub_uint32_t *addr) > +{ > + return 1UL & (addr[nr / 32] >> (nr & 31)); > +} > + This is used only in grub_f2fs_check_dentries() with on-disk bitmap. On-disk bitmap is little-endian; code is wrong on big-endian system. Also dentry_bitmap is not multiple of 4 bytes as you replied earlier. You should rather compute correct byte address instead and make all parameters grub_uint8_t *. This will also avoid all those casts later. That's really just grub_uint8_t *addr; byte =3D nr >> 3; #ifdef WORDS_BIGENDIAN byte ^=3D 3; #endif return addr[byte] & (1 << nr & 7); ... > + > +static inline int > +__inode_inline_set (struct grub_f2fs_inode *inode, int flag) > +{ > + return inode->i_inline & flag; > +} > + Function is completely redundant if you really want to check i_inline; just use it directly. Then definition of flags is wrong. If you mean inode->i_flags (as implied by passed flag values) this should obviously be (1 << flag) as adjusted by system byte order. Out of curiosity - it appears those flags are present in both i_inline and i_flags; which one is authoritative? > +static inline grub_uint32_t > +__nat_bitmap_size (struct grub_f2fs_data *data) > +{ > + struct grub_f2fs_checkpoint *ckpt =3D &data->ckpt; > + > + return grub_le_to_cpu32 (ckpt->nat_ver_bitmap_bytesize); > +} This function is not used anywhere. ... > + > +static inline grub_uint32_t > +__get_node_id (struct grub_f2fs_node *rn, int off, int i) > +{ > + if (i) Judging by usage something like "first" would probably be more appropriate. > + return grub_le_to_cpu32 (rn->i.i_nid[off - NODE_DIR1_BLOCK]); > + return grub_le_to_cpu32 (rn->in.nid[off]); > +} > + > +static inline grub_err_t > +grub_f2fs_block_read (struct grub_f2fs_data *data, grub_uint32_t blkaddr= , void *buf) > +{ > + return grub_disk_read (data->disk, blkaddr << F2FS_BLK_SEC_BITS, I suspect coverity will complain about overflow here; cast of blkaddr to grub_disk_addr_t should silence it. > + 0, F2FS_BLKSIZE, buf); > +} > + ... > + > +static grub_err_t Not sure if it is needed here; see comment below at caller. > +grub_f2fs_read_sb (struct grub_f2fs_data *data, grub_uint64_t offset) > +{ > + grub_disk_t disk =3D data->disk; > + grub_err_t err; > + > + /* Read first super block. */ > + err =3D grub_disk_read (disk, offset >> GRUB_DISK_SECTOR_BITS, 0, Make parameter grub_disk_addr_t and compute it in caller. It is constant, there is no need to compute it at run time. > + sizeof (data->sblock), &data->sblock); > + if (err) > + return err; > + > + if (grub_f2fs_sanity_check_sb (&data->sblock)) > + err =3D GRUB_ERR_BAD_FS; > + > + return err; > +} > + > +static void * > +validate_checkpoint (struct grub_f2fs_data *data, grub_uint32_t cp_addr, > + grub_uint64_t *version) > +{ > + void *cp_page_1, *cp_page_2; > + struct grub_f2fs_checkpoint *cp_block; > + grub_uint64_t cur_version =3D 0, pre_version =3D 0; > + grub_uint32_t crc =3D 0; > + grub_uint32_t crc_offset; > + grub_err_t err; > + > + /* Read the 1st cp block in this CP pack */ > + cp_page_1 =3D grub_malloc (F2FS_BLKSIZE); > + if (!cp_page_1) > + return NULL; > + > + err =3D grub_f2fs_block_read (data, cp_addr, cp_page_1); > + if (err) > + goto invalid_cp1; > + > + cp_block =3D (struct grub_f2fs_checkpoint *)cp_page_1; > + crc_offset =3D grub_le_to_cpu32 (cp_block->checksum_offset); > + if (crc_offset >=3D F2FS_BLKSIZE) > + goto invalid_cp1; > + > + crc =3D grub_le_to_cpu32 (*(grub_uint32_t *)((char *)cp_block + crc_of= fset)); I understand that it /should/ be hardcoded to 4092, but then please either check that crc_offset *is* 4092 before or use grub_get_unaligned. Otherwise it crashes on archs that do not support unaligned access. > + if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset)) > + goto invalid_cp1; > + > + pre_version =3D grub_le_to_cpu64 (cp_block->checkpoint_ver); > + > + /* Read the 2nd cp block in this CP pack */ > + cp_page_2 =3D grub_malloc (F2FS_BLKSIZE); > + if (!cp_page_2) > + goto invalid_cp1; > + > + cp_addr +=3D grub_le_to_cpu32 (cp_block->cp_pack_total_block_count) - = 1; > + > + err =3D grub_f2fs_block_read (data, cp_addr, cp_page_2); > + if (err) > + goto invalid_cp2; > + > + cp_block =3D (struct grub_f2fs_checkpoint *)cp_page_2; > + crc_offset =3D grub_le_to_cpu32 (cp_block->checksum_offset); > + if (crc_offset >=3D F2FS_BLKSIZE) > + goto invalid_cp2; > + > + crc =3D grub_le_to_cpu32 (*(grub_uint32_t *)((char *)cp_block + crc_of= fset)); Ditto. > + if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset)) > + goto invalid_cp2; > + > + cur_version =3D grub_le_to_cpu64 (cp_block->checkpoint_ver); > + if (cur_version =3D=3D pre_version) > + { > + *version =3D cur_version; > + grub_free (cp_page_2); > + return cp_page_1; > + } > + > +invalid_cp2: > + grub_free (cp_page_2); > +invalid_cp1: > + grub_free (cp_page_1); > + return NULL; > +} > + > +static grub_err_t > +grub_f2fs_read_cp (struct grub_f2fs_data *data) > +{ > + void *cp1, *cp2, *cur_page; > + grub_uint64_t cp1_version =3D 0, cp2_version =3D 0; > + grub_uint64_t cp_start_blk_no; > + > + /* > + * Finding out valid cp block involves read both > + * sets (cp pack1 and cp pack 2) > + */ > + cp_start_blk_no =3D data->cp_blkaddr; > + cp1 =3D validate_checkpoint (data, cp_start_blk_no, &cp1_version); > + if (!cp1 && grub_errno) > + return grub_errno; > + > + /* The second checkpoint pack should start at the next segment */ > + cp_start_blk_no +=3D data->blocks_per_seg; > + cp2 =3D validate_checkpoint (data, cp_start_blk_no, &cp2_version); > + if (!cp2 && grub_errno) > + { > + grub_free (cp1); > + return grub_errno; > + } > + > + if (cp1 && cp2) > + cur_page =3D (cp2_version > cp1_version) ? cp2 : cp1; > + else if (cp1) > + cur_page =3D cp1; > + else if (cp2) > + cur_page =3D cp2; > + else > + return grub_error (GRUB_ERR_BAD_FS, "no checkpoints\n"); Trailing "\n" is not needed. > + > + grub_memcpy (&data->ckpt, cur_page, F2FS_BLKSIZE); > + > + grub_free (cp1); > + grub_free (cp2); > + return 0; > +} > + ... > + > +static struct grub_f2fs_data * > +grub_f2fs_mount (grub_disk_t disk) > +{ > + struct grub_f2fs_data *data; > + grub_err_t err; > + > + data =3D grub_zalloc (sizeof (*data)); Is it needed to be zalloc? Structure is large and it runs every time file is accessed. Most of it is immediately overwritten, may be explicitly initialize what remains? > + if (!data) > + return NULL; > + > + data->disk =3D disk; > + > + err =3D grub_f2fs_read_sb (data, F2FS_SUPER_OFFSET); > + if (err) > + { > + err =3D grub_f2fs_read_sb (data, F2FS_BLKSIZE + F2FS_SUPER_OFFSET); As mentioned just compute disk address here, it is static. > + if (err) > + { > + grub_error (GRUB_ERR_BAD_FS, "not a F2FS filesystem (no superb= lock)"); > + goto fail; > + } > + } You should check for err !=3D GRUB_ERR_BAD_FS here, otherwise error from grub_disk_read is lost. Alternatively just return 0/1 from read_sb, so that if (grub_f2fs_read_sb) if (grub_f2fs_read_sb) if (grub_errno =3D=3D GRUB_ERR_NONE) grub_error (GRUB_ERR_BAD_FS, ...) goto fail > + > + data->root_ino =3D grub_le_to_cpu32 (data->sblock.root_ino); > + data->cp_blkaddr =3D grub_le_to_cpu32 (data->sblock.cp_blkaddr); > + data->nat_blkaddr =3D grub_le_to_cpu32 (data->sblock.nat_blkaddr); > + data->blocks_per_seg =3D 1 << > + grub_le_to_cpu32 (data->sblock.log_blocks_per_seg); > + > + err =3D grub_f2fs_read_cp (data); > + if (err) > + goto fail; > + > + data->nat_bitmap =3D __nat_bitmap_ptr (data); > + > + err =3D get_nat_journal (data); > + if (err) > + goto fail; > + > + data->diropen.data =3D data; > + data->diropen.ino =3D data->root_ino; > + data->diropen.inode_read =3D 1; > + data->inode =3D &data->diropen.inode; > + > + err =3D grub_f2fs_read_node (data, data->root_ino, data->inode); > + if (err) > + goto fail; > + > + return data; > + > +fail: > + grub_free (data); > + return NULL; > +} > + ... > + > +static grub_ssize_t > +grub_f2fs_read_file (grub_fshelp_node_t node, > + grub_disk_read_hook_t read_hook, void *read_hook_data, > + grub_off_t pos, grub_size_t len, char *buf) > +{ > + struct grub_f2fs_inode *inode =3D &(node->inode.i); Why extra parens? > + grub_off_t filesize =3D grub_f2fs_file_size (inode); > + char *inline_addr =3D __inline_addr (inode); > + > + if (__inode_inline_set (&node->inode.i, FI_INLINE_DATA)) Just inode, you already have it. > + { > + if (pos > filesize || filesize > MAX_INLINE_DATA) > + { > + grub_error (GRUB_ERR_OUT_OF_RANGE, > + N_("attempt to read past the end of file")); If filesize > MAX_INLINE_DATA at this point we really deal with corrupted filesystem so this should be GRUB_ERR_BAD_FS. > + return -1; > + } > + if (pos + len > filesize) len > filesize - pos is probably more coverity-friendly. > + len =3D filesize - pos; > + > + grub_memcpy (buf + pos, inline_addr + pos, len); > + return len; > + } > + > + return grub_fshelp_read_file (node->data->disk, node, > + read_hook, read_hook_data, > + pos, len, buf, grub_f2fs_get_block, > + filesize, > + F2FS_BLK_SEC_BITS, 0); > +} > + ... > + > +static int > +grub_f2fs_check_dentries (struct grub_f2fs_dir_iter_ctx *ctx) > +{ > + struct grub_fshelp_node *fdiro; > + int i; > + > + for (i =3D 0; i < ctx->max;) > + { > + char *filename; > + enum grub_fshelp_filetype type =3D GRUB_FSHELP_UNKNOWN; > + enum FILE_TYPE ftype; > + int name_len; > + int ret; > + > + if (grub_generic_test_bit (i, ctx->bitmap) =3D=3D 0) > + { > + i++; > + continue; > + } > + > + ftype =3D ctx->dentry[i].file_type; > + name_len =3D grub_le_to_cpu16 (ctx->dentry[i].name_len); > + filename =3D grub_zalloc (name_len + 1); It is overwritten on next line, do you really need grub_zalloc only for the trailing zero? > + if (!filename) > + return 0; > + > + grub_memcpy (filename, ctx->filename[i], name_len); > + > + fdiro =3D grub_malloc (sizeof (struct grub_fshelp_node)); > + if (!fdiro) > + { > + grub_free(filename); > + return 0; > + } > + > + if (ftype =3D=3D F2FS_FT_DIR) > + type =3D GRUB_FSHELP_DIR; > + else if (ftype =3D=3D F2FS_FT_SYMLINK) > + type =3D GRUB_FSHELP_SYMLINK; > + else if (ftype =3D=3D F2FS_FT_REG_FILE) > + type =3D GRUB_FSHELP_REG; > + > + fdiro->data =3D ctx->data; > + fdiro->ino =3D grub_le_to_cpu32 (ctx->dentry[i].ino); > + fdiro->inode_read =3D 0; > + > + ret =3D ctx->hook (filename, type, fdiro, ctx->hook_data); > + grub_free(filename); > + if (ret) > + return 1; > + > + i +=3D (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN; > + } > + return 0; > +} > + ... > + > +static void > +grub_f2fs_unicode_to_ascii (grub_uint8_t *out_buf, grub_uint16_t *in_buf) > +{ > + grub_uint16_t *pchTempPtr =3D in_buf; > + grub_uint8_t *pwTempPtr =3D out_buf; > + > + while (*pchTempPtr !=3D '\0') > + { > + *pwTempPtr =3D (grub_uint8_t) *pchTempPtr; This is not byte order safe and it does not convert to ASCII as name suggests. If you are going to convert to 8 bit encoding why not simply use grub_utf16_to_utf8? > + pchTempPtr++; > + pwTempPtr++; > + } > + *pwTempPtr =3D '\0'; > + return; > +} > + > +static grub_err_t > +grub_f2fs_label (grub_device_t device, char **label) > +{ > + struct grub_f2fs_data *data; > + grub_disk_t disk =3D device->disk; > + > + grub_dl_ref (my_mod); > + > + data =3D grub_f2fs_mount (disk); > + if (data) > + { > + *label =3D grub_zalloc (sizeof (data->sblock.volume_name)); > + if (*label) > + grub_f2fs_unicode_to_ascii ((grub_uint8_t *) (*label), > + data->sblock.volume_name); See above. > + } > + else > + *label =3D NULL; > + > + grub_free (data); > + grub_dl_unref (my_mod); > + return grub_errno; > +} > + ... From mboxrd@z Thu Jan 1 00:00:00 1970 From: Andrei Borzenkov Subject: Re: [PATCH v2] F2FS support Date: Sat, 2 May 2015 20:15:45 +0300 Message-ID: <20150502201545.1ac3fead@opensuse.site> References: <1427185140-41120-1-git-send-email-jaegeuk@kernel.org> <20150403224908.GB25673@jaegeuk-mac02.mot.com> Reply-To: The development of GNU GRUB Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20150403224908.GB25673@jaegeuk-mac02.mot.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: grub-devel-bounces+gcbgd-grub-devel=m.gmane.org@gnu.org Sender: grub-devel-bounces+gcbgd-grub-devel=m.gmane.org@gnu.org To: Jaegeuk Kim Cc: grub-devel@gnu.org, linux-f2fs-devel@lists.sourceforge.net List-Id: linux-f2fs-devel.lists.sourceforge.net U29ycnkgZm9yIGRlbGF5LgoKCtCSIEZyaSwgMyBBcHIgMjAxNSAxNTo0OTowOCAtMDcwMApKYWVn ZXVrIEtpbSA8amFlZ2V1a0BrZXJuZWwub3JnPiDQv9C40YjQtdGCOgoKPiAKPiBUaGlzIHBhdGNo IGNoYW5nZXM6Cj4gCj4gICogTWFrZWZpbGUudXRpbC5kZWY6IEFkZCBmMmZzLmMuCj4gICogZG9j L2dydWIudGV4aTogQWRkIGYyZnMgZGVzY3JpcHRpb24uCj4gICogZ3J1Yi1jb3JlL01ha2VmaWxl LmNvcmUuZGVmOiBBZGQgZjJmcyBtb2R1bGUuCj4gICogZ3J1Yi1jb3JlL2ZzL2YyZnMuYzogTmV3 IGZpbGUuCj4gICogdGVzdHMvZjJmc190ZXN0LmluOiBOZXcgZmlsZS4KPiAgKiB0ZXN0cy91dGls L2dydWItZnMtdGVzdGVyLmluOiBBZGQgZjJmcyByZXF1aXJlbWVudHMuCj4gCgpEcm9wIGZpbGUg bGlzdCwgaXQgaXMgYXZhaWxhYmxlIGZyb20gZ2l0LgoKLi4uCj4gZGlmZiAtLWdpdCBhL2dydWIt Y29yZS9mcy9mMmZzLmMgYi9ncnViLWNvcmUvZnMvZjJmcy5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2 NDQKPiBpbmRleCAwMDAwMDAwLi5lNmI4Mzg2Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2dydWIt Y29yZS9mcy9mMmZzLmMKPiArCi4uLgo+ICsjZGVmaW5lIEpFTlRSWV9TSVpFCQkxMwoKc2l6ZW9m IChzdHJ1Y3QgZ3J1Yl9mMmZzX25hdF9qZW50KSwgcmlnaHQ/CgouLi4KPiArCj4gKyNkZWZpbmUg TkFUX0VOVFJZX1NJWkUgCQk5CgpUaGF0J3Mgc2l6ZW9mIChzdHJ1Y3QgZ3J1Yl9mMmZzX25hdF9l bnRyeSk/CgouLi4KPiArI2RlZmluZSB2ZXJfYWZ0ZXIgKGEsIGIpCSgobG9uZyBsb25nKSgoYSkg LSAoYikpID4gMCkKClRoaXMgbWFjcm8gaXMgbm90IHVzZWQgYW55d2hlcmUKCj4gKyNkZWZpbmUg RjJGU19OQU1FX0xFTgkJMjU1Cj4gKyNkZWZpbmUgRjJGU19TTE9UX0xFTgkJOAo+ICsjZGVmaW5l IE5SX0RFTlRSWV9JTl9CTE9DSwkyMTQKPiArI2RlZmluZSBTSVpFX09GX0RJUl9FTlRSWQkxMQkv KiBieSBieXRlICovCgpzaXplb2YgKHN0cnVjdCBncnViX2YyZnNfZGlyX2VudHJ5KT8KCi4uLgo+ ICtlbnVtCj4gKyAgewo+ICsgICAgRklfSU5MSU5FX1hBVFRSID0gOSwKPiArICAgIEZJX0lOTElO RV9EQVRBID0gMTAsCj4gKyAgICBGSV9JTkxJTkVfREVOVFJZID0gMTEsCj4gKyAgICBGSV9EQVRB X0VYSVNUID0gMTgsCj4gKyAgfTsKPiArCgpUaGlzIGRvZXMgbm90IG1hdGNoIHN1YnNlcXVlbnQg dXNhZ2U7IHlvdSB1c2UgdGhlbSB3aXRoIGlfaW5saW5lLCBub3QKaV9mbGFncy4KCi4uLgo+ICsK PiArc3RhdGljIGlubGluZSBpbnQKPiArZ3J1Yl9nZW5lcmljX3Rlc3RfYml0IChpbnQgbnIsIGNv bnN0IGdydWJfdWludDMyX3QgKmFkZHIpCj4gK3sKPiArICByZXR1cm4gMVVMICYgKGFkZHJbbnIg LyAzMl0gPj4gKG5yICYgMzEpKTsKPiArfQo+ICsKClRoaXMgaXMgdXNlZCBvbmx5IGluIGdydWJf ZjJmc19jaGVja19kZW50cmllcygpIHdpdGggb24tZGlzayBiaXRtYXAuCk9uLWRpc2sgYml0bWFw IGlzIGxpdHRsZS1lbmRpYW47IGNvZGUgaXMgd3Jvbmcgb24gYmlnLWVuZGlhbiBzeXN0ZW0uCgpB bHNvIGRlbnRyeV9iaXRtYXAgaXMgbm90IG11bHRpcGxlIG9mIDQgYnl0ZXMgYXMgeW91IHJlcGxp ZWQgZWFybGllci4KWW91IHNob3VsZCByYXRoZXIgY29tcHV0ZSBjb3JyZWN0IGJ5dGUgYWRkcmVz cyBpbnN0ZWFkIGFuZCBtYWtlIGFsbApwYXJhbWV0ZXJzIGdydWJfdWludDhfdCAqLiBUaGlzIHdp bGwgYWxzbyBhdm9pZCBhbGwgdGhvc2UgY2FzdHMgbGF0ZXIuCgpUaGF0J3MgcmVhbGx5IGp1c3QK CiAgZ3J1Yl91aW50OF90ICphZGRyOwoKICBieXRlID0gbnIgPj4gMzsKI2lmZGVmIFdPUkRTX0JJ R0VORElBTgogIGJ5dGUgXj0gMzsKI2VuZGlmCiAgcmV0dXJuIGFkZHJbYnl0ZV0gJiAoMSA8PCBu ciAmIDcpOwoKLi4uCj4gKwo+ICtzdGF0aWMgaW5saW5lIGludAo+ICtfX2lub2RlX2lubGluZV9z ZXQgKHN0cnVjdCBncnViX2YyZnNfaW5vZGUgKmlub2RlLCBpbnQgZmxhZykKPiArewo+ICsgIHJl dHVybiBpbm9kZS0+aV9pbmxpbmUgJiBmbGFnOwo+ICt9Cj4gKwoKRnVuY3Rpb24gaXMgY29tcGxl dGVseSByZWR1bmRhbnQgaWYgeW91IHJlYWxseSB3YW50IHRvIGNoZWNrIGlfaW5saW5lOwpqdXN0 IHVzZSBpdCBkaXJlY3RseS4gVGhlbiBkZWZpbml0aW9uIG9mIGZsYWdzIGlzIHdyb25nLgoKSWYg eW91IG1lYW4gaW5vZGUtPmlfZmxhZ3MgKGFzIGltcGxpZWQgYnkgcGFzc2VkIGZsYWcgdmFsdWVz KSB0aGlzCnNob3VsZCBvYnZpb3VzbHkgYmUgKDEgPDwgZmxhZykgYXMgYWRqdXN0ZWQgYnkgc3lz dGVtIGJ5dGUgb3JkZXIuCgpPdXQgb2YgY3VyaW9zaXR5IC0gaXQgYXBwZWFycyB0aG9zZSBmbGFn cyBhcmUgcHJlc2VudCBpbiBib3RoIGlfaW5saW5lCmFuZCBpX2ZsYWdzOyB3aGljaCBvbmUgaXMg YXV0aG9yaXRhdGl2ZT8KCj4gK3N0YXRpYyBpbmxpbmUgZ3J1Yl91aW50MzJfdAo+ICtfX25hdF9i aXRtYXBfc2l6ZSAoc3RydWN0IGdydWJfZjJmc19kYXRhICpkYXRhKQo+ICt7Cj4gKyAgc3RydWN0 IGdydWJfZjJmc19jaGVja3BvaW50ICpja3B0ID0gJmRhdGEtPmNrcHQ7Cj4gKwo+ICsgIHJldHVy biBncnViX2xlX3RvX2NwdTMyIChja3B0LT5uYXRfdmVyX2JpdG1hcF9ieXRlc2l6ZSk7Cj4gK30K ClRoaXMgZnVuY3Rpb24gaXMgbm90IHVzZWQgYW55d2hlcmUuCgouLi4KPiArCj4gK3N0YXRpYyBp bmxpbmUgZ3J1Yl91aW50MzJfdAo+ICtfX2dldF9ub2RlX2lkIChzdHJ1Y3QgZ3J1Yl9mMmZzX25v ZGUgKnJuLCBpbnQgb2ZmLCBpbnQgaSkKPiArewo+ICsgIGlmIChpKQoKSnVkZ2luZyBieSB1c2Fn ZSBzb21ldGhpbmcgbGlrZSAiZmlyc3QiIHdvdWxkIHByb2JhYmx5IGJlIG1vcmUKYXBwcm9wcmlh dGUuCgo+ICsgICAgcmV0dXJuIGdydWJfbGVfdG9fY3B1MzIgKHJuLT5pLmlfbmlkW29mZiAtIE5P REVfRElSMV9CTE9DS10pOwo+ICsgIHJldHVybiBncnViX2xlX3RvX2NwdTMyIChybi0+aW4ubmlk W29mZl0pOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGdydWJfZXJyX3QKPiArZ3J1Yl9mMmZz X2Jsb2NrX3JlYWQgKHN0cnVjdCBncnViX2YyZnNfZGF0YSAqZGF0YSwgZ3J1Yl91aW50MzJfdCBi bGthZGRyLCB2b2lkICpidWYpCj4gK3sKPiArICByZXR1cm4gZ3J1Yl9kaXNrX3JlYWQgKGRhdGEt PmRpc2ssIGJsa2FkZHIgPDwgRjJGU19CTEtfU0VDX0JJVFMsCgpJIHN1c3BlY3QgY292ZXJpdHkg d2lsbCBjb21wbGFpbiBhYm91dCBvdmVyZmxvdyBoZXJlOyBjYXN0IG9mIGJsa2FkZHIKdG8gZ3J1 Yl9kaXNrX2FkZHJfdCBzaG91bGQgc2lsZW5jZSBpdC4KCj4gKwkJCQkJMCwgRjJGU19CTEtTSVpF LCBidWYpOwo+ICt9Cj4gKwouLi4KPiArCj4gK3N0YXRpYyBncnViX2Vycl90CgpOb3Qgc3VyZSBp ZiBpdCBpcyBuZWVkZWQgaGVyZTsgc2VlIGNvbW1lbnQgYmVsb3cgYXQgY2FsbGVyLgoKPiArZ3J1 Yl9mMmZzX3JlYWRfc2IgKHN0cnVjdCBncnViX2YyZnNfZGF0YSAqZGF0YSwgZ3J1Yl91aW50NjRf dCBvZmZzZXQpCj4gK3sKPiArICBncnViX2Rpc2tfdCBkaXNrID0gZGF0YS0+ZGlzazsKPiArICBn cnViX2Vycl90IGVycjsKPiArCj4gKyAgLyogUmVhZCBmaXJzdCBzdXBlciBibG9jay4gKi8KPiAr ICBlcnIgPSBncnViX2Rpc2tfcmVhZCAoZGlzaywgb2Zmc2V0ID4+IEdSVUJfRElTS19TRUNUT1Jf QklUUywgMCwKCk1ha2UgcGFyYW1ldGVyIGdydWJfZGlza19hZGRyX3QgYW5kIGNvbXB1dGUgaXQg aW4gY2FsbGVyLiBJdCBpcwpjb25zdGFudCwgdGhlcmUgaXMgbm8gbmVlZCB0byBjb21wdXRlIGl0 IGF0IHJ1biB0aW1lLgoKPiArCQkJc2l6ZW9mIChkYXRhLT5zYmxvY2spLCAmZGF0YS0+c2Jsb2Nr KTsKPiArICBpZiAoZXJyKQo+ICsgICAgcmV0dXJuIGVycjsKPiArCj4gKyAgaWYgKGdydWJfZjJm c19zYW5pdHlfY2hlY2tfc2IgKCZkYXRhLT5zYmxvY2spKQo+ICsgICAgZXJyID0gR1JVQl9FUlJf QkFEX0ZTOwo+ICsKPiArICByZXR1cm4gZXJyOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCAqCj4g K3ZhbGlkYXRlX2NoZWNrcG9pbnQgKHN0cnVjdCBncnViX2YyZnNfZGF0YSAqZGF0YSwgZ3J1Yl91 aW50MzJfdCBjcF9hZGRyLAo+ICsJCQkJCQlncnViX3VpbnQ2NF90ICp2ZXJzaW9uKQo+ICt7Cj4g KyAgdm9pZCAqY3BfcGFnZV8xLCAqY3BfcGFnZV8yOwo+ICsgIHN0cnVjdCBncnViX2YyZnNfY2hl Y2twb2ludCAqY3BfYmxvY2s7Cj4gKyAgZ3J1Yl91aW50NjRfdCBjdXJfdmVyc2lvbiA9IDAsIHBy ZV92ZXJzaW9uID0gMDsKPiArICBncnViX3VpbnQzMl90IGNyYyA9IDA7Cj4gKyAgZ3J1Yl91aW50 MzJfdCBjcmNfb2Zmc2V0Owo+ICsgIGdydWJfZXJyX3QgZXJyOwo+ICsKPiArICAvKiBSZWFkIHRo ZSAxc3QgY3AgYmxvY2sgaW4gdGhpcyBDUCBwYWNrICovCj4gKyAgY3BfcGFnZV8xID0gZ3J1Yl9t YWxsb2MgKEYyRlNfQkxLU0laRSk7Cj4gKyAgaWYgKCFjcF9wYWdlXzEpCj4gKyAgICByZXR1cm4g TlVMTDsKPiArCj4gKyAgZXJyID0gZ3J1Yl9mMmZzX2Jsb2NrX3JlYWQgKGRhdGEsIGNwX2FkZHIs IGNwX3BhZ2VfMSk7Cj4gKyAgaWYgKGVycikKPiArICAgIGdvdG8gaW52YWxpZF9jcDE7Cj4gKwo+ ICsgIGNwX2Jsb2NrID0gKHN0cnVjdCBncnViX2YyZnNfY2hlY2twb2ludCAqKWNwX3BhZ2VfMTsK PiArICBjcmNfb2Zmc2V0ID0gZ3J1Yl9sZV90b19jcHUzMiAoY3BfYmxvY2stPmNoZWNrc3VtX29m ZnNldCk7Cj4gKyAgaWYgKGNyY19vZmZzZXQgPj0gRjJGU19CTEtTSVpFKQo+ICsgICAgZ290byBp bnZhbGlkX2NwMTsKPiArCj4gKyAgY3JjID0gZ3J1Yl9sZV90b19jcHUzMiAoKihncnViX3VpbnQz Ml90ICopKChjaGFyICopY3BfYmxvY2sgKyBjcmNfb2Zmc2V0KSk7CgpJIHVuZGVyc3RhbmQgdGhh dCBpdCAvc2hvdWxkLyBiZSBoYXJkY29kZWQgdG8gNDA5MiwgYnV0IHRoZW4gcGxlYXNlCmVpdGhl ciBjaGVjayB0aGF0IGNyY19vZmZzZXQgKmlzKiA0MDkyIGJlZm9yZSBvciB1c2UKZ3J1Yl9nZXRf dW5hbGlnbmVkLiBPdGhlcndpc2UgaXQgY3Jhc2hlcyBvbiBhcmNocyB0aGF0IGRvIG5vdCBzdXBw b3J0CnVuYWxpZ25lZCBhY2Nlc3MuCgo+ICsgIGlmICghZ3J1Yl9mMmZzX2NyY192YWxpZCAoY3Jj LCBjcF9ibG9jaywgY3JjX29mZnNldCkpCj4gKyAgICBnb3RvIGludmFsaWRfY3AxOwo+ICsKPiAr ICBwcmVfdmVyc2lvbiA9IGdydWJfbGVfdG9fY3B1NjQgKGNwX2Jsb2NrLT5jaGVja3BvaW50X3Zl cik7Cj4gKwo+ICsgIC8qIFJlYWQgdGhlIDJuZCBjcCBibG9jayBpbiB0aGlzIENQIHBhY2sgKi8K PiArICBjcF9wYWdlXzIgPSBncnViX21hbGxvYyAoRjJGU19CTEtTSVpFKTsKPiArICBpZiAoIWNw X3BhZ2VfMikKPiArICAgIGdvdG8gaW52YWxpZF9jcDE7Cj4gKwo+ICsgIGNwX2FkZHIgKz0gZ3J1 Yl9sZV90b19jcHUzMiAoY3BfYmxvY2stPmNwX3BhY2tfdG90YWxfYmxvY2tfY291bnQpIC0gMTsK PiArCj4gKyAgZXJyID0gZ3J1Yl9mMmZzX2Jsb2NrX3JlYWQgKGRhdGEsIGNwX2FkZHIsIGNwX3Bh Z2VfMik7Cj4gKyAgaWYgKGVycikKPiArICAgIGdvdG8gaW52YWxpZF9jcDI7Cj4gKwo+ICsgIGNw X2Jsb2NrID0gKHN0cnVjdCBncnViX2YyZnNfY2hlY2twb2ludCAqKWNwX3BhZ2VfMjsKPiArICBj cmNfb2Zmc2V0ID0gZ3J1Yl9sZV90b19jcHUzMiAoY3BfYmxvY2stPmNoZWNrc3VtX29mZnNldCk7 Cj4gKyAgaWYgKGNyY19vZmZzZXQgPj0gRjJGU19CTEtTSVpFKQo+ICsgICAgZ290byBpbnZhbGlk X2NwMjsKPiArCj4gKyAgY3JjID0gZ3J1Yl9sZV90b19jcHUzMiAoKihncnViX3VpbnQzMl90ICop KChjaGFyICopY3BfYmxvY2sgKyBjcmNfb2Zmc2V0KSk7CgpEaXR0by4KCj4gKyAgaWYgKCFncnVi X2YyZnNfY3JjX3ZhbGlkIChjcmMsIGNwX2Jsb2NrLCBjcmNfb2Zmc2V0KSkKPiArICAgIGdvdG8g aW52YWxpZF9jcDI7Cj4gKwo+ICsgIGN1cl92ZXJzaW9uID0gZ3J1Yl9sZV90b19jcHU2NCAoY3Bf YmxvY2stPmNoZWNrcG9pbnRfdmVyKTsKPiArICBpZiAoY3VyX3ZlcnNpb24gPT0gcHJlX3ZlcnNp b24pCj4gKyAgICB7Cj4gKyAgICAgICp2ZXJzaW9uID0gY3VyX3ZlcnNpb247Cj4gKyAgICAgIGdy dWJfZnJlZSAoY3BfcGFnZV8yKTsKPiArICAgICAgcmV0dXJuIGNwX3BhZ2VfMTsKPiArICAgIH0K PiArCj4gK2ludmFsaWRfY3AyOgo+ICsgIGdydWJfZnJlZSAoY3BfcGFnZV8yKTsKPiAraW52YWxp ZF9jcDE6Cj4gKyAgZ3J1Yl9mcmVlIChjcF9wYWdlXzEpOwo+ICsgIHJldHVybiBOVUxMOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgZ3J1Yl9lcnJfdAo+ICtncnViX2YyZnNfcmVhZF9jcCAoc3RydWN0IGdy dWJfZjJmc19kYXRhICpkYXRhKQo+ICt7Cj4gKyAgdm9pZCAqY3AxLCAqY3AyLCAqY3VyX3BhZ2U7 Cj4gKyAgZ3J1Yl91aW50NjRfdCBjcDFfdmVyc2lvbiA9IDAsIGNwMl92ZXJzaW9uID0gMDsKPiAr ICBncnViX3VpbnQ2NF90IGNwX3N0YXJ0X2Jsa19ubzsKPiArCj4gKyAgLyoKPiArICAgKiBGaW5k aW5nIG91dCB2YWxpZCBjcCBibG9jayBpbnZvbHZlcyByZWFkIGJvdGgKPiArICAgKiBzZXRzIChj cCBwYWNrMSBhbmQgY3AgcGFjayAyKQo+ICsgICAqLwo+ICsgIGNwX3N0YXJ0X2Jsa19ubyA9IGRh dGEtPmNwX2Jsa2FkZHI7Cj4gKyAgY3AxID0gdmFsaWRhdGVfY2hlY2twb2ludCAoZGF0YSwgY3Bf c3RhcnRfYmxrX25vLCAmY3AxX3ZlcnNpb24pOwo+ICsgIGlmICghY3AxICYmIGdydWJfZXJybm8p Cj4gKyAgICAgIHJldHVybiBncnViX2Vycm5vOwo+ICsKPiArICAvKiBUaGUgc2Vjb25kIGNoZWNr cG9pbnQgcGFjayBzaG91bGQgc3RhcnQgYXQgdGhlIG5leHQgc2VnbWVudCAqLwo+ICsgIGNwX3N0 YXJ0X2Jsa19ubyArPSBkYXRhLT5ibG9ja3NfcGVyX3NlZzsKPiArICBjcDIgPSB2YWxpZGF0ZV9j aGVja3BvaW50IChkYXRhLCBjcF9zdGFydF9ibGtfbm8sICZjcDJfdmVyc2lvbik7Cj4gKyAgaWYg KCFjcDIgJiYgZ3J1Yl9lcnJubykKPiArICAgIHsKPiArICAgICAgZ3J1Yl9mcmVlIChjcDEpOwo+ ICsgICAgICByZXR1cm4gZ3J1Yl9lcnJubzsKPiArICAgIH0KPiArCj4gKyAgaWYgKGNwMSAmJiBj cDIpCj4gKyAgICBjdXJfcGFnZSA9IChjcDJfdmVyc2lvbiA+IGNwMV92ZXJzaW9uKSA/IGNwMiA6 IGNwMTsKPiArICBlbHNlIGlmIChjcDEpCj4gKyAgICBjdXJfcGFnZSA9IGNwMTsKPiArICBlbHNl IGlmIChjcDIpCj4gKyAgICBjdXJfcGFnZSA9IGNwMjsKPiArICBlbHNlCj4gKyAgICByZXR1cm4g Z3J1Yl9lcnJvciAoR1JVQl9FUlJfQkFEX0ZTLCAibm8gY2hlY2twb2ludHNcbiIpOwoKVHJhaWxp bmcgIlxuIiBpcyBub3QgbmVlZGVkLgoKPiArCj4gKyAgZ3J1Yl9tZW1jcHkgKCZkYXRhLT5ja3B0 LCBjdXJfcGFnZSwgRjJGU19CTEtTSVpFKTsKPiArCj4gKyAgZ3J1Yl9mcmVlIChjcDEpOwo+ICsg IGdydWJfZnJlZSAoY3AyKTsKPiArICByZXR1cm4gMDsKPiArfQo+ICsKLi4uCj4gKwo+ICtzdGF0 aWMgc3RydWN0IGdydWJfZjJmc19kYXRhICoKPiArZ3J1Yl9mMmZzX21vdW50IChncnViX2Rpc2tf dCBkaXNrKQo+ICt7Cj4gKyAgc3RydWN0IGdydWJfZjJmc19kYXRhICpkYXRhOwo+ICsgIGdydWJf ZXJyX3QgZXJyOwo+ICsKPiArICBkYXRhID0gZ3J1Yl96YWxsb2MgKHNpemVvZiAoKmRhdGEpKTsK CklzIGl0IG5lZWRlZCB0byBiZSB6YWxsb2M/IFN0cnVjdHVyZSBpcyBsYXJnZSBhbmQgaXQgcnVu cyBldmVyeSB0aW1lCmZpbGUgaXMgYWNjZXNzZWQuIE1vc3Qgb2YgaXQgaXMgaW1tZWRpYXRlbHkg b3ZlcndyaXR0ZW4sIG1heSBiZQpleHBsaWNpdGx5IGluaXRpYWxpemUgd2hhdCByZW1haW5zPwoK PiArICBpZiAoIWRhdGEpCj4gKyAgICByZXR1cm4gTlVMTDsKPiArCj4gKyAgZGF0YS0+ZGlzayA9 IGRpc2s7Cj4gKwo+ICsgIGVyciA9IGdydWJfZjJmc19yZWFkX3NiIChkYXRhLCBGMkZTX1NVUEVS X09GRlNFVCk7Cj4gKyAgaWYgKGVycikKPiArICAgIHsKPiArICAgICAgZXJyID0gZ3J1Yl9mMmZz X3JlYWRfc2IgKGRhdGEsIEYyRlNfQkxLU0laRSArIEYyRlNfU1VQRVJfT0ZGU0VUKTsKCkFzIG1l bnRpb25lZCBqdXN0IGNvbXB1dGUgZGlzayBhZGRyZXNzIGhlcmUsIGl0IGlzIHN0YXRpYy4KCj4g KyAgICAgIGlmIChlcnIpCj4gKyAgICAgICAgewo+ICsgICAgICAgICAgZ3J1Yl9lcnJvciAoR1JV Ql9FUlJfQkFEX0ZTLCAibm90IGEgRjJGUyBmaWxlc3lzdGVtIChubyBzdXBlcmJsb2NrKSIpOwo+ ICsgICAgICAgICAgZ290byBmYWlsOwo+ICsJfQo+ICsgICAgfQoKWW91IHNob3VsZCBjaGVjayBm b3IgZXJyICE9IEdSVUJfRVJSX0JBRF9GUyBoZXJlLCBvdGhlcndpc2UgZXJyb3IgZnJvbQpncnVi X2Rpc2tfcmVhZCBpcyBsb3N0LiBBbHRlcm5hdGl2ZWx5IGp1c3QgcmV0dXJuIDAvMSBmcm9tIHJl YWRfc2IsIHNvCnRoYXQKCmlmIChncnViX2YyZnNfcmVhZF9zYikKICBpZiAoZ3J1Yl9mMmZzX3Jl YWRfc2IpCiAgICBpZiAoZ3J1Yl9lcnJubyA9PSBHUlVCX0VSUl9OT05FKQogICAgICBncnViX2Vy cm9yIChHUlVCX0VSUl9CQURfRlMsIC4uLikKICAgIGdvdG8gZmFpbAoKPiArCj4gKyAgZGF0YS0+ cm9vdF9pbm8gPSBncnViX2xlX3RvX2NwdTMyIChkYXRhLT5zYmxvY2sucm9vdF9pbm8pOwo+ICsg IGRhdGEtPmNwX2Jsa2FkZHIgPSBncnViX2xlX3RvX2NwdTMyIChkYXRhLT5zYmxvY2suY3BfYmxr YWRkcik7Cj4gKyAgZGF0YS0+bmF0X2Jsa2FkZHIgPSBncnViX2xlX3RvX2NwdTMyIChkYXRhLT5z YmxvY2submF0X2Jsa2FkZHIpOwo+ICsgIGRhdGEtPmJsb2Nrc19wZXJfc2VnID0gMSA8PAo+ICsJ CWdydWJfbGVfdG9fY3B1MzIgKGRhdGEtPnNibG9jay5sb2dfYmxvY2tzX3Blcl9zZWcpOwo+ICsK PiArICBlcnIgPSBncnViX2YyZnNfcmVhZF9jcCAoZGF0YSk7Cj4gKyAgaWYgKGVycikKPiArICAg IGdvdG8gZmFpbDsKPiArCj4gKyAgZGF0YS0+bmF0X2JpdG1hcCA9IF9fbmF0X2JpdG1hcF9wdHIg KGRhdGEpOwo+ICsKPiArICBlcnIgPSBnZXRfbmF0X2pvdXJuYWwgKGRhdGEpOwo+ICsgIGlmIChl cnIpCj4gKyAgICBnb3RvIGZhaWw7Cj4gKwo+ICsgIGRhdGEtPmRpcm9wZW4uZGF0YSA9IGRhdGE7 Cj4gKyAgZGF0YS0+ZGlyb3Blbi5pbm8gPSBkYXRhLT5yb290X2lubzsKPiArICBkYXRhLT5kaXJv cGVuLmlub2RlX3JlYWQgPSAxOwo+ICsgIGRhdGEtPmlub2RlID0gJmRhdGEtPmRpcm9wZW4uaW5v ZGU7Cj4gKwo+ICsgIGVyciA9IGdydWJfZjJmc19yZWFkX25vZGUgKGRhdGEsIGRhdGEtPnJvb3Rf aW5vLCBkYXRhLT5pbm9kZSk7Cj4gKyAgaWYgKGVycikKPiArICAgIGdvdG8gZmFpbDsKPiArCj4g KyAgcmV0dXJuIGRhdGE7Cj4gKwo+ICtmYWlsOgo+ICsgIGdydWJfZnJlZSAoZGF0YSk7Cj4gKyAg cmV0dXJuIE5VTEw7Cj4gK30KPiArCi4uLgo+ICsKPiArc3RhdGljIGdydWJfc3NpemVfdAo+ICtn cnViX2YyZnNfcmVhZF9maWxlIChncnViX2ZzaGVscF9ub2RlX3Qgbm9kZSwKPiArCQkgICAgICAg Z3J1Yl9kaXNrX3JlYWRfaG9va190IHJlYWRfaG9vaywgdm9pZCAqcmVhZF9ob29rX2RhdGEsCj4g KwkJICAgICAgIGdydWJfb2ZmX3QgcG9zLCBncnViX3NpemVfdCBsZW4sIGNoYXIgKmJ1ZikKPiAr ewo+ICsgIHN0cnVjdCBncnViX2YyZnNfaW5vZGUgKmlub2RlID0gJihub2RlLT5pbm9kZS5pKTsK CldoeSBleHRyYSBwYXJlbnM/Cgo+ICsgIGdydWJfb2ZmX3QgZmlsZXNpemUgPSBncnViX2YyZnNf ZmlsZV9zaXplIChpbm9kZSk7Cj4gKyAgY2hhciAqaW5saW5lX2FkZHIgPSBfX2lubGluZV9hZGRy IChpbm9kZSk7Cj4gKwo+ICsgIGlmIChfX2lub2RlX2lubGluZV9zZXQgKCZub2RlLT5pbm9kZS5p LCBGSV9JTkxJTkVfREFUQSkpCkp1c3QgaW5vZGUsIHlvdSBhbHJlYWR5IGhhdmUgaXQuCgo+ICsg ICAgewo+ICsgICAgICBpZiAocG9zID4gZmlsZXNpemUgfHwgZmlsZXNpemUgPiBNQVhfSU5MSU5F X0RBVEEpCj4gKyAgICAgICAgewo+ICsgICAgICAgICAgZ3J1Yl9lcnJvciAoR1JVQl9FUlJfT1VU X09GX1JBTkdFLAo+ICsJCSAgTl8oImF0dGVtcHQgdG8gcmVhZCBwYXN0IHRoZSBlbmQgb2YgZmls ZSIpKTsKCklmIGZpbGVzaXplID4gTUFYX0lOTElORV9EQVRBIGF0IHRoaXMgcG9pbnQgd2UgcmVh bGx5IGRlYWwgd2l0aApjb3JydXB0ZWQgZmlsZXN5c3RlbSBzbyB0aGlzIHNob3VsZCBiZSBHUlVC X0VSUl9CQURfRlMuCgo+ICsgICAgICAgICAgcmV0dXJuIC0xOwo+ICsgICAgICAgIH0KPiArICAg ICAgaWYgKHBvcyArIGxlbiA+IGZpbGVzaXplKQoKbGVuID4gZmlsZXNpemUgLSBwb3MgaXMgcHJv YmFibHkgbW9yZSBjb3Zlcml0eS1mcmllbmRseS4KCj4gKyAgICAgICAgbGVuID0gZmlsZXNpemUg LSBwb3M7Cj4gKwo+ICsgICAgICBncnViX21lbWNweSAoYnVmICsgcG9zLCBpbmxpbmVfYWRkciAr IHBvcywgbGVuKTsKPiArICAgICAgcmV0dXJuIGxlbjsKPiArICAgIH0KPiArCj4gKyAgcmV0dXJu IGdydWJfZnNoZWxwX3JlYWRfZmlsZSAobm9kZS0+ZGF0YS0+ZGlzaywgbm9kZSwKPiArCQkJCXJl YWRfaG9vaywgcmVhZF9ob29rX2RhdGEsCj4gKwkJCQlwb3MsIGxlbiwgYnVmLCBncnViX2YyZnNf Z2V0X2Jsb2NrLAo+ICsJCQkJZmlsZXNpemUsCj4gKwkJCQlGMkZTX0JMS19TRUNfQklUUywgMCk7 Cj4gK30KPiArCi4uLgo+ICsKPiArc3RhdGljIGludAo+ICtncnViX2YyZnNfY2hlY2tfZGVudHJp ZXMgKHN0cnVjdCBncnViX2YyZnNfZGlyX2l0ZXJfY3R4ICpjdHgpCj4gK3sKPiArICBzdHJ1Y3Qg Z3J1Yl9mc2hlbHBfbm9kZSAqZmRpcm87Cj4gKyAgaW50IGk7Cj4gKwo+ICsgIGZvciAoaSA9IDA7 IGkgPCBjdHgtPm1heDspCj4gKyAgICB7Cj4gKyAgICAgIGNoYXIgKmZpbGVuYW1lOwo+ICsgICAg ICBlbnVtIGdydWJfZnNoZWxwX2ZpbGV0eXBlIHR5cGUgPSBHUlVCX0ZTSEVMUF9VTktOT1dOOwo+ ICsgICAgICBlbnVtIEZJTEVfVFlQRSBmdHlwZTsKPiArICAgICAgaW50IG5hbWVfbGVuOwo+ICsg ICAgICBpbnQgcmV0Owo+ICsKPiArICAgICAgaWYgKGdydWJfZ2VuZXJpY190ZXN0X2JpdCAoaSwg Y3R4LT5iaXRtYXApID09IDApCj4gKyAgICAgICAgewo+ICsgICAgICAgICAgaSsrOwo+ICsgICAg ICAgICAgY29udGludWU7Cj4gKyAgICAgICAgfQo+ICsKPiArICAgICAgZnR5cGUgPSBjdHgtPmRl bnRyeVtpXS5maWxlX3R5cGU7Cj4gKyAgICAgIG5hbWVfbGVuID0gZ3J1Yl9sZV90b19jcHUxNiAo Y3R4LT5kZW50cnlbaV0ubmFtZV9sZW4pOwo+ICsgICAgICBmaWxlbmFtZSA9IGdydWJfemFsbG9j IChuYW1lX2xlbiArIDEpOwpJdCBpcyBvdmVyd3JpdHRlbiBvbiBuZXh0IGxpbmUsIGRvIHlvdSBy ZWFsbHkgbmVlZCBncnViX3phbGxvYyBvbmx5IGZvcgp0aGUgdHJhaWxpbmcgemVybz8KCj4gKyAg ICAgIGlmICghZmlsZW5hbWUpCj4gKyAgICAgICAgcmV0dXJuIDA7Cj4gKwo+ICsgICAgICBncnVi X21lbWNweSAoZmlsZW5hbWUsIGN0eC0+ZmlsZW5hbWVbaV0sIG5hbWVfbGVuKTsKPiArCj4gKyAg ICAgIGZkaXJvID0gZ3J1Yl9tYWxsb2MgKHNpemVvZiAoc3RydWN0IGdydWJfZnNoZWxwX25vZGUp KTsKPiArICAgICAgaWYgKCFmZGlybykKPiArICAgICAgICB7Cj4gKyAgICAgICAgICBncnViX2Zy ZWUoZmlsZW5hbWUpOwo+ICsgICAgICAgICAgcmV0dXJuIDA7Cj4gKyAgICAgICAgfQo+ICsKPiAr ICAgICAgaWYgKGZ0eXBlID09IEYyRlNfRlRfRElSKQo+ICsgICAgICAgIHR5cGUgPSBHUlVCX0ZT SEVMUF9ESVI7Cj4gKyAgICAgIGVsc2UgaWYgKGZ0eXBlID09IEYyRlNfRlRfU1lNTElOSykKPiAr ICAgICAgICB0eXBlID0gR1JVQl9GU0hFTFBfU1lNTElOSzsKPiArICAgICAgZWxzZSBpZiAoZnR5 cGUgPT0gRjJGU19GVF9SRUdfRklMRSkKPiArICAgICAgICB0eXBlID0gR1JVQl9GU0hFTFBfUkVH Owo+ICsKPiArICAgICAgZmRpcm8tPmRhdGEgPSBjdHgtPmRhdGE7Cj4gKyAgICAgIGZkaXJvLT5p bm8gPSBncnViX2xlX3RvX2NwdTMyIChjdHgtPmRlbnRyeVtpXS5pbm8pOwo+ICsgICAgICBmZGly by0+aW5vZGVfcmVhZCA9IDA7Cj4gKwo+ICsgICAgICByZXQgPSBjdHgtPmhvb2sgKGZpbGVuYW1l LCB0eXBlLCBmZGlybywgY3R4LT5ob29rX2RhdGEpOwo+ICsgICAgICBncnViX2ZyZWUoZmlsZW5h bWUpOwo+ICsgICAgICBpZiAocmV0KQo+ICsgICAgICAgIHJldHVybiAxOwo+ICsKPiArICAgICAg aSArPSAobmFtZV9sZW4gKyBGMkZTX1NMT1RfTEVOIC0gMSkgLyBGMkZTX1NMT1RfTEVOOwo+ICsg ICAgfQo+ICsgICAgcmV0dXJuIDA7Cj4gK30KPiArCi4uLgo+ICsKPiArc3RhdGljIHZvaWQKPiAr Z3J1Yl9mMmZzX3VuaWNvZGVfdG9fYXNjaWkgKGdydWJfdWludDhfdCAqb3V0X2J1ZiwgZ3J1Yl91 aW50MTZfdCAqaW5fYnVmKQo+ICt7Cj4gKyAgZ3J1Yl91aW50MTZfdCAqcGNoVGVtcFB0ciA9IGlu X2J1ZjsKPiArICBncnViX3VpbnQ4X3QgKnB3VGVtcFB0ciA9IG91dF9idWY7Cj4gKwo+ICsgIHdo aWxlICgqcGNoVGVtcFB0ciAhPSAnXDAnKQo+ICsgIHsKPiArICAgICpwd1RlbXBQdHIgPSAoZ3J1 Yl91aW50OF90KSAqcGNoVGVtcFB0cjsKClRoaXMgaXMgbm90IGJ5dGUgb3JkZXIgc2FmZSBhbmQg aXQgZG9lcyBub3QgY29udmVydCB0byBBU0NJSSBhcyBuYW1lCnN1Z2dlc3RzLiBJZiB5b3UgYXJl IGdvaW5nIHRvIGNvbnZlcnQgdG8gOCBiaXQgZW5jb2Rpbmcgd2h5IG5vdCBzaW1wbHkKdXNlIGdy dWJfdXRmMTZfdG9fdXRmOD8KCj4gKyAgICBwY2hUZW1wUHRyKys7Cj4gKyAgICBwd1RlbXBQdHIr KzsKPiArICB9Cj4gKyAgKnB3VGVtcFB0ciA9ICdcMCc7Cj4gKyAgcmV0dXJuOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgZ3J1Yl9lcnJfdAo+ICtncnViX2YyZnNfbGFiZWwgKGdydWJfZGV2aWNlX3QgZGV2 aWNlLCBjaGFyICoqbGFiZWwpCj4gK3sKPiArICBzdHJ1Y3QgZ3J1Yl9mMmZzX2RhdGEgKmRhdGE7 Cj4gKyAgZ3J1Yl9kaXNrX3QgZGlzayA9IGRldmljZS0+ZGlzazsKPiArCj4gKyAgZ3J1Yl9kbF9y ZWYgKG15X21vZCk7Cj4gKwo+ICsgIGRhdGEgPSBncnViX2YyZnNfbW91bnQgKGRpc2spOwo+ICsg IGlmIChkYXRhKQo+ICsgICAgewo+ICsgICAgICAqbGFiZWwgPSBncnViX3phbGxvYyAoc2l6ZW9m IChkYXRhLT5zYmxvY2sudm9sdW1lX25hbWUpKTsKPiArICAgICAgaWYgKCpsYWJlbCkKPiArICAg ICAgICBncnViX2YyZnNfdW5pY29kZV90b19hc2NpaSAoKGdydWJfdWludDhfdCAqKSAoKmxhYmVs KSwKPiArCQkJCWRhdGEtPnNibG9jay52b2x1bWVfbmFtZSk7CgpTZWUgYWJvdmUuCgo+ICsgICAg fQo+ICsgIGVsc2UKPiArICAgICpsYWJlbCA9IE5VTEw7Cj4gKwo+ICsgIGdydWJfZnJlZSAoZGF0 YSk7Cj4gKyAgZ3J1Yl9kbF91bnJlZiAobXlfbW9kKTsKPiArICByZXR1cm4gZ3J1Yl9lcnJubzsK PiArfQo+ICsKLi4uCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KR3J1Yi1kZXZlbCBtYWlsaW5nIGxpc3QKR3J1Yi1kZXZlbEBnbnUub3JnCmh0dHBzOi8v bGlzdHMuZ251Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2dydWItZGV2ZWwK