/* Resizes the area
* Returns 1 if successful or -1 on error
*/
int libfdata_area_resize(
libfdata_area_t *area,
int number_of_segments,
libcerror_error_t **error )
{
libfdata_internal_area_t *internal_area = NULL;
static char *function = "libfdata_area_resize";
if( area == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid area.",
function );
return( -1 );
}
internal_area = (libfdata_internal_area_t *) area;
if( libcdata_array_resize(
internal_area->segments_array,
number_of_segments,
(int (*)(intptr_t **, libcerror_error_t **)) &libfdata_range_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize segments array.",
function );
return( -1 );
}
if( libcdata_array_resize(
internal_area->mapped_ranges_array,
number_of_segments,
(int (*)(intptr_t **, libcerror_error_t **)) &libfdata_mapped_range_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize mapped ranges array.",
function );
return( -1 );
}
internal_area->flags |= LIBFDATA_FLAG_CALCULATE_MAPPED_RANGES;
return( 1 );
}
/* Resizes the cache
* Returns 1 if successful or -1 on error
*/
int libfcache_cache_resize(
libfcache_cache_t *cache,
int maximum_cache_entries,
libcerror_error_t **error )
{
libfcache_internal_cache_t *internal_cache = NULL;
static char *function = "libfcache_cache_resize";
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_resize(
internal_cache->entries,
maximum_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_RESIZE_FAILED,
"%s: unable to resize entries array.",
function );
return( -1 );
}
return( 1 );
}
/* Reads the page tags
* Returns 1 if successful or -1 on error
*/
int libesedb_page_read_tags(
libcdata_array_t *page_tags_array,
libesedb_io_handle_t *io_handle,
uint16_t number_of_page_tags,
uint8_t *page_data,
size_t page_data_size,
libcerror_error_t **error )
{
libesedb_page_tags_value_t *page_tags_value = NULL;
uint8_t *page_tags_data = NULL;
static char *function = "libesedb_page_read_tags";
uint16_t page_tag_offset = 0;
uint16_t page_tag_size = 0;
uint16_t page_tags_index = 0;
#if defined( HAVE_DEBUG_OUTPUT )
size_t page_tags_data_size = 0;
#endif
if( page_tags_array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid page tags array.",
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( page_data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid page data.",
function );
return( -1 );
}
if( page_data_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid page data size value exceeds maximum.",
function );
return( -1 );
}
if( libcdata_array_resize(
page_tags_array,
number_of_page_tags,
(int (*)(intptr_t **, libcerror_error_t **)) &libesedb_page_tags_value_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize page tags array.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
page_tags_data_size = 4 * number_of_page_tags;
libcnotify_printf(
"%s: page tags:\n",
function );
libcnotify_print_data(
&( page_data[ page_data_size - page_tags_data_size ] ),
page_tags_data_size,
0 );
}
#endif
/* Read the page tags back to front
*/
page_tags_data = &( page_data[ page_data_size - 2 ] );
for( page_tags_index = 0;
page_tags_index < number_of_page_tags;
page_tags_index++ )
{
if( libesedb_page_tags_value_initialize(
&page_tags_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create page tags value.",
function );
goto on_error;
}
byte_stream_copy_to_uint16_little_endian(
page_tags_data,
page_tag_offset );
page_tags_data -= 2;
byte_stream_copy_to_uint16_little_endian(
page_tags_data,
page_tag_size );
page_tags_data -= 2;
if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_EXTENDED_PAGE_HEADER )
&& ( io_handle->page_size >= 16384 ) )
{
page_tags_value->flags = 0;
page_tags_value->offset = page_tag_offset & 0x7fff;
page_tags_value->size = page_tag_size & 0x7fff;;
}
else
{
page_tags_value->flags = page_tag_offset >> 13;
page_tags_value->offset = page_tag_offset & 0x1fff;
page_tags_value->size = page_tag_size & 0x1fff;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: page tag: %03" PRIu16 " offset\t\t\t\t: %" PRIu16 " (0x%04" PRIx16 ")\n",
function,
page_tags_index,
page_tags_value->offset,
page_tag_offset );
libcnotify_printf(
"%s: page tag: %03" PRIu16 " size\t\t\t\t: %" PRIu16 " (0x%04" PRIx16 ")\n",
function,
page_tags_index,
page_tags_value->size,
page_tag_size );
if( ( io_handle->format_revision < LIBESEDB_FORMAT_REVISION_EXTENDED_PAGE_HEADER )
&& ( io_handle->page_size < 16384 ) )
{
libcnotify_printf(
"%s: page tag: %03" PRIu16 " flags\t\t\t\t: 0x%02" PRIx8 "",
function,
page_tags_index,
page_tags_value->flags );
libesedb_debug_print_page_tag_flags(
page_tags_value->flags );
libcnotify_printf(
"\n" );
}
}
#endif
if( libcdata_array_set_entry_by_index(
page_tags_array,
(int) page_tags_index,
(intptr_t *) page_tags_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set page tag: %" PRIu16 ".",
function,
page_tags_index );
goto on_error;
}
page_tags_value = NULL;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"\n" );
}
#endif
return( 1 );
on_error:
if( page_tags_value != NULL )
{
libesedb_page_tags_value_free(
&page_tags_value,
NULL );
}
return( -1 );
}
/* Reads the page values
* Returns 1 if successful or -1 on error
*/
int libesedb_page_read_values(
libesedb_page_t *page,
libesedb_io_handle_t *io_handle,
libcdata_array_t *page_tags_array,
uint8_t *page_values_data,
size_t page_values_data_size,
size_t page_values_data_offset,
libcerror_error_t **error )
{
libesedb_page_tags_value_t *page_tags_value = NULL;
libesedb_page_value_t *page_value = NULL;
static char *function = "libesedb_page_read_values";
uint16_t page_tags_index = 0;
int number_of_page_tags = 0;
if( page == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid page.",
function );
return( -1 );
}
if( page->values_array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid page - missing values array.",
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( page_tags_array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid page tags array.",
function );
return( -1 );
}
if( page_values_data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid page values data.",
function );
return( -1 );
}
if( page_values_data_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid page values data size value exceeds maximum.",
function );
return( -1 );
}
if( libcdata_array_get_number_of_entries(
page_tags_array,
&number_of_page_tags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of page tags.",
function );
return( -1 );
}
if( libcdata_array_resize(
page->values_array,
number_of_page_tags,
(int (*)(intptr_t **, libcerror_error_t **)) &libesedb_page_value_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize page values array.",
function );
goto on_error;
}
for( page_tags_index = 0;
page_tags_index < number_of_page_tags;
page_tags_index++ )
{
if( libcdata_array_get_entry_by_index(
page_tags_array,
page_tags_index,
(intptr_t **) &page_tags_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve page tag: %" PRIu16 ".",
function,
page_tags_index );
goto on_error;
}
if( page_tags_value == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid page tags value.",
function );
goto on_error;
}
if( libesedb_page_value_initialize(
&page_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create tags value.",
function );
goto on_error;
}
if( page_tags_value->offset > page->data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: unsupported page tags value offset value out of bounds.",
function );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: page value: %03" PRIu16 " offset: % 5" PRIu16 ", size: % 5" PRIu16 "\n",
function,
page_tags_index,
page_tags_value->offset,
page_tags_value->size );
}
#endif
goto on_error;
}
if( page_tags_value->size > ( page->data_size - page_tags_value->offset ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: unsupported page tags value size value out of bounds.",
function );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: page value: %03" PRIu16 " offset: % 5" PRIu16 ", size: % 5" PRIu16 "\n",
function,
page_tags_index,
page_tags_value->offset,
page_tags_value->size );
}
#endif
goto on_error;
}
if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_EXTENDED_PAGE_HEADER )
&& ( io_handle->page_size >= 16384 ) )
{
/* The page tags flags are stored in the upper byte of the first 16-bit value
*/
page_tags_value->flags = page_values_data[ page_tags_value->offset + 1 ] >> 5;
page_values_data[ page_tags_value->offset + 1 ] &= 0x1f;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: page value: %03" PRIu16 " offset: % 5" PRIu16 ", size: % 5" PRIu16 ", flags: 0x%02" PRIx8 "",
function,
page_tags_index,
page_tags_value->offset,
page_tags_value->size,
page_tags_value->flags );
libesedb_debug_print_page_tag_flags(
page_tags_value->flags );
libcnotify_printf(
"\n" );
}
#endif
page_value->data = &( page_values_data[ page_tags_value->offset ] );
page_value->offset = (uint16_t) ( page_values_data_offset + page_tags_value->offset );
page_value->size = page_tags_value->size;
page_value->flags = page_tags_value->flags;
if( libcdata_array_set_entry_by_index(
page->values_array,
(int) page_tags_index,
(intptr_t *) page_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set page value: %" PRIu16 ".",
function,
page_tags_index );
goto on_error;
}
page_value = NULL;
}
