1 2 /*-------------------------------------------------------------*/ 3 /*--- Library top-level functions. ---*/ 4 /*--- bzlib.c ---*/ 5 /*-------------------------------------------------------------*/ 6 7 /* ------------------------------------------------------------------ 8 This file is part of bzip2/libbzip2, a program and library for 9 lossless, block-sorting data compression. 10 11 bzip2/libbzip2 version 1.0.6 of 6 September 2010 12 Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org> 13 14 Please read the WARNING, DISCLAIMER and PATENTS sections in the 15 README file. 16 17 This program is released under the terms of the license contained 18 in the file LICENSE. 19 ------------------------------------------------------------------ */ 20 21 /* CHANGES 22 0.9.0 -- original version. 23 0.9.0a/b -- no changes in this file. 24 0.9.0c -- made zero-length BZ_FLUSH work correctly in bzCompress(). 25 fixed bzWrite/bzRead to ignore zero-length requests. 26 fixed bzread to correctly handle read requests after EOF. 27 wrong parameter order in call to bzDecompressInit in 28 bzBuffToBuffDecompress. Fixed. 29 */ 30 31 #include "bzlib_private.h" 32 33 #ifndef BZ_NO_COMPRESS 34 35 /*---------------------------------------------------*/ 36 /*--- Compression stuff ---*/ 37 /*---------------------------------------------------*/ 38 39 40 /*---------------------------------------------------*/ 41 #ifndef BZ_NO_STDIO 42 void BZ2_bz__AssertH__fail ( int errcode ) 43 { 44 fprintf(stderr, 45 "\n\nbzip2/libbzip2: internal error number %d.\n" 46 "This is a bug in bzip2/libbzip2, %s.\n" 47 "Please report it to me at: jseward@bzip.org. If this happened\n" 48 "when you were using some program which uses libbzip2 as a\n" 49 "component, you should also report this bug to the author(s)\n" 50 "of that program. Please make an effort to report this bug;\n" 51 "timely and accurate bug reports eventually lead to higher\n" 52 "quality software. Thanks. Julian Seward, 10 December 2007.\n\n", 53 errcode, 54 BZ2_bzlibVersion() 55 ); 56 57 if (errcode == 1007) { 58 fprintf(stderr, 59 "\n*** A special note about internal error number 1007 ***\n" 60 "\n" 61 "Experience suggests that a common cause of i.e. 1007\n" 62 "is unreliable memory or other hardware. The 1007 assertion\n" 63 "just happens to cross-check the results of huge numbers of\n" 64 "memory reads/writes, and so acts (unintendedly) as a stress\n" 65 "test of your memory system.\n" 66 "\n" 67 "I suggest the following: try compressing the file again,\n" 68 "possibly monitoring progress in detail with the -vv flag.\n" 69 "\n" 70 "* If the error cannot be reproduced, and/or happens at different\n" 71 " points in compression, you may have a flaky memory system.\n" 72 " Try a memory-test program. I have used Memtest86\n" 73 " (www.memtest86.com). At the time of writing it is free (GPLd).\n" 74 " Memtest86 tests memory much more thorougly than your BIOSs\n" 75 " power-on test, and may find failures that the BIOS doesn't.\n" 76 "\n" 77 "* If the error can be repeatably reproduced, this is a bug in\n" 78 " bzip2, and I would very much like to hear about it. Please\n" 79 " let me know, and, ideally, save a copy of the file causing the\n" 80 " problem -- without which I will be unable to investigate it.\n" 81 "\n" 82 ); 83 } 84 85 exit(3); 86 } 87 #endif 88 89 #endif /* BZ_NO_COMPRESS */ 90 91 /*---------------------------------------------------*/ 92 static 93 int bz_config_ok ( void ) 94 { 95 if (sizeof(int) != 4) return 0; 96 if (sizeof(short) != 2) return 0; 97 if (sizeof(char) != 1) return 0; 98 return 1; 99 } 100 101 /* 102 * Added for Solaris kernel 103 */ 104 #define BZES \ 105 BZE(BZ_OK) \ 106 BZE(BZ_RUN_OK) \ 107 BZE(BZ_FLUSH_OK) \ 108 BZE(BZ_FINISH_OK) \ 109 BZE(BZ_STREAM_END) \ 110 BZE(BZ_SEQUENCE_ERROR) \ 111 BZE(BZ_PARAM_ERROR) \ 112 BZE(BZ_MEM_ERROR) \ 113 BZE(BZ_DATA_ERROR) \ 114 BZE(BZ_DATA_ERROR_MAGIC) \ 115 BZE(BZ_IO_ERROR) \ 116 BZE(BZ_UNEXPECTED_EOF) \ 117 BZE(BZ_OUTBUFF_FULL) \ 118 BZE(BZ_CONFIG_ERROR) 119 120 BZ_EXTERN const char * BZ_API(BZ2_bzErrorString) ( 121 int error_code 122 ) 123 { 124 switch (error_code) 125 { 126 #define BZE(x) case x: return (#x); 127 BZES 128 #undef BZE 129 } 130 return ("BZ_UNKNOWN_ERROR"); 131 } 132 133 #ifndef BZ_LOADER 134 #include <sys/sysmacros.h> 135 #endif 136 137 #ifdef _KERNEL 138 139 #include <sys/types.h> 140 #include <sys/cmn_err.h> 141 #include <sys/kmem.h> 142 143 void 144 bz_internal_error(int errcode) 145 { 146 panic("bzip2 internal error: %s\n", BZ2_bzErrorString(errcode)); 147 } 148 149 /*---------------------------------------------------*/ 150 typedef struct { 151 char *buf; 152 size_t sz; 153 } bzap; 154 155 static 156 void* default_bzalloc ( void* opaque, Int32 items, Int32 size ) 157 { 158 size_t sz = sizeof (bzap) + BZ2_BZALLOC_ALIGN + (items * size); 159 uintptr_t p = (uintptr_t)kmem_alloc(sz, KM_SLEEP); 160 161 if (p != NULL) { 162 bzap *pp = (bzap *)((p + sizeof (bzap) + BZ2_BZALLOC_ALIGN - 1) & 163 -BZ2_BZALLOC_ALIGN); 164 pp[-1].buf = (void *)p; 165 pp[-1].sz = sz; 166 return (pp); 167 } 168 return (NULL); 169 } 170 171 static 172 void default_bzfree ( void* opaque, void* addr ) 173 { 174 if (addr != NULL) { 175 bzap *pp = (bzap *)addr - 1; 176 kmem_free(pp->buf, pp->sz); 177 } 178 } 179 180 #else 181 182 /*---------------------------------------------------*/ 183 static 184 void* default_bzalloc ( void* opaque, Int32 items, Int32 size ) 185 { 186 void* v = malloc ( items * size ); 187 return v; 188 } 189 190 static 191 void default_bzfree ( void* opaque, void* addr ) 192 { 193 if (addr != NULL) free ( addr ); 194 } 195 #endif /* _KERNEL */ 196 197 /*---------------------------------------------------*/ 198 #ifndef BZ_NO_COMPRESS 199 static 200 void prepare_new_block ( EState* s ) 201 { 202 Int32 i; 203 s->nblock = 0; 204 s->numZ = 0; 205 s->state_out_pos = 0; 206 BZ_INITIALISE_CRC ( s->blockCRC ); 207 for (i = 0; i < 256; i++) s->inUse[i] = False; 208 s->blockNo++; 209 } 210 211 212 /*---------------------------------------------------*/ 213 static 214 void init_RL ( EState* s ) 215 { 216 s->state_in_ch = 256; 217 s->state_in_len = 0; 218 } 219 220 221 static 222 Bool isempty_RL ( EState* s ) 223 { 224 if (s->state_in_ch < 256 && s->state_in_len > 0) 225 return False; else 226 return True; 227 } 228 229 230 /*---------------------------------------------------*/ 231 int BZ_API(BZ2_bzCompressInit) 232 ( bz_stream* strm, 233 int blockSize100k, 234 int verbosity, 235 int workFactor ) 236 { 237 Int32 n; 238 EState* s; 239 240 if (!bz_config_ok()) return BZ_CONFIG_ERROR; 241 242 if (strm == NULL || 243 blockSize100k < 1 || blockSize100k > 9 || 244 workFactor < 0 || workFactor > 250) 245 return BZ_PARAM_ERROR; 246 247 if (workFactor == 0) workFactor = 30; 248 if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc; 249 if (strm->bzfree == NULL) strm->bzfree = default_bzfree; 250 251 s = BZALLOC( sizeof(EState) ); 252 if (s == NULL) return BZ_MEM_ERROR; 253 s->strm = strm; 254 255 s->arr1 = NULL; 256 s->arr2 = NULL; 257 s->ftab = NULL; 258 259 n = 100000 * blockSize100k; 260 s->arr1 = BZALLOC( n * sizeof(UInt32) ); 261 s->arr2 = BZALLOC( (n+BZ_N_OVERSHOOT) * sizeof(UInt32) ); 262 s->ftab = BZALLOC( 65537 * sizeof(UInt32) ); 263 264 if (s->arr1 == NULL || s->arr2 == NULL || s->ftab == NULL) { 265 if (s->arr1 != NULL) BZFREE(s->arr1); 266 if (s->arr2 != NULL) BZFREE(s->arr2); 267 if (s->ftab != NULL) BZFREE(s->ftab); 268 if (s != NULL) BZFREE(s); 269 return BZ_MEM_ERROR; 270 } 271 272 s->blockNo = 0; 273 s->state = BZ_S_INPUT; 274 s->mode = BZ_M_RUNNING; 275 s->combinedCRC = 0; 276 s->blockSize100k = blockSize100k; 277 s->nblockMAX = 100000 * blockSize100k - 19; 278 s->verbosity = verbosity; 279 s->workFactor = workFactor; 280 281 s->block = (UChar*)s->arr2; 282 s->mtfv = (UInt16*)s->arr1; 283 s->zbits = NULL; 284 s->ptr = (UInt32*)s->arr1; 285 286 strm->state = s; 287 strm->total_in_lo32 = 0; 288 strm->total_in_hi32 = 0; 289 strm->total_out_lo32 = 0; 290 strm->total_out_hi32 = 0; 291 init_RL ( s ); 292 prepare_new_block ( s ); 293 return BZ_OK; 294 } 295 296 /*---------------------------------------------------*/ 297 /* 298 * returns the BZALLOC size needed for bzCompressInit 299 */ 300 int BZ_API(BZ2_bzCompressInitSize) ( 301 int blockSize100k) 302 { 303 Int32 n, t; 304 305 n = 100000 * blockSize100k; 306 t = 0; 307 t += ( sizeof(EState) ); 308 t = P2ROUNDUP(t, BZ2_BZALLOC_ALIGN); 309 t += ( n * sizeof(UInt32) ); 310 t = P2ROUNDUP(t, BZ2_BZALLOC_ALIGN); 311 t += ( (n+BZ_N_OVERSHOOT) * sizeof(UInt32) ); 312 t = P2ROUNDUP(t, BZ2_BZALLOC_ALIGN); 313 t += ( 65537 * sizeof(UInt32) ); 314 t = P2ROUNDUP(t, BZ2_BZALLOC_ALIGN); 315 return (t); 316 } 317 318 /*---------------------------------------------------*/ 319 /* 320 * added to allow reuse of bz_stream without malloc/free 321 */ 322 int BZ_API(BZ2_bzCompressReset) ( bz_stream *strm ) 323 { 324 EState* s = strm->state; 325 326 if (!bz_config_ok()) return BZ_CONFIG_ERROR; 327 328 if (s == NULL) return BZ_MEM_ERROR; 329 s->strm = strm; 330 331 s->blockNo = 0; 332 s->state = BZ_S_INPUT; 333 s->mode = BZ_M_RUNNING; 334 s->combinedCRC = 0; 335 s->nblockMAX = 100000 * s->blockSize100k - 19; 336 337 s->block = (UChar*)s->arr2; 338 s->mtfv = (UInt16*)s->arr1; 339 s->zbits = NULL; 340 s->ptr = (UInt32*)s->arr1; 341 342 strm->state = s; 343 strm->total_in_lo32 = 0; 344 strm->total_in_hi32 = 0; 345 strm->total_out_lo32 = 0; 346 strm->total_out_hi32 = 0; 347 init_RL ( s ); 348 prepare_new_block ( s ); 349 return BZ_OK; 350 } 351 352 353 /*---------------------------------------------------*/ 354 static 355 void add_pair_to_block ( EState* s ) 356 { 357 Int32 i; 358 UChar ch = (UChar)(s->state_in_ch); 359 for (i = 0; i < s->state_in_len; i++) { 360 BZ_UPDATE_CRC( s->blockCRC, ch ); 361 } 362 s->inUse[s->state_in_ch] = True; 363 switch (s->state_in_len) { 364 case 1: 365 s->block[s->nblock] = (UChar)ch; s->nblock++; 366 break; 367 case 2: 368 s->block[s->nblock] = (UChar)ch; s->nblock++; 369 s->block[s->nblock] = (UChar)ch; s->nblock++; 370 break; 371 case 3: 372 s->block[s->nblock] = (UChar)ch; s->nblock++; 373 s->block[s->nblock] = (UChar)ch; s->nblock++; 374 s->block[s->nblock] = (UChar)ch; s->nblock++; 375 break; 376 default: 377 s->inUse[s->state_in_len-4] = True; 378 s->block[s->nblock] = (UChar)ch; s->nblock++; 379 s->block[s->nblock] = (UChar)ch; s->nblock++; 380 s->block[s->nblock] = (UChar)ch; s->nblock++; 381 s->block[s->nblock] = (UChar)ch; s->nblock++; 382 s->block[s->nblock] = ((UChar)(s->state_in_len-4)); 383 s->nblock++; 384 break; 385 } 386 } 387 388 389 /*---------------------------------------------------*/ 390 static 391 void flush_RL ( EState* s ) 392 { 393 if (s->state_in_ch < 256) add_pair_to_block ( s ); 394 init_RL ( s ); 395 } 396 397 398 /*---------------------------------------------------*/ 399 #define ADD_CHAR_TO_BLOCK(zs,zchh0) \ 400 { \ 401 UInt32 zchh = (UInt32)(zchh0); \ 402 /*-- fast track the common case --*/ \ 403 if (zchh != zs->state_in_ch && \ 404 zs->state_in_len == 1) { \ 405 UChar ch = (UChar)(zs->state_in_ch); \ 406 BZ_UPDATE_CRC( zs->blockCRC, ch ); \ 407 zs->inUse[zs->state_in_ch] = True; \ 408 zs->block[zs->nblock] = (UChar)ch; \ 409 zs->nblock++; \ 410 zs->state_in_ch = zchh; \ 411 } \ 412 else \ 413 /*-- general, uncommon cases --*/ \ 414 if (zchh != zs->state_in_ch || \ 415 zs->state_in_len == 255) { \ 416 if (zs->state_in_ch < 256) \ 417 add_pair_to_block ( zs ); \ 418 zs->state_in_ch = zchh; \ 419 zs->state_in_len = 1; \ 420 } else { \ 421 zs->state_in_len++; \ 422 } \ 423 } 424 425 426 /*---------------------------------------------------*/ 427 static 428 Bool copy_input_until_stop ( EState* s ) 429 { 430 Bool progress_in = False; 431 432 if (s->mode == BZ_M_RUNNING) { 433 434 /*-- fast track the common case --*/ 435 while (True) { 436 /*-- block full? --*/ 437 if (s->nblock >= s->nblockMAX) break; 438 /*-- no input? --*/ 439 if (s->strm->avail_in == 0) break; 440 progress_in = True; 441 ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) ); 442 s->strm->next_in++; 443 s->strm->avail_in--; 444 s->strm->total_in_lo32++; 445 if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; 446 } 447 448 } else { 449 450 /*-- general, uncommon case --*/ 451 while (True) { 452 /*-- block full? --*/ 453 if (s->nblock >= s->nblockMAX) break; 454 /*-- no input? --*/ 455 if (s->strm->avail_in == 0) break; 456 /*-- flush/finish end? --*/ 457 if (s->avail_in_expect == 0) break; 458 progress_in = True; 459 ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) ); 460 s->strm->next_in++; 461 s->strm->avail_in--; 462 s->strm->total_in_lo32++; 463 if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; 464 s->avail_in_expect--; 465 } 466 } 467 return progress_in; 468 } 469 470 471 /*---------------------------------------------------*/ 472 static 473 Bool copy_output_until_stop ( EState* s ) 474 { 475 Bool progress_out = False; 476 477 while (True) { 478 479 /*-- no output space? --*/ 480 if (s->strm->avail_out == 0) break; 481 482 /*-- block done? --*/ 483 if (s->state_out_pos >= s->numZ) break; 484 485 progress_out = True; 486 *(s->strm->next_out) = s->zbits[s->state_out_pos]; 487 s->state_out_pos++; 488 s->strm->avail_out--; 489 s->strm->next_out++; 490 s->strm->total_out_lo32++; 491 if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; 492 } 493 494 return progress_out; 495 } 496 497 498 /*---------------------------------------------------*/ 499 static 500 Bool handle_compress ( bz_stream* strm ) 501 { 502 Bool progress_in = False; 503 Bool progress_out = False; 504 EState* s = strm->state; 505 506 while (True) { 507 508 if (s->state == BZ_S_OUTPUT) { 509 progress_out |= copy_output_until_stop ( s ); 510 if (s->state_out_pos < s->numZ) break; 511 if (s->mode == BZ_M_FINISHING && 512 s->avail_in_expect == 0 && 513 isempty_RL(s)) break; 514 prepare_new_block ( s ); 515 s->state = BZ_S_INPUT; 516 if (s->mode == BZ_M_FLUSHING && 517 s->avail_in_expect == 0 && 518 isempty_RL(s)) break; 519 } 520 521 if (s->state == BZ_S_INPUT) { 522 progress_in |= copy_input_until_stop ( s ); 523 if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) { 524 flush_RL ( s ); 525 BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING) ); 526 s->state = BZ_S_OUTPUT; 527 } 528 else 529 if (s->nblock >= s->nblockMAX) { 530 BZ2_compressBlock ( s, False ); 531 s->state = BZ_S_OUTPUT; 532 } 533 else 534 if (s->strm->avail_in == 0) { 535 break; 536 } 537 } 538 539 } 540 541 return progress_in || progress_out; 542 } 543 544 545 /*---------------------------------------------------*/ 546 int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action ) 547 { 548 Bool progress; 549 EState* s; 550 if (strm == NULL) return BZ_PARAM_ERROR; 551 s = strm->state; 552 if (s == NULL) return BZ_PARAM_ERROR; 553 if (s->strm != strm) return BZ_PARAM_ERROR; 554 555 preswitch: 556 switch (s->mode) { 557 558 case BZ_M_IDLE: 559 return BZ_SEQUENCE_ERROR; 560 561 case BZ_M_RUNNING: 562 if (action == BZ_RUN) { 563 progress = handle_compress ( strm ); 564 return progress ? BZ_RUN_OK : BZ_PARAM_ERROR; 565 } 566 else 567 if (action == BZ_FLUSH) { 568 s->avail_in_expect = strm->avail_in; 569 s->mode = BZ_M_FLUSHING; 570 goto preswitch; 571 } 572 else 573 if (action == BZ_FINISH) { 574 s->avail_in_expect = strm->avail_in; 575 s->mode = BZ_M_FINISHING; 576 goto preswitch; 577 } 578 else 579 return BZ_PARAM_ERROR; 580 581 case BZ_M_FLUSHING: 582 if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR; 583 if (s->avail_in_expect != s->strm->avail_in) 584 return BZ_SEQUENCE_ERROR; 585 progress = handle_compress ( strm ); 586 if (s->avail_in_expect > 0 || !isempty_RL(s) || 587 s->state_out_pos < s->numZ) return BZ_FLUSH_OK; 588 s->mode = BZ_M_RUNNING; 589 return BZ_RUN_OK; 590 591 case BZ_M_FINISHING: 592 if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR; 593 if (s->avail_in_expect != s->strm->avail_in) 594 return BZ_SEQUENCE_ERROR; 595 progress = handle_compress ( strm ); 596 if (!progress) return BZ_SEQUENCE_ERROR; 597 if (s->avail_in_expect > 0 || !isempty_RL(s) || 598 s->state_out_pos < s->numZ) return BZ_FINISH_OK; 599 s->mode = BZ_M_IDLE; 600 return BZ_STREAM_END; 601 } 602 return BZ_OK; /*--not reached--*/ 603 } 604 605 606 /*---------------------------------------------------*/ 607 int BZ_API(BZ2_bzCompressEnd) ( bz_stream *strm ) 608 { 609 EState* s; 610 if (strm == NULL) return BZ_PARAM_ERROR; 611 s = strm->state; 612 if (s == NULL) return BZ_PARAM_ERROR; 613 if (s->strm != strm) return BZ_PARAM_ERROR; 614 615 if (s->arr1 != NULL) BZFREE(s->arr1); 616 if (s->arr2 != NULL) BZFREE(s->arr2); 617 if (s->ftab != NULL) BZFREE(s->ftab); 618 BZFREE(strm->state); 619 620 strm->state = NULL; 621 622 return BZ_OK; 623 } 624 625 #endif /* BZ_NO_COMPRESS */ 626 627 /*---------------------------------------------------*/ 628 /*--- Decompression stuff ---*/ 629 /*---------------------------------------------------*/ 630 631 /*---------------------------------------------------*/ 632 int BZ_API(BZ2_bzDecompressInit) 633 ( bz_stream* strm, 634 int verbosity, 635 int small ) 636 { 637 DState* s; 638 639 if (!bz_config_ok()) return BZ_CONFIG_ERROR; 640 641 if (strm == NULL) return BZ_PARAM_ERROR; 642 if (small != 0 && small != 1) return BZ_PARAM_ERROR; 643 if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR; 644 645 if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc; 646 if (strm->bzfree == NULL) strm->bzfree = default_bzfree; 647 648 s = BZALLOC( sizeof(DState) ); 649 if (s == NULL) return BZ_MEM_ERROR; 650 s->strm = strm; 651 strm->state = s; 652 s->state = BZ_X_MAGIC_1; 653 s->bsLive = 0; 654 s->bsBuff = 0; 655 s->calculatedCombinedCRC = 0; 656 strm->total_in_lo32 = 0; 657 strm->total_in_hi32 = 0; 658 strm->total_out_lo32 = 0; 659 strm->total_out_hi32 = 0; 660 s->smallDecompress = (Bool)small; 661 s->ll4 = NULL; 662 s->ll16 = NULL; 663 s->tt = NULL; 664 s->currBlockNo = 0; 665 s->verbosity = verbosity; 666 667 return BZ_OK; 668 } 669 670 /*---------------------------------------------------*/ 671 /* 672 * added to allow reuse of bz_stream without malloc/free 673 */ 674 int BZ_API(BZ2_bzDecompressReset) ( bz_stream* strm ) 675 { 676 DState* s = strm->state; 677 678 if (!bz_config_ok()) return BZ_CONFIG_ERROR; 679 680 if (strm == NULL) return BZ_PARAM_ERROR; 681 682 s->strm = strm; 683 684 s->state = BZ_X_MAGIC_1; 685 s->bsLive = 0; 686 s->bsBuff = 0; 687 s->calculatedCombinedCRC = 0; 688 strm->total_in_lo32 = 0; 689 strm->total_in_hi32 = 0; 690 strm->total_out_lo32 = 0; 691 strm->total_out_hi32 = 0; 692 693 s->ll4 = NULL; 694 s->ll16 = NULL; 695 s->tt = NULL; 696 s->currBlockNo = 0; 697 698 699 return BZ_OK; 700 } 701 702 703 /*---------------------------------------------------*/ 704 /* Return True iff data corruption is discovered. 705 Returns False if there is no problem. 706 */ 707 static 708 Bool unRLE_obuf_to_output_FAST ( DState* s ) 709 { 710 UChar k1; 711 712 if (s->blockRandomised) { 713 714 while (True) { 715 /* try to finish existing run */ 716 while (True) { 717 if (s->strm->avail_out == 0) return False; 718 if (s->state_out_len == 0) break; 719 *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; 720 BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); 721 s->state_out_len--; 722 s->strm->next_out++; 723 s->strm->avail_out--; 724 s->strm->total_out_lo32++; 725 if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; 726 } 727 728 /* can a new run be started? */ 729 if (s->nblock_used == s->save_nblock+1) return False; 730 731 /* Only caused by corrupt data stream? */ 732 if (s->nblock_used > s->save_nblock+1) 733 return True; 734 735 s->state_out_len = 1; 736 s->state_out_ch = s->k0; 737 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; 738 k1 ^= BZ_RAND_MASK; s->nblock_used++; 739 if (s->nblock_used == s->save_nblock+1) continue; 740 if (k1 != s->k0) { s->k0 = k1; continue; }; 741 742 s->state_out_len = 2; 743 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; 744 k1 ^= BZ_RAND_MASK; s->nblock_used++; 745 if (s->nblock_used == s->save_nblock+1) continue; 746 if (k1 != s->k0) { s->k0 = k1; continue; }; 747 748 s->state_out_len = 3; 749 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; 750 k1 ^= BZ_RAND_MASK; s->nblock_used++; 751 if (s->nblock_used == s->save_nblock+1) continue; 752 if (k1 != s->k0) { s->k0 = k1; continue; }; 753 754 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; 755 k1 ^= BZ_RAND_MASK; s->nblock_used++; 756 s->state_out_len = ((Int32)k1) + 4; 757 BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK; 758 s->k0 ^= BZ_RAND_MASK; s->nblock_used++; 759 } 760 761 } else { 762 763 /* restore */ 764 UInt32 c_calculatedBlockCRC = s->calculatedBlockCRC; 765 UChar c_state_out_ch = s->state_out_ch; 766 Int32 c_state_out_len = s->state_out_len; 767 Int32 c_nblock_used = s->nblock_used; 768 Int32 c_k0 = s->k0; 769 UInt32* c_tt = s->tt; 770 UInt32 c_tPos = s->tPos; 771 char* cs_next_out = s->strm->next_out; 772 unsigned int cs_avail_out = s->strm->avail_out; 773 Int32 ro_blockSize100k = s->blockSize100k; 774 /* end restore */ 775 776 UInt32 avail_out_INIT = cs_avail_out; 777 Int32 s_save_nblockPP = s->save_nblock+1; 778 unsigned int total_out_lo32_old; 779 780 while (True) { 781 782 /* try to finish existing run */ 783 if (c_state_out_len > 0) { 784 while (True) { 785 if (cs_avail_out == 0) goto return_notr; 786 if (c_state_out_len == 1) break; 787 *( (UChar*)(cs_next_out) ) = c_state_out_ch; 788 BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ); 789 c_state_out_len--; 790 cs_next_out++; 791 cs_avail_out--; 792 } 793 s_state_out_len_eq_one: 794 { 795 if (cs_avail_out == 0) { 796 c_state_out_len = 1; goto return_notr; 797 }; 798 *( (UChar*)(cs_next_out) ) = c_state_out_ch; 799 BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ); 800 cs_next_out++; 801 cs_avail_out--; 802 } 803 } 804 /* Only caused by corrupt data stream? */ 805 if (c_nblock_used > s_save_nblockPP) 806 return True; 807 808 /* can a new run be started? */ 809 if (c_nblock_used == s_save_nblockPP) { 810 c_state_out_len = 0; goto return_notr; 811 }; 812 c_state_out_ch = c_k0; 813 BZ_GET_FAST_C(k1); c_nblock_used++; 814 if (k1 != c_k0) { 815 c_k0 = k1; goto s_state_out_len_eq_one; 816 }; 817 if (c_nblock_used == s_save_nblockPP) 818 goto s_state_out_len_eq_one; 819 820 c_state_out_len = 2; 821 BZ_GET_FAST_C(k1); c_nblock_used++; 822 if (c_nblock_used == s_save_nblockPP) continue; 823 if (k1 != c_k0) { c_k0 = k1; continue; }; 824 825 c_state_out_len = 3; 826 BZ_GET_FAST_C(k1); c_nblock_used++; 827 if (c_nblock_used == s_save_nblockPP) continue; 828 if (k1 != c_k0) { c_k0 = k1; continue; }; 829 830 BZ_GET_FAST_C(k1); c_nblock_used++; 831 c_state_out_len = ((Int32)k1) + 4; 832 BZ_GET_FAST_C(c_k0); c_nblock_used++; 833 } 834 835 return_notr: 836 total_out_lo32_old = s->strm->total_out_lo32; 837 s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out); 838 if (s->strm->total_out_lo32 < total_out_lo32_old) 839 s->strm->total_out_hi32++; 840 841 /* save */ 842 s->calculatedBlockCRC = c_calculatedBlockCRC; 843 s->state_out_ch = c_state_out_ch; 844 s->state_out_len = c_state_out_len; 845 s->nblock_used = c_nblock_used; 846 s->k0 = c_k0; 847 s->tt = c_tt; 848 s->tPos = c_tPos; 849 s->strm->next_out = cs_next_out; 850 s->strm->avail_out = cs_avail_out; 851 /* end save */ 852 } 853 return False; 854 } 855 856 857 858 /*---------------------------------------------------*/ 859 __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab ) 860 { 861 Int32 nb, na, mid; 862 nb = 0; 863 na = 256; 864 do { 865 mid = (nb + na) >> 1; 866 if (indx >= cftab[mid]) nb = mid; else na = mid; 867 } 868 while (na - nb != 1); 869 return nb; 870 } 871 872 873 /*---------------------------------------------------*/ 874 /* Return True iff data corruption is discovered. 875 Returns False if there is no problem. 876 */ 877 static 878 Bool unRLE_obuf_to_output_SMALL ( DState* s ) 879 { 880 UChar k1; 881 882 if (s->blockRandomised) { 883 884 while (True) { 885 /* try to finish existing run */ 886 while (True) { 887 if (s->strm->avail_out == 0) return False; 888 if (s->state_out_len == 0) break; 889 *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; 890 BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); 891 s->state_out_len--; 892 s->strm->next_out++; 893 s->strm->avail_out--; 894 s->strm->total_out_lo32++; 895 if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; 896 } 897 898 /* can a new run be started? */ 899 if (s->nblock_used == s->save_nblock+1) return False; 900 901 /* Only caused by corrupt data stream? */ 902 if (s->nblock_used > s->save_nblock+1) 903 return True; 904 905 s->state_out_len = 1; 906 s->state_out_ch = s->k0; 907 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; 908 k1 ^= BZ_RAND_MASK; s->nblock_used++; 909 if (s->nblock_used == s->save_nblock+1) continue; 910 if (k1 != s->k0) { s->k0 = k1; continue; }; 911 912 s->state_out_len = 2; 913 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; 914 k1 ^= BZ_RAND_MASK; s->nblock_used++; 915 if (s->nblock_used == s->save_nblock+1) continue; 916 if (k1 != s->k0) { s->k0 = k1; continue; }; 917 918 s->state_out_len = 3; 919 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; 920 k1 ^= BZ_RAND_MASK; s->nblock_used++; 921 if (s->nblock_used == s->save_nblock+1) continue; 922 if (k1 != s->k0) { s->k0 = k1; continue; }; 923 924 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; 925 k1 ^= BZ_RAND_MASK; s->nblock_used++; 926 s->state_out_len = ((Int32)k1) + 4; 927 BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK; 928 s->k0 ^= BZ_RAND_MASK; s->nblock_used++; 929 } 930 931 } else { 932 933 while (True) { 934 /* try to finish existing run */ 935 while (True) { 936 if (s->strm->avail_out == 0) return False; 937 if (s->state_out_len == 0) break; 938 *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; 939 BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); 940 s->state_out_len--; 941 s->strm->next_out++; 942 s->strm->avail_out--; 943 s->strm->total_out_lo32++; 944 if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; 945 } 946 947 /* can a new run be started? */ 948 if (s->nblock_used == s->save_nblock+1) return False; 949 950 /* Only caused by corrupt data stream? */ 951 if (s->nblock_used > s->save_nblock+1) 952 return True; 953 954 s->state_out_len = 1; 955 s->state_out_ch = s->k0; 956 BZ_GET_SMALL(k1); s->nblock_used++; 957 if (s->nblock_used == s->save_nblock+1) continue; 958 if (k1 != s->k0) { s->k0 = k1; continue; }; 959 960 s->state_out_len = 2; 961 BZ_GET_SMALL(k1); s->nblock_used++; 962 if (s->nblock_used == s->save_nblock+1) continue; 963 if (k1 != s->k0) { s->k0 = k1; continue; }; 964 965 s->state_out_len = 3; 966 BZ_GET_SMALL(k1); s->nblock_used++; 967 if (s->nblock_used == s->save_nblock+1) continue; 968 if (k1 != s->k0) { s->k0 = k1; continue; }; 969 970 BZ_GET_SMALL(k1); s->nblock_used++; 971 s->state_out_len = ((Int32)k1) + 4; 972 BZ_GET_SMALL(s->k0); s->nblock_used++; 973 } 974 975 } 976 } 977 978 979 /*---------------------------------------------------*/ 980 int BZ_API(BZ2_bzDecompress) ( bz_stream *strm ) 981 { 982 Bool corrupt; 983 DState* s; 984 if (strm == NULL) return BZ_PARAM_ERROR; 985 s = strm->state; 986 if (s == NULL) return BZ_PARAM_ERROR; 987 if (s->strm != strm) return BZ_PARAM_ERROR; 988 989 while (True) { 990 if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR; 991 if (s->state == BZ_X_OUTPUT) { 992 if (s->smallDecompress) 993 corrupt = unRLE_obuf_to_output_SMALL ( s ); else 994 corrupt = unRLE_obuf_to_output_FAST ( s ); 995 if (corrupt) return BZ_DATA_ERROR; 996 if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) { 997 BZ_FINALISE_CRC ( s->calculatedBlockCRC ); 998 if (s->verbosity >= 3) 999 VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC, 1000 s->calculatedBlockCRC ); 1001 if (s->verbosity >= 2) VPrintf0 ( "]" ); 1002 if (s->calculatedBlockCRC != s->storedBlockCRC) 1003 return BZ_DATA_ERROR; 1004 s->calculatedCombinedCRC 1005 = (s->calculatedCombinedCRC << 1) | 1006 (s->calculatedCombinedCRC >> 31); 1007 s->calculatedCombinedCRC ^= s->calculatedBlockCRC; 1008 s->state = BZ_X_BLKHDR_1; 1009 } else { 1010 return BZ_OK; 1011 } 1012 } 1013 if (s->state >= BZ_X_MAGIC_1) { 1014 Int32 r = BZ2_decompress ( s ); 1015 if (r == BZ_STREAM_END) { 1016 if (s->verbosity >= 3) 1017 VPrintf2 ( "\n combined CRCs: stored = 0x%08x, computed = 0x%08x", 1018 s->storedCombinedCRC, s->calculatedCombinedCRC ); 1019 if (s->calculatedCombinedCRC != s->storedCombinedCRC) 1020 return BZ_DATA_ERROR; 1021 return r; 1022 } 1023 if (s->state != BZ_X_OUTPUT) return r; 1024 } 1025 } 1026 1027 #if 0 1028 AssertH ( 0, 6001 ); 1029 1030 return 0; /*NOTREACHED*/ 1031 #endif 1032 } 1033 1034 1035 /*---------------------------------------------------*/ 1036 int BZ_API(BZ2_bzDecompressEnd) ( bz_stream *strm ) 1037 { 1038 DState* s; 1039 if (strm == NULL) return BZ_PARAM_ERROR; 1040 s = strm->state; 1041 if (s == NULL) return BZ_PARAM_ERROR; 1042 if (s->strm != strm) return BZ_PARAM_ERROR; 1043 1044 if (s->tt != NULL) BZFREE(s->tt); 1045 if (s->ll16 != NULL) BZFREE(s->ll16); 1046 if (s->ll4 != NULL) BZFREE(s->ll4); 1047 1048 BZFREE(strm->state); 1049 strm->state = NULL; 1050 1051 return BZ_OK; 1052 } 1053 1054 #ifndef BZ_NO_COMPRESS 1055 1056 #ifndef BZ_NO_STDIO 1057 /*---------------------------------------------------*/ 1058 /*--- File I/O stuff ---*/ 1059 /*---------------------------------------------------*/ 1060 1061 #define BZ_SETERR(eee) \ 1062 { \ 1063 if (bzerror != NULL) *bzerror = eee; \ 1064 if (bzf != NULL) bzf->lastErr = eee; \ 1065 } 1066 1067 typedef 1068 struct { 1069 FILE* handle; 1070 Char buf[BZ_MAX_UNUSED]; 1071 Int32 bufN; 1072 Bool writing; 1073 bz_stream strm; 1074 Int32 lastErr; 1075 Bool initialisedOk; 1076 } 1077 bzFile; 1078 1079 1080 /*---------------------------------------------*/ 1081 static Bool myfeof ( FILE* f ) 1082 { 1083 Int32 c = fgetc ( f ); 1084 if (c == EOF) return True; 1085 ungetc ( c, f ); 1086 return False; 1087 } 1088 1089 1090 /*---------------------------------------------------*/ 1091 BZFILE* BZ_API(BZ2_bzWriteOpen) 1092 ( int* bzerror, 1093 FILE* f, 1094 int blockSize100k, 1095 int verbosity, 1096 int workFactor ) 1097 { 1098 Int32 ret; 1099 bzFile* bzf = NULL; 1100 1101 BZ_SETERR(BZ_OK); 1102 1103 if (f == NULL || 1104 (blockSize100k < 1 || blockSize100k > 9) || 1105 (workFactor < 0 || workFactor > 250) || 1106 (verbosity < 0 || verbosity > 4)) 1107 { BZ_SETERR(BZ_PARAM_ERROR); return NULL; }; 1108 1109 if (ferror(f)) 1110 { BZ_SETERR(BZ_IO_ERROR); return NULL; }; 1111 1112 bzf = malloc ( sizeof(bzFile) ); 1113 if (bzf == NULL) 1114 { BZ_SETERR(BZ_MEM_ERROR); return NULL; }; 1115 1116 BZ_SETERR(BZ_OK); 1117 bzf->initialisedOk = False; 1118 bzf->bufN = 0; 1119 bzf->handle = f; 1120 bzf->writing = True; 1121 bzf->strm.bzalloc = NULL; 1122 bzf->strm.bzfree = NULL; 1123 bzf->strm.opaque = NULL; 1124 1125 if (workFactor == 0) workFactor = 30; 1126 ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k, 1127 verbosity, workFactor ); 1128 if (ret != BZ_OK) 1129 { BZ_SETERR(ret); free(bzf); return NULL; }; 1130 1131 bzf->strm.avail_in = 0; 1132 bzf->initialisedOk = True; 1133 return bzf; 1134 } 1135 1136 1137 1138 /*---------------------------------------------------*/ 1139 void BZ_API(BZ2_bzWrite) 1140 ( int* bzerror, 1141 BZFILE* b, 1142 void* buf, 1143 int len ) 1144 { 1145 Int32 n, n2, ret; 1146 bzFile* bzf = (bzFile*)b; 1147 1148 BZ_SETERR(BZ_OK); 1149 if (bzf == NULL || buf == NULL || len < 0) 1150 { BZ_SETERR(BZ_PARAM_ERROR); return; }; 1151 if (!(bzf->writing)) 1152 { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; 1153 if (ferror(bzf->handle)) 1154 { BZ_SETERR(BZ_IO_ERROR); return; }; 1155 1156 if (len == 0) 1157 { BZ_SETERR(BZ_OK); return; }; 1158 1159 bzf->strm.avail_in = len; 1160 bzf->strm.next_in = buf; 1161 1162 while (True) { 1163 bzf->strm.avail_out = BZ_MAX_UNUSED; 1164 bzf->strm.next_out = bzf->buf; 1165 ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN ); 1166 if (ret != BZ_RUN_OK) 1167 { BZ_SETERR(ret); return; }; 1168 1169 if (bzf->strm.avail_out < BZ_MAX_UNUSED) { 1170 n = BZ_MAX_UNUSED - bzf->strm.avail_out; 1171 n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), 1172 n, bzf->handle ); 1173 if (n != n2 || ferror(bzf->handle)) 1174 { BZ_SETERR(BZ_IO_ERROR); return; }; 1175 } 1176 1177 if (bzf->strm.avail_in == 0) 1178 { BZ_SETERR(BZ_OK); return; }; 1179 } 1180 } 1181 1182 1183 /*---------------------------------------------------*/ 1184 void BZ_API(BZ2_bzWriteClose) 1185 ( int* bzerror, 1186 BZFILE* b, 1187 int abandon, 1188 unsigned int* nbytes_in, 1189 unsigned int* nbytes_out ) 1190 { 1191 BZ2_bzWriteClose64 ( bzerror, b, abandon, 1192 nbytes_in, NULL, nbytes_out, NULL ); 1193 } 1194 1195 1196 void BZ_API(BZ2_bzWriteClose64) 1197 ( int* bzerror, 1198 BZFILE* b, 1199 int abandon, 1200 unsigned int* nbytes_in_lo32, 1201 unsigned int* nbytes_in_hi32, 1202 unsigned int* nbytes_out_lo32, 1203 unsigned int* nbytes_out_hi32 ) 1204 { 1205 Int32 n, n2, ret; 1206 bzFile* bzf = (bzFile*)b; 1207 1208 if (bzf == NULL) 1209 { BZ_SETERR(BZ_OK); return; }; 1210 if (!(bzf->writing)) 1211 { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; 1212 if (ferror(bzf->handle)) 1213 { BZ_SETERR(BZ_IO_ERROR); return; }; 1214 1215 if (nbytes_in_lo32 != NULL) *nbytes_in_lo32 = 0; 1216 if (nbytes_in_hi32 != NULL) *nbytes_in_hi32 = 0; 1217 if (nbytes_out_lo32 != NULL) *nbytes_out_lo32 = 0; 1218 if (nbytes_out_hi32 != NULL) *nbytes_out_hi32 = 0; 1219 1220 if ((!abandon) && bzf->lastErr == BZ_OK) { 1221 while (True) { 1222 bzf->strm.avail_out = BZ_MAX_UNUSED; 1223 bzf->strm.next_out = bzf->buf; 1224 ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH ); 1225 if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END) 1226 { BZ_SETERR(ret); return; }; 1227 1228 if (bzf->strm.avail_out < BZ_MAX_UNUSED) { 1229 n = BZ_MAX_UNUSED - bzf->strm.avail_out; 1230 n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), 1231 n, bzf->handle ); 1232 if (n != n2 || ferror(bzf->handle)) 1233 { BZ_SETERR(BZ_IO_ERROR); return; }; 1234 } 1235 1236 if (ret == BZ_STREAM_END) break; 1237 } 1238 } 1239 1240 if ( !abandon && !ferror ( bzf->handle ) ) { 1241 fflush ( bzf->handle ); 1242 if (ferror(bzf->handle)) 1243 { BZ_SETERR(BZ_IO_ERROR); return; }; 1244 } 1245 1246 if (nbytes_in_lo32 != NULL) 1247 *nbytes_in_lo32 = bzf->strm.total_in_lo32; 1248 if (nbytes_in_hi32 != NULL) 1249 *nbytes_in_hi32 = bzf->strm.total_in_hi32; 1250 if (nbytes_out_lo32 != NULL) 1251 *nbytes_out_lo32 = bzf->strm.total_out_lo32; 1252 if (nbytes_out_hi32 != NULL) 1253 *nbytes_out_hi32 = bzf->strm.total_out_hi32; 1254 1255 BZ_SETERR(BZ_OK); 1256 (void) BZ2_bzCompressEnd ( &(bzf->strm) ); 1257 free ( bzf ); 1258 } 1259 1260 1261 /*---------------------------------------------------*/ 1262 BZFILE* BZ_API(BZ2_bzReadOpen) 1263 ( int* bzerror, 1264 FILE* f, 1265 int verbosity, 1266 int small, 1267 void* unused, 1268 int nUnused ) 1269 { 1270 bzFile* bzf = NULL; 1271 int ret; 1272 1273 BZ_SETERR(BZ_OK); 1274 1275 if (f == NULL || 1276 (small != 0 && small != 1) || 1277 (verbosity < 0 || verbosity > 4) || 1278 (unused == NULL && nUnused != 0) || 1279 (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED))) 1280 { BZ_SETERR(BZ_PARAM_ERROR); return NULL; }; 1281 1282 if (ferror(f)) 1283 { BZ_SETERR(BZ_IO_ERROR); return NULL; }; 1284 1285 bzf = malloc ( sizeof(bzFile) ); 1286 if (bzf == NULL) 1287 { BZ_SETERR(BZ_MEM_ERROR); return NULL; }; 1288 1289 BZ_SETERR(BZ_OK); 1290 1291 bzf->initialisedOk = False; 1292 bzf->handle = f; 1293 bzf->bufN = 0; 1294 bzf->writing = False; 1295 bzf->strm.bzalloc = NULL; 1296 bzf->strm.bzfree = NULL; 1297 bzf->strm.opaque = NULL; 1298 1299 while (nUnused > 0) { 1300 bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++; 1301 unused = ((void*)( 1 + ((UChar*)(unused)) )); 1302 nUnused--; 1303 } 1304 1305 ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small ); 1306 if (ret != BZ_OK) 1307 { BZ_SETERR(ret); free(bzf); return NULL; }; 1308 1309 bzf->strm.avail_in = bzf->bufN; 1310 bzf->strm.next_in = bzf->buf; 1311 1312 bzf->initialisedOk = True; 1313 return bzf; 1314 } 1315 1316 1317 /*---------------------------------------------------*/ 1318 void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b ) 1319 { 1320 bzFile* bzf = (bzFile*)b; 1321 1322 BZ_SETERR(BZ_OK); 1323 if (bzf == NULL) 1324 { BZ_SETERR(BZ_OK); return; }; 1325 1326 if (bzf->writing) 1327 { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; 1328 1329 if (bzf->initialisedOk) 1330 (void) BZ2_bzDecompressEnd ( &(bzf->strm) ); 1331 free ( bzf ); 1332 } 1333 1334 1335 /*---------------------------------------------------*/ 1336 int BZ_API(BZ2_bzRead) 1337 ( int* bzerror, 1338 BZFILE* b, 1339 void* buf, 1340 int len ) 1341 { 1342 Int32 n, ret; 1343 bzFile* bzf = (bzFile*)b; 1344 1345 BZ_SETERR(BZ_OK); 1346 1347 if (bzf == NULL || buf == NULL || len < 0) 1348 { BZ_SETERR(BZ_PARAM_ERROR); return 0; }; 1349 1350 if (bzf->writing) 1351 { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; }; 1352 1353 if (len == 0) 1354 { BZ_SETERR(BZ_OK); return 0; }; 1355 1356 bzf->strm.avail_out = len; 1357 bzf->strm.next_out = buf; 1358 1359 while (True) { 1360 1361 if (ferror(bzf->handle)) 1362 { BZ_SETERR(BZ_IO_ERROR); return 0; }; 1363 1364 if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) { 1365 n = fread ( bzf->buf, sizeof(UChar), 1366 BZ_MAX_UNUSED, bzf->handle ); 1367 if (ferror(bzf->handle)) 1368 { BZ_SETERR(BZ_IO_ERROR); return 0; }; 1369 bzf->bufN = n; 1370 bzf->strm.avail_in = bzf->bufN; 1371 bzf->strm.next_in = bzf->buf; 1372 } 1373 1374 ret = BZ2_bzDecompress ( &(bzf->strm) ); 1375 1376 if (ret != BZ_OK && ret != BZ_STREAM_END) 1377 { BZ_SETERR(ret); return 0; }; 1378 1379 if (ret == BZ_OK && myfeof(bzf->handle) && 1380 bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0) 1381 { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; }; 1382 1383 if (ret == BZ_STREAM_END) 1384 { BZ_SETERR(BZ_STREAM_END); 1385 return len - bzf->strm.avail_out; }; 1386 if (bzf->strm.avail_out == 0) 1387 { BZ_SETERR(BZ_OK); return len; }; 1388 1389 } 1390 1391 return 0; /*not reached*/ 1392 } 1393 1394 1395 /*---------------------------------------------------*/ 1396 void BZ_API(BZ2_bzReadGetUnused) 1397 ( int* bzerror, 1398 BZFILE* b, 1399 void** unused, 1400 int* nUnused ) 1401 { 1402 bzFile* bzf = (bzFile*)b; 1403 if (bzf == NULL) 1404 { BZ_SETERR(BZ_PARAM_ERROR); return; }; 1405 if (bzf->lastErr != BZ_STREAM_END) 1406 { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; 1407 if (unused == NULL || nUnused == NULL) 1408 { BZ_SETERR(BZ_PARAM_ERROR); return; }; 1409 1410 BZ_SETERR(BZ_OK); 1411 *nUnused = bzf->strm.avail_in; 1412 *unused = bzf->strm.next_in; 1413 } 1414 #endif 1415 1416 1417 /*---------------------------------------------------*/ 1418 /*--- Misc convenience stuff ---*/ 1419 /*---------------------------------------------------*/ 1420 1421 /*---------------------------------------------------*/ 1422 int BZ_API(BZ2_bzBuffToBuffCompress) 1423 ( char* dest, 1424 unsigned int* destLen, 1425 char* source, 1426 unsigned int sourceLen, 1427 int blockSize100k, 1428 int verbosity, 1429 int workFactor ) 1430 { 1431 bz_stream strm; 1432 int ret; 1433 1434 if (dest == NULL || destLen == NULL || 1435 source == NULL || 1436 blockSize100k < 1 || blockSize100k > 9 || 1437 verbosity < 0 || verbosity > 4 || 1438 workFactor < 0 || workFactor > 250) 1439 return BZ_PARAM_ERROR; 1440 1441 if (workFactor == 0) workFactor = 30; 1442 strm.bzalloc = NULL; 1443 strm.bzfree = NULL; 1444 strm.opaque = NULL; 1445 ret = BZ2_bzCompressInit ( &strm, blockSize100k, 1446 verbosity, workFactor ); 1447 if (ret != BZ_OK) return ret; 1448 1449 strm.next_in = source; 1450 strm.next_out = dest; 1451 strm.avail_in = sourceLen; 1452 strm.avail_out = *destLen; 1453 1454 ret = BZ2_bzCompress ( &strm, BZ_FINISH ); 1455 if (ret == BZ_FINISH_OK) goto output_overflow; 1456 if (ret != BZ_STREAM_END) goto errhandler; 1457 1458 /* normal termination */ 1459 *destLen -= strm.avail_out; 1460 (void) BZ2_bzCompressEnd ( &strm ); 1461 return BZ_OK; 1462 1463 output_overflow: 1464 (void) BZ2_bzCompressEnd ( &strm ); 1465 return BZ_OUTBUFF_FULL; 1466 1467 errhandler: 1468 (void) BZ2_bzCompressEnd ( &strm ); 1469 return ret; 1470 } 1471 1472 1473 /*---------------------------------------------------*/ 1474 int BZ_API(BZ2_bzBuffToBuffDecompress) 1475 ( char* dest, 1476 unsigned int* destLen, 1477 char* source, 1478 unsigned int sourceLen, 1479 int small, 1480 int verbosity ) 1481 { 1482 bz_stream strm; 1483 int ret; 1484 1485 if (dest == NULL || destLen == NULL || 1486 source == NULL || 1487 (small != 0 && small != 1) || 1488 verbosity < 0 || verbosity > 4) 1489 return BZ_PARAM_ERROR; 1490 1491 strm.bzalloc = NULL; 1492 strm.bzfree = NULL; 1493 strm.opaque = NULL; 1494 ret = BZ2_bzDecompressInit ( &strm, verbosity, small ); 1495 if (ret != BZ_OK) return ret; 1496 1497 strm.next_in = source; 1498 strm.next_out = dest; 1499 strm.avail_in = sourceLen; 1500 strm.avail_out = *destLen; 1501 1502 ret = BZ2_bzDecompress ( &strm ); 1503 if (ret == BZ_OK) goto output_overflow_or_eof; 1504 if (ret != BZ_STREAM_END) goto errhandler; 1505 1506 /* normal termination */ 1507 *destLen -= strm.avail_out; 1508 (void) BZ2_bzDecompressEnd ( &strm ); 1509 return BZ_OK; 1510 1511 output_overflow_or_eof: 1512 if (strm.avail_out > 0) { 1513 (void) BZ2_bzDecompressEnd ( &strm ); 1514 return BZ_UNEXPECTED_EOF; 1515 } else { 1516 (void) BZ2_bzDecompressEnd ( &strm ); 1517 return BZ_OUTBUFF_FULL; 1518 } 1519 1520 errhandler: 1521 (void) BZ2_bzDecompressEnd ( &strm ); 1522 return ret; 1523 } 1524 1525 1526 /*---------------------------------------------------*/ 1527 /*-- 1528 Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp) 1529 to support better zlib compatibility. 1530 This code is not _officially_ part of libbzip2 (yet); 1531 I haven't tested it, documented it, or considered the 1532 threading-safeness of it. 1533 If this code breaks, please contact both Yoshioka and me. 1534 --*/ 1535 /*---------------------------------------------------*/ 1536 1537 /*---------------------------------------------------*/ 1538 /*-- 1539 return version like "0.9.5d, 4-Sept-1999". 1540 --*/ 1541 const char * BZ_API(BZ2_bzlibVersion)(void) 1542 { 1543 return BZ_VERSION; 1544 } 1545 1546 1547 #ifndef BZ_NO_STDIO 1548 /*---------------------------------------------------*/ 1549 1550 #if defined(_WIN32) || defined(OS2) || defined(MSDOS) 1551 # include <fcntl.h> 1552 # include <io.h> 1553 # define SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY) 1554 #else 1555 # define SET_BINARY_MODE(file) 1556 #endif 1557 static 1558 BZFILE * bzopen_or_bzdopen 1559 ( const char *path, /* no use when bzdopen */ 1560 int fd, /* no use when bzdopen */ 1561 const char *mode, 1562 int open_mode) /* bzopen: 0, bzdopen:1 */ 1563 { 1564 int bzerr; 1565 char unused[BZ_MAX_UNUSED]; 1566 int blockSize100k = 9; 1567 int writing = 0; 1568 char mode2[10] = ""; 1569 FILE *fp = NULL; 1570 BZFILE *bzfp = NULL; 1571 int verbosity = 0; 1572 int workFactor = 30; 1573 int smallMode = 0; 1574 int nUnused = 0; 1575 1576 if (mode == NULL) return NULL; 1577 while (*mode) { 1578 switch (*mode) { 1579 case 'r': 1580 writing = 0; break; 1581 case 'w': 1582 writing = 1; break; 1583 case 's': 1584 smallMode = 1; break; 1585 default: 1586 if (isdigit((int)(*mode))) { 1587 blockSize100k = *mode-BZ_HDR_0; 1588 } 1589 } 1590 mode++; 1591 } 1592 strcat(mode2, writing ? "w" : "r" ); 1593 strcat(mode2,"b"); /* binary mode */ 1594 1595 if (open_mode==0) { 1596 if (path==NULL || strcmp(path,"")==0) { 1597 fp = (writing ? stdout : stdin); 1598 SET_BINARY_MODE(fp); 1599 } else { 1600 fp = fopen(path,mode2); 1601 } 1602 } else { 1603 #ifdef BZ_STRICT_ANSI 1604 fp = NULL; 1605 #else 1606 fp = fdopen(fd,mode2); 1607 #endif 1608 } 1609 if (fp == NULL) return NULL; 1610 1611 if (writing) { 1612 /* Guard against total chaos and anarchy -- JRS */ 1613 if (blockSize100k < 1) blockSize100k = 1; 1614 if (blockSize100k > 9) blockSize100k = 9; 1615 bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k, 1616 verbosity,workFactor); 1617 } else { 1618 bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode, 1619 unused,nUnused); 1620 } 1621 if (bzfp == NULL) { 1622 if (fp != stdin && fp != stdout) fclose(fp); 1623 return NULL; 1624 } 1625 return bzfp; 1626 } 1627 1628 1629 /*---------------------------------------------------*/ 1630 /*-- 1631 open file for read or write. 1632 ex) bzopen("file","w9") 1633 case path="" or NULL => use stdin or stdout. 1634 --*/ 1635 BZFILE * BZ_API(BZ2_bzopen) 1636 ( const char *path, 1637 const char *mode ) 1638 { 1639 return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0); 1640 } 1641 1642 1643 /*---------------------------------------------------*/ 1644 BZFILE * BZ_API(BZ2_bzdopen) 1645 ( int fd, 1646 const char *mode ) 1647 { 1648 return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1); 1649 } 1650 1651 1652 /*---------------------------------------------------*/ 1653 int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len ) 1654 { 1655 int bzerr, nread; 1656 if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0; 1657 nread = BZ2_bzRead(&bzerr,b,buf,len); 1658 if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) { 1659 return nread; 1660 } else { 1661 return -1; 1662 } 1663 } 1664 1665 1666 /*---------------------------------------------------*/ 1667 int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len ) 1668 { 1669 int bzerr; 1670 1671 BZ2_bzWrite(&bzerr,b,buf,len); 1672 if(bzerr == BZ_OK){ 1673 return len; 1674 }else{ 1675 return -1; 1676 } 1677 } 1678 1679 1680 /*---------------------------------------------------*/ 1681 int BZ_API(BZ2_bzflush) (BZFILE *b) 1682 { 1683 /* do nothing now... */ 1684 return 0; 1685 } 1686 1687 1688 /*---------------------------------------------------*/ 1689 void BZ_API(BZ2_bzclose) (BZFILE* b) 1690 { 1691 int bzerr; 1692 FILE *fp; 1693 1694 if (b==NULL) {return;} 1695 fp = ((bzFile *)b)->handle; 1696 if(((bzFile*)b)->writing){ 1697 BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL); 1698 if(bzerr != BZ_OK){ 1699 BZ2_bzWriteClose(NULL,b,1,NULL,NULL); 1700 } 1701 }else{ 1702 BZ2_bzReadClose(&bzerr,b); 1703 } 1704 if(fp!=stdin && fp!=stdout){ 1705 fclose(fp); 1706 } 1707 } 1708 1709 1710 /*---------------------------------------------------*/ 1711 /*-- 1712 return last error code 1713 --*/ 1714 static const char *bzerrorstrings[] = { 1715 "OK" 1716 ,"SEQUENCE_ERROR" 1717 ,"PARAM_ERROR" 1718 ,"MEM_ERROR" 1719 ,"DATA_ERROR" 1720 ,"DATA_ERROR_MAGIC" 1721 ,"IO_ERROR" 1722 ,"UNEXPECTED_EOF" 1723 ,"OUTBUFF_FULL" 1724 ,"CONFIG_ERROR" 1725 ,"???" /* for future */ 1726 ,"???" /* for future */ 1727 ,"???" /* for future */ 1728 ,"???" /* for future */ 1729 ,"???" /* for future */ 1730 ,"???" /* for future */ 1731 }; 1732 1733 1734 const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum) 1735 { 1736 int err = ((bzFile *)b)->lastErr; 1737 1738 if(err>0) err = 0; 1739 *errnum = err; 1740 return bzerrorstrings[err*-1]; 1741 } 1742 #endif 1743 1744 #endif /* BZ_NO_COMPRESS */ 1745 1746 /*-------------------------------------------------------------*/ 1747 /*--- end bzlib.c ---*/ 1748 /*-------------------------------------------------------------*/ 1749