Return to nlist.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / lib / libc / gen

Annotation of 43BSDReno/lib/libc/gen/nlist.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1989 The Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms are permitted
        !             6:  * provided that: (1) source distributions retain this entire copyright
        !             7:  * notice and comment, and (2) distributions including binaries display
        !             8:  * the following acknowledgement:  ``This product includes software
        !             9:  * developed by the University of California, Berkeley and its contributors''
        !            10:  * in the documentation or other materials provided with the distribution
        !            11:  * and in all advertising materials mentioning features or use of this
        !            12:  * software. Neither the name of the University nor the names of its
        !            13:  * contributors may be used to endorse or promote products derived
        !            14:  * from this software without specific prior written permission.
        !            15:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
        !            16:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
        !            17:  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        !            18:  */
        !            19: 
        !            20: #if defined(LIBC_SCCS) && !defined(lint)
        !            21: static char sccsid[] = "@(#)nlist.c    5.7 (Berkeley) 6/1/90";
        !            22: #endif /* LIBC_SCCS and not lint */
        !            23: 
        !            24: #include <sys/types.h>
        !            25: #include <sys/file.h>
        !            26: #include <a.out.h>
        !            27: #include <stdio.h>
        !            28: #include <unistd.h>
        !            29: 
        !            30: typedef struct nlist NLIST;
        !            31: #define        _strx   n_un.n_strx
        !            32: #define        _name   n_un.n_name
        !            33: #define        ISVALID(p)      (p->_name && p->_name[0])
        !            34: 
        !            35: nlist(name, list)
        !            36:        char *name;
        !            37:        NLIST *list;
        !            38: {
        !            39:        register NLIST *p, *s;
        !            40:        struct exec ebuf;
        !            41:        FILE *fstr, *fsym;
        !            42:        NLIST nbuf;
        !            43:        off_t strings_offset, symbol_offset, symbol_size, lseek();
        !            44:        int entries, len, maxlen;
        !            45:        char sbuf[256];
        !            46: 
        !            47:        entries = -1;
        !            48: 
        !            49:        if (!(fsym = fopen(name, "r")))
        !            50:                return(-1);
        !            51:        if (fread((char *)&ebuf, sizeof(struct exec), 1, fsym) != 1 ||
        !            52:            N_BADMAG(ebuf))
        !            53:                goto done1;
        !            54: 
        !            55:        symbol_offset = N_SYMOFF(ebuf);
        !            56:        symbol_size = ebuf.a_syms;
        !            57:        strings_offset = symbol_offset + symbol_size;
        !            58:        if (fseek(fsym, symbol_offset, SEEK_SET))
        !            59:                goto done1;
        !            60: 
        !            61:        if (!(fstr = fopen(name, "r")))
        !            62:                goto done1;
        !            63: 
        !            64:        /*
        !            65:         * clean out any left-over information for all valid entries.
        !            66:         * Type and value defined to be 0 if not found; historical
        !            67:         * versions cleared other and desc as well.  Also figure out
        !            68:         * the largest string length so don't read any more of the
        !            69:         * string table than we have to.
        !            70:         */
        !            71:        for (p = list, entries = maxlen = 0; ISVALID(p); ++p, ++entries) {
        !            72:                p->n_type = 0;
        !            73:                p->n_other = 0;
        !            74:                p->n_desc = 0;
        !            75:                p->n_value = 0;
        !            76:                if ((len = strlen(p->_name)) > maxlen)
        !            77:                        maxlen = len;
        !            78:        }
        !            79:        if (++maxlen > sizeof(sbuf)) {          /* for the NULL */
        !            80:                (void)fprintf(stderr, "nlist: symbol too large.\n");
        !            81:                entries = -1;
        !            82:                goto done2;
        !            83:        }
        !            84: 
        !            85:        for (s = &nbuf; symbol_size; symbol_size -= sizeof(NLIST)) {
        !            86:                if (fread((char *)s, sizeof(NLIST), 1, fsym) != 1)
        !            87:                        goto done2;
        !            88:                if (!s->_strx || s->n_type&N_STAB)
        !            89:                        continue;
        !            90:                if (fseek(fstr, strings_offset + s->_strx, SEEK_SET))
        !            91:                        goto done2;
        !            92:                (void)fread(sbuf, sizeof(sbuf[0]), maxlen, fstr);
        !            93:                for (p = list; ISVALID(p); p++)
        !            94:                        if (!strcmp(p->_name, sbuf)) {
        !            95:                                p->n_value = s->n_value;
        !            96:                                p->n_type = s->n_type;
        !            97:                                p->n_desc = s->n_desc;
        !            98:                                p->n_other = s->n_other;
        !            99:                                if (!--entries)
        !           100:                                        goto done2;
        !           101:                        }
        !           102:        }
        !           103: done2: (void)fclose(fstr);
        !           104: done1: (void)fclose(fsym);
        !           105:        return(entries);
        !           106: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.