oabd.c File Reference

#include <system.h>
#include <oab.h>
#include <lzx.h>
#include <crc32.h>

Go to the source code of this file.

Classes
struct	oabd_file

Functions
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)
void	mspack_destroy_oab_decompressor (struct msoab_decompressor *base)
static int	oabd_sys_read (struct mspack_file *base_file, void *buf, int size)
static int	oabd_sys_write (struct mspack_file *base_file, void *buf, int size)

Function Documentation

copy_fh()

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  )

static

Definition at line 375 of file oabd.c.

{
    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;
}

References buf_size, int, MSPACK_ERR_OK, MSPACK_ERR_READ, MSPACK_ERR_WRITE, mspack_system::read, run(), and mspack_system::write.

Referenced by oabd_decompress(), and oabd_decompress_incremental().

mspack_create_oab_decompressor()

struct msoab_decompressor* mspack_create_oab_decompressor

(

struct mspack_system *

sys

)

Creates a new OAB decompressor.

Parameters

sys	a custom mspack_system structure, or NULL to use the default

Returns

a msoab_decompressor or NULL

Definition at line 43 of file oabd.c.

{
  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;
}

References mspack_system::alloc, mspack_default_system, mspack_valid_system(), NULL, oabd_decompress(), oabd_decompress_incremental(), and oabd_param().

Referenced by main().

mspack_destroy_oab_decompressor()

void mspack_destroy_oab_decompressor

(

struct msoab_decompressor *

self

)

Destroys an existing OAB decompressor.

Parameters

self	the msoab_decompressor to destroy

Definition at line 60 of file oabd.c.

                                                                      {
  struct msoab_decompressor_p *self = (struct msoab_decompressor_p *)base;
  if (self) {
    struct mspack_system *sys = self->system;
    sys->free(self);
  }
}

References msoab_decompressor_p::base, and mspack_system::free.

Referenced by main().

oabd_decompress()

static int oabd_decompress ( struct msoab_decompressor *  self, const char *  input, const char *  output  )

static

Definition at line 103 of file oabd.c.

{
  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;
}

References mspack_system::alloc, oabd_file::available, mspack_system::close, copy_fh(), oabd_file::crc, EndGetI32, mspack_system::free, input(), lzxd_decompress(), lzxd_free(), lzxd_init(), MSPACK_ERR_ARGS, MSPACK_ERR_CHECKSUM, MSPACK_ERR_DATAFORMAT, MSPACK_ERR_NOMEMORY, MSPACK_ERR_OK, MSPACK_ERR_OPEN, MSPACK_ERR_READ, MSPACK_ERR_SIGNATURE, MSPACK_SYS_OPEN_READ, MSPACK_SYS_OPEN_WRITE, NULL, oabblk_CompSize, oabblk_CRC, oabblk_Flags, oabblk_SIZEOF, oabblk_UncompSize, oabd_sys_read(), oabd_sys_write(), oabhead_BlockMax, oabhead_SIZEOF, oabhead_TargetSize, oabhead_VersionHi, oabhead_VersionLo, mspack_system::open, oabd_file::orig_file, oabd_file::orig_sys, out, output, mspack_system::read, and mspack_system::write.

Referenced by mspack_create_oab_decompressor().

oabd_decompress_incremental()

static int oabd_decompress_incremental ( struct msoab_decompressor *  self, const char *  input, const char *  base, const char *  output  )

static

Definition at line 234 of file oabd.c.

{
  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;
}

References mspack_system::alloc, oabd_file::available, mspack_system::close, copy_fh(), oabd_file::crc, EndGetI32, mspack_system::free, input(), lzxd_decompress(), lzxd_free(), lzxd_init(), lzxd_set_reference_data(), MSPACK_ERR_ARGS, MSPACK_ERR_CHECKSUM, MSPACK_ERR_DATAFORMAT, MSPACK_ERR_NOMEMORY, MSPACK_ERR_OK, MSPACK_ERR_OPEN, MSPACK_ERR_READ, MSPACK_ERR_SIGNATURE, MSPACK_SYS_OPEN_READ, MSPACK_SYS_OPEN_WRITE, NULL, oabd_sys_read(), oabd_sys_write(), mspack_system::open, oabd_file::orig_file, oabd_file::orig_sys, out, output, patchblk_CRC, patchblk_PatchSize, patchblk_SIZEOF, patchblk_SourceSize, patchblk_TargetSize, patchhead_BlockMax, patchhead_SIZEOF, patchhead_TargetSize, patchhead_VersionHi, patchhead_VersionLo, mspack_system::read, and mspack_system::write.

Referenced by mspack_create_oab_decompressor().

oabd_param()

static int oabd_param ( struct msoab_decompressor *  base, int  param, int  value  )

static

Definition at line 395 of file oabd.c.

                                                                             {
    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;
}

References msoab_decompressor_p::base, MSOABD_PARAM_DECOMPBUF, MSPACK_ERR_ARGS, MSPACK_ERR_OK, and value.

Referenced by mspack_create_oab_decompressor().

oabd_sys_read()

static int oabd_sys_read ( struct mspack_file *  base_file, void *  buf, int  size  )

static

Definition at line 76 of file oabd.c.

{
  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;
}

Referenced by oabd_decompress(), and oabd_decompress_incremental().

oabd_sys_write()

static int oabd_sys_write ( struct mspack_file *  base_file, void *  buf, int  size  )

static

Definition at line 92 of file oabd.c.

{
  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;
}

References crc32().

Referenced by oabd_decompress(), and oabd_decompress_incremental().