/* Sets the format
* Returns 1 if successful, 0 if unsupported value or -1 on error
*/
int mount_handle_set_format(
mount_handle_t *mount_handle,
const libcstring_system_character_t *string,
libcerror_error_t **error )
{
static char *function = "mount_handle_set_format";
size_t string_length = 0;
int result = 0;
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
string_length = libcstring_system_string_length(
string );
if( string_length == 3 )
{
if( libcstring_system_string_compare(
string,
_LIBCSTRING_SYSTEM_STRING( "raw" ),
3 ) == 0 )
{
mount_handle->input_format = MOUNT_HANDLE_INPUT_FORMAT_RAW;
result = 1;
}
}
else if( string_length == 5 )
{
if( libcstring_system_string_compare(
string,
_LIBCSTRING_SYSTEM_STRING( "files" ),
5 ) == 0 )
{
mount_handle->input_format = MOUNT_HANDLE_INPUT_FORMAT_FILES;
result = 1;
}
}
return( result );
}
/* Cross Windows safe version of FormatMessageA
* Returns TRUE if successful or FALSE on error
*/
DWORD libcerror_FormatMessageA(
DWORD flags,
LPCVOID source,
DWORD message_identifier,
DWORD language_identifier,
LPCSTR string,
DWORD string_size,
va_list *argument_list )
{
FARPROC function = NULL;
HMODULE library_handle = NULL;
DWORD result = 0;
if( string == NULL )
{
return( FALSE );
}
library_handle = LoadLibrary(
_LIBCSTRING_SYSTEM_STRING( "kernel32.dll" ) );
if( library_handle == NULL )
{
return( FALSE );
}
function = GetProcAddress(
library_handle,
(LPCSTR) "FormatMessageA" );
if( function != NULL )
{
result = function(
flags,
source,
message_identifier,
language_identifier,
string,
string_size,
argument_list );
}
/* This call should be after using the function
* in most cases kernel32.dll will still be available after free
*/
if( FreeLibrary(
library_handle ) != TRUE )
{
result = FALSE;
}
return( result );
}
/* Opens the log handle
* Returns 1 if successful or -1 on error
*/
int log_handle_open(
log_handle_t *log_handle,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
static char *function = "log_handle_open";
if( log_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid log handle.",
function );
return( -1 );
}
if( filename != NULL )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
log_handle->log_stream = file_stream_open_wide(
filename,
_LIBCSTRING_SYSTEM_STRING( FILE_STREAM_OPEN_APPEND ) );
#else
log_handle->log_stream = file_stream_open(
filename,
FILE_STREAM_OPEN_APPEND );
#endif
if( log_handle->log_stream == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
}
return( 1 );
}
/* Cross Windows safe version of GetLocaleInfoA
* Returns the number of bytes read if successful or 0 on error
*/
int libcstring_GetLocaleInfoA(
LCID locale,
LCTYPE lctype,
LPSTR buffer,
int size )
{
FARPROC function = NULL;
HMODULE library_handle = NULL;
int result = 0;
library_handle = LoadLibrary(
_LIBCSTRING_SYSTEM_STRING( "kernel32.dll" ) );
if( library_handle == NULL )
{
return( 0 );
}
function = GetProcAddress(
library_handle,
(LPCSTR) "GetLocaleInfoA" );
if( function != NULL )
{
result = function(
locale,
lctype,
buffer,
size );
}
/* This call should be after using the function
* in most cases kernel32.dll will still be available after free
*/
if( FreeLibrary(
library_handle ) != TRUE )
{
result = 0;
}
return( result );
}
/* Opens the log handle
* Returns 1 if successful or -1 on error
*/
int log_handle_open(
log_handle_t *log_handle,
const libcstring_system_character_t *filename,
liberror_error_t **error )
{
static char *function = "log_handle_open";
if( log_handle == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid log handle.",
function );
return( -1 );
}
if( filename != NULL )
{
log_handle->log_stream = libsystem_file_stream_open(
filename,
_LIBCSTRING_SYSTEM_STRING( FILE_STREAM_OPEN_APPEND ) );
if( log_handle->log_stream == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
}
return( 1 );
}
/* Determines the event log type from a string
* Returns 1 if successful, 0 if unsupported value or -1 on error
*/
int evtxinput_determine_event_log_type(
const libcstring_system_character_t *string,
int *event_log_type,
libcerror_error_t **error )
{
static char *function = "evtxinput_determine_event_log_type";
size_t string_length = 0;
int result = 0;
if( string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid string.",
function );
return( -1 );
}
if( event_log_type == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid event log type.",
function );
return( -1 );
}
string_length = libcstring_system_string_length(
string );
if( string_length == 6 )
{
if( libcstring_system_string_compare_no_case(
string,
_LIBCSTRING_SYSTEM_STRING( "system" ),
6 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SYSTEM;
result = 1;
}
}
else if( string_length == 8 )
{
if( libcstring_system_string_compare_no_case(
string,
_LIBCSTRING_SYSTEM_STRING( "security" ),
8 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SECURITY;
result = 1;
}
}
else if( string_length == 11 )
{
if( libcstring_system_string_compare_no_case(
string,
_LIBCSTRING_SYSTEM_STRING( "application" ),
11 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_APPLICATION;
result = 1;
}
}
return( result );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t *source = NULL;
libcstring_system_integer_t option = 0;
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
return( EXIT_FAILURE );
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file or device.\n" );
return( EXIT_FAILURE );
}
source = argv[ optind ];
#if defined( HAVE_DEBUG_OUTPUT ) && defined( LNK_TEST_OPEN_CLOSE_VERBOSE )
liblnk_notify_set_verbose(
1 );
liblnk_notify_set_stream(
stderr,
NULL );
#endif
/* Case 0: single open and close of a file using filename
*/
if( lnk_test_single_open_close_file(
source,
LIBLNK_OPEN_READ,
1 ) != 1 )
{
fprintf(
stderr,
"Unable to test single open close.\n" );
return( EXIT_FAILURE );
}
if( lnk_test_single_open_close_file(
NULL,
LIBLNK_OPEN_READ,
-1 ) != 1 )
{
fprintf(
stderr,
"Unable to test single open close.\n" );
return( EXIT_FAILURE );
}
if( lnk_test_single_open_close_file(
source,
LIBLNK_OPEN_WRITE,
-1 ) != 1 )
{
fprintf(
stderr,
"Unable to test single open close.\n" );
return( EXIT_FAILURE );
}
/* Case 1: multiple open and close of a file using filename
*/
if( lnk_test_multi_open_close_file(
source,
LIBLNK_OPEN_READ,
1 ) != 1 )
{
fprintf(
stderr,
"Unable to test multi open close.\n" );
return( EXIT_FAILURE );
}
return( EXIT_SUCCESS );
}
int main( int argc, char * const argv[] )
#endif
{
char destination[ 128 ];
libcerror_error_t *error = NULL;
libcfile_file_t *source_file = NULL;
uint8_t *buffer = NULL;
uint8_t *uncompressed_data = NULL;
char *program = "ascii7decompress";
libcstring_system_integer_t option = 0;
char *source = NULL;
size64_t source_size = 0;
off_t source_offset = 0;
size_t buffer_size = 0;
size_t uncompressed_data_size = 0;
ssize_t read_count = 0;
int print_count = 0;
int verbose = 0;
assorted_output_version_fprint(
stdout,
program );
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "ho:s:vV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM "\n",
argv[ optind ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case 'o':
source_offset = atol( optarg );
break;
case 's':
source_size = atol( optarg );
break;
case 'v':
verbose = 1;
break;
case 'V':
assorted_output_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
source = argv[ optind ];
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
verbose );
/* Open the source file
*/
if( libcfile_file_initialize(
&source_file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create source file.\n" );
goto on_error;
}
if( libcfile_file_open(
source_file,
source,
LIBCFILE_OPEN_READ,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open source file.\n" );
goto on_error;
}
if( source_size == 0 )
{
if( libcfile_file_get_size(
source_file,
&source_size,
&error ) == -1 )
{
fprintf(
stderr,
"Unable to determine size of source file.\n" );
goto on_error;
}
}
if( source_size == 0 )
{
fprintf(
stderr,
"Invalid source size value is zero.\n" );
goto on_error;
}
if( source_size > (size_t) SSIZE_MAX )
{
fprintf(
stderr,
"Invalid source size value exceeds maximum.\n" );
goto on_error;
}
/* Create the input buffer
*/
buffer_size = source_size;
buffer = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * buffer_size );
if( buffer == NULL )
{
fprintf(
stderr,
"Unable to create buffer.\n" );
return( EXIT_FAILURE );
}
uncompressed_data_size = 1 + ( ( ( source_size - 1 ) * 8 ) / 7 );
uncompressed_data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * uncompressed_data_size );
if( uncompressed_data == NULL )
{
fprintf(
stderr,
"Unable to create uncompressed data buffer.\n" );
return( EXIT_FAILURE );
}
/* Position the source file at the right offset
*/
if( libcfile_file_seek_offset(
source_file,
source_offset,
SEEK_SET,
&error ) == -1 )
{
fprintf(
stderr,
"Unable to seek offset in source file.\n" );
goto on_error;
}
print_count = libcstring_narrow_string_snprintf(
destination,
128,
"%s.ascii7decompressed",
source );
if( ( print_count < 0 )
|| ( print_count > 128 ) )
{
fprintf(
stderr,
"Unable to set destination filename.\n" );
memory_free(
uncompressed_data );
memory_free(
buffer );
return( EXIT_FAILURE );
}
fprintf(
stdout,
"Starting 7-bit ASCII decompression of: %s at offset: %jd (0x%08jx).\n",
source,
source_offset,
source_offset );
read_count = libcfile_file_read_buffer(
source_file,
buffer,
source_size,
&error );
if( read_count != (ssize_t) source_size )
{
fprintf(
stderr,
"Unable to read from source file.\n" );
goto on_error;
}
/* Decompress the data
*/
fprintf(
stderr,
"Compressed data:\n" );
libcnotify_print_data(
buffer,
source_size,
0 );
if( ascii7_decompress(
uncompressed_data,
uncompressed_data_size,
buffer,
source_size,
NULL ) != 1 )
{
fprintf(
stderr,
"Unable to decompress data.\n" );
goto on_error;
}
fprintf(
stderr,
"Uncompressed data:\n" );
libcnotify_print_data(
uncompressed_data,
uncompressed_data_size,
0 );
source_offset += source_size;
source_size -= source_size;
#ifdef NOWRITE
libcfile_file_t *destination_file = NULL;
ssize_t write_count = 0;
if( destination_file == NULL )
{
/* Open the destination file
*/
if( libcfile_file_initialize(
&destination_file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create destination file.\n" );
goto on_error;
}
if( libcfile_file_open(
destination_file,
destination,
LIBCFILE_OPEN_WRITE,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open destination file.\n" );
goto on_error;
}
}
write_count = libcfile_file_write_buffer(
destination_file,
uncompressed_data,
uncompressed_data_size,
&error );
if( write_count != (ssize_t) uncompressed_data_size )
{
fprintf(
stderr,
"Unable to write to destination file.\n" );
goto on_error;
}
/* Clean up
*/
if( destination_file != NULL )
{
if( libcfile_file_close(
destination_file,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close destination file.\n" );
goto on_error;
}
if( libcfile_file_free(
&destination_file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free destination file.\n" );
goto on_error;
}
}
#endif
/* Clean up
*/
if( libcfile_file_close(
source_file,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close source file.\n" );
goto on_error;
}
if( libcfile_file_free(
&source_file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free source file.\n" );
goto on_error;
}
fprintf(
stdout,
"7-bit ASCII decompression:\tSUCCESS\n" );
memory_free(
uncompressed_data );
memory_free(
buffer );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
#ifdef NOWRITE
if( destination_file != NULL )
{
libcfile_file_free(
&destination_file,
NULL );
}
#endif
if( uncompressed_data != NULL )
{
memory_free(
uncompressed_data );
}
if( buffer != NULL )
{
memory_free(
buffer );
}
if( source_file != NULL )
{
libcfile_file_free(
&source_file,
NULL );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
libcerror_error_t *error = NULL;
libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "odrawinfo" );
libcstring_system_character_t *source = NULL;
libcstring_system_integer_t option = 0;
uint8_t ignore_data_files = 0;
int verbose = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"odrawtools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
odrawoutput_version_fprint(
stdout,
program );
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "ihvV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'i':
ignore_data_files = 1;
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
odrawoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
source = argv[ optind ];
libcnotify_verbose_set(
verbose );
#if !defined( HAVE_LOCAL_LIBODRAW )
libodraw_notify_set_stream(
stderr,
NULL );
libodraw_notify_set_verbose(
verbose );
#endif
if( info_handle_initialize(
&odrawinfo_info_handle,
&error ) != 1 )
{
odrawoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to create info handle.\n" );
goto on_error;
}
odrawinfo_info_handle->ignore_data_files = ignore_data_files;
if( libcsystem_signal_attach(
odrawinfo_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( info_handle_open_input(
odrawinfo_info_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
source );
goto on_error;
}
if( info_handle_handle_fprint(
odrawinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print information.\n" );
goto on_error;
}
if( info_handle_close(
odrawinfo_info_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close info handle.\n" );
goto on_error;
}
if( libcsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( info_handle_free(
&odrawinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free info handle.\n" );
goto on_error;
}
if( odrawinfo_abort != 0 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n",
program );
return( EXIT_FAILURE );
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( odrawinfo_info_handle != NULL )
{
info_handle_free(
&odrawinfo_info_handle,
NULL );
}
return( EXIT_FAILURE );
}
/* Creates a human readable byte size string
* Returns 1 if successful or -1 on error
*/
int byte_size_string_create(
libcstring_system_character_t *byte_size_string,
size_t byte_size_string_length,
uint64_t size,
int units,
libcerror_error_t **error )
{
const libcstring_system_character_t *factor_string = NULL;
const libcstring_system_character_t *units_string = NULL;
static char *function = "byte_size_string_create";
ssize_t print_count = 0;
uint64_t factored_size = 0;
uint64_t last_factored_size = 0;
int8_t factor = 0;
int8_t remainder = -1;
int decimal_point = 0;
if( byte_size_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid byte size string.",
function );
return( -1 );
}
/* Minimum of 4 digits and separator, space, 3 letter unit, end of string
*/
if( byte_size_string_length < 9 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: byte size string too small.",
function );
return( -1 );
}
if( ( size < 1024 )
|| ( units == BYTE_SIZE_STRING_UNIT_MEGABYTE ) )
{
units_string = _LIBCSTRING_SYSTEM_STRING( "B" );
}
else if( units == BYTE_SIZE_STRING_UNIT_MEBIBYTE )
{
units_string = _LIBCSTRING_SYSTEM_STRING( "iB" );
}
factored_size = size;
if( factored_size >= (uint64_t) units )
{
while( factored_size >= (uint64_t) units )
{
last_factored_size = factored_size;
factored_size /= units;
factor++;
}
if( factored_size < 10 )
{
last_factored_size %= units;
remainder = (int8_t) ( last_factored_size / 100 );
}
}
if( factor > 8 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: factor size greater than 8 unsupported.",
function );
return( -1 );
}
switch( factor )
{
case 0:
factor_string = _LIBCSTRING_SYSTEM_STRING( "" );
break;
case 1:
factor_string = _LIBCSTRING_SYSTEM_STRING( "K" );
break;
case 2:
factor_string = _LIBCSTRING_SYSTEM_STRING( "M" );
break;
case 3:
factor_string = _LIBCSTRING_SYSTEM_STRING( "G" );
break;
case 4:
factor_string = _LIBCSTRING_SYSTEM_STRING( "T" );
break;
case 5:
factor_string = _LIBCSTRING_SYSTEM_STRING( "P" );
break;
case 6:
factor_string = _LIBCSTRING_SYSTEM_STRING( "E" );
break;
case 7:
factor_string = _LIBCSTRING_SYSTEM_STRING( "Z" );
break;
case 8:
factor_string = _LIBCSTRING_SYSTEM_STRING( "Y" );
break;
}
if( remainder > 9 )
{
remainder = 9;
}
if( remainder >= 0 )
{
if( libclocale_locale_get_decimal_point(
&decimal_point,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve locale decimal point.",
function );
return( -1 );
}
print_count = libcstring_system_string_sprintf(
byte_size_string,
byte_size_string_length,
_LIBCSTRING_SYSTEM_STRING( "%" ) _LIBCSTRING_SYSTEM_STRING( PRIu64 )
_LIBCSTRING_SYSTEM_STRING( "%" ) _LIBCSTRING_SYSTEM_STRING( PRIc_LIBCSTRING_SYSTEM )
_LIBCSTRING_SYSTEM_STRING( "%" ) _LIBCSTRING_SYSTEM_STRING( PRIu8 )
_LIBCSTRING_SYSTEM_STRING( " %" ) _LIBCSTRING_SYSTEM_STRING( PRIs_LIBCSTRING_SYSTEM )
_LIBCSTRING_SYSTEM_STRING( "%" ) _LIBCSTRING_SYSTEM_STRING( PRIs_LIBCSTRING_SYSTEM ),
factored_size,
(libcstring_system_character_t) decimal_point,
remainder,
factor_string,
units_string );
}
else
{
print_count = libcstring_system_string_sprintf(
byte_size_string,
byte_size_string_length,
_LIBCSTRING_SYSTEM_STRING( "%" ) _LIBCSTRING_SYSTEM_STRING( PRIu64 )
_LIBCSTRING_SYSTEM_STRING( " %" ) _LIBCSTRING_SYSTEM_STRING( PRIs_LIBCSTRING_SYSTEM )
_LIBCSTRING_SYSTEM_STRING( "%" ) _LIBCSTRING_SYSTEM_STRING( PRIs_LIBCSTRING_SYSTEM ),
factored_size,
factor_string,
units_string );
}
if( ( print_count < 0 )
|| ( (size_t) print_count > byte_size_string_length ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set byte size string.",
function );
return( -1 );
}
return( 1 );
}
int main( int argc, char * const argv[] )
#endif
{
#if defined( HAVE_GETRLIMIT )
struct rlimit limit_data;
#endif
libcstring_system_character_t * const *source_filenames = NULL;
#if !defined( HAVE_GLOB_H )
libcsystem_glob_t *glob = NULL;
#endif
libcerror_error_t *error = NULL;
libcstring_system_character_t *option_date_format = NULL;
libcstring_system_character_t *option_header_codepage = NULL;
libcstring_system_character_t *option_output_format = NULL;
libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "ewfinfo" );
libcstring_system_integer_t option = 0;
uint8_t verbose = 0;
char info_option = 'a';
int number_of_filenames = 0;
int print_header = 1;
int result = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"ewftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "A:d:ef:himvV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
goto on_error;
case (libcstring_system_integer_t) 'A':
option_header_codepage = optarg;
break;
case (libcstring_system_integer_t) 'd':
option_date_format = optarg;
break;
case (libcstring_system_integer_t) 'e':
if( info_option != 'a' )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Conflicting options: %" PRIc_LIBCSTRING_SYSTEM " and %c\n",
option,
info_option );
usage_fprint(
stdout );
goto on_error;
}
info_option = 'e';
break;
case (libcstring_system_integer_t) 'f':
option_output_format = optarg;
break;
case (libcstring_system_integer_t) 'h':
ewfoutput_version_fprint(
stdout,
program );
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'i':
if( info_option != 'a' )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Conflicting options: %" PRIc_LIBCSTRING_SYSTEM " and %c\n",
option,
info_option );
usage_fprint(
stdout );
goto on_error;
}
info_option = 'i';
break;
case (libcstring_system_integer_t) 'm':
if( info_option != 'a' )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Conflicting options: %" PRIc_LIBCSTRING_SYSTEM " and %c\n",
option,
info_option );
usage_fprint(
stdout );
goto on_error;
}
info_option = 'm';
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
ewfoutput_version_fprint(
stdout,
program );
ewfoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Missing EWF image file(s).\n" );
usage_fprint(
stdout );
goto on_error;
}
libcnotify_verbose_set(
verbose );
#if !defined( HAVE_LOCAL_LIBEWF )
libewf_notify_set_verbose(
verbose );
libewf_notify_set_stream(
stderr,
NULL );
#endif
if( info_handle_initialize(
&ewfinfo_info_handle,
&error ) != 1 )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to create info handle.\n" );
goto on_error;
}
if( option_output_format != NULL )
{
result = info_handle_set_output_format(
ewfinfo_info_handle,
option_output_format,
&error );
if( result == -1 )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to set output format.\n" );
goto on_error;
}
else if( result == 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
fprintf(
stderr,
"Unsupported output format defaulting to: text.\n" );
}
}
if( ewfinfo_info_handle->output_format == INFO_HANDLE_OUTPUT_FORMAT_DFXML )
{
if( info_handle_dfxml_header_fprint(
ewfinfo_info_handle,
&error ) != 1 )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to print header.\n" );
goto on_error;
}
}
else if( ewfinfo_info_handle->output_format == INFO_HANDLE_OUTPUT_FORMAT_TEXT )
{
ewfoutput_version_fprint(
stdout,
program );
print_header = 0;
}
if( ( option_output_format == NULL )
&& ( option_date_format != NULL ) )
{
result = info_handle_set_date_format(
ewfinfo_info_handle,
option_date_format,
&error );
if( result == -1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to set date format.\n" );
goto on_error;
}
else if( result == 0 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unsupported date format defaulting to: ctime.\n" );
}
}
if( option_header_codepage != NULL )
{
result = info_handle_set_header_codepage(
ewfinfo_info_handle,
option_header_codepage,
&error );
if( result == -1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to set header codepage in info handle.\n" );
goto on_error;
}
else if( result == 0 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unsupported header codepage defaulting to: ascii.\n" );
}
}
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_initialize(
&glob,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to initialize glob.\n" );
goto on_error;
}
if( libcsystem_glob_resolve(
glob,
&( argv[ optind ] ),
argc - optind,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to resolve glob.\n" );
goto on_error;
}
if( libcsystem_glob_get_results(
glob,
&number_of_filenames,
(libcstring_system_character_t ***) &source_filenames,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve glob results.\n" );
goto on_error;
}
#else
source_filenames = &( argv[ optind ] );
number_of_filenames = argc - optind;
#endif
#if defined( HAVE_GETRLIMIT )
if( getrlimit(
RLIMIT_NOFILE,
&limit_data ) != 0 )
{
fprintf(
stderr,
"Unable to determine limit: number of open file descriptors.\n" );
}
if( limit_data.rlim_max > (rlim_t) INT_MAX )
{
limit_data.rlim_max = (rlim_t) INT_MAX;
}
if( limit_data.rlim_max > 0 )
{
limit_data.rlim_max /= 2;
}
if( info_handle_set_maximum_number_of_open_handles(
ewfinfo_info_handle,
(int) limit_data.rlim_max,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set maximum number of open file handles.\n" );
goto on_error;
}
#endif
if( libcsystem_signal_attach(
ewfinfo_signal_handler,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
result = info_handle_open_input(
ewfinfo_info_handle,
source_filenames,
number_of_filenames,
&error );
if( ewfinfo_abort != 0 )
{
goto on_abort;
}
if( result != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to open EWF file(s).\n" );
goto on_error;
}
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_free(
&glob,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
#endif
if( ( info_option == 'a' )
|| ( info_option == 'i' ) )
{
if( info_handle_header_values_fprint(
ewfinfo_info_handle,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to print header values.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
}
if( ( info_option == 'a' )
|| ( info_option == 'm' ) )
{
if( info_handle_media_information_fprint(
ewfinfo_info_handle,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to print media information.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( info_handle_hash_values_fprint(
ewfinfo_info_handle,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to print hash values.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( info_handle_sessions_fprint(
ewfinfo_info_handle,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to print sessions.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( info_handle_tracks_fprint(
ewfinfo_info_handle,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to print tracks.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
}
if( ( info_option == 'a' )
|| ( info_option == 'e' ) )
{
if( info_handle_acquiry_errors_fprint(
ewfinfo_info_handle,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to print acquiry errors.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
}
if( info_handle_single_files_fprint(
ewfinfo_info_handle,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to print single files.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( ewfinfo_info_handle->output_format == INFO_HANDLE_OUTPUT_FORMAT_DFXML )
{
if( info_handle_dfxml_footer_fprint(
ewfinfo_info_handle,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to print footer.\n" );
goto on_error;
}
}
on_abort:
if( info_handle_close(
ewfinfo_info_handle,
&error ) != 0 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to close info handle.\n" );
goto on_error;
}
if( libcsystem_signal_detach(
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( info_handle_free(
&ewfinfo_info_handle,
&error ) != 1 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stderr,
"Unable to free info handle.\n" );
goto on_error;
}
if( ewfinfo_abort != 0 )
{
if( print_header != 0 )
{
ewfoutput_version_fprint(
stderr,
program );
print_header = 0;
}
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n",
program );
return( EXIT_FAILURE );
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( ewfinfo_info_handle != NULL )
{
info_handle_free(
&ewfinfo_info_handle,
NULL );
}
#if !defined( HAVE_GLOB_H )
if( glob != NULL )
{
libcsystem_glob_free(
&glob,
NULL );
}
#endif
return( EXIT_FAILURE );
}
/* Converts the GUID into a string
* Returns 1 if successful or -1 on error
*/
int guid_to_string(
uint8_t *guid,
size_t guid_size,
int byte_order,
libcstring_system_character_t *string,
size_t string_size,
liberror_error_t **error )
{
static char *function = "guid_to_string";
int print_count = 0;
if( guid == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid guid.",
function );
return( -1 );
}
if( guid_size < GUID_SIZE )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: GUID too small.",
function );
return( -1 );
}
if( guid_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid GUID size value exceeds maximum.",
function );
return( -1 );
}
if( ( byte_order != _BYTE_STREAM_ENDIAN_BIG )
&& ( byte_order != _BYTE_STREAM_ENDIAN_LITTLE ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported byte order.",
function );
return( -1 );
}
if( string == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid string.",
function );
return( -1 );
}
if( string_size < GUID_STRING_SIZE )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: string too small.",
function );
return( -1 );
}
if( string_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid string size value exceeds maximum.",
function );
return( -1 );
}
/* Create the GUID string
* It is stored as uint32 - uint16 - uint16 - 8 byte array
*/
if( byte_order == _BYTE_STREAM_ENDIAN_BIG )
{
print_count = libcstring_system_string_sprintf(
string,
string_size,
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "-%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "-%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "-%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "-%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 ),
guid[ 0 ], guid[ 1 ], guid[ 2 ], guid[ 3 ],
guid[ 4 ], guid[ 5 ],
guid[ 6 ], guid[ 7 ],
guid[ 8 ], guid[ 9 ],
guid[ 10 ], guid[ 11 ], guid[ 12 ], guid[ 13 ], guid[ 14 ], guid[ 15 ] );
}
else if( byte_order == _BYTE_STREAM_ENDIAN_LITTLE )
{
print_count = libcstring_system_string_sprintf(
string,
string_size,
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "-%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "-%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "-%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "-%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 )
_LIBCSTRING_SYSTEM_STRING( "%.2" ) _LIBCSTRING_SYSTEM_STRING( PRIx8 ),
guid[ 3 ], guid[ 2 ], guid[ 1 ], guid[ 0 ],
guid[ 5 ], guid[ 4 ],
guid[ 7 ], guid[ 6 ],
guid[ 8 ], guid[ 9 ],
guid[ 10 ], guid[ 11 ], guid[ 12 ], guid[ 13 ], guid[ 14 ], guid[ 15 ] );
}
if( ( print_count < 0 )
|| ( (size_t) print_count > string_size ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set string.",
function );
return( -1 );
}
return( 1 );
}
int main( int argc, char * const argv[] )
#endif
{
libcerror_error_t *error = NULL;
libcfile_file_t *source_file = NULL;
uint8_t *buffer = NULL;
char *program = "crc32sum";
char *source = NULL;
libcstring_system_integer_t option = 0;
size64_t source_size = 0;
off_t source_offset = 0;
ssize_t read_count = 0;
uint32_t calculated_crc32 = 0;
uint32_t crc32 = 0;
uint32_t initial_value = 0;
uint32_t polynomial = 0xedb88320UL;
uint8_t bit_index = 0;
uint8_t weak_crc = 0;
int calculation_method = 2;
int result = 0;
int validate_crc = 0;
int verbose = 0;
assorted_output_version_fprint(
stdout,
program );
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "12c:hi:o:p:s:vVw" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM "\n",
argv[ optind ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case '1':
calculation_method = 1;
break;
case '2':
calculation_method = 2;
break;
case 'c':
crc32 = atol( optarg );
validate_crc = 1;
break;
case 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case 'i':
initial_value = atol( optarg );
break;
case 'o':
source_offset = atol( optarg );
break;
case 'p':
polynomial = atol( optarg );
break;
case 's':
source_size = atol( optarg );
break;
case 'v':
verbose = 1;
break;
case 'V':
assorted_output_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
case 'w':
weak_crc = 1;
break;
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
source = argv[ optind ];
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
verbose );
/* Open the source file
*/
if( libcfile_file_initialize(
&source_file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create source file.\n" );
goto on_error;
}
if( libcfile_file_open(
source_file,
source,
LIBCFILE_OPEN_READ,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open source file.\n" );
goto on_error;
}
if( source_size == 0 )
{
if( libcfile_file_get_size(
source_file,
&source_size,
&error ) == -1 )
{
fprintf(
stderr,
"Unable to determine size of source file.\n" );
goto on_error;
}
}
if( source_size == 0 )
{
fprintf(
stderr,
"Invalid source size value is zero.\n" );
goto on_error;
}
if( source_size > (size_t) SSIZE_MAX )
{
fprintf(
stderr,
"Invalid source size value exceeds maximum.\n" );
goto on_error;
}
buffer = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * source_size );
if( buffer == NULL )
{
fprintf(
stderr,
"Unable to create buffer.\n" );
goto on_error;
}
/* Position the source file at the right offset
*/
if( libcfile_file_seek_offset(
source_file,
source_offset,
SEEK_SET,
&error ) == -1 )
{
fprintf(
stderr,
"Unable to seek offset in source file.\n" );
goto on_error;
}
read_count = libcfile_file_read_buffer(
source_file,
buffer,
source_size,
&error );
if( read_count != (ssize_t) source_size )
{
fprintf(
stderr,
"Unable to read from source file.\n" );
goto on_error;
}
/* Clean up
*/
if( libcfile_file_close(
source_file,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close source file.\n" );
goto on_error;
}
if( libcfile_file_free(
&source_file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free source file.\n" );
goto on_error;
}
if( calculation_method == 1 )
{
result = crc32_calculate_modulo2(
&calculated_crc32,
buffer,
source_size,
initial_value,
weak_crc,
&error );
}
else if( calculation_method == 2 )
{
initialize_crc32_table(
polynomial );
result = crc32_calculate(
&calculated_crc32,
buffer,
source_size,
initial_value,
weak_crc,
&error );
}
if( result != 1 )
{
fprintf(
stderr,
"Unable to calculate CRC-32.\n" );
goto on_error;
}
if( libcnotify_verbose != 0 )
{
libcnotify_print_data(
buffer,
source_size,
0 );
}
fprintf(
stdout,
"Calculated CRC-32: %" PRIu32 " (0x%08" PRIx32 ")\n",
calculated_crc32,
calculated_crc32 );
if( validate_crc != 0 )
{
if( calculated_crc32 != crc32 )
{
fprintf(
stdout,
"Mismatch between CRC-32: %" PRIu32 " and calculated CRC-32: %" PRIu32 "\n",
crc32,
calculated_crc32 );
result = crc32_validate(
crc32,
calculated_crc32,
&bit_index,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to locate error.\n" );
goto on_error;
}
else if( result != 0 )
{
fprintf(
stdout,
"Single bit-error in bit: %" PRIu8 " of CRC-32\n",
bit_index );
}
result = crc32_locate_error_offset(
crc32,
calculated_crc32,
buffer,
source_size,
initial_value,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to locate error.\n" );
goto on_error;
}
}
else
{
fprintf(
stdout,
"Match between CRC-32: %" PRIu32 " and calculated CRC-32: %" PRIu32 "\n",
crc32,
calculated_crc32 );
}
}
memory_free(
buffer );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( buffer != NULL )
{
memory_free(
buffer );
}
if( source_file != NULL )
{
libcfile_file_free(
&source_file,
NULL );
}
return( EXIT_FAILURE );
}
/* Sets an error and adds a system specific error string if possible
* Creates the error if necessary
* The error domain and code are set only the first time and the error message is appended for back tracing
*/
void VARARGS(
libcerror_system_set_error,
libcerror_error_t **error,
int error_domain,
int error_code,
uint32_t system_error_code,
const char *,
format_string )
{
va_list argument_list;
libcerror_internal_error_t *internal_error = NULL;
libcstring_system_character_t *system_format_string = NULL;
void *reallocation = NULL;
size_t format_string_length = 0;
size_t message_size = LIBCERROR_MESSAGE_INCREMENT_SIZE;
size_t string_index = 0;
int message_index = 0;
int print_count = 0;
if( error == NULL )
{
return;
}
if( format_string == NULL )
{
return;
}
format_string_length = libcstring_narrow_string_length(
format_string );
if( format_string_length > message_size )
{
message_size = ( ( format_string_length / LIBCERROR_MESSAGE_INCREMENT_SIZE ) + 1 )
* LIBCERROR_MESSAGE_INCREMENT_SIZE;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
do
{
reallocation = memory_reallocate(
system_format_string,
sizeof( libcstring_system_character_t ) * ( format_string_length + 1 ) );
if( reallocation == NULL )
{
goto on_error;
}
system_format_string = (libcstring_system_character_t *) reallocation;
#if defined( __BORLANDC__ ) || defined( _MSC_VER )
print_count = libcstring_wide_string_snwprintf(
system_format_string,
format_string_length + 1,
L"%S",
format_string );
#else
print_count = libcstring_wide_string_snwprintf(
system_format_string,
format_string_length + 1,
L"%s",
format_string );
#endif
if( print_count <= -1 )
{
format_string_length += LIBCERROR_MESSAGE_INCREMENT_SIZE;
}
else if( ( (size_t) print_count > format_string_length )
|| ( system_format_string[ print_count ] != 0 ) )
{
format_string_length = (size_t) print_count;
print_count = -1;
}
if( format_string_length >= LIBCERROR_MESSAGE_MAXIMUM_SIZE )
{
goto on_error;
}
}
while( print_count <= -1 );
#else
system_format_string = (libcstring_system_character_t *) format_string;
#endif
#if defined( __BORLANDC__ ) || defined( _MSC_VER )
/* Rewrite %s to %S
*/
string_index = 0;
while( string_index < format_string_length )
{
if( system_format_string[ string_index ] == 0 )
{
break;
}
else if( system_format_string[ string_index ] == (libcstring_system_character_t) '%' )
{
string_index++;
if( system_format_string[ string_index ] == (libcstring_system_character_t) 's' )
{
system_format_string[ string_index ] = (libcstring_system_character_t) 'S';
}
}
string_index++;
}
#endif
if( *error == NULL )
{
internal_error = memory_allocate_structure(
libcerror_internal_error_t );
if( internal_error == NULL )
{
goto on_error;
}
internal_error->domain = error_domain;
internal_error->code = error_code;
internal_error->number_of_messages = 0;
internal_error->messages = NULL;
internal_error->sizes = NULL;
*error = (libcerror_error_t *) internal_error;
}
else
{
internal_error = (libcerror_internal_error_t *) *error;
}
reallocation = memory_reallocate(
internal_error->messages,
sizeof( libcstring_system_character_t * ) * ( internal_error->number_of_messages + 1 ) );
if( reallocation == NULL )
{
goto on_error;
}
internal_error->messages = (libcstring_system_character_t **) reallocation;
reallocation = memory_reallocate(
internal_error->sizes,
sizeof( size_t ) * ( internal_error->number_of_messages + 1 ) );
if( reallocation == NULL )
{
goto on_error;
}
internal_error->sizes = (size_t *) reallocation;
message_index = internal_error->number_of_messages;
internal_error->messages[ message_index ] = NULL;
internal_error->sizes[ message_index ] = 0;
internal_error->number_of_messages += 1;
do
{
reallocation = memory_reallocate(
internal_error->messages[ message_index ],
sizeof( libcstring_system_character_t ) * message_size );
if( reallocation == NULL )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
break;
}
internal_error->messages[ message_index ] = (libcstring_system_character_t *) reallocation;
VASTART(
argument_list,
const char *,
format_string );
print_count = libcstring_system_string_vsprintf(
internal_error->messages[ message_index ],
message_size,
system_format_string,
argument_list );
VAEND(
argument_list );
if( print_count <= -1 )
{
message_size += LIBCERROR_MESSAGE_INCREMENT_SIZE;
}
else if( ( (size_t) print_count > message_size )
|| ( ( internal_error->messages[ message_index ] )[ print_count ] != 0 ) )
{
message_size = (size_t) ( print_count + 1 );
print_count = -1;
}
if( message_size >= LIBCERROR_MESSAGE_MAXIMUM_SIZE )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
internal_error->sizes[ message_index ] = 0;
break;
}
internal_error->sizes[ message_index ] = (size_t) print_count + 1;
}
while( print_count <= -1 );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
memory_free(
system_format_string );
system_format_string = NULL;
#endif
string_index = internal_error->sizes[ message_index ] - 1;
if( ( internal_error->messages[ message_index ] != NULL )
&& ( ( internal_error->messages[ message_index ] )[ string_index - 1 ] == (libcstring_system_character_t) '.' ) )
{
string_index -= 1;
}
reallocation = memory_reallocate(
internal_error->messages[ message_index ],
sizeof( libcstring_system_character_t ) * ( message_size + 13 + 512 ) );
if( reallocation == NULL )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
goto on_error;
}
internal_error->messages[ message_index ] = (libcstring_system_character_t *) reallocation;
if( libcstring_system_string_copy(
&( ( internal_error->messages[ message_index ] )[ string_index ] ),
_LIBCSTRING_SYSTEM_STRING( " with error: " ),
13 ) == NULL )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
goto on_error;
}
internal_error->sizes[ message_index ] += 13;
string_index += 13;
print_count = libcerror_system_copy_string_from_error_number(
&( ( internal_error->messages[ message_index ] )[ string_index ] ),
512,
system_error_code );
if( print_count == -1 )
{
goto on_error;
}
message_size += (size_t) print_count;
if( message_size >= LIBCERROR_MESSAGE_MAXIMUM_SIZE )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
internal_error->sizes[ message_index ] = 0;
goto on_error;
}
internal_error->sizes[ message_index ] += print_count;
return;
on_error:
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( system_format_string != NULL )
{
memory_free(
system_format_string );
}
#endif
if( ( *error == NULL )
&& ( internal_error != NULL ) )
{
memory_free(
internal_error );
}
return;
}
int main( int argc, char * const argv[] )
#endif
{
export_handle_t *olecfexport_export_handle = NULL;
libcerror_error_t *error = NULL;
log_handle_t *log_handle = NULL;
libcstring_system_character_t *log_filename = NULL;
libcstring_system_character_t *option_ascii_codepage = NULL;
libcstring_system_character_t *option_target_path = NULL;
libcstring_system_character_t *path_separator = NULL;
libcstring_system_character_t *source = NULL;
char *program = "olecfexport";
size_t source_length = 0;
libcstring_system_integer_t option = 0;
int result = 0;
int verbose = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"olecftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
olecfoutput_version_fprint(
stdout,
program );
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "c:hl:t:vV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 'c':
option_ascii_codepage = optarg;
break;
case (libcstring_system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'l':
log_filename = optarg;
break;
case (libcstring_system_integer_t) 't':
option_target_path = optarg;
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
olecfoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
source = argv[ optind ];
if( option_target_path == NULL )
{
source_length = libcstring_system_string_length(
source );
path_separator = libcstring_system_string_search_character_reverse(
source,
(libcstring_system_character_t) LIBCPATH_SEPARATOR,
source_length );
if( path_separator == NULL )
{
path_separator = source;
}
else
{
path_separator++;
}
option_target_path = path_separator;
}
libcnotify_verbose_set(
verbose );
libolecf_notify_set_stream(
stderr,
NULL );
libolecf_notify_set_verbose(
verbose );
if( export_handle_initialize(
&olecfexport_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize export handle.\n" );
goto on_error;
}
if( export_handle_set_target_path(
olecfexport_export_handle,
option_target_path,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set target path.\n" );
goto on_error;
}
result = export_handle_create_items_export_path(
olecfexport_export_handle,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to create items export path.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"%" PRIs_LIBCSTRING_SYSTEM " already exists.\n",
olecfexport_export_handle->items_export_path );
goto on_error;
}
if( log_handle_initialize(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize log handle.\n" );
goto on_error;
}
if( log_handle_open(
log_handle,
log_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open log file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
log_filename );
goto on_error;
}
if( option_ascii_codepage != NULL )
{
result = export_handle_set_ascii_codepage(
olecfexport_export_handle,
option_ascii_codepage,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set ASCII codepage in export handle.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported ASCII codepage defaulting to: windows-1252.\n" );
}
}
fprintf(
stdout,
"Opening file.\n" );
if( export_handle_open_input(
olecfexport_export_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open: %" PRIs_LIBCSTRING_SYSTEM ".\n",
source );
goto on_error;
}
if( export_handle_export_file(
olecfexport_export_handle,
log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to export file stream and storage items.\n" );
goto on_error;
}
if( export_handle_close(
olecfexport_export_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close export handle.\n" );
goto on_error;
}
if( export_handle_free(
&olecfexport_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free export handle.\n" );
goto on_error;
}
if( log_handle_close(
log_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close log file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
log_filename );
goto on_error;
}
if( log_handle_free(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free log handle.\n" );
goto on_error;
}
fprintf(
stdout,
"Export completed.\n" );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( log_handle != NULL )
{
log_handle_close(
log_handle,
NULL );
log_handle_free(
&log_handle,
NULL );
}
if( olecfexport_export_handle != NULL )
{
export_handle_close(
olecfexport_export_handle,
NULL );
export_handle_free(
&olecfexport_export_handle,
NULL );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
libcerror_error_t *error = NULL;
libcstring_system_character_t *option_ascii_codepage = NULL;
libcstring_system_character_t *source = NULL;
char *program = "msiecfinfo";
libcstring_system_integer_t option = 0;
int show_allocation_information = 0;
int result = 0;
int verbose = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"msiecftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
msiecfoutput_version_fprint(
stdout,
program );
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "ac:hvV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 'a':
show_allocation_information = 1;
break;
case (libcstring_system_integer_t) 'c':
option_ascii_codepage = optarg;
break;
case (libcstring_system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
msiecfoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
source = argv[ optind ];
libcnotify_verbose_set(
verbose );
libmsiecf_notify_set_stream(
stderr,
NULL );
libmsiecf_notify_set_verbose(
verbose );
if( info_handle_initialize(
&msiecfinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize info handle.\n" );
goto on_error;
}
if( option_ascii_codepage != NULL )
{
result = info_handle_set_ascii_codepage(
msiecfinfo_info_handle,
option_ascii_codepage,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set ASCII codepage in info handle.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported ASCII codepage defaulting to: windows-1252.\n" );
}
}
if( info_handle_open_input(
msiecfinfo_info_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open: %" PRIs_LIBCSTRING_SYSTEM ".\n",
source );
goto on_error;
}
if( info_handle_file_fprint(
msiecfinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print file information.\n" );
goto on_error;
}
if( show_allocation_information != 0 )
{
if( info_handle_unallocated_blocks_fprint(
msiecfinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print file unallocated blocks.\n" );
goto on_error;
}
}
if( info_handle_close_input(
msiecfinfo_info_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close info handle.\n" );
goto on_error;
}
if( info_handle_free(
&msiecfinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free info handle.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( msiecfinfo_info_handle != NULL )
{
info_handle_free(
&msiecfinfo_info_handle,
NULL );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
libesedb_error_t *error = NULL;
libcstring_system_character_t *source = NULL;
char *program = "esedbinfo";
libcstring_system_integer_t option = 0;
int verbose = 0;
libsystem_notify_set_stream(
stderr,
NULL );
libsystem_notify_set_verbose(
1 );
if( libsystem_initialize(
"esedbtools",
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize system values.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
return( EXIT_FAILURE );
}
esedboutput_version_fprint(
stdout,
program );
while( ( option = libsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "hvV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
esedboutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
source = argv[ optind ];
libsystem_notify_set_verbose(
verbose );
libesedb_notify_set_stream(
stderr,
NULL );
libesedb_notify_set_verbose(
verbose );
if( info_handle_initialize(
&esedbinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize info handle.\n" );
goto on_error;
}
if( info_handle_open(
esedbinfo_info_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open: %" PRIs_LIBCSTRING_SYSTEM ".\n",
source );
goto on_error;
}
if( info_handle_file_fprint(
esedbinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print file information.\n" );
goto on_error;
}
if( info_handle_close(
esedbinfo_info_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close info handle.\n" );
goto on_error;
}
if( info_handle_free(
&esedbinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free info handle.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
if( esedbinfo_info_handle != NULL )
{
info_handle_free(
&esedbinfo_info_handle,
NULL );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t *target_filename = NULL;
liberror_error_t *error = NULL;
libewf_handle_t *handle = NULL;
libcstring_system_integer_t option = 0;
off64_t read_offset = 0;
size64_t media_size = 0;
size64_t read_size = 0;
size32_t chunk_size = 0;
size_t delta_segment_filename_length = 0;
while( ( option = libsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "t:" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 't':
target_filename = optarg;
break;
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing EWF image filename(s).\n" );
return( EXIT_FAILURE );
}
/* Initialization
*/
if( libewf_handle_initialize(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create handle.\n" );
goto on_error;
}
/*
#if defined( HAVE_DEBUG_OUTPUT )
libewf_notify_set_verbose(
1 );
libewf_notify_set_stream(
stderr,
NULL );
#endif
*/
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_open_wide(
handle,
&( argv[ optind ] ),
argc - optind,
LIBEWF_OPEN_READ_WRITE,
&error ) != 1 )
#else
if( libewf_handle_open(
handle,
&( argv[ optind ] ),
argc - optind,
LIBEWF_OPEN_READ_WRITE,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to open file(s).\n" );
goto on_error;
}
if( target_filename != NULL )
{
delta_segment_filename_length = libcstring_system_string_length(
target_filename );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_set_delta_segment_filename_wide(
handle,
target_filename,
delta_segment_filename_length,
&error ) != 1 )
#else
if( libewf_handle_set_delta_segment_filename(
handle,
target_filename,
delta_segment_filename_length,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to set delta segment filename.\n" );
goto on_error;
}
}
if( libewf_handle_get_media_size(
handle,
&media_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve media size.\n" );
goto on_error;
}
if( media_size > (size64_t) INT64_MAX )
{
fprintf(
stderr,
"Media size exceeds maximum.\n" );
goto on_error;
}
if( libewf_handle_get_chunk_size(
handle,
&chunk_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve chunk size.\n" );
goto on_error;
}
if( chunk_size == 0 )
{
fprintf(
stderr,
"Invalid chunk size.\n" );
goto on_error;
}
fprintf(
stdout,
"Media size: %" PRIu64 " bytes\n",
media_size );
/* Case 0: test full read
*/
/* Test: offset: 0 size: <media_size>
* Expected result: offset: 0 size: <media_size>
*/
read_offset = 0;
read_size = media_size;
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
/* Case 1: test random read
*/
/* Test: offset: <media_size / 7> size: <media_size / 2>
* Expected result: offset: <media_size / 7> size: <media_size / 2>
*/
read_offset = (off64_t) ( media_size / 7 );
read_size = media_size / 2;
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
/* Case 2: test read buffer beyond media size
*/
if( media_size < 1024 )
{
/* Test: offset: <media_size - 1024> size: 4096
* Expected result: offset: -1 size: <undetermined>
*/
read_offset = (off64_t) ( media_size - 1024 );
read_size = 4096;
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
}
else
{
/* Test: offset: <media_size - 1024> size: 4096
* Expected result: offset: <media_size - 1024> size: 1024
*/
read_offset = (off64_t) ( media_size - 1024 );
read_size = 4096;
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
1024 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
1024 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
}
fprintf(
stdout,
"\nChunk size: %" PRIu32 " bytes\n",
chunk_size );
/* Case 0: test full read
*/
/* Test: offset: 0 size: <media_size>
* Expected result: offset: 0 size: <media_size>
*/
read_offset = 0;
read_size = media_size;
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
/* Case 1: test random read
*/
/* Test: offset: <( ( media_size / 7 ) / chunk_size ) * chunk_size> size: <( ( ( media_size / 2 ) / chunk_size ) + 1 ) * chunk_size>
* Expected result: offset: <( ( media_size / 7 ) / chunk_size ) * chunk_size> size: <( ( ( media_size / 2 ) / chunk_size ) + 1 ) * chunk_size>
*/
read_offset = (off64_t) ( ( media_size / 7 ) / chunk_size ) * chunk_size;
read_size = ( ( ( media_size / 2 ) / chunk_size ) + 1 ) * chunk_size;
if( media_size == 0 )
{
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
0 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
0 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
}
else
{
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
}
/* Case 2: test read chunk beyond media size
*/
if( media_size < 1024 )
{
/* Test: offset: <media_size - 1024> size: chunk_size
* Expected result: offset: -1 size: <undetermined>
*/
read_offset = (off64_t) ( media_size - 1024 );
read_size = chunk_size;
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
}
else
{
/* Test: offset: <media_size - 1024> size: chunk_size
* Expected result: offset: <media_size - 1024> size: chunk size or media_size % chunk_size
*/
read_offset = (off64_t) ( media_size - 1024 );
read_size = chunk_size;
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
(off64_t) ( media_size - 1024 ),
( ( media_size % chunk_size ) == 0 ) ? chunk_size : media_size % chunk_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
(off64_t) ( media_size - 1024 ),
( ( media_size % chunk_size ) == 0 ) ? chunk_size : media_size % chunk_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
}
/* Clean up
*/
if( libewf_handle_close(
handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close file(s).\n" );
goto on_error;
}
if( libewf_handle_free(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free handle.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libewf_error_backtrace_fprint(
error,
stderr );
libewf_error_free(
&error );
}
if( handle != NULL )
{
libewf_handle_close(
handle,
NULL );
libewf_handle_free(
&handle,
NULL );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
#if defined( HAVE_GETRLIMIT )
struct rlimit limit_data;
#endif
libcerror_error_t *error = NULL;
libcstring_system_character_t * const *source_filenames = NULL;
#if !defined( HAVE_GLOB_H )
libcsystem_glob_t *glob = NULL;
#endif
libcstring_system_character_t *log_filename = NULL;
libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "ewfverify" );
libcstring_system_character_t *option_additional_digest_types = NULL;
libcstring_system_character_t *option_format = NULL;
libcstring_system_character_t *option_header_codepage = NULL;
libcstring_system_character_t *option_process_buffer_size = NULL;
log_handle_t *log_handle = NULL;
libcstring_system_integer_t option = 0;
uint8_t calculate_md5 = 1;
uint8_t print_status_information = 1;
uint8_t use_chunk_data_functions = 0;
uint8_t verbose = 0;
uint8_t zero_chunk_on_error = 0;
int number_of_filenames = 0;
int result = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"ewftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
ewfoutput_version_fprint(
stdout,
program );
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "A:d:f:hl:p:qvVwx" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
goto on_error;
case (libcstring_system_integer_t) 'A':
option_header_codepage = optarg;
break;
case (libcstring_system_integer_t) 'd':
option_additional_digest_types = optarg;
break;
case (libcstring_system_integer_t) 'f':
option_format = optarg;
break;
case (libcstring_system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'l':
log_filename = optarg;
break;
case (libcstring_system_integer_t) 'p':
option_process_buffer_size = optarg;
break;
case (libcstring_system_integer_t) 'q':
print_status_information = 0;
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
ewfoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'w':
zero_chunk_on_error = 1;
break;
case (libcstring_system_integer_t) 'x':
use_chunk_data_functions = 1;
break;
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing EWF image file(s).\n" );
usage_fprint(
stdout );
goto on_error;
}
libcnotify_verbose_set(
verbose );
#if !defined( HAVE_LOCAL_LIBEWF )
libewf_notify_set_verbose(
verbose );
libewf_notify_set_stream(
stderr,
NULL );
#endif
if( verification_handle_initialize(
&ewfverify_verification_handle,
calculate_md5,
use_chunk_data_functions,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create verification handle.\n" );
goto on_error;
}
if( option_header_codepage != NULL )
{
result = verification_handle_set_header_codepage(
ewfverify_verification_handle,
option_header_codepage,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set header codepage.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported header codepage defaulting to: ascii.\n" );
}
}
if( option_format != NULL )
{
result = verification_handle_set_format(
ewfverify_verification_handle,
option_format,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set format.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported input format defaulting to: raw.\n" );
}
}
if( option_process_buffer_size != NULL )
{
result = verification_handle_set_process_buffer_size(
ewfverify_verification_handle,
option_process_buffer_size,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set process buffer size.\n" );
goto on_error;
}
else if( ( result == 0 )
|| ( ewfverify_verification_handle->process_buffer_size > (size_t) SSIZE_MAX ) )
{
ewfverify_verification_handle->process_buffer_size = 0;
fprintf(
stderr,
"Unsupported process buffer size defaulting to: chunk size.\n" );
}
}
if( option_additional_digest_types != NULL )
{
result = verification_handle_set_additional_digest_types(
ewfverify_verification_handle,
option_additional_digest_types,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set additional digest types.\n" );
goto on_error;
}
}
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_initialize(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize glob.\n" );
goto on_error;
}
if( libcsystem_glob_resolve(
glob,
&( argv[ optind ] ),
argc - optind,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to resolve glob.\n" );
goto on_error;
}
source_filenames = glob->result;
number_of_filenames = glob->number_of_results;
#else
source_filenames = &( argv[ optind ] );
number_of_filenames = argc - optind;
#endif
#if defined( HAVE_GETRLIMIT )
if( getrlimit(
RLIMIT_NOFILE,
&limit_data ) != 0 )
{
fprintf(
stderr,
"Unable to determine limit: number of open file descriptors.\n" );
}
if( limit_data.rlim_max > (rlim_t) INT_MAX )
{
limit_data.rlim_max = (rlim_t) INT_MAX;
}
if( limit_data.rlim_max > 0 )
{
limit_data.rlim_max /= 2;
}
if( verification_handle_set_maximum_number_of_open_handles(
ewfverify_verification_handle,
(int) limit_data.rlim_max,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set maximum number of open file handles.\n" );
goto on_error;
}
#endif
if( libcsystem_signal_attach(
ewfverify_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
result = verification_handle_open_input(
ewfverify_verification_handle,
source_filenames,
number_of_filenames,
&error );
if( ewfverify_abort != 0 )
{
goto on_abort;
}
if( result != 1 )
{
fprintf(
stderr,
"Unable to open EWF image file(s).\n" );
goto on_error;
}
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_free(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
#endif
if( verification_handle_set_zero_chunk_on_error(
ewfverify_verification_handle,
zero_chunk_on_error,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set zero on chunk error.\n" );
goto on_error;
}
if( log_filename != NULL )
{
if( log_handle_initialize(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create log handle.\n" );
goto on_error;
}
if( log_handle_open(
log_handle,
log_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open log file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
log_filename );
goto on_error;
}
}
if( ewfverify_verification_handle->input_format == VERIFICATION_HANDLE_INPUT_FORMAT_FILES )
{
result = verification_handle_verify_single_files(
ewfverify_verification_handle,
print_status_information,
log_handle,
&error );
if( result != 1 )
{
fprintf(
stderr,
"Unable to verify single files.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
}
else
{
result = verification_handle_verify_input(
ewfverify_verification_handle,
print_status_information,
log_handle,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to verify input.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
}
if( log_handle != NULL )
{
if( log_handle_close(
log_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close log handle.\n" );
goto on_error;
}
if( log_handle_free(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free log handle.\n" );
goto on_error;
}
}
on_abort:
if( libcsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( verification_handle_close(
ewfverify_verification_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close verification handle.\n" );
goto on_error;
}
if( verification_handle_free(
&ewfverify_verification_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free verification handle.\n" );
goto on_error;
}
if( ewfverify_abort != 0 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n",
program );
return( EXIT_FAILURE );
}
if( result != 1 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": FAILURE\n",
program );
return( EXIT_FAILURE );
}
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": SUCCESS\n",
program );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( log_handle != NULL )
{
log_handle_close(
log_handle,
NULL );
log_handle_free(
&log_handle,
NULL );
}
if( ewfverify_verification_handle != NULL )
{
verification_handle_close(
ewfverify_verification_handle,
NULL );
verification_handle_free(
&ewfverify_verification_handle,
NULL );
}
#if !defined( HAVE_GLOB_H )
if( glob != NULL )
{
libcsystem_glob_free(
&glob,
NULL );
}
#endif
return( EXIT_FAILURE );
}
/* Stops the process status information
* Returns 1 if successful or -1 on error
*/
int process_status_stop(
process_status_t *process_status,
size64_t bytes_total,
int status,
libcerror_error_t **error )
{
libcstring_system_character_t time_string[ 32 ];
static char *function = "process_status_start";
const libcstring_system_character_t *status_string = NULL;
int64_t total_number_of_seconds = 0;
if( process_status == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid process status.",
function );
return( -1 );
}
if( ( status != PROCESS_STATUS_ABORTED )
&& ( status != PROCESS_STATUS_COMPLETED )
&& ( status != PROCESS_STATUS_FAILED ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported status.",
function );
return( -1 );
}
if( libcdatetime_elements_set_current_time_localtime(
process_status->last_time_elements,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set last time elements to current time.",
function );
return( -1 );
}
if( ( process_status->output_stream != NULL )
&& ( process_status->print_status_information != 0 )
&& ( process_status->status_process_string != NULL ) )
{
if( status == PROCESS_STATUS_ABORTED )
{
status_string = _LIBCSTRING_SYSTEM_STRING( "aborted" );
}
else if( status == PROCESS_STATUS_COMPLETED )
{
status_string = _LIBCSTRING_SYSTEM_STRING( "completed" );
}
else if( status == PROCESS_STATUS_FAILED )
{
status_string = _LIBCSTRING_SYSTEM_STRING( "failed" );
}
fprintf(
process_status->output_stream,
"%" PRIs_LIBCSTRING_SYSTEM " %" PRIs_LIBCSTRING_SYSTEM "",
process_status->status_process_string,
status_string );
if( libcdatetime_elements_copy_to_string(
process_status->last_time_elements,
(uint8_t *) time_string,
32,
LIBCDATETIME_STRING_FORMAT_TYPE_CTIME | LIBCDATETIME_STRING_FORMAT_FLAG_DATE_TIME,
NULL ) == 1 )
{
fprintf(
process_status->output_stream,
" at: %" PRIs_LIBCSTRING_SYSTEM "\n",
time_string );
}
else
{
fprintf(
process_status->output_stream,
".\n" );
}
if( ( status == PROCESS_STATUS_COMPLETED )
&& ( process_status->status_summary_string != NULL )
&& ( bytes_total > 0 ) )
{
fprintf(
process_status->output_stream,
"\n" );
if( libcdatetime_elements_get_delta_in_seconds(
process_status->last_time_elements,
process_status->start_time_elements,
&total_number_of_seconds,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine delta between last and start time.",
function );
return( -1 );
}
fprintf(
process_status->output_stream,
"%" PRIs_LIBCSTRING_SYSTEM ":",
process_status->status_summary_string );
process_status_bytes_fprint(
process_status->output_stream,
bytes_total );
process_status_timestamp_fprint(
process_status->output_stream,
total_number_of_seconds );
process_status_bytes_per_second_fprint(
process_status->output_stream,
bytes_total,
total_number_of_seconds );
fprintf(
process_status->output_stream,
".\n" );
}
}
return( 1 );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t *option_chunk_size = NULL;
libcstring_system_character_t *option_compression_level = NULL;
libcstring_system_character_t *option_maximum_segment_size = NULL;
libcstring_system_character_t *option_media_size = NULL;
libcerror_error_t *error = NULL;
libcstring_system_integer_t option = 0;
size64_t chunk_size = 0;
size64_t maximum_segment_size = 0;
size64_t media_size = 0;
size_t string_length = 0;
uint8_t compression_flags = 0;
int8_t compression_level = LIBEWF_COMPRESSION_NONE;
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "b:B:c:S:" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 'b':
option_chunk_size = optarg;
break;
case (libcstring_system_integer_t) 'c':
option_compression_level = optarg;
break;
case (libcstring_system_integer_t) 'B':
option_media_size = optarg;
break;
case (libcstring_system_integer_t) 'S':
option_maximum_segment_size = optarg;
break;
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing EWF image filename.\n" );
return( EXIT_FAILURE );
}
if( option_chunk_size != NULL )
{
string_length = libcstring_system_string_length(
option_chunk_size );
if( libcsystem_string_decimal_copy_to_64_bit(
option_chunk_size,
string_length + 1,
&chunk_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unsupported chunk size.\n" );
goto on_error;
}
}
if( option_compression_level != NULL )
{
string_length = libcstring_system_string_length(
option_compression_level );
if( string_length != 1 )
{
fprintf(
stderr,
"Unsupported compression level.\n" );
goto on_error;
}
if( option_compression_level[ 0 ] == (libcstring_system_character_t) 'n' )
{
compression_level = LIBEWF_COMPRESSION_NONE;
compression_flags = 0;
}
else if( option_compression_level[ 0 ] == (libcstring_system_character_t) 'e' )
{
compression_level = LIBEWF_COMPRESSION_NONE;
compression_flags = LIBEWF_COMPRESS_FLAG_USE_EMPTY_BLOCK_COMPRESSION;
}
else if( option_compression_level[ 0 ] == (libcstring_system_character_t) 'f' )
{
compression_level = LIBEWF_COMPRESSION_FAST;
compression_flags = 0;
}
else if( option_compression_level[ 0 ] == (libcstring_system_character_t) 'b' )
{
compression_level = LIBEWF_COMPRESSION_BEST;
compression_flags = 0;
}
else
{
fprintf(
stderr,
"Unsupported compression level.\n" );
goto on_error;
}
}
if( option_maximum_segment_size != NULL )
{
string_length = libcstring_system_string_length(
option_maximum_segment_size );
if( libcsystem_string_decimal_copy_to_64_bit(
option_maximum_segment_size,
string_length + 1,
&maximum_segment_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unsupported maximum segment size.\n" );
goto on_error;
}
}
if( option_media_size != NULL )
{
string_length = libcstring_system_string_length(
option_media_size );
if( libcsystem_string_decimal_copy_to_64_bit(
option_media_size,
string_length + 1,
&media_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unsupported media size.\n" );
goto on_error;
}
}
if( ewf_test_write_chunk(
argv[ optind ],
media_size,
maximum_segment_size,
compression_level,
compression_flags,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to test write.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libewf_error_backtrace_fprint(
error,
stderr );
libewf_error_free(
&error );
}
return( EXIT_FAILURE );
}
/* Opens the registry file
* Returns 1 if successful or -1 on error
*/
int registry_file_open(
registry_file_t *registry_file,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
libcstring_system_character_t *name = NULL;
libregf_key_t *sub_key = NULL;
libregf_value_t *value = NULL;
static char *function = "registry_file_open";
const char *sub_key_path = NULL;
const char *value_name = NULL;
size_t name_size = 0;
size_t sub_key_path_length = 0;
size_t value_name_length = 0;
int number_of_sub_keys = 0;
int result = 0;
if( registry_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid registry file.",
function );
return( -1 );
}
if( registry_file->is_open != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid registry file already open.",
function );
return( -1 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libregf_file_open_wide(
registry_file->regf_file,
filename,
LIBREGF_OPEN_READ,
error ) != 1 )
#else
if( libregf_file_open(
registry_file->regf_file,
filename,
LIBREGF_OPEN_READ,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open REGF file.",
function );
goto on_error;
}
if( libregf_file_get_root_key(
registry_file->regf_file,
&( registry_file->root_key ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve root key.",
function );
goto on_error;
}
if( libregf_key_get_number_of_sub_keys(
registry_file->root_key,
&number_of_sub_keys,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of sub keys of root key.",
function );
goto on_error;
}
result = 0;
if( number_of_sub_keys == 1 )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libregf_key_get_utf16_name_size(
registry_file->root_key,
&name_size,
error );
#else
result = libregf_key_get_utf8_name_size(
registry_file->root_key,
&name_size,
error );
#endif
if( ( result != 1 )
|| ( name_size == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve root key name size.",
function );
goto on_error;
}
if( ( name_size > (size_t) SSIZE_MAX )
|| ( ( sizeof( libcstring_system_character_t ) * name_size ) > (size_t) SSIZE_MAX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid name size value exceeds maximum.",
function );
goto on_error;
}
name = libcstring_system_string_allocate(
name_size );
if( name == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name string.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libregf_key_get_utf16_name(
registry_file->root_key,
(uint16_t *) name,
name_size,
error );
#else
result = libregf_key_get_utf8_name(
registry_file->root_key,
(uint8_t *) name,
name_size,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve root key name.",
function );
goto on_error;
}
result = 0;
/* TODO what about Windows NT4 */
if( name_size == 13 )
{
/* Root key used by Windows 2000, XP, 2003
*/
if( libcstring_system_string_compare_no_case(
name,
_LIBCSTRING_SYSTEM_STRING( "$$$PROTO.HIV" ),
12 ) == 0 )
{
result = 1;
}
}
else if( name_size == 53 )
{
/* Root key used by Windows Vista, 2008, 7
*/
if( libcstring_system_string_compare_no_case(
name,
_LIBCSTRING_SYSTEM_STRING( "CMI-CreateHive{" ),
15 ) == 0 )
{
if( name[ 51 ] == (libcstring_system_character_t) '}' )
{
result = 1;
}
}
}
else if( name_size == 58 )
{
/* Root key used by Windows 8
*/
if( libcstring_system_string_compare_no_case(
name,
_LIBCSTRING_SYSTEM_STRING( "CsiTool-CreateHive-{" ),
20 ) == 0 )
{
if( name[ 56 ] == (libcstring_system_character_t) '}' )
{
result = 1;
}
}
}
memory_free(
name );
name = NULL;
}
if( result != 0 )
{
if( libregf_key_get_sub_key(
registry_file->root_key,
0,
&( registry_file->base_key ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve base key.",
function );
goto on_error;
}
}
else
{
/* E.g. for the SAM registry file the root key is the base
*/
registry_file->base_key = registry_file->root_key;
}
/* Determine the registry file type based on the name of the base key
*/
/* TODO refactor to separate function */
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libregf_key_get_utf16_name_size(
registry_file->base_key,
&name_size,
error );
#else
result = libregf_key_get_utf8_name_size(
registry_file->base_key,
&name_size,
error );
#endif
if( ( result != 1 )
|| ( name_size == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve base key name size.",
function );
goto on_error;
}
if( ( name_size > (size_t) SSIZE_MAX )
|| ( ( sizeof( libcstring_system_character_t ) * name_size ) > (size_t) SSIZE_MAX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid name size value exceeds maximum.",
function );
goto on_error;
}
name = libcstring_system_string_allocate(
name_size );
if( name == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name string.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libregf_key_get_utf16_name(
registry_file->base_key,
(uint16_t *) name,
name_size,
error );
#else
result = libregf_key_get_utf8_name(
registry_file->base_key,
(uint8_t *) name,
name_size,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve base key name.",
function );
goto on_error;
}
/* TODO add more types */
if( name_size == 4 )
{
if( libcstring_system_string_compare_no_case(
name,
_LIBCSTRING_SYSTEM_STRING( "SAM" ),
3 ) == 0 )
{
registry_file->type = REGISTRY_FILE_TYPE_SAM;
}
}
memory_free(
name );
name = NULL;
/* TODO still needed ? */
if( libregf_key_get_number_of_sub_keys(
registry_file->base_key,
&number_of_sub_keys,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of sub keys of base key.",
function );
goto on_error;
}
/* TODO refactor to separate function */
/* Get the current control set from:
* SYSTEM\Select\Current
*/
sub_key_path = "Select";
sub_key_path_length = libcstring_narrow_string_length(
sub_key_path );
result = libregf_key_get_sub_key_by_utf8_path(
registry_file->base_key,
(uint8_t *) sub_key_path,
sub_key_path_length,
&sub_key,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve sub key: %s.",
function,
sub_key_path );
goto on_error;
}
else if( result != 0 )
{
value_name = "Current";
value_name_length = libcstring_narrow_string_length(
value_name );
result = libregf_key_get_value_by_utf8_name(
sub_key,
(uint8_t *) value_name,
value_name_length,
&value,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve value: %s.",
function,
value_name );
goto on_error;
}
else if( result != 0 )
{
if( libregf_value_get_value_32bit(
value,
&( registry_file->current_control_set ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve 32-bit value: %s.",
function,
value_name );
goto on_error;
}
if( libregf_value_free(
&value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free value.",
function );
goto on_error;
}
}
}
if( libregf_key_free(
&sub_key,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free sub key.",
function );
goto on_error;
}
/* Retrieve the control set 1 key: SYSTEM\ControlSet001
*/
sub_key_path = "ControlSet001";
sub_key_path_length = libcstring_narrow_string_length(
sub_key_path );
result = libregf_key_get_sub_key_by_utf8_path(
registry_file->base_key,
(uint8_t *) sub_key_path,
sub_key_path_length,
&( registry_file->control_set1_key ),
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve sub key: %s.",
function,
sub_key_path );
goto on_error;
}
/* Retrieve the control set 2 key: SYSTEM\ControlSet002
*/
sub_key_path = "ControlSet002";
sub_key_path_length = libcstring_narrow_string_length(
sub_key_path );
result = libregf_key_get_sub_key_by_utf8_path(
registry_file->base_key,
(uint8_t *) sub_key_path,
sub_key_path_length,
&( registry_file->control_set2_key ),
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve sub key: %s.",
function,
sub_key_path );
goto on_error;
}
if( ( registry_file->current_control_set != 0 )
|| ( registry_file->control_set1_key != NULL )
|| ( registry_file->control_set2_key != NULL ) )
{
if( ( registry_file->current_control_set != 1 )
&& ( registry_file->current_control_set != 2 ) )
{
/* TODO print debug notification */
registry_file->current_control_set = 1;
}
if( ( registry_file->current_control_set == 1 )
&& ( registry_file->control_set1_key != NULL ) )
{
registry_file->current_control_set_key = registry_file->control_set1_key;
}
else if( ( registry_file->current_control_set == 2 )
&& ( registry_file->control_set2_key != NULL ) )
{
registry_file->current_control_set_key = registry_file->control_set2_key;
}
}
registry_file->is_open = 1;
return( 1 );
on_error:
if( value != NULL )
{
libregf_value_free(
&value,
NULL );
}
if( sub_key != NULL )
{
libregf_key_free(
&sub_key,
NULL );
}
if( registry_file->control_set2_key != NULL )
{
libregf_key_free(
&( registry_file->control_set2_key ),
NULL );
}
if( registry_file->control_set1_key != NULL )
{
libregf_key_free(
&( registry_file->control_set1_key ),
NULL );
}
if( ( registry_file->base_key != NULL )
&& ( registry_file->base_key != registry_file->root_key ) )
{
libregf_key_free(
&( registry_file->base_key ),
NULL );
}
if( name != NULL )
{
memory_free(
name );
}
if( registry_file->root_key != NULL )
{
libregf_key_free(
&( registry_file->root_key ),
NULL );
}
libregf_file_close(
registry_file->regf_file,
NULL );
return( -1 );
}
/* Exports the values in a Container_ table record
* Returns 1 if successful or -1 on error
*/
int webcache_export_record_container(
libesedb_record_t *record,
FILE *record_file_stream,
log_handle_t *log_handle,
libcerror_error_t **error )
{
libcstring_system_character_t column_name[ 256 ];
static char *function = "webcache_export_record_container";
size_t column_name_size = 0;
uint32_t column_type = 0;
int known_column_type = 0;
int number_of_values = 0;
int result = 0;
int value_iterator = 0;
uint8_t byte_order = _BYTE_STREAM_ENDIAN_LITTLE;
if( record == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid record.",
function );
return( -1 );
}
if( record_file_stream == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid record file stream.",
function );
return( -1 );
}
if( libesedb_record_get_number_of_values(
record,
&number_of_values,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of values.",
function );
return( -1 );
}
for( value_iterator = 0;
value_iterator < number_of_values;
value_iterator++ )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libesedb_record_get_utf16_column_name_size(
record,
value_iterator,
&column_name_size,
error );
#else
result = libesedb_record_get_utf8_column_name_size(
record,
value_iterator,
&column_name_size,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve column name size of value: %d.",
function,
value_iterator );
return( -1 );
}
/* It is assumed that the column name cannot be larger than 255 characters
* otherwise using dynamic allocation is more appropriate
*/
if( column_name_size > 256 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: column name size value exceeds maximum.",
function );
return( -1 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libesedb_record_get_utf16_column_name(
record,
value_iterator,
(uint16_t *) column_name,
column_name_size,
error );
#else
result = libesedb_record_get_utf8_column_name(
record,
value_iterator,
(uint8_t *) column_name,
column_name_size,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve column name of value: %d.",
function,
value_iterator );
return( -1 );
}
if( libesedb_record_get_column_type(
record,
value_iterator,
&column_type,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve column type of value: %d.",
function,
value_iterator );
return( -1 );
}
known_column_type = WEBCACHE_KNOWN_COLUMN_TYPE_UNDEFINED;
if( column_type == LIBESEDB_COLUMN_TYPE_INTEGER_64BIT_SIGNED )
{
if( column_name_size == 9 )
{
if( libcstring_system_string_compare(
column_name,
_LIBCSTRING_SYSTEM_STRING( "SyncTime" ),
8 ) == 0 )
{
known_column_type = WEBCACHE_KNOWN_COLUMN_TYPE_FILETIME;
}
}
else if( column_name_size == 11 )
{
if( libcstring_system_string_compare(
column_name,
_LIBCSTRING_SYSTEM_STRING( "ExpiryTime" ),
10 ) == 0 )
{
known_column_type = WEBCACHE_KNOWN_COLUMN_TYPE_FILETIME;
}
}
else if( column_name_size == 13 )
{
if( libcstring_system_string_compare(
column_name,
_LIBCSTRING_SYSTEM_STRING( "AccessedTime" ),
12 ) == 0 )
{
known_column_type = WEBCACHE_KNOWN_COLUMN_TYPE_FILETIME;
}
else if( libcstring_system_string_compare(
column_name,
_LIBCSTRING_SYSTEM_STRING( "CreationTime" ),
12 ) == 0 )
{
known_column_type = WEBCACHE_KNOWN_COLUMN_TYPE_FILETIME;
}
else if( libcstring_system_string_compare(
column_name,
_LIBCSTRING_SYSTEM_STRING( "ModifiedTime" ),
12 ) == 0 )
{
known_column_type = WEBCACHE_KNOWN_COLUMN_TYPE_FILETIME;
}
}
}
if( known_column_type == WEBCACHE_KNOWN_COLUMN_TYPE_FILETIME )
{
result = export_filetime(
record,
value_iterator,
byte_order,
record_file_stream,
error );
}
else if( known_column_type == WEBCACHE_KNOWN_COLUMN_TYPE_UNDEFINED )
{
result = export_handle_export_record_value(
record,
value_iterator,
record_file_stream,
log_handle,
error );
}
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GENERIC,
"%s: unable to export record value: %d.",
function,
value_iterator );
return( -1 );
}
if( value_iterator == ( number_of_values - 1 ) )
{
fprintf(
record_file_stream,
"\n" );
}
else
{
fprintf(
record_file_stream,
"\t" );
}
}
return( 1 );
}
/* Stops the process status information
* Returns 1 if successful or -1 on error
*/
int process_status_stop(
process_status_t *process_status,
size64_t bytes_total,
int status,
libcerror_error_t **error )
{
libcstring_system_character_t time_string[ 32 ];
static char *function = "process_status_start";
const libcstring_system_character_t *status_string = NULL;
time_t seconds_total = 0;
if( process_status == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid process status.",
function );
return( -1 );
}
if( ( status != PROCESS_STATUS_ABORTED )
&& ( status != PROCESS_STATUS_COMPLETED )
&& ( status != PROCESS_STATUS_FAILED ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported status.",
function );
return( -1 );
}
process_status->last_timestamp = time(
NULL );
if( ( process_status->output_stream != NULL )
&& ( process_status->print_status_information != 0 )
&& ( process_status->status_process_string != NULL ) )
{
if( status == PROCESS_STATUS_ABORTED )
{
status_string = _LIBCSTRING_SYSTEM_STRING( "aborted" );
}
else if( status == PROCESS_STATUS_COMPLETED )
{
status_string = _LIBCSTRING_SYSTEM_STRING( "completed" );
}
else if( status == PROCESS_STATUS_FAILED )
{
status_string = _LIBCSTRING_SYSTEM_STRING( "failed" );
}
fprintf(
process_status->output_stream,
"%" PRIs_LIBCSTRING_SYSTEM " %" PRIs_LIBCSTRING_SYSTEM "",
process_status->status_process_string,
status_string );
if( process_status_get_ctime_string(
&( process_status->last_timestamp ),
time_string,
32,
NULL ) == 1 )
{
fprintf(
process_status->output_stream,
" at: %" PRIs_LIBCSTRING_SYSTEM "\n",
time_string );
}
else
{
fprintf(
process_status->output_stream,
".\n" );
}
if( ( status == PROCESS_STATUS_COMPLETED )
&& ( process_status->status_summary_string != NULL )
&& ( bytes_total > 0 ) )
{
seconds_total = process_status->last_timestamp - process_status->start_timestamp;
fprintf(
process_status->output_stream,
"%" PRIs_LIBCSTRING_SYSTEM ":",
process_status->status_summary_string );
process_status_bytes_fprint(
process_status->output_stream,
bytes_total );
process_status_timestamp_fprint(
process_status->output_stream,
seconds_total );
process_status_bytes_per_second_fprint(
process_status->output_stream,
bytes_total,
seconds_total );
fprintf(
process_status->output_stream,
".\n" );
}
}
return( 1 );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t acquiry_operating_system[ 32 ];
libcstring_system_character_t input_buffer[ EWFEXPORT_INPUT_BUFFER_SIZE ];
libcstring_system_character_t * const *argv_filenames = NULL;
liberror_error_t *error = NULL;
#if !defined( LIBSYSTEM_HAVE_GLOB )
libsystem_glob_t *glob = NULL;
#endif
libcstring_system_character_t *acquiry_software_version = NULL;
libcstring_system_character_t *log_filename = NULL;
libcstring_system_character_t *option_additional_digest_types = NULL;
libcstring_system_character_t *option_compression_level = NULL;
libcstring_system_character_t *option_format = NULL;
libcstring_system_character_t *option_header_codepage = NULL;
libcstring_system_character_t *option_maximum_segment_size = NULL;
libcstring_system_character_t *option_offset = NULL;
libcstring_system_character_t *option_process_buffer_size = NULL;
libcstring_system_character_t *option_sectors_per_chunk = NULL;
libcstring_system_character_t *option_size = NULL;
libcstring_system_character_t *option_target_filename = NULL;
libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "ewfexport" );
libcstring_system_character_t *request_string = NULL;
log_handle_t *log_handle = NULL;
libcstring_system_integer_t option = 0;
size64_t media_size = 0;
size_t string_length = 0;
uint8_t calculate_md5 = 1;
uint8_t print_status_information = 1;
uint8_t swap_byte_pairs = 0;
uint8_t verbose = 0;
uint8_t zero_chunk_on_error = 0;
int interactive_mode = 1;
int number_of_filenames = 0;
int result = 1;
libsystem_notify_set_stream(
stderr,
NULL );
libsystem_notify_set_verbose(
1 );
if( libsystem_initialize(
"ewftools",
&error ) != 1 )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
#if defined( WINAPI ) && !defined( __CYGWIN__ )
#if defined( _MSC_VER )
if( _setmode(
_fileno(
stdout ),
_O_BINARY ) == -1 )
#else
if( setmode(
_fileno(
stdout ),
_O_BINARY ) == -1 )
#endif
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to set stdout to binary mode.\n" );
usage_fprint(
stdout );
goto on_error;
}
#endif
while( ( option = libsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "A:b:B:c:d:f:hl:o:p:qsS:t:uvVw" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
usage_fprint(
stderr );
goto on_error;
case (libcstring_system_integer_t) 'A':
option_header_codepage = optarg;
break;
case (libcstring_system_integer_t) 'b':
option_sectors_per_chunk = optarg;
break;
case (libcstring_system_integer_t) 'B':
option_size = optarg;
break;
case (libcstring_system_integer_t) 'c':
option_compression_level = optarg;
break;
case (libcstring_system_integer_t) 'd':
option_additional_digest_types = optarg;
break;
case (libcstring_system_integer_t) 'f':
option_format = optarg;
break;
case (libcstring_system_integer_t) 'h':
ewfoutput_version_fprint(
stderr,
program );
usage_fprint(
stderr );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'l':
log_filename = optarg;
break;
case (libcstring_system_integer_t) 'o':
option_offset = optarg;
break;
case (libcstring_system_integer_t) 'p':
option_process_buffer_size = optarg;
break;
case (libcstring_system_integer_t) 'q':
print_status_information = 0;
break;
case (libcstring_system_integer_t) 's':
swap_byte_pairs = 1;
break;
case (libcstring_system_integer_t) 'S':
option_maximum_segment_size = optarg;
break;
case (libcstring_system_integer_t) 't':
option_target_filename = optarg;
break;
case (libcstring_system_integer_t) 'u':
interactive_mode = 0;
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
ewfoutput_version_fprint(
stderr,
program );
ewfoutput_copyright_fprint(
stderr );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'w':
zero_chunk_on_error = 1;
break;
}
}
if( optind == argc )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Missing EWF image file(s).\n" );
usage_fprint(
stderr );
goto on_error;
}
ewfoutput_version_fprint(
stderr,
program );
libsystem_notify_set_verbose(
verbose );
libewf_notify_set_verbose(
verbose );
libewf_notify_set_stream(
stderr,
NULL );
#if !defined( LIBSYSTEM_HAVE_GLOB )
if( libsystem_glob_initialize(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize glob.\n" );
goto on_error;
}
if( libsystem_glob_resolve(
glob,
&( argv[ optind ] ),
argc - optind,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to resolve glob.\n" );
goto on_error;
}
argv_filenames = glob->result;
number_of_filenames = glob->number_of_results;
#else
argv_filenames = &( argv[ optind ] );
number_of_filenames = argc - optind;
#endif
if( export_handle_initialize(
&ewfexport_export_handle,
calculate_md5,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create export handle.\n" );
goto on_error;
}
if( libsystem_signal_attach(
ewfexport_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
result = export_handle_open_input(
ewfexport_export_handle,
argv_filenames,
number_of_filenames,
&error );
if( ewfexport_abort != 0 )
{
goto on_abort;
}
if( result != 1 )
{
fprintf(
stderr,
"Unable to open EWF file(s).\n" );
goto on_error;
}
#if !defined( LIBSYSTEM_HAVE_GLOB )
if( libsystem_glob_free(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
#endif
if( export_handle_get_input_media_size(
ewfexport_export_handle,
&media_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve input media size.\n" );
goto on_error;
}
if( option_header_codepage != NULL )
{
result = export_handle_set_header_codepage(
ewfexport_export_handle,
option_header_codepage,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set header codepage.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported header codepage defaulting to: ascii.\n" );
}
}
if( option_target_filename != NULL )
{
if( export_handle_set_string(
ewfexport_export_handle,
option_target_filename,
&( ewfexport_export_handle->target_filename ),
&( ewfexport_export_handle->target_filename_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set target filename.\n" );
goto on_error;
}
}
else if( interactive_mode == 0 )
{
/* Make sure the target filename is set in unattended mode
*/
if( export_handle_set_string(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "export" ),
&( ewfexport_export_handle->target_filename ),
&( ewfexport_export_handle->target_filename_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set target filename.\n" );
goto on_error;
}
}
if( option_compression_level != NULL )
{
result = export_handle_set_compression_values(
ewfexport_export_handle,
option_compression_level,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set compression values.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported compression level defaulting to: none.\n" );
}
}
if( option_format != NULL )
{
result = export_handle_set_format(
ewfexport_export_handle,
option_format,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set format.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported output format defaulting to: raw.\n" );
}
}
if( option_sectors_per_chunk != NULL )
{
result = export_handle_set_sectors_per_chunk(
ewfexport_export_handle,
option_sectors_per_chunk,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set sectors per chunk.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported sectors per chunk defaulting to: 64.\n" );
}
}
if( option_maximum_segment_size != NULL )
{
result = export_handle_set_maximum_segment_size(
ewfexport_export_handle,
option_maximum_segment_size,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set maximum segment size.\n" );
goto on_error;
}
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
{
if( ( result == 0 )
|| ( ewfexport_export_handle->maximum_segment_size < EWFCOMMON_MINIMUM_SEGMENT_FILE_SIZE )
|| ( ( ewfexport_export_handle->ewf_format == LIBEWF_FORMAT_ENCASE6 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) )
|| ( ( ewfexport_export_handle->ewf_format != LIBEWF_FORMAT_ENCASE6 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_32BIT ) ) )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE;
fprintf(
stderr,
"Unsupported maximum segment size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->maximum_segment_size );
}
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW )
{
if( ( result == 0 )
|| ( ( ewfexport_export_handle->maximum_segment_size != 0 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) ) )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE;
fprintf(
stderr,
"Unsupported maximum segment size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->maximum_segment_size );
}
}
}
if( option_offset != NULL )
{
string_length = libcstring_system_string_length(
option_offset );
if( libsystem_string_to_uint64(
option_offset,
string_length + 1,
&ewfexport_export_handle->export_offset,
&error ) != 1 )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
ewfexport_export_handle->export_offset = 0;
fprintf(
stderr,
"Unsupported export offset defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->export_offset );
}
}
if( option_size != NULL )
{
string_length = libcstring_system_string_length(
option_size );
if( libsystem_string_to_uint64(
option_size,
string_length + 1,
&ewfexport_export_handle->export_size,
&error ) != 1 )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
ewfexport_export_handle->export_size = 0;
fprintf(
stderr,
"Unsupported export size defaulting to: all bytes.\n" );
}
}
if( option_process_buffer_size != NULL )
{
result = export_handle_set_process_buffer_size(
ewfexport_export_handle,
option_process_buffer_size,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set process buffer size.\n" );
goto on_error;
}
else if( ( result == 0 )
|| ( ewfexport_export_handle->process_buffer_size > (size_t) SSIZE_MAX ) )
{
ewfexport_export_handle->process_buffer_size = 0;
fprintf(
stderr,
"Unsupported process buffer size defaulting to: chunk size.\n" );
}
}
if( option_additional_digest_types != NULL )
{
result = export_handle_set_additional_digest_types(
ewfexport_export_handle,
option_additional_digest_types,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set additional digest types.\n" );
goto on_error;
}
}
/* Initialize values
*/
if( ( ewfexport_export_handle->export_size == 0 )
|| ( ewfexport_export_handle->export_size > ( media_size - ewfexport_export_handle->export_offset ) ) )
{
ewfexport_export_handle->export_size = media_size - ewfexport_export_handle->export_offset;
}
/* Request the necessary case data
*/
if( interactive_mode != 0 )
{
if( libsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
fprintf(
stderr,
"Information for export required, please provide the necessary input\n" );
if( option_format == NULL )
{
result = export_handle_prompt_for_format(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "Export to format" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine format.\n" );
goto on_error;
}
}
if( option_target_filename == NULL )
{
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
{
request_string = _LIBCSTRING_SYSTEM_STRING( "Target path and filename without extension" );
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_FILES )
{
request_string = _LIBCSTRING_SYSTEM_STRING( "Target path" );
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW )
{
request_string = _LIBCSTRING_SYSTEM_STRING( "Target path and filename without extension or - for stdout" );
}
}
if( request_string != NULL )
{
do
{
result = export_handle_prompt_for_string(
ewfexport_export_handle,
request_string,
&( ewfexport_export_handle->target_filename ),
&( ewfexport_export_handle->target_filename_size ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine target.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stdout,
"Target is required, please try again or terminate using Ctrl^C.\n" );
}
}
while( result != 1 );
}
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
{
if( option_compression_level == NULL )
{
result = export_handle_prompt_for_compression_level(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "Use compression" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine compression level.\n" );
goto on_error;
}
}
if( option_maximum_segment_size == NULL )
{
result = export_handle_prompt_for_maximum_segment_size(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "Evidence segment file size in bytes" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine maximum segment size.\n" );
goto on_error;
}
if( ( ewfexport_export_handle->maximum_segment_size < EWFCOMMON_MINIMUM_SEGMENT_FILE_SIZE )
|| ( ( ewfexport_export_handle->ewf_format == LIBEWF_FORMAT_ENCASE6 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) )
|| ( ( ewfexport_export_handle->ewf_format != LIBEWF_FORMAT_ENCASE6 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_32BIT ) ) )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE;
fprintf(
stderr,
"Unsupported maximum segment size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->maximum_segment_size );
}
}
if( option_sectors_per_chunk == NULL )
{
result = export_handle_prompt_for_sectors_per_chunk(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "The number of sectors to read at once" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine sectors per chunk.\n" );
goto on_error;
}
}
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW )
{
if( ( ewfexport_export_handle->target_filename != NULL )
&& ( ( ewfexport_export_handle->target_filename )[ 0 ] == (libcstring_system_character_t) '-' )
&& ( ( ewfexport_export_handle->target_filename )[ 1 ] == 0 ) )
{
/* No need for segment files when exporting to stdout */
}
else if( option_maximum_segment_size == NULL )
{
result = export_handle_prompt_for_maximum_segment_size(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "Evidence segment file size in bytes (0 is unlimited)" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine maximum segment size.\n" );
goto on_error;
}
if( ( ewfexport_export_handle->maximum_segment_size != 0 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE;
fprintf(
stderr,
"Unsupported maximum segment size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->maximum_segment_size );
}
}
}
if( ( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
|| ( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW ) )
{
if( option_offset == NULL )
{
if( ewfinput_get_size_variable(
stderr,
input_buffer,
EWFEXPORT_INPUT_BUFFER_SIZE,
_LIBCSTRING_SYSTEM_STRING( "Start export at offset" ),
0,
media_size,
ewfexport_export_handle->export_offset,
&( ewfexport_export_handle->export_offset ),
&error ) == -1 )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
ewfexport_export_handle->export_offset = 0;
fprintf(
stderr,
"Unable to determine export offset defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->export_offset );
}
}
if( option_size == NULL )
{
if( ewfinput_get_size_variable(
stderr,
input_buffer,
EWFEXPORT_INPUT_BUFFER_SIZE,
_LIBCSTRING_SYSTEM_STRING( "Number of bytes to export" ),
0,
media_size - ewfexport_export_handle->export_offset,
ewfexport_export_handle->export_size,
&( ewfexport_export_handle->export_size ),
&error ) == -1 )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
ewfexport_export_handle->export_size = media_size - ewfexport_export_handle->export_offset;
fprintf(
stderr,
"Unable to determine export size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->export_size );
}
}
}
if( libsystem_signal_attach(
ewfexport_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
}
else
{
if( ewfexport_export_handle->maximum_segment_size == 0 )
{
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
{
if( ewfexport_export_handle->ewf_format == LIBEWF_FORMAT_ENCASE6 )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT;
}
else
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_32BIT;
}
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT;
}
}
}
fprintf(
stderr,
"\n" );
if( log_filename != NULL )
{
if( log_handle_initialize(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create log handle.\n" );
goto on_error;
}
if( log_handle_open(
log_handle,
log_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open log file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
log_filename );
goto on_error;
}
}
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_FILES )
{
result = export_handle_export_single_files(
ewfexport_export_handle,
ewfexport_export_handle->target_filename,
print_status_information,
log_handle,
&error );
if( result != 1 )
{
fprintf(
stderr,
"Unable to export single files.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
}
else
{
if( export_handle_open_output(
ewfexport_export_handle,
ewfexport_export_handle->target_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open output.\n" );
goto on_error;
}
if( platform_get_operating_system(
acquiry_operating_system,
32,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to determine operating system.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
acquiry_operating_system[ 0 ] = 0;
}
acquiry_software_version = _LIBCSTRING_SYSTEM_STRING( LIBEWF_VERSION_STRING );
if( export_handle_set_output_values(
ewfexport_export_handle,
acquiry_operating_system,
program,
acquiry_software_version,
zero_chunk_on_error,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set output values.\n" );
goto on_error;
}
result = export_handle_export_input(
ewfexport_export_handle,
swap_byte_pairs,
print_status_information,
log_handle,
&error );
if( result != 1 )
{
fprintf(
stderr,
"Unable to export input.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
}
if( log_handle != NULL )
{
if( log_handle_close(
log_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close log file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
log_filename );
goto on_error;
}
if( log_handle_free(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free log handle.\n" );
goto on_error;
}
}
on_abort:
if( export_handle_close(
ewfexport_export_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close export handle.\n" );
goto on_error;
}
if( libsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
if( export_handle_free(
&ewfexport_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free export handle.\n" );
goto on_error;
}
if( ewfexport_abort != 0 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n",
program );
return( EXIT_FAILURE );
}
if( result != 1 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": FAILURE\n",
program );
return( EXIT_FAILURE );
}
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": SUCCESS\n",
program );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
if( log_handle != NULL )
{
log_handle_close(
log_handle,
NULL );
log_handle_free(
&log_handle,
NULL );
}
if( ewfexport_export_handle != NULL )
{
export_handle_close(
ewfexport_export_handle,
NULL );
export_handle_free(
&ewfexport_export_handle,
NULL );
}
#if !defined( LIBSYSTEM_HAVE_GLOB )
if( glob != NULL )
{
libsystem_glob_free(
&glob,
NULL );
}
#endif
return( EXIT_FAILURE );
}
/* Creates a (split) RAW filename
* Returns 1 if successful or -1 on error
*/
int libsmraw_filename_create(
libcstring_system_character_t **filename,
size_t *filename_size,
libcstring_system_character_t *basename,
size_t basename_size,
int number_of_segments,
int segment_index,
libcerror_error_t **error )
{
static char *function = "libsmraw_filename_create";
size_t additional_length = 0;
size_t filename_index = 0;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment filename.",
function );
return( -1 );
}
if( *filename != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid segment filename already set.",
function );
return( -1 );
}
if( filename_size == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment filename size.",
function );
return( -1 );
}
if( basename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid basename.",
function );
return( -1 );
}
if( basename_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid basename size value exceeds maximum.",
function );
return( -1 );
}
if( ( number_of_segments < 0 )
|| ( number_of_segments >= 1000 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid number of segments value out of bounds.",
function );
return( -1 );
}
if( number_of_segments > 0 )
{
if( ( segment_index < 0 )
|| ( segment_index > number_of_segments ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid segment index value out of bounds.",
function );
return( -1 );
}
}
if( number_of_segments == 1 )
{
additional_length = 4;
}
else
{
additional_length = 8;
}
*filename_size = basename_size + additional_length;
*filename = libcstring_system_string_allocate(
*filename_size );
if( *filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create segment filename.",
function );
goto on_error;
}
if( libcstring_system_string_copy(
*filename,
basename,
basename_size - 1 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy basename to segment filename.",
function );
goto on_error;
}
filename_index = basename_size - 1;
if( libcstring_system_string_copy(
&( ( *filename )[ filename_index ] ),
_LIBCSTRING_SYSTEM_STRING( ".raw" ),
4 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy extension to segment filename.",
function );
goto on_error;
}
filename_index += 4;
if( number_of_segments != 1 )
{
( *filename )[ filename_index++ ] = (libcstring_system_character_t) '.';
( *filename )[ filename_index++ ] = (libcstring_system_character_t) '0'
+ (libcstring_system_character_t) ( segment_index / 100 );
segment_index %= 100;
( *filename )[ filename_index++ ] = (libcstring_system_character_t) '0'
+ (libcstring_system_character_t) ( segment_index / 10 );
segment_index %= 10;
( *filename )[ filename_index++ ] = (libcstring_system_character_t) '0'
+ (libcstring_system_character_t) segment_index;
}
( *filename )[ filename_index ] = 0;
return( 1 );
on_error:
if( *filename != NULL )
{
memory_free(
*filename );
*filename = NULL;
}
*filename_size = 0;
return( -1 );
}
/* Determines the event log type from the filename
* Returns 1 if successful, 0 if unsupported value or -1 on error
*/
int evtxinput_determine_event_log_type_from_filename(
const libcstring_system_character_t *filename,
int *event_log_type,
libcerror_error_t **error )
{
const libcstring_system_character_t *path_separator = NULL;
static char *function = "evtxinput_determine_event_log_type_from_filename";
size_t filename_length = 0;
int result = 0;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
if( event_log_type == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid event log type.",
function );
return( -1 );
}
filename_length = libcstring_system_string_length(
filename );
path_separator = libcstring_system_string_search_character_reverse(
filename,
(libcstring_system_character_t) LIBCPATH_SEPARATOR,
filename_length );
if( path_separator == NULL )
{
path_separator = filename;
}
else
{
path_separator++;
filename_length = libcstring_system_string_length(
path_separator );
}
if( filename_length == 11 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "System.evtx" ),
11 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SYSTEM;
result = 1;
}
}
else if( filename_length == 13 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Security.evtx" ),
13 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SECURITY;
result = 1;
}
}
else if( filename_length == 16 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Application.evtx" ),
16 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_APPLICATION;
result = 1;
}
}
else if( filename_length == 17 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Media Center.evtx" ),
17 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_MEDIA_CENTER;
result = 1;
}
}
else if( filename_length == 19 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "HardwareEvents.evtx" ),
19 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_HARDWARE_EVENTS;
result = 1;
}
}
else if( filename_length == 20 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "DFS Replication.evtx" ),
20 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_DFS_REPLICATION;
result = 1;
}
}
else if( filename_length == 22 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Internet Explorer.evtx" ),
22 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_INTERNET_EXPLORER;
result = 1;
}
}
else if( filename_length == 27 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Key Management Service.evtx" ),
27 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_KEY_MANAGEMENT_SERVICE;
result = 1;
}
}
return( result );
}
/* Resolves filenames with wildcards (globs)
* Returns the number of results if successful or -1 on error
*/
int libsystem_glob_resolve(
libsystem_glob_t *glob,
libcstring_system_character_t * const patterns[],
int number_of_patterns,
liberror_error_t **error )
{
#if defined( HAVE_IO_H ) || defined( WINAPI )
libsystem_find_data_t find_data;
libcstring_system_character_t find_path[ _MAX_PATH ];
libcstring_system_character_t find_drive[ _MAX_DRIVE ];
libcstring_system_character_t find_directory[ _MAX_DIR ];
libcstring_system_character_t find_name[ _MAX_FNAME ];
libcstring_system_character_t find_extension[ _MAX_EXT ];
intptr_t find_handle = 0;
#endif
static char *function = "libsystem_glob_resolve";
size_t find_path_length = 0;
int globs_found = 0;
int iterator = 0;
if( glob == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid glob.",
function );
return( -1 );
}
for( iterator = 0;
iterator < number_of_patterns;
iterator++ )
{
if( patterns[ iterator ] == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: missing pattern value.",
function );
return( -1 );
}
#if defined( _MSC_VER )
if( libsystem_path_split(
patterns[ iterator ],
find_drive,
_MAX_DRIVE,
find_directory,
_MAX_DIR,
find_name,
_MAX_FNAME,
find_extension,
_MAX_EXT ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to split path.",
function );
return( -1 );
}
#else
libsystem_path_split(
patterns[ iterator ],
find_drive,
_MAX_DRIVE,
find_directory,
_MAX_DIR,
find_name,
_MAX_FNAME,
find_extension,
_MAX_EXT );
#endif
find_handle = libsystem_find_first(
patterns[ iterator ],
&find_data );
if( find_handle != -1 )
{
do
{
if( libsystem_glob_resize(
glob,
glob->number_of_results + 1,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize glob.",
function );
return( -1 );
}
#if defined( _MSC_VER )
if( libsystem_path_make(
find_path,
_MAX_PATH,
find_drive,
find_directory,
find_data.name,
_LIBCSTRING_SYSTEM_STRING( "" ) ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to make path.",
function );
return( -1 );
}
#elif defined( __BORLANDC__ ) && __BORLANDC__ <= 0x0520
libsystem_path_make(
find_path,
_MAX_PATH,
find_drive,
find_directory,
find_data.ff_name,
_LIBCSTRING_SYSTEM_STRING( "" ) );
#else
libsystem_path_make(
find_path,
_MAX_PATH,
find_drive,
find_directory,
find_data.name,
_LIBCSTRING_SYSTEM_STRING( "" ) );
#endif
find_path_length = libcstring_system_string_length(
find_path );
glob->result[ glob->number_of_results - 1 ] = (libcstring_system_character_t *) memory_allocate(
sizeof( libcstring_system_character_t ) * ( find_path_length + 1 ) );
if( glob->result[ glob->number_of_results - 1 ] == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create glob result.",
function );
return( -1 );
}
if( libcstring_system_string_copy(
glob->result[ glob->number_of_results - 1 ],
find_path,
find_path_length ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set glob result.",
function );
memory_free(
glob->result[ glob->number_of_results - 1 ] );
glob->result[ glob->number_of_results - 1 ] = NULL;
return( -1 );
}
( glob->result[ glob->number_of_results - 1 ] )[ find_path_length ] = 0;
globs_found++;
if( globs_found > (int32_t) UINT16_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: too many globs found.",
function );
return( -1 );
}
}
while( libsystem_find_next(
find_handle,
&find_data ) == 0 );
if( errno != ENOENT )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: error finding next file entry.",
function );
return( -1 );
}
if( libsystem_find_close(
find_handle ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: error closing find handle.",
function );
return( -1 );
}
}
else if( errno != ENOENT )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: error finding file entry.",
function );
return( -1 );
}
}
return( 1 );
}
int main( int argc, char * const argv[] )
#endif
{
#if !defined( HAVE_GLOB_H )
libcsystem_glob_t *glob = NULL;
#endif
libcerror_error_t *error = NULL;
libcstring_system_character_t * const *source_filenames = NULL;
libcstring_system_character_t **ewf_filenames = NULL;
libcstring_system_character_t *option_header_codepage = NULL;
libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "ewfdebug" );
libcstring_system_integer_t option = 0;
size_t first_filename_length = 0;
uint8_t verbose = 0;
int number_of_filenames = 0;
int header_codepage = LIBEWF_CODEPAGE_ASCII;
int result = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"ewftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "A:hqvV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 'A':
option_header_codepage = optarg;
break;
case (libcstring_system_integer_t) 'h':
ewfoutput_version_fprint(
stdout,
program );
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'q':
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
ewfoutput_version_fprint(
stdout,
program );
ewfoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Missing EWF image file(s).\n" );
usage_fprint(
stdout );
goto on_error;
}
ewfoutput_version_fprint(
stdout,
program );
libcnotify_verbose_set(
verbose );
#if !defined( HAVE_LOCAL_LIBEWF )
libewf_notify_set_verbose(
verbose );
libewf_notify_set_stream(
stderr,
NULL );
#endif
if( option_header_codepage != NULL )
{
if( ewfinput_determine_header_codepage(
option_header_codepage,
&header_codepage,
&error ) != 1 )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
fprintf(
stderr,
"Unsupported header codepage defaulting to: ascii.\n" );
header_codepage = LIBEWF_CODEPAGE_ASCII;
}
}
if( libcsystem_signal_attach(
ewfdebug_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_initialize(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize glob.\n" );
goto on_error;
}
if( libcsystem_glob_resolve(
glob,
&( argv[ optind ] ),
argc - optind,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to resolve glob.\n" );
goto on_error;
}
if( libcsystem_glob_get_results(
glob,
&number_of_filenames,
(libcstring_system_character_t ***) &source_filenames,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve glob results.\n" );
goto on_error;
}
#else
source_filenames = &( argv[ optind ] );
number_of_filenames = argc - optind;
#endif
if( number_of_filenames == 1 )
{
first_filename_length = libcstring_system_string_length(
source_filenames[ 0 ] );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide(
source_filenames[ 0 ],
first_filename_length,
LIBEWF_FORMAT_UNKNOWN,
&ewf_filenames,
&number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob(
source_filenames[ 0 ],
first_filename_length,
LIBEWF_FORMAT_UNKNOWN,
&ewf_filenames,
&number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to resolve ewf file(s).\n" );
goto on_error;
}
source_filenames = (libcstring_system_character_t * const *) ewf_filenames;
}
if( libewf_handle_initialize(
&ewfdebug_input_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize input handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libewf_handle_open_wide(
ewfdebug_input_handle,
source_filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error );
#else
result = libewf_handle_open(
ewfdebug_input_handle,
source_filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error );
#endif
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_free(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
#endif
if( ewf_filenames != NULL )
{
for( ; number_of_filenames > 0; number_of_filenames-- )
{
memory_free(
ewf_filenames[ number_of_filenames - 1 ] );
}
memory_free(
ewf_filenames );
}
if( ( ewfdebug_abort == 0 )
&& ( result != 1 ) )
{
fprintf(
stderr,
"Unable to open EWF file(s).\n" );
libewf_handle_close(
ewfdebug_input_handle,
NULL );
libewf_handle_free(
&ewfdebug_input_handle,
NULL );
return( EXIT_FAILURE );
}
/* TODO */
if( libewf_handle_close(
ewfdebug_input_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close EWF file(s).\n" );
libewf_handle_free(
&ewfdebug_input_handle,
NULL );
return( EXIT_FAILURE );
}
if( libewf_handle_free(
&ewfdebug_input_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free input handle.\n" );
return( EXIT_FAILURE );
}
if( libcsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( ewfdebug_abort != 0 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n",
program );
return( EXIT_FAILURE );
}
fprintf(
stdout,
"Debug completed.\n" );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
#if !defined( HAVE_GLOB_H )
if( glob != NULL )
{
libcsystem_glob_free(
&glob,
NULL );
}
#endif
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
#if defined( HAVE_GETRLIMIT )
struct rlimit limit_data;
#endif
libcstring_system_character_t acquiry_operating_system[ 32 ];
libcstring_system_character_t * const *argv_filenames = NULL;
libcerror_error_t *error = NULL;
#if !defined( LIBCSYSTEM_HAVE_GLOB )
libcsystem_glob_t *glob = NULL;
#endif
libcstring_system_character_t *acquiry_software_version = NULL;
libcstring_system_character_t *log_filename = NULL;
libcstring_system_character_t *option_header_codepage = NULL;
libcstring_system_character_t *option_process_buffer_size = NULL;
libcstring_system_character_t *option_target_path = NULL;
libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "ewfrecover" );
log_handle_t *log_handle = NULL;
libcstring_system_integer_t option = 0;
uint8_t calculate_md5 = 1;
uint8_t print_status_information = 1;
uint8_t verbose = 0;
int number_of_filenames = 0;
int result = 1;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"ewftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
#if defined( WINAPI ) && !defined( __CYGWIN__ )
#if defined( _MSC_VER )
if( _setmode(
_fileno(
stdout ),
_O_BINARY ) == -1 )
#else
if( setmode(
_fileno(
stdout ),
_O_BINARY ) == -1 )
#endif
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to set stdout to binary mode.\n" );
usage_fprint(
stdout );
goto on_error;
}
#endif
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "A:f:hl:p:qt:uvV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
usage_fprint(
stderr );
goto on_error;
case (libcstring_system_integer_t) 'A':
option_header_codepage = optarg;
break;
case (libcstring_system_integer_t) 'h':
ewfoutput_version_fprint(
stderr,
program );
usage_fprint(
stderr );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'l':
log_filename = optarg;
break;
case (libcstring_system_integer_t) 'p':
option_process_buffer_size = optarg;
break;
case (libcstring_system_integer_t) 'q':
print_status_information = 0;
break;
case (libcstring_system_integer_t) 't':
option_target_path = optarg;
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
ewfoutput_version_fprint(
stderr,
program );
ewfoutput_copyright_fprint(
stderr );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Missing EWF image file(s).\n" );
usage_fprint(
stderr );
goto on_error;
}
ewfoutput_version_fprint(
stderr,
program );
libcnotify_verbose_set(
verbose );
#if !defined( HAVE_LOCAL_LIBEWF )
libewf_notify_set_verbose(
verbose );
libewf_notify_set_stream(
stderr,
NULL );
#endif
#if !defined( LIBCSYSTEM_HAVE_GLOB )
if( libcsystem_glob_initialize(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize glob.\n" );
goto on_error;
}
if( libcsystem_glob_resolve(
glob,
&( argv[ optind ] ),
argc - optind,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to resolve glob.\n" );
goto on_error;
}
argv_filenames = glob->result;
number_of_filenames = glob->number_of_results;
#else
argv_filenames = &( argv[ optind ] );
number_of_filenames = argc - optind;
#endif
if( export_handle_initialize(
&ewfrecover_export_handle,
calculate_md5,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create export handle.\n" );
goto on_error;
}
#if defined( HAVE_GETRLIMIT )
if( getrlimit(
RLIMIT_NOFILE,
&limit_data ) != 0 )
{
fprintf(
stderr,
"Unable to determine limit: number of open file descriptors.\n" );
}
if( limit_data.rlim_max > (rlim_t) INT_MAX )
{
limit_data.rlim_max = (rlim_t) INT_MAX;
}
if( limit_data.rlim_max > 0 )
{
limit_data.rlim_max /= 2;
}
if( export_handle_set_maximum_number_of_open_handles(
ewfrecover_export_handle,
(int) limit_data.rlim_max,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set maximum number of open file handles.\n" );
goto on_error;
}
#endif
if( libcsystem_signal_attach(
ewfrecover_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
result = export_handle_open_input(
ewfrecover_export_handle,
argv_filenames,
number_of_filenames,
&error );
if( ewfrecover_abort != 0 )
{
goto on_abort;
}
if( result != 1 )
{
fprintf(
stderr,
"Unable to open EWF file(s).\n" );
goto on_error;
}
#if !defined( LIBCSYSTEM_HAVE_GLOB )
if( libcsystem_glob_free(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
#endif
result = export_handle_input_is_corrupted(
ewfrecover_export_handle,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine if EWF file(s) are corrupted.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"EWF file(s) are not corrupted.\n" );
goto on_error;
}
ewfrecover_export_handle->output_format = EXPORT_HANDLE_OUTPUT_FORMAT_EWF;
ewfrecover_export_handle->export_size = ewfrecover_export_handle->input_media_size;
if( option_header_codepage != NULL )
{
result = export_handle_set_header_codepage(
ewfrecover_export_handle,
option_header_codepage,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set header codepage.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported header codepage defaulting to: ascii.\n" );
}
}
if( option_target_path != NULL )
{
if( export_handle_set_string(
ewfrecover_export_handle,
option_target_path,
&( ewfrecover_export_handle->target_path ),
&( ewfrecover_export_handle->target_path_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set target path.\n" );
goto on_error;
}
}
else
{
/* Make sure the target filename is set in unattended mode
*/
if( export_handle_set_string(
ewfrecover_export_handle,
_LIBCSTRING_SYSTEM_STRING( "recover" ),
&( ewfrecover_export_handle->target_path ),
&( ewfrecover_export_handle->target_path_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set target filename.\n" );
goto on_error;
}
}
if( option_process_buffer_size != NULL )
{
result = export_handle_set_process_buffer_size(
ewfrecover_export_handle,
option_process_buffer_size,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set process buffer size.\n" );
goto on_error;
}
else if( ( result == 0 )
|| ( ewfrecover_export_handle->process_buffer_size > (size_t) SSIZE_MAX ) )
{
ewfrecover_export_handle->process_buffer_size = 0;
fprintf(
stderr,
"Unsupported process buffer size defaulting to: chunk size.\n" );
}
}
/* Initialize values
*/
if( log_filename != NULL )
{
if( log_handle_initialize(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create log handle.\n" );
goto on_error;
}
if( log_handle_open(
log_handle,
log_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open log file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
log_filename );
goto on_error;
}
}
if( export_handle_open_output(
ewfrecover_export_handle,
ewfrecover_export_handle->target_path,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open output.\n" );
goto on_error;
}
if( platform_get_operating_system(
acquiry_operating_system,
32,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to determine operating system.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
acquiry_operating_system[ 0 ] = 0;
}
acquiry_software_version = _LIBCSTRING_SYSTEM_STRING( LIBEWF_VERSION_STRING );
if( export_handle_set_output_values(
ewfrecover_export_handle,
acquiry_operating_system,
program,
acquiry_software_version,
0,
1,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set output values.\n" );
goto on_error;
}
result = export_handle_export_input(
ewfrecover_export_handle,
0,
print_status_information,
log_handle,
&error );
if( result != 1 )
{
fprintf(
stderr,
"Unable to recover input.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( log_handle != NULL )
{
if( log_handle_close(
log_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close log file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
log_filename );
goto on_error;
}
if( log_handle_free(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free log handle.\n" );
goto on_error;
}
}
on_abort:
if( export_handle_close(
ewfrecover_export_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close export handle.\n" );
goto on_error;
}
if( libcsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( export_handle_free(
&ewfrecover_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free export handle.\n" );
goto on_error;
}
if( ewfrecover_abort != 0 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n",
program );
return( EXIT_FAILURE );
}
if( result != 1 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": FAILURE\n",
program );
return( EXIT_FAILURE );
}
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": SUCCESS\n",
program );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( log_handle != NULL )
{
log_handle_close(
log_handle,
NULL );
log_handle_free(
&log_handle,
NULL );
}
if( ewfrecover_export_handle != NULL )
{
export_handle_close(
ewfrecover_export_handle,
NULL );
export_handle_free(
&ewfrecover_export_handle,
NULL );
}
#if !defined( LIBCSYSTEM_HAVE_GLOB )
if( glob != NULL )
{
libcsystem_glob_free(
&glob,
NULL );
}
#endif
return( EXIT_FAILURE );
}
