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 );
}
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
{
libcerror_error_t *error = NULL;
libewf_handle_t *handle = NULL;
off64_t read_offset = 0;
size64_t media_size = 0;
size64_t read_size = 0;
size32_t chunk_size = 0;
if( argc < 2 )
{
fprintf(
stderr,
"Missing filename(s).\n" );
return( EXIT_FAILURE );
}
#if defined( HAVE_DEBUG_OUTPUT ) && defined( EWF_TEST_READ_VERBOSE )
libewf_notify_set_verbose(
1 );
libewf_notify_set_stream(
stderr,
NULL );
#endif
/* Initialization
*/
if( libewf_handle_initialize(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_open_wide(
handle,
&( argv[ 1 ] ),
argc - 1,
LIBEWF_OPEN_READ,
&error ) != 1 )
#else
if( libewf_handle_open(
handle,
&( argv[ 1 ] ),
argc - 1,
LIBEWF_OPEN_READ,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to open file(s).\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_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read buffer.\n" );
goto on_error;
}
if( ewf_test_read_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read 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_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read buffer.\n" );
goto on_error;
}
if( ewf_test_read_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read 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_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read buffer.\n" );
goto on_error;
}
if( ewf_test_read_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read 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_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
1024 ) != 1 )
{
fprintf(
stderr,
"Unable to test read buffer.\n" );
goto on_error;
}
if( ewf_test_read_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
1024 ) != 1 )
{
fprintf(
stderr,
"Unable to test read 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_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read chunk.\n" );
goto on_error;
}
if( ewf_test_read_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read 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_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
0 ) != 1 )
{
fprintf(
stderr,
"Unable to test read chunk.\n" );
goto on_error;
}
if( ewf_test_read_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
0 ) != 1 )
{
fprintf(
stderr,
"Unable to test read chunk.\n" );
goto on_error;
}
}
else
{
if( ewf_test_read_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read chunk.\n" );
goto on_error;
}
if( ewf_test_read_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read 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_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read chunk.\n" );
goto on_error;
}
if( ewf_test_read_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read 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_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 chunk.\n" );
goto on_error;
}
if( ewf_test_read_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 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( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
wchar_t **filenames = NULL;
#else
char **filenames = NULL;
#endif
libewf_error_t *error = NULL;
int number_of_filenames = 0;
int filename_iterator = 0;
if( argc < 2 )
{
fprintf(
stderr,
"Missing filename(s).\n" );
return( EXIT_FAILURE );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide(
argv[ 1 ],
libcstring_wide_string_length(
argv[ 1 ] ),
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob(
argv[ 1 ],
libcstring_narrow_string_length(
argv[ 1 ] ),
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to glob filenames.\n" );
goto on_error;
}
if( number_of_filenames < 0 )
{
fprintf(
stderr,
"Invalid number of filenames.\n" );
return( EXIT_FAILURE );
}
else if( number_of_filenames == 0 )
{
fprintf(
stderr,
"Missing filenames.\n" );
return( EXIT_FAILURE );
}
for( filename_iterator = 0;
filename_iterator < number_of_filenames;
filename_iterator++ )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
fprintf(
stdout,
"%ls",
filenames[ filename_iterator ] );
#else
fprintf(
stdout,
"%s",
filenames[ filename_iterator ] );
#endif
if( filename_iterator == ( number_of_filenames - 1 ) )
{
fprintf(
stdout,
"\n" );
}
else
{
fprintf(
stdout,
" " );
}
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide_free(
filenames,
number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob_free(
filenames,
number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to free glob.\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 );
}
/* Tests libewf_handle_seek_offset
* Returns 1 if successful, 0 if not or -1 on error
*/
int ewf_test_seek_offset(
libewf_handle_t *handle,
off64_t input_offset,
int input_whence,
off64_t output_offset )
{
const char *whence_string = NULL;
libcerror_error_t *error = NULL;
off64_t result_offset = 0;
int result = 0;
if( handle == NULL )
{
return( -1 );
}
if( input_whence == SEEK_CUR )
{
whence_string = "SEEK_CUR";
}
else if( input_whence == SEEK_END )
{
whence_string = "SEEK_END";
}
else if( input_whence == SEEK_SET )
{
whence_string = "SEEK_SET";
}
else
{
whence_string = "UNKNOWN";
}
fprintf(
stdout,
"Testing seek of offset: %" PRIi64 " and whence: %s\t",
input_offset,
whence_string );
result_offset = libewf_handle_seek_offset(
handle,
input_offset,
input_whence,
&error );
if( result_offset == -1 )
{
libewf_error_backtrace_fprint(
error,
stderr );
libewf_error_free(
&error );
}
if( result_offset == output_offset )
{
result = 1;
}
if( result != 0 )
{
fprintf(
stdout,
"(PASS)" );
}
else
{
fprintf(
stdout,
"(FAIL)" );
}
fprintf(
stdout,
"\n" );
return( result );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t **filenames = NULL;
libewf_error_t *error = NULL;
libewf_handle_t *handle = NULL;
size64_t media_size = 0;
int number_of_filenames = 0;
if( argc < 2 )
{
fprintf(
stderr,
"Missing filename(s).\n" );
return( EXIT_FAILURE );
}
#if defined( HAVE_DEBUG_OUTPUT ) && defined( EWF_TEST_SEEK_VERBOSE )
libewf_notify_set_verbose(
1 );
libewf_notify_set_stream(
stderr,
NULL );
#endif
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide(
argv[ 1 ],
libcstring_wide_string_length(
argv[ 1 ] ),
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob(
argv[ 1 ],
libcstring_narrow_string_length(
argv[ 1 ] ),
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to glob filenames.\n" );
goto on_error;
}
if( number_of_filenames < 0 )
{
fprintf(
stderr,
"Invalid number of filenames.\n" );
goto on_error;
}
else if( number_of_filenames == 0 )
{
fprintf(
stderr,
"Missing filenames.\n" );
goto on_error;
}
/* Initialization
*/
if( libewf_handle_initialize(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_open_wide(
handle,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error ) != 1 )
#else
if( libewf_handle_open(
handle,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to open handle.\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( ewf_handle_test_seek(
handle,
media_size ) != 1 )
{
fprintf(
stderr,
"Unable to seek in handle.\n" );
goto on_error;
}
/* Clean up
*/
if( libewf_handle_close(
handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close handle.\n" );
goto on_error;
}
if( libewf_handle_free(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide_free(
filenames,
number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob_free(
filenames,
number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to free glob.\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 );
}
if( filenames != NULL )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
libewf_glob_wide_free(
filenames,
number_of_filenames,
NULL );
#else
libewf_glob_free(
filenames,
number_of_filenames,
NULL );
#endif
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
{
libewf_error_t *error = NULL;
libewf_handle_t *handle = NULL;
if( argc <= 1 )
{
fprintf(
stderr,
"Usage: ./open_close filename(s)\n" );
return( EXIT_FAILURE );
}
/* The function will return 1 if successful or -1 on error.
* On error the error 'object' is created by the library.
*
* handle must refer to NULL to create a new libewf handle 'object'.
*
* If error is NULL e.g. libewf_handle_initialize( &handle, NULL )
* no error 'object' is created
*
* The error 'object' can be freed by libewf_error_free()
*/
if( libewf_handle_initialize(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize handle.\n" );
goto on_error;
}
if( libewf_handle_open(
handle,
&( argv[ 1 ] ),
argc - 1,
LIBEWF_OPEN_READ,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open file(s).\n" );
goto on_error;
}
if( libewf_handle_close(
handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close handle.\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_free(
&handle,
NULL );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t *option_offset = NULL;
libcstring_system_character_t *option_size = NULL;
libcstring_system_character_t *target_filename = NULL;
libcerror_error_t *error = NULL;
libcstring_system_integer_t option = 0;
off64_t write_offset = 0;
size64_t write_size = 0;
size_t string_length = 0;
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "B:o: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) 'B':
option_size = optarg;
break;
case (libcstring_system_integer_t) 'o':
option_offset = optarg;
break;
case (libcstring_system_integer_t) 't':
target_filename = optarg;
break;
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing EWF image filename(s).\n" );
return( EXIT_FAILURE );
}
if( option_offset != NULL )
{
string_length = libcstring_system_string_length(
option_offset );
if( libcsystem_string_decimal_copy_to_64_bit(
option_offset,
string_length + 1,
(uint64_t *) &write_offset,
&error ) != 1 )
{
fprintf(
stderr,
"Unsupported write offset.\n" );
goto on_error;
}
}
if( option_size != NULL )
{
string_length = libcstring_system_string_length(
option_size );
if( libcsystem_string_decimal_copy_to_64_bit(
option_size,
string_length + 1,
&write_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unsupported write size.\n" );
goto on_error;
}
}
if( ewf_test_read_write_delta(
&( argv[ optind ] ),
argc - optind,
target_filename,
write_offset,
write_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to test read/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 );
}
