1
2 /*-------------------------------------------------------------*/
3 /*--- Library top-level functions. ---*/
4 /*--- bzlib.c ---*/
5 /*-------------------------------------------------------------*/
6
7 /* ------------------------------------------------------------------
8 This file is part of bzip2/libbzip2, a program and library for
9 lossless, block-sorting data compression.
10
11 bzip2/libbzip2 version 1.0.4 of 20 December 2006
12 Copyright (C) 1996-2006 Julian Seward <jseward@bzip.org>
13 This file was modified for ClamAV by aCaB <acab@clamav.net>
14
15 This program is released under the terms of the license contained
16 in the file COPYING.bzip2.
17 ------------------------------------------------------------------ */
18
19 /* CHANGES
20 0.9.0 -- original version.
21 0.9.0a/b -- no changes in this file.
22 0.9.0c -- made zero-length BZ_FLUSH work correctly in bzCompress().
23 fixed bzWrite/bzRead to ignore zero-length requests.
24 fixed bzread to correctly handle read requests after EOF.
25 wrong parameter order in call to bzDecompressInit in
26 bzBuffToBuffDecompress. Fixed.
27 */
28
29 #if HAVE_CONFIG_H
30 #include "clamav-config.h"
31 #endif
32
33 #include "clamav.h"
34 #include "bzlib_private.h"
35 #include "others.h"
36
37 /*---------------------------------------------------*/
38 static
makeMaps_d(DState * s)39 void makeMaps_d ( DState* s )
40 {
41 Int32 i;
42 s->nInUse = 0;
43 for (i = 0; i < 256; i++)
44 if (s->inUse[i]) {
45 s->seqToUnseq[s->nInUse] = i;
46 s->nInUse++;
47 }
48 }
49
50
51 /*---------------------------------------------------*/
52 #define RETURN(rrr) \
53 { retVal = rrr; goto save_state_and_return; };
54
55 #define GET_BITS(lll,vvv,nnn) \
56 case lll: s->state = lll; \
57 while (True) { \
58 if (s->bsLive >= nnn) { \
59 UInt32 v; \
60 v = (s->bsBuff >> \
61 (s->bsLive-nnn)) & ((1 << nnn)-1); \
62 s->bsLive -= nnn; \
63 vvv = v; \
64 break; \
65 } \
66 if (s->strm->avail_in == 0) RETURN(BZ_OK); \
67 s->bsBuff \
68 = (s->bsBuff << 8) | \
69 ((UInt32) \
70 (*(s->strm->next_in))); \
71 s->bsLive += 8; \
72 s->strm->next_in++; \
73 s->strm->avail_in--; \
74 s->strm->total_in_lo32++; \
75 if (s->strm->total_in_lo32 == 0) \
76 s->strm->total_in_hi32++; \
77 }
78
79 #define GET_UCHAR(lll,uuu) \
80 GET_BITS(lll,uuu,8)
81
82 #define GET_BIT(lll,uuu) \
83 GET_BITS(lll,uuu,1)
84
85 /*---------------------------------------------------*/
86 #define GET_MTF_VAL(label1,label2,lval) \
87 { \
88 if (groupPos == 0) { \
89 groupNo++; \
90 if (groupNo >= nSelectors) \
91 RETURN(BZ_DATA_ERROR); \
92 groupPos = BZ_G_SIZE; \
93 gSel = s->selector[groupNo]; \
94 gMinlen = s->minLens[gSel]; \
95 gLimit = &(s->limit[gSel][0]); \
96 gPerm = &(s->perm[gSel][0]); \
97 gBase = &(s->base[gSel][0]); \
98 } \
99 groupPos--; \
100 zn = gMinlen; \
101 GET_BITS(label1, zvec, zn); \
102 while (1) { \
103 if (zn > 20 /* the longest code */) \
104 RETURN(BZ_DATA_ERROR); \
105 if (zvec <= gLimit[zn]) break; \
106 zn++; \
107 GET_BIT(label2, zj); \
108 zvec = (zvec << 1) | zj; \
109 }; \
110 if (zvec - gBase[zn] < 0 \
111 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) \
112 RETURN(BZ_DATA_ERROR); \
113 lval = gPerm[zvec - gBase[zn]]; \
114 }
115
116 /*---------------------------------------------------*/
117
indexIntoF(Int32 indx,Int32 * cftab)118 inline static Int32 indexIntoF ( Int32 indx, Int32 *cftab )
119 {
120 Int32 nb, na, mid;
121 nb = 0;
122 na = 256;
123 do {
124 mid = (nb + na) >> 1;
125 if (indx >= cftab[mid]) nb = mid; else na = mid;
126 }
127 while (na - nb != 1);
128 return nb;
129 }
130
131 /*---------------------------------------------------*/
132 /* Return True iff data corruption is discovered.
133 Returns False if there is no problem.
134 */
135 static
unRLE_obuf_to_output_FAST(DState * s)136 Bool unRLE_obuf_to_output_FAST ( DState* s )
137 {
138 UChar k1;
139
140 /* if (s->blockRandomised) { */
141
142 /* while (True) { */
143 /* /\* try to finish existing run *\/ */
144 /* while (True) { */
145 /* if (s->strm->avail_out == 0) return False; */
146 /* if (s->state_out_len == 0) break; */
147 /* *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; */
148 /* BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); */
149 /* s->state_out_len--; */
150 /* s->strm->next_out++; */
151 /* s->strm->avail_out--; */
152 /* s->strm->total_out_lo32++; */
153 /* if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; */
154 /* } */
155
156 /* /\* can a new run be started? *\/ */
157 /* if (s->nblock_used == s->save_nblock+1) return False; */
158
159 /* /\* Only caused by corrupt data stream? *\/ */
160 /* if (s->nblock_used > s->save_nblock+1) */
161 /* return True; */
162
163 /* s->state_out_len = 1; */
164 /* s->state_out_ch = s->k0; */
165 /* BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; */
166
167
168
169 /* k1 ^= BZ_RAND_MASK; s->nblock_used++; */
170 /* if (s->nblock_used == s->save_nblock+1) continue; */
171 /* if (k1 != s->k0) { s->k0 = k1; continue; }; */
172
173 /* s->state_out_len = 2; */
174 /* BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; */
175 /* k1 ^= BZ_RAND_MASK; s->nblock_used++; */
176 /* if (s->nblock_used == s->save_nblock+1) continue; */
177 /* if (k1 != s->k0) { s->k0 = k1; continue; }; */
178
179 /* s->state_out_len = 3; */
180 /* BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; */
181 /* k1 ^= BZ_RAND_MASK; s->nblock_used++; */
182 /* if (s->nblock_used == s->save_nblock+1) continue; */
183 /* if (k1 != s->k0) { s->k0 = k1; continue; }; */
184
185 /* BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; */
186 /* k1 ^= BZ_RAND_MASK; s->nblock_used++; */
187 /* s->state_out_len = ((Int32)k1) + 4; */
188 /* BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK; */
189 /* s->k0 ^= BZ_RAND_MASK; s->nblock_used++; */
190 /* } */
191
192 /* } else */ {
193
194 /* restore */
195 UInt32 c_calculatedBlockCRC = s->calculatedBlockCRC;
196 UChar c_state_out_ch = s->state_out_ch;
197 Int32 c_state_out_len = s->state_out_len;
198 Int32 c_nblock_used = s->nblock_used;
199 Int32 c_k0 = s->k0;
200 UInt32* c_tt = s->tt;
201 UInt32 c_tPos = s->tPos;
202 UChar* cs_next_out = s->strm->next_out;
203 unsigned int cs_avail_out = s->strm->avail_out;
204 Int32 ro_blockSize100k = s->blockSize100k;
205 /* end restore */
206
207 UInt32 avail_out_INIT = cs_avail_out;
208 Int32 s_save_nblockPP = s->save_nblock+1;
209 unsigned int total_out_lo32_old;
210
211 while (True) {
212
213 /* try to finish existing run */
214 if (c_state_out_len > 0) {
215 while (True) {
216 if (cs_avail_out == 0) goto return_notr;
217 if (c_state_out_len == 1) break;
218 *cs_next_out = c_state_out_ch;
219 /* aCaB BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ); */
220 c_state_out_len--;
221 cs_next_out++;
222 cs_avail_out--;
223 }
224 s_state_out_len_eq_one:
225 {
226 if (cs_avail_out == 0) {
227 c_state_out_len = 1; goto return_notr;
228 };
229 *cs_next_out = c_state_out_ch;
230 /* aCaB BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ); */
231 cs_next_out++;
232 cs_avail_out--;
233 }
234 }
235 /* Only caused by corrupt data stream? */
236 if (c_nblock_used > s_save_nblockPP)
237 return True;
238
239 /* can a new run be started? */
240 if (c_nblock_used == s_save_nblockPP) {
241 c_state_out_len = 0; goto return_notr;
242 };
243 c_state_out_ch = c_k0;
244 BZ_GET_FAST_C(k1); c_nblock_used++;
245 if (k1 != c_k0) {
246 c_k0 = k1; goto s_state_out_len_eq_one;
247 };
248 if (c_nblock_used == s_save_nblockPP)
249 goto s_state_out_len_eq_one;
250
251 c_state_out_len = 2;
252 BZ_GET_FAST_C(k1); c_nblock_used++;
253 if (c_nblock_used == s_save_nblockPP) continue;
254 if (k1 != c_k0) { c_k0 = k1; continue; };
255
256 c_state_out_len = 3;
257 BZ_GET_FAST_C(k1); c_nblock_used++;
258 if (c_nblock_used == s_save_nblockPP) continue;
259 if (k1 != c_k0) { c_k0 = k1; continue; };
260
261 BZ_GET_FAST_C(k1); c_nblock_used++;
262 c_state_out_len = ((Int32)k1) + 4;
263 BZ_GET_FAST_C(c_k0); c_nblock_used++;
264 }
265
266 return_notr:
267 total_out_lo32_old = s->strm->total_out_lo32;
268 s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
269 if (s->strm->total_out_lo32 < total_out_lo32_old)
270 s->strm->total_out_hi32++;
271
272 /* save */
273 s->calculatedBlockCRC = c_calculatedBlockCRC;
274 s->state_out_ch = c_state_out_ch;
275 s->state_out_len = c_state_out_len;
276 s->nblock_used = c_nblock_used;
277 s->k0 = c_k0;
278 s->tt = c_tt;
279 s->tPos = c_tPos;
280 s->strm->next_out = cs_next_out;
281 s->strm->avail_out = cs_avail_out;
282 /* end save */
283 }
284 return False;
285 }
286
287
288 /*---------------------------------------------------*/
289 /* Return True iff data corruption is discovered.
290 Returns False if there is no problem.
291 */
292 static
unRLE_obuf_to_output_SMALL(DState * s)293 Bool unRLE_obuf_to_output_SMALL ( DState* s )
294 {
295 UChar k1;
296
297 /* if (s->blockRandomised) { */
298
299 /* while (True) { */
300 /* /\* try to finish existing run *\/ */
301 /* while (True) { */
302 /* if (s->strm->avail_out == 0) return False; */
303 /* if (s->state_out_len == 0) break; */
304 /* *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; */
305 /* BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); */
306 /* s->state_out_len--; */
307 /* s->strm->next_out++; */
308 /* s->strm->avail_out--; */
309 /* s->strm->total_out_lo32++; */
310 /* if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; */
311 /* } */
312
313 /* /\* can a new run be started? *\/ */
314 /* if (s->nblock_used == s->save_nblock+1) return False; */
315
316 /* /\* Only caused by corrupt data stream? *\/ */
317 /* if (s->nblock_used > s->save_nblock+1) */
318 /* return True; */
319
320 /* s->state_out_len = 1; */
321 /* s->state_out_ch = s->k0; */
322 /* BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; */
323 /* k1 ^= BZ_RAND_MASK; s->nblock_used++; */
324 /* if (s->nblock_used == s->save_nblock+1) continue; */
325 /* if (k1 != s->k0) { s->k0 = k1; continue; }; */
326
327 /* s->state_out_len = 2; */
328 /* BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; */
329 /* k1 ^= BZ_RAND_MASK; s->nblock_used++; */
330 /* if (s->nblock_used == s->save_nblock+1) continue; */
331 /* if (k1 != s->k0) { s->k0 = k1; continue; }; */
332
333 /* s->state_out_len = 3; */
334 /* BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; */
335 /* k1 ^= BZ_RAND_MASK; s->nblock_used++; */
336 /* if (s->nblock_used == s->save_nblock+1) continue; */
337 /* if (k1 != s->k0) { s->k0 = k1; continue; }; */
338
339 /* BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; */
340 /* k1 ^= BZ_RAND_MASK; s->nblock_used++; */
341 /* s->state_out_len = ((Int32)k1) + 4; */
342 /* BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK; */
343 /* s->k0 ^= BZ_RAND_MASK; s->nblock_used++; */
344 /* } */
345
346 /* } else */ {
347
348 while (True) {
349 /* try to finish existing run */
350 while (True) {
351 if (s->strm->avail_out == 0) return False;
352 if (s->state_out_len == 0) break;
353 *(s->strm->next_out) = s->state_out_ch;
354 /* aCaB BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); */
355 s->state_out_len--;
356 s->strm->next_out++;
357 s->strm->avail_out--;
358 s->strm->total_out_lo32++;
359 if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
360 }
361
362 /* can a new run be started? */
363 if (s->nblock_used == s->save_nblock+1) return False;
364
365 /* Only caused by corrupt data stream? */
366 if (s->nblock_used > s->save_nblock+1)
367 return True;
368
369 s->state_out_len = 1;
370 s->state_out_ch = s->k0;
371 BZ_GET_SMALL(k1); s->nblock_used++;
372 if (s->nblock_used == s->save_nblock+1) continue;
373 if (k1 != s->k0) { s->k0 = k1; continue; };
374
375 s->state_out_len = 2;
376 BZ_GET_SMALL(k1); s->nblock_used++;
377 if (s->nblock_used == s->save_nblock+1) continue;
378 if (k1 != s->k0) { s->k0 = k1; continue; };
379
380 s->state_out_len = 3;
381 BZ_GET_SMALL(k1); s->nblock_used++;
382 if (s->nblock_used == s->save_nblock+1) continue;
383 if (k1 != s->k0) { s->k0 = k1; continue; };
384
385 BZ_GET_SMALL(k1); s->nblock_used++;
386 s->state_out_len = ((Int32)k1) + 4;
387 BZ_GET_SMALL(s->k0); s->nblock_used++;
388 }
389
390 }
391 }
392 /*---------------------------------------------------*/
393
CreateDecodeTables(Int32 * limit,Int32 * base,Int32 * perm,UChar * length,Int32 minLen,Int32 maxLen,Int32 alphaSize)394 static void CreateDecodeTables ( Int32 *limit,
395 Int32 *base,
396 Int32 *perm,
397 UChar *length,
398 Int32 minLen,
399 Int32 maxLen,
400 Int32 alphaSize )
401 {
402 Int32 pp, i, j, vec;
403
404 pp = 0;
405 for (i = minLen; i <= maxLen; i++)
406 for (j = 0; j < alphaSize; j++)
407 if (length[j] == i) { perm[pp] = j; pp++; };
408
409 for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0;
410 for (i = 0; i < alphaSize; i++) base[length[i]+1]++;
411
412 for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1];
413
414 for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0;
415 vec = 0;
416
417 for (i = minLen; i <= maxLen; i++) {
418 vec += (base[i+1] - base[i]);
419 limit[i] = vec-1;
420 vec <<= 1;
421 }
422 for (i = minLen + 1; i <= maxLen; i++)
423 base[i] = ((limit[i-1] + 1) << 1) - base[i];
424 }
425
426 /*---------------------------------------------------*/
BZ2_decompress(DState * s)427 static Int32 BZ2_decompress ( DState* s )
428 {
429 UChar uc;
430 Int32 retVal;
431 Int32 minLen, maxLen;
432 nsis_bzstream* strm = s->strm;
433
434 /* stuff that needs to be saved/restored */
435 Int32 i;
436 Int32 j;
437 Int32 t;
438 Int32 alphaSize;
439 Int32 nGroups;
440 Int32 nSelectors;
441 Int32 EOB;
442 Int32 groupNo;
443 Int32 groupPos;
444 Int32 nextSym;
445 Int32 nblockMAX;
446 Int32 nblock;
447 Int32 es;
448 Int32 N;
449 Int32 curr;
450 Int32 zt;
451 Int32 zn;
452 Int32 zvec;
453 Int32 zj;
454 Int32 gSel;
455 Int32 gMinlen;
456 Int32* gLimit;
457 Int32* gBase;
458 Int32* gPerm;
459
460 if (s->state == BZ_X_MAGIC_1) {
461 /*initialise the save area*/
462 s->save_i = 0;
463 s->save_j = 0;
464 s->save_t = 0;
465 s->save_alphaSize = 0;
466 s->save_nGroups = 0;
467 s->save_nSelectors = 0;
468 s->save_EOB = 0;
469 s->save_groupNo = 0;
470 s->save_groupPos = 0;
471 s->save_nextSym = 0;
472 s->save_nblockMAX = 0;
473 s->save_nblock = 0;
474 s->save_es = 0;
475 s->save_N = 0;
476 s->save_curr = 0;
477 s->save_zt = 0;
478 s->save_zn = 0;
479 s->save_zvec = 0;
480 s->save_zj = 0;
481 s->save_gSel = 0;
482 s->save_gMinlen = 0;
483 s->save_gLimit = NULL;
484 s->save_gBase = NULL;
485 s->save_gPerm = NULL;
486 }
487
488 /*restore from the save area*/
489 i = s->save_i;
490 j = s->save_j;
491 t = s->save_t;
492 alphaSize = s->save_alphaSize;
493 nGroups = s->save_nGroups;
494 nSelectors = s->save_nSelectors;
495 EOB = s->save_EOB;
496 groupNo = s->save_groupNo;
497 groupPos = s->save_groupPos;
498 nextSym = s->save_nextSym;
499 nblockMAX = s->save_nblockMAX;
500 nblock = s->save_nblock;
501 es = s->save_es;
502 N = s->save_N;
503 curr = s->save_curr;
504 zt = s->save_zt;
505 zn = s->save_zn;
506 zvec = s->save_zvec;
507 zj = s->save_zj;
508 gSel = s->save_gSel;
509 gMinlen = s->save_gMinlen;
510 gLimit = s->save_gLimit;
511 gBase = s->save_gBase;
512 gPerm = s->save_gPerm;
513
514 retVal = BZ_OK;
515
516 switch (s->state) {
517
518 /* aCaB
519 GET_UCHAR(BZ_X_MAGIC_1, uc);
520 if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);
521
522 GET_UCHAR(BZ_X_MAGIC_2, uc);
523 if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);
524
525 GET_UCHAR(BZ_X_MAGIC_3, uc)
526 if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);
527
528 GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
529 if (s->blockSize100k < (BZ_HDR_0 + 1) ||
530 s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
531 s->blockSize100k -= BZ_HDR_0;
532 */
533
534 case BZ_X_MAGIC_1:
535
536 s->blockSize100k = 9;
537
538 if (s->smallDecompress) {
539 s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
540 s->ll4 = BZALLOC(
541 ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
542 );
543 if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
544 } else {
545 s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
546 if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
547 }
548
549 GET_UCHAR(BZ_X_BLKHDR_1, uc);
550
551 if (uc == 0x17) goto endhdr_2;
552 if (uc != 0x31) RETURN(BZ_DATA_ERROR);
553
554 /* aCaB
555 GET_UCHAR(BZ_X_BLKHDR_2, uc);
556 if (uc != 0x41) RETURN(BZ_DATA_ERROR);
557 GET_UCHAR(BZ_X_BLKHDR_3, uc);
558 if (uc != 0x59) RETURN(BZ_DATA_ERROR);
559 GET_UCHAR(BZ_X_BLKHDR_4, uc);
560 if (uc != 0x26) RETURN(BZ_DATA_ERROR);
561 GET_UCHAR(BZ_X_BLKHDR_5, uc);
562 if (uc != 0x53) RETURN(BZ_DATA_ERROR);
563 GET_UCHAR(BZ_X_BLKHDR_6, uc);
564 if (uc != 0x59) RETURN(BZ_DATA_ERROR);
565
566 s->currBlockNo++;
567 if (s->verbosity >= 2)
568 VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo );
569
570 s->storedBlockCRC = 0;
571 GET_UCHAR(BZ_X_BCRC_1, uc);
572 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
573 GET_UCHAR(BZ_X_BCRC_2, uc);
574 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
575 GET_UCHAR(BZ_X_BCRC_3, uc);
576 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
577 GET_UCHAR(BZ_X_BCRC_4, uc);
578 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
579
580
581 GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);
582 */
583
584 s->origPtr = 0;
585 GET_UCHAR(BZ_X_ORIGPTR_1, uc);
586 s->origPtr = (s->origPtr << 8) | ((Int32)uc);
587 GET_UCHAR(BZ_X_ORIGPTR_2, uc);
588 s->origPtr = (s->origPtr << 8) | ((Int32)uc);
589 GET_UCHAR(BZ_X_ORIGPTR_3, uc);
590 s->origPtr = (s->origPtr << 8) | ((Int32)uc);
591
592 if (s->origPtr < 0)
593 RETURN(BZ_DATA_ERROR);
594 if (s->origPtr > 10 + 100000*s->blockSize100k)
595 RETURN(BZ_DATA_ERROR);
596
597 /*--- Receive the mapping table ---*/
598 for (i = 0; i < 16; i++) {
599 GET_BIT(BZ_X_MAPPING_1, uc);
600 if (uc == 1)
601 s->inUse16[i] = True; else
602 s->inUse16[i] = False;
603 }
604
605 for (i = 0; i < 256; i++) s->inUse[i] = False;
606
607 for (i = 0; i < 16; i++)
608 if (s->inUse16[i])
609 for (j = 0; j < 16; j++) {
610 GET_BIT(BZ_X_MAPPING_2, uc);
611 if (uc == 1) s->inUse[i * 16 + j] = True;
612 }
613 makeMaps_d ( s );
614 if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
615 alphaSize = s->nInUse+2;
616
617 /*--- Now the selectors ---*/
618 GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
619 if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
620 GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
621 if (nSelectors < 1 || nSelectors > BZ_MAX_SELECTORS) RETURN(BZ_DATA_ERROR);
622 for (i = 0; i < nSelectors; i++) {
623 j = 0;
624 while (True) {
625 GET_BIT(BZ_X_SELECTOR_3, uc);
626 if (uc == 0) break;
627 j++;
628 if (j >= nGroups) RETURN(BZ_DATA_ERROR);
629 }
630 s->selectorMtf[i] = j;
631 }
632
633 /*--- Undo the MTF values for the selectors. ---*/
634 {
635 UChar pos[BZ_N_GROUPS], tmp, v;
636 for (v = 0; v < nGroups; v++) pos[v] = v;
637
638 for (i = 0; i < nSelectors; i++) {
639 v = s->selectorMtf[i];
640 tmp = pos[v];
641 while (v > 0) { pos[v] = pos[v-1]; v--; }
642 pos[0] = tmp;
643 s->selector[i] = tmp;
644 }
645 }
646
647 /*--- Now the coding tables ---*/
648 for (t = 0; t < nGroups; t++) {
649 GET_BITS(BZ_X_CODING_1, curr, 5);
650 for (i = 0; i < alphaSize; i++) {
651 while (True) {
652 if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
653 GET_BIT(BZ_X_CODING_2, uc);
654 if (uc == 0) break;
655 GET_BIT(BZ_X_CODING_3, uc);
656 if (uc == 0) curr++; else curr--;
657 }
658 s->len[t][i] = curr;
659 }
660 }
661
662 /*--- Create the Huffman decoding tables ---*/
663 for (t = 0; t < nGroups; t++) {
664 minLen = 32;
665 maxLen = 0;
666 for (i = 0; i < alphaSize; i++) {
667 if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
668 if (s->len[t][i] < minLen) minLen = s->len[t][i];
669 }
670 CreateDecodeTables (
671 &(s->limit[t][0]),
672 &(s->base[t][0]),
673 &(s->perm[t][0]),
674 &(s->len[t][0]),
675 minLen, maxLen, alphaSize
676 );
677 s->minLens[t] = minLen;
678 }
679
680 /*--- Now the MTF values ---*/
681
682 EOB = s->nInUse+1;
683 nblockMAX = 100000 * s->blockSize100k;
684 groupNo = -1;
685 groupPos = 0;
686
687 for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
688
689 /*-- MTF init --*/
690 {
691 Int32 ii, jj, kk;
692 kk = MTFA_SIZE-1;
693 for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
694 for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
695 s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
696 kk--;
697 }
698 s->mtfbase[ii] = kk + 1;
699 }
700 }
701 /*-- end MTF init --*/
702
703 nblock = 0;
704 GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
705
706 while (True) {
707
708 if (nextSym == EOB) break;
709
710 if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
711
712 es = -1;
713 N = 1;
714 do {
715 /* Check that N doesn't get too big, so that es doesn't
716 go negative. The maximum value that can be
717 RUNA/RUNB encoded is equal to the block size (post
718 the initial RLE), viz, 900k, so bounding N at 2
719 million should guard against overflow without
720 rejecting any legitimate inputs. */
721 if (N >= 2*1024*1024) RETURN(BZ_DATA_ERROR);
722 if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
723 if (nextSym == BZ_RUNB) es = es + (1+1) * N;
724 N = N * 2;
725 GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
726 }
727 while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
728
729 es++;
730 uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
731 s->unzftab[uc] += es;
732
733 if (s->smallDecompress)
734 while (es > 0) {
735 if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
736 s->ll16[nblock] = (UInt16)uc;
737 nblock++;
738 es--;
739 }
740 else
741 while (es > 0) {
742 if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
743 s->tt[nblock] = (UInt32)uc;
744 nblock++;
745 es--;
746 };
747
748 continue;
749
750 } else {
751
752 if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
753
754 /*-- uc = MTF ( nextSym-1 ) --*/
755 {
756 Int32 ii, jj, kk, pp, lno, off;
757 UInt32 nn;
758 nn = (UInt32)(nextSym - 1);
759
760 if (nn < MTFL_SIZE) {
761 /* avoid general-case expense */
762 pp = s->mtfbase[0];
763 uc = s->mtfa[pp+nn];
764 while (nn > 3) {
765 Int32 z = pp+nn;
766 s->mtfa[(z) ] = s->mtfa[(z)-1];
767 s->mtfa[(z)-1] = s->mtfa[(z)-2];
768 s->mtfa[(z)-2] = s->mtfa[(z)-3];
769 s->mtfa[(z)-3] = s->mtfa[(z)-4];
770 nn -= 4;
771 }
772 while (nn > 0) {
773 s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
774 };
775 s->mtfa[pp] = uc;
776 } else {
777 /* general case */
778 lno = nn / MTFL_SIZE;
779 off = nn % MTFL_SIZE;
780 pp = s->mtfbase[lno] + off;
781 uc = s->mtfa[pp];
782 while (pp > s->mtfbase[lno]) {
783 s->mtfa[pp] = s->mtfa[pp-1]; pp--;
784 };
785 s->mtfbase[lno]++;
786 while (lno > 0) {
787 s->mtfbase[lno]--;
788 s->mtfa[s->mtfbase[lno]]
789 = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
790 lno--;
791 }
792 s->mtfbase[0]--;
793 s->mtfa[s->mtfbase[0]] = uc;
794 if (s->mtfbase[0] == 0) {
795 kk = MTFA_SIZE-1;
796 for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
797 for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
798 s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
799 kk--;
800 }
801 s->mtfbase[ii] = kk + 1;
802 }
803 }
804 }
805 }
806 /*-- end uc = MTF ( nextSym-1 ) --*/
807
808 s->unzftab[s->seqToUnseq[uc]]++;
809 if (s->smallDecompress)
810 s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
811 s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]);
812 nblock++;
813
814 GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
815 continue;
816 }
817 }
818
819 /* Now we know what nblock is, we can do a better sanity
820 check on s->origPtr.
821 */
822 if (s->origPtr < 0 || s->origPtr >= nblock)
823 RETURN(BZ_DATA_ERROR);
824
825 /*-- Set up cftab to facilitate generation of T^(-1) --*/
826 /* Check: unzftab entries in range. */
827 for (i = 0; i <= 255; i++) {
828 if (s->unzftab[i] < 0 || s->unzftab[i] > nblock)
829 RETURN(BZ_DATA_ERROR);
830 }
831 /* Actually generate cftab. */
832 s->cftab[0] = 0;
833 for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
834 for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
835 /* Check: cftab entries in range. */
836 for (i = 0; i <= 256; i++) {
837 if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
838 RETURN(BZ_DATA_ERROR);
839 }
840 }
841 /* Check: cftab entries non-descending. */
842 for (i = 1; i <= 256; i++) {
843 if (s->cftab[i-1] > s->cftab[i]) {
844 RETURN(BZ_DATA_ERROR);
845 }
846 }
847
848 s->state_out_len = 0;
849 s->state_out_ch = 0;
850 /* BZ_INITIALISE_CRC ( s->calculatedBlockCRC ); */
851 s->state = BZ_X_OUTPUT;
852 if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
853
854 if (s->smallDecompress) {
855
856 /*-- Make a copy of cftab, used in generation of T --*/
857 for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
858
859 /*-- compute the T vector --*/
860 for (i = 0; i < nblock; i++) {
861 uc = (UChar)(s->ll16[i]);
862 SET_LL(i, s->cftabCopy[uc]);
863 s->cftabCopy[uc]++;
864 }
865
866 /*-- Compute T^(-1) by pointer reversal on T --*/
867 i = s->origPtr;
868 j = GET_LL(i);
869 do {
870 Int32 tmp = GET_LL(j);
871 SET_LL(j, i);
872 i = j;
873 j = tmp;
874 }
875 while (i != s->origPtr);
876
877 s->tPos = s->origPtr;
878 s->nblock_used = 0;
879 /* aCaB
880 if (s->blockRandomised) {
881 BZ_RAND_INIT_MASK;
882 BZ_GET_SMALL(s->k0); s->nblock_used++;
883 BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
884 } else */{
885 BZ_GET_SMALL(s->k0); s->nblock_used++;
886 }
887
888 } else {
889
890 /*-- compute the T^(-1) vector --*/
891 for (i = 0; i < nblock; i++) {
892 uc = (UChar)(s->tt[i] & 0xff);
893 s->tt[s->cftab[uc]] |= (i << 8);
894 s->cftab[uc]++;
895 }
896
897 s->tPos = s->tt[s->origPtr] >> 8;
898 s->nblock_used = 0;
899 /* aCaB
900 if (s->blockRandomised) {
901 BZ_RAND_INIT_MASK;
902 BZ_GET_FAST(s->k0); s->nblock_used++;
903 BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
904 } else */{
905 BZ_GET_FAST(s->k0); s->nblock_used++;
906 }
907
908 }
909
910 RETURN(BZ_OK);
911
912
913
914 endhdr_2:
915 /* aCaB
916 GET_UCHAR(BZ_X_ENDHDR_2, uc);
917 if (uc != 0x72) RETURN(BZ_DATA_ERROR);
918 GET_UCHAR(BZ_X_ENDHDR_3, uc);
919 if (uc != 0x45) RETURN(BZ_DATA_ERROR);
920 GET_UCHAR(BZ_X_ENDHDR_4, uc);
921 if (uc != 0x38) RETURN(BZ_DATA_ERROR);
922 GET_UCHAR(BZ_X_ENDHDR_5, uc);
923 if (uc != 0x50) RETURN(BZ_DATA_ERROR);
924 GET_UCHAR(BZ_X_ENDHDR_6, uc);
925 if (uc != 0x90) RETURN(BZ_DATA_ERROR);
926
927 s->storedCombinedCRC = 0;
928 GET_UCHAR(BZ_X_CCRC_1, uc);
929 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
930 GET_UCHAR(BZ_X_CCRC_2, uc);
931 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
932 GET_UCHAR(BZ_X_CCRC_3, uc);
933 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
934 GET_UCHAR(BZ_X_CCRC_4, uc);
935 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
936 */
937 s->state = BZ_X_IDLE;
938 RETURN(BZ_STREAM_END);
939
940 default: /* aCaB AssertH ( False, 4001 ); */
941 RETURN(BZ_DATA_ERROR);
942 }
943
944 /* aCaB AssertH ( False, 4002 ); */
945 RETURN(BZ_DATA_ERROR);
946
947 save_state_and_return:
948
949 s->save_i = i;
950 s->save_j = j;
951 s->save_t = t;
952 s->save_alphaSize = alphaSize;
953 s->save_nGroups = nGroups;
954 s->save_nSelectors = nSelectors;
955 s->save_EOB = EOB;
956 s->save_groupNo = groupNo;
957 s->save_groupPos = groupPos;
958 s->save_nextSym = nextSym;
959 s->save_nblockMAX = nblockMAX;
960 s->save_nblock = nblock;
961 s->save_es = es;
962 s->save_N = N;
963 s->save_curr = curr;
964 s->save_zt = zt;
965 s->save_zn = zn;
966 s->save_zvec = zvec;
967 s->save_zj = zj;
968 s->save_gSel = gSel;
969 s->save_gMinlen = gMinlen;
970 s->save_gLimit = gLimit;
971 s->save_gBase = gBase;
972 s->save_gPerm = gPerm;
973
974 return retVal;
975 }
976
977
978 /*---------------------------------------------------*/
979 static
bz_config_ok(void)980 int bz_config_ok ( void )
981 {
982 if (sizeof(int) != 4) return 0;
983 if (sizeof(short) != 2) return 0;
984 if (sizeof(char) != 1) return 0;
985 return 1;
986 }
987
988
989 /*---------------------------------------------------*/
990 static
default_bzalloc(void * opaque,Int32 items,Int32 size)991 void* default_bzalloc ( void* opaque, Int32 items, Int32 size )
992 {
993 void* v = cli_malloc ( items * size );
994 UNUSEDPARAM(opaque);
995 return v;
996 }
997
998 static
default_bzfree(void * opaque,void * addr)999 void default_bzfree ( void* opaque, void* addr )
1000 {
1001 UNUSEDPARAM(opaque);
1002 if (addr != NULL) free ( addr );
1003 }
1004
1005 /*---------------------------------------------------*/
BZ_API(nsis_BZ2_bzDecompressInit)1006 int BZ_API(nsis_BZ2_bzDecompressInit)
1007 ( nsis_bzstream* strm,
1008 int verbosity,
1009 int small )
1010 {
1011 DState* s;
1012
1013 if (!bz_config_ok()) return BZ_CONFIG_ERROR;
1014
1015 if (strm == NULL) return BZ_PARAM_ERROR;
1016 if (small != 0 && small != 1) return BZ_PARAM_ERROR;
1017 if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR;
1018
1019 if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
1020 if (strm->bzfree == NULL) strm->bzfree = default_bzfree;
1021
1022 s = BZALLOC( sizeof(DState) );
1023 if (s == NULL) return BZ_MEM_ERROR;
1024 s->strm = strm;
1025 strm->state = s;
1026 s->state = BZ_X_MAGIC_1;
1027 s->bsLive = 0;
1028 s->bsBuff = 0;
1029 s->calculatedCombinedCRC = 0;
1030 strm->total_in_lo32 = 0;
1031 strm->total_in_hi32 = 0;
1032 strm->total_out_lo32 = 0;
1033 strm->total_out_hi32 = 0;
1034 s->smallDecompress = (Bool)small;
1035 s->ll4 = NULL;
1036 s->ll16 = NULL;
1037 s->tt = NULL;
1038 s->currBlockNo = 0;
1039 s->verbosity = verbosity;
1040
1041 return BZ_OK;
1042 }
1043
1044 /*---------------------------------------------------*/
BZ_API(nsis_BZ2_bzDecompress)1045 int BZ_API(nsis_BZ2_bzDecompress) ( nsis_bzstream *strm )
1046 {
1047 Bool corrupt;
1048 DState* s;
1049 if (strm == NULL) return BZ_PARAM_ERROR;
1050 s = strm->state;
1051 if (s == NULL) return BZ_PARAM_ERROR;
1052 if (s->strm != strm) return BZ_PARAM_ERROR;
1053
1054 while (True) {
1055 if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
1056 if (s->state == BZ_X_OUTPUT) {
1057 if (s->smallDecompress)
1058 corrupt = unRLE_obuf_to_output_SMALL ( s ); else
1059 corrupt = unRLE_obuf_to_output_FAST ( s );
1060 if (corrupt) return BZ_DATA_ERROR;
1061 if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
1062 /* BZ_FINALISE_CRC ( s->calculatedBlockCRC );
1063 if (s->verbosity >= 3)
1064 VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC,
1065 s->calculatedBlockCRC );
1066 if (s->verbosity >= 2) VPrintf0 ( "]" );
1067 if (s->calculatedBlockCRC != s->storedBlockCRC)
1068 return BZ_DATA_ERROR;
1069 s->calculatedCombinedCRC
1070 = (s->calculatedCombinedCRC << 1) |
1071 (s->calculatedCombinedCRC >> 31);
1072 s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
1073 */
1074 s->state = BZ_X_BLKHDR_1;
1075 } else {
1076 return BZ_OK;
1077 }
1078 }
1079 if (s->state >= BZ_X_MAGIC_1) {
1080 Int32 r = BZ2_decompress ( s );
1081 if (r == BZ_STREAM_END) {
1082 /* aCaB
1083 if (s->verbosity >= 3)
1084 VPrintf2 ( "\n combined CRCs: stored = 0x%08x, computed = 0x%08x",
1085 s->storedCombinedCRC, s->calculatedCombinedCRC );
1086 if (s->calculatedCombinedCRC != s->storedCombinedCRC)
1087 return BZ_DATA_ERROR;
1088 */
1089 return r;
1090 }
1091 if (s->state != BZ_X_OUTPUT) return r;
1092 }
1093 }
1094
1095 /* AssertH ( 0, 6001 ); */
1096 return BZ_DATA_ERROR;
1097 /* return 0; */ /*NOTREACHED*/
1098 }
1099
1100
1101 /*---------------------------------------------------*/
BZ_API(nsis_BZ2_bzDecompressEnd)1102 int BZ_API(nsis_BZ2_bzDecompressEnd) ( nsis_bzstream *strm )
1103 {
1104 DState* s;
1105 if (strm == NULL) return BZ_PARAM_ERROR;
1106 s = strm->state;
1107 if (s == NULL) return BZ_PARAM_ERROR;
1108 if (s->strm != strm) return BZ_PARAM_ERROR;
1109
1110 if (s->tt != NULL) BZFREE(s->tt);
1111 if (s->ll16 != NULL) BZFREE(s->ll16);
1112 if (s->ll4 != NULL) BZFREE(s->ll4);
1113
1114 BZFREE(strm->state);
1115 strm->state = NULL;
1116
1117 return BZ_OK;
1118 }
1119
1120 /*-------------------------------------------------------------*/
1121 /*--- end bzlib.c ---*/
1122 /*-------------------------------------------------------------*/
1123