/* Copies a byte string to a character string
* and trims whitespace and non readable characters
* Returns the resulting string length if successful or -1 on error
*/
ssize_t libtableau_string_trim_copy(
uint8_t *destination,
const uint8_t *source,
size_t source_length,
libcerror_error_t **error )
{
static char *function = "libtableau_string_trim_copy";
ssize_t first_character = 0;
ssize_t last_character = 0;
if( destination == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid destination.",
function );
return( -1 );
}
if( source == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid source.",
function );
return( -1 );
}
if( source_length > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid source length value exceeds maximum.",
function );
return( -1 );
}
for( first_character = 0;
first_character < (ssize_t) source_length;
first_character++ )
{
if( ( source[ first_character ] >= (uint8_t) 0x21 )
&& ( source[ first_character ] <= (uint8_t) 0x7e ) )
{
break;
}
}
for( last_character = (ssize_t) ( source_length - 1 );
last_character >= 0;
last_character-- )
{
if( ( source[ last_character ] >= (uint8_t) 0x21 )
&& ( source[ last_character ] <= (uint8_t) 0x7e ) )
{
break;
}
}
if( last_character <= first_character )
{
return( 0 );
}
last_character -= first_character - 1;
if( narrow_string_copy(
destination,
&( source[ first_character ] ),
last_character ) != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy trimmed string.",
function );
return( -1 );
}
destination[ last_character + 1 ] = 0;
return( last_character );
}
/* Set a value in the values table
* Frees the previous value if necessary
* Returns 1 if successful or -1 on error
*/
int libewf_values_table_set_identifier(
libewf_values_table_t *values_table,
int index,
const uint8_t *identifier,
size_t identifier_length,
liberror_error_t **error )
{
static char *function = "libewf_values_table_set_identifier";
if( values_table == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid values table.",
function );
return( -1 );
}
if( identifier == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid identifier.",
function );
return( -1 );
}
if( identifier_length == 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS,
"%s: invalid identifier length value is zero.",
function );
return( -1 );
}
if( identifier_length > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid identifier length value exceeds maximum.",
function );
return( -1 );
}
if( ( values_table->amount_of_values == 0 )
|| ( index < 0 )
|| ( index >= values_table->amount_of_values ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_OUT_OF_RANGE,
"%s: invalid index out of range.",
function );
return( -1 );
}
/* Remove exisiting identifiers
*/
if( values_table->identifier[ index ] != NULL )
{
memory_free(
values_table->identifier[ index ] );
values_table->identifier[ index ] = NULL;
}
/* Do not include the end of string character in the identifier length
*/
if( identifier[ identifier_length - 1 ] == 0 )
{
identifier_length -= 1;
}
values_table->identifier_length[ index ] = identifier_length;
values_table->identifier[ index ] = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * ( values_table->identifier_length[ index ] + 1 ) );
if( values_table->identifier[ index ] == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create identifier.",
function );
return( -1 );
}
if( narrow_string_copy(
(char *) values_table->identifier[ index ],
(char *) identifier,
identifier_length ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to set identifier.",
function );
memory_free(
values_table->identifier[ index ] );
values_table->identifier[ index ] = NULL;
values_table->identifier_length[ index ] = 0;
return( -1 );
}
( values_table->identifier[ index ] )[ identifier_length ] = 0;
return( 1 );
}
/* Retrieves an identifier in the values table
* Returns 1 if successful, 0 if value not present or -1 on error
*/
int libewf_values_table_get_identifier(
libewf_values_table_t *values_table,
int index,
uint8_t *identifier,
size_t identifier_size,
liberror_error_t **error )
{
static char *function = "libewf_values_table_get_identifier";
size_t narrow_identifier_size = 0;
if( values_table == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid values table.",
function );
return( -1 );
}
if( identifier == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid identifier.",
function );
return( -1 );
}
if( identifier_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid identifier size value exceeds maximum.",
function );
return( -1 );
}
if( values_table->amount_of_values == 0 )
{
return( 0 );
}
if( ( index < 0 )
|| ( index >= values_table->amount_of_values ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_OUT_OF_RANGE,
"%s: index out of range.",
function );
return( -1 );
}
if( values_table->identifier[ index ] == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: missing identifier for index: %d.",
function,
index );
return( -1 );
}
if( values_table->identifier_length[ index ] == 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: missing identifier size for length: %d.",
function,
index );
return( -1 );
}
narrow_identifier_size = values_table->identifier_length[ index ] + 1;
if( identifier_size < narrow_identifier_size )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: identifier too small.",
function );
return( -1 );
}
if( narrow_string_copy(
(char *) identifier,
(char *) values_table->identifier[ index ],
values_table->identifier_length[ index ] ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to set identifier.",
function );
return( -1 );
}
identifier[ values_table->identifier_length[ index ] ] = 0;
return( 1 );
}
/* Set a value in the values table
* Frees the previous value if necessary
* Returns 1 if successful or -1 on error
*/
int libewf_values_table_set_value(
libewf_values_table_t *values_table,
const uint8_t *identifier,
size_t identifier_length,
const uint8_t *value,
size_t value_length,
liberror_error_t **error )
{
static char *function = "libewf_values_table_set_value";
int index = 0;
int result = 0;
result = libewf_values_table_get_index(
values_table,
identifier,
identifier_length,
&index,
error );
if( result <= -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to find index for: %s.",
function,
(char *) identifier );
return( -1 );
}
else if( result == 0 )
{
index = values_table->amount_of_values;
if( libewf_values_table_resize(
values_table,
index + 1,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize values table.",
function );
return( -1 );
}
if( libewf_values_table_set_identifier(
values_table,
index,
identifier,
identifier_length,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set identifier.",
function );
return( -1 );
}
}
/* Remove exisiting values
*/
if( values_table->value[ index ] != NULL )
{
memory_free(
values_table->value[ index ] );
values_table->value[ index ] = NULL;
}
if( ( value != NULL )
&& ( value[ 0 ] != 0 )
&& ( value_length > 0 ) )
{
/* Do not include the end of string character in the value length
*/
if( value[ value_length - 1 ] == 0 )
{
value_length -= 1;
}
values_table->value_length[ index ] = value_length;
values_table->value[ index ] = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * ( values_table->value_length[ index ] + 1 ) );
if( values_table->value[ index ] == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create value.",
function );
return( -1 );
}
if( narrow_string_copy(
(char *) values_table->value[ index ],
(char *) value,
value_length ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to set value.",
function );
memory_free(
values_table->value[ index ] );
values_table->value[ index ] = NULL;
values_table->value_length[ index ] = 0;
return( -1 );
}
( values_table->value[ index ] )[ value_length ] = 0;
}
return( 1 );
}
/* Retrieves a value in the values table
* Returns 1 if successful, 0 if value not present or -1 on error
*/
int libewf_values_table_get_value(
libewf_values_table_t *values_table,
const uint8_t *identifier,
size_t identifier_length,
uint8_t *value,
size_t value_size,
liberror_error_t **error )
{
static char *function = "libewf_values_table_get_value";
size_t narrow_value_size = 0;
int index = 0;
int result = 0;
if( value == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid value.",
function );
return( -1 );
}
if( value_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid value size value exceeds maximum.",
function );
return( -1 );
}
result = libewf_values_table_get_index(
values_table,
identifier,
identifier_length,
&index,
error );
if( result <= -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to find index for: %s.",
function,
(char *) identifier );
return( -1 );
}
else if( result == 0 )
{
return( 0 );
}
if( ( values_table->value[ index ] == NULL )
|| ( values_table->value_length[ index ] == 0 ) )
{
return( 0 );
}
narrow_value_size = values_table->value_length[ index ] + 1;
if( value_size < narrow_value_size )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: value too small.",
function );
return( -1 );
}
if( narrow_string_copy(
(char *) value,
(char *) values_table->value[ index ],
values_table->value_length[ index ] ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to set value.",
function );
return( -1 );
}
value[ values_table->value_length[ index ] ] = 0;
return( 1 );
}
/* Globs the segment files according to the EWF naming schema
* Make sure the value filenames is referencing, is set to NULL
*
* If the format is known the filename should contain the base of the filename
* otherwise the function will try to determine the format based on the extension
* Returns 1 if successful or -1 on error
*/
int libewf_glob(
const char *filename,
size_t filename_length,
uint8_t format,
char **filenames[],
int *number_of_filenames,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
char *segment_filename = NULL;
void *reallocation = NULL;
static char *function = "libewf_glob";
size_t additional_length = 0;
size_t segment_extention_length = 0;
size_t segment_filename_index = 0;
size_t segment_filename_length = 0;
uint8_t segment_file_type = 0;
int result = 0;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
if( ( filename_length == 0 )
|| ( filename_length > (size_t) SSIZE_MAX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid filename length value out of bounds.",
function );
return( -1 );
}
if( ( format != LIBEWF_FORMAT_UNKNOWN )
&& ( format != LIBEWF_FORMAT_ENCASE1 )
&& ( format != LIBEWF_FORMAT_ENCASE2 )
&& ( format != LIBEWF_FORMAT_ENCASE3 )
&& ( format != LIBEWF_FORMAT_ENCASE4 )
&& ( format != LIBEWF_FORMAT_ENCASE5 )
&& ( format != LIBEWF_FORMAT_ENCASE6 )
&& ( format != LIBEWF_FORMAT_LINEN5 )
&& ( format != LIBEWF_FORMAT_LINEN6 )
&& ( format != LIBEWF_FORMAT_SMART )
&& ( format != LIBEWF_FORMAT_FTK_IMAGER )
&& ( format != LIBEWF_FORMAT_LOGICAL_ENCASE5 )
&& ( format != LIBEWF_FORMAT_LOGICAL_ENCASE6 )
&& ( format != LIBEWF_FORMAT_LOGICAL_ENCASE7 )
&& ( format != LIBEWF_FORMAT_V2_ENCASE7 )
&& ( format != LIBEWF_FORMAT_V2_LOGICAL_ENCASE7 )
&& ( format != LIBEWF_FORMAT_EWF )
&& ( format != LIBEWF_FORMAT_EWFX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported format.",
function );
return( -1 );
}
if( filenames == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filenames.",
function );
return( -1 );
}
if( *filenames != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid filenames value already set.",
function );
return( -1 );
}
if( number_of_filenames == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid number of filenames.",
function );
return( -1 );
}
if( format == LIBEWF_FORMAT_UNKNOWN )
{
if( ( filename_length > 4 )
&& ( filename[ filename_length - 4 ] == '.' ) )
{
if( filename[ filename_length - 3 ] == 'E' )
{
format = LIBEWF_FORMAT_ENCASE5;
}
else if( filename[ filename_length - 3 ] == 'e' )
{
format = LIBEWF_FORMAT_EWF;
}
else if( filename[ filename_length - 3 ] == 'L' )
{
format = LIBEWF_FORMAT_LOGICAL_ENCASE5;
}
else if( filename[ filename_length - 3 ] == 's' )
{
format = LIBEWF_FORMAT_SMART;
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - unsupported extension: %s.",
function,
&( filename[ filename_length - 4 ] ) );
return( -1 );
}
segment_extention_length = 4;
}
else if( ( filename_length > 5 )
&& ( filename[ filename_length - 5 ] == '.' ) )
{
if( filename[ filename_length - 4 ] == 'E' )
{
format = LIBEWF_FORMAT_V2_ENCASE7;
}
else if( filename[ filename_length - 4 ] == 'L' )
{
format = LIBEWF_FORMAT_V2_LOGICAL_ENCASE7;
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - unsupported extension: %s.",
function,
&( filename[ filename_length - 5 ] ) );
return( -1 );
}
if( filename[ filename_length - 3 ] != 'x' )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - unsupported extension: %s.",
function,
&( filename[ filename_length - 5 ] ) );
return( -1 );
}
segment_extention_length = 5;
}
else
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - missing extension.",
function );
return( -1 );
}
}
else
{
additional_length = 4;
}
if( segment_file_type == 0 )
{
if( ( format == LIBEWF_FORMAT_LOGICAL_ENCASE5 )
|| ( format == LIBEWF_FORMAT_LOGICAL_ENCASE6 )
|| ( format == LIBEWF_FORMAT_LOGICAL_ENCASE7 ) )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF1_LOGICAL;
}
else if( format == LIBEWF_FORMAT_SMART )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF1_SMART;
}
else if( format == LIBEWF_FORMAT_V2_ENCASE7 )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF2;
}
else if( format == LIBEWF_FORMAT_V2_LOGICAL_ENCASE7 )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF2_LOGICAL;
}
else
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF1;
}
}
if( libbfio_file_initialize(
&file_io_handle,
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;
}
*number_of_filenames = 0;
while( *number_of_filenames < (int) UINT16_MAX )
{
segment_filename_length = filename_length + additional_length;
segment_filename = (char *) memory_allocate(
sizeof( char ) * ( segment_filename_length + 1 ) );
if( segment_filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create segment filename.",
function );
goto on_error;
}
if( narrow_string_copy(
segment_filename,
filename,
filename_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy filename.",
function );
goto on_error;
}
if( additional_length == 0 )
{
segment_filename_index = segment_filename_length - segment_extention_length;
}
else
{
segment_filename_index = filename_length;
}
segment_filename[ segment_filename_index++ ] = '.';
if( libewf_filename_set_extension(
segment_filename,
segment_filename_length + 1,
&segment_filename_index,
(uint32_t) ( *number_of_filenames + 1 ),
(uint32_t) UINT16_MAX,
segment_file_type,
format,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set extension.",
function );
goto on_error;
}
/* The libewf_filename_set_extension also adds the end-of-string character */
if( libbfio_file_set_name(
file_io_handle,
segment_filename,
segment_filename_length,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set name in file IO handle.",
function );
goto on_error;
}
result = libbfio_handle_exists(
file_io_handle,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_GENERIC,
"%s: unable to test if file exists.",
function );
goto on_error;
}
else if( result == 0 )
{
memory_free(
segment_filename );
break;
}
*number_of_filenames += 1;
reallocation = memory_reallocate(
*filenames,
sizeof( char * ) * *number_of_filenames );
if( reallocation == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize filenames.",
function );
goto on_error;
}
*filenames = (char **) reallocation;
( *filenames )[ *number_of_filenames - 1 ] = segment_filename;
}
if( libbfio_handle_free(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free file IO handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( segment_filename != NULL )
{
memory_free(
segment_filename );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
