/* Sets the data range
* Returns 1 if successful or -1 on error
*/
int libfdata_list_element_set_data_range(
libfdata_list_element_t *element,
int file_index,
off64_t offset,
size64_t size,
uint32_t flags,
libcerror_error_t **error )
{
libfdata_internal_list_element_t *internal_element = NULL;
static char *function = "libfdata_list_element_set_data_range";
if( element == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid element.",
function );
return( -1 );
}
internal_element = (libfdata_internal_list_element_t *) element;
if( file_index < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid file index less than zero.",
function );
return( -1 );
}
if( offset < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid offset value less than zero.",
function );
return( -1 );
}
if( size > (size64_t) INT64_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid size value exceeds maximum.",
function );
return( -1 );
}
if( libfdata_range_set(
internal_element->data_range,
file_index,
offset,
size,
flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set data range.",
function );
return( -1 );
}
internal_element->timestamp = libfcache_date_time_get_timestamp();
return( 1 );
}
/* Creates an area
* Make sure the value area is referencing, is set to NULL
*
* If the flag LIBFDATA_DATA_HANDLE_FLAG_MANAGED is set the area
* takes over management of the data handle and the data handle is freed when
* no longer needed
*
* Returns 1 if successful or -1 on error
*/
int libfdata_area_initialize(
libfdata_area_t **area,
size64_t element_data_size,
intptr_t *data_handle,
int (*free_data_handle)(
intptr_t **data_handle,
libcerror_error_t **error ),
int (*clone_data_handle)(
intptr_t **destination_data_handle,
intptr_t *source_data_handle,
libcerror_error_t **error ),
int (*read_element_data)(
intptr_t *data_handle,
intptr_t *file_io_handle,
libfdata_area_t *area,
libfdata_cache_t *cache,
off64_t element_value_offset,
int element_data_file_index,
off64_t element_data_offset,
size64_t element_data_size,
uint32_t element_data_flags,
uint8_t read_flags,
libcerror_error_t **error ),
int (*write_element_data)(
intptr_t *data_handle,
intptr_t *file_io_handle,
libfdata_area_t *area,
libfdata_cache_t *cache,
off64_t element_value_offset,
int element_data_file_index,
off64_t element_data_offset,
size64_t element_data_size,
uint32_t element_data_flags,
uint8_t write_flags,
libcerror_error_t **error ),
uint8_t flags,
libcerror_error_t **error )
{
libfdata_internal_area_t *internal_area = NULL;
static char *function = "libfdata_area_initialize";
if( area == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid area.",
function );
return( -1 );
}
if( *area != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid area value already set.",
function );
return( -1 );
}
if( element_data_size == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS,
"%s: invalid element data size value zero or less.",
function );
return( -1 );
}
internal_area = memory_allocate_structure(
libfdata_internal_area_t );
if( internal_area == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create area.",
function );
goto on_error;
}
if( memory_set(
internal_area,
0,
sizeof( libfdata_internal_area_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear area.",
function );
memory_free(
internal_area );
return( -1 );
}
if( libcdata_array_initialize(
&( internal_area->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;
}
if( libcdata_array_initialize(
&( internal_area->mapped_ranges_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create mapped ranges array.",
function );
goto on_error;
}
if( libfcache_date_time_get_timestamp(
&( internal_area->timestamp ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve cache timestamp.",
function );
goto on_error;
}
internal_area->element_data_size = element_data_size;
internal_area->flags |= flags;
internal_area->data_handle = data_handle;
internal_area->free_data_handle = free_data_handle;
internal_area->clone_data_handle = clone_data_handle;
internal_area->read_element_data = read_element_data;
internal_area->write_element_data = write_element_data;
*area = (libfdata_area_t *) internal_area;
return( 1 );
on_error:
if( internal_area != NULL )
{
if( internal_area->segments_array != NULL )
{
libcdata_array_free(
&( internal_area->segments_array ),
NULL,
NULL );
}
memory_free(
internal_area );
}
return( -1 );
}
/* Creates an element
* Make sure the value element is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfdata_list_element_initialize(
libfdata_list_element_t **element,
libfdata_list_t *list,
int element_index,
libcerror_error_t **error )
{
libfdata_internal_list_element_t *internal_element = NULL;
static char *function = "libfdata_list_element_initialize";
if( element == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid element.",
function );
return( -1 );
}
if( *element != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid element value already set.",
function );
return( -1 );
}
if( list == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid list.",
function );
return( -1 );
}
if( element_index < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid element index value less than zero.",
function );
return( -1 );
}
internal_element = memory_allocate_structure(
libfdata_internal_list_element_t );
if( internal_element == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create element.",
function );
goto on_error;
}
if( memory_set(
internal_element,
0,
sizeof( libfdata_internal_list_element_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear element.",
function );
memory_free(
internal_element );
return( -1 );
}
if( libfdata_range_initialize(
&( internal_element->data_range ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create data range.",
function );
goto on_error;
}
internal_element->list = list;
internal_element->element_index = element_index;
internal_element->timestamp = libfcache_date_time_get_timestamp();
*element = (libfdata_list_element_t *) internal_element;
return( 1 );
on_error:
if( internal_element != NULL )
{
memory_free(
internal_element );
}
return( -1 );
}
/* Retrieves a specific message string
* Returns 1 if successful, 0 if no such message string or -1 error
*/
int resource_file_get_message_string(
resource_file_t *resource_file,
uint32_t message_string_identifier,
message_string_t **message_string,
libcerror_error_t **error )
{
static char *function = "resource_file_get_message_string";
uint32_t language_identifier = 0;
time_t timestamp = 0;
int result = 0;
if( resource_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid resource file.",
function );
return( -1 );
}
if( message_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid message string.",
function );
return( -1 );
}
if( resource_file->message_table_resource == NULL )
{
result = libwrc_stream_get_resource_by_type(
resource_file->resource_stream,
LIBWRC_RESOURCE_TYPE_MESSAGE_TABLE,
&( resource_file->message_table_resource ),
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve message table resource.",
function );
return( -1 );
}
else if( result == 0 )
{
return( 0 );
}
}
result = resource_file_get_message_string_from_cache(
resource_file,
message_string_identifier,
message_string,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve message string from cache.",
function );
return( -1 );
}
else if( result == 0 )
{
if( resource_file_get_resource_available_languague_identifier(
resource_file,
resource_file->message_table_resource,
&language_identifier,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve an available language identifier.",
function );
return( -1 );
}
*message_string = NULL;
if( message_string_initialize(
message_string,
message_string_identifier,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create message string.",
function );
return( -1 );
}
result = message_string_get_from_message_table_resource(
*message_string,
resource_file->message_table_resource,
language_identifier,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve message string: 0x%08" PRIx32 ".",
function,
message_string_identifier );
message_string_free(
message_string,
NULL );
return( -1 );
}
else if( result != 0 )
{
if( libfcache_date_time_get_timestamp(
×tamp,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve cache timestamp.",
function );
message_string_free(
message_string,
NULL );
return( -1 );
}
if( libfcache_cache_set_value_by_index(
resource_file->message_string_cache,
resource_file->next_message_string_cache_index,
0,
resource_file->next_message_string_cache_index,
timestamp,
(intptr_t *) *message_string,
(int (*)(intptr_t **, libcerror_error_t **)) &message_string_free,
LIBFCACHE_CACHE_VALUE_FLAG_MANAGED,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set message string in cache entry: %d.",
function,
resource_file->next_message_string_cache_index );
message_string_free(
message_string,
NULL );
return( -1 );
}
resource_file->next_message_string_cache_index++;
if( resource_file->next_message_string_cache_index == 16 )
{
resource_file->next_message_string_cache_index = 0;
}
message_string = NULL;
}
if( message_string != NULL )
{
if( message_string_free(
message_string,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free message string.",
function );
return( -1 );
}
}
}
return( result );
}
