зеркало из https://github.com/microsoft/git.git
Merge branch 'jc/zlib-wrap' into maint
* jc/zlib-wrap: zlib: allow feeding more than 4GB in one go zlib: zlib can only process 4GB at a time zlib: wrap deflateBound() too zlib: wrap deflate side of the API zlib: wrap inflateInit2 used to accept only for gzip format zlib: wrap remaining calls to direct inflate/inflateEnd zlib wrapper: refactor error message formatter
This commit is contained in:
Коммит
a35d78c0f4
|
@ -90,14 +90,14 @@ static void copy_le32(unsigned char *dest, unsigned int n)
|
|||
static void *zlib_deflate(void *data, unsigned long size,
|
||||
int compression_level, unsigned long *compressed_size)
|
||||
{
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
unsigned long maxsize;
|
||||
void *buffer;
|
||||
int result;
|
||||
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
deflateInit(&stream, compression_level);
|
||||
maxsize = deflateBound(&stream, size);
|
||||
git_deflate_init(&stream, compression_level);
|
||||
maxsize = git_deflate_bound(&stream, size);
|
||||
buffer = xmalloc(maxsize);
|
||||
|
||||
stream.next_in = data;
|
||||
|
@ -106,7 +106,7 @@ static void *zlib_deflate(void *data, unsigned long size,
|
|||
stream.avail_out = maxsize;
|
||||
|
||||
do {
|
||||
result = deflate(&stream, Z_FINISH);
|
||||
result = git_deflate(&stream, Z_FINISH);
|
||||
} while (result == Z_OK);
|
||||
|
||||
if (result != Z_STREAM_END) {
|
||||
|
@ -114,7 +114,7 @@ static void *zlib_deflate(void *data, unsigned long size,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
deflateEnd(&stream);
|
||||
git_deflate_end(&stream);
|
||||
*compressed_size = stream.total_out;
|
||||
|
||||
return buffer;
|
||||
|
|
|
@ -1634,7 +1634,7 @@ static inline int metadata_changes(struct patch *patch)
|
|||
static char *inflate_it(const void *data, unsigned long size,
|
||||
unsigned long inflated_size)
|
||||
{
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
void *out;
|
||||
int st;
|
||||
|
||||
|
|
|
@ -265,7 +265,7 @@ static void unlink_base_data(struct base_data *c)
|
|||
static void *unpack_entry_data(unsigned long offset, unsigned long size)
|
||||
{
|
||||
int status;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
void *buf = xmalloc(size);
|
||||
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
|
@ -355,7 +355,7 @@ static void *get_data_from_pack(struct object_entry *obj)
|
|||
off_t from = obj[0].idx.offset + obj[0].hdr_size;
|
||||
unsigned long len = obj[1].idx.offset - from;
|
||||
unsigned char *data, *inbuf;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
int status;
|
||||
|
||||
data = xmalloc(obj->size);
|
||||
|
@ -666,26 +666,26 @@ static void parse_pack_objects(unsigned char *sha1)
|
|||
|
||||
static int write_compressed(struct sha1file *f, void *in, unsigned int size)
|
||||
{
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
int status;
|
||||
unsigned char outbuf[4096];
|
||||
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
deflateInit(&stream, zlib_compression_level);
|
||||
git_deflate_init(&stream, zlib_compression_level);
|
||||
stream.next_in = in;
|
||||
stream.avail_in = size;
|
||||
|
||||
do {
|
||||
stream.next_out = outbuf;
|
||||
stream.avail_out = sizeof(outbuf);
|
||||
status = deflate(&stream, Z_FINISH);
|
||||
status = git_deflate(&stream, Z_FINISH);
|
||||
sha1write(f, outbuf, sizeof(outbuf) - stream.avail_out);
|
||||
} while (status == Z_OK);
|
||||
|
||||
if (status != Z_STREAM_END)
|
||||
die("unable to deflate appended object (%d)", status);
|
||||
size = stream.total_out;
|
||||
deflateEnd(&stream);
|
||||
git_deflate_end(&stream);
|
||||
return size;
|
||||
}
|
||||
|
||||
|
|
|
@ -126,13 +126,13 @@ static void *get_delta(struct object_entry *entry)
|
|||
|
||||
static unsigned long do_compress(void **pptr, unsigned long size)
|
||||
{
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
void *in, *out;
|
||||
unsigned long maxsize;
|
||||
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
deflateInit(&stream, pack_compression_level);
|
||||
maxsize = deflateBound(&stream, size);
|
||||
git_deflate_init(&stream, pack_compression_level);
|
||||
maxsize = git_deflate_bound(&stream, size);
|
||||
|
||||
in = *pptr;
|
||||
out = xmalloc(maxsize);
|
||||
|
@ -142,9 +142,9 @@ static unsigned long do_compress(void **pptr, unsigned long size)
|
|||
stream.avail_in = size;
|
||||
stream.next_out = out;
|
||||
stream.avail_out = maxsize;
|
||||
while (deflate(&stream, Z_FINISH) == Z_OK)
|
||||
while (git_deflate(&stream, Z_FINISH) == Z_OK)
|
||||
; /* nothing */
|
||||
deflateEnd(&stream);
|
||||
git_deflate_end(&stream);
|
||||
|
||||
free(in);
|
||||
return stream.total_out;
|
||||
|
@ -160,7 +160,7 @@ static int check_pack_inflate(struct packed_git *p,
|
|||
off_t len,
|
||||
unsigned long expect)
|
||||
{
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
unsigned char fakebuf[4096], *in;
|
||||
int st;
|
||||
|
||||
|
@ -187,12 +187,12 @@ static void copy_pack_data(struct sha1file *f,
|
|||
off_t len)
|
||||
{
|
||||
unsigned char *in;
|
||||
unsigned int avail;
|
||||
unsigned long avail;
|
||||
|
||||
while (len) {
|
||||
in = use_pack(p, w_curs, offset, &avail);
|
||||
if (avail > len)
|
||||
avail = (unsigned int)len;
|
||||
avail = (unsigned long)len;
|
||||
sha1write(f, in, avail);
|
||||
offset += avail;
|
||||
len -= avail;
|
||||
|
@ -994,7 +994,7 @@ static void check_object(struct object_entry *entry)
|
|||
const unsigned char *base_ref = NULL;
|
||||
struct object_entry *base_entry;
|
||||
unsigned long used, used_0;
|
||||
unsigned int avail;
|
||||
unsigned long avail;
|
||||
off_t ofs;
|
||||
unsigned char *buf, c;
|
||||
|
||||
|
|
|
@ -90,7 +90,7 @@ static void use(int bytes)
|
|||
|
||||
static void *get_data(unsigned long size)
|
||||
{
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
void *buf = xmalloc(size);
|
||||
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
|
|
28
cache.h
28
cache.h
|
@ -16,13 +16,27 @@
|
|||
#endif
|
||||
|
||||
#include <zlib.h>
|
||||
#if defined(NO_DEFLATE_BOUND) || ZLIB_VERNUM < 0x1200
|
||||
#define deflateBound(c,s) ((s) + (((s) + 7) >> 3) + (((s) + 63) >> 6) + 11)
|
||||
#endif
|
||||
typedef struct git_zstream {
|
||||
z_stream z;
|
||||
unsigned long avail_in;
|
||||
unsigned long avail_out;
|
||||
unsigned long total_in;
|
||||
unsigned long total_out;
|
||||
unsigned char *next_in;
|
||||
unsigned char *next_out;
|
||||
} git_zstream;
|
||||
|
||||
void git_inflate_init(z_streamp strm);
|
||||
void git_inflate_end(z_streamp strm);
|
||||
int git_inflate(z_streamp strm, int flush);
|
||||
void git_inflate_init(git_zstream *);
|
||||
void git_inflate_init_gzip_only(git_zstream *);
|
||||
void git_inflate_end(git_zstream *);
|
||||
int git_inflate(git_zstream *, int flush);
|
||||
|
||||
void git_deflate_init(git_zstream *, int level);
|
||||
void git_deflate_init_gzip(git_zstream *, int level);
|
||||
void git_deflate_end(git_zstream *);
|
||||
int git_deflate_end_gently(git_zstream *);
|
||||
int git_deflate(git_zstream *, int flush);
|
||||
unsigned long git_deflate_bound(git_zstream *, unsigned long);
|
||||
|
||||
#if defined(DT_UNKNOWN) && !defined(NO_D_TYPE_IN_DIRENT)
|
||||
#define DTYPE(de) ((de)->d_type)
|
||||
|
@ -1009,7 +1023,7 @@ extern struct packed_git *find_sha1_pack(const unsigned char *sha1,
|
|||
extern void pack_report(void);
|
||||
extern int open_pack_index(struct packed_git *);
|
||||
extern void close_pack_index(struct packed_git *);
|
||||
extern unsigned char *use_pack(struct packed_git *, struct pack_window **, off_t, unsigned int *);
|
||||
extern unsigned char *use_pack(struct packed_git *, struct pack_window **, off_t, unsigned long *);
|
||||
extern void close_pack_windows(struct packed_git *);
|
||||
extern void unuse_pack(struct pack_window **);
|
||||
extern void free_pack_by_name(const char *);
|
||||
|
|
10
diff.c
10
diff.c
|
@ -1839,20 +1839,20 @@ static unsigned char *deflate_it(char *data,
|
|||
{
|
||||
int bound;
|
||||
unsigned char *deflated;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
deflateInit(&stream, zlib_compression_level);
|
||||
bound = deflateBound(&stream, size);
|
||||
git_deflate_init(&stream, zlib_compression_level);
|
||||
bound = git_deflate_bound(&stream, size);
|
||||
deflated = xmalloc(bound);
|
||||
stream.next_out = deflated;
|
||||
stream.avail_out = bound;
|
||||
|
||||
stream.next_in = (unsigned char *)data;
|
||||
stream.avail_in = size;
|
||||
while (deflate(&stream, Z_FINISH) == Z_OK)
|
||||
while (git_deflate(&stream, Z_FINISH) == Z_OK)
|
||||
; /* nothing */
|
||||
deflateEnd(&stream);
|
||||
git_deflate_end(&stream);
|
||||
*result_size = stream.total_out;
|
||||
return deflated;
|
||||
}
|
||||
|
|
|
@ -1017,7 +1017,7 @@ static int store_object(
|
|||
unsigned char sha1[20];
|
||||
unsigned long hdrlen, deltalen;
|
||||
git_SHA_CTX c;
|
||||
z_stream s;
|
||||
git_zstream s;
|
||||
|
||||
hdrlen = sprintf((char *)hdr,"%s %lu", typename(type),
|
||||
(unsigned long)dat->len) + 1;
|
||||
|
@ -1050,7 +1050,7 @@ static int store_object(
|
|||
delta = NULL;
|
||||
|
||||
memset(&s, 0, sizeof(s));
|
||||
deflateInit(&s, pack_compression_level);
|
||||
git_deflate_init(&s, pack_compression_level);
|
||||
if (delta) {
|
||||
s.next_in = delta;
|
||||
s.avail_in = deltalen;
|
||||
|
@ -1058,11 +1058,11 @@ static int store_object(
|
|||
s.next_in = (void *)dat->buf;
|
||||
s.avail_in = dat->len;
|
||||
}
|
||||
s.avail_out = deflateBound(&s, s.avail_in);
|
||||
s.avail_out = git_deflate_bound(&s, s.avail_in);
|
||||
s.next_out = out = xmalloc(s.avail_out);
|
||||
while (deflate(&s, Z_FINISH) == Z_OK)
|
||||
/* nothing */;
|
||||
deflateEnd(&s);
|
||||
while (git_deflate(&s, Z_FINISH) == Z_OK)
|
||||
; /* nothing */
|
||||
git_deflate_end(&s);
|
||||
|
||||
/* Determine if we should auto-checkpoint. */
|
||||
if ((max_packsize && (pack_size + 60 + s.total_out) > max_packsize)
|
||||
|
@ -1078,14 +1078,14 @@ static int store_object(
|
|||
delta = NULL;
|
||||
|
||||
memset(&s, 0, sizeof(s));
|
||||
deflateInit(&s, pack_compression_level);
|
||||
git_deflate_init(&s, pack_compression_level);
|
||||
s.next_in = (void *)dat->buf;
|
||||
s.avail_in = dat->len;
|
||||
s.avail_out = deflateBound(&s, s.avail_in);
|
||||
s.avail_out = git_deflate_bound(&s, s.avail_in);
|
||||
s.next_out = out = xrealloc(out, s.avail_out);
|
||||
while (deflate(&s, Z_FINISH) == Z_OK)
|
||||
/* nothing */;
|
||||
deflateEnd(&s);
|
||||
while (git_deflate(&s, Z_FINISH) == Z_OK)
|
||||
; /* nothing */
|
||||
git_deflate_end(&s);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1163,7 +1163,7 @@ static void stream_blob(uintmax_t len, unsigned char *sha1out, uintmax_t mark)
|
|||
off_t offset;
|
||||
git_SHA_CTX c;
|
||||
git_SHA_CTX pack_file_ctx;
|
||||
z_stream s;
|
||||
git_zstream s;
|
||||
int status = Z_OK;
|
||||
|
||||
/* Determine if we should auto-checkpoint. */
|
||||
|
@ -1187,7 +1187,7 @@ static void stream_blob(uintmax_t len, unsigned char *sha1out, uintmax_t mark)
|
|||
crc32_begin(pack_file);
|
||||
|
||||
memset(&s, 0, sizeof(s));
|
||||
deflateInit(&s, pack_compression_level);
|
||||
git_deflate_init(&s, pack_compression_level);
|
||||
|
||||
hdrlen = encode_in_pack_object_header(OBJ_BLOB, len, out_buf);
|
||||
if (out_sz <= hdrlen)
|
||||
|
@ -1209,7 +1209,7 @@ static void stream_blob(uintmax_t len, unsigned char *sha1out, uintmax_t mark)
|
|||
len -= n;
|
||||
}
|
||||
|
||||
status = deflate(&s, len ? 0 : Z_FINISH);
|
||||
status = git_deflate(&s, len ? 0 : Z_FINISH);
|
||||
|
||||
if (!s.avail_out || status == Z_STREAM_END) {
|
||||
size_t n = s.next_out - out_buf;
|
||||
|
@ -1228,7 +1228,7 @@ static void stream_blob(uintmax_t len, unsigned char *sha1out, uintmax_t mark)
|
|||
die("unexpected deflate failure: %d", status);
|
||||
}
|
||||
}
|
||||
deflateEnd(&s);
|
||||
git_deflate_end(&s);
|
||||
git_SHA1_Final(sha1, &c);
|
||||
|
||||
if (sha1out)
|
||||
|
|
|
@ -271,16 +271,13 @@ static struct rpc_service *select_service(const char *name)
|
|||
|
||||
static void inflate_request(const char *prog_name, int out)
|
||||
{
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
unsigned char in_buf[8192];
|
||||
unsigned char out_buf[8192];
|
||||
unsigned long cnt = 0;
|
||||
int ret;
|
||||
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
ret = inflateInit2(&stream, (15 + 16));
|
||||
if (ret != Z_OK)
|
||||
die("cannot start zlib inflater, zlib err %d", ret);
|
||||
git_inflate_init_gzip_only(&stream);
|
||||
|
||||
while (1) {
|
||||
ssize_t n = xread(0, in_buf, sizeof(in_buf));
|
||||
|
@ -296,7 +293,7 @@ static void inflate_request(const char *prog_name, int out)
|
|||
stream.next_out = out_buf;
|
||||
stream.avail_out = sizeof(out_buf);
|
||||
|
||||
ret = inflate(&stream, Z_NO_FLUSH);
|
||||
ret = git_inflate(&stream, Z_NO_FLUSH);
|
||||
if (ret != Z_OK && ret != Z_STREAM_END)
|
||||
die("zlib error inflating request, result %d", ret);
|
||||
|
||||
|
@ -311,7 +308,7 @@ static void inflate_request(const char *prog_name, int out)
|
|||
}
|
||||
|
||||
done:
|
||||
inflateEnd(&stream);
|
||||
git_inflate_end(&stream);
|
||||
close(out);
|
||||
}
|
||||
|
||||
|
|
16
http-push.c
16
http-push.c
|
@ -377,15 +377,15 @@ static void start_put(struct transfer_request *request)
|
|||
unsigned long len;
|
||||
int hdrlen;
|
||||
ssize_t size;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
|
||||
unpacked = read_sha1_file(request->obj->sha1, &type, &len);
|
||||
hdrlen = sprintf(hdr, "%s %lu", typename(type), len) + 1;
|
||||
|
||||
/* Set it up */
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
deflateInit(&stream, zlib_compression_level);
|
||||
size = deflateBound(&stream, len + hdrlen);
|
||||
git_deflate_init(&stream, zlib_compression_level);
|
||||
size = git_deflate_bound(&stream, len + hdrlen);
|
||||
strbuf_init(&request->buffer.buf, size);
|
||||
request->buffer.posn = 0;
|
||||
|
||||
|
@ -396,15 +396,15 @@ static void start_put(struct transfer_request *request)
|
|||
/* First header.. */
|
||||
stream.next_in = (void *)hdr;
|
||||
stream.avail_in = hdrlen;
|
||||
while (deflate(&stream, 0) == Z_OK)
|
||||
/* nothing */;
|
||||
while (git_deflate(&stream, 0) == Z_OK)
|
||||
; /* nothing */
|
||||
|
||||
/* Then the data itself.. */
|
||||
stream.next_in = unpacked;
|
||||
stream.avail_in = len;
|
||||
while (deflate(&stream, Z_FINISH) == Z_OK)
|
||||
/* nothing */;
|
||||
deflateEnd(&stream);
|
||||
while (git_deflate(&stream, Z_FINISH) == Z_OK)
|
||||
; /* nothing */
|
||||
git_deflate_end(&stream);
|
||||
free(unpacked);
|
||||
|
||||
request->buffer.buf.len = stream.total_out;
|
||||
|
|
2
http.h
2
http.h
|
@ -172,7 +172,7 @@ struct http_object_request {
|
|||
unsigned char sha1[20];
|
||||
unsigned char real_sha1[20];
|
||||
git_SHA_CTX c;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
int zret;
|
||||
int rename;
|
||||
struct active_request_slot *slot;
|
||||
|
|
|
@ -26,7 +26,7 @@ int check_pack_crc(struct packed_git *p, struct pack_window **w_curs,
|
|||
uint32_t data_crc = crc32(0, NULL, 0);
|
||||
|
||||
do {
|
||||
unsigned int avail;
|
||||
unsigned long avail;
|
||||
void *data = use_pack(p, w_curs, offset, &avail);
|
||||
if (avail > len)
|
||||
avail = len;
|
||||
|
@ -61,7 +61,7 @@ static int verify_packfile(struct packed_git *p,
|
|||
|
||||
git_SHA1_Init(&ctx);
|
||||
do {
|
||||
unsigned int remaining;
|
||||
unsigned long remaining;
|
||||
unsigned char *in = use_pack(p, w_curs, offset, &remaining);
|
||||
offset += remaining;
|
||||
if (!pack_sig_ofs)
|
||||
|
|
|
@ -473,16 +473,12 @@ static int post_rpc(struct rpc_state *rpc)
|
|||
* the transfer time.
|
||||
*/
|
||||
size_t size;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
int ret;
|
||||
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
ret = deflateInit2(&stream, Z_BEST_COMPRESSION,
|
||||
Z_DEFLATED, (15 + 16),
|
||||
8, Z_DEFAULT_STRATEGY);
|
||||
if (ret != Z_OK)
|
||||
die("cannot deflate request; zlib init error %d", ret);
|
||||
size = deflateBound(&stream, rpc->len);
|
||||
git_deflate_init_gzip(&stream, Z_BEST_COMPRESSION);
|
||||
size = git_deflate_bound(&stream, rpc->len);
|
||||
gzip_body = xmalloc(size);
|
||||
|
||||
stream.next_in = (unsigned char *)rpc->buf;
|
||||
|
@ -490,11 +486,11 @@ static int post_rpc(struct rpc_state *rpc)
|
|||
stream.next_out = (unsigned char *)gzip_body;
|
||||
stream.avail_out = size;
|
||||
|
||||
ret = deflate(&stream, Z_FINISH);
|
||||
ret = git_deflate(&stream, Z_FINISH);
|
||||
if (ret != Z_STREAM_END)
|
||||
die("cannot deflate request; zlib deflate error %d", ret);
|
||||
|
||||
ret = deflateEnd(&stream);
|
||||
ret = git_deflate_end_gently(&stream);
|
||||
if (ret != Z_OK)
|
||||
die("cannot deflate request; zlib end error %d", ret);
|
||||
|
||||
|
|
28
sha1_file.c
28
sha1_file.c
|
@ -834,7 +834,7 @@ static int in_window(struct pack_window *win, off_t offset)
|
|||
unsigned char *use_pack(struct packed_git *p,
|
||||
struct pack_window **w_cursor,
|
||||
off_t offset,
|
||||
unsigned int *left)
|
||||
unsigned long *left)
|
||||
{
|
||||
struct pack_window *win = *w_cursor;
|
||||
|
||||
|
@ -1254,7 +1254,7 @@ unsigned long unpack_object_header_buffer(const unsigned char *buf,
|
|||
return used;
|
||||
}
|
||||
|
||||
static int unpack_sha1_header(z_stream *stream, unsigned char *map, unsigned long mapsize, void *buffer, unsigned long bufsiz)
|
||||
static int unpack_sha1_header(git_zstream *stream, unsigned char *map, unsigned long mapsize, void *buffer, unsigned long bufsiz)
|
||||
{
|
||||
unsigned long size, used;
|
||||
static const char valid_loose_object_type[8] = {
|
||||
|
@ -1296,7 +1296,7 @@ static int unpack_sha1_header(z_stream *stream, unsigned char *map, unsigned lon
|
|||
return git_inflate(stream, 0);
|
||||
}
|
||||
|
||||
static void *unpack_sha1_rest(z_stream *stream, void *buffer, unsigned long size, const unsigned char *sha1)
|
||||
static void *unpack_sha1_rest(git_zstream *stream, void *buffer, unsigned long size, const unsigned char *sha1)
|
||||
{
|
||||
int bytes = strlen(buffer) + 1;
|
||||
unsigned char *buf = xmallocz(size);
|
||||
|
@ -1395,7 +1395,7 @@ static int parse_sha1_header(const char *hdr, unsigned long *sizep)
|
|||
static void *unpack_sha1_file(void *map, unsigned long mapsize, enum object_type *type, unsigned long *size, const unsigned char *sha1)
|
||||
{
|
||||
int ret;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
char hdr[8192];
|
||||
|
||||
ret = unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr));
|
||||
|
@ -1411,7 +1411,7 @@ unsigned long get_size_from_delta(struct packed_git *p,
|
|||
{
|
||||
const unsigned char *data;
|
||||
unsigned char delta_head[20], *in;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
int st;
|
||||
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
|
@ -1533,7 +1533,7 @@ static int unpack_object_header(struct packed_git *p,
|
|||
unsigned long *sizep)
|
||||
{
|
||||
unsigned char *base;
|
||||
unsigned int left;
|
||||
unsigned long left;
|
||||
unsigned long used;
|
||||
enum object_type type;
|
||||
|
||||
|
@ -1646,7 +1646,7 @@ static void *unpack_compressed_entry(struct packed_git *p,
|
|||
unsigned long size)
|
||||
{
|
||||
int st;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
unsigned char *buffer, *in;
|
||||
|
||||
buffer = xmallocz(size);
|
||||
|
@ -2079,7 +2079,7 @@ static int sha1_loose_object_info(const unsigned char *sha1, unsigned long *size
|
|||
int status;
|
||||
unsigned long mapsize, size;
|
||||
void *map;
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
char hdr[32];
|
||||
|
||||
map = map_sha1_file(sha1, &mapsize);
|
||||
|
@ -2428,7 +2428,7 @@ static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,
|
|||
{
|
||||
int fd, ret;
|
||||
unsigned char compressed[4096];
|
||||
z_stream stream;
|
||||
git_zstream stream;
|
||||
git_SHA_CTX c;
|
||||
unsigned char parano_sha1[20];
|
||||
char *filename;
|
||||
|
@ -2445,7 +2445,7 @@ static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,
|
|||
|
||||
/* Set it up */
|
||||
memset(&stream, 0, sizeof(stream));
|
||||
deflateInit(&stream, zlib_compression_level);
|
||||
git_deflate_init(&stream, zlib_compression_level);
|
||||
stream.next_out = compressed;
|
||||
stream.avail_out = sizeof(compressed);
|
||||
git_SHA1_Init(&c);
|
||||
|
@ -2453,8 +2453,8 @@ static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,
|
|||
/* First header.. */
|
||||
stream.next_in = (unsigned char *)hdr;
|
||||
stream.avail_in = hdrlen;
|
||||
while (deflate(&stream, 0) == Z_OK)
|
||||
/* nothing */;
|
||||
while (git_deflate(&stream, 0) == Z_OK)
|
||||
; /* nothing */
|
||||
git_SHA1_Update(&c, hdr, hdrlen);
|
||||
|
||||
/* Then the data itself.. */
|
||||
|
@ -2462,7 +2462,7 @@ static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,
|
|||
stream.avail_in = len;
|
||||
do {
|
||||
unsigned char *in0 = stream.next_in;
|
||||
ret = deflate(&stream, Z_FINISH);
|
||||
ret = git_deflate(&stream, Z_FINISH);
|
||||
git_SHA1_Update(&c, in0, stream.next_in - in0);
|
||||
if (write_buffer(fd, compressed, stream.next_out - compressed) < 0)
|
||||
die("unable to write sha1 file");
|
||||
|
@ -2472,7 +2472,7 @@ static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,
|
|||
|
||||
if (ret != Z_STREAM_END)
|
||||
die("unable to deflate new object %s (%d)", sha1_to_hex(sha1), ret);
|
||||
ret = deflateEnd(&stream);
|
||||
ret = git_deflate_end_gently(&stream);
|
||||
if (ret != Z_OK)
|
||||
die("deflateEnd on object %s failed (%d)", sha1_to_hex(sha1), ret);
|
||||
git_SHA1_Final(parano_sha1, &c);
|
||||
|
|
272
zlib.c
272
zlib.c
|
@ -4,58 +4,248 @@
|
|||
*/
|
||||
#include "cache.h"
|
||||
|
||||
void git_inflate_init(z_streamp strm)
|
||||
static const char *zerr_to_string(int status)
|
||||
{
|
||||
const char *err;
|
||||
|
||||
switch (inflateInit(strm)) {
|
||||
case Z_OK:
|
||||
return;
|
||||
|
||||
switch (status) {
|
||||
case Z_MEM_ERROR:
|
||||
err = "out of memory";
|
||||
break;
|
||||
return "out of memory";
|
||||
case Z_VERSION_ERROR:
|
||||
err = "wrong version";
|
||||
break;
|
||||
default:
|
||||
err = "error";
|
||||
}
|
||||
die("inflateInit: %s (%s)", err, strm->msg ? strm->msg : "no message");
|
||||
}
|
||||
|
||||
void git_inflate_end(z_streamp strm)
|
||||
{
|
||||
if (inflateEnd(strm) != Z_OK)
|
||||
error("inflateEnd: %s", strm->msg ? strm->msg : "failed");
|
||||
}
|
||||
|
||||
int git_inflate(z_streamp strm, int flush)
|
||||
{
|
||||
int ret = inflate(strm, flush);
|
||||
const char *err;
|
||||
|
||||
switch (ret) {
|
||||
/* Out of memory is fatal. */
|
||||
case Z_MEM_ERROR:
|
||||
die("inflate: out of memory");
|
||||
|
||||
/* Data corruption errors: we may want to recover from them (fsck) */
|
||||
return "wrong version";
|
||||
case Z_NEED_DICT:
|
||||
err = "needs dictionary"; break;
|
||||
return "needs dictionary";
|
||||
case Z_DATA_ERROR:
|
||||
err = "data stream error"; break;
|
||||
return "data stream error";
|
||||
case Z_STREAM_ERROR:
|
||||
err = "stream consistency error"; break;
|
||||
return "stream consistency error";
|
||||
default:
|
||||
err = "unknown error"; break;
|
||||
return "unknown error";
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* avail_in and avail_out in zlib are counted in uInt, which typically
|
||||
* limits the size of the buffer we can use to 4GB when interacting
|
||||
* with zlib in a single call to inflate/deflate.
|
||||
*/
|
||||
/* #define ZLIB_BUF_MAX ((uInt)-1) */
|
||||
#define ZLIB_BUF_MAX ((uInt) 1024 * 1024 * 1024) /* 1GB */
|
||||
static inline uInt zlib_buf_cap(unsigned long len)
|
||||
{
|
||||
return (ZLIB_BUF_MAX < len) ? ZLIB_BUF_MAX : len;
|
||||
}
|
||||
|
||||
static void zlib_pre_call(git_zstream *s)
|
||||
{
|
||||
s->z.next_in = s->next_in;
|
||||
s->z.next_out = s->next_out;
|
||||
s->z.total_in = s->total_in;
|
||||
s->z.total_out = s->total_out;
|
||||
s->z.avail_in = zlib_buf_cap(s->avail_in);
|
||||
s->z.avail_out = zlib_buf_cap(s->avail_out);
|
||||
}
|
||||
|
||||
static void zlib_post_call(git_zstream *s)
|
||||
{
|
||||
unsigned long bytes_consumed;
|
||||
unsigned long bytes_produced;
|
||||
|
||||
bytes_consumed = s->z.next_in - s->next_in;
|
||||
bytes_produced = s->z.next_out - s->next_out;
|
||||
if (s->z.total_out != s->total_out + bytes_produced)
|
||||
die("BUG: total_out mismatch");
|
||||
if (s->z.total_in != s->total_in + bytes_consumed)
|
||||
die("BUG: total_in mismatch");
|
||||
|
||||
s->total_out = s->z.total_out;
|
||||
s->total_in = s->z.total_in;
|
||||
s->next_in = s->z.next_in;
|
||||
s->next_out = s->z.next_out;
|
||||
s->avail_in -= bytes_consumed;
|
||||
s->avail_out -= bytes_produced;
|
||||
}
|
||||
|
||||
void git_inflate_init(git_zstream *strm)
|
||||
{
|
||||
int status;
|
||||
|
||||
zlib_pre_call(strm);
|
||||
status = inflateInit(&strm->z);
|
||||
zlib_post_call(strm);
|
||||
if (status == Z_OK)
|
||||
return;
|
||||
die("inflateInit: %s (%s)", zerr_to_string(status),
|
||||
strm->z.msg ? strm->z.msg : "no message");
|
||||
}
|
||||
|
||||
void git_inflate_init_gzip_only(git_zstream *strm)
|
||||
{
|
||||
/*
|
||||
* Use default 15 bits, +16 is to accept only gzip and to
|
||||
* yield Z_DATA_ERROR when fed zlib format.
|
||||
*/
|
||||
const int windowBits = 15 + 16;
|
||||
int status;
|
||||
|
||||
zlib_pre_call(strm);
|
||||
status = inflateInit2(&strm->z, windowBits);
|
||||
zlib_post_call(strm);
|
||||
if (status == Z_OK)
|
||||
return;
|
||||
die("inflateInit2: %s (%s)", zerr_to_string(status),
|
||||
strm->z.msg ? strm->z.msg : "no message");
|
||||
}
|
||||
|
||||
void git_inflate_end(git_zstream *strm)
|
||||
{
|
||||
int status;
|
||||
|
||||
zlib_pre_call(strm);
|
||||
status = inflateEnd(&strm->z);
|
||||
zlib_post_call(strm);
|
||||
if (status == Z_OK)
|
||||
return;
|
||||
error("inflateEnd: %s (%s)", zerr_to_string(status),
|
||||
strm->z.msg ? strm->z.msg : "no message");
|
||||
}
|
||||
|
||||
int git_inflate(git_zstream *strm, int flush)
|
||||
{
|
||||
int status;
|
||||
|
||||
for (;;) {
|
||||
zlib_pre_call(strm);
|
||||
/* Never say Z_FINISH unless we are feeding everything */
|
||||
status = inflate(&strm->z,
|
||||
(strm->z.avail_in != strm->avail_in)
|
||||
? 0 : flush);
|
||||
if (status == Z_MEM_ERROR)
|
||||
die("inflate: out of memory");
|
||||
zlib_post_call(strm);
|
||||
|
||||
/*
|
||||
* Let zlib work another round, while we can still
|
||||
* make progress.
|
||||
*/
|
||||
if ((strm->avail_out && !strm->z.avail_out) &&
|
||||
(status == Z_OK || status == Z_BUF_ERROR))
|
||||
continue;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (status) {
|
||||
/* Z_BUF_ERROR: normal, needs more space in the output buffer */
|
||||
case Z_BUF_ERROR:
|
||||
case Z_OK:
|
||||
case Z_STREAM_END:
|
||||
return ret;
|
||||
return status;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
error("inflate: %s (%s)", err, strm->msg ? strm->msg : "no message");
|
||||
return ret;
|
||||
error("inflate: %s (%s)", zerr_to_string(status),
|
||||
strm->z.msg ? strm->z.msg : "no message");
|
||||
return status;
|
||||
}
|
||||
|
||||
#if defined(NO_DEFLATE_BOUND) || ZLIB_VERNUM < 0x1200
|
||||
#define deflateBound(c,s) ((s) + (((s) + 7) >> 3) + (((s) + 63) >> 6) + 11)
|
||||
#endif
|
||||
|
||||
unsigned long git_deflate_bound(git_zstream *strm, unsigned long size)
|
||||
{
|
||||
return deflateBound(&strm->z, size);
|
||||
}
|
||||
|
||||
void git_deflate_init(git_zstream *strm, int level)
|
||||
{
|
||||
int status;
|
||||
|
||||
zlib_pre_call(strm);
|
||||
status = deflateInit(&strm->z, level);
|
||||
zlib_post_call(strm);
|
||||
if (status == Z_OK)
|
||||
return;
|
||||
die("deflateInit: %s (%s)", zerr_to_string(status),
|
||||
strm->z.msg ? strm->z.msg : "no message");
|
||||
}
|
||||
|
||||
void git_deflate_init_gzip(git_zstream *strm, int level)
|
||||
{
|
||||
/*
|
||||
* Use default 15 bits, +16 is to generate gzip header/trailer
|
||||
* instead of the zlib wrapper.
|
||||
*/
|
||||
const int windowBits = 15 + 16;
|
||||
int status;
|
||||
|
||||
zlib_pre_call(strm);
|
||||
status = deflateInit2(&strm->z, level,
|
||||
Z_DEFLATED, windowBits,
|
||||
8, Z_DEFAULT_STRATEGY);
|
||||
zlib_post_call(strm);
|
||||
if (status == Z_OK)
|
||||
return;
|
||||
die("deflateInit2: %s (%s)", zerr_to_string(status),
|
||||
strm->z.msg ? strm->z.msg : "no message");
|
||||
}
|
||||
|
||||
void git_deflate_end(git_zstream *strm)
|
||||
{
|
||||
int status;
|
||||
|
||||
zlib_pre_call(strm);
|
||||
status = deflateEnd(&strm->z);
|
||||
zlib_post_call(strm);
|
||||
if (status == Z_OK)
|
||||
return;
|
||||
error("deflateEnd: %s (%s)", zerr_to_string(status),
|
||||
strm->z.msg ? strm->z.msg : "no message");
|
||||
}
|
||||
|
||||
int git_deflate_end_gently(git_zstream *strm)
|
||||
{
|
||||
int status;
|
||||
|
||||
zlib_pre_call(strm);
|
||||
status = deflateEnd(&strm->z);
|
||||
zlib_post_call(strm);
|
||||
return status;
|
||||
}
|
||||
|
||||
int git_deflate(git_zstream *strm, int flush)
|
||||
{
|
||||
int status;
|
||||
|
||||
for (;;) {
|
||||
zlib_pre_call(strm);
|
||||
|
||||
/* Never say Z_FINISH unless we are feeding everything */
|
||||
status = deflate(&strm->z,
|
||||
(strm->z.avail_in != strm->avail_in)
|
||||
? 0 : flush);
|
||||
if (status == Z_MEM_ERROR)
|
||||
die("deflate: out of memory");
|
||||
zlib_post_call(strm);
|
||||
|
||||
/*
|
||||
* Let zlib work another round, while we can still
|
||||
* make progress.
|
||||
*/
|
||||
if ((strm->avail_out && !strm->z.avail_out) &&
|
||||
(status == Z_OK || status == Z_BUF_ERROR))
|
||||
continue;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (status) {
|
||||
/* Z_BUF_ERROR: normal, needs more space in the output buffer */
|
||||
case Z_BUF_ERROR:
|
||||
case Z_OK:
|
||||
case Z_STREAM_END:
|
||||
return status;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
error("deflate: %s (%s)", zerr_to_string(status),
|
||||
strm->z.msg ? strm->z.msg : "no message");
|
||||
return status;
|
||||
}
|
||||
|
|
Загрузка…
Ссылка в новой задаче