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
151 /* Fields common to all headers */
160 /* Fields common to all file headers */
161 struct rar_file_header
174 struct huffman_tree_node
179 struct huffman_table_entry
187 struct huffman_tree_node *tree;
189 int numallocatedentries;
193 struct huffman_table_entry *table;
198 unsigned char *window;
203 struct data_block_offsets
206 int64_t start_offset;
212 /* Entries from main RAR header */
214 unsigned long file_crc;
219 /* File header entries */
220 char compression_method;
229 size_t filename_save_size;
230 size_t filename_allocated;
232 /* File header optional entries */
241 /* Fields to help with tracking decompression of files. */
242 int64_t bytes_unconsumed;
243 int64_t bytes_remaining;
244 int64_t bytes_uncopied;
246 int64_t offset_outgoing;
249 unsigned int unp_offset;
250 unsigned int unp_buffer_size;
251 unsigned char *unp_buffer;
252 unsigned int dictionary_size;
253 char start_new_block;
255 unsigned long crc_calculated;
256 int found_first_header;
257 char has_endarc_header;
258 struct data_block_offsets *dbo;
263 struct huffman_code maincode;
264 struct huffman_code offsetcode;
265 struct huffman_code lowoffsetcode;
266 struct huffman_code lengthcode;
267 unsigned char lengthtable[HUFFMAN_TABLE_SIZE];
269 char output_last_match;
270 unsigned int lastlength;
271 unsigned int lastoffset;
272 unsigned int oldoffset[4];
273 unsigned int lastlowoffset;
274 unsigned int numlowoffsetrepeats;
276 char start_new_table;
278 /* PPMd Variant H members */
283 CPpmd7 ppmd7_context;
284 CPpmd7z_RangeDec range_dec;
288 * String conversion object.
290 int init_default_conversion;
291 struct archive_string_conv *sconv_default;
292 struct archive_string_conv *opt_sconv;
293 struct archive_string_conv *sconv_utf8;
294 struct archive_string_conv *sconv_utf16be;
300 #define CACHE_TYPE uint64_t
301 #define CACHE_BITS (8 * sizeof(CACHE_TYPE))
303 CACHE_TYPE cache_buffer;
304 /* Indicates how many bits avail in cache_buffer. */
307 const unsigned char *next_in;
311 * Custom field to denote that this archive contains encrypted entries
313 int has_encrypted_entries;
316 static int archive_read_support_format_rar_capabilities(struct archive_read *);
317 static int archive_read_format_rar_has_encrypted_entries(struct archive_read *);
318 static int archive_read_format_rar_bid(struct archive_read *, int);
319 static int archive_read_format_rar_options(struct archive_read *,
320 const char *, const char *);
321 static int archive_read_format_rar_read_header(struct archive_read *,
322 struct archive_entry *);
323 static int archive_read_format_rar_read_data(struct archive_read *,
324 const void **, size_t *, int64_t *);
325 static int archive_read_format_rar_read_data_skip(struct archive_read *a);
326 static int64_t archive_read_format_rar_seek_data(struct archive_read *, int64_t,
328 static int archive_read_format_rar_cleanup(struct archive_read *);
330 /* Support functions */
331 static int read_header(struct archive_read *, struct archive_entry *, char);
332 static time_t get_time(int);
333 static int read_exttime(const char *, struct rar *, const char *);
334 static int read_symlink_stored(struct archive_read *, struct archive_entry *,
335 struct archive_string_conv *);
336 static int read_data_stored(struct archive_read *, const void **, size_t *,
338 static int read_data_compressed(struct archive_read *, const void **, size_t *,
340 static int rar_br_preparation(struct archive_read *, struct rar_br *);
341 static int parse_codes(struct archive_read *);
342 static void free_codes(struct archive_read *);
343 static int read_next_symbol(struct archive_read *, struct huffman_code *);
344 static int create_code(struct archive_read *, struct huffman_code *,
345 unsigned char *, int, char);
346 static int add_value(struct archive_read *, struct huffman_code *, int, int,
348 static int new_node(struct huffman_code *);
349 static int make_table(struct archive_read *, struct huffman_code *);
350 static int make_table_recurse(struct archive_read *, struct huffman_code *, int,
351 struct huffman_table_entry *, int, int);
352 static int64_t expand(struct archive_read *, int64_t);
353 static int copy_from_lzss_window(struct archive_read *, const void **,
355 static const void *rar_read_ahead(struct archive_read *, size_t, ssize_t *);
360 /* Check that the cache buffer has enough bits. */
361 #define rar_br_has(br, n) ((br)->cache_avail >= n)
362 /* Get compressed data by bit. */
363 #define rar_br_bits(br, n) \
364 (((uint32_t)((br)->cache_buffer >> \
365 ((br)->cache_avail - (n)))) & cache_masks[n])
366 #define rar_br_bits_forced(br, n) \
367 (((uint32_t)((br)->cache_buffer << \
368 ((n) - (br)->cache_avail))) & cache_masks[n])
369 /* Read ahead to make sure the cache buffer has enough compressed data we
371 * True : completed, there is enough data in the cache buffer.
372 * False : there is no data in the stream. */
373 #define rar_br_read_ahead(a, br, n) \
374 ((rar_br_has(br, (n)) || rar_br_fillup(a, br)) || rar_br_has(br, (n)))
375 /* Notify how many bits we consumed. */
376 #define rar_br_consume(br, n) ((br)->cache_avail -= (n))
377 #define rar_br_consume_unalined_bits(br) ((br)->cache_avail &= ~7)
379 static const uint32_t cache_masks[] = {
380 0x00000000, 0x00000001, 0x00000003, 0x00000007,
381 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F,
382 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,
383 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF,
384 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF,
385 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,
386 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF,
387 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF,
388 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
392 * Shift away used bits in the cache data and fill it up with following bits.
393 * Call this when cache buffer does not have enough bits you need.
395 * Returns 1 if the cache buffer is full.
396 * Returns 0 if the cache buffer is not full; input buffer is empty.
399 rar_br_fillup(struct archive_read *a, struct rar_br *br)
401 struct rar *rar = (struct rar *)(a->format->data);
402 int n = CACHE_BITS - br->cache_avail;
407 if (br->avail_in >= 8) {
409 ((uint64_t)br->next_in[0]) << 56 |
410 ((uint64_t)br->next_in[1]) << 48 |
411 ((uint64_t)br->next_in[2]) << 40 |
412 ((uint64_t)br->next_in[3]) << 32 |
413 ((uint32_t)br->next_in[4]) << 24 |
414 ((uint32_t)br->next_in[5]) << 16 |
415 ((uint32_t)br->next_in[6]) << 8 |
416 (uint32_t)br->next_in[7];
419 br->cache_avail += 8 * 8;
420 rar->bytes_unconsumed += 8;
421 rar->bytes_remaining -= 8;
426 if (br->avail_in >= 7) {
428 (br->cache_buffer << 56) |
429 ((uint64_t)br->next_in[0]) << 48 |
430 ((uint64_t)br->next_in[1]) << 40 |
431 ((uint64_t)br->next_in[2]) << 32 |
432 ((uint32_t)br->next_in[3]) << 24 |
433 ((uint32_t)br->next_in[4]) << 16 |
434 ((uint32_t)br->next_in[5]) << 8 |
435 (uint32_t)br->next_in[6];
438 br->cache_avail += 7 * 8;
439 rar->bytes_unconsumed += 7;
440 rar->bytes_remaining -= 7;
445 if (br->avail_in >= 6) {
447 (br->cache_buffer << 48) |
448 ((uint64_t)br->next_in[0]) << 40 |
449 ((uint64_t)br->next_in[1]) << 32 |
450 ((uint32_t)br->next_in[2]) << 24 |
451 ((uint32_t)br->next_in[3]) << 16 |
452 ((uint32_t)br->next_in[4]) << 8 |
453 (uint32_t)br->next_in[5];
456 br->cache_avail += 6 * 8;
457 rar->bytes_unconsumed += 6;
458 rar->bytes_remaining -= 6;
463 /* We have enough compressed data in
464 * the cache buffer.*/
469 if (br->avail_in <= 0) {
471 if (rar->bytes_unconsumed > 0) {
472 /* Consume as much as the decompressor
474 __archive_read_consume(a, rar->bytes_unconsumed);
475 rar->bytes_unconsumed = 0;
477 br->next_in = rar_read_ahead(a, 1, &(br->avail_in));
478 if (br->next_in == NULL)
480 if (br->avail_in == 0)
484 (br->cache_buffer << 8) | *br->next_in++;
486 br->cache_avail += 8;
488 rar->bytes_unconsumed++;
489 rar->bytes_remaining--;
494 rar_br_preparation(struct archive_read *a, struct rar_br *br)
496 struct rar *rar = (struct rar *)(a->format->data);
498 if (rar->bytes_remaining > 0) {
499 br->next_in = rar_read_ahead(a, 1, &(br->avail_in));
500 if (br->next_in == NULL) {
501 archive_set_error(&a->archive,
502 ARCHIVE_ERRNO_FILE_FORMAT,
503 "Truncated RAR file data");
504 return (ARCHIVE_FATAL);
506 if (br->cache_avail == 0)
507 (void)rar_br_fillup(a, br);
512 /* Find last bit set */
514 rar_fls(unsigned int word)
520 word |= (word >> 16);
521 return word - (word >> 1);
525 static inline int64_t
526 lzss_position(struct lzss *lzss)
528 return lzss->position;
532 lzss_mask(struct lzss *lzss)
538 lzss_size(struct lzss *lzss)
540 return lzss->mask + 1;
544 lzss_offset_for_position(struct lzss *lzss, int64_t pos)
546 return (int)(pos & lzss->mask);
549 static inline unsigned char *
550 lzss_pointer_for_position(struct lzss *lzss, int64_t pos)
552 return &lzss->window[lzss_offset_for_position(lzss, pos)];
556 lzss_current_offset(struct lzss *lzss)
558 return lzss_offset_for_position(lzss, lzss->position);
561 static inline uint8_t *
562 lzss_current_pointer(struct lzss *lzss)
564 return lzss_pointer_for_position(lzss, lzss->position);
568 lzss_emit_literal(struct rar *rar, uint8_t literal)
570 *lzss_current_pointer(&rar->lzss) = literal;
571 rar->lzss.position++;
575 lzss_emit_match(struct rar *rar, int offset, int length)
577 int dstoffs = lzss_current_offset(&rar->lzss);
578 int srcoffs = (dstoffs - offset) & lzss_mask(&rar->lzss);
579 int l, li, remaining;
580 unsigned char *d, *s;
583 while (remaining > 0) {
585 if (dstoffs > srcoffs) {
586 if (l > lzss_size(&rar->lzss) - dstoffs)
587 l = lzss_size(&rar->lzss) - dstoffs;
589 if (l > lzss_size(&rar->lzss) - srcoffs)
590 l = lzss_size(&rar->lzss) - srcoffs;
592 d = &(rar->lzss.window[dstoffs]);
593 s = &(rar->lzss.window[srcoffs]);
594 if ((dstoffs + l < srcoffs) || (srcoffs + l < dstoffs))
597 for (li = 0; li < l; li++)
601 dstoffs = (dstoffs + l) & lzss_mask(&(rar->lzss));
602 srcoffs = (srcoffs + l) & lzss_mask(&(rar->lzss));
604 rar->lzss.position += length;
608 ppmd_alloc(void *p, size_t size)
614 ppmd_free(void *p, void *address)
619 static ISzAlloc g_szalloc = { ppmd_alloc, ppmd_free };
624 struct archive_read *a = ((IByteIn*)p)->a;
625 struct rar *rar = (struct rar *)(a->format->data);
626 struct rar_br *br = &(rar->br);
628 if (!rar_br_read_ahead(a, br, 8))
630 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
631 "Truncated RAR file data");
635 b = rar_br_bits(br, 8);
636 rar_br_consume(br, 8);
641 archive_read_support_format_rar(struct archive *_a)
643 struct archive_read *a = (struct archive_read *)_a;
647 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
648 "archive_read_support_format_rar");
650 rar = (struct rar *)calloc(sizeof(*rar), 1);
653 archive_set_error(&a->archive, ENOMEM, "Can't allocate rar data");
654 return (ARCHIVE_FATAL);
658 * Until enough data has been read, we cannot tell about
659 * any encrypted entries yet.
661 rar->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
663 r = __archive_read_register_format(a,
666 archive_read_format_rar_bid,
667 archive_read_format_rar_options,
668 archive_read_format_rar_read_header,
669 archive_read_format_rar_read_data,
670 archive_read_format_rar_read_data_skip,
671 archive_read_format_rar_seek_data,
672 archive_read_format_rar_cleanup,
673 archive_read_support_format_rar_capabilities,
674 archive_read_format_rar_has_encrypted_entries);
682 archive_read_support_format_rar_capabilities(struct archive_read * a)
684 (void)a; /* UNUSED */
685 return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA
686 | ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA);
690 archive_read_format_rar_has_encrypted_entries(struct archive_read *_a)
692 if (_a && _a->format) {
693 struct rar * rar = (struct rar *)_a->format->data;
695 return rar->has_encrypted_entries;
698 return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
703 archive_read_format_rar_bid(struct archive_read *a, int best_bid)
707 /* If there's already a bid > 30, we'll never win. */
711 if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)
714 if (memcmp(p, RAR_SIGNATURE, 7) == 0)
717 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
718 /* This is a PE file */
719 ssize_t offset = 0x10000;
720 ssize_t window = 4096;
722 while (offset + window <= (1024 * 128)) {
723 const char *buff = __archive_read_ahead(a, offset + window, &bytes_avail);
725 /* Remaining bytes are less than window. */
732 while (p + 7 < buff + bytes_avail) {
733 if (memcmp(p, RAR_SIGNATURE, 7) == 0)
744 skip_sfx(struct archive_read *a)
749 ssize_t bytes, window;
753 while (total + window <= (1024 * 128)) {
754 h = __archive_read_ahead(a, window, &bytes);
756 /* Remaining bytes are less than window. */
768 * Scan ahead until we find something that looks
769 * like the RAR header.
772 if (memcmp(p, RAR_SIGNATURE, 7) == 0) {
773 skip = p - (const char *)h;
774 __archive_read_consume(a, skip);
779 skip = p - (const char *)h;
780 __archive_read_consume(a, skip);
784 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
785 "Couldn't find out RAR header");
786 return (ARCHIVE_FATAL);
790 archive_read_format_rar_options(struct archive_read *a,
791 const char *key, const char *val)
794 int ret = ARCHIVE_FAILED;
796 rar = (struct rar *)(a->format->data);
797 if (strcmp(key, "hdrcharset") == 0) {
798 if (val == NULL || val[0] == 0)
799 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
800 "rar: hdrcharset option needs a character-set name");
803 archive_string_conversion_from_charset(
804 &a->archive, val, 0);
805 if (rar->opt_sconv != NULL)
813 /* Note: The "warn" return is just to inform the options
814 * supervisor that we didn't handle it. It will generate
815 * a suitable error if no one used this option. */
816 return (ARCHIVE_WARN);
820 archive_read_format_rar_read_header(struct archive_read *a,
821 struct archive_entry *entry)
830 unsigned long crc32_expected;
832 a->archive.archive_format = ARCHIVE_FORMAT_RAR;
833 if (a->archive.archive_format_name == NULL)
834 a->archive.archive_format_name = "RAR";
836 rar = (struct rar *)(a->format->data);
839 * It should be sufficient to call archive_read_next_header() for
840 * a reader to determine if an entry is encrypted or not. If the
841 * encryption of an entry is only detectable when calling
842 * archive_read_data(), so be it. We'll do the same check there
845 if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
846 rar->has_encrypted_entries = 0;
849 /* RAR files can be generated without EOF headers, so return ARCHIVE_EOF if
852 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
853 return (ARCHIVE_EOF);
856 if (rar->found_first_header == 0 &&
857 ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0)) {
858 /* This is an executable ? Must be self-extracting... */
860 if (ret < ARCHIVE_WARN)
863 rar->found_first_header = 1;
867 unsigned long crc32_val;
869 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
870 return (ARCHIVE_FATAL);
877 if (memcmp(p, RAR_SIGNATURE, 7) != 0) {
878 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
879 "Invalid marker header");
880 return (ARCHIVE_FATAL);
882 __archive_read_consume(a, 7);
886 rar->main_flags = archive_le16dec(p + 3);
887 skip = archive_le16dec(p + 5);
888 if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)) {
889 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
890 "Invalid header size");
891 return (ARCHIVE_FATAL);
893 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL)
894 return (ARCHIVE_FATAL);
896 memcpy(rar->reserved1, p + 7, sizeof(rar->reserved1));
897 memcpy(rar->reserved2, p + 7 + sizeof(rar->reserved1),
898 sizeof(rar->reserved2));
899 if (rar->main_flags & MHD_ENCRYPTVER) {
900 if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)+1) {
901 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
902 "Invalid header size");
903 return (ARCHIVE_FATAL);
905 rar->encryptver = *(p + 7 + sizeof(rar->reserved1) +
906 sizeof(rar->reserved2));
909 /* Main header is password encrypted, so we cannot read any
910 file names or any other info about files from the header. */
911 if (rar->main_flags & MHD_PASSWORD)
913 archive_entry_set_is_metadata_encrypted(entry, 1);
914 archive_entry_set_is_data_encrypted(entry, 1);
915 rar->has_encrypted_entries = 1;
916 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
917 "RAR encryption support unavailable.");
918 return (ARCHIVE_FATAL);
921 crc32_val = crc32(0, (const unsigned char *)p + 2, (unsigned)skip - 2);
922 if ((crc32_val & 0xffff) != archive_le16dec(p)) {
923 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
925 return (ARCHIVE_FATAL);
927 __archive_read_consume(a, skip);
931 return read_header(a, entry, head_type);
939 flags = archive_le16dec(p + 3);
940 skip = archive_le16dec(p + 5);
942 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
943 "Invalid header size too small");
944 return (ARCHIVE_FATAL);
946 if (flags & HD_ADD_SIZE_PRESENT)
949 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
950 "Invalid header size too small");
951 return (ARCHIVE_FATAL);
953 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL)
954 return (ARCHIVE_FATAL);
956 skip += archive_le32dec(p + 7);
959 /* Skip over the 2-byte CRC at the beginning of the header. */
960 crc32_expected = archive_le16dec(p);
961 __archive_read_consume(a, 2);
964 /* Skim the entire header and compute the CRC. */
967 size_t to_read = skip;
969 if (to_read > 32 * 1024) {
972 if ((h = __archive_read_ahead(a, to_read, &did_read)) == NULL) {
973 return (ARCHIVE_FATAL);
976 crc32_val = crc32(crc32_val, (const unsigned char *)p, (unsigned)did_read);
977 __archive_read_consume(a, did_read);
980 if ((crc32_val & 0xffff) != crc32_expected) {
981 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
983 return (ARCHIVE_FATAL);
985 if (head_type == ENDARC_HEAD)
986 return (ARCHIVE_EOF);
990 if ((ret = read_header(a, entry, head_type)) < ARCHIVE_WARN)
995 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
997 return (ARCHIVE_FATAL);
1003 archive_read_format_rar_read_data(struct archive_read *a, const void **buff,
1004 size_t *size, int64_t *offset)
1006 struct rar *rar = (struct rar *)(a->format->data);
1009 if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
1010 rar->has_encrypted_entries = 0;
1013 if (rar->bytes_unconsumed > 0) {
1014 /* Consume as much as the decompressor actually used. */
1015 __archive_read_consume(a, rar->bytes_unconsumed);
1016 rar->bytes_unconsumed = 0;
1020 if (rar->entry_eof || rar->offset_seek >= rar->unp_size) {
1022 *offset = rar->offset;
1023 if (*offset < rar->unp_size)
1024 *offset = rar->unp_size;
1025 return (ARCHIVE_EOF);
1028 switch (rar->compression_method)
1030 case COMPRESS_METHOD_STORE:
1031 ret = read_data_stored(a, buff, size, offset);
1034 case COMPRESS_METHOD_FASTEST:
1035 case COMPRESS_METHOD_FAST:
1036 case COMPRESS_METHOD_NORMAL:
1037 case COMPRESS_METHOD_GOOD:
1038 case COMPRESS_METHOD_BEST:
1039 ret = read_data_compressed(a, buff, size, offset);
1040 if (ret != ARCHIVE_OK && ret != ARCHIVE_WARN)
1041 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc);
1045 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1046 "Unsupported compression method for RAR file.");
1047 ret = ARCHIVE_FATAL;
1054 archive_read_format_rar_read_data_skip(struct archive_read *a)
1057 int64_t bytes_skipped;
1060 rar = (struct rar *)(a->format->data);
1062 if (rar->bytes_unconsumed > 0) {
1063 /* Consume as much as the decompressor actually used. */
1064 __archive_read_consume(a, rar->bytes_unconsumed);
1065 rar->bytes_unconsumed = 0;
1068 if (rar->bytes_remaining > 0) {
1069 bytes_skipped = __archive_read_consume(a, rar->bytes_remaining);
1070 if (bytes_skipped < 0)
1071 return (ARCHIVE_FATAL);
1074 /* Compressed data to skip must be read from each header in a multivolume
1077 if (rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER)
1079 ret = archive_read_format_rar_read_header(a, a->entry);
1080 if (ret == (ARCHIVE_EOF))
1081 ret = archive_read_format_rar_read_header(a, a->entry);
1082 if (ret != (ARCHIVE_OK))
1084 return archive_read_format_rar_read_data_skip(a);
1087 return (ARCHIVE_OK);
1091 archive_read_format_rar_seek_data(struct archive_read *a, int64_t offset,
1094 int64_t client_offset, ret;
1096 struct rar *rar = (struct rar *)(a->format->data);
1098 if (rar->compression_method == COMPRESS_METHOD_STORE)
1100 /* Modify the offset for use with SEEK_SET */
1104 client_offset = rar->offset_seek;
1107 client_offset = rar->unp_size;
1113 client_offset += offset;
1114 if (client_offset < 0)
1116 /* Can't seek past beginning of data block */
1119 else if (client_offset > rar->unp_size)
1122 * Set the returned offset but only seek to the end of
1125 rar->offset_seek = client_offset;
1126 client_offset = rar->unp_size;
1129 client_offset += rar->dbo[0].start_offset;
1131 while (i < rar->cursor)
1134 client_offset += rar->dbo[i].start_offset - rar->dbo[i-1].end_offset;
1136 if (rar->main_flags & MHD_VOLUME)
1138 /* Find the appropriate offset among the multivolume archive */
1141 if (client_offset < rar->dbo[rar->cursor].start_offset &&
1142 rar->file_flags & FHD_SPLIT_BEFORE)
1144 /* Search backwards for the correct data block */
1145 if (rar->cursor == 0)
1147 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1148 "Attempt to seek past beginning of RAR data block");
1149 return (ARCHIVE_FAILED);
1152 client_offset -= rar->dbo[rar->cursor+1].start_offset -
1153 rar->dbo[rar->cursor].end_offset;
1154 if (client_offset < rar->dbo[rar->cursor].start_offset)
1156 ret = __archive_read_seek(a, rar->dbo[rar->cursor].start_offset -
1157 rar->dbo[rar->cursor].header_size, SEEK_SET);
1158 if (ret < (ARCHIVE_OK))
1160 ret = archive_read_format_rar_read_header(a, a->entry);
1161 if (ret != (ARCHIVE_OK))
1163 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1164 "Error during seek of RAR file");
1165 return (ARCHIVE_FAILED);
1170 else if (client_offset > rar->dbo[rar->cursor].end_offset &&
1171 rar->file_flags & FHD_SPLIT_AFTER)
1173 /* Search forward for the correct data block */
1175 if (rar->cursor < rar->nodes &&
1176 client_offset > rar->dbo[rar->cursor].end_offset)
1178 client_offset += rar->dbo[rar->cursor].start_offset -
1179 rar->dbo[rar->cursor-1].end_offset;
1183 ret = __archive_read_seek(a, rar->dbo[rar->cursor].end_offset,
1185 if (ret < (ARCHIVE_OK))
1187 ret = archive_read_format_rar_read_header(a, a->entry);
1188 if (ret == (ARCHIVE_EOF))
1190 rar->has_endarc_header = 1;
1191 ret = archive_read_format_rar_read_header(a, a->entry);
1193 if (ret != (ARCHIVE_OK))
1195 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1196 "Error during seek of RAR file");
1197 return (ARCHIVE_FAILED);
1199 client_offset += rar->dbo[rar->cursor].start_offset -
1200 rar->dbo[rar->cursor-1].end_offset;
1207 ret = __archive_read_seek(a, client_offset, SEEK_SET);
1208 if (ret < (ARCHIVE_OK))
1210 rar->bytes_remaining = rar->dbo[rar->cursor].end_offset - ret;
1215 ret -= rar->dbo[i+1].start_offset - rar->dbo[i].end_offset;
1217 ret -= rar->dbo[0].start_offset;
1219 /* Always restart reading the file after a seek */
1220 __archive_reset_read_data(&a->archive);
1222 rar->bytes_unconsumed = 0;
1226 * If a seek past the end of file was requested, return the requested
1229 if (ret == rar->unp_size && rar->offset_seek > rar->unp_size)
1230 return rar->offset_seek;
1232 /* Return the new offset */
1233 rar->offset_seek = ret;
1234 return rar->offset_seek;
1238 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1239 "Seeking of compressed RAR files is unsupported");
1241 return (ARCHIVE_FAILED);
1245 archive_read_format_rar_cleanup(struct archive_read *a)
1249 rar = (struct rar *)(a->format->data);
1251 free(rar->filename);
1252 free(rar->filename_save);
1254 free(rar->unp_buffer);
1255 free(rar->lzss.window);
1256 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc);
1258 (a->format->data) = NULL;
1259 return (ARCHIVE_OK);
1263 read_header(struct archive_read *a, struct archive_entry *entry,
1267 const char *p, *endp;
1269 struct rar_header rar_header;
1270 struct rar_file_header file_header;
1271 int64_t header_size;
1272 unsigned filename_size, end;
1275 char packed_size[8];
1278 struct archive_string_conv *sconv, *fn_sconv;
1279 unsigned long crc32_val;
1280 int ret = (ARCHIVE_OK), ret2;
1282 rar = (struct rar *)(a->format->data);
1284 /* Setup a string conversion object for non-rar-unicode filenames. */
1285 sconv = rar->opt_sconv;
1286 if (sconv == NULL) {
1287 if (!rar->init_default_conversion) {
1288 rar->sconv_default =
1289 archive_string_default_conversion_for_read(
1291 rar->init_default_conversion = 1;
1293 sconv = rar->sconv_default;
1297 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
1298 return (ARCHIVE_FATAL);
1300 memcpy(&rar_header, p, sizeof(rar_header));
1301 rar->file_flags = archive_le16dec(rar_header.flags);
1302 header_size = archive_le16dec(rar_header.size);
1303 if (header_size < (int64_t)sizeof(file_header) + 7) {
1304 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1305 "Invalid header size");
1306 return (ARCHIVE_FATAL);
1308 crc32_val = crc32(0, (const unsigned char *)p + 2, 7 - 2);
1309 __archive_read_consume(a, 7);
1311 if (!(rar->file_flags & FHD_SOLID))
1313 rar->compression_method = 0;
1314 rar->packed_size = 0;
1321 memset(&rar->salt, 0, sizeof(rar->salt));
1333 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1334 "RAR solid archive support unavailable.");
1335 return (ARCHIVE_FATAL);
1338 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL)
1339 return (ARCHIVE_FATAL);
1341 /* File Header CRC check. */
1342 crc32_val = crc32(crc32_val, h, (unsigned)(header_size - 7));
1343 if ((crc32_val & 0xffff) != archive_le16dec(rar_header.crc)) {
1344 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1345 "Header CRC error");
1346 return (ARCHIVE_FATAL);
1348 /* If no CRC error, Go on parsing File Header. */
1350 endp = p + header_size - 7;
1351 memcpy(&file_header, p, sizeof(file_header));
1352 p += sizeof(file_header);
1354 rar->compression_method = file_header.method;
1356 ttime = archive_le32dec(file_header.file_time);
1357 rar->mtime = get_time(ttime);
1359 rar->file_crc = archive_le32dec(file_header.file_crc);
1361 if (rar->file_flags & FHD_PASSWORD)
1363 archive_entry_set_is_data_encrypted(entry, 1);
1364 rar->has_encrypted_entries = 1;
1365 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1366 "RAR encryption support unavailable.");
1367 /* Since it is only the data part itself that is encrypted we can at least
1368 extract information about the currently processed entry and don't need
1369 to return ARCHIVE_FATAL here. */
1370 /*return (ARCHIVE_FATAL);*/
1373 if (rar->file_flags & FHD_LARGE)
1375 memcpy(packed_size, file_header.pack_size, 4);
1376 memcpy(packed_size + 4, p, 4); /* High pack size */
1378 memcpy(unp_size, file_header.unp_size, 4);
1379 memcpy(unp_size + 4, p, 4); /* High unpack size */
1381 rar->packed_size = archive_le64dec(&packed_size);
1382 rar->unp_size = archive_le64dec(&unp_size);
1386 rar->packed_size = archive_le32dec(file_header.pack_size);
1387 rar->unp_size = archive_le32dec(file_header.unp_size);
1390 if (rar->packed_size < 0 || rar->unp_size < 0)
1392 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1393 "Invalid sizes specified.");
1394 return (ARCHIVE_FATAL);
1397 rar->bytes_remaining = rar->packed_size;
1399 /* TODO: RARv3 subblocks contain comments. For now the complete block is
1400 * consumed at the end.
1402 if (head_type == NEWSUB_HEAD) {
1403 size_t distance = p - (const char *)h;
1404 header_size += rar->packed_size;
1405 /* Make sure we have the extended data. */
1406 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL)
1407 return (ARCHIVE_FATAL);
1409 endp = p + header_size - 7;
1413 filename_size = archive_le16dec(file_header.name_size);
1414 if (p + filename_size > endp) {
1415 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1416 "Invalid filename size");
1417 return (ARCHIVE_FATAL);
1419 if (rar->filename_allocated < filename_size * 2 + 2) {
1421 size_t newsize = filename_size * 2 + 2;
1422 newptr = realloc(rar->filename, newsize);
1423 if (newptr == NULL) {
1424 archive_set_error(&a->archive, ENOMEM,
1425 "Couldn't allocate memory.");
1426 return (ARCHIVE_FATAL);
1428 rar->filename = newptr;
1429 rar->filename_allocated = newsize;
1431 filename = rar->filename;
1432 memcpy(filename, p, filename_size);
1433 filename[filename_size] = '\0';
1434 if (rar->file_flags & FHD_UNICODE)
1436 if (filename_size != strlen(filename))
1438 unsigned char highbyte, flagbits, flagbyte;
1439 unsigned fn_end, offset;
1441 end = filename_size;
1442 fn_end = filename_size * 2;
1444 offset = (unsigned)strlen(filename) + 1;
1445 highbyte = *(p + offset++);
1448 while (offset < end && filename_size < fn_end)
1452 flagbyte = *(p + offset++);
1457 switch((flagbyte >> flagbits) & 3)
1460 filename[filename_size++] = '\0';
1461 filename[filename_size++] = *(p + offset++);
1464 filename[filename_size++] = highbyte;
1465 filename[filename_size++] = *(p + offset++);
1468 filename[filename_size++] = *(p + offset + 1);
1469 filename[filename_size++] = *(p + offset);
1475 uint8_t length = *(p + offset++);
1477 if (length & 0x80) {
1478 extra = *(p + offset++);
1479 high = (char)highbyte;
1482 length = (length & 0x7f) + 2;
1483 while (length && filename_size < fn_end) {
1484 unsigned cp = filename_size >> 1;
1485 filename[filename_size++] = high;
1486 filename[filename_size++] = p[cp] + extra;
1493 if (filename_size > fn_end) {
1494 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1495 "Invalid filename");
1496 return (ARCHIVE_FATAL);
1498 filename[filename_size++] = '\0';
1499 filename[filename_size++] = '\0';
1501 /* Decoded unicode form is UTF-16BE, so we have to update a string
1502 * conversion object for it. */
1503 if (rar->sconv_utf16be == NULL) {
1504 rar->sconv_utf16be = archive_string_conversion_from_charset(
1505 &a->archive, "UTF-16BE", 1);
1506 if (rar->sconv_utf16be == NULL)
1507 return (ARCHIVE_FATAL);
1509 fn_sconv = rar->sconv_utf16be;
1512 while (memcmp(strp, "\x00\x00", 2))
1514 if (!memcmp(strp, "\x00\\", 2))
1521 * If FHD_UNICODE is set but no unicode data, this file name form
1522 * is UTF-8, so we have to update a string conversion object for
1525 if (rar->sconv_utf8 == NULL) {
1526 rar->sconv_utf8 = archive_string_conversion_from_charset(
1527 &a->archive, "UTF-8", 1);
1528 if (rar->sconv_utf8 == NULL)
1529 return (ARCHIVE_FATAL);
1531 fn_sconv = rar->sconv_utf8;
1532 while ((strp = strchr(filename, '\\')) != NULL)
1540 while ((strp = strchr(filename, '\\')) != NULL)
1545 /* Split file in multivolume RAR. No more need to process header. */
1546 if (rar->filename_save &&
1547 filename_size == rar->filename_save_size &&
1548 !memcmp(rar->filename, rar->filename_save, filename_size + 1))
1550 __archive_read_consume(a, header_size - 7);
1552 if (rar->cursor >= rar->nodes)
1556 realloc(rar->dbo, sizeof(*rar->dbo) * rar->nodes)) == NULL)
1558 archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
1559 return (ARCHIVE_FATAL);
1561 rar->dbo[rar->cursor].header_size = header_size;
1562 rar->dbo[rar->cursor].start_offset = -1;
1563 rar->dbo[rar->cursor].end_offset = -1;
1565 if (rar->dbo[rar->cursor].start_offset < 0)
1567 rar->dbo[rar->cursor].start_offset = a->filter->position;
1568 rar->dbo[rar->cursor].end_offset = rar->dbo[rar->cursor].start_offset +
1574 rar->filename_save = (char*)realloc(rar->filename_save,
1576 memcpy(rar->filename_save, rar->filename, filename_size + 1);
1577 rar->filename_save_size = filename_size;
1579 /* Set info for seeking */
1581 if ((rar->dbo = calloc(1, sizeof(*rar->dbo))) == NULL)
1583 archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
1584 return (ARCHIVE_FATAL);
1586 rar->dbo[0].header_size = header_size;
1587 rar->dbo[0].start_offset = -1;
1588 rar->dbo[0].end_offset = -1;
1592 if (rar->file_flags & FHD_SALT)
1595 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1596 "Invalid header size");
1597 return (ARCHIVE_FATAL);
1599 memcpy(rar->salt, p, 8);
1603 if (rar->file_flags & FHD_EXTTIME) {
1604 if (read_exttime(p, rar, endp) < 0) {
1605 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1606 "Invalid header size");
1607 return (ARCHIVE_FATAL);
1611 __archive_read_consume(a, header_size - 7);
1612 rar->dbo[0].start_offset = a->filter->position;
1613 rar->dbo[0].end_offset = rar->dbo[0].start_offset + rar->packed_size;
1615 switch(file_header.host_os)
1620 rar->mode = archive_le32dec(file_header.file_attr);
1621 if (rar->mode & FILE_ATTRIBUTE_DIRECTORY)
1622 rar->mode = AE_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
1624 rar->mode = AE_IFREG;
1625 rar->mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
1631 rar->mode = archive_le32dec(file_header.file_attr);
1635 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1636 "Unknown file attributes from RAR file's host OS");
1637 return (ARCHIVE_FATAL);
1640 rar->bytes_uncopied = rar->bytes_unconsumed = 0;
1641 rar->lzss.position = rar->offset = 0;
1642 rar->offset_seek = 0;
1643 rar->dictionary_size = 0;
1644 rar->offset_outgoing = 0;
1645 rar->br.cache_avail = 0;
1646 rar->br.avail_in = 0;
1647 rar->crc_calculated = 0;
1650 rar->is_ppmd_block = 0;
1651 rar->start_new_table = 1;
1652 free(rar->unp_buffer);
1653 rar->unp_buffer = NULL;
1654 rar->unp_offset = 0;
1655 rar->unp_buffer_size = UNP_BUFFER_SIZE;
1656 memset(rar->lengthtable, 0, sizeof(rar->lengthtable));
1657 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc);
1658 rar->ppmd_valid = rar->ppmd_eod = 0;
1660 /* Don't set any archive entries for non-file header types */
1661 if (head_type == NEWSUB_HEAD)
1664 archive_entry_set_mtime(entry, rar->mtime, rar->mnsec);
1665 archive_entry_set_ctime(entry, rar->ctime, rar->cnsec);
1666 archive_entry_set_atime(entry, rar->atime, rar->ansec);
1667 archive_entry_set_size(entry, rar->unp_size);
1668 archive_entry_set_mode(entry, rar->mode);
1670 if (archive_entry_copy_pathname_l(entry, filename, filename_size, fn_sconv))
1672 if (errno == ENOMEM)
1674 archive_set_error(&a->archive, ENOMEM,
1675 "Can't allocate memory for Pathname");
1676 return (ARCHIVE_FATAL);
1678 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1679 "Pathname cannot be converted from %s to current locale.",
1680 archive_string_conversion_charset_name(fn_sconv));
1681 ret = (ARCHIVE_WARN);
1684 if (((rar->mode) & AE_IFMT) == AE_IFLNK)
1686 /* Make sure a symbolic-link file does not have its body. */
1687 rar->bytes_remaining = 0;
1688 archive_entry_set_size(entry, 0);
1690 /* Read a symbolic-link name. */
1691 if ((ret2 = read_symlink_stored(a, entry, sconv)) < (ARCHIVE_WARN))
1697 if (rar->bytes_remaining == 0)
1707 tm.tm_sec = 2 * (ttime & 0x1f);
1708 tm.tm_min = (ttime >> 5) & 0x3f;
1709 tm.tm_hour = (ttime >> 11) & 0x1f;
1710 tm.tm_mday = (ttime >> 16) & 0x1f;
1711 tm.tm_mon = ((ttime >> 21) & 0x0f) - 1;
1712 tm.tm_year = ((ttime >> 25) & 0x7f) + 80;
1718 read_exttime(const char *p, struct rar *rar, const char *endp)
1720 unsigned rmode, flags, rem, j, count;
1728 flags = archive_le16dec(p);
1731 for (i = 3; i >= 0; i--)
1736 rmode = flags >> i * 4;
1743 ttime = archive_le32dec(p);
1744 t = get_time(ttime);
1749 if (p + count > endp)
1751 for (j = 0; j < count; j++)
1753 rem = (((unsigned)(unsigned char)*p) << 16) | (rem >> 8);
1757 nsec = tm->tm_sec + rem / NS_UNIT;
1781 rar->arcnsec = nsec;
1789 read_symlink_stored(struct archive_read *a, struct archive_entry *entry,
1790 struct archive_string_conv *sconv)
1795 int ret = (ARCHIVE_OK);
1797 rar = (struct rar *)(a->format->data);
1798 if ((h = rar_read_ahead(a, (size_t)rar->packed_size, NULL)) == NULL)
1799 return (ARCHIVE_FATAL);
1802 if (archive_entry_copy_symlink_l(entry,
1803 p, (size_t)rar->packed_size, sconv))
1805 if (errno == ENOMEM)
1807 archive_set_error(&a->archive, ENOMEM,
1808 "Can't allocate memory for link");
1809 return (ARCHIVE_FATAL);
1811 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1812 "link cannot be converted from %s to current locale.",
1813 archive_string_conversion_charset_name(sconv));
1814 ret = (ARCHIVE_WARN);
1816 __archive_read_consume(a, rar->packed_size);
1821 read_data_stored(struct archive_read *a, const void **buff, size_t *size,
1825 ssize_t bytes_avail;
1827 rar = (struct rar *)(a->format->data);
1828 if (rar->bytes_remaining == 0 &&
1829 !(rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER))
1833 *offset = rar->offset;
1834 if (rar->file_crc != rar->crc_calculated) {
1835 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1837 return (ARCHIVE_FATAL);
1840 return (ARCHIVE_EOF);
1843 *buff = rar_read_ahead(a, 1, &bytes_avail);
1844 if (bytes_avail <= 0)
1846 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1847 "Truncated RAR file data");
1848 return (ARCHIVE_FATAL);
1851 *size = bytes_avail;
1852 *offset = rar->offset;
1853 rar->offset += bytes_avail;
1854 rar->offset_seek += bytes_avail;
1855 rar->bytes_remaining -= bytes_avail;
1856 rar->bytes_unconsumed = bytes_avail;
1857 /* Calculate File CRC. */
1858 rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1859 (unsigned)bytes_avail);
1860 return (ARCHIVE_OK);
1864 read_data_compressed(struct archive_read *a, const void **buff, size_t *size,
1868 int64_t start, end, actualend;
1870 int ret = (ARCHIVE_OK), sym, code, lzss_offset, length, i;
1872 rar = (struct rar *)(a->format->data);
1876 return (ARCHIVE_FATAL);
1877 if (rar->ppmd_eod ||
1878 (rar->dictionary_size && rar->offset >= rar->unp_size))
1880 if (rar->unp_offset > 0) {
1882 * We have unprocessed extracted data. write it out.
1884 *buff = rar->unp_buffer;
1885 *size = rar->unp_offset;
1886 *offset = rar->offset_outgoing;
1887 rar->offset_outgoing += *size;
1888 /* Calculate File CRC. */
1889 rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1891 rar->unp_offset = 0;
1892 return (ARCHIVE_OK);
1896 *offset = rar->offset;
1897 if (rar->file_crc != rar->crc_calculated) {
1898 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1900 return (ARCHIVE_FATAL);
1903 return (ARCHIVE_EOF);
1906 if (!rar->is_ppmd_block && rar->dictionary_size && rar->bytes_uncopied > 0)
1908 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset))
1909 bs = rar->unp_buffer_size - rar->unp_offset;
1911 bs = (size_t)rar->bytes_uncopied;
1912 ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs);
1913 if (ret != ARCHIVE_OK)
1916 rar->bytes_uncopied -= bs;
1917 if (*buff != NULL) {
1918 rar->unp_offset = 0;
1919 *size = rar->unp_buffer_size;
1920 *offset = rar->offset_outgoing;
1921 rar->offset_outgoing += *size;
1922 /* Calculate File CRC. */
1923 rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1930 if (!rar->br.next_in &&
1931 (ret = rar_br_preparation(a, &(rar->br))) < ARCHIVE_WARN)
1933 if (rar->start_new_table && ((ret = parse_codes(a)) < (ARCHIVE_WARN)))
1936 if (rar->is_ppmd_block)
1938 if ((sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1939 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1941 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1943 return (ARCHIVE_FATAL);
1945 if(sym != rar->ppmd_escape)
1947 lzss_emit_literal(rar, sym);
1948 rar->bytes_uncopied++;
1952 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1953 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1955 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1957 return (ARCHIVE_FATAL);
1963 rar->start_new_table = 1;
1964 return read_data_compressed(a, buff, size, offset);
1967 rar->ppmd_eod = 1;/* End Of ppmd Data. */
1971 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1972 "Parsing filters is unsupported.");
1973 return (ARCHIVE_FAILED);
1977 for (i = 2; i >= 0; i--)
1979 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1980 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1982 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1984 return (ARCHIVE_FATAL);
1986 lzss_offset |= code << (i * 8);
1988 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1989 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1991 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1993 return (ARCHIVE_FATAL);
1995 lzss_emit_match(rar, lzss_offset + 2, length + 32);
1996 rar->bytes_uncopied += length + 32;
2000 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
2001 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
2003 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2005 return (ARCHIVE_FATAL);
2007 lzss_emit_match(rar, 1, length + 4);
2008 rar->bytes_uncopied += length + 4;
2012 lzss_emit_literal(rar, sym);
2013 rar->bytes_uncopied++;
2019 start = rar->offset;
2020 end = start + rar->dictionary_size;
2021 rar->filterstart = INT64_MAX;
2023 if ((actualend = expand(a, end)) < 0)
2024 return ((int)actualend);
2026 rar->bytes_uncopied = actualend - start;
2027 if (rar->bytes_uncopied == 0) {
2028 /* Broken RAR files cause this case.
2029 * NOTE: If this case were possible on a normal RAR file
2030 * we would find out where it was actually bad and
2031 * what we would do to solve it. */
2032 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2033 "Internal error extracting RAR file");
2034 return (ARCHIVE_FATAL);
2037 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset))
2038 bs = rar->unp_buffer_size - rar->unp_offset;
2040 bs = (size_t)rar->bytes_uncopied;
2041 ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs);
2042 if (ret != ARCHIVE_OK)
2045 rar->bytes_uncopied -= bs;
2047 * If *buff is NULL, it means unp_buffer is not full.
2048 * So we have to continue extracting a RAR file.
2050 } while (*buff == NULL);
2052 rar->unp_offset = 0;
2053 *size = rar->unp_buffer_size;
2054 *offset = rar->offset_outgoing;
2055 rar->offset_outgoing += *size;
2056 /* Calculate File CRC. */
2057 rar->crc_calculated = crc32(rar->crc_calculated, *buff, (unsigned)*size);
2062 parse_codes(struct archive_read *a)
2064 int i, j, val, n, r;
2065 unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags;
2066 unsigned int maxorder;
2067 struct huffman_code precode;
2068 struct rar *rar = (struct rar *)(a->format->data);
2069 struct rar_br *br = &(rar->br);
2073 /* Skip to the next byte */
2074 rar_br_consume_unalined_bits(br);
2076 /* PPMd block flag */
2077 if (!rar_br_read_ahead(a, br, 1))
2078 goto truncated_data;
2079 if ((rar->is_ppmd_block = rar_br_bits(br, 1)) != 0)
2081 rar_br_consume(br, 1);
2082 if (!rar_br_read_ahead(a, br, 7))
2083 goto truncated_data;
2084 ppmd_flags = rar_br_bits(br, 7);
2085 rar_br_consume(br, 7);
2087 /* Memory is allocated in MB */
2088 if (ppmd_flags & 0x20)
2090 if (!rar_br_read_ahead(a, br, 8))
2091 goto truncated_data;
2092 rar->dictionary_size = (rar_br_bits(br, 8) + 1) << 20;
2093 rar_br_consume(br, 8);
2096 if (ppmd_flags & 0x40)
2098 if (!rar_br_read_ahead(a, br, 8))
2099 goto truncated_data;
2100 rar->ppmd_escape = rar->ppmd7_context.InitEsc = rar_br_bits(br, 8);
2101 rar_br_consume(br, 8);
2104 rar->ppmd_escape = 2;
2106 if (ppmd_flags & 0x20)
2108 maxorder = (ppmd_flags & 0x1F) + 1;
2110 maxorder = 16 + (maxorder - 16) * 3;
2114 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2115 "Truncated RAR file data");
2116 return (ARCHIVE_FATAL);
2119 /* Make sure ppmd7_contest is freed before Ppmd7_Construct
2120 * because reading a broken file cause this abnormal sequence. */
2121 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc);
2124 rar->bytein.Read = &ppmd_read;
2125 __archive_ppmd7_functions.PpmdRAR_RangeDec_CreateVTable(&rar->range_dec);
2126 rar->range_dec.Stream = &rar->bytein;
2127 __archive_ppmd7_functions.Ppmd7_Construct(&rar->ppmd7_context);
2129 if (rar->dictionary_size == 0) {
2130 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2131 "Invalid zero dictionary size");
2132 return (ARCHIVE_FATAL);
2135 if (!__archive_ppmd7_functions.Ppmd7_Alloc(&rar->ppmd7_context,
2136 rar->dictionary_size, &g_szalloc))
2138 archive_set_error(&a->archive, ENOMEM,
2140 return (ARCHIVE_FATAL);
2142 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec))
2144 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2145 "Unable to initialize PPMd range decoder");
2146 return (ARCHIVE_FATAL);
2148 __archive_ppmd7_functions.Ppmd7_Init(&rar->ppmd7_context, maxorder);
2149 rar->ppmd_valid = 1;
2153 if (!rar->ppmd_valid) {
2154 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2155 "Invalid PPMd sequence");
2156 return (ARCHIVE_FATAL);
2158 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec))
2160 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2161 "Unable to initialize PPMd range decoder");
2162 return (ARCHIVE_FATAL);
2168 rar_br_consume(br, 1);
2170 /* Keep existing table flag */
2171 if (!rar_br_read_ahead(a, br, 1))
2172 goto truncated_data;
2173 if (!rar_br_bits(br, 1))
2174 memset(rar->lengthtable, 0, sizeof(rar->lengthtable));
2175 rar_br_consume(br, 1);
2177 memset(&bitlengths, 0, sizeof(bitlengths));
2178 for (i = 0; i < MAX_SYMBOLS;)
2180 if (!rar_br_read_ahead(a, br, 4))
2181 goto truncated_data;
2182 bitlengths[i++] = rar_br_bits(br, 4);
2183 rar_br_consume(br, 4);
2184 if (bitlengths[i-1] == 0xF)
2186 if (!rar_br_read_ahead(a, br, 4))
2187 goto truncated_data;
2188 zerocount = rar_br_bits(br, 4);
2189 rar_br_consume(br, 4);
2193 for (j = 0; j < zerocount + 2 && i < MAX_SYMBOLS; j++)
2194 bitlengths[i++] = 0;
2199 memset(&precode, 0, sizeof(precode));
2200 r = create_code(a, &precode, bitlengths, MAX_SYMBOLS, MAX_SYMBOL_LENGTH);
2201 if (r != ARCHIVE_OK) {
2203 free(precode.table);
2207 for (i = 0; i < HUFFMAN_TABLE_SIZE;)
2209 if ((val = read_next_symbol(a, &precode)) < 0) {
2211 free(precode.table);
2212 return (ARCHIVE_FATAL);
2216 rar->lengthtable[i] = (rar->lengthtable[i] + val) & 0xF;
2224 free(precode.table);
2225 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2226 "Internal error extracting RAR file.");
2227 return (ARCHIVE_FATAL);
2231 if (!rar_br_read_ahead(a, br, 3)) {
2233 free(precode.table);
2234 goto truncated_data;
2236 n = rar_br_bits(br, 3) + 3;
2237 rar_br_consume(br, 3);
2239 if (!rar_br_read_ahead(a, br, 7)) {
2241 free(precode.table);
2242 goto truncated_data;
2244 n = rar_br_bits(br, 7) + 11;
2245 rar_br_consume(br, 7);
2248 for (j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++)
2250 rar->lengthtable[i] = rar->lengthtable[i-1];
2257 if (!rar_br_read_ahead(a, br, 3)) {
2259 free(precode.table);
2260 goto truncated_data;
2262 n = rar_br_bits(br, 3) + 3;
2263 rar_br_consume(br, 3);
2265 if (!rar_br_read_ahead(a, br, 7)) {
2267 free(precode.table);
2268 goto truncated_data;
2270 n = rar_br_bits(br, 7) + 11;
2271 rar_br_consume(br, 7);
2274 for(j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++)
2275 rar->lengthtable[i++] = 0;
2279 free(precode.table);
2281 r = create_code(a, &rar->maincode, &rar->lengthtable[0], MAINCODE_SIZE,
2283 if (r != ARCHIVE_OK)
2285 r = create_code(a, &rar->offsetcode, &rar->lengthtable[MAINCODE_SIZE],
2286 OFFSETCODE_SIZE, MAX_SYMBOL_LENGTH);
2287 if (r != ARCHIVE_OK)
2289 r = create_code(a, &rar->lowoffsetcode,
2290 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE],
2291 LOWOFFSETCODE_SIZE, MAX_SYMBOL_LENGTH);
2292 if (r != ARCHIVE_OK)
2294 r = create_code(a, &rar->lengthcode,
2295 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE +
2296 LOWOFFSETCODE_SIZE], LENGTHCODE_SIZE, MAX_SYMBOL_LENGTH);
2297 if (r != ARCHIVE_OK)
2301 if (!rar->dictionary_size || !rar->lzss.window)
2303 /* Seems as though dictionary sizes are not used. Even so, minimize
2304 * memory usage as much as possible.
2307 unsigned int new_size;
2309 if (rar->unp_size >= DICTIONARY_MAX_SIZE)
2310 new_size = DICTIONARY_MAX_SIZE;
2312 new_size = rar_fls((unsigned int)rar->unp_size) << 1;
2313 new_window = realloc(rar->lzss.window, new_size);
2314 if (new_window == NULL) {
2315 archive_set_error(&a->archive, ENOMEM,
2316 "Unable to allocate memory for uncompressed data.");
2317 return (ARCHIVE_FATAL);
2319 rar->lzss.window = (unsigned char *)new_window;
2320 rar->dictionary_size = new_size;
2321 memset(rar->lzss.window, 0, rar->dictionary_size);
2322 rar->lzss.mask = rar->dictionary_size - 1;
2325 rar->start_new_table = 0;
2326 return (ARCHIVE_OK);
2328 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2329 "Truncated RAR file data");
2331 return (ARCHIVE_FATAL);
2335 free_codes(struct archive_read *a)
2337 struct rar *rar = (struct rar *)(a->format->data);
2338 free(rar->maincode.tree);
2339 free(rar->offsetcode.tree);
2340 free(rar->lowoffsetcode.tree);
2341 free(rar->lengthcode.tree);
2342 free(rar->maincode.table);
2343 free(rar->offsetcode.table);
2344 free(rar->lowoffsetcode.table);
2345 free(rar->lengthcode.table);
2346 memset(&rar->maincode, 0, sizeof(rar->maincode));
2347 memset(&rar->offsetcode, 0, sizeof(rar->offsetcode));
2348 memset(&rar->lowoffsetcode, 0, sizeof(rar->lowoffsetcode));
2349 memset(&rar->lengthcode, 0, sizeof(rar->lengthcode));
2354 read_next_symbol(struct archive_read *a, struct huffman_code *code)
2358 int length, value, node;
2364 if (make_table(a, code) != (ARCHIVE_OK))
2368 rar = (struct rar *)(a->format->data);
2371 /* Look ahead (peek) at bits */
2372 if (!rar_br_read_ahead(a, br, code->tablesize)) {
2373 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2374 "Truncated RAR file data");
2378 bits = rar_br_bits(br, code->tablesize);
2380 length = code->table[bits].length;
2381 value = code->table[bits].value;
2385 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2386 "Invalid prefix code in bitstream");
2390 if (length <= code->tablesize)
2392 /* Skip length bits */
2393 rar_br_consume(br, length);
2397 /* Skip tablesize bits */
2398 rar_br_consume(br, code->tablesize);
2401 while (!(code->tree[node].branches[0] ==
2402 code->tree[node].branches[1]))
2404 if (!rar_br_read_ahead(a, br, 1)) {
2405 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2406 "Truncated RAR file data");
2410 bit = rar_br_bits(br, 1);
2411 rar_br_consume(br, 1);
2413 if (code->tree[node].branches[bit] < 0)
2415 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2416 "Invalid prefix code in bitstream");
2419 node = code->tree[node].branches[bit];
2422 return code->tree[node].branches[0];
2426 create_code(struct archive_read *a, struct huffman_code *code,
2427 unsigned char *lengths, int numsymbols, char maxlength)
2429 int i, j, codebits = 0, symbolsleft = numsymbols;
2431 code->numentries = 0;
2432 code->numallocatedentries = 0;
2433 if (new_node(code) < 0) {
2434 archive_set_error(&a->archive, ENOMEM,
2435 "Unable to allocate memory for node data.");
2436 return (ARCHIVE_FATAL);
2438 code->numentries = 1;
2439 code->minlength = INT_MAX;
2440 code->maxlength = INT_MIN;
2442 for(i = 1; i <= maxlength; i++)
2444 for(j = 0; j < numsymbols; j++)
2446 if (lengths[j] != i) continue;
2447 if (add_value(a, code, j, codebits, i) != ARCHIVE_OK)
2448 return (ARCHIVE_FATAL);
2450 if (--symbolsleft <= 0) { break; break; }
2454 return (ARCHIVE_OK);
2458 add_value(struct archive_read *a, struct huffman_code *code, int value,
2459 int codebits, int length)
2461 int repeatpos, lastnode, bitpos, bit, repeatnode, nextnode;
2466 if(length > code->maxlength)
2467 code->maxlength = length;
2468 if(length < code->minlength)
2469 code->minlength = length;
2472 if (repeatpos == 0 || (repeatpos >= 0
2473 && (((codebits >> (repeatpos - 1)) & 3) == 0
2474 || ((codebits >> (repeatpos - 1)) & 3) == 3)))
2476 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2477 "Invalid repeat position");
2478 return (ARCHIVE_FATAL);
2482 for (bitpos = length - 1; bitpos >= 0; bitpos--)
2484 bit = (codebits >> bitpos) & 1;
2486 /* Leaf node check */
2487 if (code->tree[lastnode].branches[0] ==
2488 code->tree[lastnode].branches[1])
2490 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2492 return (ARCHIVE_FATAL);
2495 if (bitpos == repeatpos)
2497 /* Open branch check */
2498 if (!(code->tree[lastnode].branches[bit] < 0))
2500 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2501 "Invalid repeating code");
2502 return (ARCHIVE_FATAL);
2505 if ((repeatnode = new_node(code)) < 0) {
2506 archive_set_error(&a->archive, ENOMEM,
2507 "Unable to allocate memory for node data.");
2508 return (ARCHIVE_FATAL);
2510 if ((nextnode = new_node(code)) < 0) {
2511 archive_set_error(&a->archive, ENOMEM,
2512 "Unable to allocate memory for node data.");
2513 return (ARCHIVE_FATAL);
2517 code->tree[lastnode].branches[bit] = repeatnode;
2518 code->tree[repeatnode].branches[bit] = repeatnode;
2519 code->tree[repeatnode].branches[bit^1] = nextnode;
2520 lastnode = nextnode;
2522 bitpos++; /* terminating bit already handled, skip it */
2526 /* Open branch check */
2527 if (code->tree[lastnode].branches[bit] < 0)
2529 if (new_node(code) < 0) {
2530 archive_set_error(&a->archive, ENOMEM,
2531 "Unable to allocate memory for node data.");
2532 return (ARCHIVE_FATAL);
2534 code->tree[lastnode].branches[bit] = code->numentries++;
2538 lastnode = code->tree[lastnode].branches[bit];
2542 if (!(code->tree[lastnode].branches[0] == -1
2543 && code->tree[lastnode].branches[1] == -2))
2545 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2547 return (ARCHIVE_FATAL);
2550 /* Set leaf value */
2551 code->tree[lastnode].branches[0] = value;
2552 code->tree[lastnode].branches[1] = value;
2554 return (ARCHIVE_OK);
2558 new_node(struct huffman_code *code)
2561 if (code->numallocatedentries == code->numentries) {
2562 int new_num_entries = 256;
2563 if (code->numentries > 0) {
2564 new_num_entries = code->numentries * 2;
2566 new_tree = realloc(code->tree, new_num_entries * sizeof(*code->tree));
2567 if (new_tree == NULL)
2569 code->tree = (struct huffman_tree_node *)new_tree;
2570 code->numallocatedentries = new_num_entries;
2572 code->tree[code->numentries].branches[0] = -1;
2573 code->tree[code->numentries].branches[1] = -2;
2578 make_table(struct archive_read *a, struct huffman_code *code)
2580 if (code->maxlength < code->minlength || code->maxlength > 10)
2581 code->tablesize = 10;
2583 code->tablesize = code->maxlength;
2586 (struct huffman_table_entry *)calloc(1, sizeof(*code->table)
2587 * ((size_t)1 << code->tablesize));
2589 return make_table_recurse(a, code, 0, code->table, 0, code->tablesize);
2593 make_table_recurse(struct archive_read *a, struct huffman_code *code, int node,
2594 struct huffman_table_entry *table, int depth,
2597 int currtablesize, i, ret = (ARCHIVE_OK);
2601 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2602 "Huffman tree was not created.");
2603 return (ARCHIVE_FATAL);
2605 if (node < 0 || node >= code->numentries)
2607 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2608 "Invalid location to Huffman tree specified.");
2609 return (ARCHIVE_FATAL);
2612 currtablesize = 1 << (maxdepth - depth);
2614 if (code->tree[node].branches[0] ==
2615 code->tree[node].branches[1])
2617 for(i = 0; i < currtablesize; i++)
2619 table[i].length = depth;
2620 table[i].value = code->tree[node].branches[0];
2625 for(i = 0; i < currtablesize; i++)
2626 table[i].length = -1;
2630 if(depth == maxdepth)
2632 table[0].length = maxdepth + 1;
2633 table[0].value = node;
2637 ret |= make_table_recurse(a, code, code->tree[node].branches[0], table,
2638 depth + 1, maxdepth);
2639 ret |= make_table_recurse(a, code, code->tree[node].branches[1],
2640 table + currtablesize / 2, depth + 1, maxdepth);
2647 expand(struct archive_read *a, int64_t end)
2649 static const unsigned char lengthbases[] =
2650 { 0, 1, 2, 3, 4, 5, 6,
2651 7, 8, 10, 12, 14, 16, 20,
2652 24, 28, 32, 40, 48, 56, 64,
2653 80, 96, 112, 128, 160, 192, 224 };
2654 static const unsigned char lengthbits[] =
2655 { 0, 0, 0, 0, 0, 0, 0,
2656 0, 1, 1, 1, 1, 2, 2,
2657 2, 2, 3, 3, 3, 3, 4,
2658 4, 4, 4, 5, 5, 5, 5 };
2659 static const unsigned int offsetbases[] =
2661 8, 12, 16, 24, 32, 48,
2662 64, 96, 128, 192, 256, 384,
2663 512, 768, 1024, 1536, 2048, 3072,
2664 4096, 6144, 8192, 12288, 16384, 24576,
2665 32768, 49152, 65536, 98304, 131072, 196608,
2666 262144, 327680, 393216, 458752, 524288, 589824,
2667 655360, 720896, 786432, 851968, 917504, 983040,
2668 1048576, 1310720, 1572864, 1835008, 2097152, 2359296,
2669 2621440, 2883584, 3145728, 3407872, 3670016, 3932160 };
2670 static const unsigned char offsetbits[] =
2671 { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4,
2672 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
2673 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
2674 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
2675 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 };
2676 static const unsigned char shortbases[] =
2677 { 0, 4, 8, 16, 32, 64, 128, 192 };
2678 static const unsigned char shortbits[] =
2679 { 2, 2, 3, 4, 5, 6, 6, 6 };
2681 int symbol, offs, len, offsindex, lensymbol, i, offssymbol, lowoffsetsymbol;
2682 unsigned char newfile;
2683 struct rar *rar = (struct rar *)(a->format->data);
2684 struct rar_br *br = &(rar->br);
2686 if (rar->filterstart < end)
2687 end = rar->filterstart;
2691 if (rar->output_last_match &&
2692 lzss_position(&rar->lzss) + rar->lastlength <= end)
2694 lzss_emit_match(rar, rar->lastoffset, rar->lastlength);
2695 rar->output_last_match = 0;
2698 if(rar->is_ppmd_block || rar->output_last_match ||
2699 lzss_position(&rar->lzss) >= end)
2700 return lzss_position(&rar->lzss);
2702 if ((symbol = read_next_symbol(a, &rar->maincode)) < 0)
2703 return (ARCHIVE_FATAL);
2704 rar->output_last_match = 0;
2708 lzss_emit_literal(rar, symbol);
2711 else if (symbol == 256)
2713 if (!rar_br_read_ahead(a, br, 1))
2714 goto truncated_data;
2715 newfile = !rar_br_bits(br, 1);
2716 rar_br_consume(br, 1);
2720 rar->start_new_block = 1;
2721 if (!rar_br_read_ahead(a, br, 1))
2722 goto truncated_data;
2723 rar->start_new_table = rar_br_bits(br, 1);
2724 rar_br_consume(br, 1);
2725 return lzss_position(&rar->lzss);
2729 if (parse_codes(a) != ARCHIVE_OK)
2730 return (ARCHIVE_FATAL);
2734 else if(symbol==257)
2736 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2737 "Parsing filters is unsupported.");
2738 return (ARCHIVE_FAILED);
2740 else if(symbol==258)
2742 if(rar->lastlength == 0)
2745 offs = rar->lastoffset;
2746 len = rar->lastlength;
2748 else if (symbol <= 262)
2750 offsindex = symbol - 259;
2751 offs = rar->oldoffset[offsindex];
2753 if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0)
2755 if (lensymbol > (int)(sizeof(lengthbases)/sizeof(lengthbases[0])))
2757 if (lensymbol > (int)(sizeof(lengthbits)/sizeof(lengthbits[0])))
2759 len = lengthbases[lensymbol] + 2;
2760 if (lengthbits[lensymbol] > 0) {
2761 if (!rar_br_read_ahead(a, br, lengthbits[lensymbol]))
2762 goto truncated_data;
2763 len += rar_br_bits(br, lengthbits[lensymbol]);
2764 rar_br_consume(br, lengthbits[lensymbol]);
2767 for (i = offsindex; i > 0; i--)
2768 rar->oldoffset[i] = rar->oldoffset[i-1];
2769 rar->oldoffset[0] = offs;
2771 else if(symbol<=270)
2773 offs = shortbases[symbol-263] + 1;
2774 if(shortbits[symbol-263] > 0) {
2775 if (!rar_br_read_ahead(a, br, shortbits[symbol-263]))
2776 goto truncated_data;
2777 offs += rar_br_bits(br, shortbits[symbol-263]);
2778 rar_br_consume(br, shortbits[symbol-263]);
2783 for(i = 3; i > 0; i--)
2784 rar->oldoffset[i] = rar->oldoffset[i-1];
2785 rar->oldoffset[0] = offs;
2789 if (symbol-271 > (int)(sizeof(lengthbases)/sizeof(lengthbases[0])))
2791 if (symbol-271 > (int)(sizeof(lengthbits)/sizeof(lengthbits[0])))
2793 len = lengthbases[symbol-271]+3;
2794 if(lengthbits[symbol-271] > 0) {
2795 if (!rar_br_read_ahead(a, br, lengthbits[symbol-271]))
2796 goto truncated_data;
2797 len += rar_br_bits(br, lengthbits[symbol-271]);
2798 rar_br_consume(br, lengthbits[symbol-271]);
2801 if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0)
2803 if (offssymbol > (int)(sizeof(offsetbases)/sizeof(offsetbases[0])))
2805 if (offssymbol > (int)(sizeof(offsetbits)/sizeof(offsetbits[0])))
2807 offs = offsetbases[offssymbol]+1;
2808 if(offsetbits[offssymbol] > 0)
2812 if(offsetbits[offssymbol] > 4) {
2813 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol] - 4))
2814 goto truncated_data;
2815 offs += rar_br_bits(br, offsetbits[offssymbol] - 4) << 4;
2816 rar_br_consume(br, offsetbits[offssymbol] - 4);
2819 if(rar->numlowoffsetrepeats > 0)
2821 rar->numlowoffsetrepeats--;
2822 offs += rar->lastlowoffset;
2826 if ((lowoffsetsymbol =
2827 read_next_symbol(a, &rar->lowoffsetcode)) < 0)
2828 return (ARCHIVE_FATAL);
2829 if(lowoffsetsymbol == 16)
2831 rar->numlowoffsetrepeats = 15;
2832 offs += rar->lastlowoffset;
2836 offs += lowoffsetsymbol;
2837 rar->lastlowoffset = lowoffsetsymbol;
2842 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol]))
2843 goto truncated_data;
2844 offs += rar_br_bits(br, offsetbits[offssymbol]);
2845 rar_br_consume(br, offsetbits[offssymbol]);
2849 if (offs >= 0x40000)
2854 for(i = 3; i > 0; i--)
2855 rar->oldoffset[i] = rar->oldoffset[i-1];
2856 rar->oldoffset[0] = offs;
2859 rar->lastoffset = offs;
2860 rar->lastlength = len;
2861 rar->output_last_match = 1;
2864 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2865 "Truncated RAR file data");
2867 return (ARCHIVE_FATAL);
2869 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2870 "Bad RAR file data");
2871 return (ARCHIVE_FATAL);
2875 copy_from_lzss_window(struct archive_read *a, const void **buffer,
2876 int64_t startpos, int length)
2878 int windowoffs, firstpart;
2879 struct rar *rar = (struct rar *)(a->format->data);
2881 if (!rar->unp_buffer)
2883 if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL)
2885 archive_set_error(&a->archive, ENOMEM,
2886 "Unable to allocate memory for uncompressed data.");
2887 return (ARCHIVE_FATAL);
2891 windowoffs = lzss_offset_for_position(&rar->lzss, startpos);
2892 if(windowoffs + length <= lzss_size(&rar->lzss)) {
2893 memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs],
2895 } else if (length <= lzss_size(&rar->lzss)) {
2896 firstpart = lzss_size(&rar->lzss) - windowoffs;
2897 if (firstpart < 0) {
2898 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2899 "Bad RAR file data");
2900 return (ARCHIVE_FATAL);
2902 if (firstpart < length) {
2903 memcpy(&rar->unp_buffer[rar->unp_offset],
2904 &rar->lzss.window[windowoffs], firstpart);
2905 memcpy(&rar->unp_buffer[rar->unp_offset + firstpart],
2906 &rar->lzss.window[0], length - firstpart);
2908 memcpy(&rar->unp_buffer[rar->unp_offset],
2909 &rar->lzss.window[windowoffs], length);
2912 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2913 "Bad RAR file data");
2914 return (ARCHIVE_FATAL);
2916 rar->unp_offset += length;
2917 if (rar->unp_offset >= rar->unp_buffer_size)
2918 *buffer = rar->unp_buffer;
2921 return (ARCHIVE_OK);
2925 rar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail)
2927 struct rar *rar = (struct rar *)(a->format->data);
2928 const void *h = __archive_read_ahead(a, min, avail);
2932 if (a->archive.read_data_is_posix_read && *avail > (ssize_t)a->archive.read_data_requested)
2933 *avail = a->archive.read_data_requested;
2934 if (*avail > rar->bytes_remaining)
2935 *avail = (ssize_t)rar->bytes_remaining;
2938 else if (*avail == 0 && rar->main_flags & MHD_VOLUME &&
2939 rar->file_flags & FHD_SPLIT_AFTER)
2941 ret = archive_read_format_rar_read_header(a, a->entry);
2942 if (ret == (ARCHIVE_EOF))
2944 rar->has_endarc_header = 1;
2945 ret = archive_read_format_rar_read_header(a, a->entry);
2947 if (ret != (ARCHIVE_OK))
2949 return rar_read_ahead(a, min, avail);