memdisk/unzip.c

   1 /*
   2  * unzip.c
   3  *
   4  * This is a collection of several routines from gzip-1.0.3
   5  * adapted for Linux.
   6  *
   7  * malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994
   8  * puts by Nick Holloway 1993, better puts by Martin Mares 1995
   9  * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
  10  *
  11  * Adapted for MEMDISK by H. Peter Anvin, April 2003
  12  */
  13
  14 #include <stdint.h>
  15 #include "memdisk.h"
  16 #include "conio.h"
  17
  18 /*
  19  * gzip declarations
  20  */
  21
  22 #define OF(args)  args
  23 #define STATIC static
  24
  25 #define memzero(s, n)     memset ((s), 0, (n))
  26
  27 typedef uint8_t  uch;
  28 typedef uint16_t ush;
  29 typedef uint32_t ulg;
  30
  31 #define WSIZE 0x8000            /* Window size must be at least 32k, */
  32                                 /* and a power of two */
  33
  34 static uch *inbuf;              /* input pointer */
  35 static uch window[WSIZE];       /* sliding output window buffer */
  36
  37 static unsigned insize;         /* total input bytes read */
  38 static unsigned inbytes;        /* valid bytes in inbuf */
  39 static unsigned outcnt;         /* bytes in output buffer */
  40
  41 /* gzip flag byte */
  42 #define ASCII_FLAG   0x01 /* bit 0 set: file probably ASCII text */
  43 #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
  44 #define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
  45 #define ORIG_NAME    0x08 /* bit 3 set: original file name present */
  46 #define COMMENT      0x10 /* bit 4 set: file comment present */
  47 #define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
  48 #define RESERVED     0xC0 /* bit 6,7:   reserved */
  49
  50 /* Diagnostic functions */
  51 #ifdef DEBUG
  52 #  define Assert(cond,msg) {if(!(cond)) error(msg);}
  53 #  define Trace(x) fprintf x
  54 #  define Tracev(x) {if (verbose) fprintf x ;}
  55 #  define Tracevv(x) {if (verbose>1) fprintf x ;}
  56 #  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
  57 #  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
  58 #else
  59 #  define Assert(cond,msg)
  60 #  define Trace(x)
  61 #  define Tracev(x)
  62 #  define Tracevv(x)
  63 #  define Tracec(c,x)
  64 #  define Tracecv(c,x)
  65 #endif
  66
  67 static int  fill_inbuf(void);
  68 static void flush_window(void);
  69 static void error(char *m);
  70 static void gzip_mark(void **);
  71 static void gzip_release(void **);
  72
  73 static ulg crc_32_tab[256];
  74
  75 /* Get byte from input buffer */
  76 static inline uch get_byte(void)
  77 {
  78   if ( inbytes ) {
  79     uch b = *inbuf++;
  80     inbytes--;
  81     return b;
  82   } else {
  83     return fill_inbuf();        /* Input buffer underrun */
  84   }
  85 }
  86
  87 /* Unget byte from input buffer */
  88 static inline void unget_byte(void)
  89 {
  90   inbytes++;
  91   inbuf--;
  92 }
  93
  94 static ulg bytes_out = 0;       /* Number of bytes output */
  95 static uch *output_data;        /* Output data pointer */
  96 static ulg output_size;         /* Number of output bytes expected */
  97
  98 static void *malloc(int size);
  99 static void free(void *where);
 100
 101 static ulg free_mem_ptr, free_mem_end_ptr;
 102
 103 #include "inflate.c"
 104
 105 static void *malloc(int size)
 106 {
 107   void *p;
 108
 109   if (size < 0) error("malloc error");
 110
 111   free_mem_ptr = (free_mem_ptr + 3) & ~3;       /* Align */
 112
 113   p = (void *)free_mem_ptr;
 114   free_mem_ptr += size;
 115
 116   if (free_mem_ptr >= free_mem_end_ptr)
 117     error("out of memory");
 118
 119   return p;
 120 }
 121
 122 static void free(void *where)
 123 {
 124   /* Don't care */
 125   (void)where;
 126 }
 127
 128 static void gzip_mark(void **ptr)
 129 {
 130   *ptr = (void *) free_mem_ptr;
 131 }
 132
 133 static void gzip_release(void **ptr)
 134 {
 135   free_mem_ptr = (long) *ptr;
 136 }
 137
 138 /* ===========================================================================
 139  * Fill the input buffer. This is called only when the buffer is empty
 140  * and at least one byte is really needed.
 141  */
 142 static int fill_inbuf(void)
 143 {
 144   /* This should never happen.  We have already pointed the algorithm
 145      to all the data we have. */
 146   printf("failed\nDecompression error: ran out of input data\n");
 147   die();
 148 }
 149
 150 /* ===========================================================================
 151  * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 152  * (Used for the decompressed data only.)
 153  */
 154 static void flush_window(void)
 155 {
 156     ulg c = crc;         /* temporary variable */
 157     unsigned n;
 158     uch *in, *out, ch;
 159
 160     if ( bytes_out+outcnt > output_size )
 161       error("output buffer overrun");
 162
 163     in = window;
 164     out = output_data;
 165     for (n = 0; n < outcnt; n++) {
 166             ch = *out++ = *in++;
 167             c = crc_32_tab[(c ^ ch) & 0xff] ^ (c >> 8);
 168     }
 169     crc = c;
 170     output_data = out;
 171     bytes_out += (ulg)outcnt;
 172     outcnt = 0;
 173 }
 174
 175 static void error(char *x)
 176 {
 177   printf("failed\nDecompression error: %s\n", x);
 178   die();
 179 }
 180
 181 /* GZIP header */
 182 struct gzip_header {
 183   uint16_t magic;
 184   uint8_t method;
 185   uint8_t flags;
 186   uint32_t timestamp;
 187   uint8_t extra_flags;
 188   uint8_t os_type;
 189 } __attribute__ ((packed));
 190 /* (followed by optional and variable length "extra", "original name",
 191    and "comment" fields) */
 192
 193 struct gzip_trailer {
 194   uint32_t crc;
 195   uint32_t dbytes;
 196 } __attribute__ ((packed));
 197
 198 /* PKZIP header.  See
 199  * <http://www.pkware.com/products/enterprise/white_papers/appnote.html>.
 200  */
 201 struct pkzip_header {
 202   uint32_t magic;
 203   uint16_t version;
 204   uint16_t flags;
 205   uint16_t method;
 206   uint16_t modified_time;
 207   uint16_t modified_date;
 208   uint32_t crc;
 209   uint32_t zbytes;
 210   uint32_t dbytes;
 211   uint16_t filename_len;
 212   uint16_t extra_len;
 213 } __attribute__ ((packed));
 214 /* (followed by optional and variable length "filename" and "extra"
 215    fields) */
 216
 217 /* gzip flag byte */
 218 #define ASCII_FLAG   0x01 /* bit 0 set: file probably ASCII text */
 219 #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
 220 #define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
 221 #define ORIG_NAME    0x08 /* bit 3 set: original file name present */
 222 #define COMMENT      0x10 /* bit 4 set: file comment present */
 223 #define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
 224 #define RESERVED     0xC0 /* bit 6,7:   reserved */
 225
 226 /* pkzip flag byte */
 227 #define PK_ENCRYPTED     0x01  /* bit 0 set: file is encrypted */
 228 #define PK_DATADESC       0x08  /* bit 3 set: file has trailing "data
 229                                    descriptor" */
 230 #define PK_UNSUPPORTED    0xFFF0 /* All other bits must be zero */
 231
 232
 233 /* Return 0 if (indata, size) points to a ZIP file, and fill in
 234    compressed data size, uncompressed data size, CRC, and offset of
 235    data.
 236
 237    If indata is not a ZIP file, return -1. */
 238 int check_zip(void *indata, uint32_t size, uint32_t *zbytes_p,
 239               uint32_t *dbytes_p, uint32_t *orig_crc, uint32_t *offset_p) {
 240   struct gzip_header *gzh = (struct gzip_header *)indata;
 241   struct pkzip_header *pkzh = (struct pkzip_header *)indata;
 242   uint32_t offset;
 243
 244   if (gzh->magic == 0x8b1f) {
 245     struct gzip_trailer *gzt = indata + size - sizeof (struct gzip_trailer);
 246     /* We only support method #8, DEFLATED */
 247     if (gzh->method != 8)  {
 248       error("gzip file uses invalid method");
 249       return -1;
 250     }
 251     if (gzh->flags & ENCRYPTED) {
 252       error("gzip file is encrypted; not supported");
 253       return -1;
 254     }
 255     if (gzh->flags & CONTINUATION) {
 256       error("gzip file is a continuation file; not supported");
 257       return -1;
 258     }
 259     if (gzh->flags & RESERVED) {
 260       error("gzip file has unsupported flags");
 261       return -1;
 262     }
 263     offset = sizeof (*gzh);
 264     if (gzh->flags & EXTRA_FIELD) {
 265       /* Skip extra field */
 266       unsigned len = *(unsigned *)(indata + offset);
 267       offset += 2 + len;
 268     }
 269     if (gzh->flags & ORIG_NAME) {
 270       /* Discard the old name */
 271       uint8_t *p = indata;
 272       while (p[offset] != 0 && offset < size) {
 273         offset++;
 274       }
 275       offset++;
 276     }
 277
 278     if (gzh->flags & COMMENT) {
 279       /* Discard the comment */
 280       uint8_t *p = indata;
 281       while (p[offset] != 0 && offset < size) {
 282         offset++;
 283       }
 284       offset++;
 285     }
 286
 287     if (offset > size) {
 288       error ("gzip file corrupt");
 289       return -1;
 290     }
 291     *zbytes_p = size - offset - sizeof (struct gzip_trailer);
 292     *dbytes_p = gzt->dbytes;
 293     *orig_crc = gzt->crc;
 294     *offset_p = offset;
 295     return 0;
 296   }
 297   else if (pkzh->magic == 0x04034b50UL) {
 298     /* Magic number matches pkzip file. */
 299
 300     offset = sizeof (*pkzh);
 301     if (pkzh->flags & PK_ENCRYPTED) {
 302       error("pkzip file is encrypted; not supported");
 303       return -1;
 304     }
 305     if (pkzh->flags & PK_DATADESC) {
 306       error("pkzip file uses data_descriptor field; not supported");
 307       return -1;
 308     }
 309     if (pkzh->flags & PK_UNSUPPORTED) {
 310       error("pkzip file has unsupported flags");
 311       return -1;
 312     }
 313
 314     /* We only support method #8, DEFLATED */
 315     if (pkzh->method != 8) {
 316       error("pkzip file uses invalid method");
 317       return -1;
 318     }
 319     /* skip header */
 320     offset = sizeof (*pkzh);
 321     /* skip filename */
 322     offset += pkzh->filename_len;
 323     /* skip extra field */
 324     offset += pkzh->extra_len;
 325
 326     if (offset + pkzh->zbytes > size) {
 327       error ("pkzip file corrupt");
 328       return -1;
 329     }
 330
 331     *zbytes_p = pkzh->zbytes;
 332     *dbytes_p = pkzh->dbytes;
 333     *orig_crc = pkzh->crc;
 334     *offset_p = offset;
 335     return 0;
 336   }
 337   else {
 338     /* Magic number does not match. */
 339     return -1;
 340   }
 341
 342   error ("Internal error in check_zip");
 343   return -1;
 344 }
 345
 346 /*
 347  * Decompress the image, trying to flush the end of it as close
 348  * to end_mem as possible.  Return a pointer to the data block,
 349  * and change datalen.
 350  */
 351 extern void _end;
 352
 353 void *unzip(void *indata, uint32_t zbytes, uint32_t dbytes,
 354             uint32_t orig_crc, void *target)
 355 {
 356   /* Set up the heap; it's the 64K after the bounce buffer */
 357   free_mem_ptr = (ulg)sys_bounce + 0x10000;
 358   free_mem_end_ptr = free_mem_ptr + 0x10000;
 359
 360   /* Set up input buffer */
 361   inbuf  = indata;
 362   /* Sometimes inflate() looks beyond the end of the compressed data,
 363      but it always backs up before it is done.  So we give it 4 bytes
 364      of slack. */
 365   insize = inbytes = zbytes + 4;
 366
 367   /* Set up output buffer */
 368   outcnt = 0;
 369   output_data = target;
 370   output_size = dbytes;
 371   bytes_out = 0;
 372
 373   makecrc();
 374   gunzip();
 375
 376   /* Verify that gunzip() consumed the entire input. */
 377   if (inbytes != 4)
 378     error("compressed data length error");
 379
 380   /* Check the uncompressed data length and CRC. */
 381   if ( bytes_out != dbytes )
 382     error("uncompressed data length error");
 383
 384   if (orig_crc != CRC_VALUE)
 385     error("crc error");
 386
 387   puts("ok\n");
 388
 389   return target;
 390 }