rufus-3.13.tar.gz: .../bled/decompress_gunzip.c

"Fossies" - the Fresh Open Source Software Archive

Member "rufus-3.13/src/bled/decompress_gunzip.c" (20 Nov 2020, 36109 Bytes) of package /linux/misc/rufus-3.13.tar.gz:

As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "decompress_gunzip.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report:

3.12_vs_3.13.

1 /* vi: set sw=4 ts=4: */ 2 /* 3 * gunzip implementation for busybox 4 * 5 * Based on GNU gzip v1.2.4 Copyright (C) 1992-1993 Jean-loup Gailly. 6 * 7 * Originally adjusted for busybox by Sven Rudolph <sr1@inf.tu-dresden.de> 8 * based on gzip sources 9 * 10 * Adjusted further by Erik Andersen <andersen@codepoet.org> to support 11 * files as well as stdin/stdout, and to generally behave itself wrt 12 * command line handling. 13 * 14 * General cleanup to better adhere to the style guide and make use of standard 15 * busybox functions by Glenn McGrath 16 * 17 * read_gz interface + associated hacking by Laurence Anderson 18 * 19 * Fixed huft_build() so decoding end-of-block code does not grab more bits 20 * than necessary (this is required by unzip applet), added inflate_cleanup() 21 * to free leaked bytebuffer memory (used in unzip.c), and some minor style 22 * guide cleanups by Ed Clark 23 * 24 * gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface 25 * Copyright (C) 1992-1993 Jean-loup Gailly 26 * The unzip code was written and put in the public domain by Mark Adler. 27 * Portions of the lzw code are derived from the public domain 'compress' 28 * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies, 29 * Ken Turkowski, Dave Mack and Peter Jannesen. 30 * 31 * See the file algorithm.doc for the compression algorithms and file formats. 32 * 33 * Licensed under GPLv2 or later, see file LICENSE in this source tree. 34 */ 35 36 #include <setjmp.h> 37 #include "libbb.h" 38 #include "bb_archive.h" 39 40 typedef struct huft_t { 41 unsigned char e; /* number of extra bits or operation */ 42 unsigned char b; /* number of bits in this code or subcode */ 43 union { 44 unsigned short n; /* literal, length base, or distance base */ 45 struct huft_t *t; /* pointer to next level of table */ 46 } v; 47 } huft_t; 48 49 enum { 50 /* gunzip_window size--must be a power of two, and 51 * at least 32K for zip's deflate method */ 52 GUNZIP_WSIZE = BB_BUFSIZE, 53 /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */ 54 BMAX = 16, /* maximum bit length of any code (16 for explode) */ 55 N_MAX = 288, /* maximum number of codes in any set */ 56 }; 57 58 59 /* This is somewhat complex-looking arrangement, but it allows 60 * to place decompressor state either in bss or in 61 * malloc'ed space simply by changing #defines below. 62 * Sizes on i386: 63 * text data bss dec hex 64 * 5256 0 108 5364 14f4 - bss 65 * 4915 0 0 4915 1333 - malloc 66 */ 67 #define STATE_IN_BSS 0 68 #define STATE_IN_MALLOC 1 69 70 71 typedef struct state_t { 72 off_t gunzip_bytes_out; /* number of output bytes */ 73 uint32_t gunzip_crc; 74 75 int gunzip_src_fd; 76 unsigned gunzip_outbuf_count; /* bytes in output buffer */ 77 78 unsigned char *gunzip_window; 79 80 uint32_t *gunzip_crc_table; 81 82 /* bitbuffer */ 83 unsigned gunzip_bb; /* bit buffer */ 84 unsigned char gunzip_bk; /* bits in bit buffer */ 85 86 /* input (compressed) data */ 87 unsigned char *bytebuffer; /* buffer itself */ 88 off_t to_read; /* compressed bytes to read (unzip only, -1 for gunzip) */ 89 // unsigned bytebuffer_max; /* buffer size */ 90 unsigned bytebuffer_offset; /* buffer position */ 91 unsigned bytebuffer_size; /* how much data is there (size <= max) */ 92 93 /* private data of inflate_codes() */ 94 unsigned inflate_codes_ml; /* masks for bl and bd bits */ 95 unsigned inflate_codes_md; /* masks for bl and bd bits */ 96 unsigned inflate_codes_bb; /* bit buffer */ 97 unsigned inflate_codes_k; /* number of bits in bit buffer */ 98 unsigned inflate_codes_w; /* current gunzip_window position */ 99 huft_t *inflate_codes_tl; 100 huft_t *inflate_codes_td; 101 unsigned inflate_codes_bl; 102 unsigned inflate_codes_bd; 103 unsigned inflate_codes_nn; /* length and index for copy */ 104 unsigned inflate_codes_dd; 105 106 smallint resume_copy; 107 108 /* private data of inflate_get_next_window() */ 109 smallint method; /* method == -1 for stored, -2 for codes */ 110 smallint need_another_block; 111 smallint end_reached; 112 113 /* private data of inflate_stored() */ 114 unsigned inflate_stored_n; 115 unsigned inflate_stored_b; 116 unsigned inflate_stored_k; 117 unsigned inflate_stored_w; 118 119 const char *error_msg; 120 jmp_buf error_jmp; 121 } state_t; 122 #define gunzip_bytes_out (S()gunzip_bytes_out ) 123 #define gunzip_crc (S()gunzip_crc ) 124 #define gunzip_src_fd (S()gunzip_src_fd ) 125 #define gunzip_outbuf_count (S()gunzip_outbuf_count) 126 #define gunzip_window (S()gunzip_window ) 127 #define gunzip_crc_table (S()gunzip_crc_table ) 128 #define gunzip_bb (S()gunzip_bb ) 129 #define gunzip_bk (S()gunzip_bk ) 130 #define to_read (S()to_read ) 131 #define bytebuffer_max BB_BUFSIZE 132 #define bytebuffer (S()bytebuffer ) 133 #define bytebuffer_offset (S()bytebuffer_offset ) 134 #define bytebuffer_size (S()bytebuffer_size ) 135 #define inflate_codes_ml (S()inflate_codes_ml ) 136 #define inflate_codes_md (S()inflate_codes_md ) 137 #define inflate_codes_bb (S()inflate_codes_bb ) 138 #define inflate_codes_k (S()inflate_codes_k ) 139 #define inflate_codes_w (S()inflate_codes_w ) 140 #define inflate_codes_tl (S()inflate_codes_tl ) 141 #define inflate_codes_td (S()inflate_codes_td ) 142 #define inflate_codes_bl (S()inflate_codes_bl ) 143 #define inflate_codes_bd (S()inflate_codes_bd ) 144 #define inflate_codes_nn (S()inflate_codes_nn ) 145 #define inflate_codes_dd (S()inflate_codes_dd ) 146 #define resume_copy (S()resume_copy ) 147 #define method (S()method ) 148 #define need_another_block (S()need_another_block ) 149 #define end_reached (S()end_reached ) 150 #define inflate_stored_n (S()inflate_stored_n ) 151 #define inflate_stored_b (S()inflate_stored_b ) 152 #define inflate_stored_k (S()inflate_stored_k ) 153 #define inflate_stored_w (S()inflate_stored_w ) 154 #define error_msg (S()error_msg ) 155 #define error_jmp (S()error_jmp ) 156 157 /* This is a generic part */ 158 #if STATE_IN_BSS /* Use global data segment */ 159 #define DECLARE_STATE /*nothing*/ 160 #define ALLOC_STATE /*nothing*/ 161 #define DEALLOC_STATE ((void)0) 162 #define S() state. 163 #define PASS_STATE /*nothing*/ 164 #define PASS_STATE_ONLY /*nothing*/ 165 #define STATE_PARAM /*nothing*/ 166 #define STATE_PARAM_ONLY void 167 static state_t state; 168 #endif 169 170 #if STATE_IN_MALLOC /* Use malloc space */ 171 #define DECLARE_STATE state_t *state 172 #define ALLOC_STATE (state = xzalloc(sizeof(*state))) 173 #define DEALLOC_STATE free(state) 174 #define S() state-> 175 #define PASS_STATE state, 176 #define PASS_STATE_ONLY state 177 #define STATE_PARAM state_t *state, 178 #define STATE_PARAM_ONLY state_t *state 179 #endif 180 181 182 static const uint16_t mask_bits[] ALIGN2 = { 183 0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, 184 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff 185 }; 186 187 /* Copy lengths for literal codes 257..285 */ 188 static const uint16_t cplens[] ALIGN2 = { 189 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 190 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 191 }; 192 193 /* note: see note #13 above about the 258 in this list. */ 194 /* Extra bits for literal codes 257..285 */ 195 static const uint8_t cplext[] ALIGN1 = { 196 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, 197 5, 5, 5, 0, 99, 99 198 }; /* 99 == invalid */ 199 200 /* Copy offsets for distance codes 0..29 */ 201 static const uint16_t cpdist[] ALIGN2 = { 202 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 203 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 204 }; 205 206 /* Extra bits for distance codes */ 207 static const uint8_t cpdext[] ALIGN1 = { 208 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 209 11, 11, 12, 12, 13, 13 210 }; 211 212 /* Tables for deflate from PKZIP's appnote.txt. */ 213 /* Order of the bit length code lengths */ 214 static const uint8_t border[] ALIGN1 = { 215 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 216 }; 217 218 219 /* 220 * Free the malloc'ed tables built by huft_build(), which makes a linked 221 * list of the tables it made, with the links in a dummy first entry of 222 * each table. 223 * t: table to free 224 */ 225 static void huft_free(huft_t *p) 226 { 227 huft_t *q; 228 229 /* Go through linked list, freeing from the malloced (t[-1]) address. */ 230 while (p) { 231 q = (--p)->v.t; 232 free(p); 233 p = q; 234 } 235 } 236 237 static void huft_free_all(STATE_PARAM_ONLY) 238 { 239 huft_free(inflate_codes_tl); 240 huft_free(inflate_codes_td); 241 inflate_codes_tl = NULL; 242 inflate_codes_td = NULL; 243 } 244 245 static void abort_unzip(STATE_PARAM_ONLY) NORETURN; 246 static void abort_unzip(STATE_PARAM_ONLY) 247 { 248 huft_free_all(PASS_STATE_ONLY); 249 longjmp(error_jmp, 1); 250 } 251 252 static unsigned fill_bitbuffer(STATE_PARAM unsigned bitbuffer, unsigned *current, const unsigned required) 253 { 254 while (*current < required) { 255 if (bytebuffer_offset >= bytebuffer_size) { 256 unsigned sz = bytebuffer_max - 4; 257 if (to_read >= 0 && to_read < sz) /* unzip only */ 258 sz = (unsigned)to_read; 259 /* Leave the first 4 bytes empty so we can always unwind the bitbuffer 260 * to the front of the bytebuffer */ 261 bytebuffer_size = safe_read(gunzip_src_fd, &bytebuffer[4], sz); 262 if ((int)bytebuffer_size < 1) { 263 error_msg = "unexpected end of file"; 264 abort_unzip(PASS_STATE_ONLY); 265 } 266 if (to_read >= 0) /* unzip only */ 267 to_read -= bytebuffer_size; 268 bytebuffer_size += 4; 269 bytebuffer_offset = 4; 270 } 271 bitbuffer |= ((unsigned) bytebuffer[bytebuffer_offset]) << *current; 272 bytebuffer_offset++; 273 *current += 8; 274 } 275 return bitbuffer; 276 } 277 278 279 /* Given a list of code lengths and a maximum table size, make a set of 280 * tables to decode that set of codes. Return zero on success, one if 281 * the given code set is incomplete (the tables are still built in this 282 * case), two if the input is invalid (all zero length codes or an 283 * oversubscribed set of lengths) - in this case stores NULL in *t. 284 * 285 * b: code lengths in bits (all assumed <= BMAX) 286 * n: number of codes (assumed <= N_MAX) 287 * s: number of simple-valued codes (0..s-1) 288 * d: list of base values for non-simple codes 289 * e: list of extra bits for non-simple codes 290 * t: result: starting table 291 * m: maximum lookup bits, returns actual 292 */ 293 static int huft_build(const unsigned *b, const unsigned n, 294 const unsigned s, const unsigned short *d, 295 const unsigned char *e, huft_t **t, unsigned *m) 296 { 297 unsigned a; /* counter for codes of length k */ 298 unsigned c[BMAX + 1]; /* bit length count table */ 299 unsigned eob_len; /* length of end-of-block code (value 256) */ 300 unsigned f; /* i repeats in table every f entries */ 301 int g; /* maximum code length */ 302 int htl; /* table level */ 303 unsigned i; /* counter, current code */ 304 unsigned j; /* counter */ 305 int k; /* number of bits in current code */ 306 unsigned *p; /* pointer into c[], b[], or v[] */ 307 huft_t *q; /* points to current table */ 308 huft_t r; /* table entry for structure assignment */ 309 huft_t *u[BMAX]; /* table stack */ 310 unsigned v[N_MAX]; /* values in order of bit length */ 311 int ws[BMAX + 1]; /* bits decoded stack */ 312 int w; /* bits decoded */ 313 unsigned x[BMAX + 1]; /* bit offsets, then code stack */ 314 unsigned *xp; /* pointer into x */ 315 int y; /* number of dummy codes added */ 316 unsigned z; /* number of entries in current table */ 317 318 /* Length of EOB code, if any */ 319 eob_len = n > 256 ? b[256] : BMAX; 320 321 *t = NULL; 322 323 /* Generate counts for each bit length */ 324 memset(c, 0, sizeof(c)); 325 p = (unsigned *) b; /* cast allows us to reuse p for pointing to b */ 326 i = n; 327 do { 328 c[*p]++; /* assume all entries <= BMAX */ 329 p++; /* can't combine with above line (Solaris bug) */ 330 } while (--i); 331 if (c[0] == n) { /* null input - all zero length codes */ 332 *m = 0; 333 return 2; 334 } 335 336 /* Find minimum and maximum length, bound *m by those */ 337 for (j = 1; (j <= BMAX) && (c[j] == 0); j++) 338 continue; 339 k = j; /* minimum code length */ 340 for (i = BMAX; (c[i] == 0) && i; i--) 341 continue; 342 g = i; /* maximum code length */ 343 *m = (*m < j) ? j : ((*m > i) ? i : *m); 344 345 /* Adjust last length count to fill out codes, if needed */ 346 for (y = 1 << j; j < i; j++, y <<= 1) { 347 y -= c[j]; 348 if (y < 0) 349 return 2; /* bad input: more codes than bits */ 350 } 351 y -= c[i]; 352 if (y < 0) 353 return 2; 354 c[i] += y; 355 356 /* Generate starting offsets into the value table for each length */ 357 x[1] = j = 0; 358 p = c + 1; 359 xp = x + 2; 360 while (--i) { /* note that i == g from above */ 361 j += *p++; 362 *xp++ = j; 363 } 364 365 /* Make a table of values in order of bit lengths */ 366 p = (unsigned *) b; 367 i = 0; 368 do { 369 j = *p++; 370 if (j != 0) { 371 v[x[j]++] = i; 372 } 373 } while (++i < n); 374 375 /* Generate the Huffman codes and for each, make the table entries */ 376 x[0] = i = 0; /* first Huffman code is zero */ 377 p = v; /* grab values in bit order */ 378 htl = -1; /* no tables yet--level -1 */ 379 w = ws[0] = 0; /* bits decoded */ 380 u[0] = NULL; /* just to keep compilers happy */ 381 q = NULL; /* ditto */ 382 z = 0; /* ditto */ 383 384 /* go through the bit lengths (k already is bits in shortest code) */ 385 for (; k <= g; k++) { 386 a = c[k]; 387 while (a--) { 388 /* here i is the Huffman code of length k bits for value *p */ 389 /* make tables up to required level */ 390 while (k > ws[htl + 1]) { 391 w = ws[++htl]; 392 393 /* compute minimum size table less than or equal to *m bits */ 394 z = g - w; 395 z = z > *m ? *m : z; /* upper limit on table size */ 396 j = k - w; 397 f = 1 << j; 398 if (f > a + 1) { /* try a k-w bit table */ 399 /* too few codes for k-w bit table */ 400 f -= a + 1; /* deduct codes from patterns left */ 401 xp = c + k; 402 while (++j < z) { /* try smaller tables up to z bits */ 403 f <<= 1; 404 if (f <= *++xp) { 405 break; /* enough codes to use up j bits */ 406 } 407 f -= *xp; /* else deduct codes from patterns */ 408 } 409 } 410 j = ((w + j) > (int)eob_len && w < (int)eob_len) ? eob_len - w : j; /* make EOB code end at table */ 411 z = 1 << j; /* table entries for j-bit table */ 412 ws[htl+1] = w + j; /* set bits decoded in stack */ 413 414 /* allocate and link in new table */ 415 q = xzalloc((z + 1) * sizeof(huft_t)); 416 *t = q + 1; /* link to list for huft_free() */ 417 t = &(q->v.t); 418 u[htl] = ++q; /* table starts after link */ 419 420 /* connect to last table, if there is one */ 421 if (htl) { 422 x[htl] = i; /* save pattern for backing up */ 423 r.b = (unsigned char) (w - ws[htl - 1]); /* bits to dump before this table */ 424 r.e = (unsigned char) (16 + j); /* bits in this table */ 425 r.v.t = q; /* pointer to this table */ 426 j = (i & ((1 << w) - 1)) >> ws[htl - 1]; 427 u[htl - 1][j] = r; /* connect to last table */ 428 } 429 } 430 431 /* set up table entry in r */ 432 r.b = (unsigned char) (k - w); 433 if (p >= v + n) { 434 r.e = 99; /* out of values--invalid code */ 435 } else if (*p < s) { 436 r.e = (unsigned char) (*p < 256 ? 16 : 15); /* 256 is EOB code */ 437 r.v.n = (unsigned short) (*p++); /* simple code is just the value */ 438 } else { 439 r.e = (unsigned char) e[*p - s]; /* non-simple--look up in lists */ 440 r.v.n = d[*p++ - s]; 441 } 442 443 /* fill code-like entries with r */ 444 f = 1 << (k - w); 445 for (j = i >> w; j < z; j += f) { 446 q[j] = r; 447 } 448 449 /* backwards increment the k-bit code i */ 450 for (j = 1 << (k - 1); i & j; j >>= 1) { 451 i ^= j; 452 } 453 i ^= j; 454 455 /* backup over finished tables */ 456 while ((i & ((1 << w) - 1)) != x[htl]) { 457 w = ws[--htl]; 458 } 459 } 460 } 461 462 /* return actual size of base table */ 463 *m = ws[1]; 464 465 /* Return 1 if we were given an incomplete table */ 466 return y != 0 && g != 1; 467 } 468 469 470 /* 471 * inflate (decompress) the codes in a deflated (compressed) block. 472 * Return an error code or zero if it all goes ok. 473 * 474 * tl, td: literal/length and distance decoder tables 475 * bl, bd: number of bits decoded by tl[] and td[] 476 */ 477 /* called once from inflate_block */ 478 479 /* map formerly local static variables to globals */ 480 #define ml inflate_codes_ml 481 #define md inflate_codes_md 482 #define bb inflate_codes_bb 483 #define k inflate_codes_k 484 #define w inflate_codes_w 485 #define tl inflate_codes_tl 486 #define td inflate_codes_td 487 #define bl inflate_codes_bl 488 #define bd inflate_codes_bd 489 #define nn inflate_codes_nn 490 #define dd inflate_codes_dd 491 static void inflate_codes_setup(STATE_PARAM unsigned my_bl, unsigned my_bd) 492 { 493 bl = my_bl; 494 bd = my_bd; 495 /* make local copies of globals */ 496 bb = gunzip_bb; /* initialize bit buffer */ 497 k = gunzip_bk; 498 w = gunzip_outbuf_count; /* initialize gunzip_window position */ 499 /* inflate the coded data */ 500 ml = mask_bits[bl]; /* precompute masks for speed */ 501 md = mask_bits[bd]; 502 } 503 /* called once from inflate_get_next_window */ 504 static NOINLINE int inflate_codes(STATE_PARAM_ONLY) 505 { 506 unsigned e; /* table entry flag/number of extra bits */ 507 huft_t *t; /* pointer to table entry */ 508 509 if (resume_copy) 510 goto do_copy; 511 512 while (1) { /* do until end of block */ 513 bb = fill_bitbuffer(PASS_STATE bb, &k, bl); 514 t = tl + ((unsigned) bb & ml); 515 e = t->e; 516 if (e > 16) 517 do { 518 if (e == 99) 519 abort_unzip(PASS_STATE_ONLY);; 520 bb >>= t->b; 521 k -= t->b; 522 e -= 16; 523 bb = fill_bitbuffer(PASS_STATE bb, &k, e); 524 t = t->v.t + ((unsigned) bb & mask_bits[e]); 525 e = t->e; 526 } while (e > 16); 527 bb >>= t->b; 528 k -= t->b; 529 if (e == 16) { /* then it's a literal */ 530 gunzip_window[w++] = (unsigned char) t->v.n; 531 if (w == GUNZIP_WSIZE) { 532 gunzip_outbuf_count = w; 533 //flush_gunzip_window(); 534 w = 0; 535 return 1; // We have a block to read 536 } 537 } else { /* it's an EOB or a length */ 538 /* exit if end of block */ 539 if (e == 15) { 540 break; 541 } 542 543 /* get length of block to copy */ 544 bb = fill_bitbuffer(PASS_STATE bb, &k, e); 545 nn = t->v.n + ((unsigned) bb & mask_bits[e]); 546 bb >>= e; 547 k -= e; 548 549 /* decode distance of block to copy */ 550 bb = fill_bitbuffer(PASS_STATE bb, &k, bd); 551 t = td + ((unsigned) bb & md); 552 e = t->e; 553 if (e > 16) 554 do { 555 if (e == 99) 556 abort_unzip(PASS_STATE_ONLY); 557 bb >>= t->b; 558 k -= t->b; 559 e -= 16; 560 bb = fill_bitbuffer(PASS_STATE bb, &k, e); 561 t = t->v.t + ((unsigned) bb & mask_bits[e]); 562 e = t->e; 563 } while (e > 16); 564 bb >>= t->b; 565 k -= t->b; 566 bb = fill_bitbuffer(PASS_STATE bb, &k, e); 567 dd = w - t->v.n - ((unsigned) bb & mask_bits[e]); 568 bb >>= e; 569 k -= e; 570 571 /* do the copy */ 572 do_copy: 573 do { 574 /* Was: nn -= (e = (e = GUNZIP_WSIZE - ((dd &= GUNZIP_WSIZE - 1) > w ? dd : w)) > nn ? nn : e); */ 575 /* Who wrote THAT?? rewritten as: */ 576 unsigned delta; 577 578 dd &= GUNZIP_WSIZE - 1; 579 e = GUNZIP_WSIZE - (dd > w ? dd : w); 580 delta = w > dd ? w - dd : dd - w; 581 if (e > nn) e = nn; 582 nn -= e; 583 584 /* copy to new buffer to prevent possible overwrite */ 585 if (delta >= e) { 586 memcpy(gunzip_window + w, gunzip_window + dd, e); 587 w += e; 588 dd += e; 589 } else { 590 /* do it slow to avoid memcpy() overlap */ 591 /* !NOMEMCPY */ 592 do { 593 gunzip_window[w++] = gunzip_window[dd++]; 594 } while (--e); 595 } 596 if (w == GUNZIP_WSIZE) { 597 gunzip_outbuf_count = w; 598 resume_copy = (nn != 0); 599 //flush_gunzip_window(); 600 w = 0; 601 return 1; 602 } 603 } while (nn); 604 resume_copy = 0; 605 } 606 } 607 608 /* restore the globals from the locals */ 609 gunzip_outbuf_count = w; /* restore global gunzip_window pointer */ 610 gunzip_bb = bb; /* restore global bit buffer */ 611 gunzip_bk = k; 612 613 /* normally just after call to inflate_codes, but save code by putting it here */ 614 /* free the decoding tables (tl and td), return */ 615 huft_free_all(PASS_STATE_ONLY); 616 617 /* done */ 618 return 0; 619 } 620 #undef ml 621 #undef md 622 #undef bb 623 #undef k 624 #undef w 625 #undef tl 626 #undef td 627 #undef bl 628 #undef bd 629 #undef nn 630 #undef dd 631 632 633 /* called once from inflate_block */ 634 static void inflate_stored_setup(STATE_PARAM int my_n, int my_b, int my_k) 635 { 636 inflate_stored_n = my_n; 637 inflate_stored_b = my_b; 638 inflate_stored_k = my_k; 639 /* initialize gunzip_window position */ 640 inflate_stored_w = gunzip_outbuf_count; 641 } 642 /* called once from inflate_get_next_window */ 643 static int inflate_stored(STATE_PARAM_ONLY) 644 { 645 /* read and output the compressed data */ 646 while (inflate_stored_n--) { 647 inflate_stored_b = fill_bitbuffer(PASS_STATE inflate_stored_b, &inflate_stored_k, 8); 648 gunzip_window[inflate_stored_w++] = (unsigned char) inflate_stored_b; 649 if (inflate_stored_w == GUNZIP_WSIZE) { 650 gunzip_outbuf_count = inflate_stored_w; 651 //flush_gunzip_window(); 652 inflate_stored_w = 0; 653 inflate_stored_b >>= 8; 654 inflate_stored_k -= 8; 655 return 1; /* We have a block */ 656 } 657 inflate_stored_b >>= 8; 658 inflate_stored_k -= 8; 659 } 660 661 /* restore the globals from the locals */ 662 gunzip_outbuf_count = inflate_stored_w; /* restore global gunzip_window pointer */ 663 gunzip_bb = inflate_stored_b; /* restore global bit buffer */ 664 gunzip_bk = inflate_stored_k; 665 return 0; /* Finished */ 666 } 667 668 669 /* 670 * decompress an inflated block 671 * e: last block flag 672 * 673 * GLOBAL VARIABLES: bb, kk, 674 */ 675 /* Return values: -1 = inflate_stored, -2 = inflate_codes */ 676 /* One callsite in inflate_get_next_window */ 677 static int inflate_block(STATE_PARAM smallint *e) 678 { 679 unsigned ll[286 + 30]; /* literal/length and distance code lengths */ 680 unsigned t; /* block type */ 681 unsigned b; /* bit buffer */ 682 unsigned k; /* number of bits in bit buffer */ 683 684 /* make local bit buffer */ 685 686 b = gunzip_bb; 687 k = gunzip_bk; 688 689 /* read in last block bit */ 690 b = fill_bitbuffer(PASS_STATE b, &k, 1); 691 *e = b & 1; 692 b >>= 1; 693 k -= 1; 694 695 /* read in block type */ 696 b = fill_bitbuffer(PASS_STATE b, &k, 2); 697 t = (unsigned) b & 3; 698 b >>= 2; 699 k -= 2; 700 701 /* restore the global bit buffer */ 702 gunzip_bb = b; 703 gunzip_bk = k; 704 705 /* Do we see block type 1 often? Yes! 706 * TODO: fix performance problem (see below) */ 707 //bb_error_msg("blktype %d", t); 708 709 /* inflate that block type */ 710 switch (t) { 711 case 0: /* Inflate stored */ 712 { 713 unsigned n; /* number of bytes in block */ 714 unsigned b_stored; /* bit buffer */ 715 unsigned k_stored; /* number of bits in bit buffer */ 716 717 /* make local copies of globals */ 718 b_stored = gunzip_bb; /* initialize bit buffer */ 719 k_stored = gunzip_bk; 720 721 /* go to byte boundary */ 722 n = k_stored & 7; 723 b_stored >>= n; 724 k_stored -= n; 725 726 /* get the length and its complement */ 727 b_stored = fill_bitbuffer(PASS_STATE b_stored, &k_stored, 16); 728 n = ((unsigned) b_stored & 0xffff); 729 b_stored >>= 16; 730 k_stored -= 16; 731 732 b_stored = fill_bitbuffer(PASS_STATE b_stored, &k_stored, 16); 733 if (n != (unsigned) ((~b_stored) & 0xffff)) { 734 abort_unzip(PASS_STATE_ONLY); /* error in compressed data */ 735 } 736 b_stored >>= 16; 737 k_stored -= 16; 738 739 inflate_stored_setup(PASS_STATE n, b_stored, k_stored); 740 741 return -1; 742 } 743 case 1: 744 /* Inflate fixed 745 * decompress an inflated type 1 (fixed Huffman codes) block. We should 746 * either replace this with a custom decoder, or at least precompute the 747 * Huffman tables. TODO */ 748 { 749 int i; /* temporary variable */ 750 unsigned bl; /* lookup bits for tl */ 751 unsigned bd; /* lookup bits for td */ 752 /* gcc 4.2.1 is too dumb to reuse stackspace. Moved up... */ 753 //unsigned ll[288]; /* length list for huft_build */ 754 755 /* set up literal table */ 756 for (i = 0; i < 144; i++) 757 ll[i] = 8; 758 for (; i < 256; i++) 759 ll[i] = 9; 760 for (; i < 280; i++) 761 ll[i] = 7; 762 for (; i < 288; i++) /* make a complete, but wrong code set */ 763 ll[i] = 8; 764 bl = 7; 765 huft_build(ll, 288, 257, cplens, cplext, &inflate_codes_tl, &bl); 766 /* huft_build() never return nonzero - we use known data */ 767 768 /* set up distance table */ 769 for (i = 0; i < 30; i++) /* make an incomplete code set */ 770 ll[i] = 5; 771 bd = 5; 772 huft_build(ll, 30, 0, cpdist, cpdext, &inflate_codes_td, &bd); 773 774 /* set up data for inflate_codes() */ 775 inflate_codes_setup(PASS_STATE bl, bd); 776 777 /* huft_free code moved into inflate_codes */ 778 779 return -2; 780 } 781 case 2: /* Inflate dynamic */ 782 { 783 enum { dbits = 6 }; /* bits in base distance lookup table */ 784 enum { lbits = 9 }; /* bits in base literal/length lookup table */ 785 786 huft_t *td; /* distance code table */ 787 unsigned i; /* temporary variables */ 788 unsigned j; 789 unsigned l; /* last length */ 790 unsigned m; /* mask for bit lengths table */ 791 unsigned n; /* number of lengths to get */ 792 unsigned bl; /* lookup bits for tl */ 793 unsigned bd; /* lookup bits for td */ 794 unsigned nb; /* number of bit length codes */ 795 unsigned nl; /* number of literal/length codes */ 796 unsigned nd; /* number of distance codes */ 797 798 //unsigned ll[286 + 30];/* literal/length and distance code lengths */ 799 unsigned b_dynamic; /* bit buffer */ 800 unsigned k_dynamic; /* number of bits in bit buffer */ 801 802 /* make local bit buffer */ 803 b_dynamic = gunzip_bb; 804 k_dynamic = gunzip_bk; 805 806 /* read in table lengths */ 807 b_dynamic = fill_bitbuffer(PASS_STATE b_dynamic, &k_dynamic, 5); 808 nl = 257 + ((unsigned) b_dynamic & 0x1f); /* number of literal/length codes */ 809 810 b_dynamic >>= 5; 811 k_dynamic -= 5; 812 b_dynamic = fill_bitbuffer(PASS_STATE b_dynamic, &k_dynamic, 5); 813 nd = 1 + ((unsigned) b_dynamic & 0x1f); /* number of distance codes */ 814 815 b_dynamic >>= 5; 816 k_dynamic -= 5; 817 b_dynamic = fill_bitbuffer(PASS_STATE b_dynamic, &k_dynamic, 4); 818 nb = 4 + ((unsigned) b_dynamic & 0xf); /* number of bit length codes */ 819 820 b_dynamic >>= 4; 821 k_dynamic -= 4; 822 if (nl > 286 || nd > 30) 823 abort_unzip(PASS_STATE_ONLY); /* bad lengths */ 824 825 /* read in bit-length-code lengths */ 826 for (j = 0; j < nb; j++) { 827 b_dynamic = fill_bitbuffer(PASS_STATE b_dynamic, &k_dynamic, 3); 828 ll[border[j]] = (unsigned) b_dynamic & 7; 829 b_dynamic >>= 3; 830 k_dynamic -= 3; 831 } 832 for (; j < 19; j++) 833 ll[border[j]] = 0; 834 835 /* build decoding table for trees - single level, 7 bit lookup */ 836 bl = 7; 837 i = huft_build(ll, 19, 19, NULL, NULL, &inflate_codes_tl, &bl); 838 if (i != 0) { 839 abort_unzip(PASS_STATE_ONLY); //return i; /* incomplete code set */ 840 } 841 842 /* read in literal and distance code lengths */ 843 n = nl + nd; 844 m = mask_bits[bl]; 845 i = l = 0; 846 while ((unsigned) i < n) { 847 b_dynamic = fill_bitbuffer(PASS_STATE b_dynamic, &k_dynamic, (unsigned)bl); 848 td = inflate_codes_tl + ((unsigned) b_dynamic & m); 849 j = td->b; 850 b_dynamic >>= j; 851 k_dynamic -= j; 852 j = td->v.n; 853 if (j < 16) { /* length of code in bits (0..15) */ 854 ll[i++] = l = j; /* save last length in l */ 855 } else if (j == 16) { /* repeat last length 3 to 6 times */ 856 b_dynamic = fill_bitbuffer(PASS_STATE b_dynamic, &k_dynamic, 2); 857 j = 3 + ((unsigned) b_dynamic & 3); 858 b_dynamic >>= 2; 859 k_dynamic -= 2; 860 if ((unsigned) i + j > n) { 861 abort_unzip(PASS_STATE_ONLY); //return 1; 862 } 863 while (j--) { 864 ll[i++] = l; 865 } 866 } else if (j == 17) { /* 3 to 10 zero length codes */ 867 b_dynamic = fill_bitbuffer(PASS_STATE b_dynamic, &k_dynamic, 3); 868 j = 3 + ((unsigned) b_dynamic & 7); 869 b_dynamic >>= 3; 870 k_dynamic -= 3; 871 if ((unsigned) i + j > n) { 872 abort_unzip(PASS_STATE_ONLY); //return 1; 873 } 874 while (j--) { 875 ll[i++] = 0; 876 } 877 l = 0; 878 } else { /* j == 18: 11 to 138 zero length codes */ 879 b_dynamic = fill_bitbuffer(PASS_STATE b_dynamic, &k_dynamic, 7); 880 j = 11 + ((unsigned) b_dynamic & 0x7f); 881 b_dynamic >>= 7; 882 k_dynamic -= 7; 883 if ((unsigned) i + j > n) { 884 abort_unzip(PASS_STATE_ONLY); //return 1; 885 } 886 while (j--) { 887 ll[i++] = 0; 888 } 889 l = 0; 890 } 891 } 892 893 /* free decoding table for trees */ 894 huft_free(inflate_codes_tl); 895 896 /* restore the global bit buffer */ 897 gunzip_bb = b_dynamic; 898 gunzip_bk = k_dynamic; 899 900 /* build the decoding tables for literal/length and distance codes */ 901 bl = lbits; 902 903 i = huft_build(ll, nl, 257, cplens, cplext, &inflate_codes_tl, &bl); 904 if (i != 0) 905 abort_unzip(PASS_STATE_ONLY); 906 bd = dbits; 907 i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &inflate_codes_td, &bd); 908 if (i != 0) 909 abort_unzip(PASS_STATE_ONLY); 910 911 /* set up data for inflate_codes() */ 912 inflate_codes_setup(PASS_STATE bl, bd); 913 914 /* huft_free code moved into inflate_codes */ 915 916 return -2; 917 } 918 default: 919 abort_unzip(PASS_STATE_ONLY); 920 return 0; 921 } 922 } 923 924 /* Two callsites, both in inflate_get_next_window */ 925 static void calculate_gunzip_crc(STATE_PARAM_ONLY) 926 { 927 gunzip_crc = crc32_block_endian0(gunzip_crc, gunzip_window, gunzip_outbuf_count, gunzip_crc_table); 928 gunzip_bytes_out += gunzip_outbuf_count; 929 } 930 931 /* One callsite in inflate_unzip_internal */ 932 static int inflate_get_next_window(STATE_PARAM_ONLY) 933 { 934 gunzip_outbuf_count = 0; 935 936 while (1) { 937 int ret = 0; 938 939 if (need_another_block) { 940 if (end_reached) { 941 calculate_gunzip_crc(PASS_STATE_ONLY); 942 end_reached = 0; 943 /* NB: need_another_block is still set */ 944 return 0; /* Last block */ 945 } 946 method = inflate_block(PASS_STATE &end_reached); 947 need_another_block = 0; 948 } 949 950 switch (method) { 951 case -1: 952 ret = inflate_stored(PASS_STATE_ONLY); 953 break; 954 case -2: 955 ret = inflate_codes(PASS_STATE_ONLY); 956 break; 957 default: /* cannot happen */ 958 abort_unzip(PASS_STATE_ONLY); 959 } 960 961 if (ret == 1) { 962 calculate_gunzip_crc(PASS_STATE_ONLY); 963 return 1; /* more data left */ 964 } 965 need_another_block = 1; /* end of that block */ 966 } 967 /* Doesnt get here */ 968 } 969 970 971 /* Called from unpack_gz_stream() and inflate_unzip() */ 972 static IF_DESKTOP(long long) int 973 inflate_unzip_internal(STATE_PARAM transformer_state_t *xstate) 974 { 975 IF_DESKTOP(long long) int n = 0; 976 ssize_t nwrote; 977 978 /* Allocate all global buffers (for DYN_ALLOC option) */ 979 gunzip_window = xmalloc(GUNZIP_WSIZE); 980 gunzip_outbuf_count = 0; 981 gunzip_bytes_out = 0; 982 gunzip_src_fd = xstate->src_fd; 983 984 /* (re) initialize state */ 985 method = -1; 986 need_another_block = 1; 987 resume_copy = 0; 988 gunzip_bk = 0; 989 gunzip_bb = 0; 990 991 /* Create the crc table */ 992 gunzip_crc_table = crc32_filltable(NULL, 0); 993 gunzip_crc = ~0; 994 995 error_msg = "corrupted data"; 996 if (setjmp(error_jmp)) { 997 /* Error from deep inside zip machinery */ 998 n = -1; 999 goto ret; 1000 } 1001 1002 while (1) { 1003 int r = inflate_get_next_window(PASS_STATE_ONLY); 1004 nwrote = transformer_write(xstate, gunzip_window, gunzip_outbuf_count); 1005 if (nwrote != (ssize_t)gunzip_outbuf_count) { 1006 huft_free_all(PASS_STATE_ONLY); 1007 n = (nwrote <0)?nwrote:-1; 1008 goto ret; 1009 } 1010 IF_DESKTOP(n += nwrote;) 1011 if (r == 0) break; 1012 } 1013 1014 /* Store unused bytes in a global buffer so calling applets can access it */ 1015 if (gunzip_bk >= 8) { 1016 /* Undo too much lookahead. The next read will be byte aligned 1017 * so we can discard unused bits in the last meaningful byte. */ 1018 bytebuffer_offset--; 1019 bytebuffer[bytebuffer_offset] = gunzip_bb & 0xff; 1020 gunzip_bb >>= 8; 1021 gunzip_bk -= 8; 1022 } 1023 ret: 1024 /* Cleanup */ 1025 free(gunzip_window); 1026 free(gunzip_crc_table); 1027 return n; 1028 } 1029 1030 1031 /* External entry points */ 1032 1033 /* For unzip */ 1034 1035 IF_DESKTOP(long long) int FAST_FUNC 1036 inflate_unzip(transformer_state_t *xstate) 1037 { 1038 IF_DESKTOP(long long) int n; 1039 DECLARE_STATE; 1040 1041 ALLOC_STATE; 1042 if (state == NULL) 1043 return -1; 1044 1045 to_read = xstate->bytes_in; 1046 // bytebuffer_max = 0x8000; 1047 bytebuffer_offset = 4; 1048 bytebuffer = xmalloc(bytebuffer_max); 1049 n = inflate_unzip_internal(PASS_STATE xstate); 1050 free(bytebuffer); 1051 1052 xstate->crc32 = gunzip_crc; 1053 xstate->bytes_out = gunzip_bytes_out; 1054 DEALLOC_STATE; 1055 return n; 1056 } 1057 1058 1059 /* For gunzip */ 1060 1061 /* helpers first */ 1062 1063 /* Top up the input buffer with at least n bytes. */ 1064 static int top_up(STATE_PARAM unsigned n) 1065 { 1066 int count = bytebuffer_size - bytebuffer_offset; 1067 1068 if (count < (int)n) { 1069 memmove(bytebuffer, &bytebuffer[bytebuffer_offset], count); 1070 bytebuffer_offset = 0; 1071 bytebuffer_size = full_read(gunzip_src_fd, &bytebuffer[count], bytebuffer_max - count); 1072 if ((int)bytebuffer_size < 0) { 1073 bb_error_msg(bb_msg_read_error); 1074 return 0; 1075 } 1076 bytebuffer_size += count; 1077 if (bytebuffer_size < n) 1078 return 0; 1079 } 1080 return 1; 1081 } 1082 1083 static uint16_t buffer_read_le_u16(STATE_PARAM_ONLY) 1084 { 1085 uint16_t res; 1086 #if BB_LITTLE_ENDIAN 1087 move_from_unaligned16(res, &bytebuffer[bytebuffer_offset]); 1088 #else 1089 res = bytebuffer[bytebuffer_offset]; 1090 res |= bytebuffer[bytebuffer_offset + 1] << 8; 1091 #endif 1092 bytebuffer_offset += 2; 1093 return res; 1094 } 1095 1096 static uint32_t buffer_read_le_u32(STATE_PARAM_ONLY) 1097 { 1098 uint32_t res; 1099 #if BB_LITTLE_ENDIAN 1100 move_from_unaligned32(res, &bytebuffer[bytebuffer_offset]); 1101 #else 1102 res = bytebuffer[bytebuffer_offset]; 1103 res |= bytebuffer[bytebuffer_offset + 1] << 8; 1104 res |= bytebuffer[bytebuffer_offset + 2] << 16; 1105 res |= bytebuffer[bytebuffer_offset + 3] << 24; 1106 #endif 1107 bytebuffer_offset += 4; 1108 return res; 1109 } 1110 1111 static int check_header_gzip(STATE_PARAM transformer_state_t *xstate) 1112 { 1113 PRAGMA_BEGIN_PACKED 1114 union { 1115 unsigned char raw[8]; 1116 struct { 1117 uint8_t gz_method; 1118 uint8_t flags; 1119 uint32_t mtime; 1120 uint8_t xtra_flags_UNUSED; 1121 uint8_t os_flags_UNUSED; 1122 } PACKED formatted; 1123 } header; 1124 PRAGMA_END_PACKED 1125 struct BUG_header { 1126 char BUG_header[sizeof(header) == 8 ? 1 : -1]; 1127 }; 1128 1129 /* 1130 * Rewind bytebuffer. We use the beginning because the header has 8 1131 * bytes, leaving enough for unwinding afterwards. 1132 */ 1133 bytebuffer_size -= bytebuffer_offset; 1134 memmove(bytebuffer, &bytebuffer[bytebuffer_offset], bytebuffer_size); 1135 bytebuffer_offset = 0; 1136 1137 if (!top_up(PASS_STATE 8)) 1138 return 0; 1139 memcpy(header.raw, &bytebuffer[bytebuffer_offset], 8); 1140 bytebuffer_offset += 8; 1141 1142 /* Check the compression method */ 1143 if (header.formatted.gz_method != 8) { 1144 return 0; 1145 } 1146 1147 if (header.formatted.flags & 0x04) { 1148 /* bit 2 set: extra field present */ 1149 unsigned extra_short; 1150 1151 if (!top_up(PASS_STATE 2)) 1152 return 0; 1153 extra_short = buffer_read_le_u16(PASS_STATE_ONLY); 1154 if (!top_up(PASS_STATE extra_short)) 1155 return 0; 1156 /* Ignore extra field */ 1157 bytebuffer_offset += extra_short; 1158 } 1159 1160 /* Discard original name and file comment if any */ 1161 /* bit 3 set: original file name present */ 1162 /* bit 4 set: file comment present */ 1163 if (header.formatted.flags & 0x18) { 1164 while (1) { 1165 do { 1166 if (!top_up(PASS_STATE 1)) 1167 return 0; 1168 } while (bytebuffer[bytebuffer_offset++] != 0); 1169 if ((header.formatted.flags & 0x18) != 0x18) 1170 break; 1171 header.formatted.flags &= ~0x18; 1172 } 1173 } 1174 1175 xstate->mtime = SWAP_LE32(header.formatted.mtime); 1176 1177 /* Read the header checksum */ 1178 if (header.formatted.flags & 0x02) { 1179 if (!top_up(PASS_STATE 2)) 1180 return 0; 1181 bytebuffer_offset += 2; 1182 } 1183 return 1; 1184 } 1185 1186 IF_DESKTOP(long long) int FAST_FUNC 1187 unpack_gz_stream(transformer_state_t *xstate) 1188 { 1189 uint32_t v32; 1190 IF_DESKTOP(long long) int total, n; 1191 DECLARE_STATE; 1192 1193 #if !ENABLE_FEATURE_SEAMLESS_Z 1194 if (check_signature16(xstate, GZIP_MAGIC)) 1195 return -1; 1196 #else 1197 if (xstate->check_signature) { 1198 uint16_t magic2; 1199 1200 if (full_read(xstate->src_fd, &magic2, 2) != 2) { 1201 bad_magic: 1202 bb_error_msg("invalid magic"); 1203 return -1; 1204 } 1205 if (magic2 == COMPRESS_MAGIC) { 1206 xstate->check_signature = 0; 1207 return unpack_Z_stream(xstate); 1208 } 1209 if (magic2 != GZIP_MAGIC) 1210 goto bad_magic; 1211 } 1212 #endif 1213 1214 total = 0; 1215 1216 ALLOC_STATE; 1217 if (state == NULL) { 1218 bb_error_msg("alloc error"); 1219 return -1; 1220 } 1221 to_read = -1; 1222 // bytebuffer_max = 0x8000; 1223 bytebuffer = xmalloc(bytebuffer_max); 1224 if (bytebuffer == NULL) { 1225 bb_error_msg("alloc error"); 1226 total = -1; 1227 goto ret; 1228 } 1229 gunzip_src_fd = xstate->src_fd; 1230 1231 again: 1232 if (!check_header_gzip(PASS_STATE xstate)) { 1233 bb_error_msg("corrupted data"); 1234 total = -1; 1235 goto ret; 1236 } 1237 1238 n = inflate_unzip_internal(PASS_STATE xstate); 1239 if (n < 0) { 1240 total = (n == -ENOSPC)?xstate->mem_output_size_max:n; 1241 goto ret; 1242 } 1243 total += n; 1244 1245 if (!top_up(PASS_STATE 8)) { 1246 bb_error_msg("corrupted data"); 1247 total = -1; 1248 goto ret; 1249 } 1250 1251 /* Validate decompression - crc */ 1252 v32 = buffer_read_le_u32(PASS_STATE_ONLY); 1253 if ((~gunzip_crc) != v32) { 1254 bb_error_msg("crc error"); 1255 total = -1; 1256 goto ret; 1257 } 1258 1259 /* Validate decompression - size */ 1260 v32 = buffer_read_le_u32(PASS_STATE_ONLY); 1261 if ((uint32_t)gunzip_bytes_out != v32) { 1262 bb_error_msg("incorrect length"); 1263 total = -1; 1264 } 1265 1266 if (!top_up(PASS_STATE 2)) 1267 goto ret; /* EOF */ 1268 1269 if (bytebuffer[bytebuffer_offset] == 0x1f 1270 && bytebuffer[bytebuffer_offset + 1] == 0x8b 1271 ) { 1272 bytebuffer_offset += 2; 1273 goto again; 1274 } 1275 /* GNU gzip says: */ 1276 /*bb_error_msg("decompression OK, trailing garbage ignored");*/ 1277 1278 ret: 1279 free(bytebuffer); 1280 DEALLOC_STATE; 1281 return total; 1282 }