Dependencies/zlib/examples/gun.c

   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 }