/* Reads a grain * Callback function for the grains list * Returns 1 if successful or -1 on error */ int libvmdk_grain_data_read_element_data( libvmdk_io_handle_t *io_handle, libbfio_pool_t *file_io_pool, libfdata_list_element_t *element, libfcache_cache_t *cache, int file_io_pool_entry, off64_t grain_data_offset, size64_t grain_data_size, uint32_t grain_data_flags, uint8_t read_flags LIBVMDK_ATTRIBUTE_UNUSED, libcerror_error_t **error ) { libvmdk_grain_data_t *grain_data = NULL; uint8_t *compressed_data = NULL; static char *function = "libvmdk_grain_data_read_element_data"; ssize_t read_count = 0; LIBVMDK_UNREFERENCED_PARAMETER( read_flags ) if( io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid IO handle.", function ); return( -1 ); } if( ( grain_data_size == (size64_t) 0 ) || ( grain_data_size > (size64_t) SSIZE_MAX ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid grain data size value out of bounds.", function ); return( -1 ); } if( ( grain_data_flags & LIBVMDK_RANGE_FLAG_IS_SPARSE ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE, "%s: sparse grain not supported.", function ); return( -1 ); } if( libbfio_pool_seek_offset( file_io_pool, file_io_pool_entry, grain_data_offset, SEEK_SET, error ) == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_SEEK_FAILED, "%s: unable to seek grain offset: %" PRIi64 " in file IO pool entry: %d.", function, grain_data_offset, file_io_pool_entry ); goto on_error; } if( ( grain_data_flags & LIBVMDK_RANGE_FLAG_IS_COMPRESSED ) != 0 ) { if( io_handle->grain_size > (size64_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid IO handle - grain size value exceeds maximum.", function ); goto on_error; } if( libvmdk_grain_data_initialize( &grain_data, (size_t) io_handle->grain_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create grain data.", function ); goto on_error; } read_count = libvmdk_grain_data_read_compressed_header( grain_data, io_handle, file_io_pool, file_io_pool_entry, error ); if( read_count == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read compressed grain data header.", function ); goto on_error; } #if SIZEOF_UINT32 <= SIZEOF_SIZE_T if( grain_data->compressed_data_size > (uint32_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid grain data - compressed data size value exceeds maximum.", function ); goto on_error; } #endif if( grain_data->compressed_data_size == 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid grain data - compressed data size value out of bounds.", function ); goto on_error; } compressed_data = (uint8_t *) memory_allocate( sizeof( uint8_t ) * (size_t) grain_data->compressed_data_size ); if( compressed_data == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create compressed data.", function ); goto on_error; } read_count = libbfio_pool_read_buffer( file_io_pool, file_io_pool_entry, compressed_data, (size_t) grain_data->compressed_data_size, error ); if( read_count != (ssize_t) grain_data->compressed_data_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read compressed grain data.", function ); goto on_error; } if( libvmdk_decompress_data( compressed_data, (size_t) grain_data->compressed_data_size, LIBVMDK_COMPRESSION_METHOD_DEFLATE, grain_data->data, &( grain_data->data_size ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_COMPRESSION, LIBCERROR_COMPRESSION_ERROR_DECOMPRESS_FAILED, "%s: unable to decompress grain data.", function ); goto on_error; } memory_free( compressed_data ); compressed_data = NULL; } else { if( libvmdk_grain_data_initialize( &grain_data, (size_t) grain_data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create grain data.", function ); goto on_error; } if( grain_data == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: missing grain data.", function ); goto on_error; } read_count = libbfio_pool_read_buffer( file_io_pool, file_io_pool_entry, grain_data->data, (size_t) grain_data_size, error ); if( read_count != (ssize_t) grain_data_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read grain data.", function ); goto on_error; } } if( libfdata_list_element_set_element_value( element, (intptr_t *) file_io_pool, cache, (intptr_t *) grain_data, (int (*)(intptr_t **, libcerror_error_t **)) &libvmdk_grain_data_free, LIBFDATA_LIST_ELEMENT_VALUE_FLAG_MANAGED, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set grain data as element value.", function ); goto on_error; } return( 1 ); on_error: if( compressed_data != NULL ) { memory_free( compressed_data ); } if( grain_data != NULL ) { libvmdk_grain_data_free( &grain_data, NULL ); } return( -1 ); }
/* Reads a chunk * Callback function for the chunk table list * Returns 1 if successful or -1 on error */ int libewf_chunk_table_read_chunk( intptr_t *io_handle, libbfio_pool_t *file_io_pool, libmfdata_list_element_t *list_element, libfcache_cache_t *cache, int file_io_pool_entry, off64_t element_data_offset, size64_t element_data_size, uint32_t element_data_flags, uint8_t read_flags LIBEWF_ATTRIBUTE_UNUSED, libcerror_error_t **error ) { libewf_chunk_data_t *chunk_data = NULL; static char *function = "libewf_chunk_table_read_chunk"; ssize_t read_count = 0; #if defined( HAVE_DEBUG_OUTPUT ) int element_index = 0; #endif LIBEWF_UNREFERENCED_PARAMETER( read_flags ) if( io_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid IO handle.", function ); return( -1 ); } if( element_data_size > (size64_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid element data size value exceeds maximum.", function ); return( -1 ); } if( ( element_data_flags & LIBMFDATA_RANGE_FLAG_IS_SPARSE ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE, "%s: unsupported element data flags.", function ); return( -1 ); } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { if( libmfdata_list_element_get_element_index( list_element, &element_index, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve element index from list element.", function ); goto on_error; } if( ( element_data_flags & LIBMFDATA_RANGE_FLAG_IS_COMPRESSED ) != 0 ) { libcnotify_printf( "%s: reading compressed chunk: %d from file IO pool entry: %d at offset: %" PRIi64 " of size: %" PRIu64 "\n", function, element_index, file_io_pool_entry, element_data_offset, element_data_size ); } else { libcnotify_printf( "%s: reading uncompressed chunk: %d from file IO pool entry: %d at offset: %" PRIi64 " of size: %" PRIu64 "\n", function, element_index, file_io_pool_entry, element_data_offset, element_data_size ); } } #endif if( libbfio_pool_seek_offset( file_io_pool, file_io_pool_entry, element_data_offset, SEEK_SET, error ) == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_SEEK_FAILED, "%s: unable to seek chunk offset: %" PRIi64 " in file IO pool entry: %d.", function, element_data_offset, file_io_pool_entry ); goto on_error; } if( libewf_chunk_data_initialize( &chunk_data, (size_t) element_data_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create chunk data.", function ); goto on_error; } if( chunk_data == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: missing chunk data.", function ); goto on_error; } read_count = libbfio_pool_read_buffer( file_io_pool, file_io_pool_entry, chunk_data->data, (size_t) element_data_size, error ); if( read_count != (ssize_t) element_data_size ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read chunk data.", function ); goto on_error; } chunk_data->data_size = (size_t) read_count; if( ( element_data_flags & LIBMFDATA_RANGE_FLAG_IS_COMPRESSED ) != 0 ) { chunk_data->is_compressed = 1; } chunk_data->is_packed = 1; if( libmfdata_list_element_set_element_value( list_element, cache, (intptr_t *) chunk_data, (int (*)(intptr_t **, libcerror_error_t **)) &libewf_chunk_data_free, LIBMFDATA_LIST_ELEMENT_VALUE_FLAG_MANAGED, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set chunk data as element value.", function ); goto on_error; } return( 1 ); on_error: if( chunk_data != NULL ) { libewf_chunk_data_free( &chunk_data, NULL ); } return( -1 ); }
/* Reads a compressed grain data header * The number of bytes read or -1 on error */ ssize_t libvmdk_grain_data_read_compressed_header( libvmdk_grain_data_t *grain_data, libvmdk_io_handle_t *io_handle, libbfio_pool_t *file_io_pool, int file_io_pool_entry, libcerror_error_t **error ) { uint8_t compressed_data_header[ 12 ]; static char *function = "libvmdk_grain_data_read_compressed_header"; ssize_t read_count = 0; if( grain_data == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid grain data.", 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 ); } read_count = libbfio_pool_read_buffer( file_io_pool, file_io_pool_entry, compressed_data_header, 12, error ); if( read_count != (ssize_t) 12 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read compressed grain data header.", function ); return( -1 ); } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: compressed grain data header:\n", function ); libcnotify_print_data( compressed_data_header, 12, 0 ); } #endif byte_stream_copy_to_uint64_little_endian( compressed_data_header, grain_data->uncompressed_data_offset ); byte_stream_copy_to_uint32_little_endian( &( compressed_data_header[ 8 ] ), grain_data->compressed_data_size ); #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: uncompressed data offset\t: %" PRIu64 " grains (0x%08" PRIx64 ")\n", function, grain_data->uncompressed_data_offset, grain_data->uncompressed_data_offset * io_handle->grain_size ); libcnotify_printf( "%s: compressed data size\t\t: %" PRIu32 "\n", function, grain_data->compressed_data_size ); libcnotify_printf( "\n" ); } #endif grain_data->uncompressed_data_offset *= io_handle->grain_size; return( read_count ); }
/* Reads a physical volume label * Returns 1 if successful, 0 if not found or -1 on error */ int libvslvm_physical_volume_read_label( libvslvm_physical_volume_t *physical_volume, libbfio_pool_t *file_io_pool, int file_io_pool_entry, off64_t file_offset, libcerror_error_t **error ) { vslvm_data_area_descriptor_t data_area_descriptor_data; vslvm_physical_volume_label_header_t physical_volume_label_header; vslvm_physical_volume_header_t physical_volume_header; libvslvm_data_area_descriptor_t *data_area_descriptor = NULL; libvslvm_internal_physical_volume_t *internal_physical_volume = NULL; static char *function = "libvslvm_physical_volume_read_label"; ssize_t read_count = 0; uint64_t offset = 0; uint64_t size = 0; int entry_index = 0; int result = 0; #if defined( HAVE_DEBUG_OUTPUT ) uint64_t value_64bit = 0; uint32_t value_32bit = 0; #endif if( physical_volume == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid physical volume.", function ); return( -1 ); } internal_physical_volume = (libvslvm_internal_physical_volume_t *) physical_volume; #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: reading physical volume label at offset: %" PRIi64 "\n", function, file_offset ); } #endif if( libbfio_pool_seek_offset( file_io_pool, file_io_pool_entry, file_offset, SEEK_SET, error ) == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_SEEK_FAILED, "%s: unable to seek offset: %" PRIi64 " (0x%08" PRIx64 ").", function, file_offset, file_offset ); goto on_error; } read_count = libbfio_pool_read_buffer( file_io_pool, file_io_pool_entry, (uint8_t *) &physical_volume_label_header, sizeof( vslvm_physical_volume_label_header_t ), error ); if( read_count != (ssize_t) sizeof( vslvm_physical_volume_label_header_t ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read physical volume label header.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: physical volume label header data:\n", function ); libcnotify_print_data( (uint8_t *) &physical_volume_label_header, sizeof( vslvm_physical_volume_label_header_t ), 0 ); } #endif if( memory_compare( physical_volume_label_header.signature, vslvm_physical_volume_label_signature, 8 ) != 0 ) { return( 0 ); } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: signature\t\t\t\t: %c%c%c%c%c%c%c%c\n", function, physical_volume_label_header.signature[ 0 ], physical_volume_label_header.signature[ 1 ], physical_volume_label_header.signature[ 2 ], physical_volume_label_header.signature[ 3 ], physical_volume_label_header.signature[ 4 ], physical_volume_label_header.signature[ 5 ], physical_volume_label_header.signature[ 6 ], physical_volume_label_header.signature[ 7 ] ); byte_stream_copy_to_uint64_little_endian( physical_volume_label_header.sector_number, value_64bit ); libcnotify_printf( "%s: sector number\t\t\t: %" PRIu64 "\n", function, value_64bit ); byte_stream_copy_to_uint32_little_endian( physical_volume_label_header.checksum, value_32bit ); libcnotify_printf( "%s: checksum\t\t\t\t: 0x%08" PRIx32 "\n", function, value_32bit ); byte_stream_copy_to_uint32_little_endian( physical_volume_label_header.data_offset, value_32bit ); libcnotify_printf( "%s: data offset\t\t\t: 0x%08" PRIx32 "\n", function, value_32bit ); libcnotify_printf( "%s: type indicator\t\t\t: %c%c%c%c%c%c%c%c\n", function, physical_volume_label_header.type_indicator[ 0 ], physical_volume_label_header.type_indicator[ 1 ], physical_volume_label_header.type_indicator[ 2 ], physical_volume_label_header.type_indicator[ 3 ], physical_volume_label_header.type_indicator[ 4 ], physical_volume_label_header.type_indicator[ 5 ], physical_volume_label_header.type_indicator[ 6 ], physical_volume_label_header.type_indicator[ 7 ] ); libcnotify_printf( "\n" ); } #endif /* TODO calculate checksum */ read_count = libbfio_pool_read_buffer( file_io_pool, file_io_pool_entry, (uint8_t *) &physical_volume_header, sizeof( vslvm_physical_volume_header_t ), error ); if( read_count != (ssize_t) sizeof( vslvm_physical_volume_header_t ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read physical volume header.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: physical volume header data:\n", function ); libcnotify_print_data( (uint8_t *) &physical_volume_header, sizeof( vslvm_physical_volume_header_t ), 0 ); } #endif #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: identifier\t\t\t\t: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n", function, physical_volume_header.identifier[ 0 ], physical_volume_header.identifier[ 1 ], physical_volume_header.identifier[ 2 ], physical_volume_header.identifier[ 3 ], physical_volume_header.identifier[ 4 ], physical_volume_header.identifier[ 5 ], physical_volume_header.identifier[ 6 ], physical_volume_header.identifier[ 7 ], physical_volume_header.identifier[ 8 ], physical_volume_header.identifier[ 9 ], physical_volume_header.identifier[ 10 ], physical_volume_header.identifier[ 11 ], physical_volume_header.identifier[ 12 ], physical_volume_header.identifier[ 13 ], physical_volume_header.identifier[ 14 ], physical_volume_header.identifier[ 15 ], physical_volume_header.identifier[ 16 ], physical_volume_header.identifier[ 17 ], physical_volume_header.identifier[ 18 ], physical_volume_header.identifier[ 19 ], physical_volume_header.identifier[ 20 ], physical_volume_header.identifier[ 21 ], physical_volume_header.identifier[ 22 ], physical_volume_header.identifier[ 23 ], physical_volume_header.identifier[ 24 ], physical_volume_header.identifier[ 25 ], physical_volume_header.identifier[ 26 ], physical_volume_header.identifier[ 27 ], physical_volume_header.identifier[ 28 ], physical_volume_header.identifier[ 29 ], physical_volume_header.identifier[ 30 ], physical_volume_header.identifier[ 31 ] ); byte_stream_copy_to_uint64_little_endian( physical_volume_header.volume_size, value_64bit ); libcnotify_printf( "%s: volume size\t\t\t: %" PRIu64 "\n", function, value_64bit ); libcnotify_printf( "\n" ); } #endif do { read_count = libbfio_pool_read_buffer( file_io_pool, file_io_pool_entry, (uint8_t *) &data_area_descriptor_data, sizeof( vslvm_data_area_descriptor_t ), error ); if( read_count != (ssize_t) sizeof( vslvm_data_area_descriptor_t ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read data area descriptor.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: data area descriptor data:\n", function ); libcnotify_print_data( (uint8_t *) &data_area_descriptor_data, sizeof( vslvm_data_area_descriptor_t ), 0 ); } #endif result = memory_compare( (uint8_t *) &data_area_descriptor_data, vslvm_empty_data_area_descriptor, sizeof( vslvm_data_area_descriptor_t ) ); if( result != 0 ) { byte_stream_copy_to_uint64_little_endian( data_area_descriptor_data.offset, offset ); byte_stream_copy_to_uint64_little_endian( data_area_descriptor_data.size, size ); #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: data area offset\t\t\t: 0x%08" PRIx64 "\n", function, offset ); libcnotify_printf( "%s: data area size\t\t\t: %" PRIu64 "\n", function, size ); libcnotify_printf( "\n" ); } #endif if( libvslvm_data_area_descriptor_initialize( &data_area_descriptor, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create data area descriptor.", function ); goto on_error; } if( libvslvm_data_area_descriptor_set( data_area_descriptor, (off64_t) offset, (size64_t) size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set data area descriptor.", function ); goto on_error; } if( libcdata_array_append_entry( internal_physical_volume->data_area_descriptors_array, &entry_index, (intptr_t *) data_area_descriptor, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_APPEND_FAILED, "%s: unable to append entry to data area descriptors array.", function ); goto on_error; } data_area_descriptor = NULL; } } while( result != 0 ); do { read_count = libbfio_pool_read_buffer( file_io_pool, file_io_pool_entry, (uint8_t *) &data_area_descriptor_data, sizeof( vslvm_data_area_descriptor_t ), error ); if( read_count != (ssize_t) sizeof( vslvm_data_area_descriptor_t ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_READ_FAILED, "%s: unable to read metadata area descriptor.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: metadata area descriptor data:\n", function ); libcnotify_print_data( (uint8_t *) &data_area_descriptor_data, sizeof( vslvm_data_area_descriptor_t ), 0 ); } #endif result = memory_compare( (uint8_t *) &data_area_descriptor_data, vslvm_empty_data_area_descriptor, sizeof( vslvm_data_area_descriptor_t ) ); if( result != 0 ) { byte_stream_copy_to_uint64_little_endian( data_area_descriptor_data.offset, offset ); byte_stream_copy_to_uint64_little_endian( data_area_descriptor_data.size, size ); #if defined( HAVE_DEBUG_OUTPUT ) if( libcnotify_verbose != 0 ) { libcnotify_printf( "%s: metadata area offset\t\t: 0x%08" PRIx64 "\n", function, offset ); libcnotify_printf( "%s: metadata area size\t\t\t: %" PRIu64 "\n", function, size ); libcnotify_printf( "\n" ); } #endif if( libvslvm_data_area_descriptor_initialize( &data_area_descriptor, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create data area descriptor.", function ); goto on_error; } if( libvslvm_data_area_descriptor_set( data_area_descriptor, (off64_t) offset, (size64_t) size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set data area descriptor.", function ); goto on_error; } if( libcdata_array_append_entry( internal_physical_volume->metadata_area_descriptors_array, &entry_index, (intptr_t *) data_area_descriptor, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_APPEND_FAILED, "%s: unable to append entry to metadata area descriptors array.", function ); goto on_error; } data_area_descriptor = NULL; } } while( result != 0 ); return( 1 ); on_error: if( data_area_descriptor != NULL ) { libvslvm_data_area_descriptor_free( &data_area_descriptor, NULL ); } libcdata_array_empty( internal_physical_volume->metadata_area_descriptors_array, (int (*)(intptr_t **, libcerror_error_t **)) &libvslvm_data_area_descriptor_free, NULL ); libcdata_array_empty( internal_physical_volume->data_area_descriptors_array, (int (*)(intptr_t **, libcerror_error_t **)) &libvslvm_data_area_descriptor_free, NULL ); return( -1 ); }