zlib/contrib/untgz/untgz.c

   1 /*
   2  * untgz.c -- Display contents and extract files from a gzip'd TAR file
   3  *
   4  * written by Pedro A. Aranda Gutierrez <paag@tid.es>
   5  * adaptation to Unix by Jean-loup Gailly <jloup@gzip.org>
   6  * various fixes by Cosmin Truta <cosmint@cs.ubbcluj.ro>
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <time.h>
  13 #include <errno.h>
  14
  15 #include "zlib.h"
  16
  17 #ifdef unix
  18 #  include <unistd.h>
  19 #else
  20 #  include <direct.h>
  21 #  include <io.h>
  22 #endif
  23
  24 #ifdef WIN32
  25 #include <windows.h>
  26 #  ifndef F_OK
  27 #    define F_OK  0
  28 #  endif
  29 #  define mkdir(dirname,mode)   _mkdir(dirname)
  30 #  ifdef _MSC_VER
  31 #    define access(path,mode)   _access(path,mode)
  32 #    define chmod(path,mode)    _chmod(path,mode)
  33 #    define strdup(str)         _strdup(str)
  34 #  endif
  35 #else
  36 #  include <utime.h>
  37 #endif
  38
  39
  40 /* values used in typeflag field */
  41
  42 #define REGTYPE  '0'            /* regular file */
  43 #define AREGTYPE '\0'           /* regular file */
  44 #define LNKTYPE  '1'            /* link */
  45 #define SYMTYPE  '2'            /* reserved */
  46 #define CHRTYPE  '3'            /* character special */
  47 #define BLKTYPE  '4'            /* block special */
  48 #define DIRTYPE  '5'            /* directory */
  49 #define FIFOTYPE '6'            /* FIFO special */
  50 #define CONTTYPE '7'            /* reserved */
  51
  52 /* GNU tar extensions */
  53
  54 #define GNUTYPE_DUMPDIR  'D'    /* file names from dumped directory */
  55 #define GNUTYPE_LONGLINK 'K'    /* long link name */
  56 #define GNUTYPE_LONGNAME 'L'    /* long file name */
  57 #define GNUTYPE_MULTIVOL 'M'    /* continuation of file from another volume */
  58 #define GNUTYPE_NAMES    'N'    /* file name that does not fit into main hdr */
  59 #define GNUTYPE_SPARSE   'S'    /* sparse file */
  60 #define GNUTYPE_VOLHDR   'V'    /* tape/volume header */
  61
  62
  63 /* tar header */
  64
  65 #define BLOCKSIZE     512
  66 #define SHORTNAMESIZE 100
  67
  68 struct tar_header
  69 {                               /* byte offset */
  70   char name[100];               /*   0 */
  71   char mode[8];                 /* 100 */
  72   char uid[8];                  /* 108 */
  73   char gid[8];                  /* 116 */
  74   char size[12];                /* 124 */
  75   char mtime[12];               /* 136 */
  76   char chksum[8];               /* 148 */
  77   char typeflag;                /* 156 */
  78   char linkname[100];           /* 157 */
  79   char magic[6];                /* 257 */
  80   char version[2];              /* 263 */
  81   char uname[32];               /* 265 */
  82   char gname[32];               /* 297 */
  83   char devmajor[8];             /* 329 */
  84   char devminor[8];             /* 337 */
  85   char prefix[155];             /* 345 */
  86                                 /* 500 */
  87 };
  88
  89 union tar_buffer
  90 {
  91   char               buffer[BLOCKSIZE];
  92   struct tar_header  header;
  93 };
  94
  95 struct attr_item
  96 {
  97   struct attr_item  *next;
  98   char              *fname;
  99   int                mode;
 100   time_t             time;
 101 };
 102
 103 enum { TGZ_EXTRACT, TGZ_LIST, TGZ_INVALID };
 104
 105 char *TGZfname          OF((const char *));
 106 void TGZnotfound        OF((const char *));
 107
 108 int getoct              OF((char *, int));
 109 char *strtime           OF((time_t *));
 110 int setfiletime         OF((char *, time_t));
 111 void push_attr          OF((struct attr_item **, char *, int, time_t));
 112 void restore_attr       OF((struct attr_item **));
 113
 114 int ExprMatch           OF((char *, char *));
 115
 116 int makedir             OF((char *));
 117 int matchname           OF((int, int, char **, char *));
 118
 119 void error              OF((const char *));
 120 int tar                 OF((gzFile, int, int, int, char **));
 121
 122 void help               OF((int));
 123 int main                OF((int, char **));
 124
 125 char *prog;
 126
 127 const char *TGZsuffix[] = { "\0", ".tar", ".tar.gz", ".taz", ".tgz", NULL };
 128
 129 /* return the file name of the TGZ archive */
 130 /* or NULL if it does not exist */
 131
 132 char *TGZfname (const char *arcname)
 133 {
 134   static char buffer[1024];
 135   int origlen,i;
 136
 137   strcpy(buffer,arcname);
 138   origlen = strlen(buffer);
 139
 140   for (i=0; TGZsuffix[i]; i++)
 141     {
 142        strcpy(buffer+origlen,TGZsuffix[i]);
 143        if (access(buffer,F_OK) == 0)
 144          return buffer;
 145     }
 146   return NULL;
 147 }
 148
 149
 150 /* error message for the filename */
 151
 152 void TGZnotfound (const char *arcname)
 153 {
 154   int i;
 155
 156   fprintf(stderr,"%s: Couldn't find ",prog);
 157   for (i=0;TGZsuffix[i];i++)
 158     fprintf(stderr,(TGZsuffix[i+1]) ? "%s%s, " : "or %s%s\n",
 159             arcname,
 160             TGZsuffix[i]);
 161   exit(1);
 162 }
 163
 164
 165 /* convert octal digits to int */
 166 /* on error return -1 */
 167
 168 int getoct (char *p,int width)
 169 {
 170   int result = 0;
 171   char c;
 172
 173   while (width--)
 174     {
 175       c = *p++;
 176       if (c == 0)
 177         break;
 178       if (c == ' ')
 179         continue;
 180       if (c < '0' || c > '7')
 181         return -1;
 182       result = result * 8 + (c - '0');
 183     }
 184   return result;
 185 }
 186
 187
 188 /* convert time_t to string */
 189 /* use the "YYYY/MM/DD hh:mm:ss" format */
 190
 191 char *strtime (time_t *t)
 192 {
 193   struct tm   *local;
 194   static char result[32];
 195
 196   local = localtime(t);
 197   sprintf(result,"%4d/%02d/%02d %02d:%02d:%02d",
 198           local->tm_year+1900, local->tm_mon+1, local->tm_mday,
 199           local->tm_hour, local->tm_min, local->tm_sec);
 200   return result;
 201 }
 202
 203
 204 /* set file time */
 205
 206 int setfiletime (char *fname,time_t ftime)
 207 {
 208 #ifdef WIN32
 209   static int isWinNT = -1;
 210   SYSTEMTIME st;
 211   FILETIME locft, modft;
 212   struct tm *loctm;
 213   HANDLE hFile;
 214   int result;
 215
 216   loctm = localtime(&ftime);
 217   if (loctm == NULL)
 218     return -1;
 219
 220   st.wYear         = (WORD)loctm->tm_year + 1900;
 221   st.wMonth        = (WORD)loctm->tm_mon + 1;
 222   st.wDayOfWeek    = (WORD)loctm->tm_wday;
 223   st.wDay          = (WORD)loctm->tm_mday;
 224   st.wHour         = (WORD)loctm->tm_hour;
 225   st.wMinute       = (WORD)loctm->tm_min;
 226   st.wSecond       = (WORD)loctm->tm_sec;
 227   st.wMilliseconds = 0;
 228   if (!SystemTimeToFileTime(&st, &locft) ||
 229       !LocalFileTimeToFileTime(&locft, &modft))
 230     return -1;
 231
 232   if (isWinNT < 0)
 233     isWinNT = (GetVersion() < 0x80000000) ? 1 : 0;
 234   hFile = CreateFile(fname, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
 235                      (isWinNT ? FILE_FLAG_BACKUP_SEMANTICS : 0),
 236                      NULL);
 237   if (hFile == INVALID_HANDLE_VALUE)
 238     return -1;
 239   result = SetFileTime(hFile, NULL, NULL, &modft) ? 0 : -1;
 240   CloseHandle(hFile);
 241   return result;
 242 #else
 243   struct utimbuf settime;
 244
 245   settime.actime = settime.modtime = ftime;
 246   return utime(fname,&settime);
 247 #endif
 248 }
 249
 250
 251 /* push file attributes */
 252
 253 void push_attr(struct attr_item **list,char *fname,int mode,time_t time)
 254 {
 255   struct attr_item *item;
 256
 257   item = (struct attr_item *)malloc(sizeof(struct attr_item));
 258   if (item == NULL)
 259     error("Out of memory");
 260   item->fname = strdup(fname);
 261   item->mode  = mode;
 262   item->time  = time;
 263   item->next  = *list;
 264   *list       = item;
 265 }
 266
 267
 268 /* restore file attributes */
 269
 270 void restore_attr(struct attr_item **list)
 271 {
 272   struct attr_item *item, *prev;
 273
 274   for (item = *list; item != NULL; )
 275     {
 276       setfiletime(item->fname,item->time);
 277       chmod(item->fname,item->mode);
 278       prev = item;
 279       item = item->next;
 280       free(prev);
 281     }
 282   *list = NULL;
 283 }
 284
 285
 286 /* match regular expression */
 287
 288 #define ISSPECIAL(c) (((c) == '*') || ((c) == '/'))
 289
 290 int ExprMatch (char *string,char *expr)
 291 {
 292   while (1)
 293     {
 294       if (ISSPECIAL(*expr))
 295         {
 296           if (*expr == '/')
 297             {
 298               if (*string != '\\' && *string != '/')
 299                 return 0;
 300               string ++; expr++;
 301             }
 302           else if (*expr == '*')
 303             {
 304               if (*expr ++ == 0)
 305                 return 1;
 306               while (*++string != *expr)
 307                 if (*string == 0)
 308                   return 0;
 309             }
 310         }
 311       else
 312         {
 313           if (*string != *expr)
 314             return 0;
 315           if (*expr++ == 0)
 316             return 1;
 317           string++;
 318         }
 319     }
 320 }
 321
 322
 323 /* recursive mkdir */
 324 /* abort on ENOENT; ignore other errors like "directory already exists" */
 325 /* return 1 if OK */
 326 /*        0 on error */
 327
 328 int makedir (char *newdir)
 329 {
 330   char *buffer = strdup(newdir);
 331   char *p;
 332   int  len = strlen(buffer);
 333
 334   if (len <= 0) {
 335     free(buffer);
 336     return 0;
 337   }
 338   if (buffer[len-1] == '/') {
 339     buffer[len-1] = '\0';
 340   }
 341   if (mkdir(buffer, 0755) == 0)
 342     {
 343       free(buffer);
 344       return 1;
 345     }
 346
 347   p = buffer+1;
 348   while (1)
 349     {
 350       char hold;
 351
 352       while(*p && *p != '\\' && *p != '/')
 353         p++;
 354       hold = *p;
 355       *p = 0;
 356       if ((mkdir(buffer, 0755) == -1) && (errno == ENOENT))
 357         {
 358           fprintf(stderr,"%s: Couldn't create directory %s\n",prog,buffer);
 359           free(buffer);
 360           return 0;
 361         }
 362       if (hold == 0)
 363         break;
 364       *p++ = hold;
 365     }
 366   free(buffer);
 367   return 1;
 368 }
 369
 370
 371 int matchname (int arg,int argc,char **argv,char *fname)
 372 {
 373   if (arg == argc)      /* no arguments given (untgz tgzarchive) */
 374     return 1;
 375
 376   while (arg < argc)
 377     if (ExprMatch(fname,argv[arg++]))
 378       return 1;
 379
 380   return 0; /* ignore this for the moment being */
 381 }
 382
 383
 384 /* tar file list or extract */
 385
 386 int tar (gzFile in,int action,int arg,int argc,char **argv)
 387 {
 388   union  tar_buffer buffer;
 389   int    len;
 390   int    err;
 391   int    getheader = 1;
 392   int    remaining = 0;
 393   FILE   *outfile = NULL;
 394   char   fname[BLOCKSIZE];
 395   int    tarmode;
 396   time_t tartime;
 397   struct attr_item *attributes = NULL;
 398
 399   if (action == TGZ_LIST)
 400     printf("    date      time     size                       file\n"
 401            " ---------- -------- --------- -------------------------------------\n");
 402   while (1)
 403     {
 404       len = gzread(in, &buffer, BLOCKSIZE);
 405       if (len < 0)
 406         error(gzerror(in, &err));
 407       /*
 408        * Always expect complete blocks to process
 409        * the tar information.
 410        */
 411       if (len != BLOCKSIZE)
 412         {
 413           action = TGZ_INVALID; /* force error exit */
 414           remaining = 0;        /* force I/O cleanup */
 415         }
 416
 417       /*
 418        * If we have to get a tar header
 419        */
 420       if (getheader >= 1)
 421         {
 422           /*
 423            * if we met the end of the tar
 424            * or the end-of-tar block,
 425            * we are done
 426            */
 427           if (len == 0 || buffer.header.name[0] == 0)
 428             break;
 429
 430           tarmode = getoct(buffer.header.mode,8);
 431           tartime = (time_t)getoct(buffer.header.mtime,12);
 432           if (tarmode == -1 || tartime == (time_t)-1)
 433             {
 434               buffer.header.name[0] = 0;
 435               action = TGZ_INVALID;
 436             }
 437
 438           if (getheader == 1)
 439             {
 440               strncpy(fname,buffer.header.name,SHORTNAMESIZE);
 441               if (fname[SHORTNAMESIZE-1] != 0)
 442                   fname[SHORTNAMESIZE] = 0;
 443             }
 444           else
 445             {
 446               /*
 447                * The file name is longer than SHORTNAMESIZE
 448                */
 449               if (strncmp(fname,buffer.header.name,SHORTNAMESIZE-1) != 0)
 450                   error("bad long name");
 451               getheader = 1;
 452             }
 453
 454           /*
 455            * Act according to the type flag
 456            */
 457           switch (buffer.header.typeflag)
 458             {
 459             case DIRTYPE:
 460               if (action == TGZ_LIST)
 461                 printf(" %s     <dir> %s\n",strtime(&tartime),fname);
 462               if (action == TGZ_EXTRACT)
 463                 {
 464                   makedir(fname);
 465                   push_attr(&attributes,fname,tarmode,tartime);
 466                 }
 467               break;
 468             case REGTYPE:
 469             case AREGTYPE:
 470               remaining = getoct(buffer.header.size,12);
 471               if (remaining == -1)
 472                 {
 473                   action = TGZ_INVALID;
 474                   break;
 475                 }
 476               if (action == TGZ_LIST)
 477                 printf(" %s %9d %s\n",strtime(&tartime),remaining,fname);
 478               else if (action == TGZ_EXTRACT)
 479                 {
 480                   if (matchname(arg,argc,argv,fname))
 481                     {
 482                       outfile = fopen(fname,"wb");
 483                       if (outfile == NULL) {
 484                         /* try creating directory */
 485                         char *p = strrchr(fname, '/');
 486                         if (p != NULL) {
 487                           *p = '\0';
 488                           makedir(fname);
 489                           *p = '/';
 490                           outfile = fopen(fname,"wb");
 491                         }
 492                       }
 493                       if (outfile != NULL)
 494                         printf("Extracting %s\n",fname);
 495                       else
 496                         fprintf(stderr, "%s: Couldn't create %s",prog,fname);
 497                     }
 498                   else
 499                     outfile = NULL;
 500                 }
 501               getheader = 0;
 502               break;
 503             case GNUTYPE_LONGLINK:
 504             case GNUTYPE_LONGNAME:
 505               remaining = getoct(buffer.header.size,12);
 506               if (remaining < 0 || remaining >= BLOCKSIZE)
 507                 {
 508                   action = TGZ_INVALID;
 509                   break;
 510                 }
 511               len = gzread(in, fname, BLOCKSIZE);
 512               if (len < 0)
 513                 error(gzerror(in, &err));
 514               if (fname[BLOCKSIZE-1] != 0 || (int)strlen(fname) > remaining)
 515                 {
 516                   action = TGZ_INVALID;
 517                   break;
 518                 }
 519               getheader = 2;
 520               break;
 521             default:
 522               if (action == TGZ_LIST)
 523                 printf(" %s     <---> %s\n",strtime(&tartime),fname);
 524               break;
 525             }
 526         }
 527       else
 528         {
 529           unsigned int bytes = (remaining > BLOCKSIZE) ? BLOCKSIZE : remaining;
 530
 531           if (outfile != NULL)
 532             {
 533               if (fwrite(&buffer,sizeof(char),bytes,outfile) != bytes)
 534                 {
 535                   fprintf(stderr,
 536                     "%s: Error writing %s -- skipping\n",prog,fname);
 537                   fclose(outfile);
 538                   outfile = NULL;
 539                   remove(fname);
 540                 }
 541             }
 542           remaining -= bytes;
 543         }
 544
 545       if (remaining == 0)
 546         {
 547           getheader = 1;
 548           if (outfile != NULL)
 549             {
 550               fclose(outfile);
 551               outfile = NULL;
 552               if (action != TGZ_INVALID)
 553                 push_attr(&attributes,fname,tarmode,tartime);
 554             }
 555         }
 556
 557       /*
 558        * Abandon if errors are found
 559        */
 560       if (action == TGZ_INVALID)
 561         {
 562           error("broken archive");
 563           break;
 564         }
 565     }
 566
 567   /*
 568    * Restore file modes and time stamps
 569    */
 570   restore_attr(&attributes);
 571
 572   if (gzclose(in) != Z_OK)
 573     error("failed gzclose");
 574
 575   return 0;
 576 }
 577
 578
 579 /* ============================================================ */
 580
 581 void help(int exitval)
 582 {
 583   printf("untgz version 0.2.1\n"
 584          "  using zlib version %s\n\n",
 585          zlibVersion());
 586   printf("Usage: untgz file.tgz            extract all files\n"
 587          "       untgz file.tgz fname ...  extract selected files\n"
 588          "       untgz -l file.tgz         list archive contents\n"
 589          "       untgz -h                  display this help\n");
 590   exit(exitval);
 591 }
 592
 593 void error(const char *msg)
 594 {
 595   fprintf(stderr, "%s: %s\n", prog, msg);
 596   exit(1);
 597 }
 598
 599
 600 /* ============================================================ */
 601
 602 #if defined(WIN32) && defined(__GNUC__)
 603 int _CRT_glob = 0;      /* disable argument globbing in MinGW */
 604 #endif
 605
 606 int main(int argc,char **argv)
 607 {
 608     int         action = TGZ_EXTRACT;
 609     int         arg = 1;
 610     char        *TGZfile;
 611     gzFile      *f;
 612
 613     prog = strrchr(argv[0],'\\');
 614     if (prog == NULL)
 615       {
 616         prog = strrchr(argv[0],'/');
 617         if (prog == NULL)
 618           {
 619             prog = strrchr(argv[0],':');
 620             if (prog == NULL)
 621               prog = argv[0];
 622             else
 623               prog++;
 624           }
 625         else
 626           prog++;
 627       }
 628     else
 629       prog++;
 630
 631     if (argc == 1)
 632       help(0);
 633
 634     if (strcmp(argv[arg],"-l") == 0)
 635       {
 636         action = TGZ_LIST;
 637         if (argc == ++arg)
 638           help(0);
 639       }
 640     else if (strcmp(argv[arg],"-h") == 0)
 641       {
 642         help(0);
 643       }
 644
 645     if ((TGZfile = TGZfname(argv[arg])) == NULL)
 646       TGZnotfound(argv[arg]);
 647
 648     ++arg;
 649     if ((action == TGZ_LIST) && (arg != argc))
 650       help(1);
 651
 652 /*
 653  *  Process the TGZ file
 654  */
 655     switch(action)
 656       {
 657       case TGZ_LIST:
 658       case TGZ_EXTRACT:
 659         f = gzopen(TGZfile,"rb");
 660         if (f == NULL)
 661           {
 662             fprintf(stderr,"%s: Couldn't gzopen %s\n",prog,TGZfile);
 663             return 1;
 664           }
 665         exit(tar(f, action, arg, argc, argv));
 666       break;
 667
 668       default:
 669         error("Unknown option");
 670         exit(1);
 671       }
 672
 673     return 0;
 674 }