/* Frees an info handle
* Returns 1 if successful or -1 on error
*/
int info_handle_free(
info_handle_t **info_handle,
libcerror_error_t **error )
{
static char *function = "info_handle_free";
int result = 1;
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 )
{
if( libvslvm_handle_free(
&( ( *info_handle )->input_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free input handle.",
function );
result = -1;
}
if( libbfio_pool_free(
&( ( *info_handle )->physical_volume_file_io_pool ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free physical volume file IO pool.",
function );
result = -1;
}
memory_free(
*info_handle );
*info_handle = NULL;
}
return( result );
}
/* Frees the write io handle including elements
* Returns 1 if successful or -1 on error
*/
int libewf_io_handle_free(
libewf_io_handle_t **io_handle,
liberror_error_t **error )
{
static char *function = "libewf_io_handle_free";
int result = 1;
if( io_handle == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid write io handle.",
function );
return( 1 );
}
if( *io_handle != NULL )
{
if( ( ( *io_handle )->pool_created_in_library != 0 )
&& ( ( *io_handle )->file_io_pool != NULL )
&& ( libbfio_pool_free(
&( ( *io_handle )->file_io_pool ),
error ) != 1 ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free file io pool.",
function );
result = -1;
}
memory_free(
*io_handle );
*io_handle = NULL;
}
return( result );
}
/* 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;
}
/* TODO control maximum number of handles */
if( libbfio_pool_initialize(
&( ( *info_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(
&( ( *info_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;
}
( *info_handle )->notify_stream = INFO_HANDLE_NOTIFY_STREAM;
return( 1 );
on_error:
if( *info_handle != NULL )
{
if( ( *info_handle )->physical_volume_file_io_pool != NULL )
{
libbfio_pool_free(
&( ( *info_handle )->physical_volume_file_io_pool ),
NULL );
}
memory_free(
*info_handle );
*info_handle = NULL;
}
return( -1 );
}
/* Initializes the file objects IO pool
* Returns 1 if successful or -1 on error
*/
int pyvslvm_file_objects_pool_initialize(
libbfio_pool_t **pool,
PyObject *sequence_object,
int access_flags,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
PyObject *file_object = NULL;
static char *function = "pyvslvm_file_objects_pool_initialize";
Py_ssize_t sequence_size = 0;
int element_index = 0;
int file_io_pool_entry = 0;
int number_of_elements = 0;
if( pool == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
if( *pool != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid pool value already set.",
function );
return( -1 );
}
sequence_size = PySequence_Size(
sequence_object );
if( sequence_size > (Py_ssize_t) INT_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid sequence size value exceeds maximum.",
function );
goto on_error;
}
number_of_elements = (int) sequence_size;
if( libbfio_pool_initialize(
pool,
0,
LIBBFIO_POOL_UNLIMITED_NUMBER_OF_OPEN_HANDLES,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create pool.",
function );
goto on_error;
}
for( element_index = 0;
element_index < number_of_elements;
element_index++ )
{
file_object = PySequence_GetItem(
sequence_object,
element_index );
if( file_object == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: missing file object IO handle.",
function );
goto on_error;
}
if( pyvslvm_file_object_initialize(
&file_io_handle,
file_object,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle.",
function );
goto on_error;
}
if( libbfio_pool_append_handle(
*pool,
&file_io_pool_entry,
file_io_handle,
access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append file IO handle to pool.",
function );
goto on_error;
}
file_io_handle = NULL;
}
return( 1 );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
if( *pool != NULL )
{
libbfio_pool_free(
pool,
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 );
}
/* Frees a mount handle
* Returns 1 if successful or -1 on error
*/
int mount_handle_free(
mount_handle_t **mount_handle,
libcerror_error_t **error )
{
static char *function = "mount_handle_free";
int result = 1;
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 )
{
if( libcdata_array_free(
&( ( *mount_handle )->logical_volumes_array ),
(int (*)(intptr_t **, libcerror_error_t **)) &libvslvm_logical_volume_free,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free logical volumes array.",
function );
result = -1;
}
if( ( *mount_handle )->volume_group != NULL )
{
if( libvslvm_volume_group_free(
&( ( *mount_handle )->volume_group ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free volume group.",
function );
result = -1;
}
}
if( libvslvm_handle_free(
&( ( *mount_handle )->input_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free input handle.",
function );
result = -1;
}
if( libbfio_pool_free(
&( ( *mount_handle )->physical_volume_file_io_pool ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free physical volume file IO pool.",
function );
result = -1;
}
if( libbfio_handle_free(
&( ( *mount_handle )->input_file_io_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free input file IO handle.",
function );
result = -1;
}
memory_free(
*mount_handle );
*mount_handle = NULL;
}
return( result );
}
