contrib/libarchive/libarchive/archive_read_support_format_rar.c

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