/* Checks if the file has an 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 ];
liberror_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 );
}
result = libewf_check_file_signature(
filename,
&error );
if( result == -1 )
{
if( liberror_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 );
}
liberror_error_free(
&error );
return( NULL );
}
if( result != 0 )
{
return( Py_True );
}
return( Py_False );
}
/* Prints a backtrace of the error to the string
* Returns the number of printed characters if successful or -1 on error
*/
int libmapidb_error_backtrace_sprint(
libmapidb_error_t *error,
char *string,
size_t size )
{
return( liberror_error_backtrace_sprint(
(liberror_error_t *) error,
string,
size ) );
}
/* Closes EWF file(s)
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_handle_close(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
liberror_error_t *error = NULL;
static char *function = "pyewf_handle_close";
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle.",
function );
return( NULL );
}
if( pyewf_handle->handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle - missing libewf handle.",
function );
return( NULL );
}
if( libewf_handle_close(
pyewf_handle->handle,
&error ) != 0 )
{
if( liberror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to close handle.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to close handle.\n%s",
function,
error_string );
}
liberror_error_free(
&error );
return( NULL );
}
return( Py_None );
}
/* Intializes a handle object
* Returns 0 if successful or -1 on error
*/
int pyewf_handle_init(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
static char *function = "pyewf_handle_init";
liberror_error_t *error = NULL;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid handle.",
function );
return( -1 );
}
/* Make sure libewf handle is set to NULL
*/
pyewf_handle->handle = NULL;
if( libewf_handle_initialize(
&( pyewf_handle->handle ),
&error ) != 1 )
{
if( liberror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to initialize handle.",
function );
}
else
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to initialize handle.\n%s",
function,
error_string );
}
liberror_error_free(
&error );
return( -1 );
}
return( 0 );
}
/* Retrieves the current offset in the media data
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_get_offset(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
liberror_error_t *error = NULL;
static char *function = "pyewf_handle_get_offset";
off64_t current_offset = 0;
if( libewf_handle_get_offset(
pyewf_handle->handle,
¤t_offset,
&error ) != 1 )
{
if( liberror_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 );
}
liberror_error_free(
&error );
return( NULL );
}
return( PyLong_FromLongLong(
current_offset ) );
}
/* Globs filenames according to the 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;
liberror_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( liberror_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 );
}
liberror_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 ] );
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( liberror_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 );
}
liberror_error_free(
&error );
Py_DecRef(
list_object );
return( NULL );
}
return( list_object );
}
/* 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 ];
liberror_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;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle.",
function );
return( NULL );
}
if( pyewf_handle->handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle - missing libewf 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 );
write_count = libewf_handle_write_buffer(
pyewf_handle->handle,
PyString_AsString(
result_data ),
(size_t) write_size,
&error );
if( write_count != (ssize_t) write_size )
{
if( liberror_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 );
}
liberror_error_free(
&error );
return( NULL );
}
return( result_data );
}
/* 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 );
}
/* Frees a handle object
*/
void pyewf_handle_free(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
liberror_error_t *error = NULL;
static char *function = "pyewf_handle_free";
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;
}
if( libewf_handle_free(
&( pyewf_handle->handle ),
&error ) != 1 )
{
if( liberror_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 );
}
liberror_error_free(
&error );
}
pyewf_handle->ob_type->tp_free(
(PyObject*) pyewf_handle );
}
/* 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 ];
liberror_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( pyewf_handle->handle == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf handle - missing libewf handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"L|i",
keyword_list,
&offset,
&whence ) == 0 )
{
return( NULL );
}
if( libewf_handle_seek_offset(
pyewf_handle->handle,
offset,
whence,
&error ) < 0 )
{
if( liberror_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 );
}
liberror_error_free(
&error );
return( NULL );
}
return( Py_None );
}
