archival/bunzip2.c

   1 /* Modified for busybox by Glenn McGrath <bug1@optushome.com.au> */
   2 /* Added support output to stdout by Thomas Lundquist <thomasez@zelow.no> */
   3 /*--
   4   This file is a part of bzip2 and/or libbzip2, a program and
   5   library for lossless, block-sorting data compression.
   6
   7   Copyright (C) 1996-2000 Julian R Seward.  All rights reserved.
   8
   9   Redistribution and use in source and binary forms, with or without
  10   modification, are permitted provided that the following conditions
  11   are met:
  12
  13   1. Redistributions of source code must retain the above copyright
  14      notice, this list of conditions and the following disclaimer.
  15
  16   2. The origin of this software must not be misrepresented; you must
  17      not claim that you wrote the original software.  If you use this
  18      software in a product, an acknowledgment in the product
  19      documentation would be appreciated but is not required.
  20
  21   3. Altered source versions must be plainly marked as such, and must
  22      not be misrepresented as being the original software.
  23
  24   4. The name of the author may not be used to endorse or promote
  25      products derived from this software without specific prior written
  26      permission.
  27
  28   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  29   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  30   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  32   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  34   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  36   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  37   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  38   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  39
  40   Julian Seward, Cambridge, UK.
  41   jseward@acm.org
  42   bzip2/libbzip2 version 1.0 of 21 March 2000
  43
  44   This program is based on (at least) the work of:
  45      Mike Burrows
  46      David Wheeler
  47      Peter Fenwick
  48      Alistair Moffat
  49      Radford Neal
  50      Ian H. Witten
  51      Robert Sedgewick
  52      Jon L. Bentley
  53
  54   For more information on these sources, see the manual.
  55 --*/
  56
  57 #include <stdlib.h>
  58 #include <stdio.h>
  59 #include <string.h>
  60 #include <getopt.h>
  61 #include <unistd.h>
  62 #include <busybox.h>
  63
  64 //#define TRUE 1
  65 //#define FALSE 0
  66
  67 #define MTFA_SIZE 4096
  68 #define MTFL_SIZE 16
  69 #define BZ_N_GROUPS 6
  70 #define BZ_G_SIZE   50
  71 #define BZ_MAX_ALPHA_SIZE 258
  72
  73 #define BZ_OK                0
  74 #define BZ_STREAM_END        4
  75 #define BZ_SEQUENCE_ERROR    (-1)
  76 #define BZ_DATA_ERROR        (-4)
  77 #define BZ_DATA_ERROR_MAGIC  (-5)
  78 #define BZ_IO_ERROR          (-6)
  79 #define BZ_UNEXPECTED_EOF    (-7)
  80
  81 #define BZ_RUNA 0
  82 #define BZ_RUNB 1
  83
  84 #define BZ_MAX_UNUSED 5000
  85 #define FILE_NAME_LEN 1034
  86 /*-- states for decompression. --*/
  87
  88 #define BZ_X_IDLE        1
  89 #define BZ_X_OUTPUT      2
  90
  91 #define BZ_X_MAGIC_1     10
  92 #define BZ_X_MAGIC_2     11
  93 #define BZ_X_MAGIC_3     12
  94 #define BZ_X_MAGIC_4     13
  95 #define BZ_X_BLKHDR_1    14
  96 #define BZ_X_BLKHDR_2    15
  97 #define BZ_X_BLKHDR_3    16
  98 #define BZ_X_BLKHDR_4    17
  99 #define BZ_X_BLKHDR_5    18
 100 #define BZ_X_BLKHDR_6    19
 101 #define BZ_X_BCRC_1      20
 102 #define BZ_X_BCRC_2      21
 103 #define BZ_X_BCRC_3      22
 104 #define BZ_X_BCRC_4      23
 105 #define BZ_X_RANDBIT     24
 106 #define BZ_X_ORIGPTR_1   25
 107 #define BZ_X_ORIGPTR_2   26
 108 #define BZ_X_ORIGPTR_3   27
 109 #define BZ_X_MAPPING_1   28
 110 #define BZ_X_MAPPING_2   29
 111 #define BZ_X_SELECTOR_1  30
 112 #define BZ_X_SELECTOR_2  31
 113 #define BZ_X_SELECTOR_3  32
 114 #define BZ_X_CODING_1    33
 115 #define BZ_X_CODING_2    34
 116 #define BZ_X_CODING_3    35
 117 #define BZ_X_MTF_1       36
 118 #define BZ_X_MTF_2       37
 119 #define BZ_X_MTF_3       38
 120 #define BZ_X_MTF_4       39
 121 #define BZ_X_MTF_5       40
 122 #define BZ_X_MTF_6       41
 123 #define BZ_X_ENDHDR_2    42
 124 #define BZ_X_ENDHDR_3    43
 125 #define BZ_X_ENDHDR_4    44
 126 #define BZ_X_ENDHDR_5    45
 127 #define BZ_X_ENDHDR_6    46
 128 #define BZ_X_CCRC_1      47
 129 #define BZ_X_CCRC_2      48
 130 #define BZ_X_CCRC_3      49
 131 #define BZ_X_CCRC_4      50
 132
 133 #define BZ_MAX_CODE_LEN    23
 134 #define OM_TEST          3
 135 #define SM_F2F 3
 136
 137 typedef struct {
 138         char *next_in;
 139         unsigned int avail_in;
 140
 141         char *next_out;
 142         unsigned int avail_out;
 143
 144         void *state;
 145
 146 } bz_stream;
 147
 148 typedef struct {
 149         bz_stream       strm;
 150         FILE    *handle;
 151     unsigned char       initialisedOk;
 152         char    buf[BZ_MAX_UNUSED];
 153         int             lastErr;
 154         int             bufN;
 155 } bzFile;
 156
 157 /*-- Structure holding all the decompression-side stuff. --*/
 158 typedef struct {
 159         /* pointer back to the struct bz_stream */
 160         bz_stream* strm;
 161
 162         /* state indicator for this stream */
 163         int     state;
 164
 165         /* for doing the final run-length decoding */
 166         unsigned char    state_out_ch;
 167         int    state_out_len;
 168         unsigned char     blockRandomised;
 169         int rNToGo;
 170         int rTPos;
 171
 172         /* the buffer for bit stream reading */
 173         unsigned int   bsBuff;
 174         int    bsLive;
 175
 176         /* misc administratium */
 177         int    blockSize100k;
 178         int    currBlockNo;
 179
 180         /* for undoing the Burrows-Wheeler transform */
 181         int    origPtr;
 182         unsigned int   tPos;
 183         int    k0;
 184         int    unzftab[256];
 185         int    nblock_used;
 186         int    cftab[257];
 187         int    cftabCopy[257];
 188
 189         /* for undoing the Burrows-Wheeler transform (FAST) */
 190         unsigned int *tt;
 191
 192         /* stored and calculated CRCs */
 193         unsigned int   storedBlockCRC;
 194         unsigned int   storedCombinedCRC;
 195         unsigned int   calculatedBlockCRC;
 196         unsigned int   calculatedCombinedCRC;
 197
 198         /* map of bytes used in block */
 199         int    nInUse;
 200         unsigned char     inUse[256];
 201         unsigned char     inUse16[16];
 202         unsigned char    seqToUnseq[256];
 203
 204         /* for decoding the MTF values */
 205         unsigned char    mtfa   [MTFA_SIZE];
 206         unsigned char    selector   [2 + (900000 / BZ_G_SIZE)];
 207         unsigned char    selectorMtf[2 + (900000 / BZ_G_SIZE)];
 208         unsigned char    len  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
 209         int    mtfbase[256 / MTFL_SIZE];
 210
 211         int    limit  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
 212         int    base   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
 213         int    perm   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
 214         int    minLens[BZ_N_GROUPS];
 215
 216         /* save area for scalars in the main decompress code */
 217         int    save_i;
 218         int    save_j;
 219         int    save_t;
 220         int    save_alphaSize;
 221         int    save_nGroups;
 222         int    save_nSelectors;
 223         int    save_EOB;
 224         int    save_groupNo;
 225         int    save_groupPos;
 226         int    save_nextSym;
 227         int    save_nblockMAX;
 228         int    save_nblock;
 229         int    save_es;
 230         int    save_N;
 231         int    save_curr;
 232         int    save_zt;
 233         int    save_zn;
 234         int    save_zvec;
 235         int    save_zj;
 236         int    save_gSel;
 237         int    save_gMinlen;
 238         int     *save_gLimit;
 239         int     *save_gBase;
 240         int     *save_gPerm;
 241 } DState;
 242
 243 int BZ2_rNums[512];
 244 char inName[FILE_NAME_LEN];
 245 char outName[FILE_NAME_LEN];
 246 int srcMode;
 247 int opMode;
 248 unsigned char deleteOutputOnInterrupt;
 249 FILE *outputHandleJustInCase;
 250 int numFileNames;
 251 int numFilesProcessed;
 252 int exitValue;
 253
 254 const unsigned int BZ2_crc32Table[256] = {
 255
 256    /*-- Ugly, innit? --*/
 257
 258    0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
 259    0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
 260    0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
 261    0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
 262    0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
 263    0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
 264    0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
 265    0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
 266    0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
 267    0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
 268    0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
 269    0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
 270    0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
 271    0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
 272    0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
 273    0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
 274    0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
 275    0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
 276    0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
 277    0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
 278    0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
 279    0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
 280    0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
 281    0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
 282    0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
 283    0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
 284    0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
 285    0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
 286    0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
 287    0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
 288    0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
 289    0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
 290    0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
 291    0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
 292    0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
 293    0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
 294    0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
 295    0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
 296    0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
 297    0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
 298    0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
 299    0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
 300    0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
 301    0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
 302    0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
 303    0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
 304    0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
 305    0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
 306    0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
 307    0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
 308    0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
 309    0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
 310    0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
 311    0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
 312    0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
 313    0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
 314    0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
 315    0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
 316    0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
 317    0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
 318    0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
 319    0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
 320    0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
 321    0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
 322 };
 323
 324 void bz_rand_udp_mask(DState *s)
 325 {
 326         if (s->rNToGo == 0) {
 327                 s->rNToGo = BZ2_rNums[s->rTPos];
 328                 s->rTPos++;
 329                 if (s->rTPos == 512) {
 330                         s->rTPos = 0;
 331                 }
 332         }
 333         s->rNToGo--;
 334 }
 335
 336 static unsigned char myfeof(FILE *f)
 337 {
 338         int c = fgetc(f);
 339         if (c == EOF) {
 340                 return(TRUE);
 341         }
 342         ungetc(c, f);
 343         return(FALSE);
 344 }
 345
 346 static void cleanUpAndFail(int ec)
 347 {
 348         int retVal;
 349
 350         if ((srcMode == SM_F2F) && (opMode != OM_TEST) && deleteOutputOnInterrupt) {
 351                 if (outputHandleJustInCase != NULL) {
 352                         fclose(outputHandleJustInCase);
 353                 }
 354                 retVal = remove(outName);
 355                 if (retVal != 0) {
 356                         error_msg("%s: WARNING: deletion of output file (apparently) failed.\n", applet_name);
 357                 }
 358         }
 359
 360         exit(ec);
 361 }
 362
 363
 364 void BZ2_hbCreateDecodeTables(int *limit, int *base, int *perm, unsigned char *length, int minLen, int maxLen, int alphaSize )
 365 {
 366         int pp, i, j, vec;
 367
 368         pp = 0;
 369         for (i = minLen; i <= maxLen; i++) {
 370                 for (j = 0; j < alphaSize; j++) {
 371                         if (length[j] == i) {
 372                                 perm[pp] = j;
 373                                 pp++;
 374                         }
 375                 }
 376         }
 377
 378         for (i = 0; i < BZ_MAX_CODE_LEN; i++) {
 379                 base[i] = 0;
 380         }
 381
 382         for (i = 0; i < alphaSize; i++) {
 383                 base[length[i]+1]++;
 384         }
 385
 386         for (i = 1; i < BZ_MAX_CODE_LEN; i++) {
 387                 base[i] += base[i-1];
 388         }
 389
 390         for (i = 0; i < BZ_MAX_CODE_LEN; i++) {
 391                 limit[i] = 0;
 392         }
 393         vec = 0;
 394
 395         for (i = minLen; i <= maxLen; i++) {
 396                 vec += (base[i+1] - base[i]);
 397                 limit[i] = vec-1;
 398                 vec <<= 1;
 399         }
 400         for (i = minLen + 1; i <= maxLen; i++) {
 401                 base[i] = ((limit[i-1] + 1) << 1) - base[i];
 402         }
 403 }
 404
 405
 406 static int get_bits(DState *s, int *vvv, char nnn)
 407 {
 408         while (1) {
 409                 if (s->bsLive >= nnn) {
 410                         *vvv = (s->bsBuff >> (s->bsLive-nnn)) & ((1 << nnn)-1);
 411                         s->bsLive -= nnn;
 412                         break;
 413                 }
 414                 if (s->strm->avail_in == 0) {
 415                         return(FALSE);
 416                 }
 417                 s->bsBuff = (s->bsBuff << 8) | ((unsigned int) (*((unsigned char*)(s->strm->next_in))));
 418                 s->bsLive += 8;
 419                 s->strm->next_in++;
 420                 s->strm->avail_in--;
 421         }
 422         return(TRUE);
 423 }
 424
 425 int bz_get_fast(DState *s)
 426 {
 427         int cccc;
 428         s->tPos = s->tt[s->tPos];
 429         cccc = (unsigned char)(s->tPos & 0xff);
 430         s->tPos >>= 8;
 431         return(cccc);
 432 }
 433
 434 /*---------------------------------------------------*/
 435 int BZ2_decompress(DState *s)
 436 {
 437         int uc = 0;
 438         int     retVal;
 439         int     minLen, maxLen;
 440
 441         /* stuff that needs to be saved/restored */
 442         int  i;
 443         int  j;
 444         int  t;
 445         int  alphaSize;
 446         int  nGroups;
 447         int  nSelectors;
 448         int  EOB;
 449         int  groupNo;
 450         int  groupPos;
 451         int  nextSym;
 452         int  nblockMAX;
 453         int  nblock;
 454         int  es;
 455         int  N;
 456         int  curr;
 457         int  zt;
 458         int  zn;
 459         int  zvec;
 460         int  zj;
 461         int  gSel;
 462         int  gMinlen;
 463         int *gLimit;
 464         int *gBase;
 465         int *gPerm;
 466         int switch_val;
 467
 468         int get_mtf_val_init(void)
 469         {
 470                 if (groupPos == 0) {
 471                         groupNo++;
 472                         if (groupNo >= nSelectors) {
 473                                 retVal = BZ_DATA_ERROR;
 474                                 return(FALSE);
 475                         }
 476                         groupPos = BZ_G_SIZE;
 477                         gSel = s->selector[groupNo];
 478                         gMinlen = s->minLens[gSel];
 479                         gLimit = &(s->limit[gSel][0]);
 480                         gPerm = &(s->perm[gSel][0]);
 481                         gBase = &(s->base[gSel][0]);
 482                 }
 483                 groupPos--;
 484                 zn = gMinlen;
 485                 return(TRUE);
 486         }
 487
 488         if (s->state == BZ_X_MAGIC_1) {
 489                 /*initialise the save area*/
 490                 s->save_i           = 0;
 491                 s->save_j           = 0;
 492                 s->save_t           = 0;
 493                 s->save_alphaSize   = 0;
 494                 s->save_nGroups     = 0;
 495                 s->save_nSelectors  = 0;
 496                 s->save_EOB         = 0;
 497                 s->save_groupNo     = 0;
 498                 s->save_groupPos    = 0;
 499                 s->save_nextSym     = 0;
 500                 s->save_nblockMAX   = 0;
 501                 s->save_nblock      = 0;
 502                 s->save_es          = 0;
 503                 s->save_N           = 0;
 504                 s->save_curr        = 0;
 505                 s->save_zt          = 0;
 506                 s->save_zn          = 0;
 507                 s->save_zvec        = 0;
 508                 s->save_zj          = 0;
 509                 s->save_gSel        = 0;
 510                 s->save_gMinlen     = 0;
 511                 s->save_gLimit      = NULL;
 512                 s->save_gBase       = NULL;
 513                 s->save_gPerm       = NULL;
 514         }
 515
 516         /*restore from the save area*/
 517         i           = s->save_i;
 518         j           = s->save_j;
 519         t           = s->save_t;
 520         alphaSize   = s->save_alphaSize;
 521         nGroups     = s->save_nGroups;
 522         nSelectors  = s->save_nSelectors;
 523         EOB         = s->save_EOB;
 524         groupNo     = s->save_groupNo;
 525         groupPos    = s->save_groupPos;
 526         nextSym     = s->save_nextSym;
 527         nblockMAX   = s->save_nblockMAX;
 528         nblock      = s->save_nblock;
 529         es          = s->save_es;
 530         N           = s->save_N;
 531         curr        = s->save_curr;
 532         zt          = s->save_zt;
 533         zn          = s->save_zn;
 534         zvec        = s->save_zvec;
 535         zj          = s->save_zj;
 536         gSel        = s->save_gSel;
 537         gMinlen     = s->save_gMinlen;
 538         gLimit      = s->save_gLimit;
 539         gBase       = s->save_gBase;
 540         gPerm       = s->save_gPerm;
 541
 542         retVal = BZ_OK;
 543         switch_val = s->state;
 544         switch (switch_val) {
 545                 case BZ_X_MAGIC_1:
 546                         s->state = BZ_X_MAGIC_1;
 547                         if (! get_bits(s, &uc, 8)) {
 548                                 retVal = BZ_OK;
 549                                 goto save_state_and_return;
 550                         }
 551                         if (uc != 'B') {
 552                                 retVal = BZ_DATA_ERROR_MAGIC;
 553                                 goto save_state_and_return;
 554                         }
 555
 556                 case BZ_X_MAGIC_2:
 557                         s->state = BZ_X_MAGIC_2;
 558                         if (! get_bits(s, &uc, 8)) {
 559                                 retVal = BZ_OK;
 560                                 goto save_state_and_return;
 561                         }
 562                         if (uc != 'Z') {
 563                                 retVal = BZ_DATA_ERROR_MAGIC;
 564                                 goto save_state_and_return;
 565                         }
 566
 567                 case BZ_X_MAGIC_3:
 568                         s->state = BZ_X_MAGIC_3;
 569                         if (! get_bits(s, &uc, 8)) {
 570                                 retVal = BZ_OK;
 571                                 goto save_state_and_return;
 572                         }
 573                         if (uc != 'h') {
 574                                 retVal = BZ_DATA_ERROR_MAGIC;
 575                                 goto save_state_and_return;
 576                         }
 577
 578                 case BZ_X_MAGIC_4:
 579                         s->state = BZ_X_MAGIC_4;
 580                         if (! get_bits(s, &s->blockSize100k, 8)) {
 581                                 retVal = BZ_OK;
 582                                 goto save_state_and_return;
 583                         }
 584                         if ((s->blockSize100k < '1') || (s->blockSize100k > '9')) {
 585                                 retVal = BZ_DATA_ERROR_MAGIC;
 586                                 goto save_state_and_return;
 587                         }
 588                         s->blockSize100k -= '0';
 589
 590                         s->tt = xmalloc(s->blockSize100k * 100000 * sizeof(int));
 591
 592                 case BZ_X_BLKHDR_1:
 593                         s->state = BZ_X_BLKHDR_1;
 594                         if (! get_bits(s, &uc, 8)) {
 595                                 retVal = BZ_OK;
 596                                 goto save_state_and_return;
 597                         }
 598
 599                         if (uc == 0x17) {
 600                                 goto endhdr_2;
 601                         }
 602                         if (uc != 0x31) {
 603                                 retVal = BZ_DATA_ERROR;
 604                                 goto save_state_and_return;
 605                         }
 606
 607                 case BZ_X_BLKHDR_2:
 608                         s->state = BZ_X_BLKHDR_2;
 609                         if (! get_bits(s, &uc, 8)) {
 610                                 retVal = BZ_OK;
 611                                 goto save_state_and_return;
 612                         }
 613                         if (uc != 0x41) {
 614                                 retVal = BZ_DATA_ERROR;
 615                                 goto save_state_and_return;
 616                         }
 617
 618                 case BZ_X_BLKHDR_3:
 619                         s->state = BZ_X_BLKHDR_3;
 620                         if (! get_bits(s, &uc, 8)) {
 621                                 retVal = BZ_OK;
 622                                 goto save_state_and_return;
 623                         }
 624                         if (uc != 0x59) {
 625                                 retVal = BZ_DATA_ERROR;
 626                                 goto save_state_and_return;
 627                         }
 628
 629                 case BZ_X_BLKHDR_4:
 630                         s->state = BZ_X_BLKHDR_4;
 631                         if (! get_bits(s, &uc, 8)) {
 632                                 retVal = BZ_OK;
 633                                 goto save_state_and_return;
 634                         }
 635                         if (uc != 0x26) {
 636                                 retVal = BZ_DATA_ERROR;
 637                                 goto save_state_and_return;
 638                         }
 639
 640                 case BZ_X_BLKHDR_5:
 641                         s->state = BZ_X_BLKHDR_5;
 642                         if (! get_bits(s, &uc, 8)) {
 643                                 retVal = BZ_OK;
 644                                 goto save_state_and_return;
 645                         }
 646                         if (uc != 0x53) {
 647                                 retVal = BZ_DATA_ERROR;
 648                                 goto save_state_and_return;
 649                         }
 650
 651                 case BZ_X_BLKHDR_6:
 652                         s->state = BZ_X_BLKHDR_6;
 653                         if (! get_bits(s, &uc, 8)) {
 654                                 retVal = BZ_OK;
 655                                 goto save_state_and_return;
 656                         }
 657                         if (uc != 0x59) {
 658                                 retVal = BZ_DATA_ERROR;
 659                                 goto save_state_and_return;
 660                         }
 661
 662                 s->currBlockNo++;
 663                 s->storedBlockCRC = 0;
 664
 665                 case BZ_X_BCRC_1:
 666                         s->state = BZ_X_BCRC_1;
 667                         if (! get_bits(s, &uc, 8)) {
 668                                 retVal = BZ_OK;
 669                                 goto save_state_and_return;
 670                         }
 671                         s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
 672
 673                 case BZ_X_BCRC_2:
 674                         s->state = BZ_X_BCRC_2;
 675                         if (! get_bits(s, &uc, 8)) {
 676                                 retVal = BZ_OK;
 677                                 goto save_state_and_return;
 678                         }
 679                         s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
 680
 681                 case BZ_X_BCRC_3:
 682                         s->state = BZ_X_BCRC_3;
 683                         if (! get_bits(s, &uc, 8)) {
 684                                 retVal = BZ_OK;
 685                                 goto save_state_and_return;
 686                         }
 687                         s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
 688
 689                 case BZ_X_BCRC_4:
 690                         s->state = BZ_X_BCRC_4;
 691                         if (! get_bits(s, &uc, 8)) {
 692                                 retVal = BZ_OK;
 693                                 goto save_state_and_return;
 694                         }
 695                         s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
 696
 697                 case BZ_X_RANDBIT:
 698                         s->state = BZ_X_RANDBIT;
 699                         {
 700                                 int tmp = s->blockRandomised;
 701                                 const int ret = get_bits(s, &tmp, 1);
 702                                 s->blockRandomised = tmp;
 703                                 if (! ret) {
 704                                         retVal = BZ_OK;
 705                                         goto save_state_and_return;
 706                                 }
 707                         }
 708
 709                         s->origPtr = 0;
 710
 711                 case BZ_X_ORIGPTR_1:
 712                         s->state = BZ_X_ORIGPTR_1;
 713                         if (! get_bits(s, &uc, 8)) {
 714                                 retVal = BZ_OK;
 715                                 goto save_state_and_return;
 716                         }
 717                         s->origPtr = (s->origPtr << 8) | ((int)uc);
 718
 719                 case BZ_X_ORIGPTR_2:
 720                         s->state = BZ_X_ORIGPTR_2;
 721                         if (! get_bits(s, &uc, 8)) {
 722                                 retVal = BZ_OK;
 723                                 goto save_state_and_return;
 724                         }
 725                         s->origPtr = (s->origPtr << 8) | ((int)uc);
 726
 727                 case BZ_X_ORIGPTR_3:
 728                         s->state = BZ_X_ORIGPTR_3;
 729                         if (! get_bits(s, &uc, 8)) {
 730                                 retVal = BZ_OK;
 731                                 goto save_state_and_return;
 732                         }
 733                         s->origPtr = (s->origPtr << 8) | ((int)uc);
 734
 735                         if (s->origPtr < 0) {
 736                                 retVal = BZ_DATA_ERROR;
 737                                 goto save_state_and_return;
 738                         }
 739                         if (s->origPtr > 10 + 100000*s->blockSize100k) {
 740                                 retVal = BZ_DATA_ERROR;
 741                                 goto save_state_and_return;
 742                         }
 743
 744                         /*--- Receive the mapping table ---*/
 745                 case BZ_X_MAPPING_1:
 746                         for (i = 0; i < 16; i++) {
 747                                 s->state = BZ_X_MAPPING_1;
 748                                 if (! get_bits(s, &uc, 1)) {
 749                                         retVal = BZ_OK;
 750                                         goto save_state_and_return;
 751                                 }
 752                                 if (uc == 1) {
 753                                         s->inUse16[i] = TRUE;
 754                                 } else {
 755                                         s->inUse16[i] = FALSE;
 756                                 }
 757                         }
 758
 759                         for (i = 0; i < 256; i++) {
 760                                 s->inUse[i] = FALSE;
 761                         }
 762
 763                         for (i = 0; i < 16; i++) {
 764                                 if (s->inUse16[i]) {
 765                                         for (j = 0; j < 16; j++) {
 766                                         case BZ_X_MAPPING_2:
 767                                                 s->state = BZ_X_MAPPING_2;
 768                                                 if (! get_bits(s, &uc, 1)) {
 769                                                         retVal = BZ_OK;
 770                                                         goto save_state_and_return;
 771                                                 }
 772                                                 if (uc == 1) {
 773                                                         s->inUse[i * 16 + j] = TRUE;
 774                                                 }
 775                                         }
 776                                 }
 777                         }
 778
 779                         s->nInUse = 0;
 780                         for (i = 0; i < 256; i++) {
 781                                 if (s->inUse[i]) {
 782                                         s->seqToUnseq[s->nInUse] = i;
 783                                         s->nInUse++;
 784                                 }
 785                         }
 786                         if (s->nInUse == 0) {
 787                                 retVal = BZ_DATA_ERROR;
 788                                 goto save_state_and_return;
 789                         }
 790                         alphaSize = s->nInUse+2;
 791
 792                 /*--- Now the selectors ---*/
 793                 case BZ_X_SELECTOR_1:
 794                         s->state = BZ_X_SELECTOR_1;
 795                         if (! get_bits(s, &nGroups, 3)) {
 796                                 retVal = BZ_OK;
 797                                 goto save_state_and_return;
 798                         }
 799                         if (nGroups < 2 || nGroups > 6) {
 800                                 retVal = BZ_DATA_ERROR;
 801                                 goto save_state_and_return;
 802                         }
 803
 804                 case BZ_X_SELECTOR_2:
 805                         s->state = BZ_X_SELECTOR_2;
 806                         if (! get_bits(s, &nSelectors, 15)) {
 807                                 retVal = BZ_OK;
 808                                 goto save_state_and_return;
 809                         }
 810                         if (nSelectors < 1) {
 811                                 retVal = BZ_DATA_ERROR;
 812                                 goto save_state_and_return;
 813                         }
 814
 815
 816
 817                         for (i = 0; i < nSelectors; i++) {
 818                                 j = 0;
 819                                 while (1) {
 820                                         case BZ_X_SELECTOR_3:
 821                                         s->state = BZ_X_SELECTOR_3;
 822                                         if (! get_bits(s, &uc, 1)) {
 823                                                 retVal = BZ_OK;
 824                                                 goto save_state_and_return;
 825                                         }
 826                                         if (uc == 0) {
 827                                                 break;
 828                                         }
 829                                         j++;
 830                                         if (j >= nGroups) {
 831                                                 retVal = BZ_DATA_ERROR;
 832                                                 goto save_state_and_return;
 833                                         }
 834                                 }
 835                                 s->selectorMtf[i] = j;
 836                         }
 837
 838                         /*--- Undo the MTF values for the selectors. ---*/
 839                         {
 840                                 unsigned char pos[BZ_N_GROUPS], tmp, v;
 841                                 for (v = 0; v < nGroups; v++) {
 842                                         pos[v] = v;
 843                                 }
 844                                 for (i = 0; i < nSelectors; i++) {
 845                                         v = s->selectorMtf[i];
 846                                         tmp = pos[v];
 847                                         while (v > 0) {
 848                                                 pos[v] = pos[v-1];
 849                                                 v--;
 850                                         }
 851                                         pos[0] = tmp;
 852                                         s->selector[i] = tmp;
 853                                 }
 854                         }
 855
 856                         /*--- Now the coding tables ---*/
 857                         for (t = 0; t < nGroups; t++) {
 858                         case BZ_X_CODING_1:
 859                                 s->state = BZ_X_CODING_1;
 860                                 if (! get_bits(s, &curr, 5)) {
 861                                         retVal = BZ_OK;
 862                                         goto save_state_and_return;
 863                                 }
 864                         for (i = 0; i < alphaSize; i++) {
 865                                 while (TRUE) {
 866                                         if (curr < 1 || curr > 20) {
 867                                                 retVal = BZ_DATA_ERROR;
 868                                                 goto save_state_and_return;
 869                                         }
 870
 871                                         case BZ_X_CODING_2:
 872                                                 s->state = BZ_X_CODING_2;
 873                                                 if (! get_bits(s, &uc, 1)) {
 874                                                         retVal = BZ_OK;
 875                                                         goto save_state_and_return;
 876                                                 }
 877                                                 if (uc == 0) {
 878                                                         break;
 879                                                 }
 880
 881                                         case BZ_X_CODING_3:
 882                                                 s->state = BZ_X_CODING_3;
 883                                                 if (! get_bits(s, &uc, 1)) {
 884                                                         retVal = BZ_OK;
 885                                                         goto save_state_and_return;
 886                                                 }
 887                                                 if (uc == 0) {
 888                                                         curr++;
 889                                                 } else {
 890                                                         curr--;
 891                                                 }
 892                                 }
 893                                 s->len[t][i] = curr;
 894                         }
 895                 }
 896
 897                 /*--- Create the Huffman decoding tables ---*/
 898                 for (t = 0; t < nGroups; t++) {
 899                         minLen = 32;
 900                         maxLen = 0;
 901                         for (i = 0; i < alphaSize; i++) {
 902                                 if (s->len[t][i] > maxLen) {
 903                                         maxLen = s->len[t][i];
 904                                 }
 905                                 if (s->len[t][i] < minLen) {
 906                                         minLen = s->len[t][i];
 907                                 }
 908                         }
 909
 910                         BZ2_hbCreateDecodeTables (
 911                                 &(s->limit[t][0]),
 912                                 &(s->base[t][0]),
 913                                 &(s->perm[t][0]),
 914                                 &(s->len[t][0]),
 915                                 minLen, maxLen, alphaSize
 916                                 );
 917
 918
 919                         s->minLens[t] = minLen;
 920                 }
 921
 922                 /*--- Now the MTF values ---*/
 923
 924                 EOB      = s->nInUse+1;
 925                 nblockMAX = 100000 * s->blockSize100k;
 926                 groupNo  = -1;
 927                 groupPos = 0;
 928
 929                 for (i = 0; i <= 255; i++) {
 930                         s->unzftab[i] = 0;
 931                 }
 932                 /*-- MTF init --*/
 933                 {
 934                         int ii, jj, kk;
 935                         kk = MTFA_SIZE-1;
 936                         for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
 937                                 for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
 938                                         s->mtfa[kk] = (unsigned char)(ii * MTFL_SIZE + jj);
 939                                         kk--;
 940                                 }
 941                                 s->mtfbase[ii] = kk + 1;
 942                         }
 943                 }
 944                 /*-- end MTF init --*/
 945
 946                 nblock = 0;
 947
 948                 if (! get_mtf_val_init()) {
 949                         goto save_state_and_return;
 950                 }
 951                 case BZ_X_MTF_1:
 952                         s->state = BZ_X_MTF_1;
 953                         if (! get_bits(s, &zvec, zn)) {
 954                                 retVal = BZ_OK;
 955                                 goto save_state_and_return;
 956                         }
 957                         while (1) {
 958                                 if (zn > 20 /* the longest code */) {
 959                                         retVal = BZ_DATA_ERROR;
 960                                         goto save_state_and_return;
 961                                 }
 962                                 if (zvec <= gLimit[zn]) {
 963                                         break;
 964                                 }
 965                                 zn++;
 966
 967                                 case BZ_X_MTF_2:
 968                                         s->state = BZ_X_MTF_2;
 969                                         if (! get_bits(s, &zj, 1)) {
 970                                                 retVal = BZ_OK;
 971                                                 goto save_state_and_return;
 972                                         }
 973                                         zvec = (zvec << 1) | zj;
 974                         }
 975                         if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
 976                                 retVal = BZ_DATA_ERROR;
 977                                 goto save_state_and_return;
 978                         }
 979                         nextSym = gPerm[zvec - gBase[zn]];
 980
 981                 while (1) {
 982                         if (nextSym == EOB) {
 983                                 break;
 984                         }
 985
 986                 if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
 987                         es = -1;
 988                         N = 1;
 989                         do {
 990                                 if (nextSym == BZ_RUNA) {
 991                                         es = es + (0+1) * N;
 992                                 } else {
 993                                         if (nextSym == BZ_RUNB) {
 994                                                 es = es + (1+1) * N;
 995                                         }
 996                                 }
 997                                 N = N * 2;
 998                                 if (! get_mtf_val_init()) {
 999                                         goto save_state_and_return;
1000                                 }
1001                                 case BZ_X_MTF_3:
1002                                         s->state = BZ_X_MTF_3;
1003                                         if (! get_bits(s, &zvec, zn)) {
1004                                                 retVal = BZ_OK;
1005                                                 goto save_state_and_return;
1006                                         }
1007                                         while (1) {
1008                                                 if (zn > 20 /* the longest code */) {
1009                                                         retVal = BZ_DATA_ERROR;
1010                                                         goto save_state_and_return;
1011                                                 }
1012                                                 if (zvec <= gLimit[zn]) {
1013                                                         break;
1014                                                 }
1015                                                 zn++;
1016
1017                                                 case BZ_X_MTF_4:
1018                                                         s->state = BZ_X_MTF_4;
1019                                                         if (! get_bits(s, &zj, 1)) {
1020                                                                 retVal = BZ_OK;
1021                                                                 goto save_state_and_return;
1022                                                         }
1023                                                         zvec = (zvec << 1) | zj;
1024                                         }
1025                                         if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
1026                                                 retVal = BZ_DATA_ERROR;
1027                                                 goto save_state_and_return;
1028
1029                                         }
1030                                         nextSym = gPerm[zvec - gBase[zn]];
1031                         }
1032                         while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
1033
1034                         es++;
1035                         uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
1036                         s->unzftab[uc] += es;
1037
1038                         while (es > 0) {
1039                                 if (nblock >= nblockMAX) {
1040                                         retVal = BZ_DATA_ERROR;
1041                                         goto save_state_and_return;
1042                                 }
1043                                 s->tt[nblock] = (unsigned int)uc;
1044                                 nblock++;
1045                                 es--;
1046                         }
1047                         continue;
1048                 } else {
1049                         if (nblock >= nblockMAX) {
1050                                 retVal = BZ_DATA_ERROR;
1051                                 goto save_state_and_return;
1052                         }
1053                         /*-- uc = MTF ( nextSym-1 ) --*/
1054                         {
1055                                 int ii, jj, kk, pp, lno, off;
1056                                 unsigned int nn;
1057                                 nn = (unsigned int)(nextSym - 1);
1058
1059                                 if (nn < MTFL_SIZE) {
1060                                         /* avoid general-case expense */
1061                                         pp = s->mtfbase[0];
1062                                         uc = s->mtfa[pp+nn];
1063                                         while (nn > 3) {
1064                                                 int z = pp+nn;
1065                                                 s->mtfa[(z)  ] = s->mtfa[(z)-1];
1066                                                 s->mtfa[(z)-1] = s->mtfa[(z)-2];
1067                                                 s->mtfa[(z)-2] = s->mtfa[(z)-3];
1068                                                 s->mtfa[(z)-3] = s->mtfa[(z)-4];
1069                                                 nn -= 4;
1070                                         }
1071                                         while (nn > 0) {
1072                                                 s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
1073                                         }
1074                                         s->mtfa[pp] = uc;
1075                                 } else {
1076                                         /* general case */
1077                                         lno = nn / MTFL_SIZE;
1078                                         off = nn % MTFL_SIZE;
1079                                         pp = s->mtfbase[lno] + off;
1080                                         uc = s->mtfa[pp];
1081                                         while (pp > s->mtfbase[lno]) {
1082                                                 s->mtfa[pp] = s->mtfa[pp-1];
1083                                                 pp--;
1084                                         }
1085                                         s->mtfbase[lno]++;
1086                                         while (lno > 0) {
1087                                                 s->mtfbase[lno]--;
1088                                                 s->mtfa[s->mtfbase[lno]] = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
1089                                                 lno--;
1090                                         }
1091                                         s->mtfbase[0]--;
1092                                         s->mtfa[s->mtfbase[0]] = uc;
1093                                         if (s->mtfbase[0] == 0) {
1094                                                 kk = MTFA_SIZE-1;
1095                                                 for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
1096                                                         for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
1097                                                                 s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
1098                                                                 kk--;
1099                                                         }
1100                                                         s->mtfbase[ii] = kk + 1;
1101                                                 }
1102                                         }
1103                                 }
1104                         }
1105                         /*-- end uc = MTF ( nextSym-1 ) --*/
1106
1107                         s->unzftab[s->seqToUnseq[uc]]++;
1108                         s->tt[nblock]   = (unsigned int)(s->seqToUnseq[uc]);
1109                         nblock++;
1110
1111                         if (! get_mtf_val_init()) {
1112                                 goto save_state_and_return;
1113                         }
1114                         case BZ_X_MTF_5:
1115                                 s->state = BZ_X_MTF_5;
1116                                 if (! get_bits(s, &zvec, zn)) {
1117                                         retVal = BZ_OK;
1118                                         goto save_state_and_return;
1119                                 }
1120                                 while (1) {
1121                                         if (zn > 20 /* the longest code */) {
1122                                                 retVal = BZ_DATA_ERROR;
1123                                                 goto save_state_and_return;
1124                                         }
1125                                         if (zvec <= gLimit[zn]) {
1126                                                 break;
1127                                         }
1128                                         zn++;
1129
1130                                         case BZ_X_MTF_6:
1131                                                 s->state = BZ_X_MTF_6;
1132                                                 if (! get_bits(s, &zj, 1)) {
1133                                                         retVal = BZ_OK;
1134                                                         goto save_state_and_return;
1135                                                 }
1136                                                 zvec = (zvec << 1) | zj;
1137                                 }
1138                         if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
1139                                 retVal = BZ_DATA_ERROR;
1140                                 goto save_state_and_return;
1141                         }
1142                         nextSym = gPerm[zvec - gBase[zn]];
1143                         continue;
1144                 }
1145         }
1146
1147         /* Now we know what nblock is, we can do a better sanity
1148                 check on s->origPtr.
1149         */
1150         if (s->origPtr < 0 || s->origPtr >= nblock) {
1151                 retVal = BZ_DATA_ERROR;
1152                 goto save_state_and_return;
1153         }
1154         s->state_out_len = 0;
1155         s->state_out_ch  = 0;
1156         s->calculatedBlockCRC = 0xffffffffL;
1157         s->state = BZ_X_OUTPUT;
1158
1159         /*-- Set up cftab to facilitate generation of T^(-1) --*/
1160         s->cftab[0] = 0;
1161         for (i = 1; i <= 256; i++) {
1162                 s->cftab[i] = s->unzftab[i-1];
1163         }
1164         for (i = 1; i <= 256; i++) {
1165                 s->cftab[i] += s->cftab[i-1];
1166         }
1167
1168         /*-- compute the T^(-1) vector --*/
1169         for (i = 0; i < nblock; i++) {
1170                 uc = (unsigned char)(s->tt[i] & 0xff);
1171                 s->tt[s->cftab[uc]] |= (i << 8);
1172                 s->cftab[uc]++;
1173         }
1174
1175         s->tPos = s->tt[s->origPtr] >> 8;
1176         s->nblock_used = 0;
1177         if (s->blockRandomised) {
1178                 s->rNToGo = 0;
1179                 s->rTPos  = 0;
1180                 s->k0 = bz_get_fast(s);
1181
1182                 s->nblock_used++;
1183                 bz_rand_udp_mask(s);
1184                 s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
1185         } else {
1186                 s->k0 = bz_get_fast(s);
1187                 s->nblock_used++;
1188         }
1189
1190                 retVal = BZ_OK;
1191                 goto save_state_and_return;
1192
1193 endhdr_2:
1194                 case BZ_X_ENDHDR_2:
1195                         s->state = BZ_X_ENDHDR_2;
1196                         if (! get_bits(s, &uc, 8)) {
1197                                 retVal = BZ_OK;
1198                                 goto save_state_and_return;
1199                         }
1200                         if (uc != 0x72) {
1201                                 retVal = BZ_DATA_ERROR;
1202                                 goto save_state_and_return;
1203                         }
1204
1205                 case BZ_X_ENDHDR_3:
1206                         s->state = BZ_X_ENDHDR_3;
1207                         if (! get_bits(s, &uc, 8)) {
1208                                 retVal = BZ_OK;
1209                                 goto save_state_and_return;
1210                         }
1211                         if (uc != 0x45) {
1212                                 retVal = BZ_DATA_ERROR;
1213                                 goto save_state_and_return;
1214                         }
1215
1216                 case BZ_X_ENDHDR_4:
1217                         s->state = BZ_X_ENDHDR_4;
1218                         if (! get_bits(s, &uc, 8)) {
1219                                 retVal = BZ_OK;
1220                                 goto save_state_and_return;
1221                         }
1222                         if (uc != 0x38) {
1223                                 retVal = BZ_DATA_ERROR;
1224                                 goto save_state_and_return;
1225                         }
1226
1227                 case BZ_X_ENDHDR_5:
1228                         s->state = BZ_X_ENDHDR_5;
1229                         if (! get_bits(s, &uc, 8)) {
1230                                 retVal = BZ_OK;
1231                                 goto save_state_and_return;
1232                         }
1233                         if (uc != 0x50) {
1234                                 retVal = BZ_DATA_ERROR;
1235                                 goto save_state_and_return;
1236                         }
1237
1238                 case BZ_X_ENDHDR_6:
1239                         s->state = BZ_X_ENDHDR_6;
1240                         if (! get_bits(s, &uc, 8)) {
1241                                 retVal = BZ_OK;
1242                                 goto save_state_and_return;
1243                         }
1244                         if (uc != 0x90) {
1245                                 retVal = BZ_DATA_ERROR;
1246                                 goto save_state_and_return;
1247                         }
1248                         s->storedCombinedCRC = 0;
1249
1250                 case BZ_X_CCRC_1:
1251                         s->state = BZ_X_CCRC_1;
1252                         if (! get_bits(s, &uc, 8)) {
1253                                 retVal = BZ_OK;
1254                                 goto save_state_and_return;
1255                         }
1256                         s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
1257                 case BZ_X_CCRC_2:
1258                         s->state = BZ_X_CCRC_2;
1259                         if (! get_bits(s, &uc, 8)) {
1260                                 retVal = BZ_OK;
1261                                 goto save_state_and_return;
1262                         }
1263                         s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
1264
1265                 case BZ_X_CCRC_3:
1266                         s->state = BZ_X_CCRC_3;
1267                         if (! get_bits(s, &uc, 8)) {
1268                                 retVal = BZ_OK;
1269                                 goto save_state_and_return;
1270                         }
1271                         s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
1272
1273                 case BZ_X_CCRC_4:
1274                         s->state = BZ_X_CCRC_4;
1275                         if (! get_bits(s, &uc, 8)) {
1276                                 retVal = BZ_OK;
1277                                 goto save_state_and_return;
1278                         }
1279                         s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
1280
1281                 s->state = BZ_X_IDLE;
1282                 retVal = BZ_STREAM_END;
1283                 goto save_state_and_return;
1284
1285         }
1286
1287 save_state_and_return:
1288         s->save_i           = i;
1289         s->save_j           = j;
1290         s->save_t           = t;
1291         s->save_alphaSize   = alphaSize;
1292         s->save_nGroups     = nGroups;
1293         s->save_nSelectors  = nSelectors;
1294         s->save_EOB         = EOB;
1295         s->save_groupNo     = groupNo;
1296         s->save_groupPos    = groupPos;
1297         s->save_nextSym     = nextSym;
1298         s->save_nblockMAX   = nblockMAX;
1299         s->save_nblock      = nblock;
1300         s->save_es          = es;
1301         s->save_N           = N;
1302         s->save_curr        = curr;
1303         s->save_zt          = zt;
1304         s->save_zn          = zn;
1305         s->save_zvec        = zvec;
1306         s->save_zj          = zj;
1307         s->save_gSel        = gSel;
1308         s->save_gMinlen     = gMinlen;
1309         s->save_gLimit      = gLimit;
1310         s->save_gBase       = gBase;
1311         s->save_gPerm       = gPerm;
1312
1313         return retVal;
1314 }
1315
1316 //int BZ2_bzDecompressInit(bz_stream* strm, int verbosity_level, int small)
1317 int BZ2_bzDecompressInit(bz_stream* strm)
1318 {
1319         DState* s;
1320
1321 //      if (verbosity_level < 0 || verbosity_level > 4) {
1322 //              return BZ_PARAM_ERROR;
1323 //      }
1324         s = xmalloc(sizeof(DState));
1325         s->strm                  = strm;
1326         strm->state              = s;
1327         s->state                 = BZ_X_MAGIC_1;
1328         s->bsLive                = 0;
1329         s->bsBuff                = 0;
1330         s->calculatedCombinedCRC = 0;
1331         s->tt                    = NULL;
1332         s->currBlockNo           = 0;
1333
1334         return BZ_OK;
1335 }
1336
1337 void bz_seterr(int eee, int *bzerror, bzFile **bzf)
1338 {
1339         if (bzerror != NULL) {
1340                 *bzerror = eee;
1341         }
1342         if (*bzf != NULL) {
1343                 (*bzf)->lastErr = eee;
1344         }
1345 }
1346
1347 static void BZ2_bzReadClose(int *bzerror, void *b)
1348 {
1349         bzFile* bzf = (bzFile*)b;
1350
1351         bz_seterr(BZ_OK, bzerror, &bzf);
1352
1353         if (bzf->initialisedOk) {
1354                 bz_stream *strm = &(bzf->strm);
1355                 DState *s;
1356                 if (strm == NULL) {
1357                         return;
1358                 }
1359                 s = strm->state;
1360                 if ((s == NULL) || (s->strm != strm)) {
1361                         return;
1362                 }
1363                 free(s->tt);
1364                 free(strm->state);
1365                 strm->state = NULL;
1366                 return;
1367         }
1368         free(bzf);
1369 }
1370
1371 static void unRLE_obuf_to_output_FAST(DState *s)
1372 {
1373         unsigned char k1;
1374
1375         if (s->blockRandomised) {
1376                 while (1) {
1377                         /* try to finish existing run */
1378                         while (1) {
1379                                 if (s->strm->avail_out == 0) {
1380                                         return;
1381                                 }
1382                                 if (s->state_out_len == 0) {
1383                                         break;
1384                                 }
1385                                 *((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
1386                                 s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
1387                                         BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
1388                                         ((unsigned char)s->state_out_ch)];
1389                                 s->state_out_len--;
1390                                 s->strm->next_out++;
1391                                 s->strm->avail_out--;
1392                         }
1393
1394                         /* can a new run be started? */
1395                         if (s->nblock_used == s->save_nblock+1) {
1396                                 return;
1397                         }
1398                         s->state_out_len = 1;
1399                         s->state_out_ch = s->k0;
1400                         k1 = bz_get_fast(s);
1401                         bz_rand_udp_mask(s);
1402                         k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1403                         s->nblock_used++;
1404                         if (s->nblock_used == s->save_nblock+1) {
1405                                 continue;
1406                         }
1407                         if (k1 != s->k0) {
1408                                 s->k0 = k1;
1409                                 continue;
1410                         }
1411
1412                         s->state_out_len = 2;
1413                         k1 = bz_get_fast(s);
1414                         bz_rand_udp_mask(s);
1415                         k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1416                         s->nblock_used++;
1417                         if (s->nblock_used == s->save_nblock+1) {
1418                                 continue;
1419                         }
1420                         if (k1 != s->k0) {
1421                                 s->k0 = k1;
1422                                 continue;
1423                         }
1424                         s->state_out_len = 3;
1425                         k1 = bz_get_fast(s);
1426                         bz_rand_udp_mask(s);
1427                         k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1428                         s->nblock_used++;
1429                         if (s->nblock_used == s->save_nblock+1) {
1430                                 continue;
1431                         }
1432                         if (k1 != s->k0) {
1433                                 s->k0 = k1;
1434                                 continue;
1435                         }
1436
1437                         k1 = bz_get_fast(s);
1438                         bz_rand_udp_mask(s);
1439                         k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1440                         s->nblock_used++;
1441                         s->state_out_len = ((int)k1) + 4;
1442                         s->k0 = bz_get_fast(s);
1443                         bz_rand_udp_mask(s);
1444                         s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
1445                         s->nblock_used++;
1446                 }
1447         } else {
1448                 /* restore */
1449                 unsigned int c_calculatedBlockCRC = s->calculatedBlockCRC;
1450                 unsigned char c_state_out_ch       = s->state_out_ch;
1451                 int c_state_out_len      = s->state_out_len;
1452                 int c_nblock_used        = s->nblock_used;
1453                 int c_k0                 = s->k0;
1454                 unsigned int    *c_tt                 = s->tt;
1455                 unsigned int    c_tPos               = s->tPos;
1456                 char    *cs_next_out          = s->strm->next_out;
1457                 unsigned int  cs_avail_out         = s->strm->avail_out;
1458                 /* end restore */
1459
1460                 int        s_save_nblockPP = s->save_nblock+1;
1461
1462                 while (1) {
1463                         /* try to finish existing run */
1464                         if (c_state_out_len > 0) {
1465                                 while (TRUE) {
1466                                         if (cs_avail_out == 0) {
1467                                                 goto return_notr;
1468                                         }
1469                                         if (c_state_out_len == 1) {
1470                                                 break;
1471                                         }
1472                                         *((unsigned char *)(cs_next_out)) = c_state_out_ch;
1473                                         c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
1474                                                 BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
1475                                                 ((unsigned char)c_state_out_ch)];
1476                                         c_state_out_len--;
1477                                         cs_next_out++;
1478                                         cs_avail_out--;
1479                                 }
1480 s_state_out_len_eq_one:
1481                                 {
1482                                         if (cs_avail_out == 0) {
1483                                                 c_state_out_len = 1;
1484                                                 goto return_notr;
1485                                         }
1486                                         *((unsigned char *)(cs_next_out)) = c_state_out_ch;
1487                                         c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
1488                                                 BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
1489                                                 ((unsigned char)c_state_out_ch)];
1490                                         cs_next_out++;
1491                                         cs_avail_out--;
1492                                 }
1493                         }
1494                         /* can a new run be started? */
1495                         if (c_nblock_used == s_save_nblockPP) {
1496                                 c_state_out_len = 0; goto return_notr;
1497                         }
1498                         c_state_out_ch = c_k0;
1499                         c_tPos = c_tt[c_tPos];
1500                         k1 = (unsigned char)(c_tPos & 0xff);
1501                         c_tPos >>= 8;
1502
1503                         c_nblock_used++;
1504
1505                         if (k1 != c_k0) {
1506                                 c_k0 = k1;
1507                                 goto s_state_out_len_eq_one;
1508                         }
1509
1510                         if (c_nblock_used == s_save_nblockPP) {
1511                                 goto s_state_out_len_eq_one;
1512                         }
1513
1514                         c_state_out_len = 2;
1515                         c_tPos = c_tt[c_tPos];
1516                         k1 = (unsigned char)(c_tPos & 0xff);
1517                         c_tPos >>= 8;
1518
1519                         c_nblock_used++;
1520                         if (c_nblock_used == s_save_nblockPP) {
1521                                 continue;
1522                         }
1523                         if (k1 != c_k0) {
1524                                 c_k0 = k1;
1525                                 continue;
1526                         }
1527
1528                         c_state_out_len = 3;
1529                         c_tPos = c_tt[c_tPos];
1530                         k1 = (unsigned char)(c_tPos & 0xff);
1531                         c_tPos >>= 8;
1532
1533                         c_nblock_used++;
1534                         if (c_nblock_used == s_save_nblockPP) {
1535                                 continue;
1536                         }
1537                         if (k1 != c_k0) {
1538                                 c_k0 = k1;
1539                                 continue;
1540                         }
1541
1542                         c_tPos = c_tt[c_tPos];
1543                         k1 = (unsigned char)(c_tPos & 0xff);
1544                         c_tPos >>= 8;
1545
1546                         c_nblock_used++;
1547                         c_state_out_len = ((int)k1) + 4;
1548
1549                         c_tPos = c_tt[c_tPos];
1550                         c_k0 = (unsigned char)(c_tPos & 0xff);
1551                         c_tPos >>= 8;
1552
1553                         c_nblock_used++;
1554                 }
1555
1556 return_notr:
1557
1558                 /* save */
1559                 s->calculatedBlockCRC = c_calculatedBlockCRC;
1560                 s->state_out_ch       = c_state_out_ch;
1561                 s->state_out_len      = c_state_out_len;
1562                 s->nblock_used        = c_nblock_used;
1563                 s->k0                 = c_k0;
1564                 s->tt                 = c_tt;
1565                 s->tPos               = c_tPos;
1566                 s->strm->next_out     = cs_next_out;
1567                 s->strm->avail_out    = cs_avail_out;
1568                 /* end save */
1569         }
1570 }
1571
1572 int BZ2_bzDecompress(bz_stream *strm)
1573 {
1574         DState* s;
1575         s = strm->state;
1576
1577         while (1) {
1578                 if (s->state == BZ_X_IDLE) {
1579                         return BZ_SEQUENCE_ERROR;
1580                 }
1581                 if (s->state == BZ_X_OUTPUT) {
1582                         unRLE_obuf_to_output_FAST(s);
1583                         if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
1584                                 s->calculatedBlockCRC = ~(s->calculatedBlockCRC);
1585                                 if (s->calculatedBlockCRC != s->storedBlockCRC) {
1586                                         return BZ_DATA_ERROR;
1587                                 }
1588                                 s->calculatedCombinedCRC = (s->calculatedCombinedCRC << 1) | (s->calculatedCombinedCRC >> 31);
1589                                 s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
1590                                 s->state = BZ_X_BLKHDR_1;
1591                         } else {
1592                                 return BZ_OK;
1593                         }
1594                 }
1595                 if (s->state >= BZ_X_MAGIC_1) {
1596                         int r = BZ2_decompress(s);
1597                         if (r == BZ_STREAM_END) {
1598                                 if (s->calculatedCombinedCRC != s->storedCombinedCRC) {
1599                                         return BZ_DATA_ERROR;
1600                                 }
1601                                 return r;
1602                         }
1603                         if (s->state != BZ_X_OUTPUT) {
1604                                 return r;
1605                         }
1606                 }
1607         }
1608
1609         return(0);  /*NOTREACHED*/
1610 }
1611
1612 int BZ2_bzRead(int *bzerror, void *b, void *buf, int len)
1613 {
1614         int n, ret;
1615         bzFile *bzf = (bzFile*)b;
1616
1617         bz_seterr(BZ_OK, bzerror, &bzf);
1618
1619         if (len == 0) {
1620                 bz_seterr(BZ_OK, bzerror, &bzf);
1621                 return 0;
1622         }
1623
1624         bzf->strm.avail_out = len;
1625         bzf->strm.next_out = buf;
1626
1627         while (1) {
1628                 if (ferror(bzf->handle)) {
1629                         bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
1630                         return 0;
1631                 }
1632                 if ((bzf->strm.avail_in == 0) && !myfeof(bzf->handle)) {
1633                         n = fread(bzf->buf, sizeof(unsigned char), BZ_MAX_UNUSED, bzf->handle);
1634                         if (ferror(bzf->handle)) {
1635                                 bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
1636                                 return 0;
1637                         }
1638                         bzf->bufN = n;
1639                         bzf->strm.avail_in = bzf->bufN;
1640                         bzf->strm.next_in = bzf->buf;
1641                 }
1642
1643                 ret = BZ2_bzDecompress(&(bzf->strm));
1644
1645                 if ((ret != BZ_OK) && (ret != BZ_STREAM_END)) {
1646                         bz_seterr(ret, bzerror, &bzf);
1647                         return 0;
1648                 }
1649
1650                 if ((ret == BZ_OK) && myfeof(bzf->handle) &&
1651                         (bzf->strm.avail_in == 0) && (bzf->strm.avail_out > 0)) {
1652                         bz_seterr(BZ_UNEXPECTED_EOF, bzerror, &bzf);
1653                         return(0);
1654                 }
1655
1656                 if (ret == BZ_STREAM_END) {
1657                         bz_seterr(BZ_STREAM_END, bzerror, &bzf);
1658                         return(len - bzf->strm.avail_out);
1659                 }
1660                 if (bzf->strm.avail_out == 0) {
1661                         bz_seterr(BZ_OK, bzerror, &bzf);
1662                         return(len);
1663                 }
1664         }
1665         return(0); /*not reached*/
1666 }
1667
1668 void *BZ2_bzReadOpen(int *bzerror, FILE *f, void *unused, int nUnused)
1669 {
1670         bzFile *bzf = xmalloc(sizeof(bzFile));
1671         int ret;
1672
1673         bz_seterr(BZ_OK, bzerror, &bzf);
1674
1675         bzf->initialisedOk = FALSE;
1676         bzf->handle        = f;
1677         bzf->bufN          = 0;
1678
1679         ret = BZ2_bzDecompressInit(&(bzf->strm));
1680         if (ret != BZ_OK) {
1681                 bz_seterr(ret, bzerror, &bzf);
1682                 free(bzf);
1683                 return NULL;
1684         }
1685
1686         while (nUnused > 0) {
1687                 bzf->buf[bzf->bufN] = *((unsigned char *)(unused)); bzf->bufN++;
1688                 unused = ((void *)( 1 + ((unsigned char *)(unused))  ));
1689                 nUnused--;
1690         }
1691         bzf->strm.avail_in = bzf->bufN;
1692         bzf->strm.next_in  = bzf->buf;
1693
1694         bzf->initialisedOk = TRUE;
1695         return bzf;
1696 }
1697
1698 static unsigned char uncompressStream(FILE *zStream, FILE *stream)
1699 {
1700         unsigned char unused[BZ_MAX_UNUSED];
1701         unsigned char *unusedTmp;
1702         unsigned char obuf[5000];
1703         bzFile *bzf = NULL;
1704         int bzerr_dummy;
1705         int bzerr;
1706         int nread;
1707         int nUnused;
1708         int streamNo;
1709         int ret;
1710         int i;
1711
1712         nUnused = 0;
1713         streamNo = 0;
1714
1715         if (ferror(stream)) {
1716                 goto errhandler_io;
1717         }
1718         if (ferror(zStream)) {
1719                 goto errhandler_io;
1720         }
1721
1722         while(1) {
1723                 bzf = BZ2_bzReadOpen(&bzerr, zStream, unused, nUnused);
1724                 if (bzf == NULL || bzerr != BZ_OK) {
1725                         goto errhandler;
1726                 }
1727                 streamNo++;
1728
1729                 while (bzerr == BZ_OK) {
1730                         nread = BZ2_bzRead(&bzerr, bzf, obuf, 5000);
1731                         if (bzerr == BZ_DATA_ERROR_MAGIC) {
1732                                 goto errhandler;
1733                         }
1734                         if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0) {
1735                                 fwrite(obuf, sizeof(unsigned char), nread, stream);
1736                         }
1737                         if (ferror(stream)) {
1738                                 goto errhandler_io;
1739                         }
1740                 }
1741                 if (bzerr != BZ_STREAM_END) {
1742                         goto errhandler;
1743                 }
1744                 nUnused = bzf->strm.avail_in;
1745                 unusedTmp = bzf->strm.next_in;
1746                 bz_seterr(BZ_OK, &bzerr, &bzf);
1747                 for (i = 0; i < nUnused; i++) {
1748                         unused[i] = unusedTmp[i];
1749                 }
1750                 BZ2_bzReadClose(&bzerr, bzf);
1751                 if ((nUnused == 0) && myfeof(zStream)) {
1752                         break;
1753                 }
1754         }
1755
1756         if (ferror(zStream)) {
1757                 goto errhandler_io;
1758         }
1759         ret = fclose(zStream);
1760         if (ret == EOF) {
1761                 goto errhandler_io;
1762         }
1763         if (ferror(stream)) {
1764                 goto errhandler_io;
1765         }
1766         ret = fflush(stream);
1767         if (ret != 0) {
1768                 goto errhandler_io;
1769         }
1770         if (stream != stdout) {
1771                 ret = fclose(stream);
1772                 if (ret == EOF) {
1773                         goto errhandler_io;
1774                 }
1775         }
1776         return TRUE;
1777
1778 errhandler:
1779         BZ2_bzReadClose ( &bzerr_dummy, bzf );
1780         switch (bzerr) {
1781                 case BZ_IO_ERROR:
1782 errhandler_io:
1783                         error_msg("\n%s: I/O or other error, bailing out.  "
1784                                 "Possible reason follows.\n", applet_name);
1785                         perror(applet_name);
1786                         cleanUpAndFail(1);
1787                 case BZ_DATA_ERROR:
1788                         error_msg("\n%s: Data integrity error when decompressing.\n", applet_name);
1789                         cleanUpAndFail(2);
1790                 case BZ_UNEXPECTED_EOF:
1791                         error_msg("\n%s: Compressed file ends unexpectedly;\n\t"
1792                                 "perhaps it is corrupted?  *Possible* reason follows.\n", applet_name);
1793                         perror(applet_name);
1794                         cleanUpAndFail(2);
1795                 case BZ_DATA_ERROR_MAGIC:
1796                         if (zStream != stdin) {
1797                                 fclose(zStream);
1798                         }
1799                         if (stream != stdout) {
1800                                 fclose(stream);
1801                         }
1802                         if (streamNo == 1) {
1803                                 return FALSE;
1804                         } else {
1805                                 return TRUE;
1806                         }
1807         }
1808
1809         return(TRUE); /*notreached*/
1810 }
1811
1812 int bunzip2_main(int argc, char **argv)
1813 {
1814         const int bunzip_to_stdout = 1;
1815         const int bunzip_force = 2;
1816         int flags = 0;
1817         int opt = 0;
1818         int status;
1819
1820         FILE *src_stream;
1821         FILE *dst_stream;
1822         char *save_name = NULL;
1823         char *delete_name = NULL;
1824
1825         /* if called as bzcat */
1826         if (strcmp(applet_name, "bzcat") == 0)
1827                 flags |= bunzip_to_stdout;
1828
1829         while ((opt = getopt(argc, argv, "cfh")) != -1) {
1830                 switch (opt) {
1831                 case 'c':
1832                         flags |= bunzip_to_stdout;
1833                         break;
1834                 case 'f':
1835                         flags |= bunzip_force;
1836                         break;
1837                 case 'h':
1838                 default:
1839                         show_usage(); /* exit's inside usage */
1840                 }
1841         }
1842
1843         /* Set input filename and number */
1844         if (argv[optind] == NULL || strcmp(argv[optind], "-") == 0) {
1845                 flags |= bunzip_to_stdout;
1846                 src_stream = stdin;
1847         } else {
1848                 /* Open input file */
1849                 src_stream = xfopen(argv[optind], "r");
1850
1851                 save_name = xstrdup(argv[optind]);
1852                 if (strcmp(save_name + strlen(save_name) - 4, ".bz2") != 0)
1853                         error_msg_and_die("Invalid extension");
1854                 save_name[strlen(save_name) - 4] = '\0';
1855         }
1856
1857         /* Check that the input is sane.  */
1858         if (isatty(fileno(src_stream)) && (flags & bunzip_force) == 0)
1859                 error_msg_and_die("compressed data not read from terminal.  Use -f to force it.");
1860
1861         if (flags & bunzip_to_stdout) {
1862                 dst_stream = stdout;
1863         } else {
1864                 dst_stream = xfopen(save_name, "w");
1865         }
1866
1867         if (uncompressStream(src_stream, dst_stream)) {
1868                 if (!(flags & bunzip_to_stdout))
1869                         delete_name = argv[optind];
1870                 status = EXIT_SUCCESS;
1871         } else {
1872                 if (!(flags & bunzip_to_stdout))
1873                         delete_name = save_name;
1874                 status = EXIT_FAILURE;
1875         }
1876
1877         if (delete_name) {
1878                 if (unlink(delete_name) < 0) {
1879                         error_msg_and_die("Couldn't remove %s", delete_name);
1880                 }
1881         }
1882
1883         return status;
1884 }