]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * zlib wrappers to make sure we don't silently miss errors | |
3 | * at init time. | |
4 | */ | |
5 | #include "cache.h" | |
6 | ||
7 | static const char *zerr_to_string(int status) | |
8 | { | |
9 | switch (status) { | |
10 | case Z_MEM_ERROR: | |
11 | return "out of memory"; | |
12 | case Z_VERSION_ERROR: | |
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"; | |
20 | default: | |
21 | return "unknown error"; | |
22 | } | |
23 | } | |
24 | ||
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 | */ | |
30 | /* #define ZLIB_BUF_MAX ((uInt)-1) */ | |
31 | #define ZLIB_BUF_MAX ((uInt) 1024 * 1024 * 1024) /* 1GB */ | |
32 | static inline uInt zlib_buf_cap(unsigned long len) | |
33 | { | |
34 | return (ZLIB_BUF_MAX < len) ? ZLIB_BUF_MAX : len; | |
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 | { | |
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) | |
55 | BUG("total_out mismatch"); | |
56 | if (s->z.total_in != s->total_in + bytes_consumed) | |
57 | BUG("total_in mismatch"); | |
58 | ||
59 | s->total_out = s->z.total_out; | |
60 | s->total_in = s->z.total_in; | |
61 | s->next_in = s->z.next_in; | |
62 | s->next_out = s->z.next_out; | |
63 | s->avail_in -= bytes_consumed; | |
64 | s->avail_out -= bytes_produced; | |
65 | } | |
66 | ||
67 | void git_inflate_init(git_zstream *strm) | |
68 | { | |
69 | int status; | |
70 | ||
71 | zlib_pre_call(strm); | |
72 | status = inflateInit(&strm->z); | |
73 | zlib_post_call(strm); | |
74 | if (status == Z_OK) | |
75 | return; | |
76 | die("inflateInit: %s (%s)", zerr_to_string(status), | |
77 | strm->z.msg ? strm->z.msg : "no message"); | |
78 | } | |
79 | ||
80 | void git_inflate_init_gzip_only(git_zstream *strm) | |
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; | |
87 | int status; | |
88 | ||
89 | zlib_pre_call(strm); | |
90 | status = inflateInit2(&strm->z, windowBits); | |
91 | zlib_post_call(strm); | |
92 | if (status == Z_OK) | |
93 | return; | |
94 | die("inflateInit2: %s (%s)", zerr_to_string(status), | |
95 | strm->z.msg ? strm->z.msg : "no message"); | |
96 | } | |
97 | ||
98 | void git_inflate_end(git_zstream *strm) | |
99 | { | |
100 | int status; | |
101 | ||
102 | zlib_pre_call(strm); | |
103 | status = inflateEnd(&strm->z); | |
104 | zlib_post_call(strm); | |
105 | if (status == Z_OK) | |
106 | return; | |
107 | error("inflateEnd: %s (%s)", zerr_to_string(status), | |
108 | strm->z.msg ? strm->z.msg : "no message"); | |
109 | } | |
110 | ||
111 | int git_inflate(git_zstream *strm, int flush) | |
112 | { | |
113 | int status; | |
114 | ||
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 | ||
135 | switch (status) { | |
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: | |
140 | return status; | |
141 | default: | |
142 | break; | |
143 | } | |
144 | error("inflate: %s (%s)", zerr_to_string(status), | |
145 | strm->z.msg ? strm->z.msg : "no message"); | |
146 | return status; | |
147 | } | |
148 | ||
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 | ||
153 | unsigned long git_deflate_bound(git_zstream *strm, unsigned long size) | |
154 | { | |
155 | return deflateBound(&strm->z, size); | |
156 | } | |
157 | ||
158 | void git_deflate_init(git_zstream *strm, int level) | |
159 | { | |
160 | int status; | |
161 | ||
162 | memset(strm, 0, sizeof(*strm)); | |
163 | zlib_pre_call(strm); | |
164 | status = deflateInit(&strm->z, level); | |
165 | zlib_post_call(strm); | |
166 | if (status == Z_OK) | |
167 | return; | |
168 | die("deflateInit: %s (%s)", zerr_to_string(status), | |
169 | strm->z.msg ? strm->z.msg : "no message"); | |
170 | } | |
171 | ||
172 | static void do_git_deflate_init(git_zstream *strm, int level, int windowBits) | |
173 | { | |
174 | int status; | |
175 | ||
176 | memset(strm, 0, sizeof(*strm)); | |
177 | zlib_pre_call(strm); | |
178 | status = deflateInit2(&strm->z, level, | |
179 | Z_DEFLATED, windowBits, | |
180 | 8, Z_DEFAULT_STRATEGY); | |
181 | zlib_post_call(strm); | |
182 | if (status == Z_OK) | |
183 | return; | |
184 | die("deflateInit2: %s (%s)", zerr_to_string(status), | |
185 | strm->z.msg ? strm->z.msg : "no message"); | |
186 | } | |
187 | ||
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 | */ | |
194 | do_git_deflate_init(strm, level, 15 + 16); | |
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 | */ | |
203 | do_git_deflate_init(strm, level, -15); | |
204 | } | |
205 | ||
206 | int git_deflate_abort(git_zstream *strm) | |
207 | { | |
208 | int status; | |
209 | ||
210 | zlib_pre_call(strm); | |
211 | status = deflateEnd(&strm->z); | |
212 | zlib_post_call(strm); | |
213 | return status; | |
214 | } | |
215 | ||
216 | void git_deflate_end(git_zstream *strm) | |
217 | { | |
218 | int status = git_deflate_abort(strm); | |
219 | ||
220 | if (status == Z_OK) | |
221 | return; | |
222 | error("deflateEnd: %s (%s)", zerr_to_string(status), | |
223 | strm->z.msg ? strm->z.msg : "no message"); | |
224 | } | |
225 | ||
226 | int git_deflate_end_gently(git_zstream *strm) | |
227 | { | |
228 | int status; | |
229 | ||
230 | zlib_pre_call(strm); | |
231 | status = deflateEnd(&strm->z); | |
232 | zlib_post_call(strm); | |
233 | return status; | |
234 | } | |
235 | ||
236 | int git_deflate(git_zstream *strm, int flush) | |
237 | { | |
238 | int status; | |
239 | ||
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 | ||
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; | |
267 | default: | |
268 | break; | |
269 | } | |
270 | error("deflate: %s (%s)", zerr_to_string(status), | |
271 | strm->z.msg ? strm->z.msg : "no message"); | |
272 | return status; | |
273 | } |