435 строки
16 KiB
CMake
435 строки
16 KiB
CMake
# Copyright (c) Microsoft. All rights reserved.
|
|
# Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
|
|
|
cmake_minimum_required (VERSION 3.5)
|
|
project(azure_iot_sdks)
|
|
|
|
########## Enable CMake Features ##########
|
|
# Use solution folders.
|
|
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
|
|
# Set CMAKE_INSTALL_LIBDIR if not defined
|
|
include(GNUInstallDirs)
|
|
include (CTest)
|
|
|
|
include("${CMAKE_CURRENT_LIST_DIR}/configs/azure_iot_sdksFunctions.cmake")
|
|
|
|
# MACOSX_RPATH is enabled
|
|
# https://cmake.org/cmake/help/latest/prop_tgt/MACOSX_RPATH.html#prop_tgt:MACOSX_RPATH
|
|
if (POLICY CMP0042)
|
|
cmake_policy(SET CMP0042 NEW)
|
|
endif()
|
|
|
|
getIoTSDKVersion()
|
|
message(STATUS "IoT Client SDK Version = ${IOT_SDK_VERSION}")
|
|
|
|
# Make a global variable to know if we are on linux, windows, or macosx.
|
|
if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
|
|
set(WINDOWS TRUE)
|
|
elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
|
|
set(LINUX TRUE)
|
|
# on Linux, enable valgrind
|
|
# these commands (MEMORYCHECK...) need to apear BEFORE include(CTest) or they will not have any effect
|
|
find_program(MEMORYCHECK_COMMAND valgrind)
|
|
set(MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --error-exitcode=1")
|
|
elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
|
|
set(MACOSX TRUE)
|
|
add_definitions(-DMACOSX)
|
|
endif()
|
|
|
|
IF(WIN32)
|
|
# windows needs this define
|
|
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
|
|
endif()
|
|
|
|
|
|
########### CMake Options ###########
|
|
# Testing
|
|
option(run_e2e_tests "set run_e2e_tests to ON to run e2e tests (default is OFF)" OFF)
|
|
option(run_unittests "set run_unittests to ON to run unittests (default is OFF)" OFF)
|
|
option(run_longhaul_tests "set run_longhaul_tests to ON to run longhaul tests (default is OFF)[if possible, they are always build]" OFF)
|
|
option(run_e2e_openssl_engine_tests "set run_e2e_openssl_engine_tests to ON to run OpenSSL ENGINE tests (default is OFF)[if possible, they are always build]" OFF)
|
|
option(use_cppunittest "set use_cppunittest to ON to build CppUnitTest tests on Windows (default is OFF)" OFF)
|
|
option(run_sfc_tests "setup the Service Fault tests" OFF)
|
|
# Turn ON/OFF samples and upload to blob
|
|
option(skip_samples "set skip_samples to ON to skip building samples (default is OFF)[if possible, they are always build]" OFF)
|
|
option(dont_use_uploadtoblob "set dont_use_uploadtoblob to ON if the functionality of upload to blob is to be excluded, OFF otherwise. It requires HTTP" OFF)
|
|
# Compile options
|
|
option(no_logging "disable logging" OFF)
|
|
option(use_installed_dependencies "set use_installed_dependencies to ON to use installed packages instead of building dependencies from submodules" OFF)
|
|
option(warnings_as_errors "enable strict compiler warnings-as-errors" ON)
|
|
option(strict_prototypes "enable GCC strict-prototypes compiler option. This is not supported with test code enabled." OFF)
|
|
option(build_as_dynamic "build the IoT SDK libaries as dynamic" OFF)
|
|
# Turn on/off IoT features
|
|
option(use_prov_client "Enable provisioning client" ON)
|
|
option(use_tpm_simulator "tpm simulator type of hsm used with the provisioning client" OFF)
|
|
option(use_edge_modules "Enable support for running modules against Azure IoT Edge" OFF)
|
|
option(use_custom_heap "use externally defined heap functions instead of the malloc family" OFF)
|
|
option(build_service_client "controls whether the iothub_service_client is built or not" ON)
|
|
option(build_provisioning_service_client "controls whether the provisioning_service_client is built or not" ON)
|
|
# HSM Type
|
|
option(hsm_type_x509 "x509 type of hsm used with the Provisioning client" ON)
|
|
option(hsm_type_riot "DICE/RIoT x509 type of hsm used with the Provisioning client" OFF)
|
|
option(hsm_type_sastoken "tpm type of hsm used with the Provisioning client" ON)
|
|
option(hsm_type_symm_key "Symmetric key type of hsm used with the Provisioning client" ON)
|
|
option(hsm_type_custom "hsm type of custom used with the Provisioning client" OFF)
|
|
# Transport
|
|
option(use_amqp "set use_amqp to ON if amqp is to be used, set to OFF to not use amqp" ON)
|
|
option(use_http "set use_http to ON if http is to be used, set to OFF to not use http" ON)
|
|
option(use_mqtt "set use_mqtt to ON if mqtt is to be used, set to OFF to not use mqtt" ON)
|
|
# TLS Options (OpenSSL further below)
|
|
option(use_mbedtls "set use_mbedtls to ON to use mbedtls." OFF)
|
|
option(use_bearssl "set use_bearssl to ON to use bearssl." OFF)
|
|
option(use_wolfssl "set use_wolfssl to ON to use wolfssl." OFF)
|
|
# Compiled-in cert options
|
|
option(use_azure_cloud_rsa_cert "set use_azure_cloud_rsa_cert to ON if the Azure Cloud RSA certs are to be used for samples, set to OFF to not use it" OFF)
|
|
option(use_azure_cloud_ecc_cert "set use_azure_cloud_ecc_cert to ON if the Azure Cloud ECC certs are to be used for samples, set to OFF to not use it" OFF)
|
|
option(use_microsoftazure_de_cert "set use_microsoftazure_de_cert to ON if the MicrosoftAzure DE cert is to be used for samples, set to OFF to not use it" OFF)
|
|
option(use_portal_azure_cn_cert "set use_portal_azure_cn_cert to ON if the Portal Azure CN cert is to be used for samples, set to OFF to not use it" OFF)
|
|
|
|
########## Conditional Options set ##########
|
|
if (WIN32 OR MACOSX)
|
|
option(use_openssl "set use_openssl to ON to use OpenSSL." OFF)
|
|
else()
|
|
option(use_openssl "set use_openssl to ON to use OpenSSL." ON)
|
|
endif()
|
|
|
|
# OpenSSL samples on Windows need to have a trusted cert set
|
|
if ((WIN32 AND ${use_openssl}) OR ${use_wolfssl} OR ${use_mbedtls} OR ${use_bearssl})
|
|
option(use_sample_trusted_cert "Set flag in samples to use SDK's built-in CA as TrustedCerts" ON)
|
|
else()
|
|
option(use_sample_trusted_cert "Set flag in samples to use SDK's built-in CA as TrustedCerts" OFF)
|
|
endif()
|
|
|
|
########## String Options ##########
|
|
set(hsm_custom_lib "" CACHE STRING "Full path to custom HSM repo library")
|
|
set(compileOption_C "" CACHE STRING "passes a string to the command line of the C compiler")
|
|
set(compileOption_CXX "" CACHE STRING "passes a string to the command line of the C++ compiler")
|
|
set(linkerOption "" CACHE STRING "passes a string to the shared and exe linker options of the C compiler")
|
|
|
|
# If any compiler has a command line switch called "OFF" then it will need special care
|
|
if (NOT "${compileOption_C}" STREQUAL "")
|
|
add_definitions(${compileOption_C})
|
|
endif()
|
|
|
|
if (NOT "${compileOption_CXX}" STREQUAL "")
|
|
add_definitions(${compileOption_CXX})
|
|
endif()
|
|
|
|
if (NOT "${linkerOption}" STREQUAL "")
|
|
message("linkerOption: ${CMAKE_SHARED_LINKER_FLAGS}")
|
|
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${linkerOption}")
|
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${linkerOption}")
|
|
endif()
|
|
|
|
if (${warnings_as_errors})
|
|
if (MSVC)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /wd4232")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4 /wd4232")
|
|
# Make warning as error
|
|
add_definitions(/WX)
|
|
else()
|
|
# Make warning as error
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror")
|
|
endif()
|
|
endif()
|
|
|
|
if (${strict_prototypes})
|
|
if (NOT MSVC)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wstrict-prototypes")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-prototypes")
|
|
endif()
|
|
endif()
|
|
|
|
if(${use_custom_heap})
|
|
add_definitions(-DGB_USE_CUSTOM_HEAP)
|
|
endif()
|
|
|
|
if (${use_azure_cloud_rsa_cert})
|
|
add_definitions(-DUSE_AZURE_CLOUD_RSA_CERT)
|
|
endif()
|
|
|
|
if (${use_azure_cloud_ecc_cert})
|
|
add_definitions(-DUSE_AZURE_CLOUD_ECC_CERT)
|
|
endif()
|
|
|
|
if (${use_microsoftazure_de_cert})
|
|
add_definitions(-DUSE_MICROSOFTAZURE_DE_CERT)
|
|
endif()
|
|
|
|
if (${use_portal_azure_cn_cert})
|
|
add_definitions(-DUSE_PORTAL_AZURE_CN_CERT)
|
|
endif()
|
|
|
|
########## Set Provisioning Features ON/OFF ##########
|
|
if (XCODE AND ${use_prov_client})
|
|
# The TPM module is not available on Mac, and Mac's <string.h> and <unistd.h> files collide as well
|
|
message(FATAL_ERROR "Provisioning client is not supported on Mac.")
|
|
endif()
|
|
|
|
# Default to OFF
|
|
set(use_prov_client_core OFF)
|
|
|
|
# Enable IoT SDK to act as a module for Edge
|
|
if(${use_edge_modules})
|
|
set(use_prov_client_core ON)
|
|
set(use_http ON)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_EDGE_MODULES")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_EDGE_MODULES")
|
|
set(hsm_type_edge_module ON)
|
|
endif()
|
|
|
|
# Set Provisioning Information. This will also setup appropriate HSM
|
|
if (${use_prov_client})
|
|
set(use_prov_client_core ON)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_PROV_MODULE_FULL")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_PROV_MODULE_FULL")
|
|
if ("${hsm_custom_lib}" STREQUAL "")
|
|
if ((NOT ${hsm_type_x509}) AND (NOT ${hsm_type_sastoken}) AND (NOT ${hsm_type_symm_key}) AND (NOT ${hsm_type_riot}))
|
|
# If the cmake option did not explicitly configure an hsm type, then enable them all.
|
|
set(hsm_type_x509 ON)
|
|
set(hsm_type_sastoken ON)
|
|
set(hsm_type_symm_key ON)
|
|
endif()
|
|
else()
|
|
set(hsm_type_custom ON)
|
|
endif()
|
|
endif()
|
|
|
|
if (${use_prov_client_core})
|
|
getProvSDKVersion()
|
|
message(STATUS "Provisioning SDK Version = ${PROV_SDK_VERSION}")
|
|
endif()
|
|
|
|
########## Check for conflicting options ##########
|
|
if (NOT ${use_http})
|
|
MESSAGE( "Setting dont_use_uploadtoblob to ON because use_http is OFF")
|
|
set(dont_use_uploadtoblob ON)
|
|
MESSAGE( STATUS "use_http: " ${use_http} )
|
|
MESSAGE( STATUS "dont_use_uploadtoblob: " ${dont_use_uploadtoblob} )
|
|
endif()
|
|
|
|
if (NOT ${use_amqp} AND NOT ${use_http} AND NOT ${use_mqtt})
|
|
message(FATAL_ERROR "CMAKE Failure: AMQP, HTTP & MQTT are all disabled, IoT Hub Client must have one protocol enabled.")
|
|
endif()
|
|
|
|
if (${hsm_type_x509} AND ${hsm_type_riot})
|
|
message(FATAL_ERROR "CMAKE Failure: hsm_type_x509 and hsm_type_riot are incompatible. Select only one X509 HSM type.")
|
|
endif()
|
|
|
|
if (${dont_use_uploadtoblob})
|
|
add_definitions(-DDONT_USE_UPLOADTOBLOB)
|
|
endif()
|
|
|
|
if (${no_logging})
|
|
add_definitions(-DNO_LOGGING)
|
|
endif()
|
|
|
|
if (LINUX)
|
|
if (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
|
|
# now all static libraries use PIC flag for Python shared lib
|
|
set(CMAKE_C_FLAGS "-fPIC ${CMAKE_C_FLAGS}")
|
|
set(CMAKE_CXX_FLAGS "-fPIC ${CMAKE_CXX_FLAGS}")
|
|
endif()
|
|
endif()
|
|
|
|
########## Turn off tests for dependencies ##########
|
|
set(original_run_e2e_tests ${run_e2e_tests})
|
|
set(original_run_unittests ${run_unittests})
|
|
set(original_skip_samples ${skip_samples})
|
|
|
|
set(run_e2e_tests OFF)
|
|
set(run_unittests OFF)
|
|
set(skip_samples ON)
|
|
|
|
########## Globally include macro utils and umock ##########
|
|
if (IN_OPENWRT)
|
|
add_definitions("$ENV{TARGET_LDFLAGS}" "$ENV{TARGET_CPPFLAGS}" "$ENV{TARGET_CFLAGS}")
|
|
include_directories("$ENV{TOOLCHAIN_DIR}/usr/include" "$ENV{TARGET_LDFLAGS}" "$ENV{TARGET_CPPFLAGS}" "$ENV{TARGET_CFLAGS}")
|
|
endif()
|
|
|
|
########## Add dependencies ##########
|
|
if (${original_run_e2e_tests} OR ${original_run_unittests} OR ${run_sfc_tests})
|
|
set(SHARED_UTIL_REAL_TEST_FOLDER ${CMAKE_CURRENT_LIST_DIR}/c-utility/tests/real_test_files CACHE INTERNAL "this is what needs to be included when doing test sources" FORCE)
|
|
endif()
|
|
|
|
add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/deps)
|
|
if(${use_installed_dependencies})
|
|
find_package(parson REQUIRED CONFIG)
|
|
endif()
|
|
|
|
include_directories(${MACRO_UTILS_INC_FOLDER})
|
|
include_directories(${UMOCK_C_INC_FOLDER})
|
|
|
|
if(${use_installed_dependencies})
|
|
if (NOT azure_c_shared_utility_FOUND)
|
|
find_package(azure_c_shared_utility REQUIRED CONFIG)
|
|
endif ()
|
|
|
|
if (${use_amqp})
|
|
if (NOT uamqp_FOUND)
|
|
find_package(uamqp REQUIRED CONFIG)
|
|
endif ()
|
|
endif ()
|
|
|
|
if (${use_mqtt})
|
|
if (NOT umqtt_FOUND)
|
|
find_package(umqtt REQUIRED CONFIG)
|
|
endif ()
|
|
endif ()
|
|
|
|
if (${use_http})
|
|
if (NOT uhttp_FOUND)
|
|
find_package(uhttp REQUIRED CONFIG)
|
|
endif ()
|
|
endif ()
|
|
else ()
|
|
add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/c-utility)
|
|
|
|
if (${use_amqp})
|
|
add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/uamqp)
|
|
endif ()
|
|
|
|
if (${use_mqtt})
|
|
add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/umqtt)
|
|
endif ()
|
|
|
|
# For now this must go here and not in deps/CMakeLists.txt for
|
|
# CMake functionality which is in c-utility.
|
|
if (${use_http})
|
|
add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/deps/uhttp)
|
|
endif ()
|
|
endif()
|
|
|
|
if (${original_run_e2e_tests} OR ${original_run_unittests} OR ${run_sfc_tests})
|
|
# Used for serializer
|
|
add_subdirectory(${SHARED_UTIL_FOLDER}/testtools/sal)
|
|
add_subdirectory(${SHARED_UTIL_FOLDER}/testtools/micromock)
|
|
endif()
|
|
|
|
set_platform_files(${SHARED_UTIL_FOLDER})
|
|
|
|
set(run_e2e_tests ${original_run_e2e_tests})
|
|
set(run_unittests ${original_run_unittests})
|
|
set(skip_samples ${original_skip_samples})
|
|
|
|
# this project uses several other projects that are build not by these CMakeFiles
|
|
# this project also targets several OSes
|
|
include(CheckSymbolExists)
|
|
function(detect_architecture symbol arch)
|
|
if (NOT DEFINED ARCHITECTURE OR ARCHITECTURE STREQUAL "")
|
|
set(CMAKE_REQUIRED_QUIET 1)
|
|
check_symbol_exists("${symbol}" "" ARCHITECTURE_${arch})
|
|
unset(CMAKE_REQUIRED_QUIET)
|
|
|
|
# The output variable needs to be unique across invocations otherwise
|
|
# CMake's crazy scope rules will keep it defined
|
|
if (ARCHITECTURE_${arch})
|
|
set(ARCHITECTURE "${arch}" PARENT_SCOPE)
|
|
set(ARCHITECTURE_${arch} 1 PARENT_SCOPE)
|
|
add_definitions(-DARCHITECTURE_${arch}=1)
|
|
endif()
|
|
endif()
|
|
endfunction()
|
|
|
|
if (MSVC)
|
|
detect_architecture("_M_AMD64" x86_64)
|
|
detect_architecture("_M_IX86" x86)
|
|
detect_architecture("_M_ARM" ARM)
|
|
else()
|
|
detect_architecture("__x86_64__" x86_64)
|
|
detect_architecture("__i386__" x86)
|
|
detect_architecture("__arm__" ARM)
|
|
endif()
|
|
|
|
if (NOT DEFINED ARCHITECTURE OR ARCHITECTURE STREQUAL "")
|
|
set(ARCHITECTURE "GENERIC")
|
|
endif()
|
|
|
|
message(STATUS "IoT Hub Architecture: ${ARCHITECTURE}")
|
|
|
|
if (WIN32)
|
|
set(LOCK_C_FILE ${SHARED_UTIL_ADAPTER_FOLDER}/lock_win32.c)
|
|
set(THREAD_C_FILE ${SHARED_UTIL_ADAPTER_FOLDER}/threadapi_c11.c)
|
|
else()
|
|
set(LOCK_C_FILE ${SHARED_UTIL_ADAPTER_FOLDER}/lock_pthreads.c)
|
|
set(THREAD_C_FILE ${SHARED_UTIL_ADAPTER_FOLDER}/threadapi_pthreads.c)
|
|
endif()
|
|
|
|
if (NOT ${use_amqp} OR NOT ${use_http})
|
|
set (build_service_client OFF)
|
|
message(STATUS "iothub_service_client build is disabled (AMQP and HTTP support are required)")
|
|
endif()
|
|
|
|
if (NOT ${use_http} AND ${use_prov_client})
|
|
set (build_provisioning_service_client OFF)
|
|
message(STATUS "provisioning_service_client build is disabled (HTTP support is required)")
|
|
endif()
|
|
|
|
########## Add SDK libraries ##########
|
|
# Needs to go before the libs for testing CMake variables to resolve
|
|
if (${run_e2e_tests} OR ${run_longhaul_tests} OR ${run_sfc_tests} OR ${run_unittests})
|
|
add_subdirectory(testtools)
|
|
endif()
|
|
|
|
if (${build_service_client})
|
|
add_subdirectory(iothub_service_client)
|
|
endif()
|
|
|
|
if (${use_prov_client_core})
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_PROV_MODULE")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSE_PROV_MODULE")
|
|
|
|
if ((${build_provisioning_service_client} AND ${use_prov_client}) OR ${run_e2e_tests})
|
|
add_subdirectory(provisioning_service_client)
|
|
endif()
|
|
|
|
add_subdirectory(provisioning_client)
|
|
endif()
|
|
|
|
add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/iothub_client)
|
|
|
|
|
|
# Note this is deprecated
|
|
add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/serializer)
|
|
|
|
########## Add SDK samples ##########
|
|
if (NOT ${skip_samples})
|
|
add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/samples/solutions)
|
|
endif()
|
|
|
|
########## Add install components ##########
|
|
if (${use_installed_dependencies})
|
|
# Install azure_iot_sdks
|
|
set(package_location "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
|
|
|
|
include(CMakePackageConfigHelpers)
|
|
|
|
write_basic_package_version_file(
|
|
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
|
|
VERSION ${IOT_SDK_VERSION}
|
|
COMPATIBILITY SameMajorVersion
|
|
)
|
|
|
|
configure_file("configs/${PROJECT_NAME}Config.cmake"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake"
|
|
COPYONLY
|
|
)
|
|
|
|
install(EXPORT azure_iot_sdksTargets
|
|
FILE
|
|
"${PROJECT_NAME}Targets.cmake"
|
|
DESTINATION
|
|
${package_location}
|
|
)
|
|
|
|
install(
|
|
FILES
|
|
"configs/${PROJECT_NAME}Config.cmake"
|
|
"configs/${PROJECT_NAME}Functions.cmake"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
|
|
DESTINATION
|
|
${package_location}
|
|
)
|
|
endif()
|