archive_read_support_format_rar.c revision 299529
1231200Smm/*- 2231200Smm* Copyright (c) 2003-2007 Tim Kientzle 3231200Smm* Copyright (c) 2011 Andres Mejia 4231200Smm* All rights reserved. 5231200Smm* 6231200Smm* Redistribution and use in source and binary forms, with or without 7231200Smm* modification, are permitted provided that the following conditions 8231200Smm* are met: 9231200Smm* 1. Redistributions of source code must retain the above copyright 10231200Smm* notice, this list of conditions and the following disclaimer. 11231200Smm* 2. Redistributions in binary form must reproduce the above copyright 12231200Smm* notice, this list of conditions and the following disclaimer in the 13231200Smm* documentation and/or other materials provided with the distribution. 14231200Smm* 15231200Smm* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 16231200Smm* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17231200Smm* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18231200Smm* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 19231200Smm* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20231200Smm* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21231200Smm* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22231200Smm* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23231200Smm* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24231200Smm* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25231200Smm*/ 26231200Smm 27231200Smm#include "archive_platform.h" 28231200Smm 29231200Smm#ifdef HAVE_ERRNO_H 30231200Smm#include <errno.h> 31231200Smm#endif 32231200Smm#include <time.h> 33231200Smm#include <limits.h> 34231200Smm#ifdef HAVE_ZLIB_H 35231200Smm#include <zlib.h> /* crc32 */ 36231200Smm#endif 37231200Smm 38231200Smm#include "archive.h" 39231200Smm#ifndef HAVE_ZLIB_H 40231200Smm#include "archive_crc32.h" 41231200Smm#endif 42231200Smm#include "archive_endian.h" 43231200Smm#include "archive_entry.h" 44231200Smm#include "archive_entry_locale.h" 45231200Smm#include "archive_ppmd7_private.h" 46231200Smm#include "archive_private.h" 47231200Smm#include "archive_read_private.h" 48231200Smm 49231200Smm/* RAR signature, also known as the mark header */ 50231200Smm#define RAR_SIGNATURE "\x52\x61\x72\x21\x1A\x07\x00" 51231200Smm 52231200Smm/* Header types */ 53231200Smm#define MARK_HEAD 0x72 54231200Smm#define MAIN_HEAD 0x73 55231200Smm#define FILE_HEAD 0x74 56231200Smm#define COMM_HEAD 0x75 57231200Smm#define AV_HEAD 0x76 58231200Smm#define SUB_HEAD 0x77 59231200Smm#define PROTECT_HEAD 0x78 60231200Smm#define SIGN_HEAD 0x79 61231200Smm#define NEWSUB_HEAD 0x7a 62231200Smm#define ENDARC_HEAD 0x7b 63231200Smm 64231200Smm/* Main Header Flags */ 65231200Smm#define MHD_VOLUME 0x0001 66231200Smm#define MHD_COMMENT 0x0002 67231200Smm#define MHD_LOCK 0x0004 68231200Smm#define MHD_SOLID 0x0008 69231200Smm#define MHD_NEWNUMBERING 0x0010 70231200Smm#define MHD_AV 0x0020 71231200Smm#define MHD_PROTECT 0x0040 72231200Smm#define MHD_PASSWORD 0x0080 73231200Smm#define MHD_FIRSTVOLUME 0x0100 74231200Smm#define MHD_ENCRYPTVER 0x0200 75231200Smm 76231200Smm/* Flags common to all headers */ 77231200Smm#define HD_MARKDELETION 0x4000 78231200Smm#define HD_ADD_SIZE_PRESENT 0x8000 79231200Smm 80231200Smm/* File Header Flags */ 81231200Smm#define FHD_SPLIT_BEFORE 0x0001 82231200Smm#define FHD_SPLIT_AFTER 0x0002 83231200Smm#define FHD_PASSWORD 0x0004 84231200Smm#define FHD_COMMENT 0x0008 85231200Smm#define FHD_SOLID 0x0010 86231200Smm#define FHD_LARGE 0x0100 87231200Smm#define FHD_UNICODE 0x0200 88231200Smm#define FHD_SALT 0x0400 89231200Smm#define FHD_VERSION 0x0800 90231200Smm#define FHD_EXTTIME 0x1000 91231200Smm#define FHD_EXTFLAGS 0x2000 92231200Smm 93231200Smm/* File dictionary sizes */ 94231200Smm#define DICTIONARY_SIZE_64 0x00 95231200Smm#define DICTIONARY_SIZE_128 0x20 96231200Smm#define DICTIONARY_SIZE_256 0x40 97231200Smm#define DICTIONARY_SIZE_512 0x60 98231200Smm#define DICTIONARY_SIZE_1024 0x80 99231200Smm#define DICTIONARY_SIZE_2048 0xA0 100231200Smm#define DICTIONARY_SIZE_4096 0xC0 101231200Smm#define FILE_IS_DIRECTORY 0xE0 102231200Smm#define DICTIONARY_MASK FILE_IS_DIRECTORY 103231200Smm 104231200Smm/* OS Flags */ 105231200Smm#define OS_MSDOS 0 106231200Smm#define OS_OS2 1 107231200Smm#define OS_WIN32 2 108231200Smm#define OS_UNIX 3 109231200Smm#define OS_MAC_OS 4 110231200Smm#define OS_BEOS 5 111231200Smm 112231200Smm/* Compression Methods */ 113231200Smm#define COMPRESS_METHOD_STORE 0x30 114231200Smm/* LZSS */ 115231200Smm#define COMPRESS_METHOD_FASTEST 0x31 116231200Smm#define COMPRESS_METHOD_FAST 0x32 117231200Smm#define COMPRESS_METHOD_NORMAL 0x33 118231200Smm/* PPMd Variant H */ 119231200Smm#define COMPRESS_METHOD_GOOD 0x34 120231200Smm#define COMPRESS_METHOD_BEST 0x35 121231200Smm 122231200Smm#define CRC_POLYNOMIAL 0xEDB88320 123231200Smm 124231200Smm#define NS_UNIT 10000000 125231200Smm 126231200Smm#define DICTIONARY_MAX_SIZE 0x400000 127231200Smm 128231200Smm#define MAINCODE_SIZE 299 129231200Smm#define OFFSETCODE_SIZE 60 130231200Smm#define LOWOFFSETCODE_SIZE 17 131231200Smm#define LENGTHCODE_SIZE 28 132231200Smm#define HUFFMAN_TABLE_SIZE \ 133231200Smm MAINCODE_SIZE + OFFSETCODE_SIZE + LOWOFFSETCODE_SIZE + LENGTHCODE_SIZE 134231200Smm 135231200Smm#define MAX_SYMBOL_LENGTH 0xF 136231200Smm#define MAX_SYMBOLS 20 137231200Smm 138231200Smm/* 139231200Smm * Considering L1,L2 cache miss and a calling of write system-call, 140231200Smm * the best size of the output buffer(uncompressed buffer) is 128K. 141231200Smm * If the structure of extracting process is changed, this value 142231200Smm * might be researched again. 143231200Smm */ 144231200Smm#define UNP_BUFFER_SIZE (128 * 1024) 145231200Smm 146231200Smm/* Define this here for non-Windows platforms */ 147231200Smm#if !((defined(__WIN32__) || defined(_WIN32) || defined(__WIN32)) && !defined(__CYGWIN__)) 148231200Smm#define FILE_ATTRIBUTE_DIRECTORY 0x10 149231200Smm#endif 150231200Smm 151231200Smm/* Fields common to all headers */ 152231200Smmstruct rar_header 153231200Smm{ 154231200Smm char crc[2]; 155231200Smm char type; 156231200Smm char flags[2]; 157231200Smm char size[2]; 158231200Smm}; 159231200Smm 160231200Smm/* Fields common to all file headers */ 161231200Smmstruct rar_file_header 162231200Smm{ 163231200Smm char pack_size[4]; 164231200Smm char unp_size[4]; 165231200Smm char host_os; 166231200Smm char file_crc[4]; 167231200Smm char file_time[4]; 168231200Smm char unp_ver; 169231200Smm char method; 170231200Smm char name_size[2]; 171231200Smm char file_attr[4]; 172231200Smm}; 173231200Smm 174231200Smmstruct huffman_tree_node 175231200Smm{ 176231200Smm int branches[2]; 177231200Smm}; 178231200Smm 179231200Smmstruct huffman_table_entry 180231200Smm{ 181231200Smm unsigned int length; 182231200Smm int value; 183231200Smm}; 184231200Smm 185231200Smmstruct huffman_code 186231200Smm{ 187231200Smm struct huffman_tree_node *tree; 188231200Smm int numentries; 189299529Smm int numallocatedentries; 190231200Smm int minlength; 191231200Smm int maxlength; 192231200Smm int tablesize; 193231200Smm struct huffman_table_entry *table; 194231200Smm}; 195231200Smm 196231200Smmstruct lzss 197231200Smm{ 198231200Smm unsigned char *window; 199231200Smm int mask; 200231200Smm int64_t position; 201231200Smm}; 202231200Smm 203248616Smmstruct data_block_offsets 204248616Smm{ 205248616Smm int64_t header_size; 206248616Smm int64_t start_offset; 207248616Smm int64_t end_offset; 208248616Smm}; 209248616Smm 210231200Smmstruct rar 211231200Smm{ 212231200Smm /* Entries from main RAR header */ 213231200Smm unsigned main_flags; 214231200Smm unsigned long file_crc; 215231200Smm char reserved1[2]; 216231200Smm char reserved2[4]; 217231200Smm char encryptver; 218231200Smm 219231200Smm /* File header entries */ 220231200Smm char compression_method; 221231200Smm unsigned file_flags; 222231200Smm int64_t packed_size; 223231200Smm int64_t unp_size; 224231200Smm time_t mtime; 225231200Smm long mnsec; 226231200Smm mode_t mode; 227231200Smm char *filename; 228248616Smm char *filename_save; 229299529Smm size_t filename_save_size; 230231200Smm size_t filename_allocated; 231231200Smm 232231200Smm /* File header optional entries */ 233231200Smm char salt[8]; 234231200Smm time_t atime; 235231200Smm long ansec; 236231200Smm time_t ctime; 237231200Smm long cnsec; 238231200Smm time_t arctime; 239231200Smm long arcnsec; 240231200Smm 241231200Smm /* Fields to help with tracking decompression of files. */ 242231200Smm int64_t bytes_unconsumed; 243231200Smm int64_t bytes_remaining; 244231200Smm int64_t bytes_uncopied; 245231200Smm int64_t offset; 246231200Smm int64_t offset_outgoing; 247248616Smm int64_t offset_seek; 248231200Smm char valid; 249231200Smm unsigned int unp_offset; 250231200Smm unsigned int unp_buffer_size; 251231200Smm unsigned char *unp_buffer; 252231200Smm unsigned int dictionary_size; 253231200Smm char start_new_block; 254231200Smm char entry_eof; 255231200Smm unsigned long crc_calculated; 256231200Smm int found_first_header; 257248616Smm char has_endarc_header; 258248616Smm struct data_block_offsets *dbo; 259248616Smm unsigned int cursor; 260248616Smm unsigned int nodes; 261231200Smm 262231200Smm /* LZSS members */ 263231200Smm struct huffman_code maincode; 264231200Smm struct huffman_code offsetcode; 265231200Smm struct huffman_code lowoffsetcode; 266231200Smm struct huffman_code lengthcode; 267231200Smm unsigned char lengthtable[HUFFMAN_TABLE_SIZE]; 268231200Smm struct lzss lzss; 269231200Smm char output_last_match; 270231200Smm unsigned int lastlength; 271231200Smm unsigned int lastoffset; 272231200Smm unsigned int oldoffset[4]; 273231200Smm unsigned int lastlowoffset; 274231200Smm unsigned int numlowoffsetrepeats; 275231200Smm int64_t filterstart; 276231200Smm char start_new_table; 277231200Smm 278231200Smm /* PPMd Variant H members */ 279231200Smm char ppmd_valid; 280231200Smm char ppmd_eod; 281231200Smm char is_ppmd_block; 282231200Smm int ppmd_escape; 283231200Smm CPpmd7 ppmd7_context; 284231200Smm CPpmd7z_RangeDec range_dec; 285231200Smm IByteIn bytein; 286231200Smm 287231200Smm /* 288231200Smm * String conversion object. 289231200Smm */ 290231200Smm int init_default_conversion; 291231200Smm struct archive_string_conv *sconv_default; 292231200Smm struct archive_string_conv *opt_sconv; 293231200Smm struct archive_string_conv *sconv_utf8; 294231200Smm struct archive_string_conv *sconv_utf16be; 295231200Smm 296231200Smm /* 297231200Smm * Bit stream reader. 298231200Smm */ 299231200Smm struct rar_br { 300231200Smm#define CACHE_TYPE uint64_t 301231200Smm#define CACHE_BITS (8 * sizeof(CACHE_TYPE)) 302231200Smm /* Cache buffer. */ 303231200Smm CACHE_TYPE cache_buffer; 304231200Smm /* Indicates how many bits avail in cache_buffer. */ 305231200Smm int cache_avail; 306231200Smm ssize_t avail_in; 307231200Smm const unsigned char *next_in; 308231200Smm } br; 309299529Smm 310299529Smm /* 311299529Smm * Custom field to denote that this archive contains encrypted entries 312299529Smm */ 313299529Smm int has_encrypted_entries; 314231200Smm}; 315231200Smm 316299529Smmstatic int archive_read_support_format_rar_capabilities(struct archive_read *); 317299529Smmstatic int archive_read_format_rar_has_encrypted_entries(struct archive_read *); 318231200Smmstatic int archive_read_format_rar_bid(struct archive_read *, int); 319231200Smmstatic int archive_read_format_rar_options(struct archive_read *, 320231200Smm const char *, const char *); 321231200Smmstatic int archive_read_format_rar_read_header(struct archive_read *, 322231200Smm struct archive_entry *); 323231200Smmstatic int archive_read_format_rar_read_data(struct archive_read *, 324231200Smm const void **, size_t *, int64_t *); 325231200Smmstatic int archive_read_format_rar_read_data_skip(struct archive_read *a); 326248616Smmstatic int64_t archive_read_format_rar_seek_data(struct archive_read *, int64_t, 327248616Smm int); 328231200Smmstatic int archive_read_format_rar_cleanup(struct archive_read *); 329231200Smm 330231200Smm/* Support functions */ 331231200Smmstatic int read_header(struct archive_read *, struct archive_entry *, char); 332232153Smmstatic time_t get_time(int); 333231200Smmstatic int read_exttime(const char *, struct rar *, const char *); 334231200Smmstatic int read_symlink_stored(struct archive_read *, struct archive_entry *, 335231200Smm struct archive_string_conv *); 336231200Smmstatic int read_data_stored(struct archive_read *, const void **, size_t *, 337231200Smm int64_t *); 338231200Smmstatic int read_data_compressed(struct archive_read *, const void **, size_t *, 339231200Smm int64_t *); 340231200Smmstatic int rar_br_preparation(struct archive_read *, struct rar_br *); 341231200Smmstatic int parse_codes(struct archive_read *); 342231200Smmstatic void free_codes(struct archive_read *); 343231200Smmstatic int read_next_symbol(struct archive_read *, struct huffman_code *); 344231200Smmstatic int create_code(struct archive_read *, struct huffman_code *, 345231200Smm unsigned char *, int, char); 346231200Smmstatic int add_value(struct archive_read *, struct huffman_code *, int, int, 347231200Smm int); 348231200Smmstatic int new_node(struct huffman_code *); 349231200Smmstatic int make_table(struct archive_read *, struct huffman_code *); 350231200Smmstatic int make_table_recurse(struct archive_read *, struct huffman_code *, int, 351231200Smm struct huffman_table_entry *, int, int); 352231200Smmstatic int64_t expand(struct archive_read *, int64_t); 353231200Smmstatic int copy_from_lzss_window(struct archive_read *, const void **, 354231200Smm int64_t, int); 355248616Smmstatic const void *rar_read_ahead(struct archive_read *, size_t, ssize_t *); 356231200Smm 357231200Smm/* 358231200Smm * Bit stream reader. 359231200Smm */ 360231200Smm/* Check that the cache buffer has enough bits. */ 361231200Smm#define rar_br_has(br, n) ((br)->cache_avail >= n) 362231200Smm/* Get compressed data by bit. */ 363231200Smm#define rar_br_bits(br, n) \ 364231200Smm (((uint32_t)((br)->cache_buffer >> \ 365231200Smm ((br)->cache_avail - (n)))) & cache_masks[n]) 366231200Smm#define rar_br_bits_forced(br, n) \ 367231200Smm (((uint32_t)((br)->cache_buffer << \ 368231200Smm ((n) - (br)->cache_avail))) & cache_masks[n]) 369231200Smm/* Read ahead to make sure the cache buffer has enough compressed data we 370231200Smm * will use. 371231200Smm * True : completed, there is enough data in the cache buffer. 372231200Smm * False : there is no data in the stream. */ 373231200Smm#define rar_br_read_ahead(a, br, n) \ 374231200Smm ((rar_br_has(br, (n)) || rar_br_fillup(a, br)) || rar_br_has(br, (n))) 375231200Smm/* Notify how many bits we consumed. */ 376231200Smm#define rar_br_consume(br, n) ((br)->cache_avail -= (n)) 377231200Smm#define rar_br_consume_unalined_bits(br) ((br)->cache_avail &= ~7) 378231200Smm 379231200Smmstatic const uint32_t cache_masks[] = { 380231200Smm 0x00000000, 0x00000001, 0x00000003, 0x00000007, 381231200Smm 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F, 382231200Smm 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF, 383231200Smm 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 384231200Smm 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 385231200Smm 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 386231200Smm 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 387231200Smm 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 388231200Smm 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF 389231200Smm}; 390231200Smm 391231200Smm/* 392231200Smm * Shift away used bits in the cache data and fill it up with following bits. 393231200Smm * Call this when cache buffer does not have enough bits you need. 394231200Smm * 395231200Smm * Returns 1 if the cache buffer is full. 396231200Smm * Returns 0 if the cache buffer is not full; input buffer is empty. 397231200Smm */ 398231200Smmstatic int 399231200Smmrar_br_fillup(struct archive_read *a, struct rar_br *br) 400231200Smm{ 401231200Smm struct rar *rar = (struct rar *)(a->format->data); 402231200Smm int n = CACHE_BITS - br->cache_avail; 403231200Smm 404231200Smm for (;;) { 405231200Smm switch (n >> 3) { 406231200Smm case 8: 407231200Smm if (br->avail_in >= 8) { 408231200Smm br->cache_buffer = 409231200Smm ((uint64_t)br->next_in[0]) << 56 | 410231200Smm ((uint64_t)br->next_in[1]) << 48 | 411231200Smm ((uint64_t)br->next_in[2]) << 40 | 412231200Smm ((uint64_t)br->next_in[3]) << 32 | 413231200Smm ((uint32_t)br->next_in[4]) << 24 | 414231200Smm ((uint32_t)br->next_in[5]) << 16 | 415231200Smm ((uint32_t)br->next_in[6]) << 8 | 416231200Smm (uint32_t)br->next_in[7]; 417231200Smm br->next_in += 8; 418231200Smm br->avail_in -= 8; 419231200Smm br->cache_avail += 8 * 8; 420231200Smm rar->bytes_unconsumed += 8; 421231200Smm rar->bytes_remaining -= 8; 422231200Smm return (1); 423231200Smm } 424231200Smm break; 425231200Smm case 7: 426231200Smm if (br->avail_in >= 7) { 427231200Smm br->cache_buffer = 428231200Smm (br->cache_buffer << 56) | 429231200Smm ((uint64_t)br->next_in[0]) << 48 | 430231200Smm ((uint64_t)br->next_in[1]) << 40 | 431231200Smm ((uint64_t)br->next_in[2]) << 32 | 432231200Smm ((uint32_t)br->next_in[3]) << 24 | 433231200Smm ((uint32_t)br->next_in[4]) << 16 | 434231200Smm ((uint32_t)br->next_in[5]) << 8 | 435231200Smm (uint32_t)br->next_in[6]; 436231200Smm br->next_in += 7; 437231200Smm br->avail_in -= 7; 438231200Smm br->cache_avail += 7 * 8; 439231200Smm rar->bytes_unconsumed += 7; 440231200Smm rar->bytes_remaining -= 7; 441231200Smm return (1); 442231200Smm } 443231200Smm break; 444231200Smm case 6: 445231200Smm if (br->avail_in >= 6) { 446231200Smm br->cache_buffer = 447231200Smm (br->cache_buffer << 48) | 448231200Smm ((uint64_t)br->next_in[0]) << 40 | 449231200Smm ((uint64_t)br->next_in[1]) << 32 | 450231200Smm ((uint32_t)br->next_in[2]) << 24 | 451231200Smm ((uint32_t)br->next_in[3]) << 16 | 452231200Smm ((uint32_t)br->next_in[4]) << 8 | 453231200Smm (uint32_t)br->next_in[5]; 454231200Smm br->next_in += 6; 455231200Smm br->avail_in -= 6; 456231200Smm br->cache_avail += 6 * 8; 457231200Smm rar->bytes_unconsumed += 6; 458231200Smm rar->bytes_remaining -= 6; 459231200Smm return (1); 460231200Smm } 461231200Smm break; 462231200Smm case 0: 463231200Smm /* We have enough compressed data in 464231200Smm * the cache buffer.*/ 465231200Smm return (1); 466231200Smm default: 467231200Smm break; 468231200Smm } 469231200Smm if (br->avail_in <= 0) { 470231200Smm 471231200Smm if (rar->bytes_unconsumed > 0) { 472231200Smm /* Consume as much as the decompressor 473231200Smm * actually used. */ 474231200Smm __archive_read_consume(a, rar->bytes_unconsumed); 475231200Smm rar->bytes_unconsumed = 0; 476231200Smm } 477248616Smm br->next_in = rar_read_ahead(a, 1, &(br->avail_in)); 478231200Smm if (br->next_in == NULL) 479231200Smm return (0); 480231200Smm if (br->avail_in == 0) 481231200Smm return (0); 482231200Smm } 483231200Smm br->cache_buffer = 484231200Smm (br->cache_buffer << 8) | *br->next_in++; 485231200Smm br->avail_in--; 486231200Smm br->cache_avail += 8; 487231200Smm n -= 8; 488231200Smm rar->bytes_unconsumed++; 489231200Smm rar->bytes_remaining--; 490231200Smm } 491231200Smm} 492231200Smm 493231200Smmstatic int 494231200Smmrar_br_preparation(struct archive_read *a, struct rar_br *br) 495231200Smm{ 496231200Smm struct rar *rar = (struct rar *)(a->format->data); 497231200Smm 498231200Smm if (rar->bytes_remaining > 0) { 499248616Smm br->next_in = rar_read_ahead(a, 1, &(br->avail_in)); 500231200Smm if (br->next_in == NULL) { 501231200Smm archive_set_error(&a->archive, 502231200Smm ARCHIVE_ERRNO_FILE_FORMAT, 503231200Smm "Truncated RAR file data"); 504231200Smm return (ARCHIVE_FATAL); 505231200Smm } 506231200Smm if (br->cache_avail == 0) 507231200Smm (void)rar_br_fillup(a, br); 508231200Smm } 509231200Smm return (ARCHIVE_OK); 510231200Smm} 511231200Smm 512231200Smm/* Find last bit set */ 513231200Smmstatic inline int 514231200Smmrar_fls(unsigned int word) 515231200Smm{ 516231200Smm word |= (word >> 1); 517231200Smm word |= (word >> 2); 518231200Smm word |= (word >> 4); 519231200Smm word |= (word >> 8); 520231200Smm word |= (word >> 16); 521231200Smm return word - (word >> 1); 522231200Smm} 523231200Smm 524231200Smm/* LZSS functions */ 525231200Smmstatic inline int64_t 526231200Smmlzss_position(struct lzss *lzss) 527231200Smm{ 528231200Smm return lzss->position; 529231200Smm} 530231200Smm 531231200Smmstatic inline int 532231200Smmlzss_mask(struct lzss *lzss) 533231200Smm{ 534231200Smm return lzss->mask; 535231200Smm} 536231200Smm 537231200Smmstatic inline int 538231200Smmlzss_size(struct lzss *lzss) 539231200Smm{ 540231200Smm return lzss->mask + 1; 541231200Smm} 542231200Smm 543231200Smmstatic inline int 544231200Smmlzss_offset_for_position(struct lzss *lzss, int64_t pos) 545231200Smm{ 546238856Smm return (int)(pos & lzss->mask); 547231200Smm} 548231200Smm 549231200Smmstatic inline unsigned char * 550231200Smmlzss_pointer_for_position(struct lzss *lzss, int64_t pos) 551231200Smm{ 552231200Smm return &lzss->window[lzss_offset_for_position(lzss, pos)]; 553231200Smm} 554231200Smm 555231200Smmstatic inline int 556231200Smmlzss_current_offset(struct lzss *lzss) 557231200Smm{ 558231200Smm return lzss_offset_for_position(lzss, lzss->position); 559231200Smm} 560231200Smm 561231200Smmstatic inline uint8_t * 562231200Smmlzss_current_pointer(struct lzss *lzss) 563231200Smm{ 564231200Smm return lzss_pointer_for_position(lzss, lzss->position); 565231200Smm} 566231200Smm 567231200Smmstatic inline void 568231200Smmlzss_emit_literal(struct rar *rar, uint8_t literal) 569231200Smm{ 570231200Smm *lzss_current_pointer(&rar->lzss) = literal; 571231200Smm rar->lzss.position++; 572231200Smm} 573231200Smm 574231200Smmstatic inline void 575231200Smmlzss_emit_match(struct rar *rar, int offset, int length) 576231200Smm{ 577231200Smm int dstoffs = lzss_current_offset(&rar->lzss); 578231200Smm int srcoffs = (dstoffs - offset) & lzss_mask(&rar->lzss); 579231200Smm int l, li, remaining; 580231200Smm unsigned char *d, *s; 581231200Smm 582231200Smm remaining = length; 583231200Smm while (remaining > 0) { 584231200Smm l = remaining; 585231200Smm if (dstoffs > srcoffs) { 586231200Smm if (l > lzss_size(&rar->lzss) - dstoffs) 587231200Smm l = lzss_size(&rar->lzss) - dstoffs; 588231200Smm } else { 589231200Smm if (l > lzss_size(&rar->lzss) - srcoffs) 590231200Smm l = lzss_size(&rar->lzss) - srcoffs; 591231200Smm } 592231200Smm d = &(rar->lzss.window[dstoffs]); 593231200Smm s = &(rar->lzss.window[srcoffs]); 594231200Smm if ((dstoffs + l < srcoffs) || (srcoffs + l < dstoffs)) 595231200Smm memcpy(d, s, l); 596231200Smm else { 597231200Smm for (li = 0; li < l; li++) 598231200Smm d[li] = s[li]; 599231200Smm } 600231200Smm remaining -= l; 601231200Smm dstoffs = (dstoffs + l) & lzss_mask(&(rar->lzss)); 602231200Smm srcoffs = (srcoffs + l) & lzss_mask(&(rar->lzss)); 603231200Smm } 604231200Smm rar->lzss.position += length; 605231200Smm} 606231200Smm 607231200Smmstatic void * 608231200Smmppmd_alloc(void *p, size_t size) 609231200Smm{ 610231200Smm (void)p; 611231200Smm return malloc(size); 612231200Smm} 613231200Smmstatic void 614231200Smmppmd_free(void *p, void *address) 615231200Smm{ 616231200Smm (void)p; 617231200Smm free(address); 618231200Smm} 619231200Smmstatic ISzAlloc g_szalloc = { ppmd_alloc, ppmd_free }; 620231200Smm 621231200Smmstatic Byte 622231200Smmppmd_read(void *p) 623231200Smm{ 624231200Smm struct archive_read *a = ((IByteIn*)p)->a; 625231200Smm struct rar *rar = (struct rar *)(a->format->data); 626231200Smm struct rar_br *br = &(rar->br); 627231200Smm Byte b; 628231200Smm if (!rar_br_read_ahead(a, br, 8)) 629231200Smm { 630231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 631231200Smm "Truncated RAR file data"); 632231200Smm rar->valid = 0; 633231200Smm return 0; 634231200Smm } 635231200Smm b = rar_br_bits(br, 8); 636231200Smm rar_br_consume(br, 8); 637231200Smm return b; 638231200Smm} 639231200Smm 640231200Smmint 641231200Smmarchive_read_support_format_rar(struct archive *_a) 642231200Smm{ 643231200Smm struct archive_read *a = (struct archive_read *)_a; 644231200Smm struct rar *rar; 645231200Smm int r; 646231200Smm 647231200Smm archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 648231200Smm "archive_read_support_format_rar"); 649231200Smm 650231200Smm rar = (struct rar *)malloc(sizeof(*rar)); 651231200Smm if (rar == NULL) 652231200Smm { 653231200Smm archive_set_error(&a->archive, ENOMEM, "Can't allocate rar data"); 654231200Smm return (ARCHIVE_FATAL); 655231200Smm } 656231200Smm memset(rar, 0, sizeof(*rar)); 657231200Smm 658299529Smm /* 659299529Smm * Until enough data has been read, we cannot tell about 660299529Smm * any encrypted entries yet. 661299529Smm */ 662299529Smm rar->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW; 663299529Smm 664231200Smm r = __archive_read_register_format(a, 665231200Smm rar, 666231200Smm "rar", 667231200Smm archive_read_format_rar_bid, 668231200Smm archive_read_format_rar_options, 669231200Smm archive_read_format_rar_read_header, 670231200Smm archive_read_format_rar_read_data, 671231200Smm archive_read_format_rar_read_data_skip, 672248616Smm archive_read_format_rar_seek_data, 673299529Smm archive_read_format_rar_cleanup, 674299529Smm archive_read_support_format_rar_capabilities, 675299529Smm archive_read_format_rar_has_encrypted_entries); 676231200Smm 677231200Smm if (r != ARCHIVE_OK) 678231200Smm free(rar); 679231200Smm return (r); 680231200Smm} 681231200Smm 682231200Smmstatic int 683299529Smmarchive_read_support_format_rar_capabilities(struct archive_read * a) 684299529Smm{ 685299529Smm (void)a; /* UNUSED */ 686299529Smm return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA 687299529Smm | ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA); 688299529Smm} 689299529Smm 690299529Smmstatic int 691299529Smmarchive_read_format_rar_has_encrypted_entries(struct archive_read *_a) 692299529Smm{ 693299529Smm if (_a && _a->format) { 694299529Smm struct rar * rar = (struct rar *)_a->format->data; 695299529Smm if (rar) { 696299529Smm return rar->has_encrypted_entries; 697299529Smm } 698299529Smm } 699299529Smm return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW; 700299529Smm} 701299529Smm 702299529Smm 703299529Smmstatic int 704231200Smmarchive_read_format_rar_bid(struct archive_read *a, int best_bid) 705231200Smm{ 706231200Smm const char *p; 707231200Smm 708231200Smm /* If there's already a bid > 30, we'll never win. */ 709231200Smm if (best_bid > 30) 710231200Smm return (-1); 711231200Smm 712231200Smm if ((p = __archive_read_ahead(a, 7, NULL)) == NULL) 713231200Smm return (-1); 714231200Smm 715231200Smm if (memcmp(p, RAR_SIGNATURE, 7) == 0) 716231200Smm return (30); 717231200Smm 718231200Smm if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) { 719231200Smm /* This is a PE file */ 720231200Smm ssize_t offset = 0x10000; 721231200Smm ssize_t window = 4096; 722231200Smm ssize_t bytes_avail; 723231200Smm while (offset + window <= (1024 * 128)) { 724231200Smm const char *buff = __archive_read_ahead(a, offset + window, &bytes_avail); 725231200Smm if (buff == NULL) { 726231200Smm /* Remaining bytes are less than window. */ 727231200Smm window >>= 1; 728231200Smm if (window < 0x40) 729231200Smm return (0); 730231200Smm continue; 731231200Smm } 732231200Smm p = buff + offset; 733231200Smm while (p + 7 < buff + bytes_avail) { 734231200Smm if (memcmp(p, RAR_SIGNATURE, 7) == 0) 735231200Smm return (30); 736231200Smm p += 0x10; 737231200Smm } 738231200Smm offset = p - buff; 739231200Smm } 740231200Smm } 741231200Smm return (0); 742231200Smm} 743231200Smm 744231200Smmstatic int 745231200Smmskip_sfx(struct archive_read *a) 746231200Smm{ 747231200Smm const void *h; 748231200Smm const char *p, *q; 749231200Smm size_t skip, total; 750231200Smm ssize_t bytes, window; 751231200Smm 752231200Smm total = 0; 753231200Smm window = 4096; 754231200Smm while (total + window <= (1024 * 128)) { 755231200Smm h = __archive_read_ahead(a, window, &bytes); 756231200Smm if (h == NULL) { 757231200Smm /* Remaining bytes are less than window. */ 758231200Smm window >>= 1; 759231200Smm if (window < 0x40) 760231200Smm goto fatal; 761231200Smm continue; 762231200Smm } 763231200Smm if (bytes < 0x40) 764231200Smm goto fatal; 765231200Smm p = h; 766231200Smm q = p + bytes; 767231200Smm 768231200Smm /* 769231200Smm * Scan ahead until we find something that looks 770231200Smm * like the RAR header. 771231200Smm */ 772231200Smm while (p + 7 < q) { 773231200Smm if (memcmp(p, RAR_SIGNATURE, 7) == 0) { 774231200Smm skip = p - (const char *)h; 775231200Smm __archive_read_consume(a, skip); 776231200Smm return (ARCHIVE_OK); 777231200Smm } 778231200Smm p += 0x10; 779231200Smm } 780231200Smm skip = p - (const char *)h; 781231200Smm __archive_read_consume(a, skip); 782231200Smm total += skip; 783231200Smm } 784231200Smmfatal: 785231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 786231200Smm "Couldn't find out RAR header"); 787231200Smm return (ARCHIVE_FATAL); 788231200Smm} 789231200Smm 790231200Smmstatic int 791231200Smmarchive_read_format_rar_options(struct archive_read *a, 792231200Smm const char *key, const char *val) 793231200Smm{ 794231200Smm struct rar *rar; 795231200Smm int ret = ARCHIVE_FAILED; 796299529Smm 797231200Smm rar = (struct rar *)(a->format->data); 798231200Smm if (strcmp(key, "hdrcharset") == 0) { 799231200Smm if (val == NULL || val[0] == 0) 800231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 801231200Smm "rar: hdrcharset option needs a character-set name"); 802231200Smm else { 803231200Smm rar->opt_sconv = 804231200Smm archive_string_conversion_from_charset( 805231200Smm &a->archive, val, 0); 806231200Smm if (rar->opt_sconv != NULL) 807231200Smm ret = ARCHIVE_OK; 808231200Smm else 809231200Smm ret = ARCHIVE_FATAL; 810231200Smm } 811232153Smm return (ret); 812232153Smm } 813232153Smm 814232153Smm /* Note: The "warn" return is just to inform the options 815232153Smm * supervisor that we didn't handle it. It will generate 816232153Smm * a suitable error if no one used this option. */ 817232153Smm return (ARCHIVE_WARN); 818231200Smm} 819231200Smm 820231200Smmstatic int 821231200Smmarchive_read_format_rar_read_header(struct archive_read *a, 822231200Smm struct archive_entry *entry) 823231200Smm{ 824231200Smm const void *h; 825231200Smm const char *p; 826231200Smm struct rar *rar; 827231200Smm size_t skip; 828231200Smm char head_type; 829231200Smm int ret; 830231200Smm unsigned flags; 831299529Smm unsigned long crc32_expected; 832231200Smm 833231200Smm a->archive.archive_format = ARCHIVE_FORMAT_RAR; 834231200Smm if (a->archive.archive_format_name == NULL) 835231200Smm a->archive.archive_format_name = "RAR"; 836231200Smm 837231200Smm rar = (struct rar *)(a->format->data); 838231200Smm 839299529Smm /* 840299529Smm * It should be sufficient to call archive_read_next_header() for 841299529Smm * a reader to determine if an entry is encrypted or not. If the 842299529Smm * encryption of an entry is only detectable when calling 843299529Smm * archive_read_data(), so be it. We'll do the same check there 844299529Smm * as well. 845299529Smm */ 846299529Smm if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { 847299529Smm rar->has_encrypted_entries = 0; 848299529Smm } 849299529Smm 850231200Smm /* RAR files can be generated without EOF headers, so return ARCHIVE_EOF if 851231200Smm * this fails. 852231200Smm */ 853231200Smm if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 854231200Smm return (ARCHIVE_EOF); 855231200Smm 856231200Smm p = h; 857231200Smm if (rar->found_first_header == 0 && 858231200Smm ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0)) { 859231200Smm /* This is an executable ? Must be self-extracting... */ 860231200Smm ret = skip_sfx(a); 861231200Smm if (ret < ARCHIVE_WARN) 862231200Smm return (ret); 863231200Smm } 864231200Smm rar->found_first_header = 1; 865231200Smm 866231200Smm while (1) 867231200Smm { 868231200Smm unsigned long crc32_val; 869231200Smm 870231200Smm if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 871231200Smm return (ARCHIVE_FATAL); 872231200Smm p = h; 873231200Smm 874231200Smm head_type = p[2]; 875231200Smm switch(head_type) 876231200Smm { 877231200Smm case MARK_HEAD: 878231200Smm if (memcmp(p, RAR_SIGNATURE, 7) != 0) { 879231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 880231200Smm "Invalid marker header"); 881231200Smm return (ARCHIVE_FATAL); 882231200Smm } 883231200Smm __archive_read_consume(a, 7); 884231200Smm break; 885231200Smm 886231200Smm case MAIN_HEAD: 887231200Smm rar->main_flags = archive_le16dec(p + 3); 888231200Smm skip = archive_le16dec(p + 5); 889231200Smm if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)) { 890231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 891231200Smm "Invalid header size"); 892231200Smm return (ARCHIVE_FATAL); 893231200Smm } 894231200Smm if ((h = __archive_read_ahead(a, skip, NULL)) == NULL) 895231200Smm return (ARCHIVE_FATAL); 896231200Smm p = h; 897231200Smm memcpy(rar->reserved1, p + 7, sizeof(rar->reserved1)); 898231200Smm memcpy(rar->reserved2, p + 7 + sizeof(rar->reserved1), 899231200Smm sizeof(rar->reserved2)); 900231200Smm if (rar->main_flags & MHD_ENCRYPTVER) { 901231200Smm if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)+1) { 902231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 903231200Smm "Invalid header size"); 904231200Smm return (ARCHIVE_FATAL); 905231200Smm } 906231200Smm rar->encryptver = *(p + 7 + sizeof(rar->reserved1) + 907231200Smm sizeof(rar->reserved2)); 908231200Smm } 909231200Smm 910299529Smm /* Main header is password encrytped, so we cannot read any 911299529Smm file names or any other info about files from the header. */ 912231200Smm if (rar->main_flags & MHD_PASSWORD) 913231200Smm { 914299529Smm archive_entry_set_is_metadata_encrypted(entry, 1); 915299529Smm archive_entry_set_is_data_encrypted(entry, 1); 916299529Smm rar->has_encrypted_entries = 1; 917299529Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 918231200Smm "RAR encryption support unavailable."); 919231200Smm return (ARCHIVE_FATAL); 920231200Smm } 921231200Smm 922248616Smm crc32_val = crc32(0, (const unsigned char *)p + 2, (unsigned)skip - 2); 923231200Smm if ((crc32_val & 0xffff) != archive_le16dec(p)) { 924231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 925231200Smm "Header CRC error"); 926231200Smm return (ARCHIVE_FATAL); 927231200Smm } 928231200Smm __archive_read_consume(a, skip); 929231200Smm break; 930231200Smm 931231200Smm case FILE_HEAD: 932231200Smm return read_header(a, entry, head_type); 933231200Smm 934231200Smm case COMM_HEAD: 935231200Smm case AV_HEAD: 936231200Smm case SUB_HEAD: 937231200Smm case PROTECT_HEAD: 938231200Smm case SIGN_HEAD: 939248616Smm case ENDARC_HEAD: 940231200Smm flags = archive_le16dec(p + 3); 941231200Smm skip = archive_le16dec(p + 5); 942231200Smm if (skip < 7) { 943231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 944299529Smm "Invalid header size too small"); 945231200Smm return (ARCHIVE_FATAL); 946231200Smm } 947231200Smm if (flags & HD_ADD_SIZE_PRESENT) 948231200Smm { 949231200Smm if (skip < 7 + 4) { 950231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 951299529Smm "Invalid header size too small"); 952231200Smm return (ARCHIVE_FATAL); 953231200Smm } 954231200Smm if ((h = __archive_read_ahead(a, skip, NULL)) == NULL) 955231200Smm return (ARCHIVE_FATAL); 956231200Smm p = h; 957299529Smm skip += archive_le32dec(p + 7); 958231200Smm } 959231200Smm 960299529Smm /* Skip over the 2-byte CRC at the beginning of the header. */ 961299529Smm crc32_expected = archive_le16dec(p); 962299529Smm __archive_read_consume(a, 2); 963299529Smm skip -= 2; 964299529Smm 965299529Smm /* Skim the entire header and compute the CRC. */ 966299529Smm crc32_val = 0; 967299529Smm while (skip > 0) { 968299529Smm size_t to_read = skip; 969299529Smm ssize_t did_read; 970299529Smm if (to_read > 32 * 1024) { 971299529Smm to_read = 32 * 1024; 972299529Smm } 973299529Smm if ((h = __archive_read_ahead(a, to_read, &did_read)) == NULL) { 974299529Smm return (ARCHIVE_FATAL); 975299529Smm } 976299529Smm p = h; 977299529Smm crc32_val = crc32(crc32_val, (const unsigned char *)p, (unsigned)did_read); 978299529Smm __archive_read_consume(a, did_read); 979299529Smm skip -= did_read; 980231200Smm } 981299529Smm if ((crc32_val & 0xffff) != crc32_expected) { 982299529Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 983299529Smm "Header CRC error"); 984299529Smm return (ARCHIVE_FATAL); 985299529Smm } 986248616Smm if (head_type == ENDARC_HEAD) 987299529Smm return (ARCHIVE_EOF); 988231200Smm break; 989231200Smm 990231200Smm case NEWSUB_HEAD: 991231200Smm if ((ret = read_header(a, entry, head_type)) < ARCHIVE_WARN) 992231200Smm return ret; 993231200Smm break; 994231200Smm 995231200Smm default: 996231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 997231200Smm "Bad RAR file"); 998231200Smm return (ARCHIVE_FATAL); 999231200Smm } 1000231200Smm } 1001231200Smm} 1002231200Smm 1003231200Smmstatic int 1004231200Smmarchive_read_format_rar_read_data(struct archive_read *a, const void **buff, 1005231200Smm size_t *size, int64_t *offset) 1006231200Smm{ 1007231200Smm struct rar *rar = (struct rar *)(a->format->data); 1008231200Smm int ret; 1009231200Smm 1010299529Smm if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { 1011299529Smm rar->has_encrypted_entries = 0; 1012299529Smm } 1013299529Smm 1014231200Smm if (rar->bytes_unconsumed > 0) { 1015231200Smm /* Consume as much as the decompressor actually used. */ 1016231200Smm __archive_read_consume(a, rar->bytes_unconsumed); 1017231200Smm rar->bytes_unconsumed = 0; 1018231200Smm } 1019231200Smm 1020299529Smm *buff = NULL; 1021248616Smm if (rar->entry_eof || rar->offset_seek >= rar->unp_size) { 1022231200Smm *size = 0; 1023231200Smm *offset = rar->offset; 1024248616Smm if (*offset < rar->unp_size) 1025248616Smm *offset = rar->unp_size; 1026231200Smm return (ARCHIVE_EOF); 1027231200Smm } 1028231200Smm 1029231200Smm switch (rar->compression_method) 1030231200Smm { 1031231200Smm case COMPRESS_METHOD_STORE: 1032231200Smm ret = read_data_stored(a, buff, size, offset); 1033299529Smm break; 1034231200Smm 1035231200Smm case COMPRESS_METHOD_FASTEST: 1036231200Smm case COMPRESS_METHOD_FAST: 1037231200Smm case COMPRESS_METHOD_NORMAL: 1038231200Smm case COMPRESS_METHOD_GOOD: 1039231200Smm case COMPRESS_METHOD_BEST: 1040231200Smm ret = read_data_compressed(a, buff, size, offset); 1041231200Smm if (ret != ARCHIVE_OK && ret != ARCHIVE_WARN) 1042231200Smm __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc); 1043299529Smm break; 1044231200Smm 1045231200Smm default: 1046231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1047231200Smm "Unsupported compression method for RAR file."); 1048231200Smm ret = ARCHIVE_FATAL; 1049299529Smm break; 1050231200Smm } 1051231200Smm return (ret); 1052231200Smm} 1053231200Smm 1054231200Smmstatic int 1055231200Smmarchive_read_format_rar_read_data_skip(struct archive_read *a) 1056231200Smm{ 1057231200Smm struct rar *rar; 1058231200Smm int64_t bytes_skipped; 1059248616Smm int ret; 1060231200Smm 1061231200Smm rar = (struct rar *)(a->format->data); 1062231200Smm 1063231200Smm if (rar->bytes_unconsumed > 0) { 1064231200Smm /* Consume as much as the decompressor actually used. */ 1065231200Smm __archive_read_consume(a, rar->bytes_unconsumed); 1066231200Smm rar->bytes_unconsumed = 0; 1067231200Smm } 1068231200Smm 1069231200Smm if (rar->bytes_remaining > 0) { 1070231200Smm bytes_skipped = __archive_read_consume(a, rar->bytes_remaining); 1071231200Smm if (bytes_skipped < 0) 1072231200Smm return (ARCHIVE_FATAL); 1073231200Smm } 1074248616Smm 1075248616Smm /* Compressed data to skip must be read from each header in a multivolume 1076248616Smm * archive. 1077248616Smm */ 1078248616Smm if (rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER) 1079248616Smm { 1080248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1081248616Smm if (ret == (ARCHIVE_EOF)) 1082248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1083248616Smm if (ret != (ARCHIVE_OK)) 1084248616Smm return ret; 1085248616Smm return archive_read_format_rar_read_data_skip(a); 1086248616Smm } 1087248616Smm 1088231200Smm return (ARCHIVE_OK); 1089231200Smm} 1090231200Smm 1091248616Smmstatic int64_t 1092248616Smmarchive_read_format_rar_seek_data(struct archive_read *a, int64_t offset, 1093248616Smm int whence) 1094248616Smm{ 1095248616Smm int64_t client_offset, ret; 1096248616Smm unsigned int i; 1097248616Smm struct rar *rar = (struct rar *)(a->format->data); 1098248616Smm 1099248616Smm if (rar->compression_method == COMPRESS_METHOD_STORE) 1100248616Smm { 1101248616Smm /* Modify the offset for use with SEEK_SET */ 1102248616Smm switch (whence) 1103248616Smm { 1104248616Smm case SEEK_CUR: 1105248616Smm client_offset = rar->offset_seek; 1106248616Smm break; 1107248616Smm case SEEK_END: 1108248616Smm client_offset = rar->unp_size; 1109248616Smm break; 1110248616Smm case SEEK_SET: 1111248616Smm default: 1112248616Smm client_offset = 0; 1113248616Smm } 1114248616Smm client_offset += offset; 1115248616Smm if (client_offset < 0) 1116248616Smm { 1117248616Smm /* Can't seek past beginning of data block */ 1118248616Smm return -1; 1119248616Smm } 1120248616Smm else if (client_offset > rar->unp_size) 1121248616Smm { 1122248616Smm /* 1123248616Smm * Set the returned offset but only seek to the end of 1124248616Smm * the data block. 1125248616Smm */ 1126248616Smm rar->offset_seek = client_offset; 1127248616Smm client_offset = rar->unp_size; 1128248616Smm } 1129248616Smm 1130248616Smm client_offset += rar->dbo[0].start_offset; 1131248616Smm i = 0; 1132248616Smm while (i < rar->cursor) 1133248616Smm { 1134248616Smm i++; 1135248616Smm client_offset += rar->dbo[i].start_offset - rar->dbo[i-1].end_offset; 1136248616Smm } 1137248616Smm if (rar->main_flags & MHD_VOLUME) 1138248616Smm { 1139248616Smm /* Find the appropriate offset among the multivolume archive */ 1140248616Smm while (1) 1141248616Smm { 1142248616Smm if (client_offset < rar->dbo[rar->cursor].start_offset && 1143248616Smm rar->file_flags & FHD_SPLIT_BEFORE) 1144248616Smm { 1145248616Smm /* Search backwards for the correct data block */ 1146248616Smm if (rar->cursor == 0) 1147248616Smm { 1148248616Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1149248616Smm "Attempt to seek past beginning of RAR data block"); 1150248616Smm return (ARCHIVE_FAILED); 1151248616Smm } 1152248616Smm rar->cursor--; 1153248616Smm client_offset -= rar->dbo[rar->cursor+1].start_offset - 1154248616Smm rar->dbo[rar->cursor].end_offset; 1155248616Smm if (client_offset < rar->dbo[rar->cursor].start_offset) 1156248616Smm continue; 1157248616Smm ret = __archive_read_seek(a, rar->dbo[rar->cursor].start_offset - 1158248616Smm rar->dbo[rar->cursor].header_size, SEEK_SET); 1159248616Smm if (ret < (ARCHIVE_OK)) 1160248616Smm return ret; 1161248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1162248616Smm if (ret != (ARCHIVE_OK)) 1163248616Smm { 1164248616Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1165248616Smm "Error during seek of RAR file"); 1166248616Smm return (ARCHIVE_FAILED); 1167248616Smm } 1168248616Smm rar->cursor--; 1169248616Smm break; 1170248616Smm } 1171248616Smm else if (client_offset > rar->dbo[rar->cursor].end_offset && 1172248616Smm rar->file_flags & FHD_SPLIT_AFTER) 1173248616Smm { 1174248616Smm /* Search forward for the correct data block */ 1175248616Smm rar->cursor++; 1176248616Smm if (rar->cursor < rar->nodes && 1177248616Smm client_offset > rar->dbo[rar->cursor].end_offset) 1178248616Smm { 1179248616Smm client_offset += rar->dbo[rar->cursor].start_offset - 1180248616Smm rar->dbo[rar->cursor-1].end_offset; 1181248616Smm continue; 1182248616Smm } 1183248616Smm rar->cursor--; 1184248616Smm ret = __archive_read_seek(a, rar->dbo[rar->cursor].end_offset, 1185248616Smm SEEK_SET); 1186248616Smm if (ret < (ARCHIVE_OK)) 1187248616Smm return ret; 1188248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1189248616Smm if (ret == (ARCHIVE_EOF)) 1190248616Smm { 1191248616Smm rar->has_endarc_header = 1; 1192248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1193248616Smm } 1194248616Smm if (ret != (ARCHIVE_OK)) 1195248616Smm { 1196248616Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1197248616Smm "Error during seek of RAR file"); 1198248616Smm return (ARCHIVE_FAILED); 1199248616Smm } 1200248616Smm client_offset += rar->dbo[rar->cursor].start_offset - 1201248616Smm rar->dbo[rar->cursor-1].end_offset; 1202248616Smm continue; 1203248616Smm } 1204248616Smm break; 1205248616Smm } 1206248616Smm } 1207248616Smm 1208248616Smm ret = __archive_read_seek(a, client_offset, SEEK_SET); 1209248616Smm if (ret < (ARCHIVE_OK)) 1210248616Smm return ret; 1211248616Smm rar->bytes_remaining = rar->dbo[rar->cursor].end_offset - ret; 1212248616Smm i = rar->cursor; 1213248616Smm while (i > 0) 1214248616Smm { 1215248616Smm i--; 1216248616Smm ret -= rar->dbo[i+1].start_offset - rar->dbo[i].end_offset; 1217248616Smm } 1218248616Smm ret -= rar->dbo[0].start_offset; 1219248616Smm 1220248616Smm /* Always restart reading the file after a seek */ 1221299529Smm __archive_reset_read_data(&a->archive); 1222299529Smm 1223248616Smm rar->bytes_unconsumed = 0; 1224248616Smm rar->offset = 0; 1225248616Smm 1226248616Smm /* 1227248616Smm * If a seek past the end of file was requested, return the requested 1228248616Smm * offset. 1229248616Smm */ 1230248616Smm if (ret == rar->unp_size && rar->offset_seek > rar->unp_size) 1231248616Smm return rar->offset_seek; 1232248616Smm 1233248616Smm /* Return the new offset */ 1234248616Smm rar->offset_seek = ret; 1235248616Smm return rar->offset_seek; 1236248616Smm } 1237248616Smm else 1238248616Smm { 1239248616Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1240248616Smm "Seeking of compressed RAR files is unsupported"); 1241248616Smm } 1242248616Smm return (ARCHIVE_FAILED); 1243248616Smm} 1244248616Smm 1245231200Smmstatic int 1246231200Smmarchive_read_format_rar_cleanup(struct archive_read *a) 1247231200Smm{ 1248231200Smm struct rar *rar; 1249231200Smm 1250231200Smm rar = (struct rar *)(a->format->data); 1251231200Smm free_codes(a); 1252231200Smm free(rar->filename); 1253248616Smm free(rar->filename_save); 1254248616Smm free(rar->dbo); 1255231200Smm free(rar->unp_buffer); 1256231200Smm free(rar->lzss.window); 1257231200Smm __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc); 1258231200Smm free(rar); 1259231200Smm (a->format->data) = NULL; 1260231200Smm return (ARCHIVE_OK); 1261231200Smm} 1262231200Smm 1263231200Smmstatic int 1264231200Smmread_header(struct archive_read *a, struct archive_entry *entry, 1265231200Smm char head_type) 1266231200Smm{ 1267231200Smm const void *h; 1268231200Smm const char *p, *endp; 1269231200Smm struct rar *rar; 1270231200Smm struct rar_header rar_header; 1271231200Smm struct rar_file_header file_header; 1272231200Smm int64_t header_size; 1273231200Smm unsigned filename_size, end; 1274231200Smm char *filename; 1275231200Smm char *strp; 1276231200Smm char packed_size[8]; 1277231200Smm char unp_size[8]; 1278232153Smm int ttime; 1279231200Smm struct archive_string_conv *sconv, *fn_sconv; 1280231200Smm unsigned long crc32_val; 1281231200Smm int ret = (ARCHIVE_OK), ret2; 1282231200Smm 1283231200Smm rar = (struct rar *)(a->format->data); 1284231200Smm 1285231200Smm /* Setup a string conversion object for non-rar-unicode filenames. */ 1286231200Smm sconv = rar->opt_sconv; 1287231200Smm if (sconv == NULL) { 1288231200Smm if (!rar->init_default_conversion) { 1289231200Smm rar->sconv_default = 1290231200Smm archive_string_default_conversion_for_read( 1291231200Smm &(a->archive)); 1292231200Smm rar->init_default_conversion = 1; 1293231200Smm } 1294231200Smm sconv = rar->sconv_default; 1295231200Smm } 1296231200Smm 1297231200Smm 1298231200Smm if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 1299231200Smm return (ARCHIVE_FATAL); 1300231200Smm p = h; 1301231200Smm memcpy(&rar_header, p, sizeof(rar_header)); 1302231200Smm rar->file_flags = archive_le16dec(rar_header.flags); 1303231200Smm header_size = archive_le16dec(rar_header.size); 1304232153Smm if (header_size < (int64_t)sizeof(file_header) + 7) { 1305231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1306231200Smm "Invalid header size"); 1307231200Smm return (ARCHIVE_FATAL); 1308231200Smm } 1309231200Smm crc32_val = crc32(0, (const unsigned char *)p + 2, 7 - 2); 1310231200Smm __archive_read_consume(a, 7); 1311231200Smm 1312231200Smm if (!(rar->file_flags & FHD_SOLID)) 1313231200Smm { 1314231200Smm rar->compression_method = 0; 1315231200Smm rar->packed_size = 0; 1316231200Smm rar->unp_size = 0; 1317231200Smm rar->mtime = 0; 1318231200Smm rar->ctime = 0; 1319231200Smm rar->atime = 0; 1320231200Smm rar->arctime = 0; 1321231200Smm rar->mode = 0; 1322231200Smm memset(&rar->salt, 0, sizeof(rar->salt)); 1323231200Smm rar->atime = 0; 1324231200Smm rar->ansec = 0; 1325231200Smm rar->ctime = 0; 1326231200Smm rar->cnsec = 0; 1327231200Smm rar->mtime = 0; 1328231200Smm rar->mnsec = 0; 1329231200Smm rar->arctime = 0; 1330231200Smm rar->arcnsec = 0; 1331231200Smm } 1332231200Smm else 1333231200Smm { 1334231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1335231200Smm "RAR solid archive support unavailable."); 1336231200Smm return (ARCHIVE_FATAL); 1337231200Smm } 1338231200Smm 1339238856Smm if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL) 1340231200Smm return (ARCHIVE_FATAL); 1341231200Smm 1342231200Smm /* File Header CRC check. */ 1343238856Smm crc32_val = crc32(crc32_val, h, (unsigned)(header_size - 7)); 1344231200Smm if ((crc32_val & 0xffff) != archive_le16dec(rar_header.crc)) { 1345231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1346231200Smm "Header CRC error"); 1347231200Smm return (ARCHIVE_FATAL); 1348231200Smm } 1349231200Smm /* If no CRC error, Go on parsing File Header. */ 1350231200Smm p = h; 1351231200Smm endp = p + header_size - 7; 1352231200Smm memcpy(&file_header, p, sizeof(file_header)); 1353231200Smm p += sizeof(file_header); 1354231200Smm 1355231200Smm rar->compression_method = file_header.method; 1356231200Smm 1357232153Smm ttime = archive_le32dec(file_header.file_time); 1358232153Smm rar->mtime = get_time(ttime); 1359231200Smm 1360231200Smm rar->file_crc = archive_le32dec(file_header.file_crc); 1361231200Smm 1362231200Smm if (rar->file_flags & FHD_PASSWORD) 1363231200Smm { 1364299529Smm archive_entry_set_is_data_encrypted(entry, 1); 1365299529Smm rar->has_encrypted_entries = 1; 1366231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1367231200Smm "RAR encryption support unavailable."); 1368299529Smm /* Since it is only the data part itself that is encrypted we can at least 1369299529Smm extract information about the currently processed entry and don't need 1370299529Smm to return ARCHIVE_FATAL here. */ 1371299529Smm /*return (ARCHIVE_FATAL);*/ 1372231200Smm } 1373231200Smm 1374231200Smm if (rar->file_flags & FHD_LARGE) 1375231200Smm { 1376231200Smm memcpy(packed_size, file_header.pack_size, 4); 1377231200Smm memcpy(packed_size + 4, p, 4); /* High pack size */ 1378231200Smm p += 4; 1379231200Smm memcpy(unp_size, file_header.unp_size, 4); 1380231200Smm memcpy(unp_size + 4, p, 4); /* High unpack size */ 1381231200Smm p += 4; 1382231200Smm rar->packed_size = archive_le64dec(&packed_size); 1383231200Smm rar->unp_size = archive_le64dec(&unp_size); 1384231200Smm } 1385231200Smm else 1386231200Smm { 1387231200Smm rar->packed_size = archive_le32dec(file_header.pack_size); 1388231200Smm rar->unp_size = archive_le32dec(file_header.unp_size); 1389231200Smm } 1390231200Smm 1391231200Smm if (rar->packed_size < 0 || rar->unp_size < 0) 1392231200Smm { 1393231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1394231200Smm "Invalid sizes specified."); 1395231200Smm return (ARCHIVE_FATAL); 1396231200Smm } 1397231200Smm 1398248616Smm rar->bytes_remaining = rar->packed_size; 1399248616Smm 1400231200Smm /* TODO: RARv3 subblocks contain comments. For now the complete block is 1401231200Smm * consumed at the end. 1402231200Smm */ 1403231200Smm if (head_type == NEWSUB_HEAD) { 1404231200Smm size_t distance = p - (const char *)h; 1405231200Smm header_size += rar->packed_size; 1406231200Smm /* Make sure we have the extended data. */ 1407238856Smm if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL) 1408231200Smm return (ARCHIVE_FATAL); 1409231200Smm p = h; 1410231200Smm endp = p + header_size - 7; 1411231200Smm p += distance; 1412231200Smm } 1413231200Smm 1414231200Smm filename_size = archive_le16dec(file_header.name_size); 1415231200Smm if (p + filename_size > endp) { 1416231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1417231200Smm "Invalid filename size"); 1418231200Smm return (ARCHIVE_FATAL); 1419231200Smm } 1420238856Smm if (rar->filename_allocated < filename_size * 2 + 2) { 1421238856Smm char *newptr; 1422238856Smm size_t newsize = filename_size * 2 + 2; 1423238856Smm newptr = realloc(rar->filename, newsize); 1424238856Smm if (newptr == NULL) { 1425231200Smm archive_set_error(&a->archive, ENOMEM, 1426231200Smm "Couldn't allocate memory."); 1427231200Smm return (ARCHIVE_FATAL); 1428231200Smm } 1429238856Smm rar->filename = newptr; 1430238856Smm rar->filename_allocated = newsize; 1431231200Smm } 1432231200Smm filename = rar->filename; 1433231200Smm memcpy(filename, p, filename_size); 1434231200Smm filename[filename_size] = '\0'; 1435231200Smm if (rar->file_flags & FHD_UNICODE) 1436231200Smm { 1437231200Smm if (filename_size != strlen(filename)) 1438231200Smm { 1439248616Smm unsigned char highbyte, flagbits, flagbyte; 1440248616Smm unsigned fn_end, offset; 1441231200Smm 1442231200Smm end = filename_size; 1443238856Smm fn_end = filename_size * 2; 1444231200Smm filename_size = 0; 1445248616Smm offset = (unsigned)strlen(filename) + 1; 1446231200Smm highbyte = *(p + offset++); 1447231200Smm flagbits = 0; 1448231200Smm flagbyte = 0; 1449238856Smm while (offset < end && filename_size < fn_end) 1450231200Smm { 1451231200Smm if (!flagbits) 1452231200Smm { 1453231200Smm flagbyte = *(p + offset++); 1454231200Smm flagbits = 8; 1455231200Smm } 1456299529Smm 1457231200Smm flagbits -= 2; 1458231200Smm switch((flagbyte >> flagbits) & 3) 1459231200Smm { 1460231200Smm case 0: 1461231200Smm filename[filename_size++] = '\0'; 1462231200Smm filename[filename_size++] = *(p + offset++); 1463231200Smm break; 1464231200Smm case 1: 1465231200Smm filename[filename_size++] = highbyte; 1466231200Smm filename[filename_size++] = *(p + offset++); 1467231200Smm break; 1468231200Smm case 2: 1469231200Smm filename[filename_size++] = *(p + offset + 1); 1470231200Smm filename[filename_size++] = *(p + offset); 1471231200Smm offset += 2; 1472231200Smm break; 1473231200Smm case 3: 1474231200Smm { 1475238856Smm char extra, high; 1476238856Smm uint8_t length = *(p + offset++); 1477238856Smm 1478238856Smm if (length & 0x80) { 1479238856Smm extra = *(p + offset++); 1480238856Smm high = (char)highbyte; 1481238856Smm } else 1482238856Smm extra = high = 0; 1483238856Smm length = (length & 0x7f) + 2; 1484238856Smm while (length && filename_size < fn_end) { 1485238856Smm unsigned cp = filename_size >> 1; 1486238856Smm filename[filename_size++] = high; 1487238856Smm filename[filename_size++] = p[cp] + extra; 1488231200Smm length--; 1489231200Smm } 1490231200Smm } 1491231200Smm break; 1492231200Smm } 1493231200Smm } 1494238856Smm if (filename_size > fn_end) { 1495231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1496231200Smm "Invalid filename"); 1497231200Smm return (ARCHIVE_FATAL); 1498231200Smm } 1499231200Smm filename[filename_size++] = '\0'; 1500231200Smm filename[filename_size++] = '\0'; 1501231200Smm 1502231200Smm /* Decoded unicode form is UTF-16BE, so we have to update a string 1503231200Smm * conversion object for it. */ 1504231200Smm if (rar->sconv_utf16be == NULL) { 1505231200Smm rar->sconv_utf16be = archive_string_conversion_from_charset( 1506231200Smm &a->archive, "UTF-16BE", 1); 1507231200Smm if (rar->sconv_utf16be == NULL) 1508231200Smm return (ARCHIVE_FATAL); 1509231200Smm } 1510231200Smm fn_sconv = rar->sconv_utf16be; 1511231200Smm 1512231200Smm strp = filename; 1513231200Smm while (memcmp(strp, "\x00\x00", 2)) 1514231200Smm { 1515231200Smm if (!memcmp(strp, "\x00\\", 2)) 1516231200Smm *(strp + 1) = '/'; 1517231200Smm strp += 2; 1518231200Smm } 1519231200Smm p += offset; 1520231200Smm } else { 1521231200Smm /* 1522231200Smm * If FHD_UNICODE is set but no unicode data, this file name form 1523231200Smm * is UTF-8, so we have to update a string conversion object for 1524231200Smm * it accordingly. 1525231200Smm */ 1526231200Smm if (rar->sconv_utf8 == NULL) { 1527231200Smm rar->sconv_utf8 = archive_string_conversion_from_charset( 1528231200Smm &a->archive, "UTF-8", 1); 1529231200Smm if (rar->sconv_utf8 == NULL) 1530231200Smm return (ARCHIVE_FATAL); 1531231200Smm } 1532231200Smm fn_sconv = rar->sconv_utf8; 1533231200Smm while ((strp = strchr(filename, '\\')) != NULL) 1534231200Smm *strp = '/'; 1535231200Smm p += filename_size; 1536231200Smm } 1537231200Smm } 1538231200Smm else 1539231200Smm { 1540231200Smm fn_sconv = sconv; 1541231200Smm while ((strp = strchr(filename, '\\')) != NULL) 1542231200Smm *strp = '/'; 1543231200Smm p += filename_size; 1544231200Smm } 1545231200Smm 1546248616Smm /* Split file in multivolume RAR. No more need to process header. */ 1547248616Smm if (rar->filename_save && 1548299529Smm filename_size == rar->filename_save_size && 1549248616Smm !memcmp(rar->filename, rar->filename_save, filename_size + 1)) 1550248616Smm { 1551248616Smm __archive_read_consume(a, header_size - 7); 1552248616Smm rar->cursor++; 1553248616Smm if (rar->cursor >= rar->nodes) 1554248616Smm { 1555248616Smm rar->nodes++; 1556248616Smm if ((rar->dbo = 1557248616Smm realloc(rar->dbo, sizeof(*rar->dbo) * rar->nodes)) == NULL) 1558248616Smm { 1559248616Smm archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory."); 1560248616Smm return (ARCHIVE_FATAL); 1561248616Smm } 1562248616Smm rar->dbo[rar->cursor].header_size = header_size; 1563248616Smm rar->dbo[rar->cursor].start_offset = -1; 1564248616Smm rar->dbo[rar->cursor].end_offset = -1; 1565248616Smm } 1566248616Smm if (rar->dbo[rar->cursor].start_offset < 0) 1567248616Smm { 1568248616Smm rar->dbo[rar->cursor].start_offset = a->filter->position; 1569248616Smm rar->dbo[rar->cursor].end_offset = rar->dbo[rar->cursor].start_offset + 1570248616Smm rar->packed_size; 1571248616Smm } 1572248616Smm return ret; 1573248616Smm } 1574248616Smm 1575248616Smm rar->filename_save = (char*)realloc(rar->filename_save, 1576248616Smm filename_size + 1); 1577248616Smm memcpy(rar->filename_save, rar->filename, filename_size + 1); 1578299529Smm rar->filename_save_size = filename_size; 1579248616Smm 1580248616Smm /* Set info for seeking */ 1581248616Smm free(rar->dbo); 1582248616Smm if ((rar->dbo = calloc(1, sizeof(*rar->dbo))) == NULL) 1583248616Smm { 1584248616Smm archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory."); 1585248616Smm return (ARCHIVE_FATAL); 1586248616Smm } 1587248616Smm rar->dbo[0].header_size = header_size; 1588248616Smm rar->dbo[0].start_offset = -1; 1589248616Smm rar->dbo[0].end_offset = -1; 1590248616Smm rar->cursor = 0; 1591248616Smm rar->nodes = 1; 1592248616Smm 1593231200Smm if (rar->file_flags & FHD_SALT) 1594231200Smm { 1595231200Smm if (p + 8 > endp) { 1596231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1597231200Smm "Invalid header size"); 1598231200Smm return (ARCHIVE_FATAL); 1599231200Smm } 1600231200Smm memcpy(rar->salt, p, 8); 1601231200Smm p += 8; 1602231200Smm } 1603231200Smm 1604231200Smm if (rar->file_flags & FHD_EXTTIME) { 1605231200Smm if (read_exttime(p, rar, endp) < 0) { 1606231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1607231200Smm "Invalid header size"); 1608231200Smm return (ARCHIVE_FATAL); 1609231200Smm } 1610231200Smm } 1611231200Smm 1612231200Smm __archive_read_consume(a, header_size - 7); 1613248616Smm rar->dbo[0].start_offset = a->filter->position; 1614248616Smm rar->dbo[0].end_offset = rar->dbo[0].start_offset + rar->packed_size; 1615231200Smm 1616231200Smm switch(file_header.host_os) 1617231200Smm { 1618231200Smm case OS_MSDOS: 1619231200Smm case OS_OS2: 1620231200Smm case OS_WIN32: 1621231200Smm rar->mode = archive_le32dec(file_header.file_attr); 1622231200Smm if (rar->mode & FILE_ATTRIBUTE_DIRECTORY) 1623231200Smm rar->mode = AE_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH; 1624231200Smm else 1625231200Smm rar->mode = AE_IFREG; 1626231200Smm rar->mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; 1627231200Smm break; 1628231200Smm 1629231200Smm case OS_UNIX: 1630231200Smm case OS_MAC_OS: 1631231200Smm case OS_BEOS: 1632231200Smm rar->mode = archive_le32dec(file_header.file_attr); 1633231200Smm break; 1634231200Smm 1635231200Smm default: 1636231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1637231200Smm "Unknown file attributes from RAR file's host OS"); 1638231200Smm return (ARCHIVE_FATAL); 1639231200Smm } 1640231200Smm 1641231200Smm rar->bytes_uncopied = rar->bytes_unconsumed = 0; 1642238856Smm rar->lzss.position = rar->offset = 0; 1643248616Smm rar->offset_seek = 0; 1644238856Smm rar->dictionary_size = 0; 1645231200Smm rar->offset_outgoing = 0; 1646231200Smm rar->br.cache_avail = 0; 1647231200Smm rar->br.avail_in = 0; 1648231200Smm rar->crc_calculated = 0; 1649231200Smm rar->entry_eof = 0; 1650231200Smm rar->valid = 1; 1651231200Smm rar->is_ppmd_block = 0; 1652231200Smm rar->start_new_table = 1; 1653231200Smm free(rar->unp_buffer); 1654231200Smm rar->unp_buffer = NULL; 1655231200Smm rar->unp_offset = 0; 1656231200Smm rar->unp_buffer_size = UNP_BUFFER_SIZE; 1657231200Smm memset(rar->lengthtable, 0, sizeof(rar->lengthtable)); 1658231200Smm __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc); 1659231200Smm rar->ppmd_valid = rar->ppmd_eod = 0; 1660231200Smm 1661231200Smm /* Don't set any archive entries for non-file header types */ 1662231200Smm if (head_type == NEWSUB_HEAD) 1663231200Smm return ret; 1664231200Smm 1665231200Smm archive_entry_set_mtime(entry, rar->mtime, rar->mnsec); 1666231200Smm archive_entry_set_ctime(entry, rar->ctime, rar->cnsec); 1667231200Smm archive_entry_set_atime(entry, rar->atime, rar->ansec); 1668231200Smm archive_entry_set_size(entry, rar->unp_size); 1669231200Smm archive_entry_set_mode(entry, rar->mode); 1670231200Smm 1671231200Smm if (archive_entry_copy_pathname_l(entry, filename, filename_size, fn_sconv)) 1672231200Smm { 1673231200Smm if (errno == ENOMEM) 1674231200Smm { 1675231200Smm archive_set_error(&a->archive, ENOMEM, 1676231200Smm "Can't allocate memory for Pathname"); 1677231200Smm return (ARCHIVE_FATAL); 1678231200Smm } 1679231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1680231200Smm "Pathname cannot be converted from %s to current locale.", 1681231200Smm archive_string_conversion_charset_name(fn_sconv)); 1682231200Smm ret = (ARCHIVE_WARN); 1683231200Smm } 1684231200Smm 1685231200Smm if (((rar->mode) & AE_IFMT) == AE_IFLNK) 1686231200Smm { 1687231200Smm /* Make sure a symbolic-link file does not have its body. */ 1688231200Smm rar->bytes_remaining = 0; 1689231200Smm archive_entry_set_size(entry, 0); 1690231200Smm 1691231200Smm /* Read a symbolic-link name. */ 1692231200Smm if ((ret2 = read_symlink_stored(a, entry, sconv)) < (ARCHIVE_WARN)) 1693231200Smm return ret2; 1694231200Smm if (ret > ret2) 1695231200Smm ret = ret2; 1696231200Smm } 1697231200Smm 1698231200Smm if (rar->bytes_remaining == 0) 1699231200Smm rar->entry_eof = 1; 1700231200Smm 1701231200Smm return ret; 1702231200Smm} 1703231200Smm 1704231200Smmstatic time_t 1705232153Smmget_time(int ttime) 1706231200Smm{ 1707231200Smm struct tm tm; 1708232153Smm tm.tm_sec = 2 * (ttime & 0x1f); 1709232153Smm tm.tm_min = (ttime >> 5) & 0x3f; 1710232153Smm tm.tm_hour = (ttime >> 11) & 0x1f; 1711232153Smm tm.tm_mday = (ttime >> 16) & 0x1f; 1712232153Smm tm.tm_mon = ((ttime >> 21) & 0x0f) - 1; 1713232153Smm tm.tm_year = ((ttime >> 25) & 0x7f) + 80; 1714231200Smm tm.tm_isdst = -1; 1715231200Smm return mktime(&tm); 1716231200Smm} 1717231200Smm 1718231200Smmstatic int 1719231200Smmread_exttime(const char *p, struct rar *rar, const char *endp) 1720231200Smm{ 1721231200Smm unsigned rmode, flags, rem, j, count; 1722232153Smm int ttime, i; 1723231200Smm struct tm *tm; 1724231200Smm time_t t; 1725231200Smm long nsec; 1726231200Smm 1727231200Smm if (p + 2 > endp) 1728231200Smm return (-1); 1729231200Smm flags = archive_le16dec(p); 1730231200Smm p += 2; 1731231200Smm 1732231200Smm for (i = 3; i >= 0; i--) 1733231200Smm { 1734231200Smm t = 0; 1735231200Smm if (i == 3) 1736231200Smm t = rar->mtime; 1737231200Smm rmode = flags >> i * 4; 1738231200Smm if (rmode & 8) 1739231200Smm { 1740231200Smm if (!t) 1741231200Smm { 1742231200Smm if (p + 4 > endp) 1743231200Smm return (-1); 1744232153Smm ttime = archive_le32dec(p); 1745232153Smm t = get_time(ttime); 1746231200Smm p += 4; 1747231200Smm } 1748231200Smm rem = 0; 1749231200Smm count = rmode & 3; 1750231200Smm if (p + count > endp) 1751231200Smm return (-1); 1752231200Smm for (j = 0; j < count; j++) 1753231200Smm { 1754231200Smm rem = ((*p) << 16) | (rem >> 8); 1755231200Smm p++; 1756231200Smm } 1757231200Smm tm = localtime(&t); 1758231200Smm nsec = tm->tm_sec + rem / NS_UNIT; 1759231200Smm if (rmode & 4) 1760231200Smm { 1761231200Smm tm->tm_sec++; 1762231200Smm t = mktime(tm); 1763231200Smm } 1764231200Smm if (i == 3) 1765231200Smm { 1766231200Smm rar->mtime = t; 1767231200Smm rar->mnsec = nsec; 1768231200Smm } 1769231200Smm else if (i == 2) 1770231200Smm { 1771231200Smm rar->ctime = t; 1772231200Smm rar->cnsec = nsec; 1773231200Smm } 1774231200Smm else if (i == 1) 1775231200Smm { 1776231200Smm rar->atime = t; 1777231200Smm rar->ansec = nsec; 1778231200Smm } 1779231200Smm else 1780231200Smm { 1781231200Smm rar->arctime = t; 1782231200Smm rar->arcnsec = nsec; 1783231200Smm } 1784231200Smm } 1785231200Smm } 1786231200Smm return (0); 1787231200Smm} 1788231200Smm 1789231200Smmstatic int 1790231200Smmread_symlink_stored(struct archive_read *a, struct archive_entry *entry, 1791231200Smm struct archive_string_conv *sconv) 1792231200Smm{ 1793231200Smm const void *h; 1794231200Smm const char *p; 1795231200Smm struct rar *rar; 1796231200Smm int ret = (ARCHIVE_OK); 1797231200Smm 1798231200Smm rar = (struct rar *)(a->format->data); 1799248616Smm if ((h = rar_read_ahead(a, (size_t)rar->packed_size, NULL)) == NULL) 1800231200Smm return (ARCHIVE_FATAL); 1801231200Smm p = h; 1802231200Smm 1803238856Smm if (archive_entry_copy_symlink_l(entry, 1804238856Smm p, (size_t)rar->packed_size, sconv)) 1805231200Smm { 1806231200Smm if (errno == ENOMEM) 1807231200Smm { 1808231200Smm archive_set_error(&a->archive, ENOMEM, 1809231200Smm "Can't allocate memory for link"); 1810231200Smm return (ARCHIVE_FATAL); 1811231200Smm } 1812231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1813231200Smm "link cannot be converted from %s to current locale.", 1814231200Smm archive_string_conversion_charset_name(sconv)); 1815231200Smm ret = (ARCHIVE_WARN); 1816231200Smm } 1817231200Smm __archive_read_consume(a, rar->packed_size); 1818231200Smm return ret; 1819231200Smm} 1820231200Smm 1821231200Smmstatic int 1822231200Smmread_data_stored(struct archive_read *a, const void **buff, size_t *size, 1823231200Smm int64_t *offset) 1824231200Smm{ 1825231200Smm struct rar *rar; 1826231200Smm ssize_t bytes_avail; 1827231200Smm 1828231200Smm rar = (struct rar *)(a->format->data); 1829248616Smm if (rar->bytes_remaining == 0 && 1830248616Smm !(rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER)) 1831231200Smm { 1832231200Smm *buff = NULL; 1833231200Smm *size = 0; 1834231200Smm *offset = rar->offset; 1835231200Smm if (rar->file_crc != rar->crc_calculated) { 1836231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1837231200Smm "File CRC error"); 1838231200Smm return (ARCHIVE_FATAL); 1839231200Smm } 1840231200Smm rar->entry_eof = 1; 1841231200Smm return (ARCHIVE_EOF); 1842231200Smm } 1843231200Smm 1844248616Smm *buff = rar_read_ahead(a, 1, &bytes_avail); 1845231200Smm if (bytes_avail <= 0) 1846231200Smm { 1847231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1848231200Smm "Truncated RAR file data"); 1849231200Smm return (ARCHIVE_FATAL); 1850231200Smm } 1851231200Smm 1852231200Smm *size = bytes_avail; 1853231200Smm *offset = rar->offset; 1854231200Smm rar->offset += bytes_avail; 1855248616Smm rar->offset_seek += bytes_avail; 1856231200Smm rar->bytes_remaining -= bytes_avail; 1857231200Smm rar->bytes_unconsumed = bytes_avail; 1858231200Smm /* Calculate File CRC. */ 1859248616Smm rar->crc_calculated = crc32(rar->crc_calculated, *buff, 1860248616Smm (unsigned)bytes_avail); 1861231200Smm return (ARCHIVE_OK); 1862231200Smm} 1863231200Smm 1864231200Smmstatic int 1865231200Smmread_data_compressed(struct archive_read *a, const void **buff, size_t *size, 1866231200Smm int64_t *offset) 1867231200Smm{ 1868231200Smm struct rar *rar; 1869231200Smm int64_t start, end, actualend; 1870231200Smm size_t bs; 1871231200Smm int ret = (ARCHIVE_OK), sym, code, lzss_offset, length, i; 1872231200Smm 1873231200Smm rar = (struct rar *)(a->format->data); 1874231200Smm 1875231200Smm do { 1876231200Smm if (!rar->valid) 1877231200Smm return (ARCHIVE_FATAL); 1878231200Smm if (rar->ppmd_eod || 1879231200Smm (rar->dictionary_size && rar->offset >= rar->unp_size)) 1880231200Smm { 1881231200Smm if (rar->unp_offset > 0) { 1882231200Smm /* 1883231200Smm * We have unprocessed extracted data. write it out. 1884231200Smm */ 1885231200Smm *buff = rar->unp_buffer; 1886231200Smm *size = rar->unp_offset; 1887231200Smm *offset = rar->offset_outgoing; 1888231200Smm rar->offset_outgoing += *size; 1889231200Smm /* Calculate File CRC. */ 1890248616Smm rar->crc_calculated = crc32(rar->crc_calculated, *buff, 1891248616Smm (unsigned)*size); 1892231200Smm rar->unp_offset = 0; 1893231200Smm return (ARCHIVE_OK); 1894231200Smm } 1895231200Smm *buff = NULL; 1896231200Smm *size = 0; 1897231200Smm *offset = rar->offset; 1898231200Smm if (rar->file_crc != rar->crc_calculated) { 1899231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1900231200Smm "File CRC error"); 1901231200Smm return (ARCHIVE_FATAL); 1902231200Smm } 1903231200Smm rar->entry_eof = 1; 1904231200Smm return (ARCHIVE_EOF); 1905231200Smm } 1906231200Smm 1907231200Smm if (!rar->is_ppmd_block && rar->dictionary_size && rar->bytes_uncopied > 0) 1908231200Smm { 1909231200Smm if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset)) 1910231200Smm bs = rar->unp_buffer_size - rar->unp_offset; 1911231200Smm else 1912238856Smm bs = (size_t)rar->bytes_uncopied; 1913248616Smm ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs); 1914231200Smm if (ret != ARCHIVE_OK) 1915231200Smm return (ret); 1916231200Smm rar->offset += bs; 1917231200Smm rar->bytes_uncopied -= bs; 1918231200Smm if (*buff != NULL) { 1919231200Smm rar->unp_offset = 0; 1920231200Smm *size = rar->unp_buffer_size; 1921231200Smm *offset = rar->offset_outgoing; 1922231200Smm rar->offset_outgoing += *size; 1923231200Smm /* Calculate File CRC. */ 1924248616Smm rar->crc_calculated = crc32(rar->crc_calculated, *buff, 1925248616Smm (unsigned)*size); 1926231200Smm return (ret); 1927231200Smm } 1928231200Smm continue; 1929231200Smm } 1930231200Smm 1931231200Smm if (!rar->br.next_in && 1932231200Smm (ret = rar_br_preparation(a, &(rar->br))) < ARCHIVE_WARN) 1933231200Smm return (ret); 1934231200Smm if (rar->start_new_table && ((ret = parse_codes(a)) < (ARCHIVE_WARN))) 1935231200Smm return (ret); 1936231200Smm 1937231200Smm if (rar->is_ppmd_block) 1938231200Smm { 1939231200Smm if ((sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1940231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1941231200Smm { 1942231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1943231200Smm "Invalid symbol"); 1944231200Smm return (ARCHIVE_FATAL); 1945231200Smm } 1946231200Smm if(sym != rar->ppmd_escape) 1947231200Smm { 1948231200Smm lzss_emit_literal(rar, sym); 1949231200Smm rar->bytes_uncopied++; 1950231200Smm } 1951231200Smm else 1952231200Smm { 1953231200Smm if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1954231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1955231200Smm { 1956231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1957231200Smm "Invalid symbol"); 1958231200Smm return (ARCHIVE_FATAL); 1959231200Smm } 1960231200Smm 1961231200Smm switch(code) 1962231200Smm { 1963231200Smm case 0: 1964231200Smm rar->start_new_table = 1; 1965231200Smm return read_data_compressed(a, buff, size, offset); 1966231200Smm 1967231200Smm case 2: 1968231200Smm rar->ppmd_eod = 1;/* End Of ppmd Data. */ 1969231200Smm continue; 1970231200Smm 1971231200Smm case 3: 1972231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1973231200Smm "Parsing filters is unsupported."); 1974231200Smm return (ARCHIVE_FAILED); 1975231200Smm 1976231200Smm case 4: 1977231200Smm lzss_offset = 0; 1978231200Smm for (i = 2; i >= 0; i--) 1979231200Smm { 1980231200Smm if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1981231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1982231200Smm { 1983231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1984231200Smm "Invalid symbol"); 1985231200Smm return (ARCHIVE_FATAL); 1986231200Smm } 1987231200Smm lzss_offset |= code << (i * 8); 1988231200Smm } 1989231200Smm if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1990231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1991231200Smm { 1992231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1993231200Smm "Invalid symbol"); 1994231200Smm return (ARCHIVE_FATAL); 1995231200Smm } 1996231200Smm lzss_emit_match(rar, lzss_offset + 2, length + 32); 1997231200Smm rar->bytes_uncopied += length + 32; 1998231200Smm break; 1999231200Smm 2000231200Smm case 5: 2001231200Smm if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 2002231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 2003231200Smm { 2004231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2005231200Smm "Invalid symbol"); 2006231200Smm return (ARCHIVE_FATAL); 2007231200Smm } 2008231200Smm lzss_emit_match(rar, 1, length + 4); 2009231200Smm rar->bytes_uncopied += length + 4; 2010231200Smm break; 2011231200Smm 2012231200Smm default: 2013231200Smm lzss_emit_literal(rar, sym); 2014231200Smm rar->bytes_uncopied++; 2015231200Smm } 2016231200Smm } 2017231200Smm } 2018231200Smm else 2019231200Smm { 2020231200Smm start = rar->offset; 2021231200Smm end = start + rar->dictionary_size; 2022231200Smm rar->filterstart = INT64_MAX; 2023231200Smm 2024231200Smm if ((actualend = expand(a, end)) < 0) 2025231200Smm return ((int)actualend); 2026231200Smm 2027231200Smm rar->bytes_uncopied = actualend - start; 2028231200Smm if (rar->bytes_uncopied == 0) { 2029231200Smm /* Broken RAR files cause this case. 2030231200Smm * NOTE: If this case were possible on a normal RAR file 2031231200Smm * we would find out where it was actually bad and 2032231200Smm * what we would do to solve it. */ 2033231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2034231200Smm "Internal error extracting RAR file"); 2035231200Smm return (ARCHIVE_FATAL); 2036231200Smm } 2037231200Smm } 2038231200Smm if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset)) 2039231200Smm bs = rar->unp_buffer_size - rar->unp_offset; 2040231200Smm else 2041238856Smm bs = (size_t)rar->bytes_uncopied; 2042248616Smm ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs); 2043231200Smm if (ret != ARCHIVE_OK) 2044231200Smm return (ret); 2045231200Smm rar->offset += bs; 2046231200Smm rar->bytes_uncopied -= bs; 2047231200Smm /* 2048231200Smm * If *buff is NULL, it means unp_buffer is not full. 2049231200Smm * So we have to continue extracting a RAR file. 2050231200Smm */ 2051231200Smm } while (*buff == NULL); 2052231200Smm 2053231200Smm rar->unp_offset = 0; 2054231200Smm *size = rar->unp_buffer_size; 2055231200Smm *offset = rar->offset_outgoing; 2056231200Smm rar->offset_outgoing += *size; 2057231200Smm /* Calculate File CRC. */ 2058248616Smm rar->crc_calculated = crc32(rar->crc_calculated, *buff, (unsigned)*size); 2059231200Smm return ret; 2060231200Smm} 2061231200Smm 2062231200Smmstatic int 2063231200Smmparse_codes(struct archive_read *a) 2064231200Smm{ 2065231200Smm int i, j, val, n, r; 2066231200Smm unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags; 2067231200Smm unsigned int maxorder; 2068231200Smm struct huffman_code precode; 2069231200Smm struct rar *rar = (struct rar *)(a->format->data); 2070231200Smm struct rar_br *br = &(rar->br); 2071231200Smm 2072231200Smm free_codes(a); 2073231200Smm 2074231200Smm /* Skip to the next byte */ 2075231200Smm rar_br_consume_unalined_bits(br); 2076231200Smm 2077231200Smm /* PPMd block flag */ 2078231200Smm if (!rar_br_read_ahead(a, br, 1)) 2079231200Smm goto truncated_data; 2080231200Smm if ((rar->is_ppmd_block = rar_br_bits(br, 1)) != 0) 2081231200Smm { 2082231200Smm rar_br_consume(br, 1); 2083231200Smm if (!rar_br_read_ahead(a, br, 7)) 2084231200Smm goto truncated_data; 2085231200Smm ppmd_flags = rar_br_bits(br, 7); 2086231200Smm rar_br_consume(br, 7); 2087231200Smm 2088231200Smm /* Memory is allocated in MB */ 2089231200Smm if (ppmd_flags & 0x20) 2090231200Smm { 2091231200Smm if (!rar_br_read_ahead(a, br, 8)) 2092231200Smm goto truncated_data; 2093231200Smm rar->dictionary_size = (rar_br_bits(br, 8) + 1) << 20; 2094231200Smm rar_br_consume(br, 8); 2095231200Smm } 2096231200Smm 2097231200Smm if (ppmd_flags & 0x40) 2098231200Smm { 2099231200Smm if (!rar_br_read_ahead(a, br, 8)) 2100231200Smm goto truncated_data; 2101231200Smm rar->ppmd_escape = rar->ppmd7_context.InitEsc = rar_br_bits(br, 8); 2102231200Smm rar_br_consume(br, 8); 2103231200Smm } 2104231200Smm else 2105231200Smm rar->ppmd_escape = 2; 2106231200Smm 2107231200Smm if (ppmd_flags & 0x20) 2108231200Smm { 2109231200Smm maxorder = (ppmd_flags & 0x1F) + 1; 2110231200Smm if(maxorder > 16) 2111231200Smm maxorder = 16 + (maxorder - 16) * 3; 2112231200Smm 2113231200Smm if (maxorder == 1) 2114231200Smm { 2115231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2116231200Smm "Truncated RAR file data"); 2117231200Smm return (ARCHIVE_FATAL); 2118231200Smm } 2119231200Smm 2120231200Smm /* Make sure ppmd7_contest is freed before Ppmd7_Construct 2121231200Smm * because reading a broken file cause this abnormal sequence. */ 2122231200Smm __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context, &g_szalloc); 2123231200Smm 2124231200Smm rar->bytein.a = a; 2125231200Smm rar->bytein.Read = &ppmd_read; 2126231200Smm __archive_ppmd7_functions.PpmdRAR_RangeDec_CreateVTable(&rar->range_dec); 2127231200Smm rar->range_dec.Stream = &rar->bytein; 2128231200Smm __archive_ppmd7_functions.Ppmd7_Construct(&rar->ppmd7_context); 2129231200Smm 2130231200Smm if (!__archive_ppmd7_functions.Ppmd7_Alloc(&rar->ppmd7_context, 2131231200Smm rar->dictionary_size, &g_szalloc)) 2132231200Smm { 2133231200Smm archive_set_error(&a->archive, ENOMEM, 2134231200Smm "Out of memory"); 2135231200Smm return (ARCHIVE_FATAL); 2136231200Smm } 2137231200Smm if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec)) 2138231200Smm { 2139231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2140231200Smm "Unable to initialize PPMd range decoder"); 2141231200Smm return (ARCHIVE_FATAL); 2142231200Smm } 2143231200Smm __archive_ppmd7_functions.Ppmd7_Init(&rar->ppmd7_context, maxorder); 2144231200Smm rar->ppmd_valid = 1; 2145231200Smm } 2146231200Smm else 2147231200Smm { 2148231200Smm if (!rar->ppmd_valid) { 2149231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2150231200Smm "Invalid PPMd sequence"); 2151231200Smm return (ARCHIVE_FATAL); 2152231200Smm } 2153231200Smm if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec)) 2154231200Smm { 2155231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2156231200Smm "Unable to initialize PPMd range decoder"); 2157231200Smm return (ARCHIVE_FATAL); 2158231200Smm } 2159231200Smm } 2160231200Smm } 2161231200Smm else 2162231200Smm { 2163231200Smm rar_br_consume(br, 1); 2164231200Smm 2165231200Smm /* Keep existing table flag */ 2166231200Smm if (!rar_br_read_ahead(a, br, 1)) 2167231200Smm goto truncated_data; 2168231200Smm if (!rar_br_bits(br, 1)) 2169231200Smm memset(rar->lengthtable, 0, sizeof(rar->lengthtable)); 2170231200Smm rar_br_consume(br, 1); 2171231200Smm 2172231200Smm memset(&bitlengths, 0, sizeof(bitlengths)); 2173231200Smm for (i = 0; i < MAX_SYMBOLS;) 2174231200Smm { 2175231200Smm if (!rar_br_read_ahead(a, br, 4)) 2176231200Smm goto truncated_data; 2177231200Smm bitlengths[i++] = rar_br_bits(br, 4); 2178231200Smm rar_br_consume(br, 4); 2179231200Smm if (bitlengths[i-1] == 0xF) 2180231200Smm { 2181231200Smm if (!rar_br_read_ahead(a, br, 4)) 2182231200Smm goto truncated_data; 2183231200Smm zerocount = rar_br_bits(br, 4); 2184231200Smm rar_br_consume(br, 4); 2185231200Smm if (zerocount) 2186231200Smm { 2187231200Smm i--; 2188231200Smm for (j = 0; j < zerocount + 2 && i < MAX_SYMBOLS; j++) 2189231200Smm bitlengths[i++] = 0; 2190231200Smm } 2191231200Smm } 2192231200Smm } 2193231200Smm 2194231200Smm memset(&precode, 0, sizeof(precode)); 2195231200Smm r = create_code(a, &precode, bitlengths, MAX_SYMBOLS, MAX_SYMBOL_LENGTH); 2196231200Smm if (r != ARCHIVE_OK) { 2197231200Smm free(precode.tree); 2198231200Smm free(precode.table); 2199231200Smm return (r); 2200231200Smm } 2201231200Smm 2202231200Smm for (i = 0; i < HUFFMAN_TABLE_SIZE;) 2203231200Smm { 2204231200Smm if ((val = read_next_symbol(a, &precode)) < 0) { 2205231200Smm free(precode.tree); 2206231200Smm free(precode.table); 2207231200Smm return (ARCHIVE_FATAL); 2208231200Smm } 2209231200Smm if (val < 16) 2210231200Smm { 2211231200Smm rar->lengthtable[i] = (rar->lengthtable[i] + val) & 0xF; 2212231200Smm i++; 2213231200Smm } 2214231200Smm else if (val < 18) 2215231200Smm { 2216231200Smm if (i == 0) 2217231200Smm { 2218231200Smm free(precode.tree); 2219231200Smm free(precode.table); 2220231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2221231200Smm "Internal error extracting RAR file."); 2222231200Smm return (ARCHIVE_FATAL); 2223231200Smm } 2224231200Smm 2225231200Smm if(val == 16) { 2226231200Smm if (!rar_br_read_ahead(a, br, 3)) { 2227231200Smm free(precode.tree); 2228231200Smm free(precode.table); 2229231200Smm goto truncated_data; 2230231200Smm } 2231231200Smm n = rar_br_bits(br, 3) + 3; 2232231200Smm rar_br_consume(br, 3); 2233231200Smm } else { 2234231200Smm if (!rar_br_read_ahead(a, br, 7)) { 2235231200Smm free(precode.tree); 2236231200Smm free(precode.table); 2237231200Smm goto truncated_data; 2238231200Smm } 2239231200Smm n = rar_br_bits(br, 7) + 11; 2240231200Smm rar_br_consume(br, 7); 2241231200Smm } 2242231200Smm 2243231200Smm for (j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++) 2244231200Smm { 2245231200Smm rar->lengthtable[i] = rar->lengthtable[i-1]; 2246231200Smm i++; 2247231200Smm } 2248231200Smm } 2249231200Smm else 2250231200Smm { 2251231200Smm if(val == 18) { 2252231200Smm if (!rar_br_read_ahead(a, br, 3)) { 2253231200Smm free(precode.tree); 2254231200Smm free(precode.table); 2255231200Smm goto truncated_data; 2256231200Smm } 2257231200Smm n = rar_br_bits(br, 3) + 3; 2258231200Smm rar_br_consume(br, 3); 2259231200Smm } else { 2260231200Smm if (!rar_br_read_ahead(a, br, 7)) { 2261231200Smm free(precode.tree); 2262231200Smm free(precode.table); 2263231200Smm goto truncated_data; 2264231200Smm } 2265231200Smm n = rar_br_bits(br, 7) + 11; 2266231200Smm rar_br_consume(br, 7); 2267231200Smm } 2268231200Smm 2269231200Smm for(j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++) 2270231200Smm rar->lengthtable[i++] = 0; 2271231200Smm } 2272231200Smm } 2273231200Smm free(precode.tree); 2274231200Smm free(precode.table); 2275231200Smm 2276231200Smm r = create_code(a, &rar->maincode, &rar->lengthtable[0], MAINCODE_SIZE, 2277231200Smm MAX_SYMBOL_LENGTH); 2278231200Smm if (r != ARCHIVE_OK) 2279231200Smm return (r); 2280231200Smm r = create_code(a, &rar->offsetcode, &rar->lengthtable[MAINCODE_SIZE], 2281231200Smm OFFSETCODE_SIZE, MAX_SYMBOL_LENGTH); 2282231200Smm if (r != ARCHIVE_OK) 2283231200Smm return (r); 2284231200Smm r = create_code(a, &rar->lowoffsetcode, 2285231200Smm &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE], 2286231200Smm LOWOFFSETCODE_SIZE, MAX_SYMBOL_LENGTH); 2287231200Smm if (r != ARCHIVE_OK) 2288231200Smm return (r); 2289231200Smm r = create_code(a, &rar->lengthcode, 2290231200Smm &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE + 2291231200Smm LOWOFFSETCODE_SIZE], LENGTHCODE_SIZE, MAX_SYMBOL_LENGTH); 2292231200Smm if (r != ARCHIVE_OK) 2293231200Smm return (r); 2294231200Smm } 2295231200Smm 2296231200Smm if (!rar->dictionary_size || !rar->lzss.window) 2297231200Smm { 2298231200Smm /* Seems as though dictionary sizes are not used. Even so, minimize 2299231200Smm * memory usage as much as possible. 2300231200Smm */ 2301248616Smm void *new_window; 2302248616Smm unsigned int new_size; 2303248616Smm 2304231200Smm if (rar->unp_size >= DICTIONARY_MAX_SIZE) 2305248616Smm new_size = DICTIONARY_MAX_SIZE; 2306231200Smm else 2307248616Smm new_size = rar_fls((unsigned int)rar->unp_size) << 1; 2308248616Smm new_window = realloc(rar->lzss.window, new_size); 2309248616Smm if (new_window == NULL) { 2310231200Smm archive_set_error(&a->archive, ENOMEM, 2311231200Smm "Unable to allocate memory for uncompressed data."); 2312231200Smm return (ARCHIVE_FATAL); 2313231200Smm } 2314248616Smm rar->lzss.window = (unsigned char *)new_window; 2315248616Smm rar->dictionary_size = new_size; 2316231200Smm memset(rar->lzss.window, 0, rar->dictionary_size); 2317231200Smm rar->lzss.mask = rar->dictionary_size - 1; 2318231200Smm } 2319231200Smm 2320231200Smm rar->start_new_table = 0; 2321231200Smm return (ARCHIVE_OK); 2322231200Smmtruncated_data: 2323231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2324231200Smm "Truncated RAR file data"); 2325231200Smm rar->valid = 0; 2326231200Smm return (ARCHIVE_FATAL); 2327231200Smm} 2328231200Smm 2329231200Smmstatic void 2330231200Smmfree_codes(struct archive_read *a) 2331231200Smm{ 2332231200Smm struct rar *rar = (struct rar *)(a->format->data); 2333231200Smm free(rar->maincode.tree); 2334231200Smm free(rar->offsetcode.tree); 2335231200Smm free(rar->lowoffsetcode.tree); 2336231200Smm free(rar->lengthcode.tree); 2337231200Smm free(rar->maincode.table); 2338231200Smm free(rar->offsetcode.table); 2339231200Smm free(rar->lowoffsetcode.table); 2340231200Smm free(rar->lengthcode.table); 2341231200Smm memset(&rar->maincode, 0, sizeof(rar->maincode)); 2342231200Smm memset(&rar->offsetcode, 0, sizeof(rar->offsetcode)); 2343231200Smm memset(&rar->lowoffsetcode, 0, sizeof(rar->lowoffsetcode)); 2344231200Smm memset(&rar->lengthcode, 0, sizeof(rar->lengthcode)); 2345231200Smm} 2346231200Smm 2347231200Smm 2348231200Smmstatic int 2349231200Smmread_next_symbol(struct archive_read *a, struct huffman_code *code) 2350231200Smm{ 2351231200Smm unsigned char bit; 2352231200Smm unsigned int bits; 2353231200Smm int length, value, node; 2354231200Smm struct rar *rar; 2355231200Smm struct rar_br *br; 2356231200Smm 2357231200Smm if (!code->table) 2358231200Smm { 2359231200Smm if (make_table(a, code) != (ARCHIVE_OK)) 2360231200Smm return -1; 2361231200Smm } 2362231200Smm 2363231200Smm rar = (struct rar *)(a->format->data); 2364231200Smm br = &(rar->br); 2365231200Smm 2366231200Smm /* Look ahead (peek) at bits */ 2367231200Smm if (!rar_br_read_ahead(a, br, code->tablesize)) { 2368231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2369231200Smm "Truncated RAR file data"); 2370231200Smm rar->valid = 0; 2371231200Smm return -1; 2372231200Smm } 2373231200Smm bits = rar_br_bits(br, code->tablesize); 2374231200Smm 2375231200Smm length = code->table[bits].length; 2376231200Smm value = code->table[bits].value; 2377231200Smm 2378231200Smm if (length < 0) 2379231200Smm { 2380231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2381231200Smm "Invalid prefix code in bitstream"); 2382231200Smm return -1; 2383231200Smm } 2384231200Smm 2385231200Smm if (length <= code->tablesize) 2386231200Smm { 2387231200Smm /* Skip length bits */ 2388231200Smm rar_br_consume(br, length); 2389231200Smm return value; 2390231200Smm } 2391231200Smm 2392231200Smm /* Skip tablesize bits */ 2393231200Smm rar_br_consume(br, code->tablesize); 2394231200Smm 2395231200Smm node = value; 2396231200Smm while (!(code->tree[node].branches[0] == 2397231200Smm code->tree[node].branches[1])) 2398231200Smm { 2399231200Smm if (!rar_br_read_ahead(a, br, 1)) { 2400231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2401231200Smm "Truncated RAR file data"); 2402231200Smm rar->valid = 0; 2403231200Smm return -1; 2404231200Smm } 2405231200Smm bit = rar_br_bits(br, 1); 2406231200Smm rar_br_consume(br, 1); 2407231200Smm 2408231200Smm if (code->tree[node].branches[bit] < 0) 2409231200Smm { 2410231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2411231200Smm "Invalid prefix code in bitstream"); 2412231200Smm return -1; 2413231200Smm } 2414231200Smm node = code->tree[node].branches[bit]; 2415231200Smm } 2416231200Smm 2417231200Smm return code->tree[node].branches[0]; 2418231200Smm} 2419231200Smm 2420231200Smmstatic int 2421231200Smmcreate_code(struct archive_read *a, struct huffman_code *code, 2422231200Smm unsigned char *lengths, int numsymbols, char maxlength) 2423231200Smm{ 2424231200Smm int i, j, codebits = 0, symbolsleft = numsymbols; 2425231200Smm 2426299529Smm code->numentries = 0; 2427299529Smm code->numallocatedentries = 0; 2428231200Smm if (new_node(code) < 0) { 2429231200Smm archive_set_error(&a->archive, ENOMEM, 2430231200Smm "Unable to allocate memory for node data."); 2431231200Smm return (ARCHIVE_FATAL); 2432231200Smm } 2433231200Smm code->numentries = 1; 2434231200Smm code->minlength = INT_MAX; 2435231200Smm code->maxlength = INT_MIN; 2436231200Smm codebits = 0; 2437231200Smm for(i = 1; i <= maxlength; i++) 2438231200Smm { 2439231200Smm for(j = 0; j < numsymbols; j++) 2440231200Smm { 2441231200Smm if (lengths[j] != i) continue; 2442231200Smm if (add_value(a, code, j, codebits, i) != ARCHIVE_OK) 2443231200Smm return (ARCHIVE_FATAL); 2444231200Smm codebits++; 2445231200Smm if (--symbolsleft <= 0) { break; break; } 2446231200Smm } 2447231200Smm codebits <<= 1; 2448231200Smm } 2449231200Smm return (ARCHIVE_OK); 2450231200Smm} 2451231200Smm 2452231200Smmstatic int 2453231200Smmadd_value(struct archive_read *a, struct huffman_code *code, int value, 2454231200Smm int codebits, int length) 2455231200Smm{ 2456231200Smm int repeatpos, lastnode, bitpos, bit, repeatnode, nextnode; 2457231200Smm 2458231200Smm free(code->table); 2459231200Smm code->table = NULL; 2460231200Smm 2461231200Smm if(length > code->maxlength) 2462231200Smm code->maxlength = length; 2463231200Smm if(length < code->minlength) 2464231200Smm code->minlength = length; 2465231200Smm 2466231200Smm repeatpos = -1; 2467231200Smm if (repeatpos == 0 || (repeatpos >= 0 2468231200Smm && (((codebits >> (repeatpos - 1)) & 3) == 0 2469231200Smm || ((codebits >> (repeatpos - 1)) & 3) == 3))) 2470231200Smm { 2471231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2472231200Smm "Invalid repeat position"); 2473231200Smm return (ARCHIVE_FATAL); 2474231200Smm } 2475231200Smm 2476231200Smm lastnode = 0; 2477231200Smm for (bitpos = length - 1; bitpos >= 0; bitpos--) 2478231200Smm { 2479231200Smm bit = (codebits >> bitpos) & 1; 2480231200Smm 2481231200Smm /* Leaf node check */ 2482231200Smm if (code->tree[lastnode].branches[0] == 2483231200Smm code->tree[lastnode].branches[1]) 2484231200Smm { 2485231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2486231200Smm "Prefix found"); 2487231200Smm return (ARCHIVE_FATAL); 2488231200Smm } 2489231200Smm 2490231200Smm if (bitpos == repeatpos) 2491231200Smm { 2492231200Smm /* Open branch check */ 2493231200Smm if (!(code->tree[lastnode].branches[bit] < 0)) 2494231200Smm { 2495231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2496231200Smm "Invalid repeating code"); 2497231200Smm return (ARCHIVE_FATAL); 2498231200Smm } 2499231200Smm 2500231200Smm if ((repeatnode = new_node(code)) < 0) { 2501231200Smm archive_set_error(&a->archive, ENOMEM, 2502231200Smm "Unable to allocate memory for node data."); 2503231200Smm return (ARCHIVE_FATAL); 2504231200Smm } 2505231200Smm if ((nextnode = new_node(code)) < 0) { 2506231200Smm archive_set_error(&a->archive, ENOMEM, 2507231200Smm "Unable to allocate memory for node data."); 2508231200Smm return (ARCHIVE_FATAL); 2509231200Smm } 2510231200Smm 2511231200Smm /* Set branches */ 2512231200Smm code->tree[lastnode].branches[bit] = repeatnode; 2513231200Smm code->tree[repeatnode].branches[bit] = repeatnode; 2514231200Smm code->tree[repeatnode].branches[bit^1] = nextnode; 2515231200Smm lastnode = nextnode; 2516231200Smm 2517231200Smm bitpos++; /* terminating bit already handled, skip it */ 2518231200Smm } 2519231200Smm else 2520231200Smm { 2521231200Smm /* Open branch check */ 2522231200Smm if (code->tree[lastnode].branches[bit] < 0) 2523231200Smm { 2524231200Smm if (new_node(code) < 0) { 2525231200Smm archive_set_error(&a->archive, ENOMEM, 2526231200Smm "Unable to allocate memory for node data."); 2527231200Smm return (ARCHIVE_FATAL); 2528231200Smm } 2529231200Smm code->tree[lastnode].branches[bit] = code->numentries++; 2530231200Smm } 2531231200Smm 2532231200Smm /* set to branch */ 2533231200Smm lastnode = code->tree[lastnode].branches[bit]; 2534231200Smm } 2535231200Smm } 2536231200Smm 2537231200Smm if (!(code->tree[lastnode].branches[0] == -1 2538231200Smm && code->tree[lastnode].branches[1] == -2)) 2539231200Smm { 2540231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2541231200Smm "Prefix found"); 2542231200Smm return (ARCHIVE_FATAL); 2543231200Smm } 2544231200Smm 2545231200Smm /* Set leaf value */ 2546231200Smm code->tree[lastnode].branches[0] = value; 2547231200Smm code->tree[lastnode].branches[1] = value; 2548231200Smm 2549231200Smm return (ARCHIVE_OK); 2550231200Smm} 2551231200Smm 2552231200Smmstatic int 2553231200Smmnew_node(struct huffman_code *code) 2554231200Smm{ 2555248616Smm void *new_tree; 2556299529Smm if (code->numallocatedentries == code->numentries) { 2557299529Smm int new_num_entries = 256; 2558299529Smm if (code->numentries > 0) { 2559299529Smm new_num_entries = code->numentries * 2; 2560299529Smm } 2561299529Smm new_tree = realloc(code->tree, new_num_entries * sizeof(*code->tree)); 2562299529Smm if (new_tree == NULL) 2563299529Smm return (-1); 2564299529Smm code->tree = (struct huffman_tree_node *)new_tree; 2565299529Smm code->numallocatedentries = new_num_entries; 2566299529Smm } 2567231200Smm code->tree[code->numentries].branches[0] = -1; 2568231200Smm code->tree[code->numentries].branches[1] = -2; 2569231200Smm return 1; 2570231200Smm} 2571231200Smm 2572231200Smmstatic int 2573231200Smmmake_table(struct archive_read *a, struct huffman_code *code) 2574231200Smm{ 2575231200Smm if (code->maxlength < code->minlength || code->maxlength > 10) 2576231200Smm code->tablesize = 10; 2577231200Smm else 2578231200Smm code->tablesize = code->maxlength; 2579231200Smm 2580231200Smm code->table = 2581248616Smm (struct huffman_table_entry *)calloc(1, sizeof(*code->table) 2582248616Smm * ((size_t)1 << code->tablesize)); 2583231200Smm 2584231200Smm return make_table_recurse(a, code, 0, code->table, 0, code->tablesize); 2585231200Smm} 2586231200Smm 2587231200Smmstatic int 2588231200Smmmake_table_recurse(struct archive_read *a, struct huffman_code *code, int node, 2589231200Smm struct huffman_table_entry *table, int depth, 2590231200Smm int maxdepth) 2591231200Smm{ 2592231200Smm int currtablesize, i, ret = (ARCHIVE_OK); 2593231200Smm 2594231200Smm if (!code->tree) 2595231200Smm { 2596231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2597231200Smm "Huffman tree was not created."); 2598231200Smm return (ARCHIVE_FATAL); 2599231200Smm } 2600231200Smm if (node < 0 || node >= code->numentries) 2601231200Smm { 2602231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2603231200Smm "Invalid location to Huffman tree specified."); 2604231200Smm return (ARCHIVE_FATAL); 2605231200Smm } 2606231200Smm 2607231200Smm currtablesize = 1 << (maxdepth - depth); 2608231200Smm 2609231200Smm if (code->tree[node].branches[0] == 2610231200Smm code->tree[node].branches[1]) 2611231200Smm { 2612231200Smm for(i = 0; i < currtablesize; i++) 2613231200Smm { 2614231200Smm table[i].length = depth; 2615231200Smm table[i].value = code->tree[node].branches[0]; 2616231200Smm } 2617231200Smm } 2618231200Smm else if (node < 0) 2619231200Smm { 2620231200Smm for(i = 0; i < currtablesize; i++) 2621231200Smm table[i].length = -1; 2622231200Smm } 2623231200Smm else 2624231200Smm { 2625231200Smm if(depth == maxdepth) 2626231200Smm { 2627231200Smm table[0].length = maxdepth + 1; 2628231200Smm table[0].value = node; 2629231200Smm } 2630231200Smm else 2631231200Smm { 2632231200Smm ret |= make_table_recurse(a, code, code->tree[node].branches[0], table, 2633231200Smm depth + 1, maxdepth); 2634231200Smm ret |= make_table_recurse(a, code, code->tree[node].branches[1], 2635231200Smm table + currtablesize / 2, depth + 1, maxdepth); 2636231200Smm } 2637231200Smm } 2638231200Smm return ret; 2639231200Smm} 2640231200Smm 2641231200Smmstatic int64_t 2642231200Smmexpand(struct archive_read *a, int64_t end) 2643231200Smm{ 2644231200Smm static const unsigned char lengthbases[] = 2645231200Smm { 0, 1, 2, 3, 4, 5, 6, 2646231200Smm 7, 8, 10, 12, 14, 16, 20, 2647231200Smm 24, 28, 32, 40, 48, 56, 64, 2648231200Smm 80, 96, 112, 128, 160, 192, 224 }; 2649231200Smm static const unsigned char lengthbits[] = 2650231200Smm { 0, 0, 0, 0, 0, 0, 0, 2651231200Smm 0, 1, 1, 1, 1, 2, 2, 2652231200Smm 2, 2, 3, 3, 3, 3, 4, 2653231200Smm 4, 4, 4, 5, 5, 5, 5 }; 2654231200Smm static const unsigned int offsetbases[] = 2655231200Smm { 0, 1, 2, 3, 4, 6, 2656231200Smm 8, 12, 16, 24, 32, 48, 2657231200Smm 64, 96, 128, 192, 256, 384, 2658231200Smm 512, 768, 1024, 1536, 2048, 3072, 2659231200Smm 4096, 6144, 8192, 12288, 16384, 24576, 2660231200Smm 32768, 49152, 65536, 98304, 131072, 196608, 2661231200Smm 262144, 327680, 393216, 458752, 524288, 589824, 2662231200Smm 655360, 720896, 786432, 851968, 917504, 983040, 2663231200Smm 1048576, 1310720, 1572864, 1835008, 2097152, 2359296, 2664231200Smm 2621440, 2883584, 3145728, 3407872, 3670016, 3932160 }; 2665231200Smm static const unsigned char offsetbits[] = 2666231200Smm { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 2667231200Smm 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 2668231200Smm 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 2669231200Smm 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 2670231200Smm 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 }; 2671231200Smm static const unsigned char shortbases[] = 2672231200Smm { 0, 4, 8, 16, 32, 64, 128, 192 }; 2673231200Smm static const unsigned char shortbits[] = 2674231200Smm { 2, 2, 3, 4, 5, 6, 6, 6 }; 2675231200Smm 2676231200Smm int symbol, offs, len, offsindex, lensymbol, i, offssymbol, lowoffsetsymbol; 2677231200Smm unsigned char newfile; 2678231200Smm struct rar *rar = (struct rar *)(a->format->data); 2679231200Smm struct rar_br *br = &(rar->br); 2680231200Smm 2681231200Smm if (rar->filterstart < end) 2682231200Smm end = rar->filterstart; 2683231200Smm 2684231200Smm while (1) 2685231200Smm { 2686231200Smm if (rar->output_last_match && 2687231200Smm lzss_position(&rar->lzss) + rar->lastlength <= end) 2688231200Smm { 2689231200Smm lzss_emit_match(rar, rar->lastoffset, rar->lastlength); 2690231200Smm rar->output_last_match = 0; 2691231200Smm } 2692231200Smm 2693231200Smm if(rar->is_ppmd_block || rar->output_last_match || 2694231200Smm lzss_position(&rar->lzss) >= end) 2695231200Smm return lzss_position(&rar->lzss); 2696231200Smm 2697231200Smm if ((symbol = read_next_symbol(a, &rar->maincode)) < 0) 2698231200Smm return (ARCHIVE_FATAL); 2699231200Smm rar->output_last_match = 0; 2700299529Smm 2701231200Smm if (symbol < 256) 2702231200Smm { 2703231200Smm lzss_emit_literal(rar, symbol); 2704231200Smm continue; 2705231200Smm } 2706231200Smm else if (symbol == 256) 2707231200Smm { 2708231200Smm if (!rar_br_read_ahead(a, br, 1)) 2709231200Smm goto truncated_data; 2710231200Smm newfile = !rar_br_bits(br, 1); 2711231200Smm rar_br_consume(br, 1); 2712231200Smm 2713231200Smm if(newfile) 2714231200Smm { 2715231200Smm rar->start_new_block = 1; 2716231200Smm if (!rar_br_read_ahead(a, br, 1)) 2717231200Smm goto truncated_data; 2718231200Smm rar->start_new_table = rar_br_bits(br, 1); 2719231200Smm rar_br_consume(br, 1); 2720231200Smm return lzss_position(&rar->lzss); 2721231200Smm } 2722231200Smm else 2723231200Smm { 2724231200Smm if (parse_codes(a) != ARCHIVE_OK) 2725231200Smm return (ARCHIVE_FATAL); 2726231200Smm continue; 2727231200Smm } 2728231200Smm } 2729231200Smm else if(symbol==257) 2730231200Smm { 2731231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 2732231200Smm "Parsing filters is unsupported."); 2733231200Smm return (ARCHIVE_FAILED); 2734231200Smm } 2735231200Smm else if(symbol==258) 2736231200Smm { 2737231200Smm if(rar->lastlength == 0) 2738231200Smm continue; 2739231200Smm 2740231200Smm offs = rar->lastoffset; 2741231200Smm len = rar->lastlength; 2742231200Smm } 2743231200Smm else if (symbol <= 262) 2744231200Smm { 2745231200Smm offsindex = symbol - 259; 2746231200Smm offs = rar->oldoffset[offsindex]; 2747231200Smm 2748231200Smm if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0) 2749231200Smm goto bad_data; 2750232153Smm if (lensymbol > (int)(sizeof(lengthbases)/sizeof(lengthbases[0]))) 2751231200Smm goto bad_data; 2752232153Smm if (lensymbol > (int)(sizeof(lengthbits)/sizeof(lengthbits[0]))) 2753231200Smm goto bad_data; 2754231200Smm len = lengthbases[lensymbol] + 2; 2755231200Smm if (lengthbits[lensymbol] > 0) { 2756231200Smm if (!rar_br_read_ahead(a, br, lengthbits[lensymbol])) 2757231200Smm goto truncated_data; 2758231200Smm len += rar_br_bits(br, lengthbits[lensymbol]); 2759231200Smm rar_br_consume(br, lengthbits[lensymbol]); 2760231200Smm } 2761231200Smm 2762231200Smm for (i = offsindex; i > 0; i--) 2763231200Smm rar->oldoffset[i] = rar->oldoffset[i-1]; 2764231200Smm rar->oldoffset[0] = offs; 2765231200Smm } 2766231200Smm else if(symbol<=270) 2767231200Smm { 2768231200Smm offs = shortbases[symbol-263] + 1; 2769231200Smm if(shortbits[symbol-263] > 0) { 2770231200Smm if (!rar_br_read_ahead(a, br, shortbits[symbol-263])) 2771231200Smm goto truncated_data; 2772231200Smm offs += rar_br_bits(br, shortbits[symbol-263]); 2773231200Smm rar_br_consume(br, shortbits[symbol-263]); 2774231200Smm } 2775231200Smm 2776231200Smm len = 2; 2777231200Smm 2778231200Smm for(i = 3; i > 0; i--) 2779231200Smm rar->oldoffset[i] = rar->oldoffset[i-1]; 2780231200Smm rar->oldoffset[0] = offs; 2781231200Smm } 2782231200Smm else 2783231200Smm { 2784232153Smm if (symbol-271 > (int)(sizeof(lengthbases)/sizeof(lengthbases[0]))) 2785231200Smm goto bad_data; 2786232153Smm if (symbol-271 > (int)(sizeof(lengthbits)/sizeof(lengthbits[0]))) 2787231200Smm goto bad_data; 2788231200Smm len = lengthbases[symbol-271]+3; 2789231200Smm if(lengthbits[symbol-271] > 0) { 2790231200Smm if (!rar_br_read_ahead(a, br, lengthbits[symbol-271])) 2791231200Smm goto truncated_data; 2792231200Smm len += rar_br_bits(br, lengthbits[symbol-271]); 2793231200Smm rar_br_consume(br, lengthbits[symbol-271]); 2794231200Smm } 2795231200Smm 2796231200Smm if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0) 2797231200Smm goto bad_data; 2798232153Smm if (offssymbol > (int)(sizeof(offsetbases)/sizeof(offsetbases[0]))) 2799231200Smm goto bad_data; 2800232153Smm if (offssymbol > (int)(sizeof(offsetbits)/sizeof(offsetbits[0]))) 2801231200Smm goto bad_data; 2802231200Smm offs = offsetbases[offssymbol]+1; 2803231200Smm if(offsetbits[offssymbol] > 0) 2804231200Smm { 2805231200Smm if(offssymbol > 9) 2806231200Smm { 2807231200Smm if(offsetbits[offssymbol] > 4) { 2808231200Smm if (!rar_br_read_ahead(a, br, offsetbits[offssymbol] - 4)) 2809231200Smm goto truncated_data; 2810231200Smm offs += rar_br_bits(br, offsetbits[offssymbol] - 4) << 4; 2811231200Smm rar_br_consume(br, offsetbits[offssymbol] - 4); 2812231200Smm } 2813231200Smm 2814231200Smm if(rar->numlowoffsetrepeats > 0) 2815231200Smm { 2816231200Smm rar->numlowoffsetrepeats--; 2817231200Smm offs += rar->lastlowoffset; 2818231200Smm } 2819231200Smm else 2820231200Smm { 2821231200Smm if ((lowoffsetsymbol = 2822231200Smm read_next_symbol(a, &rar->lowoffsetcode)) < 0) 2823231200Smm return (ARCHIVE_FATAL); 2824231200Smm if(lowoffsetsymbol == 16) 2825231200Smm { 2826231200Smm rar->numlowoffsetrepeats = 15; 2827231200Smm offs += rar->lastlowoffset; 2828231200Smm } 2829231200Smm else 2830231200Smm { 2831231200Smm offs += lowoffsetsymbol; 2832231200Smm rar->lastlowoffset = lowoffsetsymbol; 2833231200Smm } 2834231200Smm } 2835231200Smm } 2836231200Smm else { 2837231200Smm if (!rar_br_read_ahead(a, br, offsetbits[offssymbol])) 2838231200Smm goto truncated_data; 2839231200Smm offs += rar_br_bits(br, offsetbits[offssymbol]); 2840231200Smm rar_br_consume(br, offsetbits[offssymbol]); 2841231200Smm } 2842231200Smm } 2843231200Smm 2844231200Smm if (offs >= 0x40000) 2845231200Smm len++; 2846231200Smm if (offs >= 0x2000) 2847231200Smm len++; 2848231200Smm 2849231200Smm for(i = 3; i > 0; i--) 2850231200Smm rar->oldoffset[i] = rar->oldoffset[i-1]; 2851231200Smm rar->oldoffset[0] = offs; 2852231200Smm } 2853231200Smm 2854231200Smm rar->lastoffset = offs; 2855231200Smm rar->lastlength = len; 2856231200Smm rar->output_last_match = 1; 2857231200Smm } 2858231200Smmtruncated_data: 2859231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2860231200Smm "Truncated RAR file data"); 2861231200Smm rar->valid = 0; 2862231200Smm return (ARCHIVE_FATAL); 2863231200Smmbad_data: 2864231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2865231200Smm "Bad RAR file data"); 2866231200Smm return (ARCHIVE_FATAL); 2867231200Smm} 2868231200Smm 2869231200Smmstatic int 2870231200Smmcopy_from_lzss_window(struct archive_read *a, const void **buffer, 2871231200Smm int64_t startpos, int length) 2872231200Smm{ 2873231200Smm int windowoffs, firstpart; 2874231200Smm struct rar *rar = (struct rar *)(a->format->data); 2875231200Smm 2876231200Smm if (!rar->unp_buffer) 2877231200Smm { 2878231200Smm if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL) 2879231200Smm { 2880231200Smm archive_set_error(&a->archive, ENOMEM, 2881231200Smm "Unable to allocate memory for uncompressed data."); 2882231200Smm return (ARCHIVE_FATAL); 2883231200Smm } 2884231200Smm } 2885231200Smm 2886231200Smm windowoffs = lzss_offset_for_position(&rar->lzss, startpos); 2887231200Smm if(windowoffs + length <= lzss_size(&rar->lzss)) 2888231200Smm memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs], 2889231200Smm length); 2890231200Smm else 2891231200Smm { 2892231200Smm firstpart = lzss_size(&rar->lzss) - windowoffs; 2893231200Smm if (firstpart < 0) { 2894231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2895231200Smm "Bad RAR file data"); 2896231200Smm return (ARCHIVE_FATAL); 2897231200Smm } 2898231200Smm if (firstpart < length) { 2899231200Smm memcpy(&rar->unp_buffer[rar->unp_offset], 2900231200Smm &rar->lzss.window[windowoffs], firstpart); 2901231200Smm memcpy(&rar->unp_buffer[rar->unp_offset + firstpart], 2902231200Smm &rar->lzss.window[0], length - firstpart); 2903231200Smm } else 2904231200Smm memcpy(&rar->unp_buffer[rar->unp_offset], 2905231200Smm &rar->lzss.window[windowoffs], length); 2906231200Smm } 2907231200Smm rar->unp_offset += length; 2908231200Smm if (rar->unp_offset >= rar->unp_buffer_size) 2909231200Smm *buffer = rar->unp_buffer; 2910231200Smm else 2911231200Smm *buffer = NULL; 2912231200Smm return (ARCHIVE_OK); 2913231200Smm} 2914248616Smm 2915248616Smmstatic const void * 2916248616Smmrar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail) 2917248616Smm{ 2918248616Smm struct rar *rar = (struct rar *)(a->format->data); 2919248616Smm const void *h = __archive_read_ahead(a, min, avail); 2920248616Smm int ret; 2921248616Smm if (avail) 2922248616Smm { 2923299529Smm if (a->archive.read_data_is_posix_read && *avail > (ssize_t)a->archive.read_data_requested) 2924299529Smm *avail = a->archive.read_data_requested; 2925248616Smm if (*avail > rar->bytes_remaining) 2926248616Smm *avail = (ssize_t)rar->bytes_remaining; 2927248616Smm if (*avail < 0) 2928248616Smm return NULL; 2929248616Smm else if (*avail == 0 && rar->main_flags & MHD_VOLUME && 2930248616Smm rar->file_flags & FHD_SPLIT_AFTER) 2931248616Smm { 2932248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 2933248616Smm if (ret == (ARCHIVE_EOF)) 2934248616Smm { 2935248616Smm rar->has_endarc_header = 1; 2936248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 2937248616Smm } 2938248616Smm if (ret != (ARCHIVE_OK)) 2939248616Smm return NULL; 2940248616Smm return rar_read_ahead(a, min, avail); 2941248616Smm } 2942248616Smm } 2943248616Smm return h; 2944248616Smm} 2945