]>
Commit | Line | Data |
---|---|---|
b0613ce0 JN |
1 | /* |
2 | * zlib wrappers to make sure we don't silently miss errors | |
3 | * at init time. | |
4 | */ | |
5 | #include "cache.h" | |
6 | ||
1a507fc1 | 7 | static const char *zerr_to_string(int status) |
b0613ce0 | 8 | { |
1a507fc1 | 9 | switch (status) { |
b0613ce0 | 10 | case Z_MEM_ERROR: |
1a507fc1 | 11 | return "out of memory"; |
b0613ce0 | 12 | case Z_VERSION_ERROR: |
1a507fc1 JH |
13 | return "wrong version"; |
14 | case Z_NEED_DICT: | |
15 | return "needs dictionary"; | |
16 | case Z_DATA_ERROR: | |
17 | return "data stream error"; | |
18 | case Z_STREAM_ERROR: | |
19 | return "stream consistency error"; | |
b0613ce0 | 20 | default: |
1a507fc1 | 21 | return "unknown error"; |
b0613ce0 | 22 | } |
b0613ce0 JN |
23 | } |
24 | ||
ef49a7a0 JH |
25 | /* |
26 | * avail_in and avail_out in zlib are counted in uInt, which typically | |
27 | * limits the size of the buffer we can use to 4GB when interacting | |
28 | * with zlib in a single call to inflate/deflate. | |
29 | */ | |
e01503b5 JH |
30 | /* #define ZLIB_BUF_MAX ((uInt)-1) */ |
31 | #define ZLIB_BUF_MAX ((uInt) 1024 * 1024 * 1024) /* 1GB */ | |
ef49a7a0 JH |
32 | static inline uInt zlib_buf_cap(unsigned long len) |
33 | { | |
e01503b5 | 34 | return (ZLIB_BUF_MAX < len) ? ZLIB_BUF_MAX : len; |
ef49a7a0 JH |
35 | } |
36 | ||
37 | static void zlib_pre_call(git_zstream *s) | |
38 | { | |
39 | s->z.next_in = s->next_in; | |
40 | s->z.next_out = s->next_out; | |
41 | s->z.total_in = s->total_in; | |
42 | s->z.total_out = s->total_out; | |
43 | s->z.avail_in = zlib_buf_cap(s->avail_in); | |
44 | s->z.avail_out = zlib_buf_cap(s->avail_out); | |
45 | } | |
46 | ||
47 | static void zlib_post_call(git_zstream *s) | |
48 | { | |
e01503b5 JH |
49 | unsigned long bytes_consumed; |
50 | unsigned long bytes_produced; | |
51 | ||
52 | bytes_consumed = s->z.next_in - s->next_in; | |
53 | bytes_produced = s->z.next_out - s->next_out; | |
54 | if (s->z.total_out != s->total_out + bytes_produced) | |
033abf97 | 55 | BUG("total_out mismatch"); |
e01503b5 | 56 | if (s->z.total_in != s->total_in + bytes_consumed) |
033abf97 | 57 | BUG("total_in mismatch"); |
e01503b5 JH |
58 | |
59 | s->total_out = s->z.total_out; | |
60 | s->total_in = s->z.total_in; | |
ef49a7a0 JH |
61 | s->next_in = s->z.next_in; |
62 | s->next_out = s->z.next_out; | |
e01503b5 JH |
63 | s->avail_in -= bytes_consumed; |
64 | s->avail_out -= bytes_produced; | |
ef49a7a0 JH |
65 | } |
66 | ||
67 | void git_inflate_init(git_zstream *strm) | |
b0613ce0 | 68 | { |
ef49a7a0 | 69 | int status; |
1a507fc1 | 70 | |
ef49a7a0 JH |
71 | zlib_pre_call(strm); |
72 | status = inflateInit(&strm->z); | |
73 | zlib_post_call(strm); | |
1a507fc1 JH |
74 | if (status == Z_OK) |
75 | return; | |
76 | die("inflateInit: %s (%s)", zerr_to_string(status), | |
ef49a7a0 | 77 | strm->z.msg ? strm->z.msg : "no message"); |
b0613ce0 JN |
78 | } |
79 | ||
ef49a7a0 | 80 | void git_inflate_init_gzip_only(git_zstream *strm) |
5e86c1fb JH |
81 | { |
82 | /* | |
83 | * Use default 15 bits, +16 is to accept only gzip and to | |
84 | * yield Z_DATA_ERROR when fed zlib format. | |
85 | */ | |
86 | const int windowBits = 15 + 16; | |
ef49a7a0 | 87 | int status; |
5e86c1fb | 88 | |
ef49a7a0 JH |
89 | zlib_pre_call(strm); |
90 | status = inflateInit2(&strm->z, windowBits); | |
91 | zlib_post_call(strm); | |
5e86c1fb JH |
92 | if (status == Z_OK) |
93 | return; | |
94 | die("inflateInit2: %s (%s)", zerr_to_string(status), | |
ef49a7a0 | 95 | strm->z.msg ? strm->z.msg : "no message"); |
5e86c1fb JH |
96 | } |
97 | ||
ef49a7a0 | 98 | void git_inflate_end(git_zstream *strm) |
b0613ce0 | 99 | { |
ef49a7a0 | 100 | int status; |
b0613ce0 | 101 | |
ef49a7a0 JH |
102 | zlib_pre_call(strm); |
103 | status = inflateEnd(&strm->z); | |
104 | zlib_post_call(strm); | |
1a507fc1 JH |
105 | if (status == Z_OK) |
106 | return; | |
107 | error("inflateEnd: %s (%s)", zerr_to_string(status), | |
ef49a7a0 | 108 | strm->z.msg ? strm->z.msg : "no message"); |
1a507fc1 | 109 | } |
b0613ce0 | 110 | |
ef49a7a0 | 111 | int git_inflate(git_zstream *strm, int flush) |
1a507fc1 | 112 | { |
ef49a7a0 | 113 | int status; |
b0613ce0 | 114 | |
e01503b5 JH |
115 | for (;;) { |
116 | zlib_pre_call(strm); | |
117 | /* Never say Z_FINISH unless we are feeding everything */ | |
118 | status = inflate(&strm->z, | |
119 | (strm->z.avail_in != strm->avail_in) | |
120 | ? 0 : flush); | |
121 | if (status == Z_MEM_ERROR) | |
122 | die("inflate: out of memory"); | |
123 | zlib_post_call(strm); | |
124 | ||
125 | /* | |
126 | * Let zlib work another round, while we can still | |
127 | * make progress. | |
128 | */ | |
129 | if ((strm->avail_out && !strm->z.avail_out) && | |
130 | (status == Z_OK || status == Z_BUF_ERROR)) | |
131 | continue; | |
132 | break; | |
133 | } | |
134 | ||
1a507fc1 | 135 | switch (status) { |
b0613ce0 JN |
136 | /* Z_BUF_ERROR: normal, needs more space in the output buffer */ |
137 | case Z_BUF_ERROR: | |
138 | case Z_OK: | |
139 | case Z_STREAM_END: | |
1a507fc1 | 140 | return status; |
1a507fc1 JH |
141 | default: |
142 | break; | |
b0613ce0 | 143 | } |
1a507fc1 | 144 | error("inflate: %s (%s)", zerr_to_string(status), |
ef49a7a0 | 145 | strm->z.msg ? strm->z.msg : "no message"); |
1a507fc1 | 146 | return status; |
b0613ce0 | 147 | } |
55bb5c91 | 148 | |
225a6f10 JH |
149 | #if defined(NO_DEFLATE_BOUND) || ZLIB_VERNUM < 0x1200 |
150 | #define deflateBound(c,s) ((s) + (((s) + 7) >> 3) + (((s) + 63) >> 6) + 11) | |
151 | #endif | |
152 | ||
ef49a7a0 | 153 | unsigned long git_deflate_bound(git_zstream *strm, unsigned long size) |
225a6f10 | 154 | { |
ef49a7a0 | 155 | return deflateBound(&strm->z, size); |
225a6f10 JH |
156 | } |
157 | ||
ef49a7a0 | 158 | void git_deflate_init(git_zstream *strm, int level) |
55bb5c91 | 159 | { |
ef49a7a0 | 160 | int status; |
55bb5c91 | 161 | |
9a6f1287 | 162 | memset(strm, 0, sizeof(*strm)); |
ef49a7a0 JH |
163 | zlib_pre_call(strm); |
164 | status = deflateInit(&strm->z, level); | |
165 | zlib_post_call(strm); | |
55bb5c91 JH |
166 | if (status == Z_OK) |
167 | return; | |
168 | die("deflateInit: %s (%s)", zerr_to_string(status), | |
ef49a7a0 | 169 | strm->z.msg ? strm->z.msg : "no message"); |
55bb5c91 JH |
170 | } |
171 | ||
c3c2e1a0 | 172 | static void do_git_deflate_init(git_zstream *strm, int level, int windowBits) |
55bb5c91 | 173 | { |
ef49a7a0 JH |
174 | int status; |
175 | ||
9a6f1287 | 176 | memset(strm, 0, sizeof(*strm)); |
ef49a7a0 JH |
177 | zlib_pre_call(strm); |
178 | status = deflateInit2(&strm->z, level, | |
55bb5c91 JH |
179 | Z_DEFLATED, windowBits, |
180 | 8, Z_DEFAULT_STRATEGY); | |
ef49a7a0 | 181 | zlib_post_call(strm); |
55bb5c91 JH |
182 | if (status == Z_OK) |
183 | return; | |
184 | die("deflateInit2: %s (%s)", zerr_to_string(status), | |
ef49a7a0 | 185 | strm->z.msg ? strm->z.msg : "no message"); |
55bb5c91 JH |
186 | } |
187 | ||
c3c2e1a0 RS |
188 | void git_deflate_init_gzip(git_zstream *strm, int level) |
189 | { | |
190 | /* | |
191 | * Use default 15 bits, +16 is to generate gzip header/trailer | |
192 | * instead of the zlib wrapper. | |
193 | */ | |
7f49036f | 194 | do_git_deflate_init(strm, level, 15 + 16); |
c3c2e1a0 RS |
195 | } |
196 | ||
197 | void git_deflate_init_raw(git_zstream *strm, int level) | |
198 | { | |
199 | /* | |
200 | * Use default 15 bits, negate the value to get raw compressed | |
201 | * data without zlib header and trailer. | |
202 | */ | |
7f49036f | 203 | do_git_deflate_init(strm, level, -15); |
c3c2e1a0 RS |
204 | } |
205 | ||
568508e7 | 206 | int git_deflate_abort(git_zstream *strm) |
55bb5c91 | 207 | { |
ef49a7a0 | 208 | int status; |
55bb5c91 | 209 | |
ef49a7a0 JH |
210 | zlib_pre_call(strm); |
211 | status = deflateEnd(&strm->z); | |
212 | zlib_post_call(strm); | |
568508e7 JH |
213 | return status; |
214 | } | |
215 | ||
216 | void git_deflate_end(git_zstream *strm) | |
217 | { | |
218 | int status = git_deflate_abort(strm); | |
219 | ||
55bb5c91 JH |
220 | if (status == Z_OK) |
221 | return; | |
222 | error("deflateEnd: %s (%s)", zerr_to_string(status), | |
ef49a7a0 | 223 | strm->z.msg ? strm->z.msg : "no message"); |
55bb5c91 JH |
224 | } |
225 | ||
ef49a7a0 | 226 | int git_deflate_end_gently(git_zstream *strm) |
55bb5c91 | 227 | { |
ef49a7a0 JH |
228 | int status; |
229 | ||
230 | zlib_pre_call(strm); | |
231 | status = deflateEnd(&strm->z); | |
232 | zlib_post_call(strm); | |
233 | return status; | |
55bb5c91 JH |
234 | } |
235 | ||
ef49a7a0 | 236 | int git_deflate(git_zstream *strm, int flush) |
55bb5c91 | 237 | { |
ef49a7a0 | 238 | int status; |
55bb5c91 | 239 | |
e01503b5 JH |
240 | for (;;) { |
241 | zlib_pre_call(strm); | |
242 | ||
243 | /* Never say Z_FINISH unless we are feeding everything */ | |
244 | status = deflate(&strm->z, | |
245 | (strm->z.avail_in != strm->avail_in) | |
246 | ? 0 : flush); | |
247 | if (status == Z_MEM_ERROR) | |
248 | die("deflate: out of memory"); | |
249 | zlib_post_call(strm); | |
250 | ||
251 | /* | |
252 | * Let zlib work another round, while we can still | |
253 | * make progress. | |
254 | */ | |
255 | if ((strm->avail_out && !strm->z.avail_out) && | |
256 | (status == Z_OK || status == Z_BUF_ERROR)) | |
257 | continue; | |
258 | break; | |
259 | } | |
260 | ||
55bb5c91 JH |
261 | switch (status) { |
262 | /* Z_BUF_ERROR: normal, needs more space in the output buffer */ | |
263 | case Z_BUF_ERROR: | |
264 | case Z_OK: | |
265 | case Z_STREAM_END: | |
266 | return status; | |
55bb5c91 JH |
267 | default: |
268 | break; | |
269 | } | |
270 | error("deflate: %s (%s)", zerr_to_string(status), | |
ef49a7a0 | 271 | strm->z.msg ? strm->z.msg : "no message"); |
55bb5c91 JH |
272 | return status; |
273 | } |