/* 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 ); }