Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include "import-compress.h"
4 : : #include "string-table.h"
5 : : #include "util.h"
6 : :
7 : 0 : void import_compress_free(ImportCompress *c) {
8 [ # # ]: 0 : assert(c);
9 : :
10 [ # # ]: 0 : if (c->type == IMPORT_COMPRESS_XZ)
11 : 0 : lzma_end(&c->xz);
12 [ # # ]: 0 : else if (c->type == IMPORT_COMPRESS_GZIP) {
13 [ # # ]: 0 : if (c->encoding)
14 : 0 : deflateEnd(&c->gzip);
15 : : else
16 : 0 : inflateEnd(&c->gzip);
17 : : #if HAVE_BZIP2
18 [ # # ]: 0 : } else if (c->type == IMPORT_COMPRESS_BZIP2) {
19 [ # # ]: 0 : if (c->encoding)
20 : 0 : BZ2_bzCompressEnd(&c->bzip2);
21 : : else
22 : 0 : BZ2_bzDecompressEnd(&c->bzip2);
23 : : #endif
24 : : }
25 : :
26 : 0 : c->type = IMPORT_COMPRESS_UNKNOWN;
27 : 0 : }
28 : :
29 : 0 : int import_uncompress_detect(ImportCompress *c, const void *data, size_t size) {
30 : : static const uint8_t xz_signature[] = {
31 : : 0xfd, '7', 'z', 'X', 'Z', 0x00
32 : : };
33 : : static const uint8_t gzip_signature[] = {
34 : : 0x1f, 0x8b
35 : : };
36 : : static const uint8_t bzip2_signature[] = {
37 : : 'B', 'Z', 'h'
38 : : };
39 : :
40 : : int r;
41 : :
42 [ # # ]: 0 : assert(c);
43 : :
44 [ # # ]: 0 : if (c->type != IMPORT_COMPRESS_UNKNOWN)
45 : 0 : return 1;
46 : :
47 [ # # ]: 0 : if (size < MAX3(sizeof(xz_signature),
48 : : sizeof(gzip_signature),
49 : : sizeof(bzip2_signature)))
50 : 0 : return 0;
51 : :
52 [ # # ]: 0 : assert(data);
53 : :
54 [ # # ]: 0 : if (memcmp(data, xz_signature, sizeof(xz_signature)) == 0) {
55 : : lzma_ret xzr;
56 : :
57 : 0 : xzr = lzma_stream_decoder(&c->xz, UINT64_MAX, LZMA_TELL_UNSUPPORTED_CHECK | LZMA_CONCATENATED);
58 [ # # ]: 0 : if (xzr != LZMA_OK)
59 : 0 : return -EIO;
60 : :
61 : 0 : c->type = IMPORT_COMPRESS_XZ;
62 : :
63 [ # # ]: 0 : } else if (memcmp(data, gzip_signature, sizeof(gzip_signature)) == 0) {
64 : 0 : r = inflateInit2(&c->gzip, 15+16);
65 [ # # ]: 0 : if (r != Z_OK)
66 : 0 : return -EIO;
67 : :
68 : 0 : c->type = IMPORT_COMPRESS_GZIP;
69 : :
70 : : #if HAVE_BZIP2
71 [ # # ]: 0 : } else if (memcmp(data, bzip2_signature, sizeof(bzip2_signature)) == 0) {
72 : 0 : r = BZ2_bzDecompressInit(&c->bzip2, 0, 0);
73 [ # # ]: 0 : if (r != BZ_OK)
74 : 0 : return -EIO;
75 : :
76 : 0 : c->type = IMPORT_COMPRESS_BZIP2;
77 : : #endif
78 : : } else
79 : 0 : c->type = IMPORT_COMPRESS_UNCOMPRESSED;
80 : :
81 : 0 : c->encoding = false;
82 : :
83 : 0 : return 1;
84 : : }
85 : :
86 : 0 : int import_uncompress(ImportCompress *c, const void *data, size_t size, ImportCompressCallback callback, void *userdata) {
87 : : int r;
88 : :
89 [ # # ]: 0 : assert(c);
90 [ # # ]: 0 : assert(callback);
91 : :
92 : 0 : r = import_uncompress_detect(c, data, size);
93 [ # # ]: 0 : if (r <= 0)
94 : 0 : return r;
95 : :
96 [ # # ]: 0 : if (c->encoding)
97 : 0 : return -EINVAL;
98 : :
99 [ # # ]: 0 : if (size <= 0)
100 : 0 : return 1;
101 : :
102 [ # # ]: 0 : assert(data);
103 : :
104 [ # # # # : 0 : switch (c->type) {
# ]
105 : :
106 : 0 : case IMPORT_COMPRESS_UNCOMPRESSED:
107 : 0 : r = callback(data, size, userdata);
108 [ # # ]: 0 : if (r < 0)
109 : 0 : return r;
110 : :
111 : 0 : break;
112 : :
113 : 0 : case IMPORT_COMPRESS_XZ:
114 : 0 : c->xz.next_in = data;
115 : 0 : c->xz.avail_in = size;
116 : :
117 [ # # ]: 0 : while (c->xz.avail_in > 0) {
118 : : uint8_t buffer[16 * 1024];
119 : : lzma_ret lzr;
120 : :
121 : 0 : c->xz.next_out = buffer;
122 : 0 : c->xz.avail_out = sizeof(buffer);
123 : :
124 : 0 : lzr = lzma_code(&c->xz, LZMA_RUN);
125 [ # # # # ]: 0 : if (!IN_SET(lzr, LZMA_OK, LZMA_STREAM_END))
126 : 0 : return -EIO;
127 : :
128 : 0 : r = callback(buffer, sizeof(buffer) - c->xz.avail_out, userdata);
129 [ # # ]: 0 : if (r < 0)
130 : 0 : return r;
131 : : }
132 : :
133 : 0 : break;
134 : :
135 : 0 : case IMPORT_COMPRESS_GZIP:
136 : 0 : c->gzip.next_in = (void*) data;
137 : 0 : c->gzip.avail_in = size;
138 : :
139 [ # # ]: 0 : while (c->gzip.avail_in > 0) {
140 : : uint8_t buffer[16 * 1024];
141 : :
142 : 0 : c->gzip.next_out = buffer;
143 : 0 : c->gzip.avail_out = sizeof(buffer);
144 : :
145 : 0 : r = inflate(&c->gzip, Z_NO_FLUSH);
146 [ # # # # ]: 0 : if (!IN_SET(r, Z_OK, Z_STREAM_END))
147 : 0 : return -EIO;
148 : :
149 : 0 : r = callback(buffer, sizeof(buffer) - c->gzip.avail_out, userdata);
150 [ # # ]: 0 : if (r < 0)
151 : 0 : return r;
152 : : }
153 : :
154 : 0 : break;
155 : :
156 : : #if HAVE_BZIP2
157 : 0 : case IMPORT_COMPRESS_BZIP2:
158 : 0 : c->bzip2.next_in = (void*) data;
159 : 0 : c->bzip2.avail_in = size;
160 : :
161 [ # # ]: 0 : while (c->bzip2.avail_in > 0) {
162 : : uint8_t buffer[16 * 1024];
163 : :
164 : 0 : c->bzip2.next_out = (char*) buffer;
165 : 0 : c->bzip2.avail_out = sizeof(buffer);
166 : :
167 : 0 : r = BZ2_bzDecompress(&c->bzip2);
168 [ # # # # ]: 0 : if (!IN_SET(r, BZ_OK, BZ_STREAM_END))
169 : 0 : return -EIO;
170 : :
171 : 0 : r = callback(buffer, sizeof(buffer) - c->bzip2.avail_out, userdata);
172 [ # # ]: 0 : if (r < 0)
173 : 0 : return r;
174 : : }
175 : :
176 : 0 : break;
177 : : #endif
178 : :
179 : 0 : default:
180 : 0 : assert_not_reached("Unknown compression");
181 : : }
182 : :
183 : 0 : return 1;
184 : : }
185 : :
186 : 0 : int import_compress_init(ImportCompress *c, ImportCompressType t) {
187 : : int r;
188 : :
189 [ # # ]: 0 : assert(c);
190 : :
191 [ # # # # : 0 : switch (t) {
# ]
192 : :
193 : 0 : case IMPORT_COMPRESS_XZ: {
194 : : lzma_ret xzr;
195 : :
196 : 0 : xzr = lzma_easy_encoder(&c->xz, LZMA_PRESET_DEFAULT, LZMA_CHECK_CRC64);
197 [ # # ]: 0 : if (xzr != LZMA_OK)
198 : 0 : return -EIO;
199 : :
200 : 0 : c->type = IMPORT_COMPRESS_XZ;
201 : 0 : break;
202 : : }
203 : :
204 : 0 : case IMPORT_COMPRESS_GZIP:
205 : 0 : r = deflateInit2(&c->gzip, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 + 16, 8, Z_DEFAULT_STRATEGY);
206 [ # # ]: 0 : if (r != Z_OK)
207 : 0 : return -EIO;
208 : :
209 : 0 : c->type = IMPORT_COMPRESS_GZIP;
210 : 0 : break;
211 : :
212 : : #if HAVE_BZIP2
213 : 0 : case IMPORT_COMPRESS_BZIP2:
214 : 0 : r = BZ2_bzCompressInit(&c->bzip2, 9, 0, 0);
215 [ # # ]: 0 : if (r != BZ_OK)
216 : 0 : return -EIO;
217 : :
218 : 0 : c->type = IMPORT_COMPRESS_BZIP2;
219 : 0 : break;
220 : : #endif
221 : :
222 : 0 : case IMPORT_COMPRESS_UNCOMPRESSED:
223 : 0 : c->type = IMPORT_COMPRESS_UNCOMPRESSED;
224 : 0 : break;
225 : :
226 : 0 : default:
227 : 0 : return -EOPNOTSUPP;
228 : : }
229 : :
230 : 0 : c->encoding = true;
231 : 0 : return 0;
232 : : }
233 : :
234 : 0 : static int enlarge_buffer(void **buffer, size_t *buffer_size, size_t *buffer_allocated) {
235 : : size_t l;
236 : : void *p;
237 : :
238 [ # # ]: 0 : if (*buffer_allocated > *buffer_size)
239 : 0 : return 0;
240 : :
241 : 0 : l = MAX(16*1024U, (*buffer_size * 2));
242 : 0 : p = realloc(*buffer, l);
243 [ # # ]: 0 : if (!p)
244 : 0 : return -ENOMEM;
245 : :
246 : 0 : *buffer = p;
247 : 0 : *buffer_allocated = l;
248 : :
249 : 0 : return 1;
250 : : }
251 : :
252 : 0 : int import_compress(ImportCompress *c, const void *data, size_t size, void **buffer, size_t *buffer_size, size_t *buffer_allocated) {
253 : : int r;
254 : :
255 [ # # ]: 0 : assert(c);
256 [ # # ]: 0 : assert(buffer);
257 [ # # ]: 0 : assert(buffer_size);
258 [ # # ]: 0 : assert(buffer_allocated);
259 : :
260 [ # # ]: 0 : if (!c->encoding)
261 : 0 : return -EINVAL;
262 : :
263 [ # # ]: 0 : if (size <= 0)
264 : 0 : return 0;
265 : :
266 [ # # ]: 0 : assert(data);
267 : :
268 : 0 : *buffer_size = 0;
269 : :
270 [ # # # # : 0 : switch (c->type) {
# ]
271 : :
272 : 0 : case IMPORT_COMPRESS_XZ:
273 : :
274 : 0 : c->xz.next_in = data;
275 : 0 : c->xz.avail_in = size;
276 : :
277 [ # # ]: 0 : while (c->xz.avail_in > 0) {
278 : : lzma_ret lzr;
279 : :
280 : 0 : r = enlarge_buffer(buffer, buffer_size, buffer_allocated);
281 [ # # ]: 0 : if (r < 0)
282 : 0 : return r;
283 : :
284 : 0 : c->xz.next_out = (uint8_t*) *buffer + *buffer_size;
285 : 0 : c->xz.avail_out = *buffer_allocated - *buffer_size;
286 : :
287 : 0 : lzr = lzma_code(&c->xz, LZMA_RUN);
288 [ # # ]: 0 : if (lzr != LZMA_OK)
289 : 0 : return -EIO;
290 : :
291 : 0 : *buffer_size += (*buffer_allocated - *buffer_size) - c->xz.avail_out;
292 : : }
293 : :
294 : 0 : break;
295 : :
296 : 0 : case IMPORT_COMPRESS_GZIP:
297 : :
298 : 0 : c->gzip.next_in = (void*) data;
299 : 0 : c->gzip.avail_in = size;
300 : :
301 [ # # ]: 0 : while (c->gzip.avail_in > 0) {
302 : 0 : r = enlarge_buffer(buffer, buffer_size, buffer_allocated);
303 [ # # ]: 0 : if (r < 0)
304 : 0 : return r;
305 : :
306 : 0 : c->gzip.next_out = (uint8_t*) *buffer + *buffer_size;
307 : 0 : c->gzip.avail_out = *buffer_allocated - *buffer_size;
308 : :
309 : 0 : r = deflate(&c->gzip, Z_NO_FLUSH);
310 [ # # ]: 0 : if (r != Z_OK)
311 : 0 : return -EIO;
312 : :
313 : 0 : *buffer_size += (*buffer_allocated - *buffer_size) - c->gzip.avail_out;
314 : : }
315 : :
316 : 0 : break;
317 : :
318 : : #if HAVE_BZIP2
319 : 0 : case IMPORT_COMPRESS_BZIP2:
320 : :
321 : 0 : c->bzip2.next_in = (void*) data;
322 : 0 : c->bzip2.avail_in = size;
323 : :
324 [ # # ]: 0 : while (c->bzip2.avail_in > 0) {
325 : 0 : r = enlarge_buffer(buffer, buffer_size, buffer_allocated);
326 [ # # ]: 0 : if (r < 0)
327 : 0 : return r;
328 : :
329 : 0 : c->bzip2.next_out = (void*) ((uint8_t*) *buffer + *buffer_size);
330 : 0 : c->bzip2.avail_out = *buffer_allocated - *buffer_size;
331 : :
332 : 0 : r = BZ2_bzCompress(&c->bzip2, BZ_RUN);
333 [ # # ]: 0 : if (r != BZ_RUN_OK)
334 : 0 : return -EIO;
335 : :
336 : 0 : *buffer_size += (*buffer_allocated - *buffer_size) - c->bzip2.avail_out;
337 : : }
338 : :
339 : 0 : break;
340 : : #endif
341 : :
342 : 0 : case IMPORT_COMPRESS_UNCOMPRESSED:
343 : :
344 [ # # ]: 0 : if (*buffer_allocated < size) {
345 : : void *p;
346 : :
347 : 0 : p = realloc(*buffer, size);
348 [ # # ]: 0 : if (!p)
349 : 0 : return -ENOMEM;
350 : :
351 : 0 : *buffer = p;
352 : 0 : *buffer_allocated = size;
353 : : }
354 : :
355 : 0 : memcpy(*buffer, data, size);
356 : 0 : *buffer_size = size;
357 : 0 : break;
358 : :
359 : 0 : default:
360 : 0 : return -EOPNOTSUPP;
361 : : }
362 : :
363 : 0 : return 0;
364 : : }
365 : :
366 : 0 : int import_compress_finish(ImportCompress *c, void **buffer, size_t *buffer_size, size_t *buffer_allocated) {
367 : : int r;
368 : :
369 [ # # ]: 0 : assert(c);
370 [ # # ]: 0 : assert(buffer);
371 [ # # ]: 0 : assert(buffer_size);
372 [ # # ]: 0 : assert(buffer_allocated);
373 : :
374 [ # # ]: 0 : if (!c->encoding)
375 : 0 : return -EINVAL;
376 : :
377 : 0 : *buffer_size = 0;
378 : :
379 [ # # # # : 0 : switch (c->type) {
# ]
380 : :
381 : 0 : case IMPORT_COMPRESS_XZ: {
382 : : lzma_ret lzr;
383 : :
384 : 0 : c->xz.avail_in = 0;
385 : :
386 : : do {
387 : 0 : r = enlarge_buffer(buffer, buffer_size, buffer_allocated);
388 [ # # ]: 0 : if (r < 0)
389 : 0 : return r;
390 : :
391 : 0 : c->xz.next_out = (uint8_t*) *buffer + *buffer_size;
392 : 0 : c->xz.avail_out = *buffer_allocated - *buffer_size;
393 : :
394 : 0 : lzr = lzma_code(&c->xz, LZMA_FINISH);
395 [ # # # # ]: 0 : if (!IN_SET(lzr, LZMA_OK, LZMA_STREAM_END))
396 : 0 : return -EIO;
397 : :
398 : 0 : *buffer_size += (*buffer_allocated - *buffer_size) - c->xz.avail_out;
399 [ # # ]: 0 : } while (lzr != LZMA_STREAM_END);
400 : :
401 : 0 : break;
402 : : }
403 : :
404 : 0 : case IMPORT_COMPRESS_GZIP:
405 : 0 : c->gzip.avail_in = 0;
406 : :
407 : : do {
408 : 0 : r = enlarge_buffer(buffer, buffer_size, buffer_allocated);
409 [ # # ]: 0 : if (r < 0)
410 : 0 : return r;
411 : :
412 : 0 : c->gzip.next_out = (uint8_t*) *buffer + *buffer_size;
413 : 0 : c->gzip.avail_out = *buffer_allocated - *buffer_size;
414 : :
415 : 0 : r = deflate(&c->gzip, Z_FINISH);
416 [ # # # # ]: 0 : if (!IN_SET(r, Z_OK, Z_STREAM_END))
417 : 0 : return -EIO;
418 : :
419 : 0 : *buffer_size += (*buffer_allocated - *buffer_size) - c->gzip.avail_out;
420 [ # # ]: 0 : } while (r != Z_STREAM_END);
421 : :
422 : 0 : break;
423 : :
424 : : #if HAVE_BZIP2
425 : 0 : case IMPORT_COMPRESS_BZIP2:
426 : 0 : c->bzip2.avail_in = 0;
427 : :
428 : : do {
429 : 0 : r = enlarge_buffer(buffer, buffer_size, buffer_allocated);
430 [ # # ]: 0 : if (r < 0)
431 : 0 : return r;
432 : :
433 : 0 : c->bzip2.next_out = (void*) ((uint8_t*) *buffer + *buffer_size);
434 : 0 : c->bzip2.avail_out = *buffer_allocated - *buffer_size;
435 : :
436 : 0 : r = BZ2_bzCompress(&c->bzip2, BZ_FINISH);
437 [ # # # # ]: 0 : if (!IN_SET(r, BZ_FINISH_OK, BZ_STREAM_END))
438 : 0 : return -EIO;
439 : :
440 : 0 : *buffer_size += (*buffer_allocated - *buffer_size) - c->bzip2.avail_out;
441 [ # # ]: 0 : } while (r != BZ_STREAM_END);
442 : :
443 : 0 : break;
444 : : #endif
445 : :
446 : 0 : case IMPORT_COMPRESS_UNCOMPRESSED:
447 : 0 : break;
448 : :
449 : 0 : default:
450 : 0 : return -EOPNOTSUPP;
451 : : }
452 : :
453 : 0 : return 0;
454 : : }
455 : :
456 : : static const char* const import_compress_type_table[_IMPORT_COMPRESS_TYPE_MAX] = {
457 : : [IMPORT_COMPRESS_UNKNOWN] = "unknown",
458 : : [IMPORT_COMPRESS_UNCOMPRESSED] = "uncompressed",
459 : : [IMPORT_COMPRESS_XZ] = "xz",
460 : : [IMPORT_COMPRESS_GZIP] = "gzip",
461 : : #if HAVE_BZIP2
462 : : [IMPORT_COMPRESS_BZIP2] = "bzip2",
463 : : #endif
464 : : };
465 : :
466 [ # # # # ]: 0 : DEFINE_STRING_TABLE_LOOKUP(import_compress_type, ImportCompressType);
|
