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