/* Creates a manifest
* Make sure the value manifest is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfwevt_manifest_initialize(
libfwevt_manifest_t **manifest,
libcerror_error_t **error )
{
libfwevt_internal_manifest_t *internal_manifest = NULL;
static char *function = "libfwevt_manifest_initialize";
if( manifest == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid manifest.",
function );
return( -1 );
}
if( *manifest != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid manifest value already set.",
function );
return( -1 );
}
internal_manifest = memory_allocate_structure(
libfwevt_internal_manifest_t );
if( internal_manifest == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create manifest.",
function );
goto on_error;
}
if( memory_set(
internal_manifest,
0,
sizeof( libfwevt_internal_manifest_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear manifest.",
function );
goto on_error;
}
*manifest = (libfwevt_manifest_t *) internal_manifest;
return( 1 );
on_error:
if( internal_manifest != NULL )
{
memory_free(
internal_manifest );
}
return( -1 );
}
/* Creates a wipekey handle
* Make sure the value wipekey_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int wipekey_handle_initialize(
wipekey_handle_t **wipekey_handle,
libcerror_error_t **error )
{
static char *function = "wipekey_handle_initialize";
if( wipekey_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid wipekey handle.",
function );
return( -1 );
}
if( *wipekey_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid wipekey handle value already set.",
function );
return( -1 );
}
*wipekey_handle = memory_allocate_structure(
wipekey_handle_t );
if( *wipekey_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create wipekey handle.",
function );
goto on_error;
}
if( memory_set(
*wipekey_handle,
0,
sizeof( wipekey_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear wipekey handle.",
function );
goto on_error;
}
if( libbfio_file_initialize(
&( ( *wipekey_handle )->input_file_io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input file IO handle.",
function );
goto on_error;
}
( *wipekey_handle )->notify_stream = INFO_HANDLE_NOTIFY_STREAM;
return( 1 );
on_error:
if( *wipekey_handle != NULL )
{
memory_free(
*wipekey_handle );
*wipekey_handle = NULL;
}
return( -1 );
}
/* Frees a handle
* Returns 1 if successful or -1 on error
*/
int libvsmbr_handle_free(
libvsmbr_handle_t **handle,
libcerror_error_t **error )
{
libvsmbr_internal_handle_t *internal_handle = NULL;
static char *function = "libvsmbr_handle_free";
int result = 1;
if( handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid handle.",
function );
return( -1 );
}
if( *handle != NULL )
{
internal_handle = (libvsmbr_internal_handle_t *) *handle;
if( internal_handle->file_io_handle != NULL )
{
if( libvsmbr_handle_close(
*handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close handle.",
function );
result = -1;
}
}
*handle = NULL;
if( libcdata_array_free(
&( internal_handle->partitions_array ),
(int (*)(intptr_t **, libcerror_error_t **)) &libvsmbr_partition_values_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free the partitions array.",
function );
result = -1;
}
if( libcdata_array_free(
&( internal_handle->sections_array ),
(int (*)(intptr_t **, libcerror_error_t **)) &libvsmbr_section_values_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free the sections array.",
function );
result = -1;
}
if( libvsmbr_io_handle_free(
&( internal_handle->io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free IO handle.",
function );
result = -1;
}
memory_free(
internal_handle );
}
return( result );
}
/* Reads an index node
* Returns 1 if successful or -1 on error
*/
int libpff_index_node_read(
libpff_index_node_t *index_node,
libpff_io_handle_t *io_handle,
libbfio_handle_t *file_io_handle,
off64_t node_offset,
libcerror_error_t **error )
{
uint8_t *index_node_footer_data = NULL;
static char *function = "libpff_index_node_read";
ssize_t read_count = 0;
uint32_t calculated_checksum = 0;
uint32_t stored_checksum = 0;
uint8_t calculated_entry_size = 0;
uint8_t calculated_maximum_number_of_entries = 0;
uint8_t index_node_type_copy = 0;
int result = 0;
#if defined( HAVE_DEBUG_OUTPUT )
uint8_t *index_node_entry_data = NULL;
uint64_t value_64bit = 0;
uint32_t value_32bit = 0;
uint16_t entry_index = 0;
uint16_t index_node_entry_data_size = 0;
uint16_t value_16bit = 0;
#endif
if( index_node == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid index node.",
function );
return( -1 );
}
if( index_node->data != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid index node - data already set.",
function );
return( -1 );
}
if( io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid IO handle.",
function );
return( -1 );
}
if( ( io_handle->file_type != LIBPFF_FILE_TYPE_32BIT )
&& ( io_handle->file_type != LIBPFF_FILE_TYPE_64BIT )
&& ( io_handle->file_type != LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported file type.",
function );
return( -1 );
}
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
index_node->data_size = 512;
index_node->maximum_entries_data_size = 512 - sizeof( pff_index_node_32bit_footer_t );
}
else if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
{
index_node->data_size = 512;
index_node->maximum_entries_data_size = 512 - sizeof( pff_index_node_64bit_footer_t );
}
else if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE )
{
index_node->data_size = 4096;
index_node->maximum_entries_data_size = 4096 - sizeof( pff_index_node_64bit_4k_page_footer_t );
}
index_node->data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * index_node->data_size );
if( index_node->data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create index node data.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: reading index node data at offset: %" PRIi64 " (0x%08" PRIx64 ")\n",
function,
node_offset,
node_offset );
}
#endif
if( libbfio_handle_seek_offset(
file_io_handle,
node_offset,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek node offset: %" PRIi64 ".",
function,
node_offset );
goto on_error;
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
index_node->data,
index_node->data_size,
error );
if( read_count != (ssize_t) index_node->data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read index node data.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: index node data:\n",
function );
libcnotify_print_data(
index_node->data,
index_node->data_size,
LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
}
#endif
index_node_footer_data = &( index_node->data[ index_node->maximum_entries_data_size ] );
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
index_node->type = ( (pff_index_node_32bit_footer_t *) index_node_footer_data )->type;
index_node_type_copy = ( (pff_index_node_32bit_footer_t *) index_node_footer_data )->type_copy;
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_32bit_footer_t *) index_node_footer_data )->back_pointer,
index_node->back_pointer );
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_32bit_footer_t *) index_node_footer_data )->checksum,
stored_checksum );
index_node->number_of_entries = ( (pff_index_node_32bit_footer_t *) index_node_footer_data )->number_of_entries;
index_node->maximum_number_of_entries = ( (pff_index_node_32bit_footer_t *) index_node_footer_data )->maximum_number_of_entries;
index_node->entry_size = ( (pff_index_node_32bit_footer_t *) index_node_footer_data )->entry_size;
index_node->level = ( (pff_index_node_32bit_footer_t *) index_node_footer_data )->level;
if( ( index_node->type == LIBPFF_INDEX_TYPE_DESCRIPTOR )
&& ( index_node->level == LIBPFF_INDEX_NODE_LEVEL_LEAF ) )
{
calculated_entry_size = 16;
calculated_maximum_number_of_entries = 496 / 16;
}
else
{
calculated_entry_size = 12;
calculated_maximum_number_of_entries = 496 / 12;
}
}
else if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
{
index_node->type = ( (pff_index_node_64bit_footer_t *) index_node_footer_data )->type;
index_node_type_copy = ( (pff_index_node_64bit_footer_t *) index_node_footer_data )->type_copy;
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_64bit_footer_t *) index_node_footer_data )->checksum,
stored_checksum );
byte_stream_copy_to_uint64_little_endian(
( (pff_index_node_64bit_footer_t *) index_node_footer_data )->back_pointer,
index_node->back_pointer );
index_node->number_of_entries = ( (pff_index_node_64bit_footer_t *) index_node_footer_data )->number_of_entries;
index_node->maximum_number_of_entries = ( (pff_index_node_64bit_footer_t *) index_node_footer_data )->maximum_number_of_entries;
index_node->entry_size = ( (pff_index_node_64bit_footer_t *) index_node_footer_data )->entry_size;
index_node->level = ( (pff_index_node_64bit_footer_t *) index_node_footer_data )->level;
if( ( index_node->type == LIBPFF_INDEX_TYPE_DESCRIPTOR )
&& ( index_node->level == LIBPFF_INDEX_NODE_LEVEL_LEAF ) )
{
calculated_entry_size = 32;
calculated_maximum_number_of_entries = 488 / 32;
}
else
{
calculated_entry_size = 24;
calculated_maximum_number_of_entries = 488 / 24;
}
}
else if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE )
{
index_node->type = ( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->type;
index_node_type_copy = ( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->type_copy;
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->checksum,
stored_checksum );
byte_stream_copy_to_uint64_little_endian(
( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->back_pointer,
index_node->back_pointer );
byte_stream_copy_to_uint16_little_endian(
( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->number_of_entries,
index_node->number_of_entries );
byte_stream_copy_to_uint16_little_endian(
( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->maximum_number_of_entries,
index_node->maximum_number_of_entries );
index_node->entry_size = ( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->entry_size;
index_node->level = ( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->level;
if( ( index_node->type == LIBPFF_INDEX_TYPE_DESCRIPTOR )
&& ( index_node->level == LIBPFF_INDEX_NODE_LEVEL_LEAF ) )
{
calculated_entry_size = 32;
calculated_maximum_number_of_entries = 4056 / 32;
}
else
{
calculated_entry_size = 24;
calculated_maximum_number_of_entries = 4056 / 24;
}
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: number of entries\t\t\t\t: %" PRIu16 "\n",
function,
index_node->number_of_entries );
libcnotify_printf(
"%s: maximum number of entries\t\t\t: %" PRIu16 "\n",
function,
index_node->maximum_number_of_entries );
libcnotify_printf(
"%s: entry size\t\t\t\t\t: %" PRIu8 "\n",
function,
index_node->entry_size );
libcnotify_printf(
"%s: node level\t\t\t\t\t: %" PRIu8 "\n",
function,
index_node->level );
if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
{
libcnotify_printf(
"%s: padding:\n",
function );
libcnotify_print_data(
( (pff_index_node_64bit_footer_t *) index_node_footer_data )->padding1,
4,
0 );
}
else if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE )
{
libcnotify_printf(
"%s: padding:\n",
function );
libcnotify_print_data(
( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->padding1,
10,
0 );
}
libcnotify_printf(
"%s: index node type\t\t\t\t\t: 0x%02" PRIx8 "\n",
function,
index_node->type );
libcnotify_printf(
"%s: index node type copy\t\t\t\t: 0x%02" PRIx8 "\n",
function,
index_node_type_copy );
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint16_little_endian(
( (pff_index_node_32bit_footer_t *) index_node_footer_data )->signature,
value_16bit );
libcnotify_printf(
"%s: signature\t\t\t\t\t: 0x%04" PRIx16 "\n",
function,
value_16bit );
libcnotify_printf(
"%s: back pointer\t\t\t\t\t: 0x%08" PRIx64 "\n",
function,
index_node->back_pointer );
libcnotify_printf(
"%s: checksum\t\t\t\t\t: 0x%08" PRIx32 "\n",
function,
stored_checksum );
}
else if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
{
byte_stream_copy_to_uint16_little_endian(
( (pff_index_node_64bit_footer_t *) index_node_footer_data )->signature,
value_16bit );
libcnotify_printf(
"%s: signature\t\t\t\t\t: 0x%04" PRIx16 "\n",
function,
value_16bit );
libcnotify_printf(
"%s: checksum\t\t\t\t\t: 0x%08" PRIx32 "\n",
function,
stored_checksum );
libcnotify_printf(
"%s: back pointer\t\t\t\t\t: 0x%08" PRIx64 "\n",
function,
index_node->back_pointer );
}
else if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE )
{
byte_stream_copy_to_uint16_little_endian(
( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->signature,
value_16bit );
libcnotify_printf(
"%s: signature\t\t\t\t\t: 0x%04" PRIx16 "\n",
function,
value_16bit );
libcnotify_printf(
"%s: checksum\t\t\t\t\t: 0x%08" PRIx32 "\n",
function,
stored_checksum );
libcnotify_printf(
"%s: back pointer\t\t\t\t\t: 0x%08" PRIx64 "\n",
function,
index_node->back_pointer );
byte_stream_copy_to_uint64_little_endian(
( (pff_index_node_64bit_4k_page_footer_t *) index_node_footer_data )->unknown1,
value_64bit );
libcnotify_printf(
"%s: unknown1\t\t\t\t\t: 0x%08" PRIx64 "\n",
function,
value_64bit );
}
libcnotify_printf(
"\n" );
}
#endif
if( index_node->type != index_node_type_copy )
{
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: mismatch in index node type (0x%02" PRIx8 " != 0x%02" PRIx8 ").\n",
function,
index_node->type,
index_node_type_copy );
}
#endif
if( ( index_node->type != LIBPFF_INDEX_TYPE_DESCRIPTOR )
&& ( index_node->type != LIBPFF_INDEX_TYPE_OFFSET )
&& ( ( index_node_type_copy == LIBPFF_INDEX_TYPE_DESCRIPTOR )
|| ( index_node_type_copy == LIBPFF_INDEX_TYPE_OFFSET ) ) )
{
index_node->type = index_node_type_copy;
}
}
if( ( index_node->type != LIBPFF_INDEX_TYPE_DESCRIPTOR )
&& ( index_node->type != LIBPFF_INDEX_TYPE_OFFSET ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported index node type: 0x%02" PRIx8 ".",
function,
index_node->type );
goto on_error;
}
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
result = libfmapi_checksum_calculate_weak_crc32(
&calculated_checksum,
index_node->data,
500,
0,
error );
}
else if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
{
result = libfmapi_checksum_calculate_weak_crc32(
&calculated_checksum,
index_node->data,
496,
0,
error );
}
else if( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE )
{
result = libfmapi_checksum_calculate_weak_crc32(
&calculated_checksum,
index_node->data,
4072,
0,
error );
}
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to calculate weak CRC-32.",
function );
goto on_error;
}
if( stored_checksum != calculated_checksum )
{
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: mismatch in checksum ( 0x%08" PRIx32 " != 0x%08" PRIx32 " ).\n",
function,
stored_checksum,
calculated_checksum );
}
#endif
/* TODO smart error handling */
}
if( ( index_node->entry_size != 0 )
&& ( index_node->entry_size != calculated_entry_size ) )
{
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: entry size mismatch (calculated: %" PRIu8 ", stored: %" PRIu8 ").\n",
function,
calculated_entry_size,
index_node->entry_size );
}
#endif
index_node->entry_size = calculated_entry_size;
}
if( ( index_node->maximum_number_of_entries != 0 )
&& ( index_node->maximum_number_of_entries != calculated_maximum_number_of_entries ) )
{
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: maximum number of entries mismatch (calculated: %" PRIu8 ", stored: %" PRIu8 ").\n",
function,
calculated_maximum_number_of_entries,
index_node->maximum_number_of_entries );
}
#endif
index_node->maximum_number_of_entries = calculated_maximum_number_of_entries;
}
if( index_node->number_of_entries > index_node->maximum_number_of_entries )
{
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: number of entries: %" PRIu8 ", exceeds maximum: %" PRIu8 ".",
function,
index_node->number_of_entries,
index_node->maximum_number_of_entries );
}
#endif
index_node->number_of_entries = index_node->maximum_number_of_entries;
}
if( ( (uint16_t) index_node->number_of_entries * (uint16_t) index_node->entry_size ) > index_node->maximum_entries_data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: size of entries: %" PRIu16 ", exceeds maximum: %" PRIu16 ".",
function,
index_node->number_of_entries * index_node->entry_size,
index_node->maximum_entries_data_size );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
index_node_entry_data = index_node->data;
index_node_entry_data_size = index_node->maximum_entries_data_size;
/* Print all the entries
*/
for( entry_index = 0;
entry_index < index_node->maximum_number_of_entries;
entry_index++ )
{
if( entry_index == index_node->number_of_entries )
{
result = libpff_index_node_check_for_empty_block(
index_node_entry_data,
index_node_entry_data_size,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if remaining index nodes are empty.",
function );
return( -1 );
}
else if( result != 0 )
{
break;
}
libcnotify_printf(
"\n" );
libcnotify_printf(
"%s: remaining node entries\n",
function );
}
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint32_little_endian(
index_node_entry_data,
value_64bit );
}
else if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint64_little_endian(
index_node_entry_data,
value_64bit );
}
libcnotify_printf(
"%s: entry: %03" PRIu16 " index node identifier\t\t: 0x%08" PRIx64 " (%" PRIu64 ")\n",
function,
entry_index,
value_64bit,
value_64bit );
/* Process descriptor index node leaf nodes
*/
if( ( index_node->type == LIBPFF_INDEX_TYPE_DESCRIPTOR )
&& ( index_node->level == LIBPFF_INDEX_NODE_LEVEL_LEAF ) )
{
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_descriptor_entry_32bit_t *) index_node_entry_data )->data_identifier,
value_64bit );
}
else if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint64_little_endian(
( (pff_index_node_descriptor_entry_64bit_t *) index_node_entry_data )->data_identifier,
value_64bit );
}
libcnotify_printf(
"%s: entry: %03" PRIu16 " data identifier\t\t\t: 0x%08" PRIx64 " (%" PRIu64 ")\n",
function,
entry_index,
value_64bit,
value_64bit );
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_descriptor_entry_32bit_t *) index_node_entry_data )->local_descriptors_identifier,
value_64bit );
}
else if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint64_little_endian(
( (pff_index_node_descriptor_entry_64bit_t *) index_node_entry_data )->local_descriptors_identifier,
value_64bit );
}
libcnotify_printf(
"%s: entry: %03" PRIu16 " local descriptors identifier\t\t: 0x%08" PRIx64 " (%" PRIu64 ")\n",
function,
entry_index,
value_64bit,
value_64bit );
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_descriptor_entry_32bit_t *) index_node_entry_data )->parent_identifier,
value_32bit );
}
else if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_descriptor_entry_64bit_t *) index_node_entry_data )->parent_identifier,
value_32bit );
}
libcnotify_printf(
"%s: entry: %03" PRIu16 " parent identifier\t\t\t: 0x%08" PRIx32 " (%" PRIu32 ")\n",
function,
entry_index,
value_32bit,
value_32bit );
if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_descriptor_entry_64bit_t *) index_node_entry_data )->unknown1,
value_32bit );
libcnotify_printf(
"%s: entry: %03" PRIu16 " unknown1\t\t\t\t: 0x%08" PRIx32 " (%" PRIu32 ")\n",
function,
entry_index,
value_32bit,
value_32bit );
}
}
/* Process offset and descriptor index node branch nodes and offset index node leaf nodes
*/
else
{
if( index_node->level != LIBPFF_INDEX_NODE_LEVEL_LEAF )
{
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_branch_entry_32bit_t *) index_node_entry_data )->back_pointer,
value_64bit );
}
else if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint64_little_endian(
( (pff_index_node_branch_entry_64bit_t *) index_node_entry_data )->back_pointer,
value_64bit );
}
libcnotify_printf(
"%s: entry: %03" PRIu16 " back pointer\t\t\t\t: 0x%08" PRIx64 "\n",
function,
entry_index,
value_64bit );
}
if( index_node->level == LIBPFF_INDEX_NODE_LEVEL_LEAF )
{
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_offset_entry_32bit_t *) index_node_entry_data )->file_offset,
value_64bit );
}
else if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint64_little_endian(
( (pff_index_node_offset_entry_64bit_t *) index_node_entry_data )->file_offset,
value_64bit );
}
}
else
{
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_branch_entry_32bit_t *) index_node_entry_data )->file_offset,
value_64bit );
}
else if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint64_little_endian(
( (pff_index_node_branch_entry_64bit_t *) index_node_entry_data )->file_offset,
value_64bit );
}
}
libcnotify_printf(
"%s: entry: %03" PRIu16 " file offset\t\t\t\t: 0x%08" PRIx64 " (%" PRIu64 ")\n",
function,
entry_index,
value_64bit,
value_64bit );
if( index_node->level == LIBPFF_INDEX_NODE_LEVEL_LEAF )
{
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint16_little_endian(
( (pff_index_node_offset_entry_32bit_t *) index_node_entry_data )->data_size,
value_16bit );
}
else if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint16_little_endian(
( (pff_index_node_offset_entry_64bit_t *) index_node_entry_data )->data_size,
value_16bit );
}
libcnotify_printf(
"%s: entry: %03" PRIu16 " data size\t\t\t\t: %" PRIu16 "\n",
function,
entry_index,
value_16bit );
if( io_handle->file_type == LIBPFF_FILE_TYPE_32BIT )
{
byte_stream_copy_to_uint16_little_endian(
( (pff_index_node_offset_entry_32bit_t *) index_node_entry_data )->reference_count,
value_16bit );
}
else if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint16_little_endian(
( (pff_index_node_offset_entry_64bit_t *) index_node_entry_data )->reference_count,
value_16bit );
}
libcnotify_printf(
"%s: entry: %03" PRIu16 " reference count\t\t\t: %" PRIu16 "\n",
function,
entry_index,
value_16bit );
if( ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT )
|| ( io_handle->file_type == LIBPFF_FILE_TYPE_64BIT_4K_PAGE ) )
{
byte_stream_copy_to_uint32_little_endian(
( (pff_index_node_offset_entry_64bit_t *) index_node_entry_data )->data_allocation_table_file_offset,
value_32bit );
libcnotify_printf(
"%s: entry: %03" PRIu16 " data allocation table offset\t\t: 0x%08" PRIx32 " (%" PRIu32 ")\n",
function,
entry_index,
value_32bit,
value_32bit );
}
}
}
index_node_entry_data += index_node->entry_size;
index_node_entry_data_size -= index_node->entry_size;
}
libcnotify_printf(
"\n" );
}
#endif
index_node->entries_data = index_node->data;
return( 1 );
on_error:
if( index_node->data != NULL )
{
memory_free(
index_node->data );
index_node->data = NULL;
}
return( -1 );
}
/* Creates volume name values
* Make sure the value volume_name_values is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfsntfs_volume_name_values_initialize(
libfsntfs_volume_name_values_t **volume_name_values,
libcerror_error_t **error )
{
static char *function = "libfsntfs_volume_name_values_initialize";
if( volume_name_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid volume name values.",
function );
return( -1 );
}
if( *volume_name_values != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid volume name values value already set.",
function );
return( -1 );
}
*volume_name_values = memory_allocate_structure(
libfsntfs_volume_name_values_t );
if( *volume_name_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create volume name values.",
function );
goto on_error;
}
if( memory_set(
*volume_name_values,
0,
sizeof( libfsntfs_volume_name_values_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear volume name values.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *volume_name_values != NULL )
{
memory_free(
*volume_name_values );
*volume_name_values = NULL;
}
return( -1 );
}
/* Creates an allocation table
* Make sure the value allocation_table is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libolecf_allocation_table_initialize(
libolecf_allocation_table_t **allocation_table,
int number_of_sector_identifiers,
libcerror_error_t **error )
{
static char *function = "libolecf_allocation_table_initialize";
size_t sector_identifiers_size = 0;
if( allocation_table == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid allocation table.",
function );
return( -1 );
}
if( *allocation_table != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid allocation table value already set.",
function );
return( -1 );
}
if( number_of_sector_identifiers < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid number of sector identifiers value less than zero.",
function );
return( -1 );
}
if( (size_t) number_of_sector_identifiers > (size_t) ( SSIZE_MAX / sizeof( uint32_t ) ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid number of sector identifers value exceeds maximum.",
function );
goto on_error;
}
*allocation_table = memory_allocate_structure(
libolecf_allocation_table_t );
if( *allocation_table == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create allocation table.",
function );
goto on_error;
}
if( memory_set(
*allocation_table,
0,
sizeof( libolecf_allocation_table_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear allocation table.",
function );
memory_free(
*allocation_table );
*allocation_table = NULL;
return( -1 );
}
if( number_of_sector_identifiers > 0 )
{
sector_identifiers_size = number_of_sector_identifiers * sizeof( uint32_t );
if( sector_identifiers_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid sector identifiers size value exceeds maximum.",
function );
goto on_error;
}
( *allocation_table )->sector_identifier = (uint32_t *) memory_allocate(
sector_identifiers_size );
if( ( *allocation_table )->sector_identifier == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create sector identifiers.",
function );
goto on_error;
}
if( memory_set(
( *allocation_table )->sector_identifier,
0,
sector_identifiers_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear sector identifiers.",
function );
goto on_error;
}
( *allocation_table )->number_of_sector_identifiers = number_of_sector_identifiers;
}
return( 1 );
on_error:
if( *allocation_table != NULL )
{
if( ( *allocation_table )->sector_identifier != NULL )
{
memory_free(
( *allocation_table )->sector_identifier );
}
memory_free(
*allocation_table );
*allocation_table = NULL;
}
return( -1 );
}
/* Creates a record
* Make sure the value record is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libftxf_record_initialize(
libftxf_record_t **record,
libcerror_error_t **error )
{
libftxf_internal_record_t *internal_record = NULL;
static char *function = "libftxf_record_initialize";
if( record == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid record.",
function );
return( -1 );
}
if( *record != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid record value already set.",
function );
return( -1 );
}
internal_record = memory_allocate_structure(
libftxf_internal_record_t );
if( internal_record == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create record.",
function );
goto on_error;
}
if( memory_set(
internal_record,
0,
sizeof( libftxf_internal_record_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear record.",
function );
goto on_error;
}
*record = (libftxf_record_t *) internal_record;
return( 1 );
on_error:
if( internal_record != NULL )
{
memory_free(
internal_record );
}
return( -1 );
}
/* Creates a data stream
* Make sure the value data_stream is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfsntfs_data_stream_initialize(
libfsntfs_data_stream_t **data_stream,
libbfio_handle_t *file_io_handle,
libfsntfs_io_handle_t *io_handle,
libfsntfs_attribute_t *data_attribute,
libcerror_error_t **error )
{
libfsntfs_internal_data_stream_t *internal_data_stream = NULL;
static char *function = "libfsntfs_data_stream_initialize";
int number_of_data_runs = 0;
if( data_stream == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data stream.",
function );
return( -1 );
}
if( *data_stream != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid data stream value already set.",
function );
return( -1 );
}
if( data_attribute == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data attribute.",
function );
return( -1 );
}
internal_data_stream = memory_allocate_structure(
libfsntfs_internal_data_stream_t );
if( internal_data_stream == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create data stream.",
function );
return( -1 );
}
if( memory_set(
internal_data_stream,
0,
sizeof( libfsntfs_internal_data_stream_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear data stream.",
function );
memory_free(
internal_data_stream );
return( -1 );
}
if( libfsntfs_attribute_get_number_of_data_runs(
data_attribute,
&number_of_data_runs,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of data runs.",
function );
goto on_error;
}
if( libfsntfs_cluster_block_stream_initialize(
&( internal_data_stream->data_cluster_block_stream ),
io_handle,
data_attribute,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create data cluster block stream.",
function );
goto on_error;
}
if( libfsntfs_attribute_get_data_size(
data_attribute,
&( internal_data_stream->data_size ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve data attribute data size.",
function );
return( -1 );
}
internal_data_stream->file_io_handle = file_io_handle;
internal_data_stream->data_attribute = data_attribute;
*data_stream = (libfsntfs_data_stream_t *) internal_data_stream;
return( 1 );
on_error:
if( internal_data_stream != NULL )
{
memory_free(
internal_data_stream );
}
return( -1 );
}
/* Globs the segment files according to the EWF naming schema
* if format is known the filename should contain the base of the filename
* otherwise the function will try to determine the format based on the extension
* Returns 1 if successful or -1 on error
*/
int libewf_glob_wide(
const wchar_t *filename,
size_t filename_length,
uint8_t format,
wchar_t **filenames[],
int *number_of_filenames,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
wchar_t *segment_filename = NULL;
void *reallocation = NULL;
static char *function = "libewf_glob_wide";
size_t additional_length = 4;
size_t segment_filename_length = 0;
int result = 0;
uint8_t segment_file_type = 0;
uint8_t ewf_format = 0;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
if( ( filename_length == 0 )
|| ( filename_length > (size_t) SSIZE_MAX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid filename length.",
function );
return( -1 );
}
if( ( format != LIBEWF_FORMAT_UNKNOWN )
&& ( format != LIBEWF_FORMAT_ENCASE1 )
&& ( format != LIBEWF_FORMAT_ENCASE2 )
&& ( format != LIBEWF_FORMAT_ENCASE3 )
&& ( format != LIBEWF_FORMAT_ENCASE4 )
&& ( format != LIBEWF_FORMAT_ENCASE5 )
&& ( format != LIBEWF_FORMAT_ENCASE6 )
&& ( format != LIBEWF_FORMAT_LINEN5 )
&& ( format != LIBEWF_FORMAT_LINEN6 )
&& ( format != LIBEWF_FORMAT_SMART )
&& ( format != LIBEWF_FORMAT_FTK )
&& ( format != LIBEWF_FORMAT_LVF )
&& ( format != LIBEWF_FORMAT_EWF )
&& ( format != LIBEWF_FORMAT_EWFX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported format.",
function );
return( -1 );
}
if( filenames == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filenames.",
function );
return( -1 );
}
if( number_of_filenames == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid number of filenames.",
function );
return( -1 );
}
if( format == LIBEWF_FORMAT_UNKNOWN )
{
if( filename[ filename_length - 4 ] != (wchar_t) '.' )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - missing extension.",
function );
return( -1 );
}
additional_length = 0;
if( filename[ filename_length - 3 ] == (wchar_t) 'E' )
{
format = LIBEWF_FORMAT_ENCASE5;
}
else if( filename[ filename_length - 3 ] == (wchar_t) 'e' )
{
format = LIBEWF_FORMAT_EWF;
}
else if( filename[ filename_length - 3 ] == (wchar_t) 'L' )
{
format = LIBEWF_FORMAT_LVF;
}
else if( filename[ filename_length - 3 ] == (wchar_t) 's' )
{
format = LIBEWF_FORMAT_SMART;
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - unsupported extension: %s.",
function,
&( filename[ filename_length - 4 ] ) );
return( -1 );
}
}
if( format == LIBEWF_FORMAT_LVF )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_LWF;
ewf_format = EWF_FORMAT_L01;
}
else if( format == LIBEWF_FORMAT_SMART )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF;
ewf_format = EWF_FORMAT_S01;
}
else
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF;
ewf_format = EWF_FORMAT_E01;
}
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle.",
function );
goto on_error;
}
*number_of_filenames = 0;
while( *number_of_filenames < (int) UINT16_MAX )
{
segment_filename_length = filename_length + additional_length;
segment_filename = (wchar_t *) memory_allocate(
sizeof( wchar_t ) * ( segment_filename_length + 1 ) );
if( segment_filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create segment filename.",
function );
goto on_error;
}
if( libcstring_wide_string_copy(
segment_filename,
filename,
filename_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy filename.",
function );
goto on_error;
}
if( additional_length > 0 )
{
segment_filename[ filename_length ] = (wchar_t) '.';
}
if( libewf_filename_set_extension_wide(
&( segment_filename[ segment_filename_length - 3 ] ),
(uint16_t) ( *number_of_filenames + 1 ),
UINT16_MAX,
segment_file_type,
format,
ewf_format,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set extension.",
function );
goto on_error;
}
segment_filename[ segment_filename_length ] = 0;
if( libbfio_file_set_name_wide(
file_io_handle,
segment_filename,
segment_filename_length,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set name in file IO handle.",
function );
goto on_error;
}
result = libbfio_handle_exists(
file_io_handle,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_GENERIC,
"%s: unable to test if file exists.",
function );
goto on_error;
}
else if( result == 0 )
{
memory_free(
segment_filename );
break;
}
*number_of_filenames += 1;
reallocation = memory_reallocate(
*filenames,
sizeof( wchar_t * ) * *number_of_filenames );
if( reallocation == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize filenames.",
function );
goto on_error;
}
*filenames = (wchar_t **) reallocation;
( *filenames )[ *number_of_filenames - 1 ] = segment_filename;
}
if( libbfio_handle_free(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free file IO handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( segment_filename != NULL )
{
memory_free(
segment_filename );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
/* Frees a condition
* Returns 1 if successful or -1 on error
*/
int libcthreads_condition_free(
libcthreads_condition_t **condition,
libcerror_error_t **error )
{
libcthreads_internal_condition_t *internal_condition = NULL;
static char *function = "libcthreads_condition_free";
int result = 1;
#if defined( WINAPI ) && ( WINVER < 0x0600 )
DWORD error_code = 0;
#elif defined( HAVE_PTHREAD_H ) && !defined( WINAPI )
int pthread_result = 0;
#endif
if( condition == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid condition.",
function );
return( -1 );
}
if( *condition != NULL )
{
internal_condition = (libcthreads_internal_condition_t *) *condition;
*condition = NULL;
#if defined( WINAPI ) && ( WINVER >= 0x0600 )
#elif defined( WINAPI )
if( CloseHandle(
internal_condition->signal_event_handle ) == 0 )
{
error_code = GetLastError();
libcerror_system_set_error(
error,
error_code,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free signal event handle.",
function );
result = -1;
}
if( CloseHandle(
internal_condition->signal_semaphore_handle ) == 0 )
{
error_code = GetLastError();
libcerror_system_set_error(
error,
error_code,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free signal semaphore handle.",
function );
result = -1;
}
DeleteCriticalSection(
&( internal_condition->wait_critical_section ) );
#elif defined( HAVE_PTHREAD_H )
pthread_result = pthread_cond_destroy(
&( internal_condition->condition ) );
if( pthread_result != 0 )
{
switch( pthread_result )
{
case EBUSY:
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to destroy condition with error: Resource busy.",
function );
break;
default:
libcerror_system_set_error(
error,
pthread_result,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to destroy condition.",
function );
break;
}
result = -1;
}
#endif
memory_free(
internal_condition );
}
return( result );
}
/* Creates a condition
* Make sure the value condition is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libcthreads_condition_initialize(
libcthreads_condition_t **condition,
libcerror_error_t **error )
{
libcthreads_internal_condition_t *internal_condition = NULL;
static char *function = "libcthreads_condition_initialize";
#if defined( WINAPI ) && ( WINVER < 0x0600 )
DWORD error_code = 0;
#elif defined( HAVE_PTHREAD_H ) && !defined( WINAPI )
int pthread_result = 0;
#endif
if( condition == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid condition.",
function );
return( -1 );
}
if( *condition != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid condition value already set.",
function );
return( -1 );
}
internal_condition = memory_allocate_structure(
libcthreads_internal_condition_t );
if( internal_condition == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create condition.",
function );
goto on_error;
}
if( memory_set(
internal_condition,
0,
sizeof( libcthreads_internal_condition_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear condition.",
function );
goto on_error;
}
#if defined( WINAPI ) && ( WINVER >= 0x0600 )
InitializeConditionVariable(
&( internal_condition->condition_variable ) );
#elif defined( WINAPI )
InitializeCriticalSection(
&( internal_condition->wait_critical_section ) );
internal_condition->signal_semaphore_handle = CreateSemaphore (
NULL,
0,
INT_MAX,
NULL );
if( internal_condition->signal_semaphore_handle == NULL )
{
error_code = GetLastError();
libcerror_system_set_error(
error,
error_code,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize signal semaphore handle.",
function );
goto on_error;
}
internal_condition->signal_event_handle = CreateEvent (
NULL,
FALSE,
FALSE,
NULL );
if( internal_condition->signal_event_handle == NULL )
{
error_code = GetLastError();
libcerror_system_set_error(
error,
error_code,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize signal event handle.",
function );
goto on_error;
}
#elif defined( HAVE_PTHREAD_H )
pthread_result = pthread_cond_init(
&( internal_condition->condition ),
NULL );
if( pthread_result != 0 )
{
libcerror_system_set_error(
error,
pthread_result,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize condition.",
function );
goto on_error;
}
#endif
*condition = (libcthreads_condition_t *) internal_condition;
return( 1 );
on_error:
if( internal_condition != NULL )
{
#if defined( WINAPI ) && ( WINVER < 0x0600 )
if( internal_condition->signal_semaphore_handle != NULL )
{
CloseHandle(
internal_condition->signal_semaphore_handle );
}
DeleteCriticalSection(
&( internal_condition->wait_critical_section ) );
#endif
memory_free(
internal_condition );
}
return( -1 );
}
/* Initialize the segment file handle
* Returns 1 if successful or -1 on error
*/
int libewf_segment_file_handle_initialize(
libewf_segment_file_handle_t **segment_file_handle,
int segment_file_index,
liberror_error_t **error )
{
static char *function = "libewf_segment_file_handle_initialize";
if( segment_file_handle == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment file handle.",
function );
return( -1 );
}
if( segment_file_index < 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid segment file index value less than zero.",
function );
return( -1 );
}
if( *segment_file_handle == NULL )
{
*segment_file_handle = memory_allocate_structure(
libewf_segment_file_handle_t );
if( *segment_file_handle == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create segment file handle.",
function );
goto on_error;
}
if( memory_set(
*segment_file_handle,
0,
sizeof( libewf_segment_file_handle_t ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear segment file handle.",
function );
goto on_error;
}
( *segment_file_handle )->segment_file_index = segment_file_index;
}
return( 1 );
on_error:
if( *segment_file_handle != NULL )
{
memory_free(
*segment_file_handle );
*segment_file_handle = NULL;
}
return( -1 );
}
/* Clones the segment file handle
* Returns 1 if successful or -1 on error
*/
int libewf_segment_file_handle_clone(
intptr_t **destination_segment_file_handle,
intptr_t *source_segment_file_handle,
liberror_error_t **error )
{
static char *function = "libewf_segment_file_handle_clone";
if( destination_segment_file_handle == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid destination segment file handle.",
function );
return( -1 );
}
if( *destination_segment_file_handle != NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid destination segment file handle value already set.",
function );
return( -1 );
}
if( source_segment_file_handle == NULL )
{
*destination_segment_file_handle = NULL;
return( 1 );
}
*destination_segment_file_handle = memory_allocate_structure_as_value(
libewf_segment_file_handle_t );
if( *destination_segment_file_handle == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create destination segment file handle.",
function );
goto on_error;
}
if( memory_copy(
*destination_segment_file_handle,
source_segment_file_handle,
sizeof( libewf_segment_file_handle_t ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy source to destination segment file handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *destination_segment_file_handle != NULL )
{
memory_free(
*destination_segment_file_handle );
*destination_segment_file_handle = NULL;
}
return( -1 );
}
/* Resolves filenames with wildcards (globs)
* Returns the number of results if successful or -1 on error
*/
int libsystem_glob_resolve(
libsystem_glob_t *glob,
libcstring_system_character_t * const patterns[],
int number_of_patterns,
liberror_error_t **error )
{
#if defined( HAVE_IO_H ) || defined( WINAPI )
libsystem_find_data_t find_data;
libcstring_system_character_t find_path[ _MAX_PATH ];
libcstring_system_character_t find_drive[ _MAX_DRIVE ];
libcstring_system_character_t find_directory[ _MAX_DIR ];
libcstring_system_character_t find_name[ _MAX_FNAME ];
libcstring_system_character_t find_extension[ _MAX_EXT ];
intptr_t find_handle = 0;
#endif
static char *function = "libsystem_glob_resolve";
size_t find_path_length = 0;
int globs_found = 0;
int iterator = 0;
if( glob == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid glob.",
function );
return( -1 );
}
for( iterator = 0;
iterator < number_of_patterns;
iterator++ )
{
if( patterns[ iterator ] == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: missing pattern value.",
function );
return( -1 );
}
#if defined( _MSC_VER )
if( libsystem_path_split(
patterns[ iterator ],
find_drive,
_MAX_DRIVE,
find_directory,
_MAX_DIR,
find_name,
_MAX_FNAME,
find_extension,
_MAX_EXT ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to split path.",
function );
return( -1 );
}
#else
libsystem_path_split(
patterns[ iterator ],
find_drive,
_MAX_DRIVE,
find_directory,
_MAX_DIR,
find_name,
_MAX_FNAME,
find_extension,
_MAX_EXT );
#endif
find_handle = libsystem_find_first(
patterns[ iterator ],
&find_data );
if( find_handle != -1 )
{
do
{
if( libsystem_glob_resize(
glob,
glob->number_of_results + 1,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize glob.",
function );
return( -1 );
}
#if defined( _MSC_VER )
if( libsystem_path_make(
find_path,
_MAX_PATH,
find_drive,
find_directory,
find_data.name,
_LIBCSTRING_SYSTEM_STRING( "" ) ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to make path.",
function );
return( -1 );
}
#elif defined( __BORLANDC__ ) && __BORLANDC__ <= 0x0520
libsystem_path_make(
find_path,
_MAX_PATH,
find_drive,
find_directory,
find_data.ff_name,
_LIBCSTRING_SYSTEM_STRING( "" ) );
#else
libsystem_path_make(
find_path,
_MAX_PATH,
find_drive,
find_directory,
find_data.name,
_LIBCSTRING_SYSTEM_STRING( "" ) );
#endif
find_path_length = libcstring_system_string_length(
find_path );
glob->result[ glob->number_of_results - 1 ] = (libcstring_system_character_t *) memory_allocate(
sizeof( libcstring_system_character_t ) * ( find_path_length + 1 ) );
if( glob->result[ glob->number_of_results - 1 ] == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create glob result.",
function );
return( -1 );
}
if( libcstring_system_string_copy(
glob->result[ glob->number_of_results - 1 ],
find_path,
find_path_length ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set glob result.",
function );
memory_free(
glob->result[ glob->number_of_results - 1 ] );
glob->result[ glob->number_of_results - 1 ] = NULL;
return( -1 );
}
( glob->result[ glob->number_of_results - 1 ] )[ find_path_length ] = 0;
globs_found++;
if( globs_found > (int32_t) UINT16_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: too many globs found.",
function );
return( -1 );
}
}
while( libsystem_find_next(
find_handle,
&find_data ) == 0 );
if( errno != ENOENT )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: error finding next file entry.",
function );
return( -1 );
}
if( libsystem_find_close(
find_handle ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: error closing find handle.",
function );
return( -1 );
}
}
else if( errno != ENOENT )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: error finding file entry.",
function );
return( -1 );
}
}
return( 1 );
}
/* Creates an index
* Make sure the value index is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libesedb_index_initialize(
libesedb_index_t **index,
libbfio_handle_t *file_io_handle,
libesedb_io_handle_t *io_handle,
libesedb_table_definition_t *table_definition,
libesedb_table_definition_t *template_table_definition,
libesedb_catalog_definition_t *index_catalog_definition,
libfdata_vector_t *pages_vector,
libfcache_cache_t *pages_cache,
libfdata_vector_t *long_values_pages_vector,
libfcache_cache_t *long_values_pages_cache,
libfdata_btree_t *table_values_tree,
libfcache_cache_t *table_values_cache,
libfdata_btree_t *long_values_tree,
libfcache_cache_t *long_values_cache,
libcerror_error_t **error )
{
libesedb_internal_index_t *internal_index = NULL;
libesedb_page_tree_t *index_page_tree = NULL;
static char *function = "libesedb_index_initialize";
off64_t node_data_offset = 0;
if( index == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid index.",
function );
return( -1 );
}
if( *index != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid index value already set.",
function );
return( -1 );
}
if( table_definition == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid table definition.",
function );
return( -1 );
}
if( index_catalog_definition == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid index catalog definition.",
function );
return( -1 );
}
internal_index = memory_allocate_structure(
libesedb_internal_index_t );
if( internal_index == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create index.",
function );
goto on_error;
}
if( memory_set(
internal_index,
0,
sizeof( libesedb_internal_index_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear index.",
function );
memory_free(
internal_index );
return( -1 );
}
/* TODO (template) table definition required ? */
if( libesedb_page_tree_initialize(
&index_page_tree,
io_handle,
pages_vector,
pages_cache,
index_catalog_definition->identifier,
NULL,
NULL,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create index page tree.",
function );
goto on_error;
}
/* TODO clone function
*/
if( libfdata_btree_initialize(
&( internal_index->index_values_tree ),
(intptr_t *) index_page_tree,
(int (*)(intptr_t **, libcerror_error_t **)) &libesedb_page_tree_free,
NULL,
(int (*)(intptr_t *, intptr_t *, libfdata_btree_node_t *, int, off64_t, size64_t, uint32_t, intptr_t *, uint8_t, libcerror_error_t **)) &libesedb_page_tree_read_node,
(int (*)(intptr_t *, intptr_t *, libfdata_btree_t *, libfcache_cache_t *, int, int, off64_t, size64_t, uint32_t, intptr_t *, uint8_t, libcerror_error_t **)) &libesedb_page_tree_read_leaf_value,
LIBFDATA_DATA_HANDLE_FLAG_MANAGED,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create index values tree.",
function );
libesedb_page_tree_free(
&index_page_tree,
NULL );
goto on_error;
}
if( libfcache_cache_initialize(
&( internal_index->index_values_cache ),
LIBESEDB_MAXIMUM_CACHE_ENTRIES_INDEX_VALUES,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create index values cache.",
function );
goto on_error;
}
node_data_offset = index_catalog_definition->father_data_page_number - 1;
node_data_offset *= io_handle->page_size;
if( libfdata_btree_set_root_node(
internal_index->index_values_tree,
0,
node_data_offset,
0,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set root node in index values tree.",
function );
goto on_error;
}
internal_index->io_handle = io_handle;
internal_index->file_io_handle = file_io_handle;
internal_index->table_definition = table_definition;
internal_index->template_table_definition = template_table_definition;
internal_index->index_catalog_definition = index_catalog_definition;
internal_index->pages_vector = pages_vector;
internal_index->pages_cache = pages_cache;
internal_index->long_values_pages_vector = long_values_pages_vector;
internal_index->long_values_pages_cache = long_values_pages_cache;
internal_index->table_values_tree = table_values_tree;
internal_index->table_values_cache = table_values_cache;
internal_index->long_values_tree = long_values_tree;
internal_index->long_values_cache = long_values_cache;
*index = (libesedb_index_t *) internal_index;
return( 1 );
on_error:
if( internal_index != NULL )
{
if( internal_index->index_values_cache != NULL )
{
libfcache_cache_free(
&( internal_index->index_values_cache ),
NULL );
}
if( internal_index->index_values_tree != NULL )
{
libfdata_btree_free(
&( internal_index->index_values_tree ),
NULL );
}
memory_free(
internal_index );
}
return( -1 );
}
int http_read(const char *hostName, const void *requestString, int requestLength, int port, int readTimeOut,
int contentOnly, void **resultBuffer, int *resultBufferLength)
{
int responseStatusCode = 0;
SOCKET_DESCRIPTOR socketDescriptor;
struct hostent *host;
struct sockaddr_in serverAddr;
char *buffer = NULL;
int bytes_read = 0;
int count = 0;
int readCount = 0;
int res;
char *r_start, *r_end;
#ifdef WIN32
WSADATA wsaData;
WSAStartup(MAKEWORD(2, 2), &wsaData);
#endif
socketDescriptor = socket(AF_INET, SOCK_STREAM, 0);
if (socketDescriptor == INVALID_SOCKET)
{
#ifdef WIN32
WSACleanup();
#endif
return HTTP_SOCKET_ERROR;
}
host = (struct hostent *) gethostbyname(hostName);
if (host == NULL)
{
res = HTTP_NOLIVEINTERNET_ERROR;
goto exit_sopened;
}
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = (short)host->h_addrtype;
serverAddr.sin_port = htons((unsigned short)port);
serverAddr.sin_addr.s_addr = *(unsigned long*)host->h_addr;
if (connect(socketDescriptor, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0)
{
res = HTTP_CONNECT_ERROR;
goto exit_sopened;
}
/* Send request */
if (safe_send(socketDescriptor, requestString, requestLength, 0) != requestLength)
{
res = HTTP_SEND_ERROR;
goto exit_sopened;
}
buffer = (char*)memory_alloc(0);
count = 0;
for(;;)
{
fd_set rfds;
struct timeval tv;
int selectResult;
tv.tv_sec = readTimeOut;
tv.tv_usec = 0;
FD_ZERO(&rfds);
FD_SET(socketDescriptor, &rfds);
selectResult = select((int)socketDescriptor + 1, &rfds, NULL, NULL, &tv);
if ((selectResult == 0) || (selectResult == -1))
{
res = HTTP_READTIMEOUT_ERROR;
goto exit_sopened;
}
count++;
buffer = (char*)memory_realloc((void*)buffer, HTTP_READ_BUFFER_SIZE * count);
if (!buffer)
{
res = HTTP_RECEIVE_ERROR;
goto exit_sopened;
}
#ifdef WIN32
readCount = recv(socketDescriptor, buffer + bytes_read, HTTP_READ_BUFFER_SIZE, 0);
#else
readCount = read(socketDescriptor, buffer + bytes_read, HTTP_READ_BUFFER_SIZE);
#endif
if (readCount == 0)
{
buffer[bytes_read] = '\0';
break;
}
if (readCount < 0)
{
res = HTTP_RECEIVE_ERROR;
goto exit_sopened;
}
bytes_read += readCount;
}
close_socket(socketDescriptor);
if (buffer)
{
if (sscanf(buffer, "%*s %d", &responseStatusCode) != 1)
{
res = HTTP_RECEIVE_ERROR;
goto exit_buffree;
}
}
switch (responseStatusCode)
{
case 200:
{
/* Status is OK */
break;
}
case 301:
{
/* Permanent redirection, extract new location */
if (buffer)
{
r_start = strstr(buffer, HTTP_Header_Location);
if (r_start)
{
r_start += strlen(HTTP_Header_Location);
r_end = strstr(r_start, "\r\n");
if (r_end && r_end > r_start)
{
*resultBufferLength = r_end - r_start;
*resultBuffer = memory_alloc(*resultBufferLength + 1);
if (!*resultBuffer)
{
res = HTTP_RECEIVE_ERROR;
goto exit_buffree;
}
memcpy(*resultBuffer, r_start, *resultBufferLength);
/* Put null terminating character */
((char*)*resultBuffer)[*resultBufferLength] = '\0';
*resultBufferLength += 1;
res = HTTP_REDIRECTION;
goto exit_buffree;
}
}
}
break;
}
default:
{
/* No HTTP return code */
res = HTTP_RESPONSESTATUS_ERROR;
goto exit_buffree;
}
}
if (contentOnly == 0)
{
*resultBuffer = buffer;
*resultBufferLength = bytes_read;
}
else
{
int headerLength;
char* temp = strstr(buffer, "\r\n\r\n");
headerLength = (int)(temp - buffer + 4);
res = HTTP_CONTENT_ERROR;
if (!temp) goto exit_buffree;
*resultBuffer = memory_alloc(bytes_read - headerLength);
if (!*resultBuffer) goto exit_buffree;
*resultBuffer = memcpy(*resultBuffer, temp + 4, bytes_read - headerLength);
*resultBufferLength = bytes_read - headerLength;
res = HTTP_NOERROR;
goto exit_buffree;
}
res = HTTP_NOERROR;
goto exit;
exit_sopened:
close_socket(socketDescriptor);
exit_buffree:
if (buffer)
{
memory_free(buffer);
}
exit:
return res;
}
/* Creates a block
* Make sure the value block is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libvshadow_block_initialize(
libvshadow_block_t **block,
libvshadow_block_descriptor_t *block_descriptor,
libcerror_error_t **error )
{
libvshadow_internal_block_t *internal_block = NULL;
static char *function = "libvshadow_block_initialize";
if( block == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid block.",
function );
return( -1 );
}
if( *block != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid block value already set.",
function );
return( -1 );
}
if( block_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid block descriptor.",
function );
return( -1 );
}
internal_block = memory_allocate_structure(
libvshadow_internal_block_t );
if( internal_block == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create block.",
function );
goto on_error;
}
if( memory_set(
internal_block,
0,
sizeof( libvshadow_internal_block_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear block.",
function );
goto on_error;
}
internal_block->block_descriptor = block_descriptor;
*block = (libvshadow_block_t *) internal_block;
return( 1 );
on_error:
if( internal_block != NULL )
{
memory_free(
internal_block );
}
return( -1 );
}
/* Reads a hash table
* Returns 1 if successful or -1 on error
*/
int libmsiecf_hash_table_read(
libcdata_array_t *hash_table,
off64_t *next_hash_table_offset,
libbfio_handle_t *file_io_handle,
off64_t hash_table_offset,
size32_t block_size,
libcerror_error_t **error )
{
msiecf_hash_record_header_t hash_record_header;
uint8_t *hash_record_data = NULL;
uint8_t *entry_data = NULL;
static char *function = "libmsiecf_hash_table_read";
size_t read_size = 0;
size_t table_iterator = 0;
ssize_t read_count = 0;
uint32_t entry_hash = 0;
uint32_t entry_offset = 0;
uint32_t number_of_blocks = 0;
#if defined( HAVE_DEBUG_OUTPUT )
uint32_t value_32bit = 0;
int number_of_items = 0;
#endif
if( hash_table == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid hash table.",
function );
return( -1 );
}
if( next_hash_table_offset == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid next hash table offset.",
function );
return( -1 );
}
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
if( block_size == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS,
"%s: invalid block size value zero or less.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: reading HASH record at offset: %" PRIi64 " (0x%08" PRIx64 ")\n",
function,
hash_table_offset,
hash_table_offset );
}
#endif
if( libbfio_handle_seek_offset(
file_io_handle,
hash_table_offset,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek HASH record offset: %" PRIi64 ".",
function,
hash_table_offset );
return( -1 );
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
(uint8_t *) &hash_record_header,
sizeof( msiecf_hash_record_header_t ),
error );
if( read_count != (ssize_t) sizeof( msiecf_hash_record_header_t ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read HASH record header.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: HASH record header:\n",
function );
libcnotify_print_data(
(uint8_t *) &hash_record_header,
sizeof( msiecf_hash_record_header_t ),
0 );
}
#endif
if( memory_compare(
hash_record_header.signature,
"HASH",
4 ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported signature.",
function );
return( -1 );
}
byte_stream_copy_to_uint32_little_endian(
hash_record_header.number_of_blocks,
number_of_blocks );
byte_stream_copy_to_uint32_little_endian(
hash_record_header.next_offset,
*next_hash_table_offset );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: signature\t\t\t\t\t: %c%c%c%c\n",
function,
hash_record_header.signature[ 0 ],
hash_record_header.signature[ 1 ],
hash_record_header.signature[ 2 ],
hash_record_header.signature[ 3 ] );
libcnotify_printf(
"%s: number of blocks\t\t\t\t: %" PRIu32 "\n",
function,
number_of_blocks );
libcnotify_printf(
"%s: next offset\t\t\t\t\t: %" PRIi64 " (0x%08" PRIx64 ")\n",
function,
*next_hash_table_offset,
*next_hash_table_offset );
byte_stream_copy_to_uint32_little_endian(
hash_record_header.sequence_number,
value_32bit );
libcnotify_printf(
"%s: sequence number\t\t\t\t: %" PRIu32 "\n",
function,
value_32bit );
libcnotify_printf(
"\n" );
}
#endif
read_size = ( number_of_blocks * block_size ) - sizeof( msiecf_hash_record_header_t );
if( read_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid read size value exceeds maximum.",
function );
return( -1 );
}
if( ( read_size % 8 ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported HASH record data size.",
function );
return( -1 );
}
hash_record_data = (uint8_t *) memory_allocate(
read_size );
if( hash_record_data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create HASH record data.",
function );
return( -1 );
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
hash_record_data,
read_size,
error );
if( read_count != (ssize_t) read_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read HASH record data.",
function );
memory_free(
hash_record_data );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: HASH record data:\n",
function );
libcnotify_print_data(
hash_record_data,
read_size,
0 );
}
#endif
read_size /= 8;
entry_data = hash_record_data;
for( table_iterator = 0;
table_iterator < read_size;
table_iterator++ )
{
byte_stream_copy_to_uint32_little_endian(
entry_data,
entry_hash );
entry_data += 4;
byte_stream_copy_to_uint32_little_endian(
entry_data,
entry_offset );
entry_data += 4;
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: entry %03d hash\t\t\t\t: 0x%08" PRIx32 "\n",
function,
table_iterator,
entry_hash );
libcnotify_printf(
"%s: entry %03d offset\t\t\t\t: 0x%08" PRIx32 "\n",
function,
table_iterator,
entry_offset );
}
#endif
/* Skip empty entries
*/
if( entry_hash == entry_offset )
{
continue;
}
/* Skip uninitialized entries
* These should only appear at the end of the HASH record data
*/
if( ( entry_hash == 0x0badf00d )
|| ( entry_hash == 0xdeadbeef ) )
{
continue;
}
/* Skip invalid URL entries
*/
if( ( entry_hash & 0x0f ) == 0x01 )
{
continue;
}
/* Check if the entry record offset is block aligned
*/
if( ( entry_offset % block_size ) != 0 )
{
continue;
}
#if defined( HAVE_DEBUG_OUTPUT )
number_of_items++;
#endif
/* TODO flag hashed items
*/
}
memory_free(
hash_record_data );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: found %d hashed items.\n",
function,
number_of_items );
libcnotify_printf(
"\n" );
}
#endif
return( 1 );
}
/* Creates a split UTF-8 string
* Make sure the value split_string is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfvalue_split_utf8_string_initialize(
libfvalue_split_utf8_string_t **split_string,
const uint8_t *utf8_string,
size_t utf8_string_size,
int number_of_segments,
libcerror_error_t **error )
{
libfvalue_internal_split_utf8_string_t *internal_split_string = NULL;
static char *function = "libfvalue_split_utf8_string_initialize";
if( split_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid split string.",
function );
return( -1 );
}
if( *split_string != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid split string value already set.",
function );
return( -1 );
}
if( number_of_segments < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid number of segments less than zero.",
function );
return( -1 );
}
internal_split_string = memory_allocate_structure(
libfvalue_internal_split_utf8_string_t );
if( internal_split_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create split string.",
function );
goto on_error;
}
if( memory_set(
internal_split_string,
0,
sizeof( libfvalue_internal_split_utf8_string_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear split string.",
function );
memory_free(
internal_split_string );
return( -1 );
}
if( ( utf8_string != NULL )
&& ( utf8_string_size > 0 ) )
{
internal_split_string->string = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * utf8_string_size );
if( internal_split_string->string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create string.",
function );
goto on_error;
}
if( memory_copy(
internal_split_string->string,
utf8_string,
sizeof( uint8_t ) * ( utf8_string_size - 1 ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to copy string.",
function );
goto on_error;
}
internal_split_string->string[ utf8_string_size - 1 ] = 0;
internal_split_string->string_size = utf8_string_size;
}
if( number_of_segments > 0 )
{
internal_split_string->segments = (uint8_t **) memory_allocate(
sizeof( uint8_t * ) * number_of_segments );
if( internal_split_string->segments == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create segments.",
function );
goto on_error;
}
if( memory_set(
internal_split_string->segments,
0,
sizeof( uint8_t * ) * number_of_segments ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear segments.",
function );
goto on_error;
}
internal_split_string->segment_sizes = (size_t *) memory_allocate(
sizeof( size_t ) * number_of_segments );
if( internal_split_string->segment_sizes == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create segment sizes.",
function );
goto on_error;
}
if( memory_set(
internal_split_string->segment_sizes,
0,
sizeof( size_t ) * number_of_segments ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear segment sizes.",
function );
goto on_error;
}
}
internal_split_string->number_of_segments = number_of_segments;
*split_string = (libfvalue_split_utf8_string_t *) internal_split_string;
return( 1 );
on_error:
if( internal_split_string != NULL )
{
if( internal_split_string->segment_sizes != NULL )
{
memory_free(
internal_split_string->segment_sizes );
}
if( internal_split_string->segments != NULL )
{
memory_free(
internal_split_string->segments );
}
if( internal_split_string->string != NULL )
{
memory_free(
internal_split_string->string );
}
memory_free(
internal_split_string );
}
return( -1 );
}
/* Creates a data descriptor
* Make sure the value data_descriptor is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libwrc_data_descriptor_initialize(
libwrc_data_descriptor_t **data_descriptor,
libcerror_error_t **error )
{
static char *function = "libwrc_data_descriptor_initialize";
if( data_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data descriptor.",
function );
return( -1 );
}
if( *data_descriptor != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid data descriptor value already set.",
function );
return( -1 );
}
*data_descriptor = memory_allocate_structure(
libwrc_data_descriptor_t );
if( *data_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create data descriptor.",
function );
goto on_error;
}
if( memory_set(
*data_descriptor,
0,
sizeof( libwrc_data_descriptor_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear data descriptor.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *data_descriptor != NULL )
{
memory_free(
*data_descriptor );
*data_descriptor = NULL;
}
return( -1 );
}
/* Sends a SCSI ioctl to the file descriptor
* Returns 1 if successful or -1 on error
*/
int libsmdev_scsi_ioctrl(
int file_descriptor,
void *request_data,
size_t request_data_size,
liberror_error_t **error )
{
uint8_t *ioctrl_request = 0;
static char *function = "libsmdev_scsi_ioctrl";
size_t ioctrl_request_size = 0;
if( file_descriptor == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file descriptor.",
function );
return( -1 );
}
ioctrl_request_size = sizeof( libsmdev_scsi_ioctrl_header_t ) + request_data_size;
ioctrl_request = (uint8_t *) memory_allocate(
ioctrl_request_size );
if( ioctrl_request == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create SCSI ioctrl request.",
function );
return( -1 );
}
if( memory_set(
ioctrl_request,
0,
ioctrl_request_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear SCSI ioctrl request.",
function );
memory_free(
ioctrl_request );
return( -1 );
}
( (libsmdev_scsi_ioctrl_header_t *) ioctrl_request )->request_size = request_data_size;
if( memory_copy(
&( ioctrl_request[ sizeof( libsmdev_scsi_ioctrl_header_t ) ] ),
request_data,
request_data_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to set SCSI ioctrl request.",
function );
memory_free(
ioctrl_request );
return( -1 );
}
if( ioctl(
file_descriptor,
SCSI_IOCTL_SEND_COMMAND,
ioctrl_request ) == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_IOCTL_FAILED,
"%s: unable to query device for: SCSI_IOCTL_SEND_COMMAND.",
function );
memory_free(
ioctrl_request );
return( -1 );
}
memory_free(
ioctrl_request );
return( 1 );
}
/* Creates a CHS address
* Make sure the value chs_address is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libvsmbr_chs_address_initialize(
libvsmbr_chs_address_t **chs_address,
libcerror_error_t **error )
{
static char *function = "libvsmbr_chs_address_initialize";
if( chs_address == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid CHS address.",
function );
return( -1 );
}
if( *chs_address != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid CHS address value already set.",
function );
return( -1 );
}
*chs_address = memory_allocate_structure(
libvsmbr_chs_address_t );
if( *chs_address == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create CHS address.",
function );
goto on_error;
}
if( memory_set(
*chs_address,
0,
sizeof( libvsmbr_chs_address_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear CHS address.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *chs_address != NULL )
{
memory_free(
*chs_address );
*chs_address = NULL;
}
return( -1 );
}
/* Reads the volume name values
* Returns 1 if successful or -1 on error
*/
int libfsntfs_volume_name_values_read(
libfsntfs_volume_name_values_t *volume_name_values,
const uint8_t *data,
size_t data_size,
libcerror_error_t **error )
{
static char *function = "libfsntfs_volume_name_values_read";
#if defined( HAVE_DEBUG_OUTPUT )
libcstring_system_character_t *value_string = NULL;
size_t value_string_size = 0;
int result = 0;
#endif
if( volume_name_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid volume name values.",
function );
return( -1 );
}
/* The size of the data can be 0 if the name is not set.
*/
if( data_size == 0 )
{
return( 1 );
}
if( data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid data.",
function );
goto on_error;
}
if( data_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid data size value out of bounds.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: volume name data:\n",
function );
libcnotify_print_data(
data,
data_size,
0 );
}
#endif
if( data_size > 0 )
{
volume_name_values->name = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * data_size );
if( volume_name_values->name == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name.",
function );
goto on_error;
}
volume_name_values->name_size = data_size;
if( memory_copy(
volume_name_values->name,
data,
volume_name_values->name_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy volume name.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libuna_utf16_string_size_from_utf16_stream(
volume_name_values->name,
volume_name_values->name_size,
LIBUNA_ENDIAN_LITTLE,
&value_string_size,
error );
#else
result = libuna_utf8_string_size_from_utf16_stream(
volume_name_values->name,
volume_name_values->name_size,
LIBUNA_ENDIAN_LITTLE,
&value_string_size,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine size of name string.",
function );
goto on_error;
}
value_string = libcstring_system_string_allocate(
value_string_size );
if( value_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name string.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libuna_utf16_string_copy_from_utf16_stream(
(libuna_utf16_character_t *) value_string,
value_string_size,
volume_name_values->name,
volume_name_values->name_size,
LIBUNA_ENDIAN_LITTLE,
error );
#else
result = libuna_utf8_string_copy_from_utf16_stream(
(libuna_utf8_character_t *) value_string,
value_string_size,
volume_name_values->name,
volume_name_values->name_size,
LIBUNA_ENDIAN_LITTLE,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set name string.",
function );
goto on_error;
}
libcnotify_printf(
"%s: name\t\t\t\t\t: %" PRIs_LIBCSTRING_SYSTEM "\n",
function,
value_string );
memory_free(
value_string );
value_string = NULL;
libcnotify_printf(
"\n" );
}
#endif
}
return( 1 );
on_error:
#if defined( HAVE_DEBUG_OUTPUT )
if( value_string != NULL )
{
memory_free(
value_string );
}
#endif
if( volume_name_values->name != NULL )
{
memory_free(
volume_name_values->name );
volume_name_values->name = NULL;
}
volume_name_values->name_size = 0;
return( -1 );
}
/* Sets the name
* Returns 1 if successful or -1 on error
*/
int libvslvm_logical_volume_values_set_name(
libvslvm_logical_volume_values_t *logical_volume_values,
const char *name,
size_t name_size,
libcerror_error_t **error )
{
static char *function = "libvslvm_logical_volume_values_set_name";
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( name == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid name.",
function );
return( -1 );
}
if( name_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: name size value exceeds maximum.",
function );
return( -1 );
}
if( logical_volume_values->name != NULL )
{
memory_free(
logical_volume_values->name );
logical_volume_values->name = NULL;
logical_volume_values->name_size = 0;
}
logical_volume_values->name = (char *) memory_allocate(
sizeof( char ) * name_size );
if( logical_volume_values->name == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name.",
function );
goto on_error;
}
if( memory_copy(
logical_volume_values->name,
name,
name_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy name.",
function );
goto on_error;
}
logical_volume_values->name[ name_size - 1 ] = 0;
logical_volume_values->name_size = name_size;
return( 1 );
on_error:
if( logical_volume_values->name != NULL )
{
memory_free(
logical_volume_values->name );
logical_volume_values->name = NULL;
}
logical_volume_values->name_size = 0;
return( -1 );
}
/* Prints the EncryptedRoot.plist.wipekey information to a stream
* Returns 1 if successful or -1 on error
*/
int wipekey_handle_wipekey_fprint(
wipekey_handle_t *wipekey_handle,
libcerror_error_t **error )
{
uint8_t *data = NULL;
static char *function = "wipekey_handle_wipekey_fprint";
size64_t data_size = 0;
if( wipekey_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid wipekey handle.",
function );
return( -1 );
}
if( libfvde_encryption_context_plist_get_data_size(
wipekey_handle->encrypted_root_plist,
&data_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve encrypted root plist data size.",
function );
goto on_error;
}
if( data_size > (size64_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid encrypted root plist data size value exceeds maximum.",
function );
goto on_error;
}
fprintf(
wipekey_handle->notify_stream,
"Decrypted EncryptedRoot.plist.wipekey:\n" );
if( data_size > 0 )
{
data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * (size_t) data_size );
if( data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create encrypted root plist data.",
function );
goto on_error;
}
if( libfvde_encryption_context_plist_copy_data(
wipekey_handle->encrypted_root_plist,
data,
(size_t) data_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy encrypted root plist data.",
function );
goto on_error;
}
fprintf(
wipekey_handle->notify_stream,
"%s",
data );
memory_free(
data );
data = NULL;
}
fprintf(
wipekey_handle->notify_stream,
"\n" );
return( 1 );
on_error:
if( data != NULL )
{
memory_free(
data );
}
return( -1 );
}
/* Creates logical volume values
* Make sure the value logical_volume_values is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libvslvm_logical_volume_values_initialize(
libvslvm_logical_volume_values_t **logical_volume_values,
libcerror_error_t **error )
{
static char *function = "libvslvm_logical_volume_values_initialize";
if( logical_volume_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid logical volume values.",
function );
return( -1 );
}
if( *logical_volume_values != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid logical volume values value already set.",
function );
return( -1 );
}
*logical_volume_values = memory_allocate_structure(
libvslvm_logical_volume_values_t );
if( *logical_volume_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create logical volume values.",
function );
goto on_error;
}
if( memory_set(
*logical_volume_values,
0,
sizeof( libvslvm_logical_volume_values_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear logical volume values.",
function );
memory_free(
*logical_volume_values );
*logical_volume_values = NULL;
return( -1 );
}
if( libcdata_array_initialize(
&( ( *logical_volume_values )->segments_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create segments array.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *logical_volume_values != NULL )
{
memory_free(
*logical_volume_values );
*logical_volume_values = NULL;
}
return( -1 );
}
/* Creates a memory range IO handle
* Make sure the value memory_range_io_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libbfio_memory_range_io_handle_initialize(
libbfio_memory_range_io_handle_t **memory_range_io_handle,
libcerror_error_t **error )
{
static char *function = "libbfio_memory_range_io_handle_initialize";
if( memory_range_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid memory range IO handle.",
function );
return( -1 );
}
if( *memory_range_io_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid memory range IO handle value already set.",
function );
return( -1 );
}
*memory_range_io_handle = memory_allocate_structure(
libbfio_memory_range_io_handle_t );
if( *memory_range_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create memory range IO handle.",
function );
goto on_error;
}
if( memory_set(
*memory_range_io_handle,
0,
sizeof( libbfio_memory_range_io_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear memory range IO handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *memory_range_io_handle != NULL )
{
memory_free(
*memory_range_io_handle );
*memory_range_io_handle = NULL;
}
return( -1 );
}
/* Creates a page tree
* Make sure the value page_tree is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libesedb_page_tree_initialize(
libesedb_page_tree_t **page_tree,
libesedb_io_handle_t *io_handle,
libfdata_vector_t *pages_vector,
libfcache_cache_t *pages_cache,
uint32_t object_identifier,
libesedb_table_definition_t *table_definition,
libesedb_table_definition_t *template_table_definition,
libcerror_error_t **error )
{
static char *function = "libesedb_page_tree_initialize";
if( page_tree == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid page tree.",
function );
return( -1 );
}
if( *page_tree != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid page tree value already set.",
function );
return( -1 );
}
if( io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid IO handle.",
function );
return( -1 );
}
*page_tree = memory_allocate_structure(
libesedb_page_tree_t );
if( *page_tree == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create page tree.",
function );
goto on_error;
}
if( memory_set(
*page_tree,
0,
sizeof( libesedb_page_tree_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear page tree.",
function );
goto on_error;
}
( *page_tree )->io_handle = io_handle;
( *page_tree )->pages_vector = pages_vector;
( *page_tree )->pages_cache = pages_cache;
( *page_tree )->object_identifier = object_identifier;
( *page_tree )->table_definition = table_definition;
( *page_tree )->template_table_definition = template_table_definition;
return( 1 );
on_error:
if( *page_tree != NULL )
{
memory_free(
*page_tree );
*page_tree = NULL;
}
return( -1 );
}
/* Creates a handle
* Make sure the value handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libvsmbr_handle_initialize(
libvsmbr_handle_t **handle,
libcerror_error_t **error )
{
libvsmbr_internal_handle_t *internal_handle = NULL;
static char *function = "libvsmbr_handle_initialize";
if( handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid handle.",
function );
return( -1 );
}
if( *handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid handle value already set.",
function );
return( -1 );
}
internal_handle = memory_allocate_structure(
libvsmbr_internal_handle_t );
if( internal_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create handle.",
function );
goto on_error;
}
if( memory_set(
internal_handle,
0,
sizeof( libvsmbr_internal_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear handle.",
function );
memory_free(
internal_handle );
return( -1 );
}
if( libvsmbr_io_handle_initialize(
&( internal_handle->io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create IO handle.",
function );
goto on_error;
}
if( libcdata_array_initialize(
&( internal_handle->partitions_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create partitions array.",
function );
goto on_error;
}
if( libcdata_array_initialize(
&( internal_handle->sections_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create sections array.",
function );
goto on_error;
}
*handle = (libvsmbr_handle_t *) internal_handle;
return( 1 );
on_error:
if( internal_handle != NULL )
{
if( internal_handle->partitions_array != NULL )
{
libcdata_array_free(
&( internal_handle->partitions_array ),
(int (*)(intptr_t **, libcerror_error_t **)) &libvsmbr_partition_values_free,
NULL );
}
memory_free(
internal_handle );
}
return( -1 );
}
/****************************************************************************
NAME
inquiry_write_eir_data - Write devices EIR data
*/
void inquiry_write_eir_data(const CL_DM_LOCAL_NAME_COMPLETE_T *data)
{
/* Determine length of EIR data */
uint16 total_eir_size = 0;
uint16 size_uuids = 0;
uint8 *eir = NULL;
if (AGHFP_PROFILE_IS_ENABLED)
{
size_uuids += sizeof(eir_hfp_uuids);
}
if (A2DP_PROFILE_IS_ENABLED)
{
size_uuids += sizeof(eir_a2dp_uuids);
}
if (AVRCP_PROFILE_IS_ENABLED)
{
size_uuids += sizeof(eir_avrcp_uuids);
}
total_eir_size = EIR_BLOCK_SIZE(EIR_DATA_SIZE_FULL(data->size_local_name) +
EIR_DATA_SIZE_FULL(sizeof(uint8)) + EIR_DATA_SIZE_FULL(size_uuids));
/* Allocate space for EIR data */
eir = (uint8 *)memory_create(total_eir_size);
if (eir)
{
uint8 *p = eir;
/* Device Name Field */
*p++ = EIR_DATA_SIZE(data->size_local_name);
*p++ = EIR_TYPE_LOCAL_NAME_COMPLETE;
memmove(p, data->local_name, data->size_local_name);
p += data->size_local_name;
/* Inquiry Tx Field */
*p++ = EIR_DATA_SIZE(sizeof(int8));
*p++ = EIR_TYPE_INQUIRY_TX;
*p++ = theSource->inquiry_mode.inquiry_tx;
/* UUID16 field */
*p++ = EIR_DATA_SIZE(sizeof(eir_uuids));
*p++ = EIR_TYPE_UUID16_COMPLETE;
if (AGHFP_PROFILE_IS_ENABLED)
{
memmove(p, eir_hfp_uuids, sizeof(eir_hfp_uuids));
p += sizeof(eir_hfp_uuids);
}
if (A2DP_PROFILE_IS_ENABLED)
{
memmove(p, eir_a2dp_uuids, sizeof(eir_a2dp_uuids));
p += sizeof(eir_a2dp_uuids);
}
if (AVRCP_PROFILE_IS_ENABLED)
{
memmove(p, eir_avrcp_uuids, sizeof(eir_avrcp_uuids));
p += sizeof(eir_avrcp_uuids);
}
/* NULL Termination */
*p++ = 0x00;
/* Register and free EIR data */
ConnectionWriteEirData(FALSE, total_eir_size, eir);
memory_free(eir);
INQUIRY_DEBUG(("INQUIRY: inquiry_write_eir_data\n"));
}
}