gun.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <utime.h>
#include "zlib.h"

Go to the source code of this file.

Classes
struct	ind
struct	outd

Macros
#define	local   static
#define	SIZE   32768U /* input and output buffer sizes */
#define	PIECE   16384 /* limits i/o chunks for 16-bit int case */
#define	NEXT()
#define	FLUSHCODE()

Functions
unsigned	in (void *in_desc, z_const unsigned char **buf)
int	out (void *out_desc, unsigned char *buf, unsigned len)
int	lunpipe (unsigned have, z_const unsigned char *next, struct ind *indp, int outfile, z_stream *strm)
int	gunpipe (z_stream *strm, int infile, int outfile)
void	copymeta (char *from, char *to)
int	gunzip (z_stream *strm, char *inname, char *outname, int test)
int	main (int argc, char **argv)

Variables
unsigned char	inbuf [SIZE]
unsigned char	outbuf [SIZE]
unsigned short	prefix [65536]
unsigned char	suffix [65536]
unsigned char	match [65280+2]

Macro Definition Documentation

FLUSHCODE

#define FLUSHCODE

(

)

Value:

    do { \
        left = 0; \
        rem = 0; \
        if (chunk > have) { \
            chunk -= have; \
            have = 0; \
            if (NEXT() == -1) \
                break; \
            chunk--; \
            if (chunk > have) { \
                chunk = have = 0; \
                break; \
            } \
        } \
        have -= chunk; \
        next += chunk; \
        chunk = 0; \
    } while (0)

Definition at line 171 of file gun.c.

local

#define local   static

Definition at line 73 of file gun.c.

NEXT

#define NEXT

(

)

Value:

                (have ? 0 : (have = in(indp, &next)), \
                last = have ? (have--, (int)(*next++)) : -1)

Definition at line 155 of file gun.c.

PIECE

#define PIECE   16384 /* limits i/o chunks for 16-bit int case */

Definition at line 77 of file gun.c.

SIZE

#define SIZE   32768U /* input and output buffer sizes */

Definition at line 76 of file gun.c.

Function Documentation

copymeta()

void copymeta	(	char *	from,
		char *	to
	)

Definition at line 517 of file gun.c.

{
    struct stat was;
    struct utimbuf when;
 
    /* get all of from's Unix meta data, return if not a regular file */
    if (stat(from, &was) != 0 || (was.st_mode & S_IFMT) != S_IFREG)
        return;
 
    /* set to's mode bits, ignore errors */
    (void)chmod(to, was.st_mode & 07777);
 
    /* copy owner's user and group, ignore errors */
    (void)chown(to, was.st_uid, was.st_gid);
 
    /* copy access and modify times, ignore errors */
    when.actime = was.st_atime;
    when.modtime = was.st_mtime;
    (void)utime(to, &when);
}

References chmod, chown, from, stat, to, and utime.

Referenced by gunzip().

gunpipe()

int gunpipe	(	z_stream *	strm,
		int	infile,
		int	outfile
	)

Definition at line 383 of file gun.c.

{
    int ret, first, last;
    unsigned have, flags, len;
    z_const unsigned char *next = NULL;
    struct ind ind, *indp;
    struct outd outd;
 
    /* setup input buffer */
    ind.infile = infile;
    ind.inbuf = inbuf;
    indp = &ind;
 
    /* decompress concatenated gzip streams */
    have = 0;                               /* no input data read in yet */
    first = 1;                              /* looking for first gzip header */
    strm->next_in = Z_NULL;                 /* so Z_BUF_ERROR means EOF */
    for (;;) {
        /* look for the two magic header bytes for a gzip stream */
        if (NEXT() == -1) {
            ret = Z_OK;
            break;                          /* empty gzip stream is ok */
        }
        if (last != 31 || (NEXT() != 139 && last != 157)) {
            strm->msg = (char *)"incorrect header check";
            ret = first ? Z_DATA_ERROR : Z_ERRNO;
            break;                          /* not a gzip or compress header */
        }
        first = 0;                          /* next non-header is junk */
 
        /* process a compress (LZW) file -- can't be concatenated after this */
        if (last == 157) {
            ret = lunpipe(have, next, indp, outfile, strm);
            break;
        }
 
        /* process remainder of gzip header */
        ret = Z_BUF_ERROR;
        if (NEXT() != 8) {                  /* only deflate method allowed */
            if (last == -1) break;
            strm->msg = (char *)"unknown compression method";
            ret = Z_DATA_ERROR;
            break;
        }
        flags = NEXT();                     /* header flags */
        NEXT();                             /* discard mod time, xflgs, os */
        NEXT();
        NEXT();
        NEXT();
        NEXT();
        NEXT();
        if (last == -1) break;
        if (flags & 0xe0) {
            strm->msg = (char *)"unknown header flags set";
            ret = Z_DATA_ERROR;
            break;
        }
        if (flags & 4) {                    /* extra field */
            len = NEXT();
            len += (unsigned)(NEXT()) << 8;
            if (last == -1) break;
            while (len > have) {
                len -= have;
                have = 0;
                if (NEXT() == -1) break;
                len--;
            }
            if (last == -1) break;
            have -= len;
            next += len;
        }
        if (flags & 8)                      /* file name */
            while (NEXT() != 0 && last != -1)
                ;
        if (flags & 16)                     /* comment */
            while (NEXT() != 0 && last != -1)
                ;
        if (flags & 2) {                    /* header crc */
            NEXT();
            NEXT();
        }
        if (last == -1) break;
 
        /* set up output */
        outd.outfile = outfile;
        outd.check = 1;
        outd.crc = crc32(0L, Z_NULL, 0);
        outd.total = 0;
 
        /* decompress data to output */
        strm->next_in = next;
        strm->avail_in = have;
        ret = inflateBack(strm, in, indp, out, &outd);
        if (ret != Z_STREAM_END) break;
        next = strm->next_in;
        have = strm->avail_in;
        strm->next_in = Z_NULL;             /* so Z_BUF_ERROR means EOF */
 
        /* check trailer */
        ret = Z_BUF_ERROR;
        if (NEXT() != (int)(outd.crc & 0xff) ||
            NEXT() != (int)((outd.crc >> 8) & 0xff) ||
            NEXT() != (int)((outd.crc >> 16) & 0xff) ||
            NEXT() != (int)((outd.crc >> 24) & 0xff)) {
            /* crc error */
            if (last != -1) {
                strm->msg = (char *)"incorrect data check";
                ret = Z_DATA_ERROR;
            }
            break;
        }
        if (NEXT() != (int)(outd.total & 0xff) ||
            NEXT() != (int)((outd.total >> 8) & 0xff) ||
            NEXT() != (int)((outd.total >> 16) & 0xff) ||
            NEXT() != (int)((outd.total >> 24) & 0xff)) {
            /* length error */
            if (last != -1) {
                strm->msg = (char *)"incorrect length check";
                ret = Z_DATA_ERROR;
            }
            break;
        }
 
        /* go back and look for another gzip stream */
    }
 
    /* clean up and return */
    return ret;
}

References lzma_stream::avail_in, outd::check, outd::crc, crc32(), flags, in(), ind::inbuf, inbuf, ind::infile, inflateBack(), int, L, len, lunpipe(), NEXT, lzma_stream::next_in, NULL, out(), outfile, outd::outfile, strm, outd::total, unsigned, Z_BUF_ERROR, z_const, Z_DATA_ERROR, Z_ERRNO, Z_NULL, Z_OK, and Z_STREAM_END.

Referenced by gunzip().

gunzip()

int gunzip	(	z_stream *	strm,
		char *	inname,
		char *	outname,
		int	test
	)

Definition at line 548 of file gun.c.

{
    int ret;
    int infile, outfile;
 
    /* open files */
    if (inname == NULL || *inname == 0) {
        inname = "-";
        infile = 0;     /* stdin */
    }
    else {
        infile = open(inname, O_RDONLY, 0);
        if (infile == -1) {
            fprintf(stderr, "gun cannot open %s\n", inname);
            return 0;
        }
    }
    if (test)
        outfile = -1;
    else if (outname == NULL || *outname == 0) {
        outname = "-";
        outfile = 1;    /* stdout */
    }
    else {
        outfile = open(outname, O_CREAT | O_TRUNC | O_WRONLY, 0666);
        if (outfile == -1) {
            close(infile);
            fprintf(stderr, "gun cannot create %s\n", outname);
            return 0;
        }
    }
    errno = 0;
 
    /* decompress */
    ret = gunpipe(strm, infile, outfile);
    if (outfile > 2) close(outfile);
    if (infile > 2) close(infile);
 
    /* interpret result */
    switch (ret) {
    case Z_OK:
    case Z_ERRNO:
        if (infile > 2 && outfile > 2) {
            copymeta(inname, outname);          /* copy attributes */
            unlink(inname);
        }
        if (ret == Z_ERRNO)
            fprintf(stderr, "gun warning: trailing garbage ignored in %s\n",
                    inname);
        break;
    case Z_DATA_ERROR:
        if (outfile > 2) unlink(outname);
        fprintf(stderr, "gun data error on %s: %s\n", inname, strm->msg);
        break;
    case Z_MEM_ERROR:
        if (outfile > 2) unlink(outname);
        fprintf(stderr, "gun out of memory error--aborting\n");
        return 1;
    case Z_BUF_ERROR:
        if (outfile > 2) unlink(outname);
        if (strm->next_in != Z_NULL) {
            fprintf(stderr, "gun write error on %s: %s\n",
                    outname, strerror(errno));
        }
        else if (errno) {
            fprintf(stderr, "gun read error on %s: %s\n",
                    inname, strerror(errno));
        }
        else {
            fprintf(stderr, "gun unexpected end of file on %s\n",
                    inname);
        }
        break;
    default:
        if (outfile > 2) unlink(outname);
        fprintf(stderr, "gun internal error--aborting\n");
        return 1;
    }
    return 0;
}

References close, copymeta(), gunpipe(), lzma_stream::next_in, NULL, O_CREAT, O_RDONLY, O_TRUNC, O_WRONLY, outfile, strm, unlink, Z_BUF_ERROR, Z_DATA_ERROR, Z_ERRNO, Z_MEM_ERROR, Z_NULL, and Z_OK.

Referenced by main().

in()

unsigned in	(	void *	in_desc,
		z_const unsigned char **	buf
	)

Definition at line 89 of file gun.c.

{
    int ret;
    unsigned len;
    unsigned char *next;
    struct ind *me = (struct ind *)in_desc;
 
    next = me->inbuf;
    *buf = next;
    len = 0;
    do {
        ret = PIECE;
        if ((unsigned)ret > SIZE - len)
            ret = (int)(SIZE - len);
        ret = (int)read(me->infile, next, ret);
        if (ret == -1) {
            len = 0;
            break;
        }
        next += ret;
        len += ret;
    } while (ret != 0 && len < SIZE);
    return len;
}

References ind::inbuf, ind::infile, int, len, PIECE, read(), and SIZE.

Referenced by gunpipe().

lunpipe()

int lunpipe	(	unsigned	have,
		z_const unsigned char *	next,
		struct ind *	indp,
		int	outfile,
		z_stream *	strm
	)

Definition at line 200 of file gun.c.

{
    int last;                   /* last byte read by NEXT(), or -1 if EOF */
    unsigned chunk;             /* bytes left in current chunk */
    int left;                   /* bits left in rem */
    unsigned rem;               /* unused bits from input */
    int bits;                   /* current bits per code */
    unsigned code;              /* code, table traversal index */
    unsigned mask;              /* mask for current bits codes */
    int max;                    /* maximum bits per code for this stream */
    unsigned flags;             /* compress flags, then block compress flag */
    unsigned end;               /* last valid entry in prefix/suffix tables */
    unsigned temp;              /* current code */
    unsigned prev;              /* previous code */
    unsigned final;             /* last character written for previous code */
    unsigned stack;             /* next position for reversed string */
    unsigned outcnt;            /* bytes in output buffer */
    struct outd outd;           /* output structure */
    unsigned char *p;
 
    /* set up output */
    outd.outfile = outfile;
    outd.check = 0;
 
    /* process remainder of compress header -- a flags byte */
    flags = NEXT();
    if (last == -1)
        return Z_BUF_ERROR;
    if (flags & 0x60) {
        strm->msg = (char *)"unknown lzw flags set";
        return Z_DATA_ERROR;
    }
    max = flags & 0x1f;
    if (max < 9 || max > 16) {
        strm->msg = (char *)"lzw bits out of range";
        return Z_DATA_ERROR;
    }
    if (max == 9)                           /* 9 doesn't really mean 9 */
        max = 10;
    flags &= 0x80;                          /* true if block compress */
 
    /* clear table */
    bits = 9;
    mask = 0x1ff;
    end = flags ? 256 : 255;
 
    /* set up: get first 9-bit code, which is the first decompressed byte, but
       don't create a table entry until the next code */
    if (NEXT() == -1)                       /* no compressed data is ok */
        return Z_OK;
    final = prev = (unsigned)last;          /* low 8 bits of code */
    if (NEXT() == -1)                       /* missing a bit */
        return Z_BUF_ERROR;
    if (last & 1) {                         /* code must be < 256 */
        strm->msg = (char *)"invalid lzw code";
        return Z_DATA_ERROR;
    }
    rem = (unsigned)last >> 1;              /* remaining 7 bits */
    left = 7;
    chunk = bits - 2;                       /* 7 bytes left in this chunk */
    outbuf[0] = (unsigned char)final;       /* write first decompressed byte */
    outcnt = 1;
 
    /* decode codes */
    stack = 0;
    for (;;) {
        /* if the table will be full after this, increment the code size */
        if (end >= mask && bits < max) {
            FLUSHCODE();
            bits++;
            mask <<= 1;
            mask++;
        }
 
        /* get a code of length bits */
        if (chunk == 0)                     /* decrement chunk modulo bits */
            chunk = bits;
        code = rem;                         /* low bits of code */
        if (NEXT() == -1) {                 /* EOF is end of compressed data */
            /* write remaining buffered output */
            if (outcnt && out(&outd, outbuf, outcnt)) {
                strm->next_in = outbuf;     /* signal write error */
                return Z_BUF_ERROR;
            }
            return Z_OK;
        }
        code += (unsigned)last << left;     /* middle (or high) bits of code */
        left += 8;
        chunk--;
        if (bits > left) {                  /* need more bits */
            if (NEXT() == -1)               /* can't end in middle of code */
                return Z_BUF_ERROR;
            code += (unsigned)last << left; /* high bits of code */
            left += 8;
            chunk--;
        }
        code &= mask;                       /* mask to current code length */
        left -= bits;                       /* number of unused bits */
        rem = (unsigned)last >> (8 - left); /* unused bits from last byte */
 
        /* process clear code (256) */
        if (code == 256 && flags) {
            FLUSHCODE();
            bits = 9;                       /* initialize bits and mask */
            mask = 0x1ff;
            end = 255;                      /* empty table */
            continue;                       /* get next code */
        }
 
        /* special code to reuse last match */
        temp = code;                        /* save the current code */
        if (code > end) {
            /* Be picky on the allowed code here, and make sure that the code
               we drop through (prev) will be a valid index so that random
               input does not cause an exception.  The code != end + 1 check is
               empirically derived, and not checked in the original uncompress
               code.  If this ever causes a problem, that check could be safely
               removed.  Leaving this check in greatly improves gun's ability
               to detect random or corrupted input after a compress header.
               In any case, the prev > end check must be retained. */
            if (code != end + 1 || prev > end) {
                strm->msg = (char *)"invalid lzw code";
                return Z_DATA_ERROR;
            }
            match[stack++] = (unsigned char)final;
            code = prev;
        }
 
        /* walk through linked list to generate output in reverse order */
        p = match + stack;
        while (code >= 256) {
            *p++ = suffix[code];
            code = prefix[code];
        }
        stack = p - match;
        match[stack++] = (unsigned char)code;
        final = code;
 
        /* link new table entry */
        if (end < mask) {
            end++;
            prefix[end] = (unsigned short)prev;
            suffix[end] = (unsigned char)final;
        }
 
        /* set previous code for next iteration */
        prev = temp;
 
        /* write output in forward order */
        while (stack > SIZE - outcnt) {
            while (outcnt < SIZE)
                outbuf[outcnt++] = match[--stack];
            if (out(&outd, outbuf, outcnt)) {
                strm->next_in = outbuf; /* signal write error */
                return Z_BUF_ERROR;
            }
            outcnt = 0;
        }
        p = match + stack;
        do {
            outbuf[outcnt++] = *--p;
        } while (p > match);
        stack = 0;
 
        /* loop for next code with final and prev as the last match, rem and
           left provide the first 0..7 bits of the next code, end is the last
           valid table entry */
    }
}

References bits(), outd::check, code, test_evm::end, flags, FLUSHCODE, mask, match, max, NEXT, lzma_stream::next_in, out(), outbuf, outfile, outd::outfile, p, prefix, SIZE, stack, strm, suffix, unsigned, Z_BUF_ERROR, Z_DATA_ERROR, and Z_OK.

Referenced by gunpipe().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 631 of file gun.c.

{
    int ret, len, test;
    char *outname;
    unsigned char *window;
    z_stream strm;
 
    /* initialize inflateBack state for repeated use */
    window = match;                         /* reuse LZW match buffer */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    ret = inflateBackInit(&strm, 15, window);
    if (ret != Z_OK) {
        fprintf(stderr, "gun out of memory error--aborting\n");
        return 1;
    }
 
    /* decompress each file to the same name with the suffix removed */
    argc--;
    argv++;
    test = 0;
    if (argc && strcmp(*argv, "-h") == 0) {
        fprintf(stderr, "gun 1.6 (17 Jan 2010)\n");
        fprintf(stderr, "Copyright (C) 2003-2010 Mark Adler\n");
        fprintf(stderr, "usage: gun [-t] [file1.gz [file2.Z ...]]\n");
        return 0;
    }
    if (argc && strcmp(*argv, "-t") == 0) {
        test = 1;
        argc--;
        argv++;
    }
    if (argc)
        do {
            if (test)
                outname = NULL;
            else {
                len = (int)strlen(*argv);
                if (strcmp(*argv + len - 3, ".gz") == 0 ||
                    strcmp(*argv + len - 3, "-gz") == 0)
                    len -= 3;
                else if (strcmp(*argv + len - 2, ".z") == 0 ||
                    strcmp(*argv + len - 2, "-z") == 0 ||
                    strcmp(*argv + len - 2, "_z") == 0 ||
                    strcmp(*argv + len - 2, ".Z") == 0)
                    len -= 2;
                else {
                    fprintf(stderr, "gun error: no gz type on %s--skipping\n",
                            *argv);
                    continue;
                }
                outname = malloc(len + 1);
                if (outname == NULL) {
                    fprintf(stderr, "gun out of memory error--aborting\n");
                    ret = 1;
                    break;
                }
                memcpy(outname, *argv, len);
                outname[len] = 0;
            }
            ret = gunzip(&strm, *argv, outname, test);
            if (outname != NULL) free(outname);
            if (ret) break;
        } while (argv++, --argc);
    else
        ret = gunzip(&strm, NULL, NULL, test);
 
    /* clean up */
    inflateBackEnd(&strm);
    return ret;
}

References argv, free(), gunzip(), inflateBackEnd(), inflateBackInit, int, len, malloc(), match, memcpy(), NULL, strm, test_customized_mnem::test(), Z_NULL, and Z_OK.

out()

int out	(	void *	out_desc,
		unsigned char *	buf,
		unsigned	len
	)

Definition at line 131 of file gun.c.

{
    int ret;
    struct outd *me = (struct outd *)out_desc;
 
    if (me->check) {
        me->crc = crc32(me->crc, buf, len);
        me->total += len;
    }
    if (me->outfile != -1)
        do {
            ret = PIECE;
            if ((unsigned)ret > len)
                ret = (int)len;
            ret = (int)write(me->outfile, buf, ret);
            if (ret == -1)
                return 1;
            buf += ret;
            len -= ret;
        } while (len != 0);
    return 0;
}

References outd::check, outd::crc, crc32(), int, len, outd::outfile, PIECE, outd::total, and write.

Referenced by gunpipe(), and lunpipe().

Variable Documentation

inbuf

unsigned char inbuf[SIZE]

Definition at line 161 of file gun.c.

Referenced by blowfish_crypt(), blowfish_decrypt(), compress(), decompress(), F(), gunpipe(), lzss_decompress(), rc2_crypt(), rc2_crypt8(), rc2_dcrypt(), rc2_dcrypt8(), rc4_crypt(), rc6_decrypt(), rc6_encrypt(), rol_crypt(), ror_crypt(), rot_crypt(), rot_decrypt(), and xor_crypt().

match

static int match

Definition at line 165 of file gun.c.

Referenced by _zip_find_central_dir(), diff_hexdump_partial(), find_longest_match(), FUZ_fillCompressibleNoiseBuffer(), inflate_table(), longest_match(), lunpipe(), LZ4_compress_generic_validated(), LZ4_decompress_generic(), LZ4HC_FindLongerMatch(), main(), match_new(), RDG_genBlock(), rz_regex_get_match_list(), rz_search_regexp_update(), ts_query_captures_wasm(), ts_query_matches_wasm(), and types_enum_member_find_all().

outbuf

unsigned char outbuf[SIZE]

Definition at line 162 of file gun.c.

Referenced by blowfish_crypt(), blowfish_decrypt(), compress(), decompress(), lunpipe(), rc2_crypt(), rc2_crypt8(), rc2_dcrypt(), rc2_dcrypt8(), rc4_crypt(), rc6_decrypt(), rc6_encrypt(), rol_crypt(), ror_crypt(), rot_crypt(), rot_decrypt(), rz_print_format_register(), rz_type_format_10bytes(), rz_type_format_bitfield(), rz_type_format_byte(), rz_type_format_char(), rz_type_format_data(), rz_type_format_data_internal(), rz_type_format_decchar(), rz_type_format_double(), rz_type_format_enum(), rz_type_format_float(), rz_type_format_hex(), rz_type_format_hexflag(), rz_type_format_hexpairs(), rz_type_format_int(), rz_type_format_nulltermstring(), rz_type_format_nulltermwidestring(), rz_type_format_num(), rz_type_format_num_specifier(), rz_type_format_octal(), rz_type_format_quadword(), rz_type_format_string(), rz_type_format_struct(), rz_type_format_time(), rz_type_format_u128(), rz_type_format_uleb(), rz_type_format_word(), xor_crypt(), z80asm(), and zip_fread().

prefix

unsigned short prefix[65536]

Definition at line 163 of file gun.c.

Referenced by __childrenFlagsOf(), __rotate_panel_cmds(), _CbInRangeSearchV(), add_map(), cmd_print_format(), d_substitution(), decode_prefix(), diff_output_data(), diff_unified_append_data(), diff_unified_lines_hl(), diffrow(), ds_esc_str(), ds_print_str(), extract_sections_symbols(), find_include(), get_pkt_indicator(), lunpipe(), main_print_var(), mpc_err_count(), mpc_err_repeat(), myregwrite(), print_register_list(), printRegbitsRange(), process_constructors(), reloc_set_flag(), rtti_itanium_print_class_type_info(), rtti_itanium_print_si_class_type_info(), rtti_itanium_print_vmi_class_type_info(), rtti_msvc_print_base_class_descriptor(), rtti_msvc_print_class_hierarchy_descriptor(), rtti_msvc_print_complete_object_locator(), rtti_msvc_print_type_descriptor(), rz_cons_pal_list(), rz_core_get_boundaries_prot(), rz_egg_lang_include_init(), rz_file_mkstemp(), rz_file_temp(), RZ_PACKED(), rz_str_between(), sections_from_mach0(), uv_interface_addresses(), and xap_decode().

suffix

unsigned char suffix[65536]

Definition at line 164 of file gun.c.

Referenced by cmd_foreach_cmdname_modes(), compressed_name(), d_clone_suffix(), d_expression_1(), d_print_mod_list(), diffrow(), fill_modes_children_chars(), get_ext_suffix(), is_valid_argv_modes(), lunpipe(), LZ4IO_compressMultipleFilenames(), LZ4IO_compressMultipleFilenames_Legacy(), LZ4IO_decompressMultipleFilenames(), mode_cmd_desc_help(), msg_suffix(), rz_file_mkstemp(), rz_str_between(), rz_syscmd_mkdir(), suffix2mode(), suffix_set(), test_suffix(), and uint64_to_nicestr().