1 /*- 2 * Copyright (c) 2003-2007 Tim Kientzle 3 * Copyright (c) 2011 Andres Mejia 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 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. 14 * 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. 25 */ 26 27 #include "archive_platform.h" 28 29 #ifdef HAVE_ERRNO_H 30 #include <errno.h> 31 #endif 32 #include <time.h> 33 #include <limits.h> 34 #ifdef HAVE_ZLIB_H 35 #include <zlib.h> /* crc32 */ 36 #endif 37 38 #include "archive.h" 39 #ifndef HAVE_ZLIB_H 40 #include "archive_crc32.h" 41 #endif 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" 48 49 /* RAR signature, also known as the mark header */ 50 #define RAR_SIGNATURE "\x52\x61\x72\x21\x1A\x07\x00" 51 52 /* Header types */ 53 #define MARK_HEAD 0x72 54 #define MAIN_HEAD 0x73 55 #define FILE_HEAD 0x74 56 #define COMM_HEAD 0x75 57 #define AV_HEAD 0x76 58 #define SUB_HEAD 0x77 59 #define PROTECT_HEAD 0x78 60 #define SIGN_HEAD 0x79 61 #define NEWSUB_HEAD 0x7a 62 #define ENDARC_HEAD 0x7b 63 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 70 #define MHD_AV 0x0020 71 #define MHD_PROTECT 0x0040 72 #define MHD_PASSWORD 0x0080 73 #define MHD_FIRSTVOLUME 0x0100 74 #define MHD_ENCRYPTVER 0x0200 75 76 /* Flags common to all headers */ 77 #define HD_MARKDELETION 0x4000 78 #define HD_ADD_SIZE_PRESENT 0x8000 79 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 92 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 103 104 /* OS Flags */ 105 #define OS_MSDOS 0 106 #define OS_OS2 1 107 #define OS_WIN32 2 108 #define OS_UNIX 3 109 #define OS_MAC_OS 4 110 #define OS_BEOS 5 111 112 /* Compression Methods */ 113 #define COMPRESS_METHOD_STORE 0x30 114 /* LZSS */ 115 #define COMPRESS_METHOD_FASTEST 0x31 116 #define COMPRESS_METHOD_FAST 0x32 117 #define COMPRESS_METHOD_NORMAL 0x33 118 /* PPMd Variant H */ 119 #define COMPRESS_METHOD_GOOD 0x34 120 #define COMPRESS_METHOD_BEST 0x35 121 122 #define CRC_POLYNOMIAL 0xEDB88320 123 124 #define NS_UNIT 10000000 125 126 #define DICTIONARY_MAX_SIZE 0x400000 127 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 134 135 #define MAX_SYMBOL_LENGTH 0xF 136 #define MAX_SYMBOLS 20 137 138 /* 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. 143 */ 144 #define UNP_BUFFER_SIZE (128 * 1024) 145 146 /* Define this here for non-Windows platforms */ 147 #if !((defined(__WIN32__) || defined(_WIN32) || defined(__WIN32)) && !defined(__CYGWIN__)) 148 #define FILE_ATTRIBUTE_DIRECTORY 0x10 149 #endif 150 151 /* Fields common to all headers */ 152 struct rar_header 153 { 154 char crc[2]; 155 char type; 156 char flags[2]; 157 char size[2]; 158 }; 159 160 /* Fields common to all file headers */ 161 struct rar_file_header 162 { 163 char pack_size[4]; 164 char unp_size[4]; 165 char host_os; 166 char file_crc[4]; 167 char file_time[4]; 168 char unp_ver; 169 char method; 170 char name_size[2]; 171 char file_attr[4]; 172 }; 173 174 struct huffman_tree_node 175 { 176 int branches[2]; 177 }; 178 179 struct huffman_table_entry 180 { 181 unsigned int length; 182 int value; 183 }; 184 185 struct huffman_code 186 { 187 struct huffman_tree_node *tree; 188 int numentries; 189 int minlength; 190 int maxlength; 191 int tablesize; 192 struct huffman_table_entry *table; 193 }; 194 195 struct lzss 196 { 197 unsigned char *window; 198 int mask; 199 int64_t position; 200 }; 201 202 struct rar 203 { 204 /* Entries from main RAR header */ 205 unsigned main_flags; 206 unsigned long file_crc; 207 char reserved1[2]; 208 char reserved2[4]; 209 char encryptver; 210 211 /* File header entries */ 212 char compression_method; 213 unsigned file_flags; 214 int64_t packed_size; 215 int64_t unp_size; 216 time_t mtime; 217 long mnsec; 218 mode_t mode; 219 char *filename; 220 size_t filename_allocated; 221 222 /* File header optional entries */ 223 char salt[8]; 224 time_t atime; 225 long ansec; 226 time_t ctime; 227 long cnsec; 228 time_t arctime; 229 long arcnsec; 230 231 /* Fields to help with tracking decompression of files. */ 232 int64_t bytes_unconsumed; 233 int64_t bytes_remaining; 234 int64_t bytes_uncopied; 235 int64_t offset; 236 int64_t offset_outgoing; 237 char valid; 238 unsigned int unp_offset; 239 unsigned int unp_buffer_size; 240 unsigned char *unp_buffer; 241 unsigned int dictionary_size; 242 char start_new_block; 243 char entry_eof; 244 unsigned long crc_calculated; 245 int found_first_header; 246 247 /* LZSS members */ 248 struct huffman_code maincode; 249 struct huffman_code offsetcode; 250 struct huffman_code lowoffsetcode; 251 struct huffman_code lengthcode; 252 unsigned char lengthtable[HUFFMAN_TABLE_SIZE]; 253 struct lzss lzss; 254 char output_last_match; 255 unsigned int lastlength; 256 unsigned int lastoffset; 257 unsigned int oldoffset[4]; 258 unsigned int lastlowoffset; 259 unsigned int numlowoffsetrepeats; 260 int64_t filterstart; 261 char start_new_table; 262 263 /* PPMd Variant H members */ 264 char ppmd_valid; 265 char ppmd_eod; 266 char is_ppmd_block; 267 int ppmd_escape; 268 CPpmd7 ppmd7_context; 269 CPpmd7z_RangeDec range_dec; 270 IByteIn bytein; 271 272 /* 273 * String conversion object. 274 */ 275 int init_default_conversion; 276 struct archive_string_conv *sconv_default; 277 struct archive_string_conv *opt_sconv; 278 struct archive_string_conv *sconv_utf8; 279 struct archive_string_conv *sconv_utf16be; 280 281 /* 282 * Bit stream reader. 283 */ 284 struct rar_br { 285 #define CACHE_TYPE uint64_t 286 #define CACHE_BITS (8 * sizeof(CACHE_TYPE)) 287 /* Cache buffer. */ 288 CACHE_TYPE cache_buffer; 289 /* Indicates how many bits avail in cache_buffer. */ 290 int cache_avail; 291 ssize_t avail_in; 292 const unsigned char *next_in; 293 } br; 294 }; 295 296 static int archive_read_format_rar_bid(struct archive_read *, int); 297 static int archive_read_format_rar_options(struct archive_read *, 298 const char *, const char *); 299 static int archive_read_format_rar_read_header(struct archive_read *, 300 struct archive_entry *); 301 static int archive_read_format_rar_read_data(struct archive_read *, 302 const void **, size_t *, int64_t *); 303 static int archive_read_format_rar_read_data_skip(struct archive_read *a); 304 static int archive_read_format_rar_cleanup(struct archive_read *); 305 306 /* Support functions */ 307 static int read_header(struct archive_read *, struct archive_entry *, char); 308 static time_t get_time(int); 309 static int read_exttime(const char *, struct rar *, const char *); 310 static int read_symlink_stored(struct archive_read *, struct archive_entry *, 311 struct archive_string_conv *); 312 static int read_data_stored(struct archive_read *, const void **, size_t *, 313 int64_t *); 314 static int read_data_compressed(struct archive_read *, const void **, size_t *, 315 int64_t *); 316 static int rar_br_preparation(struct archive_read *, struct rar_br *); 317 static int parse_codes(struct archive_read *); 318 static void free_codes(struct archive_read *); 319 static int read_next_symbol(struct archive_read *, struct huffman_code *); 320 static int create_code(struct archive_read *, struct huffman_code *, 321 unsigned char *, int, char); 322 static int add_value(struct archive_read *, struct huffman_code *, int, int, 323 int); 324 static int new_node(struct huffman_code *); 325 static int make_table(struct archive_read *, struct huffman_code *); 326 static int make_table_recurse(struct archive_read *, struct huffman_code *, int, 327 struct huffman_table_entry *, int, int); 328 static int64_t expand(struct archive_read *, int64_t); 329 static int copy_from_lzss_window(struct archive_read *, const void **, 330 int64_t, int); 331 332 /* 333 * Bit stream reader. 334 */ 335 /* Check that the cache buffer has enough bits. */ 336 #define rar_br_has(br, n) ((br)->cache_avail >= n) 337 /* Get compressed data by bit. */ 338 #define rar_br_bits(br, n) \ 339 (((uint32_t)((br)->cache_buffer >> \ 340 ((br)->cache_avail - (n)))) & cache_masks[n]) 341 #define rar_br_bits_forced(br, n) \ 342 (((uint32_t)((br)->cache_buffer << \ 343 ((n) - (br)->cache_avail))) & cache_masks[n]) 344 /* Read ahead to make sure the cache buffer has enough compressed data we 345 * will use. 346 * True : completed, there is enough data in the cache buffer. 347 * False : there is no data in the stream. */ 348 #define rar_br_read_ahead(a, br, n) \ 349 ((rar_br_has(br, (n)) || rar_br_fillup(a, br)) || rar_br_has(br, (n))) 350 /* Notify how many bits we consumed. */ 351 #define rar_br_consume(br, n) ((br)->cache_avail -= (n)) 352 #define rar_br_consume_unalined_bits(br) ((br)->cache_avail &= ~7) 353 354 static const uint32_t cache_masks[] = { 355 0x00000000, 0x00000001, 0x00000003, 0x00000007, 356 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F, 357 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF, 358 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 359 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 360 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 361 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 362 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 363 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF 364 }; 365 366 /* 367 * Shift away used bits in the cache data and fill it up with following bits. 368 * Call this when cache buffer does not have enough bits you need. 369 * 370 * Returns 1 if the cache buffer is full. 371 * Returns 0 if the cache buffer is not full; input buffer is empty. 372 */ 373 static int 374 rar_br_fillup(struct archive_read *a, struct rar_br *br) 375 { 376 struct rar *rar = (struct rar *)(a->format->data); 377 int n = CACHE_BITS - br->cache_avail; 378 379 for (;;) { 380 switch (n >> 3) { 381 case 8: 382 if (br->avail_in >= 8) { 383 br->cache_buffer = 384 ((uint64_t)br->next_in[0]) << 56 | 385 ((uint64_t)br->next_in[1]) << 48 | 386 ((uint64_t)br->next_in[2]) << 40 | 387 ((uint64_t)br->next_in[3]) << 32 | 388 ((uint32_t)br->next_in[4]) << 24 | 389 ((uint32_t)br->next_in[5]) << 16 | 390 ((uint32_t)br->next_in[6]) << 8 | 391 (uint32_t)br->next_in[7]; 392 br->next_in += 8; 393 br->avail_in -= 8; 394 br->cache_avail += 8 * 8; 395 rar->bytes_unconsumed += 8; 396 rar->bytes_remaining -= 8; 397 return (1); 398 } 399 break; 400 case 7: 401 if (br->avail_in >= 7) { 402 br->cache_buffer = 403 (br->cache_buffer << 56) | 404 ((uint64_t)br->next_in[0]) << 48 | 405 ((uint64_t)br->next_in[1]) << 40 | 406 ((uint64_t)br->next_in[2]) << 32 | 407 ((uint32_t)br->next_in[3]) << 24 | 408 ((uint32_t)br->next_in[4]) << 16 | 409 ((uint32_t)br->next_in[5]) << 8 | 410 (uint32_t)br->next_in[6]; 411 br->next_in += 7; 412 br->avail_in -= 7; 413 br->cache_avail += 7 * 8; 414 rar->bytes_unconsumed += 7; 415 rar->bytes_remaining -= 7; 416 return (1); 417 } 418 break; 419 case 6: 420 if (br->avail_in >= 6) { 421 br->cache_buffer = 422 (br->cache_buffer << 48) | 423 ((uint64_t)br->next_in[0]) << 40 | 424 ((uint64_t)br->next_in[1]) << 32 | 425 ((uint32_t)br->next_in[2]) << 24 | 426 ((uint32_t)br->next_in[3]) << 16 | 427 ((uint32_t)br->next_in[4]) << 8 | 428 (uint32_t)br->next_in[5]; 429 br->next_in += 6; 430 br->avail_in -= 6; 431 br->cache_avail += 6 * 8; 432 rar->bytes_unconsumed += 6; 433 rar->bytes_remaining -= 6; 434 return (1); 435 } 436 break; 437 case 0: 438 /* We have enough compressed data in 439 * the cache buffer.*/ 440 return (1); 441 default: 442 break; 443 } 444 if (br->avail_in <= 0) { 445 446 if (rar->bytes_unconsumed > 0) { 447 /* Consume as much as the decompressor 448 * actually used. */ 449 __archive_read_consume(a, rar->bytes_unconsumed); 450 rar->bytes_unconsumed = 0; 451 } 452 br->next_in = __archive_read_ahead(a, 1, &(br->avail_in)); 453 if (br->next_in == NULL) 454 return (0); 455 if (br->avail_in > rar->bytes_remaining) 456 br->avail_in = (ssize_t)rar->bytes_remaining; 457 if (br->avail_in == 0) 458 return (0); 459 } 460 br->cache_buffer = 461 (br->cache_buffer << 8) | *br->next_in++; 462 br->avail_in--; 463 br->cache_avail += 8; 464 n -= 8; 465 rar->bytes_unconsumed++; 466 rar->bytes_remaining--; 467 } 468 } 469 470 static int 471 rar_br_preparation(struct archive_read *a, struct rar_br *br) 472 { 473 struct rar *rar = (struct rar *)(a->format->data); 474 475 if (rar->bytes_remaining > 0) { 476 br->next_in = __archive_read_ahead(a, 1, &(br->avail_in)); 477 if (br->next_in == NULL) { 478 archive_set_error(&a->archive, 479 ARCHIVE_ERRNO_FILE_FORMAT, 480 "Truncated RAR file data"); 481 return (ARCHIVE_FATAL); 482 } 483 if (br->avail_in > rar->bytes_remaining) 484 br->avail_in = (ssize_t)rar->bytes_remaining; 485 if (br->cache_avail == 0) 486 (void)rar_br_fillup(a, br); 487 } 488 return (ARCHIVE_OK); 489 } 490 491 /* Find last bit set */ 492 static inline int 493 rar_fls(unsigned int word) 494 { 495 word |= (word >> 1); 496 word |= (word >> 2); 497 word |= (word >> 4); 498 word |= (word >> 8); 499 word |= (word >> 16); 500 return word - (word >> 1); 501 } 502 503 /* LZSS functions */ 504 static inline int64_t 505 lzss_position(struct lzss *lzss) 506 { 507 return lzss->position; 508 } 509 510 static inline int 511 lzss_mask(struct lzss *lzss) 512 { 513 return lzss->mask; 514 } 515 516 static inline int 517 lzss_size(struct lzss *lzss) 518 { 519 return lzss->mask + 1; 520 } 521 522 static inline int 523 lzss_offset_for_position(struct lzss *lzss, int64_t pos) 524 { 525 return (int)(pos & lzss->mask); 526 } 527 528 static inline unsigned char * 529 lzss_pointer_for_position(struct lzss *lzss, int64_t pos) 530 { 531 return &lzss->window[lzss_offset_for_position(lzss, pos)]; 532 } 533 534 static inline int 535 lzss_current_offset(struct lzss *lzss) 536 { 537 return lzss_offset_for_position(lzss, lzss->position); 538 } 539 540 static inline uint8_t * 541 lzss_current_pointer(struct lzss *lzss) 542 { 543 return lzss_pointer_for_position(lzss, lzss->position); 544 } 545 546 static inline void 547 lzss_emit_literal(struct rar *rar, uint8_t literal) 548 { 549 *lzss_current_pointer(&rar->lzss) = literal; 550 rar->lzss.position++; 551 } 552 553 static inline void 554 lzss_emit_match(struct rar *rar, int offset, int length) 555 { 556 int dstoffs = lzss_current_offset(&rar->lzss); 557 int srcoffs = (dstoffs - offset) & lzss_mask(&rar->lzss); 558 int l, li, remaining; 559 unsigned char *d, *s; 560 561 remaining = length; 562 while (remaining > 0) { 563 l = remaining; 564 if (dstoffs > srcoffs) { 565 if (l > lzss_size(&rar->lzss) - dstoffs) 566 l = lzss_size(&rar->lzss) - dstoffs; 567 } else { 568 if (l > lzss_size(&rar->lzss) - srcoffs) 569 l = lzss_size(&rar->lzss) - srcoffs; 570 } 571 d = &(rar->lzss.window[dstoffs]); 572 s = &(rar->lzss.window[srcoffs]); 573 if ((dstoffs + l < srcoffs) || (srcoffs + l < dstoffs)) 574 memcpy(d, s, l); 575 else { 576 for (li = 0; li < l; li++) 577 d[li] = s[li]; 578 } 579 remaining -= l; 580 dstoffs = (dstoffs + l) & lzss_mask(&(rar->lzss)); 581 srcoffs = (srcoffs + l) & lzss_mask(&(rar->lzss)); 582 } 583 rar->lzss.position += length; 584 } 585 586 static void * 587 ppmd_alloc(void *p, size_t size) 588 { 589 (void)p; 590 return malloc(size); 591 } 592 static void 593 ppmd_free(void *p, void *address) 594 { 595 (void)p; 596 free(address); 597 } 598 static ISzAlloc g_szalloc = { ppmd_alloc, ppmd_free }; 599 600 static Byte 601 ppmd_read(void *p) 602 { 603 struct archive_read *a = ((IByteIn*)p)->a; 604 struct rar *rar = (struct rar *)(a->format->data); 605 struct rar_br *br = &(rar->br); 606 Byte b; 607 if (!rar_br_read_ahead(a, br, 8)) 608 { 609 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 610 "Truncated RAR file data"); 611 rar->valid = 0; 612 return 0; 613 } 614 b = rar_br_bits(br, 8); 615 rar_br_consume(br, 8); 616 return b; 617 } 618 619 int 620 archive_read_support_format_rar(struct archive *_a) 621 { 622 struct archive_read *a = (struct archive_read *)_a; 623 struct rar *rar; 624 int r; 625 626 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 627 "archive_read_support_format_rar"); 628 629 rar = (struct rar *)malloc(sizeof(*rar)); 630 if (rar == NULL) 631 { 632 archive_set_error(&a->archive, ENOMEM, "Can't allocate rar data"); 633 return (ARCHIVE_FATAL); 634 } 635 memset(rar, 0, sizeof(*rar)); 636 637 r = __archive_read_register_format(a, 638 rar, 639 "rar", 640 archive_read_format_rar_bid, 641 archive_read_format_rar_options, 642 archive_read_format_rar_read_header, 643 archive_read_format_rar_read_data, 644 archive_read_format_rar_read_data_skip, 645 archive_read_format_rar_cleanup); 646 647 if (r != ARCHIVE_OK) 648 free(rar); 649 return (r); 650 } 651 652 static int 653 archive_read_format_rar_bid(struct archive_read *a, int best_bid) 654 { 655 const char *p; 656 657 /* If there's already a bid > 30, we'll never win. */ 658 if (best_bid > 30) 659 return (-1); 660 661 if ((p = __archive_read_ahead(a, 7, NULL)) == NULL) 662 return (-1); 663 664 if (memcmp(p, RAR_SIGNATURE, 7) == 0) 665 return (30); 666 667 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) { 668 /* This is a PE file */ 669 ssize_t offset = 0x10000; 670 ssize_t window = 4096; 671 ssize_t bytes_avail; 672 while (offset + window <= (1024 * 128)) { 673 const char *buff = __archive_read_ahead(a, offset + window, &bytes_avail); 674 if (buff == NULL) { 675 /* Remaining bytes are less than window. */ 676 window >>= 1; 677 if (window < 0x40) 678 return (0); 679 continue; 680 } 681 p = buff + offset; 682 while (p + 7 < buff + bytes_avail) { 683 if (memcmp(p, RAR_SIGNATURE, 7) == 0) 684 return (30); 685 p += 0x10; 686 } 687 offset = p - buff; 688 } 689 } 690 return (0); 691 } 692 693 static int 694 skip_sfx(struct archive_read *a) 695 { 696 const void *h; 697 const char *p, *q; 698 size_t skip, total; 699 ssize_t bytes, window; 700 701 total = 0; 702 window = 4096; 703 while (total + window <= (1024 * 128)) { 704 h = __archive_read_ahead(a, window, &bytes); 705 if (h == NULL) { 706 /* Remaining bytes are less than window. */ 707 window >>= 1; 708 if (window < 0x40) 709 goto fatal; 710 continue; 711 } 712 if (bytes < 0x40) 713 goto fatal; 714 p = h; 715 q = p + bytes; 716 717 /* 718 * Scan ahead until we find something that looks 719 * like the RAR header. 720 */ 721 while (p + 7 < q) { 722 if (memcmp(p, RAR_SIGNATURE, 7) == 0) { 723 skip = p - (const char *)h; 724 __archive_read_consume(a, skip); 725 return (ARCHIVE_OK); 726 } 727 p += 0x10; 728 } 729 skip = p - (const char *)h; 730 __archive_read_consume(a, skip); 731 total += skip; 732 } 733 fatal: 734 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 735 "Couldn't find out RAR header"); 736 return (ARCHIVE_FATAL); 737 } 738 739 static int 740 archive_read_format_rar_options(struct archive_read *a, 741 const char *key, const char *val) 742 { 743 struct rar *rar; 744 int ret = ARCHIVE_FAILED; 745 746 rar = (struct rar *)(a->format->data); 747 if (strcmp(key, "hdrcharset") == 0) { 748 if (val == NULL || val[0] == 0) 749 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 750 "rar: hdrcharset option needs a character-set name"); 751 else { 752 rar->opt_sconv = 753 archive_string_conversion_from_charset( 754 &a->archive, val, 0); 755 if (rar->opt_sconv != NULL) 756 ret = ARCHIVE_OK; 757 else 758 ret = ARCHIVE_FATAL; 759 } 760 return (ret); 761 } 762 763 /* Note: The "warn" return is just to inform the options 764 * supervisor that we didn't handle it. It will generate 765 * a suitable error if no one used this option. */ 766 return (ARCHIVE_WARN); 767 } 768 769 static int 770 archive_read_format_rar_read_header(struct archive_read *a, 771 struct archive_entry *entry) 772 { 773 const void *h; 774 const char *p; 775 struct rar *rar; 776 size_t skip; 777 char head_type; 778 int ret; 779 unsigned flags; 780 781 a->archive.archive_format = ARCHIVE_FORMAT_RAR; 782 if (a->archive.archive_format_name == NULL) 783 a->archive.archive_format_name = "RAR"; 784 785 rar = (struct rar *)(a->format->data); 786 787 /* RAR files can be generated without EOF headers, so return ARCHIVE_EOF if 788 * this fails. 789 */ 790 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 791 return (ARCHIVE_EOF); 792 793 p = h; 794 if (rar->found_first_header == 0 && 795 ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0)) { 796 /* This is an executable ? Must be self-extracting... */ 797 ret = skip_sfx(a); 798 if (ret < ARCHIVE_WARN) 799 return (ret); 800 } 801 rar->found_first_header = 1; 802 803 while (1) 804 { 805 unsigned long crc32_val; 806 807 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 808 return (ARCHIVE_FATAL); 809 p = h; 810 811 head_type = p[2]; 812 switch(head_type) 813 { 814 case MARK_HEAD: 815 if (memcmp(p, RAR_SIGNATURE, 7) != 0) { 816 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 817 "Invalid marker header"); 818 return (ARCHIVE_FATAL); 819 } 820 __archive_read_consume(a, 7); 821 break; 822 823 case MAIN_HEAD: 824 rar->main_flags = archive_le16dec(p + 3); 825 skip = archive_le16dec(p + 5); 826 if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)) { 827 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 828 "Invalid header size"); 829 return (ARCHIVE_FATAL); 830 } 831 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL) 832 return (ARCHIVE_FATAL); 833 p = h; 834 memcpy(rar->reserved1, p + 7, sizeof(rar->reserved1)); 835 memcpy(rar->reserved2, p + 7 + sizeof(rar->reserved1), 836 sizeof(rar->reserved2)); 837 if (rar->main_flags & MHD_ENCRYPTVER) { 838 if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)+1) { 839 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 840 "Invalid header size"); 841 return (ARCHIVE_FATAL); 842 } 843 rar->encryptver = *(p + 7 + sizeof(rar->reserved1) + 844 sizeof(rar->reserved2)); 845 } 846 847 if (rar->main_flags & MHD_VOLUME || 848 rar->main_flags & MHD_FIRSTVOLUME) 849 { 850 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 851 "RAR volume support unavailable."); 852 return (ARCHIVE_FATAL); 853 } 854 if (rar->main_flags & MHD_PASSWORD) 855 { 856 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 857 "RAR encryption support unavailable."); 858 return (ARCHIVE_FATAL); 859 } 860 861 crc32_val = crc32(0, (const unsigned char *)p + 2, skip - 2); 862 if ((crc32_val & 0xffff) != archive_le16dec(p)) { 863 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 864 "Header CRC error"); 865 return (ARCHIVE_FATAL); 866 } 867 __archive_read_consume(a, skip); 868 break; 869 870 case FILE_HEAD: 871 return read_header(a, entry, head_type); 872 873 case COMM_HEAD: 874 case AV_HEAD: 875 case SUB_HEAD: 876 case PROTECT_HEAD: 877 case SIGN_HEAD: 878 flags = archive_le16dec(p + 3); 879 skip = archive_le16dec(p + 5); 880 if (skip < 7) { 881 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 882 "Invalid header size"); 883 return (ARCHIVE_FATAL); 884 } 885 if (skip > 7) { 886 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL) 887 return (ARCHIVE_FATAL); 888 p = h; 889 } 890 if (flags & HD_ADD_SIZE_PRESENT) 891 { 892 if (skip < 7 + 4) { 893 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 894 "Invalid header size"); 895 return (ARCHIVE_FATAL); 896 } 897 skip += archive_le32dec(p + 7); 898 if ((h = __archive_read_ahead(a, skip, NULL)) == NULL) 899 return (ARCHIVE_FATAL); 900 p = h; 901 } 902 903 crc32_val = crc32(0, (const unsigned char *)p + 2, skip - 2); 904 if ((crc32_val & 0xffff) != archive_le16dec(p)) { 905 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 906 "Header CRC error"); 907 return (ARCHIVE_FATAL); 908 } 909 __archive_read_consume(a, skip); 910 break; 911 912 case NEWSUB_HEAD: 913 if ((ret = read_header(a, entry, head_type)) < ARCHIVE_WARN) 914 return ret; 915 break; 916 917 case ENDARC_HEAD: 918 return (ARCHIVE_EOF); 919 920 default: 921 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 922 "Bad RAR file"); 923 return (ARCHIVE_FATAL); 924 } 925 } 926 } 927 928 static int 929 archive_read_format_rar_read_data(struct archive_read *a, const void **buff, 930 size_t *size, int64_t *offset) 931 { 932 struct rar *rar = (struct rar *)(a->format->data); 933 int ret; 934 935 if (rar->bytes_unconsumed > 0) { 936 /* Consume as much as the decompressor actually used. */ 937 __archive_read_consume(a, rar->bytes_unconsumed); 938 rar->bytes_unconsumed = 0; 939 } 940 941 if (rar->entry_eof) { 942 *buff = NULL; 943 *size = 0; 944 *offset = rar->offset; 945 return (ARCHIVE_EOF); 946 } 947 948 switch (rar->compression_method) 949 { 950 case COMPRESS_METHOD_STORE: 951 ret = read_data_stored(a, buff, size, offset); 952 break; 953 954 case COMPRESS_METHOD_FASTEST: 955 case COMPRESS_METHOD_FAST: 956 case COMPRESS_METHOD_NORMAL: 957 case COMPRESS_METHOD_GOOD: 958 case COMPRESS_METHOD_BEST: 959 ret = read_data_compressed(a, buff, size, offset); 960 if (ret != ARCHIVE_OK && ret != ARCHIVE_WARN) 961 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc); 962 break; 963 964 default: 965 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 966 "Unsupported compression method for RAR file."); 967 ret = ARCHIVE_FATAL; 968 break; 969 } 970 return (ret); 971 } 972 973 static int 974 archive_read_format_rar_read_data_skip(struct archive_read *a) 975 { 976 struct rar *rar; 977 int64_t bytes_skipped; 978 979 rar = (struct rar *)(a->format->data); 980 981 if (rar->bytes_unconsumed > 0) { 982 /* Consume as much as the decompressor actually used. */ 983 __archive_read_consume(a, rar->bytes_unconsumed); 984 rar->bytes_unconsumed = 0; 985 } 986 987 if (rar->bytes_remaining > 0) { 988 bytes_skipped = __archive_read_consume(a, rar->bytes_remaining); 989 if (bytes_skipped < 0) 990 return (ARCHIVE_FATAL); 991 } 992 return (ARCHIVE_OK); 993 } 994 995 static int 996 archive_read_format_rar_cleanup(struct archive_read *a) 997 { 998 struct rar *rar; 999 1000 rar = (struct rar *)(a->format->data); 1001 free_codes(a); 1002 free(rar->filename); 1003 free(rar->unp_buffer); 1004 free(rar->lzss.window); 1005 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc); 1006 free(rar); 1007 (a->format->data) = NULL; 1008 return (ARCHIVE_OK); 1009 } 1010 1011 static int 1012 read_header(struct archive_read *a, struct archive_entry *entry, 1013 char head_type) 1014 { 1015 const void *h; 1016 const char *p, *endp; 1017 struct rar *rar; 1018 struct rar_header rar_header; 1019 struct rar_file_header file_header; 1020 int64_t header_size; 1021 unsigned filename_size, end; 1022 char *filename; 1023 char *strp; 1024 char packed_size[8]; 1025 char unp_size[8]; 1026 int ttime; 1027 struct archive_string_conv *sconv, *fn_sconv; 1028 unsigned long crc32_val; 1029 int ret = (ARCHIVE_OK), ret2; 1030 1031 rar = (struct rar *)(a->format->data); 1032 1033 /* Setup a string conversion object for non-rar-unicode filenames. */ 1034 sconv = rar->opt_sconv; 1035 if (sconv == NULL) { 1036 if (!rar->init_default_conversion) { 1037 rar->sconv_default = 1038 archive_string_default_conversion_for_read( 1039 &(a->archive)); 1040 rar->init_default_conversion = 1; 1041 } 1042 sconv = rar->sconv_default; 1043 } 1044 1045 1046 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 1047 return (ARCHIVE_FATAL); 1048 p = h; 1049 memcpy(&rar_header, p, sizeof(rar_header)); 1050 rar->file_flags = archive_le16dec(rar_header.flags); 1051 header_size = archive_le16dec(rar_header.size); 1052 if (header_size < (int64_t)sizeof(file_header) + 7) { 1053 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1054 "Invalid header size"); 1055 return (ARCHIVE_FATAL); 1056 } 1057 crc32_val = crc32(0, (const unsigned char *)p + 2, 7 - 2); 1058 __archive_read_consume(a, 7); 1059 1060 if (!(rar->file_flags & FHD_SOLID)) 1061 { 1062 rar->compression_method = 0; 1063 rar->packed_size = 0; 1064 rar->unp_size = 0; 1065 rar->mtime = 0; 1066 rar->ctime = 0; 1067 rar->atime = 0; 1068 rar->arctime = 0; 1069 rar->mode = 0; 1070 memset(&rar->salt, 0, sizeof(rar->salt)); 1071 rar->atime = 0; 1072 rar->ansec = 0; 1073 rar->ctime = 0; 1074 rar->cnsec = 0; 1075 rar->mtime = 0; 1076 rar->mnsec = 0; 1077 rar->arctime = 0; 1078 rar->arcnsec = 0; 1079 } 1080 else 1081 { 1082 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1083 "RAR solid archive support unavailable."); 1084 return (ARCHIVE_FATAL); 1085 } 1086 1087 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL) 1088 return (ARCHIVE_FATAL); 1089 1090 /* File Header CRC check. */ 1091 crc32_val = crc32(crc32_val, h, (unsigned)(header_size - 7)); 1092 if ((crc32_val & 0xffff) != archive_le16dec(rar_header.crc)) { 1093 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1094 "Header CRC error"); 1095 return (ARCHIVE_FATAL); 1096 } 1097 /* If no CRC error, Go on parsing File Header. */ 1098 p = h; 1099 endp = p + header_size - 7; 1100 memcpy(&file_header, p, sizeof(file_header)); 1101 p += sizeof(file_header); 1102 1103 rar->compression_method = file_header.method; 1104 1105 ttime = archive_le32dec(file_header.file_time); 1106 rar->mtime = get_time(ttime); 1107 1108 rar->file_crc = archive_le32dec(file_header.file_crc); 1109 1110 if (rar->file_flags & FHD_PASSWORD) 1111 { 1112 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1113 "RAR encryption support unavailable."); 1114 return (ARCHIVE_FATAL); 1115 } 1116 1117 if (rar->file_flags & FHD_LARGE) 1118 { 1119 memcpy(packed_size, file_header.pack_size, 4); 1120 memcpy(packed_size + 4, p, 4); /* High pack size */ 1121 p += 4; 1122 memcpy(unp_size, file_header.unp_size, 4); 1123 memcpy(unp_size + 4, p, 4); /* High unpack size */ 1124 p += 4; 1125 rar->packed_size = archive_le64dec(&packed_size); 1126 rar->unp_size = archive_le64dec(&unp_size); 1127 } 1128 else 1129 { 1130 rar->packed_size = archive_le32dec(file_header.pack_size); 1131 rar->unp_size = archive_le32dec(file_header.unp_size); 1132 } 1133 1134 if (rar->packed_size < 0 || rar->unp_size < 0) 1135 { 1136 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1137 "Invalid sizes specified."); 1138 return (ARCHIVE_FATAL); 1139 } 1140 1141 /* TODO: RARv3 subblocks contain comments. For now the complete block is 1142 * consumed at the end. 1143 */ 1144 if (head_type == NEWSUB_HEAD) { 1145 size_t distance = p - (const char *)h; 1146 header_size += rar->packed_size; 1147 /* Make sure we have the extended data. */ 1148 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL) 1149 return (ARCHIVE_FATAL); 1150 p = h; 1151 endp = p + header_size - 7; 1152 p += distance; 1153 } 1154 1155 filename_size = archive_le16dec(file_header.name_size); 1156 if (p + filename_size > endp) { 1157 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1158 "Invalid filename size"); 1159 return (ARCHIVE_FATAL); 1160 } 1161 if (rar->filename_allocated < filename_size * 2 + 2) { 1162 char *newptr; 1163 size_t newsize = filename_size * 2 + 2; 1164 newptr = realloc(rar->filename, newsize); 1165 if (newptr == NULL) { 1166 archive_set_error(&a->archive, ENOMEM, 1167 "Couldn't allocate memory."); 1168 return (ARCHIVE_FATAL); 1169 } 1170 rar->filename = newptr; 1171 rar->filename_allocated = newsize; 1172 } 1173 filename = rar->filename; 1174 memcpy(filename, p, filename_size); 1175 filename[filename_size] = '\0'; 1176 if (rar->file_flags & FHD_UNICODE) 1177 { 1178 if (filename_size != strlen(filename)) 1179 { 1180 unsigned char highbyte, flagbits, flagbyte, offset; 1181 unsigned fn_end; 1182 1183 end = filename_size; 1184 fn_end = filename_size * 2; 1185 filename_size = 0; 1186 offset = strlen(filename) + 1; 1187 highbyte = *(p + offset++); 1188 flagbits = 0; 1189 flagbyte = 0; 1190 while (offset < end && filename_size < fn_end) 1191 { 1192 if (!flagbits) 1193 { 1194 flagbyte = *(p + offset++); 1195 flagbits = 8; 1196 } 1197 1198 flagbits -= 2; 1199 switch((flagbyte >> flagbits) & 3) 1200 { 1201 case 0: 1202 filename[filename_size++] = '\0'; 1203 filename[filename_size++] = *(p + offset++); 1204 break; 1205 case 1: 1206 filename[filename_size++] = highbyte; 1207 filename[filename_size++] = *(p + offset++); 1208 break; 1209 case 2: 1210 filename[filename_size++] = *(p + offset + 1); 1211 filename[filename_size++] = *(p + offset); 1212 offset += 2; 1213 break; 1214 case 3: 1215 { 1216 char extra, high; 1217 uint8_t length = *(p + offset++); 1218 1219 if (length & 0x80) { 1220 extra = *(p + offset++); 1221 high = (char)highbyte; 1222 } else 1223 extra = high = 0; 1224 length = (length & 0x7f) + 2; 1225 while (length && filename_size < fn_end) { 1226 unsigned cp = filename_size >> 1; 1227 filename[filename_size++] = high; 1228 filename[filename_size++] = p[cp] + extra; 1229 length--; 1230 } 1231 } 1232 break; 1233 } 1234 } 1235 if (filename_size > fn_end) { 1236 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1237 "Invalid filename"); 1238 return (ARCHIVE_FATAL); 1239 } 1240 filename[filename_size++] = '\0'; 1241 filename[filename_size++] = '\0'; 1242 1243 /* Decoded unicode form is UTF-16BE, so we have to update a string 1244 * conversion object for it. */ 1245 if (rar->sconv_utf16be == NULL) { 1246 rar->sconv_utf16be = archive_string_conversion_from_charset( 1247 &a->archive, "UTF-16BE", 1); 1248 if (rar->sconv_utf16be == NULL) 1249 return (ARCHIVE_FATAL); 1250 } 1251 fn_sconv = rar->sconv_utf16be; 1252 1253 strp = filename; 1254 while (memcmp(strp, "\x00\x00", 2)) 1255 { 1256 if (!memcmp(strp, "\x00\\", 2)) 1257 *(strp + 1) = '/'; 1258 strp += 2; 1259 } 1260 p += offset; 1261 } else { 1262 /* 1263 * If FHD_UNICODE is set but no unicode data, this file name form 1264 * is UTF-8, so we have to update a string conversion object for 1265 * it accordingly. 1266 */ 1267 if (rar->sconv_utf8 == NULL) { 1268 rar->sconv_utf8 = archive_string_conversion_from_charset( 1269 &a->archive, "UTF-8", 1); 1270 if (rar->sconv_utf8 == NULL) 1271 return (ARCHIVE_FATAL); 1272 } 1273 fn_sconv = rar->sconv_utf8; 1274 while ((strp = strchr(filename, '\\')) != NULL) 1275 *strp = '/'; 1276 p += filename_size; 1277 } 1278 } 1279 else 1280 { 1281 fn_sconv = sconv; 1282 while ((strp = strchr(filename, '\\')) != NULL) 1283 *strp = '/'; 1284 p += filename_size; 1285 } 1286 1287 if (rar->file_flags & FHD_SALT) 1288 { 1289 if (p + 8 > endp) { 1290 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1291 "Invalid header size"); 1292 return (ARCHIVE_FATAL); 1293 } 1294 memcpy(rar->salt, p, 8); 1295 p += 8; 1296 } 1297 1298 if (rar->file_flags & FHD_EXTTIME) { 1299 if (read_exttime(p, rar, endp) < 0) { 1300 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1301 "Invalid header size"); 1302 return (ARCHIVE_FATAL); 1303 } 1304 } 1305 1306 __archive_read_consume(a, header_size - 7); 1307 1308 switch(file_header.host_os) 1309 { 1310 case OS_MSDOS: 1311 case OS_OS2: 1312 case OS_WIN32: 1313 rar->mode = archive_le32dec(file_header.file_attr); 1314 if (rar->mode & FILE_ATTRIBUTE_DIRECTORY) 1315 rar->mode = AE_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH; 1316 else 1317 rar->mode = AE_IFREG; 1318 rar->mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; 1319 break; 1320 1321 case OS_UNIX: 1322 case OS_MAC_OS: 1323 case OS_BEOS: 1324 rar->mode = archive_le32dec(file_header.file_attr); 1325 break; 1326 1327 default: 1328 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1329 "Unknown file attributes from RAR file's host OS"); 1330 return (ARCHIVE_FATAL); 1331 } 1332 1333 rar->bytes_remaining = rar->packed_size; 1334 rar->bytes_uncopied = rar->bytes_unconsumed = 0; 1335 rar->lzss.position = rar->offset = 0; 1336 rar->dictionary_size = 0; 1337 rar->offset_outgoing = 0; 1338 rar->br.cache_avail = 0; 1339 rar->br.avail_in = 0; 1340 rar->crc_calculated = 0; 1341 rar->entry_eof = 0; 1342 rar->valid = 1; 1343 rar->is_ppmd_block = 0; 1344 rar->start_new_table = 1; 1345 free(rar->unp_buffer); 1346 rar->unp_buffer = NULL; 1347 rar->unp_offset = 0; 1348 rar->unp_buffer_size = UNP_BUFFER_SIZE; 1349 memset(rar->lengthtable, 0, sizeof(rar->lengthtable)); 1350 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc); 1351 rar->ppmd_valid = rar->ppmd_eod = 0; 1352 1353 /* Don't set any archive entries for non-file header types */ 1354 if (head_type == NEWSUB_HEAD) 1355 return ret; 1356 1357 archive_entry_set_mtime(entry, rar->mtime, rar->mnsec); 1358 archive_entry_set_ctime(entry, rar->ctime, rar->cnsec); 1359 archive_entry_set_atime(entry, rar->atime, rar->ansec); 1360 archive_entry_set_size(entry, rar->unp_size); 1361 archive_entry_set_mode(entry, rar->mode); 1362 1363 if (archive_entry_copy_pathname_l(entry, filename, filename_size, fn_sconv)) 1364 { 1365 if (errno == ENOMEM) 1366 { 1367 archive_set_error(&a->archive, ENOMEM, 1368 "Can't allocate memory for Pathname"); 1369 return (ARCHIVE_FATAL); 1370 } 1371 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1372 "Pathname cannot be converted from %s to current locale.", 1373 archive_string_conversion_charset_name(fn_sconv)); 1374 ret = (ARCHIVE_WARN); 1375 } 1376 1377 if (((rar->mode) & AE_IFMT) == AE_IFLNK) 1378 { 1379 /* Make sure a symbolic-link file does not have its body. */ 1380 rar->bytes_remaining = 0; 1381 archive_entry_set_size(entry, 0); 1382 1383 /* Read a symbolic-link name. */ 1384 if ((ret2 = read_symlink_stored(a, entry, sconv)) < (ARCHIVE_WARN)) 1385 return ret2; 1386 if (ret > ret2) 1387 ret = ret2; 1388 } 1389 1390 if (rar->bytes_remaining == 0) 1391 rar->entry_eof = 1; 1392 1393 return ret; 1394 } 1395 1396 static time_t 1397 get_time(int ttime) 1398 { 1399 struct tm tm; 1400 tm.tm_sec = 2 * (ttime & 0x1f); 1401 tm.tm_min = (ttime >> 5) & 0x3f; 1402 tm.tm_hour = (ttime >> 11) & 0x1f; 1403 tm.tm_mday = (ttime >> 16) & 0x1f; 1404 tm.tm_mon = ((ttime >> 21) & 0x0f) - 1; 1405 tm.tm_year = ((ttime >> 25) & 0x7f) + 80; 1406 tm.tm_isdst = -1; 1407 return mktime(&tm); 1408 } 1409 1410 static int 1411 read_exttime(const char *p, struct rar *rar, const char *endp) 1412 { 1413 unsigned rmode, flags, rem, j, count; 1414 int ttime, i; 1415 struct tm *tm; 1416 time_t t; 1417 long nsec; 1418 1419 if (p + 2 > endp) 1420 return (-1); 1421 flags = archive_le16dec(p); 1422 p += 2; 1423 1424 for (i = 3; i >= 0; i--) 1425 { 1426 t = 0; 1427 if (i == 3) 1428 t = rar->mtime; 1429 rmode = flags >> i * 4; 1430 if (rmode & 8) 1431 { 1432 if (!t) 1433 { 1434 if (p + 4 > endp) 1435 return (-1); 1436 ttime = archive_le32dec(p); 1437 t = get_time(ttime); 1438 p += 4; 1439 } 1440 rem = 0; 1441 count = rmode & 3; 1442 if (p + count > endp) 1443 return (-1); 1444 for (j = 0; j < count; j++) 1445 { 1446 rem = ((*p) << 16) | (rem >> 8); 1447 p++; 1448 } 1449 tm = localtime(&t); 1450 nsec = tm->tm_sec + rem / NS_UNIT; 1451 if (rmode & 4) 1452 { 1453 tm->tm_sec++; 1454 t = mktime(tm); 1455 } 1456 if (i == 3) 1457 { 1458 rar->mtime = t; 1459 rar->mnsec = nsec; 1460 } 1461 else if (i == 2) 1462 { 1463 rar->ctime = t; 1464 rar->cnsec = nsec; 1465 } 1466 else if (i == 1) 1467 { 1468 rar->atime = t; 1469 rar->ansec = nsec; 1470 } 1471 else 1472 { 1473 rar->arctime = t; 1474 rar->arcnsec = nsec; 1475 } 1476 } 1477 } 1478 return (0); 1479 } 1480 1481 static int 1482 read_symlink_stored(struct archive_read *a, struct archive_entry *entry, 1483 struct archive_string_conv *sconv) 1484 { 1485 const void *h; 1486 const char *p; 1487 struct rar *rar; 1488 int ret = (ARCHIVE_OK); 1489 1490 rar = (struct rar *)(a->format->data); 1491 if ((h = __archive_read_ahead(a, (size_t)rar->packed_size, NULL)) == NULL) 1492 return (ARCHIVE_FATAL); 1493 p = h; 1494 1495 if (archive_entry_copy_symlink_l(entry, 1496 p, (size_t)rar->packed_size, sconv)) 1497 { 1498 if (errno == ENOMEM) 1499 { 1500 archive_set_error(&a->archive, ENOMEM, 1501 "Can't allocate memory for link"); 1502 return (ARCHIVE_FATAL); 1503 } 1504 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1505 "link cannot be converted from %s to current locale.", 1506 archive_string_conversion_charset_name(sconv)); 1507 ret = (ARCHIVE_WARN); 1508 } 1509 __archive_read_consume(a, rar->packed_size); 1510 return ret; 1511 } 1512 1513 static int 1514 read_data_stored(struct archive_read *a, const void **buff, size_t *size, 1515 int64_t *offset) 1516 { 1517 struct rar *rar; 1518 ssize_t bytes_avail; 1519 1520 rar = (struct rar *)(a->format->data); 1521 if (rar->bytes_remaining == 0) 1522 { 1523 *buff = NULL; 1524 *size = 0; 1525 *offset = rar->offset; 1526 if (rar->file_crc != rar->crc_calculated) { 1527 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1528 "File CRC error"); 1529 return (ARCHIVE_FATAL); 1530 } 1531 rar->entry_eof = 1; 1532 return (ARCHIVE_EOF); 1533 } 1534 1535 *buff = __archive_read_ahead(a, 1, &bytes_avail); 1536 if (bytes_avail <= 0) 1537 { 1538 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1539 "Truncated RAR file data"); 1540 return (ARCHIVE_FATAL); 1541 } 1542 if (bytes_avail > rar->bytes_remaining) 1543 bytes_avail = (ssize_t)rar->bytes_remaining; 1544 1545 *size = bytes_avail; 1546 *offset = rar->offset; 1547 rar->offset += bytes_avail; 1548 rar->bytes_remaining -= bytes_avail; 1549 rar->bytes_unconsumed = bytes_avail; 1550 /* Calculate File CRC. */ 1551 rar->crc_calculated = crc32(rar->crc_calculated, *buff, bytes_avail); 1552 return (ARCHIVE_OK); 1553 } 1554 1555 static int 1556 read_data_compressed(struct archive_read *a, const void **buff, size_t *size, 1557 int64_t *offset) 1558 { 1559 struct rar *rar; 1560 int64_t start, end, actualend; 1561 size_t bs; 1562 int ret = (ARCHIVE_OK), sym, code, lzss_offset, length, i; 1563 1564 rar = (struct rar *)(a->format->data); 1565 1566 do { 1567 if (!rar->valid) 1568 return (ARCHIVE_FATAL); 1569 if (rar->ppmd_eod || 1570 (rar->dictionary_size && rar->offset >= rar->unp_size)) 1571 { 1572 if (rar->unp_offset > 0) { 1573 /* 1574 * We have unprocessed extracted data. write it out. 1575 */ 1576 *buff = rar->unp_buffer; 1577 *size = rar->unp_offset; 1578 *offset = rar->offset_outgoing; 1579 rar->offset_outgoing += *size; 1580 /* Calculate File CRC. */ 1581 rar->crc_calculated = crc32(rar->crc_calculated, *buff, *size); 1582 rar->unp_offset = 0; 1583 return (ARCHIVE_OK); 1584 } 1585 *buff = NULL; 1586 *size = 0; 1587 *offset = rar->offset; 1588 if (rar->file_crc != rar->crc_calculated) { 1589 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1590 "File CRC error"); 1591 return (ARCHIVE_FATAL); 1592 } 1593 rar->entry_eof = 1; 1594 return (ARCHIVE_EOF); 1595 } 1596 1597 if (!rar->is_ppmd_block && rar->dictionary_size && rar->bytes_uncopied > 0) 1598 { 1599 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset)) 1600 bs = rar->unp_buffer_size - rar->unp_offset; 1601 else 1602 bs = (size_t)rar->bytes_uncopied; 1603 ret = copy_from_lzss_window(a, buff, rar->offset, bs); 1604 if (ret != ARCHIVE_OK) 1605 return (ret); 1606 rar->offset += bs; 1607 rar->bytes_uncopied -= bs; 1608 if (*buff != NULL) { 1609 rar->unp_offset = 0; 1610 *size = rar->unp_buffer_size; 1611 *offset = rar->offset_outgoing; 1612 rar->offset_outgoing += *size; 1613 /* Calculate File CRC. */ 1614 rar->crc_calculated = crc32(rar->crc_calculated, *buff, *size); 1615 return (ret); 1616 } 1617 continue; 1618 } 1619 1620 if (!rar->br.next_in && 1621 (ret = rar_br_preparation(a, &(rar->br))) < ARCHIVE_WARN) 1622 return (ret); 1623 if (rar->start_new_table && ((ret = parse_codes(a)) < (ARCHIVE_WARN))) 1624 return (ret); 1625 1626 if (rar->is_ppmd_block) 1627 { 1628 if ((sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1629 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1630 { 1631 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1632 "Invalid symbol"); 1633 return (ARCHIVE_FATAL); 1634 } 1635 if(sym != rar->ppmd_escape) 1636 { 1637 lzss_emit_literal(rar, sym); 1638 rar->bytes_uncopied++; 1639 } 1640 else 1641 { 1642 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1643 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1644 { 1645 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1646 "Invalid symbol"); 1647 return (ARCHIVE_FATAL); 1648 } 1649 1650 switch(code) 1651 { 1652 case 0: 1653 rar->start_new_table = 1; 1654 return read_data_compressed(a, buff, size, offset); 1655 1656 case 2: 1657 rar->ppmd_eod = 1;/* End Of ppmd Data. */ 1658 continue; 1659 1660 case 3: 1661 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1662 "Parsing filters is unsupported."); 1663 return (ARCHIVE_FAILED); 1664 1665 case 4: 1666 lzss_offset = 0; 1667 for (i = 2; i >= 0; i--) 1668 { 1669 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1670 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1671 { 1672 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1673 "Invalid symbol"); 1674 return (ARCHIVE_FATAL); 1675 } 1676 lzss_offset |= code << (i * 8); 1677 } 1678 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1679 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1680 { 1681 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1682 "Invalid symbol"); 1683 return (ARCHIVE_FATAL); 1684 } 1685 lzss_emit_match(rar, lzss_offset + 2, length + 32); 1686 rar->bytes_uncopied += length + 32; 1687 break; 1688 1689 case 5: 1690 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1691 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1692 { 1693 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1694 "Invalid symbol"); 1695 return (ARCHIVE_FATAL); 1696 } 1697 lzss_emit_match(rar, 1, length + 4); 1698 rar->bytes_uncopied += length + 4; 1699 break; 1700 1701 default: 1702 lzss_emit_literal(rar, sym); 1703 rar->bytes_uncopied++; 1704 } 1705 } 1706 } 1707 else 1708 { 1709 start = rar->offset; 1710 end = start + rar->dictionary_size; 1711 rar->filterstart = INT64_MAX; 1712 1713 if ((actualend = expand(a, end)) < 0) 1714 return ((int)actualend); 1715 1716 rar->bytes_uncopied = actualend - start; 1717 if (rar->bytes_uncopied == 0) { 1718 /* Broken RAR files cause this case. 1719 * NOTE: If this case were possible on a normal RAR file 1720 * we would find out where it was actually bad and 1721 * what we would do to solve it. */ 1722 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1723 "Internal error extracting RAR file"); 1724 return (ARCHIVE_FATAL); 1725 } 1726 } 1727 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset)) 1728 bs = rar->unp_buffer_size - rar->unp_offset; 1729 else 1730 bs = (size_t)rar->bytes_uncopied; 1731 ret = copy_from_lzss_window(a, buff, rar->offset, bs); 1732 if (ret != ARCHIVE_OK) 1733 return (ret); 1734 rar->offset += bs; 1735 rar->bytes_uncopied -= bs; 1736 /* 1737 * If *buff is NULL, it means unp_buffer is not full. 1738 * So we have to continue extracting a RAR file. 1739 */ 1740 } while (*buff == NULL); 1741 1742 rar->unp_offset = 0; 1743 *size = rar->unp_buffer_size; 1744 *offset = rar->offset_outgoing; 1745 rar->offset_outgoing += *size; 1746 /* Calculate File CRC. */ 1747 rar->crc_calculated = crc32(rar->crc_calculated, *buff, *size); 1748 return ret; 1749 } 1750 1751 static int 1752 parse_codes(struct archive_read *a) 1753 { 1754 int i, j, val, n, r; 1755 unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags; 1756 unsigned int maxorder; 1757 struct huffman_code precode; 1758 struct rar *rar = (struct rar *)(a->format->data); 1759 struct rar_br *br = &(rar->br); 1760 1761 free_codes(a); 1762 1763 /* Skip to the next byte */ 1764 rar_br_consume_unalined_bits(br); 1765 1766 /* PPMd block flag */ 1767 if (!rar_br_read_ahead(a, br, 1)) 1768 goto truncated_data; 1769 if ((rar->is_ppmd_block = rar_br_bits(br, 1)) != 0) 1770 { 1771 rar_br_consume(br, 1); 1772 if (!rar_br_read_ahead(a, br, 7)) 1773 goto truncated_data; 1774 ppmd_flags = rar_br_bits(br, 7); 1775 rar_br_consume(br, 7); 1776 1777 /* Memory is allocated in MB */ 1778 if (ppmd_flags & 0x20) 1779 { 1780 if (!rar_br_read_ahead(a, br, 8)) 1781 goto truncated_data; 1782 rar->dictionary_size = (rar_br_bits(br, 8) + 1) << 20; 1783 rar_br_consume(br, 8); 1784 } 1785 1786 if (ppmd_flags & 0x40) 1787 { 1788 if (!rar_br_read_ahead(a, br, 8)) 1789 goto truncated_data; 1790 rar->ppmd_escape = rar->ppmd7_context.InitEsc = rar_br_bits(br, 8); 1791 rar_br_consume(br, 8); 1792 } 1793 else 1794 rar->ppmd_escape = 2; 1795 1796 if (ppmd_flags & 0x20) 1797 { 1798 maxorder = (ppmd_flags & 0x1F) + 1; 1799 if(maxorder > 16) 1800 maxorder = 16 + (maxorder - 16) * 3; 1801 1802 if (maxorder == 1) 1803 { 1804 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1805 "Truncated RAR file data"); 1806 return (ARCHIVE_FATAL); 1807 } 1808 1809 /* Make sure ppmd7_contest is freed before Ppmd7_Construct 1810 * because reading a broken file cause this abnormal sequence. */ 1811 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc); 1812 1813 rar->bytein.a = a; 1814 rar->bytein.Read = &ppmd_read; 1815 __archive_ppmd7_functions.PpmdRAR_RangeDec_CreateVTable(&rar->range_dec); 1816 rar->range_dec.Stream = &rar->bytein; 1817 __archive_ppmd7_functions.Ppmd7_Construct(&rar->ppmd7_context); 1818 1819 if (!__archive_ppmd7_functions.Ppmd7_Alloc(&rar->ppmd7_context, 1820 rar->dictionary_size, &g_szalloc)) 1821 { 1822 archive_set_error(&a->archive, ENOMEM, 1823 "Out of memory"); 1824 return (ARCHIVE_FATAL); 1825 } 1826 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec)) 1827 { 1828 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1829 "Unable to initialize PPMd range decoder"); 1830 return (ARCHIVE_FATAL); 1831 } 1832 __archive_ppmd7_functions.Ppmd7_Init(&rar->ppmd7_context, maxorder); 1833 rar->ppmd_valid = 1; 1834 } 1835 else 1836 { 1837 if (!rar->ppmd_valid) { 1838 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1839 "Invalid PPMd sequence"); 1840 return (ARCHIVE_FATAL); 1841 } 1842 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec)) 1843 { 1844 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1845 "Unable to initialize PPMd range decoder"); 1846 return (ARCHIVE_FATAL); 1847 } 1848 } 1849 } 1850 else 1851 { 1852 rar_br_consume(br, 1); 1853 1854 /* Keep existing table flag */ 1855 if (!rar_br_read_ahead(a, br, 1)) 1856 goto truncated_data; 1857 if (!rar_br_bits(br, 1)) 1858 memset(rar->lengthtable, 0, sizeof(rar->lengthtable)); 1859 rar_br_consume(br, 1); 1860 1861 memset(&bitlengths, 0, sizeof(bitlengths)); 1862 for (i = 0; i < MAX_SYMBOLS;) 1863 { 1864 if (!rar_br_read_ahead(a, br, 4)) 1865 goto truncated_data; 1866 bitlengths[i++] = rar_br_bits(br, 4); 1867 rar_br_consume(br, 4); 1868 if (bitlengths[i-1] == 0xF) 1869 { 1870 if (!rar_br_read_ahead(a, br, 4)) 1871 goto truncated_data; 1872 zerocount = rar_br_bits(br, 4); 1873 rar_br_consume(br, 4); 1874 if (zerocount) 1875 { 1876 i--; 1877 for (j = 0; j < zerocount + 2 && i < MAX_SYMBOLS; j++) 1878 bitlengths[i++] = 0; 1879 } 1880 } 1881 } 1882 1883 memset(&precode, 0, sizeof(precode)); 1884 r = create_code(a, &precode, bitlengths, MAX_SYMBOLS, MAX_SYMBOL_LENGTH); 1885 if (r != ARCHIVE_OK) { 1886 free(precode.tree); 1887 free(precode.table); 1888 return (r); 1889 } 1890 1891 for (i = 0; i < HUFFMAN_TABLE_SIZE;) 1892 { 1893 if ((val = read_next_symbol(a, &precode)) < 0) { 1894 free(precode.tree); 1895 free(precode.table); 1896 return (ARCHIVE_FATAL); 1897 } 1898 if (val < 16) 1899 { 1900 rar->lengthtable[i] = (rar->lengthtable[i] + val) & 0xF; 1901 i++; 1902 } 1903 else if (val < 18) 1904 { 1905 if (i == 0) 1906 { 1907 free(precode.tree); 1908 free(precode.table); 1909 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1910 "Internal error extracting RAR file."); 1911 return (ARCHIVE_FATAL); 1912 } 1913 1914 if(val == 16) { 1915 if (!rar_br_read_ahead(a, br, 3)) { 1916 free(precode.tree); 1917 free(precode.table); 1918 goto truncated_data; 1919 } 1920 n = rar_br_bits(br, 3) + 3; 1921 rar_br_consume(br, 3); 1922 } else { 1923 if (!rar_br_read_ahead(a, br, 7)) { 1924 free(precode.tree); 1925 free(precode.table); 1926 goto truncated_data; 1927 } 1928 n = rar_br_bits(br, 7) + 11; 1929 rar_br_consume(br, 7); 1930 } 1931 1932 for (j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++) 1933 { 1934 rar->lengthtable[i] = rar->lengthtable[i-1]; 1935 i++; 1936 } 1937 } 1938 else 1939 { 1940 if(val == 18) { 1941 if (!rar_br_read_ahead(a, br, 3)) { 1942 free(precode.tree); 1943 free(precode.table); 1944 goto truncated_data; 1945 } 1946 n = rar_br_bits(br, 3) + 3; 1947 rar_br_consume(br, 3); 1948 } else { 1949 if (!rar_br_read_ahead(a, br, 7)) { 1950 free(precode.tree); 1951 free(precode.table); 1952 goto truncated_data; 1953 } 1954 n = rar_br_bits(br, 7) + 11; 1955 rar_br_consume(br, 7); 1956 } 1957 1958 for(j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++) 1959 rar->lengthtable[i++] = 0; 1960 } 1961 } 1962 free(precode.tree); 1963 free(precode.table); 1964 1965 r = create_code(a, &rar->maincode, &rar->lengthtable[0], MAINCODE_SIZE, 1966 MAX_SYMBOL_LENGTH); 1967 if (r != ARCHIVE_OK) 1968 return (r); 1969 r = create_code(a, &rar->offsetcode, &rar->lengthtable[MAINCODE_SIZE], 1970 OFFSETCODE_SIZE, MAX_SYMBOL_LENGTH); 1971 if (r != ARCHIVE_OK) 1972 return (r); 1973 r = create_code(a, &rar->lowoffsetcode, 1974 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE], 1975 LOWOFFSETCODE_SIZE, MAX_SYMBOL_LENGTH); 1976 if (r != ARCHIVE_OK) 1977 return (r); 1978 r = create_code(a, &rar->lengthcode, 1979 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE + 1980 LOWOFFSETCODE_SIZE], LENGTHCODE_SIZE, MAX_SYMBOL_LENGTH); 1981 if (r != ARCHIVE_OK) 1982 return (r); 1983 } 1984 1985 if (!rar->dictionary_size || !rar->lzss.window) 1986 { 1987 /* Seems as though dictionary sizes are not used. Even so, minimize 1988 * memory usage as much as possible. 1989 */ 1990 if (rar->unp_size >= DICTIONARY_MAX_SIZE) 1991 rar->dictionary_size = DICTIONARY_MAX_SIZE; 1992 else 1993 rar->dictionary_size = rar_fls((unsigned int)rar->unp_size) << 1; 1994 rar->lzss.window = (unsigned char *)realloc(rar->lzss.window, 1995 rar->dictionary_size); 1996 if (rar->lzss.window == NULL) { 1997 archive_set_error(&a->archive, ENOMEM, 1998 "Unable to allocate memory for uncompressed data."); 1999 return (ARCHIVE_FATAL); 2000 } 2001 memset(rar->lzss.window, 0, rar->dictionary_size); 2002 rar->lzss.mask = rar->dictionary_size - 1; 2003 } 2004 2005 rar->start_new_table = 0; 2006 return (ARCHIVE_OK); 2007 truncated_data: 2008 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2009 "Truncated RAR file data"); 2010 rar->valid = 0; 2011 return (ARCHIVE_FATAL); 2012 } 2013 2014 static void 2015 free_codes(struct archive_read *a) 2016 { 2017 struct rar *rar = (struct rar *)(a->format->data); 2018 free(rar->maincode.tree); 2019 free(rar->offsetcode.tree); 2020 free(rar->lowoffsetcode.tree); 2021 free(rar->lengthcode.tree); 2022 free(rar->maincode.table); 2023 free(rar->offsetcode.table); 2024 free(rar->lowoffsetcode.table); 2025 free(rar->lengthcode.table); 2026 memset(&rar->maincode, 0, sizeof(rar->maincode)); 2027 memset(&rar->offsetcode, 0, sizeof(rar->offsetcode)); 2028 memset(&rar->lowoffsetcode, 0, sizeof(rar->lowoffsetcode)); 2029 memset(&rar->lengthcode, 0, sizeof(rar->lengthcode)); 2030 } 2031 2032 2033 static int 2034 read_next_symbol(struct archive_read *a, struct huffman_code *code) 2035 { 2036 unsigned char bit; 2037 unsigned int bits; 2038 int length, value, node; 2039 struct rar *rar; 2040 struct rar_br *br; 2041 2042 if (!code->table) 2043 { 2044 if (make_table(a, code) != (ARCHIVE_OK)) 2045 return -1; 2046 } 2047 2048 rar = (struct rar *)(a->format->data); 2049 br = &(rar->br); 2050 2051 /* Look ahead (peek) at bits */ 2052 if (!rar_br_read_ahead(a, br, code->tablesize)) { 2053 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2054 "Truncated RAR file data"); 2055 rar->valid = 0; 2056 return -1; 2057 } 2058 bits = rar_br_bits(br, code->tablesize); 2059 2060 length = code->table[bits].length; 2061 value = code->table[bits].value; 2062 2063 if (length < 0) 2064 { 2065 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2066 "Invalid prefix code in bitstream"); 2067 return -1; 2068 } 2069 2070 if (length <= code->tablesize) 2071 { 2072 /* Skip length bits */ 2073 rar_br_consume(br, length); 2074 return value; 2075 } 2076 2077 /* Skip tablesize bits */ 2078 rar_br_consume(br, code->tablesize); 2079 2080 node = value; 2081 while (!(code->tree[node].branches[0] == 2082 code->tree[node].branches[1])) 2083 { 2084 if (!rar_br_read_ahead(a, br, 1)) { 2085 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2086 "Truncated RAR file data"); 2087 rar->valid = 0; 2088 return -1; 2089 } 2090 bit = rar_br_bits(br, 1); 2091 rar_br_consume(br, 1); 2092 2093 if (code->tree[node].branches[bit] < 0) 2094 { 2095 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2096 "Invalid prefix code in bitstream"); 2097 return -1; 2098 } 2099 node = code->tree[node].branches[bit]; 2100 } 2101 2102 return code->tree[node].branches[0]; 2103 } 2104 2105 static int 2106 create_code(struct archive_read *a, struct huffman_code *code, 2107 unsigned char *lengths, int numsymbols, char maxlength) 2108 { 2109 int i, j, codebits = 0, symbolsleft = numsymbols; 2110 2111 if (new_node(code) < 0) { 2112 archive_set_error(&a->archive, ENOMEM, 2113 "Unable to allocate memory for node data."); 2114 return (ARCHIVE_FATAL); 2115 } 2116 code->numentries = 1; 2117 code->minlength = INT_MAX; 2118 code->maxlength = INT_MIN; 2119 codebits = 0; 2120 for(i = 1; i <= maxlength; i++) 2121 { 2122 for(j = 0; j < numsymbols; j++) 2123 { 2124 if (lengths[j] != i) continue; 2125 if (add_value(a, code, j, codebits, i) != ARCHIVE_OK) 2126 return (ARCHIVE_FATAL); 2127 codebits++; 2128 if (--symbolsleft <= 0) { break; break; } 2129 } 2130 codebits <<= 1; 2131 } 2132 return (ARCHIVE_OK); 2133 } 2134 2135 static int 2136 add_value(struct archive_read *a, struct huffman_code *code, int value, 2137 int codebits, int length) 2138 { 2139 int repeatpos, lastnode, bitpos, bit, repeatnode, nextnode; 2140 2141 free(code->table); 2142 code->table = NULL; 2143 2144 if(length > code->maxlength) 2145 code->maxlength = length; 2146 if(length < code->minlength) 2147 code->minlength = length; 2148 2149 repeatpos = -1; 2150 if (repeatpos == 0 || (repeatpos >= 0 2151 && (((codebits >> (repeatpos - 1)) & 3) == 0 2152 || ((codebits >> (repeatpos - 1)) & 3) == 3))) 2153 { 2154 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2155 "Invalid repeat position"); 2156 return (ARCHIVE_FATAL); 2157 } 2158 2159 lastnode = 0; 2160 for (bitpos = length - 1; bitpos >= 0; bitpos--) 2161 { 2162 bit = (codebits >> bitpos) & 1; 2163 2164 /* Leaf node check */ 2165 if (code->tree[lastnode].branches[0] == 2166 code->tree[lastnode].branches[1]) 2167 { 2168 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2169 "Prefix found"); 2170 return (ARCHIVE_FATAL); 2171 } 2172 2173 if (bitpos == repeatpos) 2174 { 2175 /* Open branch check */ 2176 if (!(code->tree[lastnode].branches[bit] < 0)) 2177 { 2178 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2179 "Invalid repeating code"); 2180 return (ARCHIVE_FATAL); 2181 } 2182 2183 if ((repeatnode = new_node(code)) < 0) { 2184 archive_set_error(&a->archive, ENOMEM, 2185 "Unable to allocate memory for node data."); 2186 return (ARCHIVE_FATAL); 2187 } 2188 if ((nextnode = new_node(code)) < 0) { 2189 archive_set_error(&a->archive, ENOMEM, 2190 "Unable to allocate memory for node data."); 2191 return (ARCHIVE_FATAL); 2192 } 2193 2194 /* Set branches */ 2195 code->tree[lastnode].branches[bit] = repeatnode; 2196 code->tree[repeatnode].branches[bit] = repeatnode; 2197 code->tree[repeatnode].branches[bit^1] = nextnode; 2198 lastnode = nextnode; 2199 2200 bitpos++; /* terminating bit already handled, skip it */ 2201 } 2202 else 2203 { 2204 /* Open branch check */ 2205 if (code->tree[lastnode].branches[bit] < 0) 2206 { 2207 if (new_node(code) < 0) { 2208 archive_set_error(&a->archive, ENOMEM, 2209 "Unable to allocate memory for node data."); 2210 return (ARCHIVE_FATAL); 2211 } 2212 code->tree[lastnode].branches[bit] = code->numentries++; 2213 } 2214 2215 /* set to branch */ 2216 lastnode = code->tree[lastnode].branches[bit]; 2217 } 2218 } 2219 2220 if (!(code->tree[lastnode].branches[0] == -1 2221 && code->tree[lastnode].branches[1] == -2)) 2222 { 2223 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2224 "Prefix found"); 2225 return (ARCHIVE_FATAL); 2226 } 2227 2228 /* Set leaf value */ 2229 code->tree[lastnode].branches[0] = value; 2230 code->tree[lastnode].branches[1] = value; 2231 2232 return (ARCHIVE_OK); 2233 } 2234 2235 static int 2236 new_node(struct huffman_code *code) 2237 { 2238 code->tree = (struct huffman_tree_node *)realloc(code->tree, 2239 (code->numentries + 1) * sizeof(*code->tree)); 2240 if (code->tree == NULL) 2241 return (-1); 2242 code->tree[code->numentries].branches[0] = -1; 2243 code->tree[code->numentries].branches[1] = -2; 2244 return 1; 2245 } 2246 2247 static int 2248 make_table(struct archive_read *a, struct huffman_code *code) 2249 { 2250 if (code->maxlength < code->minlength || code->maxlength > 10) 2251 code->tablesize = 10; 2252 else 2253 code->tablesize = code->maxlength; 2254 2255 code->table = 2256 (struct huffman_table_entry *)malloc(sizeof(*code->table) 2257 * (1 << code->tablesize)); 2258 2259 return make_table_recurse(a, code, 0, code->table, 0, code->tablesize); 2260 } 2261 2262 static int 2263 make_table_recurse(struct archive_read *a, struct huffman_code *code, int node, 2264 struct huffman_table_entry *table, int depth, 2265 int maxdepth) 2266 { 2267 int currtablesize, i, ret = (ARCHIVE_OK); 2268 2269 if (!code->tree) 2270 { 2271 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2272 "Huffman tree was not created."); 2273 return (ARCHIVE_FATAL); 2274 } 2275 if (node < 0 || node >= code->numentries) 2276 { 2277 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2278 "Invalid location to Huffman tree specified."); 2279 return (ARCHIVE_FATAL); 2280 } 2281 2282 currtablesize = 1 << (maxdepth - depth); 2283 2284 if (code->tree[node].branches[0] == 2285 code->tree[node].branches[1]) 2286 { 2287 for(i = 0; i < currtablesize; i++) 2288 { 2289 table[i].length = depth; 2290 table[i].value = code->tree[node].branches[0]; 2291 } 2292 } 2293 else if (node < 0) 2294 { 2295 for(i = 0; i < currtablesize; i++) 2296 table[i].length = -1; 2297 } 2298 else 2299 { 2300 if(depth == maxdepth) 2301 { 2302 table[0].length = maxdepth + 1; 2303 table[0].value = node; 2304 } 2305 else 2306 { 2307 ret |= make_table_recurse(a, code, code->tree[node].branches[0], table, 2308 depth + 1, maxdepth); 2309 ret |= make_table_recurse(a, code, code->tree[node].branches[1], 2310 table + currtablesize / 2, depth + 1, maxdepth); 2311 } 2312 } 2313 return ret; 2314 } 2315 2316 static int64_t 2317 expand(struct archive_read *a, int64_t end) 2318 { 2319 static const unsigned char lengthbases[] = 2320 { 0, 1, 2, 3, 4, 5, 6, 2321 7, 8, 10, 12, 14, 16, 20, 2322 24, 28, 32, 40, 48, 56, 64, 2323 80, 96, 112, 128, 160, 192, 224 }; 2324 static const unsigned char lengthbits[] = 2325 { 0, 0, 0, 0, 0, 0, 0, 2326 0, 1, 1, 1, 1, 2, 2, 2327 2, 2, 3, 3, 3, 3, 4, 2328 4, 4, 4, 5, 5, 5, 5 }; 2329 static const unsigned int offsetbases[] = 2330 { 0, 1, 2, 3, 4, 6, 2331 8, 12, 16, 24, 32, 48, 2332 64, 96, 128, 192, 256, 384, 2333 512, 768, 1024, 1536, 2048, 3072, 2334 4096, 6144, 8192, 12288, 16384, 24576, 2335 32768, 49152, 65536, 98304, 131072, 196608, 2336 262144, 327680, 393216, 458752, 524288, 589824, 2337 655360, 720896, 786432, 851968, 917504, 983040, 2338 1048576, 1310720, 1572864, 1835008, 2097152, 2359296, 2339 2621440, 2883584, 3145728, 3407872, 3670016, 3932160 }; 2340 static const unsigned char offsetbits[] = 2341 { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 2342 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 2343 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 2344 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 2345 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 }; 2346 static const unsigned char shortbases[] = 2347 { 0, 4, 8, 16, 32, 64, 128, 192 }; 2348 static const unsigned char shortbits[] = 2349 { 2, 2, 3, 4, 5, 6, 6, 6 }; 2350 2351 int symbol, offs, len, offsindex, lensymbol, i, offssymbol, lowoffsetsymbol; 2352 unsigned char newfile; 2353 struct rar *rar = (struct rar *)(a->format->data); 2354 struct rar_br *br = &(rar->br); 2355 2356 if (rar->filterstart < end) 2357 end = rar->filterstart; 2358 2359 while (1) 2360 { 2361 if (rar->output_last_match && 2362 lzss_position(&rar->lzss) + rar->lastlength <= end) 2363 { 2364 lzss_emit_match(rar, rar->lastoffset, rar->lastlength); 2365 rar->output_last_match = 0; 2366 } 2367 2368 if(rar->is_ppmd_block || rar->output_last_match || 2369 lzss_position(&rar->lzss) >= end) 2370 return lzss_position(&rar->lzss); 2371 2372 if ((symbol = read_next_symbol(a, &rar->maincode)) < 0) 2373 return (ARCHIVE_FATAL); 2374 rar->output_last_match = 0; 2375 2376 if (symbol < 256) 2377 { 2378 lzss_emit_literal(rar, symbol); 2379 continue; 2380 } 2381 else if (symbol == 256) 2382 { 2383 if (!rar_br_read_ahead(a, br, 1)) 2384 goto truncated_data; 2385 newfile = !rar_br_bits(br, 1); 2386 rar_br_consume(br, 1); 2387 2388 if(newfile) 2389 { 2390 rar->start_new_block = 1; 2391 if (!rar_br_read_ahead(a, br, 1)) 2392 goto truncated_data; 2393 rar->start_new_table = rar_br_bits(br, 1); 2394 rar_br_consume(br, 1); 2395 return lzss_position(&rar->lzss); 2396 } 2397 else 2398 { 2399 if (parse_codes(a) != ARCHIVE_OK) 2400 return (ARCHIVE_FATAL); 2401 continue; 2402 } 2403 } 2404 else if(symbol==257) 2405 { 2406 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 2407 "Parsing filters is unsupported."); 2408 return (ARCHIVE_FAILED); 2409 } 2410 else if(symbol==258) 2411 { 2412 if(rar->lastlength == 0) 2413 continue; 2414 2415 offs = rar->lastoffset; 2416 len = rar->lastlength; 2417 } 2418 else if (symbol <= 262) 2419 { 2420 offsindex = symbol - 259; 2421 offs = rar->oldoffset[offsindex]; 2422 2423 if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0) 2424 goto bad_data; 2425 if (lensymbol > (int)(sizeof(lengthbases)/sizeof(lengthbases[0]))) 2426 goto bad_data; 2427 if (lensymbol > (int)(sizeof(lengthbits)/sizeof(lengthbits[0]))) 2428 goto bad_data; 2429 len = lengthbases[lensymbol] + 2; 2430 if (lengthbits[lensymbol] > 0) { 2431 if (!rar_br_read_ahead(a, br, lengthbits[lensymbol])) 2432 goto truncated_data; 2433 len += rar_br_bits(br, lengthbits[lensymbol]); 2434 rar_br_consume(br, lengthbits[lensymbol]); 2435 } 2436 2437 for (i = offsindex; i > 0; i--) 2438 rar->oldoffset[i] = rar->oldoffset[i-1]; 2439 rar->oldoffset[0] = offs; 2440 } 2441 else if(symbol<=270) 2442 { 2443 offs = shortbases[symbol-263] + 1; 2444 if(shortbits[symbol-263] > 0) { 2445 if (!rar_br_read_ahead(a, br, shortbits[symbol-263])) 2446 goto truncated_data; 2447 offs += rar_br_bits(br, shortbits[symbol-263]); 2448 rar_br_consume(br, shortbits[symbol-263]); 2449 } 2450 2451 len = 2; 2452 2453 for(i = 3; i > 0; i--) 2454 rar->oldoffset[i] = rar->oldoffset[i-1]; 2455 rar->oldoffset[0] = offs; 2456 } 2457 else 2458 { 2459 if (symbol-271 > (int)(sizeof(lengthbases)/sizeof(lengthbases[0]))) 2460 goto bad_data; 2461 if (symbol-271 > (int)(sizeof(lengthbits)/sizeof(lengthbits[0]))) 2462 goto bad_data; 2463 len = lengthbases[symbol-271]+3; 2464 if(lengthbits[symbol-271] > 0) { 2465 if (!rar_br_read_ahead(a, br, lengthbits[symbol-271])) 2466 goto truncated_data; 2467 len += rar_br_bits(br, lengthbits[symbol-271]); 2468 rar_br_consume(br, lengthbits[symbol-271]); 2469 } 2470 2471 if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0) 2472 goto bad_data; 2473 if (offssymbol > (int)(sizeof(offsetbases)/sizeof(offsetbases[0]))) 2474 goto bad_data; 2475 if (offssymbol > (int)(sizeof(offsetbits)/sizeof(offsetbits[0]))) 2476 goto bad_data; 2477 offs = offsetbases[offssymbol]+1; 2478 if(offsetbits[offssymbol] > 0) 2479 { 2480 if(offssymbol > 9) 2481 { 2482 if(offsetbits[offssymbol] > 4) { 2483 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol] - 4)) 2484 goto truncated_data; 2485 offs += rar_br_bits(br, offsetbits[offssymbol] - 4) << 4; 2486 rar_br_consume(br, offsetbits[offssymbol] - 4); 2487 } 2488 2489 if(rar->numlowoffsetrepeats > 0) 2490 { 2491 rar->numlowoffsetrepeats--; 2492 offs += rar->lastlowoffset; 2493 } 2494 else 2495 { 2496 if ((lowoffsetsymbol = 2497 read_next_symbol(a, &rar->lowoffsetcode)) < 0) 2498 return (ARCHIVE_FATAL); 2499 if(lowoffsetsymbol == 16) 2500 { 2501 rar->numlowoffsetrepeats = 15; 2502 offs += rar->lastlowoffset; 2503 } 2504 else 2505 { 2506 offs += lowoffsetsymbol; 2507 rar->lastlowoffset = lowoffsetsymbol; 2508 } 2509 } 2510 } 2511 else { 2512 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol])) 2513 goto truncated_data; 2514 offs += rar_br_bits(br, offsetbits[offssymbol]); 2515 rar_br_consume(br, offsetbits[offssymbol]); 2516 } 2517 } 2518 2519 if (offs >= 0x40000) 2520 len++; 2521 if (offs >= 0x2000) 2522 len++; 2523 2524 for(i = 3; i > 0; i--) 2525 rar->oldoffset[i] = rar->oldoffset[i-1]; 2526 rar->oldoffset[0] = offs; 2527 } 2528 2529 rar->lastoffset = offs; 2530 rar->lastlength = len; 2531 rar->output_last_match = 1; 2532 } 2533 truncated_data: 2534 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2535 "Truncated RAR file data"); 2536 rar->valid = 0; 2537 return (ARCHIVE_FATAL); 2538 bad_data: 2539 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2540 "Bad RAR file data"); 2541 return (ARCHIVE_FATAL); 2542 } 2543 2544 static int 2545 copy_from_lzss_window(struct archive_read *a, const void **buffer, 2546 int64_t startpos, int length) 2547 { 2548 int windowoffs, firstpart; 2549 struct rar *rar = (struct rar *)(a->format->data); 2550 2551 if (!rar->unp_buffer) 2552 { 2553 if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL) 2554 { 2555 archive_set_error(&a->archive, ENOMEM, 2556 "Unable to allocate memory for uncompressed data."); 2557 return (ARCHIVE_FATAL); 2558 } 2559 } 2560 2561 windowoffs = lzss_offset_for_position(&rar->lzss, startpos); 2562 if(windowoffs + length <= lzss_size(&rar->lzss)) 2563 memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs], 2564 length); 2565 else 2566 { 2567 firstpart = lzss_size(&rar->lzss) - windowoffs; 2568 if (firstpart < 0) { 2569 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2570 "Bad RAR file data"); 2571 return (ARCHIVE_FATAL); 2572 } 2573 if (firstpart < length) { 2574 memcpy(&rar->unp_buffer[rar->unp_offset], 2575 &rar->lzss.window[windowoffs], firstpart); 2576 memcpy(&rar->unp_buffer[rar->unp_offset + firstpart], 2577 &rar->lzss.window[0], length - firstpart); 2578 } else 2579 memcpy(&rar->unp_buffer[rar->unp_offset], 2580 &rar->lzss.window[windowoffs], length); 2581 } 2582 rar->unp_offset += length; 2583 if (rar->unp_offset >= rar->unp_buffer_size) 2584 *buffer = rar->unp_buffer; 2585 else 2586 *buffer = NULL; 2587 return (ARCHIVE_OK); 2588 } 2589