ckolivas/lrzip
1
0
Fork 0
mirror of https://github.com/ckolivas/lrzip.git synced 2025-12-06 07:12:00 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Start cleaning up all the flag testing with neat macros.

Browse source
This commit is contained in:
Con Kolivas 2010-11-01 04:53:53 +11:00
parent 2bacbc60d2
commit a9ad1aef0e
5 changed files with 195 additions and 194 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

235
main.c
View file

@ -23,36 +23,36 @@ struct rzip_control control;
static void usage(void)
{
fprintf(stdout, "lrzip version %d.%d%d\n", LRZIP_MAJOR_VERSION, LRZIP_MINOR_VERSION, LRZIP_MINOR_SUBVERSION);
fprintf(stdout, "Copyright (C) Con Kolivas 2006-2010\n\n");
fprintf(stdout, "Based on rzip ");
fprintf(stdout, "Copyright (C) Andrew Tridgell 1998-2003\n");
fprintf(stdout, "usage: lrzip [options] <file...>\n");
fprintf(stdout, " Options:\n");
fprintf(stdout, " -w size compression window in hundreds of MB\n");
fprintf(stdout, " default chosen by heuristic dependent on ram and chosen compression\n");
fprintf(stdout, " -d decompress\n");
fprintf(stdout, " -o filename specify the output file name and/or path\n");
fprintf(stdout, " -O directory specify the output directory when -o is not used\n");
fprintf(stdout, " -S suffix specify compressed suffix (default '.lrz')\n");
fprintf(stdout, " -f force overwrite of any existing files\n");
fprintf(stdout, " -D delete existing files\n");
fprintf(stdout, " -P don't set permissions on output file - may leave it world-readable\n");
fprintf(stdout, " -q don't show compression progress\n");
fprintf(stdout, " -L level set lzma/bzip2/gzip compression level (1-9, default 7)\n");
fprintf(stdout, " -n no backend compression - prepare for other compressor\n");
fprintf(stdout, " -l lzo compression (ultra fast)\n");
fprintf(stdout, " -b bzip2 compression\n");
fprintf(stdout, " -g gzip compression using zlib\n");
fprintf(stdout, " -z zpaq compression (best, extreme compression, extremely slow)\n");
fprintf(stdout, " -M Maximum window and level - (all available ram and level 9)\n");
fprintf(stdout, " -T value Compression threshold with LZO test. (0 (nil) - 10 (high), default 1)\n");
fprintf(stdout, " -N value Set nice value to value (default 19)\n");
fprintf(stdout, " -v[v] Increase verbosity\n");
fprintf(stdout, " -V show version\n");
fprintf(stdout, " -t test compressed file integrity\n");
fprintf(stdout, " -i show compressed file information\n");
fprintf(stdout, "\nIf no filenames or \"-\" is specified, stdin/out will be used.\n");
print_out("lrzip version %d.%d%d\n", LRZIP_MAJOR_VERSION, LRZIP_MINOR_VERSION, LRZIP_MINOR_SUBVERSION);
print_out("Copyright (C) Con Kolivas 2006-2010\n\n");
print_out("Based on rzip ");
print_out("Copyright (C) Andrew Tridgell 1998-2003\n");
print_out("usage: lrzip [options] <file...>\n");
print_out(" Options:\n");
print_out(" -w size compression window in hundreds of MB\n");
print_out(" default chosen by heuristic dependent on ram and chosen compression\n");
print_out(" -d decompress\n");
print_out(" -o filename specify the output file name and/or path\n");
print_out(" -O directory specify the output directory when -o is not used\n");
print_out(" -S suffix specify compressed suffix (default '.lrz')\n");
print_out(" -f force overwrite of any existing files\n");
print_out(" -D delete existing files\n");
print_out(" -P don't set permissions on output file - may leave it world-readable\n");
print_out(" -q don't show compression progress\n");
print_out(" -L level set lzma/bzip2/gzip compression level (1-9, default 7)\n");
print_out(" -n no backend compression - prepare for other compressor\n");
print_out(" -l lzo compression (ultra fast)\n");
print_out(" -b bzip2 compression\n");
print_out(" -g gzip compression using zlib\n");
print_out(" -z zpaq compression (best, extreme compression, extremely slow)\n");
print_out(" -M Maximum window and level - (all available ram and level 9)\n");
print_out(" -T value Compression threshold with LZO test. (0 (nil) - 10 (high), default 1)\n");
print_out(" -N value Set nice value to value (default 19)\n");
print_out(" -v[v] Increase verbosity\n");
print_out(" -V show version\n");
print_out(" -t test compressed file integrity\n");
print_out(" -i show compressed file information\n");
print_out("\nIf no filenames or \"-\" is specified, stdin/out will be used.\n");
}
static void write_magic(int fd_in, int fd_out)
@ -116,15 +116,10 @@ static void read_magic(int fd_in, i64 *expected_size)
for (i = 0; i < 5; i++)
control.lzma_properties[i] = magic[i + 16];
}
if (control.flags & FLAG_VERBOSE) {
fprintf(control.msgout, "Detected lrzip version %d.%d file.\n", control.major_version, control.minor_version);
fflush(control.msgout);
}
print_verbose("Detected lrzip version %d.%d file.\n", control.major_version, control.minor_version);
if (control.major_version > LRZIP_MAJOR_VERSION ||
(control.major_version == LRZIP_MAJOR_VERSION && control.minor_version > LRZIP_MINOR_VERSION)) {
fprintf(control.msgout, "Attempting to work with file produced by newer lrzip version %d.%d file.\n", control.major_version, control.minor_version);
fflush(control.msgout);
}
(control.major_version == LRZIP_MAJOR_VERSION && control.minor_version > LRZIP_MINOR_VERSION))
print_output("Attempting to work with file produced by newer lrzip version %d.%d file.\n", control.major_version, control.minor_version);
}
/* preserve ownership and permissions where possible */
@ -146,8 +141,8 @@ static int open_tmpoutfile(void)
{
int fd_out;
if ((control.flags & FLAG_STDOUT) && (control.flags & FLAG_VERBOSE))
fprintf(control.msgout, "Outputting to stdout.\n");
if (STDOUT)
print_verbose("Outputting to stdout.\n");
control.outfile = realloc(NULL, 16);
strcpy(control.outfile, "lrzipout.XXXXXX");
if (!control.outfile)
@ -165,8 +160,7 @@ static void dump_tmpoutfile(int fd_out)
FILE *tmpoutfp;
int tmpchar;
if (control.flags & FLAG_SHOW_PROGRESS)
fprintf(control.msgout, "Dumping to stdout.\n");
print_progress("Dumping to stdout.\n");
/* flush anything not yet in the temporary file */
fflush(NULL);
tmpoutfp = fdopen(fd_out, "r");
@ -202,8 +196,7 @@ static void read_tmpinfile(int fd_in)
FILE *tmpinfp;
int tmpchar;
if (control.flags & FLAG_SHOW_PROGRESS)
fprintf(control.msgout, "Copying from stdin.\n");
print_progress("Copying from stdin.\n");
tmpinfp = fdopen(fd_in, "w+");
if (tmpinfp == NULL)
fatal("Failed to fdopen in tmpfile: %s\n", strerror(errno));
@ -224,7 +217,7 @@ static void decompress_file(void)
int fd_in, fd_out = -1, fd_hist = -1;
i64 expected_size;
if (!(control.flags & FLAG_STDIN)) {
if (!STDIN) {
if ((tmp = strrchr(control.infile, '.')) && strcmp(tmp,control.suffix)) {
/* make sure infile has an extension. If not, add it
* because manipulations may be made to input filename, set local ptr
@ -241,7 +234,7 @@ static void decompress_file(void)
/* regardless, infilecopy has the input filename */
}
if (!(control.flags & FLAG_STDOUT) && !(control.flags & FLAG_TEST_ONLY)) {
if (!STDOUT && !TEST_ONLY) {
/* if output name already set, use it */
if (control.outname) {
control.outfile = strdup(control.outname);
@ -271,13 +264,11 @@ static void decompress_file(void)
free(tmpoutfile);
}
if ((control.flags & FLAG_SHOW_PROGRESS) && !(control.flags & FLAG_STDOUT)) {
fprintf(control.msgout, "Output filename is: %s...Decompressing...\n", control.outfile);
fflush(control.msgout);
}
if (!STDOUT)
print_progress("Output filename is: %s...Decompressing...\n", control.outfile);
}
if (control.flags & FLAG_STDIN) {
if (STDIN) {
fd_in = open_tmpinfile();
read_tmpinfile(fd_in);
} else {
@ -289,15 +280,15 @@ static void decompress_file(void)
}
}
if ((control.flags & (FLAG_TEST_ONLY | FLAG_STDOUT)) == 0) {
if (control.flags & FLAG_FORCE_REPLACE)
if (!(TEST_ONLY | STDOUT)) {
if (FORCE_REPLACE)
fd_out = open(control.outfile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
else
fd_out = open(control.outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
if (fd_out == -1)
fatal("Failed to create %s: %s\n", control.outfile, strerror(errno));
if (!(control.flags & FLAG_NO_SET_PERMS))
if (!NO_SET_PERMS)
preserve_perms(fd_in, fd_out);
} else
fd_out = open_tmpoutfile();
@ -307,28 +298,23 @@ static void decompress_file(void)
fatal("Failed to open history file %s\n", control.outfile);
read_magic(fd_in, &expected_size);
if (control.flags & FLAG_SHOW_PROGRESS) {
fprintf(control.msgout, "Decompressing...");
fflush(control.msgout);
}
print_progress("Decompressing...");
runzip_fd(fd_in, fd_out, fd_hist, expected_size);
if (control.flags & FLAG_STDOUT)
if (STDOUT)
dump_tmpoutfile(fd_out);
/* if we get here, no fatal errors during decompression */
fprintf(control.msgout, "\r");
if (!(control.flags & (FLAG_STDOUT | FLAG_TEST_ONLY)))
fprintf(control.msgout, "Output filename is: %s: ", control.outfile);
if (control.flags & FLAG_SHOW_PROGRESS)
fprintf(control.msgout, "[OK] - %lld bytes \n", (long long)expected_size);
fflush(control.msgout);
print_progress("\r");
if (!(STDOUT | TEST_ONLY))
print_output("Output filename is: %s: ", control.outfile);
print_progress("[OK] - %lld bytes \n", expected_size);
if (close(fd_hist) != 0 || close(fd_out) != 0)
fatal("Failed to close files\n");
if (control.flags & (FLAG_TEST_ONLY | FLAG_STDOUT)) {
if (TEST_ONLY | STDOUT) {
/* Delete temporary files generated for testing or faking stdout */
if (unlink(control.outfile) != 0)
fatal("Failed to unlink tmpfile: %s\n", strerror(errno));
@ -336,7 +322,7 @@ static void decompress_file(void)
close(fd_in);
if (((control.flags & (FLAG_KEEP_FILES | FLAG_TEST_ONLY)) == 0) || (control.flags & FLAG_STDIN)) {
if (!(KEEP_FILES | TEST_ONLY) || STDIN) {
if (unlink(control.infile) != 0)
fatal("Failed to unlink %s: %s\n", infilecopy, strerror(errno));
}
@ -356,7 +342,7 @@ static void get_fileinfo(void)
char *tmp, *infilecopy = NULL;
if (!(control.flags & FLAG_STDIN)) {
if (!STDIN) {
if ((tmp = strrchr(control.infile, '.')) && strcmp(tmp,control.suffix)) {
infilecopy = malloc(strlen(control.infile) + strlen(control.suffix) + 1);
if (infilecopy == NULL)
@ -369,7 +355,7 @@ static void get_fileinfo(void)
infilecopy = strdup(control.infile);
}
if (control.flags & FLAG_STDIN) {
if (STDIN) {
fd_in = open_tmpinfile();
read_tmpinfile(fd_in);
} else {
@ -401,25 +387,25 @@ static void get_fileinfo(void)
cratio = (long double)expected_size / (long double)infile_size;
fprintf(control.msgout, "%s:\nlrzip version: %d.%d file\n", infilecopy, control.major_version, control.minor_version);
fprintf(control.msgout, "Compression: ");
print_output("%s:\nlrzip version: %d.%d file\n", infilecopy, control.major_version, control.minor_version);
print_output("Compression: ");
if (ctype == CTYPE_NONE)
fprintf(control.msgout, "rzip alone\n");
print_out("rzip alone\n");
else if (ctype == CTYPE_BZIP2)
fprintf(control.msgout, "rzip + bzip2\n");
print_out("rzip + bzip2\n");
else if (ctype == CTYPE_LZO)
fprintf(control.msgout, "rzip + lzo\n");
print_out("rzip + lzo\n");
else if (ctype == CTYPE_LZMA)
fprintf(control.msgout, "rzip + lzma\n");
print_out("rzip + lzma\n");
else if (ctype == CTYPE_GZIP)
fprintf(control.msgout, "rzip + gzip\n");
print_out("rzip + gzip\n");
else if (ctype == CTYPE_ZPAQ)
fprintf(control.msgout, "rzip + zpaq\n");
fprintf(control.msgout, "Decompressed file size: %llu\n", expected_size);
fprintf(control.msgout, "Compressed file size: %llu\n", infile_size);
fprintf(control.msgout, "Compression ratio: %.3Lf\n", cratio);
print_out("rzip + zpaq\n");
print_output("Decompressed file size: %llu\n", expected_size);
print_output("Compressed file size: %llu\n", infile_size);
print_output("Compression ratio: %.3Lf\n", cratio);
if (control.flags & FLAG_STDIN) {
if (STDIN) {
if (unlink(control.infile) != 0)
fatal("Failed to unlink %s: %s\n", infilecopy, strerror(errno));
}
@ -441,10 +427,10 @@ static void compress_file(void)
memset(header, 0, sizeof(header));
if (!(control.flags & FLAG_STDIN)) {
if (!STDIN) {
/* is extension at end of infile? */
if ((tmp = strrchr(control.infile, '.')) && !strcmp(tmp, control.suffix)) {
fprintf(control.msgout, "%s: already has %s suffix. Skipping...\n", control.infile, control.suffix);
print_output("%s: already has %s suffix. Skipping...\n", control.infile, control.suffix);
return;
}
@ -456,7 +442,7 @@ static void compress_file(void)
read_tmpinfile(fd_in);
}
if (!(control.flags & FLAG_STDOUT)) {
if (!STDOUT) {
if (control.outname) {
/* check if outname has control.suffix */
if (*(control.suffix) == '\0') /* suffix is empty string */
@ -467,7 +453,7 @@ static void compress_file(void)
fatal("Failed to allocate outfile name\n");
strcpy(control.outfile, control.outname);
strcat(control.outfile, control.suffix);
fprintf(control.msgout, "Suffix added to %s.\nFull pathname is: %s\n", control.outname, control.outfile);
print_out("Suffix added to %s.\nFull pathname is: %s\n", control.outname, control.outfile);
} else /* no, already has suffix */
control.outfile = strdup(control.outname);
} else {
@ -490,11 +476,10 @@ static void compress_file(void)
} else
strcpy(control.outfile, tmpinfile);
strcat(control.outfile, control.suffix);
if ( control.flags & FLAG_SHOW_PROGRESS )
fprintf(control.msgout, "Output filename is: %s\n", control.outfile);
print_progress("Output filename is: %s\n", control.outfile);
}
if (control.flags & FLAG_FORCE_REPLACE)
if (FORCE_REPLACE)
fd_out = open(control.outfile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
else
fd_out = open(control.outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
@ -503,7 +488,7 @@ static void compress_file(void)
} else
fd_out = open_tmpoutfile();
if (!(control.flags & FLAG_NO_SET_PERMS))
if (!NO_SET_PERMS)
preserve_perms(fd_in, fd_out);
/* write zeroes to 24 bytes at beginning of file */
@ -515,19 +500,19 @@ static void compress_file(void)
/* write magic at end b/c lzma does not tell us properties until it is done */
write_magic(fd_in, fd_out);
if (control.flags & FLAG_STDOUT)
if (STDOUT)
dump_tmpoutfile(fd_out);
if (close(fd_in) != 0 || close(fd_out) != 0)
fatal("Failed to close files\n");
if (control.flags & FLAG_STDOUT) {
if (STDOUT) {
/* Delete temporary files generated for testing or faking stdout */
if (unlink(control.outfile) != 0)
fatal("Failed to unlink tmpfile: %s\n", strerror(errno));
}
if ((control.flags & FLAG_KEEP_FILES) == 0 || (control.flags & FLAG_STDIN)) {
if (!KEEP_FILES || STDIN) {
if (unlink(control.infile) != 0)
fatal("Failed to unlink %s: %s\n", control.infile, strerror(errno));
}
@ -642,7 +627,7 @@ int main(int argc, char *argv[])
case 't':
if (control.outname)
fatal("Cannot specify an output file name when just testing.\n");
if (!(control.flags & FLAG_KEEP_FILES))
if (!KEEP_FILES)
fatal("Doubt that you want to delete a file when just testing.\n");
control.flags |= FLAG_TEST_ONLY;
break;
@ -659,7 +644,7 @@ int main(int argc, char *argv[])
control.flags &= ~FLAG_SHOW_PROGRESS;
break;
case 'V':
fprintf(stdout, "lrzip version %d.%d%d\n",
print_out("lrzip version %d.%d%d\n",
LRZIP_MAJOR_VERSION, LRZIP_MINOR_VERSION, LRZIP_MINOR_SUBVERSION);
exit(0);
break;
@ -734,8 +719,8 @@ int main(int argc, char *argv[])
if (control.outname && argc > 1)
fatal("Cannot specify output filename with more than 1 file\n");
if ((control.flags & FLAG_VERBOSE) && !(control.flags & FLAG_SHOW_PROGRESS)) {
fprintf(stderr, "Cannot have -v and -q options. -v wins.\n");
if (VERBOSE && !SHOW_PROGRESS) {
print_err("Cannot have -v and -q options. -v wins.\n");
control.flags |= FLAG_SHOW_PROGRESS;
}
@ -743,7 +728,7 @@ int main(int argc, char *argv[])
control.flags |= FLAG_STDIN;
if (control.window > control.ramsize)
fprintf(stderr, "Compression window has been set to larger than ramsize, proceeding at your request. If you did not mean this, abort now.\n");
print_output("Compression window has been set to larger than ramsize, proceeding at your request. If you did not mean this, abort now.\n");
if (sizeof(long) == 4 && control.ramsize > 9) {
/* On 32 bit, the default high/lowmem split of 896MB lowmem
@ -771,52 +756,52 @@ int main(int argc, char *argv[])
}
/* OK, if verbosity set, print summary of options selected */
if ((control.flags & FLAG_VERBOSE) && !(control.flags & FLAG_INFO)) {
fprintf(stderr, "The following options are in effect for this %s.\n",
if (VERBOSE && !INFO) {
print_err("The following options are in effect for this %s.\n",
control.flags & FLAG_DECOMPRESS ? "DECOMPRESSION" : "COMPRESSION");
if (LZMA_COMPRESS(control.flags))
fprintf(stderr, "Threading is %s. Number of CPUs detected: %lu\n", control.threads > 1? "ENABLED" : "DISABLED",
print_err("Threading is %s. Number of CPUs detected: %lu\n", control.threads > 1? "ENABLED" : "DISABLED",
control.threads);
fprintf(stderr, "Nice Value: %d\n", control.nice_val);
print_err("Nice Value: %d\n", control.nice_val);
if (control.flags & FLAG_SHOW_PROGRESS)
fprintf(stderr, "Show Progress\n");
print_err("Show Progress\n");
if (control.flags & FLAG_VERBOSITY)
fprintf(stderr, "Verbose\n");
print_err("Verbose\n");
else if (control.flags & FLAG_VERBOSITY_MAX)
fprintf(stderr, "Max Verbosity\n");
print_err("Max Verbosity\n");
if (control.flags & FLAG_FORCE_REPLACE)
fprintf(stderr, "Overwrite Files\n");
print_err("Overwrite Files\n");
if (!(control.flags & FLAG_KEEP_FILES))
fprintf(stderr, "Remove input files on completion\n");
print_err("Remove input files on completion\n");
if (control.outdir)
fprintf(stderr, "Output Directory Specified: %s\n", control.outdir);
print_err("Output Directory Specified: %s\n", control.outdir);
else if (control.outname)
fprintf(stderr, "Output Filename Specified: %s\n", control.outname);
print_err("Output Filename Specified: %s\n", control.outname);
if (control.flags & FLAG_TEST_ONLY)
fprintf(stderr, "Test file integrity\n");
print_err("Test file integrity\n");
/* show compression options */
if (!(control.flags & FLAG_DECOMPRESS)) {
fprintf(stderr, "Compression mode is: ");
print_err("Compression mode is: ");
if (LZMA_COMPRESS(control.flags))
fprintf(stderr, "LZMA. LZO Test Compression Threshold: %.f\n",
print_err("LZMA. LZO Test Compression Threshold: %.f\n",
(control.threshold < 1.05 ? 21 - control.threshold * 20 : 0));
else if (control.flags & FLAG_LZO_COMPRESS)
fprintf(stderr, "LZO\n");
print_err("LZO\n");
else if (control.flags & FLAG_BZIP2_COMPRESS)
fprintf(stderr, "BZIP2. LZO Test Compression Threshold: %.f\n",
print_err("BZIP2. LZO Test Compression Threshold: %.f\n",
(control.threshold < 1.05 ? 21 - control.threshold * 20 : 0));
else if (control.flags & FLAG_ZLIB_COMPRESS)
fprintf(stderr, "GZIP\n");
print_err("GZIP\n");
else if (control.flags & FLAG_ZPAQ_COMPRESS)
fprintf(stderr, "ZPAQ. LZO Test Compression Threshold: %.f\n",
print_err("ZPAQ. LZO Test Compression Threshold: %.f\n",
(control.threshold < 1.05 ? 21 - control.threshold * 20 : 0));
else if (control.flags & FLAG_NO_COMPRESS)
fprintf(stderr, "RZIP\n");
fprintf(stderr, "Compression Window: %lld = %lldMB\n", control.window, control.window * 100ull);
fprintf(stderr, "Compression Level: %d\n", control.compression_level);
print_err("RZIP\n");
print_err("Compression Window: %lld = %lldMB\n", control.window, control.window * 100ull);
print_err("Compression Level: %d\n", control.compression_level);
}
fprintf(stderr, "\n");
print_err("\n");
}
if (setpriority(PRIO_PROCESS, 0, control.nice_val) == -1)
@ -826,7 +811,7 @@ int main(int argc, char *argv[])
for (i = 0; i <= argc; i++) {
if (i < argc)
control.infile = argv[i];
else if (!(i == 0 && (control.flags & FLAG_STDIN)))
else if (!(i == 0 && STDIN))
break;
if (control.infile && (strcmp(control.infile, "-") == 0))
control.flags |= FLAG_STDIN;
@ -837,12 +822,12 @@ int main(int argc, char *argv[])
}
/* If we're using stdin and no output filename, use stdout */
if ((control.flags & FLAG_STDIN) && !control.outname) {
if (STDIN && !control.outname) {
control.flags |= FLAG_STDOUT;
control.msgout = stderr;
}
if (!(control.flags & FLAG_STDOUT))
if (!STDOUT)
control.msgout = stdout;
/* Implement signal handler only once flags are set */
handler.sa_handler = &sighandler;
@ -853,7 +838,7 @@ int main(int argc, char *argv[])
if (control.flags & (FLAG_DECOMPRESS | FLAG_TEST_ONLY))
decompress_file();
else if (control.flags & FLAG_INFO)
else if (INFO)
get_fileinfo();
else
compress_file();
@ -865,8 +850,8 @@ int main(int argc, char *argv[])
hours = (int)total_time / 3600;
minutes = (int)(total_time - hours * 3600) / 60;
seconds = total_time - hours * 60 - minutes * 60;
if ((control.flags & FLAG_SHOW_PROGRESS) && !(control.flags & FLAG_INFO))
fprintf(control.msgout, "Total time: %02d:%02d:%06.3f\n", hours, minutes, seconds);
if (!INFO)
print_progress("Total time: %02d:%02d:%06.3f\n", hours, minutes, seconds);
}
return 0;

11
runzip.c
View file

@ -37,6 +37,7 @@ static inline u32 read_u32(void *ss, int stream)
fatal("Stream read u32 failed\n");
return ret;
}
/* Read a variable length of chars dependant on how big the chunk was */
static inline i64 read_vchars(void *ss, int stream, int length)
{
@ -179,10 +180,10 @@ static i64 runzip_chunk(int fd_in, int fd_out, int fd_hist, i64 expected_size, i
break;
}
p = 100 * ((double)(tally + total) / (double)expected_size);
if (control.flags & FLAG_SHOW_PROGRESS) {
if (SHOW_PROGRESS) {
if ( p != l ) {
prog_done = (double)(tally + total) / (double)divisor[divisor_index];
fprintf(control.msgout, "%3d%% %9.2f / %9.2f %s\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
print_out("%3d%% %9.2f / %9.2f %s\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
p, prog_done, prog_tsize, suffix[divisor_index] );
fflush(control.msgout);
l = p;
@ -227,15 +228,13 @@ i64 runzip_fd(int fd_in, int fd_out, int fd_hist, i64 expected_size)
if (bits % 8)
chunk_bytes++;
}
if (control.flags & FLAG_VERBOSE)
fprintf(control.msgout, "Expected size: %lld\nChunk byte width: %d\n", expected_size, chunk_bytes);
print_maxverbose("\nExpected size: %lld\nChunk byte width: %d\n", expected_size, chunk_bytes);
while (total < expected_size)
total += runzip_chunk(fd_in, fd_out, fd_hist, expected_size, total, chunk_bytes);
gettimeofday(&end,NULL);
if (control.flags & FLAG_SHOW_PROGRESS)
fprintf(control.msgout, "\nAverage DeCompression Speed: %6.3fMB/s\n",
print_progress("\nAverage DeCompression Speed: %6.3fMB/s\n",
(total / 1024 / 1024) / (double)((end.tv_sec-start.tv_sec)? : 1));
return total;
}

59
rzip.c
View file

@ -250,10 +250,8 @@ static tag clean_one_from_hash(struct rzip_state *st)
again:
better_than_min = increase_mask(st->minimum_tag_mask);
if (control.flags & FLAG_VERBOSITY_MAX) {
if (!st->tag_clean_ptr)
fprintf(control.msgout, "\nStarting sweep for mask %u\n", (unsigned int)st->minimum_tag_mask);
}
print_maxverbose("\nStarting sweep for mask %u\n", (unsigned int)st->minimum_tag_mask);
for (; st->tag_clean_ptr < (1U << st->hash_bits); st->tag_clean_ptr++) {
if (empty_hash(st, st->tag_clean_ptr))
@ -382,9 +380,9 @@ static void show_distrib(struct rzip_state *st)
}
if (total != st->hash_count)
fprintf(control.msgout, "/tWARNING: hash_count says total %lld\n", st->hash_count);
print_out("/tWARNING: hash_count says total %lld\n", st->hash_count);
fprintf(control.msgout, "\t%lld total hashes -- %lld in primary bucket (%-2.3f%%)\n", total, primary,
print_out("\t%lld total hashes -- %lld in primary bucket (%-2.3f%%)\n", total, primary,
primary*100.0/total);
}
@ -409,8 +407,7 @@ static void hash_search(struct rzip_state *st, uchar *buf,
(1024 * 1024 / sizeof(st->hash_table[0]));
for (st->hash_bits = 0; (1U << st->hash_bits) < hashsize; st->hash_bits++);
if (control.flags & FLAG_VERBOSITY_MAX)
fprintf(control.msgout, "hashsize = %lld. bits = %lld. %luMB\n",
print_maxverbose("hashsize = %lld. bits = %lld. %luMB\n",
hashsize, st->hash_bits, st->level->mb_used);
/* 66% full at max. */
@ -476,7 +473,7 @@ static void hash_search(struct rzip_state *st, uchar *buf,
t = full_tag(st, p);
}
if ((control.flags & FLAG_SHOW_PROGRESS) && (p - buf) % 100 == 0) {
if (SHOW_PROGRESS && (p - buf) % 100 == 0) {
pct = pct_base + (pct_multiple * (100.0 * (p - buf)) /
st->chunk_size);
if (pct != lastpct) {
@ -484,7 +481,7 @@ static void hash_search(struct rzip_state *st, uchar *buf,
fstat(st->fd_in, &s1);
fstat(st->fd_out, &s2);
fprintf(control.msgout, "%2lld%%\r", pct);
print_out("%2lld%%\r", pct);
fflush(control.msgout);
lastpct = pct;
}
@ -535,8 +532,7 @@ static void rzip_chunk(struct rzip_state *st, int fd_in, int fd_out, i64 offset,
* faster than slowly reading in the file and then failing. Filling
* it with zeroes has a defragmenting effect on ram before the real
* read in. */
if (control.flags & FLAG_VERBOSE)
fprintf(control.msgout, "Preallocating ram...\n");
print_verbose("Preallocating ram...\n");
while (buf == (void*)-1) {
/* If we fail to mmap the full amount, it is worth trying to
* mmap ever smaller sizes till we succeed as we may be able
@ -547,15 +543,13 @@ static void rzip_chunk(struct rzip_state *st, int fd_in, int fd_out, i64 offset,
prealloc_size = prealloc_size / 10 * 9;
continue;
}
if (control.flags & FLAG_VERBOSE)
fprintf(control.msgout, "Preallocated %lld ram...\n", prealloc_size);
print_maxverbose("Preallocated %lld ram...\n", prealloc_size);
if (!memset(buf, 0, prealloc_size))
fatal("Failed to memset in rzip_chunk\n");
if (munmap(buf, prealloc_size) != 0)
fatal("Failed to munmap in rzip_chunk\n");
}
if (control.flags & FLAG_VERBOSE)
fprintf(control.msgout, "Reading file into mmapped ram...\n");
print_verbose("Reading file into mmapped ram...\n");
buf = (uchar *)mmap(buf, st->chunk_size, PROT_READ, MAP_SHARED, fd_in, offset);
if (buf == (uchar *)-1)
fatal("Failed to map buffer in rzip_chunk\n");
@ -603,15 +597,13 @@ void rzip_fd(int fd_in, int fd_out)
fatal("Failed to stat fd_in in rzip_fd - %s\n", strerror(errno));
len = s.st_size;
if (control.flags & FLAG_VERBOSE)
fprintf(control.msgout, "File size: %lld\n", len);
print_verbose("File size: %lld\n", len);
while (len >> bits > 0)
bits++;
st->chunk_bytes = bits / 8;
if (bits % 8)
st->chunk_bytes++;
if (control.flags & FLAG_VERBOSE)
fprintf(control.msgout, "Byte width: %d\n", st->chunk_bytes);
print_maxverbose("Byte width: %d\n", st->chunk_bytes);
chunk_window = control.window * CHUNK_MULTIPLE;
@ -635,16 +627,15 @@ void rzip_fd(int fd_in, int fd_out)
* running out of memory when we allocate ram again on the
* next chunk. It will also prevent thrashing on-disk due to
* concurrent reads and writes if we're on the same device. */
if (last_chunk && control.flags & FLAG_VERBOSE)
fprintf(control.msgout, "Flushing data to disk.\n");
if (last_chunk)
print_verbose("Flushing data to disk.\n");
fsync(fd_out);
chunk = chunk_window;
if (chunk > len)
chunk = len;
limit = chunk;
st->chunk_size = chunk;
if (control.flags & FLAG_VERBOSE)
fprintf(control.msgout, "Chunk size: %lld\n\n", chunk);
print_maxverbose("Chunk size: %lld\n\n", chunk);
pct_base = (100.0 * (s.st_size - len)) / s.st_size;
pct_multiple = ((double)chunk) / s.st_size;
@ -653,7 +644,7 @@ void rzip_fd(int fd_in, int fd_out)
gettimeofday(&current, NULL);
/* this will count only when size > window */
if (last.tv_sec > 0) {
if (control.flags & FLAG_VERBOSE) {
if (VERBOSE) {
elapsed_time = current.tv_sec - start.tv_sec;
finish_time = elapsed_time / (pct_base / 100.0);
elapsed_hours = (unsigned int)(elapsed_time) / 3600;
@ -663,7 +654,7 @@ void rzip_fd(int fd_in, int fd_out)
eta_minutes = (unsigned int)((finish_time - elapsed_time) - eta_hours * 3600) / 60;
eta_seconds = (unsigned int)(finish_time - elapsed_time) - eta_hours * 60 - eta_minutes * 60;
chunkmbs=(last_chunk / 1024 / 1024) / (double)(current.tv_sec-last.tv_sec);
fprintf(control.msgout, "\nPass %d / %d -- Elapsed Time: %02d:%02d:%02d. ETA: %02d:%02d:%02d. Compress Speed: %3.3fMB/s.\n",
print_out("\nPass %d / %d -- Elapsed Time: %02d:%02d:%02d. ETA: %02d:%02d:%02d. Compress Speed: %3.3fMB/s.\n",
pass, passes, elapsed_hours, elapsed_minutes, elapsed_seconds,
eta_hours, eta_minutes, eta_seconds, chunkmbs);
}
@ -680,24 +671,20 @@ void rzip_fd(int fd_in, int fd_out)
fstat(fd_out, &s2);
if (control.flags & FLAG_VERBOSITY_MAX) {
fprintf(control.msgout, "matches=%u match_bytes=%u\n",
print_maxverbose("matches=%u match_bytes=%u\n",
(unsigned int)st->stats.matches, (unsigned int)st->stats.match_bytes);
fprintf(control.msgout, "literals=%u literal_bytes=%u\n",
print_maxverbose("literals=%u literal_bytes=%u\n",
(unsigned int)st->stats.literals, (unsigned int)st->stats.literal_bytes);
fprintf(control.msgout, "true_tag_positives=%u false_tag_positives=%u\n",
print_maxverbose("true_tag_positives=%u false_tag_positives=%u\n",
(unsigned int)st->stats.tag_hits, (unsigned int)st->stats.tag_misses);
fprintf(control.msgout, "inserts=%u match %.3f\n",
print_maxverbose("inserts=%u match %.3f\n",
(unsigned int)st->stats.inserts,
(1.0 + st->stats.match_bytes) / st->stats.literal_bytes);
}
if (control.flags & FLAG_SHOW_PROGRESS) {
if (!(control.flags & FLAG_STDIN))
fprintf(control.msgout, "%s - ", control.infile);
fprintf(control.msgout, "Compression Ratio: %.3f. Average Compression Speed: %6.3fMB/s.\n",
if (!STDIN)
print_progress("%s - ", control.infile);
print_progress("Compression Ratio: %.3f. Average Compression Speed: %6.3fMB/s.\n",
1.0 * s.st_size / s2.st_size, chunkmbs);
}
if (st->hash_table)
free(st->hash_table);

39
rzip.h
View file

@ -140,6 +140,17 @@ typedef uint32_t u32;
#define FLAG_NOT_LZMA (FLAG_NO_COMPRESS | FLAG_LZO_COMPRESS | FLAG_BZIP2_COMPRESS | FLAG_ZLIB_COMPRESS | FLAG_ZPAQ_COMPRESS)
#define LZMA_COMPRESS(C) (!((C) & FLAG_NOT_LZMA))
#define SHOW_PROGRESS (control.flags & FLAG_SHOW_PROGRESS)
#define KEEP_FILES (control.flags & FLAG_KEEP_FILES)
#define TEST_ONLY (control.flags & FLAG_TEST_ONLY)
#define FORCE_REPLACE (control.flags & FLAG_FORCE_REPLACE)
#define VERBOSE (control.flags & FLAG_VERBOSE)
#define MAX_VERBOSE (control.flags & FLAG_VERBOSITY_MAX)
#define NO_SET_PERMS (control.flags & FLAG_NO_SET_PERMS)
#define STDIN (control.flags & FLAG_STDIN)
#define STDOUT (control.flags & FLAG_STDOUT)
#define INFO (control.flags & FLAG_INFO)
#define CTYPE_NONE 3
#define CTYPE_BZIP2 4
#define CTYPE_LZO 5
@ -184,3 +195,31 @@ ssize_t write_1g(int fd, void *buf, i64 len);
ssize_t read_1g(int fd, void *buf, i64 len);
extern void zpipe_compress(FILE *in, FILE *out, FILE *msgout, long long int buf_len, int progress);
extern void zpipe_decompress(FILE *in, FILE *out, FILE *msgout, long long int buf_len, int progress);
#define print_out(format, args...) do {\
fprintf(stdout, format, ##args); \
} while (0)
#define print_err(format, args...) do {\
fprintf(stderr, format, ##args); \
} while (0)
#define print_output(format, args...) do {\
fprintf(control.msgout, format, ##args); \
fflush(control.msgout); \
} while (0)
#define print_progress(format, args...) do {\
if (SHOW_PROGRESS) \
print_output(format, ##args); \
} while (0)
#define print_verbose(format, args...) do {\
if (VERBOSE) \
print_output(format, ##args); \
} while (0)
#define print_maxverbose(format, args...) do {\
if (MAX_VERBOSE) \
print_output(format, ##args); \
} while (0)

31
stream.c
View file

@ -226,10 +226,7 @@ static void lzma_compress_buf(struct stream *s, int *c_type, i64 *c_len)
if (!c_buf)
return;
if (control.flags & FLAG_SHOW_PROGRESS) {
fprintf(control.msgout, "\tProgress percentage pausing during lzma compression...");
fflush(control.msgout);
}
print_progress("\tProgress percentage pausing during lzma compression...");
/* with LZMA SDK 4.63, we pass compression level and threads only
* and receive properties in control->lzma_properties */
@ -270,11 +267,10 @@ static void lzma_compress_buf(struct stream *s, int *c_type, i64 *c_len)
s->buf = c_buf;
*c_type = CTYPE_LZMA;
out:
if (control.flags & FLAG_VERBOSITY_MAX)
fprintf(control.msgout, "\n");
else if ((control.flags & FLAG_SHOW_PROGRESS || control.flags & FLAG_VERBOSITY ))
fprintf(control.msgout, "\r\t \r");
fflush(control.msgout);
if (MAX_VERBOSE)
print_out("\n");
else if (SHOW_PROGRESS || VERBOSE)
print_out("\r\t \r");
}
static void lzo_compress_buf(struct stream *s, int *c_type, i64 *c_len)
@ -1006,10 +1002,7 @@ static int lzo_compresses(struct stream *s)
if (!c_buf)
fatal("Unable to allocate c_buf in lzo_compresses\n");
if (control.flags & FLAG_SHOW_PROGRESS) {
fprintf(control.msgout, "\tlzo testing for incompressible data...");
fflush(control.msgout);
}
print_progress("\tlzo testing for incompressible data...");
/* Test progressively larger blocks at a time and as soon as anything
compressible is found, jump out as a success */
@ -1033,15 +1026,13 @@ static int lzo_compresses(struct stream *s)
in_len = MIN(test_len, buftest_size);
}
}
if (control.flags & FLAG_VERBOSITY_MAX)
fprintf(control.msgout, "%s for chunk %ld. Compressed size = %5.2F%% of chunk, %d Passes\n",
if (MAX_VERBOSE)
print_out("%s for chunk %ld. Compressed size = %5.2F%% of chunk, %d Passes\n",
(ret == 0? "FAILED - below threshold" : "OK"), save_len,
100 * ((double) best_dlen / (double) in_len), workcounter);
else if (control.flags & FLAG_VERBOSITY)
fprintf(control.msgout, "%s\r", (ret == 0? "FAILED - below threshold" : "OK"));
else if (control.flags & FLAG_SHOW_PROGRESS)
fprintf(control.msgout, "\r\t \r");
fflush(control.msgout);
else if (VERBOSE)
print_out("%s\r", (ret == 0? "FAILED - below threshold" : "OK"));
else print_progress("\r\t \r");
free(wrkmem);
free(c_buf);