[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[gnurl] branch master updated (7f49525e8 -> 70745a841)
|
From: |
gnunet |
|
Subject: |
[gnurl] branch master updated (7f49525e8 -> 70745a841) |
|
Date: |
Fri, 22 Nov 2019 22:36:45 +0100 |
This is an automated email from the git hooks/post-receive script.
ng0 pushed a change to branch master
in repository gnurl.
from 7f49525e8 portability fix.
new 1716c3566 start work on CMake, based on the experimental curl CMake.
new 70745a841 cmake, gnutls.
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
CMake/CMakeConfigurableFile.in | 1 +
CMake/CurlSymbolHiding.cmake | 61 ++
CMake/CurlTests.c | 617 ++++++++++++++++++
CMake/FindGCrypt.cmake | 72 +++
CMake/FindGSS.cmake | 289 +++++++++
CMake/FindIDN.cmake | 68 ++
CMake/FindIDN2.cmake | 69 ++
CMake/FindNettle.cmake | 23 +
CMake/Macros.cmake | 88 +++
CMake/OtherTests.cmake | 264 ++++++++
CMake/Platforms/WindowsCache.cmake | 123 ++++
CMake/Utilities.cmake | 13 +
CMake/cmake_uninstall.cmake.in | 26 +
CMake/gnurl-config.cmake.in | 15 +
CMakeLists.txt | 1226 ++++++++++++++++++++++++++++++++++++
docs/CMakeLists.txt | 3 +
docs/cmdline-opts/CMakeLists.txt | 12 +
docs/libcurl/CMakeLists.txt | 55 ++
docs/libcurl/opts/CMakeLists.txt | 12 +
lib/CMakeLists.txt | 121 ++++
src/CMakeLists.txt | 76 +++
src/Makefile.inc | 12 +-
tests/CMakeLists.txt | 4 +
tests/data/CMakeLists.txt | 7 +
tests/libtest/CMakeLists.txt | 140 ++++
tests/server/CMakeLists.txt | 59 ++
tests/unit/CMakeLists.txt | 56 ++
27 files changed, 3506 insertions(+), 6 deletions(-)
create mode 100644 CMake/CMakeConfigurableFile.in
create mode 100644 CMake/CurlSymbolHiding.cmake
create mode 100644 CMake/CurlTests.c
create mode 100644 CMake/FindGCrypt.cmake
create mode 100644 CMake/FindGSS.cmake
create mode 100644 CMake/FindIDN.cmake
create mode 100644 CMake/FindIDN2.cmake
create mode 100644 CMake/FindNettle.cmake
create mode 100644 CMake/Macros.cmake
create mode 100644 CMake/OtherTests.cmake
create mode 100644 CMake/Platforms/WindowsCache.cmake
create mode 100644 CMake/Utilities.cmake
create mode 100644 CMake/cmake_uninstall.cmake.in
create mode 100644 CMake/gnurl-config.cmake.in
create mode 100644 CMakeLists.txt
create mode 100644 docs/CMakeLists.txt
create mode 100644 docs/cmdline-opts/CMakeLists.txt
create mode 100644 docs/libcurl/CMakeLists.txt
create mode 100644 docs/libcurl/opts/CMakeLists.txt
create mode 100644 lib/CMakeLists.txt
create mode 100644 src/CMakeLists.txt
create mode 100644 tests/CMakeLists.txt
create mode 100644 tests/data/CMakeLists.txt
create mode 100644 tests/libtest/CMakeLists.txt
create mode 100644 tests/server/CMakeLists.txt
create mode 100644 tests/unit/CMakeLists.txt
diff --git a/CMake/CMakeConfigurableFile.in b/CMake/CMakeConfigurableFile.in
new file mode 100644
index 000000000..df2c382e9
--- /dev/null
+++ b/CMake/CMakeConfigurableFile.in
@@ -0,0 +1 @@
+@CMAKE_CONFIGURABLE_FILE_CONTENT@
diff --git a/CMake/CurlSymbolHiding.cmake b/CMake/CurlSymbolHiding.cmake
new file mode 100644
index 000000000..224755a31
--- /dev/null
+++ b/CMake/CurlSymbolHiding.cmake
@@ -0,0 +1,61 @@
+include(CheckCSourceCompiles)
+
+option(CURL_HIDDEN_SYMBOLS "Set to ON to hide libcurl internal symbols (=hide
all symbols that aren't officially external)." ON)
+mark_as_advanced(CURL_HIDDEN_SYMBOLS)
+
+if(CURL_HIDDEN_SYMBOLS)
+ set(SUPPORTS_SYMBOL_HIDING FALSE)
+
+ if(CMAKE_C_COMPILER_ID MATCHES "Clang")
+ set(SUPPORTS_SYMBOL_HIDING TRUE)
+ set(_SYMBOL_EXTERN "__attribute__ ((__visibility__ (\"default\")))")
+ set(_CFLAG_SYMBOLS_HIDE "-fvisibility=hidden")
+ elseif(CMAKE_COMPILER_IS_GNUCC)
+ if(NOT CMAKE_VERSION VERSION_LESS 2.8.10)
+ set(GCC_VERSION ${CMAKE_C_COMPILER_VERSION})
+ else()
+ execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
+ OUTPUT_VARIABLE GCC_VERSION)
+ endif()
+ if(NOT GCC_VERSION VERSION_LESS 3.4)
+ # note: this is considered buggy prior to 4.0 but the autotools don't
care, so let's ignore that fact
+ set(SUPPORTS_SYMBOL_HIDING TRUE)
+ set(_SYMBOL_EXTERN "__attribute__ ((__visibility__ (\"default\")))")
+ set(_CFLAG_SYMBOLS_HIDE "-fvisibility=hidden")
+ endif()
+ elseif(CMAKE_C_COMPILER_ID MATCHES "SunPro" AND NOT CMAKE_C_COMPILER_VERSION
VERSION_LESS 8.0)
+ set(SUPPORTS_SYMBOL_HIDING TRUE)
+ set(_SYMBOL_EXTERN "__global")
+ set(_CFLAG_SYMBOLS_HIDE "-xldscope=hidden")
+ elseif(CMAKE_C_COMPILER_ID MATCHES "Intel" AND NOT CMAKE_C_COMPILER_VERSION
VERSION_LESS 9.0)
+ # note: this should probably just check for version 9.1.045 but I'm not
100% sure
+ # so let's do it the same way autotools do.
+ set(SUPPORTS_SYMBOL_HIDING TRUE)
+ set(_SYMBOL_EXTERN "__attribute__ ((__visibility__ (\"default\")))")
+ set(_CFLAG_SYMBOLS_HIDE "-fvisibility=hidden")
+ check_c_source_compiles("#include <stdio.h>
+ int main (void) { printf(\"icc fvisibility bug test\"); return 0; }"
_no_bug)
+ if(NOT _no_bug)
+ set(SUPPORTS_SYMBOL_HIDING FALSE)
+ set(_SYMBOL_EXTERN "")
+ set(_CFLAG_SYMBOLS_HIDE "")
+ endif()
+ elseif(MSVC)
+ set(SUPPORTS_SYMBOL_HIDING TRUE)
+ endif()
+
+ set(HIDES_CURL_PRIVATE_SYMBOLS ${SUPPORTS_SYMBOL_HIDING})
+elseif(MSVC)
+ if(NOT CMAKE_VERSION VERSION_LESS 3.7)
+ set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE) #present since 3.4.3 but broken
+ set(HIDES_CURL_PRIVATE_SYMBOLS FALSE)
+ else()
+ message(WARNING "Hiding private symbols regardless CURL_HIDDEN_SYMBOLS
being disabled.")
+ set(HIDES_CURL_PRIVATE_SYMBOLS TRUE)
+ endif()
+else()
+ set(HIDES_CURL_PRIVATE_SYMBOLS FALSE)
+endif()
+
+set(CURL_CFLAG_SYMBOLS_HIDE ${_CFLAG_SYMBOLS_HIDE})
+set(CURL_EXTERN_SYMBOL ${_SYMBOL_EXTERN})
diff --git a/CMake/CurlTests.c b/CMake/CurlTests.c
new file mode 100644
index 000000000..3ef35f025
--- /dev/null
+++ b/CMake/CurlTests.c
@@ -0,0 +1,617 @@
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2019, Daniel Stenberg, <address@hidden>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+#ifdef TIME_WITH_SYS_TIME
+/* Time with sys/time test */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <time.h>
+
+int
+main ()
+{
+if ((struct tm *) 0)
+return 0;
+ ;
+ return 0;
+}
+
+#endif
+
+#ifdef HAVE_FCNTL_O_NONBLOCK
+
+/* headers for FCNTL_O_NONBLOCK test */
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+/* */
+#if defined(sun) || defined(__sun__) || \
+ defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+# if defined(__SVR4) || defined(__srv4__)
+# define PLATFORM_SOLARIS
+# else
+# define PLATFORM_SUNOS4
+# endif
+#endif
+#if (defined(_AIX) || defined(__xlC__)) && !defined(_AIX41)
+# define PLATFORM_AIX_V3
+#endif
+/* */
+#if defined(PLATFORM_SUNOS4) || defined(PLATFORM_AIX_V3) || defined(__BEOS__)
+#error "O_NONBLOCK does not work on this platform"
+#endif
+
+int
+main ()
+{
+ /* O_NONBLOCK source test */
+ int flags = 0;
+ if(0 != fcntl(0, F_SETFL, flags | O_NONBLOCK))
+ return 1;
+ return 0;
+}
+#endif
+
+/* tests for gethostbyaddr_r or gethostbyname_r */
+#if defined(HAVE_GETHOSTBYADDR_R_5_REENTRANT) || \
+ defined(HAVE_GETHOSTBYADDR_R_7_REENTRANT) || \
+ defined(HAVE_GETHOSTBYADDR_R_8_REENTRANT) || \
+ defined(HAVE_GETHOSTBYNAME_R_3_REENTRANT) || \
+ defined(HAVE_GETHOSTBYNAME_R_5_REENTRANT) || \
+ defined(HAVE_GETHOSTBYNAME_R_6_REENTRANT)
+# define _REENTRANT
+ /* no idea whether _REENTRANT is always set, just invent a new flag */
+# define TEST_GETHOSTBYFOO_REENTRANT
+#endif
+#if defined(HAVE_GETHOSTBYADDR_R_5) || \
+ defined(HAVE_GETHOSTBYADDR_R_7) || \
+ defined(HAVE_GETHOSTBYADDR_R_8) || \
+ defined(HAVE_GETHOSTBYNAME_R_3) || \
+ defined(HAVE_GETHOSTBYNAME_R_5) || \
+ defined(HAVE_GETHOSTBYNAME_R_6) || \
+ defined(TEST_GETHOSTBYFOO_REENTRANT)
+#include <sys/types.h>
+#include <netdb.h>
+int main(void)
+{
+ char *address = "example.com";
+ int length = 0;
+ int type = 0;
+ struct hostent h;
+ int rc = 0;
+#if defined(HAVE_GETHOSTBYADDR_R_5) || \
+ defined(HAVE_GETHOSTBYADDR_R_5_REENTRANT) || \
+ \
+ defined(HAVE_GETHOSTBYNAME_R_3) || \
+ defined(HAVE_GETHOSTBYNAME_R_3_REENTRANT)
+ struct hostent_data hdata;
+#elif defined(HAVE_GETHOSTBYADDR_R_7) || \
+ defined(HAVE_GETHOSTBYADDR_R_7_REENTRANT) || \
+ defined(HAVE_GETHOSTBYADDR_R_8) || \
+ defined(HAVE_GETHOSTBYADDR_R_8_REENTRANT) || \
+ \
+ defined(HAVE_GETHOSTBYNAME_R_5) || \
+ defined(HAVE_GETHOSTBYNAME_R_5_REENTRANT) || \
+ defined(HAVE_GETHOSTBYNAME_R_6) || \
+ defined(HAVE_GETHOSTBYNAME_R_6_REENTRANT)
+ char buffer[8192];
+ int h_errnop;
+ struct hostent *hp;
+#endif
+
+#ifndef gethostbyaddr_r
+ (void)gethostbyaddr_r;
+#endif
+
+#if defined(HAVE_GETHOSTBYADDR_R_5) || \
+ defined(HAVE_GETHOSTBYADDR_R_5_REENTRANT)
+ rc = gethostbyaddr_r(address, length, type, &h, &hdata);
+ (void)rc;
+#elif defined(HAVE_GETHOSTBYADDR_R_7) || \
+ defined(HAVE_GETHOSTBYADDR_R_7_REENTRANT)
+ hp = gethostbyaddr_r(address, length, type, &h, buffer, 8192, &h_errnop);
+ (void)hp;
+#elif defined(HAVE_GETHOSTBYADDR_R_8) || \
+ defined(HAVE_GETHOSTBYADDR_R_8_REENTRANT)
+ rc = gethostbyaddr_r(address, length, type, &h, buffer, 8192, &hp,
&h_errnop);
+ (void)rc;
+#endif
+
+#if defined(HAVE_GETHOSTBYNAME_R_3) || \
+ defined(HAVE_GETHOSTBYNAME_R_3_REENTRANT)
+ rc = gethostbyname_r(address, &h, &hdata);
+#elif defined(HAVE_GETHOSTBYNAME_R_5) || \
+ defined(HAVE_GETHOSTBYNAME_R_5_REENTRANT)
+ rc = gethostbyname_r(address, &h, buffer, 8192, &h_errnop);
+ (void)hp; /* not used for test */
+#elif defined(HAVE_GETHOSTBYNAME_R_6) || \
+ defined(HAVE_GETHOSTBYNAME_R_6_REENTRANT)
+ rc = gethostbyname_r(address, &h, buffer, 8192, &hp, &h_errnop);
+#endif
+
+ (void)length;
+ (void)type;
+ (void)rc;
+ return 0;
+}
+#endif
+
+#ifdef HAVE_SOCKLEN_T
+#ifdef _WIN32
+#include <ws2tcpip.h>
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#endif
+int
+main ()
+{
+if ((socklen_t *) 0)
+ return 0;
+if (sizeof (socklen_t))
+ return 0;
+ ;
+ return 0;
+}
+#endif
+#ifdef HAVE_IN_ADDR_T
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+int
+main ()
+{
+if ((in_addr_t *) 0)
+ return 0;
+if (sizeof (in_addr_t))
+ return 0;
+ ;
+ return 0;
+}
+#endif
+
+#ifdef HAVE_BOOL_T
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_STDBOOL_H
+#include <stdbool.h>
+#endif
+int
+main ()
+{
+if (sizeof (bool *) )
+ return 0;
+ ;
+ return 0;
+}
+#endif
+
+#ifdef STDC_HEADERS
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+int main() { return 0; }
+#endif
+#ifdef RETSIGTYPE_TEST
+#include <sys/types.h>
+#include <signal.h>
+#ifdef signal
+# undef signal
+#endif
+#ifdef __cplusplus
+extern "C" void (*signal (int, void (*)(int)))(int);
+#else
+void (*signal ()) ();
+#endif
+
+int
+main ()
+{
+ return 0;
+}
+#endif
+#ifdef HAVE_INET_NTOA_R_DECL
+#include <arpa/inet.h>
+
+typedef void (*func_type)();
+
+int main()
+{
+#ifndef inet_ntoa_r
+ func_type func;
+ func = (func_type)inet_ntoa_r;
+ (void)func;
+#endif
+ return 0;
+}
+#endif
+#ifdef HAVE_INET_NTOA_R_DECL_REENTRANT
+#define _REENTRANT
+#include <arpa/inet.h>
+
+typedef void (*func_type)();
+
+int main()
+{
+#ifndef inet_ntoa_r
+ func_type func;
+ func = (func_type)&inet_ntoa_r;
+ (void)func;
+#endif
+ return 0;
+}
+#endif
+#ifdef HAVE_GETADDRINFO
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+int main(void) {
+ struct addrinfo hints, *ai;
+ int error;
+
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+#ifndef getaddrinfo
+ (void)getaddrinfo;
+#endif
+ error = getaddrinfo("127.0.0.1", "8080", &hints, &ai);
+ if (error) {
+ return 1;
+ }
+ return 0;
+}
+#endif
+#ifdef HAVE_FILE_OFFSET_BITS
+#ifdef _FILE_OFFSET_BITS
+#undef _FILE_OFFSET_BITS
+#endif
+#define _FILE_OFFSET_BITS 64
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+ We can't simply define LARGE_OFF_T to be 9223372036854775807,
+ since some C++ compilers masquerading as C compilers
+ incorrectly reject 9223372036854775807. */
+#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
+ int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+ && LARGE_OFF_T % 2147483647 == 1)
+ ? 1 : -1];
+int main () { ; return 0; }
+#endif
+#ifdef HAVE_IOCTLSOCKET
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+# ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+# endif
+# include <windows.h>
+# ifdef HAVE_WINSOCK2_H
+# include <winsock2.h>
+# else
+# ifdef HAVE_WINSOCK_H
+# include <winsock.h>
+# endif
+# endif
+#endif
+
+int
+main ()
+{
+
+/* ioctlsocket source code */
+ int socket;
+ unsigned long flags = ioctlsocket(socket, FIONBIO, &flags);
+
+ ;
+ return 0;
+}
+
+#endif
+#ifdef HAVE_IOCTLSOCKET_CAMEL
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+# ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+# endif
+# include <windows.h>
+# ifdef HAVE_WINSOCK2_H
+# include <winsock2.h>
+# else
+# ifdef HAVE_WINSOCK_H
+# include <winsock.h>
+# endif
+# endif
+#endif
+
+int
+main ()
+{
+
+/* IoctlSocket source code */
+ if(0 != IoctlSocket(0, 0, 0))
+ return 1;
+ ;
+ return 0;
+}
+#endif
+#ifdef HAVE_IOCTLSOCKET_CAMEL_FIONBIO
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+# ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+# endif
+# include <windows.h>
+# ifdef HAVE_WINSOCK2_H
+# include <winsock2.h>
+# else
+# ifdef HAVE_WINSOCK_H
+# include <winsock.h>
+# endif
+# endif
+#endif
+
+int
+main ()
+{
+
+/* IoctlSocket source code */
+ long flags = 0;
+ if(0 != ioctlsocket(0, FIONBIO, &flags))
+ return 1;
+ ;
+ return 0;
+}
+#endif
+#ifdef HAVE_IOCTLSOCKET_FIONBIO
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+# ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+# endif
+# include <windows.h>
+# ifdef HAVE_WINSOCK2_H
+# include <winsock2.h>
+# else
+# ifdef HAVE_WINSOCK_H
+# include <winsock.h>
+# endif
+# endif
+#endif
+
+int
+main ()
+{
+
+ int flags = 0;
+ if(0 != ioctlsocket(0, FIONBIO, &flags))
+ return 1;
+
+ ;
+ return 0;
+}
+#endif
+#ifdef HAVE_IOCTL_FIONBIO
+/* headers for FIONBIO test */
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+# include <sys/ioctl.h>
+#endif
+#ifdef HAVE_STROPTS_H
+# include <stropts.h>
+#endif
+
+int
+main ()
+{
+
+ int flags = 0;
+ if(0 != ioctl(0, FIONBIO, &flags))
+ return 1;
+
+ ;
+ return 0;
+}
+#endif
+#ifdef HAVE_IOCTL_SIOCGIFADDR
+/* headers for FIONBIO test */
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+# include <sys/ioctl.h>
+#endif
+#ifdef HAVE_STROPTS_H
+# include <stropts.h>
+#endif
+#include <net/if.h>
+
+int
+main ()
+{
+ struct ifreq ifr;
+ if(0 != ioctl(0, SIOCGIFADDR, &ifr))
+ return 1;
+
+ ;
+ return 0;
+}
+#endif
+#ifdef HAVE_SETSOCKOPT_SO_NONBLOCK
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+# ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+# endif
+# include <windows.h>
+# ifdef HAVE_WINSOCK2_H
+# include <winsock2.h>
+# else
+# ifdef HAVE_WINSOCK_H
+# include <winsock.h>
+# endif
+# endif
+#endif
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+/* includes end */
+
+int
+main ()
+{
+ if(0 != setsockopt(0, SOL_SOCKET, SO_NONBLOCK, 0, 0))
+ return 1;
+ ;
+ return 0;
+}
+#endif
+#ifdef HAVE_GLIBC_STRERROR_R
+#include <string.h>
+#include <errno.h>
+
+void check(char c) {}
+
+int
+main () {
+ char buffer[1024];
+ /* This will not compile if strerror_r does not return a char* */
+ check(strerror_r(EACCES, buffer, sizeof(buffer))[0]);
+ return 0;
+}
+#endif
+#ifdef HAVE_POSIX_STRERROR_R
+#include <string.h>
+#include <errno.h>
+
+/* float, because a pointer can't be implicitly cast to float */
+void check(float f) {}
+
+int
+main () {
+ char buffer[1024];
+ /* This will not compile if strerror_r does not return an int */
+ check(strerror_r(EACCES, buffer, sizeof(buffer)));
+ return 0;
+}
+#endif
+#ifdef HAVE_FSETXATTR_6
+#include <sys/xattr.h> /* header from libc, not from libattr */
+int
+main() {
+ fsetxattr(0, 0, 0, 0, 0, 0);
+ return 0;
+}
+#endif
+#ifdef HAVE_FSETXATTR_5
+#include <sys/xattr.h> /* header from libc, not from libattr */
+int
+main() {
+ fsetxattr(0, 0, 0, 0, 0);
+ return 0;
+}
+#endif
+#ifdef HAVE_CLOCK_GETTIME_MONOTONIC
+#include <time.h>
+int
+main() {
+ struct timespec ts = {0, 0};
+ clock_gettime(CLOCK_MONOTONIC, &ts);
+ return 0;
+}
+#endif
+#ifdef HAVE_BUILTIN_AVAILABLE
+int
+main() {
+ if(__builtin_available(macOS 10.12, *)) {}
+ return 0;
+}
+#endif
+#ifdef HAVE_VARIADIC_MACROS_C99
+#define c99_vmacro3(first, ...) fun3(first, __VA_ARGS__)
+#define c99_vmacro2(first, ...) fun2(first, __VA_ARGS__)
+
+int fun3(int arg1, int arg2, int arg3);
+int fun2(int arg1, int arg2);
+
+int fun3(int arg1, int arg2, int arg3) {
+ return arg1 + arg2 + arg3;
+}
+int fun2(int arg1, int arg2) {
+ return arg1 + arg2;
+}
+
+int
+main() {
+ int res3 = c99_vmacro3(1, 2, 3);
+ int res2 = c99_vmacro2(1, 2);
+ (void)res3;
+ (void)res2;
+ return 0;
+}
+#endif
+#ifdef HAVE_VARIADIC_MACROS_GCC
+#define gcc_vmacro3(first, args...) fun3(first, args)
+#define gcc_vmacro2(first, args...) fun2(first, args)
+
+int fun3(int arg1, int arg2, int arg3);
+int fun2(int arg1, int arg2);
+
+int fun3(int arg1, int arg2, int arg3) {
+ return arg1 + arg2 + arg3;
+}
+int fun2(int arg1, int arg2) {
+ return arg1 + arg2;
+}
+
+int
+main() {
+ int res3 = gcc_vmacro3(1, 2, 3);
+ int res2 = gcc_vmacro2(1, 2);
+ (void)res3;
+ (void)res2;
+ return 0;
+}
+#endif
diff --git a/CMake/FindGCrypt.cmake b/CMake/FindGCrypt.cmake
new file mode 100644
index 000000000..8fd6c9417
--- /dev/null
+++ b/CMake/FindGCrypt.cmake
@@ -0,0 +1,72 @@
+# - Try to find GCrypt
+# Once done this will define
+#
+# GCRYPT_FOUND - system has GCrypt
+# GCRYPT_INCLUDE_DIRS - the GCrypt include directory
+# GCRYPT_LIBRARIES - Link these to use GCrypt
+# GCRYPT_DEFINITIONS - Compiler switches required for using GCrypt
+#
+#=============================================================================
+# Copyright (c) 2009-2011 Andreas Schneider <address@hidden>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+#
+
+if (GCRYPT_LIBRARIES AND GCRYPT_INCLUDE_DIRS)
+ # in cache already
+ # set(GCRYPT_FOUND TRUE)
+else (GCRYPT_LIBRARIES AND GCRYPT_INCLUDE_DIRS)
+
+ set(_GCRYPT_ROOT_PATHS
+ "$ENV{PROGRAMFILES}/libgcrypt"
+ )
+
+ find_path(GCRYPT_ROOT_DIR
+ NAMES
+ include/gcrypt.h
+ PATHS
+ ${_GCRYPT_ROOT_PATHS}
+ )
+ #mark_as_advanced(ZLIB_ROOT_DIR)
+ mark_as_advanced(GCRYPT_ROOT_DIR)
+
+ find_path(GCRYPT_INCLUDE_DIR
+ NAMES
+ gcrypt.h
+ PATHS
+ /usr/local/include
+ /opt/local/include
+ /sw/include
+ /usr/lib/sfw/include
+ ${GCRYPT_ROOT_DIR}/include
+ )
+ set(GCRYPT_INCLUDE_DIRS ${GCRYPT_INCLUDE_DIR})
+
+ find_library(GCRYPT_LIBRARY
+ NAMES
+ gcrypt
+ gcrypt11
+ libgcrypt-11
+ PATHS
+ /opt/local/lib
+ /sw/lib
+ /usr/sfw/lib/64
+ /usr/sfw/lib
+ ${GCRYPT_ROOT_DIR}/lib
+ )
+ set(GCRYPT_LIBRARIES ${GCRYPT_LIBRARY})
+
+ include(FindPackageHandleStandardArgs)
+ find_package_handle_standard_args(GCrypt DEFAULT_MSG GCRYPT_LIBRARIES
GCRYPT_INCLUDE_DIRS)
+
+ # show the GCRYPT_INCLUDE_DIRS and GCRYPT_LIBRARIES variables only in the
advanced view
+ mark_as_advanced(GCRYPT_INCLUDE_DIRS GCRYPT_LIBRARIES)
+
+endif (GCRYPT_LIBRARIES AND GCRYPT_INCLUDE_DIRS)
+
diff --git a/CMake/FindGSS.cmake b/CMake/FindGSS.cmake
new file mode 100644
index 000000000..a2f150cda
--- /dev/null
+++ b/CMake/FindGSS.cmake
@@ -0,0 +1,289 @@
+# - Try to find the GSS Kerberos library
+# Once done this will define
+#
+# GSS_ROOT_DIR - Set this variable to the root installation of GSS
+#
+# Read-Only variables:
+# GSS_FOUND - system has the Heimdal library
+# GSS_FLAVOUR - "MIT" or "Heimdal" if anything found.
+# GSS_INCLUDE_DIR - the Heimdal include directory
+# GSS_LIBRARIES - The libraries needed to use GSS
+# GSS_LINK_DIRECTORIES - Directories to add to linker search path
+# GSS_LINKER_FLAGS - Additional linker flags
+# GSS_COMPILER_FLAGS - Additional compiler flags
+# GSS_VERSION - This is set to version advertised by pkg-config or read from
manifest.
+# In case the library is found but no version info available
it'll be set to "unknown"
+
+set(_MIT_MODNAME mit-krb5-gssapi)
+set(_HEIMDAL_MODNAME heimdal-gssapi)
+
+include(CheckIncludeFile)
+include(CheckIncludeFiles)
+include(CheckTypeSize)
+
+set(_GSS_ROOT_HINTS
+ "${GSS_ROOT_DIR}"
+ "$ENV{GSS_ROOT_DIR}"
+)
+
+# try to find library using system pkg-config if user didn't specify root dir
+if(NOT GSS_ROOT_DIR AND NOT "$ENV{GSS_ROOT_DIR}")
+ if(UNIX)
+ find_package(PkgConfig QUIET)
+ pkg_search_module(_GSS_PKG ${_MIT_MODNAME} ${_HEIMDAL_MODNAME})
+ list(APPEND _GSS_ROOT_HINTS "${_GSS_PKG_PREFIX}")
+ elseif(WIN32)
+ list(APPEND _GSS_ROOT_HINTS
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\MIT\\Kerberos;InstallDir]")
+ endif()
+endif()
+
+if(NOT _GSS_FOUND) #not found by pkg-config. Let's take more traditional
approach.
+ find_file(_GSS_CONFIGURE_SCRIPT
+ NAMES
+ "krb5-config"
+ HINTS
+ ${_GSS_ROOT_HINTS}
+ PATH_SUFFIXES
+ bin
+ NO_CMAKE_PATH
+ NO_CMAKE_ENVIRONMENT_PATH
+ )
+
+ # if not found in user-supplied directories, maybe system knows better
+ find_file(_GSS_CONFIGURE_SCRIPT
+ NAMES
+ "krb5-config"
+ PATH_SUFFIXES
+ bin
+ )
+
+ if(_GSS_CONFIGURE_SCRIPT)
+ execute_process(
+ COMMAND ${_GSS_CONFIGURE_SCRIPT} "--cflags" "gssapi"
+ OUTPUT_VARIABLE _GSS_CFLAGS
+ RESULT_VARIABLE _GSS_CONFIGURE_FAILED
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ message(STATUS "CFLAGS: ${_GSS_CFLAGS}")
+ if(NOT _GSS_CONFIGURE_FAILED) # 0 means success
+ # should also work in an odd case when multiple directories are given
+ string(STRIP "${_GSS_CFLAGS}" _GSS_CFLAGS)
+ string(REGEX REPLACE " +-I" ";" _GSS_CFLAGS "${_GSS_CFLAGS}")
+ string(REGEX REPLACE " +-([^I][^ \\t;]*)" ";-\\1" _GSS_CFLAGS
"${_GSS_CFLAGS}")
+
+ foreach(_flag ${_GSS_CFLAGS})
+ if(_flag MATCHES "^-I.*")
+ string(REGEX REPLACE "^-I" "" _val "${_flag}")
+ list(APPEND _GSS_INCLUDE_DIR "${_val}")
+ else()
+ list(APPEND _GSS_COMPILER_FLAGS "${_flag}")
+ endif()
+ endforeach()
+ endif()
+
+ execute_process(
+ COMMAND ${_GSS_CONFIGURE_SCRIPT} "--libs" "gssapi"
+ OUTPUT_VARIABLE _GSS_LIB_FLAGS
+ RESULT_VARIABLE _GSS_CONFIGURE_FAILED
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ message(STATUS "LDFLAGS: ${_GSS_LIB_FLAGS}")
+
+ if(NOT _GSS_CONFIGURE_FAILED) # 0 means success
+ # this script gives us libraries and link directories. Blah. We have to
deal with it.
+ string(STRIP "${_GSS_LIB_FLAGS}" _GSS_LIB_FLAGS)
+ string(REGEX REPLACE " +-(L|l)" ";-\\1" _GSS_LIB_FLAGS
"${_GSS_LIB_FLAGS}")
+ string(REGEX REPLACE " +-([^Ll][^ \\t;]*)" ";-\\1" _GSS_LIB_FLAGS
"${_GSS_LIB_FLAGS}")
+
+ foreach(_flag ${_GSS_LIB_FLAGS})
+ if(_flag MATCHES "^-l.*")
+ string(REGEX REPLACE "^-l" "" _val "${_flag}")
+ list(APPEND _GSS_LIBRARIES "${_val}")
+ elseif(_flag MATCHES "^-L.*")
+ string(REGEX REPLACE "^-L" "" _val "${_flag}")
+ list(APPEND _GSS_LINK_DIRECTORIES "${_val}")
+ else()
+ list(APPEND _GSS_LINKER_FLAGS "${_flag}")
+ endif()
+ endforeach()
+ endif()
+
+ execute_process(
+ COMMAND ${_GSS_CONFIGURE_SCRIPT} "--version"
+ OUTPUT_VARIABLE _GSS_VERSION
+ RESULT_VARIABLE _GSS_CONFIGURE_FAILED
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+
+ # older versions may not have the "--version" parameter. In this case we
just don't care.
+ if(_GSS_CONFIGURE_FAILED)
+ set(_GSS_VERSION 0)
+ endif()
+
+ execute_process(
+ COMMAND ${_GSS_CONFIGURE_SCRIPT} "--vendor"
+ OUTPUT_VARIABLE _GSS_VENDOR
+ RESULT_VARIABLE _GSS_CONFIGURE_FAILED
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+
+ # older versions may not have the "--vendor" parameter. In this case we
just don't care.
+ if(_GSS_CONFIGURE_FAILED)
+ set(GSS_FLAVOUR "Heimdal") # most probably, shouldn't really matter
+ else()
+ if(_GSS_VENDOR MATCHES ".*H|heimdal.*")
+ set(GSS_FLAVOUR "Heimdal")
+ else()
+ set(GSS_FLAVOUR "MIT")
+ endif()
+ endif()
+
+ else() # either there is no config script or we are on a platform that
doesn't provide one (Windows?)
+
+ find_path(_GSS_INCLUDE_DIR
+ NAMES
+ "gssapi/gssapi.h"
+ HINTS
+ ${_GSS_ROOT_HINTS}
+ PATH_SUFFIXES
+ include
+ inc
+ )
+
+ if(_GSS_INCLUDE_DIR) #jay, we've found something
+ set(CMAKE_REQUIRED_INCLUDES "${_GSS_INCLUDE_DIR}")
+ check_include_files( "gssapi/gssapi_generic.h;gssapi/gssapi_krb5.h"
_GSS_HAVE_MIT_HEADERS)
+
+ if(_GSS_HAVE_MIT_HEADERS)
+ set(GSS_FLAVOUR "MIT")
+ else()
+ # prevent compiling the header - just check if we can include it
+ set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}
-D__ROKEN_H__")
+ check_include_file( "roken.h" _GSS_HAVE_ROKEN_H)
+
+ check_include_file( "heimdal/roken.h" _GSS_HAVE_HEIMDAL_ROKEN_H)
+ if(_GSS_HAVE_ROKEN_H OR _GSS_HAVE_HEIMDAL_ROKEN_H)
+ set(GSS_FLAVOUR "Heimdal")
+ endif()
+ set(CMAKE_REQUIRED_DEFINITIONS "")
+ endif()
+ else()
+ # I'm not convinced if this is the right way but this is what autotools
do at the moment
+ find_path(_GSS_INCLUDE_DIR
+ NAMES
+ "gssapi.h"
+ HINTS
+ ${_GSS_ROOT_HINTS}
+ PATH_SUFFIXES
+ include
+ inc
+ )
+
+ if(_GSS_INCLUDE_DIR)
+ set(GSS_FLAVOUR "Heimdal")
+ endif()
+ endif()
+
+ # if we have headers, check if we can link libraries
+ if(GSS_FLAVOUR)
+ set(_GSS_LIBDIR_SUFFIXES "")
+ set(_GSS_LIBDIR_HINTS ${_GSS_ROOT_HINTS})
+ get_filename_component(_GSS_CALCULATED_POTENTIAL_ROOT
"${_GSS_INCLUDE_DIR}" PATH)
+ list(APPEND _GSS_LIBDIR_HINTS ${_GSS_CALCULATED_POTENTIAL_ROOT})
+
+ if(WIN32)
+ if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+ list(APPEND _GSS_LIBDIR_SUFFIXES "lib/AMD64")
+ if(GSS_FLAVOUR STREQUAL "MIT")
+ set(_GSS_LIBNAME "gssapi64")
+ else()
+ set(_GSS_LIBNAME "libgssapi")
+ endif()
+ else()
+ list(APPEND _GSS_LIBDIR_SUFFIXES "lib/i386")
+ if(GSS_FLAVOUR STREQUAL "MIT")
+ set(_GSS_LIBNAME "gssapi32")
+ else()
+ set(_GSS_LIBNAME "libgssapi")
+ endif()
+ endif()
+ else()
+ list(APPEND _GSS_LIBDIR_SUFFIXES "lib;lib64") # those suffixes are not
checked for HINTS
+ if(GSS_FLAVOUR STREQUAL "MIT")
+ set(_GSS_LIBNAME "gssapi_krb5")
+ else()
+ set(_GSS_LIBNAME "gssapi")
+ endif()
+ endif()
+
+ find_library(_GSS_LIBRARIES
+ NAMES
+ ${_GSS_LIBNAME}
+ HINTS
+ ${_GSS_LIBDIR_HINTS}
+ PATH_SUFFIXES
+ ${_GSS_LIBDIR_SUFFIXES}
+ )
+
+ endif()
+ endif()
+else()
+ if(_GSS_PKG_${_MIT_MODNAME}_VERSION)
+ set(GSS_FLAVOUR "MIT")
+ set(_GSS_VERSION _GSS_PKG_${_MIT_MODNAME}_VERSION)
+ else()
+ set(GSS_FLAVOUR "Heimdal")
+ set(_GSS_VERSION _GSS_PKG_${_MIT_HEIMDAL}_VERSION)
+ endif()
+endif()
+
+set(GSS_INCLUDE_DIR ${_GSS_INCLUDE_DIR})
+set(GSS_LIBRARIES ${_GSS_LIBRARIES})
+set(GSS_LINK_DIRECTORIES ${_GSS_LINK_DIRECTORIES})
+set(GSS_LINKER_FLAGS ${_GSS_LINKER_FLAGS})
+set(GSS_COMPILER_FLAGS ${_GSS_COMPILER_FLAGS})
+set(GSS_VERSION ${_GSS_VERSION})
+
+if(GSS_FLAVOUR)
+ if(NOT GSS_VERSION AND GSS_FLAVOUR STREQUAL "Heimdal")
+ if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+ set(HEIMDAL_MANIFEST_FILE "Heimdal.Application.amd64.manifest")
+ else()
+ set(HEIMDAL_MANIFEST_FILE "Heimdal.Application.x86.manifest")
+ endif()
+
+ if(EXISTS "${GSS_INCLUDE_DIR}/${HEIMDAL_MANIFEST_FILE}")
+ file(STRINGS "${GSS_INCLUDE_DIR}/${HEIMDAL_MANIFEST_FILE}"
heimdal_version_str
+ REGEX "^.*version=\"[0-9]\\.[^\"]+\".*$")
+
+ string(REGEX MATCH "[0-9]\\.[^\"]+"
+ GSS_VERSION "${heimdal_version_str}")
+ endif()
+
+ if(NOT GSS_VERSION)
+ set(GSS_VERSION "Heimdal Unknown")
+ endif()
+ elseif(NOT GSS_VERSION AND GSS_FLAVOUR STREQUAL "MIT")
+ get_filename_component(_MIT_VERSION
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\MIT\\Kerberos\\SDK\\CurrentVersion;VersionString]"
NAME CACHE)
+ if(WIN32 AND _MIT_VERSION)
+ set(GSS_VERSION "${_MIT_VERSION}")
+ else()
+ set(GSS_VERSION "MIT Unknown")
+ endif()
+ endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+
+set(_GSS_REQUIRED_VARS GSS_LIBRARIES GSS_FLAVOUR)
+
+find_package_handle_standard_args(GSS
+ REQUIRED_VARS
+ ${_GSS_REQUIRED_VARS}
+ VERSION_VAR
+ GSS_VERSION
+ FAIL_MESSAGE
+ "Could NOT find GSS, try to set the path to GSS root folder in the
system variable GSS_ROOT_DIR"
+)
+
+mark_as_advanced(GSS_INCLUDE_DIR GSS_LIBRARIES)
diff --git a/CMake/FindIDN.cmake b/CMake/FindIDN.cmake
new file mode 100644
index 000000000..76921f776
--- /dev/null
+++ b/CMake/FindIDN.cmake
@@ -0,0 +1,68 @@
+# - Try to find idn
+# Once done this will define
+#
+# IDN_FOUND - system has idn
+# IDN_INCLUDE_DIRS - the idn include directory
+# IDN_LIBRARIES - Link these to use idn
+# IDN_DEFINITIONS - Compiler switches required for using idn
+#
+#=============================================================================
+# Copyright (c) 2019 ng0 <address@hidden>
+#
+# Distributed under the OSI-approved 0BSD License.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+#
+
+if (IDN_LIBRARIES AND IDN_INCLUDE_DIRS)
+ # in cache already
+ # set(IDN_FOUND TRUE)
+else (IDN_LIBRARIES AND IDN_INCLUDE_DIRS)
+
+ set(_IDN_ROOT_PATHS
+ "$ENV{PROGRAMFILES}/libidn"
+ )
+
+ find_path(IDN_ROOT_DIR
+ NAMES
+ include/idna.h
+ PATHS
+ ${_IDN_ROOT_PATHS}
+ )
+ mark_as_advanced(IDN_ROOT_DIR)
+
+ find_path(IDN_INCLUDE_DIR
+ NAMES
+ idna.h
+ PATHS
+ /usr/local/include
+ /opt/local/include
+ /sw/include
+ /usr/lib/sfw/include
+ ${IDN_ROOT_DIR}/include
+ )
+ set(IDN_INCLUDE_DIRS ${IDN_INCLUDE_DIR})
+
+ find_library(IDN_LIBRARY
+ NAMES
+ libidn
+ PATHS
+ /opt/local/lib
+ /sw/lib
+ /usr/sfw/lib/64
+ /usr/sfw/lib
+ ${IDN_ROOT_DIR}/lib
+ )
+ set(IDN_LIBRARIES ${IDN_LIBRARY})
+
+ include(FindPackageHandleStandardArgs)
+ find_package_handle_standard_args(IDN DEFAULT_MSG IDN_LIBRARIES
IDN_INCLUDE_DIRS)
+
+ # show the IDN_INCLUDE_DIRS and IDN_LIBRARIES variables only in the
advanced view
+ mark_as_advanced(IDN_INCLUDE_DIRS IDN_LIBRARIES)
+
+endif (IDN_LIBRARIES AND IDN_INCLUDE_DIRS)
+
diff --git a/CMake/FindIDN2.cmake b/CMake/FindIDN2.cmake
new file mode 100644
index 000000000..c7a85149d
--- /dev/null
+++ b/CMake/FindIDN2.cmake
@@ -0,0 +1,69 @@
+# - Try to find idn2
+# Once done this will define
+#
+# IDN2_FOUND - system has idn2
+# IDN2_INCLUDE_DIRS - the idn2 include directory
+# IDN2_LIBRARIES - Link these to use idn2
+# IDN2_DEFINITIONS - Compiler switches required for using idn2
+#
+#=============================================================================
+# Copyright (c) 2019 ng0 <address@hidden>
+#
+# Distributed under the OSI-approved 0BSD License.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+#
+
+if (IDN2_LIBRARIES AND IDN2_INCLUDE_DIRS)
+ # in cache already
+ # set(IDN2_FOUND TRUE)
+else (IDN2_LIBRARIES AND IDN2_INCLUDE_DIRS)
+
+ set(_IDN2_ROOT_PATHS
+ "$ENV{PROGRAMFILES}/libidn2"
+ )
+
+ find_path(IDN2_ROOT_DIR
+ NAMES
+ include/idn2.h
+ PATHS
+ ${_IDN2_ROOT_PATHS}
+ )
+ mark_as_advanced(IDN2_ROOT_DIR)
+
+ find_path(IDN2_INCLUDE_DIR
+ NAMES
+ idn2.h
+ idn2/idn2.h
+ PATHS
+ /usr/local/include
+ /opt/local/include
+ /sw/include
+ /usr/lib/sfw/include
+ ${IDN2_ROOT_DIR}/include
+ )
+ set(IDN2_INCLUDE_DIRS ${IDN2_INCLUDE_DIR})
+
+ find_library(IDN2_LIBRARY
+ NAMES
+ libidn2
+ PATHS
+ /opt/local/lib
+ /sw/lib
+ /usr/sfw/lib/64
+ /usr/sfw/lib
+ ${IDN2_ROOT_DIR}/lib
+ )
+ set(IDN2_LIBRARIES ${IDN2_LIBRARY})
+
+ include(FindPackageHandleStandardArgs)
+ find_package_handle_standard_args(IDN2 DEFAULT_MSG IDN2_LIBRARIES
IDN2_INCLUDE_DIRS)
+
+ # show the IDN2_INCLUDE_DIRS and IDN2_LIBRARIES variables only in the
advanced view
+ mark_as_advanced(IDN2_INCLUDE_DIRS IDN2_LIBRARIES)
+
+endif (IDN2_LIBRARIES AND IDN2_INCLUDE_DIRS)
+
diff --git a/CMake/FindNettle.cmake b/CMake/FindNettle.cmake
new file mode 100644
index 000000000..54ec9f5d3
--- /dev/null
+++ b/CMake/FindNettle.cmake
@@ -0,0 +1,23 @@
+# - Find Nettle
+# Find the Nettle include directory and library
+#
+# NETTLE_INCLUDE_DIR - where to find <nettle/sha.h>, etc.
+# NETTLE_LIBRARIES - List of libraries when using libnettle.
+# NETTLE_FOUND - True if libnettle found.
+
+IF (NETTLE_INCLUDE_DIR)
+ # Already in cache, be silent
+ SET(NETTLE_FIND_QUIETLY TRUE)
+ENDIF (NETTLE_INCLUDE_DIR)
+
+FIND_PATH(NETTLE_INCLUDE_DIR nettle/md5.h nettle/ripemd160.h nettle/sha.h)
+FIND_LIBRARY(NETTLE_LIBRARY NAMES nettle libnettle)
+
+# handle the QUIETLY and REQUIRED arguments and set NETTLE_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(NETTLE DEFAULT_MSG NETTLE_LIBRARY
NETTLE_INCLUDE_DIR)
+
+IF(NETTLE_FOUND)
+ SET(NETTLE_LIBRARIES ${NETTLE_LIBRARY})
+ENDIF(NETTLE_FOUND)
diff --git a/CMake/Macros.cmake b/CMake/Macros.cmake
new file mode 100644
index 000000000..f5a34dbb3
--- /dev/null
+++ b/CMake/Macros.cmake
@@ -0,0 +1,88 @@
+#File defines convenience macros for available feature testing
+
+# This macro checks if the symbol exists in the library and if it
+# does, it prepends library to the list. It is intended to be called
+# multiple times with a sequence of possibly dependent libraries in
+# order of least-to-most-dependent. Some libraries depend on others
+# to link correctly.
+macro(check_library_exists_concat LIBRARY SYMBOL VARIABLE)
+ check_library_exists("${LIBRARY};${GNURL_LIBS}" ${SYMBOL}
"${CMAKE_LIBRARY_PATH}"
+ ${VARIABLE})
+ if(${VARIABLE})
+ set(GNURL_LIBS ${LIBRARY} ${GNURL_LIBS})
+ endif()
+endmacro()
+
+# Check if header file exists and add it to the list.
+# This macro is intended to be called multiple times with a sequence of
+# possibly dependent header files. Some headers depend on others to be
+# compiled correctly.
+macro(check_include_file_concat FILE VARIABLE)
+ check_include_files("${GNURL_INCLUDES};${FILE}" ${VARIABLE})
+ if(${VARIABLE})
+ set(GNURL_INCLUDES ${GNURL_INCLUDES} ${FILE})
+ set(GNURL_TEST_DEFINES "${GNURL_TEST_DEFINES} -D${VARIABLE}")
+ endif()
+endmacro()
+
+# For other curl specific tests, use this macro.
+macro(curl_internal_test GNURL_TEST)
+ if(NOT DEFINED "${GNURL_TEST}")
+ set(MACRO_CHECK_FUNCTION_DEFINITIONS
+ "-D${GNURL_TEST} ${GNURL_TEST_DEFINES} ${CMAKE_REQUIRED_FLAGS}")
+ if(CMAKE_REQUIRED_LIBRARIES)
+ set(GNURL_TEST_ADD_LIBRARIES
+ "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
+ endif()
+
+ message(STATUS "Performing Curl Test ${GNURL_TEST}")
+ try_compile(${GNURL_TEST}
+ ${CMAKE_BINARY_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/CMake/CurlTests.c
+ CMAKE_FLAGS
-DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
+ "${GNURL_TEST_ADD_LIBRARIES}"
+ OUTPUT_VARIABLE OUTPUT)
+ if(${GNURL_TEST})
+ set(${GNURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
+ message(STATUS "Performing Curl Test ${GNURL_TEST} - Success")
+ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+ "Performing Curl Test ${GNURL_TEST} passed with the following
output:\n"
+ "${OUTPUT}\n")
+ else()
+ message(STATUS "Performing Curl Test ${GNURL_TEST} - Failed")
+ set(${GNURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
+ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+ "Performing Curl Test ${GNURL_TEST} failed with the following
output:\n"
+ "${OUTPUT}\n")
+ endif()
+ endif()
+endmacro()
+
+macro(curl_nroff_check)
+ find_program(NROFF NAMES gnroff nroff)
+ if(NROFF)
+ # Need a way to write to stdin, this will do
+ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/nroff-input.txt" "test")
+ # Tests for a valid nroff option to generate a manpage
+ foreach(_MANOPT "-man" "-mandoc")
+ execute_process(COMMAND "${NROFF}" ${_MANOPT}
+ OUTPUT_VARIABLE NROFF_MANOPT_OUTPUT
+ INPUT_FILE "${CMAKE_CURRENT_BINARY_DIR}/nroff-input.txt"
+ ERROR_QUIET)
+ # Save the option if it was valid
+ if(NROFF_MANOPT_OUTPUT)
+ message("Found *nroff option: -- ${_MANOPT}")
+ set(NROFF_MANOPT ${_MANOPT})
+ set(NROFF_USEFUL ON)
+ break()
+ endif()
+ endforeach()
+ # No need for the temporary file
+ file(REMOVE "${CMAKE_CURRENT_BINARY_DIR}/nroff-input.txt")
+ if(NOT NROFF_USEFUL)
+ message(WARNING "Found no *nroff option to get plaintext from man pages")
+ endif()
+ else()
+ message(WARNING "Found no *nroff program")
+ endif()
+endmacro()
diff --git a/CMake/OtherTests.cmake b/CMake/OtherTests.cmake
new file mode 100644
index 000000000..c1c9aa32a
--- /dev/null
+++ b/CMake/OtherTests.cmake
@@ -0,0 +1,264 @@
+include(CheckCSourceCompiles)
+# The begin of the sources (macros and includes)
+set(_source_epilogue "#undef inline")
+
+macro(add_header_include check header)
+ if(${check})
+ set(_source_epilogue "${_source_epilogue}\n#include <${header}>")
+ endif()
+endmacro()
+
+set(signature_call_conv)
+if(HAVE_WINDOWS_H)
+ add_header_include(HAVE_WINSOCK2_H "winsock2.h")
+ add_header_include(HAVE_WINDOWS_H "windows.h")
+ add_header_include(HAVE_WINSOCK_H "winsock.h")
+ set(_source_epilogue
+ "${_source_epilogue}\n#ifndef WIN32_LEAN_AND_MEAN\n#define
WIN32_LEAN_AND_MEAN\n#endif")
+ set(signature_call_conv "PASCAL")
+ if(HAVE_LIBWS2_32)
+ set(CMAKE_REQUIRED_LIBRARIES ws2_32)
+ endif()
+else()
+ add_header_include(HAVE_SYS_TYPES_H "sys/types.h")
+ add_header_include(HAVE_SYS_SOCKET_H "sys/socket.h")
+endif()
+
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+check_c_source_compiles("${_source_epilogue}
+int main(void) {
+ recv(0, 0, 0, 0);
+ return 0;
+}" curl_cv_recv)
+if(curl_cv_recv)
+ if(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}"
STREQUAL "unknown")
+ foreach(recv_retv "int" "ssize_t" )
+ foreach(recv_arg1 "SOCKET" "int" )
+ foreach(recv_arg2 "char *" "void *" )
+ foreach(recv_arg3 "int" "size_t" "socklen_t" "unsigned int")
+ foreach(recv_arg4 "int" "unsigned int")
+ if(NOT curl_cv_func_recv_done)
+ unset(curl_cv_func_recv_test CACHE)
+ check_c_source_compiles("
+ ${_source_epilogue}
+ extern ${recv_retv} ${signature_call_conv}
+ recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4});
+ int main(void) {
+ ${recv_arg1} s=0;
+ ${recv_arg2} buf=0;
+ ${recv_arg3} len=0;
+ ${recv_arg4} flags=0;
+ ${recv_retv} res = recv(s, buf, len, flags);
+ (void) res;
+ return 0;
+ }"
+ curl_cv_func_recv_test)
+ message(STATUS
+ "Tested: ${recv_retv} recv(${recv_arg1}, ${recv_arg2},
${recv_arg3}, ${recv_arg4})")
+ if(curl_cv_func_recv_test)
+ set(curl_cv_func_recv_args
+
"${recv_arg1},${recv_arg2},${recv_arg3},${recv_arg4},${recv_retv}")
+ set(RECV_TYPE_ARG1 "${recv_arg1}")
+ set(RECV_TYPE_ARG2 "${recv_arg2}")
+ set(RECV_TYPE_ARG3 "${recv_arg3}")
+ set(RECV_TYPE_ARG4 "${recv_arg4}")
+ set(RECV_TYPE_RETV "${recv_retv}")
+ set(HAVE_RECV 1)
+ set(curl_cv_func_recv_done 1)
+ endif()
+ endif()
+ endforeach()
+ endforeach()
+ endforeach()
+ endforeach()
+ endforeach()
+ else()
+ string(REGEX REPLACE "^([^,]*),[^,]*,[^,]*,[^,]*,[^,]*$" "\\1"
RECV_TYPE_ARG1 "${curl_cv_func_recv_args}")
+ string(REGEX REPLACE "^[^,]*,([^,]*),[^,]*,[^,]*,[^,]*$" "\\1"
RECV_TYPE_ARG2 "${curl_cv_func_recv_args}")
+ string(REGEX REPLACE "^[^,]*,[^,]*,([^,]*),[^,]*,[^,]*$" "\\1"
RECV_TYPE_ARG3 "${curl_cv_func_recv_args}")
+ string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,([^,]*),[^,]*$" "\\1"
RECV_TYPE_ARG4 "${curl_cv_func_recv_args}")
+ string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,([^,]*)$" "\\1"
RECV_TYPE_RETV "${curl_cv_func_recv_args}")
+ endif()
+
+ if("${curl_cv_func_recv_args}" STREQUAL "unknown")
+ message(FATAL_ERROR "Cannot find proper types to use for recv args")
+ endif()
+else()
+ message(FATAL_ERROR "Unable to link function recv")
+endif()
+set(curl_cv_func_recv_args "${curl_cv_func_recv_args}" CACHE INTERNAL
"Arguments for recv")
+set(HAVE_RECV 1)
+
+check_c_source_compiles("${_source_epilogue}
+int main(void) {
+ send(0, 0, 0, 0);
+ return 0;
+}" curl_cv_send)
+if(curl_cv_send)
+ if(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}"
STREQUAL "unknown")
+ foreach(send_retv "int" "ssize_t" )
+ foreach(send_arg1 "SOCKET" "int" "ssize_t" )
+ foreach(send_arg2 "const char *" "const void *" "void *" "char *")
+ foreach(send_arg3 "int" "size_t" "socklen_t" "unsigned int")
+ foreach(send_arg4 "int" "unsigned int")
+ if(NOT curl_cv_func_send_done)
+ unset(curl_cv_func_send_test CACHE)
+ check_c_source_compiles("
+ ${_source_epilogue}
+ extern ${send_retv} ${signature_call_conv}
+ send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4});
+ int main(void) {
+ ${send_arg1} s=0;
+ ${send_arg2} buf=0;
+ ${send_arg3} len=0;
+ ${send_arg4} flags=0;
+ ${send_retv} res = send(s, buf, len, flags);
+ (void) res;
+ return 0;
+ }"
+ curl_cv_func_send_test)
+ message(STATUS
+ "Tested: ${send_retv} send(${send_arg1}, ${send_arg2},
${send_arg3}, ${send_arg4})")
+ if(curl_cv_func_send_test)
+ string(REGEX REPLACE "(const) .*" "\\1" send_qual_arg2
"${send_arg2}")
+ string(REGEX REPLACE "const (.*)" "\\1" send_arg2
"${send_arg2}")
+ set(curl_cv_func_send_args
+
"${send_arg1},${send_arg2},${send_arg3},${send_arg4},${send_retv},${send_qual_arg2}")
+ set(SEND_TYPE_ARG1 "${send_arg1}")
+ set(SEND_TYPE_ARG2 "${send_arg2}")
+ set(SEND_TYPE_ARG3 "${send_arg3}")
+ set(SEND_TYPE_ARG4 "${send_arg4}")
+ set(SEND_TYPE_RETV "${send_retv}")
+ set(HAVE_SEND 1)
+ set(curl_cv_func_send_done 1)
+ endif()
+ endif()
+ endforeach()
+ endforeach()
+ endforeach()
+ endforeach()
+ endforeach()
+ else()
+ string(REGEX REPLACE "^([^,]*),[^,]*,[^,]*,[^,]*,[^,]*,[^,]*$" "\\1"
SEND_TYPE_ARG1 "${curl_cv_func_send_args}")
+ string(REGEX REPLACE "^[^,]*,([^,]*),[^,]*,[^,]*,[^,]*,[^,]*$" "\\1"
SEND_TYPE_ARG2 "${curl_cv_func_send_args}")
+ string(REGEX REPLACE "^[^,]*,[^,]*,([^,]*),[^,]*,[^,]*,[^,]*$" "\\1"
SEND_TYPE_ARG3 "${curl_cv_func_send_args}")
+ string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,([^,]*),[^,]*,[^,]*$" "\\1"
SEND_TYPE_ARG4 "${curl_cv_func_send_args}")
+ string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,([^,]*),[^,]*$" "\\1"
SEND_TYPE_RETV "${curl_cv_func_send_args}")
+ string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,([^,]*)$" "\\1"
SEND_QUAL_ARG2 "${curl_cv_func_send_args}")
+ endif()
+
+ if("${curl_cv_func_send_args}" STREQUAL "unknown")
+ message(FATAL_ERROR "Cannot find proper types to use for send args")
+ endif()
+ set(SEND_QUAL_ARG2 "const")
+else()
+ message(FATAL_ERROR "Unable to link function send")
+endif()
+set(curl_cv_func_send_args "${curl_cv_func_send_args}" CACHE INTERNAL
"Arguments for send")
+set(HAVE_SEND 1)
+
+check_c_source_compiles("${_source_epilogue}
+ int main(void) {
+ int flag = MSG_NOSIGNAL;
+ (void)flag;
+ return 0;
+ }" HAVE_MSG_NOSIGNAL)
+
+if(NOT HAVE_WINDOWS_H)
+ add_header_include(HAVE_SYS_TIME_H "sys/time.h")
+ add_header_include(TIME_WITH_SYS_TIME "time.h")
+ add_header_include(HAVE_TIME_H "time.h")
+endif()
+check_c_source_compiles("${_source_epilogue}
+int main(void) {
+ struct timeval ts;
+ ts.tv_sec = 0;
+ ts.tv_usec = 0;
+ (void)ts;
+ return 0;
+}" HAVE_STRUCT_TIMEVAL)
+
+set(HAVE_SIG_ATOMIC_T 1)
+set(CMAKE_REQUIRED_FLAGS)
+if(HAVE_SIGNAL_H)
+ set(CMAKE_REQUIRED_FLAGS "-DHAVE_SIGNAL_H")
+ set(CMAKE_EXTRA_INCLUDE_FILES "signal.h")
+endif()
+check_type_size("sig_atomic_t" SIZEOF_SIG_ATOMIC_T)
+if(HAVE_SIZEOF_SIG_ATOMIC_T)
+ check_c_source_compiles("
+ #ifdef HAVE_SIGNAL_H
+ # include <signal.h>
+ #endif
+ int main(void) {
+ static volatile sig_atomic_t dummy = 0;
+ (void)dummy;
+ return 0;
+ }" HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
+ if(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
+ set(HAVE_SIG_ATOMIC_T_VOLATILE 1)
+ endif()
+endif()
+
+if(HAVE_WINDOWS_H)
+ set(CMAKE_EXTRA_INCLUDE_FILES winsock2.h)
+else()
+ set(CMAKE_EXTRA_INCLUDE_FILES)
+ if(HAVE_SYS_SOCKET_H)
+ set(CMAKE_EXTRA_INCLUDE_FILES sys/socket.h)
+ endif()
+endif()
+
+check_type_size("struct sockaddr_storage" SIZEOF_STRUCT_SOCKADDR_STORAGE)
+if(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)
+ set(HAVE_STRUCT_SOCKADDR_STORAGE 1)
+endif()
+
+unset(CMAKE_TRY_COMPILE_TARGET_TYPE)
+
+if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
+ # if not cross-compilation...
+ include(CheckCSourceRuns)
+ set(CMAKE_REQUIRED_FLAGS "")
+ if(HAVE_SYS_POLL_H)
+ set(CMAKE_REQUIRED_FLAGS "-DHAVE_SYS_POLL_H")
+ elseif(HAVE_POLL_H)
+ set(CMAKE_REQUIRED_FLAGS "-DHAVE_POLL_H")
+ endif()
+ check_c_source_runs("
+ #include <stdlib.h>
+ #include <sys/time.h>
+
+ #ifdef HAVE_SYS_POLL_H
+ # include <sys/poll.h>
+ #elif HAVE_POLL_H
+ # include <poll.h>
+ #endif
+
+ int main(void)
+ {
+ if(0 != poll(0, 0, 10)) {
+ return 1; /* fail */
+ }
+ else {
+ /* detect the 10.12 poll() breakage */
+ struct timeval before, after;
+ int rc;
+ size_t us;
+
+ gettimeofday(&before, NULL);
+ rc = poll(NULL, 0, 500);
+ gettimeofday(&after, NULL);
+
+ us = (after.tv_sec - before.tv_sec) * 1000000 +
+ (after.tv_usec - before.tv_usec);
+
+ if(us < 400000) {
+ return 1;
+ }
+ }
+ return 0;
+ }" HAVE_POLL_FINE)
+endif()
+
diff --git a/CMake/Platforms/WindowsCache.cmake
b/CMake/Platforms/WindowsCache.cmake
new file mode 100644
index 000000000..ead4115a3
--- /dev/null
+++ b/CMake/Platforms/WindowsCache.cmake
@@ -0,0 +1,123 @@
+if(NOT UNIX)
+ if(WIN32)
+ set(HAVE_LIBDL 0)
+ set(HAVE_LIBUCB 0)
+ set(HAVE_LIBSOCKET 0)
+ set(NOT_NEED_LIBNSL 0)
+ set(HAVE_LIBNSL 0)
+ set(HAVE_GETHOSTNAME 1)
+ set(HAVE_LIBZ 0)
+
+ set(HAVE_DLOPEN 0)
+
+ set(HAVE_ALLOCA_H 0)
+ set(HAVE_ARPA_INET_H 0)
+ set(HAVE_DLFCN_H 0)
+ set(HAVE_FCNTL_H 1)
+ set(HAVE_INTTYPES_H 0)
+ set(HAVE_IO_H 1)
+ set(HAVE_MALLOC_H 1)
+ set(HAVE_MEMORY_H 1)
+ set(HAVE_NETDB_H 0)
+ set(HAVE_NETINET_IF_ETHER_H 0)
+ set(HAVE_NETINET_IN_H 0)
+ set(HAVE_NET_IF_H 0)
+ set(HAVE_PROCESS_H 1)
+ set(HAVE_PWD_H 0)
+ set(HAVE_SETJMP_H 1)
+ set(HAVE_SGTTY_H 0)
+ set(HAVE_SIGNAL_H 1)
+ set(HAVE_SOCKIO_H 0)
+ set(HAVE_STDINT_H 0)
+ set(HAVE_STDLIB_H 1)
+ set(HAVE_STRINGS_H 0)
+ set(HAVE_STRING_H 1)
+ set(HAVE_SYS_PARAM_H 0)
+ set(HAVE_SYS_POLL_H 0)
+ set(HAVE_SYS_SELECT_H 0)
+ set(HAVE_SYS_SOCKET_H 0)
+ set(HAVE_SYS_SOCKIO_H 0)
+ set(HAVE_SYS_STAT_H 1)
+ set(HAVE_SYS_TIME_H 0)
+ set(HAVE_SYS_TYPES_H 1)
+ set(HAVE_SYS_UTIME_H 1)
+ set(HAVE_TERMIOS_H 0)
+ set(HAVE_TERMIO_H 0)
+ set(HAVE_TIME_H 1)
+ set(HAVE_UNISTD_H 0)
+ set(HAVE_UTIME_H 0)
+ set(HAVE_X509_H 0)
+ set(HAVE_ZLIB_H 0)
+
+ set(HAVE_SIZEOF_LONG_DOUBLE 1)
+ set(SIZEOF_LONG_DOUBLE 8)
+
+ set(HAVE_SOCKET 1)
+ set(HAVE_POLL 0)
+ set(HAVE_SELECT 1)
+ set(HAVE_STRDUP 1)
+ set(HAVE_STRSTR 1)
+ set(HAVE_STRTOK_R 0)
+ set(HAVE_STRFTIME 1)
+ set(HAVE_UNAME 0)
+ set(HAVE_STRCASECMP 0)
+ set(HAVE_STRICMP 1)
+ set(HAVE_STRCMPI 1)
+ set(HAVE_GETHOSTBYADDR 1)
+ set(HAVE_GETTIMEOFDAY 0)
+ set(HAVE_INET_ADDR 1)
+ set(HAVE_INET_NTOA 1)
+ set(HAVE_INET_NTOA_R 0)
+ set(HAVE_TCGETATTR 0)
+ set(HAVE_TCSETATTR 0)
+ set(HAVE_PERROR 1)
+ set(HAVE_CLOSESOCKET 1)
+ set(HAVE_SETVBUF 0)
+ set(HAVE_SIGSETJMP 0)
+ set(HAVE_GETPASS_R 0)
+ set(HAVE_STRLCAT 0)
+ set(HAVE_GETPWUID 0)
+ set(HAVE_GETEUID 0)
+ set(HAVE_UTIME 1)
+ set(HAVE_RAND_EGD 0)
+ set(HAVE_RAND_SCREEN 0)
+ set(HAVE_RAND_STATUS 0)
+ set(HAVE_GMTIME_R 0)
+ set(HAVE_LOCALTIME_R 0)
+ set(HAVE_GETHOSTBYADDR_R 0)
+ set(HAVE_GETHOSTBYNAME_R 0)
+ set(HAVE_SIGNAL_FUNC 1)
+ set(HAVE_SIGNAL_MACRO 0)
+
+ set(HAVE_GETHOSTBYADDR_R_5 0)
+ set(HAVE_GETHOSTBYADDR_R_5_REENTRANT 0)
+ set(HAVE_GETHOSTBYADDR_R_7 0)
+ set(HAVE_GETHOSTBYADDR_R_7_REENTRANT 0)
+ set(HAVE_GETHOSTBYADDR_R_8 0)
+ set(HAVE_GETHOSTBYADDR_R_8_REENTRANT 0)
+ set(HAVE_GETHOSTBYNAME_R_3 0)
+ set(HAVE_GETHOSTBYNAME_R_3_REENTRANT 0)
+ set(HAVE_GETHOSTBYNAME_R_5 0)
+ set(HAVE_GETHOSTBYNAME_R_5_REENTRANT 0)
+ set(HAVE_GETHOSTBYNAME_R_6 0)
+ set(HAVE_GETHOSTBYNAME_R_6_REENTRANT 0)
+
+ set(TIME_WITH_SYS_TIME 0)
+ set(HAVE_O_NONBLOCK 0)
+ set(HAVE_IN_ADDR_T 0)
+ set(HAVE_INET_NTOA_R_DECL 0)
+ set(HAVE_INET_NTOA_R_DECL_REENTRANT 0)
+ if(ENABLE_IPV6)
+ set(HAVE_GETADDRINFO 1)
+ else()
+ set(HAVE_GETADDRINFO 0)
+ endif()
+ set(STDC_HEADERS 1)
+ set(RETSIGTYPE_TEST 1)
+
+ set(HAVE_SIGACTION 0)
+ set(HAVE_MACRO_SIGSETJMP 0)
+ else()
+ message("This file should be included on Windows platform only")
+ endif()
+endif()
diff --git a/CMake/Utilities.cmake b/CMake/Utilities.cmake
new file mode 100644
index 000000000..5cb1d4497
--- /dev/null
+++ b/CMake/Utilities.cmake
@@ -0,0 +1,13 @@
+# File containing various utilities
+
+# Returns a list of arguments that evaluate to true
+function(count_true output_count_var)
+ set(lst)
+ foreach(option_var IN LISTS ARGN)
+ if(${option_var})
+ list(APPEND lst ${option_var})
+ endif()
+ endforeach()
+ list(LENGTH lst lst_len)
+ set(${output_count_var} ${lst_len} PARENT_SCOPE)
+endfunction()
diff --git a/CMake/cmake_uninstall.cmake.in b/CMake/cmake_uninstall.cmake.in
new file mode 100644
index 000000000..db8e5367d
--- /dev/null
+++ b/CMake/cmake_uninstall.cmake.in
@@ -0,0 +1,26 @@
+if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+ message(FATAL_ERROR "Cannot find install manifest:
@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+ set(CMAKE_INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@")
+endif()
+message(${CMAKE_INSTALL_PREFIX})
+
+file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+foreach(file ${files})
+ message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+ if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+ exec_program(
+ "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+ OUTPUT_VARIABLE rm_out
+ RETURN_VALUE rm_retval
+ )
+ if(NOT "${rm_retval}" STREQUAL 0)
+ message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
+ endif()
+ else()
+ message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+ endif()
+endforeach()
diff --git a/CMake/gnurl-config.cmake.in b/CMake/gnurl-config.cmake.in
new file mode 100644
index 000000000..0e1ee5f95
--- /dev/null
+++ b/CMake/gnurl-config.cmake.in
@@ -0,0 +1,15 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+if(@USE_OPENSSL@)
+ find_dependency(OpenSSL @OPENSSL_VERSION_MAJOR@)
+endif()
+if(@USE_GNUTLS@)
+ find_dependency(GnuTLS @GNUTLS_VERSION_MAJOR@)
+endif()
+if(@USE_ZLIB@)
+ find_dependency(ZLIB @ZLIB_VERSION_MAJOR@)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake")
+check_required_components("@PROJECT_NAME@")
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 000000000..c476facad
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,1226 @@
+#***************************************************************************
+# _ _ ____ _
+# Project ___| | | | _ \| |
+# / __| | | | |_) | |
+# | (__| |_| | _ <| |___
+# \___|\___/|_| \_\_____|
+#
+# Copyright (C) 1998 - 2019, Daniel Stenberg, <address@hidden>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.haxx.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+###########################################################################
+# curl/libcurl CMake script
+# by Tetetest and Sukender (Benoit Neil)
+
+# TODO:
+# The output .so file lacks the soname number which we currently have within
the lib/Makefile.am file
+# Add full (4 or 5 libs) SSL support
+# Add INSTALL target (EXTRA_DIST variables in Makefile.am may be moved to
Makefile.inc so that CMake/CPack is aware of what's to include).
+# Add CTests(?)
+# Check on all possible platforms
+# Test with as many configurations possible (With or without any option)
+# Create scripts that help keeping the CMake build system up to date (to
reduce maintenance). According to Tetetest:
+# - lists of headers that 'configure' checks for;
+# - curl-specific tests (the ones that are in m4/curl-*.m4 files);
+# - (most obvious thing:) curl version numbers.
+# Add documentation subproject
+#
+# To check:
+# (From Daniel Stenberg) The cmake build selected to run gcc with -fPIC on my
box while the plain configure script did not.
+# (From Daniel Stenberg) The gcc command line use neither -g nor any -O
options. As a developer, I also treasure our configure scripts's --enable-debug
option that sets a long range of "picky" compiler options.
+cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}")
+include(Utilities)
+include(Macros)
+include(CMakeDependentOption)
+include(CheckCCompilerFlag)
+
+project(GNURL C)
+
+file(READ ${GNURL_SOURCE_DIR}/include/gnurl/curlver.h CURL_VERSION_H_CONTENTS)
+string(REGEX MATCH "#define LIBCURL_VERSION \"[^\"]*"
+ CURL_VERSION ${CURL_VERSION_H_CONTENTS})
+string(REGEX REPLACE "[^\"]+\"" "" CURL_VERSION ${CURL_VERSION})
+string(REGEX MATCH "#define LIBCURL_VERSION_NUM 0x[0-9a-fA-F]+"
+ CURL_VERSION_NUM ${CURL_VERSION_H_CONTENTS})
+string(REGEX REPLACE "[^0]+0x" "" CURL_VERSION_NUM ${CURL_VERSION_NUM})
+
+
+# Setup package meta-data
+# SET(PACKAGE "curl")
+message(STATUS "gnurl version=[${CURL_VERSION}]")
+# SET(PACKAGE_TARNAME "curl")
+# SET(PACKAGE_NAME "curl")
+# SET(PACKAGE_VERSION "-")
+# SET(PACKAGE_STRING "curl-")
+# SET(PACKAGE_BUGREPORT "a suitable curl mailing list =>
https://curl.haxx.se/mail/";)
+set(OPERATING_SYSTEM "${CMAKE_SYSTEM_NAME}")
+set(OS "\"${CMAKE_SYSTEM_NAME}\"")
+
+include_directories(${GNURL_SOURCE_DIR}/include)
+
+option(CURL_WERROR "Turn compiler warnings into errors" OFF)
+option(PICKY_COMPILER "Enable picky compiler options" ON)
+option(BUILD_GNURL_EXE "Set to ON to build curl executable." ON)
+option(BUILD_SHARED_LIBS "Build shared libraries" ON)
+option(ENABLE_ARES "Set to ON to enable c-ares support" OFF)
+if(WIN32)
+ option(CURL_STATIC_CRT "Set to ON to build libcurl with static CRT on
Windows (/MT)." OFF)
+ option(ENABLE_INET_PTON "Set to OFF to prevent usage of inet_pton when
building against modern SDKs while still requiring compatibility with older
Windows versions, such as Windows XP, Windows Server 2003 etc." ON)
+endif()
+
+cmake_dependent_option(ENABLE_THREADED_RESOLVER "Set to ON to enable threaded
DNS lookup"
+ ON "NOT ENABLE_ARES"
+ OFF)
+
+option(ENABLE_DEBUG "Set to ON to enable curl debug features" OFF)
+option(ENABLE_CURLDEBUG "Set to ON to build with TrackMemory feature enabled"
OFF)
+
+if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_CLANG)
+ if(PICKY_COMPILER)
+ foreach(_CCOPT -pedantic -Wall -W -Wpointer-arith -Wwrite-strings -Wunused
-Wshadow -Winline -Wnested-externs -Wmissing-declarations -Wmissing-prototypes
-Wno-long-long -Wfloat-equal -Wno-multichar -Wsign-compare -Wundef
-Wno-format-nonliteral -Wendif-labels -Wstrict-prototypes
-Wdeclaration-after-statement -Wstrict-aliasing=3 -Wcast-align -Wtype-limits
-Wold-style-declaration -Wmissing-parameter-type -Wempty-body -Wclobbered
-Wignored-qualifiers -Wconversion -Wno-sign-conversion -Wv [...]
+ # surprisingly, CHECK_C_COMPILER_FLAG needs a new variable to store each
new
+ # test result in.
+ check_c_compiler_flag(${_CCOPT} OPT${_CCOPT})
+ if(OPT${_CCOPT})
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_CCOPT}")
+ endif()
+ endforeach()
+ endif()
+endif()
+
+if(ENABLE_DEBUG)
+ # DEBUGBUILD will be defined only for Debug builds
+ set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS
$<$<CONFIG:Debug>:DEBUGBUILD>)
+ set(ENABLE_CURLDEBUG ON)
+endif()
+
+if(ENABLE_CURLDEBUG)
+ set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS CURLDEBUG)
+endif()
+
+# For debug libs and exes, add "-d" postfix
+if(NOT DEFINED CMAKE_DEBUG_POSTFIX)
+ set(CMAKE_DEBUG_POSTFIX "-d")
+endif()
+
+# initialize CURL_LIBS
+set(GNURL_LIBS "")
+
+if(ENABLE_ARES)
+ set(USE_ARES 1)
+ find_package(CARES REQUIRED)
+ list(APPEND GNURL_LIBS ${CARES_LIBRARY})
+ set(GNURL_LIBS ${GNURL_LIBS} ${CARES_LIBRARY})
+endif()
+
+include(CurlSymbolHiding)
+
+option(HTTP_ONLY "disables all protocols except HTTP (This overrides all
CURL_DISABLE_* options)" OFF)
+mark_as_advanced(HTTP_ONLY)
+
+option(CURL_DISABLE_FTP "disables FTP" ON)
+mark_as_advanced(CURL_DISABLE_FTP)
+
+option(CURL_DISABLE_LDAP "disables LDAP" ON)
+mark_as_advanced(CURL_DISABLE_LDAP)
+
+option(CURL_DISABLE_TELNET "disables Telnet" ON)
+mark_as_advanced(CURL_DISABLE_TELNET)
+
+option(CURL_DISABLE_DICT "disables DICT" ON)
+mark_as_advanced(CURL_DISABLE_DICT)
+
+option(CURL_DISABLE_FILE "disables FILE" ON)
+mark_as_advanced(CURL_DISABLE_FILE)
+
+option(CURL_DISABLE_TFTP "disables TFTP" ON)
+mark_as_advanced(CURL_DISABLE_TFTP)
+
+option(CURL_DISABLE_HTTP "disables HTTP" OFF)
+mark_as_advanced(CURL_DISABLE_HTTP)
+
+option(CURL_DISABLE_LDAPS "to disable LDAPS" ON)
+mark_as_advanced(CURL_DISABLE_LDAPS)
+
+option(CURL_DISABLE_RTSP "to disable RTSP" ON)
+mark_as_advanced(CURL_DISABLE_RTSP)
+
+option(CURL_DISABLE_PROXY "to disable proxy" OFF)
+mark_as_advanced(CURL_DISABLE_PROXY)
+
+option(CURL_DISABLE_POP3 "to disable POP3" ON)
+mark_as_advanced(CURL_DISABLE_POP3)
+
+option(CURL_DISABLE_IMAP "to disable IMAP" ON)
+mark_as_advanced(CURL_DISABLE_IMAP)
+
+option(CURL_DISABLE_SMTP "to disable SMTP" ON)
+mark_as_advanced(CURL_DISABLE_SMTP)
+
+option(CURL_DISABLE_GOPHER "to disable Gopher" ON)
+mark_as_advanced(CURL_DISABLE_GOPHER)
+
+option(CURL_DISABLE_COOKIES "to disable cookies support" OFF)
+mark_as_advanced(CURL_DISABLE_COOKIES)
+
+option(CURL_DISABLE_CRYPTO_AUTH "to disable cryptographic authentication" OFF)
+mark_as_advanced(CURL_DISABLE_CRYPTO_AUTH)
+
+option(CURL_DISABLE_VERBOSE_STRINGS "to disable verbose strings" OFF)
+mark_as_advanced(CURL_DISABLE_VERBOSE_STRINGS)
+
+option(ENABLE_IPV6 "Define if you want to enable IPv6 support" ON)
+mark_as_advanced(ENABLE_IPV6)
+
+if(ENABLE_IPV6 AND NOT WIN32)
+ include(CheckStructHasMember)
+ check_struct_has_member("struct sockaddr_in6" sin6_addr "netinet/in.h"
+ HAVE_SOCKADDR_IN6_SIN6_ADDR)
+ check_struct_has_member("struct sockaddr_in6" sin6_scope_id "netinet/in.h"
+ HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)
+ if(NOT HAVE_SOCKADDR_IN6_SIN6_ADDR)
+ message(WARNING "struct sockaddr_in6 not available, disabling IPv6
support")
+ # Force the feature off as this name is used as guard macro...
+ set(ENABLE_IPV6 OFF
+ CACHE BOOL "Define if you want to enable IPv6 support" FORCE)
+ endif()
+endif()
+
+# curl_nroff_check()
+find_package(Perl)
+
+cmake_dependent_option(ENABLE_MANUAL "to provide the built-in manual"
+ ON "NROFF_USEFUL;PERL_FOUND"
+ OFF)
+
+if(NOT PERL_FOUND)
+ message(STATUS "Perl not found, testing disabled.")
+ set(BUILD_TESTING OFF)
+endif()
+
+if(ENABLE_MANUAL)
+ set(USE_MANUAL ON)
+endif()
+
+# 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(CURL_STATIC_CRT)
+ set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT")
+ set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd")
+endif()
+
+# Disable warnings on Borland to avoid changing 3rd party code.
+if(BORLAND)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w-")
+endif()
+
+# If we are on AIX, do the _ALL_SOURCE magic
+if(${CMAKE_SYSTEM_NAME} MATCHES AIX)
+ set(_ALL_SOURCE 1)
+endif()
+
+# Include all the necessary files for macros
+include(CheckFunctionExists)
+include(CheckIncludeFile)
+include(CheckIncludeFiles)
+include(CheckLibraryExists)
+include(CheckSymbolExists)
+include(CheckTypeSize)
+include(CheckCSourceCompiles)
+
+# On windows preload settings
+if(WIN32)
+ set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}
-D_WINSOCKAPI_=")
+ include(${CMAKE_CURRENT_SOURCE_DIR}/CMake/Platforms/WindowsCache.cmake)
+endif()
+
+if(ENABLE_THREADED_RESOLVER)
+ find_package(Threads REQUIRED)
+ if(WIN32)
+ set(USE_THREADS_WIN32 ON)
+ else()
+ set(USE_THREADS_POSIX ${CMAKE_USE_PTHREADS_INIT})
+ set(HAVE_PTHREAD_H ${CMAKE_USE_PTHREADS_INIT})
+ endif()
+ set(GNURL_LIBS ${GNURL_LIBS} ${CMAKE_THREAD_LIBS_INIT})
+endif()
+
+# Check for all needed libraries
+check_library_exists_concat("${CMAKE_DL_LIBS}" dlopen HAVE_LIBDL)
+check_library_exists_concat("socket" connect HAVE_LIBSOCKET)
+check_library_exists("c" gethostbyname "" NOT_NEED_LIBNSL)
+
+# Yellowtab Zeta needs different libraries than BeOS 5.
+if(BEOS)
+ set(NOT_NEED_LIBNSL 1)
+ check_library_exists_concat("bind" gethostbyname HAVE_LIBBIND)
+ check_library_exists_concat("bnetapi" closesocket HAVE_LIBBNETAPI)
+endif()
+
+if(NOT NOT_NEED_LIBNSL)
+ check_library_exists_concat("nsl" gethostbyname HAVE_LIBNSL)
+endif()
+
+check_function_exists(gethostname HAVE_GETHOSTNAME)
+
+if(WIN32)
+ check_library_exists_concat("ws2_32" getch HAVE_LIBWS2_32)
+ check_library_exists_concat("winmm" getch HAVE_LIBWINMM)
+ list(APPEND GNURL_LIBS "advapi32")
+endif()
+
+# check SSL libraries
+# TODO support GNUTLS, NSS, POLARSSL, CYASSL
+
+if(APPLE)
+ option(CMAKE_USE_SECTRANSP "enable Apple OS native SSL/TLS" OFF)
+endif()
+if(WIN32)
+ option(CMAKE_USE_WINSSL "enable Windows native SSL/TLS" OFF)
+ cmake_dependent_option(CURL_WINDOWS_SSPI "Use windows libraries to allow
NTLM authentication without openssl" ON
+ CMAKE_USE_WINSSL OFF)
+endif()
+option(CMAKE_USE_MBEDTLS "Enable mbedTLS for SSL/TLS" OFF)
+
+set(openssl_default OFF)
+if(WIN32 OR CMAKE_USE_SECTRANSP OR CMAKE_USE_WINSSL OR CMAKE_USE_MBEDTLS)
+ set(openssl_default OFF)
+endif()
+option(CMAKE_USE_OPENSSL "Use OpenSSL code. Experimental" ${openssl_default})
+
+option(CMAKE_USE_GNUTLS "Use GnuTLS." ON)
+
+count_true(enabled_ssl_options_count
+ CMAKE_USE_GNUTLS
+ CMAKE_USE_WINSSL
+ CMAKE_USE_SECTRANSP
+ CMAKE_USE_OPENSSL
+ CMAKE_USE_MBEDTLS
+)
+if(enabled_ssl_options_count GREATER "1")
+ set(CURL_WITH_MULTI_SSL ON)
+endif()
+
+if(CMAKE_USE_WINSSL)
+ set(SSL_ENABLED ON)
+ set(USE_SCHANNEL ON) # Windows native SSL/TLS support
+ set(USE_WINDOWS_SSPI ON) # CMAKE_USE_WINSSL implies CURL_WINDOWS_SSPI
+ list(APPEND GNURL_LIBS "crypt32")
+endif()
+if(CURL_WINDOWS_SSPI)
+ set(USE_WINDOWS_SSPI ON)
+ set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}
-DSECURITY_WIN32")
+endif()
+
+if(CMAKE_USE_DARWINSSL)
+ message(FATAL_ERROR "The cmake option CMAKE_USE_DARWINSSL was renamed to
CMAKE_USE_SECTRANSP.")
+endif()
+
+if(CMAKE_USE_SECTRANSP)
+ find_library(COREFOUNDATION_FRAMEWORK "CoreFoundation")
+ if(NOT COREFOUNDATION_FRAMEWORK)
+ message(FATAL_ERROR "CoreFoundation framework not found")
+ endif()
+
+ find_library(SECURITY_FRAMEWORK "Security")
+ if(NOT SECURITY_FRAMEWORK)
+ message(FATAL_ERROR "Security framework not found")
+ endif()
+
+ set(SSL_ENABLED ON)
+ set(USE_SECTRANSP ON)
+ list(APPEND GNURL_LIBS "${COREFOUNDATION_FRAMEWORK}" "${SECURITY_FRAMEWORK}")
+endif()
+
+if(CMAKE_USE_OPENSSL)
+ find_package(OpenSSL REQUIRED)
+ set(SSL_ENABLED ON)
+ set(USE_OPENSSL ON)
+
+ # Depend on OpenSSL via imported targets if supported by the running
+ # version of CMake. This allows our dependents to get our dependencies
+ # transitively.
+ if(NOT CMAKE_VERSION VERSION_LESS 3.4)
+ list(APPEND GNURL_LIBS OpenSSL::SSL OpenSSL::Crypto)
+ else()
+ list(APPEND GNURL_LIBS ${OPENSSL_LIBRARIES})
+ include_directories(${OPENSSL_INCLUDE_DIR})
+ endif()
+
+ set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
+ check_include_file("openssl/crypto.h" HAVE_OPENSSL_CRYPTO_H)
+ check_include_file("openssl/err.h" HAVE_OPENSSL_ERR_H)
+ check_include_file("openssl/pem.h" HAVE_OPENSSL_PEM_H)
+ check_include_file("openssl/rsa.h" HAVE_OPENSSL_RSA_H)
+ check_include_file("openssl/ssl.h" HAVE_OPENSSL_SSL_H)
+ check_include_file("openssl/x509.h" HAVE_OPENSSL_X509_H)
+ check_include_file("openssl/rand.h" HAVE_OPENSSL_RAND_H)
+ check_symbol_exists(RAND_status "${GNURL_INCLUDES}" HAVE_RAND_STATUS)
+ check_symbol_exists(RAND_screen "${GNURL_INCLUDES}" HAVE_RAND_SCREEN)
+ check_symbol_exists(RAND_egd "${GNURL_INCLUDES}" HAVE_RAND_EGD)
+endif()
+
+if(CMAKE_USE_MBEDTLS)
+ find_package(MbedTLS REQUIRED)
+ set(SSL_ENABLED ON)
+ set(USE_MBEDTLS ON)
+ list(APPEND GNURL_LIBS ${MBEDTLS_LIBRARIES})
+ include_directories(${MBEDTLS_INCLUDE_DIRS})
+endif()
+
+if(CMAKE_USE_GNUTLS)
+ find_package(GnuTLS REQUIRED)
+ set(SSL_ENABLED ON)
+ list(APPEND GNURL_LIBS ${GNUTLS_LIBRARIES})
+ include_directories(${GNUTLS_INCLUDE_DIR})
+ set(USE_GNUTLS ON)
+ find_package(GCrypt)
+ find_package(Nettle)
+ if(NETTLE_FOUND)
+ check_library_exists_concat("nettle" nettle_MD5Init USE_GNUTLS_NETTLE)
+ list(APPEND GNURL_LIBS ${NETTLE_LIBRARIES})
+ include_directories(${NETTLE_INCLUDE_DIR})
+ # set(USE_GNUTLS_NETTLE ON)
+ else()
+ check_library_exists_concat("gcrypt" gcry_control USE_GNUTLS_GCRYPT)
+ list(APPEND GNURL_LIBS ${GCRYPT_LIBRARIES})
+ include_directories(${GCRYPT_INCLUDE_DIRS})
+ set(USE_GNUTLS_NETTLE OFF)
+ endif()
+endif()
+
+option(USE_NGHTTP2 "Use Nghttp2 library" OFF)
+
+# Check for idn
+check_library_exists_concat("idn2" idn2_lookup_ul HAVE_LIBIDN2)
+
+# Check for symbol dlopen (same as HAVE_LIBDL)
+check_library_exists("${GNURL_LIBS}" dlopen "" HAVE_DLOPEN)
+
+option(CURL_ZLIB "Set to ON to enable building curl with zlib support." ON)
+set(HAVE_LIBZ OFF)
+set(HAVE_ZLIB_H OFF)
+set(USE_ZLIB OFF)
+if(CURL_ZLIB)
+ find_package(ZLIB QUIET)
+ if(ZLIB_FOUND)
+ set(HAVE_ZLIB_H ON)
+ set(HAVE_LIBZ ON)
+ set(USE_ZLIB ON)
+
+ # Depend on ZLIB via imported targets if supported by the running
+ # version of CMake. This allows our dependents to get our dependencies
+ # transitively.
+ if(NOT CMAKE_VERSION VERSION_LESS 3.4)
+ list(APPEND GNURL_LIBS ZLIB::ZLIB)
+ else()
+ list(APPEND GNURL_LIBS ${ZLIB_LIBRARIES})
+ include_directories(${ZLIB_INCLUDE_DIRS})
+ endif()
+ list(APPEND CMAKE_REQUIRED_INCLUDES ${ZLIB_INCLUDE_DIRS})
+ endif()
+endif()
+
+option(CURL_BROTLI "Set to ON to enable building curl with brotli support."
OFF)
+set(HAVE_BROTLI OFF)
+
+#libSSH2
+option(CMAKE_USE_LIBSSH2 "Use libSSH2" ON)
+mark_as_advanced(CMAKE_USE_LIBSSH2)
+set(USE_LIBSSH2 OFF)
+set(HAVE_LIBSSH2 OFF)
+set(HAVE_LIBSSH2_H OFF)
+
+option(CMAKE_USE_GSSAPI "Use GSSAPI implementation (right now only Heimdal is
supported with CMake build)" OFF)
+mark_as_advanced(CMAKE_USE_GSSAPI)
+
+if(CMAKE_USE_GSSAPI)
+ find_package(GSS)
+
+ set(HAVE_GSSAPI ${GSS_FOUND})
+ if(GSS_FOUND)
+
+ message(STATUS "Found ${GSS_FLAVOUR} GSSAPI version: \"${GSS_VERSION}\"")
+
+ list(APPEND CMAKE_REQUIRED_INCLUDES ${GSS_INCLUDE_DIR})
+ check_include_file_concat("gssapi/gssapi.h" HAVE_GSSAPI_GSSAPI_H)
+ check_include_file_concat("gssapi/gssapi_generic.h"
HAVE_GSSAPI_GSSAPI_GENERIC_H)
+ check_include_file_concat("gssapi/gssapi_krb5.h" HAVE_GSSAPI_GSSAPI_KRB5_H)
+
+ if(GSS_FLAVOUR STREQUAL "Heimdal")
+ set(HAVE_GSSHEIMDAL ON)
+ else() # MIT
+ set(HAVE_GSSMIT ON)
+ set(_INCLUDE_LIST "")
+ if(HAVE_GSSAPI_GSSAPI_H)
+ list(APPEND _INCLUDE_LIST "gssapi/gssapi.h")
+ endif()
+ if(HAVE_GSSAPI_GSSAPI_GENERIC_H)
+ list(APPEND _INCLUDE_LIST "gssapi/gssapi_generic.h")
+ endif()
+ if(HAVE_GSSAPI_GSSAPI_KRB5_H)
+ list(APPEND _INCLUDE_LIST "gssapi/gssapi_krb5.h")
+ endif()
+
+ string(REPLACE ";" " " _COMPILER_FLAGS_STR "${GSS_COMPILER_FLAGS}")
+ string(REPLACE ";" " " _LINKER_FLAGS_STR "${GSS_LINKER_FLAGS}")
+
+ foreach(_dir ${GSS_LINK_DIRECTORIES})
+ set(_LINKER_FLAGS_STR "${_LINKER_FLAGS_STR} -L\"${_dir}\"")
+ endforeach()
+
+ set(CMAKE_REQUIRED_FLAGS "${_COMPILER_FLAGS_STR} ${_LINKER_FLAGS_STR}")
+ set(CMAKE_REQUIRED_LIBRARIES ${GSS_LIBRARIES})
+ check_symbol_exists("GSS_C_NT_HOSTBASED_SERVICE" ${_INCLUDE_LIST}
HAVE_GSS_C_NT_HOSTBASED_SERVICE)
+ if(NOT HAVE_GSS_C_NT_HOSTBASED_SERVICE)
+ set(HAVE_OLD_GSSMIT ON)
+ endif()
+ unset(CMAKE_REQUIRED_LIBRARIES)
+
+ endif()
+
+ include_directories(${GSS_INCLUDE_DIR})
+ link_directories(${GSS_LINK_DIRECTORIES})
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GSS_COMPILER_FLAGS}")
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}
${GSS_LINKER_FLAGS}")
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GSS_LINKER_FLAGS}")
+ list(APPEND GNURL_LIBS ${GSS_LIBRARIES})
+
+ else()
+ message(WARNING "GSSAPI support has been requested but no supporting
libraries found. Skipping.")
+ endif()
+endif()
+
+option(ENABLE_UNIX_SOCKETS "Define if you want Unix domain sockets support" ON)
+if(ENABLE_UNIX_SOCKETS)
+ include(CheckStructHasMember)
+ check_struct_has_member("struct sockaddr_un" sun_path "sys/un.h"
USE_UNIX_SOCKETS)
+else()
+ unset(USE_UNIX_SOCKETS CACHE)
+endif()
+
+#
+# CA handling
+#
+set(CURL_CA_BUNDLE "auto" CACHE STRING
+ "Path to the CA bundle. Set 'none' to disable or 'auto' for
auto-detection. Defaults to 'auto'.")
+set(CURL_CA_FALLBACK OFF CACHE BOOL
+ "Set ON to use built-in CA store of TLS backend. Defaults to OFF")
+set(CURL_CA_PATH "auto" CACHE STRING
+ "Location of default CA path. Set 'none' to disable or 'auto' for
auto-detection. Defaults to 'auto'.")
+
+if("${CURL_CA_BUNDLE}" STREQUAL "")
+ message(FATAL_ERROR "Invalid value of CURL_CA_BUNDLE. Use 'none', 'auto' or
file path.")
+elseif("${CURL_CA_BUNDLE}" STREQUAL "none")
+ unset(CURL_CA_BUNDLE CACHE)
+elseif("${CURL_CA_BUNDLE}" STREQUAL "auto")
+ unset(CURL_CA_BUNDLE CACHE)
+ set(CURL_CA_BUNDLE_AUTODETECT TRUE)
+else()
+ set(CURL_CA_BUNDLE_SET TRUE)
+endif()
+
+if("${CURL_CA_PATH}" STREQUAL "")
+ message(FATAL_ERROR "Invalid value of CURL_CA_PATH. Use 'none', 'auto' or
directory path.")
+elseif("${CURL_CA_PATH}" STREQUAL "none")
+ unset(CURL_CA_PATH CACHE)
+elseif("${CURL_CA_PATH}" STREQUAL "auto")
+ unset(CURL_CA_PATH CACHE)
+ set(CURL_CA_PATH_AUTODETECT TRUE)
+else()
+ set(CURL_CA_PATH_SET TRUE)
+endif()
+
+if(CURL_CA_BUNDLE_SET AND CURL_CA_PATH_AUTODETECT)
+ # Skip autodetection of unset CA path because CA bundle is set explicitly
+elseif(CURL_CA_PATH_SET AND CURL_CA_BUNDLE_AUTODETECT)
+ # Skip autodetection of unset CA bundle because CA path is set explicitly
+elseif(CURL_CA_PATH_AUTODETECT OR CURL_CA_BUNDLE_AUTODETECT)
+ # first try autodetecting a CA bundle, then a CA path
+
+ if(CURL_CA_BUNDLE_AUTODETECT)
+ set(SEARCH_CA_BUNDLE_PATHS
+ /etc/ssl/certs/ca-certificates.crt
+ /etc/pki/tls/certs/ca-bundle.crt
+ /usr/share/ssl/certs/ca-bundle.crt
+ /usr/local/share/certs/ca-root-nss.crt
+ /etc/ssl/cert.pem)
+
+ foreach(SEARCH_CA_BUNDLE_PATH ${SEARCH_CA_BUNDLE_PATHS})
+ if(EXISTS "${SEARCH_CA_BUNDLE_PATH}")
+ message(STATUS "Found CA bundle: ${SEARCH_CA_BUNDLE_PATH}")
+ set(CURL_CA_BUNDLE "${SEARCH_CA_BUNDLE_PATH}")
+ set(CURL_CA_BUNDLE_SET TRUE CACHE BOOL "Path to the CA bundle has been
set")
+ break()
+ endif()
+ endforeach()
+ endif()
+
+ if(CURL_CA_PATH_AUTODETECT AND (NOT CURL_CA_PATH_SET))
+ if(EXISTS "/etc/ssl/certs")
+ set(CURL_CA_PATH "/etc/ssl/certs")
+ set(CURL_CA_PATH_SET TRUE CACHE BOOL "Path to the CA bundle has been
set")
+ endif()
+ endif()
+endif()
+
+if(CURL_CA_PATH_SET AND NOT USE_OPENSSL AND NOT USE_MBEDTLS)
+ message(FATAL_ERROR
+ "CA path only supported by OpenSSL, GnuTLS or mbed TLS. "
+ "Set CURL_CA_PATH=none or enable one of those TLS backends.")
+endif()
+
+# Check for header files
+if(NOT UNIX)
+ check_include_file_concat("windows.h" HAVE_WINDOWS_H)
+ check_include_file_concat("winsock.h" HAVE_WINSOCK_H)
+ check_include_file_concat("ws2tcpip.h" HAVE_WS2TCPIP_H)
+ check_include_file_concat("winsock2.h" HAVE_WINSOCK2_H)
+ if(NOT CURL_WINDOWS_SSPI AND USE_OPENSSL)
+ set(GNURL_LIBS ${GNURL_LIBS} "crypt32")
+ endif()
+endif()
+
+check_include_file_concat("stdio.h" HAVE_STDIO_H)
+check_include_file_concat("inttypes.h" HAVE_INTTYPES_H)
+check_include_file_concat("sys/filio.h" HAVE_SYS_FILIO_H)
+check_include_file_concat("sys/ioctl.h" HAVE_SYS_IOCTL_H)
+check_include_file_concat("sys/param.h" HAVE_SYS_PARAM_H)
+check_include_file_concat("sys/poll.h" HAVE_SYS_POLL_H)
+check_include_file_concat("sys/resource.h" HAVE_SYS_RESOURCE_H)
+check_include_file_concat("sys/select.h" HAVE_SYS_SELECT_H)
+check_include_file_concat("sys/socket.h" HAVE_SYS_SOCKET_H)
+check_include_file_concat("sys/sockio.h" HAVE_SYS_SOCKIO_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("sys/types.h" HAVE_SYS_TYPES_H)
+check_include_file_concat("sys/uio.h" HAVE_SYS_UIO_H)
+check_include_file_concat("sys/un.h" HAVE_SYS_UN_H)
+check_include_file_concat("sys/utime.h" HAVE_SYS_UTIME_H)
+check_include_file_concat("sys/xattr.h" HAVE_SYS_XATTR_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("arpa/tftp.h" HAVE_ARPA_TFTP_H)
+check_include_file_concat("assert.h" HAVE_ASSERT_H)
+check_include_file_concat("crypto.h" HAVE_CRYPTO_H)
+check_include_file_concat("des.h" HAVE_DES_H)
+check_include_file_concat("err.h" HAVE_ERR_H)
+check_include_file_concat("errno.h" HAVE_ERRNO_H)
+check_include_file_concat("fcntl.h" HAVE_FCNTL_H)
+check_include_file_concat("idn2.h" HAVE_IDN2_H)
+check_include_file_concat("ifaddrs.h" HAVE_IFADDRS_H)
+check_include_file_concat("io.h" HAVE_IO_H)
+check_include_file_concat("krb.h" HAVE_KRB_H)
+check_include_file_concat("libgen.h" HAVE_LIBGEN_H)
+check_include_file_concat("locale.h" HAVE_LOCALE_H)
+check_include_file_concat("net/if.h" HAVE_NET_IF_H)
+check_include_file_concat("netdb.h" HAVE_NETDB_H)
+check_include_file_concat("netinet/in.h" HAVE_NETINET_IN_H)
+check_include_file_concat("netinet/tcp.h" HAVE_NETINET_TCP_H)
+
+check_include_file_concat("pem.h" HAVE_PEM_H)
+check_include_file_concat("poll.h" HAVE_POLL_H)
+check_include_file_concat("pwd.h" HAVE_PWD_H)
+check_include_file_concat("rsa.h" HAVE_RSA_H)
+check_include_file_concat("setjmp.h" HAVE_SETJMP_H)
+check_include_file_concat("sgtty.h" HAVE_SGTTY_H)
+check_include_file_concat("signal.h" HAVE_SIGNAL_H)
+check_include_file_concat("ssl.h" HAVE_SSL_H)
+check_include_file_concat("stdbool.h" HAVE_STDBOOL_H)
+check_include_file_concat("stdint.h" HAVE_STDINT_H)
+check_include_file_concat("stdio.h" HAVE_STDIO_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("stropts.h" HAVE_STROPTS_H)
+check_include_file_concat("termio.h" HAVE_TERMIO_H)
+check_include_file_concat("termios.h" HAVE_TERMIOS_H)
+check_include_file_concat("time.h" HAVE_TIME_H)
+check_include_file_concat("unistd.h" HAVE_UNISTD_H)
+check_include_file_concat("utime.h" HAVE_UTIME_H)
+check_include_file_concat("x509.h" HAVE_X509_H)
+
+check_include_file_concat("process.h" HAVE_PROCESS_H)
+check_include_file_concat("stddef.h" HAVE_STDDEF_H)
+check_include_file_concat("dlfcn.h" HAVE_DLFCN_H)
+check_include_file_concat("malloc.h" HAVE_MALLOC_H)
+check_include_file_concat("memory.h" HAVE_MEMORY_H)
+check_include_file_concat("netinet/if_ether.h" HAVE_NETINET_IF_ETHER_H)
+check_include_file_concat("stdint.h" HAVE_STDINT_H)
+check_include_file_concat("sockio.h" HAVE_SOCKIO_H)
+check_include_file_concat("sys/utsname.h" HAVE_SYS_UTSNAME_H)
+
+check_type_size(size_t SIZEOF_SIZE_T)
+check_type_size(ssize_t SIZEOF_SSIZE_T)
+check_type_size("long long" SIZEOF_LONG_LONG)
+check_type_size("long" SIZEOF_LONG)
+check_type_size("short" SIZEOF_SHORT)
+check_type_size("int" SIZEOF_INT)
+check_type_size("__int64" SIZEOF___INT64)
+check_type_size("long double" SIZEOF_LONG_DOUBLE)
+check_type_size("time_t" SIZEOF_TIME_T)
+if(NOT HAVE_SIZEOF_SSIZE_T)
+ if(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
+ set(ssize_t long)
+ endif()
+ if(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
+ set(ssize_t __int64)
+ endif()
+endif()
+# off_t is sized later, after the HAVE_FILE_OFFSET_BITS test
+
+if(HAVE_SIZEOF_LONG_LONG)
+ set(HAVE_LONGLONG 1)
+ set(HAVE_LL 1)
+endif()
+
+find_file(RANDOM_FILE urandom /dev)
+mark_as_advanced(RANDOM_FILE)
+
+# Check for some functions that are used
+if(HAVE_LIBWS2_32)
+ set(CMAKE_REQUIRED_LIBRARIES ws2_32)
+elseif(HAVE_LIBSOCKET)
+ set(CMAKE_REQUIRED_LIBRARIES socket)
+endif()
+
+check_symbol_exists(basename "${GNURL_INCLUDES}" HAVE_BASENAME)
+check_symbol_exists(socket "${GNURL_INCLUDES}" HAVE_SOCKET)
+check_symbol_exists(select "${GNURL_INCLUDES}" HAVE_SELECT)
+check_symbol_exists(poll "${GNURL_INCLUDES}" HAVE_POLL)
+check_symbol_exists(strdup "${GNURL_INCLUDES}" HAVE_STRDUP)
+check_symbol_exists(strstr "${GNURL_INCLUDES}" HAVE_STRSTR)
+check_symbol_exists(strtok_r "${GNURL_INCLUDES}" HAVE_STRTOK_R)
+check_symbol_exists(strftime "${GNURL_INCLUDES}" HAVE_STRFTIME)
+check_symbol_exists(uname "${GNURL_INCLUDES}" HAVE_UNAME)
+check_symbol_exists(strcasecmp "${GNURL_INCLUDES}" HAVE_STRCASECMP)
+check_symbol_exists(stricmp "${GNURL_INCLUDES}" HAVE_STRICMP)
+check_symbol_exists(strcmpi "${GNURL_INCLUDES}" HAVE_STRCMPI)
+check_symbol_exists(strncmpi "${GNURL_INCLUDES}" HAVE_STRNCMPI)
+check_symbol_exists(alarm "${GNURL_INCLUDES}" HAVE_ALARM)
+if(NOT HAVE_STRNCMPI)
+ set(HAVE_STRCMPI)
+endif()
+check_symbol_exists(gethostbyaddr "${GNURL_INCLUDES}" HAVE_GETHOSTBYADDR)
+check_symbol_exists(gethostbyaddr_r "${GNURL_INCLUDES}" HAVE_GETHOSTBYADDR_R)
+check_symbol_exists(gettimeofday "${GNURL_INCLUDES}" HAVE_GETTIMEOFDAY)
+check_symbol_exists(inet_addr "${GNURL_INCLUDES}" HAVE_INET_ADDR)
+check_symbol_exists(inet_ntoa "${GNURL_INCLUDES}" HAVE_INET_NTOA)
+check_symbol_exists(inet_ntoa_r "${GNURL_INCLUDES}" HAVE_INET_NTOA_R)
+check_symbol_exists(tcsetattr "${GNURL_INCLUDES}" HAVE_TCSETATTR)
+check_symbol_exists(tcgetattr "${GNURL_INCLUDES}" HAVE_TCGETATTR)
+check_symbol_exists(perror "${GNURL_INCLUDES}" HAVE_PERROR)
+check_symbol_exists(closesocket "${GNURL_INCLUDES}" HAVE_CLOSESOCKET)
+check_symbol_exists(setvbuf "${GNURL_INCLUDES}" HAVE_SETVBUF)
+check_symbol_exists(sigsetjmp "${GNURL_INCLUDES}" HAVE_SIGSETJMP)
+check_symbol_exists(getpass_r "${GNURL_INCLUDES}" HAVE_GETPASS_R)
+check_symbol_exists(strlcat "${GNURL_INCLUDES}" HAVE_STRLCAT)
+check_symbol_exists(getpwuid "${GNURL_INCLUDES}" HAVE_GETPWUID)
+check_symbol_exists(getpwuid_r "${GNURL_INCLUDES}" HAVE_GETPWUID_R)
+check_symbol_exists(geteuid "${GNURL_INCLUDES}" HAVE_GETEUID)
+check_symbol_exists(usleep "${GNURL_INCLUDES}" HAVE_USLEEP)
+check_symbol_exists(utime "${GNURL_INCLUDES}" HAVE_UTIME)
+check_symbol_exists(gmtime_r "${GNURL_INCLUDES}" HAVE_GMTIME_R)
+check_symbol_exists(localtime_r "${GNURL_INCLUDES}" HAVE_LOCALTIME_R)
+
+check_symbol_exists(gethostbyname "${GNURL_INCLUDES}" HAVE_GETHOSTBYNAME)
+check_symbol_exists(gethostbyname_r "${GNURL_INCLUDES}" HAVE_GETHOSTBYNAME_R)
+
+check_symbol_exists(signal "${GNURL_INCLUDES}" HAVE_SIGNAL_FUNC)
+check_symbol_exists(SIGALRM "${GNURL_INCLUDES}" HAVE_SIGNAL_MACRO)
+if(HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO)
+ set(HAVE_SIGNAL 1)
+endif()
+check_symbol_exists(uname "${GNURL_INCLUDES}" HAVE_UNAME)
+check_symbol_exists(strtoll "${GNURL_INCLUDES}" HAVE_STRTOLL)
+check_symbol_exists(_strtoi64 "${GNURL_INCLUDES}" HAVE__STRTOI64)
+check_symbol_exists(strerror_r "${GNURL_INCLUDES}" HAVE_STRERROR_R)
+check_symbol_exists(siginterrupt "${GNURL_INCLUDES}" HAVE_SIGINTERRUPT)
+check_symbol_exists(perror "${GNURL_INCLUDES}" HAVE_PERROR)
+check_symbol_exists(fork "${GNURL_INCLUDES}" HAVE_FORK)
+check_symbol_exists(getaddrinfo "${GNURL_INCLUDES}" HAVE_GETADDRINFO)
+check_symbol_exists(freeaddrinfo "${GNURL_INCLUDES}" HAVE_FREEADDRINFO)
+check_symbol_exists(freeifaddrs "${GNURL_INCLUDES}" HAVE_FREEIFADDRS)
+check_symbol_exists(pipe "${GNURL_INCLUDES}" HAVE_PIPE)
+check_symbol_exists(ftruncate "${GNURL_INCLUDES}" HAVE_FTRUNCATE)
+check_symbol_exists(getprotobyname "${GNURL_INCLUDES}" HAVE_GETPROTOBYNAME)
+check_symbol_exists(getpeername "${GNURL_INCLUDES}" HAVE_GETPEERNAME)
+check_symbol_exists(getsockname "${GNURL_INCLUDES}" HAVE_GETSOCKNAME)
+check_symbol_exists(if_nametoindex "${GNURL_INCLUDES}" HAVE_IF_NAMETOINDEX)
+check_symbol_exists(getrlimit "${GNURL_INCLUDES}" HAVE_GETRLIMIT)
+check_symbol_exists(setlocale "${GNURL_INCLUDES}" HAVE_SETLOCALE)
+check_symbol_exists(setmode "${GNURL_INCLUDES}" HAVE_SETMODE)
+check_symbol_exists(setrlimit "${GNURL_INCLUDES}" HAVE_SETRLIMIT)
+check_symbol_exists(fcntl "${GNURL_INCLUDES}" HAVE_FCNTL)
+check_symbol_exists(ioctl "${GNURL_INCLUDES}" HAVE_IOCTL)
+check_symbol_exists(setsockopt "${GNURL_INCLUDES}" HAVE_SETSOCKOPT)
+check_function_exists(mach_absolute_time HAVE_MACH_ABSOLUTE_TIME)
+
+# symbol exists in win32, but function does not.
+if(WIN32)
+ if(ENABLE_INET_PTON)
+ check_function_exists(inet_pton HAVE_INET_PTON)
+ # _WIN32_WINNT_VISTA (0x0600)
+ add_definitions(-D_WIN32_WINNT=0x0600)
+ else()
+ # _WIN32_WINNT_WINXP (0x0501)
+ add_definitions(-D_WIN32_WINNT=0x0501)
+ endif()
+else()
+ check_function_exists(inet_pton HAVE_INET_PTON)
+endif()
+
+check_symbol_exists(fsetxattr "${GNURL_INCLUDES}" HAVE_FSETXATTR)
+if(HAVE_FSETXATTR)
+ foreach(GNURL_TEST HAVE_FSETXATTR_5 HAVE_FSETXATTR_6)
+ curl_internal_test(${GNURL_TEST})
+ endforeach()
+endif()
+
+# 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()
+
+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()
+ endif()
+endif()
+
+# If there is no stricmp(), do not allow LDAP to parse URLs
+if(NOT HAVE_STRICMP)
+ set(HAVE_LDAP_URL_PARSE 1)
+endif()
+
+# Do curl specific tests
+foreach(GNURL_TEST
+ HAVE_FCNTL_O_NONBLOCK
+ HAVE_IOCTLSOCKET
+ HAVE_IOCTLSOCKET_CAMEL
+ HAVE_IOCTLSOCKET_CAMEL_FIONBIO
+ HAVE_IOCTLSOCKET_FIONBIO
+ HAVE_IOCTL_FIONBIO
+ HAVE_IOCTL_SIOCGIFADDR
+ HAVE_SETSOCKOPT_SO_NONBLOCK
+ HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
+ 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_IN_ADDR_T
+ HAVE_BOOL_T
+ STDC_HEADERS
+ RETSIGTYPE_TEST
+ HAVE_INET_NTOA_R_DECL
+ HAVE_INET_NTOA_R_DECL_REENTRANT
+ HAVE_GETADDRINFO
+ HAVE_FILE_OFFSET_BITS
+ HAVE_VARIADIC_MACROS_C99
+ HAVE_VARIADIC_MACROS_GCC
+ )
+ curl_internal_test(${GNURL_TEST})
+endforeach()
+
+if(HAVE_FILE_OFFSET_BITS)
+ set(_FILE_OFFSET_BITS 64)
+ set(CMAKE_REQUIRED_FLAGS "-D_FILE_OFFSET_BITS=64")
+endif()
+check_type_size("off_t" SIZEOF_OFF_T)
+
+# include this header to get the type
+set(CMAKE_REQUIRED_INCLUDES "${GNURL_SOURCE_DIR}/include")
+set(CMAKE_EXTRA_INCLUDE_FILES "gnurl/system.h")
+check_type_size("curl_off_t" SIZEOF_CURL_OFF_T)
+set(CMAKE_EXTRA_INCLUDE_FILES "")
+
+set(CMAKE_REQUIRED_FLAGS)
+
+foreach(GNURL_TEST
+ HAVE_GLIBC_STRERROR_R
+ HAVE_POSIX_STRERROR_R
+ )
+ curl_internal_test(${GNURL_TEST})
+endforeach()
+
+# Check for reentrant
+foreach(GNURL_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 ${GNURL_TEST})
+ if(${GNURL_TEST}_REENTRANT)
+ set(NEED_REENTRANT 1)
+ endif()
+ endif()
+endforeach()
+
+if(NEED_REENTRANT)
+ foreach(GNURL_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(${GNURL_TEST} 0)
+ if(${GNURL_TEST}_REENTRANT)
+ set(${GNURL_TEST} 1)
+ endif()
+ endforeach()
+endif()
+
+if(HAVE_INET_NTOA_R_DECL_REENTRANT)
+ set(HAVE_INET_NTOA_R_DECL 1)
+ set(NEED_REENTRANT 1)
+endif()
+
+# Check clock_gettime(CLOCK_MONOTONIC, x) support
+curl_internal_test(HAVE_CLOCK_GETTIME_MONOTONIC)
+
+# Check compiler support of __builtin_available()
+curl_internal_test(HAVE_BUILTIN_AVAILABLE)
+
+# Some other minor tests
+
+if(NOT HAVE_IN_ADDR_T)
+ set(in_addr_t "unsigned long")
+endif()
+
+# Fix libz / zlib.h
+
+if(NOT CURL_SPECIAL_LIBZ)
+ if(NOT HAVE_LIBZ)
+ set(HAVE_ZLIB_H 0)
+ endif()
+
+ if(NOT HAVE_ZLIB_H)
+ set(HAVE_LIBZ 0)
+ endif()
+endif()
+
+# Check for nonblocking
+set(HAVE_DISABLED_NONBLOCKING 1)
+if(HAVE_FIONBIO OR
+ HAVE_IOCTLSOCKET OR
+ HAVE_IOCTLSOCKET_CASE OR
+ HAVE_O_NONBLOCK)
+ set(HAVE_DISABLED_NONBLOCKING)
+endif()
+
+if(RETSIGTYPE_TEST)
+ set(RETSIGTYPE void)
+else()
+ set(RETSIGTYPE int)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCC AND APPLE)
+ include(CheckCCompilerFlag)
+ check_c_compiler_flag(-Wno-long-double HAVE_C_FLAG_Wno_long_double)
+ if(HAVE_C_FLAG_Wno_long_double)
+ # The Mac version of GCC warns about use of long double. Disable it.
+ get_source_file_property(MPRINTF_COMPILE_FLAGS mprintf.c COMPILE_FLAGS)
+ if(MPRINTF_COMPILE_FLAGS)
+ set(MPRINTF_COMPILE_FLAGS "${MPRINTF_COMPILE_FLAGS} -Wno-long-double")
+ else()
+ set(MPRINTF_COMPILE_FLAGS "-Wno-long-double")
+ endif()
+ set_source_files_properties(mprintf.c PROPERTIES
+ COMPILE_FLAGS ${MPRINTF_COMPILE_FLAGS})
+ endif()
+endif()
+
+# TODO test which of these headers are required
+if(WIN32)
+ set(CURL_PULL_WS2TCPIP_H ${HAVE_WS2TCPIP_H})
+else()
+ set(CURL_PULL_SYS_TYPES_H ${HAVE_SYS_TYPES_H})
+ set(CURL_PULL_SYS_SOCKET_H ${HAVE_SYS_SOCKET_H})
+ set(CURL_PULL_SYS_POLL_H ${HAVE_SYS_POLL_H})
+endif()
+set(CURL_PULL_STDINT_H ${HAVE_STDINT_H})
+set(CURL_PULL_INTTYPES_H ${HAVE_INTTYPES_H})
+
+include(CMake/OtherTests.cmake)
+
+add_definitions(-DHAVE_CONFIG_H)
+
+# For Windows, all compilers used by CMake should support large files
+if(WIN32)
+ set(USE_WIN32_LARGE_FILES ON)
+
+ # Use the manifest embedded in the Windows Resource
+ set(CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS} -DCURL_EMBED_MANIFEST")
+endif()
+
+if(MSVC)
+ # Disable default manifest added by CMake
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
+
+ add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
+ if(CMAKE_C_FLAGS MATCHES "/W[0-4]")
+ string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+ else()
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
+ endif()
+endif()
+
+if(CURL_WERROR)
+ if(MSVC_VERSION)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX")
+ else()
+ # this assumes clang or gcc style options
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror")
+ endif()
+endif()
+
+# Ugly (but functional) way to include "Makefile.inc" by transforming it (=
regenerate it).
+function(transform_makefile_inc INPUT_FILE OUTPUT_FILE)
+ file(READ ${INPUT_FILE} MAKEFILE_INC_TEXT)
+ string(REPLACE "$(top_srcdir)" "\${GNURL_SOURCE_DIR}" MAKEFILE_INC_TEXT
${MAKEFILE_INC_TEXT})
+ string(REPLACE "$(top_builddir)" "\${GNURL_BINARY_DIR}" MAKEFILE_INC_TEXT
${MAKEFILE_INC_TEXT})
+
+ string(REGEX REPLACE "\\\\\n" "!π!α!" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+ string(REGEX REPLACE "([a-zA-Z_][a-zA-Z0-9_]*)[\t ]*=[\t ]*([^\n]*)"
"SET(\\1 \\2)" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+ string(REPLACE "!π!α!" "\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+
+ string(REGEX REPLACE "\\$\\(([a-zA-Z_][a-zA-Z0-9_]*)\\)" "\${\\1}"
MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT}) # Replace $() with ${}
+ string(REGEX REPLACE "@([a-zA-Z_][a-zA-Z0-9_]*)@" "\${\\1}"
MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT}) # Replace @@ with ${}, even if that
may not be read by CMake scripts.
+ file(WRITE ${OUTPUT_FILE} ${MAKEFILE_INC_TEXT})
+endfunction()
+
+include(GNUInstallDirs)
+
+set(GNURL_INSTALL_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
+set(generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated")
+set(project_config "${generated_dir}/${PROJECT_NAME}Config.cmake")
+set(version_config "${generated_dir}/${PROJECT_NAME}ConfigVersion.cmake")
+
+if(USE_MANUAL)
+ add_subdirectory(docs)
+endif()
+
+add_subdirectory(lib)
+
+if(BUILD_GNURL_EXE)
+ add_subdirectory(src)
+endif()
+
+include(CTest)
+if(BUILD_TESTING)
+ add_subdirectory(tests)
+endif()
+
+# Helper to populate a list (_items) with a label when conditions (the
remaining
+# args) are satisfied
+function(_add_if label)
+ # TODO need to disable policy CMP0054 (CMake 3.1) to allow this indirection
+ if(${ARGN})
+ set(_items ${_items} "${label}" PARENT_SCOPE)
+ endif()
+endfunction()
+
+# Clear list and try to detect available features
+set(_items)
+_add_if("SSL" SSL_ENABLED)
+_add_if("IPv6" ENABLE_IPV6)
+_add_if("unix-sockets" USE_UNIX_SOCKETS)
+_add_if("libz" HAVE_LIBZ)
+_add_if("AsynchDNS" USE_ARES OR USE_THREADS_POSIX OR USE_THREADS_WIN32)
+_add_if("IDN" HAVE_LIBIDN2)
+_add_if("Largefile" (CURL_SIZEOF_CURL_OFF_T GREATER 4) AND
+ ((SIZEOF_OFF_T GREATER 4) OR USE_WIN32_LARGE_FILES))
+# TODO SSP1 (WinSSL) check is missing
+_add_if("SSPI" USE_WINDOWS_SSPI)
+_add_if("GSS-API" HAVE_GSSAPI)
+# TODO SSP1 missing for SPNEGO
+_add_if("SPNEGO" NOT CURL_DISABLE_CRYPTO_AUTH AND
+ (HAVE_GSSAPI OR USE_WINDOWS_SSPI))
+_add_if("Kerberos" NOT CURL_DISABLE_CRYPTO_AUTH AND
+ (HAVE_GSSAPI OR USE_WINDOWS_SSPI))
+# NTLM support requires crypto function adaptions from various SSL libs
+# TODO alternative SSL libs tests for SSP1, GNUTLS, NSS
+if(NOT CURL_DISABLE_CRYPTO_AUTH AND (USE_OPENSSL OR USE_WINDOWS_SSPI OR
USE_SECTRANSP OR USE_MBEDTLS OR USE_GNUTLS))
+ _add_if("NTLM" 1)
+ # TODO missing option (autoconf: --enable-ntlm-wb)
+ _add_if("NTLM_WB" NOT CURL_DISABLE_HTTP AND NTLM_WB_ENABLED)
+endif()
+# TODO missing option (--enable-tls-srp), depends on GNUTLS_SRP/OPENSSL_SRP
+_add_if("TLS-SRP" USE_TLS_SRP)
+# TODO option --with-nghttp2 tests for nghttp2 lib and nghttp2/nghttp2.h header
+_add_if("HTTP2" USE_NGHTTP2)
+string(REPLACE ";" " " SUPPORT_FEATURES "${_items}")
+message(STATUS "Enabled features: ${SUPPORT_FEATURES}")
+
+# Clear list and try to detect available protocols
+set(_items)
+_add_if("HTTP" NOT CURL_DISABLE_HTTP)
+_add_if("HTTPS" NOT CURL_DISABLE_HTTP AND SSL_ENABLED)
+_add_if("FTP" NOT CURL_DISABLE_FTP)
+_add_if("FTPS" NOT CURL_DISABLE_FTP AND SSL_ENABLED)
+_add_if("FILE" NOT CURL_DISABLE_FILE)
+_add_if("TELNET" NOT CURL_DISABLE_TELNET)
+_add_if("LDAP" NOT CURL_DISABLE_LDAP)
+# CURL_DISABLE_LDAP implies CURL_DISABLE_LDAPS
+# TODO check HAVE_LDAP_SSL (in autoconf this is enabled with --enable-ldaps)
+_add_if("LDAPS" NOT CURL_DISABLE_LDAPS AND
+ ((USE_OPENLDAP AND SSL_ENABLED) OR
+ (NOT USE_OPENLDAP AND HAVE_LDAP_SSL)))
+_add_if("DICT" NOT CURL_DISABLE_DICT)
+_add_if("TFTP" NOT CURL_DISABLE_TFTP)
+_add_if("GOPHER" NOT CURL_DISABLE_GOPHER)
+_add_if("POP3" NOT CURL_DISABLE_POP3)
+_add_if("POP3S" NOT CURL_DISABLE_POP3 AND SSL_ENABLED)
+_add_if("IMAP" NOT CURL_DISABLE_IMAP)
+_add_if("IMAPS" NOT CURL_DISABLE_IMAP AND SSL_ENABLED)
+_add_if("SMTP" NOT CURL_DISABLE_SMTP)
+_add_if("SMTPS" NOT CURL_DISABLE_SMTP AND SSL_ENABLED)
+_add_if("SCP" USE_LIBSSH2)
+_add_if("SFTP" USE_LIBSSH2)
+_add_if("RTSP" NOT CURL_DISABLE_RTSP)
+_add_if("RTMP" USE_LIBRTMP)
+if(_items)
+ list(SORT _items)
+endif()
+string(REPLACE ";" " " SUPPORT_PROTOCOLS "${_items}")
+message(STATUS "Enabled protocols: ${SUPPORT_PROTOCOLS}")
+
+# Clear list and collect SSL backends
+set(_items)
+_add_if("WinSSL" SSL_ENABLED AND USE_WINDOWS_SSPI)
+_add_if("OpenSSL" SSL_ENABLED AND USE_OPENSSL)
+_add_if("Secure Transport" SSL_ENABLED AND USE_SECTRANSP)
+_add_if("mbedTLS" SSL_ENABLED AND USE_MBEDTLS)
+if(_items)
+ list(SORT _items)
+endif()
+string(REPLACE ";" " " SSL_BACKENDS "${_items}")
+message(STATUS "Enabled SSL backends: ${SSL_BACKENDS}")
+
+# curl-config needs the following options to be set.
+set(CC "${CMAKE_C_COMPILER}")
+# TODO probably put a -D... options here?
+set(CONFIGURE_OPTIONS "")
+# TODO when to set "-DCURL_STATICLIB" for CPPFLAG_CURL_STATICLIB?
+set(CPPFLAG_CURL_STATICLIB "")
+set(CURLVERSION "${CURL_VERSION}")
+if(BUILD_SHARED_LIBS)
+ set(ENABLE_SHARED "yes")
+ set(ENABLE_STATIC "no")
+else()
+ set(ENABLE_SHARED "no")
+ set(ENABLE_STATIC "yes")
+endif()
+set(exec_prefix "\${prefix}")
+set(includedir "\${prefix}/include")
+set(LDFLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
+set(LIBGNURL_LIBS "")
+set(libdir "${CMAKE_INSTALL_PREFIX}/lib")
+foreach(_lib ${CMAKE_C_IMPLICIT_LINK_LIBRARIES} ${GNURL_LIBS})
+ if(_lib MATCHES ".*/.*" OR _lib MATCHES "^-")
+ set(LIBGNURL_LIBS "${LIBGNURL_LIBS} ${_lib}")
+ else()
+ set(LIBGNURL_LIBS "${LIBGNURL_LIBS} -l${_lib}")
+ endif()
+endforeach()
+# "a" (Linux) or "lib" (Windows)
+string(REPLACE "." "" libext "${CMAKE_STATIC_LIBRARY_SUFFIX}")
+set(prefix "${CMAKE_INSTALL_PREFIX}")
+# Set this to "yes" to append all libraries on which -lcurl is dependent
+set(REQUIRE_LIB_DEPS "no")
+# SUPPORT_FEATURES
+# SUPPORT_PROTOCOLS
+set(VERSIONNUM "${CURL_VERSION_NUM}")
+
+# Finally generate a "curl-config" matching this config
+# Use:
+# * ENABLE_SHARED
+# * ENABLE_STATIC
+configure_file("${GNURL_SOURCE_DIR}/gnurl-config.in"
+ "${GNURL_BINARY_DIR}/gnurl-config" @ONLY)
+install(FILES "${GNURL_BINARY_DIR}/gnurl-config"
+ DESTINATION ${CMAKE_INSTALL_BINDIR}
+ PERMISSIONS
+ OWNER_READ OWNER_WRITE OWNER_EXECUTE
+ GROUP_READ GROUP_EXECUTE
+ WORLD_READ WORLD_EXECUTE)
+
+# Finally generate a pkg-config file matching this config
+configure_file("${GNURL_SOURCE_DIR}/libgnurl.pc.in"
+ "${GNURL_BINARY_DIR}/libgnurl.pc" @ONLY)
+install(FILES "${GNURL_BINARY_DIR}/libgnurl.pc"
+ DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+
+# install headers
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/gnurl"
+ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+ FILES_MATCHING PATTERN "*.h")
+
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+ "${version_config}"
+ VERSION ${CURL_VERSION}
+ COMPATIBILITY SameMajorVersion
+)
+
+# Use:
+# * TARGETS_EXPORT_NAME
+# * PROJECT_NAME
+configure_package_config_file(CMake/gnurl-config.cmake.in
+ "${project_config}"
+ INSTALL_DESTINATION ${GNURL_INSTALL_CMAKE_DIR}
+)
+
+install(
+ EXPORT "${TARGETS_EXPORT_NAME}"
+ NAMESPACE "${PROJECT_NAME}::"
+ DESTINATION ${GNURL_INSTALL_CMAKE_DIR}
+)
+
+install(
+ FILES ${version_config} ${project_config}
+ DESTINATION ${GNURL_INSTALL_CMAKE_DIR}
+)
+
+if(NOT TARGET uninstall)
+ configure_file(
+ ${CMAKE_CURRENT_SOURCE_DIR}/CMake/cmake_uninstall.cmake.in
+ ${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake
+ IMMEDIATE @ONLY)
+
+ add_custom_target(uninstall
+ COMMAND ${CMAKE_COMMAND} -P
+ ${CMAKE_CURRENT_BINARY_DIR}/CMake/cmake_uninstall.cmake)
+endif()
diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt
new file mode 100644
index 000000000..694861725
--- /dev/null
+++ b/docs/CMakeLists.txt
@@ -0,0 +1,3 @@
+#add_subdirectory(examples)
+add_subdirectory(libcurl)
+add_subdirectory(cmdline-opts)
diff --git a/docs/cmdline-opts/CMakeLists.txt b/docs/cmdline-opts/CMakeLists.txt
new file mode 100644
index 000000000..3c020d418
--- /dev/null
+++ b/docs/cmdline-opts/CMakeLists.txt
@@ -0,0 +1,12 @@
+set(MANPAGE "${CURL_BINARY_DIR}/docs/curl.1")
+
+# Load DPAGES and OTHERPAGES from shared file
+transform_makefile_inc("Makefile.inc"
"${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+
+add_custom_command(OUTPUT "${MANPAGE}"
+ COMMAND "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/gen.pl" mainpage
"${CMAKE_CURRENT_SOURCE_DIR}" > "${MANPAGE}"
+ DEPENDS ${DPAGES} ${OTHERPAGES}
+ VERBATIM
+)
+add_custom_target(generate-curl.1 DEPENDS "${MANPAGE}")
diff --git a/docs/libcurl/CMakeLists.txt b/docs/libcurl/CMakeLists.txt
new file mode 100644
index 000000000..0b32c5054
--- /dev/null
+++ b/docs/libcurl/CMakeLists.txt
@@ -0,0 +1,55 @@
+# Load man_MANS from shared file
+transform_makefile_inc("Makefile.inc"
"${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+
+function(add_manual_pages _listname)
+ foreach(_file IN LISTS ${_listname})
+ if(_file STREQUAL "libcurl-symbols.3")
+ # Special case, an auto-generated file.
+ set(_srcfile "${CMAKE_CURRENT_BINARY_DIR}/${_file}")
+ else()
+ set(_srcfile "${CMAKE_CURRENT_SOURCE_DIR}/${_file}")
+ endif()
+
+ string(REPLACE ".3" ".html" _htmlfile
"${CMAKE_CURRENT_BINARY_DIR}/${_file}")
+ add_custom_command(OUTPUT "${_htmlfile}"
+ COMMAND roffit "--mandir=${CMAKE_CURRENT_SOURCE_DIR}" "${_srcfile}" >
"${_htmlfile}"
+ DEPENDS "${_srcfile}"
+ VERBATIM
+ )
+
+ string(REPLACE ".3" ".pdf" _pdffile "${CMAKE_CURRENT_BINARY_DIR}/${_file}")
+ string(REPLACE ".3" ".ps" _psfile "${CMAKE_CURRENT_BINARY_DIR}/${_file}")
+ # XXX any reason why groff -Tpdf (for gropdf) is not used?
+ add_custom_command(OUTPUT "${_pdffile}"
+ COMMAND groff -Tps -man "${_srcfile}" > "${_psfile}"
+ COMMAND ps2pdf "${_psfile}" "${_pdffile}"
+ COMMAND "${CMAKE_COMMAND}" -E remove "${_psfile}"
+ DEPENDS "${_srcfile}"
+ #BYPRODUCTS "${_psfile}"
+ VERBATIM
+ )
+ # "BYPRODUCTS" for add_custom_command requires CMake 3.2. For now hope that
+ # the temporary files are removed (i.e. the command is not interrupted).
+ endforeach()
+endfunction()
+
+add_custom_command(OUTPUT libcurl-symbols.3
+ COMMAND
+ "${PERL_EXECUTABLE}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/mksymbolsmanpage.pl" <
+ "${CMAKE_CURRENT_SOURCE_DIR}/symbols-in-versions" > libcurl-symbols.3
+ DEPENDS
+ "${CMAKE_CURRENT_SOURCE_DIR}/symbols-in-versions"
+ "${CMAKE_CURRENT_SOURCE_DIR}/mksymbolsmanpage.pl"
+ VERBATIM
+)
+
+add_manual_pages(man_MANS)
+
+string(REPLACE ".3" ".html" HTMLPAGES "${man_MANS}")
+string(REPLACE ".3" ".pdf" PDFPAGES "${man_MANS}")
+add_custom_target(html DEPENDS ${HTMLPAGES})
+add_custom_target(pdf DEPENDS ${PDFPAGES})
+
+add_subdirectory(opts)
diff --git a/docs/libcurl/opts/CMakeLists.txt b/docs/libcurl/opts/CMakeLists.txt
new file mode 100644
index 000000000..709d3e4b8
--- /dev/null
+++ b/docs/libcurl/opts/CMakeLists.txt
@@ -0,0 +1,12 @@
+# Load man_MANS from shared file
+transform_makefile_inc("Makefile.inc"
"${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+
+add_manual_pages(man_MANS)
+
+string(REPLACE ".3" ".html" HTMLPAGES "${man_MANS}")
+string(REPLACE ".3" ".pdf" PDFPAGES "${man_MANS}")
+add_custom_target(opts-html DEPENDS ${HTMLPAGES})
+add_custom_target(opts-pdf DEPENDS ${PDFPAGES})
+add_dependencies(html opts-html)
+add_dependencies(pdf opts-pdf)
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
new file mode 100644
index 000000000..8d2d73567
--- /dev/null
+++ b/lib/CMakeLists.txt
@@ -0,0 +1,121 @@
+set(LIB_NAME libgnurl)
+
+if(BUILD_SHARED_LIBS)
+ set(CURL_STATICLIB NO)
+else()
+ set(CURL_STATICLIB YES)
+endif()
+
+# Use:
+# * CURL_STATICLIB
+configure_file(curl_config.h.cmake
+ ${CMAKE_CURRENT_BINARY_DIR}/curl_config.h)
+
+transform_makefile_inc("Makefile.inc"
"${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+
+list(APPEND HHEADERS
+ ${CMAKE_CURRENT_BINARY_DIR}/curl_config.h
+ )
+
+if(MSVC)
+ list(APPEND CSOURCES libcurl.rc)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127")
+endif()
+
+# SET(CSOURCES
+# # memdebug.c -not used
+# # nwlib.c - Not used
+# # strtok.c - specify later
+# # strtoofft.c - specify later
+# )
+
+# # if we have Kerberos 4, right now this is never on
+# #OPTION(CURL_KRB4 "Use Kerberos 4" OFF)
+# IF(CURL_KRB4)
+# SET(CSOURCES ${CSOURCES}
+# krb4.c
+# security.c
+# )
+# ENDIF(CURL_KRB4)
+
+# #OPTION(CURL_MALLOC_DEBUG "Debug mallocs in Curl" OFF)
+# MARK_AS_ADVANCED(CURL_MALLOC_DEBUG)
+# IF(CURL_MALLOC_DEBUG)
+# SET(CSOURCES ${CSOURCES}
+# memdebug.c
+# )
+# ENDIF(CURL_MALLOC_DEBUG)
+
+# # only build compat strtoofft if we need to
+# IF(NOT HAVE_STRTOLL AND NOT HAVE__STRTOI64)
+# SET(CSOURCES ${CSOURCES}
+# strtoofft.c
+# )
+# ENDIF(NOT HAVE_STRTOLL AND NOT HAVE__STRTOI64)
+
+
+# The rest of the build
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/../include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include)
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/..)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+if(USE_ARES)
+ include_directories(${CARES_INCLUDE_DIR})
+endif()
+
+add_library(
+ ${LIB_NAME}
+ ${HHEADERS} ${CSOURCES}
+ )
+
+if(MSVC AND NOT BUILD_SHARED_LIBS)
+ set_target_properties(${LIB_NAME} PROPERTIES STATIC_LIBRARY_FLAGS
${CMAKE_EXE_LINKER_FLAGS})
+endif()
+
+if(NOT BUILD_SHARED_LIBS)
+ set_target_properties(${LIB_NAME} PROPERTIES INTERFACE_COMPILE_DEFINITIONS
CURL_STATICLIB)
+endif()
+
+target_link_libraries(${LIB_NAME} ${GNURL_LIBS})
+
+if(WIN32)
+ add_definitions(-D_USRDLL)
+endif()
+
+set_target_properties(${LIB_NAME} PROPERTIES COMPILE_DEFINITIONS
BUILDING_LIBCURL)
+
+if(HIDES_CURL_PRIVATE_SYMBOLS)
+ set_property(TARGET ${LIB_NAME} APPEND PROPERTY COMPILE_DEFINITIONS
"CURL_HIDDEN_SYMBOLS")
+ set_property(TARGET ${LIB_NAME} APPEND PROPERTY COMPILE_FLAGS
${CURL_CFLAG_SYMBOLS_HIDE})
+endif()
+
+# Remove the "lib" prefix since the library is already named "libcurl".
+set_target_properties(${LIB_NAME} PROPERTIES PREFIX "")
+set_target_properties(${LIB_NAME} PROPERTIES IMPORT_PREFIX "")
+
+if(WIN32)
+ if(BUILD_SHARED_LIBS)
+ # Add "_imp" as a suffix before the extension to avoid conflicting with
the statically linked "libcurl.lib"
+ set_target_properties(${LIB_NAME} PROPERTIES IMPORT_SUFFIX "_imp.lib")
+ endif()
+endif()
+
+target_include_directories(${LIB_NAME} INTERFACE
+ $<INSTALL_INTERFACE:include>
+ $<BUILD_INTERFACE:${GNURL_SOURCE_DIR}/include>)
+
+install(TARGETS ${LIB_NAME}
+ EXPORT ${TARGETS_EXPORT_NAME}
+ ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+export(TARGETS ${LIB_NAME}
+ APPEND FILE ${PROJECT_BINARY_DIR}/libgnurl-target.cmake
+ NAMESPACE GNURL::
+)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 000000000..06b2e3a5b
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,76 @@
+set(EXE_NAME gnurl)
+
+if(USE_MANUAL)
+ # Use the C locale to ensure that only ASCII characters appear in the
+ # embedded text. NROFF and MANOPT are set in the parent CMakeLists.txt
+ add_custom_command(
+ OUTPUT tool_hugehelp.c
+ COMMAND ${CMAKE_COMMAND} -E echo "#include \"tool_setup.h\"" >
tool_hugehelp.c
+ COMMAND ${CMAKE_COMMAND} -E echo "#ifndef HAVE_LIBZ" >> tool_hugehelp.c
+ COMMAND env LC_ALL=C "${NROFF}" ${NROFF_MANOPT}
+ "${CURL_BINARY_DIR}/docs/curl.1" |
+ "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/mkhelp.pl" >>
tool_hugehelp.c
+ COMMAND ${CMAKE_COMMAND} -E echo "#else" >> tool_hugehelp.c
+ COMMAND env LC_ALL=C "${NROFF}" ${NROFF_MANOPT}
+ "${CURL_BINARY_DIR}/docs/curl.1" |
+ "${PERL_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/mkhelp.pl" -c >>
tool_hugehelp.c
+ COMMAND ${CMAKE_COMMAND} -E echo "#endif /* HAVE_LIBZ */" >>
tool_hugehelp.c
+ DEPENDS
+ generate-curl.1
+ "${CURL_BINARY_DIR}/docs/curl.1"
+ "${CMAKE_CURRENT_SOURCE_DIR}/mkhelp.pl"
+ "${CMAKE_CURRENT_SOURCE_DIR}/tool_hugehelp.h"
+ VERBATIM)
+else()
+ add_custom_command(
+ OUTPUT tool_hugehelp.c
+ COMMAND ${CMAKE_COMMAND} -E echo "/* built-in manual is disabled, blank
function */" > tool_hugehelp.c
+ COMMAND ${CMAKE_COMMAND} -E echo "#include \"tool_hugehelp.h\"" >>
tool_hugehelp.c
+ COMMAND ${CMAKE_COMMAND} -E echo "void hugehelp(void) {}" >>
tool_hugehelp.c
+ DEPENDS
+ "${CMAKE_CURRENT_SOURCE_DIR}/tool_hugehelp.h"
+ VERBATIM)
+
+endif()
+
+transform_makefile_inc("Makefile.inc"
"${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+
+if(MSVC)
+ list(APPEND GNURL_FILES curl.rc)
+endif()
+
+# CURL_FILES comes from Makefile.inc
+add_executable(
+ ${EXE_NAME}
+ ${GNURL_FILES}
+ )
+
+source_group("curlX source files" FILES ${GNURLX_CFILES})
+source_group("curl source files" FILES ${GNURL_CFILES})
+source_group("curl header files" FILES ${GNURL_HFILES})
+
+include_directories(
+ ${GNURL_SOURCE_DIR}/lib # To be able to reach "curl_setup_once.h"
+ ${GNURL_BINARY_DIR}/lib # To be able to reach "curl_config.h"
+ ${GNURL_BINARY_DIR}/include # To be able to reach "curl/curl.h"
+ # This is needed as tool_hugehelp.c is generated in the binary dir
+ ${GNURL_SOURCE_DIR}/src # To be able to reach "tool_hugehelp.h"
+ )
+
+#Build gnurl executable
+target_link_libraries(${EXE_NAME} libgnurl ${GNURL_LIBS})
+
+################################################################################
+
+#SET_TARGET_PROPERTIES(${EXE_NAME} ARCHIVE_OUTPUT_DIRECTORY "blah blah blah")
+#SET_TARGET_PROPERTIES(${EXE_NAME} RUNTIME_OUTPUT_DIRECTORY "blah blah blah")
+#SET_TARGET_PROPERTIES(${EXE_NAME} LIBRARY_OUTPUT_DIRECTORY "blah blah blah")
+
+#INCLUDE(ModuleInstall OPTIONAL)
+
+install(TARGETS ${EXE_NAME} EXPORT ${TARGETS_EXPORT_NAME} DESTINATION
${CMAKE_INSTALL_BINDIR})
+export(TARGETS ${EXE_NAME}
+ APPEND FILE ${PROJECT_BINARY_DIR}/gnurl-target.cmake
+ NAMESPACE GNURL::
+)
diff --git a/src/Makefile.inc b/src/Makefile.inc
index dd6b9d336..c7cbba090 100644
--- a/src/Makefile.inc
+++ b/src/Makefile.inc
@@ -9,20 +9,20 @@
# libcurl has sources that provide functions named curlx_* that aren't part of
# the official API, but we re-use the code here to avoid duplication.
-CURLX_CFILES = \
+GNURLX_CFILES = \
../lib/strtoofft.c \
../lib/nonblock.c \
../lib/warnless.c \
../lib/curl_ctype.c
-CURLX_HFILES = \
+GNURLX_HFILES = \
../lib/curl_setup.h \
../lib/strtoofft.h \
../lib/nonblock.h \
../lib/warnless.h \
../lib/curl_ctype.h
-CURL_CFILES = \
+GNURL_CFILES = \
slist_wc.c \
tool_binmode.c \
tool_bname.c \
@@ -64,7 +64,7 @@ CURL_CFILES = \
tool_writeout.c \
tool_xattr.c
-CURL_HFILES = \
+GNURL_HFILES = \
slist_wc.h \
tool_binmode.h \
tool_bname.h \
@@ -109,7 +109,7 @@ CURL_HFILES = \
tool_writeout.h \
tool_xattr.h
-CURL_RCFILES = curl.rc
+GNURL_RCFILES = curl.rc
# curl_SOURCES is special and gets assigned in src/Makefile.am
-CURL_FILES = $(CURL_CFILES) $(CURLX_CFILES) $(CURL_HFILES)
+GNURL_FILES = $(GNURL_CFILES) $(GNURLX_CFILES) $(GNURL_HFILES)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 000000000..63b4cda03
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_subdirectory(data)
+add_subdirectory(libtest)
+add_subdirectory(server)
+add_subdirectory(unit)
diff --git a/tests/data/CMakeLists.txt b/tests/data/CMakeLists.txt
new file mode 100644
index 000000000..dec92e544
--- /dev/null
+++ b/tests/data/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Loads 'TESTCASES' from for the 'make show' target in runtests.pl
+transform_makefile_inc("Makefile.inc"
"${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+
+# Prints all available test cases. Do not quote TESTCASES, it must be displayed
+# as a space-separated string rather than comma-separated (a list in CMake).
+add_custom_target(show COMMAND echo ${TESTCASES})
diff --git a/tests/libtest/CMakeLists.txt b/tests/libtest/CMakeLists.txt
new file mode 100644
index 000000000..e1ba60844
--- /dev/null
+++ b/tests/libtest/CMakeLists.txt
@@ -0,0 +1,140 @@
+set(TARGET_LABEL_PREFIX "Test ")
+
+if(MSVC)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127")
+endif()
+
+function(setup_test TEST_NAME) # ARGN are the files in the test
+ add_executable( ${TEST_NAME} ${ARGN} )
+ string(TOUPPER ${TEST_NAME} UPPER_TEST_NAME)
+
+ include_directories(
+ ${GNURL_SOURCE_DIR}/lib # To be able to reach "curl_setup_once.h"
+ ${GNURL_BINARY_DIR}/lib # To be able to reach "curl_config.h"
+ ${GNURL_BINARY_DIR}/include # To be able to reach "curl/curl.h"
+ ${GNURL_SOURCE_DIR}/tests/libtest # To be able to build generated tests
+ )
+ if(USE_ARES)
+ include_directories(${CARES_INCLUDE_DIR})
+ endif()
+
+ target_link_libraries(${TEST_NAME} libgnurl ${GNURL_LIBS})
+
+ set_target_properties(${TEST_NAME}
+ PROPERTIES COMPILE_DEFINITIONS ${UPPER_TEST_NAME})
+ set_target_properties(${TEST_NAME}
+ PROPERTIES PROJECT_LABEL "${TARGET_LABEL_PREFIX}${TEST_NAME}")
+endfunction()
+
+
+transform_makefile_inc("Makefile.inc"
"${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+
+foreach(TEST_NAME ${noinst_PROGRAMS})
+ if(DEFINED ${TEST_NAME}_SOURCES)
+ setup_test(${TEST_NAME} ${${TEST_NAME}_SOURCES})
+ else()
+ setup_test(${TEST_NAME} ${nodist_${TEST_NAME}_SOURCES})
+ endif()
+endforeach()
+
+# Allows for hostname override to make tests machine independent.
+# TODO this cmake build assumes a shared build, detect static linking here!
+if(NOT WIN32)
+ add_library(hostname MODULE sethostname.c sethostname.h)
+ # Output to .libs for compatibility with autotools, the test data expects a
+ # library at (tests)/libtest/.libs/libhostname.so
+ set_target_properties(hostname PROPERTIES
+ LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/.libs)
+ if(HIDES_CURL_PRIVATE_SYMBOLS)
+ set_property(TARGET hostname APPEND PROPERTY COMPILE_DEFINITIONS
"CURL_HIDDEN_SYMBOLS")
+ set_property(TARGET hostname APPEND PROPERTY COMPILE_FLAGS
${CURL_CFLAG_SYMBOLS_HIDE})
+ endif()
+endif()
+
+add_custom_command(
+ OUTPUT lib1521.c
+ COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/mk-lib1521.pl <
${GNURL_SOURCE_DIR}/include/gnurl/curl.h > lib1521.c
+ DEPENDS
+ "${CMAKE_CURRENT_SOURCE_DIR}/mk-lib1521.pl"
+ "${GNURL_SOURCE_DIR}/include/gnurl/curl.h"
+ VERBATIM)
+
+set_property(TARGET chkdecimalpoint
+ APPEND PROPERTY COMPILE_DEFINITIONS
"CURLX_NO_MEMORY_CALLBACKS;CURL_STATICLIB")
+
+ # # files used only in some libcurl test programs
+# SET(TESTUTIL testutil.c testutil.h)
+
+# # these files are used in every single test program below
+# SET(SUPPORTFILES first.c test.h)
+
+# # These are all libcurl test programs
+# SET(noinst_PROGRAMS
+# lib500 lib501 lib502 lib503 lib504 lib505 lib506
+# lib507 lib508 lib510 lib511 lib512 lib513 lib514 lib515 lib516
+# lib517 lib518 lib519 lib520 lib521 lib523 lib524 lib525 lib526
+# #lib527
+# #lib529
+# lib530
+# #lib532
+# lib533 lib536 lib537 lib540 lib541 lib542 lib543
+# lib544
+# #lib545
+# lib547
+# #lib548
+# lib549 lib552 lib553 lib554 lib555 lib556
+# lib539 lib557
+# lib560
+# )
+
+# SET(noinst_PROGRAMS_USE_TESTUTIL
+# lib502 lib503 lib504
+# lib507
+# lib525 lib526 lib527
+# lib529
+# lib530
+# lib532
+# lib533 lib536
+# lib555
+# )
+
+# MACRO(ADD_TESTUTIL_IF_NECESSARY TEST_NAME)
+# LIST(FIND noinst_PROGRAMS_USE_TESTUTIL ${TEST_NAME} USES_TESTUTIL)
+# IF(NOT ${USES_TESTUTIL} EQUAL -1)
+# LIST(APPEND SOURCE ${TESTUTIL}) # Need TestUtil
+# ENDIF()
+# ENDMACRO()
+
+# # General case
+# FOREACH(TEST_NAME ${noinst_PROGRAMS})
+# SET(SOURCE "${TEST_NAME}.c" ${SUPPORTFILES})
+# ADD_TESTUTIL_IF_NECESSARY(${TEST_NAME})
+# SETUP_TEST(${TEST_NAME} ${SOURCE})
+# ENDFOREACH()
+
+# # Special cases
+# SET(TEST_NAME lib527)
+# SET(SOURCE "lib526.c" ${SUPPORTFILES})
+# ADD_TESTUTIL_IF_NECESSARY(${TEST_NAME})
+# SETUP_TEST(${TEST_NAME} ${SOURCE})
+
+# SET(TEST_NAME lib529)
+# SET(SOURCE "lib525.c" ${SUPPORTFILES})
+# ADD_TESTUTIL_IF_NECESSARY(${TEST_NAME})
+# SETUP_TEST(${TEST_NAME} ${SOURCE})
+
+# SET(TEST_NAME lib532)
+# SET(SOURCE "lib526.c" ${SUPPORTFILES})
+# ADD_TESTUTIL_IF_NECESSARY(${TEST_NAME})
+# SETUP_TEST(${TEST_NAME} ${SOURCE})
+
+# SET(TEST_NAME lib545)
+# SET(SOURCE "lib544.c" ${SUPPORTFILES})
+# ADD_TESTUTIL_IF_NECESSARY(${TEST_NAME})
+# SETUP_TEST(${TEST_NAME} ${SOURCE})
+
+# SET(TEST_NAME lib548)
+# SET(SOURCE "lib547.c" ${SUPPORTFILES})
+# ADD_TESTUTIL_IF_NECESSARY(${TEST_NAME})
+# SETUP_TEST(${TEST_NAME} ${SOURCE})
diff --git a/tests/server/CMakeLists.txt b/tests/server/CMakeLists.txt
new file mode 100644
index 000000000..06f3a75f6
--- /dev/null
+++ b/tests/server/CMakeLists.txt
@@ -0,0 +1,59 @@
+set(TARGET_LABEL_PREFIX "Test server ")
+
+if(MSVC)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127 /wd4306")
+endif()
+
+function(SETUP_EXECUTABLE TEST_NAME) # ARGN are the files in the test
+ add_executable(${TEST_NAME} ${ARGN})
+ string(TOUPPER ${TEST_NAME} UPPER_TEST_NAME)
+
+ include_directories(
+ ${GNURL_SOURCE_DIR}/lib # To be able to reach "curl_setup_once.h"
+ ${GNURL_BINARY_DIR}/lib # To be able to reach "curl_config.h"
+ ${GNURL_BINARY_DIR}/include # To be able to reach "curl/curl.h"
+ )
+ if(USE_ARES)
+ include_directories(${CARES_INCLUDE_DIR})
+ endif()
+
+ target_link_libraries(${TEST_NAME} ${GNURL_LIBS})
+
+ # Test servers simply are standalone programs that do not use libcurl
+ # library. For convenience and to ease portability of these servers,
+ # some source code files from the libcurl subdirectory are also used
+ # to build the servers. In order to achieve proper linkage of these
+ # files on Win32 targets it is necessary to build the test servers
+ # with CURL_STATICLIB defined, independently of how libcurl is built.
+ if(BUILD_SHARED_LIBS)
+ set_target_properties(${TEST_NAME} PROPERTIES
+ COMPILE_DEFINITIONS CURL_STATICLIB) # ${UPPER_TEST_NAME}
+ endif()
+ set_target_properties(${TEST_NAME} PROPERTIES
+ PROJECT_LABEL "${TARGET_LABEL_PREFIX}${TEST_NAME}")
+endfunction()
+
+
+transform_makefile_inc("Makefile.inc"
+ "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
+
+foreach(EXECUTABLE_NAME ${noinst_PROGRAMS})
+ setup_executable(${EXECUTABLE_NAME} ${${EXECUTABLE_NAME}_SOURCES})
+endforeach()
+
+
+# SET(useful
+# getpart.c getpart.h
+# ${CURL_SOURCE_DIR}/lib/strequal.c
+# ${CURL_SOURCE_DIR}/lib/base64.c
+# ${CURL_SOURCE_DIR}/lib/mprintf.c
+# ${CURL_SOURCE_DIR}/lib/memdebug.c
+# ${CURL_SOURCE_DIR}/lib/timeval.c
+# )
+
+# SETUP_EXECUTABLE(sws sws.c util.c util.h ${useful})
+# SETUP_EXECUTABLE(resolve resolve.c util.c util.h ${useful})
+# SETUP_EXECUTABLE(sockfilt sockfilt.c util.c util.h ${useful}
${CURL_SOURCE_DIR}/lib/inet_pton.c)
+# SETUP_EXECUTABLE(getpart testpart.c ${useful})
+# SETUP_EXECUTABLE(tftpd tftpd.c util.c util.h ${useful} tftp.h)
diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt
new file mode 100644
index 000000000..ec62d9dfc
--- /dev/null
+++ b/tests/unit/CMakeLists.txt
@@ -0,0 +1,56 @@
+
+set(UT_SRC
+ unit1300.c
+ unit1301.c
+ unit1302.c
+ unit1303.c
+ unit1304.c
+ unit1305.c
+ unit1307.c
+ unit1308.c
+ unit1309.c
+ unit1330.c
+# Broken link on Linux
+# unit1394.c
+ unit1395.c
+ unit1396.c
+ unit1397.c
+ unit1398.c
+ unit1600.c
+ unit1601.c
+ unit1603.c
+# Broken link on Linux
+# unit1604.c
+ unit1620.c
+ unit1655.c
+ )
+
+set(UT_COMMON_FILES ../libtest/first.c ../libtest/test.h curlcheck.h)
+include_directories(
+ ${GNURL_SOURCE_DIR}/lib # To be able to reach "curl_setup_once.h"
+ ${GNURL_SOURCE_DIR}/tests/libtest
+ ${GNURL_SOURCE_DIR}/src
+ ${GNURL_BINARY_DIR}/lib # To be able to reach "curl_config.h"
+ ${GNURL_BINARY_DIR}/include # To be able to reach "curl/curl.h"
+)
+
+foreach(_testfile ${UT_SRC})
+
+ get_filename_component(_testname ${_testfile} NAME_WE)
+ add_executable(${_testname} ${_testfile} ${UT_COMMON_FILES})
+ target_link_libraries(${_testname} libgnurl ${CURL_LIBS})
+ set_target_properties(${_testname}
+ PROPERTIES COMPILE_DEFINITIONS "UNITTESTS")
+
+ if(HIDES_CURL_PRIVATE_SYMBOLS)
+ set_target_properties(${_testname}
+ PROPERTIES
+ EXCLUDE_FROM_ALL TRUE
+ EXCLUDE_FROM_DEFAULT_BUILD TRUE
+ )
+ else()
+ add_test(NAME ${_testname}
+ COMMAND ${_testname} "http://www.google.com";
+ )
+ endif()
+endforeach()
--
To stop receiving notification emails like this one, please contact
address@hidden.
- [gnurl] branch master updated (7f49525e8 -> 70745a841),
gnunet <=