Update zlib from version 1.2.5 to 1.2.11
This commit is contained in:
Vendored
+21
-18
@@ -1,7 +1,7 @@
|
||||
/* enough.c -- determine the maximum size of inflate's Huffman code tables over
|
||||
* all possible valid and complete Huffman codes, subject to a length limit.
|
||||
* Copyright (C) 2007, 2008 Mark Adler
|
||||
* Version 1.3 17 February 2008 Mark Adler
|
||||
* Copyright (C) 2007, 2008, 2012 Mark Adler
|
||||
* Version 1.4 18 August 2012 Mark Adler
|
||||
*/
|
||||
|
||||
/* Version history:
|
||||
@@ -14,6 +14,9 @@
|
||||
1.3 17 Feb 2008 Add argument for initial root table size
|
||||
Fix bug for initial root table size == max - 1
|
||||
Use a macro to compute the history index
|
||||
1.4 18 Aug 2012 Avoid shifts more than bits in type (caused endless loop!)
|
||||
Clean up comparisons of different types
|
||||
Clean up code indentation
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -236,8 +239,8 @@ local big_t count(int syms, int len, int left)
|
||||
for (use = least; use <= most; use++) {
|
||||
got = count(syms - use, len + 1, (left - use) << 1);
|
||||
sum += got;
|
||||
if (got == -1 || sum < got) /* overflow */
|
||||
return -1;
|
||||
if (got == (big_t)0 - 1 || sum < got) /* overflow */
|
||||
return (big_t)0 - 1;
|
||||
}
|
||||
|
||||
/* verify that all recursive calls are productive */
|
||||
@@ -458,6 +461,7 @@ int main(int argc, char **argv)
|
||||
int n; /* number of symbols to code for this run */
|
||||
big_t got; /* return value of count() */
|
||||
big_t sum; /* accumulated number of codes over n */
|
||||
code_t word; /* for counting bits in code_t */
|
||||
|
||||
/* set up globals for cleanup() */
|
||||
code = NULL;
|
||||
@@ -466,19 +470,19 @@ int main(int argc, char **argv)
|
||||
|
||||
/* get arguments -- default to the deflate literal/length code */
|
||||
syms = 286;
|
||||
root = 9;
|
||||
root = 9;
|
||||
max = 15;
|
||||
if (argc > 1) {
|
||||
syms = atoi(argv[1]);
|
||||
if (argc > 2) {
|
||||
root = atoi(argv[2]);
|
||||
if (argc > 3)
|
||||
max = atoi(argv[3]);
|
||||
}
|
||||
if (argc > 3)
|
||||
max = atoi(argv[3]);
|
||||
}
|
||||
}
|
||||
if (argc > 4 || syms < 2 || root < 1 || max < 1) {
|
||||
fputs("invalid arguments, need: [sym >= 2 [root >= 1 [max >= 1]]]\n",
|
||||
stderr);
|
||||
stderr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -487,18 +491,17 @@ int main(int argc, char **argv)
|
||||
max = syms - 1;
|
||||
|
||||
/* determine the number of bits in a code_t */
|
||||
n = 0;
|
||||
while (((code_t)1 << n) != 0)
|
||||
n++;
|
||||
for (n = 0, word = 1; word; n++, word <<= 1)
|
||||
;
|
||||
|
||||
/* make sure that the calculation of most will not overflow */
|
||||
if (max > n || syms - 2 >= (((code_t)0 - 1) >> (max - 1))) {
|
||||
if (max > n || (code_t)(syms - 2) >= (((code_t)0 - 1) >> (max - 1))) {
|
||||
fputs("abort: code length too long for internal types\n", stderr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* reject impossible code requests */
|
||||
if (syms - 1 > ((code_t)1 << max) - 1) {
|
||||
if ((code_t)(syms - 1) > ((code_t)1 << max) - 1) {
|
||||
fprintf(stderr, "%d symbols cannot be coded in %d bits\n",
|
||||
syms, max);
|
||||
return 1;
|
||||
@@ -532,7 +535,7 @@ int main(int argc, char **argv)
|
||||
for (n = 2; n <= syms; n++) {
|
||||
got = count(n, 1, 2);
|
||||
sum += got;
|
||||
if (got == -1 || sum < got) { /* overflow */
|
||||
if (got == (big_t)0 - 1 || sum < got) { /* overflow */
|
||||
fputs("abort: can't count that high!\n", stderr);
|
||||
cleanup();
|
||||
return 1;
|
||||
@@ -556,9 +559,9 @@ int main(int argc, char **argv)
|
||||
}
|
||||
|
||||
/* find and show maximum inflate table usage */
|
||||
if (root > max) /* reduce root to max length */
|
||||
root = max;
|
||||
if (syms < ((code_t)1 << (root + 1)))
|
||||
if (root > max) /* reduce root to max length */
|
||||
root = max;
|
||||
if ((code_t)syms < ((code_t)1 << (root + 1)))
|
||||
enough(syms);
|
||||
else
|
||||
puts("cannot handle minimum code lengths > root");
|
||||
|
||||
Vendored
+7
-6
@@ -1,7 +1,7 @@
|
||||
/* gun.c -- simple gunzip to give an example of the use of inflateBack()
|
||||
* Copyright (C) 2003, 2005, 2008, 2010 Mark Adler
|
||||
* Copyright (C) 2003, 2005, 2008, 2010, 2012 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
Version 1.6 17 January 2010 Mark Adler */
|
||||
Version 1.7 12 August 2012 Mark Adler */
|
||||
|
||||
/* Version history:
|
||||
1.0 16 Feb 2003 First version for testing of inflateBack()
|
||||
@@ -18,6 +18,7 @@
|
||||
1.4 8 Dec 2006 LZW decompression speed improvements
|
||||
1.5 9 Feb 2008 Avoid warning in latest version of gcc
|
||||
1.6 17 Jan 2010 Avoid signed/unsigned comparison warnings
|
||||
1.7 12 Aug 2012 Update for z_const usage in zlib 1.2.8
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -45,7 +46,7 @@
|
||||
end-of-file, they cannot be concantenated. If a Unix compress stream is
|
||||
encountered in an input file, it is the last stream in that file.
|
||||
|
||||
Like gunzip and uncompress, the file attributes of the orignal compressed
|
||||
Like gunzip and uncompress, the file attributes of the original compressed
|
||||
file are maintained in the final uncompressed file, to the extent that the
|
||||
user permissions allow it.
|
||||
|
||||
@@ -85,7 +86,7 @@ struct ind {
|
||||
/* Load input buffer, assumed to be empty, and return bytes loaded and a
|
||||
pointer to them. read() is called until the buffer is full, or until it
|
||||
returns end-of-file or error. Return 0 on error. */
|
||||
local unsigned in(void *in_desc, unsigned char **buf)
|
||||
local unsigned in(void *in_desc, z_const unsigned char **buf)
|
||||
{
|
||||
int ret;
|
||||
unsigned len;
|
||||
@@ -196,7 +197,7 @@ unsigned char match[65280 + 2]; /* buffer for reversed match or gzip
|
||||
file, read error, or write error (a write error indicated by strm->next_in
|
||||
not equal to Z_NULL), or Z_DATA_ERROR for invalid input.
|
||||
*/
|
||||
local int lunpipe(unsigned have, unsigned char *next, struct ind *indp,
|
||||
local int lunpipe(unsigned have, z_const unsigned char *next, struct ind *indp,
|
||||
int outfile, z_stream *strm)
|
||||
{
|
||||
int last; /* last byte read by NEXT(), or -1 if EOF */
|
||||
@@ -383,7 +384,7 @@ local int gunpipe(z_stream *strm, int infile, int outfile)
|
||||
{
|
||||
int ret, first, last;
|
||||
unsigned have, flags, len;
|
||||
unsigned char *next = NULL;
|
||||
z_const unsigned char *next = NULL;
|
||||
struct ind ind, *indp;
|
||||
struct outd outd;
|
||||
|
||||
|
||||
Vendored
+13
-9
@@ -1,7 +1,7 @@
|
||||
/* gzappend -- command to append to a gzip file
|
||||
|
||||
Copyright (C) 2003 Mark Adler, all rights reserved
|
||||
version 1.1, 4 Nov 2003
|
||||
Copyright (C) 2003, 2012 Mark Adler, all rights reserved
|
||||
version 1.2, 11 Oct 2012
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the author be held liable for any damages
|
||||
@@ -39,6 +39,8 @@
|
||||
* - Keep gzip file clean on appended file read errors
|
||||
* - Use in-place rotate instead of auxiliary buffer
|
||||
* (Why you ask? Because it was fun to write!)
|
||||
* 1.2 11 Oct 2012 - Fix for proper z_const usage
|
||||
* - Check for input buffer malloc failure
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -170,7 +172,7 @@ typedef struct {
|
||||
int size; /* 1 << size is bytes in buf */
|
||||
unsigned left; /* bytes available at next */
|
||||
unsigned char *buf; /* buffer */
|
||||
unsigned char *next; /* next byte in buffer */
|
||||
z_const unsigned char *next; /* next byte in buffer */
|
||||
char *name; /* file name for error messages */
|
||||
} file;
|
||||
|
||||
@@ -399,14 +401,14 @@ local void gztack(char *name, int gd, z_stream *strm, int last)
|
||||
}
|
||||
|
||||
/* allocate buffers */
|
||||
in = fd == -1 ? NULL : malloc(CHUNK);
|
||||
in = malloc(CHUNK);
|
||||
out = malloc(CHUNK);
|
||||
if (out == NULL) bye("out of memory", "");
|
||||
if (in == NULL || out == NULL) bye("out of memory", "");
|
||||
|
||||
/* compress input file and append to gzip file */
|
||||
do {
|
||||
/* get more input */
|
||||
len = fd == -1 ? 0 : read(fd, in, CHUNK);
|
||||
len = read(fd, in, CHUNK);
|
||||
if (len == -1) {
|
||||
fprintf(stderr,
|
||||
"gzappend warning: error reading %s, skipping rest ...\n",
|
||||
@@ -453,7 +455,7 @@ local void gztack(char *name, int gd, z_stream *strm, int last)
|
||||
|
||||
/* clean up and return */
|
||||
free(out);
|
||||
if (in != NULL) free(in);
|
||||
free(in);
|
||||
if (fd > 0) close(fd);
|
||||
}
|
||||
|
||||
@@ -467,11 +469,13 @@ int main(int argc, char **argv)
|
||||
z_stream strm;
|
||||
|
||||
/* ignore command name */
|
||||
argv++;
|
||||
argc--; argv++;
|
||||
|
||||
/* provide usage if no arguments */
|
||||
if (*argv == NULL) {
|
||||
printf("gzappend 1.1 (4 Nov 2003) Copyright (C) 2003 Mark Adler\n");
|
||||
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;
|
||||
|
||||
Vendored
+7
-6
@@ -1,7 +1,7 @@
|
||||
/* gzjoin -- command to join gzip files into one gzip file
|
||||
|
||||
Copyright (C) 2004 Mark Adler, all rights reserved
|
||||
version 1.0, 11 Dec 2004
|
||||
Copyright (C) 2004, 2005, 2012 Mark Adler, all rights reserved
|
||||
version 1.2, 14 Aug 2012
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the author be held liable for any damages
|
||||
@@ -27,6 +27,7 @@
|
||||
*
|
||||
* 1.0 11 Dec 2004 - First version
|
||||
* 1.1 12 Jun 2005 - Changed ssize_t to long for portability
|
||||
* 1.2 14 Aug 2012 - Clean up for z_const usage
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -308,7 +309,7 @@ local void gzcopy(char *name, int clr, unsigned long *crc, unsigned long *tot,
|
||||
/* inflate and copy compressed data, clear last-block bit if requested */
|
||||
len = 0;
|
||||
zpull(&strm, in);
|
||||
start = strm.next_in;
|
||||
start = in->next;
|
||||
last = start[0] & 1;
|
||||
if (last && clr)
|
||||
start[0] &= ~1;
|
||||
@@ -351,7 +352,7 @@ local void gzcopy(char *name, int clr, unsigned long *crc, unsigned long *tot,
|
||||
pos = 0x100 >> pos;
|
||||
last = strm.next_in[-1] & pos;
|
||||
if (last && clr)
|
||||
strm.next_in[-1] &= ~pos;
|
||||
in->buf[strm.next_in - in->buf - 1] &= ~pos;
|
||||
}
|
||||
else {
|
||||
/* next last-block bit is in next unused byte */
|
||||
@@ -364,14 +365,14 @@ local void gzcopy(char *name, int clr, unsigned long *crc, unsigned long *tot,
|
||||
}
|
||||
last = strm.next_in[0] & 1;
|
||||
if (last && clr)
|
||||
strm.next_in[0] &= ~1;
|
||||
in->buf[strm.next_in - in->buf] &= ~1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* update buffer with unused input */
|
||||
in->left = strm.avail_in;
|
||||
in->next = strm.next_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;
|
||||
|
||||
Vendored
+12
-11
@@ -1,8 +1,8 @@
|
||||
/*
|
||||
* gzlog.c
|
||||
* Copyright (C) 2004, 2008 Mark Adler, all rights reserved
|
||||
* Copyright (C) 2004, 2008, 2012, 2016 Mark Adler, all rights reserved
|
||||
* For conditions of distribution and use, see copyright notice in gzlog.h
|
||||
* version 2.0, 25 Apr 2008
|
||||
* version 2.2, 14 Aug 2012
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -243,7 +243,7 @@ typedef unsigned int uint;
|
||||
typedef unsigned long ulong;
|
||||
|
||||
/* Macro for debugging to deterministically force recovery operations */
|
||||
#ifdef DEBUG
|
||||
#ifdef GZLOG_DEBUG
|
||||
#include <setjmp.h> /* longjmp */
|
||||
jmp_buf gzlog_jump; /* where to go back to */
|
||||
int gzlog_bail = 0; /* which point to bail at (1..8) */
|
||||
@@ -750,7 +750,8 @@ local int log_recover(struct log *log, int op)
|
||||
strcpy(log->end, ".add");
|
||||
if (stat(log->path, &st) == 0 && st.st_size) {
|
||||
len = (size_t)(st.st_size);
|
||||
if (len != st.st_size || (data = malloc(st.st_size)) == NULL) {
|
||||
if ((off_t)len != st.st_size ||
|
||||
(data = malloc(st.st_size)) == NULL) {
|
||||
log_log(log, op, "allocation failure");
|
||||
return -2;
|
||||
}
|
||||
@@ -758,7 +759,7 @@ local int log_recover(struct log *log, int op)
|
||||
log_log(log, op, ".add file read failure");
|
||||
return -1;
|
||||
}
|
||||
ret = read(fd, data, len) != len;
|
||||
ret = (size_t)read(fd, data, len) != len;
|
||||
close(fd);
|
||||
if (ret) {
|
||||
log_log(log, op, ".add file read failure");
|
||||
@@ -913,7 +914,7 @@ int gzlog_compress(gzlog *logd)
|
||||
struct log *log = logd;
|
||||
|
||||
/* check arguments */
|
||||
if (log == NULL || strcmp(log->id, LOGID) || len < 0)
|
||||
if (log == NULL || strcmp(log->id, LOGID))
|
||||
return -3;
|
||||
|
||||
/* see if we lost the lock -- if so get it again and reload the extra
|
||||
@@ -952,7 +953,7 @@ int gzlog_compress(gzlog *logd)
|
||||
fd = open(log->path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
|
||||
if (fd < 0)
|
||||
break;
|
||||
ret = write(fd, data, len) != len;
|
||||
ret = (size_t)write(fd, data, len) != len;
|
||||
if (ret | close(fd))
|
||||
break;
|
||||
log_touch(log);
|
||||
@@ -963,7 +964,7 @@ int gzlog_compress(gzlog *logd)
|
||||
if (fd < 0)
|
||||
break;
|
||||
next = DICT > len ? len : DICT;
|
||||
ret = write(fd, (char *)data + len - next, next) != next;
|
||||
ret = (size_t)write(fd, (char *)data + len - next, next) != next;
|
||||
if (ret | close(fd))
|
||||
break;
|
||||
log_touch(log);
|
||||
@@ -997,9 +998,9 @@ int gzlog_write(gzlog *logd, void *data, size_t len)
|
||||
struct log *log = logd;
|
||||
|
||||
/* check arguments */
|
||||
if (log == NULL || strcmp(log->id, LOGID) || len < 0)
|
||||
if (log == NULL || strcmp(log->id, LOGID))
|
||||
return -3;
|
||||
if (data == NULL || len == 0)
|
||||
if (data == NULL || len <= 0)
|
||||
return 0;
|
||||
|
||||
/* see if we lost the lock -- if so get it again and reload the extra
|
||||
@@ -1013,7 +1014,7 @@ int gzlog_write(gzlog *logd, void *data, size_t len)
|
||||
fd = open(log->path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
|
||||
if (fd < 0)
|
||||
return -1;
|
||||
ret = write(fd, data, len) != len;
|
||||
ret = (size_t)write(fd, data, len) != len;
|
||||
if (ret | close(fd))
|
||||
return -1;
|
||||
log_touch(log);
|
||||
|
||||
Vendored
+4
-2
@@ -1,6 +1,6 @@
|
||||
/* gzlog.h
|
||||
Copyright (C) 2004, 2008 Mark Adler, all rights reserved
|
||||
version 2.0, 25 Apr 2008
|
||||
Copyright (C) 2004, 2008, 2012 Mark Adler, all rights reserved
|
||||
version 2.2, 14 Aug 2012
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the author be held liable for any damages
|
||||
@@ -27,6 +27,8 @@
|
||||
Interface changed slightly in that now path is a prefix
|
||||
Compression now occurs as needed during gzlog_write()
|
||||
gzlog_write() now always leaves the log file as valid gzip
|
||||
2.1 8 Jul 2012 Fix argument checks in gzlog_compress() and gzlog_write()
|
||||
2.2 14 Aug 2012 Clean up signed comparisons
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Vendored
+9
-4
@@ -1,7 +1,12 @@
|
||||
/* zran.c -- example of zlib/gzip stream indexing and random access
|
||||
* Copyright (C) 2005 Mark Adler
|
||||
* Copyright (C) 2005, 2012 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
Version 1.0 29 May 2005 Mark Adler */
|
||||
Version 1.1 29 Sep 2012 Mark Adler */
|
||||
|
||||
/* Version History:
|
||||
1.0 29 May 2005 First version
|
||||
1.1 29 Sep 2012 Fix memory reallocation error
|
||||
*/
|
||||
|
||||
/* Illustrate the use of Z_BLOCK, inflatePrime(), and inflateSetDictionary()
|
||||
for random access of a compressed file. A file containing a zlib or gzip
|
||||
@@ -22,7 +27,7 @@
|
||||
grows as needed to accommodate the points.
|
||||
|
||||
To use the index, an offset in the uncompressed data is provided, for which
|
||||
the latest accees point at or preceding that offset is located in the index.
|
||||
the latest access point at or preceding that offset is located in the index.
|
||||
The input file is positioned to the specified location in the index, and if
|
||||
necessary the first few bits of the compressed data is read from the file.
|
||||
inflate is initialized with those bits and the 32K of uncompressed data, and
|
||||
@@ -221,7 +226,7 @@ local int build_index(FILE *in, off_t span, struct access **built)
|
||||
|
||||
/* clean up and return index (release unused entries in list) */
|
||||
(void)inflateEnd(&strm);
|
||||
index = realloc(index, sizeof(struct point) * index->have);
|
||||
index->list = realloc(index->list, sizeof(struct point) * index->have);
|
||||
index->size = index->have;
|
||||
*built = index;
|
||||
return index->size;
|
||||
|
||||
Reference in New Issue
Block a user