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