/* Reads string values
* Returns 1 if successful or -1 on error
*/
int libwrc_string_values_read(
libwrc_language_entry_t *language_entry,
libwrc_io_handle_t *io_handle,
libbfio_handle_t *file_io_handle,
uint32_t identifier,
libwrc_data_descriptor_t *data_descriptor,
libcerror_error_t **error )
{
libfvalue_value_t *string_value = NULL;
uint8_t *resource_data = NULL;
uint8_t *string_resource_data = NULL;
static char *function = "libwrc_string_values_read";
off64_t file_offset = 0;
size_t resource_data_size = 0;
ssize_t read_count = 0;
uint32_t string_identifier = 0;
uint32_t string_index = 0;
uint32_t string_size = 0;
int value_index = 0;
if( language_entry == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid language entry.",
function );
return( -1 );
}
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( data_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data descriptor.",
function );
return( -1 );
}
file_offset = data_descriptor->virtual_address
- io_handle->virtual_address;
if( libbfio_handle_seek_offset(
file_io_handle,
file_offset,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek resource data offset: %" PRIi64 ".",
function,
file_offset );
goto on_error;
}
resource_data_size = (size_t) data_descriptor->size;
resource_data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * resource_data_size );
if( resource_data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create resource data.",
function );
goto on_error;
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
resource_data,
resource_data_size,
error );
if( read_count != (ssize_t) resource_data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read resource data.",
function );
goto on_error;
}
string_resource_data = resource_data;
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: resource data:\n",
function );
libcnotify_print_data(
string_resource_data,
resource_data_size,
0 );
}
#endif
while( resource_data_size > 0 )
{
byte_stream_copy_to_uint16_little_endian(
string_resource_data,
string_size );
string_resource_data += sizeof( uint16_t );
resource_data_size -= sizeof( uint16_t );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: string: %02" PRIu32 " length\t\t\t\t: %" PRIu32 "\n",
function,
string_index,
string_size );
}
#endif
if( string_size > 0 )
{
string_identifier = ( identifier << 4 ) | string_index;
string_size *= 2;
if( string_size > resource_data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: string size value out of bound.",
function );
goto on_error;
}
if( libfvalue_value_type_initialize(
&string_value,
LIBFVALUE_VALUE_TYPE_STRING_UTF16,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create string value.",
function );
goto on_error;
}
if( libfvalue_value_set_identifier(
string_value,
(uint8_t *) &string_identifier,
4,
LIBFVALUE_VALUE_FLAG_IDENTIFIER_MANAGED,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to set identifier of string value.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: string: %02" PRIu32 " data:\n",
function,
string_index );
libcnotify_print_data(
string_resource_data,
(size_t) string_size,
0 );
}
#endif
if( libfvalue_value_set_data(
string_value,
string_resource_data,
(size_t) string_size,
LIBFVALUE_CODEPAGE_UTF16_LITTLE_ENDIAN,
LIBFVALUE_VALUE_DATA_FLAG_MANAGED,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set data of string value.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: string: %02" PRIu32 " value\t\t\t\t: ",
function,
string_index );
if( libfvalue_value_print(
string_value,
0,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print string value.",
function );
goto on_error;
}
libcnotify_printf(
"\n" );
}
#endif
string_resource_data += (size_t) string_size;
resource_data_size -= (size_t) string_size;
if( libwrc_language_entry_append_value(
language_entry,
&value_index,
(intptr_t *) string_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append string value.",
function );
goto on_error;
}
string_value = NULL;
}
#if defined( HAVE_DEBUG_OUTPUT )
else if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"\n" );
}
#endif
string_index++;
}
memory_free(
resource_data );
/* TODO validate if number of strings is 16 ? */
return( 1 );
on_error:
if( string_value != NULL )
{
libfvalue_value_free(
&string_value,
NULL );
}
if( resource_data != NULL )
{
memory_free(
resource_data );
}
return( -1 );
}
/* Frees record values
* Returns 1 if successful or -1 on error
*/
int libevt_record_values_free(
libevt_record_values_t **record_values,
libcerror_error_t **error )
{
static char *function = "libevt_record_values_free";
int result = 1;
if( record_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid record values.",
function );
return( -1 );
}
if( *record_values != NULL )
{
if( ( *record_values )->source_name != NULL )
{
if( libfvalue_value_free(
&( ( *record_values )->source_name ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free source name value.",
function );
result = -1;
}
}
if( ( *record_values )->computer_name != NULL )
{
if( libfvalue_value_free(
&( ( *record_values )->computer_name ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free computer name value.",
function );
result = -1;
}
}
if( ( *record_values )->user_security_identifier != NULL )
{
if( libfvalue_value_free(
&( ( *record_values )->user_security_identifier ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free user security identifier (SID).",
function );
result = -1;
}
}
if( ( *record_values )->strings != NULL )
{
if( libfvalue_value_free(
&( ( *record_values )->strings ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free strings.",
function );
result = -1;
}
}
if( ( *record_values )->data != NULL )
{
if( libfvalue_value_free(
&( ( *record_values )->data ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free data.",
function );
result = -1;
}
}
memory_free(
*record_values );
*record_values = NULL;
}
return( result );
}
/* Reads a redirected
* Returns 1 if successful or -1 on error
*/
int libmsiecf_redirected_values_read(
libmsiecf_redirected_values_t *redirected_values,
libmsiecf_io_handle_t *io_handle,
libbfio_handle_t *file_io_handle,
off64_t redirected_offset,
size32_t record_size,
uint8_t item_flags,
libcerror_error_t **error )
{
uint8_t *redr_record_data = NULL;
static char *function = "libmsiecf_redirected_values_read";
ssize_t read_count = 0;
ssize_t value_size = 0;
#if defined( HAVE_DEBUG_OUTPUT )
uint32_t value_32bit = 0;
#endif
if( redirected_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid redirected values.",
function );
return( -1 );
}
if( record_size == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS,
"%s: invalid record size value zero or less.",
function );
return( -1 );
}
#if SIZEOF_SIZE_T <= 4
if( record_size > (size32_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid record size value exceeds maximum.",
function );
return( -1 );
}
#endif
if( ( record_size % 8 ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported REDR record size.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: reading REDR record at offset: %" PRIi64 " (0x%08" PRIx64 ")\n",
function,
redirected_offset,
redirected_offset );
}
#endif
if( libbfio_handle_seek_offset(
file_io_handle,
redirected_offset,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek REDR record offset: %" PRIi64 ".",
function,
redirected_offset );
goto on_error;
}
redr_record_data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * record_size );
if( redr_record_data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create REDR record data.",
function );
goto on_error;
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
redr_record_data,
record_size,
error );
if( read_count != (ssize_t) record_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read REDR record data.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: REDR record data:\n",
function );
libcnotify_print_data(
redr_record_data,
record_size,
0 );
}
#endif
if( memory_compare(
( (msiecf_redr_record_header_t *) redr_record_data )->signature,
"REDR",
4 ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported signature.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: signature\t\t\t\t: %c%c%c%c\n",
function,
( (msiecf_redr_record_header_t *) redr_record_data )->signature[ 0 ],
( (msiecf_redr_record_header_t *) redr_record_data )->signature[ 1 ],
( (msiecf_redr_record_header_t *) redr_record_data )->signature[ 2 ],
( (msiecf_redr_record_header_t *) redr_record_data )->signature[ 3 ] );
byte_stream_copy_to_uint32_little_endian(
( (msiecf_redr_record_header_t *) redr_record_data )->number_of_blocks,
value_32bit );
libcnotify_printf(
"%s: number of blocks\t\t\t: %" PRIu32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
( (msiecf_redr_record_header_t *) redr_record_data )->unknown1,
value_32bit );
libcnotify_printf(
"%s: unknown1\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
( (msiecf_redr_record_header_t *) redr_record_data )->unknown2,
value_32bit );
libcnotify_printf(
"%s: unknown2\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
}
#endif
if( libfvalue_value_type_initialize(
&( redirected_values->location ),
LIBFVALUE_VALUE_TYPE_STRING_BYTE_STREAM,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create location value.",
function );
goto on_error;
}
value_size = libfvalue_value_type_set_data_string(
redirected_values->location,
&( redr_record_data[ 16 ] ),
record_size - 16,
io_handle->ascii_codepage,
LIBFVALUE_VALUE_DATA_FLAG_MANAGED,
error );
if( value_size == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set data of location value.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: location\t\t\t\t: ",
function );
if( libfvalue_value_print(
redirected_values->location,
0,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print location value.",
function );
goto on_error;
}
libcnotify_printf(
"\n" );
if( libmsiecf_hash_calculate(
&value_32bit,
&( redr_record_data[ 16 ] ),
record_size - 16,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to calculate location hash.",
function );
goto on_error;
}
libcnotify_printf(
"%s: hash value\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
}
#endif
if( ( redr_record_data[ 16 + value_size - 1 ] != 0 )
&& ( ( item_flags & LIBMSIECF_ITEM_FLAG_PARTIAL ) == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported unterminated location string.",
function );
goto on_error;
}
memory_free(
redr_record_data );
redr_record_data = NULL;
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"\n" );
}
#endif
return( 1 );
on_error:
if( redirected_values->location != NULL )
{
libfvalue_value_free(
&( redirected_values->location ),
NULL );
}
if( redr_record_data != NULL )
{
memory_free(
redr_record_data );
}
return( -1 );
}
/* Reads the version (resource) values
* Returns 1 if successful or -1 on error
*/
int libwrc_version_values_read(
libwrc_language_entry_t *language_entry,
libwrc_io_handle_t *io_handle,
libbfio_handle_t *file_io_handle,
libwrc_data_descriptor_t *data_descriptor,
libcerror_error_t **error )
{
libwrc_version_values_t *version_values = NULL;
libfvalue_value_t *value_identifier = NULL;
uint8_t *resource_data = NULL;
uint8_t *version_resource_data = NULL;
static char *function = "libwrc_version_values_read";
off64_t file_offset = 0;
size_t alignment_padding_size = 0;
size_t resource_data_offset = 0;
size_t resource_data_size = 0;
ssize_t read_count = 0;
uint32_t value_32bit = 0;
uint16_t value_data_size = 0;
uint16_t value_data_type = 0;
uint16_t version_resource_data_size = 0;
int value_index = 0;
if( language_entry == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid language entry.",
function );
return( -1 );
}
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( data_descriptor == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid data descriptor.",
function );
return( -1 );
}
if( libwrc_version_values_initialize(
&version_values,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create version values.",
function );
goto on_error;
}
file_offset = data_descriptor->virtual_address
- io_handle->virtual_address;
if( libbfio_handle_seek_offset(
file_io_handle,
file_offset,
SEEK_SET,
error ) == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek resource data offset: %" PRIi64 ".",
function,
file_offset );
goto on_error;
}
resource_data_size = (size_t) data_descriptor->size;
resource_data = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * resource_data_size );
if( resource_data == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create resource data.",
function );
goto on_error;
}
read_count = libbfio_handle_read_buffer(
file_io_handle,
resource_data,
resource_data_size,
error );
if( read_count != (ssize_t) resource_data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read resource data.",
function );
goto on_error;
}
version_resource_data = resource_data;
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: resource data:\n",
function );
libcnotify_print_data(
version_resource_data,
resource_data_size,
0 );
}
#endif
byte_stream_copy_to_uint16_little_endian(
( (wrc_version_value_header_t *) version_resource_data )->size,
version_resource_data_size );
byte_stream_copy_to_uint16_little_endian(
( (wrc_version_value_header_t *) version_resource_data )->value_data_size,
value_data_size );
byte_stream_copy_to_uint16_little_endian(
( (wrc_version_value_header_t *) version_resource_data )->value_data_type,
value_data_type );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: size\t\t\t\t\t: %" PRIu16 "\n",
function,
version_resource_data_size );
libcnotify_printf(
"%s: value data size\t\t\t\t: %" PRIu16 "\n",
function,
value_data_size );
libcnotify_printf(
"%s: value data type\t\t\t\t: %" PRIu16 "\n",
function,
value_data_type );
libcnotify_printf(
"\n" );
}
#endif
resource_data_offset += sizeof( wrc_version_value_header_t );
if( libfvalue_value_type_initialize(
&value_identifier,
LIBFVALUE_VALUE_TYPE_STRING_UTF16,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create value identifier value.",
function );
goto on_error;
}
read_count = libfvalue_value_type_set_data_string(
value_identifier,
&( version_resource_data[ resource_data_offset ] ),
resource_data_size,
LIBFVALUE_CODEPAGE_UTF16_LITTLE_ENDIAN,
LIBFVALUE_VALUE_DATA_FLAG_MANAGED,
error );
if( read_count == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set data of value identifier value.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: value identifier\t\t\t\t: ",
function );
if( libfvalue_value_print(
value_identifier,
0,
0,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print value identifier value.",
function );
goto on_error;
}
libcnotify_printf(
"\n" );
}
#endif
if( ( read_count != 32 )
|| ( memory_compare(
&( version_resource_data[ resource_data_offset ] ),
libwrc_version_information_value_identifier,
32 ) != 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported version resource value signature.",
function );
goto on_error;
}
if( libfvalue_value_free(
&value_identifier,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free value identifier value.",
function );
goto on_error;
}
resource_data_offset += read_count;
if( ( resource_data_offset % 4 ) != 0 )
{
alignment_padding_size = 4 - ( resource_data_offset % 4 );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: alignment padding:\n",
function );
libcnotify_print_data(
&( version_resource_data[ resource_data_offset ] ),
alignment_padding_size,
0 );
}
#endif
resource_data_offset += alignment_padding_size;
}
/* TODO refactor to separate function? */
if( value_data_size > 0 )
{
if( value_data_size > resource_data_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: value data size value out of bounds.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: value data:\n",
function );
libcnotify_print_data(
&( version_resource_data[ resource_data_offset ] ),
value_data_size,
0 );
}
#endif
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 8 ] ),
version_values->file_version );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 12 ] ),
value_32bit );
version_values->file_version <<= 32;
version_values->file_version |= value_32bit;
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 16 ] ),
version_values->product_version );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 20 ] ),
value_32bit );
version_values->product_version <<= 32;
version_values->product_version |= value_32bit;
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset ] ),
value_32bit );
libcnotify_printf(
"%s: signature\t\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 4 ] ),
value_32bit );
libcnotify_printf(
"%s: version\t\t\t\t\t: %" PRIu32 ".%" PRIu32 "\n",
function,
value_32bit >> 16,
value_32bit & 0x0000ffffUL );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 8 ] ),
value_32bit );
libcnotify_printf(
"%s: file version upper\t\t\t\t: %" PRIu32 ".%" PRIu32 "\n",
function,
value_32bit >> 16,
value_32bit & 0x0000ffffUL );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 12 ] ),
value_32bit );
libcnotify_printf(
"%s: file version lower\t\t\t\t: %" PRIu32 ".%" PRIu32 "\n",
function,
value_32bit >> 16,
value_32bit & 0x0000ffffUL );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 16 ] ),
value_32bit );
libcnotify_printf(
"%s: product version upper\t\t\t: %" PRIu32 ".%" PRIu32 "\n",
function,
value_32bit >> 16,
value_32bit & 0x0000ffffUL );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 20 ] ),
value_32bit );
libcnotify_printf(
"%s: product version lower\t\t\t: %" PRIu32 ".%" PRIu32 "\n",
function,
value_32bit >> 16,
value_32bit & 0x0000ffffUL );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 24 ] ),
value_32bit );
libcnotify_printf(
"%s: file flags bitmask\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 28 ] ),
value_32bit );
libcnotify_printf(
"%s: file flags\t\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 32 ] ),
value_32bit );
libcnotify_printf(
"%s: file operating system\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 36 ] ),
value_32bit );
libcnotify_printf(
"%s: file type\t\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 40 ] ),
value_32bit );
libcnotify_printf(
"%s: file sub type\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 44 ] ),
value_32bit );
libcnotify_printf(
"%s: file time upper\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
byte_stream_copy_to_uint32_little_endian(
&( version_resource_data[ resource_data_offset + 48 ] ),
value_32bit );
libcnotify_printf(
"%s: file time lower\t\t\t\t: 0x%08" PRIx32 "\n",
function,
value_32bit );
libcnotify_printf(
"\n" );
}
#endif
resource_data_offset += value_data_size;
}
/* Frees URL values
* Returns 1 if successful or -1 on error
*/
int libmsiecf_url_values_free(
libmsiecf_url_values_t **url_values,
libcerror_error_t **error )
{
static char *function = "libmsiecf_url_values_free";
int result = 1;
if( url_values == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid URL values.",
function );
return( -1 );
}
if( *url_values != NULL )
{
if( ( *url_values )->location != NULL )
{
if( libfvalue_value_free(
&( ( *url_values )->location ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free location value.",
function );
result = -1;
}
}
if( ( *url_values )->filename != NULL )
{
if( libfvalue_value_free(
&( ( *url_values )->filename ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free filename value.",
function );
result = -1;
}
}
if( ( *url_values )->data != NULL )
{
memory_free(
( *url_values )->data );
}
memory_free(
*url_values );
*url_values = NULL;
}
return( result );
}
