common/dist/zlib/examples/gun.c

   1 /*      $NetBSD$        */
   2
   3 /* gun.c -- simple gunzip to give an example of the use of inflateBack()
   4  * Copyright (C) 2003, 2005 Mark Adler
   5  * For conditions of distribution and use, see copyright notice in zlib.h
   6    Version 1.3  12 June 2005  Mark Adler */
   7
   8 /* Version history:
   9    1.0  16 Feb 2003  First version for testing of inflateBack()
  10    1.1  21 Feb 2005  Decompress concatenated gzip streams
  11                      Remove use of "this" variable (C++ keyword)
  12                      Fix return value for in()
  13                      Improve allocation failure checking
  14                      Add typecasting for void * structures
  15                      Add -h option for command version and usage
  16                      Add a bunch of comments
  17    1.2  20 Mar 2005  Add Unix compress (LZW) decompression
  18                      Copy file attributes from input file to output file
  19    1.3  12 Jun 2005  Add casts for error messages [Oberhumer]
  20  */
  21
  22 /*
  23    gun [ -t ] [ name ... ]
  24
  25    decompresses the data in the named gzip files.  If no arguments are given,
  26    gun will decompress from stdin to stdout.  The names must end in .gz, -gz,
  27    .z, -z, _z, or .Z.  The uncompressed data will be written to a file name
  28    with the suffix stripped.  On success, the original file is deleted.  On
  29    failure, the output file is deleted.  For most failures, the command will
  30    continue to process the remaining names on the command line.  A memory
  31    allocation failure will abort the command.  If -t is specified, then the
  32    listed files or stdin will be tested as gzip files for integrity (without
  33    checking for a proper suffix), no output will be written, and no files
  34    will be deleted.
  35
  36    Like gzip, gun allows concatenated gzip streams and will decompress them,
  37    writing all of the uncompressed data to the output.  Unlike gzip, gun allows
  38    an empty file on input, and will produce no error writing an empty output
  39    file.
  40
  41    gun will also decompress files made by Unix compress, which uses LZW
  42    compression.  These files are automatically detected by virtue of their
  43    magic header bytes.  Since the end of Unix compress stream is marked by the
  44    end-of-file, they cannot be concantenated.  If a Unix compress stream is
  45    encountered in an input file, it is the last stream in that file.
  46
  47    Like gunzip and uncompress, the file attributes of the orignal compressed
  48    file are maintained in the final uncompressed file, to the extent that the
  49    user permissions allow it.
  50
  51    On my Mac OS X PowerPC G4, gun is almost twice as fast as gunzip (version
  52    1.2.4) is on the same file, when gun is linked with zlib 1.2.2.  Also the
  53    LZW decompression provided by gun is about twice as fast as the standard
  54    Unix uncompress command.
  55  */
  56
  57 /* external functions and related types and constants */
  58 #include <stdio.h>          /* fprintf() */
  59 #include <stdlib.h>         /* malloc(), free() */
  60 #include <string.h>         /* strerror(), strcmp(), strlen(), memcpy() */
  61 #include <errno.h>          /* errno */
  62 #include <fcntl.h>          /* open() */
  63 #include <unistd.h>         /* read(), write(), close(), chown(), unlink() */
  64 #include <sys/types.h>
  65 #include <sys/stat.h>       /* stat(), chmod() */
  66 #include <utime.h>          /* utime() */
  67 #include "zlib.h"           /* inflateBackInit(), inflateBack(), */
  68                             /* inflateBackEnd(), crc32() */
  69
  70 /* function declaration */
  71 #define local static
  72
  73 /* buffer constants */
  74 #define SIZE 32768U         /* input and output buffer sizes */
  75 #define PIECE 16384         /* limits i/o chunks for 16-bit int case */
  76
  77 /* structure for infback() to pass to input function in() -- it maintains the
  78    input file and a buffer of size SIZE */
  79 struct ind {
  80     int infile;
  81     unsigned char *inbuf;
  82 };
  83
  84 /* Load input buffer, assumed to be empty, and return bytes loaded and a
  85    pointer to them.  read() is called until the buffer is full, or until it
  86    returns end-of-file or error.  Return 0 on error. */
  87 local unsigned in(void *in_desc, unsigned char **buf)
  88 {
  89     int ret;
  90     unsigned len;
  91     unsigned char *next;
  92     struct ind *me = (struct ind *)in_desc;
  93
  94     next = me->inbuf;
  95     *buf = next;
  96     len = 0;
  97     do {
  98         ret = PIECE;
  99         if ((unsigned)ret > SIZE - len)
 100             ret = (int)(SIZE - len);
 101         ret = (int)read(me->infile, next, ret);
 102         if (ret == -1) {
 103             len = 0;
 104             break;
 105         }
 106         next += ret;
 107         len += ret;
 108     } while (ret != 0 && len < SIZE);
 109     return len;
 110 }
 111
 112 /* structure for infback() to pass to output function out() -- it maintains the
 113    output file, a running CRC-32 check on the output and the total number of
 114    bytes output, both for checking against the gzip trailer.  (The length in
 115    the gzip trailer is stored modulo 2^32, so it's ok if a long is 32 bits and
 116    the output is greater than 4 GB.) */
 117 struct outd {
 118     int outfile;
 119     int check;                  /* true if checking crc and total */
 120     unsigned long crc;
 121     unsigned long total;
 122 };
 123
 124 /* Write output buffer and update the CRC-32 and total bytes written.  write()
 125    is called until all of the output is written or an error is encountered.
 126    On success out() returns 0.  For a write failure, out() returns 1.  If the
 127    output file descriptor is -1, then nothing is written.
 128  */
 129 local int out(void *out_desc, unsigned char *buf, unsigned len)
 130 {
 131     int ret;
 132     struct outd *me = (struct outd *)out_desc;
 133
 134     if (me->check) {
 135         me->crc = crc32(me->crc, buf, len);
 136         me->total += len;
 137     }
 138     if (me->outfile != -1)
 139         do {
 140             ret = PIECE;
 141             if ((unsigned)ret > len)
 142                 ret = (int)len;
 143             ret = (int)write(me->outfile, buf, ret);
 144             if (ret == -1)
 145                 return 1;
 146             buf += ret;
 147             len -= ret;
 148         } while (len != 0);
 149     return 0;
 150 }
 151
 152 /* next input byte macro for use inside lunpipe() and gunpipe() */
 153 #define NEXT() (have ? 0 : (have = in(indp, &next)), \
 154                 last = have ? (have--, (int)(*next++)) : -1)
 155
 156 /* memory for gunpipe() and lunpipe() --
 157    the first 256 entries of prefix[] and suffix[] are never used, could
 158    have offset the index, but it's faster to waste the memory */
 159 unsigned char inbuf[SIZE];              /* input buffer */
 160 unsigned char outbuf[SIZE];             /* output buffer */
 161 unsigned short prefix[65536];           /* index to LZW prefix string */
 162 unsigned char suffix[65536];            /* one-character LZW suffix */
 163 unsigned char match[65280 + 2];         /* buffer for reversed match or gzip
 164                                            32K sliding window */
 165
 166 /* throw out what's left in the current bits byte buffer (this is a vestigial
 167    aspect of the compressed data format derived from an implementation that
 168    made use of a special VAX machine instruction!) */
 169 #define FLUSHCODE() \
 170     do { \
 171         left = 0; \
 172         rem = 0; \
 173         if (chunk > have) { \
 174             chunk -= have; \
 175             have = 0; \
 176             if (NEXT() == -1) \
 177                 break; \
 178             chunk--; \
 179             if (chunk > have) { \
 180                 chunk = have = 0; \
 181                 break; \
 182             } \
 183         } \
 184         have -= chunk; \
 185         next += chunk; \
 186         chunk = 0; \
 187     } while (0)
 188
 189 /* Decompress a compress (LZW) file from indp to outfile.  The compress magic
 190    header (two bytes) has already been read and verified.  There are have bytes
 191    of buffered input at next.  strm is used for passing error information back
 192    to gunpipe().
 193
 194    lunpipe() will return Z_OK on success, Z_BUF_ERROR for an unexpected end of
 195    file, read error, or write error (a write error indicated by strm->next_in
 196    not equal to Z_NULL), or Z_DATA_ERROR for invalid input.
 197  */
 198 local int lunpipe(unsigned have, unsigned char *next, struct ind *indp,
 199                   int outfile, z_stream *strm)
 200 {
 201     int last;                   /* last byte read by NEXT(), or -1 if EOF */
 202     int chunk;                  /* bytes left in current chunk */
 203     int left;                   /* bits left in rem */
 204     unsigned rem;               /* unused bits from input */
 205     int bits;                   /* current bits per code */
 206     unsigned code;              /* code, table traversal index */
 207     unsigned mask;              /* mask for current bits codes */
 208     int max;                    /* maximum bits per code for this stream */
 209     int flags;                  /* compress flags, then block compress flag */
 210     unsigned end;               /* last valid entry in prefix/suffix tables */
 211     unsigned temp;              /* current code */
 212     unsigned prev;              /* previous code */
 213     unsigned final;             /* last character written for previous code */
 214     unsigned stack;             /* next position for reversed string */
 215     unsigned outcnt;            /* bytes in output buffer */
 216     struct outd outd;           /* output structure */
 217
 218     /* set up output */
 219     outd.outfile = outfile;
 220     outd.check = 0;
 221
 222     /* process remainder of compress header -- a flags byte */
 223     flags = NEXT();
 224     if (last == -1)
 225         return Z_BUF_ERROR;
 226     if (flags & 0x60) {
 227         strm->msg = (char *)"unknown lzw flags set";
 228         return Z_DATA_ERROR;
 229     }
 230     max = flags & 0x1f;
 231     if (max < 9 || max > 16) {
 232         strm->msg = (char *)"lzw bits out of range";
 233         return Z_DATA_ERROR;
 234     }
 235     if (max == 9)                           /* 9 doesn't really mean 9 */
 236         max = 10;
 237     flags &= 0x80;                          /* true if block compress */
 238
 239     /* clear table */
 240     bits = 9;
 241     mask = 0x1ff;
 242     end = flags ? 256 : 255;
 243
 244     /* set up: get first 9-bit code, which is the first decompressed byte, but
 245        don't create a table entry until the next code */
 246     if (NEXT() == -1)                       /* no compressed data is ok */
 247         return Z_OK;
 248     final = prev = (unsigned)last;          /* low 8 bits of code */
 249     if (NEXT() == -1)                       /* missing a bit */
 250         return Z_BUF_ERROR;
 251     if (last & 1) {                         /* code must be < 256 */
 252         strm->msg = (char *)"invalid lzw code";
 253         return Z_DATA_ERROR;
 254     }
 255     rem = (unsigned)last >> 1;              /* remaining 7 bits */
 256     left = 7;
 257     chunk = bits - 2;                       /* 7 bytes left in this chunk */
 258     outbuf[0] = (unsigned char)final;       /* write first decompressed byte */
 259     outcnt = 1;
 260
 261     /* decode codes */
 262     stack = 0;
 263     for (;;) {
 264         /* if the table will be full after this, increment the code size */
 265         if (end >= mask && bits < max) {
 266             FLUSHCODE();
 267             bits++;
 268             mask <<= 1;
 269             mask++;
 270         }
 271
 272         /* get a code of length bits */
 273         if (chunk == 0)                     /* decrement chunk modulo bits */
 274             chunk = bits;
 275         code = rem;                         /* low bits of code */
 276         if (NEXT() == -1) {                 /* EOF is end of compressed data */
 277             /* write remaining buffered output */
 278             if (outcnt && out(&outd, outbuf, outcnt)) {
 279                 strm->next_in = outbuf;     /* signal write error */
 280                 return Z_BUF_ERROR;
 281             }
 282             return Z_OK;
 283         }
 284         code += (unsigned)last << left;     /* middle (or high) bits of code */
 285         left += 8;
 286         chunk--;
 287         if (bits > left) {                  /* need more bits */
 288             if (NEXT() == -1)               /* can't end in middle of code */
 289                 return Z_BUF_ERROR;
 290             code += (unsigned)last << left; /* high bits of code */
 291             left += 8;
 292             chunk--;
 293         }
 294         code &= mask;                       /* mask to current code length */
 295         left -= bits;                       /* number of unused bits */
 296         rem = (unsigned)last >> (8 - left); /* unused bits from last byte */
 297
 298         /* process clear code (256) */
 299         if (code == 256 && flags) {
 300             FLUSHCODE();
 301             bits = 9;                       /* initialize bits and mask */
 302             mask = 0x1ff;
 303             end = 255;                      /* empty table */
 304             continue;                       /* get next code */
 305         }
 306
 307         /* special code to reuse last match */
 308         temp = code;                        /* save the current code */
 309         if (code > end) {
 310             /* Be picky on the allowed code here, and make sure that the code
 311                we drop through (prev) will be a valid index so that random
 312                input does not cause an exception.  The code != end + 1 check is
 313                empirically derived, and not checked in the original uncompress
 314                code.  If this ever causes a problem, that check could be safely
 315                removed.  Leaving this check in greatly improves gun's ability
 316                to detect random or corrupted input after a compress header.
 317                In any case, the prev > end check must be retained. */
 318             if (code != end + 1 || prev > end) {
 319                 strm->msg = (char *)"invalid lzw code";
 320                 return Z_DATA_ERROR;
 321             }
 322             match[stack++] = (unsigned char)final;
 323             code = prev;
 324         }
 325
 326         /* walk through linked list to generate output in reverse order */
 327         while (code >= 256) {
 328             match[stack++] = suffix[code];
 329             code = prefix[code];
 330         }
 331         match[stack++] = (unsigned char)code;
 332         final = code;
 333
 334         /* link new table entry */
 335         if (end < mask) {
 336             end++;
 337             prefix[end] = (unsigned short)prev;
 338             suffix[end] = (unsigned char)final;
 339         }
 340
 341         /* set previous code for next iteration */
 342         prev = temp;
 343
 344         /* write output in forward order */
 345         while (stack > SIZE - outcnt) {
 346             while (outcnt < SIZE)
 347                 outbuf[outcnt++] = match[--stack];
 348             if (out(&outd, outbuf, outcnt)) {
 349                 strm->next_in = outbuf; /* signal write error */
 350                 return Z_BUF_ERROR;
 351             }
 352             outcnt = 0;
 353         }
 354         do {
 355             outbuf[outcnt++] = match[--stack];
 356         } while (stack);
 357
 358         /* loop for next code with final and prev as the last match, rem and
 359            left provide the first 0..7 bits of the next code, end is the last
 360            valid table entry */
 361     }
 362 }
 363
 364 /* Decompress a gzip file from infile to outfile.  strm is assumed to have been
 365    successfully initialized with inflateBackInit().  The input file may consist
 366    of a series of gzip streams, in which case all of them will be decompressed
 367    to the output file.  If outfile is -1, then the gzip stream(s) integrity is
 368    checked and nothing is written.
 369
 370    The return value is a zlib error code: Z_MEM_ERROR if out of memory,
 371    Z_DATA_ERROR if the header or the compressed data is invalid, or if the
 372    trailer CRC-32 check or length doesn't match, Z_BUF_ERROR if the input ends
 373    prematurely or a write error occurs, or Z_ERRNO if junk (not a another gzip
 374    stream) follows a valid gzip stream.
 375  */
 376 local int gunpipe(z_stream *strm, int infile, int outfile)
 377 {
 378     int ret, first, last;
 379     unsigned have, flags, len;
 380     unsigned char *next;
 381     struct ind ind, *indp;
 382     struct outd outd;
 383
 384     /* setup input buffer */
 385     ind.infile = infile;
 386     ind.inbuf = inbuf;
 387     indp = &ind;
 388
 389     /* decompress concatenated gzip streams */
 390     have = 0;                               /* no input data read in yet */
 391     first = 1;                              /* looking for first gzip header */
 392     strm->next_in = Z_NULL;                 /* so Z_BUF_ERROR means EOF */
 393     for (;;) {
 394         /* look for the two magic header bytes for a gzip stream */
 395         if (NEXT() == -1) {
 396             ret = Z_OK;
 397             break;                          /* empty gzip stream is ok */
 398         }
 399         if (last != 31 || (NEXT() != 139 && last != 157)) {
 400             strm->msg = (char *)"incorrect header check";
 401             ret = first ? Z_DATA_ERROR : Z_ERRNO;
 402             break;                          /* not a gzip or compress header */
 403         }
 404         first = 0;                          /* next non-header is junk */
 405
 406         /* process a compress (LZW) file -- can't be concatenated after this */
 407         if (last == 157) {
 408             ret = lunpipe(have, next, indp, outfile, strm);
 409             break;
 410         }
 411
 412         /* process remainder of gzip header */
 413         ret = Z_BUF_ERROR;
 414         if (NEXT() != 8) {                  /* only deflate method allowed */
 415             if (last == -1) break;
 416             strm->msg = (char *)"unknown compression method";
 417             ret = Z_DATA_ERROR;
 418             break;
 419         }
 420         flags = NEXT();                     /* header flags */
 421         NEXT();                             /* discard mod time, xflgs, os */
 422         NEXT();
 423         NEXT();
 424         NEXT();
 425         NEXT();
 426         NEXT();
 427         if (last == -1) break;
 428         if (flags & 0xe0) {
 429             strm->msg = (char *)"unknown header flags set";
 430             ret = Z_DATA_ERROR;
 431             break;
 432         }
 433         if (flags & 4) {                    /* extra field */
 434             len = NEXT();
 435             len += (unsigned)(NEXT()) << 8;
 436             if (last == -1) break;
 437             while (len > have) {
 438                 len -= have;
 439                 have = 0;
 440                 if (NEXT() == -1) break;
 441                 len--;
 442             }
 443             if (last == -1) break;
 444             have -= len;
 445             next += len;
 446         }
 447         if (flags & 8)                      /* file name */
 448             while (NEXT() != 0 && last != -1)
 449                 ;
 450         if (flags & 16)                     /* comment */
 451             while (NEXT() != 0 && last != -1)
 452                 ;
 453         if (flags & 2) {                    /* header crc */
 454             NEXT();
 455             NEXT();
 456         }
 457         if (last == -1) break;
 458
 459         /* set up output */
 460         outd.outfile = outfile;
 461         outd.check = 1;
 462         outd.crc = crc32(0L, Z_NULL, 0);
 463         outd.total = 0;
 464
 465         /* decompress data to output */
 466         strm->next_in = next;
 467         strm->avail_in = have;
 468         ret = inflateBack(strm, in, indp, out, &outd);
 469         if (ret != Z_STREAM_END) break;
 470         next = strm->next_in;
 471         have = strm->avail_in;
 472         strm->next_in = Z_NULL;             /* so Z_BUF_ERROR means EOF */
 473
 474         /* check trailer */
 475         ret = Z_BUF_ERROR;
 476         if (NEXT() != (outd.crc & 0xff) ||
 477             NEXT() != ((outd.crc >> 8) & 0xff) ||
 478             NEXT() != ((outd.crc >> 16) & 0xff) ||
 479             NEXT() != ((outd.crc >> 24) & 0xff)) {
 480             /* crc error */
 481             if (last != -1) {
 482                 strm->msg = (char *)"incorrect data check";
 483                 ret = Z_DATA_ERROR;
 484             }
 485             break;
 486         }
 487         if (NEXT() != (outd.total & 0xff) ||
 488             NEXT() != ((outd.total >> 8) & 0xff) ||
 489             NEXT() != ((outd.total >> 16) & 0xff) ||
 490             NEXT() != ((outd.total >> 24) & 0xff)) {
 491             /* length error */
 492             if (last != -1) {
 493                 strm->msg = (char *)"incorrect length check";
 494                 ret = Z_DATA_ERROR;
 495             }
 496             break;
 497         }
 498
 499         /* go back and look for another gzip stream */
 500     }
 501
 502     /* clean up and return */
 503     return ret;
 504 }
 505
 506 /* Copy file attributes, from -> to, as best we can.  This is best effort, so
 507    no errors are reported.  The mode bits, including suid, sgid, and the sticky
 508    bit are copied (if allowed), the owner's user id and group id are copied
 509    (again if allowed), and the access and modify times are copied. */
 510 local void copymeta(char *from, char *to)
 511 {
 512     struct stat was;
 513     struct utimbuf when;
 514
 515     /* get all of from's Unix meta data, return if not a regular file */
 516     if (stat(from, &was) != 0 || (was.st_mode & S_IFMT) != S_IFREG)
 517         return;
 518
 519     /* set to's mode bits, ignore errors */
 520     (void)chmod(to, was.st_mode & 07777);
 521
 522     /* copy owner's user and group, ignore errors */
 523     (void)chown(to, was.st_uid, was.st_gid);
 524
 525     /* copy access and modify times, ignore errors */
 526     when.actime = was.st_atime;
 527     when.modtime = was.st_mtime;
 528     (void)utime(to, &when);
 529 }
 530
 531 /* Decompress the file inname to the file outnname, of if test is true, just
 532    decompress without writing and check the gzip trailer for integrity.  If
 533    inname is NULL or an empty string, read from stdin.  If outname is NULL or
 534    an empty string, write to stdout.  strm is a pre-initialized inflateBack
 535    structure.  When appropriate, copy the file attributes from inname to
 536    outname.
 537
 538    gunzip() returns 1 if there is an out-of-memory error or an unexpected
 539    return code from gunpipe().  Otherwise it returns 0.
 540  */
 541 local int gunzip(z_stream *strm, char *inname, char *outname, int test)
 542 {
 543     int ret;
 544     int infile, outfile;
 545
 546     /* open files */
 547     if (inname == NULL || *inname == 0) {
 548         inname = "-";
 549         infile = 0;     /* stdin */
 550     }
 551     else {
 552         infile = open(inname, O_RDONLY, 0);
 553         if (infile == -1) {
 554             fprintf(stderr, "gun cannot open %s\n", inname);
 555             return 0;
 556         }
 557     }
 558     if (test)
 559         outfile = -1;
 560     else if (outname == NULL || *outname == 0) {
 561         outname = "-";
 562         outfile = 1;    /* stdout */
 563     }
 564     else {
 565         outfile = open(outname, O_CREAT | O_TRUNC | O_WRONLY, 0666);
 566         if (outfile == -1) {
 567             close(infile);
 568             fprintf(stderr, "gun cannot create %s\n", outname);
 569             return 0;
 570         }
 571     }
 572     errno = 0;
 573
 574     /* decompress */
 575     ret = gunpipe(strm, infile, outfile);
 576     if (outfile > 2) close(outfile);
 577     if (infile > 2) close(infile);
 578
 579     /* interpret result */
 580     switch (ret) {
 581     case Z_OK:
 582     case Z_ERRNO:
 583         if (infile > 2 && outfile > 2) {
 584             copymeta(inname, outname);          /* copy attributes */
 585             unlink(inname);
 586         }
 587         if (ret == Z_ERRNO)
 588             fprintf(stderr, "gun warning: trailing garbage ignored in %s\n",
 589                     inname);
 590         break;
 591     case Z_DATA_ERROR:
 592         if (outfile > 2) unlink(outname);
 593         fprintf(stderr, "gun data error on %s: %s\n", inname, strm->msg);
 594         break;
 595     case Z_MEM_ERROR:
 596         if (outfile > 2) unlink(outname);
 597         fprintf(stderr, "gun out of memory error--aborting\n");
 598         return 1;
 599     case Z_BUF_ERROR:
 600         if (outfile > 2) unlink(outname);
 601         if (strm->next_in != Z_NULL) {
 602             fprintf(stderr, "gun write error on %s: %s\n",
 603                     outname, strerror(errno));
 604         }
 605         else if (errno) {
 606             fprintf(stderr, "gun read error on %s: %s\n",
 607                     inname, strerror(errno));
 608         }
 609         else {
 610             fprintf(stderr, "gun unexpected end of file on %s\n",
 611                     inname);
 612         }
 613         break;
 614     default:
 615         if (outfile > 2) unlink(outname);
 616         fprintf(stderr, "gun internal error--aborting\n");
 617         return 1;
 618     }
 619     return 0;
 620 }
 621
 622 /* Process the gun command line arguments.  See the command syntax near the
 623    beginning of this source file. */
 624 int main(int argc, char **argv)
 625 {
 626     int ret, len, test;
 627     char *outname;
 628     unsigned char *window;
 629     z_stream strm;
 630
 631     /* initialize inflateBack state for repeated use */
 632     window = match;                         /* reuse LZW match buffer */
 633     strm.zalloc = Z_NULL;
 634     strm.zfree = Z_NULL;
 635     strm.opaque = Z_NULL;
 636     ret = inflateBackInit(&strm, 15, window);
 637     if (ret != Z_OK) {
 638         fprintf(stderr, "gun out of memory error--aborting\n");
 639         return 1;
 640     }
 641
 642     /* decompress each file to the same name with the suffix removed */
 643     argc--;
 644     argv++;
 645     test = 0;
 646     if (argc && strcmp(*argv, "-h") == 0) {
 647         fprintf(stderr, "gun 1.3 (12 Jun 2005)\n");
 648         fprintf(stderr, "Copyright (c) 2005 Mark Adler\n");
 649         fprintf(stderr, "usage: gun [-t] [file1.gz [file2.Z ...]]\n");
 650         return 0;
 651     }
 652     if (argc && strcmp(*argv, "-t") == 0) {
 653         test = 1;
 654         argc--;
 655         argv++;
 656     }
 657     if (argc)
 658         do {
 659             if (test)
 660                 outname = NULL;
 661             else {
 662                 len = (int)strlen(*argv);
 663                 if (strcmp(*argv + len - 3, ".gz") == 0 ||
 664                     strcmp(*argv + len - 3, "-gz") == 0)
 665                     len -= 3;
 666                 else if (strcmp(*argv + len - 2, ".z") == 0 ||
 667                     strcmp(*argv + len - 2, "-z") == 0 ||
 668                     strcmp(*argv + len - 2, "_z") == 0 ||
 669                     strcmp(*argv + len - 2, ".Z") == 0)
 670                     len -= 2;
 671                 else {
 672                     fprintf(stderr, "gun error: no gz type on %s--skipping\n",
 673                             *argv);
 674                     continue;
 675                 }
 676                 outname = malloc(len + 1);
 677                 if (outname == NULL) {
 678                     fprintf(stderr, "gun out of memory error--aborting\n");
 679                     ret = 1;
 680                     break;
 681                 }
 682                 memcpy(outname, *argv, len);
 683                 outname[len] = 0;
 684             }
 685             ret = gunzip(&strm, *argv, outname, test);
 686             if (outname != NULL) free(outname);
 687             if (ret) break;
 688         } while (argv++, --argc);
 689     else
 690         ret = gunzip(&strm, NULL, NULL, test);
 691
 692     /* clean up */
 693     inflateBackEnd(&strm);
 694     return ret;
 695 }