int main( int argc, char * const argv[] )
#endif
{
libcerror_error_t *error = NULL;
log_handle_t *log_handle = NULL;
system_character_t *option_ascii_codepage = NULL;
system_character_t *log_filename = NULL;
system_character_t *source = NULL;
char *program = "regfexport";
size_t source_length = 0;
system_integer_t option = 0;
int result = 0;
int verbose = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"regftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( regftools_output_initialize(
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize output settings.\n" );
goto on_error;
}
regftools_output_version_fprint(
stdout,
program );
while( ( option = regftools_getopt(
argc,
argv,
_SYSTEM_STRING( "c:hl:vV" ) ) ) != (system_integer_t) -1 )
{
switch( option )
{
case (system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (system_integer_t) 'c':
option_ascii_codepage = optarg;
break;
case (system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (system_integer_t) 'l':
log_filename = optarg;
break;
case (system_integer_t) 'v':
verbose = 1;
break;
case (system_integer_t) 'V':
regftools_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_verbose_set(
verbose );
libregf_notify_set_stream(
stderr,
NULL );
libregf_notify_set_verbose(
verbose );
if( log_handle_initialize(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize log handle.\n" );
goto on_error;
}
if( export_handle_initialize(
®fexport_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize export handle.\n" );
goto on_error;
}
if( log_handle_open(
log_handle,
log_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open log file: %" PRIs_SYSTEM ".\n",
log_filename );
goto on_error;
}
if( option_ascii_codepage != NULL )
{
result = export_handle_set_ascii_codepage(
regfexport_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" );
}
}
if( export_handle_open_input(
regfexport_export_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open: %" PRIs_SYSTEM ".\n",
source );
goto on_error;
}
if( export_handle_export_file(
regfexport_export_handle,
log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to export file.\n" );
goto on_error;
}
if( export_handle_close_input(
regfexport_export_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close export handle.\n" );
goto on_error;
}
if( export_handle_free(
®fexport_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 handle.\n" );
goto on_error;
}
if( log_handle_free(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free log handle.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( regfexport_export_handle != NULL )
{
export_handle_free(
®fexport_export_handle,
NULL );
}
if( log_handle != NULL )
{
log_handle_free(
&log_handle,
NULL );
}
return( EXIT_FAILURE );
}
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 );
}
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 );
}
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 );
}
int main( int argc, char * const argv[] )
#endif
{
libcerror_error_t *error = NULL;
log_handle_t *log_handle = NULL;
system_character_t *option_ascii_codepage = NULL;
system_character_t *option_event_log_type = NULL;
system_character_t *option_export_format = NULL;
system_character_t *option_export_mode = NULL;
system_character_t *option_log_filename = NULL;
system_character_t *option_resource_files_path = NULL;
system_character_t *option_preferred_language = NULL;
system_character_t *option_registry_directory_name = NULL;
system_character_t *option_software_registry_filename = NULL;
system_character_t *option_system_registry_filename = NULL;
system_character_t *source = NULL;
char *program = "evtxexport";
system_integer_t option = 0;
int result = 0;
int use_template_definition = 0;
int verbose = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"evtxtools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( evtxtools_output_initialize(
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize output settings.\n" );
goto on_error;
}
evtxoutput_version_fprint(
stdout,
program );
while( ( option = evtxtools_getopt(
argc,
argv,
_SYSTEM_STRING( "c:f:hl:m:p:r:s:S:t:TvV" ) ) ) != (system_integer_t) -1 )
{
switch( option )
{
case (system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (system_integer_t) 'c':
option_ascii_codepage = optarg;
break;
case (system_integer_t) 'f':
option_export_format = optarg;
break;
case (system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (system_integer_t) 'l':
option_log_filename = optarg;
break;
case (system_integer_t) 'm':
option_export_mode = optarg;
break;
case (system_integer_t) 'p':
option_resource_files_path = optarg;
break;
case (system_integer_t) 'r':
option_registry_directory_name = optarg;
break;
case (system_integer_t) 's':
option_system_registry_filename = optarg;
break;
case (system_integer_t) 'S':
option_software_registry_filename = optarg;
break;
case (system_integer_t) 't':
option_event_log_type = optarg;
break;
case (system_integer_t) 'T':
use_template_definition = 1;
break;
case (system_integer_t) 'v':
verbose = 1;
break;
case (system_integer_t) 'V':
evtxoutput_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 );
libevtx_notify_set_stream(
stderr,
NULL );
libevtx_notify_set_verbose(
verbose );
if( log_handle_initialize(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize log handle.\n" );
goto on_error;
}
if( export_handle_initialize(
&evtxexport_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize export handle.\n" );
goto on_error;
}
if( option_ascii_codepage != NULL )
{
result = export_handle_set_ascii_codepage(
evtxexport_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" );
}
}
if( option_event_log_type != NULL )
{
result = export_handle_set_event_log_type(
evtxexport_export_handle,
option_event_log_type,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set event log type in export handle.\n" );
goto on_error;
}
}
if( option_export_format != NULL )
{
result = export_handle_set_export_format(
evtxexport_export_handle,
option_export_format,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set export format.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported export format defaulting to: text.\n" );
}
}
if( option_export_mode != NULL )
{
result = export_handle_set_export_mode(
evtxexport_export_handle,
option_export_mode,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set export mode.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported export mode defaulting to: items.\n" );
}
}
if( ( option_event_log_type == NULL )
|| ( result == 0 ) )
{
result = export_handle_set_event_log_type_from_filename(
evtxexport_export_handle,
source,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set event log type from filename in export handle.\n" );
goto on_error;
}
}
if( option_resource_files_path != NULL )
{
if( export_handle_set_resource_files_path(
evtxexport_export_handle,
option_resource_files_path,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set resource files path in export handle.\n" );
goto on_error;
}
}
if( option_software_registry_filename != NULL )
{
if( export_handle_set_software_registry_filename(
evtxexport_export_handle,
option_software_registry_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set software registry filename in export handle.\n" );
goto on_error;
}
}
if( option_system_registry_filename != NULL )
{
if( export_handle_set_system_registry_filename(
evtxexport_export_handle,
option_system_registry_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set system registry filename in export handle.\n" );
goto on_error;
}
}
if( option_registry_directory_name != NULL )
{
if( export_handle_set_registry_directory_name(
evtxexport_export_handle,
option_registry_directory_name,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set registry directory name in export handle.\n" );
goto on_error;
}
}
if( option_preferred_language != NULL )
{
/* TODO set preferred language identifier from input */
if( export_handle_set_preferred_language_identifier(
evtxexport_export_handle,
0x0409,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set preferred language identifier in export handle.\n" );
goto on_error;
}
}
evtxexport_export_handle->use_template_definition = use_template_definition;
evtxexport_export_handle->verbose = verbose;
if( log_handle_open(
log_handle,
option_log_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open log file: %" PRIs_SYSTEM ".\n",
option_log_filename );
goto on_error;
}
if( export_handle_open_input(
evtxexport_export_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open: %" PRIs_SYSTEM ".\n",
source );
goto on_error;
}
result = export_handle_export_file(
evtxexport_export_handle,
log_handle,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to export file.\n" );
goto on_error;
}
if( export_handle_close_input(
evtxexport_export_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close export handle.\n" );
goto on_error;
}
if( export_handle_free(
&evtxexport_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 handle.\n" );
goto on_error;
}
if( log_handle_free(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free log handle.\n" );
goto on_error;
}
if( result == 0 )
{
fprintf(
stdout,
"No records to export.\n" );
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( evtxexport_export_handle != NULL )
{
export_handle_free(
&evtxexport_export_handle,
NULL );
}
if( log_handle != NULL )
{
log_handle_free(
&log_handle,
NULL );
}
return( EXIT_FAILURE );
}
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 *log_filename = NULL;
libcstring_system_character_t *option_additional_digest_types = NULL;
libcstring_system_character_t *option_bytes_per_sector = NULL;
libcstring_system_character_t *option_case_number = NULL;
libcstring_system_character_t *option_compression_values = NULL;
libcstring_system_character_t *option_description = NULL;
libcstring_system_character_t *option_examiner_name = NULL;
libcstring_system_character_t *option_evidence_number = 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_media_flags = NULL;
libcstring_system_character_t *option_media_type = NULL;
libcstring_system_character_t *option_notes = NULL;
libcstring_system_character_t *option_offset = NULL;
libcstring_system_character_t *option_process_buffer_size = NULL;
libcstring_system_character_t *option_secondary_target_filename = 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( "ewfacquirestream" );
log_handle_t *log_handle = NULL;
libcstring_system_integer_t option = 0;
size_t string_length = 0;
uint8_t calculate_md5 = 1;
uint8_t print_status_information = 1;
uint8_t read_error_retries = 2;
uint8_t resume_acquiry = 0;
uint8_t swap_byte_pairs = 0;
uint8_t use_chunk_data_functions = 0;
uint8_t verbose = 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 )
{
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
#if defined( WINAPI ) && !defined( __CYGWIN__ )
#if defined( _MSC_VER )
if( _setmode(
_fileno(
stdin ),
_O_BINARY ) == -1 )
#else
if( setmode(
_fileno(
stdin ),
_O_BINARY ) == -1 )
#endif
{
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Unable to set stdin to binary mode.\n" );
usage_fprint(
stdout );
goto on_error;
}
#endif
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "A:b:B:c:C:d:D:e:E:f:hl:m:M:N:o:p:P:qsS:t:vVx2:" ) ) ) != (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 );
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_values = optarg;
break;
case (libcstring_system_integer_t) 'C':
option_case_number = optarg;
break;
case (libcstring_system_integer_t) 'd':
option_additional_digest_types = optarg;
break;
case (libcstring_system_integer_t) 'D':
option_description = optarg;
break;
case (libcstring_system_integer_t) 'e':
option_examiner_name = optarg;
break;
case (libcstring_system_integer_t) 'E':
option_evidence_number = optarg;
break;
case (libcstring_system_integer_t) 'f':
option_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) 'l':
log_filename = optarg;
break;
case (libcstring_system_integer_t) 'm':
option_media_type = optarg;
break;
case (libcstring_system_integer_t) 'M':
option_media_flags = optarg;
break;
case (libcstring_system_integer_t) 'N':
option_notes = 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) 'P':
option_bytes_per_sector = 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) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
ewfoutput_version_fprint(
stdout,
program );
ewfoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'x':
use_chunk_data_functions = 1;
break;
case (libcstring_system_integer_t) '2':
option_secondary_target_filename = optarg;
break;
}
}
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_target_filename != NULL )
&& ( option_secondary_target_filename != NULL ) )
{
string_length = libcstring_system_string_length(
option_secondary_target_filename );
if( libcstring_system_string_length(
option_target_filename ) == string_length )
{
if( libcstring_system_string_compare(
option_target_filename,
option_secondary_target_filename,
string_length ) == 0 )
{
fprintf(
stderr,
"Primary and secondary target cannot be the same.\n" );
goto on_error;
}
}
}
if( imaging_handle_initialize(
&ewfacquirestream_imaging_handle,
calculate_md5,
use_chunk_data_functions,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create imaging handle.\n" );
goto on_error;
}
if( option_header_codepage != NULL )
{
result = imaging_handle_set_header_codepage(
ewfacquirestream_imaging_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( imaging_handle_set_string(
ewfacquirestream_imaging_handle,
option_target_filename,
&( ewfacquirestream_imaging_handle->target_filename ),
&( ewfacquirestream_imaging_handle->target_filename_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set target filename.\n" );
goto on_error;
}
}
else
{
/* Make sure the target filename is set
*/
if( imaging_handle_set_string(
ewfacquirestream_imaging_handle,
_LIBCSTRING_SYSTEM_STRING( "image" ),
&( ewfacquirestream_imaging_handle->target_filename ),
&( ewfacquirestream_imaging_handle->target_filename_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set target filename.\n" );
goto on_error;
}
}
if( option_secondary_target_filename != NULL )
{
if( imaging_handle_set_string(
ewfacquirestream_imaging_handle,
option_secondary_target_filename,
&( ewfacquirestream_imaging_handle->secondary_target_filename ),
&( ewfacquirestream_imaging_handle->secondary_target_filename_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set secondary target filename.\n" );
goto on_error;
}
}
if( option_case_number == NULL )
{
option_case_number = _LIBCSTRING_SYSTEM_STRING( "case_number" );
}
if( imaging_handle_set_string(
ewfacquirestream_imaging_handle,
option_case_number,
&( ewfacquirestream_imaging_handle->case_number ),
&( ewfacquirestream_imaging_handle->case_number_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set case number.\n" );
goto on_error;
}
if( option_description == NULL )
{
option_description = _LIBCSTRING_SYSTEM_STRING( "description" );
}
if( imaging_handle_set_string(
ewfacquirestream_imaging_handle,
option_description,
&( ewfacquirestream_imaging_handle->description ),
&( ewfacquirestream_imaging_handle->description_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set description.\n" );
goto on_error;
}
if( option_evidence_number == NULL )
{
option_evidence_number = _LIBCSTRING_SYSTEM_STRING( "evidence_number" );
}
if( imaging_handle_set_string(
ewfacquirestream_imaging_handle,
option_evidence_number,
&( ewfacquirestream_imaging_handle->evidence_number ),
&( ewfacquirestream_imaging_handle->evidence_number_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set evidence number.\n" );
goto on_error;
}
if( option_examiner_name == NULL )
{
option_examiner_name = _LIBCSTRING_SYSTEM_STRING( "examiner_name" );
}
if( imaging_handle_set_string(
ewfacquirestream_imaging_handle,
option_examiner_name,
&( ewfacquirestream_imaging_handle->examiner_name ),
&( ewfacquirestream_imaging_handle->examiner_name_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set examiner name.\n" );
goto on_error;
}
if( option_notes == NULL )
{
option_notes = _LIBCSTRING_SYSTEM_STRING( "notes" );
}
if( imaging_handle_set_string(
ewfacquirestream_imaging_handle,
option_notes,
&( ewfacquirestream_imaging_handle->notes ),
&( ewfacquirestream_imaging_handle->notes_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set notes.\n" );
goto on_error;
}
if( option_format != NULL )
{
result = imaging_handle_set_format(
ewfacquirestream_imaging_handle,
option_format,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set format.\n" );
goto on_error;
}
else if( ( result == 0 )
|| ( ewfacquirestream_imaging_handle->ewf_format == LIBEWF_FORMAT_EWF )
|| ( ewfacquirestream_imaging_handle->ewf_format == LIBEWF_FORMAT_ENCASE1 )
|| ( ewfacquirestream_imaging_handle->ewf_format == LIBEWF_FORMAT_SMART ) )
{
ewfacquirestream_imaging_handle->ewf_format = LIBEWF_FORMAT_ENCASE6;
fprintf(
stderr,
"Unsupported EWF format defaulting to: encase6.\n" );
}
}
if( option_compression_values != NULL )
{
result = imaging_handle_set_compression_values(
ewfacquirestream_imaging_handle,
option_compression_values,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set compression values.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported compression values defaulting to method: deflate with level: none.\n" );
}
}
if( option_media_type != NULL )
{
result = imaging_handle_set_media_type(
ewfacquirestream_imaging_handle,
option_media_type,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set media type.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported media type defaulting to: fixed.\n" );
}
}
if( option_media_flags != NULL )
{
result = imaging_handle_set_media_flags(
ewfacquirestream_imaging_handle,
option_media_flags,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set media flags.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported media flags defaulting to: physical.\n" );
}
}
if( option_bytes_per_sector != NULL )
{
result = imaging_handle_set_bytes_per_sector(
ewfacquirestream_imaging_handle,
option_bytes_per_sector,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set bytes per sector.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported bytes per sector defaulting to: %" PRIu32 ".\n",
ewfacquirestream_imaging_handle->bytes_per_sector );
}
}
if( option_sectors_per_chunk != NULL )
{
result = imaging_handle_set_sectors_per_chunk(
ewfacquirestream_imaging_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: %" PRIu32 ".\n",
ewfacquirestream_imaging_handle->sectors_per_chunk );
}
}
if( option_maximum_segment_size != NULL )
{
result = imaging_handle_set_maximum_segment_size(
ewfacquirestream_imaging_handle,
option_maximum_segment_size,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set maximum segment size.\n" );
goto on_error;
}
else if( result == 0 )
{
ewfacquirestream_imaging_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE;
fprintf(
stderr,
"Unsupported maximum segment size defaulting to: %" PRIu64 ".\n",
ewfacquirestream_imaging_handle->maximum_segment_size );
}
}
if( option_offset != NULL )
{
result = imaging_handle_set_acquiry_offset(
ewfacquirestream_imaging_handle,
option_offset,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set acquiry offset.\n" );
goto on_error;
}
else if( result == 0 )
{
ewfacquirestream_imaging_handle->acquiry_offset = 0;
fprintf(
stderr,
"Unsupported acquiry offset defaulting to: 0.\n" );
}
}
if( option_size != NULL )
{
result = imaging_handle_set_acquiry_size(
ewfacquirestream_imaging_handle,
option_size,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set acquiry size.\n" );
goto on_error;
}
else if( result == 0 )
{
ewfacquirestream_imaging_handle->acquiry_size = 0;
fprintf(
stderr,
"Unsupported acquiry size defaulting to: all bytes.\n" );
}
}
if( option_process_buffer_size != NULL )
{
result = imaging_handle_set_process_buffer_size(
ewfacquirestream_imaging_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 )
{
fprintf(
stderr,
"Unsupported process buffer size defaulting to: chunk size.\n" );
}
}
if( option_additional_digest_types != NULL )
{
result = imaging_handle_set_additional_digest_types(
ewfacquirestream_imaging_handle,
option_additional_digest_types,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set additional digest types.\n" );
goto on_error;
}
}
fprintf(
stdout,
"Using the following acquiry parameters:\n" );
if( imaging_handle_print_parameters(
ewfacquirestream_imaging_handle,
0,
read_error_retries,
0,
0,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print acquiry parameters.\n" );
goto on_error;
}
if( imaging_handle_open_output(
ewfacquirestream_imaging_handle,
ewfacquirestream_imaging_handle->target_filename,
resume_acquiry,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open output.\n" );
goto on_error;
}
if( ewfacquirestream_imaging_handle->secondary_target_filename != NULL )
{
if( imaging_handle_open_secondary_output(
ewfacquirestream_imaging_handle,
ewfacquirestream_imaging_handle->secondary_target_filename,
resume_acquiry,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open secondary output.\n" );
goto on_error;
}
}
if( imaging_handle_set_output_values(
ewfacquirestream_imaging_handle,
program,
_LIBCSTRING_SYSTEM_STRING( LIBEWF_VERSION_STRING ),
NULL,
NULL,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize output settings.\n" );
goto on_error;
}
if( libcsystem_signal_attach(
ewfacquirestream_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&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;
}
}
result = ewfacquirestream_read_input(
ewfacquirestream_imaging_handle,
0,
swap_byte_pairs,
read_error_retries,
print_status_information,
use_chunk_data_functions,
log_handle,
&error );
if( result != 1 )
{
fprintf(
stderr,
"Unable to read 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;
}
}
if( libcsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( imaging_handle_close(
ewfacquirestream_imaging_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close output.\n" );
goto on_error;
}
if( imaging_handle_free(
&ewfacquirestream_imaging_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free imaging handle.\n" );
goto on_error;
}
if( ewfacquirestream_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( ewfacquirestream_imaging_handle != NULL )
{
imaging_handle_close(
ewfacquirestream_imaging_handle,
NULL );
imaging_handle_free(
&ewfacquirestream_imaging_handle,
NULL );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t *log_filename = NULL;
libcstring_system_character_t *option_ascii_codepage = NULL;
libcstring_system_character_t *option_export_mode = NULL;
libcstring_system_character_t *option_table_name = NULL;
libcstring_system_character_t *option_target_path = NULL;
libcstring_system_character_t *path_separator = NULL;
libcstring_system_character_t *source = NULL;
liberror_error_t *error = NULL;
log_handle_t *log_handle = NULL;
char *program = "esedbexport";
size_t source_length = 0;
size_t option_table_name_length = 0;
libcstring_system_integer_t option = 0;
int result = 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( "c:hl:m:t: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) 'm':
option_export_mode = optarg;
break;
case (libcstring_system_integer_t) 't':
option_target_path = optarg;
break;
case (libcstring_system_integer_t) 'T':
option_table_name = optarg;
break;
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 ];
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) LIBSYSTEM_PATH_SEPARATOR,
source_length );
if( path_separator == NULL )
{
path_separator = source;
}
else
{
path_separator++;
}
option_target_path = path_separator;
}
if( option_table_name != NULL )
{
option_table_name_length = libcstring_system_string_length(
option_table_name );
}
libsystem_notify_set_verbose(
verbose );
libesedb_notify_set_stream(
stderr,
NULL );
libesedb_notify_set_verbose(
verbose );
if( log_handle_initialize(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize log handle.\n" );
goto on_error;
}
if( export_handle_initialize(
&esedbexport_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize export handle.\n" );
goto on_error;
}
/* TODO
esedbexport_export_handle->print_status_information = print_status_information;
*/
if( option_export_mode != NULL )
{
result = export_handle_set_export_mode(
esedbexport_export_handle,
option_export_mode,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set export mode.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported export mode defaulting to: tables.\n" );
}
}
if( option_ascii_codepage != NULL )
{
result = export_handle_set_ascii_codepage(
esedbexport_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" );
}
}
if( export_handle_set_target_path(
esedbexport_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(
esedbexport_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",
esedbexport_export_handle->items_export_path );
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;
}
fprintf(
stdout,
"Opening file.\n" );
#ifdef TODO_SIGNAL_ABORT
if( libsystem_signal_attach(
esedbexport_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
#endif
if( export_handle_open(
esedbexport_export_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open: %" PRIs_LIBCSTRING_SYSTEM ".\n",
source );
goto on_error;
}
/* TODO
fprintf(
stdout,
"Exporting aliases.\n" );
*/
result = export_handle_export_file(
esedbexport_export_handle,
option_table_name,
option_table_name_length,
log_handle,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to export file.\n" );
goto on_error;
}
#ifdef TODO_SIGNAL_ABORT
if( libsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
#endif
if( export_handle_close(
esedbexport_export_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close export handle.\n" );
goto on_error;
}
if( export_handle_free(
&esedbexport_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 handle.\n" );
goto on_error;
}
if( log_handle_free(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free log handle.\n" );
goto on_error;
}
if( esedbexport_abort != 0 )
{
fprintf(
stdout,
"Export aborted.\n" );
return( EXIT_FAILURE );
}
/* TODO export FAILED ? */
fprintf(
stdout,
"Export completed.\n" );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
if( esedbexport_export_handle != NULL )
{
export_handle_free(
&esedbexport_export_handle,
NULL );
}
if( log_handle != NULL )
{
log_handle_free(
&log_handle,
NULL );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
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_export_mode = NULL;
libcstring_system_character_t *option_preferred_export_format = NULL;
libcstring_system_character_t *option_target_path = NULL;
libcstring_system_character_t *path_separator = NULL;
libcstring_system_character_t *source = NULL;
char *program = "pffexport";
size_t source_length = 0;
libcstring_system_integer_t option = 0;
uint8_t dump_item_values = 0;
uint8_t print_status_information = 1;
int result = 0;
int verbose = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"pfftools",
&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;
}
pffoutput_version_fprint(
stdout,
program );
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "c:df:hl:m:qt: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) 'd':
dump_item_values = 1;
break;
case (libcstring_system_integer_t) 'f':
option_preferred_export_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) 'm':
option_export_mode = 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':
pffoutput_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 );
libpff_notify_set_stream(
stderr,
NULL );
libpff_notify_set_verbose(
verbose );
if( export_handle_initialize(
&pffexport_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create export handle.\n" );
goto on_error;
}
pffexport_export_handle->print_status_information = print_status_information;
if( option_export_mode != NULL )
{
result = export_handle_set_export_mode(
pffexport_export_handle,
option_export_mode,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set export mode.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported export mode defaulting to: items.\n" );
}
}
pffexport_export_handle->dump_item_values = dump_item_values;
if( option_preferred_export_format != NULL )
{
result = export_handle_set_preferred_export_format(
pffexport_export_handle,
option_preferred_export_format,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set preferred export format.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported preferred export format defaulting to: text.\n" );
}
}
if( option_ascii_codepage != NULL )
{
result = export_handle_set_ascii_codepage(
pffexport_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" );
}
}
if( export_handle_set_target_path(
pffexport_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(
pffexport_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",
pffexport_export_handle->items_export_path );
goto on_error;
}
result = export_handle_create_orphans_export_path(
pffexport_export_handle,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to create orphans export path.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"%" PRIs_LIBCSTRING_SYSTEM " already exists.\n",
pffexport_export_handle->orphans_export_path );
goto on_error;
}
result = export_handle_create_recovered_export_path(
pffexport_export_handle,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to create recovered export path.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"%" PRIs_LIBCSTRING_SYSTEM " already exists.\n",
pffexport_export_handle->recovered_export_path );
goto on_error;
}
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( libpff_file_initialize(
&pffexport_file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create file.\n" );
goto on_error;
}
if( libpff_file_set_ascii_codepage(
pffexport_file,
pffexport_export_handle->ascii_codepage,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set ASCII codepage.\n" );
goto on_error;
}
if( libcsystem_signal_attach(
pffexport_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
goto on_error;
}
fprintf(
stdout,
"Opening file.\n" );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libpff_file_open_wide(
pffexport_file,
source,
LIBPFF_OPEN_READ,
&error ) != 1 )
#else
if( libpff_file_open(
pffexport_file,
source,
LIBPFF_OPEN_READ,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Error opening file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
source );
goto on_error;
}
if( export_handle_export_file(
pffexport_export_handle,
pffexport_file,
log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to export file.\n" );
goto on_error;
}
if( libpff_file_close(
pffexport_file,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close file.\n" );
goto on_error;
}
if( libcsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
goto on_error;
}
if( libpff_file_free(
&pffexport_file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free file.\n" );
goto on_error;
}
if( log_handle_close(
log_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close log file.\n" );
goto on_error;
}
if( log_handle_free(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free log handle.\n" );
goto on_error;
}
if( export_handle_free(
&pffexport_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free export handle.\n" );
goto on_error;
}
if( pffexport_abort != 0 )
{
fprintf(
stdout,
"Export aborted.\n" );
return( EXIT_FAILURE );
}
fprintf(
stdout,
"Export completed.\n" );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( pffexport_file != NULL )
{
libpff_file_close(
pffexport_file,
NULL );
libpff_file_free(
&pffexport_file,
NULL );
}
if( log_handle != NULL )
{
log_handle_close(
log_handle,
NULL );
log_handle_free(
&log_handle,
NULL );
}
if( pffexport_export_handle != NULL )
{
export_handle_free(
&pffexport_export_handle,
NULL );
}
return( EXIT_FAILURE );
}
