gzappend.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include "zlib.h"

Go to the source code of this file.

Classes
struct	file

Macros
#define	local   static
#define	LGCHUNK   14
#define	CHUNK   (1U << LGCHUNK)
#define	DSIZE   32768U
#define	read1(in)

Functions
void	bye (char *msg1, char *msg2)
unsigned	gcd (unsigned a, unsigned b)
void	rotate (unsigned char *list, unsigned len, unsigned rot)
int	readin (file *in)
int	readmore (file *in)
void	skip (file *in, unsigned n)
unsigned long	read4 (file *in)
void	gzheader (file *in)
int	gzscan (char *name, z_stream *strm, int level)
void	gztack (char *name, int gd, z_stream *strm, int last)
int	main (int argc, char **argv)

Macro Definition Documentation

CHUNK

#define CHUNK   (1U << LGCHUNK)

Definition at line 89 of file gzappend.c.

DSIZE

#define DSIZE   32768U

Definition at line 90 of file gzappend.c.

LGCHUNK

#define LGCHUNK   14

Definition at line 88 of file gzappend.c.

local

#define local   static

Definition at line 87 of file gzappend.c.

read1

#define read1

(

in

)

Value:

                   (in->left == 0 ? readmore(in) : 0, \
                   in->left--, *(in->next)++)

Definition at line 198 of file gzappend.c.

Function Documentation

bye()

void bye	(	char *	msg1,
		char *	msg2
	)

Definition at line 93 of file gzappend.c.

{
    fprintf(stderr, "gzappend error: %s%s\n", msg1, msg2);
    exit(1);
}

References test-lz4-list::exit.

Referenced by gzheader(), gzscan(), gztack(), main(), readin(), readmore(), sh_assembler(), and skip().

gcd()

unsigned gcd	(	unsigned	a,
		unsigned	b
	)

Definition at line 102 of file gzappend.c.

{
    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;
}

References a, b, and c.

Referenced by rotate().

gzheader()

void gzheader

(

file *

in

)

Definition at line 235 of file gzappend.c.

{
    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);
}

References bye(), flags, in, n, read1, skip(), and unsigned.

Referenced by gzscan().

gzscan()

int gzscan	(	char *	name,
		z_stream *	strm,
		int	level
	)

Definition at line 259 of file gzappend.c.

{
    int ret, lastbit, left, full;
    unsigned have;
    unsigned long crc, tot;
    unsigned char *window;
    off_t lastoff, end;
    file gz;
 
    /* open gzip file */
    gz.name = name;
    gz.fd = open(name, O_RDWR, 0);
    if (gz.fd == -1) bye("cannot open ", name);
    gz.buf = malloc(CHUNK);
    if (gz.buf == NULL) bye("out of memory", "");
    gz.size = LGCHUNK;
    gz.left = 0;
 
    /* skip gzip header */
    gzheader(&gz);
 
    /* prepare to decompress */
    window = malloc(DSIZE);
    if (window == NULL) bye("out of memory", "");
    strm->zalloc = Z_NULL;
    strm->zfree = Z_NULL;
    strm->opaque = Z_NULL;
    ret = inflateInit2(strm, -15);
    if (ret != Z_OK) bye("out of memory", " or library mismatch");
 
    /* decompress the deflate stream, saving append information */
    lastbit = 0;
    lastoff = lseek(gz.fd, 0L, SEEK_CUR) - gz.left;
    left = 0;
    strm->avail_in = gz.left;
    strm->next_in = gz.next;
    crc = crc32(0L, Z_NULL, 0);
    have = full = 0;
    do {
        /* if needed, get more input */
        if (strm->avail_in == 0) {
            readmore(&gz);
            strm->avail_in = gz.left;
            strm->next_in = gz.next;
        }
 
        /* set up output to next available section of sliding window */
        strm->avail_out = DSIZE - have;
        strm->next_out = window + have;
 
        /* inflate and check for errors */
        ret = inflate(strm, Z_BLOCK);
        if (ret == Z_STREAM_ERROR) bye("internal stream error!", "");
        if (ret == Z_MEM_ERROR) bye("out of memory", "");
        if (ret == Z_DATA_ERROR)
            bye("invalid compressed data--format violated in", name);
 
        /* update crc and sliding window pointer */
        crc = crc32(crc, window + have, DSIZE - have - strm->avail_out);
        if (strm->avail_out)
            have = DSIZE - strm->avail_out;
        else {
            have = 0;
            full = 1;
        }
 
        /* process end of block */
        if (strm->data_type & 128) {
            if (strm->data_type & 64)
                left = strm->data_type & 0x1f;
            else {
                lastbit = strm->data_type & 0x1f;
                lastoff = lseek(gz.fd, 0L, SEEK_CUR) - strm->avail_in;
            }
        }
    } while (ret != Z_STREAM_END);
    inflateEnd(strm);
    gz.left = strm->avail_in;
    gz.next = strm->next_in;
 
    /* save the location of the end of the compressed data */
    end = lseek(gz.fd, 0L, SEEK_CUR) - gz.left;
 
    /* check gzip trailer and save total for deflate */
    if (crc != read4(&gz))
        bye("invalid compressed data--crc mismatch in ", name);
    tot = strm->total_out;
    if ((tot & 0xffffffffUL) != read4(&gz))
        bye("invalid compressed data--length mismatch in", name);
 
    /* if not at end of file, warn */
    if (gz.left || readin(&gz))
        fprintf(stderr,
            "gzappend warning: junk at end of gzip file overwritten\n");
 
    /* clear last block bit */
    lseek(gz.fd, lastoff - (lastbit != 0), SEEK_SET);
    if (read(gz.fd, gz.buf, 1) != 1) bye("reading after seek on ", name);
    *gz.buf = (unsigned char)(*gz.buf ^ (1 << ((8 - lastbit) & 7)));
    lseek(gz.fd, -1L, SEEK_CUR);
    if (write(gz.fd, gz.buf, 1) != 1) bye("writing after seek to ", name);
 
    /* if window wrapped, build dictionary from window by rotating */
    if (full) {
        rotate(window, DSIZE, have);
        have = DSIZE;
    }
 
    /* set up deflate stream with window, crc, total_in, and leftover bits */
    ret = deflateInit2(strm, level, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
    if (ret != Z_OK) bye("out of memory", "");
    deflateSetDictionary(strm, window, have);
    strm->adler = crc;
    strm->total_in = tot;
    if (left) {
        lseek(gz.fd, --end, SEEK_SET);
        if (read(gz.fd, gz.buf, 1) != 1) bye("reading after seek on ", name);
        deflatePrime(strm, 8 - left, *gz.buf);
    }
    lseek(gz.fd, end, SEEK_SET);
 
    /* clean up and return */
    free(window);
    free(gz.buf);
    return gz.fd;
}

References lzma_stream::avail_in, lzma_stream::avail_out, file::buf, bye(), CHUNK, crc32(), deflateInit2, deflatePrime(), deflateSetDictionary(), DSIZE, test_evm::end, file::fd, free(), gzheader(), inflate(), inflateEnd(), inflateInit2, L, file::left, level, LGCHUNK, lseek, malloc(), name, file::name, file::next, lzma_stream::next_in, lzma_stream::next_out, NULL, O_RDWR, read(), read4(), readin(), readmore(), rotate(), SEEK_CUR, SEEK_SET, file::size, strm, tot, lzma_stream::total_in, lzma_stream::total_out, write, Z_BLOCK, Z_DATA_ERROR, Z_DEFAULT_STRATEGY, Z_DEFLATED, Z_MEM_ERROR, Z_NULL, Z_OK, Z_STREAM_END, and Z_STREAM_ERROR.

Referenced by main().

gztack()

void gztack	(	char *	name,
		int	gd,
		z_stream *	strm,
		int	last
	)

Definition at line 388 of file gzappend.c.

{
    int fd, len, ret;
    unsigned left;
    unsigned char *in, *out;
 
    /* open file to compress and append */
    fd = 0;
    if (name != NULL) {
        fd = open(name, O_RDONLY, 0);
        if (fd == -1)
            fprintf(stderr, "gzappend warning: %s not found, skipping ...\n",
                    name);
    }
 
    /* allocate buffers */
    in = malloc(CHUNK);
    out = malloc(CHUNK);
    if (in == NULL || out == NULL) bye("out of memory", "");
 
    /* compress input file and append to gzip file */
    do {
        /* get more input */
        len = read(fd, in, CHUNK);
        if (len == -1) {
            fprintf(stderr,
                    "gzappend warning: error reading %s, skipping rest ...\n",
                    name);
            len = 0;
        }
        strm->avail_in = (unsigned)len;
        strm->next_in = in;
        if (len) strm->adler = crc32(strm->adler, in, (unsigned)len);
 
        /* compress and write all available output */
        do {
            strm->avail_out = CHUNK;
            strm->next_out = out;
            ret = deflate(strm, last && len == 0 ? Z_FINISH : Z_NO_FLUSH);
            left = CHUNK - strm->avail_out;
            while (left) {
                len = write(gd, out + CHUNK - strm->avail_out - left, left);
                if (len == -1) bye("writing gzip file", "");
                left -= (unsigned)len;
            }
        } while (strm->avail_out == 0 && ret != Z_STREAM_END);
    } while (len != 0);
 
    /* write trailer after last entry */
    if (last) {
        deflateEnd(strm);
        out[0] = (unsigned char)(strm->adler);
        out[1] = (unsigned char)(strm->adler >> 8);
        out[2] = (unsigned char)(strm->adler >> 16);
        out[3] = (unsigned char)(strm->adler >> 24);
        out[4] = (unsigned char)(strm->total_in);
        out[5] = (unsigned char)(strm->total_in >> 8);
        out[6] = (unsigned char)(strm->total_in >> 16);
        out[7] = (unsigned char)(strm->total_in >> 24);
        len = 8;
        do {
            ret = write(gd, out + 8 - len, len);
            if (ret == -1) bye("writing gzip file", "");
            len -= ret;
        } while (len);
        close(gd);
    }
 
    /* clean up and return */
    free(out);
    free(in);
    if (fd > 0) close(fd);
}

References lzma_stream::avail_in, lzma_stream::avail_out, bye(), CHUNK, close, crc32(), deflate(), deflateEnd(), fd, free(), in, len, malloc(), lzma_stream::next_in, lzma_stream::next_out, NULL, O_RDONLY, out, read(), strm, lzma_stream::total_in, unsigned, write, Z_FINISH, Z_NO_FLUSH, and Z_STREAM_END.

Referenced by main().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 466 of file gzappend.c.

{
    int gd, level;
    z_stream strm;
 
    /* ignore command name */
    argc--; argv++;
 
    /* provide usage if no arguments */
    if (*argv == NULL) {
        printf(
            "gzappend 1.2 (11 Oct 2012) Copyright (C) 2003, 2012 Mark Adler\n"
               );
        printf(
            "usage: gzappend [-level] file.gz [ addthis [ andthis ... ]]\n");
        return 0;
    }
 
    /* set compression level */
    level = Z_DEFAULT_COMPRESSION;
    if (argv[0][0] == '-') {
        if (argv[0][1] < '0' || argv[0][1] > '9' || argv[0][2] != 0)
            bye("invalid compression level", "");
        level = argv[0][1] - '0';
        if (*++argv == NULL) bye("no gzip file name after options", "");
    }
 
    /* prepare to append to gzip file */
    gd = gzscan(*argv++, &strm, level);
 
    /* append files on command line, or from stdin if none */
    if (*argv == NULL)
        gztack(NULL, gd, &strm, 1);
    else
        do {
            gztack(*argv, gd, &strm, argv[1] == NULL);
        } while (*++argv != NULL);
    return 0;
}

References argv, bye(), gzscan(), gztack(), level, NULL, printf(), strm, and Z_DEFAULT_COMPRESSION.

read4()

unsigned long read4

(

file *

in

)

Definition at line 223 of file gzappend.c.

{
    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;
}

References in, long, read1, unsigned, and val.

Referenced by gzscan().

readin()

int readin

(

file *

in

)

Definition at line 180 of file gzappend.c.

{
    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;
}

References bye(), in, len, read(), and unsigned.

Referenced by gzscan(), and readmore().

readmore()

int readmore

(

file *

in

)

Definition at line 192 of file gzappend.c.

{
    if (readin(in) == 0) bye("unexpected end of ", in->name);
    return 0;
}

References bye(), in, and readin().

Referenced by gzscan(), and skip().

rotate()

void rotate	(	unsigned char *	list,
		unsigned	len,
		unsigned	rot
	)

Definition at line 123 of file gzappend.c.

{
    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;
        memmove(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);
}

References from, gcd(), len, list(), start, autogen_x86imm::tmp, and to.

Referenced by getimmed8(), gzscan(), and LZ4HC_rotatePattern().

skip()

void skip	(	file *	in,
		unsigned	n
	)

Definition at line 202 of file gzappend.c.

{
    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;
}

References bye(), in, lseek, n, readmore(), and SEEK_CUR.

Referenced by bskip(), deflate_index_extract(), demangle_classname(), do_extract_currentfile(), findMinMax(), get_relocs(), gzheader(), main(), parse_gdata_stream(), print_debug_maps_ascii_art(), reconstruct_chained_fixup(), rz_analysis_reflines_get(), rz_asm_pseudo_incbin(), rz_core_visual(), rz_core_visual_xrefs(), rz_main_rz_asm(), rz_print_bitstream_handler(), rz_str_widget_list(), show_analysis_classes(), show_class(), ts_lexer__advance(), ts_lexer__do_advance(), and uv_tty_init().