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;
192 struct huffman_table_entry *table;
197 unsigned char *window;
202 struct data_block_offsets
205 int64_t start_offset;
211 /* Entries from main RAR header */
213 unsigned long file_crc;
218 /* File header entries */
219 char compression_method;
228 size_t filename_allocated;
230 /* File header optional entries */
239 /* Fields to help with tracking decompression of files. */
240 int64_t bytes_unconsumed;
241 int64_t bytes_remaining;
242 int64_t bytes_uncopied;
244 int64_t offset_outgoing;
247 unsigned int unp_offset;
248 unsigned int unp_buffer_size;
249 unsigned char *unp_buffer;
250 unsigned int dictionary_size;
251 char start_new_block;
253 unsigned long crc_calculated;
254 int found_first_header;
255 char has_endarc_header;
256 struct data_block_offsets *dbo;
261 struct huffman_code maincode;
262 struct huffman_code offsetcode;
263 struct huffman_code lowoffsetcode;
264 struct huffman_code lengthcode;
265 unsigned char lengthtable[HUFFMAN_TABLE_SIZE];
267 char output_last_match;
268 unsigned int lastlength;
269 unsigned int lastoffset;
270 unsigned int oldoffset[4];
271 unsigned int lastlowoffset;
272 unsigned int numlowoffsetrepeats;
274 char start_new_table;
276 /* PPMd Variant H members */
281 CPpmd7 ppmd7_context;
282 CPpmd7z_RangeDec range_dec;
286 * String conversion object.
288 int init_default_conversion;
289 struct archive_string_conv *sconv_default;
290 struct archive_string_conv *opt_sconv;
291 struct archive_string_conv *sconv_utf8;
292 struct archive_string_conv *sconv_utf16be;
298 #define CACHE_TYPE uint64_t
299 #define CACHE_BITS (8 * sizeof(CACHE_TYPE))
301 CACHE_TYPE cache_buffer;
302 /* Indicates how many bits avail in cache_buffer. */
305 const unsigned char *next_in;
309 static int archive_read_format_rar_bid(struct archive_read *, int);
310 static int archive_read_format_rar_options(struct archive_read *,
311 const char *, const char *);
312 static int archive_read_format_rar_read_header(struct archive_read *,
313 struct archive_entry *);
314 static int archive_read_format_rar_read_data(struct archive_read *,
315 const void **, size_t *, int64_t *);
316 static int archive_read_format_rar_read_data_skip(struct archive_read *a);
317 static int64_t archive_read_format_rar_seek_data(struct archive_read *, int64_t,
319 static int archive_read_format_rar_cleanup(struct archive_read *);
321 /* Support functions */
322 static int read_header(struct archive_read *, struct archive_entry *, char);
323 static time_t get_time(int);
324 static int read_exttime(const char *, struct rar *, const char *);
325 static int read_symlink_stored(struct archive_read *, struct archive_entry *,
326 struct archive_string_conv *);
327 static int read_data_stored(struct archive_read *, const void **, size_t *,
329 static int read_data_compressed(struct archive_read *, const void **, size_t *,
331 static int rar_br_preparation(struct archive_read *, struct rar_br *);
332 static int parse_codes(struct archive_read *);
333 static void free_codes(struct archive_read *);
334 static int read_next_symbol(struct archive_read *, struct huffman_code *);
335 static int create_code(struct archive_read *, struct huffman_code *,
336 unsigned char *, int, char);
337 static int add_value(struct archive_read *, struct huffman_code *, int, int,
339 static int new_node(struct huffman_code *);
340 static int make_table(struct archive_read *, struct huffman_code *);
341 static int make_table_recurse(struct archive_read *, struct huffman_code *, int,
342 struct huffman_table_entry *, int, int);
343 static int64_t expand(struct archive_read *, int64_t);
344 static int copy_from_lzss_window(struct archive_read *, const void **,
346 static const void *rar_read_ahead(struct archive_read *, size_t, ssize_t *);
351 /* Check that the cache buffer has enough bits. */
352 #define rar_br_has(br, n) ((br)->cache_avail >= n)
353 /* Get compressed data by bit. */
354 #define rar_br_bits(br, n) \
355 (((uint32_t)((br)->cache_buffer >> \
356 ((br)->cache_avail - (n)))) & cache_masks[n])
357 #define rar_br_bits_forced(br, n) \
358 (((uint32_t)((br)->cache_buffer << \
359 ((n) - (br)->cache_avail))) & cache_masks[n])
360 /* Read ahead to make sure the cache buffer has enough compressed data we
362 * True : completed, there is enough data in the cache buffer.
363 * False : there is no data in the stream. */
364 #define rar_br_read_ahead(a, br, n) \
365 ((rar_br_has(br, (n)) || rar_br_fillup(a, br)) || rar_br_has(br, (n)))
366 /* Notify how many bits we consumed. */
367 #define rar_br_consume(br, n) ((br)->cache_avail -= (n))
368 #define rar_br_consume_unalined_bits(br) ((br)->cache_avail &= ~7)
370 static const uint32_t cache_masks[] = {
371 0x00000000, 0x00000001, 0x00000003, 0x00000007,
372 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F,
373 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,
374 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF,
375 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF,
376 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,
377 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF,
378 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF,
379 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
383 * Shift away used bits in the cache data and fill it up with following bits.
384 * Call this when cache buffer does not have enough bits you need.
386 * Returns 1 if the cache buffer is full.
387 * Returns 0 if the cache buffer is not full; input buffer is empty.
390 rar_br_fillup(struct archive_read *a, struct rar_br *br)
392 struct rar *rar = (struct rar *)(a->format->data);
393 int n = CACHE_BITS - br->cache_avail;
398 if (br->avail_in >= 8) {
400 ((uint64_t)br->next_in[0]) << 56 |
401 ((uint64_t)br->next_in[1]) << 48 |
402 ((uint64_t)br->next_in[2]) << 40 |
403 ((uint64_t)br->next_in[3]) << 32 |
404 ((uint32_t)br->next_in[4]) << 24 |
405 ((uint32_t)br->next_in[5]) << 16 |
406 ((uint32_t)br->next_in[6]) << 8 |
407 (uint32_t)br->next_in[7];
410 br->cache_avail += 8 * 8;
411 rar->bytes_unconsumed += 8;
412 rar->bytes_remaining -= 8;
417 if (br->avail_in >= 7) {
419 (br->cache_buffer << 56) |
420 ((uint64_t)br->next_in[0]) << 48 |
421 ((uint64_t)br->next_in[1]) << 40 |
422 ((uint64_t)br->next_in[2]) << 32 |
423 ((uint32_t)br->next_in[3]) << 24 |
424 ((uint32_t)br->next_in[4]) << 16 |
425 ((uint32_t)br->next_in[5]) << 8 |
426 (uint32_t)br->next_in[6];
429 br->cache_avail += 7 * 8;
430 rar->bytes_unconsumed += 7;
431 rar->bytes_remaining -= 7;
436 if (br->avail_in >= 6) {
438 (br->cache_buffer << 48) |
439 ((uint64_t)br->next_in[0]) << 40 |
440 ((uint64_t)br->next_in[1]) << 32 |
441 ((uint32_t)br->next_in[2]) << 24 |
442 ((uint32_t)br->next_in[3]) << 16 |
443 ((uint32_t)br->next_in[4]) << 8 |
444 (uint32_t)br->next_in[5];
447 br->cache_avail += 6 * 8;
448 rar->bytes_unconsumed += 6;
449 rar->bytes_remaining -= 6;
454 /* We have enough compressed data in
455 * the cache buffer.*/
460 if (br->avail_in <= 0) {
462 if (rar->bytes_unconsumed > 0) {
463 /* Consume as much as the decompressor
465 __archive_read_consume(a, rar->bytes_unconsumed);
466 rar->bytes_unconsumed = 0;
468 br->next_in = rar_read_ahead(a, 1, &(br->avail_in));
469 if (br->next_in == NULL)
471 if (br->avail_in == 0)
475 (br->cache_buffer << 8) | *br->next_in++;
477 br->cache_avail += 8;
479 rar->bytes_unconsumed++;
480 rar->bytes_remaining--;
485 rar_br_preparation(struct archive_read *a, struct rar_br *br)
487 struct rar *rar = (struct rar *)(a->format->data);
489 if (rar->bytes_remaining > 0) {
490 br->next_in = rar_read_ahead(a, 1, &(br->avail_in));
491 if (br->next_in == NULL) {
492 archive_set_error(&a->archive,
493 ARCHIVE_ERRNO_FILE_FORMAT,
494 "Truncated RAR file data");
495 return (ARCHIVE_FATAL);
497 if (br->cache_avail == 0)
498 (void)rar_br_fillup(a, br);
503 /* Find last bit set */
505 rar_fls(unsigned int word)
511 word |= (word >> 16);
512 return word - (word >> 1);
516 static inline int64_t
517 lzss_position(struct lzss *lzss)
519 return lzss->position;
523 lzss_mask(struct lzss *lzss)
529 lzss_size(struct lzss *lzss)
531 return lzss->mask + 1;
535 lzss_offset_for_position(struct lzss *lzss, int64_t pos)
537 return (int)(pos & lzss->mask);
540 static inline unsigned char *
541 lzss_pointer_for_position(struct lzss *lzss, int64_t pos)
543 return &lzss->window[lzss_offset_for_position(lzss, pos)];
547 lzss_current_offset(struct lzss *lzss)
549 return lzss_offset_for_position(lzss, lzss->position);
552 static inline uint8_t *
553 lzss_current_pointer(struct lzss *lzss)
555 return lzss_pointer_for_position(lzss, lzss->position);
559 lzss_emit_literal(struct rar *rar, uint8_t literal)
561 *lzss_current_pointer(&rar->lzss) = literal;
562 rar->lzss.position++;
566 lzss_emit_match(struct rar *rar, int offset, int length)
568 int dstoffs = lzss_current_offset(&rar->lzss);
569 int srcoffs = (dstoffs - offset) & lzss_mask(&rar->lzss);
570 int l, li, remaining;
571 unsigned char *d, *s;
574 while (remaining > 0) {
576 if (dstoffs > srcoffs) {
577 if (l > lzss_size(&rar->lzss) - dstoffs)
578 l = lzss_size(&rar->lzss) - dstoffs;
580 if (l > lzss_size(&rar->lzss) - srcoffs)
581 l = lzss_size(&rar->lzss) - srcoffs;
583 d = &(rar->lzss.window[dstoffs]);
584 s = &(rar->lzss.window[srcoffs]);
585 if ((dstoffs + l < srcoffs) || (srcoffs + l < dstoffs))
588 for (li = 0; li < l; li++)
592 dstoffs = (dstoffs + l) & lzss_mask(&(rar->lzss));
593 srcoffs = (srcoffs + l) & lzss_mask(&(rar->lzss));
595 rar->lzss.position += length;
599 ppmd_alloc(void *p, size_t size)
605 ppmd_free(void *p, void *address)
610 static ISzAlloc g_szalloc = { ppmd_alloc, ppmd_free };
615 struct archive_read *a = ((IByteIn*)p)->a;
616 struct rar *rar = (struct rar *)(a->format->data);
617 struct rar_br *br = &(rar->br);
619 if (!rar_br_read_ahead(a, br, 8))
621 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
622 "Truncated RAR file data");
626 b = rar_br_bits(br, 8);
627 rar_br_consume(br, 8);
632 archive_read_support_format_rar(struct archive *_a)
634 struct archive_read *a = (struct archive_read *)_a;
638 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
639 "archive_read_support_format_rar");
641 rar = (struct rar *)malloc(sizeof(*rar));
644 archive_set_error(&a->archive, ENOMEM, "Can't allocate rar data");
645 return (ARCHIVE_FATAL);
647 memset(rar, 0, sizeof(*rar));
649 r = __archive_read_register_format(a,
652 archive_read_format_rar_bid,
653 archive_read_format_rar_options,
654 archive_read_format_rar_read_header,
655 archive_read_format_rar_read_data,
656 archive_read_format_rar_read_data_skip,
657 archive_read_format_rar_seek_data,
658 archive_read_format_rar_cleanup);
666 archive_read_format_rar_bid(struct archive_read *a, int best_bid)
670 /* If there's already a bid > 30, we'll never win. */
674 if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)
677 if (memcmp(p, RAR_SIGNATURE, 7) == 0)
680 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
681 /* This is a PE file */
682 ssize_t offset = 0x10000;
683 ssize_t window = 4096;
685 while (offset + window <= (1024 * 128)) {
686 const char *buff = __archive_read_ahead(a, offset + window, &bytes_avail);
688 /* Remaining bytes are less than window. */
695 while (p + 7 < buff + bytes_avail) {
696 if (memcmp(p, RAR_SIGNATURE, 7) == 0)
707 skip_sfx(struct archive_read *a)
712 ssize_t bytes, window;
716 while (total + window <= (1024 * 128)) {
717 h = __archive_read_ahead(a, window, &bytes);
719 /* Remaining bytes are less than window. */
731 * Scan ahead until we find something that looks
732 * like the RAR header.
735 if (memcmp(p, RAR_SIGNATURE, 7) == 0) {
736 skip = p - (const char *)h;
737 __archive_read_consume(a, skip);
742 skip = p - (const char *)h;
743 __archive_read_consume(a, skip);
747 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
748 "Couldn't find out RAR header");
749 return (ARCHIVE_FATAL);
753 archive_read_format_rar_options(struct archive_read *a,
754 const char *key, const char *val)
757 int ret = ARCHIVE_FAILED;
759 rar = (struct rar *)(a->format->data);
760 if (strcmp(key, "hdrcharset") == 0) {
761 if (val == NULL || val[0] == 0)
762 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
763 "rar: hdrcharset option needs a character-set name");
766 archive_string_conversion_from_charset(
767 &a->archive, val, 0);
768 if (rar->opt_sconv != NULL)
776 /* Note: The "warn" return is just to inform the options
777 * supervisor that we didn't handle it. It will generate
778 * a suitable error if no one used this option. */
779 return (ARCHIVE_WARN);
783 archive_read_format_rar_read_header(struct archive_read *a,
784 struct archive_entry *entry)
794 a->archive.archive_format = ARCHIVE_FORMAT_RAR;
795 if (a->archive.archive_format_name == NULL)
796 a->archive.archive_format_name = "RAR";
798 rar = (struct rar *)(a->format->data);
800 /* RAR files can be generated without EOF headers, so return ARCHIVE_EOF if
803 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
804 return (ARCHIVE_EOF);
807 if (rar->found_first_header == 0 &&
808 ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0)) {
809 /* This is an executable ? Must be self-extracting... */
811 if (ret < ARCHIVE_WARN)
814 rar->found_first_header = 1;
818 unsigned long crc32_val;
820 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
821 return (ARCHIVE_FATAL);
828 if (memcmp(p, RAR_SIGNATURE, 7) != 0) {
829 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
830 "Invalid marker header");
831 return (ARCHIVE_FATAL);
833 __archive_read_consume(a, 7);
837 rar->main_flags = archive_le16dec(p + 3);
838 skip = archive_le16dec(p + 5);
839 if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)) {
840 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
841 "Invalid header size");
842 return (ARCHIVE_FATAL);
844 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL)
845 return (ARCHIVE_FATAL);
847 memcpy(rar->reserved1, p + 7, sizeof(rar->reserved1));
848 memcpy(rar->reserved2, p + 7 + sizeof(rar->reserved1),
849 sizeof(rar->reserved2));
850 if (rar->main_flags & MHD_ENCRYPTVER) {
851 if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)+1) {
852 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
853 "Invalid header size");
854 return (ARCHIVE_FATAL);
856 rar->encryptver = *(p + 7 + sizeof(rar->reserved1) +
857 sizeof(rar->reserved2));
860 if (rar->main_flags & MHD_PASSWORD)
862 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
863 "RAR encryption support unavailable.");
864 return (ARCHIVE_FATAL);
867 crc32_val = crc32(0, (const unsigned char *)p + 2, (unsigned)skip - 2);
868 if ((crc32_val & 0xffff) != archive_le16dec(p)) {
869 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
871 return (ARCHIVE_FATAL);
873 __archive_read_consume(a, skip);
877 return read_header(a, entry, head_type);
885 flags = archive_le16dec(p + 3);
886 skip = archive_le16dec(p + 5);
888 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
889 "Invalid header size");
890 return (ARCHIVE_FATAL);
893 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL)
894 return (ARCHIVE_FATAL);
897 if (flags & HD_ADD_SIZE_PRESENT)
900 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
901 "Invalid header size");
902 return (ARCHIVE_FATAL);
904 skip += archive_le32dec(p + 7);
905 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL)
906 return (ARCHIVE_FATAL);
910 crc32_val = crc32(0, (const unsigned char *)p + 2, (unsigned)skip - 2);
911 if ((crc32_val & 0xffff) != archive_le16dec(p)) {
912 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
914 return (ARCHIVE_FATAL);
916 __archive_read_consume(a, skip);
917 if (head_type == ENDARC_HEAD)
918 return (ARCHIVE_EOF);
922 if ((ret = read_header(a, entry, head_type)) < ARCHIVE_WARN)
927 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
929 return (ARCHIVE_FATAL);
935 archive_read_format_rar_read_data(struct archive_read *a, const void **buff,
936 size_t *size, int64_t *offset)
938 struct rar *rar = (struct rar *)(a->format->data);
941 if (rar->bytes_unconsumed > 0) {
942 /* Consume as much as the decompressor actually used. */
943 __archive_read_consume(a, rar->bytes_unconsumed);
944 rar->bytes_unconsumed = 0;
947 if (rar->entry_eof || rar->offset_seek >= rar->unp_size) {
950 *offset = rar->offset;
951 if (*offset < rar->unp_size)
952 *offset = rar->unp_size;
953 return (ARCHIVE_EOF);
956 switch (rar->compression_method)
958 case COMPRESS_METHOD_STORE:
959 ret = read_data_stored(a, buff, size, offset);
962 case COMPRESS_METHOD_FASTEST:
963 case COMPRESS_METHOD_FAST:
964 case COMPRESS_METHOD_NORMAL:
965 case COMPRESS_METHOD_GOOD:
966 case COMPRESS_METHOD_BEST:
967 ret = read_data_compressed(a, buff, size, offset);
968 if (ret != ARCHIVE_OK && ret != ARCHIVE_WARN)
969 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc);
973 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
974 "Unsupported compression method for RAR file.");
982 archive_read_format_rar_read_data_skip(struct archive_read *a)
985 int64_t bytes_skipped;
988 rar = (struct rar *)(a->format->data);
990 if (rar->bytes_unconsumed > 0) {
991 /* Consume as much as the decompressor actually used. */
992 __archive_read_consume(a, rar->bytes_unconsumed);
993 rar->bytes_unconsumed = 0;
996 if (rar->bytes_remaining > 0) {
997 bytes_skipped = __archive_read_consume(a, rar->bytes_remaining);
998 if (bytes_skipped < 0)
999 return (ARCHIVE_FATAL);
1002 /* Compressed data to skip must be read from each header in a multivolume
1005 if (rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER)
1007 ret = archive_read_format_rar_read_header(a, a->entry);
1008 if (ret == (ARCHIVE_EOF))
1009 ret = archive_read_format_rar_read_header(a, a->entry);
1010 if (ret != (ARCHIVE_OK))
1012 return archive_read_format_rar_read_data_skip(a);
1015 return (ARCHIVE_OK);
1019 archive_read_format_rar_seek_data(struct archive_read *a, int64_t offset,
1022 int64_t client_offset, ret;
1024 struct rar *rar = (struct rar *)(a->format->data);
1026 if (rar->compression_method == COMPRESS_METHOD_STORE)
1028 /* Modify the offset for use with SEEK_SET */
1032 client_offset = rar->offset_seek;
1035 client_offset = rar->unp_size;
1041 client_offset += offset;
1042 if (client_offset < 0)
1044 /* Can't seek past beginning of data block */
1047 else if (client_offset > rar->unp_size)
1050 * Set the returned offset but only seek to the end of
1053 rar->offset_seek = client_offset;
1054 client_offset = rar->unp_size;
1057 client_offset += rar->dbo[0].start_offset;
1059 while (i < rar->cursor)
1062 client_offset += rar->dbo[i].start_offset - rar->dbo[i-1].end_offset;
1064 if (rar->main_flags & MHD_VOLUME)
1066 /* Find the appropriate offset among the multivolume archive */
1069 if (client_offset < rar->dbo[rar->cursor].start_offset &&
1070 rar->file_flags & FHD_SPLIT_BEFORE)
1072 /* Search backwards for the correct data block */
1073 if (rar->cursor == 0)
1075 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1076 "Attempt to seek past beginning of RAR data block");
1077 return (ARCHIVE_FAILED);
1080 client_offset -= rar->dbo[rar->cursor+1].start_offset -
1081 rar->dbo[rar->cursor].end_offset;
1082 if (client_offset < rar->dbo[rar->cursor].start_offset)
1084 ret = __archive_read_seek(a, rar->dbo[rar->cursor].start_offset -
1085 rar->dbo[rar->cursor].header_size, SEEK_SET);
1086 if (ret < (ARCHIVE_OK))
1088 ret = archive_read_format_rar_read_header(a, a->entry);
1089 if (ret != (ARCHIVE_OK))
1091 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1092 "Error during seek of RAR file");
1093 return (ARCHIVE_FAILED);
1098 else if (client_offset > rar->dbo[rar->cursor].end_offset &&
1099 rar->file_flags & FHD_SPLIT_AFTER)
1101 /* Search forward for the correct data block */
1103 if (rar->cursor < rar->nodes &&
1104 client_offset > rar->dbo[rar->cursor].end_offset)
1106 client_offset += rar->dbo[rar->cursor].start_offset -
1107 rar->dbo[rar->cursor-1].end_offset;
1111 ret = __archive_read_seek(a, rar->dbo[rar->cursor].end_offset,
1113 if (ret < (ARCHIVE_OK))
1115 ret = archive_read_format_rar_read_header(a, a->entry);
1116 if (ret == (ARCHIVE_EOF))
1118 rar->has_endarc_header = 1;
1119 ret = archive_read_format_rar_read_header(a, a->entry);
1121 if (ret != (ARCHIVE_OK))
1123 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1124 "Error during seek of RAR file");
1125 return (ARCHIVE_FAILED);
1127 client_offset += rar->dbo[rar->cursor].start_offset -
1128 rar->dbo[rar->cursor-1].end_offset;
1135 ret = __archive_read_seek(a, client_offset, SEEK_SET);
1136 if (ret < (ARCHIVE_OK))
1138 rar->bytes_remaining = rar->dbo[rar->cursor].end_offset - ret;
1143 ret -= rar->dbo[i+1].start_offset - rar->dbo[i].end_offset;
1145 ret -= rar->dbo[0].start_offset;
1147 /* Always restart reading the file after a seek */
1148 a->read_data_block = NULL;
1149 a->read_data_offset = 0;
1150 a->read_data_output_offset = 0;
1151 a->read_data_remaining = 0;
1152 rar->bytes_unconsumed = 0;
1156 * If a seek past the end of file was requested, return the requested
1159 if (ret == rar->unp_size && rar->offset_seek > rar->unp_size)
1160 return rar->offset_seek;
1162 /* Return the new offset */
1163 rar->offset_seek = ret;
1164 return rar->offset_seek;
1168 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1169 "Seeking of compressed RAR files is unsupported");
1171 return (ARCHIVE_FAILED);
1175 archive_read_format_rar_cleanup(struct archive_read *a)
1179 rar = (struct rar *)(a->format->data);
1181 free(rar->filename);
1182 free(rar->filename_save);
1184 free(rar->unp_buffer);
1185 free(rar->lzss.window);
1186 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc);
1188 (a->format->data) = NULL;
1189 return (ARCHIVE_OK);
1193 read_header(struct archive_read *a, struct archive_entry *entry,
1197 const char *p, *endp;
1199 struct rar_header rar_header;
1200 struct rar_file_header file_header;
1201 int64_t header_size;
1202 unsigned filename_size, end;
1205 char packed_size[8];
1208 struct archive_string_conv *sconv, *fn_sconv;
1209 unsigned long crc32_val;
1210 int ret = (ARCHIVE_OK), ret2;
1212 rar = (struct rar *)(a->format->data);
1214 /* Setup a string conversion object for non-rar-unicode filenames. */
1215 sconv = rar->opt_sconv;
1216 if (sconv == NULL) {
1217 if (!rar->init_default_conversion) {
1218 rar->sconv_default =
1219 archive_string_default_conversion_for_read(
1221 rar->init_default_conversion = 1;
1223 sconv = rar->sconv_default;
1227 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
1228 return (ARCHIVE_FATAL);
1230 memcpy(&rar_header, p, sizeof(rar_header));
1231 rar->file_flags = archive_le16dec(rar_header.flags);
1232 header_size = archive_le16dec(rar_header.size);
1233 if (header_size < (int64_t)sizeof(file_header) + 7) {
1234 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1235 "Invalid header size");
1236 return (ARCHIVE_FATAL);
1238 crc32_val = crc32(0, (const unsigned char *)p + 2, 7 - 2);
1239 __archive_read_consume(a, 7);
1241 if (!(rar->file_flags & FHD_SOLID))
1243 rar->compression_method = 0;
1244 rar->packed_size = 0;
1251 memset(&rar->salt, 0, sizeof(rar->salt));
1263 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1264 "RAR solid archive support unavailable.");
1265 return (ARCHIVE_FATAL);
1268 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL)
1269 return (ARCHIVE_FATAL);
1271 /* File Header CRC check. */
1272 crc32_val = crc32(crc32_val, h, (unsigned)(header_size - 7));
1273 if ((crc32_val & 0xffff) != archive_le16dec(rar_header.crc)) {
1274 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1275 "Header CRC error");
1276 return (ARCHIVE_FATAL);
1278 /* If no CRC error, Go on parsing File Header. */
1280 endp = p + header_size - 7;
1281 memcpy(&file_header, p, sizeof(file_header));
1282 p += sizeof(file_header);
1284 rar->compression_method = file_header.method;
1286 ttime = archive_le32dec(file_header.file_time);
1287 rar->mtime = get_time(ttime);
1289 rar->file_crc = archive_le32dec(file_header.file_crc);
1291 if (rar->file_flags & FHD_PASSWORD)
1293 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1294 "RAR encryption support unavailable.");
1295 return (ARCHIVE_FATAL);
1298 if (rar->file_flags & FHD_LARGE)
1300 memcpy(packed_size, file_header.pack_size, 4);
1301 memcpy(packed_size + 4, p, 4); /* High pack size */
1303 memcpy(unp_size, file_header.unp_size, 4);
1304 memcpy(unp_size + 4, p, 4); /* High unpack size */
1306 rar->packed_size = archive_le64dec(&packed_size);
1307 rar->unp_size = archive_le64dec(&unp_size);
1311 rar->packed_size = archive_le32dec(file_header.pack_size);
1312 rar->unp_size = archive_le32dec(file_header.unp_size);
1315 if (rar->packed_size < 0 || rar->unp_size < 0)
1317 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1318 "Invalid sizes specified.");
1319 return (ARCHIVE_FATAL);
1322 rar->bytes_remaining = rar->packed_size;
1324 /* TODO: RARv3 subblocks contain comments. For now the complete block is
1325 * consumed at the end.
1327 if (head_type == NEWSUB_HEAD) {
1328 size_t distance = p - (const char *)h;
1329 header_size += rar->packed_size;
1330 /* Make sure we have the extended data. */
1331 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL)
1332 return (ARCHIVE_FATAL);
1334 endp = p + header_size - 7;
1338 filename_size = archive_le16dec(file_header.name_size);
1339 if (p + filename_size > endp) {
1340 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1341 "Invalid filename size");
1342 return (ARCHIVE_FATAL);
1344 if (rar->filename_allocated < filename_size * 2 + 2) {
1346 size_t newsize = filename_size * 2 + 2;
1347 newptr = realloc(rar->filename, newsize);
1348 if (newptr == NULL) {
1349 archive_set_error(&a->archive, ENOMEM,
1350 "Couldn't allocate memory.");
1351 return (ARCHIVE_FATAL);
1353 rar->filename = newptr;
1354 rar->filename_allocated = newsize;
1356 filename = rar->filename;
1357 memcpy(filename, p, filename_size);
1358 filename[filename_size] = '\0';
1359 if (rar->file_flags & FHD_UNICODE)
1361 if (filename_size != strlen(filename))
1363 unsigned char highbyte, flagbits, flagbyte;
1364 unsigned fn_end, offset;
1366 end = filename_size;
1367 fn_end = filename_size * 2;
1369 offset = (unsigned)strlen(filename) + 1;
1370 highbyte = *(p + offset++);
1373 while (offset < end && filename_size < fn_end)
1377 flagbyte = *(p + offset++);
1382 switch((flagbyte >> flagbits) & 3)
1385 filename[filename_size++] = '\0';
1386 filename[filename_size++] = *(p + offset++);
1389 filename[filename_size++] = highbyte;
1390 filename[filename_size++] = *(p + offset++);
1393 filename[filename_size++] = *(p + offset + 1);
1394 filename[filename_size++] = *(p + offset);
1400 uint8_t length = *(p + offset++);
1402 if (length & 0x80) {
1403 extra = *(p + offset++);
1404 high = (char)highbyte;
1407 length = (length & 0x7f) + 2;
1408 while (length && filename_size < fn_end) {
1409 unsigned cp = filename_size >> 1;
1410 filename[filename_size++] = high;
1411 filename[filename_size++] = p[cp] + extra;
1418 if (filename_size > fn_end) {
1419 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1420 "Invalid filename");
1421 return (ARCHIVE_FATAL);
1423 filename[filename_size++] = '\0';
1424 filename[filename_size++] = '\0';
1426 /* Decoded unicode form is UTF-16BE, so we have to update a string
1427 * conversion object for it. */
1428 if (rar->sconv_utf16be == NULL) {
1429 rar->sconv_utf16be = archive_string_conversion_from_charset(
1430 &a->archive, "UTF-16BE", 1);
1431 if (rar->sconv_utf16be == NULL)
1432 return (ARCHIVE_FATAL);
1434 fn_sconv = rar->sconv_utf16be;
1437 while (memcmp(strp, "\x00\x00", 2))
1439 if (!memcmp(strp, "\x00\\", 2))
1446 * If FHD_UNICODE is set but no unicode data, this file name form
1447 * is UTF-8, so we have to update a string conversion object for
1450 if (rar->sconv_utf8 == NULL) {
1451 rar->sconv_utf8 = archive_string_conversion_from_charset(
1452 &a->archive, "UTF-8", 1);
1453 if (rar->sconv_utf8 == NULL)
1454 return (ARCHIVE_FATAL);
1456 fn_sconv = rar->sconv_utf8;
1457 while ((strp = strchr(filename, '\\')) != NULL)
1465 while ((strp = strchr(filename, '\\')) != NULL)
1470 /* Split file in multivolume RAR. No more need to process header. */
1471 if (rar->filename_save &&
1472 !memcmp(rar->filename, rar->filename_save, filename_size + 1))
1474 __archive_read_consume(a, header_size - 7);
1476 if (rar->cursor >= rar->nodes)
1480 realloc(rar->dbo, sizeof(*rar->dbo) * rar->nodes)) == NULL)
1482 archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
1483 return (ARCHIVE_FATAL);
1485 rar->dbo[rar->cursor].header_size = header_size;
1486 rar->dbo[rar->cursor].start_offset = -1;
1487 rar->dbo[rar->cursor].end_offset = -1;
1489 if (rar->dbo[rar->cursor].start_offset < 0)
1491 rar->dbo[rar->cursor].start_offset = a->filter->position;
1492 rar->dbo[rar->cursor].end_offset = rar->dbo[rar->cursor].start_offset +
1498 rar->filename_save = (char*)realloc(rar->filename_save,
1500 memcpy(rar->filename_save, rar->filename, filename_size + 1);
1502 /* Set info for seeking */
1504 if ((rar->dbo = calloc(1, sizeof(*rar->dbo))) == NULL)
1506 archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
1507 return (ARCHIVE_FATAL);
1509 rar->dbo[0].header_size = header_size;
1510 rar->dbo[0].start_offset = -1;
1511 rar->dbo[0].end_offset = -1;
1515 if (rar->file_flags & FHD_SALT)
1518 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1519 "Invalid header size");
1520 return (ARCHIVE_FATAL);
1522 memcpy(rar->salt, p, 8);
1526 if (rar->file_flags & FHD_EXTTIME) {
1527 if (read_exttime(p, rar, endp) < 0) {
1528 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1529 "Invalid header size");
1530 return (ARCHIVE_FATAL);
1534 __archive_read_consume(a, header_size - 7);
1535 rar->dbo[0].start_offset = a->filter->position;
1536 rar->dbo[0].end_offset = rar->dbo[0].start_offset + rar->packed_size;
1538 switch(file_header.host_os)
1543 rar->mode = archive_le32dec(file_header.file_attr);
1544 if (rar->mode & FILE_ATTRIBUTE_DIRECTORY)
1545 rar->mode = AE_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
1547 rar->mode = AE_IFREG;
1548 rar->mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
1554 rar->mode = archive_le32dec(file_header.file_attr);
1558 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1559 "Unknown file attributes from RAR file's host OS");
1560 return (ARCHIVE_FATAL);
1563 rar->bytes_uncopied = rar->bytes_unconsumed = 0;
1564 rar->lzss.position = rar->offset = 0;
1565 rar->offset_seek = 0;
1566 rar->dictionary_size = 0;
1567 rar->offset_outgoing = 0;
1568 rar->br.cache_avail = 0;
1569 rar->br.avail_in = 0;
1570 rar->crc_calculated = 0;
1573 rar->is_ppmd_block = 0;
1574 rar->start_new_table = 1;
1575 free(rar->unp_buffer);
1576 rar->unp_buffer = NULL;
1577 rar->unp_offset = 0;
1578 rar->unp_buffer_size = UNP_BUFFER_SIZE;
1579 memset(rar->lengthtable, 0, sizeof(rar->lengthtable));
1580 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc);
1581 rar->ppmd_valid = rar->ppmd_eod = 0;
1583 /* Don't set any archive entries for non-file header types */
1584 if (head_type == NEWSUB_HEAD)
1587 archive_entry_set_mtime(entry, rar->mtime, rar->mnsec);
1588 archive_entry_set_ctime(entry, rar->ctime, rar->cnsec);
1589 archive_entry_set_atime(entry, rar->atime, rar->ansec);
1590 archive_entry_set_size(entry, rar->unp_size);
1591 archive_entry_set_mode(entry, rar->mode);
1593 if (archive_entry_copy_pathname_l(entry, filename, filename_size, fn_sconv))
1595 if (errno == ENOMEM)
1597 archive_set_error(&a->archive, ENOMEM,
1598 "Can't allocate memory for Pathname");
1599 return (ARCHIVE_FATAL);
1601 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1602 "Pathname cannot be converted from %s to current locale.",
1603 archive_string_conversion_charset_name(fn_sconv));
1604 ret = (ARCHIVE_WARN);
1607 if (((rar->mode) & AE_IFMT) == AE_IFLNK)
1609 /* Make sure a symbolic-link file does not have its body. */
1610 rar->bytes_remaining = 0;
1611 archive_entry_set_size(entry, 0);
1613 /* Read a symbolic-link name. */
1614 if ((ret2 = read_symlink_stored(a, entry, sconv)) < (ARCHIVE_WARN))
1620 if (rar->bytes_remaining == 0)
1630 tm.tm_sec = 2 * (ttime & 0x1f);
1631 tm.tm_min = (ttime >> 5) & 0x3f;
1632 tm.tm_hour = (ttime >> 11) & 0x1f;
1633 tm.tm_mday = (ttime >> 16) & 0x1f;
1634 tm.tm_mon = ((ttime >> 21) & 0x0f) - 1;
1635 tm.tm_year = ((ttime >> 25) & 0x7f) + 80;
1641 read_exttime(const char *p, struct rar *rar, const char *endp)
1643 unsigned rmode, flags, rem, j, count;
1651 flags = archive_le16dec(p);
1654 for (i = 3; i >= 0; i--)
1659 rmode = flags >> i * 4;
1666 ttime = archive_le32dec(p);
1667 t = get_time(ttime);
1672 if (p + count > endp)
1674 for (j = 0; j < count; j++)
1676 rem = ((*p) << 16) | (rem >> 8);
1680 nsec = tm->tm_sec + rem / NS_UNIT;
1704 rar->arcnsec = nsec;
1712 read_symlink_stored(struct archive_read *a, struct archive_entry *entry,
1713 struct archive_string_conv *sconv)
1718 int ret = (ARCHIVE_OK);
1720 rar = (struct rar *)(a->format->data);
1721 if ((h = rar_read_ahead(a, (size_t)rar->packed_size, NULL)) == NULL)
1722 return (ARCHIVE_FATAL);
1725 if (archive_entry_copy_symlink_l(entry,
1726 p, (size_t)rar->packed_size, sconv))
1728 if (errno == ENOMEM)
1730 archive_set_error(&a->archive, ENOMEM,
1731 "Can't allocate memory for link");
1732 return (ARCHIVE_FATAL);
1734 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1735 "link cannot be converted from %s to current locale.",
1736 archive_string_conversion_charset_name(sconv));
1737 ret = (ARCHIVE_WARN);
1739 __archive_read_consume(a, rar->packed_size);
1744 read_data_stored(struct archive_read *a, const void **buff, size_t *size,
1748 ssize_t bytes_avail;
1750 rar = (struct rar *)(a->format->data);
1751 if (rar->bytes_remaining == 0 &&
1752 !(rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER))
1756 *offset = rar->offset;
1757 if (rar->file_crc != rar->crc_calculated) {
1758 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1760 return (ARCHIVE_FATAL);
1763 return (ARCHIVE_EOF);
1766 *buff = rar_read_ahead(a, 1, &bytes_avail);
1767 if (bytes_avail <= 0)
1769 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1770 "Truncated RAR file data");
1771 return (ARCHIVE_FATAL);
1774 *size = bytes_avail;
1775 *offset = rar->offset;
1776 rar->offset += bytes_avail;
1777 rar->offset_seek += bytes_avail;
1778 rar->bytes_remaining -= bytes_avail;
1779 rar->bytes_unconsumed = bytes_avail;
1780 /* Calculate File CRC. */
1781 rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1782 (unsigned)bytes_avail);
1783 return (ARCHIVE_OK);
1787 read_data_compressed(struct archive_read *a, const void **buff, size_t *size,
1791 int64_t start, end, actualend;
1793 int ret = (ARCHIVE_OK), sym, code, lzss_offset, length, i;
1795 rar = (struct rar *)(a->format->data);
1799 return (ARCHIVE_FATAL);
1800 if (rar->ppmd_eod ||
1801 (rar->dictionary_size && rar->offset >= rar->unp_size))
1803 if (rar->unp_offset > 0) {
1805 * We have unprocessed extracted data. write it out.
1807 *buff = rar->unp_buffer;
1808 *size = rar->unp_offset;
1809 *offset = rar->offset_outgoing;
1810 rar->offset_outgoing += *size;
1811 /* Calculate File CRC. */
1812 rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1814 rar->unp_offset = 0;
1815 return (ARCHIVE_OK);
1819 *offset = rar->offset;
1820 if (rar->file_crc != rar->crc_calculated) {
1821 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1823 return (ARCHIVE_FATAL);
1826 return (ARCHIVE_EOF);
1829 if (!rar->is_ppmd_block && rar->dictionary_size && rar->bytes_uncopied > 0)
1831 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset))
1832 bs = rar->unp_buffer_size - rar->unp_offset;
1834 bs = (size_t)rar->bytes_uncopied;
1835 ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs);
1836 if (ret != ARCHIVE_OK)
1839 rar->bytes_uncopied -= bs;
1840 if (*buff != NULL) {
1841 rar->unp_offset = 0;
1842 *size = rar->unp_buffer_size;
1843 *offset = rar->offset_outgoing;
1844 rar->offset_outgoing += *size;
1845 /* Calculate File CRC. */
1846 rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1853 if (!rar->br.next_in &&
1854 (ret = rar_br_preparation(a, &(rar->br))) < ARCHIVE_WARN)
1856 if (rar->start_new_table && ((ret = parse_codes(a)) < (ARCHIVE_WARN)))
1859 if (rar->is_ppmd_block)
1861 if ((sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1862 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1864 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1866 return (ARCHIVE_FATAL);
1868 if(sym != rar->ppmd_escape)
1870 lzss_emit_literal(rar, sym);
1871 rar->bytes_uncopied++;
1875 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1876 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1878 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1880 return (ARCHIVE_FATAL);
1886 rar->start_new_table = 1;
1887 return read_data_compressed(a, buff, size, offset);
1890 rar->ppmd_eod = 1;/* End Of ppmd Data. */
1894 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1895 "Parsing filters is unsupported.");
1896 return (ARCHIVE_FAILED);
1900 for (i = 2; i >= 0; i--)
1902 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1903 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1905 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1907 return (ARCHIVE_FATAL);
1909 lzss_offset |= code << (i * 8);
1911 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1912 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1914 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1916 return (ARCHIVE_FATAL);
1918 lzss_emit_match(rar, lzss_offset + 2, length + 32);
1919 rar->bytes_uncopied += length + 32;
1923 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1924 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1926 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1928 return (ARCHIVE_FATAL);
1930 lzss_emit_match(rar, 1, length + 4);
1931 rar->bytes_uncopied += length + 4;
1935 lzss_emit_literal(rar, sym);
1936 rar->bytes_uncopied++;
1942 start = rar->offset;
1943 end = start + rar->dictionary_size;
1944 rar->filterstart = INT64_MAX;
1946 if ((actualend = expand(a, end)) < 0)
1947 return ((int)actualend);
1949 rar->bytes_uncopied = actualend - start;
1950 if (rar->bytes_uncopied == 0) {
1951 /* Broken RAR files cause this case.
1952 * NOTE: If this case were possible on a normal RAR file
1953 * we would find out where it was actually bad and
1954 * what we would do to solve it. */
1955 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1956 "Internal error extracting RAR file");
1957 return (ARCHIVE_FATAL);
1960 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset))
1961 bs = rar->unp_buffer_size - rar->unp_offset;
1963 bs = (size_t)rar->bytes_uncopied;
1964 ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs);
1965 if (ret != ARCHIVE_OK)
1968 rar->bytes_uncopied -= bs;
1970 * If *buff is NULL, it means unp_buffer is not full.
1971 * So we have to continue extracting a RAR file.
1973 } while (*buff == NULL);
1975 rar->unp_offset = 0;
1976 *size = rar->unp_buffer_size;
1977 *offset = rar->offset_outgoing;
1978 rar->offset_outgoing += *size;
1979 /* Calculate File CRC. */
1980 rar->crc_calculated = crc32(rar->crc_calculated, *buff, (unsigned)*size);
1985 parse_codes(struct archive_read *a)
1987 int i, j, val, n, r;
1988 unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags;
1989 unsigned int maxorder;
1990 struct huffman_code precode;
1991 struct rar *rar = (struct rar *)(a->format->data);
1992 struct rar_br *br = &(rar->br);
1996 /* Skip to the next byte */
1997 rar_br_consume_unalined_bits(br);
1999 /* PPMd block flag */
2000 if (!rar_br_read_ahead(a, br, 1))
2001 goto truncated_data;
2002 if ((rar->is_ppmd_block = rar_br_bits(br, 1)) != 0)
2004 rar_br_consume(br, 1);
2005 if (!rar_br_read_ahead(a, br, 7))
2006 goto truncated_data;
2007 ppmd_flags = rar_br_bits(br, 7);
2008 rar_br_consume(br, 7);
2010 /* Memory is allocated in MB */
2011 if (ppmd_flags & 0x20)
2013 if (!rar_br_read_ahead(a, br, 8))
2014 goto truncated_data;
2015 rar->dictionary_size = (rar_br_bits(br, 8) + 1) << 20;
2016 rar_br_consume(br, 8);
2019 if (ppmd_flags & 0x40)
2021 if (!rar_br_read_ahead(a, br, 8))
2022 goto truncated_data;
2023 rar->ppmd_escape = rar->ppmd7_context.InitEsc = rar_br_bits(br, 8);
2024 rar_br_consume(br, 8);
2027 rar->ppmd_escape = 2;
2029 if (ppmd_flags & 0x20)
2031 maxorder = (ppmd_flags & 0x1F) + 1;
2033 maxorder = 16 + (maxorder - 16) * 3;
2037 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2038 "Truncated RAR file data");
2039 return (ARCHIVE_FATAL);
2042 /* Make sure ppmd7_contest is freed before Ppmd7_Construct
2043 * because reading a broken file cause this abnormal sequence. */
2044 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc);
2047 rar->bytein.Read = &ppmd_read;
2048 __archive_ppmd7_functions.PpmdRAR_RangeDec_CreateVTable(&rar->range_dec);
2049 rar->range_dec.Stream = &rar->bytein;
2050 __archive_ppmd7_functions.Ppmd7_Construct(&rar->ppmd7_context);
2052 if (!__archive_ppmd7_functions.Ppmd7_Alloc(&rar->ppmd7_context,
2053 rar->dictionary_size, &g_szalloc))
2055 archive_set_error(&a->archive, ENOMEM,
2057 return (ARCHIVE_FATAL);
2059 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec))
2061 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2062 "Unable to initialize PPMd range decoder");
2063 return (ARCHIVE_FATAL);
2065 __archive_ppmd7_functions.Ppmd7_Init(&rar->ppmd7_context, maxorder);
2066 rar->ppmd_valid = 1;
2070 if (!rar->ppmd_valid) {
2071 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2072 "Invalid PPMd sequence");
2073 return (ARCHIVE_FATAL);
2075 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec))
2077 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2078 "Unable to initialize PPMd range decoder");
2079 return (ARCHIVE_FATAL);
2085 rar_br_consume(br, 1);
2087 /* Keep existing table flag */
2088 if (!rar_br_read_ahead(a, br, 1))
2089 goto truncated_data;
2090 if (!rar_br_bits(br, 1))
2091 memset(rar->lengthtable, 0, sizeof(rar->lengthtable));
2092 rar_br_consume(br, 1);
2094 memset(&bitlengths, 0, sizeof(bitlengths));
2095 for (i = 0; i < MAX_SYMBOLS;)
2097 if (!rar_br_read_ahead(a, br, 4))
2098 goto truncated_data;
2099 bitlengths[i++] = rar_br_bits(br, 4);
2100 rar_br_consume(br, 4);
2101 if (bitlengths[i-1] == 0xF)
2103 if (!rar_br_read_ahead(a, br, 4))
2104 goto truncated_data;
2105 zerocount = rar_br_bits(br, 4);
2106 rar_br_consume(br, 4);
2110 for (j = 0; j < zerocount + 2 && i < MAX_SYMBOLS; j++)
2111 bitlengths[i++] = 0;
2116 memset(&precode, 0, sizeof(precode));
2117 r = create_code(a, &precode, bitlengths, MAX_SYMBOLS, MAX_SYMBOL_LENGTH);
2118 if (r != ARCHIVE_OK) {
2120 free(precode.table);
2124 for (i = 0; i < HUFFMAN_TABLE_SIZE;)
2126 if ((val = read_next_symbol(a, &precode)) < 0) {
2128 free(precode.table);
2129 return (ARCHIVE_FATAL);
2133 rar->lengthtable[i] = (rar->lengthtable[i] + val) & 0xF;
2141 free(precode.table);
2142 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2143 "Internal error extracting RAR file.");
2144 return (ARCHIVE_FATAL);
2148 if (!rar_br_read_ahead(a, br, 3)) {
2150 free(precode.table);
2151 goto truncated_data;
2153 n = rar_br_bits(br, 3) + 3;
2154 rar_br_consume(br, 3);
2156 if (!rar_br_read_ahead(a, br, 7)) {
2158 free(precode.table);
2159 goto truncated_data;
2161 n = rar_br_bits(br, 7) + 11;
2162 rar_br_consume(br, 7);
2165 for (j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++)
2167 rar->lengthtable[i] = rar->lengthtable[i-1];
2174 if (!rar_br_read_ahead(a, br, 3)) {
2176 free(precode.table);
2177 goto truncated_data;
2179 n = rar_br_bits(br, 3) + 3;
2180 rar_br_consume(br, 3);
2182 if (!rar_br_read_ahead(a, br, 7)) {
2184 free(precode.table);
2185 goto truncated_data;
2187 n = rar_br_bits(br, 7) + 11;
2188 rar_br_consume(br, 7);
2191 for(j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++)
2192 rar->lengthtable[i++] = 0;
2196 free(precode.table);
2198 r = create_code(a, &rar->maincode, &rar->lengthtable[0], MAINCODE_SIZE,
2200 if (r != ARCHIVE_OK)
2202 r = create_code(a, &rar->offsetcode, &rar->lengthtable[MAINCODE_SIZE],
2203 OFFSETCODE_SIZE, MAX_SYMBOL_LENGTH);
2204 if (r != ARCHIVE_OK)
2206 r = create_code(a, &rar->lowoffsetcode,
2207 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE],
2208 LOWOFFSETCODE_SIZE, MAX_SYMBOL_LENGTH);
2209 if (r != ARCHIVE_OK)
2211 r = create_code(a, &rar->lengthcode,
2212 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE +
2213 LOWOFFSETCODE_SIZE], LENGTHCODE_SIZE, MAX_SYMBOL_LENGTH);
2214 if (r != ARCHIVE_OK)
2218 if (!rar->dictionary_size || !rar->lzss.window)
2220 /* Seems as though dictionary sizes are not used. Even so, minimize
2221 * memory usage as much as possible.
2224 unsigned int new_size;
2226 if (rar->unp_size >= DICTIONARY_MAX_SIZE)
2227 new_size = DICTIONARY_MAX_SIZE;
2229 new_size = rar_fls((unsigned int)rar->unp_size) << 1;
2230 new_window = realloc(rar->lzss.window, new_size);
2231 if (new_window == NULL) {
2232 archive_set_error(&a->archive, ENOMEM,
2233 "Unable to allocate memory for uncompressed data.");
2234 return (ARCHIVE_FATAL);
2236 rar->lzss.window = (unsigned char *)new_window;
2237 rar->dictionary_size = new_size;
2238 memset(rar->lzss.window, 0, rar->dictionary_size);
2239 rar->lzss.mask = rar->dictionary_size - 1;
2242 rar->start_new_table = 0;
2243 return (ARCHIVE_OK);
2245 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2246 "Truncated RAR file data");
2248 return (ARCHIVE_FATAL);
2252 free_codes(struct archive_read *a)
2254 struct rar *rar = (struct rar *)(a->format->data);
2255 free(rar->maincode.tree);
2256 free(rar->offsetcode.tree);
2257 free(rar->lowoffsetcode.tree);
2258 free(rar->lengthcode.tree);
2259 free(rar->maincode.table);
2260 free(rar->offsetcode.table);
2261 free(rar->lowoffsetcode.table);
2262 free(rar->lengthcode.table);
2263 memset(&rar->maincode, 0, sizeof(rar->maincode));
2264 memset(&rar->offsetcode, 0, sizeof(rar->offsetcode));
2265 memset(&rar->lowoffsetcode, 0, sizeof(rar->lowoffsetcode));
2266 memset(&rar->lengthcode, 0, sizeof(rar->lengthcode));
2271 read_next_symbol(struct archive_read *a, struct huffman_code *code)
2275 int length, value, node;
2281 if (make_table(a, code) != (ARCHIVE_OK))
2285 rar = (struct rar *)(a->format->data);
2288 /* Look ahead (peek) at bits */
2289 if (!rar_br_read_ahead(a, br, code->tablesize)) {
2290 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2291 "Truncated RAR file data");
2295 bits = rar_br_bits(br, code->tablesize);
2297 length = code->table[bits].length;
2298 value = code->table[bits].value;
2302 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2303 "Invalid prefix code in bitstream");
2307 if (length <= code->tablesize)
2309 /* Skip length bits */
2310 rar_br_consume(br, length);
2314 /* Skip tablesize bits */
2315 rar_br_consume(br, code->tablesize);
2318 while (!(code->tree[node].branches[0] ==
2319 code->tree[node].branches[1]))
2321 if (!rar_br_read_ahead(a, br, 1)) {
2322 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2323 "Truncated RAR file data");
2327 bit = rar_br_bits(br, 1);
2328 rar_br_consume(br, 1);
2330 if (code->tree[node].branches[bit] < 0)
2332 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2333 "Invalid prefix code in bitstream");
2336 node = code->tree[node].branches[bit];
2339 return code->tree[node].branches[0];
2343 create_code(struct archive_read *a, struct huffman_code *code,
2344 unsigned char *lengths, int numsymbols, char maxlength)
2346 int i, j, codebits = 0, symbolsleft = numsymbols;
2348 if (new_node(code) < 0) {
2349 archive_set_error(&a->archive, ENOMEM,
2350 "Unable to allocate memory for node data.");
2351 return (ARCHIVE_FATAL);
2353 code->numentries = 1;
2354 code->minlength = INT_MAX;
2355 code->maxlength = INT_MIN;
2357 for(i = 1; i <= maxlength; i++)
2359 for(j = 0; j < numsymbols; j++)
2361 if (lengths[j] != i) continue;
2362 if (add_value(a, code, j, codebits, i) != ARCHIVE_OK)
2363 return (ARCHIVE_FATAL);
2365 if (--symbolsleft <= 0) { break; break; }
2369 return (ARCHIVE_OK);
2373 add_value(struct archive_read *a, struct huffman_code *code, int value,
2374 int codebits, int length)
2376 int repeatpos, lastnode, bitpos, bit, repeatnode, nextnode;
2381 if(length > code->maxlength)
2382 code->maxlength = length;
2383 if(length < code->minlength)
2384 code->minlength = length;
2387 if (repeatpos == 0 || (repeatpos >= 0
2388 && (((codebits >> (repeatpos - 1)) & 3) == 0
2389 || ((codebits >> (repeatpos - 1)) & 3) == 3)))
2391 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2392 "Invalid repeat position");
2393 return (ARCHIVE_FATAL);
2397 for (bitpos = length - 1; bitpos >= 0; bitpos--)
2399 bit = (codebits >> bitpos) & 1;
2401 /* Leaf node check */
2402 if (code->tree[lastnode].branches[0] ==
2403 code->tree[lastnode].branches[1])
2405 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2407 return (ARCHIVE_FATAL);
2410 if (bitpos == repeatpos)
2412 /* Open branch check */
2413 if (!(code->tree[lastnode].branches[bit] < 0))
2415 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2416 "Invalid repeating code");
2417 return (ARCHIVE_FATAL);
2420 if ((repeatnode = new_node(code)) < 0) {
2421 archive_set_error(&a->archive, ENOMEM,
2422 "Unable to allocate memory for node data.");
2423 return (ARCHIVE_FATAL);
2425 if ((nextnode = new_node(code)) < 0) {
2426 archive_set_error(&a->archive, ENOMEM,
2427 "Unable to allocate memory for node data.");
2428 return (ARCHIVE_FATAL);
2432 code->tree[lastnode].branches[bit] = repeatnode;
2433 code->tree[repeatnode].branches[bit] = repeatnode;
2434 code->tree[repeatnode].branches[bit^1] = nextnode;
2435 lastnode = nextnode;
2437 bitpos++; /* terminating bit already handled, skip it */
2441 /* Open branch check */
2442 if (code->tree[lastnode].branches[bit] < 0)
2444 if (new_node(code) < 0) {
2445 archive_set_error(&a->archive, ENOMEM,
2446 "Unable to allocate memory for node data.");
2447 return (ARCHIVE_FATAL);
2449 code->tree[lastnode].branches[bit] = code->numentries++;
2453 lastnode = code->tree[lastnode].branches[bit];
2457 if (!(code->tree[lastnode].branches[0] == -1
2458 && code->tree[lastnode].branches[1] == -2))
2460 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2462 return (ARCHIVE_FATAL);
2465 /* Set leaf value */
2466 code->tree[lastnode].branches[0] = value;
2467 code->tree[lastnode].branches[1] = value;
2469 return (ARCHIVE_OK);
2473 new_node(struct huffman_code *code)
2477 new_tree = realloc(code->tree, (code->numentries + 1) * sizeof(*code->tree));
2478 if (new_tree == NULL)
2480 code->tree = (struct huffman_tree_node *)new_tree;
2481 code->tree[code->numentries].branches[0] = -1;
2482 code->tree[code->numentries].branches[1] = -2;
2487 make_table(struct archive_read *a, struct huffman_code *code)
2489 if (code->maxlength < code->minlength || code->maxlength > 10)
2490 code->tablesize = 10;
2492 code->tablesize = code->maxlength;
2495 (struct huffman_table_entry *)calloc(1, sizeof(*code->table)
2496 * ((size_t)1 << code->tablesize));
2498 return make_table_recurse(a, code, 0, code->table, 0, code->tablesize);
2502 make_table_recurse(struct archive_read *a, struct huffman_code *code, int node,
2503 struct huffman_table_entry *table, int depth,
2506 int currtablesize, i, ret = (ARCHIVE_OK);
2510 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2511 "Huffman tree was not created.");
2512 return (ARCHIVE_FATAL);
2514 if (node < 0 || node >= code->numentries)
2516 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2517 "Invalid location to Huffman tree specified.");
2518 return (ARCHIVE_FATAL);
2521 currtablesize = 1 << (maxdepth - depth);
2523 if (code->tree[node].branches[0] ==
2524 code->tree[node].branches[1])
2526 for(i = 0; i < currtablesize; i++)
2528 table[i].length = depth;
2529 table[i].value = code->tree[node].branches[0];
2534 for(i = 0; i < currtablesize; i++)
2535 table[i].length = -1;
2539 if(depth == maxdepth)
2541 table[0].length = maxdepth + 1;
2542 table[0].value = node;
2546 ret |= make_table_recurse(a, code, code->tree[node].branches[0], table,
2547 depth + 1, maxdepth);
2548 ret |= make_table_recurse(a, code, code->tree[node].branches[1],
2549 table + currtablesize / 2, depth + 1, maxdepth);
2556 expand(struct archive_read *a, int64_t end)
2558 static const unsigned char lengthbases[] =
2559 { 0, 1, 2, 3, 4, 5, 6,
2560 7, 8, 10, 12, 14, 16, 20,
2561 24, 28, 32, 40, 48, 56, 64,
2562 80, 96, 112, 128, 160, 192, 224 };
2563 static const unsigned char lengthbits[] =
2564 { 0, 0, 0, 0, 0, 0, 0,
2565 0, 1, 1, 1, 1, 2, 2,
2566 2, 2, 3, 3, 3, 3, 4,
2567 4, 4, 4, 5, 5, 5, 5 };
2568 static const unsigned int offsetbases[] =
2570 8, 12, 16, 24, 32, 48,
2571 64, 96, 128, 192, 256, 384,
2572 512, 768, 1024, 1536, 2048, 3072,
2573 4096, 6144, 8192, 12288, 16384, 24576,
2574 32768, 49152, 65536, 98304, 131072, 196608,
2575 262144, 327680, 393216, 458752, 524288, 589824,
2576 655360, 720896, 786432, 851968, 917504, 983040,
2577 1048576, 1310720, 1572864, 1835008, 2097152, 2359296,
2578 2621440, 2883584, 3145728, 3407872, 3670016, 3932160 };
2579 static const unsigned char offsetbits[] =
2580 { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4,
2581 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
2582 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
2583 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
2584 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 };
2585 static const unsigned char shortbases[] =
2586 { 0, 4, 8, 16, 32, 64, 128, 192 };
2587 static const unsigned char shortbits[] =
2588 { 2, 2, 3, 4, 5, 6, 6, 6 };
2590 int symbol, offs, len, offsindex, lensymbol, i, offssymbol, lowoffsetsymbol;
2591 unsigned char newfile;
2592 struct rar *rar = (struct rar *)(a->format->data);
2593 struct rar_br *br = &(rar->br);
2595 if (rar->filterstart < end)
2596 end = rar->filterstart;
2600 if (rar->output_last_match &&
2601 lzss_position(&rar->lzss) + rar->lastlength <= end)
2603 lzss_emit_match(rar, rar->lastoffset, rar->lastlength);
2604 rar->output_last_match = 0;
2607 if(rar->is_ppmd_block || rar->output_last_match ||
2608 lzss_position(&rar->lzss) >= end)
2609 return lzss_position(&rar->lzss);
2611 if ((symbol = read_next_symbol(a, &rar->maincode)) < 0)
2612 return (ARCHIVE_FATAL);
2613 rar->output_last_match = 0;
2617 lzss_emit_literal(rar, symbol);
2620 else if (symbol == 256)
2622 if (!rar_br_read_ahead(a, br, 1))
2623 goto truncated_data;
2624 newfile = !rar_br_bits(br, 1);
2625 rar_br_consume(br, 1);
2629 rar->start_new_block = 1;
2630 if (!rar_br_read_ahead(a, br, 1))
2631 goto truncated_data;
2632 rar->start_new_table = rar_br_bits(br, 1);
2633 rar_br_consume(br, 1);
2634 return lzss_position(&rar->lzss);
2638 if (parse_codes(a) != ARCHIVE_OK)
2639 return (ARCHIVE_FATAL);
2643 else if(symbol==257)
2645 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2646 "Parsing filters is unsupported.");
2647 return (ARCHIVE_FAILED);
2649 else if(symbol==258)
2651 if(rar->lastlength == 0)
2654 offs = rar->lastoffset;
2655 len = rar->lastlength;
2657 else if (symbol <= 262)
2659 offsindex = symbol - 259;
2660 offs = rar->oldoffset[offsindex];
2662 if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0)
2664 if (lensymbol > (int)(sizeof(lengthbases)/sizeof(lengthbases[0])))
2666 if (lensymbol > (int)(sizeof(lengthbits)/sizeof(lengthbits[0])))
2668 len = lengthbases[lensymbol] + 2;
2669 if (lengthbits[lensymbol] > 0) {
2670 if (!rar_br_read_ahead(a, br, lengthbits[lensymbol]))
2671 goto truncated_data;
2672 len += rar_br_bits(br, lengthbits[lensymbol]);
2673 rar_br_consume(br, lengthbits[lensymbol]);
2676 for (i = offsindex; i > 0; i--)
2677 rar->oldoffset[i] = rar->oldoffset[i-1];
2678 rar->oldoffset[0] = offs;
2680 else if(symbol<=270)
2682 offs = shortbases[symbol-263] + 1;
2683 if(shortbits[symbol-263] > 0) {
2684 if (!rar_br_read_ahead(a, br, shortbits[symbol-263]))
2685 goto truncated_data;
2686 offs += rar_br_bits(br, shortbits[symbol-263]);
2687 rar_br_consume(br, shortbits[symbol-263]);
2692 for(i = 3; i > 0; i--)
2693 rar->oldoffset[i] = rar->oldoffset[i-1];
2694 rar->oldoffset[0] = offs;
2698 if (symbol-271 > (int)(sizeof(lengthbases)/sizeof(lengthbases[0])))
2700 if (symbol-271 > (int)(sizeof(lengthbits)/sizeof(lengthbits[0])))
2702 len = lengthbases[symbol-271]+3;
2703 if(lengthbits[symbol-271] > 0) {
2704 if (!rar_br_read_ahead(a, br, lengthbits[symbol-271]))
2705 goto truncated_data;
2706 len += rar_br_bits(br, lengthbits[symbol-271]);
2707 rar_br_consume(br, lengthbits[symbol-271]);
2710 if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0)
2712 if (offssymbol > (int)(sizeof(offsetbases)/sizeof(offsetbases[0])))
2714 if (offssymbol > (int)(sizeof(offsetbits)/sizeof(offsetbits[0])))
2716 offs = offsetbases[offssymbol]+1;
2717 if(offsetbits[offssymbol] > 0)
2721 if(offsetbits[offssymbol] > 4) {
2722 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol] - 4))
2723 goto truncated_data;
2724 offs += rar_br_bits(br, offsetbits[offssymbol] - 4) << 4;
2725 rar_br_consume(br, offsetbits[offssymbol] - 4);
2728 if(rar->numlowoffsetrepeats > 0)
2730 rar->numlowoffsetrepeats--;
2731 offs += rar->lastlowoffset;
2735 if ((lowoffsetsymbol =
2736 read_next_symbol(a, &rar->lowoffsetcode)) < 0)
2737 return (ARCHIVE_FATAL);
2738 if(lowoffsetsymbol == 16)
2740 rar->numlowoffsetrepeats = 15;
2741 offs += rar->lastlowoffset;
2745 offs += lowoffsetsymbol;
2746 rar->lastlowoffset = lowoffsetsymbol;
2751 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol]))
2752 goto truncated_data;
2753 offs += rar_br_bits(br, offsetbits[offssymbol]);
2754 rar_br_consume(br, offsetbits[offssymbol]);
2758 if (offs >= 0x40000)
2763 for(i = 3; i > 0; i--)
2764 rar->oldoffset[i] = rar->oldoffset[i-1];
2765 rar->oldoffset[0] = offs;
2768 rar->lastoffset = offs;
2769 rar->lastlength = len;
2770 rar->output_last_match = 1;
2773 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2774 "Truncated RAR file data");
2776 return (ARCHIVE_FATAL);
2778 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2779 "Bad RAR file data");
2780 return (ARCHIVE_FATAL);
2784 copy_from_lzss_window(struct archive_read *a, const void **buffer,
2785 int64_t startpos, int length)
2787 int windowoffs, firstpart;
2788 struct rar *rar = (struct rar *)(a->format->data);
2790 if (!rar->unp_buffer)
2792 if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL)
2794 archive_set_error(&a->archive, ENOMEM,
2795 "Unable to allocate memory for uncompressed data.");
2796 return (ARCHIVE_FATAL);
2800 windowoffs = lzss_offset_for_position(&rar->lzss, startpos);
2801 if(windowoffs + length <= lzss_size(&rar->lzss))
2802 memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs],
2806 firstpart = lzss_size(&rar->lzss) - windowoffs;
2807 if (firstpart < 0) {
2808 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2809 "Bad RAR file data");
2810 return (ARCHIVE_FATAL);
2812 if (firstpart < length) {
2813 memcpy(&rar->unp_buffer[rar->unp_offset],
2814 &rar->lzss.window[windowoffs], firstpart);
2815 memcpy(&rar->unp_buffer[rar->unp_offset + firstpart],
2816 &rar->lzss.window[0], length - firstpart);
2818 memcpy(&rar->unp_buffer[rar->unp_offset],
2819 &rar->lzss.window[windowoffs], length);
2821 rar->unp_offset += length;
2822 if (rar->unp_offset >= rar->unp_buffer_size)
2823 *buffer = rar->unp_buffer;
2826 return (ARCHIVE_OK);
2830 rar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail)
2832 struct rar *rar = (struct rar *)(a->format->data);
2833 const void *h = __archive_read_ahead(a, min, avail);
2837 if (a->read_data_is_posix_read && *avail > (ssize_t)a->read_data_requested)
2838 *avail = a->read_data_requested;
2839 if (*avail > rar->bytes_remaining)
2840 *avail = (ssize_t)rar->bytes_remaining;
2843 else if (*avail == 0 && rar->main_flags & MHD_VOLUME &&
2844 rar->file_flags & FHD_SPLIT_AFTER)
2846 ret = archive_read_format_rar_read_header(a, a->entry);
2847 if (ret == (ARCHIVE_EOF))
2849 rar->has_endarc_header = 1;
2850 ret = archive_read_format_rar_read_header(a, a->entry);
2852 if (ret != (ARCHIVE_OK))
2854 return rar_read_ahead(a, min, avail);