/* Empties the cache
* Returns 1 if successful or -1 on error
*/
int libfcache_cache_empty(
libfcache_cache_t *cache,
libcerror_error_t **error )
{
libfcache_internal_cache_t *internal_cache = NULL;
static char *function = "libfcache_cache_empty";
if( cache == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid cache.",
function );
return( -1 );
}
internal_cache = (libfcache_internal_cache_t *) cache;
if( libcdata_array_clear(
internal_cache->entries,
(int (*)(intptr_t **, libcerror_error_t **)) &libfcache_cache_value_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to clear entries array.",
function );
return( -1 );
}
internal_cache->number_of_cache_values = 0;
return( 1 );
}
/* Reads a data block and determines its entries
* Returns 1 if successful or -1 on error
*/
int libcreg_data_block_read_entries(
libcreg_data_block_t *data_block,
libbfio_handle_t *file_io_handle,
int (*read_entry_size_function)(
const uint8_t *data,
size_t data_size,
size_t *entry_size,
libcerror_error_t **error ),
int ascii_codepage,
uint8_t have_debug_output LIBCREG_ATTRIBUTE_UNUSED,
libcerror_error_t **error )
{
libcreg_data_block_entry_t *data_block_entry = NULL;
uint8_t *data_block_entry_data = NULL;
static char *function = "libcreg_data_block_read_entries";
size_t data_block_data_size = 0;
size_t data_block_entry_offset = 0;
ssize_t read_count = 0;
int entry_index = 0;
int data_block_entry_index = 0;
#if defined( HAVE_DEBUG_OUTPUT )
libcreg_key_name_entry_t *key_name_entry = NULL;
#else
LIBCREG_UNREFERENCED_PARAMETER( have_debug_output );
#endif
if( data_block == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data block.",
function );
return( -1 );
}
if( data_block->data != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid data block - data already set.",
function );
return( -1 );
}
#if SIZEOF_SIZE_T <= 4
if( data_block->size > (size_t) SSIZE_MAX )
#else
if( data_block->size > (uint32_t) SSIZE_MAX )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid data block - size value exceeds maximum.",
function );
return( -1 );
}
if( read_entry_size_function == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid read entry size function.",
function );
return( -1 );
}
data_block->data_size = (size_t) data_block->size - sizeof( creg_data_block_header_t );
data_block->data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * data_block->data_size );
if( data_block->data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create data block data.",
function );
goto on_error;
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
data_block->data,
data_block->data_size,
error );
if( read_count != (ssize_t) data_block->data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read data block data.",
function );
goto on_error;
}
data_block_entry_data = data_block->data;
if( (int32_t) data_block->used_size < 0 )
{
data_block_data_size = data_block->data_size;
}
else
{
data_block_data_size = (size_t) data_block->used_size - sizeof( creg_data_block_header_t );
}
while( data_block_entry_offset < data_block_data_size )
{
if( libcreg_data_block_entry_initialize(
&data_block_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create data block entry.",
function );
goto on_error;
}
if( read_entry_size_function(
&( data_block_entry_data[ data_block_entry_offset ] ),
data_block->data_size - data_block_entry_offset,
&( data_block_entry->size ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve data block entry size.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: data block entry: %03d offset\t\t: %" PRIzd "\n",
function,
data_block_entry_index,
data_block_entry_offset );
libcnotify_printf(
"%s: data block entry: %03d size\t\t: %" PRIzd "\n",
function,
data_block_entry_index,
data_block_entry->size );
}
#endif
data_block_entry->offset = data_block_entry_offset;
#if defined( HAVE_DEBUG_OUTPUT )
if( ( libcnotify_verbose != 0 )
&& ( have_debug_output != 0 ) )
{
if( libcreg_key_name_entry_initialize(
&key_name_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create key name entry.",
function );
goto on_error;
}
if( libcreg_key_name_entry_read_data(
key_name_entry,
&( ( data_block->data )[ data_block_entry->offset ] ),
data_block_entry->size,
ascii_codepage,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read key name entry: %d.",
function,
data_block_entry_index );
goto on_error;
}
if( libcreg_key_name_entry_free(
&key_name_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free key name entry.",
function );
goto on_error;
}
}
#endif
data_block_entry_offset += (size_t) data_block_entry->size;
if( libcdata_array_append_entry(
data_block->entries_array,
&entry_index,
(intptr_t *) data_block_entry,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append data block entry: %d.",
function,
data_block_entry_index );
goto on_error;
}
data_block_entry = NULL;
data_block_entry_index++;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( ( libcnotify_verbose != 0 )
&& ( have_debug_output != 0 ) )
{
if( data_block_entry_offset < data_block->data_size )
{
libcnotify_printf(
"%s: trailing data:\n",
function );
libcnotify_print_data(
&( ( data_block->data )[ data_block_entry_offset ] ),
data_block->data_size - data_block_entry_offset,
LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
}
else
{
libcnotify_printf(
"\n" );
}
}
#endif
return( 1 );
on_error:
#if defined( HAVE_DEBUG_OUTPUT )
if( key_name_entry != NULL )
{
libcreg_key_name_entry_free(
&key_name_entry,
NULL );
}
#endif
if( data_block_entry != NULL )
{
libcreg_data_block_entry_free(
&data_block_entry,
NULL );
}
if( data_block->entries_array != NULL )
{
libcdata_array_clear(
data_block->entries_array,
(int (*)(intptr_t **, libcerror_error_t **)) &libcreg_data_block_entry_free,
NULL );
}
if( data_block->data != NULL )
{
memory_free(
data_block->data );
data_block->data = NULL;
}
data_block->data_size = 0;
return( -1 );
}
