contrib/libarchive/libarchive/archive_write_add_filter_lz4.c

   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 */