summaryrefslogtreecommitdiffstats
path: root/lziprecover.cc
diff options
context:
space:
mode:
Diffstat (limited to 'lziprecover.cc')
-rw-r--r--lziprecover.cc613
1 files changed, 556 insertions, 57 deletions
diff --git a/lziprecover.cc b/lziprecover.cc
index 3acd46c..3f1b130 100644
--- a/lziprecover.cc
+++ b/lziprecover.cc
@@ -1,4 +1,4 @@
-/* Lziprecover - Member recoverer program for lzip compressed files
+/* Lziprecover - Data recovery tool for lzip compressed files
Copyright (C) 2008, 2009, 2010 Antonio Diaz Diaz.
This program is free software: you can redistribute it and/or modify
@@ -23,7 +23,9 @@
#define _FILE_OFFSET_BITS 64
+#include <algorithm>
#include <cerrno>
+#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
@@ -33,9 +35,30 @@
#include <stdint.h>
#include <unistd.h>
#include <sys/stat.h>
+#if defined(__MSVCRT__)
+#define S_IRGRP 0
+#define S_IWGRP 0
+#define S_IROTH 0
+#define S_IWOTH 0
+#endif
#include "arg_parser.h"
#include "lzip.h"
+#include "decoder.h"
+
+#if CHAR_BIT != 8
+#error "Environments where CHAR_BIT != 8 are not supported."
+#endif
+
+#ifndef LLONG_MAX
+#define LLONG_MAX 0x7FFFFFFFFFFFFFFFLL
+#endif
+#ifndef LLONG_MIN
+#define LLONG_MIN (-LLONG_MAX - 1LL)
+#endif
+#ifndef ULLONG_MAX
+#define ULLONG_MAX 0xFFFFFFFFFFFFFFFFULL
+#endif
namespace {
@@ -51,18 +74,43 @@ const int o_binary = O_BINARY;
const int o_binary = 0;
#endif
+int verbosity = 0;
+
+
+class Block
+ {
+ long long pos_, size_; // pos + size <= LLONG_MAX
+
+public:
+ Block( const long long p, const long long s ) throw()
+ : pos_( p ), size_( s ) {}
+
+ long long pos() const throw() { return pos_; }
+ long long size() const throw() { return size_; }
+ long long end() const throw() { return pos_ + size_; }
+
+ void pos( const long long p ) throw() { pos_ = p; }
+ void size( const long long s ) throw() { size_ = s; }
+ void shift( Block & b ) throw() { ++size_; ++b.pos_; --b.size_; }
+ };
+
void show_help() throw()
{
- std::printf( "%s - Member recoverer program for lzip compressed files.\n", Program_name );
- std::printf( "\nSearches for members in .lz files, and writes each member in its own .lz\n" );
- std::printf( "file. You can then use `lzip -t' to test the integrity of the resulting\n" );
- std::printf( "files, and decompress those which are undamaged.\n" );
- std::printf( "\nUsage: %s [options] file\n", invocation_name );
- std::printf( "Options:\n" );
+ std::printf( "%s - Data recovery tool for lzip compressed files.\n", Program_name );
+ std::printf( "\nUsage: %s [options] [files]\n", invocation_name );
+ std::printf( "\nOptions:\n" );
std::printf( " -h, --help display this help and exit\n" );
std::printf( " -V, --version output version information and exit\n" );
+// std::printf( " -c, --create-recover-file create a recover file\n" );
+ std::printf( " -f, --force overwrite existing output files\n" );
+ std::printf( " -m, --merge correct errors in file using several copies\n" );
+ std::printf( " -o, --output=<file> place the output into <file>\n" );
std::printf( " -q, --quiet suppress all messages\n" );
+// std::printf( " -r, --recover correct errors in file using a recover file\n" );
+ std::printf( " -R, --repair try to repair a small error in file\n" );
+ std::printf( " -s, --split split a multimember file in single-member files\n" );
+// std::printf( " -u, --update convert file from version 0 to version 1\n" );
std::printf( " -v, --verbose be verbose (a 2nd -v gives more)\n" );
std::printf( "\nReport bugs to lzip-bug@nongnu.org\n");
std::printf( "Lzip home page: http://www.nongnu.org/lzip/lzip.html\n" );
@@ -95,7 +143,7 @@ int open_instream( const std::string & input_filename ) throw()
if( i < 0 || !S_ISREG( in_stats.st_mode ) )
{
if( verbosity >= 0 )
- std::fprintf( stderr, "%s: input file `%s' is not a regular file.\n",
+ std::fprintf( stderr, "%s: Input file `%s' is not a regular file.\n",
program_name, input_filename.c_str() );
close( infd );
infd = -1;
@@ -105,14 +153,21 @@ int open_instream( const std::string & input_filename ) throw()
}
-int open_outstream( const std::string & output_filename ) throw()
+int open_outstream( const std::string & output_filename,
+ const bool force ) throw()
{
- int outfd = open( output_filename.c_str(),
- O_CREAT | O_TRUNC | O_WRONLY | o_binary,
+ int flags = O_CREAT | O_RDWR | o_binary;
+ if( force ) flags |= O_TRUNC; else flags |= O_EXCL;
+
+ int outfd = open( output_filename.c_str(), flags,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH );
- if( outfd < 0 )
+ if( outfd < 0 && verbosity >= 0 )
{
- if( verbosity >= 0 )
+ if( errno == EEXIST )
+ std::fprintf( stderr, "%s: Output file `%s' already exists."
+ " Use `--force' to overwrite it.\n",
+ program_name, output_filename.c_str() );
+ else
std::fprintf( stderr, "%s: Can't create output file `%s': %s.\n",
program_name, output_filename.c_str(), std::strerror( errno ) );
}
@@ -120,36 +175,22 @@ int open_outstream( const std::string & output_filename ) throw()
}
-bool next_filename( std::string & output_filename )
- {
- for( int i = 7; i >= 3; --i ) // "rec00001"
- {
- if( output_filename[i] < '9' ) { ++output_filename[i]; return true; }
- else output_filename[i] = '0';
- }
- return false;
- }
-
-
-bool verify_header( const uint8_t * const buffer, const int pos )
+bool verify_header( const File_header & header )
{
- File_header header;
- for( int i = 0; i < File_header::size; ++i )
- header.data[i] = buffer[pos+i];
if( !header.verify_magic() )
{
- show_error( "bad magic number (file not in lzip format).\n" );
+ show_error( "Bad magic number (file not in lzip format)." );
return false;
}
if( header.version() == 0 )
{
- show_error( "version 0 member format can't be recovered.\n" );
+ show_error( "Version 0 member format can't be recovered." );
return false;
}
if( header.version() != 1 )
{
if( verbosity >= 0 )
- std::fprintf( stderr, "version %d member format not supported, newer %s needed.\n",
+ std::fprintf( stderr, "Version %d member format not supported, newer %s needed.\n",
header.version(), program_name );
return false;
}
@@ -157,7 +198,396 @@ bool verify_header( const uint8_t * const buffer, const int pos )
}
-int process_file( const std::string & input_filename, uint8_t * & base_buffer )
+bool verify_single_member( const int fd, const long long file_size )
+ {
+ File_header header;
+ if( lseek( fd, 0, SEEK_SET ) < 0 ||
+ readblock( fd, header.data, File_header::size ) != File_header::size )
+ { show_error( "Error reading member header", errno ); return false; }
+ if( !verify_header( header ) ) return false;
+
+ File_trailer trailer;
+ if( lseek( fd, -File_trailer::size(), SEEK_END ) < 0 ||
+ readblock( fd, trailer.data, File_trailer::size() ) != File_trailer::size() )
+ { show_error( "Error reading member trailer", errno ); return false; }
+ const long long member_size = trailer.member_size();
+ if( member_size != file_size )
+ {
+ if( member_size < file_size &&
+ lseek( fd, -member_size, SEEK_END ) > 0 &&
+ readblock( fd, header.data, File_header::size ) == File_header::size &&
+ verify_header( header ) )
+ show_error( "Input file has more than 1 member. Split it first." );
+ else
+ show_error( "Member size in input file trailer is corrupt." );
+ return false;
+ }
+ return true;
+ }
+
+
+bool try_decompress( const int fd, const long long file_size,
+ long long * failure_pos = 0 )
+ {
+ try {
+ Range_decoder rdec( fd );
+ File_header header;
+ rdec.reset_member_position();
+ for( int i = 0; i < File_header::size; ++i )
+ header.data[i] = rdec.get_byte();
+ if( !rdec.finished() && // End Of File
+ header.verify_magic() &&
+ header.version() == 1 &&
+ header.dictionary_size() >= min_dictionary_size &&
+ header.dictionary_size() <= max_dictionary_size )
+ {
+ LZ_decoder decoder( header, rdec, -1 );
+ std::vector< std::string > dummy_filenames;
+ Pretty_print dummy( dummy_filenames, -1 );
+
+ if( decoder.decode_member( dummy ) == 0 &&
+ rdec.member_position() == file_size ) return true;
+ if( failure_pos ) *failure_pos = rdec.member_position();
+ }
+ }
+ catch( std::bad_alloc )
+ {
+ show_error( "Not enough memory. Find a machine with more memory." );
+ std::exit( 1 );
+ }
+ catch( Error e ) {}
+ return false;
+ }
+
+
+bool copy_and_diff_file( const std::vector< int > & infd_vector,
+ const int outfd, std::vector< Block > & block_vector )
+ {
+ const int buffer_size = 65536;
+ std::vector< uint8_t * > buffer_vector( infd_vector.size() );
+ for( unsigned int i = 0; i < infd_vector.size(); ++i )
+ buffer_vector[i] = new uint8_t[buffer_size];
+ Block b( 0, 0 );
+ long long partial_pos = 0;
+ int equal_bytes = 0;
+ bool error = false;
+
+ while( !error )
+ {
+ const int rd = readblock( infd_vector[0], buffer_vector[0], buffer_size );
+ if( rd != buffer_size && errno )
+ { show_error( "Error reading input file", errno ); error = true; }
+ if( rd > 0 )
+ {
+ for( unsigned int i = 1; i < infd_vector.size(); ++i )
+ if( readblock( infd_vector[i], buffer_vector[i], rd ) != rd )
+ { show_error( "Error reading input file", errno ); error = true; }
+ const int wr = writeblock( outfd, buffer_vector[0], rd );
+ if( wr != rd )
+ { show_error( "Error writing output file", errno ); error = true; }
+ for( int i = 0; i < rd; ++i )
+ {
+ while( i < rd && b.pos() == 0 )
+ {
+ for( unsigned int j = 1; j < infd_vector.size(); ++j )
+ if( buffer_vector[0][i] != buffer_vector[j][i] )
+ { b.pos( partial_pos + i ); break; } // begin block
+ ++i;
+ }
+ while( i < rd && b.pos() > 0 )
+ {
+ ++equal_bytes;
+ for( unsigned int j = 1; j < infd_vector.size(); ++j )
+ if( buffer_vector[0][i] != buffer_vector[j][i] )
+ { equal_bytes = 0; break; }
+ if( equal_bytes >= 2 ) // end block
+ {
+ b.size( partial_pos + i - ( equal_bytes - 1 ) - b.pos() );
+ block_vector.push_back( b );
+ b.pos( 0 );
+ equal_bytes = 0;
+ }
+ ++i;
+ }
+ }
+ partial_pos += rd;
+ }
+ if( rd < buffer_size ) break; // EOF
+ }
+ if( b.pos() > 0 ) // finish last block
+ {
+ b.size( partial_pos - b.pos() );
+ block_vector.push_back( b );
+ }
+ for( unsigned int i = 0; i < infd_vector.size(); ++i )
+ delete[] buffer_vector[i];
+ return !error;
+ }
+
+
+bool copy_file( const int infd, const int outfd,
+ const long long size = LLONG_MAX )
+ {
+ long long rest = size;
+ const int buffer_size = 65536;
+ uint8_t * const buffer = new uint8_t[buffer_size];
+ bool error = false;
+
+ while( !error )
+ {
+ const int block_size = std::min( (long long)buffer_size, rest );
+ if( block_size <= 0 ) break;
+ const int rd = readblock( infd, buffer, block_size );
+ if( rd != block_size && errno )
+ { show_error( "Error reading input file", errno ); error = true; }
+ if( rd > 0 )
+ {
+ const int wr = writeblock( outfd, buffer, rd );
+ if( wr != rd )
+ { show_error( "Error writing output file", errno ); error = true; }
+ rest -= rd;
+ }
+ if( rd < block_size ) break; // EOF
+ }
+ delete[] buffer;
+ return !error;
+ }
+
+
+std::string insert_fixed( std::string name ) throw()
+ {
+ if( name.size() > 4 && name.compare( name.size() - 4, 4, ".tlz" ) == 0 )
+ name.insert( name.size() - 4, "_fixed" );
+ else if( name.size() > 3 && name.compare( name.size() - 3, 3, ".lz" ) == 0 )
+ name.insert( name.size() - 3, "_fixed" );
+ else name += "_fixed.lz";
+ return name;
+ }
+
+
+int ipow( const unsigned int base, const unsigned int exponent ) throw()
+ {
+ int result = 1;
+ for( unsigned int i = 0; i < exponent; ++i )
+ {
+ if( INT_MAX / base >= (unsigned int)result ) result *= base;
+ else { result = INT_MAX; break; }
+ }
+ return result;
+ }
+
+
+int merge_files( const std::vector< std::string > & filenames,
+ const std::string & output_filename, const bool force )
+ {
+ std::vector< int > infd_vector( filenames.size() );
+ for( unsigned int i = 0; i < filenames.size(); ++i )
+ {
+ infd_vector[i] = open_instream( filenames[i] );
+ if( infd_vector[i] < 0 ) return 1;
+ }
+ long long isize = 0;
+ for( unsigned int i = 0; i < filenames.size(); ++i )
+ {
+ const long long tmp = lseek( infd_vector[i], 0, SEEK_END );
+ if( tmp < 0 )
+ {
+ if( verbosity >= 0 )
+ std::fprintf( stderr, "File `%s' is not seekable.\n", filenames[i].c_str() );
+ return 1;
+ }
+ if( i == 0 ) isize = tmp;
+ else if( isize != tmp )
+ { show_error( "Sizes of input files are different." ); return 1; }
+ }
+ if( isize < 36 )
+ { show_error( "Input file is too short." ); return 2; }
+ for( unsigned int i = 0; i < filenames.size(); ++i )
+ if( !verify_single_member( infd_vector[i], isize ) )
+ return 2;
+ for( unsigned int i = 0; i < filenames.size(); ++i )
+ if( lseek( infd_vector[i], 0, SEEK_SET ) < 0 )
+ { show_error( "Seek error in input file", errno ); return 1; }
+ for( unsigned int i = 0; i < filenames.size(); ++i )
+ if( try_decompress( infd_vector[i], isize ) )
+ {
+ if( verbosity >= 0 )
+ std::printf( "File `%s' has no errors. Recovery is not needed.\n",
+ filenames[i].c_str() );
+ return 0;
+ }
+
+ const int outfd = open_outstream( output_filename, force );
+ if( outfd < 0 ) return 1;
+ for( unsigned int i = 0; i < filenames.size(); ++i )
+ if( lseek( infd_vector[i], 0, SEEK_SET ) < 0 )
+ { show_error( "Seek error in input file", errno ); return 1; }
+
+ // vector of data blocks differing among the copies of the input file.
+ std::vector< Block > block_vector;
+ if( !copy_and_diff_file( infd_vector, outfd, block_vector ) ) return 1;
+
+ if( !block_vector.size() )
+ { show_error( "Input files are identical. Recovery is not possible." );
+ return 1; }
+
+ const bool single_block = ( block_vector.size() == 1 );
+ if( single_block && block_vector[0].size() < 2 )
+ { show_error( "Input files have the same byte damaged."
+ " Try repairing one of them." );
+ return 1; }
+
+ if( ipow( filenames.size(), block_vector.size() ) >= INT_MAX ||
+ ( single_block &&
+ ipow( filenames.size(), 2 ) >= INT_MAX / block_vector[0].size() ) )
+ { show_error( "Input files are too damaged. Recovery is not possible." );
+ return 1; }
+
+ const int shifts = ( single_block ? block_vector[0].size() - 1 : 1 );
+ if( single_block )
+ {
+ Block b( block_vector[0].pos() + 1, block_vector[0].size() - 1 );
+ block_vector[0].size( 1 );
+ block_vector.push_back( b );
+ }
+
+ const int base_variations = ipow( filenames.size(), block_vector.size() );
+ const int variations = ( base_variations * shifts ) - 2;
+ bool done = false;
+ for( int var = 1; var <= variations; ++var )
+ {
+ if( verbosity >= 0 )
+ {
+ std::printf( "Trying variation %d of %d \r", var, variations );
+ std::fflush( stdout );
+ }
+ int tmp = var;
+ for( unsigned int i = 0; i < block_vector.size(); ++i )
+ {
+ const int infd = infd_vector[tmp % filenames.size()];
+ tmp /= filenames.size();
+ if( lseek( infd, block_vector[i].pos(), SEEK_SET ) < 0 ||
+ lseek( outfd, block_vector[i].pos(), SEEK_SET ) < 0 ||
+ !copy_file( infd, outfd, block_vector[i].size() ) )
+ { show_error( "Error reading output file", errno ); return 1; }
+ }
+ if( lseek( outfd, 0, SEEK_SET ) < 0 )
+ { show_error( "Seek error in output file", errno ); return 1; }
+ if( try_decompress( outfd, isize ) )
+ { done = true; break; }
+ if( var % base_variations == 0 ) block_vector[0].shift( block_vector[1] );
+ }
+ if( verbosity >= 0 ) std::printf( "\n" );
+
+ if( close( outfd ) != 0 )
+ { show_error( "Error closing output file", errno ); return 1; }
+ if( done )
+ {
+ if( verbosity >= 0 )
+ std::printf( "Input files merged successfully.\n" );
+ return 0;
+ }
+ else
+ {
+ std::remove( output_filename.c_str() );
+ show_error( "Some error areas overlap. Can't recover input file." );
+ return 2;
+ }
+ }
+
+
+int repair_file( const std::string & input_filename,
+ const std::string & output_filename, const bool force )
+ {
+ const int infd = open_instream( input_filename );
+ if( infd < 0 ) return 1;
+ const long long isize = lseek( infd, 0, SEEK_END );
+ if( isize < 0 )
+ { show_error( "Input file is not seekable", errno ); return 1; }
+ if( isize < 36 )
+ { show_error( "Input file is too short." ); return 2; }
+ if( !verify_single_member( infd, isize ) ) return 2;
+ if( lseek( infd, 0, SEEK_SET ) < 0 )
+ { show_error( "Seek error in input file", errno ); return 1; }
+ long long failure_pos = 0;
+ if( try_decompress( infd, isize, &failure_pos ) )
+ {
+ if( verbosity >= 0 )
+ std::printf( "Input file has no errors. Recovery is not needed.\n" );
+ return 0;
+ }
+ if( failure_pos >= isize - 8 ) failure_pos = isize - 8 - 1;
+ if( failure_pos < File_header::size )
+ { show_error( "Can't repair error in input file." ); return 2; }
+
+ const int outfd = open_outstream( output_filename, force );
+ if( outfd < 0 ) { close( infd ); return 1; }
+ if( lseek( infd, 0, SEEK_SET ) < 0 )
+ { show_error( "Seek error in input file", errno ); return 1; }
+ if( !copy_file( infd, outfd ) ) return 1;
+
+ const long long min_pos =
+ std::max( (long long)File_header::size, failure_pos - 1000 );
+ bool done = false;
+ for( long long pos = failure_pos; pos >= min_pos; --pos )
+ {
+ if( verbosity >= 0 )
+ {
+ std::printf( "Trying position %lld \r", pos );
+ std::fflush( stdout );
+ }
+ uint8_t byte;
+ if( lseek( outfd, pos, SEEK_SET ) < 0 ||
+ readblock( outfd, &byte, 1 ) != 1 )
+ { show_error( "Error reading output file", errno ); return 1; }
+ for( int i = 0; i < 255; ++i )
+ {
+ ++byte;
+ if( lseek( outfd, pos, SEEK_SET ) < 0 ||
+ writeblock( outfd, &byte, 1 ) != 1 ||
+ lseek( outfd, 0, SEEK_SET ) < 0 )
+ { show_error( "Error writing output file", errno ); return 1; }
+ if( try_decompress( outfd, isize ) )
+ { done = true; break; }
+ }
+ if( done ) break;
+ ++byte;
+ if( lseek( outfd, pos, SEEK_SET ) < 0 ||
+ writeblock( outfd, &byte, 1 ) != 1 )
+ { show_error( "Error writing output file", errno ); return 1; }
+ }
+ if( verbosity >= 0 ) std::printf( "\n" );
+
+ if( close( outfd ) != 0 )
+ { show_error( "Error closing output file", errno ); return 1; }
+ if( done )
+ {
+ if( verbosity >= 0 )
+ std::printf( "Copy of input file repaired successfully.\n" );
+ return 0;
+ }
+ else
+ {
+ std::remove( output_filename.c_str() );
+ show_error( "Error is larger than 1 byte. Can't repair input file." );
+ return 2;
+ }
+ }
+
+
+bool next_filename( std::string & output_filename )
+ {
+ for( int i = 7; i >= 3; --i ) // "rec00001"
+ {
+ if( output_filename[i] < '9' ) { ++output_filename[i]; return true; }
+ else output_filename[i] = '0';
+ }
+ return false;
+ }
+
+
+int do_split_file( const std::string & input_filename, uint8_t * & base_buffer,
+ const std::string & default_output_filename, const bool force )
{
const int hsize = File_header::size;
const int tsize = File_trailer::size();
@@ -171,13 +601,17 @@ int process_file( const std::string & input_filename, uint8_t * & base_buffer )
int size = readblock( infd, buffer, buffer_size + hsize ) - hsize;
bool at_stream_end = ( size < buffer_size );
if( size != buffer_size && errno )
- { show_error( "read error", errno ); return 1; }
+ { show_error( "Read error", errno ); return 1; }
if( size <= tsize )
- { show_error( "file too short" ); return 2; }
- if( !verify_header( buffer, 0 ) ) return 2;
+ { show_error( "Input file is too short." ); return 2; }
+ File_header header;
+ for( int i = 0; i < File_header::size; ++i )
+ header.data[i] = buffer[i];
+ if( !verify_header( header ) ) return 2;
- std::string output_filename( "rec00001" ); output_filename += input_filename;
- int outfd = open_outstream( output_filename );
+ std::string output_filename( "rec00001" );
+ output_filename += default_output_filename;
+ int outfd = open_outstream( output_filename, force );
if( outfd < 0 ) { close( infd ); return 1; }
long long partial_member_size = 0;
@@ -197,12 +631,12 @@ int process_file( const std::string & input_filename, uint8_t * & base_buffer )
{ // header found
const int wr = writeblock( outfd, buffer + pos, newpos - pos );
if( wr != newpos - pos )
- { show_error( "write error", errno ); return 1; }
+ { show_error( "Write error", errno ); return 1; }
if( close( outfd ) != 0 )
- { show_error( "error closing output file", errno ); return 1; }
+ { show_error( "Error closing output file", errno ); return 1; }
if( !next_filename( output_filename ) )
- { show_error( "too many members in file" ); close( infd ); return 1; }
- outfd = open_outstream( output_filename );
+ { show_error( "Too many members in file." ); close( infd ); return 1; }
+ outfd = open_outstream( output_filename, force );
if( outfd < 0 ) { close( infd ); return 1; }
partial_member_size = 0;
pos = newpos;
@@ -213,7 +647,7 @@ int process_file( const std::string & input_filename, uint8_t * & base_buffer )
{
const int wr = writeblock( outfd, buffer + pos, size + hsize - pos );
if( wr != size + hsize - pos )
- { show_error( "write error", errno ); return 1; }
+ { show_error( "Write error", errno ); return 1; }
break;
}
if( pos < buffer_size )
@@ -221,46 +655,72 @@ int process_file( const std::string & input_filename, uint8_t * & base_buffer )
partial_member_size += buffer_size - pos;
const int wr = writeblock( outfd, buffer + pos, buffer_size - pos );
if( wr != buffer_size - pos )
- { show_error( "write error", errno ); return 1; }
+ { show_error( "Write error", errno ); return 1; }
}
std::memcpy( base_buffer, base_buffer + buffer_size, tsize + hsize );
size = readblock( infd, buffer + hsize, buffer_size );
at_stream_end = ( size < buffer_size );
if( size != buffer_size && errno )
- { show_error( "read error", errno ); return 1; }
+ { show_error( "Read error", errno ); return 1; }
}
close( infd );
if( close( outfd ) != 0 )
- { show_error( "error closing output file", errno ); return 1; }
+ { show_error( "Error closing output file", errno ); return 1; }
return 0;
}
+
+int split_file( const std::string & input_filename,
+ const std::string & default_output_filename, const bool force )
+ {
+ uint8_t * base_buffer;
+ const int retval = do_split_file( input_filename, base_buffer,
+ default_output_filename, force );
+ delete[] base_buffer;
+ return retval;
+ }
+
} // end namespace
-int verbosity = 0;
+void Pretty_print::operator()( const char * const msg ) const throw()
+ {
+ if( verbosity_ >= 0 )
+ {
+ if( first_post )
+ {
+ first_post = false;
+ std::fprintf( stderr, " %s: ", name_.c_str() );
+ for( unsigned int i = 0; i < longest_name - name_.size(); ++i )
+ std::fprintf( stderr, " " );
+ if( !msg ) std::fflush( stderr );
+ }
+ if( msg ) std::fprintf( stderr, "%s.\n", msg );
+ }
+ }
void show_error( const char * const msg, const int errcode, const bool help ) throw()
{
if( verbosity >= 0 )
{
- if( msg && msg[0] != 0 )
+ if( msg && msg[0] )
{
std::fprintf( stderr, "%s: %s", program_name, msg );
- if( errcode > 0 ) std::fprintf( stderr, ": %s", std::strerror( errcode ) );
+ if( errcode > 0 )
+ std::fprintf( stderr, ": %s", std::strerror( errcode ) );
std::fprintf( stderr, "\n" );
}
- if( help && invocation_name && invocation_name[0] != 0 )
- std::fprintf( stderr, "Try `%s --help' for more information.\n", invocation_name );
+ if( help && invocation_name && invocation_name[0] )
+ std::fprintf( stderr, "Try `%s --help' for more information.\n",
+ invocation_name );
}
}
void internal_error( const char * const msg )
{
- std::string s( "internal error: " ); s += msg;
- show_error( s.c_str() );
+ std::fprintf( stderr, "%s: internal error: %s.\n", program_name, msg );
std::exit( 3 );
}
@@ -304,12 +764,22 @@ int writeblock( const int fd, const uint8_t * const buf, const int size ) throw(
int main( const int argc, const char * const argv[] )
{
+ enum Mode
+ { m_none, m_create, m_merge, m_recover, m_repair, m_split, m_update };
+ Mode program_mode = m_none;
+ bool force = false;
+ std::string default_output_filename;
invocation_name = argv[0];
const Arg_parser::Option options[] =
{
+ { 'f', "force", Arg_parser::no },
{ 'h', "help", Arg_parser::no },
+ { 'm', "merge", Arg_parser::no },
+ { 'o', "output", Arg_parser::yes },
{ 'q', "quiet", Arg_parser::no },
+ { 'R', "repair", Arg_parser::no },
+ { 's', "split", Arg_parser::no },
{ 'v', "verbose", Arg_parser::no },
{ 'V', "version", Arg_parser::no },
{ 0 , 0, Arg_parser::no } };
@@ -325,20 +795,49 @@ int main( const int argc, const char * const argv[] )
if( !code ) break; // no more options
switch( code )
{
+ case 'f': force = true; break;
case 'h': show_help(); return 0;
+ case 'm': program_mode = m_merge; break;
+ case 'o': default_output_filename = parser.argument( argind ); break;
case 'q': verbosity = -1; break;
+ case 'R': program_mode = m_repair; break;
+ case 's': program_mode = m_split; break;
case 'v': if( verbosity < 4 ) ++verbosity; break;
case 'V': show_version(); return 0;
default : internal_error( "uncaught option" );
}
}
+ if( program_mode == m_merge )
+ {
+ std::vector< std::string > filenames;
+ for( ; argind < parser.arguments(); ++argind )
+ filenames.push_back( parser.argument( argind ) );
+ if( filenames.size() < 2 )
+ { show_error( "You must specify at least 2 files.", 0, true ); return 1; }
+ if( !default_output_filename.size() )
+ default_output_filename = insert_fixed( filenames[0] );
+ return merge_files( filenames, default_output_filename, force );
+ }
+
if( argind + 1 != parser.arguments() )
- { show_error( "you must specify exactly 1 file", 0, true ); return 1; }
+ { show_error( "You must specify exactly 1 file.", 0, true ); return 1; }
- uint8_t * base_buffer;
- const int retval = process_file( parser.argument( argind ), base_buffer );
+ if( program_mode == m_repair )
+ {
+ if( !default_output_filename.size() )
+ default_output_filename = insert_fixed( parser.argument( argind ) );
+ return repair_file( parser.argument( argind ), default_output_filename, force );
+ }
- delete[] base_buffer;
- return retval;
+ if( program_mode == m_split )
+ {
+ if( !default_output_filename.size() )
+ default_output_filename = parser.argument( argind );
+ return split_file( parser.argument( argind ), default_output_filename, force );
+ }
+
+ show_error( "You must specify the operation to be performed on file.",
+ 0, true );
+ return 1;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-07 05:17:23 +0000