/*
* EwfSize
*/
static int EwfSize(void *p_handle, uint64_t *p_size) {
pts_EwfHandle p_ewf_handle=(pts_EwfHandle)p_handle;
#ifdef HAVE_LIBEWF_V2_API
if(libewf_handle_get_media_size(p_ewf_handle->h_ewf,p_size,NULL)!=1) {
#else
if(libewf_get_media_size(p_ewf_handle->h_ewf,p_size)!=1) {
#endif
return EWF_GET_SIZE_FAILED;
}
return EWF_OK;
}
/*
* EwfRead
*/
static int EwfRead(void *p_handle,
char *p_buf,
off_t offset,
size_t count,
size_t *p_read,
int *p_errno)
{
pts_EwfHandle p_ewf_handle=(pts_EwfHandle)p_handle;
// TODO: Return value of libewf_handle_read_buffer is ssize_t with -1 on error
size_t bytes_read;
#ifdef HAVE_LIBEWF_V2_API
if(libewf_handle_seek_offset(p_ewf_handle->h_ewf,
offset,
SEEK_SET,
NULL)!=-1)
#else
if(libewf_seek_offset(p_ewf_handle->h_ewf,offset)!=-1)
#endif
{
#ifdef HAVE_LIBEWF_V2_API
bytes_read=libewf_handle_read_buffer(p_ewf_handle->h_ewf,
p_buf,
count,
NULL);
#else
bytes_read=libewf_read_buffer(p_ewf_handle->h_ewf,p_buf,count);
#endif
if(bytes_read!=count) return EWF_READ_FAILED;
} else {
return EWF_SEEK_FAILED;
}
*p_read=bytes_read;
return EWF_OK;
}
/* Read a buffer from the input handle
* Return the number of bytes read if successful or -1 on error
*/
ssize_t mount_handle_read_buffer(
mount_handle_t *mount_handle,
uint8_t *buffer,
size_t size,
libcerror_error_t **error )
{
static char *function = "mount_handle_read_buffer";
ssize_t read_count = 0;
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
read_count = libewf_handle_read_buffer(
mount_handle->input_handle,
buffer,
size,
error );
if( read_count == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read buffer from input handle.",
function );
return( -1 );
}
return( read_count );
}
static int ewf__read(RIO *io, RIODesc *fd, ut8 *buf, int count) {
return libewf_handle_read_buffer (RIOEWF_HANDLE (fd), buf, count, NULL);
}
/* Tests libewf_handle_read_buffer
* Returns 1 if successful, 0 if not or -1 on error
*/
int ewf_test_read_buffer(
libewf_handle_t *handle,
uint8_t *buffer,
size_t buffer_size,
size64_t input_size,
size64_t expected_size,
libcerror_error_t **error )
{
static char *function = "ewf_test_read_buffer";
size64_t remaining_size = 0;
size64_t result_size = 0;
size_t read_size = 0;
ssize_t read_count = 0;
remaining_size = input_size;
while( remaining_size > 0 )
{
read_size = buffer_size;
if( remaining_size < (size64_t) read_size )
{
read_size = (size_t) remaining_size;
}
read_count = libewf_handle_read_buffer(
handle,
buffer,
read_size,
error );
if( read_count < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read buffer of size: %" PRIzd ".",
function,
read_size );
return( -1 );
}
else if( read_count == 0 )
{
break;
}
remaining_size -= (size64_t) read_count;
result_size += (size64_t) read_count;
if( read_count != (ssize_t) read_size )
{
break;
}
}
if( expected_size != result_size )
{
fprintf(
stderr,
"%s: unexpected read count: %" PRIu64 "\n",
function,
result_size );
return( 0 );
}
return( 1 );
}
/* Reads a buffer of media data from EWF file(s)
* Returns a Python object holding the data if successful or NULL on error
*/
PyObject *pyewf_handle_read_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_read_buffer";
static char *keyword_list[] = { "size", NULL };
ssize_t read_count = 0;
int read_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,
&read_size ) == 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 );
}
result_data = PyString_FromStringAndSize(
NULL,
read_size );
read_count = libewf_handle_read_buffer(
pyewf_handle->handle,
PyString_AsString(
result_data ),
(size_t) read_size,
&error );
if( read_count != (ssize_t) read_size )
{
if( liberror_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 );
}
liberror_error_free(
&error );
return( NULL );
}
return( result_data );
}
/* Tests libewf_handle_read_buffer and libewf_handle_write_buffer
* Returns 1 if successful, 0 if not or -1 on error
*/
int ewf_test_read_write_buffer(
libewf_handle_t *handle,
uint8_t *buffer,
size_t buffer_size,
size64_t input_size,
size64_t expected_size,
liberror_error_t **error )
{
static char *function = "ewf_test_read_write_buffer";
size64_t remaining_size = 0;
size64_t result_size = 0;
size_t read_size = 0;
ssize_t read_count = 0;
ssize_t write_count = 0;
remaining_size = input_size;
while( remaining_size > 0 )
{
read_size = buffer_size;
if( remaining_size < (size64_t) read_size )
{
read_size = (size_t) remaining_size;
}
read_count = libewf_handle_read_buffer(
handle,
buffer,
read_size,
error );
if( read_count < 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_READ_FAILED,
"%s: unable to read buffer of size: %" PRIzd ".",
function,
read_size );
return( -1 );
}
else if( read_count == 0 )
{
break;
}
if( libewf_handle_seek_offset(
handle,
-1 * (off64_t) read_count,
SEEK_CUR,
error ) == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_READ_FAILED,
"%s: unable to seek previous offset.",
function );
return( -1 );
}
if( memory_set(
buffer,
(int) 'B',
(size_t) read_count ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable set value in buffer.",
function );
return( -1 );
}
write_count = libewf_handle_write_buffer(
handle,
buffer,
(size_t) read_count,
error );
if( write_count < 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_WRITE_FAILED,
"%s: unable write buffer of size: %" PRIzd ".",
function,
read_count );
return( -1 );
}
if( write_count != read_count )
{
break;
}
remaining_size -= (size64_t) write_count;
result_size += (size64_t) write_count;
}
if( expected_size != result_size )
{
fprintf(
stderr,
"%s: unexpected read/write count: %" PRIu64 "\n",
function,
result_size );
return( 0 );
}
return( 1 );
}
/* Tests reading/writing data of a specific size at a specific offset
* Return 1 if successful, 0 if not or -1 on error
*/
int ewf_test_read_write_delta(
libcstring_system_character_t * const filenames[],
int number_of_filenames,
const libcstring_system_character_t *delta_segment_filename,
off64_t write_offset,
size64_t write_size,
libcerror_error_t **error )
{
libewf_handle_t *handle = NULL;
uint8_t *buffer = NULL;
static char *function = "ewf_test_read_write_delta";
size_t delta_segment_filename_length = 0;
size_t read_size = 0;
ssize_t read_count = 0;
ssize_t write_count = 0;
if( libewf_handle_initialize(
&handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create handle.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT ) && defined( EWF_TEST_READ_WRITE_DELTA_VERBOSE )
libewf_notify_set_verbose(
1 );
libewf_notify_set_stream(
stderr,
NULL );
#endif
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_open_wide(
handle,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ_WRITE,
error ) != 1 )
#else
if( libewf_handle_open(
handle,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ_WRITE,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open handle.",
function );
goto on_error;
}
if( delta_segment_filename != NULL )
{
delta_segment_filename_length = libcstring_system_string_length(
delta_segment_filename );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_set_delta_segment_filename_wide(
handle,
delta_segment_filename,
delta_segment_filename_length,
error ) != 1 )
#else
if( libewf_handle_set_delta_segment_filename(
handle,
delta_segment_filename,
delta_segment_filename_length,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set delta segment filename.",
function );
goto on_error;
}
}
if( libewf_handle_seek_offset(
handle,
write_offset,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to seek offset: %" PRIi64 ".",
function,
write_offset );
goto on_error;
}
buffer = (uint8_t *) memory_allocate(
EWF_TEST_BUFFER_SIZE );
while( write_size > 0 )
{
if( write_size > (size64_t) EWF_TEST_BUFFER_SIZE )
{
read_size = EWF_TEST_BUFFER_SIZE;
}
else
{
read_size = (size_t) write_size;
}
read_count = libewf_handle_read_buffer(
handle,
buffer,
read_size,
error );
if( read_count < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_WRITE_FAILED,
"%s: unable read buffer of size: %" PRIzd ".",
function,
read_size );
goto on_error;
}
if( memory_set(
buffer,
(int) 'X',
(size_t) read_count ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable set value in buffer.",
function );
goto on_error;
}
if( libewf_handle_seek_offset(
handle,
-1 * (off64_t) read_size,
SEEK_CUR,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to seek previous offset.",
function );
goto on_error;
}
write_count = libewf_handle_write_buffer(
handle,
buffer,
(size_t) read_count,
error );
if( write_count < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_WRITE_FAILED,
"%s: unable write buffer of size: %" PRIzd ".",
function,
read_count );
goto on_error;
}
if( write_count != read_count )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_WRITE_FAILED,
"%s: unable write buffer of size: %" PRIzd ".",
function,
read_count );
goto on_error;
}
write_offset += write_count;
write_size -= write_count;
}
memory_free(
buffer );
buffer = NULL;
if( libewf_handle_close(
handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close handle.",
function );
goto on_error;
}
if( libewf_handle_free(
&handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( buffer != NULL )
{
memory_free(
buffer );
}
if( handle != NULL )
{
libewf_handle_close(
handle,
NULL );
libewf_handle_free(
&handle,
NULL );
}
return( -1 );
}
/*
* EwfOpen
*/
static int EwfOpen(void *p_handle,
const char **pp_filename_arr,
uint64_t filename_arr_len)
{
pts_EwfHandle p_ewf_handle=(pts_EwfHandle)p_handle;
// We need at least one file
if(filename_arr_len==0) return EWF_NO_INPUT_FILES;
// Make sure all files are EWF files
for(uint64_t i=0;i<filename_arr_len;i++) {
#ifdef HAVE_LIBEWF_V2_API
if(libewf_check_file_signature(pp_filename_arr[i],NULL)!=1)
#else
if(libewf_check_file_signature(pp_filename_arr[i])!=1)
#endif
{
return EWF_INVALID_INPUT_FILES;
}
}
// Open EWF file
#ifdef HAVE_LIBEWF_V2_API
if(libewf_handle_open(p_ewf_handle->h_ewf,
(char* const*)pp_filename_arr,
filename_arr_len,
libewf_get_access_flags_read(),
NULL)!=1)
#else
p_ewf_handle->h_ewf=libewf_open((char* const*)pp_filename_arr,
filename_arr_len,
libewf_get_flags_read());
if(p_ewf_handle->h_ewf==NULL)
#endif
{
return EWF_OPEN_FAILED;
}
#ifdef HAVE_LIBEWF_V2_API
// Try to read 1 byte from the image end to verify that all segments were
// specified (Only needed because libewf_handle_open() won't fail even if not
// all segments were specified!)
uint64_t image_size=0;
char buf;
if(libewf_handle_get_media_size(p_ewf_handle->h_ewf,&image_size,NULL)!=1) {
return EWF_GET_SIZE_FAILED;
}
if(image_size==0) return EWF_OK;
LIBXMOUNT_LOG_DEBUG(p_ewf_handle->debug,
"Trying to read last byte of image at offset %"
PRIu64 " (image size = %" PRIu64 " bytes)\n",
image_size-1,
image_size);
if(libewf_handle_seek_offset(p_ewf_handle->h_ewf,
image_size-1,
SEEK_SET,
NULL)==-1)
{
return EWF_OPEN_FAILED_SEEK;
}
if(libewf_handle_read_buffer(p_ewf_handle->h_ewf,&buf,1,NULL)!=1) {
return EWF_OPEN_FAILED_READ;
}
#endif
#ifndef HAVE_LIBEWF_V2_API
// Parse EWF header
if(libewf_parse_header_values(p_ewf_handle->h_ewf,
LIBEWF_DATE_FORMAT_ISO8601)!=1)
{
return EWF_HEADER_PARSING_FAILED;
}
#endif
return EWF_OK;
}
