/* $OpenBSD: nlist.c,v 1.37 2007/09/02 15:19:38 deraadt Exp $ */ /*- * Copyright (c) 1990, 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. 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. */ #ifndef lint #if 0 static char sccsid[] = "from: @(#)nlist.c 8.1 (Berkeley) 6/6/93"; #else static const char rcsid[] = "$OpenBSD: nlist.c,v 1.37 2007/09/02 15:19:38 deraadt Exp $"; #endif #endif /* not lint */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "extern.h" #include #include #include #include #ifdef _NLIST_DO_ELF #include #endif #ifdef _NLIST_DO_ECOFF #include #endif typedef struct nlist NLIST; #define _strx n_un.n_strx #define _name n_un.n_name static char *kfile; static char *fmterr; #if defined(_NLIST_DO_AOUT) static u_long get_kerntext(char *kfn, u_int magic); int __aout_knlist(int fd, DB *db, int ksyms) { int nsyms; struct exec ebuf; FILE *fp; NLIST nbuf; DBT data, key; int nr, strsize; size_t len; u_long kerntextoff; size_t snamesize = 0; char *strtab, buf[1024], *sname, *p; /* Read in exec structure. */ nr = read(fd, &ebuf, sizeof(struct exec)); if (nr != sizeof(struct exec)) { fmterr = "no exec header"; return (1); } /* Check magic number and symbol count. */ if (N_BADMAG(ebuf)) { fmterr = "bad magic number"; return (1); } /* Must have a symbol table. */ if (!ebuf.a_syms) { fmterr = "stripped"; return (-1); } /* Seek to string table. */ if (lseek(fd, N_STROFF(ebuf), SEEK_SET) == -1) { fmterr = "corrupted string table"; return (-1); } /* Read in the size of the string table. */ nr = read(fd, (char *)&strsize, sizeof(strsize)); if (nr != sizeof(strsize)) { fmterr = "no symbol table"; return (-1); } /* Read in the string table. */ strsize -= sizeof(strsize); if (!(strtab = malloc(strsize))) errx(1, "cannot allocate %d bytes for string table", strsize); if ((nr = read(fd, strtab, strsize)) != strsize) { fmterr = "corrupted symbol table"; return (-1); } /* Seek to symbol table. */ if (!(fp = fdopen(fd, "r"))) err(1, "%s", kfile); if (fseek(fp, N_SYMOFF(ebuf), SEEK_SET) == -1) { warn("fseek %s", kfile); return (-1); } data.data = (u_char *)&nbuf; data.size = sizeof(NLIST); kerntextoff = get_kerntext(kfile, N_GETMAGIC(ebuf)); /* Read each symbol and enter it into the database. */ nsyms = ebuf.a_syms / sizeof(struct nlist); sname = NULL; while (nsyms--) { if (fread((char *)&nbuf, sizeof (NLIST), 1, fp) != 1) { if (feof(fp)) fmterr = "corrupted symbol table"; else warn("%s", kfile); return (-1); } if (!nbuf._strx || (nbuf.n_type & N_STAB)) continue; /* If the symbol does not start with '_', add one */ p = strtab + nbuf._strx - sizeof(int); if (*p != '_') { len = strlen(p) + 1; if (len >= snamesize) { char *newsname; int newsnamesize = len + 1024; newsname = realloc(sname, newsnamesize); if (newsname == NULL) { if (sname) free(sname); sname = NULL; } else { sname = newsname; snamesize = newsnamesize; } } if (sname == NULL) errx(1, "cannot allocate memory"); *sname = '_'; strlcpy(sname + 1, p, snamesize - 1); key.data = (u_char *)sname; key.size = len; } else { key.data = (u_char *)p; key.size = strlen((char *)key.data); } if (db->put(db, &key, &data, 0)) err(1, "record enter"); if (strcmp((char *)key.data, VRS_SYM) == 0) { long cur_off; if (!ksyms) { /* * Calculate offset relative to a normal * (non-kernel) a.out. Kerntextoff is where the * kernel is really loaded; N_TXTADDR is where * a normal file is loaded. From there, locate * file offset in text or data. */ long voff; voff = nbuf.n_value-kerntextoff+N_TXTADDR(ebuf); if ((nbuf.n_type & N_TYPE) == N_TEXT) voff += N_TXTOFF(ebuf)-N_TXTADDR(ebuf); else voff += N_DATOFF(ebuf)-N_DATADDR(ebuf); cur_off = ftell(fp); if (fseek(fp, voff, SEEK_SET) == -1) { fmterr = "corrupted string table"; return (-1); } /* * Read version string up to, and including * newline. This code assumes that a newline * terminates the version line. */ if (fgets(buf, sizeof(buf), fp) == NULL) { fmterr = "corrupted string table"; return (-1); } } else { /* * This is /dev/ksyms or a look alike. * Use sysctl() to get version since we * don't have real text or data. */ int mib[2]; mib[0] = CTL_KERN; mib[1] = KERN_VERSION; len = sizeof(buf); if (sysctl(mib, 2, buf, &len, NULL, 0) == -1) { err(1, "sysctl can't find kernel " "version string"); } if ((p = strchr(buf, '\n')) != NULL) *(p+1) = '\0'; } key.data = (u_char *)VRS_KEY; key.size = sizeof(VRS_KEY) - 1; data.data = (u_char *)buf; data.size = strlen(buf); if (db->put(db, &key, &data, 0)) err(1, "record enter"); /* Restore to original values. */ data.data = (u_char *)&nbuf; data.size = sizeof(NLIST); if (!ksyms && fseek(fp, cur_off, SEEK_SET) == -1) { fmterr = "corrupted string table"; return (-1); } } } (void)fclose(fp); return (0); } /* * XXX: Using this value from machine/param.h introduces a * XXX: machine dependency on this program, so /usr can not * XXX: be shared between (i.e.) several m68k machines. * Instead of compiling in KERNTEXTOFF or KERNBASE, try to * determine the text start address from a standard symbol. * For backward compatibility, use the old compiled-in way * when the standard symbol name is not found. */ #ifndef KERNTEXTOFF #define KERNTEXTOFF KERNBASE #endif static u_long get_kerntext(char *name, u_int magic) { NLIST nl[2]; bzero((caddr_t)nl, sizeof(nl)); nl[0]._name = "_kernel_text"; if (nlist(name, nl) != 0) return (KERNTEXTOFF); return (nl[0].n_value); } #endif /* _NLIST_DO_AOUT */ #ifdef _NLIST_DO_ELF int __elf_knlist(int fd, DB *db, int ksyms) { caddr_t strtab; off_t symstroff, symoff; u_long symsize, symstrsize; u_long kernvma, kernoffs; int i, j; Elf_Sym sbuf; char buf[1024]; Elf_Ehdr eh; Elf_Shdr *sh = NULL; DBT data, key; NLIST nbuf; FILE *fp; int usemalloc = 0; if ((fp = fdopen(fd, "r")) == NULL) err(1, "%s", kfile); if (fseek(fp, (off_t)0, SEEK_SET) == -1 || fread(&eh, sizeof(eh), 1, fp) != 1 || !IS_ELF(eh)) return (1); sh = (Elf_Shdr *)calloc(sizeof(Elf_Shdr), eh.e_shnum); if (sh == NULL) errx(1, "cannot allocate %d bytes for symbol header", sizeof(Elf_Shdr) * eh.e_shnum); if (fseek (fp, eh.e_shoff, SEEK_SET) < 0) { fmterr = "no exec header"; return (-1); } if (fread(sh, sizeof(Elf_Shdr) * eh.e_shnum, 1, fp) != 1) { fmterr = "no exec header"; return (-1); } symstrsize = symsize = kernvma = 0; for (i = 0; i < eh.e_shnum; i++) { if (sh[i].sh_type == SHT_STRTAB) { for (j = 0; j < eh.e_shnum; j++) if (sh[j].sh_type == SHT_SYMTAB && sh[j].sh_link == (unsigned)i) { symstroff = sh[i].sh_offset; symstrsize = sh[i].sh_size; } } else if (sh[i].sh_type == SHT_SYMTAB) { symoff = sh[i].sh_offset; symsize = sh[i].sh_size; } else if (sh[i].sh_type == SHT_PROGBITS && (sh[i].sh_flags & SHF_EXECINSTR)) { kernvma = sh[i].sh_addr; kernoffs = sh[i].sh_offset; } } if (!symstrsize || !symsize || !kernvma) { fmterr = "corrupt file"; return (-1); } /* * Map string table into our address space. This gives us * an easy way to randomly access all the strings, without * making the memory allocation permanent as with malloc/free * (i.e., munmap will return it to the system). * * XXX - we really want to check if this is a regular file. * then we probably want a MAP_PRIVATE here. */ strtab = mmap(NULL, (size_t)symstrsize, PROT_READ, MAP_SHARED|MAP_FILE, fileno(fp), symstroff); if (strtab == MAP_FAILED) { usemalloc = 1; if ((strtab = malloc(symstrsize)) == NULL) { fmterr = "out of memory"; return (-1); } if (fseek(fp, symstroff, SEEK_SET) == -1) { free(strtab); fmterr = "corrupt file"; return (-1); } if (fread(strtab, symstrsize, 1, fp) != 1) { free(strtab); fmterr = "corrupt file"; return (-1); } } if (fseek(fp, symoff, SEEK_SET) == -1) { fmterr = "corrupt file"; return (-1); } data.data = (u_char *)&nbuf; data.size = sizeof(NLIST); /* Read each symbol and enter it into the database. */ while (symsize > 0) { symsize -= sizeof(Elf_Sym); if (fread((char *)&sbuf, sizeof(sbuf), 1, fp) != 1) { if (feof(fp)) fmterr = "corrupted symbol table"; else warn("%s", kfile); return (-1); } if (!sbuf.st_name) continue; nbuf.n_value = sbuf.st_value; /* XXX type conversion is pretty rude... */ switch(ELF_ST_TYPE(sbuf.st_info)) { case STT_NOTYPE: switch (sbuf.st_shndx) { case SHN_UNDEF: nbuf.n_type = N_UNDF; break; case SHN_ABS: nbuf.n_type = N_ABS; break; case SHN_COMMON: nbuf.n_type = N_COMM; break; default: nbuf.n_type = N_COMM | N_EXT; break; } break; case STT_FUNC: nbuf.n_type = N_TEXT; break; case STT_OBJECT: nbuf.n_type = N_DATA; break; case STT_FILE: nbuf.n_type = N_FN; break; } if (ELF_ST_BIND(sbuf.st_info) == STB_LOCAL) nbuf.n_type = N_EXT; *buf = '_'; strlcpy(buf + 1, strtab + sbuf.st_name, sizeof buf - 1); key.data = (u_char *)buf; key.size = strlen((char *)key.data); if (db->put(db, &key, &data, 0)) err(1, "record enter"); if (strcmp((char *)key.data, VRS_SYM) == 0) { long cur_off; if (!ksyms) { /* * Calculate offset to the version string in * the file. kernvma is where the kernel is * really loaded; kernoffs is where in the * file it starts. */ long voff; voff = nbuf.n_value - kernvma + kernoffs; cur_off = ftell(fp); if (fseek(fp, voff, SEEK_SET) == -1) { fmterr = "corrupted string table"; return (-1); } /* * Read version string up to, and including * newline. This code assumes that a newline * terminates the version line. */ if (fgets(buf, sizeof(buf), fp) == NULL) { fmterr = "corrupted string table"; return (-1); } } else { /* * This is /dev/ksyms or a look alike. * Use sysctl() to get version since we * don't have real text or data. */ int mib[2]; size_t len; char *p; mib[0] = CTL_KERN; mib[1] = KERN_VERSION; len = sizeof(buf); if (sysctl(mib, 2, buf, &len, NULL, 0) == -1) { err(1, "sysctl can't find kernel " "version string"); } if ((p = strchr(buf, '\n')) != NULL) *(p+1) = '\0'; } key.data = (u_char *)VRS_KEY; key.size = sizeof(VRS_KEY) - 1; data.data = (u_char *)buf; data.size = strlen(buf); if (db->put(db, &key, &data, 0)) err(1, "record enter"); /* Restore to original values. */ data.data = (u_char *)&nbuf; data.size = sizeof(NLIST); if (!ksyms && fseek(fp, cur_off, SEEK_SET) == -1) { fmterr = "corrupted string table"; return (-1); } } } if (usemalloc) free(strtab); else munmap(strtab, symstrsize); (void)fclose(fp); return (0); } #endif /* _NLIST_DO_ELF */ #ifdef _NLIST_DO_ECOFF #define check(off, size) ((off < 0) || (off + size > mappedsize)) #define BAD do { rv = -1; goto out; } while (0) #define BADUNMAP do { rv = -1; goto unmap; } while (0) #define ECOFF_INTXT(p, e) ((p) > (e)->a.text_start && \ (p) < (e)->a.text_start + (e)->a.tsize) #define ECOFF_INDAT(p, e) ((p) > (e)->a.data_start && \ (p) < (e)->a.data_start + (e)->a.dsize) int __ecoff_knlist(int fd, DB *db, int ksyms) { struct ecoff_exechdr *exechdrp; struct ecoff_symhdr *symhdrp; struct ecoff_extsym *esyms; struct stat st; char *mappedfile, *cp; size_t mappedsize; u_long symhdroff, extstroff, off; u_int symhdrsize; int rv = 0; long i, nesyms; DBT data, key; NLIST nbuf; char *sname = NULL; size_t len, snamesize = 0; if (fstat(fd, &st) < 0) err(1, "can't stat %s", kfile); if (st.st_size > SIZE_T_MAX) { fmterr = "file too large"; BAD; } mappedsize = st.st_size; mappedfile = mmap(NULL, mappedsize, PROT_READ, MAP_SHARED|MAP_FILE, fd, 0); if (mappedfile == MAP_FAILED) { fmterr = "unable to mmap"; BAD; } if (check(0, sizeof *exechdrp)) BADUNMAP; exechdrp = (struct ecoff_exechdr *)&mappedfile[0]; if (ECOFF_BADMAG(exechdrp)) BADUNMAP; symhdroff = exechdrp->f.f_symptr; symhdrsize = exechdrp->f.f_nsyms; if (symhdrsize == 0) { fmterr = "stripped"; return (-1); } if (check(symhdroff, sizeof *symhdrp) || sizeof *symhdrp != symhdrsize) BADUNMAP; symhdrp = (struct ecoff_symhdr *)&mappedfile[symhdroff]; nesyms = symhdrp->esymMax; if (check(symhdrp->cbExtOffset, nesyms * sizeof *esyms)) BADUNMAP; esyms = (struct ecoff_extsym *)&mappedfile[symhdrp->cbExtOffset]; extstroff = symhdrp->cbSsExtOffset; data.data = (u_char *)&nbuf; data.size = sizeof(NLIST); for (sname = NULL, i = 0; i < nesyms; i++) { /* Need to prepend a '_' */ len = strlen(&mappedfile[extstroff + esyms[i].es_strindex]) + 1; if (len >= snamesize) { char *newsname; int newsnamesize = len + 1024; newsname = realloc(sname, newsnamesize); if (newsname == NULL) { if (sname) free(sname); sname = NULL; } else { sname = newsname; snamesize = newsnamesize; } } if (sname == NULL) errx(1, "cannot allocate memory"); *sname = '_'; strlcpy(sname+1, &mappedfile[extstroff + esyms[i].es_strindex], snamesize - 1); /* Fill in NLIST */ bzero(&nbuf, sizeof(nbuf)); nbuf.n_value = esyms[i].es_value; nbuf.n_type = N_EXT; /* XXX */ /* Store entry in db */ key.data = (u_char *)sname; key.size = strlen(sname); if (db->put(db, &key, &data, 0)) err(1, "record enter"); if (strcmp(sname, VRS_SYM) == 0) { key.data = (u_char *)VRS_KEY; key.size = sizeof(VRS_KEY) - 1; /* Version string may be in either text or data segs */ if (ECOFF_INTXT(nbuf.n_value, exechdrp)) off = nbuf.n_value - exechdrp->a.text_start + ECOFF_TXTOFF(exechdrp); else if (ECOFF_INDAT(nbuf.n_value, exechdrp)) off = nbuf.n_value - exechdrp->a.data_start + ECOFF_DATOFF(exechdrp); else err(1, "unable to find version string"); /* Version string should end in newline but... */ data.data = &mappedfile[off]; if ((cp = strchr(data.data, '\n')) != NULL) data.size = cp - (char *)data.data; else data.size = strlen((char *)data.data); if (db->put(db, &key, &data, 0)) err(1, "record enter"); /* Restore to original values */ data.data = (u_char *)&nbuf; data.size = sizeof(nbuf); } } unmap: munmap(mappedfile, mappedsize); out: return (rv); } #endif /* _NLIST_DO_ECOFF */ static struct knlist_handlers { int (*fn)(int fd, DB *db, int ksyms); } nlist_fn[] = { #ifdef _NLIST_DO_AOUT { __aout_knlist }, #endif #ifdef _NLIST_DO_ELF { __elf_knlist }, #endif #ifdef _NLIST_DO_ECOFF { __ecoff_knlist }, #endif }; int create_knlist(char *name, int fd, DB *db) { int i, error, ksyms; if (strcmp(name, _PATH_KSYMS) == 0) { ksyms = 1; } else { ksyms = 0; } for (i = 0; i < sizeof(nlist_fn)/sizeof(nlist_fn[0]); i++) { fmterr = NULL; kfile = name; /* rval of 1 means wrong executable type */ if ((error = (nlist_fn[i].fn)(fd, db, ksyms)) != 1) break; } if (fmterr != NULL) warnx("%s: %s: %s", kfile, fmterr, strerror(EFTYPE)); return(error); }