/* Reads a page and its values * Returns 1 if successful or -1 on error */ int libesedb_page_read( libesedb_page_t *page, libesedb_io_handle_t *io_handle, libbfio_handle_t *file_io_handle, off64_t file_offset, libcerror_error_t **error ) { libcdata_array_t *page_tags_array = NULL; uint8_t *page_values_data = NULL; static char *function = "libesedb_page_read"; size_t page_values_data_offset = 0; size_t page_values_data_size = 0; ssize_t read_count = 0; uint32_t calculated_ecc32_checksum = 0; uint32_t calculated_page_number = 0; uint32_t calculated_xor32_checksum = 0; uint32_t stored_ecc32_checksum = 0; uint32_t stored_page_number = 0; uint32_t stored_xor32_checksum = 0; uint16_t available_data_size = 0; uint16_t available_page_tag = 0; #if defined( HAVE_DEBUG_OUTPUT ) uint64_t value_64bit = 0; uint16_t value_16bit = 0; #endif if( page == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid page.", function ); return( -1 ); } if( page->data != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid page data already set.", function ); return( -1 ); } if( io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid IO handle.", function ); return( -1 ); } calculated_page_number = (uint32_t) ( ( file_offset - io_handle->page_size ) / io_handle->page_size ); page->offset = file_offset; #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: reading page: %" PRIu32 " at offset: %" PRIi64 " (0x%08" PRIx64 ")\n", function, calculated_page_number, page->offset, page->offset ); } #endif if( libbfio_handle_seek_offset( file_io_handle, page->offset, SEEK_SET, error ) == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_SEEK_FAILED, "%s: unable to seek page offset: %" PRIi64 ".", function, page->offset ); goto on_error; } page->data = (uint8_t *) memory_allocate( (size_t) io_handle->page_size ); if( page->data == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create page data.", function ); goto on_error; } page->data_size = (size_t) io_handle->page_size; read_count = libbfio_handle_read_buffer( file_io_handle, page->data, page->data_size, error ); if( read_count != (ssize_t) page->data_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read page data.", function ); goto on_error; } page_values_data = page->data; page_values_data_size = page->data_size; #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: page header:\n", function ); libcnotify_print_data( page_values_data, sizeof( esedb_page_header_t ), 0 ); } #endif page->page_number = calculated_page_number; byte_stream_copy_to_uint16_little_endian( ( (esedb_page_header_t *) page_values_data )->available_data_size, available_data_size ); byte_stream_copy_to_uint32_little_endian( ( (esedb_page_header_t *) page_values_data )->previous_page, page->previous_page_number ); byte_stream_copy_to_uint32_little_endian( ( (esedb_page_header_t *) page_values_data )->next_page, page->next_page_number ); byte_stream_copy_to_uint32_little_endian( ( (esedb_page_header_t *) page_values_data )->father_data_page_object_identifier, page->father_data_page_object_identifier ); byte_stream_copy_to_uint16_little_endian( ( (esedb_page_header_t *) page_values_data )->available_page_tag, available_page_tag ); byte_stream_copy_to_uint32_little_endian( ( (esedb_page_header_t *) page_values_data )->page_flags, page->flags ); /* Make sure to read after the page flags */ if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_EXTENDED_PAGE_HEADER ) && ( io_handle->page_size >= 16384 ) ) { /* TODO handle checksum */ } else { byte_stream_copy_to_uint32_little_endian( ( (esedb_page_header_t *) page_values_data )->xor_checksum, stored_xor32_checksum ); if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_NEW_RECORD_FORMAT ) && ( ( page->flags & LIBESEDB_PAGE_FLAG_IS_NEW_RECORD_FORMAT ) != 0 ) ) { byte_stream_copy_to_uint32_little_endian( ( (esedb_page_header_t *) page_values_data )->ecc_checksum, stored_ecc32_checksum ); } else { byte_stream_copy_to_uint32_little_endian( ( (esedb_page_header_t *) page_values_data )->page_number, stored_page_number ); } } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: current page number\t\t\t\t\t: %" PRIu32 "\n", function, calculated_page_number ); if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_EXTENDED_PAGE_HEADER ) && ( io_handle->page_size >= 16384 ) ) { /* TODO handle checksum */ byte_stream_copy_to_uint64_little_endian( page_values_data, value_64bit ); libcnotify_printf( "%s: checksum\t\t\t\t\t\t: 0x%08" PRIx64 "\n", function, value_64bit ); } else { libcnotify_printf( "%s: XOR checksum\t\t\t\t\t: 0x%08" PRIx32 "\n", function, stored_xor32_checksum ); if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_NEW_RECORD_FORMAT ) && ( ( page->flags & LIBESEDB_PAGE_FLAG_IS_NEW_RECORD_FORMAT ) != 0 ) ) { libcnotify_printf( "%s: ECC checksum\t\t\t\t\t: 0x%08" PRIx32 "\n", function, stored_ecc32_checksum ); } else { libcnotify_printf( "%s: page number\t\t\t\t\t\t: %" PRIu32 "\n", function, stored_page_number ); } } libcnotify_printf( "%s: database modification time:\n", function ); libcnotify_print_data( ( (esedb_page_header_t *) page_values_data )->database_modification_time, 8, 0 ); libcnotify_printf( "%s: previous page number\t\t\t\t: %" PRIu32 "\n", function, page->previous_page_number ); libcnotify_printf( "%s: next page number\t\t\t\t\t: %" PRIu32 "\n", function, page->next_page_number ); libcnotify_printf( "%s: father data page (FDP) object identifier\t\t: %" PRIu32 "\n", function, page->father_data_page_object_identifier ); libcnotify_printf( "%s: available data size\t\t\t\t\t: %" PRIu32 "\n", function, available_data_size ); byte_stream_copy_to_uint16_little_endian( ( (esedb_page_header_t *) page_values_data )->available_uncommitted_data_size, value_16bit ); libcnotify_printf( "%s: available uncommitted data size\t\t\t: %" PRIu16 "\n", function, value_16bit ); byte_stream_copy_to_uint16_little_endian( ( (esedb_page_header_t *) page_values_data )->available_data_offset, value_16bit ); libcnotify_printf( "%s: available data offset\t\t\t\t: %" PRIu16 "\n", function, value_16bit ); libcnotify_printf( "%s: available page tag\t\t\t\t\t: %" PRIu32 "\n", function, available_page_tag ); libcnotify_printf( "%s: page flags\t\t\t\t\t\t: 0x%08" PRIx32 "\n", function, page->flags ); libesedb_debug_print_page_flags( page->flags ); libcnotify_printf( "\n" ); } #endif /* TODO for now don't bother calculating a checksum for uninitialized pages */ if( ( page_values_data[ 0 ] != 0 ) || ( page_values_data[ 1 ] != 0 ) || ( page_values_data[ 2 ] != 0 ) || ( page_values_data[ 3 ] != 0 ) ) { if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_EXTENDED_PAGE_HEADER ) && ( io_handle->page_size >= 16384 ) ) { /* TODO handle checksum */ } else if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_NEW_RECORD_FORMAT ) && ( ( page->flags & LIBESEDB_PAGE_FLAG_IS_NEW_RECORD_FORMAT ) != 0 ) ) { if( libesedb_checksum_calculate_little_endian_ecc32( &calculated_ecc32_checksum, &calculated_xor32_checksum, page_values_data, page_values_data_size, 8, calculated_page_number, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE, "%s: unable to calculate ECC-32 and XOR-32 checksum.", function ); goto on_error; } } else { if( libesedb_checksum_calculate_little_endian_xor32( &calculated_xor32_checksum, &( page_values_data[ 4 ] ), page_values_data_size - 4, 0x89abcdef, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE, "%s: unable to calculate XOR-32 checksum.", function ); goto on_error; } } if( stored_xor32_checksum != calculated_xor32_checksum ) { #ifdef TODO libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_INPUT, LIBCERROR_INPUT_ERROR_CRC_MISMATCH, "%s: mismatch in page XOR-32 checksum ( 0x%08" PRIx32 " != 0x%08" PRIx32 " ).", function, stored_xor32_checksum, calculated_xor32_checksum ); goto on_error; #else if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: mismatch in page XOR-32 checksum ( 0x%08" PRIx32 " != 0x%08" PRIx32 " ).\n", function, stored_xor32_checksum, calculated_xor32_checksum ); } #endif } if( stored_ecc32_checksum != calculated_ecc32_checksum ) { #ifdef TODO libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_INPUT, LIBCERROR_INPUT_ERROR_CRC_MISMATCH, "%s: mismatch in page ECC-32 checksum ( 0x%08" PRIx32 " != 0x%08" PRIx32 " ).", function, stored_ecc32_checksum, calculated_ecc32_checksum ); goto on_error; #else if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: mismatch in page ECC-32 checksum ( 0x%08" PRIx32 " != 0x%08" PRIx32 " ).\n", function, stored_ecc32_checksum, calculated_ecc32_checksum ); } #endif } } page_values_data += sizeof( esedb_page_header_t ); page_values_data_size -= sizeof( esedb_page_header_t ); page_values_data_offset += sizeof( esedb_page_header_t ); if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_EXTENDED_PAGE_HEADER ) && ( io_handle->page_size >= 16384 ) ) { #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: extended page header:\n", function ); libcnotify_print_data( page_values_data, 40, 0 ); } #endif #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { byte_stream_copy_to_uint64_little_endian( ( (esedb_extended_page_header_t *) page_values_data )->checksum1, value_64bit ); libcnotify_printf( "%s: checksum1\t\t\t\t\t\t: 0x%08" PRIx64 "\n", function, value_64bit ); byte_stream_copy_to_uint64_little_endian( ( (esedb_extended_page_header_t *) page_values_data )->checksum2, value_64bit ); libcnotify_printf( "%s: checksum2\t\t\t\t\t\t: 0x%08" PRIx64 "\n", function, value_64bit ); byte_stream_copy_to_uint64_little_endian( ( (esedb_extended_page_header_t *) page_values_data )->checksum3, value_64bit ); libcnotify_printf( "%s: checksum3\t\t\t\t\t\t: 0x%08" PRIx64 "\n", function, value_64bit ); byte_stream_copy_to_uint64_little_endian( ( (esedb_extended_page_header_t *) page_values_data )->page_number, value_64bit ); libcnotify_printf( "%s: page number\t\t\t\t\t\t: %" PRIu64 "\n", function, value_64bit ); libcnotify_printf( "%s: unknown1:\n", function ); libcnotify_print_data( ( (esedb_extended_page_header_t *) page_values_data )->unknown1, 8, 0 ); } #endif page_values_data += sizeof( esedb_extended_page_header_t ); page_values_data_size -= sizeof( esedb_extended_page_header_t ); page_values_data_offset += sizeof( esedb_extended_page_header_t ); } if( available_page_tag > 0 ) { /* Create the page tags array */ if( libcdata_array_initialize( &page_tags_array, 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create page tags array.", function ); goto on_error; } if( libesedb_page_read_tags( page_tags_array, io_handle, available_page_tag, page->data, page->data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read page tags.", function ); goto on_error; } /* The offsets in the page tags are relative after the page header */ if( libesedb_page_read_values( page, io_handle, page_tags_array, page_values_data, page_values_data_size, page_values_data_offset, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read page values.", function ); goto on_error; } if( libcdata_array_free( &page_tags_array, (int (*)(intptr_t **, libcerror_error_t **)) &libesedb_page_tags_value_free, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free the page tags array.", function ); goto on_error; } } return( 1 ); on_error: if( page_tags_array != NULL ) { libcdata_array_free( &page_tags_array, (int (*)(intptr_t **, libcerror_error_t **)) &libesedb_page_tags_value_free, NULL ); } if( page->data != NULL ) { memory_free( page->data ); page->data = NULL; } return( -1 ); }
/* Creates an external key * Make sure the value external key is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libbde_external_key_initialize( libbde_external_key_t **external_key, libcerror_error_t **error ) { static char *function = "libbde_external_key_initialize"; if( external_key == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid external key.", function ); return( -1 ); } if( *external_key != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid external key value already set.", function ); return( -1 ); } *external_key = memory_allocate_structure( libbde_external_key_t ); if( *external_key == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create external key.", function ); goto on_error; } if( memory_set( *external_key, 0, sizeof( libbde_external_key_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear external key.", function ); goto on_error; } if( libcdata_array_initialize( &( ( *external_key )->entries_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create entries array.", function ); goto on_error; } return( 1 ); on_error: if( *external_key != NULL ) { memory_free( *external_key ); *external_key = NULL; } return( -1 ); }
/* Creates a page * Make sure the value page is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libesedb_page_initialize( libesedb_page_t **page, libcerror_error_t **error ) { static char *function = "libesedb_page_initialize"; if( page == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid page.", function ); return( -1 ); } if( *page != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid page value already set.", function ); return( -1 ); } *page = memory_allocate_structure( libesedb_page_t ); if( *page == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create page.", function ); goto on_error; } if( memory_set( *page, 0, sizeof( libesedb_page_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear page.", function ); goto on_error; } if( libcdata_array_initialize( &( ( *page )->values_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create page values array.", function ); goto on_error; } return( 1 ); on_error: if( *page != NULL ) { memory_free( *page ); *page = NULL; } return( -1 ); }
/* Creates a file system * Make sure the value file_system is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int mount_file_system_initialize( mount_file_system_t **file_system, libcerror_error_t **error ) { #if defined( WINAPI ) FILETIME filetime; SYSTEMTIME systemtime; #elif defined( HAVE_CLOCK_GETTIME ) struct timespec time_structure; #endif static char *function = "mount_file_system_initialize"; #if defined( WINAPI ) DWORD error_code = 0; #else int64_t timestamp = 0; #endif if( file_system == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid file system.", function ); return( -1 ); } if( *file_system != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid file system value already set.", function ); return( -1 ); } *file_system = memory_allocate_structure( mount_file_system_t ); if( *file_system == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create file system.", function ); goto on_error; } if( memory_set( *file_system, 0, sizeof( mount_file_system_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear file system.", function ); memory_free( *file_system ); *file_system = NULL; return( -1 ); } if( libcdata_array_initialize( &( ( *file_system )->handles_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to initialize handles array.", function ); goto on_error; } #if defined( WINAPI ) if( memory_set( &systemtime, 0, sizeof( SYSTEMTIME ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear systemtime.", function ); goto on_error; } GetSystemTime( &systemtime ); if( SystemTimeToFileTime( &systemtime, &filetime ) == 0 ) { error_code = GetLastError(); libcerror_system_set_error( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, error_code, "%s: unable to retrieve FILETIME of current time.", function ); goto on_error; } ( *file_system )->mounted_timestamp = ( (uint64_t) filetime.dwHighDateTime << 32 ) | filetime.dwLowDateTime; #elif defined( HAVE_CLOCK_GETTIME ) if( clock_gettime( CLOCK_REALTIME, &time_structure ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve current time structure.", function ); goto on_error; } timestamp = ( (int64_t) time_structure.tv_sec * 1000000000 ) + time_structure.tv_nsec; ( *file_system )->mounted_timestamp = (uint64_t) timestamp; #else timestamp = (int64_t) time( NULL ); if( timestamp == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve current time.", function ); goto on_error; } timestamp *= 1000000000; ( *file_system )->mounted_timestamp = (uint64_t) timestamp; #endif /* defined( HAVE_CLOCK_GETTIME ) */ return( 1 ); on_error: if( *file_system != NULL ) { memory_free( *file_system ); *file_system = NULL; } return( -1 ); }
/* Initialize the segment table * Returns 1 if successful or -1 on error */ int libewf_segment_table_initialize( libewf_segment_table_t **segment_table, size64_t maximum_segment_size, libcerror_error_t **error ) { static char *function = "libewf_segment_table_initialize"; if( segment_table == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid segment table.", function ); return( -1 ); } if( *segment_table != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid segment table value already set.", function ); return( -1 ); } *segment_table = memory_allocate_structure( libewf_segment_table_t ); if( *segment_table == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create segment table.", function ); goto on_error; } if( memory_set( *segment_table, 0, sizeof( libewf_segment_table_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear segment table.", function ); goto on_error; } if( libcdata_array_initialize( &( ( *segment_table )->segment_files_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create segment files array.", function ); goto on_error; } ( *segment_table )->maximum_segment_size = maximum_segment_size; return( 1 ); on_error: if( *segment_table != NULL ) { memory_free( *segment_table ); *segment_table = NULL; } return( -1 ); }
/* Creates an area * Make sure the value area is referencing, is set to NULL * * If the flag LIBFDATA_DATA_HANDLE_FLAG_MANAGED is set the area * takes over management of the data handle and the data handle is freed when * no longer needed * * Returns 1 if successful or -1 on error */ int libfdata_area_initialize( libfdata_area_t **area, size64_t element_data_size, intptr_t *data_handle, int (*free_data_handle)( intptr_t **data_handle, libcerror_error_t **error ), int (*clone_data_handle)( intptr_t **destination_data_handle, intptr_t *source_data_handle, libcerror_error_t **error ), int (*read_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_area_t *area, libfdata_cache_t *cache, off64_t element_value_offset, int element_data_file_index, off64_t element_data_offset, size64_t element_data_size, uint32_t element_data_flags, uint8_t read_flags, libcerror_error_t **error ), int (*write_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_area_t *area, libfdata_cache_t *cache, off64_t element_value_offset, int element_data_file_index, off64_t element_data_offset, size64_t element_data_size, uint32_t element_data_flags, uint8_t write_flags, libcerror_error_t **error ), uint8_t flags, libcerror_error_t **error ) { libfdata_internal_area_t *internal_area = NULL; static char *function = "libfdata_area_initialize"; if( area == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid area.", function ); return( -1 ); } if( *area != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid area value already set.", function ); return( -1 ); } if( element_data_size == 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS, "%s: invalid element data size value zero or less.", function ); return( -1 ); } internal_area = memory_allocate_structure( libfdata_internal_area_t ); if( internal_area == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create area.", function ); goto on_error; } if( memory_set( internal_area, 0, sizeof( libfdata_internal_area_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear area.", function ); memory_free( internal_area ); return( -1 ); } if( libcdata_array_initialize( &( internal_area->segments_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create segments array.", function ); goto on_error; } if( libcdata_array_initialize( &( internal_area->mapped_ranges_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create mapped ranges array.", function ); goto on_error; } if( libfcache_date_time_get_timestamp( &( internal_area->timestamp ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve cache timestamp.", function ); goto on_error; } internal_area->element_data_size = element_data_size; internal_area->flags |= flags; internal_area->data_handle = data_handle; internal_area->free_data_handle = free_data_handle; internal_area->clone_data_handle = clone_data_handle; internal_area->read_element_data = read_element_data; internal_area->write_element_data = write_element_data; *area = (libfdata_area_t *) internal_area; return( 1 ); on_error: if( internal_area != NULL ) { if( internal_area->segments_array != NULL ) { libcdata_array_free( &( internal_area->segments_array ), NULL, NULL ); } memory_free( internal_area ); } return( -1 ); }
/* Creates a mount handle * Make sure the value mount_handle is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int mount_handle_initialize( mount_handle_t **mount_handle, libcerror_error_t **error ) { static char *function = "mount_handle_initialize"; if( mount_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid mount handle.", function ); return( -1 ); } if( *mount_handle != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid mount handle value already set.", function ); return( -1 ); } *mount_handle = memory_allocate_structure( mount_handle_t ); if( *mount_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create mount handle.", function ); goto on_error; } if( memory_set( *mount_handle, 0, sizeof( mount_handle_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear mount handle.", function ); memory_free( *mount_handle ); *mount_handle = NULL; return( -1 ); } if( libbfio_file_range_initialize( &( ( *mount_handle )->input_file_io_handle ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to initialize input file IO handle.", function ); goto on_error; } /* TODO control maximum number of handles */ if( libbfio_pool_initialize( &( ( *mount_handle )->physical_volume_file_io_pool ), 0, 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to initialize physical volume file IO pool.", function ); goto on_error; } if( libvslvm_handle_initialize( &( ( *mount_handle )->input_handle ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to initialize input handle.", function ); goto on_error; } if( libcdata_array_initialize( &( ( *mount_handle )->logical_volumes_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to initialize logical volumes array.", function ); goto on_error; } return( 1 ); on_error: if( *mount_handle != NULL ) { if( ( *mount_handle )->input_handle != NULL ) { libvslvm_handle_free( &( ( *mount_handle )->input_handle ), NULL ); } if( ( *mount_handle )->physical_volume_file_io_pool != NULL ) { libbfio_pool_free( &( ( *mount_handle )->physical_volume_file_io_pool ), NULL ); } if( ( *mount_handle )->input_file_io_handle != NULL ) { libbfio_handle_free( &( ( *mount_handle )->input_file_io_handle ), NULL ); } memory_free( *mount_handle ); *mount_handle = NULL; } return( -1 ); }
/* Tests the libewf_session_section_read_data function * Returns 1 if successful or 0 if not */ int ewf_test_session_section_read_data( void ) { libcdata_array_t *sessions = NULL; libcdata_array_t *tracks = NULL; libcerror_error_t *error = NULL; libewf_media_values_t *media_values = NULL; int result = 0; /* Initialize test */ result = libewf_media_values_initialize( &media_values, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, 1 ); EWF_TEST_ASSERT_IS_NOT_NULL( "media_values", media_values ); EWF_TEST_ASSERT_IS_NULL( "error", error ); result = libcdata_array_initialize( &sessions, 0, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, 1 ); EWF_TEST_ASSERT_IS_NOT_NULL( "sessions", sessions ); EWF_TEST_ASSERT_IS_NULL( "error", error ); result = libcdata_array_initialize( &tracks, 0, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, 1 ); EWF_TEST_ASSERT_IS_NOT_NULL( "tracks", tracks ); EWF_TEST_ASSERT_IS_NULL( "error", error ); /* Test regular cases */ result = libewf_session_section_read_data( ewf_test_session_section_data1, 168, 1, media_values, sessions, tracks, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, 1 ); EWF_TEST_ASSERT_IS_NULL( "error", error ); /* Test error cases */ result = libewf_session_section_read_data( NULL, 168, 1, media_values, sessions, tracks, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, -1 ); EWF_TEST_ASSERT_IS_NOT_NULL( "error", error ); libcerror_error_free( &error ); result = libewf_session_section_read_data( ewf_test_session_section_data1, (size_t) SSIZE_MAX + 1, 1, media_values, sessions, tracks, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, -1 ); EWF_TEST_ASSERT_IS_NOT_NULL( "error", error ); libcerror_error_free( &error ); result = libewf_session_section_read_data( ewf_test_session_section_data1, 0, 1, media_values, sessions, tracks, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, -1 ); EWF_TEST_ASSERT_IS_NOT_NULL( "error", error ); libcerror_error_free( &error ); result = libewf_session_section_read_data( ewf_test_session_section_data1, 168, 0, media_values, sessions, tracks, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, -1 ); EWF_TEST_ASSERT_IS_NOT_NULL( "error", error ); libcerror_error_free( &error ); result = libewf_session_section_read_data( ewf_test_session_section_data1, 168, 1, NULL, sessions, tracks, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, -1 ); EWF_TEST_ASSERT_IS_NOT_NULL( "error", error ); libcerror_error_free( &error ); /* Clean up */ result = libewf_media_values_free( &media_values, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, 1 ); EWF_TEST_ASSERT_IS_NULL( "media_values", media_values ); EWF_TEST_ASSERT_IS_NULL( "error", error ); result = libcdata_array_free( &sessions, (int (*)(intptr_t **, libcerror_error_t **)) &libewf_sector_range_free, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, 1 ); EWF_TEST_ASSERT_IS_NULL( "sessions", sessions ); EWF_TEST_ASSERT_IS_NULL( "error", error ); result = libcdata_array_free( &tracks, (int (*)(intptr_t **, libcerror_error_t **)) &libewf_sector_range_free, &error ); EWF_TEST_ASSERT_EQUAL_INT( "result", result, 1 ); EWF_TEST_ASSERT_IS_NULL( "tracks", tracks ); EWF_TEST_ASSERT_IS_NULL( "error", error ); return( 1 ); on_error: if( error != NULL ) { libcerror_error_free( &error ); } if( tracks != NULL ) { libcdata_array_free( &tracks, (int (*)(intptr_t **, libcerror_error_t **)) &libewf_sector_range_free, NULL ); } if( sessions != NULL ) { libcdata_array_free( &sessions, (int (*)(intptr_t **, libcerror_error_t **)) &libewf_sector_range_free, NULL ); } if( media_values != NULL ) { libewf_media_values_free( &media_values, NULL ); } return( 0 ); }
/* Creates a handle * Make sure the value handle is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libvsmbr_handle_initialize( libvsmbr_handle_t **handle, libcerror_error_t **error ) { libvsmbr_internal_handle_t *internal_handle = NULL; static char *function = "libvsmbr_handle_initialize"; if( handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid handle.", function ); return( -1 ); } if( *handle != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid handle value already set.", function ); return( -1 ); } internal_handle = memory_allocate_structure( libvsmbr_internal_handle_t ); if( internal_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create handle.", function ); goto on_error; } if( memory_set( internal_handle, 0, sizeof( libvsmbr_internal_handle_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear handle.", function ); memory_free( internal_handle ); return( -1 ); } if( libvsmbr_io_handle_initialize( &( internal_handle->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; } if( libcdata_array_initialize( &( internal_handle->partitions_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create partitions array.", function ); goto on_error; } if( libcdata_array_initialize( &( internal_handle->sections_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create sections array.", function ); goto on_error; } *handle = (libvsmbr_handle_t *) internal_handle; return( 1 ); on_error: if( internal_handle != NULL ) { if( internal_handle->partitions_array != NULL ) { libcdata_array_free( &( internal_handle->partitions_array ), (int (*)(intptr_t **, libcerror_error_t **)) &libvsmbr_partition_values_free, NULL ); } memory_free( internal_handle ); } return( -1 ); }
/* Reads the manifest * Returns 1 if successful or -1 on error */ int libfwevt_manifest_read( libfwevt_manifest_t *manifest, const uint8_t *data, size_t data_size, libcerror_error_t **error ) { libfwevt_internal_manifest_t *internal_manifest = NULL; libfwevt_provider_t *provider = NULL; fwevt_template_manifest_t *wevt_manifest = NULL; fwevt_template_provider_entry_t *provider_entry = NULL; static char *function = "libfwevt_manifest_read"; size_t data_offset = 0; uint32_t number_of_providers = 0; uint32_t provider_data_offset = 0; uint32_t provider_index = 0; #if defined( HAVE_DEBUG_OUTPUT ) system_character_t guid_string[ 48 ]; libfguid_identifier_t *guid = NULL; uint32_t value_32bit = 0; int result = 0; #endif if( manifest == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid manifest.", function ); return( -1 ); } internal_manifest = (libfwevt_internal_manifest_t *) manifest; if( data == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid data.", function ); return( -1 ); } if( data_size > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid data size value exceeds maximum.", function ); return( -1 ); } if( data_size < sizeof( fwevt_template_manifest_t ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL, "%s: invalid data value too small.", function ); return( -1 ); } wevt_manifest = (fwevt_template_manifest_t *) data; #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: manifest data:\n", function ); libcnotify_print_data( (uint8_t *) wevt_manifest, sizeof( fwevt_template_manifest_t ), 0 ); } #endif byte_stream_copy_to_uint16_little_endian( wevt_manifest->major_version, internal_manifest->major_version ); byte_stream_copy_to_uint16_little_endian( wevt_manifest->minor_version, internal_manifest->minor_version ); byte_stream_copy_to_uint32_little_endian( wevt_manifest->number_of_providers, number_of_providers ); #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: signature\t\t\t\t\t: %c%c%c%c\n", function, wevt_manifest->signature[ 0 ], wevt_manifest->signature[ 1 ], wevt_manifest->signature[ 2 ], wevt_manifest->signature[ 3 ] ); byte_stream_copy_to_uint32_little_endian( wevt_manifest->size, value_32bit ); libcnotify_printf( "%s: size\t\t\t\t\t\t: %" PRIu32 "\n", function, value_32bit ); libcnotify_printf( "%s: major version\t\t\t\t\t: %" PRIu16 "\n", function, internal_manifest->major_version ); libcnotify_printf( "%s: minor version\t\t\t\t\t: %" PRIu16 "\n", function, internal_manifest->minor_version ); libcnotify_printf( "%s: number of providers\t\t\t\t: %" PRIu32 "\n", function, number_of_providers ); libcnotify_printf( "\n" ); } #endif if( memory_compare( wevt_manifest->signature, "CRIM", 4 ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE, "%s: unsupported manifest signature.", function ); goto on_error; } data_offset = sizeof( fwevt_template_manifest_t ); if( libcdata_array_initialize( &( internal_manifest->providers_array ), number_of_providers, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create providers array.", function ); goto on_error; } for( provider_index = 0; provider_index < number_of_providers; provider_index++ ) { if( data_offset >= data_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid data offset value out of bounds.", function ); goto on_error; } provider_entry = (fwevt_template_provider_entry_t *) &( data[ data_offset ] ); if( ( data_offset + sizeof( fwevt_template_provider_entry_t ) ) >= data_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid data value too small.", function ); goto on_error; } byte_stream_copy_to_uint32_little_endian( provider_entry->data_offset, provider_data_offset ); #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { if( libfguid_identifier_initialize( &guid, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create GUID.", function ); goto on_error; } if( libfguid_identifier_copy_from_byte_stream( guid, provider_entry->identifier, 16, LIBFGUID_ENDIAN_LITTLE, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_COPY_FAILED, "%s: unable to copy byte stream to GUID.", function ); goto on_error; } #if defined( HAVE_WIDE_SYSTEM_CHARACTER ) result = libfguid_identifier_copy_to_utf16_string( guid, (uint16_t *) guid_string, 48, LIBFGUID_STRING_FORMAT_FLAG_USE_LOWER_CASE, error ); #else result = libfguid_identifier_copy_to_utf8_string( guid, (uint8_t *) guid_string, 48, LIBFGUID_STRING_FORMAT_FLAG_USE_LOWER_CASE, error ); #endif if( result != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_COPY_FAILED, "%s: unable to copy GUID to string.", function ); goto on_error; } libcnotify_printf( "%s: provider entry: %02" PRIu32 " identifier\t\t\t: %" PRIs_SYSTEM "\n", function, provider_index, guid_string ); if( libfguid_identifier_free( &guid, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free GUID.", function ); goto on_error; } libcnotify_printf( "%s: provider entry: %02" PRIu32 " data offset\t\t\t: 0x%08" PRIx32 "\n", function, provider_index, provider_data_offset ); } #endif data_offset += sizeof( fwevt_template_provider_entry_t ); if( libfwevt_provider_initialize( &provider, provider_entry->identifier, 16, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create provider: %" PRIu32 ".", function, provider_index ); goto on_error; } if( libfwevt_provider_read( provider, data, data_size, (size_t) provider_data_offset, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read provider: %d.", function, provider_index ); goto on_error; } if( libcdata_array_set_entry_by_index( internal_manifest->providers_array, (int) provider_index, (intptr_t *) provider, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set provider: %" PRIu32 ".", function, provider_index ); goto on_error; } provider = NULL; } /* TODO refactor to read on demand ? */ for( provider_index = 0; provider_index < number_of_providers; provider_index++ ) { if( libcdata_array_get_entry_by_index( internal_manifest->providers_array, provider_index, (intptr_t **) &provider, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve provider: %d.", function, provider_index ); provider = NULL; goto on_error; } if( libfwevt_provider_read_channels( provider, data, data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read channels.", function ); provider = NULL; goto on_error; } if( libfwevt_provider_read_events( provider, data, data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read events.", function ); provider = NULL; goto on_error; } if( libfwevt_provider_read_keywords( provider, data, data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read keywords.", function ); provider = NULL; goto on_error; } if( libfwevt_provider_read_levels( provider, data, data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read levels.", function ); provider = NULL; goto on_error; } if( libfwevt_provider_read_maps( provider, data, data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read maps.", function ); provider = NULL; goto on_error; } if( libfwevt_provider_read_opcodes( provider, data, data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read opcodes.", function ); provider = NULL; goto on_error; } if( libfwevt_provider_read_tasks( provider, data, data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read tasks.", function ); provider = NULL; goto on_error; } if( libfwevt_provider_read_templates( provider, data, data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read templates.", function ); provider = NULL; goto on_error; } } /* TODO end refactor */ #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { if( number_of_providers > 0 ) { libcnotify_printf( "\n" ); } } #endif return( 1 ); on_error: #if defined( HAVE_DEBUG_OUTPUT ) if( guid != NULL ) { libfguid_identifier_free( &guid, NULL ); } #endif if( provider != NULL ) { libfwevt_provider_free( &provider, NULL ); } if( internal_manifest->providers_array != NULL ) { libcdata_array_free( &( internal_manifest->providers_array ), (int (*)(intptr_t **, libcerror_error_t **)) &libfwevt_provider_free, NULL ); } return( -1 ); }
/* Creates logical volume values * Make sure the value logical_volume_values is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libvslvm_logical_volume_values_initialize( libvslvm_logical_volume_values_t **logical_volume_values, libcerror_error_t **error ) { static char *function = "libvslvm_logical_volume_values_initialize"; if( logical_volume_values == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid logical volume values.", function ); return( -1 ); } if( *logical_volume_values != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid logical volume values value already set.", function ); return( -1 ); } *logical_volume_values = memory_allocate_structure( libvslvm_logical_volume_values_t ); if( *logical_volume_values == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create logical volume values.", function ); goto on_error; } if( memory_set( *logical_volume_values, 0, sizeof( libvslvm_logical_volume_values_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear logical volume values.", function ); memory_free( *logical_volume_values ); *logical_volume_values = NULL; return( -1 ); } if( libcdata_array_initialize( &( ( *logical_volume_values )->segments_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create segments array.", function ); goto on_error; } return( 1 ); on_error: if( *logical_volume_values != NULL ) { memory_free( *logical_volume_values ); *logical_volume_values = NULL; } return( -1 ); }
/* Reads a hive bin and determines its cells * Returns 1 if successful or -1 on error */ int libregf_hive_bin_read_cells( libregf_hive_bin_t *hive_bin, libbfio_handle_t *file_io_handle, libcerror_error_t **error ) { libregf_hive_bin_cell_t *hive_bin_cell = NULL; uint8_t *hive_bin_cells_data = NULL; static char *function = "libregf_hive_bin_read_cells"; ssize_t read_count = 0; size_t hive_bin_cells_data_size = 0; uint32_t hive_bin_cell_size = 0; uint32_t hive_bin_cells_offset = 0; int hive_bin_cell_index = 0; if( hive_bin == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid hive bin.", function ); return( -1 ); } if( hive_bin->data != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid hive bin - data already set.", function ); return( -1 ); } #if SIZEOF_SIZE_T <= 4 if( hive_bin->size > (size_t) SSIZE_MAX ) #else if( hive_bin->size > (uint32_t) SSIZE_MAX ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid hive bin - size value exceeds maximum.", function ); return( -1 ); } if( hive_bin->cells_array != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid hive bin - cells array already set.", function ); return( -1 ); } hive_bin->data_size = (size_t) hive_bin->size - sizeof( regf_hive_bin_header_t ); hive_bin->data = (uint8_t *) memory_allocate( sizeof( uint8_t ) * hive_bin->data_size ); if( hive_bin->data == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create hive cells data.", function ); goto on_error; } read_count = libbfio_handle_read_buffer( file_io_handle, hive_bin->data, hive_bin->data_size, error ); if( read_count != (ssize_t) hive_bin->data_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read hive bin cells data.", function ); goto on_error; } if( libcdata_array_initialize( &( hive_bin->cells_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create hive bin cells array.", function ); goto on_error; } hive_bin_cells_data = hive_bin->data; hive_bin_cells_data_size = hive_bin->data_size; hive_bin_cells_offset = hive_bin->offset + sizeof( regf_hive_bin_header_t ); #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: hive bin cells:\n", function ); libcnotify_print_data( hive_bin_cells_data, hive_bin_cells_data_size, 0 ); } #endif while( hive_bin_cells_data_size > 0 ) { if( libregf_hive_bin_cell_initialize( &hive_bin_cell, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create hive bin cell.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: hive bin cell: %03d offset\t\t\t: 0x%08" PRIx32 "\n", function, hive_bin_cell_index, hive_bin_cells_offset ); } #endif hive_bin_cell->offset = (uint32_t) hive_bin_cells_offset; byte_stream_copy_to_uint32_little_endian( hive_bin_cells_data, hive_bin_cell_size ); hive_bin_cells_data += 4; hive_bin_cells_offset += 4; hive_bin_cells_data_size -= 4; #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: hive bin cell: %03d size\t\t\t: 0x%08" PRIx32 " (%" PRIi32 ")\n", function, hive_bin_cell_index, hive_bin_cell_size, (int32_t) hive_bin_cell_size ); } #endif if( (int32_t) hive_bin_cell_size < 0 ) { hive_bin_cell_size = (uint32_t) ( -1 * (int32_t) hive_bin_cell_size ); } else { hive_bin_cell->flags |= LIBREGF_HIVE_BIN_CELL_FLAG_UNALLOCATED; } if( ( hive_bin_cell_size % 8 ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE, "%s: invalid cell size value should be multitude of 8.", function ); goto on_error; } /* Remove the size of the cell size value */ hive_bin_cell_size -= 4; if( hive_bin_cell_size > hive_bin_cells_data_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid cell size value exceeds hive bin size.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: hive bin cell: %03d data:\n", function, hive_bin_cell_index ); libcnotify_print_data( hive_bin_cells_data, hive_bin_cell_size, 0 ); } #endif hive_bin_cell->data = hive_bin_cells_data; hive_bin_cell->size = hive_bin_cell_size; if( libcdata_array_append_entry( hive_bin->cells_array, &hive_bin_cell_index, (intptr_t *) hive_bin_cell, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_APPEND_FAILED, "%s: unable to append hive bin cell: %d.", function, hive_bin_cell_index ); goto on_error; } hive_bin_cell = NULL; hive_bin_cells_data += hive_bin_cell_size; hive_bin_cells_offset += hive_bin_cell_size; hive_bin_cells_data_size -= hive_bin_cell_size; hive_bin_cell_index++; } return( 1 ); on_error: if( hive_bin_cell != NULL ) { libregf_hive_bin_cell_free( &hive_bin_cell, NULL ); } if( hive_bin->data != NULL ) { memory_free( hive_bin->data ); hive_bin->data = NULL; } hive_bin->data_size = 0; return( -1 ); }
/* Creates a volume * ake sure the value volume is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libvshadow_volume_initialize( libvshadow_volume_t **volume, libcerror_error_t **error ) { libvshadow_internal_volume_t *internal_volume = NULL; static char *function = "libvshadow_volume_initialize"; if( volume == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid volume.", function ); return( -1 ); } if( *volume != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid volume value already set.", function ); return( -1 ); } internal_volume = memory_allocate_structure( libvshadow_internal_volume_t ); if( internal_volume == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create volume.", function ); goto on_error; } if( memory_set( internal_volume, 0, sizeof( libvshadow_internal_volume_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear volume.", function ); memory_free( internal_volume ); return( -1 ); } if( libcdata_array_initialize( &( internal_volume->store_descriptors_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create store descriptors array.", function ); goto on_error; } if( libvshadow_io_handle_initialize( &( internal_volume->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; } #if defined( HAVE_LIBVSHADOW_MULTI_THREAD_SUPPORT ) if( libcthreads_read_write_lock_initialize( &( internal_volume->read_write_lock ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to intialize read/write lock.", function ); goto on_error; } #endif *volume = (libvshadow_volume_t *) internal_volume; return( 1 ); on_error: if( internal_volume != NULL ) { if( internal_volume->store_descriptors_array != NULL ) { libcdata_array_free( &( internal_volume->store_descriptors_array ), (int (*)(intptr_t **, libcerror_error_t **)) &libvshadow_store_descriptor_free, NULL ); } memory_free( internal_volume ); } return( -1 ); }
/* Creates a cache * Make sure the value cache is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libfcache_cache_initialize( libfcache_cache_t **cache, int maximum_cache_entries, libcerror_error_t **error ) { libfcache_internal_cache_t *internal_cache = NULL; static char *function = "libfcache_cache_initialize"; if( cache == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid cache.", function ); return( -1 ); } if( *cache != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid cache value already set.", function ); return( -1 ); } if( maximum_cache_entries <= 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS, "%s: invalid maximum cache entries value zero or less.", function ); return( -1 ); } internal_cache = memory_allocate_structure( libfcache_internal_cache_t ); if( internal_cache == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create cache.", function ); goto on_error; } if( memory_set( internal_cache, 0, sizeof( libfcache_internal_cache_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear cache.", function ); goto on_error; } if( libcdata_array_initialize( &( internal_cache->entries ), maximum_cache_entries, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create entries array.", function ); goto on_error; } *cache = (libfcache_cache_t *) internal_cache; return( 1 ); on_error: if( internal_cache != NULL ) { memory_free( internal_cache ); } return( -1 ); }
/* Creates a property set * Make sure the value property_set is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libolecf_property_set_initialize( libolecf_property_set_t **property_set, libcerror_error_t **error ) { libolecf_internal_property_set_t *internal_property_set = NULL; static char *function = "libolecf_property_set_initialize"; if( property_set == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid property set.", function ); return( -1 ); } if( *property_set != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid property set value already set.", function ); return( -1 ); } internal_property_set = memory_allocate_structure( libolecf_internal_property_set_t ); if( internal_property_set == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create property set.", function ); goto on_error; } if( memory_set( internal_property_set, 0, sizeof( libolecf_internal_property_set_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear property set.", function ); goto on_error; } if( libcdata_array_initialize( &( internal_property_set->sections ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create sections array.", function ); goto on_error; } *property_set = (libolecf_property_set_t *) internal_property_set; return( 1 ); on_error: if( internal_property_set != NULL ) { memory_free( internal_property_set ); } return( -1 ); }
/* Creates a metadata area * Make sure the value metadata_area is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libvslvm_metadata_area_initialize( libvslvm_metadata_area_t **metadata_area, libcerror_error_t **error ) { static char *function = "libvslvm_metadata_area_initialize"; if( metadata_area == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid metadata area.", function ); return( -1 ); } if( *metadata_area != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid metadata area value already set.", function ); return( -1 ); } *metadata_area = memory_allocate_structure( libvslvm_metadata_area_t ); if( *metadata_area == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create metadata area.", function ); goto on_error; } if( memory_set( *metadata_area, 0, sizeof( libvslvm_metadata_area_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear metadata area.", function ); memory_free( *metadata_area ); *metadata_area = NULL; return( -1 ); } if( libcdata_array_initialize( &( ( *metadata_area )->raw_location_descriptors_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create raw location descriptors array.", function ); goto on_error; } return( 1 ); on_error: if( *metadata_area != NULL ) { memory_free( *metadata_area ); *metadata_area = NULL; } return( -1 ); }
/* Opens a file for reading * Returns 1 if successful or -1 on error */ int libmsiecf_file_open_read( libmsiecf_internal_file_t *internal_file, libbfio_handle_t *file_io_handle, libcerror_error_t **error ) { static char *function = "libmsiecf_file_open_read"; uint32_t hash_table_offset = 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->directory_array != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid file - directory array already set.", function ); return( -1 ); } if( internal_file->item_array != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid file - item array already set.", function ); return( -1 ); } if( internal_file->recovered_item_array != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid file - recovered item array already set.", function ); return( -1 ); } if( internal_file->unallocated_block_list != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid file - unallocated block list already set.", function ); return( -1 ); } if( libcdata_array_initialize( &( internal_file->directory_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create directory array.", function ); goto on_error; } if( libcdata_array_initialize( &( internal_file->item_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create item array.", function ); goto on_error; } if( libcdata_array_initialize( &( internal_file->recovered_item_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create recovered item array.", function ); goto on_error; } if( libcdata_range_list_initialize( &( internal_file->unallocated_block_list ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create unallocated data block list.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "Reading file header:\n" ); } #endif if( libmsiecf_io_handle_read_file_header( internal_file->io_handle, file_io_handle, &hash_table_offset, internal_file->directory_array, internal_file->unallocated_block_list, 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 defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "Reading hash table:\n" ); } #endif if( libmsiecf_io_handle_read_hash_table( internal_file->item_array, internal_file->io_handle, file_io_handle, hash_table_offset, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read hash table.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "Scanning for records:\n" ); } #endif if( libmsiecf_io_handle_read_record_scan( internal_file->item_array, internal_file->recovered_item_array, internal_file->io_handle, file_io_handle, hash_table_offset, internal_file->unallocated_block_list, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to perform record scan.", function ); goto on_error; } return( 1 ); on_error: if( internal_file->unallocated_block_list != NULL ) { libcdata_range_list_free( &( internal_file->unallocated_block_list ), NULL, NULL ); } if( internal_file->recovered_item_array != NULL ) { libcdata_array_free( &( internal_file->recovered_item_array ), (int (*)(intptr_t **, libcerror_error_t **)) &libmsiecf_item_descriptor_free, NULL ); } if( internal_file->item_array != NULL ) { libcdata_array_free( &( internal_file->item_array ), (int (*)(intptr_t **, libcerror_error_t **)) &libmsiecf_item_descriptor_free, NULL ); } if( internal_file->directory_array != NULL ) { libcdata_array_free( &( internal_file->directory_array ), (int (*)(intptr_t **, libcerror_error_t **)) &libmsiecf_directory_descriptor_free, NULL ); } return( -1 ); }
/* Appends a value entry * Returns if successful or -1 on error */ int libfvalue_data_handle_append_value_entry( libfvalue_data_handle_t *data_handle, int *value_entry_index, const uint8_t *value_entry_data, size_t value_entry_data_size, int encoding, libcerror_error_t **error ) { libfvalue_internal_data_handle_t *internal_data_handle = NULL; libfvalue_value_entry_t *value_entry = NULL; void *reallocation = NULL; static char *function = "libfvalue_data_handle_append_value_entry"; if( data_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid data handle.", function ); return( -1 ); } internal_data_handle = (libfvalue_internal_data_handle_t *) data_handle; if( value_entry_index == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid value entry index.", function ); return( -1 ); } if( value_entry_data == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid value entry data.", function ); return( -1 ); } if( value_entry_data_size > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid value entry data size value exceeds maximum.", function ); return( -1 ); } if( internal_data_handle->data == NULL ) { if( libfvalue_data_handle_set_data( data_handle, value_entry_data, value_entry_data_size, encoding, LIBFVALUE_VALUE_DATA_FLAG_MANAGED, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set data in data handle.", function ); goto on_error; } internal_data_handle->encoding = encoding; } else { if( encoding != internal_data_handle->encoding ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid encoding value out of bounds.", function ); return( -1 ); } if( ( internal_data_handle->data_size + value_entry_data_size ) > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid value entry data size value exceeds maximum.", function ); return( -1 ); } if( internal_data_handle->value_entries == NULL ) { if( libcdata_array_initialize( &( internal_data_handle->value_entries ), 1, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create value entries array.", function ); goto on_error; } if( libfvalue_value_entry_initialize( &value_entry, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create value entry.", function ); goto on_error; } value_entry->offset = 0; value_entry->size = internal_data_handle->data_size; if( libcdata_array_set_entry_by_index( internal_data_handle->value_entries, 0, (intptr_t *) value_entry, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set entry: 0 in values entries array.", function ); goto on_error; } value_entry = NULL; } if( libfvalue_value_entry_initialize( &value_entry, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create value entry.", function ); goto on_error; } value_entry->offset = internal_data_handle->data_size; value_entry->size = value_entry_data_size; reallocation = memory_reallocate( internal_data_handle->data, internal_data_handle->data_size + value_entry_data_size ); if( reallocation == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to resize array entries.", function ); goto on_error; } internal_data_handle->data = (uint8_t *) reallocation; internal_data_handle->data_size += value_entry_data_size; if( memory_copy( &( ( internal_data_handle->data )[ value_entry->offset ] ), value_entry_data, value_entry->size ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_COPY_FAILED, "%s: unable to copy value entry data.", function ); goto on_error; } if( libcdata_array_append_entry( internal_data_handle->value_entries, value_entry_index, (intptr_t *) value_entry, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_APPEND_FAILED, "%s: unable to append entry to values entries array.", function ); goto on_error; } value_entry = NULL; } return( 1 ); on_error: if( value_entry != NULL ) { libfvalue_value_entry_free( &value_entry, NULL ); } return( -1 ); }
/* Clones the array and its entries * * The entries are cloned using the entry_clone_function * On error the entries are freed using the entry_free_function * * Returns 1 if successful or -1 on error */ int libcdata_array_clone( libcdata_array_t **destination_array, libcdata_array_t *source_array, int (*entry_free_function)( intptr_t **entry, libcerror_error_t **error ), int (*entry_clone_function)( intptr_t **destination_entry, intptr_t *source_entry, libcerror_error_t **error ), libcerror_error_t **error ) { libcdata_internal_array_t *internal_destination_array = NULL; libcdata_internal_array_t *internal_source_array = NULL; static char *function = "libcdata_array_clone"; int entry_iterator = 0; int result = 1; if( destination_array == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid destination array.", function ); return( -1 ); } if( *destination_array != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid destination array already set.", function ); return( -1 ); } if( entry_free_function == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid entry free function.", function ); return( -1 ); } if( entry_clone_function == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid entry clone function.", function ); return( -1 ); } if( source_array == NULL ) { *destination_array = NULL; return( 1 ); } internal_source_array = (libcdata_internal_array_t *) source_array; if( libcdata_array_initialize( destination_array, internal_source_array->number_of_entries, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create destination array.", function ); goto on_error; } if( *destination_array == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: missing destination array.", function ); goto on_error; } internal_destination_array = (libcdata_internal_array_t *) *destination_array; #if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA ) if( libcthreads_read_write_lock_grab_for_read( internal_source_array->read_write_lock, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to grab read/write lock for reading.", function ); goto on_error; } #endif if( internal_source_array->entries != NULL ) { for( entry_iterator = 0; entry_iterator < internal_source_array->number_of_entries; entry_iterator++ ) { if( internal_source_array->entries[ entry_iterator ] != NULL ) { result = entry_clone_function( &( internal_destination_array->entries[ entry_iterator ] ), internal_source_array->entries[ entry_iterator ], error ); if( result != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create destination array entry: %d.", function, entry_iterator ); break; } } } } #if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA ) if( libcthreads_read_write_lock_release_for_read( internal_source_array->read_write_lock, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to release read/write lock for reading.", function ); goto on_error; } #endif if( result != 1 ) { goto on_error; } return( 1 ); on_error: if( *destination_array != NULL ) { libcdata_array_free( destination_array, entry_free_function, NULL ); } return( -1 ); }
/* Creates a physical volume * Make sure the value physical_volume is referencing, is set to NULL * Returns 1 if successful or -1 on error */ int libvslvm_physical_volume_initialize( libvslvm_physical_volume_t **physical_volume, libcerror_error_t **error ) { libvslvm_internal_physical_volume_t *internal_physical_volume = NULL; static char *function = "libvslvm_physical_volume_initialize"; if( physical_volume == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid physical volume.", function ); return( -1 ); } if( *physical_volume != NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET, "%s: invalid physical volume value already set.", function ); return( -1 ); } internal_physical_volume = memory_allocate_structure( libvslvm_internal_physical_volume_t ); if( internal_physical_volume == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create physical volume.", function ); goto on_error; } if( memory_set( internal_physical_volume, 0, sizeof( libvslvm_internal_physical_volume_t ) ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear physical volume.", function ); memory_free( internal_physical_volume ); return( -1 ); } if( libcdata_array_initialize( &( internal_physical_volume->data_area_descriptors_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create data area descripors array.", function ); goto on_error; } if( libcdata_array_initialize( &( internal_physical_volume->metadata_area_descriptors_array ), 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create metadata area descripors array.", function ); goto on_error; } *physical_volume= (libvslvm_physical_volume_t *) internal_physical_volume; return( 1 ); on_error: if( internal_physical_volume != NULL ) { if( internal_physical_volume->data_area_descriptors_array != NULL ) { libcdata_array_free( &( internal_physical_volume->data_area_descriptors_array ), NULL, NULL ); } memory_free( internal_physical_volume ); } return( -1 ); }