xbmc/lib/bzip2/bzip2.c at Dharma · AIahmedshrf/xbmc

Repository navigation

13

/*-----------------------------------------------------------*/

/*--- A block-sorting, lossless compressor bzip2.c ---*/

/*-----------------------------------------------------------*/

/* ------------------------------------------------------------------

This file is part of bzip2/libbzip2, a program and library for

lossless, block-sorting data compression.

bzip2/libbzip2 version 1.0.5 of 10 December 2007

Please read the WARNING, DISCLAIMER and PATENTS sections in the

README file.

This program is released under the terms of the license contained

in the file LICENSE.

------------------------------------------------------------------ */

/* Place a 1 beside your platform, and 0 elsewhere.

Generic 32-bit Unix.

Also works on 64-bit Unix boxes.

This is the default.

#define BZ_UNIX 1

/*--

Win32, as seen by Jacob Navia's excellent

port of (Chris Fraser & David Hanson)'s excellent

lcc compiler. Or with MS Visual C.

This is selected automatically if compiled by a compiler which

defines _WIN32, not including the Cygwin GCC.

--*/

#define BZ_LCCWIN32 0

#if defined(_WIN32) && !defined(__CYGWIN__)

#undef BZ_LCCWIN32

#define BZ_LCCWIN32 1

#undef BZ_UNIX

#define BZ_UNIX 0

#endif

/*---------------------------------------------*/

/*--

Some stuff for all platforms.

--*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <signal.h>

#include <math.h>

#include <errno.h>

#include <ctype.h>

#include "bzlib.h"

#define ERROR_IF_EOF(i) { if ((i) == EOF) ioError(); }

#define ERROR_IF_NOT_ZERO(i) { if ((i) != 0) ioError(); }

#define ERROR_IF_MINUS_ONE(i) { if ((i) == (-1)) ioError(); }

/*---------------------------------------------*/

/*--

Platform-specific stuff.

--*/

#if BZ_UNIX

# include <fcntl.h>

# include <sys/types.h>

# include <utime.h>

# include <unistd.h>

# include <sys/stat.h>

# include <sys/times.h>

# define PATH_SEP '/'

# define MY_LSTAT lstat

# define MY_STAT stat

# define MY_S_ISREG S_ISREG

# define MY_S_ISDIR S_ISDIR

# define APPEND_FILESPEC(root, name) \

root=snocString((root), (name))

# define APPEND_FLAG(root, name) \

root=snocString((root), (name))

# define SET_BINARY_MODE(fd) /**/

# ifdef __GNUC__

# define NORETURN __attribute__ ((noreturn))

# else

# define NORETURN /**/

# endif

# ifdef __DJGPP__

# include <io.h>

# include <fcntl.h>

# undef MY_LSTAT

# undef MY_STAT

# define MY_LSTAT stat

# define MY_STAT stat

# undef SET_BINARY_MODE

# define SET_BINARY_MODE(fd) \

do { \

int retVal = setmode ( fileno ( fd ), \

O_BINARY ); \

ERROR_IF_MINUS_ONE ( retVal ); \

} while ( 0 )

# endif

# ifdef __CYGWIN__

# include <io.h>

# include <fcntl.h>

# undef SET_BINARY_MODE

# define SET_BINARY_MODE(fd) \

do { \

int retVal = setmode ( fileno ( fd ), \

O_BINARY ); \

ERROR_IF_MINUS_ONE ( retVal ); \

} while ( 0 )

# endif

#endif /* BZ_UNIX */

#if BZ_LCCWIN32

# include <io.h>

# include <fcntl.h>

# include <sys\stat.h>

# define NORETURN /**/

# define PATH_SEP '\\'

# define MY_LSTAT _stat

# define MY_STAT _stat

# define MY_S_ISREG(x) ((x) & _S_IFREG)

# define MY_S_ISDIR(x) ((x) & _S_IFDIR)

# define APPEND_FLAG(root, name) \

root=snocString((root), (name))

# define APPEND_FILESPEC(root, name) \

root = snocString ((root), (name))

# define SET_BINARY_MODE(fd) \

do { \

int retVal = setmode ( fileno ( fd ), \

O_BINARY ); \

ERROR_IF_MINUS_ONE ( retVal ); \

} while ( 0 )

#endif /* BZ_LCCWIN32 */

/*---------------------------------------------*/

/*--

Some more stuff for all platforms :-)

--*/

typedef char Char;

typedef unsigned char Bool;

typedef unsigned char UChar;

typedef int Int32;

typedef unsigned int UInt32;

typedef short Int16;

typedef unsigned short UInt16;

#define True ((Bool)1)

#define False ((Bool)0)

/*--

IntNative is your platform's `native' int size.

Only here to avoid probs with 64-bit platforms.

--*/

typedef int IntNative;

/*---------------------------------------------------*/

/*--- Misc (file handling) data decls ---*/

/*---------------------------------------------------*/

Int32 verbosity;

Bool keepInputFiles, smallMode, deleteOutputOnInterrupt;

Bool forceOverwrite, testFailsExist, unzFailsExist, noisy;

Int32 numFileNames, numFilesProcessed, blockSize100k;

Int32 exitValue;

/*-- source modes; F==file, I==stdin, O==stdout --*/

#define SM_I2O 1

#define SM_F2O 2

#define SM_F2F 3

/*-- operation modes --*/

#define OM_Z 1

#define OM_UNZ 2

#define OM_TEST 3

Int32 opMode;

Int32 srcMode;

#define FILE_NAME_LEN 1034

Int32 longestFileName;

Char inName [FILE_NAME_LEN];

Char outName[FILE_NAME_LEN];

Char tmpName[FILE_NAME_LEN];

Char *progName;

Char progNameReally[FILE_NAME_LEN];

FILE *outputHandleJustInCase;

Int32 workFactor;

static void panic ( const Char* ) NORETURN;

static void ioError ( void ) NORETURN;

static void outOfMemory ( void ) NORETURN;

static void configError ( void ) NORETURN;

static void crcError ( void ) NORETURN;

static void cleanUpAndFail ( Int32 ) NORETURN;

static void compressedStreamEOF ( void ) NORETURN;

static void copyFileName ( Char*, Char* );

static void* myMalloc ( Int32 );

static void applySavedFileAttrToOutputFile ( IntNative fd );

/*---------------------------------------------------*/

/*--- An implementation of 64-bit ints. Sigh. ---*/

/*--- Roll on widespread deployment of ANSI C9X ! ---*/

/*---------------------------------------------------*/

typedef

struct { UChar b[8]; }

UInt64;

static

void uInt64_from_UInt32s ( UInt64* n, UInt32 lo32, UInt32 hi32 )

{

n->b[7] = (UChar)((hi32 >> 24) & 0xFF);

n->b[6] = (UChar)((hi32 >> 16) & 0xFF);

n->b[5] = (UChar)((hi32 >> 8) & 0xFF);

n->b[4] = (UChar) (hi32 & 0xFF);

n->b[3] = (UChar)((lo32 >> 24) & 0xFF);

n->b[2] = (UChar)((lo32 >> 16) & 0xFF);

n->b[1] = (UChar)((lo32 >> 8) & 0xFF);

n->b[0] = (UChar) (lo32 & 0xFF);

}

static

double uInt64_to_double ( UInt64* n )

{

Int32 i;

double base = 1.0;

double sum = 0.0;

for (i = 0; i < 8; i++) {

sum += base * (double)(n->b[i]);

base *= 256.0;

}

return sum;

}

static

Bool uInt64_isZero ( UInt64* n )

{

Int32 i;

for (i = 0; i < 8; i++)

if (n->b[i] != 0) return 0;

return 1;

}

/* Divide *n by 10, and return the remainder. */

static

Int32 uInt64_qrm10 ( UInt64* n )

{

UInt32 rem, tmp;

Int32 i;

rem = 0;

for (i = 7; i >= 0; i--) {

tmp = rem * 256 + n->b[i];

n->b[i] = tmp / 10;

rem = tmp % 10;

}

return rem;

}

/* ... and the Whole Entire Point of all this UInt64 stuff is

so that we can supply the following function.

static

void uInt64_toAscii ( char* outbuf, UInt64* n )

{

Int32 i, q;

UChar buf[32];

Int32 nBuf = 0;

UInt64 n_copy = *n;

do {

q = uInt64_qrm10 ( &n_copy );

buf[nBuf] = q + '0';

nBuf++;

} while (!uInt64_isZero(&n_copy));

outbuf[nBuf] = 0;

for (i = 0; i < nBuf; i++)

outbuf[i] = buf[nBuf-i-1];

}

/*---------------------------------------------------*/

/*--- Processing of complete files and streams ---*/

/*---------------------------------------------------*/

/*---------------------------------------------*/

static

Bool myfeof ( FILE* f )

{

Int32 c = fgetc ( f );

if (c == EOF) return True;

ungetc ( c, f );

return False;

}

/*---------------------------------------------*/

static

void compressStream ( FILE *stream, FILE *zStream )

{

BZFILE* bzf = NULL;

UChar ibuf[5000];

Int32 nIbuf;

UInt32 nbytes_in_lo32, nbytes_in_hi32;

UInt32 nbytes_out_lo32, nbytes_out_hi32;

Int32 bzerr, bzerr_dummy, ret;

SET_BINARY_MODE(stream);

SET_BINARY_MODE(zStream);

if (ferror(stream)) goto errhandler_io;

if (ferror(zStream)) goto errhandler_io;

bzf = BZ2_bzWriteOpen ( &bzerr, zStream,

blockSize100k, verbosity, workFactor );

if (bzerr != BZ_OK) goto errhandler;

if (verbosity >= 2) fprintf ( stderr, "\n" );

while (True) {

if (myfeof(stream)) break;

nIbuf = fread ( ibuf, sizeof(UChar), 5000, stream );

if (ferror(stream)) goto errhandler_io;

if (nIbuf > 0) BZ2_bzWrite ( &bzerr, bzf, (void*)ibuf, nIbuf );

if (bzerr != BZ_OK) goto errhandler;

}

BZ2_bzWriteClose64 ( &bzerr, bzf, 0,

&nbytes_in_lo32, &nbytes_in_hi32,

&nbytes_out_lo32, &nbytes_out_hi32 );

if (bzerr != BZ_OK) goto errhandler;

if (ferror(zStream)) goto errhandler_io;

ret = fflush ( zStream );

if (ret == EOF) goto errhandler_io;

if (zStream != stdout) {

Int32 fd = fileno ( zStream );

if (fd < 0) goto errhandler_io;

applySavedFileAttrToOutputFile ( fd );

ret = fclose ( zStream );

outputHandleJustInCase = NULL;

if (ret == EOF) goto errhandler_io;

}

outputHandleJustInCase = NULL;

if (ferror(stream)) goto errhandler_io;

ret = fclose ( stream );

if (ret == EOF) goto errhandler_io;

if (verbosity >= 1) {

if (nbytes_in_lo32 == 0 && nbyt 10000 es_in_hi32 == 0) {

fprintf ( stderr, " no data compressed.\n");

} else {

Char buf_nin[32], buf_nout[32];

UInt64 nbytes_in, nbytes_out;

double nbytes_in_d, nbytes_out_d;

uInt64_from_UInt32s ( &nbytes_in,

nbytes_in_lo32, nbytes_in_hi32 );

uInt64_from_UInt32s ( &nbytes_out,

nbytes_out_lo32, nbytes_out_hi32 );

nbytes_in_d = uInt64_to_double ( &nbytes_in );

nbytes_out_d = uInt64_to_double ( &nbytes_out );

uInt64_toAscii ( buf_nin, &nbytes_in );

uInt64_toAscii ( buf_nout, &nbytes_out );

fprintf ( stderr, "%6.3f:1, %6.3f bits/byte, "

"%5.2f%% saved, %s in, %s out.\n",

nbytes_in_d / nbytes_out_d,

(8.0 * nbytes_out_d) / nbytes_in_d,

100.0 * (1.0 - nbytes_out_d / nbytes_in_d),

buf_nin,

buf_nout

);

}

return;

errhandler:

BZ2_bzWriteClose64 ( &bzerr_dummy, bzf, 1,

&nbytes_in_lo32, &nbytes_in_hi32,

&nbytes_out_lo32, &nbytes_out_hi32 );

switch (bzerr) {

case BZ_CONFIG_ERROR:

configError(); break;

case BZ_MEM_ERROR:

outOfMemory (); break;

case BZ_IO_ERROR:

errhandler_io:

ioError(); break;

default:

panic ( "compress:unexpected error" );

}

panic ( "compress:end" );

/*notreached*/

}

/*---------------------------------------------*/

static

Bool uncompressStream ( FILE *zStream, FILE *stream )

{

BZFILE* bzf = NULL;

Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i;

UChar obuf[5000];

UChar unused[BZ_MAX_UNUSED];

Int32 nUnused;

void* unusedTmpV;

UChar* unusedTmp;

nUnused = 0;

streamNo = 0;

SET_BINARY_MODE(stream);

SET_BINARY_MODE(zStream);

if (ferror(stream)) goto errhandler_io;

if (ferror(zStream)) goto errhandler_io;

while (True) {

bzf = BZ2_bzReadOpen (

&bzerr, zStream, verbosity,

(int)smallMode, unused, nUnused

);

if (bzf == NULL || bzerr != BZ_OK) goto errhandler;

streamNo++;

while (bzerr == BZ_OK) {

nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );

if (bzerr == BZ_DATA_ERROR_MAGIC) goto trycat;

if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0)

fwrite ( obuf, sizeof(UChar), nread, stream );

if (ferror(stream)) goto errhandler_io;

}

if (bzerr != BZ_STREAM_END) goto errhandler;

BZ2_bzReadGetUnused ( &bzerr, bzf, &unusedTmpV, &nUnused );

if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );

unusedTmp = (UChar*)unusedTmpV;

for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];

BZ2_bzReadClose ( &bzerr, bzf );

if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );

if (nUnused == 0 && myfeof(zStream)) break;

}

closeok:

if (ferror(zStream)) goto errhandler_io;

if (stream != stdout) {

Int32 fd = fileno ( stream );

if (fd < 0) goto errhandler_io;

applySavedFileAttrToOutputFile ( fd );

}

ret = fclose ( zStream );

if (ret == EOF) goto errhandler_io;

if (ferror(stream)) goto errhandler_io;

ret = fflush ( stream );

if (ret != 0) goto errhandler_io;

if (stream != stdout) {

ret = fclose ( stream );

outputHandleJustInCase = NULL;

if (ret == EOF) goto errhandler_io;

}

outputHandleJustInCase = NULL;

if (verbosity >= 2) fprintf ( stderr, "\n " );

return True;

trycat:

if (forceOverwrite) {

rewind(zStream);

while (True) {

if (myfeof(zStream)) break;

nread = fread ( obuf, sizeof(UChar), 5000, zStream );

if (ferror(zStream)) goto errhandler_io;

if (nread > 0) fwrite ( obuf, sizeof(UChar), nread, stream );

if (ferror(stream)) goto errhandler_io;

}

goto closeok;

}

errhandler:

BZ2_bzReadClose ( &bzerr_dummy, bzf );

switch (bzerr) {

case BZ_CONFIG_ERROR:

configError(); break;

case BZ_IO_ERROR:

errhandler_io:

ioError(); break;

case BZ_DATA_ERROR:

crcError();

case BZ_MEM_ERROR:

outOfMemory();

case BZ_UNEXPECTED_EOF:

compressedStreamEOF();

case BZ_DATA_ERROR_MAGIC:

if (zStream != stdin) fclose(zStream);

if (stream != stdout) fclose(stream);

if (streamNo == 1) {

return False;

} else {

if (noisy)

fprintf ( stderr,

"\n%s: %s: trailing garbage after EOF ignored\n",

progName, inName );

return True;

}

default:

panic ( "decompress:unexpected error" );

}

panic ( "decompress:end" );

return True; /*notreached*/

}

/*---------------------------------------------*/

static

Bool testStream ( FILE *zStream )

{

BZFILE* bzf = NULL;

Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i;

UChar obuf[5000];

UChar unused[BZ_MAX_UNUSED];

Int32 nUnused;

void* unusedTmpV;

UChar* unusedTmp;

nUnused = 0;

streamNo = 0;

SET_BINARY_MODE(zStream);

if (ferror(zStream)) goto errhandler_io;

while (True) {

bzf = BZ2_bzReadOpen (

&bzerr, zStream, verbosity,

(int)smallMode, unused, nUnused

);

if (bzf == NULL || bzerr != BZ_OK) goto errhandler;

streamNo++;

while (bzerr == BZ_OK) {

nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );

if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler;

}

if (bzerr != BZ_STREAM_END) goto errhandler;

BZ2_bzReadGetUnused ( &bzerr, bzf, &unusedTmpV, &nUnused );

if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );

unusedTmp = (UChar*)unusedTmpV;

for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];

BZ2_bzReadClose ( &bzerr, bzf );

if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );

if (nUnused == 0 && myfeof(zStream)) break;

}

if (ferror(zStream)) goto errhandler_io;

ret = fclose ( zStream );

if (ret == EOF) goto errhandler_io;

if (verbosity >= 2) fprintf ( stderr, "\n " );

return True;

errhandler:

BZ2_bzReadClose ( &bzerr_dummy, bzf );

if (verbosity == 0)

fprintf ( stderr, "%s: %s: ", progName, inName );

switch (bzerr) {

case BZ_CONFIG_ERROR:

configError(); break;

case BZ_IO_ERROR:

errhandler_io:

ioError(); break;

case BZ_DATA_ERROR:

fprintf ( stderr,

"data integrity (CRC) error in data\n" );

return False;

case BZ_MEM_ERROR:

outOfMemory();

case BZ_UNEXPECTED_EOF:

fprintf ( stderr,

"file ends unexpectedly\n" );

return False;

case BZ_DATA_ERROR_MAGIC:

if (zStream != stdin) fclose(zStream);

if (streamNo == 1) {

fprintf ( stderr,

"bad magic number (file not created by bzip2)\n" );

return False;

} else {

if (noisy)

fprintf ( stderr,

"trailing garbage after EOF ignored\n" );

return True;

}

default:

panic ( "test:unexpected error" );

}

panic ( "test:end" );

return True; /*notreached*/

}

/*---------------------------------------------------*/

/*--- Error [non-] handling grunge ---*/

/*---------------------------------------------------*/

/*---------------------------------------------*/

static

void setExit ( Int32 v )

{

if (v > exitValue) exitValue = v;

}

/*---------------------------------------------*/

static

void cadvise ( void )

{

if (noisy)

fprintf (

stderr,

"\nIt is possible that the compressed file(s) have become corrupted.\n"

"You can use the -tvv option to test integrity of such files.\n\n"

"You can use the `bzip2recover' program to attempt to recover\n"

"data from undamaged sections of corrupted files.\n\n"

);

}

/*---------------------------------------------*/

static

void showFileNames ( void )

{

if (noisy)

fprintf (

stderr,

"\tInput file = %s, output file = %s\n",

inName, outName

);

}

/*---------------------------------------------*/

static

void cleanUpAndFail ( Int32 ec )

{

IntNative retVal;

struct MY_STAT statBuf;

if ( srcMode == SM_F2F

&& opMode != OM_TEST

&& deleteOutputOnInterrupt ) {

/* Check whether input file still exists. Delete output file

only if input exists to avoid loss of data. Joerg Prante, 5

January 2002. (JRS 06-Jan-2002: other changes in 1.0.2 mean

this is less likely to happen. But to be ultra-paranoid, we

do the check anyway.) */

retVal = MY_STAT ( inName, &statBuf );

if (retVal == 0) {

if (noisy)

fprintf ( stderr,

"%s: Deleting output file %s, if it exists.\n",

progName, outName );

if (outputHandleJustInCase != NULL)

fclose ( outputHandleJustInCase );

retVal = remove ( outName );

if (retVal != 0)

fprintf ( stderr,

"%s: WARNING: deletion of output file "

"(apparently) failed.\n",

progName );

} else {

fprintf ( stderr,

"%s: WARNING: deletion of output file suppressed\n",

progName );

fprintf ( stderr,

"%s: since input file no longer exists. Output file\n",

progName );

fprintf ( stderr,

"%s: `%s' may be incomplete.\n",

progName, outName );

fprintf ( stderr,

"%s: I suggest doing an integrity test (bzip2 -tv)"

" of it.\n",

progName );

}

if (noisy && numFileNames > 0 && numFilesProcessed < numFileNames) {

fprintf ( stderr,

"%s: WARNING: some files have not been processed:\n"

"%s: %d specified on command line, %d not processed yet.\n\n",

progName, progName,

numFileNames, numFileNames - numFilesProcessed );

}

setExit(ec);

exit(exitValue);

}

/*---------------------------------------------*/

static

void panic ( const Char* s )

{

fprintf ( stderr,

"\n%s: PANIC -- internal consistency error:\n"

"\t%s\n"

"\tThis is a BUG. Please report it to me at:\n"

"\tjseward@bzip.org\n",

progName, s );

showFileNames();

cleanUpAndFail( 3 );

}

/*---------------------------------------------*/

static

void crcError ( void )

{

fprintf ( stderr,

"\n%s: Data integrity error when decompressing.\n",

progName );

showFileNames();

cadvise();

cleanUpAndFail( 2 );

}

/*---------------------------------------------*/

static

void compressedStreamEOF ( void )

{

if (noisy) {

fprintf ( stderr,

"\n%s: Compressed file ends unexpectedly;\n\t"

"perhaps it is corrupted? *Possible* reason follows.\n",

progName );

perror ( progName );

showFileNames();

cadvise();

}

cleanUpAndFail( 2 );

}

/*---------------------------------------------*/

static

void ioError ( void )

{

fprintf ( stderr,

"\n%s: I/O or other error, bailing out. "

"Possible reason follows.\n",

progName );

perror ( progName );

showFileNames();

cleanUpAndFail( 1 );

}

/*---------------------------------------------*/

static

void mySignalCatcher ( IntNative n )

{

fprintf ( stderr,

"\n%s: Control-C or similar caught, quitting.\n",

progName );

cleanUpAndFail(1);

}

/*---------------------------------------------*/

static

void mySIGSEGVorSIGBUScatcher ( IntNative n )

{

if (opMode == OM_Z)

fprintf (

stderr,

"\n%s: Caught a SIGSEGV or SIGBUS whilst compressing.\n"

"\n"

" Possible causes are (most likely first):\n"

" (1) This computer has unreliable memory or cache hardware\n"

" (a surprisingly common problem; try a different machine.)\n"

" (2) A bug in the compiler used to create this executable\n"

" (unlikely, if you didn't compile bzip2 yourself.)\n"

" (3) A real bug in bzip2 -- I hope this should never be the case.\n"

" The user's manual, Section 4.3, has more info on (1) and (2).\n"

" \n"

" If you suspect this is a bug in bzip2, or are unsure about (1)\n"

" or (2), feel free to report it to me at: jseward@bzip.org.\n"

" Section 4.3 of the user's manual describes the info a useful\n"

" bug report should have. If the manual is available on your\n"

" system, please try and read it before mailing me. If you don't\n"

" have the manual or can't be bothered to read it, mail me anyway.\n"

"\n",

progName );

else

fprintf (

stderr,

"\n%s: Caught a SIGSEGV or SIGBUS whilst decompressing.\n"

"\n"

" Possible causes are (most likely first):\n"

" (1) The compressed data is corrupted, and bzip2's usual checks\n"

" failed to detect this. Try bzip2 -tvv my_file.bz2.\n"

" (2) This computer has unreliable memory or cache hardware\n"

" (a surprisingly common problem; try a different machine.)\n"

" (3) A bug in the compiler used to create this executable\n"

" (unlikely, if you didn't compile bzip2 yourself.)\n"

" (4) A real bug in bzip2 -- I hope this should never be the case.\n"

" The user's manual, Section 4.3, has more info on (2) and (3).\n"

" \n"

" If you suspect this is a bug in bzip2, or are unsure about (2)\n"

" or (3), feel free to report it to me at: jseward@bzip.org.\n"

" Section 4.3 of the user's manual describes the info a useful\n"

" bug report should have. If the manual is available on your\n"

" system, please try and read it before mailing me. If you don't\n"

" have the manual or can't be bothered to read it, mail me anyway.\n"

"\n",

progName );

showFileNames();

if (opMode == OM_Z)

cleanUpAndFail( 3 ); else

{ cadvise(); cleanUpAndFail( 2 ); }

}

/*---------------------------------------------*/

static

void outOfMemory ( void )

{

fprintf ( stderr,

"\n%s: couldn't allocate enough memory\n",

progName );

showFileNames();

cleanUpAndFail(1);

}

/*---------------------------------------------*/

static

void configError ( void )

{

fprintf ( stderr,

"bzip2: I'm not configured correctly for this platform!\n"

"\tI require Int32, Int16 and Char to have sizes\n"

"\tof 4, 2 and 1 bytes to run properly, and they don't.\n"

"\tProbably you can fix this by defining them correctly,\n"

"\tand recompiling. Bye!\n" );

setExit(3);

exit(exitValue);

}

/*---------------------------------------------------*/

/*--- The main driver machinery ---*/

/*---------------------------------------------------*/

/* All rather crufty. The main problem is that input files

are stat()d multiple times before use. This should be

cleaned up.

/*---------------------------------------------*/

static

void pad ( Char *s )

{

Int32 i;

< 8532 div id="LC911" class="react-file-line html-div" data-testid="code-cell" data-line-number="911" style="position:relative"> if ( (Int32)strlen(s) >= longestFileName ) return;

for (i = 1; i <= longestFileName - (Int32)strlen(s); i++)

fprintf ( stderr, " " );

}

/*---------------------------------------------*/

static

void copyFileName ( Char* to, Char* from )

{

if ( strlen(from) > FILE_NAME_LEN-10 ) {

fprintf (

stderr,

"bzip2: file name\n`%s'\n"

"is suspiciously (more than %d chars) long.\n"

"Try using a reasonable file name instead. Sorry! :-)\n",

from, FILE_NAME_LEN-10

);

setExit(1);

exit(exitValue);

}

strncpy(to,from,FILE_NAME_LEN-10);

to[FILE_NAME_LEN-10]='\0';

}

/*---------------------------------------------*/

static

Bool fileExists ( Char* name )

{

FILE *tmp = fopen ( name, "rb" );

Bool exists = (tmp != NULL);

if (tmp != NULL) fclose ( tmp );

return exists;

}

/*---------------------------------------------*/

/* Open an output file safely with O_EXCL and good permissions.

This avoids a race condition in versions < 1.0.2, in which

the file was first opened and then had its interim permissions

set safely. We instead use open() to create the file with

the interim permissions required. (--- --- rw-).

For non-Unix platforms, if we are not worrying about

security issues, simple this simply behaves like fopen.

static

FILE* fopen_output_safely ( Char* name, const char* mode )

{

# if BZ_UNIX

FILE* fp;

IntNative fh;

fh = open(name, O_WRONLY|O_CREAT|O_EXCL, S_IWUSR|S_IRUSR);

if (fh == -1) return NULL;

fp = fdopen(fh, mode);

if (fp == NULL) close(fh);

return fp;

# else

return fopen(name, mode);

# endif

}

/*---------------------------------------------*/

/*--

if in doubt, return True

--*/

static

Bool notAStandardFile ( Char* name )

{

IntNative i;

struct MY_STAT statBuf;

i = MY_LSTAT ( name, &statBuf );

if (i != 0) return True;

if (MY_S_ISREG(statBuf.st_mode)) return False;

return True;

}

/*---------------------------------------------*/

/*--

rac 11/21/98 see if file has hard links to it

--*/

static

Int32 countHardLinks ( Char* name )

{

IntNative i;

View remainder of file in raw view

FilesExpand file tree

bzip2.c

Latest commit

History

bzip2.c

File metadata and controls