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