/* gzappend -- command to append to a gzip file  Copyright (C) 2003 Mark Adler, all rights reserved  version 1.1, 4 Nov 2003  This software is provided 'as-is', without any express or implied  warranty.  In no event will the author be held liable for any damages  arising from the use of this software.  Permission is granted to anyone to use this software for any purpose,  including commercial applications, and to alter it and redistribute it  freely, subject to the following restrictions:  1. The origin of this software must not be misrepresented; you must not     claim that you wrote the original software. If you use this software     in a product, an acknowledgment in the product documentation would be     appreciated but is not required.  2. Altered source versions must be plainly marked as such, and must not be     misrepresented as being the original software.  3. This notice may not be removed or altered from any source distribution.  Mark Adler    madler@alumni.caltech.edu *//* * Change history: * * 1.0  19 Oct 2003     - First version * 1.1   4 Nov 2003     - Expand and clarify some comments and notes *                      - Add version and copyright to help *                      - Send help to stdout instead of stderr *                      - Add some preemptive typecasts *                      - Add L to constants in lseek() calls *                      - Remove some debugging information in error messages *                      - Use new data_type definition for zlib 1.2.1 *                      - Simplfy and unify file operations *                      - Finish off gzip file in gztack() *                      - Use deflatePrime() instead of adding empty blocks *                      - Keep gzip file clean on appended file read errors *                      - Use in-place rotate instead of auxiliary buffer *                        (Why you ask?  Because it was fun to write!) *//*   gzappend takes a gzip file and appends to it, compressing files from the   command line or data from stdin.  The gzip file is written to directly, to   avoid copying that file, in case it's large.  Note that this results in the   unfriendly behavior that if gzappend fails, the gzip file is corrupted.   This program was written to illustrate the use of the new Z_BLOCK option of   zlib 1.2.x's inflate() function.  This option returns from inflate() at each   block boundary to facilitate locating and modifying the last block bit at   the start of the final deflate block.  Also whether using Z_BLOCK or not,   another required feature of zlib 1.2.x is that inflate() now provides the   number of unusued bits in the last input byte used.  gzappend will not work   with versions of zlib earlier than 1.2.1.   gzappend first decompresses the gzip file internally, discarding all but   the last 32K of uncompressed data, and noting the location of the last block   bit and the number of unused bits in the last byte of the compressed data.   The gzip trailer containing the CRC-32 and length of the uncompressed data   is verified.  This trailer will be later overwritten.   Then the last block bit is cleared by seeking back in the file and rewriting   the byte that contains it.  Seeking forward, the last byte of the compressed   data is saved along with the number of unused bits to initialize deflate.   A deflate process is initialized, using the last 32K of the uncompressed   data from the gzip file to initialize the dictionary.  If the total   uncompressed data was less than 32K, then all of it is used to initialize   the dictionary.  The deflate output bit buffer is also initialized with the   last bits from the original deflate stream.  From here on, the data to   append is simply compressed using deflate, and written to the gzip file.   When that is complete, the new CRC-32 and uncompressed length are written   as the trailer of the gzip file. */#include <stdio.h>#include <stdlib.h>#include <string.h>#include <fcntl.h>#include <unistd.h>#include "zlib.h"#define local static#define LGCHUNK 14#define CHUNK (1U << LGCHUNK)#define DSIZE 32768U/* print an error message and terminate with extreme prejudice */local void bye(char *msg1, char *msg2){    fprintf(stderr, "gzappend error: %s%s\n", msg1, msg2);    exit(1);}/* return the greatest common divisor of a and b using Euclid's algorithm,   modified to be fast when one argument much greater than the other, and   coded to avoid unnecessary swapping */local unsigned gcd(unsigned a, unsigned b){    unsigned c;    while (a && b)        if (a > b) {            c = b;            while (a - c >= c)                c <<= 1;            a -= c;        }        else {            c = a;            while (b - c >= c)                c <<= 1;            b -= c;        }    return a + b;}/* rotate list[0..len-1] left by rot positions, in place */local void rotate(unsigned char *list, unsigned len, unsigned rot){    unsigned char tmp;    unsigned cycles;    unsigned char *start, *last, *to, *from;    /* normalize rot and handle degenerate cases */    if (len < 2) return;    if (rot >= len) rot %= len;    if (rot == 0) return;    /* pointer to last entry in list */    last = list + (len - 1);    /* do simple left shift by one */    if (rot == 1) {        tmp = *list;        memcpy(list, list + 1, len - 1);        *last = tmp;        return;    }    /* do simple right shift by one */    if (rot == len - 1) {        tmp = *last;        memmove(list + 1, list, len - 1);        *list = tmp;        return;    }    /* otherwise do rotate as a set of cycles in place */    cycles = gcd(len, rot);             /* number of cycles */    do {        start = from = list + cycles;   /* start index is arbitrary */        tmp = *from;                    /* save entry to be overwritten */        for (;;) {            to = from;                  /* next step in cycle */            from += rot;                /* go right rot positions */            if (from > last) from -= len;   /* (pointer better not wrap) */            if (from == start) break;   /* all but one shifted */            *to = *from;                /* shift left */        }        *to = tmp;                      /* complete the circle */    } while (--cycles);}/* structure for gzip file read operations */typedef struct {    int fd;                     /* file descriptor */    int size;                   /* 1 << size is bytes in buf */    unsigned left;              /* bytes available at next */    unsigned char *buf;         /* buffer */    unsigned char *next;        /* next byte in buffer */    char *name;                 /* file name for error messages */} file;/* reload buffer */local int readin(file *in){    int len;    len = read(in->fd, in->buf, 1 << in->size);    if (len == -1) bye("error reading ", in->name);    in->left = (unsigned)len;    in->next = in->buf;    return len;}/* read from file in, exit if end-of-file */local int readmore(file *in){    if (readin(in) == 0) bye("unexpected end of ", in->name);    return 0;}#define read1(in) (in->left == 0 ? readmore(in) : 0, \                   in->left--, *(in->next)++)/* skip over n bytes of in */local void skip(file *in, unsigned n){    unsigned bypass;    if (n > in->left) {        n -= in->left;        bypass = n & ~((1U << in->size) - 1);        if (bypass) {            if (lseek(in->fd, (off_t)bypass, SEEK_CUR) == -1)                bye("seeking ", in->name);            n -= bypass;        }        readmore(in);        if (n > in->left)            bye("unexpected end of ", in->name);    }    in->left -= n;    in->next += n;}/* read a four-byte unsigned integer, little-endian, from in */unsigned long read4(file *in){    unsigned long val;    val = read1(in);    val += (unsigned)read1(in) << 8;    val += (unsigned long)read1(in) << 16;    val += (unsigned long)read1(in) << 24;    return val;}/* skip over gzip header */local void gzheader(file *in){    int flags;    unsigned n;    if (read1(in) != 31 || read1(in) != 139) bye(in->name, " not a gzip file");    if (read1(in) != 8) bye("unknown compression method in", in->name);    flags = read1(in);    if (flags & 0xe0) bye("unknown header flags set in", in->name);    skip(in, 6);    if (flags & 4) {        n = read1(in);        n += (unsigned)(read1(in)) << 8;        skip(in, n);    }    if (flags & 8) while (read1(in) != 0) ;    if (flags & 16) while (read1(in) != 0) ;    if (flags & 2) skip(in, 2);}