X-Git-Url: https://code.delx.au/refind/blobdiff_plain/422321bc65fbee93798a7d74f2450eb15d06d871..45db1723901c7accd95b4cf996c2bb4bdca59fff:/filesystems/gzio.c diff --git a/filesystems/gzio.c b/filesystems/gzio.c index 271e2d8..9377660 100644 --- a/filesystems/gzio.c +++ b/filesystems/gzio.c @@ -59,7 +59,7 @@ GRUB_MOD_LICENSE ("GPLv3+"); * This must be a power of two, and at least 32K for zip's deflate method */ -#define WSIZE 0x8000 +#define WSIZE 0x8000 #define INBUFSIZ 0x2000 @@ -113,8 +113,8 @@ typedef struct grub_gzio *grub_gzio_t; static void initialize_tables (grub_gzio_t); /* Little-Endian defines for the 2-byte magic numbers for gzip files. */ -#define GZIP_MAGIC grub_le_to_cpu16 (0x8B1F) -#define OLD_GZIP_MAGIC grub_le_to_cpu16 (0x9E1F) +#define GZIP_MAGIC grub_le_to_cpu16 (0x8B1F) +#define OLD_GZIP_MAGIC grub_le_to_cpu16 (0x9E1F) /* Compression methods (see algorithm.doc) */ #define STORED 0 @@ -126,20 +126,20 @@ static void initialize_tables (grub_gzio_t); #define MAX_METHODS 9 /* gzip flag byte */ -#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ -#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */ -#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ -#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ -#define COMMENT 0x10 /* bit 4 set: file comment present */ -#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */ -#define RESERVED 0xC0 /* bit 6,7: reserved */ +#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ +#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */ +#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ +#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ +#define COMMENT 0x10 /* bit 4 set: file comment present */ +#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */ +#define RESERVED 0xC0 /* bit 6,7: reserved */ -#define UNSUPPORTED_FLAGS (CONTINUATION | ENCRYPTED | RESERVED) +#define UNSUPPORTED_FLAGS (CONTINUATION | ENCRYPTED | RESERVED) /* inflate block codes */ -#define INFLATE_STORED 0 -#define INFLATE_FIXED 1 -#define INFLATE_DYNAMIC 2 +#define INFLATE_STORED 0 +#define INFLATE_FIXED 1 +#define INFLATE_DYNAMIC 2 typedef unsigned char uch; typedef unsigned short ush; @@ -154,12 +154,12 @@ typedef unsigned long ulg; error in the data. */ struct huft { - uch e; /* number of extra bits or operation */ - uch b; /* number of bits in this code or subcode */ + uch e; /* number of extra bits or operation */ + uch b; /* number of bits in this code or subcode */ union { - ush n; /* literal, length base, or distance base */ - struct huft *t; /* pointer to next level of table */ + ush n; /* literal, length base, or distance base */ + struct huft *t; /* pointer to next level of table */ } v; }; @@ -177,24 +177,24 @@ struct huft /* Tables for deflate from PKZIP's appnote.txt. */ static unsigned bitorder[] = -{ /* Order of the bit length code lengths */ +{ /* Order of the bit length code lengths */ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; static ush cplens[] = -{ /* Copy lengths for literal codes 257..285 */ +{ /* Copy lengths for literal codes 257..285 */ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; - /* note: see note #13 above about the 258 in this list. */ + /* note: see note #13 above about the 258 in this list. */ static ush cplext[] = -{ /* Extra bits for literal codes 257..285 */ +{ /* Extra bits for literal codes 257..285 */ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, - 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99}; /* 99==invalid */ + 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99}; /* 99==invalid */ static ush cpdist[] = -{ /* Copy offsets for distance codes 0..29 */ +{ /* Copy offsets for distance codes 0..29 */ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577}; static ush cpdext[] = -{ /* Extra bits for distance codes */ +{ /* Extra bits for distance codes */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}; @@ -233,13 +233,13 @@ static ush cpdext[] = */ -static int lbits = 9; /* bits in base literal/length lookup table */ -static int dbits = 6; /* bits in base distance lookup table */ +static int lbits = 9; /* bits in base literal/length lookup table */ +static int dbits = 6; /* bits in base distance lookup table */ /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */ -#define BMAX 16 /* maximum bit length of any code (16 for explode) */ -#define N_MAX 288 /* maximum number of codes in any set */ +#define BMAX 16 /* maximum bit length of any code (16 for explode) */ +#define N_MAX 288 /* maximum number of codes in any set */ /* Macros for inflate() bit peeking and grabbing. @@ -288,7 +288,7 @@ static int get_byte (grub_gzio_t gzio) { if (gzio->mem_input_off < gzio->mem_input_size) - return gzio->mem_input[gzio->mem_input_off++]; + return gzio->mem_input[gzio->mem_input_off++]; return 0; } @@ -296,14 +296,14 @@ static void gzio_seek (grub_gzio_t gzio, grub_off_t off) { if (off > gzio->mem_input_size) - gzio->err = -1; + gzio->err = -1; else - gzio->mem_input_off = off; + gzio->mem_input_off = off; } /* more function prototypes */ static int huft_build (unsigned *, unsigned, unsigned, ush *, ush *, - struct huft **, int *); + struct huft **, int *); static int huft_free (struct huft *); static int inflate_codes_in_window (grub_gzio_t); @@ -315,33 +315,33 @@ static int inflate_codes_in_window (grub_gzio_t); oversubscribed set of lengths), and three if not enough memory. */ static int -huft_build (unsigned *b, /* code lengths in bits (all assumed <= BMAX) */ - unsigned n, /* number of codes (assumed <= N_MAX) */ - unsigned s, /* number of simple-valued codes (0..s-1) */ - ush * d, /* list of base values for non-simple codes */ - ush * e, /* list of extra bits for non-simple codes */ - struct huft **t, /* result: starting table */ - int *m) /* maximum lookup bits, returns actual */ +huft_build (unsigned *b, /* code lengths in bits (all assumed <= BMAX) */ + unsigned n, /* number of codes (assumed <= N_MAX) */ + unsigned s, /* number of simple-valued codes (0..s-1) */ + ush * d, /* list of base values for non-simple codes */ + ush * e, /* list of extra bits for non-simple codes */ + struct huft **t, /* result: starting table */ + int *m) /* maximum lookup bits, returns actual */ { - unsigned a; /* counter for codes of length k */ - unsigned c[BMAX + 1]; /* bit length count table */ - unsigned f; /* i repeats in table every f entries */ - int g; /* maximum code length */ - int h; /* table level */ - register unsigned i; /* counter, current code */ - register unsigned j; /* counter */ - register int k; /* number of bits in current code */ - int l; /* bits per table (returned in m) */ - register unsigned *p; /* pointer into c[], b[], or v[] */ - register struct huft *q; /* points to current table */ - struct huft r; /* table entry for structure assignment */ - struct huft *u[BMAX]; /* table stack */ - unsigned v[N_MAX]; /* values in order of bit length */ - register int w; /* bits before this table == (l * h) */ - unsigned x[BMAX + 1]; /* bit offsets, then code stack */ - unsigned *xp; /* pointer into x */ - int y; /* number of dummy codes added */ - unsigned z; /* number of entries in current table */ + unsigned a; /* counter for codes of length k */ + unsigned c[BMAX + 1]; /* bit length count table */ + unsigned f; /* i repeats in table every f entries */ + int g; /* maximum code length */ + int h; /* table level */ + register unsigned i; /* counter, current code */ + register unsigned j; /* counter */ + register int k; /* number of bits in current code */ + int l; /* bits per table (returned in m) */ + register unsigned *p; /* pointer into c[], b[], or v[] */ + register struct huft *q; /* points to current table */ + struct huft r; /* table entry for structure assignment */ + struct huft *u[BMAX]; /* table stack */ + unsigned v[N_MAX]; /* values in order of bit length */ + register int w; /* bits before this table == (l * h) */ + unsigned x[BMAX + 1]; /* bit offsets, then code stack */ + unsigned *xp; /* pointer into x */ + int y; /* number of dummy codes added */ + unsigned z; /* number of entries in current table */ /* Generate counts for each bit length */ fsw_memzero ((char *) c, sizeof (c)); @@ -349,11 +349,11 @@ huft_build (unsigned *b, /* code lengths in bits (all assumed <= BMAX) */ i = n; do { - c[*p]++; /* assume all entries <= BMAX */ - p++; /* Can't combine with above line (Solaris bug) */ + c[*p]++; /* assume all entries <= BMAX */ + p++; /* Can't combine with above line (Solaris bug) */ } while (--i); - if (c[0] == n) /* null input--all zero length codes */ + if (c[0] == n) /* null input--all zero length codes */ { *t = (struct huft *) NULL; *m = 0; @@ -365,13 +365,13 @@ huft_build (unsigned *b, /* code lengths in bits (all assumed <= BMAX) */ for (j = 1; j <= BMAX; j++) if (c[j]) break; - k = j; /* minimum code length */ + k = j; /* minimum code length */ if ((unsigned) l < j) l = j; for (i = BMAX; i; i--) if (c[i]) break; - g = i; /* maximum code length */ + g = i; /* maximum code length */ if ((unsigned) l > i) l = i; *m = l; @@ -379,7 +379,7 @@ huft_build (unsigned *b, /* code lengths in bits (all assumed <= BMAX) */ /* Adjust last length count to fill out codes, if needed */ for (y = 1 << j; j < i; j++, y <<= 1) if ((y -= c[j]) < 0) - return 2; /* bad input: more codes than bits */ + return 2; /* bad input: more codes than bits */ if ((y -= c[i]) < 0) return 2; c[i] += y; @@ -389,7 +389,7 @@ huft_build (unsigned *b, /* code lengths in bits (all assumed <= BMAX) */ p = c + 1; xp = x + 2; while (--i) - { /* note that i == g from above */ + { /* note that i == g from above */ *xp++ = (j += *p++); } @@ -399,105 +399,105 @@ huft_build (unsigned *b, /* code lengths in bits (all assumed <= BMAX) */ do { if ((j = *p++) != 0) - v[x[j]++] = i; + v[x[j]++] = i; } while (++i < n); /* Generate the Huffman codes and for each, make the table entries */ - x[0] = i = 0; /* first Huffman code is zero */ - p = v; /* grab values in bit order */ - h = -1; /* no tables yet--level -1 */ - w = -l; /* bits decoded == (l * h) */ - u[0] = (struct huft *) NULL; /* just to keep compilers happy */ - q = (struct huft *) NULL; /* ditto */ - z = 0; /* ditto */ + x[0] = i = 0; /* first Huffman code is zero */ + p = v; /* grab values in bit order */ + h = -1; /* no tables yet--level -1 */ + w = -l; /* bits decoded == (l * h) */ + u[0] = (struct huft *) NULL; /* just to keep compilers happy */ + q = (struct huft *) NULL; /* ditto */ + z = 0; /* ditto */ /* go through the bit lengths (k already is bits in shortest code) */ for (; k <= g; k++) { a = c[k]; while (a--) - { - /* here i is the Huffman code of length k bits for value *p */ - /* make tables up to required level */ - while (k > w + l) - { - h++; - w += l; /* previous table always l bits */ - - /* compute minimum size table less than or equal to l bits */ - z = (z = (unsigned) (g - w)) > (unsigned) l ? (unsigned) l : z; /* upper limit on table size */ - if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ - { /* too few codes for k-w bit table */ - f -= a + 1; /* deduct codes from patterns left */ - xp = c + k; - while (++j < z) /* try smaller tables up to z bits */ - { - if ((f <<= 1) <= *++xp) - break; /* enough codes to use up j bits */ - f -= *xp; /* else deduct codes from patterns */ - } - } - z = 1 << j; /* table entries for j-bit table */ - - /* allocate and link in new table */ - q = (struct huft *) AllocatePool ((z + 1) * sizeof (struct huft)); - if (! q) - { - if (h) - huft_free (u[0]); - return 3; - } - - *t = q + 1; /* link to list for huft_free() */ - *(t = &(q->v.t)) = (struct huft *) NULL; - u[h] = ++q; /* table starts after link */ - - /* connect to last table, if there is one */ - if (h) - { - x[h] = i; /* save pattern for backing up */ - r.b = (uch) l; /* bits to dump before this table */ - r.e = (uch) (16 + j); /* bits in this table */ - r.v.t = q; /* pointer to this table */ - j = i >> (w - l); /* (get around Turbo C bug) */ - u[h - 1][j] = r; /* connect to last table */ - } - } - - /* set up table entry in r */ - r.b = (uch) (k - w); - if (p >= v + n) - r.e = 99; /* out of values--invalid code */ - else if (*p < s) - { - r.e = (uch) (*p < 256 ? 16 : 15); /* 256 is end-of-block code */ - r.v.n = (ush) (*p); /* simple code is just the value */ - p++; /* one compiler does not like *p++ */ - } - else - { - r.e = (uch) e[*p - s]; /* non-simple--look up in lists */ - r.v.n = d[*p++ - s]; - } - - /* fill code-like entries with r */ - f = 1 << (k - w); - for (j = i >> w; j < z; j += f) - q[j] = r; - - /* backwards increment the k-bit code i */ - for (j = 1 << (k - 1); i & j; j >>= 1) - i ^= j; - i ^= j; - - /* backup over finished tables */ - while ((i & ((1 << w) - 1)) != x[h]) - { - h--; /* don't need to update q */ - w -= l; - } - } + { + /* here i is the Huffman code of length k bits for value *p */ + /* make tables up to required level */ + while (k > w + l) + { + h++; + w += l; /* previous table always l bits */ + + /* compute minimum size table less than or equal to l bits */ + z = (z = (unsigned) (g - w)) > (unsigned) l ? (unsigned) l : z; /* upper limit on table size */ + if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ + { /* too few codes for k-w bit table */ + f -= a + 1; /* deduct codes from patterns left */ + xp = c + k; + while (++j < z) /* try smaller tables up to z bits */ + { + if ((f <<= 1) <= *++xp) + break; /* enough codes to use up j bits */ + f -= *xp; /* else deduct codes from patterns */ + } + } + z = 1 << j; /* table entries for j-bit table */ + + /* allocate and link in new table */ + q = (struct huft *) AllocatePool ((z + 1) * sizeof (struct huft)); + if (! q) + { + if (h) + huft_free (u[0]); + return 3; + } + + *t = q + 1; /* link to list for huft_free() */ + *(t = &(q->v.t)) = (struct huft *) NULL; + u[h] = ++q; /* table starts after link */ + + /* connect to last table, if there is one */ + if (h) + { + x[h] = i; /* save pattern for backing up */ + r.b = (uch) l; /* bits to dump before this table */ + r.e = (uch) (16 + j); /* bits in this table */ + r.v.t = q; /* pointer to this table */ + j = i >> (w - l); /* (get around Turbo C bug) */ + u[h - 1][j] = r; /* connect to last table */ + } + } + + /* set up table entry in r */ + r.b = (uch) (k - w); + if (p >= v + n) + r.e = 99; /* out of values--invalid code */ + else if (*p < s) + { + r.e = (uch) (*p < 256 ? 16 : 15); /* 256 is end-of-block code */ + r.v.n = (ush) (*p); /* simple code is just the value */ + p++; /* one compiler does not like *p++ */ + } + else + { + r.e = (uch) e[*p - s]; /* non-simple--look up in lists */ + r.v.n = d[*p++ - s]; + } + + /* fill code-like entries with r */ + f = 1 << (k - w); + for (j = i >> w; j < z; j += f) + q[j] = r; + + /* backwards increment the k-bit code i */ + for (j = 1 << (k - 1); i & j; j >>= 1) + i ^= j; + i ^= j; + + /* backup over finished tables */ + while ((i & ((1 << w) - 1)) != x[h]) + { + h--; /* don't need to update q */ + w -= l; + } + } } /* Return true (1) if we were given an incomplete table */ @@ -534,129 +534,129 @@ huft_free (struct huft *t) static int inflate_codes_in_window (grub_gzio_t gzio) { - register unsigned e; /* table entry flag/number of extra bits */ - unsigned n, d; /* length and index for copy */ - unsigned w; /* current window position */ - struct huft *t; /* pointer to table entry */ - unsigned ml, md; /* masks for bl and bd bits */ - register ulg b; /* bit buffer */ - register unsigned k; /* number of bits in bit buffer */ + register unsigned e; /* table entry flag/number of extra bits */ + unsigned n, d; /* length and index for copy */ + unsigned w; /* current window position */ + struct huft *t; /* pointer to table entry */ + unsigned ml, md; /* masks for bl and bd bits */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ /* make local copies of globals */ d = gzio->inflate_d; n = gzio->inflate_n; - b = gzio->bb; /* initialize bit buffer */ + b = gzio->bb; /* initialize bit buffer */ k = gzio->bk; - w = gzio->wp; /* initialize window position */ + w = gzio->wp; /* initialize window position */ /* inflate the coded data */ - ml = mask_bits[gzio->bl]; /* precompute masks for speed */ + ml = mask_bits[gzio->bl]; /* precompute masks for speed */ md = mask_bits[gzio->bd]; - for (;;) /* do until end of block */ + for (;;) /* do until end of block */ { if (! gzio->code_state) - { - NEEDBITS ((unsigned) gzio->bl); - if ((e = (t = gzio->tl + ((unsigned) b & ml))->e) > 16) - do - { - if (e == 99) - { - gzio->err = -1; - return 1; - } - DUMPBITS (t->b); - e -= 16; - NEEDBITS (e); - } - while ((e = (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16); - DUMPBITS (t->b); - - if (e == 16) /* then it's a literal */ - { - gzio->slide[w++] = (uch) t->v.n; - if (w == WSIZE) - break; - } - else - /* it's an EOB or a length */ - { - /* exit if end of block */ - if (e == 15) - { - gzio->block_len = 0; - break; - } - - /* get length of block to copy */ - NEEDBITS (e); - n = t->v.n + ((unsigned) b & mask_bits[e]); - DUMPBITS (e); - - /* decode distance of block to copy */ - NEEDBITS ((unsigned) gzio->bd); - if ((e = (t = gzio->td + ((unsigned) b & md))->e) > 16) - do - { - if (e == 99) - { - gzio->err = -1; - return 1; - } - DUMPBITS (t->b); - e -= 16; - NEEDBITS (e); - } - while ((e = (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) - > 16); - DUMPBITS (t->b); - NEEDBITS (e); - d = w - t->v.n - ((unsigned) b & mask_bits[e]); - DUMPBITS (e); - gzio->code_state++; - } - } + { + NEEDBITS ((unsigned) gzio->bl); + if ((e = (t = gzio->tl + ((unsigned) b & ml))->e) > 16) + do + { + if (e == 99) + { + gzio->err = -1; + return 1; + } + DUMPBITS (t->b); + e -= 16; + NEEDBITS (e); + } + while ((e = (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16); + DUMPBITS (t->b); + + if (e == 16) /* then it's a literal */ + { + gzio->slide[w++] = (uch) t->v.n; + if (w == WSIZE) + break; + } + else + /* it's an EOB or a length */ + { + /* exit if end of block */ + if (e == 15) + { + gzio->block_len = 0; + break; + } + + /* get length of block to copy */ + NEEDBITS (e); + n = t->v.n + ((unsigned) b & mask_bits[e]); + DUMPBITS (e); + + /* decode distance of block to copy */ + NEEDBITS ((unsigned) gzio->bd); + if ((e = (t = gzio->td + ((unsigned) b & md))->e) > 16) + do + { + if (e == 99) + { + gzio->err = -1; + return 1; + } + DUMPBITS (t->b); + e -= 16; + NEEDBITS (e); + } + while ((e = (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) + > 16); + DUMPBITS (t->b); + NEEDBITS (e); + d = w - t->v.n - ((unsigned) b & mask_bits[e]); + DUMPBITS (e); + gzio->code_state++; + } + } if (gzio->code_state) - { - /* do the copy */ - do - { - n -= (e = (e = WSIZE - ((d &= WSIZE - 1) > w ? d : w)) > n ? n - : e); - - if (w - d >= e) - { - fsw_memcpy (gzio->slide + w, gzio->slide + d, e); - w += e; - d += e; - } - else - /* purposefully use the overlap for extra copies here!! */ - { - while (e--) - gzio->slide[w++] = gzio->slide[d++]; - } - - if (w == WSIZE) - break; - } - while (n); - - if (! n) - gzio->code_state--; - - /* did we break from the loop too soon? */ - if (w == WSIZE) - break; - } + { + /* do the copy */ + do + { + n -= (e = (e = WSIZE - ((d &= WSIZE - 1) > w ? d : w)) > n ? n + : e); + + if (w - d >= e) + { + fsw_memcpy (gzio->slide + w, gzio->slide + d, e); + w += e; + d += e; + } + else + /* purposefully use the overlap for extra copies here!! */ + { + while (e--) + gzio->slide[w++] = gzio->slide[d++]; + } + + if (w == WSIZE) + break; + } + while (n); + + if (! n) + gzio->code_state--; + + /* did we break from the loop too soon? */ + if (w == WSIZE) + break; + } } /* restore the globals from the locals */ gzio->inflate_d = d; gzio->inflate_n = n; - gzio->wp = w; /* restore global window pointer */ - gzio->bb = b; /* restore global bit buffer */ + gzio->wp = w; /* restore global window pointer */ + gzio->bb = b; /* restore global bit buffer */ gzio->bk = k; return ! gzio->block_len; @@ -668,11 +668,11 @@ inflate_codes_in_window (grub_gzio_t gzio) static void init_stored_block (grub_gzio_t gzio) { - register ulg b; /* bit buffer */ - register unsigned k; /* number of bits in bit buffer */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ /* make local copies of globals */ - b = gzio->bb; /* initialize bit buffer */ + b = gzio->bb; /* initialize bit buffer */ k = gzio->bk; /* go to byte boundary */ @@ -700,8 +700,8 @@ init_stored_block (grub_gzio_t gzio) static void init_fixed_block (grub_gzio_t gzio) { - int i; /* temporary variable */ - unsigned l[288]; /* length list for huft_build */ + int i; /* temporary variable */ + unsigned l[288]; /* length list for huft_build */ /* set up literal table */ for (i = 0; i < 144; i++) @@ -710,22 +710,22 @@ init_fixed_block (grub_gzio_t gzio) l[i] = 9; for (; i < 280; i++) l[i] = 7; - for (; i < 288; i++) /* make a complete, but wrong code set */ + for (; i < 288; i++) /* make a complete, but wrong code set */ l[i] = 8; gzio->bl = 7; if (huft_build (l, 288, 257, cplens, cplext, &gzio->tl, &gzio->bl) != 0) { - gzio->err = -1; + gzio->err = -1; return; } /* set up distance table */ - for (i = 0; i < 30; i++) /* make an incomplete code set */ + for (i = 0; i < 30; i++) /* make an incomplete code set */ l[i] = 5; gzio->bd = 5; if (huft_build (l, 30, 0, cpdist, cpdext, &gzio->td, &gzio->bd) > 1) { - gzio->err = -1; + gzio->err = -1; huft_free (gzio->tl); gzio->tl = 0; return; @@ -742,17 +742,17 @@ init_fixed_block (grub_gzio_t gzio) static void init_dynamic_block (grub_gzio_t gzio) { - int i; /* temporary variables */ + int i; /* temporary variables */ unsigned j; - unsigned l; /* last length */ - unsigned m; /* mask for bit lengths table */ - unsigned n; /* number of lengths to get */ - unsigned nb; /* number of bit length codes */ - unsigned nl; /* number of literal/length codes */ - unsigned nd; /* number of distance codes */ - unsigned ll[286 + 30]; /* literal/length and distance code lengths */ - register ulg b; /* bit buffer */ - register unsigned k; /* number of bits in bit buffer */ + unsigned l; /* last length */ + unsigned m; /* mask for bit lengths table */ + unsigned n; /* number of lengths to get */ + unsigned nb; /* number of bit length codes */ + unsigned nl; /* number of literal/length codes */ + unsigned nd; /* number of distance codes */ + unsigned ll[286 + 30]; /* literal/length and distance code lengths */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ /* make local bit buffer */ b = gzio->bb; @@ -760,13 +760,13 @@ init_dynamic_block (grub_gzio_t gzio) /* read in table lengths */ NEEDBITS (5); - nl = 257 + ((unsigned) b & 0x1f); /* number of literal/length codes */ + nl = 257 + ((unsigned) b & 0x1f); /* number of literal/length codes */ DUMPBITS (5); NEEDBITS (5); - nd = 1 + ((unsigned) b & 0x1f); /* number of distance codes */ + nd = 1 + ((unsigned) b & 0x1f); /* number of distance codes */ DUMPBITS (5); NEEDBITS (4); - nb = 4 + ((unsigned) b & 0xf); /* number of bit length codes */ + nb = 4 + ((unsigned) b & 0xf); /* number of bit length codes */ DUMPBITS (4); if (nl > 286 || nd > 30) { @@ -802,50 +802,50 @@ init_dynamic_block (grub_gzio_t gzio) j = (gzio->td = gzio->tl + ((unsigned) b & m))->b; DUMPBITS (j); j = gzio->td->v.n; - if (j < 16) /* length of code in bits (0..15) */ - ll[i++] = l = j; /* save last length in l */ - else if (j == 16) /* repeat last length 3 to 6 times */ - { - NEEDBITS (2); - j = 3 + ((unsigned) b & 3); - DUMPBITS (2); - if ((unsigned) i + j > n) - { - gzio->err = -1; - return; - } - while (j--) - ll[i++] = l; - } - else if (j == 17) /* 3 to 10 zero length codes */ - { - NEEDBITS (3); - j = 3 + ((unsigned) b & 7); - DUMPBITS (3); - if ((unsigned) i + j > n) - { - gzio->err = -1; - return; - } - while (j--) - ll[i++] = 0; - l = 0; - } + if (j < 16) /* length of code in bits (0..15) */ + ll[i++] = l = j; /* save last length in l */ + else if (j == 16) /* repeat last length 3 to 6 times */ + { + NEEDBITS (2); + j = 3 + ((unsigned) b & 3); + DUMPBITS (2); + if ((unsigned) i + j > n) + { + gzio->err = -1; + return; + } + while (j--) + ll[i++] = l; + } + else if (j == 17) /* 3 to 10 zero length codes */ + { + NEEDBITS (3); + j = 3 + ((unsigned) b & 7); + DUMPBITS (3); + if ((unsigned) i + j > n) + { + gzio->err = -1; + return; + } + while (j--) + ll[i++] = 0; + l = 0; + } else - /* j == 18: 11 to 138 zero length codes */ - { - NEEDBITS (7); - j = 11 + ((unsigned) b & 0x7f); - DUMPBITS (7); - if ((unsigned) i + j > n) - { - gzio->err = -1; - return; - } - while (j--) - ll[i++] = 0; - l = 0; - } + /* j == 18: 11 to 138 zero length codes */ + { + NEEDBITS (7); + j = 11 + ((unsigned) b & 0x7f); + DUMPBITS (7); + if ((unsigned) i + j > n) + { + gzio->err = -1; + return; + } + while (j--) + ll[i++] = 0; + l = 0; + } } /* free decoding table for trees */ @@ -882,8 +882,8 @@ init_dynamic_block (grub_gzio_t gzio) static void get_new_block (grub_gzio_t gzio) { - register ulg b; /* bit buffer */ - register unsigned k; /* number of bits in bit buffer */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ /* make local bit buffer */ b = gzio->bb; @@ -933,52 +933,52 @@ inflate_window (grub_gzio_t gzio) while (gzio->wp < WSIZE && !gzio->err) { if (! gzio->block_len) - { - if (gzio->last_block) - break; + { + if (gzio->last_block) + break; - get_new_block (gzio); - } + get_new_block (gzio); + } if (gzio->block_type > INFLATE_DYNAMIC) - gzio->err = -1; + gzio->err = -1; if (gzio->err) - return; + return; /* * Expand stored block here. */ if (gzio->block_type == INFLATE_STORED) - { - int w = gzio->wp; + { + int w = gzio->wp; - /* - * This is basically a glorified pass-through - */ + /* + * This is basically a glorified pass-through + */ - while (gzio->block_len && w < WSIZE && !gzio->err) - { - gzio->slide[w++] = get_byte (gzio); - gzio->block_len--; - } + while (gzio->block_len && w < WSIZE && !gzio->err) + { + gzio->slide[w++] = get_byte (gzio); + gzio->block_len--; + } - gzio->wp = w; + gzio->wp = w; - continue; - } + continue; + } /* * Expand other kind of block. */ if (inflate_codes_in_window (gzio)) - { - huft_free (gzio->tl); - huft_free (gzio->td); - gzio->tl = 0; - gzio->td = 0; - } + { + huft_free (gzio->tl); + huft_free (gzio->td); + gzio->tl = 0; + gzio->td = 0; + } } gzio->saved_offset += WSIZE; @@ -1040,7 +1040,7 @@ test_zlib_header (grub_gzio_t gzio) static grub_ssize_t grub_gzio_read_real (grub_gzio_t gzio, grub_off_t offset, - char *buf, grub_size_t len) + char *buf, grub_size_t len) { grub_ssize_t ret = 0; @@ -1060,12 +1060,12 @@ grub_gzio_read_real (grub_gzio_t gzio, grub_off_t offset, register char *srcaddr; while (offset >= gzio->saved_offset) - inflate_window (gzio); + inflate_window (gzio); srcaddr = (char *) ((offset & (WSIZE - 1)) + gzio->slide); size = gzio->saved_offset - offset; if (size > len) - size = len; + size = len; fsw_memcpy (buf, srcaddr, size); @@ -1083,7 +1083,7 @@ grub_gzio_read_real (grub_gzio_t gzio, grub_off_t offset, grub_ssize_t grub_zlib_decompress (char *inbuf, grub_size_t insize, grub_off_t off, - char *outbuf, grub_size_t outsize) + char *outbuf, grub_size_t outsize) { grub_gzio_t gzio = 0; grub_ssize_t ret;