/* Clones the single file entry * Returns 1 if successful or -1 on error */ int libewf_single_file_entry_clone( libewf_single_file_entry_t **destination_single_file_entry, libewf_single_file_entry_t *source_single_file_entry, libcerror_error_t **error ) { static char *function = "libewf_single_file_entry_clone"; if( destination_single_file_entry == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid destination single file entry.", function ); return( -1 ); } if( *destination_single_file_entry != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid destination single file entry value already set.", function ); return( -1 ); } if( source_single_file_entry == NULL ) { *destination_single_file_entry = NULL; return( 1 ); } *destination_single_file_entry = memory_allocate_structure( libewf_single_file_entry_t ); if( *destination_single_file_entry == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create destination single file entry.", function ); goto on_error; } if( memory_copy( *destination_single_file_entry, source_single_file_entry, sizeof( libewf_single_file_entry_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_COPY_FAILED, "%s: unable to copy source to destination single file entry.", function ); memory_free( *destination_single_file_entry ); *destination_single_file_entry = NULL; return( -1 ); } ( *destination_single_file_entry )->name = NULL; ( *destination_single_file_entry )->md5_hash = NULL; ( *destination_single_file_entry )->sha1_hash = NULL; if( source_single_file_entry->name != NULL ) { ( *destination_single_file_entry )->name = (uint8_t *) memory_allocate( sizeof( uint8_t ) * source_single_file_entry->name_size ); if( ( *destination_single_file_entry )->name == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create destination name.", function ); goto on_error; } if( memory_copy( ( *destination_single_file_entry )->name, source_single_file_entry->name, source_single_file_entry->name_size ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_COPY_FAILED, "%s: unable to copy source to destination name.", function ); goto on_error; } ( *destination_single_file_entry )->name_size = source_single_file_entry->name_size; } if( source_single_file_entry->md5_hash != NULL ) { ( *destination_single_file_entry )->md5_hash = (uint8_t *) memory_allocate( sizeof( uint8_t ) * source_single_file_entry->md5_hash_size ); if( ( *destination_single_file_entry )->md5_hash == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create destination MD5 hash.", function ); goto on_error; } if( memory_copy( ( *destination_single_file_entry )->md5_hash, source_single_file_entry->md5_hash, source_single_file_entry->md5_hash_size ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_COPY_FAILED, "%s: unable to copy source to destination MD5 hash.", function ); goto on_error; } ( *destination_single_file_entry )->md5_hash_size = source_single_file_entry->md5_hash_size; } if( source_single_file_entry->sha1_hash != NULL ) { ( *destination_single_file_entry )->sha1_hash = (uint8_t *) memory_allocate( sizeof( uint8_t ) * source_single_file_entry->sha1_hash_size ); if( ( *destination_single_file_entry )->sha1_hash == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create destination SHA1 hash.", function ); goto on_error; } if( memory_copy( ( *destination_single_file_entry )->sha1_hash, source_single_file_entry->sha1_hash, source_single_file_entry->sha1_hash_size ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_COPY_FAILED, "%s: unable to copy source to destination SHA1 hash.", function ); goto on_error; } ( *destination_single_file_entry )->sha1_hash_size = source_single_file_entry->sha1_hash_size; } return( 1 ); on_error: if( *destination_single_file_entry != NULL ) { if( ( *destination_single_file_entry )->sha1_hash != NULL ) { memory_free( ( *destination_single_file_entry )->sha1_hash ); } if( ( *destination_single_file_entry )->md5_hash != NULL ) { memory_free( ( *destination_single_file_entry )->md5_hash ); } if( ( *destination_single_file_entry )->name != NULL ) { memory_free( ( *destination_single_file_entry )->name ); } memory_free( *destination_single_file_entry ); *destination_single_file_entry = NULL; } return( -1 ); }
/* Initializes the file objects IO pool * Returns 1 if successful or -1 on error */ int pyewf_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 = "pyewf_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( pyewf_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 ); }
/* Determines if a file contains an EVT file signature using a Basic File IO (bfio) handle * Returns 1 if true, 0 if not or -1 on error */ int libevt_check_file_signature_file_io_handle( libbfio_handle_t *file_io_handle, libcerror_error_t **error ) { uint8_t signature[ 8 ]; static char *function = "libevt_check_file_signature_file_io_handle"; ssize_t read_count = 0; int file_io_handle_is_open = 0; if( file_io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid file IO handle.", function ); return( -1 ); } file_io_handle_is_open = libbfio_handle_is_open( file_io_handle, error ); if( file_io_handle_is_open == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open file.", function ); goto on_error; } else if( file_io_handle_is_open == 0 ) { if( libbfio_handle_open( file_io_handle, LIBBFIO_OPEN_READ, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open file.", function ); goto on_error; } } if( libbfio_handle_seek_offset( file_io_handle, 0, SEEK_SET, error ) == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_SEEK_FAILED, "%s: unable to seek file header offset: 0.", function ); goto on_error; } read_count = libbfio_handle_read_buffer( file_io_handle, signature, 8, error ); if( read_count != 8 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read signature.", function ); goto on_error; } if( file_io_handle_is_open == 0 ) { if( libbfio_handle_close( file_io_handle, error ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_CLOSE_FAILED, "%s: unable to close file.", function ); goto on_error; } } if( memory_compare( evt_file_signature, &( signature[ 4 ] ), 4 ) == 0 ) { return( 1 ); } return( 0 ); on_error: if( file_io_handle_is_open == 0 ) { libbfio_handle_close( file_io_handle, NULL ); } return( -1 ); }
/* Sets the stream ASCII codepage * Returns 1 if successful or -1 on error */ int libwrc_stream_set_ascii_codepage( libwrc_stream_t *stream, int ascii_codepage, libcerror_error_t **error ) { libwrc_internal_stream_t *internal_stream = NULL; static char *function = "libwrc_stream_set_ascii_codepage"; if( stream == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid stream.", function ); return( -1 ); } internal_stream = (libwrc_internal_stream_t *) stream; if( internal_stream->io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: invalid stream - missing IO handle.", function ); return( -1 ); } if( ( ascii_codepage != LIBWRC_CODEPAGE_ASCII ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_874 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_932 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_936 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_949 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_950 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_1250 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_1251 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_1252 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_1253 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_1254 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_1255 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_1256 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_1257 ) && ( ascii_codepage != LIBWRC_CODEPAGE_WINDOWS_1258 ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE, "%s: unsupported ASCII codepage.", function ); return( -1 ); } internal_stream->io_handle->ascii_codepage = ascii_codepage; return( 1 ); }
/* Initializes the group * Returns 1 if successful or -1 on error */ int libmfdata_group_initialize( libmfdata_group_t **group, libcerror_error_t **error ) { static char *function = "libmfdata_group_initialize"; if( group == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid group.", function ); return( -1 ); } if( *group != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid group value already set.", function ); return( -1 ); } *group = memory_allocate_structure( libmfdata_group_t ); if( *group == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create group.", function ); goto on_error; } if( memory_set( *group, 0, sizeof( libmfdata_group_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear group.", function ); goto on_error; } return( 1 ); on_error: if( *group != NULL ) { memory_free( *group ); *group = NULL; } return( -1 ); }
/* Opens a stream * Returns 1 if successful or -1 on error */ int libwrc_stream_open_wide( libwrc_stream_t *stream, const wchar_t *filename, int access_flags, libcerror_error_t **error ) { libbfio_handle_t *file_io_handle = NULL; libwrc_internal_stream_t *internal_stream = NULL; static char *function = "libwrc_stream_open_wide"; size_t filename_length = 0; if( stream == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid stream.", function ); return( -1 ); } internal_stream = (libwrc_internal_stream_t *) stream; if( filename == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid filename.", function ); return( -1 ); } if( ( ( access_flags & LIBWRC_ACCESS_FLAG_READ ) == 0 ) && ( ( access_flags & LIBWRC_ACCESS_FLAG_WRITE ) == 0 ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE, "%s: unsupported access flags.", function ); return( -1 ); } if( ( access_flags & LIBWRC_ACCESS_FLAG_WRITE ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE, "%s: write access currently not supported.", function ); return( -1 ); } if( libbfio_file_initialize( &file_io_handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create file IO handle.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libbfio_handle_set_track_offsets_read( file_io_handle, 1, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set track offsets read in file IO handle.", function ); goto on_error; } #endif filename_length = wide_string_length( filename ); if( libbfio_file_set_name_wide( file_io_handle, filename, filename_length + 1, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set filename in file IO handle.", function ); goto on_error; } if( libwrc_stream_open_file_io_handle( stream, file_io_handle, access_flags, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open stream: %ls.", function, filename ); goto on_error; } internal_stream->file_io_handle_created_in_library = 1; return( 1 ); on_error: if( file_io_handle != NULL ) { libbfio_handle_free( &file_io_handle, NULL ); } return( -1 ); }
/* Opens a stream using a Basic File IO (bfio) handle * Returns 1 if successful or -1 on error */ int libwrc_stream_open_file_io_handle( libwrc_stream_t *stream, libbfio_handle_t *file_io_handle, int access_flags, libcerror_error_t **error ) { libwrc_internal_stream_t *internal_stream = NULL; static char *function = "libwrc_stream_open_file_io_handle"; int bfio_access_flags = 0; int file_io_handle_is_open = 0; if( stream == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid stream.", function ); return( -1 ); } internal_stream = (libwrc_internal_stream_t *) stream; if( internal_stream->file_io_handle != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid stream - file IO handle already set.", function ); return( -1 ); } if( file_io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid file IO handle.", function ); return( -1 ); } if( ( ( access_flags & LIBWRC_ACCESS_FLAG_READ ) == 0 ) && ( ( access_flags & LIBWRC_ACCESS_FLAG_WRITE ) == 0 ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE, "%s: unsupported access flags.", function ); return( -1 ); } if( ( access_flags & LIBWRC_ACCESS_FLAG_WRITE ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE, "%s: write access currently not supported.", function ); return( -1 ); } if( ( access_flags & LIBWRC_ACCESS_FLAG_READ ) != 0 ) { bfio_access_flags = LIBBFIO_ACCESS_FLAG_READ; } file_io_handle_is_open = libbfio_handle_is_open( file_io_handle, error ); if( file_io_handle_is_open == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to determine if file IO handle is open.", function ); goto on_error; } else if( file_io_handle_is_open == 0 ) { if( libbfio_handle_open( file_io_handle, bfio_access_flags, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open file IO handle.", function ); goto on_error; } internal_stream->file_io_handle_opened_in_library = 1; } if( libwrc_stream_open_read( internal_stream, file_io_handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read from file handle.", function ); goto on_error; } internal_stream->file_io_handle = file_io_handle; return( 1 ); on_error: if( ( file_io_handle_is_open == 0 ) && ( internal_stream->file_io_handle_opened_in_library != 0 ) ) { libbfio_handle_close( file_io_handle, error ); internal_stream->file_io_handle_opened_in_library = 0; } internal_stream->file_io_handle = NULL; return( -1 ); }
/* Tests single open and close of a file * Returns 1 if successful, 0 if not or -1 on error */ int pff_test_single_open_close_file( libcstring_system_character_t *filename, int access_flags, int expected_result ) { libcerror_error_t *error = NULL; libpff_file_t *file = NULL; static char *function = "pff_test_single_open_close_file"; char *access_string = NULL; int result = 0; if( access_flags == LIBPFF_OPEN_READ ) { access_string = "read"; } else if( access_flags == LIBPFF_OPEN_WRITE ) { access_string = "write"; } else { access_string = "UNKNOWN"; } fprintf( stdout, "Testing single open close of: " ); if( filename != NULL ) { fprintf( stdout, "%" PRIs_LIBCSTRING_SYSTEM "", filename ); } else { fprintf( stdout, "NULL" ); } fprintf( stdout, " with access: %s\t", access_string ); if( libpff_file_initialize( &file, &error ) != 1 ) { libcerror_error_set( &error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create file.", function ); goto on_error; } #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) result = libpff_file_open_wide( file, filename, access_flags, &error ); #else result = libpff_file_open( file, filename, access_flags, &error ); #endif if( result == 1 ) { if( libpff_file_close( file, &error ) != 0 ) { libcerror_error_set( &error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_CLOSE_FAILED, "%s: unable to close file.", function ); goto on_error; } } if( libpff_file_free( &file, &error ) != 1 ) { libcerror_error_set( &error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free file.", function ); goto on_error; } result = ( expected_result == result ); if( result == 1 ) { fprintf( stdout, "(PASS)" ); } else { fprintf( stdout, "(FAIL)" ); } fprintf( stdout, "\n" ); if( error != NULL ) { libcerror_error_backtrace_fprint( error, stderr ); libcerror_error_free( &error ); } return( result ); on_error: if( error != NULL ) { libcerror_error_backtrace_fprint( error, stderr ); libcerror_error_free( &error ); } if( file != NULL ) { libpff_file_free( &file, NULL); } return( -1 ); }
/* Retrieves the root key * Returns 1 if successful, 0 if no such key or -1 on error */ int libregf_file_get_root_key( libregf_file_t *file, libregf_key_t **key, libcerror_error_t **error ) { libfdata_tree_node_t *key_tree_root_node = NULL; libregf_internal_file_t *internal_file = NULL; static char *function = "libregf_file_get_root_key"; if( file == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid file.", function ); return( -1 ); } internal_file = (libregf_internal_file_t *) file; if( internal_file->io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: invalid file - missing IO handle.", function ); return( -1 ); } if( key == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid key.", function ); return( -1 ); } if( *key != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: key already set.", function ); return( -1 ); } if( ( internal_file->io_handle->file_type != LIBREGF_FILE_TYPE_REGISTRY ) || ( internal_file->key_tree == NULL ) ) { return( 0 ); } if( libfdata_tree_get_root_node( internal_file->key_tree, &key_tree_root_node, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve key tree root node.", function ); return( -1 ); } if( libregf_key_initialize( key, internal_file->io_handle, internal_file->file_io_handle, key_tree_root_node, internal_file->key_cache, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create root key.", function ); return( -1 ); } return( 1 ); }
/* Retrieves the UTF-8 encoded MD5 hash value * Returns 1 if successful, 0 if value not present or -1 on error */ int libewf_single_file_entry_get_utf8_hash_value_md5( libewf_single_file_entry_t *single_file_entry, uint8_t *utf8_string, size_t utf8_string_size, libcerror_error_t **error ) { static char *function = "libewf_single_file_entry_get_utf8_hash_value_md5"; if( single_file_entry == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid single file entry.", function ); return( -1 ); } if( utf8_string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid UTF-8 string.", function ); return( -1 ); } if( utf8_string_size > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid UTF-8 string size value exceeds maximum.", function ); return( -1 ); } if( utf8_string_size < single_file_entry->md5_hash_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL, "%s: UTF-8 string too small.", function ); return( -1 ); } if( single_file_entry->md5_hash_size == 0 ) { return( 0 ); } if( memory_copy( utf8_string, single_file_entry->md5_hash, single_file_entry->md5_hash_size ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_COPY_FAILED, "%s: unable to copy MD5 hash to UTF-8 string.", function ); return( -1 ); } return( 1 ); }
/* Prints the read offsets * Returns 1 if successful or -1 on error */ int libevtx_debug_print_read_offsets( libbfio_handle_t *file_io_handle, libcerror_error_t **error ) { static char *function = "libevtx_debug_print_read_offsets"; off64_t offset = 0; size64_t size = 0; int number_of_offsets = 0; int offset_iterator = 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_get_number_of_offsets_read( file_io_handle, &number_of_offsets, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve number of offsets read.", function ); return( -1 ); } libcnotify_printf( "Offsets read:\n" ); for( offset_iterator = 0; offset_iterator < number_of_offsets; offset_iterator++ ) { if( libbfio_handle_get_offset_read( file_io_handle, offset_iterator, &offset, &size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve offset: %d.", function, offset_iterator ); return( -1 ); } libcnotify_printf( "%08" PRIi64 " ( 0x%08" PRIx64 " ) - %08" PRIi64 " ( 0x%08" PRIx64 " ) size: %" PRIi64 "\n", offset, offset, offset + (off64_t) size, offset + (off64_t) size, size ); } libcnotify_printf( "\n" ); return( 1 ); }
/* Retrieves the UTF-16 encoded name value * The size should include the end of string character * Returns 1 if successful or -1 on error */ int libewf_single_file_entry_get_utf16_name( libewf_single_file_entry_t *single_file_entry, uint16_t *utf16_string, size_t utf16_string_size, libcerror_error_t **error ) { static char *function = "libewf_single_file_entry_get_utf16_name"; if( single_file_entry == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid single file entry.", function ); return( -1 ); } if( utf16_string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid UTF-16 string.", function ); return( -1 ); } if( utf16_string_size == 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL, "%s: invalid UTF-16 string size value too small.", function ); return( -1 ); } if( ( single_file_entry->name == NULL ) || ( single_file_entry->name_size == 0 ) ) { utf16_string[ 0 ] = 0; } else { if( libuna_utf16_string_copy_from_utf8( utf16_string, utf16_string_size, single_file_entry->name, single_file_entry->name_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_COPY_FAILED, "%s: unable to copy name to UTF-16 string.", function ); return( -1 ); } } return( 1 ); }
/* Retrieves the UTF-8 encoded name value * The size should include the end of string character * Returns 1 if successful or -1 on error */ int libewf_single_file_entry_get_utf8_name( libewf_single_file_entry_t *single_file_entry, uint8_t *utf8_string, size_t utf8_string_size, libcerror_error_t **error ) { static char *function = "libewf_single_file_entry_get_utf8_name"; if( single_file_entry == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid single file entry.", function ); return( -1 ); } if( utf8_string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid UTF-8 string.", function ); return( -1 ); } if( utf8_string_size == 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL, "%s: invalid UTF-8 string size value too small.", function ); return( -1 ); } if( ( single_file_entry->name == NULL ) || ( single_file_entry->name_size == 0 ) ) { utf8_string[ 0 ] = 0; } else { if( utf8_string_size < single_file_entry->name_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL, "%s: invalid UTF-8 string size value too small.", function ); return( -1 ); } if( libcstring_narrow_string_copy( (char *) utf8_string, (char *) single_file_entry->name, single_file_entry->name_size ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_COPY_FAILED, "%s: unable to set UTF-8 string.", function ); return( -1 ); } utf8_string[ single_file_entry->name_size - 1 ] = 0; } return( 1 ); }
/* Initialize the single file entry * Returns 1 if successful or -1 on error */ int libewf_single_file_entry_initialize( libewf_single_file_entry_t **single_file_entry, libcerror_error_t **error ) { static char *function = "libewf_single_file_entry_initialize"; if( single_file_entry == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid single file entry.", function ); return( -1 ); } if( *single_file_entry != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid single file entry value already set.", function ); return( -1 ); } *single_file_entry = memory_allocate_structure( libewf_single_file_entry_t ); if( *single_file_entry == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create single file entry.", function ); goto on_error; } if( memory_set( *single_file_entry, 0, sizeof( libewf_single_file_entry_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear single file entry.", function ); goto on_error; } ( *single_file_entry )->data_offset = -1; ( *single_file_entry )->duplicate_data_offset = -1; return( 1 ); on_error: if( *single_file_entry != NULL ) { memory_free( *single_file_entry ); *single_file_entry = NULL; } return( -1 ); }
/* Retrieves a specific resource by type * Returns 1 if successful, 0 if no such resource or -1 on error */ int libwrc_stream_get_resource_by_type( libwrc_stream_t *stream, int type, libwrc_resource_t **resource, libcerror_error_t **error ) { libcdata_tree_node_t *resource_node = NULL; libwrc_internal_stream_t *internal_stream = NULL; libwrc_resource_values_t *resource_values = NULL; static char *function = "libwrc_stream_get_resource_by_type"; int number_of_resources = 0; int resource_index = 0; if( stream == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid stream.", function ); return( -1 ); } internal_stream = (libwrc_internal_stream_t *) stream; if( resource == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid resource.", function ); return( -1 ); } if( *resource != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid resource value already set.", function ); return( -1 ); } if( libcdata_tree_node_get_number_of_sub_nodes( internal_stream->resources_root_node, &number_of_resources, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve number of resources.", function ); return( -1 ); } if( libcdata_tree_node_get_sub_node_by_index( internal_stream->resources_root_node, 0, &resource_node, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve first resource node.", function ); return( -1 ); } for( resource_index = 0; resource_index < number_of_resources; resource_index++ ) { if( libcdata_tree_node_get_value( resource_node, (intptr_t **) &resource_values, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve value of resource node: %d.", function, resource_index ); return( -1 ); } if( resource_values == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: missing resource values: %d.", function, resource_index ); return( -1 ); } if( type == resource_values->type ) { if( libwrc_resource_initialize( resource, internal_stream->io_handle, internal_stream->file_io_handle, resource_node, LIBWRC_RESOURCE_FLAGS_DEFAULT, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create resource.", function ); return( -1 ); } return( 1 ); } if( libcdata_tree_node_get_next_node( resource_node, &resource_node, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve next node of resource node: %d.", function, resource_index ); return( -1 ); } } return( 0 ); }
/* Retrieves the key for the specific UTF-16 encoded path * The path separator is the \ character * Returns 1 if successful, 0 if no such key or -1 on error */ int libregf_file_get_key_by_utf16_path( libregf_file_t *file, const uint16_t *utf16_string, size_t utf16_string_length, libregf_key_t **key, libcerror_error_t **error ) { libfdata_tree_node_t *key_tree_node = NULL; libfdata_tree_node_t *key_tree_sub_node = NULL; libregf_internal_file_t *internal_file = NULL; libregf_key_item_t *key_item = NULL; libregf_key_item_t *sub_key_item = NULL; uint16_t *utf16_string_segment = NULL; static char *function = "libregf_file_get_key_by_utf16_path"; libuna_unicode_character_t unicode_character = 0; size_t utf16_string_index = 0; size_t utf16_string_segment_length = 0; uint32_t name_hash = 0; 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 = (libregf_internal_file_t *) file; if( internal_file->io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: invalid file - missing IO handle.", function ); return( -1 ); } if( utf16_string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid UTF-16 string.", function ); return( -1 ); } if( utf16_string_length > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid UTF-16 string length value exceeds maximum.", function ); return( -1 ); } if( key == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid key.", function ); return( -1 ); } if( *key != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: key already set.", function ); return( -1 ); } if( utf16_string_length > 0 ) { /* Ignore a leading separator */ if( utf16_string[ utf16_string_index ] == (uint16_t) LIBREGF_SEPARATOR ) { utf16_string_index++; } } if( libfdata_tree_get_root_node( internal_file->key_tree, &key_tree_node, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve key tree root node.", function ); return( -1 ); } if( libfdata_tree_node_get_node_value( key_tree_node, (intptr_t *) internal_file->file_io_handle, (libfdata_cache_t *) internal_file->key_cache, (intptr_t **) &key_item, 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve root key item.", function ); return( -1 ); } if( key_item == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: missing root key item.", function ); return( -1 ); } if( utf16_string_length == utf16_string_index ) { result = 1; } else while( utf16_string_index < utf16_string_length ) { utf16_string_segment = (uint16_t *) &( utf16_string[ utf16_string_index ] ); utf16_string_segment_length = utf16_string_index; name_hash = 0; while( utf16_string_index < utf16_string_length ) { if( libuna_unicode_character_copy_from_utf16( &unicode_character, utf16_string, utf16_string_length, &utf16_string_index, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_COPY_FAILED, "%s: unable to copy UTF-16 string to Unicode character.", function ); return( -1 ); } if( ( unicode_character == (libuna_unicode_character_t) LIBREGF_SEPARATOR ) || ( unicode_character == 0 ) ) { utf16_string_segment_length += 1; break; } name_hash *= 37; name_hash += (uint32_t) towupper( (wint_t) unicode_character ); } utf16_string_segment_length = utf16_string_index - utf16_string_segment_length; if( utf16_string_segment_length == 0 ) { result = 0; } else { result = libregf_key_tree_get_sub_key_values_by_utf16_name( key_tree_node, internal_file->file_io_handle, internal_file->key_cache, name_hash, utf16_string_segment, utf16_string_segment_length, internal_file->io_handle->ascii_codepage, &key_tree_sub_node, &sub_key_item, error ); } if( result == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve sub key values by name.", function ); return( -1 ); } else if( result == 0 ) { break; } key_tree_node = key_tree_sub_node; } if( result != 0 ) { if( libregf_key_initialize( key, internal_file->io_handle, internal_file->file_io_handle, key_tree_node, internal_file->key_cache, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create key.", function ); return( -1 ); } } return( result ); }
/* Retrieves a specific resource by an UTF-16 formatted name * Returns 1 if successful, 0 if no such resource or -1 on error */ int libwrc_stream_get_resource_by_utf16_name( libwrc_stream_t *stream, const uint16_t *utf16_string, size_t utf16_string_length, libwrc_resource_t **resource, libcerror_error_t **error ) { libcdata_tree_node_t *resource_node = NULL; libwrc_internal_stream_t *internal_stream = NULL; libwrc_resource_values_t *resource_values = NULL; static char *function = "libwrc_stream_get_resource_by_type"; int number_of_resources = 0; int resource_index = 0; int result = 0; if( stream == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid stream.", function ); return( -1 ); } internal_stream = (libwrc_internal_stream_t *) stream; if( resource == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid resource.", function ); return( -1 ); } if( *resource != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid resource value already set.", function ); return( -1 ); } if( libcdata_tree_node_get_number_of_sub_nodes( internal_stream->resources_root_node, &number_of_resources, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve number of resources.", function ); return( -1 ); } if( libcdata_tree_node_get_sub_node_by_index( internal_stream->resources_root_node, 0, &resource_node, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve first resource node.", function ); return( -1 ); } for( resource_index = 0; resource_index < number_of_resources; resource_index++ ) { if( libcdata_tree_node_get_value( resource_node, (intptr_t **) &resource_values, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve value of resource node: %d.", function, resource_index ); return( -1 ); } if( resource_values == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: missing resource values: %d.", function, resource_index ); return( -1 ); } if( resource_values->name_string_size > 0 ) { result = libuna_utf16_string_compare_with_utf16_stream( utf16_string, utf16_string_length + 1, resource_values->name_string, resource_values->name_string_size, LIBUNA_ENDIAN_LITTLE, error ); if( result == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GENERIC, "%s: unable to compare name of resource node: %d.", function, resource_index ); return( -1 ); } else if( result == LIBUNA_COMPARE_EQUAL ) { if( libwrc_resource_initialize( resource, internal_stream->io_handle, internal_stream->file_io_handle, resource_node, LIBWRC_RESOURCE_FLAGS_DEFAULT, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create resource.", function ); return( -1 ); } return( 1 ); } } if( libcdata_tree_node_get_next_node( resource_node, &resource_node, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve next node of resource node: %d.", function, resource_index ); return( -1 ); } } return( 0 ); }
/* Closes a file * Returns 0 if successful or -1 on error */ int libregf_file_close( libregf_file_t *file, libcerror_error_t **error ) { libregf_internal_file_t *internal_file = NULL; static char *function = "libregf_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 = (libregf_internal_file_t *) file; if( internal_file->io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: invalid file - missing 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( libregf_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( libregf_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->hive_bins_list != NULL ) { if( libregf_hive_bins_list_free( &( internal_file->hive_bins_list ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free hive bins list.", function ); result = -1; } } if( internal_file->key_tree != NULL ) { if( libfdata_tree_free( &( internal_file->key_tree ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free key tree.", function ); result = -1; } } if( internal_file->key_cache != NULL ) { if( libfcache_cache_free( &( internal_file->key_cache ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free key cache.", function ); result = -1; } } return( result ); }
/* Creates a stream * Make sure the value stream is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libwrc_stream_initialize( libwrc_stream_t **stream, libcerror_error_t **error ) { libwrc_internal_stream_t *internal_stream = NULL; static char *function = "libwrc_stream_initialize"; if( stream == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid stream.", function ); return( -1 ); } if( *stream != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid stream value already set.", function ); return( -1 ); } internal_stream = memory_allocate_structure( libwrc_internal_stream_t ); if( internal_stream == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create stream.", function ); goto on_error; } if( memory_set( internal_stream, 0, sizeof( libwrc_internal_stream_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear stream.", function ); memory_free( internal_stream ); return( -1 ); } if( libwrc_io_handle_initialize( &( internal_stream->io_handle ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create IO handle.", function ); goto on_error; } *stream = (libwrc_stream_t *) internal_stream; return( 1 ); on_error: if( internal_stream != NULL ) { memory_free( internal_stream ); } return( -1 ); }
/* Opens a file for reading * Returns 1 if successful or -1 on error */ int libregf_file_open_read( libregf_internal_file_t *internal_file, libbfio_handle_t *file_io_handle, libcerror_error_t **error ) { static char *function = "libregf_file_open_read"; size64_t file_size = 0; uint32_t hive_bins_size = 0; uint32_t root_key_offset = 0; int result = 0; if( internal_file == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid file.", function ); return( -1 ); } if( internal_file->io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: invalid file - missing IO handle.", function ); return( -1 ); } if( internal_file->hive_bins_list != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid file - hive bins list already set.", function ); return( -1 ); } if( internal_file->key_tree != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid file - key tree already set.", function ); return( -1 ); } if( libbfio_handle_get_size( file_io_handle, &file_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve file size.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "Reading file header:\n" ); } #endif if( libregf_io_handle_read_file_header( internal_file->io_handle, file_io_handle, &root_key_offset, &hive_bins_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read file header.", function ); goto on_error; } if( ( internal_file->io_handle->file_type == LIBREGF_FILE_TYPE_REGISTRY ) && ( file_size > 4096 ) ) { /* TODO print data between header and hive bins list offset ? */ #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "Reading hive bins:\n" ); } #endif internal_file->io_handle->hive_bins_list_offset = 4096; if( libregf_hive_bins_list_initialize( &( internal_file->hive_bins_list ), internal_file->io_handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create hive bins list.", function ); goto on_error; } result = libregf_hive_bins_list_read( internal_file->hive_bins_list, file_io_handle, internal_file->io_handle->hive_bins_list_offset, hive_bins_size, error ); if( result == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read hive bins.", function ); goto on_error; } else if( result != 0 ) { /* TODO free & clone function */ if( libfdata_tree_initialize( &( internal_file->key_tree ), (intptr_t *) internal_file->hive_bins_list, NULL, NULL, (int (*)(intptr_t *, intptr_t *, libfdata_tree_node_t *, libfdata_cache_t *, int, off64_t, size64_t, uint32_t, uint8_t, libcerror_error_t **)) &libregf_key_item_read_node_data, (int (*)(intptr_t *, intptr_t *, libfdata_tree_node_t *, libfdata_cache_t *, int, off64_t, size64_t, uint32_t, uint8_t, libcerror_error_t **)) &libregf_key_item_read_sub_nodes, LIBFDATA_DATA_HANDLE_FLAG_NON_MANAGED, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create key tree.", function ); goto on_error; } if( libfcache_cache_initialize( &( internal_file->key_cache ), LIBREGF_MAXIMUM_CACHE_ENTRIES_KEYS, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create key cache.", function ); goto on_error; } if( libfdata_tree_set_root_node( internal_file->key_tree, 0, (off64_t) root_key_offset, 0, 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set key tree root node.", function ); goto on_error; } } } return( 1 ); on_error: if( internal_file->key_cache != NULL ) { libfcache_cache_free( &( internal_file->key_cache ), NULL ); } if( internal_file->key_tree != NULL ) { libfdata_tree_free( &( internal_file->key_tree ), NULL ); } if( internal_file->hive_bins_list != NULL ) { libregf_hive_bins_list_free( &( internal_file->hive_bins_list ), NULL ); } return( -1 ); }
/* Closes a stream * Returns 0 if successful or -1 on error */ int libwrc_stream_close( libwrc_stream_t *stream, libcerror_error_t **error ) { libwrc_internal_stream_t *internal_stream = NULL; static char *function = "libwrc_stream_close"; int result = 0; if( stream == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid stream.", function ); return( -1 ); } internal_stream = (libwrc_internal_stream_t *) stream; if( internal_stream->file_io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: invalid stream - missing file IO handle.", function ); return( -1 ); } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { if( internal_stream->file_io_handle_created_in_library != 0 ) { if( libwrc_debug_print_read_offsets( internal_stream->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_stream->file_io_handle_opened_in_library != 0 ) { if( libbfio_handle_close( internal_stream->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_stream->file_io_handle_opened_in_library = 0; } if( internal_stream->file_io_handle_created_in_library != 0 ) { if( libbfio_handle_free( &( internal_stream->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_stream->file_io_handle_created_in_library = 0; } internal_stream->file_io_handle = NULL; if( libwrc_io_handle_clear( internal_stream->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_tree_node_free( &( internal_stream->resources_root_node ), (int (*)(intptr_t **, libcerror_error_t **)) &libwrc_resource_values_free, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free resources root node.", function ); result = -1; } return( result ); }
/* Reads a chunk of data from the file descriptor into the buffer * Returns the number of bytes read, 0 if at end of input or -1 on error */ ssize_t ewfacquirestream_read_chunk( libewf_handle_t *handle, int input_file_descriptor, uint8_t *buffer, size_t buffer_size, size32_t chunk_size, ssize64_t total_read_count, uint8_t read_error_retries, libcerror_error_t **error ) { static char *function = "ewfacquirestream_read_chunk"; ssize_t read_count = 0; ssize_t buffer_offset = 0; size_t read_size = 0; size_t bytes_to_read = 0; int32_t read_number_of_errors = 0; uint32_t read_error_offset = 0; if( handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid handle.", function ); return( -1 ); } if( input_file_descriptor == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid input file descriptor.", function ); return( -1 ); } if( buffer == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid buffer.", function ); return( -1 ); } if( buffer_size > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid buffer size value exceeds maximum.", function ); return( -1 ); } if( chunk_size == 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS, "%s: invalid chunk size value zero or less.", function ); return( -1 ); } if( total_read_count <= -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO, "%s: invalid total read count value less than zero.", function ); return( -1 ); } while( buffer_size > 0 ) { /* Determine the number of bytes to read from the input * Read as much as possible in chunk sizes */ if( buffer_size < (size_t) chunk_size ) { read_size = buffer_size; } else { read_size = chunk_size; } bytes_to_read = read_size; while( read_number_of_errors <= read_error_retries ) { read_count = libcsystem_file_io_read( input_file_descriptor, &( buffer[ buffer_offset + read_error_offset ] ), bytes_to_read ); #if defined( HAVE_VERBOSE_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: read buffer at: %" PRIu64 " of size: %" PRIzd ".\n", function, total_read_count, read_count ); } #endif if( read_count <= -1 ) { if( ( errno == ESPIPE ) || ( errno == EPERM ) || ( errno == ENXIO ) || ( errno == ENODEV ) ) { if( errno == ESPIPE ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: error reading data: invalid seek.", function ); } else if( errno == EPERM ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: error reading data: operation not permitted.", function ); } else if( errno == ENXIO ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: error reading data: no such device or address.", function ); } else if( errno == ENODEV ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: error reading data: no such device.", function ); } else { libcerror_system_set_error( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, errno, "%s: error reading data.", function ); } return( -1 ); } } else { /* The last read is OK, correct read_count */ if( read_count == (ssize_t) bytes_to_read ) { read_count = read_error_offset + bytes_to_read; } /* The entire read is OK */ if( read_count == (ssize_t) read_size ) { break; } /* If no end of input can be determined */ /* If some bytes were read it is possible that the end of the input reached */ if( read_count > 0 ) { return( (ssize32_t) ( buffer_offset + read_count ) ); } /* No bytes were read */ if( read_count == 0 ) { return( 0 ); } #if defined( HAVE_VERBOSE_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: read error at offset %" PRIjd " after reading %" PRIzd " bytes.\n", function, total_read_count, read_count ); } #endif /* There was a read error at a certain offset */ read_error_offset += (uint32_t) read_count; bytes_to_read -= read_count; } read_number_of_errors++; if( read_number_of_errors > read_error_retries ) { return( 0 ); } } buffer_size -= read_count; buffer_offset += read_count; /* At the end of the input */ if( ewfacquirestream_abort != 0 ) { break; } } return( buffer_offset ); }
/* Clones (duplicates) the group * Returns 1 if successful or -1 on error */ int libmfdata_group_clone( libmfdata_group_t **destination_group, libmfdata_group_t *source_group, libcerror_error_t **error ) { static char *function = "libmfdata_group_clone"; if( destination_group == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid destination group.", function ); return( -1 ); } if( *destination_group != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: destination group already set.", function ); return( -1 ); } if( source_group == NULL ) { *destination_group = NULL; return( 1 ); } *destination_group = memory_allocate_structure( libmfdata_group_t ); if( *destination_group == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create destination group.", function ); goto on_error; } if( memory_copy( *destination_group, source_group, sizeof( libmfdata_group_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_COPY_FAILED, "%s: unable to copy source to destination group.", function ); goto on_error; } return( 1 ); on_error: if( *destination_group != NULL ) { memory_free( *destination_group ); *destination_group = NULL; } return( -1 ); }
/* Reads the input * Returns 1 if successful or -1 on error */ int ewfacquirestream_read_input( imaging_handle_t *imaging_handle, int input_file_descriptor, uint8_t swap_byte_pairs, uint8_t read_error_retries, uint8_t print_status_information, uint8_t use_chunk_data_functions, log_handle_t *log_handle, libcerror_error_t **error ) { process_status_t *process_status = NULL; storage_media_buffer_t *storage_media_buffer = NULL; uint8_t *data = NULL; static char *function = "ewfacquirestream_read_input"; size64_t acquiry_count = 0; size32_t chunk_size = 0; size_t data_size = 0; size_t process_buffer_size = 0; size_t read_size = 0; ssize_t read_count = 0; ssize_t process_count = 0; ssize_t write_count = 0; uint8_t storage_media_buffer_mode = 0; int status = PROCESS_STATUS_COMPLETED; if( imaging_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid imaging handle.", function ); return( -1 ); } if( imaging_handle->process_buffer_size > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid imaging handle - process buffer size value exceeds maximum.", function ); return( -1 ); } if( input_file_descriptor == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid file descriptor.", function ); return( -1 ); } if( imaging_handle_get_chunk_size( imaging_handle, &chunk_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve chunk size.", function ); goto on_error; } if( chunk_size == 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: missing chunk size.", function ); return( -1 ); } if( use_chunk_data_functions != 0 ) { process_buffer_size = (size_t) chunk_size; storage_media_buffer_mode = STORAGE_MEDIA_BUFFER_MODE_CHUNK_DATA; } else { if( imaging_handle->process_buffer_size == 0 ) { process_buffer_size = (size_t) chunk_size; } else { process_buffer_size = imaging_handle->process_buffer_size; } storage_media_buffer_mode = STORAGE_MEDIA_BUFFER_MODE_BUFFERED; } if( storage_media_buffer_initialize( &storage_media_buffer, storage_media_buffer_mode, process_buffer_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create storage media buffer.", function ); goto on_error; } if( imaging_handle_initialize_integrity_hash( imaging_handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to initialize integrity hash(es).", function ); goto on_error; } if( process_status_initialize( &process_status, _LIBCSTRING_SYSTEM_STRING( "Acquiry" ), _LIBCSTRING_SYSTEM_STRING( "acquired" ), _LIBCSTRING_SYSTEM_STRING( "Written" ), stdout, print_status_information, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create process status.", function ); goto on_error; } if( process_status_start( process_status, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to start process status.", function ); goto on_error; } while( ( imaging_handle->acquiry_size == 0 ) || ( acquiry_count < (size64_t) imaging_handle->acquiry_size ) ) { read_size = process_buffer_size; /* Align with acquiry offset if necessary */ if( ( imaging_handle->acquiry_offset != 0 ) && ( imaging_handle->acquiry_offset < (uint64_t) read_size ) ) { read_size = (size_t) imaging_handle->acquiry_offset; } else if( ( imaging_handle->acquiry_size != 0 ) && ( ( (size64_t) imaging_handle->acquiry_size - acquiry_count ) < (size64_t) read_size ) ) { read_size = (size_t) ( (ssize64_t) imaging_handle->acquiry_size - acquiry_count ); } /* Read a chunk from the file descriptor */ read_count = ewfacquirestream_read_chunk( imaging_handle->output_handle, input_file_descriptor, storage_media_buffer->raw_buffer, storage_media_buffer->raw_buffer_size, (size32_t) read_size, acquiry_count, read_error_retries, error ); if( read_count < 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: error reading data from input.", function ); goto on_error; } if( read_count == 0 ) { break; } if( storage_media_buffer->mode == STORAGE_MEDIA_BUFFER_MODE_CHUNK_DATA ) { storage_media_buffer->data_in_compression_buffer = 0; } storage_media_buffer->raw_buffer_data_size = (size_t) read_count; /* Skip a certain number of bytes if necessary */ if( (size64_t) imaging_handle->acquiry_offset > acquiry_count ) { imaging_handle->acquiry_offset -= read_count; continue; } /* Swap byte pairs */ if( swap_byte_pairs == 1 ) { if( imaging_handle_swap_byte_pairs( imaging_handle, storage_media_buffer, read_count, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_CONVERSION, LIBCERROR_CONVERSION_ERROR_GENERIC, "%s: unable to swap byte pairs.", function ); goto on_error; } } /* Digest hashes are calcultated after swap */ if( storage_media_buffer_get_data( storage_media_buffer, &data, &data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve storage media buffer data.", function ); goto on_error; } if( imaging_handle_update_integrity_hash( imaging_handle, data, read_count, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GENERIC, "%s: unable to update integrity hash(es).", function ); goto on_error; } process_count = imaging_handle_prepare_write_buffer( imaging_handle, storage_media_buffer, error ); if( process_count < 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to prepare buffer before write.", function ); goto on_error; } write_count = imaging_handle_write_buffer( imaging_handle, storage_media_buffer, process_count, error ); if( write_count < 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_WRITE_FAILED, "%s: unable to write data to file.", function ); goto on_error; } acquiry_count += read_count; if( process_status_update_unknown_total( process_status, acquiry_count, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to update process status.", function ); goto on_error; } if( ewfacquirestream_abort != 0 ) { break; } } if( storage_media_buffer_free( &storage_media_buffer, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free storage media buffer.", function ); goto on_error; } if( imaging_handle_finalize_integrity_hash( imaging_handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to finalize integrity hash(es).", function ); goto on_error; } write_count = imaging_handle_finalize( imaging_handle, error ); if( write_count == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_WRITE_FAILED, "%s: unable to finalize write.", function ); goto on_error; } acquiry_count += write_count; if( ewfacquirestream_abort != 0 ) { status = PROCESS_STATUS_ABORTED; } if( process_status_stop( process_status, acquiry_count, status, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to stop process status.", function ); goto on_error; } if( process_status_free( &process_status, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free process status.", function ); goto on_error; } if( ewfacquirestream_abort == 0 ) { if( imaging_handle_print_hashes( imaging_handle, imaging_handle->notify_stream, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_PRINT_FAILED, "%s: unable to print hashes.", function ); goto on_error; } if( log_handle != NULL ) { if( imaging_handle_print_hashes( imaging_handle, log_handle->log_stream, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_PRINT_FAILED, "%s: unable to print hashes in log handle.", function ); goto on_error; } } } return( 1 ); on_error: if( process_status != NULL ) { process_status_stop( process_status, (size64_t) write_count, PROCESS_STATUS_FAILED, NULL ); process_status_free( &process_status, NULL ); } if( storage_media_buffer != NULL ) { storage_media_buffer_free( &storage_media_buffer, NULL ); } return( -1 ); }
/* Creates a log handle * Make sure the value log_handle is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int log_handle_initialize( log_handle_t **log_handle, libcerror_error_t **error ) { static char *function = "log_handle_initialize"; if( log_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid log handle.", function ); return( -1 ); } if( *log_handle != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid log handle value already set.", function ); return( -1 ); } *log_handle = memory_allocate_structure( log_handle_t ); if( *log_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create log handle.", function ); goto on_error; } if( memory_set( *log_handle, 0, sizeof( log_handle_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear log handle.", function ); goto on_error; } return( 1 ); on_error: if( *log_handle != NULL ) { memory_free( *log_handle ); *log_handle = NULL; } return( -1 ); }
/* Attaches a signal handler for Ctrl+C or Ctrl+Break signals * Returns 1 if successful or -1 on error */ int mdmptools_signal_attach( void (*signal_handler)( mdmptools_signal_t ), libcerror_error_t **error ) { static char *function = "mdmptools_signal_attach"; if( signal_handler == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid signal handler.", function ); return( -1 ); } mdmptools_signal_signal_handler = signal_handler; if( SetConsoleCtrlHandler( mdmptools_signal_handler, TRUE ) == 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to attach signal handler.", function ); return( -1 ); } if( SetConsoleCtrlHandler( NULL, FALSE ) == 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to attach break signal.", function ); return( -1 ); } #if defined( _MSC_VER ) mdmptools_signal_initialize_memory_debug(); #endif SetErrorMode( SEM_FAILCRITICALERRORS ); #if defined( LOCALE_SUPPORT ) /* Allow subsequent threads to have their own locale. * If the application is single threaded this call has * no practical effect. */ _configthreadlocale( _ENABLE_PER_THREAD_LOCALE ); /* Set the current thread locale to the user default * ANSI code page. */ setlocale( LC_ALL, "" ); /* Set the the code page used by multibyte functions * to use the same code page as the previous call to setlocale. */ _setmbcp( _MB_CP_LOCALE ); #endif /* defined( LOCALE_SUPPORT ) */ return( 1 ); }
/* Determines if a file contains an EVT file signature * Returns 1 if true, 0 if not or -1 on error */ int libevt_check_file_signature_wide( const wchar_t *filename, libcerror_error_t **error ) { libbfio_handle_t *file_io_handle = NULL; static char *function = "libevt_check_file_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 = libevt_check_file_signature_file_io_handle( file_io_handle, error ); if( result == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to check file signature using a file handle.", function ); goto on_error; } if( libbfio_handle_free( &file_io_handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to free file IO handle.", function ); goto on_error; } return( result ); on_error: if( file_io_handle != NULL ) { libbfio_handle_free( &file_io_handle, NULL ); } return( -1 ); }
/* Retrieves a specific resource * Returns 1 if successful or -1 on error */ int libwrc_stream_get_resource( libwrc_stream_t *stream, int resource_index, libwrc_resource_t **resource, libcerror_error_t **error ) { libcdata_tree_node_t *resource_node = NULL; libwrc_internal_stream_t *internal_stream = NULL; static char *function = "libwrc_stream_get_resource"; if( stream == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid stream.", function ); return( -1 ); } internal_stream = (libwrc_internal_stream_t *) stream; if( resource == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid resource.", function ); return( -1 ); } if( *resource != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid resource value already set.", function ); return( -1 ); } if( libcdata_tree_node_get_sub_node_by_index( internal_stream->resources_root_node, resource_index, &resource_node, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve event resource node: %d.", function, resource_index ); return( -1 ); } if( libwrc_resource_initialize( resource, internal_stream->io_handle, internal_stream->file_io_handle, resource_node, LIBWRC_RESOURCE_FLAGS_DEFAULT, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create resource.", function ); return( -1 ); } return( 1 ); }
/* Retrieves the name of a directory entry by name ignoring case * If a corresponding entry is found entry name is update * This function is needed to find case insensitive directory entries on a case sensitive system * Return 1 if successful, 0 if no corresponding entry was found or -1 on error */ int path_handle_get_directory_entry_name_by_name_no_case( path_handle_t *path_handle, const libcstring_system_character_t *path, size_t path_length, libcstring_system_character_t *entry_name, size_t entry_name_size, uint8_t entry_type, libcerror_error_t **error ) { libcdirectory_directory_t *directory = NULL; libcdirectory_directory_entry_t *directory_entry = NULL; libcstring_system_character_t *directory_entry_name = NULL; static char *function = "path_handle_get_directory_entry_name_by_name_no_case"; size_t directory_entry_name_length = 0; int result = 0; if( path_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid path handle.", function ); return( -1 ); } if( path_length > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid path length value exceeds maximum.", function ); return( -1 ); } if( entry_name == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid entry name.", function ); return( -1 ); } if( entry_name_size > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid entry name size value exceeds maximum.", function ); return( -1 ); } if( entry_name == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid entry name.", function ); return( -1 ); } if( libcdirectory_directory_initialize( &directory, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create directory.", function ); goto on_error; } #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) result = libcdirectory_directory_open_wide( directory, path, error ); #else result = libcdirectory_directory_open( directory, path, error ); #endif if( result != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open directory: %" PRIs_LIBCSTRING_SYSTEM ".", function, path ); goto on_error; } if( libcdirectory_directory_entry_initialize( &directory_entry, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create directory entry.", function ); goto on_error; } #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) result = libcdirectory_directory_has_entry_wide( directory, directory_entry, entry_name, entry_name_size - 1, entry_type, LIBCDIRECTORY_COMPARE_FLAG_NO_CASE, error ); #else result = libcdirectory_directory_has_entry( directory, directory_entry, entry_name, entry_name_size - 1, entry_type, LIBCDIRECTORY_COMPARE_FLAG_NO_CASE, error ); #endif if( result == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_GENERIC, "%s: unable to determine if directory has entry: %" PRIs_LIBCSTRING_SYSTEM ".", function, entry_name ); goto on_error; } else if( result != 0 ) { #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) result = libcdirectory_directory_entry_get_name_wide( directory_entry, (wchar_t **) &directory_entry_name, error ); #else result = libcdirectory_directory_entry_get_name( directory_entry, (char **) &directory_entry_name, error ); #endif if( result != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve directory entry name.", function ); goto on_error; } directory_entry_name_length = libcstring_system_string_length( directory_entry_name ); if( ( directory_entry_name_length + 1 ) != entry_name_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS, "%s: entry name length value out of bounds.", function ); goto on_error; } if( libcstring_system_string_copy( entry_name, directory_entry_name, directory_entry_name_length ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set entry name.", function ); goto on_error; } } if( libcdirectory_directory_entry_free( &directory_entry, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free directory entry.", function ); goto on_error; } if( libcdirectory_directory_close( directory, error ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_CLOSE_FAILED, "%s: unable to close directory.", function ); goto on_error; } if( libcdirectory_directory_free( &directory, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free directory.", function ); goto on_error; } return( result ); on_error: if( directory_entry != NULL ) { libcdirectory_directory_entry_free( &directory_entry, NULL ); } if( directory != NULL ) { libcdirectory_directory_free( &directory, NULL ); } return( -1 ); }
/* Retrieves the UTF-16 encoded SHA1 hash value * Returns 1 if successful, 0 if value not present or -1 on error */ int libewf_single_file_entry_get_utf16_hash_value_sha1( libewf_single_file_entry_t *single_file_entry, uint16_t *utf16_string, size_t utf16_string_size, libcerror_error_t **error ) { static char *function = "libewf_single_file_entry_get_utf16_hash_value_sha1"; if( single_file_entry == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid single file entry.", function ); return( -1 ); } if( utf16_string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid UTF-16 string.", function ); return( -1 ); } if( utf16_string_size > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid UTF-16 string size value exceeds maximum.", function ); return( -1 ); } if( utf16_string_size < single_file_entry->sha1_hash_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL, "%s: UTF-16 string too small.", function ); return( -1 ); } if( single_file_entry->sha1_hash_size == 0 ) { return( 0 ); } if( libuna_utf16_string_copy_from_utf8( utf16_string, utf16_string_size, single_file_entry->sha1_hash, single_file_entry->sha1_hash_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_COPY_FAILED, "%s: unable to copy SHA1 hash to UTF-16 string.", function ); return( -1 ); } return( 1 ); }