/* Creates a volume
* ake sure the value volume is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libvshadow_volume_initialize(
libvshadow_volume_t **volume,
libcerror_error_t **error )
{
libvshadow_internal_volume_t *internal_volume = NULL;
static char *function = "libvshadow_volume_initialize";
if( volume == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid volume.",
function );
return( -1 );
}
if( *volume != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid volume value already set.",
function );
return( -1 );
}
internal_volume = memory_allocate_structure(
libvshadow_internal_volume_t );
if( internal_volume == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create volume.",
function );
goto on_error;
}
if( memory_set(
internal_volume,
0,
sizeof( libvshadow_internal_volume_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear volume.",
function );
memory_free(
internal_volume );
return( -1 );
}
if( libcdata_array_initialize(
&( internal_volume->store_descriptors_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create store descriptors array.",
function );
goto on_error;
}
if( libvshadow_io_handle_initialize(
&( internal_volume->io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create IO handle.",
function );
goto on_error;
}
#if defined( HAVE_LIBVSHADOW_MULTI_THREAD_SUPPORT )
if( libcthreads_read_write_lock_initialize(
&( internal_volume->read_write_lock ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to intialize read/write lock.",
function );
goto on_error;
}
#endif
*volume = (libvshadow_volume_t *) internal_volume;
return( 1 );
on_error:
if( internal_volume != NULL )
{
if( internal_volume->store_descriptors_array != NULL )
{
libcdata_array_free(
&( internal_volume->store_descriptors_array ),
(int (*)(intptr_t **, libcerror_error_t **)) &libvshadow_store_descriptor_free,
NULL );
}
memory_free(
internal_volume );
}
return( -1 );
}
/* Creates an array
* Make sure the value array is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libcdata_array_initialize(
libcdata_array_t **array,
int number_of_entries,
libcerror_error_t **error )
{
libcdata_internal_array_t *internal_array = NULL;
static char *function = "libcdata_array_initialize";
size_t entries_size = 0;
int number_of_allocated_entries = 0;
if( array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
if( *array != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid array value already set.",
function );
return( -1 );
}
if( number_of_entries < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid number of entries value less than zero.",
function );
return( -1 );
}
internal_array = memory_allocate_structure(
libcdata_internal_array_t );
if( internal_array == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create array.",
function );
goto on_error;
}
if( memory_set(
internal_array,
0,
sizeof( libcdata_internal_array_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear array.",
function );
memory_free(
internal_array );
return( -1 );
}
/* Pre-allocate in blocks of 16 entries
*/
number_of_allocated_entries = ( number_of_entries & ~( 15 ) ) + 16;
#if SIZEOF_INT <= SIZEOF_SIZE_T
if( (size_t) number_of_allocated_entries > (size_t) ( SSIZE_MAX / sizeof( intptr_t * ) ) )
#else
if( number_of_allocated_entries > (int) ( SSIZE_MAX / sizeof( intptr_t * ) ) )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid number of allocated entries value exceeds maximum.",
function );
goto on_error;
}
entries_size = sizeof( intptr_t * ) * number_of_allocated_entries;
if( entries_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid entries size value exceeds maximum.",
function );
goto on_error;
}
internal_array->entries = (intptr_t **) memory_allocate(
entries_size );
if( internal_array->entries == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create array entries.",
function );
goto on_error;
}
if( memory_set(
internal_array->entries,
0,
entries_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear array entries.",
function );
goto on_error;
}
internal_array->number_of_allocated_entries = number_of_allocated_entries;
internal_array->number_of_entries = number_of_entries;
#if defined( HAVE_MULTI_THREAD_SUPPORT ) && !defined( HAVE_LOCAL_LIBCDATA )
if( libcthreads_read_write_lock_initialize(
&( internal_array->read_write_lock ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to intialize read/write lock.",
function );
goto on_error;
}
#endif
*array = (libcdata_array_t *) internal_array;
return( 1 );
on_error:
if( internal_array != NULL )
{
if( internal_array->entries != NULL )
{
memory_free(
internal_array->entries );
}
memory_free(
internal_array );
}
return( -1 );
}
/* Creates a data chunk
* Make sure the value data_chunk is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libewf_data_chunk_initialize(
libewf_data_chunk_t **data_chunk,
libewf_io_handle_t *io_handle,
libewf_write_io_handle_t *write_io_handle,
libcerror_error_t **error )
{
libewf_internal_data_chunk_t *internal_data_chunk = NULL;
static char *function = "libewf_data_chunk_initialize";
if( data_chunk == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data chunk.",
function );
return( -1 );
}
if( *data_chunk != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid data chunk value already set.",
function );
return( -1 );
}
if( io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid IO handle.",
function );
return( -1 );
}
internal_data_chunk = memory_allocate_structure(
libewf_internal_data_chunk_t );
if( internal_data_chunk == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create data chunk.",
function );
goto on_error;
}
if( memory_set(
internal_data_chunk,
0,
sizeof( libewf_internal_data_chunk_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear data chunk.",
function );
memory_free(
internal_data_chunk );
return( -1 );
}
#if defined( HAVE_LIBEWF_MULTI_THREAD_SUPPORT )
if( libcthreads_read_write_lock_initialize(
&( internal_data_chunk->read_write_lock ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize read/write lock.",
function );
goto on_error;
}
#endif
internal_data_chunk->io_handle = io_handle;
internal_data_chunk->write_io_handle = write_io_handle;
*data_chunk = (libewf_data_chunk_t *) internal_data_chunk;
return( 1 );
on_error:
if( internal_data_chunk != NULL )
{
memory_free(
internal_data_chunk );
}
return( -1 );
}
