libmspack 0.0.1

data/ext/libmspack/test/md5_fh.h

@@ -0,0 +1,123 @@
+/* an mspack_system implementation which reads one or more files, and
+ * only writes to one file; the file is not actually written to, but
+ * an MD5 sum is computed and is available once the written-to file is
+ * closed. You can use anything for the written-to filename, NULL is
+ * probably the most obvious. The code is not multithreadable.
+ */
+
+#include <md5.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+struct md5_ctx md5_context;
+char md5_string[33];
+
+struct mspack_file_p {
+    FILE *fh;
+};
+
+static struct mspack_file *m_open(struct mspack_system *self, const char *filename, int mode) {
+    struct mspack_file_p *fh;
+    if (mode != MSPACK_SYS_OPEN_WRITE &&
+	mode != MSPACK_SYS_OPEN_READ) return NULL;
+
+    if ((fh = (struct mspack_file_p *) malloc(sizeof(struct mspack_file_p)))) {
+	if (mode == MSPACK_SYS_OPEN_WRITE) {
+	    fh->fh = NULL;
+	    md5_init_ctx(&md5_context);
+	    return (struct mspack_file *) fh;
+	}
+	else {
+	    if ((fh->fh = fopen(filename, "rb")))
+		return (struct mspack_file *) fh;
+	}
+	/* error - free file handle and return NULL */
+	free(fh);
+    }
+    return NULL;
+}
+
+static void m_close(struct mspack_file *file) {
+  struct mspack_file_p *self = (struct mspack_file_p *) file;
+  if (self) {
+      if (self->fh) fclose(self->fh);
+      else {
+	  unsigned char md5[16];
+	  md5_finish_ctx(&md5_context, (void *) &md5);
+	  snprintf(md5_string, sizeof(md5_string),
+		   "%02x%02x%02x%02x%02x%02x%02x%02x"
+		   "%02x%02x%02x%02x%02x%02x%02x%02x",
+		   md5[0],  md5[1],  md5[2],  md5[3],
+		   md5[4],  md5[5],  md5[6],  md5[7],
+		   md5[8],  md5[9],  md5[10], md5[11],
+		   md5[12], md5[13], md5[14], md5[15]);
+      }
+      free(self);
+  }
+}
+
+static int m_read(struct mspack_file *file, void *buffer, int bytes) {
+  struct mspack_file_p *self = (struct mspack_file_p *) file;
+  if (self && self->fh && buffer && bytes >= 0) {
+      size_t count = fread(buffer, 1, bytes, self->fh);
+      if (!ferror(self->fh)) return (int) count;
+  }
+  return -1;
+}
+
+static int m_write(struct mspack_file *file, void *buffer, int bytes) {
+    struct mspack_file_p *self = (struct mspack_file_p *) file;
+    if (!self || self->fh || !buffer || bytes < 0) return -1;
+    md5_process_bytes(buffer, bytes, &md5_context);
+    return bytes;
+}
+
+static int m_seek(struct mspack_file *file, off_t offset, int mode) {
+    struct mspack_file_p *self = (struct mspack_file_p *) file;
+    if (self && self->fh) {
+	switch (mode) {
+	case MSPACK_SYS_SEEK_START: mode = SEEK_SET; break;
+	case MSPACK_SYS_SEEK_CUR:   mode = SEEK_CUR; break;
+	case MSPACK_SYS_SEEK_END:   mode = SEEK_END; break;
+	default: return -1;
+	}
+#if HAVE_FSEEKO
+	return fseeko(self->fh, offset, mode);
+#else
+	return fseek(self->fh, offset, mode);
+#endif
+    }
+    return -1;
+}
+
+static off_t m_tell(struct mspack_file *file) {
+    struct mspack_file_p *self = (struct mspack_file_p *) file;
+#if HAVE_FSEEKO
+    return (self && self->fh) ? (off_t) ftello(self->fh) : 0;
+#else
+    return (self && self->fh) ? (off_t) ftell(self->fh) : 0;
+#endif
+}
+
+static void m_msg(struct mspack_file *file, const char *format, ...) {
+    va_list ap;
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+    fputc((int) '\n', stderr);
+    fflush(stderr);
+}
+static void *m_alloc(struct mspack_system *self, size_t bytes) {
+    return malloc(bytes);
+}
+static void m_free(void *buffer) {
+    free(buffer);
+}
+static void m_copy(void *src, void *dest, size_t bytes) {
+    memcpy(dest, src, bytes);
+}
+
+static struct mspack_system read_files_write_md5 = {
+    &m_open, &m_close, &m_read, &m_write, &m_seek,
+    &m_tell, &m_msg, &m_alloc, &m_free, &m_copy, NULL
+};

data/ext/libmspack/test/msdecompile_md5

@@ -0,0 +1,24 @@
+#!/usr/bin/perl -w
+# put hh.exe, hhctrl.ocx and itss.dll into this directory
+# for this script to work. You can get them by downloading
+# the HTML Help Workshop from Microsoft and then doing:
+#   $ cabextract -F 'hh*' htmlhelp.exe
+#   $ cabextract -F itircl.dll hhupd.exe
+#   $ cabextract -F itss.dll hhupd.exe
+#   $ cp -a itircl.dll ~/.wine/drive_c/windows/system32/
+#   $ cp -a itss.dll ~/.wine/drive_c/windows/system32/
+#   $ wine regsvr32 /s 'C:\WINDOWS\SYSTEM32\itircl.dll'
+#   $ wine regsvr32 /s 'C:\WINDOWS\SYSTEM32\itss.dll'
+
+use strict;
+use File::Temp qw(tempdir);
+
+die "Usage: $0 <file.chm>\n" unless @ARGV == 1;
+my $hh = $0; $hh =~ s{[^/]+$}{hh.exe};
+my $dir = tempdir("./.tempXXXX", CLEANUP => 1);
+
+$ENV{LANG} = 'C';
+$ENV{WINEDLLOVERRIDES}='hhctrl.ocx,itss=n';
+print "*** $ARGV[0]\n";
+system("wine $hh -decompile $dir $ARGV[0] 1>&2 && " .
+       "cd $dir && find * -type f -print0 | xargs -0 md5sum");

data/ext/libmspack/test/msexpand_md5

@@ -0,0 +1,39 @@
+#!/usr/bin/perl -w
+# put extract.exe (or a link to it) into this directory
+# for this script to work
+
+use strict;
+use File::Temp qw(tempdir);
+use Cwd qw(cwd);
+
+my $extract = $0; $extract =~ s{[^/]+$}{extract.exe};
+my $HDR1 = 'Microsoft (R) Diamond Extraction Tool';
+my $HDR2 = 'Copyright (c) Microsoft Corp';
+
+my $dir = tempdir("./.tempXXXX", CLEANUP => 1) . '/extradir';
+mkdir $dir;
+$ENV{LANG} = 'C';
+
+for my $cab (@ARGV) {
+    my @files;
+    print "*** $cab\n";
+    for (`wine $extract /y /a /e /l $dir $cab 2>&1`) {
+        s/\015?\012$//s; # remove line endings
+        next if /^(\Q$HDR1\E|\Q$HDR2\E|\s*$| Cabinet )/;
+        if (/^Extracting \Q$dir\E\\(.+)$/) {
+	    my $file = $1;
+            $file =~ s{\\}{/}g;
+            $file =~ s{^/+}{};
+            push @files, $file;
+        }
+        else {
+            print STDERR "$_\n";
+        }
+    }
+
+    next unless @files;
+    my $olddir = cwd();
+    chdir $dir;
+    system 'md5sum', @files;
+    chdir $olddir;
+}

data/ext/libmspack/test/multifh.c

@@ -0,0 +1,435 @@
+/* An implementation of the mspack_system interface which can access many
+ * things:
+ * - regular disk files
+ * - already opened stdio FILE* file pointers
+ * - open file descriptors
+ * - blocks of memory
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <mspack.h>
+
+/* definitions */
+
+#define MTYPE_DISKFILE  (0x01)
+#define MTYPE_STDIOFH   (0x02)
+#define MTYPE_FILEDESC  (0x03)
+#define MTYPE_MEMORY    (0x04)
+
+struct m_filename {
+  unsigned char type;   /* one of MTYPE_DISKFILE, STDIOFH, FILEDESC or MEMORY */
+  const char *filename; /* the user-friendly printable filename (may be NULL) */
+  union {
+    const char *diskfile; /* char *filename      for MTYPE_DISKFILE */
+    FILE *stdiofh;        /* FILE *existing_fh   for MTYPE_STDIOFH */
+    int filedesc;         /* int file_descriptor for MTYPE_FILEDESC */
+    struct {
+      unsigned char *data;
+      size_t length;
+    } memory;
+  } x;
+};
+
+struct m_file {
+  struct m_filename *file; /* pointer back to the m_filename data */
+  union {
+    FILE *fh;        /* only used in DISKFILE, STDIOFH and FILEDESC types */
+    size_t position; /* only used in MEMORY types */
+  } x;
+};
+
+/* ------------------------------------------------------------------------ */
+/* mspack_system implementation */
+
+static void *m_alloc(struct mspack_system *self, size_t bytes) {
+  return malloc(bytes);
+}
+
+static void m_free(void *buffer) {
+  free(buffer);
+}
+
+static void m_copy(void *src, void *dest, size_t bytes) {
+  memcpy(dest, src, bytes);
+}
+
+/* A message printer that prints to stderr */
+static void m_msg(struct m_file *file, const char *format, ...) {
+  va_list ap;
+  if (file && file->file && file->file->filename) {
+    fprintf(stderr, "%s: ", file->file->filename);
+  }
+  va_start(ap, format);
+  vfprintf(stderr, format, ap);
+  va_end(ap);
+  fputc((int) '\n', stderr);
+  fflush(stderr);
+}
+
+
+static struct m_file *m_open_mem(struct mspack_system *self,
+				 struct m_filename *fn, int mode)
+{
+  struct m_file *fh;
+
+  /* validate arguments of the filename */
+  if (!fn->x.memory.data)   return NULL;
+  if (!fn->x.memory.length) return NULL;
+
+  if ((fh = (struct m_file *) m_alloc(self, sizeof(struct m_file)))) {
+    fh->x.position = (mode == MSPACK_SYS_OPEN_APPEND) ?
+      fn->x.memory.length : 0;
+    fh->file = fn;
+  }
+  return fh;
+}
+
+static struct m_file *m_open_file(struct mspack_system *self,
+				  struct m_filename *fn, int mode)
+{
+  struct m_file *fh;
+  const char *fmode;
+  int fd;
+
+  switch (mode) {
+  case MSPACK_SYS_OPEN_READ:   fmode = "rb";  break;
+  case MSPACK_SYS_OPEN_WRITE:  fmode = "wb";  break;
+  case MSPACK_SYS_OPEN_UPDATE: fmode = "r+b"; break;
+  case MSPACK_SYS_OPEN_APPEND: fmode = "ab";  break;
+  default: return NULL;
+  }
+
+  /* validate the arguments in the provided filename */
+  switch (fn->type) {
+  case MTYPE_DISKFILE: if (!fn->x.diskfile)    return NULL; break;
+  case MTYPE_STDIOFH:  if (!fn->x.stdiofh)     return NULL; break;
+  case MTYPE_FILEDESC: if (fn->x.filedesc < 0) return NULL; break;
+  }
+
+  /* allocate memory for the file handle */
+  if (!(fh = (struct m_file *) m_alloc(self, sizeof(struct m_file)))) return NULL;
+
+  /* open or duplicate the filehandle */
+  switch (fn->type) {
+  case MTYPE_DISKFILE:
+    fh->x.fh = fopen(fn->x.diskfile, fmode);
+    break;
+
+  case MTYPE_STDIOFH:
+    fd = fileno(fn->x.stdiofh);
+    fh->x.fh = (fd >= 0) ? fdopen(fd, fmode) : NULL;
+    break;
+
+  case MTYPE_FILEDESC:
+    fh->x.fh = fdopen(fn->x.filedesc, fmode);
+    break;
+  }
+
+  /* validate the new stdio filehandle */
+  if (fh->x.fh) {
+    fh->file = fn;
+  }
+  else {
+    free(fh);
+    fh = NULL;
+  }
+
+  return fh;
+}
+
+static struct m_file *m_open(struct mspack_system *self,
+			     struct m_filename *fn, int mode)
+{
+  if (!self || !fn) return NULL;
+
+  switch (fn->type) {
+  case MTYPE_DISKFILE:
+  case MTYPE_STDIOFH:
+  case MTYPE_FILEDESC:
+    return m_open_file(self, fn, mode);
+
+  case MTYPE_MEMORY:
+    return m_open_mem(self, fn, mode);
+  }
+  return NULL;
+}
+
+static void m_close(struct m_file *fh) {
+  if (!fh || !fh->file) return;
+  if (fh->file->type != MTYPE_MEMORY) fclose(fh->x.fh);
+  m_free(fh);
+}
+
+
+static int m_read(struct m_file *fh, void *buffer, int bytes) {
+  if (!fh || !fh->file || !buffer || bytes < 0) return -1;
+
+  if (fh->file->type == MTYPE_MEMORY) {
+    int count = fh->file->x.memory.length - fh->x.position;
+    if (count > bytes) count = bytes;
+    if (count > 0) {
+      m_copy(&fh->file->x.memory.data[fh->x.position], buffer, (size_t) count);
+    }
+    fh->x.position += count;
+    return count;
+  }
+  else {
+    size_t count = fread(buffer, 1, (size_t) bytes, fh->x.fh);
+    if (!ferror(fh->x.fh)) return (int) count;
+  }
+  return -1;
+}
+
+
+static int m_write(struct m_file *fh, void *buffer, int bytes) {
+  if (!fh || !fh->file || !buffer || bytes < 0) return -1;
+
+  if (fh->file->type == MTYPE_MEMORY) {
+    int count = fh->file->x.memory.length - fh->x.position;
+    if (count > bytes) count = bytes;
+    if (count > 0) {
+      m_copy(buffer, &fh->file->x.memory.data[fh->x.position], (size_t) count);
+    }
+    fh->x.position += count;
+    return count;
+  }
+  else {
+    size_t count = fwrite(buffer, 1, (size_t) bytes, fh->x.fh);
+    if (!ferror(fh->x.fh)) return (int) count;
+  }
+  return -1;
+}
+
+
+static int m_seek(struct m_file *fh, off_t offset, int mode) {
+  if (!fh || !fh->file) return 1;
+
+  if (fh->file->type == MTYPE_MEMORY) {
+    switch (mode) {
+    case MSPACK_SYS_SEEK_START:
+      break;
+    case MSPACK_SYS_SEEK_CUR:
+      offset += (off_t) fh->x.position;
+      break;
+    case MSPACK_SYS_SEEK_END:
+      offset += (off_t) fh->file->x.memory.length;
+      break;
+    default:
+      return 1;
+    }
+
+    if (offset < 0) return 1;
+    if (offset > (off_t) fh->file->x.memory.length) return 1;
+    fh->x.position = (size_t) offset;
+    return 0;
+  }
+
+  /* file IO based method */
+  switch (mode) {
+  case MSPACK_SYS_SEEK_START: mode = SEEK_SET; break;
+  case MSPACK_SYS_SEEK_CUR:   mode = SEEK_CUR; break;
+  case MSPACK_SYS_SEEK_END:   mode = SEEK_END; break;
+  default: return 1;
+  }
+#if HAVE_FSEEKO
+  return fseeko(fh->x.fh, offset, mode);
+#else
+  return fseek(fh->x.fh, offset, mode);
+#endif
+}
+
+
+static off_t m_tell(struct m_file *fh) {
+  if (!fh || !fh->file) return -1;
+  if (fh->file->type == MTYPE_MEMORY) {
+    return (off_t) fh->x.position;
+  }
+#if HAVE_FSEEKO
+  return (off_t) ftello(fh->x.fh);
+#else
+  return (off_t) ftell(fh->x.fh);
+#endif
+}
+
+
+static struct mspack_system multi_system = {
+  (struct mspack_file * (*)(struct mspack_system *, const char *, int)) &m_open,
+  (void (*)(struct mspack_file *)) &m_close,
+  (int (*)(struct mspack_file *, void *, int)) &m_read, 
+  (int (*)(struct mspack_file *, void *, int)) &m_write,
+  (int (*)(struct mspack_file *, off_t, int)) &m_seek, 
+  (off_t (*)(struct mspack_file *)) &m_tell,
+  (void (*)(struct mspack_file *, const char *, ...))  &m_msg,
+  &m_alloc,
+  &m_free,
+  &m_copy,
+  NULL
+};
+
+/* ------------------------------------------------------------------------ */
+/* constructors and destructor */
+
+const char *create_filename(const char *filename) {
+  struct m_filename *fn;
+
+  if (!filename) return NULL; /* filename must not be null */
+
+  if ((fn = (struct m_filename *) malloc(sizeof(struct m_filename)))) {
+    fn->type = MTYPE_DISKFILE;
+    fn->filename = filename; /* pretty-printable filename */
+    fn->x.diskfile = filename;
+  }
+  return (const char *) fn;
+}
+
+const char *create_filename_from_handle(FILE *fh) {
+  struct m_filename *fn;
+
+  if (!fh) return NULL; /* file handle must not be null */
+
+  if ((fn = (struct m_filename *) malloc(sizeof(struct m_filename)))) {
+    fn->type = MTYPE_STDIOFH;
+    fn->filename = NULL; /* pretty-printable filename */
+    fn->x.stdiofh = fh;
+  }
+  return (const char *) fn;
+}
+
+const char *create_filename_from_descriptor(int fd) {
+  struct m_filename *fn;
+
+  if (fd < 0) return NULL; /* file descriptor must be valid */
+
+  if ((fn = (struct m_filename *) malloc(sizeof(struct m_filename)))) {
+    fn->type = MTYPE_FILEDESC;
+    fn->filename = NULL; /* pretty-printable filename */
+    fn->x.filedesc = fd;
+  }
+  return (const char *) fn;
+}
+
+const char *create_filename_from_memory(void *data, size_t length) {
+  struct m_filename *fn;
+
+  if (!data) return NULL; /* data pointer must not be NULL */
+  if (length == 0) return NULL; /* length must not be zero */
+
+  if ((fn = (struct m_filename *) malloc(sizeof(struct m_filename)))) {
+    fn->type = MTYPE_MEMORY;
+    fn->filename = NULL; /* pretty-printable filename */
+    fn->x.memory.data   = (unsigned char *) data;
+    fn->x.memory.length = length;
+  }
+  return (const char *) fn;
+}
+
+void set_filename_printable_name(const char *filename, const char *name) {
+  struct m_filename *fn = (struct m_filename *) filename;
+  if (!fn) return;
+  /* very basic validation of structure */
+  if ((fn->type < MTYPE_DISKFILE) || (fn->type > MTYPE_MEMORY)) return;
+  fn->filename = name;
+}
+
+void free_filename(const char *filename) {
+  free((void *) filename);
+}
+
+/* ------------------------------------------------------------------------ */
+/* example of usage with mscab_decompressor */
+
+/* a simple cabinet */
+static unsigned char memory_cab[] = {
+  0x4D,0x53,0x43,0x46,0x00,0x00,0x00,0x00,0xFD,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x2C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x01,0x01,0x00,0x02,0x00,
+  0x00,0x00,0x22,0x06,0x00,0x00,0x5E,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x4D,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x6C,0x22,0xBA,0x59,0x20,0x00,
+  0x68,0x65,0x6C,0x6C,0x6F,0x2E,0x63,0x00,0x4A,0x00,0x00,0x00,0x4D,0x00,0x00,
+  0x00,0x00,0x00,0x6C,0x22,0xE7,0x59,0x20,0x00,0x77,0x65,0x6C,0x63,0x6F,0x6D,
+  0x65,0x2E,0x63,0x00,0xBD,0x5A,0xA6,0x30,0x97,0x00,0x97,0x00,0x23,0x69,0x6E,
+  0x63,0x6C,0x75,0x64,0x65,0x20,0x3C,0x73,0x74,0x64,0x69,0x6F,0x2E,0x68,0x3E,
+  0x0D,0x0A,0x0D,0x0A,0x76,0x6F,0x69,0x64,0x20,0x6D,0x61,0x69,0x6E,0x28,0x76,
+  0x6F,0x69,0x64,0x29,0x0D,0x0A,0x7B,0x0D,0x0A,0x20,0x20,0x20,0x20,0x70,0x72,
+  0x69,0x6E,0x74,0x66,0x28,0x22,0x48,0x65,0x6C,0x6C,0x6F,0x2C,0x20,0x77,0x6F,
+  0x72,0x6C,0x64,0x21,0x5C,0x6E,0x22,0x29,0x3B,0x0D,0x0A,0x7D,0x0D,0x0A,0x23,
+  0x69,0x6E,0x63,0x6C,0x75,0x64,0x65,0x20,0x3C,0x73,0x74,0x64,0x69,0x6F,0x2E,
+  0x68,0x3E,0x0D,0x0A,0x0D,0x0A,0x76,0x6F,0x69,0x64,0x20,0x6D,0x61,0x69,0x6E,
+  0x28,0x76,0x6F,0x69,0x64,0x29,0x0D,0x0A,0x7B,0x0D,0x0A,0x20,0x20,0x20,0x20,
+  0x70,0x72,0x69,0x6E,0x74,0x66,0x28,0x22,0x57,0x65,0x6C,0x63,0x6F,0x6D,0x65,
+  0x21,0x5C,0x6E,0x22,0x29,0x3B,0x0D,0x0A,0x7D,0x0D,0x0A,0x0D,0x0A
+};
+
+int main() {
+  const char *mem_cab, *std_out, *std_err, *example;
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+  struct mscabd_file *file;
+  int err;
+
+  mem_cab = create_filename_from_memory(&memory_cab[0], sizeof(memory_cab));
+  if (!mem_cab) exit(1);
+
+  std_out = create_filename_from_descriptor(1);
+  if (!std_out) exit(1);
+
+  std_err = create_filename_from_handle(stderr);
+  if (!std_err) exit(1);
+
+  example = create_filename("example.txt");
+  if (!example) exit(1);
+
+  set_filename_printable_name(mem_cab, "internal");
+  set_filename_printable_name(std_out, "stdout");
+  set_filename_printable_name(std_err, "stderr");
+
+  /* if self-test reveals an error */
+  MSPACK_SYS_SELFTEST(err);
+  if (err) exit(1);
+
+  /* create a cab decompressor using our custom mspack_system interface */
+  if ((cabd = mspack_create_cab_decompressor(&multi_system))) {
+
+    /* open a cab file direct from memory */
+    if ((cab = cabd->open(cabd, mem_cab))) {
+
+      /* first file in the cabinet: print it to stdout */
+      file = cab->files;
+      if (cabd->extract(cabd, file, std_out)) {
+	exit(1);
+      }
+
+      /* second file in the cabinet: print it to stderr */
+      file = file->next;
+      if (cabd->extract(cabd, file, std_err)) {
+	exit(1);
+      }
+      /* also write it to "example.txt" */
+      if (cabd->extract(cabd, file, example)) {
+	exit(1);
+      }
+      cabd->close(cabd, cab);
+    }
+    else {
+      fprintf(stderr, "can't open cabinet (%d)\n", cabd->last_error(cabd));
+    }
+    mspack_destroy_cab_decompressor(cabd);
+  }
+  else {
+    fprintf(stderr, "can't make decompressor\n");
+  }
+
+  free_filename(example);
+  free_filename(std_err);
+  free_filename(std_out);
+  free_filename(mem_cab);
+
+  return 0;
+
+}

data/ext/libmspack/test/oabx.c

@@ -0,0 +1,41 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mspack.h>
+
+#include <error.h>
+
+int main(int argc, char *argv[]) {
+    struct msoab_decompressor *oabd;
+    int err;
+
+    setbuf(stdout, NULL);
+    setbuf(stderr, NULL);
+
+    MSPACK_SYS_SELFTEST(err);
+    if (err) return 0;
+
+    if ((oabd = mspack_create_oab_decompressor(NULL))) {
+        if (argc == 3) {
+            err = oabd->decompress(oabd, argv[1], argv[2]);
+            if (err) fprintf(stderr, "%s -> %s: %s\n", argv[1], argv[2], error_msg(err));
+        }
+        else if (argc == 4) {
+            err = oabd->decompress_incremental(oabd, argv[2], argv[1], argv[3]);
+            if (err) fprintf(stderr, "%s + %s -> %s: %s\n", argv[1], argv[2], argv[3], error_msg(err));
+        }
+        else {
+            fprintf(stderr, "Usage: %s <input> <output>\n", *argv);
+            fprintf(stderr, "   or  %s <base> <patch> <output>\n", *argv);
+        }
+        mspack_destroy_oab_decompressor(oabd);
+    }
+    else {
+        fprintf(stderr, "%s: can't make OAB decompressor\n", *argv);
+    }
+    return 0;
+}