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