libmspack 0.0.1

data/ext/libmspack/mspack/szddd.c

@@ -0,0 +1,247 @@
+/* This file is part of libmspack.
+ * (C) 2003-2010 Stuart Caie.
+ *
+ * SZDD is a format used in the MS-DOS commands COMPRESS.EXE and
+ * EXPAND.EXE. The compression method is attributed to Steven Zeck,
+ * however it's pretty much identical to LZSS.
+ *
+ * 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
+ */
+
+/* SZDD decompression implementation */
+
+#include <system.h>
+#include <szdd.h>
+
+/* prototypes */
+static struct msszddd_header *szddd_open(
+    struct msszdd_decompressor *base, const char *filename);
+static void szddd_close(
+    struct msszdd_decompressor *base, struct msszddd_header *hdr);
+static int szddd_read_headers(
+    struct mspack_system *sys, struct mspack_file *fh,
+    struct msszddd_header *hdr);
+static int szddd_extract(
+    struct msszdd_decompressor *base, struct msszddd_header *hdr,
+    const char *filename);
+static int szddd_decompress(
+    struct msszdd_decompressor *base, const char *input, const char *output);
+static int szddd_error(
+    struct msszdd_decompressor *base);
+
+/***************************************
+ * MSPACK_CREATE_SZDD_DECOMPRESSOR
+ ***************************************
+ * constructor
+ */
+struct msszdd_decompressor *
+    mspack_create_szdd_decompressor(struct mspack_system *sys)
+{
+  struct msszdd_decompressor_p *self = NULL;
+
+  if (!sys) sys = mspack_default_system;
+  if (!mspack_valid_system(sys)) return NULL;
+
+  if ((self = (struct msszdd_decompressor_p *) sys->alloc(sys, sizeof(struct msszdd_decompressor_p)))) {
+    self->base.open       = &szddd_open;
+    self->base.close      = &szddd_close;
+    self->base.extract    = &szddd_extract;
+    self->base.decompress = &szddd_decompress;
+    self->base.last_error = &szddd_error;
+    self->system          = sys;
+    self->error           = MSPACK_ERR_OK;
+  }
+  return (struct msszdd_decompressor *) self;
+}
+
+/***************************************
+ * MSPACK_DESTROY_SZDD_DECOMPRESSOR
+ ***************************************
+ * destructor
+ */
+void mspack_destroy_szdd_decompressor(struct msszdd_decompressor *base)
+{
+    struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+    if (self) {
+	struct mspack_system *sys = self->system;
+	sys->free(self);
+    }
+}
+
+/***************************************
+ * SZDDD_OPEN
+ ***************************************
+ * opens an SZDD file without decompressing, reads header
+ */
+static struct msszddd_header *szddd_open(struct msszdd_decompressor *base,
+					 const char *filename)
+{
+    struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+    struct msszddd_header *hdr;
+    struct mspack_system *sys;
+    struct mspack_file *fh;
+
+    if (!self) return NULL;
+    sys = self->system;
+
+    fh  = sys->open(sys, filename, MSPACK_SYS_OPEN_READ);
+    hdr = (struct msszddd_header *) sys->alloc(sys, sizeof(struct msszddd_header_p));
+    if (fh && hdr) {
+	((struct msszddd_header_p *) hdr)->fh = fh;
+	self->error = szddd_read_headers(sys, fh, hdr);
+    }
+    else {
+	if (!fh)  self->error = MSPACK_ERR_OPEN;
+	if (!hdr) self->error = MSPACK_ERR_NOMEMORY;
+    }
+    
+    if (self->error) {
+	if (fh)  sys->close(fh);
+	if (hdr) sys->free(hdr);
+	hdr = NULL;
+    }
+
+    return hdr;
+}
+
+/***************************************
+ * SZDDD_CLOSE
+ ***************************************
+ * closes an SZDD file
+ */
+static void szddd_close(struct msszdd_decompressor *base,
+			struct msszddd_header *hdr)
+{
+    struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+    struct msszddd_header_p *hdr_p = (struct msszddd_header_p *) hdr;
+
+    if (!self || !self->system) return;
+
+    /* close the file handle associated */
+    self->system->close(hdr_p->fh);
+
+    /* free the memory associated */
+    self->system->free(hdr);
+
+    self->error = MSPACK_ERR_OK;
+}
+
+/***************************************
+ * SZDDD_READ_HEADERS
+ ***************************************
+ * reads the headers of an SZDD format file
+ */
+static unsigned char szdd_signature_expand[8] = {
+    0x53, 0x5A, 0x44, 0x44, 0x88, 0xF0, 0x27, 0x33
+};
+static unsigned char szdd_signature_qbasic[8] = {
+    0x53, 0x5A, 0x20, 0x88, 0xF0, 0x27, 0x33, 0xD1
+};
+
+static int szddd_read_headers(struct mspack_system *sys,
+			      struct mspack_file *fh,
+			      struct msszddd_header *hdr)
+{
+    unsigned char buf[8];
+
+    /* read and check signature */
+    if (sys->read(fh, buf, 8) != 8) return MSPACK_ERR_READ;
+
+    if ((mspack_memcmp(buf, szdd_signature_expand, 8) == 0)) {
+	/* common SZDD */
+	hdr->format = MSSZDD_FMT_NORMAL;
+
+	/* read the rest of the header */
+	if (sys->read(fh, buf, 6) != 6) return MSPACK_ERR_READ;
+	if (buf[0] != 0x41) return MSPACK_ERR_DATAFORMAT;
+	hdr->missing_char = buf[1];
+	hdr->length = EndGetI32(&buf[2]);
+    }
+    else if ((mspack_memcmp(buf, szdd_signature_qbasic, 8) == 0)) {
+	/* special QBasic SZDD */
+	hdr->format = MSSZDD_FMT_QBASIC;
+	if (sys->read(fh, buf, 4) != 4) return MSPACK_ERR_READ;
+	hdr->missing_char = '\0';
+	hdr->length = EndGetI32(buf);
+    }
+    else {
+	return MSPACK_ERR_SIGNATURE;
+    }
+    return MSPACK_ERR_OK;
+}
+
+/***************************************
+ * SZDDD_EXTRACT
+ ***************************************
+ * decompresses an SZDD file
+ */
+static int szddd_extract(struct msszdd_decompressor *base,
+			 struct msszddd_header *hdr, const char *filename)
+{
+    struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+    struct mspack_file *fh, *outfh;
+    struct mspack_system *sys;
+    off_t data_offset;
+
+    if (!self) return MSPACK_ERR_ARGS;
+    if (!hdr)  return self->error = MSPACK_ERR_ARGS;
+    sys = self->system;
+
+    fh = ((struct msszddd_header_p *) hdr)->fh;
+
+    /* seek to the compressed data */
+    data_offset = (hdr->format == MSSZDD_FMT_NORMAL) ? 14 : 12;
+    if (sys->seek(fh, data_offset, MSPACK_SYS_SEEK_START)) {
+	return self->error = MSPACK_ERR_SEEK;
+    }
+
+    /* open file for output */
+    if (!(outfh = sys->open(sys, filename, MSPACK_SYS_OPEN_WRITE))) {
+	return self->error = MSPACK_ERR_OPEN;
+    }
+
+    /* decompress the data */
+    self->error = lzss_decompress(sys, fh, outfh, SZDD_INPUT_SIZE,
+				  hdr->format == MSSZDD_FMT_NORMAL
+				  ? LZSS_MODE_EXPAND
+				  : LZSS_MODE_QBASIC);
+
+    /* close output file */
+    sys->close(outfh);
+
+    return self->error;
+}
+
+/***************************************
+ * SZDDD_DECOMPRESS
+ ***************************************
+ * unpacks directly from input to output
+ */
+static int szddd_decompress(struct msszdd_decompressor *base,
+			    const char *input, const char *output)
+{
+    struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+    struct msszddd_header *hdr;
+    int error;
+
+    if (!self) return MSPACK_ERR_ARGS;
+
+    if (!(hdr = szddd_open(base, input))) return self->error;
+    error = szddd_extract(base, hdr, output);
+    szddd_close(base, hdr);
+    return self->error = error;
+}
+
+/***************************************
+ * SZDDD_ERROR
+ ***************************************
+ * returns the last error that occurred
+ */
+static int szddd_error(struct msszdd_decompressor *base)
+{
+    struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+    return (self) ? self->error : MSPACK_ERR_ARGS;
+}

data/ext/libmspack/rebuild.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+./cleanup.sh
+mkdir m4
+autoreconf -i -W all
+./configure
+make
+make -C doc
+make distcheck

data/ext/libmspack/test/cabd_c10

@@ -0,0 +1,19 @@
+#!/bin/sh
+# Expand all cabs from the C10 collection; none are intentionally valid.
+# See https://www.ee.oulu.fi/research/ouspg/PROTOS_Test-Suite_c10-archive
+
+# I downloaded the .iso, unpacked cab_tar.bz2 and moved the cab files into
+# 256 directories (00 to ff) under C10/unpacked. This makes it possible to
+# invoke cabd_md5 just 256 times to test the entire collection.
+
+for dir in `find C10/unpacked -maxdepth 1 -type d`
+do
+    echo "testing $dir"
+    ./cabd_md5 $dir/*.cab >/dev/null 2>.err
+    result=$?
+    if [ $result -ne 0 ]; then
+      echo "FAIL $dir $result" >&2
+      cat .err >&2
+    fi
+done
+rm .err

data/ext/libmspack/test/cabd_compare

@@ -0,0 +1,34 @@
+#!/bin/sh
+# Test if cabd_md5 expands cab files identically to Microsoft's EXPAND.EXE
+
+[ -d .cache ] || mkdir .cache
+
+for cab in "$@"
+do
+    echo "test $cab"
+    cached=`echo $cab | sed -e 's/\//-/g' -e 's/^/.cache\//'`
+    if [ ! -s $cached ]; then
+        ./msexpand_md5 $cab >.orig.out 2>.orig.err
+        if [ -s .orig.err ]; then
+            echo "FAIL $cab: MS errors" >&2
+            cat .orig.err >&2
+        else
+            mv .orig.out $cached
+        fi
+    fi
+
+    ./cabd_md5 $cab >.test.out 2>.test.err
+    perl -pi -e 'if($.>1){s{\\}{/}g;s{  /}{  }}' .test.out
+    if [ -s .test.err ]; then
+        echo "FAIL $cab: errors" >&2
+        cat .test.err >&2
+    fi
+
+    if cmp $cached .test.out >/dev/null; then
+       echo "OK   $cab"
+    else
+       echo "FAIL $cab: differences" >&2
+       diff -u $cached .test.out >&2
+    fi
+done
+rm -f .orig.out .orig.err .test.out .test.err

data/ext/libmspack/test/cabd_md5.c

@@ -0,0 +1,161 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mspack.h>
+#include <sys/stat.h>
+#include <dirent.h>
+
+#include <md5_fh.h>
+#include <error.h>
+
+/**
+ * Matches a cabinet's filename case-insensitively in the filesystem and
+ * returns the case-correct form.
+ *
+ * @param origcab if this is non-NULL, the pathname part of this filename
+ *                will be extracted, and the search will be conducted in
+ *                that directory.
+ * @param cabname the internal CAB filename to search for.
+ * @return a copy of the full, case-correct filename of the given cabinet
+ *         filename, or NULL if the specified filename does not exist on disk.
+ */
+static char *find_cabinet_file(char *origcab, char *cabname) {
+    struct dirent *entry;
+    struct stat st_buf;
+    int found = 0, len;
+    char *tail, *cab;
+    DIR *dir;
+
+    /* ensure we have a cabinet name at all */
+    if (!cabname || !cabname[0]) return NULL;
+
+    /* find if there's a directory path in the origcab */
+    tail = origcab ? strrchr(origcab, '/') : NULL;
+    len = (tail - origcab) + 1;
+
+    /* allocate memory for our copy */
+    if (!(cab = (char *) malloc((tail ? len : 2) + strlen(cabname) + 1))) return NULL;
+
+    /* add the directory path from the original cabinet name, or "." */
+    if (tail) memcpy(cab, origcab, (size_t) len);
+    else      cab[0]='.', cab[1]='/', len=2;
+    cab[len] = '\0';
+
+    /* try accessing the cabinet with its current name (case-sensitive) */
+    strcpy(&cab[len], cabname);
+    if (stat(cab, &st_buf) == 0) {
+	found = 1;
+    }
+    else {
+	/* cabinet was not found, look for it in the current dir */
+	cab[len] = '\0';
+	if ((dir = opendir(cab))) {
+	    while ((entry = readdir(dir))) {
+		if (strcasecmp(cabname, entry->d_name) == 0) {
+		    strcat(cab, entry->d_name);
+		    found = (stat(cab, &st_buf) == 0);
+		    break;
+		}
+	    }
+	    closedir(dir);
+	}
+    }
+
+    if (!found || !S_ISREG(st_buf.st_mode)) {
+	/* cabinet not found, or not a regular file */
+	free(cab);
+	cab = NULL;
+    }
+
+    return cab;
+}
+
+
+int main(int argc, char *argv[]) {
+    struct mscab_decompressor *cabd;
+    struct mscabd_cabinet *cab, *c, *c2;
+    struct mscabd_file *file;
+    char *cabname, *newname;
+    int err;
+
+    setbuf(stdout, NULL);
+    setbuf(stderr, NULL);
+
+    /* if self-test reveals an error */
+    MSPACK_SYS_SELFTEST(err);
+    if (err) return 1;
+
+    if (!(cabd = mspack_create_cab_decompressor(&read_files_write_md5))) {
+	fprintf(stderr, "can't make decompressor\n");
+	return 1;
+    }
+
+    for (argv++; (cabname = *argv); argv++) {
+	printf("*** %s\n", cabname);
+
+	if (!(cab = cabd->open(cabd, cabname))) {
+	    fprintf(stderr, "cab open error: %s\n", ERROR(cabd));
+	    continue;
+	}
+
+	/* prepend any spanning cabinets */
+	for (c = cab; c && (c->flags & MSCAB_HDR_PREVCAB); c = c->prevcab) {
+	    if (!(newname = find_cabinet_file(cabname, c->prevname))) {
+		fprintf(stderr, "%s: can't find \"%s\" to prepend\n",
+			cabname, c->prevname);
+		break;
+	    }
+	    if (!(c2 = cabd->open(cabd, newname))) {
+		fprintf(stderr, "%s: error opening \"%s\" for prepend: %s\n",
+			cabname, newname, ERROR(cabd));
+		break;
+	    }
+	    if (cabd->prepend(cabd, c, c2) != MSPACK_ERR_OK) {
+		fprintf(stderr, "%s: error prepending \"%s\": %s\n",
+			cabname, newname, ERROR(cabd));
+		break;
+	    }
+	}
+
+	/* append any spanning cabinets */
+	for (c = cab; c && (c->flags & MSCAB_HDR_NEXTCAB); c = c->nextcab) {
+	    if (!(newname = find_cabinet_file(cabname, c->nextname))) {
+		fprintf(stderr, "%s: can't find \"%s\" to append\n",
+			cabname, c->nextname);
+		break;
+	    }
+	    if (!(c2 = cabd->open(cabd, newname))) {
+		fprintf(stderr, "%s: error opening \"%s\" for append: %s\n",
+			cabname, newname, ERROR(cabd));
+		break;
+	    }
+	    if (cabd->append(cabd, c, c2) != MSPACK_ERR_OK) {
+		fprintf(stderr, "%s: error appending \"%s\": %s\n",
+			cabname, newname, ERROR(cabd));
+		break;
+	    }
+	}
+
+	/* extract files */
+	for (file = cab->files; file; file = file->next ) {
+	    if (cabd->extract(cabd, file, NULL) == MSPACK_ERR_OK) {
+		printf("%s  %s\n", md5_string, file->filename);
+	    }
+	    else {
+		fprintf(stderr, "%s: error extracting \"%s\": %s\n",
+			cabname, file->filename, ERROR(cabd));
+	    }
+	}
+
+	/* free all resources */
+	for (c2 = cab->prevcab; c2; c2 = c2->prevcab) free((void*)c2->filename);
+	for (c2 = cab->nextcab; c2; c2 = c2->nextcab) free((void*)c2->filename);
+	cabd->close(cabd, cab);
+    }
+    mspack_destroy_cab_decompressor(cabd);
+    return 0;
+}

data/ext/libmspack/test/cabd_memory.c

@@ -0,0 +1,179 @@
+/* An implementation of the mspack_system interface using only memory */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mspack.h>
+
+/* use a pointer to a mem_buf structure as "filenames" */
+struct mem_buf {
+  void *data;
+  size_t length;
+};
+
+struct mem_file {
+  char *data;
+  size_t length, posn;
+};
+
+static void *mem_alloc(struct mspack_system *self, size_t bytes) {
+  /* put your memory allocator here */
+  return malloc(bytes);
+}
+
+static void mem_free(void *buffer) {
+  /* put your memory deallocator here */
+  free(buffer);
+}
+
+static void mem_copy(void *src, void *dest, size_t bytes) {
+  /* put your own memory copy routine here */
+  memcpy(dest, src, bytes);
+}
+
+static void mem_msg(struct mem_file *file, const char *format, ...) {
+  /* put your own printf-type routine here, or leave it empty */
+}
+
+static struct mem_file *mem_open(struct mspack_system *self,
+				 struct mem_buf *fn, int mode)
+{
+  struct mem_file *fh;
+  if (!fn || !fn->data || !fn->length) return NULL;
+  if ((fh = (struct mem_file *) mem_alloc(self, sizeof(struct mem_file)))) {
+    fh->data   = (char *) fn->data;
+    fh->length = fn->length;
+    fh->posn   = (mode == MSPACK_SYS_OPEN_APPEND) ? fn->length : 0;
+  }
+  return fh;
+}
+
+static void mem_close(struct mem_file *fh) {
+  if (fh) mem_free(fh);
+}
+
+static int mem_read(struct mem_file *fh, void *buffer, int bytes) {
+  int todo;
+  if (!fh || !buffer || bytes < 0) return -1;
+  todo = fh->length - fh->posn;
+  if (todo > bytes) todo = bytes;
+  if (todo > 0) mem_copy(&fh->data[fh->posn], buffer, (size_t) todo);
+  fh->posn += todo; return todo;
+}
+
+static int mem_write(struct mem_file *fh, void *buffer, int bytes) {
+  int todo;
+  if (!fh || !buffer || bytes < 0) return -1;
+  todo = fh->length - fh->posn;
+  if (todo > bytes) todo = bytes;
+  if (todo > 0) mem_copy(buffer, &fh->data[fh->posn], (size_t) todo);
+  fh->posn += todo; return todo;
+}
+
+static int mem_seek(struct mem_file *fh, off_t offset, int mode) {
+  if (!fh) return 1;
+  switch (mode) {
+  case MSPACK_SYS_SEEK_START: break;
+  case MSPACK_SYS_SEEK_CUR:   offset += (off_t) fh->posn; break;
+  case MSPACK_SYS_SEEK_END:   offset += (off_t) fh->length; break;
+  default: return 1;
+  }
+  if ((offset < 0) || (offset > (off_t) fh->length)) return 1;
+  fh->posn = (size_t) offset;
+  return 0;
+}
+
+static off_t mem_tell(struct mem_file *fh) {
+  return (fh) ? (off_t) fh->posn : -1;
+}
+
+static struct mspack_system mem_system = {
+  (struct mspack_file * (*)(struct mspack_system *, const char *, int)) &mem_open,
+  (void (*)(struct mspack_file *)) &mem_close,
+  (int (*)(struct mspack_file *, void *, int)) &mem_read, 
+  (int (*)(struct mspack_file *, void *, int)) &mem_write,
+  (int (*)(struct mspack_file *, off_t, int)) &mem_seek, 
+  (off_t (*)(struct mspack_file *)) &mem_tell,
+  (void (*)(struct mspack_file *, const char *, ...)) &mem_msg,
+  &mem_alloc,
+  &mem_free,
+  &mem_copy,
+  NULL
+};
+
+/* example of usage with mscab_decompressor */
+
+/* a simple cabinet */
+static unsigned char embedded_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() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+  struct mscabd_file *file;
+  struct mem_buf source = { &embedded_cab[0], sizeof(embedded_cab) };
+  struct mem_buf output;
+  int err;
+
+  /* if self-test reveals an error */
+  MSPACK_SYS_SELFTEST(err);
+  if (err) return 1;
+
+  /* create a cab decompressor using our custom mspack_system interface */
+  if ((cabd = mspack_create_cab_decompressor(&mem_system))) {
+
+    /* open a cab file direct from memory */
+    if ((cab = cabd->open(cabd, (char *) &source))) {
+
+      /* for all files */
+      for (file = cab->files; file; file = file->next) {
+	/* fill out our "filename" (memory pointer and length) */
+	output.data = (char *) malloc(file->length);
+	output.length = file->length;
+
+	/* let cabd extract this file to our memory buffer */
+	if (output.data && cabd->extract(cabd, file, (char *) &output)) {
+	  exit(1);
+	}
+
+	/* dump the memory buffer to stdout (for display purposes) */
+	printf("Filename: %s\nContents:\n", file->filename);
+	fwrite(output.data, 1, output.length, stdout);
+
+	/* free our buffer */
+	free(output.data);
+      }
+      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");
+  }
+  return 0;
+
+}