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