/* 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 ); }
/* 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 ); }
/* 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 ); }
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 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 ); }
/* 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 ); }
/* 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_wide( libbfio_pool_t *pool, wchar_t * 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_wide"; 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_wide_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_wide( 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 ); }
/* 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 ); }