static int ewf__write(RIO *io, RIODesc *fd, const ut8 *buf, int count) {
return libewf_handle_write_buffer (RIOEWF_HANDLE (fd),
(void*)buf, count, NULL);
}
/* 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 );
}
/* Tests writing data of media size to EWF file(s) with a maximum segment size
* Return 1 if successful, 0 if not or -1 on error
*/
int ewf_test_write(
const char *filename,
size64_t media_size,
size64_t maximum_segment_size,
int8_t compression_level,
uint8_t compression_flags,
liberror_error_t **error )
{
libewf_handle_t *handle = NULL;
uint8_t *buffer = NULL;
static char *function = "ewf_test_write";
size_t write_size = 0;
ssize_t write_count = 0;
int sector_iterator = 0;
if( libewf_handle_initialize(
&handle,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create handle.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_open_wide(
handle,
(wchar_t * const *) &filename,
1,
LIBEWF_OPEN_WRITE,
error ) != 1 )
#else
if( libewf_handle_open(
handle,
(char * const *) &filename,
1,
LIBEWF_OPEN_WRITE,
error ) != 1 )
#endif
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open handle.",
function );
goto on_error;
}
if( media_size > 0 )
{
if( libewf_handle_set_media_size(
handle,
media_size,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable set media size.",
function );
goto on_error;
}
}
if( maximum_segment_size > 0 )
{
if( libewf_handle_set_maximum_segment_size(
handle,
maximum_segment_size,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable set maximum segment size.",
function );
goto on_error;
}
}
if( libewf_handle_set_compression_values(
handle,
compression_level,
compression_flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable set compression values.",
function );
goto on_error;
}
buffer = (uint8_t *) memory_allocate(
EWF_TEST_BUFFER_SIZE );
if( buffer == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable created buffer.",
function );
goto on_error;
}
write_size = 512;
for( sector_iterator = 0;
sector_iterator < 26;
sector_iterator++ )
{
if( memory_set(
buffer,
(int) 'A' + sector_iterator,
write_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable set value in buffer.",
function );
goto on_error;
}
write_count = libewf_handle_write_buffer(
handle,
buffer,
write_size,
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,
write_size );
goto on_error;
}
if( write_count != (ssize_t) write_size )
{
if( (size64_t) write_count != media_size )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_WRITE_FAILED,
"%s: unable write buffer of size: %" PRIzd ".",
function,
write_size );
goto on_error;
}
}
if( media_size > 0 )
{
media_size -= write_count;
}
}
write_size = 3751;
for( sector_iterator = 0;
sector_iterator < 26;
sector_iterator++ )
{
if( memory_set(
buffer,
(int) 'a' + sector_iterator,
write_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable set value in buffer.",
function );
goto on_error;
}
write_count = libewf_handle_write_buffer(
handle,
buffer,
write_size,
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,
write_size );
goto on_error;
}
if( write_count != (ssize_t) write_size )
{
if( (size64_t) write_count != media_size )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_WRITE_FAILED,
"%s: unable write buffer of size: %" PRIzd ".",
function,
write_size );
goto on_error;
}
}
if( media_size > 0 )
{
media_size -= write_count;
}
}
memory_free(
buffer );
buffer = NULL;
if( libewf_handle_close(
handle,
error ) != 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close handle.",
function );
goto on_error;
}
if( libewf_handle_free(
&handle,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_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 );
}
/* 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 );
}
