/* 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 ); }