/* Determines if a file contains a BDE volume signature using a Basic File IO (bfio) handle
* Returns 1 if true, 0 if not or -1 on error
*/
int libbde_check_volume_signature_file_io_handle(
libbfio_handle_t *file_io_handle,
libcerror_error_t **error )
{
uint8_t signature[ 12 ];
static char *function = "libbde_check_volume_signature_file_io_handle";
ssize_t read_count = 0;
int file_io_handle_is_open = 0;
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
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 file.",
function );
return( -1 );
}
}
if( libbfio_handle_seek_offset(
file_io_handle,
0,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek file header offset: 0.",
function );
if( file_io_handle_is_open == 0 )
{
libbfio_handle_close(
file_io_handle,
error );
}
return( -1 );
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
signature,
12,
error );
if( read_count != 12 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read signature.",
function );
if( file_io_handle_is_open == 0 )
{
libbfio_handle_close(
file_io_handle,
error );
}
return( -1 );
}
if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_close(
file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file.",
function );
return( -1 );
}
}
if( memory_compare(
bde_signature,
&( signature[ 3 ] ),
8 ) == 0 )
{
return( 1 );
}
return( 0 );
}
/* Opens a file using a Basic File IO (bfio) handle
* Returns 1 if successful or -1 on error
*/
int libmsiecf_file_open_file_io_handle(
libmsiecf_file_t *file,
libbfio_handle_t *file_io_handle,
int access_flags,
libcerror_error_t **error )
{
libmsiecf_internal_file_t *internal_file = NULL;
static char *function = "libmsiecf_file_open_file_io_handle";
int bfio_access_flags = 0;
int file_io_handle_is_open = 0;
if( file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file.",
function );
return( -1 );
}
internal_file = (libmsiecf_internal_file_t *) file;
if( internal_file->file_io_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid file - file IO handle already set.",
function );
return( -1 );
}
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
if( ( ( access_flags & LIBMSIECF_ACCESS_FLAG_READ ) == 0 )
&& ( ( access_flags & LIBMSIECF_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 & LIBMSIECF_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( ( access_flags & LIBMSIECF_ACCESS_FLAG_READ ) != 0 )
{
bfio_access_flags = LIBBFIO_ACCESS_FLAG_READ;
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
goto on_error;
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
file_io_handle,
bfio_access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file IO handle.",
function );
goto on_error;
}
internal_file->file_io_handle_opened_in_library = 1;
}
internal_file->file_io_handle = file_io_handle;
if( libmsiecf_file_open_read(
internal_file,
file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( ( file_io_handle_is_open == 0 )
&& ( internal_file->file_io_handle_opened_in_library != 0 ) )
{
libbfio_handle_close(
file_io_handle,
error );
}
internal_file->file_io_handle = NULL;
return( -1 );
}
/* Determines if a file is a Windows Event Log file (check for the EVT file signature) using a Basic File IO (bfio) handle
* Returns 1 if true, 0 if not or -1 on error
*/
int libevt_check_file_signature_file_io_handle(
libbfio_handle_t *file_io_handle,
libcerror_error_t **error )
{
uint8_t signature[ 8 ];
static char *function = "libevt_check_file_signature_file_io_handle";
ssize_t read_count = 0;
int file_io_handle_is_open = 0;
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
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 file.",
function );
return( -1 );
}
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
signature,
8,
error );
if( read_count != 8 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read signature.",
function );
libbfio_handle_close(
file_io_handle,
NULL );
return( -1 );
}
if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_close(
file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file.",
function );
return( -1 );
}
}
if( memory_compare(
evt_file_signature,
&( signature[ 4 ] ),
4 ) == 0 )
{
return( 1 );
}
return( 0 );
}
/* 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 );
}
/* Creates a file IO handle for test data
* Returns 1 if successful or -1 on error
*/
int agdb_test_open_file_io_handle(
libbfio_handle_t **file_io_handle,
uint8_t *data,
size_t data_size,
libcerror_error_t **error )
{
static char *function = "agdb_test_open_file_io_handle";
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
if( libbfio_memory_range_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_memory_range_set(
*file_io_handle,
data,
data_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set memory range of file IO handle.",
function );
goto on_error;
}
if( libbfio_handle_open(
*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 file IO handle.",
function );
goto on_error;
}
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 );
}
/* Opens the handle
* Returns 1 if successful or -1 on error
*/
int libbfio_pool_open_handle(
libbfio_internal_pool_t *internal_pool,
libbfio_handle_t *handle,
int flags,
liberror_error_t **error )
{
static char *function = "libbfio_pool_open_handle";
int is_open = 0;
if( internal_pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
if( internal_pool->last_used_list == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid pool - missing last used list.",
function );
return( -1 );
}
if( handle == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid handle.",
function );
return( -1 );
}
is_open = libbfio_handle_is_open(
handle,
error );
if( is_open == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if handle is open.",
function );
return( -1 );
}
else if( is_open == 1 )
{
return( 1 );
}
if( internal_pool->maximum_amount_of_open_handles != LIBBFIO_POOL_UNLIMITED_AMOUNT_OF_OPEN_HANDLES )
{
if( libbfio_pool_add_handle_to_last_used_list(
internal_pool,
handle,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append handle to last used list.",
function );
return( -1 );
}
}
if( libbfio_handle_open(
handle,
flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open handle.",
function );
return( -1 );
}
return( 1 );
}
/* Opens a volume using a Basic File IO (bfio) handle
* Returns 1 if successful or -1 on error
*/
int libvshadow_volume_open_file_io_handle(
libvshadow_volume_t *volume,
libbfio_handle_t *file_io_handle,
int access_flags,
libcerror_error_t **error )
{
libvshadow_internal_volume_t *internal_volume = NULL;
static char *function = "libvshadow_volume_open_file_io_handle";
int bfio_access_flags = 0;
int file_io_handle_is_open = 0;
int file_io_handle_opened_in_library = 0;
if( volume == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid volume.",
function );
return( -1 );
}
internal_volume = (libvshadow_internal_volume_t *) volume;
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
if( ( ( access_flags & LIBVSHADOW_ACCESS_FLAG_READ ) == 0 )
&& ( ( access_flags & LIBVSHADOW_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 & LIBVSHADOW_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( ( access_flags & LIBVSHADOW_ACCESS_FLAG_READ ) != 0 )
{
bfio_access_flags = LIBBFIO_ACCESS_FLAG_READ;
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to determine if file IO handle is open.",
function );
goto on_error;
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
file_io_handle,
bfio_access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file IO handle.",
function );
goto on_error;
}
file_io_handle_opened_in_library = 1;
}
if( libvshadow_volume_open_read(
internal_volume,
file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file IO handle.",
function );
goto on_error;
}
#if defined( HAVE_LIBVSHADOW_MULTI_THREAD_SUPPORT )
if( libcthreads_read_write_lock_grab_for_write(
internal_volume->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to grab read/write lock for writing.",
function );
return( -1 );
}
#endif
internal_volume->file_io_handle = file_io_handle;
internal_volume->file_io_handle_opened_in_library = file_io_handle_opened_in_library;
#if defined( HAVE_LIBVSHADOW_MULTI_THREAD_SUPPORT )
if( libcthreads_read_write_lock_release_for_write(
internal_volume->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to release read/write lock for writing.",
function );
return( -1 );
}
#endif
return( 1 );
on_error:
if( file_io_handle_opened_in_library != 0 )
{
libbfio_handle_close(
file_io_handle,
NULL );
}
return( -1 );
}
/* Determines if a file contains an EWF file signature using a Basic File IO (bfio) handle
* Returns 1 if true, 0 if not or -1 on error
*/
int libewf_check_file_signature_file_io_handle(
libbfio_handle_t *file_io_handle,
libcerror_error_t **error )
{
uint8_t signature[ 8 ];
static char *function = "libewf_check_file_signature_file_io_handle";
ssize_t read_count = 0;
int file_io_handle_is_open = 0;
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
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 file.",
function );
return( -1 );
}
}
if( libbfio_handle_seek_offset(
file_io_handle,
0,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek file header offset: 0.",
function );
if( file_io_handle_is_open == 0 )
{
libbfio_handle_close(
file_io_handle,
error );
}
return( -1 );
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
signature,
8,
error );
if( read_count != 8 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read signature.",
function );
libbfio_handle_close(
file_io_handle,
NULL );
return( -1 );
}
if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_close(
file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file.",
function );
return( -1 );
}
}
/* The number of EWF segment files will be the largest
*/
if( memory_compare(
ewf1_evf_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
else if( memory_compare(
ewf1_lvf_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
else if( memory_compare(
ewf2_evf_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
else if( memory_compare(
ewf2_lef_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
else if( memory_compare(
ewf1_dvf_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
return( 0 );
}
