bzip2recover.c (12281B)
1 2 /*-----------------------------------------------------------*/ 3 /*--- Block recoverer program for bzip2 ---*/ 4 /*--- bzip2recover.c ---*/ 5 /*-----------------------------------------------------------*/ 6 7 /*-- 8 This program is bzip2recover, a program to attempt data 9 salvage from damaged files created by the accompanying 10 bzip2-1.0 program. 11 12 Copyright (C) 1996-2000 Julian R Seward. All rights reserved. 13 14 Redistribution and use in source and binary forms, with or without 15 modification, are permitted provided that the following conditions 16 are met: 17 18 1. Redistributions of source code must retain the above copyright 19 notice, this list of conditions and the following disclaimer. 20 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. 25 26 3. Altered source versions must be plainly marked as such, and must 27 not be misrepresented as being the original software. 28 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 31 permission. 32 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. 44 45 Julian Seward, Cambridge, UK. 46 jseward@acm.org 47 bzip2/libbzip2 version 1.0 of 21 March 2000 48 --*/ 49 50 /*-- 51 This program is a complete hack and should be rewritten 52 properly. It isn't very complicated. 53 --*/ 54 55 #include <stdio.h> 56 #include <errno.h> 57 #include <stdlib.h> 58 #include <string.h> 59 60 typedef unsigned int UInt32; 61 typedef int Int32; 62 typedef unsigned char UChar; 63 typedef char Char; 64 typedef unsigned char Bool; 65 #define True ((Bool)1) 66 #define False ((Bool)0) 67 68 69 Char inFileName[2000]; 70 Char outFileName[2000]; 71 Char progName[2000]; 72 73 UInt32 bytesOut = 0; 74 UInt32 bytesIn = 0; 75 76 77 /*---------------------------------------------------*/ 78 /*--- I/O errors ---*/ 79 /*---------------------------------------------------*/ 80 81 /*---------------------------------------------*/ 82 void readError ( void ) 83 { 84 fprintf ( stderr, 85 "%s: I/O error reading `%s', possible reason follows.\n", 86 progName, inFileName ); 87 perror ( progName ); 88 fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n", 89 progName ); 90 exit ( 1 ); 91 } 92 93 94 /*---------------------------------------------*/ 95 void writeError ( void ) 96 { 97 fprintf ( stderr, 98 "%s: I/O error reading `%s', possible reason follows.\n", 99 progName, inFileName ); 100 perror ( progName ); 101 fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n", 102 progName ); 103 exit ( 1 ); 104 } 105 106 107 /*---------------------------------------------*/ 108 void mallocFail ( Int32 n ) 109 { 110 fprintf ( stderr, 111 "%s: malloc failed on request for %d bytes.\n", 112 progName, n ); 113 fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n", 114 progName ); 115 exit ( 1 ); 116 } 117 118 119 /*---------------------------------------------------*/ 120 /*--- Bit stream I/O ---*/ 121 /*---------------------------------------------------*/ 122 123 typedef 124 struct { 125 FILE* handle; 126 Int32 buffer; 127 Int32 buffLive; 128 Char mode; 129 } 130 BitStream; 131 132 133 /*---------------------------------------------*/ 134 BitStream* bsOpenReadStream ( FILE* stream ) 135 { 136 BitStream *bs = malloc ( sizeof(BitStream) ); 137 if (bs == NULL) mallocFail ( sizeof(BitStream) ); 138 bs->handle = stream; 139 bs->buffer = 0; 140 bs->buffLive = 0; 141 bs->mode = 'r'; 142 return bs; 143 } 144 145 146 /*---------------------------------------------*/ 147 BitStream* bsOpenWriteStream ( FILE* stream ) 148 { 149 BitStream *bs = malloc ( sizeof(BitStream) ); 150 if (bs == NULL) mallocFail ( sizeof(BitStream) ); 151 bs->handle = stream; 152 bs->buffer = 0; 153 bs->buffLive = 0; 154 bs->mode = 'w'; 155 return bs; 156 } 157 158 159 /*---------------------------------------------*/ 160 void bsPutBit ( BitStream* bs, Int32 bit ) 161 { 162 if (bs->buffLive == 8) { 163 Int32 retVal = putc ( (UChar) bs->buffer, bs->handle ); 164 if (retVal == EOF) writeError(); 165 bytesOut++; 166 bs->buffLive = 1; 167 bs->buffer = bit & 0x1; 168 } else { 169 bs->buffer = ( (bs->buffer << 1) | (bit & 0x1) ); 170 bs->buffLive++; 171 }; 172 } 173 174 175 /*---------------------------------------------*/ 176 /*-- 177 Returns 0 or 1, or 2 to indicate EOF. 178 --*/ 179 Int32 bsGetBit ( BitStream* bs ) 180 { 181 if (bs->buffLive > 0) { 182 bs->buffLive --; 183 return ( ((bs->buffer) >> (bs->buffLive)) & 0x1 ); 184 } else { 185 Int32 retVal = getc ( bs->handle ); 186 if ( retVal == EOF ) { 187 if (errno != 0) readError(); 188 return 2; 189 } 190 bs->buffLive = 7; 191 bs->buffer = retVal; 192 return ( ((bs->buffer) >> 7) & 0x1 ); 193 } 194 } 195 196 197 /*---------------------------------------------*/ 198 void bsClose ( BitStream* bs ) 199 { 200 Int32 retVal; 201 202 if ( bs->mode == 'w' ) { 203 while ( bs->buffLive < 8 ) { 204 bs->buffLive++; 205 bs->buffer <<= 1; 206 }; 207 retVal = putc ( (UChar) (bs->buffer), bs->handle ); 208 if (retVal == EOF) writeError(); 209 bytesOut++; 210 retVal = fflush ( bs->handle ); 211 if (retVal == EOF) writeError(); 212 } 213 retVal = fclose ( bs->handle ); 214 if (retVal == EOF) { 215 if (bs->mode == 'w') writeError(); else readError(); 216 } 217 free ( bs ); 218 } 219 220 221 /*---------------------------------------------*/ 222 void bsPutUChar ( BitStream* bs, UChar c ) 223 { 224 Int32 i; 225 for (i = 7; i >= 0; i--) 226 bsPutBit ( bs, (((UInt32) c) >> i) & 0x1 ); 227 } 228 229 230 /*---------------------------------------------*/ 231 void bsPutUInt32 ( BitStream* bs, UInt32 c ) 232 { 233 Int32 i; 234 235 for (i = 31; i >= 0; i--) 236 bsPutBit ( bs, (c >> i) & 0x1 ); 237 } 238 239 240 /*---------------------------------------------*/ 241 Bool endsInBz2 ( Char* name ) 242 { 243 Int32 n = strlen ( name ); 244 if (n <= 4) return False; 245 return 246 (name[n-4] == '.' && 247 name[n-3] == 'b' && 248 name[n-2] == 'z' && 249 name[n-1] == '2'); 250 } 251 252 253 /*---------------------------------------------------*/ 254 /*--- ---*/ 255 /*---------------------------------------------------*/ 256 257 #define BLOCK_HEADER_HI 0x00003141UL 258 #define BLOCK_HEADER_LO 0x59265359UL 259 260 #define BLOCK_ENDMARK_HI 0x00001772UL 261 #define BLOCK_ENDMARK_LO 0x45385090UL 262 263 264 UInt32 bStart[20000]; 265 UInt32 bEnd[20000]; 266 UInt32 rbStart[20000]; 267 UInt32 rbEnd[20000]; 268 269 Int32 main ( Int32 argc, Char** argv ) 270 { 271 FILE* inFile; 272 FILE* outFile; 273 BitStream* bsIn, *bsWr; 274 Int32 currBlock, b, wrBlock; 275 UInt32 bitsRead; 276 Int32 rbCtr; 277 278 279 UInt32 buffHi, buffLo, blockCRC; 280 Char* p; 281 282 strcpy ( progName, argv[0] ); 283 inFileName[0] = outFileName[0] = 0; 284 285 fprintf ( stderr, "bzip2recover 1.0: extracts blocks from damaged .bz2 files.\n" ); 286 287 if (argc != 2) { 288 fprintf ( stderr, "%s: usage is `%s damaged_file_name'.\n", 289 progName, progName ); 290 exit(1); 291 } 292 293 strcpy ( inFileName, argv[1] ); 294 295 inFile = fopen ( inFileName, "rb" ); 296 if (inFile == NULL) { 297 fprintf ( stderr, "%s: can't read `%s'\n", progName, inFileName ); 298 exit(1); 299 } 300 301 bsIn = bsOpenReadStream ( inFile ); 302 fprintf ( stderr, "%s: searching for block boundaries ...\n", progName ); 303 304 bitsRead = 0; 305 buffHi = buffLo = 0; 306 currBlock = 0; 307 bStart[currBlock] = 0; 308 309 rbCtr = 0; 310 311 while (True) { 312 b = bsGetBit ( bsIn ); 313 bitsRead++; 314 if (b == 2) { 315 if (bitsRead >= bStart[currBlock] && 316 (bitsRead - bStart[currBlock]) >= 40) { 317 bEnd[currBlock] = bitsRead-1; 318 if (currBlock > 0) 319 fprintf ( stderr, " block %d runs from %d to %d (incomplete)\n", 320 currBlock, bStart[currBlock], bEnd[currBlock] ); 321 } else 322 currBlock--; 323 break; 324 } 325 buffHi = (buffHi << 1) | (buffLo >> 31); 326 buffLo = (buffLo << 1) | (b & 1); 327 if ( ( (buffHi & 0x0000ffff) == BLOCK_HEADER_HI 328 && buffLo == BLOCK_HEADER_LO) 329 || 330 ( (buffHi & 0x0000ffff) == BLOCK_ENDMARK_HI 331 && buffLo == BLOCK_ENDMARK_LO) 332 ) { 333 if (bitsRead > 49) 334 bEnd[currBlock] = bitsRead-49; else 335 bEnd[currBlock] = 0; 336 if (currBlock > 0 && 337 (bEnd[currBlock] - bStart[currBlock]) >= 130) { 338 fprintf ( stderr, " block %d runs from %d to %d\n", 339 rbCtr+1, bStart[currBlock], bEnd[currBlock] ); 340 rbStart[rbCtr] = bStart[currBlock]; 341 rbEnd[rbCtr] = bEnd[currBlock]; 342 rbCtr++; 343 } 344 currBlock++; 345 346 bStart[currBlock] = bitsRead; 347 } 348 } 349 350 bsClose ( bsIn ); 351 352 /*-- identified blocks run from 1 to rbCtr inclusive. --*/ 353 354 if (rbCtr < 1) { 355 fprintf ( stderr, 356 "%s: sorry, I couldn't find any block boundaries.\n", 357 progName ); 358 exit(1); 359 }; 360 361 fprintf ( stderr, "%s: splitting into blocks\n", progName ); 362 363 inFile = fopen ( inFileName, "rb" ); 364 if (inFile == NULL) { 365 fprintf ( stderr, "%s: can't open `%s'\n", progName, inFileName ); 366 exit(1); 367 } 368 bsIn = bsOpenReadStream ( inFile ); 369 370 /*-- placate gcc's dataflow analyser --*/ 371 blockCRC = 0; bsWr = 0; 372 373 bitsRead = 0; 374 outFile = NULL; 375 wrBlock = 0; 376 while (True) { 377 b = bsGetBit(bsIn); 378 if (b == 2) break; 379 buffHi = (buffHi << 1) | (buffLo >> 31); 380 buffLo = (buffLo << 1) | (b & 1); 381 if (bitsRead == 47+rbStart[wrBlock]) 382 blockCRC = (buffHi << 16) | (buffLo >> 16); 383 384 if (outFile != NULL && bitsRead >= rbStart[wrBlock] 385 && bitsRead <= rbEnd[wrBlock]) { 386 bsPutBit ( bsWr, b ); 387 } 388 389 bitsRead++; 390 391 if (bitsRead == rbEnd[wrBlock]+1) { 392 if (outFile != NULL) { 393 bsPutUChar ( bsWr, 0x17 ); bsPutUChar ( bsWr, 0x72 ); 394 bsPutUChar ( bsWr, 0x45 ); bsPutUChar ( bsWr, 0x38 ); 395 bsPutUChar ( bsWr, 0x50 ); bsPutUChar ( bsWr, 0x90 ); 396 bsPutUInt32 ( bsWr, blockCRC ); 397 bsClose ( bsWr ); 398 } 399 if (wrBlock >= rbCtr) break; 400 wrBlock++; 401 } else 402 if (bitsRead == rbStart[wrBlock]) { 403 outFileName[0] = 0; 404 sprintf ( outFileName, "rec%4d", wrBlock+1 ); 405 for (p = outFileName; *p != 0; p++) if (*p == ' ') *p = '0'; 406 strcat ( outFileName, inFileName ); 407 if ( !endsInBz2(outFileName)) strcat ( outFileName, ".bz2" ); 408 409 fprintf ( stderr, " writing block %d to `%s' ...\n", 410 wrBlock+1, outFileName ); 411 412 outFile = fopen ( outFileName, "wb" ); 413 if (outFile == NULL) { 414 fprintf ( stderr, "%s: can't write `%s'\n", 415 progName, outFileName ); 416 exit(1); 417 } 418 bsWr = bsOpenWriteStream ( outFile ); 419 bsPutUChar ( bsWr, 'B' ); bsPutUChar ( bsWr, 'Z' ); 420 bsPutUChar ( bsWr, 'h' ); bsPutUChar ( bsWr, '9' ); 421 bsPutUChar ( bsWr, 0x31 ); bsPutUChar ( bsWr, 0x41 ); 422 bsPutUChar ( bsWr, 0x59 ); bsPutUChar ( bsWr, 0x26 ); 423 bsPutUChar ( bsWr, 0x53 ); bsPutUChar ( bsWr, 0x59 ); 424 } 425 } 426 427 fprintf ( stderr, "%s: finished\n", progName ); 428 return 0; 429 } 430 431 432 433 /*-----------------------------------------------------------*/ 434 /*--- end bzip2recover.c ---*/ 435 /*-----------------------------------------------------------*/