From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 35D7B139082 for ; Sun, 22 Jan 2017 17:59:46 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 478E3E0EF0; Sun, 22 Jan 2017 17:59:35 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id 12497E0EEF for ; Sun, 22 Jan 2017 17:59:35 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 0F9DF34168D for ; Sun, 22 Jan 2017 17:59:34 +0000 (UTC) Received: from localhost.localdomain (localhost [127.0.0.1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 6E87B2CB8 for ; Sun, 22 Jan 2017 17:59:32 +0000 (UTC) From: "Mike Frysinger" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Mike Frysinger" Message-ID: <1479945678.b091c4764133a1eab7921809f3b4aee938faa194.vapier@gentoo> Subject: [gentoo-commits] proj/pax-utils:master commit in: / X-VCS-Repository: proj/pax-utils X-VCS-Files: scanelf.c X-VCS-Directories: / X-VCS-Committer: vapier X-VCS-Committer-Name: Mike Frysinger X-VCS-Revision: b091c4764133a1eab7921809f3b4aee938faa194 X-VCS-Branch: master Date: Sun, 22 Jan 2017 17:59:32 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Archives-Salt: fd580ab6-3e1a-45d7-8e5f-55fdbaf7d35a X-Archives-Hash: aaa9f26d002738a7177a6c80c90d1818 commit: b091c4764133a1eab7921809f3b4aee938faa194 Author: Mike Frysinger gentoo org> AuthorDate: Thu Nov 24 00:01:18 2016 +0000 Commit: Mike Frysinger gentoo org> CommitDate: Thu Nov 24 00:01:18 2016 +0000 URL: https://gitweb.gentoo.org/proj/pax-utils.git/commit/?id=b091c476 scanelf: standardize macro indentation levels The style for indentation of ELF macros has drifted over time. Realign them all to follow the same style. No functional changes. scanelf.c | 509 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 254 insertions(+), 255 deletions(-) diff --git a/scanelf.c b/scanelf.c index 71288fc..5632527 100644 --- a/scanelf.c +++ b/scanelf.c @@ -690,114 +690,114 @@ static void scanelf_file_rpath(elfobj *elf, char *found_rpath, char **ret, size_ rpath = runpath = NULL; #define SHOW_RPATH(B) \ - Elf ## B ## _Dyn *dyn; \ - Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ - Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ - Elf ## B ## _Shdr *strtbl = SHDR ## B (strtbl_void); \ - Elf ## B ## _Off offset; \ - Elf ## B ## _Xword word; \ - /* Scan all the program headers */ \ - for (i = 0; i < EGET(ehdr->e_phnum); i++) { \ - /* Just scan dynamic headers */ \ - if (EGET(phdr[i].p_type) != PT_DYNAMIC || EGET(phdr[i].p_filesz) == 0) continue; \ - offset = EGET(phdr[i].p_offset); \ - if (offset >= elf->len - sizeof(Elf ## B ## _Dyn)) continue; \ - /* Just scan dynamic RPATH/RUNPATH headers */ \ - dyn = DYN ## B (elf->vdata + offset); \ - while ((word=EGET(dyn->d_tag)) != DT_NULL) { \ - if (word == DT_RPATH) { \ - r = &rpath; \ - } else if (word == DT_RUNPATH) { \ - r = &runpath; \ - } else { \ - ++dyn; \ - continue; \ + Elf ## B ## _Dyn *dyn; \ + Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ + Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ + Elf ## B ## _Shdr *strtbl = SHDR ## B (strtbl_void); \ + Elf ## B ## _Off offset; \ + Elf ## B ## _Xword word; \ + /* Scan all the program headers */ \ + for (i = 0; i < EGET(ehdr->e_phnum); i++) { \ + /* Just scan dynamic headers */ \ + if (EGET(phdr[i].p_type) != PT_DYNAMIC || EGET(phdr[i].p_filesz) == 0) continue; \ + offset = EGET(phdr[i].p_offset); \ + if (offset >= elf->len - sizeof(Elf ## B ## _Dyn)) continue; \ + /* Just scan dynamic RPATH/RUNPATH headers */ \ + dyn = DYN ## B (elf->vdata + offset); \ + while ((word=EGET(dyn->d_tag)) != DT_NULL) { \ + if (word == DT_RPATH) { \ + r = &rpath; \ + } else if (word == DT_RUNPATH) { \ + r = &runpath; \ + } else { \ + ++dyn; \ + continue; \ + } \ + /* Verify the memory is somewhat sane */ \ + offset = EGET(strtbl->sh_offset) + EGET(dyn->d_un.d_ptr); \ + if (offset < (Elf ## B ## _Off)elf->len) { \ + if (*r) warn("ELF has multiple %s's !?", get_elfdtype(word)); \ + *r = elf->data + offset; \ + /* cache the length in case we need to nuke this section later on */ \ + if (fix_elf) \ + offset = strlen(*r); \ + /* If quiet, don't output paths in ld.so.conf */ \ + if (be_quiet) { \ + size_t len; \ + char *start, *end; \ + /* note that we only 'chop' off leading known paths. */ \ + /* since *r is read-only memory, we can only move the ptr forward. */ \ + start = *r; \ + /* scan each path in : delimited list */ \ + while (start) { \ + rpath_security_checks(elf, start, get_elfdtype(word)); \ + end = strchr(start, ':'); \ + len = (end ? abs(end - start) : strlen(start)); \ + if (use_ldcache) { \ + size_t n; \ + const char *ldpath; \ + array_for_each(ldpaths, n, ldpath) \ + if (!strncmp(ldpath, start, len) && !ldpath[len]) { \ + *r = end; \ + /* corner case ... if RPATH reads "/usr/lib:", we want \ + * to show ':' rather than '' */ \ + if (end && end[1] != '\0') \ + (*r)++; \ + break; \ + } \ + } \ + if (!*r || !end) \ + break; \ + else \ + start = start + len + 1; \ + } \ } \ - /* Verify the memory is somewhat sane */ \ - offset = EGET(strtbl->sh_offset) + EGET(dyn->d_un.d_ptr); \ - if (offset < (Elf ## B ## _Off)elf->len) { \ - if (*r) warn("ELF has multiple %s's !?", get_elfdtype(word)); \ - *r = elf->data + offset; \ - /* cache the length in case we need to nuke this section later on */ \ - if (fix_elf) \ - offset = strlen(*r); \ - /* If quiet, don't output paths in ld.so.conf */ \ - if (be_quiet) { \ - size_t len; \ + if (*r) { \ + if (fix_elf > 2 || (fix_elf && **r == '\0')) { \ + /* just nuke it */ \ + nuke_it##B: \ + memset(*r, 0x00, offset); \ + *r = NULL; \ + ESET(dyn->d_tag, DT_DEBUG); \ + ESET(dyn->d_un.d_ptr, 0); \ + } else if (fix_elf) { \ + /* try to clean "bad" paths */ \ + size_t len, tmpdir_len; \ char *start, *end; \ - /* note that we only 'chop' off leading known paths. */ \ - /* since *r is read-only memory, we can only move the ptr forward. */ \ + const char *tmpdir; \ start = *r; \ - /* scan each path in : delimited list */ \ - while (start) { \ - rpath_security_checks(elf, start, get_elfdtype(word)); \ + tmpdir = (getenv("TMPDIR") ? : "."); \ + tmpdir_len = strlen(tmpdir); \ + while (1) { \ end = strchr(start, ':'); \ - len = (end ? abs(end - start) : strlen(start)); \ - if (use_ldcache) { \ - size_t n; \ - const char *ldpath; \ - array_for_each(ldpaths, n, ldpath) \ - if (!strncmp(ldpath, start, len) && !ldpath[len]) { \ - *r = end; \ - /* corner case ... if RPATH reads "/usr/lib:", we want \ - * to show ':' rather than '' */ \ - if (end && end[1] != '\0') \ - (*r)++; \ - break; \ - } \ + if (start == end) { \ + eat_this_path##B: \ + len = strlen(end); \ + memmove(start, end+1, len); \ + start[len-1] = '\0'; \ + end = start - 1; \ + } else if (tmpdir && !strncmp(start, tmpdir, tmpdir_len)) { \ + if (!end) { \ + if (start == *r) \ + goto nuke_it##B; \ + *--start = '\0'; \ + } else \ + goto eat_this_path##B; \ } \ - if (!*r || !end) \ + if (!end) \ break; \ - else \ - start = start + len + 1; \ + start = end + 1; \ } \ + if (**r == '\0') \ + goto nuke_it##B; \ } \ - if (*r) { \ - if (fix_elf > 2 || (fix_elf && **r == '\0')) { \ - /* just nuke it */ \ - nuke_it##B: \ - memset(*r, 0x00, offset); \ - *r = NULL; \ - ESET(dyn->d_tag, DT_DEBUG); \ - ESET(dyn->d_un.d_ptr, 0); \ - } else if (fix_elf) { \ - /* try to clean "bad" paths */ \ - size_t len, tmpdir_len; \ - char *start, *end; \ - const char *tmpdir; \ - start = *r; \ - tmpdir = (getenv("TMPDIR") ? : "."); \ - tmpdir_len = strlen(tmpdir); \ - while (1) { \ - end = strchr(start, ':'); \ - if (start == end) { \ - eat_this_path##B: \ - len = strlen(end); \ - memmove(start, end+1, len); \ - start[len-1] = '\0'; \ - end = start - 1; \ - } else if (tmpdir && !strncmp(start, tmpdir, tmpdir_len)) { \ - if (!end) { \ - if (start == *r) \ - goto nuke_it##B; \ - *--start = '\0'; \ - } else \ - goto eat_this_path##B; \ - } \ - if (!end) \ - break; \ - start = end + 1; \ - } \ - if (**r == '\0') \ - goto nuke_it##B; \ - } \ - if (*r) \ - *found_rpath = 1; \ - } \ + if (*r) \ + *found_rpath = 1; \ } \ - ++dyn; \ } \ - } + ++dyn; \ + } \ + } if (elf->phdr && strtbl_void) SCANELF_ELF_SIZED(SHOW_RPATH); @@ -852,65 +852,65 @@ static const char *scanelf_file_needed_lib(elfobj *elf, char *found_needed, char strtbl_void = elf_findsecbyname(elf, ".dynstr"); #define SHOW_NEEDED(B) \ - Elf ## B ## _Dyn *dyn; \ - Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ - Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ - Elf ## B ## _Shdr *strtbl = SHDR ## B (strtbl_void); \ - Elf ## B ## _Off offset; \ - size_t matched = 0; \ - /* Walk all the program headers to find the PT_DYNAMIC */ \ - for (i = 0; i < EGET(ehdr->e_phnum); i++) { \ - if (EGET(phdr[i].p_type) != PT_DYNAMIC || EGET(phdr[i].p_filesz) == 0) \ - continue; \ - offset = EGET(phdr[i].p_offset); \ - if (offset >= elf->len - sizeof(Elf ## B ## _Dyn)) \ - continue; \ - /* Walk all the dynamic tags to find NEEDED entries */ \ - dyn = DYN ## B (elf->vdata + offset); \ - while (EGET(dyn->d_tag) != DT_NULL) { \ - if (EGET(dyn->d_tag) == DT_NEEDED) { \ - offset = EGET(strtbl->sh_offset) + EGET(dyn->d_un.d_ptr); \ - if (offset >= (Elf ## B ## _Off)elf->len) { \ - ++dyn; \ - continue; \ - } \ - needed = elf->data + offset; \ - if (op == 0) { \ - /* -n -> print all entries */ \ - if (!be_wewy_wewy_quiet) { \ - if (*found_needed) xchrcat(ret, ',', ret_len); \ - if (use_ldpath) { \ - if ((p = lookup_config_lib(needed)) != NULL) \ - needed = p; \ - } else if (use_ldcache) { \ - if ((p = ldso_cache_lookup_lib(elf, needed)) != NULL) \ - needed = p; \ - } \ - xstrcat(ret, needed, ret_len); \ - } \ - *found_needed = 1; \ - } else { \ - /* -N -> print matching entries */ \ - size_t n; \ - const char *find_lib_name; \ - \ - array_for_each(find_lib_arr, n, find_lib_name) { \ - int invert = 1; \ - if (find_lib_name[0] == '!') \ - invert = 0, ++find_lib_name; \ - if ((!strcmp(find_lib_name, needed)) == invert) \ - ++matched; \ - } \ - \ - if (matched == array_cnt(find_lib_arr)) { \ - *found_lib = 1; \ - return (be_wewy_wewy_quiet ? NULL : find_lib); \ + Elf ## B ## _Dyn *dyn; \ + Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ + Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ + Elf ## B ## _Shdr *strtbl = SHDR ## B (strtbl_void); \ + Elf ## B ## _Off offset; \ + size_t matched = 0; \ + /* Walk all the program headers to find the PT_DYNAMIC */ \ + for (i = 0; i < EGET(ehdr->e_phnum); i++) { \ + if (EGET(phdr[i].p_type) != PT_DYNAMIC || EGET(phdr[i].p_filesz) == 0) \ + continue; \ + offset = EGET(phdr[i].p_offset); \ + if (offset >= elf->len - sizeof(Elf ## B ## _Dyn)) \ + continue; \ + /* Walk all the dynamic tags to find NEEDED entries */ \ + dyn = DYN ## B (elf->vdata + offset); \ + while (EGET(dyn->d_tag) != DT_NULL) { \ + if (EGET(dyn->d_tag) == DT_NEEDED) { \ + offset = EGET(strtbl->sh_offset) + EGET(dyn->d_un.d_ptr); \ + if (offset >= (Elf ## B ## _Off)elf->len) { \ + ++dyn; \ + continue; \ + } \ + needed = elf->data + offset; \ + if (op == 0) { \ + /* -n -> print all entries */ \ + if (!be_wewy_wewy_quiet) { \ + if (*found_needed) xchrcat(ret, ',', ret_len); \ + if (use_ldpath) { \ + if ((p = lookup_config_lib(needed)) != NULL) \ + needed = p; \ + } else if (use_ldcache) { \ + if ((p = ldso_cache_lookup_lib(elf, needed)) != NULL) \ + needed = p; \ } \ + xstrcat(ret, needed, ret_len); \ + } \ + *found_needed = 1; \ + } else { \ + /* -N -> print matching entries */ \ + size_t n; \ + const char *find_lib_name; \ + \ + array_for_each(find_lib_arr, n, find_lib_name) { \ + int invert = 1; \ + if (find_lib_name[0] == '!') \ + invert = 0, ++find_lib_name; \ + if ((!strcmp(find_lib_name, needed)) == invert) \ + ++matched; \ + } \ + \ + if (matched == array_cnt(find_lib_arr)) { \ + *found_lib = 1; \ + return (be_wewy_wewy_quiet ? NULL : find_lib); \ } \ } \ - ++dyn; \ } \ - } + ++dyn; \ + } \ + } if (elf->phdr && strtbl_void) { SCANELF_ELF_SIZED(SHOW_NEEDED); if (op == 0 && !*found_needed && be_verbose) @@ -928,23 +928,23 @@ static char *scanelf_file_interp(elfobj *elf, char *found_interp) if (elf->phdr) { /* Walk all the program headers to find the PT_INTERP */ #define SHOW_PT_INTERP(B) \ - size_t i; \ - Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ - Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ - for (i = 0; i < EGET(ehdr->e_phnum); ++i) { \ - if (EGET(phdr[i].p_type) == PT_INTERP) { \ - offset = EGET(phdr[i].p_offset); \ - break; \ - } \ - } + size_t i; \ + Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ + Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ + for (i = 0; i < EGET(ehdr->e_phnum); ++i) { \ + if (EGET(phdr[i].p_type) == PT_INTERP) { \ + offset = EGET(phdr[i].p_offset); \ + break; \ + } \ + } SCANELF_ELF_SIZED(SHOW_PT_INTERP); } else if (elf->shdr) { /* Use the section headers to find it */ void *strtbl_void = elf_findsecbyname(elf, ".interp"); #define SHOW_INTERP(B) \ - Elf ## B ## _Shdr *strtbl = SHDR ## B (strtbl_void); \ - offset = EGET(strtbl->sh_offset); + Elf ## B ## _Shdr *strtbl = SHDR ## B (strtbl_void); \ + offset = EGET(strtbl->sh_offset); if (strtbl_void) SCANELF_ELF_SIZED(SHOW_INTERP); } @@ -973,27 +973,27 @@ static const char *scanelf_file_bind(elfobj *elf, char *found_bind) if (!elf->phdr) return NULL; #define SHOW_BIND(B) \ - Elf ## B ## _Dyn *dyn; \ - Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ - Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ - Elf ## B ## _Off offset; \ - for (i = 0; i < EGET(ehdr->e_phnum); i++) { \ - if (EGET(phdr[i].p_type) != PT_DYNAMIC || EGET(phdr[i].p_filesz) == 0) continue; \ - dynamic = true; \ - offset = EGET(phdr[i].p_offset); \ - if (offset >= elf->len - sizeof(Elf ## B ## _Dyn)) continue; \ - dyn = DYN ## B (elf->vdata + offset); \ - while (EGET(dyn->d_tag) != DT_NULL) { \ - if (EGET(dyn->d_tag) == DT_BIND_NOW || \ - (EGET(dyn->d_tag) == DT_FLAGS && EGET(dyn->d_un.d_val) & DF_BIND_NOW)) \ - { \ - if (be_quiet) return NULL; \ - *found_bind = 1; \ - return (char *)(be_wewy_wewy_quiet ? NULL : "NOW"); \ - } \ - ++dyn; \ + Elf ## B ## _Dyn *dyn; \ + Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ + Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ + Elf ## B ## _Off offset; \ + for (i = 0; i < EGET(ehdr->e_phnum); i++) { \ + if (EGET(phdr[i].p_type) != PT_DYNAMIC || EGET(phdr[i].p_filesz) == 0) continue; \ + dynamic = true; \ + offset = EGET(phdr[i].p_offset); \ + if (offset >= elf->len - sizeof(Elf ## B ## _Dyn)) continue; \ + dyn = DYN ## B (elf->vdata + offset); \ + while (EGET(dyn->d_tag) != DT_NULL) { \ + if (EGET(dyn->d_tag) == DT_BIND_NOW || \ + (EGET(dyn->d_tag) == DT_FLAGS && EGET(dyn->d_un.d_val) & DF_BIND_NOW)) \ + { \ + if (be_quiet) return NULL; \ + *found_bind = 1; \ + return (char *)(be_wewy_wewy_quiet ? NULL : "NOW"); \ } \ - } + ++dyn; \ + } \ + } SCANELF_ELF_SIZED(SHOW_BIND); if (be_wewy_wewy_quiet) return NULL; @@ -1017,33 +1017,33 @@ static char *scanelf_file_soname(elfobj *elf, char *found_soname) strtbl_void = elf_findsecbyname(elf, ".dynstr"); #define SHOW_SONAME(B) \ - Elf ## B ## _Dyn *dyn; \ - Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ - Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ - Elf ## B ## _Shdr *strtbl = SHDR ## B (strtbl_void); \ - Elf ## B ## _Off offset; \ - /* only look for soname in shared objects */ \ - if (EGET(ehdr->e_type) != ET_DYN) \ - return NULL; \ - for (i = 0; i < EGET(ehdr->e_phnum); i++) { \ - if (EGET(phdr[i].p_type) != PT_DYNAMIC || EGET(phdr[i].p_filesz) == 0) continue; \ - offset = EGET(phdr[i].p_offset); \ - if (offset >= elf->len - sizeof(Elf ## B ## _Dyn)) continue; \ - dyn = DYN ## B (elf->vdata + offset); \ - while (EGET(dyn->d_tag) != DT_NULL) { \ - if (EGET(dyn->d_tag) == DT_SONAME) { \ - offset = EGET(strtbl->sh_offset) + EGET(dyn->d_un.d_ptr); \ - if (offset >= (Elf ## B ## _Off)elf->len) { \ - ++dyn; \ - continue; \ - } \ - soname = elf->data + offset; \ - *found_soname = 1; \ - return (be_wewy_wewy_quiet ? NULL : soname); \ + Elf ## B ## _Dyn *dyn; \ + Elf ## B ## _Ehdr *ehdr = EHDR ## B (elf->ehdr); \ + Elf ## B ## _Phdr *phdr = PHDR ## B (elf->phdr); \ + Elf ## B ## _Shdr *strtbl = SHDR ## B (strtbl_void); \ + Elf ## B ## _Off offset; \ + /* only look for soname in shared objects */ \ + if (EGET(ehdr->e_type) != ET_DYN) \ + return NULL; \ + for (i = 0; i < EGET(ehdr->e_phnum); i++) { \ + if (EGET(phdr[i].p_type) != PT_DYNAMIC || EGET(phdr[i].p_filesz) == 0) continue; \ + offset = EGET(phdr[i].p_offset); \ + if (offset >= elf->len - sizeof(Elf ## B ## _Dyn)) continue; \ + dyn = DYN ## B (elf->vdata + offset); \ + while (EGET(dyn->d_tag) != DT_NULL) { \ + if (EGET(dyn->d_tag) == DT_SONAME) { \ + offset = EGET(strtbl->sh_offset) + EGET(dyn->d_un.d_ptr); \ + if (offset >= (Elf ## B ## _Off)elf->len) { \ + ++dyn; \ + continue; \ } \ - ++dyn; \ + soname = elf->data + offset; \ + *found_soname = 1; \ + return (be_wewy_wewy_quiet ? NULL : soname); \ } \ - } + ++dyn; \ + } \ + } if (elf->phdr && strtbl_void) SCANELF_ELF_SIZED(SHOW_SONAME); @@ -1226,39 +1226,38 @@ static char *scanelf_file_sym(elfobj *elf, char *found_sym) scanelf_file_get_symtabs(elf, &symtab_void, &strtab_void); - if (symtab_void && strtab_void) { #define FIND_SYM(B) \ - Elf ## B ## _Shdr *symtab = SHDR ## B (symtab_void); \ - Elf ## B ## _Shdr *strtab = SHDR ## B (strtab_void); \ - Elf ## B ## _Sym *sym = SYM ## B (elf->vdata + EGET(symtab->sh_offset)); \ - Elf ## B ## _Word i, cnt = EGET(symtab->sh_entsize); \ - char *symname; \ - size_t ret_len = 0; \ - if (cnt) \ - cnt = EGET(symtab->sh_size) / cnt; \ - for (i = 0; i < cnt; ++i) { \ - if ((void *)sym >= elf->data_end - sizeof(*sym)) \ - goto break_out; \ - if (sym->st_name) { \ - /* make sure the symbol name is in acceptable memory range */ \ - symname = elf->data + EGET(strtab->sh_offset) + EGET(sym->st_name); \ - if (EGET(sym->st_name) >= (uint64_t)elf->len || \ - EGET(strtab->sh_offset) + EGET(sym->st_name) >= (uint64_t)elf->len || \ - !memchr(symname, 0, elf->len - EGET(strtab->sh_offset) + EGET(sym->st_name))) \ - goto break_out; \ - scanelf_match_symname(elf, found_sym, \ - &ret, &ret_len, symname, \ - ELF##B##_ST_TYPE(EGET(sym->st_info)), \ - ELF##B##_ST_BIND(EGET(sym->st_info)), \ - ELF##B##_ST_VISIBILITY(EGET(sym->st_other)), \ - EGET(sym->st_shndx), \ - /* st_size can be 64bit, but no one is really that big, so screw em */ \ - EGET(sym->st_size)); \ - } \ - ++sym; \ - } - SCANELF_ELF_SIZED(FIND_SYM); + Elf ## B ## _Shdr *symtab = SHDR ## B (symtab_void); \ + Elf ## B ## _Shdr *strtab = SHDR ## B (strtab_void); \ + Elf ## B ## _Sym *sym = SYM ## B (elf->vdata + EGET(symtab->sh_offset)); \ + Elf ## B ## _Word i, cnt = EGET(symtab->sh_entsize); \ + char *symname; \ + size_t ret_len = 0; \ + if (cnt) \ + cnt = EGET(symtab->sh_size) / cnt; \ + for (i = 0; i < cnt; ++i) { \ + if ((void *)sym >= elf->data_end - sizeof(*sym)) \ + goto break_out; \ + if (sym->st_name) { \ + /* make sure the symbol name is in acceptable memory range */ \ + symname = elf->data + EGET(strtab->sh_offset) + EGET(sym->st_name); \ + if (EGET(sym->st_name) >= (uint64_t)elf->len || \ + EGET(strtab->sh_offset) + EGET(sym->st_name) >= (uint64_t)elf->len || \ + !memchr(symname, 0, elf->len - EGET(strtab->sh_offset) + EGET(sym->st_name))) \ + goto break_out; \ + scanelf_match_symname(elf, found_sym, \ + &ret, &ret_len, symname, \ + ELF##B##_ST_TYPE(EGET(sym->st_info)), \ + ELF##B##_ST_BIND(EGET(sym->st_info)), \ + ELF##B##_ST_VISIBILITY(EGET(sym->st_other)), \ + EGET(sym->st_shndx), \ + /* st_size can be 64bit, but no one is really that big, so screw em */ \ + EGET(sym->st_size)); \ + } \ + ++sym; \ } + if (symtab_void && strtab_void) + SCANELF_ELF_SIZED(FIND_SYM); if (be_wewy_wewy_quiet) { free(ret); @@ -1286,21 +1285,21 @@ static const char *scanelf_file_sections(elfobj *elf, char *found_section) return NULL; #define FIND_SECTION(B) \ - size_t matched, n; \ - int invert; \ - const char *section_name; \ - Elf ## B ## _Shdr *section; \ - \ - matched = 0; \ - array_for_each(find_section_arr, n, section_name) { \ - invert = (*section_name == '!' ? 1 : 0); \ - section = SHDR ## B (elf_findsecbyname(elf, section_name + invert)); \ - if ((section == NULL && invert) || (section != NULL && !invert)) \ - ++matched; \ - } \ - \ - if (matched == array_cnt(find_section_arr)) \ - *found_section = 1; + size_t matched, n; \ + int invert; \ + const char *section_name; \ + Elf ## B ## _Shdr *section; \ + \ + matched = 0; \ + array_for_each(find_section_arr, n, section_name) { \ + invert = (*section_name == '!' ? 1 : 0); \ + section = SHDR ## B (elf_findsecbyname(elf, section_name + invert)); \ + if ((section == NULL && invert) || (section != NULL && !invert)) \ + ++matched; \ + } \ + \ + if (matched == array_cnt(find_section_arr)) \ + *found_section = 1; SCANELF_ELF_SIZED(FIND_SECTION); if (be_wewy_wewy_quiet)