projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Imported bzip2 modified to build a decompression only dll for use by the ramdisk...
[reactos.git] / reactos / drivers / lib / bzip2 / bzip2.c
1
2 /*-----------------------------------------------------------*/
3 /*--- A block-sorting, lossless compressor bzip2.c ---*/
4 /*-----------------------------------------------------------*/
5
6 /*--
7 This file is a part of bzip2 and/or libbzip2, a program and
8 library for lossless, block-sorting data compression.
9
10 Copyright (C) 1996-2000 Julian R Seward. All rights reserved.
11
12 Redistribution and use in source and binary forms, with or without
13 modification, are permitted provided that the following conditions
14 are met:
15
16 1. Redistributions of source code must retain the above copyright
17 notice, this list of conditions and the following disclaimer.
18
19 2. The origin of this software must not be misrepresented; you must
20 not claim that you wrote the original software. If you use this
21 software in a product, an acknowledgment in the product
22 documentation would be appreciated but is not required.
23
24 3. Altered source versions must be plainly marked as such, and must
25 not be misrepresented as being the original software.
26
27 4. The name of the author may not be used to endorse or promote
28 products derived from this software without specific prior written
29 permission.
30
31 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
32 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
33 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
34 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
35 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
37 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
38 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
39 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
40 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
41 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42
43 Julian Seward, Cambridge, UK.
44 jseward@acm.org
45 bzip2/libbzip2 version 1.0 of 21 March 2000
46
47 This program is based on (at least) the work of:
48 Mike Burrows
49 David Wheeler
50 Peter Fenwick
51 Alistair Moffat
52 Radford Neal
53 Ian H. Witten
54 Robert Sedgewick
55 Jon L. Bentley
56
57 For more information on these sources, see the manual.
58 --*/
59
60
61 /*----------------------------------------------------*/
62 /*--- IMPORTANT ---*/
63 /*----------------------------------------------------*/
64
65 /*--
66 WARNING:
67 This program and library (attempts to) compress data by
68 performing several non-trivial transformations on it.
69 Unless you are 100% familiar with *all* the algorithms
70 contained herein, and with the consequences of modifying them,
71 you should NOT meddle with the compression or decompression
72 machinery. Incorrect changes can and very likely *will*
73 lead to disasterous loss of data.
74
75 DISCLAIMER:
76 I TAKE NO RESPONSIBILITY FOR ANY LOSS OF DATA ARISING FROM THE
77 USE OF THIS PROGRAM, HOWSOEVER CAUSED.
78
79 Every compression of a file implies an assumption that the
80 compressed file can be decompressed to reproduce the original.
81 Great efforts in design, coding and testing have been made to
82 ensure that this program works correctly. However, the
83 complexity of the algorithms, and, in particular, the presence
84 of various special cases in the code which occur with very low
85 but non-zero probability make it impossible to rule out the
86 possibility of bugs remaining in the program. DO NOT COMPRESS
87 ANY DATA WITH THIS PROGRAM AND/OR LIBRARY UNLESS YOU ARE PREPARED
88 TO ACCEPT THE POSSIBILITY, HOWEVER SMALL, THAT THE DATA WILL
89 NOT BE RECOVERABLE.
90
91 That is not to say this program is inherently unreliable.
92 Indeed, I very much hope the opposite is true. bzip2/libbzip2
93 has been carefully constructed and extensively tested.
94
95 PATENTS:
96 To the best of my knowledge, bzip2/libbzip2 does not use any
97 patented algorithms. However, I do not have the resources
98 available to carry out a full patent search. Therefore I cannot
99 give any guarantee of the above statement.
100 --*/
101
102
103
104 /*----------------------------------------------------*/
105 /*--- and now for something much more pleasant :-) ---*/
106 /*----------------------------------------------------*/
107
108 /*---------------------------------------------*/
109 /*--
110 Place a 1 beside your platform, and 0 elsewhere.
111 --*/
112
113 /*--
114 Generic 32-bit Unix.
115 Also works on 64-bit Unix boxes.
116 --*/
117 #define BZ_UNIX 1
118
119 /*--
120 Win32, as seen by Jacob Navia's excellent
121 port of (Chris Fraser & David Hanson)'s excellent
122 lcc compiler.
123 --*/
124 #define BZ_LCCWIN32 0
125
126 #if defined(_WIN32) && !defined(__CYGWIN__)
127 #undef BZ_LCCWIN32
128 #define BZ_LCCWIN32 1
129 #undef BZ_UNIX
130 #define BZ_UNIX 0
131 #endif
132
133
134 /*---------------------------------------------*/
135 /*--
136 Some stuff for all platforms.
137 --*/
138
139 #include <stdio.h>
140 #include <stdlib.h>
141 #include <string.h>
142 #include <signal.h>
143 #include <math.h>
144 #include <errno.h>
145 #include <ctype.h>
146 #include "bzlib.h"
147
148 #define ERROR_IF_EOF(i) { if ((i) == EOF) ioError(); }
149 #define ERROR_IF_NOT_ZERO(i) { if ((i) != 0) ioError(); }
150 #define ERROR_IF_MINUS_ONE(i) { if ((i) == (-1)) ioError(); }
151
152
153 /*---------------------------------------------*/
154 /*--
155 Platform-specific stuff.
156 --*/
157
158 #if BZ_UNIX
159 # include <sys/types.h>
160 # include <utime.h>
161 # include <unistd.h>
162 # include <sys/stat.h>
163 # include <sys/times.h>
164
165 # define PATH_SEP '/'
166 # define MY_LSTAT lstat
167 # define MY_S_IFREG S_ISREG
168 # define MY_STAT stat
169
170 # define APPEND_FILESPEC(root, name) \
171 root=snocString((root), (name))
172
173 # define APPEND_FLAG(root, name) \
174 root=snocString((root), (name))
175
176 # define SET_BINARY_MODE(fd) /**/
177
178 # ifdef __GNUC__
179 # define NORETURN __attribute__ ((noreturn))
180 # else
181 # define NORETURN /**/
182 # endif
183 # ifdef __DJGPP__
184 # include <io.h>
185 # include <fcntl.h>
186 # undef MY_LSTAT
187 # define MY_LSTAT stat
188 # undef SET_BINARY_MODE
189 # define SET_BINARY_MODE(fd) \
190 do { \
191 int retVal = setmode ( fileno ( fd ), \
192 O_BINARY ); \
193 ERROR_IF_MINUS_ONE ( retVal ); \
194 } while ( 0 )
195 # endif
196 # ifdef __CYGWIN__
197 # include <io.h>
198 # include <fcntl.h>
199 # undef SET_BINARY_MODE
200 # define SET_BINARY_MODE(fd) \
201 do { \
202 int retVal = setmode ( fileno ( fd ), \
203 O_BINARY ); \
204 ERROR_IF_MINUS_ONE ( retVal ); \
205 } while ( 0 )
206 # endif
207 #endif
208
209
210
211 #if BZ_LCCWIN32
212 # include <io.h>
213 # include <fcntl.h>
214 # include <sys\stat.h>
215
216 # define NORETURN /**/
217 # define PATH_SEP '\\'
218 # define MY_LSTAT _stat
219 # define MY_STAT _stat
220 # define MY_S_IFREG(x) ((x) & _S_IFREG)
221
222 # define APPEND_FLAG(root, name) \
223 root=snocString((root), (name))
224
225 # if 0
226 /*-- lcc-win32 seems to expand wildcards itself --*/
227 # define APPEND_FILESPEC(root, spec) \
228 do { \
229 if ((spec)[0] == '-') { \
230 root = snocString((root), (spec)); \
231 } else { \
232 struct _finddata_t c_file; \
233 long hFile; \
234 hFile = _findfirst((spec), &c_file); \
235 if ( hFile == -1L ) { \
236 root = snocString ((root), (spec)); \
237 } else { \
238 int anInt = 0; \
239 while ( anInt == 0 ) { \
240 root = snocString((root), \
241 &c_file.name[0]); \
242 anInt = _findnext(hFile, &c_file); \
243 } \
244 } \
245 } \
246 } while ( 0 )
247 # else
248 # define APPEND_FILESPEC(root, name) \
249 root = snocString ((root), (name))
250 # endif
251
252 # define SET_BINARY_MODE(fd) \
253 do { \
254 int retVal = setmode ( fileno ( fd ), \
255 O_BINARY ); \
256 ERROR_IF_MINUS_ONE ( retVal ); \
257 } while ( 0 )
258
259 #endif
260
261
262 /*---------------------------------------------*/
263 /*--
264 Some more stuff for all platforms :-)
265 --*/
266
267 typedef char Char;
268 typedef unsigned char Bool;
269 typedef unsigned char UChar;
270 typedef int Int32;
271 typedef unsigned int UInt32;
272 typedef short Int16;
273 typedef unsigned short UInt16;
274
275 #define True ((Bool)1)
276 #define False ((Bool)0)
277
278 /*--
279 IntNative is your platform's `native' int size.
280 Only here to avoid probs with 64-bit platforms.
281 --*/
282 typedef int IntNative;
283
284
285 /*---------------------------------------------------*/
286 /*--- Misc (file handling) data decls ---*/
287 /*---------------------------------------------------*/
288
289 Int32 verbosity;
290 Bool keepInputFiles, smallMode, deleteOutputOnInterrupt;
291 Bool forceOverwrite, testFailsExist, unzFailsExist, noisy;
292 Int32 numFileNames, numFilesProcessed, blockSize100k;
293 Int32 exitValue;
294
295 /*-- source modes; F==file, I==stdin, O==stdout --*/
296 #define SM_I2O 1
297 #define SM_F2O 2
298 #define SM_F2F 3
299
300 /*-- operation modes --*/
301 #define OM_Z 1
302 #define OM_UNZ 2
303 #define OM_TEST 3
304
305 Int32 opMode;
306 Int32 srcMode;
307
308 #define FILE_NAME_LEN 1034
309
310 Int32 longestFileName;
311 Char inName [FILE_NAME_LEN];
312 Char outName[FILE_NAME_LEN];
313 Char tmpName[FILE_NAME_LEN];
314 Char *progName;
315 Char progNameReally[FILE_NAME_LEN];
316 FILE *outputHandleJustInCase;
317 Int32 workFactor;
318
319 static void panic ( Char* ) NORETURN;
320 static void ioError ( void ) NORETURN;
321 static void outOfMemory ( void ) NORETURN;
322 static void configError ( void ) NORETURN;
323 static void crcError ( void ) NORETURN;
324 static void cleanUpAndFail ( Int32 ) NORETURN;
325 static void compressedStreamEOF ( void ) NORETURN;
326
327 static void copyFileName ( Char*, Char* );
328 static void* myMalloc ( Int32 );
329
330
331
332 /*---------------------------------------------------*/
333 /*--- An implementation of 64-bit ints. Sigh. ---*/
334 /*--- Roll on widespread deployment of ANSI C9X ! ---*/
335 /*---------------------------------------------------*/
336
337 typedef
338 struct { UChar b[8]; }
339 UInt64;
340
341 static
342 void uInt64_from_UInt32s ( UInt64* n, UInt32 lo32, UInt32 hi32 )
343 {
344 n->b[7] = (UChar)((hi32 >> 24) & 0xFF);
345 n->b[6] = (UChar)((hi32 >> 16) & 0xFF);
346 n->b[5] = (UChar)((hi32 >> 8) & 0xFF);
347 n->b[4] = (UChar) (hi32 & 0xFF);
348 n->b[3] = (UChar)((lo32 >> 24) & 0xFF);
349 n->b[2] = (UChar)((lo32 >> 16) & 0xFF);
350 n->b[1] = (UChar)((lo32 >> 8) & 0xFF);
351 n->b[0] = (UChar) (lo32 & 0xFF);
352 }
353
354 static
355 double uInt64_to_double ( UInt64* n )
356 {
357 Int32 i;
358 double base = 1.0;
359 double sum = 0.0;
360 for (i = 0; i < 8; i++) {
361 sum += base * (double)(n->b[i]);
362 base *= 256.0;
363 }
364 return sum;
365 }
366
367 static
368 void uInt64_add ( UInt64* src, UInt64* dst )
369 {
370 Int32 i;
371 Int32 carry = 0;
372 for (i = 0; i < 8; i++) {
373 carry += ( ((Int32)src->b[i]) + ((Int32)dst->b[i]) );
374 dst->b[i] = (UChar)(carry & 0xFF);
375 carry >>= 8;
376 }
377 }
378
379 static
380 void uInt64_sub ( UInt64* src, UInt64* dst )
381 {
382 Int32 t, i;
383 Int32 borrow = 0;
384 for (i = 0; i < 8; i++) {
385 t = ((Int32)dst->b[i]) - ((Int32)src->b[i]) - borrow;
386 if (t < 0) {
387 dst->b[i] = (UChar)(t + 256);
388 borrow = 1;
389 } else {
390 dst->b[i] = (UChar)t;
391 borrow = 0;
392 }
393 }
394 }
395
396 static
397 void uInt64_mul ( UInt64* a, UInt64* b, UInt64* r_hi, UInt64* r_lo )
398 {
399 UChar sum[16];
400 Int32 ia, ib, carry;
401 for (ia = 0; ia < 16; ia++) sum[ia] = 0;
402 for (ia = 0; ia < 8; ia++) {
403 carry = 0;
404 for (ib = 0; ib < 8; ib++) {
405 carry += ( ((Int32)sum[ia+ib])
406 + ((Int32)a->b[ia]) * ((Int32)b->b[ib]) );
407 sum[ia+ib] = (UChar)(carry & 0xFF);
408 carry >>= 8;
409 }
410 sum[ia+8] = (UChar)(carry & 0xFF);
411 if ((carry >>= 8) != 0) panic ( "uInt64_mul" );
412 }
413
414 for (ia = 0; ia < 8; ia++) r_hi->b[ia] = sum[ia+8];
415 for (ia = 0; ia < 8; ia++) r_lo->b[ia] = sum[ia];
416 }
417
418
419 static
420 void uInt64_shr1 ( UInt64* n )
421 {
422 Int32 i;
423 for (i = 0; i < 8; i++) {
424 n->b[i] >>= 1;
425 if (i < 7 && (n->b[i+1] & 1)) n->b[i] |= 0x80;
426 }
427 }
428
429 static
430 void uInt64_shl1 ( UInt64* n )
431 {
432 Int32 i;
433 for (i = 7; i >= 0; i--) {
434 n->b[i] <<= 1;
435 if (i > 0 && (n->b[i-1] & 0x80)) n->b[i]++;
436 }
437 }
438
439 static
440 Bool uInt64_isZero ( UInt64* n )
441 {
442 Int32 i;
443 for (i = 0; i < 8; i++)
444 if (n->b[i] != 0) return 0;
445 return 1;
446 }
447
448 static
449 Int32 uInt64_qrm10 ( UInt64* n )
450 {
451 /* Divide *n by 10, and return the remainder. Long division
452 is difficult, so we cheat and instead multiply by
453 0xCCCC CCCC CCCC CCCD, which is 0.8 (viz, 0.1 << 3).
454 */
455 Int32 i;
456 UInt64 tmp1, tmp2, n_orig, zero_point_eight;
457
458 zero_point_eight.b[1] = zero_point_eight.b[2] =
459 zero_point_eight.b[3] = zero_point_eight.b[4] =
460 zero_point_eight.b[5] = zero_point_eight.b[6] =
461 zero_point_eight.b[7] = 0xCC;
462 zero_point_eight.b[0] = 0xCD;
463
464 n_orig = *n;
465
466 /* divide n by 10,
467 by multiplying by 0.8 and then shifting right 3 times */
468 uInt64_mul ( n, &zero_point_eight, &tmp1, &tmp2 );
469 uInt64_shr1(&tmp1); uInt64_shr1(&tmp1); uInt64_shr1(&tmp1);
470 *n = tmp1;
471
472 /* tmp1 = 8*n, tmp2 = 2*n */
473 uInt64_shl1(&tmp1); uInt64_shl1(&tmp1); uInt64_shl1(&tmp1);
474 tmp2 = *n; uInt64_shl1(&tmp2);
475
476 /* tmp1 = 10*n */
477 uInt64_add ( &tmp2, &tmp1 );
478
479 /* n_orig = n_orig - 10*n */
480 uInt64_sub ( &tmp1, &n_orig );
481
482 /* n_orig should now hold quotient, in range 0 .. 9 */
483 for (i = 7; i >= 1; i--)
484 if (n_orig.b[i] != 0) panic ( "uInt64_qrm10(1)" );
485 if (n_orig.b[0] > 9)
486 panic ( "uInt64_qrm10(2)" );
487
488 return (int)n_orig.b[0];
489 }
490
491 /* ... and the Whole Entire Point of all this UInt64 stuff is
492 so that we can supply the following function.
493 */
494 static
495 void uInt64_toAscii ( char* outbuf, UInt64* n )
496 {
497 Int32 i, q;
498 UChar buf[32];
499 Int32 nBuf = 0;
500 UInt64 n_copy = *n;
501 do {
502 q = uInt64_qrm10 ( &n_copy );
503 buf[nBuf] = q + '0';
504 nBuf++;
505 } while (!uInt64_isZero(&n_copy));
506 outbuf[nBuf] = 0;
507 for (i = 0; i < nBuf; i++) outbuf[i] = buf[nBuf-i-1];
508 }
509
510
511 /*---------------------------------------------------*/
512 /*--- Processing of complete files and streams ---*/
513 /*---------------------------------------------------*/
514
515 /*---------------------------------------------*/
516 static
517 Bool myfeof ( FILE* f )
518 {
519 Int32 c = fgetc ( f );
520 if (c == EOF) return True;
521 ungetc ( c, f );
522 return False;
523 }
524
525
526 /*---------------------------------------------*/
527 static
528 void compressStream ( FILE *stream, FILE *zStream )
529 {
530 BZFILE* bzf = NULL;
531 UChar ibuf[5000];
532 Int32 nIbuf;
533 UInt32 nbytes_in_lo32, nbytes_in_hi32;
534 UInt32 nbytes_out_lo32, nbytes_out_hi32;
535 Int32 bzerr, bzerr_dummy, ret;
536
537 SET_BINARY_MODE(stream);
538 SET_BINARY_MODE(zStream);
539
540 if (ferror(stream)) goto errhandler_io;
541 if (ferror(zStream)) goto errhandler_io;
542
543 bzf = BZ2_bzWriteOpen ( &bzerr, zStream,
544 blockSize100k, verbosity, workFactor );
545 if (bzerr != BZ_OK) goto errhandler;
546
547 if (verbosity >= 2) fprintf ( stderr, "\n" );
548
549 while (True) {
550
551 if (myfeof(stream)) break;
552 nIbuf = fread ( ibuf, sizeof(UChar), 5000, stream );
553 if (ferror(stream)) goto errhandler_io;
554 if (nIbuf > 0) BZ2_bzWrite ( &bzerr, bzf, (void*)ibuf, nIbuf );
555 if (bzerr != BZ_OK) goto errhandler;
556
557 }
558
559 BZ2_bzWriteClose64 ( &bzerr, bzf, 0,
560 &nbytes_in_lo32, &nbytes_in_hi32,
561 &nbytes_out_lo32, &nbytes_out_hi32 );
562 if (bzerr != BZ_OK) goto errhandler;
563
564 if (ferror(zStream)) goto errhandler_io;
565 ret = fflush ( zStream );
566 if (ret == EOF) goto errhandler_io;
567 if (zStream != stdout) {
568 ret = fclose ( zStream );
569 if (ret == EOF) goto errhandler_io;
570 }
571 if (ferror(stream)) goto errhandler_io;
572 ret = fclose ( stream );
573 if (ret == EOF) goto errhandler_io;
574
575 if (nbytes_in_lo32 == 0 && nbytes_in_hi32 == 0)
576 nbytes_in_lo32 = 1;
577
578 if (verbosity >= 1) {
579 Char buf_nin[32], buf_nout[32];
580 UInt64 nbytes_in, nbytes_out;
581 double nbytes_in_d, nbytes_out_d;
582 uInt64_from_UInt32s ( &nbytes_in,
583 nbytes_in_lo32, nbytes_in_hi32 );
584 uInt64_from_UInt32s ( &nbytes_out,
585 nbytes_out_lo32, nbytes_out_hi32 );
586 nbytes_in_d = uInt64_to_double ( &nbytes_in );
587 nbytes_out_d = uInt64_to_double ( &nbytes_out );
588 uInt64_toAscii ( buf_nin, &nbytes_in );
589 uInt64_toAscii ( buf_nout, &nbytes_out );
590 fprintf ( stderr, "%6.3f:1, %6.3f bits/byte, "
591 "%5.2f%% saved, %s in, %s out.\n",
592 nbytes_in_d / nbytes_out_d,
593 (8.0 * nbytes_out_d) / nbytes_in_d,
594 100.0 * (1.0 - nbytes_out_d / nbytes_in_d),
595 buf_nin,
596 buf_nout
597 );
598 }
599
600 return;
601
602 errhandler:
603 BZ2_bzWriteClose64 ( &bzerr_dummy, bzf, 1,
604 &nbytes_in_lo32, &nbytes_in_hi32,
605 &nbytes_out_lo32, &nbytes_out_hi32 );
606 switch (bzerr) {
607 case BZ_CONFIG_ERROR:
608 configError(); break;
609 case BZ_MEM_ERROR:
610 outOfMemory (); break;
611 case BZ_IO_ERROR:
612 errhandler_io:
613 ioError(); break;
614 default:
615 panic ( "compress:unexpected error" );
616 }
617
618 panic ( "compress:end" );
619 /*notreached*/
620 }
621
622
623
624 /*---------------------------------------------*/
625 static
626 Bool uncompressStream ( FILE *zStream, FILE *stream )
627 {
628 BZFILE* bzf = NULL;
629 Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i;
630 UChar obuf[5000];
631 UChar unused[BZ_MAX_UNUSED];
632 Int32 nUnused;
633 UChar* unusedTmp;
634
635 nUnused = 0;
636 streamNo = 0;
637
638 SET_BINARY_MODE(stream);
639 SET_BINARY_MODE(zStream);
640
641 if (ferror(stream)) goto errhandler_io;
642 if (ferror(zStream)) goto errhandler_io;
643
644 while (True) {
645
646 bzf = BZ2_bzReadOpen (
647 &bzerr, zStream, verbosity,
648 (int)smallMode, unused, nUnused
649 );
650 if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
651 streamNo++;
652
653 while (bzerr == BZ_OK) {
654 nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );
655 if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler;
656 if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0)
657 fwrite ( obuf, sizeof(UChar), nread, stream );
658 if (ferror(stream)) goto errhandler_io;
659 }
660 if (bzerr != BZ_STREAM_END) goto errhandler;
661
662 BZ2_bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused );
663 if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
664
665 for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
666
667 BZ2_bzReadClose ( &bzerr, bzf );
668 if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
669
670 if (nUnused == 0 && myfeof(zStream)) break;
671
672 }
673
674 if (ferror(zStream)) goto errhandler_io;
675 ret = fclose ( zStream );
676 if (ret == EOF) goto errhandler_io;
677
678 if (ferror(stream)) goto errhandler_io;
679 ret = fflush ( stream );
680 if (ret != 0) goto errhandler_io;
681 if (stream != stdout) {
682 ret = fclose ( stream );
683 if (ret == EOF) goto errhandler_io;
684 }
685 if (verbosity >= 2) fprintf ( stderr, "\n " );
686 return True;
687
688 errhandler:
689 BZ2_bzReadClose ( &bzerr_dummy, bzf );
690 switch (bzerr) {
691 case BZ_CONFIG_ERROR:
692 configError(); break;
693 case BZ_IO_ERROR:
694 errhandler_io:
695 ioError(); break;
696 case BZ_DATA_ERROR:
697 crcError();
698 case BZ_MEM_ERROR:
699 outOfMemory();
700 case BZ_UNEXPECTED_EOF:
701 compressedStreamEOF();
702 case BZ_DATA_ERROR_MAGIC:
703 if (zStream != stdin) fclose(zStream);
704 if (stream != stdout) fclose(stream);
705 if (streamNo == 1) {
706 return False;
707 } else {
708 if (noisy)
709 fprintf ( stderr,
710 "\n%s: %s: trailing garbage after EOF ignored\n",
711 progName, inName );
712 return True;
713 }
714 default:
715 panic ( "decompress:unexpected error" );
716 }
717
718 panic ( "decompress:end" );
719 return True; /*notreached*/
720 }
721
722
723 /*---------------------------------------------*/
724 static
725 Bool testStream ( FILE *zStream )
726 {
727 BZFILE* bzf = NULL;
728 Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i;
729 UChar obuf[5000];
730 UChar unused[BZ_MAX_UNUSED];
731 Int32 nUnused;
732 UChar* unusedTmp;
733
734 nUnused = 0;
735 streamNo = 0;
736
737 SET_BINARY_MODE(zStream);
738 if (ferror(zStream)) goto errhandler_io;
739
740 while (True) {
741
742 bzf = BZ2_bzReadOpen (
743 &bzerr, zStream, verbosity,
744 (int)smallMode, unused, nUnused
745 );
746 if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
747 streamNo++;
748
749 while (bzerr == BZ_OK) {
750 nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );
751 if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler;
752 }
753 if (bzerr != BZ_STREAM_END) goto errhandler;
754
755 BZ2_bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused );
756 if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
757
758 for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
759
760 BZ2_bzReadClose ( &bzerr, bzf );
761 if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
762 if (nUnused == 0 && myfeof(zStream)) break;
763
764 }
765
766 if (ferror(zStream)) goto errhandler_io;
767 ret = fclose ( zStream );
768 if (ret == EOF) goto errhandler_io;
769
770 if (verbosity >= 2) fprintf ( stderr, "\n " );
771 return True;
772
773 errhandler:
774 BZ2_bzReadClose ( &bzerr_dummy, bzf );
775 if (verbosity == 0)
776 fprintf ( stderr, "%s: %s: ", progName, inName );
777 switch (bzerr) {
778 case BZ_CONFIG_ERROR:
779 configError(); break;
780 case BZ_IO_ERROR:
781 errhandler_io:
782 ioError(); break;
783 case BZ_DATA_ERROR:
784 fprintf ( stderr,
785 "data integrity (CRC) error in data\n" );
786 return False;
787 case BZ_MEM_ERROR:
788 outOfMemory();
789 case BZ_UNEXPECTED_EOF:
790 fprintf ( stderr,
791 "file ends unexpectedly\n" );
792 return False;
793 case BZ_DATA_ERROR_MAGIC:
794 if (zStream != stdin) fclose(zStream);
795 if (streamNo == 1) {
796 fprintf ( stderr,
797 "bad magic number (file not created by bzip2)\n" );
798 return False;
799 } else {
800 if (noisy)
801 fprintf ( stderr,
802 "trailing garbage after EOF ignored\n" );
803 return True;
804 }
805 default:
806 panic ( "test:unexpected error" );
807 }
808
809 panic ( "test:end" );
810 return True; /*notreached*/
811 }
812
813
814 /*---------------------------------------------------*/
815 /*--- Error [non-] handling grunge ---*/
816 /*---------------------------------------------------*/
817
818 /*---------------------------------------------*/
819 static
820 void setExit ( Int32 v )
821 {
822 if (v > exitValue) exitValue = v;
823 }
824
825
826 /*---------------------------------------------*/
827 static
828 void cadvise ( void )
829 {
830 if (noisy)
831 fprintf (
832 stderr,
833 "\nIt is possible that the compressed file(s) have become corrupted.\n"
834 "You can use the -tvv option to test integrity of such files.\n\n"
835 "You can use the `bzip2recover' program to *attempt* to recover\n"
836 "data from undamaged sections of corrupted files.\n\n"
837 );
838 }
839
840
841 /*---------------------------------------------*/
842 static
843 void showFileNames ( void )
844 {
845 if (noisy)
846 fprintf (
847 stderr,
848 "\tInput file = %s, output file = %s\n",
849 inName, outName
850 );
851 }
852
853
854 /*---------------------------------------------*/
855 static
856 void cleanUpAndFail ( Int32 ec )
857 {
858 IntNative retVal;
859
860 if ( srcMode == SM_F2F
861 && opMode != OM_TEST
862 && deleteOutputOnInterrupt ) {
863 if (noisy)
864 fprintf ( stderr, "%s: Deleting output file %s, if it exists.\n",
865 progName, outName );
866 if (outputHandleJustInCase != NULL)
867 fclose ( outputHandleJustInCase );
868 retVal = remove ( outName );
869 if (retVal != 0)
870 fprintf ( stderr,
871 "%s: WARNING: deletion of output file (apparently) failed.\n",
872 progName );
873 }
874 if (noisy && numFileNames > 0 && numFilesProcessed < numFileNames) {
875 fprintf ( stderr,
876 "%s: WARNING: some files have not been processed:\n"
877 "\t%d specified on command line, %d not processed yet.\n\n",
878 progName, numFileNames,
879 numFileNames - numFilesProcessed );
880 }
881 setExit(ec);
882 exit(exitValue);
883 }
884
885
886 /*---------------------------------------------*/
887 static
888 void panic ( Char* s )
889 {
890 fprintf ( stderr,
891 "\n%s: PANIC -- internal consistency error:\n"
892 "\t%s\n"
893 "\tThis is a BUG. Please report it to me at:\n"
894 "\tjseward@acm.org\n",
895 progName, s );
896 showFileNames();
897 cleanUpAndFail( 3 );
898 }
899
900
901 /*---------------------------------------------*/
902 static
903 void crcError ( void )
904 {
905 fprintf ( stderr,
906 "\n%s: Data integrity error when decompressing.\n",
907 progName );
908 showFileNames();
909 cadvise();
910 cleanUpAndFail( 2 );
911 }
912
913
914 /*---------------------------------------------*/
915 static
916 void compressedStreamEOF ( void )
917 {
918 fprintf ( stderr,
919 "\n%s: Compressed file ends unexpectedly;\n\t"
920 "perhaps it is corrupted? *Possible* reason follows.\n",
921 progName );
922 perror ( progName );
923 showFileNames();
924 cadvise();
925 cleanUpAndFail( 2 );
926 }
927
928
929 /*---------------------------------------------*/
930 static
931 void ioError ( void )
932 {
933 fprintf ( stderr,
934 "\n%s: I/O or other error, bailing out. "
935 "Possible reason follows.\n",
936 progName );
937 perror ( progName );
938 showFileNames();
939 cleanUpAndFail( 1 );
940 }
941
942
943 /*---------------------------------------------*/
944 static
945 void mySignalCatcher ( IntNative n )
946 {
947 fprintf ( stderr,
948 "\n%s: Control-C or similar caught, quitting.\n",
949 progName );
950 cleanUpAndFail(1);
951 }
952
953
954 /*---------------------------------------------*/
955 static
956 void mySIGSEGVorSIGBUScatcher ( IntNative n )
957 {
958 if (opMode == OM_Z)
959 fprintf (
960 stderr,
961 "\n%s: Caught a SIGSEGV or SIGBUS whilst compressing.\n"
962 "\n"
963 " Possible causes are (most likely first):\n"
964 " (1) This computer has unreliable memory or cache hardware\n"
965 " (a surprisingly common problem; try a different machine.)\n"
966 " (2) A bug in the compiler used to create this executable\n"
967 " (unlikely, if you didn't compile bzip2 yourself.)\n"
968 " (3) A real bug in bzip2 -- I hope this should never be the case.\n"
969 " The user's manual, Section 4.3, has more info on (1) and (2).\n"
970 " \n"
971 " If you suspect this is a bug in bzip2, or are unsure about (1)\n"
972 " or (2), feel free to report it to me at: jseward@acm.org.\n"
973 " Section 4.3 of the user's manual describes the info a useful\n"
974 " bug report should have. If the manual is available on your\n"
975 " system, please try and read it before mailing me. If you don't\n"
976 " have the manual or can't be bothered to read it, mail me anyway.\n"
977 "\n",
978 progName );
979 else
980 fprintf (
981 stderr,
982 "\n%s: Caught a SIGSEGV or SIGBUS whilst decompressing.\n"
983 "\n"
984 " Possible causes are (most likely first):\n"
985 " (1) The compressed data is corrupted, and bzip2's usual checks\n"
986 " failed to detect this. Try bzip2 -tvv my_file.bz2.\n"
987 " (2) This computer has unreliable memory or cache hardware\n"
988 " (a surprisingly common problem; try a different machine.)\n"
989 " (3) A bug in the compiler used to create this executable\n"
990 " (unlikely, if you didn't compile bzip2 yourself.)\n"
991 " (4) A real bug in bzip2 -- I hope this should never be the case.\n"
992 " The user's manual, Section 4.3, has more info on (2) and (3).\n"
993 " \n"
994 " If you suspect this is a bug in bzip2, or are unsure about (2)\n"
995 " or (3), feel free to report it to me at: jseward@acm.org.\n"
996 " Section 4.3 of the user's manual describes the info a useful\n"
997 " bug report should have. If the manual is available on your\n"
998 " system, please try and read it before mailing me. If you don't\n"
999 " have the manual or can't be bothered to read it, mail me anyway.\n"
1000 "\n",
1001 progName );
1002
1003 showFileNames();
1004 if (opMode == OM_Z)
1005 cleanUpAndFail( 3 ); else
1006 { cadvise(); cleanUpAndFail( 2 ); }
1007 }
1008
1009
1010 /*---------------------------------------------*/
1011 static
1012 void outOfMemory ( void )
1013 {
1014 fprintf ( stderr,
1015 "\n%s: couldn't allocate enough memory\n",
1016 progName );
1017 showFileNames();
1018 cleanUpAndFail(1);
1019 }
1020
1021
1022 /*---------------------------------------------*/
1023 static
1024 void configError ( void )
1025 {
1026 fprintf ( stderr,
1027 "bzip2: I'm not configured correctly for this platform!\n"
1028 "\tI require Int32, Int16 and Char to have sizes\n"
1029 "\tof 4, 2 and 1 bytes to run properly, and they don't.\n"
1030 "\tProbably you can fix this by defining them correctly,\n"
1031 "\tand recompiling. Bye!\n" );
1032 setExit(3);
1033 exit(exitValue);
1034 }
1035
1036
1037 /*---------------------------------------------------*/
1038 /*--- The main driver machinery ---*/
1039 /*---------------------------------------------------*/
1040
1041 /*---------------------------------------------*/
1042 static
1043 void pad ( Char *s )
1044 {
1045 Int32 i;
1046 if ( (Int32)strlen(s) >= longestFileName ) return;
1047 for (i = 1; i <= longestFileName - (Int32)strlen(s); i++)
1048 fprintf ( stderr, " " );
1049 }
1050
1051
1052 /*---------------------------------------------*/
1053 static
1054 void copyFileName ( Char* to, Char* from )
1055 {
1056 if ( strlen(from) > FILE_NAME_LEN-10 ) {
1057 fprintf (
1058 stderr,
1059 "bzip2: file name\n`%s'\n"
1060 "is suspiciously (more than %d chars) long.\n"
1061 "Try using a reasonable file name instead. Sorry! :-)\n",
1062 from, FILE_NAME_LEN-10
1063 );
1064 setExit(1);
1065 exit(exitValue);
1066 }
1067
1068 strncpy(to,from,FILE_NAME_LEN-10);
1069 to[FILE_NAME_LEN-10]='\0';
1070 }
1071
1072
1073 /*---------------------------------------------*/
1074 static
1075 Bool fileExists ( Char* name )
1076 {
1077 FILE *tmp = fopen ( name, "rb" );
1078 Bool exists = (tmp != NULL);
1079 if (tmp != NULL) fclose ( tmp );
1080 return exists;
1081 }
1082
1083
1084 /*---------------------------------------------*/
1085 /*--
1086 if in doubt, return True
1087 --*/
1088 static
1089 Bool notAStandardFile ( Char* name )
1090 {
1091 IntNative i;
1092 struct MY_STAT statBuf;
1093
1094 i = MY_LSTAT ( name, &statBuf );
1095 if (i != 0) return True;
1096 if (MY_S_IFREG(statBuf.st_mode)) return False;
1097 return True;
1098 }
1099
1100
1101 /*---------------------------------------------*/
1102 /*--
1103 rac 11/21/98 see if file has hard links to it
1104 --*/
1105 static
1106 Int32 countHardLinks ( Char* name )
1107 {
1108 IntNative i;
1109 struct MY_STAT statBuf;
1110
1111 i = MY_LSTAT ( name, &statBuf );
1112 if (i != 0) return 0;
1113 return (statBuf.st_nlink - 1);
1114 }
1115
1116
1117 /*---------------------------------------------*/
1118 static
1119 void copyDatePermissionsAndOwner ( Char *srcName, Char *dstName )
1120 {
1121 #if BZ_UNIX
1122 IntNative retVal;
1123 struct MY_STAT statBuf;
1124 struct utimbuf uTimBuf;
1125
1126 retVal = MY_LSTAT ( srcName, &statBuf );
1127 ERROR_IF_NOT_ZERO ( retVal );
1128 uTimBuf.actime = statBuf.st_atime;
1129 uTimBuf.modtime = statBuf.st_mtime;
1130
1131 retVal = chmod ( dstName, statBuf.st_mode );
1132 ERROR_IF_NOT_ZERO ( retVal );
1133
1134 retVal = utime ( dstName, &uTimBuf );
1135 ERROR_IF_NOT_ZERO ( retVal );
1136
1137 retVal = chown ( dstName, statBuf.st_uid, statBuf.st_gid );
1138 /* chown() will in many cases return with EPERM, which can
1139 be safely ignored.
1140 */
1141 #endif
1142 }
1143
1144
1145 /*---------------------------------------------*/
1146 static
1147 void setInterimPermissions ( Char *dstName )
1148 {
1149 #if BZ_UNIX
1150 IntNative retVal;
1151 retVal = chmod ( dstName, S_IRUSR | S_IWUSR );
1152 ERROR_IF_NOT_ZERO ( retVal );
1153 #endif
1154 }
1155
1156
1157 /*---------------------------------------------*/
1158 static
1159 Bool containsDubiousChars ( Char* name )
1160 {
1161 Bool cdc = False;
1162 for (; *name != '\0'; name++)
1163 if (*name == '?' || *name == '*') cdc = True;
1164 return cdc;
1165 }
1166
1167
1168 /*---------------------------------------------*/
1169 #define BZ_N_SUFFIX_PAIRS 4
1170
1171 Char* zSuffix[BZ_N_SUFFIX_PAIRS]
1172 = { ".bz2", ".bz", ".tbz2", ".tbz" };
1173 Char* unzSuffix[BZ_N_SUFFIX_PAIRS]
1174 = { "", "", ".tar", ".tar" };
1175
1176 static
1177 Bool hasSuffix ( Char* s, Char* suffix )
1178 {
1179 Int32 ns = strlen(s);
1180 Int32 nx = strlen(suffix);
1181 if (ns < nx) return False;
1182 if (strcmp(s + ns - nx, suffix) == 0) return True;
1183 return False;
1184 }
1185
1186 static
1187 Bool mapSuffix ( Char* name,
1188 Char* oldSuffix, Char* newSuffix )
1189 {
1190 if (!hasSuffix(name,oldSuffix)) return False;
1191 name[strlen(name)-strlen(oldSuffix)] = 0;
1192 strcat ( name, newSuffix );
1193 return True;
1194 }
1195
1196
1197 /*---------------------------------------------*/
1198 static
1199 void compress ( Char *name )
1200 {
1201 FILE *inStr;
1202 FILE *outStr;
1203 Int32 n, i;
1204
1205 deleteOutputOnInterrupt = False;
1206
1207 if (name == NULL && srcMode != SM_I2O)
1208 panic ( "compress: bad modes\n" );
1209
1210 switch (srcMode) {
1211 case SM_I2O:
1212 copyFileName ( inName, "(stdin)" );
1213 copyFileName ( outName, "(stdout)" );
1214 break;
1215 case SM_F2F:
1216 copyFileName ( inName, name );
1217 copyFileName ( outName, name );
1218 strcat ( outName, ".bz2" );
1219 break;
1220 case SM_F2O:
1221 copyFileName ( inName, name );
1222 copyFileName ( outName, "(stdout)" );
1223 break;
1224 }
1225
1226 if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
1227 if (noisy)
1228 fprintf ( stderr, "%s: There are no files matching `%s'.\n",
1229 progName, inName );
1230 setExit(1);
1231 return;
1232 }
1233 if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
1234 fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1235 progName, inName, strerror(errno) );
1236 setExit(1);
1237 return;
1238 }
1239 for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++) {
1240 if (hasSuffix(inName, zSuffix[i])) {
1241 if (noisy)
1242 fprintf ( stderr,
1243 "%s: Input file %s already has %s suffix.\n",
1244 progName, inName, zSuffix[i] );
1245 setExit(1);
1246 return;
1247 }
1248 }
1249 if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) {
1250 if (noisy)
1251 fprintf ( stderr, "%s: Input file %s is not a normal file.\n",
1252 progName, inName );
1253 setExit(1);
1254 return;
1255 }
1256 if ( srcMode == SM_F2F && !forceOverwrite && fileExists ( outName ) ) {
1257 fprintf ( stderr, "%s: Output file %s already exists.\n",
1258 progName, outName );
1259 setExit(1);
1260 return;
1261 }
1262 if ( srcMode == SM_F2F && !forceOverwrite &&
1263 (n=countHardLinks ( inName )) > 0) {
1264 fprintf ( stderr, "%s: Input file %s has %d other link%s.\n",
1265 progName, inName, n, n > 1 ? "s" : "" );
1266 setExit(1);
1267 return;
1268 }
1269
1270 switch ( srcMode ) {
1271
1272 case SM_I2O:
1273 inStr = stdin;
1274 outStr = stdout;
1275 if ( isatty ( fileno ( stdout ) ) ) {
1276 fprintf ( stderr,
1277 "%s: I won't write compressed data to a terminal.\n",
1278 progName );
1279 fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
1280 progName, progName );
1281 setExit(1);
1282 return;
1283 };
1284 break;
1285
1286 case SM_F2O:
1287 inStr = fopen ( inName, "rb" );
1288 outStr = stdout;
1289 if ( isatty ( fileno ( stdout ) ) ) {
1290 fprintf ( stderr,
1291 "%s: I won't write compressed data to a terminal.\n",
1292 progName );
1293 fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
1294 progName, progName );
1295 if ( inStr != NULL ) fclose ( inStr );
1296 setExit(1);
1297 return;
1298 };
1299 if ( inStr == NULL ) {
1300 fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1301 progName, inName, strerror(errno) );
1302 setExit(1);
1303 return;
1304 };
1305 break;
1306
1307 case SM_F2F:
1308 inStr = fopen ( inName, "rb" );
1309 outStr = fopen ( outName, "wb" );
1310 if ( outStr == NULL) {
1311 fprintf ( stderr, "%s: Can't create output file %s: %s.\n",
1312 progName, outName, strerror(errno) );
1313 if ( inStr != NULL ) fclose ( inStr );
1314 setExit(1);
1315 return;
1316 }
1317 if ( inStr == NULL ) {
1318 fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1319 progName, inName, strerror(errno) );
1320 if ( outStr != NULL ) fclose ( outStr );
1321 setExit(1);
1322 return;
1323 };
1324 setInterimPermissions ( outName );
1325 break;
1326
1327 default:
1328 panic ( "compress: bad srcMode" );
1329 break;
1330 }
1331
1332 if (verbosity >= 1) {
1333 fprintf ( stderr, " %s: ", inName );
1334 pad ( inName );
1335 fflush ( stderr );
1336 }
1337
1338 /*--- Now the input and output handles are sane. Do the Biz. ---*/
1339 outputHandleJustInCase = outStr;
1340 deleteOutputOnInterrupt = True;
1341 compressStream ( inStr, outStr );
1342 outputHandleJustInCase = NULL;
1343
1344 /*--- If there was an I/O error, we won't get here. ---*/
1345 if ( srcMode == SM_F2F ) {
1346 copyDatePermissionsAndOwner ( inName, outName );
1347 deleteOutputOnInterrupt = False;
1348 if ( !keepInputFiles ) {
1349 IntNative retVal = remove ( inName );
1350 ERROR_IF_NOT_ZERO ( retVal );
1351 }
1352 }
1353
1354 deleteOutputOnInterrupt = False;
1355 }
1356
1357
1358 /*---------------------------------------------*/
1359 static
1360 void uncompress ( Char *name )
1361 {
1362 FILE *inStr;
1363 FILE *outStr;
1364 Int32 n, i;
1365 Bool magicNumberOK;
1366 Bool cantGuess;
1367
1368 deleteOutputOnInterrupt = False;
1369
1370 if (name == NULL && srcMode != SM_I2O)
1371 panic ( "uncompress: bad modes\n" );
1372
1373 cantGuess = False;
1374 switch (srcMode) {
1375 case SM_I2O:
1376 copyFileName ( inName, "(stdin)" );
1377 copyFileName ( outName, "(stdout)" );
1378 break;
1379 case SM_F2F:
1380 copyFileName ( inName, name );
1381 copyFileName ( outName, name );
1382 for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++)
1383 if (mapSuffix(outName,zSuffix[i],unzSuffix[i]))
1384 goto zzz;
1385 cantGuess = True;
1386 strcat ( outName, ".out" );
1387 break;
1388 case SM_F2O:
1389 copyFileName ( inName, name );
1390 copyFileName ( outName, "(stdout)" );
1391 break;
1392 }
1393
1394 zzz:
1395 if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
1396 if (noisy)
1397 fprintf ( stderr, "%s: There are no files matching `%s'.\n",
1398 progName, inName );
1399 setExit(1);
1400 return;
1401 }
1402 if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
1403 fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1404 progName, inName, strerror(errno) );
1405 setExit(1);
1406 return;
1407 }
1408 if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) {
1409 if (noisy)
1410 fprintf ( stderr, "%s: Input file %s is not a normal file.\n",
1411 progName, inName );
1412 setExit(1);
1413 return;
1414 }
1415 if ( /* srcMode == SM_F2F implied && */ cantGuess ) {
1416 if (noisy)
1417 fprintf ( stderr,
1418 "%s: Can't guess original name for %s -- using %s\n",
1419 progName, inName, outName );
1420 /* just a warning, no return */
1421 }
1422 if ( srcMode == SM_F2F && !forceOverwrite && fileExists ( outName ) ) {
1423 fprintf ( stderr, "%s: Output file %s already exists.\n",
1424 progName, outName );
1425 setExit(1);
1426 return;
1427 }
1428 if ( srcMode == SM_F2F && !forceOverwrite &&
1429 (n=countHardLinks ( inName ) ) > 0) {
1430 fprintf ( stderr, "%s: Input file %s has %d other link%s.\n",
1431 progName, inName, n, n > 1 ? "s" : "" );
1432 setExit(1);
1433 return;
1434 }
1435
1436 switch ( srcMode ) {
1437
1438 case SM_I2O:
1439 inStr = stdin;
1440 outStr = stdout;
1441 if ( isatty ( fileno ( stdin ) ) ) {
1442 fprintf ( stderr,
1443 "%s: I won't read compressed data from a terminal.\n",
1444 progName );
1445 fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
1446 progName, progName );
1447 setExit(1);
1448 return;
1449 };
1450 break;
1451
1452 case SM_F2O:
1453 inStr = fopen ( inName, "rb" );
1454 outStr = stdout;
1455 if ( inStr == NULL ) {
1456 fprintf ( stderr, "%s: Can't open input file %s:%s.\n",
1457 progName, inName, strerror(errno) );
1458 if ( inStr != NULL ) fclose ( inStr );
1459 setExit(1);
1460 return;
1461 };
1462 break;
1463
1464 case SM_F2F:
1465 inStr = fopen ( inName, "rb" );
1466 outStr = fopen ( outName, "wb" );
1467 if ( outStr == NULL) {
1468 fprintf ( stderr, "%s: Can't create output file %s: %s.\n",
1469 progName, outName, strerror(errno) );
1470 if ( inStr != NULL ) fclose ( inStr );
1471 setExit(1);
1472 return;
1473 }
1474 if ( inStr == NULL ) {
1475 fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
1476 progName, inName, strerror(errno) );
1477 if ( outStr != NULL ) fclose ( outStr );
1478 setExit(1);
1479 return;
1480 };
1481 setInterimPermissions ( outName );
1482 break;
1483
1484 default:
1485 panic ( "uncompress: bad srcMode" );
1486 break;
1487 }
1488
1489 if (verbosity >= 1) {
1490 fprintf ( stderr, " %s: ", inName );
1491 pad ( inName );
1492 fflush ( stderr );
1493 }
1494
1495 /*--- Now the input and output handles are sane. Do the Biz. ---*/
1496 outputHandleJustInCase = outStr;
1497 deleteOutputOnInterrupt = True;
1498 magicNumberOK = uncompressStream ( inStr, outStr );
1499 outputHandleJustInCase = NULL;
1500
1501 /*--- If there was an I/O error, we won't get here. ---*/
1502 if ( magicNumberOK ) {
1503 if ( srcMode == SM_F2F ) {
1504 copyDatePermissionsAndOwner ( inName, outName );
1505 deleteOutputOnInterrupt = False;
1506 if ( !keepInputFiles ) {
1507 IntNative retVal = remove ( inName );
1508 ERROR_IF_NOT_ZERO ( retVal );
1509 }
1510 }
1511 } else {
1512 unzFailsExist = True;
1513 deleteOutputOnInterrupt = False;
1514 if ( srcMode == SM_F2F ) {
1515 IntNative retVal = remove ( outName );
1516 ERROR_IF_NOT_ZERO ( retVal );
1517 }
1518 }
1519 deleteOutputOnInterrupt = False;
1520
1521 if ( magicNumberOK ) {
1522 if (verbosity >= 1)
1523 fprintf ( stderr, "done\n" );
1524 } else {
1525 setExit(2);
1526 if (verbosity >= 1)
1527 fprintf ( stderr, "not a bzip2 file.\n" ); else
1528 fprintf ( stderr,
1529 "%s: %s is not a bzip2 file.\n",
1530 progName, inName );
1531 }
1532
1533 }
1534
1535
1536 /*---------------------------------------------*/
1537 static
1538 void testf ( Char *name )
1539 {
1540 FILE *inStr;
1541 Bool allOK;
1542
1543 deleteOutputOnInterrupt = False;
1544
1545 if (name == NULL && srcMode != SM_I2O)
1546 panic ( "testf: bad modes\n" );
1547
1548 copyFileName ( outName, "(none)" );
1549 switch (srcMode) {
1550 case SM_I2O: copyFileName ( inName, "(stdin)" ); break;
1551 case SM_F2F: copyFileName ( inName, name ); break;
1552 case SM_F2O: copyFileName ( inName, name ); break;
1553 }
1554
1555 if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
1556 if (noisy)
1557 fprintf ( stderr, "%s: There are no files matching `%s'.\n",
1558 progName, inName );
1559 setExit(1);
1560 return;
1561 }
1562 if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
1563 fprintf ( stderr, "%s: Can't open input %s: %s.\n",
1564 progName, inName, strerror(errno) );
1565 setExit(1);
1566 return;
1567 }
1568
1569 switch ( srcMode ) {
1570
1571 case SM_I2O:
1572 if ( isatty ( fileno ( stdin ) ) ) {
1573 fprintf ( stderr,
1574 "%s: I won't read compressed data from a terminal.\n",
1575 progName );
1576 fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
1577 progName, progName );
1578 setExit(1);
1579 return;
1580 };
1581 inStr = stdin;
1582 break;
1583
1584 case SM_F2O: case SM_F2F:
1585 inStr = fopen ( inName, "rb" );
1586 if ( inStr == NULL ) {
1587 fprintf ( stderr, "%s: Can't open input file %s:%s.\n",
1588 progName, inName, strerror(errno) );
1589 setExit(1);
1590 return;
1591 };
1592 break;
1593
1594 default:
1595 panic ( "testf: bad srcMode" );
1596 break;
1597 }
1598
1599 if (verbosity >= 1) {
1600 fprintf ( stderr, " %s: ", inName );
1601 pad ( inName );
1602 fflush ( stderr );
1603 }
1604
1605 /*--- Now the input handle is sane. Do the Biz. ---*/
1606 allOK = testStream ( inStr );
1607
1608 if (allOK && verbosity >= 1) fprintf ( stderr, "ok\n" );
1609 if (!allOK) testFailsExist = True;
1610 }
1611
1612
1613 /*---------------------------------------------*/
1614 static
1615 void license ( void )
1616 {
1617 fprintf ( stderr,
1618
1619 "bzip2, a block-sorting file compressor. "
1620 "Version %s.\n"
1621 " \n"
1622 " Copyright (C) 1996-2000 by Julian Seward.\n"
1623 " \n"
1624 " This program is free software; you can redistribute it and/or modify\n"
1625 " it under the terms set out in the LICENSE file, which is included\n"
1626 " in the bzip2-1.0 source distribution.\n"
1627 " \n"
1628 " This program is distributed in the hope that it will be useful,\n"
1629 " but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1630 " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1631 " LICENSE file for more details.\n"
1632 " \n",
1633 BZ2_bzlibVersion()
1634 );
1635 }
1636
1637
1638 /*---------------------------------------------*/
1639 static
1640 void usage ( Char *fullProgName )
1641 {
1642 fprintf (
1643 stderr,
1644 "bzip2, a block-sorting file compressor. "
1645 "Version %s.\n"
1646 "\n usage: %s [flags and input files in any order]\n"
1647 "\n"
1648 " -h --help print this message\n"
1649 " -d --decompress force decompression\n"
1650 " -z --compress force compression\n"
1651 " -k --keep keep (don't delete) input files\n"
1652 " -f --force overwrite existing output files\n"
1653 " -t --test test compressed file integrity\n"
1654 " -c --stdout output to standard out\n"
1655 " -q --quiet suppress noncritical error messages\n"
1656 " -v --verbose be verbose (a 2nd -v gives more)\n"
1657 " -L --license display software version & license\n"
1658 " -V --version display software version & license\n"
1659 " -s --small use less memory (at most 2500k)\n"
1660 " -1 .. -9 set block size to 100k .. 900k\n"
1661 "\n"
1662 " If invoked as `bzip2', default action is to compress.\n"
1663 " as `bunzip2', default action is to decompress.\n"
1664 " as `bzcat', default action is to decompress to stdout.\n"
1665 "\n"
1666 " If no file names are given, bzip2 compresses or decompresses\n"
1667 " from standard input to standard output. You can combine\n"
1668 " short flags, so `-v -4' means the same as -v4 or -4v, &c.\n"
1669 #if BZ_UNIX
1670 "\n"
1671 #endif
1672 ,
1673
1674 BZ2_bzlibVersion(),
1675 fullProgName
1676 );
1677 }
1678
1679
1680 /*---------------------------------------------*/
1681 static
1682 void redundant ( Char* flag )
1683 {
1684 fprintf (
1685 stderr,
1686 "%s: %s is redundant in versions 0.9.5 and above\n",
1687 progName, flag );
1688 }
1689
1690
1691 /*---------------------------------------------*/
1692 /*--
1693 All the garbage from here to main() is purely to
1694 implement a linked list of command-line arguments,
1695 into which main() copies argv[1 .. argc-1].
1696
1697 The purpose of this exercise is to facilitate
1698 the expansion of wildcard characters * and ? in
1699 filenames for OSs which don't know how to do it
1700 themselves, like MSDOS, Windows 95 and NT.
1701
1702 The actual Dirty Work is done by the platform-
1703 specific macro APPEND_FILESPEC.
1704 --*/
1705
1706 typedef
1707 struct zzzz {
1708 Char *name;
1709 struct zzzz *link;
1710 }
1711 Cell;
1712
1713
1714 /*---------------------------------------------*/
1715 static
1716 void *myMalloc ( Int32 n )
1717 {
1718 void* p;
1719
1720 p = malloc ( (size_t)n );
1721 if (p == NULL) outOfMemory ();
1722 return p;
1723 }
1724
1725
1726 /*---------------------------------------------*/
1727 static
1728 Cell *mkCell ( void )
1729 {
1730 Cell *c;
1731
1732 c = (Cell*) myMalloc ( sizeof ( Cell ) );
1733 c->name = NULL;
1734 c->link = NULL;
1735 return c;
1736 }
1737
1738
1739 /*---------------------------------------------*/
1740 static
1741 Cell *snocString ( Cell *root, Char *name )
1742 {
1743 if (root == NULL) {
1744 Cell *tmp = mkCell();
1745 tmp->name = (Char*) myMalloc ( 5 + strlen(name) );
1746 strcpy ( tmp->name, name );
1747 return tmp;
1748 } else {
1749 Cell *tmp = root;
1750 while (tmp->link != NULL) tmp = tmp->link;
1751 tmp->link = snocString ( tmp->link, name );
1752 return root;
1753 }
1754 }
1755
1756
1757 /*---------------------------------------------*/
1758 static
1759 void addFlagsFromEnvVar ( Cell** argList, Char* varName )
1760 {
1761 Int32 i, j, k;
1762 Char *envbase, *p;
1763
1764 envbase = getenv(varName);
1765 if (envbase != NULL) {
1766 p = envbase;
1767 i = 0;
1768 while (True) {
1769 if (p[i] == 0) break;
1770 p += i;
1771 i = 0;
1772 while (isspace((Int32)(p[0]))) p++;
1773 while (p[i] != 0 && !isspace((Int32)(p[i]))) i++;
1774 if (i > 0) {
1775 k = i; if (k > FILE_NAME_LEN-10) k = FILE_NAME_LEN-10;
1776 for (j = 0; j < k; j++) tmpName[j] = p[j];
1777 tmpName[k] = 0;
1778 APPEND_FLAG(*argList, tmpName);
1779 }
1780 }
1781 }
1782 }
1783
1784
1785 /*---------------------------------------------*/
1786 #define ISFLAG(s) (strcmp(aa->name, (s))==0)
1787
1788 IntNative main ( IntNative argc, Char *argv[] )
1789 {
1790 Int32 i, j;
1791 Char *tmp;
1792 Cell *argList;
1793 Cell *aa;
1794 Bool decode;
1795
1796 /*-- Be really really really paranoid :-) --*/
1797 if (sizeof(Int32) != 4 || sizeof(UInt32) != 4 ||
1798 sizeof(Int16) != 2 || sizeof(UInt16) != 2 ||
1799 sizeof(Char) != 1 || sizeof(UChar) != 1)
1800 configError();
1801
1802 /*-- Initialise --*/
1803 outputHandleJustInCase = NULL;
1804 smallMode = False;
1805 keepInputFiles = False;
1806 forceOverwrite = False;
1807 noisy = True;
1808 verbosity = 0;
1809 blockSize100k = 9;
1810 testFailsExist = False;
1811 unzFailsExist = False;
1812 numFileNames = 0;
1813 numFilesProcessed = 0;
1814 workFactor = 30;
1815 deleteOutputOnInterrupt = False;
1816 exitValue = 0;
1817 i = j = 0; /* avoid bogus warning from egcs-1.1.X */
1818
1819 /*-- Set up signal handlers for mem access errors --*/
1820 signal (SIGSEGV, mySIGSEGVorSIGBUScatcher);
1821 #if BZ_UNIX
1822 #ifndef __DJGPP__
1823 signal (SIGBUS, mySIGSEGVorSIGBUScatcher);
1824 #endif
1825 #endif
1826
1827 copyFileName ( inName, "(none)" );
1828 copyFileName ( outName, "(none)" );
1829
1830 copyFileName ( progNameReally, argv[0] );
1831 progName = &progNameReally[0];
1832 for (tmp = &progNameReally[0]; *tmp != '\0'; tmp++)
1833 if (*tmp == PATH_SEP) progName = tmp + 1;
1834
1835
1836 /*-- Copy flags from env var BZIP2, and
1837 expand filename wildcards in arg list.
1838 --*/
1839 argList = NULL;
1840 addFlagsFromEnvVar ( &argList, "BZIP2" );
1841 addFlagsFromEnvVar ( &argList, "BZIP" );
1842 for (i = 1; i <= argc-1; i++)
1843 APPEND_FILESPEC(argList, argv[i]);
1844
1845
1846 /*-- Find the length of the longest filename --*/
1847 longestFileName = 7;
1848 numFileNames = 0;
1849 decode = True;
1850 for (aa = argList; aa != NULL; aa = aa->link) {
1851 if (ISFLAG("--")) { decode = False; continue; }
1852 if (aa->name[0] == '-' && decode) continue;
1853 numFileNames++;
1854 if (longestFileName < (Int32)strlen(aa->name) )
1855 longestFileName = (Int32)strlen(aa->name);
1856 }
1857
1858
1859 /*-- Determine source modes; flag handling may change this too. --*/
1860 if (numFileNames == 0)
1861 srcMode = SM_I2O; else srcMode = SM_F2F;
1862
1863
1864 /*-- Determine what to do (compress/uncompress/test/cat). --*/
1865 /*-- Note that subsequent flag handling may change this. --*/
1866 opMode = OM_Z;
1867
1868 if ( (strstr ( progName, "unzip" ) != 0) ||
1869 (strstr ( progName, "UNZIP" ) != 0) )
1870 opMode = OM_UNZ;
1871
1872 if ( (strstr ( progName, "z2cat" ) != 0) ||
1873 (strstr ( progName, "Z2CAT" ) != 0) ||
1874 (strstr ( progName, "zcat" ) != 0) ||
1875 (strstr ( progName, "ZCAT" ) != 0) ) {
1876 opMode = OM_UNZ;
1877 srcMode = (numFileNames == 0) ? SM_I2O : SM_F2O;
1878 }
1879
1880
1881 /*-- Look at the flags. --*/
1882 for (aa = argList; aa != NULL; aa = aa->link) {
1883 if (ISFLAG("--")) break;
1884 if (aa->name[0] == '-' && aa->name[1] != '-') {
1885 for (j = 1; aa->name[j] != '\0'; j++) {
1886 switch (aa->name[j]) {
1887 case 'c': srcMode = SM_F2O; break;
1888 case 'd': opMode = OM_UNZ; break;
1889 case 'z': opMode = OM_Z; break;
1890 case 'f': forceOverwrite = True; break;
1891 case 't': opMode = OM_TEST; break;
1892 case 'k': keepInputFiles = True; break;
1893 case 's': smallMode = True; break;
1894 case 'q': noisy = False; break;
1895 case '1': blockSize100k = 1; break;
1896 case '2': blockSize100k = 2; break;
1897 case '3': blockSize100k = 3; break;
1898 case '4': blockSize100k = 4; break;
1899 case '5': blockSize100k = 5; break;
1900 case '6': blockSize100k = 6; break;
1901 case '7': blockSize100k = 7; break;
1902 case '8': blockSize100k = 8; break;
1903 case '9': blockSize100k = 9; break;
1904 case 'V':
1905 case 'L': license(); break;
1906 case 'v': verbosity++; break;
1907 case 'h': usage ( progName );
1908 exit ( 0 );
1909 break;
1910 default: fprintf ( stderr, "%s: Bad flag `%s'\n",
1911 progName, aa->name );
1912 usage ( progName );
1913 exit ( 1 );
1914 break;
1915 }
1916 }
1917 }
1918 }
1919
1920 /*-- And again ... --*/
1921 for (aa = argList; aa != NULL; aa = aa->link) {
1922 if (ISFLAG("--")) break;
1923 if (ISFLAG("--stdout")) srcMode = SM_F2O; else
1924 if (ISFLAG("--decompress")) opMode = OM_UNZ; else
1925 if (ISFLAG("--compress")) opMode = OM_Z; else
1926 if (ISFLAG("--force")) forceOverwrite = True; else
1927 if (ISFLAG("--test")) opMode = OM_TEST; else
1928 if (ISFLAG("--keep")) keepInputFiles = True; else
1929 if (ISFLAG("--small")) smallMode = True; else
1930 if (ISFLAG("--quiet")) noisy = False; else
1931 if (ISFLAG("--version")) license(); else
1932 if (ISFLAG("--license")) license(); else
1933 if (ISFLAG("--exponential")) workFactor = 1; else
1934 if (ISFLAG("--repetitive-best")) redundant(aa->name); else
1935 if (ISFLAG("--repetitive-fast")) redundant(aa->name); else
1936 if (ISFLAG("--verbose")) verbosity++; else
1937 if (ISFLAG("--help")) { usage ( progName ); exit ( 0 ); }
1938 else
1939 if (strncmp ( aa->name, "--", 2) == 0) {
1940 fprintf ( stderr, "%s: Bad flag `%s'\n", progName, aa->name );
1941 usage ( progName );
1942 exit ( 1 );
1943 }
1944 }
1945
1946 if (verbosity > 4) verbosity = 4;
1947 if (opMode == OM_Z && smallMode && blockSize100k > 2)
1948 blockSize100k = 2;
1949
1950 if (opMode == OM_TEST && srcMode == SM_F2O) {
1951 fprintf ( stderr, "%s: -c and -t cannot be used together.\n",
1952 progName );
1953 exit ( 1 );
1954 }
1955
1956 if (srcMode == SM_F2O && numFileNames == 0)
1957 srcMode = SM_I2O;
1958
1959 if (opMode != OM_Z) blockSize100k = 0;
1960
1961 if (srcMode == SM_F2F) {
1962 signal (SIGINT, mySignalCatcher);
1963 signal (SIGTERM, mySignalCatcher);
1964 # if BZ_UNIX
1965 signal (SIGHUP, mySignalCatcher);
1966 # endif
1967 }
1968
1969 if (opMode == OM_Z) {
1970 if (srcMode == SM_I2O) {
1971 compress ( NULL );
1972 } else {
1973 decode = True;
1974 for (aa = argList; aa != NULL; aa = aa->link) {
1975 if (ISFLAG("--")) { decode = False; continue; }
1976 if (aa->name[0] == '-' && decode) continue;
1977 numFilesProcessed++;
1978 compress ( aa->name );
1979 }
1980 }
1981 }
1982 else
1983
1984 if (opMode == OM_UNZ) {
1985 unzFailsExist = False;
1986 if (srcMode == SM_I2O) {
1987 uncompress ( NULL );
1988 } else {
1989 decode = True;
1990 for (aa = argList; aa != NULL; aa = aa->link) {
1991 if (ISFLAG("--")) { decode = False; continue; }
1992 if (aa->name[0] == '-' && decode) continue;
1993 numFilesProcessed++;
1994 uncompress ( aa->name );
1995 }
1996 }
1997 if (unzFailsExist) {
1998 setExit(2);
1999 exit(exitValue);
2000 }
2001 }
2002
2003 else {
2004 testFailsExist = False;
2005 if (srcMode == SM_I2O) {
2006 testf ( NULL );
2007 } else {
2008 decode = True;
2009 for (aa = argList; aa != NULL; aa = aa->link) {
2010 if (ISFLAG("--")) { decode = False; continue; }
2011 if (aa->name[0] == '-' && decode) continue;
2012 numFilesProcessed++;
2013 testf ( aa->name );
2014 }
2015 }
2016 if (testFailsExist && noisy) {
2017 fprintf ( stderr,
2018 "\n"
2019 "You can use the `bzip2recover' program to attempt to recover\n"
2020 "data from undamaged sections of corrupted files.\n\n"
2021 );
2022 setExit(2);
2023 exit(exitValue);
2024 }
2025 }
2026
2027 /* Free the argument list memory to mollify leak detectors
2028 (eg) Purify, Checker. Serves no other useful purpose.
2029 */
2030 aa = argList;
2031 while (aa != NULL) {
2032 Cell* aa2 = aa->link;
2033 if (aa->name != NULL) free(aa->name);
2034 free(aa);
2035 aa = aa2;
2036 }
2037
2038 return exitValue;
2039 }
2040
2041
2042 /*-----------------------------------------------------------*/
2043 /*--- end bzip2.c ---*/
2044 /*-----------------------------------------------------------*/
A free Windows-compatible Operating System