rdoff/rdlib.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2014 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 #include "rdfutils.h"
  45 #include "rdlib.h"
  46 #include "rdlar.h"
  47
  48 /* See Texinfo documentation about new RDOFF libraries format */
  49
  50 int rdl_error = 0;
  51
  52 char *rdl_errors[5] = {
  53     "no error", "could not open file", "invalid file structure",
  54     "file contains modules of an unsupported RDOFF version",
  55     "module not found"
  56 };
  57
  58 int rdl_verify(const char *filename)
  59 {
  60     FILE *fp;
  61     char buf[257];
  62     int i;
  63     int32_t length;
  64     static char lastverified[256];
  65     static int lastresult = -1;
  66
  67     if (lastresult != -1 && !strcmp(filename, lastverified))
  68         return lastresult;
  69
  70     fp = fopen(filename, "rb");
  71     strcpy(lastverified, filename);
  72
  73     if (!fp)
  74         return (rdl_error = lastresult = 1);
  75
  76     while (!feof(fp)) {
  77         i = 0;
  78
  79         while (fread(buf + i, 1, 1, fp) == 1 && i < 257 && buf[i])
  80             i++;
  81         if (feof(fp))
  82             break;
  83
  84         if (buf[0] == '.') {
  85             /*
  86              * A special module, eg a signature block or a directory.
  87              * Format of such a module is defined to be:
  88              *   six char type identifier
  89              *   int32_t count bytes content
  90              *   content
  91              * so we can handle it uniformaly with RDOFF2 modules.
  92              */
  93             nasm_read(buf, 6, fp);
  94             buf[6] = 0;
  95             /* Currently, nothing useful to do with signature block.. */
  96         } else {
  97             nasm_read(buf, 6, fp);
  98             buf[6] = 0;
  99             if (strncmp(buf, "RDOFF", 5)) {
 100                 fclose(fp);
 101                 return rdl_error = lastresult = 2;
 102             } else if (buf[5] != '2') {
 103                 fclose(fp);
 104                 return rdl_error = lastresult = 3;
 105             }
 106         }
 107         nasm_read(&length, 4, fp);
 108         fseek(fp, length, SEEK_CUR);    /* skip over the module */
 109     }
 110     fclose(fp);
 111     return lastresult = 0;      /* library in correct format */
 112 }
 113
 114 int rdl_open(struct librarynode *lib, const char *name)
 115 {
 116     int i = rdl_verify(name);
 117     if (i)
 118         return i;
 119
 120     lib->fp = NULL;
 121     lib->name = nasm_strdup(name);
 122     lib->referenced = 0;
 123     lib->next = NULL;
 124     return 0;
 125 }
 126
 127 int rdl_searchlib(struct librarynode *lib, const char *label, rdffile * f)
 128 {
 129     char buf[512];
 130     int i, t;
 131     void *hdr;
 132     rdfheaderrec *r;
 133     int32_t l;
 134
 135     rdl_error = 0;
 136     lib->referenced++;
 137
 138     if (!lib->fp) {
 139         lib->fp = fopen(lib->name, "rb");
 140
 141         if (!lib->fp) {
 142             rdl_error = 1;
 143             return 0;
 144         }
 145     } else
 146         rewind(lib->fp);
 147
 148     while (!feof(lib->fp)) {
 149         /*
 150          * read the module name from the file, and prepend
 151          * the library name and '.' to it.
 152          */
 153         strcpy(buf, lib->name);
 154
 155         i = strlen(lib->name);
 156         buf[i++] = '.';
 157         t = i;
 158         while (fread(buf + i, 1, 1, lib->fp) == 1 && i < 512 && buf[i])
 159             i++;
 160
 161         buf[i] = 0;
 162
 163         if (feof(lib->fp))
 164             break;
 165         if (!strcmp(buf + t, ".dir")) { /* skip over directory */
 166             nasm_read(&l, 4, lib->fp);
 167             fseek(lib->fp, l, SEEK_CUR);
 168             continue;
 169         }
 170         /*
 171          * open the RDOFF module
 172          */
 173         if (rdfopenhere(f, lib->fp, &lib->referenced, buf)) {
 174             rdl_error = 16 * rdf_errno;
 175             return 0;
 176         }
 177         /*
 178          * read in the header, and scan for exported symbols
 179          */
 180         hdr = nasm_malloc(f->header_len);
 181         rdfloadseg(f, RDOFF_HEADER, hdr);
 182
 183         while ((r = rdfgetheaderrec(f))) {
 184             if (r->type != 3)   /* not an export */
 185                 continue;
 186
 187             if (!strcmp(r->e.label, label)) {   /* match! */
 188                 nasm_free(hdr);      /* reset to 'just open' */
 189                 f->header_loc = NULL;   /* state... */
 190                 f->header_fp = 0;
 191                 return 1;
 192             }
 193         }
 194
 195         /* find start of next module... */
 196         i = f->eof_offset;
 197         rdfclose(f);
 198         fseek(lib->fp, i, SEEK_SET);
 199     }
 200
 201     /*
 202      * close the file if nobody else is using it
 203      */
 204     lib->referenced--;
 205     if (!lib->referenced) {
 206         fclose(lib->fp);
 207         lib->fp = NULL;
 208     }
 209     return 0;
 210 }
 211
 212 int rdl_openmodule(struct librarynode *lib, int moduleno, rdffile * f)
 213 {
 214     char buf[512];
 215     int i, cmod, t;
 216     int32_t length;
 217
 218     lib->referenced++;
 219
 220     if (!lib->fp) {
 221         lib->fp = fopen(lib->name, "rb");
 222         if (!lib->fp) {
 223             lib->referenced--;
 224             return (rdl_error = 1);
 225         }
 226     } else
 227         rewind(lib->fp);
 228
 229     cmod = -1;
 230     while (!feof(lib->fp)) {
 231         strcpy(buf, lib->name);
 232         i = strlen(buf);
 233         buf[i++] = '.';
 234         t = i;
 235         while (fread(buf + i, 1, 1, lib->fp) == 1 && i < 512 && buf[i])
 236             i++;
 237         buf[i] = 0;
 238         if (feof(lib->fp))
 239             break;
 240
 241         if (buf[t] != '.')      /* special module - not counted in the numbering */
 242             cmod++;             /* of RDOFF modules - must be referred to by name */
 243
 244         if (cmod == moduleno) {
 245             rdl_error = 16 *
 246                 rdfopenhere(f, lib->fp, &lib->referenced, buf);
 247             lib->referenced--;
 248             if (!lib->referenced) {
 249                 fclose(lib->fp);
 250                 lib->fp = NULL;
 251             }
 252             return rdl_error;
 253         }
 254
 255         nasm_read(buf, 6, lib->fp);
 256         buf[6] = 0;
 257         if (buf[t] == '.') {
 258             /* do nothing */
 259         } else if (strncmp(buf, "RDOFF", 5)) {
 260             if (!--lib->referenced) {
 261                 fclose(lib->fp);
 262                 lib->fp = NULL;
 263             }
 264             return rdl_error = 2;
 265         } else if (buf[5] != '2') {
 266             if (!--lib->referenced) {
 267                 fclose(lib->fp);
 268                 lib->fp = NULL;
 269             }
 270             return rdl_error = 3;
 271         }
 272
 273         nasm_read(&length, 4, lib->fp);
 274         fseek(lib->fp, length, SEEK_CUR);       /* skip over the module */
 275     }
 276     if (!--lib->referenced) {
 277         fclose(lib->fp);
 278         lib->fp = NULL;
 279     }
 280     return rdl_error = 4;       /* module not found */
 281 }
 282
 283 void rdl_perror(const char *apname, const char *filename)
 284 {
 285     if (rdl_error >= 16)
 286         rdfperror(apname, filename);
 287     else
 288         fprintf(stderr, "%s:%s:%s\n", apname, filename,
 289                 rdl_errors[rdl_error]);
 290 }