/* This file is part of libmspack.
  * © 2013 Intel Corporation
  *
  * libmspack is free software; you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License (LGPL) version 2.1
  *
  * For further details, see the file COPYING.LIB distributed with libmspack
  */
 
 /* The Exchange Online Addressbook (OAB or sometimes OAL) is distributed
  * as a .LZX file in one of two forms. Either a "full download" containing
  * the entire address list, or an incremental binary patch which should be
  * applied to a previous version of the full decompressed data.
  *
  * The contents and format of the decompressed OAB are not handled here.
  *
  * For a complete description of the format, see the MSDN site:
  *
  * http://msdn.microsoft.com/en-us/library/cc463914 - [MS-OXOAB].pdf
  * http://msdn.microsoft.com/en-us/library/cc483133 - [MS-PATCH].pdf
  */
 
 /* OAB decompression implementation */
 
 #include <system.h>
 #include <oab.h>
 #include <lzx.h>
 #include <crc32.h>
 
 /* prototypes */
 static int oabd_decompress(struct msoab_decompressor *self, const char *input,

                            const char *output);

 static int oabd_decompress_incremental(struct msoab_decompressor *self,

                                        const char *input, const char *base,
                                        const char *output);
 static int oabd_param(struct msoab_decompressor *base, int param, int value);
 static int copy_fh(struct mspack_system *sys, struct mspack_file *infh,
                    struct mspack_file *outfh, size_t bytes_to_copy,
                    unsigned char *buf, int buf_size);
 

 
 struct msoab_decompressor *
   mspack_create_oab_decompressor(struct mspack_system *sys)
 {
   struct msoab_decompressor_p *self = NULL;
 
   if (!sys) sys = mspack_default_system;
   if (!mspack_valid_system(sys)) return NULL;
 
   if ((self = (struct msoab_decompressor_p *) sys->alloc(sys, sizeof(struct msoab_decompressor_p)))) {
     self->base.decompress             = &oabd_decompress;
     self->base.decompress_incremental = &oabd_decompress_incremental;

     self->base.set_param              = &oabd_param;

     self->system                      = sys;

     self->buf_size                    = 4096;

   }
   return (struct msoab_decompressor *) self;
 }
 
 void mspack_destroy_oab_decompressor(struct msoab_decompressor *base) {
   struct msoab_decompressor_p *self = (struct msoab_decompressor_p *)base;
   if (self) {
     struct mspack_system *sys = self->system;
     sys->free(self);
   }
 }
 
 struct oabd_file {
   struct mspack_system *orig_sys;
   struct mspack_file *orig_file;
   unsigned int crc;
   size_t available;
 };
 
 
 static int oabd_sys_read (struct mspack_file *base_file, void *buf, int size)
 {
   struct oabd_file *file = (struct oabd_file *)base_file;
   int bytes_read;
 
   if ((size_t)size > file->available)
     size = file->available;
 
   bytes_read = file->orig_sys->read(file->orig_file, buf, size);
   if (bytes_read < 0)
     return bytes_read;
 
   file->available -= bytes_read;
   return bytes_read;
 }
 
 static int oabd_sys_write (struct mspack_file *base_file, void *buf, int size)
 {
   struct oabd_file *file = (struct oabd_file *)base_file;
   int bytes_written = file->orig_sys->write(file->orig_file, buf, size);
 
   if (bytes_written > 0)
     file->crc = crc32(file->crc, buf, bytes_written);
 
   return bytes_written;
 }
 
 static int oabd_decompress(struct msoab_decompressor *_self, const char *input,

                            const char *output)

 {
   struct msoab_decompressor_p *self = (struct msoab_decompressor_p *) _self;
   struct mspack_system *sys;
   struct mspack_file *infh = NULL;
   struct mspack_file *outfh = NULL;
   unsigned char *buf = NULL;
   unsigned char hdrbuf[oabhead_SIZEOF];
   unsigned int block_max, target_size;
   struct lzxd_stream *lzx = NULL;
   struct mspack_system oabd_sys;
   struct oabd_file in_ofh, out_ofh;
   unsigned int window_bits;
   int ret = MSPACK_ERR_OK;
 
   if (!self) return MSPACK_ERR_ARGS;
   sys = self->system;
 
   infh = sys->open(sys, input, MSPACK_SYS_OPEN_READ);
   if (!infh) {
     ret = MSPACK_ERR_OPEN;
     goto out;
   }
 
   if (sys->read(infh, hdrbuf, oabhead_SIZEOF) != oabhead_SIZEOF) {
     ret = MSPACK_ERR_READ;
     goto out;
   }
 
   if (EndGetI32(&hdrbuf[oabhead_VersionHi]) != 3 ||
       EndGetI32(&hdrbuf[oabhead_VersionLo]) != 1) {
     ret = MSPACK_ERR_SIGNATURE;
     goto out;
   }
 
   block_max   = EndGetI32(&hdrbuf[oabhead_BlockMax]);
   target_size = EndGetI32(&hdrbuf[oabhead_TargetSize]);
 
   outfh = sys->open(sys, output, MSPACK_SYS_OPEN_WRITE);
   if (!outfh) {
     ret = MSPACK_ERR_OPEN;
     goto out;
   }
 

   buf = sys->alloc(sys, self->buf_size);

   if (!buf) {
     ret = MSPACK_ERR_NOMEMORY;
     goto out;
   }
 
   oabd_sys = *sys;
   oabd_sys.read = oabd_sys_read;
   oabd_sys.write = oabd_sys_write;
 
   in_ofh.orig_sys = sys;
   in_ofh.orig_file = infh;
 
   out_ofh.orig_sys = sys;
   out_ofh.orig_file = outfh;
 
   while (target_size) {
     unsigned int blk_csize, blk_dsize, blk_crc, blk_flags;
 
     if (sys->read(infh, buf, oabblk_SIZEOF) != oabblk_SIZEOF) {
       ret = MSPACK_ERR_READ;
       goto out;
     }
     blk_flags = EndGetI32(&buf[oabblk_Flags]);
     blk_csize = EndGetI32(&buf[oabblk_CompSize]);
     blk_dsize = EndGetI32(&buf[oabblk_UncompSize]);
     blk_crc   = EndGetI32(&buf[oabblk_CRC]);
 
     if (blk_dsize > block_max || blk_dsize > target_size || blk_flags > 1) {
       ret = MSPACK_ERR_DATAFORMAT;
       goto out;
     }
 
     if (!blk_flags) {
       /* Uncompressed block */
       if (blk_dsize != blk_csize) {

         ret = MSPACK_ERR_DATAFORMAT;
         goto out;

       }

       ret = copy_fh(sys, infh, outfh, blk_dsize, buf, self->buf_size);
       if (ret) goto out;

     } else {
       /* LZX compressed block */
       window_bits = 17;
 
       while (window_bits < 25 && (1U << window_bits) < blk_dsize)

         window_bits++;

 
       in_ofh.available = blk_csize;
       out_ofh.crc = 0xffffffff;
 
       lzx = lzxd_init(&oabd_sys, (void *)&in_ofh, (void *)&out_ofh, window_bits,

                       0, self->buf_size, blk_dsize, 1);

       if (!lzx) {

         ret = MSPACK_ERR_NOMEMORY;
         goto out;

       }
 
       ret = lzxd_decompress(lzx, blk_dsize);
       if (ret != MSPACK_ERR_OK)

         goto out;

 
       lzxd_free(lzx);
       lzx = NULL;
 
       /* Consume any trailing padding bytes before the next block */

       ret = copy_fh(sys, infh, NULL, in_ofh.available, buf, self->buf_size);
       if (ret) goto out;

 
       if (out_ofh.crc != blk_crc) {

         ret = MSPACK_ERR_CHECKSUM;
         goto out;

       }
     }
     target_size -= blk_dsize;
   }
 
  out:

   if (lzx) lzxd_free(lzx);
   if (outfh) sys->close(outfh);
   if (infh) sys->close(infh);
   sys->free(buf);

 
   return ret;
 }
 
 static int oabd_decompress_incremental(struct msoab_decompressor *_self,

                                        const char *input, const char *base,
                                        const char *output)

 {
   struct msoab_decompressor_p *self = (struct msoab_decompressor_p *) _self;
   struct mspack_system *sys;
   struct mspack_file *infh = NULL;
   struct mspack_file *basefh = NULL;
   struct mspack_file *outfh = NULL;
   unsigned char *buf = NULL;
   unsigned char hdrbuf[patchhead_SIZEOF];
   unsigned int block_max, target_size;
   struct lzxd_stream *lzx = NULL;
   struct mspack_system oabd_sys;
   struct oabd_file in_ofh, out_ofh;
   unsigned int window_bits, window_size;
   int ret = MSPACK_ERR_OK;
 
   if (!self) return MSPACK_ERR_ARGS;
   sys = self->system;
 
   infh = sys->open(sys, input, MSPACK_SYS_OPEN_READ);
   if (!infh) {
     ret = MSPACK_ERR_OPEN;
     goto out;
   }
 
   if (sys->read(infh, hdrbuf, patchhead_SIZEOF) != patchhead_SIZEOF) {
     ret = MSPACK_ERR_READ;
     goto out;
   }
 
   if (EndGetI32(&hdrbuf[patchhead_VersionHi]) != 3 ||
       EndGetI32(&hdrbuf[patchhead_VersionLo]) != 2) {
     ret = MSPACK_ERR_SIGNATURE;
     goto out;
   }
 
   block_max = EndGetI32(&hdrbuf[patchhead_BlockMax]);
   target_size = EndGetI32(&hdrbuf[patchhead_TargetSize]);
 
   /* We use it for reading block headers too */
   if (block_max < patchblk_SIZEOF)
     block_max = patchblk_SIZEOF;
 
   basefh = sys->open(sys, base, MSPACK_SYS_OPEN_READ);
   if (!basefh) {
     ret = MSPACK_ERR_OPEN;
     goto out;
   }
 
   outfh = sys->open(sys, output, MSPACK_SYS_OPEN_WRITE);
   if (!outfh) {
     ret = MSPACK_ERR_OPEN;
     goto out;
   }
 

   buf = sys->alloc(sys, self->buf_size);

   if (!buf) {
     ret = MSPACK_ERR_NOMEMORY;
     goto out;
   }
 
   oabd_sys = *sys;
   oabd_sys.read = oabd_sys_read;
   oabd_sys.write = oabd_sys_write;
 
   in_ofh.orig_sys = sys;
   in_ofh.orig_file = infh;
 
   out_ofh.orig_sys = sys;
   out_ofh.orig_file = outfh;
 
   while (target_size) {
     unsigned int blk_csize, blk_dsize, blk_ssize, blk_crc;
 
     if (sys->read(infh, buf, patchblk_SIZEOF) != patchblk_SIZEOF) {
       ret = MSPACK_ERR_READ;
       goto out;
     }
     blk_csize = EndGetI32(&buf[patchblk_PatchSize]);
     blk_dsize = EndGetI32(&buf[patchblk_TargetSize]);
     blk_ssize = EndGetI32(&buf[patchblk_SourceSize]);
     blk_crc   = EndGetI32(&buf[patchblk_CRC]);
 
     if (blk_dsize > block_max || blk_dsize > target_size ||

         blk_ssize > block_max) {

       ret = MSPACK_ERR_DATAFORMAT;
       goto out;
     }
 
 
     window_size = (blk_ssize + 32767) & ~32767;
     window_size += blk_dsize;
     window_bits = 17;
 
     while (window_bits < 25 && (1U << window_bits) < window_size)
       window_bits++;
 
     in_ofh.available = blk_csize;
     out_ofh.crc = 0xffffffff;
 
     lzx = lzxd_init(&oabd_sys, (void *)&in_ofh, (void *)&out_ofh, window_bits,

                     0, 4096, blk_dsize, 1);

     if (!lzx) {
       ret = MSPACK_ERR_NOMEMORY;
       goto out;
     }
     ret = lzxd_set_reference_data(lzx, sys, basefh, blk_ssize);
     if (ret != MSPACK_ERR_OK)
       goto out;
 
     ret = lzxd_decompress(lzx, blk_dsize);
     if (ret != MSPACK_ERR_OK)
       goto out;
 
     lzxd_free(lzx);
     lzx = NULL;
 
     /* Consume any trailing padding bytes before the next block */

     ret = copy_fh(sys, infh, NULL, in_ofh.available, buf, self->buf_size);
     if (ret) goto out;

 
     if (out_ofh.crc != blk_crc) {
       ret = MSPACK_ERR_CHECKSUM;
       goto out;
     }
 
     target_size -= blk_dsize;
   }
 
  out:

   if (lzx) lzxd_free(lzx);
   if (outfh) sys->close(outfh);
   if (basefh) sys->close(basefh);
   if (infh) sys->close(infh);
   sys->free(buf);

 
   return ret;
 }

 
 static int copy_fh(struct mspack_system *sys, struct mspack_file *infh,
                    struct mspack_file *outfh, size_t bytes_to_copy,
                    unsigned char *buf, int buf_size)
 {
     while (bytes_to_copy) {
         int run = buf_size;
         if ((size_t) run > bytes_to_copy) {
             run = (int) bytes_to_copy;
         }
         if (sys->read(infh, buf, run) != run) {
             return MSPACK_ERR_READ;
         }
         if (outfh && sys->write(outfh, buf, run) != run) {
             return MSPACK_ERR_WRITE;
         }
         bytes_to_copy -= run;
     }
     return MSPACK_ERR_OK;
 }
 
 static int oabd_param(struct msoab_decompressor *base, int param, int value) {
     struct msoab_decompressor_p *self = (struct msoab_decompressor_p *) base;
     if (self && param == MSOABD_PARAM_DECOMPBUF && value >= 16) {
         /* must be at least 16 bytes (patchblk_SIZEOF, oabblk_SIZEOF) */
         self->buf_size = value;
         return MSPACK_ERR_OK;
     }
     return MSPACK_ERR_ARGS;
 }