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