/* Frees a wipekey handle
* Returns 1 if successful or -1 on error
*/
int wipekey_handle_free(
wipekey_handle_t **wipekey_handle,
libcerror_error_t **error )
{
static char *function = "wipekey_handle_free";
int result = 1;
if( wipekey_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid wipekey handle.",
function );
return( -1 );
}
if( *wipekey_handle != NULL )
{
if( ( *wipekey_handle )->encrypted_root_plist != NULL )
{
if( libfvde_encryption_context_plist_free(
&( ( *wipekey_handle )->encrypted_root_plist ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free encrypted root plist.",
function );
result = -1;
}
}
if( libbfio_handle_free(
&( ( *wipekey_handle )->input_file_io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free input file IO handle.",
function );
result = -1;
}
memory_free(
*wipekey_handle );
*wipekey_handle = NULL;
}
return( result );
}
/* Frees an info handle
* Returns 1 if successful or -1 on error
*/
int info_handle_free(
info_handle_t **info_handle,
libcerror_error_t **error )
{
static char *function = "info_handle_free";
int result = 1;
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( *info_handle != NULL )
{
if( libvshadow_volume_free(
&( ( *info_handle )->input_volume ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free input volume.",
function );
result = -1;
}
if( libbfio_handle_free(
&( ( *info_handle )->input_file_io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free input file IO handle.",
function );
result = -1;
}
memory_free(
*info_handle );
*info_handle = NULL;
}
return( result );
}
/* Closes a file IO handle for test data
* Returns 0 if successful or -1 on error
*/
int agdb_test_close_file_io_handle(
libbfio_handle_t **file_io_handle,
libcerror_error_t **error )
{
static char *function = "agdb_test_close_file_io_handle";
int result = 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 );
}
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 IO handle.",
function );
result = -1;
}
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 );
result = -1;
}
return( result );
}
/* 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 );
}
/* 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 );
}
/* Determines if a file contains a BDE volume signature
* Returns 1 if true, 0 if not or -1 on error
*/
int libbde_check_volume_signature_wide(
const wchar_t *filename,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
static char *function = "libbde_check_volume_signature_wide";
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_wide_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_wide(
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 = libbde_check_volume_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 volume 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 );
}
/* Opens a file
* Returns 1 if successful or -1 on error
*/
int libmsiecf_file_open_wide(
libmsiecf_file_t *file,
const wchar_t *filename,
int access_flags,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
libmsiecf_internal_file_t *internal_file = NULL;
static char *function = "libmsiecf_file_open_wide";
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( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
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( 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( libmsiecf_file_open_file_io_handle(
file,
file_io_handle,
access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file: %ls.",
function,
filename );
goto on_error;
}
internal_file->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 );
}
/* Checks if the file has a Windows Event Log (EWF) file signature using a file-like object
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_check_file_signature_file_object(
PyObject *self,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
libbfio_handle_t *file_io_handle = NULL;
PyObject *file_object = NULL;
static char *function = "pyewf_check_file_signature_file_object";
static char *keyword_list[] = { "file_object", NULL };
int result = 0;
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"|O",
keyword_list,
&file_object ) == 0 )
{
return( NULL );
}
if( pyewf_file_object_initialize(
&file_io_handle,
file_object,
&error ) != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to initialize file IO handle.",
function );
}
else
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to initialize file IO handle.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_check_file_signature_file_io_handle(
file_io_handle,
&error );
Py_END_ALLOW_THREADS
if( result == -1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to check file signature.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to check file signature.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
if( libbfio_handle_free(
&file_io_handle,
&error ) != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free file IO handle.",
function );
}
else
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free file IO handle.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
if( result != 0 )
{
return( Py_True );
}
return( Py_False );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( NULL );
}
/* Opens a file
* Returns 1 if successful or -1 on error
*/
int libolecf_file_open(
libolecf_file_t *file,
const char *filename,
int access_flags,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
libolecf_internal_file_t *internal_file = NULL;
static char *function = "libolecf_file_open";
if( file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file.",
function );
return( -1 );
}
internal_file = (libolecf_internal_file_t *) file;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
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(
file_io_handle,
filename,
libcstring_narrow_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( libolecf_file_open_file_io_handle(
file,
file_io_handle,
access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file: %s.",
function,
filename );
goto on_error;
}
internal_file->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_file_header_read_file_io_handle function
* Returns 1 if successful or 0 if not
*/
int esedb_test_file_header_read_file_io_handle(
void )
{
libbfio_handle_t *file_io_handle = NULL;
libcerror_error_t *error = NULL;
libesedb_file_header_t *file_header = NULL;
int result = 0;
/* Initialize test
*/
result = libesedb_file_header_initialize(
&file_header,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NOT_NULL(
"file_header",
file_header );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
/* Initialize file IO handle
*/
result = esedb_test_open_file_io_handle(
&file_io_handle,
esedb_test_file_header_data1,
668,
&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 );
/* Test regular cases
*/
result = libesedb_file_header_read_file_io_handle(
file_header,
file_io_handle,
0,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libesedb_file_header_read_file_io_handle(
NULL,
file_io_handle,
0,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
ESEDB_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libesedb_file_header_read_file_io_handle(
file_header,
NULL,
0,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
ESEDB_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Clean up file IO handle
*/
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 data too small
*/
result = esedb_test_open_file_io_handle(
&file_io_handle,
esedb_test_file_header_data1,
8,
&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_file_header_read_file_io_handle(
file_header,
file_io_handle,
0,
&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 data invalid
*/
result = esedb_test_open_file_io_handle(
&file_io_handle,
esedb_test_file_header_error_data1,
668,
&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_file_header_read_file_io_handle(
file_header,
file_io_handle,
0,
&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 );
/* Clean up
*/
result = libesedb_file_header_free(
&file_header,
&error );
ESEDB_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
ESEDB_TEST_ASSERT_IS_NULL(
"file_header",
file_header );
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 );
}
if( file_header != NULL )
{
libesedb_file_header_free(
&file_header,
NULL );
}
return( 0 );
}
/* Closes a handle
* Returns 0 if successful or -1 on error
*/
int libvsmbr_handle_close(
libvsmbr_handle_t *handle,
libcerror_error_t **error )
{
libvsmbr_internal_handle_t *internal_handle = NULL;
static char *function = "libvsmbr_handle_close";
int result = 0;
if( handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid handle.",
function );
return( -1 );
}
internal_handle = (libvsmbr_internal_handle_t *) handle;
if( internal_handle->file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid handle - missing file IO handle.",
function );
return( -1 );
}
if( internal_handle->file_io_handle_created_in_library != 0 )
{
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
if( libvsmbr_debug_print_read_offsets(
internal_handle->file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print the read offsets.",
function );
result = -1;
}
}
#endif
if( libbfio_handle_close(
internal_handle->file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file IO handle.",
function );
result = -1;
}
if( libbfio_handle_free(
&( internal_handle->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 );
result = -1;
}
}
internal_handle->file_io_handle = NULL;
internal_handle->file_io_handle_created_in_library = 0;
if( libcdata_array_empty(
internal_handle->partitions_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libvsmbr_partition_values_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to empty the partitions array.",
function );
result = -1;
}
if( libcdata_array_empty(
internal_handle->sections_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libvsmbr_section_values_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to empty the sections array.",
function );
result = -1;
}
return( result );
}
/* 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 );
}
/* Tests the libpff_allocation_table_read_file_io_handle function
* Returns 1 if successful or 0 if not
*/
int pff_test_allocation_table_read_file_io_handle(
void )
{
libbfio_handle_t *file_io_handle = NULL;
libcdata_range_list_t *unallocated_block_list = NULL;
libcerror_error_t *error = NULL;
int result = 0;
/* Initialize test
*/
result = libcdata_range_list_initialize(
&unallocated_block_list,
&error );
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
PFF_TEST_ASSERT_IS_NOT_NULL(
"unallocated_block_list",
unallocated_block_list );
PFF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Initialize file IO handle
*/
result = pff_test_open_file_io_handle(
&file_io_handle,
pff_test_allocation_table_data_32bit,
512,
&error );
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
PFF_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
PFF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test regular cases
*/
result = libpff_allocation_table_read_file_io_handle(
unallocated_block_list,
file_io_handle,
0,
LIBPFF_FILE_TYPE_32BIT,
&error );
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
PFF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libpff_allocation_table_read_file_io_handle(
NULL,
file_io_handle,
0,
LIBPFF_FILE_TYPE_32BIT,
&error );
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
PFF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libpff_allocation_table_read_file_io_handle(
unallocated_block_list,
NULL,
0,
LIBPFF_FILE_TYPE_32BIT,
&error );
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
PFF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libpff_allocation_table_read_file_io_handle(
unallocated_block_list,
file_io_handle,
-1,
LIBPFF_FILE_TYPE_32BIT,
&error );
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
PFF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libpff_allocation_table_read_file_io_handle(
unallocated_block_list,
file_io_handle,
0,
0xff,
&error );
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
PFF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
#if defined( HAVE_PFF_TEST_MEMORY )
/* Test libpff_allocation_table_read_file_io_handle with malloc failing
*/
pff_test_malloc_attempts_before_fail = 0;
result = libpff_allocation_table_read_file_io_handle(
unallocated_block_list,
file_io_handle,
0,
LIBPFF_FILE_TYPE_32BIT,
&error );
if( pff_test_malloc_attempts_before_fail != -1 )
{
pff_test_malloc_attempts_before_fail = -1;
}
else
{
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
PFF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
#endif /* defined( HAVE_PFF_TEST_MEMORY ) */
/* Clean up file IO handle
*/
result = pff_test_close_file_io_handle(
&file_io_handle,
&error );
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
PFF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Clean up
*/
result = libcdata_range_list_free(
&unallocated_block_list,
NULL,
&error );
PFF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
PFF_TEST_ASSERT_IS_NULL(
"unallocated_block_list",
unallocated_block_list );
PFF_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 );
}
if( unallocated_block_list != NULL )
{
libcdata_range_list_free(
&unallocated_block_list,
NULL,
NULL );
}
return( 0 );
}
/* Frees the pool including elements
* Returns 1 if successful or -1 on error
*/
int libbfio_pool_free(
libbfio_pool_t **pool,
liberror_error_t **error )
{
libbfio_internal_pool_t *internal_pool = NULL;
static char *function = "libbfio_pool_free";
int handle_iterator = 0;
int result = 1;
if( pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
if( *pool != NULL )
{
internal_pool = (libbfio_internal_pool_t *) *pool;
if( internal_pool->handles != NULL )
{
for( handle_iterator = 0; handle_iterator < internal_pool->amount_of_handles; handle_iterator++ )
{
if( ( internal_pool->handles[ handle_iterator ] != NULL )
&& ( libbfio_handle_free(
&( internal_pool->handles[ handle_iterator ] ),
error ) != 1 ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to free handle: %d.",
function,
handle_iterator );
result = -1;
}
}
memory_free(
internal_pool->handles );
}
if( ( internal_pool->last_used_list != NULL )
&& ( libbfio_list_free(
&( internal_pool->last_used_list ),
NULL,
error ) != 1 ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free last used list.",
function );
result = -1;
}
memory_free(
internal_pool );
*pool = NULL;
}
return( result );
}
/* Closes a volume
* Returns 0 if successful or -1 on error
*/
int libvshadow_volume_close(
libvshadow_volume_t *volume,
libcerror_error_t **error )
{
libvshadow_internal_volume_t *internal_volume = NULL;
static char *function = "libvshadow_volume_close";
int result = 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( internal_volume->io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid volume - missing IO handle.",
function );
return( -1 );
}
#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
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
if( internal_volume->file_io_handle_created_in_library != 0 )
{
if( libvshadow_debug_print_read_offsets(
internal_volume->file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print the read offsets.",
function );
}
}
}
#endif
if( internal_volume->file_io_handle_opened_in_library != 0 )
{
if( libbfio_handle_close(
internal_volume->file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file IO handle.",
function );
result = -1;
}
internal_volume->file_io_handle_opened_in_library = 0;
}
if( internal_volume->file_io_handle_created_in_library != 0 )
{
if( libbfio_handle_free(
&( internal_volume->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 );
result = -1;
}
internal_volume->file_io_handle_created_in_library = 0;
}
internal_volume->file_io_handle = NULL;
internal_volume->size = 0;
if( libvshadow_io_handle_clear(
internal_volume->io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to clear IO handle.",
function );
result = -1;
}
if( libcdata_array_empty(
internal_volume->store_descriptors_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libvshadow_store_descriptor_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to empty store descriptors array.",
function );
result = -1;
}
#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( result );
}
/* Opens a volume
* Returns 1 if successful or -1 on error
*/
int libvshadow_volume_open(
libvshadow_volume_t *volume,
const char *filename,
int access_flags,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
libvshadow_internal_volume_t *internal_volume = NULL;
static char *function = "libvshadow_volume_open";
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( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
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( 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(
file_io_handle,
filename,
libcstring_narrow_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( libvshadow_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: %s.",
function,
filename );
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_created_in_library = 1;
#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 != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
/* 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 );
}
/* Tests the libmdmp_file_open_file_io_handle function
* Returns 1 if successful or 0 if not
*/
int mdmp_test_file_open_file_io_handle(
const system_character_t *source )
{
libbfio_handle_t *file_io_handle = NULL;
libcerror_error_t *error = NULL;
libmdmp_file_t *file = NULL;
size_t string_length = 0;
int result = 0;
/* Initialize test
*/
result = libbfio_file_initialize(
&file_io_handle,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
string_length = system_string_length(
source );
#if defined( HAVE_WIDE_SYSTEM_CHARACTER )
result = libbfio_file_set_name_wide(
file_io_handle,
source,
string_length,
&error );
#else
result = libbfio_file_set_name(
file_io_handle,
source,
string_length,
&error );
#endif
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
result = libmdmp_file_initialize(
&file,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NOT_NULL(
"file",
file );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test open
*/
result = libmdmp_file_open_file_io_handle(
file,
file_io_handle,
LIBMDMP_OPEN_READ,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libmdmp_file_open_file_io_handle(
NULL,
file_io_handle,
LIBMDMP_OPEN_READ,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
MDMP_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libmdmp_file_open_file_io_handle(
file,
NULL,
LIBMDMP_OPEN_READ,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
MDMP_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libmdmp_file_open_file_io_handle(
file,
file_io_handle,
-1,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
MDMP_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Test open when already opened
*/
result = libmdmp_file_open_file_io_handle(
file,
file_io_handle,
LIBMDMP_OPEN_READ,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
MDMP_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Clean up
*/
result = libmdmp_file_free(
&file,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NULL(
"file",
file );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
result = libbfio_handle_free(
&file_io_handle,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NULL(
"file_io_handle",
file_io_handle );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( file != NULL )
{
libmdmp_file_free(
&file,
NULL );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( 0 );
}
/* Closes a volume
* Returns 0 if successful or -1 on error
*/
int libfshfs_volume_close(
libfshfs_volume_t *volume,
libcerror_error_t **error )
{
libfshfs_internal_volume_t *internal_volume = NULL;
static char *function = "libfshfs_volume_close";
int result = 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 = (libfshfs_internal_volume_t *) volume;
if( internal_volume->io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid volume - missing IO handle.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
if( internal_volume->file_io_handle_created_in_library != 0 )
{
if( libfshfs_debug_print_read_offsets(
internal_volume->file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print the read offsets.",
function );
result = -1;
}
}
}
#endif
if( internal_volume->file_io_handle_opened_in_library != 0 )
{
if( libbfio_handle_close(
internal_volume->file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file IO handle.",
function );
result = -1;
}
internal_volume->file_io_handle_opened_in_library = 0;
}
if( internal_volume->file_io_handle_created_in_library != 0 )
{
if( libbfio_handle_free(
&( internal_volume->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 );
result = -1;
}
internal_volume->file_io_handle_created_in_library = 0;
}
internal_volume->file_io_handle = NULL;
if( libfshfs_io_handle_clear(
internal_volume->io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to clear IO handle.",
function );
result = -1;
}
if( libfshfs_fork_descriptor_free(
&( internal_volume->allocation_file_fork_descriptor ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free allocation file fork descriptor.",
function );
result = -1;
}
if( libfshfs_fork_descriptor_free(
&( internal_volume->extents_file_fork_descriptor ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free extents file fork descriptor.",
function );
result = -1;
}
if( libfshfs_fork_descriptor_free(
&( internal_volume->catalog_file_fork_descriptor ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free catalog file fork descriptor.",
function );
result = -1;
}
if( libfshfs_fork_descriptor_free(
&( internal_volume->attributes_file_fork_descriptor ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free attributes file fork descriptor.",
function );
result = -1;
}
if( libfshfs_fork_descriptor_free(
&( internal_volume->startup_file_fork_descriptor ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free startup file fork descriptor.",
function );
result = -1;
}
return( result );
}
/* Creates a mount handle
* Make sure the value mount_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int mount_handle_initialize(
mount_handle_t **mount_handle,
libcerror_error_t **error )
{
static char *function = "mount_handle_initialize";
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( *mount_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid mount handle value already set.",
function );
return( -1 );
}
*mount_handle = memory_allocate_structure(
mount_handle_t );
if( *mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create mount handle.",
function );
goto on_error;
}
if( memory_set(
*mount_handle,
0,
sizeof( mount_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear mount handle.",
function );
memory_free(
*mount_handle );
*mount_handle = NULL;
return( -1 );
}
if( libbfio_file_range_initialize(
&( ( *mount_handle )->input_file_io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input file IO handle.",
function );
goto on_error;
}
/* TODO control maximum number of handles */
if( libbfio_pool_initialize(
&( ( *mount_handle )->physical_volume_file_io_pool ),
0,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize physical volume file IO pool.",
function );
goto on_error;
}
if( libvslvm_handle_initialize(
&( ( *mount_handle )->input_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input handle.",
function );
goto on_error;
}
if( libcdata_array_initialize(
&( ( *mount_handle )->logical_volumes_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize logical volumes array.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *mount_handle != NULL )
{
if( ( *mount_handle )->input_handle != NULL )
{
libvslvm_handle_free(
&( ( *mount_handle )->input_handle ),
NULL );
}
if( ( *mount_handle )->physical_volume_file_io_pool != NULL )
{
libbfio_pool_free(
&( ( *mount_handle )->physical_volume_file_io_pool ),
NULL );
}
if( ( *mount_handle )->input_file_io_handle != NULL )
{
libbfio_handle_free(
&( ( *mount_handle )->input_file_io_handle ),
NULL );
}
memory_free(
*mount_handle );
*mount_handle = NULL;
}
return( -1 );
}
int main(
int argc,
char * const argv[] )
#endif
{
libbfio_handle_t *file_io_handle = NULL;
libcerror_error_t *error = NULL;
libmdmp_file_t *file = NULL;
system_character_t *source = NULL;
system_integer_t option = 0;
size_t string_length = 0;
int result = 0;
while( ( option = mdmp_test_getopt(
argc,
argv,
_SYSTEM_STRING( "" ) ) ) != (system_integer_t) -1 )
{
switch( option )
{
case (system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_SYSTEM ".\n",
argv[ optind - 1 ] );
return( EXIT_FAILURE );
}
}
if( optind < argc )
{
source = argv[ optind ];
}
#if defined( HAVE_DEBUG_OUTPUT ) && defined( MDMP_TEST_FILE_VERBOSE )
libmdmp_notify_set_verbose(
1 );
libmdmp_notify_set_stream(
stderr,
NULL );
#endif
MDMP_TEST_RUN(
"libmdmp_file_initialize",
mdmp_test_file_initialize );
MDMP_TEST_RUN(
"libmdmp_file_free",
mdmp_test_file_free );
#if !defined( __BORLANDC__ ) || ( __BORLANDC__ >= 0x0560 )
if( source != NULL )
{
result = libbfio_file_initialize(
&file_io_handle,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
string_length = system_string_length(
source );
#if defined( HAVE_WIDE_SYSTEM_CHARACTER )
result = libbfio_file_set_name_wide(
file_io_handle,
source,
string_length,
&error );
#else
result = libbfio_file_set_name(
file_io_handle,
source,
string_length,
&error );
#endif
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
result = libmdmp_check_file_signature_file_io_handle(
file_io_handle,
&error );
MDMP_TEST_ASSERT_NOT_EQUAL_INT(
"result",
result,
-1 );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
}
if( result != 0 )
{
MDMP_TEST_RUN_WITH_ARGS(
"libmdmp_file_open",
mdmp_test_file_open,
source );
#if defined( HAVE_WIDE_CHARACTER_TYPE )
MDMP_TEST_RUN_WITH_ARGS(
"libmdmp_file_open_wide",
mdmp_test_file_open_wide,
source );
#endif /* defined( HAVE_WIDE_CHARACTER_TYPE ) */
MDMP_TEST_RUN_WITH_ARGS(
"libmdmp_file_open_file_io_handle",
mdmp_test_file_open_file_io_handle,
source );
MDMP_TEST_RUN(
"libmdmp_file_close",
mdmp_test_file_close );
MDMP_TEST_RUN_WITH_ARGS(
"libmdmp_file_open_close",
mdmp_test_file_open_close,
source );
/* Initialize file for tests
*/
result = mdmp_test_file_open_source(
&file,
file_io_handle,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NOT_NULL(
"file",
file );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
MDMP_TEST_RUN_WITH_ARGS(
"libmdmp_file_signal_abort",
mdmp_test_file_signal_abort,
file );
#if defined( __GNUC__ ) && !defined( LIBMDMP_DLL_IMPORT )
/* TODO: add tests for libmdmp_file_open_read */
#endif /* defined( __GNUC__ ) && !defined( LIBMDMP_DLL_IMPORT ) */
MDMP_TEST_RUN_WITH_ARGS(
"libmdmp_file_get_number_of_streams",
mdmp_test_file_get_number_of_streams,
file );
MDMP_TEST_RUN_WITH_ARGS(
"libmdmp_file_get_stream",
mdmp_test_file_get_stream,
file );
/* TODO: add tests for libmdmp_file_get_stream_by_type */
/* Clean up
*/
result = mdmp_test_file_close_source(
&file,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
MDMP_TEST_ASSERT_IS_NULL(
"file",
file );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
}
if( file_io_handle != NULL )
{
result = libbfio_handle_free(
&file_io_handle,
&error );
MDMP_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
MDMP_TEST_ASSERT_IS_NULL(
"file_io_handle",
file_io_handle );
MDMP_TEST_ASSERT_IS_NULL(
"error",
error );
}
#endif /* !defined( __BORLANDC__ ) || ( __BORLANDC__ >= 0x0560 ) */
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( file != NULL )
{
libmdmp_file_free(
&file,
NULL );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( EXIT_FAILURE );
}
/* Opens the resource file
* Returns 1 if successful or -1 on error
*/
int resource_file_open(
resource_file_t *resource_file,
const system_character_t *filename,
libcerror_error_t **error )
{
static char *function = "resource_file_open";
uint32_t virtual_address = 0;
if( resource_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid resource file.",
function );
return( -1 );
}
if( resource_file->is_open != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid resource file already open.",
function );
return( -1 );
}
#if defined( HAVE_WIDE_SYSTEM_CHARACTER )
if( libexe_file_open_wide(
resource_file->exe_file,
filename,
LIBEXE_OPEN_READ,
error ) != 1 )
#else
if( libexe_file_open(
resource_file->exe_file,
filename,
LIBEXE_OPEN_READ,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open EXE file.",
function );
goto on_error;
}
if( libexe_file_get_section_by_name(
resource_file->exe_file,
".rsrc",
5,
&( resource_file->resource_section ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve resource section.",
function );
goto on_error;
}
if( libexe_section_get_virtual_address(
resource_file->resource_section,
&virtual_address,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve resource section virtual adress.",
function );
goto on_error;
}
if( libexe_section_get_data_file_io_handle(
resource_file->resource_section,
&( resource_file->resource_section_file_io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve resource section file IO handle.",
function );
goto on_error;
}
if( libwrc_stream_set_virtual_address(
resource_file->resource_stream,
virtual_address,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set resource stream virtual adress.",
function );
goto on_error;
}
if( libwrc_stream_open_file_io_handle(
resource_file->resource_stream,
resource_file->resource_section_file_io_handle,
LIBWRC_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open resource stream.",
function );
goto on_error;
}
resource_file->is_open = 1;
return( 1 );
on_error:
if( resource_file->resource_section_file_io_handle != NULL )
{
libbfio_handle_free(
&( resource_file->resource_section_file_io_handle ),
NULL );
}
if( resource_file->resource_section != NULL )
{
libexe_section_free(
&( resource_file->resource_section ),
NULL );
}
libexe_file_close(
resource_file->exe_file,
NULL );
return( -1 );
}
/* Initializes the file objects IO pool
* Returns 1 if successful or -1 on error
*/
int pyvslvm_file_objects_pool_initialize(
libbfio_pool_t **pool,
PyObject *sequence_object,
int access_flags,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
PyObject *file_object = NULL;
static char *function = "pyvslvm_file_objects_pool_initialize";
Py_ssize_t sequence_size = 0;
int element_index = 0;
int file_io_pool_entry = 0;
int number_of_elements = 0;
if( pool == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
if( *pool != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid pool value already set.",
function );
return( -1 );
}
sequence_size = PySequence_Size(
sequence_object );
if( sequence_size > (Py_ssize_t) INT_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid sequence size value exceeds maximum.",
function );
goto on_error;
}
number_of_elements = (int) sequence_size;
if( libbfio_pool_initialize(
pool,
0,
LIBBFIO_POOL_UNLIMITED_NUMBER_OF_OPEN_HANDLES,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create pool.",
function );
goto on_error;
}
for( element_index = 0;
element_index < number_of_elements;
element_index++ )
{
file_object = PySequence_GetItem(
sequence_object,
element_index );
if( file_object == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: missing file object IO handle.",
function );
goto on_error;
}
if( pyvslvm_file_object_initialize(
&file_io_handle,
file_object,
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_pool_append_handle(
*pool,
&file_io_pool_entry,
file_io_handle,
access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append file IO handle to pool.",
function );
goto on_error;
}
file_io_handle = NULL;
}
return( 1 );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
if( *pool != NULL )
{
libbfio_pool_free(
pool,
NULL );
}
return( -1 );
}
/* Closes the resource file
* Returns the 0 if succesful or -1 on error
*/
int resource_file_close(
resource_file_t *resource_file,
libcerror_error_t **error )
{
static char *function = "resource_file_close";
int result = 0;
if( resource_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid resource file.",
function );
return( -1 );
}
if( resource_file->is_open != 0 )
{
if( libfcache_cache_empty(
resource_file->message_string_cache,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to empty message string cache.",
function );
result = -1;
}
if( resource_file->message_table_resource != NULL )
{
if( libwrc_resource_free(
&( resource_file->message_table_resource ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free message table resource.",
function );
result = -1;
}
}
if( resource_file->mui_resource != NULL )
{
if( libwrc_resource_free(
&( resource_file->mui_resource ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free MUI resource.",
function );
result = -1;
}
}
if( resource_file->wevt_template_resource != NULL )
{
if( libwrc_resource_free(
&( resource_file->wevt_template_resource ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free WEVT_TEMPLATE resource.",
function );
result = -1;
}
}
if( libwrc_stream_close(
resource_file->resource_stream,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close resource stream.",
function );
result = -1;
}
if( resource_file->resource_section_file_io_handle != NULL )
{
if( libbfio_handle_free(
&( resource_file->resource_section_file_io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free resource section file IO handle.",
function );
result = -1;
}
}
if( resource_file->resource_section != NULL )
{
if( libexe_section_free(
&( resource_file->resource_section ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free resource section.",
function );
result = -1;
}
}
if( libexe_file_close(
resource_file->exe_file,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close EXE file.",
function );
result = -1;
}
resource_file->is_open = 0;
}
return( result );
}
/* 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 );
}
/* 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 );
}
/* Closes a file
* Returns 0 if successful or -1 on error
*/
int libevtx_file_close(
libevtx_file_t *file,
libcerror_error_t **error )
{
libevtx_internal_file_t *internal_file = NULL;
static char *function = "libevtx_file_close";
int result = 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 = (libevtx_internal_file_t *) file;
if( internal_file->file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid file - missing file IO handle.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
if( internal_file->file_io_handle_created_in_library != 0 )
{
if( libevtx_debug_print_read_offsets(
internal_file->file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print the read offsets.",
function );
result = -1;
}
}
}
#endif
if( internal_file->file_io_handle_opened_in_library != 0 )
{
if( libbfio_handle_close(
internal_file->file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file IO handle.",
function );
result = -1;
}
internal_file->file_io_handle_opened_in_library = 0;
}
if( internal_file->file_io_handle_created_in_library != 0 )
{
if( libbfio_handle_free(
&( internal_file->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 );
result = -1;
}
internal_file->file_io_handle_created_in_library = 0;
}
internal_file->file_io_handle = NULL;
if( libevtx_io_handle_clear(
internal_file->io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to clear IO handle.",
function );
result = -1;
}
if( libfdata_list_free(
&( internal_file->recovered_records_list ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free recovered records list.",
function );
result = -1;
}
if( libfdata_list_free(
&( internal_file->records_list ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free records list.",
function );
result = -1;
}
if( libfcache_cache_free(
&( internal_file->records_cache ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free records cache.",
function );
result = -1;
}
if( libfdata_vector_free(
&( internal_file->chunks_vector ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free chunks vector.",
function );
result = -1;
}
if( libfcache_cache_free(
&( internal_file->chunks_cache ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free chunks cache.",
function );
result = -1;
}
return( result );
}
/* Tests the libevt_file_header_read_file_io_handle function
* Returns 1 if successful or 0 if not
*/
int evt_test_file_header_read_file_io_handle(
void )
{
libbfio_handle_t *file_io_handle = NULL;
libcerror_error_t *error = NULL;
libevt_file_header_t *file_header = NULL;
int result = 0;
/* Initialize test
*/
result = libevt_file_header_initialize(
&file_header,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
EVT_TEST_ASSERT_IS_NOT_NULL(
"file_header",
file_header );
EVT_TEST_ASSERT_IS_NULL(
"error",
error );
/* Initialize file IO handle
*/
result = evt_test_open_file_io_handle(
&file_io_handle,
evt_test_file_header_data1,
48,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
EVT_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
EVT_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test regular cases
*/
result = libevt_file_header_read_file_io_handle(
file_header,
file_io_handle,
0,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
EVT_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libevt_file_header_read_file_io_handle(
NULL,
file_io_handle,
0,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
EVT_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libevt_file_header_read_file_io_handle(
file_header,
NULL,
0,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
EVT_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libevt_file_header_read_file_io_handle(
file_header,
file_io_handle,
-1,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
EVT_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Clean up file IO handle
*/
result = evt_test_close_file_io_handle(
&file_io_handle,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
EVT_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test data too small
*/
result = evt_test_open_file_io_handle(
&file_io_handle,
evt_test_file_header_data1,
8,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
EVT_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
EVT_TEST_ASSERT_IS_NULL(
"error",
error );
result = libevt_file_header_read_file_io_handle(
file_header,
file_io_handle,
0,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
EVT_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = evt_test_close_file_io_handle(
&file_io_handle,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
EVT_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test invalid signature
*/
result = evt_test_open_file_io_handle(
&file_io_handle,
evt_test_file_header_data1,
48,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
EVT_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
EVT_TEST_ASSERT_IS_NULL(
"error",
error );
byte_stream_copy_from_uint32_little_endian(
&( evt_test_file_header_data1[ 4 ] ),
0xffffffffUL );
result = libevt_file_header_read_file_io_handle(
file_header,
file_io_handle,
0,
&error );
byte_stream_copy_from_uint32_little_endian(
&( evt_test_file_header_data1[ 4 ] ),
0x654c664cUL );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
EVT_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = evt_test_close_file_io_handle(
&file_io_handle,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
EVT_TEST_ASSERT_IS_NULL(
"error",
error );
/* Clean up
*/
result = libevt_file_header_free(
&file_header,
&error );
EVT_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
EVT_TEST_ASSERT_IS_NULL(
"file_header",
file_header );
EVT_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 );
}
if( file_header != NULL )
{
libevt_file_header_free(
&file_header,
NULL );
}
return( 0 );
}
/* Closes a file
* Returns 0 if successful or -1 on error
*/
int libmsiecf_file_close(
libmsiecf_file_t *file,
libcerror_error_t **error )
{
libmsiecf_internal_file_t *internal_file = NULL;
static char *function = "libmsiecf_file_close";
int result = 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_MISSING,
"%s: invalid file - missing file IO handle.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
if( internal_file->file_io_handle_created_in_library != 0 )
{
if( libmsiecf_debug_print_read_offsets(
internal_file->file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print the read offsets.",
function );
}
}
}
#endif
if( internal_file->file_io_handle_opened_in_library != 0 )
{
if( libbfio_handle_close(
internal_file->file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file IO handle.",
function );
result = -1;
}
internal_file->file_io_handle_opened_in_library = 0;
}
if( internal_file->file_io_handle_created_in_library != 0 )
{
if( libbfio_handle_free(
&( internal_file->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 );
result = -1;
}
internal_file->file_io_handle_created_in_library = 0;
}
internal_file->file_io_handle = NULL;
if( libmsiecf_io_handle_clear(
internal_file->io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to clear IO handle.",
function );
result = -1;
}
if( internal_file->directory_array != NULL )
{
if( libcdata_array_free(
&( internal_file->directory_array ),
(int (*)(intptr_t **, libcerror_error_t **)) &libmsiecf_directory_descriptor_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free directory array.",
function );
result = -1;
}
}
if( internal_file->item_array != NULL )
{
if( libcdata_array_free(
&( internal_file->item_array ),
(int (*)(intptr_t **, libcerror_error_t **)) &libmsiecf_item_descriptor_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free item array.",
function );
result = -1;
}
}
if( internal_file->recovered_item_array != NULL )
{
if( libcdata_array_free(
&( internal_file->recovered_item_array ),
(int (*)(intptr_t **, libcerror_error_t **)) &libmsiecf_item_descriptor_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free recovered item array.",
function );
result = -1;
}
}
if( internal_file->unallocated_block_list != NULL )
{
if( libcdata_range_list_free(
&( internal_file->unallocated_block_list ),
NULL,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free unallocated block list.",
function );
result = -1;
}
}
return( result );
}
/* Frees a mount handle
* Returns 1 if successful or -1 on error
*/
int mount_handle_free(
mount_handle_t **mount_handle,
libcerror_error_t **error )
{
static char *function = "mount_handle_free";
int result = 1;
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( *mount_handle != NULL )
{
if( libcdata_array_free(
&( ( *mount_handle )->logical_volumes_array ),
(int (*)(intptr_t **, libcerror_error_t **)) &libvslvm_logical_volume_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free logical volumes array.",
function );
result = -1;
}
if( ( *mount_handle )->volume_group != NULL )
{
if( libvslvm_volume_group_free(
&( ( *mount_handle )->volume_group ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free volume group.",
function );
result = -1;
}
}
if( libvslvm_handle_free(
&( ( *mount_handle )->input_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free input handle.",
function );
result = -1;
}
if( libbfio_pool_free(
&( ( *mount_handle )->physical_volume_file_io_pool ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free physical volume file IO pool.",
function );
result = -1;
}
if( libbfio_handle_free(
&( ( *mount_handle )->input_file_io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free input file IO handle.",
function );
result = -1;
}
memory_free(
*mount_handle );
*mount_handle = NULL;
}
return( result );
}
