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 */
42 #include "archive_crc32.h"
45 #include "archive_entry.h"
46 #include "archive_entry_locale.h"
47 #include "archive_ppmd7_private.h"
48 #include "archive_entry_private.h"
53 #include "archive_blake2.h"
56 /*#define CHECK_CRC_ON_SOLID_SKIP*/
57 /*#define DONT_FAIL_ON_CRC_ERROR*/
60 #define rar5_min(a, b) (((a) > (b)) ? (b) : (a))
61 #define rar5_max(a, b) (((a) > (b)) ? (a) : (b))
62 #define rar5_countof(X) ((const ssize_t) (sizeof(X) / sizeof(*X)))
65 #define DEBUG_CODE if(1)
66 #define LOG(...) do { printf("rar5: " __VA_ARGS__); puts(""); } while(0)
68 #define DEBUG_CODE if(0)
71 /* Real RAR5 magic number is:
73 * 0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x01, 0x00
76 * It's stored in `rar5_signature` after XOR'ing it with 0xA1, because I don't
77 * want to put this magic sequence in each binary that uses libarchive, so
78 * applications that scan through the file for this marker won't trigger on
81 * The array itself is decrypted in `rar5_init` function. */
83 static unsigned char rar5_signature[] = { 243, 192, 211, 128, 187, 166, 160, 161 };
84 static const ssize_t rar5_signature_size = sizeof(rar5_signature);
85 static const size_t g_unpack_window_size = 0x20000;
87 /* These could have been static const's, but they aren't, because of
89 #define MAX_NAME_IN_CHARS 2048
90 #define MAX_NAME_IN_BYTES (4 * MAX_NAME_IN_CHARS)
93 ssize_t bytes_remaining;
94 ssize_t unpacked_size;
95 int64_t last_offset; /* Used in sanity checks. */
96 int64_t last_size; /* Used in sanity checks. */
98 uint8_t solid : 1; /* Is this a solid stream? */
99 uint8_t service : 1; /* Is this file a service data? */
100 uint8_t eof : 1; /* Did we finish unpacking the file? */
101 uint8_t dir : 1; /* Is this file entry a directory? */
103 /* Optional time fields. */
109 /* Optional hash fields. */
110 uint32_t stored_crc32;
111 uint32_t calculated_crc32;
112 uint8_t blake2sp[32];
113 blake2sp_state b2state;
116 /* Optional redir fields */
118 uint64_t redir_flags;
120 ssize_t solid_window_size; /* Used in file format check. */
133 #define REDIR_SYMLINK_IS_DIR 1
137 REDIR_TYPE_UNIXSYMLINK = 1,
138 REDIR_TYPE_WINSYMLINK = 2,
139 REDIR_TYPE_JUNCTION = 3,
140 REDIR_TYPE_HARDLINK = 4,
141 REDIR_TYPE_FILECOPY = 5,
144 #define OWNER_USER_NAME 0x01
145 #define OWNER_GROUP_NAME 0x02
146 #define OWNER_USER_UID 0x04
147 #define OWNER_GROUP_GID 0x08
148 #define OWNER_MAXNAMELEN 256
151 FILTER_DELTA = 0, /* Generic pattern. */
152 FILTER_E8 = 1, /* Intel x86 code. */
153 FILTER_E8E9 = 2, /* Intel x86 code. */
154 FILTER_ARM = 3, /* ARM code. */
155 FILTER_AUDIO = 4, /* Audio filter, not used in RARv5. */
156 FILTER_RGB = 5, /* Color palette, not used in RARv5. */
157 FILTER_ITANIUM = 6, /* Intel's Itanium, not used in RARv5. */
158 FILTER_PPM = 7, /* Predictive pattern matching, not used in
169 ssize_t block_length;
188 struct decode_table {
190 int32_t decode_len[16];
191 uint32_t decode_pos[16];
193 uint8_t quick_len[1 << 10];
194 uint16_t quick_num[1 << 10];
195 uint16_t decode_num[306];
199 /* Flag used to specify if unpacker needs to reinitialize the
200 uncompression context. */
201 uint8_t initialized : 1;
203 /* Flag used when applying filters. */
204 uint8_t all_filters_applied : 1;
206 /* Flag used to skip file context reinitialization, used when unpacker
207 is skipping through different multivolume archives. */
208 uint8_t switch_multivolume : 1;
210 /* Flag used to specify if unpacker has processed the whole data block
211 or just a part of it. */
212 uint8_t block_parsing_finished : 1;
216 int flags; /* Uncompression flags. */
217 int method; /* Uncompression algorithm method. */
218 int version; /* Uncompression algorithm version. */
219 ssize_t window_size; /* Size of window_buf. */
220 uint8_t* window_buf; /* Circular buffer used during
222 uint8_t* filtered_buf; /* Buffer used when applying filters. */
223 const uint8_t* block_buf; /* Buffer used when merging blocks. */
224 size_t window_mask; /* Convenience field; window_size - 1. */
225 int64_t write_ptr; /* This amount of data has been unpacked
226 in the window buffer. */
227 int64_t last_write_ptr; /* This amount of data has been stored in
229 int64_t last_unstore_ptr; /* Counter of bytes extracted during
230 unstoring. This is separate from
231 last_write_ptr because of how SERVICE
232 base blocks are handled during skipping
233 in solid multiarchive archives. */
234 int64_t solid_offset; /* Additional offset inside the window
235 buffer, used in unpacking solid
237 ssize_t cur_block_size; /* Size of current data block. */
238 int last_len; /* Flag used in lzss decompression. */
240 /* Decode tables used during lzss uncompression. */
243 struct decode_table bd; /* huffman bit lengths */
245 struct decode_table ld; /* literals */
247 struct decode_table dd; /* distances */
249 struct decode_table ldd; /* lower bits of distances */
251 struct decode_table rd; /* repeating distances */
252 #define HUFF_TABLE_SIZE (HUFF_NC + HUFF_DC + HUFF_RC + HUFF_LDC)
254 /* Circular deque for storing filters. */
255 struct cdeque filters;
256 int64_t last_block_start; /* Used for sanity checking. */
257 ssize_t last_block_length; /* Used for sanity checking. */
259 /* Distance cache used during lzss uncompression. */
262 /* Data buffer stack. */
263 struct data_ready dready[2];
266 /* Bit reader state. */
268 int8_t bit_addr; /* Current bit pointer inside current byte. */
269 int in_addr; /* Current byte pointer. */
272 /* RARv5 block header structure. Use bf_* functions to get values from
273 * block_flags_u8 field. I.e. bf_byte_count, etc. */
274 struct compressed_block_header {
275 /* block_flags_u8 contain fields encoded in little-endian bitfield:
277 * - table present flag (shr 7, and 1),
278 * - last block flag (shr 6, and 1),
279 * - byte_count (shr 3, and 7),
280 * - bit_size (shr 0, and 7).
282 uint8_t block_flags_u8;
286 /* RARv5 main header structure. */
288 /* Does the archive contain solid streams? */
291 /* If this a multi-file archive? */
299 struct generic_header {
300 uint8_t split_after : 1;
301 uint8_t split_before : 1;
308 unsigned int expected_vol_no;
312 /* Main context structure. */
314 int header_initialized;
316 /* Set to 1 if current file is positioned AFTER the magic value
317 * of the archive file. This is used in header reading functions. */
320 /* Set to not zero if we're in skip mode (either by calling
321 * rar5_data_skip function or when skipping over solid streams).
322 * Set to 0 when in * extraction mode. This is used during checksum
323 * calculation functions. */
326 /* Set to not zero if we're in block merging mode (i.e. when switching
327 * to another file in multivolume archive, last block from 1st archive
328 * needs to be merged with 1st block from 2nd archive). This flag
329 * guards against recursive use of the merging function, which doesn't
330 * support recursive calls. */
333 /* An offset to QuickOpen list. This is not supported by this unpacker,
334 * because we're focusing on streaming interface. QuickOpen is designed
335 * to make things quicker for non-stream interfaces, so it's not our
337 uint64_t qlist_offset;
339 /* An offset to additional Recovery data. This is not supported by this
340 * unpacker. Recovery data are additional Reed-Solomon codes that could
341 * be used to calculate bytes that are missing in archive or are
345 /* Various context variables grouped to different structures. */
346 struct generic_header generic;
347 struct main_header main;
348 struct comp_state cstate;
349 struct file_header file;
350 struct bit_reader bits;
351 struct multivolume vol;
353 /* The header of currently processed RARv5 block. Used in main
354 * decompression logic loop. */
355 struct compressed_block_header last_block_hdr;
358 /* Forward function declarations. */
360 static int verify_global_checksums(struct archive_read* a);
361 static int rar5_read_data_skip(struct archive_read *a);
362 static int push_data_ready(struct archive_read* a, struct rar5* rar,
363 const uint8_t* buf, size_t size, int64_t offset);
365 /* CDE_xxx = Circular Double Ended (Queue) return values. */
366 enum CDE_RETURN_VALUES {
367 CDE_OK, CDE_ALLOC, CDE_PARAM, CDE_OUT_OF_BOUNDS,
370 /* Clears the contents of this circular deque. */
371 static void cdeque_clear(struct cdeque* d) {
377 /* Creates a new circular deque object. Capacity must be power of 2: 8, 16, 32,
378 * 64, 256, etc. When the user will add another item above current capacity,
379 * the circular deque will overwrite the oldest entry. */
380 static int cdeque_init(struct cdeque* d, int max_capacity_power_of_2) {
381 if(d == NULL || max_capacity_power_of_2 == 0)
384 d->cap_mask = max_capacity_power_of_2 - 1;
387 if((max_capacity_power_of_2 & d->cap_mask) > 0)
391 d->arr = malloc(sizeof(void*) * max_capacity_power_of_2);
393 return d->arr ? CDE_OK : CDE_ALLOC;
396 /* Return the current size (not capacity) of circular deque `d`. */
397 static size_t cdeque_size(struct cdeque* d) {
401 /* Returns the first element of current circular deque. Note that this function
402 * doesn't perform any bounds checking. If you need bounds checking, use
403 * `cdeque_front()` function instead. */
404 static void cdeque_front_fast(struct cdeque* d, void** value) {
405 *value = (void*) d->arr[d->beg_pos];
408 /* Returns the first element of current circular deque. This function
409 * performs bounds checking. */
410 static int cdeque_front(struct cdeque* d, void** value) {
412 cdeque_front_fast(d, value);
415 return CDE_OUT_OF_BOUNDS;
418 /* Pushes a new element into the end of this circular deque object. If current
419 * size will exceed capacity, the oldest element will be overwritten. */
420 static int cdeque_push_back(struct cdeque* d, void* item) {
424 if(d->size == d->cap_mask + 1)
425 return CDE_OUT_OF_BOUNDS;
427 d->arr[d->end_pos] = (size_t) item;
428 d->end_pos = (d->end_pos + 1) & d->cap_mask;
434 /* Pops a front element of this circular deque object and returns its value.
435 * This function doesn't perform any bounds checking. */
436 static void cdeque_pop_front_fast(struct cdeque* d, void** value) {
437 *value = (void*) d->arr[d->beg_pos];
438 d->beg_pos = (d->beg_pos + 1) & d->cap_mask;
442 /* Pops a front element of this circular deque object and returns its value.
443 * This function performs bounds checking. */
444 static int cdeque_pop_front(struct cdeque* d, void** value) {
449 return CDE_OUT_OF_BOUNDS;
451 cdeque_pop_front_fast(d, value);
455 /* Convenience function to cast filter_info** to void **. */
456 static void** cdeque_filter_p(struct filter_info** f) {
457 return (void**) (size_t) f;
460 /* Convenience function to cast filter_info* to void *. */
461 static void* cdeque_filter(struct filter_info* f) {
462 return (void**) (size_t) f;
465 /* Destroys this circular deque object. Deallocates the memory of the
466 * collection buffer, but doesn't deallocate the memory of any pointer passed
467 * to this deque as a value. */
468 static void cdeque_free(struct cdeque* d) {
484 uint8_t bf_bit_size(const struct compressed_block_header* hdr) {
485 return hdr->block_flags_u8 & 7;
489 uint8_t bf_byte_count(const struct compressed_block_header* hdr) {
490 return (hdr->block_flags_u8 >> 3) & 7;
494 uint8_t bf_is_table_present(const struct compressed_block_header* hdr) {
495 return (hdr->block_flags_u8 >> 7) & 1;
498 static inline struct rar5* get_context(struct archive_read* a) {
499 return (struct rar5*) a->format->data;
502 /* Convenience functions used by filter implementations. */
503 static void circular_memcpy(uint8_t* dst, uint8_t* window, const uint64_t mask,
504 int64_t start, int64_t end)
506 if((start & mask) > (end & mask)) {
507 ssize_t len1 = mask + 1 - (start & mask);
508 ssize_t len2 = end & mask;
510 memcpy(dst, &window[start & mask], len1);
511 memcpy(dst + len1, window, len2);
513 memcpy(dst, &window[start & mask], (size_t) (end - start));
517 static uint32_t read_filter_data(struct rar5* rar, uint32_t offset) {
518 uint8_t linear_buf[4];
519 circular_memcpy(linear_buf, rar->cstate.window_buf,
520 rar->cstate.window_mask, offset, offset + 4);
521 return archive_le32dec(linear_buf);
524 static void write_filter_data(struct rar5* rar, uint32_t offset,
527 archive_le32enc(&rar->cstate.filtered_buf[offset], value);
530 /* Allocates a new filter descriptor and adds it to the filter array. */
531 static struct filter_info* add_new_filter(struct rar5* rar) {
532 struct filter_info* f =
533 (struct filter_info*) calloc(1, sizeof(struct filter_info));
539 cdeque_push_back(&rar->cstate.filters, cdeque_filter(f));
543 static int run_delta_filter(struct rar5* rar, struct filter_info* flt) {
545 ssize_t dest_pos, src_pos = 0;
547 for(i = 0; i < flt->channels; i++) {
548 uint8_t prev_byte = 0;
550 dest_pos < flt->block_length;
551 dest_pos += flt->channels)
555 byte = rar->cstate.window_buf[
556 (rar->cstate.solid_offset + flt->block_start +
557 src_pos) & rar->cstate.window_mask];
560 rar->cstate.filtered_buf[dest_pos] = prev_byte;
568 static int run_e8e9_filter(struct rar5* rar, struct filter_info* flt,
571 const uint32_t file_size = 0x1000000;
574 circular_memcpy(rar->cstate.filtered_buf,
575 rar->cstate.window_buf, rar->cstate.window_mask,
576 rar->cstate.solid_offset + flt->block_start,
577 rar->cstate.solid_offset + flt->block_start + flt->block_length);
579 for(i = 0; i < flt->block_length - 4;) {
580 uint8_t b = rar->cstate.window_buf[
581 (rar->cstate.solid_offset + flt->block_start +
582 i++) & rar->cstate.window_mask];
585 * 0xE8 = x86's call <relative_addr_uint32> (function call)
586 * 0xE9 = x86's jmp <relative_addr_uint32> (unconditional jump)
588 if(b == 0xE8 || (extended && b == 0xE9)) {
591 uint32_t offset = (i + flt->block_start) % file_size;
593 addr = read_filter_data(rar,
594 (uint32_t)(rar->cstate.solid_offset +
595 flt->block_start + i) & rar->cstate.window_mask);
597 if(addr & 0x80000000) {
598 if(((addr + offset) & 0x80000000) == 0) {
599 write_filter_data(rar, (uint32_t)i,
603 if((addr - file_size) & 0x80000000) {
604 uint32_t naddr = addr - offset;
605 write_filter_data(rar, (uint32_t)i,
617 static int run_arm_filter(struct rar5* rar, struct filter_info* flt) {
621 circular_memcpy(rar->cstate.filtered_buf,
622 rar->cstate.window_buf, rar->cstate.window_mask,
623 rar->cstate.solid_offset + flt->block_start,
624 rar->cstate.solid_offset + flt->block_start + flt->block_length);
626 for(i = 0; i < flt->block_length - 3; i += 4) {
627 uint8_t* b = &rar->cstate.window_buf[
628 (rar->cstate.solid_offset +
629 flt->block_start + i + 3) & rar->cstate.window_mask];
632 /* 0xEB = ARM's BL (branch + link) instruction. */
633 offset = read_filter_data(rar,
634 (rar->cstate.solid_offset + flt->block_start + i) &
635 rar->cstate.window_mask) & 0x00ffffff;
637 offset -= (uint32_t) ((i + flt->block_start) / 4);
638 offset = (offset & 0x00ffffff) | 0xeb000000;
639 write_filter_data(rar, (uint32_t)i, offset);
646 static int run_filter(struct archive_read* a, struct filter_info* flt) {
648 struct rar5* rar = get_context(a);
650 free(rar->cstate.filtered_buf);
652 rar->cstate.filtered_buf = malloc(flt->block_length);
653 if(!rar->cstate.filtered_buf) {
654 archive_set_error(&a->archive, ENOMEM,
655 "Can't allocate memory for filter data.");
656 return ARCHIVE_FATAL;
661 ret = run_delta_filter(rar, flt);
667 ret = run_e8e9_filter(rar, flt,
668 flt->type == FILTER_E8E9);
672 ret = run_arm_filter(rar, flt);
676 archive_set_error(&a->archive,
677 ARCHIVE_ERRNO_FILE_FORMAT,
678 "Unsupported filter type: 0x%x", flt->type);
679 return ARCHIVE_FATAL;
682 if(ret != ARCHIVE_OK) {
683 /* Filter has failed. */
687 if(ARCHIVE_OK != push_data_ready(a, rar, rar->cstate.filtered_buf,
688 flt->block_length, rar->cstate.last_write_ptr))
690 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
691 "Stack overflow when submitting unpacked data");
693 return ARCHIVE_FATAL;
696 rar->cstate.last_write_ptr += flt->block_length;
700 /* The `push_data` function submits the selected data range to the user.
701 * Next call of `use_data` will use the pointer, size and offset arguments
702 * that are specified here. These arguments are pushed to the FIFO stack here,
703 * and popped from the stack by the `use_data` function. */
704 static void push_data(struct archive_read* a, struct rar5* rar,
705 const uint8_t* buf, int64_t idx_begin, int64_t idx_end)
707 const uint64_t wmask = rar->cstate.window_mask;
708 const ssize_t solid_write_ptr = (rar->cstate.solid_offset +
709 rar->cstate.last_write_ptr) & wmask;
711 idx_begin += rar->cstate.solid_offset;
712 idx_end += rar->cstate.solid_offset;
714 /* Check if our unpacked data is wrapped inside the window circular
715 * buffer. If it's not wrapped, it can be copied out by using
716 * a single memcpy, but when it's wrapped, we need to copy the first
717 * part with one memcpy, and the second part with another memcpy. */
719 if((idx_begin & wmask) > (idx_end & wmask)) {
720 /* The data is wrapped (begin offset sis bigger than end
722 const ssize_t frag1_size = rar->cstate.window_size -
724 const ssize_t frag2_size = idx_end & wmask;
726 /* Copy the first part of the buffer first. */
727 push_data_ready(a, rar, buf + solid_write_ptr, frag1_size,
728 rar->cstate.last_write_ptr);
730 /* Copy the second part of the buffer. */
731 push_data_ready(a, rar, buf, frag2_size,
732 rar->cstate.last_write_ptr + frag1_size);
734 rar->cstate.last_write_ptr += frag1_size + frag2_size;
736 /* Data is not wrapped, so we can just use one call to copy the
738 push_data_ready(a, rar,
739 buf + solid_write_ptr, (idx_end - idx_begin) & wmask,
740 rar->cstate.last_write_ptr);
742 rar->cstate.last_write_ptr += idx_end - idx_begin;
746 /* Convenience function that submits the data to the user. It uses the
747 * unpack window buffer as a source location. */
748 static void push_window_data(struct archive_read* a, struct rar5* rar,
749 int64_t idx_begin, int64_t idx_end)
751 push_data(a, rar, rar->cstate.window_buf, idx_begin, idx_end);
754 static int apply_filters(struct archive_read* a) {
755 struct filter_info* flt;
756 struct rar5* rar = get_context(a);
759 rar->cstate.all_filters_applied = 0;
761 /* Get the first filter that can be applied to our data. The data
762 * needs to be fully unpacked before the filter can be run. */
763 if(CDE_OK == cdeque_front(&rar->cstate.filters,
764 cdeque_filter_p(&flt))) {
765 /* Check if our unpacked data fully covers this filter's
767 if(rar->cstate.write_ptr > flt->block_start &&
768 rar->cstate.write_ptr >= flt->block_start +
770 /* Check if we have some data pending to be written
771 * right before the filter's start offset. */
772 if(rar->cstate.last_write_ptr == flt->block_start) {
773 /* Run the filter specified by descriptor
775 ret = run_filter(a, flt);
776 if(ret != ARCHIVE_OK) {
777 /* Filter failure, return error. */
781 /* Filter descriptor won't be needed anymore
782 * after it's used, * so remove it from the
783 * filter list and free its memory. */
784 (void) cdeque_pop_front(&rar->cstate.filters,
785 cdeque_filter_p(&flt));
789 /* We can't run filters yet, dump the memory
790 * right before the filter. */
791 push_window_data(a, rar,
792 rar->cstate.last_write_ptr,
796 /* Return 'filter applied or not needed' state to the
798 return ARCHIVE_RETRY;
802 rar->cstate.all_filters_applied = 1;
806 static void dist_cache_push(struct rar5* rar, int value) {
807 int* q = rar->cstate.dist_cache;
815 static int dist_cache_touch(struct rar5* rar, int idx) {
816 int* q = rar->cstate.dist_cache;
817 int i, dist = q[idx];
819 for(i = idx; i > 0; i--)
826 static void free_filters(struct rar5* rar) {
827 struct cdeque* d = &rar->cstate.filters;
829 /* Free any remaining filters. All filters should be naturally
830 * consumed by the unpacking function, so remaining filters after
831 * unpacking normally mean that unpacking wasn't successful.
832 * But still of course we shouldn't leak memory in such case. */
834 /* cdeque_size() is a fast operation, so we can use it as a loop
836 while(cdeque_size(d) > 0) {
837 struct filter_info* f = NULL;
839 /* Pop_front will also decrease the collection's size. */
840 if (CDE_OK == cdeque_pop_front(d, cdeque_filter_p(&f)))
846 /* Also clear out the variables needed for sanity checking. */
847 rar->cstate.last_block_start = 0;
848 rar->cstate.last_block_length = 0;
851 static void reset_file_context(struct rar5* rar) {
852 memset(&rar->file, 0, sizeof(rar->file));
853 blake2sp_init(&rar->file.b2state, 32);
855 if(rar->main.solid) {
856 rar->cstate.solid_offset += rar->cstate.write_ptr;
858 rar->cstate.solid_offset = 0;
861 rar->cstate.write_ptr = 0;
862 rar->cstate.last_write_ptr = 0;
863 rar->cstate.last_unstore_ptr = 0;
865 rar->file.redir_type = REDIR_TYPE_NONE;
866 rar->file.redir_flags = 0;
871 static inline int get_archive_read(struct archive* a,
872 struct archive_read** ar)
874 *ar = (struct archive_read*) a;
875 archive_check_magic(a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
876 "archive_read_support_format_rar5");
881 static int read_ahead(struct archive_read* a, size_t how_many,
888 *ptr = __archive_read_ahead(a, how_many, &avail);
896 static int consume(struct archive_read* a, int64_t how_many) {
899 ret = how_many == __archive_read_consume(a, how_many)
907 * Read a RAR5 variable sized numeric value. This value will be stored in
908 * `pvalue`. The `pvalue_len` argument points to a variable that will receive
909 * the byte count that was consumed in order to decode the `pvalue` value, plus
912 * pvalue_len is optional and can be NULL.
914 * NOTE: if `pvalue_len` is NOT NULL, the caller needs to manually consume
915 * the number of bytes that `pvalue_len` value contains. If the `pvalue_len`
916 * is NULL, this consuming operation is done automatically.
918 * Returns 1 if *pvalue was successfully read.
919 * Returns 0 if there was an error. In this case, *pvalue contains an
923 static int read_var(struct archive_read* a, uint64_t* pvalue,
924 uint64_t* pvalue_len)
931 /* We will read maximum of 8 bytes. We don't have to handle the
932 * situation to read the RAR5 variable-sized value stored at the end of
933 * the file, because such situation will never happen. */
934 if(!read_ahead(a, 8, &p))
937 for(shift = 0, i = 0; i < 8; i++, shift += 7) {
940 /* Strip the MSB from the input byte and add the resulting
941 * number to the `result`. */
942 result += (b & (uint64_t)0x7F) << shift;
944 /* MSB set to 1 means we need to continue decoding process.
945 * MSB set to 0 means we're done.
947 * This conditional checks for the second case. */
948 if((b & 0x80) == 0) {
953 /* If the caller has passed the `pvalue_len` pointer,
954 * store the number of consumed bytes in it and do NOT
955 * consume those bytes, since the caller has all the
956 * information it needs to perform */
960 /* If the caller did not provide the
961 * `pvalue_len` pointer, it will not have the
962 * possibility to advance the file pointer,
963 * because it will not know how many bytes it
964 * needs to consume. This is why we handle
965 * such situation here automatically. */
966 if(ARCHIVE_OK != consume(a, 1 + i)) {
971 /* End of decoding process, return success. */
976 /* The decoded value takes the maximum number of 8 bytes.
977 * It's a maximum number of bytes, so end decoding process here
978 * even if the first bit of last byte is 1. */
986 if(ARCHIVE_OK != consume(a, 9)) {
994 static int read_var_sized(struct archive_read* a, size_t* pvalue,
1000 const int ret = pvalue_len ? read_var(a, &v, &v_size)
1001 : read_var(a, &v, NULL);
1003 if(ret == 1 && pvalue) {
1004 *pvalue = (size_t) v;
1008 /* Possible data truncation should be safe. */
1009 *pvalue_len = (size_t) v_size;
1015 static int read_bits_32(struct rar5* rar, const uint8_t* p, uint32_t* value) {
1016 uint32_t bits = ((uint32_t) p[rar->bits.in_addr]) << 24;
1017 bits |= p[rar->bits.in_addr + 1] << 16;
1018 bits |= p[rar->bits.in_addr + 2] << 8;
1019 bits |= p[rar->bits.in_addr + 3];
1020 bits <<= rar->bits.bit_addr;
1021 bits |= p[rar->bits.in_addr + 4] >> (8 - rar->bits.bit_addr);
1026 static int read_bits_16(struct rar5* rar, const uint8_t* p, uint16_t* value) {
1027 int bits = (int) ((uint32_t) p[rar->bits.in_addr]) << 16;
1028 bits |= (int) p[rar->bits.in_addr + 1] << 8;
1029 bits |= (int) p[rar->bits.in_addr + 2];
1030 bits >>= (8 - rar->bits.bit_addr);
1031 *value = bits & 0xffff;
1035 static void skip_bits(struct rar5* rar, int bits) {
1036 const int new_bits = rar->bits.bit_addr + bits;
1037 rar->bits.in_addr += new_bits >> 3;
1038 rar->bits.bit_addr = new_bits & 7;
1042 static int read_consume_bits(struct rar5* rar, const uint8_t* p, int n,
1048 if(n == 0 || n > 16) {
1049 /* This is a programmer error and should never happen
1051 return ARCHIVE_FATAL;
1054 ret = read_bits_16(rar, p, &v);
1055 if(ret != ARCHIVE_OK)
1069 static int read_u32(struct archive_read* a, uint32_t* pvalue) {
1071 if(!read_ahead(a, 4, &p))
1074 *pvalue = archive_le32dec(p);
1075 return ARCHIVE_OK == consume(a, 4) ? 1 : 0;
1078 static int read_u64(struct archive_read* a, uint64_t* pvalue) {
1080 if(!read_ahead(a, 8, &p))
1083 *pvalue = archive_le64dec(p);
1084 return ARCHIVE_OK == consume(a, 8) ? 1 : 0;
1087 static int bid_standard(struct archive_read* a) {
1090 if(!read_ahead(a, rar5_signature_size, &p))
1093 if(!memcmp(rar5_signature, p, rar5_signature_size))
1099 static int rar5_bid(struct archive_read* a, int best_bid) {
1105 my_bid = bid_standard(a);
1113 static int rar5_options(struct archive_read *a, const char *key,
1119 /* No options supported in this version. Return the ARCHIVE_WARN code
1120 * to signal the options supervisor that the unpacker didn't handle
1121 * setting this option. */
1123 return ARCHIVE_WARN;
1126 static void init_header(struct archive_read* a) {
1127 a->archive.archive_format = ARCHIVE_FORMAT_RAR_V5;
1128 a->archive.archive_format_name = "RAR5";
1131 static void init_window_mask(struct rar5* rar) {
1132 if (rar->cstate.window_size)
1133 rar->cstate.window_mask = rar->cstate.window_size - 1;
1135 rar->cstate.window_mask = 0;
1139 HFL_EXTRA_DATA = 0x0001,
1141 HFL_SKIP_IF_UNKNOWN = 0x0004,
1142 HFL_SPLIT_BEFORE = 0x0008,
1143 HFL_SPLIT_AFTER = 0x0010,
1145 HFL_INHERITED = 0x0040
1148 static int process_main_locator_extra_block(struct archive_read* a,
1151 uint64_t locator_flags;
1153 if(!read_var(a, &locator_flags, NULL)) {
1157 enum LOCATOR_FLAGS {
1158 QLIST = 0x01, RECOVERY = 0x02,
1161 if(locator_flags & QLIST) {
1162 if(!read_var(a, &rar->qlist_offset, NULL)) {
1166 /* qlist is not used */
1169 if(locator_flags & RECOVERY) {
1170 if(!read_var(a, &rar->rr_offset, NULL)) {
1174 /* rr is not used */
1180 static int parse_file_extra_hash(struct archive_read* a, struct rar5* rar,
1181 ssize_t* extra_data_size)
1183 size_t hash_type = 0;
1186 if(!read_var_sized(a, &hash_type, &value_len))
1189 *extra_data_size -= value_len;
1190 if(ARCHIVE_OK != consume(a, value_len)) {
1198 /* The file uses BLAKE2sp checksum algorithm instead of plain old
1200 if(hash_type == BLAKE2sp) {
1202 const int hash_size = sizeof(rar->file.blake2sp);
1204 if(!read_ahead(a, hash_size, &p))
1207 rar->file.has_blake2 = 1;
1208 memcpy(&rar->file.blake2sp, p, hash_size);
1210 if(ARCHIVE_OK != consume(a, hash_size)) {
1214 *extra_data_size -= hash_size;
1216 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1217 "Unsupported hash type (0x%x)", (int) hash_type);
1218 return ARCHIVE_FATAL;
1224 static uint64_t time_win_to_unix(uint64_t win_time) {
1225 const size_t ns_in_sec = 10000000;
1226 const uint64_t sec_to_unix = 11644473600LL;
1227 return win_time / ns_in_sec - sec_to_unix;
1230 static int parse_htime_item(struct archive_read* a, char unix_time,
1231 uint64_t* where, ssize_t* extra_data_size)
1235 if(!read_u32(a, &time_val))
1238 *extra_data_size -= 4;
1239 *where = (uint64_t) time_val;
1241 uint64_t windows_time;
1242 if(!read_u64(a, &windows_time))
1245 *where = time_win_to_unix(windows_time);
1246 *extra_data_size -= 8;
1252 static int parse_file_extra_version(struct archive_read* a,
1253 struct archive_entry* e, ssize_t* extra_data_size)
1257 size_t value_len = 0;
1258 struct archive_string version_string;
1259 struct archive_string name_utf8_string;
1261 /* Flags are ignored. */
1262 if(!read_var_sized(a, &flags, &value_len))
1265 *extra_data_size -= value_len;
1266 if(ARCHIVE_OK != consume(a, value_len))
1269 if(!read_var_sized(a, &version, &value_len))
1272 *extra_data_size -= value_len;
1273 if(ARCHIVE_OK != consume(a, value_len))
1276 /* extra_data_size should be zero here. */
1278 const char* cur_filename = archive_entry_pathname_utf8(e);
1279 if(cur_filename == NULL) {
1280 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
1281 "Version entry without file name");
1282 return ARCHIVE_FATAL;
1285 archive_string_init(&version_string);
1286 archive_string_init(&name_utf8_string);
1288 /* Prepare a ;123 suffix for the filename, where '123' is the version
1289 * value of this file. */
1290 archive_string_sprintf(&version_string, ";%zu", version);
1292 /* Build the new filename. */
1293 archive_strcat(&name_utf8_string, cur_filename);
1294 archive_strcat(&name_utf8_string, version_string.s);
1296 /* Apply the new filename into this file's context. */
1297 archive_entry_update_pathname_utf8(e, name_utf8_string.s);
1300 archive_string_free(&version_string);
1301 archive_string_free(&name_utf8_string);
1305 static int parse_file_extra_htime(struct archive_read* a,
1306 struct archive_entry* e, struct rar5* rar, ssize_t* extra_data_size)
1320 if(!read_var_sized(a, &flags, &value_len))
1323 *extra_data_size -= value_len;
1324 if(ARCHIVE_OK != consume(a, value_len)) {
1328 unix_time = flags & IS_UNIX;
1330 if(flags & HAS_MTIME) {
1331 parse_htime_item(a, unix_time, &rar->file.e_mtime,
1333 archive_entry_set_mtime(e, rar->file.e_mtime, 0);
1336 if(flags & HAS_CTIME) {
1337 parse_htime_item(a, unix_time, &rar->file.e_ctime,
1339 archive_entry_set_ctime(e, rar->file.e_ctime, 0);
1342 if(flags & HAS_ATIME) {
1343 parse_htime_item(a, unix_time, &rar->file.e_atime,
1345 archive_entry_set_atime(e, rar->file.e_atime, 0);
1348 if(flags & HAS_UNIX_NS) {
1349 if(!read_u32(a, &rar->file.e_unix_ns))
1352 *extra_data_size -= 4;
1358 static int parse_file_extra_redir(struct archive_read* a,
1359 struct archive_entry* e, struct rar5* rar, ssize_t* extra_data_size)
1361 uint64_t value_size = 0;
1362 size_t target_size = 0;
1363 char target_utf8_buf[MAX_NAME_IN_BYTES];
1366 if(!read_var(a, &rar->file.redir_type, &value_size))
1368 if(ARCHIVE_OK != consume(a, (int64_t)value_size))
1370 *extra_data_size -= value_size;
1372 if(!read_var(a, &rar->file.redir_flags, &value_size))
1374 if(ARCHIVE_OK != consume(a, (int64_t)value_size))
1376 *extra_data_size -= value_size;
1378 if(!read_var_sized(a, &target_size, NULL))
1380 *extra_data_size -= target_size + 1;
1382 if(!read_ahead(a, target_size, &p))
1385 if(target_size > (MAX_NAME_IN_CHARS - 1)) {
1386 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1387 "Link target is too long");
1388 return ARCHIVE_FATAL;
1391 if(target_size == 0) {
1392 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1393 "No link target specified");
1394 return ARCHIVE_FATAL;
1397 memcpy(target_utf8_buf, p, target_size);
1398 target_utf8_buf[target_size] = 0;
1400 if(ARCHIVE_OK != consume(a, (int64_t)target_size))
1403 switch(rar->file.redir_type) {
1404 case REDIR_TYPE_UNIXSYMLINK:
1405 case REDIR_TYPE_WINSYMLINK:
1406 archive_entry_set_filetype(e, AE_IFLNK);
1407 archive_entry_update_symlink_utf8(e, target_utf8_buf);
1408 if (rar->file.redir_flags & REDIR_SYMLINK_IS_DIR) {
1409 archive_entry_set_symlink_type(e,
1410 AE_SYMLINK_TYPE_DIRECTORY);
1412 archive_entry_set_symlink_type(e,
1413 AE_SYMLINK_TYPE_FILE);
1417 case REDIR_TYPE_HARDLINK:
1418 archive_entry_set_filetype(e, AE_IFREG);
1419 archive_entry_update_hardlink_utf8(e, target_utf8_buf);
1423 /* Unknown redir type, skip it. */
1429 static int parse_file_extra_owner(struct archive_read* a,
1430 struct archive_entry* e, ssize_t* extra_data_size)
1433 uint64_t value_size = 0;
1435 size_t name_len = 0;
1436 size_t name_size = 0;
1437 char namebuf[OWNER_MAXNAMELEN];
1440 if(!read_var(a, &flags, &value_size))
1442 if(ARCHIVE_OK != consume(a, (int64_t)value_size))
1444 *extra_data_size -= value_size;
1446 if ((flags & OWNER_USER_NAME) != 0) {
1447 if(!read_var_sized(a, &name_size, NULL))
1449 *extra_data_size -= name_size + 1;
1451 if(!read_ahead(a, name_size, &p))
1454 if (name_size >= OWNER_MAXNAMELEN) {
1455 name_len = OWNER_MAXNAMELEN - 1;
1457 name_len = name_size;
1460 memcpy(namebuf, p, name_len);
1461 namebuf[name_len] = 0;
1462 if(ARCHIVE_OK != consume(a, (int64_t)name_size))
1465 archive_entry_set_uname(e, namebuf);
1467 if ((flags & OWNER_GROUP_NAME) != 0) {
1468 if(!read_var_sized(a, &name_size, NULL))
1470 *extra_data_size -= name_size + 1;
1472 if(!read_ahead(a, name_size, &p))
1475 if (name_size >= OWNER_MAXNAMELEN) {
1476 name_len = OWNER_MAXNAMELEN - 1;
1478 name_len = name_size;
1481 memcpy(namebuf, p, name_len);
1482 namebuf[name_len] = 0;
1483 if(ARCHIVE_OK != consume(a, (int64_t)name_size))
1486 archive_entry_set_gname(e, namebuf);
1488 if ((flags & OWNER_USER_UID) != 0) {
1489 if(!read_var(a, &id, &value_size))
1491 if(ARCHIVE_OK != consume(a, (int64_t)value_size))
1493 *extra_data_size -= value_size;
1495 archive_entry_set_uid(e, (la_int64_t)id);
1497 if ((flags & OWNER_GROUP_GID) != 0) {
1498 if(!read_var(a, &id, &value_size))
1500 if(ARCHIVE_OK != consume(a, (int64_t)value_size))
1502 *extra_data_size -= value_size;
1504 archive_entry_set_gid(e, (la_int64_t)id);
1509 static int process_head_file_extra(struct archive_read* a,
1510 struct archive_entry* e, struct rar5* rar, ssize_t extra_data_size)
1512 size_t extra_field_size;
1513 size_t extra_field_id = 0;
1514 int ret = ARCHIVE_FATAL;
1517 while(extra_data_size > 0) {
1518 if(!read_var_sized(a, &extra_field_size, &var_size))
1521 extra_data_size -= var_size;
1522 if(ARCHIVE_OK != consume(a, var_size)) {
1526 if(!read_var_sized(a, &extra_field_id, &var_size))
1529 extra_data_size -= var_size;
1530 if(ARCHIVE_OK != consume(a, var_size)) {
1534 switch(extra_field_id) {
1536 ret = parse_file_extra_hash(a, rar,
1540 ret = parse_file_extra_htime(a, e, rar,
1544 ret = parse_file_extra_redir(a, e, rar,
1548 ret = parse_file_extra_owner(a, e,
1552 ret = parse_file_extra_version(a, e,
1560 /* Skip unsupported entry. */
1561 return consume(a, extra_data_size);
1565 if(ret != ARCHIVE_OK) {
1566 /* Attribute not implemented. */
1573 static int process_head_file(struct archive_read* a, struct rar5* rar,
1574 struct archive_entry* entry, size_t block_flags)
1576 ssize_t extra_data_size = 0;
1577 size_t data_size = 0;
1578 size_t file_flags = 0;
1579 size_t file_attr = 0;
1580 size_t compression_info = 0;
1582 size_t name_size = 0;
1583 uint64_t unpacked_size, window_size;
1584 uint32_t mtime = 0, crc = 0;
1585 int c_method = 0, c_version = 0;
1586 char name_utf8_buf[MAX_NAME_IN_BYTES];
1589 archive_entry_clear(entry);
1591 /* Do not reset file context if we're switching archives. */
1592 if(!rar->cstate.switch_multivolume) {
1593 reset_file_context(rar);
1596 if(block_flags & HFL_EXTRA_DATA) {
1597 size_t edata_size = 0;
1598 if(!read_var_sized(a, &edata_size, NULL))
1601 /* Intentional type cast from unsigned to signed. */
1602 extra_data_size = (ssize_t) edata_size;
1605 if(block_flags & HFL_DATA) {
1606 if(!read_var_sized(a, &data_size, NULL))
1609 rar->file.bytes_remaining = data_size;
1611 rar->file.bytes_remaining = 0;
1613 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1614 "no data found in file/service block");
1615 return ARCHIVE_FATAL;
1619 DIRECTORY = 0x0001, UTIME = 0x0002, CRC32 = 0x0004,
1620 UNKNOWN_UNPACKED_SIZE = 0x0008,
1624 ATTR_READONLY = 0x1, ATTR_HIDDEN = 0x2, ATTR_SYSTEM = 0x4,
1625 ATTR_DIRECTORY = 0x10,
1628 enum COMP_INFO_FLAGS {
1632 if(!read_var_sized(a, &file_flags, NULL))
1635 if(!read_var(a, &unpacked_size, NULL))
1638 if(file_flags & UNKNOWN_UNPACKED_SIZE) {
1639 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
1640 "Files with unknown unpacked size are not supported");
1641 return ARCHIVE_FATAL;
1644 rar->file.dir = (uint8_t) ((file_flags & DIRECTORY) > 0);
1646 if(!read_var_sized(a, &file_attr, NULL))
1649 if(file_flags & UTIME) {
1650 if(!read_u32(a, &mtime))
1654 if(file_flags & CRC32) {
1655 if(!read_u32(a, &crc))
1659 if(!read_var_sized(a, &compression_info, NULL))
1662 c_method = (int) (compression_info >> 7) & 0x7;
1663 c_version = (int) (compression_info & 0x3f);
1665 /* RAR5 seems to limit the dictionary size to 64MB. */
1666 window_size = (rar->file.dir > 0) ?
1668 g_unpack_window_size << ((compression_info >> 10) & 15);
1669 rar->cstate.method = c_method;
1670 rar->cstate.version = c_version + 50;
1671 rar->file.solid = (compression_info & SOLID) > 0;
1673 /* Archives which declare solid files without initializing the window
1674 * buffer first are invalid. */
1676 if(rar->file.solid > 0 && rar->cstate.window_buf == NULL) {
1677 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1678 "Declared solid file, but no window buffer "
1679 "initialized yet.");
1680 return ARCHIVE_FATAL;
1683 /* Check if window_size is a sane value. Also, if the file is not
1684 * declared as a directory, disallow window_size == 0. */
1685 if(window_size > (64 * 1024 * 1024) ||
1686 (rar->file.dir == 0 && window_size == 0))
1688 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1689 "Declared dictionary size is not supported.");
1690 return ARCHIVE_FATAL;
1693 if(rar->file.solid > 0) {
1694 /* Re-check if current window size is the same as previous
1695 * window size (for solid files only). */
1696 if(rar->file.solid_window_size > 0 &&
1697 rar->file.solid_window_size != (ssize_t) window_size)
1699 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1700 "Window size for this solid file doesn't match "
1701 "the window size used in previous solid file. ");
1702 return ARCHIVE_FATAL;
1706 /* If we're currently switching volumes, ignore the new definition of
1708 if(rar->cstate.switch_multivolume == 0) {
1709 /* Values up to 64M should fit into ssize_t on every
1711 rar->cstate.window_size = (ssize_t) window_size;
1714 if(rar->file.solid > 0 && rar->file.solid_window_size == 0) {
1715 /* Solid files have to have the same window_size across
1716 whole archive. Remember the window_size parameter
1717 for first solid file found. */
1718 rar->file.solid_window_size = rar->cstate.window_size;
1721 init_window_mask(rar);
1723 rar->file.service = 0;
1725 if(!read_var_sized(a, &host_os, NULL))
1733 if(host_os == HOST_WINDOWS) {
1734 /* Host OS is Windows */
1738 if(file_attr & ATTR_DIRECTORY) {
1739 if (file_attr & ATTR_READONLY) {
1740 mode = 0555 | AE_IFDIR;
1742 mode = 0755 | AE_IFDIR;
1745 if (file_attr & ATTR_READONLY) {
1746 mode = 0444 | AE_IFREG;
1748 mode = 0644 | AE_IFREG;
1752 archive_entry_set_mode(entry, mode);
1754 if (file_attr & (ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM)) {
1755 char *fflags_text, *ptr;
1756 /* allocate for "rdonly,hidden,system," */
1757 fflags_text = malloc(22 * sizeof(char));
1758 if (fflags_text != NULL) {
1760 if (file_attr & ATTR_READONLY) {
1761 strcpy(ptr, "rdonly,");
1764 if (file_attr & ATTR_HIDDEN) {
1765 strcpy(ptr, "hidden,");
1768 if (file_attr & ATTR_SYSTEM) {
1769 strcpy(ptr, "system,");
1772 if (ptr > fflags_text) {
1773 /* Delete trailing comma */
1775 archive_entry_copy_fflags_text(entry,
1781 } else if(host_os == HOST_UNIX) {
1782 /* Host OS is Unix */
1783 archive_entry_set_mode(entry, (__LA_MODE_T) file_attr);
1785 /* Unknown host OS */
1786 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1787 "Unsupported Host OS: 0x%x", (int) host_os);
1789 return ARCHIVE_FATAL;
1792 if(!read_var_sized(a, &name_size, NULL))
1795 if(!read_ahead(a, name_size, &p))
1798 if(name_size > (MAX_NAME_IN_CHARS - 1)) {
1799 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1800 "Filename is too long");
1802 return ARCHIVE_FATAL;
1805 if(name_size == 0) {
1806 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1807 "No filename specified");
1809 return ARCHIVE_FATAL;
1812 memcpy(name_utf8_buf, p, name_size);
1813 name_utf8_buf[name_size] = 0;
1814 if(ARCHIVE_OK != consume(a, name_size)) {
1818 archive_entry_update_pathname_utf8(entry, name_utf8_buf);
1820 if(extra_data_size > 0) {
1821 int ret = process_head_file_extra(a, entry, rar,
1825 if(extra_data_size < 0) {
1826 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
1827 "File extra data size is not zero");
1828 return ARCHIVE_FATAL;
1831 if(ret != ARCHIVE_OK)
1835 if((file_flags & UNKNOWN_UNPACKED_SIZE) == 0) {
1836 rar->file.unpacked_size = (ssize_t) unpacked_size;
1837 if(rar->file.redir_type == REDIR_TYPE_NONE)
1838 archive_entry_set_size(entry, unpacked_size);
1841 if(file_flags & UTIME) {
1842 archive_entry_set_mtime(entry, (time_t) mtime, 0);
1845 if(file_flags & CRC32) {
1846 rar->file.stored_crc32 = crc;
1849 if(!rar->cstate.switch_multivolume) {
1850 /* Do not reinitialize unpacking state if we're switching
1852 rar->cstate.block_parsing_finished = 1;
1853 rar->cstate.all_filters_applied = 1;
1854 rar->cstate.initialized = 0;
1857 if(rar->generic.split_before > 0) {
1858 /* If now we're standing on a header that has a 'split before'
1859 * mark, it means we're standing on a 'continuation' file
1860 * header. Signal the caller that if it wants to move to
1861 * another file, it must call rar5_read_header() function
1864 return ARCHIVE_RETRY;
1870 static int process_head_service(struct archive_read* a, struct rar5* rar,
1871 struct archive_entry* entry, size_t block_flags)
1873 /* Process this SERVICE block the same way as FILE blocks. */
1874 int ret = process_head_file(a, rar, entry, block_flags);
1875 if(ret != ARCHIVE_OK)
1878 rar->file.service = 1;
1880 /* But skip the data part automatically. It's no use for the user
1881 * anyway. It contains only service data, not even needed to
1882 * properly unpack the file. */
1883 ret = rar5_read_data_skip(a);
1884 if(ret != ARCHIVE_OK)
1887 /* After skipping, try parsing another block automatically. */
1888 return ARCHIVE_RETRY;
1891 static int process_head_main(struct archive_read* a, struct rar5* rar,
1892 struct archive_entry* entry, size_t block_flags)
1897 size_t extra_data_size = 0;
1898 size_t extra_field_size = 0;
1899 size_t extra_field_id = 0;
1900 size_t archive_flags = 0;
1902 if(block_flags & HFL_EXTRA_DATA) {
1903 if(!read_var_sized(a, &extra_data_size, NULL))
1906 extra_data_size = 0;
1909 if(!read_var_sized(a, &archive_flags, NULL)) {
1914 VOLUME = 0x0001, /* multi-volume archive */
1915 VOLUME_NUMBER = 0x0002, /* volume number, first vol doesn't
1917 SOLID = 0x0004, /* solid archive */
1918 PROTECT = 0x0008, /* contains Recovery info */
1919 LOCK = 0x0010, /* readonly flag, not used */
1922 rar->main.volume = (archive_flags & VOLUME) > 0;
1923 rar->main.solid = (archive_flags & SOLID) > 0;
1925 if(archive_flags & VOLUME_NUMBER) {
1927 if(!read_var_sized(a, &v, NULL)) {
1932 archive_set_error(&a->archive,
1933 ARCHIVE_ERRNO_FILE_FORMAT,
1934 "Invalid volume number");
1935 return ARCHIVE_FATAL;
1938 rar->main.vol_no = (unsigned int) v;
1940 rar->main.vol_no = 0;
1943 if(rar->vol.expected_vol_no > 0 &&
1944 rar->main.vol_no != rar->vol.expected_vol_no)
1946 /* Returning EOF instead of FATAL because of strange
1947 * libarchive behavior. When opening multiple files via
1948 * archive_read_open_filenames(), after reading up the whole
1949 * last file, the __archive_read_ahead function wraps up to
1950 * the first archive instead of returning EOF. */
1954 if(extra_data_size == 0) {
1959 if(!read_var_sized(a, &extra_field_size, NULL)) {
1963 if(!read_var_sized(a, &extra_field_id, NULL)) {
1967 if(extra_field_size == 0) {
1968 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1969 "Invalid extra field size");
1970 return ARCHIVE_FATAL;
1974 // Just one attribute here.
1978 switch(extra_field_id) {
1980 ret = process_main_locator_extra_block(a, rar);
1981 if(ret != ARCHIVE_OK) {
1982 /* Error while parsing main locator extra
1989 archive_set_error(&a->archive,
1990 ARCHIVE_ERRNO_FILE_FORMAT,
1991 "Unsupported extra type (0x%x)",
1992 (int) extra_field_id);
1993 return ARCHIVE_FATAL;
1999 static int skip_unprocessed_bytes(struct archive_read* a) {
2000 struct rar5* rar = get_context(a);
2003 if(rar->file.bytes_remaining) {
2004 /* Use different skipping method in block merging mode than in
2005 * normal mode. If merge mode is active, rar5_read_data_skip
2006 * can't be used, because it could allow recursive use of
2007 * merge_block() * function, and this function doesn't support
2009 if(rar->merge_mode) {
2010 /* Discard whole merged block. This is valid in solid
2011 * mode as well, because the code will discard blocks
2012 * only if those blocks are safe to discard (i.e.
2013 * they're not FILE blocks). */
2014 ret = consume(a, rar->file.bytes_remaining);
2015 if(ret != ARCHIVE_OK) {
2018 rar->file.bytes_remaining = 0;
2020 /* If we're not in merge mode, use safe skipping code.
2021 * This will ensure we'll handle solid archives
2023 ret = rar5_read_data_skip(a);
2024 if(ret != ARCHIVE_OK) {
2033 static int scan_for_signature(struct archive_read* a);
2035 /* Base block processing function. A 'base block' is a RARv5 header block
2036 * that tells the reader what kind of data is stored inside the block.
2038 * From the birds-eye view a RAR file looks file this:
2040 * <magic><base_block_1><base_block_2>...<base_block_n>
2042 * There are a few types of base blocks. Those types are specified inside
2043 * the 'switch' statement in this function. For example purposes, I'll write
2044 * how a standard RARv5 file could look like here:
2046 * <magic><MAIN><FILE><FILE><FILE><SERVICE><ENDARC>
2048 * The structure above could describe an archive file with 3 files in it,
2049 * one service "QuickOpen" block (that is ignored by this parser), and an
2050 * end of file base block marker.
2052 * If the file is stored in multiple archive files ("multiarchive"), it might
2055 * .part01.rar: <magic><MAIN><FILE><ENDARC>
2056 * .part02.rar: <magic><MAIN><FILE><ENDARC>
2057 * .part03.rar: <magic><MAIN><FILE><ENDARC>
2059 * This example could describe 3 RAR files that contain ONE archived file.
2060 * Or it could describe 3 RAR files that contain 3 different files. Or 3
2061 * RAR files than contain 2 files. It all depends what metadata is stored in
2062 * the headers of <FILE> blocks.
2064 * Each <FILE> block contains info about its size, the name of the file it's
2065 * storing inside, and whether this FILE block is a continuation block of
2066 * previous archive ('split before'), and is this FILE block should be
2067 * continued in another archive ('split after'). By parsing the 'split before'
2068 * and 'split after' flags, we're able to tell if multiple <FILE> base blocks
2069 * are describing one file, or multiple files (with the same filename, for
2072 * One thing to note is that if we're parsing the first <FILE> block, and
2073 * we see 'split after' flag, then we need to jump over to another <FILE>
2074 * block to be able to decompress rest of the data. To do this, we need
2075 * to skip the <ENDARC> block, then switch to another file, then skip the
2076 * <magic> block, <MAIN> block, and then we're standing on the proper
2080 static int process_base_block(struct archive_read* a,
2081 struct archive_entry* entry)
2083 struct rar5* rar = get_context(a);
2084 uint32_t hdr_crc, computed_crc;
2085 size_t raw_hdr_size = 0, hdr_size_len, hdr_size;
2086 size_t header_id = 0;
2087 size_t header_flags = 0;
2091 /* Skip any unprocessed data for this file. */
2092 ret = skip_unprocessed_bytes(a);
2093 if(ret != ARCHIVE_OK)
2096 /* Read the expected CRC32 checksum. */
2097 if(!read_u32(a, &hdr_crc)) {
2101 /* Read header size. */
2102 if(!read_var_sized(a, &raw_hdr_size, &hdr_size_len)) {
2106 /* Sanity check, maximum header size for RAR5 is 2MB. */
2107 if(raw_hdr_size > (2 * 1024 * 1024)) {
2108 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2109 "Base block header is too large");
2111 return ARCHIVE_FATAL;
2114 hdr_size = raw_hdr_size + hdr_size_len;
2116 /* Read the whole header data into memory, maximum memory use here is
2118 if(!read_ahead(a, hdr_size, &p)) {
2122 /* Verify the CRC32 of the header data. */
2123 computed_crc = (uint32_t) crc32(0, p, (int) hdr_size);
2124 if(computed_crc != hdr_crc) {
2125 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2126 "Header CRC error");
2128 return ARCHIVE_FATAL;
2131 /* If the checksum is OK, we proceed with parsing. */
2132 if(ARCHIVE_OK != consume(a, hdr_size_len)) {
2136 if(!read_var_sized(a, &header_id, NULL))
2139 if(!read_var_sized(a, &header_flags, NULL))
2142 rar->generic.split_after = (header_flags & HFL_SPLIT_AFTER) > 0;
2143 rar->generic.split_before = (header_flags & HFL_SPLIT_BEFORE) > 0;
2144 rar->generic.size = (int)hdr_size;
2145 rar->generic.last_header_id = (int)header_id;
2146 rar->main.endarc = 0;
2148 /* Those are possible header ids in RARv5. */
2150 HEAD_MARK = 0x00, HEAD_MAIN = 0x01, HEAD_FILE = 0x02,
2151 HEAD_SERVICE = 0x03, HEAD_CRYPT = 0x04, HEAD_ENDARC = 0x05,
2152 HEAD_UNKNOWN = 0xff,
2157 ret = process_head_main(a, rar, entry, header_flags);
2159 /* Main header doesn't have any files in it, so it's
2160 * pointless to return to the caller. Retry to next
2161 * header, which should be HEAD_FILE/HEAD_SERVICE. */
2162 if(ret == ARCHIVE_OK)
2163 return ARCHIVE_RETRY;
2167 ret = process_head_service(a, rar, entry, header_flags);
2170 ret = process_head_file(a, rar, entry, header_flags);
2173 archive_set_error(&a->archive,
2174 ARCHIVE_ERRNO_FILE_FORMAT,
2175 "Encryption is not supported");
2176 return ARCHIVE_FATAL;
2178 rar->main.endarc = 1;
2180 /* After encountering an end of file marker, we need
2181 * to take into consideration if this archive is
2182 * continued in another file (i.e. is it part01.rar:
2183 * is there a part02.rar?) */
2184 if(rar->main.volume) {
2185 /* In case there is part02.rar, position the
2186 * read pointer in a proper place, so we can
2187 * resume parsing. */
2188 ret = scan_for_signature(a);
2189 if(ret == ARCHIVE_FATAL) {
2192 if(rar->vol.expected_vol_no ==
2194 archive_set_error(&a->archive,
2195 ARCHIVE_ERRNO_FILE_FORMAT,
2197 return ARCHIVE_FATAL;
2200 rar->vol.expected_vol_no =
2201 rar->main.vol_no + 1;
2210 if((header_flags & HFL_SKIP_IF_UNKNOWN) == 0) {
2211 archive_set_error(&a->archive,
2212 ARCHIVE_ERRNO_FILE_FORMAT,
2213 "Header type error");
2214 return ARCHIVE_FATAL;
2216 /* If the block is marked as 'skip if unknown',
2217 * do as the flag says: skip the block
2218 * instead on failing on it. */
2219 return ARCHIVE_RETRY;
2225 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
2226 "Internal unpacker error");
2227 return ARCHIVE_FATAL;
2231 static int skip_base_block(struct archive_read* a) {
2233 struct rar5* rar = get_context(a);
2235 /* Create a new local archive_entry structure that will be operated on
2236 * by header reader; operations on this archive_entry will be discarded.
2238 struct archive_entry* entry = archive_entry_new();
2239 ret = process_base_block(a, entry);
2241 /* Discard operations on this archive_entry structure. */
2242 archive_entry_free(entry);
2243 if(ret == ARCHIVE_FATAL)
2246 if(rar->generic.last_header_id == 2 && rar->generic.split_before > 0)
2249 if(ret == ARCHIVE_OK)
2250 return ARCHIVE_RETRY;
2255 static int rar5_read_header(struct archive_read *a,
2256 struct archive_entry *entry)
2258 struct rar5* rar = get_context(a);
2261 if(rar->header_initialized == 0) {
2263 rar->header_initialized = 1;
2266 if(rar->skipped_magic == 0) {
2267 if(ARCHIVE_OK != consume(a, rar5_signature_size)) {
2271 rar->skipped_magic = 1;
2275 ret = process_base_block(a, entry);
2276 } while(ret == ARCHIVE_RETRY ||
2277 (rar->main.endarc > 0 && ret == ARCHIVE_OK));
2282 static void init_unpack(struct rar5* rar) {
2283 rar->file.calculated_crc32 = 0;
2284 init_window_mask(rar);
2286 free(rar->cstate.window_buf);
2287 free(rar->cstate.filtered_buf);
2289 if(rar->cstate.window_size > 0) {
2290 rar->cstate.window_buf = calloc(1, rar->cstate.window_size);
2291 rar->cstate.filtered_buf = calloc(1, rar->cstate.window_size);
2293 rar->cstate.window_buf = NULL;
2294 rar->cstate.filtered_buf = NULL;
2297 rar->cstate.write_ptr = 0;
2298 rar->cstate.last_write_ptr = 0;
2300 memset(&rar->cstate.bd, 0, sizeof(rar->cstate.bd));
2301 memset(&rar->cstate.ld, 0, sizeof(rar->cstate.ld));
2302 memset(&rar->cstate.dd, 0, sizeof(rar->cstate.dd));
2303 memset(&rar->cstate.ldd, 0, sizeof(rar->cstate.ldd));
2304 memset(&rar->cstate.rd, 0, sizeof(rar->cstate.rd));
2307 static void update_crc(struct rar5* rar, const uint8_t* p, size_t to_read) {
2310 if(rar->skip_mode) {
2311 #if defined CHECK_CRC_ON_SOLID_SKIP
2320 /* Don't update CRC32 if the file doesn't have the
2321 * `stored_crc32` info filled in. */
2322 if(rar->file.stored_crc32 > 0) {
2323 rar->file.calculated_crc32 =
2324 crc32(rar->file.calculated_crc32, p, to_read);
2327 /* Check if the file uses an optional BLAKE2sp checksum
2329 if(rar->file.has_blake2 > 0) {
2330 /* Return value of the `update` function is always 0,
2331 * so we can explicitly ignore it here. */
2332 (void) blake2sp_update(&rar->file.b2state, p, to_read);
2337 static int create_decode_tables(uint8_t* bit_length,
2338 struct decode_table* table, int size)
2340 int code, upper_limit = 0, i, lc[16];
2341 uint32_t decode_pos_clone[rar5_countof(table->decode_pos)];
2342 ssize_t cur_len, quick_data_size;
2344 memset(&lc, 0, sizeof(lc));
2345 memset(table->decode_num, 0, sizeof(table->decode_num));
2347 table->quick_bits = size == HUFF_NC ? 10 : 7;
2349 for(i = 0; i < size; i++) {
2350 lc[bit_length[i] & 15]++;
2354 table->decode_pos[0] = 0;
2355 table->decode_len[0] = 0;
2357 for(i = 1; i < 16; i++) {
2358 upper_limit += lc[i];
2360 table->decode_len[i] = upper_limit << (16 - i);
2361 table->decode_pos[i] = table->decode_pos[i - 1] + lc[i - 1];
2366 memcpy(decode_pos_clone, table->decode_pos, sizeof(decode_pos_clone));
2368 for(i = 0; i < size; i++) {
2369 uint8_t clen = bit_length[i] & 15;
2371 int last_pos = decode_pos_clone[clen];
2372 table->decode_num[last_pos] = i;
2373 decode_pos_clone[clen]++;
2377 quick_data_size = (int64_t)1 << table->quick_bits;
2379 for(code = 0; code < quick_data_size; code++) {
2380 int bit_field = code << (16 - table->quick_bits);
2383 while(cur_len < rar5_countof(table->decode_len) &&
2384 bit_field >= table->decode_len[cur_len]) {
2388 table->quick_len[code] = (uint8_t) cur_len;
2390 dist = bit_field - table->decode_len[cur_len - 1];
2391 dist >>= (16 - cur_len);
2393 pos = table->decode_pos[cur_len & 15] + dist;
2394 if(cur_len < rar5_countof(table->decode_pos) && pos < size) {
2395 table->quick_num[code] = table->decode_num[pos];
2397 table->quick_num[code] = 0;
2404 static int decode_number(struct archive_read* a, struct decode_table* table,
2405 const uint8_t* p, uint16_t* num)
2410 struct rar5* rar = get_context(a);
2412 if(ARCHIVE_OK != read_bits_16(rar, p, &bitfield)) {
2418 if(bitfield < table->decode_len[table->quick_bits]) {
2419 int code = bitfield >> (16 - table->quick_bits);
2420 skip_bits(rar, table->quick_len[code]);
2421 *num = table->quick_num[code];
2427 for(i = table->quick_bits + 1; i < 15; i++) {
2428 if(bitfield < table->decode_len[i]) {
2434 skip_bits(rar, bits);
2436 dist = bitfield - table->decode_len[bits - 1];
2437 dist >>= (16 - bits);
2438 pos = table->decode_pos[bits] + dist;
2440 if(pos >= table->size)
2443 *num = table->decode_num[pos];
2447 /* Reads and parses Huffman tables from the beginning of the block. */
2448 static int parse_tables(struct archive_read* a, struct rar5* rar,
2451 int ret, value, i, w, idx = 0;
2452 uint8_t bit_length[HUFF_BC],
2453 table[HUFF_TABLE_SIZE],
2457 enum { ESCAPE = 15 };
2459 /* The data for table generation is compressed using a simple RLE-like
2460 * algorithm when storing zeroes, so we need to unpack it first. */
2461 for(w = 0, i = 0; w < HUFF_BC;) {
2462 if(i >= rar->cstate.cur_block_size) {
2463 /* Truncated data, can't continue. */
2464 archive_set_error(&a->archive,
2465 ARCHIVE_ERRNO_FILE_FORMAT,
2466 "Truncated data in huffman tables");
2467 return ARCHIVE_FATAL;
2470 value = (p[i] & nibble_mask) >> nibble_shift;
2472 if(nibble_mask == 0x0F)
2475 nibble_mask ^= 0xFF;
2478 /* Values smaller than 15 is data, so we write it directly.
2479 * Value 15 is a flag telling us that we need to unpack more
2481 if(value == ESCAPE) {
2482 value = (p[i] & nibble_mask) >> nibble_shift;
2483 if(nibble_mask == 0x0F)
2485 nibble_mask ^= 0xFF;
2489 /* We sometimes need to write the actual value
2490 * of 15, so this case handles that. */
2491 bit_length[w++] = ESCAPE;
2496 for(k = 0; (k < value + 2) && (w < HUFF_BC);
2498 bit_length[w++] = 0;
2502 bit_length[w++] = value;
2506 rar->bits.in_addr = i;
2507 rar->bits.bit_addr = nibble_shift ^ 4;
2509 ret = create_decode_tables(bit_length, &rar->cstate.bd, HUFF_BC);
2510 if(ret != ARCHIVE_OK) {
2511 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2512 "Decoding huffman tables failed");
2513 return ARCHIVE_FATAL;
2516 for(i = 0; i < HUFF_TABLE_SIZE;) {
2519 if((rar->bits.in_addr + 6) >= rar->cstate.cur_block_size) {
2520 /* Truncated data, can't continue. */
2521 archive_set_error(&a->archive,
2522 ARCHIVE_ERRNO_FILE_FORMAT,
2523 "Truncated data in huffman tables (#2)");
2524 return ARCHIVE_FATAL;
2527 ret = decode_number(a, &rar->cstate.bd, p, &num);
2528 if(ret != ARCHIVE_OK) {
2529 archive_set_error(&a->archive,
2530 ARCHIVE_ERRNO_FILE_FORMAT,
2531 "Decoding huffman tables failed");
2532 return ARCHIVE_FATAL;
2536 /* 0..15: store directly */
2537 table[i] = (uint8_t) num;
2543 /* 16..17: repeat previous code */
2545 if(ARCHIVE_OK != read_bits_16(rar, p, &n))
2559 while(n-- > 0 && i < HUFF_TABLE_SIZE) {
2560 table[i] = table[i - 1];
2564 archive_set_error(&a->archive,
2565 ARCHIVE_ERRNO_FILE_FORMAT,
2566 "Unexpected error when decoding "
2568 return ARCHIVE_FATAL;
2574 /* other codes: fill with zeroes `n` times */
2576 if(ARCHIVE_OK != read_bits_16(rar, p, &n))
2589 while(n-- > 0 && i < HUFF_TABLE_SIZE)
2593 ret = create_decode_tables(&table[idx], &rar->cstate.ld, HUFF_NC);
2594 if(ret != ARCHIVE_OK) {
2595 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2596 "Failed to create literal table");
2597 return ARCHIVE_FATAL;
2602 ret = create_decode_tables(&table[idx], &rar->cstate.dd, HUFF_DC);
2603 if(ret != ARCHIVE_OK) {
2604 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2605 "Failed to create distance table");
2606 return ARCHIVE_FATAL;
2611 ret = create_decode_tables(&table[idx], &rar->cstate.ldd, HUFF_LDC);
2612 if(ret != ARCHIVE_OK) {
2613 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2614 "Failed to create lower bits of distances table");
2615 return ARCHIVE_FATAL;
2620 ret = create_decode_tables(&table[idx], &rar->cstate.rd, HUFF_RC);
2621 if(ret != ARCHIVE_OK) {
2622 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2623 "Failed to create repeating distances table");
2624 return ARCHIVE_FATAL;
2630 /* Parses the block header, verifies its CRC byte, and saves the header
2631 * fields inside the `hdr` pointer. */
2632 static int parse_block_header(struct archive_read* a, const uint8_t* p,
2633 ssize_t* block_size, struct compressed_block_header* hdr)
2635 memcpy(hdr, p, sizeof(struct compressed_block_header));
2637 if(bf_byte_count(hdr) > 2) {
2638 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2639 "Unsupported block header size (was %d, max is 2)",
2640 bf_byte_count(hdr));
2641 return ARCHIVE_FATAL;
2644 /* This should probably use bit reader interface in order to be more
2647 switch(bf_byte_count(hdr)) {
2648 /* 1-byte block size */
2650 *block_size = *(const uint8_t*) &p[2];
2653 /* 2-byte block size */
2655 *block_size = archive_le16dec(&p[2]);
2658 /* 3-byte block size */
2660 *block_size = archive_le32dec(&p[2]);
2661 *block_size &= 0x00FFFFFF;
2664 /* Other block sizes are not supported. This case is not
2665 * reached, because we have an 'if' guard before the switch
2666 * that makes sure of it. */
2668 return ARCHIVE_FATAL;
2671 /* Verify the block header checksum. 0x5A is a magic value and is
2672 * always * constant. */
2673 uint8_t calculated_cksum = 0x5A
2674 ^ (uint8_t) hdr->block_flags_u8
2675 ^ (uint8_t) *block_size
2676 ^ (uint8_t) (*block_size >> 8)
2677 ^ (uint8_t) (*block_size >> 16);
2679 if(calculated_cksum != hdr->block_cksum) {
2680 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2681 "Block checksum error: got 0x%x, expected 0x%x",
2682 hdr->block_cksum, calculated_cksum);
2684 return ARCHIVE_FATAL;
2690 /* Convenience function used during filter processing. */
2691 static int parse_filter_data(struct rar5* rar, const uint8_t* p,
2692 uint32_t* filter_data)
2697 if(ARCHIVE_OK != read_consume_bits(rar, p, 2, &bytes))
2702 for(i = 0; i < bytes; i++) {
2705 if(ARCHIVE_OK != read_bits_16(rar, p, &byte)) {
2709 /* Cast to uint32_t will ensure the shift operation will not
2710 * produce undefined result. */
2711 data += ((uint32_t) byte >> 8) << (i * 8);
2715 *filter_data = data;
2719 /* Function is used during sanity checking. */
2720 static int is_valid_filter_block_start(struct rar5* rar,
2723 const int64_t block_start = (ssize_t) start + rar->cstate.write_ptr;
2724 const int64_t last_bs = rar->cstate.last_block_start;
2725 const ssize_t last_bl = rar->cstate.last_block_length;
2727 if(last_bs == 0 || last_bl == 0) {
2728 /* We didn't have any filters yet, so accept this offset. */
2732 if(block_start >= last_bs + last_bl) {
2733 /* Current offset is bigger than last block's end offset, so
2734 * accept current offset. */
2738 /* Any other case is not a normal situation and we should fail. */
2742 /* The function will create a new filter, read its parameters from the input
2743 * stream and add it to the filter collection. */
2744 static int parse_filter(struct archive_read* ar, const uint8_t* p) {
2745 uint32_t block_start, block_length;
2746 uint16_t filter_type;
2747 struct rar5* rar = get_context(ar);
2749 /* Read the parameters from the input stream. */
2750 if(ARCHIVE_OK != parse_filter_data(rar, p, &block_start))
2753 if(ARCHIVE_OK != parse_filter_data(rar, p, &block_length))
2756 if(ARCHIVE_OK != read_bits_16(rar, p, &filter_type))
2762 /* Perform some sanity checks on this filter parameters. Note that we
2763 * allow only DELTA, E8/E9 and ARM filters here, because rest of
2764 * filters are not used in RARv5. */
2766 if(block_length < 4 ||
2767 block_length > 0x400000 ||
2768 filter_type > FILTER_ARM ||
2769 !is_valid_filter_block_start(rar, block_start))
2771 archive_set_error(&ar->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2772 "Invalid filter encountered");
2773 return ARCHIVE_FATAL;
2776 /* Allocate a new filter. */
2777 struct filter_info* filt = add_new_filter(rar);
2779 archive_set_error(&ar->archive, ENOMEM,
2780 "Can't allocate memory for a filter descriptor.");
2781 return ARCHIVE_FATAL;
2784 filt->type = filter_type;
2785 filt->block_start = rar->cstate.write_ptr + block_start;
2786 filt->block_length = block_length;
2788 rar->cstate.last_block_start = filt->block_start;
2789 rar->cstate.last_block_length = filt->block_length;
2791 /* Read some more data in case this is a DELTA filter. Other filter
2792 * types don't require any additional data over what was already
2794 if(filter_type == FILTER_DELTA) {
2797 if(ARCHIVE_OK != read_consume_bits(rar, p, 5, &channels))
2800 filt->channels = channels + 1;
2806 static int decode_code_length(struct rar5* rar, const uint8_t* p,
2809 int lbits, length = 2;
2814 lbits = code / 4 - 1;
2815 length += (4 | (code & 3)) << lbits;
2821 if(ARCHIVE_OK != read_consume_bits(rar, p, lbits, &add))
2830 static int copy_string(struct archive_read* a, int len, int dist) {
2831 struct rar5* rar = get_context(a);
2832 const uint64_t cmask = rar->cstate.window_mask;
2833 const uint64_t write_ptr = rar->cstate.write_ptr +
2834 rar->cstate.solid_offset;
2837 if (rar->cstate.window_buf == NULL)
2838 return ARCHIVE_FATAL;
2840 /* The unpacker spends most of the time in this function. It would be
2841 * a good idea to introduce some optimizations here.
2843 * Just remember that this loop treats buffers that overlap differently
2844 * than buffers that do not overlap. This is why a simple memcpy(3)
2845 * call will not be enough. */
2847 for(i = 0; i < len; i++) {
2848 const ssize_t write_idx = (write_ptr + i) & cmask;
2849 const ssize_t read_idx = (write_ptr + i - dist) & cmask;
2850 rar->cstate.window_buf[write_idx] =
2851 rar->cstate.window_buf[read_idx];
2854 rar->cstate.write_ptr += len;
2858 static int do_uncompress_block(struct archive_read* a, const uint8_t* p) {
2859 struct rar5* rar = get_context(a);
2863 const uint64_t cmask = rar->cstate.window_mask;
2864 const struct compressed_block_header* hdr = &rar->last_block_hdr;
2865 const uint8_t bit_size = 1 + bf_bit_size(hdr);
2868 if(rar->cstate.write_ptr - rar->cstate.last_write_ptr >
2869 (rar->cstate.window_size >> 1)) {
2870 /* Don't allow growing data by more than half of the
2871 * window size at a time. In such case, break the loop;
2872 * next call to this function will continue processing
2873 * from this moment. */
2877 if(rar->bits.in_addr > rar->cstate.cur_block_size - 1 ||
2878 (rar->bits.in_addr == rar->cstate.cur_block_size - 1 &&
2879 rar->bits.bit_addr >= bit_size))
2881 /* If the program counter is here, it means the
2882 * function has finished processing the block. */
2883 rar->cstate.block_parsing_finished = 1;
2887 /* Decode the next literal. */
2888 if(ARCHIVE_OK != decode_number(a, &rar->cstate.ld, p, &num)) {
2892 /* Num holds a decompression literal, or 'command code'.
2894 * - Values lower than 256 are just bytes. Those codes
2895 * can be stored in the output buffer directly.
2897 * - Code 256 defines a new filter, which is later used to
2898 * ransform the data block accordingly to the filter type.
2899 * The data block needs to be fully uncompressed first.
2901 * - Code bigger than 257 and smaller than 262 define
2902 * a repetition pattern that should be copied from
2903 * an already uncompressed chunk of data.
2907 /* Directly store the byte. */
2908 int64_t write_idx = rar->cstate.solid_offset +
2909 rar->cstate.write_ptr++;
2911 rar->cstate.window_buf[write_idx & cmask] =
2914 } else if(num >= 262) {
2916 int len = decode_code_length(rar, p, num - 262),
2921 archive_set_error(&a->archive,
2922 ARCHIVE_ERRNO_PROGRAMMER,
2923 "Failed to decode the code length");
2925 return ARCHIVE_FATAL;
2928 if(ARCHIVE_OK != decode_number(a, &rar->cstate.dd, p,
2931 archive_set_error(&a->archive,
2932 ARCHIVE_ERRNO_PROGRAMMER,
2933 "Failed to decode the distance slot");
2935 return ARCHIVE_FATAL;
2942 dbits = dist_slot / 2 - 1;
2944 /* Cast to uint32_t will make sure the shift
2945 * left operation won't produce undefined
2946 * result. Then, the uint32_t type will
2947 * be implicitly casted to int. */
2948 dist += (uint32_t) (2 |
2949 (dist_slot & 1)) << dbits;
2958 if(ARCHIVE_OK != read_bits_32(
2966 skip_bits(rar, dbits - 4);
2972 if(ARCHIVE_OK != decode_number(a,
2973 &rar->cstate.ldd, p, &low_dist))
2975 archive_set_error(&a->archive,
2976 ARCHIVE_ERRNO_PROGRAMMER,
2977 "Failed to decode the "
2980 return ARCHIVE_FATAL;
2983 if(dist >= INT_MAX - low_dist - 1) {
2984 /* This only happens in
2985 * invalid archives. */
2986 archive_set_error(&a->archive,
2987 ARCHIVE_ERRNO_FILE_FORMAT,
2990 return ARCHIVE_FATAL;
2995 /* dbits is one of [0,1,2,3] */
2998 if(ARCHIVE_OK != read_consume_bits(rar,
3000 /* Return EOF if we can't read
3015 if(dist > 0x40000) {
3021 dist_cache_push(rar, dist);
3022 rar->cstate.last_len = len;
3024 if(ARCHIVE_OK != copy_string(a, len, dist))
3025 return ARCHIVE_FATAL;
3028 } else if(num == 256) {
3029 /* Create a filter. */
3030 ret = parse_filter(a, p);
3031 if(ret != ARCHIVE_OK)
3035 } else if(num == 257) {
3036 if(rar->cstate.last_len != 0) {
3037 if(ARCHIVE_OK != copy_string(a,
3038 rar->cstate.last_len,
3039 rar->cstate.dist_cache[0]))
3041 return ARCHIVE_FATAL;
3046 } else if(num < 262) {
3047 const int idx = num - 258;
3048 const int dist = dist_cache_touch(rar, idx);
3053 if(ARCHIVE_OK != decode_number(a, &rar->cstate.rd, p,
3055 return ARCHIVE_FATAL;
3058 len = decode_code_length(rar, p, len_slot);
3059 rar->cstate.last_len = len;
3061 if(ARCHIVE_OK != copy_string(a, len, dist))
3062 return ARCHIVE_FATAL;
3067 /* The program counter shouldn't reach here. */
3068 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
3069 "Unsupported block code: 0x%x", num);
3071 return ARCHIVE_FATAL;
3077 /* Binary search for the RARv5 signature. */
3078 static int scan_for_signature(struct archive_read* a) {
3080 const int chunk_size = 512;
3083 /* If we're here, it means we're on an 'unknown territory' data.
3084 * There's no indication what kind of data we're reading here.
3085 * It could be some text comment, any kind of binary data,
3086 * digital sign, dragons, etc.
3088 * We want to find a valid RARv5 magic header inside this unknown
3091 /* Is it possible in libarchive to just skip everything until the
3092 * end of the file? If so, it would be a better approach than the
3093 * current implementation of this function. */
3096 if(!read_ahead(a, chunk_size, &p))
3099 for(i = 0; i < chunk_size - rar5_signature_size; i++) {
3100 if(memcmp(&p[i], rar5_signature,
3101 rar5_signature_size) == 0) {
3102 /* Consume the number of bytes we've used to
3103 * search for the signature, as well as the
3104 * number of bytes used by the signature
3105 * itself. After this we should be standing
3106 * on a valid base block header. */
3107 (void) consume(a, i + rar5_signature_size);
3112 consume(a, chunk_size);
3115 return ARCHIVE_FATAL;
3118 /* This function will switch the multivolume archive file to another file,
3119 * i.e. from part03 to part 04. */
3120 static int advance_multivolume(struct archive_read* a) {
3122 struct rar5* rar = get_context(a);
3124 /* A small state machine that will skip unnecessary data, needed to
3125 * switch from one multivolume to another. Such skipping is needed if
3126 * we want to be an stream-oriented (instead of file-oriented)
3129 * The state machine starts with `rar->main.endarc` == 0. It also
3130 * assumes that current stream pointer points to some base block
3133 * The `endarc` field is being set when the base block parsing
3134 * function encounters the 'end of archive' marker.
3138 if(rar->main.endarc == 1) {
3141 rar->main.endarc = 0;
3144 lret = skip_base_block(a);
3147 /* Continue looping. */
3154 /* Forward any errors to the
3162 /* Skip current base block. In order to properly skip
3163 * it, we really need to simply parse it and discard
3166 lret = skip_base_block(a);
3167 if(lret == ARCHIVE_FATAL || lret == ARCHIVE_FAILED)
3170 /* The `skip_base_block` function tells us if we
3171 * should continue with skipping, or we should stop
3172 * skipping. We're trying to skip everything up to
3173 * a base FILE block. */
3175 if(lret != ARCHIVE_RETRY) {
3176 /* If there was an error during skipping, or we
3177 * have just skipped a FILE base block... */
3179 if(rar->main.endarc == 0) {
3191 /* Merges the partial block from the first multivolume archive file, and
3192 * partial block from the second multivolume archive file. The result is
3193 * a chunk of memory containing the whole block, and the stream pointer
3194 * is advanced to the next block in the second multivolume archive file. */
3195 static int merge_block(struct archive_read* a, ssize_t block_size,
3198 struct rar5* rar = get_context(a);
3199 ssize_t cur_block_size, partial_offset = 0;
3203 if(rar->merge_mode) {
3204 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
3205 "Recursive merge is not allowed");
3207 return ARCHIVE_FATAL;
3210 /* Set a flag that we're in the switching mode. */
3211 rar->cstate.switch_multivolume = 1;
3213 /* Reallocate the memory which will hold the whole block. */
3214 if(rar->vol.push_buf)
3215 free((void*) rar->vol.push_buf);
3217 /* Increasing the allocation block by 8 is due to bit reading functions,
3218 * which are using additional 2 or 4 bytes. Allocating the block size
3219 * by exact value would make bit reader perform reads from invalid
3220 * memory block when reading the last byte from the buffer. */
3221 rar->vol.push_buf = malloc(block_size + 8);
3222 if(!rar->vol.push_buf) {
3223 archive_set_error(&a->archive, ENOMEM,
3224 "Can't allocate memory for a merge block buffer.");
3225 return ARCHIVE_FATAL;
3228 /* Valgrind complains if the extension block for bit reader is not
3229 * initialized, so initialize it. */
3230 memset(&rar->vol.push_buf[block_size], 0, 8);
3232 /* A single block can span across multiple multivolume archive files,
3233 * so we use a loop here. This loop will consume enough multivolume
3234 * archive files until the whole block is read. */
3237 /* Get the size of current block chunk in this multivolume
3238 * archive file and read it. */
3239 cur_block_size = rar5_min(rar->file.bytes_remaining,
3240 block_size - partial_offset);
3242 if(cur_block_size == 0) {
3243 archive_set_error(&a->archive,
3244 ARCHIVE_ERRNO_FILE_FORMAT,
3245 "Encountered block size == 0 during block merge");
3246 return ARCHIVE_FATAL;
3249 if(!read_ahead(a, cur_block_size, &lp))
3252 /* Sanity check; there should never be a situation where this
3253 * function reads more data than the block's size. */
3254 if(partial_offset + cur_block_size > block_size) {
3255 archive_set_error(&a->archive,
3256 ARCHIVE_ERRNO_PROGRAMMER,
3257 "Consumed too much data when merging blocks.");
3258 return ARCHIVE_FATAL;
3261 /* Merge previous block chunk with current block chunk,
3262 * or create first block chunk if this is our first
3264 memcpy(&rar->vol.push_buf[partial_offset], lp, cur_block_size);
3266 /* Advance the stream read pointer by this block chunk size. */
3267 if(ARCHIVE_OK != consume(a, cur_block_size))
3270 /* Update the pointers. `partial_offset` contains information
3271 * about the sum of merged block chunks. */
3272 partial_offset += cur_block_size;
3273 rar->file.bytes_remaining -= cur_block_size;
3275 /* If `partial_offset` is the same as `block_size`, this means
3276 * we've merged all block chunks and we have a valid full
3278 if(partial_offset == block_size) {
3282 /* If we don't have any bytes to read, this means we should
3283 * switch to another multivolume archive file. */
3284 if(rar->file.bytes_remaining == 0) {
3286 ret = advance_multivolume(a);
3288 if(ret != ARCHIVE_OK) {
3294 *p = rar->vol.push_buf;
3296 /* If we're here, we can resume unpacking by processing the block
3297 * pointed to by the `*p` memory pointer. */
3302 static int process_block(struct archive_read* a) {
3304 struct rar5* rar = get_context(a);
3307 /* If we don't have any data to be processed, this most probably means
3308 * we need to switch to the next volume. */
3309 if(rar->main.volume && rar->file.bytes_remaining == 0) {
3310 ret = advance_multivolume(a);
3311 if(ret != ARCHIVE_OK)
3315 if(rar->cstate.block_parsing_finished) {
3318 /* The header size won't be bigger than 6 bytes. */
3319 if(!read_ahead(a, 6, &p)) {
3320 /* Failed to prefetch data block header. */
3325 * Read block_size by parsing block header. Validate the header
3326 * by calculating CRC byte stored inside the header. Size of
3327 * the header is not constant (block size can be stored either
3328 * in 1 or 2 bytes), that's why block size is left out from the
3329 * `compressed_block_header` structure and returned by
3330 * `parse_block_header` as the second argument. */
3332 ret = parse_block_header(a, p, &block_size,
3333 &rar->last_block_hdr);
3334 if(ret != ARCHIVE_OK) {
3338 /* Skip block header. Next data is huffman tables,
3340 ssize_t to_skip = sizeof(struct compressed_block_header) +
3341 bf_byte_count(&rar->last_block_hdr) + 1;
3343 if(ARCHIVE_OK != consume(a, to_skip))
3346 rar->file.bytes_remaining -= to_skip;
3348 /* The block size gives information about the whole block size,
3349 * but the block could be stored in split form when using
3350 * multi-volume archives. In this case, the block size will be
3351 * bigger than the actual data stored in this file. Remaining
3352 * part of the data will be in another file. */
3354 ssize_t cur_block_size =
3355 rar5_min(rar->file.bytes_remaining, block_size);
3357 if(block_size > rar->file.bytes_remaining) {
3358 /* If current blocks' size is bigger than our data
3359 * size, this means we have a multivolume archive.
3360 * In this case, skip all base headers until the end
3361 * of the file, proceed to next "partXXX.rar" volume,
3362 * find its signature, skip all headers up to the first
3363 * FILE base header, and continue from there.
3365 * Note that `merge_block` will update the `rar`
3366 * context structure quite extensively. */
3368 ret = merge_block(a, block_size, &p);
3369 if(ret != ARCHIVE_OK) {
3373 cur_block_size = block_size;
3375 /* Current stream pointer should be now directly
3376 * *after* the block that spanned through multiple
3377 * archive files. `p` pointer should have the data of
3378 * the *whole* block (merged from partial blocks
3379 * stored in multiple archives files). */
3381 rar->cstate.switch_multivolume = 0;
3383 /* Read the whole block size into memory. This can take
3384 * up to 8 megabytes of memory in theoretical cases.
3385 * Might be worth to optimize this and use a standard
3386 * chunk of 4kb's. */
3387 if(!read_ahead(a, 4 + cur_block_size, &p)) {
3388 /* Failed to prefetch block data. */
3393 rar->cstate.block_buf = p;
3394 rar->cstate.cur_block_size = cur_block_size;
3395 rar->cstate.block_parsing_finished = 0;
3397 rar->bits.in_addr = 0;
3398 rar->bits.bit_addr = 0;
3400 if(bf_is_table_present(&rar->last_block_hdr)) {
3401 /* Load Huffman tables. */
3402 ret = parse_tables(a, rar, p);
3403 if(ret != ARCHIVE_OK) {
3404 /* Error during decompression of Huffman
3410 /* Block parsing not finished, reuse previous memory buffer. */
3411 p = rar->cstate.block_buf;
3414 /* Uncompress the block, or a part of it, depending on how many bytes
3415 * will be generated by uncompressing the block.
3417 * In case too many bytes will be generated, calling this function
3418 * again will resume the uncompression operation. */
3419 ret = do_uncompress_block(a, p);
3420 if(ret != ARCHIVE_OK) {
3424 if(rar->cstate.block_parsing_finished &&
3425 rar->cstate.switch_multivolume == 0 &&
3426 rar->cstate.cur_block_size > 0)
3428 /* If we're processing a normal block, consume the whole
3429 * block. We can do this because we've already read the whole
3430 * block to memory. */
3431 if(ARCHIVE_OK != consume(a, rar->cstate.cur_block_size))
3432 return ARCHIVE_FATAL;
3434 rar->file.bytes_remaining -= rar->cstate.cur_block_size;
3435 } else if(rar->cstate.switch_multivolume) {
3436 /* Don't consume the block if we're doing multivolume
3437 * processing. The volume switching function will consume
3438 * the proper count of bytes instead. */
3439 rar->cstate.switch_multivolume = 0;
3445 /* Pops the `buf`, `size` and `offset` from the "data ready" stack.
3447 * Returns ARCHIVE_OK when those arguments can be used, ARCHIVE_RETRY
3448 * when there is no data on the stack. */
3449 static int use_data(struct rar5* rar, const void** buf, size_t* size,
3454 for(i = 0; i < rar5_countof(rar->cstate.dready); i++) {
3455 struct data_ready *d = &rar->cstate.dready[i];
3458 if(buf) *buf = d->buf;
3459 if(size) *size = d->size;
3460 if(offset) *offset = d->offset;
3467 return ARCHIVE_RETRY;
3470 /* Pushes the `buf`, `size` and `offset` arguments to the rar->cstate.dready
3471 * FIFO stack. Those values will be popped from this stack by the `use_data`
3473 static int push_data_ready(struct archive_read* a, struct rar5* rar,
3474 const uint8_t* buf, size_t size, int64_t offset)
3478 /* Don't push if we're in skip mode. This is needed because solid
3479 * streams need full processing even if we're skipping data. After
3480 * fully processing the stream, we need to discard the generated bytes,
3481 * because we're interested only in the side effect: building up the
3482 * internal window circular buffer. This window buffer will be used
3483 * later during unpacking of requested data. */
3488 if(offset != rar->file.last_offset + rar->file.last_size) {
3489 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
3490 "Sanity check error: output stream is not continuous");
3491 return ARCHIVE_FATAL;
3494 for(i = 0; i < rar5_countof(rar->cstate.dready); i++) {
3495 struct data_ready* d = &rar->cstate.dready[i];
3502 /* These fields are used only in sanity checking. */
3503 rar->file.last_offset = offset;
3504 rar->file.last_size = size;
3506 /* Calculate the checksum of this new block before
3507 * submitting data to libarchive's engine. */
3508 update_crc(rar, d->buf, d->size);
3514 /* Program counter will reach this code if the `rar->cstate.data_ready`
3515 * stack will be filled up so that no new entries will be allowed. The
3516 * code shouldn't allow such situation to occur. So we treat this case
3517 * as an internal error. */
3519 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
3520 "Error: premature end of data_ready stack");
3521 return ARCHIVE_FATAL;
3524 /* This function uncompresses the data that is stored in the <FILE> base
3527 * The FILE base block looks like this:
3529 * <header><huffman tables><block_1><block_2>...<block_n>
3531 * The <header> is a block header, that is parsed in parse_block_header().
3532 * It's a "compressed_block_header" structure, containing metadata needed
3533 * to know when we should stop looking for more <block_n> blocks.
3535 * <huffman tables> contain data needed to set up the huffman tables, needed
3536 * for the actual decompression.
3538 * Each <block_n> consists of series of literals:
3540 * <literal><literal><literal>...<literal>
3542 * Those literals generate the uncompression data. They operate on a circular
3543 * buffer, sometimes writing raw data into it, sometimes referencing
3544 * some previous data inside this buffer, and sometimes declaring a filter
3545 * that will need to be executed on the data stored in the circular buffer.
3546 * It all depends on the literal that is used.
3548 * Sometimes blocks produce output data, sometimes they don't. For example, for
3549 * some huge files that use lots of filters, sometimes a block is filled with
3550 * only filter declaration literals. Such blocks won't produce any data in the
3553 * Sometimes blocks will produce 4 bytes of data, and sometimes 1 megabyte,
3554 * because a literal can reference previously decompressed data. For example,
3555 * there can be a literal that says: 'append a byte 0xFE here', and after
3556 * it another literal can say 'append 1 megabyte of data from circular buffer
3557 * offset 0x12345'. This is how RAR format handles compressing repeated
3560 * The RAR compressor creates those literals and the actual efficiency of
3561 * compression depends on what those literals are. The literals can also
3562 * be seen as a kind of a non-turing-complete virtual machine that simply
3563 * tells the decompressor what it should do.
3566 static int do_uncompress_file(struct archive_read* a) {
3567 struct rar5* rar = get_context(a);
3569 int64_t max_end_pos;
3571 if(!rar->cstate.initialized) {
3572 /* Don't perform full context reinitialization if we're
3573 * processing a solid archive. */
3574 if(!rar->main.solid || !rar->cstate.window_buf) {
3578 rar->cstate.initialized = 1;
3581 if(rar->cstate.all_filters_applied == 1) {
3582 /* We use while(1) here, but standard case allows for just 1
3583 * iteration. The loop will iterate if process_block() didn't
3584 * generate any data at all. This can happen if the block
3585 * contains only filter definitions (this is common in big
3588 ret = process_block(a);
3589 if(ret == ARCHIVE_EOF || ret == ARCHIVE_FATAL)
3592 if(rar->cstate.last_write_ptr ==
3593 rar->cstate.write_ptr) {
3594 /* The block didn't generate any new data,
3595 * so just process a new block. */
3599 /* The block has generated some new data, so break
3605 /* Try to run filters. If filters won't be applied, it means that
3606 * insufficient data was generated. */
3607 ret = apply_filters(a);
3608 if(ret == ARCHIVE_RETRY) {
3610 } else if(ret == ARCHIVE_FATAL) {
3611 return ARCHIVE_FATAL;
3614 /* If apply_filters() will return ARCHIVE_OK, we can continue here. */
3616 if(cdeque_size(&rar->cstate.filters) > 0) {
3617 /* Check if we can write something before hitting first
3619 struct filter_info* flt;
3621 /* Get the block_start offset from the first filter. */
3622 if(CDE_OK != cdeque_front(&rar->cstate.filters,
3623 cdeque_filter_p(&flt)))
3625 archive_set_error(&a->archive,
3626 ARCHIVE_ERRNO_PROGRAMMER,
3627 "Can't read first filter");
3628 return ARCHIVE_FATAL;
3631 max_end_pos = rar5_min(flt->block_start,
3632 rar->cstate.write_ptr);
3634 /* There are no filters defined, or all filters were applied.
3635 * This means we can just store the data without any
3636 * postprocessing. */
3637 max_end_pos = rar->cstate.write_ptr;
3640 if(max_end_pos == rar->cstate.last_write_ptr) {
3641 /* We can't write anything yet. The block uncompression
3642 * function did not generate enough data, and no filter can be
3643 * applied. At the same time we don't have any data that can be
3644 * stored without filter postprocessing. This means we need to
3645 * wait for more data to be generated, so we can apply the
3648 * Signal the caller that we need more data to be able to do
3651 return ARCHIVE_RETRY;
3653 /* We can write the data before hitting the first filter.
3654 * So let's do it. The push_window_data() function will
3655 * effectively return the selected data block to the user
3657 push_window_data(a, rar, rar->cstate.last_write_ptr,
3659 rar->cstate.last_write_ptr = max_end_pos;
3665 static int uncompress_file(struct archive_read* a) {
3669 /* Sometimes the uncompression function will return a
3670 * 'retry' signal. If this will happen, we have to retry
3672 ret = do_uncompress_file(a);
3673 if(ret != ARCHIVE_RETRY)
3679 static int do_unstore_file(struct archive_read* a,
3680 struct rar5* rar, const void** buf, size_t* size, int64_t* offset)
3684 if(rar->file.bytes_remaining == 0 && rar->main.volume > 0 &&
3685 rar->generic.split_after > 0)
3689 rar->cstate.switch_multivolume = 1;
3690 ret = advance_multivolume(a);
3691 rar->cstate.switch_multivolume = 0;
3693 if(ret != ARCHIVE_OK) {
3694 /* Failed to advance to next multivolume archive
3700 size_t to_read = rar5_min(rar->file.bytes_remaining, 64 * 1024);
3705 if(!read_ahead(a, to_read, &p)) {
3706 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
3707 "I/O error when unstoring file");
3708 return ARCHIVE_FATAL;
3711 if(ARCHIVE_OK != consume(a, to_read)) {
3716 if(size) *size = to_read;
3717 if(offset) *offset = rar->cstate.last_unstore_ptr;
3719 rar->file.bytes_remaining -= to_read;
3720 rar->cstate.last_unstore_ptr += to_read;
3722 update_crc(rar, p, to_read);
3726 static int do_unpack(struct archive_read* a, struct rar5* rar,
3727 const void** buf, size_t* size, int64_t* offset)
3729 enum COMPRESSION_METHOD {
3730 STORE = 0, FASTEST = 1, FAST = 2, NORMAL = 3, GOOD = 4,
3734 if(rar->file.service > 0) {
3735 return do_unstore_file(a, rar, buf, size, offset);
3737 switch(rar->cstate.method) {
3739 return do_unstore_file(a, rar, buf, size,
3750 return uncompress_file(a);
3752 archive_set_error(&a->archive,
3753 ARCHIVE_ERRNO_FILE_FORMAT,
3754 "Compression method not supported: 0x%x",
3755 rar->cstate.method);
3757 return ARCHIVE_FATAL;
3767 static int verify_checksums(struct archive_read* a) {
3769 struct rar5* rar = get_context(a);
3771 /* Check checksums only when actually unpacking the data. There's no
3772 * need to calculate checksum when we're skipping data in solid archives
3773 * (skipping in solid archives is the same thing as unpacking compressed
3774 * data and discarding the result). */
3776 if(!rar->skip_mode) {
3777 /* Always check checksums if we're not in skip mode */
3780 /* We can override the logic above with a compile-time option
3781 * NO_CRC_ON_SOLID_SKIP. This option is used during debugging,
3782 * and it will check checksums of unpacked data even when
3783 * we're skipping it. */
3785 #if defined CHECK_CRC_ON_SOLID_SKIP
3795 /* During unpacking, on each unpacked block we're calling the
3796 * update_crc() function. Since we are here, the unpacking
3797 * process is already over and we can check if calculated
3798 * checksum (CRC32 or BLAKE2sp) is the same as what is stored
3799 * in the archive. */
3800 if(rar->file.stored_crc32 > 0) {
3801 /* Check CRC32 only when the file contains a CRC32
3802 * value for this file. */
3804 if(rar->file.calculated_crc32 !=
3805 rar->file.stored_crc32) {
3806 /* Checksums do not match; the unpacked file
3810 printf("Checksum error: CRC32 "
3811 "(was: %08x, expected: %08x)\n",
3812 rar->file.calculated_crc32,
3813 rar->file.stored_crc32);
3816 #ifndef DONT_FAIL_ON_CRC_ERROR
3817 archive_set_error(&a->archive,
3818 ARCHIVE_ERRNO_FILE_FORMAT,
3819 "Checksum error: CRC32");
3820 return ARCHIVE_FATAL;
3824 printf("Checksum OK: CRC32 "
3826 rar->file.stored_crc32,
3827 rar->file.calculated_crc32);
3832 if(rar->file.has_blake2 > 0) {
3833 /* BLAKE2sp is an optional checksum algorithm that is
3834 * added to RARv5 archives when using the `-htb` switch
3835 * during creation of archive.
3837 * We now finalize the hash calculation by calling the
3838 * `final` function. This will generate the final hash
3839 * value we can use to compare it with the BLAKE2sp
3840 * checksum that is stored in the archive.
3842 * The return value of this `final` function is not
3843 * very helpful, as it guards only against improper use.
3844 * This is why we're explicitly ignoring it. */
3847 (void) blake2sp_final(&rar->file.b2state, b2_buf, 32);
3849 if(memcmp(&rar->file.blake2sp, b2_buf, 32) != 0) {
3850 #ifndef DONT_FAIL_ON_CRC_ERROR
3851 archive_set_error(&a->archive,
3852 ARCHIVE_ERRNO_FILE_FORMAT,
3853 "Checksum error: BLAKE2");
3855 return ARCHIVE_FATAL;
3861 /* Finalization for this file has been successfully completed. */
3865 static int verify_global_checksums(struct archive_read* a) {
3866 return verify_checksums(a);
3869 static int rar5_read_data(struct archive_read *a, const void **buff,
3870 size_t *size, int64_t *offset) {
3872 struct rar5* rar = get_context(a);
3874 if(rar->file.dir > 0) {
3875 /* Don't process any data if this file entry was declared
3876 * as a directory. This is needed, because entries marked as
3877 * directory doesn't have any dictionary buffer allocated, so
3878 * it's impossible to perform any decompression. */
3879 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
3880 "Can't decompress an entry marked as a directory");
3881 return ARCHIVE_FAILED;
3884 if(!rar->skip_mode && (rar->cstate.last_write_ptr > rar->file.unpacked_size)) {
3885 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
3886 "Unpacker has written too many bytes");
3887 return ARCHIVE_FATAL;
3890 ret = use_data(rar, buff, size, offset);
3891 if(ret == ARCHIVE_OK) {
3895 if(rar->file.eof == 1) {
3899 ret = do_unpack(a, rar, buff, size, offset);
3900 if(ret != ARCHIVE_OK) {
3904 if(rar->file.bytes_remaining == 0 &&
3905 rar->cstate.last_write_ptr == rar->file.unpacked_size)
3907 /* If all bytes of current file were processed, run
3910 * Finalization will check checksum against proper values. If
3911 * some of the checksums will not match, we'll return an error
3912 * value in the last `archive_read_data` call to signal an error
3916 return verify_global_checksums(a);
3922 static int rar5_read_data_skip(struct archive_read *a) {
3923 struct rar5* rar = get_context(a);
3925 if(rar->main.solid) {
3926 /* In solid archives, instead of skipping the data, we need to
3927 * extract it, and dispose the result. The side effect of this
3928 * operation will be setting up the initial window buffer state
3929 * needed to be able to extract the selected file. */
3933 /* Make sure to process all blocks in the compressed stream. */
3934 while(rar->file.bytes_remaining > 0) {
3935 /* Setting the "skip mode" will allow us to skip
3936 * checksum checks during data skipping. Checking the
3937 * checksum of skipped data isn't really necessary and
3938 * it's only slowing things down.
3940 * This is incremented instead of setting to 1 because
3941 * this data skipping function can be called
3945 /* We're disposing 1 block of data, so we use triple
3946 * NULLs in arguments. */
3947 ret = rar5_read_data(a, NULL, NULL, NULL);
3949 /* Turn off "skip mode". */
3952 if(ret < 0 || ret == ARCHIVE_EOF) {
3953 /* Propagate any potential error conditions
3959 /* In standard archives, we can just jump over the compressed
3960 * stream. Each file in non-solid archives starts from an empty
3963 if(ARCHIVE_OK != consume(a, rar->file.bytes_remaining)) {
3964 return ARCHIVE_FATAL;
3967 rar->file.bytes_remaining = 0;
3973 static int64_t rar5_seek_data(struct archive_read *a, int64_t offset,
3980 /* We're a streaming unpacker, and we don't support seeking. */
3982 return ARCHIVE_FATAL;
3985 static int rar5_cleanup(struct archive_read *a) {
3986 struct rar5* rar = get_context(a);
3988 free(rar->cstate.window_buf);
3989 free(rar->cstate.filtered_buf);
3991 free(rar->vol.push_buf);
3994 cdeque_free(&rar->cstate.filters);
3997 a->format->data = NULL;
4002 static int rar5_capabilities(struct archive_read * a) {
4007 static int rar5_has_encrypted_entries(struct archive_read *_a) {
4010 /* Unsupported for now. */
4011 return ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED;
4014 static int rar5_init(struct rar5* rar) {
4017 memset(rar, 0, sizeof(struct rar5));
4019 /* Decrypt the magic signature pattern. Check the comment near the
4020 * `rar5_signature` symbol to read the rationale behind this. */
4022 if(rar5_signature[0] == 243) {
4023 for(i = 0; i < rar5_signature_size; i++) {
4024 rar5_signature[i] ^= 0xA1;
4028 if(CDE_OK != cdeque_init(&rar->cstate.filters, 8192))
4029 return ARCHIVE_FATAL;
4034 int archive_read_support_format_rar5(struct archive *_a) {
4035 struct archive_read* ar;
4039 if(ARCHIVE_OK != (ret = get_archive_read(_a, &ar)))
4042 rar = malloc(sizeof(*rar));
4044 archive_set_error(&ar->archive, ENOMEM,
4045 "Can't allocate rar5 data");
4046 return ARCHIVE_FATAL;
4049 if(ARCHIVE_OK != rar5_init(rar)) {
4050 archive_set_error(&ar->archive, ENOMEM,
4051 "Can't allocate rar5 filter buffer");
4052 return ARCHIVE_FATAL;
4055 ret = __archive_read_register_format(ar,
4062 rar5_read_data_skip,
4066 rar5_has_encrypted_entries);
4068 if(ret != ARCHIVE_OK) {
4069 (void) rar5_cleanup(ar);