CMake/Source/CTest/Curl/CMakeLists.txt

CMAKE_MINIMUM_REQUIRED(VERSION 1.5)
PROJECT(LIBCURL C)

INCLUDE_REGULAR_EXPRESSION("^.*\\.h$")

# Setup package meta-data
SET(PACKAGE "curl")
SET(VERSION "7.10.3")
SET(PACKAGE_TARNAME " ")
SET(PACKAGE_BUGREPORT " ")
SET(PACKAGE_NAME " ")
SET(PACKAGE_VERSION " ")
SET(PACKAGE_STRING " ")
SET(OPERATING_SYSTEM ${CMAKE_SYSTEM_NAME})

# We need ansi c-flags, especially on HP
SET(CMAKE_C_FLAGS "${CMAKE_ANSI_CFLAGS} ${CMAKE_C_FLAGS}")
SET(CMAKE_REQUIRED_FLAGS ${CMAKE_ANSI_CFLAGS})

# If we are on AIX, do the _ALL_SOURCE magic
IF(${CMAKE_SYSTEM_NAME} MATCHES AIX)
  SET(_ALL_SOURCE 1)
ENDIF(${CMAKE_SYSTEM_NAME} MATCHES AIX)

# Include all the necessary files for macros
INCLUDE (${CMAKE_ROOT}/Modules/CheckFunctionExists.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFiles.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CheckLibraryExists.cmake)
INCLUDE (${LIBCURL_SOURCE_DIR}/CMake/CheckSymbolExists.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CheckTypeSize.cmake)

SET(libCurl_SRCS
    file.c
    timeval.c
    base64.c
    hostip.c
    progress.c
    formdata.c
    cookie.c
    http.c
    sendf.c
    ftp.c
    url.c
    dict.c
    if2ip.c
    speedcheck.c
    getdate.c
    ldap.c
    ssluse.c
    version.c
    getenv.c
    escape.c
    mprintf.c
    telnet.c
    getpass.c
    netrc.c
    getinfo.c
    transfer.c
    strequal.c
    easy.c
    security.c
    krb4.c
    http_chunks.c
    strtok.c
    connect.c
    llist.c
    hash.c
    multi.c
    content_encoding.c
    )

OPTION(CURL_MALLOC_DEBUG "Debug mallocs in Curl" OFF)
MARK_AS_ADVANCED(CURL_MALLOC_DEBUG)
IF(CURL_MALLOC_DEBUG)
  SET(libCurl_SRCS ${libCurl_SRCS}
    memdebug.c
  )
ENDIF(CURL_MALLOC_DEBUG)

# On windows preload settings
#IF(WIN32)
#  INCLUDE(${LIBCURL_SOURCE_DIR}/Platforms/WindowsCache.cmake)
#ENDIF(WIN32)

# This macro checks if the symbol exists in the library and if it
# does, it appends library to the list.
SET(CURL_LIBS "")
MACRO(CHECK_LIBRARY_EXISTS_CONCAT LIBRARY SYMBOL VARIABLE)
  CHECK_LIBRARY_EXISTS("${LIBRARY};${CURL_LIBS}" ${SYMBOL} "" 
                       ${VARIABLE})
  IF(${VARIABLE})
    SET(CURL_LIBS ${CURL_LIBS} ${LIBRARY})
  ENDIF(${VARIABLE})
ENDMACRO(CHECK_LIBRARY_EXISTS_CONCAT)

# Check for all needed libraries
CHECK_LIBRARY_EXISTS_CONCAT("dl"     dlopen       HAVE_LIBDL)
CHECK_LIBRARY_EXISTS_CONCAT("ucb"    gethostname  HAVE_LIBUCB)
CHECK_LIBRARY_EXISTS_CONCAT("socket" connect      HAVE_LIBSOCKET)
CHECK_LIBRARY_EXISTS("c" gethostbyname "" NOT_NEED_LIBNSL)

IF(NOT NOT_NEED_LIBNSL)
  CHECK_LIBRARY_EXISTS_CONCAT("nsl"    gethostbyname  HAVE_LIBNSL)
ENDIF(NOT NOT_NEED_LIBNSL)

CHECK_LIBRARY_EXISTS_CONCAT("ws2_32" getch        HAVE_LIBWS2_32)
CHECK_LIBRARY_EXISTS_CONCAT("winmm"  getch        HAVE_LIBWINMM)
CHECK_LIBRARY_EXISTS_CONCAT("z"      inflateEnd   HAVE_LIBZ)
CHECK_LIBRARY_EXISTS_CONCAT("crypto" CRYPTO_lock  HAVE_LIBCRYPTO)
CHECK_LIBRARY_EXISTS_CONCAT("ssl"    SSL_connect  HAVE_LIBSSL)

# Check for symbol dlopen (same as HAVE_LIBDL)
CHECK_LIBRARY_EXISTS("${CURL_LIBS}" dlopen "" HAVE_DLOPEN)

# For other tests to use the same libraries
SET(CMAKE_REQUIRED_LIBRARIES ${CURL_LIBS})

# If we have features.h, then do the _BSD_SOURCE magic
CHECK_INCLUDE_FILE("features.h"       HAVE_FEATURES_H)
IF(HAVE_FEATURES_H)
  SET_SOURCE_FILES_PROPERTIES(
    cookie.c
    easy.c
    formdata.c
    getenv.c
    hash.c
    http.c
    if2ip.c 
    mprintf.c
    multi.c
    sendf.c
    telnet.c
    transfer.c
    url.c
    COMPILE_FLAGS -D_BSD_SOURCE)
ENDIF(HAVE_FEATURES_H)

# Check if header file exists and add it to the list.
MACRO(CHECK_INCLUDE_FILE_CONCAT FILE VARIABLE)
  CHECK_INCLUDE_FILES("${CURL_INCLUDES};${FILE}" ${VARIABLE})
  IF(${VARIABLE})
    SET(CURL_INCLUDES ${CURL_INCLUDES} ${FILE})
  ENDIF(${VARIABLE})
ENDMACRO(CHECK_INCLUDE_FILE_CONCAT)

# Check for header files
CHECK_INCLUDE_FILE_CONCAT("sys/types.h"      HAVE_SYS_TYPES_H)
CHECK_INCLUDE_FILE_CONCAT("inttypes.h"       HAVE_INTTYPES_H)
CHECK_INCLUDE_FILE_CONCAT("alloca.h"         HAVE_ALLOCA_H)
CHECK_INCLUDE_FILE_CONCAT("arpa/inet.h"      HAVE_ARPA_INET_H)
CHECK_INCLUDE_FILE_CONCAT("dlfcn.h"          HAVE_DLFCN_H)
CHECK_INCLUDE_FILE_CONCAT("fcntl.h"          HAVE_FCNTL_H)
CHECK_INCLUDE_FILE_CONCAT("malloc.h"         HAVE_MALLOC_H)
CHECK_INCLUDE_FILE_CONCAT("memory.h"         HAVE_MEMORY_H)
CHECK_INCLUDE_FILE_CONCAT("netdb.h"          HAVE_NETDB_H)
CHECK_INCLUDE_FILE_CONCAT("zlib.h"           HAVE_ZLIB_H)
CHECK_INCLUDE_FILE_CONCAT("sys/poll.h"       HAVE_SYS_POLL_H)

IF(CMAKE_USE_OPENSSL)
  CHECK_INCLUDE_FILE_CONCAT("openssl/x509.h"   HAVE_OPENSSL_X509_H)
  CHECK_INCLUDE_FILE_CONCAT("openssl/engine.h" HAVE_OPENSSL_ENGINE_H)
  CHECK_INCLUDE_FILE_CONCAT("openssl/rsa.h"    HAVE_OPENSSL_RSA_H)
  CHECK_INCLUDE_FILE_CONCAT("openssl/crypto.h" HAVE_OPENSSL_CRYPTO_H)
  CHECK_INCLUDE_FILE_CONCAT("openssl/pem.h"    HAVE_OPENSSL_PEM_H)
  CHECK_INCLUDE_FILE_CONCAT("openssl/ssl.h"    HAVE_OPENSSL_SSL_H)
  CHECK_INCLUDE_FILE_CONCAT("openssl/err.h"    HAVE_OPENSSL_ERR_H)
ENDIF(CMAKE_USE_OPENSSL)

CHECK_INCLUDE_FILE_CONCAT("sys/socket.h"     HAVE_SYS_SOCKET_H)
CHECK_INCLUDE_FILE_CONCAT("netinet/in.h"     HAVE_NETINET_IN_H)
CHECK_INCLUDE_FILE_CONCAT("net/if.h"         HAVE_NET_IF_H)
CHECK_INCLUDE_FILE_CONCAT("netinet/if_ether.h" 
                          HAVE_NETINET_IF_ETHER_H)
CHECK_INCLUDE_FILE_CONCAT("sys/select.h"    HAVE_SYS_SELECT_H)
CHECK_INCLUDE_FILE_CONCAT("utime.h"         HAVE_UTIME_H)
CHECK_INCLUDE_FILE_CONCAT("netinet/in.h"    HAVE_NETINET_IN_H)
CHECK_INCLUDE_FILE_CONCAT("pwd.h"           HAVE_PWD_H)
CHECK_INCLUDE_FILE_CONCAT("sgtty.h"         HAVE_SGTTY_H)
CHECK_INCLUDE_FILE_CONCAT("stdint.h"        HAVE_STDINT_H)
CHECK_INCLUDE_FILE_CONCAT("stdlib.h"        HAVE_STDLIB_H)
CHECK_INCLUDE_FILE_CONCAT("string.h"        HAVE_STRING_H)
CHECK_INCLUDE_FILE_CONCAT("strings.h"       HAVE_STRINGS_H)
CHECK_INCLUDE_FILE_CONCAT("sys/param.h"     HAVE_SYS_PARAM_H)
CHECK_INCLUDE_FILE_CONCAT("sys/stat.h"      HAVE_SYS_STAT_H)
CHECK_INCLUDE_FILE_CONCAT("sys/time.h"      HAVE_SYS_TIME_H)
CHECK_INCLUDE_FILE_CONCAT("termios.h"       HAVE_TERMIOS_H)
CHECK_INCLUDE_FILE_CONCAT("termio.h"        HAVE_TERMIO_H)
CHECK_INCLUDE_FILE_CONCAT("io.h"            HAVE_IO_H)
CHECK_INCLUDE_FILE_CONCAT("time.h"          HAVE_TIME_H)
CHECK_INCLUDE_FILE_CONCAT("unistd.h"        HAVE_UNISTD_H)
CHECK_INCLUDE_FILE_CONCAT("sys/utime.h"     HAVE_SYS_UTIME_H)
CHECK_INCLUDE_FILE_CONCAT("winsock.h"       HAVE_WINSOCK_H)
CHECK_INCLUDE_FILE_CONCAT("sockio.h"        HAVE_SOCKIO_H)
CHECK_INCLUDE_FILE_CONCAT("sys/sockio.h"    HAVE_SYS_SOCKIO_H)
CHECK_INCLUDE_FILE_CONCAT("x509.h"          HAVE_X509_H)
CHECK_INCLUDE_FILE_CONCAT("setjmp.h"        HAVE_SETJMP_H)
CHECK_INCLUDE_FILE_CONCAT("signal.h"        HAVE_SIGNAL_H)

CHECK_TYPE_SIZE(ssize_t  SIZEOF_SSIZE_T)
CHECK_TYPE_SIZE("long double"  SIZEOF_LONG_DOUBLE)
IF(NOT HAVE_SIZEOF_SSIZE_T)
  SET(ssize_t int)
ENDIF(NOT HAVE_SIZEOF_SSIZE_T)

FIND_FILE(RANDOM_FILE urandom /dev)

# Check for some functions that are used
CHECK_SYMBOL_EXISTS(socket        "${CURL_INCLUDES}" HAVE_SOCKET)
CHECK_SYMBOL_EXISTS(poll          "${CURL_INCLUDES}" HAVE_POLL)
CHECK_SYMBOL_EXISTS(select        "${CURL_INCLUDES}" HAVE_SELECT)
CHECK_SYMBOL_EXISTS(strdup        "${CURL_INCLUDES}" HAVE_STRDUP)
CHECK_SYMBOL_EXISTS(strstr        "${CURL_INCLUDES}" HAVE_STRSTR)
CHECK_SYMBOL_EXISTS(strtok_r      "${CURL_INCLUDES}" HAVE_STRTOK_R)
CHECK_SYMBOL_EXISTS(strftime      "${CURL_INCLUDES}" HAVE_STRFTIME)
CHECK_SYMBOL_EXISTS(uname         "${CURL_INCLUDES}" HAVE_UNAME)
CHECK_SYMBOL_EXISTS(strcasecmp    "${CURL_INCLUDES}" HAVE_STRCASECMP)
CHECK_SYMBOL_EXISTS(stricmp       "${CURL_INCLUDES}" HAVE_STRICMP)
CHECK_SYMBOL_EXISTS(strcmpi       "${CURL_INCLUDES}" HAVE_STRCMPI)
CHECK_SYMBOL_EXISTS(gethostbyaddr "${CURL_INCLUDES}" HAVE_GETHOSTBYADDR)
CHECK_SYMBOL_EXISTS(gettimeofday  "${CURL_INCLUDES}" HAVE_GETTIMEOFDAY)
CHECK_SYMBOL_EXISTS(inet_addr     "${CURL_INCLUDES}" HAVE_INET_ADDR)
CHECK_SYMBOL_EXISTS(inet_ntoa     "${CURL_INCLUDES}" HAVE_INET_NTOA)
CHECK_SYMBOL_EXISTS(inet_ntoa_r   "${CURL_INCLUDES}" HAVE_INET_NTOA_R)
CHECK_SYMBOL_EXISTS(tcsetattr     "${CURL_INCLUDES}" HAVE_TCSETATTR)
CHECK_SYMBOL_EXISTS(tcgetattr     "${CURL_INCLUDES}" HAVE_TCGETATTR)
CHECK_SYMBOL_EXISTS(perror        "${CURL_INCLUDES}" HAVE_PERROR)
CHECK_SYMBOL_EXISTS(closesocket   "${CURL_INCLUDES}" HAVE_CLOSESOCKET)
CHECK_SYMBOL_EXISTS(setvbuf       "${CURL_INCLUDES}" HAVE_SETVBUF)
CHECK_SYMBOL_EXISTS(sigsetjmp     "${CURL_INCLUDES}" HAVE_SIGSETJMP)
CHECK_SYMBOL_EXISTS(getpass_r     "${CURL_INCLUDES}" HAVE_GETPASS_R)
CHECK_SYMBOL_EXISTS(strlcat       "${CURL_INCLUDES}" HAVE_STRLCAT)
CHECK_SYMBOL_EXISTS(getpwuid      "${CURL_INCLUDES}" HAVE_GETPWUID)
CHECK_SYMBOL_EXISTS(geteuid       "${CURL_INCLUDES}" HAVE_GETEUID)
CHECK_SYMBOL_EXISTS(utime         "${CURL_INCLUDES}" HAVE_UTIME)
CHECK_SYMBOL_EXISTS(RAND_status   "${CURL_INCLUDES}" HAVE_RAND_STATUS)
CHECK_SYMBOL_EXISTS(RAND_screen   "${CURL_INCLUDES}" HAVE_RAND_SCREEN)
CHECK_SYMBOL_EXISTS(RAND_egd      "${CURL_INCLUDES}" HAVE_RAND_EGD)
CHECK_SYMBOL_EXISTS(gmtime_r      "${CURL_INCLUDES}" HAVE_GMTIME_R)
CHECK_SYMBOL_EXISTS(localtime_r   "${CURL_INCLUDES}" HAVE_LOCALTIME_R)

CHECK_SYMBOL_EXISTS(gethostbyname_r "${CURL_INCLUDES};netdb.h" HAVE_GETHOSTBYNAME_R)
CHECK_SYMBOL_EXISTS(gethostbyaddr_r "${CURL_INCLUDES};netdb.h" HAVE_GETHOSTBYADDR_R)

CHECK_SYMBOL_EXISTS(signal        "${CURL_INCLUDES}" HAVE_SIGNAL_FUNC)
CHECK_SYMBOL_EXISTS(SIGALRM       "${CURL_INCLUDES}" HAVE_SIGNAL_MACRO)
IF(HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO)
  SET(HAVE_SIGNAL 1)
ENDIF(HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO)


# sigaction and sigsetjmp are special. Use special mechanism for
# detecting those, but only if previous attempt failed.
IF(HAVE_SIGNAL_H)
  CHECK_SYMBOL_EXISTS(sigaction "signal.h" HAVE_SIGACTION)
ENDIF(HAVE_SIGNAL_H)

IF(NOT HAVE_SIGSETJMP)
  IF(HAVE_SETJMP_H)
    CHECK_SYMBOL_EXISTS(sigsetjmp "setjmp.h" HAVE_MACRO_SIGSETJMP)
    IF(HAVE_MACRO_SIGSETJMP)
      SET(HAVE_SIGSETJMP 1)
    ENDIF(HAVE_MACRO_SIGSETJMP)
  ENDIF(HAVE_SETJMP_H)
ENDIF(NOT HAVE_SIGSETJMP)

# For other curl specific tests, use this macro.
MACRO(CURL_INTERNAL_TEST CURL_TEST)
  IF("${CURL_TEST}" MATCHES "^${CURL_TEST}$")
    SET(MACRO_CHECK_FUNCTION_DEFINITIONS 
	"-D${CURL_TEST} ${CMAKE_REQUIRED_FLAGS}")
    IF(CMAKE_REQUIRED_LIBRARIES)
      SET(CURL_TEST_ADD_LIBRARIES
          "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
    ENDIF(CMAKE_REQUIRED_LIBRARIES)

    MESSAGE(STATUS "Performing Curl Test ${CURL_TEST}")
    TRY_COMPILE(${CURL_TEST}
                ${CMAKE_BINARY_DIR}
                ${LIBCURL_SOURCE_DIR}/CMake/CurlTests.c
                CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
                            "${CURL_TEST_ADD_LIBRARIES}"
                OUTPUT_VARIABLE OUTPUT)
    IF(${CURL_TEST})
      SET(${CURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Success")
    ELSE(${CURL_TEST})
      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
      SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
      WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeError.log 
        "Performing Curl Test ${CURL_TEST} failed with the following output:\n"
        "${OUTPUT}\n" APPEND)
    ENDIF(${CURL_TEST})
  ENDIF("${CURL_TEST}" MATCHES "^${CURL_TEST}$")
ENDMACRO(CURL_INTERNAL_TEST) 

# Do curl specific tests
FOREACH(CURL_TEST 
        TIME_WITH_SYS_TIME
        HAVE_O_NONBLOCK
        HAVE_GETHOSTBYADDR_R_5
        HAVE_GETHOSTBYADDR_R_7
        HAVE_GETHOSTBYADDR_R_8
        HAVE_GETHOSTBYADDR_R_5_REENTRANT
        HAVE_GETHOSTBYADDR_R_7_REENTRANT
        HAVE_GETHOSTBYADDR_R_8_REENTRANT
        HAVE_GETHOSTBYNAME_R_3
        HAVE_GETHOSTBYNAME_R_5
        HAVE_GETHOSTBYNAME_R_6
        HAVE_GETHOSTBYNAME_R_3_REENTRANT
        HAVE_GETHOSTBYNAME_R_5_REENTRANT
        HAVE_GETHOSTBYNAME_R_6_REENTRANT
        HAVE_SOCKLEN_T
        HAVE_IN_ADDR_T
        STDC_HEADERS
        RETSIGTYPE_TEST
	HAVE_INET_NTOA_R_DECL
	HAVE_INET_NTOA_R_DECL_REENTRANT
        HAVE_GETADDRINFO
        )
  CURL_INTERNAL_TEST(${CURL_TEST})
ENDFOREACH(CURL_TEST)

# Check for reentrant
FOREACH(CURL_TEST
        HAVE_GETHOSTBYADDR_R_5
        HAVE_GETHOSTBYADDR_R_7
        HAVE_GETHOSTBYADDR_R_8
        HAVE_GETHOSTBYNAME_R_3
        HAVE_GETHOSTBYNAME_R_5
        HAVE_GETHOSTBYNAME_R_6
	HAVE_INET_NTOA_R_DECL_REENTRANT)
  IF(NOT ${CURL_TEST})
    IF(${CURL_TEST}_REENTRANT)
      SET(NEED_REENTRANT 1)
    ENDIF(${CURL_TEST}_REENTRANT)
  ENDIF(NOT ${CURL_TEST})
ENDFOREACH(CURL_TEST)

IF(NEED_REENTRANT)
  FOREACH(CURL_TEST
          HAVE_GETHOSTBYADDR_R_5
          HAVE_GETHOSTBYADDR_R_7
          HAVE_GETHOSTBYADDR_R_8
          HAVE_GETHOSTBYNAME_R_3
          HAVE_GETHOSTBYNAME_R_5
          HAVE_GETHOSTBYNAME_R_6)
    SET(${CURL_TEST} 0)
    IF(${CURL_TEST}_REENTRANT)
      SET(${CURL_TEST} 1)
    ENDIF(${CURL_TEST}_REENTRANT)
  ENDFOREACH(CURL_TEST)
ENDIF(NEED_REENTRANT)

IF(HAVE_INET_NTOA_R_DECL_REENTRANT)
  SET(HAVE_INET_NTOA_R_DECL 1)
  SET(NEED_REENTRANT 1)
ENDIF(HAVE_INET_NTOA_R_DECL_REENTRANT)

# Some other minor tests

IF(NOT HAVE_SOCKLEN_T)
  SET(socklen_t "int")
ENDIF(NOT HAVE_SOCKLEN_T)

IF(NOT HAVE_IN_ADDR_T)
  SET(in_addr_t "unsigned long")
ENDIF(NOT HAVE_IN_ADDR_T)

# Fix libz / zlib.h

IF(NOT HAVE_LIBZ)
  SET(HAVE_ZLIB_H 0)
ENDIF(NOT HAVE_LIBZ)

IF(NOT HAVE_ZLIB_H)
  SET(HAVE_LIBZ 0)
ENDIF(NOT HAVE_ZLIB_H)

# Check for nonblocking

SET(HAVE_SOME_NONBLOCK 0)
FOREACH(CURL_TEST
        HAVE_FIONBIO
        HAVE_IOCTLSOCKET
        HAVE_IOCTLSOCKET_CASE
        HAVE_O_NONBLOCK)
  IF(${CURL_TEST})
    SET(HAVE_SOME_NONBLOCK 1)
  ENDIF(${CURL_TEST})
ENDFOREACH(CURL_TEST)
IF(NOT HAVE_SOME_NONBLOCK)
  SET(HAVE_DISABLED_NONBLOCKING 1)
ENDIF(NOT HAVE_SOME_NONBLOCK)

IF(RETSIGTYPE_TEST)
  SET(RETSIGTYPE void)
ELSE(RETSIGTYPE_TEST)
  SET(RETSIGTYPE int)
ENDIF(RETSIGTYPE_TEST)

# The rest of the build

INCLUDE_DIRECTORIES(${LIBCURL_SOURCE_DIR})
INCLUDE_DIRECTORIES(${LIBCURL_BINARY_DIR})
ADD_DEFINITIONS(-DHAVE_CONFIG_H)
CONFIGURE_FILE(${LIBCURL_SOURCE_DIR}/config.h.in
               ${LIBCURL_BINARY_DIR}/config.h)

ADD_LIBRARY(Curl STATIC ${libCurl_SRCS})

TARGET_LINK_LIBRARIES(Curl ${CURL_LIBS})

OPTION(CURL_TESTING "Do libCurl testing" OFF)
IF(CURL_TESTING)
  SUBDIRS(Testing)
ENDIF(CURL_TESTING)

IF(NOT CMAKE_BUILD_WITH_CURL)
  ADD_EXECUTABLE(LIBCURL Testing/curltest.c)
  TARGET_LINK_LIBRARIES(LIBCURL Curl)
ENDIF(NOT CMAKE_BUILD_WITH_CURL)