CMakeLists.txt - security/mbedtls - Rivoreo Source Code Repositories

 cmake_minimum_required(VERSION 2.6)
 if(TEST_CPP)
     project("mbed TLS" C CXX)
 else()
     project("mbed TLS" C)
 endif()

 option(USE_PKCS11_HELPER_LIBRARY "Build mbed TLS with the pkcs11-helper library." OFF)
 option(ENABLE_ZLIB_SUPPORT "Build mbed TLS with zlib library." OFF)

 option(ENABLE_PROGRAMS "Build mbed TLS programs." ON)

 option(UNSAFE_BUILD "Allow unsafe builds. These builds ARE NOT SECURE." OFF)

 string(REGEX MATCH "Clang" CMAKE_COMPILER_IS_CLANG "${CMAKE_C_COMPILER_ID}")
 string(REGEX MATCH "GNU" CMAKE_COMPILER_IS_GNU "${CMAKE_C_COMPILER_ID}")
 string(REGEX MATCH "IAR" CMAKE_COMPILER_IS_IAR "${CMAKE_C_COMPILER_ID}")
 string(REGEX MATCH "MSVC" CMAKE_COMPILER_IS_MSVC "${CMAKE_C_COMPILER_ID}")

 # the test suites currently have compile errors with MSVC
 if(CMAKE_COMPILER_IS_MSVC)
     option(ENABLE_TESTING "Build mbed TLS tests." OFF)
 else()
     option(ENABLE_TESTING "Build mbed TLS tests." ON)
 endif()

 # Warning string - created as a list for compatibility with CMake 2.8
 set(WARNING_BORDER "*******************************************************\n")
 set(NULL_ENTROPY_WARN_L1 "****  WARNING!  MBEDTLS_TEST_NULL_ENTROPY defined!\n")
 set(NULL_ENTROPY_WARN_L2 "****  THIS BUILD HAS NO DEFINED ENTROPY SOURCES\n")
 set(NULL_ENTROPY_WARN_L3 "****  AND IS *NOT* SUITABLE FOR PRODUCTION USE\n")

 set(NULL_ENTROPY_WARNING "${WARNING_BORDER}"
                          "${NULL_ENTROPY_WARN_L1}"
                          "${NULL_ENTROPY_WARN_L2}"
                          "${NULL_ENTROPY_WARN_L3}"
                          "${WARNING_BORDER}")

 set(CTR_DRBG_128_BIT_KEY_WARN_L1 "****  WARNING!  MBEDTLS_CTR_DRBG_USE_128_BIT_KEY defined!\n")
 set(CTR_DRBG_128_BIT_KEY_WARN_L2 "****  Using 128-bit keys for CTR_DRBG limits the security of generated\n")
 set(CTR_DRBG_128_BIT_KEY_WARN_L3 "****  keys and operations that use random values generated to 128-bit security\n")

 set(CTR_DRBG_128_BIT_KEY_WARNING "${WARNING_BORDER}"
                          "${CTR_DRBG_128_BIT_KEY_WARN_L1}"
                          "${CTR_DRBG_128_BIT_KEY_WARN_L2}"
                          "${CTR_DRBG_128_BIT_KEY_WARN_L3}"
                          "${WARNING_BORDER}")

 find_package(PythonInterp)
 find_package(Perl)
 if(PERL_FOUND)

     # If 128-bit keys are configured for CTR_DRBG, display an appropriate warning
     execute_process(COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/config.pl -f ${CMAKE_CURRENT_SOURCE_DIR}/include/mbedtls/config.h get MBEDTLS_CTR_DRBG_USE_128_BIT_KEY
                         RESULT_VARIABLE result)
     if(${result} EQUAL 0)
         message(WARNING ${CTR_DRBG_128_BIT_KEY_WARNING})
     endif()

     # If NULL Entropy is configured, display an appropriate warning
     execute_process(COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/config.pl -f ${CMAKE_CURRENT_SOURCE_DIR}/include/mbedtls/config.h get MBEDTLS_TEST_NULL_ENTROPY
                         RESULT_VARIABLE result)
     if(${result} EQUAL 0)
         message(WARNING ${NULL_ENTROPY_WARNING})

         if(NOT UNSAFE_BUILD)
             message(FATAL_ERROR "\
 \n\
 Warning! You have enabled MBEDTLS_TEST_NULL_ENTROPY. \
 This option is not safe for production use and negates all security \
 It is intended for development use only. \
 \n\
 To confirm you want to build with this option, re-run cmake with the \
 option: \n\
   cmake -DUNSAFE_BUILD=ON ")

             return()
         endif()
     endif()
 endif()

 set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}
     CACHE STRING "Choose the type of build: None Debug Release Coverage ASan ASanDbg MemSan MemSanDbg Check CheckFull"
     FORCE)

 # Create a symbolic link from ${base_name} in the binary directory
 # to the corresponding path in the source directory.
 function(link_to_source base_name)
     # Get OS dependent path to use in `execute_process`
     file(TO_NATIVE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${base_name}" link)
     file(TO_NATIVE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${base_name}" target)

     if (NOT EXISTS ${link})
         if (CMAKE_HOST_UNIX)
             set(command ln -s ${target} ${link})
         else()
             if (IS_DIRECTORY ${target})
                 set(command cmd.exe /c mklink /j ${link} ${target})
             else()
                 set(command cmd.exe /c mklink /h ${link} ${target})
             endif()
         endif()

         execute_process(COMMAND ${command}
             RESULT_VARIABLE result
             ERROR_VARIABLE output)

         if (NOT ${result} EQUAL 0)
             message(FATAL_ERROR "Could not create symbolic link for: ${target} --> ${output}")
         endif()
     endif()
 endfunction(link_to_source)

 string(REGEX MATCH "Clang" CMAKE_COMPILER_IS_CLANG "${CMAKE_C_COMPILER_ID}")

 if(CMAKE_COMPILER_IS_GNU)
     # some warnings we want are not available with old GCC versions
     # note: starting with CMake 2.8 we could use CMAKE_C_COMPILER_VERSION
     execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
                     OUTPUT_VARIABLE GCC_VERSION)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -W -Wdeclaration-after-statement -Wwrite-strings")
     if (GCC_VERSION VERSION_GREATER 4.5 OR GCC_VERSION VERSION_EQUAL 4.5)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wlogical-op")
     endif()
     if (GCC_VERSION VERSION_GREATER 4.8 OR GCC_VERSION VERSION_EQUAL 4.8)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wshadow")
     endif()
     set(CMAKE_C_FLAGS_RELEASE     "-O2")
     set(CMAKE_C_FLAGS_DEBUG       "-O0 -g3")
     set(CMAKE_C_FLAGS_COVERAGE    "-O0 -g3 --coverage")
     set(CMAKE_C_FLAGS_ASAN        "-Werror -fsanitize=address -fno-common -O3")
     set(CMAKE_C_FLAGS_ASANDBG     "-Werror -fsanitize=address -fno-common -O1 -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls ")
     set(CMAKE_C_FLAGS_CHECK       "-Werror -Os")
     set(CMAKE_C_FLAGS_CHECKFULL   "${CMAKE_C_FLAGS_CHECK} -Wcast-qual")
 endif(CMAKE_COMPILER_IS_GNU)

 if(CMAKE_COMPILER_IS_CLANG)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -W -Wdeclaration-after-statement -Wwrite-strings -Wpointer-arith -Wimplicit-fallthrough -Wshadow")
     set(CMAKE_C_FLAGS_RELEASE     "-O2")
     set(CMAKE_C_FLAGS_DEBUG       "-O0 -g3")
     set(CMAKE_C_FLAGS_COVERAGE    "-O0 -g3 --coverage")
     set(CMAKE_C_FLAGS_ASAN        "-Werror -fsanitize=address -fno-common -fsanitize=undefined -fno-sanitize-recover=all -O3")
     set(CMAKE_C_FLAGS_ASANDBG     "-Werror -fsanitize=address -fno-common -fsanitize=undefined -fno-sanitize-recover=all -O1 -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls ")
     set(CMAKE_C_FLAGS_MEMSAN      "-Werror -fsanitize=memory -O3")
     set(CMAKE_C_FLAGS_MEMSANDBG   "-Werror -fsanitize=memory -O1 -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls -fsanitize-memory-track-origins=2")
     set(CMAKE_C_FLAGS_CHECK       "-Werror -Os")
 endif(CMAKE_COMPILER_IS_CLANG)

 if(CMAKE_COMPILER_IS_IAR)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --warn_about_c_style_casts --warnings_are_errors -Ohz")
 endif(CMAKE_COMPILER_IS_IAR)

 if(CMAKE_COMPILER_IS_MSVC)
     # Strictest warnings, and treat as errors
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX")
 endif(CMAKE_COMPILER_IS_MSVC)

 if(CMAKE_BUILD_TYPE STREQUAL "Coverage")
     if(CMAKE_COMPILER_IS_GNU OR CMAKE_COMPILER_IS_CLANG)
         set(CMAKE_SHARED_LINKER_FLAGS "--coverage")
     endif(CMAKE_COMPILER_IS_GNU OR CMAKE_COMPILER_IS_CLANG)
 endif(CMAKE_BUILD_TYPE STREQUAL "Coverage")

 if(LIB_INSTALL_DIR)
 else()
     set(LIB_INSTALL_DIR lib)
 endif()

 include_directories(include/)

 if(ENABLE_ZLIB_SUPPORT)
     find_package(ZLIB)

     if(ZLIB_FOUND)
         include_directories(${ZLIB_INCLUDE_DIR})
     endif(ZLIB_FOUND)
 endif(ENABLE_ZLIB_SUPPORT)

 add_subdirectory(library)
 add_subdirectory(include)

 if(ENABLE_PROGRAMS)
     add_subdirectory(programs)
 endif()

 ADD_CUSTOM_TARGET(apidoc
     COMMAND doxygen mbedtls.doxyfile
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doxygen)

 if(ENABLE_TESTING)
     enable_testing()

     add_subdirectory(tests)

     # additional convenience targets for Unix only
     if(UNIX)

         ADD_CUSTOM_TARGET(covtest
             COMMAND make test
             COMMAND programs/test/selftest
             COMMAND tests/compat.sh
             COMMAND tests/ssl-opt.sh
         )

         ADD_CUSTOM_TARGET(lcov
             COMMAND rm -rf Coverage
             COMMAND lcov --capture --initial --directory library/CMakeFiles/mbedtls.dir -o files.info
             COMMAND lcov --capture --directory library/CMakeFiles/mbedtls.dir -o tests.info
             COMMAND lcov --add-tracefile files.info --add-tracefile tests.info -o all.info
             COMMAND lcov --remove all.info -o final.info '*.h'
             COMMAND gendesc tests/Descriptions.txt -o descriptions
             COMMAND genhtml --title "mbed TLS" --description-file descriptions --keep-descriptions --legend --no-branch-coverage -o Coverage final.info
             COMMAND rm -f files.info tests.info all.info final.info descriptions
         )

         ADD_CUSTOM_TARGET(memcheck
             COMMAND sed -i.bak s+/usr/bin/valgrind+`which valgrind`+ DartConfiguration.tcl
             COMMAND ctest -O memcheck.log -D ExperimentalMemCheck
             COMMAND tail -n1 memcheck.log | grep 'Memory checking results:' > /dev/null
             COMMAND rm -f memcheck.log
             COMMAND mv DartConfiguration.tcl.bak DartConfiguration.tcl
         )
     endif(UNIX)
 endif()

 # Make scripts needed for testing available in an out-of-source build.
 if (NOT ${CMAKE_CURRENT_BINARY_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
     link_to_source(scripts)
     # Copy (don't link) DartConfiguration.tcl, needed for memcheck, to
     # keep things simple with the sed commands in the memcheck target.
     configure_file(${CMAKE_CURRENT_SOURCE_DIR}/DartConfiguration.tcl
                    ${CMAKE_CURRENT_BINARY_DIR}/DartConfiguration.tcl COPYONLY)
 endif()
	cmake_minimum_required(VERSION 2.6)
	if(TEST_CPP)
	project("mbed TLS" C CXX)
	else()
	project("mbed TLS" C)
	endif()

	option(USE_PKCS11_HELPER_LIBRARY "Build mbed TLS with the pkcs11-helper library." OFF)
	option(ENABLE_ZLIB_SUPPORT "Build mbed TLS with zlib library." OFF)

	option(ENABLE_PROGRAMS "Build mbed TLS programs." ON)

	option(UNSAFE_BUILD "Allow unsafe builds. These builds ARE NOT SECURE." OFF)

	string(REGEX MATCH "Clang" CMAKE_COMPILER_IS_CLANG "${CMAKE_C_COMPILER_ID}")
	string(REGEX MATCH "GNU" CMAKE_COMPILER_IS_GNU "${CMAKE_C_COMPILER_ID}")
	string(REGEX MATCH "IAR" CMAKE_COMPILER_IS_IAR "${CMAKE_C_COMPILER_ID}")
	string(REGEX MATCH "MSVC" CMAKE_COMPILER_IS_MSVC "${CMAKE_C_COMPILER_ID}")

	# the test suites currently have compile errors with MSVC
	if(CMAKE_COMPILER_IS_MSVC)
	option(ENABLE_TESTING "Build mbed TLS tests." OFF)
	else()
	option(ENABLE_TESTING "Build mbed TLS tests." ON)
	endif()

	# Warning string - created as a list for compatibility with CMake 2.8
	set(WARNING_BORDER "*******************************************************\n")
	set(NULL_ENTROPY_WARN_L1 "**** WARNING! MBEDTLS_TEST_NULL_ENTROPY defined!\n")
	set(NULL_ENTROPY_WARN_L2 "**** THIS BUILD HAS NO DEFINED ENTROPY SOURCES\n")
	set(NULL_ENTROPY_WARN_L3 "**** AND IS NOT SUITABLE FOR PRODUCTION USE\n")

	set(NULL_ENTROPY_WARNING "${WARNING_BORDER}"
	"${NULL_ENTROPY_WARN_L1}"
	"${NULL_ENTROPY_WARN_L2}"
	"${NULL_ENTROPY_WARN_L3}"
	"${WARNING_BORDER}")

	set(CTR_DRBG_128_BIT_KEY_WARN_L1 "**** WARNING! MBEDTLS_CTR_DRBG_USE_128_BIT_KEY defined!\n")
	set(CTR_DRBG_128_BIT_KEY_WARN_L2 "**** Using 128-bit keys for CTR_DRBG limits the security of generated\n")
	set(CTR_DRBG_128_BIT_KEY_WARN_L3 "**** keys and operations that use random values generated to 128-bit security\n")

	set(CTR_DRBG_128_BIT_KEY_WARNING "${WARNING_BORDER}"
	"${CTR_DRBG_128_BIT_KEY_WARN_L1}"
	"${CTR_DRBG_128_BIT_KEY_WARN_L2}"
	"${CTR_DRBG_128_BIT_KEY_WARN_L3}"
	"${WARNING_BORDER}")

	find_package(PythonInterp)
	find_package(Perl)
	if(PERL_FOUND)

	# If 128-bit keys are configured for CTR_DRBG, display an appropriate warning
	execute_process(COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/config.pl -f ${CMAKE_CURRENT_SOURCE_DIR}/include/mbedtls/config.h get MBEDTLS_CTR_DRBG_USE_128_BIT_KEY
	RESULT_VARIABLE result)
	if(${result} EQUAL 0)
	message(WARNING ${CTR_DRBG_128_BIT_KEY_WARNING})
	endif()

	# If NULL Entropy is configured, display an appropriate warning
	execute_process(COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/config.pl -f ${CMAKE_CURRENT_SOURCE_DIR}/include/mbedtls/config.h get MBEDTLS_TEST_NULL_ENTROPY
	RESULT_VARIABLE result)
	if(${result} EQUAL 0)
	message(WARNING ${NULL_ENTROPY_WARNING})

	if(NOT UNSAFE_BUILD)
	message(FATAL_ERROR "\
	\n\
	Warning! You have enabled MBEDTLS_TEST_NULL_ENTROPY. \
	This option is not safe for production use and negates all security \
	It is intended for development use only. \
	\n\
	To confirm you want to build with this option, re-run cmake with the \
	option: \n\
	cmake -DUNSAFE_BUILD=ON ")

	return()
	endif()
	endif()
	endif()

	set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}
	CACHE STRING "Choose the type of build: None Debug Release Coverage ASan ASanDbg MemSan MemSanDbg Check CheckFull"
	FORCE)

	# Create a symbolic link from ${base_name} in the binary directory
	# to the corresponding path in the source directory.
	function(link_to_source base_name)
	# Get OS dependent path to use in `execute_process`
	file(TO_NATIVE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${base_name}" link)
	file(TO_NATIVE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${base_name}" target)

	if (NOT EXISTS ${link})
	if (CMAKE_HOST_UNIX)
	set(command ln -s ${target} ${link})
	else()
	if (IS_DIRECTORY ${target})
	set(command cmd.exe /c mklink /j ${link} ${target})
	else()
	set(command cmd.exe /c mklink /h ${link} ${target})
	endif()
	endif()

	execute_process(COMMAND ${command}
	RESULT_VARIABLE result
	ERROR_VARIABLE output)

	if (NOT ${result} EQUAL 0)
	message(FATAL_ERROR "Could not create symbolic link for: ${target} --> ${output}")
	endif()
	endif()
	endfunction(link_to_source)

	string(REGEX MATCH "Clang" CMAKE_COMPILER_IS_CLANG "${CMAKE_C_COMPILER_ID}")

	if(CMAKE_COMPILER_IS_GNU)
	# some warnings we want are not available with old GCC versions
	# note: starting with CMake 2.8 we could use CMAKE_C_COMPILER_VERSION
	execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
	OUTPUT_VARIABLE GCC_VERSION)
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -W -Wdeclaration-after-statement -Wwrite-strings")
	if (GCC_VERSION VERSION_GREATER 4.5 OR GCC_VERSION VERSION_EQUAL 4.5)
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wlogical-op")
	endif()
	if (GCC_VERSION VERSION_GREATER 4.8 OR GCC_VERSION VERSION_EQUAL 4.8)
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wshadow")
	endif()
	set(CMAKE_C_FLAGS_RELEASE "-O2")
	set(CMAKE_C_FLAGS_DEBUG "-O0 -g3")
	set(CMAKE_C_FLAGS_COVERAGE "-O0 -g3 --coverage")
	set(CMAKE_C_FLAGS_ASAN "-Werror -fsanitize=address -fno-common -O3")
	set(CMAKE_C_FLAGS_ASANDBG "-Werror -fsanitize=address -fno-common -O1 -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls ")
	set(CMAKE_C_FLAGS_CHECK "-Werror -Os")
	set(CMAKE_C_FLAGS_CHECKFULL "${CMAKE_C_FLAGS_CHECK} -Wcast-qual")
	endif(CMAKE_COMPILER_IS_GNU)

	if(CMAKE_COMPILER_IS_CLANG)
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -W -Wdeclaration-after-statement -Wwrite-strings -Wpointer-arith -Wimplicit-fallthrough -Wshadow")
	set(CMAKE_C_FLAGS_RELEASE "-O2")
	set(CMAKE_C_FLAGS_DEBUG "-O0 -g3")
	set(CMAKE_C_FLAGS_COVERAGE "-O0 -g3 --coverage")
	set(CMAKE_C_FLAGS_ASAN "-Werror -fsanitize=address -fno-common -fsanitize=undefined -fno-sanitize-recover=all -O3")
	set(CMAKE_C_FLAGS_ASANDBG "-Werror -fsanitize=address -fno-common -fsanitize=undefined -fno-sanitize-recover=all -O1 -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls ")
	set(CMAKE_C_FLAGS_MEMSAN "-Werror -fsanitize=memory -O3")
	set(CMAKE_C_FLAGS_MEMSANDBG "-Werror -fsanitize=memory -O1 -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls -fsanitize-memory-track-origins=2")
	set(CMAKE_C_FLAGS_CHECK "-Werror -Os")
	endif(CMAKE_COMPILER_IS_CLANG)

	if(CMAKE_COMPILER_IS_IAR)
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --warn_about_c_style_casts --warnings_are_errors -Ohz")
	endif(CMAKE_COMPILER_IS_IAR)

	if(CMAKE_COMPILER_IS_MSVC)
	# Strictest warnings, and treat as errors
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3")
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX")
	endif(CMAKE_COMPILER_IS_MSVC)

	if(CMAKE_BUILD_TYPE STREQUAL "Coverage")
	if(CMAKE_COMPILER_IS_GNU OR CMAKE_COMPILER_IS_CLANG)
	set(CMAKE_SHARED_LINKER_FLAGS "--coverage")
	endif(CMAKE_COMPILER_IS_GNU OR CMAKE_COMPILER_IS_CLANG)
	endif(CMAKE_BUILD_TYPE STREQUAL "Coverage")

	if(LIB_INSTALL_DIR)
	else()
	set(LIB_INSTALL_DIR lib)
	endif()

	include_directories(include/)

	if(ENABLE_ZLIB_SUPPORT)
	find_package(ZLIB)

	if(ZLIB_FOUND)
	include_directories(${ZLIB_INCLUDE_DIR})
	endif(ZLIB_FOUND)
	endif(ENABLE_ZLIB_SUPPORT)

	add_subdirectory(library)
	add_subdirectory(include)

	if(ENABLE_PROGRAMS)
	add_subdirectory(programs)
	endif()

	ADD_CUSTOM_TARGET(apidoc
	COMMAND doxygen mbedtls.doxyfile
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doxygen)

	if(ENABLE_TESTING)
	enable_testing()

	add_subdirectory(tests)

	# additional convenience targets for Unix only
	if(UNIX)

	ADD_CUSTOM_TARGET(covtest
	COMMAND make test
	COMMAND programs/test/selftest
	COMMAND tests/compat.sh
	COMMAND tests/ssl-opt.sh
	)

	ADD_CUSTOM_TARGET(lcov
	COMMAND rm -rf Coverage
	COMMAND lcov --capture --initial --directory library/CMakeFiles/mbedtls.dir -o files.info
	COMMAND lcov --capture --directory library/CMakeFiles/mbedtls.dir -o tests.info
	COMMAND lcov --add-tracefile files.info --add-tracefile tests.info -o all.info
	COMMAND lcov --remove all.info -o final.info '*.h'
	COMMAND gendesc tests/Descriptions.txt -o descriptions
	COMMAND genhtml --title "mbed TLS" --description-file descriptions --keep-descriptions --legend --no-branch-coverage -o Coverage final.info
	COMMAND rm -f files.info tests.info all.info final.info descriptions
	)

	ADD_CUSTOM_TARGET(memcheck
	COMMAND sed -i.bak s+/usr/bin/valgrind+`which valgrind`+ DartConfiguration.tcl
	COMMAND ctest -O memcheck.log -D ExperimentalMemCheck
	COMMAND tail -n1 memcheck.log \| grep 'Memory checking results:' > /dev/null
	COMMAND rm -f memcheck.log
	COMMAND mv DartConfiguration.tcl.bak DartConfiguration.tcl
	)
	endif(UNIX)
	endif()

	# Make scripts needed for testing available in an out-of-source build.
	if (NOT ${CMAKE_CURRENT_BINARY_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
	link_to_source(scripts)
	# Copy (don't link) DartConfiguration.tcl, needed for memcheck, to
	# keep things simple with the sed commands in the memcheck target.
	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/DartConfiguration.tcl
	${CMAKE_CURRENT_BINARY_DIR}/DartConfiguration.tcl COPYONLY)
	endif()