rdoff/rdlib.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * rdlib.c - routines for manipulating RDOFF libraries (.rdl)
  36  */
  37
  38 #include "compiler.h"
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43
  44 #define RDOFF_UTILS
  45
  46 #include "rdoff.h"
  47 #include "rdlib.h"
  48 #include "rdlar.h"
  49
  50 /* See Texinfo documentation about new RDOFF libraries format */
  51
  52 int rdl_error = 0;
  53
  54 char *rdl_errors[5] = {
  55     "no error", "could not open file", "invalid file structure",
  56     "file contains modules of an unsupported RDOFF version",
  57     "module not found"
  58 };
  59
  60 int rdl_verify(const char *filename)
  61 {
  62     FILE *fp;
  63     char buf[257];
  64     int i;
  65     int32_t length;
  66     static char lastverified[256];
  67     static int lastresult = -1;
  68
  69     if (lastresult != -1 && !strcmp(filename, lastverified))
  70         return lastresult;
  71
  72     fp = fopen(filename, "rb");
  73     strcpy(lastverified, filename);
  74
  75     if (!fp)
  76         return (rdl_error = lastresult = 1);
  77
  78     while (!feof(fp)) {
  79         i = 0;
  80
  81         while (fread(buf + i, 1, 1, fp) == 1 && i < 257 && buf[i])
  82             i++;
  83         if (feof(fp))
  84             break;
  85
  86         if (buf[0] == '.') {
  87             /*
  88              * A special module, eg a signature block or a directory.
  89              * Format of such a module is defined to be:
  90              *   six char type identifier
  91              *   int32_t count bytes content
  92              *   content
  93              * so we can handle it uniformaly with RDOFF2 modules.
  94              */
  95             fread(buf, 6, 1, fp);
  96             buf[6] = 0;
  97             /* Currently, nothing useful to do with signature block.. */
  98         } else {
  99             fread(buf, 6, 1, fp);
 100             buf[6] = 0;
 101             if (strncmp(buf, "RDOFF", 5)) {
 102                 fclose(fp);
 103                 return rdl_error = lastresult = 2;
 104             } else if (buf[5] != '2') {
 105                 fclose(fp);
 106                 return rdl_error = lastresult = 3;
 107             }
 108         }
 109         fread(&length, 4, 1, fp);
 110         fseek(fp, length, SEEK_CUR);    /* skip over the module */
 111     }
 112     fclose(fp);
 113     return lastresult = 0;      /* library in correct format */
 114 }
 115
 116 int rdl_open(struct librarynode *lib, const char *name)
 117 {
 118     int i = rdl_verify(name);
 119     if (i)
 120         return i;
 121
 122     lib->fp = NULL;
 123     lib->name = strdup(name);
 124     lib->referenced = 0;
 125     lib->next = NULL;
 126     return 0;
 127 }
 128
 129 void rdl_close(struct librarynode *lib)
 130 {
 131     if (lib->fp)
 132         fclose(lib->fp);
 133     free(lib->name);
 134 }
 135
 136 int rdl_searchlib(struct librarynode *lib, const char *label, rdffile * f)
 137 {
 138     char buf[512];
 139     int i, t;
 140     void *hdr;
 141     rdfheaderrec *r;
 142     int32_t l;
 143
 144     rdl_error = 0;
 145     lib->referenced++;
 146
 147     if (!lib->fp) {
 148         lib->fp = fopen(lib->name, "rb");
 149
 150         if (!lib->fp) {
 151             rdl_error = 1;
 152             return 0;
 153         }
 154     } else
 155         rewind(lib->fp);
 156
 157     while (!feof(lib->fp)) {
 158         /*
 159          * read the module name from the file, and prepend
 160          * the library name and '.' to it.
 161          */
 162         strcpy(buf, lib->name);
 163
 164         i = strlen(lib->name);
 165         buf[i++] = '.';
 166         t = i;
 167         while (fread(buf + i, 1, 1, lib->fp) == 1 && i < 512 && buf[i])
 168             i++;
 169
 170         buf[i] = 0;
 171
 172         if (feof(lib->fp))
 173             break;
 174         if (!strcmp(buf + t, ".dir")) { /* skip over directory */
 175             fread(&l, 4, 1, lib->fp);
 176             fseek(lib->fp, l, SEEK_CUR);
 177             continue;
 178         }
 179         /*
 180          * open the RDOFF module
 181          */
 182         if (rdfopenhere(f, lib->fp, &lib->referenced, buf)) {
 183             rdl_error = 16 * rdf_errno;
 184             return 0;
 185         }
 186         /*
 187          * read in the header, and scan for exported symbols
 188          */
 189         hdr = malloc(f->header_len);
 190         rdfloadseg(f, RDOFF_HEADER, hdr);
 191
 192         while ((r = rdfgetheaderrec(f))) {
 193             if (r->type != 3)   /* not an export */
 194                 continue;
 195
 196             if (!strcmp(r->e.label, label)) {   /* match! */
 197                 free(hdr);      /* reset to 'just open' */
 198                 f->header_loc = NULL;   /* state... */
 199                 f->header_fp = 0;
 200                 return 1;
 201             }
 202         }
 203
 204         /* find start of next module... */
 205         i = f->eof_offset;
 206         rdfclose(f);
 207         fseek(lib->fp, i, SEEK_SET);
 208     }
 209
 210     /*
 211      * close the file if nobody else is using it
 212      */
 213     lib->referenced--;
 214     if (!lib->referenced) {
 215         fclose(lib->fp);
 216         lib->fp = NULL;
 217     }
 218     return 0;
 219 }
 220
 221 int rdl_openmodule(struct librarynode *lib, int moduleno, rdffile * f)
 222 {
 223     char buf[512];
 224     int i, cmod, t;
 225     int32_t length;
 226
 227     lib->referenced++;
 228
 229     if (!lib->fp) {
 230         lib->fp = fopen(lib->name, "rb");
 231         if (!lib->fp) {
 232             lib->referenced--;
 233             return (rdl_error = 1);
 234         }
 235     } else
 236         rewind(lib->fp);
 237
 238     cmod = -1;
 239     while (!feof(lib->fp)) {
 240         strcpy(buf, lib->name);
 241         i = strlen(buf);
 242         buf[i++] = '.';
 243         t = i;
 244         while (fread(buf + i, 1, 1, lib->fp) == 1 && i < 512 && buf[i])
 245             i++;
 246         buf[i] = 0;
 247         if (feof(lib->fp))
 248             break;
 249
 250         if (buf[t] != '.')      /* special module - not counted in the numbering */
 251             cmod++;             /* of RDOFF modules - must be referred to by name */
 252
 253         if (cmod == moduleno) {
 254             rdl_error = 16 *
 255                 rdfopenhere(f, lib->fp, &lib->referenced, buf);
 256             lib->referenced--;
 257             if (!lib->referenced) {
 258                 fclose(lib->fp);
 259                 lib->fp = NULL;
 260             }
 261             return rdl_error;
 262         }
 263
 264         fread(buf, 6, 1, lib->fp);
 265         buf[6] = 0;
 266         if (buf[t] == '.') {
 267             /* do nothing */
 268         } else if (strncmp(buf, "RDOFF", 5)) {
 269             if (!--lib->referenced) {
 270                 fclose(lib->fp);
 271                 lib->fp = NULL;
 272             }
 273             return rdl_error = 2;
 274         } else if (buf[5] != '2') {
 275             if (!--lib->referenced) {
 276                 fclose(lib->fp);
 277                 lib->fp = NULL;
 278             }
 279             return rdl_error = 3;
 280         }
 281
 282         fread(&length, 4, 1, lib->fp);
 283         fseek(lib->fp, length, SEEK_CUR);       /* skip over the module */
 284     }
 285     if (!--lib->referenced) {
 286         fclose(lib->fp);
 287         lib->fp = NULL;
 288     }
 289     return rdl_error = 4;       /* module not found */
 290 }
 291
 292 void rdl_perror(const char *apname, const char *filename)
 293 {
 294     if (rdl_error >= 16)
 295         rdfperror(apname, filename);
 296     else
 297         fprintf(stderr, "%s:%s:%s\n", apname, filename,
 298                 rdl_errors[rdl_error]);
 299 }