/* Globs the segment files according to the EWF naming schema
* if format is known the filename should contain the base of the filename
* otherwise the function will try to determine the format based on the extension
* Returns 1 if successful or -1 on error
*/
int libewf_glob_wide(
const wchar_t *filename,
size_t filename_length,
uint8_t format,
wchar_t **filenames[],
int *number_of_filenames,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
wchar_t *segment_filename = NULL;
void *reallocation = NULL;
static char *function = "libewf_glob_wide";
size_t additional_length = 4;
size_t segment_filename_length = 0;
int result = 0;
uint8_t segment_file_type = 0;
uint8_t ewf_format = 0;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
if( ( filename_length == 0 )
|| ( filename_length > (size_t) SSIZE_MAX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid filename length.",
function );
return( -1 );
}
if( ( format != LIBEWF_FORMAT_UNKNOWN )
&& ( format != LIBEWF_FORMAT_ENCASE1 )
&& ( format != LIBEWF_FORMAT_ENCASE2 )
&& ( format != LIBEWF_FORMAT_ENCASE3 )
&& ( format != LIBEWF_FORMAT_ENCASE4 )
&& ( format != LIBEWF_FORMAT_ENCASE5 )
&& ( format != LIBEWF_FORMAT_ENCASE6 )
&& ( format != LIBEWF_FORMAT_LINEN5 )
&& ( format != LIBEWF_FORMAT_LINEN6 )
&& ( format != LIBEWF_FORMAT_SMART )
&& ( format != LIBEWF_FORMAT_FTK )
&& ( format != LIBEWF_FORMAT_LVF )
&& ( format != LIBEWF_FORMAT_EWF )
&& ( format != LIBEWF_FORMAT_EWFX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported format.",
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 == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid number of filenames.",
function );
return( -1 );
}
if( format == LIBEWF_FORMAT_UNKNOWN )
{
if( filename[ filename_length - 4 ] != (wchar_t) '.' )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - missing extension.",
function );
return( -1 );
}
additional_length = 0;
if( filename[ filename_length - 3 ] == (wchar_t) 'E' )
{
format = LIBEWF_FORMAT_ENCASE5;
}
else if( filename[ filename_length - 3 ] == (wchar_t) 'e' )
{
format = LIBEWF_FORMAT_EWF;
}
else if( filename[ filename_length - 3 ] == (wchar_t) 'L' )
{
format = LIBEWF_FORMAT_LVF;
}
else if( filename[ filename_length - 3 ] == (wchar_t) 's' )
{
format = LIBEWF_FORMAT_SMART;
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - unsupported extension: %s.",
function,
&( filename[ filename_length - 4 ] ) );
return( -1 );
}
}
if( format == LIBEWF_FORMAT_LVF )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_LWF;
ewf_format = EWF_FORMAT_L01;
}
else if( format == LIBEWF_FORMAT_SMART )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF;
ewf_format = EWF_FORMAT_S01;
}
else
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF;
ewf_format = EWF_FORMAT_E01;
}
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle.",
function );
goto on_error;
}
*number_of_filenames = 0;
while( *number_of_filenames < (int) UINT16_MAX )
{
segment_filename_length = filename_length + additional_length;
segment_filename = (wchar_t *) memory_allocate(
sizeof( wchar_t ) * ( segment_filename_length + 1 ) );
if( segment_filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create segment filename.",
function );
goto on_error;
}
if( libcstring_wide_string_copy(
segment_filename,
filename,
filename_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy filename.",
function );
goto on_error;
}
if( additional_length > 0 )
{
segment_filename[ filename_length ] = (wchar_t) '.';
}
if( libewf_filename_set_extension_wide(
&( segment_filename[ segment_filename_length - 3 ] ),
(uint16_t) ( *number_of_filenames + 1 ),
UINT16_MAX,
segment_file_type,
format,
ewf_format,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set extension.",
function );
goto on_error;
}
segment_filename[ segment_filename_length ] = 0;
if( libbfio_file_set_name_wide(
file_io_handle,
segment_filename,
segment_filename_length,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set name in file IO handle.",
function );
goto on_error;
}
result = libbfio_handle_exists(
file_io_handle,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_GENERIC,
"%s: unable to test if file exists.",
function );
goto on_error;
}
else if( result == 0 )
{
memory_free(
segment_filename );
break;
}
*number_of_filenames += 1;
reallocation = memory_reallocate(
*filenames,
sizeof( wchar_t * ) * *number_of_filenames );
if( reallocation == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize filenames.",
function );
goto on_error;
}
*filenames = (wchar_t **) reallocation;
( *filenames )[ *number_of_filenames - 1 ] = segment_filename;
}
if( libbfio_handle_free(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free file IO handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( segment_filename != NULL )
{
memory_free(
segment_filename );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
/* Determines if a file is a Windows Event Log file (check for the EVT file signature)
* Returns 1 if true, 0 if not or -1 on error
*/
int libevt_check_file_signature(
const char *filename,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
static char *function = "libevt_check_file_signature";
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 );
}
filename_length = libcstring_narrow_string_length(
filename );
if( filename_length == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
goto on_error;
}
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle.",
function );
goto on_error;
}
if( libbfio_file_set_name(
file_io_handle,
filename,
filename_length,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set filename in file IO handle.",
function );
goto on_error;
}
result = libevt_check_file_signature_file_io_handle(
file_io_handle,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to check file signature using a file handle.",
function );
goto on_error;
}
if( libbfio_handle_free(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to free file IO handle.",
function );
goto on_error;
}
return( result );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
/* Appends file handles to the pool for the corresponding filenames
* Returns 1 if successful or -1 on error
*/
int libbfio_file_pool_append_handles_for_names(
libbfio_pool_t *pool,
char * const names[],
int number_of_names,
int access_flags,
liberror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
static char *function = "libbfio_file_pool_append_handles_for_names";
size_t name_length = 0;
int pool_entry = 0;
int name_iterator = 0;
if( pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
if( names == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid names.",
function );
return( -1 );
}
if( number_of_names <= 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS,
"%s: invalid number of names zero or less.",
function );
return( -1 );
}
for( name_iterator = 0;
name_iterator < number_of_names;
name_iterator++ )
{
name_length = libcstring_narrow_string_length(
names[ name_iterator ] );
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle: %d.",
function,
name_iterator );
return( -1 );
}
if( libbfio_file_set_name(
file_io_handle,
names[ name_iterator ],
name_length + 1,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set name in file IO handle: %d.",
function,
name_iterator );
libbfio_handle_free(
&file_io_handle,
NULL );
return( -1 );
}
if( libbfio_pool_append_handle(
pool,
&pool_entry,
file_io_handle,
access_flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append file IO handle: %d to pool.",
function,
name_iterator );
libbfio_handle_free(
&file_io_handle,
NULL );
return( -1 );
}
file_io_handle = NULL;
}
return( 1 );
}
/* Opens a volume
* Returns 1 if successful or -1 on error
*/
int libfshfs_volume_open_wide(
libfshfs_volume_t *volume,
const wchar_t *filename,
int access_flags,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
libfshfs_internal_volume_t *internal_volume = NULL;
static char *function = "libfshfs_volume_open_wide";
if( volume == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid volume.",
function );
return( -1 );
}
internal_volume = (libfshfs_internal_volume_t *) volume;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
if( ( ( access_flags & LIBFSHFS_ACCESS_FLAG_READ ) == 0 )
&& ( ( access_flags & LIBFSHFS_ACCESS_FLAG_WRITE ) == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported access flags.",
function );
return( -1 );
}
if( ( access_flags & LIBFSHFS_ACCESS_FLAG_WRITE ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: write access currently not supported.",
function );
return( -1 );
}
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libbfio_handle_set_track_offsets_read(
file_io_handle,
1,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set track offsets read in file IO handle.",
function );
goto on_error;
}
#endif
if( libbfio_file_set_name_wide(
file_io_handle,
filename,
libcstring_wide_string_length(
filename ) + 1,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set filename in file IO handle.",
function );
goto on_error;
}
if( libfshfs_volume_open_file_io_handle(
volume,
file_io_handle,
access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open volume: %ls.",
function,
filename );
goto on_error;
}
internal_volume->file_io_handle_created_in_library = 1;
return( 1 );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
/* Tests the libesedb_check_file_signature_file_io_handle function
* Returns 1 if successful or 0 if not
*/
int esedb_test_check_file_signature_file_io_handle(
const system_character_t *source )
{
uint8_t empty_block[ 8192 ];
libbfio_handle_t *file_io_handle = NULL;
libcerror_error_t *error = NULL;
void *memset_result = NULL;
size_t source_length = 0;
int result = 0;
/* Initialize test
*/
memset_result = memory_set(
empty_block,
0,
sizeof( uint8_t ) * 8192 );
ESEDB_TEST_ASSERT_IS_NOT_NULL(
"memset_result",
memset_result );
if( source != NULL )
{
/* Initialize test
*/
result = libbfio_file_initialize(
&file_io_handle,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
source_length = system_string_length(
source );
#if defined( HAVE_WIDE_SYSTEM_CHARACTER )
result = libbfio_file_set_name_wide(
file_io_handle,
source,
source_length,
&error );
#else
result = libbfio_file_set_name(
file_io_handle,
source,
source_length,
&error );
#endif
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
result = libbfio_handle_open(
file_io_handle,
LIBBFIO_OPEN_READ,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test check file signature
*/
result = libesedb_check_file_signature_file_io_handle(
file_io_handle,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
}
/* Test error cases
*/
result = libesedb_check_file_signature_file_io_handle(
NULL,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
ESEDB_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Clean up
*/
if( source != NULL )
{
result = libbfio_handle_close(
file_io_handle,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
result = libbfio_handle_free(
&file_io_handle,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NULL(
"file_io_handle",
file_io_handle );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
}
/* Test check file signature with data too small
*/
result = esedb_test_open_file_io_handle(
&file_io_handle,
empty_block,
sizeof( uint8_t ) * 1,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
result = libesedb_check_file_signature_file_io_handle(
file_io_handle,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
ESEDB_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = esedb_test_close_file_io_handle(
&file_io_handle,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test check file signature with empty block
*/
result = esedb_test_open_file_io_handle(
&file_io_handle,
empty_block,
sizeof( uint8_t ) * 8192,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
result = libesedb_check_file_signature_file_io_handle(
file_io_handle,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
result = esedb_test_close_file_io_handle(
&file_io_handle,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( 0 );
}
/* Globs the segment files according to the EWF naming schema
* Make sure the value filenames is referencing, is set to NULL
*
* If the format is known the filename should contain the base of the filename
* otherwise the function will try to determine the format based on the extension
* Returns 1 if successful or -1 on error
*/
int libewf_glob(
const char *filename,
size_t filename_length,
uint8_t format,
char **filenames[],
int *number_of_filenames,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
char *segment_filename = NULL;
void *reallocation = NULL;
static char *function = "libewf_glob";
size_t additional_length = 0;
size_t segment_extention_length = 0;
size_t segment_filename_index = 0;
size_t segment_filename_length = 0;
uint8_t segment_file_type = 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( ( filename_length == 0 )
|| ( filename_length > (size_t) SSIZE_MAX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid filename length value out of bounds.",
function );
return( -1 );
}
if( ( format != LIBEWF_FORMAT_UNKNOWN )
&& ( format != LIBEWF_FORMAT_ENCASE1 )
&& ( format != LIBEWF_FORMAT_ENCASE2 )
&& ( format != LIBEWF_FORMAT_ENCASE3 )
&& ( format != LIBEWF_FORMAT_ENCASE4 )
&& ( format != LIBEWF_FORMAT_ENCASE5 )
&& ( format != LIBEWF_FORMAT_ENCASE6 )
&& ( format != LIBEWF_FORMAT_LINEN5 )
&& ( format != LIBEWF_FORMAT_LINEN6 )
&& ( format != LIBEWF_FORMAT_SMART )
&& ( format != LIBEWF_FORMAT_FTK_IMAGER )
&& ( format != LIBEWF_FORMAT_LOGICAL_ENCASE5 )
&& ( format != LIBEWF_FORMAT_LOGICAL_ENCASE6 )
&& ( format != LIBEWF_FORMAT_LOGICAL_ENCASE7 )
&& ( format != LIBEWF_FORMAT_V2_ENCASE7 )
&& ( format != LIBEWF_FORMAT_V2_LOGICAL_ENCASE7 )
&& ( format != LIBEWF_FORMAT_EWF )
&& ( format != LIBEWF_FORMAT_EWFX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported format.",
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( *filenames != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid filenames value already set.",
function );
return( -1 );
}
if( number_of_filenames == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid number of filenames.",
function );
return( -1 );
}
if( format == LIBEWF_FORMAT_UNKNOWN )
{
if( ( filename_length > 4 )
&& ( filename[ filename_length - 4 ] == '.' ) )
{
if( filename[ filename_length - 3 ] == 'E' )
{
format = LIBEWF_FORMAT_ENCASE5;
}
else if( filename[ filename_length - 3 ] == 'e' )
{
format = LIBEWF_FORMAT_EWF;
}
else if( filename[ filename_length - 3 ] == 'L' )
{
format = LIBEWF_FORMAT_LOGICAL_ENCASE5;
}
else if( filename[ filename_length - 3 ] == 's' )
{
format = LIBEWF_FORMAT_SMART;
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - unsupported extension: %s.",
function,
&( filename[ filename_length - 4 ] ) );
return( -1 );
}
segment_extention_length = 4;
}
else if( ( filename_length > 5 )
&& ( filename[ filename_length - 5 ] == '.' ) )
{
if( filename[ filename_length - 4 ] == 'E' )
{
format = LIBEWF_FORMAT_V2_ENCASE7;
}
else if( filename[ filename_length - 4 ] == 'L' )
{
format = LIBEWF_FORMAT_V2_LOGICAL_ENCASE7;
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - unsupported extension: %s.",
function,
&( filename[ filename_length - 5 ] ) );
return( -1 );
}
if( filename[ filename_length - 3 ] != 'x' )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - unsupported extension: %s.",
function,
&( filename[ filename_length - 5 ] ) );
return( -1 );
}
segment_extention_length = 5;
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - missing extension.",
function );
return( -1 );
}
}
else
{
additional_length = 4;
}
if( segment_file_type == 0 )
{
if( ( format == LIBEWF_FORMAT_LOGICAL_ENCASE5 )
|| ( format == LIBEWF_FORMAT_LOGICAL_ENCASE6 )
|| ( format == LIBEWF_FORMAT_LOGICAL_ENCASE7 ) )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF1_LOGICAL;
}
else if( format == LIBEWF_FORMAT_SMART )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF1_SMART;
}
else if( format == LIBEWF_FORMAT_V2_ENCASE7 )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF2;
}
else if( format == LIBEWF_FORMAT_V2_LOGICAL_ENCASE7 )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF2_LOGICAL;
}
else
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF1;
}
}
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle.",
function );
goto on_error;
}
*number_of_filenames = 0;
while( *number_of_filenames < (int) UINT16_MAX )
{
segment_filename_length = filename_length + additional_length;
segment_filename = (char *) memory_allocate(
sizeof( char ) * ( segment_filename_length + 1 ) );
if( segment_filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create segment filename.",
function );
goto on_error;
}
if( libcstring_narrow_string_copy(
segment_filename,
filename,
filename_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy filename.",
function );
goto on_error;
}
if( additional_length == 0 )
{
segment_filename_index = segment_filename_length - segment_extention_length;
}
else
{
segment_filename_index = filename_length;
}
segment_filename[ segment_filename_index++ ] = '.';
if( libewf_filename_set_extension(
segment_filename,
segment_filename_length + 1,
&segment_filename_index,
(uint32_t) ( *number_of_filenames + 1 ),
(uint32_t) UINT16_MAX,
segment_file_type,
format,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set extension.",
function );
goto on_error;
}
/* The libewf_filename_set_extension also adds the end-of-string character */
if( libbfio_file_set_name(
file_io_handle,
segment_filename,
segment_filename_length,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set name in file IO handle.",
function );
goto on_error;
}
result = libbfio_handle_exists(
file_io_handle,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_GENERIC,
"%s: unable to test if file exists.",
function );
goto on_error;
}
else if( result == 0 )
{
memory_free(
segment_filename );
break;
}
*number_of_filenames += 1;
reallocation = memory_reallocate(
*filenames,
sizeof( char * ) * *number_of_filenames );
if( reallocation == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize filenames.",
function );
goto on_error;
}
*filenames = (char **) reallocation;
( *filenames )[ *number_of_filenames - 1 ] = segment_filename;
}
if( libbfio_handle_free(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free file IO handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( segment_filename != NULL )
{
memory_free(
segment_filename );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
/* Opens a stream
* Returns 1 if successful or -1 on error
*/
int libwrc_stream_open(
libwrc_stream_t *stream,
const char *filename,
int access_flags,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
libwrc_internal_stream_t *internal_stream = NULL;
static char *function = "libwrc_stream_open";
size_t filename_length = 0;
if( stream == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid stream.",
function );
return( -1 );
}
internal_stream = (libwrc_internal_stream_t *) stream;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
if( ( ( access_flags & LIBWRC_ACCESS_FLAG_READ ) == 0 )
&& ( ( access_flags & LIBWRC_ACCESS_FLAG_WRITE ) == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported access flags.",
function );
return( -1 );
}
if( ( access_flags & LIBWRC_ACCESS_FLAG_WRITE ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: write access currently not supported.",
function );
return( -1 );
}
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libbfio_handle_set_track_offsets_read(
file_io_handle,
1,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set track offsets read in file IO handle.",
function );
goto on_error;
}
#endif
filename_length = narrow_string_length(
filename );
if( libbfio_file_set_name(
file_io_handle,
filename,
filename_length + 1,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set filename in file IO handle.",
function );
goto on_error;
}
if( libwrc_stream_open_file_io_handle(
stream,
file_io_handle,
access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open stream: %s.",
function,
filename );
goto on_error;
}
internal_stream->file_io_handle_created_in_library = 1;
return( 1 );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
