/* Determines if a file contains a BDE volume signature using a Basic File IO (bfio) handle
* Returns 1 if true, 0 if not or -1 on error
*/
int libbde_check_volume_signature_file_io_handle(
libbfio_handle_t *file_io_handle,
libcerror_error_t **error )
{
uint8_t signature[ 12 ];
static char *function = "libbde_check_volume_signature_file_io_handle";
ssize_t read_count = 0;
int file_io_handle_is_open = 0;
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
file_io_handle,
LIBBFIO_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
}
if( libbfio_handle_seek_offset(
file_io_handle,
0,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek file header offset: 0.",
function );
if( file_io_handle_is_open == 0 )
{
libbfio_handle_close(
file_io_handle,
error );
}
return( -1 );
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
signature,
12,
error );
if( read_count != 12 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read signature.",
function );
if( file_io_handle_is_open == 0 )
{
libbfio_handle_close(
file_io_handle,
error );
}
return( -1 );
}
if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_close(
file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file.",
function );
return( -1 );
}
}
if( memory_compare(
bde_signature,
&( signature[ 3 ] ),
8 ) == 0 )
{
return( 1 );
}
return( 0 );
}
/* Opens a file using a Basic File IO (bfio) handle
* Returns 1 if successful or -1 on error
*/
int libmsiecf_file_open_file_io_handle(
libmsiecf_file_t *file,
libbfio_handle_t *file_io_handle,
int access_flags,
libcerror_error_t **error )
{
libmsiecf_internal_file_t *internal_file = NULL;
static char *function = "libmsiecf_file_open_file_io_handle";
int bfio_access_flags = 0;
int file_io_handle_is_open = 0;
if( file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file.",
function );
return( -1 );
}
internal_file = (libmsiecf_internal_file_t *) file;
if( internal_file->file_io_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid file - file IO handle already set.",
function );
return( -1 );
}
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
if( ( ( access_flags & LIBMSIECF_ACCESS_FLAG_READ ) == 0 )
&& ( ( access_flags & LIBMSIECF_ACCESS_FLAG_WRITE ) == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported access flags.",
function );
return( -1 );
}
if( ( access_flags & LIBMSIECF_ACCESS_FLAG_WRITE ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: write access currently not supported.",
function );
return( -1 );
}
if( ( access_flags & LIBMSIECF_ACCESS_FLAG_READ ) != 0 )
{
bfio_access_flags = LIBBFIO_ACCESS_FLAG_READ;
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
goto on_error;
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
file_io_handle,
bfio_access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file IO handle.",
function );
goto on_error;
}
internal_file->file_io_handle_opened_in_library = 1;
}
internal_file->file_io_handle = file_io_handle;
if( libmsiecf_file_open_read(
internal_file,
file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file handle.",
function );
goto on_error;
}
return( 1 );
on_error:
if( ( file_io_handle_is_open == 0 )
&& ( internal_file->file_io_handle_opened_in_library != 0 ) )
{
libbfio_handle_close(
file_io_handle,
error );
}
internal_file->file_io_handle = NULL;
return( -1 );
}
/* Sets a certain handle in the pool
* Returns 1 if successful or -1 on error
*/
int libbfio_pool_set_handle(
libbfio_pool_t *pool,
int entry,
libbfio_handle_t *handle,
int flags,
liberror_error_t **error )
{
libbfio_internal_pool_t *internal_pool = NULL;
static char *function = "libbfio_pool_set_handle";
int is_open = 0;
if( pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
internal_pool = (libbfio_internal_pool_t *) pool;
if( internal_pool->last_used_list == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid pool - missing last used list.",
function );
return( -1 );
}
if( internal_pool->handles == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid pool - missing handles.",
function );
return( -1 );
}
if( ( entry < 0 )
|| ( entry >= internal_pool->amount_of_handles ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_OUT_OF_RANGE,
"%s: invalid entry value out of range.",
function );
return( -1 );
}
/* TODO allow to re set handles
* make sure all pool references are removed
*/
if( internal_pool->handles[ entry ] != NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid entry value already set.",
function );
return( -1 );
}
/* Check if the handle is open
*/
is_open = libbfio_handle_is_open(
handle,
error );
if( is_open == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if handle is open.",
function );
return( -1 );
}
internal_pool->handles[ entry ] = handle;
if( is_open == 0 )
{
/* Set the flags is the handle is not open
*/
if( libbfio_handle_set_flags(
handle,
flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to set flags.",
function );
return( -1 );
}
}
else if( internal_pool->maximum_amount_of_open_handles != LIBBFIO_POOL_UNLIMITED_AMOUNT_OF_OPEN_HANDLES )
{
if( libbfio_pool_add_handle_to_last_used_list(
internal_pool,
handle,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append handle to last used list.",
function );
return( -1 );
}
}
return( 1 );
}
/* Determines if a file is a Windows Event Log file (check for the EVT file signature) using a Basic File IO (bfio) handle
* Returns 1 if true, 0 if not or -1 on error
*/
int libevt_check_file_signature_file_io_handle(
libbfio_handle_t *file_io_handle,
libcerror_error_t **error )
{
uint8_t signature[ 8 ];
static char *function = "libevt_check_file_signature_file_io_handle";
ssize_t read_count = 0;
int file_io_handle_is_open = 0;
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
file_io_handle,
LIBBFIO_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
signature,
8,
error );
if( read_count != 8 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read signature.",
function );
libbfio_handle_close(
file_io_handle,
NULL );
return( -1 );
}
if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_close(
file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file.",
function );
return( -1 );
}
}
if( memory_compare(
evt_file_signature,
&( signature[ 4 ] ),
4 ) == 0 )
{
return( 1 );
}
return( 0 );
}
/* Opens the handle
* Returns 1 if successful or -1 on error
*/
int libbfio_pool_open_handle(
libbfio_internal_pool_t *internal_pool,
libbfio_handle_t *handle,
int flags,
liberror_error_t **error )
{
static char *function = "libbfio_pool_open_handle";
int is_open = 0;
if( internal_pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
if( internal_pool->last_used_list == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid pool - missing last used list.",
function );
return( -1 );
}
if( handle == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid handle.",
function );
return( -1 );
}
is_open = libbfio_handle_is_open(
handle,
error );
if( is_open == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if handle is open.",
function );
return( -1 );
}
else if( is_open == 1 )
{
return( 1 );
}
if( internal_pool->maximum_amount_of_open_handles != LIBBFIO_POOL_UNLIMITED_AMOUNT_OF_OPEN_HANDLES )
{
if( libbfio_pool_add_handle_to_last_used_list(
internal_pool,
handle,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append handle to last used list.",
function );
return( -1 );
}
}
if( libbfio_handle_open(
handle,
flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open handle.",
function );
return( -1 );
}
return( 1 );
}
/* Appends a handle to the pool
* Sets the entry
* Returns 1 if successful or -1 on error
*/
int libbfio_pool_add_handle(
libbfio_pool_t *pool,
int *entry,
libbfio_handle_t *handle,
int flags,
liberror_error_t **error )
{
libbfio_internal_pool_t *internal_pool = NULL;
static char *function = "libbfio_pool_add_handle";
int is_open = 0;
if( pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
internal_pool = (libbfio_internal_pool_t *) pool;
if( internal_pool->last_used_list == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid pool - missing last used list.",
function );
return( -1 );
}
if( entry == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry.",
function );
return( -1 );
}
if( handle == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid handle.",
function );
return( -1 );
}
/* Check if the handle is open
*/
is_open = libbfio_handle_is_open(
handle,
error );
if( is_open == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if handle is open.",
function );
return( -1 );
}
/* Resize the pool if necessary
*/
if( ( internal_pool->amount_of_used_handles + 1 ) >= internal_pool->amount_of_handles )
{
if( libbfio_pool_resize(
pool,
internal_pool->amount_of_handles + 1,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_RESIZE_FAILED,
"%s: unable to resize pool.",
function );
return( -1 );
}
}
*entry = internal_pool->amount_of_used_handles;
internal_pool->handles[ *entry ] = handle;
internal_pool->amount_of_used_handles++;
if( is_open == 0 )
{
/* Set the flags is the handle is not open
*/
if( libbfio_handle_set_flags(
handle,
flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to set flags.",
function );
return( -1 );
}
}
else if( internal_pool->maximum_amount_of_open_handles != LIBBFIO_POOL_UNLIMITED_AMOUNT_OF_OPEN_HANDLES )
{
if( libbfio_pool_add_handle_to_last_used_list(
internal_pool,
handle,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append handle to last used list.",
function );
return( -1 );
}
}
return( 1 );
}
/* Retrieves the current offset in a handle in the pool
* Returns 1 if successful or -1 on error
*/
int libbfio_pool_get_offset(
libbfio_pool_t *pool,
int entry,
off64_t *offset,
liberror_error_t **error )
{
libbfio_internal_pool_t *internal_pool = NULL;
static char *function = "libbfio_pool_get_offset";
int flags = 0;
int is_open = 0;
if( pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
internal_pool = (libbfio_internal_pool_t *) pool;
if( internal_pool->handles == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid pool - missing handles.",
function );
return( -1 );
}
if( ( entry < 0 )
|| ( entry >= internal_pool->amount_of_handles ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_OUT_OF_RANGE,
"%s: invalid entry.",
function );
return( -1 );
}
/* Make sure the handle is open
*/
is_open = libbfio_handle_is_open(
internal_pool->handles[ entry ],
error );
if( is_open == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if entry: %d is open.",
function,
entry );
return( -1 );
}
else if( is_open == 0 )
{
if( libbfio_handle_get_flags(
internal_pool->handles[ entry ],
&flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve flags.",
function );
return( -1 );
}
if( libbfio_pool_open_handle(
internal_pool,
internal_pool->handles[ entry ],
flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open entry: %d.",
function,
entry );
return( -1 );
}
}
if( libbfio_handle_get_offset(
internal_pool->handles[ entry ],
offset,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve offset.",
function );
return( -1 );
}
return( 1 );
}
/* Closes all the files in the pool
* Returns 0 if successful or -1 on error
*/
int libbfio_pool_close_all(
libbfio_pool_t *pool,
liberror_error_t **error )
{
libbfio_internal_pool_t *internal_pool = NULL;
static char *function = "libbfio_pool_close_all";
int handle_iterator = 0;
int is_open = 0;
int result = 0;
if( pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
internal_pool = (libbfio_internal_pool_t *) pool;
for( handle_iterator = 0; handle_iterator < internal_pool->amount_of_handles; handle_iterator++ )
{
if( internal_pool->handles[ handle_iterator ] != NULL )
{
/* Make sure the handle is open
*/
is_open = libbfio_handle_is_open(
internal_pool->handles[ handle_iterator ],
error );
if( is_open == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if entry: %d is open.",
function,
handle_iterator );
result = -1;
}
else if( ( is_open == 1 )
&& ( libbfio_pool_close(
pool,
handle_iterator,
error ) != 0 ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close handle: %d.",
function,
handle_iterator );
result = -1;
}
}
}
return( result );
}
/* Opens a handle in the pool
* Returns 1 if successful or -1 on error
*/
int libbfio_pool_open(
libbfio_pool_t *pool,
int entry,
int flags,
liberror_error_t **error )
{
libbfio_internal_pool_t *internal_pool = NULL;
static char *function = "libbfio_pool_open";
int is_open = 0;
if( pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
internal_pool = (libbfio_internal_pool_t *) pool;
if( internal_pool->handles == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid pool - missing handles.",
function );
return( -1 );
}
if( ( entry < 0 )
|| ( entry >= internal_pool->amount_of_handles ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_OUT_OF_RANGE,
"%s: invalid entry value out of range.",
function );
return( -1 );
}
/* Make sure the handle is not open
*/
is_open = libbfio_handle_is_open(
internal_pool->handles[ entry ],
error );
if( is_open == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to determine if entry: %d is open.",
function,
entry );
return( -1 );
}
else if( is_open == 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: entry: %d is already open.",
function,
entry );
return( -1 );
}
if( libbfio_pool_open_handle(
internal_pool,
internal_pool->handles[ entry ],
flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open entry: %d.",
function,
entry );
return( -1 );
}
return( 1 );
}
/* Opens a volume using a Basic File IO (bfio) handle
* Returns 1 if successful or -1 on error
*/
int libvshadow_volume_open_file_io_handle(
libvshadow_volume_t *volume,
libbfio_handle_t *file_io_handle,
int access_flags,
libcerror_error_t **error )
{
libvshadow_internal_volume_t *internal_volume = NULL;
static char *function = "libvshadow_volume_open_file_io_handle";
int bfio_access_flags = 0;
int file_io_handle_is_open = 0;
int file_io_handle_opened_in_library = 0;
if( volume == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid volume.",
function );
return( -1 );
}
internal_volume = (libvshadow_internal_volume_t *) volume;
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
if( ( ( access_flags & LIBVSHADOW_ACCESS_FLAG_READ ) == 0 )
&& ( ( access_flags & LIBVSHADOW_ACCESS_FLAG_WRITE ) == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported access flags.",
function );
return( -1 );
}
if( ( access_flags & LIBVSHADOW_ACCESS_FLAG_WRITE ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: write access currently not supported.",
function );
return( -1 );
}
if( ( access_flags & LIBVSHADOW_ACCESS_FLAG_READ ) != 0 )
{
bfio_access_flags = LIBBFIO_ACCESS_FLAG_READ;
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to determine if file IO handle is open.",
function );
goto on_error;
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
file_io_handle,
bfio_access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file IO handle.",
function );
goto on_error;
}
file_io_handle_opened_in_library = 1;
}
if( libvshadow_volume_open_read(
internal_volume,
file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from file IO handle.",
function );
goto on_error;
}
#if defined( HAVE_LIBVSHADOW_MULTI_THREAD_SUPPORT )
if( libcthreads_read_write_lock_grab_for_write(
internal_volume->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to grab read/write lock for writing.",
function );
return( -1 );
}
#endif
internal_volume->file_io_handle = file_io_handle;
internal_volume->file_io_handle_opened_in_library = file_io_handle_opened_in_library;
#if defined( HAVE_LIBVSHADOW_MULTI_THREAD_SUPPORT )
if( libcthreads_read_write_lock_release_for_write(
internal_volume->read_write_lock,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to release read/write lock for writing.",
function );
return( -1 );
}
#endif
return( 1 );
on_error:
if( file_io_handle_opened_in_library != 0 )
{
libbfio_handle_close(
file_io_handle,
NULL );
}
return( -1 );
}
/* Determines if a file contains an EWF file signature using a Basic File IO (bfio) handle
* Returns 1 if true, 0 if not or -1 on error
*/
int libewf_check_file_signature_file_io_handle(
libbfio_handle_t *file_io_handle,
libcerror_error_t **error )
{
uint8_t signature[ 8 ];
static char *function = "libewf_check_file_signature_file_io_handle";
ssize_t read_count = 0;
int file_io_handle_is_open = 0;
if( file_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file IO handle.",
function );
return( -1 );
}
file_io_handle_is_open = libbfio_handle_is_open(
file_io_handle,
error );
if( file_io_handle_is_open == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
else if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_open(
file_io_handle,
LIBBFIO_OPEN_READ,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file.",
function );
return( -1 );
}
}
if( libbfio_handle_seek_offset(
file_io_handle,
0,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek file header offset: 0.",
function );
if( file_io_handle_is_open == 0 )
{
libbfio_handle_close(
file_io_handle,
error );
}
return( -1 );
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
signature,
8,
error );
if( read_count != 8 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read signature.",
function );
libbfio_handle_close(
file_io_handle,
NULL );
return( -1 );
}
if( file_io_handle_is_open == 0 )
{
if( libbfio_handle_close(
file_io_handle,
error ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close file.",
function );
return( -1 );
}
}
/* The number of EWF segment files will be the largest
*/
if( memory_compare(
ewf1_evf_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
else if( memory_compare(
ewf1_lvf_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
else if( memory_compare(
ewf2_evf_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
else if( memory_compare(
ewf2_lef_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
else if( memory_compare(
ewf1_dvf_file_signature,
signature,
8 ) == 0 )
{
return( 1 );
}
return( 0 );
}