cabd_memory.c

Go to the documentation of this file.

/* 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;
 
}