sys/i386/boot/kzipboot/misc.c

   1 /*
   2  * misc.c
   3  *
   4  * This is a collection of several routines from gzip-1.0.3
   5  * adapted for Linux.
   6  *
   7  * Ported to 386bsd by Serge Vakulenko
   8  *
   9  * $DragonFly: src/sys/i386/boot/kzipboot/Attic/misc.c,v 1.2 2003/08/07 21:17:20 dillon Exp $
  10  */
  11
  12 #include "use_gzip.h"
  13
  14 unsigned outcnt;
  15 unsigned insize;
  16 unsigned inptr;
  17
  18 extern const char input_data[];
  19 extern const int input_len;
  20
  21 int input_ptr;
  22
  23 int method;
  24
  25 char *output_data;
  26 ulong output_ptr;
  27
  28 void makecrc (void);
  29 void putstr (char *c);
  30 void *memcpy (void *to, const void *from, unsigned len);
  31 int memcmp (const void *arg1, const void *arg2, unsigned len);
  32
  33 ulong crc;                              /* shift register contents */
  34 ulong crc_32_tab[256];                  /* crc table, defined below */
  35
  36 /*
  37  * Run a set of bytes through the crc shift register.  If s is a NULL
  38  * pointer, then initialize the crc shift register contents instead.
  39  * Return the current crc in either case.
  40  */
  41 void updcrc(s, n)
  42 uchar *s;                       /* pointer to bytes to pump through */
  43 unsigned n;                     /* number of bytes in s[] */
  44 {
  45         while (n--)
  46                 crc = crc_32_tab[(uchar)crc ^ (*s++)] ^ (crc >> 8);
  47 }
  48
  49 /*
  50  * Clear input and output buffers
  51  */
  52 void clear_bufs()
  53 {
  54         outcnt = 0;
  55         insize = inptr = 0;
  56 }
  57
  58 /*
  59  * Fill the input buffer. This is called only when the buffer is empty
  60  * and at least one byte is really needed.
  61  */
  62 void fill_inbuf ()
  63 {
  64         int len, i;
  65
  66         /* Read as much as possible */
  67         insize = 0;
  68         do {
  69                 len = INBUFSIZ - insize;
  70                 if (len > input_len - input_ptr + 1)
  71                         len = input_len-input_ptr+1;
  72                 if (len <= 0)
  73                         break;
  74                 for (i=0; i<len; i++)
  75                         inbuf[insize+i] = input_data[input_ptr+i];
  76                 insize += len;
  77                 input_ptr += len;
  78         } while (insize < INBUFSIZ);
  79         if (insize == 0)
  80                 error("unable to fill buffer");
  81         inptr = 0;
  82 }
  83
  84 /*
  85  * Write the output window window[0..outcnt-1] and update crc and bytes_out.
  86  * (Used for the decompressed data only.)
  87  */
  88 void flush_window()
  89 {
  90         if (outcnt == 0) return;
  91         updcrc(window, outcnt);
  92
  93         memcpy(&output_data[output_ptr], (char *)window, outcnt);
  94
  95         output_ptr += outcnt;
  96         outcnt = 0;
  97 }
  98
  99 /*
 100  * Code to compute the CRC-32 table. Borrowed from
 101  * gzip-1.0.3/makecrc.c.
 102  * Not copyrighted 1990 Mark Adler
 103  */
 104 void makecrc(void)
 105 {
 106         ulong c;        /* crc shift register */
 107         ulong e;        /* polynomial exclusive-or pattern */
 108         int i;          /* counter for all possible eight bit values */
 109         int k;          /* byte being shifted into crc apparatus */
 110
 111         /* terms of polynomial defining this crc (except x^32): */
 112         static const uchar poly[] = { 0,1,2,4,5,7,8,10,11,12,16,22,23,26, };
 113
 114         /* Make exclusive-or pattern from polynomial */
 115         e = 0;
 116         for (i = 0; i < sizeof(poly)/sizeof(*poly); i++)
 117                 e |= 1L << (31 - poly[i]);
 118
 119         crc_32_tab[0] = 0;
 120
 121         for (i = 1; i < 256; i++) {
 122                 c = 0;
 123                 for (k = i | 256; k != 1; k >>= 1) {
 124                         c = c & 1 ? (c >> 1) ^ e : c >> 1;
 125                         if (k & 1)
 126                                 c ^= e;
 127                 }
 128                 crc_32_tab[i] = c;
 129         }
 130 }
 131
 132 /*
 133  * Check the magic number of the input file and update ofname if an
 134  * original name was given and to_stdout is not set.
 135  * Set inptr to the offset of the next byte to be processed.
 136  */
 137 static void get_method()
 138 {
 139         uchar flags;
 140         char magic[2];  /* magic header */
 141
 142         magic[0] = get_byte();
 143         magic[1] = get_byte();
 144
 145         method = -1;            /* unknown yet */
 146         extended = pkzip = 0;
 147         /* assume multiple members in gzip file except for record oriented I/O */
 148
 149         if (memcmp(magic, GZIP_MAGIC, 2) == 0
 150             || memcmp(magic, OLD_GZIP_MAGIC, 2) == 0) {
 151                 method = get_byte();
 152                 flags  = get_byte();
 153                 if (flags & ENCRYPTED)
 154                         error("Input is encrypted");
 155                 if (flags & CONTINUATION)
 156                         error("Multi part input");
 157                 if (flags & RESERVED)
 158                         error("Input has invalid flags");
 159
 160                 (void) get_byte();      /* Get timestamp */
 161                 (void) get_byte();
 162                 (void) get_byte();
 163                 (void) get_byte();
 164
 165                 (void) get_byte();      /* Ignore extra flags for the moment */
 166                 (void) get_byte();      /* Ignore OS type for the moment */
 167
 168                 if (flags & EXTRA_FIELD) {
 169                         unsigned len = get_byte();
 170                         len |= get_byte() << 8;
 171                         while (len--)
 172                                 (void) get_byte();
 173                 }
 174
 175                 /* Discard file comment if any */
 176                 if (flags & COMMENT)
 177                         while (get_byte())
 178                                 continue;
 179
 180         } else if (memcmp(magic, PKZIP_MAGIC, 2) == 0 && inptr == 2
 181             && memcmp(inbuf, PKZIP_MAGIC, 4) == 0) {
 182                 /*
 183                  * To simplify the code, we support a zip file when alone only.
 184                  * We are thus guaranteed that the entire local header fits in inbuf.
 185                  */
 186                 inptr = 0;
 187                 check_zipfile();
 188
 189         } else if (memcmp(magic, PACK_MAGIC, 2) == 0)
 190                 error("packed input");
 191         else if (memcmp(magic, LZW_MAGIC, 2) == 0)
 192                 error("compressed input");
 193         if (method == -1)
 194                 error("Corrupted input");
 195 }
 196
 197 void
 198 decompress_kernel (void *dest)
 199 {
 200         output_data = dest;
 201         output_ptr = 0;
 202
 203         input_ptr = 0;
 204
 205         clear_bufs ();
 206         makecrc ();
 207         get_method ();
 208         unzip ();
 209 }