# 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 and 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()