2 * Copyright (c) 2018 Grzegorz Antoniak (http://antoniak.org)
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
26 #include "archive_platform.h"
27 #include "archive_endian.h"
34 #include <zlib.h> /* crc32 */
39 #include "archive_crc32.h"
42 #include "archive_entry.h"
43 #include "archive_entry_locale.h"
44 #include "archive_ppmd7_private.h"
45 #include "archive_entry_private.h"
50 #include "archive_blake2.h"
53 /*#define CHECK_CRC_ON_SOLID_SKIP*/
54 /*#define DONT_FAIL_ON_CRC_ERROR*/
57 #define rar5_min(a, b) (((a) > (b)) ? (b) : (a))
58 #define rar5_max(a, b) (((a) > (b)) ? (a) : (b))
59 #define rar5_countof(X) ((const ssize_t) (sizeof(X) / sizeof(*X)))
62 #define DEBUG_CODE if(1)
64 #define DEBUG_CODE if(0)
67 /* Real RAR5 magic number is:
69 * 0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x01, 0x00
72 * It's stored in `rar5_signature` after XOR'ing it with 0xA1, because I don't
73 * want to put this magic sequence in each binary that uses libarchive, so
74 * applications that scan through the file for this marker won't trigger on
77 * The array itself is decrypted in `rar5_init` function. */
79 static unsigned char rar5_signature[] = { 243, 192, 211, 128, 187, 166, 160, 161 };
80 static const ssize_t rar5_signature_size = sizeof(rar5_signature);
81 /* static const size_t g_unpack_buf_chunk_size = 1024; */
82 static const size_t g_unpack_window_size = 0x20000;
85 ssize_t bytes_remaining;
86 ssize_t unpacked_size;
87 int64_t last_offset; /* Used in sanity checks. */
88 int64_t last_size; /* Used in sanity checks. */
90 uint8_t solid : 1; /* Is this a solid stream? */
91 uint8_t service : 1; /* Is this file a service data? */
92 uint8_t eof : 1; /* Did we finish unpacking the file? */
94 /* Optional time fields. */
100 /* Optional hash fields. */
101 uint32_t stored_crc32;
102 uint32_t calculated_crc32;
103 uint8_t blake2sp[32];
104 blake2sp_state b2state;
109 FILTER_DELTA = 0, /* Generic pattern. */
110 FILTER_E8 = 1, /* Intel x86 code. */
111 FILTER_E8E9 = 2, /* Intel x86 code. */
112 FILTER_ARM = 3, /* ARM code. */
113 FILTER_AUDIO = 4, /* Audio filter, not used in RARv5. */
114 FILTER_RGB = 5, /* Color palette, not used in RARv5. */
115 FILTER_ITANIUM = 6, /* Intel's Itanium, not used in RARv5. */
116 FILTER_PPM = 7, /* Predictive pattern matching, not used in RARv5. */
126 ssize_t block_length;
145 struct decode_table {
147 int32_t decode_len[16];
148 uint32_t decode_pos[16];
150 uint8_t quick_len[1 << 10];
151 uint16_t quick_num[1 << 10];
152 uint16_t decode_num[306];
156 /* Flag used to specify if unpacker needs to reinitialize the uncompression
158 uint8_t initialized : 1;
160 /* Flag used when applying filters. */
161 uint8_t all_filters_applied : 1;
163 /* Flag used to skip file context reinitialization, used when unpacker is
164 * skipping through different multivolume archives. */
165 uint8_t switch_multivolume : 1;
167 /* Flag used to specify if unpacker has processed the whole data block or
168 * just a part of it. */
169 uint8_t block_parsing_finished : 1;
173 int flags; /* Uncompression flags. */
174 int method; /* Uncompression algorithm method. */
175 int version; /* Uncompression algorithm version. */
176 ssize_t window_size; /* Size of window_buf. */
177 uint8_t* window_buf; /* Circular buffer used during
179 uint8_t* filtered_buf; /* Buffer used when applying filters. */
180 const uint8_t* block_buf; /* Buffer used when merging blocks. */
181 size_t window_mask; /* Convenience field; window_size - 1. */
182 int64_t write_ptr; /* This amount of data has been unpacked in
183 the window buffer. */
184 int64_t last_write_ptr; /* This amount of data has been stored in
186 int64_t last_unstore_ptr; /* Counter of bytes extracted during
187 unstoring. This is separate from
188 last_write_ptr because of how SERVICE
189 base blocks are handled during skipping
190 in solid multiarchive archives. */
191 int64_t solid_offset; /* Additional offset inside the window
192 buffer, used in unpacking solid
194 ssize_t cur_block_size; /* Size of current data block. */
195 int last_len; /* Flag used in lzss decompression. */
197 /* Decode tables used during lzss uncompression. */
200 struct decode_table bd; /* huffman bit lengths */
202 struct decode_table ld; /* literals */
204 struct decode_table dd; /* distances */
206 struct decode_table ldd; /* lower bits of distances */
208 struct decode_table rd; /* repeating distances */
209 #define HUFF_TABLE_SIZE (HUFF_NC + HUFF_DC + HUFF_RC + HUFF_LDC)
211 /* Circular deque for storing filters. */
212 struct cdeque filters;
213 int64_t last_block_start; /* Used for sanity checking. */
214 ssize_t last_block_length; /* Used for sanity checking. */
216 /* Distance cache used during lzss uncompression. */
219 /* Data buffer stack. */
220 struct data_ready dready[2];
223 /* Bit reader state. */
225 int8_t bit_addr; /* Current bit pointer inside current byte. */
226 int in_addr; /* Current byte pointer. */
229 /* RARv5 block header structure. Use bf_* functions to get values from
230 * block_flags_u8 field. I.e. bf_byte_count, etc. */
231 struct compressed_block_header {
232 /* block_flags_u8 contain fields encoded in little-endian bitfield:
234 * - table present flag (shr 7, and 1),
235 * - last block flag (shr 6, and 1),
236 * - byte_count (shr 3, and 7),
237 * - bit_size (shr 0, and 7).
239 uint8_t block_flags_u8;
243 /* RARv5 main header structure. */
245 /* Does the archive contain solid streams? */
248 /* If this a multi-file archive? */
256 struct generic_header {
257 uint8_t split_after : 1;
258 uint8_t split_before : 1;
269 /* Main context structure. */
271 int header_initialized;
273 /* Set to 1 if current file is positioned AFTER the magic value
274 * of the archive file. This is used in header reading functions. */
277 /* Set to not zero if we're in skip mode (either by calling rar5_data_skip
278 * function or when skipping over solid streams). Set to 0 when in
279 * extraction mode. This is used during checksum calculation functions. */
282 /* An offset to QuickOpen list. This is not supported by this unpacker,
283 * because we're focusing on streaming interface. QuickOpen is designed
284 * to make things quicker for non-stream interfaces, so it's not our
286 uint64_t qlist_offset;
288 /* An offset to additional Recovery data. This is not supported by this
289 * unpacker. Recovery data are additional Reed-Solomon codes that could
290 * be used to calculate bytes that are missing in archive or are
294 /* Various context variables grouped to different structures. */
295 struct generic_header generic;
296 struct main_header main;
297 struct comp_state cstate;
298 struct file_header file;
299 struct bit_reader bits;
300 struct multivolume vol;
302 /* The header of currently processed RARv5 block. Used in main
303 * decompression logic loop. */
304 struct compressed_block_header last_block_hdr;
307 /* Forward function declarations. */
309 static int verify_global_checksums(struct archive_read* a);
310 static int rar5_read_data_skip(struct archive_read *a);
311 static int push_data_ready(struct archive_read* a, struct rar5* rar,
312 const uint8_t* buf, size_t size, int64_t offset);
314 /* CDE_xxx = Circular Double Ended (Queue) return values. */
315 enum CDE_RETURN_VALUES {
316 CDE_OK, CDE_ALLOC, CDE_PARAM, CDE_OUT_OF_BOUNDS,
319 /* Clears the contents of this circular deque. */
320 static void cdeque_clear(struct cdeque* d) {
326 /* Creates a new circular deque object. Capacity must be power of 2: 8, 16, 32,
327 * 64, 256, etc. When the user will add another item above current capacity,
328 * the circular deque will overwrite the oldest entry. */
329 static int cdeque_init(struct cdeque* d, int max_capacity_power_of_2) {
330 if(d == NULL || max_capacity_power_of_2 == 0)
333 d->cap_mask = max_capacity_power_of_2 - 1;
336 if((max_capacity_power_of_2 & d->cap_mask) > 0)
340 d->arr = malloc(sizeof(void*) * max_capacity_power_of_2);
342 return d->arr ? CDE_OK : CDE_ALLOC;
345 /* Return the current size (not capacity) of circular deque `d`. */
346 static size_t cdeque_size(struct cdeque* d) {
350 /* Returns the first element of current circular deque. Note that this function
351 * doesn't perform any bounds checking. If you need bounds checking, use
352 * `cdeque_front()` function instead. */
353 static void cdeque_front_fast(struct cdeque* d, void** value) {
354 *value = (void*) d->arr[d->beg_pos];
357 /* Returns the first element of current circular deque. This function
358 * performs bounds checking. */
359 static int cdeque_front(struct cdeque* d, void** value) {
361 cdeque_front_fast(d, value);
364 return CDE_OUT_OF_BOUNDS;
367 /* Pushes a new element into the end of this circular deque object. If current
368 * size will exceed capacity, the oldest element will be overwritten. */
369 static int cdeque_push_back(struct cdeque* d, void* item) {
373 if(d->size == d->cap_mask + 1)
374 return CDE_OUT_OF_BOUNDS;
376 d->arr[d->end_pos] = (size_t) item;
377 d->end_pos = (d->end_pos + 1) & d->cap_mask;
383 /* Pops a front element of this circular deque object and returns its value.
384 * This function doesn't perform any bounds checking. */
385 static void cdeque_pop_front_fast(struct cdeque* d, void** value) {
386 *value = (void*) d->arr[d->beg_pos];
387 d->beg_pos = (d->beg_pos + 1) & d->cap_mask;
391 /* Pops a front element of this circular deque object and returns its value.
392 * This function performs bounds checking. */
393 static int cdeque_pop_front(struct cdeque* d, void** value) {
398 return CDE_OUT_OF_BOUNDS;
400 cdeque_pop_front_fast(d, value);
404 /* Convenience function to cast filter_info** to void **. */
405 static void** cdeque_filter_p(struct filter_info** f) {
406 return (void**) (size_t) f;
409 /* Convenience function to cast filter_info* to void *. */
410 static void* cdeque_filter(struct filter_info* f) {
411 return (void**) (size_t) f;
414 /* Destroys this circular deque object. Deallocates the memory of the collection
415 * buffer, but doesn't deallocate the memory of any pointer passed to this
416 * deque as a value. */
417 static void cdeque_free(struct cdeque* d) {
433 uint8_t bf_bit_size(const struct compressed_block_header* hdr) {
434 return hdr->block_flags_u8 & 7;
438 uint8_t bf_byte_count(const struct compressed_block_header* hdr) {
439 return (hdr->block_flags_u8 >> 3) & 7;
443 uint8_t bf_is_table_present(const struct compressed_block_header* hdr) {
444 return (hdr->block_flags_u8 >> 7) & 1;
447 static inline struct rar5* get_context(struct archive_read* a) {
448 return (struct rar5*) a->format->data;
451 /* Convenience functions used by filter implementations. */
453 static uint32_t read_filter_data(struct rar5* rar, uint32_t offset) {
454 return archive_le32dec(&rar->cstate.window_buf[offset]);
457 static void write_filter_data(struct rar5* rar, uint32_t offset,
460 archive_le32enc(&rar->cstate.filtered_buf[offset], value);
463 static void circular_memcpy(uint8_t* dst, uint8_t* window, const int mask,
464 int64_t start, int64_t end)
466 if((start & mask) > (end & mask)) {
467 ssize_t len1 = mask + 1 - (start & mask);
468 ssize_t len2 = end & mask;
470 memcpy(dst, &window[start & mask], len1);
471 memcpy(dst + len1, window, len2);
473 memcpy(dst, &window[start & mask], (size_t) (end - start));
477 /* Allocates a new filter descriptor and adds it to the filter array. */
478 static struct filter_info* add_new_filter(struct rar5* rar) {
479 struct filter_info* f =
480 (struct filter_info*) calloc(1, sizeof(struct filter_info));
486 cdeque_push_back(&rar->cstate.filters, cdeque_filter(f));
490 static int run_delta_filter(struct rar5* rar, struct filter_info* flt) {
492 ssize_t dest_pos, src_pos = 0;
494 for(i = 0; i < flt->channels; i++) {
495 uint8_t prev_byte = 0;
497 dest_pos < flt->block_length;
498 dest_pos += flt->channels)
502 byte = rar->cstate.window_buf[(rar->cstate.solid_offset +
503 flt->block_start + src_pos) & rar->cstate.window_mask];
506 rar->cstate.filtered_buf[dest_pos] = prev_byte;
514 static int run_e8e9_filter(struct rar5* rar, struct filter_info* flt,
517 const uint32_t file_size = 0x1000000;
520 const int mask = (int)rar->cstate.window_mask;
521 circular_memcpy(rar->cstate.filtered_buf,
522 rar->cstate.window_buf,
524 rar->cstate.solid_offset + flt->block_start,
525 rar->cstate.solid_offset + flt->block_start + flt->block_length);
527 for(i = 0; i < flt->block_length - 4;) {
528 uint8_t b = rar->cstate.window_buf[(rar->cstate.solid_offset +
529 flt->block_start + i++) & mask];
531 /* 0xE8 = x86's call <relative_addr_uint32> (function call)
532 * 0xE9 = x86's jmp <relative_addr_uint32> (unconditional jump) */
533 if(b == 0xE8 || (extended && b == 0xE9)) {
536 uint32_t offset = (i + flt->block_start) % file_size;
538 addr = read_filter_data(rar, (uint32_t)(rar->cstate.solid_offset +
539 flt->block_start + i) & rar->cstate.window_mask);
541 if(addr & 0x80000000) {
542 if(((addr + offset) & 0x80000000) == 0) {
543 write_filter_data(rar, (uint32_t)i, addr + file_size);
546 if((addr - file_size) & 0x80000000) {
547 uint32_t naddr = addr - offset;
548 write_filter_data(rar, (uint32_t)i, naddr);
559 static int run_arm_filter(struct rar5* rar, struct filter_info* flt) {
562 const int mask = (int)rar->cstate.window_mask;
564 circular_memcpy(rar->cstate.filtered_buf,
565 rar->cstate.window_buf,
567 rar->cstate.solid_offset + flt->block_start,
568 rar->cstate.solid_offset + flt->block_start + flt->block_length);
570 for(i = 0; i < flt->block_length - 3; i += 4) {
571 uint8_t* b = &rar->cstate.window_buf[(rar->cstate.solid_offset +
572 flt->block_start + i) & mask];
575 /* 0xEB = ARM's BL (branch + link) instruction. */
576 offset = read_filter_data(rar, (rar->cstate.solid_offset +
577 flt->block_start + i) & mask) & 0x00ffffff;
579 offset -= (uint32_t) ((i + flt->block_start) / 4);
580 offset = (offset & 0x00ffffff) | 0xeb000000;
581 write_filter_data(rar, (uint32_t)i, offset);
588 static int run_filter(struct archive_read* a, struct filter_info* flt) {
590 struct rar5* rar = get_context(a);
592 free(rar->cstate.filtered_buf);
594 rar->cstate.filtered_buf = malloc(flt->block_length);
595 if(!rar->cstate.filtered_buf) {
596 archive_set_error(&a->archive, ENOMEM, "Can't allocate memory for "
598 return ARCHIVE_FATAL;
603 ret = run_delta_filter(rar, flt);
609 ret = run_e8e9_filter(rar, flt, flt->type == FILTER_E8E9);
613 ret = run_arm_filter(rar, flt);
617 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
618 "Unsupported filter type: 0x%02x", flt->type);
619 return ARCHIVE_FATAL;
622 if(ret != ARCHIVE_OK) {
623 /* Filter has failed. */
627 if(ARCHIVE_OK != push_data_ready(a, rar, rar->cstate.filtered_buf,
628 flt->block_length, rar->cstate.last_write_ptr))
630 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
631 "Stack overflow when submitting unpacked data");
633 return ARCHIVE_FATAL;
636 rar->cstate.last_write_ptr += flt->block_length;
640 /* The `push_data` function submits the selected data range to the user.
641 * Next call of `use_data` will use the pointer, size and offset arguments
642 * that are specified here. These arguments are pushed to the FIFO stack here,
643 * and popped from the stack by the `use_data` function. */
644 static void push_data(struct archive_read* a, struct rar5* rar,
645 const uint8_t* buf, int64_t idx_begin, int64_t idx_end)
647 const int wmask = (int)rar->cstate.window_mask;
648 const ssize_t solid_write_ptr = (rar->cstate.solid_offset +
649 rar->cstate.last_write_ptr) & wmask;
651 idx_begin += rar->cstate.solid_offset;
652 idx_end += rar->cstate.solid_offset;
654 /* Check if our unpacked data is wrapped inside the window circular buffer.
655 * If it's not wrapped, it can be copied out by using a single memcpy,
656 * but when it's wrapped, we need to copy the first part with one
657 * memcpy, and the second part with another memcpy. */
659 if((idx_begin & wmask) > (idx_end & wmask)) {
660 /* The data is wrapped (begin offset sis bigger than end offset). */
661 const ssize_t frag1_size = rar->cstate.window_size - (idx_begin & wmask);
662 const ssize_t frag2_size = idx_end & wmask;
664 /* Copy the first part of the buffer first. */
665 push_data_ready(a, rar, buf + solid_write_ptr, frag1_size,
666 rar->cstate.last_write_ptr);
668 /* Copy the second part of the buffer. */
669 push_data_ready(a, rar, buf, frag2_size,
670 rar->cstate.last_write_ptr + frag1_size);
672 rar->cstate.last_write_ptr += frag1_size + frag2_size;
674 /* Data is not wrapped, so we can just use one call to copy the
676 push_data_ready(a, rar,
677 buf + solid_write_ptr,
678 (idx_end - idx_begin) & wmask,
679 rar->cstate.last_write_ptr);
681 rar->cstate.last_write_ptr += idx_end - idx_begin;
685 /* Convenience function that submits the data to the user. It uses the
686 * unpack window buffer as a source location. */
687 static void push_window_data(struct archive_read* a, struct rar5* rar,
688 int64_t idx_begin, int64_t idx_end)
690 push_data(a, rar, rar->cstate.window_buf, idx_begin, idx_end);
693 static int apply_filters(struct archive_read* a) {
694 struct filter_info* flt;
695 struct rar5* rar = get_context(a);
698 rar->cstate.all_filters_applied = 0;
700 /* Get the first filter that can be applied to our data. The data needs to
701 * be fully unpacked before the filter can be run. */
703 cdeque_front(&rar->cstate.filters, cdeque_filter_p(&flt)))
705 /* Check if our unpacked data fully covers this filter's range. */
706 if(rar->cstate.write_ptr > flt->block_start &&
707 rar->cstate.write_ptr >= flt->block_start + flt->block_length)
709 /* Check if we have some data pending to be written right before
710 * the filter's start offset. */
711 if(rar->cstate.last_write_ptr == flt->block_start) {
712 /* Run the filter specified by descriptor `flt`. */
713 ret = run_filter(a, flt);
714 if(ret != ARCHIVE_OK) {
715 /* Filter failure, return error. */
719 /* Filter descriptor won't be needed anymore after it's used,
720 * so remove it from the filter list and free its memory. */
721 (void) cdeque_pop_front(&rar->cstate.filters,
722 cdeque_filter_p(&flt));
726 /* We can't run filters yet, dump the memory right before the
728 push_window_data(a, rar, rar->cstate.last_write_ptr,
732 /* Return 'filter applied or not needed' state to the caller. */
733 return ARCHIVE_RETRY;
737 rar->cstate.all_filters_applied = 1;
741 static void dist_cache_push(struct rar5* rar, int value) {
742 int* q = rar->cstate.dist_cache;
750 static int dist_cache_touch(struct rar5* rar, int idx) {
751 int* q = rar->cstate.dist_cache;
752 int i, dist = q[idx];
754 for(i = idx; i > 0; i--)
761 static void free_filters(struct rar5* rar) {
762 struct cdeque* d = &rar->cstate.filters;
764 /* Free any remaining filters. All filters should be naturally consumed by
765 * the unpacking function, so remaining filters after unpacking normally
766 * mean that unpacking wasn't successful. But still of course we shouldn't
767 * leak memory in such case. */
769 /* cdeque_size() is a fast operation, so we can use it as a loop
771 while(cdeque_size(d) > 0) {
772 struct filter_info* f = NULL;
774 /* Pop_front will also decrease the collection's size. */
775 if (CDE_OK == cdeque_pop_front(d, cdeque_filter_p(&f)))
781 /* Also clear out the variables needed for sanity checking. */
782 rar->cstate.last_block_start = 0;
783 rar->cstate.last_block_length = 0;
786 static void reset_file_context(struct rar5* rar) {
787 memset(&rar->file, 0, sizeof(rar->file));
788 blake2sp_init(&rar->file.b2state, 32);
790 if(rar->main.solid) {
791 rar->cstate.solid_offset += rar->cstate.write_ptr;
793 rar->cstate.solid_offset = 0;
796 rar->cstate.write_ptr = 0;
797 rar->cstate.last_write_ptr = 0;
798 rar->cstate.last_unstore_ptr = 0;
803 static inline int get_archive_read(struct archive* a,
804 struct archive_read** ar)
806 *ar = (struct archive_read*) a;
807 archive_check_magic(a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
808 "archive_read_support_format_rar5");
813 static int read_ahead(struct archive_read* a, size_t how_many,
820 *ptr = __archive_read_ahead(a, how_many, &avail);
829 static int consume(struct archive_read* a, int64_t how_many) {
833 how_many == __archive_read_consume(a, how_many)
841 * Read a RAR5 variable sized numeric value. This value will be stored in
842 * `pvalue`. The `pvalue_len` argument points to a variable that will receive
843 * the byte count that was consumed in order to decode the `pvalue` value, plus
846 * pvalue_len is optional and can be NULL.
848 * NOTE: if `pvalue_len` is NOT NULL, the caller needs to manually consume
849 * the number of bytes that `pvalue_len` value contains. If the `pvalue_len`
850 * is NULL, this consuming operation is done automatically.
852 * Returns 1 if *pvalue was successfully read.
853 * Returns 0 if there was an error. In this case, *pvalue contains an
857 static int read_var(struct archive_read* a, uint64_t* pvalue,
858 uint64_t* pvalue_len)
865 /* We will read maximum of 8 bytes. We don't have to handle the situation
866 * to read the RAR5 variable-sized value stored at the end of the file,
867 * because such situation will never happen. */
868 if(!read_ahead(a, 8, &p))
871 for(shift = 0, i = 0; i < 8; i++, shift += 7) {
874 /* Strip the MSB from the input byte and add the resulting number
875 * to the `result`. */
876 result += (b & (uint64_t)0x7F) << shift;
878 /* MSB set to 1 means we need to continue decoding process. MSB set
879 * to 0 means we're done.
881 * This conditional checks for the second case. */
882 if((b & 0x80) == 0) {
887 /* If the caller has passed the `pvalue_len` pointer, store the
888 * number of consumed bytes in it and do NOT consume those bytes,
889 * since the caller has all the information it needs to perform
890 * the consuming process itself. */
894 /* If the caller did not provide the `pvalue_len` pointer,
895 * it will not have the possibility to advance the file
896 * pointer, because it will not know how many bytes it needs
897 * to consume. This is why we handle such situation here
899 if(ARCHIVE_OK != consume(a, 1 + i)) {
904 /* End of decoding process, return success. */
909 /* The decoded value takes the maximum number of 8 bytes. It's a maximum
910 * number of bytes, so end decoding process here even if the first bit
911 * of last byte is 1. */
919 if(ARCHIVE_OK != consume(a, 9)) {
927 static int read_var_sized(struct archive_read* a, size_t* pvalue,
933 const int ret = pvalue_len
934 ? read_var(a, &v, &v_size)
935 : read_var(a, &v, NULL);
937 if(ret == 1 && pvalue) {
938 *pvalue = (size_t) v;
942 /* Possible data truncation should be safe. */
943 *pvalue_len = (size_t) v_size;
949 static int read_bits_32(struct rar5* rar, const uint8_t* p, uint32_t* value) {
950 uint32_t bits = p[rar->bits.in_addr] << 24;
951 bits |= p[rar->bits.in_addr + 1] << 16;
952 bits |= p[rar->bits.in_addr + 2] << 8;
953 bits |= p[rar->bits.in_addr + 3];
954 bits <<= rar->bits.bit_addr;
955 bits |= p[rar->bits.in_addr + 4] >> (8 - rar->bits.bit_addr);
960 static int read_bits_16(struct rar5* rar, const uint8_t* p, uint16_t* value) {
961 int bits = (int) p[rar->bits.in_addr] << 16;
962 bits |= (int) p[rar->bits.in_addr + 1] << 8;
963 bits |= (int) p[rar->bits.in_addr + 2];
964 bits >>= (8 - rar->bits.bit_addr);
965 *value = bits & 0xffff;
969 static void skip_bits(struct rar5* rar, int bits) {
970 const int new_bits = rar->bits.bit_addr + bits;
971 rar->bits.in_addr += new_bits >> 3;
972 rar->bits.bit_addr = new_bits & 7;
976 static int read_consume_bits(struct rar5* rar, const uint8_t* p, int n,
982 if(n == 0 || n > 16) {
983 /* This is a programmer error and should never happen in runtime. */
984 return ARCHIVE_FATAL;
987 ret = read_bits_16(rar, p, &v);
988 if(ret != ARCHIVE_OK)
1002 static int read_u32(struct archive_read* a, uint32_t* pvalue) {
1004 if(!read_ahead(a, 4, &p))
1007 *pvalue = archive_le32dec(p);
1008 return ARCHIVE_OK == consume(a, 4) ? 1 : 0;
1011 static int read_u64(struct archive_read* a, uint64_t* pvalue) {
1013 if(!read_ahead(a, 8, &p))
1016 *pvalue = archive_le64dec(p);
1017 return ARCHIVE_OK == consume(a, 8) ? 1 : 0;
1020 static int bid_standard(struct archive_read* a) {
1023 if(!read_ahead(a, rar5_signature_size, &p))
1026 if(!memcmp(rar5_signature, p, rar5_signature_size))
1032 static int rar5_bid(struct archive_read* a, int best_bid) {
1038 my_bid = bid_standard(a);
1046 static int rar5_options(struct archive_read *a, const char *key, const char *val) {
1051 /* No options supported in this version. Return the ARCHIVE_WARN code to
1052 * signal the options supervisor that the unpacker didn't handle setting
1055 return ARCHIVE_WARN;
1058 static void init_header(struct archive_read* a) {
1059 a->archive.archive_format = ARCHIVE_FORMAT_RAR_V5;
1060 a->archive.archive_format_name = "RAR5";
1064 HFL_EXTRA_DATA = 0x0001, HFL_DATA = 0x0002, HFL_SKIP_IF_UNKNOWN = 0x0004,
1065 HFL_SPLIT_BEFORE = 0x0008, HFL_SPLIT_AFTER = 0x0010, HFL_CHILD = 0x0020,
1066 HFL_INHERITED = 0x0040
1069 static int process_main_locator_extra_block(struct archive_read* a,
1072 uint64_t locator_flags;
1074 if(!read_var(a, &locator_flags, NULL)) {
1078 enum LOCATOR_FLAGS {
1079 QLIST = 0x01, RECOVERY = 0x02,
1082 if(locator_flags & QLIST) {
1083 if(!read_var(a, &rar->qlist_offset, NULL)) {
1087 /* qlist is not used */
1090 if(locator_flags & RECOVERY) {
1091 if(!read_var(a, &rar->rr_offset, NULL)) {
1095 /* rr is not used */
1101 static int parse_file_extra_hash(struct archive_read* a, struct rar5* rar,
1102 ssize_t* extra_data_size)
1107 if(!read_var_sized(a, &hash_type, &value_len))
1110 *extra_data_size -= value_len;
1111 if(ARCHIVE_OK != consume(a, value_len)) {
1119 /* The file uses BLAKE2sp checksum algorithm instead of plain old
1121 if(hash_type == BLAKE2sp) {
1123 const int hash_size = sizeof(rar->file.blake2sp);
1125 if(!read_ahead(a, hash_size, &p))
1128 rar->file.has_blake2 = 1;
1129 memcpy(&rar->file.blake2sp, p, hash_size);
1131 if(ARCHIVE_OK != consume(a, hash_size)) {
1135 *extra_data_size -= hash_size;
1137 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1138 "Unsupported hash type (0x%02x)", (int) hash_type);
1139 return ARCHIVE_FATAL;
1145 static uint64_t time_win_to_unix(uint64_t win_time) {
1146 const size_t ns_in_sec = 10000000;
1147 const uint64_t sec_to_unix = 11644473600LL;
1148 return win_time / ns_in_sec - sec_to_unix;
1151 static int parse_htime_item(struct archive_read* a, char unix_time,
1152 uint64_t* where, ssize_t* extra_data_size)
1156 if(!read_u32(a, &time_val))
1159 *extra_data_size -= 4;
1160 *where = (uint64_t) time_val;
1162 uint64_t windows_time;
1163 if(!read_u64(a, &windows_time))
1166 *where = time_win_to_unix(windows_time);
1167 *extra_data_size -= 8;
1173 static int parse_file_extra_htime(struct archive_read* a,
1174 struct archive_entry* e, struct rar5* rar,
1175 ssize_t* extra_data_size)
1189 if(!read_var_sized(a, &flags, &value_len))
1192 *extra_data_size -= value_len;
1193 if(ARCHIVE_OK != consume(a, value_len)) {
1197 unix_time = flags & IS_UNIX;
1199 if(flags & HAS_MTIME) {
1200 parse_htime_item(a, unix_time, &rar->file.e_mtime, extra_data_size);
1201 archive_entry_set_mtime(e, rar->file.e_mtime, 0);
1204 if(flags & HAS_CTIME) {
1205 parse_htime_item(a, unix_time, &rar->file.e_ctime, extra_data_size);
1206 archive_entry_set_ctime(e, rar->file.e_ctime, 0);
1209 if(flags & HAS_ATIME) {
1210 parse_htime_item(a, unix_time, &rar->file.e_atime, extra_data_size);
1211 archive_entry_set_atime(e, rar->file.e_atime, 0);
1214 if(flags & HAS_UNIX_NS) {
1215 if(!read_u32(a, &rar->file.e_unix_ns))
1218 *extra_data_size -= 4;
1224 static int process_head_file_extra(struct archive_read* a,
1225 struct archive_entry* e, struct rar5* rar,
1226 ssize_t extra_data_size)
1228 size_t extra_field_size;
1229 size_t extra_field_id = 0;
1230 int ret = ARCHIVE_FATAL;
1234 CRYPT = 0x01, HASH = 0x02, HTIME = 0x03, VERSION_ = 0x04,
1235 REDIR = 0x05, UOWNER = 0x06, SUBDATA = 0x07
1238 while(extra_data_size > 0) {
1239 if(!read_var_sized(a, &extra_field_size, &var_size))
1242 extra_data_size -= var_size;
1243 if(ARCHIVE_OK != consume(a, var_size)) {
1247 if(!read_var_sized(a, &extra_field_id, &var_size))
1250 extra_data_size -= var_size;
1251 if(ARCHIVE_OK != consume(a, var_size)) {
1255 switch(extra_field_id) {
1257 ret = parse_file_extra_hash(a, rar, &extra_data_size);
1260 ret = parse_file_extra_htime(a, e, rar, &extra_data_size);
1273 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1274 "Unknown extra field in file/service block: 0x%02x",
1275 (int) extra_field_id);
1276 return ARCHIVE_FATAL;
1280 if(ret != ARCHIVE_OK) {
1281 /* Attribute not implemented. */
1288 static int process_head_file(struct archive_read* a, struct rar5* rar,
1289 struct archive_entry* entry, size_t block_flags)
1291 ssize_t extra_data_size = 0;
1292 size_t data_size = 0;
1293 size_t file_flags = 0;
1294 size_t file_attr = 0;
1295 size_t compression_info = 0;
1297 size_t name_size = 0;
1298 uint64_t unpacked_size;
1299 uint32_t mtime = 0, crc = 0;
1300 int c_method = 0, c_version = 0, is_dir;
1301 char name_utf8_buf[2048 * 4];
1304 archive_entry_clear(entry);
1306 /* Do not reset file context if we're switching archives. */
1307 if(!rar->cstate.switch_multivolume) {
1308 reset_file_context(rar);
1311 if(block_flags & HFL_EXTRA_DATA) {
1312 size_t edata_size = 0;
1313 if(!read_var_sized(a, &edata_size, NULL))
1316 /* Intentional type cast from unsigned to signed. */
1317 extra_data_size = (ssize_t) edata_size;
1320 if(block_flags & HFL_DATA) {
1321 if(!read_var_sized(a, &data_size, NULL))
1324 rar->file.bytes_remaining = data_size;
1326 rar->file.bytes_remaining = 0;
1328 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1329 "no data found in file/service block");
1330 return ARCHIVE_FATAL;
1334 DIRECTORY = 0x0001, UTIME = 0x0002, CRC32 = 0x0004,
1335 UNKNOWN_UNPACKED_SIZE = 0x0008,
1338 enum COMP_INFO_FLAGS {
1342 if(!read_var_sized(a, &file_flags, NULL))
1345 if(!read_var(a, &unpacked_size, NULL))
1348 if(file_flags & UNKNOWN_UNPACKED_SIZE) {
1349 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
1350 "Files with unknown unpacked size are not supported");
1351 return ARCHIVE_FATAL;
1354 is_dir = (int) (file_flags & DIRECTORY);
1356 if(!read_var_sized(a, &file_attr, NULL))
1359 if(file_flags & UTIME) {
1360 if(!read_u32(a, &mtime))
1364 if(file_flags & CRC32) {
1365 if(!read_u32(a, &crc))
1369 if(!read_var_sized(a, &compression_info, NULL))
1372 c_method = (int) (compression_info >> 7) & 0x7;
1373 c_version = (int) (compression_info & 0x3f);
1375 rar->cstate.window_size = is_dir ?
1377 g_unpack_window_size << ((compression_info >> 10) & 15);
1378 rar->cstate.method = c_method;
1379 rar->cstate.version = c_version + 50;
1381 rar->file.solid = (compression_info & SOLID) > 0;
1382 rar->file.service = 0;
1384 if(!read_var_sized(a, &host_os, NULL))
1392 if(host_os == HOST_WINDOWS) {
1393 /* Host OS is Windows */
1395 unsigned short mode = 0660;
1402 archive_entry_set_mode(entry, mode);
1403 } else if(host_os == HOST_UNIX) {
1404 /* Host OS is Unix */
1405 archive_entry_set_mode(entry, (unsigned short) file_attr);
1407 /* Unknown host OS */
1408 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1409 "Unsupported Host OS: 0x%02x", (int) host_os);
1411 return ARCHIVE_FATAL;
1414 if(!read_var_sized(a, &name_size, NULL))
1417 if(!read_ahead(a, name_size, &p))
1420 if(name_size > 2047) {
1421 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1422 "Filename is too long");
1424 return ARCHIVE_FATAL;
1427 if(name_size == 0) {
1428 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1429 "No filename specified");
1431 return ARCHIVE_FATAL;
1434 memcpy(name_utf8_buf, p, name_size);
1435 name_utf8_buf[name_size] = 0;
1436 if(ARCHIVE_OK != consume(a, name_size)) {
1440 if(extra_data_size > 0) {
1441 int ret = process_head_file_extra(a, entry, rar, extra_data_size);
1444 if(extra_data_size < 0) {
1445 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
1446 "File extra data size is not zero");
1447 return ARCHIVE_FATAL;
1450 if(ret != ARCHIVE_OK)
1454 if((file_flags & UNKNOWN_UNPACKED_SIZE) == 0) {
1455 rar->file.unpacked_size = (ssize_t) unpacked_size;
1456 archive_entry_set_size(entry, unpacked_size);
1459 if(file_flags & UTIME) {
1460 archive_entry_set_mtime(entry, (time_t) mtime, 0);
1463 if(file_flags & CRC32) {
1464 rar->file.stored_crc32 = crc;
1467 archive_entry_update_pathname_utf8(entry, name_utf8_buf);
1469 if(!rar->cstate.switch_multivolume) {
1470 /* Do not reinitialize unpacking state if we're switching archives. */
1471 rar->cstate.block_parsing_finished = 1;
1472 rar->cstate.all_filters_applied = 1;
1473 rar->cstate.initialized = 0;
1476 if(rar->generic.split_before > 0) {
1477 /* If now we're standing on a header that has a 'split before' mark,
1478 * it means we're standing on a 'continuation' file header. Signal
1479 * the caller that if it wants to move to another file, it must call
1480 * rar5_read_header() function again. */
1482 return ARCHIVE_RETRY;
1488 static int process_head_service(struct archive_read* a, struct rar5* rar,
1489 struct archive_entry* entry, size_t block_flags)
1491 /* Process this SERVICE block the same way as FILE blocks. */
1492 int ret = process_head_file(a, rar, entry, block_flags);
1493 if(ret != ARCHIVE_OK)
1496 rar->file.service = 1;
1498 /* But skip the data part automatically. It's no use for the user anyway.
1499 * It contains only service data, not even needed to properly unpack the
1501 ret = rar5_read_data_skip(a);
1502 if(ret != ARCHIVE_OK)
1505 /* After skipping, try parsing another block automatically. */
1506 return ARCHIVE_RETRY;
1509 static int process_head_main(struct archive_read* a, struct rar5* rar,
1510 struct archive_entry* entry, size_t block_flags)
1515 size_t extra_data_size = 0;
1516 size_t extra_field_size = 0;
1517 size_t extra_field_id = 0;
1518 size_t archive_flags = 0;
1520 if(block_flags & HFL_EXTRA_DATA) {
1521 if(!read_var_sized(a, &extra_data_size, NULL))
1524 extra_data_size = 0;
1527 if(!read_var_sized(a, &archive_flags, NULL)) {
1532 VOLUME = 0x0001, /* multi-volume archive */
1533 VOLUME_NUMBER = 0x0002, /* volume number, first vol doesn't have it */
1534 SOLID = 0x0004, /* solid archive */
1535 PROTECT = 0x0008, /* contains Recovery info */
1536 LOCK = 0x0010, /* readonly flag, not used */
1539 rar->main.volume = (archive_flags & VOLUME) > 0;
1540 rar->main.solid = (archive_flags & SOLID) > 0;
1542 if(archive_flags & VOLUME_NUMBER) {
1544 if(!read_var_sized(a, &v, NULL)) {
1548 rar->main.vol_no = (int) v;
1550 rar->main.vol_no = 0;
1553 if(rar->vol.expected_vol_no > 0 &&
1554 rar->main.vol_no != rar->vol.expected_vol_no)
1556 /* Returning EOF instead of FATAL because of strange libarchive
1557 * behavior. When opening multiple files via
1558 * archive_read_open_filenames(), after reading up the whole last file,
1559 * the __archive_read_ahead function wraps up to the first archive
1560 * instead of returning EOF. */
1564 if(extra_data_size == 0) {
1569 if(!read_var_sized(a, &extra_field_size, NULL)) {
1573 if(!read_var_sized(a, &extra_field_id, NULL)) {
1577 if(extra_field_size == 0) {
1578 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1579 "Invalid extra field size");
1580 return ARCHIVE_FATAL;
1584 // Just one attribute here.
1588 switch(extra_field_id) {
1590 ret = process_main_locator_extra_block(a, rar);
1591 if(ret != ARCHIVE_OK) {
1592 /* Error while parsing main locator extra block. */
1598 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1599 "Unsupported extra type (0x%02x)", (int) extra_field_id);
1600 return ARCHIVE_FATAL;
1606 static int scan_for_signature(struct archive_read* a);
1608 /* Base block processing function. A 'base block' is a RARv5 header block
1609 * that tells the reader what kind of data is stored inside the block.
1611 * From the birds-eye view a RAR file looks file this:
1613 * <magic><base_block_1><base_block_2>...<base_block_n>
1615 * There are a few types of base blocks. Those types are specified inside
1616 * the 'switch' statement in this function. For example purposes, I'll write
1617 * how a standard RARv5 file could look like here:
1619 * <magic><MAIN><FILE><FILE><FILE><SERVICE><ENDARC>
1621 * The structure above could describe an archive file with 3 files in it,
1622 * one service "QuickOpen" block (that is ignored by this parser), and an
1623 * end of file base block marker.
1625 * If the file is stored in multiple archive files ("multiarchive"), it might
1628 * .part01.rar: <magic><MAIN><FILE><ENDARC>
1629 * .part02.rar: <magic><MAIN><FILE><ENDARC>
1630 * .part03.rar: <magic><MAIN><FILE><ENDARC>
1632 * This example could describe 3 RAR files that contain ONE archived file.
1633 * Or it could describe 3 RAR files that contain 3 different files. Or 3
1634 * RAR files than contain 2 files. It all depends what metadata is stored in
1635 * the headers of <FILE> blocks.
1637 * Each <FILE> block contains info about its size, the name of the file it's
1638 * storing inside, and whether this FILE block is a continuation block of
1639 * previous archive ('split before'), and is this FILE block should be
1640 * continued in another archive ('split after'). By parsing the 'split before'
1641 * and 'split after' flags, we're able to tell if multiple <FILE> base blocks
1642 * are describing one file, or multiple files (with the same filename, for
1645 * One thing to note is that if we're parsing the first <FILE> block, and
1646 * we see 'split after' flag, then we need to jump over to another <FILE>
1647 * block to be able to decompress rest of the data. To do this, we need
1648 * to skip the <ENDARC> block, then switch to another file, then skip the
1649 * <magic> block, <MAIN> block, and then we're standing on the proper
1653 static int process_base_block(struct archive_read* a,
1654 struct archive_entry* entry)
1656 struct rar5* rar = get_context(a);
1657 uint32_t hdr_crc, computed_crc;
1658 size_t raw_hdr_size = 0, hdr_size_len, hdr_size;
1659 size_t header_id = 0;
1660 size_t header_flags = 0;
1664 /* Skip any unprocessed data for this file. */
1665 if(rar->file.bytes_remaining) {
1666 ret = rar5_read_data_skip(a);
1667 if(ret != ARCHIVE_OK) {
1672 /* Read the expected CRC32 checksum. */
1673 if(!read_u32(a, &hdr_crc)) {
1677 /* Read header size. */
1678 if(!read_var_sized(a, &raw_hdr_size, &hdr_size_len)) {
1682 /* Sanity check, maximum header size for RAR5 is 2MB. */
1683 if(raw_hdr_size > (2 * 1024 * 1024)) {
1684 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1685 "Base block header is too large");
1687 return ARCHIVE_FATAL;
1690 hdr_size = raw_hdr_size + hdr_size_len;
1692 /* Read the whole header data into memory, maximum memory use here is
1694 if(!read_ahead(a, hdr_size, &p)) {
1698 /* Verify the CRC32 of the header data. */
1699 computed_crc = (uint32_t) crc32(0, p, (int) hdr_size);
1700 if(computed_crc != hdr_crc) {
1701 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1702 "Header CRC error");
1704 return ARCHIVE_FATAL;
1707 /* If the checksum is OK, we proceed with parsing. */
1708 if(ARCHIVE_OK != consume(a, hdr_size_len)) {
1712 if(!read_var_sized(a, &header_id, NULL))
1715 if(!read_var_sized(a, &header_flags, NULL))
1718 rar->generic.split_after = (header_flags & HFL_SPLIT_AFTER) > 0;
1719 rar->generic.split_before = (header_flags & HFL_SPLIT_BEFORE) > 0;
1720 rar->generic.size = (int)hdr_size;
1721 rar->generic.last_header_id = (int)header_id;
1722 rar->main.endarc = 0;
1724 /* Those are possible header ids in RARv5. */
1726 HEAD_MARK = 0x00, HEAD_MAIN = 0x01, HEAD_FILE = 0x02,
1727 HEAD_SERVICE = 0x03, HEAD_CRYPT = 0x04, HEAD_ENDARC = 0x05,
1728 HEAD_UNKNOWN = 0xff,
1733 ret = process_head_main(a, rar, entry, header_flags);
1735 /* Main header doesn't have any files in it, so it's pointless
1736 * to return to the caller. Retry to next header, which should be
1737 * HEAD_FILE/HEAD_SERVICE. */
1738 if(ret == ARCHIVE_OK)
1739 return ARCHIVE_RETRY;
1743 ret = process_head_service(a, rar, entry, header_flags);
1746 ret = process_head_file(a, rar, entry, header_flags);
1749 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1750 "Encryption is not supported");
1751 return ARCHIVE_FATAL;
1753 rar->main.endarc = 1;
1755 /* After encountering an end of file marker, we need to take
1756 * into consideration if this archive is continued in another
1757 * file (i.e. is it part01.rar: is there a part02.rar?) */
1758 if(rar->main.volume) {
1759 /* In case there is part02.rar, position the read pointer
1760 * in a proper place, so we can resume parsing. */
1762 ret = scan_for_signature(a);
1763 if(ret == ARCHIVE_FATAL) {
1766 rar->vol.expected_vol_no = rar->main.vol_no + 1;
1775 if((header_flags & HFL_SKIP_IF_UNKNOWN) == 0) {
1776 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1777 "Header type error");
1778 return ARCHIVE_FATAL;
1780 /* If the block is marked as 'skip if unknown', do as the flag
1781 * says: skip the block instead on failing on it. */
1782 return ARCHIVE_RETRY;
1788 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
1789 "Internal unpacker error");
1790 return ARCHIVE_FATAL;
1794 static int skip_base_block(struct archive_read* a) {
1796 struct rar5* rar = get_context(a);
1798 /* Create a new local archive_entry structure that will be operated on
1799 * by header reader; operations on this archive_entry will be discarded.
1801 struct archive_entry* entry = archive_entry_new();
1802 ret = process_base_block(a, entry);
1804 /* Discard operations on this archive_entry structure. */
1805 archive_entry_free(entry);
1807 if(rar->generic.last_header_id == 2 && rar->generic.split_before > 0)
1810 if(ret == ARCHIVE_OK)
1811 return ARCHIVE_RETRY;
1816 static int rar5_read_header(struct archive_read *a,
1817 struct archive_entry *entry)
1819 struct rar5* rar = get_context(a);
1822 if(rar->header_initialized == 0) {
1824 rar->header_initialized = 1;
1827 if(rar->skipped_magic == 0) {
1828 if(ARCHIVE_OK != consume(a, rar5_signature_size)) {
1832 rar->skipped_magic = 1;
1836 ret = process_base_block(a, entry);
1837 } while(ret == ARCHIVE_RETRY ||
1838 (rar->main.endarc > 0 && ret == ARCHIVE_OK));
1843 static void init_unpack(struct rar5* rar) {
1844 rar->file.calculated_crc32 = 0;
1845 if (rar->cstate.window_size)
1846 rar->cstate.window_mask = rar->cstate.window_size - 1;
1848 rar->cstate.window_mask = 0;
1850 free(rar->cstate.window_buf);
1852 free(rar->cstate.filtered_buf);
1854 rar->cstate.window_buf = calloc(1, rar->cstate.window_size);
1855 rar->cstate.filtered_buf = calloc(1, rar->cstate.window_size);
1857 rar->cstate.write_ptr = 0;
1858 rar->cstate.last_write_ptr = 0;
1860 memset(&rar->cstate.bd, 0, sizeof(rar->cstate.bd));
1861 memset(&rar->cstate.ld, 0, sizeof(rar->cstate.ld));
1862 memset(&rar->cstate.dd, 0, sizeof(rar->cstate.dd));
1863 memset(&rar->cstate.ldd, 0, sizeof(rar->cstate.ldd));
1864 memset(&rar->cstate.rd, 0, sizeof(rar->cstate.rd));
1867 static void update_crc(struct rar5* rar, const uint8_t* p, size_t to_read) {
1870 if(rar->skip_mode) {
1871 #if defined CHECK_CRC_ON_SOLID_SKIP
1880 /* Don't update CRC32 if the file doesn't have the `stored_crc32` info
1882 if(rar->file.stored_crc32 > 0) {
1883 rar->file.calculated_crc32 =
1884 crc32(rar->file.calculated_crc32, p, to_read);
1887 /* Check if the file uses an optional BLAKE2sp checksum algorithm. */
1888 if(rar->file.has_blake2 > 0) {
1889 /* Return value of the `update` function is always 0, so we can
1890 * explicitly ignore it here. */
1891 (void) blake2sp_update(&rar->file.b2state, p, to_read);
1896 static int create_decode_tables(uint8_t* bit_length,
1897 struct decode_table* table,
1900 int code, upper_limit = 0, i, lc[16];
1901 uint32_t decode_pos_clone[rar5_countof(table->decode_pos)];
1902 ssize_t cur_len, quick_data_size;
1904 memset(&lc, 0, sizeof(lc));
1905 memset(table->decode_num, 0, sizeof(table->decode_num));
1907 table->quick_bits = size == HUFF_NC ? 10 : 7;
1909 for(i = 0; i < size; i++) {
1910 lc[bit_length[i] & 15]++;
1914 table->decode_pos[0] = 0;
1915 table->decode_len[0] = 0;
1917 for(i = 1; i < 16; i++) {
1918 upper_limit += lc[i];
1920 table->decode_len[i] = upper_limit << (16 - i);
1921 table->decode_pos[i] = table->decode_pos[i - 1] + lc[i - 1];
1926 memcpy(decode_pos_clone, table->decode_pos, sizeof(decode_pos_clone));
1928 for(i = 0; i < size; i++) {
1929 uint8_t clen = bit_length[i] & 15;
1931 int last_pos = decode_pos_clone[clen];
1932 table->decode_num[last_pos] = i;
1933 decode_pos_clone[clen]++;
1937 quick_data_size = (int64_t)1 << table->quick_bits;
1939 for(code = 0; code < quick_data_size; code++) {
1940 int bit_field = code << (16 - table->quick_bits);
1943 while(cur_len < rar5_countof(table->decode_len) &&
1944 bit_field >= table->decode_len[cur_len]) {
1948 table->quick_len[code] = (uint8_t) cur_len;
1950 dist = bit_field - table->decode_len[cur_len - 1];
1951 dist >>= (16 - cur_len);
1953 pos = table->decode_pos[cur_len & 15] + dist;
1954 if(cur_len < rar5_countof(table->decode_pos) && pos < size) {
1955 table->quick_num[code] = table->decode_num[pos];
1957 table->quick_num[code] = 0;
1964 static int decode_number(struct archive_read* a, struct decode_table* table,
1965 const uint8_t* p, uint16_t* num)
1970 struct rar5* rar = get_context(a);
1972 if(ARCHIVE_OK != read_bits_16(rar, p, &bitfield)) {
1978 if(bitfield < table->decode_len[table->quick_bits]) {
1979 int code = bitfield >> (16 - table->quick_bits);
1980 skip_bits(rar, table->quick_len[code]);
1981 *num = table->quick_num[code];
1987 for(i = table->quick_bits + 1; i < 15; i++) {
1988 if(bitfield < table->decode_len[i]) {
1994 skip_bits(rar, bits);
1996 dist = bitfield - table->decode_len[bits - 1];
1997 dist >>= (16 - bits);
1998 pos = table->decode_pos[bits] + dist;
2000 if(pos >= table->size)
2003 *num = table->decode_num[pos];
2007 /* Reads and parses Huffman tables from the beginning of the block. */
2008 static int parse_tables(struct archive_read* a, struct rar5* rar,
2011 int ret, value, i, w, idx = 0;
2012 uint8_t bit_length[HUFF_BC],
2013 table[HUFF_TABLE_SIZE],
2017 enum { ESCAPE = 15 };
2019 /* The data for table generation is compressed using a simple RLE-like
2020 * algorithm when storing zeroes, so we need to unpack it first. */
2021 for(w = 0, i = 0; w < HUFF_BC;) {
2022 value = (p[i] & nibble_mask) >> nibble_shift;
2024 if(nibble_mask == 0x0F)
2027 nibble_mask ^= 0xFF;
2030 /* Values smaller than 15 is data, so we write it directly. Value 15
2031 * is a flag telling us that we need to unpack more bytes. */
2032 if(value == ESCAPE) {
2033 value = (p[i] & nibble_mask) >> nibble_shift;
2034 if(nibble_mask == 0x0F)
2036 nibble_mask ^= 0xFF;
2040 /* We sometimes need to write the actual value of 15, so this
2041 * case handles that. */
2042 bit_length[w++] = ESCAPE;
2047 for(k = 0; k < value + 2; k++) {
2048 bit_length[w++] = 0;
2052 bit_length[w++] = value;
2056 rar->bits.in_addr = i;
2057 rar->bits.bit_addr = nibble_shift ^ 4;
2059 ret = create_decode_tables(bit_length, &rar->cstate.bd, HUFF_BC);
2060 if(ret != ARCHIVE_OK) {
2061 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2062 "Decoding huffman tables failed");
2063 return ARCHIVE_FATAL;
2066 for(i = 0; i < HUFF_TABLE_SIZE;) {
2069 ret = decode_number(a, &rar->cstate.bd, p, &num);
2070 if(ret != ARCHIVE_OK) {
2071 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2072 "Decoding huffman tables failed");
2073 return ARCHIVE_FATAL;
2077 /* 0..15: store directly */
2078 table[i] = (uint8_t) num;
2084 /* 16..17: repeat previous code */
2086 if(ARCHIVE_OK != read_bits_16(rar, p, &n))
2100 while(n-- > 0 && i < HUFF_TABLE_SIZE) {
2101 table[i] = table[i - 1];
2105 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2106 "Unexpected error when decoding huffman tables");
2107 return ARCHIVE_FATAL;
2113 /* other codes: fill with zeroes `n` times */
2115 if(ARCHIVE_OK != read_bits_16(rar, p, &n))
2128 while(n-- > 0 && i < HUFF_TABLE_SIZE)
2132 ret = create_decode_tables(&table[idx], &rar->cstate.ld, HUFF_NC);
2133 if(ret != ARCHIVE_OK) {
2134 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2135 "Failed to create literal table");
2136 return ARCHIVE_FATAL;
2141 ret = create_decode_tables(&table[idx], &rar->cstate.dd, HUFF_DC);
2142 if(ret != ARCHIVE_OK) {
2143 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2144 "Failed to create distance table");
2145 return ARCHIVE_FATAL;
2150 ret = create_decode_tables(&table[idx], &rar->cstate.ldd, HUFF_LDC);
2151 if(ret != ARCHIVE_OK) {
2152 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2153 "Failed to create lower bits of distances table");
2154 return ARCHIVE_FATAL;
2159 ret = create_decode_tables(&table[idx], &rar->cstate.rd, HUFF_RC);
2160 if(ret != ARCHIVE_OK) {
2161 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2162 "Failed to create repeating distances table");
2163 return ARCHIVE_FATAL;
2169 /* Parses the block header, verifies its CRC byte, and saves the header
2170 * fields inside the `hdr` pointer. */
2171 static int parse_block_header(struct archive_read* a, const uint8_t* p,
2172 ssize_t* block_size, struct compressed_block_header* hdr)
2174 memcpy(hdr, p, sizeof(struct compressed_block_header));
2176 if(bf_byte_count(hdr) > 2) {
2177 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2178 "Unsupported block header size (was %d, max is 2)",
2179 bf_byte_count(hdr));
2180 return ARCHIVE_FATAL;
2183 /* This should probably use bit reader interface in order to be more
2186 switch(bf_byte_count(hdr)) {
2187 /* 1-byte block size */
2189 *block_size = *(const uint8_t*) &p[2];
2192 /* 2-byte block size */
2194 *block_size = archive_le16dec(&p[2]);
2197 /* 3-byte block size */
2199 *block_size = archive_le32dec(&p[2]);
2200 *block_size &= 0x00FFFFFF;
2203 /* Other block sizes are not supported. This case is not reached,
2204 * because we have an 'if' guard before the switch that makes sure
2207 return ARCHIVE_FATAL;
2210 /* Verify the block header checksum. 0x5A is a magic value and is always
2212 uint8_t calculated_cksum = 0x5A
2213 ^ (uint8_t) hdr->block_flags_u8
2214 ^ (uint8_t) *block_size
2215 ^ (uint8_t) (*block_size >> 8)
2216 ^ (uint8_t) (*block_size >> 16);
2218 if(calculated_cksum != hdr->block_cksum) {
2219 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2220 "Block checksum error: got 0x%02x, expected 0x%02x",
2221 hdr->block_cksum, calculated_cksum);
2223 return ARCHIVE_FATAL;
2229 /* Convenience function used during filter processing. */
2230 static int parse_filter_data(struct rar5* rar, const uint8_t* p,
2231 uint32_t* filter_data)
2236 if(ARCHIVE_OK != read_consume_bits(rar, p, 2, &bytes))
2241 for(i = 0; i < bytes; i++) {
2244 if(ARCHIVE_OK != read_bits_16(rar, p, &byte)) {
2248 data += (byte >> 8) << (i * 8);
2252 *filter_data = data;
2256 /* Function is used during sanity checking. */
2257 static int is_valid_filter_block_start(struct rar5* rar,
2260 const int64_t block_start = (ssize_t) start + rar->cstate.write_ptr;
2261 const int64_t last_bs = rar->cstate.last_block_start;
2262 const ssize_t last_bl = rar->cstate.last_block_length;
2264 if(last_bs == 0 || last_bl == 0) {
2265 /* We didn't have any filters yet, so accept this offset. */
2269 if(block_start >= last_bs + last_bl) {
2270 /* Current offset is bigger than last block's end offset, so
2271 * accept current offset. */
2275 /* Any other case is not a normal situation and we should fail. */
2279 /* The function will create a new filter, read its parameters from the input
2280 * stream and add it to the filter collection. */
2281 static int parse_filter(struct archive_read* ar, const uint8_t* p) {
2282 uint32_t block_start, block_length;
2283 uint16_t filter_type;
2284 struct rar5* rar = get_context(ar);
2286 /* Read the parameters from the input stream. */
2287 if(ARCHIVE_OK != parse_filter_data(rar, p, &block_start))
2290 if(ARCHIVE_OK != parse_filter_data(rar, p, &block_length))
2293 if(ARCHIVE_OK != read_bits_16(rar, p, &filter_type))
2299 /* Perform some sanity checks on this filter parameters. Note that we
2300 * allow only DELTA, E8/E9 and ARM filters here, because rest of filters
2301 * are not used in RARv5. */
2303 if(block_length < 4 ||
2304 block_length > 0x400000 ||
2305 filter_type > FILTER_ARM ||
2306 !is_valid_filter_block_start(rar, block_start))
2308 archive_set_error(&ar->archive, ARCHIVE_ERRNO_FILE_FORMAT, "Invalid "
2309 "filter encountered");
2310 return ARCHIVE_FATAL;
2313 /* Allocate a new filter. */
2314 struct filter_info* filt = add_new_filter(rar);
2316 archive_set_error(&ar->archive, ENOMEM, "Can't allocate memory for a "
2317 "filter descriptor.");
2318 return ARCHIVE_FATAL;
2321 filt->type = filter_type;
2322 filt->block_start = rar->cstate.write_ptr + block_start;
2323 filt->block_length = block_length;
2325 rar->cstate.last_block_start = filt->block_start;
2326 rar->cstate.last_block_length = filt->block_length;
2328 /* Read some more data in case this is a DELTA filter. Other filter types
2329 * don't require any additional data over what was already read. */
2330 if(filter_type == FILTER_DELTA) {
2333 if(ARCHIVE_OK != read_consume_bits(rar, p, 5, &channels))
2336 filt->channels = channels + 1;
2342 static int decode_code_length(struct rar5* rar, const uint8_t* p,
2345 int lbits, length = 2;
2350 lbits = code / 4 - 1;
2351 length += (4 | (code & 3)) << lbits;
2357 if(ARCHIVE_OK != read_consume_bits(rar, p, lbits, &add))
2366 static int copy_string(struct archive_read* a, int len, int dist) {
2367 struct rar5* rar = get_context(a);
2368 const int cmask = (int)rar->cstate.window_mask;
2369 const int64_t write_ptr = rar->cstate.write_ptr + rar->cstate.solid_offset;
2372 /* The unpacker spends most of the time in this function. It would be
2373 * a good idea to introduce some optimizations here.
2375 * Just remember that this loop treats buffers that overlap differently
2376 * than buffers that do not overlap. This is why a simple memcpy(3) call
2377 * will not be enough. */
2379 for(i = 0; i < len; i++) {
2380 const ssize_t write_idx = (write_ptr + i) & cmask;
2381 const ssize_t read_idx = (write_ptr + i - dist) & cmask;
2382 rar->cstate.window_buf[write_idx] = rar->cstate.window_buf[read_idx];
2385 rar->cstate.write_ptr += len;
2389 static int do_uncompress_block(struct archive_read* a, const uint8_t* p) {
2390 struct rar5* rar = get_context(a);
2394 const int cmask = (int)rar->cstate.window_mask;
2395 const struct compressed_block_header* hdr = &rar->last_block_hdr;
2396 const uint8_t bit_size = 1 + bf_bit_size(hdr);
2399 if(rar->cstate.write_ptr - rar->cstate.last_write_ptr >
2400 (rar->cstate.window_size >> 1)) {
2402 /* Don't allow growing data by more than half of the window size
2403 * at a time. In such case, break the loop; next call to this
2404 * function will continue processing from this moment. */
2409 if(rar->bits.in_addr > rar->cstate.cur_block_size - 1 ||
2410 (rar->bits.in_addr == rar->cstate.cur_block_size - 1 &&
2411 rar->bits.bit_addr >= bit_size))
2413 /* If the program counter is here, it means the function has
2414 * finished processing the block. */
2415 rar->cstate.block_parsing_finished = 1;
2419 /* Decode the next literal. */
2420 if(ARCHIVE_OK != decode_number(a, &rar->cstate.ld, p, &num)) {
2424 /* Num holds a decompression literal, or 'command code'.
2426 * - Values lower than 256 are just bytes. Those codes can be stored
2427 * in the output buffer directly.
2429 * - Code 256 defines a new filter, which is later used to transform
2430 * the data block accordingly to the filter type. The data block
2431 * needs to be fully uncompressed first.
2433 * - Code bigger than 257 and smaller than 262 define a repetition
2434 * pattern that should be copied from an already uncompressed chunk
2439 /* Directly store the byte. */
2441 int64_t write_idx = rar->cstate.solid_offset +
2442 rar->cstate.write_ptr++;
2444 rar->cstate.window_buf[write_idx & cmask] = (uint8_t) num;
2446 } else if(num >= 262) {
2448 int len = decode_code_length(rar, p, num - 262),
2453 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
2454 "Failed to decode the code length");
2456 return ARCHIVE_FATAL;
2459 if(ARCHIVE_OK != decode_number(a, &rar->cstate.dd, p, &dist_slot))
2461 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
2462 "Failed to decode the distance slot");
2464 return ARCHIVE_FATAL;
2471 dbits = dist_slot / 2 - 1;
2472 dist += (2 | (dist_slot & 1)) << dbits;
2481 if(ARCHIVE_OK != read_bits_32(rar, p, &add)) {
2482 /* Return EOF if we can't read more data. */
2486 skip_bits(rar, dbits - 4);
2487 add = (add >> (36 - dbits)) << 4;
2491 if(ARCHIVE_OK != decode_number(a, &rar->cstate.ldd, p,
2494 archive_set_error(&a->archive,
2495 ARCHIVE_ERRNO_PROGRAMMER,
2496 "Failed to decode the distance slot");
2498 return ARCHIVE_FATAL;
2503 /* dbits is one of [0,1,2,3] */
2506 if(ARCHIVE_OK != read_consume_bits(rar, p, dbits, &add)) {
2507 /* Return EOF if we can't read more data. */
2521 if(dist > 0x40000) {
2527 dist_cache_push(rar, dist);
2528 rar->cstate.last_len = len;
2530 if(ARCHIVE_OK != copy_string(a, len, dist))
2531 return ARCHIVE_FATAL;
2534 } else if(num == 256) {
2535 /* Create a filter. */
2536 ret = parse_filter(a, p);
2537 if(ret != ARCHIVE_OK)
2541 } else if(num == 257) {
2542 if(rar->cstate.last_len != 0) {
2543 if(ARCHIVE_OK != copy_string(a, rar->cstate.last_len,
2544 rar->cstate.dist_cache[0]))
2546 return ARCHIVE_FATAL;
2551 } else if(num < 262) {
2552 const int idx = num - 258;
2553 const int dist = dist_cache_touch(rar, idx);
2558 if(ARCHIVE_OK != decode_number(a, &rar->cstate.rd, p, &len_slot)) {
2559 return ARCHIVE_FATAL;
2562 len = decode_code_length(rar, p, len_slot);
2563 rar->cstate.last_len = len;
2565 if(ARCHIVE_OK != copy_string(a, len, dist))
2566 return ARCHIVE_FATAL;
2571 /* The program counter shouldn't reach here. */
2572 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2573 "Unsupported block code: 0x%02x", num);
2575 return ARCHIVE_FATAL;
2581 /* Binary search for the RARv5 signature. */
2582 static int scan_for_signature(struct archive_read* a) {
2584 const int chunk_size = 512;
2587 /* If we're here, it means we're on an 'unknown territory' data.
2588 * There's no indication what kind of data we're reading here. It could be
2589 * some text comment, any kind of binary data, digital sign, dragons, etc.
2591 * We want to find a valid RARv5 magic header inside this unknown data. */
2593 /* Is it possible in libarchive to just skip everything until the
2594 * end of the file? If so, it would be a better approach than the
2595 * current implementation of this function. */
2598 if(!read_ahead(a, chunk_size, &p))
2601 for(i = 0; i < chunk_size - rar5_signature_size; i++) {
2602 if(memcmp(&p[i], rar5_signature, rar5_signature_size) == 0) {
2603 /* Consume the number of bytes we've used to search for the
2604 * signature, as well as the number of bytes used by the
2605 * signature itself. After this we should be standing on a
2606 * valid base block header. */
2607 (void) consume(a, i + rar5_signature_size);
2612 consume(a, chunk_size);
2615 return ARCHIVE_FATAL;
2618 /* This function will switch the multivolume archive file to another file,
2619 * i.e. from part03 to part 04. */
2620 static int advance_multivolume(struct archive_read* a) {
2622 struct rar5* rar = get_context(a);
2624 /* A small state machine that will skip unnecessary data, needed to
2625 * switch from one multivolume to another. Such skipping is needed if
2626 * we want to be an stream-oriented (instead of file-oriented)
2629 * The state machine starts with `rar->main.endarc` == 0. It also
2630 * assumes that current stream pointer points to some base block header.
2632 * The `endarc` field is being set when the base block parsing function
2633 * encounters the 'end of archive' marker.
2637 if(rar->main.endarc == 1) {
2638 rar->main.endarc = 0;
2639 while(ARCHIVE_RETRY == skip_base_block(a));
2642 /* Skip current base block. In order to properly skip it,
2643 * we really need to simply parse it and discard the results. */
2645 lret = skip_base_block(a);
2647 /* The `skip_base_block` function tells us if we should continue
2648 * with skipping, or we should stop skipping. We're trying to skip
2649 * everything up to a base FILE block. */
2651 if(lret != ARCHIVE_RETRY) {
2652 /* If there was an error during skipping, or we have just
2653 * skipped a FILE base block... */
2655 if(rar->main.endarc == 0) {
2667 /* Merges the partial block from the first multivolume archive file, and
2668 * partial block from the second multivolume archive file. The result is
2669 * a chunk of memory containing the whole block, and the stream pointer
2670 * is advanced to the next block in the second multivolume archive file. */
2671 static int merge_block(struct archive_read* a, ssize_t block_size,
2674 struct rar5* rar = get_context(a);
2675 ssize_t cur_block_size, partial_offset = 0;
2679 /* Set a flag that we're in the switching mode. */
2680 rar->cstate.switch_multivolume = 1;
2682 /* Reallocate the memory which will hold the whole block. */
2683 if(rar->vol.push_buf)
2684 free((void*) rar->vol.push_buf);
2686 /* Increasing the allocation block by 8 is due to bit reading functions,
2687 * which are using additional 2 or 4 bytes. Allocating the block size
2688 * by exact value would make bit reader perform reads from invalid memory
2689 * block when reading the last byte from the buffer. */
2690 rar->vol.push_buf = malloc(block_size + 8);
2691 if(!rar->vol.push_buf) {
2692 archive_set_error(&a->archive, ENOMEM, "Can't allocate memory for a "
2693 "merge block buffer.");
2694 return ARCHIVE_FATAL;
2697 /* Valgrind complains if the extension block for bit reader is not
2698 * initialized, so initialize it. */
2699 memset(&rar->vol.push_buf[block_size], 0, 8);
2701 /* A single block can span across multiple multivolume archive files,
2702 * so we use a loop here. This loop will consume enough multivolume
2703 * archive files until the whole block is read. */
2706 /* Get the size of current block chunk in this multivolume archive
2707 * file and read it. */
2709 rar5_min(rar->file.bytes_remaining, block_size - partial_offset);
2711 if(cur_block_size == 0) {
2712 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2713 "Encountered block size == 0 during block merge");
2714 return ARCHIVE_FATAL;
2717 if(!read_ahead(a, cur_block_size, &lp))
2720 /* Sanity check; there should never be a situation where this function
2721 * reads more data than the block's size. */
2722 if(partial_offset + cur_block_size > block_size) {
2723 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
2724 "Consumed too much data when merging blocks.");
2725 return ARCHIVE_FATAL;
2728 /* Merge previous block chunk with current block chunk, or create
2729 * first block chunk if this is our first iteration. */
2730 memcpy(&rar->vol.push_buf[partial_offset], lp, cur_block_size);
2732 /* Advance the stream read pointer by this block chunk size. */
2733 if(ARCHIVE_OK != consume(a, cur_block_size))
2736 /* Update the pointers. `partial_offset` contains information about
2737 * the sum of merged block chunks. */
2738 partial_offset += cur_block_size;
2739 rar->file.bytes_remaining -= cur_block_size;
2741 /* If `partial_offset` is the same as `block_size`, this means we've
2742 * merged all block chunks and we have a valid full block. */
2743 if(partial_offset == block_size) {
2747 /* If we don't have any bytes to read, this means we should switch
2748 * to another multivolume archive file. */
2749 if(rar->file.bytes_remaining == 0) {
2750 ret = advance_multivolume(a);
2751 if(ret != ARCHIVE_OK)
2756 *p = rar->vol.push_buf;
2758 /* If we're here, we can resume unpacking by processing the block pointed
2759 * to by the `*p` memory pointer. */
2764 static int process_block(struct archive_read* a) {
2766 struct rar5* rar = get_context(a);
2769 /* If we don't have any data to be processed, this most probably means
2770 * we need to switch to the next volume. */
2771 if(rar->main.volume && rar->file.bytes_remaining == 0) {
2772 ret = advance_multivolume(a);
2773 if(ret != ARCHIVE_OK)
2777 if(rar->cstate.block_parsing_finished) {
2780 rar->cstate.block_parsing_finished = 0;
2782 /* The header size won't be bigger than 6 bytes. */
2783 if(!read_ahead(a, 6, &p)) {
2784 /* Failed to prefetch data block header. */
2789 * Read block_size by parsing block header. Validate the header by
2790 * calculating CRC byte stored inside the header. Size of the header is
2791 * not constant (block size can be stored either in 1 or 2 bytes),
2792 * that's why block size is left out from the `compressed_block_header`
2793 * structure and returned by `parse_block_header` as the second
2796 ret = parse_block_header(a, p, &block_size, &rar->last_block_hdr);
2797 if(ret != ARCHIVE_OK)
2800 /* Skip block header. Next data is huffman tables, if present. */
2801 ssize_t to_skip = sizeof(struct compressed_block_header) +
2802 bf_byte_count(&rar->last_block_hdr) + 1;
2804 if(ARCHIVE_OK != consume(a, to_skip))
2807 rar->file.bytes_remaining -= to_skip;
2809 /* The block size gives information about the whole block size, but
2810 * the block could be stored in split form when using multi-volume
2811 * archives. In this case, the block size will be bigger than the
2812 * actual data stored in this file. Remaining part of the data will
2813 * be in another file. */
2815 ssize_t cur_block_size =
2816 rar5_min(rar->file.bytes_remaining, block_size);
2818 if(block_size > rar->file.bytes_remaining) {
2819 /* If current blocks' size is bigger than our data size, this
2820 * means we have a multivolume archive. In this case, skip
2821 * all base headers until the end of the file, proceed to next
2822 * "partXXX.rar" volume, find its signature, skip all headers up
2823 * to the first FILE base header, and continue from there.
2825 * Note that `merge_block` will update the `rar` context structure
2826 * quite extensively. */
2828 ret = merge_block(a, block_size, &p);
2829 if(ret != ARCHIVE_OK) {
2833 cur_block_size = block_size;
2835 /* Current stream pointer should be now directly *after* the
2836 * block that spanned through multiple archive files. `p` pointer
2837 * should have the data of the *whole* block (merged from
2838 * partial blocks stored in multiple archives files). */
2840 rar->cstate.switch_multivolume = 0;
2842 /* Read the whole block size into memory. This can take up to
2843 * 8 megabytes of memory in theoretical cases. Might be worth to
2844 * optimize this and use a standard chunk of 4kb's. */
2846 if(!read_ahead(a, 4 + cur_block_size, &p)) {
2847 /* Failed to prefetch block data. */
2852 rar->cstate.block_buf = p;
2853 rar->cstate.cur_block_size = cur_block_size;
2855 rar->bits.in_addr = 0;
2856 rar->bits.bit_addr = 0;
2858 if(bf_is_table_present(&rar->last_block_hdr)) {
2859 /* Load Huffman tables. */
2860 ret = parse_tables(a, rar, p);
2861 if(ret != ARCHIVE_OK) {
2862 /* Error during decompression of Huffman tables. */
2867 p = rar->cstate.block_buf;
2870 /* Uncompress the block, or a part of it, depending on how many bytes
2871 * will be generated by uncompressing the block.
2873 * In case too many bytes will be generated, calling this function again
2874 * will resume the uncompression operation. */
2875 ret = do_uncompress_block(a, p);
2876 if(ret != ARCHIVE_OK) {
2880 if(rar->cstate.block_parsing_finished &&
2881 rar->cstate.switch_multivolume == 0 &&
2882 rar->cstate.cur_block_size > 0)
2884 /* If we're processing a normal block, consume the whole block. We
2885 * can do this because we've already read the whole block to memory.
2887 if(ARCHIVE_OK != consume(a, rar->cstate.cur_block_size))
2888 return ARCHIVE_FATAL;
2890 rar->file.bytes_remaining -= rar->cstate.cur_block_size;
2891 } else if(rar->cstate.switch_multivolume) {
2892 /* Don't consume the block if we're doing multivolume processing.
2893 * The volume switching function will consume the proper count of
2896 rar->cstate.switch_multivolume = 0;
2902 /* Pops the `buf`, `size` and `offset` from the "data ready" stack.
2904 * Returns ARCHIVE_OK when those arguments can be used, ARCHIVE_RETRY
2905 * when there is no data on the stack. */
2906 static int use_data(struct rar5* rar, const void** buf, size_t* size,
2911 for(i = 0; i < rar5_countof(rar->cstate.dready); i++) {
2912 struct data_ready *d = &rar->cstate.dready[i];
2915 if(buf) *buf = d->buf;
2916 if(size) *size = d->size;
2917 if(offset) *offset = d->offset;
2924 return ARCHIVE_RETRY;
2927 /* Pushes the `buf`, `size` and `offset` arguments to the rar->cstate.dready
2928 * FIFO stack. Those values will be popped from this stack by the `use_data`
2930 static int push_data_ready(struct archive_read* a, struct rar5* rar,
2931 const uint8_t* buf, size_t size, int64_t offset)
2935 /* Don't push if we're in skip mode. This is needed because solid
2936 * streams need full processing even if we're skipping data. After fully
2937 * processing the stream, we need to discard the generated bytes, because
2938 * we're interested only in the side effect: building up the internal
2939 * window circular buffer. This window buffer will be used later during
2940 * unpacking of requested data. */
2945 if(offset != rar->file.last_offset + rar->file.last_size) {
2946 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, "Sanity "
2947 "check error: output stream is not continuous");
2948 return ARCHIVE_FATAL;
2951 for(i = 0; i < rar5_countof(rar->cstate.dready); i++) {
2952 struct data_ready* d = &rar->cstate.dready[i];
2959 /* These fields are used only in sanity checking. */
2960 rar->file.last_offset = offset;
2961 rar->file.last_size = size;
2963 /* Calculate the checksum of this new block before submitting
2964 * data to libarchive's engine. */
2965 update_crc(rar, d->buf, d->size);
2971 /* Program counter will reach this code if the `rar->cstate.data_ready`
2972 * stack will be filled up so that no new entries will be allowed. The
2973 * code shouldn't allow such situation to occur. So we treat this case
2974 * as an internal error. */
2976 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, "Error: "
2977 "premature end of data_ready stack");
2978 return ARCHIVE_FATAL;
2981 /* This function uncompresses the data that is stored in the <FILE> base
2984 * The FILE base block looks like this:
2986 * <header><huffman tables><block_1><block_2>...<block_n>
2988 * The <header> is a block header, that is parsed in parse_block_header().
2989 * It's a "compressed_block_header" structure, containing metadata needed
2990 * to know when we should stop looking for more <block_n> blocks.
2992 * <huffman tables> contain data needed to set up the huffman tables, needed
2993 * for the actual decompression.
2995 * Each <block_n> consists of series of literals:
2997 * <literal><literal><literal>...<literal>
2999 * Those literals generate the uncompression data. They operate on a circular
3000 * buffer, sometimes writing raw data into it, sometimes referencing
3001 * some previous data inside this buffer, and sometimes declaring a filter
3002 * that will need to be executed on the data stored in the circular buffer.
3003 * It all depends on the literal that is used.
3005 * Sometimes blocks produce output data, sometimes they don't. For example, for
3006 * some huge files that use lots of filters, sometimes a block is filled with
3007 * only filter declaration literals. Such blocks won't produce any data in the
3010 * Sometimes blocks will produce 4 bytes of data, and sometimes 1 megabyte,
3011 * because a literal can reference previously decompressed data. For example,
3012 * there can be a literal that says: 'append a byte 0xFE here', and after
3013 * it another literal can say 'append 1 megabyte of data from circular buffer
3014 * offset 0x12345'. This is how RAR format handles compressing repeated
3017 * The RAR compressor creates those literals and the actual efficiency of
3018 * compression depends on what those literals are. The literals can also
3019 * be seen as a kind of a non-turing-complete virtual machine that simply
3020 * tells the decompressor what it should do.
3023 static int do_uncompress_file(struct archive_read* a) {
3024 struct rar5* rar = get_context(a);
3026 int64_t max_end_pos;
3028 if(!rar->cstate.initialized) {
3029 /* Don't perform full context reinitialization if we're processing
3030 * a solid archive. */
3031 if(!rar->main.solid || !rar->cstate.window_buf) {
3035 rar->cstate.initialized = 1;
3038 if(rar->cstate.all_filters_applied == 1) {
3039 /* We use while(1) here, but standard case allows for just 1 iteration.
3040 * The loop will iterate if process_block() didn't generate any data at
3041 * all. This can happen if the block contains only filter definitions
3042 * (this is common in big files). */
3045 ret = process_block(a);
3046 if(ret == ARCHIVE_EOF || ret == ARCHIVE_FATAL)
3049 if(rar->cstate.last_write_ptr == rar->cstate.write_ptr) {
3050 /* The block didn't generate any new data, so just process
3055 /* The block has generated some new data, so break the loop. */
3060 /* Try to run filters. If filters won't be applied, it means that
3061 * insufficient data was generated. */
3062 ret = apply_filters(a);
3063 if(ret == ARCHIVE_RETRY) {
3065 } else if(ret == ARCHIVE_FATAL) {
3066 return ARCHIVE_FATAL;
3069 /* If apply_filters() will return ARCHIVE_OK, we can continue here. */
3071 if(cdeque_size(&rar->cstate.filters) > 0) {
3072 /* Check if we can write something before hitting first filter. */
3073 struct filter_info* flt;
3075 /* Get the block_start offset from the first filter. */
3076 if(CDE_OK != cdeque_front(&rar->cstate.filters, cdeque_filter_p(&flt)))
3078 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
3079 "Can't read first filter");
3080 return ARCHIVE_FATAL;
3083 max_end_pos = rar5_min(flt->block_start, rar->cstate.write_ptr);
3085 /* There are no filters defined, or all filters were applied. This
3086 * means we can just store the data without any postprocessing. */
3087 max_end_pos = rar->cstate.write_ptr;
3090 if(max_end_pos == rar->cstate.last_write_ptr) {
3091 /* We can't write anything yet. The block uncompression function did
3092 * not generate enough data, and no filter can be applied. At the same
3093 * time we don't have any data that can be stored without filter
3094 * postprocessing. This means we need to wait for more data to be
3095 * generated, so we can apply the filters.
3097 * Signal the caller that we need more data to be able to do anything.
3099 return ARCHIVE_RETRY;
3101 /* We can write the data before hitting the first filter. So let's
3102 * do it. The push_window_data() function will effectively return
3103 * the selected data block to the user application. */
3104 push_window_data(a, rar, rar->cstate.last_write_ptr, max_end_pos);
3105 rar->cstate.last_write_ptr = max_end_pos;
3111 static int uncompress_file(struct archive_read* a) {
3115 /* Sometimes the uncompression function will return a 'retry' signal.
3116 * If this will happen, we have to retry the function. */
3117 ret = do_uncompress_file(a);
3118 if(ret != ARCHIVE_RETRY)
3124 static int do_unstore_file(struct archive_read* a,
3132 if(rar->file.bytes_remaining == 0 && rar->main.volume > 0 &&
3133 rar->generic.split_after > 0)
3137 rar->cstate.switch_multivolume = 1;
3138 ret = advance_multivolume(a);
3139 rar->cstate.switch_multivolume = 0;
3141 if(ret != ARCHIVE_OK) {
3142 /* Failed to advance to next multivolume archive file. */
3147 size_t to_read = rar5_min(rar->file.bytes_remaining, 64 * 1024);
3152 if(!read_ahead(a, to_read, &p)) {
3153 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, "I/O error "
3154 "when unstoring file");
3155 return ARCHIVE_FATAL;
3158 if(ARCHIVE_OK != consume(a, to_read)) {
3163 if(size) *size = to_read;
3164 if(offset) *offset = rar->cstate.last_unstore_ptr;
3166 rar->file.bytes_remaining -= to_read;
3167 rar->cstate.last_unstore_ptr += to_read;
3169 update_crc(rar, p, to_read);
3173 static int do_unpack(struct archive_read* a, struct rar5* rar,
3174 const void** buf, size_t* size, int64_t* offset)
3176 enum COMPRESSION_METHOD {
3177 STORE = 0, FASTEST = 1, FAST = 2, NORMAL = 3, GOOD = 4, BEST = 5
3180 if(rar->file.service > 0) {
3181 return do_unstore_file(a, rar, buf, size, offset);
3183 switch(rar->cstate.method) {
3185 return do_unstore_file(a, rar, buf, size, offset);
3195 return uncompress_file(a);
3197 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
3198 "Compression method not supported: 0x%08x",
3199 rar->cstate.method);
3201 return ARCHIVE_FATAL;
3211 static int verify_checksums(struct archive_read* a) {
3213 struct rar5* rar = get_context(a);
3215 /* Check checksums only when actually unpacking the data. There's no need
3216 * to calculate checksum when we're skipping data in solid archives
3217 * (skipping in solid archives is the same thing as unpacking compressed
3218 * data and discarding the result). */
3220 if(!rar->skip_mode) {
3221 /* Always check checksums if we're not in skip mode */
3224 /* We can override the logic above with a compile-time option
3225 * NO_CRC_ON_SOLID_SKIP. This option is used during debugging, and it
3226 * will check checksums of unpacked data even when we're skipping it.
3229 #if defined CHECK_CRC_ON_SOLID_SKIP
3239 /* During unpacking, on each unpacked block we're calling the
3240 * update_crc() function. Since we are here, the unpacking process is
3241 * already over and we can check if calculated checksum (CRC32 or
3242 * BLAKE2sp) is the same as what is stored in the archive.
3244 if(rar->file.stored_crc32 > 0) {
3245 /* Check CRC32 only when the file contains a CRC32 value for this
3248 if(rar->file.calculated_crc32 != rar->file.stored_crc32) {
3249 /* Checksums do not match; the unpacked file is corrupted. */
3252 printf("Checksum error: CRC32 (was: %08x, expected: %08x)\n",
3253 rar->file.calculated_crc32, rar->file.stored_crc32);
3256 #ifndef DONT_FAIL_ON_CRC_ERROR
3257 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
3258 "Checksum error: CRC32");
3259 return ARCHIVE_FATAL;
3263 printf("Checksum OK: CRC32 (%08x/%08x)\n",
3264 rar->file.stored_crc32,
3265 rar->file.calculated_crc32);
3270 if(rar->file.has_blake2 > 0) {
3271 /* BLAKE2sp is an optional checksum algorithm that is added to
3272 * RARv5 archives when using the `-htb` switch during creation of
3275 * We now finalize the hash calculation by calling the `final`
3276 * function. This will generate the final hash value we can use to
3277 * compare it with the BLAKE2sp checksum that is stored in the
3280 * The return value of this `final` function is not very helpful,
3281 * as it guards only against improper use. This is why we're
3282 * explicitly ignoring it. */
3285 (void) blake2sp_final(&rar->file.b2state, b2_buf, 32);
3287 if(memcmp(&rar->file.blake2sp, b2_buf, 32) != 0) {
3288 #ifndef DONT_FAIL_ON_CRC_ERROR
3289 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
3290 "Checksum error: BLAKE2");
3292 return ARCHIVE_FATAL;
3298 /* Finalization for this file has been successfully completed. */
3302 static int verify_global_checksums(struct archive_read* a) {
3303 return verify_checksums(a);
3306 static int rar5_read_data(struct archive_read *a, const void **buff,
3307 size_t *size, int64_t *offset) {
3309 struct rar5* rar = get_context(a);
3311 if(!rar->skip_mode && (rar->cstate.last_write_ptr > rar->file.unpacked_size)) {
3312 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
3313 "Unpacker has written too many bytes");
3314 return ARCHIVE_FATAL;
3317 ret = use_data(rar, buff, size, offset);
3318 if(ret == ARCHIVE_OK) {
3322 if(rar->file.eof == 1) {
3326 ret = do_unpack(a, rar, buff, size, offset);
3327 if(ret != ARCHIVE_OK) {
3331 if(rar->file.bytes_remaining == 0 &&
3332 rar->cstate.last_write_ptr == rar->file.unpacked_size)
3334 /* If all bytes of current file were processed, run finalization.
3336 * Finalization will check checksum against proper values. If
3337 * some of the checksums will not match, we'll return an error
3338 * value in the last `archive_read_data` call to signal an error
3342 return verify_global_checksums(a);
3348 static int rar5_read_data_skip(struct archive_read *a) {
3349 struct rar5* rar = get_context(a);
3351 if(rar->main.solid) {
3352 /* In solid archives, instead of skipping the data, we need to extract
3353 * it, and dispose the result. The side effect of this operation will
3354 * be setting up the initial window buffer state needed to be able to
3355 * extract the selected file. */
3359 /* Make sure to process all blocks in the compressed stream. */
3360 while(rar->file.bytes_remaining > 0) {
3361 /* Setting the "skip mode" will allow us to skip checksum checks
3362 * during data skipping. Checking the checksum of skipped data
3363 * isn't really necessary and it's only slowing things down.
3365 * This is incremented instead of setting to 1 because this data
3366 * skipping function can be called recursively. */
3369 /* We're disposing 1 block of data, so we use triple NULLs in
3372 ret = rar5_read_data(a, NULL, NULL, NULL);
3374 /* Turn off "skip mode". */
3378 /* Propagate any potential error conditions to the caller. */
3383 /* In standard archives, we can just jump over the compressed stream.
3384 * Each file in non-solid archives starts from an empty window buffer.
3387 if(ARCHIVE_OK != consume(a, rar->file.bytes_remaining)) {
3388 return ARCHIVE_FATAL;
3391 rar->file.bytes_remaining = 0;
3397 static int64_t rar5_seek_data(struct archive_read *a, int64_t offset,
3404 /* We're a streaming unpacker, and we don't support seeking. */
3406 return ARCHIVE_FATAL;
3409 static int rar5_cleanup(struct archive_read *a) {
3410 struct rar5* rar = get_context(a);
3412 free(rar->cstate.window_buf);
3414 free(rar->cstate.filtered_buf);
3416 free(rar->vol.push_buf);
3419 cdeque_free(&rar->cstate.filters);
3422 a->format->data = NULL;
3427 static int rar5_capabilities(struct archive_read * a) {
3432 static int rar5_has_encrypted_entries(struct archive_read *_a) {
3435 /* Unsupported for now. */
3436 return ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED;
3439 static int rar5_init(struct rar5* rar) {
3442 memset(rar, 0, sizeof(struct rar5));
3444 /* Decrypt the magic signature pattern. Check the comment near the
3445 * `rar5_signature` symbol to read the rationale behind this. */
3447 if(rar5_signature[0] == 243) {
3448 for(i = 0; i < rar5_signature_size; i++) {
3449 rar5_signature[i] ^= 0xA1;
3453 if(CDE_OK != cdeque_init(&rar->cstate.filters, 8192))
3454 return ARCHIVE_FATAL;
3459 int archive_read_support_format_rar5(struct archive *_a) {
3460 struct archive_read* ar;
3464 if(ARCHIVE_OK != (ret = get_archive_read(_a, &ar)))
3467 rar = malloc(sizeof(*rar));
3469 archive_set_error(&ar->archive, ENOMEM, "Can't allocate rar5 data");
3470 return ARCHIVE_FATAL;
3473 if(ARCHIVE_OK != rar5_init(rar)) {
3474 archive_set_error(&ar->archive, ENOMEM, "Can't allocate rar5 filter "
3476 return ARCHIVE_FATAL;
3479 ret = __archive_read_register_format(ar,
3486 rar5_read_data_skip,
3490 rar5_has_encrypted_entries);
3492 if(ret != ARCHIVE_OK) {
3493 (void) rar5_cleanup(ar);