/* Reads a data block header
* Returns 1 if successful, 0 if no data block signature was found or -1 on error
*/
int libcreg_data_block_read_header(
libcreg_data_block_t *data_block,
libbfio_handle_t *file_io_handle,
libcerror_error_t **error )
{
creg_data_block_header_t data_block_header;
static char *function = "libcreg_data_block_read_header";
ssize_t read_count = 0;
#if defined( HAVE_DEBUG_OUTPUT )
uint16_t value_16bit = 0;
#endif
if( data_block == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data block.",
function );
return( -1 );
}
if( libbfio_handle_get_offset(
file_io_handle,
&( data_block->offset ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve file offset.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: reading data block header at offset: %" PRIi64 " (0x%08" PRIx64 ")\n",
function,
data_block->offset,
data_block->offset );
}
#endif
read_count = libbfio_handle_read_buffer(
file_io_handle,
(uint8_t *) &data_block_header,
sizeof( creg_data_block_header_t ),
error );
if( read_count != (ssize_t) sizeof( creg_data_block_header_t ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read data block header data.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: data block header:\n",
function );
libcnotify_print_data(
(uint8_t *) &data_block_header,
sizeof( creg_data_block_header_t ),
0 );
}
#endif
if( memory_compare(
data_block_header.signature,
creg_data_block_signature,
4 ) != 0 )
{
return( 0 );
}
byte_stream_copy_to_uint32_little_endian(
data_block_header.size,
data_block->size );
byte_stream_copy_to_uint32_little_endian(
data_block_header.unused_size,
data_block->unused_size );
byte_stream_copy_to_uint32_little_endian(
data_block_header.used_size,
data_block->used_size );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: signature\t\t\t\t: %c%c%c%c\n",
function,
data_block_header.signature[ 0 ],
data_block_header.signature[ 1 ],
data_block_header.signature[ 2 ],
data_block_header.signature[ 3 ] );
libcnotify_printf(
"%s: size\t\t\t\t\t: %" PRIu32 "\n",
function,
data_block->size );
libcnotify_printf(
"%s: unused size\t\t\t\t: %" PRIu32 "\n",
function,
data_block->unused_size );
byte_stream_copy_to_uint16_little_endian(
data_block_header.unknown1,
value_16bit );
libcnotify_printf(
"%s: unknown1\t\t\t\t: 0x%04" PRIx16 "\n",
function,
value_16bit );
byte_stream_copy_to_uint16_little_endian(
data_block_header.index,
value_16bit );
libcnotify_printf(
"%s: index\t\t\t\t\t: %" PRIu16 "\n",
function,
value_16bit );
libcnotify_printf(
"%s: used size\t\t\t\t: %" PRIi32 "\n",
function,
(int32_t) data_block->used_size );
byte_stream_copy_to_uint16_little_endian(
data_block_header.unknown2,
value_16bit );
libcnotify_printf(
"%s: unknown2\t\t\t\t: %" PRIu16 "\n",
function,
value_16bit );
byte_stream_copy_to_uint16_little_endian(
data_block_header.unknown3,
value_16bit );
libcnotify_printf(
"%s: unknown3\t\t\t\t: %" PRIu16 "\n",
function,
value_16bit );
libcnotify_printf(
"%s: unknown3:\n",
function );
libcnotify_print_data(
data_block_header.unknown4,
8,
0 );
libcnotify_printf(
"\n" );
}
#endif
/* TODO check if unused_size + used_size == size */
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 );
}
