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