Revision control

++ # Copyright (C) 2025 The Qt Company Ltd.
++ # SPDX-License-Identifier: BSD-3-Clause
++
++ __qt_internal_cmake_include_guard(GLOBAL GUARD_KEY "QtPublicSbomDocumentNamespaceHelpers")
++
++ # Computes the SPDX document namespace field.
++ # The document namespace is used in SPDX external references and dependency relationships.
++ function(_qt_internal_sbom_compute_project_namespace out_var)
++ set(opt_args "")
++ set(single_args
++ SUPPLIER_URL
++ PROJECT_NAME
++ VERSION_SUFFIX
++ DOCUMENT_NAMESPACE_INFIX
++ DOCUMENT_NAMESPACE_SUFFIX
++ DOCUMENT_NAMESPACE_URL_PREFIX
++ )
++ set(multi_args "")
++
++ cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ if(NOT arg_PROJECT_NAME)
++ message(FATAL_ERROR "PROJECT_NAME must be set")
++ endif()
++
++ if(NOT arg_SUPPLIER_URL)
++ message(FATAL_ERROR "SUPPLIER_URL must be set")
++ endif()
++
++ string(TOLOWER "${arg_PROJECT_NAME}" project_name_lowercase)
++
++ set(version_suffix "")
++
++ if(arg_VERSION_SUFFIX)
++ set(version_suffix "-${arg_VERSION_SUFFIX}")
++ else()
++ _qt_internal_sbom_get_git_version_vars()
++ if(QT_SBOM_GIT_VERSION)
++ set(version_suffix "-${QT_SBOM_GIT_VERSION}")
++ endif()
++ endif()
++
++ set(namespace "${project_name_lowercase}${version_suffix}")
++
++ if(arg_DOCUMENT_NAMESPACE_INFIX)
++ string(APPEND namespace "${arg_DOCUMENT_NAMESPACE_INFIX}")
++ endif()
++
++ if(arg_DOCUMENT_NAMESPACE_SUFFIX)
++ string(APPEND namespace "${arg_DOCUMENT_NAMESPACE_SUFFIX}")
++ endif()
++
++ if(arg_DOCUMENT_NAMESPACE_URL_PREFIX)
++ set(url_prefix "${arg_DOCUMENT_NAMESPACE_URL_PREFIX}")
++ else()
++ set(url_prefix "${arg_SUPPLIER_URL}/spdxdocs")
++ endif()
++
++ set(repo_spdx_namespace "${url_prefix}/${namespace}")
++
++ set(${out_var} "${repo_spdx_namespace}" PARENT_SCOPE)
++ endfunction()
++
++ # A document namespace is recommended to be either a URI + v4 random UUID or a URI + v5 UUID
++ # generated from a sha1 checksum.
++ # It needs to be unique per document.
++ # Having randomness is bad for build reproducibility, so the v4 UUID is not a good idea.
++ #
++ # Collecting enough unique content as part of the build for a checksum is difficult
++ # without outside input, and because the final document contents is only available at install time.
++ #
++ # We currently create a fake URI (that is not hosted on a web service) and a combination of the
++ # following info:
++ # - project name
++ # - project version
++ # - document namespace infix, which consists of:
++ # - platform and arch info (host + target)
++ # - a v5 UUID based on various inputs
++ # - extra content provided as input
++ # - document namespace suffix (as a last resort)
++ #
++ # The document namespace infix should make the namespace unique enough, so that different
++ # builds don't usually map to the same value, and thus is conformant to the spec.
++ function(_qt_internal_sbom_compute_uniqueish_document_namespace_infix)
++ set(opt_args "")
++ set(single_args
++ UUID_EXTRA_CONTENT
++ OUT_VAR_INFIX
++ OUT_VAR_UUID_INFIX
++ OUT_VAR_UUID_INFIX_MERGED
++ )
++ set(multi_args "")
++
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ if(NOT arg_OUT_VAR_INFIX AND NOT arg_OUT_VAR_UUID_INFIX AND NOT arg_OUT_VAR_UUID_INFIX_MERGED)
++ message(FATAL_ERROR "One of OUT_VAR_INFIX, OUT_VAR_UUID_INFIX or "
++ "OUT_VAR_UUID_INFIX_MERGED must be set")
++ endif()
++
++ if(QT_SBOM_NO_UNIQUE_NAMESPACE_INFIX)
++ set(${arg_OUT_VAR_INFIX} "" PARENT_SCOPE)
++
++ if(arg_OUT_VAR_UUID_INFIX)
++ set(${arg_OUT_VAR_UUID_INFIX} "" PARENT_SCOPE)
++ endif()
++
++ if(arg_OUT_VAR_UUID_INFIX_MERGED)
++ set(${arg_OUT_VAR_UUID_INFIX_MERGED} "" PARENT_SCOPE)
++ endif()
++
++ return()
++ endif()
++
++ # Collect the various pieces of information to build the unique-ish infix.
++ set(main_value "")
++
++ _qt_internal_sbom_get_host_platform_name(host_platform_name)
++ if(host_platform_name)
++ string(APPEND main_value "host-${host_platform_name}")
++ endif()
++
++ _qt_internal_sbom_get_host_platform_architecture(host_arch)
++ if(host_arch)
++ string(APPEND main_value "-${host_arch}")
++ endif()
++
++ _qt_internal_sbom_get_target_platform_friendly_name(target_platform_name)
++ if(target_platform_name)
++ string(APPEND main_value "-target-${target_platform_name}")
++ endif()
++
++ _qt_internal_sbom_get_target_platform_architecture(target_arch)
++ if(target_arch)
++ string(APPEND main_value "-${target_arch}")
++ endif()
++
++
++ # Collect the pieces for the infix uuid part.
++ set(uuid_content "<main_value>:${main_value}\n")
++
++ _qt_internal_sbom_get_build_tools_info_for_namespace_infix_uuid(tools_info)
++ if(tools_info)
++ string(APPEND uuid_content "<build_tools_info>:${tools_info}\n")
++ endif()
++
++ if(arg_UUID_EXTRA_CONTENT)
++ string(APPEND uuid_content "<extra_content>:\n${arg_UUID_EXTRA_CONTENT}\n")
++ endif()
++
++ if(QT_SBOM_NAMESPACE_INFIX_UUID_EXTRA_CONTENT)
++ string(APPEND uuid_content
++ "<extra_content_var>:${QT_SBOM_NAMESPACE_INFIX_UUID_EXTRA_CONTENT}\n")
++ endif()
++
++ _qt_internal_sbom_compute_document_namespace_infix_uuid(
++ UUID_CONTENT "${uuid_content}"
++ OUT_VAR_UUID uuid_value
++ )
++
++ if(arg_OUT_VAR_INFIX)
++ set(${arg_OUT_VAR_INFIX} "${main_value}" PARENT_SCOPE)
++ endif()
++
++ if(arg_OUT_VAR_UUID_INFIX)
++ set(${arg_OUT_VAR_UUID_INFIX} "${uuid_value}" PARENT_SCOPE)
++ endif()
++
++ if(arg_OUT_VAR_UUID_INFIX_MERGED)
++ set(${arg_OUT_VAR_UUID_INFIX_MERGED} "${main_value}-${uuid_value}" PARENT_SCOPE)
++ endif()
++ endfunction()
++
++ # Computes the uuid part of a SPDX document namespace, given the inputs.
++ # UUID_CONTENT - should be given enough unique content to ensure the uniqueness of generated the
++ # uuid based on the content.
++ #
++ # Allow various overrides like:
++ # - override of the full uuid content via QT_SBOM_FORCE_DOCUMENT_NAMESPACE_INFIX_UUID_CONTENT
++ # - allow using a random value via QT_SBOM_FORCE_RANDOM_DOCUMENT_NAMESPACE_INFIX_UUID_CONTENT
++ # - allow setting a specific uuid via QT_SBOM_FORCE_DOCUMENT_NAMESPACE_INFIX_UUID
++ # - fake deterministic uuid (only useful for development purposes of this code)
++ function(_qt_internal_sbom_compute_document_namespace_infix_uuid)
++ set(opt_args "")
++ set(single_args
++ UUID_CONTENT
++ OUT_VAR_UUID
++ )
++ set(multi_args "")
++
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ if(NOT arg_OUT_VAR_UUID)
++ message(FATAL_ERROR "OUT_VAR_UUID must be set")
++ endif()
++
++ set(content "${arg_UUID_CONTENT}")
++
++ _qt_internal_sbom_get_document_namespace_uuid_namespace(uuid_namespace)
++
++ # Allow various overrides.
++ if(QT_SBOM_FAKE_DETERMINISTIC_BUILD
++ # This is to allow developers test a fake build, without a fake uuid
++ AND NOT QT_SBOM_NO_FAKE_DETERMINISTIC_BUILD_DOCUMENT_NAMESPACE_INFIX_UUID
++ )
++ set(uuid_content "<fake_deterministic_build>")
++ elseif(QT_SBOM_FORCE_DOCUMENT_NAMESPACE_INFIX_UUID_CONTENT)
++ set(uuid_content "${QT_SBOM_FORCE_DOCUMENT_NAMESPACE_INFIX_UUID_CONTENT}")
++ elseif(QT_SBOM_FORCE_RANDOM_DOCUMENT_NAMESPACE_INFIX_UUID_CONTENT)
++ string(RANDOM LENGTH 256 uuid_content)
++ else()
++ set(uuid_content "${content}")
++ endif()
++
++ # Also allow direct override of uuid.
++ if(QT_SBOM_FORCE_DOCUMENT_NAMESPACE_INFIX_UUID)
++ set(namespace_infix_uuid "${QT_SBOM_FORCE_DOCUMENT_NAMESPACE_INFIX_UUID}")
++ else()
++ string(UUID namespace_infix_uuid
++ NAMESPACE "${uuid_namespace}" NAME "${uuid_content}" TYPE SHA1)
++ endif()
++
++ set(${arg_OUT_VAR_UUID} "${namespace_infix_uuid}" PARENT_SCOPE)
++ endfunction()
++
++ # A v4 uuid to be used as a namespace value for generating v5 uuids.
++ function(_qt_internal_sbom_get_document_namespace_uuid_namespace out_var)
++ # This is a randomly generated uuid v4 value. To be used for all eternity. Until we change the
++ # implementation of the function.
++ set(uuid_namespace "c024642f-9853-45b2-9bfd-ab3f061a05bb")
++ set(${out_var} "${uuid_namespace}" PARENT_SCOPE)
++ endfunction()
++
++ # Collects extra uuid content for generating a more unique document namespace uuid for qt repos.
++ function(_qt_internal_sbom_compute_qt_uniqueish_document_namespace_infix)
++ set(opt_args "")
++ set(single_args
++ OUT_VAR_INFIX
++ OUT_VAR_UUID_INFIX
++ OUT_VAR_UUID_INFIX_MERGED
++ )
++ set(multi_args "")
++
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ if(NOT arg_OUT_VAR_INFIX AND NOT arg_OUT_VAR_UUID_INFIX AND NOT arg_OUT_VAR_UUID_INFIX_MERGED)
++ message(FATAL_ERROR "One of OUT_VAR_INFIX, OUT_VAR_UUID_INFIX or "
++ "OUT_VAR_UUID_INFIX_MERGED must be set")
++ endif()
++
++ if(QT_SBOM_NO_UNIQUE_QT_NAMESPACE_INFIX)
++ set(${arg_OUT_VAR_INFIX} "" PARENT_SCOPE)
++
++ if(arg_OUT_VAR_UUID_INFIX)
++ set(${arg_OUT_VAR_UUID_INFIX} "" PARENT_SCOPE)
++ endif()
++
++ if(arg_OUT_VAR_UUID_INFIX_MERGED)
++ set(${arg_OUT_VAR_UUID_INFIX_MERGED} "" PARENT_SCOPE)
++ endif()
++
++ return()
++ endif()
++
++ set(uuid_extra_content "")
++
++ if(APPLE AND (CMAKE_OSX_ARCHITECTURES MATCHES ";"))
++ string(CONCAT building_for
++ "${QT_QMAKE_TARGET_MKSPEC} (${CMAKE_OSX_ARCHITECTURES}), ${TEST_architecture_arch} "
++ "features: ${subarch_summary})")
++ else()
++ string(CONCAT building_for
++ "${QT_QMAKE_TARGET_MKSPEC} (${TEST_architecture_arch}, "
++ "CPU features: ${subarch_summary})")
++ endif()
++
++ string(APPEND uuid_extra_content "<building_for>:${building_for}\n")
++
++ _qt_internal_get_configure_line(configure_line)
++ if(configure_line)
++ string(APPEND uuid_extra_content "<configure_line>:${configure_line}\n")
++ endif()
++
++ _qt_internal_sbom_compute_uniqueish_document_namespace_infix(
++ UUID_EXTRA_CONTENT "${uuid_extra_content}"
++ OUT_VAR_INFIX infix
++ OUT_VAR_UUID_INFIX uuid_infix
++ OUT_VAR_UUID_INFIX_MERGED uuid_infix_merged
++ )
++
++ if(arg_OUT_VAR_INFIX)
++ set(${arg_OUT_VAR_INFIX} "${infix}" PARENT_SCOPE)
++ endif()
++
++ if(arg_OUT_VAR_UUID_INFIX)
++ set(${arg_OUT_VAR_UUID_INFIX} "${uuid_infix}" PARENT_SCOPE)
++ endif()
++
++ if(arg_OUT_VAR_UUID_INFIX_MERGED)
++ set(${arg_OUT_VAR_UUID_INFIX_MERGED} "${uuid_infix_merged}" PARENT_SCOPE)
++ endif()
++ endfunction()
++
++ # Computes a short unique-ish sha suffix to embed into all Qt package SPDX ids, to ensure that each
++ # package spdx id is distinct enough between Qt builds.
++ #
++ # The use case is referencing multiple versions of the the same target, within a project that
++ # mixes multiple Qt versions, like Qt for MCU.
++ #
++ # E.g. record that MyLib depends on Qt Core 6.8.3 from qtbase spdx doc1, and that MyLib2 depends
++ # on Qt Core 6.9.1 from qtbase spdx doc2, within the generated project doc that contains MyLib and
++ # MyLib2.
++ #
++ # Default hash length chosen to be 12, to have a probability of 0.001 collisions when there are
++ # 750000 releases of the same Qt repo, according to
++ function(_qt_internal_sbom_compute_uniqueish_spdx_id_suffix)
++ set(opt_args "")
++ set(single_args
++ SPDX_NAMESPACE
++ OUT_VAR_UNIQUE_SUFFIX
++ HASH_LENGTH
++ )
++ set(multi_args "")
++
++ cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
++ _qt_internal_validate_all_args_are_parsed(arg)
++
++ if(QT_SBOM_NO_AUTO_SPDX_SUFFIX)
++ set(${arg_OUT_VAR_UNIQUE_SUFFIX} "" PARENT_SCOPE)
++ return()
++ endif()
++
++ if(NOT arg_OUT_VAR_UNIQUE_SUFFIX)
++ message(FATAL_ERROR "OUT_VAR_UNIQUE_SUFFIX must be set")
++ endif()
++
++ if(NOT arg_SPDX_NAMESPACE)
++ message(FATAL_ERROR "SPDX_NAMESPACE must be set")
++ endif()
++
++ if(QT_SBOM_FAKE_DETERMINISTIC_BUILD
++ # This is to allow developers test a fake build, without a fake uuid
++ AND NOT QT_SBOM_NO_FAKE_DETERMINISTIC_BUILD_SPDX_IDX_SUFFIX
++ )
++ set(unique_suffix "fake-id-suffix")
++ else()
++ string(SHA1 namespace_sha "${arg_SPDX_NAMESPACE}")
++
++ if(arg_HASH_LENGTH)
++ set(sha_suffix_length "${arg_HASH_LENGTH}")
++ else()
++ set(sha_suffix_length "12")
++ endif()
++
++ string(SUBSTRING "${namespace_sha}" 0 "${sha_suffix_length}" unique_suffix)
++ endif()
++
++ set(${arg_OUT_VAR_UNIQUE_SUFFIX} "${unique_suffix}" PARENT_SCOPE)
++ endfunction()
++
++ # Retrieves the current project's spdx id suffix.
++ function(_qt_internal_sbom_get_spdx_id_unique_suffix out_var)
++ get_cmake_property(unique_suffix _qt_internal_sbom_repo_spdx_id_unique_suffix)
++ if(NOT unique_suffix)
++ set(unique_suffix "")
++ endif()
++
++ set(${out_var} "${unique_suffix}" PARENT_SCOPE)
++ endfunction()
++
++ # Returns a lower case host platform name for sbom document namespace purposes.
++ function(_qt_internal_sbom_get_host_platform_name out_var)
++ string(TOLOWER "${CMAKE_HOST_SYSTEM_NAME}" main_value)
++ if(NOT main_value)
++ set(main_value "unknown-platform")
++ endif()
++
++ set(${out_var} "${main_value}" PARENT_SCOPE)
++ endfunction()
++
++ # Returns a lower case target platform name for sbom document namespace purposes.
++ function(_qt_internal_sbom_get_target_platform_friendly_name out_var)
++ string(TOLOWER "${CMAKE_SYSTEM_NAME}" lower_system_name)
++ set(friendly_name "${lower_system_name}")
++
++ if(NOT friendly_name)
++ set(friendly_name "unknown-platform")
++ endif()
++
++ if(MSVC)
++ string(APPEND friendly_name "-msvc")
++ endif()
++
++ if(MINGW)
++ string(APPEND friendly_name "-mingw")
++ endif()
++
++ if(CYGWIN)
++ string(APPEND friendly_name "-cygwin")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
++ set(friendly_name "linux")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "HPUX")
++ set(friendly_name "hpux")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "Android")
++ set(friendly_name "android")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "Integrity")
++ set(friendly_name "integrity")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "VxWorks")
++ set(friendly_name "vxworks")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "QNX")
++ set(friendly_name "qnx")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
++ set(friendly_name "openbsd")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
++ set(friendly_name "freebsd")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "NetBSD")
++ set(friendly_name "netbsd")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten" OR EMSCRIPTEN)
++ set(friendly_name "wasm")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
++ set(friendly_name "sunos")
++ endif()
++
++ if(CMAKE_SYSTEM_NAME STREQUAL "GNU")
++ set(friendly_name "hurd")
++ endif()
++
++ if(CMAKE_CXX_FLAGS MATCHES "-D__WEBOS__")
++ set(friendly_name "webos")
++ endif()
++
++ if(APPLE)
++ if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
++ set(friendly_name "ios")
++ elseif(CMAKE_SYSTEM_NAME STREQUAL "tvOS")
++ set(friendly_name "tvos")
++ elseif(CMAKE_SYSTEM_NAME STREQUAL "watchOS")
++ set(friendly_name "watchos")
++ elseif(CMAKE_SYSTEM_NAME STREQUAL "visionOS")
++ set(friendly_name "visionos")
++ else()
++ set(friendly_name "macos")
++ endif()
++ endif()
++
++ set(${out_var} "${friendly_name}" PARENT_SCOPE)
++ endfunction()
++
++ # Returns the host architecture for sbom document namespace purposes.
++ function(_qt_internal_sbom_get_host_platform_architecture out_var)
++ set(main_value "${CMAKE_HOST_SYSTEM_PROCESSOR}")
++
++ if(QT_SBOM_HOST_PLATFORM_ARCHITECTURE)
++ set(main_value "${QT_SBOM_HOST_PLATFORM_ARCHITECTURE}")
++ endif()
++
++ string(TOLOWER "${main_value}" main_value)
++
++ set(${out_var} "${main_value}" PARENT_SCOPE)
++ endfunction()
++
++ # Returns the target architecture for sbom document namespace purposes.
++ function(_qt_internal_sbom_get_target_platform_architecture out_var)
++ set(main_value "")
++ if(APPLE)
++ set(main_value "${CMALE_OSX_ARCHITECTURES}")
++ string(REPLACE ";" "_" main_value "${main_value}")
++ endif()
++
++ if(NOT main_value)
++ set(main_value "${CMAKE_SYSTEM_PROCESSOR}")
++ endif()
++
++ if(QT_SBOM_TARGET_PLATFORM_ARCHITECTURE)
++ set(main_value "${QT_SBOM_TARGET_PLATFORM_ARCHITECTURE}")
++ endif()
++
++ string(TOLOWER "${main_value}" main_value)
++
++ set(${out_var} "${main_value}" PARENT_SCOPE)
++ endfunction()
++
++ # Returns various build tool information ofr document namespace purposes.
++ function(_qt_internal_sbom_get_build_tools_info_for_namespace_infix_uuid out_var)
++ set(content "")
++
++ string(APPEND content "<cmake_version>: ${CMAKE_VERSION}\n")
++ string(APPEND content "<cmake_generator>: ${CMAKE_GENERATOR}\n")
++ string(APPEND content "<compiler>: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}\n")
++
++ if(CMAKE_CXX_COMPILER_LINKER_ID)
++ string(APPEND content "<linker>: ${CMAKE_CXX_COMPILER_LINKER_ID} "
++ "${CMAKE_CXX_COMPILER_LINKER_VERSION} "
++ "${CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT}\n")
++ endif()
++
++ set(${out_var} "${content}" PARENT_SCOPE)
++ endfunction()