/* Generate an xhash
* Sets xhash and xhash size
* Returns 1 if successful or -1 on error
*/
int libewf_hash_values_generate_xhash(
libfvalue_table_t *hash_values,
uint8_t **xhash,
size_t *xhash_size,
libcerror_error_t **error )
{
libfvalue_value_t *hash_value = NULL;
uint8_t *identifier = NULL;
char *xml_head = NULL;
char *xml_xhash_close_tag = NULL;
char *xml_xhash_open_tag = NULL;
static char *function = "libewf_hash_values_generate_xhash";
size_t xhash_index = 0;
size_t identifier_size = 0;
size_t value_string_size = 0;
size_t xml_head_length = 0;
size_t xml_xhash_close_tag_length = 0;
size_t xml_xhash_open_tag_length = 0;
int hash_value_index = 0;
int number_of_hash_values = 0;
int result = 0;
if( xhash == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid xhash.",
function );
return( -1 );
}
if( *xhash != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: xhash already created.",
function );
return( -1 );
}
if( xhash_size == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid xhash size.",
function );
return( -1 );
}
if( libfvalue_table_get_number_of_values(
hash_values,
&number_of_hash_values,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of hash values.",
function );
goto on_error;
}
xml_head = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
xml_head_length = libcstring_narrow_string_length(
xml_head );
xml_xhash_open_tag = "<xhash>\n";
xml_xhash_open_tag_length = libcstring_narrow_string_length(
xml_xhash_open_tag );
xml_xhash_close_tag = "</xhash>\n\n";
xml_xhash_close_tag_length = libcstring_narrow_string_length(
xml_xhash_close_tag );
/* Reserve space for the UTF-8 byte order mark and the XML skeleton data
*/
*xhash_size = 3 + xml_head_length + xml_xhash_open_tag_length + xml_xhash_close_tag_length;
for( hash_value_index = 0;
hash_value_index < number_of_hash_values;
hash_value_index++ )
{
if( libfvalue_table_get_value_by_index(
hash_values,
hash_value_index,
&hash_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve hash value: %d.",
function,
hash_value_index );
goto on_error;
}
if( libfvalue_value_get_identifier(
hash_value,
&identifier,
&identifier_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier of hash value: %d.",
function,
hash_value_index );
goto on_error;
}
if( ( identifier == NULL )
|| ( identifier_size == 0 ) )
{
#if defined( HAVE_VERBOSE_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: missing identifier for hash value: %d.\n",
function,
hash_value_index );
}
#endif
continue;
}
result = libfvalue_value_get_utf8_string_size(
hash_value,
0,
&value_string_size,
error );
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve string size of hash value: %s.",
function,
(char *) identifier );
goto on_error;
}
if( ( result != 0 )
&& ( value_string_size > 1 ) )
{
/* Reserve space for a leading tab, <identifier>value</identifier> and a newline
*/
*xhash_size += 7 + ( 2 * ( identifier_size - 1 ) ) + ( value_string_size - 1 );
}
}
/* Reserve space for the end-of-string character
*/
*xhash_size += 1;
*xhash = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * *xhash_size );
if( *xhash == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: unable to create xhash.",
function );
goto on_error;
}
( *xhash )[ xhash_index++ ] = 0xef;
( *xhash )[ xhash_index++ ] = 0xbb;
( *xhash )[ xhash_index++ ] = 0xbf;
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
xml_head,
xml_head_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy XML head string.",
function );
goto on_error;
}
xhash_index += xml_head_length;
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
xml_xhash_open_tag,
xml_xhash_open_tag_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy xhash open tag string.",
function );
goto on_error;
}
xhash_index += xml_xhash_open_tag_length;
for( hash_value_index = 0;
hash_value_index < number_of_hash_values;
hash_value_index++ )
{
if( libfvalue_table_get_value_by_index(
hash_values,
hash_value_index,
&hash_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve hash value: %d.",
function,
hash_value_index );
goto on_error;
}
if( libfvalue_value_get_identifier(
hash_value,
&identifier,
&identifier_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier of hash value: %d.",
function,
hash_value_index );
goto on_error;
}
if( ( identifier == NULL )
|| ( identifier_size == 0 ) )
{
#if defined( HAVE_VERBOSE_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: missing identifier for hash value: %d.\n",
function,
hash_value_index );
}
#endif
continue;
}
result = libfvalue_value_get_utf8_string_size(
hash_value,
0,
&value_string_size,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve string size of hash value: %s.",
function,
(char *) identifier );
goto on_error;
}
if( ( result != 0 )
&& ( value_string_size > 1 ) )
{
( *xhash )[ xhash_index++ ] = (uint8_t) '\t';
( *xhash )[ xhash_index++ ] = (uint8_t) '<';
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
(char *) identifier,
identifier_size - 1 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy %s open tag string.",
function,
(char *) identifier );
goto on_error;
}
xhash_index += identifier_size - 1;
( *xhash )[ xhash_index++ ] = (uint8_t) '>';
if( libfvalue_value_copy_to_utf8_string_with_index(
hash_value,
0,
*xhash,
*xhash_size,
&xhash_index,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy string of hash value: %s.",
function,
(char *) identifier );
goto on_error;
}
( *xhash )[ xhash_index - 1 ] = (uint8_t) '<';
( *xhash )[ xhash_index++ ] = (uint8_t) '/';
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
(char *) identifier,
identifier_size - 1 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy %s close tag string.",
function,
(char *) identifier );
goto on_error;
}
xhash_index += identifier_size - 1;
( *xhash )[ xhash_index++ ] = (uint8_t) '>';
( *xhash )[ xhash_index++ ] = (uint8_t) '\n';
}
}
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
xml_xhash_close_tag,
xml_xhash_close_tag_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy xhash close tag string.",
function );
goto on_error;
}
xhash_index += xml_xhash_close_tag_length;
/* Make sure the string is terminated
*/
( *xhash )[ xhash_index ] = 0;
return( 1 );
on_error:
if( *xhash != NULL )
{
memory_free(
*xhash );
*xhash = NULL;
}
*xhash_size = 0;
return( -1 );
}
/* Globs the segment files according to the EWF naming schema
* if 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 = 4;
size_t segment_filename_length = 0;
int result = 0;
uint8_t segment_file_type = 0;
uint8_t ewf_format = 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.",
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 )
&& ( format != LIBEWF_FORMAT_LVF )
&& ( 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( 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[ filename_length - 4 ] != (char) '.' )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: invalid filename - missing extension.",
function );
return( -1 );
}
additional_length = 0;
if( filename[ filename_length - 3 ] == (char) 'E' )
{
format = LIBEWF_FORMAT_ENCASE5;
}
else if( filename[ filename_length - 3 ] == (char) 'e' )
{
format = LIBEWF_FORMAT_EWF;
}
else if( filename[ filename_length - 3 ] == (char) 'L' )
{
format = LIBEWF_FORMAT_LVF;
}
else if( filename[ filename_length - 3 ] == (char) '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 );
}
}
if( format == LIBEWF_FORMAT_LVF )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_LWF;
ewf_format = EWF_FORMAT_L01;
}
else if( format == LIBEWF_FORMAT_SMART )
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF;
ewf_format = EWF_FORMAT_S01;
}
else
{
segment_file_type = LIBEWF_SEGMENT_FILE_TYPE_EWF;
ewf_format = EWF_FORMAT_E01;
}
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( libcstring_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[ filename_length ] = (char) '.';
}
if( libewf_filename_set_extension(
&( segment_filename[ segment_filename_length - 3 ] ),
(uint16_t) ( *number_of_filenames + 1 ),
UINT16_MAX,
segment_file_type,
format,
ewf_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;
}
segment_filename[ segment_filename_length ] = 0;
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 );
}
/* Retrieves the UTF-8 encoded name value
* The size should include the end of string character
* Returns 1 if successful or -1 on error
*/
int libewf_single_file_entry_get_utf8_name(
libewf_single_file_entry_t *single_file_entry,
uint8_t *utf8_string,
size_t utf8_string_size,
libcerror_error_t **error )
{
static char *function = "libewf_single_file_entry_get_utf8_name";
if( single_file_entry == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid single file entry.",
function );
return( -1 );
}
if( utf8_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid UTF-8 string.",
function );
return( -1 );
}
if( utf8_string_size == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: invalid UTF-8 string size value too small.",
function );
return( -1 );
}
if( ( single_file_entry->name == NULL )
|| ( single_file_entry->name_size == 0 ) )
{
utf8_string[ 0 ] = 0;
}
else
{
if( utf8_string_size < single_file_entry->name_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: invalid UTF-8 string size value too small.",
function );
return( -1 );
}
if( libcstring_narrow_string_copy(
(char *) utf8_string,
(char *) single_file_entry->name,
single_file_entry->name_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to set UTF-8 string.",
function );
return( -1 );
}
utf8_string[ single_file_entry->name_size - 1 ] = 0;
}
return( 1 );
}
/* Open EWF file(s)
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_handle_open(
pyewf_handle_t *pyewf_handle,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
liberror_error_t *error = NULL;
char **filenames = NULL;
static char *keyword_list[] = { "filenames", "access_flags", NULL };
PyObject *sequence_object = NULL;
PyObject *string_object = NULL;
static char *function = "pyewf_handle_open";
size_t filename_length = 0;
int access_flags = 0;
int filename_index = 0;
int number_of_filenames = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"O|i",
keyword_list,
&sequence_object,
&access_flags ) == 0 )
{
return( NULL );
}
if( PySequence_Check(
sequence_object ) == 0 )
{
PyErr_Format(
PyExc_TypeError,
"%s: argument: files must be a list or tuple.",
function );
return( NULL );
}
number_of_filenames = PySequence_Size(
sequence_object );
if( ( number_of_filenames <= 0 )
|| ( number_of_filenames > (int) UINT16_MAX ) )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid number of files.",
function );
return( NULL );
}
filenames = (char **) memory_allocate(
sizeof( char * ) * number_of_filenames );
if( filenames == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create filenames.",
function );
return( NULL );
}
if( memory_set(
filenames,
0,
sizeof( char * ) * number_of_filenames ) == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to clear filenames.",
function );
memory_free(
filenames );
return( NULL );
}
for( filename_index = 0;
filename_index < number_of_filenames;
filename_index++ )
{
string_object = PySequence_GetItem(
sequence_object,
filename_index );
filename_length = PyString_Size(
string_object );
filenames[ filename_index ] = (char *) memory_allocate(
sizeof( char ) * ( filename_length + 1 ) );
if( filenames[ filename_index ] == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create filename: %d.",
function,
filename_index );
for( ; filename_index > 0; filename_index-- )
{
memory_free(
filenames[ filename_index - 1 ] );
}
memory_free(
filenames );
return( NULL );
}
if( libcstring_narrow_string_copy(
filenames[ filename_index ],
PyString_AsString(
string_object ),
filename_length ) == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to set filename: %d.",
function,
filename_index );
for( ; filename_index > 0; filename_index-- )
{
memory_free(
filenames[ filename_index - 1 ] );
}
memory_free(
filenames );
return( NULL );
}
( filenames[ filename_index ] )[ filename_length ] = 0;
Py_DecRef(
string_object );
}
if( libewf_handle_open(
pyewf_handle->handle,
filenames,
number_of_filenames,
access_flags,
&error ) != 1 )
{
if( liberror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to open handle.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to open handle.\n%s",
function,
error_string );
}
liberror_error_free(
&error );
for( filename_index = 0;
filename_index < number_of_filenames;
filename_index++ )
{
memory_free(
filenames[ filename_index ] );
}
memory_free(
filenames );
return( NULL );
}
for( filename_index = 0;
filename_index < number_of_filenames;
filename_index++ )
{
memory_free(
filenames[ filename_index ] );
}
memory_free(
filenames );
return( Py_None );
}
/* Open EWF file(s)
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_handle_open(
pyewf_handle_t *pyewf_handle,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
char **filenames = NULL;
char *mode = NULL;
static char *keyword_list[] = { "filenames", "mode", NULL };
PyObject *sequence_object = NULL;
PyObject *string_object = NULL;
static char *function = "pyewf_handle_open";
size_t filename_length = 0;
int access_flags = 0;
int filename_index = 0;
int number_of_filenames = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"O|s",
keyword_list,
&sequence_object,
&mode ) == 0 )
{
return( NULL );
}
if( PySequence_Check(
sequence_object ) == 0 )
{
PyErr_Format(
PyExc_TypeError,
"%s: argument: files must be a sequence object.",
function );
return( NULL );
}
if( mode == NULL )
{
access_flags = LIBEWF_OPEN_READ;
}
else if( mode[ 0 ] == 'r' )
{
if( mode[ 1 ] == '+' )
{
if( ( mode[ 2 ] == 0 )
|| ( ( mode[ 2 ] == 'b' )
&& ( mode[ 3 ] == 0 ) ) )
{
access_flags = LIBEWF_OPEN_READ_WRITE;
}
}
else if( ( mode[ 1 ] == 0 )
|| ( ( mode[ 1 ] == 'b' )
&& ( mode[ 2 ] == 0 ) ) )
{
access_flags = LIBEWF_OPEN_READ;
}
}
else if( mode[ 0 ] == 'w' )
{
if( ( mode[ 1 ] == 0 )
|| ( ( mode[ 1 ] == 'b' )
&& ( mode[ 2 ] == 0 ) ) )
{
access_flags = LIBEWF_OPEN_WRITE;
}
}
else if( mode[ 0 ] == 'a' )
{
if( ( mode[ 1 ] == 0 )
|| ( ( mode[ 1 ] == 'b' )
&& ( mode[ 2 ] == 0 ) ) )
{
access_flags = LIBEWF_OPEN_WRITE_RESUME;
}
}
if( access_flags == 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: unsupported mode: %s.",
function,
mode );
return( NULL );
}
number_of_filenames = PySequence_Size(
sequence_object );
if( ( number_of_filenames <= 0 )
|| ( number_of_filenames > (int) UINT16_MAX ) )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid number of files.",
function );
goto on_error;
}
filenames = (char **) PyMem_Malloc(
sizeof( char * ) * number_of_filenames );
if( filenames == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create filenames.",
function );
goto on_error;
}
if( memory_set(
filenames,
0,
sizeof( char * ) * number_of_filenames ) == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to clear filenames.",
function );
PyMem_Free(
filenames );
return( NULL );
}
for( filename_index = 0;
filename_index < number_of_filenames;
filename_index++ )
{
string_object = PySequence_GetItem(
sequence_object,
filename_index );
filename_length = PyString_Size(
string_object );
filenames[ filename_index ] = (char *) PyMem_Malloc(
sizeof( char ) * ( filename_length + 1 ) );
if( filenames[ filename_index ] == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create filename: %d.",
function,
filename_index );
goto on_error;
}
if( libcstring_narrow_string_copy(
filenames[ filename_index ],
PyString_AsString(
string_object ),
filename_length ) == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to set filename: %d.",
function,
filename_index );
goto on_error;
}
( filenames[ filename_index ] )[ filename_length ] = 0;
Py_DecRef(
string_object );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_open(
pyewf_handle->handle,
filenames,
number_of_filenames,
access_flags,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to open handle.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to open handle.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
for( filename_index = 0;
filename_index < number_of_filenames;
filename_index++ )
{
PyMem_Free(
filenames[ filename_index ] );
}
PyMem_Free(
filenames );
Py_IncRef(
Py_None );
return( Py_None );
on_error:
if( filenames != NULL )
{
for( ; filename_index > 0; filename_index-- )
{
PyMem_Free(
filenames[ filename_index - 1 ] );
}
PyMem_Free(
filenames );
}
return( NULL );
}
/* Prints a backtrace of the error to the string
* The end-of-string character is not included in the return value
* Returns the number of printed characters if successful or -1 on error
*/
int libcerror_error_backtrace_sprint(
libcerror_error_t *error,
char *string,
size_t size )
{
libcerror_internal_error_t *internal_error = NULL;
size_t string_index = 0;
int message_index = 0;
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
size_t print_count = 0;
#endif
if( error == NULL )
{
return( -1 );
}
internal_error = (libcerror_internal_error_t *) error;
if( internal_error->messages == NULL )
{
return( -1 );
}
if( internal_error->sizes == NULL )
{
return( -1 );
}
if( string == NULL )
{
return( -1 );
}
#if INT_MAX < SSIZE_MAX
if( size > (size_t) INT_MAX )
#else
if( size > (size_t) SSIZE_MAX )
#endif
{
return( -1 );
}
for( message_index = 0;
message_index < internal_error->number_of_messages;
message_index++ )
{
if( internal_error->messages[ message_index ] != NULL )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
#if defined( _MSC_VER )
if( wcstombs_s(
&print_count,
&( string[ string_index ] ),
size - string_index,
internal_error->messages[ message_index ],
_TRUNCATE ) != 0 )
{
return( -1 );
}
#else
print_count = wcstombs(
&( string[ string_index ] ),
internal_error->messages[ message_index ],
size - string_index );
if( print_count == (size_t) -1 )
{
return( -1 );
}
#endif
string_index += print_count;
if( string_index >= size )
{
return( -1 );
}
#else
if( ( string_index + internal_error->sizes[ message_index ] ) > size )
{
return( -1 );
}
if( string_index > 0 )
{
string[ string_index++ ] = (libcstring_system_character_t) '\n';
}
if( libcstring_narrow_string_copy(
&( string[ string_index ] ),
internal_error->messages[ message_index ],
internal_error->sizes[ message_index ] ) == NULL )
{
string[ string_index ] = (libcstring_system_character_t) 0;
return( -1 );
}
string_index += internal_error->sizes[ message_index ] - 1;
string[ string_index ] = (libcstring_system_character_t) 0;
#endif /* defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) */
}
}
if( string_index > (size_t) INT_MAX )
{
return( -1 );
}
return( (int) string_index );
}
