gzjoin.c File Reference

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

Go to the source code of this file.

Classes
struct	bin

Macros
#define	local   static
#define	CHUNK   32768 /* must be a power of two and fit in unsigned */
#define	bget(in)

Functions
int	bail (char *why1, char *why2)
void	bclose (bin *in)
bin *	bopen (char *name)
int	bload (bin *in)
unsigned long	bget4 (bin *in)
void	bskip (bin *in, unsigned skip)
void	gzhead (bin *in)
void	put4 (unsigned long val, FILE *out)
void	zpull (z_streamp strm, bin *in)
void	gzinit (unsigned long *crc, unsigned long *tot, FILE *out)
void	gzcopy (char *name, int clr, unsigned long *crc, unsigned long *tot, FILE *out)
int	main (int argc, char **argv)

Macro Definition Documentation

bget

#define bget

(

in

)

Value:

                  (in->left ? 0 : bload(in), \
                  in->left ? (in->left--, *(in->next)++) : \
                    bail("unexpected end of file on ", in->name))

Definition at line 140 of file gzjoin.c.

CHUNK

#define CHUNK   32768 /* must be a power of two and fit in unsigned */

Definition at line 75 of file gzjoin.c.

local

#define local   static

Definition at line 63 of file gzjoin.c.

Function Documentation

bail()

int bail	(	char *	why1,
		char *	why2
	)

Definition at line 66 of file gzjoin.c.

{
    fprintf(stderr, "gzjoin error: %s%s, output incomplete\n", why1, why2);
    exit(1);
    return 0;
}

References test-lz4-list::exit.

Referenced by bskip(), gzcopy(), gzhead(), and zpull().

bclose()

void bclose

(

bin *

in

)

Definition at line 87 of file gzjoin.c.

{
    if (in != NULL) {
        if (in->fd != -1)
            close(in->fd);
        if (in->buf != NULL)
            free(in->buf);
        free(in);
    }
}

References close, free(), in, and NULL.

Referenced by bopen(), and gzcopy().

bget4()

unsigned long bget4

(

bin *

in

)

Definition at line 145 of file gzjoin.c.

{
    unsigned long val;
 
    val = bget(in);
    val += (unsigned long)(bget(in)) << 8;
    val += (unsigned long)(bget(in)) << 16;
    val += (unsigned long)(bget(in)) << 24;
    return val;
}

References bget, in, long, and val.

Referenced by gzcopy().

bload()

int bload

(

bin *

in

)

Definition at line 121 of file gzjoin.c.

{
    long len;
 
    if (in == NULL)
        return -1;
    if (in->left != 0)
        return 0;
    in->next = in->buf;
    do {
        len = (long)read(in->fd, in->buf + in->left, CHUNK - in->left);
        if (len < 0)
            return -1;
        in->left += (unsigned)len;
    } while (len != 0 && in->left < CHUNK);
    return len == 0 ? 1 : 0;
}

References CHUNK, in, len, long, NULL, read(), and unsigned.

Referenced by bskip(), and zpull().

bopen()

bin* bopen

(

char *

name

)

Definition at line 100 of file gzjoin.c.

{
    bin *in;
 
    in = malloc(sizeof(bin));
    if (in == NULL)
        return NULL;
    in->buf = malloc(CHUNK);
    in->fd = open(name, O_RDONLY, 0);
    if (in->buf == NULL || in->fd == -1) {
        bclose(in);
        return NULL;
    }
    in->left = 0;
    in->next = in->buf;
    in->name = name;
    return in;
}

References bclose(), CHUNK, in, malloc(), name, NULL, and O_RDONLY.

Referenced by gzcopy().

bskip()

void bskip	(	bin *	in,
		unsigned	skip
	)

Definition at line 157 of file gzjoin.c.

{
    /* check pointer */
    if (in == NULL)
        return;
 
    /* easy case -- skip bytes in buffer */
    if (skip <= in->left) {
        in->left -= skip;
        in->next += skip;
        return;
    }
 
    /* skip what's in buffer, discard buffer contents */
    skip -= in->left;
    in->left = 0;
 
    /* seek past multiples of CHUNK bytes */
    if (skip > CHUNK) {
        unsigned left;
 
        left = skip & (CHUNK - 1);
        if (left == 0) {
            /* exact number of chunks: seek all the way minus one byte to check
               for end-of-file with a read */
            lseek(in->fd, skip - 1, SEEK_CUR);
            if (read(in->fd, in->buf, 1) != 1)
                bail("unexpected end of file on ", in->name);
            return;
        }
 
        /* skip the integral chunks, update skip with remainder */
        lseek(in->fd, skip - left, SEEK_CUR);
        skip = left;
    }
 
    /* read more input and skip remainder */
    bload(in);
    if (skip > in->left)
        bail("unexpected end of file on ", in->name);
    in->left -= skip;
    in->next += skip;
}

References bail(), bload(), CHUNK, in, lseek, NULL, read(), SEEK_CUR, and skip().

Referenced by gzhead().

gzcopy()

void gzcopy	(	char *	name,
		int	clr,
		unsigned long *	crc,
		unsigned long *	tot,
		FILE *	out
	)

Definition at line 279 of file gzjoin.c.

{
    int ret;                /* return value from zlib functions */
    int pos;                /* where the "last block" bit is in byte */
    int last;               /* true if processing the last block */
    bin *in;                /* buffered input file */
    unsigned char *start;   /* start of compressed data in buffer */
    unsigned char *junk;    /* buffer for uncompressed data -- discarded */
    z_off_t len;            /* length of uncompressed data (support > 4 GB) */
    z_stream strm;          /* zlib inflate stream */
 
    /* open gzip file and skip header */
    in = bopen(name);
    if (in == NULL)
        bail("could not open ", name);
    gzhead(in);
 
    /* allocate buffer for uncompressed data and initialize raw inflate
       stream */
    junk = malloc(CHUNK);
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    ret = inflateInit2(&strm, -15);
    if (junk == NULL || ret != Z_OK)
        bail("out of memory", "");
 
    /* inflate and copy compressed data, clear last-block bit if requested */
    len = 0;
    zpull(&strm, in);
    start = in->next;
    last = start[0] & 1;
    if (last && clr)
        start[0] &= ~1;
    strm.avail_out = 0;
    for (;;) {
        /* if input used and output done, write used input and get more */
        if (strm.avail_in == 0 && strm.avail_out != 0) {
            fwrite(start, 1, strm.next_in - start, out);
            start = in->buf;
            in->left = 0;
            zpull(&strm, in);
        }
 
        /* decompress -- return early when end-of-block reached */
        strm.avail_out = CHUNK;
        strm.next_out = junk;
        ret = inflate(&strm, Z_BLOCK);
        switch (ret) {
        case Z_MEM_ERROR:
            bail("out of memory", "");
        case Z_DATA_ERROR:
            bail("invalid compressed data in ", in->name);
        }
 
        /* update length of uncompressed data */
        len += CHUNK - strm.avail_out;
 
        /* check for block boundary (only get this when block copied out) */
        if (strm.data_type & 128) {
            /* if that was the last block, then done */
            if (last)
                break;
 
            /* number of unused bits in last byte */
            pos = strm.data_type & 7;
 
            /* find the next last-block bit */
            if (pos != 0) {
                /* next last-block bit is in last used byte */
                pos = 0x100 >> pos;
                last = strm.next_in[-1] & pos;
                if (last && clr)
                    in->buf[strm.next_in - in->buf - 1] &= ~pos;
            }
            else {
                /* next last-block bit is in next unused byte */
                if (strm.avail_in == 0) {
                    /* don't have that byte yet -- get it */
                    fwrite(start, 1, strm.next_in - start, out);
                    start = in->buf;
                    in->left = 0;
                    zpull(&strm, in);
                }
                last = strm.next_in[0] & 1;
                if (last && clr)
                    in->buf[strm.next_in - in->buf] &= ~1;
            }
        }
    }
 
    /* update buffer with unused input */
    in->left = strm.avail_in;
    in->next = in->buf + (strm.next_in - in->buf);
 
    /* copy used input, write empty blocks to get to byte boundary */
    pos = strm.data_type & 7;
    fwrite(start, 1, in->next - start - 1, out);
    last = in->next[-1];
    if (pos == 0 || !clr)
        /* already at byte boundary, or last file: write last byte */
        putc(last, out);
    else {
        /* append empty blocks to last byte */
        last &= ((0x100 >> pos) - 1);       /* assure unused bits are zero */
        if (pos & 1) {
            /* odd -- append an empty stored block */
            putc(last, out);
            if (pos == 1)
                putc(0, out);               /* two more bits in block header */
            fwrite("\0\0\xff\xff", 1, 4, out);
        }
        else {
            /* even -- append 1, 2, or 3 empty fixed blocks */
            switch (pos) {
            case 6:
                putc(last | 8, out);
                last = 0;
            case 4:
                putc(last | 0x20, out);
                last = 0;
            case 2:
                putc(last | 0x80, out);
                putc(0, out);
            }
        }
    }
 
    /* update crc and tot */
    *crc = crc32_combine(*crc, bget4(in), len);
    *tot += (unsigned long)len;
 
    /* clean up */
    inflateEnd(&strm);
    free(junk);
    bclose(in);
 
    /* write trailer if this is the last gzip file */
    if (!clr) {
        put4(*crc, out);
        put4(*tot, out);
    }
}

References lzma_stream::avail_in, lzma_stream::avail_out, bail(), bclose(), bget4(), bopen(), CHUNK, crc32_combine(), free(), gzhead(), in, inflate(), inflateEnd(), inflateInit2, len, long, malloc(), lzma_stream::next_in, lzma_stream::next_out, NULL, out, pos, put4(), start, strm, tot, Z_BLOCK, Z_DATA_ERROR, Z_MEM_ERROR, Z_NULL, z_off_t, Z_OK, and zpull().

Referenced by main().

gzhead()

void gzhead

(

bin *

in

)

Definition at line 204 of file gzjoin.c.

{
    int flags;
 
    /* verify gzip magic header and compression method */
    if (bget(in) != 0x1f || bget(in) != 0x8b || bget(in) != 8)
        bail(in->name, " is not a valid gzip file");
 
    /* get and verify flags */
    flags = bget(in);
    if ((flags & 0xe0) != 0)
        bail("unknown reserved bits set in ", in->name);
 
    /* skip modification time, extra flags, and os */
    bskip(in, 6);
 
    /* skip extra field if present */
    if (flags & 4) {
        unsigned len;
 
        len = bget(in);
        len += (unsigned)(bget(in)) << 8;
        bskip(in, len);
    }
 
    /* skip file name if present */
    if (flags & 8)
        while (bget(in) != 0)
            ;
 
    /* skip comment if present */
    if (flags & 16)
        while (bget(in) != 0)
            ;
 
    /* skip header crc if present */
    if (flags & 2)
        bskip(in, 2);
}

References bail(), bget, bskip(), flags, in, len, and unsigned.

Referenced by gzcopy().

gzinit()

void gzinit	(	unsigned long *	crc,
		unsigned long *	tot,
		FILE *	out
	)

Definition at line 265 of file gzjoin.c.

{
    fwrite("\x1f\x8b\x08\0\0\0\0\0\0\xff", 1, 10, out);
    *crc = crc32(0L, Z_NULL, 0);
    *tot = 0;
}

References crc32(), L, out, tot, and Z_NULL.

Referenced by main().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 427 of file gzjoin.c.

{
    unsigned long crc, tot;     /* running crc and total uncompressed length */
 
    /* skip command name */
    argc--;
    argv++;
 
    /* show usage if no arguments */
    if (argc == 0) {
        fputs("gzjoin usage: gzjoin f1.gz [f2.gz [f3.gz ...]] > fjoin.gz\n",
              stderr);
        return 0;
    }
 
    /* join gzip files on command line and write to stdout */
    gzinit(&crc, &tot, stdout);
    while (argc--)
        gzcopy(*argv++, argc, &crc, &tot, stdout);
 
    /* done */
    return 0;
}

References argv, gzcopy(), gzinit(), and tot.

put4()

void put4	(	unsigned long	val,
		FILE *	out
	)

Definition at line 245 of file gzjoin.c.

{
    putc(val & 0xff, out);
    putc((val >> 8) & 0xff, out);
    putc((val >> 16) & 0xff, out);
    putc((val >> 24) & 0xff, out);
}

References out, and val.

Referenced by gzcopy().

zpull()

void zpull	(	z_streamp	strm,
		bin *	in
	)

Definition at line 254 of file gzjoin.c.

{
    if (in->left == 0)
        bload(in);
    if (in->left == 0)
        bail("unexpected end of file on ", in->name);
    strm->avail_in = in->left;
    strm->next_in = in->next;
}

References lzma_stream::avail_in, bail(), bload(), in, lzma_stream::next_in, and strm.

Referenced by gzcopy().