rdoff/rdoff.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  * rdoff.c      library of routines for manipulating rdoff files
  36  */
  37
  38 /* TODO:        The functions in this module assume they are running
  39  *              on a little-endian machine. This should be fixed to
  40  *              make it portable.
  41  */
  42
  43 #include "compiler.h"
  44
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <errno.h>
  49
  50 #define RDOFF_UTILS
  51
  52 #include "rdoff.h"
  53
  54 #define newstr(str) strcpy(malloc(strlen(str) + 1),str)
  55 #define newstrcat(s1,s2) strcat(strcpy(malloc(strlen(s1) + strlen(s2) + 1), \
  56                                        s1),s2)
  57
  58 /*
  59  * Comment this out to allow the module to read & write header record types
  60  * that it isn't aware of. With this defined, unrecognised header records
  61  * will generate error number 8, reported as 'unknown extended header record'.
  62  */
  63
  64 #define STRICT_ERRORS
  65
  66 /* ========================================================================
  67  * Code for memory buffers (for delayed writing of header until we know
  68  * how int32_t it is).
  69  * ======================================================================== */
  70
  71 static memorybuffer *newmembuf(void)
  72 {
  73     memorybuffer *t;
  74
  75     t = malloc(sizeof(memorybuffer));
  76     if (!t)
  77         return NULL;
  78
  79     t->length = 0;
  80     t->next = NULL;
  81     return t;
  82 }
  83
  84 static void membufwrite(memorybuffer * const b, void *data, int bytes)
  85 {
  86     uint16_t w;
  87     int32_t l;
  88     char *c;
  89
  90     if (b->next) {              /* memory buffer full - use next buffer */
  91         membufwrite(b->next, data, bytes);
  92         return;
  93     }
  94
  95     if ((bytes < 0 && b->length - bytes > BUF_BLOCK_LEN)
  96         || (bytes > 0 && b->length + bytes > BUF_BLOCK_LEN)) {
  97
  98         /* buffer full and no next allocated... allocate and initialise next
  99          * buffer */
 100         b->next = newmembuf();
 101         membufwrite(b->next, data, bytes);
 102         return;
 103     }
 104
 105     switch (bytes) {
 106     case -4:                   /* convert to little-endian */
 107         l = *(int32_t *)data;
 108         b->buffer[b->length++] = l & 0xFF;
 109         l >>= 8;
 110         b->buffer[b->length++] = l & 0xFF;
 111         l >>= 8;
 112         b->buffer[b->length++] = l & 0xFF;
 113         l >>= 8;
 114         b->buffer[b->length++] = l & 0xFF;
 115         break;
 116
 117     case -2:
 118         w = *(uint16_t *) data;
 119         b->buffer[b->length++] = w & 0xFF;
 120         w >>= 8;
 121         b->buffer[b->length++] = w & 0xFF;
 122         break;
 123
 124     default:
 125         c = data;
 126         while (bytes--)
 127             b->buffer[b->length++] = *c++;
 128         break;
 129     }
 130 }
 131
 132 static void membufdump(memorybuffer * b, FILE * fp)
 133 {
 134     if (!b)
 135         return;
 136
 137     fwrite(b->buffer, 1, b->length, fp);
 138
 139     membufdump(b->next, fp);
 140 }
 141
 142 static int membuflength(memorybuffer * b)
 143 {
 144     if (!b)
 145         return 0;
 146     return b->length + membuflength(b->next);
 147 }
 148
 149 static void freemembuf(memorybuffer * b)
 150 {
 151     if (!b)
 152         return;
 153     freemembuf(b->next);
 154     free(b);
 155 }
 156
 157 /* =========================================================================
 158    General purpose routines and variables used by the library functions
 159    ========================================================================= */
 160
 161 /*
 162  * translateint32_t() and translateint16_t()
 163  *
 164  * translate from little endian to local representation
 165  */
 166 int32_t translateint32_t(int32_t in)
 167 {
 168     int32_t r;
 169     uint8_t *i;
 170
 171     i = (uint8_t *)&in;
 172     r = i[3];
 173     r = (r << 8) + i[2];
 174     r = (r << 8) + i[1];
 175     r = (r << 8) + *i;
 176
 177     return r;
 178 }
 179
 180 uint16_t translateint16_t(uint16_t in)
 181 {
 182     uint16_t r;
 183     uint8_t *i;
 184
 185     i = (uint8_t *)&in;
 186     r = (i[1] << 8) + i[0];
 187
 188     return r;
 189 }
 190
 191 /* Segment types */
 192 static char *knownsegtypes[8] = {
 193     "NULL", "text", "data", "object comment",
 194     "linked comment", "loader comment",
 195     "symbolic debug", "line number debug"
 196 };
 197
 198 /* Get a textual string describing the segment type */
 199 char *translatesegmenttype(uint16_t type)
 200 {
 201     if (type < 8)
 202         return knownsegtypes[type];
 203     if (type < 0x0020)
 204         return "reserved";
 205     if (type < 0x1000)
 206         return "reserved - Moscow";
 207     if (type < 0x8000)
 208         return "reserved - system dependant";
 209     if (type < 0xFFFF)
 210         return "reserved - other";
 211     if (type == 0xFFFF)
 212         return "invalid type code";
 213     return "type code out of range";
 214 }
 215
 216 /* This signature is written to the start of RDOFF files */
 217 const char *RDOFFId = RDOFF2_SIGNATURE;
 218
 219 /* Error messages. Must correspond to the codes defined in rdoff.h */
 220 const char *rdf_errors[11] = {
 221     /* 0 */ "no error occurred",
 222     /* 1 */ "could not open file",
 223     /* 2 */ "invalid file format",
 224     /* 3 */ "error reading file",
 225     /* 4 */ "unknown error",
 226     /* 5 */ "header not read",
 227     /* 6 */ "out of memory",
 228     /* 7 */ "RDOFF v1 not supported",
 229     /* 8 */ "unknown extended header record",
 230     /* 9 */ "header record of known type but unknown length",
 231     /* 10 */ "no such segment"
 232 };
 233
 234 int rdf_errno = 0;
 235
 236 /* ========================================================================
 237    The library functions
 238    ======================================================================== */
 239
 240 int rdfopen(rdffile * f, const char *name)
 241 {
 242     FILE *fp;
 243
 244     fp = fopen(name, "rb");
 245     if (!fp)
 246         return rdf_errno = RDF_ERR_OPEN;
 247
 248     return rdfopenhere(f, fp, NULL, name);
 249 }
 250
 251 int rdfopenhere(rdffile * f, FILE * fp, int *refcount, const char *name)
 252 {
 253     char buf[8];
 254     int32_t initpos;
 255     int32_t l;
 256     uint16_t s;
 257
 258     if (translateint32_t(0x01020304) != 0x01020304) {
 259         /* fix this to be portable! */
 260         fputs("*** this program requires a little endian machine\n",
 261               stderr);
 262         fprintf(stderr, "01020304h = %08"PRIx32"h\n", translateint32_t(0x01020304));
 263         exit(3);
 264     }
 265
 266     f->fp = fp;
 267     initpos = ftell(fp);
 268
 269     fread(buf, 6, 1, f->fp);    /* read header */
 270     buf[6] = 0;
 271
 272     if (strcmp(buf, RDOFFId)) {
 273         fclose(f->fp);
 274         if (!strcmp(buf, "RDOFF1"))
 275             return rdf_errno = RDF_ERR_VER;
 276         return rdf_errno = RDF_ERR_FORMAT;
 277     }
 278
 279     if (fread(&l, 1, 4, f->fp) != 4
 280         || fread(&f->header_len, 1, 4, f->fp) != 4) {
 281         fclose(f->fp);
 282         return rdf_errno = RDF_ERR_READ;
 283     }
 284
 285     f->header_ofs = ftell(f->fp);
 286     f->eof_offset = f->header_ofs + translateint32_t(l) - 4;
 287
 288     if (fseek(f->fp, f->header_len, SEEK_CUR)) {
 289         fclose(f->fp);
 290         return rdf_errno = RDF_ERR_FORMAT;      /* seek past end of file...? */
 291     }
 292
 293     if (fread(&s, 1, 2, f->fp) != 2) {
 294         fclose(f->fp);
 295         return rdf_errno = RDF_ERR_READ;
 296     }
 297
 298     f->nsegs = 0;
 299
 300     while (s != 0) {
 301         f->seg[f->nsegs].type = s;
 302         if (fread(&f->seg[f->nsegs].number, 1, 2, f->fp) != 2 ||
 303             fread(&f->seg[f->nsegs].reserved, 1, 2, f->fp) != 2 ||
 304             fread(&f->seg[f->nsegs].length, 1, 4, f->fp) != 4) {
 305             fclose(f->fp);
 306             return rdf_errno = RDF_ERR_READ;
 307         }
 308
 309         f->seg[f->nsegs].offset = ftell(f->fp);
 310         if (fseek(f->fp, f->seg[f->nsegs].length, SEEK_CUR)) {
 311             fclose(f->fp);
 312             return rdf_errno = RDF_ERR_FORMAT;
 313         }
 314         f->nsegs++;
 315
 316         if (fread(&s, 1, 2, f->fp) != 2) {
 317             fclose(f->fp);
 318             return rdf_errno = RDF_ERR_READ;
 319         }
 320     }
 321
 322     if (f->eof_offset != ftell(f->fp) + 8) {    /* +8 = skip null segment header */
 323         fprintf(stderr, "warning: eof_offset [%"PRId32"] and actual eof offset "
 324                 "[%ld] don't match\n", f->eof_offset, ftell(f->fp) + 8);
 325     }
 326     fseek(f->fp, initpos, SEEK_SET);
 327     f->header_loc = NULL;
 328
 329     f->name = newstr(name);
 330     f->refcount = refcount;
 331     if (refcount)
 332         (*refcount)++;
 333     return RDF_OK;
 334 }
 335
 336 int rdfclose(rdffile * f)
 337 {
 338     if (!f->refcount || !--(*f->refcount)) {
 339         fclose(f->fp);
 340         f->fp = NULL;
 341     }
 342     free(f->name);
 343
 344     return 0;
 345 }
 346
 347 /*
 348  * Print the message for last error (from rdf_errno)
 349  */
 350 void rdfperror(const char *app, const char *name)
 351 {
 352     fprintf(stderr, "%s:%s: %s\n", app, name, rdf_errors[rdf_errno]);
 353     if (rdf_errno == RDF_ERR_OPEN || rdf_errno == RDF_ERR_READ) {
 354         perror(app);
 355     }
 356 }
 357
 358 /*
 359  * Find the segment by its number.
 360  * Returns segment array index, or -1 if segment with such number was not found.
 361  */
 362 int rdffindsegment(rdffile * f, int segno)
 363 {
 364     int i;
 365     for (i = 0; i < f->nsegs; i++)
 366         if (f->seg[i].number == segno)
 367             return i;
 368     return -1;
 369 }
 370
 371 /*
 372  * Load the segment. Returns status.
 373  */
 374 int rdfloadseg(rdffile * f, int segment, void *buffer)
 375 {
 376     int32_t fpos;
 377     size_t slen;
 378
 379     switch (segment) {
 380     case RDOFF_HEADER:
 381         fpos = f->header_ofs;
 382         slen = f->header_len;
 383         f->header_loc = (uint8_t *) buffer;
 384         f->header_fp = 0;
 385         break;
 386     default:
 387         if (segment < f->nsegs) {
 388             fpos = f->seg[segment].offset;
 389             slen = f->seg[segment].length;
 390             f->seg[segment].data = (uint8_t *) buffer;
 391         } else {
 392             return rdf_errno = RDF_ERR_SEGMENT;
 393         }
 394     }
 395
 396     if (fseek(f->fp, fpos, SEEK_SET))
 397         return rdf_errno = RDF_ERR_UNKNOWN;
 398
 399     if (fread(buffer, 1, slen, f->fp) != slen)
 400         return rdf_errno = RDF_ERR_READ;
 401
 402     return RDF_OK;
 403 }
 404
 405 /* Macros for reading integers from header in memory */
 406
 407 #define RI8(v) v = f->header_loc[f->header_fp++]
 408 #define RI16(v) { v = (f->header_loc[f->header_fp] + \
 409                        (f->header_loc[f->header_fp+1] << 8)); \
 410                   f->header_fp += 2; }
 411
 412 #define RI32(v) { v = (f->header_loc[f->header_fp] + \
 413                        (f->header_loc[f->header_fp+1] << 8) + \
 414                        (f->header_loc[f->header_fp+2] << 16) + \
 415                        (f->header_loc[f->header_fp+3] << 24)); \
 416                   f->header_fp += 4; }
 417
 418 #define RS(str,max) { for(i=0;i<max;i++){\
 419   RI8(str[i]); if (!str[i]) break;} str[i]=0; }
 420
 421 /*
 422  * Read a header record.
 423  * Returns the address of record, or NULL in case of error.
 424  */
 425 rdfheaderrec *rdfgetheaderrec(rdffile * f)
 426 {
 427     static rdfheaderrec r;
 428     int i;
 429
 430     if (!f->header_loc) {
 431         rdf_errno = RDF_ERR_HEADER;
 432         return NULL;
 433     }
 434
 435     if (f->header_fp >= f->header_len)
 436         return 0;
 437
 438     RI8(r.type);
 439     RI8(r.g.reclen);
 440
 441     switch (r.type) {
 442     case RDFREC_RELOC:         /* Relocation record */
 443     case RDFREC_SEGRELOC:
 444         if (r.r.reclen != 8) {
 445             rdf_errno = RDF_ERR_RECLEN;
 446             return NULL;
 447         }
 448         RI8(r.r.segment);
 449         RI32(r.r.offset);
 450         RI8(r.r.length);
 451         RI16(r.r.refseg);
 452         break;
 453
 454     case RDFREC_IMPORT:        /* Imported symbol record */
 455     case RDFREC_FARIMPORT:
 456         RI8(r.i.flags);
 457         RI16(r.i.segment);
 458         RS(r.i.label, EXIM_LABEL_MAX);
 459         break;
 460
 461     case RDFREC_GLOBAL:        /* Exported symbol record */
 462         RI8(r.e.flags);
 463         RI8(r.e.segment);
 464         RI32(r.e.offset);
 465         RS(r.e.label, EXIM_LABEL_MAX);
 466         break;
 467
 468     case RDFREC_DLL:           /* DLL record */
 469         RS(r.d.libname, MODLIB_NAME_MAX);
 470         break;
 471
 472     case RDFREC_BSS:           /* BSS reservation record */
 473         if (r.r.reclen != 4) {
 474             rdf_errno = RDF_ERR_RECLEN;
 475             return NULL;
 476         }
 477         RI32(r.b.amount);
 478         break;
 479
 480     case RDFREC_MODNAME:       /* Module name record */
 481         RS(r.m.modname, MODLIB_NAME_MAX);
 482         break;
 483
 484     case RDFREC_COMMON:        /* Common variable */
 485         RI16(r.c.segment);
 486         RI32(r.c.size);
 487         RI16(r.c.align);
 488         RS(r.c.label, EXIM_LABEL_MAX);
 489         break;
 490
 491     default:
 492 #ifdef STRICT_ERRORS
 493         rdf_errno = RDF_ERR_RECTYPE;    /* unknown header record */
 494         return NULL;
 495 #else
 496         for (i = 0; i < r.g.reclen; i++)
 497             RI8(r.g.data[i]);
 498 #endif
 499     }
 500     return &r;
 501 }
 502
 503 /*
 504  * Rewind to the beginning of the file
 505  */
 506 void rdfheaderrewind(rdffile * f)
 507 {
 508     f->header_fp = 0;
 509 }
 510
 511 rdf_headerbuf *rdfnewheader(void)
 512 {
 513     rdf_headerbuf *hb = malloc(sizeof(rdf_headerbuf));
 514     if (hb == NULL)
 515         return NULL;
 516
 517     hb->buf = newmembuf();
 518     hb->nsegments = 0;
 519     hb->seglength = 0;
 520
 521     return hb;
 522 }
 523
 524 int rdfaddheader(rdf_headerbuf * h, rdfheaderrec * r)
 525 {
 526 #ifndef STRICT_ERRORS
 527     int i;
 528 #endif
 529     membufwrite(h->buf, &r->type, 1);
 530     membufwrite(h->buf, &r->g.reclen, 1);
 531
 532     switch (r->type) {
 533     case RDFREC_GENERIC:       /* generic */
 534         membufwrite(h->buf, &r->g.data, r->g.reclen);
 535         break;
 536     case RDFREC_RELOC:
 537     case RDFREC_SEGRELOC:
 538         membufwrite(h->buf, &r->r.segment, 1);
 539         membufwrite(h->buf, &r->r.offset, -4);
 540         membufwrite(h->buf, &r->r.length, 1);
 541         membufwrite(h->buf, &r->r.refseg, -2);  /* 9 bytes written */
 542         break;
 543
 544     case RDFREC_IMPORT:        /* import */
 545     case RDFREC_FARIMPORT:
 546         membufwrite(h->buf, &r->i.flags, 1);
 547         membufwrite(h->buf, &r->i.segment, -2);
 548         membufwrite(h->buf, &r->i.label, strlen(r->i.label) + 1);
 549         break;
 550
 551     case RDFREC_GLOBAL:        /* export */
 552         membufwrite(h->buf, &r->e.flags, 1);
 553         membufwrite(h->buf, &r->e.segment, 1);
 554         membufwrite(h->buf, &r->e.offset, -4);
 555         membufwrite(h->buf, &r->e.label, strlen(r->e.label) + 1);
 556         break;
 557
 558     case RDFREC_DLL:           /* DLL */
 559         membufwrite(h->buf, &r->d.libname, strlen(r->d.libname) + 1);
 560         break;
 561
 562     case RDFREC_BSS:           /* BSS */
 563         membufwrite(h->buf, &r->b.amount, -4);
 564         break;
 565
 566     case RDFREC_MODNAME:       /* Module name */
 567         membufwrite(h->buf, &r->m.modname, strlen(r->m.modname) + 1);
 568         break;
 569
 570     default:
 571 #ifdef STRICT_ERRORS
 572         return rdf_errno = RDF_ERR_RECTYPE;
 573 #else
 574         for (i = 0; i < r->g.reclen; i++)
 575             membufwrite(h->buf, r->g.data[i], 1);
 576 #endif
 577     }
 578     return 0;
 579 }
 580
 581 int rdfaddsegment(rdf_headerbuf * h, int32_t seglength)
 582 {
 583     h->nsegments++;
 584     h->seglength += seglength;
 585     return 0;
 586 }
 587
 588 int rdfwriteheader(FILE * fp, rdf_headerbuf * h)
 589 {
 590     int32_t l, l2;
 591
 592     fwrite(RDOFFId, 1, strlen(RDOFFId), fp);
 593
 594     l = membuflength(h->buf);
 595     l2 = l + 14 + 10 * h->nsegments + h->seglength;
 596     l = translateint32_t(l);
 597     l2 = translateint32_t(l2);
 598     fwrite(&l2, 4, 1, fp);      /* object length */
 599     fwrite(&l, 4, 1, fp);       /* header length */
 600
 601     membufdump(h->buf, fp);
 602
 603     return 0;                   /* no error handling in here... CHANGE THIS! */
 604 }
 605
 606 void rdfdoneheader(rdf_headerbuf * h)
 607 {
 608     freemembuf(h->buf);
 609     free(h);
 610 }