cmake_minimum_required(VERSION 3.5 FATAL_ERROR)

if (POLICY CMP0075)
  cmake_policy(SET CMP0075 NEW)
endif ()

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules/")

set(CMAKE_VERBOSE_MAKEFILE_ON)

# The following must be set BEFORE doing project() or enable_language().
if (NOT CMAKE_BUILD_TYPE)
  message(STATUS "No build type defined; defaulting to 'Debug'")
  set(CMAKE_BUILD_TYPE "Debug" CACHE STRING
    "The type of build. Possible values are: Debug, Release, RelWithDebInfo and MinSizeRel.")
endif ()

set(PACKAGE "getdns")
set(PACKAGE_NAME "getdns")
set(PACKAGE_VERSION "1.5.2")
set(PACKAGE_BUGREPORT "team@getdnsapi.net")
set(PACKAGE_URL "https://getdnsapi.net")

set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
set(PACKAGE_TARNAME "${PACKAGE}-${PACKAGE_VERSION}")

# Dont forget to put a dash in front of the release candidate!!!
# That is how it is done with semantic versioning!
set(RELEASE_CANDIDATE "")

set(GETDNS_VERSION "${PACKAGE_VERSION}${RELEASE_CANDIDATE}")
set(GETDNS_NUMERIC_VERSION 0x01050200)
set(API_VERSION "December 2015")
set(API_NUMERIC_VERSION 0x07df0c00)
set(GETDNS_COMPILATION_COMMENT "${PACKAGE_NAME} ${GETDNS_VERSION} configured on <date> for the ${API_VERSION} of the API")

# Version 11:2:1 in libtool-speak.
set(GETDNS_VERSION_CURRENT 11)
set(GETDNS_VERSION_REVISION 2)
set(GETDNS_VERSION_AGE 1)

include(CheckCSourceRuns)
include(CheckFunctionExists)
include(CheckLibraryExists)
include(CheckIncludeFile)
include(CheckSymbolExists)
include(CheckTypeSize)
include(TestBigEndian)

project(getdns VERSION ${PACKAGE_VERSION} LANGUAGES C)

list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")

# Directories
include(GNUInstallDirs)

if (DEFINED CMAKE_INSTALL_FULL_RUNSTATEDIR)
  set(RUNSTATEDIR "${CMAKE_INSTALL_FULL_RUNSTATEDIR}")
else ()
  set(RUNSTATEDIR "${CMAKE_INSTALL_FULL_LOCALSTATEDIR}/run")
endif ()
install(
  DIRECTORY
  DESTINATION ${RUNSTATEDIR}
  DIRECTORY_PERMISSIONS
  OWNER_READ OWNER_WRITE OWNER_EXECUTE
  GROUP_READ GROUP_EXECUTE
  WORLD_READ WORLD_EXECUTE
  )

# Always have build dir as an include directory.
include_directories(
  ${CMAKE_CURRENT_BINARY_DIR}
  )

# Target Platform
if (WIN32 OR MINGW OR MSYS OR CYGWIN)
  set(HOSTOS "windows")
  set(GETDNS_ON_WINDOWS 1)
  set(USE_WINSOCK 1)
elseif (APPLE)
  set(HOSTOS "macos")
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_DARWIN_C_SOURCE")
elseif (UNIX)
  set(HOSTOS "unix")

  if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_POSIX_C_SOURCE=200112L -D_XOPEN_SOURCE=600")
  endif ()
  if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
    set(LINUX 1)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_BSD_SOURCE -D_DEFAULT_SOURCE")
  elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Solaris")
    set(SOLARIS 1)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__EXTENSIONS_")
  endif ()
endif ()

test_big_endian(TARGET_IS_BIG_ENDIAN)
set(HAVE_TARGET_ENDIANNESS 1)

# File locations
set(TRUST_ANCHOR_FILE "${CMAKE_INSTALL_FULL_SYSCONF_DIR}/unbound/getdns-root.key")
set(GETDNS_FN_RESOLVCONF "/etc/resolv.conf")
if (WIN32)
  # BUG! Don't hardcode the Windows directory and drive.
  set(GETDNS_FN_HOSTS "C:/Windows/System32/Drivers/etc/hosts")
else ()
  set(GETDNS_FN_HOSTS "${CMAKE_INSTALL_FULL_SYSCONF_DIR}/hosts")
endif ()

# Options.
option(ENABLE_SHARED "build shared libraries" ON)
option(ENABLE_STATIC "build static libraries" ON)
if ((NOT ENABLE_SHARED) AND (NOT ENABLE_STATIC))
  message(FATAL_ERROR "You must build either static or shared libraries.")
endif ()

set(DNSSEC_ROADBLOCK_AVOIDANCE 1)        # Nail on, as build fails if off.
set(STUB_NATIVE_DNSSEC 1)                # Nail on for now.
set(MAXIMUM_UPSTREAM_OPTION_SPACE 3000)
set(EDNS_PADDING_OPCODE 12)
set(MAX_CNAME_REFERRALS 100)
set(DRAFT_RRTYPES 1)
set(EDNS_COOKIE_OPCODE 10)
set(EDNS_COOKIE_ROLLOVER_TIME "(24*60*60)")
set(UDP_MAX_BACKOFF 1000)

# Does the compiler accept the "format" attribute?
try_compile(HAVE_ATTR_FORMAT
  ${CMAKE_CURRENT_BINARY_DIR}
  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/tests/test_format_attr.c
  )
# Does the compiler accept the "unused" attribute?
try_compile(HAVE_ATTR_UNUSED
  ${CMAKE_CURRENT_BINARY_DIR}
  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/tests/test_unused_attr.c
  )

# Compiler flags
if (MSVC)
  # The Visual Studio C compiler is C90 with some of C99 and C11.
  # So full on warnings are not appropriate.
  add_compile_options(/W2)
else ()
  add_compile_options(-Wall -Wextra)
endif ()

# Windows. Uh-oh.
set(getdns_system_libs "")
set(static_lib_suffix "")
if (DEFINED GETDNS_ON_WINDOWS)
  set(static_lib_suffix "_static")
  list(APPEND getdns_system_libs
    "ws2_32"
    "crypt32"
    "gdi32"
    "iphlpapi"
    )
endif ()

# Check for include files
check_include_file(assert.h HAVE_ASSERT_H)
check_include_file(inttypes.h HAVE_INTTYPES_H)
check_include_file(limits.h HAVE_LIMITS_H)
check_include_file(sys/limits.h HAVE_SYS_LIMITS_H)
check_include_file(stdarg.h HAVE_STDARG_H)
check_include_file(stdint.h HAVE_STDINT_H)
check_include_file(stdio.h HAVE_STDIO_H)
check_include_file(stdlib.h HAVE_STDLIB_H)
check_include_file(string.h HAVE_STRING_H)
check_include_file(time.h HAVE_TIME_H)
check_include_file(unistd.h HAVE_UNISTD_H)

check_include_file(fcntl.h HAVE_FCNTL_H)

check_include_file(signal.h HAVE_SIGNAL_H)
check_include_file(sys/poll.h HAVE_SYS_POLL_H)
check_include_file(poll.h HAVE_POLL_H)
check_include_file(resource.h HAVE_RESOURCE_H)
check_include_file(sys/types.h HAVE_SYS_TYPES_H)
check_include_file(sys/stat.h HAVE_SYS_STAT_H)

check_include_file(endian.h HAVE_ENDIAN_H)
check_include_file(netdb.h HAVE_NETDB_H)
check_include_file(arpa/inet.h HAVE_ARPA_INET_H)
check_include_file(netinet/in.h HAVE_NETINET_IN_H)
check_include_file(sys/select.h HAVE_SYS_SELECT_H)
check_include_file(sys/socket.h HAVE_SYS_SOCKET_H)
check_include_file(sys/sysctl.h HAVE_SYS_SYSCTL_H)
check_include_file(sys/time.h HAVE_SYS_TIME_H)
check_include_file(sys/wait.h HAVE_SYS_WAIT_H)

check_include_file(windows.h HAVE_WINDOWS_H)
check_include_file(winsock.h HAVE_WINSOCK_H)
check_include_file(winsock2.h HAVE_WINSOCK2_H)
check_include_file(ws2tcpip.h HAVE_WS2TCPIP_H)

# Check for include declarations
check_symbol_exists(getentropy unistd.h HAVE_DECL_GETENTROPY)
if (DEFINED GETDNS_ON_WINDOWS)
  set(CMAKE_REQUIRED_LIBRARIES ${getdns_system_libs})
  check_symbol_exists(inet_pton ws2tcpip.h HAVE_DECL_INET_PTON)
  check_symbol_exists(inet_ntop ws2tcpip.h HAVE_DECL_INET_NTOP)
else ()
  check_symbol_exists(inet_pton arpa/inet.h HAVE_DECL_INET_PTON)
  check_symbol_exists(inet_ntop arpa/inet.h HAVE_DECL_INET_NTOP)
endif ()
check_symbol_exists(mkstemp stdlib.h HAVE_DECL_MKSTEMP)
check_symbol_exists(sigemptyset signal.h HAVE_DECL_SIGEMPTYSET)
check_symbol_exists(sigfillset signal.h HAVE_DECL_SIGFILLSET)
check_symbol_exists(sigaddset signal.h HAVE_DECL_SIGADDSET)
check_symbol_exists(strptime time.h HAVE_DECL_STRPTIME)

# Check for functions
check_function_exists(fcntl HAVE_FCNTL)
check_function_exists(getauxval HAVE_GETAUXVAL)
check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
check_function_exists(ioctlsocket HAVE_IOCTLSOCKET)
check_function_exists(sigemptyset HAVE_SIGEMPTYSET)
check_function_exists(sigfillset HAVE_SIGFILLSET)
check_function_exists(sigaddset HAVE_SIGADDSET)
check_function_exists(strptime HAVE_STRPTIME)

# Check for types
check_type_size(sigset_t SIGSET_T)
check_type_size(_sigset_t _SIGSET_T)

# SSL library
find_package(OpenSSL "1.0.2" REQUIRED)

set(HAVE_SSL 1)

set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
check_include_file(openssl/ssl.h HAVE_OPENSSL_SSL_H)
check_include_file(openssl/evp.h HAVE_OPENSSL_EVP_H)
check_include_file(openssl/err.h HAVE_OPENSSL_ERR_H)
check_include_file(openssl/rand.h HAVE_OPENSSL_RAND_H)
check_include_file(openssl/conf.h HAVE_OPENSSL_CONF_H)
check_include_file(openssl/engine.h HAVE_OPENSSL_ENGINE_H)

set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_LIBRARIES})
check_function_exists(DSA_SIG_set0 HAVE_DSA_SIG_SET0)
check_function_exists(DSA_set0_pqg HAVE_DSA_SET0_PQG)
check_function_exists(DSA_set0_key HAVE_DSA_SET0_KEY)

check_function_exists(RSA_set0_key HAVE_RSA_SET0_KEY)

check_function_exists(EVP_md5 HAVE_EVP_MD5)
check_function_exists(EVP_sha1 HAVE_EVP_SHA1)
check_function_exists(EVP_sha224 HAVE_EVP_SHA224)
check_function_exists(EVP_sha256 HAVE_EVP_SHA256)
check_function_exists(EVP_sha384 HAVE_EVP_SHA384)
check_function_exists(EVP_sha512 HAVE_EVP_SHA512)

check_function_exists(EVP_dss1 HAVE_EVP_DSS1)
check_function_exists(EVP_DigestVerify HAVE_EVP_DIGESTVERIFY)

check_function_exists(EVP_MD_CTX_new HAVE_EVP_MD_CTX_NEW)

check_function_exists(HMAC_CTX_new HAVE_HMAC_CTX_NEW)

check_function_exists(OpenSSL_version_num HAVE_OPENSSL_VERSION_NUM)
check_function_exists(OpenSSL_version HAVE_OPENSSL_VERSION)

check_function_exists(SSL_CTX_dane_enable HAVE_SSL_CTX_DANE_ENABLE)

check_function_exists(SSL_CTX_set_ciphersuites HAVE_SSL_CTX_SET_CIPHERSUITES)
check_function_exists(SSL_set_ciphersuites HAVE_SSL_SET_CIPHERSUITES)

check_function_exists(OPENSSL_init_crypto HAVE_OPENSSL_INIT_CRYPTO)

check_symbol_exists(SSL_dane_enable "openssl/ssl.h" HAVE_SSL_DANE_ENABLE)
check_symbol_exists(SSL_CTX_set1_curves_list "openssl/ssl.h" HAVE_DECL_SSL_CTX_SET1_CURVES_LIST)
check_symbol_exists(SSL_set1_curves_list "openssl/ssl.h" HAVE_DECL_SSL_SET1_CURVES_LIST)
check_symbol_exists(SSL_set_min_proto_version "openssl/ssl.h" HAVE_DECL_SSL_SET_MIN_PROTO_VERSION)
check_symbol_exists(TLS_client_method "openssl/ssl.h" HAVE_TLS_CLIENT_METHOD)
check_symbol_exists(X509_get_notAfter "openssl/x509.h" HAVE_X509_GET_NOTAFTER)
check_symbol_exists(X509_get0_notAfter "openssl/x509.h" HAVE_X509_GET0_NOTAFTER)


# Threading library
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)

if (CMAKE_USE_PTHREADS_INIT)
  set(HAVE_PTHREAD 1)
elseif (CMAKE_USE_WIN32_THREADS_INIT)
  set(HAVE_WINDOWS_THREADS 1)
else ()
  message(WARNING "Neither pthreads nor Windows threading available.")
endif ()

# Stuff that might be in a BSD library
check_symbol_exists(strlcpy string.h HAVE_DECL_STRLCPY)
check_symbol_exists(arc4random stdlib.h HAVE_DECL_ARC4RANDOM)
check_symbol_exists(arc4random_uniform stdlib.h HAVE_DECL_ARC4RANDOM_UNIFORM)

check_function_exists(strlcpy HAVE_STRLCPY)
check_function_exists(arc4random HAVE_ARC4RANDOM)
check_function_exists(arc4random_uniform HAVE_ARC4RANDOM_UNIFORM)

if (NOT
    (HAVE_STRLCPY AND HAVE_DECL_STRLCPY AND
     HAVE_ARC4RANDOM AND HAVE_DECL_ARC4RANDOM AND
     HAVE_ARC4RANDOM_UNIFORM AND HAVE_DECL_ARC4RANDOM_UNIFORM))
 find_library(BSD_LIB bsd)
 if (BSD_LIB)
   list(APPEND getdns_system_libs "bsd")
   set(CMAKE_REQUIRED_LIBRARIES "bsd")

   check_include_file(bsd/stdlib.h HAVE_BSD_STDLIB_H)
   check_include_file(bsd/string.h HAVE_BSD_STRING_H)

   check_symbol_exists(strlcpy "bsd/string.h" HAVE_BSD_DECL_STRLCPY)
   set(HAVE_DECL_STRLCPY ${HAVE_BSD_DECL_STRLCPY})
   check_symbol_exists(arc4random "bsd/stdlib.h" HAVE_BSD_DECL_ARC4RANDOM)
   set(HAVE_DECL_ARC4RANDOM ${HAVE_BSD_DECL_ARC4RANDOM})
   check_symbol_exists(arc4random_uniform "bsd/stdlib.h" HAVE_BSD_DECL_ARC4RANDOM_UNIFORM)
   set(HAVE_DECL_ARC4RANDOM_UNIFORM ${HAVE_BSD_DECL_ARC4RANDOM_UNIFORM})

   check_function_exists(strlcpy HAVE_BSD_STRLCPY)
   set(HAVE_STRLCPY ${HAVE_BSD_STRLCPY})
   check_function_exists(arc4random HAVE_BSD_ARC4RANDOM)
   set(HAVE_ARC4RANDOM ${HAVE_BSD_ARC4RANDOM})
   check_function_exists(arc4random_uniform HAVE_BSD_ARC4RANDOM_UNIFORM)
   set(HAVE_ARC4RANDOM_UNIFORM ${HAVE_BSD_ARC4RANDOM_UNIFORM})
 endif ()
endif ()

# Event loop extension
# TODO: other event loops
set(DEFAULT_EVENTLOOP "select_eventloop")
if (HAVE_SYS_POLL_H)
  set(TEST_CFLAG "HAVE_SYS_POLL_H=1")
endif ()
try_compile(USE_POLL_DEFAULT_EVENTLOOP
  ${CMAKE_CURRENT_BINARY_DIR}
  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/tests/test_poll.c
  COMPILE_DEFINITIONS "${TEST_CFLAG}"
  )
if (USE_POLL_DEFAULT_EVENTLOOP)
  set(DEFAULT_EVENTLOOP "poll_eventloop")
endif ()

# Custom checks
set(STRPTIME_TEST_SOURCE "\n
  #define _XOPEN_SOURCE 600\n
  #include <time.h>\n
  int main(void) { struct tm tm; char *res;\n
  res = strptime(\"2010-07-15T00:00:00+00:00\", \"%t%Y%t-%t%m%t-%t%d%tT%t%H%t:%t%M%t:%t%S%t\", &tm);\n
  if (!res) return 2;\n
  res = strptime(\"20070207111842\", \"%Y%m%d%H%M%S\", &tm);\n
  if (!res) return 1; return 0; }")

if (HAVE_STRPTIME)
  check_c_source_runs("${STRPTIME_TEST_SOURCE}" STRPTIME_WORKS)
endif ()

# Main library
add_library(getdns_objects OBJECT
  src/anchor.c
  src/const-info.c
  src/convert.c
  src/context.c
  src/dict.c
  src/dnssec.c
  src/general.c
  src/list.c
  src/request-internal.c
  src/mdns.c
  src/platform.c
  src/pubkey-pinning.c
  src/rr-dict.c
  src/rr-iter.c
  src/server.c
  src/stub.c
  src/sync.c
  src/ub_loop.c
  src/util-internal.c

  src/extension/${DEFAULT_EVENTLOOP}.c

  src/gldns/keyraw.c
  src/gldns/gbuffer.c
  src/gldns/wire2str.c
  src/gldns/parse.c
  src/gldns/parseutil.c
  src/gldns/rrdef.c
  src/gldns/str2wire.c

  src/util/rbtree.c
  src/util/lruhash.c
  src/util/lookup3.c
  src/util/locks.c

  src/jsmn/jsmn.c

  src/yxml/yxml.c

  src/tls/val_secalgo.c
  src/tls/anchor-internal.c

  src/openssl/tls.c
  src/openssl/pubkey-pinning-internal.c
  src/openssl/keyraw-internal.c

  ${CMAKE_CURRENT_BINARY_DIR}/version.c
  )
if (NOT HAVE_GETTIMEOFDAY)
  target_sources(getdns_objects PRIVATE src/compat/gettimeofday.c)
endif ()
if (NOT HAVE_DECL_INET_PTON)
  target_sources(getdns_objects PRIVATE src/compat/inet_pton.c)
endif ()
if (NOT HAVE_DECL_INET_NTOP)
  target_sources(getdns_objects PRIVATE src/compat/inet_ntop.c)
endif ()
if (NOT HAVE_DECL_MKSTEMP)
  target_sources(getdns_objects PRIVATE src/compat/mkstemp.c)
endif ()
if (NOT HAVE_DECL_STRLCPY)
  target_sources(getdns_objects PRIVATE src/compat/strlcpy.c)
endif ()
if (NOT HAVE_DECL_ARC4RANDOM)
  target_sources(getdns_objects PRIVATE
    src/compat/arc4random.c
    src/compat/explicit_bzero.c
    src/compat/arc4_lock.c
    )

  if (NOT HAVE_DECL_GETENTROPY)
    if (DEFINED GETDNS_ON_WINDOWS)
      target_sources(getdns_objects PRIVATE src/compat/getentropy_win.c)
    elseif (APPLE)
      target_sources(getdns_objects PRIVATE src/compat/getentropy_osx.c)
    elseif (DEFINED LINUX)
      target_sources(getdns_objects PRIVATE src/compat/getentropy_linux.c)
    endif ()
  endif ()
endif ()
if (NOT HAVE_DECL_ARC4RANDOM_UNIFORM)
  target_sources(getdns_objects PRIVATE src/compat/arc4random_uniform.c)
endif ()
if (NOT STRPTIME_WORKS)
  target_sources(getdns_objects PRIVATE src/compat/strptime.c)
endif ()
target_include_directories(getdns_objects
  PUBLIC
  src

  PRIVATE
  src/util/auxiliary
  src/openssl
  src/tls
  src/yxml
  stubby/src    # Wrong, wrong, wrong.

  ${OPENSSL_INCLUDE_DIR}
  )
if (NOT HAVE_SSL_DANE_ENABLE)
  target_sources(getdns_objects PRIVATE src/ssl_dane/danessl.c)
  target_include_directories(getdns_objects PRIVATE src/ssl_dane)
  set(USE_DANESSL 1)
endif ()

# Don't compile separate objects for shared and static libraries.
# Yes, -fPIC is slightly suboptimal for static libraries, but it looks
# to me that it's the behaviour the autoconf build follows.
set_property(TARGET getdns_objects PROPERTY POSITION_INDEPENDENT_CODE 1)
set_property(TARGET getdns_objects PROPERTY C_STANDARD 11)

# Static library version of main library.
if (ENABLE_STATIC)
  add_library(getdns STATIC $<TARGET_OBJECTS:getdns_objects>)
  target_include_directories(getdns PUBLIC
    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>"
    )
  target_link_libraries(getdns
    PUBLIC
    OpenSSL::SSL
    OpenSSL::Crypto
    Threads::Threads
    ${getdns_system_libs}
    )
  set_target_properties(getdns PROPERTIES OUTPUT_NAME getdns${static_lib_suffix})
endif ()

# Shared library version of main library.
if (ENABLE_SHARED)
  add_library(getdns_shared SHARED $<TARGET_OBJECTS:getdns_objects>)
  target_include_directories(getdns_shared PUBLIC
    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>"
    )
  target_link_libraries(getdns_shared
    PUBLIC
    OpenSSL::SSL
    OpenSSL::Crypto
    Threads::Threads
    ${getdns_system_libs}
    )
  set_target_properties(getdns_shared PROPERTIES OUTPUT_NAME getdns)

  if (NOT ENABLE_STATIC)
    add_library(getdns ALIAS getdns_shared)
  endif ()

  # Generate platform-specific link file with the export symbols.
  file(STRINGS src/libgetdns.symbols symbols)
  if (WIN32)
    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/getdns.def" "LIBRARY GETDNS\n  VERSION ${GETDNS_VERSION_CURRENT}.${GETDNS_VERSION_REVISION}\n  EXPORTS\n")
    foreach (symbol IN LISTS symbols)
      file(APPEND "${CMAKE_CURRENT_BINARY_DIR}/getdns.def" "    ${symbol}\n")
    endforeach ()
    target_sources(getdns_shared PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/getdns.def")
  elseif (APPLE)
    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/getdns.syms" "")
    foreach (symbol IN LISTS symbols)
      file(APPEND "${CMAKE_CURRENT_BINARY_DIR}/getdns.syms" "_${symbol}\n")
    endforeach ()
    target_sources(getdns_shared PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/getdns.syms")
    target_link_libraries(getdns_shared PRIVATE "-exported_symbols_list getdns.syms")

    # Follow libtool. Add one to major version, as version 0 doesn't work.
    # But tag dynlib name with current-age.
    math(EXPR major_version "${GETDNS_VERSION_CURRENT}+1")
    math(EXPR dynlib_version "${GETDNS_VERSION_CURRENT}-${GETDNS_VERSION_AGE}")
    set_target_properties(getdns_shared PROPERTIES VERSION "${dynlib_version}")
    target_link_libraries(getdns_shared PRIVATE "-compatibility_version ${major_version}")
    target_link_libraries(getdns_shared PRIVATE "-current_version ${major_version}.${GETDNS_VERSION_REVISION}")
  else ()
    # Assume GNU ld.
    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/getdns.ver" "{ global:\n")
    foreach (symbol IN LISTS symbols)
      file(APPEND "${CMAKE_CURRENT_BINARY_DIR}/getdns.ver" "  ${symbol};\n")
    endforeach ()
    file(APPEND "${CMAKE_CURRENT_BINARY_DIR}/getdns.ver" "local:\n  *;\n};\n")
    target_link_libraries(getdns_shared PRIVATE "-Wl,--version-script=getdns.ver")

    # Again, follow libtool. Major version is current-age.
    math(EXPR compat_version "${GETDNS_VERSION_CURRENT}-${GETDNS_VERSION_AGE}")
    set_target_properties(getdns_shared PROPERTIES VERSION "${compat_version}.${GETDNS_VERSION_AGE}.${GETDNS_VERSION_REVISION}" SOVERSION "${compat_version}")
  endif ()
endif ()


# The tools.
add_executable(getdns_query src/tools/getdns_query.c)
if (NOT HAVE_GETTIMEOFDAY)
  target_sources(getdns_query PRIVATE src/compat/gettimeofday.c)
endif ()
target_link_libraries(getdns_query PRIVATE getdns)
set_property(TARGET getdns_query PROPERTY C_STANDARD 11)

add_executable(getdns_server_mon src/tools/getdns_server_mon.c)
target_link_libraries(getdns_server_mon
  PUBLIC
  OpenSSL::SSL
  OpenSSL::Crypto
  PRIVATE
  getdns
  )
set_property(TARGET getdns_server_mon PROPERTY C_STANDARD 11)

find_package(Check "0.9.6")

if (NOT Check_FOUND)
  message(WARNING "check library not found, not building test programs")
else ()
  add_executable(check_getdns
    src/test/check_getdns_common.c
    src/test/check_getdns_context_set_timeout.c
    src/test/check_getdns_transport.c
    src/test/check_getdns_selectloop.c
    src/test/check_getdns.c
    )
  target_link_libraries(check_getdns
    PRIVATE
    getdns
    Check::Check
    Threads::Threads
    )

  add_executable(tests_dict
    src/test/tests_dict.c
    src/test/testmessages.c
    )
  target_link_libraries(tests_dict PRIVATE getdns Check::Check)

  add_executable(tests_list
    src/test/tests_list.c
    src/test/testmessages.c
    )
  target_link_libraries(tests_list PRIVATE getdns Check::Check)

  add_executable(tests_namespaces src/test/tests_namespaces.c)
  target_link_libraries(tests_namespaces PRIVATE getdns Check::Check)

  add_executable(tests_stub_async
    src/test/tests_stub_async.c
    src/test/testmessages.c
    )
  target_link_libraries(tests_stub_async PRIVATE getdns Check::Check)

  add_executable(tests_stub_sync src/test/tests_stub_sync.c)
  target_link_libraries(tests_stub_sync PRIVATE getdns Check::Check)

  include(CTest)

  add_test(NAME test_noeventloop COMMAND check_getdns)
  set_property(TEST test_noeventloop PROPERTY
    ENVIRONMENT "GETDNS_TEST_PORT=43210;CK_TIMEOUT_MULTIPLIER=2;CK_LOG_FILE_NAME=check_getdns.log"
    )
endif ()

# Substitutions in files.
configure_file(cmake/include/cmakeconfig.h.in config.h)
configure_file(src/getdns/getdns.h.in getdns/getdns.h)
configure_file(src/getdns/getdns_extra.h.in getdns/getdns_extra.h)
configure_file(src/version.c.in version.c)

set(version ${PACKAGE_VERSION})
set(date ${API_VERSION})
file(GLOB mans doc/*.3.in)
file(MAKE_DIRECTORY man3)
foreach (man ${mans})
  get_filename_component(out ${man} NAME_WE)
  configure_file(${man} man3/${out}.3 @ONLY)

  # Look through the page and make copies of the page for all APIs
  # defined in that page. Defined means listed in a line ".B <name>"
  # between lines ".SH NAME" and ".SH LIBRARY". Ignore terminating ","
  # or spaces in .B line.
  file(STRINGS ${man} manpage REGEX "^\\.(SH +NAME|SH +LIBRARY|B )")
  set(in_list 0)
  foreach (line ${manpage})
    if ("${line}" MATCHES "^\\.SH +NAME")
      set(in_list 1)
    elseif ("${line}" MATCHES "^\\.SH +LIBRARY")
      set(in_list 0)
    elseif (${in_list})
      string(REGEX REPLACE ".B +([^ ,]+).*" "\\1" alt "${line}")
      configure_file(${man} man3/${alt}.3 @ONLY)
    endif ()
  endforeach()
endforeach()

set(prefix ${CMAKE_INSTALL_PREFIX})
configure_file(getdns.pc.in getdns.pc @ONLY)

# Installing.
if (ENABLE_STATIC)
  install(TARGETS getdns LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)
endif ()
if (ENABLE_SHARED)
  install(TARGETS getdns_shared LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)
endif ()
install(TARGETS getdns_query getdns_server_mon RUNTIME DESTINATION bin)

install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/getdns DESTINATION include)
install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/man3 DESTINATION share/man)

set(docdir share/doc/getdns)
install(FILES AUTHORS ChangeLog COPYING INSTALL LICENSE NEWS README.md DESTINATION ${docdir})
install(FILES spec/index.html DESTINATION ${docdir}/spec)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/getdns.pc DESTINATION lib/pkgconfig)

install(CODE "message(\"\
***\n\
***  !!! IMPORTANT !!!!\n\
***\n\
***  From release 1.2.0, getdns comes with built-in DNSSEC\n\
***  trust anchor management.  External trust anchor management,\n\
***  for example with unbound-anchor, is no longer necessary\n\
***  and no longer recommended.\n\
***\n\
***  Previously installed trust anchors, in the default location -\n\
***\n\
***        /etc/unbound/getdns-root.key\n\
***\n\
***  - will be preferred and used for DNSSEC validation, however\n\
***  getdns will fallback to trust-anchors obtained via built-in\n\
***  trust anchor management when the anchors from the default\n\
***  location fail to validate the root DNSKEY rrset.\n\
***\n\
***  To prevent expired DNSSEC trust anchors to be used for\n\
***  validation, we strongly recommend removing the trust anchors\n\
***  on the default location when there is no active external\n\
***  trust anchor management keeping it up-to-date.\n\
***\")")