/* Sets the password
* Returns 1 if successful or -1 on error
*/
int mount_handle_set_password(
mount_handle_t *mount_handle,
const libcstring_system_character_t *string,
libcerror_error_t **error )
{
static char *function = "mount_handle_set_password";
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
if( string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid string.",
function );
return( -1 );
}
mount_handle->password = string;
mount_handle->password_length = libcstring_system_string_length(
mount_handle->password );
return( 1 );
}
/* Sets the ascii codepage
* Returns 1 if successful or -1 on error
*/
int info_handle_set_ascii_codepage(
info_handle_t *info_handle,
const libcstring_system_character_t *string,
libcerror_error_t **error )
{
static char *function = "info_handle_set_ascii_codepage";
size_t string_length = 0;
uint32_t feature_flags = 0;
int result = 0;
if( info_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid info handle.",
function );
return( -1 );
}
feature_flags = LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_KOI8
| LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_WINDOWS;
string_length = libcstring_system_string_length(
string );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libclocale_codepage_copy_from_string_wide(
&( info_handle->ascii_codepage ),
string,
string_length,
feature_flags,
error );
#else
result = libclocale_codepage_copy_from_string(
&( info_handle->ascii_codepage ),
string,
string_length,
feature_flags,
error );
#endif
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine ASCII codepage.",
function );
return( -1 );
}
return( result );
}
/* Retrieves a descriptive string of the error number
* This function uses the POSIX strerror function or equivalent
* Returns the string_length if successful or -1 on error
*/
int libcerror_system_copy_string_from_error_number(
libcstring_system_character_t *string,
size_t string_size,
uint32_t error_number )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
const wchar_t *static_error_string = NULL;
#else
const char *static_error_string = NULL;
#endif
size_t static_error_string_length = 0;
if( string == NULL )
{
return( -1 );
}
if( string_size > (size_t) INT_MAX )
{
return( -1 );
}
/* Sanity check
*/
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) && !defined( WINAPI )
#error Missing wide character strerror function
#endif
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
static_error_string = _wcserror(
(int) error_number );
#else
static_error_string = strerror(
(int) error_number );
#endif
if( static_error_string == NULL )
{
return( -1 );
}
static_error_string_length = libcstring_system_string_length(
static_error_string );
if( libcstring_system_string_copy(
string,
static_error_string,
static_error_string_length ) == NULL )
{
return( -1 );
}
string[ static_error_string_length ] = 0;
return( (int) static_error_string_length );
}
/* Sets the format
* Returns 1 if successful, 0 if unsupported value or -1 on error
*/
int mount_handle_set_format(
mount_handle_t *mount_handle,
const libcstring_system_character_t *string,
libcerror_error_t **error )
{
static char *function = "mount_handle_set_format";
size_t string_length = 0;
int result = 0;
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
string_length = libcstring_system_string_length(
string );
if( string_length == 3 )
{
if( libcstring_system_string_compare(
string,
_LIBCSTRING_SYSTEM_STRING( "raw" ),
3 ) == 0 )
{
mount_handle->input_format = MOUNT_HANDLE_INPUT_FORMAT_RAW;
result = 1;
}
}
else if( string_length == 5 )
{
if( libcstring_system_string_compare(
string,
_LIBCSTRING_SYSTEM_STRING( "files" ),
5 ) == 0 )
{
mount_handle->input_format = MOUNT_HANDLE_INPUT_FORMAT_FILES;
result = 1;
}
}
return( result );
}
/* Sets the volume offset
* Returns 1 if successful or -1 on error
*/
int info_handle_set_volume_offset(
info_handle_t *info_handle,
const libcstring_system_character_t *string,
libcerror_error_t **error )
{
static char *function = "info_handle_set_volume_offset";
size_t string_length = 0;
uint64_t value_64bit = 0;
if( info_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid info handle.",
function );
return( -1 );
}
string_length = libcstring_system_string_length(
string );
if( libcsystem_string_decimal_copy_to_64_bit(
string,
string_length + 1,
&value_64bit,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy string to 64-bit decimal.",
function );
return( -1 );
}
info_handle->volume_offset = (off64_t) value_64bit;
return( 1 );
}
/* Retrieves a descriptive string of the error number
* This function uses the POSIX strerror_r function or equivalent
* Returns the string_length if successful or -1 on error
*/
int libcerror_system_copy_string_from_error_number(
libcstring_system_character_t *string,
size_t string_size,
uint32_t error_number )
{
size_t string_length = 0;
if( string == NULL )
{
return( -1 );
}
if( string_size > (size_t) INT_MAX )
{
return( -1 );
}
/* Sanity check
*/
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
#error Missing wide character strerror_r function
#endif
#if defined( STRERROR_R_CHAR_P )
if( strerror_r(
(int) error_number,
string,
string_size ) == NULL )
#else
if( strerror_r(
(int) error_number,
string,
string_size ) != 0 )
#endif
{
return( -1 );
}
string[ string_size - 1 ] = (libcstring_system_character_t) 0;
string_length = libcstring_system_string_length(
string );
return( (int) string_length );
}
/* Retrieves a descriptive string of the error number
* This function uses the Visual Studio C runtime library functions
* Returns the string_length if successful or -1 on error
*/
int libcerror_system_copy_string_from_error_number(
libcstring_system_character_t *string,
size_t string_size,
uint32_t error_number )
{
size_t string_length = 0;
if( string == NULL )
{
return( -1 );
}
if( string_size > (size_t) INT_MAX )
{
return( -1 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( _wcserror_s(
string,
string_size,
(int) error_number ) != 0 )
#else
if( strerror_s(
string,
string_size,
(int) error_number ) != 0 )
#endif
{
return( -1 );
}
string[ string_size - 1 ] = 0;
string_length = libcstring_system_string_length(
string );
return( (int) string_length );
}
/* Sets the volume key data
* Returns 1 if successful or -1 on error
*/
int wipekey_handle_set_volume_key_data(
wipekey_handle_t *wipekey_handle,
const libcstring_system_character_t *string,
libcerror_error_t **error )
{
static char *function = "wipekey_handle_set_volume_key_data";
size_t string_length = 0;
uint32_t base16_variant = 0;
if( wipekey_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid wipekey handle.",
function );
return( -1 );
}
string_length = libcstring_system_string_length(
string );
if( memory_set(
wipekey_handle->volume_key_data,
0,
16 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear volume key data.",
function );
goto on_error;
}
base16_variant = LIBUNA_BASE16_VARIANT_RFC4648;
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( _BYTE_STREAM_HOST_IS_ENDIAN_BIG )
{
base16_variant |= LIBUNA_BASE16_VARIANT_ENCODING_UTF16_BIG_ENDIAN;
}
else
{
base16_variant |= LIBUNA_BASE16_VARIANT_ENCODING_UTF16_LITTLE_ENDIAN;
}
#endif
if( string_length != 32 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported string length.",
function );
goto on_error;
}
if( libuna_base16_stream_copy_to_byte_stream(
(uint8_t *) string,
string_length,
wipekey_handle->volume_key_data,
16,
base16_variant,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy volume key data.",
function );
goto on_error;
}
return( 1 );
on_error:
memory_set(
wipekey_handle->volume_key_data,
0,
16 );
return( -1 );
}
/* Retrieves a descriptive string of the error number
* Returns 1 if successful or -1 on error
*/
int libsmdev_error_string_copy_from_error_number(
libcstring_system_character_t *string,
size_t string_size,
int error_number,
liberror_error_t **error )
{
static char *function = "libsmdev_error_string_copy_from_error_number";
#if ( defined( HAVE_STRERROR ) && !defined( HAVE_STRERROR_R ) && !defined( WINAPI ) ) || ( defined( WINAPI ) && defined( USE_CRT_FUNCTIONS ) && !defined( _MSC_VER ) )
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
const wchar_t *static_error_string = NULL;
#else
const char *static_error_string = NULL;
#endif
size_t static_error_string_length = 0;
#endif
if( string == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid string.",
function );
return( -1 );
}
if( string_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid string size value exceeds maximum.",
function );
return( -1 );
}
/* Use the WINAPI error string function
*/
#if defined( WINAPI ) && !defined( USE_CRT_FUNCTIONS )
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( FormatMessageW(
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
(DWORD) error_number,
MAKELANGID(
LANG_NEUTRAL,
SUBLANG_DEFAULT ),
string,
string_size,
NULL ) == 0 )
#else
if( FormatMessageA(
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
(DWORD) error_number,
MAKELANGID(
LANG_NEUTRAL,
SUBLANG_DEFAULT ),
string,
string_size,
NULL ) == 0 )
#endif
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set string.",
function );
return( -1 );
}
/* Use MSVSC++ specific CRT error string functions
*/
#elif defined( USE_CRT_FUNCTIONS ) && defined( _MSC_VER )
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( _wcserror_s(
string,
string_size,
error_number ) != 0 )
#else
if( strerror_s(
string,
string_size,
error_number ) != 0 )
#endif
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set string.",
function );
return( -1 );
}
/* Use POSIX specific error string functions
*/
#elif defined( HAVE_STRERROR_R )
/* Sanity check
*/
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
#error Missing wide character strerror_r function
#endif
#if defined( STRERROR_R_CHAR_P )
if( strerror_r(
error_number,
string,
string_size ) == NULL )
#else
if( strerror_r(
error_number,
string,
string_size ) != 0 )
#endif
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set string.",
function );
return( -1 );
}
/* Use the static error string function
*/
#elif defined( HAVE_STRERROR ) || defined( WINAPI )
/* Sanity check
*/
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) && !defined( WINAPI )
#error Missing wide character strerror function
#endif
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
static_error_string = _wcserror(
error_number );
#else
static_error_string = strerror(
error_number );
#endif
if( static_error_string == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to create static error string.",
function );
return( -1 );
}
static_error_string_length = libcstring_system_string_length(
static_error_string );
if( libcstring_system_string_copy(
string,
static_error_string,
static_error_string_length ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set string.",
function );
return( -1 );
}
string[ static_error_string_length ] = 0;
#else
#error Missing strerror function
#endif
return( 1 );
}
/* Resolves filenames with wildcards (globs)
* Returns the number of results if successful or -1 on error
*/
int libsystem_glob_resolve(
libsystem_glob_t *glob,
libcstring_system_character_t * const patterns[],
int number_of_patterns,
liberror_error_t **error )
{
#if defined( HAVE_IO_H ) || defined( WINAPI )
libsystem_find_data_t find_data;
libcstring_system_character_t find_path[ _MAX_PATH ];
libcstring_system_character_t find_drive[ _MAX_DRIVE ];
libcstring_system_character_t find_directory[ _MAX_DIR ];
libcstring_system_character_t find_name[ _MAX_FNAME ];
libcstring_system_character_t find_extension[ _MAX_EXT ];
intptr_t find_handle = 0;
#endif
static char *function = "libsystem_glob_resolve";
size_t find_path_length = 0;
int globs_found = 0;
int iterator = 0;
if( glob == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid glob.",
function );
return( -1 );
}
for( iterator = 0;
iterator < number_of_patterns;
iterator++ )
{
if( patterns[ iterator ] == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: missing pattern value.",
function );
return( -1 );
}
#if defined( _MSC_VER )
if( libsystem_path_split(
patterns[ iterator ],
find_drive,
_MAX_DRIVE,
find_directory,
_MAX_DIR,
find_name,
_MAX_FNAME,
find_extension,
_MAX_EXT ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to split path.",
function );
return( -1 );
}
#else
libsystem_path_split(
patterns[ iterator ],
find_drive,
_MAX_DRIVE,
find_directory,
_MAX_DIR,
find_name,
_MAX_FNAME,
find_extension,
_MAX_EXT );
#endif
find_handle = libsystem_find_first(
patterns[ iterator ],
&find_data );
if( find_handle != -1 )
{
do
{
if( libsystem_glob_resize(
glob,
glob->number_of_results + 1,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize glob.",
function );
return( -1 );
}
#if defined( _MSC_VER )
if( libsystem_path_make(
find_path,
_MAX_PATH,
find_drive,
find_directory,
find_data.name,
_LIBCSTRING_SYSTEM_STRING( "" ) ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to make path.",
function );
return( -1 );
}
#elif defined( __BORLANDC__ ) && __BORLANDC__ <= 0x0520
libsystem_path_make(
find_path,
_MAX_PATH,
find_drive,
find_directory,
find_data.ff_name,
_LIBCSTRING_SYSTEM_STRING( "" ) );
#else
libsystem_path_make(
find_path,
_MAX_PATH,
find_drive,
find_directory,
find_data.name,
_LIBCSTRING_SYSTEM_STRING( "" ) );
#endif
find_path_length = libcstring_system_string_length(
find_path );
glob->result[ glob->number_of_results - 1 ] = (libcstring_system_character_t *) memory_allocate(
sizeof( libcstring_system_character_t ) * ( find_path_length + 1 ) );
if( glob->result[ glob->number_of_results - 1 ] == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create glob result.",
function );
return( -1 );
}
if( libcstring_system_string_copy(
glob->result[ glob->number_of_results - 1 ],
find_path,
find_path_length ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set glob result.",
function );
memory_free(
glob->result[ glob->number_of_results - 1 ] );
glob->result[ glob->number_of_results - 1 ] = NULL;
return( -1 );
}
( glob->result[ glob->number_of_results - 1 ] )[ find_path_length ] = 0;
globs_found++;
if( globs_found > (int32_t) UINT16_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: too many globs found.",
function );
return( -1 );
}
}
while( libsystem_find_next(
find_handle,
&find_data ) == 0 );
if( errno != ENOENT )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: error finding next file entry.",
function );
return( -1 );
}
if( libsystem_find_close(
find_handle ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: error closing find handle.",
function );
return( -1 );
}
}
else if( errno != ENOENT )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: error finding file entry.",
function );
return( -1 );
}
}
return( 1 );
}
/* Retrieves a ctime formatted string
* The string must be at least 32 characters of size including the end of string character
* Returns 1 if successful or -1 on error
*/
int process_status_get_ctime_string(
const time_t *timestamp,
libcstring_system_character_t *string,
size_t string_size,
libcerror_error_t **error )
{
static char *function = "process_status_get_ctime_string";
#if ( defined( HAVE_CTIME ) && !defined( HAVE_CTIME_R ) ) || ( defined( WINAPI ) && !defined( _MSC_VER ) )
const libcstring_system_character_t *static_ctime_string = NULL;
size_t static_ctime_string_length = 0;
#endif
if( timestamp == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid timestamp.",
function );
return( -1 );
}
if( string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid string.",
function );
return( -1 );
}
if( string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid string size value exceeds maximum.",
function );
return( -1 );
}
if( string_size < 32 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: string too small.",
function );
return( -1 );
}
#if defined( _MSC_VER )
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( _wctime_s(
string,
string_size,
timestamp ) != 0 )
#else
if( ctime_s(
string,
string_size,
timestamp ) != 0 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set string.",
function );
return( -1 );
}
#elif defined( HAVE_CTIME_R )
/* Sanity check
*/
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
#error Missing wide character ctime_r function
#endif
#if defined( HAVE_CTIME_R_SIZE )
if( ctime_r(
timestamp,
string,
string_size ) == NULL )
#else
if( ctime_r(
timestamp,
string ) == NULL )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set string.",
function );
return( -1 );
}
#else
/* Sanity check
*/
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) && !defined( WINAPI )
#error Missing wide character ctime function
#endif
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
static_ctime_string = _wctime(
timestamp );
#else
static_ctime_string = ctime(
timestamp );
#endif
if( static_ctime_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to create static ctime string.",
function );
return( -1 );
}
static_ctime_string_length = libcstring_system_string_length(
static_ctime_string );
if( libcstring_system_string_copy(
string,
static_ctime_string,
static_ctime_string_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set string.",
function );
return( -1 );
}
string[ static_ctime_string_length ] = 0;
#endif
return( 1 );
}
/* Opens the mount handle
* Returns 1 if successful or -1 on error
*/
int mount_handle_open_input(
mount_handle_t *mount_handle,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
libvslvm_logical_volume_t *logical_volume = NULL;
static char *function = "mount_handle_open_input";
size_t filename_length = 0;
int entry_index = 0;
int logical_volume_index = 0;
int number_of_logical_volumes = 0;
int result = 0;
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
if( libbfio_file_range_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize file IO handle.",
function );
goto on_error;
}
filename_length = libcstring_system_string_length(
filename );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libbfio_file_range_set_name_wide(
file_io_handle,
filename,
filename_length,
error ) != 1 )
#else
if( libbfio_file_range_set_name(
file_io_handle,
filename,
filename_length,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open set file name.",
function );
goto on_error;
}
if( libbfio_file_range_set(
file_io_handle,
mount_handle->volume_offset,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open set volume offset.",
function );
goto on_error;
}
if( libvslvm_handle_open_file_io_handle(
mount_handle->input_handle,
file_io_handle,
LIBVSLVM_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input handle.",
function );
goto on_error;
}
if( libbfio_pool_append_handle(
mount_handle->physical_volume_file_io_pool,
&entry_index,
file_io_handle,
LIBBFIO_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input handle.",
function );
goto on_error;
}
/* The takes over management of the file IO handle
*/
file_io_handle = NULL;
/* TODO determine if the first file is a metadata only file and change filenames accordingly
*/
if( libvslvm_handle_open_physical_volume_files_file_io_pool(
mount_handle->input_handle,
mount_handle->physical_volume_file_io_pool,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open physical volume files.",
function );
goto on_error;
}
if( libvslvm_handle_get_volume_group(
mount_handle->input_handle,
&( mount_handle->volume_group ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve volume group.",
function );
goto on_error;
}
if( libvslvm_volume_group_get_number_of_logical_volumes(
mount_handle->volume_group,
&number_of_logical_volumes,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of logical volumes.",
function );
goto on_error;
}
for( logical_volume_index = 0;
logical_volume_index < number_of_logical_volumes;
logical_volume_index++ )
{
if( libvslvm_volume_group_get_logical_volume(
mount_handle->volume_group,
logical_volume_index,
&logical_volume,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve logical volume: %d.",
function,
logical_volume_index );
goto on_error;
}
if( libcdata_array_append_entry(
mount_handle->logical_volumes_array,
&entry_index,
(intptr_t *) logical_volume,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append logical volume to array.",
function );
goto on_error;
}
logical_volume = NULL;
}
return( 1 );
on_error:
if( logical_volume != NULL )
{
libvslvm_logical_volume_free(
&logical_volume,
NULL );
}
if( mount_handle->volume_group != NULL )
{
libvslvm_volume_group_free(
&( mount_handle->volume_group ),
NULL );
}
if( mount_handle->input_handle != NULL )
{
libvslvm_handle_free(
&( mount_handle->input_handle ),
NULL );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
libcdata_array_empty(
mount_handle->logical_volumes_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libvslvm_logical_volume_free,
NULL );
return( -1 );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t acquiry_operating_system[ 32 ];
libcstring_system_character_t input_buffer[ EWFEXPORT_INPUT_BUFFER_SIZE ];
libcstring_system_character_t * const *argv_filenames = NULL;
liberror_error_t *error = NULL;
#if !defined( LIBSYSTEM_HAVE_GLOB )
libsystem_glob_t *glob = NULL;
#endif
libcstring_system_character_t *acquiry_software_version = NULL;
libcstring_system_character_t *log_filename = NULL;
libcstring_system_character_t *option_additional_digest_types = NULL;
libcstring_system_character_t *option_compression_level = NULL;
libcstring_system_character_t *option_format = NULL;
libcstring_system_character_t *option_header_codepage = NULL;
libcstring_system_character_t *option_maximum_segment_size = NULL;
libcstring_system_character_t *option_offset = NULL;
libcstring_system_character_t *option_process_buffer_size = NULL;
libcstring_system_character_t *option_sectors_per_chunk = NULL;
libcstring_system_character_t *option_size = NULL;
libcstring_system_character_t *option_target_filename = NULL;
libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "ewfexport" );
libcstring_system_character_t *request_string = NULL;
log_handle_t *log_handle = NULL;
libcstring_system_integer_t option = 0;
size64_t media_size = 0;
size_t string_length = 0;
uint8_t calculate_md5 = 1;
uint8_t print_status_information = 1;
uint8_t swap_byte_pairs = 0;
uint8_t verbose = 0;
uint8_t zero_chunk_on_error = 0;
int interactive_mode = 1;
int number_of_filenames = 0;
int result = 1;
libsystem_notify_set_stream(
stderr,
NULL );
libsystem_notify_set_verbose(
1 );
if( libsystem_initialize(
"ewftools",
&error ) != 1 )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
#if defined( WINAPI ) && !defined( __CYGWIN__ )
#if defined( _MSC_VER )
if( _setmode(
_fileno(
stdout ),
_O_BINARY ) == -1 )
#else
if( setmode(
_fileno(
stdout ),
_O_BINARY ) == -1 )
#endif
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Unable to set stdout to binary mode.\n" );
usage_fprint(
stdout );
goto on_error;
}
#endif
while( ( option = libsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "A:b:B:c:d:f:hl:o:p:qsS:t:uvVw" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
usage_fprint(
stderr );
goto on_error;
case (libcstring_system_integer_t) 'A':
option_header_codepage = optarg;
break;
case (libcstring_system_integer_t) 'b':
option_sectors_per_chunk = optarg;
break;
case (libcstring_system_integer_t) 'B':
option_size = optarg;
break;
case (libcstring_system_integer_t) 'c':
option_compression_level = optarg;
break;
case (libcstring_system_integer_t) 'd':
option_additional_digest_types = optarg;
break;
case (libcstring_system_integer_t) 'f':
option_format = optarg;
break;
case (libcstring_system_integer_t) 'h':
ewfoutput_version_fprint(
stderr,
program );
usage_fprint(
stderr );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'l':
log_filename = optarg;
break;
case (libcstring_system_integer_t) 'o':
option_offset = optarg;
break;
case (libcstring_system_integer_t) 'p':
option_process_buffer_size = optarg;
break;
case (libcstring_system_integer_t) 'q':
print_status_information = 0;
break;
case (libcstring_system_integer_t) 's':
swap_byte_pairs = 1;
break;
case (libcstring_system_integer_t) 'S':
option_maximum_segment_size = optarg;
break;
case (libcstring_system_integer_t) 't':
option_target_filename = optarg;
break;
case (libcstring_system_integer_t) 'u':
interactive_mode = 0;
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
ewfoutput_version_fprint(
stderr,
program );
ewfoutput_copyright_fprint(
stderr );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'w':
zero_chunk_on_error = 1;
break;
}
}
if( optind == argc )
{
ewfoutput_version_fprint(
stderr,
program );
fprintf(
stderr,
"Missing EWF image file(s).\n" );
usage_fprint(
stderr );
goto on_error;
}
ewfoutput_version_fprint(
stderr,
program );
libsystem_notify_set_verbose(
verbose );
libewf_notify_set_verbose(
verbose );
libewf_notify_set_stream(
stderr,
NULL );
#if !defined( LIBSYSTEM_HAVE_GLOB )
if( libsystem_glob_initialize(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize glob.\n" );
goto on_error;
}
if( libsystem_glob_resolve(
glob,
&( argv[ optind ] ),
argc - optind,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to resolve glob.\n" );
goto on_error;
}
argv_filenames = glob->result;
number_of_filenames = glob->number_of_results;
#else
argv_filenames = &( argv[ optind ] );
number_of_filenames = argc - optind;
#endif
if( export_handle_initialize(
&ewfexport_export_handle,
calculate_md5,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create export handle.\n" );
goto on_error;
}
if( libsystem_signal_attach(
ewfexport_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
result = export_handle_open_input(
ewfexport_export_handle,
argv_filenames,
number_of_filenames,
&error );
if( ewfexport_abort != 0 )
{
goto on_abort;
}
if( result != 1 )
{
fprintf(
stderr,
"Unable to open EWF file(s).\n" );
goto on_error;
}
#if !defined( LIBSYSTEM_HAVE_GLOB )
if( libsystem_glob_free(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
#endif
if( export_handle_get_input_media_size(
ewfexport_export_handle,
&media_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve input media size.\n" );
goto on_error;
}
if( option_header_codepage != NULL )
{
result = export_handle_set_header_codepage(
ewfexport_export_handle,
option_header_codepage,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set header codepage.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported header codepage defaulting to: ascii.\n" );
}
}
if( option_target_filename != NULL )
{
if( export_handle_set_string(
ewfexport_export_handle,
option_target_filename,
&( ewfexport_export_handle->target_filename ),
&( ewfexport_export_handle->target_filename_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set target filename.\n" );
goto on_error;
}
}
else if( interactive_mode == 0 )
{
/* Make sure the target filename is set in unattended mode
*/
if( export_handle_set_string(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "export" ),
&( ewfexport_export_handle->target_filename ),
&( ewfexport_export_handle->target_filename_size ),
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set target filename.\n" );
goto on_error;
}
}
if( option_compression_level != NULL )
{
result = export_handle_set_compression_values(
ewfexport_export_handle,
option_compression_level,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set compression values.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported compression level defaulting to: none.\n" );
}
}
if( option_format != NULL )
{
result = export_handle_set_format(
ewfexport_export_handle,
option_format,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set format.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported output format defaulting to: raw.\n" );
}
}
if( option_sectors_per_chunk != NULL )
{
result = export_handle_set_sectors_per_chunk(
ewfexport_export_handle,
option_sectors_per_chunk,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set sectors per chunk.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported sectors per chunk defaulting to: 64.\n" );
}
}
if( option_maximum_segment_size != NULL )
{
result = export_handle_set_maximum_segment_size(
ewfexport_export_handle,
option_maximum_segment_size,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set maximum segment size.\n" );
goto on_error;
}
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
{
if( ( result == 0 )
|| ( ewfexport_export_handle->maximum_segment_size < EWFCOMMON_MINIMUM_SEGMENT_FILE_SIZE )
|| ( ( ewfexport_export_handle->ewf_format == LIBEWF_FORMAT_ENCASE6 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) )
|| ( ( ewfexport_export_handle->ewf_format != LIBEWF_FORMAT_ENCASE6 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_32BIT ) ) )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE;
fprintf(
stderr,
"Unsupported maximum segment size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->maximum_segment_size );
}
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW )
{
if( ( result == 0 )
|| ( ( ewfexport_export_handle->maximum_segment_size != 0 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) ) )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE;
fprintf(
stderr,
"Unsupported maximum segment size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->maximum_segment_size );
}
}
}
if( option_offset != NULL )
{
string_length = libcstring_system_string_length(
option_offset );
if( libsystem_string_to_uint64(
option_offset,
string_length + 1,
&ewfexport_export_handle->export_offset,
&error ) != 1 )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
ewfexport_export_handle->export_offset = 0;
fprintf(
stderr,
"Unsupported export offset defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->export_offset );
}
}
if( option_size != NULL )
{
string_length = libcstring_system_string_length(
option_size );
if( libsystem_string_to_uint64(
option_size,
string_length + 1,
&ewfexport_export_handle->export_size,
&error ) != 1 )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
ewfexport_export_handle->export_size = 0;
fprintf(
stderr,
"Unsupported export size defaulting to: all bytes.\n" );
}
}
if( option_process_buffer_size != NULL )
{
result = export_handle_set_process_buffer_size(
ewfexport_export_handle,
option_process_buffer_size,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set process buffer size.\n" );
goto on_error;
}
else if( ( result == 0 )
|| ( ewfexport_export_handle->process_buffer_size > (size_t) SSIZE_MAX ) )
{
ewfexport_export_handle->process_buffer_size = 0;
fprintf(
stderr,
"Unsupported process buffer size defaulting to: chunk size.\n" );
}
}
if( option_additional_digest_types != NULL )
{
result = export_handle_set_additional_digest_types(
ewfexport_export_handle,
option_additional_digest_types,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set additional digest types.\n" );
goto on_error;
}
}
/* Initialize values
*/
if( ( ewfexport_export_handle->export_size == 0 )
|| ( ewfexport_export_handle->export_size > ( media_size - ewfexport_export_handle->export_offset ) ) )
{
ewfexport_export_handle->export_size = media_size - ewfexport_export_handle->export_offset;
}
/* Request the necessary case data
*/
if( interactive_mode != 0 )
{
if( libsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
fprintf(
stderr,
"Information for export required, please provide the necessary input\n" );
if( option_format == NULL )
{
result = export_handle_prompt_for_format(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "Export to format" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine format.\n" );
goto on_error;
}
}
if( option_target_filename == NULL )
{
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
{
request_string = _LIBCSTRING_SYSTEM_STRING( "Target path and filename without extension" );
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_FILES )
{
request_string = _LIBCSTRING_SYSTEM_STRING( "Target path" );
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW )
{
request_string = _LIBCSTRING_SYSTEM_STRING( "Target path and filename without extension or - for stdout" );
}
}
if( request_string != NULL )
{
do
{
result = export_handle_prompt_for_string(
ewfexport_export_handle,
request_string,
&( ewfexport_export_handle->target_filename ),
&( ewfexport_export_handle->target_filename_size ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine target.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stdout,
"Target is required, please try again or terminate using Ctrl^C.\n" );
}
}
while( result != 1 );
}
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
{
if( option_compression_level == NULL )
{
result = export_handle_prompt_for_compression_level(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "Use compression" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine compression level.\n" );
goto on_error;
}
}
if( option_maximum_segment_size == NULL )
{
result = export_handle_prompt_for_maximum_segment_size(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "Evidence segment file size in bytes" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine maximum segment size.\n" );
goto on_error;
}
if( ( ewfexport_export_handle->maximum_segment_size < EWFCOMMON_MINIMUM_SEGMENT_FILE_SIZE )
|| ( ( ewfexport_export_handle->ewf_format == LIBEWF_FORMAT_ENCASE6 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) )
|| ( ( ewfexport_export_handle->ewf_format != LIBEWF_FORMAT_ENCASE6 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_32BIT ) ) )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE;
fprintf(
stderr,
"Unsupported maximum segment size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->maximum_segment_size );
}
}
if( option_sectors_per_chunk == NULL )
{
result = export_handle_prompt_for_sectors_per_chunk(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "The number of sectors to read at once" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine sectors per chunk.\n" );
goto on_error;
}
}
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW )
{
if( ( ewfexport_export_handle->target_filename != NULL )
&& ( ( ewfexport_export_handle->target_filename )[ 0 ] == (libcstring_system_character_t) '-' )
&& ( ( ewfexport_export_handle->target_filename )[ 1 ] == 0 ) )
{
/* No need for segment files when exporting to stdout */
}
else if( option_maximum_segment_size == NULL )
{
result = export_handle_prompt_for_maximum_segment_size(
ewfexport_export_handle,
_LIBCSTRING_SYSTEM_STRING( "Evidence segment file size in bytes (0 is unlimited)" ),
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine maximum segment size.\n" );
goto on_error;
}
if( ( ewfexport_export_handle->maximum_segment_size != 0 )
&& ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE;
fprintf(
stderr,
"Unsupported maximum segment size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->maximum_segment_size );
}
}
}
if( ( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
|| ( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW ) )
{
if( option_offset == NULL )
{
if( ewfinput_get_size_variable(
stderr,
input_buffer,
EWFEXPORT_INPUT_BUFFER_SIZE,
_LIBCSTRING_SYSTEM_STRING( "Start export at offset" ),
0,
media_size,
ewfexport_export_handle->export_offset,
&( ewfexport_export_handle->export_offset ),
&error ) == -1 )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
ewfexport_export_handle->export_offset = 0;
fprintf(
stderr,
"Unable to determine export offset defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->export_offset );
}
}
if( option_size == NULL )
{
if( ewfinput_get_size_variable(
stderr,
input_buffer,
EWFEXPORT_INPUT_BUFFER_SIZE,
_LIBCSTRING_SYSTEM_STRING( "Number of bytes to export" ),
0,
media_size - ewfexport_export_handle->export_offset,
ewfexport_export_handle->export_size,
&( ewfexport_export_handle->export_size ),
&error ) == -1 )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
ewfexport_export_handle->export_size = media_size - ewfexport_export_handle->export_offset;
fprintf(
stderr,
"Unable to determine export size defaulting to: %" PRIu64 ".\n",
ewfexport_export_handle->export_size );
}
}
}
if( libsystem_signal_attach(
ewfexport_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
}
else
{
if( ewfexport_export_handle->maximum_segment_size == 0 )
{
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF )
{
if( ewfexport_export_handle->ewf_format == LIBEWF_FORMAT_ENCASE6 )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT;
}
else
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_32BIT;
}
}
else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW )
{
ewfexport_export_handle->maximum_segment_size = EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT;
}
}
}
fprintf(
stderr,
"\n" );
if( log_filename != NULL )
{
if( log_handle_initialize(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create log handle.\n" );
goto on_error;
}
if( log_handle_open(
log_handle,
log_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open log file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
log_filename );
goto on_error;
}
}
if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_FILES )
{
result = export_handle_export_single_files(
ewfexport_export_handle,
ewfexport_export_handle->target_filename,
print_status_information,
log_handle,
&error );
if( result != 1 )
{
fprintf(
stderr,
"Unable to export single files.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
}
else
{
if( export_handle_open_output(
ewfexport_export_handle,
ewfexport_export_handle->target_filename,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open output.\n" );
goto on_error;
}
if( platform_get_operating_system(
acquiry_operating_system,
32,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to determine operating system.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
acquiry_operating_system[ 0 ] = 0;
}
acquiry_software_version = _LIBCSTRING_SYSTEM_STRING( LIBEWF_VERSION_STRING );
if( export_handle_set_output_values(
ewfexport_export_handle,
acquiry_operating_system,
program,
acquiry_software_version,
zero_chunk_on_error,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set output values.\n" );
goto on_error;
}
result = export_handle_export_input(
ewfexport_export_handle,
swap_byte_pairs,
print_status_information,
log_handle,
&error );
if( result != 1 )
{
fprintf(
stderr,
"Unable to export input.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
}
if( log_handle != NULL )
{
if( log_handle_close(
log_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close log file: %" PRIs_LIBCSTRING_SYSTEM ".\n",
log_filename );
goto on_error;
}
if( log_handle_free(
&log_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free log handle.\n" );
goto on_error;
}
}
on_abort:
if( export_handle_close(
ewfexport_export_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close export handle.\n" );
goto on_error;
}
if( libsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
if( export_handle_free(
&ewfexport_export_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free export handle.\n" );
goto on_error;
}
if( ewfexport_abort != 0 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n",
program );
return( EXIT_FAILURE );
}
if( result != 1 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": FAILURE\n",
program );
return( EXIT_FAILURE );
}
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": SUCCESS\n",
program );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libsystem_notify_print_error_backtrace(
error );
liberror_error_free(
&error );
}
if( log_handle != NULL )
{
log_handle_close(
log_handle,
NULL );
log_handle_free(
&log_handle,
NULL );
}
if( ewfexport_export_handle != NULL )
{
export_handle_close(
ewfexport_export_handle,
NULL );
export_handle_free(
&ewfexport_export_handle,
NULL );
}
#if !defined( LIBSYSTEM_HAVE_GLOB )
if( glob != NULL )
{
libsystem_glob_free(
&glob,
NULL );
}
#endif
return( EXIT_FAILURE );
}
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 *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 );
}
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;
liblnk_file_t *file = NULL;
size_t string_length = 0;
uint32_t feature_flags = 0;
int ascii_codepage = 0;
int result = 0;
if( argc != 2 )
{
fprintf(
stderr,
"Unsupported number of arguments.\n" );
return( EXIT_FAILURE );
}
feature_flags = LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_ISO_8859
| LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_KOI8
| LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_WINDOWS;
string_length = libcstring_system_string_length(
argv[ 1 ] );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libclocale_codepage_copy_from_string_wide(
&ascii_codepage,
argv[ 1 ],
string_length,
feature_flags,
&error );
#else
result = libclocale_codepage_copy_from_string(
&ascii_codepage,
argv[ 1 ],
string_length,
feature_flags,
&error );
#endif
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine ASCII codepage from: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ 1 ] );
goto on_error;
}
if( liblnk_file_initialize(
&file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create file.\n" );
goto on_error;
}
if( liblnk_file_set_ascii_codepage(
file,
ascii_codepage,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set codepage: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ 1 ] );
goto on_error;
}
if( liblnk_file_free(
&file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free file.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcerror_error_backtrace_fprint(
error,
stdout );
libcerror_error_free(
&error );
}
if( file != NULL )
{
liblnk_file_free(
&file,
NULL );
}
return( -1 );
}
/* Tests reading/writing data of a specific size at a specific offset
* Return 1 if successful, 0 if not or -1 on error
*/
int ewf_test_read_write_delta(
libcstring_system_character_t * const filenames[],
int number_of_filenames,
const libcstring_system_character_t *delta_segment_filename,
off64_t write_offset,
size64_t write_size,
libcerror_error_t **error )
{
libewf_handle_t *handle = NULL;
uint8_t *buffer = NULL;
static char *function = "ewf_test_read_write_delta";
size_t delta_segment_filename_length = 0;
size_t read_size = 0;
ssize_t read_count = 0;
ssize_t write_count = 0;
if( libewf_handle_initialize(
&handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create handle.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT ) && defined( EWF_TEST_READ_WRITE_DELTA_VERBOSE )
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,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ_WRITE,
error ) != 1 )
#else
if( libewf_handle_open(
handle,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ_WRITE,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open handle.",
function );
goto on_error;
}
if( delta_segment_filename != NULL )
{
delta_segment_filename_length = libcstring_system_string_length(
delta_segment_filename );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_set_delta_segment_filename_wide(
handle,
delta_segment_filename,
delta_segment_filename_length,
error ) != 1 )
#else
if( libewf_handle_set_delta_segment_filename(
handle,
delta_segment_filename,
delta_segment_filename_length,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set delta segment filename.",
function );
goto on_error;
}
}
if( libewf_handle_seek_offset(
handle,
write_offset,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to seek offset: %" PRIi64 ".",
function,
write_offset );
goto on_error;
}
buffer = (uint8_t *) memory_allocate(
EWF_TEST_BUFFER_SIZE );
while( write_size > 0 )
{
if( write_size > (size64_t) EWF_TEST_BUFFER_SIZE )
{
read_size = EWF_TEST_BUFFER_SIZE;
}
else
{
read_size = (size_t) write_size;
}
read_count = libewf_handle_read_buffer(
handle,
buffer,
read_size,
error );
if( read_count < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_WRITE_FAILED,
"%s: unable read buffer of size: %" PRIzd ".",
function,
read_size );
goto on_error;
}
if( memory_set(
buffer,
(int) 'X',
(size_t) read_count ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable set value in buffer.",
function );
goto on_error;
}
if( libewf_handle_seek_offset(
handle,
-1 * (off64_t) read_size,
SEEK_CUR,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to seek previous offset.",
function );
goto on_error;
}
write_count = libewf_handle_write_buffer(
handle,
buffer,
(size_t) read_count,
error );
if( write_count < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_WRITE_FAILED,
"%s: unable write buffer of size: %" PRIzd ".",
function,
read_count );
goto on_error;
}
if( write_count != read_count )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_WRITE_FAILED,
"%s: unable write buffer of size: %" PRIzd ".",
function,
read_count );
goto on_error;
}
write_offset += write_count;
write_size -= write_count;
}
memory_free(
buffer );
buffer = NULL;
if( libewf_handle_close(
handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close handle.",
function );
goto on_error;
}
if( libewf_handle_free(
&handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( buffer != NULL )
{
memory_free(
buffer );
}
if( handle != NULL )
{
libewf_handle_close(
handle,
NULL );
libewf_handle_free(
&handle,
NULL );
}
return( -1 );
}
/* Opens the wipekey handle
* Returns 1 if successful, 0 if the keys could not be read or -1 on error
*/
int wipekey_handle_open_input(
wipekey_handle_t *wipekey_handle,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
static char *function = "wipekey_handle_open_input";
size_t filename_length = 0;
int result = 0;
if( wipekey_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid wipekey handle.",
function );
return( -1 );
}
filename_length = libcstring_system_string_length(
filename );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libbfio_file_set_name_wide(
wipekey_handle->input_file_io_handle,
filename,
filename_length,
error ) != 1 )
#else
if( libbfio_file_set_name(
wipekey_handle->input_file_io_handle,
filename,
filename_length,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open set file name.",
function );
goto on_error;
}
if( libbfio_handle_open(
wipekey_handle->input_file_io_handle,
LIBBFIO_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input file.",
function );
goto on_error;
}
if( libfvde_encryption_context_plist_initialize(
&( wipekey_handle->encrypted_root_plist ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create encrypted root plist.",
function );
goto on_error;
}
if( libfvde_encryption_context_plist_read_file_io_handle(
wipekey_handle->encrypted_root_plist,
wipekey_handle->input_file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_GENERIC,
"%s: unable to read encrypted root plist.",
function );
goto on_error;
}
if( libbfio_handle_close(
wipekey_handle->input_file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close input file IO handle.",
function );
goto on_error;
}
result = libfvde_encryption_context_plist_decrypt(
wipekey_handle->encrypted_root_plist,
wipekey_handle->volume_key_data,
128,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ENCRYPTION,
LIBCERROR_ENCRYPTION_ERROR_DECRYPT_FAILED,
"%s: unable to decrypt encrypted root plist.",
function );
goto on_error;
}
if( memory_set(
wipekey_handle->volume_key_data,
0,
16 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear volume key data.",
function );
goto on_error;
}
return( result );
on_error:
if( wipekey_handle->encrypted_root_plist != NULL )
{
libfvde_encryption_context_plist_free(
&( wipekey_handle->encrypted_root_plist ),
NULL );
}
return( -1 );
}
/* Opens the input
* Returns 1 if successful or -1 on error
*/
int info_handle_open_input(
info_handle_t *info_handle,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
static char *function = "info_handle_open_input";
size_t filename_length = 0;
int entry_index = 0;
if( info_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid info handle.",
function );
return( -1 );
}
if( libbfio_file_range_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize file IO handle.",
function );
goto on_error;
}
filename_length = libcstring_system_string_length(
filename );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libbfio_file_range_set_name_wide(
file_io_handle,
filename,
filename_length,
error ) != 1 )
#else
if( libbfio_file_range_set_name(
file_io_handle,
filename,
filename_length,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open set file name.",
function );
goto on_error;
}
if( libbfio_file_range_set(
file_io_handle,
info_handle->volume_offset,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open set volume offset.",
function );
goto on_error;
}
if( libvslvm_handle_open_file_io_handle(
info_handle->input_handle,
file_io_handle,
LIBVSLVM_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input handle.",
function );
goto on_error;
}
if( libbfio_pool_append_handle(
info_handle->physical_volume_file_io_pool,
&entry_index,
file_io_handle,
LIBBFIO_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input handle.",
function );
goto on_error;
}
/* The takes over management of the file IO handle
*/
file_io_handle = NULL;
/* TODO determine if the first file is a metadata only file and change filenames accordingly
*/
if( libvslvm_handle_open_physical_volume_files_file_io_pool(
info_handle->input_handle,
info_handle->physical_volume_file_io_pool,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open physical volume files.",
function );
goto on_error;
}
return( 1 );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
/* Opens the input of the mount handle
* Returns 1 if successful, 0 if the keys could not be read or -1 on error
*/
int mount_handle_open_input(
mount_handle_t *mount_handle,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
libcstring_system_character_t *basename_end = NULL;
libvhdi_file_t *input_file = NULL;
static char *function = "mount_handle_open_input";
size_t basename_length = 0;
size_t filename_length = 0;
int entry_index = 0;
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
filename_length = libcstring_system_string_length(
filename );
basename_end = libcstring_system_string_search_character_reverse(
filename,
(libcstring_system_character_t) LIBCPATH_SEPARATOR,
filename_length + 1 );
if( basename_end != NULL )
{
basename_length = (size_t) ( basename_end - filename ) + 1;
}
if( basename_length > 0 )
{
if( mount_handle_set_basename(
mount_handle,
filename,
basename_length,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set basename.",
function );
goto on_error;
}
}
if( libvhdi_file_initialize(
&input_file,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input file.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libvhdi_file_open_wide(
input_file,
filename,
LIBVHDI_OPEN_READ,
error ) != 1 )
#else
if( libvhdi_file_open(
input_file,
filename,
LIBVHDI_OPEN_READ,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input file.",
function );
goto on_error;
}
if( mount_handle_open_input_parent_file(
mount_handle,
input_file,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open parent input file.",
function );
goto on_error;
}
if( libcdata_array_append_entry(
mount_handle->input_files_array,
&entry_index,
(intptr_t *) input_file,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append input file to array.",
function );
goto on_error;
}
return( 1 );
on_error:
if( input_file != NULL )
{
libvhdi_file_free(
&input_file,
NULL );
}
libcdata_array_empty(
mount_handle->input_files_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libvhdi_file_free,
NULL );
return( -1 );
}
/* Determines the event log type from a string
* Returns 1 if successful, 0 if unsupported value or -1 on error
*/
int evtxinput_determine_event_log_type(
const libcstring_system_character_t *string,
int *event_log_type,
libcerror_error_t **error )
{
static char *function = "evtxinput_determine_event_log_type";
size_t string_length = 0;
int result = 0;
if( string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid string.",
function );
return( -1 );
}
if( event_log_type == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid event log type.",
function );
return( -1 );
}
string_length = libcstring_system_string_length(
string );
if( string_length == 6 )
{
if( libcstring_system_string_compare_no_case(
string,
_LIBCSTRING_SYSTEM_STRING( "system" ),
6 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SYSTEM;
result = 1;
}
}
else if( string_length == 8 )
{
if( libcstring_system_string_compare_no_case(
string,
_LIBCSTRING_SYSTEM_STRING( "security" ),
8 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SECURITY;
result = 1;
}
}
else if( string_length == 11 )
{
if( libcstring_system_string_compare_no_case(
string,
_LIBCSTRING_SYSTEM_STRING( "application" ),
11 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_APPLICATION;
result = 1;
}
}
return( result );
}
/* Determines the UTF-8 string size from the system string
* Returns 1 if successful or -1 on error
*/
int libcsystem_string_size_to_utf8_string(
const libcstring_system_character_t *string,
size_t string_size,
size_t *utf8_string_size,
libcerror_error_t **error )
{
static char *function = "libcsystem_string_size_to_utf8_string";
if( string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid string.",
function );
return( -1 );
}
if( string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid string size value exceeds maximum.",
function );
return( -1 );
}
if( utf8_string_size == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid UTF-8 string size.",
function );
return( -1 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
#if SIZEOF_WCHAR_T == 4
if( libuna_utf8_string_size_from_utf32(
(libuna_utf32_character_t *) string,
string_size,
utf8_string_size,
error ) != 1 )
#elif SIZEOF_WCHAR_T == 2
if( libuna_utf8_string_size_from_utf16(
(libuna_utf16_character_t *) string,
string_size,
utf8_string_size,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to determine UTF-8 string size.",
function );
return( -1 );
}
#else
if( libclocale_codepage == 0 )
{
*utf8_string_size = 1 + libcstring_system_string_length(
string );
}
else if( libuna_utf8_string_size_from_byte_stream(
(uint8_t *) string,
string_size,
libclocale_codepage,
utf8_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to determine UTF-8 string size.",
function );
return( -1 );
}
#endif
return( 1 );
}
int main( int argc, char * const argv[] )
#endif
{
libbde_volume_t *volume = NULL;
libcstring_system_character_t *option_password = NULL;
libcstring_system_character_t *option_recovery_password = NULL;
libcstring_system_character_t *source = NULL;
libcerror_error_t *error = NULL;
libcstring_system_integer_t option = 0;
size64_t volume_size = 0;
size_t string_length = 0;
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "p:r:" ) ) ) != (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) 'p':
option_password = optarg;
break;
case (libcstring_system_integer_t) 'r':
option_recovery_password = optarg;
break;
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file or device.\n" );
return( EXIT_FAILURE );
}
source = argv[ optind ];
#if defined( HAVE_DEBUG_OUTPUT ) && defined( BDE_TEST_OPEN_CLOSE_VERBOSE )
libbde_notify_set_verbose(
1 );
libbde_notify_set_stream(
stderr,
NULL );
#endif
/* Initialization
*/
if( libbde_volume_initialize(
&volume,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create volume.\n" );
goto on_error;
}
if( option_password != NULL )
{
string_length = libcstring_system_string_length(
option_password );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libbde_volume_set_utf16_password(
volume,
(uint16_t *) option_password,
string_length,
&error ) != 1 )
#else
if( libbde_volume_set_utf8_password(
volume,
(uint8_t *) option_password,
string_length,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to set password." );
goto on_error;
}
}
if( option_recovery_password != NULL )
{
string_length = libcstring_system_string_length(
option_recovery_password );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libbde_volume_set_utf16_recovery_password(
volume,
(uint16_t *) option_recovery_password,
string_length,
&error ) != 1 )
#else
if( libbde_volume_set_utf8_recovery_password(
volume,
(uint8_t *) option_recovery_password,
string_length,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to set recovery password." );
goto on_error;
}
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libbde_volume_open_wide(
volume,
source,
LIBBDE_OPEN_READ,
&error ) != 1 )
#else
if( libbde_volume_open(
volume,
source,
LIBBDE_OPEN_READ,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to open file.\n" );
goto on_error;
}
if( libbde_volume_get_size(
volume,
&volume_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve volume size.\n" );
goto on_error;
}
fprintf(
stdout,
"Volume size: %" PRIu64 " bytes\n",
volume_size );
if( bde_volume_test_seek(
volume,
volume_size ) != 1 )
{
fprintf(
stderr,
"Unable to seek in volume.\n" );
goto on_error;
}
/* Clean up
*/
if( libbde_volume_close(
volume,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close volume.\n" );
goto on_error;
}
if( libbde_volume_free(
&volume,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free volume.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libbde_error_backtrace_fprint(
error,
stderr );
libbde_error_free(
&error );
}
if( volume != NULL )
{
libbde_volume_close(
volume,
NULL );
libbde_volume_free(
&volume,
NULL );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t *target_filename = NULL;
liberror_error_t *error = NULL;
libewf_handle_t *handle = NULL;
libcstring_system_integer_t option = 0;
off64_t read_offset = 0;
size64_t media_size = 0;
size64_t read_size = 0;
size32_t chunk_size = 0;
size_t delta_segment_filename_length = 0;
while( ( option = libsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "t:" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 't':
target_filename = optarg;
break;
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing EWF image filename(s).\n" );
return( EXIT_FAILURE );
}
/* Initialization
*/
if( libewf_handle_initialize(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create handle.\n" );
goto on_error;
}
/*
#if defined( HAVE_DEBUG_OUTPUT )
libewf_notify_set_verbose(
1 );
libewf_notify_set_stream(
stderr,
NULL );
#endif
*/
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_open_wide(
handle,
&( argv[ optind ] ),
argc - optind,
LIBEWF_OPEN_READ_WRITE,
&error ) != 1 )
#else
if( libewf_handle_open(
handle,
&( argv[ optind ] ),
argc - optind,
LIBEWF_OPEN_READ_WRITE,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to open file(s).\n" );
goto on_error;
}
if( target_filename != NULL )
{
delta_segment_filename_length = libcstring_system_string_length(
target_filename );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_set_delta_segment_filename_wide(
handle,
target_filename,
delta_segment_filename_length,
&error ) != 1 )
#else
if( libewf_handle_set_delta_segment_filename(
handle,
target_filename,
delta_segment_filename_length,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to set delta segment filename.\n" );
goto on_error;
}
}
if( libewf_handle_get_media_size(
handle,
&media_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve media size.\n" );
goto on_error;
}
if( media_size > (size64_t) INT64_MAX )
{
fprintf(
stderr,
"Media size exceeds maximum.\n" );
goto on_error;
}
if( libewf_handle_get_chunk_size(
handle,
&chunk_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve chunk size.\n" );
goto on_error;
}
if( chunk_size == 0 )
{
fprintf(
stderr,
"Invalid chunk size.\n" );
goto on_error;
}
fprintf(
stdout,
"Media size: %" PRIu64 " bytes\n",
media_size );
/* Case 0: test full read
*/
/* Test: offset: 0 size: <media_size>
* Expected result: offset: 0 size: <media_size>
*/
read_offset = 0;
read_size = media_size;
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
/* Case 1: test random read
*/
/* Test: offset: <media_size / 7> size: <media_size / 2>
* Expected result: offset: <media_size / 7> size: <media_size / 2>
*/
read_offset = (off64_t) ( media_size / 7 );
read_size = media_size / 2;
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
/* Case 2: test read buffer beyond media size
*/
if( media_size < 1024 )
{
/* Test: offset: <media_size - 1024> size: 4096
* Expected result: offset: -1 size: <undetermined>
*/
read_offset = (off64_t) ( media_size - 1024 );
read_size = 4096;
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
}
else
{
/* Test: offset: <media_size - 1024> size: 4096
* Expected result: offset: <media_size - 1024> size: 1024
*/
read_offset = (off64_t) ( media_size - 1024 );
read_size = 4096;
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
1024 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
if( ewf_test_read_write_buffer_at_offset(
handle,
read_offset,
SEEK_SET,
read_size,
read_offset,
1024 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write buffer.\n" );
goto on_error;
}
}
fprintf(
stdout,
"\nChunk size: %" PRIu32 " bytes\n",
chunk_size );
/* Case 0: test full read
*/
/* Test: offset: 0 size: <media_size>
* Expected result: offset: 0 size: <media_size>
*/
read_offset = 0;
read_size = media_size;
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
/* Case 1: test random read
*/
/* Test: offset: <( ( media_size / 7 ) / chunk_size ) * chunk_size> size: <( ( ( media_size / 2 ) / chunk_size ) + 1 ) * chunk_size>
* Expected result: offset: <( ( media_size / 7 ) / chunk_size ) * chunk_size> size: <( ( ( media_size / 2 ) / chunk_size ) + 1 ) * chunk_size>
*/
read_offset = (off64_t) ( ( media_size / 7 ) / chunk_size ) * chunk_size;
read_size = ( ( ( media_size / 2 ) / chunk_size ) + 1 ) * chunk_size;
if( media_size == 0 )
{
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
0 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
0 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
}
else
{
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
read_offset,
read_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
}
/* Case 2: test read chunk beyond media size
*/
if( media_size < 1024 )
{
/* Test: offset: <media_size - 1024> size: chunk_size
* Expected result: offset: -1 size: <undetermined>
*/
read_offset = (off64_t) ( media_size - 1024 );
read_size = chunk_size;
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
-1,
(size64_t) -1 ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
}
else
{
/* Test: offset: <media_size - 1024> size: chunk_size
* Expected result: offset: <media_size - 1024> size: chunk size or media_size % chunk_size
*/
read_offset = (off64_t) ( media_size - 1024 );
read_size = chunk_size;
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
(off64_t) ( media_size - 1024 ),
( ( media_size % chunk_size ) == 0 ) ? chunk_size : media_size % chunk_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
if( ewf_test_read_write_chunk_at_offset(
handle,
chunk_size,
read_offset,
SEEK_SET,
read_size,
(off64_t) ( media_size - 1024 ),
( ( media_size % chunk_size ) == 0 ) ? chunk_size : media_size % chunk_size ) != 1 )
{
fprintf(
stderr,
"Unable to test read/write chunk.\n" );
goto on_error;
}
}
/* Clean up
*/
if( libewf_handle_close(
handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close file(s).\n" );
goto on_error;
}
if( libewf_handle_free(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free handle.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libewf_error_backtrace_fprint(
error,
stderr );
libewf_error_free(
&error );
}
if( handle != NULL )
{
libewf_handle_close(
handle,
NULL );
libewf_handle_free(
&handle,
NULL );
}
return( EXIT_FAILURE );
}
/* Opens the input of the mount handle
* Returns 1 if successful or -1 on error
*/
int mount_handle_open_input(
mount_handle_t *mount_handle,
libcstring_system_character_t * const * filenames,
int number_of_filenames,
libcerror_error_t **error )
{
libcstring_system_character_t **libewf_filenames = NULL;
static char *function = "mount_handle_open_input";
size_t first_filename_length = 0;
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
if( filenames == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filenames.",
function );
return( -1 );
}
if( number_of_filenames <= 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS,
"%s: invalid number of filenames.",
function );
return( -1 );
}
if( number_of_filenames == 1 )
{
first_filename_length = libcstring_system_string_length(
filenames[ 0 ] );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide(
filenames[ 0 ],
first_filename_length,
LIBEWF_FORMAT_UNKNOWN,
&libewf_filenames,
&number_of_filenames,
error ) != 1 )
#else
if( libewf_glob(
filenames[ 0 ],
first_filename_length,
LIBEWF_FORMAT_UNKNOWN,
&libewf_filenames,
&number_of_filenames,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to resolve filename(s).",
function );
return( -1 );
}
filenames = (libcstring_system_character_t * const *) libewf_filenames;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_open_wide(
mount_handle->input_handle,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
error ) != 1 )
#else
if( libewf_handle_open(
mount_handle->input_handle,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file(s).",
function );
if( libewf_filenames != NULL )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
libewf_glob_wide_free(
libewf_filenames,
number_of_filenames,
NULL );
#else
libewf_glob_free(
libewf_filenames,
number_of_filenames,
NULL );
#endif
}
return( -1 );
}
if( libewf_filenames != NULL )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide_free(
libewf_filenames,
number_of_filenames,
error ) != 1 )
#else
if( libewf_glob_free(
libewf_filenames,
number_of_filenames,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free globbed filenames.",
function );
return( -1 );
}
}
if( mount_handle->input_format == MOUNT_HANDLE_INPUT_FORMAT_FILES )
{
if( libewf_handle_get_root_file_entry(
mount_handle->input_handle,
&( mount_handle->root_file_entry ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve root file entry.",
function );
return( -1 );
}
}
return( 1 );
}
/* Determines the event log type from the filename
* Returns 1 if successful, 0 if unsupported value or -1 on error
*/
int evtxinput_determine_event_log_type_from_filename(
const libcstring_system_character_t *filename,
int *event_log_type,
libcerror_error_t **error )
{
const libcstring_system_character_t *path_separator = NULL;
static char *function = "evtxinput_determine_event_log_type_from_filename";
size_t filename_length = 0;
int result = 0;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
if( event_log_type == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid event log type.",
function );
return( -1 );
}
filename_length = libcstring_system_string_length(
filename );
path_separator = libcstring_system_string_search_character_reverse(
filename,
(libcstring_system_character_t) LIBCPATH_SEPARATOR,
filename_length );
if( path_separator == NULL )
{
path_separator = filename;
}
else
{
path_separator++;
filename_length = libcstring_system_string_length(
path_separator );
}
if( filename_length == 11 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "System.evtx" ),
11 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SYSTEM;
result = 1;
}
}
else if( filename_length == 13 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Security.evtx" ),
13 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SECURITY;
result = 1;
}
}
else if( filename_length == 16 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Application.evtx" ),
16 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_APPLICATION;
result = 1;
}
}
else if( filename_length == 17 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Media Center.evtx" ),
17 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_MEDIA_CENTER;
result = 1;
}
}
else if( filename_length == 19 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "HardwareEvents.evtx" ),
19 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_HARDWARE_EVENTS;
result = 1;
}
}
else if( filename_length == 20 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "DFS Replication.evtx" ),
20 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_DFS_REPLICATION;
result = 1;
}
}
else if( filename_length == 22 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Internet Explorer.evtx" ),
22 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_INTERNET_EXPLORER;
result = 1;
}
}
else if( filename_length == 27 )
{
if( libcstring_system_string_compare_no_case(
path_separator,
_LIBCSTRING_SYSTEM_STRING( "Key Management Service.evtx" ),
27 ) == 0 )
{
*event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_KEY_MANAGEMENT_SERVICE;
result = 1;
}
}
return( result );
}
/* Opens the info handle
* Returns 1 if successful, 0 if no VSS enabled volume was found or -1 on error
*/
int info_handle_open_input(
info_handle_t *info_handle,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
static char *function = "info_handle_open_input";
size_t filename_length = 0;
int result = 0;
if( info_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid info handle.",
function );
return( -1 );
}
filename_length = libcstring_system_string_length(
filename );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libbfio_file_range_set_name_wide(
info_handle->input_file_io_handle,
filename,
filename_length,
error ) != 1 )
#else
if( libbfio_file_range_set_name(
info_handle->input_file_io_handle,
filename,
filename_length,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open set file name.",
function );
return( -1 );
}
if( libbfio_file_range_set(
info_handle->input_file_io_handle,
info_handle->volume_offset,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open set volume offset.",
function );
return( -1 );
}
result = libvshadow_check_volume_signature_file_io_handle(
info_handle->input_file_io_handle,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if volume has a VSS signature.",
function );
return( -1 );
}
else if( result != 0 )
{
if( libvshadow_volume_open_file_io_handle(
info_handle->input_volume,
info_handle->input_file_io_handle,
LIBVSHADOW_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input volume.",
function );
return( -1 );
}
}
return( result );
}
int main( int argc, char * const argv[] )
#endif
{
#if !defined( HAVE_GLOB_H )
libcsystem_glob_t *glob = NULL;
#endif
libcerror_error_t *error = NULL;
libcstring_system_character_t * const *source_filenames = NULL;
libcstring_system_character_t **ewf_filenames = NULL;
libcstring_system_character_t *option_header_codepage = NULL;
libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "ewfdebug" );
libcstring_system_integer_t option = 0;
size_t first_filename_length = 0;
uint8_t verbose = 0;
int number_of_filenames = 0;
int header_codepage = LIBEWF_CODEPAGE_ASCII;
int result = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"ewftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "A:hqvV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 'A':
option_header_codepage = optarg;
break;
case (libcstring_system_integer_t) 'h':
ewfoutput_version_fprint(
stdout,
program );
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'q':
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
ewfoutput_version_fprint(
stdout,
program );
ewfoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Missing EWF image file(s).\n" );
usage_fprint(
stdout );
goto on_error;
}
ewfoutput_version_fprint(
stdout,
program );
libcnotify_verbose_set(
verbose );
#if !defined( HAVE_LOCAL_LIBEWF )
libewf_notify_set_verbose(
verbose );
libewf_notify_set_stream(
stderr,
NULL );
#endif
if( option_header_codepage != NULL )
{
if( ewfinput_determine_header_codepage(
option_header_codepage,
&header_codepage,
&error ) != 1 )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
fprintf(
stderr,
"Unsupported header codepage defaulting to: ascii.\n" );
header_codepage = LIBEWF_CODEPAGE_ASCII;
}
}
if( libcsystem_signal_attach(
ewfdebug_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_initialize(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize glob.\n" );
goto on_error;
}
if( libcsystem_glob_resolve(
glob,
&( argv[ optind ] ),
argc - optind,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to resolve glob.\n" );
goto on_error;
}
if( libcsystem_glob_get_results(
glob,
&number_of_filenames,
(libcstring_system_character_t ***) &source_filenames,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve glob results.\n" );
goto on_error;
}
#else
source_filenames = &( argv[ optind ] );
number_of_filenames = argc - optind;
#endif
if( number_of_filenames == 1 )
{
first_filename_length = libcstring_system_string_length(
source_filenames[ 0 ] );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide(
source_filenames[ 0 ],
first_filename_length,
LIBEWF_FORMAT_UNKNOWN,
&ewf_filenames,
&number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob(
source_filenames[ 0 ],
first_filename_length,
LIBEWF_FORMAT_UNKNOWN,
&ewf_filenames,
&number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to resolve ewf file(s).\n" );
goto on_error;
}
source_filenames = (libcstring_system_character_t * const *) ewf_filenames;
}
if( libewf_handle_initialize(
&ewfdebug_input_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize input handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libewf_handle_open_wide(
ewfdebug_input_handle,
source_filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error );
#else
result = libewf_handle_open(
ewfdebug_input_handle,
source_filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error );
#endif
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_free(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
#endif
if( ewf_filenames != NULL )
{
for( ; number_of_filenames > 0; number_of_filenames-- )
{
memory_free(
ewf_filenames[ number_of_filenames - 1 ] );
}
memory_free(
ewf_filenames );
}
if( ( ewfdebug_abort == 0 )
&& ( result != 1 ) )
{
fprintf(
stderr,
"Unable to open EWF file(s).\n" );
libewf_handle_close(
ewfdebug_input_handle,
NULL );
libewf_handle_free(
&ewfdebug_input_handle,
NULL );
return( EXIT_FAILURE );
}
/* TODO */
if( libewf_handle_close(
ewfdebug_input_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close EWF file(s).\n" );
libewf_handle_free(
&ewfdebug_input_handle,
NULL );
return( EXIT_FAILURE );
}
if( libewf_handle_free(
&ewfdebug_input_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free input handle.\n" );
return( EXIT_FAILURE );
}
if( libcsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( ewfdebug_abort != 0 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n",
program );
return( EXIT_FAILURE );
}
fprintf(
stdout,
"Debug completed.\n" );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
#if !defined( HAVE_GLOB_H )
if( glob != NULL )
{
libcsystem_glob_free(
&glob,
NULL );
}
#endif
return( EXIT_FAILURE );
}
/* Sets the target path
* Returns 1 if successful or -1 on error
*/
int export_handle_set_target_path(
export_handle_t *export_handle,
const libcstring_system_character_t *target_path,
libcerror_error_t **error )
{
static char *function = "export_handle_set_target_path";
size_t target_path_length = 0;
#if defined( WINAPI )
libcstring_system_character_t *full_target_path = NULL;
size_t full_target_path_size = 0;
int result = 0;
#endif
if( export_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid export handle.",
function );
return( -1 );
}
if( target_path == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid target path.",
function );
return( -1 );
}
if( export_handle->target_path != NULL )
{
memory_free(
export_handle->target_path );
export_handle->target_path = NULL;
export_handle->target_path_size = 0;
}
target_path_length = libcstring_system_string_length(
target_path );
#if defined( WINAPI )
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libcpath_path_get_full_path_wide(
target_path,
target_path_length,
&full_target_path,
&full_target_path_size,
error );
#else
result = libcpath_path_get_full_path(
target_path,
target_path_length,
&full_target_path,
&full_target_path_size,
error );
#endif
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create full target path.",
function );
goto on_error;
}
else if( result != 0 )
{
target_path = full_target_path;
target_path_length = full_target_path_size - 1;
}
#endif
if( target_path_length > 0 )
{
export_handle->target_path = libcstring_system_string_allocate(
target_path_length + 1 );
if( export_handle->target_path == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create target path.",
function );
goto on_error;
}
if( libcstring_system_string_copy(
export_handle->target_path,
target_path,
target_path_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy target path.",
function );
goto on_error;
}
( export_handle->target_path )[ target_path_length ] = 0;
export_handle->target_path_size = target_path_length + 1;
}
#if defined( WINAPI )
memory_free(
full_target_path );
full_target_path = NULL;
#endif
return( 1 );
on_error:
#if defined( WINAPI )
if( full_target_path != NULL )
{
memory_free(
full_target_path );
}
#endif
if( export_handle->target_path != NULL )
{
memory_free(
export_handle->target_path );
export_handle->target_path = NULL;
}
export_handle->target_path_size = 0;
return( -1 );
}