contrib/libarchive/libarchive/archive_read_support_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_UNISTD_H
  41 #include <unistd.h>
  42 #endif
  43 #ifdef HAVE_LZ4_H
  44 #include <lz4.h>
  45 #endif
  46
  47 #include "archive.h"
  48 #include "archive_endian.h"
  49 #include "archive_private.h"
  50 #include "archive_read_private.h"
  51 #include "archive_xxhash.h"
  52
  53 #define LZ4_MAGICNUMBER         0x184d2204
  54 #define LZ4_SKIPPABLED          0x184d2a50
  55 #define LZ4_LEGACY              0x184c2102
  56
  57 #if defined(HAVE_LIBLZ4)
  58 struct private_data {
  59         enum {  SELECT_STREAM,
  60                 READ_DEFAULT_STREAM,
  61                 READ_DEFAULT_BLOCK,
  62                 READ_LEGACY_STREAM,
  63                 READ_LEGACY_BLOCK,
  64         }               stage;
  65         struct {
  66                 unsigned block_independence:1;
  67                 unsigned block_checksum:3;
  68                 unsigned stream_size:1;
  69                 unsigned stream_checksum:1;
  70                 unsigned preset_dictionary:1;
  71                 int      block_maximum_size;
  72         } flags;
  73         int64_t          stream_size;
  74         uint32_t         dict_id;
  75         char            *out_block;
  76         size_t           out_block_size;
  77
  78         /* Bytes read but not yet consumed via __archive_read_consume() */
  79         size_t           unconsumed;
  80         size_t           decoded_size;
  81         void            *xxh32_state;
  82
  83         char             valid; /* True = decompressor is initialized */
  84         char             eof; /* True = found end of compressed data. */
  85 };
  86
  87 #define LEGACY_BLOCK_SIZE       (8 * 1024 * 1024)
  88
  89 /* Lz4 filter */
  90 static ssize_t  lz4_filter_read(struct archive_read_filter *, const void **);
  91 static int      lz4_filter_close(struct archive_read_filter *);
  92 #endif
  93
  94 /*
  95  * Note that we can detect lz4 archives even if we can't decompress
  96  * them.  (In fact, we like detecting them because we can give better
  97  * error messages.)  So the bid framework here gets compiled even
  98  * if liblz4 is unavailable.
  99  */
 100 static int      lz4_reader_bid(struct archive_read_filter_bidder *, struct archive_read_filter *);
 101 static int      lz4_reader_init(struct archive_read_filter *);
 102 #if defined(HAVE_LIBLZ4)
 103 static ssize_t  lz4_filter_read_default_stream(struct archive_read_filter *,
 104                     const void **);
 105 static ssize_t  lz4_filter_read_legacy_stream(struct archive_read_filter *,
 106                     const void **);
 107 #endif
 108
 109 static const struct archive_read_filter_bidder_vtable
 110 lz4_bidder_vtable = {
 111         .bid = lz4_reader_bid,
 112         .init = lz4_reader_init,
 113 };
 114
 115 int
 116 archive_read_support_filter_lz4(struct archive *_a)
 117 {
 118         struct archive_read *a = (struct archive_read *)_a;
 119
 120         if (__archive_read_register_bidder(a, NULL, "lz4",
 121                                 &lz4_bidder_vtable) != ARCHIVE_OK)
 122                 return (ARCHIVE_FATAL);
 123
 124 #if defined(HAVE_LIBLZ4)
 125         return (ARCHIVE_OK);
 126 #else
 127         archive_set_error(_a, ARCHIVE_ERRNO_MISC,
 128             "Using external lz4 program");
 129         return (ARCHIVE_WARN);
 130 #endif
 131 }
 132
 133 /*
 134  * Test whether we can handle this data.
 135  *
 136  * This logic returns zero if any part of the signature fails.  It
 137  * also tries to Do The Right Thing if a very short buffer prevents us
 138  * from verifying as much as we would like.
 139  */
 140 static int
 141 lz4_reader_bid(struct archive_read_filter_bidder *self,
 142     struct archive_read_filter *filter)
 143 {
 144         const unsigned char *buffer;
 145         ssize_t avail;
 146         int bits_checked;
 147         uint32_t number;
 148
 149         (void)self; /* UNUSED */
 150
 151         /* Minimal lz4 archive is 11 bytes. */
 152         buffer = __archive_read_filter_ahead(filter, 11, &avail);
 153         if (buffer == NULL)
 154                 return (0);
 155
 156         /* First four bytes must be LZ4 magic numbers. */
 157         bits_checked = 0;
 158         if ((number = archive_le32dec(buffer)) == LZ4_MAGICNUMBER) {
 159                 unsigned char flag, BD;
 160
 161                 bits_checked += 32;
 162                 /* Next follows a stream descriptor. */
 163                 /* Descriptor Flags. */
 164                 flag = buffer[4];
 165                 /* A version number must be "01". */
 166                 if (((flag & 0xc0) >> 6) != 1)
 167                         return (0);
 168                 /* A reserved bit must be "0". */
 169                 if (flag & 2)
 170                         return (0);
 171                 bits_checked += 8;
 172                 BD = buffer[5];
 173                 /* A block maximum size should be more than 3. */
 174                 if (((BD & 0x70) >> 4) < 4)
 175                         return (0);
 176                 /* Reserved bits must be "0". */
 177                 if (BD & ~0x70)
 178                         return (0);
 179                 bits_checked += 8;
 180         } else if (number == LZ4_LEGACY) {
 181                 bits_checked += 32;
 182         }
 183
 184         return (bits_checked);
 185 }
 186
 187 #if !defined(HAVE_LIBLZ4)
 188
 189 /*
 190  * If we don't have the library on this system, we can't actually do the
 191  * decompression.  We can, however, still detect compressed archives
 192  * and emit a useful message.
 193  */
 194 static int
 195 lz4_reader_init(struct archive_read_filter *self)
 196 {
 197         int r;
 198
 199         r = __archive_read_program(self, "lz4 -d -q");
 200         /* Note: We set the format here even if __archive_read_program()
 201          * above fails.  We do, after all, know what the format is
 202          * even if we weren't able to read it. */
 203         self->code = ARCHIVE_FILTER_LZ4;
 204         self->name = "lz4";
 205         return (r);
 206 }
 207
 208
 209 #else
 210
 211 static const struct archive_read_filter_vtable
 212 lz4_reader_vtable = {
 213         .read = lz4_filter_read,
 214         .close = lz4_filter_close,
 215 };
 216
 217 /*
 218  * Setup the callbacks.
 219  */
 220 static int
 221 lz4_reader_init(struct archive_read_filter *self)
 222 {
 223         struct private_data *state;
 224
 225         self->code = ARCHIVE_FILTER_LZ4;
 226         self->name = "lz4";
 227
 228         state = (struct private_data *)calloc(sizeof(*state), 1);
 229         if (state == NULL) {
 230                 archive_set_error(&self->archive->archive, ENOMEM,
 231                     "Can't allocate data for lz4 decompression");
 232                 return (ARCHIVE_FATAL);
 233         }
 234
 235         self->data = state;
 236         state->stage = SELECT_STREAM;
 237         self->vtable = &lz4_reader_vtable;
 238
 239         return (ARCHIVE_OK);
 240 }
 241
 242 static int
 243 lz4_allocate_out_block(struct archive_read_filter *self)
 244 {
 245         struct private_data *state = (struct private_data *)self->data;
 246         size_t out_block_size = state->flags.block_maximum_size;
 247         void *out_block;
 248
 249         if (!state->flags.block_independence)
 250                 out_block_size += 64 * 1024;
 251         if (state->out_block_size < out_block_size) {
 252                 free(state->out_block);
 253                 out_block = (unsigned char *)malloc(out_block_size);
 254                 state->out_block_size = out_block_size;
 255                 if (out_block == NULL) {
 256                         archive_set_error(&self->archive->archive, ENOMEM,
 257                             "Can't allocate data for lz4 decompression");
 258                         return (ARCHIVE_FATAL);
 259                 }
 260                 state->out_block = out_block;
 261         }
 262         if (!state->flags.block_independence)
 263                 memset(state->out_block, 0, 64 * 1024);
 264         return (ARCHIVE_OK);
 265 }
 266
 267 static int
 268 lz4_allocate_out_block_for_legacy(struct archive_read_filter *self)
 269 {
 270         struct private_data *state = (struct private_data *)self->data;
 271         size_t out_block_size = LEGACY_BLOCK_SIZE;
 272         void *out_block;
 273
 274         if (state->out_block_size < out_block_size) {
 275                 free(state->out_block);
 276                 out_block = (unsigned char *)malloc(out_block_size);
 277                 state->out_block_size = out_block_size;
 278                 if (out_block == NULL) {
 279                         archive_set_error(&self->archive->archive, ENOMEM,
 280                             "Can't allocate data for lz4 decompression");
 281                         return (ARCHIVE_FATAL);
 282                 }
 283                 state->out_block = out_block;
 284         }
 285         return (ARCHIVE_OK);
 286 }
 287
 288 /*
 289  * Return the next block of decompressed data.
 290  */
 291 static ssize_t
 292 lz4_filter_read(struct archive_read_filter *self, const void **p)
 293 {
 294         struct private_data *state = (struct private_data *)self->data;
 295         ssize_t ret;
 296
 297         if (state->eof) {
 298                 *p = NULL;
 299                 return (0);
 300         }
 301
 302         __archive_read_filter_consume(self->upstream, state->unconsumed);
 303         state->unconsumed = 0;
 304
 305         switch (state->stage) {
 306         case SELECT_STREAM:
 307                 break;
 308         case READ_DEFAULT_STREAM:
 309         case READ_LEGACY_STREAM:
 310                 /* Reading a lz4 stream already failed. */
 311                 archive_set_error(&self->archive->archive,
 312                     ARCHIVE_ERRNO_MISC, "Invalid sequence.");
 313                 return (ARCHIVE_FATAL);
 314         case READ_DEFAULT_BLOCK:
 315                 ret = lz4_filter_read_default_stream(self, p);
 316                 if (ret != 0 || state->stage != SELECT_STREAM)
 317                         return ret;
 318                 break;
 319         case READ_LEGACY_BLOCK:
 320                 ret = lz4_filter_read_legacy_stream(self, p);
 321                 if (ret != 0 || state->stage != SELECT_STREAM)
 322                         return ret;
 323                 break;
 324         default:
 325                 archive_set_error(&self->archive->archive,
 326                     ARCHIVE_ERRNO_MISC, "Program error.");
 327                 return (ARCHIVE_FATAL);
 328                 break;
 329         }
 330
 331         while (state->stage == SELECT_STREAM) {
 332                 const char *read_buf;
 333
 334                 /* Read a magic number. */
 335                 read_buf = __archive_read_filter_ahead(self->upstream, 4,
 336                                 NULL);
 337                 if (read_buf == NULL) {
 338                         state->eof = 1;
 339                         *p = NULL;
 340                         return (0);
 341                 }
 342                 uint32_t number = archive_le32dec(read_buf);
 343                 __archive_read_filter_consume(self->upstream, 4);
 344                 if (number == LZ4_MAGICNUMBER)
 345                         return lz4_filter_read_default_stream(self, p);
 346                 else if (number == LZ4_LEGACY)
 347                         return lz4_filter_read_legacy_stream(self, p);
 348                 else if ((number & ~0xF) == LZ4_SKIPPABLED) {
 349                         read_buf = __archive_read_filter_ahead(
 350                                 self->upstream, 4, NULL);
 351                         if (read_buf == NULL) {
 352                                 archive_set_error(
 353                                     &self->archive->archive,
 354                                     ARCHIVE_ERRNO_MISC,
 355                                     "Malformed lz4 data");
 356                                 return (ARCHIVE_FATAL);
 357                         }
 358                         uint32_t skip_bytes = archive_le32dec(read_buf);
 359                         __archive_read_filter_consume(self->upstream,
 360                                 4 + skip_bytes);
 361                 } else {
 362                         /* Ignore following unrecognized data. */
 363                         state->eof = 1;
 364                         *p = NULL;
 365                         return (0);
 366                 }
 367         }
 368         state->eof = 1;
 369         *p = NULL;
 370         return (0);
 371 }
 372
 373 static int
 374 lz4_filter_read_descriptor(struct archive_read_filter *self)
 375 {
 376         struct private_data *state = (struct private_data *)self->data;
 377         const char *read_buf;
 378         ssize_t bytes_remaining;
 379         ssize_t descriptor_bytes;
 380         unsigned char flag, bd;
 381         unsigned int chsum, chsum_verifier;
 382
 383         /* Make sure we have 2 bytes for flags. */
 384         read_buf = __archive_read_filter_ahead(self->upstream, 2,
 385             &bytes_remaining);
 386         if (read_buf == NULL) {
 387                 archive_set_error(&self->archive->archive,
 388                     ARCHIVE_ERRNO_MISC,
 389                     "truncated lz4 input");
 390                 return (ARCHIVE_FATAL);
 391         }
 392
 393         /*
 394            Parse flags.
 395          */
 396         flag = (unsigned char)read_buf[0];
 397         /* Verify version number. */
 398         if ((flag & 0xc0) != 1<<6)
 399                 goto malformed_error;
 400         /* A reserved bit must be zero. */
 401         if (flag & 0x02)
 402                 goto malformed_error;
 403         state->flags.block_independence = (flag & 0x20) != 0;
 404         state->flags.block_checksum = (flag & 0x10)?4:0;
 405         state->flags.stream_size = (flag & 0x08) != 0;
 406         state->flags.stream_checksum = (flag & 0x04) != 0;
 407         state->flags.preset_dictionary = (flag & 0x01) != 0;
 408
 409         /* BD */
 410         bd = (unsigned char)read_buf[1];
 411         /* Reserved bits must be zero. */
 412         if (bd & 0x8f)
 413                 goto malformed_error;
 414         /* Get a maximum block size. */
 415         switch (read_buf[1] >> 4) {
 416         case 4: /* 64 KB */
 417                 state->flags.block_maximum_size = 64 * 1024;
 418                 break;
 419         case 5: /* 256 KB */
 420                 state->flags.block_maximum_size = 256 * 1024;
 421                 break;
 422         case 6: /* 1 MB */
 423                 state->flags.block_maximum_size = 1024 * 1024;
 424                 break;
 425         case 7: /* 4 MB */
 426                 state->flags.block_maximum_size = 4 * 1024 * 1024;
 427                 break;
 428         default:
 429                 goto malformed_error;
 430         }
 431
 432         /* Read the whole descriptor in a stream block. */
 433         descriptor_bytes = 3;
 434         if (state->flags.stream_size)
 435                 descriptor_bytes += 8;
 436         if (state->flags.preset_dictionary)
 437                 descriptor_bytes += 4;
 438         if (bytes_remaining < descriptor_bytes) {
 439                 read_buf = __archive_read_filter_ahead(self->upstream,
 440                     descriptor_bytes, &bytes_remaining);
 441                 if (read_buf == NULL) {
 442                         archive_set_error(&self->archive->archive,
 443                             ARCHIVE_ERRNO_MISC,
 444                             "truncated lz4 input");
 445                         return (ARCHIVE_FATAL);
 446                 }
 447         }
 448         /* Check if a descriptor is corrupted */
 449         chsum = __archive_xxhash.XXH32(read_buf, (int)descriptor_bytes -1, 0);
 450         chsum = (chsum >> 8) & 0xff;
 451         chsum_verifier = read_buf[descriptor_bytes-1] & 0xff;
 452         if (chsum != chsum_verifier)
 453                 goto malformed_error;
 454
 455         __archive_read_filter_consume(self->upstream, descriptor_bytes);
 456
 457         /* Make sure we have a large enough buffer for uncompressed data. */
 458         if (lz4_allocate_out_block(self) != ARCHIVE_OK)
 459                 return (ARCHIVE_FATAL);
 460         if (state->flags.stream_checksum)
 461                 state->xxh32_state = __archive_xxhash.XXH32_init(0);
 462
 463         state->decoded_size = 0;
 464         /* Success */
 465         return (ARCHIVE_OK);
 466 malformed_error:
 467         archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
 468             "malformed lz4 data");
 469         return (ARCHIVE_FATAL);
 470 }
 471
 472 static ssize_t
 473 lz4_filter_read_data_block(struct archive_read_filter *self, const void **p)
 474 {
 475         struct private_data *state = (struct private_data *)self->data;
 476         ssize_t compressed_size;
 477         const char *read_buf;
 478         ssize_t bytes_remaining;
 479         int checksum_size;
 480         ssize_t uncompressed_size;
 481         size_t prefix64k;
 482
 483         *p = NULL;
 484
 485         /* Make sure we have 4 bytes for a block size. */
 486         read_buf = __archive_read_filter_ahead(self->upstream, 4,
 487             &bytes_remaining);
 488         if (read_buf == NULL)
 489                 goto truncated_error;
 490         compressed_size = archive_le32dec(read_buf);
 491         if ((compressed_size & 0x7fffffff) > state->flags.block_maximum_size)
 492                 goto malformed_error;
 493         /* A compressed size == 0 means the end of stream blocks. */
 494         if (compressed_size == 0) {
 495                 __archive_read_filter_consume(self->upstream, 4);
 496                 return 0;
 497         }
 498
 499         checksum_size = state->flags.block_checksum;
 500         /* Check if the block is uncompressed. */
 501         if (compressed_size & 0x80000000U) {
 502                 compressed_size &= 0x7fffffff;
 503                 uncompressed_size = compressed_size;
 504         } else
 505                 uncompressed_size = 0;/* Unknown yet. */
 506
 507         /*
 508           Unfortunately, lz4 decompression API requires a whole block
 509           for its decompression speed, so we read a whole block and allocate
 510           a huge buffer used for decoded data.
 511         */
 512         read_buf = __archive_read_filter_ahead(self->upstream,
 513             4 + compressed_size + checksum_size, &bytes_remaining);
 514         if (read_buf == NULL)
 515                 goto truncated_error;
 516
 517         /* Optional processing, checking a block sum. */
 518         if (checksum_size) {
 519                 unsigned int chsum = __archive_xxhash.XXH32(
 520                         read_buf + 4, (int)compressed_size, 0);
 521                 unsigned int chsum_block =
 522                     archive_le32dec(read_buf + 4 + compressed_size);
 523                 if (chsum != chsum_block)
 524                         goto malformed_error;
 525         }
 526
 527
 528         /* If the block is uncompressed, there is nothing to do. */
 529         if (uncompressed_size) {
 530                 /* Prepare a prefix 64k block for next block. */
 531                 if (!state->flags.block_independence) {
 532                         prefix64k = 64 * 1024;
 533                         if (uncompressed_size < (ssize_t)prefix64k) {
 534                                 memcpy(state->out_block
 535                                         + prefix64k - uncompressed_size,
 536                                     read_buf + 4,
 537                                     uncompressed_size);
 538                                 memset(state->out_block, 0,
 539                                     prefix64k - uncompressed_size);
 540                         } else {
 541                                 memcpy(state->out_block,
 542                                     read_buf + 4
 543                                         + uncompressed_size - prefix64k,
 544                                     prefix64k);
 545                         }
 546                         state->decoded_size = 0;
 547                 }
 548                 state->unconsumed = 4 + uncompressed_size + checksum_size;
 549                 *p = read_buf + 4;
 550                 return uncompressed_size;
 551         }
 552
 553         /*
 554            Decompress a block data.
 555          */
 556         if (state->flags.block_independence) {
 557                 prefix64k = 0;
 558                 uncompressed_size = LZ4_decompress_safe(read_buf + 4,
 559                     state->out_block, (int)compressed_size,
 560                     state->flags.block_maximum_size);
 561         } else {
 562                 prefix64k = 64 * 1024;
 563                 if (state->decoded_size) {
 564                         if (state->decoded_size < prefix64k) {
 565                                 memmove(state->out_block
 566                                         + prefix64k - state->decoded_size,
 567                                     state->out_block + prefix64k,
 568                                     state->decoded_size);
 569                                 memset(state->out_block, 0,
 570                                     prefix64k - state->decoded_size);
 571                         } else {
 572                                 memmove(state->out_block,
 573                                     state->out_block + state->decoded_size,
 574                                     prefix64k);
 575                         }
 576                 }
 577 #if LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 7
 578                 uncompressed_size = LZ4_decompress_safe_usingDict(
 579                     read_buf + 4,
 580                     state->out_block + prefix64k, (int)compressed_size,
 581                     state->flags.block_maximum_size,
 582                     state->out_block,
 583                     prefix64k);
 584 #else
 585                 uncompressed_size = LZ4_decompress_safe_withPrefix64k(
 586                     read_buf + 4,
 587                     state->out_block + prefix64k, (int)compressed_size,
 588                     state->flags.block_maximum_size);
 589 #endif
 590         }
 591
 592         /* Check if an error occurred in the decompression process. */
 593         if (uncompressed_size < 0) {
 594                 archive_set_error(&(self->archive->archive),
 595                     ARCHIVE_ERRNO_MISC, "lz4 decompression failed");
 596                 return (ARCHIVE_FATAL);
 597         }
 598
 599         state->unconsumed = 4 + compressed_size + checksum_size;
 600         *p = state->out_block + prefix64k;
 601         state->decoded_size = uncompressed_size;
 602         return uncompressed_size;
 603
 604 malformed_error:
 605         archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
 606             "malformed lz4 data");
 607         return (ARCHIVE_FATAL);
 608 truncated_error:
 609         archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
 610             "truncated lz4 input");
 611         return (ARCHIVE_FATAL);
 612 }
 613
 614 static ssize_t
 615 lz4_filter_read_default_stream(struct archive_read_filter *self, const void **p)
 616 {
 617         struct private_data *state = (struct private_data *)self->data;
 618         const char *read_buf;
 619         ssize_t bytes_remaining;
 620         ssize_t ret;
 621
 622         if (state->stage == SELECT_STREAM) {
 623                 state->stage = READ_DEFAULT_STREAM;
 624                 /* First, read a descriptor. */
 625                 if((ret = lz4_filter_read_descriptor(self)) != ARCHIVE_OK)
 626                         return (ret);
 627                 state->stage = READ_DEFAULT_BLOCK;
 628         }
 629         /* Decompress a block. */
 630         ret = lz4_filter_read_data_block(self, p);
 631
 632         /* If the end of block is detected, change the filter status
 633            to read next stream. */
 634         if (ret == 0 && *p == NULL)
 635                 state->stage = SELECT_STREAM;
 636
 637         /* Optional processing, checking a stream sum. */
 638         if (state->flags.stream_checksum) {
 639                 if (state->stage == SELECT_STREAM) {
 640                         unsigned int checksum;
 641                         unsigned int checksum_stream;
 642                         read_buf = __archive_read_filter_ahead(self->upstream,
 643                             4, &bytes_remaining);
 644                         if (read_buf == NULL) {
 645                                 archive_set_error(&self->archive->archive,
 646                                     ARCHIVE_ERRNO_MISC, "truncated lz4 input");
 647                                 return (ARCHIVE_FATAL);
 648                         }
 649                         checksum = archive_le32dec(read_buf);
 650                         __archive_read_filter_consume(self->upstream, 4);
 651                         checksum_stream = __archive_xxhash.XXH32_digest(
 652                             state->xxh32_state);
 653                         state->xxh32_state = NULL;
 654                         if (checksum != checksum_stream) {
 655                                 archive_set_error(&self->archive->archive,
 656                                     ARCHIVE_ERRNO_MISC,
 657                                     "lz4 stream checksum error");
 658                                 return (ARCHIVE_FATAL);
 659                         }
 660                 } else if (ret > 0)
 661                         __archive_xxhash.XXH32_update(state->xxh32_state,
 662                             *p, (int)ret);
 663         }
 664         return (ret);
 665 }
 666
 667 static ssize_t
 668 lz4_filter_read_legacy_stream(struct archive_read_filter *self, const void **p)
 669 {
 670         struct private_data *state = (struct private_data *)self->data;
 671         uint32_t compressed;
 672         const char *read_buf;
 673         ssize_t ret;
 674
 675         *p = NULL;
 676         ret = lz4_allocate_out_block_for_legacy(self);
 677         if (ret != ARCHIVE_OK)
 678                 return ret;
 679
 680         /* Make sure we have 4 bytes for a block size. */
 681         read_buf = __archive_read_filter_ahead(self->upstream, 4, NULL);
 682         if (read_buf == NULL) {
 683                 if (state->stage == SELECT_STREAM) {
 684                         state->stage = READ_LEGACY_STREAM;
 685                         archive_set_error(&self->archive->archive,
 686                             ARCHIVE_ERRNO_MISC,
 687                             "truncated lz4 input");
 688                         return (ARCHIVE_FATAL);
 689                 }
 690                 state->stage = SELECT_STREAM;
 691                 return 0;
 692         }
 693         state->stage = READ_LEGACY_BLOCK;
 694         compressed = archive_le32dec(read_buf);
 695         if (compressed > LZ4_COMPRESSBOUND(LEGACY_BLOCK_SIZE)) {
 696                 state->stage = SELECT_STREAM;
 697                 return 0;
 698         }
 699
 700         /* Make sure we have a whole block. */
 701         read_buf = __archive_read_filter_ahead(self->upstream,
 702             4 + compressed, NULL);
 703         if (read_buf == NULL) {
 704                 archive_set_error(&(self->archive->archive),
 705                     ARCHIVE_ERRNO_MISC, "truncated lz4 input");
 706                 return (ARCHIVE_FATAL);
 707         }
 708         ret = LZ4_decompress_safe(read_buf + 4, state->out_block,
 709             compressed, (int)state->out_block_size);
 710         if (ret < 0) {
 711                 archive_set_error(&(self->archive->archive),
 712                     ARCHIVE_ERRNO_MISC, "lz4 decompression failed");
 713                 return (ARCHIVE_FATAL);
 714         }
 715         *p = state->out_block;
 716         state->unconsumed = 4 + compressed;
 717         return ret;
 718 }
 719
 720 /*
 721  * Clean up the decompressor.
 722  */
 723 static int
 724 lz4_filter_close(struct archive_read_filter *self)
 725 {
 726         struct private_data *state;
 727         int ret = ARCHIVE_OK;
 728
 729         state = (struct private_data *)self->data;
 730         free(state->xxh32_state);
 731         free(state->out_block);
 732         free(state);
 733         return (ret);
 734 }
 735
 736 #endif /* HAVE_LIBLZ4 */