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