/* De- or encrypts a block of data using AES-XTS (XEX-based tweaked-codebook mode with ciphertext stealing)
* Returns 1 if successful or -1 on error
*/
int libcaes_crypt_xts(
libcaes_tweaked_context_t *context,
int mode,
const uint8_t *tweak_value,
size_t tweak_value_size,
const uint8_t *input_data,
size_t input_data_size,
uint8_t *output_data,
size_t output_data_size,
libcerror_error_t **error )
{
uint8_t encrypted_tweak_value[ 16 ];
uint8_t encrypted_tweak_value_copy[ 16 ];
libcaes_internal_tweaked_context_t *internal_context = NULL;
static char *function = "libcaes_crypt_xts";
size_t data_offset = 0;
size_t remaining_data_size = 0;
uint8_t block_index = 0;
uint8_t byte_value = 0;
uint8_t carry_bit = 0;
if( context == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid context.",
function );
return( -1 );
}
internal_context = (libcaes_internal_tweaked_context_t *) context;
if( ( mode != LIBCAES_CRYPT_MODE_DECRYPT )
&& ( mode != LIBCAES_CRYPT_MODE_ENCRYPT ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported mode.",
function );
return( -1 );
}
if( tweak_value == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid tweak value.",
function );
return( -1 );
}
if( tweak_value_size != 16 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid tweak value size value out of bounds.",
function );
return( -1 );
}
if( input_data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid input data.",
function );
return( -1 );
}
if( input_data_size < 16 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: invalid input data size value too small.",
function );
return( -1 );
}
if( input_data_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid input data size value exceeds maximum.",
function );
return( -1 );
}
if( output_data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid output data.",
function );
return( -1 );
}
if( output_data_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid output data size value exceeds maximum.",
function );
return( -1 );
}
if( output_data_size < input_data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid ouput data size smaller than input data size.",
function );
return( -1 );
}
if( libcaes_crypt_ecb(
internal_context->tweak_context,
LIBCAES_CRYPT_MODE_ENCRYPT,
tweak_value,
16,
encrypted_tweak_value,
16,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ENCRYPTION,
LIBCERROR_ENCRYPTION_ERROR_GENERIC,
"%s: unable to encrypt tweak value.",
function );
goto on_error;
}
if( memory_copy(
output_data,
input_data,
input_data_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy input data to output data.",
function );
return( -1 );
}
remaining_data_size = input_data_size;
while( ( data_offset + 16 ) <= input_data_size )
{
if( ( remaining_data_size < 32 )
&& ( remaining_data_size != 16 ) )
{
/* If the input data size is not a multitude of 16 the remaining data needs to be handled differently
*/
if( mode == LIBCAES_CRYPT_MODE_DECRYPT )
{
if( memory_copy(
encrypted_tweak_value_copy,
encrypted_tweak_value,
16 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy encrypted tweak value.",
function );
goto on_error;
}
/* Update the encrypted tweak value for the next 16-byte block
*/
carry_bit = 0;
for( block_index = 0;
block_index < 16;
block_index++ )
{
byte_value = ( encrypted_tweak_value[ block_index ] << 1 ) | carry_bit;
carry_bit = encrypted_tweak_value[ block_index ] >> 7;
encrypted_tweak_value[ block_index ] = byte_value;
}
if( carry_bit > 0 )
{
encrypted_tweak_value[ 0 ] ^= 0x87;
}
}
}
#if defined( LIBCAES_UNFOLLED_LOOPS )
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 0 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 1 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 2 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 3 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 4 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 5 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 6 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 7 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 8 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 9 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 10 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 11 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 12 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 13 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 14 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 15 ];
#else
for( block_index = 0;
block_index < 16;
block_index++ )
{
output_data[ data_offset++ ] ^= encrypted_tweak_value[ block_index ];
}
#endif
data_offset -= 16;
if( libcaes_crypt_ecb(
internal_context->main_context,
mode,
&( output_data[ data_offset ] ),
16,
&( output_data[ data_offset ] ),
16,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ENCRYPTION,
LIBCERROR_ENCRYPTION_ERROR_GENERIC,
"%s: unable to de/encrypt data.",
function );
goto on_error;
}
#if defined( LIBCAES_UNFOLLED_LOOPS )
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 0 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 1 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 2 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 3 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 4 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 5 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 6 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 7 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 8 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 9 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 10 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 11 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 12 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 13 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 14 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 15 ];
#else
for( block_index = 0;
block_index < 16;
block_index++ )
{
output_data[ data_offset++ ] ^= encrypted_tweak_value[ block_index ];
}
#endif
remaining_data_size -= 16;
/* Update the encrypted tweak value for the next 16-byte block
*/
carry_bit = 0;
for( block_index = 0;
block_index < 16;
block_index++ )
{
byte_value = ( encrypted_tweak_value[ block_index ] << 1 ) | carry_bit;
carry_bit = encrypted_tweak_value[ block_index ] >> 7;
encrypted_tweak_value[ block_index ] = byte_value;
}
if( carry_bit > 0 )
{
encrypted_tweak_value[ 0 ] ^= 0x87;
}
}
/* Any remaining data needs to be handled differently
*/
if( remaining_data_size > 0 )
{
if( mode == LIBCAES_CRYPT_MODE_DECRYPT )
{
if( memory_copy(
encrypted_tweak_value,
encrypted_tweak_value_copy,
16 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy encrypted tweak value.",
function );
goto on_error;
}
if( memory_set(
encrypted_tweak_value_copy,
0,
16 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear encrypted tweak value copy.",
function );
goto on_error;
}
}
/* Swap the data of the last 16-byte block with the remaining data
*/
data_offset -= 16;
if( memory_copy(
&( output_data[ data_offset + 16 ] ),
&( output_data[ data_offset ] ),
remaining_data_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy remaining output data.",
function );
goto on_error;
}
if( memory_copy(
&( output_data[ data_offset ] ),
&( input_data[ data_offset + 16 ] ),
remaining_data_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to copy input data to block data.",
function );
goto on_error;
}
#if defined( LIBCAES_UNFOLLED_LOOPS )
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 0 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 1 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 2 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 3 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 4 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 5 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 6 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 7 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 8 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 9 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 10 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 11 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 12 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 13 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 14 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 15 ];
#else
for( block_index = 0;
block_index < 16;
block_index++ )
{
output_data[ data_offset++ ] ^= encrypted_tweak_value[ block_index ];
}
#endif
data_offset -= 16;
if( libcaes_crypt_ecb(
internal_context->main_context,
mode,
&( output_data[ data_offset ] ),
16,
&( output_data[ data_offset ] ),
16,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ENCRYPTION,
LIBCERROR_ENCRYPTION_ERROR_GENERIC,
"%s: unable to de/encrypt data.",
function );
goto on_error;
}
#if defined( LIBCAES_UNFOLLED_LOOPS )
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 0 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 1 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 2 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 3 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 4 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 5 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 6 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 7 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 8 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 9 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 10 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 11 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 12 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 13 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 14 ];
output_data[ data_offset++ ] ^= encrypted_tweak_value[ 15 ];
#else
for( block_index = 0;
block_index < 16;
block_index++ )
{
output_data[ data_offset++ ] ^= encrypted_tweak_value[ block_index ];
}
#endif
}
if( memory_set(
encrypted_tweak_value,
0,
16 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear encrypted tweak value.",
function );
goto on_error;
}
return( 1 );
on_error:
memory_set(
encrypted_tweak_value_copy,
0,
16 );
memory_set(
encrypted_tweak_value,
0,
16 );
return( -1 );
}
/* Creates a section
* Make sure the value section is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libexe_section_initialize(
libexe_section_t **section,
libexe_io_handle_t *io_handle,
libbfio_handle_t *file_io_handle,
libexe_section_descriptor_t *section_descriptor,
libcerror_error_t **error )
{
libexe_internal_section_t *internal_section = NULL;
static char *function = "libexe_section_initialize";
if( section == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid section.",
function );
return( -1 );
}
if( *section != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid section value already set.",
function );
return( -1 );
}
if( section_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid section descriptor.",
function );
return( -1 );
}
internal_section = memory_allocate_structure(
libexe_internal_section_t );
if( internal_section == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create internal section.",
function );
goto on_error;
}
if( memory_set(
internal_section,
0,
sizeof( libexe_internal_section_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear internal section.",
function );
memory_free(
internal_section );
return( -1 );
}
internal_section->file_io_handle = file_io_handle;
internal_section->io_handle = io_handle;
internal_section->section_descriptor = section_descriptor;
*section = (libexe_section_t *) internal_section;
return( 1 );
on_error:
if( internal_section != NULL )
{
memory_free(
internal_section );
}
return( -1 );
}
/* Creates a catalog
* Make sure the value catalog is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libesedb_catalog_initialize(
libesedb_catalog_t **catalog,
libcerror_error_t **error )
{
static char *function = "libesedb_catalog_initialize";
if( catalog == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid catalog.",
function );
return( -1 );
}
if( *catalog != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid catalog value already set.",
function );
return( -1 );
}
*catalog = memory_allocate_structure(
libesedb_catalog_t );
if( *catalog == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create catalog.",
function );
goto on_error;
}
if( memory_set(
*catalog,
0,
sizeof( libesedb_catalog_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear catalog.",
function );
goto on_error;
}
if( libcdata_list_initialize(
&( ( *catalog )->table_definition_list ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create table definition list.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *catalog != NULL )
{
memory_free(
*catalog );
*catalog = NULL;
}
return( -1 );
}
/* Creates a registry file
* Make sure the value registry_file is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int registry_file_initialize(
registry_file_t **registry_file,
libcerror_error_t **error )
{
static char *function = "registry_file_initialize";
if( registry_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid registry file.",
function );
return( -1 );
}
if( *registry_file != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid registry file value already set.",
function );
return( -1 );
}
*registry_file = memory_allocate_structure(
registry_file_t );
if( *registry_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create registry file.",
function );
goto on_error;
}
if( memory_set(
*registry_file,
0,
sizeof( registry_file_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear registry file.",
function );
memory_free(
*registry_file );
*registry_file = NULL;
return( -1 );
}
if( libregf_file_initialize(
&( ( *registry_file )->regf_file ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize REGF file.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *registry_file != NULL )
{
memory_free(
*registry_file );
*registry_file = NULL;
}
return( -1 );
}
/* Creates an attached file IO handle
* Make sure the value io_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libpff_attached_file_io_handle_initialize(
libpff_attached_file_io_handle_t **io_handle,
libpff_item_t *attachment,
libcerror_error_t **error )
{
static char *function = "libpff_attached_file_io_handle_initialize";
if( io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid IO handle.",
function );
return( -1 );
}
if( *io_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid IO handle value already set.",
function );
return( -1 );
}
if( attachment == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid attachment.",
function );
return( -1 );
}
*io_handle = memory_allocate_structure(
libpff_attached_file_io_handle_t );
if( *io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create IO handle.",
function );
goto on_error;
}
if( memory_set(
*io_handle,
0,
sizeof( libpff_attached_file_io_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear IO handle.",
function );
goto on_error;
}
( *io_handle )->attachment = attachment;
return( 1 );
on_error:
if( *io_handle != NULL )
{
memory_free(
*io_handle );
*io_handle = NULL;
}
return( -1 );
}
/* Creates a channel
* Make sure the value channel is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfwevt_channel_initialize(
libfwevt_channel_t **channel,
libcerror_error_t **error )
{
libfwevt_internal_channel_t *internal_channel = NULL;
static char *function = "libfwevt_channel_initialize";
if( channel == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid channel.",
function );
return( -1 );
}
if( *channel != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid channel value already set.",
function );
return( -1 );
}
internal_channel = memory_allocate_structure(
libfwevt_internal_channel_t );
if( internal_channel == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create channel.",
function );
goto on_error;
}
if( memory_set(
internal_channel,
0,
sizeof( libfwevt_internal_channel_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear channel.",
function );
goto on_error;
}
*channel = (libfwevt_channel_t *) internal_channel;
return( 1 );
on_error:
if( internal_channel != NULL )
{
memory_free(
internal_channel );
}
return( -1 );
}
/* Creates an IO handle
* Make sure the value io_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libesedb_io_handle_initialize(
libesedb_io_handle_t **io_handle,
libcerror_error_t **error )
{
static char *function = "libesedb_io_handle_initialize";
if( io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid IO handle.",
function );
return( -1 );
}
if( *io_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid IO handle value already set.",
function );
return( -1 );
}
*io_handle = memory_allocate_structure(
libesedb_io_handle_t );
if( *io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create IO handle.",
function );
goto on_error;
}
if( memory_set(
*io_handle,
0,
sizeof( libesedb_io_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear IO handle.",
function );
goto on_error;
}
( *io_handle )->ascii_codepage = LIBESEDB_CODEPAGE_WINDOWS_1252;
return( 1 );
on_error:
if( *io_handle != NULL )
{
memory_free(
*io_handle );
*io_handle = NULL;
}
return( -1 );
}
/* Creates file information
* Make sure the value file_information is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libscca_file_information_initialize(
libscca_file_information_t **file_information,
libcerror_error_t **error )
{
static char *function = "libscca_file_information_initialize";
if( file_information == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file information.",
function );
return( -1 );
}
if( *file_information != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid file information value already set.",
function );
return( -1 );
}
*file_information = memory_allocate_structure(
libscca_file_information_t );
if( *file_information == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create file information.",
function );
goto on_error;
}
if( memory_set(
*file_information,
0,
sizeof( libscca_file_information_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear file.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *file_information != NULL )
{
memory_free(
*file_information );
*file_information = NULL;
}
return( -1 );
}
/* Creates a resource file
* Make sure the value resource_file is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int resource_file_initialize(
resource_file_t **resource_file,
uint32_t preferred_language_identifier,
libcerror_error_t **error )
{
static char *function = "resource_file_initialize";
if( resource_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid resource file.",
function );
return( -1 );
}
if( *resource_file != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid resource file value already set.",
function );
return( -1 );
}
*resource_file = memory_allocate_structure(
resource_file_t );
if( *resource_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create resource file.",
function );
goto on_error;
}
if( memory_set(
*resource_file,
0,
sizeof( resource_file_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear resource file.",
function );
memory_free(
*resource_file );
*resource_file = NULL;
return( -1 );
}
if( libexe_file_initialize(
&( ( *resource_file )->exe_file ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create EXE file.",
function );
goto on_error;
}
if( libwrc_stream_initialize(
&( ( *resource_file )->resource_stream ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create resource stream.",
function );
goto on_error;
}
if( libfcache_cache_initialize(
&( ( *resource_file )->message_string_cache ),
16,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create message string cache.",
function );
goto on_error;
}
( *resource_file )->preferred_language_identifier = preferred_language_identifier;
return( 1 );
on_error:
if( *resource_file != NULL )
{
if( ( *resource_file )->resource_stream != NULL )
{
libwrc_stream_free(
&( ( *resource_file )->resource_stream ),
NULL );
}
if( ( *resource_file )->exe_file != NULL )
{
libexe_file_free(
&( ( *resource_file )->exe_file ),
NULL );
}
memory_free(
*resource_file );
*resource_file = NULL;
}
return( -1 );
}
/* Resizes the values table
* Returns 1 if successful or -1 on error
*/
int libewf_values_table_resize(
libewf_values_table_t *values_table,
int amount_of_values,
liberror_error_t **error )
{
static char *function = "libewf_values_table_resize";
void *reallocation = NULL;
size_t values_table_size = 0;
size_t values_table_string_size = 0;
if( values_table == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid values table.",
function );
return( -1 );
}
if( amount_of_values < 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid amount of values less than zero.",
function );
return( -1 );
}
if( values_table->amount_of_values < amount_of_values )
{
values_table_string_size = amount_of_values * sizeof( uint8_t * );
if( values_table_string_size > (ssize_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid values table string size value exceeds maximum.",
function );
return( -1 );
}
values_table_size = amount_of_values * sizeof( size_t );
if( values_table_size > (ssize_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid values table size value exceeds maximum.",
function );
return( -1 );
}
reallocation = memory_reallocate(
values_table->identifier,
values_table_string_size );
if( reallocation == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize identifiers.",
function );
return( -1 );
}
values_table->identifier = (uint8_t **) reallocation;
if( memory_set(
&( values_table->identifier[ values_table->amount_of_values ] ),
0,
sizeof( uint8_t * ) * ( amount_of_values - values_table->amount_of_values ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear identifiers.",
function );
return( -1 );
}
reallocation = memory_reallocate(
values_table->identifier_length,
values_table_size );
if( reallocation == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize identifier lengths.",
function );
return( -1 );
}
values_table->identifier_length = (size_t *) reallocation;
if( memory_set(
&( values_table->identifier_length[ values_table->amount_of_values ] ),
0,
sizeof( size_t ) * ( amount_of_values - values_table->amount_of_values ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear identifier lengths.",
function );
return( -1 );
}
reallocation = memory_reallocate(
values_table->value,
values_table_string_size );
if( reallocation == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize values.",
function );
return( -1 );
}
values_table->value = (uint8_t **) reallocation;
if( memory_set(
&( values_table->value[ values_table->amount_of_values ] ),
0,
sizeof( uint8_t * ) * ( amount_of_values - values_table->amount_of_values ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear values.",
function );
return( -1 );
}
reallocation = memory_reallocate(
values_table->value_length,
values_table_size );
if( reallocation == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize value lengths.",
function );
return( -1 );
}
values_table->value_length = (size_t *) reallocation;
if( memory_set(
&( values_table->value_length[ values_table->amount_of_values ] ),
0,
sizeof( size_t ) * ( amount_of_values - values_table->amount_of_values ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear value sizes.",
function );
return( -1 );
}
values_table->amount_of_values = amount_of_values;
}
return( 1 );
}
/* Creates a store block
* Make sure the value store_block is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libvshadow_store_block_initialize(
libvshadow_store_block_t **store_block,
size_t block_size,
libcerror_error_t **error )
{
static char *function = "libvshadow_store_block_initialize";
if( store_block == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid store block.",
function );
return( -1 );
}
if( *store_block != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid store block value already set.",
function );
return( -1 );
}
if( block_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid block size value exceeds maximum.",
function );
return( -1 );
}
*store_block = memory_allocate_structure(
libvshadow_store_block_t );
if( store_block == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create store block.",
function );
goto on_error;
}
if( memory_set(
*store_block,
0,
sizeof( libvshadow_store_block_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear store block.",
function );
goto on_error;
}
( *store_block )->data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * block_size );
if( ( *store_block )->data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create store block data.",
function );
goto on_error;
}
( *store_block )->data_size = block_size;
return( 1 );
on_error:
if( *store_block != NULL )
{
memory_free(
*store_block );
*store_block = NULL;
}
return( -1 );
}
/* Initializes the values table
* Returns 1 if successful or -1 on error
*/
int libewf_values_table_initialize(
libewf_values_table_t **values_table,
int amount_of_values,
liberror_error_t **error )
{
static char *function = "libewf_values_table_initialize";
size_t values_table_size = 0;
size_t values_table_string_size = 0;
if( values_table == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid values table.",
function );
return( 1 );
}
if( amount_of_values < 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid amount of values less than zero.",
function );
return( -1 );
}
if( *values_table == NULL )
{
values_table_string_size = amount_of_values * sizeof( uint8_t * );
if( values_table_string_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid values table string size value exceeds maximum.",
function );
return( -1 );
}
values_table_size = amount_of_values * sizeof( size_t );
if( values_table_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid values table size value exceeds maximum.",
function );
return( -1 );
}
*values_table = (libewf_values_table_t *) memory_allocate(
sizeof( libewf_values_table_t ) );
if( *values_table == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create values table.",
function );
return( -1 );
}
( *values_table )->identifier = (uint8_t **) memory_allocate(
values_table_string_size );
if( ( *values_table )->identifier == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create identifiers.",
function );
memory_free(
*values_table );
return( -1 );
}
if( memory_set(
( *values_table )->identifier,
0,
values_table_string_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear identifiers.",
function );
memory_free(
( *values_table )->identifier );
memory_free(
*values_table );
return( -1 );
}
( *values_table )->identifier_length = (size_t *) memory_allocate(
values_table_size );
if( ( *values_table )->identifier_length == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create identifier lengths.",
function );
memory_free(
( *values_table )->identifier );
memory_free(
*values_table );
return( -1 );
}
if( memory_set(
( *values_table )->identifier_length,
0,
values_table_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear identifier lengths.",
function );
memory_free(
( *values_table )->identifier_length );
memory_free(
( *values_table )->identifier );
memory_free(
*values_table );
return( -1 );
}
( *values_table )->value = (uint8_t **) memory_allocate(
values_table_string_size );
if( ( *values_table )->value == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create values.",
function );
memory_free(
( *values_table )->identifier_length );
memory_free(
( *values_table )->identifier );
memory_free(
*values_table );
return( -1 );
}
if( memory_set(
( *values_table )->value,
0,
values_table_string_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear values.",
function );
memory_free(
( *values_table )->value );
memory_free(
( *values_table )->identifier_length );
memory_free(
( *values_table )->identifier );
memory_free(
*values_table );
return( -1 );
}
( *values_table )->value_length = (size_t *) memory_allocate(
values_table_size );
if( ( *values_table )->value_length == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create value lengths.",
function );
memory_free(
( *values_table )->value );
memory_free(
( *values_table )->identifier_length );
memory_free(
( *values_table )->identifier );
memory_free(
*values_table );
return( -1 );
}
if( memory_set(
( *values_table )->value_length,
0,
values_table_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear value lengths.",
function );
memory_free(
( *values_table )->value_length );
memory_free(
( *values_table )->value );
memory_free(
( *values_table )->identifier_length );
memory_free(
( *values_table )->identifier );
memory_free(
*values_table );
return( -1 );
}
( *values_table )->amount_of_values = amount_of_values;
}
return( 1 );
}
/* Creates a physical volume
* Make sure the value physical_volume is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libvslvm_physical_volume_initialize(
libvslvm_physical_volume_t **physical_volume,
libcerror_error_t **error )
{
libvslvm_internal_physical_volume_t *internal_physical_volume = NULL;
static char *function = "libvslvm_physical_volume_initialize";
if( physical_volume == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid physical volume.",
function );
return( -1 );
}
if( *physical_volume != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid physical volume value already set.",
function );
return( -1 );
}
internal_physical_volume = memory_allocate_structure(
libvslvm_internal_physical_volume_t );
if( internal_physical_volume == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create physical volume.",
function );
goto on_error;
}
if( memory_set(
internal_physical_volume,
0,
sizeof( libvslvm_internal_physical_volume_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear physical volume.",
function );
memory_free(
internal_physical_volume );
return( -1 );
}
if( libcdata_array_initialize(
&( internal_physical_volume->data_area_descriptors_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create data area descripors array.",
function );
goto on_error;
}
if( libcdata_array_initialize(
&( internal_physical_volume->metadata_area_descriptors_array ),
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create metadata area descripors array.",
function );
goto on_error;
}
*physical_volume= (libvslvm_physical_volume_t *) internal_physical_volume;
return( 1 );
on_error:
if( internal_physical_volume != NULL )
{
if( internal_physical_volume->data_area_descriptors_array != NULL )
{
libcdata_array_free(
&( internal_physical_volume->data_area_descriptors_array ),
NULL,
NULL );
}
memory_free(
internal_physical_volume );
}
return( -1 );
}
/* Creates a tweaked context
* Make sure the value context is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libcaes_tweaked_context_initialize(
libcaes_tweaked_context_t **context,
libcerror_error_t **error )
{
libcaes_internal_tweaked_context_t *internal_context = NULL;
static char *function = "libcaes_tweaked_context_initialize";
if( context == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid context.",
function );
return( -1 );
}
if( *context != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid context value already set.",
function );
return( -1 );
}
internal_context = memory_allocate_structure(
libcaes_internal_tweaked_context_t );
if( internal_context == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create context.",
function );
goto on_error;
}
if( memory_set(
internal_context,
0,
sizeof( libcaes_internal_tweaked_context_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear context.",
function );
memory_free(
internal_context );
return( -1 );
}
if( libcaes_context_initialize(
&( internal_context->main_context ),
error ) != 1)
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize main context.",
function );
goto on_error;
}
if( libcaes_context_initialize(
&( internal_context->tweak_context ),
error ) != 1)
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize tweak context.",
function );
goto on_error;
}
*context = (libcaes_tweaked_context_t *) internal_context;
return( 1 );
on_error:
if( internal_context != NULL )
{
if( internal_context->main_context != NULL )
{
libcaes_context_free(
&( internal_context->main_context ),
NULL );
}
memory_free(
internal_context );
}
return( -1 );
}
Void data(Value value) {
memory_set(memory_current_free_address, value);
memory_current_free_address =
memory_current_free_address + cell;
}
/* Determines if a file exists
* This function uses the POSIX stat function or equivalent
* Returns 1 if the file exists, 0 if not or -1 on error
*/
int libcfile_file_exists(
const char *filename,
libcerror_error_t **error )
{
struct stat file_statistics;
static char *function = "libcfile_file_exists";
int result = 0;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
if( memory_set(
&file_statistics,
0,
sizeof( struct stat ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear file statistics.",
function );
return( -1 );
}
result = stat(
filename,
&file_statistics );
if( result != 0 )
{
switch( errno )
{
case EACCES:
result = 1;
break;
case ENOENT:
result = 0;
break;
default:
libcerror_system_set_error(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_GENERIC,
errno,
"%s: unable to stat file: %" PRIs_LIBCSTRING_SYSTEM ".",
function,
filename );
return( -1 );
}
}
else
{
result = 1;
}
return( result );
}
Void argument_stack_push(Value value) {
memory_set(argument_stack_current_free_address, value);
argument_stack_current_free_address =
argument_stack_current_free_address + cell;
}
/* Creates an array
* Make sure the value array is pointing to is set to NULL
* Returns 1 if successful or -1 on error
*/
int libfvalue_array_initialize(
libfvalue_array_t **array,
int number_of_entries,
liberror_error_t **error )
{
static char *function = "libfvalue_array_initialize";
size_t entries_size = 0;
if( array == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
if( *array != NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid array value already set.",
function );
return( -1 );
}
if( number_of_entries < 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid number of entries.",
function );
return( -1 );
}
*array = memory_allocate_structure(
libfvalue_array_t );
if( *array == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create array.",
function );
goto on_error;
}
if( memory_set(
*array,
0,
sizeof( libfvalue_array_t ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear array.",
function );
goto on_error;
}
if( number_of_entries > 0 )
{
entries_size = sizeof( intptr_t * ) * number_of_entries;
if( entries_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid entries size value exceeds maximum.",
function );
goto on_error;
}
( *array )->entries = (intptr_t **) memory_allocate(
entries_size );
if( ( *array )->entries == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create array entries.",
function );
goto on_error;
}
if( memory_set(
( *array )->entries,
0,
entries_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear array entries.",
function );
goto on_error;
}
( *array )->number_of_allocated_entries = number_of_entries;
( *array )->number_of_entries = number_of_entries;
}
return( 1 );
on_error:
if( *array != NULL )
{
if( ( *array )->entries != NULL )
{
memory_free(
( *array )->entries );
}
memory_free(
*array );
*array = NULL;
}
return( -1 );
}
/* Initialize the segment file handle
* Returns 1 if successful or -1 on error
*/
int libewf_segment_file_handle_initialize(
libewf_segment_file_handle_t **segment_file_handle,
int segment_file_index,
libcerror_error_t **error )
{
static char *function = "libewf_segment_file_handle_initialize";
if( segment_file_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment file handle.",
function );
return( -1 );
}
if( *segment_file_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid segment file handle value already set.",
function );
return( -1 );
}
if( segment_file_index < 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO,
"%s: invalid segment file index value less than zero.",
function );
return( -1 );
}
*segment_file_handle = memory_allocate_structure(
libewf_segment_file_handle_t );
if( *segment_file_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create segment file handle.",
function );
goto on_error;
}
if( memory_set(
*segment_file_handle,
0,
sizeof( libewf_segment_file_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear segment file handle.",
function );
goto on_error;
}
( *segment_file_handle )->segment_file_index = segment_file_index;
return( 1 );
on_error:
if( *segment_file_handle != NULL )
{
memory_free(
*segment_file_handle );
*segment_file_handle = NULL;
}
return( -1 );
}
/* Resizes an array
* Returns 1 if successful or -1 on error
*/
int libfvalue_array_resize(
libfvalue_array_t *array,
int number_of_entries,
int (*entry_free_function)(
intptr_t **entry,
liberror_error_t **error ),
liberror_error_t **error )
{
void *reallocation = NULL;
static char *function = "libfvalue_array_resize";
size_t entries_size = 0;
int entry_iterator = 0;
int result = 1;
if( array == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid array.",
function );
return( -1 );
}
if( number_of_entries < 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid number of entries.",
function );
return( -1 );
}
if( number_of_entries > array->number_of_allocated_entries )
{
entries_size = sizeof( intptr_t * ) * number_of_entries;
if( entries_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid entries size value exceeds maximum.",
function );
return( -1 );
}
reallocation = memory_reallocate(
array->entries,
entries_size );
if( reallocation == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to resize array entries.",
function );
return( -1 );
}
array->entries = (intptr_t **) reallocation;
if( memory_set(
&( array->entries[ array->number_of_allocated_entries ] ),
0,
sizeof( intptr_t * ) * ( number_of_entries - array->number_of_allocated_entries ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear array entries.",
function );
result = -1;
}
array->number_of_allocated_entries = number_of_entries;
array->number_of_entries = number_of_entries;
}
else if( number_of_entries > array->number_of_entries )
{
array->number_of_entries = number_of_entries;
}
else if( array->entries != NULL )
{
if( entry_free_function == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid entry free function.",
function );
return( -1 );
}
for( entry_iterator = number_of_entries;
entry_iterator < array->number_of_entries;
entry_iterator++ )
{
if( array->entries[ entry_iterator ] != NULL )
{
if( entry_free_function != NULL )
{
if( entry_free_function(
&( array->entries[ entry_iterator ] ),
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free array entry: %d.",
function,
entry_iterator );
result = -1;
}
}
array->entries[ entry_iterator ] = NULL;
}
}
array->number_of_entries = number_of_entries;
}
return( result );
}
/* Creates a section descriptor
* Make sure the value section_descriptor is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libewf_section_descriptor_initialize(
libewf_section_descriptor_t **section_descriptor,
libcerror_error_t **error )
{
static char *function = "libewf_section_descriptor_initialize";
if( section_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid section descriptor.",
function );
return( -1 );
}
if( *section_descriptor != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid section descriptor value already set.",
function );
return( -1 );
}
*section_descriptor = memory_allocate_structure(
libewf_section_descriptor_t );
if( *section_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create section descriptor.",
function );
goto on_error;
}
if( memory_set(
*section_descriptor,
0,
sizeof( libewf_section_descriptor_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear section descriptor.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *section_descriptor != NULL )
{
memory_free(
*section_descriptor );
*section_descriptor = NULL;
}
return( -1 );
}
/* Creates an info handle
* Make sure the value info_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int info_handle_initialize(
info_handle_t **info_handle,
libcerror_error_t **error )
{
static char *function = "info_handle_initialize";
if( info_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid info handle.",
function );
return( -1 );
}
if( *info_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid info handle value already set.",
function );
return( -1 );
}
*info_handle = memory_allocate_structure(
info_handle_t );
if( *info_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create info handle.",
function );
goto on_error;
}
if( memory_set(
*info_handle,
0,
sizeof( info_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear info handle.",
function );
goto on_error;
}
if( libevt_file_initialize(
&( ( *info_handle )->input_file ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input file.",
function );
goto on_error;
}
( *info_handle )->event_log_type = EVTTOOLS_EVENT_LOG_TYPE_UNKNOWN;
( *info_handle )->ascii_codepage = LIBEVT_CODEPAGE_WINDOWS_1252;
( *info_handle )->notify_stream = INFO_HANDLE_NOTIFY_STREAM;
return( 1 );
on_error:
if( *info_handle != NULL )
{
memory_free(
*info_handle );
*info_handle = NULL;
}
return( -1 );
}
/* Creates version values
* Make sure the value version_values is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libwrc_version_values_initialize(
libwrc_version_values_t **version_values,
libcerror_error_t **error )
{
static char *function = "libwrc_version_values_initialize";
if( version_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid version values.",
function );
return( -1 );
}
if( *version_values != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid version values value already set.",
function );
return( -1 );
}
*version_values = memory_allocate_structure(
libwrc_version_values_t );
if( *version_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create version values.",
function );
goto on_error;
}
if( memory_set(
*version_values,
0,
sizeof( libwrc_version_values_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear version values.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *version_values != NULL )
{
memory_free(
*version_values );
*version_values = NULL;
}
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 );
}
/* Creates an export handle
* Make sure the value export_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int export_handle_initialize(
export_handle_t **export_handle,
libcerror_error_t **error )
{
static char *function = "export_handle_initialize";
if( export_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid export handle.",
function );
return( -1 );
}
if( *export_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid export handle value already set.",
function );
return( -1 );
}
*export_handle = memory_allocate_structure(
export_handle_t );
if( *export_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create export handle.",
function );
goto on_error;
}
if( memory_set(
*export_handle,
0,
sizeof( export_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear export handle.",
function );
goto on_error;
}
if( libolecf_file_initialize(
&( ( *export_handle )->input_file ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input file.",
function );
goto on_error;
}
( *export_handle )->ascii_codepage = LIBOLECF_CODEPAGE_WINDOWS_1252;
( *export_handle )->notify_stream = EXPORT_HANDLE_NOTIFY_STREAM;
return( 1 );
on_error:
if( *export_handle != NULL )
{
memory_free(
*export_handle );
*export_handle = NULL;
}
return( -1 );
}
/* Initializes the mount handle
* Returns 1 if successful or -1 on error
*/
int mount_handle_initialize(
mount_handle_t **mount_handle,
libcerror_error_t **error )
{
static char *function = "mount_handle_initialize";
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
if( *mount_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid info handle value already set.",
function );
return( -1 );
}
*mount_handle = memory_allocate_structure(
mount_handle_t );
if( *mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create mount handle.",
function );
goto on_error;
}
if( memory_set(
*mount_handle,
0,
sizeof( mount_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear mount handle.",
function );
goto on_error;
}
if( libewf_handle_initialize(
&( ( *mount_handle )->input_handle ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize input handle.",
function );
goto on_error;
}
( *mount_handle )->input_format = MOUNT_HANDLE_INPUT_FORMAT_RAW;
return( 1 );
on_error:
if( *mount_handle != NULL )
{
memory_free(
*mount_handle );
*mount_handle = NULL;
}
return( -1 );
}
/* Creates a page value
* Make sure the value page_value is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int libesedb_page_value_initialize(
libesedb_page_value_t **page_value,
libcerror_error_t **error )
{
static char *function = "libesedb_page_value_initialize";
if( page_value == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid page value.",
function );
return( -1 );
}
if( *page_value != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid page value value already set.",
function );
return( -1 );
}
*page_value = memory_allocate_structure(
libesedb_page_value_t );
if( *page_value == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create page value.",
function );
goto on_error;
}
if( memory_set(
*page_value,
0,
sizeof( libesedb_page_value_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear page value.",
function );
goto on_error;
}
return( 1 );
on_error:
if( *page_value != NULL )
{
memory_free(
*page_value );
*page_value = NULL;
}
return( -1 );
}
Void return_stack_push(Value value) {
memory_set(return_stack_current_free_address, value);
return_stack_current_free_address =
return_stack_current_free_address + cell;
}
/* Creates a mount handle
* Make sure the value mount_handle is referencing, is set to NULL
* Returns 1 if successful or -1 on error
*/
int mount_handle_initialize(
mount_handle_t **mount_handle,
libcerror_error_t **error )
{
static char *function = "mount_handle_initialize";
if( mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid mount handle.",
function );
return( -1 );
}
if( *mount_handle != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid mount handle value already set.",
function );
return( -1 );
}
*mount_handle = memory_allocate_structure(
mount_handle_t );
if( *mount_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create mount handle.",
function );
goto on_error;
}
if( memory_set(
*mount_handle,
0,
sizeof( mount_handle_t ) ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear mount handle.",
function );
goto on_error;
}
if( mount_file_system_initialize(
&( ( *mount_handle )->file_system ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to initialize file system.",
function );
goto on_error;
}
( *mount_handle )->ascii_codepage = LIBREGF_CODEPAGE_WINDOWS_1252;
return( 1 );
on_error:
if( *mount_handle != NULL )
{
memory_free(
*mount_handle );
*mount_handle = NULL;
}
return( -1 );
}
/* Initialize the sector table
* Returns 1 if successful or -1 on error
*/
int libewf_sector_table_initialize(
libewf_sector_table_t **sector_table,
uint32_t amount,
liberror_error_t **error )
{
static char *function = "libewf_sector_table_initialize";
size_t sector_table_size = 0;
if( sector_table == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid sector table.",
function );
return( -1 );
}
if( *sector_table == NULL )
{
sector_table_size = sizeof( libewf_sector_table_entry_t ) * amount;
if( sector_table_size > (size_t) SSIZE_MAX )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid sector table size value exceeds maximum.",
function );
return( -1 );
}
*sector_table = (libewf_sector_table_t *) memory_allocate(
sizeof( libewf_sector_table_t ) );
if( *sector_table == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create sector table.",
function );
return( -1 );
}
if( memory_set(
*sector_table,
0,
sizeof( libewf_sector_table_t ) ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear sector table.",
function );
memory_free(
*sector_table );
*sector_table = NULL;
return( -1 );
}
if( amount > 0 )
{
( *sector_table )->sector = (libewf_sector_table_entry_t *) memory_allocate(
sector_table_size );
if( ( *sector_table )->sector == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create sector array.",
function );
memory_free(
*sector_table );
*sector_table = NULL;
return( -1 );
}
if( memory_set(
( *sector_table )->sector,
0,
sector_table_size ) == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_MEMORY,
LIBERROR_MEMORY_ERROR_SET_FAILED,
"%s: unable to clear sector array.",
function );
memory_free(
( *sector_table )->sector );
memory_free(
*sector_table );
*sector_table = NULL;
return( -1 );
}
}
( *sector_table )->amount = amount;
}
return( 1 );
}
