rdoff/rdlib.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include "rdoff.h"
   6 #include "rdlib.h"
   7
   8 /*
   9  * format of rdoff library files:
  10  * repeat
  11  *   null terminated module name (max 255 chars)
  12  *   RDOFF module
  13  * until eof
  14  */
  15
  16 /*
  17  * TODO
  18  *
  19  * No support exists yet for special modules. But we aren't using
  20  * any special modules yet. They are only defined now so that their
  21  * existance doesn't break older versions of the linker... presently
  22  * anything whose name begins with '.' is ignored.
  23  */
  24
  25 int rdl_error = 0;
  26
  27 char *rdl_errors[5] = {
  28     "no error","could not open file", "invalid file structure",
  29     "file contains modules of an unsupported RDOFF version",
  30     "module not found"
  31 };
  32 int rdl_verify(const char * filename)
  33 {
  34     FILE    * fp = fopen(filename, "rb");
  35     char    buf[257];
  36     int     i;
  37     long    length;
  38     static char lastverified[256];
  39     static int lastresult = -1;
  40
  41     if (lastresult != -1 && !strcmp(filename, lastverified))
  42         return lastresult;
  43
  44     strcpy(lastverified, filename);
  45
  46     if (!fp)
  47         return (rdl_error = lastresult = 1);
  48
  49     while (!feof(fp))
  50     {
  51         i = 0;
  52
  53         while (fread(buf + i,1,1,fp) == 1 && buf[i] && i < 257)
  54             i++;
  55         if (feof(fp)) break;
  56
  57         fread(buf, 6, 1, fp);
  58         buf[6] = 0;
  59         if (buf[0] == '.') {
  60             /*
  61              * a special module, eg a directory.
  62              * Format of such a module is defined to be:
  63              *   six char type identifier (which we've already read)
  64              *   long count bytes content
  65              *   content
  66              * so we can handle it uniformaly with RDOFF2 modules...
  67              * do nothing here. :-)
  68              */
  69         }
  70         else if (strncmp(buf, "RDOFF", 5)) {
  71             return rdl_error = lastresult = 2;
  72         }
  73         else if (buf[5] != '2') {
  74             return rdl_error = lastresult = 3;
  75         }
  76
  77         fread(&length, 4, 1, fp);
  78         fseek(fp, length, SEEK_CUR); /* skip over the module */
  79     }
  80     fclose(fp);
  81     return lastresult = 0;           /* library in correct format */
  82 }
  83
  84 int rdl_open (struct librarynode * lib, const char * name)
  85 {
  86     int i = rdl_verify(name);
  87     if (i) return i;
  88
  89     lib->fp = NULL;
  90     lib->name = strdup(name);
  91     lib->referenced = 0;
  92     lib->next = NULL;
  93     return 0;
  94 }
  95
  96 void rdl_close (struct librarynode * lib)
  97 {
  98     if (lib->fp)
  99         fclose(lib->fp);
 100     free(lib->name);
 101 }
 102
 103 int rdl_searchlib (struct librarynode * lib,
 104                    const char * label, rdffile * f)
 105 {
 106     char                buf[512];
 107     int                 i, t;
 108     void *              hdr;
 109     rdfheaderrec        * r;
 110     long                l;
 111
 112     rdl_error = 0;
 113     lib->referenced ++;
 114
 115     if (! lib->fp)
 116     {
 117         lib->fp = fopen(lib->name,"rb");
 118
 119         if (! lib->fp) {
 120             rdl_error = 1;
 121             return 0;
 122         }
 123     }
 124     else
 125         rewind(lib->fp);
 126
 127     while (! feof(lib->fp) )
 128     {
 129         /*
 130          * read the module name from the file, and prepend
 131          * the library name and '.' to it.
 132          */
 133         strcpy(buf, lib->name);
 134
 135         i = strlen(lib->name);
 136         buf[i++] = '.'; t = i;
 137         while (fread(buf + i,1,1,lib->fp) == 1 && buf[i] && i < 512)
 138             i++;
 139
 140         buf[i] = 0;
 141
 142         if (feof(lib->fp)) break;
 143         if (!strcmp(buf + t, ".dir"))   /* skip over directory */
 144         {
 145             fread (&l, 4, 1, lib->fp);
 146             fseek (lib->fp, l, SEEK_CUR);
 147             continue;
 148         }
 149         /*
 150          * open the RDOFF module
 151          */
 152         if ( rdfopenhere(f,lib->fp,&lib->referenced,buf) ) {
 153             rdl_error = 16 * rdf_errno;
 154             return 0;
 155         }
 156         /*
 157          * read in the header, and scan for exported symbols
 158          */
 159         hdr = malloc(f->header_len);
 160         rdfloadseg(f,RDOFF_HEADER,hdr);
 161
 162         while ((r = rdfgetheaderrec(f)))
 163         {
 164             if (r->type != 3)   /* not an export */
 165                 continue;
 166
 167             if (! strcmp(r->e.label, label) )   /* match! */
 168             {
 169                 free(hdr);                      /* reset to 'just open' */
 170                 f->header_loc = NULL;           /* state... */
 171                 f->header_fp = 0;
 172                 return 1;
 173             }
 174         }
 175
 176         /* find start of next module... */
 177         i = f->eof_offset;
 178         rdfclose(f);
 179         fseek(lib->fp,i,SEEK_SET);
 180     }
 181
 182     /*
 183      * close the file if nobody else is using it
 184      */
 185     lib->referenced --;
 186     if (! lib->referenced)
 187     {
 188         fclose(lib->fp);
 189         lib->fp = NULL;
 190     }
 191     return 0;
 192 }
 193
 194 int rdl_openmodule (struct librarynode * lib, int moduleno, rdffile * f)
 195 {
 196     char    buf[512];
 197     int     i, cmod, t;
 198     long    length;
 199
 200     lib->referenced++;
 201
 202     if (!lib->fp)
 203     {
 204         lib->fp = fopen(lib->name, "rb");
 205         if (!lib->fp) {
 206             lib->referenced--;
 207             return (rdl_error = 1);
 208         }
 209     }
 210     else
 211         rewind(lib->fp);
 212
 213     cmod = -1;
 214     while (!feof(lib->fp))
 215     {
 216         strcpy(buf, lib->name);
 217         i = strlen(buf);
 218         buf[i++] = '.'; t = i;
 219         while (fread(buf + i,1,1,lib->fp) == 1 && buf[i] && i < 512)
 220             i++;
 221         buf[i] = 0;
 222         if (feof(lib->fp)) break;
 223
 224         if (buf[t] != '.') /* special module - not counted in the numbering */
 225             cmod++;        /* of RDOFF modules - must be referred to by name */
 226
 227         if (cmod == moduleno) {
 228             rdl_error = 16 *
 229                 rdfopenhere(f, lib->fp, &lib->referenced, buf);
 230             lib->referenced--;
 231             if (!lib->referenced) {
 232                 fclose(lib->fp);
 233                 lib->fp = NULL;
 234             }
 235             return rdl_error;
 236         }
 237
 238         fread(buf, 6, 1, lib->fp);
 239         buf[6] = 0;
 240         if (buf[t] == '.') {
 241             /* do nothing */
 242         }
 243         else if (strncmp(buf, "RDOFF", 5)) {
 244             if (! --lib->referenced) {
 245                 fclose(lib->fp);
 246                 lib->fp = NULL;
 247             }
 248             return rdl_error = 2;
 249         }
 250         else if (buf[5] != '2') {
 251             if (! --lib->referenced) {
 252                 fclose(lib->fp);
 253                 lib->fp = NULL;
 254             }
 255             return rdl_error = 3;
 256         }
 257
 258         fread(&length, 4, 1, lib->fp);
 259         fseek(lib->fp, length, SEEK_CUR); /* skip over the module */
 260     }
 261     if (! --lib->referenced) {
 262         fclose(lib->fp);
 263         lib->fp = NULL;
 264     }
 265     return rdl_error = 4;       /* module not found */
 266 }
 267
 268 void rdl_perror(const char *apname, const char *filename)
 269 {
 270     if (rdl_error >= 16)
 271         rdfperror(apname, filename);
 272     else
 273         fprintf(stderr,"%s:%s:%s\n",apname,filename,rdl_errors[rdl_error]);
 274 }
 275
 276
 277