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 AC130383941F for ; Tue, 24 May 2022 15:53:28 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org AC130383941F Received: from mail-lj1-f197.google.com (mail-lj1-f197.google.com [209.85.208.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-15-4F2FEjG4NdakWJ73PvCT5Q-1; Tue, 24 May 2022 11:53:25 -0400 X-MC-Unique: 4F2FEjG4NdakWJ73PvCT5Q-1 Received: by mail-lj1-f197.google.com with SMTP id e22-20020a2e9e16000000b00253cd8911easo3623184ljk.13 for ; Tue, 24 May 2022 08:53:25 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=ZaIjFptTDmkQh+QyizWFZdCAshXtqCj9janPsT31g1c=; b=ltAx3sSxf8qZdb+Hp4d4fS60aAqZFAFOV0WAM3cxDgi4cjOant4wlUaNVlM1uEaNY+ V6xBGOOBsg47VLiHIvlXN4wZ46SXbgOxXPEdC7iGXOaYpnnwhI0f1MqDjGSlzr8adYpV 4xYfCpY1GvXM8OswSRpQHw41yyi02Iow4o1PJ/83Cs6WTzCL+6bO4pCwrN2p9TwKSsjc OacOxaqPuTzoRO0VxEPI7oSsfJvvoDyY3aKcs6o/c7DtIwpqJuUaVG6FaZPsJrMaE3Qz JmrBahsTe5fiw6GfYESKGejeN3rA7OD+3qqJzKEsEvUyy2xsnBr6rXoeNsTqWJEEObJZ vQfQ== X-Gm-Message-State: AOAM531frlsMGIwsQZB9H8y8WAJOd9lSxfujQfcyHJjwZXjN5T9c7aEC FdEezvPx99zAVjZCj1BZzy3vh9Ra4T2s6pSAHwex/qxKthUJd5yXcdJ/AEA/458HdJLjjyw3Tfn UyXLrtA38NFLr2QxkSPTIp9c4JC107JxTnx3FejYcGQ== X-Received: by 2002:ac2:5297:0:b0:477:b1ac:d012 with SMTP id q23-20020ac25297000000b00477b1acd012mr20248072lfm.440.1653407603662; Tue, 24 May 2022 08:53:23 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzPFOMXkHncyYCNI9R/NJ1BTAhVvH0HaEwvcYD7e09JOQffeNpd1mrk5p5zHs5BDp3v1Z7QUb5zurOnzpmE4Ec= X-Received: by 2002:ac2:5297:0:b0:477:b1ac:d012 with SMTP id q23-20020ac25297000000b00477b1acd012mr20248036lfm.440.1653407603033; Tue, 24 May 2022 08:53:23 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Di Chen Date: Tue, 24 May 2022 23:53:11 +0800 Message-ID: Subject: Re: [PATCH] readelf: Support --dynamic with --use-dynamic To: Mark Wielaard Cc: elfutils-devel@sourceware.org X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="000000000000d9370005dfc3f447" X-Spam-Status: No, score=-13.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, KAM_SHORT, RCVD_IN_DNSWL_LOW, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-Content-Filtered-By: Mailman/MimeDel 2.1.29 X-BeenThere: elfutils-devel@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Elfutils-devel mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 24 May 2022 15:53:34 -0000 --000000000000d9370005dfc3f447 Content-Type: text/plain; charset="UTF-8" Thanks Mark, All the request changes are fixed, ready for review again. 1. help message updated: "Use the dynamic segment when possible for displaying info" 2. move enum dyn_idx to a proper place 3. add strtab_data's NULL check in function: handle_dynamic() 4. add phdr's NULL check in function: print_dynamic() 5. add comments for function: find_offsets() 6. remove redundant return-statement in function: get_dynscn_addrs() 7. add run-readelf-Dd.sh to EXTRA_DISTS 8. check strsz in (dyn->d_un.d_ptr < strtab_data->d_size) in function: handle_dynamic() On Fri, May 20, 2022 at 8:41 AM Mark Wielaard wrote: > Hi, > > On Thu, May 05, 2022 at 09:01:24PM +0800, Di Chen via Elfutils-devel wrote: > > From 3ac23c2584d76114deab0c0af6f4af99068dc7f4 Mon Sep 17 00:00:00 2001 > > From: Di Chen > > Date: Thu, 28 Apr 2022 19:55:33 +0800 > > Subject: [PATCH] readelf: Support --dynamic with --use-dynamic > > > > Currently, eu-readelf is using section headers to dump the dynamic > > segment information (print_dynamic -> handle_dynamic). > > > > This patch adds new options to eu-readelf (-D, --use-dynamic) > > for (-d, --dynamic). > > > > https://sourceware.org/bugzilla/show_bug.cgi?id=28873 > > This looks pretty good. But there are lots of white-space issues which > make it hard to apply the patch. Could you sent it again preferrably > using git send-email ? > > > Signed-off-by: Di Chen > > --- > > src/readelf.c | 168 +++++++++++++++++++++++++++++++++++++--- > > tests/Makefile.am | 3 +- > > tests/run-readelf-Dd.sh | 65 ++++++++++++++++ > > 3 files changed, 223 insertions(+), 13 deletions(-) > > create mode 100755 tests/run-readelf-Dd.sh > > > > diff --git a/src/readelf.c b/src/readelf.c > > index 4b6aab2b..e578456b 100644 > > --- a/src/readelf.c > > +++ b/src/readelf.c > > @@ -137,6 +137,8 @@ static const struct argp_option options[] = > > { "string-dump", 'p', NULL, OPTION_ALIAS | OPTION_HIDDEN, NULL, 0 }, > > { "archive-index", 'c', NULL, 0, > > N_("Display the symbol index of an archive"), 0 }, > > + { "use-dynamic", 'D', NULL, 0, > > + N_("Use the dynamic section info when displaying symbols"), 0 }, > > This doesn't handle symbols yet. Should it simply say: > "Use the dynamic segment when possible for displaying info" > > > { NULL, 0, NULL, 0, N_("Output control:"), 0 }, > > { "numeric-addresses", 'N', NULL, 0, > > @@ -195,6 +197,9 @@ static bool print_symbol_table; > > /* True if (only) the dynsym table should be printed. */ > > static bool print_dynsym_table; > > > > +/* True if reconstruct dynamic symbol table from the PT_DYNAMIC segment. > > */ > > +static bool use_dynamic_segment; > > + > > /* A specific section name, or NULL to print all symbol tables. */ > > static char *symbol_table_section; > > > > @@ -268,6 +273,19 @@ static enum section_e > > | section_macro | section_addr | section_types) > > } print_debug_sections, implicit_debug_sections; > > > > +enum dyn_idx > > +{ > > + i_strsz, > > + i_verneed, > > + i_verdef, > > + i_versym, > > + i_symtab, > > + i_strtab, > > + i_hash, > > + i_gnu_hash, > > + i_max > > +}; > > Maybe move this just before it is used in declarations of the > get_dyn... functions? > > > /* Select hex dumping of sections. */ > > static struct section_argument *dump_data_sections; > > static struct section_argument **dump_data_sections_tail = > > &dump_data_sections; > > @@ -318,6 +336,11 @@ static void dump_strings (Ebl *ebl); > > static void print_strings (Ebl *ebl); > > static void dump_archive_index (Elf *, const char *); > > > > +/* Declarations of local functions for use-dynamic. */ > > +static Elf_Data * get_dynscn_strtab(Elf *elf, GElf_Phdr *phdr); > > +static void get_dynscn_addrs(Elf *elf, GElf_Phdr *phdr, GElf_Addr > > addrs[i_max]); > > +static void find_offsets(Elf *elf, GElf_Addr main_bias, size_t n, > > + GElf_Addr addrs[n], GElf_Off offs[n]); > > I mean, just before these. > > > /* Looked up once with gettext in main. */ > > static char *yes_str; > > @@ -429,6 +452,9 @@ parse_opt (int key, char *arg, > > print_dynamic_table = true; > > any_control_option = true; > > break; > > + case 'D': > > + use_dynamic_segment = true; > > + break; > > case 'e': > > print_debug_sections |= section_exception; > > any_control_option = true; > > @@ -1791,7 +1817,7 @@ get_dyn_ents (Elf_Data * dyn_data) > > OK, setting flag. > > > > > static void > > -handle_dynamic (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr) > > +handle_dynamic (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr, GElf_Phdr > *phdr) > > { > > int class = gelf_getclass (ebl->elf); > > GElf_Shdr glink_mem; > > @@ -1802,13 +1828,20 @@ handle_dynamic (Ebl *ebl, Elf_Scn *scn, GElf_Shdr > > *shdr) > > size_t dyn_ents; > > > > /* Get the data of the section. */ > > - data = elf_getdata (scn, NULL); > > + if (use_dynamic_segment) > > + data = elf_getdata_rawchunk( > > + ebl->elf, phdr->p_offset, phdr->p_filesz, ELF_T_DYN); > > + else > > + data = elf_getdata (scn, NULL); > > + > > if (data == NULL) > > return; > > > > /* Get the dynamic section entry number */ > > dyn_ents = get_dyn_ents (data); > > > > + if (!use_dynamic_segment) > > +{ > > /* Get the section header string table index. */ > > if (unlikely (elf_getshdrstrndx (ebl->elf, &shstrndx) < 0)) > > error_exit (0, _("cannot get section header string table index")); > > @@ -1828,8 +1861,25 @@ handle_dynamic (Ebl *ebl, Elf_Scn *scn, GElf_Shdr > > *shdr) > > shdr->sh_offset, > > (int) shdr->sh_link, > > elf_strptr (ebl->elf, shstrndx, glink->sh_name)); > > +} else { > > + printf (ngettext ("\ > > +\nDynamic segment contains %lu entry:\n Addr: %#0*" PRIx64 " Offset: > > %#08" PRIx64 "\n", > > + "\ > > +\nDynamic segment contains %lu entries:\n Addr: %#0*" PRIx64 " Offset: > > %#08" PRIx64 "\n", > > + dyn_ents), > > + (unsigned long int) dyn_ents, > > + class == ELFCLASS32 ? 10 : 18, phdr->p_paddr, > > + phdr->p_offset); > > +} > > + > > fputs_unlocked (_(" Type Value\n"), stdout); > > > > + /* if --use-dynamic option is enabled, > > + use the string table to get the related library info. */ > > + Elf_Data *strtab_data = NULL; > > + if (use_dynamic_segment) > > + strtab_data = get_dynscn_strtab(ebl->elf, phdr); > > + > > for (cnt = 0; cnt < dyn_ents; ++cnt) > > { > > GElf_Dyn dynmem; > > @@ -1841,6 +1891,12 @@ handle_dynamic (Ebl *ebl, Elf_Scn *scn, GElf_Shdr > > *shdr) > > printf (" %-17s ", > > ebl_dynamic_tag_name (ebl, dyn->d_tag, buf, sizeof (buf))); > > > > + char *lib_name = NULL; > > + if (use_dynamic_segment) > > + lib_name = ((char *)strtab_data->d_buf) + dyn->d_un.d_ptr; > > I think strtab_data can be NULL here (if get_dynscn_strtab failed) and > dyn->d_un.d_ptr could be beyond the end of data (if the ELF file is > bogus). > > > + else > > + lib_name = elf_strptr (ebl->elf, shdr->sh_link, dyn->d_un.d_val); > > + > > switch (dyn->d_tag) > > { > > case DT_NULL: > > @@ -1852,23 +1908,19 @@ handle_dynamic (Ebl *ebl, Elf_Scn *scn, GElf_Shdr > > *shdr) > > break; > > > > case DT_NEEDED: > > - printf (_("Shared library: [%s]\n"), > > - elf_strptr (ebl->elf, shdr->sh_link, dyn->d_un.d_val)); > > + printf (_("Shared library: [%s]\n"), lib_name); > > break; > > > > case DT_SONAME: > > - printf (_("Library soname: [%s]\n"), > > - elf_strptr (ebl->elf, shdr->sh_link, dyn->d_un.d_val)); > > + printf (_("Library soname: [%s]\n"),lib_name); > > break; > > > > case DT_RPATH: > > - printf (_("Library rpath: [%s]\n"), > > - elf_strptr (ebl->elf, shdr->sh_link, dyn->d_un.d_val)); > > + printf (_("Library rpath: [%s]\n"),lib_name); > > break; > > > > case DT_RUNPATH: > > - printf (_("Library runpath: [%s]\n"), > > - elf_strptr (ebl->elf, shdr->sh_link, dyn->d_un.d_val)); > > + printf (_("Library runpath: [%s]\n"), lib_name); > > break; > > OK. > > > case DT_PLTRELSZ: > > @@ -1942,8 +1994,8 @@ print_dynamic (Ebl *ebl) > > Elf_Scn *scn = gelf_offscn (ebl->elf, phdr->p_offset); > > GElf_Shdr shdr_mem; > > GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); > > - if (shdr != NULL && shdr->sh_type == SHT_DYNAMIC) > > - handle_dynamic (ebl, scn, shdr); > > + if (use_dynamic_segment || (shdr != NULL && shdr->sh_type == > > SHT_DYNAMIC)) > > + handle_dynamic (ebl, scn, shdr, phdr); > > break; > > Should you check that phdr != NULL here? > > > } > > } > > @@ -4801,6 +4853,98 @@ print_ops (Dwfl_Module *dwflmod, Dwarf *dbg, int > > indent, int indentrest, > > } > > > > > > +static void > > +find_offsets(Elf *elf, GElf_Addr main_bias, size_t n, > > + GElf_Addr addrs[n], GElf_Off offs[n]) > > +{ > > + size_t unsolved = n; > > + for (size_t i = 0; i < phnum; ++i) { > > + GElf_Phdr phdr_mem; > > + GElf_Phdr *phdr = gelf_getphdr(elf, i, &phdr_mem); > > + if (phdr != NULL && phdr->p_type == PT_LOAD && phdr->p_memsz > 0) > > + for (size_t j = 0; j < n; ++j) > > + if (offs[j] == 0 && addrs[j] >= phdr->p_vaddr + main_bias && > > + addrs[j] - (phdr->p_vaddr + main_bias) < phdr->p_filesz) { > > + offs[j] = addrs[j] - (phdr->p_vaddr + main_bias) + > > phdr->p_offset; > > + if (--unsolved == 0) > > + break; > > + } > > + } > > +} > > OK, so this turns the addresses into file offsets using the phdrs. It > is slightly tricky, so I wouldn't mind a comment explaining what is > going on. > > > +/* The dynamic segment (type PT_DYNAMIC), contains the .dynamic section. > > + And .dynamic section contains an array of the dynamic structures. > > + We use the array to get: > > + DT_STRTAB: the address of the string table. > > + DT_SYMTAB: the address of the symbol table. > > + DT_STRSZ: the size, in bytes, of the string table. > > + , and etc. */ > > +static void > > +get_dynscn_addrs(Elf *elf, GElf_Phdr *phdr, GElf_Addr addrs[i_max]) > > +{ > > + Elf_Data *data = elf_getdata_rawchunk( > > + elf, phdr->p_offset, phdr->p_filesz, ELF_T_DYN); > > + > > + int dyn_idx = 0; > > + for (;; ++dyn_idx) { > > + GElf_Dyn dyn_mem; > > + GElf_Dyn *dyn = gelf_getdyn(data, dyn_idx, &dyn_mem); > > + /* DT_NULL Marks end of dynamic section. */ > > + if (dyn->d_tag == DT_NULL) > > + break; > > + > > + switch (dyn->d_tag) { > > + case DT_SYMTAB: > > + addrs[i_symtab] = dyn->d_un.d_ptr; > > + break; > > + > > + case DT_HASH: > > + addrs[i_hash] = dyn->d_un.d_ptr; > > + break; > > + > > + case DT_GNU_HASH: > > + addrs[i_gnu_hash] = dyn->d_un.d_ptr; > > + break; > > + > > + case DT_STRTAB: > > + addrs[i_strtab] = dyn->d_un.d_ptr; > > + break; > > + > > + case DT_VERSYM: > > + addrs[i_versym] = dyn->d_un.d_ptr; > > + break; > > + > > + case DT_VERDEF: > > + addrs[i_verdef] = dyn->d_un.d_ptr; > > + break; > > + > > + case DT_VERNEED: > > + addrs[i_verneed] = dyn->d_un.d_ptr; > > + break; > > + > > + case DT_STRSZ: > > + addrs[i_strsz] = dyn->d_un.d_val; > > + } > > + } > > + return; > > +} > > Note that the return here is redundant and could be left off. > > > +/* Use dynamic segment to get data for the string table section. */ > > +static Elf_Data * > > +get_dynscn_strtab(Elf *elf, GElf_Phdr *phdr) > > +{ > > + Elf_Data *strtab_data; > > + GElf_Addr addrs[i_max] = {0,}; > > + GElf_Off offs[i_max] = {0,}; > > + get_dynscn_addrs(elf, phdr, addrs); > > + find_offsets(elf, 0, i_max, addrs, offs); > > + strtab_data = elf_getdata_rawchunk( > > + elf, offs[i_strtab], addrs[i_strsz], ELF_T_BYTE); > > + return strtab_data; > > +} > > OK. > > > + > > struct listptr > > { > > Dwarf_Off offset:(64 - 3); > > diff --git a/tests/Makefile.am b/tests/Makefile.am > > index 84c3950a..b239a461 100644 > > --- a/tests/Makefile.am > > +++ b/tests/Makefile.am > > @@ -197,7 +197,8 @@ TESTS = run-arextract.sh run-arsymtest.sh run-ar.sh > > newfile test-nlist \ > > msg_tst system-elf-libelf-test \ > > $(asm_TESTS) run-disasm-bpf.sh run-low_high_pc-dw-form-indirect.sh \ > > run-nvidia-extended-linemap-libdw.sh > > run-nvidia-extended-linemap-readelf.sh \ > > - run-readelf-dw-form-indirect.sh run-strip-largealign.sh > > + run-readelf-dw-form-indirect.sh run-strip-largealign.sh \ > > + run-readelf-Dd.sh > > Don't forget to add run-readelf-Dd.sh to EXTRA_DISTS. > (make distcheck can be used to check for that) > > > if !BIARCH > > export ELFUTILS_DISABLE_BIARCH = 1 > > diff --git a/tests/run-readelf-Dd.sh b/tests/run-readelf-Dd.sh > > new file mode 100755 > > index 00000000..6420a0fe > > --- /dev/null > > +++ b/tests/run-readelf-Dd.sh > > @@ -0,0 +1,65 @@ > > +#! /bin/sh > > +# Copyright (C) 2022 Red Hat, Inc. > > +# This file is part of elfutils. > > +# > > +# This file is free software; you can redistribute it and/or modify > > +# it under the terms of the GNU General Public License as published by > > +# the Free Software Foundation; either version 3 of the License, or > > +# (at your option) any later version. > > +# > > +# elfutils is distributed in the hope that it will be useful, but > > +# WITHOUT ANY WARRANTY; without even the implied warranty of > > +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > > +# GNU General Public License for more details. > > +# > > +# You should have received a copy of the GNU General Public License > > +# along with this program. If not, see . > > + > > +. $srcdir/test-subr.sh > > + > > +# #include > > +# > > +# __thread int i; > > +# > > +# void print_i () > > +# { > > +# printf("%d\n", i); > > +# } > > +# > > +# gcc -fPIC -shared -o testlib_dynseg.so testlib_dynseg.c > > +# With ld --version > > +# GNU gold (GNU Binutils 2.22.52.20120402) 1.11 > > + > > +testfiles testlib_dynseg.so > > Maybe add a comment saying the same testfile is used in run-readelf-d.sh > > > +testrun_compare ${abs_top_builddir}/src/readelf -Dd testlib_dynseg.so > > <<\EOF > > + > > +Dynamic segment contains 23 entries: > > + Addr: 0x00000000000017e0 Offset: 0x0007e0 > > + Type Value > > + PLTGOT 0x00000000000019c8 > > + PLTRELSZ 72 (bytes) > > + JMPREL 0x0000000000000568 > > + PLTREL RELA > > + RELA 0x00000000000004d8 > > + RELASZ 144 (bytes) > > + RELAENT 24 (bytes) > > + RELACOUNT 1 > > + SYMTAB 0x0000000000000228 > > + SYMENT 24 (bytes) > > + STRTAB 0x0000000000000360 > > + STRSZ 190 (bytes) > > + GNU_HASH 0x0000000000000420 > > + NEEDED Shared library: [libc.so.6] > > + NEEDED Shared library: [ld-linux-x86-64.so.2] > > + INIT 0x00000000000005b0 > > + FINI 0x0000000000000748 > > + VERSYM 0x0000000000000460 > > + VERDEF 0x000000000000047c > > + VERDEFNUM 1 > > + VERNEED 0x0000000000000498 > > + VERNEEDNUM 2 > > + NULL > > +EOF > > + > > +exit 0 > > -- > > 2.35.1 > > --000000000000d9370005dfc3f447 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-readelf-Support-dynamic-with-use-dynamic.patch" Content-Disposition: attachment; filename="0001-readelf-Support-dynamic-with-use-dynamic.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_l3kc6avg0 RnJvbSBiOGZmMTE4OWM0NmZlNzM4MGM0NWUxYjQ2YWJiZjkyNzhkYzg2MWVmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEaSBDaGVuIDxkaWNoZW5AcmVkaGF0LmNvbT4KRGF0ZTogVGh1 LCAyOCBBcHIgMjAyMiAxOTo1NTozMyArMDgwMApTdWJqZWN0OiBbUEFUQ0hdIHJlYWRlbGY6IFN1 cHBvcnQgLS1keW5hbWljIHdpdGggLS11c2UtZHluYW1pYwoKQ3VycmVudGx5LCBldS1yZWFkZWxm IGlzIHVzaW5nIHNlY3Rpb24gaGVhZGVycyB0byBkdW1wIHRoZSBkeW5hbWljCnNlZ21lbnQgaW5m b3JtYXRpb24gKHByaW50X2R5bmFtaWMgLT4gaGFuZGxlX2R5bmFtaWMpLgoKVGhpcyBwYXRjaCBh ZGRzIG5ldyBvcHRpb25zIHRvIGV1LXJlYWRlbGYgKC1ELCAtLXVzZS1keW5hbWljKQpmb3IgKC1k LCAtLWR5bmFtaWMpLgoKaHR0cHM6Ly9zb3VyY2V3YXJlLm9yZy9idWd6aWxsYS9zaG93X2J1Zy5j Z2k/aWQ9Mjg4NzMKClNpZ25lZC1vZmYtYnk6IERpIENoZW4gPGRpY2hlbkByZWRoYXQuY29tPgot LS0KIHNyYy9yZWFkZWxmLmMgICAgICAgICAgIHwgMTgyICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKystLS0KIHRlc3RzL01ha2VmaWxlLmFtICAgICAgIHwgICA0ICstCiB0ZXN0 cy9ydW4tcmVhZGVsZi1EZC5zaCB8ICA2NiArKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdl ZCwgMjM5IGluc2VydGlvbnMoKyksIDEzIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNzU1 IHRlc3RzL3J1bi1yZWFkZWxmLURkLnNoCgpkaWZmIC0tZ2l0IGEvc3JjL3JlYWRlbGYuYyBiL3Ny Yy9yZWFkZWxmLmMKaW5kZXggNGI2YWFiMmIuLjZlZDExZjFlIDEwMDY0NAotLS0gYS9zcmMvcmVh ZGVsZi5jCisrKyBiL3NyYy9yZWFkZWxmLmMKQEAgLTEzNyw2ICsxMzcsOCBAQCBzdGF0aWMgY29u c3Qgc3RydWN0IGFyZ3Bfb3B0aW9uIG9wdGlvbnNbXSA9CiAgIHsgInN0cmluZy1kdW1wIiwgJ3An LCBOVUxMLCBPUFRJT05fQUxJQVMgfCBPUFRJT05fSElEREVOLCBOVUxMLCAwIH0sCiAgIHsgImFy Y2hpdmUtaW5kZXgiLCAnYycsIE5VTEwsIDAsCiAgICAgTl8oIkRpc3BsYXkgdGhlIHN5bWJvbCBp bmRleCBvZiBhbiBhcmNoaXZlIiksIDAgfSwKKyAgeyAidXNlLWR5bmFtaWMiLCAnRCcsIE5VTEws IDAsCisgICAgTl8oIlVzZSB0aGUgZHluYW1pYyBzZWdtZW50IHdoZW4gcG9zc2libGUgZm9yIGRp c3BsYXlpbmcgaW5mbyIpLCAwIH0sCiAKICAgeyBOVUxMLCAwLCBOVUxMLCAwLCBOXygiT3V0cHV0 IGNvbnRyb2w6IiksIDAgfSwKICAgeyAibnVtZXJpYy1hZGRyZXNzZXMiLCAnTicsIE5VTEwsIDAs CkBAIC0xOTUsNiArMTk3LDkgQEAgc3RhdGljIGJvb2wgcHJpbnRfc3ltYm9sX3RhYmxlOwogLyog VHJ1ZSBpZiAob25seSkgdGhlIGR5bnN5bSB0YWJsZSBzaG91bGQgYmUgcHJpbnRlZC4gICovCiBz dGF0aWMgYm9vbCBwcmludF9keW5zeW1fdGFibGU7CiAKKy8qIFRydWUgaWYgcmVjb25zdHJ1Y3Qg ZHluYW1pYyBzeW1ib2wgdGFibGUgZnJvbSB0aGUgUFRfRFlOQU1JQyBzZWdtZW50LiAgKi8KK3N0 YXRpYyBib29sIHVzZV9keW5hbWljX3NlZ21lbnQ7CisKIC8qIEEgc3BlY2lmaWMgc2VjdGlvbiBu YW1lLCBvciBOVUxMIHRvIHByaW50IGFsbCBzeW1ib2wgdGFibGVzLiAgKi8KIHN0YXRpYyBjaGFy ICpzeW1ib2xfdGFibGVfc2VjdGlvbjsKIApAQCAtMzE4LDYgKzMyMywyNCBAQCBzdGF0aWMgdm9p ZCBkdW1wX3N0cmluZ3MgKEVibCAqZWJsKTsKIHN0YXRpYyB2b2lkIHByaW50X3N0cmluZ3MgKEVi bCAqZWJsKTsKIHN0YXRpYyB2b2lkIGR1bXBfYXJjaGl2ZV9pbmRleCAoRWxmICosIGNvbnN0IGNo YXIgKik7CiAKK2VudW0gZHluX2lkeAoreworICBpX3N0cnN6LAorICBpX3Zlcm5lZWQsCisgIGlf dmVyZGVmLAorICBpX3ZlcnN5bSwKKyAgaV9zeW10YWIsCisgIGlfc3RydGFiLAorICBpX2hhc2gs CisgIGlfZ251X2hhc2gsCisgIGlfbWF4Cit9OworCisvKiBEZWNsYXJhdGlvbnMgb2YgbG9jYWwg ZnVuY3Rpb25zIGZvciB1c2UtZHluYW1pYy4gICovCitzdGF0aWMgRWxmX0RhdGEgKiBnZXRfZHlu c2NuX3N0cnRhYihFbGYgKmVsZiwgR0VsZl9QaGRyICpwaGRyKTsKK3N0YXRpYyB2b2lkIGdldF9k eW5zY25fYWRkcnMoRWxmICplbGYsIEdFbGZfUGhkciAqcGhkciwgR0VsZl9BZGRyIGFkZHJzW2lf bWF4XSk7CitzdGF0aWMgdm9pZCBmaW5kX29mZnNldHMoRWxmICplbGYsIEdFbGZfQWRkciBtYWlu X2JpYXMsIHNpemVfdCBuLAorICAgICAgICAgICAgICAgIEdFbGZfQWRkciBhZGRyc1tuXSwgR0Vs Zl9PZmYgb2Zmc1tuXSk7CiAKIC8qIExvb2tlZCB1cCBvbmNlIHdpdGggZ2V0dGV4dCBpbiBtYWlu LiAgKi8KIHN0YXRpYyBjaGFyICp5ZXNfc3RyOwpAQCAtNDI5LDYgKzQ1Miw5IEBAIHBhcnNlX29w dCAoaW50IGtleSwgY2hhciAqYXJnLAogICAgICAgcHJpbnRfZHluYW1pY190YWJsZSA9IHRydWU7 CiAgICAgICBhbnlfY29udHJvbF9vcHRpb24gPSB0cnVlOwogICAgICAgYnJlYWs7CisgICAgY2Fz ZSAnRCc6CisgICAgICB1c2VfZHluYW1pY19zZWdtZW50ID0gdHJ1ZTsKKyAgICAgIGJyZWFrOwog ICAgIGNhc2UgJ2UnOgogICAgICAgcHJpbnRfZGVidWdfc2VjdGlvbnMgfD0gc2VjdGlvbl9leGNl cHRpb247CiAgICAgICBhbnlfY29udHJvbF9vcHRpb24gPSB0cnVlOwpAQCAtMTc5MSw3ICsxODE3 LDcgQEAgZ2V0X2R5bl9lbnRzIChFbGZfRGF0YSAqIGR5bl9kYXRhKQogCiAKIHN0YXRpYyB2b2lk Ci1oYW5kbGVfZHluYW1pYyAoRWJsICplYmwsIEVsZl9TY24gKnNjbiwgR0VsZl9TaGRyICpzaGRy KQoraGFuZGxlX2R5bmFtaWMgKEVibCAqZWJsLCBFbGZfU2NuICpzY24sIEdFbGZfU2hkciAqc2hk ciwgR0VsZl9QaGRyICpwaGRyKQogewogICBpbnQgY2xhc3MgPSBnZWxmX2dldGNsYXNzIChlYmwt PmVsZik7CiAgIEdFbGZfU2hkciBnbGlua19tZW07CkBAIC0xODAyLDEzICsxODI4LDIwIEBAIGhh bmRsZV9keW5hbWljIChFYmwgKmVibCwgRWxmX1NjbiAqc2NuLCBHRWxmX1NoZHIgKnNoZHIpCiAg IHNpemVfdCBkeW5fZW50czsKIAogICAvKiBHZXQgdGhlIGRhdGEgb2YgdGhlIHNlY3Rpb24uICAq LwotICBkYXRhID0gZWxmX2dldGRhdGEgKHNjbiwgTlVMTCk7CisgIGlmICh1c2VfZHluYW1pY19z ZWdtZW50KQorICAgIGRhdGEgPSBlbGZfZ2V0ZGF0YV9yYXdjaHVuaygKKwkgIGVibC0+ZWxmLCBw aGRyLT5wX29mZnNldCwgcGhkci0+cF9maWxlc3osIEVMRl9UX0RZTik7CisgIGVsc2UKKyAgICBk YXRhID0gZWxmX2dldGRhdGEgKHNjbiwgTlVMTCk7CisKICAgaWYgKGRhdGEgPT0gTlVMTCkKICAg ICByZXR1cm47CiAKICAgLyogR2V0IHRoZSBkeW5hbWljIHNlY3Rpb24gZW50cnkgbnVtYmVyICov CiAgIGR5bl9lbnRzID0gZ2V0X2R5bl9lbnRzIChkYXRhKTsKIAorICBpZiAoIXVzZV9keW5hbWlj X3NlZ21lbnQpCit7CiAgIC8qIEdldCB0aGUgc2VjdGlvbiBoZWFkZXIgc3RyaW5nIHRhYmxlIGlu ZGV4LiAgKi8KICAgaWYgKHVubGlrZWx5IChlbGZfZ2V0c2hkcnN0cm5keCAoZWJsLT5lbGYsICZz aHN0cm5keCkgPCAwKSkKICAgICBlcnJvcl9leGl0ICgwLCBfKCJjYW5ub3QgZ2V0IHNlY3Rpb24g aGVhZGVyIHN0cmluZyB0YWJsZSBpbmRleCIpKTsKQEAgLTE4MjgsOCArMTg2MSwzMCBAQCBoYW5k bGVfZHluYW1pYyAoRWJsICplYmwsIEVsZl9TY24gKnNjbiwgR0VsZl9TaGRyICpzaGRyKQogCSAg c2hkci0+c2hfb2Zmc2V0LAogCSAgKGludCkgc2hkci0+c2hfbGluaywKIAkgIGVsZl9zdHJwdHIg KGVibC0+ZWxmLCBzaHN0cm5keCwgZ2xpbmstPnNoX25hbWUpKTsKK30gZWxzZSB7CisgIHByaW50 ZiAobmdldHRleHQgKCJcCitcbkR5bmFtaWMgc2VnbWVudCBjb250YWlucyAlbHUgZW50cnk6XG4g QWRkcjogJSMwKiIgUFJJeDY0ICIgIE9mZnNldDogJSMwOCIgUFJJeDY0ICJcbiIsCisJCSAgICAi XAorXG5EeW5hbWljIHNlZ21lbnQgY29udGFpbnMgJWx1IGVudHJpZXM6XG4gQWRkcjogJSMwKiIg UFJJeDY0ICIgIE9mZnNldDogJSMwOCIgUFJJeDY0ICJcbiIsCisJCSAgICBkeW5fZW50cyksCisJ ICAodW5zaWduZWQgbG9uZyBpbnQpIGR5bl9lbnRzLAorCSAgY2xhc3MgPT0gRUxGQ0xBU1MzMiA/ IDEwIDogMTgsIHBoZHItPnBfcGFkZHIsCisJICBwaGRyLT5wX29mZnNldCk7Cit9CisKICAgZnB1 dHNfdW5sb2NrZWQgKF8oIiAgVHlwZSAgICAgICAgICAgICAgVmFsdWVcbiIpLCBzdGRvdXQpOwog CisgIC8qIGlmIC0tdXNlLWR5bmFtaWMgb3B0aW9uIGlzIGVuYWJsZWQsCisgICAgIHVzZSB0aGUg c3RyaW5nIHRhYmxlIHRvIGdldCB0aGUgcmVsYXRlZCBsaWJyYXJ5IGluZm8uICAqLworICBFbGZf RGF0YSAqc3RydGFiX2RhdGEgPSBOVUxMOworICBpZiAodXNlX2R5bmFtaWNfc2VnbWVudCkKK3sK KyAgICBzdHJ0YWJfZGF0YSA9IGdldF9keW5zY25fc3RydGFiKGVibC0+ZWxmLCBwaGRyKTsKKyAg ICBpZiAoc3RydGFiX2RhdGEgPT0gTlVMTCkKKyAgICAgIGVycm9yX2V4aXQgKDAsIF8oImNhbm5v dCBnZXQgc3RyaW5nIHRhYmxlIGJ5IHVzaW5nIGR5bmFtaWMgc2VnbWVudCIpKTsKK30KKworCiAg IGZvciAoY250ID0gMDsgY250IDwgZHluX2VudHM7ICsrY250KQogICAgIHsKICAgICAgIEdFbGZf RHluIGR5bm1lbTsKQEAgLTE4NDEsNiArMTg5NiwxNSBAQCBoYW5kbGVfZHluYW1pYyAoRWJsICpl YmwsIEVsZl9TY24gKnNjbiwgR0VsZl9TaGRyICpzaGRyKQogICAgICAgcHJpbnRmICgiICAlLTE3 cyAiLAogCSAgICAgIGVibF9keW5hbWljX3RhZ19uYW1lIChlYmwsIGR5bi0+ZF90YWcsIGJ1Ziwg c2l6ZW9mIChidWYpKSk7CiAKKyAgICAgIGNoYXIgKmxpYl9uYW1lID0gTlVMTDsKKworICAgICAg aWYgKCF1c2VfZHluYW1pY19zZWdtZW50KQorICAgIGxpYl9uYW1lID0gZWxmX3N0cnB0ciAoZWJs LT5lbGYsIHNoZHItPnNoX2xpbmssIGR5bi0+ZF91bi5kX3ZhbCk7CisgICAgICBlbHNlIGlmICh1 c2VfZHluYW1pY19zZWdtZW50KQorICAgIGxpYl9uYW1lID0gKChjaGFyICopc3RydGFiX2RhdGEt PmRfYnVmKSArIGR5bi0+ZF91bi5kX3B0cjsKKyAgICAgIGVsc2UKKyAgICBicmVhazsKKwogICAg ICAgc3dpdGNoIChkeW4tPmRfdGFnKQogCXsKIAljYXNlIERUX05VTEw6CkBAIC0xODUyLDIzICsx OTE2LDI1IEBAIGhhbmRsZV9keW5hbWljIChFYmwgKmVibCwgRWxmX1NjbiAqc2NuLCBHRWxmX1No ZHIgKnNoZHIpCiAJICBicmVhazsKIAogCWNhc2UgRFRfTkVFREVEOgotCSAgcHJpbnRmIChfKCJT aGFyZWQgbGlicmFyeTogWyVzXVxuIiksCi0JCSAgZWxmX3N0cnB0ciAoZWJsLT5lbGYsIHNoZHIt PnNoX2xpbmssIGR5bi0+ZF91bi5kX3ZhbCkpOworCSAgLyogaWYgLS11c2UtZHluYW1pYyBvcHRp b24gaXMgZW5hYmxlZCwKKwkgICAgIGl0IG5lZWRzIHRvIG1ha2Ugc3VyZSBkX3B0ciBpcyB3aXRo aW4gc3Ryc3ouICAqLworCSAgaWYgKCAhdXNlX2R5bmFtaWNfc2VnbWVudCB8fCAoZHluLT5kX3Vu LmRfcHRyIDwgc3RydGFiX2RhdGEtPmRfc2l6ZSkpCisJICAgIHByaW50ZiAoXygiU2hhcmVkIGxp YnJhcnk6IFslc11cbiIpLCBsaWJfbmFtZSk7CiAJICBicmVhazsKIAogCWNhc2UgRFRfU09OQU1F OgotCSAgcHJpbnRmIChfKCJMaWJyYXJ5IHNvbmFtZTogWyVzXVxuIiksCi0JCSAgZWxmX3N0cnB0 ciAoZWJsLT5lbGYsIHNoZHItPnNoX2xpbmssIGR5bi0+ZF91bi5kX3ZhbCkpOworCSAgaWYgKCAh dXNlX2R5bmFtaWNfc2VnbWVudCB8fCAoZHluLT5kX3VuLmRfcHRyIDwgc3RydGFiX2RhdGEtPmRf c2l6ZSkpCisJICAgIHByaW50ZiAoXygiTGlicmFyeSBzb25hbWU6IFslc11cbiIpLGxpYl9uYW1l KTsKIAkgIGJyZWFrOwogCiAJY2FzZSBEVF9SUEFUSDoKLQkgIHByaW50ZiAoXygiTGlicmFyeSBy cGF0aDogWyVzXVxuIiksCi0JCSAgZWxmX3N0cnB0ciAoZWJsLT5lbGYsIHNoZHItPnNoX2xpbmss IGR5bi0+ZF91bi5kX3ZhbCkpOworCSAgaWYgKCAhdXNlX2R5bmFtaWNfc2VnbWVudCB8fCAoZHlu LT5kX3VuLmRfcHRyIDwgc3RydGFiX2RhdGEtPmRfc2l6ZSkpCisJICAgIHByaW50ZiAoXygiTGli cmFyeSBycGF0aDogWyVzXVxuIiksbGliX25hbWUpOwogCSAgYnJlYWs7CiAKIAljYXNlIERUX1JV TlBBVEg6Ci0JICBwcmludGYgKF8oIkxpYnJhcnkgcnVucGF0aDogWyVzXVxuIiksCi0JCSAgZWxm X3N0cnB0ciAoZWJsLT5lbGYsIHNoZHItPnNoX2xpbmssIGR5bi0+ZF91bi5kX3ZhbCkpOworCSAg aWYgKCAhdXNlX2R5bmFtaWNfc2VnbWVudCB8fCAoZHluLT5kX3VuLmRfcHRyIDwgc3RydGFiX2Rh dGEtPmRfc2l6ZSkpCisJICAgIHByaW50ZiAoXygiTGlicmFyeSBydW5wYXRoOiBbJXNdXG4iKSwg bGliX25hbWUpOwogCSAgYnJlYWs7CiAKIAljYXNlIERUX1BMVFJFTFNaOgpAQCAtMTk0Miw4ICsy MDA4LDggQEAgcHJpbnRfZHluYW1pYyAoRWJsICplYmwpCiAJICBFbGZfU2NuICpzY24gPSBnZWxm X29mZnNjbiAoZWJsLT5lbGYsIHBoZHItPnBfb2Zmc2V0KTsKIAkgIEdFbGZfU2hkciBzaGRyX21l bTsKIAkgIEdFbGZfU2hkciAqc2hkciA9IGdlbGZfZ2V0c2hkciAoc2NuLCAmc2hkcl9tZW0pOwot CSAgaWYgKHNoZHIgIT0gTlVMTCAmJiBzaGRyLT5zaF90eXBlID09IFNIVF9EWU5BTUlDKQotCSAg ICBoYW5kbGVfZHluYW1pYyAoZWJsLCBzY24sIHNoZHIpOworCSAgaWYgKCh1c2VfZHluYW1pY19z ZWdtZW50ICYmIHBoZHIgIT0gTlVMTCkgfHwgKHNoZHIgIT0gTlVMTCAmJiBzaGRyLT5zaF90eXBl ID09IFNIVF9EWU5BTUlDKSkKKwkgICAgaGFuZGxlX2R5bmFtaWMgKGVibCwgc2NuLCBzaGRyLCBw aGRyKTsKIAkgIGJyZWFrOwogCX0KICAgICB9CkBAIC00ODAxLDYgKzQ4NjcsOTggQEAgcHJpbnRf b3BzIChEd2ZsX01vZHVsZSAqZHdmbG1vZCwgRHdhcmYgKmRiZywgaW50IGluZGVudCwgaW50IGlu ZGVudHJlc3QsCiB9CiAKIAorLyogVHVybiB0aGUgYWRkcmVzc2VzIGludG8gZmlsZSBvZmZzZXRz IGJ5IHVzaW5nIHRoZSBwaGRycy4gICovCitzdGF0aWMgdm9pZAorZmluZF9vZmZzZXRzKEVsZiAq ZWxmLCBHRWxmX0FkZHIgbWFpbl9iaWFzLCBzaXplX3QgbiwKKyAgICAgICAgICAgICAgICAgIEdF bGZfQWRkciBhZGRyc1tuXSwgR0VsZl9PZmYgb2Zmc1tuXSkKK3sKKyAgc2l6ZV90IHVuc29sdmVk ID0gbjsKKyAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBwaG51bTsgKytpKSB7CisgICAgR0VsZl9Q aGRyIHBoZHJfbWVtOworICAgIEdFbGZfUGhkciAqcGhkciA9IGdlbGZfZ2V0cGhkcihlbGYsIGks ICZwaGRyX21lbSk7CisgICAgaWYgKHBoZHIgIT0gTlVMTCAmJiBwaGRyLT5wX3R5cGUgPT0gUFRf TE9BRCAmJiBwaGRyLT5wX21lbXN6ID4gMCkKKyAgICAgIGZvciAoc2l6ZV90IGogPSAwOyBqIDwg bjsgKytqKQorICAgICAgICBpZiAob2Zmc1tqXSA9PSAwICYmIGFkZHJzW2pdID49IHBoZHItPnBf dmFkZHIgKyBtYWluX2JpYXMgJiYKKyAgICAgICAgICAgIGFkZHJzW2pdIC0gKHBoZHItPnBfdmFk ZHIgKyBtYWluX2JpYXMpIDwgcGhkci0+cF9maWxlc3opIHsKKyAgICAgICAgICBvZmZzW2pdID0g YWRkcnNbal0gLSAocGhkci0+cF92YWRkciArIG1haW5fYmlhcykgKyBwaGRyLT5wX29mZnNldDsK KyAgICAgICAgICBpZiAoLS11bnNvbHZlZCA9PSAwKQorICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgIH0KKyAgfQorfQorCisvKiBUaGUgZHluYW1pYyBzZWdtZW50ICh0eXBlIFBUX0RZTkFNSUMp LCBjb250YWlucyB0aGUgLmR5bmFtaWMgc2VjdGlvbi4KKyAgIEFuZCAuZHluYW1pYyBzZWN0aW9u IGNvbnRhaW5zIGFuIGFycmF5IG9mIHRoZSBkeW5hbWljIHN0cnVjdHVyZXMuCisgICBXZSB1c2Ug dGhlIGFycmF5IHRvIGdldDoKKyAgICBEVF9TVFJUQUI6IHRoZSBhZGRyZXNzIG9mIHRoZSBzdHJp bmcgdGFibGUKKyAgICBEVF9TWU1UQUI6IHRoZSBhZGRyZXNzIG9mIHRoZSBzeW1ib2wgdGFibGUK KyAgICBEVF9TVFJTWjogdGhlIHNpemUsIGluIGJ5dGVzLCBvZiB0aGUgc3RyaW5nIHRhYmxlCisg ICAgLi4uICAqLworc3RhdGljIHZvaWQKK2dldF9keW5zY25fYWRkcnMoRWxmICplbGYsIEdFbGZf UGhkciAqcGhkciwgR0VsZl9BZGRyIGFkZHJzW2lfbWF4XSkKK3sKKyAgRWxmX0RhdGEgKmRhdGEg PSBlbGZfZ2V0ZGF0YV9yYXdjaHVuaygKKyAgICBlbGYsIHBoZHItPnBfb2Zmc2V0LCBwaGRyLT5w X2ZpbGVzeiwgRUxGX1RfRFlOKTsKKworICBpbnQgZHluX2lkeCA9IDA7CisgIGZvciAoOzsgKytk eW5faWR4KSB7CisgICAgR0VsZl9EeW4gZHluX21lbTsKKyAgICBHRWxmX0R5biAqZHluID0gZ2Vs Zl9nZXRkeW4oZGF0YSwgZHluX2lkeCwgJmR5bl9tZW0pOworICAgIC8qIERUX05VTEwgTWFya3Mg ZW5kIG9mIGR5bmFtaWMgc2VjdGlvbi4gICovCisgICAgaWYgKGR5bi0+ZF90YWcgPT0gRFRfTlVM TCkKKyAgICAgIGJyZWFrOworCisgICAgc3dpdGNoIChkeW4tPmRfdGFnKSB7CisgICAgY2FzZSBE VF9TWU1UQUI6CisgICAgICBhZGRyc1tpX3N5bXRhYl0gPSBkeW4tPmRfdW4uZF9wdHI7CisgICAg ICBicmVhazsKKworICAgIGNhc2UgRFRfSEFTSDoKKyAgICAgIGFkZHJzW2lfaGFzaF0gPSBkeW4t PmRfdW4uZF9wdHI7CisgICAgICBicmVhazsKKworICAgIGNhc2UgRFRfR05VX0hBU0g6CisgICAg ICBhZGRyc1tpX2dudV9oYXNoXSA9IGR5bi0+ZF91bi5kX3B0cjsKKyAgICAgIGJyZWFrOworCisg ICAgY2FzZSBEVF9TVFJUQUI6CisgICAgICBhZGRyc1tpX3N0cnRhYl0gPSBkeW4tPmRfdW4uZF9w dHI7CisgICAgICBicmVhazsKKworICAgIGNhc2UgRFRfVkVSU1lNOgorICAgICAgYWRkcnNbaV92 ZXJzeW1dID0gZHluLT5kX3VuLmRfcHRyOworICAgICAgYnJlYWs7CisKKyAgICBjYXNlIERUX1ZF UkRFRjoKKyAgICAgIGFkZHJzW2lfdmVyZGVmXSA9IGR5bi0+ZF91bi5kX3B0cjsKKyAgICAgIGJy ZWFrOworCisgICAgY2FzZSBEVF9WRVJORUVEOgorICAgICAgYWRkcnNbaV92ZXJuZWVkXSA9IGR5 bi0+ZF91bi5kX3B0cjsKKyAgICAgIGJyZWFrOworCisgICAgY2FzZSBEVF9TVFJTWjoKKyAgICAg IGFkZHJzW2lfc3Ryc3pdID0gZHluLT5kX3VuLmRfdmFsOworICAgIH0KKyAgfQorfQorCisKKy8q IFVzZSBkeW5hbWljIHNlZ21lbnQgdG8gZ2V0IGRhdGEgZm9yIHRoZSBzdHJpbmcgdGFibGUgc2Vj dGlvbi4gICovCitzdGF0aWMgRWxmX0RhdGEgKgorZ2V0X2R5bnNjbl9zdHJ0YWIoRWxmICplbGYs IEdFbGZfUGhkciAqcGhkcikKK3sKKyAgRWxmX0RhdGEgKnN0cnRhYl9kYXRhOworICBHRWxmX0Fk ZHIgYWRkcnNbaV9tYXhdID0gezAsfTsKKyAgR0VsZl9PZmYgb2Zmc1tpX21heF0gPSB7MCx9Owor ICBnZXRfZHluc2NuX2FkZHJzKGVsZiwgcGhkciwgYWRkcnMpOworICBmaW5kX29mZnNldHMoZWxm LCAwLCBpX21heCwgYWRkcnMsIG9mZnMpOworICBzdHJ0YWJfZGF0YSA9IGVsZl9nZXRkYXRhX3Jh d2NodW5rKAorICAgICAgICAgIGVsZiwgb2Zmc1tpX3N0cnRhYl0sIGFkZHJzW2lfc3Ryc3pdLCBF TEZfVF9CWVRFKTsKKyAgcmV0dXJuIHN0cnRhYl9kYXRhOworfQorCisKIHN0cnVjdCBsaXN0cHRy CiB7CiAgIER3YXJmX09mZiBvZmZzZXQ6KDY0IC0gMyk7CmRpZmYgLS1naXQgYS90ZXN0cy9NYWtl ZmlsZS5hbSBiL3Rlc3RzL01ha2VmaWxlLmFtCmluZGV4IDg0YzM5NTBhLi4xZmMzNGJkZiAxMDA2 NDQKLS0tIGEvdGVzdHMvTWFrZWZpbGUuYW0KKysrIGIvdGVzdHMvTWFrZWZpbGUuYW0KQEAgLTE5 Nyw3ICsxOTcsOCBAQCBURVNUUyA9IHJ1bi1hcmV4dHJhY3Quc2ggcnVuLWFyc3ltdGVzdC5zaCBy dW4tYXIuc2ggbmV3ZmlsZSB0ZXN0LW5saXN0IFwKIAltc2dfdHN0IHN5c3RlbS1lbGYtbGliZWxm LXRlc3QgXAogCSQoYXNtX1RFU1RTKSBydW4tZGlzYXNtLWJwZi5zaCBydW4tbG93X2hpZ2hfcGMt ZHctZm9ybS1pbmRpcmVjdC5zaCBcCiAJcnVuLW52aWRpYS1leHRlbmRlZC1saW5lbWFwLWxpYmR3 LnNoIHJ1bi1udmlkaWEtZXh0ZW5kZWQtbGluZW1hcC1yZWFkZWxmLnNoIFwKLQlydW4tcmVhZGVs Zi1kdy1mb3JtLWluZGlyZWN0LnNoIHJ1bi1zdHJpcC1sYXJnZWFsaWduLnNoCisJcnVuLXJlYWRl bGYtZHctZm9ybS1pbmRpcmVjdC5zaCBydW4tc3RyaXAtbGFyZ2VhbGlnbi5zaCBcCisJcnVuLXJl YWRlbGYtRGQuc2gKIAogaWYgIUJJQVJDSAogZXhwb3J0IEVMRlVUSUxTX0RJU0FCTEVfQklBUkNI ID0gMQpAQCAtMzc1LDYgKzM3Niw3IEBAIEVYVFJBX0RJU1QgPSBydW4tYXJleHRyYWN0LnNoIHJ1 bi1hcnN5bXRlc3Quc2ggcnVuLWFyLnNoIFwKIAkgICAgIHRlc3RmaWxlNTYuYnoyIHRlc3RmaWxl NTcuYnoyIHRlc3RmaWxlNTguYnoyIFwKIAkgICAgIHJ1bi10eXBlaXRlci5zaCB0ZXN0ZmlsZTU5 LmJ6MiBcCiAJICAgICBydW4tcmVhZGVsZi1kLnNoIHRlc3RsaWJfZHluc2VnLnNvLmJ6MiBcCisJ ICAgICBydW4tcmVhZGVsZi1EZC5zaCBcCiAJICAgICB0ZXN0ZmlsZS1zMzkweC1oYXNoLWJvdGgu YnoyIFwKIAkgICAgIHJ1bi1yZWFkZWxmLWdkYl9pbmRleC5zaCB0ZXN0ZmlsZWdkYmluZGV4NS5i ejIgXAogCSAgICAgdGVzdGZpbGVnZGJpbmRleDcuYnoyIFwKZGlmZiAtLWdpdCBhL3Rlc3RzL3J1 bi1yZWFkZWxmLURkLnNoIGIvdGVzdHMvcnVuLXJlYWRlbGYtRGQuc2gKbmV3IGZpbGUgbW9kZSAx MDA3NTUKaW5kZXggMDAwMDAwMDAuLjhjNjk5OTM3Ci0tLSAvZGV2L251bGwKKysrIGIvdGVzdHMv cnVuLXJlYWRlbGYtRGQuc2gKQEAgLTAsMCArMSw2NiBAQAorIyEgL2Jpbi9zaAorIyBDb3B5cmln aHQgKEMpIDIwMjIgUmVkIEhhdCwgSW5jLgorIyBUaGlzIGZpbGUgaXMgcGFydCBvZiBlbGZ1dGls cy4KKyMKKyMgVGhpcyBmaWxlIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vciBtb2RpZnkKKyMgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyMgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IKKyMgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyMKKyMgZWxmdXRpbHMgaXMgZGlzdHJpYnV0ZWQg aW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisjIFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyMgTUVSQ0hBTlRB QklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorIyBH TlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorIworIyBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZQorIyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3Lmdu dS5vcmcvbGljZW5zZXMvPi4KKworLiAkc3JjZGlyL3Rlc3Qtc3Vici5zaAorCisjICNpbmNsdWRl IDxzdGRpby5oPgorIworIyBfX3RocmVhZCBpbnQgaTsKKyMKKyMgdm9pZCBwcmludF9pICgpCisj IHsKKyMgICBwcmludGYoIiVkXG4iLCBpKTsKKyMgfQorIworIyBnY2MgLWZQSUMgLXNoYXJlZCAt byB0ZXN0bGliX2R5bnNlZy5zbyB0ZXN0bGliX2R5bnNlZy5jCisjIFdpdGggbGQgLS12ZXJzaW9u CisjIEdOVSBnb2xkIChHTlUgQmludXRpbHMgMi4yMi41Mi4yMDEyMDQwMikgMS4xMQorCisjIFRo ZSBzYW1lIHRlc3RmaWxlIGlzIHVzZWQgaW4gcnVuLXJlYWRlbGYtZC5zaAordGVzdGZpbGVzIHRl c3RsaWJfZHluc2VnLnNvCisKK3Rlc3RydW5fY29tcGFyZSAke2Fic190b3BfYnVpbGRkaXJ9L3Ny Yy9yZWFkZWxmIC1EZCB0ZXN0bGliX2R5bnNlZy5zbyA8PFxFT0YKKworRHluYW1pYyBzZWdtZW50 IGNvbnRhaW5zIDIzIGVudHJpZXM6CisgQWRkcjogMHgwMDAwMDAwMDAwMDAxN2UwICBPZmZzZXQ6 IDB4MDAwN2UwCisgIFR5cGUgICAgICAgICAgICAgIFZhbHVlCisgIFBMVEdPVCAgICAgICAgICAg IDB4MDAwMDAwMDAwMDAwMTljOAorICBQTFRSRUxTWiAgICAgICAgICA3MiAoYnl0ZXMpCisgIEpN UFJFTCAgICAgICAgICAgIDB4MDAwMDAwMDAwMDAwMDU2OAorICBQTFRSRUwgICAgICAgICAgICBS RUxBCisgIFJFTEEgICAgICAgICAgICAgIDB4MDAwMDAwMDAwMDAwMDRkOAorICBSRUxBU1ogICAg ICAgICAgICAxNDQgKGJ5dGVzKQorICBSRUxBRU5UICAgICAgICAgICAyNCAoYnl0ZXMpCisgIFJF TEFDT1VOVCAgICAgICAgIDEKKyAgU1lNVEFCICAgICAgICAgICAgMHgwMDAwMDAwMDAwMDAwMjI4 CisgIFNZTUVOVCAgICAgICAgICAgIDI0IChieXRlcykKKyAgU1RSVEFCICAgICAgICAgICAgMHgw MDAwMDAwMDAwMDAwMzYwCisgIFNUUlNaICAgICAgICAgICAgIDE5MCAoYnl0ZXMpCisgIEdOVV9I QVNIICAgICAgICAgIDB4MDAwMDAwMDAwMDAwMDQyMAorICBORUVERUQgICAgICAgICAgICBTaGFy ZWQgbGlicmFyeTogW2xpYmMuc28uNl0KKyAgTkVFREVEICAgICAgICAgICAgU2hhcmVkIGxpYnJh cnk6IFtsZC1saW51eC14ODYtNjQuc28uMl0KKyAgSU5JVCAgICAgICAgICAgICAgMHgwMDAwMDAw MDAwMDAwNWIwCisgIEZJTkkgICAgICAgICAgICAgIDB4MDAwMDAwMDAwMDAwMDc0OAorICBWRVJT WU0gICAgICAgICAgICAweDAwMDAwMDAwMDAwMDA0NjAKKyAgVkVSREVGICAgICAgICAgICAgMHgw MDAwMDAwMDAwMDAwNDdjCisgIFZFUkRFRk5VTSAgICAgICAgIDEKKyAgVkVSTkVFRCAgICAgICAg ICAgMHgwMDAwMDAwMDAwMDAwNDk4CisgIFZFUk5FRUROVU0gICAgICAgIDIKKyAgTlVMTCAgICAg ICAgICAgICAgCitFT0YKKworZXhpdCAwCi0tIAoyLjM1LjMKCg== --000000000000d9370005dfc3f447--