@matheusbsbs / matheus-bagliano / commits / 55bb5c9147

zlib: wrap deflate side of the API

Wrap deflateInit, deflate, and deflateEnd for everybody, and the sole use of deflateInit2 in remote-curl.c to tell the library to use gzip header and trailer in git_deflate_init_gzip(). There is only one caller that cares about the status from deflateEnd(). Introduce git_deflate_end_gently() to let that sole caller retrieve the status and act on it (i.e. die) for now, but we would probably want to make inflate_end/deflate_end die when they ran out of memory and get rid of the _gently() kind. Signed-off-by: Junio C Hamano <gitster@pobox.com>

Junio C Hamano committed Jun 10, 2011 at 10:55 UTC 55bb5c9147a209eba44c3e9866704ece424c3d31

10 files changed +105 -41

archive-zip.c

+3 -3

@@ -96,7 +96,7 @@ static void *zlib_deflate(void *data, unsigned long size,

96 int result;

98 memset(&stream, 0, sizeof(stream));

99 - deflateInit(&stream, compression_level);

99 + git_deflate_init(&stream, compression_level);

100 maxsize = deflateBound(&stream, size);

101 buffer = xmalloc(maxsize);

102

@@ -106,7 +106,7 @@ static void *zlib_deflate(void *data, unsigned long size,

106 stream.avail_out = maxsize;

107

108 do {

109 - result = deflate(&stream, Z_FINISH);

109 + result = git_deflate(&stream, Z_FINISH);

110 } while (result == Z_OK);

111

112 if (result != Z_STREAM_END) {

@@ -114,7 +114,7 @@ static void *zlib_deflate(void *data, unsigned long size,

114 return NULL;

115 }

116

117 - deflateEnd(&stream);

117 + git_deflate_end(&stream);

118 *compressed_size = stream.total_out;

119

120 return buffer;

builtin/index-pack.c

+3 -3

@@ -671,21 +671,21 @@ static int write_compressed(struct sha1file *f, void *in, unsigned int size)

671 unsigned char outbuf[4096];

672

673 memset(&stream, 0, sizeof(stream));

674 - deflateInit(&stream, zlib_compression_level);

674 + git_deflate_init(&stream, zlib_compression_level);

675 stream.next_in = in;

676 stream.avail_in = size;

677

678 do {

679 stream.next_out = outbuf;

680 stream.avail_out = sizeof(outbuf);

681 - status = deflate(&stream, Z_FINISH);

681 + status = git_deflate(&stream, Z_FINISH);

682 sha1write(f, outbuf, sizeof(outbuf) - stream.avail_out);

683 } while (status == Z_OK);

684

685 if (status != Z_STREAM_END)

686 die("unable to deflate appended object (%d)", status);

687 size = stream.total_out;

688 - deflateEnd(&stream);

688 + git_deflate_end(&stream);

689 return size;

690 }

691

builtin/pack-objects.c

+3 -3

@@ -131,7 +131,7 @@ static unsigned long do_compress(void **pptr, unsigned long size)

131 unsigned long maxsize;

132

133 memset(&stream, 0, sizeof(stream));

134 - deflateInit(&stream, pack_compression_level);

134 + git_deflate_init(&stream, pack_compression_level);

135 maxsize = deflateBound(&stream, size);

136

137 in = *pptr;

@@ -142,9 +142,9 @@ static unsigned long do_compress(void **pptr, unsigned long size)

142 stream.avail_in = size;

143 stream.next_out = out;

144 stream.avail_out = maxsize;

145 - while (deflate(&stream, Z_FINISH) == Z_OK)

145 + while (git_deflate(&stream, Z_FINISH) == Z_OK)

146 ; /* nothing */

147 - deflateEnd(&stream);

147 + git_deflate_end(&stream);

148

149 free(in);

150 return stream.total_out;

cache.h

@@ -25,6 +25,12 @@ void git_inflate_init_gzip_only(z_streamp strm);

25 void git_inflate_end(z_streamp strm);

26 int git_inflate(z_streamp strm, int flush);

28 +void git_deflate_init(z_streamp strm, int level);

29 +void git_deflate_init_gzip(z_streamp strm, int level);

30 +void git_deflate_end(z_streamp strm);

31 +int git_deflate_end_gently(z_streamp strm);

32 +int git_deflate(z_streamp strm, int flush);

33 +

34 #if defined(DT_UNKNOWN) && !defined(NO_D_TYPE_IN_DIRENT)

35 #define DTYPE(de) ((de)->d_type)

36 #else

diff.c

+3 -3

@@ -1732,7 +1732,7 @@ static unsigned char *deflate_it(char *data,

1732 z_stream stream;

1733

1734 memset(&stream, 0, sizeof(stream));

1735 - deflateInit(&stream, zlib_compression_level);

1735 + git_deflate_init(&stream, zlib_compression_level);

1736 bound = deflateBound(&stream, size);

1737 deflated = xmalloc(bound);

1738 stream.next_out = deflated;

@@ -1740,9 +1740,9 @@ static unsigned char *deflate_it(char *data,

1740

1741 stream.next_in = (unsigned char *)data;

1742 stream.avail_in = size;

1743 - while (deflate(&stream, Z_FINISH) == Z_OK)

1743 + while (git_deflate(&stream, Z_FINISH) == Z_OK)

1744 ; /* nothing */

1745 - deflateEnd(&stream);

1745 + git_deflate_end(&stream);

1746 *result_size = stream.total_out;

1747 return deflated;

1748 }

fast-import.c

+11 -11

@@ -1050,7 +1050,7 @@ static int store_object(

1050 delta = NULL;

1051

1052 memset(&s, 0, sizeof(s));

1053 - deflateInit(&s, pack_compression_level);

1053 + git_deflate_init(&s, pack_compression_level);

1054 if (delta) {

1055 s.next_in = delta;

1056 s.avail_in = deltalen;

@@ -1060,9 +1060,9 @@ static int store_object(

1060 }

1061 s.avail_out = deflateBound(&s, s.avail_in);

1062 s.next_out = out = xmalloc(s.avail_out);

1063 - while (deflate(&s, Z_FINISH) == Z_OK)

1064 - /* nothing */;

1065 - deflateEnd(&s);

1063 + while (git_deflate(&s, Z_FINISH) == Z_OK)

1064 + ; /* nothing */

1065 + git_deflate_end(&s);

1066

1067 /* Determine if we should auto-checkpoint. */

1068 if ((max_packsize && (pack_size + 60 + s.total_out) > max_packsize)

@@ -1078,14 +1078,14 @@ static int store_object(

1078 delta = NULL;

1079

1080 memset(&s, 0, sizeof(s));

1081 - deflateInit(&s, pack_compression_level);

1081 + git_deflate_init(&s, pack_compression_level);

1082 s.next_in = (void *)dat->buf;

1083 s.avail_in = dat->len;

1084 s.avail_out = deflateBound(&s, s.avail_in);

1085 s.next_out = out = xrealloc(out, s.avail_out);

1086 - while (deflate(&s, Z_FINISH) == Z_OK)

1087 - /* nothing */;

1088 - deflateEnd(&s);

1086 + while (git_deflate(&s, Z_FINISH) == Z_OK)

1087 + ; /* nothing */

1088 + git_deflate_end(&s);

1089 }

1090 }

1091

@@ -1187,7 +1187,7 @@ static void stream_blob(uintmax_t len, unsigned char *sha1out, uintmax_t mark)

1187 crc32_begin(pack_file);

1188

1189 memset(&s, 0, sizeof(s));

1190 - deflateInit(&s, pack_compression_level);

1190 + git_deflate_init(&s, pack_compression_level);

1191

1192 hdrlen = encode_in_pack_object_header(OBJ_BLOB, len, out_buf);

1193 if (out_sz <= hdrlen)

@@ -1209,7 +1209,7 @@ static void stream_blob(uintmax_t len, unsigned char *sha1out, uintmax_t mark)

1209 len -= n;

1210 }

1211

1212 - status = deflate(&s, len ? 0 : Z_FINISH);

1212 + status = git_deflate(&s, len ? 0 : Z_FINISH);

1213

1214 if (!s.avail_out || status == Z_STREAM_END) {

1215 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)

1228 die("unexpected deflate failure: %d", status);

1229 }

1230 }

1231 - deflateEnd(&s);

1231 + git_deflate_end(&s);

1232 git_SHA1_Final(sha1, &c);

1233

1234 if (sha1out)

http-push.c

+6 -6

@@ -359,7 +359,7 @@ static void start_put(struct transfer_request *request)

359

360 /* Set it up */

361 memset(&stream, 0, sizeof(stream));

362 - deflateInit(&stream, zlib_compression_level);

362 + git_deflate_init(&stream, zlib_compression_level);

363 size = deflateBound(&stream, len + hdrlen);

364 strbuf_init(&request->buffer.buf, size);

365 request->buffer.posn = 0;

@@ -371,15 +371,15 @@ static void start_put(struct transfer_request *request)

371 /* First header.. */

372 stream.next_in = (void *)hdr;

373 stream.avail_in = hdrlen;

374 - while (deflate(&stream, 0) == Z_OK)

375 - /* nothing */;

374 + while (git_deflate(&stream, 0) == Z_OK)

375 + ; /* nothing */

376

377 /* Then the data itself.. */

378 stream.next_in = unpacked;

379 stream.avail_in = len;

380 - while (deflate(&stream, Z_FINISH) == Z_OK)

381 - /* nothing */;

382 - deflateEnd(&stream);

380 + while (git_deflate(&stream, Z_FINISH) == Z_OK)

381 + ; /* nothing */

382 + git_deflate_end(&stream);

383 free(unpacked);

384

385 request->buffer.buf.len = stream.total_out;

remote-curl.c

+3 -7

@@ -475,11 +475,7 @@ static int post_rpc(struct rpc_state *rpc)

475 int ret;

476

477 memset(&stream, 0, sizeof(stream));

478 - ret = deflateInit2(&stream, Z_BEST_COMPRESSION,

479 - Z_DEFLATED, (15 + 16),

480 - 8, Z_DEFAULT_STRATEGY);

481 - if (ret != Z_OK)

482 - die("cannot deflate request; zlib init error %d", ret);

478 + git_deflate_init_gzip(&stream, Z_BEST_COMPRESSION);

479 size = deflateBound(&stream, rpc->len);

480 gzip_body = xmalloc(size);

481

@@ -488,11 +484,11 @@ static int post_rpc(struct rpc_state *rpc)

484 stream.next_out = (unsigned char *)gzip_body;

485 stream.avail_out = size;

486

491 - ret = deflate(&stream, Z_FINISH);

487 + ret = git_deflate(&stream, Z_FINISH);

488 if (ret != Z_STREAM_END)

489 die("cannot deflate request; zlib deflate error %d", ret);

490

495 - ret = deflateEnd(&stream);

491 + ret = git_deflate_end_gently(&stream);

492 if (ret != Z_OK)

493 die("cannot deflate request; zlib end error %d", ret);

494

sha1_file.c

+5 -5

@@ -2442,7 +2442,7 @@ static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,

2442

2443 /* Set it up */

2444 memset(&stream, 0, sizeof(stream));

2445 - deflateInit(&stream, zlib_compression_level);

2445 + git_deflate_init(&stream, zlib_compression_level);

2446 stream.next_out = compressed;

2447 stream.avail_out = sizeof(compressed);

2448 git_SHA1_Init(&c);

@@ -2450,8 +2450,8 @@ static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,

2450 /* First header.. */

2451 stream.next_in = (unsigned char *)hdr;

2452 stream.avail_in = hdrlen;

2453 - while (deflate(&stream, 0) == Z_OK)

2454 - /* nothing */;

2453 + while (git_deflate(&stream, 0) == Z_OK)

2454 + ; /* nothing */

2455 git_SHA1_Update(&c, hdr, hdrlen);

2456

2457 /* Then the data itself.. */

@@ -2459,7 +2459,7 @@ static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,

2459 stream.avail_in = len;

2460 do {

2461 unsigned char *in0 = stream.next_in;

2462 - ret = deflate(&stream, Z_FINISH);

2462 + ret = git_deflate(&stream, Z_FINISH);

2463 git_SHA1_Update(&c, in0, stream.next_in - in0);

2464 if (write_buffer(fd, compressed, stream.next_out - compressed) < 0)

2465 die("unable to write sha1 file");

@@ -2469,7 +2469,7 @@ static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,

2469

2470 if (ret != Z_STREAM_END)

2471 die("unable to deflate new object %s (%d)", sha1_to_hex(sha1), ret);

2472 - ret = deflateEnd(&stream);

2472 + ret = git_deflate_end_gently(&stream);

2473 if (ret != Z_OK)

2474 die("deflateEnd on object %s failed (%d)", sha1_to_hex(sha1), ret);

2475 git_SHA1_Final(parano_sha1, &c);

zlib.c

+62

@@ -77,3 +77,65 @@ int git_inflate(z_streamp strm, int flush)

77 strm->msg ? strm->msg : "no message");

78 return status;

79 }

80 +

81 +void git_deflate_init(z_streamp strm, int level)

82 +{

83 + int status = deflateInit(strm, level);

84 +

85 + if (status == Z_OK)

86 + return;

87 + die("deflateInit: %s (%s)", zerr_to_string(status),

88 + strm->msg ? strm->msg : "no message");

89 +}

90 +

91 +void git_deflate_init_gzip(z_streamp strm, int level)

92 +{

93 + /*

94 + * Use default 15 bits, +16 is to generate gzip header/trailer

95 + * instead of the zlib wrapper.

96 + */

97 + const int windowBits = 15 + 16;

98 + int status = deflateInit2(strm, level,

99 + Z_DEFLATED, windowBits,

100 + 8, Z_DEFAULT_STRATEGY);

101 + if (status == Z_OK)

102 + return;

103 + die("deflateInit2: %s (%s)", zerr_to_string(status),

104 + strm->msg ? strm->msg : "no message");

105 +}

106 +

107 +void git_deflate_end(z_streamp strm)

108 +{

109 + int status = deflateEnd(strm);

110 +

111 + if (status == Z_OK)

112 + return;

113 + error("deflateEnd: %s (%s)", zerr_to_string(status),

114 + strm->msg ? strm->msg : "no message");

115 +}

116 +

117 +int git_deflate_end_gently(z_streamp strm)

118 +{

119 + return deflateEnd(strm);

120 +}

121 +

122 +int git_deflate(z_streamp strm, int flush)

123 +{

124 + int status = deflate(strm, flush);

125 +

126 + switch (status) {

127 + /* Z_BUF_ERROR: normal, needs more space in the output buffer */

128 + case Z_BUF_ERROR:

129 + case Z_OK:

130 + case Z_STREAM_END:

131 + return status;

132 +

133 + case Z_MEM_ERROR:

134 + die("deflate: out of memory");

135 + default:

136 + break;

137 + }

138 + error("deflate: %s (%s)", zerr_to_string(status),

139 + strm->msg ? strm->msg : "no message");

140 + return status;

141 +}