autoconf: #include <libintl.h> when checking for gettext()
[git] / zlib.c
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 }