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       rar->start_new_table = 1;
1030     }
1031     break;
1032
1033   default:
1034     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1035                       "Unsupported compression method for RAR file.");
1036     ret = ARCHIVE_FATAL;
1037     break;
1038   }
1039   return (ret);
1040 }
1041
1042 static int
1043 archive_read_format_rar_read_data_skip(struct archive_read *a)
1044 {
1045   struct rar *rar;
1046   int64_t bytes_skipped;
1047   int ret;
1048
1049   rar = (struct rar *)(a->format->data);
1050
1051   if (rar->bytes_unconsumed > 0) {
1052       /* Consume as much as the decompressor actually used. */
1053       __archive_read_consume(a, rar->bytes_unconsumed);
1054       rar->bytes_unconsumed = 0;
1055   }
1056
1057   if (rar->bytes_remaining > 0) {
1058     bytes_skipped = __archive_read_consume(a, rar->bytes_remaining);
1059     if (bytes_skipped < 0)
1060       return (ARCHIVE_FATAL);
1061   }
1062
1063   /* Compressed data to skip must be read from each header in a multivolume
1064    * archive.
1065    */
1066   if (rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER)
1067   {
1068     ret = archive_read_format_rar_read_header(a, a->entry);
1069     if (ret == (ARCHIVE_EOF))
1070       ret = archive_read_format_rar_read_header(a, a->entry);
1071     if (ret != (ARCHIVE_OK))
1072       return ret;
1073     return archive_read_format_rar_read_data_skip(a);
1074   }
1075
1076   return (ARCHIVE_OK);
1077 }
1078
1079 static int64_t
1080 archive_read_format_rar_seek_data(struct archive_read *a, int64_t offset,
1081     int whence)
1082 {
1083   int64_t client_offset, ret;
1084   unsigned int i;
1085   struct rar *rar = (struct rar *)(a->format->data);
1086
1087   if (rar->compression_method == COMPRESS_METHOD_STORE)
1088   {
1089     /* Modify the offset for use with SEEK_SET */
1090     switch (whence)
1091     {
1092       case SEEK_CUR:
1093         client_offset = rar->offset_seek;
1094         break;
1095       case SEEK_END:
1096         client_offset = rar->unp_size;
1097         break;
1098       case SEEK_SET:
1099       default:
1100         client_offset = 0;
1101     }
1102     client_offset += offset;
1103     if (client_offset < 0)
1104     {
1105       /* Can't seek past beginning of data block */
1106       return -1;
1107     }
1108     else if (client_offset > rar->unp_size)
1109     {
1110       /*
1111        * Set the returned offset but only seek to the end of
1112        * the data block.
1113        */
1114       rar->offset_seek = client_offset;
1115       client_offset = rar->unp_size;
1116     }
1117
1118     client_offset += rar->dbo[0].start_offset;
1119     i = 0;
1120     while (i < rar->cursor)
1121     {
1122       i++;
1123       client_offset += rar->dbo[i].start_offset - rar->dbo[i-1].end_offset;
1124     }
1125     if (rar->main_flags & MHD_VOLUME)
1126     {
1127       /* Find the appropriate offset among the multivolume archive */
1128       while (1)
1129       {
1130         if (client_offset < rar->dbo[rar->cursor].start_offset &&
1131           rar->file_flags & FHD_SPLIT_BEFORE)
1132         {
1133           /* Search backwards for the correct data block */
1134           if (rar->cursor == 0)
1135           {
1136             archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1137               "Attempt to seek past beginning of RAR data block");
1138             return (ARCHIVE_FAILED);
1139           }
1140           rar->cursor--;
1141           client_offset -= rar->dbo[rar->cursor+1].start_offset -
1142             rar->dbo[rar->cursor].end_offset;
1143           if (client_offset < rar->dbo[rar->cursor].start_offset)
1144             continue;
1145           ret = __archive_read_seek(a, rar->dbo[rar->cursor].start_offset -
1146             rar->dbo[rar->cursor].header_size, SEEK_SET);
1147           if (ret < (ARCHIVE_OK))
1148             return ret;
1149           ret = archive_read_format_rar_read_header(a, a->entry);
1150           if (ret != (ARCHIVE_OK))
1151           {
1152             archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1153               "Error during seek of RAR file");
1154             return (ARCHIVE_FAILED);
1155           }
1156           rar->cursor--;
1157           break;
1158         }
1159         else if (client_offset > rar->dbo[rar->cursor].end_offset &&
1160           rar->file_flags & FHD_SPLIT_AFTER)
1161         {
1162           /* Search forward for the correct data block */
1163           rar->cursor++;
1164           if (rar->cursor < rar->nodes &&
1165             client_offset > rar->dbo[rar->cursor].end_offset)
1166           {
1167             client_offset += rar->dbo[rar->cursor].start_offset -
1168               rar->dbo[rar->cursor-1].end_offset;
1169             continue;
1170           }
1171           rar->cursor--;
1172           ret = __archive_read_seek(a, rar->dbo[rar->cursor].end_offset,
1173                                     SEEK_SET);
1174           if (ret < (ARCHIVE_OK))
1175             return ret;
1176           ret = archive_read_format_rar_read_header(a, a->entry);
1177           if (ret == (ARCHIVE_EOF))
1178           {
1179             rar->has_endarc_header = 1;
1180             ret = archive_read_format_rar_read_header(a, a->entry);
1181           }
1182           if (ret != (ARCHIVE_OK))
1183           {
1184             archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1185               "Error during seek of RAR file");
1186             return (ARCHIVE_FAILED);
1187           }
1188           client_offset += rar->dbo[rar->cursor].start_offset -
1189             rar->dbo[rar->cursor-1].end_offset;
1190           continue;
1191         }
1192         break;
1193       }
1194     }
1195
1196     ret = __archive_read_seek(a, client_offset, SEEK_SET);
1197     if (ret < (ARCHIVE_OK))
1198       return ret;
1199     rar->bytes_remaining = rar->dbo[rar->cursor].end_offset - ret;
1200     i = rar->cursor;
1201     while (i > 0)
1202     {
1203       i--;
1204       ret -= rar->dbo[i+1].start_offset - rar->dbo[i].end_offset;
1205     }
1206     ret -= rar->dbo[0].start_offset;
1207
1208     /* Always restart reading the file after a seek */
1209     __archive_reset_read_data(&a->archive);
1210
1211     rar->bytes_unconsumed = 0;
1212     rar->offset = 0;
1213
1214     /*
1215      * If a seek past the end of file was requested, return the requested
1216      * offset.
1217      */
1218     if (ret == rar->unp_size && rar->offset_seek > rar->unp_size)
1219       return rar->offset_seek;
1220
1221     /* Return the new offset */
1222     rar->offset_seek = ret;
1223     return rar->offset_seek;
1224   }
1225   else
1226   {
1227     archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1228       "Seeking of compressed RAR files is unsupported");
1229   }
1230   return (ARCHIVE_FAILED);
1231 }
1232
1233 static int
1234 archive_read_format_rar_cleanup(struct archive_read *a)
1235 {
1236   struct rar *rar;
1237
1238   rar = (struct rar *)(a->format->data);
1239   free_codes(a);
1240   free(rar->filename);
1241   free(rar->filename_save);
1242   free(rar->dbo);
1243   free(rar->unp_buffer);
1244   free(rar->lzss.window);
1245   __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context);
1246   free(rar);
1247   (a->format->data) = NULL;
1248   return (ARCHIVE_OK);
1249 }
1250
1251 static int
1252 read_header(struct archive_read *a, struct archive_entry *entry,
1253             char head_type)
1254 {
1255   const void *h;
1256   const char *p, *endp;
1257   struct rar *rar;
1258   struct rar_header rar_header;
1259   struct rar_file_header file_header;
1260   int64_t header_size;
1261   unsigned filename_size, end;
1262   char *filename;
1263   char *strp;
1264   char packed_size[8];
1265   char unp_size[8];
1266   int ttime;
1267   struct archive_string_conv *sconv, *fn_sconv;
1268   unsigned long crc32_val;
1269   int ret = (ARCHIVE_OK), ret2;
1270
1271   rar = (struct rar *)(a->format->data);
1272
1273   /* Setup a string conversion object for non-rar-unicode filenames. */
1274   sconv = rar->opt_sconv;
1275   if (sconv == NULL) {
1276     if (!rar->init_default_conversion) {
1277       rar->sconv_default =
1278           archive_string_default_conversion_for_read(
1279             &(a->archive));
1280       rar->init_default_conversion = 1;
1281     }
1282     sconv = rar->sconv_default;
1283   }
1284
1285
1286   if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)
1287     return (ARCHIVE_FATAL);
1288   p = h;
1289   memcpy(&rar_header, p, sizeof(rar_header));
1290   rar->file_flags = archive_le16dec(rar_header.flags);
1291   header_size = archive_le16dec(rar_header.size);
1292   if (header_size < (int64_t)sizeof(file_header) + 7) {
1293     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1294       "Invalid header size");
1295     return (ARCHIVE_FATAL);
1296   }
1297   crc32_val = crc32(0, (const unsigned char *)p + 2, 7 - 2);
1298   __archive_read_consume(a, 7);
1299
1300   if (!(rar->file_flags & FHD_SOLID))
1301   {
1302     rar->compression_method = 0;
1303     rar->packed_size = 0;
1304     rar->unp_size = 0;
1305     rar->mtime = 0;
1306     rar->ctime = 0;
1307     rar->atime = 0;
1308     rar->arctime = 0;
1309     rar->mode = 0;
1310     memset(&rar->salt, 0, sizeof(rar->salt));
1311     rar->atime = 0;
1312     rar->ansec = 0;
1313     rar->ctime = 0;
1314     rar->cnsec = 0;
1315     rar->mtime = 0;
1316     rar->mnsec = 0;
1317     rar->arctime = 0;
1318     rar->arcnsec = 0;
1319   }
1320   else
1321   {
1322     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1323                       "RAR solid archive support unavailable.");
1324     return (ARCHIVE_FATAL);
1325   }
1326
1327   if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL)
1328     return (ARCHIVE_FATAL);
1329
1330   /* File Header CRC check. */
1331   crc32_val = crc32(crc32_val, h, (unsigned)(header_size - 7));
1332   if ((crc32_val & 0xffff) != archive_le16dec(rar_header.crc)) {
1333     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1334       "Header CRC error");
1335     return (ARCHIVE_FATAL);
1336   }
1337   /* If no CRC error, Go on parsing File Header. */
1338   p = h;
1339   endp = p + header_size - 7;
1340   memcpy(&file_header, p, sizeof(file_header));
1341   p += sizeof(file_header);
1342
1343   rar->compression_method = file_header.method;
1344
1345   ttime = archive_le32dec(file_header.file_time);
1346   rar->mtime = get_time(ttime);
1347
1348   rar->file_crc = archive_le32dec(file_header.file_crc);
1349
1350   if (rar->file_flags & FHD_PASSWORD)
1351   {
1352         archive_entry_set_is_data_encrypted(entry, 1);
1353         rar->has_encrypted_entries = 1;
1354     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1355                       "RAR encryption support unavailable.");
1356     /* Since it is only the data part itself that is encrypted we can at least
1357        extract information about the currently processed entry and don't need
1358        to return ARCHIVE_FATAL here. */
1359     /*return (ARCHIVE_FATAL);*/
1360   }
1361
1362   if (rar->file_flags & FHD_LARGE)
1363   {
1364     memcpy(packed_size, file_header.pack_size, 4);
1365     memcpy(packed_size + 4, p, 4); /* High pack size */
1366     p += 4;
1367     memcpy(unp_size, file_header.unp_size, 4);
1368     memcpy(unp_size + 4, p, 4); /* High unpack size */
1369     p += 4;
1370     rar->packed_size = archive_le64dec(&packed_size);
1371     rar->unp_size = archive_le64dec(&unp_size);
1372   }
1373   else
1374   {
1375     rar->packed_size = archive_le32dec(file_header.pack_size);
1376     rar->unp_size = archive_le32dec(file_header.unp_size);
1377   }
1378
1379   if (rar->packed_size < 0 || rar->unp_size < 0)
1380   {
1381     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1382                       "Invalid sizes specified.");
1383     return (ARCHIVE_FATAL);
1384   }
1385
1386   rar->bytes_remaining = rar->packed_size;
1387
1388   /* TODO: RARv3 subblocks contain comments. For now the complete block is
1389    * consumed at the end.
1390    */
1391   if (head_type == NEWSUB_HEAD) {
1392     size_t distance = p - (const char *)h;
1393     header_size += rar->packed_size;
1394     /* Make sure we have the extended data. */
1395     if ((h = __archive_read_ahead(a, (size_t)header_size - 7, NULL)) == NULL)
1396         return (ARCHIVE_FATAL);
1397     p = h;
1398     endp = p + header_size - 7;
1399     p += distance;
1400   }
1401
1402   filename_size = archive_le16dec(file_header.name_size);
1403   if (p + filename_size > endp) {
1404     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1405       "Invalid filename size");
1406     return (ARCHIVE_FATAL);
1407   }
1408   if (rar->filename_allocated < filename_size * 2 + 2) {
1409     char *newptr;
1410     size_t newsize = filename_size * 2 + 2;
1411     newptr = realloc(rar->filename, newsize);
1412     if (newptr == NULL) {
1413       archive_set_error(&a->archive, ENOMEM,
1414                         "Couldn't allocate memory.");
1415       return (ARCHIVE_FATAL);
1416     }
1417     rar->filename = newptr;
1418     rar->filename_allocated = newsize;
1419   }
1420   filename = rar->filename;
1421   memcpy(filename, p, filename_size);
1422   filename[filename_size] = '\0';
1423   if (rar->file_flags & FHD_UNICODE)
1424   {
1425     if (filename_size != strlen(filename))
1426     {
1427       unsigned char highbyte, flagbits, flagbyte;
1428       unsigned fn_end, offset;
1429
1430       end = filename_size;
1431       fn_end = filename_size * 2;
1432       filename_size = 0;
1433       offset = (unsigned)strlen(filename) + 1;
1434       highbyte = *(p + offset++);
1435       flagbits = 0;
1436       flagbyte = 0;
1437       while (offset < end && filename_size < fn_end)
1438       {
1439         if (!flagbits)
1440         {
1441           flagbyte = *(p + offset++);
1442           flagbits = 8;
1443         }
1444
1445         flagbits -= 2;
1446         switch((flagbyte >> flagbits) & 3)
1447         {
1448           case 0:
1449             filename[filename_size++] = '\0';
1450             filename[filename_size++] = *(p + offset++);
1451             break;
1452           case 1:
1453             filename[filename_size++] = highbyte;
1454             filename[filename_size++] = *(p + offset++);
1455             break;
1456           case 2:
1457             filename[filename_size++] = *(p + offset + 1);
1458             filename[filename_size++] = *(p + offset);
1459             offset += 2;
1460             break;
1461           case 3:
1462           {
1463             char extra, high;
1464             uint8_t length = *(p + offset++);
1465
1466             if (length & 0x80) {
1467               extra = *(p + offset++);
1468               high = (char)highbyte;
1469             } else
1470               extra = high = 0;
1471             length = (length & 0x7f) + 2;
1472             while (length && filename_size < fn_end) {
1473               unsigned cp = filename_size >> 1;
1474               filename[filename_size++] = high;
1475               filename[filename_size++] = p[cp] + extra;
1476               length--;
1477             }
1478           }
1479           break;
1480         }
1481       }
1482       if (filename_size > fn_end) {
1483         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1484           "Invalid filename");
1485         return (ARCHIVE_FATAL);
1486       }
1487       filename[filename_size++] = '\0';
1488       /*
1489        * Do not increment filename_size here as the computations below
1490        * add the space for the terminating NUL explicitly.
1491        */
1492       filename[filename_size] = '\0';
1493
1494       /* Decoded unicode form is UTF-16BE, so we have to update a string
1495        * conversion object for it. */
1496       if (rar->sconv_utf16be == NULL) {
1497         rar->sconv_utf16be = archive_string_conversion_from_charset(
1498            &a->archive, "UTF-16BE", 1);
1499         if (rar->sconv_utf16be == NULL)
1500           return (ARCHIVE_FATAL);
1501       }
1502       fn_sconv = rar->sconv_utf16be;
1503
1504       strp = filename;
1505       while (memcmp(strp, "\x00\x00", 2))
1506       {
1507         if (!memcmp(strp, "\x00\\", 2))
1508           *(strp + 1) = '/';
1509         strp += 2;
1510       }
1511       p += offset;
1512     } else {
1513       /*
1514        * If FHD_UNICODE is set but no unicode data, this file name form
1515        * is UTF-8, so we have to update a string conversion object for
1516        * it accordingly.
1517        */
1518       if (rar->sconv_utf8 == NULL) {
1519         rar->sconv_utf8 = archive_string_conversion_from_charset(
1520            &a->archive, "UTF-8", 1);
1521         if (rar->sconv_utf8 == NULL)
1522           return (ARCHIVE_FATAL);
1523       }
1524       fn_sconv = rar->sconv_utf8;
1525       while ((strp = strchr(filename, '\\')) != NULL)
1526         *strp = '/';
1527       p += filename_size;
1528     }
1529   }
1530   else
1531   {
1532     fn_sconv = sconv;
1533     while ((strp = strchr(filename, '\\')) != NULL)
1534       *strp = '/';
1535     p += filename_size;
1536   }
1537
1538   /* Split file in multivolume RAR. No more need to process header. */
1539   if (rar->filename_save &&
1540     filename_size == rar->filename_save_size &&
1541     !memcmp(rar->filename, rar->filename_save, filename_size + 1))
1542   {
1543     __archive_read_consume(a, header_size - 7);
1544     rar->cursor++;
1545     if (rar->cursor >= rar->nodes)
1546     {
1547       rar->nodes++;
1548       if ((rar->dbo =
1549         realloc(rar->dbo, sizeof(*rar->dbo) * rar->nodes)) == NULL)
1550       {
1551         archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
1552         return (ARCHIVE_FATAL);
1553       }
1554       rar->dbo[rar->cursor].header_size = header_size;
1555       rar->dbo[rar->cursor].start_offset = -1;
1556       rar->dbo[rar->cursor].end_offset = -1;
1557     }
1558     if (rar->dbo[rar->cursor].start_offset < 0)
1559     {
1560       rar->dbo[rar->cursor].start_offset = a->filter->position;
1561       rar->dbo[rar->cursor].end_offset = rar->dbo[rar->cursor].start_offset +
1562         rar->packed_size;
1563     }
1564     return ret;
1565   }
1566   else if (rar->filename_must_match)
1567   {
1568     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1569       "Mismatch of file parts split across multi-volume archive");
1570     return (ARCHIVE_FATAL);
1571   }
1572
1573   rar->filename_save = (char*)realloc(rar->filename_save,
1574                                       filename_size + 1);
1575   memcpy(rar->filename_save, rar->filename, filename_size + 1);
1576   rar->filename_save_size = filename_size;
1577
1578   /* Set info for seeking */
1579   free(rar->dbo);
1580   if ((rar->dbo = calloc(1, sizeof(*rar->dbo))) == NULL)
1581   {
1582     archive_set_error(&a->archive, ENOMEM, "Couldn't allocate memory.");
1583     return (ARCHIVE_FATAL);
1584   }
1585   rar->dbo[0].header_size = header_size;
1586   rar->dbo[0].start_offset = -1;
1587   rar->dbo[0].end_offset = -1;
1588   rar->cursor = 0;
1589   rar->nodes = 1;
1590
1591   if (rar->file_flags & FHD_SALT)
1592   {
1593     if (p + 8 > endp) {
1594       archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1595         "Invalid header size");
1596       return (ARCHIVE_FATAL);
1597     }
1598     memcpy(rar->salt, p, 8);
1599     p += 8;
1600   }
1601
1602   if (rar->file_flags & FHD_EXTTIME) {
1603     if (read_exttime(p, rar, endp) < 0) {
1604       archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1605         "Invalid header size");
1606       return (ARCHIVE_FATAL);
1607     }
1608   }
1609
1610   __archive_read_consume(a, header_size - 7);
1611   rar->dbo[0].start_offset = a->filter->position;
1612   rar->dbo[0].end_offset = rar->dbo[0].start_offset + rar->packed_size;
1613
1614   switch(file_header.host_os)
1615   {
1616   case OS_MSDOS:
1617   case OS_OS2:
1618   case OS_WIN32:
1619     rar->mode = archive_le32dec(file_header.file_attr);
1620     if (rar->mode & FILE_ATTRIBUTE_DIRECTORY)
1621       rar->mode = AE_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
1622     else
1623       rar->mode = AE_IFREG;
1624     rar->mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
1625     break;
1626
1627   case OS_UNIX:
1628   case OS_MAC_OS:
1629   case OS_BEOS:
1630     rar->mode = archive_le32dec(file_header.file_attr);
1631     break;
1632
1633   default:
1634     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1635                       "Unknown file attributes from RAR file's host OS");
1636     return (ARCHIVE_FATAL);
1637   }
1638
1639   rar->bytes_uncopied = rar->bytes_unconsumed = 0;
1640   rar->lzss.position = rar->offset = 0;
1641   rar->offset_seek = 0;
1642   rar->dictionary_size = 0;
1643   rar->offset_outgoing = 0;
1644   rar->br.cache_avail = 0;
1645   rar->br.avail_in = 0;
1646   rar->crc_calculated = 0;
1647   rar->entry_eof = 0;
1648   rar->valid = 1;
1649   rar->is_ppmd_block = 0;
1650   rar->start_new_table = 1;
1651   free(rar->unp_buffer);
1652   rar->unp_buffer = NULL;
1653   rar->unp_offset = 0;
1654   rar->unp_buffer_size = UNP_BUFFER_SIZE;
1655   memset(rar->lengthtable, 0, sizeof(rar->lengthtable));
1656   __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context);
1657   rar->ppmd_valid = rar->ppmd_eod = 0;
1658
1659   /* Don't set any archive entries for non-file header types */
1660   if (head_type == NEWSUB_HEAD)
1661     return ret;
1662
1663   archive_entry_set_mtime(entry, rar->mtime, rar->mnsec);
1664   archive_entry_set_ctime(entry, rar->ctime, rar->cnsec);
1665   archive_entry_set_atime(entry, rar->atime, rar->ansec);
1666   archive_entry_set_size(entry, rar->unp_size);
1667   archive_entry_set_mode(entry, rar->mode);
1668
1669   if (archive_entry_copy_pathname_l(entry, filename, filename_size, fn_sconv))
1670   {
1671     if (errno == ENOMEM)
1672     {
1673       archive_set_error(&a->archive, ENOMEM,
1674                         "Can't allocate memory for Pathname");
1675       return (ARCHIVE_FATAL);
1676     }
1677     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1678                       "Pathname cannot be converted from %s to current locale.",
1679                       archive_string_conversion_charset_name(fn_sconv));
1680     ret = (ARCHIVE_WARN);
1681   }
1682
1683   if (((rar->mode) & AE_IFMT) == AE_IFLNK)
1684   {
1685     /* Make sure a symbolic-link file does not have its body. */
1686     rar->bytes_remaining = 0;
1687     archive_entry_set_size(entry, 0);
1688
1689     /* Read a symbolic-link name. */
1690     if ((ret2 = read_symlink_stored(a, entry, sconv)) < (ARCHIVE_WARN))
1691       return ret2;
1692     if (ret > ret2)
1693       ret = ret2;
1694   }
1695
1696   if (rar->bytes_remaining == 0)
1697     rar->entry_eof = 1;
1698
1699   return ret;
1700 }
1701
1702 static time_t
1703 get_time(int ttime)
1704 {
1705   struct tm tm;
1706   tm.tm_sec = 2 * (ttime & 0x1f);
1707   tm.tm_min = (ttime >> 5) & 0x3f;
1708   tm.tm_hour = (ttime >> 11) & 0x1f;
1709   tm.tm_mday = (ttime >> 16) & 0x1f;
1710   tm.tm_mon = ((ttime >> 21) & 0x0f) - 1;
1711   tm.tm_year = ((ttime >> 25) & 0x7f) + 80;
1712   tm.tm_isdst = -1;
1713   return mktime(&tm);
1714 }
1715
1716 static int
1717 read_exttime(const char *p, struct rar *rar, const char *endp)
1718 {
1719   unsigned rmode, flags, rem, j, count;
1720   int ttime, i;
1721   struct tm *tm;
1722   time_t t;
1723   long nsec;
1724
1725   if (p + 2 > endp)
1726     return (-1);
1727   flags = archive_le16dec(p);
1728   p += 2;
1729
1730   for (i = 3; i >= 0; i--)
1731   {
1732     t = 0;
1733     if (i == 3)
1734       t = rar->mtime;
1735     rmode = flags >> i * 4;
1736     if (rmode & 8)
1737     {
1738       if (!t)
1739       {
1740         if (p + 4 > endp)
1741           return (-1);
1742         ttime = archive_le32dec(p);
1743         t = get_time(ttime);
1744         p += 4;
1745       }
1746       rem = 0;
1747       count = rmode & 3;
1748       if (p + count > endp)
1749         return (-1);
1750       for (j = 0; j < count; j++)
1751       {
1752         rem = (((unsigned)(unsigned char)*p) << 16) | (rem >> 8);
1753         p++;
1754       }
1755       tm = localtime(&t);
1756       nsec = tm->tm_sec + rem / NS_UNIT;
1757       if (rmode & 4)
1758       {
1759         tm->tm_sec++;
1760         t = mktime(tm);
1761       }
1762       if (i == 3)
1763       {
1764         rar->mtime = t;
1765         rar->mnsec = nsec;
1766       }
1767       else if (i == 2)
1768       {
1769         rar->ctime = t;
1770         rar->cnsec = nsec;
1771       }
1772       else if (i == 1)
1773       {
1774         rar->atime = t;
1775         rar->ansec = nsec;
1776       }
1777       else
1778       {
1779         rar->arctime = t;
1780         rar->arcnsec = nsec;
1781       }
1782     }
1783   }
1784   return (0);
1785 }
1786
1787 static int
1788 read_symlink_stored(struct archive_read *a, struct archive_entry *entry,
1789                     struct archive_string_conv *sconv)
1790 {
1791   const void *h;
1792   const char *p;
1793   struct rar *rar;
1794   int ret = (ARCHIVE_OK);
1795
1796   rar = (struct rar *)(a->format->data);
1797   if ((h = rar_read_ahead(a, (size_t)rar->packed_size, NULL)) == NULL)
1798     return (ARCHIVE_FATAL);
1799   p = h;
1800
1801   if (archive_entry_copy_symlink_l(entry,
1802       p, (size_t)rar->packed_size, sconv))
1803   {
1804     if (errno == ENOMEM)
1805     {
1806       archive_set_error(&a->archive, ENOMEM,
1807                         "Can't allocate memory for link");
1808       return (ARCHIVE_FATAL);
1809     }
1810     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1811                       "link cannot be converted from %s to current locale.",
1812                       archive_string_conversion_charset_name(sconv));
1813     ret = (ARCHIVE_WARN);
1814   }
1815   __archive_read_consume(a, rar->packed_size);
1816   return ret;
1817 }
1818
1819 static int
1820 read_data_stored(struct archive_read *a, const void **buff, size_t *size,
1821                  int64_t *offset)
1822 {
1823   struct rar *rar;
1824   ssize_t bytes_avail;
1825
1826   rar = (struct rar *)(a->format->data);
1827   if (rar->bytes_remaining == 0 &&
1828     !(rar->main_flags & MHD_VOLUME && rar->file_flags & FHD_SPLIT_AFTER))
1829   {
1830     *buff = NULL;
1831     *size = 0;
1832     *offset = rar->offset;
1833     if (rar->file_crc != rar->crc_calculated) {
1834       archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1835                         "File CRC error");
1836       return (ARCHIVE_FATAL);
1837     }
1838     rar->entry_eof = 1;
1839     return (ARCHIVE_EOF);
1840   }
1841
1842   *buff = rar_read_ahead(a, 1, &bytes_avail);
1843   if (bytes_avail <= 0)
1844   {
1845     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1846                       "Truncated RAR file data");
1847     return (ARCHIVE_FATAL);
1848   }
1849
1850   *size = bytes_avail;
1851   *offset = rar->offset;
1852   rar->offset += bytes_avail;
1853   rar->offset_seek += bytes_avail;
1854   rar->bytes_remaining -= bytes_avail;
1855   rar->bytes_unconsumed = bytes_avail;
1856   /* Calculate File CRC. */
1857   rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1858     (unsigned)bytes_avail);
1859   return (ARCHIVE_OK);
1860 }
1861
1862 static int
1863 read_data_compressed(struct archive_read *a, const void **buff, size_t *size,
1864                int64_t *offset)
1865 {
1866   struct rar *rar;
1867   int64_t start, end, actualend;
1868   size_t bs;
1869   int ret = (ARCHIVE_OK), sym, code, lzss_offset, length, i;
1870
1871   rar = (struct rar *)(a->format->data);
1872
1873   do {
1874     if (!rar->valid)
1875       return (ARCHIVE_FATAL);
1876     if (rar->ppmd_eod ||
1877        (rar->dictionary_size && rar->offset >= rar->unp_size))
1878     {
1879       if (rar->unp_offset > 0) {
1880         /*
1881          * We have unprocessed extracted data. write it out.
1882          */
1883         *buff = rar->unp_buffer;
1884         *size = rar->unp_offset;
1885         *offset = rar->offset_outgoing;
1886         rar->offset_outgoing += *size;
1887         /* Calculate File CRC. */
1888         rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1889           (unsigned)*size);
1890         rar->unp_offset = 0;
1891         return (ARCHIVE_OK);
1892       }
1893       *buff = NULL;
1894       *size = 0;
1895       *offset = rar->offset;
1896       if (rar->file_crc != rar->crc_calculated) {
1897         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1898                           "File CRC error");
1899         return (ARCHIVE_FATAL);
1900       }
1901       rar->entry_eof = 1;
1902       return (ARCHIVE_EOF);
1903     }
1904
1905     if (!rar->is_ppmd_block && rar->dictionary_size && rar->bytes_uncopied > 0)
1906     {
1907       if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset))
1908         bs = rar->unp_buffer_size - rar->unp_offset;
1909       else
1910         bs = (size_t)rar->bytes_uncopied;
1911       ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs);
1912       if (ret != ARCHIVE_OK)
1913         return (ret);
1914       rar->offset += bs;
1915       rar->bytes_uncopied -= bs;
1916       if (*buff != NULL) {
1917         rar->unp_offset = 0;
1918         *size = rar->unp_buffer_size;
1919         *offset = rar->offset_outgoing;
1920         rar->offset_outgoing += *size;
1921         /* Calculate File CRC. */
1922         rar->crc_calculated = crc32(rar->crc_calculated, *buff,
1923           (unsigned)*size);
1924         return (ret);
1925       }
1926       continue;
1927     }
1928
1929     if (!rar->br.next_in &&
1930       (ret = rar_br_preparation(a, &(rar->br))) < ARCHIVE_WARN)
1931       return (ret);
1932     if (rar->start_new_table && ((ret = parse_codes(a)) < (ARCHIVE_WARN)))
1933       return (ret);
1934
1935     if (rar->is_ppmd_block)
1936     {
1937       if ((sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1938         &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1939       {
1940         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1941                           "Invalid symbol");
1942         return (ARCHIVE_FATAL);
1943       }
1944       if(sym != rar->ppmd_escape)
1945       {
1946         lzss_emit_literal(rar, sym);
1947         rar->bytes_uncopied++;
1948       }
1949       else
1950       {
1951         if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1952           &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1953         {
1954           archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1955                             "Invalid symbol");
1956           return (ARCHIVE_FATAL);
1957         }
1958
1959         switch(code)
1960         {
1961           case 0:
1962             rar->start_new_table = 1;
1963             return read_data_compressed(a, buff, size, offset);
1964
1965           case 2:
1966             rar->ppmd_eod = 1;/* End Of ppmd Data. */
1967             continue;
1968
1969           case 3:
1970             archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1971                               "Parsing filters is unsupported.");
1972             return (ARCHIVE_FAILED);
1973
1974           case 4:
1975             lzss_offset = 0;
1976             for (i = 2; i >= 0; i--)
1977             {
1978               if ((code = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1979                 &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1980               {
1981                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1982                                   "Invalid symbol");
1983                 return (ARCHIVE_FATAL);
1984               }
1985               lzss_offset |= code << (i * 8);
1986             }
1987             if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1988               &rar->ppmd7_context, &rar->range_dec.p)) < 0)
1989             {
1990               archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1991                                 "Invalid symbol");
1992               return (ARCHIVE_FATAL);
1993             }
1994             lzss_emit_match(rar, lzss_offset + 2, length + 32);
1995             rar->bytes_uncopied += length + 32;
1996             break;
1997
1998           case 5:
1999             if ((length = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
2000               &rar->ppmd7_context, &rar->range_dec.p)) < 0)
2001             {
2002               archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2003                                 "Invalid symbol");
2004               return (ARCHIVE_FATAL);
2005             }
2006             lzss_emit_match(rar, 1, length + 4);
2007             rar->bytes_uncopied += length + 4;
2008             break;
2009
2010          default:
2011            lzss_emit_literal(rar, sym);
2012            rar->bytes_uncopied++;
2013         }
2014       }
2015     }
2016     else
2017     {
2018       start = rar->offset;
2019       end = start + rar->dictionary_size;
2020       rar->filterstart = INT64_MAX;
2021
2022       if ((actualend = expand(a, end)) < 0)
2023         return ((int)actualend);
2024
2025       rar->bytes_uncopied = actualend - start;
2026       if (rar->bytes_uncopied == 0) {
2027           /* Broken RAR files cause this case.
2028           * NOTE: If this case were possible on a normal RAR file
2029           * we would find out where it was actually bad and
2030           * what we would do to solve it. */
2031           archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2032                             "Internal error extracting RAR file");
2033           return (ARCHIVE_FATAL);
2034       }
2035     }
2036     if (rar->bytes_uncopied > (rar->unp_buffer_size - rar->unp_offset))
2037       bs = rar->unp_buffer_size - rar->unp_offset;
2038     else
2039       bs = (size_t)rar->bytes_uncopied;
2040     ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs);
2041     if (ret != ARCHIVE_OK)
2042       return (ret);
2043     rar->offset += bs;
2044     rar->bytes_uncopied -= bs;
2045     /*
2046      * If *buff is NULL, it means unp_buffer is not full.
2047      * So we have to continue extracting a RAR file.
2048      */
2049   } while (*buff == NULL);
2050
2051   rar->unp_offset = 0;
2052   *size = rar->unp_buffer_size;
2053   *offset = rar->offset_outgoing;
2054   rar->offset_outgoing += *size;
2055   /* Calculate File CRC. */
2056   rar->crc_calculated = crc32(rar->crc_calculated, *buff, (unsigned)*size);
2057   return ret;
2058 }
2059
2060 static int
2061 parse_codes(struct archive_read *a)
2062 {
2063   int i, j, val, n, r;
2064   unsigned char bitlengths[MAX_SYMBOLS], zerocount, ppmd_flags;
2065   unsigned int maxorder;
2066   struct huffman_code precode;
2067   struct rar *rar = (struct rar *)(a->format->data);
2068   struct rar_br *br = &(rar->br);
2069
2070   free_codes(a);
2071
2072   /* Skip to the next byte */
2073   rar_br_consume_unalined_bits(br);
2074
2075   /* PPMd block flag */
2076   if (!rar_br_read_ahead(a, br, 1))
2077     goto truncated_data;
2078   if ((rar->is_ppmd_block = rar_br_bits(br, 1)) != 0)
2079   {
2080     rar_br_consume(br, 1);
2081     if (!rar_br_read_ahead(a, br, 7))
2082       goto truncated_data;
2083     ppmd_flags = rar_br_bits(br, 7);
2084     rar_br_consume(br, 7);
2085
2086     /* Memory is allocated in MB */
2087     if (ppmd_flags & 0x20)
2088     {
2089       if (!rar_br_read_ahead(a, br, 8))
2090         goto truncated_data;
2091       rar->dictionary_size = (rar_br_bits(br, 8) + 1) << 20;
2092       rar_br_consume(br, 8);
2093     }
2094
2095     if (ppmd_flags & 0x40)
2096     {
2097       if (!rar_br_read_ahead(a, br, 8))
2098         goto truncated_data;
2099       rar->ppmd_escape = rar->ppmd7_context.InitEsc = rar_br_bits(br, 8);
2100       rar_br_consume(br, 8);
2101     }
2102     else
2103       rar->ppmd_escape = 2;
2104
2105     if (ppmd_flags & 0x20)
2106     {
2107       maxorder = (ppmd_flags & 0x1F) + 1;
2108       if(maxorder > 16)
2109         maxorder = 16 + (maxorder - 16) * 3;
2110
2111       if (maxorder == 1)
2112       {
2113         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2114                           "Truncated RAR file data");
2115         return (ARCHIVE_FATAL);
2116       }
2117
2118       /* Make sure ppmd7_contest is freed before Ppmd7_Construct
2119        * because reading a broken file cause this abnormal sequence. */
2120       __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context);
2121
2122       rar->bytein.a = a;
2123       rar->bytein.Read = &ppmd_read;
2124       __archive_ppmd7_functions.PpmdRAR_RangeDec_CreateVTable(&rar->range_dec);
2125       rar->range_dec.Stream = &rar->bytein;
2126       __archive_ppmd7_functions.Ppmd7_Construct(&rar->ppmd7_context);
2127
2128       if (rar->dictionary_size == 0) {
2129               archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2130                           "Invalid zero dictionary size");
2131               return (ARCHIVE_FATAL);
2132       }
2133
2134       if (!__archive_ppmd7_functions.Ppmd7_Alloc(&rar->ppmd7_context,
2135         rar->dictionary_size))
2136       {
2137         archive_set_error(&a->archive, ENOMEM,
2138                           "Out of memory");
2139         return (ARCHIVE_FATAL);
2140       }
2141       if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec))
2142       {
2143         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2144                           "Unable to initialize PPMd range decoder");
2145         return (ARCHIVE_FATAL);
2146       }
2147       __archive_ppmd7_functions.Ppmd7_Init(&rar->ppmd7_context, maxorder);
2148       rar->ppmd_valid = 1;
2149     }
2150     else
2151     {
2152       if (!rar->ppmd_valid) {
2153         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2154                           "Invalid PPMd sequence");
2155         return (ARCHIVE_FATAL);
2156       }
2157       if (!__archive_ppmd7_functions.PpmdRAR_RangeDec_Init(&rar->range_dec))
2158       {
2159         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2160                           "Unable to initialize PPMd range decoder");
2161         return (ARCHIVE_FATAL);
2162       }
2163     }
2164   }
2165   else
2166   {
2167     rar_br_consume(br, 1);
2168
2169     /* Keep existing table flag */
2170     if (!rar_br_read_ahead(a, br, 1))
2171       goto truncated_data;
2172     if (!rar_br_bits(br, 1))
2173       memset(rar->lengthtable, 0, sizeof(rar->lengthtable));
2174     rar_br_consume(br, 1);
2175
2176     memset(&bitlengths, 0, sizeof(bitlengths));
2177     for (i = 0; i < MAX_SYMBOLS;)
2178     {
2179       if (!rar_br_read_ahead(a, br, 4))
2180         goto truncated_data;
2181       bitlengths[i++] = rar_br_bits(br, 4);
2182       rar_br_consume(br, 4);
2183       if (bitlengths[i-1] == 0xF)
2184       {
2185         if (!rar_br_read_ahead(a, br, 4))
2186           goto truncated_data;
2187         zerocount = rar_br_bits(br, 4);
2188         rar_br_consume(br, 4);
2189         if (zerocount)
2190         {
2191           i--;
2192           for (j = 0; j < zerocount + 2 && i < MAX_SYMBOLS; j++)
2193             bitlengths[i++] = 0;
2194         }
2195       }
2196     }
2197
2198     memset(&precode, 0, sizeof(precode));
2199     r = create_code(a, &precode, bitlengths, MAX_SYMBOLS, MAX_SYMBOL_LENGTH);
2200     if (r != ARCHIVE_OK) {
2201       free(precode.tree);
2202       free(precode.table);
2203       return (r);
2204     }
2205
2206     for (i = 0; i < HUFFMAN_TABLE_SIZE;)
2207     {
2208       if ((val = read_next_symbol(a, &precode)) < 0) {
2209         free(precode.tree);
2210         free(precode.table);
2211         return (ARCHIVE_FATAL);
2212       }
2213       if (val < 16)
2214       {
2215         rar->lengthtable[i] = (rar->lengthtable[i] + val) & 0xF;
2216         i++;
2217       }
2218       else if (val < 18)
2219       {
2220         if (i == 0)
2221         {
2222           free(precode.tree);
2223           free(precode.table);
2224           archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2225                             "Internal error extracting RAR file.");
2226           return (ARCHIVE_FATAL);
2227         }
2228
2229         if(val == 16) {
2230           if (!rar_br_read_ahead(a, br, 3)) {
2231             free(precode.tree);
2232             free(precode.table);
2233             goto truncated_data;
2234           }
2235           n = rar_br_bits(br, 3) + 3;
2236           rar_br_consume(br, 3);
2237         } else {
2238           if (!rar_br_read_ahead(a, br, 7)) {
2239             free(precode.tree);
2240             free(precode.table);
2241             goto truncated_data;
2242           }
2243           n = rar_br_bits(br, 7) + 11;
2244           rar_br_consume(br, 7);
2245         }
2246
2247         for (j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++)
2248         {
2249           rar->lengthtable[i] = rar->lengthtable[i-1];
2250           i++;
2251         }
2252       }
2253       else
2254       {
2255         if(val == 18) {
2256           if (!rar_br_read_ahead(a, br, 3)) {
2257             free(precode.tree);
2258             free(precode.table);
2259             goto truncated_data;
2260           }
2261           n = rar_br_bits(br, 3) + 3;
2262           rar_br_consume(br, 3);
2263         } else {
2264           if (!rar_br_read_ahead(a, br, 7)) {
2265             free(precode.tree);
2266             free(precode.table);
2267             goto truncated_data;
2268           }
2269           n = rar_br_bits(br, 7) + 11;
2270           rar_br_consume(br, 7);
2271         }
2272
2273         for(j = 0; j < n && i < HUFFMAN_TABLE_SIZE; j++)
2274           rar->lengthtable[i++] = 0;
2275       }
2276     }
2277     free(precode.tree);
2278     free(precode.table);
2279
2280     r = create_code(a, &rar->maincode, &rar->lengthtable[0], MAINCODE_SIZE,
2281                 MAX_SYMBOL_LENGTH);
2282     if (r != ARCHIVE_OK)
2283       return (r);
2284     r = create_code(a, &rar->offsetcode, &rar->lengthtable[MAINCODE_SIZE],
2285                 OFFSETCODE_SIZE, MAX_SYMBOL_LENGTH);
2286     if (r != ARCHIVE_OK)
2287       return (r);
2288     r = create_code(a, &rar->lowoffsetcode,
2289                 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE],
2290                 LOWOFFSETCODE_SIZE, MAX_SYMBOL_LENGTH);
2291     if (r != ARCHIVE_OK)
2292       return (r);
2293     r = create_code(a, &rar->lengthcode,
2294                 &rar->lengthtable[MAINCODE_SIZE + OFFSETCODE_SIZE +
2295                 LOWOFFSETCODE_SIZE], LENGTHCODE_SIZE, MAX_SYMBOL_LENGTH);
2296     if (r != ARCHIVE_OK)
2297       return (r);
2298   }
2299
2300   if (!rar->dictionary_size || !rar->lzss.window)
2301   {
2302     /* Seems as though dictionary sizes are not used. Even so, minimize
2303      * memory usage as much as possible.
2304      */
2305     void *new_window;
2306     unsigned int new_size;
2307
2308     if (rar->unp_size >= DICTIONARY_MAX_SIZE)
2309       new_size = DICTIONARY_MAX_SIZE;
2310     else
2311       new_size = rar_fls((unsigned int)rar->unp_size) << 1;
2312     if (new_size == 0) {
2313       archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2314                         "Zero window size is invalid.");
2315       return (ARCHIVE_FATAL);
2316     }
2317     new_window = realloc(rar->lzss.window, new_size);
2318     if (new_window == NULL) {
2319       archive_set_error(&a->archive, ENOMEM,
2320                         "Unable to allocate memory for uncompressed data.");
2321       return (ARCHIVE_FATAL);
2322     }
2323     rar->lzss.window = (unsigned char *)new_window;
2324     rar->dictionary_size = new_size;
2325     memset(rar->lzss.window, 0, rar->dictionary_size);
2326     rar->lzss.mask = rar->dictionary_size - 1;
2327   }
2328
2329   rar->start_new_table = 0;
2330   return (ARCHIVE_OK);
2331 truncated_data:
2332   archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2333                     "Truncated RAR file data");
2334   rar->valid = 0;
2335   return (ARCHIVE_FATAL);
2336 }
2337
2338 static void
2339 free_codes(struct archive_read *a)
2340 {
2341   struct rar *rar = (struct rar *)(a->format->data);
2342   free(rar->maincode.tree);
2343   free(rar->offsetcode.tree);
2344   free(rar->lowoffsetcode.tree);
2345   free(rar->lengthcode.tree);
2346   free(rar->maincode.table);
2347   free(rar->offsetcode.table);
2348   free(rar->lowoffsetcode.table);
2349   free(rar->lengthcode.table);
2350   memset(&rar->maincode, 0, sizeof(rar->maincode));
2351   memset(&rar->offsetcode, 0, sizeof(rar->offsetcode));
2352   memset(&rar->lowoffsetcode, 0, sizeof(rar->lowoffsetcode));
2353   memset(&rar->lengthcode, 0, sizeof(rar->lengthcode));
2354 }
2355
2356
2357 static int
2358 read_next_symbol(struct archive_read *a, struct huffman_code *code)
2359 {
2360   unsigned char bit;
2361   unsigned int bits;
2362   int length, value, node;
2363   struct rar *rar;
2364   struct rar_br *br;
2365
2366   if (!code->table)
2367   {
2368     if (make_table(a, code) != (ARCHIVE_OK))
2369       return -1;
2370   }
2371
2372   rar = (struct rar *)(a->format->data);
2373   br = &(rar->br);
2374
2375   /* Look ahead (peek) at bits */
2376   if (!rar_br_read_ahead(a, br, code->tablesize)) {
2377     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2378                       "Truncated RAR file data");
2379     rar->valid = 0;
2380     return -1;
2381   }
2382   bits = rar_br_bits(br, code->tablesize);
2383
2384   length = code->table[bits].length;
2385   value = code->table[bits].value;
2386
2387   if (length < 0)
2388   {
2389     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2390                       "Invalid prefix code in bitstream");
2391     return -1;
2392   }
2393
2394   if (length <= code->tablesize)
2395   {
2396     /* Skip length bits */
2397     rar_br_consume(br, length);
2398     return value;
2399   }
2400
2401   /* Skip tablesize bits */
2402   rar_br_consume(br, code->tablesize);
2403
2404   node = value;
2405   while (!(code->tree[node].branches[0] ==
2406     code->tree[node].branches[1]))
2407   {
2408     if (!rar_br_read_ahead(a, br, 1)) {
2409       archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2410                         "Truncated RAR file data");
2411       rar->valid = 0;
2412       return -1;
2413     }
2414     bit = rar_br_bits(br, 1);
2415     rar_br_consume(br, 1);
2416
2417     if (code->tree[node].branches[bit] < 0)
2418     {
2419       archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2420                         "Invalid prefix code in bitstream");
2421       return -1;
2422     }
2423     node = code->tree[node].branches[bit];
2424   }
2425
2426   return code->tree[node].branches[0];
2427 }
2428
2429 static int
2430 create_code(struct archive_read *a, struct huffman_code *code,
2431             unsigned char *lengths, int numsymbols, char maxlength)
2432 {
2433   int i, j, codebits = 0, symbolsleft = numsymbols;
2434
2435   code->numentries = 0;
2436   code->numallocatedentries = 0;
2437   if (new_node(code) < 0) {
2438     archive_set_error(&a->archive, ENOMEM,
2439                       "Unable to allocate memory for node data.");
2440     return (ARCHIVE_FATAL);
2441   }
2442   code->numentries = 1;
2443   code->minlength = INT_MAX;
2444   code->maxlength = INT_MIN;
2445   codebits = 0;
2446   for(i = 1; i <= maxlength; i++)
2447   {
2448     for(j = 0; j < numsymbols; j++)
2449     {
2450       if (lengths[j] != i) continue;
2451       if (add_value(a, code, j, codebits, i) != ARCHIVE_OK)
2452         return (ARCHIVE_FATAL);
2453       codebits++;
2454       if (--symbolsleft <= 0) { break; break; }
2455     }
2456     codebits <<= 1;
2457   }
2458   return (ARCHIVE_OK);
2459 }
2460
2461 static int
2462 add_value(struct archive_read *a, struct huffman_code *code, int value,
2463           int codebits, int length)
2464 {
2465   int repeatpos, lastnode, bitpos, bit, repeatnode, nextnode;
2466
2467   free(code->table);
2468   code->table = NULL;
2469
2470   if(length > code->maxlength)
2471     code->maxlength = length;
2472   if(length < code->minlength)
2473     code->minlength = length;
2474
2475   repeatpos = -1;
2476   if (repeatpos == 0 || (repeatpos >= 0
2477     && (((codebits >> (repeatpos - 1)) & 3) == 0
2478     || ((codebits >> (repeatpos - 1)) & 3) == 3)))
2479   {
2480     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2481                       "Invalid repeat position");
2482     return (ARCHIVE_FATAL);
2483   }
2484
2485   lastnode = 0;
2486   for (bitpos = length - 1; bitpos >= 0; bitpos--)
2487   {
2488     bit = (codebits >> bitpos) & 1;
2489
2490     /* Leaf node check */
2491     if (code->tree[lastnode].branches[0] ==
2492       code->tree[lastnode].branches[1])
2493     {
2494       archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2495                         "Prefix found");
2496       return (ARCHIVE_FATAL);
2497     }
2498
2499     if (bitpos == repeatpos)
2500     {
2501       /* Open branch check */
2502       if (!(code->tree[lastnode].branches[bit] < 0))
2503       {
2504         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2505                           "Invalid repeating code");
2506         return (ARCHIVE_FATAL);
2507       }
2508
2509       if ((repeatnode = new_node(code)) < 0) {
2510         archive_set_error(&a->archive, ENOMEM,
2511                           "Unable to allocate memory for node data.");
2512         return (ARCHIVE_FATAL);
2513       }
2514       if ((nextnode = new_node(code)) < 0) {
2515         archive_set_error(&a->archive, ENOMEM,
2516                           "Unable to allocate memory for node data.");
2517         return (ARCHIVE_FATAL);
2518       }
2519
2520       /* Set branches */
2521       code->tree[lastnode].branches[bit] = repeatnode;
2522       code->tree[repeatnode].branches[bit] = repeatnode;
2523       code->tree[repeatnode].branches[bit^1] = nextnode;
2524       lastnode = nextnode;
2525
2526       bitpos++; /* terminating bit already handled, skip it */
2527     }
2528     else
2529     {
2530       /* Open branch check */
2531       if (code->tree[lastnode].branches[bit] < 0)
2532       {
2533         if (new_node(code) < 0) {
2534           archive_set_error(&a->archive, ENOMEM,
2535                             "Unable to allocate memory for node data.");
2536           return (ARCHIVE_FATAL);
2537         }
2538         code->tree[lastnode].branches[bit] = code->numentries++;
2539       }
2540
2541       /* set to branch */
2542       lastnode = code->tree[lastnode].branches[bit];
2543     }
2544   }
2545
2546   if (!(code->tree[lastnode].branches[0] == -1
2547     && code->tree[lastnode].branches[1] == -2))
2548   {
2549     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2550                       "Prefix found");
2551     return (ARCHIVE_FATAL);
2552   }
2553
2554   /* Set leaf value */
2555   code->tree[lastnode].branches[0] = value;
2556   code->tree[lastnode].branches[1] = value;
2557
2558   return (ARCHIVE_OK);
2559 }
2560
2561 static int
2562 new_node(struct huffman_code *code)
2563 {
2564   void *new_tree;
2565   if (code->numallocatedentries == code->numentries) {
2566     int new_num_entries = 256;
2567     if (code->numentries > 0) {
2568         new_num_entries = code->numentries * 2;
2569     }
2570     new_tree = realloc(code->tree, new_num_entries * sizeof(*code->tree));
2571     if (new_tree == NULL)
2572         return (-1);
2573     code->tree = (struct huffman_tree_node *)new_tree;
2574     code->numallocatedentries = new_num_entries;
2575   }
2576   code->tree[code->numentries].branches[0] = -1;
2577   code->tree[code->numentries].branches[1] = -2;
2578   return 1;
2579 }
2580
2581 static int
2582 make_table(struct archive_read *a, struct huffman_code *code)
2583 {
2584   if (code->maxlength < code->minlength || code->maxlength > 10)
2585     code->tablesize = 10;
2586   else
2587     code->tablesize = code->maxlength;
2588
2589   code->table =
2590     (struct huffman_table_entry *)calloc(1, sizeof(*code->table)
2591     * ((size_t)1 << code->tablesize));
2592
2593   return make_table_recurse(a, code, 0, code->table, 0, code->tablesize);
2594 }
2595
2596 static int
2597 make_table_recurse(struct archive_read *a, struct huffman_code *code, int node,
2598                    struct huffman_table_entry *table, int depth,
2599                    int maxdepth)
2600 {
2601   int currtablesize, i, ret = (ARCHIVE_OK);
2602
2603   if (!code->tree)
2604   {
2605     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2606                       "Huffman tree was not created.");
2607     return (ARCHIVE_FATAL);
2608   }
2609   if (node < 0 || node >= code->numentries)
2610   {
2611     archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2612                       "Invalid location to Huffman tree specified.");
2613     return (ARCHIVE_FATAL);
2614   }
2615
2616   currtablesize = 1 << (maxdepth - depth);
2617
2618   if (code->tree[node].branches[0] ==
2619     code->tree[node].branches[1])
2620   {
2621     for(i = 0; i < currtablesize; i++)
2622     {
2623       table[i].length = depth;
2624       table[i].value = code->tree[node].branches[0];
2625     }
2626   }
2627   else if (node < 0)
2628   {
2629     for(i = 0; i < currtablesize; i++)
2630       table[i].length = -1;
2631   }
2632   else
2633   {
2634     if(depth == maxdepth)
2635     {
2636       table[0].length = maxdepth + 1;
2637       table[0].value = node;
2638     }
2639     else
2640     {
2641       ret |= make_table_recurse(a, code, code->tree[node].branches[0], table,
2642                                 depth + 1, maxdepth);
2643       ret |= make_table_recurse(a, code, code->tree[node].branches[1],
2644                          table + currtablesize / 2, depth + 1, maxdepth);
2645     }
2646   }
2647   return ret;
2648 }
2649
2650 static int64_t
2651 expand(struct archive_read *a, int64_t end)
2652 {
2653   static const unsigned char lengthbases[] =
2654     {   0,   1,   2,   3,   4,   5,   6,
2655         7,   8,  10,  12,  14,  16,  20,
2656        24,  28,  32,  40,  48,  56,  64,
2657        80,  96, 112, 128, 160, 192, 224 };
2658   static const unsigned char lengthbits[] =
2659     { 0, 0, 0, 0, 0, 0, 0,
2660       0, 1, 1, 1, 1, 2, 2,
2661       2, 2, 3, 3, 3, 3, 4,
2662       4, 4, 4, 5, 5, 5, 5 };
2663   static const unsigned int offsetbases[] =
2664     {       0,       1,       2,       3,       4,       6,
2665             8,      12,      16,      24,      32,      48,
2666            64,      96,     128,     192,     256,     384,
2667           512,     768,    1024,    1536,    2048,    3072,
2668          4096,    6144,    8192,   12288,   16384,   24576,
2669         32768,   49152,   65536,   98304,  131072,  196608,
2670        262144,  327680,  393216,  458752,  524288,  589824,
2671        655360,  720896,  786432,  851968,  917504,  983040,
2672       1048576, 1310720, 1572864, 1835008, 2097152, 2359296,
2673       2621440, 2883584, 3145728, 3407872, 3670016, 3932160 };
2674   static const unsigned char offsetbits[] =
2675     {  0,  0,  0,  0,  1,  1,  2,  2,  3,  3,  4,  4,
2676        5,  5,  6,  6,  7,  7,  8,  8,  9,  9, 10, 10,
2677       11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
2678       16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
2679       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 };
2680   static const unsigned char shortbases[] =
2681     { 0, 4, 8, 16, 32, 64, 128, 192 };
2682   static const unsigned char shortbits[] =
2683     { 2, 2, 3, 4, 5, 6, 6, 6 };
2684
2685   int symbol, offs, len, offsindex, lensymbol, i, offssymbol, lowoffsetsymbol;
2686   unsigned char newfile;
2687   struct rar *rar = (struct rar *)(a->format->data);
2688   struct rar_br *br = &(rar->br);
2689
2690   if (rar->filterstart < end)
2691     end = rar->filterstart;
2692
2693   while (1)
2694   {
2695     if (rar->output_last_match &&
2696       lzss_position(&rar->lzss) + rar->lastlength <= end)
2697     {
2698       lzss_emit_match(rar, rar->lastoffset, rar->lastlength);
2699       rar->output_last_match = 0;
2700     }
2701
2702     if(rar->is_ppmd_block || rar->output_last_match ||
2703       lzss_position(&rar->lzss) >= end)
2704       return lzss_position(&rar->lzss);
2705
2706     if ((symbol = read_next_symbol(a, &rar->maincode)) < 0)
2707       return (ARCHIVE_FATAL);
2708     rar->output_last_match = 0;
2709
2710     if (symbol < 256)
2711     {
2712       lzss_emit_literal(rar, symbol);
2713       continue;
2714     }
2715     else if (symbol == 256)
2716     {
2717       if (!rar_br_read_ahead(a, br, 1))
2718         goto truncated_data;
2719       newfile = !rar_br_bits(br, 1);
2720       rar_br_consume(br, 1);
2721
2722       if(newfile)
2723       {
2724         rar->start_new_block = 1;
2725         if (!rar_br_read_ahead(a, br, 1))
2726           goto truncated_data;
2727         rar->start_new_table = rar_br_bits(br, 1);
2728         rar_br_consume(br, 1);
2729         return lzss_position(&rar->lzss);
2730       }
2731       else
2732       {
2733         if (parse_codes(a) != ARCHIVE_OK)
2734           return (ARCHIVE_FATAL);
2735         continue;
2736       }
2737     }
2738     else if(symbol==257)
2739     {
2740       archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2741                         "Parsing filters is unsupported.");
2742       return (ARCHIVE_FAILED);
2743     }
2744     else if(symbol==258)
2745     {
2746       if(rar->lastlength == 0)
2747         continue;
2748
2749       offs = rar->lastoffset;
2750       len = rar->lastlength;
2751     }
2752     else if (symbol <= 262)
2753     {
2754       offsindex = symbol - 259;
2755       offs = rar->oldoffset[offsindex];
2756
2757       if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0)
2758         goto bad_data;
2759       if (lensymbol > (int)(sizeof(lengthbases)/sizeof(lengthbases[0])))
2760         goto bad_data;
2761       if (lensymbol > (int)(sizeof(lengthbits)/sizeof(lengthbits[0])))
2762         goto bad_data;
2763       len = lengthbases[lensymbol] + 2;
2764       if (lengthbits[lensymbol] > 0) {
2765         if (!rar_br_read_ahead(a, br, lengthbits[lensymbol]))
2766           goto truncated_data;
2767         len += rar_br_bits(br, lengthbits[lensymbol]);
2768         rar_br_consume(br, lengthbits[lensymbol]);
2769       }
2770
2771       for (i = offsindex; i > 0; i--)
2772         rar->oldoffset[i] = rar->oldoffset[i-1];
2773       rar->oldoffset[0] = offs;
2774     }
2775     else if(symbol<=270)
2776     {
2777       offs = shortbases[symbol-263] + 1;
2778       if(shortbits[symbol-263] > 0) {
2779         if (!rar_br_read_ahead(a, br, shortbits[symbol-263]))
2780           goto truncated_data;
2781         offs += rar_br_bits(br, shortbits[symbol-263]);
2782         rar_br_consume(br, shortbits[symbol-263]);
2783       }
2784
2785       len = 2;
2786
2787       for(i = 3; i > 0; i--)
2788         rar->oldoffset[i] = rar->oldoffset[i-1];
2789       rar->oldoffset[0] = offs;
2790     }
2791     else
2792     {
2793       if (symbol-271 > (int)(sizeof(lengthbases)/sizeof(lengthbases[0])))
2794         goto bad_data;
2795       if (symbol-271 > (int)(sizeof(lengthbits)/sizeof(lengthbits[0])))
2796         goto bad_data;
2797       len = lengthbases[symbol-271]+3;
2798       if(lengthbits[symbol-271] > 0) {
2799         if (!rar_br_read_ahead(a, br, lengthbits[symbol-271]))
2800           goto truncated_data;
2801         len += rar_br_bits(br, lengthbits[symbol-271]);
2802         rar_br_consume(br, lengthbits[symbol-271]);
2803       }
2804
2805       if ((offssymbol = read_next_symbol(a, &rar->offsetcode)) < 0)
2806         goto bad_data;
2807       if (offssymbol > (int)(sizeof(offsetbases)/sizeof(offsetbases[0])))
2808         goto bad_data;
2809       if (offssymbol > (int)(sizeof(offsetbits)/sizeof(offsetbits[0])))
2810         goto bad_data;
2811       offs = offsetbases[offssymbol]+1;
2812       if(offsetbits[offssymbol] > 0)
2813       {
2814         if(offssymbol > 9)
2815         {
2816           if(offsetbits[offssymbol] > 4) {
2817             if (!rar_br_read_ahead(a, br, offsetbits[offssymbol] - 4))
2818               goto truncated_data;
2819             offs += rar_br_bits(br, offsetbits[offssymbol] - 4) << 4;
2820             rar_br_consume(br, offsetbits[offssymbol] - 4);
2821           }
2822
2823           if(rar->numlowoffsetrepeats > 0)
2824           {
2825             rar->numlowoffsetrepeats--;
2826             offs += rar->lastlowoffset;
2827           }
2828           else
2829           {
2830             if ((lowoffsetsymbol =
2831               read_next_symbol(a, &rar->lowoffsetcode)) < 0)
2832               return (ARCHIVE_FATAL);
2833             if(lowoffsetsymbol == 16)
2834             {
2835               rar->numlowoffsetrepeats = 15;
2836               offs += rar->lastlowoffset;
2837             }
2838             else
2839             {
2840               offs += lowoffsetsymbol;
2841               rar->lastlowoffset = lowoffsetsymbol;
2842             }
2843           }
2844         }
2845         else {
2846           if (!rar_br_read_ahead(a, br, offsetbits[offssymbol]))
2847             goto truncated_data;
2848           offs += rar_br_bits(br, offsetbits[offssymbol]);
2849           rar_br_consume(br, offsetbits[offssymbol]);
2850         }
2851       }
2852
2853       if (offs >= 0x40000)
2854         len++;
2855       if (offs >= 0x2000)
2856         len++;
2857
2858       for(i = 3; i > 0; i--)
2859         rar->oldoffset[i] = rar->oldoffset[i-1];
2860       rar->oldoffset[0] = offs;
2861     }
2862
2863     rar->lastoffset = offs;
2864     rar->lastlength = len;
2865     rar->output_last_match = 1;
2866   }
2867 truncated_data:
2868   archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2869                     "Truncated RAR file data");
2870   rar->valid = 0;
2871   return (ARCHIVE_FATAL);
2872 bad_data:
2873   archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2874                     "Bad RAR file data");
2875   return (ARCHIVE_FATAL);
2876 }
2877
2878 static int
2879 copy_from_lzss_window(struct archive_read *a, const void **buffer,
2880                         int64_t startpos, int length)
2881 {
2882   int windowoffs, firstpart;
2883   struct rar *rar = (struct rar *)(a->format->data);
2884
2885   if (!rar->unp_buffer)
2886   {
2887     if ((rar->unp_buffer = malloc(rar->unp_buffer_size)) == NULL)
2888     {
2889       archive_set_error(&a->archive, ENOMEM,
2890                         "Unable to allocate memory for uncompressed data.");
2891       return (ARCHIVE_FATAL);
2892     }
2893   }
2894
2895   windowoffs = lzss_offset_for_position(&rar->lzss, startpos);
2896   if(windowoffs + length <= lzss_size(&rar->lzss)) {
2897     memcpy(&rar->unp_buffer[rar->unp_offset], &rar->lzss.window[windowoffs],
2898            length);
2899   } else if (length <= lzss_size(&rar->lzss)) {
2900     firstpart = lzss_size(&rar->lzss) - windowoffs;
2901     if (firstpart < 0) {
2902       archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2903                         "Bad RAR file data");
2904       return (ARCHIVE_FATAL);
2905     }
2906     if (firstpart < length) {
2907       memcpy(&rar->unp_buffer[rar->unp_offset],
2908              &rar->lzss.window[windowoffs], firstpart);
2909       memcpy(&rar->unp_buffer[rar->unp_offset + firstpart],
2910              &rar->lzss.window[0], length - firstpart);
2911     } else {
2912       memcpy(&rar->unp_buffer[rar->unp_offset],
2913              &rar->lzss.window[windowoffs], length);
2914     }
2915   } else {
2916       archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
2917                         "Bad RAR file data");
2918       return (ARCHIVE_FATAL);
2919   }
2920   rar->unp_offset += length;
2921   if (rar->unp_offset >= rar->unp_buffer_size)
2922     *buffer = rar->unp_buffer;
2923   else
2924     *buffer = NULL;
2925   return (ARCHIVE_OK);
2926 }
2927
2928 static const void *
2929 rar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail)
2930 {
2931   struct rar *rar = (struct rar *)(a->format->data);
2932   const void *h = __archive_read_ahead(a, min, avail);
2933   int ret;
2934   if (avail)
2935   {
2936     if (a->archive.read_data_is_posix_read && *avail > (ssize_t)a->archive.read_data_requested)
2937       *avail = a->archive.read_data_requested;
2938     if (*avail > rar->bytes_remaining)
2939       *avail = (ssize_t)rar->bytes_remaining;
2940     if (*avail < 0)
2941       return NULL;
2942     else if (*avail == 0 && rar->main_flags & MHD_VOLUME &&
2943       rar->file_flags & FHD_SPLIT_AFTER)
2944     {
2945       rar->filename_must_match = 1;
2946       ret = archive_read_format_rar_read_header(a, a->entry);
2947       if (ret == (ARCHIVE_EOF))
2948       {
2949         rar->has_endarc_header = 1;
2950         ret = archive_read_format_rar_read_header(a, a->entry);
2951       }
2952       rar->filename_must_match = 0;
2953       if (ret != (ARCHIVE_OK))
2954         return NULL;
2955       return rar_read_ahead(a, min, avail);
2956     }
2957   }
2958   return h;
2959 }