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 2A0293858C5F for ; Fri, 10 Feb 2023 16:17:41 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 2A0293858C5F 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=1676045860; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type; bh=kHb+3eyr9B3SXjPrrRQBwDKVU51+ZTeEKbuY2ZdhyKc=; b=N05V5+dqZuQPeXSv4AYp8YMXKJUABJ5IcMfWNdVf196CFJ5Mq1NIusHDJZ/qB80whHzJ0K Th+qUlCQr7JChsGNAyfgXoLdyPOkZcyDjJr9ZBr0RmhZMtjdPJBdDtgKWcTp1mfKNSHAre GdFgSNCSRtuRHOeLoVcGCbLV7fSsbp0= Received: from mail-lf1-f69.google.com (mail-lf1-f69.google.com [209.85.167.69]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-267-M6k5wRhAMUG_3gFG7kEQpA-1; Fri, 10 Feb 2023 11:17:38 -0500 X-MC-Unique: M6k5wRhAMUG_3gFG7kEQpA-1 Received: by mail-lf1-f69.google.com with SMTP id l15-20020a056512110f00b004b6fe4513b7so2481864lfg.23 for ; Fri, 10 Feb 2023 08:17:38 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=to:subject:message-id:date:from:mime-version:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=2253CZZk8w0pAyMhNFvx0I3Qiu1XMd3QPmqbgLiJtKo=; b=IT8KeD+J/FMUy/Fl3JkoYqfMSoYiP53Roxbydn850t7Svf3bJAWApQGBHk2Er66PiD 069JfXFnbrdB//3tL30GNULqBZgWqMw9xZ9WgTxvsQqmQc8JKeg07Go3rnaZML8v7W4R yzJKElk+WJaTqkqAg5jZtA1xiVmuayGJUDuy1WiVKmqTNPEfL2NYtMjARoNohB/99mAc JVBxLUN2Ylti1JUu3CTu0varbHHfGmk/LQjeLHzTaBtzfNM2DvwDmm/ZxaEpC/KHG/s3 Sv76p6RWTC/hnifcyy82ClBrECGMC+RbmRLkbpVnemAcXUBl1KmHESrFUn/iI0rX4gBi 6SbA== X-Gm-Message-State: AO0yUKWZOOXdjnPt3TMTwvRK2EVWg1ZFOX9Lj6UrK/9Fv5a8cTUNO9Xh Gw4Y3mEhFmlcE2+W3YVQ9L2xkYpJJZg0IQlfJJYxp3Eht5MnklH790ycynkiV6vj4nwlI1TcGIW wblhbvm/N5Y6zLV/fbUNVUcfU4ri8uIDwOOklgPopaWPl7VNUaA+j1rs= X-Received: by 2002:a05:651c:1054:b0:293:341d:b765 with SMTP id x20-20020a05651c105400b00293341db765mr1019365ljm.90.1676045857031; Fri, 10 Feb 2023 08:17:37 -0800 (PST) X-Google-Smtp-Source: AK7set+bG8XEcgCjxTqdsKeS2O/hbFDli19vUNMtOfCgqxlD9Rv2d5dkBANuDRU+kiNbMVsKJV3ogCzBajp5GQCf1sQ= X-Received: by 2002:a05:651c:1054:b0:293:341d:b765 with SMTP id x20-20020a05651c105400b00293341db765mr1019359ljm.90.1676045856602; Fri, 10 Feb 2023 08:17:36 -0800 (PST) MIME-Version: 1.0 From: Di Chen Date: Sat, 11 Feb 2023 00:17:24 +0800 Message-ID: Subject: [PATCH] PR28873 - Implement eu-readelf -D To: elfutils-devel@sourceware.org X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="000000000000e93a9705f45ad597" X-Spam-Status: No, score=-12.6 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,HTML_MESSAGE,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: --000000000000e93a9705f45ad597 Content-Type: multipart/alternative; boundary="000000000000e93a9605f45ad595" --000000000000e93a9605f45ad595 Content-Type: text/plain; charset="UTF-8" >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=28873 Signed-off-by: Di Chen --- src/readelf.c | 289 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 283 insertions(+), 6 deletions(-) diff --git a/src/readelf.c b/src/readelf.c index 451f8400..9e1e9b73 100644 --- a/src/readelf.c +++ b/src/readelf.c @@ -307,7 +307,8 @@ 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 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); @@ -327,7 +328,9 @@ enum dyn_idx { i_strsz, i_verneed, + i_verneednum, i_verdef, + i_verdefnum, i_versym, i_symtab, i_strtab, @@ -1042,7 +1045,7 @@ process_elf_file (Dwfl_Module *dwflmod, int fd) symtab_printed |= 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 |= print_symtab (ebl, SHT_SYMTAB); if ((print_symbol_table || print_dynsym_table) @@ -2442,6 +2445,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 == 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 = NULL; @@ -2480,16 +2489,275 @@ 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 = true; + symtab_printed = handle_symtab (ebl, scn, shdr); } } return symtab_printed; } +static bool +handle_dynamic_symtab (Ebl *ebl) +{ + GElf_Phdr *phdr = NULL; + /* phnum is a static variable which already fetched in function process_elf_file. */ + for (size_t i = 0; i < phnum; ++i) { + GElf_Phdr phdr_mem; + phdr = gelf_getphdr(ebl->elf, i, &phdr_mem); + if (phdr->p_type == PT_DYNAMIC) { + break; + } + } + if (phdr == NULL) + return false; -static void + GElf_Addr addrs[i_max] = {0,}; + GElf_Off offs[i_max] = {0,}; + get_dynscn_addrs(ebl->elf, phdr, addrs); + find_offsets(ebl->elf, 0, i_max, addrs, offs); + + size_t syments; + + GElf_Ehdr ehdr_mem; + GElf_Ehdr *ehdr = gelf_getehdr(ebl->elf, &ehdr_mem); + + if (offs[i_hash] != 0) { + /* In the original format, .hash says the size of .dynsym. */ + + size_t entsz = SH_ENTSIZE_HASH(ehdr); + Elf_Data *data = + elf_getdata_rawchunk(ebl->elf, offs[i_hash] + entsz, entsz, + (entsz == 4 ? ELF_T_WORD : ELF_T_XWORD)); + if (data != NULL) + syments = (entsz == 4 ? *(const GElf_Word *)data->d_buf + : *(const GElf_Xword *)data->d_buf); + } + if (offs[i_gnu_hash] != 0 && syments == 0) { + /* In the new format, we can derive it with some work. */ + + const struct { + Elf32_Word nbuckets; + Elf32_Word symndx; + Elf32_Word maskwords; + Elf32_Word shift2; + } * header; + + Elf_Data *data = elf_getdata_rawchunk(ebl->elf, offs[i_gnu_hash], + sizeof *header, ELF_T_WORD); + if (data != NULL) { + header = data->d_buf; + Elf32_Word nbuckets = header->nbuckets; + Elf32_Word symndx = header->symndx; + GElf_Off buckets_at = (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 <= UINT32_MAX + if (nbuckets > SIZE_MAX / sizeof(Elf32_Word)) + data = NULL; + else + #endif + data = elf_getdata_rawchunk(ebl->elf, buckets_at, + nbuckets * sizeof(Elf32_Word), ELF_T_WORD); + if (data != NULL && symndx < nbuckets) { + const Elf32_Word *const buckets = data->d_buf; + Elf32_Word maxndx = symndx; + for (Elf32_Word bucket = 0; bucket < nbuckets; ++bucket) + if (buckets[bucket] > maxndx) + maxndx = buckets[bucket]; + + GElf_Off hasharr_at = (buckets_at + nbuckets * sizeof(Elf32_Word)); + hasharr_at += (maxndx - symndx) * sizeof(Elf32_Word); + do { + data = elf_getdata_rawchunk(ebl->elf, hasharr_at, + sizeof(Elf32_Word), ELF_T_WORD); + if (data != NULL && (*(const Elf32_Word *)data->d_buf & 1u)) { + syments = maxndx + 1; + break; + } + ++maxndx; + hasharr_at += sizeof(Elf32_Word); + } while (data != NULL); + } + } + } + if (offs[i_strtab] > offs[i_symtab] && syments == 0) + syments = ((offs[i_strtab] - offs[i_symtab]) / + gelf_fsize(ebl->elf, ELF_T_SYM, 1, EV_CURRENT)); + + if (syments <= 0 || offs[i_strtab] == 0 || offs[i_symtab] == 0) { + error_exit(0, _("Dynamic symbol information is not available for displaying symbols.")); + } + + /* All the data chunk initializaion. */ + Elf_Data *symdata = NULL; + Elf_Data *symstrdata = NULL; + Elf_Data *versym_data = NULL; + Elf_Data *verdef_data = NULL; + Elf_Data *verneed_data = NULL; + + symdata = elf_getdata_rawchunk( + ebl->elf, offs[i_symtab], + gelf_fsize(ebl->elf, ELF_T_SYM, syments, EV_CURRENT), ELF_T_SYM); + symstrdata = elf_getdata_rawchunk(ebl->elf, offs[i_strtab], addrs[i_strsz], + ELF_T_BYTE); + versym_data = elf_getdata_rawchunk(ebl->elf, offs[i_versym], + syments * sizeof(Elf64_Half), ELF_T_HALF); + + /* Get the verneed_data without vernaux. */ + verneed_data = elf_getdata_rawchunk( + ebl->elf, offs[i_verneed], addrs[i_verneednum] * sizeof(Elf64_Verneed), + ELF_T_VNEED); + size_t vernauxnum = 0; + size_t vn_next_offset = 0; + + for (size_t i = 0; i < addrs[i_verneednum]; i++) { + GElf_Verneed *verneed = + (GElf_Verneed *)(verneed_data->d_buf + vn_next_offset); + vernauxnum += verneed->vn_cnt; + vn_next_offset += verneed->vn_next; + } + + /* Update the verneed_data to include the vernaux. */ + verneed_data = 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 = elf_getdata_rawchunk(ebl->elf, offs[i_verdef], + addrs[i_verdefnum] * sizeof(Elf64_Verdef), + ELF_T_VDEF); + size_t verdauxnum = 0; + size_t vd_next_offset = 0; + + for (size_t i = 0; i < addrs[i_verdefnum]; i++) { + GElf_Verdef *verdef = (GElf_Verdef *)(verdef_data->d_buf + vd_next_offset); + verdauxnum += verdef->vd_cnt; + vd_next_offset += verdef->vd_next; + } + + /* Update the verdef_data to include the verdaux. */ + verdef_data = elf_getdata_rawchunk( + ebl->elf, offs[i_verdef], + (addrs[i_verdefnum] + verdauxnum) * sizeof(GElf_Verdef), ELF_T_VDEF); + + for (size_t i = 0; i < syments; i++) { + /* Get the symbol table entry. */ + GElf_Sym sym_mem; + GElf_Sym *sym; + sym = gelf_getsym(symdata, i, &sym_mem); + + char bindbuf[64]; + char typebuf[64]; + char scnbuf[64]; + int class = gelf_getclass(ebl->elf); + Elf32_Word xndx; + xndx = sym->st_shndx; + + printf(_("\ +%5ld: %0*" PRIx64 " %6" PRId64 " %-7s %-6s %-9s %6s %s"), + i, class == 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), + ((char *)symstrdata->d_buf) + sym->st_name); + + if (versym_data != NULL) { + /* Get the version information. */ + GElf_Versym versym_mem; + GElf_Versym *versym = gelf_getversym(versym_data, i, &versym_mem); + + if (versym != NULL && ((*versym & 0x8000) != 0 || *versym > 1)) { + GElf_Vernaux vernaux_mem; + GElf_Vernaux *vernaux = NULL; + size_t vn_offset = 0; + GElf_Verneed verneed_mem; + GElf_Verneed *verneed = (GElf_Verneed *)verneed_data->d_buf; + + while (verneed != NULL) { + size_t vna_offset = vn_offset; + + vernaux = gelf_getvernaux(verneed_data, vna_offset += verneed->vn_aux, + &vernaux_mem); + while (vernaux != NULL && vernaux->vna_other != *versym && + vernaux->vna_next != 0 && + (verneed_data->d_size - vna_offset >= vernaux->vna_next)) { + /* Update the offset. */ + vna_offset += vernaux->vna_next; + + vernaux = + (vernaux->vna_next == 0 + ? NULL + : gelf_getvernaux(verneed_data, vna_offset, &vernaux_mem)); + } + + /* Check whether we found the version. */ + if (vernaux != NULL && vernaux->vna_other == *versym) + /* Found it. */ + break; + + if (verneed_data->d_size - vn_offset < verneed->vn_next) + break; + + vn_offset += verneed->vn_next; + verneed = + (verneed->vn_next == 0 + ? NULL + : gelf_getverneed(verneed_data, vn_offset, &verneed_mem)); + } + + if (vernaux != NULL && vernaux->vna_other == *versym) { + printf("@%s (%u)", (char *)symstrdata->d_buf + vernaux->vna_name, + (unsigned int)vernaux->vna_other); + } + + if (addrs[i_verdefnum] && *versym != 0x8001) { + /* We must test both. */ + size_t vd_offset = 0; + + GElf_Verdef verdef_mem; + GElf_Verdef *verdef = gelf_getverdef(verdef_data, 0, &verdef_mem); + while (verdef != NULL) { + if (verdef->vd_ndx == (*versym & 0x7fff)) + /* Found the definition. */ + break; + + if (verdef_data->d_size - vd_offset < verdef->vd_next) + break; + + vd_offset += verdef->vd_next; + verdef = + (verdef->vd_next == 0 + ? NULL + : gelf_getverdef(verdef_data, vd_offset, &verdef_mem)); + } + + if (verdef != NULL) { + GElf_Verdaux verdaux_mem; + GElf_Verdaux *verdaux = gelf_getverdaux( + verdef_data, vd_offset + verdef->vd_aux, &verdaux_mem); + + if (verdaux != NULL) + printf((*versym & 0x8000) ? "@%s" : "@@%s", + (char *)symstrdata->d_buf + verdaux->vda_name); + } + } + } + } + putchar_unlocked('\n'); + } + return true; +} + + + +static bool handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr) { Elf_Data *versym_data = NULL; @@ -2503,7 +2771,7 @@ handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr) /* Get the data of the section. */ Elf_Data *data = elf_getdata (scn, NULL); if (data == NULL) - return; + return false; /* Find out whether we have other sections we might need. */ Elf_Scn *runscn = NULL; @@ -2730,6 +2998,7 @@ handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr) putchar_unlocked ('\n'); } + return true; } @@ -4955,10 +5224,18 @@ get_dynscn_addrs(Elf *elf, GElf_Phdr *phdr, GElf_Addr addrs[i_max]) addrs[i_verdef] = dyn->d_un.d_ptr; break; + case DT_VERDEFNUM: + addrs[i_verdefnum] = dyn->d_un.d_val; + break; + case DT_VERNEED: addrs[i_verneed] = dyn->d_un.d_ptr; break; + case DT_VERNEEDNUM: + addrs[i_verneednum] = dyn->d_un.d_val; + break; + case DT_STRSZ: addrs[i_strsz] = dyn->d_un.d_val; break; -- 2.39.1 --000000000000e93a9605f45ad595-- --000000000000e93a9705f45ad597 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_ldyqexox0 RnJvbSBiZGMxOWRlOTRiZmY4Zjg4MTI2MTFiOWJhOGMwMTE2YTY1MGQwZmI1 IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEaSBDaGVuIDxkaWNo ZW5AcmVkaGF0LmNvbT4KRGF0ZTogRnJpLCAxMyBKYW4gMjAyMyAyMDoxMjo0 MyArMDgwMApTdWJqZWN0OiBbUEFUQ0hdIHJlYWRlbGY6IGRpc3BsYXkgZHlu YW1pYyBzeW10YWIgd2l0aG91dCBzZWN0aW9uIGhlYWRlcnMKClRoaXMgY29t bWl0IGFkZHMgYSBuZXcgb3B0aW9uICItRC8tLXVzZS1keW5hbWljIiB0byBz dXBwb3J0IHByaW50aW5nIHRoZQpkeW5hbWljIHN5bWJvbCB0YWJsZSBmcm9t IHRoZSBQVF9EWU5BTUlDIHNlZ21lbnQuIEJ5IHVzaW5nIHRoZQpQVF9EWU5B TUlDIHNlZ21lbnQsIGV1LXJlYWRlbGYgY2FuIGdvIHRocm91Z2ggdGhlIGNv bnRlbnRzIG9mIGR5bmFtaWMKc2VjdGlvbiBlbnRyaWVzIGFuZCB0aGUgdmFs dWVzIG9mIGVhY2ggdGFnLiBGcm9tIHRoYXQsIHdlIGNhbiBnZXQgdGhlCmFk ZHJlc3MgYW5kIHNpemUgb2YgdGhlIGR5bmFtaWMgc3ltYm9sIHRhYmxlLCB0 aGUgYWRkcmVzcyBvZiB0aGUgc3RyaW5nCnRhYmxlLCBldGMuCgpCeSB1c2lu ZyB0aGUgbmV3IG9wdGlvbiAiLUQvLS11c2UtZHluYW1pYyIsIGV1LXJlYWRl bGYgY2FuIGxpc3QgdGhlCnN5bWJvbHMgd2l0aG91dCBzZWN0aW9uIGhlYWRl cnMuCgpFeGFtcGxlOgogICQgLi9zcmMvcmVhZGVsZiAtRHMgYS5vdXQKICAg ICAgMDogMDAwMDAwMDAwMDAwMDAwMCAgICAgIDAgTk9UWVBFICBMT0NBTCAg REVGQVVMVCAgICBVTkRFRgogICAgICAxOiAwMDAwMDAwMDAwMDAwMDAwICAg ICAgMCBGVU5DICAgIEdMT0JBTCBERUZBVUxUICAgIFVOREVGIF9fbGliY19z dGFydF9tYWluQEdMSUJDXzIuMzQgKDIpCiAgICAgIDI6IDAwMDAwMDAwMDAw MDAwMDAgICAgICAwIE5PVFlQRSAgV0VBSyAgIERFRkFVTFQgICAgVU5ERUYg X19nbW9uX3N0YXJ0X18KCmh0dHBzOi8vc291cmNld2FyZS5vcmcvYnVnemls bGEvc2hvd19idWcuY2dpP2lkPTI4ODczCgpTaWduZWQtb2ZmLWJ5OiBEaSBD aGVuIDxkaWNoZW5AcmVkaGF0LmNvbT4KLS0tCiBzcmMvcmVhZGVsZi5jIHwg Mjg5ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKy0tCiAxIGZpbGUgY2hhbmdlZCwgMjgzIGluc2VydGlvbnMoKyks IDYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL3JlYWRlbGYuYyBi L3NyYy9yZWFkZWxmLmMKaW5kZXggNDUxZjg0MDAuLjllMWU5YjczIDEwMDY0 NAotLS0gYS9zcmMvcmVhZGVsZi5jCisrKyBiL3NyYy9yZWFkZWxmLmMKQEAg LTMwNyw3ICszMDcsOCBAQCBzdGF0aWMgdm9pZCBoYW5kbGVfcmVsb2NzX3Jl bCAoRWJsICplYmwsIEdFbGZfRWhkciAqZWhkciwgRWxmX1NjbiAqc2NuLAog c3RhdGljIHZvaWQgaGFuZGxlX3JlbG9jc19yZWxhIChFYmwgKmVibCwgR0Vs Zl9FaGRyICplaGRyLCBFbGZfU2NuICpzY24sCiAJCQkJR0VsZl9TaGRyICpz aGRyKTsKIHN0YXRpYyBib29sIHByaW50X3N5bXRhYiAoRWJsICplYmwsIGlu dCB0eXBlKTsKLXN0YXRpYyB2b2lkIGhhbmRsZV9zeW10YWIgKEVibCAqZWJs LCBFbGZfU2NuICpzY24sIEdFbGZfU2hkciAqc2hkcik7CitzdGF0aWMgYm9v bCBoYW5kbGVfc3ltdGFiIChFYmwgKmVibCwgRWxmX1NjbiAqc2NuLCBHRWxm X1NoZHIgKnNoZHIpOworc3RhdGljIGJvb2wgaGFuZGxlX2R5bmFtaWNfc3lt dGFiIChFYmwgKmVibCk7CiBzdGF0aWMgdm9pZCBwcmludF92ZXJpbmZvIChF YmwgKmVibCk7CiBzdGF0aWMgdm9pZCBoYW5kbGVfdmVybmVlZCAoRWJsICpl YmwsIEVsZl9TY24gKnNjbiwgR0VsZl9TaGRyICpzaGRyKTsKIHN0YXRpYyB2 b2lkIGhhbmRsZV92ZXJkZWYgKEVibCAqZWJsLCBFbGZfU2NuICpzY24sIEdF bGZfU2hkciAqc2hkcik7CkBAIC0zMjcsNyArMzI4LDkgQEAgZW51bSBkeW5f aWR4CiB7CiAgIGlfc3Ryc3osCiAgIGlfdmVybmVlZCwKKyAgaV92ZXJuZWVk bnVtLAogICBpX3ZlcmRlZiwKKyAgaV92ZXJkZWZudW0sCiAgIGlfdmVyc3lt LAogICBpX3N5bXRhYiwKICAgaV9zdHJ0YWIsCkBAIC0xMDQyLDcgKzEwNDUs NyBAQCBwcm9jZXNzX2VsZl9maWxlIChEd2ZsX01vZHVsZSAqZHdmbG1vZCwg aW50IGZkKQogICAgIHN5bXRhYl9wcmludGVkIHw9IHByaW50X3N5bXRhYiAo ZWJsLCBTSFRfRFlOU1lNKTsKICAgaWYgKHByaW50X3ZlcnNpb25faW5mbykK ICAgICBwcmludF92ZXJpbmZvIChlYmwpOwotICBpZiAocHJpbnRfc3ltYm9s X3RhYmxlKQorICBpZiAocHJpbnRfc3ltYm9sX3RhYmxlICYmICF1c2VfZHlu YW1pY19zZWdtZW50KQogICAgIHN5bXRhYl9wcmludGVkIHw9IHByaW50X3N5 bXRhYiAoZWJsLCBTSFRfU1lNVEFCKTsKIAogICBpZiAoKHByaW50X3N5bWJv bF90YWJsZSB8fCBwcmludF9keW5zeW1fdGFibGUpCkBAIC0yNDQyLDYgKzI0 NDUsMTIgQEAgaGFuZGxlX3JlbG9jc19yZWxhIChFYmwgKmVibCwgR0VsZl9F aGRyICplaGRyLCBFbGZfU2NuICpzY24sIEdFbGZfU2hkciAqc2hkcikKIHN0 YXRpYyBib29sCiBwcmludF9zeW10YWIgKEVibCAqZWJsLCBpbnQgdHlwZSkK IHsKKyAgLyogVXNlIHRoZSBkeW5hbWljIHNlY3Rpb24gaW5mbyB0byBkaXNw bGF5IHN5bWJvbCB0YWJsZXMuICAqLworICBpZiAodXNlX2R5bmFtaWNfc2Vn bWVudCAmJiB0eXBlID09IFNIVF9EWU5TWU0pCisgIHsKKwlyZXR1cm4gaGFu ZGxlX2R5bmFtaWNfc3ltdGFiKGVibCk7CisgIH0KKwogICAvKiBGaW5kIHRo ZSBzeW1ib2wgdGFibGUocykuICBGb3IgdGhpcyB3ZSBoYXZlIHRvIHNlYXJj aCB0aHJvdWdoIHRoZQogICAgICBzZWN0aW9uIHRhYmxlLiAgKi8KICAgRWxm X1NjbiAqc2NuID0gTlVMTDsKQEAgLTI0ODAsMTYgKzI0ODksMjc1IEBAIHBy aW50X3N5bXRhYiAoRWJsICplYmwsIGludCB0eXBlKQogCQkJICAgIF8oImNh bm5vdCBnZXQgc2VjdGlvbiBbJXpkXSBoZWFkZXI6ICVzIiksCiAJCQkgICAg ZWxmX25keHNjbiAoc2NuKSwgZWxmX2Vycm1zZyAoLTEpKTsKIAkgICAgfQot CSAgaGFuZGxlX3N5bXRhYiAoZWJsLCBzY24sIHNoZHIpOwotCSAgc3ltdGFi X3ByaW50ZWQgPSB0cnVlOworCSAgc3ltdGFiX3ByaW50ZWQgPSBoYW5kbGVf c3ltdGFiIChlYmwsIHNjbiwgc2hkcik7CiAJfQogICAgIH0KIAogICByZXR1 cm4gc3ltdGFiX3ByaW50ZWQ7CiB9CiAKK3N0YXRpYyBib29sCitoYW5kbGVf ZHluYW1pY19zeW10YWIgKEVibCAqZWJsKQoreworICBHRWxmX1BoZHIgKnBo ZHIgPSBOVUxMOworICAvKiBwaG51bSBpcyBhIHN0YXRpYyB2YXJpYWJsZSB3 aGljaCBhbHJlYWR5IGZldGNoZWQgaW4gZnVuY3Rpb24gcHJvY2Vzc19lbGZf ZmlsZS4gICovCisgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgcGhudW07ICsr aSkgeworICAgIEdFbGZfUGhkciBwaGRyX21lbTsKKyAgICBwaGRyID0gZ2Vs Zl9nZXRwaGRyKGVibC0+ZWxmLCBpLCAmcGhkcl9tZW0pOworICAgIGlmIChw aGRyLT5wX3R5cGUgPT0gUFRfRFlOQU1JQykgeworICAgICAgYnJlYWs7Cisg ICAgfQorICB9CisgIGlmIChwaGRyID09IE5VTEwpCisJcmV0dXJuIGZhbHNl OwogCi1zdGF0aWMgdm9pZAorICBHRWxmX0FkZHIgYWRkcnNbaV9tYXhdID0g ezAsfTsKKyAgR0VsZl9PZmYgb2Zmc1tpX21heF0gPSB7MCx9OworICBnZXRf ZHluc2NuX2FkZHJzKGVibC0+ZWxmLCBwaGRyLCBhZGRycyk7CisgIGZpbmRf b2Zmc2V0cyhlYmwtPmVsZiwgMCwgaV9tYXgsIGFkZHJzLCBvZmZzKTsKKwor ICBzaXplX3Qgc3ltZW50czsKKworICBHRWxmX0VoZHIgZWhkcl9tZW07Cisg IEdFbGZfRWhkciAqZWhkciA9IGdlbGZfZ2V0ZWhkcihlYmwtPmVsZiwgJmVo ZHJfbWVtKTsKKworICBpZiAob2Zmc1tpX2hhc2hdICE9IDApIHsKKyAgICAv KiBJbiB0aGUgb3JpZ2luYWwgZm9ybWF0LCAuaGFzaCBzYXlzIHRoZSBzaXpl IG9mIC5keW5zeW0uICAqLworCisgICAgc2l6ZV90IGVudHN6ID0gU0hfRU5U U0laRV9IQVNIKGVoZHIpOworICAgIEVsZl9EYXRhICpkYXRhID0KKyAgICAg ICAgZWxmX2dldGRhdGFfcmF3Y2h1bmsoZWJsLT5lbGYsIG9mZnNbaV9oYXNo XSArIGVudHN6LCBlbnRzeiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgKGVudHN6ID09IDQgPyBFTEZfVF9XT1JEIDogRUxGX1RfWFdPUkQpKTsK KyAgICBpZiAoZGF0YSAhPSBOVUxMKQorICAgICAgc3ltZW50cyA9IChlbnRz eiA9PSA0ID8gKihjb25zdCBHRWxmX1dvcmQgKilkYXRhLT5kX2J1ZgorICAg ICAgICAgICAgICAgICAgICAgICAgICAgIDogKihjb25zdCBHRWxmX1h3b3Jk ICopZGF0YS0+ZF9idWYpOworICB9CisgIGlmIChvZmZzW2lfZ251X2hhc2hd ICE9IDAgJiYgc3ltZW50cyA9PSAwKSB7CisgICAgLyogSW4gdGhlIG5ldyBm b3JtYXQsIHdlIGNhbiBkZXJpdmUgaXQgd2l0aCBzb21lIHdvcmsuICAqLwor CisgICAgY29uc3Qgc3RydWN0IHsKKyAgICAgIEVsZjMyX1dvcmQgbmJ1Y2tl dHM7CisgICAgICBFbGYzMl9Xb3JkIHN5bW5keDsKKyAgICAgIEVsZjMyX1dv cmQgbWFza3dvcmRzOworICAgICAgRWxmMzJfV29yZCBzaGlmdDI7CisgICAg fSAqIGhlYWRlcjsKKworICAgIEVsZl9EYXRhICpkYXRhID0gZWxmX2dldGRh dGFfcmF3Y2h1bmsoZWJsLT5lbGYsIG9mZnNbaV9nbnVfaGFzaF0sCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzaXplb2Yg KmhlYWRlciwgRUxGX1RfV09SRCk7CisgICAgaWYgKGRhdGEgIT0gTlVMTCkg eworICAgICAgaGVhZGVyID0gZGF0YS0+ZF9idWY7CisgICAgICBFbGYzMl9X b3JkIG5idWNrZXRzID0gaGVhZGVyLT5uYnVja2V0czsKKyAgICAgIEVsZjMy X1dvcmQgc3ltbmR4ID0gaGVhZGVyLT5zeW1uZHg7CisgICAgICBHRWxmX09m ZiBidWNrZXRzX2F0ID0gKG9mZnNbaV9nbnVfaGFzaF0gKyBzaXplb2YgKmhl YWRlciArCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChnZWxmX2dl dGNsYXNzKGVibC0+ZWxmKSAqIHNpemVvZihFbGYzMl9Xb3JkKSAqCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBoZWFkZXItPm1hc2t3b3Jkcykp OworCisgICAgICAvLyBlbGZfZ2V0ZGF0YV9yYXdjaHVuayB0YWtlcyBhIHNp emVfdCwgbWFrZSBzdXJlIGl0CisgICAgICAvLyBkb2Vzbid0IG92ZXJmbG93 LgorICAjaWYgU0laRV9NQVggPD0gVUlOVDMyX01BWAorICAgICAgaWYgKG5i dWNrZXRzID4gU0laRV9NQVggLyBzaXplb2YoRWxmMzJfV29yZCkpCisgICAg ICAgIGRhdGEgPSBOVUxMOworICAgICAgZWxzZQorICAjZW5kaWYKKyAgICAg ICAgZGF0YSA9IGVsZl9nZXRkYXRhX3Jhd2NodW5rKGVibC0+ZWxmLCBidWNr ZXRzX2F0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg bmJ1Y2tldHMgKiBzaXplb2YoRWxmMzJfV29yZCksIEVMRl9UX1dPUkQpOwor ICAgICAgaWYgKGRhdGEgIT0gTlVMTCAmJiBzeW1uZHggPCBuYnVja2V0cykg eworICAgICAgICBjb25zdCBFbGYzMl9Xb3JkICpjb25zdCBidWNrZXRzID0g ZGF0YS0+ZF9idWY7CisgICAgICAgIEVsZjMyX1dvcmQgbWF4bmR4ID0gc3lt bmR4OworICAgICAgICBmb3IgKEVsZjMyX1dvcmQgYnVja2V0ID0gMDsgYnVj a2V0IDwgbmJ1Y2tldHM7ICsrYnVja2V0KQorICAgICAgICAgIGlmIChidWNr ZXRzW2J1Y2tldF0gPiBtYXhuZHgpCisgICAgICAgICAgICBtYXhuZHggPSBi dWNrZXRzW2J1Y2tldF07CisKKyAgICAgICAgR0VsZl9PZmYgaGFzaGFycl9h dCA9IChidWNrZXRzX2F0ICsgbmJ1Y2tldHMgKiBzaXplb2YoRWxmMzJfV29y ZCkpOworICAgICAgICBoYXNoYXJyX2F0ICs9IChtYXhuZHggLSBzeW1uZHgp ICogc2l6ZW9mKEVsZjMyX1dvcmQpOworICAgICAgICBkbyB7CisgICAgICAg ICAgZGF0YSA9IGVsZl9nZXRkYXRhX3Jhd2NodW5rKGVibC0+ZWxmLCBoYXNo YXJyX2F0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBzaXplb2YoRWxmMzJfV29yZCksIEVMRl9UX1dPUkQpOworICAgICAgICAg IGlmIChkYXRhICE9IE5VTEwgJiYgKCooY29uc3QgRWxmMzJfV29yZCAqKWRh dGEtPmRfYnVmICYgMXUpKSB7CisgICAgICAgICAgICBzeW1lbnRzID0gbWF4 bmR4ICsgMTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgIH0KKyAg ICAgICAgICArK21heG5keDsKKyAgICAgICAgICBoYXNoYXJyX2F0ICs9IHNp emVvZihFbGYzMl9Xb3JkKTsKKyAgICAgICAgfSB3aGlsZSAoZGF0YSAhPSBO VUxMKTsKKyAgICAgIH0KKyAgICB9CisgIH0KKyAgaWYgKG9mZnNbaV9zdHJ0 YWJdID4gb2Zmc1tpX3N5bXRhYl0gJiYgc3ltZW50cyA9PSAwKQorICAgIHN5 bWVudHMgPSAoKG9mZnNbaV9zdHJ0YWJdIC0gb2Zmc1tpX3N5bXRhYl0pIC8K KyAgICAgIGdlbGZfZnNpemUoZWJsLT5lbGYsIEVMRl9UX1NZTSwgMSwgRVZf Q1VSUkVOVCkpOworCisgIGlmIChzeW1lbnRzIDw9IDAgfHwgb2Zmc1tpX3N0 cnRhYl0gPT0gMCB8fCBvZmZzW2lfc3ltdGFiXSA9PSAwKSB7CisgICAgZXJy b3JfZXhpdCgwLCBfKCJEeW5hbWljIHN5bWJvbCBpbmZvcm1hdGlvbiBpcyBu b3QgYXZhaWxhYmxlIGZvciBkaXNwbGF5aW5nIHN5bWJvbHMuIikpOworICB9 CisKKyAgLyogQWxsIHRoZSBkYXRhIGNodW5rIGluaXRpYWxpemFpb24uICAq LworICBFbGZfRGF0YSAqc3ltZGF0YSA9IE5VTEw7CisgIEVsZl9EYXRhICpz eW1zdHJkYXRhID0gTlVMTDsKKyAgRWxmX0RhdGEgKnZlcnN5bV9kYXRhID0g TlVMTDsKKyAgRWxmX0RhdGEgKnZlcmRlZl9kYXRhID0gTlVMTDsKKyAgRWxm X0RhdGEgKnZlcm5lZWRfZGF0YSA9IE5VTEw7CisKKyAgc3ltZGF0YSA9IGVs Zl9nZXRkYXRhX3Jhd2NodW5rKAorICAgICAgZWJsLT5lbGYsIG9mZnNbaV9z eW10YWJdLAorICAgICAgZ2VsZl9mc2l6ZShlYmwtPmVsZiwgRUxGX1RfU1lN LCBzeW1lbnRzLCBFVl9DVVJSRU5UKSwgRUxGX1RfU1lNKTsKKyAgc3ltc3Ry ZGF0YSA9IGVsZl9nZXRkYXRhX3Jhd2NodW5rKGVibC0+ZWxmLCBvZmZzW2lf c3RydGFiXSwgYWRkcnNbaV9zdHJzel0sCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBFTEZfVF9CWVRFKTsKKyAgdmVyc3ltX2RhdGEg PSBlbGZfZ2V0ZGF0YV9yYXdjaHVuayhlYmwtPmVsZiwgb2Zmc1tpX3ZlcnN5 bV0sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3lt ZW50cyAqIHNpemVvZihFbGY2NF9IYWxmKSwgRUxGX1RfSEFMRik7CisKKyAg LyogR2V0IHRoZSB2ZXJuZWVkX2RhdGEgd2l0aG91dCB2ZXJuYXV4LiAgKi8K KyAgdmVybmVlZF9kYXRhID0gZWxmX2dldGRhdGFfcmF3Y2h1bmsoCisgICAg ICBlYmwtPmVsZiwgb2Zmc1tpX3Zlcm5lZWRdLCBhZGRyc1tpX3Zlcm5lZWRu dW1dICogc2l6ZW9mKEVsZjY0X1Zlcm5lZWQpLAorICAgICAgRUxGX1RfVk5F RUQpOworICBzaXplX3QgdmVybmF1eG51bSA9IDA7CisgIHNpemVfdCB2bl9u ZXh0X29mZnNldCA9IDA7CisKKyAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBh ZGRyc1tpX3Zlcm5lZWRudW1dOyBpKyspIHsKKyAgICBHRWxmX1Zlcm5lZWQg KnZlcm5lZWQgPQorICAgICAgICAoR0VsZl9WZXJuZWVkICopKHZlcm5lZWRf ZGF0YS0+ZF9idWYgKyB2bl9uZXh0X29mZnNldCk7CisgICAgdmVybmF1eG51 bSArPSB2ZXJuZWVkLT52bl9jbnQ7CisgICAgdm5fbmV4dF9vZmZzZXQgKz0g dmVybmVlZC0+dm5fbmV4dDsKKyAgfQorCisgIC8qIFVwZGF0ZSB0aGUgdmVy bmVlZF9kYXRhIHRvIGluY2x1ZGUgdGhlIHZlcm5hdXguICAqLworICB2ZXJu ZWVkX2RhdGEgPSBlbGZfZ2V0ZGF0YV9yYXdjaHVuaygKKyAgICAgIGVibC0+ ZWxmLCBvZmZzW2lfdmVybmVlZF0sCisgICAgICAoYWRkcnNbaV92ZXJuZWVk bnVtXSArIHZlcm5hdXhudW0pICogc2l6ZW9mKEdFbGZfVmVybmVlZCksIEVM Rl9UX1ZORUVEKTsKKworICAvKiBHZXQgdGhlIHZlcmRlZl9kYXRhIHdpdGhv dXQgdmVyZGF1eC4gICovCisgIHZlcmRlZl9kYXRhID0gZWxmX2dldGRhdGFf cmF3Y2h1bmsoZWJsLT5lbGYsIG9mZnNbaV92ZXJkZWZdLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFkZHJzW2lfdmVyZGVmbnVt XSAqIHNpemVvZihFbGY2NF9WZXJkZWYpLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIEVMRl9UX1ZERUYpOworICBzaXplX3QgdmVy ZGF1eG51bSA9IDA7CisgIHNpemVfdCB2ZF9uZXh0X29mZnNldCA9IDA7CisK KyAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBhZGRyc1tpX3ZlcmRlZm51bV07 IGkrKykgeworICAgIEdFbGZfVmVyZGVmICp2ZXJkZWYgPSAoR0VsZl9WZXJk ZWYgKikodmVyZGVmX2RhdGEtPmRfYnVmICsgdmRfbmV4dF9vZmZzZXQpOwor ICAgIHZlcmRhdXhudW0gKz0gdmVyZGVmLT52ZF9jbnQ7CisgICAgdmRfbmV4 dF9vZmZzZXQgKz0gdmVyZGVmLT52ZF9uZXh0OworICB9CisKKyAgLyogVXBk YXRlIHRoZSB2ZXJkZWZfZGF0YSB0byBpbmNsdWRlIHRoZSB2ZXJkYXV4LiAg Ki8KKyAgdmVyZGVmX2RhdGEgPSBlbGZfZ2V0ZGF0YV9yYXdjaHVuaygKKyAg ICAgIGVibC0+ZWxmLCBvZmZzW2lfdmVyZGVmXSwKKyAgICAgIChhZGRyc1tp X3ZlcmRlZm51bV0gKyB2ZXJkYXV4bnVtKSAqIHNpemVvZihHRWxmX1ZlcmRl ZiksIEVMRl9UX1ZERUYpOworCisgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwg c3ltZW50czsgaSsrKSB7CisgICAgLyogR2V0IHRoZSBzeW1ib2wgdGFibGUg ZW50cnkuICAqLworICAgIEdFbGZfU3ltIHN5bV9tZW07CisgICAgR0VsZl9T eW0gKnN5bTsKKyAgICBzeW0gPSBnZWxmX2dldHN5bShzeW1kYXRhLCBpLCAm c3ltX21lbSk7CisKKyAgICBjaGFyIGJpbmRidWZbNjRdOworICAgIGNoYXIg dHlwZWJ1Zls2NF07CisgICAgY2hhciBzY25idWZbNjRdOworICAgIGludCBj bGFzcyA9IGdlbGZfZ2V0Y2xhc3MoZWJsLT5lbGYpOworICAgIEVsZjMyX1dv cmQgeG5keDsKKyAgICB4bmR4ID0gc3ltLT5zdF9zaG5keDsKKworICAgIHBy aW50ZihfKCJcCislNWxkOiAlMCoiIFBSSXg2NCAiICU2IiBQUklkNjQgIiAl LTdzICUtNnMgJS05cyAlNnMgJXMiKSwKKyAgICAgICAgICAgaSwgY2xhc3Mg PT0gRUxGQ0xBU1MzMiA/IDggOiAxNiwgc3ltLT5zdF92YWx1ZSwgc3ltLT5z dF9zaXplLAorICAgICAgICAgICBlYmxfc3ltYm9sX3R5cGVfbmFtZShlYmws IEdFTEZfU1RfVFlQRShzeW0tPnN0X2luZm8pLCB0eXBlYnVmLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBzaXplb2YodHlwZWJ1ZikpLAor ICAgICAgICAgICBlYmxfc3ltYm9sX2JpbmRpbmdfbmFtZShlYmwsIEdFTEZf U1RfQklORChzeW0tPnN0X2luZm8pLCBiaW5kYnVmLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBzaXplb2YoYmluZGJ1ZikpLAorICAg ICAgICAgICBnZXRfdmlzaWJpbGl0eV90eXBlKEdFTEZfU1RfVklTSUJJTElU WShzeW0tPnN0X290aGVyKSksCisgICAgICAgICAgIGVibF9zZWN0aW9uX25h bWUoZWJsLCBzeW0tPnN0X3NobmR4LCB4bmR4LCBzY25idWYsIHNpemVvZihz Y25idWYpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwsIHNo bnVtKSwKKyAgICAgICAgICAgKChjaGFyICopc3ltc3RyZGF0YS0+ZF9idWYp ICsgc3ltLT5zdF9uYW1lKTsKKworICAgIGlmICh2ZXJzeW1fZGF0YSAhPSBO VUxMKSB7CisgICAgICAvKiBHZXQgdGhlIHZlcnNpb24gaW5mb3JtYXRpb24u ICAqLworICAgICAgR0VsZl9WZXJzeW0gdmVyc3ltX21lbTsKKyAgICAgIEdF bGZfVmVyc3ltICp2ZXJzeW0gPSBnZWxmX2dldHZlcnN5bSh2ZXJzeW1fZGF0 YSwgaSwgJnZlcnN5bV9tZW0pOworCisgICAgICBpZiAodmVyc3ltICE9IE5V TEwgJiYgKCgqdmVyc3ltICYgMHg4MDAwKSAhPSAwIHx8ICp2ZXJzeW0gPiAx KSkgeworICAgICAgICBHRWxmX1Zlcm5hdXggdmVybmF1eF9tZW07CisgICAg ICAgIEdFbGZfVmVybmF1eCAqdmVybmF1eCA9IE5VTEw7CisgICAgICAgIHNp emVfdCB2bl9vZmZzZXQgPSAwOworICAgICAgICBHRWxmX1Zlcm5lZWQgdmVy bmVlZF9tZW07CisgICAgICAgIEdFbGZfVmVybmVlZCAqdmVybmVlZCA9IChH RWxmX1Zlcm5lZWQgKil2ZXJuZWVkX2RhdGEtPmRfYnVmOworCisgICAgICAg IHdoaWxlICh2ZXJuZWVkICE9IE5VTEwpIHsKKyAgICAgICAgICBzaXplX3Qg dm5hX29mZnNldCA9IHZuX29mZnNldDsKKworICAgICAgICAgIHZlcm5hdXgg PSBnZWxmX2dldHZlcm5hdXgodmVybmVlZF9kYXRhLCB2bmFfb2Zmc2V0ICs9 IHZlcm5lZWQtPnZuX2F1eCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICZ2ZXJuYXV4X21lbSk7CisgICAgICAgICAgd2hpbGUgKHZl cm5hdXggIT0gTlVMTCAmJiB2ZXJuYXV4LT52bmFfb3RoZXIgIT0gKnZlcnN5 bSAmJgorICAgICAgICAgICAgICAgICB2ZXJuYXV4LT52bmFfbmV4dCAhPSAw ICYmCisgICAgICAgICAgICAgICAgICh2ZXJuZWVkX2RhdGEtPmRfc2l6ZSAt IHZuYV9vZmZzZXQgPj0gdmVybmF1eC0+dm5hX25leHQpKSB7CisgICAgICAg ICAgICAvKiBVcGRhdGUgdGhlIG9mZnNldC4gICovCisgICAgICAgICAgICB2 bmFfb2Zmc2V0ICs9IHZlcm5hdXgtPnZuYV9uZXh0OworCisgICAgICAgICAg ICB2ZXJuYXV4ID0KKyAgICAgICAgICAgICAgICAodmVybmF1eC0+dm5hX25l eHQgPT0gMAorICAgICAgICAgICAgICAgICAgICAgPyBOVUxMCisgICAgICAg ICAgICAgICAgICAgICA6IGdlbGZfZ2V0dmVybmF1eCh2ZXJuZWVkX2RhdGEs IHZuYV9vZmZzZXQsICZ2ZXJuYXV4X21lbSkpOworICAgICAgICAgIH0KKwor ICAgICAgICAgIC8qIENoZWNrIHdoZXRoZXIgd2UgZm91bmQgdGhlIHZlcnNp b24uICAqLworICAgICAgICAgIGlmICh2ZXJuYXV4ICE9IE5VTEwgJiYgdmVy bmF1eC0+dm5hX290aGVyID09ICp2ZXJzeW0pCisgICAgICAgICAgICAvKiBG b3VuZCBpdC4gICovCisgICAgICAgICAgICBicmVhazsKKworICAgICAgICAg IGlmICh2ZXJuZWVkX2RhdGEtPmRfc2l6ZSAtIHZuX29mZnNldCA8IHZlcm5l ZWQtPnZuX25leHQpCisgICAgICAgICAgICBicmVhazsKKworICAgICAgICAg IHZuX29mZnNldCArPSB2ZXJuZWVkLT52bl9uZXh0OworICAgICAgICAgIHZl cm5lZWQgPQorICAgICAgICAgICAgICAodmVybmVlZC0+dm5fbmV4dCA9PSAw CisgICAgICAgICAgICAgICAgICAgPyBOVUxMCisgICAgICAgICAgICAgICAg ICAgOiBnZWxmX2dldHZlcm5lZWQodmVybmVlZF9kYXRhLCB2bl9vZmZzZXQs ICZ2ZXJuZWVkX21lbSkpOworICAgICAgICB9CisKKyAgICAgICAgaWYgKHZl cm5hdXggIT0gTlVMTCAmJiB2ZXJuYXV4LT52bmFfb3RoZXIgPT0gKnZlcnN5 bSkgeworICAgICAgICAgIHByaW50ZigiQCVzICgldSkiLCAoY2hhciAqKXN5 bXN0cmRhdGEtPmRfYnVmICsgdmVybmF1eC0+dm5hX25hbWUsCisgICAgICAg ICAgICAgICAgICh1bnNpZ25lZCBpbnQpdmVybmF1eC0+dm5hX290aGVyKTsK KyAgICAgICAgfQorCisgICAgICAgIGlmIChhZGRyc1tpX3ZlcmRlZm51bV0g JiYgKnZlcnN5bSAhPSAweDgwMDEpIHsKKyAgICAgICAgICAvKiBXZSBtdXN0 IHRlc3QgYm90aC4gICovCisgICAgICAgICAgc2l6ZV90IHZkX29mZnNldCA9 IDA7CisKKyAgICAgICAgICBHRWxmX1ZlcmRlZiB2ZXJkZWZfbWVtOworICAg ICAgICAgIEdFbGZfVmVyZGVmICp2ZXJkZWYgPSBnZWxmX2dldHZlcmRlZih2 ZXJkZWZfZGF0YSwgMCwgJnZlcmRlZl9tZW0pOworICAgICAgICAgIHdoaWxl ICh2ZXJkZWYgIT0gTlVMTCkgeworICAgICAgICAgICAgaWYgKHZlcmRlZi0+ dmRfbmR4ID09ICgqdmVyc3ltICYgMHg3ZmZmKSkKKyAgICAgICAgICAgICAg LyogRm91bmQgdGhlIGRlZmluaXRpb24uICAqLworICAgICAgICAgICAgICBi cmVhazsKKworICAgICAgICAgICAgaWYgKHZlcmRlZl9kYXRhLT5kX3NpemUg LSB2ZF9vZmZzZXQgPCB2ZXJkZWYtPnZkX25leHQpCisgICAgICAgICAgICAg IGJyZWFrOworCisgICAgICAgICAgICB2ZF9vZmZzZXQgKz0gdmVyZGVmLT52 ZF9uZXh0OworICAgICAgICAgICAgdmVyZGVmID0KKyAgICAgICAgICAgICAg ICAodmVyZGVmLT52ZF9uZXh0ID09IDAKKyAgICAgICAgICAgICAgICAgICAg ID8gTlVMTAorICAgICAgICAgICAgICAgICAgICAgOiBnZWxmX2dldHZlcmRl Zih2ZXJkZWZfZGF0YSwgdmRfb2Zmc2V0LCAmdmVyZGVmX21lbSkpOworICAg ICAgICAgIH0KKworICAgICAgICAgIGlmICh2ZXJkZWYgIT0gTlVMTCkgewor ICAgICAgICAgICAgR0VsZl9WZXJkYXV4IHZlcmRhdXhfbWVtOworICAgICAg ICAgICAgR0VsZl9WZXJkYXV4ICp2ZXJkYXV4ID0gZ2VsZl9nZXR2ZXJkYXV4 KAorICAgICAgICAgICAgICAgIHZlcmRlZl9kYXRhLCB2ZF9vZmZzZXQgKyB2 ZXJkZWYtPnZkX2F1eCwgJnZlcmRhdXhfbWVtKTsKKworICAgICAgICAgICAg aWYgKHZlcmRhdXggIT0gTlVMTCkKKyAgICAgICAgICAgICAgcHJpbnRmKCgq dmVyc3ltICYgMHg4MDAwKSA/ICJAJXMiIDogIkBAJXMiLAorICAgICAgICAg ICAgICAgICAgICAgKGNoYXIgKilzeW1zdHJkYXRhLT5kX2J1ZiArIHZlcmRh dXgtPnZkYV9uYW1lKTsKKyAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAg IH0KKyAgICB9CisgICAgcHV0Y2hhcl91bmxvY2tlZCgnXG4nKTsKKyAgfQor ICByZXR1cm4gdHJ1ZTsKK30KKworCisKK3N0YXRpYyBib29sCiBoYW5kbGVf c3ltdGFiIChFYmwgKmVibCwgRWxmX1NjbiAqc2NuLCBHRWxmX1NoZHIgKnNo ZHIpCiB7CiAgIEVsZl9EYXRhICp2ZXJzeW1fZGF0YSA9IE5VTEw7CkBAIC0y NTAzLDcgKzI3NzEsNyBAQCBoYW5kbGVfc3ltdGFiIChFYmwgKmVibCwgRWxm X1NjbiAqc2NuLCBHRWxmX1NoZHIgKnNoZHIpCiAgIC8qIEdldCB0aGUgZGF0 YSBvZiB0aGUgc2VjdGlvbi4gICovCiAgIEVsZl9EYXRhICpkYXRhID0gZWxm X2dldGRhdGEgKHNjbiwgTlVMTCk7CiAgIGlmIChkYXRhID09IE5VTEwpCi0g ICAgcmV0dXJuOworICAgIHJldHVybiBmYWxzZTsKIAogICAvKiBGaW5kIG91 dCB3aGV0aGVyIHdlIGhhdmUgb3RoZXIgc2VjdGlvbnMgd2UgbWlnaHQgbmVl ZC4gICovCiAgIEVsZl9TY24gKnJ1bnNjbiA9IE5VTEw7CkBAIC0yNzMwLDYg KzI5OTgsNyBAQCBoYW5kbGVfc3ltdGFiIChFYmwgKmVibCwgRWxmX1NjbiAq c2NuLCBHRWxmX1NoZHIgKnNoZHIpCiAKICAgICAgIHB1dGNoYXJfdW5sb2Nr ZWQgKCdcbicpOwogICAgIH0KKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAogCkBA IC00OTU1LDEwICs1MjI0LDE4IEBAIGdldF9keW5zY25fYWRkcnMoRWxmICpl bGYsIEdFbGZfUGhkciAqcGhkciwgR0VsZl9BZGRyIGFkZHJzW2lfbWF4XSkK ICAgICAgIGFkZHJzW2lfdmVyZGVmXSA9IGR5bi0+ZF91bi5kX3B0cjsKICAg ICAgIGJyZWFrOwogCisgICAgY2FzZSBEVF9WRVJERUZOVU06CisgICAgICBh ZGRyc1tpX3ZlcmRlZm51bV0gPSBkeW4tPmRfdW4uZF92YWw7CisgICAgICBi cmVhazsKKwogICAgIGNhc2UgRFRfVkVSTkVFRDoKICAgICAgIGFkZHJzW2lf dmVybmVlZF0gPSBkeW4tPmRfdW4uZF9wdHI7CiAgICAgICBicmVhazsKIAor ICAgIGNhc2UgRFRfVkVSTkVFRE5VTToKKyAgICAgIGFkZHJzW2lfdmVybmVl ZG51bV0gPSBkeW4tPmRfdW4uZF92YWw7CisgICAgICBicmVhazsKKwogICAg IGNhc2UgRFRfU1RSU1o6CiAgICAgICBhZGRyc1tpX3N0cnN6XSA9IGR5bi0+ ZF91bi5kX3ZhbDsKICAgICAgIGJyZWFrOwotLSAKMi4zOS4xCgo= --000000000000e93a9705f45ad597--