?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hier.7: Document some recently added directories.
[dragonfly.git] / contrib / libarchive / libarchive / archive_write_add_filter_lz4.c
blob1d0ab8c56a16dc7cc673fa73c6c19ab16521b62f
1 /*-
2 * Copyright (c) 2014 Michihiro NAKAJIMA
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #include "archive_platform.h"
27
28 __FBSDID("$FreeBSD$");
29
30 #ifdef HAVE_ERRNO_H
31 #include <errno.h>
32 #endif
33 #include <stdio.h>
34 #ifdef HAVE_STDLIB_H
35 #include <stdlib.h>
36 #endif
37 #ifdef HAVE_STRING_H
38 #include <string.h>
39 #endif
40 #ifdef HAVE_LZ4_H
41 #include <lz4.h>
42 #endif
43 #ifdef HAVE_LZ4HC_H
44 #include <lz4hc.h>
45 #endif
46
47 #include "archive.h"
48 #include "archive_endian.h"
49 #include "archive_private.h"
50 #include "archive_write_private.h"
51 #include "archive_xxhash.h"
52
53 #define LZ4_MAGICNUMBER 0x184d2204
54
55 struct private_data {
56 int compression_level;
57 unsigned header_written:1;
58 unsigned version_number:1;
59 unsigned block_independence:1;
60 unsigned block_checksum:1;
61 unsigned stream_size:1;
62 unsigned stream_checksum:1;
63 unsigned preset_dictionary:1;
64 unsigned block_maximum_size:3;
65 #if defined(HAVE_LIBLZ4) && LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 2
66 int64_t total_in;
67 char *out;
68 char *out_buffer;
69 size_t out_buffer_size;
70 size_t out_block_size;
71 char *in;
72 char *in_buffer_allocated;
73 char *in_buffer;
74 size_t in_buffer_size;
75 size_t block_size;
76
77 void *xxh32_state;
78 void *lz4_stream;
79 #else
80 struct archive_write_program_data *pdata;
81 #endif
82 };
83
84 static int archive_filter_lz4_close(struct archive_write_filter *);
85 static int archive_filter_lz4_free(struct archive_write_filter *);
86 static int archive_filter_lz4_open(struct archive_write_filter *);
87 static int archive_filter_lz4_options(struct archive_write_filter *,
88 const char *, const char *);
89 static int archive_filter_lz4_write(struct archive_write_filter *,
90 const void *, size_t);
91
92 /*
93 * Add a lz4 compression filter to this write handle.
94 */
95 int
96 archive_write_add_filter_lz4(struct archive *_a)
97 {
98 struct archive_write *a = (struct archive_write *)_a;
99 struct archive_write_filter *f = __archive_write_allocate_filter(_a);
100 struct private_data *data;
101
102 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
103 ARCHIVE_STATE_NEW, "archive_write_add_filter_lz4");
104
105 data = calloc(1, sizeof(*data));
106 if (data == NULL) {
107 archive_set_error(&a->archive, ENOMEM, "Out of memory");
108 return (ARCHIVE_FATAL);
109 }
110
111 /*
112 * Setup default settings.
113 */
114 data->compression_level = 1;
115 data->version_number = 0x01;
116 data->block_independence = 1;
117 data->block_checksum = 0;
118 data->stream_size = 0;
119 data->stream_checksum = 1;
120 data->preset_dictionary = 0;
121 data->block_maximum_size = 7;
122
123 /*
124 * Setup a filter setting.
125 */
126 f->data = data;
127 f->options = &archive_filter_lz4_options;
128 f->close = &archive_filter_lz4_close;
129 f->free = &archive_filter_lz4_free;
130 f->open = &archive_filter_lz4_open;
131 f->code = ARCHIVE_FILTER_LZ4;
132 f->name = "lz4";
133 #if defined(HAVE_LIBLZ4) && LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 2
134 return (ARCHIVE_OK);
135 #else
136 /*
137 * We don't have lz4 library, and execute external lz4 program
138 * instead.
139 */
140 data->pdata = __archive_write_program_allocate("lz4");
141 if (data->pdata == NULL) {
142 free(data);
143 archive_set_error(&a->archive, ENOMEM, "Out of memory");
144 return (ARCHIVE_FATAL);
145 }
146 data->compression_level = 0;
147 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
148 "Using external lz4 program");
149 return (ARCHIVE_WARN);
150 #endif
151 }
152
153 /*
154 * Set write options.
155 */
156 static int
157 archive_filter_lz4_options(struct archive_write_filter *f,
158 const char *key, const char *value)
159 {
160 struct private_data *data = (struct private_data *)f->data;
161
162 if (strcmp(key, "compression-level") == 0) {
163 int val;
164 if (value == NULL || !((val = value[0] - '0') >= 1 && val <= 9) ||
165 value[1] != '\0')
166 return (ARCHIVE_WARN);
167
168 #ifndef HAVE_LZ4HC_H
169 if(val >= 3)
170 {
171 archive_set_error(f->archive, ARCHIVE_ERRNO_PROGRAMMER,
172 "High compression not included in this build");
173 return (ARCHIVE_FATAL);
174 }
175 #endif
176 data->compression_level = val;
177 return (ARCHIVE_OK);
178 }
179 if (strcmp(key, "stream-checksum") == 0) {
180 data->stream_checksum = value != NULL;
181 return (ARCHIVE_OK);
182 }
183 if (strcmp(key, "block-checksum") == 0) {
184 data->block_checksum = value != NULL;
185 return (ARCHIVE_OK);
186 }
187 if (strcmp(key, "block-size") == 0) {
188 if (value == NULL || !(value[0] >= '4' && value[0] <= '7') ||
189 value[1] != '\0')
190 return (ARCHIVE_WARN);
191 data->block_maximum_size = value[0] - '0';
192 return (ARCHIVE_OK);
193 }
194 if (strcmp(key, "block-dependence") == 0) {
195 data->block_independence = value == NULL;
196 return (ARCHIVE_OK);
197 }
198
199 /* Note: The "warn" return is just to inform the options
200 * supervisor that we didn't handle it. It will generate
201 * a suitable error if no one used this option. */
202 return (ARCHIVE_WARN);
203 }
204
205 #if defined(HAVE_LIBLZ4) && LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 2
206 /* Don't compile this if we don't have liblz4. */
207
208 static int drive_compressor(struct archive_write_filter *, const char *,
209 size_t);
210 static int drive_compressor_independence(struct archive_write_filter *,
211 const char *, size_t);
212 static int drive_compressor_dependence(struct archive_write_filter *,
213 const char *, size_t);
214 static int lz4_write_stream_descriptor(struct archive_write_filter *);
215 static ssize_t lz4_write_one_block(struct archive_write_filter *, const char *,
216 size_t);
217
218
219 /*
220 * Setup callback.
221 */
222 static int
223 archive_filter_lz4_open(struct archive_write_filter *f)
224 {
225 struct private_data *data = (struct private_data *)f->data;
226 int ret;
227 size_t required_size;
228 static size_t bkmap[] = { 64 * 1024, 256 * 1024, 1 * 1024 * 1024,
229 4 * 1024 * 1024 };
230 size_t pre_block_size;
231
232 ret = __archive_write_open_filter(f->next_filter);
233 if (ret != 0)
234 return (ret);
235
236 if (data->block_maximum_size < 4)
237 data->block_size = bkmap[0];
238 else
239 data->block_size = bkmap[data->block_maximum_size - 4];
240
241 required_size = 4 + 15 + 4 + data->block_size + 4 + 4;
242 if (data->out_buffer_size < required_size) {
243 size_t bs = required_size, bpb;
244 free(data->out_buffer);
245 if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
246 /* Buffer size should be a multiple number of
247 * the of bytes per block for performance. */
248 bpb = archive_write_get_bytes_per_block(f->archive);
249 if (bpb > bs)
250 bs = bpb;
251 else if (bpb != 0) {
252 bs += bpb;
253 bs -= bs % bpb;
254 }
255 }
256 data->out_block_size = bs;
257 bs += required_size;
258 data->out_buffer = malloc(bs);
259 data->out = data->out_buffer;
260 data->out_buffer_size = bs;
261 }
262
263 pre_block_size = (data->block_independence)? 0: 64 * 1024;
264 if (data->in_buffer_size < data->block_size + pre_block_size) {
265 free(data->in_buffer_allocated);
266 data->in_buffer_size = data->block_size;
267 data->in_buffer_allocated =
268 malloc(data->in_buffer_size + pre_block_size);
269 data->in_buffer = data->in_buffer_allocated + pre_block_size;
270 if (!data->block_independence && data->compression_level >= 3)
271 data->in_buffer = data->in_buffer_allocated;
272 data->in = data->in_buffer;
273 data->in_buffer_size = data->block_size;
274 }
275
276 if (data->out_buffer == NULL || data->in_buffer_allocated == NULL) {
277 archive_set_error(f->archive, ENOMEM,
278 "Can't allocate data for compression buffer");
279 return (ARCHIVE_FATAL);
280 }
281
282 f->write = archive_filter_lz4_write;
283
284 return (ARCHIVE_OK);
285 }
286
287 /*
288 * Write data to the out stream.
289 *
290 * Returns ARCHIVE_OK if all data written, error otherwise.
291 */
292 static int
293 archive_filter_lz4_write(struct archive_write_filter *f,
294 const void *buff, size_t length)
295 {
296 struct private_data *data = (struct private_data *)f->data;
297 int ret = ARCHIVE_OK;
298 const char *p;
299 size_t remaining;
300 ssize_t size;
301
302 /* If we haven't written a stream descriptor, we have to do it first. */
303 if (!data->header_written) {
304 ret = lz4_write_stream_descriptor(f);
305 if (ret != ARCHIVE_OK)
306 return (ret);
307 data->header_written = 1;
308 }
309
310 /* Update statistics */
311 data->total_in += length;
312
313 p = (const char *)buff;
314 remaining = length;
315 while (remaining) {
316 size_t l;
317 /* Compress input data to output buffer */
318 size = lz4_write_one_block(f, p, remaining);
319 if (size < ARCHIVE_OK)
320 return (ARCHIVE_FATAL);
321 l = data->out - data->out_buffer;
322 if (l >= data->out_block_size) {
323 ret = __archive_write_filter(f->next_filter,
324 data->out_buffer, data->out_block_size);
325 l -= data->out_block_size;
326 memcpy(data->out_buffer,
327 data->out_buffer + data->out_block_size, l);
328 data->out = data->out_buffer + l;
329 if (ret < ARCHIVE_WARN)
330 break;
331 }
332 p += size;
333 remaining -= size;
334 }
335
336 return (ret);
337 }
338
339 /*
340 * Finish the compression.
341 */
342 static int
343 archive_filter_lz4_close(struct archive_write_filter *f)
344 {
345 struct private_data *data = (struct private_data *)f->data;
346 int ret, r1;
347
348 /* Finish compression cycle. */
349 ret = (int)lz4_write_one_block(f, NULL, 0);
350 if (ret >= 0) {
351 /*
352 * Write the last block and the end of the stream data.
353 */
354
355 /* Write End Of Stream. */
356 memset(data->out, 0, 4); data->out += 4;
357 /* Write Stream checksum if needed. */
358 if (data->stream_checksum) {
359 unsigned int checksum;
360 checksum = __archive_xxhash.XXH32_digest(
361 data->xxh32_state);
362 data->xxh32_state = NULL;
363 archive_le32enc(data->out, checksum);
364 data->out += 4;
365 }
366 ret = __archive_write_filter(f->next_filter,
367 data->out_buffer, data->out - data->out_buffer);
368 }
369
370 r1 = __archive_write_close_filter(f->next_filter);
371 return (r1 < ret ? r1 : ret);
372 }
373
374 static int
375 archive_filter_lz4_free(struct archive_write_filter *f)
376 {
377 struct private_data *data = (struct private_data *)f->data;
378
379 if (data->lz4_stream != NULL) {
380 #ifdef HAVE_LZ4HC_H
381 if (data->compression_level >= 3)
382 #if LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 7
383 LZ4_freeStreamHC(data->lz4_stream);
384 #else
385 LZ4_freeHC(data->lz4_stream);
386 #endif
387 else
388 #endif
389 #if LZ4_VERSION_MINOR >= 3
390 LZ4_freeStream(data->lz4_stream);
391 #else
392 LZ4_free(data->lz4_stream);
393 #endif
394 }
395 free(data->out_buffer);
396 free(data->in_buffer_allocated);
397 free(data->xxh32_state);
398 free(data);
399 f->data = NULL;
400 return (ARCHIVE_OK);
401 }
402
403 static int
404 lz4_write_stream_descriptor(struct archive_write_filter *f)
405 {
406 struct private_data *data = (struct private_data *)f->data;
407 uint8_t *sd;
408
409 sd = (uint8_t *)data->out;
410 /* Write Magic Number. */
411 archive_le32enc(&sd[0], LZ4_MAGICNUMBER);
412 /* FLG */
413 sd[4] = (data->version_number << 6)
414 | (data->block_independence << 5)
415 | (data->block_checksum << 4)
416 | (data->stream_size << 3)
417 | (data->stream_checksum << 2)
418 | (data->preset_dictionary << 0);
419 /* BD */
420 sd[5] = (data->block_maximum_size << 4);
421 sd[6] = (__archive_xxhash.XXH32(&sd[4], 2, 0) >> 8) & 0xff;
422 data->out += 7;
423 if (data->stream_checksum)
424 data->xxh32_state = __archive_xxhash.XXH32_init(0);
425 else
426 data->xxh32_state = NULL;
427 return (ARCHIVE_OK);
428 }
429
430 static ssize_t
431 lz4_write_one_block(struct archive_write_filter *f, const char *p,
432 size_t length)
433 {
434 struct private_data *data = (struct private_data *)f->data;
435 ssize_t r;
436
437 if (p == NULL) {
438 /* Compress remaining uncompressed data. */
439 if (data->in_buffer == data->in)
440 return 0;
441 else {
442 size_t l = data->in - data->in_buffer;
443 r = drive_compressor(f, data->in_buffer, l);
444 if (r == ARCHIVE_OK)
445 r = (ssize_t)l;
446 }
447 } else if ((data->block_independence || data->compression_level < 3) &&
448 data->in_buffer == data->in && length >= data->block_size) {
449 r = drive_compressor(f, p, data->block_size);
450 if (r == ARCHIVE_OK)
451 r = (ssize_t)data->block_size;
452 } else {
453 size_t remaining_size = data->in_buffer_size -
454 (data->in - data->in_buffer);
455 size_t l = (remaining_size > length)? length: remaining_size;
456 memcpy(data->in, p, l);
457 data->in += l;
458 if (l == remaining_size) {
459 r = drive_compressor(f, data->in_buffer,
460 data->block_size);
461 if (r == ARCHIVE_OK)
462 r = (ssize_t)l;
463 data->in = data->in_buffer;
464 } else
465 r = (ssize_t)l;
466 }
467
468 return (r);
469 }
470
471
472 /*
473 * Utility function to push input data through compressor, writing
474 * full output blocks as necessary.
475 *
476 * Note that this handles both the regular write case (finishing ==
477 * false) and the end-of-archive case (finishing == true).
478 */
479 static int
480 drive_compressor(struct archive_write_filter *f, const char *p, size_t length)
481 {
482 struct private_data *data = (struct private_data *)f->data;
483
484 if (data->stream_checksum)
485 __archive_xxhash.XXH32_update(data->xxh32_state,
486 p, (int)length);
487 if (data->block_independence)
488 return drive_compressor_independence(f, p, length);
489 else
490 return drive_compressor_dependence(f, p, length);
491 }
492
493 static int
494 drive_compressor_independence(struct archive_write_filter *f, const char *p,
495 size_t length)
496 {
497 struct private_data *data = (struct private_data *)f->data;
498 unsigned int outsize;
499
500 #ifdef HAVE_LZ4HC_H
501 if (data->compression_level >= 3)
502 #if LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 7
503 outsize = LZ4_compress_HC(p, data->out + 4,
504 (int)length, (int)data->block_size,
505 data->compression_level);
506 #else
507 outsize = LZ4_compressHC2_limitedOutput(p, data->out + 4,
508 (int)length, (int)data->block_size,
509 data->compression_level);
510 #endif
511 else
512 #endif
513 #if LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 7
514 outsize = LZ4_compress_default(p, data->out + 4,
515 (int)length, (int)data->block_size);
516 #else
517 outsize = LZ4_compress_limitedOutput(p, data->out + 4,
518 (int)length, (int)data->block_size);
519 #endif
520
521 if (outsize) {
522 /* The buffer is compressed. */
523 archive_le32enc(data->out, outsize);
524 data->out += 4;
525 } else {
526 /* The buffer is not compressed. The commpressed size was
527 * bigger than its uncompressed size. */
528 archive_le32enc(data->out, length | 0x80000000);
529 data->out += 4;
530 memcpy(data->out, p, length);
531 outsize = length;
532 }
533 data->out += outsize;
534 if (data->block_checksum) {
535 unsigned int checksum =
536 __archive_xxhash.XXH32(data->out - outsize, outsize, 0);
537 archive_le32enc(data->out, checksum);
538 data->out += 4;
539 }
540 return (ARCHIVE_OK);
541 }
542
543 static int
544 drive_compressor_dependence(struct archive_write_filter *f, const char *p,
545 size_t length)
546 {
547 struct private_data *data = (struct private_data *)f->data;
548 int outsize;
549
550 #define DICT_SIZE (64 * 1024)
551 #ifdef HAVE_LZ4HC_H
552 if (data->compression_level >= 3) {
553 if (data->lz4_stream == NULL) {
554 #if LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 7
555 data->lz4_stream = LZ4_createStreamHC();
556 LZ4_resetStreamHC(data->lz4_stream, data->compression_level);
557 #else
558 data->lz4_stream =
559 LZ4_createHC(data->in_buffer_allocated);
560 #endif
561 if (data->lz4_stream == NULL) {
562 archive_set_error(f->archive, ENOMEM,
563 "Can't allocate data for compression"
564 " buffer");
565 return (ARCHIVE_FATAL);
566 }
567 }
568 else
569 LZ4_loadDictHC(data->lz4_stream, data->in_buffer_allocated, DICT_SIZE);
570
571 #if LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 7
572 outsize = LZ4_compress_HC_continue(
573 data->lz4_stream, p, data->out + 4, (int)length,
574 (int)data->block_size);
575 #else
576 outsize = LZ4_compressHC2_limitedOutput_continue(
577 data->lz4_stream, p, data->out + 4, (int)length,
578 (int)data->block_size, data->compression_level);
579 #endif
580 } else
581 #endif
582 {
583 if (data->lz4_stream == NULL) {
584 data->lz4_stream = LZ4_createStream();
585 if (data->lz4_stream == NULL) {
586 archive_set_error(f->archive, ENOMEM,
587 "Can't allocate data for compression"
588 " buffer");
589 return (ARCHIVE_FATAL);
590 }
591 }
592 else
593 LZ4_loadDict(data->lz4_stream, data->in_buffer_allocated, DICT_SIZE);
594
595 #if LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 7
596 outsize = LZ4_compress_fast_continue(
597 data->lz4_stream, p, data->out + 4, (int)length,
598 (int)data->block_size, 1);
599 #else
600 outsize = LZ4_compress_limitedOutput_continue(
601 data->lz4_stream, p, data->out + 4, (int)length,
602 (int)data->block_size);
603 #endif
604 }
605
606 if (outsize) {
607 /* The buffer is compressed. */
608 archive_le32enc(data->out, outsize);
609 data->out += 4;
610 } else {
611 /* The buffer is not compressed. The commpressed size was
612 * bigger than its uncompressed size. */
613 archive_le32enc(data->out, length | 0x80000000);
614 data->out += 4;
615 memcpy(data->out, p, length);
616 outsize = length;
617 }
618 data->out += outsize;
619 if (data->block_checksum) {
620 unsigned int checksum =
621 __archive_xxhash.XXH32(data->out - outsize, outsize, 0);
622 archive_le32enc(data->out, checksum);
623 data->out += 4;
624 }
625
626 if (length == data->block_size) {
627 #ifdef HAVE_LZ4HC_H
628 if (data->compression_level >= 3) {
629 #if LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 7
630 LZ4_saveDictHC(data->lz4_stream, data->in_buffer_allocated, DICT_SIZE);
631 #else
632 LZ4_slideInputBufferHC(data->lz4_stream);
633 #endif
634 data->in_buffer = data->in_buffer_allocated + DICT_SIZE;
635 }
636 else
637 #endif
638 LZ4_saveDict(data->lz4_stream,
639 data->in_buffer_allocated, DICT_SIZE);
640 #undef DICT_SIZE
641 }
642 return (ARCHIVE_OK);
643 }
644
645 #else /* HAVE_LIBLZ4 */
646
647 static int
648 archive_filter_lz4_open(struct archive_write_filter *f)
649 {
650 struct private_data *data = (struct private_data *)f->data;
651 struct archive_string as;
652 int r;
653
654 archive_string_init(&as);
655 archive_strcpy(&as, "lz4 -z -q -q");
656
657 /* Specify a compression level. */
658 if (data->compression_level > 0) {
659 archive_strcat(&as, " -");
660 archive_strappend_char(&as, '0' + data->compression_level);
661 }
662 /* Specify a block size. */
663 archive_strcat(&as, " -B");
664 archive_strappend_char(&as, '0' + data->block_maximum_size);
665
666 if (data->block_checksum)
667 archive_strcat(&as, " -BX");
668 if (data->stream_checksum == 0)
669 archive_strcat(&as, " --no-frame-crc");
670 if (data->block_independence == 0)
671 archive_strcat(&as, " -BD");
672
673 f->write = archive_filter_lz4_write;
674
675 r = __archive_write_program_open(f, data->pdata, as.s);
676 archive_string_free(&as);
677 return (r);
678 }
679
680 static int
681 archive_filter_lz4_write(struct archive_write_filter *f, const void *buff,
682 size_t length)
683 {
684 struct private_data *data = (struct private_data *)f->data;
685
686 return __archive_write_program_write(f, data->pdata, buff, length);
687 }
688
689 static int
690 archive_filter_lz4_close(struct archive_write_filter *f)
691 {
692 struct private_data *data = (struct private_data *)f->data;
693
694 return __archive_write_program_close(f, data->pdata);
695 }
696
697 static int
698 archive_filter_lz4_free(struct archive_write_filter *f)
699 {
700 struct private_data *data = (struct private_data *)f->data;
701
702 __archive_write_program_free(data->pdata);
703 free(data);
704 return (ARCHIVE_OK);
705 }
706
707 #endif /* HAVE_LIBLZ4 */
DragonFly BSD