archive_read_support_format_rar.c revision 328827
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 break; 1029 1030 default: 1031 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1032 "Unsupported compression method for RAR file."); 1033 ret = ARCHIVE_FATAL; 1034 break; 1035 } 1036 return (ret); 1037} 1038 1039static int 1040archive_read_format_rar_read_data_skip(struct archive_read *a) 1041{ 1042 struct rar *rar; 1043 int64_t bytes_skipped; 1044 int ret; 1045 1046 rar = (struct rar *)(a->format->data); 1047 1048 if (rar->bytes_unconsumed > 0) { 1049 /* Consume as much as the decompressor actually used. */ 1050 __archive_read_consume(a, rar->bytes_unconsumed); 1051 rar->bytes_unconsumed = 0; 1052 } 1053 1054 if (rar->bytes_remaining > 0) { 1055 bytes_skipped = __archive_read_consume(a, rar->bytes_remaining); 1056 if (bytes_skipped < 0) 1057 return (ARCHIVE_FATAL); 1058 } 1059 1060 /* Compressed data to skip must be read from each header in a multivolume 1061 * archive. 1062 */ 1063 if (rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER) 1064 { 1065 ret = archive_read_format_rar_read_header(a, a->entry); 1066 if (ret == (ARCHIVE_EOF)) 1067 ret = archive_read_format_rar_read_header(a, a->entry); 1068 if (ret != (ARCHIVE_OK)) 1069 return ret; 1070 return archive_read_format_rar_read_data_skip(a); 1071 } 1072 1073 return (ARCHIVE_OK); 1074} 1075 1076static int64_t 1077archive_read_format_rar_seek_data(struct archive_read *a, int64_t offset, 1078 int whence) 1079{ 1080 int64_t client_offset, ret; 1081 unsigned int i; 1082 struct rar *rar = (struct rar *)(a->format->data); 1083 1084 if (rar->compression_method == COMPRESS_METHOD_STORE) 1085 { 1086 /* Modify the offset for use with SEEK_SET */ 1087 switch (whence) 1088 { 1089 case SEEK_CUR: 1090 client_offset = rar->offset_seek; 1091 break; 1092 case SEEK_END: 1093 client_offset = rar->unp_size; 1094 break; 1095 case SEEK_SET: 1096 default: 1097 client_offset = 0; 1098 } 1099 client_offset += offset; 1100 if (client_offset < 0) 1101 { 1102 /* Can't seek past beginning of data block */ 1103 return -1; 1104 } 1105 else if (client_offset > rar->unp_size) 1106 { 1107 /* 1108 * Set the returned offset but only seek to the end of 1109 * the data block. 1110 */ 1111 rar->offset_seek = client_offset; 1112 client_offset = rar->unp_size; 1113 } 1114 1115 client_offset += rar->dbo[0].start_offset; 1116 i = 0; 1117 while (i < rar->cursor) 1118 { 1119 i++; 1120 client_offset += rar->dbo[i].start_offset - rar->dbo[i-1].end_offset; 1121 } 1122 if (rar->main_flags & MHD_VOLUME) 1123 { 1124 /* Find the appropriate offset among the multivolume archive */ 1125 while (1) 1126 { 1127 if (client_offset < rar->dbo[rar->cursor].start_offset && 1128 rar->file_flags & FHD_SPLIT_BEFORE) 1129 { 1130 /* Search backwards for the correct data block */ 1131 if (rar->cursor == 0) 1132 { 1133 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1134 "Attempt to seek past beginning of RAR data block"); 1135 return (ARCHIVE_FAILED); 1136 } 1137 rar->cursor--; 1138 client_offset -= rar->dbo[rar->cursor+1].start_offset - 1139 rar->dbo[rar->cursor].end_offset; 1140 if (client_offset < rar->dbo[rar->cursor].start_offset) 1141 continue; 1142 ret = __archive_read_seek(a, rar->dbo[rar->cursor].start_offset - 1143 rar->dbo[rar->cursor].header_size, SEEK_SET); 1144 if (ret < (ARCHIVE_OK)) 1145 return ret; 1146 ret = archive_read_format_rar_read_header(a, a->entry); 1147 if (ret != (ARCHIVE_OK)) 1148 { 1149 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1150 "Error during seek of RAR file"); 1151 return (ARCHIVE_FAILED); 1152 } 1153 rar->cursor--; 1154 break; 1155 } 1156 else if (client_offset > rar->dbo[rar->cursor].end_offset && 1157 rar->file_flags & FHD_SPLIT_AFTER) 1158 { 1159 /* Search forward for the correct data block */ 1160 rar->cursor++; 1161 if (rar->cursor < rar->nodes && 1162 client_offset > rar->dbo[rar->cursor].end_offset) 1163 { 1164 client_offset += rar->dbo[rar->cursor].start_offset - 1165 rar->dbo[rar->cursor-1].end_offset; 1166 continue; 1167 } 1168 rar->cursor--; 1169 ret = __archive_read_seek(a, rar->dbo[rar->cursor].end_offset, 1170 SEEK_SET); 1171 if (ret < (ARCHIVE_OK)) 1172 return ret; 1173 ret = archive_read_format_rar_read_header(a, a->entry); 1174 if (ret == (ARCHIVE_EOF)) 1175 { 1176 rar->has_endarc_header = 1; 1177 ret = archive_read_format_rar_read_header(a, a->entry); 1178 } 1179 if (ret != (ARCHIVE_OK)) 1180 { 1181 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1182 "Error during seek of RAR file"); 1183 return (ARCHIVE_FAILED); 1184 } 1185 client_offset += rar->dbo[rar->cursor].start_offset - 1186 rar->dbo[rar->cursor-1].end_offset; 1187 continue; 1188 } 1189 break; 1190 } 1191 } 1192 1193 ret = __archive_read_seek(a, client_offset, SEEK_SET); 1194 if (ret < (ARCHIVE_OK)) 1195 return ret; 1196 rar->bytes_remaining = rar->dbo[rar->cursor].end_offset - ret; 1197 i = rar->cursor; 1198 while (i > 0) 1199 { 1200 i--; 1201 ret -= rar->dbo[i+1].start_offset - rar->dbo[i].end_offset; 1202 } 1203 ret -= rar->dbo[0].start_offset; 1204 1205 /* Always restart reading the file after a seek */ 1206 __archive_reset_read_data(&a->archive); 1207 1208 rar->bytes_unconsumed = 0; 1209 rar->offset = 0; 1210 1211 /* 1212 * If a seek past the end of file was requested, return the requested 1213 * offset. 1214 */ 1215 if (ret == rar->unp_size && rar->offset_seek > rar->unp_size) 1216 return rar->offset_seek; 1217 1218 /* Return the new offset */ 1219 rar->offset_seek = ret; 1220 return rar->offset_seek; 1221 } 1222 else 1223 { 1224 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1225 "Seeking of compressed RAR files is unsupported"); 1226 } 1227 return (ARCHIVE_FAILED); 1228} 1229 1230static int 1231archive_read_format_rar_cleanup(struct archive_read *a) 1232{ 1233 struct rar *rar; 1234 1235 rar = (struct rar *)(a->format->data); 1236 free_codes(a); 1237 free(rar->filename); 1238 free(rar->filename_save); 1239 free(rar->dbo); 1240 free(rar->unp_buffer); 1241 free(rar->lzss.window); 1242 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context); 1243 free(rar); 1244 (a->format->data) = NULL; 1245 return (ARCHIVE_OK); 1246} 1247 1248static int 1249read_header(struct archive_read *a, struct archive_entry *entry, 1250 char head_type) 1251{ 1252 const void *h; 1253 const char *p, *endp; 1254 struct rar *rar; 1255 struct rar_header rar_header; 1256 struct rar_file_header file_header; 1257 int64_t header_size; 1258 unsigned filename_size, end; 1259 char *filename; 1260 char *strp; 1261 char packed_size[8]; 1262 char unp_size[8]; 1263 int ttime; 1264 struct archive_string_conv *sconv, *fn_sconv; 1265 unsigned long crc32_val; 1266 int ret = (ARCHIVE_OK), ret2; 1267 1268 rar = (struct rar *)(a->format->data); 1269 1270 /* Setup a string conversion object for non-rar-unicode filenames. */ 1271 sconv = rar->opt_sconv; 1272 if (sconv == NULL) { 1273 if (!rar->init_default_conversion) { 1274 rar->sconv_default = 1275 archive_string_default_conversion_for_read( 1276 &(a->archive)); 1277 rar->init_default_conversion = 1; 1278 } 1279 sconv = rar->sconv_default; 1280 } 1281 1282 1283 if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 1284 return (ARCHIVE_FATAL); 1285 p = h; 1286 memcpy(&rar_header, p, sizeof(rar_header)); 1287 rar->file_flags = archive_le16dec(rar_header.flags); 1288 header_size = archive_le16dec(rar_header.size); 1289 if (header_size < (int64_t)sizeof(file_header) + 7) { 1290 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1291 "Invalid header size"); 1292 return (ARCHIVE_FATAL); 1293 } 1294 crc32_val = crc32(0, (const unsigned char *)p + 2, 7 - 2); 1295 __archive_read_consume(a, 7); 1296 1297 if (!(rar->file_flags & FHD_SOLID)) 1298 { 1299 rar->compression_method = 0; 1300 rar->packed_size = 0; 1301 rar->unp_size = 0; 1302 rar->mtime = 0; 1303 rar->ctime = 0; 1304 rar->atime = 0; 1305 rar->arctime = 0; 1306 rar->mode = 0; 1307 memset(&rar->salt, 0, sizeof(rar->salt)); 1308 rar->atime = 0; 1309 rar->ansec = 0; 1310 rar->ctime = 0; 1311 rar->cnsec = 0; 1312 rar->mtime = 0; 1313 rar->mnsec = 0; 1314 rar->arctime = 0; 1315 rar->arcnsec = 0; 1316 } 1317 else 1318 { 1319 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1320 "RAR solid archive support unavailable."); 1321 return (ARCHIVE_FATAL); 1322 } 1323 1324 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL) 1325 return (ARCHIVE_FATAL); 1326 1327 /* File Header CRC check. */ 1328 crc32_val = crc32(crc32_val, h, (unsigned)(header_size - 7)); 1329 if ((crc32_val & 0xffff) != archive_le16dec(rar_header.crc)) { 1330 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1331 "Header CRC error"); 1332 return (ARCHIVE_FATAL); 1333 } 1334 /* If no CRC error, Go on parsing File Header. */ 1335 p = h; 1336 endp = p + header_size - 7; 1337 memcpy(&file_header, p, sizeof(file_header)); 1338 p += sizeof(file_header); 1339 1340 rar->compression_method = file_header.method; 1341 1342 ttime = archive_le32dec(file_header.file_time); 1343 rar->mtime = get_time(ttime); 1344 1345 rar->file_crc = archive_le32dec(file_header.file_crc); 1346 1347 if (rar->file_flags & FHD_PASSWORD) 1348 { 1349 archive_entry_set_is_data_encrypted(entry, 1); 1350 rar->has_encrypted_entries = 1; 1351 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1352 "RAR encryption support unavailable."); 1353 /* Since it is only the data part itself that is encrypted we can at least 1354 extract information about the currently processed entry and don't need 1355 to return ARCHIVE_FATAL here. */ 1356 /*return (ARCHIVE_FATAL);*/ 1357 } 1358 1359 if (rar->file_flags & FHD_LARGE) 1360 { 1361 memcpy(packed_size, file_header.pack_size, 4); 1362 memcpy(packed_size + 4, p, 4); /* High pack size */ 1363 p += 4; 1364 memcpy(unp_size, file_header.unp_size, 4); 1365 memcpy(unp_size + 4, p, 4); /* High unpack size */ 1366 p += 4; 1367 rar->packed_size = archive_le64dec(&packed_size); 1368 rar->unp_size = archive_le64dec(&unp_size); 1369 } 1370 else 1371 { 1372 rar->packed_size = archive_le32dec(file_header.pack_size); 1373 rar->unp_size = archive_le32dec(file_header.unp_size); 1374 } 1375 1376 if (rar->packed_size < 0 || rar->unp_size < 0) 1377 { 1378 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1379 "Invalid sizes specified."); 1380 return (ARCHIVE_FATAL); 1381 } 1382 1383 rar->bytes_remaining = rar->packed_size; 1384 1385 /* TODO: RARv3 subblocks contain comments. For now the complete block is 1386 * consumed at the end. 1387 */ 1388 if (head_type == NEWSUB_HEAD) { 1389 size_t distance = p - (const char *)h; 1390 header_size += rar->packed_size; 1391 /* Make sure we have the extended data. */ 1392 if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL) 1393 return (ARCHIVE_FATAL); 1394 p = h; 1395 endp = p + header_size - 7; 1396 p += distance; 1397 } 1398 1399 filename_size = archive_le16dec(file_header.name_size); 1400 if (p + filename_size > endp) { 1401 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1402 "Invalid filename size"); 1403 return (ARCHIVE_FATAL); 1404 } 1405 if (rar->filename_allocated < filename_size * 2 + 2) { 1406 char *newptr; 1407 size_t newsize = filename_size * 2 + 2; 1408 newptr = realloc(rar->filename, newsize); 1409 if (newptr == NULL) { 1410 archive_set_error(&a->archive, ENOMEM, 1411 "Couldn't allocate memory."); 1412 return (ARCHIVE_FATAL); 1413 } 1414 rar->filename = newptr; 1415 rar->filename_allocated = newsize; 1416 } 1417 filename = rar->filename; 1418 memcpy(filename, p, filename_size); 1419 filename[filename_size] = '\0'; 1420 if (rar->file_flags & FHD_UNICODE) 1421 { 1422 if (filename_size != strlen(filename)) 1423 { 1424 unsigned char highbyte, flagbits, flagbyte; 1425 unsigned fn_end, offset; 1426 1427 end = filename_size; 1428 fn_end = filename_size * 2; 1429 filename_size = 0; 1430 offset = (unsigned)strlen(filename) + 1; 1431 highbyte = *(p + offset++); 1432 flagbits = 0; 1433 flagbyte = 0; 1434 while (offset < end && filename_size < fn_end) 1435 { 1436 if (!flagbits) 1437 { 1438 flagbyte = *(p + offset++); 1439 flagbits = 8; 1440 } 1441 1442 flagbits -= 2; 1443 switch((flagbyte >> flagbits) & 3) 1444 { 1445 case 0: 1446 filename[filename_size++] = '\0'; 1447 filename[filename_size++] = *(p + offset++); 1448 break; 1449 case 1: 1450 filename[filename_size++] = highbyte; 1451 filename[filename_size++] = *(p + offset++); 1452 break; 1453 case 2: 1454 filename[filename_size++] = *(p + offset + 1); 1455 filename[filename_size++] = *(p + offset); 1456 offset += 2; 1457 break; 1458 case 3: 1459 { 1460 char extra, high; 1461 uint8_t length = *(p + offset++); 1462 1463 if (length & 0x80) { 1464 extra = *(p + offset++); 1465 high = (char)highbyte; 1466 } else 1467 extra = high = 0; 1468 length = (length & 0x7f) + 2; 1469 while (length && filename_size < fn_end) { 1470 unsigned cp = filename_size >> 1; 1471 filename[filename_size++] = high; 1472 filename[filename_size++] = p[cp] + extra; 1473 length--; 1474 } 1475 } 1476 break; 1477 } 1478 } 1479 if (filename_size > fn_end) { 1480 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1481 "Invalid filename"); 1482 return (ARCHIVE_FATAL); 1483 } 1484 filename[filename_size++] = '\0'; 1485 /* 1486 * Do not increment filename_size here as the computations below 1487 * add the space for the terminating NUL explicitly. 1488 */ 1489 filename[filename_size] = '\0'; 1490 1491 /* Decoded unicode form is UTF-16BE, so we have to update a string 1492 * conversion object for it. */ 1493 if (rar->sconv_utf16be == NULL) { 1494 rar->sconv_utf16be = archive_string_conversion_from_charset( 1495 &a->archive, "UTF-16BE", 1); 1496 if (rar->sconv_utf16be == NULL) 1497 return (ARCHIVE_FATAL); 1498 } 1499 fn_sconv = rar->sconv_utf16be; 1500 1501 strp = filename; 1502 while (memcmp(strp, "\x00\x00", 2)) 1503 { 1504 if (!memcmp(strp, "\x00\\", 2)) 1505 *(strp + 1) = '/'; 1506 strp += 2; 1507 } 1508 p += offset; 1509 } else { 1510 /* 1511 * If FHD_UNICODE is set but no unicode data, this file name form 1512 * is UTF-8, so we have to update a string conversion object for 1513 * it accordingly. 1514 */ 1515 if (rar->sconv_utf8 == NULL) { 1516 rar->sconv_utf8 = archive_string_conversion_from_charset( 1517 &a->archive, "UTF-8", 1); 1518 if (rar->sconv_utf8 == NULL) 1519 return (ARCHIVE_FATAL); 1520 } 1521 fn_sconv = rar->sconv_utf8; 1522 while ((strp = strchr(filename, '\\')) != NULL) 1523 *strp = '/'; 1524 p += filename_size; 1525 } 1526 } 1527 else 1528 { 1529 fn_sconv = sconv; 1530 while ((strp = strchr(filename, '\\')) != NULL) 1531 *strp = '/'; 1532 p += filename_size; 1533 } 1534 1535 /* Split file in multivolume RAR. No more need to process header. */ 1536 if (rar->filename_save && 1537 filename_size == rar->filename_save_size && 1538 !memcmp(rar->filename, rar->filename_save, filename_size + 1)) 1539 { 1540 __archive_read_consume(a, header_size - 7); 1541 rar->cursor++; 1542 if (rar->cursor >= rar->nodes) 1543 { 1544 rar->nodes++; 1545 if ((rar->dbo = 1546 realloc(rar->dbo, sizeof(*rar->dbo) * rar->nodes)) == NULL) 1547 { 1548 archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory."); 1549 return (ARCHIVE_FATAL); 1550 } 1551 rar->dbo[rar->cursor].header_size = header_size; 1552 rar->dbo[rar->cursor].start_offset = -1; 1553 rar->dbo[rar->cursor].end_offset = -1; 1554 } 1555 if (rar->dbo[rar->cursor].start_offset < 0) 1556 { 1557 rar->dbo[rar->cursor].start_offset = a->filter->position; 1558 rar->dbo[rar->cursor].end_offset = rar->dbo[rar->cursor].start_offset + 1559 rar->packed_size; 1560 } 1561 return ret; 1562 } 1563 1564 rar->filename_save = (char*)realloc(rar->filename_save, 1565 filename_size + 1); 1566 memcpy(rar->filename_save, rar->filename, filename_size + 1); 1567 rar->filename_save_size = filename_size; 1568 1569 /* Set info for seeking */ 1570 free(rar->dbo); 1571 if ((rar->dbo = calloc(1, sizeof(*rar->dbo))) == NULL) 1572 { 1573 archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory."); 1574 return (ARCHIVE_FATAL); 1575 } 1576 rar->dbo[0].header_size = header_size; 1577 rar->dbo[0].start_offset = -1; 1578 rar->dbo[0].end_offset = -1; 1579 rar->cursor = 0; 1580 rar->nodes = 1; 1581 1582 if (rar->file_flags & FHD_SALT) 1583 { 1584 if (p + 8 > endp) { 1585 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1586 "Invalid header size"); 1587 return (ARCHIVE_FATAL); 1588 } 1589 memcpy(rar->salt, p, 8); 1590 p += 8; 1591 } 1592 1593 if (rar->file_flags & FHD_EXTTIME) { 1594 if (read_exttime(p, rar, endp) < 0) { 1595 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1596 "Invalid header size"); 1597 return (ARCHIVE_FATAL); 1598 } 1599 } 1600 1601 __archive_read_consume(a, header_size - 7); 1602 rar->dbo[0].start_offset = a->filter->position; 1603 rar->dbo[0].end_offset = rar->dbo[0].start_offset + rar->packed_size; 1604 1605 switch(file_header.host_os) 1606 { 1607 case OS_MSDOS: 1608 case OS_OS2: 1609 case OS_WIN32: 1610 rar->mode = archive_le32dec(file_header.file_attr); 1611 if (rar->mode & FILE_ATTRIBUTE_DIRECTORY) 1612 rar->mode = AE_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH; 1613 else 1614 rar->mode = AE_IFREG; 1615 rar->mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; 1616 break; 1617 1618 case OS_UNIX: 1619 case OS_MAC_OS: 1620 case OS_BEOS: 1621 rar->mode = archive_le32dec(file_header.file_attr); 1622 break; 1623 1624 default: 1625 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1626 "Unknown file attributes from RAR file's host OS"); 1627 return (ARCHIVE_FATAL); 1628 } 1629 1630 rar->bytes_uncopied = rar->bytes_unconsumed = 0; 1631 rar->lzss.position = rar->offset = 0; 1632 rar->offset_seek = 0; 1633 rar->dictionary_size = 0; 1634 rar->offset_outgoing = 0; 1635 rar->br.cache_avail = 0; 1636 rar->br.avail_in = 0; 1637 rar->crc_calculated = 0; 1638 rar->entry_eof = 0; 1639 rar->valid = 1; 1640 rar->is_ppmd_block = 0; 1641 rar->start_new_table = 1; 1642 free(rar->unp_buffer); 1643 rar->unp_buffer = NULL; 1644 rar->unp_offset = 0; 1645 rar->unp_buffer_size = UNP_BUFFER_SIZE; 1646 memset(rar->lengthtable, 0, sizeof(rar->lengthtable)); 1647 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context); 1648 rar->ppmd_valid = rar->ppmd_eod = 0; 1649 1650 /* Don't set any archive entries for non-file header types */ 1651 if (head_type == NEWSUB_HEAD) 1652 return ret; 1653 1654 archive_entry_set_mtime(entry, rar->mtime, rar->mnsec); 1655 archive_entry_set_ctime(entry, rar->ctime, rar->cnsec); 1656 archive_entry_set_atime(entry, rar->atime, rar->ansec); 1657 archive_entry_set_size(entry, rar->unp_size); 1658 archive_entry_set_mode(entry, rar->mode); 1659 1660 if (archive_entry_copy_pathname_l(entry, filename, filename_size, fn_sconv)) 1661 { 1662 if (errno == ENOMEM) 1663 { 1664 archive_set_error(&a->archive, ENOMEM, 1665 "Can't allocate memory for Pathname"); 1666 return (ARCHIVE_FATAL); 1667 } 1668 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1669 "Pathname cannot be converted from %s to current locale.", 1670 archive_string_conversion_charset_name(fn_sconv)); 1671 ret = (ARCHIVE_WARN); 1672 } 1673 1674 if (((rar->mode) & AE_IFMT) == AE_IFLNK) 1675 { 1676 /* Make sure a symbolic-link file does not have its body. */ 1677 rar->bytes_remaining = 0; 1678 archive_entry_set_size(entry, 0); 1679 1680 /* Read a symbolic-link name. */ 1681 if ((ret2 = read_symlink_stored(a, entry, sconv)) < (ARCHIVE_WARN)) 1682 return ret2; 1683 if (ret > ret2) 1684 ret = ret2; 1685 } 1686 1687 if (rar->bytes_remaining == 0) 1688 rar->entry_eof = 1; 1689 1690 return ret; 1691} 1692 1693static time_t 1694get_time(int ttime) 1695{ 1696 struct tm tm; 1697 tm.tm_sec = 2 * (ttime & 0x1f); 1698 tm.tm_min = (ttime >> 5) & 0x3f; 1699 tm.tm_hour = (ttime >> 11) & 0x1f; 1700 tm.tm_mday = (ttime >> 16) & 0x1f; 1701 tm.tm_mon = ((ttime >> 21) & 0x0f) - 1; 1702 tm.tm_year = ((ttime >> 25) & 0x7f) + 80; 1703 tm.tm_isdst = -1; 1704 return mktime(&tm); 1705} 1706 1707static int 1708read_exttime(const char *p, struct rar *rar, const char *endp) 1709{ 1710 unsigned rmode, flags, rem, j, count; 1711 int ttime, i; 1712 struct tm *tm; 1713 time_t t; 1714 long nsec; 1715 1716 if (p + 2 > endp) 1717 return (-1); 1718 flags = archive_le16dec(p); 1719 p += 2; 1720 1721 for (i = 3; i >= 0; i--) 1722 { 1723 t = 0; 1724 if (i == 3) 1725 t = rar->mtime; 1726 rmode = flags >> i * 4; 1727 if (rmode & 8) 1728 { 1729 if (!t) 1730 { 1731 if (p + 4 > endp) 1732 return (-1); 1733 ttime = archive_le32dec(p); 1734 t = get_time(ttime); 1735 p += 4; 1736 } 1737 rem = 0; 1738 count = rmode & 3; 1739 if (p + count > endp) 1740 return (-1); 1741 for (j = 0; j < count; j++) 1742 { 1743 rem = (((unsigned)(unsigned char)*p) << 16) | (rem >> 8); 1744 p++; 1745 } 1746 tm = localtime(&t); 1747 nsec = tm->tm_sec + rem / NS_UNIT; 1748 if (rmode & 4) 1749 { 1750 tm->tm_sec++; 1751 t = mktime(tm); 1752 } 1753 if (i == 3) 1754 { 1755 rar->mtime = t; 1756 rar->mnsec = nsec; 1757 } 1758 else if (i == 2) 1759 { 1760 rar->ctime = t; 1761 rar->cnsec = nsec; 1762 } 1763 else if (i == 1) 1764 { 1765 rar->atime = t; 1766 rar->ansec = nsec; 1767 } 1768 else 1769 { 1770 rar->arctime = t; 1771 rar->arcnsec = nsec; 1772 } 1773 } 1774 } 1775 return (0); 1776} 1777 1778static int 1779read_symlink_stored(struct archive_read *a, struct archive_entry *entry, 1780 struct archive_string_conv *sconv) 1781{ 1782 const void *h; 1783 const char *p; 1784 struct rar *rar; 1785 int ret = (ARCHIVE_OK); 1786 1787 rar = (struct rar *)(a->format->data); 1788 if ((h = rar_read_ahead(a, (size_t)rar->packed_size, NULL)) == NULL) 1789 return (ARCHIVE_FATAL); 1790 p = h; 1791 1792 if (archive_entry_copy_symlink_l(entry, 1793 p, (size_t)rar->packed_size, sconv)) 1794 { 1795 if (errno == ENOMEM) 1796 { 1797 archive_set_error(&a->archive, ENOMEM, 1798 "Can't allocate memory for link"); 1799 return (ARCHIVE_FATAL); 1800 } 1801 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1802 "link cannot be converted from %s to current locale.", 1803 archive_string_conversion_charset_name(sconv)); 1804 ret = (ARCHIVE_WARN); 1805 } 1806 __archive_read_consume(a, rar->packed_size); 1807 return ret; 1808} 1809 1810static int 1811read_data_stored(struct archive_read *a, const void **buff, size_t *size, 1812 int64_t *offset) 1813{ 1814 struct rar *rar; 1815 ssize_t bytes_avail; 1816 1817 rar = (struct rar *)(a->format->data); 1818 if (rar->bytes_remaining == 0 && 1819 !(rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER)) 1820 { 1821 *buff = NULL; 1822 *size = 0; 1823 *offset = rar->offset; 1824 if (rar->file_crc != rar->crc_calculated) { 1825 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1826 "File CRC error"); 1827 return (ARCHIVE_FATAL); 1828 } 1829 rar->entry_eof = 1; 1830 return (ARCHIVE_EOF); 1831 } 1832 1833 *buff = rar_read_ahead(a, 1, &bytes_avail); 1834 if (bytes_avail <= 0) 1835 { 1836 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1837 "Truncated RAR file data"); 1838 return (ARCHIVE_FATAL); 1839 } 1840 1841 *size = bytes_avail; 1842 *offset = rar->offset; 1843 rar->offset += bytes_avail; 1844 rar->offset_seek += bytes_avail; 1845 rar->bytes_remaining -= bytes_avail; 1846 rar->bytes_unconsumed = bytes_avail; 1847 /* Calculate File CRC. */ 1848 rar->crc_calculated = crc32(rar->crc_calculated, *buff, 1849 (unsigned)bytes_avail); 1850 return (ARCHIVE_OK); 1851} 1852 1853static int 1854read_data_compressed(struct archive_read *a, const void **buff, size_t *size, 1855 int64_t *offset) 1856{ 1857 struct rar *rar; 1858 int64_t start, end, actualend; 1859 size_t bs; 1860 int ret = (ARCHIVE_OK), sym, code, lzss_offset, length, i; 1861 1862 rar = (struct rar *)(a->format->data); 1863 1864 do { 1865 if (!rar->valid) 1866 return (ARCHIVE_FATAL); 1867 if (rar->ppmd_eod || 1868 (rar->dictionary_size && rar->offset >= rar->unp_size)) 1869 { 1870 if (rar->unp_offset > 0) { 1871 /* 1872 * We have unprocessed extracted data. write it out. 1873 */ 1874 *buff = rar->unp_buffer; 1875 *size = rar->unp_offset; 1876 *offset = rar->offset_outgoing; 1877 rar->offset_outgoing += *size; 1878 /* Calculate File CRC. */ 1879 rar->crc_calculated = crc32(rar->crc_calculated, *buff, 1880 (unsigned)*size); 1881 rar->unp_offset = 0; 1882 return (ARCHIVE_OK); 1883 } 1884 *buff = NULL; 1885 *size = 0; 1886 *offset = rar->offset; 1887 if (rar->file_crc != rar->crc_calculated) { 1888 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1889 "File CRC error"); 1890 return (ARCHIVE_FATAL); 1891 } 1892 rar->entry_eof = 1; 1893 return (ARCHIVE_EOF); 1894 } 1895 1896 if (!rar->is_ppmd_block && rar->dictionary_size && rar->bytes_uncopied > 0) 1897 { 1898 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset)) 1899 bs = rar->unp_buffer_size - rar->unp_offset; 1900 else 1901 bs = (size_t)rar->bytes_uncopied; 1902 ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs); 1903 if (ret != ARCHIVE_OK) 1904 return (ret); 1905 rar->offset += bs; 1906 rar->bytes_uncopied -= bs; 1907 if (*buff != NULL) { 1908 rar->unp_offset = 0; 1909 *size = rar->unp_buffer_size; 1910 *offset = rar->offset_outgoing; 1911 rar->offset_outgoing += *size; 1912 /* Calculate File CRC. */ 1913 rar->crc_calculated = crc32(rar->crc_calculated, *buff, 1914 (unsigned)*size); 1915 return (ret); 1916 } 1917 continue; 1918 } 1919 1920 if (!rar->br.next_in && 1921 (ret = rar_br_preparation(a, &(rar->br))) < ARCHIVE_WARN) 1922 return (ret); 1923 if (rar->start_new_table && ((ret = parse_codes(a)) < (ARCHIVE_WARN))) 1924 return (ret); 1925 1926 if (rar->is_ppmd_block) 1927 { 1928 if ((sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1929 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1930 { 1931 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1932 "Invalid symbol"); 1933 return (ARCHIVE_FATAL); 1934 } 1935 if(sym != rar->ppmd_escape) 1936 { 1937 lzss_emit_literal(rar, sym); 1938 rar->bytes_uncopied++; 1939 } 1940 else 1941 { 1942 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1943 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1944 { 1945 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1946 "Invalid symbol"); 1947 return (ARCHIVE_FATAL); 1948 } 1949 1950 switch(code) 1951 { 1952 case 0: 1953 rar->start_new_table = 1; 1954 return read_data_compressed(a, buff, size, offset); 1955 1956 case 2: 1957 rar->ppmd_eod = 1;/* End Of ppmd Data. */ 1958 continue; 1959 1960 case 3: 1961 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1962 "Parsing filters is unsupported."); 1963 return (ARCHIVE_FAILED); 1964 1965 case 4: 1966 lzss_offset = 0; 1967 for (i = 2; i >= 0; i--) 1968 { 1969 if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1970 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1971 { 1972 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1973 "Invalid symbol"); 1974 return (ARCHIVE_FATAL); 1975 } 1976 lzss_offset |= code << (i * 8); 1977 } 1978 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1979 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1980 { 1981 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1982 "Invalid symbol"); 1983 return (ARCHIVE_FATAL); 1984 } 1985 lzss_emit_match(rar, lzss_offset + 2, length + 32); 1986 rar->bytes_uncopied += length + 32; 1987 break; 1988 1989 case 5: 1990 if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1991 &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1992 { 1993 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1994 "Invalid symbol"); 1995 return (ARCHIVE_FATAL); 1996 } 1997 lzss_emit_match(rar, 1, length + 4); 1998 rar->bytes_uncopied += length + 4; 1999 break; 2000 2001 default: 2002 lzss_emit_literal(rar, sym); 2003 rar->bytes_uncopied++; 2004 } 2005 } 2006 } 2007 else 2008 { 2009 start = rar->offset; 2010 end = start + rar->dictionary_size; 2011 rar->filterstart = INT64_MAX; 2012 2013 if ((actualend = expand(a, end)) < 0) 2014 return ((int)actualend); 2015 2016 rar->bytes_uncopied = actualend - start; 2017 if (rar->bytes_uncopied == 0) { 2018 /* Broken RAR files cause this case. 2019 * NOTE: If this case were possible on a normal RAR file 2020 * we would find out where it was actually bad and 2021 * what we would do to solve it. */ 2022 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2023 "Internal error extracting RAR file"); 2024 return (ARCHIVE_FATAL); 2025 } 2026 } 2027 if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset)) 2028 bs = rar->unp_buffer_size - rar->unp_offset; 2029 else 2030 bs = (size_t)rar->bytes_uncopied; 2031 ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs); 2032 if (ret != ARCHIVE_OK) 2033 return (ret); 2034 rar->offset += bs; 2035 rar->bytes_uncopied -= bs; 2036 /* 2037 * If *buff is NULL, it means unp_buffer is not full. 2038 * So we have to continue extracting a RAR file. 2039 */ 2040 } while (*buff == NULL); 2041 2042 rar->unp_offset = 0; 2043 *size = rar->unp_buffer_size; 2044 *offset = rar->offset_outgoing; 2045 rar->offset_outgoing += *size; 2046 /* Calculate File CRC. */ 2047 rar->crc_calculated = crc32(rar->crc_calculated, *buff, (unsigned)*size); 2048 return ret; 2049} 2050 2051static int 2052parse_codes(struct archive_read *a) 2053{ 2054 int i, j, val, n, r; 2055 unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags; 2056 unsigned int maxorder; 2057 struct huffman_code precode; 2058 struct rar *rar = (struct rar *)(a->format->data); 2059 struct rar_br *br = &(rar->br); 2060 2061 free_codes(a); 2062 2063 /* Skip to the next byte */ 2064 rar_br_consume_unalined_bits(br); 2065 2066 /* PPMd block flag */ 2067 if (!rar_br_read_ahead(a, br, 1)) 2068 goto truncated_data; 2069 if ((rar->is_ppmd_block = rar_br_bits(br, 1)) != 0) 2070 { 2071 rar_br_consume(br, 1); 2072 if (!rar_br_read_ahead(a, br, 7)) 2073 goto truncated_data; 2074 ppmd_flags = rar_br_bits(br, 7); 2075 rar_br_consume(br, 7); 2076 2077 /* Memory is allocated in MB */ 2078 if (ppmd_flags & 0x20) 2079 { 2080 if (!rar_br_read_ahead(a, br, 8)) 2081 goto truncated_data; 2082 rar->dictionary_size = (rar_br_bits(br, 8) + 1) << 20; 2083 rar_br_consume(br, 8); 2084 } 2085 2086 if (ppmd_flags & 0x40) 2087 { 2088 if (!rar_br_read_ahead(a, br, 8)) 2089 goto truncated_data; 2090 rar->ppmd_escape = rar->ppmd7_context.InitEsc = rar_br_bits(br, 8); 2091 rar_br_consume(br, 8); 2092 } 2093 else 2094 rar->ppmd_escape = 2; 2095 2096 if (ppmd_flags & 0x20) 2097 { 2098 maxorder = (ppmd_flags & 0x1F) + 1; 2099 if(maxorder > 16) 2100 maxorder = 16 + (maxorder - 16) * 3; 2101 2102 if (maxorder == 1) 2103 { 2104 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2105 "Truncated RAR file data"); 2106 return (ARCHIVE_FATAL); 2107 } 2108 2109 /* Make sure ppmd7_contest is freed before Ppmd7_Construct 2110 * because reading a broken file cause this abnormal sequence. */ 2111 __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context); 2112 2113 rar->bytein.a = a; 2114 rar->bytein.Read = &ppmd_read; 2115 __archive_ppmd7_functions.PpmdRAR_RangeDec_CreateVTable(&rar->range_dec); 2116 rar->range_dec.Stream = &rar->bytein; 2117 __archive_ppmd7_functions.Ppmd7_Construct(&rar->ppmd7_context); 2118 2119 if (rar->dictionary_size == 0) { 2120 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2121 "Invalid zero dictionary size"); 2122 return (ARCHIVE_FATAL); 2123 } 2124 2125 if (!__archive_ppmd7_functions.Ppmd7_Alloc(&rar->ppmd7_context, 2126 rar->dictionary_size)) 2127 { 2128 archive_set_error(&a->archive, ENOMEM, 2129 "Out of memory"); 2130 return (ARCHIVE_FATAL); 2131 } 2132 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec)) 2133 { 2134 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2135 "Unable to initialize PPMd range decoder"); 2136 return (ARCHIVE_FATAL); 2137 } 2138 __archive_ppmd7_functions.Ppmd7_Init(&rar->ppmd7_context, maxorder); 2139 rar->ppmd_valid = 1; 2140 } 2141 else 2142 { 2143 if (!rar->ppmd_valid) { 2144 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2145 "Invalid PPMd sequence"); 2146 return (ARCHIVE_FATAL); 2147 } 2148 if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec)) 2149 { 2150 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2151 "Unable to initialize PPMd range decoder"); 2152 return (ARCHIVE_FATAL); 2153 } 2154 } 2155 } 2156 else 2157 { 2158 rar_br_consume(br, 1); 2159 2160 /* Keep existing table flag */ 2161 if (!rar_br_read_ahead(a, br, 1)) 2162 goto truncated_data; 2163 if (!rar_br_bits(br, 1)) 2164 memset(rar->lengthtable, 0, sizeof(rar->lengthtable)); 2165 rar_br_consume(br, 1); 2166 2167 memset(&bitlengths, 0, sizeof(bitlengths)); 2168 for (i = 0; i < MAX_SYMBOLS;) 2169 { 2170 if (!rar_br_read_ahead(a, br, 4)) 2171 goto truncated_data; 2172 bitlengths[i++] = rar_br_bits(br, 4); 2173 rar_br_consume(br, 4); 2174 if (bitlengths[i-1] == 0xF) 2175 { 2176 if (!rar_br_read_ahead(a, br, 4)) 2177 goto truncated_data; 2178 zerocount = rar_br_bits(br, 4); 2179 rar_br_consume(br, 4); 2180 if (zerocount) 2181 { 2182 i--; 2183 for (j = 0; j < zerocount + 2 && i < MAX_SYMBOLS; j++) 2184 bitlengths[i++] = 0; 2185 } 2186 } 2187 } 2188 2189 memset(&precode, 0, sizeof(precode)); 2190 r = create_code(a, &precode, bitlengths, MAX_SYMBOLS, MAX_SYMBOL_LENGTH); 2191 if (r != ARCHIVE_OK) { 2192 free(precode.tree); 2193 free(precode.table); 2194 return (r); 2195 } 2196 2197 for (i = 0; i < HUFFMAN_TABLE_SIZE;) 2198 { 2199 if ((val = read_next_symbol(a, &precode)) < 0) { 2200 free(precode.tree); 2201 free(precode.table); 2202 return (ARCHIVE_FATAL); 2203 } 2204 if (val < 16) 2205 { 2206 rar->lengthtable[i] = (rar->lengthtable[i] + val) & 0xF; 2207 i++; 2208 } 2209 else if (val < 18) 2210 { 2211 if (i == 0) 2212 { 2213 free(precode.tree); 2214 free(precode.table); 2215 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2216 "Internal error extracting RAR file."); 2217 return (ARCHIVE_FATAL); 2218 } 2219 2220 if(val == 16) { 2221 if (!rar_br_read_ahead(a, br, 3)) { 2222 free(precode.tree); 2223 free(precode.table); 2224 goto truncated_data; 2225 } 2226 n = rar_br_bits(br, 3) + 3; 2227 rar_br_consume(br, 3); 2228 } else { 2229 if (!rar_br_read_ahead(a, br, 7)) { 2230 free(precode.tree); 2231 free(precode.table); 2232 goto truncated_data; 2233 } 2234 n = rar_br_bits(br, 7) + 11; 2235 rar_br_consume(br, 7); 2236 } 2237 2238 for (j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++) 2239 { 2240 rar->lengthtable[i] = rar->lengthtable[i-1]; 2241 i++; 2242 } 2243 } 2244 else 2245 { 2246 if(val == 18) { 2247 if (!rar_br_read_ahead(a, br, 3)) { 2248 free(precode.tree); 2249 free(precode.table); 2250 goto truncated_data; 2251 } 2252 n = rar_br_bits(br, 3) + 3; 2253 rar_br_consume(br, 3); 2254 } else { 2255 if (!rar_br_read_ahead(a, br, 7)) { 2256 free(precode.tree); 2257 free(precode.table); 2258 goto truncated_data; 2259 } 2260 n = rar_br_bits(br, 7) + 11; 2261 rar_br_consume(br, 7); 2262 } 2263 2264 for(j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++) 2265 rar->lengthtable[i++] = 0; 2266 } 2267 } 2268 free(precode.tree); 2269 free(precode.table); 2270 2271 r = create_code(a, &rar->maincode, &rar->lengthtable[0], MAINCODE_SIZE, 2272 MAX_SYMBOL_LENGTH); 2273 if (r != ARCHIVE_OK) 2274 return (r); 2275 r = create_code(a, &rar->offsetcode, &rar->lengthtable[MAINCODE_SIZE], 2276 OFFSETCODE_SIZE, MAX_SYMBOL_LENGTH); 2277 if (r != ARCHIVE_OK) 2278 return (r); 2279 r = create_code(a, &rar->lowoffsetcode, 2280 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE], 2281 LOWOFFSETCODE_SIZE, MAX_SYMBOL_LENGTH); 2282 if (r != ARCHIVE_OK) 2283 return (r); 2284 r = create_code(a, &rar->lengthcode, 2285 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE + 2286 LOWOFFSETCODE_SIZE], LENGTHCODE_SIZE, MAX_SYMBOL_LENGTH); 2287 if (r != ARCHIVE_OK) 2288 return (r); 2289 } 2290 2291 if (!rar->dictionary_size || !rar->lzss.window) 2292 { 2293 /* Seems as though dictionary sizes are not used. Even so, minimize 2294 * memory usage as much as possible. 2295 */ 2296 void *new_window; 2297 unsigned int new_size; 2298 2299 if (rar->unp_size >= DICTIONARY_MAX_SIZE) 2300 new_size = DICTIONARY_MAX_SIZE; 2301 else 2302 new_size = rar_fls((unsigned int)rar->unp_size) << 1; 2303 new_window = realloc(rar->lzss.window, new_size); 2304 if (new_window == NULL) { 2305 archive_set_error(&a->archive, ENOMEM, 2306 "Unable to allocate memory for uncompressed data."); 2307 return (ARCHIVE_FATAL); 2308 } 2309 rar->lzss.window = (unsigned char *)new_window; 2310 rar->dictionary_size = new_size; 2311 memset(rar->lzss.window, 0, rar->dictionary_size); 2312 rar->lzss.mask = rar->dictionary_size - 1; 2313 } 2314 2315 rar->start_new_table = 0; 2316 return (ARCHIVE_OK); 2317truncated_data: 2318 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2319 "Truncated RAR file data"); 2320 rar->valid = 0; 2321 return (ARCHIVE_FATAL); 2322} 2323 2324static void 2325free_codes(struct archive_read *a) 2326{ 2327 struct rar *rar = (struct rar *)(a->format->data); 2328 free(rar->maincode.tree); 2329 free(rar->offsetcode.tree); 2330 free(rar->lowoffsetcode.tree); 2331 free(rar->lengthcode.tree); 2332 free(rar->maincode.table); 2333 free(rar->offsetcode.table); 2334 free(rar->lowoffsetcode.table); 2335 free(rar->lengthcode.table); 2336 memset(&rar->maincode, 0, sizeof(rar->maincode)); 2337 memset(&rar->offsetcode, 0, sizeof(rar->offsetcode)); 2338 memset(&rar->lowoffsetcode, 0, sizeof(rar->lowoffsetcode)); 2339 memset(&rar->lengthcode, 0, sizeof(rar->lengthcode)); 2340} 2341 2342 2343static int 2344read_next_symbol(struct archive_read *a, struct huffman_code *code) 2345{ 2346 unsigned char bit; 2347 unsigned int bits; 2348 int length, value, node; 2349 struct rar *rar; 2350 struct rar_br *br; 2351 2352 if (!code->table) 2353 { 2354 if (make_table(a, code) != (ARCHIVE_OK)) 2355 return -1; 2356 } 2357 2358 rar = (struct rar *)(a->format->data); 2359 br = &(rar->br); 2360 2361 /* Look ahead (peek) at bits */ 2362 if (!rar_br_read_ahead(a, br, code->tablesize)) { 2363 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2364 "Truncated RAR file data"); 2365 rar->valid = 0; 2366 return -1; 2367 } 2368 bits = rar_br_bits(br, code->tablesize); 2369 2370 length = code->table[bits].length; 2371 value = code->table[bits].value; 2372 2373 if (length < 0) 2374 { 2375 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2376 "Invalid prefix code in bitstream"); 2377 return -1; 2378 } 2379 2380 if (length <= code->tablesize) 2381 { 2382 /* Skip length bits */ 2383 rar_br_consume(br, length); 2384 return value; 2385 } 2386 2387 /* Skip tablesize bits */ 2388 rar_br_consume(br, code->tablesize); 2389 2390 node = value; 2391 while (!(code->tree[node].branches[0] == 2392 code->tree[node].branches[1])) 2393 { 2394 if (!rar_br_read_ahead(a, br, 1)) { 2395 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2396 "Truncated RAR file data"); 2397 rar->valid = 0; 2398 return -1; 2399 } 2400 bit = rar_br_bits(br, 1); 2401 rar_br_consume(br, 1); 2402 2403 if (code->tree[node].branches[bit] < 0) 2404 { 2405 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2406 "Invalid prefix code in bitstream"); 2407 return -1; 2408 } 2409 node = code->tree[node].branches[bit]; 2410 } 2411 2412 return code->tree[node].branches[0]; 2413} 2414 2415static int 2416create_code(struct archive_read *a, struct huffman_code *code, 2417 unsigned char *lengths, int numsymbols, char maxlength) 2418{ 2419 int i, j, codebits = 0, symbolsleft = numsymbols; 2420 2421 code->numentries = 0; 2422 code->numallocatedentries = 0; 2423 if (new_node(code) < 0) { 2424 archive_set_error(&a->archive, ENOMEM, 2425 "Unable to allocate memory for node data."); 2426 return (ARCHIVE_FATAL); 2427 } 2428 code->numentries = 1; 2429 code->minlength = INT_MAX; 2430 code->maxlength = INT_MIN; 2431 codebits = 0; 2432 for(i = 1; i <= maxlength; i++) 2433 { 2434 for(j = 0; j < numsymbols; j++) 2435 { 2436 if (lengths[j] != i) continue; 2437 if (add_value(a, code, j, codebits, i) != ARCHIVE_OK) 2438 return (ARCHIVE_FATAL); 2439 codebits++; 2440 if (--symbolsleft <= 0) { break; break; } 2441 } 2442 codebits <<= 1; 2443 } 2444 return (ARCHIVE_OK); 2445} 2446 2447static int 2448add_value(struct archive_read *a, struct huffman_code *code, int value, 2449 int codebits, int length) 2450{ 2451 int repeatpos, lastnode, bitpos, bit, repeatnode, nextnode; 2452 2453 free(code->table); 2454 code->table = NULL; 2455 2456 if(length > code->maxlength) 2457 code->maxlength = length; 2458 if(length < code->minlength) 2459 code->minlength = length; 2460 2461 repeatpos = -1; 2462 if (repeatpos == 0 || (repeatpos >= 0 2463 && (((codebits >> (repeatpos - 1)) & 3) == 0 2464 || ((codebits >> (repeatpos - 1)) & 3) == 3))) 2465 { 2466 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2467 "Invalid repeat position"); 2468 return (ARCHIVE_FATAL); 2469 } 2470 2471 lastnode = 0; 2472 for (bitpos = length - 1; bitpos >= 0; bitpos--) 2473 { 2474 bit = (codebits >> bitpos) & 1; 2475 2476 /* Leaf node check */ 2477 if (code->tree[lastnode].branches[0] == 2478 code->tree[lastnode].branches[1]) 2479 { 2480 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2481 "Prefix found"); 2482 return (ARCHIVE_FATAL); 2483 } 2484 2485 if (bitpos == repeatpos) 2486 { 2487 /* Open branch check */ 2488 if (!(code->tree[lastnode].branches[bit] < 0)) 2489 { 2490 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2491 "Invalid repeating code"); 2492 return (ARCHIVE_FATAL); 2493 } 2494 2495 if ((repeatnode = new_node(code)) < 0) { 2496 archive_set_error(&a->archive, ENOMEM, 2497 "Unable to allocate memory for node data."); 2498 return (ARCHIVE_FATAL); 2499 } 2500 if ((nextnode = new_node(code)) < 0) { 2501 archive_set_error(&a->archive, ENOMEM, 2502 "Unable to allocate memory for node data."); 2503 return (ARCHIVE_FATAL); 2504 } 2505 2506 /* Set branches */ 2507 code->tree[lastnode].branches[bit] = repeatnode; 2508 code->tree[repeatnode].branches[bit] = repeatnode; 2509 code->tree[repeatnode].branches[bit^1] = nextnode; 2510 lastnode = nextnode; 2511 2512 bitpos++; /* terminating bit already handled, skip it */ 2513 } 2514 else 2515 { 2516 /* Open branch check */ 2517 if (code->tree[lastnode].branches[bit] < 0) 2518 { 2519 if (new_node(code) < 0) { 2520 archive_set_error(&a->archive, ENOMEM, 2521 "Unable to allocate memory for node data."); 2522 return (ARCHIVE_FATAL); 2523 } 2524 code->tree[lastnode].branches[bit] = code->numentries++; 2525 } 2526 2527 /* set to branch */ 2528 lastnode = code->tree[lastnode].branches[bit]; 2529 } 2530 } 2531 2532 if (!(code->tree[lastnode].branches[0] == -1 2533 && code->tree[lastnode].branches[1] == -2)) 2534 { 2535 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2536 "Prefix found"); 2537 return (ARCHIVE_FATAL); 2538 } 2539 2540 /* Set leaf value */ 2541 code->tree[lastnode].branches[0] = value; 2542 code->tree[lastnode].branches[1] = value; 2543 2544 return (ARCHIVE_OK); 2545} 2546 2547static int 2548new_node(struct huffman_code *code) 2549{ 2550 void *new_tree; 2551 if (code->numallocatedentries == code->numentries) { 2552 int new_num_entries = 256; 2553 if (code->numentries > 0) { 2554 new_num_entries = code->numentries * 2; 2555 } 2556 new_tree = realloc(code->tree, new_num_entries * sizeof(*code->tree)); 2557 if (new_tree == NULL) 2558 return (-1); 2559 code->tree = (struct huffman_tree_node *)new_tree; 2560 code->numallocatedentries = new_num_entries; 2561 } 2562 code->tree[code->numentries].branches[0] = -1; 2563 code->tree[code->numentries].branches[1] = -2; 2564 return 1; 2565} 2566 2567static int 2568make_table(struct archive_read *a, struct huffman_code *code) 2569{ 2570 if (code->maxlength < code->minlength || code->maxlength > 10) 2571 code->tablesize = 10; 2572 else 2573 code->tablesize = code->maxlength; 2574 2575 code->table = 2576 (struct huffman_table_entry *)calloc(1, sizeof(*code->table) 2577 * ((size_t)1 << code->tablesize)); 2578 2579 return make_table_recurse(a, code, 0, code->table, 0, code->tablesize); 2580} 2581 2582static int 2583make_table_recurse(struct archive_read *a, struct huffman_code *code, int node, 2584 struct huffman_table_entry *table, int depth, 2585 int maxdepth) 2586{ 2587 int currtablesize, i, ret = (ARCHIVE_OK); 2588 2589 if (!code->tree) 2590 { 2591 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2592 "Huffman tree was not created."); 2593 return (ARCHIVE_FATAL); 2594 } 2595 if (node < 0 || node >= code->numentries) 2596 { 2597 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2598 "Invalid location to Huffman tree specified."); 2599 return (ARCHIVE_FATAL); 2600 } 2601 2602 currtablesize = 1 << (maxdepth - depth); 2603 2604 if (code->tree[node].branches[0] == 2605 code->tree[node].branches[1]) 2606 { 2607 for(i = 0; i < currtablesize; i++) 2608 { 2609 table[i].length = depth; 2610 table[i].value = code->tree[node].branches[0]; 2611 } 2612 } 2613 else if (node < 0) 2614 { 2615 for(i = 0; i < currtablesize; i++) 2616 table[i].length = -1; 2617 } 2618 else 2619 { 2620 if(depth == maxdepth) 2621 { 2622 table[0].length = maxdepth + 1; 2623 table[0].value = node; 2624 } 2625 else 2626 { 2627 ret |= make_table_recurse(a, code, code->tree[node].branches[0], table, 2628 depth + 1, maxdepth); 2629 ret |= make_table_recurse(a, code, code->tree[node].branches[1], 2630 table + currtablesize / 2, depth + 1, maxdepth); 2631 } 2632 } 2633 return ret; 2634} 2635 2636static int64_t 2637expand(struct archive_read *a, int64_t end) 2638{ 2639 static const unsigned char lengthbases[] = 2640 { 0, 1, 2, 3, 4, 5, 6, 2641 7, 8, 10, 12, 14, 16, 20, 2642 24, 28, 32, 40, 48, 56, 64, 2643 80, 96, 112, 128, 160, 192, 224 }; 2644 static const unsigned char lengthbits[] = 2645 { 0, 0, 0, 0, 0, 0, 0, 2646 0, 1, 1, 1, 1, 2, 2, 2647 2, 2, 3, 3, 3, 3, 4, 2648 4, 4, 4, 5, 5, 5, 5 }; 2649 static const unsigned int offsetbases[] = 2650 { 0, 1, 2, 3, 4, 6, 2651 8, 12, 16, 24, 32, 48, 2652 64, 96, 128, 192, 256, 384, 2653 512, 768, 1024, 1536, 2048, 3072, 2654 4096, 6144, 8192, 12288, 16384, 24576, 2655 32768, 49152, 65536, 98304, 131072, 196608, 2656 262144, 327680, 393216, 458752, 524288, 589824, 2657 655360, 720896, 786432, 851968, 917504, 983040, 2658 1048576, 1310720, 1572864, 1835008, 2097152, 2359296, 2659 2621440, 2883584, 3145728, 3407872, 3670016, 3932160 }; 2660 static const unsigned char offsetbits[] = 2661 { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 2662 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 2663 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 2664 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 2665 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 }; 2666 static const unsigned char shortbases[] = 2667 { 0, 4, 8, 16, 32, 64, 128, 192 }; 2668 static const unsigned char shortbits[] = 2669 { 2, 2, 3, 4, 5, 6, 6, 6 }; 2670 2671 int symbol, offs, len, offsindex, lensymbol, i, offssymbol, lowoffsetsymbol; 2672 unsigned char newfile; 2673 struct rar *rar = (struct rar *)(a->format->data); 2674 struct rar_br *br = &(rar->br); 2675 2676 if (rar->filterstart < end) 2677 end = rar->filterstart; 2678 2679 while (1) 2680 { 2681 if (rar->output_last_match && 2682 lzss_position(&rar->lzss) + rar->lastlength <= end) 2683 { 2684 lzss_emit_match(rar, rar->lastoffset, rar->lastlength); 2685 rar->output_last_match = 0; 2686 } 2687 2688 if(rar->is_ppmd_block || rar->output_last_match || 2689 lzss_position(&rar->lzss) >= end) 2690 return lzss_position(&rar->lzss); 2691 2692 if ((symbol = read_next_symbol(a, &rar->maincode)) < 0) 2693 return (ARCHIVE_FATAL); 2694 rar->output_last_match = 0; 2695 2696 if (symbol < 256) 2697 { 2698 lzss_emit_literal(rar, symbol); 2699 continue; 2700 } 2701 else if (symbol == 256) 2702 { 2703 if (!rar_br_read_ahead(a, br, 1)) 2704 goto truncated_data; 2705 newfile = !rar_br_bits(br, 1); 2706 rar_br_consume(br, 1); 2707 2708 if(newfile) 2709 { 2710 rar->start_new_block = 1; 2711 if (!rar_br_read_ahead(a, br, 1)) 2712 goto truncated_data; 2713 rar->start_new_table = rar_br_bits(br, 1); 2714 rar_br_consume(br, 1); 2715 return lzss_position(&rar->lzss); 2716 } 2717 else 2718 { 2719 if (parse_codes(a) != ARCHIVE_OK) 2720 return (ARCHIVE_FATAL); 2721 continue; 2722 } 2723 } 2724 else if(symbol==257) 2725 { 2726 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 2727 "Parsing filters is unsupported."); 2728 return (ARCHIVE_FAILED); 2729 } 2730 else if(symbol==258) 2731 { 2732 if(rar->lastlength == 0) 2733 continue; 2734 2735 offs = rar->lastoffset; 2736 len = rar->lastlength; 2737 } 2738 else if (symbol <= 262) 2739 { 2740 offsindex = symbol - 259; 2741 offs = rar->oldoffset[offsindex]; 2742 2743 if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0) 2744 goto bad_data; 2745 if (lensymbol > (int)(sizeof(lengthbases)/sizeof(lengthbases[0]))) 2746 goto bad_data; 2747 if (lensymbol > (int)(sizeof(lengthbits)/sizeof(lengthbits[0]))) 2748 goto bad_data; 2749 len = lengthbases[lensymbol] + 2; 2750 if (lengthbits[lensymbol] > 0) { 2751 if (!rar_br_read_ahead(a, br, lengthbits[lensymbol])) 2752 goto truncated_data; 2753 len += rar_br_bits(br, lengthbits[lensymbol]); 2754 rar_br_consume(br, lengthbits[lensymbol]); 2755 } 2756 2757 for (i = offsindex; i > 0; i--) 2758 rar->oldoffset[i] = rar->oldoffset[i-1]; 2759 rar->oldoffset[0] = offs; 2760 } 2761 else if(symbol<=270) 2762 { 2763 offs = shortbases[symbol-263] + 1; 2764 if(shortbits[symbol-263] > 0) { 2765 if (!rar_br_read_ahead(a, br, shortbits[symbol-263])) 2766 goto truncated_data; 2767 offs += rar_br_bits(br, shortbits[symbol-263]); 2768 rar_br_consume(br, shortbits[symbol-263]); 2769 } 2770 2771 len = 2; 2772 2773 for(i = 3; i > 0; i--) 2774 rar->oldoffset[i] = rar->oldoffset[i-1]; 2775 rar->oldoffset[0] = offs; 2776 } 2777 else 2778 { 2779 if (symbol-271 > (int)(sizeof(lengthbases)/sizeof(lengthbases[0]))) 2780 goto bad_data; 2781 if (symbol-271 > (int)(sizeof(lengthbits)/sizeof(lengthbits[0]))) 2782 goto bad_data; 2783 len = lengthbases[symbol-271]+3; 2784 if(lengthbits[symbol-271] > 0) { 2785 if (!rar_br_read_ahead(a, br, lengthbits[symbol-271])) 2786 goto truncated_data; 2787 len += rar_br_bits(br, lengthbits[symbol-271]); 2788 rar_br_consume(br, lengthbits[symbol-271]); 2789 } 2790 2791 if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0) 2792 goto bad_data; 2793 if (offssymbol > (int)(sizeof(offsetbases)/sizeof(offsetbases[0]))) 2794 goto bad_data; 2795 if (offssymbol > (int)(sizeof(offsetbits)/sizeof(offsetbits[0]))) 2796 goto bad_data; 2797 offs = offsetbases[offssymbol]+1; 2798 if(offsetbits[offssymbol] > 0) 2799 { 2800 if(offssymbol > 9) 2801 { 2802 if(offsetbits[offssymbol] > 4) { 2803 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol] - 4)) 2804 goto truncated_data; 2805 offs += rar_br_bits(br, offsetbits[offssymbol] - 4) << 4; 2806 rar_br_consume(br, offsetbits[offssymbol] - 4); 2807 } 2808 2809 if(rar->numlowoffsetrepeats > 0) 2810 { 2811 rar->numlowoffsetrepeats--; 2812 offs += rar->lastlowoffset; 2813 } 2814 else 2815 { 2816 if ((lowoffsetsymbol = 2817 read_next_symbol(a, &rar->lowoffsetcode)) < 0) 2818 return (ARCHIVE_FATAL); 2819 if(lowoffsetsymbol == 16) 2820 { 2821 rar->numlowoffsetrepeats = 15; 2822 offs += rar->lastlowoffset; 2823 } 2824 else 2825 { 2826 offs += lowoffsetsymbol; 2827 rar->lastlowoffset = lowoffsetsymbol; 2828 } 2829 } 2830 } 2831 else { 2832 if (!rar_br_read_ahead(a, br, offsetbits[offssymbol])) 2833 goto truncated_data; 2834 offs += rar_br_bits(br, offsetbits[offssymbol]); 2835 rar_br_consume(br, offsetbits[offssymbol]); 2836 } 2837 } 2838 2839 if (offs >= 0x40000) 2840 len++; 2841 if (offs >= 0x2000) 2842 len++; 2843 2844 for(i = 3; i > 0; i--) 2845 rar->oldoffset[i] = rar->oldoffset[i-1]; 2846 rar->oldoffset[0] = offs; 2847 } 2848 2849 rar->lastoffset = offs; 2850 rar->lastlength = len; 2851 rar->output_last_match = 1; 2852 } 2853truncated_data: 2854 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2855 "Truncated RAR file data"); 2856 rar->valid = 0; 2857 return (ARCHIVE_FATAL); 2858bad_data: 2859 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2860 "Bad RAR file data"); 2861 return (ARCHIVE_FATAL); 2862} 2863 2864static int 2865copy_from_lzss_window(struct archive_read *a, const void **buffer, 2866 int64_t startpos, int length) 2867{ 2868 int windowoffs, firstpart; 2869 struct rar *rar = (struct rar *)(a->format->data); 2870 2871 if (!rar->unp_buffer) 2872 { 2873 if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL) 2874 { 2875 archive_set_error(&a->archive, ENOMEM, 2876 "Unable to allocate memory for uncompressed data."); 2877 return (ARCHIVE_FATAL); 2878 } 2879 } 2880 2881 windowoffs = lzss_offset_for_position(&rar->lzss, startpos); 2882 if(windowoffs + length <= lzss_size(&rar->lzss)) { 2883 memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs], 2884 length); 2885 } else if (length <= lzss_size(&rar->lzss)) { 2886 firstpart = lzss_size(&rar->lzss) - windowoffs; 2887 if (firstpart < 0) { 2888 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2889 "Bad RAR file data"); 2890 return (ARCHIVE_FATAL); 2891 } 2892 if (firstpart < length) { 2893 memcpy(&rar->unp_buffer[rar->unp_offset], 2894 &rar->lzss.window[windowoffs], firstpart); 2895 memcpy(&rar->unp_buffer[rar->unp_offset + firstpart], 2896 &rar->lzss.window[0], length - firstpart); 2897 } else { 2898 memcpy(&rar->unp_buffer[rar->unp_offset], 2899 &rar->lzss.window[windowoffs], length); 2900 } 2901 } else { 2902 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2903 "Bad RAR file data"); 2904 return (ARCHIVE_FATAL); 2905 } 2906 rar->unp_offset += length; 2907 if (rar->unp_offset >= rar->unp_buffer_size) 2908 *buffer = rar->unp_buffer; 2909 else 2910 *buffer = NULL; 2911 return (ARCHIVE_OK); 2912} 2913 2914static const void * 2915rar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail) 2916{ 2917 struct rar *rar = (struct rar *)(a->format->data); 2918 const void *h = __archive_read_ahead(a, min, avail); 2919 int ret; 2920 if (avail) 2921 { 2922 if (a->archive.read_data_is_posix_read && *avail > (ssize_t)a->archive.read_data_requested) 2923 *avail = a->archive.read_data_requested; 2924 if (*avail > rar->bytes_remaining) 2925 *avail = (ssize_t)rar->bytes_remaining; 2926 if (*avail < 0) 2927 return NULL; 2928 else if (*avail == 0 && rar->main_flags & MHD_VOLUME && 2929 rar->file_flags & FHD_SPLIT_AFTER) 2930 { 2931 ret = archive_read_format_rar_read_header(a, a->entry); 2932 if (ret == (ARCHIVE_EOF)) 2933 { 2934 rar->has_endarc_header = 1; 2935 ret = archive_read_format_rar_read_header(a, a->entry); 2936 } 2937 if (ret != (ARCHIVE_OK)) 2938 return NULL; 2939 return rar_read_ahead(a, min, avail); 2940 } 2941 } 2942 return h; 2943} 2944