2 /*-----------------------------------------------------------*/
3 /*--- Block recoverer program for bzip2 ---*/
4 /*--- bzip2recover.c ---*/
5 /*-----------------------------------------------------------*/
8 This program is bzip2recover, a program to attempt data
9 salvage from damaged files created by the accompanying
12 Copyright (C) 1996-2000 Julian R Seward. All rights reserved.
14 Redistribution and use in source and binary forms, with or without
15 modification, are permitted provided that the following conditions
18 1. Redistributions of source code must retain the above copyright
19 notice, this list of conditions and the following disclaimer.
21 2. The origin of this software must not be misrepresented; you must
22 not claim that you wrote the original software. If you use this
23 software in a product, an acknowledgment in the product
24 documentation would be appreciated but is not required.
26 3. Altered source versions must be plainly marked as such, and must
27 not be misrepresented as being the original software.
29 4. The name of the author may not be used to endorse or promote
30 products derived from this software without specific prior written
33 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
34 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
35 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
36 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
37 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
38 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
39 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
40 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
41 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
42 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
43 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45 Julian Seward, Cambridge, UK.
47 bzip2/libbzip2 version 1.0 of 21 March 2000
51 This program is a complete hack and should be rewritten
52 properly. It isn't very complicated.
60 typedef unsigned int UInt32;
62 typedef unsigned char UChar;
64 typedef unsigned char Bool;
65 #define True ((Bool)1)
66 #define False ((Bool)0)
69 Char inFileName[2000];
70 Char outFileName[2000];
77 /*---------------------------------------------------*/
78 /*--- I/O errors ---*/
79 /*---------------------------------------------------*/
81 /*---------------------------------------------*/
82 void readError ( void )
85 "%s: I/O error reading `%s', possible reason follows.\n",
86 progName, inFileName );
88 fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n",
94 /*---------------------------------------------*/
95 void writeError ( void )
98 "%s: I/O error reading `%s', possible reason follows.\n",
99 progName, inFileName );
101 fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n",
107 /*---------------------------------------------*/
108 void mallocFail ( Int32 n )
111 "%s: malloc failed on request for %d bytes.\n",
113 fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n",
119 /*---------------------------------------------------*/
120 /*--- Bit stream I/O ---*/
121 /*---------------------------------------------------*/
133 /*---------------------------------------------*/
134 BitStream* bsOpenReadStream ( FILE* stream )
136 BitStream *bs = malloc ( sizeof(BitStream) );
137 if (bs == NULL) mallocFail ( sizeof(BitStream) );
146 /*---------------------------------------------*/
147 BitStream* bsOpenWriteStream ( FILE* stream )
149 BitStream *bs = malloc ( sizeof(BitStream) );
150 if (bs == NULL) mallocFail ( sizeof(BitStream) );
159 /*---------------------------------------------*/
160 void bsPutBit ( BitStream* bs, Int32 bit )
162 if (bs->buffLive == 8) {
163 Int32 retVal = putc ( (UChar) bs->buffer, bs->handle );
164 if (retVal == EOF) writeError();
167 bs->buffer = bit & 0x1;
169 bs->buffer = ( (bs->buffer << 1) | (bit & 0x1) );
175 /*---------------------------------------------*/
177 Returns 0 or 1, or 2 to indicate EOF.
179 Int32 bsGetBit ( BitStream* bs )
181 if (bs->buffLive > 0) {
183 return ( ((bs->buffer) >> (bs->buffLive)) & 0x1 );
185 Int32 retVal = getc ( bs->handle );
186 if ( retVal == EOF ) {
187 if (errno != 0) readError();
192 return ( ((bs->buffer) >> 7) & 0x1 );
197 /*---------------------------------------------*/
198 void bsClose ( BitStream* bs )
202 if ( bs->mode == 'w' ) {
203 while ( bs->buffLive < 8 ) {
207 retVal = putc ( (UChar) (bs->buffer), bs->handle );
208 if (retVal == EOF) writeError();
210 retVal = fflush ( bs->handle );
211 if (retVal == EOF) writeError();
213 retVal = fclose ( bs->handle );
215 if (bs->mode == 'w') writeError(); else readError();
221 /*---------------------------------------------*/
222 void bsPutUChar ( BitStream* bs, UChar c )
225 for (i = 7; i >= 0; i--)
226 bsPutBit ( bs, (((UInt32) c) >> i) & 0x1 );
230 /*---------------------------------------------*/
231 void bsPutUInt32 ( BitStream* bs, UInt32 c )
235 for (i = 31; i >= 0; i--)
236 bsPutBit ( bs, (c >> i) & 0x1 );
240 /*---------------------------------------------*/
241 Bool endsInBz2 ( Char* name )
243 Int32 n = strlen ( name );
244 if (n <= 4) return False;
253 /*---------------------------------------------------*/
255 /*---------------------------------------------------*/
257 #define BLOCK_HEADER_HI 0x00003141UL
258 #define BLOCK_HEADER_LO 0x59265359UL
260 #define BLOCK_ENDMARK_HI 0x00001772UL
261 #define BLOCK_ENDMARK_LO 0x45385090UL
264 UInt32 bStart[20000];
266 UInt32 rbStart[20000];
269 Int32 main ( Int32 argc, Char** argv )
273 BitStream* bsIn, *bsWr;
274 Int32 currBlock, b, wrBlock;
279 UInt32 buffHi, buffLo, blockCRC;
282 strncpy ( progName, argv[0], sizeof progName );
283 progName[sizeof progName-1] = 0;
284 inFileName[0] = outFileName[0] = 0;
286 fprintf ( stderr, "bzip2recover 1.0: extracts blocks from damaged .bz2 files.\n" );
289 fprintf ( stderr, "%s: usage is `%s damaged_file_name'.\n",
290 progName, progName );
294 strcpy ( inFileName, argv[1] );
296 inFile = fopen ( inFileName, "rb" );
297 if (inFile == NULL) {
298 fprintf ( stderr, "%s: can't read `%s'\n", progName, inFileName );
302 bsIn = bsOpenReadStream ( inFile );
303 fprintf ( stderr, "%s: searching for block boundaries ...\n", progName );
308 bStart[currBlock] = 0;
313 b = bsGetBit ( bsIn );
316 if (bitsRead >= bStart[currBlock] &&
317 (bitsRead - bStart[currBlock]) >= 40) {
318 bEnd[currBlock] = bitsRead-1;
320 fprintf ( stderr, " block %d runs from %d to %d (incomplete)\n",
321 currBlock, bStart[currBlock], bEnd[currBlock] );
326 buffHi = (buffHi << 1) | (buffLo >> 31);
327 buffLo = (buffLo << 1) | (b & 1);
328 if ( ( (buffHi & 0x0000ffff) == BLOCK_HEADER_HI
329 && buffLo == BLOCK_HEADER_LO)
331 ( (buffHi & 0x0000ffff) == BLOCK_ENDMARK_HI
332 && buffLo == BLOCK_ENDMARK_LO)
335 bEnd[currBlock] = bitsRead-49; else
338 (bEnd[currBlock] - bStart[currBlock]) >= 130) {
339 fprintf ( stderr, " block %d runs from %d to %d\n",
340 rbCtr+1, bStart[currBlock], bEnd[currBlock] );
341 rbStart[rbCtr] = bStart[currBlock];
342 rbEnd[rbCtr] = bEnd[currBlock];
347 bStart[currBlock] = bitsRead;
353 /*-- identified blocks run from 1 to rbCtr inclusive. --*/
357 "%s: sorry, I couldn't find any block boundaries.\n",
362 fprintf ( stderr, "%s: splitting into blocks\n", progName );
364 inFile = fopen ( inFileName, "rb" );
365 if (inFile == NULL) {
366 fprintf ( stderr, "%s: can't open `%s'\n", progName, inFileName );
369 bsIn = bsOpenReadStream ( inFile );
371 /*-- placate gcc's dataflow analyser --*/
372 blockCRC = 0; bsWr = 0;
380 buffHi = (buffHi << 1) | (buffLo >> 31);
381 buffLo = (buffLo << 1) | (b & 1);
382 if (bitsRead == 47+rbStart[wrBlock])
383 blockCRC = (buffHi << 16) | (buffLo >> 16);
385 if (outFile != NULL && bitsRead >= rbStart[wrBlock]
386 && bitsRead <= rbEnd[wrBlock]) {
387 bsPutBit ( bsWr, b );
392 if (bitsRead == rbEnd[wrBlock]+1) {
393 if (outFile != NULL) {
394 bsPutUChar ( bsWr, 0x17 ); bsPutUChar ( bsWr, 0x72 );
395 bsPutUChar ( bsWr, 0x45 ); bsPutUChar ( bsWr, 0x38 );
396 bsPutUChar ( bsWr, 0x50 ); bsPutUChar ( bsWr, 0x90 );
397 bsPutUInt32 ( bsWr, blockCRC );
400 if (wrBlock >= rbCtr) break;
403 if (bitsRead == rbStart[wrBlock]) {
405 sprintf ( outFileName, "rec%4d", wrBlock+1 );
406 for (p = outFileName; *p != 0; p++) if (*p == ' ') *p = '0';
407 strcat ( outFileName, inFileName );
408 if ( !endsInBz2(outFileName)) strcat ( outFileName, ".bz2" );
410 fprintf ( stderr, " writing block %d to `%s' ...\n",
411 wrBlock+1, outFileName );
413 outFile = fopen ( outFileName, "wb" );
414 if (outFile == NULL) {
415 fprintf ( stderr, "%s: can't write `%s'\n",
416 progName, outFileName );
419 bsWr = bsOpenWriteStream ( outFile );
420 bsPutUChar ( bsWr, 'B' ); bsPutUChar ( bsWr, 'Z' );
421 bsPutUChar ( bsWr, 'h' ); bsPutUChar ( bsWr, '9' );
422 bsPutUChar ( bsWr, 0x31 ); bsPutUChar ( bsWr, 0x41 );
423 bsPutUChar ( bsWr, 0x59 ); bsPutUChar ( bsWr, 0x26 );
424 bsPutUChar ( bsWr, 0x53 ); bsPutUChar ( bsWr, 0x59 );
428 fprintf ( stderr, "%s: finished\n", progName );
434 /*-----------------------------------------------------------*/
435 /*--- end bzip2recover.c ---*/
436 /*-----------------------------------------------------------*/