rdoff/rdlar.c

   1 /*
   2  * rdlar.c - new librarian/archiver for RDOFF2.
   3  * Copyright (c) 2002 RET & COM Research.
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <ctype.h>
   9 #include <stdarg.h>
  10 #include <string.h>
  11 #include <errno.h>
  12 #include <time.h>
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15
  16 #include "rdlar.h"
  17
  18 #define PROGRAM_VERSION "0.1"
  19
  20 /** Types **/
  21 typedef enum { FALSE, TRUE } bool;
  22
  23 /** Constants **/
  24 const char commands[] = "adnrtx";
  25 const char modifiers[] = "cflouvV";
  26
  27 /** Global variables **/
  28 char *progname = "rdlar";
  29 char **_argv = NULL;
  30 struct {
  31     bool createok;
  32     bool usefname;
  33     bool align;
  34     bool odate;
  35     bool fresh;
  36     int verbose;
  37 } options = {
  38 0, 0, 0, 0, 0, 0};
  39
  40 #define _ENDIANNESS 0           /* 0 for little, 1 for big */
  41
  42 /*
  43  * Convert int32_t to little endian (if we were compiled on big-endian machine)
  44  */
  45 static void int32_ttolocal(int32_t *l)
  46 {
  47 #if _ENDIANNESS
  48     uint8_t t;
  49     uint8_t *p = (uint8_t *)l;
  50
  51     t = p[0];
  52     p[0] = p[3];
  53     p[3] = t;
  54     t = p[1];
  55     p[1] = p[2];
  56     p[2] = p[1];
  57 #endif
  58 }
  59
  60 /*
  61  * Print version information
  62  */
  63 void show_version(void)
  64 {
  65     puts("New RDOFF2 librarian/archiver, version " PROGRAM_VERSION "\n"
  66          "Copyright (c) 2002 RET & COM Research.\n"
  67          "This program is free software and distributed under GPL (version 2 or later);\n"
  68          "see http://www.gnu.org/copyleft/gpl.html for details.");
  69 }
  70
  71 /*
  72  * Print usage instructions
  73  */
  74 void usage(void)
  75 {
  76     printf("Usage:  %s [-]{%s}[%s] libfile [module-name] [files]\n",
  77            progname, commands, modifiers);
  78     puts(" commands:\n"
  79          "  a            - add module(s) to the library\n"
  80          "  d            - delete module(s) from the library\n"
  81          "  n            - create the library\n"
  82          "  r            - replace module(s)\n"
  83          "  t            - display contents of library\n"
  84          "  x            - extract module(s)\n"
  85          " command specific modifiers:\n"
  86          "  o            - preserve original dates\n"
  87          "  u            - only replace modules that are newer than library contents\n"
  88          " generic modifiers:\n"
  89          "  c            - do not warn if the library had to be created\n"
  90          "  f            - use file name as a module name\n"
  91          "  v            - be verbose\n"
  92          "  V            - display version information");
  93 }
  94
  95 /*
  96  * Print an error message and exit
  97  */
  98 void error_exit(int errcode, bool useperror, const char *fmt, ...)
  99 {
 100     va_list ap;
 101
 102     fprintf(stderr, "%s: ", progname);
 103     va_start(ap, fmt);
 104     vfprintf(stderr, fmt, ap);
 105     va_end(ap);
 106     putc('\n', stderr);
 107     if (useperror)
 108         perror(progname);
 109     exit(errcode);
 110 }
 111
 112 /*
 113  * Fill in and write a header
 114  */
 115 void put_header(struct rdlm_hdr *hdr, FILE * libfp, char *modname)
 116 {
 117     int n = 0;
 118
 119     hdr->hdrsize = sizeof(*hdr);
 120     if (modname)
 121         hdr->hdrsize += (n = strlen(modname) + 1);
 122     if (libfp == NULL)
 123         return;
 124     if (fwrite(hdr, 1, sizeof(*hdr), libfp) != sizeof(*hdr) ||
 125         (modname && (fwrite(modname, 1, n, libfp) != n)))
 126         error_exit(3, TRUE, "could not write header");
 127 }
 128
 129 /*
 130  * Copy n bytes from one file to another and return last character read.
 131  */
 132 char copybytes(FILE * fp, FILE * fp2, int n)
 133 {
 134     int i, t = 0;
 135
 136     for (i = 0; i < n; i++) {
 137         t = fgetc(fp);
 138         if (t == EOF)
 139             error_exit(1, FALSE, "premature end of file in '%s'",
 140                        _argv[2]);
 141         if (fp2)
 142             if (fputc(t, fp2) == EOF)
 143                 error_exit(1, FALSE, "write error");
 144     }
 145     return (char)t;
 146 }
 147
 148 /*
 149  * Copy uint32_t from one file to another.
 150  * Return local presentation of int32_t.
 151  */
 152 int32_t copyint32_t(FILE * fp, FILE * fp2)
 153 {
 154     int32_t l;
 155     int i, t;
 156     uint8_t *p = (uint8_t *)&l;
 157
 158     for (i = 0; i < 4; i++) {
 159         t = fgetc(fp);
 160         if (t == EOF)
 161             error_exit(1, FALSE, "premature end of file in '%s'",
 162                        _argv[2]);
 163         if (fp2)
 164             if (fputc(t, fp2) == EOF)
 165                 error_exit(1, FALSE, "write error");
 166         *p++ = t;
 167     }
 168     int32_ttolocal(&l);
 169     return l;
 170 }
 171
 172 /*
 173  * Create a new library
 174  */
 175 int create_library(char *libname)
 176 {
 177     FILE *libfp;
 178     struct rdlm_hdr hdr;
 179
 180     hdr.magic = RDLAMAG;
 181     hdr.hdrsize = 0;
 182     hdr.date = time(NULL);
 183     hdr.owner = getuid();
 184     hdr.group = getgid();
 185     hdr.mode = umask(022);
 186     hdr.size = 0;
 187
 188     libfp = fopen(libname, "wb");
 189     if (!libfp)
 190         error_exit(1, TRUE, "could not open '%s'\n", libname);
 191
 192     /* Write library header */
 193     put_header(&hdr, libfp, NULL);
 194
 195     fclose(libfp);
 196     return TRUE;
 197 }
 198
 199 /*
 200  * Add a module to the library
 201  */
 202 int add_module(FILE * libfp, const char *fname, char *modname)
 203 {
 204     FILE *modfp;
 205     struct rdlm_hdr hdr = { RDLMMAG, 0, 0, 0, 0, 0, 0 };
 206     struct stat finfo;
 207     int i;
 208
 209     if (options.verbose)
 210         fprintf(stderr, "adding module %s\n", modname);
 211
 212     /* Initialize some fields in the module header */
 213     if (stat(fname, &finfo) < 0)
 214         error_exit(1, TRUE, "could not stat '%s'", fname);
 215     hdr.date = finfo.st_mtime;
 216     hdr.owner = finfo.st_uid;
 217     hdr.group = finfo.st_gid;
 218     hdr.size = finfo.st_size;
 219
 220     modfp = fopen(fname, "rb");
 221     if (!modfp)
 222         error_exit(1, TRUE, "could not open '%s'", fname);
 223
 224     /* Write module header */
 225     put_header(&hdr, libfp, modname);
 226
 227     /* Put the module itself */
 228     while (!feof(modfp)) {
 229         i = fgetc(modfp);
 230         if (i == EOF)
 231             break;
 232         if (fputc(i, libfp) == EOF)
 233             error_exit(1, FALSE, "write error");
 234     }
 235
 236     fclose(modfp);
 237     return TRUE;
 238 }
 239
 240 /*
 241  * Main
 242  */
 243 int main(int argc, char **argv)
 244 {
 245     FILE *libfp, *tmpfp, *modfp = NULL;
 246     struct stat finfo;
 247     struct rdlm_hdr hdr;
 248     char buf[MAXMODNAMELEN], *p = NULL;
 249     char c;
 250     int i;
 251
 252     progname = argv[0];
 253     _argv = argv;
 254
 255     if (argc < 2) {
 256         usage();
 257         exit(1);
 258     }
 259
 260     /* Check whether some modifiers were specified */
 261     for (i = 1; i < strlen(argv[1]); i++) {
 262         switch (c = argv[1][i]) {
 263         case 'c':
 264             options.createok = TRUE;
 265             break;
 266         case 'f':
 267             options.usefname = TRUE;
 268             break;
 269         case 'l':
 270             options.align = TRUE;
 271             break;
 272         case 'o':
 273             options.odate = TRUE;
 274             break;
 275         case 'u':
 276             options.fresh = TRUE;
 277             break;
 278         case 'v':
 279             options.verbose++;
 280             break;
 281         case 'V':
 282             show_version();
 283             exit(0);
 284         default:
 285             if (strchr(commands, c) == NULL)
 286                 error_exit(2, FALSE, "invalid command or modifier '%c'",
 287                            c);
 288         }
 289     }
 290
 291     if (argc < 3)
 292         error_exit(2, FALSE, "missing library name");
 293
 294     /* Process the command */
 295     if (argv[1][0] == '-')
 296         argv[1]++;
 297     switch (c = argv[1][0]) {
 298     case 'a':                  /* add a module */
 299         if (argc < 4 || (!options.usefname && argc != 5))
 300             error_exit(2, FALSE, "invalid number of arguments");
 301
 302         /* Check if a library already exists. If not - create it */
 303         if (access(argv[2], F_OK) < 0) {
 304             if (!options.createok)
 305                 fprintf(stderr, "creating library %s\n", argv[2]);
 306             create_library(argv[2]);
 307         }
 308
 309         libfp = fopen(argv[2], "ab");
 310         if (!libfp)
 311             error_exit(1, TRUE, "could not open '%s'", argv[2]);
 312
 313         if (!options.usefname)
 314             add_module(libfp, argv[4], argv[3]);
 315         else
 316             for (i = 3; i < argc; i++)
 317                 add_module(libfp, argv[i], argv[i]);
 318
 319         fclose(libfp);
 320         break;
 321
 322     case 'n':                  /* create library */
 323         create_library(argv[2]);
 324         break;
 325
 326     case 'x':                  /* extract module(s) */
 327         if (!options.usefname)
 328             argc--;
 329         if (argc < 4)
 330             error_exit(2, FALSE, "required parameter missing");
 331         p = options.usefname ? argv[3] : argv[4];
 332     case 't':                  /* list library contents */
 333         libfp = fopen(argv[2], "rb");
 334         if (!libfp)
 335             error_exit(1, TRUE, "could not open '%s'\n", argv[2]);
 336
 337         /* Read library header */
 338         if (fread(&hdr, 1, sizeof(hdr), libfp) != sizeof(hdr) ||
 339             hdr.magic != RDLAMAG)
 340             error_exit(1, FALSE, "invalid library format");
 341
 342         /* Walk through the library looking for requested module */
 343         while (!feof(libfp)) {
 344             /* Read module header */
 345             i = fread(&hdr, 1, sizeof(hdr), libfp);
 346             if (feof(libfp))
 347                 break;
 348             if (i != sizeof(hdr) || hdr.magic != RDLMMAG)
 349                 error_exit(1, FALSE, "invalid module header");
 350             /* Read module name */
 351             i = hdr.hdrsize - sizeof(hdr);
 352             if (i > sizeof(buf) || fread(buf, 1, i, libfp) != i)
 353                 error_exit(1, FALSE, "invalid module name");
 354             if (c == 'x') {
 355                 /* Check against desired name */
 356                 if (!strcmp(buf, argv[3])) {
 357                     if (options.verbose)
 358                         fprintf(stderr,
 359                                 "extracting module %s to file %s\n", buf,
 360                                 p);
 361                     modfp = fopen(p, "wb");
 362                     if (!modfp)
 363                         error_exit(1, TRUE, "could not open '%s'", p);
 364                 }
 365             } else {
 366                 printf("%-40s ", buf);
 367                 if (options.verbose) {
 368                     printf("%ld bytes", hdr.size);
 369                 }
 370                 putchar('\n');
 371             }
 372
 373             copybytes(libfp, modfp, hdr.size);
 374             if (modfp)
 375                 break;
 376         }
 377
 378         fclose(libfp);
 379         if (modfp)
 380             fclose(modfp);
 381         else if (c == 'x')
 382             error_exit(1, FALSE, "module '%s' not found in '%s'",
 383                        argv[3], argv[2]);
 384         break;
 385
 386     case 'r':                  /* replace module(s) */
 387         argc--;
 388         if (stat(argv[4], &finfo) < 0)
 389             error_exit(1, TRUE, "could not stat '%s'", argv[4]);
 390     case 'd':                  /* delete module(s) */
 391         if (argc < 4)
 392             error_exit(2, FALSE, "required parameter missing");
 393
 394         libfp = fopen(argv[2], "rb");
 395         if (!libfp)
 396             error_exit(1, TRUE, "could not open '%s'", argv[2]);
 397
 398         /* Copy the library into a temporary file */
 399         tmpfp = tmpfile();
 400         if (!tmpfp)
 401             error_exit(1, TRUE, "could not open temporary file");
 402
 403         stat(argv[2], &finfo);
 404         copybytes(libfp, tmpfp, finfo.st_size);
 405         rewind(tmpfp);
 406         freopen(argv[2], "wb", libfp);
 407
 408         /* Read library header and write it to a new file */
 409         if (fread(&hdr, 1, sizeof(hdr), tmpfp) != sizeof(hdr) ||
 410             hdr.magic != RDLAMAG)
 411             error_exit(1, FALSE, "invalid library format");
 412         put_header(&hdr, libfp, NULL);
 413
 414         /* Walk through the library looking for requested module */
 415         while (!feof(tmpfp)) {
 416             /* Read module header */
 417             if (fread(&hdr, 1, sizeof(hdr), tmpfp) != sizeof(hdr) ||
 418                 hdr.magic != RDLMMAG)
 419                 error_exit(1, FALSE, "invalid module header");
 420             /* Read module name */
 421             i = hdr.hdrsize - sizeof(hdr);
 422             if (i > sizeof(buf) || fread(buf, 1, i, tmpfp) != i)
 423                 error_exit(1, FALSE, "invalid module name");
 424             /* Check against desired name */
 425             if (!strcmp(buf, argv[3]) &&
 426                 (c == 'd' || !options.odate
 427                  || finfo.st_mtime <= hdr.date)) {
 428                 if (options.verbose)
 429                     fprintf(stderr, "deleting module %s\n", buf);
 430                 fseek(tmpfp, hdr.size, SEEK_CUR);
 431                 break;
 432             } else {
 433                 put_header(&hdr, libfp, buf);
 434                 copybytes(tmpfp, libfp, hdr.size);
 435             }
 436         }
 437
 438         if (c == 'r') {
 439             /* Copy new module into library */
 440             p = options.usefname ? argv[4] : argv[3];
 441             add_module(libfp, argv[4], p);
 442         }
 443
 444         /* Copy rest of library if any */
 445         while (!feof(tmpfp)) {
 446             if ((i = fgetc(tmpfp)) == EOF)
 447                 break;
 448
 449             if (fputc(i, libfp) == EOF)
 450                 error_exit(1, FALSE, "write error");
 451         }
 452
 453         fclose(libfp);
 454         fclose(tmpfp);
 455         break;
 456
 457     default:
 458         error_exit(2, FALSE, "invalid command '%c'\n", c);
 459     }
 460
 461     return 0;
 462 }