rdoff/rdflib.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 /* rdflib - manipulate RDOFF library files (.rdl) */
  35
  36 /*
  37  * an rdoff library is simply a sequence of RDOFF object files, each
  38  * preceded by the name of the module, an ASCII string of up to 255
  39  * characters, terminated by a zero.
  40  *
  41  * When a library is being created, special signature block is placed
  42  * in the beginning of the file. It is a string 'RDLIB' followed by a
  43  * version number, then int32_t content size and a int32_t time stamp.
  44  * The module name of the signature block is '.sig'.
  45  *
  46  *
  47  * There may be an optional directory placed on the end of the file.
  48  * The format of the directory will be 'RDLDD' followed by a version
  49  * number, followed by the length of the directory, and then the
  50  * directory, the format of which has not yet been designed.
  51  * The module name of the directory must be '.dir'.
  52  *
  53  * All module names beginning with '.' are reserved for possible future
  54  * extensions. The linker ignores all such modules, assuming they have
  55  * the format of a six uint8_t type & version identifier followed by int32_t
  56  * content size, followed by data.
  57  */
  58
  59 #include "compiler.h"
  60
  61 #include <stdio.h>
  62 #include <stdlib.h>
  63 #include <errno.h>
  64 #include <string.h>
  65 #include <time.h>
  66
  67 /* functions supported:
  68  *   create a library   (no extra operands required)
  69  *   add a module from a library (requires filename and name to give mod.)
  70  *   replace a module in a library (requires given name and filename)
  71  *   delete a module from a library (requires given name)
  72  *   extract a module from the library (requires given name and filename)
  73  *   list modules
  74  */
  75
  76 const char *usage =
  77     "usage:\n"
  78     "  rdflib x libname [extra operands]\n\n"
  79     "  where x is one of:\n"
  80     "    c - create library\n"
  81     "    a - add module (operands = filename module-name)\n"
  82     "    x - extract               (module-name filename)\n"
  83     "    r - replace               (module-name filename)\n"
  84     "    d - delete                (module-name)\n" "    t - list\n";
  85
  86 /* Library signature */
  87 const char *rdl_signature = "RDLIB2", *sig_modname = ".sig";
  88
  89 char **_argv;
  90
  91 #define _ENDIANNESS 0           /* 0 for little, 1 for big */
  92
  93 static void int32_ttolocal(int32_t *l)
  94 {
  95 #if _ENDIANNESS
  96     uint8_t t;
  97     uint8_t *p = (uint8_t *)l;
  98
  99     t = p[0];
 100     p[0] = p[3];
 101     p[3] = t;
 102     t = p[1];
 103     p[1] = p[2];
 104     p[2] = p[1];
 105 #else
 106     (void)l;             /* placate optimizers */
 107 #endif
 108 }
 109
 110 static char copybytes(FILE * fp, FILE * fp2, int n)
 111 {
 112     int i, t = 0;
 113
 114     for (i = 0; i < n; i++) {
 115         t = fgetc(fp);
 116         if (t == EOF) {
 117             fprintf(stderr, "rdflib: premature end of file in '%s'\n",
 118                     _argv[2]);
 119             exit(1);
 120         }
 121         if (fp2)
 122             if (fputc(t, fp2) == EOF) {
 123                 fprintf(stderr, "rdflib: write error\n");
 124                 exit(1);
 125             }
 126     }
 127     return (char)t;             /* return last char read */
 128 }
 129
 130 static int32_t copyint32_t(FILE * fp, FILE * fp2)
 131 {
 132     int32_t l;
 133     int i, t;
 134     uint8_t *p = (uint8_t *)&l;
 135
 136     for (i = 0; i < 4; i++) {   /* skip magic no */
 137         t = fgetc(fp);
 138         if (t == EOF) {
 139             fprintf(stderr, "rdflib: premature end of file in '%s'\n",
 140                     _argv[2]);
 141             exit(1);
 142         }
 143         if (fp2)
 144             if (fputc(t, fp2) == EOF) {
 145                 fprintf(stderr, "rdflib: write error\n");
 146                 exit(1);
 147             }
 148         *p++ = t;
 149     }
 150     int32_ttolocal(&l);
 151     return l;
 152 }
 153
 154 int main(int argc, char **argv)
 155 {
 156     FILE *fp, *fp2 = NULL, *fptmp;
 157     char *p, buf[256], c;
 158     int i;
 159     int32_t l;
 160     time_t t;
 161     char rdbuf[10];
 162
 163     _argv = argv;
 164
 165     if (argc < 3 || !strncmp(argv[1], "-h", 2)
 166         || !strncmp(argv[1], "--h", 3)) {
 167         fputs(usage, stdout);
 168         exit(1);
 169     }
 170
 171     switch (argv[1][0]) {
 172     case 'c':                  /* create library */
 173         fp = fopen(argv[2], "wb");
 174         if (!fp) {
 175             fprintf(stderr, "rdflib: could not open '%s'\n", argv[2]);
 176             perror("rdflib");
 177             exit(1);
 178         }
 179         fwrite(sig_modname, 1, strlen(sig_modname) + 1, fp);
 180         fwrite(rdl_signature, 1, strlen(rdl_signature), fp);
 181         t = time(NULL);
 182         l = sizeof(t);
 183         fwrite(&l, sizeof(l), 1, fp);
 184         fwrite(&t, 1, l, fp);
 185         fclose(fp);
 186         break;
 187
 188     case 'a':                  /* add module */
 189         if (argc < 5) {
 190             fprintf(stderr, "rdflib: required parameter missing\n");
 191             exit(1);
 192         }
 193         fp = fopen(argv[2], "ab");
 194         if (!fp) {
 195             fprintf(stderr, "rdflib: could not open '%s'\n", argv[2]);
 196             perror("rdflib");
 197             exit(1);
 198         }
 199
 200         fp2 = fopen(argv[3], "rb");
 201         if (!fp2) {
 202             fprintf(stderr, "rdflib: could not open '%s'\n", argv[3]);
 203             perror("rdflib");
 204             exit(1);
 205         }
 206
 207         p = argv[4];
 208         do {
 209             if (fputc(*p, fp) == EOF) {
 210                 fprintf(stderr, "rdflib: write error\n");
 211                 exit(1);
 212             }
 213         } while (*p++);
 214
 215         while (!feof(fp2)) {
 216             i = fgetc(fp2);
 217             if (i == EOF) {
 218                 break;
 219             }
 220
 221             if (fputc(i, fp) == EOF) {
 222                 fprintf(stderr, "rdflib: write error\n");
 223                 exit(1);
 224             }
 225         }
 226         fclose(fp2);
 227         fclose(fp);
 228         break;
 229
 230     case 'x':
 231         if (argc < 5) {
 232             fprintf(stderr, "rdflib: required parameter missing\n");
 233             exit(1);
 234         }
 235     case 't':
 236         fp = fopen(argv[2], "rb");
 237         if (!fp) {
 238             fprintf(stderr, "rdflib: could not open '%s'\n", argv[2]);
 239             perror("rdflib");
 240             exit(1);
 241         }
 242
 243         fp2 = NULL;
 244         while (!feof(fp)) {
 245             /* read name */
 246             p = buf;
 247             while ((*(p++) = (char)fgetc(fp)))
 248                 if (feof(fp))
 249                     break;
 250
 251             if (feof(fp))
 252                 break;
 253
 254             fp2 = NULL;
 255             if (argv[1][0] == 'x') {
 256                 /* check against desired name */
 257                 if (!strcmp(buf, argv[3])) {
 258                     fp2 = fopen(argv[4], "wb");
 259                     if (!fp2) {
 260                         fprintf(stderr, "rdflib: could not open '%s'\n",
 261                                 argv[4]);
 262                         perror("rdflib");
 263                         exit(1);
 264                     }
 265                 }
 266             } else
 267                 printf("%-40s ", buf);
 268
 269             /* step over the RDOFF file, extracting type information for
 270              * the listing, and copying it if fp2 != NULL */
 271
 272             if (buf[0] == '.') {
 273
 274                 if (argv[1][0] == 't')
 275                     for (i = 0; i < 6; i++)
 276                         printf("%c", copybytes(fp, fp2, 1));
 277                 else
 278                     copybytes(fp, fp2, 6);
 279
 280                 l = copyint32_t(fp, fp2);
 281
 282                 if (argv[1][0] == 't')
 283                     printf("   %"PRId32" bytes content\n", l);
 284
 285                 copybytes(fp, fp2, l);
 286             } else if ((c = copybytes(fp, fp2, 6)) >= '2') {    /* version 2 or above */
 287                 l = copyint32_t(fp, fp2);
 288
 289                 if (argv[1][0] == 't')
 290                     printf("RDOFF%c   %"PRId32" bytes content\n", c, l);
 291                 copybytes(fp, fp2, l);  /* entire object */
 292             } else {
 293                 if (argv[1][0] == 't')
 294                     printf("RDOFF1\n");
 295                 /*
 296                  * version 1 object, so we don't have an object content
 297                  * length field.
 298                  */
 299                 copybytes(fp, fp2, copyint32_t(fp, fp2));  /* header */
 300                 copybytes(fp, fp2, copyint32_t(fp, fp2));  /* text */
 301                 copybytes(fp, fp2, copyint32_t(fp, fp2));  /* data */
 302             }
 303
 304             if (fp2)
 305                 break;
 306         }
 307         fclose(fp);
 308         if (fp2)
 309             fclose(fp2);
 310         else if (argv[1][0] == 'x') {
 311             fprintf(stderr, "rdflib: module '%s' not found in '%s'\n",
 312                     argv[3], argv[2]);
 313             exit(1);
 314         }
 315         break;
 316
 317     case 'r':                  /* replace module */
 318         argc--;
 319     case 'd':                  /* delete module */
 320         if (argc < 4) {
 321             fprintf(stderr, "rdflib: required parameter missing\n");
 322             exit(1);
 323         }
 324
 325         fp = fopen(argv[2], "rb");
 326         if (!fp) {
 327             fprintf(stderr, "rdflib: could not open '%s'\n", argv[2]);
 328             perror("rdflib");
 329             exit(1);
 330         }
 331
 332         if (argv[1][0] == 'r') {
 333             fp2 = fopen(argv[4], "rb");
 334             if (!fp2) {
 335                 fprintf(stderr, "rdflib: could not open '%s'\n", argv[4]);
 336                 perror("rdflib");
 337                 exit(1);
 338             }
 339         }
 340
 341         fptmp = tmpfile();
 342         if (!fptmp) {
 343             fprintf(stderr, "rdflib: could not open temporary file\n");
 344             perror("rdflib");
 345             exit(1);
 346         }
 347
 348         /* copy library into temporary file */
 349         fseek(fp, 0, SEEK_END); /* get file length */
 350         l = ftell(fp);
 351         fseek(fp, 0, SEEK_SET);
 352         copybytes(fp, fptmp, l);
 353         rewind(fptmp);
 354         if (freopen(argv[2], "wb", fp) == NULL) {
 355             fprintf(stderr, "rdflib: could not reopen '%s'\n", argv[2]);
 356             perror("rdflib");
 357             exit(1);
 358         }
 359
 360         while (!feof(fptmp)) {
 361             /* read name */
 362             p = buf;
 363             while ((*(p++) = (char)fgetc(fptmp)))
 364                 if (feof(fptmp))
 365                     break;
 366
 367             if (feof(fptmp))
 368                 break;
 369
 370             /* check against desired name */
 371             if (!strcmp(buf, argv[3])) {
 372                 fread(p = rdbuf, 1, sizeof(rdbuf), fptmp);
 373                 l = *(int32_t *)(p + 6);
 374                 fseek(fptmp, l, SEEK_CUR);
 375                 break;
 376             } else {
 377                 fwrite(buf, 1, strlen(buf) + 1, fp);    /* module name */
 378                 if ((c = copybytes(fptmp, fp, 6)) >= '2') {
 379                     l = copyint32_t(fptmp, fp);    /* version 2 or above */
 380                     copybytes(fptmp, fp, l);    /* entire object */
 381                 }
 382             }
 383         }
 384
 385         if (argv[1][0] == 'r') {
 386             /* copy new module into library */
 387             p = argv[3];
 388             do {
 389                 if (fputc(*p, fp) == EOF) {
 390                     fprintf(stderr, "rdflib: write error\n");
 391                     exit(1);
 392                 }
 393             } while (*p++);
 394
 395             while (!feof(fp2)) {
 396                 i = fgetc(fp2);
 397                 if (i == EOF) {
 398                     break;
 399                 }
 400                 if (fputc(i, fp) == EOF) {
 401                     fprintf(stderr, "rdflib: write error\n");
 402                     exit(1);
 403                 }
 404             }
 405             fclose(fp2);
 406         }
 407
 408         /* copy rest of library if any */
 409         while (!feof(fptmp)) {
 410             i = fgetc(fptmp);
 411             if (i == EOF) {
 412                 break;
 413             }
 414
 415             if (fputc(i, fp) == EOF) {
 416                 fprintf(stderr, "rdflib: write error\n");
 417                 exit(1);
 418             }
 419         }
 420
 421         fclose(fp);
 422         fclose(fptmp);
 423         break;
 424
 425     default:
 426         fprintf(stderr, "rdflib: command '%c' not recognized\n",
 427                 argv[1][0]);
 428         exit(1);
 429     }
 430     return 0;
 431 }