Return to ldopen.c CVS log

Up to [Research Unix] / researchv9 / jerq / sgs / libld

Annotation of researchv9/jerq/sgs/libld/ldopen.c, revision 1.1.1.1

1.1       root        1: /*
                      2: * ldopen - get LDFILE, header info for object file.
                      3: *              if it is an archive, get the first file from the archive.
                      4: *              if it is an already opened archive, assume ldclose() set
                      5: *              up everything already.
                      6: *
                      7: * #ifdef PORTAR                printable ascii header archive version
                      8: * #else #ifdef PORT5AR UNIX 5.0 semi-portable archive version
                      9: * #else                        pre UNIX 5.0 (old) archive version
                     10: * #endif
                     11: */
                     12: #include <stdio.h>
                     13: #include <ar.h>
                     14: #include "filehdr.h"
                     15: #include "ldfcn.h"
                     16: 
                     17: LDFILE *
                     18: ldopen(filename, ldptr)
                     19:        char *filename;
                     20:        LDFILE *ldptr; 
                     21: {
                     22:        extern FILE *fopen();
                     23:        extern int fclose();
                     24:        extern int fseek();
                     25:        extern int fread();
                     26:        extern int vldldptr();
                     27:        extern LDFILE *allocldptr();
                     28:        extern int freeldptr();
                     29:        extern long sgetl();
                     30:        FILE *ioptr;
                     31:        unsigned short type;
                     32: #ifdef PORTAR
                     33:        struct ar_hdr arbuf;
                     34:        char buf[SARMAG];
                     35: #else
                     36: #ifdef PORT5AR
                     37:        struct ar_hdr arbuf;
                     38:        long nsyms;
                     39: #else
                     40:        unsigned short atype = 0;
                     41: #endif
                     42: #endif
                     43: 
                     44:        if (vldldptr(ldptr) == FAILURE)
                     45:        {
                     46:                if ((ioptr = fopen(filename, "r")) == NULL)
                     47:                        return (NULL);
                     48: #ifdef PORTAR
                     49:                if (fread(buf, sizeof(char) * SARMAG, 1, ioptr) != 1)
                     50:                        buf[0] = '\0';
                     51:                fseek(ioptr, 0L, 0);
                     52: #else
                     53: #ifdef PORT5AR
                     54:                if (fread((char *)&arbuf, sizeof(arbuf), 1, ioptr) != 1)
                     55:                        arbuf.ar_magic[0] = '\0';
                     56:                fseek(ioptr, 0L, 0);
                     57: #endif
                     58: #endif
                     59:                if (fread((char *)&type, sizeof(type), 1, ioptr) != 1 ||
                     60:                        (ldptr = allocldptr()) == NULL)
                     61:                {
                     62:                        fclose(ioptr);
                     63:                        return (NULL);
                     64:                }
                     65: #ifdef PORTAR
                     66:                if (strncmp(buf, ARMAG, SARMAG) == 0)
                     67:                {
                     68:                        long ar_size;
                     69: 
                     70:                        TYPE(ldptr) = USH_ARTYPE;
                     71:                        if (fseek(ioptr, (long)(sizeof(char) * SARMAG), 0) ==
                     72:                                OKFSEEK &&
                     73:                                fread((char *)&arbuf, sizeof(arbuf), 1, ioptr)
                     74:                                == 1 &&
                     75:                                !strncmp(arbuf.ar_fmag, ARFMAG,
                     76:                                sizeof(arbuf.ar_fmag)) &&
                     77:                                arbuf.ar_name[0] == '/' &&
                     78:                                sscanf(arbuf.ar_size, "%ld", &ar_size) == 1)
                     79:                        {
                     80:                                OFFSET(ldptr) = sizeof(char) * SARMAG +
                     81:                                        2 * sizeof(struct ar_hdr) +
                     82:                                        ((ar_size + 01) & ~01);
                     83:                        }
                     84:                        else
                     85:                                OFFSET(ldptr) = sizeof(char) * SARMAG +
                     86:                                        sizeof(struct ar_hdr);
                     87:                }
                     88:                else
                     89:                {
                     90:                        TYPE(ldptr) = type;
                     91:                        OFFSET(ldptr) = 0L;
                     92:                }
                     93: #else
                     94: #ifdef PORT5AR
                     95:                if (strncmp(arbuf.ar_magic, ARMAG, SARMAG) == 0)
                     96:                {
                     97:                        TYPE(ldptr) = USH_ARTYPE;
                     98:                        nsyms = sgetl(arbuf.ar_syms);
                     99: 
                    100:                        OFFSET(ldptr) = (nsyms * sizeof(struct ar_sym)) +
                    101:                                sizeof(struct arf_hdr) + sizeof(arbuf);
                    102:                }
                    103:                else
                    104:                {
                    105:                        TYPE(ldptr) = type;
                    106:                        OFFSET(ldptr) = 0L;
                    107:                }
                    108: #else
                    109:                if (sizeof(ARTYPE) == sizeof(type) ||
                    110:                        fread((char *)&atype, sizeof(atype), 1, ioptr) != 1)
                    111:                {
                    112:                        atype = type;
                    113:                }
                    114:                if (atype == USH_ARTYPE ||
                    115:                        type == USH_ARTYPE)
                    116:                {
                    117:                        TYPE(ldptr) = USH_ARTYPE;
                    118:                        OFFSET(ldptr) = ARCHSZ + sizeof(ARMAG);
                    119:                }
                    120:                else
                    121:                {
                    122:                        TYPE(ldptr) = type;
                    123:                        OFFSET(ldptr) = 0L;
                    124:                }
                    125: #endif
                    126: #endif
                    127:                IOPTR(ldptr) = ioptr;
                    128:                if (FSEEK(ldptr, 0L, BEGINNING) == OKFSEEK &&
                    129:                        FREAD((char *)&(HEADER(ldptr)), FILHSZ, 1, ldptr) == 1)
                    130:                {
                    131:                        return (ldptr);
                    132:                }
                    133:        }
                    134:        else if (FSEEK(ldptr, 0L, BEGINNING) == OKFSEEK)
                    135:                return (ldptr);
                    136:        fclose(IOPTR(ldptr));
                    137:        freeldptr(ldptr);
                    138:        return (NULL);
                    139: }
                    140: 
                    141: static char ID[] = "@(#) ldopen.c: 1.4 5/1/83";

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