libmspack 0.0.1

data/ext/libmspack/test/chmd_order.c

@@ -0,0 +1,144 @@
+/* chmd_order: test that extracting a CHM file in different ways works
+ * and all give the same results:
+ * - extracting files in the order they're listed (generally alphabetical)
+ * - extracting files ordered by their content section offset
+ * - extracting files using fast_find() to find them
+ * - extracting files from two chms at the same time with one decompressor
+ */
+#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>
+
+struct my_file {
+    struct mschmd_file *file;
+    struct mschmd_file result;
+    char ordered[32], sorted[32], fast_find[32], mixed[32];
+};
+
+static int sortfunc(const void *a, const void *b) {
+  off_t diff =
+    ((struct my_file *) a)->file->offset -
+    ((struct my_file *) b)->file->offset;
+  return (diff < 0) ? -1 : ((diff > 0) ? 1 : 0);
+}
+
+int main(int argc, char *argv[]) {
+    struct mschm_decompressor *chmd;
+    struct mschmd_header *chm, *chm2;
+    struct mschmd_file *file;
+    struct my_file *f;
+    unsigned int N, i;
+
+    MSPACK_SYS_SELFTEST(i);
+    if (i) 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))) {
+		if ((chm2 = chmd->fast_open(chmd, *argv))) {
+
+		    /* count the number of files, allocate a results structure */
+		    for (N=0, file = chm->files; file; file = file->next) N++;
+		    if ((f = (struct my_file *) calloc(N, sizeof(struct my_file)))) {
+			
+			/* fill out results structure while doing ordered extraction */
+			for (i = 0, file = chm->files; file; file = file->next, i++) {
+			    printf("OX %s\n", file->filename);
+			    f[i].file = file;
+			    if (chmd->extract(chmd, file, NULL)) {
+				fprintf(stderr, "%s: O extract error on \"%s\": %s\n",
+					*argv, file->filename, ERROR(chmd));
+				continue;
+			    }
+			    memcpy(&f[i].ordered[0], md5_string, 32);
+			}
+
+			/* sort the list into offset order */
+			qsort(f, N, sizeof(struct my_file), &sortfunc);
+
+			/* extract in offset order */
+			for (i = 0; i < N; i++) {
+			    printf("SX %s\n", f[i].file->filename);
+			    if (chmd->extract(chmd, f[i].file, NULL)) {
+				fprintf(stderr, "%s: S extract error on \"%s\": %s\n",
+					*argv, f[i].file->filename, ERROR(chmd));
+				continue;
+			    }
+			    memcpy(&f[i].sorted[0], md5_string, 32);
+			}
+
+			/* extract using fast_find */
+			for (i = 0; i < N; i++) {
+			    printf("FX %s\n", f[i].file->filename);
+			    
+			    if (chmd->fast_find(chmd, chm2,
+                                f[i].file->filename,
+				&f[i].result, sizeof(struct mschmd_file)))
+			    {
+				fprintf(stderr, "%s: find error on \"%s\": %s\n",
+					*argv, f[i].file->filename, ERROR(chmd));
+				continue;
+			    }
+			    if (!f[i].result.section) {
+				fprintf(stderr, "%s: can't find file \"%s\"\n",
+					*argv, f[i].file->filename);
+				continue;
+			    }
+			    if (chmd->extract(chmd, &f[i].result, NULL)) {
+				fprintf(stderr, "%s: F extract error on \"%s\": %s\n",
+					*argv, f[i].file->filename, ERROR(chmd));
+				continue;
+			    }
+			    memcpy(&f[i].fast_find[0], md5_string, 32);
+			}
+
+			/* extract two chms at once */
+			for (i = 0; i < N; i++) {
+			    printf("MX %s\n", f[i].file->filename);
+			    chmd->extract(chmd, f[i].file, NULL);
+			    if (chmd->extract(chmd, &f[i].result, NULL)) {
+				fprintf(stderr, "%s: M extract error on \"%s\": %s\n",
+					*argv, f[i].file->filename, ERROR(chmd));
+				continue;
+			    }
+			    memcpy(&f[i].mixed[0], md5_string, 32);
+			}
+
+			/* check all the MD5 sums match */
+			for (i = 0; i < N; i++) {
+			    if (memcmp(&f[i].ordered, &f[i].sorted,    32) ||
+				memcmp(&f[i].ordered, &f[i].fast_find, 32) ||
+				memcmp(&f[i].ordered, &f[i].mixed,     32))
+			     {
+				 fprintf(stderr, "%s: sums mismatch on %s "
+					 "(O=%32.32s,S=%32.32s,F=%32.32s,M=%32.32s)\n",
+					 *argv, f[i].file->filename,
+					 &f[i].ordered[0], &f[i].sorted[0],
+					 &f[i].fast_find[0], &f[i].mixed[0]);
+			     }
+			}
+
+			free(f);
+		    }
+		    chmd->close(chmd, chm2);
+		}
+		chmd->close(chmd, chm);
+	    }
+	    else {
+		printf("%s: can't open -- %s\n", *argv, ERROR(chmd));
+	    }
+	}
+	mspack_destroy_chm_decompressor(chmd);
+    }
+    return 0;
+}

data/ext/libmspack/test/chminfo.c

@@ -0,0 +1,284 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <mspack.h>
+#include <system.h>
+
+#define FILENAME ".chminfo-temp"
+
+unsigned char *load_sys_data(struct mschm_decompressor *chmd,
+                             struct mschmd_header *chm,
+			     const char *filename,
+			     off_t *length_ptr)
+{
+  struct mschmd_file *file;
+  unsigned char *data;
+  FILE *fh;
+
+  for (file = chm->sysfiles; file; file = file->next) {
+    if (strcmp(file->filename, filename) == 0) break;
+  }
+  if (!file || file->section->id != 0) return NULL;
+  if (chmd->extract(chmd, file, FILENAME)) return NULL;
+  if (length_ptr) *length_ptr = file->length;
+  if (!(data = (unsigned char *) malloc((size_t) file->length))) return NULL;
+  if ((fh = fopen(FILENAME, "rb"))) {
+    fread(data, (size_t) file->length, 1, fh);
+    fclose(fh);
+  }
+  else {
+    free(data);
+    data = NULL;
+  }
+  unlink(FILENAME);
+  return data;
+}
+
+char *guid(unsigned char *data) {
+  static char result[43];
+  snprintf(result, sizeof(result),
+           "{%08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X%02X%02X}",
+           EndGetI32(&data[0]),
+           data[4] | (data[5] << 8),
+           data[6] | (data[7] << 8),
+           data[8] | (data[9] << 8),
+           data[10], data[11], data[12], data[13],
+           data[14], data[15], data[16], data[17]);
+  return result;
+}
+
+#define READ_ENCINT(var, label) do {	       		\
+    (var) = 0;						\
+    do {						\
+	if (p > &chunk[chm->chunk_size-2]) goto label;	\
+	(var) = ((var) << 7) | (*p & 0x7F);		\
+    } while (*p++ & 0x80);				\
+} while (0)
+
+void print_dir(struct mschmd_header *chm, char *filename) {
+  unsigned char dir[0x54], *chunk;
+  unsigned int i;
+  FILE *fh;
+
+  if (!(chunk = (unsigned char *) malloc(chm->chunk_size))) return;
+  
+  if ((fh = fopen(filename, "rb"))) {
+#ifdef HAVE_FSEEKO
+    fseeko(fh, chm->dir_offset - 84, SEEK_SET);
+#else
+    fseek(fh, chm->dir_offset - 84, SEEK_SET);
+#endif
+    fread(&dir[0], 84, 1, fh);
+    printf("  chmhs1_Signature  = %4.4s\n", &dir[0]);
+    printf("  chmhs1_Version    = %d\n", EndGetI32(&dir[4]));
+    printf("  chmhs1_HeaderLen  = %d\n", EndGetI32(&dir[8]));
+    printf("  chmhs1_Unknown1   = %d\n", EndGetI32(&dir[12]));
+    printf("  chmhs1_ChunkSize  = %d\n", EndGetI32(&dir[16]));
+    printf("  chmhs1_Density    = %d\n", EndGetI32(&dir[20]));
+    printf("  chmhs1_Depth      = %d\n", EndGetI32(&dir[24]));
+    printf("  chmhs1_IndexRoot  = %d\n", EndGetI32(&dir[28]));
+    printf("  chmhs1_FirstPMGL  = %d\n", EndGetI32(&dir[32]));
+    printf("  chmhs1_LastPMGL   = %d\n", EndGetI32(&dir[36]));
+    printf("  chmhs1_Unknown2   = %d\n", EndGetI32(&dir[40]));
+    printf("  chmhs1_NumChunks  = %d\n", EndGetI32(&dir[44]));
+    printf("  chmhs1_LanguageID = %d\n", EndGetI32(&dir[48]));
+    printf("  chmhs1_GUID       = %s\n", guid(&dir[52]));
+    printf("  chmhs1_Unknown3   = %d\n", EndGetI32(&dir[68]));
+    printf("  chmhs1_Unknown4   = %d\n", EndGetI32(&dir[72]));
+    printf("  chmhs1_Unknown5   = %d\n", EndGetI32(&dir[76]));
+    printf("  chmhs1_Unknown6   = %d\n", EndGetI32(&dir[80]));
+
+    for (i = 0; i < chm->num_chunks; i++) {
+      unsigned int num_entries, quickref_size, j, k;
+      unsigned char *p, *name;
+      printf("  CHUNK %u:\n", i);
+      fread(chunk, chm->chunk_size, 1, fh);
+
+      if ((chunk[0] == 'P') && (chunk[1] == 'M') &&
+          (chunk[2] == 'G') && (chunk[3] == 'L'))
+      {
+        k = chm->chunk_size - 2;
+        num_entries = chunk[k] | (chunk[k+1] << 8);
+        quickref_size = EndGetI32(&chunk[4]);
+	if (quickref_size > (chm->chunk_size - 20)) {
+	    printf("    QR size of %d too large (max is %d)\n",
+		   quickref_size, chm->chunk_size - 20);
+	    quickref_size = chm->chunk_size - 20;
+	}
+        printf("    PMGL entries=%u qrsize=%u zero=%u prev=%d next=%d\n",
+               num_entries, quickref_size, EndGetI32(&chunk[8]),
+               EndGetI32(&chunk[12]), EndGetI32(&chunk[16]));
+
+        printf("    QR: entry %4u = offset %u\n", 0, 20);
+        j = (1 << chm->density) + 1;
+        while (j < num_entries) {
+          k -= 2;
+	  if (k < (chm->chunk_size - quickref_size)) break;
+          printf("    QR: entry %4u = offset %u\n",
+                 j, (chunk[k] | (chunk[k+1] << 8)) + 20);
+          j += (1 << chm->density) + 1;
+        }
+
+        p = &chunk[20];
+        for (j = 0; j < num_entries; j++) {
+          unsigned int name_len = 0, section = 0, offset = 0, length = 0;
+          printf("    %4d: ", (int) (p - &chunk[0]));
+	  READ_ENCINT(name_len, PMGL_end); name = p; p += name_len;
+	  READ_ENCINT(section, PMGL_end);
+	  READ_ENCINT(offset, PMGL_end);
+	  READ_ENCINT(length, PMGL_end);
+          printf("sec=%u off=%-10u len=%-10u name=\"",section,offset,length);
+          if (name_len) fwrite(name, 1, name_len, stdout);
+          printf("\"\n");
+	}
+      PMGL_end:
+	if (j != num_entries) printf("premature end of chunk\n");
+
+      }
+      else if  ((chunk[0] == 'P') && (chunk[1] == 'M') &&
+		(chunk[2] == 'G') && (chunk[3] == 'I'))
+      {
+	k = chm->chunk_size - 2;
+	num_entries = chunk[k] | (chunk[k+1] << 8);
+	quickref_size = EndGetI32(&chunk[4]);
+	printf("    PMGI entries=%u free=%u\n", num_entries, quickref_size);
+
+        printf("    QR: entry %4u = offset %u\n", 0, 8);
+        j = (1 << chm->density) + 1;
+        while (j < num_entries) {
+          k -= 2;
+          printf("    QR: entry %4u = offset %u\n",
+                 j, (chunk[k] | (chunk[k+1] << 8)) + 8);
+          j += (1 << chm->density) + 1;
+        }
+
+        p = &chunk[8];
+        for (j = 0; j < num_entries; j++) {
+          unsigned int name_len, section;
+          printf("    %4d: ", (int) (p - &chunk[0]));
+          READ_ENCINT(name_len, PMGI_end); name = p; p += name_len;
+          READ_ENCINT(section, PMGI_end);
+          printf("chunk=%-4u name=\"",section);
+          if (name_len) fwrite(name, 1, name_len, stdout);
+          printf("\"\n");
+	}
+      PMGI_end: 
+	if (j != num_entries) printf("premature end of chunk\n");
+      }
+      else {
+	printf("    unknown format\n");
+      }
+    }
+
+    fclose(fh);
+  }
+}
+
+
+int main(int argc, char *argv[]) {
+  struct mschm_decompressor *chmd;
+  struct mschmd_header *chm;
+  struct mschmd_file *file;
+  unsigned int numf, i;
+  unsigned char *data;
+  off_t pos, len;
+
+  setbuf(stdout, NULL);
+  setbuf(stderr, NULL);
+
+  MSPACK_SYS_SELFTEST(i);
+  if (i) return 0;
+
+  if ((chmd = mspack_create_chm_decompressor(NULL))) {
+    for (argv++; *argv; argv++) {
+      printf("%s\n", *argv);
+      if ((chm = chmd->open(chmd, *argv))) {
+	printf("  chmhead_Version     %u\n",      chm->version);
+	printf("  chmhead_Timestamp   %u\n",      chm->timestamp);
+	printf("  chmhead_LanguageID  %u\n", 	 chm->language);
+	printf("  chmhs0_FileLen      %" LD "\n", chm->length);
+	printf("  chmhst_OffsetHS1    %" LD "\n", chm->dir_offset);
+	printf("  chmhst3_OffsetCS0   %" LD "\n", chm->sec0.offset);
+
+	print_dir(chm, *argv);
+
+	if ((data = load_sys_data(chmd, chm,
+	     "::DataSpace/Storage/MSCompressed/ControlData", &len)))
+        {
+	  printf("  lzxcd_Length        %u\n",    EndGetI32(&data[0]));
+	  printf("  lzxcd_Signature     %4.4s\n", &data[4]);
+	  printf("  lzxcd_Version       %u\n",    EndGetI32(&data[8]));
+	  printf("  lzxcd_ResetInterval %u\n",    EndGetI32(&data[12]));
+	  printf("  lzxcd_WindowSize    %u\n",    EndGetI32(&data[16]));
+	  printf("  lzxcd_CacheSize     %u\n",    EndGetI32(&data[20]));
+	  printf("  lzxcd_Unknown1      %u\n",    EndGetI32(&data[24]));
+	  free(data);
+	}
+
+	if ((data = load_sys_data(chmd, chm,
+	     "::DataSpace/Storage/MSCompressed/Transform/{7FC28940-"
+	     "9D31-11D0-9B27-00A0C91E9C7C}/InstanceData/ResetTable", &len)))
+        {
+	  off_t contents = chm->sec0.offset;
+	  printf("  lzxrt_Unknown1      %u\n",      EndGetI32(&data[0]));
+	  printf("  lzxrt_NumEntries    %u\n",      EndGetI32(&data[4]));
+	  printf("  lzxrt_EntrySize     %u\n",      EndGetI32(&data[8]));
+	  printf("  lzxrt_TableOffset   %u\n",      EndGetI32(&data[12]));
+	  printf("  lzxrt_UncompLen     %" LU "\n", EndGetI64(&data[16]));
+	  printf("  lzxrt_CompLen       %" LU "\n", EndGetI64(&data[24]));
+	  printf("  lzxrt_FrameLen      %u\n",      EndGetI32(&data[32]));
+
+	  for (file = chm->sysfiles; file; file = file->next) {
+	    if (strcmp(file->filename,
+		       "::DataSpace/Storage/MSCompressed/Content") == 0)
+	    {
+	      contents += file->offset;
+	      break;
+	    }
+	  }
+
+	  printf("  - reset table (uncomp offset -> stream offset "
+		 "[real offset, length in file]\n");
+
+	  numf = EndGetI32(&data[4]);
+	  pos = ((unsigned int) EndGetI32(&data[12]));
+	  switch (EndGetI32(&data[8])) {
+	  case 4:
+	    for (i = 0; i < numf && pos < len; i++, pos += 4) {
+	      unsigned int rtdata = EndGetI32(&data[pos]);
+	      printf("    %-10u -> %-10u [ %" LU " %u ]\n",
+		     i * EndGetI32(&data[32]),
+		     rtdata,
+		     contents + rtdata,
+		     (i == (numf-1))
+		     ? (EndGetI32(&data[24]) - rtdata)
+		     : (EndGetI32(&data[pos + 4]) - rtdata)
+		     );
+	    }
+	    break;
+	  case 8:
+	    for (i = 0; i < numf && pos < len; i++, pos += 8) {
+	      unsigned long long int rtdata = EndGetI64(&data[pos]);
+	      printf("    %-10" LU " -> %-10" LU " [ %" LU " %" LU " ]\n",
+		     i * EndGetI64(&data[32]), rtdata, contents + rtdata,
+		     (i == (numf-1))
+		     ? (EndGetI64(&data[24]) - rtdata)
+		     : (EndGetI64(&data[pos + 8]) - rtdata)
+		     );
+	    }
+	    break;
+	  }
+	  free(data);
+	}
+	chmd->close(chmd, chm);
+      }
+    }
+    mspack_destroy_chm_decompressor(chmd);
+  }
+  return 0;
+}

data/ext/libmspack/test/chmx.c

@@ -0,0 +1,216 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <mspack.h>
+#include <ctype.h>
+#include <sys/stat.h>
+
+#include <error.h>
+
+mode_t user_umask;
+
+#define FILENAME ".test.chmx"
+
+/**
+ * Ensures that all directory components in a filepath exist. New directory
+ * components are created, if necessary.
+ *
+ * @param path the filepath to check
+ * @return non-zero if all directory components in a filepath exist, zero
+ *         if components do not exist and cannot be created
+ */
+static int ensure_filepath(char *path) {
+  struct stat st_buf;
+  char *p;
+  int ok;
+
+  for (p = &path[1]; *p; p++) {
+    if (*p != '/') continue;
+    *p = '\0';
+    ok = (stat(path, &st_buf) == 0) && S_ISDIR(st_buf.st_mode);
+    if (!ok) ok = (mkdir(path, 0777 & ~user_umask) == 0);
+    *p = '/';
+    if (!ok) return 0;
+  }
+  return 1;
+}
+
+/**
+ * Creates a UNIX filename from the internal CAB filename and the given
+ * parameters.
+ *
+ * @param fname  the internal CAB filename.
+ * @param dir    a directory path to prepend to the output filename.
+ * @param lower  if non-zero, filename should be made lower-case.
+ * @param isunix if zero, MS-DOS path seperators are used in the internal
+ *               CAB filename. If non-zero, UNIX path seperators are used.
+ * @param utf8   if non-zero, the internal CAB filename is encoded in UTF8.
+ * @return a freshly allocated and created filename, or NULL if there was
+ *         not enough memory.
+ * @see unix_path_seperators()
+ */
+static char *create_output_name(unsigned char *fname, unsigned char *dir,
+			 int lower, int isunix, int utf8)
+{
+  unsigned char *p, *name, c, *fe, sep, slash;
+  unsigned int x;
+
+  sep   = (isunix) ? '/'  : '\\'; /* the path-seperator */
+  slash = (isunix) ? '\\' : '/';  /* the other slash */
+
+  /* length of filename */
+  x = strlen((char *) fname);
+  /* UTF8 worst case scenario: tolower() expands all chars from 1 to 3 bytes */
+  if (utf8) x *= 3;
+  /* length of output directory */
+  if (dir) x += strlen((char *) dir);
+
+  if (!(name = (unsigned char *) malloc(x + 2))) {
+    fprintf(stderr, "out of memory!\n");
+    return NULL;
+  }
+  
+  /* start with blank name */
+  *name = '\0';
+
+  /* add output directory if needed */
+  if (dir) {
+    strcpy((char *) name, (char *) dir);
+    strcat((char *) name, "/");
+  }
+
+  /* remove leading slashes */
+  while (*fname == sep) fname++;
+
+  /* copy from fi->filename to new name, converting MS-DOS slashes to UNIX
+   * slashes as we go. Also lowercases characters if needed.
+   */
+  p = &name[strlen((char *)name)];
+  fe = &fname[strlen((char *)fname)];
+
+  if (utf8) {
+    /* UTF8 translates two-byte unicode characters into 1, 2 or 3 bytes.
+     * %000000000xxxxxxx -> %0xxxxxxx
+     * %00000xxxxxyyyyyy -> %110xxxxx %10yyyyyy
+     * %xxxxyyyyyyzzzzzz -> %1110xxxx %10yyyyyy %10zzzzzz
+     *
+     * Therefore, the inverse is as follows:
+     * First char:
+     *  0x00 - 0x7F = one byte char
+     *  0x80 - 0xBF = invalid
+     *  0xC0 - 0xDF = 2 byte char (next char only 0x80-0xBF is valid)
+     *  0xE0 - 0xEF = 3 byte char (next 2 chars only 0x80-0xBF is valid)
+     *  0xF0 - 0xFF = invalid
+     */
+    do {
+      if (fname >= fe) {
+	free(name);
+	return NULL;
+      }
+
+      /* get next UTF8 char */
+      if ((c = *fname++) < 0x80) x = c;
+      else {
+	if ((c >= 0xC0) && (c < 0xE0)) {
+	  x = (c & 0x1F) << 6;
+	  x |= *fname++ & 0x3F;
+	}
+	else if ((c >= 0xE0) && (c < 0xF0)) {
+	  x = (c & 0xF) << 12;
+	  x |= (*fname++ & 0x3F) << 6;
+	  x |= *fname++ & 0x3F;
+	}
+	else x = '?';
+      }
+
+      /* whatever is the path seperator -> '/'
+       * whatever is the other slash    -> '\\'
+       * otherwise, if lower is set, the lowercase version */
+      if      (x == sep)   x = '/';
+      else if (x == slash) x = '\\';
+      else if (lower)      x = (unsigned int) tolower((int) x);
+
+      /* integer back to UTF8 */
+      if (x < 0x80) {
+	*p++ = (unsigned char) x;
+      }
+      else if (x < 0x800) {
+	*p++ = 0xC0 | (x >> 6);   
+	*p++ = 0x80 | (x & 0x3F);
+      }
+      else {
+	*p++ = 0xE0 | (x >> 12);
+	*p++ = 0x80 | ((x >> 6) & 0x3F);
+	*p++ = 0x80 | (x & 0x3F);
+      }
+    } while (x);
+  }
+  else {
+    /* regular non-utf8 version */
+    do {
+      c = *fname++;
+      if      (c == sep)   c = '/';
+      else if (c == slash) c = '\\';
+      else if (lower)      c = (unsigned char) tolower((int) c);
+    } while ((*p++ = c));
+  }
+  return (char *) name;
+}
+
+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;
+
+  setbuf(stdout, NULL);
+  setbuf(stderr, NULL);
+  user_umask = umask(0); umask(user_umask);
+
+  MSPACK_SYS_SELFTEST(i);
+  if (i) return 0;
+
+  if ((chmd = mspack_create_chm_decompressor(NULL))) {
+    for (argv++; *argv; argv++) {
+      printf("%s\n", *argv);
+      if ((chm = chmd->open(chmd, *argv))) {
+
+	/* build an ordered list of files for maximum extraction speed */
+	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++) {
+	    char *outname = create_output_name((unsigned char *)f[i]->filename,NULL,0,1,0);
+	    printf("Extracting %s\n", outname);
+	    ensure_filepath(outname);
+	    if (chmd->extract(chmd, f[i], outname)) {
+	      printf("%s: extract error on \"%s\": %s\n",
+		     *argv, f[i]->filename, ERROR(chmd));
+	    }
+	    free(outname);
+	  }
+	  free(f);
+	}
+	chmd->close(chmd, chm);
+      }
+      else {
+	printf("%s: can't open -- %s\n", *argv, ERROR(chmd));
+      }
+    }
+    mspack_destroy_chm_decompressor(chmd);
+  }
+  return 0;
+}

data/ext/libmspack/test/error.h

@@ -0,0 +1,22 @@
+#define ERROR(base) error_msg(base->last_error(base))
+
+const char *error_msg(int error) {
+    static char buf[32];
+    switch (error) {
+    case MSPACK_ERR_OK:         return "no error";
+    case MSPACK_ERR_ARGS:       return "bad arguments to library function";
+    case MSPACK_ERR_OPEN:       return "error opening file";
+    case MSPACK_ERR_READ:       return "read error";
+    case MSPACK_ERR_WRITE:      return "write error";
+    case MSPACK_ERR_SEEK:       return "seek error";
+    case MSPACK_ERR_NOMEMORY:   return "out of memory";
+    case MSPACK_ERR_SIGNATURE:  return "bad signature";
+    case MSPACK_ERR_DATAFORMAT: return "error in data format";
+    case MSPACK_ERR_CHECKSUM:   return "checksum error";
+    case MSPACK_ERR_CRUNCH:     return "compression error";
+    case MSPACK_ERR_DECRUNCH:   return "decompression error";
+    }
+
+    snprintf(buf, sizeof(buf), "unknown error %d", error);
+    return buf;
+}