]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Copyright (C) the libgit2 contributors. All rights reserved. | |
3 | * | |
4 | * This file is part of libgit2, distributed under the GNU GPL v2 with | |
5 | * a Linking Exception. For full terms see the included COPYING file. | |
6 | */ | |
7 | ||
8 | #include "zstream.h" | |
9 | ||
10 | #include <zlib.h> | |
11 | ||
12 | #include "buffer.h" | |
13 | ||
14 | #define ZSTREAM_BUFFER_SIZE (1024 * 1024) | |
15 | #define ZSTREAM_BUFFER_MIN_EXTRA 8 | |
16 | ||
17 | GIT_INLINE(int) zstream_seterr(git_zstream *zs) | |
18 | { | |
19 | switch (zs->zerr) { | |
20 | case Z_OK: | |
21 | case Z_STREAM_END: | |
22 | case Z_BUF_ERROR: /* not fatal; we retry with a larger buffer */ | |
23 | return 0; | |
24 | case Z_MEM_ERROR: | |
25 | git_error_set_oom(); | |
26 | break; | |
27 | default: | |
28 | if (zs->z.msg) | |
29 | git_error_set_str(GIT_ERROR_ZLIB, zs->z.msg); | |
30 | else | |
31 | git_error_set(GIT_ERROR_ZLIB, "unknown compression error"); | |
32 | } | |
33 | ||
34 | return -1; | |
35 | } | |
36 | ||
37 | int git_zstream_init(git_zstream *zstream, git_zstream_t type) | |
38 | { | |
39 | zstream->type = type; | |
40 | ||
41 | if (zstream->type == GIT_ZSTREAM_INFLATE) | |
42 | zstream->zerr = inflateInit(&zstream->z); | |
43 | else | |
44 | zstream->zerr = deflateInit(&zstream->z, Z_DEFAULT_COMPRESSION); | |
45 | return zstream_seterr(zstream); | |
46 | } | |
47 | ||
48 | void git_zstream_free(git_zstream *zstream) | |
49 | { | |
50 | if (zstream->type == GIT_ZSTREAM_INFLATE) | |
51 | inflateEnd(&zstream->z); | |
52 | else | |
53 | deflateEnd(&zstream->z); | |
54 | } | |
55 | ||
56 | void git_zstream_reset(git_zstream *zstream) | |
57 | { | |
58 | if (zstream->type == GIT_ZSTREAM_INFLATE) | |
59 | inflateReset(&zstream->z); | |
60 | else | |
61 | deflateReset(&zstream->z); | |
62 | zstream->in = NULL; | |
63 | zstream->in_len = 0; | |
64 | zstream->zerr = Z_STREAM_END; | |
65 | } | |
66 | ||
67 | int git_zstream_set_input(git_zstream *zstream, const void *in, size_t in_len) | |
68 | { | |
69 | zstream->in = in; | |
70 | zstream->in_len = in_len; | |
71 | zstream->zerr = Z_OK; | |
72 | return 0; | |
73 | } | |
74 | ||
75 | bool git_zstream_done(git_zstream *zstream) | |
76 | { | |
77 | return (!zstream->in_len && zstream->zerr == Z_STREAM_END); | |
78 | } | |
79 | ||
80 | bool git_zstream_eos(git_zstream *zstream) | |
81 | { | |
82 | return zstream->zerr == Z_STREAM_END; | |
83 | } | |
84 | ||
85 | size_t git_zstream_suggest_output_len(git_zstream *zstream) | |
86 | { | |
87 | if (zstream->in_len > ZSTREAM_BUFFER_SIZE) | |
88 | return ZSTREAM_BUFFER_SIZE; | |
89 | else if (zstream->in_len > ZSTREAM_BUFFER_MIN_EXTRA) | |
90 | return zstream->in_len; | |
91 | else | |
92 | return ZSTREAM_BUFFER_MIN_EXTRA; | |
93 | } | |
94 | ||
95 | int git_zstream_get_output_chunk( | |
96 | void *out, size_t *out_len, git_zstream *zstream) | |
97 | { | |
98 | size_t in_queued, in_used, out_queued; | |
99 | ||
100 | /* set up input data */ | |
101 | zstream->z.next_in = (Bytef *)zstream->in; | |
102 | ||
103 | /* feed as much data to zlib as it can consume, at most UINT_MAX */ | |
104 | if (zstream->in_len > UINT_MAX) { | |
105 | zstream->z.avail_in = UINT_MAX; | |
106 | zstream->flush = Z_NO_FLUSH; | |
107 | } else { | |
108 | zstream->z.avail_in = (uInt)zstream->in_len; | |
109 | zstream->flush = Z_FINISH; | |
110 | } | |
111 | in_queued = (size_t)zstream->z.avail_in; | |
112 | ||
113 | /* set up output data */ | |
114 | zstream->z.next_out = out; | |
115 | zstream->z.avail_out = (uInt)*out_len; | |
116 | ||
117 | if ((size_t)zstream->z.avail_out != *out_len) | |
118 | zstream->z.avail_out = UINT_MAX; | |
119 | out_queued = (size_t)zstream->z.avail_out; | |
120 | ||
121 | /* compress next chunk */ | |
122 | if (zstream->type == GIT_ZSTREAM_INFLATE) | |
123 | zstream->zerr = inflate(&zstream->z, zstream->flush); | |
124 | else | |
125 | zstream->zerr = deflate(&zstream->z, zstream->flush); | |
126 | ||
127 | if (zstream_seterr(zstream)) | |
128 | return -1; | |
129 | ||
130 | in_used = (in_queued - zstream->z.avail_in); | |
131 | zstream->in_len -= in_used; | |
132 | zstream->in += in_used; | |
133 | ||
134 | *out_len = (out_queued - zstream->z.avail_out); | |
135 | ||
136 | return 0; | |
137 | } | |
138 | ||
139 | int git_zstream_get_output(void *out, size_t *out_len, git_zstream *zstream) | |
140 | { | |
141 | size_t out_remain = *out_len; | |
142 | ||
143 | if (zstream->in_len && zstream->zerr == Z_STREAM_END) { | |
144 | git_error_set(GIT_ERROR_ZLIB, "zlib input had trailing garbage"); | |
145 | return -1; | |
146 | } | |
147 | ||
148 | while (out_remain > 0 && zstream->zerr != Z_STREAM_END) { | |
149 | size_t out_written = out_remain; | |
150 | ||
151 | if (git_zstream_get_output_chunk(out, &out_written, zstream) < 0) | |
152 | return -1; | |
153 | ||
154 | out_remain -= out_written; | |
155 | out = ((char *)out) + out_written; | |
156 | } | |
157 | ||
158 | /* either we finished the input or we did not flush the data */ | |
159 | GIT_ASSERT(zstream->in_len > 0 || zstream->flush == Z_FINISH); | |
160 | ||
161 | /* set out_size to number of bytes actually written to output */ | |
162 | *out_len = *out_len - out_remain; | |
163 | ||
164 | return 0; | |
165 | } | |
166 | ||
167 | static int zstream_buf(git_buf *out, const void *in, size_t in_len, git_zstream_t type) | |
168 | { | |
169 | git_zstream zs = GIT_ZSTREAM_INIT; | |
170 | int error = 0; | |
171 | ||
172 | if ((error = git_zstream_init(&zs, type)) < 0) | |
173 | return error; | |
174 | ||
175 | if ((error = git_zstream_set_input(&zs, in, in_len)) < 0) | |
176 | goto done; | |
177 | ||
178 | while (!git_zstream_done(&zs)) { | |
179 | size_t step = git_zstream_suggest_output_len(&zs), written; | |
180 | ||
181 | if ((error = git_buf_grow_by(out, step)) < 0) | |
182 | goto done; | |
183 | ||
184 | written = out->asize - out->size; | |
185 | ||
186 | if ((error = git_zstream_get_output( | |
187 | out->ptr + out->size, &written, &zs)) < 0) | |
188 | goto done; | |
189 | ||
190 | out->size += written; | |
191 | } | |
192 | ||
193 | /* NULL terminate for consistency if possible */ | |
194 | if (out->size < out->asize) | |
195 | out->ptr[out->size] = '\0'; | |
196 | ||
197 | done: | |
198 | git_zstream_free(&zs); | |
199 | return error; | |
200 | } | |
201 | ||
202 | int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len) | |
203 | { | |
204 | return zstream_buf(out, in, in_len, GIT_ZSTREAM_DEFLATE); | |
205 | } | |
206 | ||
207 | int git_zstream_inflatebuf(git_buf *out, const void *in, size_t in_len) | |
208 | { | |
209 | return zstream_buf(out, in, in_len, GIT_ZSTREAM_INFLATE); | |
210 | } |