contrib/bzip2-1.0/bzip2recover.c

   1 /*-----------------------------------------------------------*/
   2 /*--- Block recoverer program for bzip2                   ---*/
   3 /*---                                      bzip2recover.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 /* This program is a complete hack and should be rewritten properly.
  21          It isn't very complicated. */
  22
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28
  29 /* This program records bit locations in the file to be recovered.
  30    That means that if 64-bit ints are not supported, we will not
  31    be able to recover .bz2 files over 512MB (2^32 bits) long.
  32    On GNU supported platforms, we take advantage of the 64-bit
  33    int support to circumvent this problem.  Ditto MSVC.
  34
  35    This change occurred in version 1.0.2; all prior versions have
  36    the 512MB limitation.
  37 */
  38 #ifdef __GNUC__
  39    typedef  unsigned long long int  MaybeUInt64;
  40 #  define MaybeUInt64_FMT "%Lu"
  41 #else
  42 #ifdef _MSC_VER
  43    typedef  unsigned __int64  MaybeUInt64;
  44 #  define MaybeUInt64_FMT "%I64u"
  45 #else
  46    typedef  unsigned int   MaybeUInt64;
  47 #  define MaybeUInt64_FMT "%u"
  48 #endif
  49 #endif
  50
  51 typedef  unsigned int   UInt32;
  52 typedef  int            Int32;
  53 typedef  unsigned char  UChar;
  54 typedef  char           Char;
  55 typedef  unsigned char  Bool;
  56 #define True    ((Bool)1)
  57 #define False   ((Bool)0)
  58
  59
  60 #define BZ_MAX_FILENAME 2000
  61
  62 Char inFileName[BZ_MAX_FILENAME];
  63 Char outFileName[BZ_MAX_FILENAME];
  64 Char progName[BZ_MAX_FILENAME];
  65
  66 MaybeUInt64 bytesOut = 0;
  67 MaybeUInt64 bytesIn  = 0;
  68
  69
  70 /*---------------------------------------------------*/
  71 /*--- Header bytes                                ---*/
  72 /*---------------------------------------------------*/
  73
  74 #define BZ_HDR_B 0x42                         /* 'B' */
  75 #define BZ_HDR_Z 0x5a                         /* 'Z' */
  76 #define BZ_HDR_h 0x68                         /* 'h' */
  77 #define BZ_HDR_0 0x30                         /* '0' */
  78
  79
  80 /*---------------------------------------------------*/
  81 /*--- I/O errors                                  ---*/
  82 /*---------------------------------------------------*/
  83
  84 /*---------------------------------------------*/
  85 static void readError ( void )
  86 {
  87    fprintf ( stderr,
  88              "%s: I/O error reading `%s', possible reason follows.\n",
  89             progName, inFileName );
  90    perror ( progName );
  91    fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n",
  92              progName );
  93    exit ( 1 );
  94 }
  95
  96
  97 /*---------------------------------------------*/
  98 static void writeError ( void )
  99 {
 100    fprintf ( stderr,
 101              "%s: I/O error reading `%s', possible reason follows.\n",
 102             progName, inFileName );
 103    perror ( progName );
 104    fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n",
 105              progName );
 106    exit ( 1 );
 107 }
 108
 109
 110 /*---------------------------------------------*/
 111 static void mallocFail ( Int32 n )
 112 {
 113    fprintf ( stderr,
 114              "%s: malloc failed on request for %d bytes.\n",
 115             progName, n );
 116    fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n",
 117              progName );
 118    exit ( 1 );
 119 }
 120
 121
 122 /*---------------------------------------------*/
 123 static void tooManyBlocks ( Int32 max_handled_blocks )
 124 {
 125    fprintf ( stderr,
 126              "%s: `%s' appears to contain more than %d blocks\n",
 127             progName, inFileName, max_handled_blocks );
 128    fprintf ( stderr,
 129              "%s: and cannot be handled.  To fix, increase\n",
 130              progName );
 131    fprintf ( stderr,
 132              "%s: BZ_MAX_HANDLED_BLOCKS in bzip2recover.c, and recompile.\n",
 133              progName );
 134    exit ( 1 );
 135 }
 136
 137
 138
 139 /*---------------------------------------------------*/
 140 /*--- Bit stream I/O                              ---*/
 141 /*---------------------------------------------------*/
 142
 143 typedef
 144    struct {
 145       FILE*  handle;
 146       Int32  buffer;
 147       Int32  buffLive;
 148       Char   mode;
 149    }
 150    BitStream;
 151
 152
 153 /*---------------------------------------------*/
 154 static BitStream* bsOpenReadStream ( FILE* stream )
 155 {
 156    BitStream *bs = malloc ( sizeof(BitStream) );
 157    if (bs == NULL) mallocFail ( sizeof(BitStream) );
 158    bs->handle = stream;
 159    bs->buffer = 0;
 160    bs->buffLive = 0;
 161    bs->mode = 'r';
 162    return bs;
 163 }
 164
 165
 166 /*---------------------------------------------*/
 167 static BitStream* bsOpenWriteStream ( FILE* stream )
 168 {
 169    BitStream *bs = malloc ( sizeof(BitStream) );
 170    if (bs == NULL) mallocFail ( sizeof(BitStream) );
 171    bs->handle = stream;
 172    bs->buffer = 0;
 173    bs->buffLive = 0;
 174    bs->mode = 'w';
 175    return bs;
 176 }
 177
 178
 179 /*---------------------------------------------*/
 180 static void bsPutBit ( BitStream* bs, Int32 bit )
 181 {
 182    if (bs->buffLive == 8) {
 183       Int32 retVal = putc ( (UChar) bs->buffer, bs->handle );
 184       if (retVal == EOF) writeError();
 185       bytesOut++;
 186       bs->buffLive = 1;
 187       bs->buffer = bit & 0x1;
 188    } else {
 189       bs->buffer = ( (bs->buffer << 1) | (bit & 0x1) );
 190       bs->buffLive++;
 191    };
 192 }
 193
 194
 195 /*---------------------------------------------*/
 196 /*--
 197    Returns 0 or 1, or 2 to indicate EOF.
 198 --*/
 199 static Int32 bsGetBit ( BitStream* bs )
 200 {
 201    if (bs->buffLive > 0) {
 202       bs->buffLive --;
 203       return ( ((bs->buffer) >> (bs->buffLive)) & 0x1 );
 204    } else {
 205       Int32 retVal = getc ( bs->handle );
 206       if ( retVal == EOF ) {
 207          if (errno != 0) readError();
 208          return 2;
 209       }
 210       bs->buffLive = 7;
 211       bs->buffer = retVal;
 212       return ( ((bs->buffer) >> 7) & 0x1 );
 213    }
 214 }
 215
 216
 217 /*---------------------------------------------*/
 218 static void bsClose ( BitStream* bs )
 219 {
 220    Int32 retVal;
 221
 222    if ( bs->mode == 'w' ) {
 223       while ( bs->buffLive < 8 ) {
 224          bs->buffLive++;
 225          bs->buffer <<= 1;
 226       };
 227       retVal = putc ( (UChar) (bs->buffer), bs->handle );
 228       if (retVal == EOF) writeError();
 229       bytesOut++;
 230       retVal = fflush ( bs->handle );
 231       if (retVal == EOF) writeError();
 232    }
 233    retVal = fclose ( bs->handle );
 234    if (retVal == EOF) {
 235       if (bs->mode == 'w') writeError(); else readError();
 236    }
 237    free ( bs );
 238 }
 239
 240
 241 /*---------------------------------------------*/
 242 static void bsPutUChar ( BitStream* bs, UChar c )
 243 {
 244    Int32 i;
 245    for (i = 7; i >= 0; i--)
 246       bsPutBit ( bs, (((UInt32) c) >> i) & 0x1 );
 247 }
 248
 249
 250 /*---------------------------------------------*/
 251 static void bsPutUInt32 ( BitStream* bs, UInt32 c )
 252 {
 253    Int32 i;
 254
 255    for (i = 31; i >= 0; i--)
 256       bsPutBit ( bs, (c >> i) & 0x1 );
 257 }
 258
 259
 260 /*---------------------------------------------*/
 261 static Bool endsInBz2 ( Char* name )
 262 {
 263    Int32 n = strlen ( name );
 264    if (n <= 4) return False;
 265    return
 266       (name[n-4] == '.' &&
 267        name[n-3] == 'b' &&
 268        name[n-2] == 'z' &&
 269        name[n-1] == '2');
 270 }
 271
 272
 273 /*---------------------------------------------------*/
 274 /*---                                             ---*/
 275 /*---------------------------------------------------*/
 276
 277 /* This logic isn't really right when it comes to Cygwin. */
 278 #ifdef _WIN32
 279 #  define  BZ_SPLIT_SYM  '\\'  /* path splitter on Windows platform */
 280 #else
 281 #  define  BZ_SPLIT_SYM  '/'   /* path splitter on Unix platform */
 282 #endif
 283
 284 #define BLOCK_HEADER_HI  0x00003141UL
 285 #define BLOCK_HEADER_LO  0x59265359UL
 286
 287 #define BLOCK_ENDMARK_HI 0x00001772UL
 288 #define BLOCK_ENDMARK_LO 0x45385090UL
 289
 290 /* Increase if necessary.  However, a .bz2 file with > 50000 blocks
 291    would have an uncompressed size of at least 40GB, so the chances
 292    are low you'll need to up this.
 293 */
 294 #define BZ_MAX_HANDLED_BLOCKS 50000
 295
 296 MaybeUInt64 bStart [BZ_MAX_HANDLED_BLOCKS];
 297 MaybeUInt64 bEnd   [BZ_MAX_HANDLED_BLOCKS];
 298 MaybeUInt64 rbStart[BZ_MAX_HANDLED_BLOCKS];
 299 MaybeUInt64 rbEnd  [BZ_MAX_HANDLED_BLOCKS];
 300
 301 Int32 main ( Int32 argc, Char** argv )
 302 {
 303    FILE*       inFile;
 304    FILE*       outFile;
 305    BitStream*  bsIn, *bsWr;
 306    Int32       b, wrBlock, currBlock, rbCtr;
 307    MaybeUInt64 bitsRead;
 308
 309    UInt32      buffHi, buffLo, blockCRC;
 310    Char*       p;
 311
 312    strcpy ( progName, argv[0] );
 313    inFileName[0] = outFileName[0] = 0;
 314
 315    fprintf ( stderr,
 316              "bzip2recover 1.0.5: extracts blocks from damaged .bz2 files.\n" );
 317
 318    if (argc != 2) {
 319       fprintf ( stderr, "%s: usage is `%s damaged_file_name'.\n",
 320                         progName, progName );
 321       switch (sizeof(MaybeUInt64)) {
 322          case 8:
 323             fprintf(stderr,
 324                     "\trestrictions on size of recovered file: None\n");
 325             break;
 326          case 4:
 327             fprintf(stderr,
 328                     "\trestrictions on size of recovered file: 512 MB\n");
 329             fprintf(stderr,
 330                     "\tto circumvent, recompile with MaybeUInt64 as an\n"
 331                     "\tunsigned 64-bit int.\n");
 332             break;
 333          default:
 334             fprintf(stderr,
 335                     "\tsizeof(MaybeUInt64) is not 4 or 8 -- "
 336                     "configuration error.\n");
 337             break;
 338       }
 339       exit(1);
 340    }
 341
 342    if (strlen(argv[1]) >= BZ_MAX_FILENAME-20) {
 343       fprintf ( stderr,
 344                 "%s: supplied filename is suspiciously (>= %d chars) long.  Bye!\n",
 345                 progName, (int)strlen(argv[1]) );
 346       exit(1);
 347    }
 348
 349    strcpy ( inFileName, argv[1] );
 350
 351    inFile = fopen ( inFileName, "rb" );
 352    if (inFile == NULL) {
 353       fprintf ( stderr, "%s: can't read `%s'\n", progName, inFileName );
 354       exit(1);
 355    }
 356
 357    bsIn = bsOpenReadStream ( inFile );
 358    fprintf ( stderr, "%s: searching for block boundaries ...\n", progName );
 359
 360    bitsRead = 0;
 361    buffHi = buffLo = 0;
 362    currBlock = 0;
 363    bStart[currBlock] = 0;
 364
 365    rbCtr = 0;
 366
 367    while (True) {
 368       b = bsGetBit ( bsIn );
 369       bitsRead++;
 370       if (b == 2) {
 371          if (bitsRead >= bStart[currBlock] &&
 372             (bitsRead - bStart[currBlock]) >= 40) {
 373             bEnd[currBlock] = bitsRead-1;
 374             if (currBlock > 0)
 375                fprintf ( stderr, "   block %d runs from " MaybeUInt64_FMT
 376                                  " to " MaybeUInt64_FMT " (incomplete)\n",
 377                          currBlock,  bStart[currBlock], bEnd[currBlock] );
 378          } else
 379             currBlock--;
 380          break;
 381       }
 382       buffHi = (buffHi << 1) | (buffLo >> 31);
 383       buffLo = (buffLo << 1) | (b & 1);
 384       if ( ( (buffHi & 0x0000ffff) == BLOCK_HEADER_HI
 385              && buffLo == BLOCK_HEADER_LO)
 386            ||
 387            ( (buffHi & 0x0000ffff) == BLOCK_ENDMARK_HI
 388              && buffLo == BLOCK_ENDMARK_LO)
 389          ) {
 390          if (bitsRead > 49) {
 391             bEnd[currBlock] = bitsRead-49;
 392          } else {
 393             bEnd[currBlock] = 0;
 394          }
 395          if (currBlock > 0 &&
 396              (bEnd[currBlock] - bStart[currBlock]) >= 130) {
 397             fprintf ( stderr, "   block %d runs from " MaybeUInt64_FMT
 398                               " to " MaybeUInt64_FMT "\n",
 399                       rbCtr+1,  bStart[currBlock], bEnd[currBlock] );
 400             rbStart[rbCtr] = bStart[currBlock];
 401             rbEnd[rbCtr] = bEnd[currBlock];
 402             rbCtr++;
 403          }
 404          if (currBlock >= BZ_MAX_HANDLED_BLOCKS)
 405             tooManyBlocks(BZ_MAX_HANDLED_BLOCKS);
 406          currBlock++;
 407
 408          bStart[currBlock] = bitsRead;
 409       }
 410    }
 411
 412    bsClose ( bsIn );
 413
 414    /*-- identified blocks run from 1 to rbCtr inclusive. --*/
 415
 416    if (rbCtr < 1) {
 417       fprintf ( stderr,
 418                 "%s: sorry, I couldn't find any block boundaries.\n",
 419                 progName );
 420       exit(1);
 421    };
 422
 423    fprintf ( stderr, "%s: splitting into blocks\n", progName );
 424
 425    inFile = fopen ( inFileName, "rb" );
 426    if (inFile == NULL) {
 427       fprintf ( stderr, "%s: can't open `%s'\n", progName, inFileName );
 428       exit(1);
 429    }
 430    bsIn = bsOpenReadStream ( inFile );
 431
 432    /*-- placate gcc's dataflow analyser --*/
 433    blockCRC = 0; bsWr = 0;
 434
 435    bitsRead = 0;
 436    outFile = NULL;
 437    wrBlock = 0;
 438    while (True) {
 439       b = bsGetBit(bsIn);
 440       if (b == 2) break;
 441       buffHi = (buffHi << 1) | (buffLo >> 31);
 442       buffLo = (buffLo << 1) | (b & 1);
 443       if (bitsRead == 47+rbStart[wrBlock])
 444          blockCRC = (buffHi << 16) | (buffLo >> 16);
 445
 446       if (outFile != NULL && bitsRead >= rbStart[wrBlock]
 447                           && bitsRead <= rbEnd[wrBlock]) {
 448          bsPutBit ( bsWr, b );
 449       }
 450
 451       bitsRead++;
 452
 453       if (bitsRead == rbEnd[wrBlock]+1) {
 454          if (outFile != NULL) {
 455             bsPutUChar ( bsWr, 0x17 ); bsPutUChar ( bsWr, 0x72 );
 456             bsPutUChar ( bsWr, 0x45 ); bsPutUChar ( bsWr, 0x38 );
 457             bsPutUChar ( bsWr, 0x50 ); bsPutUChar ( bsWr, 0x90 );
 458             bsPutUInt32 ( bsWr, blockCRC );
 459             bsClose ( bsWr );
 460          }
 461          if (wrBlock >= rbCtr) break;
 462          wrBlock++;
 463       } else
 464       if (bitsRead == rbStart[wrBlock]) {
 465          /* Create the output file name, correctly handling leading paths.
 466             (31.10.2001 by Sergey E. Kusikov) */
 467          Char* split;
 468          Int32 ofs, k;
 469          for (k = 0; k < BZ_MAX_FILENAME; k++)
 470             outFileName[k] = 0;
 471          strcpy (outFileName, inFileName);
 472          split = strrchr (outFileName, BZ_SPLIT_SYM);
 473          if (split == NULL) {
 474             split = outFileName;
 475          } else {
 476             ++split;
 477          }
 478          /* Now split points to the start of the basename. */
 479          ofs  = split - outFileName;
 480          sprintf (split, "rec%5d", wrBlock+1);
 481          for (p = split; *p != 0; p++) if (*p == ' ') *p = '0';
 482          strcat (outFileName, inFileName + ofs);
 483
 484          if ( !endsInBz2(outFileName)) strcat ( outFileName, ".bz2" );
 485
 486          fprintf ( stderr, "   writing block %d to `%s' ...\n",
 487                            wrBlock+1, outFileName );
 488
 489          outFile = fopen ( outFileName, "wb" );
 490          if (outFile == NULL) {
 491             fprintf ( stderr, "%s: can't write `%s'\n",
 492                       progName, outFileName );
 493             exit(1);
 494          }
 495          bsWr = bsOpenWriteStream ( outFile );
 496          bsPutUChar ( bsWr, BZ_HDR_B );
 497          bsPutUChar ( bsWr, BZ_HDR_Z );
 498          bsPutUChar ( bsWr, BZ_HDR_h );
 499          bsPutUChar ( bsWr, BZ_HDR_0 + 9 );
 500          bsPutUChar ( bsWr, 0x31 ); bsPutUChar ( bsWr, 0x41 );
 501          bsPutUChar ( bsWr, 0x59 ); bsPutUChar ( bsWr, 0x26 );
 502          bsPutUChar ( bsWr, 0x53 ); bsPutUChar ( bsWr, 0x59 );
 503       }
 504    }
 505
 506    fprintf ( stderr, "%s: finished\n", progName );
 507    return 0;
 508 }
 509
 510
 511
 512 /*-----------------------------------------------------------*/
 513 /*--- end                                  bzip2recover.c ---*/
 514 /*-----------------------------------------------------------*/