/* Appends a stripe
* Returns 1 if successful or -1 on error
*/
int libvslvm_segment_append_stripe(
libvslvm_segment_t *segment,
libvslvm_stripe_t *stripe,
libcerror_error_t **error )
{
libvslvm_internal_segment_t *internal_segment = NULL;
static char *function = "libvslvm_segment_append_stripe";
int entry_index = 0;
if( segment == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment.",
function );
return( -1 );
}
internal_segment = (libvslvm_internal_segment_t *) segment;
if( stripe == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid stripe.",
function );
return( -1 );
}
if( libcdata_array_append_entry(
internal_segment->stripes_array,
&entry_index,
(intptr_t *) stripe,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append stripe to segment.",
function );
return( -1 );
}
return( 1 );
}
/* Appends a segment
* Returns 1 if successful or -1 on error
*/
int libvslvm_logical_volume_values_append_segment(
libvslvm_logical_volume_values_t *logical_volume_values,
libvslvm_segment_t *segment,
libcerror_error_t **error )
{
static char *function = "libvslvm_logical_volume_values_append_segment";
int entry_index = 0;
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( segment == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment.",
function );
return( -1 );
}
if( libcdata_array_append_entry(
logical_volume_values->segments_array,
&entry_index,
(intptr_t *) segment,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append segment to logical volume values.",
function );
return( -1 );
}
return( 1 );
}
/* Appends a handle to the file system
* Returns 1 if successful or -1 on error
*/
int mount_file_system_append_handle(
mount_file_system_t *file_system,
libvmdk_handle_t *vmdk_handle,
libcerror_error_t **error )
{
static char *function = "mount_file_system_append_handle";
int entry_index = 0;
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( libcdata_array_append_entry(
file_system->handles_array,
&entry_index,
(intptr_t *) vmdk_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append handle to array.",
function );
return( -1 );
}
return( 1 );
}
/* Reads a data block and determines its entries
* Returns 1 if successful or -1 on error
*/
int libcreg_data_block_read_entries(
libcreg_data_block_t *data_block,
libbfio_handle_t *file_io_handle,
int (*read_entry_size_function)(
const uint8_t *data,
size_t data_size,
size_t *entry_size,
libcerror_error_t **error ),
int ascii_codepage,
uint8_t have_debug_output LIBCREG_ATTRIBUTE_UNUSED,
libcerror_error_t **error )
{
libcreg_data_block_entry_t *data_block_entry = NULL;
uint8_t *data_block_entry_data = NULL;
static char *function = "libcreg_data_block_read_entries";
size_t data_block_data_size = 0;
size_t data_block_entry_offset = 0;
ssize_t read_count = 0;
int entry_index = 0;
int data_block_entry_index = 0;
#if defined( HAVE_DEBUG_OUTPUT )
libcreg_key_name_entry_t *key_name_entry = NULL;
#else
LIBCREG_UNREFERENCED_PARAMETER( have_debug_output );
#endif
if( data_block == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data block.",
function );
return( -1 );
}
if( data_block->data != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid data block - data already set.",
function );
return( -1 );
}
#if SIZEOF_SIZE_T <= 4
if( data_block->size > (size_t) SSIZE_MAX )
#else
if( data_block->size > (uint32_t) SSIZE_MAX )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid data block - size value exceeds maximum.",
function );
return( -1 );
}
if( read_entry_size_function == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid read entry size function.",
function );
return( -1 );
}
data_block->data_size = (size_t) data_block->size - sizeof( creg_data_block_header_t );
data_block->data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * data_block->data_size );
if( data_block->data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create data block data.",
function );
goto on_error;
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
data_block->data,
data_block->data_size,
error );
if( read_count != (ssize_t) data_block->data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read data block data.",
function );
goto on_error;
}
data_block_entry_data = data_block->data;
if( (int32_t) data_block->used_size < 0 )
{
data_block_data_size = data_block->data_size;
}
else
{
data_block_data_size = (size_t) data_block->used_size - sizeof( creg_data_block_header_t );
}
while( data_block_entry_offset < data_block_data_size )
{
if( libcreg_data_block_entry_initialize(
&data_block_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create data block entry.",
function );
goto on_error;
}
if( read_entry_size_function(
&( data_block_entry_data[ data_block_entry_offset ] ),
data_block->data_size - data_block_entry_offset,
&( data_block_entry->size ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve data block entry size.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: data block entry: %03d offset\t\t: %" PRIzd "\n",
function,
data_block_entry_index,
data_block_entry_offset );
libcnotify_printf(
"%s: data block entry: %03d size\t\t: %" PRIzd "\n",
function,
data_block_entry_index,
data_block_entry->size );
}
#endif
data_block_entry->offset = data_block_entry_offset;
#if defined( HAVE_DEBUG_OUTPUT )
if( ( libcnotify_verbose != 0 )
&& ( have_debug_output != 0 ) )
{
if( libcreg_key_name_entry_initialize(
&key_name_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create key name entry.",
function );
goto on_error;
}
if( libcreg_key_name_entry_read_data(
key_name_entry,
&( ( data_block->data )[ data_block_entry->offset ] ),
data_block_entry->size,
ascii_codepage,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read key name entry: %d.",
function,
data_block_entry_index );
goto on_error;
}
if( libcreg_key_name_entry_free(
&key_name_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free key name entry.",
function );
goto on_error;
}
}
#endif
data_block_entry_offset += (size_t) data_block_entry->size;
if( libcdata_array_append_entry(
data_block->entries_array,
&entry_index,
(intptr_t *) data_block_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append data block entry: %d.",
function,
data_block_entry_index );
goto on_error;
}
data_block_entry = NULL;
data_block_entry_index++;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( ( libcnotify_verbose != 0 )
&& ( have_debug_output != 0 ) )
{
if( data_block_entry_offset < data_block->data_size )
{
libcnotify_printf(
"%s: trailing data:\n",
function );
libcnotify_print_data(
&( ( data_block->data )[ data_block_entry_offset ] ),
data_block->data_size - data_block_entry_offset,
LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
}
else
{
libcnotify_printf(
"\n" );
}
}
#endif
return( 1 );
on_error:
#if defined( HAVE_DEBUG_OUTPUT )
if( key_name_entry != NULL )
{
libcreg_key_name_entry_free(
&key_name_entry,
NULL );
}
#endif
if( data_block_entry != NULL )
{
libcreg_data_block_entry_free(
&data_block_entry,
NULL );
}
if( data_block->entries_array != NULL )
{
libcdata_array_clear(
data_block->entries_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libcreg_data_block_entry_free,
NULL );
}
if( data_block->data != NULL )
{
memory_free(
data_block->data );
data_block->data = NULL;
}
data_block->data_size = 0;
return( -1 );
}
/* Opens the parent input file
* Returns 1 if successful, 0 if no parent or -1 on error
*/
int mount_handle_open_input_parent_file(
mount_handle_t *mount_handle,
libvhdi_file_t *input_file,
libcerror_error_t **error )
{
uint8_t guid[ 16 ];
libcstring_system_character_t *parent_basename_end = NULL;
libcstring_system_character_t *parent_filename = NULL;
libcstring_system_character_t *parent_path = NULL;
libvhdi_file_t *parent_input_file = NULL;
static char *function = "mount_handle_open_input_parent_file";
size_t parent_basename_length = 0;
size_t parent_filename_size = 0;
size_t parent_path_size = 0;
int entry_index = 0;
int result = 0;
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
result = libvhdi_file_get_parent_identifier(
input_file,
guid,
16,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve parent content identifier.",
function );
goto on_error;
}
else if( result != 1 )
{
return( 0 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libvhdi_file_get_utf16_parent_filename_size(
input_file,
&parent_filename_size,
error );
#else
result = libvhdi_file_get_utf8_parent_filename_size(
input_file,
&parent_filename_size,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve parent filename size.",
function );
goto on_error;
}
if( parent_filename_size == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: missing parent filename.",
function );
goto on_error;
}
if( ( parent_filename_size > (size_t) SSIZE_MAX )
|| ( ( sizeof( libcstring_system_character_t ) * parent_filename_size ) > (size_t) SSIZE_MAX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid parent filename size value exceeds maximum.",
function );
goto on_error;
}
parent_filename = libcstring_system_string_allocate(
parent_filename_size );
if( parent_filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create parent filename string.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libvhdi_file_get_utf16_parent_filename(
input_file,
(uint16_t *) parent_filename,
parent_filename_size,
error );
#else
result = libvhdi_file_get_utf8_parent_filename(
input_file,
(uint8_t *) parent_filename,
parent_filename_size,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve parent filename.",
function );
goto on_error;
}
parent_basename_end = libcstring_system_string_search_character_reverse(
parent_filename,
(libcstring_system_character_t) '\\',
parent_filename_size );
if( parent_basename_end != NULL )
{
parent_basename_length = (size_t) ( parent_basename_end - parent_filename ) + 1;
}
if( mount_handle->basename == NULL )
{
parent_path = &( parent_filename[ parent_basename_length ] );
parent_path_size = parent_filename_size - ( parent_basename_length + 1 );
}
else
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libcpath_path_join_wide(
&parent_path,
&parent_path_size,
mount_handle->basename,
mount_handle->basename_size - 1,
&( parent_filename[ parent_basename_length ] ),
parent_filename_size - ( parent_basename_length + 1 ),
error ) != 1 )
#else
if( libcpath_path_join(
&parent_path,
&parent_path_size,
mount_handle->basename,
mount_handle->basename_size - 1,
&( parent_filename[ parent_basename_length ] ),
parent_filename_size - ( parent_basename_length + 1 ),
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create parent path.",
function );
goto on_error;
}
}
if( libvhdi_file_initialize(
&parent_input_file,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize parent input file.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libvhdi_file_open_wide(
parent_input_file,
parent_path,
LIBVHDI_OPEN_READ,
error ) != 1 )
#else
if( libvhdi_file_open(
parent_input_file,
parent_path,
LIBVHDI_OPEN_READ,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open parent input file: %" PRIs_LIBCSTRING_SYSTEM ".",
function,
parent_path );
goto on_error;
}
if( mount_handle_open_input_parent_file(
mount_handle,
parent_input_file,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open parent input file.",
function );
return( -1 );
}
if( libvhdi_file_set_parent_file(
input_file,
parent_input_file,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set parent input file.",
function );
goto on_error;
}
if( libcdata_array_append_entry(
mount_handle->input_files_array,
&entry_index,
(intptr_t *) parent_input_file,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append parent input file to array.",
function );
goto on_error;
}
if( parent_path != NULL )
{
if( mount_handle->basename != NULL )
{
memory_free(
parent_path );
}
parent_path = NULL;
}
if( parent_filename != NULL )
{
memory_free(
parent_filename );
parent_filename = NULL;
}
return( 1 );
on_error:
if( parent_input_file != NULL )
{
libvhdi_file_free(
&parent_input_file,
NULL );
}
if( ( parent_path != NULL )
&& ( mount_handle->basename != NULL ) )
{
memory_free(
parent_path );
}
if( parent_filename != NULL )
{
memory_free(
parent_filename );
}
return( -1 );
}
/* Opens the input of the mount handle
* Returns 1 if successful, 0 if the keys could not be read or -1 on error
*/
int mount_handle_open_input(
mount_handle_t *mount_handle,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
libcstring_system_character_t *basename_end = NULL;
libvhdi_file_t *input_file = NULL;
static char *function = "mount_handle_open_input";
size_t basename_length = 0;
size_t filename_length = 0;
int entry_index = 0;
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( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
filename_length = libcstring_system_string_length(
filename );
basename_end = libcstring_system_string_search_character_reverse(
filename,
(libcstring_system_character_t) LIBCPATH_SEPARATOR,
filename_length + 1 );
if( basename_end != NULL )
{
basename_length = (size_t) ( basename_end - filename ) + 1;
}
if( basename_length > 0 )
{
if( mount_handle_set_basename(
mount_handle,
filename,
basename_length,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set basename.",
function );
goto on_error;
}
}
if( libvhdi_file_initialize(
&input_file,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input file.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libvhdi_file_open_wide(
input_file,
filename,
LIBVHDI_OPEN_READ,
error ) != 1 )
#else
if( libvhdi_file_open(
input_file,
filename,
LIBVHDI_OPEN_READ,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input file.",
function );
goto on_error;
}
if( mount_handle_open_input_parent_file(
mount_handle,
input_file,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open parent input file.",
function );
goto on_error;
}
if( libcdata_array_append_entry(
mount_handle->input_files_array,
&entry_index,
(intptr_t *) input_file,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append input file to array.",
function );
goto on_error;
}
return( 1 );
on_error:
if( input_file != NULL )
{
libvhdi_file_free(
&input_file,
NULL );
}
libcdata_array_empty(
mount_handle->input_files_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libvhdi_file_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 );
}
/* Reads the metadata area
* Returns 1 if successful or -1 on error
*/
int libvslvm_metadata_area_read(
libvslvm_metadata_area_t *metadata_area,
libbfio_handle_t *file_io_handle,
off64_t file_offset,
libcerror_error_t **error )
{
vslvm_raw_location_descriptor_t raw_location_descriptor_data;
vslvm_metadata_area_header_t metadata_area_header;
libvslvm_raw_location_descriptor_t *raw_location_descriptor = NULL;
static char *function = "libvslvm_metadata_area_read";
ssize_t read_count = 0;
uint64_t offset = 0;
uint64_t size = 0;
uint32_t checksum = 0;
uint32_t flags = 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( metadata_area == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid metadata area.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: reading metadata area at offset: %" PRIi64 "\n",
function,
file_offset );
}
#endif
if( libbfio_handle_seek_offset(
file_io_handle,
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_handle_read_buffer(
file_io_handle,
(uint8_t *) &metadata_area_header,
sizeof( vslvm_metadata_area_header_t ),
error );
if( read_count != (ssize_t) sizeof( vslvm_metadata_area_header_t ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read metadata area header.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: metadata area header data:\n",
function );
libcnotify_print_data(
(uint8_t *) &metadata_area_header,
sizeof( vslvm_metadata_area_header_t ),
0 );
}
#endif
if( memory_compare(
metadata_area_header.signature,
vslvm_metadata_area_signature,
8 ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported metadata area signature.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
byte_stream_copy_to_uint32_little_endian(
metadata_area_header.checksum,
value_32bit );
libcnotify_printf(
"%s: checksum\t\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
libcnotify_printf(
"%s: signature\t\t\t\t\t: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",
function,
metadata_area_header.signature[ 0 ],
metadata_area_header.signature[ 1 ],
metadata_area_header.signature[ 2 ],
metadata_area_header.signature[ 3 ],
metadata_area_header.signature[ 4 ],
metadata_area_header.signature[ 5 ],
metadata_area_header.signature[ 6 ],
metadata_area_header.signature[ 7 ],
metadata_area_header.signature[ 8 ],
metadata_area_header.signature[ 9 ],
metadata_area_header.signature[ 10 ],
metadata_area_header.signature[ 11 ],
metadata_area_header.signature[ 12 ],
metadata_area_header.signature[ 13 ],
metadata_area_header.signature[ 14 ],
metadata_area_header.signature[ 15 ] );
byte_stream_copy_to_uint32_little_endian(
metadata_area_header.version,
value_32bit );
libcnotify_printf(
"%s: version\t\t\t\t\t: %" PRIu32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint64_little_endian(
metadata_area_header.data_offset,
value_64bit );
libcnotify_printf(
"%s: data offset\t\t\t\t: 0x%08" PRIx64 "\n",
function,
value_64bit );
byte_stream_copy_to_uint64_little_endian(
metadata_area_header.data_size,
value_64bit );
libcnotify_printf(
"%s: data size\t\t\t\t\t: %" PRIu64 "\n",
function,
value_64bit );
libcnotify_printf(
"\n" );
}
#endif
/* TODO calculate checksum */
do
{
read_count = libbfio_handle_read_buffer(
file_io_handle,
(uint8_t *) &raw_location_descriptor_data,
sizeof( vslvm_raw_location_descriptor_t ),
error );
if( read_count != (ssize_t) sizeof( vslvm_raw_location_descriptor_t ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read raw location descriptor.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: raw location descriptor data:\n",
function );
libcnotify_print_data(
(uint8_t *) &raw_location_descriptor_data,
sizeof( vslvm_raw_location_descriptor_t ),
0 );
}
#endif
result = memory_compare(
(uint8_t *) &raw_location_descriptor_data,
vslvm_empty_raw_location_descriptor,
sizeof( vslvm_raw_location_descriptor_t ) );
if( result != 0 )
{
byte_stream_copy_to_uint64_little_endian(
raw_location_descriptor_data.offset,
offset );
byte_stream_copy_to_uint64_little_endian(
raw_location_descriptor_data.size,
size );
byte_stream_copy_to_uint32_little_endian(
raw_location_descriptor_data.checksum,
checksum );
byte_stream_copy_to_uint32_little_endian(
raw_location_descriptor_data.flags,
flags );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: offset\t\t\t\t\t: 0x%08" PRIx64 "\n",
function,
offset );
libcnotify_printf(
"%s: size\t\t\t\t\t: %" PRIu64 "\n",
function,
size );
libcnotify_printf(
"%s: checksum\t\t\t\t\t: 0x%08" PRIx32 "\n",
function,
checksum );
libcnotify_printf(
"%s: flags\t\t\t\t\t: 0x%08" PRIx32 "\n",
function,
flags );
libcnotify_printf(
"\n" );
}
#endif
if( ( flags & LIBVSLVM_RAW_LOCATION_DESCRIPTOR_FLAG_IGNORE ) == 0 )
{
if( libvslvm_raw_location_descriptor_initialize(
&raw_location_descriptor,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create raw location descriptor.",
function );
goto on_error;
}
if( libvslvm_raw_location_descriptor_set(
raw_location_descriptor,
(off64_t) ( file_offset + offset ),
(size64_t) size,
checksum,
flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set raw location descriptor.",
function );
goto on_error;
}
if( libcdata_array_append_entry(
metadata_area->raw_location_descriptors_array,
&entry_index,
(intptr_t *) raw_location_descriptor,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append entry to raw location descriptors array.",
function );
goto on_error;
}
raw_location_descriptor = NULL;
}
}
}
while( result != 0 );
return( 1 );
on_error:
if( raw_location_descriptor != NULL )
{
libvslvm_raw_location_descriptor_free(
&raw_location_descriptor,
NULL );
}
libcdata_array_empty(
metadata_area->raw_location_descriptors_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libvslvm_raw_location_descriptor_free,
NULL );
return( -1 );
}
/* Appends a segment
* Returns 1 if successful or -1 on error
*/
int libfdata_segments_array_append_segment(
libcdata_array_t *segments_array,
libcdata_array_t *mapped_ranges_array,
size64_t *data_size,
int *segment_index,
int segment_file_index,
off64_t segment_offset,
size64_t segment_size,
uint32_t segment_flags,
libcerror_error_t **error )
{
libfdata_mapped_range_t *mapped_range = NULL;
libfdata_range_t *segment_data_range = NULL;
static char *function = "libfdata_segments_array_append_segment";
int mapped_range_index = -1;
if( data_size == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data size.",
function );
return( -1 );
}
if( segment_file_index < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid segment file index value out of bounds.",
function );
return( -1 );
}
if( segment_offset < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid segment offset value out of bounds.",
function );
return( -1 );
}
if( libfdata_mapped_range_initialize(
&mapped_range,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create mapped range.",
function );
goto on_error;
}
if( libfdata_mapped_range_set(
mapped_range,
(off64_t) *data_size,
segment_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set mapped range values.",
function );
goto on_error;
}
if( libcdata_array_append_entry(
mapped_ranges_array,
&mapped_range_index,
(intptr_t *) mapped_range,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append mapped range to array.",
function );
goto on_error;
}
if( libfdata_range_initialize(
&segment_data_range,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create segment data range.",
function );
goto on_error;
}
if( libfdata_range_set(
segment_data_range,
segment_file_index,
segment_offset,
segment_size,
segment_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set segment data range values.",
function );
goto on_error;
}
if( libcdata_array_append_entry(
segments_array,
segment_index,
(intptr_t *) segment_data_range,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append data range to segments array.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: segment: %03d\tfile index: %03d offset: 0x%08" PRIx64 " - 0x%08" PRIx64 " (size: %" PRIu64 ")\n",
function,
*segment_index,
segment_file_index,
segment_offset,
segment_offset + segment_size,
segment_size );
libcnotify_printf(
"%s: segment: %03d\tmapped range: 0x%08" PRIx64 " - 0x%08" PRIx64 " (size: %" PRIu64 ")\n",
function,
*segment_index,
*data_size,
*data_size + segment_size,
segment_size );
libcnotify_printf(
"\n" );
}
#endif
*data_size += segment_size;
return( 1 );
on_error:
if( segment_data_range != NULL )
{
libfdata_range_free(
&segment_data_range,
NULL );
}
if( mapped_range_index != -1 )
{
libcdata_array_set_entry_by_index(
mapped_ranges_array,
mapped_range_index,
NULL,
NULL );
}
if( mapped_range != NULL )
{
libfdata_mapped_range_free(
&mapped_range,
NULL );
}
return( -1 );
}
/* Reads the streams directory
* Returns 1 if successful or -1 on error
*/
int libmdmp_io_handle_read_streams_directory(
libmdmp_io_handle_t *io_handle,
libbfio_handle_t *file_io_handle,
uint32_t streams_directory_offset,
uint32_t number_of_streams,
libcdata_array_t *streams_array,
libcerror_error_t **error )
{
libmdmp_stream_descriptor_t *stream_descriptor = NULL;
uint8_t *streams_directory_data = NULL;
uint8_t *streams_directory_entry_data = NULL;
static char *function = "libmdmp_io_handle_read_streams_directory";
size_t streams_directory_data_size = 0;
ssize_t read_count = 0;
uint32_t stream_data_offset = 0;
uint32_t stream_data_size = 0;
uint32_t stream_index = 0;
int entry_index = 0;
int result = 0;
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 defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: reading streams directory at offset: %" PRIu32 " (0x%08" PRIx32 ")\n",
function,
streams_directory_offset,
streams_directory_offset );
}
#endif
if( libbfio_handle_seek_offset(
file_io_handle,
streams_directory_offset,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek streams directory offset: %" PRIu32 " (0x%08" PRIx32 ").",
function );
goto on_error;
}
streams_directory_data_size = sizeof( mdmp_streams_directory_entry_t )
* number_of_streams;
if( streams_directory_data_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid streams directory data size value out of bounds.",
function );
goto on_error;
}
streams_directory_data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * streams_directory_data_size );
if( streams_directory_data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create streams directory data.",
function );
goto on_error;
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
streams_directory_data,
streams_directory_data_size,
error );
if( read_count != (ssize_t) streams_directory_data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read streams directory data.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: streams directory data:\n",
function );
libcnotify_print_data(
streams_directory_data,
streams_directory_data_size,
0 );
}
#endif
streams_directory_entry_data = streams_directory_data;
for( stream_index = 0;
stream_index < number_of_streams;
stream_index++ )
{
if( stream_descriptor == NULL )
{
if( libmdmp_stream_descriptor_initialize(
&stream_descriptor,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create stream descriptor.",
function );
goto on_error;
}
}
byte_stream_copy_to_uint32_little_endian(
( (mdmp_streams_directory_entry_t *) streams_directory_entry_data )->stream_type,
stream_descriptor->type );
byte_stream_copy_to_uint32_little_endian(
( (mdmp_streams_directory_entry_t *) streams_directory_entry_data )->stream_data_size,
stream_data_size );
byte_stream_copy_to_uint32_little_endian(
( (mdmp_streams_directory_entry_t *) streams_directory_entry_data )->stream_data_rva,
stream_data_offset );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: stream: %02" PRIu32 " type\t\t: %" PRIu32 " (%s)\n",
function,
stream_index,
stream_descriptor->type,
libmdmp_debug_get_stream_type(
stream_descriptor->type ) );
libcnotify_printf(
"%s: stream: %02" PRIu32 " data size\t\t: %" PRIu32 "\n",
function,
stream_index,
stream_data_size );
libcnotify_printf(
"%s: stream: %02" PRIu32 " RVA\t\t: 0x%08" PRIx32 "\n",
function,
stream_index,
stream_data_offset );
}
#endif
result = memory_compare(
streams_directory_entry_data,
empty_streams_directory_entry,
sizeof( mdmp_streams_directory_entry_t ) );
streams_directory_entry_data += sizeof( mdmp_streams_directory_entry_t );
if( result != 0 )
{
if( libmdmp_stream_descriptor_set_data_range(
stream_descriptor,
(off64_t) stream_data_offset,
(size64_t) stream_data_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set data range in stream descriptor.",
function );
goto on_error;
}
if( libcdata_array_append_entry(
streams_array,
&entry_index,
(intptr_t *) stream_descriptor,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append stream descriptor to sections array.",
function );
goto on_error;
}
stream_descriptor = NULL;
}
}
if( stream_descriptor != NULL )
{
if( libmdmp_stream_descriptor_free(
&stream_descriptor,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free stream descriptor.",
function );
goto on_error;
}
}
memory_free(
streams_directory_data );
return( 1 );
on_error:
if( stream_descriptor != NULL )
{
libmdmp_stream_descriptor_free(
&stream_descriptor,
NULL );
}
if( streams_directory_data != NULL )
{
memory_free(
streams_directory_data );
}
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 );
}
/* Opens the mount handle
* Returns 1 if successful or -1 on error
*/
int mount_handle_open_input(
mount_handle_t *mount_handle,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
libvslvm_logical_volume_t *logical_volume = NULL;
static char *function = "mount_handle_open_input";
size_t filename_length = 0;
int entry_index = 0;
int logical_volume_index = 0;
int number_of_logical_volumes = 0;
int result = 0;
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( libbfio_file_range_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize file IO handle.",
function );
goto on_error;
}
filename_length = libcstring_system_string_length(
filename );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libbfio_file_range_set_name_wide(
file_io_handle,
filename,
filename_length,
error ) != 1 )
#else
if( libbfio_file_range_set_name(
file_io_handle,
filename,
filename_length,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open set file name.",
function );
goto on_error;
}
if( libbfio_file_range_set(
file_io_handle,
mount_handle->volume_offset,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open set volume offset.",
function );
goto on_error;
}
if( libvslvm_handle_open_file_io_handle(
mount_handle->input_handle,
file_io_handle,
LIBVSLVM_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input handle.",
function );
goto on_error;
}
if( libbfio_pool_append_handle(
mount_handle->physical_volume_file_io_pool,
&entry_index,
file_io_handle,
LIBBFIO_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open input handle.",
function );
goto on_error;
}
/* The takes over management of the file IO handle
*/
file_io_handle = NULL;
/* TODO determine if the first file is a metadata only file and change filenames accordingly
*/
if( libvslvm_handle_open_physical_volume_files_file_io_pool(
mount_handle->input_handle,
mount_handle->physical_volume_file_io_pool,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open physical volume files.",
function );
goto on_error;
}
if( libvslvm_handle_get_volume_group(
mount_handle->input_handle,
&( mount_handle->volume_group ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve volume group.",
function );
goto on_error;
}
if( libvslvm_volume_group_get_number_of_logical_volumes(
mount_handle->volume_group,
&number_of_logical_volumes,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of logical volumes.",
function );
goto on_error;
}
for( logical_volume_index = 0;
logical_volume_index < number_of_logical_volumes;
logical_volume_index++ )
{
if( libvslvm_volume_group_get_logical_volume(
mount_handle->volume_group,
logical_volume_index,
&logical_volume,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve logical volume: %d.",
function,
logical_volume_index );
goto on_error;
}
if( libcdata_array_append_entry(
mount_handle->logical_volumes_array,
&entry_index,
(intptr_t *) logical_volume,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append logical volume to array.",
function );
goto on_error;
}
logical_volume = NULL;
}
return( 1 );
on_error:
if( logical_volume != NULL )
{
libvslvm_logical_volume_free(
&logical_volume,
NULL );
}
if( mount_handle->volume_group != NULL )
{
libvslvm_volume_group_free(
&( mount_handle->volume_group ),
NULL );
}
if( mount_handle->input_handle != NULL )
{
libvslvm_handle_free(
&( mount_handle->input_handle ),
NULL );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
libcdata_array_empty(
mount_handle->logical_volumes_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libvslvm_logical_volume_free,
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 );
}
/* Reads the level 1 metadata
* Returns 1 if successful or -1 on error
*/
int libfsrefs_level1_metadata_read(
libfsrefs_level1_metadata_t *level1_metadata,
libfsrefs_io_handle_t *io_handle,
libbfio_handle_t *file_io_handle,
off64_t file_offset,
libcerror_error_t **error )
{
libfsrefs_block_descriptor_t *block_descriptor = NULL;
libfsrefs_metadata_block_t *metadata_block = NULL;
static char *function = "libfsrefs_level1_metadata_read";
size_t metadata_block_data_offset = 0;
uint32_t entry_index = 0;
uint32_t entry_offset = 0;
uint32_t number_of_entries = 0;
int array_entry_index = 0;
#if defined( HAVE_DEBUG_OUTPUT )
uint64_t value_64bit = 0;
uint32_t value_32bit = 0;
uint16_t value_16bit = 0;
#endif
if( level1_metadata == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid level 1 metadata.",
function );
return( -1 );
}
if( libfsrefs_metadata_block_initialize(
&metadata_block,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create metadata block.",
function );
goto on_error;
}
if( libfsrefs_metadata_block_read(
metadata_block,
io_handle,
file_io_handle,
file_offset,
1,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read metadata block.",
function );
goto on_error;
}
if( metadata_block->data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid metadata block - missing data.",
function );
goto on_error;
}
level1_metadata->sequence_number = metadata_block->sequence_number;
/* TODO add structures */
byte_stream_copy_to_uint32_little_endian(
&( metadata_block->data[ 56 ] ),
entry_offset );
byte_stream_copy_to_uint32_little_endian(
&( metadata_block->data[ 88 ] ),
number_of_entries );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
byte_stream_copy_to_uint32_little_endian(
&( metadata_block->data[ 48 ] ),
value_32bit );
libcnotify_printf(
"%s: unknown1\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint16_little_endian(
&( metadata_block->data[ 52 ] ),
value_16bit );
libcnotify_printf(
"%s: unknown2\t\t\t\t: 0x%04" PRIx16 "\n",
function,
value_16bit );
byte_stream_copy_to_uint16_little_endian(
&( metadata_block->data[ 54 ] ),
value_16bit );
libcnotify_printf(
"%s: unknown3\t\t\t\t: 0x%04" PRIx16 "\n",
function,
value_16bit );
libcnotify_printf(
"%s: unknown4 offset\t\t\t\t: 0x%08" PRIx32 "\n",
function,
entry_offset );
byte_stream_copy_to_uint32_little_endian(
&( metadata_block->data[ 60 ] ),
value_32bit );
libcnotify_printf(
"%s: table entry size\t\t\t: %" PRIu32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint64_little_endian(
&( metadata_block->data[ 64 ] ),
value_64bit );
libcnotify_printf(
"%s: sequence number\t\t\t\t: %" PRIu64 "\n",
function,
value_64bit );
byte_stream_copy_to_uint32_little_endian(
&( metadata_block->data[ 72 ] ),
value_32bit );
libcnotify_printf(
"%s: unknown5\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
&( metadata_block->data[ 76 ] ),
value_32bit );
libcnotify_printf(
"%s: unknown6\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
libcnotify_printf(
"%s: unknown7:\n",
function );
libcnotify_print_data(
&( metadata_block->data[ 80 ] ),
8,
LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
libcnotify_printf(
"%s: number of table entries\t\t\t: %" PRIu32 "\n",
function,
number_of_entries );
libcnotify_printf(
"%s: table entry offsets data:\n",
function );
libcnotify_print_data(
&( metadata_block->data[ 92 ] ),
4 * number_of_entries,
LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
}
#endif
/* TODO check if entry offset is in bounds */
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
byte_stream_copy_to_uint64_little_endian(
&( metadata_block->data[ entry_offset ] ),
value_64bit );
libcnotify_printf(
"%s: self entry: block number\t\t: %" PRIu64 "\n",
function,
value_64bit );
byte_stream_copy_to_uint64_little_endian(
&( metadata_block->data[ entry_offset + 8 ] ),
value_64bit );
libcnotify_printf(
"%s: self entry: unknown1\t\t\t: 0x%08" PRIx64 "\n",
function,
value_64bit );
byte_stream_copy_to_uint64_little_endian(
&( metadata_block->data[ entry_offset + 16 ] ),
value_64bit );
libcnotify_printf(
"%s: self entry: checksum\t\t\t: 0x%08" PRIx64 "\n",
function,
value_64bit );
libcnotify_printf(
"\n" );
}
#endif
metadata_block_data_offset = 92;
for( entry_index = 0;
entry_index < number_of_entries;
entry_index++ )
{
byte_stream_copy_to_uint32_little_endian(
&( metadata_block->data[ metadata_block_data_offset ] ),
entry_offset );
metadata_block_data_offset += 4;
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: entry: %02" PRIu32 " offset\t\t\t: 0x%08" PRIx32 "\n",
function,
entry_index,
entry_offset );
}
#endif
if( libfsrefs_block_descriptor_initialize(
&block_descriptor,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create block descriptor.",
function );
goto on_error;
}
/* TODO check if entry offset is in bounds */
byte_stream_copy_to_uint64_little_endian(
&( metadata_block->data[ entry_offset ] ),
block_descriptor->block_number );
byte_stream_copy_to_uint64_little_endian(
&( metadata_block->data[ entry_offset + 8 ] ),
block_descriptor->unknown );
byte_stream_copy_to_uint64_little_endian(
&( metadata_block->data[ entry_offset + 16 ] ),
block_descriptor->checksum );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: entry: %02" PRIu32 " block number\t\t\t: %" PRIu64 "\n",
function,
entry_index,
block_descriptor->block_number );
libcnotify_printf(
"%s: entry: %02" PRIu32 " unknown1\t\t\t: 0x%08" PRIx64 "\n",
function,
entry_index,
block_descriptor->unknown );
libcnotify_printf(
"%s: entry: %02" PRIu32 " checksum\t\t\t: 0x%08" PRIx64 "\n",
function,
entry_index,
block_descriptor->checksum );
libcnotify_printf(
"\n" );
}
#endif
if( libcdata_array_append_entry(
level1_metadata->level2_metadata_block_descriptors_array,
&array_entry_index,
(intptr_t *) block_descriptor,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append block descriptor to array.",
function );
goto on_error;
}
block_descriptor = NULL;
}
if( libfsrefs_metadata_block_free(
&metadata_block,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free metadata block.",
function );
goto on_error;
}
return( 1 );
on_error:
if( block_descriptor != NULL )
{
libfsrefs_block_descriptor_free(
&block_descriptor,
NULL );
}
if( metadata_block != NULL )
{
libfsrefs_metadata_block_free(
&metadata_block,
NULL );
}
return( -1 );
}
/* Reads a external key from the metadata entry
* Returns 1 if successful or -1 on error
*/
int libbde_external_key_read(
libbde_external_key_t *external_key,
libbde_metadata_entry_t *metadata_entry,
libcerror_error_t **error )
{
libbde_key_t *key = NULL;
libbde_metadata_entry_t *property_metadata_entry = NULL;
uint8_t *value_data = NULL;
static char *function = "libbde_external_key_read";
size_t value_data_size = 0;
ssize_t read_count = 0;
int property_metadata_entry_index = 0;
#if defined( HAVE_DEBUG_OUTPUT )
libcstring_system_character_t filetime_string[ 32 ];
libcstring_system_character_t guid_string[ 48 ];
libfdatetime_filetime_t *filetime = NULL;
libfguid_identifier_t *guid = NULL;
int result = 0;
#endif
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( metadata_entry == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid metadata entry.",
function );
return( -1 );
}
if( metadata_entry->value_type != LIBBDE_VALUE_TYPE_EXTERNAL_KEY )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: invalid metadata entry - unsupported value type: 0x%04" PRIx16 ".",
function,
metadata_entry->value_type );
return( -1 );
}
value_data = metadata_entry->value_data;
value_data_size = metadata_entry->value_data_size;
if( value_data_size < sizeof( bde_metadata_entry_external_key_header_t ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: value data size value out of bounds.",
function );
return( -1 );
}
if( memory_copy(
external_key->identifier,
( (bde_metadata_entry_external_key_header_t *) value_data )->identifier,
16 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy volume identifier.",
function );
goto on_error;
}
#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,
( (bde_metadata_entry_external_key_header_t *) value_data )->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( LIBCSTRING_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: identifier\t\t\t\t\t: %" PRIs_LIBCSTRING_SYSTEM "\n",
function,
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;
}
if( libfdatetime_filetime_initialize(
&filetime,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create filetime.",
function );
goto on_error;
}
if( libfdatetime_filetime_copy_from_byte_stream(
filetime,
( (bde_metadata_entry_external_key_header_t *) value_data )->modification_time,
8,
LIBFDATETIME_ENDIAN_LITTLE,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to copy filetime from byte stream.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libfdatetime_filetime_copy_to_utf16_string(
filetime,
(uint16_t *) filetime_string,
32,
LIBFDATETIME_STRING_FORMAT_TYPE_CTIME | LIBFDATETIME_STRING_FORMAT_FLAG_DATE_TIME_NANO_SECONDS,
error );
#else
result = libfdatetime_filetime_copy_to_utf8_string(
filetime,
(uint8_t *) filetime_string,
32,
LIBFDATETIME_STRING_FORMAT_TYPE_CTIME | LIBFDATETIME_STRING_FORMAT_FLAG_DATE_TIME_NANO_SECONDS,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to copy filetime to string.",
function );
goto on_error;
}
libcnotify_printf(
"%s: modification time\t\t\t\t: %" PRIs_LIBCSTRING_SYSTEM " UTC\n",
function,
filetime_string );
if( libfdatetime_filetime_free(
&filetime,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free filetime.",
function );
goto on_error;
}
libcnotify_printf(
"\n" );
}
#endif
value_data += sizeof( bde_metadata_entry_external_key_header_t );
value_data_size -= sizeof( bde_metadata_entry_external_key_header_t );
while( value_data_size >= sizeof( bde_metadata_entry_v1_t ) )
{
if( memory_compare(
value_data,
libbde_metadata_entry_empty,
sizeof( bde_metadata_entry_v1_t ) ) == 0 )
{
break;
}
if( libbde_metadata_entry_initialize(
&property_metadata_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create property metadata entry.",
function );
goto on_error;
}
read_count = libbde_metadata_entry_read(
property_metadata_entry,
value_data,
value_data_size,
error );
if( read_count == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read property metadata entry.",
function );
goto on_error;
}
value_data += read_count;
value_data_size -= read_count;
if( property_metadata_entry->value_type == LIBBDE_VALUE_TYPE_KEY )
{
if( libbde_key_initialize(
&key,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create key.",
function );
goto on_error;
}
if( libbde_key_read(
key,
property_metadata_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read key metadata entry.",
function );
goto on_error;
}
if( external_key->key == NULL )
{
external_key->key = key;
key = NULL;
}
if( key != NULL )
{
if( libbde_key_free(
&key,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free key.",
function );
goto on_error;
}
}
}
else if( property_metadata_entry->value_type == LIBBDE_VALUE_TYPE_UNICODE_STRING )
{
#if defined( HAVE_DEBUG_OUTPUT )
if( libbde_metadata_entry_read_string(
property_metadata_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read string from property metadata entry.",
function );
goto on_error;
}
#endif
if( external_key->string_entry == NULL )
{
external_key->string_entry = property_metadata_entry;
}
}
if( libcdata_array_append_entry(
external_key->entries_array,
&property_metadata_entry_index,
(intptr_t *) property_metadata_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to append property metadata entry to entries array.",
function );
goto on_error;
}
property_metadata_entry = NULL;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
if( value_data_size > 0 )
{
libcnotify_printf(
"%s: trailing data:\n",
function );
libcnotify_print_data(
value_data,
value_data_size,
LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
}
}
#endif
return( 1 );
on_error:
#if defined( HAVE_DEBUG_OUTPUT )
if( guid != NULL )
{
libfguid_identifier_free(
&guid,
NULL );
}
if( filetime != NULL )
{
libfdatetime_filetime_free(
&filetime,
NULL );
}
#endif
if( key != NULL )
{
libbde_key_free(
&key,
NULL );
}
if( property_metadata_entry != NULL )
{
libbde_metadata_entry_free(
&property_metadata_entry,
NULL );
}
return( -1 );
}
/* Reads the items into the items array
* Returns 1 if successful or -1 on error
*/
int libnk2_file_read_items(
libnk2_internal_file_t *internal_file,
libbfio_handle_t *file_io_handle,
uint32_t number_of_items,
libcerror_error_t **error )
{
uint8_t number_of_record_entries_data[ 4 ];
libnk2_item_t *item = NULL;
static char *function = "libnk2_file_read_items";
ssize_t read_count = 0;
uint32_t item_index = 0;
uint32_t number_of_record_entries = 0;
int entry_index = 0;
if( internal_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid internal file.",
function );
return( -1 );
}
if( libcdata_array_empty(
internal_file->items_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libnk2_internal_item_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to empty items array.",
function );
goto on_error;
}
for( item_index = 0;
item_index < number_of_items;
item_index++ )
{
read_count = libbfio_handle_read_buffer(
file_io_handle,
number_of_record_entries_data,
4,
error );
if( read_count != (ssize_t) 4 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read item: %" PRIu32 " number of record entries data.",
function,
item_index );
goto on_error;
}
byte_stream_copy_to_uint32_little_endian(
number_of_record_entries_data,
number_of_record_entries );
if( number_of_record_entries == 0 )
{
break;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: item: %03" PRIu32 " number of record entries\t\t: %" PRIu32 "\n",
function,
item_index,
number_of_record_entries );
libcnotify_printf(
"\n" );
}
#endif
if( libnk2_item_initialize(
&item,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create item.",
function );
goto on_error;
}
if( libnk2_item_read_record_entries(
(libnk2_internal_item_t *) item,
internal_file->io_handle,
file_io_handle,
item_index,
number_of_record_entries,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read record entries: %" PRIu32 ".",
function,
item_index );
goto on_error;
}
if( libcdata_array_append_entry(
internal_file->items_array,
&entry_index,
(intptr_t *) item,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append record entries to items array.",
function );
goto on_error;
}
item = NULL;
}
return( 1 );
on_error:
if( item != NULL )
{
libnk2_item_free(
&item,
NULL );
}
libcdata_array_empty(
internal_file->items_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libnk2_internal_item_free,
NULL );
return( -1 );
}
/* Reads the property set from the property set stream
* Returns 1 if successful or -1 on error
*/
int libolecf_property_set_read(
libolecf_property_set_t *property_set,
libolecf_io_handle_t *io_handle,
libolecf_item_t *property_set_stream,
libcerror_error_t **error )
{
olecf_property_set_header_t property_set_header;
libolecf_internal_property_set_t *internal_property_set = NULL;
libolecf_property_section_t *property_section = NULL;
static char *function = "libolecf_property_set_read";
off64_t section_list_entry_offset = 0;
ssize_t read_count = 0;
uint32_t section_header_offset = 0;
uint16_t number_of_sections = 0;
uint16_t section_index = 0;
int sections_entry = 0;
#if defined( HAVE_DEBUG_OUTPUT )
libcstring_system_character_t guid_string[ 48 ];
libfguid_identifier_t *guid = NULL;
int result = 0;
#endif
if( property_set == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid property set.",
function );
return( -1 );
}
internal_property_set = (libolecf_internal_property_set_t *) property_set;
if( libolecf_stream_seek_offset(
property_set_stream,
0,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek property set header offset: 0.",
function );
goto on_error;
}
read_count = libolecf_stream_read_buffer(
property_set_stream,
(uint8_t *) &property_set_header,
sizeof( olecf_property_set_header_t ),
error );
if( read_count != (ssize_t) sizeof( olecf_property_set_header_t ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read property set header.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: property set header:\n",
function );
libcnotify_print_data(
(uint8_t *) &property_set_header,
sizeof( olecf_property_set_header_t ),
0 );
}
#endif
if( ( property_set_header.byte_order[ 0 ] == 0xfe )
&& ( property_set_header.byte_order[ 1 ] == 0xff ) )
{
internal_property_set->byte_order = LIBOLECF_ENDIAN_LITTLE;
}
else if( ( property_set_header.byte_order[ 0 ] == 0xff )
&& ( property_set_header.byte_order[ 1 ] == 0xfe ) )
{
internal_property_set->byte_order = LIBOLECF_ENDIAN_BIG;
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported byte order: 0x%02" PRIx8 " 0x%02" PRIx8 ".",
function,
property_set_header.byte_order[ 0 ],
property_set_header.byte_order[ 1 ] );
goto on_error;
}
if( internal_property_set->byte_order == LIBOLECF_ENDIAN_LITTLE )
{
byte_stream_copy_to_uint16_little_endian(
property_set_header.format,
internal_property_set->format );
byte_stream_copy_to_uint32_little_endian(
property_set_header.system_version,
internal_property_set->system_version );
byte_stream_copy_to_uint16_little_endian(
property_set_header.number_of_sections,
number_of_sections );
}
else if( internal_property_set->byte_order == LIBOLECF_ENDIAN_BIG )
{
byte_stream_copy_to_uint16_big_endian(
property_set_header.format,
internal_property_set->format );
byte_stream_copy_to_uint32_big_endian(
property_set_header.system_version,
internal_property_set->system_version );
byte_stream_copy_to_uint16_big_endian(
property_set_header.number_of_sections,
number_of_sections );
}
if( memory_copy(
internal_property_set->class_identifier,
property_set_header.class_identifier,
16 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy class identifier.",
function );
goto on_error;
}
/* TODO make sure the class identifier is set in little endian */
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: property set header byte order\t\t: 0x%02" PRIx8 " 0x%02" PRIx8 "\n",
function,
property_set_header.byte_order[ 0 ],
property_set_header.byte_order[ 1 ] );
libcnotify_printf(
"%s: property set header format\t\t\t: %" PRIu16 "\n",
function,
internal_property_set->format );
libcnotify_printf(
"%s: property set header system version\t\t: 0x%08" PRIx32 "\n",
function,
internal_property_set->system_version );
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,
internal_property_set->class_identifier,
16,
internal_property_set->byte_order,
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( LIBCSTRING_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: property set header class identifier\t: %" PRIs_LIBCSTRING_SYSTEM " (%s : %s)\n",
function,
guid_string,
libfwps_format_class_identifier_get_identifier(
internal_property_set->class_identifier ),
libfwps_format_class_identifier_get_description(
internal_property_set->class_identifier ) );
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: property set header number of sections\t: %" PRIu16 "\n",
function,
number_of_sections );
libcnotify_printf(
"\n" );
}
#endif
section_list_entry_offset = sizeof( olecf_property_set_header_t );
for( section_index = 0;
section_index < (int) number_of_sections;
section_index++ )
{
if( libolecf_property_section_initialize(
&property_section,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create property section: %d.",
function,
section_index );
goto on_error;
}
if( libolecf_stream_seek_offset(
property_set_stream,
section_list_entry_offset,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek property section list entry: %d offset: %" PRIi64 ".",
function,
section_index,
section_list_entry_offset );
goto on_error;
}
if( libolecf_property_section_read_list_entry(
(libolecf_internal_property_section_t *) property_section,
property_set_stream,
internal_property_set->byte_order,
§ion_header_offset,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read property section list entry: %d.",
function,
section_index );
goto on_error;
}
if( libolecf_stream_get_offset(
property_set_stream,
§ion_list_entry_offset,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to retrieve property section list entry offset.",
function );
goto on_error;
}
if( libolecf_property_section_read(
(libolecf_internal_property_section_t *) property_section,
io_handle,
property_set_stream,
section_header_offset,
internal_property_set->byte_order,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read property section: %d at offset: %" PRIu32 ".",
function,
section_index,
section_header_offset );
goto on_error;
}
if( libcdata_array_append_entry(
internal_property_set->sections,
§ions_entry,
(intptr_t *) property_section,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append property section: %d to sections array.",
function,
section_index );
goto on_error;
}
property_section = NULL;
}
return( 1 );
on_error:
#if defined( HAVE_DEBUG_OUTPUT )
if( guid != NULL )
{
libfguid_identifier_free(
&guid,
NULL );
}
#endif
if( property_section != NULL )
{
libolecf_property_section_free(
&property_section,
NULL );
}
return( -1 );
}
/* Prepends a segment
* Returns 1 if successful or -1 on error
*/
int libfdata_segments_array_prepend_segment(
libcdata_array_t *segments_array,
libcdata_array_t *mapped_ranges_array,
size64_t *data_size,
int segment_file_index,
off64_t segment_offset,
size64_t segment_size,
uint32_t segment_flags,
libcerror_error_t **error )
{
libfdata_mapped_range_t *mapped_range = NULL;
libfdata_range_t *segment_data_range = NULL;
static char *function = "libfdata_segments_array_prepend_segment";
int mapped_range_index = -1;
if( data_size == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data size.",
function );
return( -1 );
}
if( segment_file_index < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid segment file index value out of bounds.",
function );
return( -1 );
}
if( segment_offset < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid segment offset value out of bounds.",
function );
return( -1 );
}
if( segment_size > (size64_t) INT64_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid segment size value out of bounds.",
function );
return( -1 );
}
if( libfdata_mapped_range_initialize(
&mapped_range,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create mapped range.",
function );
goto on_error;
}
if( libfdata_mapped_range_set(
mapped_range,
(off64_t) *data_size,
segment_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set mapped range values.",
function );
goto on_error;
}
if( libcdata_array_append_entry(
mapped_ranges_array,
&mapped_range_index,
(intptr_t *) mapped_range,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append mapped range to array.",
function );
goto on_error;
}
if( libfdata_range_initialize(
&segment_data_range,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create segment data range.",
function );
goto on_error;
}
if( libfdata_range_set(
segment_data_range,
segment_file_index,
segment_offset,
segment_size,
segment_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set segment data range values.",
function );
goto on_error;
}
if( libcdata_array_prepend_entry(
segments_array,
(intptr_t *) segment_data_range,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to prepend data range to segments array.",
function );
goto on_error;
}
*data_size += segment_size;
return( 1 );
on_error:
if( segment_data_range != NULL )
{
libfdata_range_free(
&segment_data_range,
NULL );
}
if( mapped_range_index != -1 )
{
libcdata_array_set_entry_by_index(
mapped_ranges_array,
mapped_range_index,
NULL,
NULL );
}
if( mapped_range != NULL )
{
libfdata_mapped_range_free(
&mapped_range,
NULL );
}
return( -1 );
}
