2 * Copyright (c) 2003-2007 Tim Kientzle
3 * Copyright (c) 2011 Andres Mejia
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include "archive_platform.h"
35 #include <zlib.h> /* crc32 */
40 #include "archive_crc32.h"
42 #include "archive_endian.h"
43 #include "archive_entry.h"
44 #include "archive_entry_locale.h"
45 #include "archive_ppmd7_private.h"
46 #include "archive_private.h"
47 #include "archive_read_private.h"
49 /* RAR signature, also known as the mark header */
50 #define RAR_SIGNATURE "\x52\x61\x72\x21\x1A\x07\x00"
53 #define MARK_HEAD 0x72
54 #define MAIN_HEAD 0x73
55 #define FILE_HEAD 0x74
56 #define COMM_HEAD 0x75
59 #define PROTECT_HEAD 0x78
60 #define SIGN_HEAD 0x79
61 #define NEWSUB_HEAD 0x7a
62 #define ENDARC_HEAD 0x7b
64 /* Main Header Flags */
65 #define MHD_VOLUME 0x0001
66 #define MHD_COMMENT 0x0002
67 #define MHD_LOCK 0x0004
68 #define MHD_SOLID 0x0008
69 #define MHD_NEWNUMBERING 0x0010
71 #define MHD_PROTECT 0x0040
72 #define MHD_PASSWORD 0x0080
73 #define MHD_FIRSTVOLUME 0x0100
74 #define MHD_ENCRYPTVER 0x0200
76 /* Flags common to all headers */
77 #define HD_MARKDELETION 0x4000
78 #define HD_ADD_SIZE_PRESENT 0x8000
80 /* File Header Flags */
81 #define FHD_SPLIT_BEFORE 0x0001
82 #define FHD_SPLIT_AFTER 0x0002
83 #define FHD_PASSWORD 0x0004
84 #define FHD_COMMENT 0x0008
85 #define FHD_SOLID 0x0010
86 #define FHD_LARGE 0x0100
87 #define FHD_UNICODE 0x0200
88 #define FHD_SALT 0x0400
89 #define FHD_VERSION 0x0800
90 #define FHD_EXTTIME 0x1000
91 #define FHD_EXTFLAGS 0x2000
93 /* File dictionary sizes */
94 #define DICTIONARY_SIZE_64 0x00
95 #define DICTIONARY_SIZE_128 0x20
96 #define DICTIONARY_SIZE_256 0x40
97 #define DICTIONARY_SIZE_512 0x60
98 #define DICTIONARY_SIZE_1024 0x80
99 #define DICTIONARY_SIZE_2048 0xA0
100 #define DICTIONARY_SIZE_4096 0xC0
101 #define FILE_IS_DIRECTORY 0xE0
102 #define DICTIONARY_MASK FILE_IS_DIRECTORY
112 /* Compression Methods */
113 #define COMPRESS_METHOD_STORE 0x30
115 #define COMPRESS_METHOD_FASTEST 0x31
116 #define COMPRESS_METHOD_FAST 0x32
117 #define COMPRESS_METHOD_NORMAL 0x33
119 #define COMPRESS_METHOD_GOOD 0x34
120 #define COMPRESS_METHOD_BEST 0x35
122 #define CRC_POLYNOMIAL 0xEDB88320
124 #define NS_UNIT 10000000
126 #define DICTIONARY_MAX_SIZE 0x400000
128 #define MAINCODE_SIZE 299
129 #define OFFSETCODE_SIZE 60
130 #define LOWOFFSETCODE_SIZE 17
131 #define LENGTHCODE_SIZE 28
132 #define HUFFMAN_TABLE_SIZE \
133 MAINCODE_SIZE + OFFSETCODE_SIZE + LOWOFFSETCODE_SIZE + LENGTHCODE_SIZE
135 #define MAX_SYMBOL_LENGTH 0xF
136 #define MAX_SYMBOLS 20
139 * Considering L1,L2 cache miss and a calling of write system-call,
140 * the best size of the output buffer(uncompressed buffer) is 128K.
141 * If the structure of extracting process is changed, this value
142 * might be researched again.
144 #define UNP_BUFFER_SIZE (128 * 1024)
146 /* Define this here for non-Windows platforms */
147 #if !((defined(__WIN32__) || defined(_WIN32) || defined(__WIN32)) && !defined(__CYGWIN__))
148 #define FILE_ATTRIBUTE_DIRECTORY 0x10
152 #define minimum(a, b) ((a)<(b)?(a):(b))
154 /* Stack overflow check */
155 #define MAX_COMPRESS_DEPTH 1024
157 /* Fields common to all headers */
166 /* Fields common to all file headers */
167 struct rar_file_header
180 struct huffman_tree_node
185 struct huffman_table_entry
193 struct huffman_tree_node *tree;
195 int numallocatedentries;
199 struct huffman_table_entry *table;
204 unsigned char *window;
209 struct data_block_offsets
212 int64_t start_offset;
218 /* Entries from main RAR header */
220 unsigned long file_crc;
225 /* File header entries */
226 char compression_method;
235 size_t filename_save_size;
236 size_t filename_allocated;
238 /* File header optional entries */
247 /* Fields to help with tracking decompression of files. */
248 int64_t bytes_unconsumed;
249 int64_t bytes_remaining;
250 int64_t bytes_uncopied;
252 int64_t offset_outgoing;
255 unsigned int unp_offset;
256 unsigned int unp_buffer_size;
257 unsigned char *unp_buffer;
258 unsigned int dictionary_size;
259 char start_new_block;
261 unsigned long crc_calculated;
262 int found_first_header;
263 char has_endarc_header;
264 struct data_block_offsets *dbo;
269 struct huffman_code maincode;
270 struct huffman_code offsetcode;
271 struct huffman_code lowoffsetcode;
272 struct huffman_code lengthcode;
273 unsigned char lengthtable[HUFFMAN_TABLE_SIZE];
275 char output_last_match;
276 unsigned int lastlength;
277 unsigned int lastoffset;
278 unsigned int oldoffset[4];
279 unsigned int lastlowoffset;
280 unsigned int numlowoffsetrepeats;
282 char start_new_table;
284 /* PPMd Variant H members */
289 CPpmd7 ppmd7_context;
290 CPpmd7z_RangeDec range_dec;
294 * String conversion object.
296 int init_default_conversion;
297 struct archive_string_conv *sconv_default;
298 struct archive_string_conv *opt_sconv;
299 struct archive_string_conv *sconv_utf8;
300 struct archive_string_conv *sconv_utf16be;
306 #define CACHE_TYPE uint64_t
307 #define CACHE_BITS (8 * sizeof(CACHE_TYPE))
309 CACHE_TYPE cache_buffer;
310 /* Indicates how many bits avail in cache_buffer. */
313 const unsigned char *next_in;
317 * Custom field to denote that this archive contains encrypted entries
319 int has_encrypted_entries;
322 static int archive_read_support_format_rar_capabilities(struct archive_read *);
323 static int archive_read_format_rar_has_encrypted_entries(struct archive_read *);
324 static int archive_read_format_rar_bid(struct archive_read *, int);
325 static int archive_read_format_rar_options(struct archive_read *,
326 const char *, const char *);
327 static int archive_read_format_rar_read_header(struct archive_read *,
328 struct archive_entry *);
329 static int archive_read_format_rar_read_data(struct archive_read *,
330 const void **, size_t *, int64_t *);
331 static int archive_read_format_rar_read_data_skip(struct archive_read *a);
332 static int64_t archive_read_format_rar_seek_data(struct archive_read *, int64_t,
334 static int archive_read_format_rar_cleanup(struct archive_read *);
336 /* Support functions */
337 static int read_header(struct archive_read *, struct archive_entry *, char);
338 static time_t get_time(int);
339 static int read_exttime(const char *, struct rar *, const char *);
340 static int read_symlink_stored(struct archive_read *, struct archive_entry *,
341 struct archive_string_conv *);
342 static int read_data_stored(struct archive_read *, const void **, size_t *,
344 static int read_data_compressed(struct archive_read *, const void **, size_t *,
346 static int rar_br_preparation(struct archive_read *, struct rar_br *);
347 static int parse_codes(struct archive_read *);
348 static void free_codes(struct archive_read *);
349 static int read_next_symbol(struct archive_read *, struct huffman_code *);
350 static int create_code(struct archive_read *, struct huffman_code *,
351 unsigned char *, int, char);
352 static int add_value(struct archive_read *, struct huffman_code *, int, int,
354 static int new_node(struct huffman_code *);
355 static int make_table(struct archive_read *, struct huffman_code *);
356 static int make_table_recurse(struct archive_read *, struct huffman_code *, int,
357 struct huffman_table_entry *, int, int);
358 static int64_t expand(struct archive_read *, int64_t);
359 static int copy_from_lzss_window(struct archive_read *, const void **,
361 static const void *rar_read_ahead(struct archive_read *, size_t, ssize_t *);
366 /* Check that the cache buffer has enough bits. */
367 #define rar_br_has(br, n) ((br)->cache_avail >= n)
368 /* Get compressed data by bit. */
369 #define rar_br_bits(br, n) \
370 (((uint32_t)((br)->cache_buffer >> \
371 ((br)->cache_avail - (n)))) & cache_masks[n])
372 #define rar_br_bits_forced(br, n) \
373 (((uint32_t)((br)->cache_buffer << \
374 ((n) - (br)->cache_avail))) & cache_masks[n])
375 /* Read ahead to make sure the cache buffer has enough compressed data we
377 * True : completed, there is enough data in the cache buffer.
378 * False : there is no data in the stream. */
379 #define rar_br_read_ahead(a, br, n) \
380 ((rar_br_has(br, (n)) || rar_br_fillup(a, br)) || rar_br_has(br, (n)))
381 /* Notify how many bits we consumed. */
382 #define rar_br_consume(br, n) ((br)->cache_avail -= (n))
383 #define rar_br_consume_unalined_bits(br) ((br)->cache_avail &= ~7)
385 static const uint32_t cache_masks[] = {
386 0x00000000, 0x00000001, 0x00000003, 0x00000007,
387 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F,
388 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,
389 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF,
390 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF,
391 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,
392 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF,
393 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF,
394 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
398 * Shift away used bits in the cache data and fill it up with following bits.
399 * Call this when cache buffer does not have enough bits you need.
401 * Returns 1 if the cache buffer is full.
402 * Returns 0 if the cache buffer is not full; input buffer is empty.
405 rar_br_fillup(struct archive_read *a, struct rar_br *br)
407 struct rar *rar = (struct rar *)(a->format->data);
408 int n = CACHE_BITS - br->cache_avail;
413 if (br->avail_in >= 8) {
415 ((uint64_t)br->next_in[0]) << 56 |
416 ((uint64_t)br->next_in[1]) << 48 |
417 ((uint64_t)br->next_in[2]) << 40 |
418 ((uint64_t)br->next_in[3]) << 32 |
419 ((uint32_t)br->next_in[4]) << 24 |
420 ((uint32_t)br->next_in[5]) << 16 |
421 ((uint32_t)br->next_in[6]) << 8 |
422 (uint32_t)br->next_in[7];
425 br->cache_avail += 8 * 8;
426 rar->bytes_unconsumed += 8;
427 rar->bytes_remaining -= 8;
432 if (br->avail_in >= 7) {
434 (br->cache_buffer << 56) |
435 ((uint64_t)br->next_in[0]) << 48 |
436 ((uint64_t)br->next_in[1]) << 40 |
437 ((uint64_t)br->next_in[2]) << 32 |
438 ((uint32_t)br->next_in[3]) << 24 |
439 ((uint32_t)br->next_in[4]) << 16 |
440 ((uint32_t)br->next_in[5]) << 8 |
441 (uint32_t)br->next_in[6];
444 br->cache_avail += 7 * 8;
445 rar->bytes_unconsumed += 7;
446 rar->bytes_remaining -= 7;
451 if (br->avail_in >= 6) {
453 (br->cache_buffer << 48) |
454 ((uint64_t)br->next_in[0]) << 40 |
455 ((uint64_t)br->next_in[1]) << 32 |
456 ((uint32_t)br->next_in[2]) << 24 |
457 ((uint32_t)br->next_in[3]) << 16 |
458 ((uint32_t)br->next_in[4]) << 8 |
459 (uint32_t)br->next_in[5];
462 br->cache_avail += 6 * 8;
463 rar->bytes_unconsumed += 6;
464 rar->bytes_remaining -= 6;
469 /* We have enough compressed data in
470 * the cache buffer.*/
475 if (br->avail_in <= 0) {
477 if (rar->bytes_unconsumed > 0) {
478 /* Consume as much as the decompressor
480 __archive_read_consume(a, rar->bytes_unconsumed);
481 rar->bytes_unconsumed = 0;
483 br->next_in = rar_read_ahead(a, 1, &(br->avail_in));
484 if (br->next_in == NULL)
486 if (br->avail_in == 0)
490 (br->cache_buffer << 8) | *br->next_in++;
492 br->cache_avail += 8;
494 rar->bytes_unconsumed++;
495 rar->bytes_remaining--;
500 rar_br_preparation(struct archive_read *a, struct rar_br *br)
502 struct rar *rar = (struct rar *)(a->format->data);
504 if (rar->bytes_remaining > 0) {
505 br->next_in = rar_read_ahead(a, 1, &(br->avail_in));
506 if (br->next_in == NULL) {
507 archive_set_error(&a->archive,
508 ARCHIVE_ERRNO_FILE_FORMAT,
509 "Truncated RAR file data");
510 return (ARCHIVE_FATAL);
512 if (br->cache_avail == 0)
513 (void)rar_br_fillup(a, br);
518 /* Find last bit set */
520 rar_fls(unsigned int word)
526 word |= (word >> 16);
527 return word - (word >> 1);
531 static inline int64_t
532 lzss_position(struct lzss *lzss)
534 return lzss->position;
538 lzss_mask(struct lzss *lzss)
544 lzss_size(struct lzss *lzss)
546 return lzss->mask + 1;
550 lzss_offset_for_position(struct lzss *lzss, int64_t pos)
552 return (int)(pos & lzss->mask);
555 static inline unsigned char *
556 lzss_pointer_for_position(struct lzss *lzss, int64_t pos)
558 return &lzss->window[lzss_offset_for_position(lzss, pos)];
562 lzss_current_offset(struct lzss *lzss)
564 return lzss_offset_for_position(lzss, lzss->position);
567 static inline uint8_t *
568 lzss_current_pointer(struct lzss *lzss)
570 return lzss_pointer_for_position(lzss, lzss->position);
574 lzss_emit_literal(struct rar *rar, uint8_t literal)
576 *lzss_current_pointer(&rar->lzss) = literal;
577 rar->lzss.position++;
581 lzss_emit_match(struct rar *rar, int offset, int length)
583 int dstoffs = lzss_current_offset(&rar->lzss);
584 int srcoffs = (dstoffs - offset) & lzss_mask(&rar->lzss);
585 int l, li, remaining;
586 unsigned char *d, *s;
589 while (remaining > 0) {
591 if (dstoffs > srcoffs) {
592 if (l > lzss_size(&rar->lzss) - dstoffs)
593 l = lzss_size(&rar->lzss) - dstoffs;
595 if (l > lzss_size(&rar->lzss) - srcoffs)
596 l = lzss_size(&rar->lzss) - srcoffs;
598 d = &(rar->lzss.window[dstoffs]);
599 s = &(rar->lzss.window[srcoffs]);
600 if ((dstoffs + l < srcoffs) || (srcoffs + l < dstoffs))
603 for (li = 0; li < l; li++)
607 dstoffs = (dstoffs + l) & lzss_mask(&(rar->lzss));
608 srcoffs = (srcoffs + l) & lzss_mask(&(rar->lzss));
610 rar->lzss.position += length;
616 struct archive_read *a = ((IByteIn*)p)->a;
617 struct rar *rar = (struct rar *)(a->format->data);
618 struct rar_br *br = &(rar->br);
620 if (!rar_br_read_ahead(a, br, 8))
622 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
623 "Truncated RAR file data");
627 b = rar_br_bits(br, 8);
628 rar_br_consume(br, 8);
633 archive_read_support_format_rar(struct archive *_a)
635 struct archive_read *a = (struct archive_read *)_a;
639 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
640 "archive_read_support_format_rar");
642 rar = (struct rar *)calloc(sizeof(*rar), 1);
645 archive_set_error(&a->archive, ENOMEM, "Can't allocate rar data");
646 return (ARCHIVE_FATAL);
650 * Until enough data has been read, we cannot tell about
651 * any encrypted entries yet.
653 rar->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
655 r = __archive_read_register_format(a,
658 archive_read_format_rar_bid,
659 archive_read_format_rar_options,
660 archive_read_format_rar_read_header,
661 archive_read_format_rar_read_data,
662 archive_read_format_rar_read_data_skip,
663 archive_read_format_rar_seek_data,
664 archive_read_format_rar_cleanup,
665 archive_read_support_format_rar_capabilities,
666 archive_read_format_rar_has_encrypted_entries);
674 archive_read_support_format_rar_capabilities(struct archive_read * a)
676 (void)a; /* UNUSED */
677 return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA
678 | ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA);
682 archive_read_format_rar_has_encrypted_entries(struct archive_read *_a)
684 if (_a && _a->format) {
685 struct rar * rar = (struct rar *)_a->format->data;
687 return rar->has_encrypted_entries;
690 return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
695 archive_read_format_rar_bid(struct archive_read *a, int best_bid)
699 /* If there's already a bid > 30, we'll never win. */
703 if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)
706 if (memcmp(p, RAR_SIGNATURE, 7) == 0)
709 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
710 /* This is a PE file */
711 ssize_t offset = 0x10000;
712 ssize_t window = 4096;
714 while (offset + window <= (1024 * 128)) {
715 const char *buff = __archive_read_ahead(a, offset + window, &bytes_avail);
717 /* Remaining bytes are less than window. */
724 while (p + 7 < buff + bytes_avail) {
725 if (memcmp(p, RAR_SIGNATURE, 7) == 0)
736 skip_sfx(struct archive_read *a)
741 ssize_t bytes, window;
745 while (total + window <= (1024 * 128)) {
746 h = __archive_read_ahead(a, window, &bytes);
748 /* Remaining bytes are less than window. */
760 * Scan ahead until we find something that looks
761 * like the RAR header.
764 if (memcmp(p, RAR_SIGNATURE, 7) == 0) {
765 skip = p - (const char *)h;
766 __archive_read_consume(a, skip);
771 skip = p - (const char *)h;
772 __archive_read_consume(a, skip);
776 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
777 "Couldn't find out RAR header");
778 return (ARCHIVE_FATAL);
782 archive_read_format_rar_options(struct archive_read *a,
783 const char *key, const char *val)
786 int ret = ARCHIVE_FAILED;
788 rar = (struct rar *)(a->format->data);
789 if (strcmp(key, "hdrcharset") == 0) {
790 if (val == NULL || val[0] == 0)
791 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
792 "rar: hdrcharset option needs a character-set name");
795 archive_string_conversion_from_charset(
796 &a->archive, val, 0);
797 if (rar->opt_sconv != NULL)
805 /* Note: The "warn" return is just to inform the options
806 * supervisor that we didn't handle it. It will generate
807 * a suitable error if no one used this option. */
808 return (ARCHIVE_WARN);
812 archive_read_format_rar_read_header(struct archive_read *a,
813 struct archive_entry *entry)
822 unsigned long crc32_expected;
824 a->archive.archive_format = ARCHIVE_FORMAT_RAR;
825 if (a->archive.archive_format_name == NULL)
826 a->archive.archive_format_name = "RAR";
828 rar = (struct rar *)(a->format->data);
831 * It should be sufficient to call archive_read_next_header() for
832 * a reader to determine if an entry is encrypted or not. If the
833 * encryption of an entry is only detectable when calling
834 * archive_read_data(), so be it. We'll do the same check there
837 if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
838 rar->has_encrypted_entries = 0;
841 /* RAR files can be generated without EOF headers, so return ARCHIVE_EOF if
844 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
845 return (ARCHIVE_EOF);
848 if (rar->found_first_header == 0 &&
849 ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0)) {
850 /* This is an executable ? Must be self-extracting... */
852 if (ret < ARCHIVE_WARN)
855 rar->found_first_header = 1;
859 unsigned long crc32_val;
861 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
862 return (ARCHIVE_FATAL);
869 if (memcmp(p, RAR_SIGNATURE, 7) != 0) {
870 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
871 "Invalid marker header");
872 return (ARCHIVE_FATAL);
874 __archive_read_consume(a, 7);
878 rar->main_flags = archive_le16dec(p + 3);
879 skip = archive_le16dec(p + 5);
880 if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)) {
881 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
882 "Invalid header size");
883 return (ARCHIVE_FATAL);
885 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL)
886 return (ARCHIVE_FATAL);
888 memcpy(rar->reserved1, p + 7, sizeof(rar->reserved1));
889 memcpy(rar->reserved2, p + 7 + sizeof(rar->reserved1),
890 sizeof(rar->reserved2));
891 if (rar->main_flags & MHD_ENCRYPTVER) {
892 if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)+1) {
893 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
894 "Invalid header size");
895 return (ARCHIVE_FATAL);
897 rar->encryptver = *(p + 7 + sizeof(rar->reserved1) +
898 sizeof(rar->reserved2));
901 /* Main header is password encrypted, so we cannot read any
902 file names or any other info about files from the header. */
903 if (rar->main_flags & MHD_PASSWORD)
905 archive_entry_set_is_metadata_encrypted(entry, 1);
906 archive_entry_set_is_data_encrypted(entry, 1);
907 rar->has_encrypted_entries = 1;
908 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
909 "RAR encryption support unavailable.");
910 return (ARCHIVE_FATAL);
913 crc32_val = crc32(0, (const unsigned char *)p + 2, (unsigned)skip - 2);
914 if ((crc32_val & 0xffff) != archive_le16dec(p)) {
915 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
917 return (ARCHIVE_FATAL);
919 __archive_read_consume(a, skip);
923 return read_header(a, entry, head_type);
931 flags = archive_le16dec(p + 3);
932 skip = archive_le16dec(p + 5);
934 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
935 "Invalid header size too small");
936 return (ARCHIVE_FATAL);
938 if (flags & HD_ADD_SIZE_PRESENT)
941 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
942 "Invalid header size too small");
943 return (ARCHIVE_FATAL);
945 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL)
946 return (ARCHIVE_FATAL);
948 skip += archive_le32dec(p + 7);
951 /* Skip over the 2-byte CRC at the beginning of the header. */
952 crc32_expected = archive_le16dec(p);
953 __archive_read_consume(a, 2);
956 /* Skim the entire header and compute the CRC. */
959 size_t to_read = skip;
961 if (to_read > 32 * 1024) {
964 if ((h = __archive_read_ahead(a, to_read, &did_read)) == NULL) {
965 return (ARCHIVE_FATAL);
968 crc32_val = crc32(crc32_val, (const unsigned char *)p, (unsigned)did_read);
969 __archive_read_consume(a, did_read);
972 if ((crc32_val & 0xffff) != crc32_expected) {
973 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
975 return (ARCHIVE_FATAL);
977 if (head_type == ENDARC_HEAD)
978 return (ARCHIVE_EOF);
982 if ((ret = read_header(a, entry, head_type)) < ARCHIVE_WARN)
987 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
989 return (ARCHIVE_FATAL);
995 archive_read_format_rar_read_data(struct archive_read *a, const void **buff,
996 size_t *size, int64_t *offset)
998 struct rar *rar = (struct rar *)(a->format->data);
1001 if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
1002 rar->has_encrypted_entries = 0;
1005 if (rar->bytes_unconsumed > 0) {
1006 /* Consume as much as the decompressor actually used. */
1007 __archive_read_consume(a, rar->bytes_unconsumed);
1008 rar->bytes_unconsumed = 0;
1012 if (rar->entry_eof || rar->offset_seek >= rar->unp_size) {
1014 *offset = rar->offset;
1015 if (*offset < rar->unp_size)
1016 *offset = rar->unp_size;
1017 return (ARCHIVE_EOF);
1020 switch (rar->compression_method)
1022 case COMPRESS_METHOD_STORE:
1023 ret = read_data_stored(a, buff, size, offset);
1026 case COMPRESS_METHOD_FASTEST:
1027 case COMPRESS_METHOD_FAST:
1028 case COMPRESS_METHOD_NORMAL:
1029 case COMPRESS_METHOD_GOOD:
1030 case COMPRESS_METHOD_BEST:
1031 ret = read_data_compressed(a, buff, size, offset, 0);
1032 if (ret != ARCHIVE_OK && ret != ARCHIVE_WARN) {
1033 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context);
1034 rar->start_new_table = 1;
1035 rar->ppmd_valid = 0;
1040 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1041 "Unsupported compression method for RAR file.");
1042 ret = ARCHIVE_FATAL;
1049 archive_read_format_rar_read_data_skip(struct archive_read *a)
1052 int64_t bytes_skipped;
1055 rar = (struct rar *)(a->format->data);
1057 if (rar->bytes_unconsumed > 0) {
1058 /* Consume as much as the decompressor actually used. */
1059 __archive_read_consume(a, rar->bytes_unconsumed);
1060 rar->bytes_unconsumed = 0;
1063 if (rar->bytes_remaining > 0) {
1064 bytes_skipped = __archive_read_consume(a, rar->bytes_remaining);
1065 if (bytes_skipped < 0)
1066 return (ARCHIVE_FATAL);
1069 /* Compressed data to skip must be read from each header in a multivolume
1072 if (rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER)
1074 ret = archive_read_format_rar_read_header(a, a->entry);
1075 if (ret == (ARCHIVE_EOF))
1076 ret = archive_read_format_rar_read_header(a, a->entry);
1077 if (ret != (ARCHIVE_OK))
1079 return archive_read_format_rar_read_data_skip(a);
1082 return (ARCHIVE_OK);
1086 archive_read_format_rar_seek_data(struct archive_read *a, int64_t offset,
1089 int64_t client_offset, ret;
1091 struct rar *rar = (struct rar *)(a->format->data);
1093 if (rar->compression_method == COMPRESS_METHOD_STORE)
1095 /* Modify the offset for use with SEEK_SET */
1099 client_offset = rar->offset_seek;
1102 client_offset = rar->unp_size;
1108 client_offset += offset;
1109 if (client_offset < 0)
1111 /* Can't seek past beginning of data block */
1114 else if (client_offset > rar->unp_size)
1117 * Set the returned offset but only seek to the end of
1120 rar->offset_seek = client_offset;
1121 client_offset = rar->unp_size;
1124 client_offset += rar->dbo[0].start_offset;
1126 while (i < rar->cursor)
1129 client_offset += rar->dbo[i].start_offset - rar->dbo[i-1].end_offset;
1131 if (rar->main_flags & MHD_VOLUME)
1133 /* Find the appropriate offset among the multivolume archive */
1136 if (client_offset < rar->dbo[rar->cursor].start_offset &&
1137 rar->file_flags & FHD_SPLIT_BEFORE)
1139 /* Search backwards for the correct data block */
1140 if (rar->cursor == 0)
1142 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1143 "Attempt to seek past beginning of RAR data block");
1144 return (ARCHIVE_FAILED);
1147 client_offset -= rar->dbo[rar->cursor+1].start_offset -
1148 rar->dbo[rar->cursor].end_offset;
1149 if (client_offset < rar->dbo[rar->cursor].start_offset)
1151 ret = __archive_read_seek(a, rar->dbo[rar->cursor].start_offset -
1152 rar->dbo[rar->cursor].header_size, SEEK_SET);
1153 if (ret < (ARCHIVE_OK))
1155 ret = archive_read_format_rar_read_header(a, a->entry);
1156 if (ret != (ARCHIVE_OK))
1158 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1159 "Error during seek of RAR file");
1160 return (ARCHIVE_FAILED);
1165 else if (client_offset > rar->dbo[rar->cursor].end_offset &&
1166 rar->file_flags & FHD_SPLIT_AFTER)
1168 /* Search forward for the correct data block */
1170 if (rar->cursor < rar->nodes &&
1171 client_offset > rar->dbo[rar->cursor].end_offset)
1173 client_offset += rar->dbo[rar->cursor].start_offset -
1174 rar->dbo[rar->cursor-1].end_offset;
1178 ret = __archive_read_seek(a, rar->dbo[rar->cursor].end_offset,
1180 if (ret < (ARCHIVE_OK))
1182 ret = archive_read_format_rar_read_header(a, a->entry);
1183 if (ret == (ARCHIVE_EOF))
1185 rar->has_endarc_header = 1;
1186 ret = archive_read_format_rar_read_header(a, a->entry);
1188 if (ret != (ARCHIVE_OK))
1190 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1191 "Error during seek of RAR file");
1192 return (ARCHIVE_FAILED);
1194 client_offset += rar->dbo[rar->cursor].start_offset -
1195 rar->dbo[rar->cursor-1].end_offset;
1202 ret = __archive_read_seek(a, client_offset, SEEK_SET);
1203 if (ret < (ARCHIVE_OK))
1205 rar->bytes_remaining = rar->dbo[rar->cursor].end_offset - ret;
1210 ret -= rar->dbo[i+1].start_offset - rar->dbo[i].end_offset;
1212 ret -= rar->dbo[0].start_offset;
1214 /* Always restart reading the file after a seek */
1215 __archive_reset_read_data(&a->archive);
1217 rar->bytes_unconsumed = 0;
1221 * If a seek past the end of file was requested, return the requested
1224 if (ret == rar->unp_size && rar->offset_seek > rar->unp_size)
1225 return rar->offset_seek;
1227 /* Return the new offset */
1228 rar->offset_seek = ret;
1229 return rar->offset_seek;
1233 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1234 "Seeking of compressed RAR files is unsupported");
1236 return (ARCHIVE_FAILED);
1240 archive_read_format_rar_cleanup(struct archive_read *a)
1244 rar = (struct rar *)(a->format->data);
1246 free(rar->filename);
1247 free(rar->filename_save);
1249 free(rar->unp_buffer);
1250 free(rar->lzss.window);
1251 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context);
1253 (a->format->data) = NULL;
1254 return (ARCHIVE_OK);
1258 read_header(struct archive_read *a, struct archive_entry *entry,
1262 const char *p, *endp;
1264 struct rar_header rar_header;
1265 struct rar_file_header file_header;
1266 int64_t header_size;
1267 unsigned filename_size, end;
1270 char packed_size[8];
1273 struct archive_string_conv *sconv, *fn_sconv;
1274 unsigned long crc32_val;
1275 int ret = (ARCHIVE_OK), ret2;
1277 rar = (struct rar *)(a->format->data);
1279 /* Setup a string conversion object for non-rar-unicode filenames. */
1280 sconv = rar->opt_sconv;
1281 if (sconv == NULL) {
1282 if (!rar->init_default_conversion) {
1283 rar->sconv_default =
1284 archive_string_default_conversion_for_read(
1286 rar->init_default_conversion = 1;
1288 sconv = rar->sconv_default;
1292 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
1293 return (ARCHIVE_FATAL);
1295 memcpy(&rar_header, p, sizeof(rar_header));
1296 rar->file_flags = archive_le16dec(rar_header.flags);
1297 header_size = archive_le16dec(rar_header.size);
1298 if (header_size < (int64_t)sizeof(file_header) + 7) {
1299 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1300 "Invalid header size");
1301 return (ARCHIVE_FATAL);
1303 crc32_val = crc32(0, (const unsigned char *)p + 2, 7 - 2);
1304 __archive_read_consume(a, 7);
1306 if (!(rar->file_flags & FHD_SOLID))
1308 rar->compression_method = 0;
1309 rar->packed_size = 0;
1316 memset(&rar->salt, 0, sizeof(rar->salt));
1328 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1329 "RAR solid archive support unavailable.");
1330 return (ARCHIVE_FATAL);
1333 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL)
1334 return (ARCHIVE_FATAL);
1336 /* File Header CRC check. */
1337 crc32_val = crc32(crc32_val, h, (unsigned)(header_size - 7));
1338 if ((crc32_val & 0xffff) != archive_le16dec(rar_header.crc)) {
1339 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1340 "Header CRC error");
1341 return (ARCHIVE_FATAL);
1343 /* If no CRC error, Go on parsing File Header. */
1345 endp = p + header_size - 7;
1346 memcpy(&file_header, p, sizeof(file_header));
1347 p += sizeof(file_header);
1349 rar->compression_method = file_header.method;
1351 ttime = archive_le32dec(file_header.file_time);
1352 rar->mtime = get_time(ttime);
1354 rar->file_crc = archive_le32dec(file_header.file_crc);
1356 if (rar->file_flags & FHD_PASSWORD)
1358 archive_entry_set_is_data_encrypted(entry, 1);
1359 rar->has_encrypted_entries = 1;
1360 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1361 "RAR encryption support unavailable.");
1362 /* Since it is only the data part itself that is encrypted we can at least
1363 extract information about the currently processed entry and don't need
1364 to return ARCHIVE_FATAL here. */
1365 /*return (ARCHIVE_FATAL);*/
1368 if (rar->file_flags & FHD_LARGE)
1370 memcpy(packed_size, file_header.pack_size, 4);
1371 memcpy(packed_size + 4, p, 4); /* High pack size */
1373 memcpy(unp_size, file_header.unp_size, 4);
1374 memcpy(unp_size + 4, p, 4); /* High unpack size */
1376 rar->packed_size = archive_le64dec(&packed_size);
1377 rar->unp_size = archive_le64dec(&unp_size);
1381 rar->packed_size = archive_le32dec(file_header.pack_size);
1382 rar->unp_size = archive_le32dec(file_header.unp_size);
1385 if (rar->packed_size < 0 || rar->unp_size < 0)
1387 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1388 "Invalid sizes specified.");
1389 return (ARCHIVE_FATAL);
1392 rar->bytes_remaining = rar->packed_size;
1394 /* TODO: RARv3 subblocks contain comments. For now the complete block is
1395 * consumed at the end.
1397 if (head_type == NEWSUB_HEAD) {
1398 size_t distance = p - (const char *)h;
1399 header_size += rar->packed_size;
1400 /* Make sure we have the extended data. */
1401 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL)
1402 return (ARCHIVE_FATAL);
1404 endp = p + header_size - 7;
1408 filename_size = archive_le16dec(file_header.name_size);
1409 if (p + filename_size > endp) {
1410 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1411 "Invalid filename size");
1412 return (ARCHIVE_FATAL);
1414 if (rar->filename_allocated < filename_size * 2 + 2) {
1416 size_t newsize = filename_size * 2 + 2;
1417 newptr = realloc(rar->filename, newsize);
1418 if (newptr == NULL) {
1419 archive_set_error(&a->archive, ENOMEM,
1420 "Couldn't allocate memory.");
1421 return (ARCHIVE_FATAL);
1423 rar->filename = newptr;
1424 rar->filename_allocated = newsize;
1426 filename = rar->filename;
1427 memcpy(filename, p, filename_size);
1428 filename[filename_size] = '\0';
1429 if (rar->file_flags & FHD_UNICODE)
1431 if (filename_size != strlen(filename))
1433 unsigned char highbyte, flagbits, flagbyte;
1434 unsigned fn_end, offset;
1436 end = filename_size;
1437 fn_end = filename_size * 2;
1439 offset = (unsigned)strlen(filename) + 1;
1440 highbyte = *(p + offset++);
1443 while (offset < end && filename_size < fn_end)
1447 flagbyte = *(p + offset++);
1452 switch((flagbyte >> flagbits) & 3)
1455 filename[filename_size++] = '\0';
1456 filename[filename_size++] = *(p + offset++);
1459 filename[filename_size++] = highbyte;
1460 filename[filename_size++] = *(p + offset++);
1463 filename[filename_size++] = *(p + offset + 1);
1464 filename[filename_size++] = *(p + offset);
1470 uint8_t length = *(p + offset++);
1472 if (length & 0x80) {
1473 extra = *(p + offset++);
1474 high = (char)highbyte;
1477 length = (length & 0x7f) + 2;
1478 while (length && filename_size < fn_end) {
1479 unsigned cp = filename_size >> 1;
1480 filename[filename_size++] = high;
1481 filename[filename_size++] = p[cp] + extra;
1488 if (filename_size > fn_end) {
1489 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1490 "Invalid filename");
1491 return (ARCHIVE_FATAL);
1493 filename[filename_size++] = '\0';
1495 * Do not increment filename_size here as the computations below
1496 * add the space for the terminating NUL explicitly.
1498 filename[filename_size] = '\0';
1500 /* Decoded unicode form is UTF-16BE, so we have to update a string
1501 * conversion object for it. */
1502 if (rar->sconv_utf16be == NULL) {
1503 rar->sconv_utf16be = archive_string_conversion_from_charset(
1504 &a->archive, "UTF-16BE", 1);
1505 if (rar->sconv_utf16be == NULL)
1506 return (ARCHIVE_FATAL);
1508 fn_sconv = rar->sconv_utf16be;
1511 while (memcmp(strp, "\x00\x00", 2))
1513 if (!memcmp(strp, "\x00\\", 2))
1520 * If FHD_UNICODE is set but no unicode data, this file name form
1521 * is UTF-8, so we have to update a string conversion object for
1524 if (rar->sconv_utf8 == NULL) {
1525 rar->sconv_utf8 = archive_string_conversion_from_charset(
1526 &a->archive, "UTF-8", 1);
1527 if (rar->sconv_utf8 == NULL)
1528 return (ARCHIVE_FATAL);
1530 fn_sconv = rar->sconv_utf8;
1531 while ((strp = strchr(filename, '\\')) != NULL)
1539 while ((strp = strchr(filename, '\\')) != NULL)
1544 /* Split file in multivolume RAR. No more need to process header. */
1545 if (rar->filename_save &&
1546 filename_size == rar->filename_save_size &&
1547 !memcmp(rar->filename, rar->filename_save, filename_size + 1))
1549 __archive_read_consume(a, header_size - 7);
1551 if (rar->cursor >= rar->nodes)
1555 realloc(rar->dbo, sizeof(*rar->dbo) * rar->nodes)) == NULL)
1557 archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
1558 return (ARCHIVE_FATAL);
1560 rar->dbo[rar->cursor].header_size = header_size;
1561 rar->dbo[rar->cursor].start_offset = -1;
1562 rar->dbo[rar->cursor].end_offset = -1;
1564 if (rar->dbo[rar->cursor].start_offset < 0)
1566 rar->dbo[rar->cursor].start_offset = a->filter->position;
1567 rar->dbo[rar->cursor].end_offset = rar->dbo[rar->cursor].start_offset +
1573 rar->filename_save = (char*)realloc(rar->filename_save,
1575 memcpy(rar->filename_save, rar->filename, filename_size + 1);
1576 rar->filename_save_size = filename_size;
1578 /* Set info for seeking */
1580 if ((rar->dbo = calloc(1, sizeof(*rar->dbo))) == NULL)
1582 archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
1583 return (ARCHIVE_FATAL);
1585 rar->dbo[0].header_size = header_size;
1586 rar->dbo[0].start_offset = -1;
1587 rar->dbo[0].end_offset = -1;
1591 if (rar->file_flags & FHD_SALT)
1594 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1595 "Invalid header size");
1596 return (ARCHIVE_FATAL);
1598 memcpy(rar->salt, p, 8);
1602 if (rar->file_flags & FHD_EXTTIME) {
1603 if (read_exttime(p, rar, endp) < 0) {
1604 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1605 "Invalid header size");
1606 return (ARCHIVE_FATAL);
1610 __archive_read_consume(a, header_size - 7);
1611 rar->dbo[0].start_offset = a->filter->position;
1612 rar->dbo[0].end_offset = rar->dbo[0].start_offset + rar->packed_size;
1614 switch(file_header.host_os)
1619 rar->mode = archive_le32dec(file_header.file_attr);
1620 if (rar->mode & FILE_ATTRIBUTE_DIRECTORY)
1621 rar->mode = AE_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
1623 rar->mode = AE_IFREG;
1624 rar->mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
1630 rar->mode = archive_le32dec(file_header.file_attr);
1634 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1635 "Unknown file attributes from RAR file's host OS");
1636 return (ARCHIVE_FATAL);
1639 rar->bytes_uncopied = rar->bytes_unconsumed = 0;
1640 rar->lzss.position = rar->offset = 0;
1641 rar->offset_seek = 0;
1642 rar->dictionary_size = 0;
1643 rar->offset_outgoing = 0;
1644 rar->br.cache_avail = 0;
1645 rar->br.avail_in = 0;
1646 rar->crc_calculated = 0;
1649 rar->is_ppmd_block = 0;
1650 rar->start_new_table = 1;
1651 free(rar->unp_buffer);
1652 rar->unp_buffer = NULL;
1653 rar->unp_offset = 0;
1654 rar->unp_buffer_size = UNP_BUFFER_SIZE;
1655 memset(rar->lengthtable, 0, sizeof(rar->lengthtable));
1656 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context);
1657 rar->ppmd_valid = rar->ppmd_eod = 0;
1659 /* Don't set any archive entries for non-file header types */
1660 if (head_type == NEWSUB_HEAD)
1663 archive_entry_set_mtime(entry, rar->mtime, rar->mnsec);
1664 archive_entry_set_ctime(entry, rar->ctime, rar->cnsec);
1665 archive_entry_set_atime(entry, rar->atime, rar->ansec);
1666 archive_entry_set_size(entry, rar->unp_size);
1667 archive_entry_set_mode(entry, rar->mode);
1669 if (archive_entry_copy_pathname_l(entry, filename, filename_size, fn_sconv))
1671 if (errno == ENOMEM)
1673 archive_set_error(&a->archive, ENOMEM,
1674 "Can't allocate memory for Pathname");
1675 return (ARCHIVE_FATAL);
1677 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1678 "Pathname cannot be converted from %s to current locale.",
1679 archive_string_conversion_charset_name(fn_sconv));
1680 ret = (ARCHIVE_WARN);
1683 if (((rar->mode) & AE_IFMT) == AE_IFLNK)
1685 /* Make sure a symbolic-link file does not have its body. */
1686 rar->bytes_remaining = 0;
1687 archive_entry_set_size(entry, 0);
1689 /* Read a symbolic-link name. */
1690 if ((ret2 = read_symlink_stored(a, entry, sconv)) < (ARCHIVE_WARN))
1696 if (rar->bytes_remaining == 0)
1706 tm.tm_sec = 2 * (ttime & 0x1f);
1707 tm.tm_min = (ttime >> 5) & 0x3f;
1708 tm.tm_hour = (ttime >> 11) & 0x1f;
1709 tm.tm_mday = (ttime >> 16) & 0x1f;
1710 tm.tm_mon = ((ttime >> 21) & 0x0f) - 1;
1711 tm.tm_year = ((ttime >> 25) & 0x7f) + 80;
1717 read_exttime(const char *p, struct rar *rar, const char *endp)
1719 unsigned rmode, flags, rem, j, count;
1724 #if defined(HAVE_LOCALTIME_R) || defined(HAVE__LOCALTIME64_S)
1727 #if defined(HAVE__LOCALTIME64_S)
1734 flags = archive_le16dec(p);
1737 for (i = 3; i >= 0; i--)
1742 rmode = flags >> i * 4;
1749 ttime = archive_le32dec(p);
1750 t = get_time(ttime);
1755 if (p + count > endp)
1757 for (j = 0; j < count; j++)
1759 rem = (((unsigned)(unsigned char)*p) << 16) | (rem >> 8);
1762 #if defined(HAVE_LOCALTIME_R)
1763 tm = localtime_r(&t, &tmbuf);
1764 #elif defined(HAVE__LOCALTIME64_S)
1766 terr = _localtime64_s(&tmbuf, &tmptime);
1774 nsec = tm->tm_sec + rem / NS_UNIT;
1798 rar->arcnsec = nsec;
1806 read_symlink_stored(struct archive_read *a, struct archive_entry *entry,
1807 struct archive_string_conv *sconv)
1812 int ret = (ARCHIVE_OK);
1814 rar = (struct rar *)(a->format->data);
1815 if ((h = rar_read_ahead(a, (size_t)rar->packed_size, NULL)) == NULL)
1816 return (ARCHIVE_FATAL);
1819 if (archive_entry_copy_symlink_l(entry,
1820 p, (size_t)rar->packed_size, sconv))
1822 if (errno == ENOMEM)
1824 archive_set_error(&a->archive, ENOMEM,
1825 "Can't allocate memory for link");
1826 return (ARCHIVE_FATAL);
1828 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1829 "link cannot be converted from %s to current locale.",
1830 archive_string_conversion_charset_name(sconv));
1831 ret = (ARCHIVE_WARN);
1833 __archive_read_consume(a, rar->packed_size);
1838 read_data_stored(struct archive_read *a, const void **buff, size_t *size,
1842 ssize_t bytes_avail;
1844 rar = (struct rar *)(a->format->data);
1845 if (rar->bytes_remaining == 0 &&
1846 !(rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER))
1850 *offset = rar->offset;
1851 if (rar->file_crc != rar->crc_calculated) {
1852 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1854 return (ARCHIVE_FATAL);
1857 return (ARCHIVE_EOF);
1860 *buff = rar_read_ahead(a, 1, &bytes_avail);
1861 if (bytes_avail <= 0)
1863 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1864 "Truncated RAR file data");
1865 return (ARCHIVE_FATAL);
1868 *size = bytes_avail;
1869 *offset = rar->offset;
1870 rar->offset += bytes_avail;
1871 rar->offset_seek += bytes_avail;
1872 rar->bytes_remaining -= bytes_avail;
1873 rar->bytes_unconsumed = bytes_avail;
1874 /* Calculate File CRC. */
1875 rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1876 (unsigned)bytes_avail);
1877 return (ARCHIVE_OK);
1881 read_data_compressed(struct archive_read *a, const void **buff, size_t *size,
1882 int64_t *offset, size_t looper)
1884 if (looper++ > MAX_COMPRESS_DEPTH)
1885 return (ARCHIVE_FATAL);
1888 int64_t start, end, actualend;
1890 int ret = (ARCHIVE_OK), sym, code, lzss_offset, length, i;
1892 rar = (struct rar *)(a->format->data);
1896 return (ARCHIVE_FATAL);
1897 if (rar->ppmd_eod ||
1898 (rar->dictionary_size && rar->offset >= rar->unp_size))
1900 if (rar->unp_offset > 0) {
1902 * We have unprocessed extracted data. write it out.
1904 *buff = rar->unp_buffer;
1905 *size = rar->unp_offset;
1906 *offset = rar->offset_outgoing;
1907 rar->offset_outgoing += *size;
1908 /* Calculate File CRC. */
1909 rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1911 rar->unp_offset = 0;
1912 return (ARCHIVE_OK);
1916 *offset = rar->offset;
1917 if (rar->file_crc != rar->crc_calculated) {
1918 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1920 return (ARCHIVE_FATAL);
1923 return (ARCHIVE_EOF);
1926 if (!rar->is_ppmd_block && rar->dictionary_size && rar->bytes_uncopied > 0)
1928 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset))
1929 bs = rar->unp_buffer_size - rar->unp_offset;
1931 bs = (size_t)rar->bytes_uncopied;
1932 ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs);
1933 if (ret != ARCHIVE_OK)
1936 rar->bytes_uncopied -= bs;
1937 if (*buff != NULL) {
1938 rar->unp_offset = 0;
1939 *size = rar->unp_buffer_size;
1940 *offset = rar->offset_outgoing;
1941 rar->offset_outgoing += *size;
1942 /* Calculate File CRC. */
1943 rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1950 if (!rar->br.next_in &&
1951 (ret = rar_br_preparation(a, &(rar->br))) < ARCHIVE_WARN)
1953 if (rar->start_new_table && ((ret = parse_codes(a)) < (ARCHIVE_WARN)))
1956 if (rar->is_ppmd_block)
1958 if ((sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1959 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1961 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1963 return (ARCHIVE_FATAL);
1965 if(sym != rar->ppmd_escape)
1967 lzss_emit_literal(rar, sym);
1968 rar->bytes_uncopied++;
1972 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1973 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1975 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1977 return (ARCHIVE_FATAL);
1983 rar->start_new_table = 1;
1984 return read_data_compressed(a, buff, size, offset, looper);
1987 rar->ppmd_eod = 1;/* End Of ppmd Data. */
1991 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1992 "Parsing filters is unsupported.");
1993 return (ARCHIVE_FAILED);
1997 for (i = 2; i >= 0; i--)
1999 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
2000 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
2002 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2004 return (ARCHIVE_FATAL);
2006 lzss_offset |= code << (i * 8);
2008 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
2009 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
2011 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2013 return (ARCHIVE_FATAL);
2015 lzss_emit_match(rar, lzss_offset + 2, length + 32);
2016 rar->bytes_uncopied += length + 32;
2020 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
2021 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
2023 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2025 return (ARCHIVE_FATAL);
2027 lzss_emit_match(rar, 1, length + 4);
2028 rar->bytes_uncopied += length + 4;
2032 lzss_emit_literal(rar, sym);
2033 rar->bytes_uncopied++;
2039 start = rar->offset;
2040 end = start + rar->dictionary_size;
2041 rar->filterstart = INT64_MAX;
2043 if ((actualend = expand(a, end)) < 0)
2044 return ((int)actualend);
2046 rar->bytes_uncopied = actualend - start;
2047 if (rar->bytes_uncopied == 0) {
2048 /* Broken RAR files cause this case.
2049 * NOTE: If this case were possible on a normal RAR file
2050 * we would find out where it was actually bad and
2051 * what we would do to solve it. */
2052 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2053 "Internal error extracting RAR file");
2054 return (ARCHIVE_FATAL);
2057 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset))
2058 bs = rar->unp_buffer_size - rar->unp_offset;
2060 bs = (size_t)rar->bytes_uncopied;
2061 ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs);
2062 if (ret != ARCHIVE_OK)
2065 rar->bytes_uncopied -= bs;
2067 * If *buff is NULL, it means unp_buffer is not full.
2068 * So we have to continue extracting a RAR file.
2070 } while (*buff == NULL);
2072 rar->unp_offset = 0;
2073 *size = rar->unp_buffer_size;
2074 *offset = rar->offset_outgoing;
2075 rar->offset_outgoing += *size;
2076 /* Calculate File CRC. */
2077 rar->crc_calculated = crc32(rar->crc_calculated, *buff, (unsigned)*size);
2082 parse_codes(struct archive_read *a)
2084 int i, j, val, n, r;
2085 unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags;
2086 unsigned int maxorder;
2087 struct huffman_code precode;
2088 struct rar *rar = (struct rar *)(a->format->data);
2089 struct rar_br *br = &(rar->br);
2093 /* Skip to the next byte */
2094 rar_br_consume_unalined_bits(br);
2096 /* PPMd block flag */
2097 if (!rar_br_read_ahead(a, br, 1))
2098 goto truncated_data;
2099 if ((rar->is_ppmd_block = rar_br_bits(br, 1)) != 0)
2101 rar_br_consume(br, 1);
2102 if (!rar_br_read_ahead(a, br, 7))
2103 goto truncated_data;
2104 ppmd_flags = rar_br_bits(br, 7);
2105 rar_br_consume(br, 7);
2107 /* Memory is allocated in MB */
2108 if (ppmd_flags & 0x20)
2110 if (!rar_br_read_ahead(a, br, 8))
2111 goto truncated_data;
2112 rar->dictionary_size = (rar_br_bits(br, 8) + 1) << 20;
2113 rar_br_consume(br, 8);
2116 if (ppmd_flags & 0x40)
2118 if (!rar_br_read_ahead(a, br, 8))
2119 goto truncated_data;
2120 rar->ppmd_escape = rar->ppmd7_context.InitEsc = rar_br_bits(br, 8);
2121 rar_br_consume(br, 8);
2124 rar->ppmd_escape = 2;
2126 if (ppmd_flags & 0x20)
2128 maxorder = (ppmd_flags & 0x1F) + 1;
2130 maxorder = 16 + (maxorder - 16) * 3;
2134 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2135 "Truncated RAR file data");
2136 return (ARCHIVE_FATAL);
2139 /* Make sure ppmd7_contest is freed before Ppmd7_Construct
2140 * because reading a broken file cause this abnormal sequence. */
2141 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context);
2144 rar->bytein.Read = &ppmd_read;
2145 __archive_ppmd7_functions.PpmdRAR_RangeDec_CreateVTable(&rar->range_dec);
2146 rar->range_dec.Stream = &rar->bytein;
2147 __archive_ppmd7_functions.Ppmd7_Construct(&rar->ppmd7_context);
2149 if (rar->dictionary_size == 0) {
2150 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2151 "Invalid zero dictionary size");
2152 return (ARCHIVE_FATAL);
2155 if (!__archive_ppmd7_functions.Ppmd7_Alloc(&rar->ppmd7_context,
2156 rar->dictionary_size))
2158 archive_set_error(&a->archive, ENOMEM,
2160 return (ARCHIVE_FATAL);
2162 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec))
2164 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2165 "Unable to initialize PPMd range decoder");
2166 return (ARCHIVE_FATAL);
2168 __archive_ppmd7_functions.Ppmd7_Init(&rar->ppmd7_context, maxorder);
2169 rar->ppmd_valid = 1;
2173 if (!rar->ppmd_valid) {
2174 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2175 "Invalid PPMd sequence");
2176 return (ARCHIVE_FATAL);
2178 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec))
2180 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2181 "Unable to initialize PPMd range decoder");
2182 return (ARCHIVE_FATAL);
2188 rar_br_consume(br, 1);
2190 /* Keep existing table flag */
2191 if (!rar_br_read_ahead(a, br, 1))
2192 goto truncated_data;
2193 if (!rar_br_bits(br, 1))
2194 memset(rar->lengthtable, 0, sizeof(rar->lengthtable));
2195 rar_br_consume(br, 1);
2197 memset(&bitlengths, 0, sizeof(bitlengths));
2198 for (i = 0; i < MAX_SYMBOLS;)
2200 if (!rar_br_read_ahead(a, br, 4))
2201 goto truncated_data;
2202 bitlengths[i++] = rar_br_bits(br, 4);
2203 rar_br_consume(br, 4);
2204 if (bitlengths[i-1] == 0xF)
2206 if (!rar_br_read_ahead(a, br, 4))
2207 goto truncated_data;
2208 zerocount = rar_br_bits(br, 4);
2209 rar_br_consume(br, 4);
2213 for (j = 0; j < zerocount + 2 && i < MAX_SYMBOLS; j++)
2214 bitlengths[i++] = 0;
2219 memset(&precode, 0, sizeof(precode));
2220 r = create_code(a, &precode, bitlengths, MAX_SYMBOLS, MAX_SYMBOL_LENGTH);
2221 if (r != ARCHIVE_OK) {
2223 free(precode.table);
2227 for (i = 0; i < HUFFMAN_TABLE_SIZE;)
2229 if ((val = read_next_symbol(a, &precode)) < 0) {
2231 free(precode.table);
2232 return (ARCHIVE_FATAL);
2236 rar->lengthtable[i] = (rar->lengthtable[i] + val) & 0xF;
2244 free(precode.table);
2245 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2246 "Internal error extracting RAR file.");
2247 return (ARCHIVE_FATAL);
2251 if (!rar_br_read_ahead(a, br, 3)) {
2253 free(precode.table);
2254 goto truncated_data;
2256 n = rar_br_bits(br, 3) + 3;
2257 rar_br_consume(br, 3);
2259 if (!rar_br_read_ahead(a, br, 7)) {
2261 free(precode.table);
2262 goto truncated_data;
2264 n = rar_br_bits(br, 7) + 11;
2265 rar_br_consume(br, 7);
2268 for (j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++)
2270 rar->lengthtable[i] = rar->lengthtable[i-1];
2277 if (!rar_br_read_ahead(a, br, 3)) {
2279 free(precode.table);
2280 goto truncated_data;
2282 n = rar_br_bits(br, 3) + 3;
2283 rar_br_consume(br, 3);
2285 if (!rar_br_read_ahead(a, br, 7)) {
2287 free(precode.table);
2288 goto truncated_data;
2290 n = rar_br_bits(br, 7) + 11;
2291 rar_br_consume(br, 7);
2294 for(j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++)
2295 rar->lengthtable[i++] = 0;
2299 free(precode.table);
2301 r = create_code(a, &rar->maincode, &rar->lengthtable[0], MAINCODE_SIZE,
2303 if (r != ARCHIVE_OK)
2305 r = create_code(a, &rar->offsetcode, &rar->lengthtable[MAINCODE_SIZE],
2306 OFFSETCODE_SIZE, MAX_SYMBOL_LENGTH);
2307 if (r != ARCHIVE_OK)
2309 r = create_code(a, &rar->lowoffsetcode,
2310 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE],
2311 LOWOFFSETCODE_SIZE, MAX_SYMBOL_LENGTH);
2312 if (r != ARCHIVE_OK)
2314 r = create_code(a, &rar->lengthcode,
2315 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE +
2316 LOWOFFSETCODE_SIZE], LENGTHCODE_SIZE, MAX_SYMBOL_LENGTH);
2317 if (r != ARCHIVE_OK)
2321 if (!rar->dictionary_size || !rar->lzss.window)
2323 /* Seems as though dictionary sizes are not used. Even so, minimize
2324 * memory usage as much as possible.
2327 unsigned int new_size;
2329 if (rar->unp_size >= DICTIONARY_MAX_SIZE)
2330 new_size = DICTIONARY_MAX_SIZE;
2332 new_size = rar_fls((unsigned int)rar->unp_size) << 1;
2333 new_window = realloc(rar->lzss.window, new_size);
2334 if (new_window == NULL) {
2335 archive_set_error(&a->archive, ENOMEM,
2336 "Unable to allocate memory for uncompressed data.");
2337 return (ARCHIVE_FATAL);
2339 rar->lzss.window = (unsigned char *)new_window;
2340 rar->dictionary_size = new_size;
2341 memset(rar->lzss.window, 0, rar->dictionary_size);
2342 rar->lzss.mask = rar->dictionary_size - 1;
2345 rar->start_new_table = 0;
2346 return (ARCHIVE_OK);
2348 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2349 "Truncated RAR file data");
2351 return (ARCHIVE_FATAL);
2355 free_codes(struct archive_read *a)
2357 struct rar *rar = (struct rar *)(a->format->data);
2358 free(rar->maincode.tree);
2359 free(rar->offsetcode.tree);
2360 free(rar->lowoffsetcode.tree);
2361 free(rar->lengthcode.tree);
2362 free(rar->maincode.table);
2363 free(rar->offsetcode.table);
2364 free(rar->lowoffsetcode.table);
2365 free(rar->lengthcode.table);
2366 memset(&rar->maincode, 0, sizeof(rar->maincode));
2367 memset(&rar->offsetcode, 0, sizeof(rar->offsetcode));
2368 memset(&rar->lowoffsetcode, 0, sizeof(rar->lowoffsetcode));
2369 memset(&rar->lengthcode, 0, sizeof(rar->lengthcode));
2374 read_next_symbol(struct archive_read *a, struct huffman_code *code)
2378 int length, value, node;
2384 if (make_table(a, code) != (ARCHIVE_OK))
2388 rar = (struct rar *)(a->format->data);
2391 /* Look ahead (peek) at bits */
2392 if (!rar_br_read_ahead(a, br, code->tablesize)) {
2393 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2394 "Truncated RAR file data");
2398 bits = rar_br_bits(br, code->tablesize);
2400 length = code->table[bits].length;
2401 value = code->table[bits].value;
2405 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2406 "Invalid prefix code in bitstream");
2410 if (length <= code->tablesize)
2412 /* Skip length bits */
2413 rar_br_consume(br, length);
2417 /* Skip tablesize bits */
2418 rar_br_consume(br, code->tablesize);
2421 while (!(code->tree[node].branches[0] ==
2422 code->tree[node].branches[1]))
2424 if (!rar_br_read_ahead(a, br, 1)) {
2425 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2426 "Truncated RAR file data");
2430 bit = rar_br_bits(br, 1);
2431 rar_br_consume(br, 1);
2433 if (code->tree[node].branches[bit] < 0)
2435 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2436 "Invalid prefix code in bitstream");
2439 node = code->tree[node].branches[bit];
2442 return code->tree[node].branches[0];
2446 create_code(struct archive_read *a, struct huffman_code *code,
2447 unsigned char *lengths, int numsymbols, char maxlength)
2449 int i, j, codebits = 0, symbolsleft = numsymbols;
2451 code->numentries = 0;
2452 code->numallocatedentries = 0;
2453 if (new_node(code) < 0) {
2454 archive_set_error(&a->archive, ENOMEM,
2455 "Unable to allocate memory for node data.");
2456 return (ARCHIVE_FATAL);
2458 code->numentries = 1;
2459 code->minlength = INT_MAX;
2460 code->maxlength = INT_MIN;
2462 for(i = 1; i <= maxlength; i++)
2464 for(j = 0; j < numsymbols; j++)
2466 if (lengths[j] != i) continue;
2467 if (add_value(a, code, j, codebits, i) != ARCHIVE_OK)
2468 return (ARCHIVE_FATAL);
2470 if (--symbolsleft <= 0)
2473 if (symbolsleft <= 0)
2477 return (ARCHIVE_OK);
2481 add_value(struct archive_read *a, struct huffman_code *code, int value,
2482 int codebits, int length)
2484 int lastnode, bitpos, bit;
2485 /* int repeatpos, repeatnode, nextnode; */
2490 if(length > code->maxlength)
2491 code->maxlength = length;
2492 if(length < code->minlength)
2493 code->minlength = length;
2496 * Dead code, repeatpos was is -1
2499 if (repeatpos == 0 || (repeatpos >= 0
2500 && (((codebits >> (repeatpos - 1)) & 3) == 0
2501 || ((codebits >> (repeatpos - 1)) & 3) == 3)))
2503 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2504 "Invalid repeat position");
2505 return (ARCHIVE_FATAL);
2510 for (bitpos = length - 1; bitpos >= 0; bitpos--)
2512 bit = (codebits >> bitpos) & 1;
2514 /* Leaf node check */
2515 if (code->tree[lastnode].branches[0] ==
2516 code->tree[lastnode].branches[1])
2518 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2520 return (ARCHIVE_FATAL);
2524 * Dead code, repeatpos was -1, bitpos >=0
2526 if (bitpos == repeatpos)
2528 * Open branch check *
2529 if (!(code->tree[lastnode].branches[bit] < 0))
2531 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2532 "Invalid repeating code");
2533 return (ARCHIVE_FATAL);
2536 if ((repeatnode = new_node(code)) < 0) {
2537 archive_set_error(&a->archive, ENOMEM,
2538 "Unable to allocate memory for node data.");
2539 return (ARCHIVE_FATAL);
2541 if ((nextnode = new_node(code)) < 0) {
2542 archive_set_error(&a->archive, ENOMEM,
2543 "Unable to allocate memory for node data.");
2544 return (ARCHIVE_FATAL);
2548 code->tree[lastnode].branches[bit] = repeatnode;
2549 code->tree[repeatnode].branches[bit] = repeatnode;
2550 code->tree[repeatnode].branches[bit^1] = nextnode;
2551 lastnode = nextnode;
2553 bitpos++; * terminating bit already handled, skip it *
2558 /* Open branch check */
2559 if (code->tree[lastnode].branches[bit] < 0)
2561 if (new_node(code) < 0) {
2562 archive_set_error(&a->archive, ENOMEM,
2563 "Unable to allocate memory for node data.");
2564 return (ARCHIVE_FATAL);
2566 code->tree[lastnode].branches[bit] = code->numentries++;
2570 lastnode = code->tree[lastnode].branches[bit];
2574 if (!(code->tree[lastnode].branches[0] == -1
2575 && code->tree[lastnode].branches[1] == -2))
2577 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2579 return (ARCHIVE_FATAL);
2582 /* Set leaf value */
2583 code->tree[lastnode].branches[0] = value;
2584 code->tree[lastnode].branches[1] = value;
2586 return (ARCHIVE_OK);
2590 new_node(struct huffman_code *code)
2593 if (code->numallocatedentries == code->numentries) {
2594 int new_num_entries = 256;
2595 if (code->numentries > 0) {
2596 new_num_entries = code->numentries * 2;
2598 new_tree = realloc(code->tree, new_num_entries * sizeof(*code->tree));
2599 if (new_tree == NULL)
2601 code->tree = (struct huffman_tree_node *)new_tree;
2602 code->numallocatedentries = new_num_entries;
2604 code->tree[code->numentries].branches[0] = -1;
2605 code->tree[code->numentries].branches[1] = -2;
2610 make_table(struct archive_read *a, struct huffman_code *code)
2612 if (code->maxlength < code->minlength || code->maxlength > 10)
2613 code->tablesize = 10;
2615 code->tablesize = code->maxlength;
2618 (struct huffman_table_entry *)calloc(1, sizeof(*code->table)
2619 * ((size_t)1 << code->tablesize));
2621 return make_table_recurse(a, code, 0, code->table, 0, code->tablesize);
2625 make_table_recurse(struct archive_read *a, struct huffman_code *code, int node,
2626 struct huffman_table_entry *table, int depth,
2629 int currtablesize, i, ret = (ARCHIVE_OK);
2633 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2634 "Huffman tree was not created.");
2635 return (ARCHIVE_FATAL);
2637 if (node < 0 || node >= code->numentries)
2639 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2640 "Invalid location to Huffman tree specified.");
2641 return (ARCHIVE_FATAL);
2644 currtablesize = 1 << (maxdepth - depth);
2646 if (code->tree[node].branches[0] ==
2647 code->tree[node].branches[1])
2649 for(i = 0; i < currtablesize; i++)
2651 table[i].length = depth;
2652 table[i].value = code->tree[node].branches[0];
2656 * Dead code, node >= 0
2660 for(i = 0; i < currtablesize; i++)
2661 table[i].length = -1;
2666 if(depth == maxdepth)
2668 table[0].length = maxdepth + 1;
2669 table[0].value = node;
2673 ret |= make_table_recurse(a, code, code->tree[node].branches[0], table,
2674 depth + 1, maxdepth);
2675 ret |= make_table_recurse(a, code, code->tree[node].branches[1],
2676 table + currtablesize / 2, depth + 1, maxdepth);
2683 expand(struct archive_read *a, int64_t end)
2685 static const unsigned char lengthbases[] =
2686 { 0, 1, 2, 3, 4, 5, 6,
2687 7, 8, 10, 12, 14, 16, 20,
2688 24, 28, 32, 40, 48, 56, 64,
2689 80, 96, 112, 128, 160, 192, 224 };
2690 static const unsigned char lengthbits[] =
2691 { 0, 0, 0, 0, 0, 0, 0,
2692 0, 1, 1, 1, 1, 2, 2,
2693 2, 2, 3, 3, 3, 3, 4,
2694 4, 4, 4, 5, 5, 5, 5 };
2695 static const int lengthb_min = minimum(
2696 (int)(sizeof(lengthbases)/sizeof(lengthbases[0])),
2697 (int)(sizeof(lengthbits)/sizeof(lengthbits[0]))
2699 static const unsigned int offsetbases[] =
2701 8, 12, 16, 24, 32, 48,
2702 64, 96, 128, 192, 256, 384,
2703 512, 768, 1024, 1536, 2048, 3072,
2704 4096, 6144, 8192, 12288, 16384, 24576,
2705 32768, 49152, 65536, 98304, 131072, 196608,
2706 262144, 327680, 393216, 458752, 524288, 589824,
2707 655360, 720896, 786432, 851968, 917504, 983040,
2708 1048576, 1310720, 1572864, 1835008, 2097152, 2359296,
2709 2621440, 2883584, 3145728, 3407872, 3670016, 3932160 };
2710 static const unsigned char offsetbits[] =
2711 { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4,
2712 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
2713 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
2714 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
2715 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 };
2716 static const int offsetb_min = minimum(
2717 (int)(sizeof(offsetbases)/sizeof(offsetbases[0])),
2718 (int)(sizeof(offsetbits)/sizeof(offsetbits[0]))
2720 static const unsigned char shortbases[] =
2721 { 0, 4, 8, 16, 32, 64, 128, 192 };
2722 static const unsigned char shortbits[] =
2723 { 2, 2, 3, 4, 5, 6, 6, 6 };
2725 int symbol, offs, len, offsindex, lensymbol, i, offssymbol, lowoffsetsymbol;
2726 unsigned char newfile;
2727 struct rar *rar = (struct rar *)(a->format->data);
2728 struct rar_br *br = &(rar->br);
2730 if (rar->filterstart < end)
2731 end = rar->filterstart;
2735 if (rar->output_last_match &&
2736 lzss_position(&rar->lzss) + rar->lastlength <= end)
2738 lzss_emit_match(rar, rar->lastoffset, rar->lastlength);
2739 rar->output_last_match = 0;
2742 if(rar->is_ppmd_block || rar->output_last_match ||
2743 lzss_position(&rar->lzss) >= end)
2744 return lzss_position(&rar->lzss);
2746 if ((symbol = read_next_symbol(a, &rar->maincode)) < 0)
2747 return (ARCHIVE_FATAL);
2748 rar->output_last_match = 0;
2752 lzss_emit_literal(rar, symbol);
2755 else if (symbol == 256)
2757 if (!rar_br_read_ahead(a, br, 1))
2758 goto truncated_data;
2759 newfile = !rar_br_bits(br, 1);
2760 rar_br_consume(br, 1);
2764 rar->start_new_block = 1;
2765 if (!rar_br_read_ahead(a, br, 1))
2766 goto truncated_data;
2767 rar->start_new_table = rar_br_bits(br, 1);
2768 rar_br_consume(br, 1);
2769 return lzss_position(&rar->lzss);
2773 if (parse_codes(a) != ARCHIVE_OK)
2774 return (ARCHIVE_FATAL);
2778 else if(symbol==257)
2780 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2781 "Parsing filters is unsupported.");
2782 return (ARCHIVE_FAILED);
2784 else if(symbol==258)
2786 if(rar->lastlength == 0)
2789 offs = rar->lastoffset;
2790 len = rar->lastlength;
2792 else if (symbol <= 262)
2794 offsindex = symbol - 259;
2795 offs = rar->oldoffset[offsindex];
2797 if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0)
2799 if (lensymbol > lengthb_min)
2801 len = lengthbases[lensymbol] + 2;
2802 if (lengthbits[lensymbol] > 0) {
2803 if (!rar_br_read_ahead(a, br, lengthbits[lensymbol]))
2804 goto truncated_data;
2805 len += rar_br_bits(br, lengthbits[lensymbol]);
2806 rar_br_consume(br, lengthbits[lensymbol]);
2809 for (i = offsindex; i > 0; i--)
2810 rar->oldoffset[i] = rar->oldoffset[i-1];
2811 rar->oldoffset[0] = offs;
2813 else if(symbol<=270)
2815 offs = shortbases[symbol-263] + 1;
2816 if(shortbits[symbol-263] > 0) {
2817 if (!rar_br_read_ahead(a, br, shortbits[symbol-263]))
2818 goto truncated_data;
2819 offs += rar_br_bits(br, shortbits[symbol-263]);
2820 rar_br_consume(br, shortbits[symbol-263]);
2825 for(i = 3; i > 0; i--)
2826 rar->oldoffset[i] = rar->oldoffset[i-1];
2827 rar->oldoffset[0] = offs;
2831 if (symbol-271 > lengthb_min)
2833 len = lengthbases[symbol-271]+3;
2834 if(lengthbits[symbol-271] > 0) {
2835 if (!rar_br_read_ahead(a, br, lengthbits[symbol-271]))
2836 goto truncated_data;
2837 len += rar_br_bits(br, lengthbits[symbol-271]);
2838 rar_br_consume(br, lengthbits[symbol-271]);
2841 if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0)
2843 if (offssymbol > offsetb_min)
2845 offs = offsetbases[offssymbol]+1;
2846 if(offsetbits[offssymbol] > 0)
2850 if(offsetbits[offssymbol] > 4) {
2851 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol] - 4))
2852 goto truncated_data;
2853 offs += rar_br_bits(br, offsetbits[offssymbol] - 4) << 4;
2854 rar_br_consume(br, offsetbits[offssymbol] - 4);
2857 if(rar->numlowoffsetrepeats > 0)
2859 rar->numlowoffsetrepeats--;
2860 offs += rar->lastlowoffset;
2864 if ((lowoffsetsymbol =
2865 read_next_symbol(a, &rar->lowoffsetcode)) < 0)
2866 return (ARCHIVE_FATAL);
2867 if(lowoffsetsymbol == 16)
2869 rar->numlowoffsetrepeats = 15;
2870 offs += rar->lastlowoffset;
2874 offs += lowoffsetsymbol;
2875 rar->lastlowoffset = lowoffsetsymbol;
2880 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol]))
2881 goto truncated_data;
2882 offs += rar_br_bits(br, offsetbits[offssymbol]);
2883 rar_br_consume(br, offsetbits[offssymbol]);
2887 if (offs >= 0x40000)
2892 for(i = 3; i > 0; i--)
2893 rar->oldoffset[i] = rar->oldoffset[i-1];
2894 rar->oldoffset[0] = offs;
2897 rar->lastoffset = offs;
2898 rar->lastlength = len;
2899 rar->output_last_match = 1;
2902 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2903 "Truncated RAR file data");
2905 return (ARCHIVE_FATAL);
2907 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2908 "Bad RAR file data");
2909 return (ARCHIVE_FATAL);
2913 copy_from_lzss_window(struct archive_read *a, const void **buffer,
2914 int64_t startpos, int length)
2916 int windowoffs, firstpart;
2917 struct rar *rar = (struct rar *)(a->format->data);
2919 if (!rar->unp_buffer)
2921 if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL)
2923 archive_set_error(&a->archive, ENOMEM,
2924 "Unable to allocate memory for uncompressed data.");
2925 return (ARCHIVE_FATAL);
2929 windowoffs = lzss_offset_for_position(&rar->lzss, startpos);
2930 if(windowoffs + length <= lzss_size(&rar->lzss)) {
2931 memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs],
2933 } else if (length <= lzss_size(&rar->lzss)) {
2934 firstpart = lzss_size(&rar->lzss) - windowoffs;
2935 if (firstpart < 0) {
2936 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2937 "Bad RAR file data");
2938 return (ARCHIVE_FATAL);
2940 if (firstpart < length) {
2941 memcpy(&rar->unp_buffer[rar->unp_offset],
2942 &rar->lzss.window[windowoffs], firstpart);
2943 memcpy(&rar->unp_buffer[rar->unp_offset + firstpart],
2944 &rar->lzss.window[0], length - firstpart);
2946 memcpy(&rar->unp_buffer[rar->unp_offset],
2947 &rar->lzss.window[windowoffs], length);
2950 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2951 "Bad RAR file data");
2952 return (ARCHIVE_FATAL);
2954 rar->unp_offset += length;
2955 if (rar->unp_offset >= rar->unp_buffer_size)
2956 *buffer = rar->unp_buffer;
2959 return (ARCHIVE_OK);
2963 rar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail)
2965 struct rar *rar = (struct rar *)(a->format->data);
2966 const void *h = __archive_read_ahead(a, min, avail);
2970 if (a->archive.read_data_is_posix_read && *avail > (ssize_t)a->archive.read_data_requested)
2971 *avail = a->archive.read_data_requested;
2972 if (*avail > rar->bytes_remaining)
2973 *avail = (ssize_t)rar->bytes_remaining;
2976 else if (*avail == 0 && rar->main_flags & MHD_VOLUME &&
2977 rar->file_flags & FHD_SPLIT_AFTER)
2979 ret = archive_read_format_rar_read_header(a, a->entry);
2980 if (ret == (ARCHIVE_EOF))
2982 rar->has_endarc_header = 1;
2983 ret = archive_read_format_rar_read_header(a, a->entry);
2985 if (ret != (ARCHIVE_OK))
2987 return rar_read_ahead(a, min, avail);