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