| /* |
| * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. |
| * |
| * @APPLE_LICENSE_HEADER_START@ |
| * |
| * This file contains Original Code and/or Modifications of Original Code |
| * as defined in and that are subject to the Apple Public Source License |
| * Version 2.0 (the 'License'). You may not use this file except in |
| * compliance with the License. Please obtain a copy of the License at |
| * http://www.opensource.apple.com/apsl/ and read it before using this |
| * file. |
| * |
| * The Original Code and all software distributed under the License are |
| * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
| * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
| * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
| * Please see the License for the specific language governing rights and |
| * limitations under the License. |
| * |
| * @APPLE_LICENSE_HEADER_END@ |
| */ |
| /* |
| * Copyright (c) 1989, 1993 |
| * The Regents of the University of California. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. All advertising materials mentioning features or use of this software |
| * must display the following acknowledgement: |
| * This product includes software developed by the University of |
| * California, Berkeley and its contributors. |
| * 4. Neither the name of the University nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| |
| |
| /* |
| * This file was copied from libc/gen/nlist.c from Darwin's source code |
| * The version of nlist used as a base is from 10.5.2, libc-498 |
| * http://www.opensource.apple.com/darwinsource/10.5.2/Libc-498/gen/nlist.c |
| * |
| * The full tarball is at: |
| * http://www.opensource.apple.com/darwinsource/tarballs/apsl/Libc-498.tar.gz |
| * |
| * I've modified it to be compatible with 64-bit images. |
| */ |
| |
| #include "breakpad_nlist_64.h" |
| |
| #include <CoreFoundation/CoreFoundation.h> |
| #include <fcntl.h> |
| #include <mach-o/nlist.h> |
| #include <mach-o/loader.h> |
| #include <mach-o/fat.h> |
| #include <mach/mach.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <sys/types.h> |
| #include <sys/uio.h> |
| #include <TargetConditionals.h> |
| #include <unistd.h> |
| |
| /* Stuff lifted from <a.out.h> and <sys/exec.h> since they are gone */ |
| /* |
| * Header prepended to each a.out file. |
| */ |
| struct exec { |
| unsigned short a_machtype; /* machine type */ |
| unsigned short a_magic; /* magic number */ |
| unsigned long a_text; /* size of text segment */ |
| unsigned long a_data; /* size of initialized data */ |
| unsigned long a_bss; /* size of uninitialized data */ |
| unsigned long a_syms; /* size of symbol table */ |
| unsigned long a_entry; /* entry point */ |
| unsigned long a_trsize; /* size of text relocation */ |
| unsigned long a_drsize; /* size of data relocation */ |
| }; |
| |
| #define OMAGIC 0407 /* old impure format */ |
| #define NMAGIC 0410 /* read-only text */ |
| #define ZMAGIC 0413 /* demand load format */ |
| |
| #define N_BADMAG(x) \ |
| (((x).a_magic)!=OMAGIC && ((x).a_magic)!=NMAGIC && ((x).a_magic)!=ZMAGIC) |
| #define N_TXTOFF(x) \ |
| ((x).a_magic==ZMAGIC ? 0 : sizeof (struct exec)) |
| #define N_SYMOFF(x) \ |
| (N_TXTOFF(x) + (x).a_text+(x).a_data + (x).a_trsize+(x).a_drsize) |
| |
| // Traits structs for specializing function templates to handle |
| // 32-bit/64-bit Mach-O files. |
| template<typename T> |
| struct MachBits {}; |
| |
| typedef struct nlist nlist32; |
| typedef struct nlist_64 nlist64; |
| |
| template<> |
| struct MachBits<nlist32> { |
| typedef mach_header mach_header_type; |
| typedef uint32_t word_type; |
| static const uint32_t magic = MH_MAGIC; |
| }; |
| |
| template<> |
| struct MachBits<nlist64> { |
| typedef mach_header_64 mach_header_type; |
| typedef uint64_t word_type; |
| static const uint32_t magic = MH_MAGIC_64; |
| }; |
| |
| template<typename nlist_type> |
| int |
| __breakpad_fdnlist(int fd, nlist_type* list, const char** symbolNames, |
| cpu_type_t cpu_type); |
| |
| /* |
| * nlist - retreive attributes from name list (string table version) |
| */ |
| |
| template <typename nlist_type> |
| int breakpad_nlist_common(const char* name, |
| nlist_type* list, |
| const char** symbolNames, |
| cpu_type_t cpu_type) { |
| int fd = open(name, O_RDONLY, 0); |
| if (fd < 0) |
| return -1; |
| int n = __breakpad_fdnlist(fd, list, symbolNames, cpu_type); |
| close(fd); |
| return n; |
| } |
| |
| int breakpad_nlist(const char* name, |
| struct nlist* list, |
| const char** symbolNames, |
| cpu_type_t cpu_type) { |
| return breakpad_nlist_common(name, list, symbolNames, cpu_type); |
| } |
| |
| int breakpad_nlist(const char* name, |
| struct nlist_64* list, |
| const char** symbolNames, |
| cpu_type_t cpu_type) { |
| return breakpad_nlist_common(name, list, symbolNames, cpu_type); |
| } |
| |
| /* Note: __fdnlist() is called from kvm_nlist in libkvm's kvm.c */ |
| |
| template<typename nlist_type> |
| int __breakpad_fdnlist(int fd, nlist_type* list, const char** symbolNames, |
| cpu_type_t cpu_type) { |
| typedef typename MachBits<nlist_type>::mach_header_type mach_header_type; |
| typedef typename MachBits<nlist_type>::word_type word_type; |
| |
| const uint32_t magic = MachBits<nlist_type>::magic; |
| |
| int maxlen = 500; |
| int nreq = 0; |
| for (nlist_type* q = list; |
| symbolNames[q-list] && symbolNames[q-list][0]; |
| q++, nreq++) { |
| |
| q->n_type = 0; |
| q->n_value = 0; |
| q->n_desc = 0; |
| q->n_sect = 0; |
| q->n_un.n_strx = 0; |
| } |
| |
| struct exec buf; |
| if (read(fd, (char*)&buf, sizeof(buf)) != sizeof(buf) || |
| (N_BADMAG(buf) && *((uint32_t*)&buf) != magic && |
| CFSwapInt32BigToHost(*((uint32_t*)&buf)) != FAT_MAGIC && |
| /* The following is the big-endian ppc64 check */ |
| (*((uint32_t*)&buf)) != FAT_MAGIC)) { |
| return -1; |
| } |
| |
| /* Deal with fat file if necessary */ |
| unsigned arch_offset = 0; |
| if (CFSwapInt32BigToHost(*((uint32_t*)&buf)) == FAT_MAGIC || |
| /* The following is the big-endian ppc64 check */ |
| *((unsigned int*)&buf) == FAT_MAGIC) { |
| /* Read in the fat header */ |
| struct fat_header fh; |
| if (lseek(fd, 0, SEEK_SET) == -1) { |
| return -1; |
| } |
| if (read(fd, (char*)&fh, sizeof(fh)) != sizeof(fh)) { |
| return -1; |
| } |
| |
| /* Convert fat_narchs to host byte order */ |
| fh.nfat_arch = CFSwapInt32BigToHost(fh.nfat_arch); |
| |
| /* Read in the fat archs */ |
| struct fat_arch* fat_archs = |
| (struct fat_arch*)malloc(fh.nfat_arch * sizeof(struct fat_arch)); |
| if (fat_archs == NULL) { |
| return -1; |
| } |
| if (read(fd, (char*)fat_archs, |
| sizeof(struct fat_arch) * fh.nfat_arch) != |
| (ssize_t)(sizeof(struct fat_arch) * fh.nfat_arch)) { |
| free(fat_archs); |
| return -1; |
| } |
| |
| /* |
| * Convert archs to host byte ordering (a constraint of |
| * cpusubtype_getbestarch() |
| */ |
| for (unsigned i = 0; i < fh.nfat_arch; i++) { |
| fat_archs[i].cputype = |
| CFSwapInt32BigToHost(fat_archs[i].cputype); |
| fat_archs[i].cpusubtype = |
| CFSwapInt32BigToHost(fat_archs[i].cpusubtype); |
| fat_archs[i].offset = |
| CFSwapInt32BigToHost(fat_archs[i].offset); |
| fat_archs[i].size = |
| CFSwapInt32BigToHost(fat_archs[i].size); |
| fat_archs[i].align = |
| CFSwapInt32BigToHost(fat_archs[i].align); |
| } |
| |
| struct fat_arch* fap = NULL; |
| for (unsigned i = 0; i < fh.nfat_arch; i++) { |
| if (fat_archs[i].cputype == cpu_type) { |
| fap = &fat_archs[i]; |
| break; |
| } |
| } |
| |
| if (!fap) { |
| free(fat_archs); |
| return -1; |
| } |
| arch_offset = fap->offset; |
| free(fat_archs); |
| |
| /* Read in the beginning of the architecture-specific file */ |
| if (lseek(fd, arch_offset, SEEK_SET) == -1) { |
| return -1; |
| } |
| if (read(fd, (char*)&buf, sizeof(buf)) != sizeof(buf)) { |
| return -1; |
| } |
| } |
| |
| off_t sa; /* symbol address */ |
| off_t ss; /* start of strings */ |
| register_t n; |
| if (*((unsigned int*)&buf) == magic) { |
| if (lseek(fd, arch_offset, SEEK_SET) == -1) { |
| return -1; |
| } |
| mach_header_type mh; |
| if (read(fd, (char*)&mh, sizeof(mh)) != sizeof(mh)) { |
| return -1; |
| } |
| |
| struct load_command* load_commands = |
| (struct load_command*)malloc(mh.sizeofcmds); |
| if (load_commands == NULL) { |
| return -1; |
| } |
| if (read(fd, (char*)load_commands, mh.sizeofcmds) != |
| (ssize_t)mh.sizeofcmds) { |
| free(load_commands); |
| return -1; |
| } |
| struct symtab_command* stp = NULL; |
| struct load_command* lcp = load_commands; |
| // iterate through all load commands, looking for |
| // LC_SYMTAB load command |
| for (uint32_t i = 0; i < mh.ncmds; i++) { |
| if (lcp->cmdsize % sizeof(word_type) != 0 || |
| lcp->cmdsize <= 0 || |
| (char*)lcp + lcp->cmdsize > (char*)load_commands + mh.sizeofcmds) { |
| free(load_commands); |
| return -1; |
| } |
| if (lcp->cmd == LC_SYMTAB) { |
| if (lcp->cmdsize != sizeof(struct symtab_command)) { |
| free(load_commands); |
| return -1; |
| } |
| stp = (struct symtab_command*)lcp; |
| break; |
| } |
| lcp = (struct load_command*)((char*)lcp + lcp->cmdsize); |
| } |
| if (stp == NULL) { |
| free(load_commands); |
| return -1; |
| } |
| // sa points to the beginning of the symbol table |
| sa = stp->symoff + arch_offset; |
| // ss points to the beginning of the string table |
| ss = stp->stroff + arch_offset; |
| // n is the number of bytes in the symbol table |
| // each symbol table entry is an nlist structure |
| n = stp->nsyms * sizeof(nlist_type); |
| free(load_commands); |
| } else { |
| sa = N_SYMOFF(buf) + arch_offset; |
| ss = sa + buf.a_syms + arch_offset; |
| n = buf.a_syms; |
| } |
| |
| if (lseek(fd, sa, SEEK_SET) == -1) { |
| return -1; |
| } |
| |
| // the algorithm here is to read the nlist entries in m-sized |
| // chunks into q. q is then iterated over. for each entry in q, |
| // use the string table index(q->n_un.n_strx) to read the symbol |
| // name, then scan the nlist entries passed in by the user(via p), |
| // and look for a match |
| while (n) { |
| nlist_type space[BUFSIZ/sizeof (nlist_type)]; |
| register_t m = sizeof (space); |
| |
| if (n < m) |
| m = n; |
| if (read(fd, (char*)space, m) != m) |
| break; |
| n -= m; |
| off_t savpos = lseek(fd, 0, SEEK_CUR); |
| if (savpos == -1) { |
| return -1; |
| } |
| for (nlist_type* q = space; (m -= sizeof(nlist_type)) >= 0; q++) { |
| char nambuf[BUFSIZ]; |
| |
| if (q->n_un.n_strx == 0 || q->n_type & N_STAB) |
| continue; |
| |
| // seek to the location in the binary where the symbol |
| // name is stored & read it into memory |
| if (lseek(fd, ss+q->n_un.n_strx, SEEK_SET) == -1) { |
| return -1; |
| } |
| if (read(fd, nambuf, maxlen+1) == -1) { |
| return -1; |
| } |
| const char* s2 = nambuf; |
| for (nlist_type* p = list; |
| symbolNames[p-list] && symbolNames[p-list][0]; |
| p++) { |
| // get the symbol name the user has passed in that |
| // corresponds to the nlist entry that we're looking at |
| const char* s1 = symbolNames[p - list]; |
| while (*s1) { |
| if (*s1++ != *s2++) |
| goto cont; |
| } |
| if (*s2) |
| goto cont; |
| |
| p->n_value = q->n_value; |
| p->n_type = q->n_type; |
| p->n_desc = q->n_desc; |
| p->n_sect = q->n_sect; |
| p->n_un.n_strx = q->n_un.n_strx; |
| if (--nreq == 0) |
| return nreq; |
| |
| break; |
| cont: ; |
| } |
| } |
| if (lseek(fd, savpos, SEEK_SET) == -1) { |
| return -1; |
| } |
| } |
| return nreq; |
| } |
