/*-

* Copyright (c) 2003-2007 Tim Kientzle

* Copyright (c) 2011 Andres Mejia

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

*    notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

*    notice, this list of conditions and the following disclaimer in the

*    documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR

* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,

* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "archive_platform.h"

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#include <time.h>

#include <limits.h>

#ifdef HAVE_ZLIB_H

#include <zlib.h> /* crc32 */

#endif

#include "archive.h"

#ifndef HAVE_ZLIB_H

#include "archive_crc32.h"

#endif

#include "archive_endian.h"

#include "archive_entry.h"

#include "archive_entry_locale.h"

#include "archive_ppmd7_private.h"

#include "archive_private.h"

#include "archive_read_private.h"

/* RAR signature, also known as the mark header */

#define RAR_SIGNATURE "\x52\x61\x72\x21\x1A\x07\x00"

/* Header types */

#define MARK_HEAD    0x72

#define MAIN_HEAD    0x73

#define FILE_HEAD    0x74

#define COMM_HEAD    0x75

#define AV_HEAD      0x76

#define SUB_HEAD     0x77

#define PROTECT_HEAD 0x78

#define SIGN_HEAD    0x79

#define NEWSUB_HEAD  0x7a

#define ENDARC_HEAD  0x7b

/* Main Header Flags */

#define MHD_VOLUME       0x0001

#define MHD_COMMENT      0x0002

#define MHD_LOCK         0x0004

#define MHD_SOLID        0x0008

#define MHD_NEWNUMBERING 0x0010

#define MHD_AV           0x0020

#define MHD_PROTECT      0x0040

#define MHD_PASSWORD     0x0080

#define MHD_FIRSTVOLUME  0x0100

#define MHD_ENCRYPTVER   0x0200

/* Flags common to all headers */

#define HD_MARKDELETION     0x4000

#define HD_ADD_SIZE_PRESENT 0x8000

/* File Header Flags */

#define FHD_SPLIT_BEFORE 0x0001

#define FHD_SPLIT_AFTER  0x0002

#define FHD_PASSWORD     0x0004

#define FHD_COMMENT      0x0008

#define FHD_SOLID        0x0010

#define FHD_LARGE        0x0100

#define FHD_UNICODE      0x0200

#define FHD_SALT         0x0400

#define FHD_VERSION      0x0800

#define FHD_EXTTIME      0x1000

#define FHD_EXTFLAGS     0x2000

/* File dictionary sizes */

#define DICTIONARY_SIZE_64   0x00

#define DICTIONARY_SIZE_128  0x20

#define DICTIONARY_SIZE_256  0x40

#define DICTIONARY_SIZE_512  0x60

#define DICTIONARY_SIZE_1024 0x80

#define DICTIONARY_SIZE_2048 0xA0

#define DICTIONARY_SIZE_4096 0xC0

#define FILE_IS_DIRECTORY    0xE0

#define DICTIONARY_MASK      FILE_IS_DIRECTORY

/* OS Flags */

#define OS_MSDOS  0

#define OS_OS2    1

#define OS_WIN32  2

#define OS_UNIX   3

#define OS_MAC_OS 4

#define OS_BEOS   5

/* Compression Methods */

#define COMPRESS_METHOD_STORE   0x30

/* LZSS */

#define COMPRESS_METHOD_FASTEST 0x31

#define COMPRESS_METHOD_FAST    0x32

#define COMPRESS_METHOD_NORMAL  0x33

/* PPMd Variant H */

#define COMPRESS_METHOD_GOOD    0x34

#define COMPRESS_METHOD_BEST    0x35

#define CRC_POLYNOMIAL 0xEDB88320

#define NS_UNIT 10000000

#define DICTIONARY_MAX_SIZE 0x400000

#define MAINCODE_SIZE      299

#define OFFSETCODE_SIZE    60

#define LOWOFFSETCODE_SIZE 17

#define LENGTHCODE_SIZE    28

#define HUFFMAN_TABLE_SIZE \

  MAINCODE_SIZE + OFFSETCODE_SIZE + LOWOFFSETCODE_SIZE + LENGTHCODE_SIZE

#define MAX_SYMBOL_LENGTH 0xF

#define MAX_SYMBOLS       20

/* Virtual Machine Properties */

#define VM_MEMORY_SIZE 0x40000

#define VM_MEMORY_MASK (VM_MEMORY_SIZE - 1)

#define PROGRAM_WORK_SIZE 0x3C000

#define PROGRAM_GLOBAL_SIZE 0x2000

#define PROGRAM_SYSTEM_GLOBAL_ADDRESS PROGRAM_WORK_SIZE

#define PROGRAM_SYSTEM_GLOBAL_SIZE 0x40

#define PROGRAM_USER_GLOBAL_ADDRESS (PROGRAM_SYSTEM_GLOBAL_ADDRESS + PROGRAM_SYSTEM_GLOBAL_SIZE)

#define PROGRAM_USER_GLOBAL_SIZE (PROGRAM_GLOBAL_SIZE - PROGRAM_SYSTEM_GLOBAL_SIZE)

/*

 * Considering L1,L2 cache miss and a calling of write system-call,

 * the best size of the output buffer(uncompressed buffer) is 128K.

 * If the structure of extracting process is changed, this value

 * might be researched again.

 */

#define UNP_BUFFER_SIZE   (128 * 1024)

/* Define this here for non-Windows platforms */

#if !((defined(__WIN32__) || defined(_WIN32) || defined(__WIN32)) && !defined(__CYGWIN__))

#define FILE_ATTRIBUTE_DIRECTORY 0x10

#endif

#undef minimum

#define minimum(a, b) ((a)<(b)?(a):(b))

/* Stack overflow check */

#define MAX_COMPRESS_DEPTH 1024

/* Fields common to all headers */

struct rar_header

{

  char crc[2];

  char type;

  char flags[2];

  char size[2];

};

/* Fields common to all file headers */

struct rar_file_header

{

  char pack_size[4];

  char unp_size[4];

  char host_os;

  char file_crc[4];

  char file_time[4];

  char unp_ver;

  char method;

  char name_size[2];

  char file_attr[4];

};

struct huffman_tree_node

{

  int branches[2];

};

struct huffman_table_entry

{

  unsigned int length;

  int value;

};

struct huffman_code

{

  struct huffman_tree_node *tree;

  int numentries;

  int numallocatedentries;

  int minlength;

  int maxlength;

  int tablesize;

  struct huffman_table_entry *table;

};

struct lzss

{

  unsigned char *window;

  int mask;

  int64_t position;

};

struct data_block_offsets

{

  int64_t header_size;

  int64_t start_offset;

  int64_t end_offset;

};

struct rar_program_code

{

  uint8_t *staticdata;

  uint32_t staticdatalen;

  uint8_t *globalbackup;

  uint32_t globalbackuplen;

  uint64_t fingerprint;

  uint32_t usagecount;

  uint32_t oldfilterlength;

  struct rar_program_code *next;

};

struct rar_filter

{

  struct rar_program_code *prog;

  uint32_t initialregisters[8];

  uint8_t *globaldata;

  uint32_t globaldatalen;

  size_t blockstartpos;

  uint32_t blocklength;

  uint32_t filteredblockaddress;

  uint32_t filteredblocklength;

  struct rar_filter *next;

};

struct memory_bit_reader

{

  const uint8_t *bytes;

  size_t length;

  size_t offset;

  uint64_t bits;

  int available;

  int at_eof;

};

struct rar_virtual_machine

{

  uint32_t registers[8];

  uint8_t memory[VM_MEMORY_SIZE + sizeof(uint32_t)];

};

struct rar_filters

{

  struct rar_virtual_machine *vm;

  struct rar_program_code *progs;

  struct rar_filter *stack;

  int64_t filterstart;

  uint32_t lastfilternum;

  int64_t lastend;

  uint8_t *bytes;

  size_t bytes_ready;

};

struct audio_state

{

  int8_t weight[5];

  int16_t delta[4];

  int8_t lastdelta;

  int error[11];

  int count;

  uint8_t lastbyte;

};

struct rar

{

  /* Entries from main RAR header */

  unsigned main_flags;

  unsigned long file_crc;

  char reserved1[2];

  char reserved2[4];

  char encryptver;

  /* File header entries */

  char compression_method;

  unsigned file_flags;

  int64_t packed_size;

  int64_t unp_size;

  time_t mtime;

  long mnsec;

  mode_t mode;

  char *filename;

  char *filename_save;

  size_t filename_save_size;

  size_t filename_allocated;

  /* File header optional entries */

  char salt[8];

  time_t atime;

  long ansec;

  time_t ctime;

  long cnsec;

  time_t arctime;

  long arcnsec;

  /* Fields to help with tracking decompression of files. */

  int64_t bytes_unconsumed;

  int64_t bytes_remaining;

  int64_t bytes_uncopied;

  int64_t offset;

  int64_t offset_outgoing;

  int64_t offset_seek;

  char valid;

  unsigned int unp_offset;

  unsigned int unp_buffer_size;

  unsigned char *unp_buffer;

  unsigned int dictionary_size;

  char start_new_block;

  char entry_eof;

  unsigned long crc_calculated;

  int found_first_header;

  char has_endarc_header;

  struct data_block_offsets *dbo;

  unsigned int cursor;

  unsigned int nodes;

  char filename_must_match;

  /* LZSS members */

  struct huffman_code maincode;

  struct huffman_code offsetcode;

  struct huffman_code lowoffsetcode;

  struct huffman_code lengthcode;

  unsigned char lengthtable[HUFFMAN_TABLE_SIZE];

  struct lzss lzss;

  unsigned int lastlength;

  unsigned int lastoffset;

  unsigned int oldoffset[4];

  unsigned int lastlowoffset;

  unsigned int numlowoffsetrepeats;

  char start_new_table;

  /* Filters */

  struct rar_filters filters;

  /* PPMd Variant H members */

  char ppmd_valid;

  char ppmd_eod;

  char is_ppmd_block;

  int ppmd_escape;

  CPpmd7 ppmd7_context;

  CPpmd7z_RangeDec range_dec;

  IByteIn bytein;

  /*

   * String conversion object.

   */

  int init_default_conversion;

  struct archive_string_conv *sconv_default;

  struct archive_string_conv *opt_sconv;

  struct archive_string_conv *sconv_utf8;

  struct archive_string_conv *sconv_utf16be;

  /*

   * Bit stream reader.

   */

  struct rar_br {

#define CACHE_TYPE  uint64_t

#define CACHE_BITS  (8 * sizeof(CACHE_TYPE))

    /* Cache buffer. */

    CACHE_TYPE     cache_buffer;

    /* Indicates how many bits avail in cache_buffer. */

    int      cache_avail;

    ssize_t    avail_in;

    const unsigned char *next_in;

  } br;

  /*

   * Custom field to denote that this archive contains encrypted entries

   */

  int has_encrypted_entries;

};

static int archive_read_support_format_rar_capabilities(struct archive_read *);

static int archive_read_format_rar_has_encrypted_entries(struct archive_read *);

static int archive_read_format_rar_bid(struct archive_read *, int);

static int archive_read_format_rar_options(struct archive_read *,

    const char *, const char *);

static int archive_read_format_rar_read_header(struct archive_read *,

    struct archive_entry *);

static int archive_read_format_rar_read_data(struct archive_read *,

    const void **, size_t *, int64_t *);

static int archive_read_format_rar_read_data_skip(struct archive_read *a);

static int64_t archive_read_format_rar_seek_data(struct archive_read *, int64_t,

    int);

static int archive_read_format_rar_cleanup(struct archive_read *);

/* Support functions */

static int read_header(struct archive_read *, struct archive_entry *, char);

static time_t get_time(int);

static int read_exttime(const char *, struct rar *, const char *);

static int read_symlink_stored(struct archive_read *, struct archive_entry *,

                               struct archive_string_conv *);

static int read_data_stored(struct archive_read *, const void **, size_t *,

                            int64_t *);

static int read_data_compressed(struct archive_read *, const void **, size_t *,

                                int64_t *, size_t);

static int rar_br_preparation(struct archive_read *, struct rar_br *);

static int parse_codes(struct archive_read *);

static void free_codes(struct archive_read *);

static int read_next_symbol(struct archive_read *, struct huffman_code *);

static int create_code(struct archive_read *, struct huffman_code *,

                       unsigned char *, int, char);

static int add_value(struct archive_read *, struct huffman_code *, int, int,

                     int);

static int new_node(struct huffman_code *);

static int make_table(struct archive_read *, struct huffman_code *);

static int make_table_recurse(struct archive_read *, struct huffman_code *, int,

                              struct huffman_table_entry *, int, int);

static int expand(struct archive_read *, int64_t *);

static int copy_from_lzss_window_to_unp(struct archive_read *, const void **,

                                        int64_t, int);

static const void *rar_read_ahead(struct archive_read *, size_t, ssize_t *);

static int parse_filter(struct archive_read *, const uint8_t *, uint16_t,

                        uint8_t);

static int run_filters(struct archive_read *);

static void clear_filters(struct rar_filters *);

static struct rar_filter *create_filter(struct rar_program_code *,

                                        const uint8_t *, uint32_t,

                                        uint32_t[8], size_t, uint32_t);

static void delete_filter(struct rar_filter *filter);

static struct rar_program_code *compile_program(const uint8_t *, size_t);

static void delete_program_code(struct rar_program_code *prog);

static uint32_t membr_next_rarvm_number(struct memory_bit_reader *br);

static inline uint32_t membr_bits(struct memory_bit_reader *br, int bits);

static int membr_fill(struct memory_bit_reader *br, int bits);

static int read_filter(struct archive_read *, int64_t *);

static int rar_decode_byte(struct archive_read*, uint8_t *);

static int execute_filter(struct archive_read*, struct rar_filter *,

                          struct rar_virtual_machine *, size_t);

static int copy_from_lzss_window(struct archive_read *, void *, int64_t, int);

static inline void vm_write_32(struct rar_virtual_machine*, size_t, uint32_t);

static inline uint32_t vm_read_32(struct rar_virtual_machine*, size_t);

/*

 * Bit stream reader.

 */

/* Check that the cache buffer has enough bits. */

#define rar_br_has(br, n) ((br)->cache_avail >= n)

/* Get compressed data by bit. */

#define rar_br_bits(br, n)        \

  (((uint32_t)((br)->cache_buffer >>    \

    ((br)->cache_avail - (n)))) & cache_masks[n])

#define rar_br_bits_forced(br, n)     \

  (((uint32_t)((br)->cache_buffer <<    \

    ((n) - (br)->cache_avail))) & cache_masks[n])

/* Read ahead to make sure the cache buffer has enough compressed data we

 * will use.

 *  True  : completed, there is enough data in the cache buffer.

 *  False : there is no data in the stream. */

#define rar_br_read_ahead(a, br, n) \

  ((rar_br_has(br, (n)) || rar_br_fillup(a, br)) || rar_br_has(br, (n)))

/* Notify how many bits we consumed. */

#define rar_br_consume(br, n) ((br)->cache_avail -= (n))

#define rar_br_consume_unalined_bits(br) ((br)->cache_avail &= ~7)

static const uint32_t cache_masks[] = {

  0x00000000, 0x00000001, 0x00000003, 0x00000007,

  0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F,

  0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,

  0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF,

  0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF,

  0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,

  0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF,

  0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF,

  0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF

};

/*

 * Shift away used bits in the cache data and fill it up with following bits.

 * Call this when cache buffer does not have enough bits you need.

 *

 * Returns 1 if the cache buffer is full.

 * Returns 0 if the cache buffer is not full; input buffer is empty.

 */

static int

rar_br_fillup(struct archive_read *a, struct rar_br *br)

{

  struct rar *rar = (struct rar *)(a->format->data);

  int n = CACHE_BITS - br->cache_avail;

  for (;;) {

    switch (n >> 3) {

    case 8:

      if (br->avail_in >= 8) {

        br->cache_buffer =

            ((uint64_t)br->next_in[0]) << 56 |

            ((uint64_t)br->next_in[1]) << 48 |

            ((uint64_t)br->next_in[2]) << 40 |

            ((uint64_t)br->next_in[3]) << 32 |

            ((uint32_t)br->next_in[4]) << 24 |

            ((uint32_t)br->next_in[5]) << 16 |

            ((uint32_t)br->next_in[6]) << 8 |

             (uint32_t)br->next_in[7];

        br->next_in += 8;

        br->avail_in -= 8;

        br->cache_avail += 8 * 8;

        rar->bytes_unconsumed += 8;

        rar->bytes_remaining -= 8;

        return (1);

      }

      break;

    case 7:

      if (br->avail_in >= 7) {

        br->cache_buffer =

           (br->cache_buffer << 56) |

            ((uint64_t)br->next_in[0]) << 48 |

            ((uint64_t)br->next_in[1]) << 40 |

            ((uint64_t)br->next_in[2]) << 32 |

            ((uint32_t)br->next_in[3]) << 24 |

            ((uint32_t)br->next_in[4]) << 16 |

            ((uint32_t)br->next_in[5]) << 8 |

             (uint32_t)br->next_in[6];

        br->next_in += 7;

        br->avail_in -= 7;

        br->cache_avail += 7 * 8;

        rar->bytes_unconsumed += 7;

        rar->bytes_remaining -= 7;

        return (1);

      }

      break;

    case 6:

      if (br->avail_in >= 6) {

        br->cache_buffer =

           (br->cache_buffer << 48) |

            ((uint64_t)br->next_in[0]) << 40 |

            ((uint64_t)br->next_in[1]) << 32 |

            ((uint32_t)br->next_in[2]) << 24 |

            ((uint32_t)br->next_in[3]) << 16 |

            ((uint32_t)br->next_in[4]) << 8 |

             (uint32_t)br->next_in[5];

        br->next_in += 6;

        br->avail_in -= 6;

        br->cache_avail += 6 * 8;

        rar->bytes_unconsumed += 6;

        rar->bytes_remaining -= 6;

        return (1);

      }

      break;

    case 0:

      /* We have enough compressed data in

       * the cache buffer.*/

      return (1);

    default:

      break;

    }

    if (br->avail_in <= 0) {

      if (rar->bytes_unconsumed > 0) {

        /* Consume as much as the decompressor

         * actually used. */

        __archive_read_consume(a, rar->bytes_unconsumed);

        rar->bytes_unconsumed = 0;

      }

      br->next_in = rar_read_ahead(a, 1, &(br->avail_in));

      if (br->next_in == NULL)

        return (0);

      if (br->avail_in == 0)

        return (0);

    }

    br->cache_buffer =

       (br->cache_buffer << 8) | *br->next_in++;

    br->avail_in--;

    br->cache_avail += 8;

    n -= 8;

    rar->bytes_unconsumed++;

    rar->bytes_remaining--;

  }

}

static int

rar_br_preparation(struct archive_read *a, struct rar_br *br)

{

  struct rar *rar = (struct rar *)(a->format->data);

  if (rar->bytes_remaining > 0) {

    br->next_in = rar_read_ahead(a, 1, &(br->avail_in));

    if (br->next_in == NULL) {

      archive_set_error(&a->archive,

          ARCHIVE_ERRNO_FILE_FORMAT,

          "Truncated RAR file data");

      return (ARCHIVE_FATAL);

    }

    if (br->cache_avail == 0)

      (void)rar_br_fillup(a, br);

  }

  return (ARCHIVE_OK);

}

/* Find last bit set */

static inline int

rar_fls(unsigned int word)

{

  word |= (word >>  1);

  word |= (word >>  2);

  word |= (word >>  4);

  word |= (word >>  8);

  word |= (word >> 16);

  return word - (word >> 1);

}

/* LZSS functions */

static inline int64_t

lzss_position(struct lzss *lzss)

{

  return lzss->position;

}

static inline int

lzss_mask(struct lzss *lzss)

{

  return lzss->mask;

}

static inline int

lzss_size(struct lzss *lzss)

{

  return lzss->mask + 1;

}

static inline int

lzss_offset_for_position(struct lzss *lzss, int64_t pos)

{

  return (int)(pos & lzss->mask);

}

static inline unsigned char *

lzss_pointer_for_position(struct lzss *lzss, int64_t pos)

{

  return &lzss->window[lzss_offset_for_position(lzss, pos)];

}

static inline int

lzss_current_offset(struct lzss *lzss)

{

  return lzss_offset_for_position(lzss, lzss->position);

}

static inline uint8_t *

lzss_current_pointer(struct lzss *lzss)

{

  return lzss_pointer_for_position(lzss, lzss->position);

}

static inline void

lzss_emit_literal(struct rar *rar, uint8_t literal)

{

  *lzss_current_pointer(&rar->lzss) = literal;

  rar->lzss.position++;

}

static inline void

lzss_emit_match(struct rar *rar, int offset, int length)

{

  int dstoffs = lzss_current_offset(&rar->lzss);

  int srcoffs = (dstoffs - offset) & lzss_mask(&rar->lzss);

  int l, li, remaining;

  unsigned char *d, *s;

  remaining = length;

  while (remaining > 0) {

    l = remaining;

    if (dstoffs > srcoffs) {

      if (l > lzss_size(&rar->lzss) - dstoffs)

        l = lzss_size(&rar->lzss) - dstoffs;

    } else {

      if (l > lzss_size(&rar->lzss) - srcoffs)

        l = lzss_size(&rar->lzss) - srcoffs;

    }

    d = &(rar->lzss.window[dstoffs]);

    s = &(rar->lzss.window[srcoffs]);

    if ((dstoffs + l < srcoffs) || (srcoffs + l < dstoffs))

      memcpy(d, s, l);

    else {

      for (li = 0; li < l; li++)

        d[li] = s[li];

    }

    remaining -= l;

    dstoffs = (dstoffs + l) & lzss_mask(&(rar->lzss));

    srcoffs = (srcoffs + l) & lzss_mask(&(rar->lzss));

  }

  rar->lzss.position += length;

}

static Byte

ppmd_read(void *p)

{

  struct archive_read *a = ((IByteIn*)p)->a;

  struct rar *rar = (struct rar *)(a->format->data);

  struct rar_br *br = &(rar->br);

  Byte b;

  if (!rar_br_read_ahead(a, br, 8))

  {

    archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

                      "Truncated RAR file data");

    rar->valid = 0;

    return 0;

  }

  b = rar_br_bits(br, 8);

  rar_br_consume(br, 8);

  return b;

}

int

archive_read_support_format_rar(struct archive *_a)

{

  struct archive_read *a = (struct archive_read *)_a;

  struct rar *rar;

  int r;

  archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,

                      "archive_read_support_format_rar");

  rar = (struct rar *)calloc(1, sizeof(*rar));

  if (rar == NULL)

  {

    archive_set_error(&a->archive, ENOMEM, "Can't allocate rar data");

    return (ARCHIVE_FATAL);

  }

  /*

   * Until enough data has been read, we cannot tell about

   * any encrypted entries yet.

   */

  rar->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;

  r = __archive_read_register_format(a,

                                     rar,

                                     "rar",

                                     archive_read_format_rar_bid,

                                     archive_read_format_rar_options,

                                     archive_read_format_rar_read_header,

                                     archive_read_format_rar_read_data,

                                     archive_read_format_rar_read_data_skip,

                                     archive_read_format_rar_seek_data,

                                     archive_read_format_rar_cleanup,

                                     archive_read_support_format_rar_capabilities,

                                     archive_read_format_rar_has_encrypted_entries);

  if (r != ARCHIVE_OK)

    free(rar);

  return (r);

}

static int

archive_read_support_format_rar_capabilities(struct archive_read * a)

{

  (void)a; /* UNUSED */

  return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA

      | ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA);

}

static int

archive_read_format_rar_has_encrypted_entries(struct archive_read *_a)

{

  if (_a && _a->format) {

    struct rar * rar = (struct rar *)_a->format->data;

    if (rar) {

      return rar->has_encrypted_entries;

    }

  }

  return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;

}

static int

archive_read_format_rar_bid(struct archive_read *a, int best_bid)

{

  const char *p;

  /* If there's already a bid > 30, we'll never win. */

  if (best_bid > 30)

    return (-1);

  if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)

    return (-1);

  if (memcmp(p, RAR_SIGNATURE, 7) == 0)

    return (30);

  if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {

    /* This is a PE file */

    ssize_t offset = 0x10000;

    ssize_t window = 4096;

    ssize_t bytes_avail;

    while (offset + window <= (1024 * 128)) {

      const char *buff = __archive_read_ahead(a, offset + window, &bytes_avail);

      if (buff == NULL) {

        /* Remaining bytes are less than window. */

        window >>= 1;

        if (window < 0x40)

          return (0);

        continue;

      }

      p = buff + offset;

      while (p + 7 < buff + bytes_avail) {

        if (memcmp(p, RAR_SIGNATURE, 7) == 0)

          return (30);

        p += 0x10;

      }

      offset = p - buff;

    }

  }

  return (0);

}

static int

skip_sfx(struct archive_read *a)

{

  const void *h;

  const char *p, *q;

  size_t skip, total;

  ssize_t bytes, window;

  total = 0;

  window = 4096;

  while (total + window <= (1024 * 128)) {

    h = __archive_read_ahead(a, window, &bytes);

    if (h == NULL) {

      /* Remaining bytes are less than window. */

      window >>= 1;

      if (window < 0x40)

        goto fatal;

      continue;

    }

    if (bytes < 0x40)

      goto fatal;

    p = h;

    q = p + bytes;

    /*

     * Scan ahead until we find something that looks

     * like the RAR header.

     */

    while (p + 7 < q) {

      if (memcmp(p, RAR_SIGNATURE, 7) == 0) {

        skip = p - (const char *)h;

        __archive_read_consume(a, skip);

        return (ARCHIVE_OK);

      }

      p += 0x10;

    }

    skip = p - (const char *)h;

    __archive_read_consume(a, skip);

  total += skip;

  }

fatal:

  archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

      "Couldn't find out RAR header");

  return (ARCHIVE_FATAL);

}

static int

archive_read_format_rar_options(struct archive_read *a,

    const char *key, const char *val)

{

  struct rar *rar;

  int ret = ARCHIVE_FAILED;

  rar = (struct rar *)(a->format->data);

  if (strcmp(key, "hdrcharset")  == 0) {

    if (val == NULL || val[0] == 0)

      archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

          "rar: hdrcharset option needs a character-set name");

    else {

      rar->opt_sconv =

          archive_string_conversion_from_charset(

              &a->archive, val, 0);

      if (rar->opt_sconv != NULL)

        ret = ARCHIVE_OK;

      else

        ret = ARCHIVE_FATAL;

    }

    return (ret);

  }

  /* Note: The "warn" return is just to inform the options

   * supervisor that we didn't handle it.  It will generate

   * a suitable error if no one used this option. */

  return (ARCHIVE_WARN);

}

static int

archive_read_format_rar_read_header(struct archive_read *a,

                                    struct archive_entry *entry)

{

  const void *h;

  const char *p;

  struct rar *rar;

  size_t skip;

  char head_type;

  int ret;

  unsigned flags;

  unsigned long crc32_expected;

  a->archive.archive_format = ARCHIVE_FORMAT_RAR;

  if (a->archive.archive_format_name == NULL)

    a->archive.archive_format_name = "RAR";

  rar = (struct rar *)(a->format->data);

  /*

   * It should be sufficient to call archive_read_next_header() for

   * a reader to determine if an entry is encrypted or not. If the

   * encryption of an entry is only detectable when calling

   * archive_read_data(), so be it. We'll do the same check there

   * as well.

   */

  if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {

    rar->has_encrypted_entries = 0;

  }

  /* RAR files can be generated without EOF headers, so return ARCHIVE_EOF if

  * this fails.

  */

  if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)

    return (ARCHIVE_EOF);

  p = h;

  if (rar->found_first_header == 0 &&

     ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0)) {

    /* This is an executable ? Must be self-extracting... */

    ret = skip_sfx(a);

    if (ret < ARCHIVE_WARN)

      return (ret);

  }

  rar->found_first_header = 1;

  while (1)

  {

    unsigned long crc32_val;

    if ((h = __archive_read_ahead(a, 7, NULL)) == NULL)

      return (ARCHIVE_FATAL);

    p = h;

    head_type = p[2];

    switch(head_type)

    {

    case MARK_HEAD:

      if (memcmp(p, RAR_SIGNATURE, 7) != 0) {

        archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

          "Invalid marker header");

        return (ARCHIVE_FATAL);

      }

      __archive_read_consume(a, 7);

      break;

    case MAIN_HEAD:

      rar->main_flags = archive_le16dec(p + 3);

      skip = archive_le16dec(p + 5);

      if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)) {

        archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

          "Invalid header size");

        return (ARCHIVE_FATAL);

      }

      if ((h = __archive_read_ahead(a, skip, NULL)) == NULL)

        return (ARCHIVE_FATAL);

      p = h;

      memcpy(rar->reserved1, p + 7, sizeof(rar->reserved1));

      memcpy(rar->reserved2, p + 7 + sizeof(rar->reserved1),

             sizeof(rar->reserved2));

      if (rar->main_flags & MHD_ENCRYPTVER) {

        if (skip < 7 + sizeof(rar->reserved1) + sizeof(rar->reserved2)+1) {