/* 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 libfcache_error_backtrace_sprint(
libfcache_error_t *error,
char *string,
size_t size )
{
int print_count = 0;
print_count = libcerror_error_backtrace_sprint(
(libcerror_error_t *) error,
string,
size );
return( print_count );
}
/* Retrieves the root file entry
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_handle_get_root_file_entry(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
libewf_file_entry_t *root_file_entry = NULL;
PyObject *file_entry_object = NULL;
static char *function = "pyewf_handle_get_root_file_entry";
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid handle.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_root_file_entry(
pyewf_handle->handle,
&root_file_entry,
&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 retrieve root file entry.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve root file entry.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
file_entry_object = pyewf_file_entry_new(
root_file_entry,
pyewf_handle );
if( file_entry_object == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create file entry object.",
function );
goto on_error;
}
return( file_entry_object );
on_error:
if( root_file_entry != NULL )
{
libewf_file_entry_free(
&root_file_entry,
NULL );
}
return( NULL );
}
/* Retrieves the offset
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_handle_get_offset(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_handle_get_offset";
off64_t offset = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid handle.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_offset(
pyewf_handle->handle,
&offset,
&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 retrieve offset.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve offset.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
#if defined( HAVE_LONG_LONG )
if( offset > (off64_t) LLONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: offset value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLongLong(
(long long) offset ) );
#else
if( offset > (off64_t) LONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: offset value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLong(
(long) offset ) );
#endif
}
/* Seeks a certain offset in the media data
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_seek_offset(
pyewf_handle_t *pyewf_handle,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_handle_seek_offset";
static char *keyword_list[] = { "offset", "whence", NULL };
off64_t offset = 0;
int whence = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"L|i",
keyword_list,
&offset,
&whence ) == 0 )
{
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
offset = libewf_handle_seek_offset(
pyewf_handle->handle,
offset,
whence,
&error );
Py_END_ALLOW_THREADS
if( offset == -1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to seek offset.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to seek offset.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
Py_IncRef(
Py_None );
return( Py_None );
}
/* Writes a buffer of media data to EWF file(s)
* Returns a Python object holding the data if successful or NULL on error
*/
PyObject *pyewf_handle_write_buffer(
pyewf_handle_t *pyewf_handle,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *result_data = NULL;
static char *function = "pyewf_handle_write_buffer";
static char *keyword_list[] = { "size", NULL };
ssize_t write_count = 0;
int write_size = -1;
/* TODO fix this needs a string containing the buffer */
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"|i",
keyword_list,
&write_size ) == 0 )
{
return( NULL );
}
if( write_size < 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read size value less than zero.",
function );
return( NULL );
}
/* Make sure the data fits into a memory buffer
*/
if( write_size > INT_MAX )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read size value exceeds maximum.",
function );
return( NULL );
}
result_data = PyString_FromStringAndSize(
NULL,
write_size );
Py_BEGIN_ALLOW_THREADS
write_count = libewf_handle_write_buffer(
pyewf_handle->handle,
PyString_AsString(
result_data ),
(size_t) write_size,
&error );
Py_END_ALLOW_THREADS
if( write_count != (ssize_t) write_size )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to write data.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to write data.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
return( result_data );
}
/* Globs filenames according to the Expert Witness Compression Format (EWF) segment file naming schema
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_glob(
PyObject *self,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
char **filenames = NULL;
libcerror_error_t *error = NULL;
PyObject *list_object = NULL;
PyObject *string_object = NULL;
static char *function = "pyewf_glob";
static char *keyword_list[] = { "filename", NULL };
const char *errors = NULL;
const char *filename = NULL;
size_t filename_length = 0;
int filename_index = 0;
int number_of_filenames = 0;
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"|s",
keyword_list,
&filename ) == 0 )
{
return( NULL );
}
filename_length = libcstring_narrow_string_length(
filename );
if( libewf_glob(
filename,
filename_length,
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to glob filenames.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to glob filenames.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
list_object = PyList_New(
(Py_ssize_t) number_of_filenames );
for( filename_index = 0;
filename_index < number_of_filenames;
filename_index++ )
{
filename_length = libcstring_narrow_string_length(
filenames[ filename_index ] );
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
string_object = PyUnicode_DecodeUTF8(
filenames[ filename_index ],
filename_length,
errors );
if( string_object == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to convert UTF-8 filename: %d into Unicode.",
function,
filename_index );
libewf_glob_free(
filenames,
number_of_filenames,
NULL );
Py_DecRef(
list_object );
return( NULL );
}
if( PyList_SetItem(
list_object,
(Py_ssize_t) filename_index,
string_object ) != 0 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to set filename: %d in list.",
function,
filename_index );
libewf_glob_free(
filenames,
number_of_filenames,
NULL );
Py_DecRef(
string_object );
Py_DecRef(
list_object );
return( NULL );
}
}
if( libewf_glob_free(
filenames,
number_of_filenames,
&error ) != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free globbed filenames.",
function );
}
else
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free globbed filenames.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
Py_DecRef(
list_object );
return( NULL );
}
return( list_object );
}
/* Retrieves the codepage used for header strings
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_get_header_codepage(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *string_object = NULL;
const char *codepage_string = NULL;
static char *function = "pyewf_handle_get_header_codepage";
int header_codepage = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid handle.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_header_codepage(
pyewf_handle->handle,
&header_codepage,
&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 retrieve header codepage.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve header codepage.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
codepage_string = pyewf_codepage_to_string(
header_codepage );
if( codepage_string == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: unsupported header codepage: %d.",
function,
header_codepage );
return( NULL );
}
string_object = PyString_FromString(
codepage_string );
if( string_object == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to convert codepage string into string object.",
function );
return( NULL );
}
return( string_object );
}
/* Reads a buffer of media data at a specific offset from EWF file(s)
* Returns a Python object holding the data if successful or NULL on error
*/
PyObject *pyewf_handle_read_random(
pyewf_handle_t *pyewf_handle,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *result_data = NULL;
static char *function = "pyewf_handle_read_random";
static char *keyword_list[] = { "size", "offset", NULL };
off64_t read_offset = 0;
ssize_t read_count = 0;
int read_size = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"i|L",
keyword_list,
&read_size,
&read_offset ) == 0 )
{
return( NULL );
}
if( read_size < 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read size value less than zero.",
function );
return( NULL );
}
/* Make sure the data fits into a memory buffer
*/
if( read_size > INT_MAX )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read size value exceeds maximum.",
function );
return( NULL );
}
if( read_offset < 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read offset value less than zero.",
function );
return( NULL );
}
/* Make sure the data fits into a memory buffer
*/
result_data = PyString_FromStringAndSize(
NULL,
read_size );
Py_BEGIN_ALLOW_THREADS
read_count = libewf_handle_read_random(
pyewf_handle->handle,
PyString_AsString(
result_data ),
(size_t) read_size,
(off64_t) read_offset,
&error );
Py_END_ALLOW_THREADS
if( read_count != (ssize_t) read_size )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to read data.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to read data.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
return( result_data );
}
/* Retrieves the size
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_file_entry_get_size(
pyewf_file_entry_t *pyewf_file_entry )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_file_entry_get_size";
size64_t size = 0;
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file entry.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_get_size(
pyewf_file_entry->file_entry,
&size,
&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 retrieve size.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve size.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
#if defined( HAVE_LONG_LONG )
if( size > (size64_t) LLONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: size value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLongLong(
(long long) size ) );
#else
if( size > (size64_t) LONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: size value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLong(
(long) size ) );
#endif
}
/* Retrieves a file entries sequence and iterator object for the sub file entries
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_file_entry_get_sub_file_entries(
pyewf_file_entry_t *pyewf_file_entry )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *file_entries_object = NULL;
static char *function = "pyewf_file_entry_get_sub_file_entries";
int number_of_sub_file_entries = 0;
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file entry.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_get_number_of_sub_file_entries(
pyewf_file_entry->file_entry,
&number_of_sub_file_entries,
&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 retrieve number of sub file entries.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve number of sub file entries.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
file_entries_object = pyewf_file_entries_new(
pyewf_file_entry,
&pyewf_file_entry_get_sub_file_entry_by_index,
number_of_sub_file_entries );
if( file_entries_object == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create file entries object.",
function );
return( NULL );
}
return( file_entries_object );
}
/* Retrieves the MD5 hash
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_file_entry_get_hash_value_md5(
pyewf_file_entry_t *pyewf_file_entry )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *string_object = NULL;
const char *errors = NULL;
uint8_t *hash_value = NULL;
static char *function = "pyewf_file_entry_get_hash_value_md5";
size_t hash_value_size = 33;
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file entry.",
function );
return( NULL );
}
hash_value = (uint8_t *) PyMem_Malloc(
sizeof( uint8_t ) * hash_value_size );
if( hash_value == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to create hash value.",
function );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_get_utf8_hash_value_md5(
pyewf_file_entry->file_entry,
hash_value,
hash_value_size,
&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 retrieve hash value MD5.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve hash value MD5.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
string_object = PyUnicode_DecodeUTF8(
(char *) hash_value,
(Py_ssize_t) hash_value_size - 1,
errors );
PyMem_Free(
hash_value );
return( string_object );
on_error:
if( hash_value != NULL )
{
PyMem_Free(
hash_value );
}
return( NULL );
}
/* Retrieves the entry modification date and time as an integer
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_file_entry_get_entry_modification_time_as_integer(
pyewf_file_entry_t *pyewf_file_entry )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_file_entry_get_entry_modification_time_as_integer";
uint32_t posix_time = 0;
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid file entry.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_get_entry_modification_time(
pyewf_file_entry->file_entry,
&posix_time,
&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 retrieve entry modification time.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve entry modification time.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
#if defined( HAVE_LONG_LONG )
if( (uint64_t) posix_time > (uint64_t) LLONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: POSIX time value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLongLong(
(long long) posix_time ) );
#else
if( (uint64_t) posix_time > (uint64_t) LONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: POSIX time value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLong(
(long) posix_time ) );
#endif
}
/* Retrieves the header values
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_get_header_values(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *dictionary_object = NULL;
PyObject *string_object = NULL;
static char *function = "pyewf_handle_get_header_values";
const char *errors = NULL;
char *header_value = NULL;
char *header_value_identifier = NULL;
size_t header_value_identifier_length = 0;
size_t header_value_identifier_size = 0;
size_t header_value_size = 0;
uint32_t number_of_header_values = 0;
uint32_t header_value_index = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid handle.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_number_of_header_values(
pyewf_handle->handle,
&number_of_header_values,
&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: failed to retrieve number of header values.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: failed to retrieve number of header values.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
dictionary_object = PyDict_New();
for( header_value_index = 0;
header_value_index < number_of_header_values;
header_value_index++ )
{
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_header_value_identifier_size(
pyewf_handle->handle,
header_value_index,
&header_value_identifier_size,
&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 retrieve header value: %d identifier size.",
function,
header_value_index );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve header value: %d identifier size.\n%s",
function,
header_value_index,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
header_value_identifier = (char *) PyMem_Malloc(
sizeof( char ) * header_value_identifier_size );
if( header_value_identifier == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create header value identifier.",
function );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_header_value_identifier(
pyewf_handle->handle,
header_value_index,
(uint8_t *) header_value_identifier,
header_value_identifier_size,
&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 retrieve header value: %d identifier.",
function,
header_value_index );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve header value: %d identifier.\n%s",
function,
header_value_index,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
header_value_identifier_length = libcstring_narrow_string_length(
header_value_identifier );
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_utf8_header_value_size(
pyewf_handle->handle,
(uint8_t *) header_value_identifier,
header_value_identifier_length,
&header_value_size,
&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 retrieve UTF-8 header value: %s size.",
function,
header_value_identifier );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s size.\n%s",
function,
header_value_identifier,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Ignore emtpy header values
*/
if( ( result != 0 )
&& ( header_value_size > 0 ) )
{
header_value = (char *) PyMem_Malloc(
sizeof( char ) * header_value_size );
if( header_value == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create header value.",
function );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_utf8_header_value(
pyewf_handle->handle,
(uint8_t *) header_value_identifier,
header_value_identifier_length,
(uint8_t *) header_value,
header_value_size,
&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 retrieve UTF-8 header value: %s.",
function,
header_value_identifier );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s.\n%s",
function,
header_value_identifier,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
string_object = PyUnicode_DecodeUTF8(
header_value,
header_value_size - 1,
errors );
if( string_object == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to convert UTF-8 header value: %s into Unicode.",
function,
header_value_identifier );
goto on_error;
}
if( PyDict_SetItemString(
dictionary_object,
header_value_identifier,
string_object ) != 0 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to set header value: %s in dictionary.",
function,
header_value_identifier );
goto on_error;
}
string_object = NULL;
PyMem_Free(
header_value );
header_value = NULL;
}
PyMem_Free(
header_value_identifier );
header_value_identifier = NULL;
}
/* Retrieves a header value
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_get_header_value(
pyewf_handle_t *pyewf_handle,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *string_object = NULL;
static char *function = "pyewf_handle_get_header_value";
static char *keyword_list[] = { "identifier", NULL };
const char *errors = NULL;
char *header_value_identifier = NULL;
char *header_value = NULL;
size_t header_value_identifier_length = 0;
size_t header_value_size = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"s",
keyword_list,
&header_value_identifier ) == 0 )
{
return( NULL );
}
header_value_identifier_length = libcstring_narrow_string_length(
header_value_identifier );
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_utf8_header_value_size(
pyewf_handle->handle,
(uint8_t *) header_value_identifier,
header_value_identifier_length,
&header_value_size,
&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 retrieve UTF-8 header value: %s size.",
function,
header_value_identifier );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s size.\n%s",
function,
header_value_identifier,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Check if header value is present
*/
else if( result == 0 )
{
Py_IncRef(
Py_None );
return( Py_None );
}
header_value = (char *) PyMem_Malloc(
sizeof( char ) * header_value_size );
if( header_value == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create header value.",
function );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_utf8_header_value(
pyewf_handle->handle,
(uint8_t *) header_value_identifier,
header_value_identifier_length,
(uint8_t *) header_value,
header_value_size,
&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 retrieve UTF-8 header value: %s.",
function,
header_value_identifier );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s.\n%s",
function,
header_value_identifier,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Check if the header value is present
*/
else if( result == 0 )
{
PyMem_Free(
header_value );
Py_IncRef(
Py_None );
return( Py_None );
}
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
string_object = PyUnicode_DecodeUTF8(
header_value,
(Py_ssize_t) header_value_size - 1,
errors );
if( string_object == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to convert UTF-8 header value: %s into Unicode.",
function,
header_value_identifier );
goto on_error;
}
PyMem_Free(
header_value );
return( string_object );
on_error:
if( header_value != NULL )
{
PyMem_Free(
header_value );
}
return( NULL );
}
/* Sets the codepage used for header strings
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_set_header_codepage(
pyewf_handle_t *pyewf_handle,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
char *codepage_string = NULL;
static char *keyword_list[] = { "codepage", NULL };
static char *function = "pyewf_handle_set_header_codepage";
size_t codepage_string_length = 0;
uint32_t feature_flags = 0;
int header_codepage = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"s",
keyword_list,
&codepage_string ) == 0 )
{
return( NULL );
}
if( codepage_string == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid codepage string.",
function );
return( NULL );
}
codepage_string_length = libcstring_narrow_string_length(
codepage_string );
feature_flags = LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_KOI8
| LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_WINDOWS;
if( libclocale_codepage_copy_from_string(
&header_codepage,
codepage_string,
codepage_string_length,
feature_flags,
&error ) != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_RuntimeError,
"%s: unable to determine ASCII codepage.",
function );
}
else
{
PyErr_Format(
PyExc_RuntimeError,
"%s: unable to determine ASCII codepage.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_set_header_codepage(
pyewf_handle->handle,
header_codepage,
&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 set ASCII codepage.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to set ASCII codepage.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
Py_IncRef(
Py_None );
return( Py_None );
}
/* Frees a handle object
*/
void pyewf_handle_free(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_handle_free";
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid handle.",
function );
return;
}
if( pyewf_handle->ob_type == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid handle - missing ob_type.",
function );
return;
}
if( pyewf_handle->ob_type->tp_free == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid handle - invalid ob_type - missing tp_free.",
function );
return;
}
if( pyewf_handle->handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid handle - missing libewf handle.",
function );
return;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_free(
&( pyewf_handle->handle ),
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free handle.",
function );
}
else
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free handle.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
}
pyewf_handle->ob_type->tp_free(
(PyObject*) pyewf_handle );
}
/* 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 );
}
/* Checks if the file has an Expert Witness Compression Format (EWF) signature
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_check_file_signature(
PyObject *self,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_check_file_signature";
static char *keyword_list[] = { "filename", NULL };
const char *filename = NULL;
int result = 0;
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"|s",
keyword_list,
&filename ) == 0 )
{
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_check_file_signature(
filename,
&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 check file signature.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to check file signature.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
if( result != 0 )
{
return( Py_True );
}
return( Py_False );
}
/* Raises an error
*/
void VARARGS(
pyregf_error_raise,
libcerror_error_t *error,
PyObject *exception_object,
const char *,
format_string )
{
va_list argument_list;
char error_string[ PYREGF_ERROR_STRING_SIZE ];
char exception_string[ PYREGF_ERROR_STRING_SIZE ];
static char *function = "pyregf_error_raise";
size_t error_string_index = 0;
int print_count = 0;
if( format_string == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: missing format string.",
function );
return;
}
VASTART(
argument_list,
const char *,
format_string );
print_count = PyOS_vsnprintf(
exception_string,
PYREGF_ERROR_STRING_SIZE,
format_string,
argument_list );
VAEND(
argument_list );
if( print_count < 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: unable to format exception string.",
function );
return;
}
if( error != NULL )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYREGF_ERROR_STRING_SIZE ) != -1 )
{
while( error_string_index < PYREGF_ERROR_STRING_SIZE )
{
if( error_string[ error_string_index ] == 0 )
{
break;
}
if( error_string[ error_string_index ] == '\n' )
{
error_string[ error_string_index ] = ' ';
}
error_string_index++;
}
if( error_string_index >= PYREGF_ERROR_STRING_SIZE )
{
error_string[ PYREGF_ERROR_STRING_SIZE - 1 ] = 0;
}
PyErr_Format(
exception_object,
"%s %s",
exception_string,
error_string );
return;
}
}
PyErr_Format(
exception_object,
"%s",
exception_string );
return;
}
/* Checks if the file has a Windows Event Log (EWF) file signature using a file-like object
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_check_file_signature_file_object(
PyObject *self,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
libbfio_handle_t *file_io_handle = NULL;
PyObject *file_object = NULL;
static char *function = "pyewf_check_file_signature_file_object";
static char *keyword_list[] = { "file_object", NULL };
int result = 0;
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"|O",
keyword_list,
&file_object ) == 0 )
{
return( NULL );
}
if( pyewf_file_object_initialize(
&file_io_handle,
file_object,
&error ) != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to initialize file IO handle.",
function );
}
else
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to initialize file IO handle.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_check_file_signature_file_io_handle(
file_io_handle,
&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 check file signature.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to check file signature.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
if( libbfio_handle_free(
&file_io_handle,
&error ) != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free file IO handle.",
function );
}
else
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free file IO handle.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
if( result != 0 )
{
return( Py_True );
}
return( Py_False );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( NULL );
}
