archive_read_support_format_rar.c revision 342360
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; 261342360Smm char filename_must_match; 262231200Smm 263231200Smm /* LZSS members */ 264231200Smm struct huffman_code maincode; 265231200Smm struct huffman_code offsetcode; 266231200Smm struct huffman_code lowoffsetcode; 267231200Smm struct huffman_code lengthcode; 268231200Smm unsigned char lengthtable[HUFFMAN_TABLE_SIZE]; 269231200Smm struct lzss lzss; 270231200Smm char output_last_match; 271231200Smm unsigned int lastlength; 272231200Smm unsigned int lastoffset; 273231200Smm unsigned int oldoffset[4]; 274231200Smm unsigned int lastlowoffset; 275231200Smm unsigned int numlowoffsetrepeats; 276231200Smm int64_t filterstart; 277231200Smm char start_new_table; 278231200Smm 279231200Smm /* PPMd Variant H members */ 280231200Smm char ppmd_valid; 281231200Smm char ppmd_eod; 282231200Smm char is_ppmd_block; 283231200Smm int ppmd_escape; 284231200Smm CPpmd7 ppmd7_context; 285231200Smm CPpmd7z_RangeDec range_dec; 286231200Smm IByteIn bytein; 287231200Smm 288231200Smm /* 289231200Smm * String conversion object. 290231200Smm */ 291231200Smm int init_default_conversion; 292231200Smm struct archive_string_conv *sconv_default; 293231200Smm struct archive_string_conv *opt_sconv; 294231200Smm struct archive_string_conv *sconv_utf8; 295231200Smm struct archive_string_conv *sconv_utf16be; 296231200Smm 297231200Smm /* 298231200Smm * Bit stream reader. 299231200Smm */ 300231200Smm struct rar_br { 301231200Smm#define CACHE_TYPE uint64_t 302231200Smm#define CACHE_BITS (8 * sizeof(CACHE_TYPE)) 303231200Smm /* Cache buffer. */ 304231200Smm CACHE_TYPE cache_buffer; 305231200Smm /* Indicates how many bits avail in cache_buffer. */ 306231200Smm int cache_avail; 307231200Smm ssize_t avail_in; 308231200Smm const unsigned char *next_in; 309231200Smm } br; 310299529Smm 311299529Smm /* 312299529Smm * Custom field to denote that this archive contains encrypted entries 313299529Smm */ 314299529Smm int has_encrypted_entries; 315231200Smm}; 316231200Smm 317299529Smmstatic int archive_read_support_format_rar_capabilities(struct archive_read *); 318299529Smmstatic int archive_read_format_rar_has_encrypted_entries(struct archive_read *); 319231200Smmstatic int archive_read_format_rar_bid(struct archive_read *, int); 320231200Smmstatic int archive_read_format_rar_options(struct archive_read *, 321231200Smm const char *, const char *); 322231200Smmstatic int archive_read_format_rar_read_header(struct archive_read *, 323231200Smm struct archive_entry *); 324231200Smmstatic int archive_read_format_rar_read_data(struct archive_read *, 325231200Smm const void **, size_t *, int64_t *); 326231200Smmstatic int archive_read_format_rar_read_data_skip(struct archive_read *a); 327248616Smmstatic int64_t archive_read_format_rar_seek_data(struct archive_read *, int64_t, 328248616Smm int); 329231200Smmstatic int archive_read_format_rar_cleanup(struct archive_read *); 330231200Smm 331231200Smm/* Support functions */ 332231200Smmstatic int read_header(struct archive_read *, struct archive_entry *, char); 333232153Smmstatic time_t get_time(int); 334231200Smmstatic int read_exttime(const char *, struct rar *, const char *); 335231200Smmstatic int read_symlink_stored(struct archive_read *, struct archive_entry *, 336231200Smm struct archive_string_conv *); 337231200Smmstatic int read_data_stored(struct archive_read *, const void **, size_t *, 338231200Smm int64_t *); 339231200Smmstatic int read_data_compressed(struct archive_read *, const void **, size_t *, 340231200Smm int64_t *); 341231200Smmstatic int rar_br_preparation(struct archive_read *, struct rar_br *); 342231200Smmstatic int parse_codes(struct archive_read *); 343231200Smmstatic void free_codes(struct archive_read *); 344231200Smmstatic int read_next_symbol(struct archive_read *, struct huffman_code *); 345231200Smmstatic int create_code(struct archive_read *, struct huffman_code *, 346231200Smm unsigned char *, int, char); 347231200Smmstatic int add_value(struct archive_read *, struct huffman_code *, int, int, 348231200Smm int); 349231200Smmstatic int new_node(struct huffman_code *); 350231200Smmstatic int make_table(struct archive_read *, struct huffman_code *); 351231200Smmstatic int make_table_recurse(struct archive_read *, struct huffman_code *, int, 352231200Smm struct huffman_table_entry *, int, int); 353231200Smmstatic int64_t expand(struct archive_read *, int64_t); 354231200Smmstatic int copy_from_lzss_window(struct archive_read *, const void **, 355231200Smm int64_t, int); 356248616Smmstatic const void *rar_read_ahead(struct archive_read *, size_t, ssize_t *); 357231200Smm 358231200Smm/* 359231200Smm * Bit stream reader. 360231200Smm */ 361231200Smm/* Check that the cache buffer has enough bits. */ 362231200Smm#define rar_br_has(br, n) ((br)->cache_avail >= n) 363231200Smm/* Get compressed data by bit. */ 364231200Smm#define rar_br_bits(br, n) \ 365231200Smm (((uint32_t)((br)->cache_buffer >> \ 366231200Smm ((br)->cache_avail - (n)))) & cache_masks[n]) 367231200Smm#define rar_br_bits_forced(br, n) \ 368231200Smm (((uint32_t)((br)->cache_buffer << \ 369231200Smm ((n) - (br)->cache_avail))) & cache_masks[n]) 370231200Smm/* Read ahead to make sure the cache buffer has enough compressed data we 371231200Smm * will use. 372231200Smm * True : completed, there is enough data in the cache buffer. 373231200Smm * False : there is no data in the stream. */ 374231200Smm#define rar_br_read_ahead(a, br, n) \ 375231200Smm ((rar_br_has(br, (n)) || rar_br_fillup(a, br)) || rar_br_has(br, (n))) 376231200Smm/* Notify how many bits we consumed. */ 377231200Smm#define rar_br_consume(br, n) ((br)->cache_avail -= (n)) 378231200Smm#define rar_br_consume_unalined_bits(br) ((br)->cache_avail &= ~7) 379231200Smm 380231200Smmstatic const uint32_t cache_masks[] = { 381231200Smm 0x00000000, 0x00000001, 0x00000003, 0x00000007, 382231200Smm 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F, 383231200Smm 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF, 384231200Smm 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 385231200Smm 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 386231200Smm 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 387231200Smm 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 388231200Smm 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 389231200Smm 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF 390231200Smm}; 391231200Smm 392231200Smm/* 393231200Smm * Shift away used bits in the cache data and fill it up with following bits. 394231200Smm * Call this when cache buffer does not have enough bits you need. 395231200Smm * 396231200Smm * Returns 1 if the cache buffer is full. 397231200Smm * Returns 0 if the cache buffer is not full; input buffer is empty. 398231200Smm */ 399231200Smmstatic int 400231200Smmrar_br_fillup(struct archive_read *a, struct rar_br *br) 401231200Smm{ 402231200Smm struct rar *rar = (struct rar *)(a->format->data); 403231200Smm int n = CACHE_BITS - br->cache_avail; 404231200Smm 405231200Smm for (;;) { 406231200Smm switch (n >> 3) { 407231200Smm case 8: 408231200Smm if (br->avail_in >= 8) { 409231200Smm br->cache_buffer = 410231200Smm ((uint64_t)br->next_in[0]) << 56 | 411231200Smm ((uint64_t)br->next_in[1]) << 48 | 412231200Smm ((uint64_t)br->next_in[2]) << 40 | 413231200Smm ((uint64_t)br->next_in[3]) << 32 | 414231200Smm ((uint32_t)br->next_in[4]) << 24 | 415231200Smm ((uint32_t)br->next_in[5]) << 16 | 416231200Smm ((uint32_t)br->next_in[6]) << 8 | 417231200Smm (uint32_t)br->next_in[7]; 418231200Smm br->next_in += 8; 419231200Smm br->avail_in -= 8; 420231200Smm br->cache_avail += 8 * 8; 421231200Smm rar->bytes_unconsumed += 8; 422231200Smm rar->bytes_remaining -= 8; 423231200Smm return (1); 424231200Smm } 425231200Smm break; 426231200Smm case 7: 427231200Smm if (br->avail_in >= 7) { 428231200Smm br->cache_buffer = 429231200Smm (br->cache_buffer << 56) | 430231200Smm ((uint64_t)br->next_in[0]) << 48 | 431231200Smm ((uint64_t)br->next_in[1]) << 40 | 432231200Smm ((uint64_t)br->next_in[2]) << 32 | 433231200Smm ((uint32_t)br->next_in[3]) << 24 | 434231200Smm ((uint32_t)br->next_in[4]) << 16 | 435231200Smm ((uint32_t)br->next_in[5]) << 8 | 436231200Smm (uint32_t)br->next_in[6]; 437231200Smm br->next_in += 7; 438231200Smm br->avail_in -= 7; 439231200Smm br->cache_avail += 7 * 8; 440231200Smm rar->bytes_unconsumed += 7; 441231200Smm rar->bytes_remaining -= 7; 442231200Smm return (1); 443231200Smm } 444231200Smm break; 445231200Smm case 6: 446231200Smm if (br->avail_in >= 6) { 447231200Smm br->cache_buffer = 448231200Smm (br->cache_buffer << 48) | 449231200Smm ((uint64_t)br->next_in[0]) << 40 | 450231200Smm ((uint64_t)br->next_in[1]) << 32 | 451231200Smm ((uint32_t)br->next_in[2]) << 24 | 452231200Smm ((uint32_t)br->next_in[3]) << 16 | 453231200Smm ((uint32_t)br->next_in[4]) << 8 | 454231200Smm (uint32_t)br->next_in[5]; 455231200Smm br->next_in += 6; 456231200Smm br->avail_in -= 6; 457231200Smm br->cache_avail += 6 * 8; 458231200Smm rar->bytes_unconsumed += 6; 459231200Smm rar->bytes_remaining -= 6; 460231200Smm return (1); 461231200Smm } 462231200Smm break; 463231200Smm case 0: 464231200Smm /* We have enough compressed data in 465231200Smm * the cache buffer.*/ 466231200Smm return (1); 467231200Smm default: 468231200Smm break; 469231200Smm } 470231200Smm if (br->avail_in <= 0) { 471231200Smm 472231200Smm if (rar->bytes_unconsumed > 0) { 473231200Smm /* Consume as much as the decompressor 474231200Smm * actually used. */ 475231200Smm __archive_read_consume(a, rar->bytes_unconsumed); 476231200Smm rar->bytes_unconsumed = 0; 477231200Smm } 478248616Smm br->next_in = rar_read_ahead(a, 1, &(br->avail_in)); 479231200Smm if (br->next_in == NULL) 480231200Smm return (0); 481231200Smm if (br->avail_in == 0) 482231200Smm return (0); 483231200Smm } 484231200Smm br->cache_buffer = 485231200Smm (br->cache_buffer << 8) | *br->next_in++; 486231200Smm br->avail_in--; 487231200Smm br->cache_avail += 8; 488231200Smm n -= 8; 489231200Smm rar->bytes_unconsumed++; 490231200Smm rar->bytes_remaining--; 491231200Smm } 492231200Smm} 493231200Smm 494231200Smmstatic int 495231200Smmrar_br_preparation(struct archive_read *a, struct rar_br *br) 496231200Smm{ 497231200Smm struct rar *rar = (struct rar *)(a->format->data); 498231200Smm 499231200Smm if (rar->bytes_remaining > 0) { 500248616Smm br->next_in = rar_read_ahead(a, 1, &(br->avail_in)); 501231200Smm if (br->next_in == NULL) { 502231200Smm archive_set_error(&a->archive, 503231200Smm ARCHIVE_ERRNO_FILE_FORMAT, 504231200Smm "Truncated RAR file data"); 505231200Smm return (ARCHIVE_FATAL); 506231200Smm } 507231200Smm if (br->cache_avail == 0) 508231200Smm (void)rar_br_fillup(a, br); 509231200Smm } 510231200Smm return (ARCHIVE_OK); 511231200Smm} 512231200Smm 513231200Smm/* Find last bit set */ 514231200Smmstatic inline int 515231200Smmrar_fls(unsigned int word) 516231200Smm{ 517231200Smm word |= (word >> 1); 518231200Smm word |= (word >> 2); 519231200Smm word |= (word >> 4); 520231200Smm word |= (word >> 8); 521231200Smm word |= (word >> 16); 522231200Smm return word - (word >> 1); 523231200Smm} 524231200Smm 525231200Smm/* LZSS functions */ 526231200Smmstatic inline int64_t 527231200Smmlzss_position(struct lzss *lzss) 528231200Smm{ 529231200Smm return lzss->position; 530231200Smm} 531231200Smm 532231200Smmstatic inline int 533231200Smmlzss_mask(struct lzss *lzss) 534231200Smm{ 535231200Smm return lzss->mask; 536231200Smm} 537231200Smm 538231200Smmstatic inline int 539231200Smmlzss_size(struct lzss *lzss) 540231200Smm{ 541231200Smm return lzss->mask + 1; 542231200Smm} 543231200Smm 544231200Smmstatic inline int 545231200Smmlzss_offset_for_position(struct lzss *lzss, int64_t pos) 546231200Smm{ 547238856Smm return (int)(pos & lzss->mask); 548231200Smm} 549231200Smm 550231200Smmstatic inline unsigned char * 551231200Smmlzss_pointer_for_position(struct lzss *lzss, int64_t pos) 552231200Smm{ 553231200Smm return &lzss->window[lzss_offset_for_position(lzss, pos)]; 554231200Smm} 555231200Smm 556231200Smmstatic inline int 557231200Smmlzss_current_offset(struct lzss *lzss) 558231200Smm{ 559231200Smm return lzss_offset_for_position(lzss, lzss->position); 560231200Smm} 561231200Smm 562231200Smmstatic inline uint8_t * 563231200Smmlzss_current_pointer(struct lzss *lzss) 564231200Smm{ 565231200Smm return lzss_pointer_for_position(lzss, lzss->position); 566231200Smm} 567231200Smm 568231200Smmstatic inline void 569231200Smmlzss_emit_literal(struct rar *rar, uint8_t literal) 570231200Smm{ 571231200Smm *lzss_current_pointer(&rar->lzss) = literal; 572231200Smm rar->lzss.position++; 573231200Smm} 574231200Smm 575231200Smmstatic inline void 576231200Smmlzss_emit_match(struct rar *rar, int offset, int length) 577231200Smm{ 578231200Smm int dstoffs = lzss_current_offset(&rar->lzss); 579231200Smm int srcoffs = (dstoffs - offset) & lzss_mask(&rar->lzss); 580231200Smm int l, li, remaining; 581231200Smm unsigned char *d, *s; 582231200Smm 583231200Smm remaining = length; 584231200Smm while (remaining > 0) { 585231200Smm l = remaining; 586231200Smm if (dstoffs > srcoffs) { 587231200Smm if (l > lzss_size(&rar->lzss) - dstoffs) 588231200Smm l = lzss_size(&rar->lzss) - dstoffs; 589231200Smm } else { 590231200Smm if (l > lzss_size(&rar->lzss) - srcoffs) 591231200Smm l = lzss_size(&rar->lzss) - srcoffs; 592231200Smm } 593231200Smm d = &(rar->lzss.window[dstoffs]); 594231200Smm s = &(rar->lzss.window[srcoffs]); 595231200Smm if ((dstoffs + l < srcoffs) || (srcoffs + l < dstoffs)) 596231200Smm memcpy(d, s, l); 597231200Smm else { 598231200Smm for (li = 0; li < l; li++) 599231200Smm d[li] = s[li]; 600231200Smm } 601231200Smm remaining -= l; 602231200Smm dstoffs = (dstoffs + l) & lzss_mask(&(rar->lzss)); 603231200Smm srcoffs = (srcoffs + l) & lzss_mask(&(rar->lzss)); 604231200Smm } 605231200Smm rar->lzss.position += length; 606231200Smm} 607231200Smm 608231200Smmstatic Byte 609231200Smmppmd_read(void *p) 610231200Smm{ 611231200Smm struct archive_read *a = ((IByteIn*)p)->a; 612231200Smm struct rar *rar = (struct rar *)(a->format->data); 613231200Smm struct rar_br *br = &(rar->br); 614231200Smm Byte b; 615231200Smm if (!rar_br_read_ahead(a, br, 8)) 616231200Smm { 617231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 618231200Smm "Truncated RAR file data"); 619231200Smm rar->valid = 0; 620231200Smm return 0; 621231200Smm } 622231200Smm b = rar_br_bits(br, 8); 623231200Smm rar_br_consume(br, 8); 624231200Smm return b; 625231200Smm} 626231200Smm 627231200Smmint 628231200Smmarchive_read_support_format_rar(struct archive *_a) 629231200Smm{ 630231200Smm struct archive_read *a = (struct archive_read *)_a; 631231200Smm struct rar *rar; 632231200Smm int r; 633231200Smm 634231200Smm archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 635231200Smm "archive_read_support_format_rar"); 636231200Smm 637311041Smm rar = (struct rar *)calloc(sizeof(*rar), 1); 638231200Smm if (rar == NULL) 639231200Smm { 640231200Smm archive_set_error(&a->archive, ENOMEM, "Can't allocate rar data"); 641231200Smm return (ARCHIVE_FATAL); 642231200Smm } 643231200Smm 644299529Smm /* 645299529Smm * Until enough data has been read, we cannot tell about 646299529Smm * any encrypted entries yet. 647299529Smm */ 648299529Smm rar->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW; 649299529Smm 650231200Smm r = __archive_read_register_format(a, 651231200Smm rar, 652231200Smm "rar", 653231200Smm archive_read_format_rar_bid, 654231200Smm archive_read_format_rar_options, 655231200Smm archive_read_format_rar_read_header, 656231200Smm archive_read_format_rar_read_data, 657231200Smm archive_read_format_rar_read_data_skip, 658248616Smm archive_read_format_rar_seek_data, 659299529Smm archive_read_format_rar_cleanup, 660299529Smm archive_read_support_format_rar_capabilities, 661299529Smm archive_read_format_rar_has_encrypted_entries); 662231200Smm 663231200Smm if (r != ARCHIVE_OK) 664231200Smm free(rar); 665231200Smm return (r); 666231200Smm} 667231200Smm 668231200Smmstatic int 669299529Smmarchive_read_support_format_rar_capabilities(struct archive_read * a) 670299529Smm{ 671299529Smm (void)a; /* UNUSED */ 672299529Smm return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA 673299529Smm | ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA); 674299529Smm} 675299529Smm 676299529Smmstatic int 677299529Smmarchive_read_format_rar_has_encrypted_entries(struct archive_read *_a) 678299529Smm{ 679299529Smm if (_a && _a->format) { 680299529Smm struct rar * rar = (struct rar *)_a->format->data; 681299529Smm if (rar) { 682299529Smm return rar->has_encrypted_entries; 683299529Smm } 684299529Smm } 685299529Smm return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW; 686299529Smm} 687299529Smm 688299529Smm 689299529Smmstatic int 690231200Smmarchive_read_format_rar_bid(struct archive_read *a, int best_bid) 691231200Smm{ 692231200Smm const char *p; 693231200Smm 694231200Smm /* If there's already a bid > 30, we'll never win. */ 695231200Smm if (best_bid > 30) 696231200Smm return (-1); 697231200Smm 698231200Smm if ((p = __archive_read_ahead(a, 7, NULL)) == NULL) 699231200Smm return (-1); 700231200Smm 701231200Smm if (memcmp(p, RAR_SIGNATURE, 7) == 0) 702231200Smm return (30); 703231200Smm 704231200Smm if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) { 705231200Smm /* This is a PE file */ 706231200Smm ssize_t offset = 0x10000; 707231200Smm ssize_t window = 4096; 708231200Smm ssize_t bytes_avail; 709231200Smm while (offset + window <= (1024 * 128)) { 710231200Smm const char *buff = __archive_read_ahead(a, offset + window, &bytes_avail); 711231200Smm if (buff == NULL) { 712231200Smm /* Remaining bytes are less than window. */ 713231200Smm window >>= 1; 714231200Smm if (window < 0x40) 715231200Smm return (0); 716231200Smm continue; 717231200Smm } 718231200Smm p = buff + offset; 719231200Smm while (p + 7 < buff + bytes_avail) { 720231200Smm if (memcmp(p, RAR_SIGNATURE, 7) == 0) 721231200Smm return (30); 722231200Smm p += 0x10; 723231200Smm } 724231200Smm offset = p - buff; 725231200Smm } 726231200Smm } 727231200Smm return (0); 728231200Smm} 729231200Smm 730231200Smmstatic int 731231200Smmskip_sfx(struct archive_read *a) 732231200Smm{ 733231200Smm const void *h; 734231200Smm const char *p, *q; 735231200Smm size_t skip, total; 736231200Smm ssize_t bytes, window; 737231200Smm 738231200Smm total = 0; 739231200Smm window = 4096; 740231200Smm while (total + window <= (1024 * 128)) { 741231200Smm h = __archive_read_ahead(a, window, &bytes); 742231200Smm if (h == NULL) { 743231200Smm /* Remaining bytes are less than window. */ 744231200Smm window >>= 1; 745231200Smm if (window < 0x40) 746231200Smm goto fatal; 747231200Smm continue; 748231200Smm } 749231200Smm if (bytes < 0x40) 750231200Smm goto fatal; 751231200Smm p = h; 752231200Smm q = p + bytes; 753231200Smm 754231200Smm /* 755231200Smm * Scan ahead until we find something that looks 756231200Smm * like the RAR header. 757231200Smm */ 758231200Smm while (p + 7 < q) { 759231200Smm if (memcmp(p, RAR_SIGNATURE, 7) == 0) { 760231200Smm skip = p - (const char *)h; 761231200Smm __archive_read_consume(a, skip); 762231200Smm return (ARCHIVE_OK); 763231200Smm } 764231200Smm p += 0x10; 765231200Smm } 766231200Smm skip = p - (const char *)h; 767231200Smm __archive_read_consume(a, skip); 768231200Smm total += skip; 769231200Smm } 770231200Smmfatal: 771231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 772231200Smm "Couldn't find out RAR header"); 773231200Smm return (ARCHIVE_FATAL); 774231200Smm} 775231200Smm 776231200Smmstatic int 777231200Smmarchive_read_format_rar_options(struct archive_read *a, 778231200Smm const char *key, const char *val) 779231200Smm{ 780231200Smm struct rar *rar; 781231200Smm int ret = ARCHIVE_FAILED; 782299529Smm 783231200Smm rar = (struct rar *)(a->format->data); 784231200Smm if (strcmp(key, "hdrcharset") == 0) { 785231200Smm if (val == NULL || val[0] == 0) 786231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 787231200Smm "rar: hdrcharset option needs a character-set name"); 788231200Smm else { 789231200Smm rar->opt_sconv = 790231200Smm archive_string_conversion_from_charset( 791231200Smm &a->archive, val, 0); 792231200Smm if (rar->opt_sconv != NULL) 793231200Smm ret = ARCHIVE_OK; 794231200Smm else 795231200Smm ret = ARCHIVE_FATAL; 796231200Smm } 797232153Smm return (ret); 798232153Smm } 799232153Smm 800232153Smm /* Note: The "warn" return is just to inform the options 801232153Smm * supervisor that we didn't handle it. It will generate 802232153Smm * a suitable error if no one used this option. */ 803232153Smm return (ARCHIVE_WARN); 804231200Smm} 805231200Smm 806231200Smmstatic int 807231200Smmarchive_read_format_rar_read_header(struct archive_read *a, 808231200Smm struct archive_entry *entry) 809231200Smm{ 810231200Smm const void *h; 811231200Smm const char *p; 812231200Smm struct rar *rar; 813231200Smm size_t skip; 814231200Smm char head_type; 815231200Smm int ret; 816231200Smm unsigned flags; 817299529Smm unsigned long crc32_expected; 818231200Smm 819231200Smm a->archive.archive_format = ARCHIVE_FORMAT_RAR; 820231200Smm if (a->archive.archive_format_name == NULL) 821231200Smm a->archive.archive_format_name = "RAR"; 822231200Smm 823231200Smm rar = (struct rar *)(a->format->data); 824231200Smm 825299529Smm /* 826299529Smm * It should be sufficient to call archive_read_next_header() for 827299529Smm * a reader to determine if an entry is encrypted or not. If the 828299529Smm * encryption of an entry is only detectable when calling 829299529Smm * archive_read_data(), so be it. We'll do the same check there 830299529Smm * as well. 831299529Smm */ 832299529Smm if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { 833299529Smm rar->has_encrypted_entries = 0; 834299529Smm } 835299529Smm 836231200Smm /* RAR files can be generated without EOF headers, so return ARCHIVE_EOF if 837231200Smm * this fails. 838231200Smm */ 839231200Smm if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 840231200Smm return (ARCHIVE_EOF); 841231200Smm 842231200Smm p = h; 843231200Smm if (rar->found_first_header == 0 && 844231200Smm ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0)) { 845231200Smm /* This is an executable ? Must be self-extracting... */ 846231200Smm ret = skip_sfx(a); 847231200Smm if (ret < ARCHIVE_WARN) 848231200Smm return (ret); 849231200Smm } 850231200Smm rar->found_first_header = 1; 851231200Smm 852231200Smm while (1) 853231200Smm { 854231200Smm unsigned long crc32_val; 855231200Smm 856231200Smm if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 857231200Smm return (ARCHIVE_FATAL); 858231200Smm p = h; 859231200Smm 860231200Smm head_type = p[2]; 861231200Smm switch(head_type) 862231200Smm { 863231200Smm case MARK_HEAD: 864231200Smm if (memcmp(p, RAR_SIGNATURE, 7) != 0) { 865231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 866231200Smm "Invalid marker header"); 867231200Smm return (ARCHIVE_FATAL); 868231200Smm } 869231200Smm __archive_read_consume(a, 7); 870231200Smm break; 871231200Smm 872231200Smm case MAIN_HEAD: 873231200Smm rar->main_flags = archive_le16dec(p + 3); 874231200Smm skip = archive_le16dec(p + 5); 875231200Smm if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)) { 876231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 877231200Smm "Invalid header size"); 878231200Smm return (ARCHIVE_FATAL); 879231200Smm } 880231200Smm if ((h = __archive_read_ahead(a, skip, NULL)) == NULL) 881231200Smm return (ARCHIVE_FATAL); 882231200Smm p = h; 883231200Smm memcpy(rar->reserved1, p + 7, sizeof(rar->reserved1)); 884231200Smm memcpy(rar->reserved2, p + 7 + sizeof(rar->reserved1), 885231200Smm sizeof(rar->reserved2)); 886231200Smm if (rar->main_flags & MHD_ENCRYPTVER) { 887231200Smm if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)+1) { 888231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 889231200Smm "Invalid header size"); 890231200Smm return (ARCHIVE_FATAL); 891231200Smm } 892231200Smm rar->encryptver = *(p + 7 + sizeof(rar->reserved1) + 893231200Smm sizeof(rar->reserved2)); 894231200Smm } 895231200Smm 896313570Smm /* Main header is password encrypted, so we cannot read any 897299529Smm file names or any other info about files from the header. */ 898231200Smm if (rar->main_flags & MHD_PASSWORD) 899231200Smm { 900299529Smm archive_entry_set_is_metadata_encrypted(entry, 1); 901299529Smm archive_entry_set_is_data_encrypted(entry, 1); 902299529Smm rar->has_encrypted_entries = 1; 903299529Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 904231200Smm "RAR encryption support unavailable."); 905231200Smm return (ARCHIVE_FATAL); 906231200Smm } 907231200Smm 908248616Smm crc32_val = crc32(0, (const unsigned char *)p + 2, (unsigned)skip - 2); 909231200Smm if ((crc32_val & 0xffff) != archive_le16dec(p)) { 910231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 911231200Smm "Header CRC error"); 912231200Smm return (ARCHIVE_FATAL); 913231200Smm } 914231200Smm __archive_read_consume(a, skip); 915231200Smm break; 916231200Smm 917231200Smm case FILE_HEAD: 918231200Smm return read_header(a, entry, head_type); 919231200Smm 920231200Smm case COMM_HEAD: 921231200Smm case AV_HEAD: 922231200Smm case SUB_HEAD: 923231200Smm case PROTECT_HEAD: 924231200Smm case SIGN_HEAD: 925248616Smm case ENDARC_HEAD: 926231200Smm flags = archive_le16dec(p + 3); 927231200Smm skip = archive_le16dec(p + 5); 928231200Smm if (skip < 7) { 929231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 930299529Smm "Invalid header size too small"); 931231200Smm return (ARCHIVE_FATAL); 932231200Smm } 933231200Smm if (flags & HD_ADD_SIZE_PRESENT) 934231200Smm { 935231200Smm if (skip < 7 + 4) { 936231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 937299529Smm "Invalid header size too small"); 938231200Smm return (ARCHIVE_FATAL); 939231200Smm } 940231200Smm if ((h = __archive_read_ahead(a, skip, NULL)) == NULL) 941231200Smm return (ARCHIVE_FATAL); 942231200Smm p = h; 943299529Smm skip += archive_le32dec(p + 7); 944231200Smm } 945231200Smm 946299529Smm /* Skip over the 2-byte CRC at the beginning of the header. */ 947299529Smm crc32_expected = archive_le16dec(p); 948299529Smm __archive_read_consume(a, 2); 949299529Smm skip -= 2; 950299529Smm 951299529Smm /* Skim the entire header and compute the CRC. */ 952299529Smm crc32_val = 0; 953299529Smm while (skip > 0) { 954299529Smm size_t to_read = skip; 955299529Smm ssize_t did_read; 956299529Smm if (to_read > 32 * 1024) { 957299529Smm to_read = 32 * 1024; 958299529Smm } 959299529Smm if ((h = __archive_read_ahead(a, to_read, &did_read)) == NULL) { 960299529Smm return (ARCHIVE_FATAL); 961299529Smm } 962299529Smm p = h; 963299529Smm crc32_val = crc32(crc32_val, (const unsigned char *)p, (unsigned)did_read); 964299529Smm __archive_read_consume(a, did_read); 965299529Smm skip -= did_read; 966231200Smm } 967299529Smm if ((crc32_val & 0xffff) != crc32_expected) { 968299529Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 969299529Smm "Header CRC error"); 970299529Smm return (ARCHIVE_FATAL); 971299529Smm } 972248616Smm if (head_type == ENDARC_HEAD) 973299529Smm return (ARCHIVE_EOF); 974231200Smm break; 975231200Smm 976231200Smm case NEWSUB_HEAD: 977231200Smm if ((ret = read_header(a, entry, head_type)) < ARCHIVE_WARN) 978231200Smm return ret; 979231200Smm break; 980231200Smm 981231200Smm default: 982231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 983231200Smm "Bad RAR file"); 984231200Smm return (ARCHIVE_FATAL); 985231200Smm } 986231200Smm } 987231200Smm} 988231200Smm 989231200Smmstatic int 990231200Smmarchive_read_format_rar_read_data(struct archive_read *a, const void **buff, 991231200Smm size_t *size, int64_t *offset) 992231200Smm{ 993231200Smm struct rar *rar = (struct rar *)(a->format->data); 994231200Smm int ret; 995231200Smm 996299529Smm if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { 997299529Smm rar->has_encrypted_entries = 0; 998299529Smm } 999299529Smm 1000231200Smm if (rar->bytes_unconsumed > 0) { 1001231200Smm /* Consume as much as the decompressor actually used. */ 1002231200Smm __archive_read_consume(a, rar->bytes_unconsumed); 1003231200Smm rar->bytes_unconsumed = 0; 1004231200Smm } 1005231200Smm 1006299529Smm *buff = NULL; 1007248616Smm if (rar->entry_eof || rar->offset_seek >= rar->unp_size) { 1008231200Smm *size = 0; 1009231200Smm *offset = rar->offset; 1010248616Smm if (*offset < rar->unp_size) 1011248616Smm *offset = rar->unp_size; 1012231200Smm return (ARCHIVE_EOF); 1013231200Smm } 1014231200Smm 1015231200Smm switch (rar->compression_method) 1016231200Smm { 1017231200Smm case COMPRESS_METHOD_STORE: 1018231200Smm ret = read_data_stored(a, buff, size, offset); 1019299529Smm break; 1020231200Smm 1021231200Smm case COMPRESS_METHOD_FASTEST: 1022231200Smm case COMPRESS_METHOD_FAST: 1023231200Smm case COMPRESS_METHOD_NORMAL: 1024231200Smm case COMPRESS_METHOD_GOOD: 1025231200Smm case COMPRESS_METHOD_BEST: 1026231200Smm ret = read_data_compressed(a, buff, size, offset); 1027231200Smm if (ret != ARCHIVE_OK && ret != ARCHIVE_WARN) 1028328827Smm __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context); 1029299529Smm break; 1030231200Smm 1031231200Smm default: 1032231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1033231200Smm "Unsupported compression method for RAR file."); 1034231200Smm ret = ARCHIVE_FATAL; 1035299529Smm break; 1036231200Smm } 1037231200Smm return (ret); 1038231200Smm} 1039231200Smm 1040231200Smmstatic int 1041231200Smmarchive_read_format_rar_read_data_skip(struct archive_read *a) 1042231200Smm{ 1043231200Smm struct rar *rar; 1044231200Smm int64_t bytes_skipped; 1045248616Smm int ret; 1046231200Smm 1047231200Smm rar = (struct rar *)(a->format->data); 1048231200Smm 1049231200Smm if (rar->bytes_unconsumed > 0) { 1050231200Smm /* Consume as much as the decompressor actually used. */ 1051231200Smm __archive_read_consume(a, rar->bytes_unconsumed); 1052231200Smm rar->bytes_unconsumed = 0; 1053231200Smm } 1054231200Smm 1055231200Smm if (rar->bytes_remaining > 0) { 1056231200Smm bytes_skipped = __archive_read_consume(a, rar->bytes_remaining); 1057231200Smm if (bytes_skipped < 0) 1058231200Smm return (ARCHIVE_FATAL); 1059231200Smm } 1060248616Smm 1061248616Smm /* Compressed data to skip must be read from each header in a multivolume 1062248616Smm * archive. 1063248616Smm */ 1064248616Smm if (rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER) 1065248616Smm { 1066248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1067248616Smm if (ret == (ARCHIVE_EOF)) 1068248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1069248616Smm if (ret != (ARCHIVE_OK)) 1070248616Smm return ret; 1071248616Smm return archive_read_format_rar_read_data_skip(a); 1072248616Smm } 1073248616Smm 1074231200Smm return (ARCHIVE_OK); 1075231200Smm} 1076231200Smm 1077248616Smmstatic int64_t 1078248616Smmarchive_read_format_rar_seek_data(struct archive_read *a, int64_t offset, 1079248616Smm int whence) 1080248616Smm{ 1081248616Smm int64_t client_offset, ret; 1082248616Smm unsigned int i; 1083248616Smm struct rar *rar = (struct rar *)(a->format->data); 1084248616Smm 1085248616Smm if (rar->compression_method == COMPRESS_METHOD_STORE) 1086248616Smm { 1087248616Smm /* Modify the offset for use with SEEK_SET */ 1088248616Smm switch (whence) 1089248616Smm { 1090248616Smm case SEEK_CUR: 1091248616Smm client_offset = rar->offset_seek; 1092248616Smm break; 1093248616Smm case SEEK_END: 1094248616Smm client_offset = rar->unp_size; 1095248616Smm break; 1096248616Smm case SEEK_SET: 1097248616Smm default: 1098248616Smm client_offset = 0; 1099248616Smm } 1100248616Smm client_offset += offset; 1101248616Smm if (client_offset < 0) 1102248616Smm { 1103248616Smm /* Can't seek past beginning of data block */ 1104248616Smm return -1; 1105248616Smm } 1106248616Smm else if (client_offset > rar->unp_size) 1107248616Smm { 1108248616Smm /* 1109248616Smm * Set the returned offset but only seek to the end of 1110248616Smm * the data block. 1111248616Smm */ 1112248616Smm rar->offset_seek = client_offset; 1113248616Smm client_offset = rar->unp_size; 1114248616Smm } 1115248616Smm 1116248616Smm client_offset += rar->dbo[0].start_offset; 1117248616Smm i = 0; 1118248616Smm while (i < rar->cursor) 1119248616Smm { 1120248616Smm i++; 1121248616Smm client_offset += rar->dbo[i].start_offset - rar->dbo[i-1].end_offset; 1122248616Smm } 1123248616Smm if (rar->main_flags & MHD_VOLUME) 1124248616Smm { 1125248616Smm /* Find the appropriate offset among the multivolume archive */ 1126248616Smm while (1) 1127248616Smm { 1128248616Smm if (client_offset < rar->dbo[rar->cursor].start_offset && 1129248616Smm rar->file_flags & FHD_SPLIT_BEFORE) 1130248616Smm { 1131248616Smm /* Search backwards for the correct data block */ 1132248616Smm if (rar->cursor == 0) 1133248616Smm { 1134248616Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1135248616Smm "Attempt to seek past beginning of RAR data block"); 1136248616Smm return (ARCHIVE_FAILED); 1137248616Smm } 1138248616Smm rar->cursor--; 1139248616Smm client_offset -= rar->dbo[rar->cursor+1].start_offset - 1140248616Smm rar->dbo[rar->cursor].end_offset; 1141248616Smm if (client_offset < rar->dbo[rar->cursor].start_offset) 1142248616Smm continue; 1143248616Smm ret = __archive_read_seek(a, rar->dbo[rar->cursor].start_offset - 1144248616Smm rar->dbo[rar->cursor].header_size, SEEK_SET); 1145248616Smm if (ret < (ARCHIVE_OK)) 1146248616Smm return ret; 1147248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1148248616Smm if (ret != (ARCHIVE_OK)) 1149248616Smm { 1150248616Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1151248616Smm "Error during seek of RAR file"); 1152248616Smm return (ARCHIVE_FAILED); 1153248616Smm } 1154248616Smm rar->cursor--; 1155248616Smm break; 1156248616Smm } 1157248616Smm else if (client_offset > rar->dbo[rar->cursor].end_offset && 1158248616Smm rar->file_flags & FHD_SPLIT_AFTER) 1159248616Smm { 1160248616Smm /* Search forward for the correct data block */ 1161248616Smm rar->cursor++; 1162248616Smm if (rar->cursor < rar->nodes && 1163248616Smm client_offset > rar->dbo[rar->cursor].end_offset) 1164248616Smm { 1165248616Smm client_offset += rar->dbo[rar->cursor].start_offset - 1166248616Smm rar->dbo[rar->cursor-1].end_offset; 1167248616Smm continue; 1168248616Smm } 1169248616Smm rar->cursor--; 1170248616Smm ret = __archive_read_seek(a, rar->dbo[rar->cursor].end_offset, 1171248616Smm SEEK_SET); 1172248616Smm if (ret < (ARCHIVE_OK)) 1173248616Smm return ret; 1174248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1175248616Smm if (ret == (ARCHIVE_EOF)) 1176248616Smm { 1177248616Smm rar->has_endarc_header = 1; 1178248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 1179248616Smm } 1180248616Smm if (ret != (ARCHIVE_OK)) 1181248616Smm { 1182248616Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1183248616Smm "Error during seek of RAR file"); 1184248616Smm return (ARCHIVE_FAILED); 1185248616Smm } 1186248616Smm client_offset += rar->dbo[rar->cursor].start_offset - 1187248616Smm rar->dbo[rar->cursor-1].end_offset; 1188248616Smm continue; 1189248616Smm } 1190248616Smm break; 1191248616Smm } 1192248616Smm } 1193248616Smm 1194248616Smm ret = __archive_read_seek(a, client_offset, SEEK_SET); 1195248616Smm if (ret < (ARCHIVE_OK)) 1196248616Smm return ret; 1197248616Smm rar->bytes_remaining = rar->dbo[rar->cursor].end_offset - ret; 1198248616Smm i = rar->cursor; 1199248616Smm while (i > 0) 1200248616Smm { 1201248616Smm i--; 1202248616Smm ret -= rar->dbo[i+1].start_offset - rar->dbo[i].end_offset; 1203248616Smm } 1204248616Smm ret -= rar->dbo[0].start_offset; 1205248616Smm 1206248616Smm /* Always restart reading the file after a seek */ 1207299529Smm __archive_reset_read_data(&a->archive); 1208299529Smm 1209248616Smm rar->bytes_unconsumed = 0; 1210248616Smm rar->offset = 0; 1211248616Smm 1212248616Smm /* 1213248616Smm * If a seek past the end of file was requested, return the requested 1214248616Smm * offset. 1215248616Smm */ 1216248616Smm if (ret == rar->unp_size && rar->offset_seek > rar->unp_size) 1217248616Smm return rar->offset_seek; 1218248616Smm 1219248616Smm /* Return the new offset */ 1220248616Smm rar->offset_seek = ret; 1221248616Smm return rar->offset_seek; 1222248616Smm } 1223248616Smm else 1224248616Smm { 1225248616Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1226248616Smm "Seeking of compressed RAR files is unsupported"); 1227248616Smm } 1228248616Smm return (ARCHIVE_FAILED); 1229248616Smm} 1230248616Smm 1231231200Smmstatic int 1232231200Smmarchive_read_format_rar_cleanup(struct archive_read *a) 1233231200Smm{ 1234231200Smm struct rar *rar; 1235231200Smm 1236231200Smm rar = (struct rar *)(a->format->data); 1237231200Smm free_codes(a); 1238231200Smm free(rar->filename); 1239248616Smm free(rar->filename_save); 1240248616Smm free(rar->dbo); 1241231200Smm free(rar->unp_buffer); 1242231200Smm free(rar->lzss.window); 1243328827Smm __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context); 1244231200Smm free(rar); 1245231200Smm (a->format->data) = NULL; 1246231200Smm return (ARCHIVE_OK); 1247231200Smm} 1248231200Smm 1249231200Smmstatic int 1250231200Smmread_header(struct archive_read *a, struct archive_entry *entry, 1251231200Smm char head_type) 1252231200Smm{ 1253231200Smm const void *h; 1254231200Smm const char *p, *endp; 1255231200Smm struct rar *rar; 1256231200Smm struct rar_header rar_header; 1257231200Smm struct rar_file_header file_header; 1258231200Smm int64_t header_size; 1259231200Smm unsigned filename_size, end; 1260231200Smm char *filename; 1261231200Smm char *strp; 1262231200Smm char packed_size[8]; 1263231200Smm char unp_size[8]; 1264232153Smm int ttime; 1265231200Smm struct archive_string_conv *sconv, *fn_sconv; 1266231200Smm unsigned long crc32_val; 1267231200Smm int ret = (ARCHIVE_OK), ret2; 1268231200Smm 1269231200Smm rar = (struct rar *)(a->format->data); 1270231200Smm 1271231200Smm /* Setup a string conversion object for non-rar-unicode filenames. */ 1272231200Smm sconv = rar->opt_sconv; 1273231200Smm if (sconv == NULL) { 1274231200Smm if (!rar->init_default_conversion) { 1275231200Smm rar->sconv_default = 1276231200Smm archive_string_default_conversion_for_read( 1277231200Smm &(a->archive)); 1278231200Smm rar->init_default_conversion = 1; 1279231200Smm } 1280231200Smm sconv = rar->sconv_default; 1281231200Smm } 1282231200Smm 1283231200Smm 1284231200Smm if ((h = __archive_read_ahead(a, 7, NULL)) == NULL) 1285231200Smm return (ARCHIVE_FATAL); 1286231200Smm p = h; 1287231200Smm memcpy(&rar_header, p, sizeof(rar_header)); 1288231200Smm rar->file_flags = archive_le16dec(rar_header.flags); 1289231200Smm header_size = archive_le16dec(rar_header.size); 1290232153Smm if (header_size < (int64_t)sizeof(file_header) + 7) { 1291231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1292231200Smm "Invalid header size"); 1293231200Smm return (ARCHIVE_FATAL); 1294231200Smm } 1295231200Smm crc32_val = crc32(0, (const unsigned char *)p + 2, 7 - 2); 1296231200Smm __archive_read_consume(a, 7); 1297231200Smm 1298231200Smm if (!(rar->file_flags & FHD_SOLID)) 1299231200Smm { 1300231200Smm rar->compression_method = 0; 1301231200Smm rar->packed_size = 0; 1302231200Smm rar->unp_size = 0; 1303231200Smm rar->mtime = 0; 1304231200Smm rar->ctime = 0; 1305231200Smm rar->atime = 0; 1306231200Smm rar->arctime = 0; 1307231200Smm rar->mode = 0; 1308231200Smm memset(&rar->salt, 0, sizeof(rar->salt)); 1309231200Smm rar->atime = 0; 1310231200Smm rar->ansec = 0; 1311231200Smm rar->ctime = 0; 1312231200Smm rar->cnsec = 0; 1313231200Smm rar->mtime = 0; 1314231200Smm rar->mnsec = 0; 1315231200Smm rar->arctime = 0; 1316231200Smm rar->arcnsec = 0; 1317231200Smm } 1318231200Smm else 1319231200Smm { 1320231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1321231200Smm "RAR solid archive support unavailable."); 1322231200Smm return (ARCHIVE_FATAL); 1323231200Smm } 1324231200Smm 1325238856Smm if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL) 1326231200Smm return (ARCHIVE_FATAL); 1327231200Smm 1328231200Smm /* File Header CRC check. */ 1329238856Smm crc32_val = crc32(crc32_val, h, (unsigned)(header_size - 7)); 1330231200Smm if ((crc32_val & 0xffff) != archive_le16dec(rar_header.crc)) { 1331231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1332231200Smm "Header CRC error"); 1333231200Smm return (ARCHIVE_FATAL); 1334231200Smm } 1335231200Smm /* If no CRC error, Go on parsing File Header. */ 1336231200Smm p = h; 1337231200Smm endp = p + header_size - 7; 1338231200Smm memcpy(&file_header, p, sizeof(file_header)); 1339231200Smm p += sizeof(file_header); 1340231200Smm 1341231200Smm rar->compression_method = file_header.method; 1342231200Smm 1343232153Smm ttime = archive_le32dec(file_header.file_time); 1344232153Smm rar->mtime = get_time(ttime); 1345231200Smm 1346231200Smm rar->file_crc = archive_le32dec(file_header.file_crc); 1347231200Smm 1348231200Smm if (rar->file_flags & FHD_PASSWORD) 1349231200Smm { 1350299529Smm archive_entry_set_is_data_encrypted(entry, 1); 1351299529Smm rar->has_encrypted_entries = 1; 1352231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1353231200Smm "RAR encryption support unavailable."); 1354299529Smm /* Since it is only the data part itself that is encrypted we can at least 1355299529Smm extract information about the currently processed entry and don't need 1356299529Smm to return ARCHIVE_FATAL here. */ 1357299529Smm /*return (ARCHIVE_FATAL);*/ 1358231200Smm } 1359231200Smm 1360231200Smm if (rar->file_flags & FHD_LARGE) 1361231200Smm { 1362231200Smm memcpy(packed_size, file_header.pack_size, 4); 1363231200Smm memcpy(packed_size + 4, p, 4); /* High pack size */ 1364231200Smm p += 4; 1365231200Smm memcpy(unp_size, file_header.unp_size, 4); 1366231200Smm memcpy(unp_size + 4, p, 4); /* High unpack size */ 1367231200Smm p += 4; 1368231200Smm rar->packed_size = archive_le64dec(&packed_size); 1369231200Smm rar->unp_size = archive_le64dec(&unp_size); 1370231200Smm } 1371231200Smm else 1372231200Smm { 1373231200Smm rar->packed_size = archive_le32dec(file_header.pack_size); 1374231200Smm rar->unp_size = archive_le32dec(file_header.unp_size); 1375231200Smm } 1376231200Smm 1377231200Smm if (rar->packed_size < 0 || rar->unp_size < 0) 1378231200Smm { 1379231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1380231200Smm "Invalid sizes specified."); 1381231200Smm return (ARCHIVE_FATAL); 1382231200Smm } 1383231200Smm 1384248616Smm rar->bytes_remaining = rar->packed_size; 1385248616Smm 1386231200Smm /* TODO: RARv3 subblocks contain comments. For now the complete block is 1387231200Smm * consumed at the end. 1388231200Smm */ 1389231200Smm if (head_type == NEWSUB_HEAD) { 1390231200Smm size_t distance = p - (const char *)h; 1391231200Smm header_size += rar->packed_size; 1392231200Smm /* Make sure we have the extended data. */ 1393238856Smm if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL) 1394231200Smm return (ARCHIVE_FATAL); 1395231200Smm p = h; 1396231200Smm endp = p + header_size - 7; 1397231200Smm p += distance; 1398231200Smm } 1399231200Smm 1400231200Smm filename_size = archive_le16dec(file_header.name_size); 1401231200Smm if (p + filename_size > endp) { 1402231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1403231200Smm "Invalid filename size"); 1404231200Smm return (ARCHIVE_FATAL); 1405231200Smm } 1406238856Smm if (rar->filename_allocated < filename_size * 2 + 2) { 1407238856Smm char *newptr; 1408238856Smm size_t newsize = filename_size * 2 + 2; 1409238856Smm newptr = realloc(rar->filename, newsize); 1410238856Smm if (newptr == NULL) { 1411231200Smm archive_set_error(&a->archive, ENOMEM, 1412231200Smm "Couldn't allocate memory."); 1413231200Smm return (ARCHIVE_FATAL); 1414231200Smm } 1415238856Smm rar->filename = newptr; 1416238856Smm rar->filename_allocated = newsize; 1417231200Smm } 1418231200Smm filename = rar->filename; 1419231200Smm memcpy(filename, p, filename_size); 1420231200Smm filename[filename_size] = '\0'; 1421231200Smm if (rar->file_flags & FHD_UNICODE) 1422231200Smm { 1423231200Smm if (filename_size != strlen(filename)) 1424231200Smm { 1425248616Smm unsigned char highbyte, flagbits, flagbyte; 1426248616Smm unsigned fn_end, offset; 1427231200Smm 1428231200Smm end = filename_size; 1429238856Smm fn_end = filename_size * 2; 1430231200Smm filename_size = 0; 1431248616Smm offset = (unsigned)strlen(filename) + 1; 1432231200Smm highbyte = *(p + offset++); 1433231200Smm flagbits = 0; 1434231200Smm flagbyte = 0; 1435238856Smm while (offset < end && filename_size < fn_end) 1436231200Smm { 1437231200Smm if (!flagbits) 1438231200Smm { 1439231200Smm flagbyte = *(p + offset++); 1440231200Smm flagbits = 8; 1441231200Smm } 1442299529Smm 1443231200Smm flagbits -= 2; 1444231200Smm switch((flagbyte >> flagbits) & 3) 1445231200Smm { 1446231200Smm case 0: 1447231200Smm filename[filename_size++] = '\0'; 1448231200Smm filename[filename_size++] = *(p + offset++); 1449231200Smm break; 1450231200Smm case 1: 1451231200Smm filename[filename_size++] = highbyte; 1452231200Smm filename[filename_size++] = *(p + offset++); 1453231200Smm break; 1454231200Smm case 2: 1455231200Smm filename[filename_size++] = *(p + offset + 1); 1456231200Smm filename[filename_size++] = *(p + offset); 1457231200Smm offset += 2; 1458231200Smm break; 1459231200Smm case 3: 1460231200Smm { 1461238856Smm char extra, high; 1462238856Smm uint8_t length = *(p + offset++); 1463238856Smm 1464238856Smm if (length & 0x80) { 1465238856Smm extra = *(p + offset++); 1466238856Smm high = (char)highbyte; 1467238856Smm } else 1468238856Smm extra = high = 0; 1469238856Smm length = (length & 0x7f) + 2; 1470238856Smm while (length && filename_size < fn_end) { 1471238856Smm unsigned cp = filename_size >> 1; 1472238856Smm filename[filename_size++] = high; 1473238856Smm filename[filename_size++] = p[cp] + extra; 1474231200Smm length--; 1475231200Smm } 1476231200Smm } 1477231200Smm break; 1478231200Smm } 1479231200Smm } 1480238856Smm if (filename_size > fn_end) { 1481231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1482231200Smm "Invalid filename"); 1483231200Smm return (ARCHIVE_FATAL); 1484231200Smm } 1485231200Smm filename[filename_size++] = '\0'; 1486324417Smm /* 1487324417Smm * Do not increment filename_size here as the computations below 1488324417Smm * add the space for the terminating NUL explicitly. 1489324417Smm */ 1490324417Smm filename[filename_size] = '\0'; 1491231200Smm 1492231200Smm /* Decoded unicode form is UTF-16BE, so we have to update a string 1493231200Smm * conversion object for it. */ 1494231200Smm if (rar->sconv_utf16be == NULL) { 1495231200Smm rar->sconv_utf16be = archive_string_conversion_from_charset( 1496231200Smm &a->archive, "UTF-16BE", 1); 1497231200Smm if (rar->sconv_utf16be == NULL) 1498231200Smm return (ARCHIVE_FATAL); 1499231200Smm } 1500231200Smm fn_sconv = rar->sconv_utf16be; 1501231200Smm 1502231200Smm strp = filename; 1503231200Smm while (memcmp(strp, "\x00\x00", 2)) 1504231200Smm { 1505231200Smm if (!memcmp(strp, "\x00\\", 2)) 1506231200Smm *(strp + 1) = '/'; 1507231200Smm strp += 2; 1508231200Smm } 1509231200Smm p += offset; 1510231200Smm } else { 1511231200Smm /* 1512231200Smm * If FHD_UNICODE is set but no unicode data, this file name form 1513231200Smm * is UTF-8, so we have to update a string conversion object for 1514231200Smm * it accordingly. 1515231200Smm */ 1516231200Smm if (rar->sconv_utf8 == NULL) { 1517231200Smm rar->sconv_utf8 = archive_string_conversion_from_charset( 1518231200Smm &a->archive, "UTF-8", 1); 1519231200Smm if (rar->sconv_utf8 == NULL) 1520231200Smm return (ARCHIVE_FATAL); 1521231200Smm } 1522231200Smm fn_sconv = rar->sconv_utf8; 1523231200Smm while ((strp = strchr(filename, '\\')) != NULL) 1524231200Smm *strp = '/'; 1525231200Smm p += filename_size; 1526231200Smm } 1527231200Smm } 1528231200Smm else 1529231200Smm { 1530231200Smm fn_sconv = sconv; 1531231200Smm while ((strp = strchr(filename, '\\')) != NULL) 1532231200Smm *strp = '/'; 1533231200Smm p += filename_size; 1534231200Smm } 1535231200Smm 1536248616Smm /* Split file in multivolume RAR. No more need to process header. */ 1537248616Smm if (rar->filename_save && 1538299529Smm filename_size == rar->filename_save_size && 1539248616Smm !memcmp(rar->filename, rar->filename_save, filename_size + 1)) 1540248616Smm { 1541248616Smm __archive_read_consume(a, header_size - 7); 1542248616Smm rar->cursor++; 1543248616Smm if (rar->cursor >= rar->nodes) 1544248616Smm { 1545248616Smm rar->nodes++; 1546248616Smm if ((rar->dbo = 1547248616Smm realloc(rar->dbo, sizeof(*rar->dbo) * rar->nodes)) == NULL) 1548248616Smm { 1549248616Smm archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory."); 1550248616Smm return (ARCHIVE_FATAL); 1551248616Smm } 1552248616Smm rar->dbo[rar->cursor].header_size = header_size; 1553248616Smm rar->dbo[rar->cursor].start_offset = -1; 1554248616Smm rar->dbo[rar->cursor].end_offset = -1; 1555248616Smm } 1556248616Smm if (rar->dbo[rar->cursor].start_offset < 0) 1557248616Smm { 1558248616Smm rar->dbo[rar->cursor].start_offset = a->filter->position; 1559248616Smm rar->dbo[rar->cursor].end_offset = rar->dbo[rar->cursor].start_offset + 1560248616Smm rar->packed_size; 1561248616Smm } 1562248616Smm return ret; 1563248616Smm } 1564342360Smm else if (rar->filename_must_match) 1565342360Smm { 1566342360Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1567342360Smm "Mismatch of file parts split across multi-volume archive"); 1568342360Smm return (ARCHIVE_FATAL); 1569342360Smm } 1570248616Smm 1571248616Smm rar->filename_save = (char*)realloc(rar->filename_save, 1572248616Smm filename_size + 1); 1573248616Smm memcpy(rar->filename_save, rar->filename, filename_size + 1); 1574299529Smm rar->filename_save_size = filename_size; 1575248616Smm 1576248616Smm /* Set info for seeking */ 1577248616Smm free(rar->dbo); 1578248616Smm if ((rar->dbo = calloc(1, sizeof(*rar->dbo))) == NULL) 1579248616Smm { 1580248616Smm archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory."); 1581248616Smm return (ARCHIVE_FATAL); 1582248616Smm } 1583248616Smm rar->dbo[0].header_size = header_size; 1584248616Smm rar->dbo[0].start_offset = -1; 1585248616Smm rar->dbo[0].end_offset = -1; 1586248616Smm rar->cursor = 0; 1587248616Smm rar->nodes = 1; 1588248616Smm 1589231200Smm if (rar->file_flags & FHD_SALT) 1590231200Smm { 1591231200Smm if (p + 8 > endp) { 1592231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1593231200Smm "Invalid header size"); 1594231200Smm return (ARCHIVE_FATAL); 1595231200Smm } 1596231200Smm memcpy(rar->salt, p, 8); 1597231200Smm p += 8; 1598231200Smm } 1599231200Smm 1600231200Smm if (rar->file_flags & FHD_EXTTIME) { 1601231200Smm if (read_exttime(p, rar, endp) < 0) { 1602231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1603231200Smm "Invalid header size"); 1604231200Smm return (ARCHIVE_FATAL); 1605231200Smm } 1606231200Smm } 1607231200Smm 1608231200Smm __archive_read_consume(a, header_size - 7); 1609248616Smm rar->dbo[0].start_offset = a->filter->position; 1610248616Smm rar->dbo[0].end_offset = rar->dbo[0].start_offset + rar->packed_size; 1611231200Smm 1612231200Smm switch(file_header.host_os) 1613231200Smm { 1614231200Smm case OS_MSDOS: 1615231200Smm case OS_OS2: 1616231200Smm case OS_WIN32: 1617231200Smm rar->mode = archive_le32dec(file_header.file_attr); 1618231200Smm if (rar->mode & FILE_ATTRIBUTE_DIRECTORY) 1619231200Smm rar->mode = AE_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH; 1620231200Smm else 1621231200Smm rar->mode = AE_IFREG; 1622231200Smm rar->mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; 1623231200Smm break; 1624231200Smm 1625231200Smm case OS_UNIX: 1626231200Smm case OS_MAC_OS: 1627231200Smm case OS_BEOS: 1628231200Smm rar->mode = archive_le32dec(file_header.file_attr); 1629231200Smm break; 1630231200Smm 1631231200Smm default: 1632231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1633231200Smm "Unknown file attributes from RAR file's host OS"); 1634231200Smm return (ARCHIVE_FATAL); 1635231200Smm } 1636231200Smm 1637231200Smm rar->bytes_uncopied = rar->bytes_unconsumed = 0; 1638238856Smm rar->lzss.position = rar->offset = 0; 1639248616Smm rar->offset_seek = 0; 1640238856Smm rar->dictionary_size = 0; 1641231200Smm rar->offset_outgoing = 0; 1642231200Smm rar->br.cache_avail = 0; 1643231200Smm rar->br.avail_in = 0; 1644231200Smm rar->crc_calculated = 0; 1645231200Smm rar->entry_eof = 0; 1646231200Smm rar->valid = 1; 1647231200Smm rar->is_ppmd_block = 0; 1648231200Smm rar->start_new_table = 1; 1649231200Smm free(rar->unp_buffer); 1650231200Smm rar->unp_buffer = NULL; 1651231200Smm rar->unp_offset = 0; 1652231200Smm rar->unp_buffer_size = UNP_BUFFER_SIZE; 1653231200Smm memset(rar->lengthtable, 0, sizeof(rar->lengthtable)); 1654328827Smm __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context); 1655231200Smm rar->ppmd_valid = rar->ppmd_eod = 0; 1656231200Smm 1657231200Smm /* Don't set any archive entries for non-file header types */ 1658231200Smm if (head_type == NEWSUB_HEAD) 1659231200Smm return ret; 1660231200Smm 1661231200Smm archive_entry_set_mtime(entry, rar->mtime, rar->mnsec); 1662231200Smm archive_entry_set_ctime(entry, rar->ctime, rar->cnsec); 1663231200Smm archive_entry_set_atime(entry, rar->atime, rar->ansec); 1664231200Smm archive_entry_set_size(entry, rar->unp_size); 1665231200Smm archive_entry_set_mode(entry, rar->mode); 1666231200Smm 1667231200Smm if (archive_entry_copy_pathname_l(entry, filename, filename_size, fn_sconv)) 1668231200Smm { 1669231200Smm if (errno == ENOMEM) 1670231200Smm { 1671231200Smm archive_set_error(&a->archive, ENOMEM, 1672231200Smm "Can't allocate memory for Pathname"); 1673231200Smm return (ARCHIVE_FATAL); 1674231200Smm } 1675231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1676231200Smm "Pathname cannot be converted from %s to current locale.", 1677231200Smm archive_string_conversion_charset_name(fn_sconv)); 1678231200Smm ret = (ARCHIVE_WARN); 1679231200Smm } 1680231200Smm 1681231200Smm if (((rar->mode) & AE_IFMT) == AE_IFLNK) 1682231200Smm { 1683231200Smm /* Make sure a symbolic-link file does not have its body. */ 1684231200Smm rar->bytes_remaining = 0; 1685231200Smm archive_entry_set_size(entry, 0); 1686231200Smm 1687231200Smm /* Read a symbolic-link name. */ 1688231200Smm if ((ret2 = read_symlink_stored(a, entry, sconv)) < (ARCHIVE_WARN)) 1689231200Smm return ret2; 1690231200Smm if (ret > ret2) 1691231200Smm ret = ret2; 1692231200Smm } 1693231200Smm 1694231200Smm if (rar->bytes_remaining == 0) 1695231200Smm rar->entry_eof = 1; 1696231200Smm 1697231200Smm return ret; 1698231200Smm} 1699231200Smm 1700231200Smmstatic time_t 1701232153Smmget_time(int ttime) 1702231200Smm{ 1703231200Smm struct tm tm; 1704232153Smm tm.tm_sec = 2 * (ttime & 0x1f); 1705232153Smm tm.tm_min = (ttime >> 5) & 0x3f; 1706232153Smm tm.tm_hour = (ttime >> 11) & 0x1f; 1707232153Smm tm.tm_mday = (ttime >> 16) & 0x1f; 1708232153Smm tm.tm_mon = ((ttime >> 21) & 0x0f) - 1; 1709232153Smm tm.tm_year = ((ttime >> 25) & 0x7f) + 80; 1710231200Smm tm.tm_isdst = -1; 1711231200Smm return mktime(&tm); 1712231200Smm} 1713231200Smm 1714231200Smmstatic int 1715231200Smmread_exttime(const char *p, struct rar *rar, const char *endp) 1716231200Smm{ 1717231200Smm unsigned rmode, flags, rem, j, count; 1718232153Smm int ttime, i; 1719231200Smm struct tm *tm; 1720231200Smm time_t t; 1721231200Smm long nsec; 1722231200Smm 1723231200Smm if (p + 2 > endp) 1724231200Smm return (-1); 1725231200Smm flags = archive_le16dec(p); 1726231200Smm p += 2; 1727231200Smm 1728231200Smm for (i = 3; i >= 0; i--) 1729231200Smm { 1730231200Smm t = 0; 1731231200Smm if (i == 3) 1732231200Smm t = rar->mtime; 1733231200Smm rmode = flags >> i * 4; 1734231200Smm if (rmode & 8) 1735231200Smm { 1736231200Smm if (!t) 1737231200Smm { 1738231200Smm if (p + 4 > endp) 1739231200Smm return (-1); 1740232153Smm ttime = archive_le32dec(p); 1741232153Smm t = get_time(ttime); 1742231200Smm p += 4; 1743231200Smm } 1744231200Smm rem = 0; 1745231200Smm count = rmode & 3; 1746231200Smm if (p + count > endp) 1747231200Smm return (-1); 1748231200Smm for (j = 0; j < count; j++) 1749231200Smm { 1750318482Smm rem = (((unsigned)(unsigned char)*p) << 16) | (rem >> 8); 1751231200Smm p++; 1752231200Smm } 1753231200Smm tm = localtime(&t); 1754231200Smm nsec = tm->tm_sec + rem / NS_UNIT; 1755231200Smm if (rmode & 4) 1756231200Smm { 1757231200Smm tm->tm_sec++; 1758231200Smm t = mktime(tm); 1759231200Smm } 1760231200Smm if (i == 3) 1761231200Smm { 1762231200Smm rar->mtime = t; 1763231200Smm rar->mnsec = nsec; 1764231200Smm } 1765231200Smm else if (i == 2) 1766231200Smm { 1767231200Smm rar->ctime = t; 1768231200Smm rar->cnsec = nsec; 1769231200Smm } 1770231200Smm else if (i == 1) 1771231200Smm { 1772231200Smm rar->atime = t; 1773231200Smm rar->ansec = nsec; 1774231200Smm } 1775231200Smm else 1776231200Smm { 1777231200Smm rar->arctime = t; 1778231200Smm rar->arcnsec = nsec; 1779231200Smm } 1780231200Smm } 1781231200Smm } 1782231200Smm return (0); 1783231200Smm} 1784231200Smm 1785231200Smmstatic int 1786231200Smmread_symlink_stored(struct archive_read *a, struct archive_entry *entry, 1787231200Smm struct archive_string_conv *sconv) 1788231200Smm{ 1789231200Smm const void *h; 1790231200Smm const char *p; 1791231200Smm struct rar *rar; 1792231200Smm int ret = (ARCHIVE_OK); 1793231200Smm 1794231200Smm rar = (struct rar *)(a->format->data); 1795248616Smm if ((h = rar_read_ahead(a, (size_t)rar->packed_size, NULL)) == NULL) 1796231200Smm return (ARCHIVE_FATAL); 1797231200Smm p = h; 1798231200Smm 1799238856Smm if (archive_entry_copy_symlink_l(entry, 1800238856Smm p, (size_t)rar->packed_size, sconv)) 1801231200Smm { 1802231200Smm if (errno == ENOMEM) 1803231200Smm { 1804231200Smm archive_set_error(&a->archive, ENOMEM, 1805231200Smm "Can't allocate memory for link"); 1806231200Smm return (ARCHIVE_FATAL); 1807231200Smm } 1808231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1809231200Smm "link cannot be converted from %s to current locale.", 1810231200Smm archive_string_conversion_charset_name(sconv)); 1811231200Smm ret = (ARCHIVE_WARN); 1812231200Smm } 1813231200Smm __archive_read_consume(a, rar->packed_size); 1814231200Smm return ret; 1815231200Smm} 1816231200Smm 1817231200Smmstatic int 1818231200Smmread_data_stored(struct archive_read *a, const void **buff, size_t *size, 1819231200Smm int64_t *offset) 1820231200Smm{ 1821231200Smm struct rar *rar; 1822231200Smm ssize_t bytes_avail; 1823231200Smm 1824231200Smm rar = (struct rar *)(a->format->data); 1825248616Smm if (rar->bytes_remaining == 0 && 1826248616Smm !(rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER)) 1827231200Smm { 1828231200Smm *buff = NULL; 1829231200Smm *size = 0; 1830231200Smm *offset = rar->offset; 1831231200Smm if (rar->file_crc != rar->crc_calculated) { 1832231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1833231200Smm "File CRC error"); 1834231200Smm return (ARCHIVE_FATAL); 1835231200Smm } 1836231200Smm rar->entry_eof = 1; 1837231200Smm return (ARCHIVE_EOF); 1838231200Smm } 1839231200Smm 1840248616Smm *buff = rar_read_ahead(a, 1, &bytes_avail); 1841231200Smm if (bytes_avail <= 0) 1842231200Smm { 1843231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1844231200Smm "Truncated RAR file data"); 1845231200Smm return (ARCHIVE_FATAL); 1846231200Smm } 1847231200Smm 1848231200Smm *size = bytes_avail; 1849231200Smm *offset = rar->offset; 1850231200Smm rar->offset += bytes_avail; 1851248616Smm rar->offset_seek += bytes_avail; 1852231200Smm rar->bytes_remaining -= bytes_avail; 1853231200Smm rar->bytes_unconsumed = bytes_avail; 1854231200Smm /* Calculate File CRC. */ 1855248616Smm rar->crc_calculated = crc32(rar->crc_calculated, *buff, 1856248616Smm (unsigned)bytes_avail); 1857231200Smm return (ARCHIVE_OK); 1858231200Smm} 1859231200Smm 1860231200Smmstatic int 1861231200Smmread_data_compressed(struct archive_read *a, const void **buff, size_t *size, 1862231200Smm int64_t *offset) 1863231200Smm{ 1864231200Smm struct rar *rar; 1865231200Smm int64_t start, end, actualend; 1866231200Smm size_t bs; 1867231200Smm int ret = (ARCHIVE_OK), sym, code, lzss_offset, length, i; 1868231200Smm 1869231200Smm rar = (struct rar *)(a->format->data); 1870231200Smm 1871231200Smm do { 1872231200Smm if (!rar->valid) 1873231200Smm return (ARCHIVE_FATAL); 1874231200Smm if (rar->ppmd_eod || 1875231200Smm (rar->dictionary_size && rar->offset >= rar->unp_size)) 1876231200Smm { 1877231200Smm if (rar->unp_offset > 0) { 1878231200Smm /* 1879231200Smm * We have unprocessed extracted data. write it out. 1880231200Smm */ 1881231200Smm *buff = rar->unp_buffer; 1882231200Smm *size = rar->unp_offset; 1883231200Smm *offset = rar->offset_outgoing; 1884231200Smm rar->offset_outgoing += *size; 1885231200Smm /* Calculate File CRC. */ 1886248616Smm rar->crc_calculated = crc32(rar->crc_calculated, *buff, 1887248616Smm (unsigned)*size); 1888231200Smm rar->unp_offset = 0; 1889231200Smm return (ARCHIVE_OK); 1890231200Smm } 1891231200Smm *buff = NULL; 1892231200Smm *size = 0; 1893231200Smm *offset = rar->offset; 1894231200Smm if (rar->file_crc != rar->crc_calculated) { 1895231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1896231200Smm "File CRC error"); 1897231200Smm return (ARCHIVE_FATAL); 1898231200Smm } 1899231200Smm rar->entry_eof = 1; 1900231200Smm return (ARCHIVE_EOF); 1901231200Smm } 1902231200Smm 1903231200Smm if (!rar->is_ppmd_block && rar->dictionary_size && rar->bytes_uncopied > 0) 1904231200Smm { 1905231200Smm if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset)) 1906231200Smm bs = rar->unp_buffer_size - rar->unp_offset; 1907231200Smm else 1908238856Smm bs = (size_t)rar->bytes_uncopied; 1909248616Smm ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs); 1910231200Smm if (ret != ARCHIVE_OK) 1911231200Smm return (ret); 1912231200Smm rar->offset += bs; 1913231200Smm rar->bytes_uncopied -= bs; 1914231200Smm if (*buff != NULL) { 1915231200Smm rar->unp_offset = 0; 1916231200Smm *size = rar->unp_buffer_size; 1917231200Smm *offset = rar->offset_outgoing; 1918231200Smm rar->offset_outgoing += *size; 1919231200Smm /* Calculate File CRC. */ 1920248616Smm rar->crc_calculated = crc32(rar->crc_calculated, *buff, 1921248616Smm (unsigned)*size); 1922231200Smm return (ret); 1923231200Smm } 1924231200Smm continue; 1925231200Smm } 1926231200Smm 1927231200Smm if (!rar->br.next_in && 1928231200Smm (ret = rar_br_preparation(a, &(rar->br))) < ARCHIVE_WARN) 1929231200Smm return (ret); 1930231200Smm if (rar->start_new_table && ((ret = parse_codes(a)) < (ARCHIVE_WARN))) 1931231200Smm return (ret); 1932231200Smm 1933231200Smm if (rar->is_ppmd_block) 1934231200Smm { 1935231200Smm if ((sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1936231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1937231200Smm { 1938231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1939231200Smm "Invalid symbol"); 1940231200Smm return (ARCHIVE_FATAL); 1941231200Smm } 1942231200Smm if(sym != rar->ppmd_escape) 1943231200Smm { 1944231200Smm lzss_emit_literal(rar, sym); 1945231200Smm rar->bytes_uncopied++; 1946231200Smm } 1947231200Smm else 1948231200Smm { 1949231200Smm if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1950231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1951231200Smm { 1952231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1953231200Smm "Invalid symbol"); 1954231200Smm return (ARCHIVE_FATAL); 1955231200Smm } 1956231200Smm 1957231200Smm switch(code) 1958231200Smm { 1959231200Smm case 0: 1960231200Smm rar->start_new_table = 1; 1961231200Smm return read_data_compressed(a, buff, size, offset); 1962231200Smm 1963231200Smm case 2: 1964231200Smm rar->ppmd_eod = 1;/* End Of ppmd Data. */ 1965231200Smm continue; 1966231200Smm 1967231200Smm case 3: 1968231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1969231200Smm "Parsing filters is unsupported."); 1970231200Smm return (ARCHIVE_FAILED); 1971231200Smm 1972231200Smm case 4: 1973231200Smm lzss_offset = 0; 1974231200Smm for (i = 2; i >= 0; i--) 1975231200Smm { 1976231200Smm if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1977231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1978231200Smm { 1979231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1980231200Smm "Invalid symbol"); 1981231200Smm return (ARCHIVE_FATAL); 1982231200Smm } 1983231200Smm lzss_offset |= code << (i * 8); 1984231200Smm } 1985231200Smm if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1986231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1987231200Smm { 1988231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1989231200Smm "Invalid symbol"); 1990231200Smm return (ARCHIVE_FATAL); 1991231200Smm } 1992231200Smm lzss_emit_match(rar, lzss_offset + 2, length + 32); 1993231200Smm rar->bytes_uncopied += length + 32; 1994231200Smm break; 1995231200Smm 1996231200Smm case 5: 1997231200Smm if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1998231200Smm &rar->ppmd7_context, &rar->range_dec.p)) < 0) 1999231200Smm { 2000231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2001231200Smm "Invalid symbol"); 2002231200Smm return (ARCHIVE_FATAL); 2003231200Smm } 2004231200Smm lzss_emit_match(rar, 1, length + 4); 2005231200Smm rar->bytes_uncopied += length + 4; 2006231200Smm break; 2007231200Smm 2008231200Smm default: 2009231200Smm lzss_emit_literal(rar, sym); 2010231200Smm rar->bytes_uncopied++; 2011231200Smm } 2012231200Smm } 2013231200Smm } 2014231200Smm else 2015231200Smm { 2016231200Smm start = rar->offset; 2017231200Smm end = start + rar->dictionary_size; 2018231200Smm rar->filterstart = INT64_MAX; 2019231200Smm 2020231200Smm if ((actualend = expand(a, end)) < 0) 2021231200Smm return ((int)actualend); 2022231200Smm 2023231200Smm rar->bytes_uncopied = actualend - start; 2024231200Smm if (rar->bytes_uncopied == 0) { 2025231200Smm /* Broken RAR files cause this case. 2026231200Smm * NOTE: If this case were possible on a normal RAR file 2027231200Smm * we would find out where it was actually bad and 2028231200Smm * what we would do to solve it. */ 2029231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2030231200Smm "Internal error extracting RAR file"); 2031231200Smm return (ARCHIVE_FATAL); 2032231200Smm } 2033231200Smm } 2034231200Smm if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset)) 2035231200Smm bs = rar->unp_buffer_size - rar->unp_offset; 2036231200Smm else 2037238856Smm bs = (size_t)rar->bytes_uncopied; 2038248616Smm ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs); 2039231200Smm if (ret != ARCHIVE_OK) 2040231200Smm return (ret); 2041231200Smm rar->offset += bs; 2042231200Smm rar->bytes_uncopied -= bs; 2043231200Smm /* 2044231200Smm * If *buff is NULL, it means unp_buffer is not full. 2045231200Smm * So we have to continue extracting a RAR file. 2046231200Smm */ 2047231200Smm } while (*buff == NULL); 2048231200Smm 2049231200Smm rar->unp_offset = 0; 2050231200Smm *size = rar->unp_buffer_size; 2051231200Smm *offset = rar->offset_outgoing; 2052231200Smm rar->offset_outgoing += *size; 2053231200Smm /* Calculate File CRC. */ 2054248616Smm rar->crc_calculated = crc32(rar->crc_calculated, *buff, (unsigned)*size); 2055231200Smm return ret; 2056231200Smm} 2057231200Smm 2058231200Smmstatic int 2059231200Smmparse_codes(struct archive_read *a) 2060231200Smm{ 2061231200Smm int i, j, val, n, r; 2062231200Smm unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags; 2063231200Smm unsigned int maxorder; 2064231200Smm struct huffman_code precode; 2065231200Smm struct rar *rar = (struct rar *)(a->format->data); 2066231200Smm struct rar_br *br = &(rar->br); 2067231200Smm 2068231200Smm free_codes(a); 2069231200Smm 2070231200Smm /* Skip to the next byte */ 2071231200Smm rar_br_consume_unalined_bits(br); 2072231200Smm 2073231200Smm /* PPMd block flag */ 2074231200Smm if (!rar_br_read_ahead(a, br, 1)) 2075231200Smm goto truncated_data; 2076231200Smm if ((rar->is_ppmd_block = rar_br_bits(br, 1)) != 0) 2077231200Smm { 2078231200Smm rar_br_consume(br, 1); 2079231200Smm if (!rar_br_read_ahead(a, br, 7)) 2080231200Smm goto truncated_data; 2081231200Smm ppmd_flags = rar_br_bits(br, 7); 2082231200Smm rar_br_consume(br, 7); 2083231200Smm 2084231200Smm /* Memory is allocated in MB */ 2085231200Smm if (ppmd_flags & 0x20) 2086231200Smm { 2087231200Smm if (!rar_br_read_ahead(a, br, 8)) 2088231200Smm goto truncated_data; 2089231200Smm rar->dictionary_size = (rar_br_bits(br, 8) + 1) << 20; 2090231200Smm rar_br_consume(br, 8); 2091231200Smm } 2092231200Smm 2093231200Smm if (ppmd_flags & 0x40) 2094231200Smm { 2095231200Smm if (!rar_br_read_ahead(a, br, 8)) 2096231200Smm goto truncated_data; 2097231200Smm rar->ppmd_escape = rar->ppmd7_context.InitEsc = rar_br_bits(br, 8); 2098231200Smm rar_br_consume(br, 8); 2099231200Smm } 2100231200Smm else 2101231200Smm rar->ppmd_escape = 2; 2102231200Smm 2103231200Smm if (ppmd_flags & 0x20) 2104231200Smm { 2105231200Smm maxorder = (ppmd_flags & 0x1F) + 1; 2106231200Smm if(maxorder > 16) 2107231200Smm maxorder = 16 + (maxorder - 16) * 3; 2108231200Smm 2109231200Smm if (maxorder == 1) 2110231200Smm { 2111231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2112231200Smm "Truncated RAR file data"); 2113231200Smm return (ARCHIVE_FATAL); 2114231200Smm } 2115231200Smm 2116231200Smm /* Make sure ppmd7_contest is freed before Ppmd7_Construct 2117231200Smm * because reading a broken file cause this abnormal sequence. */ 2118328827Smm __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context); 2119231200Smm 2120231200Smm rar->bytein.a = a; 2121231200Smm rar->bytein.Read = &ppmd_read; 2122231200Smm __archive_ppmd7_functions.PpmdRAR_RangeDec_CreateVTable(&rar->range_dec); 2123231200Smm rar->range_dec.Stream = &rar->bytein; 2124231200Smm __archive_ppmd7_functions.Ppmd7_Construct(&rar->ppmd7_context); 2125231200Smm 2126302075Smm if (rar->dictionary_size == 0) { 2127302075Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2128302075Smm "Invalid zero dictionary size"); 2129302075Smm return (ARCHIVE_FATAL); 2130302075Smm } 2131302075Smm 2132231200Smm if (!__archive_ppmd7_functions.Ppmd7_Alloc(&rar->ppmd7_context, 2133328827Smm rar->dictionary_size)) 2134231200Smm { 2135231200Smm archive_set_error(&a->archive, ENOMEM, 2136231200Smm "Out of memory"); 2137231200Smm return (ARCHIVE_FATAL); 2138231200Smm } 2139231200Smm if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec)) 2140231200Smm { 2141231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2142231200Smm "Unable to initialize PPMd range decoder"); 2143231200Smm return (ARCHIVE_FATAL); 2144231200Smm } 2145231200Smm __archive_ppmd7_functions.Ppmd7_Init(&rar->ppmd7_context, maxorder); 2146231200Smm rar->ppmd_valid = 1; 2147231200Smm } 2148231200Smm else 2149231200Smm { 2150231200Smm if (!rar->ppmd_valid) { 2151231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2152231200Smm "Invalid PPMd sequence"); 2153231200Smm return (ARCHIVE_FATAL); 2154231200Smm } 2155231200Smm if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec)) 2156231200Smm { 2157231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2158231200Smm "Unable to initialize PPMd range decoder"); 2159231200Smm return (ARCHIVE_FATAL); 2160231200Smm } 2161231200Smm } 2162231200Smm } 2163231200Smm else 2164231200Smm { 2165231200Smm rar_br_consume(br, 1); 2166231200Smm 2167231200Smm /* Keep existing table flag */ 2168231200Smm if (!rar_br_read_ahead(a, br, 1)) 2169231200Smm goto truncated_data; 2170231200Smm if (!rar_br_bits(br, 1)) 2171231200Smm memset(rar->lengthtable, 0, sizeof(rar->lengthtable)); 2172231200Smm rar_br_consume(br, 1); 2173231200Smm 2174231200Smm memset(&bitlengths, 0, sizeof(bitlengths)); 2175231200Smm for (i = 0; i < MAX_SYMBOLS;) 2176231200Smm { 2177231200Smm if (!rar_br_read_ahead(a, br, 4)) 2178231200Smm goto truncated_data; 2179231200Smm bitlengths[i++] = rar_br_bits(br, 4); 2180231200Smm rar_br_consume(br, 4); 2181231200Smm if (bitlengths[i-1] == 0xF) 2182231200Smm { 2183231200Smm if (!rar_br_read_ahead(a, br, 4)) 2184231200Smm goto truncated_data; 2185231200Smm zerocount = rar_br_bits(br, 4); 2186231200Smm rar_br_consume(br, 4); 2187231200Smm if (zerocount) 2188231200Smm { 2189231200Smm i--; 2190231200Smm for (j = 0; j < zerocount + 2 && i < MAX_SYMBOLS; j++) 2191231200Smm bitlengths[i++] = 0; 2192231200Smm } 2193231200Smm } 2194231200Smm } 2195231200Smm 2196231200Smm memset(&precode, 0, sizeof(precode)); 2197231200Smm r = create_code(a, &precode, bitlengths, MAX_SYMBOLS, MAX_SYMBOL_LENGTH); 2198231200Smm if (r != ARCHIVE_OK) { 2199231200Smm free(precode.tree); 2200231200Smm free(precode.table); 2201231200Smm return (r); 2202231200Smm } 2203231200Smm 2204231200Smm for (i = 0; i < HUFFMAN_TABLE_SIZE;) 2205231200Smm { 2206231200Smm if ((val = read_next_symbol(a, &precode)) < 0) { 2207231200Smm free(precode.tree); 2208231200Smm free(precode.table); 2209231200Smm return (ARCHIVE_FATAL); 2210231200Smm } 2211231200Smm if (val < 16) 2212231200Smm { 2213231200Smm rar->lengthtable[i] = (rar->lengthtable[i] + val) & 0xF; 2214231200Smm i++; 2215231200Smm } 2216231200Smm else if (val < 18) 2217231200Smm { 2218231200Smm if (i == 0) 2219231200Smm { 2220231200Smm free(precode.tree); 2221231200Smm free(precode.table); 2222231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2223231200Smm "Internal error extracting RAR file."); 2224231200Smm return (ARCHIVE_FATAL); 2225231200Smm } 2226231200Smm 2227231200Smm if(val == 16) { 2228231200Smm if (!rar_br_read_ahead(a, br, 3)) { 2229231200Smm free(precode.tree); 2230231200Smm free(precode.table); 2231231200Smm goto truncated_data; 2232231200Smm } 2233231200Smm n = rar_br_bits(br, 3) + 3; 2234231200Smm rar_br_consume(br, 3); 2235231200Smm } else { 2236231200Smm if (!rar_br_read_ahead(a, br, 7)) { 2237231200Smm free(precode.tree); 2238231200Smm free(precode.table); 2239231200Smm goto truncated_data; 2240231200Smm } 2241231200Smm n = rar_br_bits(br, 7) + 11; 2242231200Smm rar_br_consume(br, 7); 2243231200Smm } 2244231200Smm 2245231200Smm for (j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++) 2246231200Smm { 2247231200Smm rar->lengthtable[i] = rar->lengthtable[i-1]; 2248231200Smm i++; 2249231200Smm } 2250231200Smm } 2251231200Smm else 2252231200Smm { 2253231200Smm if(val == 18) { 2254231200Smm if (!rar_br_read_ahead(a, br, 3)) { 2255231200Smm free(precode.tree); 2256231200Smm free(precode.table); 2257231200Smm goto truncated_data; 2258231200Smm } 2259231200Smm n = rar_br_bits(br, 3) + 3; 2260231200Smm rar_br_consume(br, 3); 2261231200Smm } else { 2262231200Smm if (!rar_br_read_ahead(a, br, 7)) { 2263231200Smm free(precode.tree); 2264231200Smm free(precode.table); 2265231200Smm goto truncated_data; 2266231200Smm } 2267231200Smm n = rar_br_bits(br, 7) + 11; 2268231200Smm rar_br_consume(br, 7); 2269231200Smm } 2270231200Smm 2271231200Smm for(j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++) 2272231200Smm rar->lengthtable[i++] = 0; 2273231200Smm } 2274231200Smm } 2275231200Smm free(precode.tree); 2276231200Smm free(precode.table); 2277231200Smm 2278231200Smm r = create_code(a, &rar->maincode, &rar->lengthtable[0], MAINCODE_SIZE, 2279231200Smm MAX_SYMBOL_LENGTH); 2280231200Smm if (r != ARCHIVE_OK) 2281231200Smm return (r); 2282231200Smm r = create_code(a, &rar->offsetcode, &rar->lengthtable[MAINCODE_SIZE], 2283231200Smm OFFSETCODE_SIZE, MAX_SYMBOL_LENGTH); 2284231200Smm if (r != ARCHIVE_OK) 2285231200Smm return (r); 2286231200Smm r = create_code(a, &rar->lowoffsetcode, 2287231200Smm &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE], 2288231200Smm LOWOFFSETCODE_SIZE, MAX_SYMBOL_LENGTH); 2289231200Smm if (r != ARCHIVE_OK) 2290231200Smm return (r); 2291231200Smm r = create_code(a, &rar->lengthcode, 2292231200Smm &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE + 2293231200Smm LOWOFFSETCODE_SIZE], LENGTHCODE_SIZE, MAX_SYMBOL_LENGTH); 2294231200Smm if (r != ARCHIVE_OK) 2295231200Smm return (r); 2296231200Smm } 2297231200Smm 2298231200Smm if (!rar->dictionary_size || !rar->lzss.window) 2299231200Smm { 2300231200Smm /* Seems as though dictionary sizes are not used. Even so, minimize 2301231200Smm * memory usage as much as possible. 2302231200Smm */ 2303248616Smm void *new_window; 2304248616Smm unsigned int new_size; 2305248616Smm 2306231200Smm if (rar->unp_size >= DICTIONARY_MAX_SIZE) 2307248616Smm new_size = DICTIONARY_MAX_SIZE; 2308231200Smm else 2309248616Smm new_size = rar_fls((unsigned int)rar->unp_size) << 1; 2310342360Smm if (new_size == 0) { 2311342360Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2312342360Smm "Zero window size is invalid."); 2313342360Smm return (ARCHIVE_FATAL); 2314342360Smm } 2315248616Smm new_window = realloc(rar->lzss.window, new_size); 2316248616Smm if (new_window == NULL) { 2317231200Smm archive_set_error(&a->archive, ENOMEM, 2318231200Smm "Unable to allocate memory for uncompressed data."); 2319231200Smm return (ARCHIVE_FATAL); 2320231200Smm } 2321248616Smm rar->lzss.window = (unsigned char *)new_window; 2322248616Smm rar->dictionary_size = new_size; 2323231200Smm memset(rar->lzss.window, 0, rar->dictionary_size); 2324231200Smm rar->lzss.mask = rar->dictionary_size - 1; 2325231200Smm } 2326231200Smm 2327231200Smm rar->start_new_table = 0; 2328231200Smm return (ARCHIVE_OK); 2329231200Smmtruncated_data: 2330231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2331231200Smm "Truncated RAR file data"); 2332231200Smm rar->valid = 0; 2333231200Smm return (ARCHIVE_FATAL); 2334231200Smm} 2335231200Smm 2336231200Smmstatic void 2337231200Smmfree_codes(struct archive_read *a) 2338231200Smm{ 2339231200Smm struct rar *rar = (struct rar *)(a->format->data); 2340231200Smm free(rar->maincode.tree); 2341231200Smm free(rar->offsetcode.tree); 2342231200Smm free(rar->lowoffsetcode.tree); 2343231200Smm free(rar->lengthcode.tree); 2344231200Smm free(rar->maincode.table); 2345231200Smm free(rar->offsetcode.table); 2346231200Smm free(rar->lowoffsetcode.table); 2347231200Smm free(rar->lengthcode.table); 2348231200Smm memset(&rar->maincode, 0, sizeof(rar->maincode)); 2349231200Smm memset(&rar->offsetcode, 0, sizeof(rar->offsetcode)); 2350231200Smm memset(&rar->lowoffsetcode, 0, sizeof(rar->lowoffsetcode)); 2351231200Smm memset(&rar->lengthcode, 0, sizeof(rar->lengthcode)); 2352231200Smm} 2353231200Smm 2354231200Smm 2355231200Smmstatic int 2356231200Smmread_next_symbol(struct archive_read *a, struct huffman_code *code) 2357231200Smm{ 2358231200Smm unsigned char bit; 2359231200Smm unsigned int bits; 2360231200Smm int length, value, node; 2361231200Smm struct rar *rar; 2362231200Smm struct rar_br *br; 2363231200Smm 2364231200Smm if (!code->table) 2365231200Smm { 2366231200Smm if (make_table(a, code) != (ARCHIVE_OK)) 2367231200Smm return -1; 2368231200Smm } 2369231200Smm 2370231200Smm rar = (struct rar *)(a->format->data); 2371231200Smm br = &(rar->br); 2372231200Smm 2373231200Smm /* Look ahead (peek) at bits */ 2374231200Smm if (!rar_br_read_ahead(a, br, code->tablesize)) { 2375231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2376231200Smm "Truncated RAR file data"); 2377231200Smm rar->valid = 0; 2378231200Smm return -1; 2379231200Smm } 2380231200Smm bits = rar_br_bits(br, code->tablesize); 2381231200Smm 2382231200Smm length = code->table[bits].length; 2383231200Smm value = code->table[bits].value; 2384231200Smm 2385231200Smm if (length < 0) 2386231200Smm { 2387231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2388231200Smm "Invalid prefix code in bitstream"); 2389231200Smm return -1; 2390231200Smm } 2391231200Smm 2392231200Smm if (length <= code->tablesize) 2393231200Smm { 2394231200Smm /* Skip length bits */ 2395231200Smm rar_br_consume(br, length); 2396231200Smm return value; 2397231200Smm } 2398231200Smm 2399231200Smm /* Skip tablesize bits */ 2400231200Smm rar_br_consume(br, code->tablesize); 2401231200Smm 2402231200Smm node = value; 2403231200Smm while (!(code->tree[node].branches[0] == 2404231200Smm code->tree[node].branches[1])) 2405231200Smm { 2406231200Smm if (!rar_br_read_ahead(a, br, 1)) { 2407231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2408231200Smm "Truncated RAR file data"); 2409231200Smm rar->valid = 0; 2410231200Smm return -1; 2411231200Smm } 2412231200Smm bit = rar_br_bits(br, 1); 2413231200Smm rar_br_consume(br, 1); 2414231200Smm 2415231200Smm if (code->tree[node].branches[bit] < 0) 2416231200Smm { 2417231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2418231200Smm "Invalid prefix code in bitstream"); 2419231200Smm return -1; 2420231200Smm } 2421231200Smm node = code->tree[node].branches[bit]; 2422231200Smm } 2423231200Smm 2424231200Smm return code->tree[node].branches[0]; 2425231200Smm} 2426231200Smm 2427231200Smmstatic int 2428231200Smmcreate_code(struct archive_read *a, struct huffman_code *code, 2429231200Smm unsigned char *lengths, int numsymbols, char maxlength) 2430231200Smm{ 2431231200Smm int i, j, codebits = 0, symbolsleft = numsymbols; 2432231200Smm 2433299529Smm code->numentries = 0; 2434299529Smm code->numallocatedentries = 0; 2435231200Smm if (new_node(code) < 0) { 2436231200Smm archive_set_error(&a->archive, ENOMEM, 2437231200Smm "Unable to allocate memory for node data."); 2438231200Smm return (ARCHIVE_FATAL); 2439231200Smm } 2440231200Smm code->numentries = 1; 2441231200Smm code->minlength = INT_MAX; 2442231200Smm code->maxlength = INT_MIN; 2443231200Smm codebits = 0; 2444231200Smm for(i = 1; i <= maxlength; i++) 2445231200Smm { 2446231200Smm for(j = 0; j < numsymbols; j++) 2447231200Smm { 2448231200Smm if (lengths[j] != i) continue; 2449231200Smm if (add_value(a, code, j, codebits, i) != ARCHIVE_OK) 2450231200Smm return (ARCHIVE_FATAL); 2451231200Smm codebits++; 2452231200Smm if (--symbolsleft <= 0) { break; break; } 2453231200Smm } 2454231200Smm codebits <<= 1; 2455231200Smm } 2456231200Smm return (ARCHIVE_OK); 2457231200Smm} 2458231200Smm 2459231200Smmstatic int 2460231200Smmadd_value(struct archive_read *a, struct huffman_code *code, int value, 2461231200Smm int codebits, int length) 2462231200Smm{ 2463231200Smm int repeatpos, lastnode, bitpos, bit, repeatnode, nextnode; 2464231200Smm 2465231200Smm free(code->table); 2466231200Smm code->table = NULL; 2467231200Smm 2468231200Smm if(length > code->maxlength) 2469231200Smm code->maxlength = length; 2470231200Smm if(length < code->minlength) 2471231200Smm code->minlength = length; 2472231200Smm 2473231200Smm repeatpos = -1; 2474231200Smm if (repeatpos == 0 || (repeatpos >= 0 2475231200Smm && (((codebits >> (repeatpos - 1)) & 3) == 0 2476231200Smm || ((codebits >> (repeatpos - 1)) & 3) == 3))) 2477231200Smm { 2478231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2479231200Smm "Invalid repeat position"); 2480231200Smm return (ARCHIVE_FATAL); 2481231200Smm } 2482231200Smm 2483231200Smm lastnode = 0; 2484231200Smm for (bitpos = length - 1; bitpos >= 0; bitpos--) 2485231200Smm { 2486231200Smm bit = (codebits >> bitpos) & 1; 2487231200Smm 2488231200Smm /* Leaf node check */ 2489231200Smm if (code->tree[lastnode].branches[0] == 2490231200Smm code->tree[lastnode].branches[1]) 2491231200Smm { 2492231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2493231200Smm "Prefix found"); 2494231200Smm return (ARCHIVE_FATAL); 2495231200Smm } 2496231200Smm 2497231200Smm if (bitpos == repeatpos) 2498231200Smm { 2499231200Smm /* Open branch check */ 2500231200Smm if (!(code->tree[lastnode].branches[bit] < 0)) 2501231200Smm { 2502231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2503231200Smm "Invalid repeating code"); 2504231200Smm return (ARCHIVE_FATAL); 2505231200Smm } 2506231200Smm 2507231200Smm if ((repeatnode = new_node(code)) < 0) { 2508231200Smm archive_set_error(&a->archive, ENOMEM, 2509231200Smm "Unable to allocate memory for node data."); 2510231200Smm return (ARCHIVE_FATAL); 2511231200Smm } 2512231200Smm if ((nextnode = new_node(code)) < 0) { 2513231200Smm archive_set_error(&a->archive, ENOMEM, 2514231200Smm "Unable to allocate memory for node data."); 2515231200Smm return (ARCHIVE_FATAL); 2516231200Smm } 2517231200Smm 2518231200Smm /* Set branches */ 2519231200Smm code->tree[lastnode].branches[bit] = repeatnode; 2520231200Smm code->tree[repeatnode].branches[bit] = repeatnode; 2521231200Smm code->tree[repeatnode].branches[bit^1] = nextnode; 2522231200Smm lastnode = nextnode; 2523231200Smm 2524231200Smm bitpos++; /* terminating bit already handled, skip it */ 2525231200Smm } 2526231200Smm else 2527231200Smm { 2528231200Smm /* Open branch check */ 2529231200Smm if (code->tree[lastnode].branches[bit] < 0) 2530231200Smm { 2531231200Smm if (new_node(code) < 0) { 2532231200Smm archive_set_error(&a->archive, ENOMEM, 2533231200Smm "Unable to allocate memory for node data."); 2534231200Smm return (ARCHIVE_FATAL); 2535231200Smm } 2536231200Smm code->tree[lastnode].branches[bit] = code->numentries++; 2537231200Smm } 2538231200Smm 2539231200Smm /* set to branch */ 2540231200Smm lastnode = code->tree[lastnode].branches[bit]; 2541231200Smm } 2542231200Smm } 2543231200Smm 2544231200Smm if (!(code->tree[lastnode].branches[0] == -1 2545231200Smm && code->tree[lastnode].branches[1] == -2)) 2546231200Smm { 2547231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2548231200Smm "Prefix found"); 2549231200Smm return (ARCHIVE_FATAL); 2550231200Smm } 2551231200Smm 2552231200Smm /* Set leaf value */ 2553231200Smm code->tree[lastnode].branches[0] = value; 2554231200Smm code->tree[lastnode].branches[1] = value; 2555231200Smm 2556231200Smm return (ARCHIVE_OK); 2557231200Smm} 2558231200Smm 2559231200Smmstatic int 2560231200Smmnew_node(struct huffman_code *code) 2561231200Smm{ 2562248616Smm void *new_tree; 2563299529Smm if (code->numallocatedentries == code->numentries) { 2564299529Smm int new_num_entries = 256; 2565299529Smm if (code->numentries > 0) { 2566299529Smm new_num_entries = code->numentries * 2; 2567299529Smm } 2568299529Smm new_tree = realloc(code->tree, new_num_entries * sizeof(*code->tree)); 2569299529Smm if (new_tree == NULL) 2570299529Smm return (-1); 2571299529Smm code->tree = (struct huffman_tree_node *)new_tree; 2572299529Smm code->numallocatedentries = new_num_entries; 2573299529Smm } 2574231200Smm code->tree[code->numentries].branches[0] = -1; 2575231200Smm code->tree[code->numentries].branches[1] = -2; 2576231200Smm return 1; 2577231200Smm} 2578231200Smm 2579231200Smmstatic int 2580231200Smmmake_table(struct archive_read *a, struct huffman_code *code) 2581231200Smm{ 2582231200Smm if (code->maxlength < code->minlength || code->maxlength > 10) 2583231200Smm code->tablesize = 10; 2584231200Smm else 2585231200Smm code->tablesize = code->maxlength; 2586231200Smm 2587231200Smm code->table = 2588248616Smm (struct huffman_table_entry *)calloc(1, sizeof(*code->table) 2589248616Smm * ((size_t)1 << code->tablesize)); 2590231200Smm 2591231200Smm return make_table_recurse(a, code, 0, code->table, 0, code->tablesize); 2592231200Smm} 2593231200Smm 2594231200Smmstatic int 2595231200Smmmake_table_recurse(struct archive_read *a, struct huffman_code *code, int node, 2596231200Smm struct huffman_table_entry *table, int depth, 2597231200Smm int maxdepth) 2598231200Smm{ 2599231200Smm int currtablesize, i, ret = (ARCHIVE_OK); 2600231200Smm 2601231200Smm if (!code->tree) 2602231200Smm { 2603231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2604231200Smm "Huffman tree was not created."); 2605231200Smm return (ARCHIVE_FATAL); 2606231200Smm } 2607231200Smm if (node < 0 || node >= code->numentries) 2608231200Smm { 2609231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2610231200Smm "Invalid location to Huffman tree specified."); 2611231200Smm return (ARCHIVE_FATAL); 2612231200Smm } 2613231200Smm 2614231200Smm currtablesize = 1 << (maxdepth - depth); 2615231200Smm 2616231200Smm if (code->tree[node].branches[0] == 2617231200Smm code->tree[node].branches[1]) 2618231200Smm { 2619231200Smm for(i = 0; i < currtablesize; i++) 2620231200Smm { 2621231200Smm table[i].length = depth; 2622231200Smm table[i].value = code->tree[node].branches[0]; 2623231200Smm } 2624231200Smm } 2625231200Smm else if (node < 0) 2626231200Smm { 2627231200Smm for(i = 0; i < currtablesize; i++) 2628231200Smm table[i].length = -1; 2629231200Smm } 2630231200Smm else 2631231200Smm { 2632231200Smm if(depth == maxdepth) 2633231200Smm { 2634231200Smm table[0].length = maxdepth + 1; 2635231200Smm table[0].value = node; 2636231200Smm } 2637231200Smm else 2638231200Smm { 2639231200Smm ret |= make_table_recurse(a, code, code->tree[node].branches[0], table, 2640231200Smm depth + 1, maxdepth); 2641231200Smm ret |= make_table_recurse(a, code, code->tree[node].branches[1], 2642231200Smm table + currtablesize / 2, depth + 1, maxdepth); 2643231200Smm } 2644231200Smm } 2645231200Smm return ret; 2646231200Smm} 2647231200Smm 2648231200Smmstatic int64_t 2649231200Smmexpand(struct archive_read *a, int64_t end) 2650231200Smm{ 2651231200Smm static const unsigned char lengthbases[] = 2652231200Smm { 0, 1, 2, 3, 4, 5, 6, 2653231200Smm 7, 8, 10, 12, 14, 16, 20, 2654231200Smm 24, 28, 32, 40, 48, 56, 64, 2655231200Smm 80, 96, 112, 128, 160, 192, 224 }; 2656231200Smm static const unsigned char lengthbits[] = 2657231200Smm { 0, 0, 0, 0, 0, 0, 0, 2658231200Smm 0, 1, 1, 1, 1, 2, 2, 2659231200Smm 2, 2, 3, 3, 3, 3, 4, 2660231200Smm 4, 4, 4, 5, 5, 5, 5 }; 2661231200Smm static const unsigned int offsetbases[] = 2662231200Smm { 0, 1, 2, 3, 4, 6, 2663231200Smm 8, 12, 16, 24, 32, 48, 2664231200Smm 64, 96, 128, 192, 256, 384, 2665231200Smm 512, 768, 1024, 1536, 2048, 3072, 2666231200Smm 4096, 6144, 8192, 12288, 16384, 24576, 2667231200Smm 32768, 49152, 65536, 98304, 131072, 196608, 2668231200Smm 262144, 327680, 393216, 458752, 524288, 589824, 2669231200Smm 655360, 720896, 786432, 851968, 917504, 983040, 2670231200Smm 1048576, 1310720, 1572864, 1835008, 2097152, 2359296, 2671231200Smm 2621440, 2883584, 3145728, 3407872, 3670016, 3932160 }; 2672231200Smm static const unsigned char offsetbits[] = 2673231200Smm { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 2674231200Smm 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 2675231200Smm 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 2676231200Smm 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 2677231200Smm 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 }; 2678231200Smm static const unsigned char shortbases[] = 2679231200Smm { 0, 4, 8, 16, 32, 64, 128, 192 }; 2680231200Smm static const unsigned char shortbits[] = 2681231200Smm { 2, 2, 3, 4, 5, 6, 6, 6 }; 2682231200Smm 2683231200Smm int symbol, offs, len, offsindex, lensymbol, i, offssymbol, lowoffsetsymbol; 2684231200Smm unsigned char newfile; 2685231200Smm struct rar *rar = (struct rar *)(a->format->data); 2686231200Smm struct rar_br *br = &(rar->br); 2687231200Smm 2688231200Smm if (rar->filterstart < end) 2689231200Smm end = rar->filterstart; 2690231200Smm 2691231200Smm while (1) 2692231200Smm { 2693231200Smm if (rar->output_last_match && 2694231200Smm lzss_position(&rar->lzss) + rar->lastlength <= end) 2695231200Smm { 2696231200Smm lzss_emit_match(rar, rar->lastoffset, rar->lastlength); 2697231200Smm rar->output_last_match = 0; 2698231200Smm } 2699231200Smm 2700231200Smm if(rar->is_ppmd_block || rar->output_last_match || 2701231200Smm lzss_position(&rar->lzss) >= end) 2702231200Smm return lzss_position(&rar->lzss); 2703231200Smm 2704231200Smm if ((symbol = read_next_symbol(a, &rar->maincode)) < 0) 2705231200Smm return (ARCHIVE_FATAL); 2706231200Smm rar->output_last_match = 0; 2707299529Smm 2708231200Smm if (symbol < 256) 2709231200Smm { 2710231200Smm lzss_emit_literal(rar, symbol); 2711231200Smm continue; 2712231200Smm } 2713231200Smm else if (symbol == 256) 2714231200Smm { 2715231200Smm if (!rar_br_read_ahead(a, br, 1)) 2716231200Smm goto truncated_data; 2717231200Smm newfile = !rar_br_bits(br, 1); 2718231200Smm rar_br_consume(br, 1); 2719231200Smm 2720231200Smm if(newfile) 2721231200Smm { 2722231200Smm rar->start_new_block = 1; 2723231200Smm if (!rar_br_read_ahead(a, br, 1)) 2724231200Smm goto truncated_data; 2725231200Smm rar->start_new_table = rar_br_bits(br, 1); 2726231200Smm rar_br_consume(br, 1); 2727231200Smm return lzss_position(&rar->lzss); 2728231200Smm } 2729231200Smm else 2730231200Smm { 2731231200Smm if (parse_codes(a) != ARCHIVE_OK) 2732231200Smm return (ARCHIVE_FATAL); 2733231200Smm continue; 2734231200Smm } 2735231200Smm } 2736231200Smm else if(symbol==257) 2737231200Smm { 2738231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 2739231200Smm "Parsing filters is unsupported."); 2740231200Smm return (ARCHIVE_FAILED); 2741231200Smm } 2742231200Smm else if(symbol==258) 2743231200Smm { 2744231200Smm if(rar->lastlength == 0) 2745231200Smm continue; 2746231200Smm 2747231200Smm offs = rar->lastoffset; 2748231200Smm len = rar->lastlength; 2749231200Smm } 2750231200Smm else if (symbol <= 262) 2751231200Smm { 2752231200Smm offsindex = symbol - 259; 2753231200Smm offs = rar->oldoffset[offsindex]; 2754231200Smm 2755231200Smm if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0) 2756231200Smm goto bad_data; 2757232153Smm if (lensymbol > (int)(sizeof(lengthbases)/sizeof(lengthbases[0]))) 2758231200Smm goto bad_data; 2759232153Smm if (lensymbol > (int)(sizeof(lengthbits)/sizeof(lengthbits[0]))) 2760231200Smm goto bad_data; 2761231200Smm len = lengthbases[lensymbol] + 2; 2762231200Smm if (lengthbits[lensymbol] > 0) { 2763231200Smm if (!rar_br_read_ahead(a, br, lengthbits[lensymbol])) 2764231200Smm goto truncated_data; 2765231200Smm len += rar_br_bits(br, lengthbits[lensymbol]); 2766231200Smm rar_br_consume(br, lengthbits[lensymbol]); 2767231200Smm } 2768231200Smm 2769231200Smm for (i = offsindex; i > 0; i--) 2770231200Smm rar->oldoffset[i] = rar->oldoffset[i-1]; 2771231200Smm rar->oldoffset[0] = offs; 2772231200Smm } 2773231200Smm else if(symbol<=270) 2774231200Smm { 2775231200Smm offs = shortbases[symbol-263] + 1; 2776231200Smm if(shortbits[symbol-263] > 0) { 2777231200Smm if (!rar_br_read_ahead(a, br, shortbits[symbol-263])) 2778231200Smm goto truncated_data; 2779231200Smm offs += rar_br_bits(br, shortbits[symbol-263]); 2780231200Smm rar_br_consume(br, shortbits[symbol-263]); 2781231200Smm } 2782231200Smm 2783231200Smm len = 2; 2784231200Smm 2785231200Smm for(i = 3; i > 0; i--) 2786231200Smm rar->oldoffset[i] = rar->oldoffset[i-1]; 2787231200Smm rar->oldoffset[0] = offs; 2788231200Smm } 2789231200Smm else 2790231200Smm { 2791232153Smm if (symbol-271 > (int)(sizeof(lengthbases)/sizeof(lengthbases[0]))) 2792231200Smm goto bad_data; 2793232153Smm if (symbol-271 > (int)(sizeof(lengthbits)/sizeof(lengthbits[0]))) 2794231200Smm goto bad_data; 2795231200Smm len = lengthbases[symbol-271]+3; 2796231200Smm if(lengthbits[symbol-271] > 0) { 2797231200Smm if (!rar_br_read_ahead(a, br, lengthbits[symbol-271])) 2798231200Smm goto truncated_data; 2799231200Smm len += rar_br_bits(br, lengthbits[symbol-271]); 2800231200Smm rar_br_consume(br, lengthbits[symbol-271]); 2801231200Smm } 2802231200Smm 2803231200Smm if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0) 2804231200Smm goto bad_data; 2805232153Smm if (offssymbol > (int)(sizeof(offsetbases)/sizeof(offsetbases[0]))) 2806231200Smm goto bad_data; 2807232153Smm if (offssymbol > (int)(sizeof(offsetbits)/sizeof(offsetbits[0]))) 2808231200Smm goto bad_data; 2809231200Smm offs = offsetbases[offssymbol]+1; 2810231200Smm if(offsetbits[offssymbol] > 0) 2811231200Smm { 2812231200Smm if(offssymbol > 9) 2813231200Smm { 2814231200Smm if(offsetbits[offssymbol] > 4) { 2815231200Smm if (!rar_br_read_ahead(a, br, offsetbits[offssymbol] - 4)) 2816231200Smm goto truncated_data; 2817231200Smm offs += rar_br_bits(br, offsetbits[offssymbol] - 4) << 4; 2818231200Smm rar_br_consume(br, offsetbits[offssymbol] - 4); 2819231200Smm } 2820231200Smm 2821231200Smm if(rar->numlowoffsetrepeats > 0) 2822231200Smm { 2823231200Smm rar->numlowoffsetrepeats--; 2824231200Smm offs += rar->lastlowoffset; 2825231200Smm } 2826231200Smm else 2827231200Smm { 2828231200Smm if ((lowoffsetsymbol = 2829231200Smm read_next_symbol(a, &rar->lowoffsetcode)) < 0) 2830231200Smm return (ARCHIVE_FATAL); 2831231200Smm if(lowoffsetsymbol == 16) 2832231200Smm { 2833231200Smm rar->numlowoffsetrepeats = 15; 2834231200Smm offs += rar->lastlowoffset; 2835231200Smm } 2836231200Smm else 2837231200Smm { 2838231200Smm offs += lowoffsetsymbol; 2839231200Smm rar->lastlowoffset = lowoffsetsymbol; 2840231200Smm } 2841231200Smm } 2842231200Smm } 2843231200Smm else { 2844231200Smm if (!rar_br_read_ahead(a, br, offsetbits[offssymbol])) 2845231200Smm goto truncated_data; 2846231200Smm offs += rar_br_bits(br, offsetbits[offssymbol]); 2847231200Smm rar_br_consume(br, offsetbits[offssymbol]); 2848231200Smm } 2849231200Smm } 2850231200Smm 2851231200Smm if (offs >= 0x40000) 2852231200Smm len++; 2853231200Smm if (offs >= 0x2000) 2854231200Smm len++; 2855231200Smm 2856231200Smm for(i = 3; i > 0; i--) 2857231200Smm rar->oldoffset[i] = rar->oldoffset[i-1]; 2858231200Smm rar->oldoffset[0] = offs; 2859231200Smm } 2860231200Smm 2861231200Smm rar->lastoffset = offs; 2862231200Smm rar->lastlength = len; 2863231200Smm rar->output_last_match = 1; 2864231200Smm } 2865231200Smmtruncated_data: 2866231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2867231200Smm "Truncated RAR file data"); 2868231200Smm rar->valid = 0; 2869231200Smm return (ARCHIVE_FATAL); 2870231200Smmbad_data: 2871231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2872231200Smm "Bad RAR file data"); 2873231200Smm return (ARCHIVE_FATAL); 2874231200Smm} 2875231200Smm 2876231200Smmstatic int 2877231200Smmcopy_from_lzss_window(struct archive_read *a, const void **buffer, 2878231200Smm int64_t startpos, int length) 2879231200Smm{ 2880231200Smm int windowoffs, firstpart; 2881231200Smm struct rar *rar = (struct rar *)(a->format->data); 2882231200Smm 2883231200Smm if (!rar->unp_buffer) 2884231200Smm { 2885231200Smm if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL) 2886231200Smm { 2887231200Smm archive_set_error(&a->archive, ENOMEM, 2888231200Smm "Unable to allocate memory for uncompressed data."); 2889231200Smm return (ARCHIVE_FATAL); 2890231200Smm } 2891231200Smm } 2892231200Smm 2893231200Smm windowoffs = lzss_offset_for_position(&rar->lzss, startpos); 2894302075Smm if(windowoffs + length <= lzss_size(&rar->lzss)) { 2895231200Smm memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs], 2896231200Smm length); 2897302075Smm } else if (length <= lzss_size(&rar->lzss)) { 2898231200Smm firstpart = lzss_size(&rar->lzss) - windowoffs; 2899231200Smm if (firstpart < 0) { 2900231200Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2901231200Smm "Bad RAR file data"); 2902231200Smm return (ARCHIVE_FATAL); 2903231200Smm } 2904231200Smm if (firstpart < length) { 2905231200Smm memcpy(&rar->unp_buffer[rar->unp_offset], 2906231200Smm &rar->lzss.window[windowoffs], firstpart); 2907231200Smm memcpy(&rar->unp_buffer[rar->unp_offset + firstpart], 2908231200Smm &rar->lzss.window[0], length - firstpart); 2909302075Smm } else { 2910231200Smm memcpy(&rar->unp_buffer[rar->unp_offset], 2911231200Smm &rar->lzss.window[windowoffs], length); 2912302075Smm } 2913302075Smm } else { 2914302075Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 2915302075Smm "Bad RAR file data"); 2916302075Smm return (ARCHIVE_FATAL); 2917231200Smm } 2918231200Smm rar->unp_offset += length; 2919231200Smm if (rar->unp_offset >= rar->unp_buffer_size) 2920231200Smm *buffer = rar->unp_buffer; 2921231200Smm else 2922231200Smm *buffer = NULL; 2923231200Smm return (ARCHIVE_OK); 2924231200Smm} 2925248616Smm 2926248616Smmstatic const void * 2927248616Smmrar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail) 2928248616Smm{ 2929248616Smm struct rar *rar = (struct rar *)(a->format->data); 2930248616Smm const void *h = __archive_read_ahead(a, min, avail); 2931248616Smm int ret; 2932248616Smm if (avail) 2933248616Smm { 2934299529Smm if (a->archive.read_data_is_posix_read && *avail > (ssize_t)a->archive.read_data_requested) 2935299529Smm *avail = a->archive.read_data_requested; 2936248616Smm if (*avail > rar->bytes_remaining) 2937248616Smm *avail = (ssize_t)rar->bytes_remaining; 2938248616Smm if (*avail < 0) 2939248616Smm return NULL; 2940248616Smm else if (*avail == 0 && rar->main_flags & MHD_VOLUME && 2941248616Smm rar->file_flags & FHD_SPLIT_AFTER) 2942248616Smm { 2943342360Smm rar->filename_must_match = 1; 2944248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 2945248616Smm if (ret == (ARCHIVE_EOF)) 2946248616Smm { 2947248616Smm rar->has_endarc_header = 1; 2948248616Smm ret = archive_read_format_rar_read_header(a, a->entry); 2949248616Smm } 2950342360Smm rar->filename_must_match = 0; 2951248616Smm if (ret != (ARCHIVE_OK)) 2952248616Smm return NULL; 2953248616Smm return rar_read_ahead(a, min, avail); 2954248616Smm } 2955248616Smm } 2956248616Smm return h; 2957248616Smm} 2958