/* Creates file information
* Make sure the value file_information is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libscca_file_information_initialize(
libscca_file_information_t **file_information,
libcerror_error_t **error )
{
static char *function = "libscca_file_information_initialize";
if( file_information == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file information.",
function );
return( -1 );
}
if( *file_information != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid file information value already set.",
function );
return( -1 );
}
*file_information = memory_allocate_structure(
libscca_file_information_t );
if( *file_information == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create file information.",
function );
goto on_error;
}
if( memory_set(
*file_information,
0,
sizeof( libscca_file_information_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear file.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *file_information != NULL )
{
memory_free(
*file_information );
*file_information = NULL;
}
return( -1 );
}
/* Creates a queue
* Make sure the value queue is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libcthreads_queue_initialize(
libcthreads_queue_t **queue,
int maximum_number_of_values,
libcerror_error_t **error )
{
libcthreads_internal_queue_t *internal_queue = NULL;
static char *function = "libcthreads_queue_initialize";
size_t values_array_size = 0;
if( queue == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid queue.",
function );
return( -1 );
}
if( *queue != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid queue value already set.",
function );
return( -1 );
}
if( maximum_number_of_values < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid maximum number of values value less than zero.",
function );
return( -1 );
}
#if SIZEOF_INT <= SIZEOF_SIZE_T
if( (size_t) maximum_number_of_values > (size_t) ( SSIZE_MAX / sizeof( intptr_t * ) ) )
#else
if( maximum_number_of_values > (int) ( SSIZE_MAX / sizeof( intptr_t * ) ) )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid maximum number of values value exceeds maximum.",
function );
return( -1 );
}
values_array_size = sizeof( intptr_t * ) * maximum_number_of_values;
if( values_array_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid values array size value exceeds maximum.",
function );
goto on_error;
}
internal_queue = memory_allocate_structure(
libcthreads_internal_queue_t );
if( internal_queue == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create queue.",
function );
goto on_error;
}
if( memory_set(
internal_queue,
0,
sizeof( libcthreads_internal_queue_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear queue.",
function );
memory_free(
internal_queue );
return( -1 );
}
internal_queue->values_array = (intptr_t **) memory_allocate(
values_array_size );
if( internal_queue->values_array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create values array.",
function );
goto on_error;
}
if( memory_set(
internal_queue->values_array,
0,
values_array_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear values array.",
function );
goto on_error;
}
internal_queue->allocated_number_of_values = maximum_number_of_values;
if( libcthreads_mutex_initialize(
&( internal_queue->condition_mutex ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create condition mutex.",
function );
goto on_error;
}
if( libcthreads_condition_initialize(
&( internal_queue->empty_condition ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create empty condition.",
function );
goto on_error;
}
if( libcthreads_condition_initialize(
&( internal_queue->full_condition ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create full condition.",
function );
goto on_error;
}
*queue = (libcthreads_queue_t *) internal_queue;
return( 1 );
on_error:
if( internal_queue != NULL )
{
if( internal_queue->empty_condition != NULL )
{
libcthreads_condition_free(
&( internal_queue->empty_condition ),
NULL );
}
if( internal_queue->condition_mutex != NULL )
{
libcthreads_mutex_free(
&( internal_queue->condition_mutex ),
NULL );
}
if( internal_queue->values_array != NULL )
{
memory_free(
internal_queue->values_array );
}
memory_free(
internal_queue );
}
return( -1 );
}
/* Creates a cache
* Make sure the value cache is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfcache_cache_initialize(
libfcache_cache_t **cache,
int maximum_cache_entries,
libcerror_error_t **error )
{
libfcache_internal_cache_t *internal_cache = NULL;
static char *function = "libfcache_cache_initialize";
if( cache == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid cache.",
function );
return( -1 );
}
if( *cache != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid cache value already set.",
function );
return( -1 );
}
if( maximum_cache_entries <= 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS,
"%s: invalid maximum cache entries value zero or less.",
function );
return( -1 );
}
internal_cache = memory_allocate_structure(
libfcache_internal_cache_t );
if( internal_cache == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create cache.",
function );
goto on_error;
}
if( memory_set(
internal_cache,
0,
sizeof( libfcache_internal_cache_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear cache.",
function );
goto on_error;
}
if( libcdata_array_initialize(
&( internal_cache->entries ),
maximum_cache_entries,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create entries array.",
function );
goto on_error;
}
*cache = (libfcache_cache_t *) internal_cache;
return( 1 );
on_error:
if( internal_cache != NULL )
{
memory_free(
internal_cache );
}
return( -1 );
}
/* Creates an IO handle
* Make sure the value io_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libevt_io_handle_initialize(
libevt_io_handle_t **io_handle,
libcerror_error_t **error )
{
static char *function = "libevt_io_handle_initialize";
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 != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid IO handle value already set.",
function );
return( -1 );
}
*io_handle = memory_allocate_structure(
libevt_io_handle_t );
if( *io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create IO handle.",
function );
goto on_error;
}
if( memory_set(
*io_handle,
0,
sizeof( libevt_io_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear file.",
function );
goto on_error;
}
( *io_handle )->ascii_codepage = LIBEVT_CODEPAGE_WINDOWS_1252;
return( 1 );
on_error:
if( *io_handle != NULL )
{
memory_free(
*io_handle );
*io_handle = NULL;
}
return( -1 );
}
/* Creates a mount handle
* Make sure the value mount_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int mount_handle_initialize(
mount_handle_t **mount_handle,
libcerror_error_t **error )
{
static char *function = "mount_handle_initialize";
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
if( *mount_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid mount handle value already set.",
function );
return( -1 );
}
*mount_handle = memory_allocate_structure(
mount_handle_t );
if( *mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create mount handle.",
function );
goto on_error;
}
if( memory_set(
*mount_handle,
0,
sizeof( mount_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear mount handle.",
function );
goto on_error;
}
if( libcdata_array_initialize(
&( ( *mount_handle )->input_files_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input files array.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *mount_handle != NULL )
{
memory_free(
*mount_handle );
*mount_handle = NULL;
}
return( -1 );
}
/* Sets an error and adds a system specific error string if possible
* Creates the error if necessary
* The error domain and code are set only the first time and the error message is appended for back tracing
*/
void VARARGS(
libcerror_system_set_error,
libcerror_error_t **error,
int error_domain,
int error_code,
uint32_t system_error_code,
const char *,
format_string )
{
va_list argument_list;
libcerror_internal_error_t *internal_error = NULL;
libcstring_system_character_t *system_format_string = NULL;
void *reallocation = NULL;
size_t format_string_length = 0;
size_t message_size = LIBCERROR_MESSAGE_INCREMENT_SIZE;
size_t string_index = 0;
int message_index = 0;
int print_count = 0;
if( error == NULL )
{
return;
}
if( format_string == NULL )
{
return;
}
format_string_length = libcstring_narrow_string_length(
format_string );
if( format_string_length > message_size )
{
message_size = ( ( format_string_length / LIBCERROR_MESSAGE_INCREMENT_SIZE ) + 1 )
* LIBCERROR_MESSAGE_INCREMENT_SIZE;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
do
{
reallocation = memory_reallocate(
system_format_string,
sizeof( libcstring_system_character_t ) * ( format_string_length + 1 ) );
if( reallocation == NULL )
{
goto on_error;
}
system_format_string = (libcstring_system_character_t *) reallocation;
#if defined( __BORLANDC__ ) || defined( _MSC_VER )
print_count = libcstring_wide_string_snwprintf(
system_format_string,
format_string_length + 1,
L"%S",
format_string );
#else
print_count = libcstring_wide_string_snwprintf(
system_format_string,
format_string_length + 1,
L"%s",
format_string );
#endif
if( print_count <= -1 )
{
format_string_length += LIBCERROR_MESSAGE_INCREMENT_SIZE;
}
else if( ( (size_t) print_count > format_string_length )
|| ( system_format_string[ print_count ] != 0 ) )
{
format_string_length = (size_t) print_count;
print_count = -1;
}
if( format_string_length >= LIBCERROR_MESSAGE_MAXIMUM_SIZE )
{
goto on_error;
}
}
while( print_count <= -1 );
#else
system_format_string = (libcstring_system_character_t *) format_string;
#endif
#if defined( __BORLANDC__ ) || defined( _MSC_VER )
/* Rewrite %s to %S
*/
string_index = 0;
while( string_index < format_string_length )
{
if( system_format_string[ string_index ] == 0 )
{
break;
}
else if( system_format_string[ string_index ] == (libcstring_system_character_t) '%' )
{
string_index++;
if( system_format_string[ string_index ] == (libcstring_system_character_t) 's' )
{
system_format_string[ string_index ] = (libcstring_system_character_t) 'S';
}
}
string_index++;
}
#endif
if( *error == NULL )
{
internal_error = memory_allocate_structure(
libcerror_internal_error_t );
if( internal_error == NULL )
{
goto on_error;
}
internal_error->domain = error_domain;
internal_error->code = error_code;
internal_error->number_of_messages = 0;
internal_error->messages = NULL;
internal_error->sizes = NULL;
*error = (libcerror_error_t *) internal_error;
}
else
{
internal_error = (libcerror_internal_error_t *) *error;
}
reallocation = memory_reallocate(
internal_error->messages,
sizeof( libcstring_system_character_t * ) * ( internal_error->number_of_messages + 1 ) );
if( reallocation == NULL )
{
goto on_error;
}
internal_error->messages = (libcstring_system_character_t **) reallocation;
reallocation = memory_reallocate(
internal_error->sizes,
sizeof( size_t ) * ( internal_error->number_of_messages + 1 ) );
if( reallocation == NULL )
{
goto on_error;
}
internal_error->sizes = (size_t *) reallocation;
message_index = internal_error->number_of_messages;
internal_error->messages[ message_index ] = NULL;
internal_error->sizes[ message_index ] = 0;
internal_error->number_of_messages += 1;
do
{
reallocation = memory_reallocate(
internal_error->messages[ message_index ],
sizeof( libcstring_system_character_t ) * message_size );
if( reallocation == NULL )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
break;
}
internal_error->messages[ message_index ] = (libcstring_system_character_t *) reallocation;
VASTART(
argument_list,
const char *,
format_string );
print_count = libcstring_system_string_vsprintf(
internal_error->messages[ message_index ],
message_size,
system_format_string,
argument_list );
VAEND(
argument_list );
if( print_count <= -1 )
{
message_size += LIBCERROR_MESSAGE_INCREMENT_SIZE;
}
else if( ( (size_t) print_count > message_size )
|| ( ( internal_error->messages[ message_index ] )[ print_count ] != 0 ) )
{
message_size = (size_t) ( print_count + 1 );
print_count = -1;
}
if( message_size >= LIBCERROR_MESSAGE_MAXIMUM_SIZE )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
internal_error->sizes[ message_index ] = 0;
break;
}
internal_error->sizes[ message_index ] = (size_t) print_count + 1;
}
while( print_count <= -1 );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
memory_free(
system_format_string );
system_format_string = NULL;
#endif
string_index = internal_error->sizes[ message_index ] - 1;
if( ( internal_error->messages[ message_index ] != NULL )
&& ( ( internal_error->messages[ message_index ] )[ string_index - 1 ] == (libcstring_system_character_t) '.' ) )
{
string_index -= 1;
}
reallocation = memory_reallocate(
internal_error->messages[ message_index ],
sizeof( libcstring_system_character_t ) * ( message_size + 13 + 512 ) );
if( reallocation == NULL )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
goto on_error;
}
internal_error->messages[ message_index ] = (libcstring_system_character_t *) reallocation;
if( libcstring_system_string_copy(
&( ( internal_error->messages[ message_index ] )[ string_index ] ),
_LIBCSTRING_SYSTEM_STRING( " with error: " ),
13 ) == NULL )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
goto on_error;
}
internal_error->sizes[ message_index ] += 13;
string_index += 13;
print_count = libcerror_system_copy_string_from_error_number(
&( ( internal_error->messages[ message_index ] )[ string_index ] ),
512,
system_error_code );
if( print_count == -1 )
{
goto on_error;
}
message_size += (size_t) print_count;
if( message_size >= LIBCERROR_MESSAGE_MAXIMUM_SIZE )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
internal_error->sizes[ message_index ] = 0;
goto on_error;
}
internal_error->sizes[ message_index ] += print_count;
return;
on_error:
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( system_format_string != NULL )
{
memory_free(
system_format_string );
}
#endif
if( ( *error == NULL )
&& ( internal_error != NULL ) )
{
memory_free(
internal_error );
}
return;
}
/* Creates a storage media buffer
* Make sure the value buffer is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int storage_media_buffer_initialize(
storage_media_buffer_t **buffer,
uint8_t mode,
size_t size,
libcerror_error_t **error )
{
static char *function = "storage_media_buffer_initialize";
size_t raw_buffer_size = 0;
if( buffer == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid buffer.",
function );
return( -1 );
}
if( *buffer != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid buffer value already set.",
function );
return( -1 );
}
if( ( mode != STORAGE_MEDIA_BUFFER_MODE_BUFFERED )
&& ( mode != STORAGE_MEDIA_BUFFER_MODE_CHUNK_DATA ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unusupported mode.",
function );
return( -1 );
}
if( size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid buffer size value exceeds maximum.",
function );
return( -1 );
}
*buffer = memory_allocate_structure(
storage_media_buffer_t );
if( *buffer == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create buffer.",
function );
goto on_error;
}
if( memory_set(
*buffer,
0,
sizeof( storage_media_buffer_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear buffer.",
function );
memory_free(
*buffer );
*buffer = NULL;
return( -1 );
}
if( size > 0 )
{
raw_buffer_size = size;
if( mode == STORAGE_MEDIA_BUFFER_MODE_CHUNK_DATA )
{
/* Add 4 bytes to allow for write checksum buffer alignment
*/
raw_buffer_size += 4;
}
/* TODO can low level functions and direct IO be combined ? */
#if defined( memory_allocate_aligned )
if( memory_allocate_aligned(
(void **) &( ( *buffer )->raw_buffer ),
raw_buffer_size,
512 ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create aligned raw buffer.",
function );
goto on_error;
}
#else
( *buffer )->raw_buffer = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * raw_buffer_size );
if( ( *buffer )->raw_buffer == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create raw buffer.",
function );
goto on_error;
}
#endif /* defined( memory_allocate_aligned ) */
( *buffer )->raw_buffer_size = size;
if( mode == STORAGE_MEDIA_BUFFER_MODE_CHUNK_DATA )
{
( *buffer )->checksum_buffer = &( ( ( *buffer )->raw_buffer )[ size ] );
( *buffer )->compression_buffer = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * ( size * 2 ) );
if( ( *buffer )->compression_buffer == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create compression buffer.",
function );
goto on_error;
}
( *buffer )->compression_buffer_size = size * 2;
}
}
( *buffer )->mode = mode;
return( 1 );
on_error:
if( *buffer != NULL )
{
if( ( *buffer )->raw_buffer != NULL )
{
memory_free(
( *buffer )->raw_buffer );
}
memory_free(
*buffer );
*buffer = NULL;
}
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,
libcerror_error_t **error )
{
static char *function = "libewf_segment_file_handle_initialize";
if( segment_file_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment file handle.",
function );
return( -1 );
}
if( *segment_file_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid segment file handle value already set.",
function );
return( -1 );
}
if( segment_file_index < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid segment file index value less than zero.",
function );
return( -1 );
}
*segment_file_handle = memory_allocate_structure(
libewf_segment_file_handle_t );
if( *segment_file_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_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 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_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 section descriptor
* Returns 1 if successful or -1 on error
*/
int libewf_section_descriptor_clone(
libewf_section_descriptor_t **destination_section_descriptor,
libewf_section_descriptor_t *source_section_descriptor,
libcerror_error_t **error )
{
static char *function = "libewf_section_descriptor_clone";
if( destination_section_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid destination section descriptor.",
function );
return( -1 );
}
if( *destination_section_descriptor != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid destination section descriptor value already set.",
function );
return( -1 );
}
if( source_section_descriptor == NULL )
{
*destination_section_descriptor = NULL;
return( 1 );
}
*destination_section_descriptor = memory_allocate_structure(
libewf_section_descriptor_t );
if( *destination_section_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create destination section descriptor.",
function );
goto on_error;
}
if( memory_copy(
*destination_section_descriptor,
source_section_descriptor,
sizeof( libewf_section_descriptor_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy source to destination section descriptor.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *destination_section_descriptor != NULL )
{
memory_free(
*destination_section_descriptor );
*destination_section_descriptor = NULL;
}
return( -1 );
}
/* Creates an info handle
* Make sure the value info_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int info_handle_initialize(
info_handle_t **info_handle,
libcerror_error_t **error )
{
static char *function = "info_handle_initialize";
if( info_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid info handle.",
function );
return( -1 );
}
if( *info_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid info handle value already set.",
function );
return( -1 );
}
*info_handle = memory_allocate_structure(
info_handle_t );
if( *info_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create info handle.",
function );
goto on_error;
}
if( memory_set(
*info_handle,
0,
sizeof( info_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear info handle.",
function );
goto on_error;
}
if( libevt_file_initialize(
&( ( *info_handle )->input_file ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input file.",
function );
goto on_error;
}
( *info_handle )->event_log_type = EVTTOOLS_EVENT_LOG_TYPE_UNKNOWN;
( *info_handle )->ascii_codepage = LIBEVT_CODEPAGE_WINDOWS_1252;
( *info_handle )->notify_stream = INFO_HANDLE_NOTIFY_STREAM;
return( 1 );
on_error:
if( *info_handle != NULL )
{
memory_free(
*info_handle );
*info_handle = NULL;
}
return( -1 );
}
/* Creates a channel
* Make sure the value channel is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfwevt_channel_initialize(
libfwevt_channel_t **channel,
libcerror_error_t **error )
{
libfwevt_internal_channel_t *internal_channel = NULL;
static char *function = "libfwevt_channel_initialize";
if( channel == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid channel.",
function );
return( -1 );
}
if( *channel != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid channel value already set.",
function );
return( -1 );
}
internal_channel = memory_allocate_structure(
libfwevt_internal_channel_t );
if( internal_channel == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create channel.",
function );
goto on_error;
}
if( memory_set(
internal_channel,
0,
sizeof( libfwevt_internal_channel_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear channel.",
function );
goto on_error;
}
*channel = (libfwevt_channel_t *) internal_channel;
return( 1 );
on_error:
if( internal_channel != NULL )
{
memory_free(
internal_channel );
}
return( -1 );
}
/* Creates an array
* Make sure the value array is pointing to is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfvalue_array_initialize(
libfvalue_array_t **array,
int number_of_entries,
liberror_error_t **error )
{
static char *function = "libfvalue_array_initialize";
size_t entries_size = 0;
if( array == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
if( *array != NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid array value already set.",
function );
return( -1 );
}
if( number_of_entries < 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid number of entries.",
function );
return( -1 );
}
*array = memory_allocate_structure(
libfvalue_array_t );
if( *array == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create array.",
function );
goto on_error;
}
if( memory_set(
*array,
0,
sizeof( libfvalue_array_t ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear array.",
function );
goto on_error;
}
if( number_of_entries > 0 )
{
entries_size = sizeof( intptr_t * ) * number_of_entries;
if( entries_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid entries size value exceeds maximum.",
function );
goto on_error;
}
( *array )->entries = (intptr_t **) memory_allocate(
entries_size );
if( ( *array )->entries == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create array entries.",
function );
goto on_error;
}
if( memory_set(
( *array )->entries,
0,
entries_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear array entries.",
function );
goto on_error;
}
( *array )->number_of_allocated_entries = number_of_entries;
( *array )->number_of_entries = number_of_entries;
}
return( 1 );
on_error:
if( *array != NULL )
{
if( ( *array )->entries != NULL )
{
memory_free(
( *array )->entries );
}
memory_free(
*array );
*array = NULL;
}
return( -1 );
}
/* Creates a resource file
* Make sure the value resource_file is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int resource_file_initialize(
resource_file_t **resource_file,
uint32_t preferred_language_identifier,
libcerror_error_t **error )
{
static char *function = "resource_file_initialize";
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( *resource_file != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid resource file value already set.",
function );
return( -1 );
}
*resource_file = memory_allocate_structure(
resource_file_t );
if( *resource_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create resource file.",
function );
goto on_error;
}
if( memory_set(
*resource_file,
0,
sizeof( resource_file_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear resource file.",
function );
memory_free(
*resource_file );
*resource_file = NULL;
return( -1 );
}
if( libexe_file_initialize(
&( ( *resource_file )->exe_file ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create EXE file.",
function );
goto on_error;
}
if( libwrc_stream_initialize(
&( ( *resource_file )->resource_stream ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create resource stream.",
function );
goto on_error;
}
if( libfcache_cache_initialize(
&( ( *resource_file )->message_string_cache ),
16,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create message string cache.",
function );
goto on_error;
}
( *resource_file )->preferred_language_identifier = preferred_language_identifier;
return( 1 );
on_error:
if( *resource_file != NULL )
{
if( ( *resource_file )->resource_stream != NULL )
{
libwrc_stream_free(
&( ( *resource_file )->resource_stream ),
NULL );
}
if( ( *resource_file )->exe_file != NULL )
{
libexe_file_free(
&( ( *resource_file )->exe_file ),
NULL );
}
memory_free(
*resource_file );
*resource_file = NULL;
}
return( -1 );
}
/* Clones the range list value
*
* The values are cloned using the value_clone_function
* On error the values are freed using the value_free_function
*
* Returns 1 if successful or -1 on error
*/
int libcdata_range_list_value_clone(
libcdata_range_list_value_t **destination_range_list_value,
libcdata_range_list_value_t *source_range_list_value,
int (*value_free_function)(
intptr_t **value,
libcerror_error_t **error ),
int (*value_clone_function)(
intptr_t **destination_value,
intptr_t *source_value,
libcerror_error_t **error ),
libcerror_error_t **error )
{
static char *function = "libcdata_range_list_value_clone";
if( destination_range_list_value == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid destination range list value.",
function );
return( -1 );
}
if( *destination_range_list_value != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid destination range list value value already set.",
function );
return( -1 );
}
if( value_free_function == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid value free function.",
function );
return( -1 );
}
if( value_clone_function == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid value clone function.",
function );
return( -1 );
}
if( source_range_list_value == NULL )
{
*destination_range_list_value = NULL;
return( 1 );
}
*destination_range_list_value = memory_allocate_structure(
libcdata_range_list_value_t );
if( *destination_range_list_value == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create destination range list value.",
function );
goto on_error;
}
if( memory_copy(
*destination_range_list_value,
source_range_list_value,
sizeof( libcdata_range_list_value_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy source to destination range list value.",
function );
memory_free(
*destination_range_list_value );
*destination_range_list_value = NULL;
return( -1 );
}
( *destination_range_list_value )->value = NULL;
if( value_clone_function(
&( ( *destination_range_list_value )->value ),
source_range_list_value->value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create destination value.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *destination_range_list_value != NULL )
{
if( ( *destination_range_list_value )->value != NULL )
{
value_free_function(
&( ( *destination_range_list_value )->value ),
NULL );
}
memory_free(
*destination_range_list_value );
*destination_range_list_value = NULL;
}
return( -1 );
}
/* Creates a mount handle
* Make sure the value mount_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int mount_handle_initialize(
mount_handle_t **mount_handle,
libcerror_error_t **error )
{
static char *function = "mount_handle_initialize";
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
if( *mount_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid mount handle value already set.",
function );
return( -1 );
}
*mount_handle = memory_allocate_structure(
mount_handle_t );
if( *mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create mount handle.",
function );
goto on_error;
}
if( memory_set(
*mount_handle,
0,
sizeof( mount_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear mount handle.",
function );
goto on_error;
}
if( mount_file_system_initialize(
&( ( *mount_handle )->file_system ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize file system.",
function );
goto on_error;
}
( *mount_handle )->ascii_codepage = LIBREGF_CODEPAGE_WINDOWS_1252;
return( 1 );
on_error:
if( *mount_handle != NULL )
{
memory_free(
*mount_handle );
*mount_handle = NULL;
}
return( -1 );
}
/* Creates a section descriptor
* Make sure the value section_descriptor is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libewf_section_descriptor_initialize(
libewf_section_descriptor_t **section_descriptor,
libcerror_error_t **error )
{
static char *function = "libewf_section_descriptor_initialize";
if( section_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid section descriptor.",
function );
return( -1 );
}
if( *section_descriptor != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid section descriptor value already set.",
function );
return( -1 );
}
*section_descriptor = memory_allocate_structure(
libewf_section_descriptor_t );
if( *section_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create section descriptor.",
function );
goto on_error;
}
if( memory_set(
*section_descriptor,
0,
sizeof( libewf_section_descriptor_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear section descriptor.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *section_descriptor != NULL )
{
memory_free(
*section_descriptor );
*section_descriptor = NULL;
}
return( -1 );
}
/* Creates a mount handle
* Make sure the value mount_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int mount_handle_initialize(
mount_handle_t **mount_handle,
libcerror_error_t **error )
{
static char *function = "mount_handle_initialize";
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
if( *mount_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid mount handle value already set.",
function );
return( -1 );
}
*mount_handle = memory_allocate_structure(
mount_handle_t );
if( *mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create mount handle.",
function );
goto on_error;
}
if( memory_set(
*mount_handle,
0,
sizeof( mount_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear mount handle.",
function );
memory_free(
*mount_handle );
*mount_handle = NULL;
return( -1 );
}
if( libbfio_file_range_initialize(
&( ( *mount_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;
}
/* TODO control maximum number of handles */
if( libbfio_pool_initialize(
&( ( *mount_handle )->physical_volume_file_io_pool ),
0,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize physical volume file IO pool.",
function );
goto on_error;
}
if( libvslvm_handle_initialize(
&( ( *mount_handle )->input_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input handle.",
function );
goto on_error;
}
if( libcdata_array_initialize(
&( ( *mount_handle )->logical_volumes_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize logical volumes array.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *mount_handle != NULL )
{
if( ( *mount_handle )->input_handle != NULL )
{
libvslvm_handle_free(
&( ( *mount_handle )->input_handle ),
NULL );
}
if( ( *mount_handle )->physical_volume_file_io_pool != NULL )
{
libbfio_pool_free(
&( ( *mount_handle )->physical_volume_file_io_pool ),
NULL );
}
if( ( *mount_handle )->input_file_io_handle != NULL )
{
libbfio_handle_free(
&( ( *mount_handle )->input_file_io_handle ),
NULL );
}
memory_free(
*mount_handle );
*mount_handle = NULL;
}
return( -1 );
}
/* Creates distributed link tracker properties
* Make sure the value distributed_link_tracker_properties is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int liblnk_distributed_link_tracker_properties_initialize(
liblnk_distributed_link_tracker_properties_t **distributed_link_tracker_properties,
libcerror_error_t **error )
{
static char *function = "liblnk_distributed_link_tracker_properties_initialize";
if( distributed_link_tracker_properties == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid distributed link tracker properties.",
function );
return( -1 );
}
if( *distributed_link_tracker_properties != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid distributed link tracker properties value already set.",
function );
return( -1 );
}
*distributed_link_tracker_properties = memory_allocate_structure(
liblnk_distributed_link_tracker_properties_t );
if( *distributed_link_tracker_properties == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create distributed link tracker properties.",
function );
goto on_error;
}
if( memory_set(
*distributed_link_tracker_properties,
0,
sizeof( liblnk_distributed_link_tracker_properties_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear distributed link tracker properties.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *distributed_link_tracker_properties != NULL )
{
memory_free(
*distributed_link_tracker_properties );
*distributed_link_tracker_properties = NULL;
}
return( -1 );
}
/* Creates a key protector
* Make sure the value key_protector is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libbde_key_protector_initialize(
libbde_key_protector_t **key_protector,
libbde_volume_master_key_t *volume_master_key,
libcerror_error_t **error )
{
libbde_internal_key_protector_t *internal_key_protector = NULL;
static char *function = "libbde_key_protector_initialize";
if( key_protector == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid key protector.",
function );
return( -1 );
}
if( *key_protector != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid key protector value already set.",
function );
return( -1 );
}
internal_key_protector = memory_allocate_structure(
libbde_internal_key_protector_t );
if( internal_key_protector == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create key protector.",
function );
goto on_error;
}
if( memory_set(
internal_key_protector,
0,
sizeof( libbde_internal_key_protector_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear key protector.",
function );
memory_free(
internal_key_protector );
return( -1 );
}
internal_key_protector->volume_master_key = volume_master_key;
*key_protector = (libbde_key_protector_t *) internal_key_protector;
return( 1 );
on_error:
if( internal_key_protector != NULL )
{
memory_free(
internal_key_protector );
}
return( -1 );
}
/* Creates a registry file
* Make sure the value registry_file is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int registry_file_initialize(
registry_file_t **registry_file,
libcerror_error_t **error )
{
static char *function = "registry_file_initialize";
if( registry_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid registry file.",
function );
return( -1 );
}
if( *registry_file != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid registry file value already set.",
function );
return( -1 );
}
*registry_file = memory_allocate_structure(
registry_file_t );
if( *registry_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create registry file.",
function );
goto on_error;
}
if( memory_set(
*registry_file,
0,
sizeof( registry_file_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear registry file.",
function );
memory_free(
*registry_file );
*registry_file = NULL;
return( -1 );
}
if( libregf_file_initialize(
&( ( *registry_file )->regf_file ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize REGF file.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *registry_file != NULL )
{
memory_free(
*registry_file );
*registry_file = NULL;
}
return( -1 );
}
/* Creates a file system
* Make sure the value file_system is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int mount_file_system_initialize(
mount_file_system_t **file_system,
libcerror_error_t **error )
{
#if defined( WINAPI )
FILETIME filetime;
SYSTEMTIME systemtime;
#elif defined( HAVE_CLOCK_GETTIME )
struct timespec time_structure;
#endif
static char *function = "mount_file_system_initialize";
#if defined( WINAPI )
DWORD error_code = 0;
#else
int64_t timestamp = 0;
#endif
if( file_system == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file system.",
function );
return( -1 );
}
if( *file_system != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid file system value already set.",
function );
return( -1 );
}
*file_system = memory_allocate_structure(
mount_file_system_t );
if( *file_system == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create file system.",
function );
goto on_error;
}
if( memory_set(
*file_system,
0,
sizeof( mount_file_system_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear file system.",
function );
memory_free(
*file_system );
*file_system = NULL;
return( -1 );
}
if( libcdata_array_initialize(
&( ( *file_system )->stores_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize stores array.",
function );
goto on_error;
}
#if defined( WINAPI )
if( memory_set(
&systemtime,
0,
sizeof( SYSTEMTIME ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear systemtime.",
function );
goto on_error;
}
GetSystemTime(
&systemtime );
if( SystemTimeToFileTime(
&systemtime,
&filetime ) == 0 )
{
error_code = GetLastError();
libcerror_system_set_error(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
error_code,
"%s: unable to retrieve FILETIME of current time.",
function );
goto on_error;
}
( *file_system )->mounted_timestamp = ( (uint64_t) filetime.dwHighDateTime << 32 ) | filetime.dwLowDateTime;
#elif defined( HAVE_CLOCK_GETTIME )
if( clock_gettime(
CLOCK_REALTIME,
&time_structure ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve current time structure.",
function );
goto on_error;
}
timestamp = ( (int64_t) time_structure.tv_sec * 1000000000 ) + time_structure.tv_nsec;
( *file_system )->mounted_timestamp = (uint64_t) timestamp;
#else
timestamp = (int64_t) time( NULL );
if( timestamp == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve current time.",
function );
goto on_error;
}
timestamp *= 1000000000;
( *file_system )->mounted_timestamp = (uint64_t) timestamp;
#endif /* defined( HAVE_CLOCK_GETTIME ) */
return( 1 );
on_error:
if( *file_system != NULL )
{
memory_free(
*file_system );
*file_system = NULL;
}
return( -1 );
}
/* Creates an attached file IO handle
* Make sure the value io_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libpff_attached_file_io_handle_initialize(
libpff_attached_file_io_handle_t **io_handle,
libpff_item_t *attachment,
libcerror_error_t **error )
{
static char *function = "libpff_attached_file_io_handle_initialize";
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 != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid IO handle value already set.",
function );
return( -1 );
}
if( attachment == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid attachment.",
function );
return( -1 );
}
*io_handle = memory_allocate_structure(
libpff_attached_file_io_handle_t );
if( *io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create IO handle.",
function );
goto on_error;
}
if( memory_set(
*io_handle,
0,
sizeof( libpff_attached_file_io_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear IO handle.",
function );
goto on_error;
}
( *io_handle )->attachment = attachment;
return( 1 );
on_error:
if( *io_handle != NULL )
{
memory_free(
*io_handle );
*io_handle = NULL;
}
return( -1 );
}
/* Creates an export handle
* Make sure the value export_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int export_handle_initialize(
export_handle_t **export_handle,
libcerror_error_t **error )
{
static char *function = "export_handle_initialize";
if( export_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid export handle.",
function );
return( -1 );
}
if( *export_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid export handle value already set.",
function );
return( -1 );
}
*export_handle = memory_allocate_structure(
export_handle_t );
if( *export_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create export handle.",
function );
goto on_error;
}
if( memory_set(
*export_handle,
0,
sizeof( export_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear export handle.",
function );
goto on_error;
}
if( libwtcdb_file_initialize(
&( ( *export_handle )->input_file ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input file.",
function );
goto on_error;
}
( *export_handle )->notify_stream = EXPORT_HANDLE_NOTIFY_STREAM;
return( 1 );
on_error:
if( *export_handle != NULL )
{
memory_free(
*export_handle );
*export_handle = NULL;
}
return( -1 );
}
/* Creates a section
* Make sure the value section is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libexe_section_initialize(
libexe_section_t **section,
libexe_io_handle_t *io_handle,
libbfio_handle_t *file_io_handle,
libexe_section_descriptor_t *section_descriptor,
libcerror_error_t **error )
{
libexe_internal_section_t *internal_section = NULL;
static char *function = "libexe_section_initialize";
if( section == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid section.",
function );
return( -1 );
}
if( *section != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid section value already set.",
function );
return( -1 );
}
if( section_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid section descriptor.",
function );
return( -1 );
}
internal_section = memory_allocate_structure(
libexe_internal_section_t );
if( internal_section == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create internal section.",
function );
goto on_error;
}
if( memory_set(
internal_section,
0,
sizeof( libexe_internal_section_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear internal section.",
function );
memory_free(
internal_section );
return( -1 );
}
internal_section->file_io_handle = file_io_handle;
internal_section->io_handle = io_handle;
internal_section->section_descriptor = section_descriptor;
*section = (libexe_section_t *) internal_section;
return( 1 );
on_error:
if( internal_section != NULL )
{
memory_free(
internal_section );
}
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 libfusn_record_initialize(
libfusn_record_t **record,
libcerror_error_t **error )
{
libfusn_internal_record_t *internal_record = NULL;
static char *function = "libfusn_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(
libfusn_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( libfusn_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 = (libfusn_record_t *) internal_record;
return( 1 );
on_error:
if( internal_record != NULL )
{
memory_free(
internal_record );
}
return( -1 );
}
/* Creates a page value
* Make sure the value page_value is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libesedb_page_value_initialize(
libesedb_page_value_t **page_value,
libcerror_error_t **error )
{
static char *function = "libesedb_page_value_initialize";
if( page_value == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid page value.",
function );
return( -1 );
}
if( *page_value != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid page value value already set.",
function );
return( -1 );
}
*page_value = memory_allocate_structure(
libesedb_page_value_t );
if( *page_value == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create page value.",
function );
goto on_error;
}
if( memory_set(
*page_value,
0,
sizeof( libesedb_page_value_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear page value.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *page_value != NULL )
{
memory_free(
*page_value );
*page_value = NULL;
}
return( -1 );
}
/* Creates control panel category values
* Make sure the value control_panel_category_values is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfwsi_control_panel_category_values_initialize(
libfwsi_control_panel_category_values_t **control_panel_category_values,
libcerror_error_t **error )
{
static char *function = "libfwsi_control_panel_category_values_initialize";
if( control_panel_category_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid control panel category values.",
function );
return( -1 );
}
if( *control_panel_category_values != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid control panel category values value already set.",
function );
return( -1 );
}
*control_panel_category_values = memory_allocate_structure(
libfwsi_control_panel_category_values_t );
if( *control_panel_category_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create control panel category values.",
function );
goto on_error;
}
if( memory_set(
*control_panel_category_values,
0,
sizeof( libfwsi_control_panel_category_values_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear control panel category values.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *control_panel_category_values != NULL )
{
memory_free(
*control_panel_category_values );
*control_panel_category_values = NULL;
}
return( -1 );
}
/* Creates a catalog
* Make sure the value catalog is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libesedb_catalog_initialize(
libesedb_catalog_t **catalog,
libcerror_error_t **error )
{
static char *function = "libesedb_catalog_initialize";
if( catalog == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid catalog.",
function );
return( -1 );
}
if( *catalog != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid catalog value already set.",
function );
return( -1 );
}
*catalog = memory_allocate_structure(
libesedb_catalog_t );
if( *catalog == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create catalog.",
function );
goto on_error;
}
if( memory_set(
*catalog,
0,
sizeof( libesedb_catalog_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear catalog.",
function );
goto on_error;
}
if( libcdata_list_initialize(
&( ( *catalog )->table_definition_list ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create table definition list.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *catalog != NULL )
{
memory_free(
*catalog );
*catalog = NULL;
}
return( -1 );
}
/* 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 );
memory_free(
internal_condition );
return( -1 );
}
#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 );
switch( pthread_result )
{
case 0:
break;
case EAGAIN:
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to initialize condition with error: Insufficient resources.",
function );
goto on_error;
default:
libcerror_system_set_error(
error,
pthread_result,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_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 );
}
/* Creates a store block
* Make sure the value store_block is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libvshadow_store_block_initialize(
libvshadow_store_block_t **store_block,
size_t block_size,
libcerror_error_t **error )
{
static char *function = "libvshadow_store_block_initialize";
if( store_block == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid store block.",
function );
return( -1 );
}
if( *store_block != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid store block value already set.",
function );
return( -1 );
}
if( block_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid block size value exceeds maximum.",
function );
return( -1 );
}
*store_block = memory_allocate_structure(
libvshadow_store_block_t );
if( store_block == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create store block.",
function );
goto on_error;
}
if( memory_set(
*store_block,
0,
sizeof( libvshadow_store_block_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear store block.",
function );
goto on_error;
}
( *store_block )->data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * block_size );
if( ( *store_block )->data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create store block data.",
function );
goto on_error;
}
( *store_block )->data_size = block_size;
return( 1 );
on_error:
if( *store_block != NULL )
{
memory_free(
*store_block );
*store_block = NULL;
}
return( -1 );
}
