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