1 #***************************************************************************
3 # Project ___| | | | _ \| |
5 # | (__| |_| | _ <| |___
6 # \___|\___/|_| \_\_____|
8 # Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
10 # This software is licensed as described in the file COPYING, which
11 # you should have received as part of this distribution. The terms
12 # are also available at https://curl.haxx.se/docs/copyright.html.
14 # You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 # copies of the Software, and permit persons to whom the Software is
16 # furnished to do so, under the terms of the COPYING file.
18 # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 # KIND, either express or implied.
21 #***************************************************************************
23 dnl CURL_CHECK_DEF (SYMBOL, [INCLUDES], [SILENT])
24 dnl -------------------------------------------------
25 dnl Use the C preprocessor to find out if the given object-style symbol
26 dnl is defined and get its expansion. This macro will not use default
27 dnl includes even if no INCLUDES argument is given. This macro will run
28 dnl silently when invoked with three arguments. If the expansion would
29 dnl result in a set of double-quoted strings the returned expansion will
30 dnl actually be a single double-quoted string concatenating all them.
32 AC_DEFUN([CURL_CHECK_DEF], [
33 AC_REQUIRE([CURL_CPP_P])dnl
35 # CPPPFLAG comes from CURL_CPP_P
36 CPPFLAGS="$CPPFLAGS $CPPPFLAG"
37 AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
38 AS_VAR_PUSHDEF([ac_Def], [curl_cv_def_$1])dnl
39 if test -z "$SED"; then
40 AC_MSG_ERROR([SED not set. Cannot continue without SED being set.])
42 if test -z "$GREP"; then
43 AC_MSG_ERROR([GREP not set. Cannot continue without GREP being set.])
45 ifelse($3,,[AC_MSG_CHECKING([for preprocessor definition of $1])])
55 tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
56 "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
57 "$SED" 's/.*CURL_DEF_TOKEN[[ ]][[ ]]*//' 2>/dev/null | \
58 "$SED" 's/[["]][[ ]]*[["]]//g' 2>/dev/null`
59 if test -z "$tmp_exp" || test "$tmp_exp" = "$1"; then
63 if test -z "$tmp_exp"; then
64 AS_VAR_SET(ac_HaveDef, no)
65 ifelse($3,,[AC_MSG_RESULT([no])])
67 AS_VAR_SET(ac_HaveDef, yes)
68 AS_VAR_SET(ac_Def, $tmp_exp)
69 ifelse($3,,[AC_MSG_RESULT([$tmp_exp])])
71 AS_VAR_POPDEF([ac_Def])dnl
72 AS_VAR_POPDEF([ac_HaveDef])dnl
77 dnl CURL_CHECK_DEF_CC (SYMBOL, [INCLUDES], [SILENT])
78 dnl -------------------------------------------------
79 dnl Use the C compiler to find out only if the given symbol is defined
80 dnl or not, this can not find out its expansion. This macro will not use
81 dnl default includes even if no INCLUDES argument is given. This macro
82 dnl will run silently when invoked with three arguments.
84 AC_DEFUN([CURL_CHECK_DEF_CC], [
85 AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
86 ifelse($3,,[AC_MSG_CHECKING([for compiler definition of $1])])
95 force compilation error
100 tst_symbol_defined="yes"
102 tst_symbol_defined="no"
104 if test "$tst_symbol_defined" = "yes"; then
105 AS_VAR_SET(ac_HaveDef, yes)
106 ifelse($3,,[AC_MSG_RESULT([yes])])
108 AS_VAR_SET(ac_HaveDef, no)
109 ifelse($3,,[AC_MSG_RESULT([no])])
111 AS_VAR_POPDEF([ac_HaveDef])dnl
115 dnl CURL_CHECK_LIB_XNET
116 dnl -------------------------------------------------
117 dnl Verify if X/Open network library is required.
119 AC_DEFUN([CURL_CHECK_LIB_XNET], [
120 AC_MSG_CHECKING([if X/Open network library is required])
121 tst_lib_xnet_required="no"
126 #if defined(__hpux) && defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600)
128 #elif defined(__hpux) && defined(_XOPEN_SOURCE_EXTENDED)
131 force compilation error
136 tst_lib_xnet_required="yes"
139 AC_MSG_RESULT([$tst_lib_xnet_required])
143 dnl CURL_CHECK_AIX_ALL_SOURCE
144 dnl -------------------------------------------------
145 dnl Provides a replacement of traditional AC_AIX with
146 dnl an uniform behaviour across all autoconf versions,
147 dnl and with our own placement rules.
149 AC_DEFUN([CURL_CHECK_AIX_ALL_SOURCE], [
150 AH_VERBATIM([_ALL_SOURCE],
151 [/* Define to 1 if OS is AIX. */
155 AC_BEFORE([$0], [AC_SYS_LARGEFILE])dnl
156 AC_BEFORE([$0], [CURL_CONFIGURE_REENTRANT])dnl
157 AC_BEFORE([$0], [CURL_CONFIGURE_PULL_SYS_POLL])dnl
158 AC_MSG_CHECKING([if OS is AIX (to define _ALL_SOURCE)])
159 AC_EGREP_CPP([yes_this_is_aix],[
165 AC_DEFINE(_ALL_SOURCE)
172 dnl CURL_CHECK_HEADER_WINDOWS
173 dnl -------------------------------------------------
174 dnl Check for compilable and valid windows.h header
176 AC_DEFUN([CURL_CHECK_HEADER_WINDOWS], [
177 AC_CACHE_CHECK([for windows.h], [curl_cv_header_windows_h], [
181 #ifndef WIN32_LEAN_AND_MEAN
182 #define WIN32_LEAN_AND_MEAN
186 #if defined(__CYGWIN__) || defined(__CEGCC__)
187 HAVE_WINDOWS_H shall not be defined.
193 curl_cv_header_windows_h="yes"
195 curl_cv_header_windows_h="no"
198 case "$curl_cv_header_windows_h" in
200 AC_DEFINE_UNQUOTED(HAVE_WINDOWS_H, 1,
201 [Define to 1 if you have the windows.h header file.])
202 AC_DEFINE_UNQUOTED(WIN32_LEAN_AND_MEAN, 1,
203 [Define to avoid automatic inclusion of winsock.h])
209 dnl CURL_CHECK_NATIVE_WINDOWS
210 dnl -------------------------------------------------
211 dnl Check if building a native Windows target
213 AC_DEFUN([CURL_CHECK_NATIVE_WINDOWS], [
214 AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
215 AC_CACHE_CHECK([whether build target is a native Windows one], [curl_cv_native_windows], [
216 if test "$curl_cv_header_windows_h" = "no"; then
217 curl_cv_native_windows="no"
222 #if defined(__MINGW32__) || defined(__MINGW32CE__) || \
223 (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64)))
226 Not a native Windows build target.
230 curl_cv_native_windows="yes"
232 curl_cv_native_windows="no"
236 AM_CONDITIONAL(DOING_NATIVE_WINDOWS, test "x$curl_cv_native_windows" = xyes)
240 dnl CURL_CHECK_HEADER_WINSOCK
241 dnl -------------------------------------------------
242 dnl Check for compilable and valid winsock.h header
244 AC_DEFUN([CURL_CHECK_HEADER_WINSOCK], [
245 AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
246 AC_CACHE_CHECK([for winsock.h], [curl_cv_header_winsock_h], [
250 #ifndef WIN32_LEAN_AND_MEAN
251 #define WIN32_LEAN_AND_MEAN
256 #if defined(__CYGWIN__) || defined(__CEGCC__)
257 HAVE_WINSOCK_H shall not be defined.
259 int dummy=WSACleanup();
263 curl_cv_header_winsock_h="yes"
265 curl_cv_header_winsock_h="no"
268 case "$curl_cv_header_winsock_h" in
270 AC_DEFINE_UNQUOTED(HAVE_WINSOCK_H, 1,
271 [Define to 1 if you have the winsock.h header file.])
277 dnl CURL_CHECK_HEADER_WINSOCK2
278 dnl -------------------------------------------------
279 dnl Check for compilable and valid winsock2.h header
281 AC_DEFUN([CURL_CHECK_HEADER_WINSOCK2], [
282 AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
283 AC_CACHE_CHECK([for winsock2.h], [curl_cv_header_winsock2_h], [
287 #ifndef WIN32_LEAN_AND_MEAN
288 #define WIN32_LEAN_AND_MEAN
291 #include <winsock2.h>
293 #if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
294 HAVE_WINSOCK2_H shall not be defined.
296 int dummy=2*IPPROTO_ESP;
300 curl_cv_header_winsock2_h="yes"
302 curl_cv_header_winsock2_h="no"
305 case "$curl_cv_header_winsock2_h" in
307 AC_DEFINE_UNQUOTED(HAVE_WINSOCK2_H, 1,
308 [Define to 1 if you have the winsock2.h header file.])
314 dnl CURL_CHECK_HEADER_WS2TCPIP
315 dnl -------------------------------------------------
316 dnl Check for compilable and valid ws2tcpip.h header
318 AC_DEFUN([CURL_CHECK_HEADER_WS2TCPIP], [
319 AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
320 AC_CACHE_CHECK([for ws2tcpip.h], [curl_cv_header_ws2tcpip_h], [
324 #ifndef WIN32_LEAN_AND_MEAN
325 #define WIN32_LEAN_AND_MEAN
328 #include <winsock2.h>
329 #include <ws2tcpip.h>
331 #if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
332 HAVE_WS2TCPIP_H shall not be defined.
334 int dummy=2*IP_PKTINFO;
338 curl_cv_header_ws2tcpip_h="yes"
340 curl_cv_header_ws2tcpip_h="no"
343 case "$curl_cv_header_ws2tcpip_h" in
345 AC_DEFINE_UNQUOTED(HAVE_WS2TCPIP_H, 1,
346 [Define to 1 if you have the ws2tcpip.h header file.])
352 dnl CURL_CHECK_HEADER_WINLDAP
353 dnl -------------------------------------------------
354 dnl Check for compilable and valid winldap.h header
356 AC_DEFUN([CURL_CHECK_HEADER_WINLDAP], [
357 AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
358 AC_CACHE_CHECK([for winldap.h], [curl_cv_header_winldap_h], [
362 #ifdef HAVE_WINDOWS_H
363 #ifndef WIN32_LEAN_AND_MEAN
364 #define WIN32_LEAN_AND_MEAN
370 #if defined(__CYGWIN__) || defined(__CEGCC__)
371 HAVE_WINLDAP_H shall not be defined.
373 LDAP *ldp = ldap_init("dummy", LDAP_PORT);
374 ULONG res = ldap_unbind(ldp);
378 curl_cv_header_winldap_h="yes"
380 curl_cv_header_winldap_h="no"
383 case "$curl_cv_header_winldap_h" in
385 AC_DEFINE_UNQUOTED(HAVE_WINLDAP_H, 1,
386 [Define to 1 if you have the winldap.h header file.])
392 dnl CURL_CHECK_HEADER_WINBER
393 dnl -------------------------------------------------
394 dnl Check for compilable and valid winber.h header
396 AC_DEFUN([CURL_CHECK_HEADER_WINBER], [
397 AC_REQUIRE([CURL_CHECK_HEADER_WINLDAP])dnl
398 AC_CACHE_CHECK([for winber.h], [curl_cv_header_winber_h], [
402 #ifdef HAVE_WINDOWS_H
403 #ifndef WIN32_LEAN_AND_MEAN
404 #define WIN32_LEAN_AND_MEAN
411 #if defined(__CYGWIN__) || defined(__CEGCC__)
412 HAVE_WINBER_H shall not be defined.
415 BerElement *bep = ber_init(bvp);
420 curl_cv_header_winber_h="yes"
422 curl_cv_header_winber_h="no"
425 case "$curl_cv_header_winber_h" in
427 AC_DEFINE_UNQUOTED(HAVE_WINBER_H, 1,
428 [Define to 1 if you have the winber.h header file.])
434 dnl CURL_CHECK_HEADER_LBER
435 dnl -------------------------------------------------
436 dnl Check for compilable and valid lber.h header,
437 dnl and check if it is needed even with ldap.h
439 AC_DEFUN([CURL_CHECK_HEADER_LBER], [
440 AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
441 AC_CACHE_CHECK([for lber.h], [curl_cv_header_lber_h], [
445 #ifdef HAVE_WINDOWS_H
446 #ifndef WIN32_LEAN_AND_MEAN
447 #define WIN32_LEAN_AND_MEAN
451 #ifdef HAVE_SYS_TYPES_H
452 #include <sys/types.h>
456 #define NULL (void *)0
460 BerValue *bvp = NULL;
461 BerElement *bep = ber_init(bvp);
465 curl_cv_header_lber_h="yes"
467 curl_cv_header_lber_h="no"
470 if test "$curl_cv_header_lber_h" = "yes"; then
471 AC_DEFINE_UNQUOTED(HAVE_LBER_H, 1,
472 [Define to 1 if you have the lber.h header file.])
477 #ifdef HAVE_WINDOWS_H
478 #ifndef WIN32_LEAN_AND_MEAN
479 #define WIN32_LEAN_AND_MEAN
483 #ifdef HAVE_SYS_TYPES_H
484 #include <sys/types.h>
488 #define NULL (void *)0
490 #ifndef LDAP_DEPRECATED
491 #define LDAP_DEPRECATED 1
495 BerValue *bvp = NULL;
496 BerElement *bep = ber_init(bvp);
500 curl_cv_need_header_lber_h="no"
502 curl_cv_need_header_lber_h="yes"
505 case "$curl_cv_need_header_lber_h" in
507 AC_DEFINE_UNQUOTED(NEED_LBER_H, 1,
508 [Define to 1 if you need the lber.h header file even with ldap.h])
515 dnl CURL_CHECK_HEADER_LDAP
516 dnl -------------------------------------------------
517 dnl Check for compilable and valid ldap.h header
519 AC_DEFUN([CURL_CHECK_HEADER_LDAP], [
520 AC_REQUIRE([CURL_CHECK_HEADER_LBER])dnl
521 AC_CACHE_CHECK([for ldap.h], [curl_cv_header_ldap_h], [
525 #ifdef HAVE_WINDOWS_H
526 #ifndef WIN32_LEAN_AND_MEAN
527 #define WIN32_LEAN_AND_MEAN
531 #ifdef HAVE_SYS_TYPES_H
532 #include <sys/types.h>
535 #ifndef LDAP_DEPRECATED
536 #define LDAP_DEPRECATED 1
543 LDAP *ldp = ldap_init("dummy", LDAP_PORT);
544 int res = ldap_unbind(ldp);
547 curl_cv_header_ldap_h="yes"
549 curl_cv_header_ldap_h="no"
552 case "$curl_cv_header_ldap_h" in
554 AC_DEFINE_UNQUOTED(HAVE_LDAP_H, 1,
555 [Define to 1 if you have the ldap.h header file.])
561 dnl CURL_CHECK_HEADER_LDAP_SSL
562 dnl -------------------------------------------------
563 dnl Check for compilable and valid ldap_ssl.h header
565 AC_DEFUN([CURL_CHECK_HEADER_LDAP_SSL], [
566 AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
567 AC_CACHE_CHECK([for ldap_ssl.h], [curl_cv_header_ldap_ssl_h], [
571 #ifdef HAVE_WINDOWS_H
572 #ifndef WIN32_LEAN_AND_MEAN
573 #define WIN32_LEAN_AND_MEAN
577 #ifdef HAVE_SYS_TYPES_H
578 #include <sys/types.h>
581 #ifndef LDAP_DEPRECATED
582 #define LDAP_DEPRECATED 1
590 #include <ldap_ssl.h>
592 LDAP *ldp = ldapssl_init("dummy", LDAPS_PORT, 1);
595 curl_cv_header_ldap_ssl_h="yes"
597 curl_cv_header_ldap_ssl_h="no"
600 case "$curl_cv_header_ldap_ssl_h" in
602 AC_DEFINE_UNQUOTED(HAVE_LDAP_SSL_H, 1,
603 [Define to 1 if you have the ldap_ssl.h header file.])
609 dnl CURL_CHECK_HEADER_LDAPSSL
610 dnl -------------------------------------------------
611 dnl Check for compilable and valid ldapssl.h header
613 AC_DEFUN([CURL_CHECK_HEADER_LDAPSSL], [
614 AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
615 AC_CACHE_CHECK([for ldapssl.h], [curl_cv_header_ldapssl_h], [
619 #ifdef HAVE_WINDOWS_H
620 #ifndef WIN32_LEAN_AND_MEAN
621 #define WIN32_LEAN_AND_MEAN
625 #ifdef HAVE_SYS_TYPES_H
626 #include <sys/types.h>
630 #define NULL (void *)0
632 #ifndef LDAP_DEPRECATED
633 #define LDAP_DEPRECATED 1
643 char *cert_label = NULL;
644 LDAP *ldp = ldap_ssl_init("dummy", LDAPS_PORT, cert_label);
647 curl_cv_header_ldapssl_h="yes"
649 curl_cv_header_ldapssl_h="no"
652 case "$curl_cv_header_ldapssl_h" in
654 AC_DEFINE_UNQUOTED(HAVE_LDAPSSL_H, 1,
655 [Define to 1 if you have the ldapssl.h header file.])
661 dnl CURL_CHECK_LIBS_WINLDAP
662 dnl -------------------------------------------------
663 dnl Check for libraries needed for WINLDAP support,
664 dnl and prepended to LIBS any needed libraries.
665 dnl This macro can take an optional parameter with a
666 dnl white space separated list of libraries to check
667 dnl before the WINLDAP default ones.
669 AC_DEFUN([CURL_CHECK_LIBS_WINLDAP], [
670 AC_REQUIRE([CURL_CHECK_HEADER_WINBER])dnl
672 AC_MSG_CHECKING([for WINLDAP libraries])
686 if test -z "$u_libs"; then
689 u_libs="$u_libs $l_lib"
694 curl_cv_save_LIBS="$LIBS"
695 curl_cv_ldap_LIBS="unknown"
697 for x_nlibs in '' "$u_libs" \
699 if test "$curl_cv_ldap_LIBS" = "unknown"; then
700 if test -z "$x_nlibs"; then
701 LIBS="$curl_cv_save_LIBS"
703 LIBS="$x_nlibs $curl_cv_save_LIBS"
708 #ifdef HAVE_WINDOWS_H
709 #ifndef WIN32_LEAN_AND_MEAN
710 #define WIN32_LEAN_AND_MEAN
713 #ifdef HAVE_WINLDAP_H
722 BerElement *bep = ber_init(bvp);
723 LDAP *ldp = ldap_init("dummy", LDAP_PORT);
724 ULONG res = ldap_unbind(ldp);
728 curl_cv_ldap_LIBS="$x_nlibs"
733 LIBS="$curl_cv_save_LIBS"
735 case X-"$curl_cv_ldap_LIBS" in
737 AC_MSG_RESULT([cannot find WINLDAP libraries])
740 AC_MSG_RESULT([no additional lib required])
743 if test -z "$curl_cv_save_LIBS"; then
744 LIBS="$curl_cv_ldap_LIBS"
746 LIBS="$curl_cv_ldap_LIBS $curl_cv_save_LIBS"
748 AC_MSG_RESULT([$curl_cv_ldap_LIBS])
755 dnl CURL_CHECK_LIBS_LDAP
756 dnl -------------------------------------------------
757 dnl Check for libraries needed for LDAP support,
758 dnl and prepended to LIBS any needed libraries.
759 dnl This macro can take an optional parameter with a
760 dnl white space separated list of libraries to check
761 dnl before the default ones.
763 AC_DEFUN([CURL_CHECK_LIBS_LDAP], [
764 AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
766 AC_MSG_CHECKING([for LDAP libraries])
780 if test -z "$u_libs"; then
783 u_libs="$u_libs $l_lib"
788 curl_cv_save_LIBS="$LIBS"
789 curl_cv_ldap_LIBS="unknown"
791 for x_nlibs in '' "$u_libs" \
795 '-lldapssl -lldapx -lldapsdk' \
796 '-lldapsdk -lldapx -lldapssl' ; do
797 if test "$curl_cv_ldap_LIBS" = "unknown"; then
798 if test -z "$x_nlibs"; then
799 LIBS="$curl_cv_save_LIBS"
801 LIBS="$x_nlibs $curl_cv_save_LIBS"
806 #ifdef HAVE_WINDOWS_H
807 #ifndef WIN32_LEAN_AND_MEAN
808 #define WIN32_LEAN_AND_MEAN
812 #ifdef HAVE_SYS_TYPES_H
813 #include <sys/types.h>
817 #define NULL (void *)0
819 #ifndef LDAP_DEPRECATED
820 #define LDAP_DEPRECATED 1
829 BerValue *bvp = NULL;
830 BerElement *bep = ber_init(bvp);
831 LDAP *ldp = ldap_init("dummy", LDAP_PORT);
832 int res = ldap_unbind(ldp);
836 curl_cv_ldap_LIBS="$x_nlibs"
841 LIBS="$curl_cv_save_LIBS"
843 case X-"$curl_cv_ldap_LIBS" in
845 AC_MSG_RESULT([cannot find LDAP libraries])
848 AC_MSG_RESULT([no additional lib required])
851 if test -z "$curl_cv_save_LIBS"; then
852 LIBS="$curl_cv_ldap_LIBS"
854 LIBS="$curl_cv_ldap_LIBS $curl_cv_save_LIBS"
856 AC_MSG_RESULT([$curl_cv_ldap_LIBS])
863 dnl CURL_CHECK_HEADER_MALLOC
864 dnl -------------------------------------------------
865 dnl Check for compilable and valid malloc.h header,
866 dnl and check if it is needed even with stdlib.h
868 AC_DEFUN([CURL_CHECK_HEADER_MALLOC], [
869 AC_CACHE_CHECK([for malloc.h], [curl_cv_header_malloc_h], [
874 void *p = malloc(10);
875 void *q = calloc(10,10);
880 curl_cv_header_malloc_h="yes"
882 curl_cv_header_malloc_h="no"
885 if test "$curl_cv_header_malloc_h" = "yes"; then
886 AC_DEFINE_UNQUOTED(HAVE_MALLOC_H, 1,
887 [Define to 1 if you have the malloc.h header file.])
893 void *p = malloc(10);
894 void *q = calloc(10,10);
899 curl_cv_need_header_malloc_h="no"
901 curl_cv_need_header_malloc_h="yes"
904 case "$curl_cv_need_header_malloc_h" in
906 AC_DEFINE_UNQUOTED(NEED_MALLOC_H, 1,
907 [Define to 1 if you need the malloc.h header file even with stdlib.h])
914 dnl CURL_CHECK_HEADER_MEMORY
915 dnl -------------------------------------------------
916 dnl Check for compilable and valid memory.h header,
917 dnl and check if it is needed even with stdlib.h for
918 dnl memory related functions.
920 AC_DEFUN([CURL_CHECK_HEADER_MEMORY], [
921 AC_CACHE_CHECK([for memory.h], [curl_cv_header_memory_h], [
926 void *p = malloc(10);
927 void *q = calloc(10,10);
932 curl_cv_header_memory_h="yes"
934 curl_cv_header_memory_h="no"
937 if test "$curl_cv_header_memory_h" = "yes"; then
938 AC_DEFINE_UNQUOTED(HAVE_MEMORY_H, 1,
939 [Define to 1 if you have the memory.h header file.])
945 void *p = malloc(10);
946 void *q = calloc(10,10);
951 curl_cv_need_header_memory_h="no"
953 curl_cv_need_header_memory_h="yes"
956 case "$curl_cv_need_header_memory_h" in
958 AC_DEFINE_UNQUOTED(NEED_MEMORY_H, 1,
959 [Define to 1 if you need the memory.h header file even with stdlib.h])
966 dnl CURL_CHECK_FUNC_GETNAMEINFO
967 dnl -------------------------------------------------
968 dnl Test if the getnameinfo function is available,
969 dnl and check the types of five of its arguments.
970 dnl If the function succeeds HAVE_GETNAMEINFO will be
971 dnl defined, defining the types of the arguments in
972 dnl GETNAMEINFO_TYPE_ARG1, GETNAMEINFO_TYPE_ARG2,
973 dnl GETNAMEINFO_TYPE_ARG46 and GETNAMEINFO_TYPE_ARG7,
974 dnl and also defining the type qualifier of first
975 dnl argument in GETNAMEINFO_QUAL_ARG1.
977 AC_DEFUN([CURL_CHECK_FUNC_GETNAMEINFO], [
978 AC_REQUIRE([CURL_CHECK_HEADER_WS2TCPIP])dnl
979 AC_CHECK_HEADERS(sys/types.h sys/socket.h netdb.h)
981 AC_MSG_CHECKING([for getnameinfo])
983 AC_LANG_FUNC_LINK_TRY([getnameinfo])
986 curl_cv_getnameinfo="yes"
989 curl_cv_getnameinfo="no"
992 if test "$curl_cv_getnameinfo" != "yes"; then
993 AC_MSG_CHECKING([deeper for getnameinfo])
1000 AC_MSG_RESULT([yes])
1001 curl_cv_getnameinfo="yes"
1003 AC_MSG_RESULT([but still no])
1004 curl_cv_getnameinfo="no"
1008 if test "$curl_cv_getnameinfo" != "yes"; then
1009 AC_MSG_CHECKING([deeper and deeper for getnameinfo])
1013 #ifdef HAVE_WINDOWS_H
1014 #ifndef WIN32_LEAN_AND_MEAN
1015 #define WIN32_LEAN_AND_MEAN
1017 #include <windows.h>
1018 #ifdef HAVE_WINSOCK2_H
1019 #include <winsock2.h>
1020 #ifdef HAVE_WS2TCPIP_H
1021 #include <ws2tcpip.h>
1025 #ifdef HAVE_SYS_TYPES_H
1026 #include <sys/types.h>
1028 #ifdef HAVE_SYS_SOCKET_H
1029 #include <sys/socket.h>
1036 getnameinfo(0, 0, 0, 0, 0, 0, 0);
1039 AC_MSG_RESULT([yes])
1040 curl_cv_getnameinfo="yes"
1042 AC_MSG_RESULT([but still no])
1043 curl_cv_getnameinfo="no"
1047 if test "$curl_cv_getnameinfo" = "yes"; then
1048 AC_CACHE_CHECK([types of arguments for getnameinfo],
1049 [curl_cv_func_getnameinfo_args], [
1050 curl_cv_func_getnameinfo_args="unknown"
1051 for gni_arg1 in 'struct sockaddr *' 'const struct sockaddr *' 'void *'; do
1052 for gni_arg2 in 'socklen_t' 'size_t' 'int'; do
1053 for gni_arg46 in 'size_t' 'int' 'socklen_t' 'unsigned int' 'DWORD'; do
1054 for gni_arg7 in 'int' 'unsigned int'; do
1055 if test "$curl_cv_func_getnameinfo_args" = "unknown"; then
1059 #ifdef HAVE_WINDOWS_H
1060 #ifndef WIN32_LEAN_AND_MEAN
1061 #define WIN32_LEAN_AND_MEAN
1063 #if (!defined(_WIN32_WINNT)) || (_WIN32_WINNT < 0x0501)
1065 #define _WIN32_WINNT 0x0501
1067 #include <windows.h>
1068 #ifdef HAVE_WINSOCK2_H
1069 #include <winsock2.h>
1070 #ifdef HAVE_WS2TCPIP_H
1071 #include <ws2tcpip.h>
1074 #define GNICALLCONV WSAAPI
1076 #ifdef HAVE_SYS_TYPES_H
1077 #include <sys/types.h>
1079 #ifdef HAVE_SYS_SOCKET_H
1080 #include <sys/socket.h>
1087 extern int GNICALLCONV getnameinfo($gni_arg1, $gni_arg2,
1093 $gni_arg46 hostlen=0;
1094 $gni_arg46 servlen=0;
1096 int res = getnameinfo(0, salen, 0, hostlen, 0, servlen, flags);
1099 curl_cv_func_getnameinfo_args="$gni_arg1,$gni_arg2,$gni_arg46,$gni_arg7"
1107 if test "$curl_cv_func_getnameinfo_args" = "unknown"; then
1108 AC_MSG_WARN([Cannot find proper types to use for getnameinfo args])
1109 AC_MSG_WARN([HAVE_GETNAMEINFO will not be defined])
1111 gni_prev_IFS=$IFS; IFS=','
1112 set dummy `echo "$curl_cv_func_getnameinfo_args" | sed 's/\*/\*/g'`
1116 gni_qual_type_arg1=$[1]
1118 AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG2, $[2],
1119 [Define to the type of arg 2 for getnameinfo.])
1120 AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG46, $[3],
1121 [Define to the type of args 4 and 6 for getnameinfo.])
1122 AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG7, $[4],
1123 [Define to the type of arg 7 for getnameinfo.])
1127 case $prev_sh_opts in
1135 case "$gni_qual_type_arg1" in
1138 gni_type_arg1=`echo $gni_qual_type_arg1 | sed 's/^const //'`
1142 gni_type_arg1=$gni_qual_type_arg1
1146 AC_DEFINE_UNQUOTED(GETNAMEINFO_QUAL_ARG1, $gni_qual_arg1,
1147 [Define to the type qualifier of arg 1 for getnameinfo.])
1148 AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG1, $gni_type_arg1,
1149 [Define to the type of arg 1 for getnameinfo.])
1151 case $prev_sh_opts in
1159 AC_DEFINE_UNQUOTED(HAVE_GETNAMEINFO, 1,
1160 [Define to 1 if you have the getnameinfo function.])
1161 curl_cv_func_getnameinfo="yes"
1167 dnl TYPE_SOCKADDR_STORAGE
1168 dnl -------------------------------------------------
1169 dnl Check for struct sockaddr_storage. Most IPv6-enabled
1170 dnl hosts have it, but AIX 4.3 is one known exception.
1172 AC_DEFUN([TYPE_SOCKADDR_STORAGE],
1174 AC_CHECK_TYPE([struct sockaddr_storage],
1175 AC_DEFINE(HAVE_STRUCT_SOCKADDR_STORAGE, 1,
1176 [if struct sockaddr_storage is defined]), ,
1179 #ifdef HAVE_WINDOWS_H
1180 #ifndef WIN32_LEAN_AND_MEAN
1181 #define WIN32_LEAN_AND_MEAN
1183 #include <windows.h>
1184 #ifdef HAVE_WINSOCK2_H
1185 #include <winsock2.h>
1188 #ifdef HAVE_SYS_TYPES_H
1189 #include <sys/types.h>
1191 #ifdef HAVE_SYS_SOCKET_H
1192 #include <sys/socket.h>
1194 #ifdef HAVE_NETINET_IN_H
1195 #include <netinet/in.h>
1197 #ifdef HAVE_ARPA_INET_H
1198 #include <arpa/inet.h>
1205 dnl CURL_CHECK_NI_WITHSCOPEID
1206 dnl -------------------------------------------------
1207 dnl Check for working NI_WITHSCOPEID in getnameinfo()
1209 AC_DEFUN([CURL_CHECK_NI_WITHSCOPEID], [
1210 AC_REQUIRE([CURL_CHECK_FUNC_GETNAMEINFO])dnl
1211 AC_REQUIRE([TYPE_SOCKADDR_STORAGE])dnl
1212 AC_CHECK_HEADERS(stdio.h sys/types.h sys/socket.h \
1213 netdb.h netinet/in.h arpa/inet.h)
1215 AC_CACHE_CHECK([for working NI_WITHSCOPEID],
1216 [curl_cv_working_ni_withscopeid], [
1219 #ifdef HAVE_STDLIB_H
1225 #ifdef HAVE_SYS_TYPES_H
1226 #include <sys/types.h>
1228 #ifdef HAVE_SYS_SOCKET_H
1229 #include <sys/socket.h>
1234 #ifdef HAVE_NETINET_IN_H
1235 #include <netinet/in.h>
1237 #ifdef HAVE_ARPA_INET_H
1238 #include <arpa/inet.h>
1241 #if defined(NI_WITHSCOPEID) && defined(HAVE_GETNAMEINFO)
1242 #ifdef HAVE_STRUCT_SOCKADDR_STORAGE
1243 struct sockaddr_storage sa;
1245 unsigned char sa[256];
1247 char hostbuf[NI_MAXHOST];
1249 GETNAMEINFO_TYPE_ARG2 salen = (GETNAMEINFO_TYPE_ARG2)sizeof(sa);
1250 GETNAMEINFO_TYPE_ARG46 hostlen = (GETNAMEINFO_TYPE_ARG46)sizeof(hostbuf);
1251 GETNAMEINFO_TYPE_ARG7 flags = NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;
1252 int fd = socket(AF_INET6, SOCK_STREAM, 0);
1255 return 1; /* Error creating socket */
1257 rc = getsockname(fd, (GETNAMEINFO_TYPE_ARG1)&sa, &salen);
1259 perror("getsockname()");
1260 return 2; /* Error retrieving socket name */
1262 rc = getnameinfo((GETNAMEINFO_TYPE_ARG1)&sa, salen, hostbuf, hostlen, NULL, 0, flags);
1264 printf("rc = %s\n", gai_strerror(rc));
1265 return 3; /* Error translating socket address */
1267 return 0; /* Ok, NI_WITHSCOPEID works */
1269 return 4; /* Error, NI_WITHSCOPEID not defined or no getnameinfo() */
1271 ]]) # AC-LANG-PROGRAM
1273 # Exit code == 0. Program worked.
1274 curl_cv_working_ni_withscopeid="yes"
1276 # Exit code != 0. Program failed.
1277 curl_cv_working_ni_withscopeid="no"
1279 # Program is not run when cross-compiling. So we assume
1280 # NI_WITHSCOPEID will work if we are able to compile it.
1283 #include <sys/types.h>
1284 #include <sys/socket.h>
1287 unsigned int dummy= NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;
1290 curl_cv_working_ni_withscopeid="yes"
1292 curl_cv_working_ni_withscopeid="no"
1293 ]) # AC-COMPILE-IFELSE
1296 case "$curl_cv_working_ni_withscopeid" in
1298 AC_DEFINE(HAVE_NI_WITHSCOPEID, 1,
1299 [Define to 1 if NI_WITHSCOPEID exists and works.])
1305 dnl CURL_CHECK_FUNC_RECV
1306 dnl -------------------------------------------------
1307 dnl Test if the socket recv() function is available,
1308 dnl and check its return type and the types of its
1309 dnl arguments. If the function succeeds HAVE_RECV
1310 dnl will be defined, defining the types of the arguments
1311 dnl in RECV_TYPE_ARG1, RECV_TYPE_ARG2, RECV_TYPE_ARG3
1312 dnl and RECV_TYPE_ARG4, defining the type of the function
1313 dnl return value in RECV_TYPE_RETV.
1315 AC_DEFUN([CURL_CHECK_FUNC_RECV], [
1316 AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1317 AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1318 AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1320 AC_MSG_CHECKING([for recv])
1324 #ifdef HAVE_WINDOWS_H
1325 #ifndef WIN32_LEAN_AND_MEAN
1326 #define WIN32_LEAN_AND_MEAN
1328 #include <windows.h>
1329 #ifdef HAVE_WINSOCK2_H
1330 #include <winsock2.h>
1332 #ifdef HAVE_WINSOCK_H
1333 #include <winsock.h>
1337 #ifdef HAVE_SYS_TYPES_H
1338 #include <sys/types.h>
1340 #ifdef HAVE_SYS_SOCKET_H
1341 #include <sys/socket.h>
1348 AC_MSG_RESULT([yes])
1355 if test "$curl_cv_recv" = "yes"; then
1356 AC_CACHE_CHECK([types of args and return type for recv],
1357 [curl_cv_func_recv_args], [
1358 curl_cv_func_recv_args="unknown"
1359 for recv_retv in 'int' 'ssize_t'; do
1360 for recv_arg1 in 'int' 'ssize_t' 'SOCKET'; do
1361 for recv_arg2 in 'char *' 'void *'; do
1362 for recv_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
1363 for recv_arg4 in 'int' 'unsigned int'; do
1364 if test "$curl_cv_func_recv_args" = "unknown"; then
1368 #ifdef HAVE_WINDOWS_H
1369 #ifndef WIN32_LEAN_AND_MEAN
1370 #define WIN32_LEAN_AND_MEAN
1372 #include <windows.h>
1373 #ifdef HAVE_WINSOCK2_H
1374 #include <winsock2.h>
1376 #ifdef HAVE_WINSOCK_H
1377 #include <winsock.h>
1380 #define RECVCALLCONV PASCAL
1382 #ifdef HAVE_SYS_TYPES_H
1383 #include <sys/types.h>
1385 #ifdef HAVE_SYS_SOCKET_H
1386 #include <sys/socket.h>
1388 #define RECVCALLCONV
1390 extern $recv_retv RECVCALLCONV
1391 recv($recv_arg1, $recv_arg2, $recv_arg3, $recv_arg4);
1397 $recv_retv res = recv(s, buf, len, flags);
1400 curl_cv_func_recv_args="$recv_arg1,$recv_arg2,$recv_arg3,$recv_arg4,$recv_retv"
1409 if test "$curl_cv_func_recv_args" = "unknown"; then
1410 AC_MSG_ERROR([Cannot find proper types to use for recv args])
1412 recv_prev_IFS=$IFS; IFS=','
1413 set dummy `echo "$curl_cv_func_recv_args" | sed 's/\*/\*/g'`
1417 AC_DEFINE_UNQUOTED(RECV_TYPE_ARG1, $[1],
1418 [Define to the type of arg 1 for recv.])
1419 AC_DEFINE_UNQUOTED(RECV_TYPE_ARG2, $[2],
1420 [Define to the type of arg 2 for recv.])
1421 AC_DEFINE_UNQUOTED(RECV_TYPE_ARG3, $[3],
1422 [Define to the type of arg 3 for recv.])
1423 AC_DEFINE_UNQUOTED(RECV_TYPE_ARG4, $[4],
1424 [Define to the type of arg 4 for recv.])
1425 AC_DEFINE_UNQUOTED(RECV_TYPE_RETV, $[5],
1426 [Define to the function return type for recv.])
1428 AC_DEFINE_UNQUOTED(HAVE_RECV, 1,
1429 [Define to 1 if you have the recv function.])
1430 curl_cv_func_recv="yes"
1433 AC_MSG_ERROR([Unable to link function recv])
1438 dnl CURL_CHECK_FUNC_SEND
1439 dnl -------------------------------------------------
1440 dnl Test if the socket send() function is available,
1441 dnl and check its return type and the types of its
1442 dnl arguments. If the function succeeds HAVE_SEND
1443 dnl will be defined, defining the types of the arguments
1444 dnl in SEND_TYPE_ARG1, SEND_TYPE_ARG2, SEND_TYPE_ARG3
1445 dnl and SEND_TYPE_ARG4, defining the type of the function
1446 dnl return value in SEND_TYPE_RETV, and also defining the
1447 dnl type qualifier of second argument in SEND_QUAL_ARG2.
1449 AC_DEFUN([CURL_CHECK_FUNC_SEND], [
1450 AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1451 AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1452 AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1454 AC_MSG_CHECKING([for send])
1458 #ifdef HAVE_WINDOWS_H
1459 #ifndef WIN32_LEAN_AND_MEAN
1460 #define WIN32_LEAN_AND_MEAN
1462 #include <windows.h>
1463 #ifdef HAVE_WINSOCK2_H
1464 #include <winsock2.h>
1466 #ifdef HAVE_WINSOCK_H
1467 #include <winsock.h>
1471 #ifdef HAVE_SYS_TYPES_H
1472 #include <sys/types.h>
1474 #ifdef HAVE_SYS_SOCKET_H
1475 #include <sys/socket.h>
1482 AC_MSG_RESULT([yes])
1489 if test "$curl_cv_send" = "yes"; then
1490 AC_CACHE_CHECK([types of args and return type for send],
1491 [curl_cv_func_send_args], [
1492 curl_cv_func_send_args="unknown"
1493 for send_retv in 'int' 'ssize_t'; do
1494 for send_arg1 in 'int' 'ssize_t' 'SOCKET'; do
1495 for send_arg2 in 'char *' 'void *' 'const char *' 'const void *'; do
1496 for send_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
1497 for send_arg4 in 'int' 'unsigned int'; do
1498 if test "$curl_cv_func_send_args" = "unknown"; then
1502 #ifdef HAVE_WINDOWS_H
1503 #ifndef WIN32_LEAN_AND_MEAN
1504 #define WIN32_LEAN_AND_MEAN
1506 #include <windows.h>
1507 #ifdef HAVE_WINSOCK2_H
1508 #include <winsock2.h>
1510 #ifdef HAVE_WINSOCK_H
1511 #include <winsock.h>
1514 #define SENDCALLCONV PASCAL
1516 #ifdef HAVE_SYS_TYPES_H
1517 #include <sys/types.h>
1519 #ifdef HAVE_SYS_SOCKET_H
1520 #include <sys/socket.h>
1522 #define SENDCALLCONV
1524 extern $send_retv SENDCALLCONV
1525 send($send_arg1, $send_arg2, $send_arg3, $send_arg4);
1530 $send_retv res = send(s, 0, len, flags);
1533 curl_cv_func_send_args="$send_arg1,$send_arg2,$send_arg3,$send_arg4,$send_retv"
1542 if test "$curl_cv_func_send_args" = "unknown"; then
1543 AC_MSG_ERROR([Cannot find proper types to use for send args])
1545 send_prev_IFS=$IFS; IFS=','
1546 set dummy `echo "$curl_cv_func_send_args" | sed 's/\*/\*/g'`
1550 send_qual_type_arg2=$[2]
1552 AC_DEFINE_UNQUOTED(SEND_TYPE_ARG1, $[1],
1553 [Define to the type of arg 1 for send.])
1554 AC_DEFINE_UNQUOTED(SEND_TYPE_ARG3, $[3],
1555 [Define to the type of arg 3 for send.])
1556 AC_DEFINE_UNQUOTED(SEND_TYPE_ARG4, $[4],
1557 [Define to the type of arg 4 for send.])
1558 AC_DEFINE_UNQUOTED(SEND_TYPE_RETV, $[5],
1559 [Define to the function return type for send.])
1563 case $prev_sh_opts in
1571 case "$send_qual_type_arg2" in
1573 send_qual_arg2=const
1574 send_type_arg2=`echo $send_qual_type_arg2 | sed 's/^const //'`
1578 send_type_arg2=$send_qual_type_arg2
1582 AC_DEFINE_UNQUOTED(SEND_QUAL_ARG2, $send_qual_arg2,
1583 [Define to the type qualifier of arg 2 for send.])
1584 AC_DEFINE_UNQUOTED(SEND_TYPE_ARG2, $send_type_arg2,
1585 [Define to the type of arg 2 for send.])
1587 case $prev_sh_opts in
1595 AC_DEFINE_UNQUOTED(HAVE_SEND, 1,
1596 [Define to 1 if you have the send function.])
1597 curl_cv_func_send="yes"
1600 AC_MSG_ERROR([Unable to link function send])
1604 dnl CURL_CHECK_MSG_NOSIGNAL
1605 dnl -------------------------------------------------
1606 dnl Check for MSG_NOSIGNAL
1608 AC_DEFUN([CURL_CHECK_MSG_NOSIGNAL], [
1609 AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1610 AC_CACHE_CHECK([for MSG_NOSIGNAL], [curl_cv_msg_nosignal], [
1614 #ifdef HAVE_WINDOWS_H
1615 #ifndef WIN32_LEAN_AND_MEAN
1616 #define WIN32_LEAN_AND_MEAN
1618 #include <windows.h>
1619 #ifdef HAVE_WINSOCK2_H
1620 #include <winsock2.h>
1622 #ifdef HAVE_WINSOCK_H
1623 #include <winsock.h>
1627 #ifdef HAVE_SYS_TYPES_H
1628 #include <sys/types.h>
1630 #ifdef HAVE_SYS_SOCKET_H
1631 #include <sys/socket.h>
1635 int flag=MSG_NOSIGNAL;
1638 curl_cv_msg_nosignal="yes"
1640 curl_cv_msg_nosignal="no"
1643 case "$curl_cv_msg_nosignal" in
1645 AC_DEFINE_UNQUOTED(HAVE_MSG_NOSIGNAL, 1,
1646 [Define to 1 if you have the MSG_NOSIGNAL flag.])
1652 dnl CURL_CHECK_STRUCT_TIMEVAL
1653 dnl -------------------------------------------------
1654 dnl Check for timeval struct
1656 AC_DEFUN([CURL_CHECK_STRUCT_TIMEVAL], [
1657 AC_REQUIRE([AC_HEADER_TIME])dnl
1658 AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1659 AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1660 AC_CHECK_HEADERS(sys/types.h sys/time.h time.h sys/socket.h)
1661 AC_CACHE_CHECK([for struct timeval], [curl_cv_struct_timeval], [
1665 #ifdef HAVE_WINDOWS_H
1666 #ifndef WIN32_LEAN_AND_MEAN
1667 #define WIN32_LEAN_AND_MEAN
1669 #include <windows.h>
1670 #ifdef HAVE_WINSOCK2_H
1671 #include <winsock2.h>
1673 #ifdef HAVE_WINSOCK_H
1674 #include <winsock.h>
1678 #ifdef HAVE_SYS_TYPES_H
1679 #include <sys/types.h>
1681 #ifdef HAVE_SYS_TIME_H
1682 #include <sys/time.h>
1683 #ifdef TIME_WITH_SYS_TIME
1691 #ifdef HAVE_SYS_SOCKET_H
1692 #include <sys/socket.h>
1700 curl_cv_struct_timeval="yes"
1702 curl_cv_struct_timeval="no"
1705 case "$curl_cv_struct_timeval" in
1707 AC_DEFINE_UNQUOTED(HAVE_STRUCT_TIMEVAL, 1,
1708 [Define to 1 if you have the timeval struct.])
1714 dnl TYPE_SIG_ATOMIC_T
1715 dnl -------------------------------------------------
1716 dnl Check if the sig_atomic_t type is available, and
1717 dnl verify if it is already defined as volatile.
1719 AC_DEFUN([TYPE_SIG_ATOMIC_T], [
1720 AC_CHECK_HEADERS(signal.h)
1721 AC_CHECK_TYPE([sig_atomic_t],[
1722 AC_DEFINE(HAVE_SIG_ATOMIC_T, 1,
1723 [Define to 1 if sig_atomic_t is an available typedef.])
1725 #ifdef HAVE_SIGNAL_H
1729 case "$ac_cv_type_sig_atomic_t" in
1732 AC_MSG_CHECKING([if sig_atomic_t is already defined as volatile])
1735 #ifdef HAVE_SIGNAL_H
1739 static volatile sig_atomic_t dummy = 0;
1743 curl_cv_sig_atomic_t_volatile="no"
1745 AC_MSG_RESULT([yes])
1746 curl_cv_sig_atomic_t_volatile="yes"
1749 if test "$curl_cv_sig_atomic_t_volatile" = "yes"; then
1750 AC_DEFINE(HAVE_SIG_ATOMIC_T_VOLATILE, 1,
1751 [Define to 1 if sig_atomic_t is already defined as volatile.])
1759 dnl -------------------------------------------------
1760 dnl Check for in_addr_t: it is used to receive the return code of inet_addr()
1761 dnl and a few other things.
1763 AC_DEFUN([TYPE_IN_ADDR_T], [
1764 AC_CHECK_TYPE([in_addr_t], ,[
1765 dnl in_addr_t not available
1766 AC_CACHE_CHECK([for in_addr_t equivalent],
1767 [curl_cv_in_addr_t_equiv], [
1768 curl_cv_in_addr_t_equiv="unknown"
1769 for t in "unsigned long" int size_t unsigned long; do
1770 if test "$curl_cv_in_addr_t_equiv" = "unknown"; then
1774 #ifdef HAVE_WINDOWS_H
1775 #ifndef WIN32_LEAN_AND_MEAN
1776 #define WIN32_LEAN_AND_MEAN
1778 #include <windows.h>
1779 #ifdef HAVE_WINSOCK2_H
1780 #include <winsock2.h>
1782 #ifdef HAVE_WINSOCK_H
1783 #include <winsock.h>
1787 #ifdef HAVE_SYS_TYPES_H
1788 #include <sys/types.h>
1790 #ifdef HAVE_SYS_SOCKET_H
1791 #include <sys/socket.h>
1793 #ifdef HAVE_NETINET_IN_H
1794 #include <netinet/in.h>
1796 #ifdef HAVE_ARPA_INET_H
1797 #include <arpa/inet.h>
1801 $t data = inet_addr ("1.2.3.4");
1804 curl_cv_in_addr_t_equiv="$t"
1809 case "$curl_cv_in_addr_t_equiv" in
1811 AC_MSG_ERROR([Cannot find a type to use in place of in_addr_t])
1814 AC_DEFINE_UNQUOTED(in_addr_t, $curl_cv_in_addr_t_equiv,
1815 [Type to use in place of in_addr_t when system does not provide it.])
1820 #ifdef HAVE_WINDOWS_H
1821 #ifndef WIN32_LEAN_AND_MEAN
1822 #define WIN32_LEAN_AND_MEAN
1824 #include <windows.h>
1825 #ifdef HAVE_WINSOCK2_H
1826 #include <winsock2.h>
1828 #ifdef HAVE_WINSOCK_H
1829 #include <winsock.h>
1833 #ifdef HAVE_SYS_TYPES_H
1834 #include <sys/types.h>
1836 #ifdef HAVE_SYS_SOCKET_H
1837 #include <sys/socket.h>
1839 #ifdef HAVE_NETINET_IN_H
1840 #include <netinet/in.h>
1842 #ifdef HAVE_ARPA_INET_H
1843 #include <arpa/inet.h>
1850 dnl CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC
1851 dnl -------------------------------------------------
1852 dnl Check if monotonic clock_gettime is available.
1854 AC_DEFUN([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC], [
1855 AC_REQUIRE([AC_HEADER_TIME])dnl
1856 AC_CHECK_HEADERS(sys/types.h sys/time.h time.h)
1857 AC_MSG_CHECKING([for monotonic clock_gettime])
1859 if test "x$dontwant_rt" = "xno" ; then
1862 #ifdef HAVE_SYS_TYPES_H
1863 #include <sys/types.h>
1865 #ifdef HAVE_SYS_TIME_H
1866 #include <sys/time.h>
1867 #ifdef TIME_WITH_SYS_TIME
1877 (void)clock_gettime(CLOCK_MONOTONIC, &ts);
1880 AC_MSG_RESULT([yes])
1881 curl_func_clock_gettime="yes"
1884 curl_func_clock_gettime="no"
1887 dnl Definition of HAVE_CLOCK_GETTIME_MONOTONIC is intentionally postponed
1888 dnl until library linking and run-time checks for clock_gettime succeed.
1892 dnl CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC
1893 dnl -------------------------------------------------
1894 dnl If monotonic clock_gettime is available then,
1895 dnl check and prepended to LIBS any needed libraries.
1897 AC_DEFUN([CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC], [
1898 AC_REQUIRE([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC])dnl
1900 if test "$curl_func_clock_gettime" = "yes"; then
1902 AC_MSG_CHECKING([for clock_gettime in libraries])
1904 curl_cv_save_LIBS="$LIBS"
1905 curl_cv_gclk_LIBS="unknown"
1907 for x_xlibs in '' '-lrt' '-lposix4' ; do
1908 if test "$curl_cv_gclk_LIBS" = "unknown"; then
1909 if test -z "$x_xlibs"; then
1910 LIBS="$curl_cv_save_LIBS"
1912 LIBS="$x_xlibs $curl_cv_save_LIBS"
1916 #ifdef HAVE_SYS_TYPES_H
1917 #include <sys/types.h>
1919 #ifdef HAVE_SYS_TIME_H
1920 #include <sys/time.h>
1921 #ifdef TIME_WITH_SYS_TIME
1931 (void)clock_gettime(CLOCK_MONOTONIC, &ts);
1934 curl_cv_gclk_LIBS="$x_xlibs"
1939 LIBS="$curl_cv_save_LIBS"
1941 case X-"$curl_cv_gclk_LIBS" in
1943 AC_MSG_RESULT([cannot find clock_gettime])
1944 AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
1945 curl_func_clock_gettime="no"
1948 AC_MSG_RESULT([no additional lib required])
1949 curl_func_clock_gettime="yes"
1952 if test -z "$curl_cv_save_LIBS"; then
1953 LIBS="$curl_cv_gclk_LIBS"
1955 LIBS="$curl_cv_gclk_LIBS $curl_cv_save_LIBS"
1957 AC_MSG_RESULT([$curl_cv_gclk_LIBS])
1958 curl_func_clock_gettime="yes"
1962 dnl only do runtime verification when not cross-compiling
1963 if test "x$cross_compiling" != "xyes" &&
1964 test "$curl_func_clock_gettime" = "yes"; then
1965 AC_MSG_CHECKING([if monotonic clock_gettime works])
1968 #ifdef HAVE_STDLIB_H
1971 #ifdef HAVE_SYS_TYPES_H
1972 #include <sys/types.h>
1974 #ifdef HAVE_SYS_TIME_H
1975 #include <sys/time.h>
1976 #ifdef TIME_WITH_SYS_TIME
1986 if (0 == clock_gettime(CLOCK_MONOTONIC, &ts))
1992 AC_MSG_RESULT([yes])
1995 AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
1996 curl_func_clock_gettime="no"
1997 LIBS="$curl_cv_save_LIBS"
2001 case "$curl_func_clock_gettime" in
2003 AC_DEFINE_UNQUOTED(HAVE_CLOCK_GETTIME_MONOTONIC, 1,
2004 [Define to 1 if you have the clock_gettime function and monotonic timer.])
2013 dnl CURL_CHECK_LIBS_CONNECT
2014 dnl -------------------------------------------------
2015 dnl Verify if network connect function is already available
2016 dnl using current libraries or if another one is required.
2018 AC_DEFUN([CURL_CHECK_LIBS_CONNECT], [
2019 AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
2020 AC_MSG_CHECKING([for connect in libraries])
2021 tst_connect_save_LIBS="$LIBS"
2022 tst_connect_need_LIBS="unknown"
2023 for tst_lib in '' '-lsocket' ; do
2024 if test "$tst_connect_need_LIBS" = "unknown"; then
2025 LIBS="$tst_lib $tst_connect_save_LIBS"
2028 $curl_includes_winsock2
2029 #ifndef HAVE_WINDOWS_H
2030 int connect(int, void*, int);
2033 if(0 != connect(0, 0, 0))
2037 tst_connect_need_LIBS="$tst_lib"
2041 LIBS="$tst_connect_save_LIBS"
2043 case X-"$tst_connect_need_LIBS" in
2045 AC_MSG_RESULT([cannot find connect])
2046 AC_MSG_ERROR([cannot find connect function in libraries.])
2049 AC_MSG_RESULT([yes])
2052 AC_MSG_RESULT([$tst_connect_need_LIBS])
2053 LIBS="$tst_connect_need_LIBS $tst_connect_save_LIBS"
2059 dnl CURL_DEFINE_UNQUOTED (VARIABLE, [VALUE])
2060 dnl -------------------------------------------------
2061 dnl Like AC_DEFINE_UNQUOTED this macro will define a C preprocessor
2062 dnl symbol that can be further used in custom template configuration
2063 dnl files. This macro, unlike AC_DEFINE_UNQUOTED, does not use a third
2064 dnl argument for the description. Symbol definitions done with this
2065 dnl macro are intended to be exclusively used in handcrafted *.h.in
2066 dnl template files. Contrary to what AC_DEFINE_UNQUOTED does, this one
2067 dnl prevents autoheader generation and insertion of symbol template
2068 dnl stub and definition into the first configuration header file. Do
2069 dnl not use this macro as a replacement for AC_DEFINE_UNQUOTED, each
2070 dnl one serves different functional needs.
2072 AC_DEFUN([CURL_DEFINE_UNQUOTED], [
2073 cat >>confdefs.h <<_EOF
2074 [@%:@define] $1 ifelse($#, 2, [$2], 1)
2079 dnl CURL_CONFIGURE_LONG
2080 dnl -------------------------------------------------
2081 dnl Find out the size of long as reported by sizeof() and define
2082 dnl CURL_SIZEOF_LONG as appropriate to be used in template file
2083 dnl include/curl/curlbuild.h.in to properly configure the library.
2084 dnl The size of long is a build time characteristic and as such
2085 dnl must be recorded in curlbuild.h
2087 AC_DEFUN([CURL_CONFIGURE_LONG], [
2088 if test -z "$ac_cv_sizeof_long" ||
2089 test "$ac_cv_sizeof_long" -eq "0"; then
2090 AC_MSG_ERROR([cannot find out size of long.])
2092 CURL_DEFINE_UNQUOTED([CURL_SIZEOF_LONG], [$ac_cv_sizeof_long])
2096 dnl CURL_CONFIGURE_CURL_SOCKLEN_T
2097 dnl -------------------------------------------------
2098 dnl Find out suitable curl_socklen_t data type definition and size, making
2099 dnl appropriate definitions for template file include/curl/curlbuild.h.in
2100 dnl to properly configure and use the library.
2102 dnl The need for the curl_socklen_t definition arises mainly to properly
2103 dnl interface HP-UX systems which on one hand have a typedef'ed socklen_t
2104 dnl data type which is 32 or 64-Bit wide depending on the data model being
2105 dnl used, and that on the other hand is only actually used when interfacing
2106 dnl the X/Open sockets provided in the xnet library.
2108 AC_DEFUN([CURL_CONFIGURE_CURL_SOCKLEN_T], [
2109 AC_REQUIRE([CURL_INCLUDES_WS2TCPIP])dnl
2110 AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])dnl
2111 AC_REQUIRE([CURL_PREPROCESS_CALLCONV])dnl
2113 AC_BEFORE([$0], [CURL_CONFIGURE_PULL_SYS_POLL])dnl
2115 AC_MSG_CHECKING([for curl_socklen_t data type])
2116 curl_typeof_curl_socklen_t="unknown"
2117 for arg1 in int SOCKET; do
2118 for arg2 in 'struct sockaddr' void; do
2119 for t in socklen_t int size_t 'unsigned int' long 'unsigned long' void; do
2120 if test "$curl_typeof_curl_socklen_t" = "unknown"; then
2123 $curl_includes_ws2tcpip
2124 $curl_includes_sys_socket
2125 $curl_preprocess_callconv
2126 extern int FUNCALLCONV getpeername($arg1, $arg2 *, $t *);
2129 if(0 != getpeername(0, 0, lenptr))
2133 curl_typeof_curl_socklen_t="$t"
2139 for t in socklen_t int; do
2140 if test "$curl_typeof_curl_socklen_t" = "void"; then
2143 $curl_includes_sys_socket
2144 typedef $t curl_socklen_t;
2146 curl_socklen_t dummy;
2149 curl_typeof_curl_socklen_t="$t"
2153 AC_MSG_RESULT([$curl_typeof_curl_socklen_t])
2154 if test "$curl_typeof_curl_socklen_t" = "void" ||
2155 test "$curl_typeof_curl_socklen_t" = "unknown"; then
2156 AC_MSG_ERROR([cannot find data type for curl_socklen_t.])
2159 AC_MSG_CHECKING([size of curl_socklen_t])
2160 curl_sizeof_curl_socklen_t="unknown"
2161 curl_pull_headers_socklen_t="unknown"
2162 if test "$curl_cv_header_ws2tcpip_h" = "yes"; then
2163 tst_pull_header_checks='none ws2tcpip'
2166 tst_pull_header_checks='none systypes syssocket'
2167 tst_size_checks='4 8 2'
2169 for tst_size in $tst_size_checks; do
2170 for tst_pull_headers in $tst_pull_header_checks; do
2171 if test "$curl_sizeof_curl_socklen_t" = "unknown"; then
2172 case $tst_pull_headers in
2174 tmp_includes="$curl_includes_ws2tcpip"
2177 tmp_includes="$curl_includes_sys_types"
2180 tmp_includes="$curl_includes_sys_socket"
2189 typedef $curl_typeof_curl_socklen_t curl_socklen_t;
2190 typedef char dummy_arr[sizeof(curl_socklen_t) == $tst_size ? 1 : -1];
2192 curl_socklen_t dummy;
2195 curl_sizeof_curl_socklen_t="$tst_size"
2196 curl_pull_headers_socklen_t="$tst_pull_headers"
2201 AC_MSG_RESULT([$curl_sizeof_curl_socklen_t])
2202 if test "$curl_sizeof_curl_socklen_t" = "unknown"; then
2203 AC_MSG_ERROR([cannot find out size of curl_socklen_t.])
2206 case $curl_pull_headers_socklen_t in
2208 CURL_DEFINE_UNQUOTED([CURL_PULL_WS2TCPIP_H])
2211 CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_TYPES_H])
2214 CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_TYPES_H])
2215 CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_SOCKET_H])
2218 CURL_DEFINE_UNQUOTED([CURL_TYPEOF_CURL_SOCKLEN_T], [$curl_typeof_curl_socklen_t])
2219 CURL_DEFINE_UNQUOTED([CURL_SIZEOF_CURL_SOCKLEN_T], [$curl_sizeof_curl_socklen_t])
2223 dnl CURL_CONFIGURE_PULL_SYS_POLL
2224 dnl -------------------------------------------------
2225 dnl Find out if system header file sys/poll.h must be included by the
2226 dnl external interface, making appropriate definitions for template file
2227 dnl include/curl/curlbuild.h.in to properly configure and use the library.
2229 dnl The need for the sys/poll.h inclusion arises mainly to properly
2230 dnl interface AIX systems which define macros 'events' and 'revents'.
2232 AC_DEFUN([CURL_CONFIGURE_PULL_SYS_POLL], [
2233 AC_REQUIRE([CURL_INCLUDES_POLL])dnl
2235 tst_poll_events_macro_defined="unknown"
2241 #if defined(events) || defined(revents)
2244 force compilation error
2248 tst_poll_events_macro_defined="yes"
2250 tst_poll_events_macro_defined="no"
2253 if test "$tst_poll_events_macro_defined" = "yes"; then
2254 if test "x$ac_cv_header_sys_poll_h" = "xyes"; then
2255 CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_POLL_H])
2262 dnl CURL_CHECK_FUNC_SELECT
2263 dnl -------------------------------------------------
2264 dnl Test if the socket select() function is available,
2265 dnl and check its return type and the types of its
2266 dnl arguments. If the function succeeds HAVE_SELECT
2267 dnl will be defined, defining the types of the
2268 dnl arguments in SELECT_TYPE_ARG1, SELECT_TYPE_ARG234
2269 dnl and SELECT_TYPE_ARG5, defining the type of the
2270 dnl function return value in SELECT_TYPE_RETV, and
2271 dnl also defining the type qualifier of fifth argument
2272 dnl in SELECT_QUAL_ARG5.
2274 AC_DEFUN([CURL_CHECK_FUNC_SELECT], [
2275 AC_REQUIRE([CURL_CHECK_STRUCT_TIMEVAL])dnl
2276 AC_CHECK_HEADERS(sys/select.h sys/socket.h)
2278 AC_MSG_CHECKING([for select])
2282 #ifdef HAVE_WINDOWS_H
2283 #ifndef WIN32_LEAN_AND_MEAN
2284 #define WIN32_LEAN_AND_MEAN
2286 #include <windows.h>
2287 #ifdef HAVE_WINSOCK2_H
2288 #include <winsock2.h>
2290 #ifdef HAVE_WINSOCK_H
2291 #include <winsock.h>
2295 #ifdef HAVE_SYS_TYPES_H
2296 #include <sys/types.h>
2298 #ifdef HAVE_SYS_TIME_H
2299 #include <sys/time.h>
2300 #ifdef TIME_WITH_SYS_TIME
2308 #ifndef HAVE_WINDOWS_H
2309 #ifdef HAVE_SYS_SELECT_H
2310 #include <sys/select.h>
2312 #ifdef HAVE_SYS_SOCKET_H
2313 #include <sys/socket.h>
2317 select(0, 0, 0, 0, 0);
2320 AC_MSG_RESULT([yes])
2321 curl_cv_select="yes"
2327 if test "$curl_cv_select" = "yes"; then
2328 AC_CACHE_CHECK([types of args and return type for select],
2329 [curl_cv_func_select_args], [
2330 curl_cv_func_select_args="unknown"
2331 for sel_retv in 'int' 'ssize_t'; do
2332 for sel_arg1 in 'int' 'ssize_t' 'size_t' 'unsigned long int' 'unsigned int'; do
2333 for sel_arg234 in 'fd_set *' 'int *' 'void *'; do
2334 for sel_arg5 in 'struct timeval *' 'const struct timeval *'; do
2335 if test "$curl_cv_func_select_args" = "unknown"; then
2339 #ifdef HAVE_WINDOWS_H
2340 #ifndef WIN32_LEAN_AND_MEAN
2341 #define WIN32_LEAN_AND_MEAN
2343 #include <windows.h>
2344 #ifdef HAVE_WINSOCK2_H
2345 #include <winsock2.h>
2347 #ifdef HAVE_WINSOCK_H
2348 #include <winsock.h>
2351 #define SELECTCALLCONV PASCAL
2353 #ifdef HAVE_SYS_TYPES_H
2354 #include <sys/types.h>
2356 #ifdef HAVE_SYS_TIME_H
2357 #include <sys/time.h>
2358 #ifdef TIME_WITH_SYS_TIME
2366 #ifndef HAVE_WINDOWS_H
2367 #ifdef HAVE_SYS_SELECT_H
2368 #include <sys/select.h>
2370 #ifdef HAVE_SYS_SOCKET_H
2371 #include <sys/socket.h>
2373 #define SELECTCALLCONV
2375 #ifndef HAVE_STRUCT_TIMEVAL
2381 extern $sel_retv SELECTCALLCONV select($sel_arg1,
2391 $sel_retv res = select(nfds, rfds, wfds, efds, 0);
2394 curl_cv_func_select_args="$sel_arg1,$sel_arg234,$sel_arg5,$sel_retv"
2402 if test "$curl_cv_func_select_args" = "unknown"; then
2403 AC_MSG_WARN([Cannot find proper types to use for select args])
2404 AC_MSG_WARN([HAVE_SELECT will not be defined])
2406 select_prev_IFS=$IFS; IFS=','
2407 set dummy `echo "$curl_cv_func_select_args" | sed 's/\*/\*/g'`
2408 IFS=$select_prev_IFS
2411 sel_qual_type_arg5=$[3]
2413 AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG1, $[1],
2414 [Define to the type of arg 1 for select.])
2415 AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG234, $[2],
2416 [Define to the type of args 2, 3 and 4 for select.])
2417 AC_DEFINE_UNQUOTED(SELECT_TYPE_RETV, $[4],
2418 [Define to the function return type for select.])
2422 case $prev_sh_opts in
2430 case "$sel_qual_type_arg5" in
2433 sel_type_arg5=`echo $sel_qual_type_arg5 | sed 's/^const //'`
2437 sel_type_arg5=$sel_qual_type_arg5
2441 AC_DEFINE_UNQUOTED(SELECT_QUAL_ARG5, $sel_qual_arg5,
2442 [Define to the type qualifier of arg 5 for select.])
2443 AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG5, $sel_type_arg5,
2444 [Define to the type of arg 5 for select.])
2446 case $prev_sh_opts in
2454 AC_DEFINE_UNQUOTED(HAVE_SELECT, 1,
2455 [Define to 1 if you have the select function.])
2456 curl_cv_func_select="yes"
2462 dnl CURL_VERIFY_RUNTIMELIBS
2463 dnl -------------------------------------------------
2464 dnl Verify that the shared libs found so far can be used when running
2465 dnl programs, since otherwise the situation will create odd configure errors
2466 dnl that are misleading people.
2468 dnl Make sure this test is run BEFORE the first test in the script that
2469 dnl runs anything, which at the time of this writing is the AC_CHECK_SIZEOF
2470 dnl macro. It must also run AFTER all lib-checking macros are complete.
2472 AC_DEFUN([CURL_VERIFY_RUNTIMELIBS], [
2474 dnl this test is of course not sensible if we are cross-compiling!
2475 if test "x$cross_compiling" != xyes; then
2477 dnl just run a program to verify that the libs checked for previous to this
2478 dnl point also is available run-time!
2479 AC_MSG_CHECKING([run-time libs availability])
2486 AC_MSG_RESULT([fine]),
2487 AC_MSG_RESULT([failed])
2488 AC_MSG_ERROR([one or more libs available at link-time are not available run-time. Libs used at link-time: $LIBS])
2491 dnl if this test fails, configure has already stopped
2496 dnl CURL_CHECK_VARIADIC_MACROS
2497 dnl -------------------------------------------------
2498 dnl Check compiler support of variadic macros
2500 AC_DEFUN([CURL_CHECK_VARIADIC_MACROS], [
2501 AC_CACHE_CHECK([for compiler support of C99 variadic macro style],
2502 [curl_cv_variadic_macros_c99], [
2505 #define c99_vmacro3(first, ...) fun3(first, __VA_ARGS__)
2506 #define c99_vmacro2(first, ...) fun2(first, __VA_ARGS__)
2507 int fun3(int arg1, int arg2, int arg3);
2508 int fun2(int arg1, int arg2);
2509 int fun3(int arg1, int arg2, int arg3)
2510 { return arg1 + arg2 + arg3; }
2511 int fun2(int arg1, int arg2)
2512 { return arg1 + arg2; }
2514 int res3 = c99_vmacro3(1, 2, 3);
2515 int res2 = c99_vmacro2(1, 2);
2518 curl_cv_variadic_macros_c99="yes"
2520 curl_cv_variadic_macros_c99="no"
2523 case "$curl_cv_variadic_macros_c99" in
2525 AC_DEFINE_UNQUOTED(HAVE_VARIADIC_MACROS_C99, 1,
2526 [Define to 1 if compiler supports C99 variadic macro style.])
2529 AC_CACHE_CHECK([for compiler support of old gcc variadic macro style],
2530 [curl_cv_variadic_macros_gcc], [
2533 #define gcc_vmacro3(first, args...) fun3(first, args)
2534 #define gcc_vmacro2(first, args...) fun2(first, args)
2535 int fun3(int arg1, int arg2, int arg3);
2536 int fun2(int arg1, int arg2);
2537 int fun3(int arg1, int arg2, int arg3)
2538 { return arg1 + arg2 + arg3; }
2539 int fun2(int arg1, int arg2)
2540 { return arg1 + arg2; }
2542 int res3 = gcc_vmacro3(1, 2, 3);
2543 int res2 = gcc_vmacro2(1, 2);
2546 curl_cv_variadic_macros_gcc="yes"
2548 curl_cv_variadic_macros_gcc="no"
2551 case "$curl_cv_variadic_macros_gcc" in
2553 AC_DEFINE_UNQUOTED(HAVE_VARIADIC_MACROS_GCC, 1,
2554 [Define to 1 if compiler supports old gcc variadic macro style.])
2560 dnl CURL_CHECK_CA_BUNDLE
2561 dnl -------------------------------------------------
2562 dnl Check if a default ca-bundle should be used
2564 dnl regarding the paths this will scan:
2565 dnl /etc/ssl/certs/ca-certificates.crt Debian systems
2566 dnl /etc/pki/tls/certs/ca-bundle.crt Redhat and Mandriva
2567 dnl /usr/share/ssl/certs/ca-bundle.crt old(er) Redhat
2568 dnl /usr/local/share/certs/ca-root-nss.crt FreeBSD
2569 dnl /etc/ssl/cert.pem OpenBSD, FreeBSD (symlink)
2570 dnl /etc/ssl/certs/ (ca path) SUSE
2572 AC_DEFUN([CURL_CHECK_CA_BUNDLE], [
2574 AC_MSG_CHECKING([default CA cert bundle/path])
2576 AC_ARG_WITH(ca-bundle,
2577 AC_HELP_STRING([--with-ca-bundle=FILE],
2578 [Path to a file containing CA certificates (example: /etc/ca-bundle.crt)])
2579 AC_HELP_STRING([--without-ca-bundle], [Don't use a default CA bundle]),
2582 if test "x$want_ca" = "xyes"; then
2583 AC_MSG_ERROR([--with-ca-bundle=FILE requires a path to the CA bundle])
2586 [ want_ca="unset" ])
2587 AC_ARG_WITH(ca-path,
2588 AC_HELP_STRING([--with-ca-path=DIRECTORY],
2589 [Path to a directory containing CA certificates stored individually, with \
2590 their filenames in a hash format. This option can be used with OpenSSL, \
2591 GnuTLS and PolarSSL backends. Refer to OpenSSL c_rehash for details. \
2592 (example: /etc/certificates)])
2593 AC_HELP_STRING([--without-ca-path], [Don't use a default CA path]),
2595 want_capath="$withval"
2596 if test "x$want_capath" = "xyes"; then
2597 AC_MSG_ERROR([--with-ca-path=DIRECTORY requires a path to the CA path directory])
2600 [ want_capath="unset"])
2602 ca_warning=" (warning: certs not found)"
2603 capath_warning=" (warning: certs not found)"
2606 if test "x$want_ca" != "xno" -a "x$want_ca" != "xunset" -a \
2607 "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
2610 capath="$want_capath"
2611 elif test "x$want_ca" != "xno" -a "x$want_ca" != "xunset"; then
2612 dnl --with-ca-bundle given
2615 elif test "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
2616 dnl --with-ca-path given
2617 if test "x$OPENSSL_ENABLED" != "x1" -a "x$GNUTLS_ENABLED" != "x1" -a "x$POLARSSL_ENABLED" != "x1"; then
2618 AC_MSG_ERROR([--with-ca-path only works with OpenSSL, GnuTLS or PolarSSL])
2620 capath="$want_capath"
2623 dnl first try autodetecting a CA bundle , then a CA path
2624 dnl both autodetections can be skipped by --without-ca-*
2627 if test "x$cross_compiling" != "xyes"; then
2628 dnl NOT cross-compiling and...
2629 dnl neither of the --with-ca-* options are provided
2630 if test "x$want_ca" = "xunset"; then
2631 dnl the path we previously would have installed the curl ca bundle
2632 dnl to, and thus we now check for an already existing cert in that
2633 dnl place in case we find no other
2634 if test "x$prefix" != xNONE; then
2635 cac="${prefix}/share/curl/curl-ca-bundle.crt"
2637 cac="$ac_default_prefix/share/curl/curl-ca-bundle.crt"
2640 for a in /etc/ssl/certs/ca-certificates.crt \
2641 /etc/pki/tls/certs/ca-bundle.crt \
2642 /usr/share/ssl/certs/ca-bundle.crt \
2643 /usr/local/share/certs/ca-root-nss.crt \
2646 if test -f "$a"; then
2652 if test "x$want_capath" = "xunset" -a "x$ca" = "xno" -a \
2653 "x$OPENSSL_ENABLED" = "x1"; then
2654 check_capath="/etc/ssl/certs/"
2657 dnl no option given and cross-compiling
2658 AC_MSG_WARN([skipped the ca-cert path detection when cross-compiling])
2662 if test "x$ca" = "xno" || test -f "$ca"; then
2666 if test "x$capath" != "xno"; then
2667 check_capath="$capath"
2670 if test ! -z "$check_capath"; then
2671 for a in "$check_capath"; do
2672 if test -d "$a" && ls "$a"/[[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]].0 >/dev/null 2>/dev/null; then
2673 if test "x$capath" = "xno"; then
2682 if test "x$capath" = "xno"; then
2686 if test "x$ca" != "xno"; then
2687 CURL_CA_BUNDLE='"'$ca'"'
2688 AC_DEFINE_UNQUOTED(CURL_CA_BUNDLE, "$ca", [Location of default ca bundle])
2689 AC_SUBST(CURL_CA_BUNDLE)
2690 AC_MSG_RESULT([$ca])
2692 if test "x$capath" != "xno"; then
2693 CURL_CA_PATH="\"$capath\""
2694 AC_DEFINE_UNQUOTED(CURL_CA_PATH, "$capath", [Location of default ca path])
2695 AC_MSG_RESULT([$capath (capath)])
2697 if test "x$ca" = "xno" && test "x$capath" = "xno"; then
2701 AC_MSG_CHECKING([whether to use builtin CA store of SSL library])
2702 AC_ARG_WITH(ca-fallback,
2703 AC_HELP_STRING([--with-ca-fallback], [Use the built in CA store of the SSL library])
2704 AC_HELP_STRING([--without-ca-fallback], [Don't use the built in CA store of the SSL library]),
2706 if test "x$with_ca_fallback" != "xyes" -a "x$with_ca_fallback" != "xno"; then
2707 AC_MSG_ERROR([--with-ca-fallback only allows yes or no as parameter])
2710 [ with_ca_fallback="no"])
2711 AC_MSG_RESULT([$with_ca_fallback])
2712 if test "x$with_ca_fallback" = "xyes"; then
2713 if test "x$OPENSSL_ENABLED" != "x1" -a "x$GNUTLS_ENABLED" != "x1"; then
2714 AC_MSG_ERROR([--with-ca-fallback only works with OpenSSL or GnuTLS])
2716 AC_DEFINE_UNQUOTED(CURL_CA_FALLBACK, 1, [define "1" to use built in CA store of SSL library ])
2721 dnl DO_CURL_OFF_T_CHECK (TYPE, SIZE)
2722 dnl -------------------------------------------------
2723 dnl Internal macro for CURL_CONFIGURE_CURL_OFF_T
2725 AC_DEFUN([DO_CURL_OFF_T_CHECK], [
2726 AC_REQUIRE([CURL_INCLUDES_INTTYPES])dnl
2727 if test "$curl_typeof_curl_off_t" = "unknown" && test ! -z "$1"; then
2731 case XC_SH_TR_SH([$1]) in
2733 tmp_includes="$curl_includes_inttypes"
2734 tmp_source="char f@<:@@:>@ = PRId64;"
2738 tmp_includes="$curl_includes_inttypes"
2739 tmp_source="char f@<:@@:>@ = PRId32;"
2743 tmp_includes="$curl_includes_inttypes"
2744 tmp_source="char f@<:@@:>@ = PRId16;"
2751 typedef $1 curl_off_t;
2752 typedef char dummy_arr[sizeof(curl_off_t) == $2 ? 1 : -1];
2758 if test -z "$tmp_fmt"; then
2759 curl_typeof_curl_off_t="$1"
2760 curl_sizeof_curl_off_t="$2"
2762 CURL_CHECK_DEF([$tmp_fmt], [$curl_includes_inttypes], [silent])
2763 AS_VAR_PUSHDEF([tmp_HaveFmtDef], [curl_cv_have_def_$tmp_fmt])dnl
2764 AS_VAR_PUSHDEF([tmp_FmtDef], [curl_cv_def_$tmp_fmt])dnl
2765 if test AS_VAR_GET(tmp_HaveFmtDef) = "yes"; then
2766 curl_format_curl_off_t=AS_VAR_GET(tmp_FmtDef)
2767 curl_typeof_curl_off_t="$1"
2768 curl_sizeof_curl_off_t="$2"
2770 AS_VAR_POPDEF([tmp_FmtDef])dnl
2771 AS_VAR_POPDEF([tmp_HaveFmtDef])dnl
2778 dnl DO_CURL_OFF_T_SUFFIX_CHECK (TYPE)
2779 dnl -------------------------------------------------
2780 dnl Internal macro for CURL_CONFIGURE_CURL_OFF_T
2782 AC_DEFUN([DO_CURL_OFF_T_SUFFIX_CHECK], [
2783 AC_REQUIRE([CURL_INCLUDES_INTTYPES])dnl
2784 AC_MSG_CHECKING([constant suffix string for curl_off_t])
2786 curl_suffix_curl_off_t="unknown"
2787 curl_suffix_curl_off_tu="unknown"
2789 case XC_SH_TR_SH([$1]) in
2790 long_long | __longlong | __longlong_t)
2800 tst_suffixes="LL:i64::"
2803 tst_suffixes="L:i32::"
2806 tst_suffixes="L:i16::"
2809 AC_MSG_ERROR([unexpected data type $1])
2813 old_IFS=$IFS; IFS=':'
2814 for tmp_ssuf in $tst_suffixes ; do
2816 if test "x$curl_suffix_curl_off_t" = "xunknown"; then
2819 tmp_usuf="u$tmp_ssuf"
2822 tmp_usuf="U$tmp_ssuf"
2830 $curl_includes_inttypes
2841 curl_suffix_curl_off_t="$tmp_ssuf"
2842 curl_suffix_curl_off_tu="$tmp_usuf"
2848 if test "x$curl_suffix_curl_off_t" = "xunknown"; then
2849 AC_MSG_ERROR([cannot find constant suffix string for curl_off_t.])
2851 AC_MSG_RESULT([$curl_suffix_curl_off_t])
2852 AC_MSG_CHECKING([constant suffix string for unsigned curl_off_t])
2853 AC_MSG_RESULT([$curl_suffix_curl_off_tu])
2859 dnl CURL_CONFIGURE_CURL_OFF_T
2860 dnl -------------------------------------------------
2861 dnl Find out suitable curl_off_t data type definition and associated
2862 dnl items, and make the appropriate definitions used in template file
2863 dnl include/curl/curlbuild.h.in to properly configure the library.
2865 AC_DEFUN([CURL_CONFIGURE_CURL_OFF_T], [
2866 AC_REQUIRE([CURL_INCLUDES_INTTYPES])dnl
2868 AC_BEFORE([$0],[AC_SYS_LARGEFILE])dnl
2869 AC_BEFORE([$0],[CURL_CONFIGURE_REENTRANT])dnl
2870 AC_BEFORE([$0],[CURL_CHECK_AIX_ALL_SOURCE])dnl
2872 if test -z "$SED"; then
2873 AC_MSG_ERROR([SED not set. Cannot continue without SED being set.])
2876 AC_CHECK_SIZEOF(long)
2877 AC_CHECK_SIZEOF(void*)
2879 if test -z "$ac_cv_sizeof_long" ||
2880 test "$ac_cv_sizeof_long" -eq "0"; then
2881 AC_MSG_ERROR([cannot find out size of long.])
2883 if test -z "$ac_cv_sizeof_voidp" ||
2884 test "$ac_cv_sizeof_voidp" -eq "0"; then
2885 AC_MSG_ERROR([cannot find out size of void*.])
2891 if test "$ac_cv_sizeof_long" -eq "8" &&
2892 test "$ac_cv_sizeof_voidp" -ge "8"; then
2894 elif test "$ac_cv_sizeof_long" -eq "4" &&
2895 test "$ac_cv_sizeof_voidp" -ge "4"; then
2899 dnl DO_CURL_OFF_T_CHECK results are stored in next 3 vars
2901 curl_typeof_curl_off_t="unknown"
2902 curl_sizeof_curl_off_t="unknown"
2903 curl_format_curl_off_t="unknown"
2904 curl_format_curl_off_tu="unknown"
2906 if test "$curl_typeof_curl_off_t" = "unknown"; then
2907 AC_MSG_CHECKING([for 64-bit curl_off_t data type])
2915 DO_CURL_OFF_T_CHECK([$t8], [8])
2917 AC_MSG_RESULT([$curl_typeof_curl_off_t])
2919 if test "$curl_typeof_curl_off_t" = "unknown"; then
2920 AC_MSG_CHECKING([for 32-bit curl_off_t data type])
2926 DO_CURL_OFF_T_CHECK([$t4], [4])
2928 AC_MSG_RESULT([$curl_typeof_curl_off_t])
2930 if test "$curl_typeof_curl_off_t" = "unknown"; then
2931 AC_MSG_ERROR([cannot find data type for curl_off_t.])
2934 AC_MSG_CHECKING([size of curl_off_t])
2935 AC_MSG_RESULT([$curl_sizeof_curl_off_t])
2937 AC_MSG_CHECKING([formatting string directive for curl_off_t])
2938 if test "$curl_format_curl_off_t" != "unknown"; then
2939 x_pull_headers="yes"
2940 curl_format_curl_off_t=`echo "$curl_format_curl_off_t" | "$SED" 's/[["]]//g'`
2941 curl_format_curl_off_tu=`echo "$curl_format_curl_off_t" | "$SED" 's/i$/u/'`
2942 curl_format_curl_off_tu=`echo "$curl_format_curl_off_tu" | "$SED" 's/d$/u/'`
2943 curl_format_curl_off_tu=`echo "$curl_format_curl_off_tu" | "$SED" 's/D$/U/'`
2946 case XC_SH_TR_SH([$curl_typeof_curl_off_t]) in
2947 long_long | __longlong | __longlong_t)
2948 curl_format_curl_off_t="lld"
2949 curl_format_curl_off_tu="llu"
2952 curl_format_curl_off_t="ld"
2953 curl_format_curl_off_tu="lu"
2956 curl_format_curl_off_t="d"
2957 curl_format_curl_off_tu="u"
2960 curl_format_curl_off_t="I64d"
2961 curl_format_curl_off_tu="I64u"
2964 curl_format_curl_off_t="I32d"
2965 curl_format_curl_off_tu="I32u"
2968 curl_format_curl_off_t="I16d"
2969 curl_format_curl_off_tu="I16u"
2972 AC_MSG_ERROR([cannot find print format string for curl_off_t.])
2976 AC_MSG_RESULT(["$curl_format_curl_off_t"])
2978 AC_MSG_CHECKING([formatting string directive for unsigned curl_off_t])
2979 AC_MSG_RESULT(["$curl_format_curl_off_tu"])
2981 DO_CURL_OFF_T_SUFFIX_CHECK([$curl_typeof_curl_off_t])
2983 if test "$x_pull_headers" = "yes"; then
2984 if test "x$ac_cv_header_sys_types_h" = "xyes"; then
2985 CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_TYPES_H])
2987 if test "x$ac_cv_header_stdint_h" = "xyes"; then
2988 CURL_DEFINE_UNQUOTED([CURL_PULL_STDINT_H])
2990 if test "x$ac_cv_header_inttypes_h" = "xyes"; then
2991 CURL_DEFINE_UNQUOTED([CURL_PULL_INTTYPES_H])
2995 CURL_DEFINE_UNQUOTED([CURL_TYPEOF_CURL_OFF_T], [$curl_typeof_curl_off_t])
2996 CURL_DEFINE_UNQUOTED([CURL_FORMAT_CURL_OFF_T], ["$curl_format_curl_off_t"])
2997 CURL_DEFINE_UNQUOTED([CURL_FORMAT_CURL_OFF_TU], ["$curl_format_curl_off_tu"])
2998 CURL_DEFINE_UNQUOTED([CURL_FORMAT_OFF_T], ["%$curl_format_curl_off_t"])
2999 CURL_DEFINE_UNQUOTED([CURL_SIZEOF_CURL_OFF_T], [$curl_sizeof_curl_off_t])
3000 CURL_DEFINE_UNQUOTED([CURL_SUFFIX_CURL_OFF_T], [$curl_suffix_curl_off_t])
3001 CURL_DEFINE_UNQUOTED([CURL_SUFFIX_CURL_OFF_TU], [$curl_suffix_curl_off_tu])
3006 dnl CURL_CHECK_WIN32_LARGEFILE
3007 dnl -------------------------------------------------
3008 dnl Check if curl's WIN32 large file will be used
3010 AC_DEFUN([CURL_CHECK_WIN32_LARGEFILE], [
3011 AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
3012 AC_MSG_CHECKING([whether build target supports WIN32 file API])
3013 curl_win32_file_api="no"
3014 if test "$curl_cv_header_windows_h" = "yes"; then
3015 if test x"$enable_largefile" != "xno"; then
3019 #if !defined(_WIN32_WCE) && \
3020 (defined(__MINGW32__) || \
3021 (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64))))
3024 WIN32 large file API not supported.
3028 curl_win32_file_api="win32_large_files"
3031 if test "$curl_win32_file_api" = "no"; then
3035 #if defined(_WIN32_WCE) || defined(__MINGW32__) || defined(_MSC_VER)
3038 WIN32 small file API not supported.
3042 curl_win32_file_api="win32_small_files"
3046 case "$curl_win32_file_api" in
3048 AC_MSG_RESULT([yes (large file enabled)])
3049 AC_DEFINE_UNQUOTED(USE_WIN32_LARGE_FILES, 1,
3050 [Define to 1 if you are building a Windows target with large file support.])
3053 AC_MSG_RESULT([yes (large file disabled)])
3054 AC_DEFINE_UNQUOTED(USE_WIN32_SMALL_FILES, 1,
3055 [Define to 1 if you are building a Windows target without large file support.])
3063 dnl CURL_EXPORT_PCDIR ($pcdir)
3064 dnl ------------------------
3065 dnl if $pcdir is not empty, set PKG_CONFIG_LIBDIR to $pcdir and export
3067 dnl we need this macro since pkg-config distinguishes among empty and unset
3068 dnl variable while checking PKG_CONFIG_LIBDIR
3071 AC_DEFUN([CURL_EXPORT_PCDIR], [
3072 if test -n "$1"; then
3073 PKG_CONFIG_LIBDIR="$1"
3074 export PKG_CONFIG_LIBDIR
3078 dnl CURL_CHECK_PKGCONFIG ($module, [$pcdir])
3079 dnl ------------------------
3080 dnl search for the pkg-config tool. Set the PKGCONFIG variable to hold the
3081 dnl path to it, or 'no' if not found/present.
3083 dnl If pkg-config is present, check that it has info about the $module or
3084 dnl return "no" anyway!
3086 dnl Optionally PKG_CONFIG_LIBDIR may be given as $pcdir.
3089 AC_DEFUN([CURL_CHECK_PKGCONFIG], [
3090 if test -n "$PKG_CONFIG"; then
3091 PKGCONFIG="$PKG_CONFIG"
3093 AC_PATH_TOOL([PKGCONFIG], [pkg-config], [no],
3094 [$PATH:/usr/bin:/usr/local/bin])
3097 if test "x$PKGCONFIG" != "xno"; then
3098 AC_MSG_CHECKING([for $1 options with pkg-config])
3099 dnl ask pkg-config about $1
3100 itexists=`CURL_EXPORT_PCDIR([$2]) dnl
3101 $PKGCONFIG --exists $1 >/dev/null 2>&1 && echo 1`
3103 if test -z "$itexists"; then
3104 dnl pkg-config does not have info about the given module! set the
3105 dnl variable to 'no'
3109 AC_MSG_RESULT([found])
3115 dnl CURL_GENERATE_CONFIGUREHELP_PM
3116 dnl -------------------------------------------------
3117 dnl Generate test harness configurehelp.pm module, defining and
3118 dnl initializing some perl variables with values which are known
3119 dnl when the configure script runs. For portability reasons, test
3120 dnl harness needs information on how to run the C preprocessor.
3122 AC_DEFUN([CURL_GENERATE_CONFIGUREHELP_PM], [
3123 AC_REQUIRE([AC_PROG_CPP])dnl
3124 tmp_cpp=`eval echo "$ac_cpp" 2>/dev/null`
3125 if test -z "$tmp_cpp"; then
3128 cat >./tests/configurehelp.pm <<_EOF
3129 [@%:@] This is a generated file. Do not edit.
3131 package configurehelp;
3143 @ISA = qw(Exporter);
3149 \$Cpreprocessor = '$tmp_cpp';
3157 dnl Check if $cpp -P should be used for extract define values due to gcc 5
3158 dnl splitting up strings and defines between line outputs. gcc by default
3159 dnl (without -P) will show TEST EINVAL TEST as
3161 dnl # 13 "conftest.c"
3163 dnl # 13 "conftest.c" 3 4
3165 dnl # 13 "conftest.c"
3168 AC_DEFUN([CURL_CPP_P], [
3169 AC_MSG_CHECKING([if cpp -P is needed])
3170 AC_EGREP_CPP([TEST.*TEST], [
3173 ], [cpp=no], [cpp=yes])
3174 AC_MSG_RESULT([$cpp])
3176 dnl we need cpp -P so check if it works then
3177 if test "x$cpp" = "xyes"; then
3178 AC_MSG_CHECKING([if cpp -P works])
3179 OLDCPPFLAGS=$CPPFLAGS
3180 CPPFLAGS="$CPPFLAGS -P"
3181 AC_EGREP_CPP([TEST.*TEST], [
3184 ], [cpp_p=yes], [cpp_p=no])
3185 AC_MSG_RESULT([$cpp_p])
3187 if test "x$cpp_p" = "xno"; then
3188 AC_MSG_WARN([failed to figure out cpp -P alternative])
3195 dnl restore CPPFLAGS
3196 CPPFLAGS=$OLDCPPFLAGS
3206 dnl Check if -mmacosx-version-min, -miphoneos-version-min or any
3207 dnl similar are set manually, otherwise do. And set
3208 dnl -Werror=partial-availability.
3211 AC_DEFUN([CURL_MAC_CFLAGS], [
3220 AC_MSG_CHECKING([for good-to-use Mac CFLAGS])
3221 AC_MSG_RESULT([$tst_cflags]);
3223 if test "$tst_cflags" = "yes"; then
3224 AC_MSG_CHECKING([for *version-min in CFLAGS])
3226 if test -z "$(echo $CFLAGS | grep m.*os.*-version-min)"; then
3227 min="-mmacosx-version-min=10.8"
3228 CFLAGS="$CFLAGS $min"
3230 if test -z "$min"; then
3231 AC_MSG_RESULT([set by user])
3233 AC_MSG_RESULT([$min set])
3237 CFLAGS="$CFLAGS -Werror=partial-availability"
3238 AC_MSG_CHECKING([whether $CC accepts -Werror=partial-availability])
3239 AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
3240 [AC_MSG_RESULT([yes])],
3241 [AC_MSG_RESULT([no])
3242 CFLAGS=$old_CFLAGS])