libmspack 0.0.1

data/ext/libmspack/test/cabd_test.c

@@ -0,0 +1,386 @@
+/* cabinet decompression regression test suite */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mspack.h>
+
+unsigned int test_count = 0;
+
+#define TEST(x) do {\
+  test_count++; \
+  if (!(x)) {printf("%s:%d FAILED %s\n",__FUNCTION__,__LINE__,#x);exit(1);} \
+} while (0)
+
+/* open where cab file doesn't exist */
+void cabd_open_test_01() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  cab = cabd->open(cabd, "!!!FILE_WHICH_DOES_NOT_EXIST");
+  TEST(cab == NULL);
+  TEST(cabd->last_error(cabd) == MSPACK_ERR_OPEN);
+
+  mspack_destroy_cab_decompressor(cabd);
+}
+
+/* normal cab file with 2 files and one folder.
+ * check ALL headers are read correctly */
+void cabd_open_test_02() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+  struct mscabd_folder *folder;
+  struct mscabd_file *file;
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  cab = cabd->open(cabd, "test_files/cabd/normal_2files_1folder.cab");
+  TEST(cab != NULL);
+
+  TEST(cab->next == NULL);
+  TEST(cab->base_offset == 0);
+  TEST(cab->length == 253);
+  TEST(cab->prevcab == NULL); TEST(cab->nextcab == NULL);
+  TEST(cab->prevname == NULL); TEST(cab->nextname == NULL);
+  TEST(cab->previnfo == NULL); TEST(cab->nextinfo == NULL);
+  TEST(cab->set_id = 1570); TEST(cab->set_index == 0);
+  TEST(cab->header_resv == 0);
+  TEST(cab->flags == 0);
+
+  folder = cab->folders;
+  TEST(folder != NULL);
+  TEST(folder->next == NULL);
+  TEST(folder->comp_type == 0);
+  TEST(folder->num_blocks == 1);
+
+  file = cab->files;
+  TEST(file != NULL);
+  TEST(strcmp(file->filename, "hello.c") == 0);
+  TEST(file->length == 77);
+  TEST(file->attribs == 0x20);
+  TEST(file->time_h == 11);TEST(file->time_m == 13);TEST(file->time_s == 52);
+  TEST(file->date_d == 12);TEST(file->date_m == 3);TEST(file->date_y == 1997);
+  TEST(file->folder == folder); TEST(file->offset == 0);
+
+  file = file->next;
+  TEST(file != NULL);
+  TEST(strcmp(file->filename, "welcome.c") == 0);
+  TEST(file->length == 74);
+  TEST(file->attribs == 0x20);
+  TEST(file->time_h == 11);TEST(file->time_m == 15);TEST(file->time_s == 14);
+  TEST(file->date_d == 12);TEST(file->date_m == 3);TEST(file->date_y == 1997);
+  TEST(file->folder == folder); TEST(file->offset == 77);
+
+  cabd->close(cabd, cab);
+  mspack_destroy_cab_decompressor(cabd);
+}
+
+/* cabs with reserve headers set, ensure they all load correctly */
+void cabd_open_test_03() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+  unsigned int i;
+  const char *files[] = {
+    "test_files/cabd/reserve_---.cab",
+    "test_files/cabd/reserve_--D.cab",
+    "test_files/cabd/reserve_-F-.cab",
+    "test_files/cabd/reserve_-FD.cab",
+    "test_files/cabd/reserve_H--.cab",
+    "test_files/cabd/reserve_H-D.cab",
+    "test_files/cabd/reserve_HF-.cab",
+    "test_files/cabd/reserve_HFD.cab"
+  };
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  for (i = 0; i < (sizeof(files)/sizeof(char *)); i++) {
+    cab = cabd->open(cabd, files[i]);
+    TEST(cab != NULL);
+    TEST(cab->files != NULL);
+    TEST(cab->files->next != NULL);
+    TEST(strcmp(cab->files->filename, "test1.txt") == 0);
+    TEST(strcmp(cab->files->next->filename, "test2.txt") == 0);
+    cabd->close(cabd, cab);
+  }
+
+  mspack_destroy_cab_decompressor(cabd);
+}
+
+/* some bad cabs, should not load */
+void cabd_open_test_04() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  /* cab has enough data for a header, but does not contain real cab data
+   * result should be MSPACK_ERR_SIGNATURE */
+  cab = cabd->open(cabd, "test_files/cabd/bad_signature.cab");
+  TEST(cab == NULL);
+
+  /* cab has 0 folders */
+  cab = cabd->open(cabd, "test_files/cabd/bad_nofolders.cab");
+  TEST(cab == NULL);
+
+  /* cab has 0 files */
+  cab = cabd->open(cabd, "test_files/cabd/bad_nofiles.cab");
+  TEST(cab == NULL);
+
+  /* second file in the cab has a folder index for a non-existant folder */
+  cab = cabd->open(cabd, "test_files/cabd/bad_folderindex.cab");
+  TEST(cab == NULL);
+
+  mspack_destroy_cab_decompressor(cabd);
+}
+
+/* cabs which have been cut short
+ * result should be MSPACK_ERR_READ for missing headers or
+ * MSPACK_ERR_DATAFORMAT for missing/partial strings.
+ * If only data blocks are missing, the cab should open()
+ */
+void cabd_open_test_05() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+  unsigned int i;
+  const char *files[] = {
+    "test_files/cabd/partial_shortheader.cab",
+    "test_files/cabd/partial_shortextheader.cab",
+    "test_files/cabd/partial_nofolder.cab",
+    "test_files/cabd/partial_shortfolder.cab",
+    "test_files/cabd/partial_nofiles.cab",
+    "test_files/cabd/partial_shortfile1.cab",
+    "test_files/cabd/partial_shortfile2.cab"
+  };
+  const char *str_files[] = {
+    "test_files/cabd/partial_str_nopname.cab",
+    "test_files/cabd/partial_str_shortpname.cab",
+    "test_files/cabd/partial_str_nopinfo.cab",
+    "test_files/cabd/partial_str_shortpinfo.cab",
+    "test_files/cabd/partial_str_nonname.cab",
+    "test_files/cabd/partial_str_shortnname.cab",
+    "test_files/cabd/partial_str_noninfo.cab",
+    "test_files/cabd/partial_str_shortninfo.cab",
+    "test_files/cabd/partial_str_nofname.cab",
+    "test_files/cabd/partial_str_shortfname.cab",
+  };
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  for (i = 0; i < (sizeof(files)/sizeof(char *)); i++) {
+    cab = cabd->open(cabd, files[i]);
+    TEST(cab == NULL);
+    TEST(cabd->last_error(cabd) == MSPACK_ERR_READ);
+  }
+
+  for (i = 0; i < (sizeof(str_files)/sizeof(char *)); i++) {
+    cab = cabd->open(cabd, str_files[i]);
+    TEST(cab == NULL);
+    TEST(cabd->last_error(cabd) == MSPACK_ERR_DATAFORMAT);
+  }
+
+  /* lack of data blocks should NOT be a problem for merely reading */
+  cab = cabd->open(cabd, "test_files/cabd/partial_nodata.cab");
+  TEST(cab != NULL);
+
+  cabd->close(cabd, cab);
+  mspack_destroy_cab_decompressor(cabd);
+}
+
+/* open cab with 255 character filename (maximum allowed) */
+void cabd_open_test_06() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  cab = cabd->open(cabd, "test_files/cabd/normal_255c_filename.cab");
+  TEST(cab != NULL);
+
+  cabd->close(cabd, cab);
+  mspack_destroy_cab_decompressor(cabd);
+}
+
+
+/* open where search file doesn't exist */
+void cabd_search_test_01() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  cab = cabd->search(cabd, "!!!FILE_WHICH_DOES_NOT_EXIST");
+  TEST(cab == NULL);
+  TEST(cabd->last_error(cabd) == MSPACK_ERR_OPEN);
+
+  mspack_destroy_cab_decompressor(cabd);
+}
+  
+/* search file using 1-byte buffer */
+void cabd_search_test_02() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  cabd->set_param(cabd, MSCABD_PARAM_SEARCHBUF, 1);
+  cab = cabd->search(cabd, "test_files/cabd/search_basic.cab");
+  cabd->set_param(cabd, MSCABD_PARAM_SEARCHBUF, 32768);
+
+  TEST(cab != NULL);
+  TEST(cab->files != NULL);
+  TEST(cab->base_offset == 6);
+  TEST(cab->files->next != NULL);
+  TEST(strcmp(cab->files->filename, "hello.c") == 0);
+  TEST(strcmp(cab->files->next->filename, "welcome.c") == 0);
+
+  TEST(cab->next != NULL);
+  TEST(cab->next->base_offset == 265);
+  TEST(cab->next->files != NULL);
+  TEST(cab->next->files->next != NULL);
+  TEST(strcmp(cab->next->files->filename, "hello.c") == 0);
+  TEST(strcmp(cab->next->files->next->filename, "welcome.c") == 0);
+
+  TEST(cab->next->next == NULL);
+
+  cabd->close(cabd, cab);
+  mspack_destroy_cab_decompressor(cabd);
+}
+
+/* tricky searches */
+void cabd_search_test_03() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab;
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  /* there is only ONE cab in this file. it is prepended by 4 bytes, "MSCF"
+   * (heh) and reserved fields in the real cab are filled in so the fake one
+   * looks real to the scanner but not the real reader
+   */
+  cab = cabd->search(cabd, "test_files/cabd/search_tricky1.cab");
+  TEST(cab != NULL);
+  TEST(cab->next == NULL);
+  TEST(cab->files != NULL);
+  TEST(cab->base_offset == 4);
+  TEST(cab->files->next != NULL);
+  TEST(strcmp(cab->files->filename, "hello.c") == 0);
+  TEST(strcmp(cab->files->next->filename, "welcome.c") == 0);
+
+  cabd->close(cabd, cab);
+  mspack_destroy_cab_decompressor(cabd);
+}
+
+/* basic parameter failures */
+void cabd_merge_test_01() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab1, *cab2;
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  cab1 = cabd->open(cabd, "test_files/cabd/multi_basic_pt1.cab");
+  cab2 = cabd->open(cabd, "test_files/cabd/multi_basic_pt2.cab");
+  TEST(cab1 != NULL);
+  TEST(cab2 != NULL);
+  TEST(cabd->append(cabd,  cab1, NULL) != MSPACK_ERR_OK);
+  TEST(cabd->append(cabd,  NULL, cab1) != MSPACK_ERR_OK);
+  TEST(cabd->append(cabd,  cab1, cab1) != MSPACK_ERR_OK);
+  TEST(cabd->prepend(cabd, cab1, NULL) != MSPACK_ERR_OK);
+  TEST(cabd->prepend(cabd, NULL, cab1) != MSPACK_ERR_OK);
+  TEST(cabd->prepend(cabd, cab1, cab1) != MSPACK_ERR_OK);
+
+  /* merge cabs, then try merging again every other way */
+  TEST(cabd->append(cabd,  cab1, cab2) == MSPACK_ERR_OK);
+  TEST(cabd->append(cabd,  cab2, cab1) != MSPACK_ERR_OK);
+  TEST(cabd->prepend(cabd, cab1, cab2) != MSPACK_ERR_OK);
+  TEST(cabd->prepend(cabd, cab2, cab1) != MSPACK_ERR_OK);
+  TEST(cabd->append(cabd,  cab1, cab2) != MSPACK_ERR_OK);
+
+  cabd->close(cabd, cab1);
+  mspack_destroy_cab_decompressor(cabd);
+}
+  
+/* test merging a normal 5 part single folder cabinet set with slightly
+ * haphazard ordering.  should still merge fine */
+void cabd_merge_test_02() {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab[5];
+
+  cabd = mspack_create_cab_decompressor(NULL);
+  TEST(cabd != NULL);
+
+  cab[0] = cabd->open(cabd, "test_files/cabd/multi_basic_pt1.cab");
+  cab[1] = cabd->open(cabd, "test_files/cabd/multi_basic_pt2.cab");
+  cab[2] = cabd->open(cabd, "test_files/cabd/multi_basic_pt3.cab");
+  cab[3] = cabd->open(cabd, "test_files/cabd/multi_basic_pt4.cab");
+  cab[4] = cabd->open(cabd, "test_files/cabd/multi_basic_pt5.cab");
+  TEST(cab[0] != NULL);
+  TEST(cab[1] != NULL);
+  TEST(cab[2] != NULL);
+  TEST(cab[3] != NULL);
+  TEST(cab[4] != NULL);
+  TEST(cabd->append(cabd,  cab[0], cab[1]) == MSPACK_ERR_OK);
+  TEST(cabd->prepend(cabd, cab[2], cab[1]) == MSPACK_ERR_OK);
+  TEST(cabd->append(cabd,  cab[3], cab[4]) == MSPACK_ERR_OK);
+  TEST(cabd->prepend(cabd, cab[3], cab[2]) == MSPACK_ERR_OK);
+
+  TEST(cab[0]->files != NULL);
+  TEST(cab[0]->files->next != NULL);
+  TEST(cab[0]->files->next->next != NULL);
+  TEST(cab[0]->files->next->next->next == NULL);
+  TEST(cab[0]->files == cab[1]->files);
+  TEST(cab[1]->files == cab[2]->files);
+  TEST(cab[2]->files == cab[3]->files);
+  TEST(cab[3]->files == cab[4]->files);
+
+  TEST(cab[0]->folders != NULL);
+  TEST(cab[0]->folders->next == NULL);
+  TEST(cab[0]->folders == cab[1]->folders);
+  TEST(cab[1]->folders == cab[2]->folders);
+  TEST(cab[2]->folders == cab[3]->folders);
+  TEST(cab[3]->folders == cab[4]->folders);
+
+  cabd->close(cabd, cab[0]);
+  mspack_destroy_cab_decompressor(cabd);
+}
+  
+int main() {
+  int selftest;
+
+  MSPACK_SYS_SELFTEST(selftest);
+  TEST(selftest == MSPACK_ERR_OK);
+
+  cabd_open_test_01();
+  cabd_open_test_02();
+  cabd_open_test_03();
+  cabd_open_test_04();
+  cabd_open_test_05();
+  cabd_open_test_06();
+
+  cabd_search_test_01();
+  cabd_search_test_02();
+  cabd_search_test_03();
+
+  cabd_merge_test_01();
+  cabd_merge_test_02();
+
+  /* extract() tests */
+
+  printf("ALL %d TESTS PASSED.\n", test_count);
+  return 0;
+}

data/ext/libmspack/test/cabrip.c

@@ -0,0 +1,81 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <mspack.h>
+#include <system.h>
+
+#define BUF_SIZE (1024*4096)
+char buf[BUF_SIZE];
+
+void rip(char *fname, off_t offset, unsigned int length) {
+  static unsigned int counter = 1;
+   struct stat st_buf;
+  char outname[13];
+  FILE *in, *out;
+
+  do {
+    snprintf(outname, 13, "%08u.cab", counter++);
+  } while (stat(outname, &st_buf) == 0);
+
+  printf("ripping %s offset %" LD " length %u to %s\n",
+	 fname, offset, length, outname);
+
+  if ((in = fopen(fname, "rb"))) {
+#ifdef HAVE_FSEEKO
+    if (!fseeko(in, offset, SEEK_SET)) {
+#else
+    if (!fseek(in, offset, SEEK_SET)) {
+#endif
+      if ((out = fopen(outname, "wb"))) {
+	while (length > 0) {
+	  unsigned int run = BUF_SIZE;
+	  if (run > length) run = length;
+	  if (fread(&buf[0], 1, run, in) != run) {
+	    perror(fname);
+	    break;
+	  }
+	  if (fwrite(&buf[0], 1, run, out) != run) {
+	    perror(outname);
+	    break;
+	  }
+	  length -= run;
+	}
+	fclose(out);
+      }
+      else {
+	perror(outname);
+      }
+    }
+    else {
+      perror(fname);
+    }
+    fclose(in);
+  }
+  else {
+    perror(fname);
+  }
+}
+
+int main(int argc, char *argv[]) {
+  struct mscab_decompressor *cabd;
+  struct mscabd_cabinet *cab, *c;
+  int err;
+
+  MSPACK_SYS_SELFTEST(err);
+  if (err) return 0;
+
+  if ((cabd = mspack_create_cab_decompressor(NULL))) {
+    for (argv++; *argv; argv++) {
+      if ((cab = cabd->search(cabd, *argv))) {
+	for (c = cab; c; c = c->next) rip(*argv, c->base_offset, c->length);
+	cabd->close(cabd, cab);
+      }
+    }
+    mspack_destroy_cab_decompressor(cabd);
+  }
+  return 0;
+}

data/ext/libmspack/test/chmd_compare

@@ -0,0 +1,38 @@
+#!/bin/sh
+# Test if chmd_md5 expands chm files identically to Microsoft's HH.EXE -DECOMPILE
+
+[ -d .cache ] || mkdir .cache
+
+for chm in "$@"
+do
+    echo "test $chm"
+    cached=`echo $chm | sed -e 's/\//-/g' -e 's/^/.cache\//'`
+    if [ ! -s $cached ]; then
+        ./msdecompile_md5 $chm >.orig.out 2>.orig.err
+        if [ -s .orig.err ]; then
+            echo "FAIL $chm: MS errors" >&2
+            cat .orig.err >&2
+        else
+            sort -k2 .orig.out >$cached
+        fi
+    fi
+
+    ./chmd_md5 $chm >.test.out 2>.test.err
+    perl -pe 'if($.>1){$_=""if/^[0-9a-f]{32} \/[#\$]/;s{ /}{  }}' .test.out | sort -k2 >.test.sorted
+    if [ -s .test.err ]; then
+        echo "FAIL $chm: errors" >&2
+        cat .test.err >&2
+    fi
+
+    if cmp $cached .test.sorted >/dev/null; then
+        echo "OK   $chm"
+    else
+       if [ `diff $cached .test.sorted | grep -c '^<'` -gt 0 ]; then
+           echo "FAIL $chm: differences" >&2
+           diff -u $cached .test.sorted >&2
+       else
+           echo "OK   $chm (better than hh.exe)"
+       fi
+    fi
+done
+rm -f .orig.out .orig.err .test.out .test.err .test.sorted

data/ext/libmspack/test/chmd_find.c

@@ -0,0 +1,95 @@
+/* chmd_find: tests fast-find functionality
+ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mspack.h>
+
+#include <error.h>
+#include <system.h>
+
+void find(struct mschm_decompressor *chmd, struct mschmd_header *chm,
+	  char *archive, char *filename, struct mschmd_file *compare)
+{
+    struct mschmd_file result;
+    if (chmd->fast_find(chmd, chm, filename, &result, sizeof(result))) {
+	fprintf(stderr, "%s: find error on \"%s\": %s\n",
+		archive, filename, ERROR(chmd));
+    }
+    else if (!result.section) {
+	if (compare) {
+	    fprintf(stderr, "%s: file \"%s\" not found\n", archive, filename);
+	}
+	else {
+	    printf("%s: file \"%s\" not found\n", archive, filename);
+	}
+    }
+    else {
+	printf("%s\n", filename);
+	printf(" section: %d\n", result.section->id);
+	printf(" offset:  %" LD "\n", result.offset);
+	printf(" length:  %" LD "\n", result.length);
+	if (compare) {
+	    if (result.section->id != compare->section->id) {
+		fprintf(stderr, "%s: found file \"%s\" section is wrong "
+			"(%d vs %d)\n", archive, filename,
+			result.section->id, compare->section->id);
+	    }
+
+	    if (result.offset != compare->offset) {
+		fprintf(stderr, "%s: found file \"%s\" offset is wrong "
+			"(%" LD " vs %" LD ")\n", archive, filename,
+			result.offset, compare->offset);
+	    }
+
+	    if (result.length != compare->length) {
+		fprintf(stderr, "%s: found file \"%s\" length is wrong "
+			"(%" LD " vs %" LD ")\n", archive, filename,
+			result.length, compare->length);
+	    }
+	}
+    }
+}
+
+int main(int argc, char *argv[]) {
+    struct mschm_decompressor *chmd;
+    struct mschmd_header *chm, *chm2;
+    unsigned int i;
+
+    if (argc < 2 || argc > 3) {
+	printf("Usage: %s <file.chm> [filename to find]\n", argv[0]);
+	return 1;
+    }
+
+    MSPACK_SYS_SELFTEST(i);
+    if (i) return 0;
+
+    if ((chmd = mspack_create_chm_decompressor(NULL))) {
+	if ((chm = chmd->fast_open(chmd, argv[1]))) {
+	    if (argv[2]) {
+		find(chmd, chm, argv[1], argv[2], NULL);
+	    }
+	    else {
+		if ((chm2 = chmd->open(chmd, argv[1]))) {
+		    struct mschmd_file *file;
+		    for (file = chm2->files; file; file = file->next) {
+			find(chmd, chm, argv[1], file->filename, file);
+		    }
+		}
+		else {
+		    printf("%s: can't open -- %s\n", argv[1], ERROR(chmd));
+		}
+	    }
+	    chmd->close(chmd, chm);
+	}
+	else {
+	    printf("%s: can't open -- %s\n", argv[1], ERROR(chmd));
+	}
+	mspack_destroy_chm_decompressor(chmd);
+    }
+    return 0;
+}

data/ext/libmspack/test/chmd_md5.c

@@ -0,0 +1,67 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mspack.h>
+
+#include <md5_fh.h>
+#include <error.h>
+
+static int sortfunc(const void *a, const void *b) {
+  off_t diff = 
+    ((* ((struct mschmd_file **) a))->offset) -
+    ((* ((struct mschmd_file **) b))->offset);
+  return (diff < 0) ? -1 : ((diff > 0) ? 1 : 0);
+}
+
+int main(int argc, char *argv[]) {
+  struct mschm_decompressor *chmd;
+  struct mschmd_header *chm;
+  struct mschmd_file *file, **f;
+  unsigned int numf, i;
+  int err;
+
+  setbuf(stdout, NULL);
+  setbuf(stderr, NULL);
+
+  MSPACK_SYS_SELFTEST(err);
+  if (err) return 0;
+
+  if ((chmd = mspack_create_chm_decompressor(&read_files_write_md5))) {
+    for (argv++; *argv; argv++) {
+      printf("*** %s\n", *argv);
+      if ((chm = chmd->open(chmd, *argv))) {
+
+	/* extract in order of the offset into content section - faster */
+	for (numf=0, file=chm->files; file; file = file->next) numf++;
+	if ((f = (struct mschmd_file **) calloc(numf, sizeof(struct mschmd_file *)))) {
+	  for (i=0, file=chm->files; file; file = file->next) f[i++] = file;
+	  qsort(f, numf, sizeof(struct mschmd_file *), &sortfunc);
+	  for (i = 0; i < numf; i++) {
+	    if (chmd->extract(chmd, f[i], NULL)) {
+	      fprintf(stderr, "%s: extract error on \"%s\": %s\n",
+		      *argv, f[i]->filename, ERROR(chmd));
+	    }
+	    else {
+	      printf("%s %s\n", md5_string, f[i]->filename);
+            }
+	  }
+	  free(f);
+	}
+
+	chmd->close(chmd, chm);
+      }
+      else {
+	fprintf(stderr, "%s: can't open -- %s\n", *argv, ERROR(chmd));
+      }
+    }
+    mspack_destroy_chm_decompressor(chmd);
+  }
+  else {
+    fprintf(stderr, "%s: can't make CHM decompressor\n", *argv);
+  }
+  return 0;
+}