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