From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id DEF703858CDB for ; Sun, 2 Apr 2023 01:06:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org DEF703858CDB Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680397589; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=KXjBKReMe4h2pqOLdTtF6Gl/uabgcNKI7sijaGKPeRs=; b=ba/s2ZqCC5SRXZV7CepPlEYeeRYdVSTOAE9bdcztluWTxP43wmWKNwxQEfrKY4QHTfO4xJ Iri410ZXNAXA/9uwfOtZ4/dN5pWk3rxc4kV8fZ2DKrkq6q9Vzlt7rVo5pO9dZDigr5PF1G B/y6FjWCLOlxxCB+2T1TvwN+CJKFc6U= Received: from mail-lf1-f71.google.com (mail-lf1-f71.google.com [209.85.167.71]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-477-k8swRGYxM6Kz0nNoyI3dXQ-1; Sat, 01 Apr 2023 21:06:27 -0400 X-MC-Unique: k8swRGYxM6Kz0nNoyI3dXQ-1 Received: by mail-lf1-f71.google.com with SMTP id k15-20020a192d0f000000b004eae6a74985so10110073lfj.11 for ; Sat, 01 Apr 2023 18:06:27 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680397585; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=NBxMhSC1E199riz7Y4V/U8fwA8YS/KxHQdiMxQtpAuE=; b=CX+SZ9wef5kTRiPxYjXtaHju8gBGwfWTSDTL6imw2KGfUZncKIlDNRz4+02U/XB4ls xVkX8e+ew9gBQLQvZ+0q8LG4te6TsMfH9VfbBWBly6nq5qH7Ee5/WRWUIBcKKBhYxFaB N5/dnvPN53K9ecj2OPMibev/ssDTEFA4rEGwcZW4s/jZniVD1x48IoRE+L3AAQAHfw9T ZSxDKmF6FrnpT/iQgGhZjTzdL3qc2jfz8zqep2q6Q3P+VCE+BKiTgdjtlscETdPBCFcn VtGPgqgmJkrR9RCa88+61MDOdm66plB4v865WJhRherwi55rsfu81mPl4k46CzSBBCkA ISOw== X-Gm-Message-State: AAQBX9cMT2pS99PVSpv303s2Ycli63gT+xo7z7cNnTth7f7FocN0tZht DxVWcGCTo9BXHsf8X+6xCqyocx74lS2PNISZFP2w1yvuY8KrEpY8cc9BvvICtoqTsyFeeRt5cwh 3tu7kvz0g8HMRQ4GAC16K9c0ip2+xzfu/38rkUnsWnkRd8d4oz6JY X-Received: by 2002:ac2:5182:0:b0:4d5:ca32:6aec with SMTP id u2-20020ac25182000000b004d5ca326aecmr9346697lfi.12.1680397585227; Sat, 01 Apr 2023 18:06:25 -0700 (PDT) X-Google-Smtp-Source: AKy350bdjabKxSvR8jRtk34jf1Oz5ARRPeOdBTXZ9+zdYNUzfzcdxPWYL8WiWiyX42/5Ftl5BvDiO/mqYmnOJb1Q/Wk= X-Received: by 2002:ac2:5182:0:b0:4d5:ca32:6aec with SMTP id u2-20020ac25182000000b004d5ca326aecmr9346691lfi.12.1680397584710; Sat, 01 Apr 2023 18:06:24 -0700 (PDT) MIME-Version: 1.0 References: <634598e6cf48b8d5a864f43ede8ec8731fc5cf51.camel@klomp.org> In-Reply-To: <634598e6cf48b8d5a864f43ede8ec8731fc5cf51.camel@klomp.org> From: Di Chen Date: Sun, 2 Apr 2023 09:06:11 +0800 Message-ID: Subject: Re: [PATCH] PR28873 - Implement eu-readelf -D To: Mark Wielaard Cc: elfutils-devel@sourceware.org X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="0000000000001ec2c205f8500d1d" X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,HTML_MESSAGE,KAM_LOTSOFHASH,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_NONE,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: --0000000000001ec2c205f8500d1d Content-Type: multipart/alternative; boundary="0000000000001ec2c005f8500d1b" --0000000000001ec2c005f8500d1b Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Thank you Mark. I made the following changes: * ChangeLog&NEWS update. * syments initialization to 0. * new function format update to GNU style. * extract the shared part to a new function, reduce code redundancy. The patch is ready for review again. =46rom 70ac6993744985b29935df6010e36bf9dbbd96d9 Mon Sep 17 00:00:00 2001 From: Di Chen Date: Mon, 27 Mar 2023 10:01:05 +0800 Subject: [PATCH] readelf: display dynamic symtab without section headers This commit adds a new option "-D/--use-dynamic" to support printing the dynamic symbol table from the PT_DYNAMIC segment. By using the PT_DYNAMIC segment, eu-readelf can go through the contents of dynamic section entries and the values of each tag. From that, we can get the address and size of the dynamic symbol table, the address of the string table, etc. By using the new option "-D/--use-dynamic", eu-readelf can list the symbols without section headers. Example: $ ./src/readelf -Ds a.out 0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UNDEF 1: 0000000000000000 0 FUNC GLOBAL DEFAULT UNDEF __libc_start_main@GLIBC_2.34 (2) 2: 0000000000000000 0 NOTYPE WEAK DEFAULT UNDEF __gmon_start__ https://sourceware.org/bugzilla/show_bug.cgi?id=3D28873 Signed-off-by: Di Chen --- ChangeLog | 5 + NEWS | 2 + src/ChangeLog | 6 + src/readelf.c | 531 ++++++++++++++++++++++++++++++++++++-------------- 4 files changed, 393 insertions(+), 151 deletions(-) diff --git a/ChangeLog b/ChangeLog index 10c23002..ece07e97 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2023-03-27 Di Chen + + * NEWS: Support readelf -Ds for using dynamic segment to + print symbol table. + 2023-03-03 Mark Wielaard * NEWS: Add ELFCOMPRESS_ZSTD support for libelf and elfcompress. diff --git a/NEWS b/NEWS index 16e37eca..679d8bd5 100644 --- a/NEWS +++ b/NEWS @@ -17,6 +17,8 @@ elfcompress: -t, --type=3D now support zstd if libelf has been build with backends: Add support for LoongArch and Synopsys ARCv2 processors. +readelf: Support readelf -Ds, --use-dynamic --symbol. + Version 0.188 "no section left behind" readelf: Add -D, --use-dynamic option. diff --git a/src/ChangeLog b/src/ChangeLog index c26dafdd..8aa269cd 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,9 @@ +2023-03-27 Di Chen + + * readelf.c (options): Support dynamic symtab print with '-Ds'. + (process_symtab): New function. + (handle_dynamic_symtab): Likewise. + 2023-03-03 Mark Wielaard * readelf (process_elf_file): ebl_closebackend only after diff --git a/src/readelf.c b/src/readelf.c index 6950204e..70848c21 100644 --- a/src/readelf.c +++ b/src/readelf.c @@ -307,7 +307,21 @@ static void handle_relocs_rel (Ebl *ebl, GElf_Ehdr *ehdr, Elf_Scn *scn, static void handle_relocs_rela (Ebl *ebl, GElf_Ehdr *ehdr, Elf_Scn *scn, GElf_Shdr *shdr); static bool print_symtab (Ebl *ebl, int type); -static void handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr); +static bool handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr); +static bool handle_dynamic_symtab (Ebl *ebl); +static void +process_symtab( + Ebl * ebl, + unsigned int nsyms, + Elf64_Word idx, + Elf32_Word verneed_stridx, + Elf32_Word verdef_stridx, + Elf_Data * symdata, + Elf_Data * versym_data, + Elf_Data * symstr_data, + Elf_Data * verneed_data, + Elf_Data * verdef_data, + Elf_Data * xndx_data); static void print_verinfo (Ebl *ebl); static void handle_verneed (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr); static void handle_verdef (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr); @@ -325,9 +339,12 @@ static void dump_archive_index (Elf *, const char *); enum dyn_idx { + i_symtab_shndx, i_strsz, i_verneed, + i_verneednum, i_verdef, + i_verdefnum, i_versym, i_symtab, i_strtab, @@ -1042,7 +1059,7 @@ process_elf_file (Dwfl_Module *dwflmod, int fd) symtab_printed |=3D print_symtab (ebl, SHT_DYNSYM); if (print_version_info) print_verinfo (ebl); - if (print_symbol_table) + if (print_symbol_table && !use_dynamic_segment) symtab_printed |=3D print_symtab (ebl, SHT_SYMTAB); if ((print_symbol_table || print_dynsym_table) @@ -2443,6 +2460,12 @@ handle_relocs_rela (Ebl *ebl, GElf_Ehdr *ehdr, Elf_Scn *scn, GElf_Shdr *shdr) static bool print_symtab (Ebl *ebl, int type) { + /* Use the dynamic section info to display symbol tables. */ + if (use_dynamic_segment && type =3D=3D SHT_DYNSYM) + { + return handle_dynamic_symtab(ebl); + } + /* Find the symbol table(s). For this we have to search through the section table. */ Elf_Scn *scn =3D NULL; @@ -2481,8 +2504,7 @@ print_symtab (Ebl *ebl, int type) _("cannot get section [%zd] header: %s"), elf_ndxscn (scn), elf_errmsg (-1)); } - handle_symtab (ebl, scn, shdr); - symtab_printed =3D true; + symtab_printed =3D handle_symtab (ebl, scn, shdr); } } @@ -2491,6 +2513,179 @@ print_symtab (Ebl *ebl, int type) static void +process_symtab (Ebl *ebl, unsigned int nsyms, Elf64_Word idx, + Elf32_Word verneed_stridx, Elf32_Word verdef_stridx, + Elf_Data *symdata, Elf_Data *versym_data, + Elf_Data *symstr_data, Elf_Data *verneed_data, + Elf_Data *verdef_data, Elf_Data *xndx_data) +{ + for (unsigned int cnt =3D 0; cnt < nsyms; ++cnt) + { + char typebuf[64]; + char bindbuf[64]; + char scnbuf[64]; + Elf32_Word xndx; + GElf_Sym sym_mem; + GElf_Sym *sym + =3D gelf_getsymshndx (symdata, xndx_data, cnt, &sym_mem, &xndx); + + if (unlikely (sym =3D=3D NULL)) + continue; + + /* Determine the real section index. */ + if (likely (sym->st_shndx !=3D SHN_XINDEX)) + xndx =3D sym->st_shndx; + + printf (_ ("\ +%5u: %0*" PRIx64 " %6" PRId64 " %-7s %-6s %-9s %6s %s"), + cnt, gelf_getclass (ebl->elf) =3D=3D ELFCLASS32 ? 8 : 16, + sym->st_value, sym->st_size, + ebl_symbol_type_name (ebl, GELF_ST_TYPE (sym->st_info), typebuf, + sizeof (typebuf)), + ebl_symbol_binding_name (ebl, GELF_ST_BIND (sym->st_info), + bindbuf, sizeof (bindbuf)), + get_visibility_type (GELF_ST_VISIBILITY (sym->st_other)), + ebl_section_name (ebl, sym->st_shndx, xndx, scnbuf, + sizeof (scnbuf), NULL, shnum), + use_dynamic_segment =3D=3D true + ? (char *)symstr_data->d_buf + sym->st_name + : elf_strptr (ebl->elf, idx, sym->st_name)); + + if (versym_data !=3D NULL) + { + /* Get the version information. */ + GElf_Versym versym_mem; + GElf_Versym *versym =3D gelf_getversym (versym_data, cnt, &versym_mem); + + if (versym !=3D NULL && ((*versym & 0x8000) !=3D 0 || *versym > = 1)) + { + bool is_nobits =3D false; + bool check_def =3D xndx !=3D SHN_UNDEF; + + if (xndx < SHN_LORESERVE || sym->st_shndx =3D=3D SHN_XINDEX) + { + GElf_Shdr symshdr_mem; + GElf_Shdr *symshdr =3D gelf_getshdr ( + elf_getscn (ebl->elf, xndx), &symshdr_mem); + + is_nobits + =3D (symshdr !=3D NULL && symshdr->sh_type =3D=3D SHT_NOBITS); + } + + if (is_nobits || !check_def) + { + /* We must test both. */ + GElf_Vernaux vernaux_mem; + GElf_Vernaux *vernaux =3D NULL; + size_t vn_offset =3D 0; + + GElf_Verneed verneed_mem; + GElf_Verneed *verneed + =3D gelf_getverneed (verneed_data, 0, &verneed_mem); + while (verneed !=3D NULL) + { + size_t vna_offset =3D vn_offset; + + vernaux =3D gelf_getvernaux (verneed_data, + vna_offset +=3D verneed->vn_aux, + &vernaux_mem); + while (vernaux !=3D NULL && vernaux->vna_other !=3D *versym + && vernaux->vna_next !=3D 0 + && (verneed_data->d_size - vna_offset + >=3D vernaux->vna_next)) + { + /* Update the offset. */ + vna_offset +=3D vernaux->vna_next; + + vernaux =3D (vernaux->vna_next =3D=3D 0 + ? NULL + : gelf_getvernaux (verneed_data, + vna_offset, + &vernaux_mem)); + } + + /* Check whether we found the version. */ + if (vernaux !=3D NULL && vernaux->vna_other =3D=3D *= versym) + /* Found it. */ + break; + + if (verneed_data->d_size - vn_offset < verneed->vn_next) + break; + + vn_offset +=3D verneed->vn_next; + verneed + =3D (verneed->vn_next =3D=3D 0 + ? NULL + : gelf_getverneed (verneed_data, vn_offset, + &verneed_mem)); + } + + if (vernaux !=3D NULL && vernaux->vna_other =3D=3D *vers= ym) + { + printf ("@%s (%u)", + use_dynamic_segment =3D=3D true + ? (char *)symstr_data->d_buf + + vernaux->vna_name + : elf_strptr (ebl->elf, verneed_stridx, + vernaux->vna_name), + (unsigned int)vernaux->vna_other); + check_def =3D 0; + } + else if (unlikely (!is_nobits)) + error (0, 0, _ ("bad dynamic symbol")); + else + check_def =3D 1; + } + + if (check_def && *versym !=3D 0x8001) + { + /* We must test both. */ + size_t vd_offset =3D 0; + + GElf_Verdef verdef_mem; + GElf_Verdef *verdef + =3D gelf_getverdef (verdef_data, 0, &verdef_mem); + while (verdef !=3D NULL) + { + if (verdef->vd_ndx =3D=3D (*versym & 0x7fff)) + /* Found the definition. */ + break; + + if (verdef_data->d_size - vd_offset < verdef->vd_next) + break; + + vd_offset +=3D verdef->vd_next; + verdef =3D (verdef->vd_next =3D=3D 0 + ? NULL + : gelf_getverdef (verdef_data, vd_offset, + &verdef_mem)); + } + + if (verdef !=3D NULL) + { + GElf_Verdaux verdaux_mem; + GElf_Verdaux *verdaux =3D gelf_getverdaux ( + verdef_data, vd_offset + verdef->vd_aux, + &verdaux_mem); + + if (verdaux !=3D NULL) + printf ((*versym & 0x8000) ? "@%s" : "@@%s", + use_dynamic_segment =3D=3D true + ? (char *)symstr_data->d_buf + + verdaux->vda_name + : elf_strptr (ebl->elf, verdef_stridx, + verdaux->vda_name)); + } + } + } + } + + putchar_unlocked ('\n'); + } +} + + +static bool handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr) { Elf_Data *versym_data =3D NULL; @@ -2504,7 +2699,7 @@ handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr) /* Get the data of the section. */ Elf_Data *data =3D elf_getdata (scn, NULL); if (data =3D=3D NULL) - return; + return false; /* Find out whether we have other sections we might need. */ Elf_Scn *runscn =3D NULL; @@ -2574,163 +2769,186 @@ handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr) Num: Value Size Type Bind Vis Ndx Name\n"), stdout); - for (unsigned int cnt =3D 0; cnt < nsyms; ++cnt) - { - char typebuf[64]; - char bindbuf[64]; - char scnbuf[64]; - Elf32_Word xndx; - GElf_Sym sym_mem; - GElf_Sym *sym =3D gelf_getsymshndx (data, xndx_data, cnt, &sym_mem, &xndx); - - if (unlikely (sym =3D=3D NULL)) - continue; - - /* Determine the real section index. */ - if (likely (sym->st_shndx !=3D SHN_XINDEX)) - xndx =3D sym->st_shndx; - - printf (_("\ -%5u: %0*" PRIx64 " %6" PRId64 " %-7s %-6s %-9s %6s %s"), - cnt, - class =3D=3D ELFCLASS32 ? 8 : 16, - sym->st_value, - sym->st_size, - ebl_symbol_type_name (ebl, GELF_ST_TYPE (sym->st_info), - typebuf, sizeof (typebuf)), - ebl_symbol_binding_name (ebl, GELF_ST_BIND (sym->st_info), - bindbuf, sizeof (bindbuf)), - get_visibility_type (GELF_ST_VISIBILITY (sym->st_other)), - ebl_section_name (ebl, sym->st_shndx, xndx, scnbuf, - sizeof (scnbuf), NULL, shnum), - elf_strptr (ebl->elf, shdr->sh_link, sym->st_name)); - - if (versym_data !=3D NULL) - { - /* Get the version information. */ - GElf_Versym versym_mem; - GElf_Versym *versym =3D gelf_getversym (versym_data, cnt, &versym_mem); - - if (versym !=3D NULL && ((*versym & 0x8000) !=3D 0 || *versym > 1)) - { - bool is_nobits =3D false; - bool check_def =3D xndx !=3D SHN_UNDEF; - - if (xndx < SHN_LORESERVE || sym->st_shndx =3D=3D SHN_XINDEX) - { - GElf_Shdr symshdr_mem; - GElf_Shdr *symshdr =3D - gelf_getshdr (elf_getscn (ebl->elf, xndx), &symshdr_mem); - - is_nobits =3D (symshdr !=3D NULL - && symshdr->sh_type =3D=3D SHT_NOBITS); - } + process_symtab(ebl, nsyms, shdr->sh_link, verneed_stridx, verdef_stridx, + data, versym_data, NULL, verneed_data, verdef_data, xndx_data); + return true; +} - if (is_nobits || ! check_def) - { - /* We must test both. */ - GElf_Vernaux vernaux_mem; - GElf_Vernaux *vernaux =3D NULL; - size_t vn_offset =3D 0; - - GElf_Verneed verneed_mem; - GElf_Verneed *verneed =3D gelf_getverneed (verneed_data, 0, - &verneed_mem); - while (verneed !=3D NULL) - { - size_t vna_offset =3D vn_offset; - - vernaux =3D gelf_getvernaux (verneed_data, - vna_offset +=3D verneed->vn_aux, - &vernaux_mem); - while (vernaux !=3D NULL - && vernaux->vna_other !=3D *versym - && vernaux->vna_next !=3D 0 - && (verneed_data->d_size - vna_offset - >=3D vernaux->vna_next)) - { - /* Update the offset. */ - vna_offset +=3D vernaux->vna_next; - - vernaux =3D (vernaux->vna_next =3D=3D 0 - ? NULL - : gelf_getvernaux (verneed_data, - vna_offset, - &vernaux_mem)); - } - /* Check whether we found the version. */ - if (vernaux !=3D NULL && vernaux->vna_other =3D=3D *versym) - /* Found it. */ - break; +static bool +handle_dynamic_symtab (Ebl *ebl) +{ + GElf_Phdr *phdr =3D NULL; + /* phnum is a static variable which already fetched in function + * process_elf_file. */ + for (size_t i =3D 0; i < phnum; ++i) + { + GElf_Phdr phdr_mem; + phdr =3D gelf_getphdr (ebl->elf, i, &phdr_mem); + if (phdr->p_type =3D=3D PT_DYNAMIC) + { + break; + } + } + if (phdr =3D=3D NULL) + return false; - if (verneed_data->d_size - vn_offset < verneed->vn_next) - break; + GElf_Addr addrs[i_max] =3D { + 0, + }; + GElf_Off offs[i_max] =3D { + 0, + }; + get_dynscn_addrs (ebl->elf, phdr, addrs); + find_offsets (ebl->elf, 0, i_max, addrs, offs); - vn_offset +=3D verneed->vn_next; - verneed =3D (verneed->vn_next =3D=3D 0 - ? NULL - : gelf_getverneed (verneed_data, vn_offset, - &verneed_mem)); - } + size_t syments =3D 0; - if (vernaux !=3D NULL && vernaux->vna_other =3D=3D *versym) - { - printf ("@%s (%u)", - elf_strptr (ebl->elf, verneed_stridx, - vernaux->vna_name), - (unsigned int) vernaux->vna_other); - check_def =3D 0; - } - else if (unlikely (! is_nobits)) - error (0, 0, _("bad dynamic symbol")); - else - check_def =3D 1; - } + GElf_Ehdr ehdr_mem; + GElf_Ehdr *ehdr =3D gelf_getehdr (ebl->elf, &ehdr_mem); - if (check_def && *versym !=3D 0x8001) - { - /* We must test both. */ - size_t vd_offset =3D 0; + if (offs[i_hash] !=3D 0) + { + /* In the original format, .hash says the size of .dynsym. */ - GElf_Verdef verdef_mem; - GElf_Verdef *verdef =3D gelf_getverdef (verdef_data, 0, - &verdef_mem); - while (verdef !=3D NULL) - { - if (verdef->vd_ndx =3D=3D (*versym & 0x7fff)) - /* Found the definition. */ - break; + size_t entsz =3D SH_ENTSIZE_HASH (ehdr); + Elf_Data *data + =3D elf_getdata_rawchunk (ebl->elf, offs[i_hash] + entsz, entsz, + (entsz =3D=3D 4 ? ELF_T_WORD : ELF_T_XWO= RD)); + if (data !=3D NULL) + syments =3D (entsz =3D=3D 4 ? *(const GElf_Word *)data->d_buf + : *(const GElf_Xword *)data->d_buf); + } + if (offs[i_gnu_hash] !=3D 0 && syments =3D=3D 0) + { + /* In the new format, we can derive it with some work. */ - if (verdef_data->d_size - vd_offset < verdef->vd_next) - break; + const struct + { + Elf32_Word nbuckets; + Elf32_Word symndx; + Elf32_Word maskwords; + Elf32_Word shift2; + } * header; + + Elf_Data *data =3D elf_getdata_rawchunk (ebl->elf, offs[i_gnu_hash], + sizeof *header, ELF_T_WORD); + if (data !=3D NULL) + { + header =3D data->d_buf; + Elf32_Word nbuckets =3D header->nbuckets; + Elf32_Word symndx =3D header->symndx; + GElf_Off buckets_at + =3D (offs[i_gnu_hash] + sizeof *header + + (gelf_getclass (ebl->elf) * sizeof (Elf32_Word) + * header->maskwords)); + + // elf_getdata_rawchunk takes a size_t, make sure it + // doesn't overflow. +#if SIZE_MAX <=3D UINT32_MAX + if (nbuckets > SIZE_MAX / sizeof (Elf32_Word)) + data =3D NULL; + else +#endif + data =3D elf_getdata_rawchunk (ebl->elf, buckets_at, + nbuckets * sizeof (Elf32_Word), + ELF_T_WORD); + if (data !=3D NULL && symndx < nbuckets) + { + const Elf32_Word *const buckets =3D data->d_buf; + Elf32_Word maxndx =3D symndx; + for (Elf32_Word bucket =3D 0; bucket < nbuckets; ++bucket) + if (buckets[bucket] > maxndx) + maxndx =3D buckets[bucket]; + + GElf_Off hasharr_at + =3D (buckets_at + nbuckets * sizeof (Elf32_Word)); + hasharr_at +=3D (maxndx - symndx) * sizeof (Elf32_Word); + do + { + data =3D elf_getdata_rawchunk ( + ebl->elf, hasharr_at, sizeof (Elf32_Word), ELF_T_WORD); + if (data !=3D NULL && (*(const Elf32_Word *)data->d_buf & 1u)) + { + syments =3D maxndx + 1; + break; + } + ++maxndx; + hasharr_at +=3D sizeof (Elf32_Word); + } + while (data !=3D NULL); + } + } + } + if (offs[i_strtab] > offs[i_symtab] && syments =3D=3D 0) + syments =3D ((offs[i_strtab] - offs[i_symtab]) + / gelf_fsize (ebl->elf, ELF_T_SYM, 1, EV_CURRENT)); - vd_offset +=3D verdef->vd_next; - verdef =3D (verdef->vd_next =3D=3D 0 - ? NULL - : gelf_getverdef (verdef_data, vd_offset, - &verdef_mem)); - } + if (syments <=3D 0 || offs[i_strtab] =3D=3D 0 || offs[i_symtab] =3D=3D 0) + { + error_exit (0, _ ("Dynamic symbol information is not available for " + "displaying symbols.")); + } - if (verdef !=3D NULL) - { - GElf_Verdaux verdaux_mem; - GElf_Verdaux *verdaux - =3D gelf_getverdaux (verdef_data, - vd_offset + verdef->vd_aux, - &verdaux_mem); - - if (verdaux !=3D NULL) - printf ((*versym & 0x8000) ? "@%s" : "@@%s", - elf_strptr (ebl->elf, verdef_stridx, - verdaux->vda_name)); - } - } - } - } + /* All the data chunk initializaion. */ + Elf_Data *symdata =3D NULL; + Elf_Data *symstrdata =3D NULL; + Elf_Data *versym_data =3D NULL; + Elf_Data *verdef_data =3D NULL; + Elf_Data *verneed_data =3D NULL; - putchar_unlocked ('\n'); - } + symdata =3D elf_getdata_rawchunk ( + ebl->elf, offs[i_symtab], + gelf_fsize (ebl->elf, ELF_T_SYM, syments, EV_CURRENT), ELF_T_SYM); + symstrdata =3D elf_getdata_rawchunk (ebl->elf, offs[i_strtab], addrs[i_strsz], + ELF_T_BYTE); + versym_data =3D elf_getdata_rawchunk ( + ebl->elf, offs[i_versym], syments * sizeof (Elf64_Half), ELF_T_HALF); + + /* Get the verneed_data without vernaux. */ + verneed_data =3D elf_getdata_rawchunk ( + ebl->elf, offs[i_verneed], addrs[i_verneednum] * sizeof (Elf64_Verneed), + ELF_T_VNEED); + size_t vernauxnum =3D 0; + size_t vn_next_offset =3D 0; + + for (size_t i =3D 0; i < addrs[i_verneednum]; i++) + { + GElf_Verneed *verneed + =3D (GElf_Verneed *)(verneed_data->d_buf + vn_next_offset); + vernauxnum +=3D verneed->vn_cnt; + vn_next_offset +=3D verneed->vn_next; + } + + /* Update the verneed_data to include the vernaux. */ + verneed_data =3D elf_getdata_rawchunk ( + ebl->elf, offs[i_verneed], + (addrs[i_verneednum] + vernauxnum) * sizeof (GElf_Verneed), ELF_T_VNEED); + + /* Get the verdef_data without verdaux. */ + verdef_data =3D elf_getdata_rawchunk ( + ebl->elf, offs[i_verdef], addrs[i_verdefnum] * sizeof (Elf64_Verdef), + ELF_T_VDEF); + size_t verdauxnum =3D 0; + size_t vd_next_offset =3D 0; + + for (size_t i =3D 0; i < addrs[i_verdefnum]; i++) + { + GElf_Verdef *verdef + =3D (GElf_Verdef *)(verdef_data->d_buf + vd_next_offset); + verdauxnum +=3D verdef->vd_cnt; + vd_next_offset +=3D verdef->vd_next; + } + + /* Update the verdef_data to include the verdaux. */ + verdef_data =3D elf_getdata_rawchunk ( + ebl->elf, offs[i_verdef], + (addrs[i_verdefnum] + verdauxnum) * sizeof (GElf_Verdef), ELF_T_VDEF); + + unsigned int nsyms =3D (unsigned int)syments; + process_symtab (ebl, nsyms, 0, 0, 0, symdata, versym_data, symstrdata, + verneed_data, verdef_data, NULL); + return true; } @@ -4990,13 +5208,24 @@ get_dynscn_addrs(Elf *elf, GElf_Phdr *phdr, GElf_Addr addrs[i_max]) addrs[i_verdef] =3D dyn->d_un.d_ptr; break; + case DT_VERDEFNUM: + addrs[i_verdefnum] =3D dyn->d_un.d_val; + break; + case DT_VERNEED: addrs[i_verneed] =3D dyn->d_un.d_ptr; break; + case DT_VERNEEDNUM: + addrs[i_verneednum] =3D dyn->d_un.d_val; + break; + case DT_STRSZ: addrs[i_strsz] =3D dyn->d_un.d_val; break; + case DT_SYMTAB_SHNDX: + addrs[i_symtab_shndx] =3D dyn->d_un.d_ptr; + break; } } } --=20 2.39.2 On Fri, Feb 17, 2023 at 12:12=E2=80=AFAM Mark Wielaard wro= te: > Hi, > > On Sat, 2023-02-11 at 00:17 +0800, Di Chen via Elfutils-devel wrote: > > From bdc19de94bff8f8812611b9ba8c0116a650d0fb5 Mon Sep 17 00:00:00 2001 > > From: Di Chen > > Date: Fri, 13 Jan 2023 20:12:43 +0800 > > Subject: [PATCH] readelf: display dynamic symtab without section headers > > > > This commit adds a new option "-D/--use-dynamic" to support printing the > > dynamic symbol table from the PT_DYNAMIC segment. By using the > > PT_DYNAMIC segment, eu-readelf can go through the contents of dynamic > > section entries and the values of each tag. From that, we can get the > > address and size of the dynamic symbol table, the address of the string > > table, etc. > > > > By using the new option "-D/--use-dynamic", eu-readelf can list the > > symbols without section headers. > > > > Example: > > $ ./src/readelf -Ds a.out > > 0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UNDEF > > 1: 0000000000000000 0 FUNC GLOBAL DEFAULT UNDEF > > __libc_start_main@GLIBC_2.34 (2) > > 2: 0000000000000000 0 NOTYPE WEAK DEFAULT UNDEF > > __gmon_start__ > > > > https://sourceware.org/bugzilla/show_bug.cgi?id=3D28873 > > > > Signed-off-by: Di Chen > > Very nice. > > Note that my local build (gcc 12.2.1) says: > > In function =E2=80=98handle_dynamic_symtab=E2=80=99, > inlined from =E2=80=98print_symtab=E2=80=99 at > /home/mark/src/elfutils/src/readelf.c:2451:9: > /home/mark/src/elfutils/src/readelf.c:2535:29: error: =E2=80=98syments=E2= =80=99 may be > used uninitialized [-Werror=3Dmaybe-uninitialized] > 2535 | if (offs[i_gnu_hash] !=3D 0 && syments =3D=3D 0) { > | ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~ > /home/mark/src/elfutils/src/readelf.c: In function =E2=80=98print_symtab= =E2=80=99: > /home/mark/src/elfutils/src/readelf.c:2519:10: note: =E2=80=98syments=E2= =80=99 was > declared here > 2519 | size_t syments; > | ^~~~~~~ > > And I think it is correct. We have 3 different ways of trying to set > syments. We should initialize syments to zero so each check knows > whether a previous one succeeded or not. > > I have not been very picky about missing ChangeLog entries, but in this > case it would really help understanding what was changed. > > Specifically it would be nice to note that the code in > handle_dynamic_symtab to calculate the syments was lifted from > libdwfl/dwfl_module_getdwarf.c. > > Lets keep the indentation GNU style, like in dwfl_module_getdwarf.c, I > don't think the new indentation is helpful. > > Finally the actual printing of the symbols and processing the version > information in handle_dynamic_symtab look like they were mostly copied > from handle_symtab. Can that code be shared? > > Thanks, > > Mark > > --0000000000001ec2c005f8500d1b-- --0000000000001ec2c205f8500d1d Content-Type: text/x-patch; charset="US-ASCII"; name="0001-readelf-display-dynamic-symtab-without-section-heade.patch" Content-Disposition: attachment; filename="0001-readelf-display-dynamic-symtab-without-section-heade.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lfypagqt0 RnJvbSA3MGFjNjk5Mzc0NDk4NWIyOTkzNWRmNjAxMGUzNmJmOWRiYmQ5NmQ5 IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEaSBDaGVuIDxkaWNo ZW5AcmVkaGF0LmNvbT4KRGF0ZTogTW9uLCAyNyBNYXIgMjAyMyAxMDowMTow NSArMDgwMApTdWJqZWN0OiBbUEFUQ0hdIHJlYWRlbGY6IGRpc3BsYXkgZHlu YW1pYyBzeW10YWIgd2l0aG91dCBzZWN0aW9uIGhlYWRlcnMKClRoaXMgY29t bWl0IGFkZHMgYSBuZXcgb3B0aW9uICItRC8tLXVzZS1keW5hbWljIiB0byBz dXBwb3J0IHByaW50aW5nIHRoZQpkeW5hbWljIHN5bWJvbCB0YWJsZSBmcm9t IHRoZSBQVF9EWU5BTUlDIHNlZ21lbnQuIEJ5IHVzaW5nIHRoZQpQVF9EWU5B TUlDIHNlZ21lbnQsIGV1LXJlYWRlbGYgY2FuIGdvIHRocm91Z2ggdGhlIGNv bnRlbnRzIG9mIGR5bmFtaWMKc2VjdGlvbiBlbnRyaWVzIGFuZCB0aGUgdmFs dWVzIG9mIGVhY2ggdGFnLiBGcm9tIHRoYXQsIHdlIGNhbiBnZXQgdGhlCmFk ZHJlc3MgYW5kIHNpemUgb2YgdGhlIGR5bmFtaWMgc3ltYm9sIHRhYmxlLCB0 aGUgYWRkcmVzcyBvZiB0aGUgc3RyaW5nCnRhYmxlLCBldGMuCgpCeSB1c2lu ZyB0aGUgbmV3IG9wdGlvbiAiLUQvLS11c2UtZHluYW1pYyIsIGV1LXJlYWRl bGYgY2FuIGxpc3QgdGhlCnN5bWJvbHMgd2l0aG91dCBzZWN0aW9uIGhlYWRl cnMuCgpFeGFtcGxlOgogICQgLi9zcmMvcmVhZGVsZiAtRHMgYS5vdXQKICAg ICAgMDogMDAwMDAwMDAwMDAwMDAwMCAgICAgIDAgTk9UWVBFICBMT0NBTCAg REVGQVVMVCAgICBVTkRFRgogICAgICAxOiAwMDAwMDAwMDAwMDAwMDAwICAg ICAgMCBGVU5DICAgIEdMT0JBTCBERUZBVUxUICAgIFVOREVGIF9fbGliY19z dGFydF9tYWluQEdMSUJDXzIuMzQgKDIpCiAgICAgIDI6IDAwMDAwMDAwMDAw MDAwMDAgICAgICAwIE5PVFlQRSAgV0VBSyAgIERFRkFVTFQgICAgVU5ERUYg X19nbW9uX3N0YXJ0X18KCmh0dHBzOi8vc291cmNld2FyZS5vcmcvYnVnemls bGEvc2hvd19idWcuY2dpP2lkPTI4ODczCgpTaWduZWQtb2ZmLWJ5OiBEaSBD aGVuIDxkaWNoZW5AcmVkaGF0LmNvbT4KLS0tCiBDaGFuZ2VMb2cgICAgIHwg ICA1ICsKIE5FV1MgICAgICAgICAgfCAgIDIgKwogc3JjL0NoYW5nZUxvZyB8 ICAgNiArCiBzcmMvcmVhZGVsZi5jIHwgNTMxICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tCiA0IGZpbGVzIGNo YW5nZWQsIDM5MyBpbnNlcnRpb25zKCspLCAxNTEgZGVsZXRpb25zKC0pCgpk aWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4IDEwYzIz MDAyLi5lY2UwN2U5NyAxMDA2NDQKLS0tIGEvQ2hhbmdlTG9nCisrKyBiL0No YW5nZUxvZwpAQCAtMSwzICsxLDggQEAKKzIwMjMtMDMtMjcgIERpIENoZW4g IDxkaWNoZW5AcmVkaGF0LmNvbT4KKworCSogTkVXUzogU3VwcG9ydCByZWFk ZWxmIC1EcyBmb3IgdXNpbmcgZHluYW1pYyBzZWdtZW50IHRvCisgICAgcHJp bnQgc3ltYm9sIHRhYmxlLgorCiAyMDIzLTAzLTAzICBNYXJrIFdpZWxhYXJk ICA8bWFya0BrbG9tcC5vcmc+CiAKIAkqIE5FV1M6IEFkZCBFTEZDT01QUkVT U19aU1REIHN1cHBvcnQgZm9yIGxpYmVsZiBhbmQgZWxmY29tcHJlc3MuCmRp ZmYgLS1naXQgYS9ORVdTIGIvTkVXUwppbmRleCAxNmUzN2VjYS4uNjc5ZDhi ZDUgMTAwNjQ0Ci0tLSBhL05FV1MKKysrIGIvTkVXUwpAQCAtMTcsNiArMTcs OCBAQCBlbGZjb21wcmVzczogLXQsIC0tdHlwZT0gbm93IHN1cHBvcnQgenN0 ZCBpZiBsaWJlbGYgaGFzIGJlZW4gYnVpbGQgd2l0aAogCiBiYWNrZW5kczog QWRkIHN1cHBvcnQgZm9yIExvb25nQXJjaCBhbmQgU3lub3BzeXMgQVJDdjIg cHJvY2Vzc29ycy4KIAorcmVhZGVsZjogU3VwcG9ydCByZWFkZWxmIC1Ecywg LS11c2UtZHluYW1pYyAtLXN5bWJvbC4KKwogVmVyc2lvbiAwLjE4OCAibm8g c2VjdGlvbiBsZWZ0IGJlaGluZCIKIAogcmVhZGVsZjogQWRkIC1ELCAtLXVz ZS1keW5hbWljIG9wdGlvbi4KZGlmZiAtLWdpdCBhL3NyYy9DaGFuZ2VMb2cg Yi9zcmMvQ2hhbmdlTG9nCmluZGV4IGMyNmRhZmRkLi44YWEyNjljZCAxMDA2 NDQKLS0tIGEvc3JjL0NoYW5nZUxvZworKysgYi9zcmMvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsOSBAQAorMjAyMy0wMy0yNyAgRGkgQ2hlbiAgPGRpY2hlbkBy ZWRoYXQuY29tPgorCisJKiByZWFkZWxmLmMgKG9wdGlvbnMpOiBTdXBwb3J0 IGR5bmFtaWMgc3ltdGFiIHByaW50IHdpdGggJy1EcycuCisJKHByb2Nlc3Nf c3ltdGFiKTogTmV3IGZ1bmN0aW9uLgorCShoYW5kbGVfZHluYW1pY19zeW10 YWIpOiBMaWtld2lzZS4KKwogMjAyMy0wMy0wMyAgTWFyayBXaWVsYWFyZCAg PG1hcmtAa2xvbXAub3JnPgogCiAJKiByZWFkZWxmIChwcm9jZXNzX2VsZl9m aWxlKTogZWJsX2Nsb3NlYmFja2VuZCBvbmx5IGFmdGVyCmRpZmYgLS1naXQg YS9zcmMvcmVhZGVsZi5jIGIvc3JjL3JlYWRlbGYuYwppbmRleCA2OTUwMjA0 ZS4uNzA4NDhjMjEgMTAwNjQ0Ci0tLSBhL3NyYy9yZWFkZWxmLmMKKysrIGIv c3JjL3JlYWRlbGYuYwpAQCAtMzA3LDcgKzMwNywyMSBAQCBzdGF0aWMgdm9p ZCBoYW5kbGVfcmVsb2NzX3JlbCAoRWJsICplYmwsIEdFbGZfRWhkciAqZWhk ciwgRWxmX1NjbiAqc2NuLAogc3RhdGljIHZvaWQgaGFuZGxlX3JlbG9jc19y ZWxhIChFYmwgKmVibCwgR0VsZl9FaGRyICplaGRyLCBFbGZfU2NuICpzY24s CiAJCQkJR0VsZl9TaGRyICpzaGRyKTsKIHN0YXRpYyBib29sIHByaW50X3N5 bXRhYiAoRWJsICplYmwsIGludCB0eXBlKTsKLXN0YXRpYyB2b2lkIGhhbmRs ZV9zeW10YWIgKEVibCAqZWJsLCBFbGZfU2NuICpzY24sIEdFbGZfU2hkciAq c2hkcik7CitzdGF0aWMgYm9vbCBoYW5kbGVfc3ltdGFiIChFYmwgKmVibCwg RWxmX1NjbiAqc2NuLCBHRWxmX1NoZHIgKnNoZHIpOworc3RhdGljIGJvb2wg aGFuZGxlX2R5bmFtaWNfc3ltdGFiIChFYmwgKmVibCk7CitzdGF0aWMgdm9p ZAorcHJvY2Vzc19zeW10YWIoCisJRWJsICogZWJsLAorCXVuc2lnbmVkIGlu dCBuc3ltcywKKwlFbGY2NF9Xb3JkIGlkeCwKKwlFbGYzMl9Xb3JkIHZlcm5l ZWRfc3RyaWR4LAorCUVsZjMyX1dvcmQgdmVyZGVmX3N0cmlkeCwKKwlFbGZf RGF0YSAqIHN5bWRhdGEsCisJRWxmX0RhdGEgKiB2ZXJzeW1fZGF0YSwKKwlF bGZfRGF0YSAqIHN5bXN0cl9kYXRhLAorCUVsZl9EYXRhICogdmVybmVlZF9k YXRhLAorCUVsZl9EYXRhICogdmVyZGVmX2RhdGEsCisJRWxmX0RhdGEgKiB4 bmR4X2RhdGEpOwogc3RhdGljIHZvaWQgcHJpbnRfdmVyaW5mbyAoRWJsICpl YmwpOwogc3RhdGljIHZvaWQgaGFuZGxlX3Zlcm5lZWQgKEVibCAqZWJsLCBF bGZfU2NuICpzY24sIEdFbGZfU2hkciAqc2hkcik7CiBzdGF0aWMgdm9pZCBo YW5kbGVfdmVyZGVmIChFYmwgKmVibCwgRWxmX1NjbiAqc2NuLCBHRWxmX1No ZHIgKnNoZHIpOwpAQCAtMzI1LDkgKzMzOSwxMiBAQCBzdGF0aWMgdm9pZCBk dW1wX2FyY2hpdmVfaW5kZXggKEVsZiAqLCBjb25zdCBjaGFyICopOwogCiBl bnVtIGR5bl9pZHgKIHsKKyAgaV9zeW10YWJfc2huZHgsCiAgIGlfc3Ryc3os CiAgIGlfdmVybmVlZCwKKyAgaV92ZXJuZWVkbnVtLAogICBpX3ZlcmRlZiwK KyAgaV92ZXJkZWZudW0sCiAgIGlfdmVyc3ltLAogICBpX3N5bXRhYiwKICAg aV9zdHJ0YWIsCkBAIC0xMDQyLDcgKzEwNTksNyBAQCBwcm9jZXNzX2VsZl9m aWxlIChEd2ZsX01vZHVsZSAqZHdmbG1vZCwgaW50IGZkKQogICAgIHN5bXRh Yl9wcmludGVkIHw9IHByaW50X3N5bXRhYiAoZWJsLCBTSFRfRFlOU1lNKTsK ICAgaWYgKHByaW50X3ZlcnNpb25faW5mbykKICAgICBwcmludF92ZXJpbmZv IChlYmwpOwotICBpZiAocHJpbnRfc3ltYm9sX3RhYmxlKQorICBpZiAocHJp bnRfc3ltYm9sX3RhYmxlICYmICF1c2VfZHluYW1pY19zZWdtZW50KQogICAg IHN5bXRhYl9wcmludGVkIHw9IHByaW50X3N5bXRhYiAoZWJsLCBTSFRfU1lN VEFCKTsKIAogICBpZiAoKHByaW50X3N5bWJvbF90YWJsZSB8fCBwcmludF9k eW5zeW1fdGFibGUpCkBAIC0yNDQzLDYgKzI0NjAsMTIgQEAgaGFuZGxlX3Jl bG9jc19yZWxhIChFYmwgKmVibCwgR0VsZl9FaGRyICplaGRyLCBFbGZfU2Nu ICpzY24sIEdFbGZfU2hkciAqc2hkcikKIHN0YXRpYyBib29sCiBwcmludF9z eW10YWIgKEVibCAqZWJsLCBpbnQgdHlwZSkKIHsKKyAgLyogVXNlIHRoZSBk eW5hbWljIHNlY3Rpb24gaW5mbyB0byBkaXNwbGF5IHN5bWJvbCB0YWJsZXMu ICAqLworICBpZiAodXNlX2R5bmFtaWNfc2VnbWVudCAmJiB0eXBlID09IFNI VF9EWU5TWU0pCisgIHsKKwlyZXR1cm4gaGFuZGxlX2R5bmFtaWNfc3ltdGFi KGVibCk7CisgIH0KKwogICAvKiBGaW5kIHRoZSBzeW1ib2wgdGFibGUocyku ICBGb3IgdGhpcyB3ZSBoYXZlIHRvIHNlYXJjaCB0aHJvdWdoIHRoZQogICAg ICBzZWN0aW9uIHRhYmxlLiAgKi8KICAgRWxmX1NjbiAqc2NuID0gTlVMTDsK QEAgLTI0ODEsOCArMjUwNCw3IEBAIHByaW50X3N5bXRhYiAoRWJsICplYmws IGludCB0eXBlKQogCQkJICAgIF8oImNhbm5vdCBnZXQgc2VjdGlvbiBbJXpk XSBoZWFkZXI6ICVzIiksCiAJCQkgICAgZWxmX25keHNjbiAoc2NuKSwgZWxm X2Vycm1zZyAoLTEpKTsKIAkgICAgfQotCSAgaGFuZGxlX3N5bXRhYiAoZWJs LCBzY24sIHNoZHIpOwotCSAgc3ltdGFiX3ByaW50ZWQgPSB0cnVlOworCSAg c3ltdGFiX3ByaW50ZWQgPSBoYW5kbGVfc3ltdGFiIChlYmwsIHNjbiwgc2hk cik7CiAJfQogICAgIH0KIApAQCAtMjQ5MSw2ICsyNTEzLDE3OSBAQCBwcmlu dF9zeW10YWIgKEVibCAqZWJsLCBpbnQgdHlwZSkKIAogCiBzdGF0aWMgdm9p ZAorcHJvY2Vzc19zeW10YWIgKEVibCAqZWJsLCB1bnNpZ25lZCBpbnQgbnN5 bXMsIEVsZjY0X1dvcmQgaWR4LAorICAgICAgICAgICAgICAgIEVsZjMyX1dv cmQgdmVybmVlZF9zdHJpZHgsIEVsZjMyX1dvcmQgdmVyZGVmX3N0cmlkeCwK KyAgICAgICAgICAgICAgICBFbGZfRGF0YSAqc3ltZGF0YSwgRWxmX0RhdGEg KnZlcnN5bV9kYXRhLAorICAgICAgICAgICAgICAgIEVsZl9EYXRhICpzeW1z dHJfZGF0YSwgRWxmX0RhdGEgKnZlcm5lZWRfZGF0YSwKKyAgICAgICAgICAg ICAgICBFbGZfRGF0YSAqdmVyZGVmX2RhdGEsIEVsZl9EYXRhICp4bmR4X2Rh dGEpCit7CisgIGZvciAodW5zaWduZWQgaW50IGNudCA9IDA7IGNudCA8IG5z eW1zOyArK2NudCkKKyAgICB7CisgICAgICBjaGFyIHR5cGVidWZbNjRdOwor ICAgICAgY2hhciBiaW5kYnVmWzY0XTsKKyAgICAgIGNoYXIgc2NuYnVmWzY0 XTsKKyAgICAgIEVsZjMyX1dvcmQgeG5keDsKKyAgICAgIEdFbGZfU3ltIHN5 bV9tZW07CisgICAgICBHRWxmX1N5bSAqc3ltCisgICAgICAgICAgPSBnZWxm X2dldHN5bXNobmR4IChzeW1kYXRhLCB4bmR4X2RhdGEsIGNudCwgJnN5bV9t ZW0sICZ4bmR4KTsKKworICAgICAgaWYgKHVubGlrZWx5IChzeW0gPT0gTlVM TCkpCisgICAgICAgIGNvbnRpbnVlOworCisgICAgICAvKiBEZXRlcm1pbmUg dGhlIHJlYWwgc2VjdGlvbiBpbmRleC4gICovCisgICAgICBpZiAobGlrZWx5 IChzeW0tPnN0X3NobmR4ICE9IFNITl9YSU5ERVgpKQorICAgICAgICB4bmR4 ID0gc3ltLT5zdF9zaG5keDsKKworICAgICAgcHJpbnRmIChfICgiXAorJTV1 OiAlMCoiIFBSSXg2NCAiICU2IiBQUklkNjQgIiAlLTdzICUtNnMgJS05cyAl NnMgJXMiKSwKKyAgICAgICAgICAgICAgY250LCBnZWxmX2dldGNsYXNzIChl YmwtPmVsZikgPT0gRUxGQ0xBU1MzMiA/IDggOiAxNiwKKyAgICAgICAgICAg ICAgc3ltLT5zdF92YWx1ZSwgc3ltLT5zdF9zaXplLAorICAgICAgICAgICAg ICBlYmxfc3ltYm9sX3R5cGVfbmFtZSAoZWJsLCBHRUxGX1NUX1RZUEUgKHN5 bS0+c3RfaW5mbyksIHR5cGVidWYsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBzaXplb2YgKHR5cGVidWYpKSwKKyAgICAgICAgICAg ICAgZWJsX3N5bWJvbF9iaW5kaW5nX25hbWUgKGVibCwgR0VMRl9TVF9CSU5E IChzeW0tPnN0X2luZm8pLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgYmluZGJ1Ziwgc2l6ZW9mIChiaW5kYnVmKSksCisgICAg ICAgICAgICAgIGdldF92aXNpYmlsaXR5X3R5cGUgKEdFTEZfU1RfVklTSUJJ TElUWSAoc3ltLT5zdF9vdGhlcikpLAorICAgICAgICAgICAgICBlYmxfc2Vj dGlvbl9uYW1lIChlYmwsIHN5bS0+c3Rfc2huZHgsIHhuZHgsIHNjbmJ1ZiwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mIChzY25i dWYpLCBOVUxMLCBzaG51bSksCisgICAgICAgICAgICAgIHVzZV9keW5hbWlj X3NlZ21lbnQgPT0gdHJ1ZQorICAgICAgICAgICAgICAgICAgPyAoY2hhciAq KXN5bXN0cl9kYXRhLT5kX2J1ZiArIHN5bS0+c3RfbmFtZQorICAgICAgICAg ICAgICAgICAgOiBlbGZfc3RycHRyIChlYmwtPmVsZiwgaWR4LCBzeW0tPnN0 X25hbWUpKTsKKworICAgICAgaWYgKHZlcnN5bV9kYXRhICE9IE5VTEwpCisg ICAgICAgIHsKKyAgICAgICAgICAvKiBHZXQgdGhlIHZlcnNpb24gaW5mb3Jt YXRpb24uICAqLworICAgICAgICAgIEdFbGZfVmVyc3ltIHZlcnN5bV9tZW07 CisgICAgICAgICAgR0VsZl9WZXJzeW0gKnZlcnN5bSA9IGdlbGZfZ2V0dmVy c3ltICh2ZXJzeW1fZGF0YSwgY250LCAmdmVyc3ltX21lbSk7CisKKyAgICAg ICAgICBpZiAodmVyc3ltICE9IE5VTEwgJiYgKCgqdmVyc3ltICYgMHg4MDAw KSAhPSAwIHx8ICp2ZXJzeW0gPiAxKSkKKyAgICAgICAgICAgIHsKKyAgICAg ICAgICAgICAgYm9vbCBpc19ub2JpdHMgPSBmYWxzZTsKKyAgICAgICAgICAg ICAgYm9vbCBjaGVja19kZWYgPSB4bmR4ICE9IFNITl9VTkRFRjsKKworICAg ICAgICAgICAgICBpZiAoeG5keCA8IFNITl9MT1JFU0VSVkUgfHwgc3ltLT5z dF9zaG5keCA9PSBTSE5fWElOREVYKQorICAgICAgICAgICAgICAgIHsKKyAg ICAgICAgICAgICAgICAgIEdFbGZfU2hkciBzeW1zaGRyX21lbTsKKyAgICAg ICAgICAgICAgICAgIEdFbGZfU2hkciAqc3ltc2hkciA9IGdlbGZfZ2V0c2hk ciAoCisgICAgICAgICAgICAgICAgICAgICAgZWxmX2dldHNjbiAoZWJsLT5l bGYsIHhuZHgpLCAmc3ltc2hkcl9tZW0pOworCisgICAgICAgICAgICAgICAg ICBpc19ub2JpdHMKKyAgICAgICAgICAgICAgICAgICAgICA9IChzeW1zaGRy ICE9IE5VTEwgJiYgc3ltc2hkci0+c2hfdHlwZSA9PSBTSFRfTk9CSVRTKTsK KyAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgaWYgKGlzX25v Yml0cyB8fCAhY2hlY2tfZGVmKQorICAgICAgICAgICAgICAgIHsKKyAgICAg ICAgICAgICAgICAgIC8qIFdlIG11c3QgdGVzdCBib3RoLiAgKi8KKyAgICAg ICAgICAgICAgICAgIEdFbGZfVmVybmF1eCB2ZXJuYXV4X21lbTsKKyAgICAg ICAgICAgICAgICAgIEdFbGZfVmVybmF1eCAqdmVybmF1eCA9IE5VTEw7Cisg ICAgICAgICAgICAgICAgICBzaXplX3Qgdm5fb2Zmc2V0ID0gMDsKKworICAg ICAgICAgICAgICAgICAgR0VsZl9WZXJuZWVkIHZlcm5lZWRfbWVtOworICAg ICAgICAgICAgICAgICAgR0VsZl9WZXJuZWVkICp2ZXJuZWVkCisgICAgICAg ICAgICAgICAgICAgICAgPSBnZWxmX2dldHZlcm5lZWQgKHZlcm5lZWRfZGF0 YSwgMCwgJnZlcm5lZWRfbWVtKTsKKyAgICAgICAgICAgICAgICAgIHdoaWxl ICh2ZXJuZWVkICE9IE5VTEwpCisgICAgICAgICAgICAgICAgICAgIHsKKyAg ICAgICAgICAgICAgICAgICAgICBzaXplX3Qgdm5hX29mZnNldCA9IHZuX29m ZnNldDsKKworICAgICAgICAgICAgICAgICAgICAgIHZlcm5hdXggPSBnZWxm X2dldHZlcm5hdXggKHZlcm5lZWRfZGF0YSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2bmFfb2Zmc2V0ICs9 IHZlcm5lZWQtPnZuX2F1eCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAmdmVybmF1eF9tZW0pOworICAgICAg ICAgICAgICAgICAgICAgIHdoaWxlICh2ZXJuYXV4ICE9IE5VTEwgJiYgdmVy bmF1eC0+dm5hX290aGVyICE9ICp2ZXJzeW0KKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgJiYgdmVybmF1eC0+dm5hX25leHQgIT0gMAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAmJiAodmVybmVlZF9kYXRhLT5kX3Np emUgLSB2bmFfb2Zmc2V0CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICA+PSB2ZXJuYXV4LT52bmFfbmV4dCkpCisgICAgICAgICAgICAgICAg ICAgICAgICB7CisgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIFVwZGF0 ZSB0aGUgb2Zmc2V0LiAgKi8KKyAgICAgICAgICAgICAgICAgICAgICAgICAg dm5hX29mZnNldCArPSB2ZXJuYXV4LT52bmFfbmV4dDsKKworICAgICAgICAg ICAgICAgICAgICAgICAgICB2ZXJuYXV4ID0gKHZlcm5hdXgtPnZuYV9uZXh0 ID09IDAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgPyBOVUxMCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIDogZ2VsZl9nZXR2ZXJuYXV4ICh2ZXJuZWVkX2RhdGEsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB2bmFfb2Zmc2V0LAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnZlcm5h dXhfbWVtKSk7CisgICAgICAgICAgICAgICAgICAgICAgICB9CisKKyAgICAg ICAgICAgICAgICAgICAgICAvKiBDaGVjayB3aGV0aGVyIHdlIGZvdW5kIHRo ZSB2ZXJzaW9uLiAgKi8KKyAgICAgICAgICAgICAgICAgICAgICBpZiAodmVy bmF1eCAhPSBOVUxMICYmIHZlcm5hdXgtPnZuYV9vdGhlciA9PSAqdmVyc3lt KQorICAgICAgICAgICAgICAgICAgICAgICAgLyogRm91bmQgaXQuICAqLwor ICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgICAg ICAgICAgICAgICBpZiAodmVybmVlZF9kYXRhLT5kX3NpemUgLSB2bl9vZmZz ZXQgPCB2ZXJuZWVkLT52bl9uZXh0KQorICAgICAgICAgICAgICAgICAgICAg ICAgYnJlYWs7CisKKyAgICAgICAgICAgICAgICAgICAgICB2bl9vZmZzZXQg Kz0gdmVybmVlZC0+dm5fbmV4dDsKKyAgICAgICAgICAgICAgICAgICAgICB2 ZXJuZWVkCisgICAgICAgICAgICAgICAgICAgICAgICAgID0gKHZlcm5lZWQt PnZuX25leHQgPT0gMAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgPyBOVUxMCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6 IGdlbGZfZ2V0dmVybmVlZCAodmVybmVlZF9kYXRhLCB2bl9vZmZzZXQsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgJnZlcm5lZWRfbWVtKSk7CisgICAgICAgICAgICAgICAgICAgIH0K KworICAgICAgICAgICAgICAgICAgaWYgKHZlcm5hdXggIT0gTlVMTCAmJiB2 ZXJuYXV4LT52bmFfb3RoZXIgPT0gKnZlcnN5bSkKKyAgICAgICAgICAgICAg ICAgICAgeworICAgICAgICAgICAgICAgICAgICAgIHByaW50ZiAoIkAlcyAo JXUpIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVzZV9keW5h bWljX3NlZ21lbnQgPT0gdHJ1ZQorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgID8gKGNoYXIgKilzeW1zdHJfZGF0YS0+ZF9idWYKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICArIHZlcm5hdXgt PnZuYV9uYW1lCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg OiBlbGZfc3RycHRyIChlYmwtPmVsZiwgdmVybmVlZF9zdHJpZHgsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2 ZXJuYXV4LT52bmFfbmFtZSksCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAodW5zaWduZWQgaW50KXZlcm5hdXgtPnZuYV9vdGhlcik7CisgICAg ICAgICAgICAgICAgICAgICAgY2hlY2tfZGVmID0gMDsKKyAgICAgICAgICAg ICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgZWxzZSBpZiAodW5saWtl bHkgKCFpc19ub2JpdHMpKQorICAgICAgICAgICAgICAgICAgICBlcnJvciAo MCwgMCwgXyAoImJhZCBkeW5hbWljIHN5bWJvbCIpKTsKKyAgICAgICAgICAg ICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgY2hlY2tfZGVmID0g MTsKKyAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgaWYgKGNo ZWNrX2RlZiAmJiAqdmVyc3ltICE9IDB4ODAwMSkKKyAgICAgICAgICAgICAg ICB7CisgICAgICAgICAgICAgICAgICAvKiBXZSBtdXN0IHRlc3QgYm90aC4g ICovCisgICAgICAgICAgICAgICAgICBzaXplX3QgdmRfb2Zmc2V0ID0gMDsK KworICAgICAgICAgICAgICAgICAgR0VsZl9WZXJkZWYgdmVyZGVmX21lbTsK KyAgICAgICAgICAgICAgICAgIEdFbGZfVmVyZGVmICp2ZXJkZWYKKyAgICAg ICAgICAgICAgICAgICAgICA9IGdlbGZfZ2V0dmVyZGVmICh2ZXJkZWZfZGF0 YSwgMCwgJnZlcmRlZl9tZW0pOworICAgICAgICAgICAgICAgICAgd2hpbGUg KHZlcmRlZiAhPSBOVUxMKQorICAgICAgICAgICAgICAgICAgICB7CisgICAg ICAgICAgICAgICAgICAgICAgaWYgKHZlcmRlZi0+dmRfbmR4ID09ICgqdmVy c3ltICYgMHg3ZmZmKSkKKyAgICAgICAgICAgICAgICAgICAgICAgIC8qIEZv dW5kIHRoZSBkZWZpbml0aW9uLiAgKi8KKyAgICAgICAgICAgICAgICAgICAg ICAgIGJyZWFrOworCisgICAgICAgICAgICAgICAgICAgICAgaWYgKHZlcmRl Zl9kYXRhLT5kX3NpemUgLSB2ZF9vZmZzZXQgPCB2ZXJkZWYtPnZkX25leHQp CisgICAgICAgICAgICAgICAgICAgICAgICBicmVhazsKKworICAgICAgICAg ICAgICAgICAgICAgIHZkX29mZnNldCArPSB2ZXJkZWYtPnZkX25leHQ7Cisg ICAgICAgICAgICAgICAgICAgICAgdmVyZGVmID0gKHZlcmRlZi0+dmRfbmV4 dCA9PSAwCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA/ IE5VTEwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDog Z2VsZl9nZXR2ZXJkZWYgKHZlcmRlZl9kYXRhLCB2ZF9vZmZzZXQsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAmdmVyZGVmX21lbSkpOworICAgICAgICAgICAgICAgICAgICB9CisK KyAgICAgICAgICAgICAgICAgIGlmICh2ZXJkZWYgIT0gTlVMTCkKKyAgICAg ICAgICAgICAgICAgICAgeworICAgICAgICAgICAgICAgICAgICAgIEdFbGZf VmVyZGF1eCB2ZXJkYXV4X21lbTsKKyAgICAgICAgICAgICAgICAgICAgICBH RWxmX1ZlcmRhdXggKnZlcmRhdXggPSBnZWxmX2dldHZlcmRhdXggKAorICAg ICAgICAgICAgICAgICAgICAgICAgICB2ZXJkZWZfZGF0YSwgdmRfb2Zmc2V0 ICsgdmVyZGVmLT52ZF9hdXgsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICZ2ZXJkYXV4X21lbSk7CisKKyAgICAgICAgICAgICAgICAgICAgICBpZiAo dmVyZGF1eCAhPSBOVUxMKQorICAgICAgICAgICAgICAgICAgICAgICAgcHJp bnRmICgoKnZlcnN5bSAmIDB4ODAwMCkgPyAiQCVzIiA6ICJAQCVzIiwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdXNlX2R5bmFtaWNfc2Vn bWVudCA9PSB0cnVlCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICA/IChjaGFyICopc3ltc3RyX2RhdGEtPmRfYnVmCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICArIHZlcmRhdXgtPnZk YV9uYW1lCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6 IGVsZl9zdHJwdHIgKGVibC0+ZWxmLCB2ZXJkZWZfc3RyaWR4LAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2 ZXJkYXV4LT52ZGFfbmFtZSkpOworICAgICAgICAgICAgICAgICAgICB9Cisg ICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9CisK KyAgICAgIHB1dGNoYXJfdW5sb2NrZWQgKCdcbicpOworICAgIH0KK30KKwor CitzdGF0aWMgYm9vbAogaGFuZGxlX3N5bXRhYiAoRWJsICplYmwsIEVsZl9T Y24gKnNjbiwgR0VsZl9TaGRyICpzaGRyKQogewogICBFbGZfRGF0YSAqdmVy c3ltX2RhdGEgPSBOVUxMOwpAQCAtMjUwNCw3ICsyNjk5LDcgQEAgaGFuZGxl X3N5bXRhYiAoRWJsICplYmwsIEVsZl9TY24gKnNjbiwgR0VsZl9TaGRyICpz aGRyKQogICAvKiBHZXQgdGhlIGRhdGEgb2YgdGhlIHNlY3Rpb24uICAqLwog ICBFbGZfRGF0YSAqZGF0YSA9IGVsZl9nZXRkYXRhIChzY24sIE5VTEwpOwog ICBpZiAoZGF0YSA9PSBOVUxMKQotICAgIHJldHVybjsKKyAgICByZXR1cm4g ZmFsc2U7CiAKICAgLyogRmluZCBvdXQgd2hldGhlciB3ZSBoYXZlIG90aGVy IHNlY3Rpb25zIHdlIG1pZ2h0IG5lZWQuICAqLwogICBFbGZfU2NuICpydW5z Y24gPSBOVUxMOwpAQCAtMjU3NCwxNjMgKzI3NjksMTg2IEBAIGhhbmRsZV9z eW10YWIgKEVibCAqZWJsLCBFbGZfU2NuICpzY24sIEdFbGZfU2hkciAqc2hk cikKICAgTnVtOiAgICAgICAgICAgIFZhbHVlICAgU2l6ZSBUeXBlICAgIEJp bmQgICBWaXMgICAgICAgICAgTmR4IE5hbWVcbiIpLAogCQkgIHN0ZG91dCk7 CiAKLSAgZm9yICh1bnNpZ25lZCBpbnQgY250ID0gMDsgY250IDwgbnN5bXM7 ICsrY250KQotICAgIHsKLSAgICAgIGNoYXIgdHlwZWJ1Zls2NF07Ci0gICAg ICBjaGFyIGJpbmRidWZbNjRdOwotICAgICAgY2hhciBzY25idWZbNjRdOwot ICAgICAgRWxmMzJfV29yZCB4bmR4OwotICAgICAgR0VsZl9TeW0gc3ltX21l bTsKLSAgICAgIEdFbGZfU3ltICpzeW0gPSBnZWxmX2dldHN5bXNobmR4IChk YXRhLCB4bmR4X2RhdGEsIGNudCwgJnN5bV9tZW0sICZ4bmR4KTsKLQotICAg ICAgaWYgKHVubGlrZWx5IChzeW0gPT0gTlVMTCkpCi0JY29udGludWU7Ci0K LSAgICAgIC8qIERldGVybWluZSB0aGUgcmVhbCBzZWN0aW9uIGluZGV4LiAg Ki8KLSAgICAgIGlmIChsaWtlbHkgKHN5bS0+c3Rfc2huZHggIT0gU0hOX1hJ TkRFWCkpCi0JeG5keCA9IHN5bS0+c3Rfc2huZHg7Ci0KLSAgICAgIHByaW50 ZiAoXygiXAotJTV1OiAlMCoiIFBSSXg2NCAiICU2IiBQUklkNjQgIiAlLTdz ICUtNnMgJS05cyAlNnMgJXMiKSwKLQkgICAgICBjbnQsCi0JICAgICAgY2xh c3MgPT0gRUxGQ0xBU1MzMiA/IDggOiAxNiwKLQkgICAgICBzeW0tPnN0X3Zh bHVlLAotCSAgICAgIHN5bS0+c3Rfc2l6ZSwKLQkgICAgICBlYmxfc3ltYm9s X3R5cGVfbmFtZSAoZWJsLCBHRUxGX1NUX1RZUEUgKHN5bS0+c3RfaW5mbyks Ci0JCQkJICAgIHR5cGVidWYsIHNpemVvZiAodHlwZWJ1ZikpLAotCSAgICAg IGVibF9zeW1ib2xfYmluZGluZ19uYW1lIChlYmwsIEdFTEZfU1RfQklORCAo c3ltLT5zdF9pbmZvKSwKLQkJCQkgICAgICAgYmluZGJ1Ziwgc2l6ZW9mIChi aW5kYnVmKSksCi0JICAgICAgZ2V0X3Zpc2liaWxpdHlfdHlwZSAoR0VMRl9T VF9WSVNJQklMSVRZIChzeW0tPnN0X290aGVyKSksCi0JICAgICAgZWJsX3Nl Y3Rpb25fbmFtZSAoZWJsLCBzeW0tPnN0X3NobmR4LCB4bmR4LCBzY25idWYs Ci0JCQkJc2l6ZW9mIChzY25idWYpLCBOVUxMLCBzaG51bSksCi0JICAgICAg ZWxmX3N0cnB0ciAoZWJsLT5lbGYsIHNoZHItPnNoX2xpbmssIHN5bS0+c3Rf bmFtZSkpOwotCi0gICAgICBpZiAodmVyc3ltX2RhdGEgIT0gTlVMTCkKLQl7 Ci0JICAvKiBHZXQgdGhlIHZlcnNpb24gaW5mb3JtYXRpb24uICAqLwotCSAg R0VsZl9WZXJzeW0gdmVyc3ltX21lbTsKLQkgIEdFbGZfVmVyc3ltICp2ZXJz eW0gPSBnZWxmX2dldHZlcnN5bSAodmVyc3ltX2RhdGEsIGNudCwgJnZlcnN5 bV9tZW0pOwotCi0JICBpZiAodmVyc3ltICE9IE5VTEwgJiYgKCgqdmVyc3lt ICYgMHg4MDAwKSAhPSAwIHx8ICp2ZXJzeW0gPiAxKSkKLQkgICAgewotCSAg ICAgIGJvb2wgaXNfbm9iaXRzID0gZmFsc2U7Ci0JICAgICAgYm9vbCBjaGVj a19kZWYgPSB4bmR4ICE9IFNITl9VTkRFRjsKLQotCSAgICAgIGlmICh4bmR4 IDwgU0hOX0xPUkVTRVJWRSB8fCBzeW0tPnN0X3NobmR4ID09IFNITl9YSU5E RVgpCi0JCXsKLQkJICBHRWxmX1NoZHIgc3ltc2hkcl9tZW07Ci0JCSAgR0Vs Zl9TaGRyICpzeW1zaGRyID0KLQkJICAgIGdlbGZfZ2V0c2hkciAoZWxmX2dl dHNjbiAoZWJsLT5lbGYsIHhuZHgpLCAmc3ltc2hkcl9tZW0pOwotCi0JCSAg aXNfbm9iaXRzID0gKHN5bXNoZHIgIT0gTlVMTAotCQkJICAgICAgICYmIHN5 bXNoZHItPnNoX3R5cGUgPT0gU0hUX05PQklUUyk7Ci0JCX0KKwlwcm9jZXNz X3N5bXRhYihlYmwsIG5zeW1zLCBzaGRyLT5zaF9saW5rLCB2ZXJuZWVkX3N0 cmlkeCwgdmVyZGVmX3N0cmlkeCwKKwlkYXRhLCB2ZXJzeW1fZGF0YSwgTlVM TCwgdmVybmVlZF9kYXRhLCB2ZXJkZWZfZGF0YSwgeG5keF9kYXRhKTsKKyAg ICByZXR1cm4gdHJ1ZTsKK30KIAotCSAgICAgIGlmIChpc19ub2JpdHMgfHwg ISBjaGVja19kZWYpCi0JCXsKLQkJICAvKiBXZSBtdXN0IHRlc3QgYm90aC4g ICovCi0JCSAgR0VsZl9WZXJuYXV4IHZlcm5hdXhfbWVtOwotCQkgIEdFbGZf VmVybmF1eCAqdmVybmF1eCA9IE5VTEw7Ci0JCSAgc2l6ZV90IHZuX29mZnNl dCA9IDA7Ci0KLQkJICBHRWxmX1Zlcm5lZWQgdmVybmVlZF9tZW07Ci0JCSAg R0VsZl9WZXJuZWVkICp2ZXJuZWVkID0gZ2VsZl9nZXR2ZXJuZWVkICh2ZXJu ZWVkX2RhdGEsIDAsCi0JCQkJCQkJICAgJnZlcm5lZWRfbWVtKTsKLQkJICB3 aGlsZSAodmVybmVlZCAhPSBOVUxMKQotCQkgICAgewotCQkgICAgICBzaXpl X3Qgdm5hX29mZnNldCA9IHZuX29mZnNldDsKLQotCQkgICAgICB2ZXJuYXV4 ID0gZ2VsZl9nZXR2ZXJuYXV4ICh2ZXJuZWVkX2RhdGEsCi0JCQkJCQkgdm5h X29mZnNldCArPSB2ZXJuZWVkLT52bl9hdXgsCi0JCQkJCQkgJnZlcm5hdXhf bWVtKTsKLQkJICAgICAgd2hpbGUgKHZlcm5hdXggIT0gTlVMTAotCQkJICAg ICAmJiB2ZXJuYXV4LT52bmFfb3RoZXIgIT0gKnZlcnN5bQotCQkJICAgICAm JiB2ZXJuYXV4LT52bmFfbmV4dCAhPSAwCi0JCQkgICAgICYmICh2ZXJuZWVk X2RhdGEtPmRfc2l6ZSAtIHZuYV9vZmZzZXQKLQkJCQkgPj0gdmVybmF1eC0+ dm5hX25leHQpKQotCQkJewotCQkJICAvKiBVcGRhdGUgdGhlIG9mZnNldC4g ICovCi0JCQkgIHZuYV9vZmZzZXQgKz0gdmVybmF1eC0+dm5hX25leHQ7Ci0K LQkJCSAgdmVybmF1eCA9ICh2ZXJuYXV4LT52bmFfbmV4dCA9PSAwCi0JCQkJ ICAgICA/IE5VTEwKLQkJCQkgICAgIDogZ2VsZl9nZXR2ZXJuYXV4ICh2ZXJu ZWVkX2RhdGEsCi0JCQkJCQkJdm5hX29mZnNldCwKLQkJCQkJCQkmdmVybmF1 eF9tZW0pKTsKLQkJCX0KIAotCQkgICAgICAvKiBDaGVjayB3aGV0aGVyIHdl IGZvdW5kIHRoZSB2ZXJzaW9uLiAgKi8KLQkJICAgICAgaWYgKHZlcm5hdXgg IT0gTlVMTCAmJiB2ZXJuYXV4LT52bmFfb3RoZXIgPT0gKnZlcnN5bSkKLQkJ CS8qIEZvdW5kIGl0LiAgKi8KLQkJCWJyZWFrOworc3RhdGljIGJvb2wKK2hh bmRsZV9keW5hbWljX3N5bXRhYiAoRWJsICplYmwpCit7CisgIEdFbGZfUGhk ciAqcGhkciA9IE5VTEw7CisgIC8qIHBobnVtIGlzIGEgc3RhdGljIHZhcmlh YmxlIHdoaWNoIGFscmVhZHkgZmV0Y2hlZCBpbiBmdW5jdGlvbgorICAgKiBw cm9jZXNzX2VsZl9maWxlLiAgKi8KKyAgZm9yIChzaXplX3QgaSA9IDA7IGkg PCBwaG51bTsgKytpKQorICAgIHsKKyAgICAgIEdFbGZfUGhkciBwaGRyX21l bTsKKyAgICAgIHBoZHIgPSBnZWxmX2dldHBoZHIgKGVibC0+ZWxmLCBpLCAm cGhkcl9tZW0pOworICAgICAgaWYgKHBoZHItPnBfdHlwZSA9PSBQVF9EWU5B TUlDKQorICAgICAgICB7CisgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0K KyAgICB9CisgIGlmIChwaGRyID09IE5VTEwpCisgICAgcmV0dXJuIGZhbHNl OwogCi0JCSAgICAgIGlmICh2ZXJuZWVkX2RhdGEtPmRfc2l6ZSAtIHZuX29m ZnNldCA8IHZlcm5lZWQtPnZuX25leHQpCi0JCQlicmVhazsKKyAgR0VsZl9B ZGRyIGFkZHJzW2lfbWF4XSA9IHsKKyAgICAwLAorICB9OworICBHRWxmX09m ZiBvZmZzW2lfbWF4XSA9IHsKKyAgICAwLAorICB9OworICBnZXRfZHluc2Nu X2FkZHJzIChlYmwtPmVsZiwgcGhkciwgYWRkcnMpOworICBmaW5kX29mZnNl dHMgKGVibC0+ZWxmLCAwLCBpX21heCwgYWRkcnMsIG9mZnMpOwogCi0JCSAg ICAgIHZuX29mZnNldCArPSB2ZXJuZWVkLT52bl9uZXh0OwotCQkgICAgICB2 ZXJuZWVkID0gKHZlcm5lZWQtPnZuX25leHQgPT0gMAotCQkJCSA/IE5VTEwK LQkJCQkgOiBnZWxmX2dldHZlcm5lZWQgKHZlcm5lZWRfZGF0YSwgdm5fb2Zm c2V0LAotCQkJCQkJICAgICZ2ZXJuZWVkX21lbSkpOwotCQkgICAgfQorICBz aXplX3Qgc3ltZW50cyA9IDA7CiAKLQkJICBpZiAodmVybmF1eCAhPSBOVUxM ICYmIHZlcm5hdXgtPnZuYV9vdGhlciA9PSAqdmVyc3ltKQotCQkgICAgewot CQkgICAgICBwcmludGYgKCJAJXMgKCV1KSIsCi0JCQkgICAgICBlbGZfc3Ry cHRyIChlYmwtPmVsZiwgdmVybmVlZF9zdHJpZHgsCi0JCQkJCSAgdmVybmF1 eC0+dm5hX25hbWUpLAotCQkJICAgICAgKHVuc2lnbmVkIGludCkgdmVybmF1 eC0+dm5hX290aGVyKTsKLQkJICAgICAgY2hlY2tfZGVmID0gMDsKLQkJICAg IH0KLQkJICBlbHNlIGlmICh1bmxpa2VseSAoISBpc19ub2JpdHMpKQotCQkg ICAgZXJyb3IgKDAsIDAsIF8oImJhZCBkeW5hbWljIHN5bWJvbCIpKTsKLQkJ ICBlbHNlCi0JCSAgICBjaGVja19kZWYgPSAxOwotCQl9CisgIEdFbGZfRWhk ciBlaGRyX21lbTsKKyAgR0VsZl9FaGRyICplaGRyID0gZ2VsZl9nZXRlaGRy IChlYmwtPmVsZiwgJmVoZHJfbWVtKTsKIAotCSAgICAgIGlmIChjaGVja19k ZWYgJiYgKnZlcnN5bSAhPSAweDgwMDEpCi0JCXsKLQkJICAvKiBXZSBtdXN0 IHRlc3QgYm90aC4gICovCi0JCSAgc2l6ZV90IHZkX29mZnNldCA9IDA7Cisg IGlmIChvZmZzW2lfaGFzaF0gIT0gMCkKKyAgICB7CisgICAgICAvKiBJbiB0 aGUgb3JpZ2luYWwgZm9ybWF0LCAuaGFzaCBzYXlzIHRoZSBzaXplIG9mIC5k eW5zeW0uICAqLwogCi0JCSAgR0VsZl9WZXJkZWYgdmVyZGVmX21lbTsKLQkJ ICBHRWxmX1ZlcmRlZiAqdmVyZGVmID0gZ2VsZl9nZXR2ZXJkZWYgKHZlcmRl Zl9kYXRhLCAwLAotCQkJCQkJCSZ2ZXJkZWZfbWVtKTsKLQkJICB3aGlsZSAo dmVyZGVmICE9IE5VTEwpCi0JCSAgICB7Ci0JCSAgICAgIGlmICh2ZXJkZWYt PnZkX25keCA9PSAoKnZlcnN5bSAmIDB4N2ZmZikpCi0JCQkvKiBGb3VuZCB0 aGUgZGVmaW5pdGlvbi4gICovCi0JCQlicmVhazsKKyAgICAgIHNpemVfdCBl bnRzeiA9IFNIX0VOVFNJWkVfSEFTSCAoZWhkcik7CisgICAgICBFbGZfRGF0 YSAqZGF0YQorICAgICAgICAgID0gZWxmX2dldGRhdGFfcmF3Y2h1bmsgKGVi bC0+ZWxmLCBvZmZzW2lfaGFzaF0gKyBlbnRzeiwgZW50c3osCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgKGVudHN6ID09IDQgPyBFTEZf VF9XT1JEIDogRUxGX1RfWFdPUkQpKTsKKyAgICAgIGlmIChkYXRhICE9IE5V TEwpCisgICAgICAgIHN5bWVudHMgPSAoZW50c3ogPT0gNCA/ICooY29uc3Qg R0VsZl9Xb3JkICopZGF0YS0+ZF9idWYKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDogKihjb25zdCBHRWxmX1h3b3JkICopZGF0YS0+ZF9idWYp OworICAgIH0KKyAgaWYgKG9mZnNbaV9nbnVfaGFzaF0gIT0gMCAmJiBzeW1l bnRzID09IDApCisgICAgeworICAgICAgLyogSW4gdGhlIG5ldyBmb3JtYXQs IHdlIGNhbiBkZXJpdmUgaXQgd2l0aCBzb21lIHdvcmsuICAqLwogCi0JCSAg ICAgIGlmICh2ZXJkZWZfZGF0YS0+ZF9zaXplIC0gdmRfb2Zmc2V0IDwgdmVy ZGVmLT52ZF9uZXh0KQotCQkJYnJlYWs7CisgICAgICBjb25zdCBzdHJ1Y3QK KyAgICAgIHsKKyAgICAgICAgRWxmMzJfV29yZCBuYnVja2V0czsKKyAgICAg ICAgRWxmMzJfV29yZCBzeW1uZHg7CisgICAgICAgIEVsZjMyX1dvcmQgbWFz a3dvcmRzOworICAgICAgICBFbGYzMl9Xb3JkIHNoaWZ0MjsKKyAgICAgIH0g KiBoZWFkZXI7CisKKyAgICAgIEVsZl9EYXRhICpkYXRhID0gZWxmX2dldGRh dGFfcmF3Y2h1bmsgKGVibC0+ZWxmLCBvZmZzW2lfZ251X2hhc2hdLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2l6 ZW9mICpoZWFkZXIsIEVMRl9UX1dPUkQpOworICAgICAgaWYgKGRhdGEgIT0g TlVMTCkKKyAgICAgICAgeworICAgICAgICAgIGhlYWRlciA9IGRhdGEtPmRf YnVmOworICAgICAgICAgIEVsZjMyX1dvcmQgbmJ1Y2tldHMgPSBoZWFkZXIt Pm5idWNrZXRzOworICAgICAgICAgIEVsZjMyX1dvcmQgc3ltbmR4ID0gaGVh ZGVyLT5zeW1uZHg7CisgICAgICAgICAgR0VsZl9PZmYgYnVja2V0c19hdAor ICAgICAgICAgICAgICA9IChvZmZzW2lfZ251X2hhc2hdICsgc2l6ZW9mICpo ZWFkZXIKKyAgICAgICAgICAgICAgICAgKyAoZ2VsZl9nZXRjbGFzcyAoZWJs LT5lbGYpICogc2l6ZW9mIChFbGYzMl9Xb3JkKQorICAgICAgICAgICAgICAg ICAgICAqIGhlYWRlci0+bWFza3dvcmRzKSk7CisKKyAgICAgICAgICAvLyBl bGZfZ2V0ZGF0YV9yYXdjaHVuayB0YWtlcyBhIHNpemVfdCwgbWFrZSBzdXJl IGl0CisgICAgICAgICAgLy8gZG9lc24ndCBvdmVyZmxvdy4KKyNpZiBTSVpF X01BWCA8PSBVSU5UMzJfTUFYCisgICAgICAgICAgaWYgKG5idWNrZXRzID4g U0laRV9NQVggLyBzaXplb2YgKEVsZjMyX1dvcmQpKQorICAgICAgICAgICAg ZGF0YSA9IE5VTEw7CisgICAgICAgICAgZWxzZQorI2VuZGlmCisgICAgICAg ICAgICBkYXRhID0gZWxmX2dldGRhdGFfcmF3Y2h1bmsgKGVibC0+ZWxmLCBi dWNrZXRzX2F0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBuYnVja2V0cyAqIHNpemVvZiAoRWxmMzJfV29yZCksCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEVMRl9UX1dP UkQpOworICAgICAgICAgIGlmIChkYXRhICE9IE5VTEwgJiYgc3ltbmR4IDwg bmJ1Y2tldHMpCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgIGNvbnN0 IEVsZjMyX1dvcmQgKmNvbnN0IGJ1Y2tldHMgPSBkYXRhLT5kX2J1ZjsKKyAg ICAgICAgICAgICAgRWxmMzJfV29yZCBtYXhuZHggPSBzeW1uZHg7CisgICAg ICAgICAgICAgIGZvciAoRWxmMzJfV29yZCBidWNrZXQgPSAwOyBidWNrZXQg PCBuYnVja2V0czsgKytidWNrZXQpCisgICAgICAgICAgICAgICAgaWYgKGJ1 Y2tldHNbYnVja2V0XSA+IG1heG5keCkKKyAgICAgICAgICAgICAgICAgIG1h eG5keCA9IGJ1Y2tldHNbYnVja2V0XTsKKworICAgICAgICAgICAgICBHRWxm X09mZiBoYXNoYXJyX2F0CisgICAgICAgICAgICAgICAgICA9IChidWNrZXRz X2F0ICsgbmJ1Y2tldHMgKiBzaXplb2YgKEVsZjMyX1dvcmQpKTsKKyAgICAg ICAgICAgICAgaGFzaGFycl9hdCArPSAobWF4bmR4IC0gc3ltbmR4KSAqIHNp emVvZiAoRWxmMzJfV29yZCk7CisgICAgICAgICAgICAgIGRvCisgICAgICAg ICAgICAgICAgeworICAgICAgICAgICAgICAgICAgZGF0YSA9IGVsZl9nZXRk YXRhX3Jhd2NodW5rICgKKyAgICAgICAgICAgICAgICAgICAgICBlYmwtPmVs ZiwgaGFzaGFycl9hdCwgc2l6ZW9mIChFbGYzMl9Xb3JkKSwgRUxGX1RfV09S RCk7CisgICAgICAgICAgICAgICAgICBpZiAoZGF0YSAhPSBOVUxMICYmICgq KGNvbnN0IEVsZjMyX1dvcmQgKilkYXRhLT5kX2J1ZiAmIDF1KSkKKyAgICAg ICAgICAgICAgICAgICAgeworICAgICAgICAgICAgICAgICAgICAgIHN5bWVu dHMgPSBtYXhuZHggKyAxOworICAgICAgICAgICAgICAgICAgICAgIGJyZWFr OworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAr K21heG5keDsKKyAgICAgICAgICAgICAgICAgIGhhc2hhcnJfYXQgKz0gc2l6 ZW9mIChFbGYzMl9Xb3JkKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAg ICAgICAgIHdoaWxlIChkYXRhICE9IE5VTEwpOworICAgICAgICAgICAgfQor ICAgICAgICB9CisgICAgfQorICBpZiAob2Zmc1tpX3N0cnRhYl0gPiBvZmZz W2lfc3ltdGFiXSAmJiBzeW1lbnRzID09IDApCisgICAgc3ltZW50cyA9ICgo b2Zmc1tpX3N0cnRhYl0gLSBvZmZzW2lfc3ltdGFiXSkKKyAgICAgICAgICAg ICAgIC8gZ2VsZl9mc2l6ZSAoZWJsLT5lbGYsIEVMRl9UX1NZTSwgMSwgRVZf Q1VSUkVOVCkpOwogCi0JCSAgICAgIHZkX29mZnNldCArPSB2ZXJkZWYtPnZk X25leHQ7Ci0JCSAgICAgIHZlcmRlZiA9ICh2ZXJkZWYtPnZkX25leHQgPT0g MAotCQkJCT8gTlVMTAotCQkJCTogZ2VsZl9nZXR2ZXJkZWYgKHZlcmRlZl9k YXRhLCB2ZF9vZmZzZXQsCi0JCQkJCQkgICZ2ZXJkZWZfbWVtKSk7Ci0JCSAg ICB9CisgIGlmIChzeW1lbnRzIDw9IDAgfHwgb2Zmc1tpX3N0cnRhYl0gPT0g MCB8fCBvZmZzW2lfc3ltdGFiXSA9PSAwKQorICAgIHsKKyAgICAgIGVycm9y X2V4aXQgKDAsIF8gKCJEeW5hbWljIHN5bWJvbCBpbmZvcm1hdGlvbiBpcyBu b3QgYXZhaWxhYmxlIGZvciAiCisgICAgICAgICAgICAgICAgICAgICAgICAi ZGlzcGxheWluZyBzeW1ib2xzLiIpKTsKKyAgICB9CiAKLQkJICBpZiAodmVy ZGVmICE9IE5VTEwpCi0JCSAgICB7Ci0JCSAgICAgIEdFbGZfVmVyZGF1eCB2 ZXJkYXV4X21lbTsKLQkJICAgICAgR0VsZl9WZXJkYXV4ICp2ZXJkYXV4Ci0J CQk9IGdlbGZfZ2V0dmVyZGF1eCAodmVyZGVmX2RhdGEsCi0JCQkJCSAgIHZk X29mZnNldCArIHZlcmRlZi0+dmRfYXV4LAotCQkJCQkgICAmdmVyZGF1eF9t ZW0pOwotCi0JCSAgICAgIGlmICh2ZXJkYXV4ICE9IE5VTEwpCi0JCQlwcmlu dGYgKCgqdmVyc3ltICYgMHg4MDAwKSA/ICJAJXMiIDogIkBAJXMiLAotCQkJ CWVsZl9zdHJwdHIgKGVibC0+ZWxmLCB2ZXJkZWZfc3RyaWR4LAotCQkJCQkg ICAgdmVyZGF1eC0+dmRhX25hbWUpKTsKLQkJICAgIH0KLQkJfQotCSAgICB9 Ci0JfQorICAvKiBBbGwgdGhlIGRhdGEgY2h1bmsgaW5pdGlhbGl6YWlvbi4g ICovCisgIEVsZl9EYXRhICpzeW1kYXRhID0gTlVMTDsKKyAgRWxmX0RhdGEg KnN5bXN0cmRhdGEgPSBOVUxMOworICBFbGZfRGF0YSAqdmVyc3ltX2RhdGEg PSBOVUxMOworICBFbGZfRGF0YSAqdmVyZGVmX2RhdGEgPSBOVUxMOworICBF bGZfRGF0YSAqdmVybmVlZF9kYXRhID0gTlVMTDsKIAotICAgICAgcHV0Y2hh cl91bmxvY2tlZCAoJ1xuJyk7Ci0gICAgfQorICBzeW1kYXRhID0gZWxmX2dl dGRhdGFfcmF3Y2h1bmsgKAorICAgICAgZWJsLT5lbGYsIG9mZnNbaV9zeW10 YWJdLAorICAgICAgZ2VsZl9mc2l6ZSAoZWJsLT5lbGYsIEVMRl9UX1NZTSwg c3ltZW50cywgRVZfQ1VSUkVOVCksIEVMRl9UX1NZTSk7CisgIHN5bXN0cmRh dGEgPSBlbGZfZ2V0ZGF0YV9yYXdjaHVuayAoZWJsLT5lbGYsIG9mZnNbaV9z dHJ0YWJdLCBhZGRyc1tpX3N0cnN6XSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBFTEZfVF9CWVRFKTsKKyAgdmVyc3ltX2RhdGEg PSBlbGZfZ2V0ZGF0YV9yYXdjaHVuayAoCisgICAgICBlYmwtPmVsZiwgb2Zm c1tpX3ZlcnN5bV0sIHN5bWVudHMgKiBzaXplb2YgKEVsZjY0X0hhbGYpLCBF TEZfVF9IQUxGKTsKKworICAvKiBHZXQgdGhlIHZlcm5lZWRfZGF0YSB3aXRo b3V0IHZlcm5hdXguICAqLworICB2ZXJuZWVkX2RhdGEgPSBlbGZfZ2V0ZGF0 YV9yYXdjaHVuayAoCisgICAgICBlYmwtPmVsZiwgb2Zmc1tpX3Zlcm5lZWRd LCBhZGRyc1tpX3Zlcm5lZWRudW1dICogc2l6ZW9mIChFbGY2NF9WZXJuZWVk KSwKKyAgICAgIEVMRl9UX1ZORUVEKTsKKyAgc2l6ZV90IHZlcm5hdXhudW0g PSAwOworICBzaXplX3Qgdm5fbmV4dF9vZmZzZXQgPSAwOworCisgIGZvciAo c2l6ZV90IGkgPSAwOyBpIDwgYWRkcnNbaV92ZXJuZWVkbnVtXTsgaSsrKQor ICAgIHsKKyAgICAgIEdFbGZfVmVybmVlZCAqdmVybmVlZAorICAgICAgICAg ID0gKEdFbGZfVmVybmVlZCAqKSh2ZXJuZWVkX2RhdGEtPmRfYnVmICsgdm5f bmV4dF9vZmZzZXQpOworICAgICAgdmVybmF1eG51bSArPSB2ZXJuZWVkLT52 bl9jbnQ7CisgICAgICB2bl9uZXh0X29mZnNldCArPSB2ZXJuZWVkLT52bl9u ZXh0OworICAgIH0KKworICAvKiBVcGRhdGUgdGhlIHZlcm5lZWRfZGF0YSB0 byBpbmNsdWRlIHRoZSB2ZXJuYXV4LiAgKi8KKyAgdmVybmVlZF9kYXRhID0g ZWxmX2dldGRhdGFfcmF3Y2h1bmsgKAorICAgICAgZWJsLT5lbGYsIG9mZnNb aV92ZXJuZWVkXSwKKyAgICAgIChhZGRyc1tpX3Zlcm5lZWRudW1dICsgdmVy bmF1eG51bSkgKiBzaXplb2YgKEdFbGZfVmVybmVlZCksIEVMRl9UX1ZORUVE KTsKKworICAvKiBHZXQgdGhlIHZlcmRlZl9kYXRhIHdpdGhvdXQgdmVyZGF1 eC4gICovCisgIHZlcmRlZl9kYXRhID0gZWxmX2dldGRhdGFfcmF3Y2h1bmsg KAorICAgICAgZWJsLT5lbGYsIG9mZnNbaV92ZXJkZWZdLCBhZGRyc1tpX3Zl cmRlZm51bV0gKiBzaXplb2YgKEVsZjY0X1ZlcmRlZiksCisgICAgICBFTEZf VF9WREVGKTsKKyAgc2l6ZV90IHZlcmRhdXhudW0gPSAwOworICBzaXplX3Qg dmRfbmV4dF9vZmZzZXQgPSAwOworCisgIGZvciAoc2l6ZV90IGkgPSAwOyBp IDwgYWRkcnNbaV92ZXJkZWZudW1dOyBpKyspCisgICAgeworICAgICAgR0Vs Zl9WZXJkZWYgKnZlcmRlZgorICAgICAgICAgID0gKEdFbGZfVmVyZGVmICop KHZlcmRlZl9kYXRhLT5kX2J1ZiArIHZkX25leHRfb2Zmc2V0KTsKKyAgICAg IHZlcmRhdXhudW0gKz0gdmVyZGVmLT52ZF9jbnQ7CisgICAgICB2ZF9uZXh0 X29mZnNldCArPSB2ZXJkZWYtPnZkX25leHQ7CisgICAgfQorCisgIC8qIFVw ZGF0ZSB0aGUgdmVyZGVmX2RhdGEgdG8gaW5jbHVkZSB0aGUgdmVyZGF1eC4g ICovCisgIHZlcmRlZl9kYXRhID0gZWxmX2dldGRhdGFfcmF3Y2h1bmsgKAor ICAgICAgZWJsLT5lbGYsIG9mZnNbaV92ZXJkZWZdLAorICAgICAgKGFkZHJz W2lfdmVyZGVmbnVtXSArIHZlcmRhdXhudW0pICogc2l6ZW9mIChHRWxmX1Zl cmRlZiksIEVMRl9UX1ZERUYpOworCisgIHVuc2lnbmVkIGludCBuc3ltcyA9 ICh1bnNpZ25lZCBpbnQpc3ltZW50czsKKyAgcHJvY2Vzc19zeW10YWIgKGVi bCwgbnN5bXMsIDAsIDAsIDAsIHN5bWRhdGEsIHZlcnN5bV9kYXRhLCBzeW1z dHJkYXRhLAorICAgICAgICAgICAgICAgICAgdmVybmVlZF9kYXRhLCB2ZXJk ZWZfZGF0YSwgTlVMTCk7CisgIHJldHVybiB0cnVlOwogfQogCiAKQEAgLTQ5 OTAsMTMgKzUyMDgsMjQgQEAgZ2V0X2R5bnNjbl9hZGRycyhFbGYgKmVsZiwg R0VsZl9QaGRyICpwaGRyLCBHRWxmX0FkZHIgYWRkcnNbaV9tYXhdKQogICAg ICAgYWRkcnNbaV92ZXJkZWZdID0gZHluLT5kX3VuLmRfcHRyOwogICAgICAg YnJlYWs7CiAKKyAgICBjYXNlIERUX1ZFUkRFRk5VTToKKyAgICAgIGFkZHJz W2lfdmVyZGVmbnVtXSA9IGR5bi0+ZF91bi5kX3ZhbDsKKyAgICAgIGJyZWFr OworCiAgICAgY2FzZSBEVF9WRVJORUVEOgogICAgICAgYWRkcnNbaV92ZXJu ZWVkXSA9IGR5bi0+ZF91bi5kX3B0cjsKICAgICAgIGJyZWFrOwogCisgICAg Y2FzZSBEVF9WRVJORUVETlVNOgorICAgICAgYWRkcnNbaV92ZXJuZWVkbnVt XSA9IGR5bi0+ZF91bi5kX3ZhbDsKKyAgICAgIGJyZWFrOworCiAgICAgY2Fz ZSBEVF9TVFJTWjoKICAgICAgIGFkZHJzW2lfc3Ryc3pdID0gZHluLT5kX3Vu LmRfdmFsOwogICAgICAgYnJlYWs7CisgICAgY2FzZSBEVF9TWU1UQUJfU0hO RFg6CisgICAgICBhZGRyc1tpX3N5bXRhYl9zaG5keF0gPSBkeW4tPmRfdW4u ZF9wdHI7CisgICAgICBicmVhazsKICAgICB9CiAgIH0KIH0KLS0gCjIuMzku MgoK --0000000000001ec2c205f8500d1d--