X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=archival%2Fgzip.c;h=bc4c7badd10118b6edf0162850e0f9ebcde0493a;hb=edc388cf4ef381282d13e2873694e3c9032214e4;hp=5c86c1070c3243d44c4420a046820eae35def3e4;hpb=74400ccfd08e8ff72b9147951dd437dd3bb7abb1;p=oweals%2Fbusybox.git diff --git a/archival/gzip.c b/archival/gzip.c index 5c86c1070..bc4c7badd 100644 --- a/archival/gzip.c +++ b/archival/gzip.c @@ -9,8 +9,8 @@ * only standard in to standard out with -9 compression. It also requires * the zcat module for some important functions." * - * Adjusted further by Erik Andersen , - * to support files as well as stdin/stdout, and to generally behave itself wrt + * Adjusted further by Erik Andersen to support + * files as well as stdin/stdout, and to generally behave itself wrt * command line handling. * * This program is free software; you can redistribute it and/or modify @@ -71,7 +71,6 @@ typedef unsigned long ulg; #define STORED 0 /* methods 4 to 7 reserved */ #define DEFLATED 8 -static int method; /* compression method */ /* To save memory for 16 bit systems, some arrays are overlaid between * the various modules: @@ -88,7 +87,7 @@ static int method; /* compression method */ # define INBUFSIZ 0x8000 /* input buffer size */ # endif #endif -#define INBUF_EXTRA 64 /* required by unlzw() */ +#define INBUF_EXTRA 64 /* required by unlzw() */ #ifndef OUTBUFSIZ # ifdef SMALL_MEM @@ -97,7 +96,7 @@ static int method; /* compression method */ # define OUTBUFSIZ 16384 /* output buffer size */ # endif #endif -#define OUTBUF_EXTRA 2048 /* required by unlzw() */ +#define OUTBUF_EXTRA 2048 /* required by unlzw() */ #ifndef DIST_BUFSIZE # ifdef SMALL_MEM @@ -112,7 +111,7 @@ static int method; /* compression method */ # define ALLOC(type, array, size) { \ array = (type*)xcalloc((size_t)(((size)+1L)/2), 2*sizeof(type)); \ } -# define FREE(array) {if (array != NULL) free(array), array=NULL;} +# define FREE(array) {free(array), array=NULL;} #else # define DECLARE(type, array, size) static type array[size] # define ALLOC(type, array, size) @@ -120,17 +119,17 @@ static int method; /* compression method */ #endif #define tab_suffix window -#define tab_prefix prev /* hash link (see deflate.c) */ -#define head (prev+WSIZE) /* hash head (see deflate.c) */ +#define tab_prefix prev /* hash link (see deflate.c) */ +#define head (prev+WSIZE) /* hash head (see deflate.c) */ -static long bytes_in; /* number of input bytes */ +static long bytes_in; /* number of input bytes */ #define isize bytes_in /* for compatibility with old zip sources (to be cleaned) */ -typedef int file_t; /* Do not use stdio */ +typedef int file_t; /* Do not use stdio */ -#define NO_FILE (-1) /* in memory compression */ +#define NO_FILE (-1) /* in memory compression */ #define PACK_MAGIC "\037\036" /* Magic header for packed files */ @@ -140,12 +139,12 @@ typedef int file_t; /* Do not use stdio */ #define PKZIP_MAGIC "\120\113\003\004" /* Magic header for pkzip files */ /* gzip flag byte */ -#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ -#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */ -#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ -#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ -#define COMMENT 0x10 /* bit 4 set: file comment present */ -#define RESERVED 0xC0 /* bit 6,7: reserved */ +#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ +#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */ +#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ +#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ +#define COMMENT 0x10 /* bit 4 set: file comment present */ +#define RESERVED 0xC0 /* bit 6,7: reserved */ /* internal file attribute */ #define UNKNOWN 0xffff @@ -153,7 +152,7 @@ typedef int file_t; /* Do not use stdio */ #define ASCII 1 #ifndef WSIZE -# define WSIZE 0x8000 /* window size--must be a power of two, and */ +# define WSIZE 0x8000 /* window size--must be a power of two, and */ #endif /* at least 32K for zip's deflate method */ #define MIN_MATCH 3 @@ -174,15 +173,6 @@ typedef int file_t; /* Do not use stdio */ #define put_byte(c) {outbuf[outcnt++]=(uch)(c); if (outcnt==OUTBUFSIZ)\ flush_outbuf();} -/* Output a 16 bit value, lsb first */ -#define put_short(w) \ -{ if (outcnt < OUTBUFSIZ-2) { \ - outbuf[outcnt++] = (uch) ((w) & 0xff); \ - outbuf[outcnt++] = (uch) ((ush)(w) >> 8); \ - } else { \ - put_short_when_full(w); \ - } \ -} /* Output a 32 bit value to the bit stream, lsb first */ #if 0 @@ -192,12 +182,12 @@ typedef int file_t; /* Do not use stdio */ } #endif -#define seekable() 0 /* force sequential output */ -#define translate_eol 0 /* no option -a yet */ +#define seekable() 0 /* force sequential output */ +#define translate_eol 0 /* no option -a yet */ /* Diagnostic functions */ #ifdef DEBUG -# define Assert(cond,msg) {if(!(cond)) error_msg(msg);} +# define Assert(cond,msg) {if(!(cond)) bb_error_msg(msg);} # define Trace(x) fprintf x # define Tracev(x) {if (verbose) fprintf x ;} # define Tracevv(x) {if (verbose>1) fprintf x ;} @@ -221,34 +211,31 @@ typedef int file_t; /* Do not use stdio */ /* from zip.c: */ -static int zip (int in, int out); -static int file_read (char *buf, unsigned size); +static int zip(int in, int out); +static int file_read(char *buf, unsigned size); /* from gzip.c */ -static RETSIGTYPE abort_gzip (void); +static RETSIGTYPE abort_gzip(void); /* from deflate.c */ -static void lm_init (ush * flags); -static ulg deflate (void); +static void lm_init(ush * flags); +static ulg deflate(void); /* from trees.c */ -static void ct_init (ush * attr, int *methodp); -static int ct_tally (int dist, int lc); -static ulg flush_block (char *buf, ulg stored_len, int eof); +static void ct_init(ush * attr, int *methodp); +static int ct_tally(int dist, int lc); +static ulg flush_block(char *buf, ulg stored_len, int eof); /* from bits.c */ -static void bi_init (file_t zipfile); -static void send_bits (int value, int length); -static unsigned bi_reverse (unsigned value, int length); -static void bi_windup (void); -static void copy_block (char *buf, unsigned len, int header); +static void bi_init(file_t zipfile); +static void send_bits(int value, int length); +static unsigned bi_reverse(unsigned value, int length); +static void bi_windup(void); +static void copy_block(char *buf, unsigned len, int header); static int (*read_buf) (char *buf, unsigned size); /* from util.c: */ -static void flush_outbuf (void); - -static void put_short_when_full (ush); - +static void flush_outbuf(void); /* lzw.h -- define the lzw functions. * Copyright (C) 1992-1993 Jean-loup Gailly. @@ -263,9 +250,9 @@ static void put_short_when_full (ush); #ifndef BITS # define BITS 16 #endif -#define INIT_BITS 9 /* Initial number of bits per code */ +#define INIT_BITS 9 /* Initial number of bits per code */ -#define BIT_MASK 0x1f /* Mask for 'number of compression bits' */ +#define BIT_MASK 0x1f /* Mask for 'number of compression bits' */ /* Mask 0x20 is reserved to mean a fourth header byte, and 0x40 is free. * It's a pity that old uncompress does not check bit 0x20. That makes * extension of the format actually undesirable because old compress @@ -289,7 +276,7 @@ static void put_short_when_full (ush); /* Common defaults */ #ifndef OS_CODE -# define OS_CODE 0x03 /* assume Unix */ +# define OS_CODE 0x03 /* assume Unix */ #endif #ifndef PATH_SEP @@ -320,21 +307,32 @@ DECLARE(ush, tab_prefix, 1L << BITS); static int crc_table_empty = 1; -static int foreground; /* set if program run in foreground */ +static int foreground; /* set if program run in foreground */ static int method = DEFLATED; /* compression method */ -static int exit_code = OK; /* program exit code */ -static int part_nb; /* number of parts in .gz file */ -static long time_stamp; /* original time stamp (modification time) */ -static long ifile_size; /* input file size, -1 for devices (debug only) */ +static int exit_code = OK; /* program exit code */ +static int part_nb; /* number of parts in .gz file */ +static long time_stamp; /* original time stamp (modification time) */ +static long ifile_size; /* input file size, -1 for devices (debug only) */ static char z_suffix[MAX_SUFFIX + 1]; /* default suffix (can be set with --suffix) */ -static int z_len; /* strlen(z_suffix) */ +static int z_len; /* strlen(z_suffix) */ + +static int ifd; /* input file descriptor */ +static int ofd; /* output file descriptor */ +static unsigned insize; /* valid bytes in inbuf */ +static unsigned outcnt; /* bytes in output buffer */ + -static char ifname[MAX_PATH_LEN]; /* input file name */ -static char ofname[MAX_PATH_LEN]; /* output file name */ -static int ifd; /* input file descriptor */ -static int ofd; /* output file descriptor */ -static unsigned insize; /* valid bytes in inbuf */ -static unsigned outcnt; /* bytes in output buffer */ +/* Output a 16 bit value, lsb first */ +static void put_short(ush w) +{ + if (outcnt < OUTBUFSIZ - 2) { + outbuf[outcnt++] = (uch) ((w) & 0xff); + outbuf[outcnt++] = (uch) ((ush) (w) >> 8); + } else { + put_byte((uch) ((w) & 0xff)); + put_byte((uch) ((ush) (w) >> 8)); + } +} /* ======================================================================== * Signal and error handler. @@ -354,10 +352,10 @@ static void clear_bufs(void) bytes_in = 0L; } -static void write_error_msg(void) +static void write_bb_error_msg(void) { - fprintf(stderr, "\n"); - perror(""); + fputc('\n', stderr); + bb_perror_nomsg(); abort_gzip(); } @@ -371,7 +369,7 @@ static void write_buf(int fd, void *buf, unsigned cnt) while ((n = write(fd, buf, cnt)) != cnt) { if (n == (unsigned) (-1)) { - write_error_msg(); + write_bb_error_msg(); } cnt -= n; buf = (void *) ((char *) buf + n); @@ -383,27 +381,28 @@ static void write_buf(int fd, void *buf, unsigned cnt) * pointer, then initialize the crc shift register contents instead. * Return the current crc in either case. */ -static ulg updcrc(uch *s, unsigned n) +static ulg updcrc(uch * s, unsigned n) { static ulg crc = (ulg) 0xffffffffL; /* shift register contents */ - register ulg c; /* temporary variable */ + register ulg c; /* temporary variable */ static unsigned long crc_32_tab[256]; + if (crc_table_empty) { - unsigned long csr; /* crc shift register */ + unsigned long csr; /* crc shift register */ const unsigned long e = 0xedb88320L; /* polynomial exclusive-or pattern */ - int i; /* counter for all possible eight bit values */ - int k; /* byte being shifted into crc apparatus */ + int i; /* counter for all possible eight bit values */ + int k; /* byte being shifted into crc apparatus */ /* Compute table of CRC's. */ crc_32_tab[0] = 0x00000000L; for (i = 1; i < 256; i++) { csr = i; - /* The idea to initialize the register with the byte instead of - * zero was stolen from Haruhiko Okumura's ar002 - */ + /* The idea to initialize the register with the byte instead of + * zero was stolen from Haruhiko Okumura's ar002 + */ for (k = 8; k; k--) csr = csr & 1 ? (csr >> 1) ^ e : csr >> 1; - crc_32_tab[i]=csr; + crc_32_tab[i] = csr; } } @@ -417,7 +416,7 @@ static ulg updcrc(uch *s, unsigned n) } while (--n); } crc = c; - return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ } /* bits.c -- output variable-length bit strings @@ -477,7 +476,7 @@ static ulg updcrc(uch *s, unsigned n) * Local data used by the "bit string" routines. */ -static file_t zfile; /* output gzip file */ +static file_t zfile; /* output gzip file */ static unsigned short bi_buf; @@ -495,7 +494,7 @@ static int bi_valid; /* Current input function. Set to mem_read for in-memory compression */ #ifdef DEBUG -ulg bits_sent; /* bit length of the compressed data */ +ulg bits_sent; /* bit length of the compressed data */ #endif /* =========================================================================== @@ -583,7 +582,7 @@ static void bi_windup() */ static void copy_block(char *buf, unsigned len, int header) { - bi_windup(); /* align on byte boundary */ + bi_windup(); /* align on byte boundary */ if (header) { put_short((ush) len); @@ -677,7 +676,7 @@ static void copy_block(char *buf, unsigned len, int header) */ #ifdef SMALL_MEM -# define HASH_BITS 13 /* Number of bits used to hash strings */ +# define HASH_BITS 13 /* Number of bits used to hash strings */ #endif #ifdef MEDIUM_MEM # define HASH_BITS 14 @@ -751,7 +750,7 @@ static long block_start; * negative when the window is moved backwards. */ -static unsigned ins_h; /* hash index of string to be inserted */ +static unsigned ins_h; /* hash index of string to be inserted */ #define H_SHIFT ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH) /* Number of bits by which ins_h and del_h must be shifted at each @@ -766,18 +765,18 @@ static unsigned int prev_length; * are discarded. This is used in the lazy match evaluation. */ -static unsigned strstart; /* start of string to insert */ -static unsigned match_start; /* start of matching string */ -static int eofile; /* flag set at end of input file */ -static unsigned lookahead; /* number of valid bytes ahead in window */ +static unsigned strstart; /* start of string to insert */ +static unsigned match_start; /* start of matching string */ +static int eofile; /* flag set at end of input file */ +static unsigned lookahead; /* number of valid bytes ahead in window */ -static const unsigned max_chain_length=4096; +static const unsigned max_chain_length = 4096; /* To speed up deflation, hash chains are never searched beyond this length. * A higher limit improves compression ratio but degrades the speed. */ -static const unsigned int max_lazy_match=258; +static const unsigned int max_lazy_match = 258; /* Attempt to find a better match only when the current match is strictly * smaller than this value. This mechanism is used only for compression @@ -789,7 +788,7 @@ static const unsigned int max_lazy_match=258; * max_insert_length is used only for compression levels <= 3. */ -static const unsigned good_match=32; +static const unsigned good_match = 32; /* Use a faster search when the previous match is longer than this */ @@ -800,7 +799,7 @@ static const unsigned good_match=32; * found for specific files. */ -static const int nice_match=258; /* Stop searching when current match exceeds this */ +static const int nice_match = 258; /* Stop searching when current match exceeds this */ /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different @@ -813,12 +812,12 @@ static const int nice_match=258; /* Stop searching when current match exceeds /* =========================================================================== * Prototypes for local functions. */ -static void fill_window (void); +static void fill_window(void); -static int longest_match (IPos cur_match); +static int longest_match(IPos cur_match); #ifdef DEBUG -static void check_match (IPos start, IPos match, int length); +static void check_match(IPos start, IPos match, int length); #endif /* =========================================================================== @@ -845,7 +844,7 @@ static void check_match (IPos start, IPos match, int length); /* =========================================================================== * Initialize the "longest match" routines for a new file */ -static void lm_init(ush *flags) +static void lm_init(ush * flags) { register unsigned j; @@ -898,11 +897,10 @@ static int longest_match(IPos cur_match) { unsigned chain_length = max_chain_length; /* max hash chain length */ register uch *scan = window + strstart; /* current string */ - register uch *match; /* matched string */ - register int len; /* length of current match */ + register uch *match; /* matched string */ + register int len; /* length of current match */ int best_len = prev_length; /* best match length so far */ IPos limit = - strstart > (IPos) MAX_DIST ? strstart - (IPos) MAX_DIST : NIL; /* Stop when cur_match becomes <= limit. To simplify the code, * we prevent matches with the string of window index 0. @@ -922,8 +920,7 @@ static int longest_match(IPos cur_match) if (prev_length >= good_match) { chain_length >>= 2; } - Assert(strstart <= window_size - MIN_LOOKAHEAD, - "insufficient lookahead"); + Assert(strstart <= window_size - MIN_LOOKAHEAD, "insufficient lookahead"); do { Assert(cur_match < strstart, "no future"); @@ -952,8 +949,7 @@ static int longest_match(IPos cur_match) } while (*++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - scan < strend); + *++scan == *++match && *++scan == *++match && scan < strend); len = MAX_MATCH - (int) (strend - scan); scan = strend - MAX_MATCH; @@ -981,12 +977,11 @@ static void check_match(IPos start, IPos match, int length) /* check that the match is indeed a match */ if (memcmp((char *) window + match, (char *) window + start, length) != EQUAL) { - fprintf(stderr, - " start %d, match %d, length %d\n", start, match, length); - error_msg("invalid match"); + bb_error_msg(" start %d, match %d, length %d", start, match, length); + bb_error_msg("invalid match"); } if (verbose > 1) { - fprintf(stderr, "\\[%d,%d]", start - match, length); + bb_error_msg("\\[%d,%d]", start - match, length); do { putc(window[start++], stderr); } while (--length != 0); @@ -1008,7 +1003,6 @@ static void fill_window() { register unsigned n, m; unsigned more = - (unsigned) (window_size - (ulg) lookahead - (ulg) strstart); /* Amount of free space at the end of the window. */ @@ -1028,7 +1022,7 @@ static void fill_window() memcpy((char *) window, (char *) window + WSIZE, (unsigned) WSIZE); match_start -= WSIZE; - strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */ + strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */ block_start -= (long) WSIZE; @@ -1071,9 +1065,9 @@ static void fill_window() */ static ulg deflate() { - IPos hash_head; /* head of hash chain */ - IPos prev_match; /* previous match */ - int flush; /* set if current block must be flushed */ + IPos hash_head; /* head of hash chain */ + IPos prev_match; /* previous match */ + int flush; /* set if current block must be flushed */ int match_available = 0; /* set if previous match exists */ register unsigned match_length = MIN_MATCH - 1; /* length of best match */ @@ -1101,8 +1095,7 @@ static ulg deflate() match_length = lookahead; /* Ignore a length 3 match if it is too distant: */ - if (match_length == MIN_MATCH - && strstart - match_start > TOO_FAR) { + if (match_length == MIN_MATCH && strstart - match_start > TOO_FAR) { /* If prev_match is also MIN_MATCH, match_start is garbage * but we will ignore the current match anyway. */ @@ -1117,8 +1110,7 @@ static ulg deflate() check_match(strstart - 1, prev_match, prev_length); flush = - ct_tally(strstart - 1 - prev_match, - prev_length - MIN_MATCH); + ct_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH); /* Insert in hash table all strings up to the end of the match. * strstart-1 and strstart are already inserted. @@ -1172,7 +1164,7 @@ static ulg deflate() if (match_available) ct_tally(0, window[strstart - 1]); - return FLUSH_BLOCK(1); /* eof */ + return FLUSH_BLOCK(1); /* eof */ } /* gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface @@ -1202,9 +1194,6 @@ typedef struct dirent dir_type; typedef RETSIGTYPE(*sig_type) (int); /* ======================================================================== */ -// int main (argc, argv) -// int argc; -// char **argv; int gzip_main(int argc, char **argv) { int result; @@ -1213,7 +1202,6 @@ int gzip_main(int argc, char **argv) struct stat statBuf; char *delFileName; int tostdout = 0; - int fromstdin = 0; int force = 0; int opt; @@ -1225,28 +1213,28 @@ int gzip_main(int argc, char **argv) case 'f': force = 1; break; - /* Ignore 1-9 (compression level) options */ - case '1': case '2': case '3': case '4': case '5': - case '6': case '7': case '8': case '9': + /* Ignore 1-9 (compression level) options */ + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': break; case 'q': break; -#ifdef BB_GUNZIP +#ifdef CONFIG_GUNZIP case 'd': optind = 1; return gunzip_main(argc, argv); #endif default: - show_usage(); + bb_show_usage(); } } - if ((optind == argc) || (strcmp(argv[optind], "-") == 0)) { - fromstdin = 1; - tostdout = 1; - } - - if (isatty(fileno(stdout)) && tostdout==1 && force==0) - error_msg_and_die( "compressed data not written to terminal. Use -f to force it."); foreground = signal(SIGINT, SIG_IGN) != SIG_IGN; if (foreground) { @@ -1273,73 +1261,83 @@ int gzip_main(int argc, char **argv) ALLOC(uch, window, 2L * WSIZE); ALLOC(ush, tab_prefix, 1L << BITS); - if (fromstdin == 1) { - strcpy(ofname, "stdin"); + clear_bufs(); + part_nb = 0; - inFileNum = fileno(stdin); - time_stamp = 0; /* time unknown by default */ - ifile_size = -1L; /* convention for unknown size */ + if (optind == argc) { + time_stamp = 0; + ifile_size = -1L; + zip(STDIN_FILENO, STDOUT_FILENO); } else { - /* Open up the input file */ - strncpy(ifname, argv[optind], MAX_PATH_LEN); - - /* Open input file */ - inFileNum = open(ifname, O_RDONLY); - if (inFileNum < 0 || stat(ifname, &statBuf) < 0) - perror_msg_and_die("%s", ifname); - /* Get the time stamp on the input file. */ - time_stamp = statBuf.st_ctime; - ifile_size = statBuf.st_size; - } + int i; + for (i = optind; i < argc; i++) { + char *path = NULL; - if (tostdout == 1) { - /* And get to work */ - strcpy(ofname, "stdout"); - outFileNum = fileno(stdout); + if (strcmp(argv[i], "-") == 0) { + time_stamp = 0; + ifile_size = -1L; + inFileNum = STDIN_FILENO; + outFileNum = STDOUT_FILENO; + } else { + inFileNum = open(argv[i], O_RDONLY); + if (inFileNum < 0 || fstat(inFileNum, &statBuf) < 0) + bb_perror_msg_and_die("%s", argv[i]); + time_stamp = statBuf.st_ctime; + ifile_size = statBuf.st_size; + + if (!tostdout) { + path = xmalloc(strlen(argv[i]) + 4); + strcpy(path, argv[i]); + strcat(path, ".gz"); + + /* Open output file */ +#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1) + outFileNum = + open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW); +#else + outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL); +#endif + if (outFileNum < 0) { + bb_perror_msg("%s", path); + free(path); + continue; + } + + /* Set permissions on the file */ + fchmod(outFileNum, statBuf.st_mode); + } else + outFileNum = STDOUT_FILENO; + } - clear_bufs(); /* clear input and output buffers */ - part_nb = 0; + if (path == NULL && isatty(outFileNum) && force == 0) { + bb_error_msg + ("compressed data not written to a terminal. Use -f to force compression."); + free(path); + continue; + } - /* Actually do the compression/decompression. */ - zip(inFileNum, outFileNum); + result = zip(inFileNum, outFileNum); - } else { + if (path != NULL) { + close(inFileNum); + close(outFileNum); - /* And get to work */ - strncpy(ofname, ifname, MAX_PATH_LEN - 4); - strcat(ofname, ".gz"); + /* Delete the original file */ + if (result == OK) + delFileName = argv[i]; + else + delFileName = path; + if (unlink(delFileName) < 0) + bb_perror_msg("%s", delFileName); + } - /* Open output fille */ -#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1) - outFileNum = open(ofname, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW); -#else - outFileNum = open(ofname, O_RDWR | O_CREAT | O_EXCL); -#endif - if (outFileNum < 0) - perror_msg_and_die("%s", ofname); - /* Set permissions on the file */ - fchmod(outFileNum, statBuf.st_mode); - - clear_bufs(); /* clear input and output buffers */ - part_nb = 0; - - /* Actually do the compression/decompression. */ - result = zip(inFileNum, outFileNum); - close(outFileNum); - close(inFileNum); - /* Delete the original file */ - if (result == OK) - delFileName = ifname; - else - delFileName = ofname; - - if (unlink(delFileName) < 0) - perror_msg_and_die("%s", delFileName); + free(path); + } } - return(exit_code); + return (exit_code); } /* trees.c -- output deflated data using Huffman coding @@ -1428,17 +1426,19 @@ int gzip_main(int argc, char **argv) typedef uch extra_bits_t; /* extra bits for each length code */ -static const extra_bits_t extra_lbits[LENGTH_CODES] +static const extra_bits_t extra_lbits[LENGTH_CODES] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, - 4, 4, 5, 5, 5, 5, 0 }; + 4, 4, 5, 5, 5, 5, 0 +}; /* extra bits for each distance code */ -static const extra_bits_t extra_dbits[D_CODES] +static const extra_bits_t extra_dbits[D_CODES] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, - 10, 10, 11, 11, 12, 12, 13, 13 }; + 10, 10, 11, 11, 12, 12, 13, 13 +}; /* extra bits for each bit length code */ -static const extra_bits_t extra_blbits[BL_CODES] +static const extra_bits_t extra_blbits[BL_CODES] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 }; #define STORED_BLOCK 0 @@ -1481,23 +1481,28 @@ static const extra_bits_t extra_blbits[BL_CODES] * if we rely on DIST_BUFSIZE == LIT_BUFSIZE. */ #if LIT_BUFSIZE > INBUFSIZ -error cannot overlay l_buf and inbuf +#error cannot overlay l_buf and inbuf #endif #define REP_3_6 16 /* repeat previous bit length 3-6 times (2 bits of repeat count) */ #define REPZ_3_10 17 /* repeat a zero length 3-10 times (3 bits of repeat count) */ #define REPZ_11_138 18 -/* repeat a zero length 11-138 times (7 bits of repeat count) *//* =========================================================================== +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +/* =========================================================================== * Local data - *//* Data structure describing a single value and its code string. */ typedef struct ct_data { + */ + +/* Data structure describing a single value and its code string. */ +typedef struct ct_data { union { - ush freq; /* frequency count */ - ush code; /* bit string */ + ush freq; /* frequency count */ + ush code; /* bit string */ } fc; union { - ush dad; /* father node in Huffman tree */ - ush len; /* length of bit string */ + ush dad; /* father node in Huffman tree */ + ush len; /* length of bit string */ } dl; } ct_data; @@ -1531,25 +1536,27 @@ static ct_data bl_tree[2 * BL_CODES + 1]; /* Huffman tree for the bit lengths */ typedef struct tree_desc { - ct_data *dyn_tree; /* the dynamic tree */ + ct_data *dyn_tree; /* the dynamic tree */ ct_data *static_tree; /* corresponding static tree or NULL */ - const extra_bits_t *extra_bits; /* extra bits for each code or NULL */ - int extra_base; /* base index for extra_bits */ - int elems; /* max number of elements in the tree */ - int max_length; /* max bit length for the codes */ - int max_code; /* largest code with non zero frequency */ + const extra_bits_t *extra_bits; /* extra bits for each code or NULL */ + int extra_base; /* base index for extra_bits */ + int elems; /* max number of elements in the tree */ + int max_length; /* max bit length for the codes */ + int max_code; /* largest code with non zero frequency */ } tree_desc; static tree_desc l_desc = { dyn_ltree, static_ltree, extra_lbits, LITERALS + 1, L_CODES, - MAX_BITS, 0 }; + MAX_BITS, 0 +}; static tree_desc d_desc = { dyn_dtree, static_dtree, extra_dbits, 0, D_CODES, MAX_BITS, 0 }; static tree_desc bl_desc = { bl_tree, (ct_data *) 0, extra_blbits, 0, BL_CODES, MAX_BL_BITS, - 0 }; + 0 +}; static ush bl_count[MAX_BITS + 1]; @@ -1564,8 +1571,8 @@ static const uch bl_order[BL_CODES] */ static int heap[2 * L_CODES + 1]; /* heap used to build the Huffman trees */ -static int heap_len; /* number of elements in the heap */ -static int heap_max; /* element of largest frequency */ +static int heap_len; /* number of elements in the heap */ +static int heap_max; /* element of largest frequency */ /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. * The same heap array is used to build all trees. @@ -1605,41 +1612,41 @@ static uch flag_buf[(LIT_BUFSIZE / 8)]; * l_buf, thus indicating the presence or absence of a distance. */ -static unsigned last_lit; /* running index in l_buf */ -static unsigned last_dist; /* running index in d_buf */ -static unsigned last_flags; /* running index in flag_buf */ -static uch flags; /* current flags not yet saved in flag_buf */ -static uch flag_bit; /* current bit used in flags */ +static unsigned last_lit; /* running index in l_buf */ +static unsigned last_dist; /* running index in d_buf */ +static unsigned last_flags; /* running index in flag_buf */ +static uch flags; /* current flags not yet saved in flag_buf */ +static uch flag_bit; /* current bit used in flags */ /* bits are filled in flags starting at bit 0 (least significant). * Note: these flags are overkill in the current code since we don't * take advantage of DIST_BUFSIZE == LIT_BUFSIZE. */ -static ulg opt_len; /* bit length of current block with optimal trees */ -static ulg static_len; /* bit length of current block with static trees */ +static ulg opt_len; /* bit length of current block with optimal trees */ +static ulg static_len; /* bit length of current block with static trees */ -static ulg compressed_len; /* total bit length of compressed file */ +static ulg compressed_len; /* total bit length of compressed file */ -static ush *file_type; /* pointer to UNKNOWN, BINARY or ASCII */ -static int *file_method; /* pointer to DEFLATE or STORE */ +static ush *file_type; /* pointer to UNKNOWN, BINARY or ASCII */ +static int *file_method; /* pointer to DEFLATE or STORE */ /* =========================================================================== * Local (static) routines in this file. */ -static void init_block (void); -static void pqdownheap (ct_data * tree, int k); -static void gen_bitlen (tree_desc * desc); -static void gen_codes (ct_data * tree, int max_code); -static void build_tree (tree_desc * desc); -static void scan_tree (ct_data * tree, int max_code); -static void send_tree (ct_data * tree, int max_code); -static int build_bl_tree (void); -static void send_all_trees (int lcodes, int dcodes, int blcodes); -static void compress_block (ct_data * ltree, ct_data * dtree); -static void set_file_type (void); +static void init_block(void); +static void pqdownheap(ct_data * tree, int k); +static void gen_bitlen(tree_desc * desc); +static void gen_codes(ct_data * tree, int max_code); +static void build_tree(tree_desc * desc); +static void scan_tree(ct_data * tree, int max_code); +static void send_tree(ct_data * tree, int max_code); +static int build_bl_tree(void); +static void send_all_trees(int lcodes, int dcodes, int blcodes); +static void compress_block(ct_data * ltree, ct_data * dtree); +static void set_file_type(void); #ifndef DEBUG @@ -1648,7 +1655,7 @@ static void set_file_type (void); #else /* DEBUG */ # define send_code(c, tree) \ - { if (verbose>1) fprintf(stderr,"\ncd %3d ",(c)); \ + { if (verbose>1) bb_error_msg("\ncd %3d ",(c)); \ send_bits(tree[c].Code, tree[c].Len); } #endif @@ -1666,20 +1673,20 @@ static void set_file_type (void); * location of the internal file attribute (ascii/binary) and method * (DEFLATE/STORE). */ -static void ct_init(ush *attr, int *methodp) +static void ct_init(ush * attr, int *methodp) { - int n; /* iterates over tree elements */ - int bits; /* bit counter */ - int length; /* length value */ - int code; /* code value */ - int dist; /* distance index */ + int n; /* iterates over tree elements */ + int bits; /* bit counter */ + int length; /* length value */ + int code; /* code value */ + int dist; /* distance index */ file_type = attr; file_method = methodp; compressed_len = 0L; if (static_dtree[0].Len != 0) - return; /* ct_init already called */ + return; /* ct_init already called */ /* Initialize the mapping length (0..255) -> length code (0..28) */ length = 0; @@ -1705,7 +1712,7 @@ static void ct_init(ush *attr, int *methodp) } } Assert(dist == 256, "ct_init: dist != 256"); - dist >>= 7; /* from now on, all distances are divided by 128 */ + dist >>= 7; /* from now on, all distances are divided by 128 */ for (; code < D_CODES; code++) { base_dist[code] = dist << 7; for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) { @@ -1747,7 +1754,7 @@ static void ct_init(ush *attr, int *methodp) */ static void init_block() { - int n; /* iterates over tree elements */ + int n; /* iterates over tree elements */ /* Initialize the trees. */ for (n = 0; n < L_CODES; n++) @@ -1793,10 +1800,10 @@ static void init_block() * when the heap property is re-established (each father smaller than its * two sons). */ -static void pqdownheap(ct_data *tree, int k) +static void pqdownheap(ct_data * tree, int k) { int v = heap[k]; - int j = k << 1; /* left son of k */ + int j = k << 1; /* left son of k */ while (j <= heap_len) { /* Set j to the smallest of the two sons: */ @@ -1827,7 +1834,7 @@ static void pqdownheap(ct_data *tree, int k) * The length opt_len is updated; static_len is also updated if stree is * not null. */ -static void gen_bitlen(tree_desc *desc) +static void gen_bitlen(tree_desc * desc) { ct_data *tree = desc->dyn_tree; const extra_bits_t *extra = desc->extra_bits; @@ -1835,12 +1842,12 @@ static void gen_bitlen(tree_desc *desc) int max_code = desc->max_code; int max_length = desc->max_length; ct_data *stree = desc->static_tree; - int h; /* heap index */ - int n, m; /* iterate over the tree elements */ - int bits; /* bit length */ - int xbits; /* extra bits */ - ush f; /* frequency */ - int overflow = 0; /* number of elements with bit length too large */ + int h; /* heap index */ + int n, m; /* iterate over the tree elements */ + int bits; /* bit length */ + int xbits; /* extra bits */ + ush f; /* frequency */ + int overflow = 0; /* number of elements with bit length too large */ for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; @@ -1859,7 +1866,7 @@ static void gen_bitlen(tree_desc *desc) /* We overwrite tree[n].Dad which is no longer needed */ if (n > max_code) - continue; /* not a leaf node */ + continue; /* not a leaf node */ bl_count[bits]++; xbits = 0; @@ -1882,7 +1889,7 @@ static void gen_bitlen(tree_desc *desc) bits = max_length - 1; while (bl_count[bits] == 0) bits--; - bl_count[bits]--; /* move one leaf down the tree */ + bl_count[bits]--; /* move one leaf down the tree */ bl_count[bits + 1] += 2; /* move one overflow item as its brother */ bl_count[max_length]--; /* The brother of the overflow item also moves one step up, @@ -1903,12 +1910,10 @@ static void gen_bitlen(tree_desc *desc) if (m > max_code) continue; if (tree[m].Len != (unsigned) bits) { - Trace( - (stderr, "code %d bits %d->%d\n", m, tree[m].Len, + Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits)); opt_len += - ((long) bits - - (long) tree[m].Len) * (long) tree[m].Freq; + ((long) bits - (long) tree[m].Len) * (long) tree[m].Freq; tree[m].Len = (ush) bits; } n--; @@ -1924,12 +1929,12 @@ static void gen_bitlen(tree_desc *desc) * OUT assertion: the field code is set for all tree elements of non * zero code length. */ -static void gen_codes(ct_data *tree, int max_code) +static void gen_codes(ct_data * tree, int max_code) { ush next_code[MAX_BITS + 1]; /* next code value for each bit length */ - ush code = 0; /* running code value */ - int bits; /* bit index */ - int n; /* code index */ + ush code = 0; /* running code value */ + int bits; /* bit index */ + int n; /* code index */ /* The distribution counts are first used to generate the code values * without bit reversal. @@ -1967,14 +1972,14 @@ static void gen_codes(ct_data *tree, int max_code) * and corresponding code. The length opt_len is updated; static_len is * also updated if stree is not null. The field max_code is set. */ -static void build_tree(tree_desc *desc) +static void build_tree(tree_desc * desc) { ct_data *tree = desc->dyn_tree; ct_data *stree = desc->static_tree; int elems = desc->elems; - int n, m; /* iterate over heap elements */ - int max_code = -1; /* largest code with non zero frequency */ - int node = elems; /* next internal node of the tree */ + int n, m; /* iterate over heap elements */ + int max_code = -1; /* largest code with non zero frequency */ + int node = elems; /* next internal node of the tree */ /* Construct the initial heap, with least frequent element in * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. @@ -2018,8 +2023,8 @@ static void build_tree(tree_desc *desc) * frequent nodes. */ do { - pqremove(tree, n); /* n = node of least frequency */ - m = heap[SMALLEST]; /* m = node of next least frequency */ + pqremove(tree, n); /* n = node of least frequency */ + m = heap[SMALLEST]; /* m = node of next least frequency */ heap[--heap_max] = n; /* keep the nodes sorted by frequency */ heap[--heap_max] = m; @@ -2030,9 +2035,8 @@ static void build_tree(tree_desc *desc) tree[n].Dad = tree[m].Dad = (ush) node; #ifdef DUMP_BL_TREE if (tree == bl_tree) { - fprintf(stderr, "\nnode %d(%d), sons %d(%d) %d(%d)", - node, tree[node].Freq, n, tree[n].Freq, m, - tree[m].Freq); + bb_error_msg("\nnode %d(%d), sons %d(%d) %d(%d)", + node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); } #endif /* and insert the new node in the heap */ @@ -2058,15 +2062,15 @@ static void build_tree(tree_desc *desc) * counts. (The contribution of the bit length codes will be added later * during the construction of bl_tree.) */ -static void scan_tree(ct_data *tree, int max_code) +static void scan_tree(ct_data * tree, int max_code) { - int n; /* iterates over all tree elements */ - int prevlen = -1; /* last emitted length */ - int curlen; /* length of current code */ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ int nextlen = tree[0].Len; /* length of next code */ - int count = 0; /* repeat count of the current code */ - int max_count = 7; /* max repeat count */ - int min_count = 4; /* min repeat count */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ if (nextlen == 0) max_count = 138, min_count = 3; @@ -2104,15 +2108,15 @@ static void scan_tree(ct_data *tree, int max_code) * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ -static void send_tree(ct_data *tree, int max_code) +static void send_tree(ct_data * tree, int max_code) { - int n; /* iterates over all tree elements */ - int prevlen = -1; /* last emitted length */ - int curlen; /* length of current code */ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ int nextlen = tree[0].Len; /* length of next code */ - int count = 0; /* repeat count of the current code */ - int max_count = 7; /* max repeat count */ - int min_count = 4; /* min repeat count */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ /* tree[max_code+1].Len = -1; *//* guard already set */ if (nextlen == 0) @@ -2163,7 +2167,7 @@ static void send_tree(ct_data *tree, int max_code) */ static const int build_bl_tree() { - int max_blindex; /* index of last bit length code of non zero freq */ + int max_blindex; /* index of last bit length code of non zero freq */ /* Determine the bit length frequencies for literal and distance trees */ scan_tree((ct_data *) dyn_ltree, l_desc.max_code); @@ -2185,9 +2189,7 @@ static const int build_bl_tree() } /* Update opt_len to include the bit length tree and counts */ opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; - Tracev( - (stderr, "\ndyn trees: dyn %ld, stat %ld", opt_len, - static_len)); + Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", opt_len, static_len)); return max_blindex; } @@ -2199,10 +2201,9 @@ static const int build_bl_tree() */ static void send_all_trees(int lcodes, int dcodes, int blcodes) { - int rank; /* index in bl_order */ + int rank; /* index in bl_order */ - Assert(lcodes >= 257 && dcodes >= 1 - && blcodes >= 4, "not enough codes"); + Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); Assert(lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, "too many codes"); Tracev((stderr, "\nbl counts: ")); @@ -2230,7 +2231,7 @@ static void send_all_trees(int lcodes, int dcodes, int blcodes) static ulg flush_block(char *buf, ulg stored_len, int eof) { ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ - int max_blindex; /* index of last bit length code of non zero freq */ + int max_blindex; /* index of last bit length code of non zero freq */ flag_buf[last_flags] = flags; /* Save the flags for the last 8 items */ @@ -2243,9 +2244,7 @@ static ulg flush_block(char *buf, ulg stored_len, int eof) Tracev((stderr, "\nlit data: dyn %ld, stat %ld", opt_len, static_len)); build_tree((tree_desc *) (&d_desc)); - Tracev( - (stderr, "\ndist data: dyn %ld, stat %ld", opt_len, - static_len)); + Tracev((stderr, "\ndist data: dyn %ld, stat %ld", opt_len, static_len)); /* At this point, opt_len and static_len are the total bit lengths of * the compressed block data, excluding the tree representations. */ @@ -2259,8 +2258,7 @@ static ulg flush_block(char *buf, ulg stored_len, int eof) opt_lenb = (opt_len + 3 + 7) >> 3; static_lenb = (static_len + 3 + 7) >> 3; - Trace( - (stderr, + Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ", opt_lenb, opt_len, static_lenb, static_len, stored_len, last_lit, last_dist)); @@ -2272,11 +2270,10 @@ static ulg flush_block(char *buf, ulg stored_len, int eof) * and if the zip file can be seeked (to rewrite the local header), * the whole file is transformed into a stored file: */ - if (stored_len <= opt_lenb && eof && compressed_len == 0L - && seekable()) { + if (stored_len <= opt_lenb && eof && compressed_len == 0L && seekable()) { /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */ if (buf == (char *) 0) - error_msg("block vanished"); + bb_error_msg("block vanished"); copy_block(buf, (unsigned) stored_len, 0); /* without header */ compressed_len = stored_len << 3; @@ -2298,15 +2295,13 @@ static ulg flush_block(char *buf, ulg stored_len, int eof) } else if (static_lenb == opt_lenb) { send_bits((STATIC_TREES << 1) + eof, 3); - compress_block((ct_data *) static_ltree, - (ct_data *) static_dtree); + compress_block((ct_data *) static_ltree, (ct_data *) static_dtree); compressed_len += 3 + static_len; } else { send_bits((DYN_TREES << 1) + eof, 3); send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1, max_blindex + 1); - compress_block((ct_data *) dyn_ltree, - (ct_data *) dyn_dtree); + compress_block((ct_data *) dyn_ltree, (ct_data *) dyn_dtree); compressed_len += 3 + opt_len; } Assert(compressed_len == bits_sent, "bad compressed size"); @@ -2334,7 +2329,7 @@ static int ct_tally(int dist, int lc) dyn_ltree[lc].Freq++; } else { /* Here, lc is the match length - MIN_MATCH */ - dist--; /* dist = match distance - 1 */ + dist--; /* dist = match distance - 1 */ Assert((ush) dist < (ush) MAX_DIST && (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH) && (ush) d_code(dist) < (ush) D_CODES, "ct_tally: bad match"); @@ -2364,8 +2359,7 @@ static int ct_tally(int dist, int lc) (ulg) dyn_dtree[dcode].Freq * (5L + extra_dbits[dcode]); } out_length >>= 3; - Trace( - (stderr, + Trace((stderr, "\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ", last_lit, last_dist, in_length, out_length, 100L - out_length * 100L / in_length)); @@ -2382,16 +2376,16 @@ static int ct_tally(int dist, int lc) /* =========================================================================== * Send the block data compressed using the given Huffman trees */ -static void compress_block(ct_data *ltree, ct_data *dtree) +static void compress_block(ct_data * ltree, ct_data * dtree) { - unsigned dist; /* distance of matched string */ - int lc; /* match length or unmatched char (if dist == 0) */ - unsigned lx = 0; /* running index in l_buf */ - unsigned dx = 0; /* running index in d_buf */ - unsigned fx = 0; /* running index in flag_buf */ - uch flag = 0; /* current flags */ - unsigned code; /* the code to send */ - int extra; /* number of extra bits to send */ + unsigned dist; /* distance of matched string */ + int lc; /* match length or unmatched char (if dist == 0) */ + unsigned lx = 0; /* running index in l_buf */ + unsigned dx = 0; /* running index in d_buf */ + unsigned fx = 0; /* running index in flag_buf */ + uch flag = 0; /* current flags */ + unsigned code; /* the code to send */ + int extra; /* number of extra bits to send */ if (last_lit != 0) do { @@ -2421,7 +2415,7 @@ static void compress_block(ct_data *ltree, ct_data *dtree) dist -= base_dist[code]; send_bits(dist, extra); /* send the extra distance bits */ } - } /* literal or match pair ? */ + } /* literal or match pair ? */ flag >>= 1; } while (lx < last_lit); @@ -2448,7 +2442,7 @@ static void set_file_type() bin_freq += dyn_ltree[n++].Freq; *file_type = bin_freq > (ascii_freq >> 2) ? BINARY : ASCII; if (*file_type == BINARY && translate_eol) { - error_msg("-l used on binary file"); + bb_error_msg("-l used on binary file"); } } @@ -2459,24 +2453,13 @@ static void set_file_type() */ -static ulg crc; /* crc on uncompressed file data */ -static long header_bytes; /* number of bytes in gzip header */ - -static void put_short_when_full(ush w) -{ - put_byte((uch)((w) & 0xff)); - put_byte((uch)((ush)(w) >> 8)); -} - -static void put_short_function(ush n) -{ - put_short(n); -} +static ulg crc; /* crc on uncompressed file data */ +static long header_bytes; /* number of bytes in gzip header */ static void put_long(ulg n) { - put_short_function((n) & 0xffff); - put_short_function(((ulg)(n)) >> 16); + put_short((n) & 0xffff); + put_short(((ulg) (n)) >> 16); } /* put_header_byte is used for the compressed output @@ -2491,9 +2474,9 @@ static void put_long(ulg n) */ static int zip(int in, int out) { - uch my_flags = 0; /* general purpose bit flags */ - ush attr = 0; /* ascii/binary flag */ - ush deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */ + uch my_flags = 0; /* general purpose bit flags */ + ush attr = 0; /* ascii/binary flag */ + ush deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */ ifd = in; ofd = out; @@ -2503,11 +2486,11 @@ static int zip(int in, int out) method = DEFLATED; - put_header_byte(GZIP_MAGIC[0]); /* magic header */ + put_header_byte(GZIP_MAGIC[0]); /* magic header */ put_header_byte(GZIP_MAGIC[1]); - put_header_byte(DEFLATED); /* compression method */ + put_header_byte(DEFLATED); /* compression method */ - put_header_byte(my_flags); /* general flags */ + put_header_byte(my_flags); /* general flags */ put_long(time_stamp); /* Write deflated file to zip file */ @@ -2518,7 +2501,7 @@ static int zip(int in, int out) lm_init(&deflate_flags); put_byte((uch) deflate_flags); /* extra flags */ - put_byte(OS_CODE); /* OS identifier */ + put_byte(OS_CODE); /* OS identifier */ header_bytes = (long) outcnt;