/* 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 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 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 );
}
