1: #***************************************************************************
2: # _ _ ____ _
3: # Project ___| | | | _ \| |
4: # / __| | | | |_) | |
5: # | (__| |_| | _ <| |___
6: # \___|\___/|_| \_\_____|
7: #
8: # Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
9: #
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.
13: #
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.
17: #
18: # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: # KIND, either express or implied.
20: #
21: #***************************************************************************
22:
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.
31:
32: AC_DEFUN([CURL_CHECK_DEF], [
33: AC_REQUIRE([CURL_CPP_P])dnl
34: OLDCPPFLAGS=$CPPFLAGS
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.])
41: fi
42: if test -z "$GREP"; then
43: AC_MSG_ERROR([GREP not set. Cannot continue without GREP being set.])
44: fi
45: ifelse($3,,[AC_MSG_CHECKING([for preprocessor definition of $1])])
46: tmp_exp=""
47: AC_PREPROC_IFELSE([
48: AC_LANG_SOURCE(
49: ifelse($2,,,[$2])[[
50: #ifdef $1
51: CURL_DEF_TOKEN $1
52: #endif
53: ]])
54: ],[
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
60: tmp_exp=""
61: fi
62: ])
63: if test -z "$tmp_exp"; then
64: AS_VAR_SET(ac_HaveDef, no)
65: ifelse($3,,[AC_MSG_RESULT([no])])
66: else
67: AS_VAR_SET(ac_HaveDef, yes)
68: AS_VAR_SET(ac_Def, $tmp_exp)
69: ifelse($3,,[AC_MSG_RESULT([$tmp_exp])])
70: fi
71: AS_VAR_POPDEF([ac_Def])dnl
72: AS_VAR_POPDEF([ac_HaveDef])dnl
73: CPPFLAGS=$OLDCPPFLAGS
74: ])
75:
76:
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.
83:
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])])
87: AC_COMPILE_IFELSE([
88: AC_LANG_SOURCE(
89: ifelse($2,,,[$2])[[
90: int main (void)
91: {
92: #ifdef $1
93: return 0;
94: #else
95: force compilation error
96: #endif
97: }
98: ]])
99: ],[
100: tst_symbol_defined="yes"
101: ],[
102: tst_symbol_defined="no"
103: ])
104: if test "$tst_symbol_defined" = "yes"; then
105: AS_VAR_SET(ac_HaveDef, yes)
106: ifelse($3,,[AC_MSG_RESULT([yes])])
107: else
108: AS_VAR_SET(ac_HaveDef, no)
109: ifelse($3,,[AC_MSG_RESULT([no])])
110: fi
111: AS_VAR_POPDEF([ac_HaveDef])dnl
112: ])
113:
114:
115: dnl CURL_CHECK_LIB_XNET
116: dnl -------------------------------------------------
117: dnl Verify if X/Open network library is required.
118:
119: AC_DEFUN([CURL_CHECK_LIB_XNET], [
120: AC_MSG_CHECKING([if X/Open network library is required])
121: tst_lib_xnet_required="no"
122: AC_COMPILE_IFELSE([
123: AC_LANG_SOURCE([[
124: int main (void)
125: {
126: #if defined(__hpux) && defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600)
127: return 0;
128: #elif defined(__hpux) && defined(_XOPEN_SOURCE_EXTENDED)
129: return 0;
130: #else
131: force compilation error
132: #endif
133: }
134: ]])
135: ],[
136: tst_lib_xnet_required="yes"
137: LIBS="-lxnet $LIBS"
138: ])
139: AC_MSG_RESULT([$tst_lib_xnet_required])
140: ])
141:
142:
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.
148:
149: AC_DEFUN([CURL_CHECK_AIX_ALL_SOURCE], [
150: AH_VERBATIM([_ALL_SOURCE],
151: [/* Define to 1 if OS is AIX. */
152: #ifndef _ALL_SOURCE
153: # undef _ALL_SOURCE
154: #endif])
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],[
160: #ifdef _AIX
161: yes_this_is_aix
162: #endif
163: ],[
164: AC_MSG_RESULT([yes])
165: AC_DEFINE(_ALL_SOURCE)
166: ],[
167: AC_MSG_RESULT([no])
168: ])
169: ])
170:
171:
172: dnl CURL_CHECK_HEADER_WINDOWS
173: dnl -------------------------------------------------
174: dnl Check for compilable and valid windows.h header
175:
176: AC_DEFUN([CURL_CHECK_HEADER_WINDOWS], [
177: AC_CACHE_CHECK([for windows.h], [curl_cv_header_windows_h], [
178: AC_COMPILE_IFELSE([
179: AC_LANG_PROGRAM([[
180: #undef inline
181: #ifndef WIN32_LEAN_AND_MEAN
182: #define WIN32_LEAN_AND_MEAN
183: #endif
184: #include <windows.h>
185: ]],[[
186: #if defined(__CYGWIN__) || defined(__CEGCC__)
187: HAVE_WINDOWS_H shall not be defined.
188: #else
189: int dummy=2*WINVER;
190: #endif
191: ]])
192: ],[
193: curl_cv_header_windows_h="yes"
194: ],[
195: curl_cv_header_windows_h="no"
196: ])
197: ])
198: case "$curl_cv_header_windows_h" in
199: yes)
200: AC_DEFINE_UNQUOTED(HAVE_WINDOWS_H, 1,
201: [Define to 1 if you have the windows.h header file.])
202: ;;
203: esac
204: ])
205:
206:
207: dnl CURL_CHECK_NATIVE_WINDOWS
208: dnl -------------------------------------------------
209: dnl Check if building a native Windows target
210:
211: AC_DEFUN([CURL_CHECK_NATIVE_WINDOWS], [
212: AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
213: AC_CACHE_CHECK([whether build target is a native Windows one], [curl_cv_native_windows], [
214: if test "$curl_cv_header_windows_h" = "no"; then
215: curl_cv_native_windows="no"
216: else
217: AC_COMPILE_IFELSE([
218: AC_LANG_PROGRAM([[
219: ]],[[
220: #if defined(__MINGW32__) || defined(__MINGW32CE__) || \
221: (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64)))
222: int dummy=1;
223: #else
224: Not a native Windows build target.
225: #endif
226: ]])
227: ],[
228: curl_cv_native_windows="yes"
229: ],[
230: curl_cv_native_windows="no"
231: ])
232: fi
233: ])
234: AM_CONDITIONAL(DOING_NATIVE_WINDOWS, test "x$curl_cv_native_windows" = xyes)
235: ])
236:
237:
238: dnl CURL_CHECK_HEADER_WINSOCK
239: dnl -------------------------------------------------
240: dnl Check for compilable and valid winsock.h header
241:
242: AC_DEFUN([CURL_CHECK_HEADER_WINSOCK], [
243: AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
244: AC_CACHE_CHECK([for winsock.h], [curl_cv_header_winsock_h], [
245: AC_COMPILE_IFELSE([
246: AC_LANG_PROGRAM([[
247: #undef inline
248: #ifndef WIN32_LEAN_AND_MEAN
249: #define WIN32_LEAN_AND_MEAN
250: #endif
251: #include <windows.h>
252: #include <winsock.h>
253: ]],[[
254: #if defined(__CYGWIN__) || defined(__CEGCC__)
255: HAVE_WINSOCK_H shall not be defined.
256: #else
257: int dummy=WSACleanup();
258: #endif
259: ]])
260: ],[
261: curl_cv_header_winsock_h="yes"
262: ],[
263: curl_cv_header_winsock_h="no"
264: ])
265: ])
266: case "$curl_cv_header_winsock_h" in
267: yes)
268: AC_DEFINE_UNQUOTED(HAVE_WINSOCK_H, 1,
269: [Define to 1 if you have the winsock.h header file.])
270: ;;
271: esac
272: ])
273:
274:
275: dnl CURL_CHECK_HEADER_WINSOCK2
276: dnl -------------------------------------------------
277: dnl Check for compilable and valid winsock2.h header
278:
279: AC_DEFUN([CURL_CHECK_HEADER_WINSOCK2], [
280: AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
281: AC_CACHE_CHECK([for winsock2.h], [curl_cv_header_winsock2_h], [
282: AC_COMPILE_IFELSE([
283: AC_LANG_PROGRAM([[
284: #undef inline
285: #ifndef WIN32_LEAN_AND_MEAN
286: #define WIN32_LEAN_AND_MEAN
287: #endif
288: #include <windows.h>
289: #include <winsock2.h>
290: ]],[[
291: #if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
292: HAVE_WINSOCK2_H shall not be defined.
293: #else
294: int dummy=2*IPPROTO_ESP;
295: #endif
296: ]])
297: ],[
298: curl_cv_header_winsock2_h="yes"
299: ],[
300: curl_cv_header_winsock2_h="no"
301: ])
302: ])
303: case "$curl_cv_header_winsock2_h" in
304: yes)
305: AC_DEFINE_UNQUOTED(HAVE_WINSOCK2_H, 1,
306: [Define to 1 if you have the winsock2.h header file.])
307: ;;
308: esac
309: ])
310:
311:
312: dnl CURL_CHECK_HEADER_WS2TCPIP
313: dnl -------------------------------------------------
314: dnl Check for compilable and valid ws2tcpip.h header
315:
316: AC_DEFUN([CURL_CHECK_HEADER_WS2TCPIP], [
317: AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
318: AC_CACHE_CHECK([for ws2tcpip.h], [curl_cv_header_ws2tcpip_h], [
319: AC_COMPILE_IFELSE([
320: AC_LANG_PROGRAM([[
321: #undef inline
322: #ifndef WIN32_LEAN_AND_MEAN
323: #define WIN32_LEAN_AND_MEAN
324: #endif
325: #include <windows.h>
326: #include <winsock2.h>
327: #include <ws2tcpip.h>
328: ]],[[
329: #if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
330: HAVE_WS2TCPIP_H shall not be defined.
331: #else
332: int dummy=2*IP_PKTINFO;
333: #endif
334: ]])
335: ],[
336: curl_cv_header_ws2tcpip_h="yes"
337: ],[
338: curl_cv_header_ws2tcpip_h="no"
339: ])
340: ])
341: case "$curl_cv_header_ws2tcpip_h" in
342: yes)
343: AC_DEFINE_UNQUOTED(HAVE_WS2TCPIP_H, 1,
344: [Define to 1 if you have the ws2tcpip.h header file.])
345: ;;
346: esac
347: ])
348:
349:
350: dnl CURL_CHECK_HEADER_WINLDAP
351: dnl -------------------------------------------------
352: dnl Check for compilable and valid winldap.h header
353:
354: AC_DEFUN([CURL_CHECK_HEADER_WINLDAP], [
355: AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
356: AC_CACHE_CHECK([for winldap.h], [curl_cv_header_winldap_h], [
357: AC_COMPILE_IFELSE([
358: AC_LANG_PROGRAM([[
359: #undef inline
360: #ifdef HAVE_WINDOWS_H
361: #ifndef WIN32_LEAN_AND_MEAN
362: #define WIN32_LEAN_AND_MEAN
363: #endif
364: #include <windows.h>
365: #endif
366: #include <winldap.h>
367: ]],[[
368: #if defined(__CYGWIN__) || defined(__CEGCC__)
369: HAVE_WINLDAP_H shall not be defined.
370: #else
371: LDAP *ldp = ldap_init("dummy", LDAP_PORT);
372: ULONG res = ldap_unbind(ldp);
373: #endif
374: ]])
375: ],[
376: curl_cv_header_winldap_h="yes"
377: ],[
378: curl_cv_header_winldap_h="no"
379: ])
380: ])
381: case "$curl_cv_header_winldap_h" in
382: yes)
383: AC_DEFINE_UNQUOTED(HAVE_WINLDAP_H, 1,
384: [Define to 1 if you have the winldap.h header file.])
385: ;;
386: esac
387: ])
388:
389:
390: dnl CURL_CHECK_HEADER_WINBER
391: dnl -------------------------------------------------
392: dnl Check for compilable and valid winber.h header
393:
394: AC_DEFUN([CURL_CHECK_HEADER_WINBER], [
395: AC_REQUIRE([CURL_CHECK_HEADER_WINLDAP])dnl
396: AC_CACHE_CHECK([for winber.h], [curl_cv_header_winber_h], [
397: AC_COMPILE_IFELSE([
398: AC_LANG_PROGRAM([[
399: #undef inline
400: #ifdef HAVE_WINDOWS_H
401: #ifndef WIN32_LEAN_AND_MEAN
402: #define WIN32_LEAN_AND_MEAN
403: #endif
404: #include <windows.h>
405: #endif
406: #include <winldap.h>
407: #include <winber.h>
408: ]],[[
409: #if defined(__CYGWIN__) || defined(__CEGCC__)
410: HAVE_WINBER_H shall not be defined.
411: #else
412: BERVAL *bvp = NULL;
413: BerElement *bep = ber_init(bvp);
414: ber_free(bep, 1);
415: #endif
416: ]])
417: ],[
418: curl_cv_header_winber_h="yes"
419: ],[
420: curl_cv_header_winber_h="no"
421: ])
422: ])
423: case "$curl_cv_header_winber_h" in
424: yes)
425: AC_DEFINE_UNQUOTED(HAVE_WINBER_H, 1,
426: [Define to 1 if you have the winber.h header file.])
427: ;;
428: esac
429: ])
430:
431:
432: dnl CURL_CHECK_HEADER_LBER
433: dnl -------------------------------------------------
434: dnl Check for compilable and valid lber.h header,
435: dnl and check if it is needed even with ldap.h
436:
437: AC_DEFUN([CURL_CHECK_HEADER_LBER], [
438: AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
439: AC_CACHE_CHECK([for lber.h], [curl_cv_header_lber_h], [
440: AC_COMPILE_IFELSE([
441: AC_LANG_PROGRAM([[
442: #undef inline
443: #ifdef HAVE_WINDOWS_H
444: #ifndef WIN32_LEAN_AND_MEAN
445: #define WIN32_LEAN_AND_MEAN
446: #endif
447: #include <windows.h>
448: #else
449: #ifdef HAVE_SYS_TYPES_H
450: #include <sys/types.h>
451: #endif
452: #endif
453: #ifndef NULL
454: #define NULL (void *)0
455: #endif
456: #include <lber.h>
457: ]],[[
458: BerValue *bvp = NULL;
459: BerElement *bep = ber_init(bvp);
460: ber_free(bep, 1);
461: ]])
462: ],[
463: curl_cv_header_lber_h="yes"
464: ],[
465: curl_cv_header_lber_h="no"
466: ])
467: ])
468: if test "$curl_cv_header_lber_h" = "yes"; then
469: AC_DEFINE_UNQUOTED(HAVE_LBER_H, 1,
470: [Define to 1 if you have the lber.h header file.])
471: #
472: AC_COMPILE_IFELSE([
473: AC_LANG_PROGRAM([[
474: #undef inline
475: #ifdef HAVE_WINDOWS_H
476: #ifndef WIN32_LEAN_AND_MEAN
477: #define WIN32_LEAN_AND_MEAN
478: #endif
479: #include <windows.h>
480: #else
481: #ifdef HAVE_SYS_TYPES_H
482: #include <sys/types.h>
483: #endif
484: #endif
485: #ifndef NULL
486: #define NULL (void *)0
487: #endif
488: #ifndef LDAP_DEPRECATED
489: #define LDAP_DEPRECATED 1
490: #endif
491: #include <ldap.h>
492: ]],[[
493: BerValue *bvp = NULL;
494: BerElement *bep = ber_init(bvp);
495: ber_free(bep, 1);
496: ]])
497: ],[
498: curl_cv_need_header_lber_h="no"
499: ],[
500: curl_cv_need_header_lber_h="yes"
501: ])
502: #
503: case "$curl_cv_need_header_lber_h" in
504: yes)
505: AC_DEFINE_UNQUOTED(NEED_LBER_H, 1,
506: [Define to 1 if you need the lber.h header file even with ldap.h])
507: ;;
508: esac
509: fi
510: ])
511:
512:
513: dnl CURL_CHECK_HEADER_LDAP
514: dnl -------------------------------------------------
515: dnl Check for compilable and valid ldap.h header
516:
517: AC_DEFUN([CURL_CHECK_HEADER_LDAP], [
518: AC_REQUIRE([CURL_CHECK_HEADER_LBER])dnl
519: AC_CACHE_CHECK([for ldap.h], [curl_cv_header_ldap_h], [
520: AC_COMPILE_IFELSE([
521: AC_LANG_PROGRAM([[
522: #undef inline
523: #ifdef HAVE_WINDOWS_H
524: #ifndef WIN32_LEAN_AND_MEAN
525: #define WIN32_LEAN_AND_MEAN
526: #endif
527: #include <windows.h>
528: #else
529: #ifdef HAVE_SYS_TYPES_H
530: #include <sys/types.h>
531: #endif
532: #endif
533: #ifndef LDAP_DEPRECATED
534: #define LDAP_DEPRECATED 1
535: #endif
536: #ifdef NEED_LBER_H
537: #include <lber.h>
538: #endif
539: #include <ldap.h>
540: ]],[[
541: LDAP *ldp = ldap_init("dummy", LDAP_PORT);
542: int res = ldap_unbind(ldp);
543: ]])
544: ],[
545: curl_cv_header_ldap_h="yes"
546: ],[
547: curl_cv_header_ldap_h="no"
548: ])
549: ])
550: case "$curl_cv_header_ldap_h" in
551: yes)
552: AC_DEFINE_UNQUOTED(HAVE_LDAP_H, 1,
553: [Define to 1 if you have the ldap.h header file.])
554: ;;
555: esac
556: ])
557:
558:
559: dnl CURL_CHECK_HEADER_LDAP_SSL
560: dnl -------------------------------------------------
561: dnl Check for compilable and valid ldap_ssl.h header
562:
563: AC_DEFUN([CURL_CHECK_HEADER_LDAP_SSL], [
564: AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
565: AC_CACHE_CHECK([for ldap_ssl.h], [curl_cv_header_ldap_ssl_h], [
566: AC_COMPILE_IFELSE([
567: AC_LANG_PROGRAM([[
568: #undef inline
569: #ifdef HAVE_WINDOWS_H
570: #ifndef WIN32_LEAN_AND_MEAN
571: #define WIN32_LEAN_AND_MEAN
572: #endif
573: #include <windows.h>
574: #else
575: #ifdef HAVE_SYS_TYPES_H
576: #include <sys/types.h>
577: #endif
578: #endif
579: #ifndef LDAP_DEPRECATED
580: #define LDAP_DEPRECATED 1
581: #endif
582: #ifdef NEED_LBER_H
583: #include <lber.h>
584: #endif
585: #ifdef HAVE_LDAP_H
586: #include <ldap.h>
587: #endif
588: #include <ldap_ssl.h>
589: ]],[[
590: LDAP *ldp = ldapssl_init("dummy", LDAPS_PORT, 1);
591: ]])
592: ],[
593: curl_cv_header_ldap_ssl_h="yes"
594: ],[
595: curl_cv_header_ldap_ssl_h="no"
596: ])
597: ])
598: case "$curl_cv_header_ldap_ssl_h" in
599: yes)
600: AC_DEFINE_UNQUOTED(HAVE_LDAP_SSL_H, 1,
601: [Define to 1 if you have the ldap_ssl.h header file.])
602: ;;
603: esac
604: ])
605:
606:
607: dnl CURL_CHECK_HEADER_LDAPSSL
608: dnl -------------------------------------------------
609: dnl Check for compilable and valid ldapssl.h header
610:
611: AC_DEFUN([CURL_CHECK_HEADER_LDAPSSL], [
612: AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
613: AC_CACHE_CHECK([for ldapssl.h], [curl_cv_header_ldapssl_h], [
614: AC_COMPILE_IFELSE([
615: AC_LANG_PROGRAM([[
616: #undef inline
617: #ifdef HAVE_WINDOWS_H
618: #ifndef WIN32_LEAN_AND_MEAN
619: #define WIN32_LEAN_AND_MEAN
620: #endif
621: #include <windows.h>
622: #else
623: #ifdef HAVE_SYS_TYPES_H
624: #include <sys/types.h>
625: #endif
626: #endif
627: #ifndef NULL
628: #define NULL (void *)0
629: #endif
630: #ifndef LDAP_DEPRECATED
631: #define LDAP_DEPRECATED 1
632: #endif
633: #ifdef NEED_LBER_H
634: #include <lber.h>
635: #endif
636: #ifdef HAVE_LDAP_H
637: #include <ldap.h>
638: #endif
639: #include <ldapssl.h>
640: ]],[[
641: char *cert_label = NULL;
642: LDAP *ldp = ldap_ssl_init("dummy", LDAPS_PORT, cert_label);
643: ]])
644: ],[
645: curl_cv_header_ldapssl_h="yes"
646: ],[
647: curl_cv_header_ldapssl_h="no"
648: ])
649: ])
650: case "$curl_cv_header_ldapssl_h" in
651: yes)
652: AC_DEFINE_UNQUOTED(HAVE_LDAPSSL_H, 1,
653: [Define to 1 if you have the ldapssl.h header file.])
654: ;;
655: esac
656: ])
657:
658:
659: dnl CURL_CHECK_LIBS_WINLDAP
660: dnl -------------------------------------------------
661: dnl Check for libraries needed for WINLDAP support,
662: dnl and prepended to LIBS any needed libraries.
663: dnl This macro can take an optional parameter with a
664: dnl white space separated list of libraries to check
665: dnl before the WINLDAP default ones.
666:
667: AC_DEFUN([CURL_CHECK_LIBS_WINLDAP], [
668: AC_REQUIRE([CURL_CHECK_HEADER_WINBER])dnl
669: #
670: AC_MSG_CHECKING([for WINLDAP libraries])
671: #
672: u_libs=""
673: #
674: ifelse($1,,,[
675: for x_lib in $1; do
676: case "$x_lib" in
677: -l*)
678: l_lib="$x_lib"
679: ;;
680: *)
681: l_lib="-l$x_lib"
682: ;;
683: esac
684: if test -z "$u_libs"; then
685: u_libs="$l_lib"
686: else
687: u_libs="$u_libs $l_lib"
688: fi
689: done
690: ])
691: #
692: curl_cv_save_LIBS="$LIBS"
693: curl_cv_ldap_LIBS="unknown"
694: #
695: for x_nlibs in '' "$u_libs" \
696: '-lwldap32' ; do
697: if test "$curl_cv_ldap_LIBS" = "unknown"; then
698: if test -z "$x_nlibs"; then
699: LIBS="$curl_cv_save_LIBS"
700: else
701: LIBS="$x_nlibs $curl_cv_save_LIBS"
702: fi
703: AC_LINK_IFELSE([
704: AC_LANG_PROGRAM([[
705: #undef inline
706: #ifdef HAVE_WINDOWS_H
707: #ifndef WIN32_LEAN_AND_MEAN
708: #define WIN32_LEAN_AND_MEAN
709: #endif
710: #include <windows.h>
711: #ifdef HAVE_WINLDAP_H
712: #include <winldap.h>
713: #endif
714: #ifdef HAVE_WINBER_H
715: #include <winber.h>
716: #endif
717: #endif
718: ]],[[
719: BERVAL *bvp = NULL;
720: BerElement *bep = ber_init(bvp);
721: LDAP *ldp = ldap_init("dummy", LDAP_PORT);
722: ULONG res = ldap_unbind(ldp);
723: ber_free(bep, 1);
724: ]])
725: ],[
726: curl_cv_ldap_LIBS="$x_nlibs"
727: ])
728: fi
729: done
730: #
731: LIBS="$curl_cv_save_LIBS"
732: #
733: case X-"$curl_cv_ldap_LIBS" in
734: X-unknown)
735: AC_MSG_RESULT([cannot find WINLDAP libraries])
736: ;;
737: X-)
738: AC_MSG_RESULT([no additional lib required])
739: ;;
740: *)
741: if test -z "$curl_cv_save_LIBS"; then
742: LIBS="$curl_cv_ldap_LIBS"
743: else
744: LIBS="$curl_cv_ldap_LIBS $curl_cv_save_LIBS"
745: fi
746: AC_MSG_RESULT([$curl_cv_ldap_LIBS])
747: ;;
748: esac
749: #
750: ])
751:
752:
753: dnl CURL_CHECK_LIBS_LDAP
754: dnl -------------------------------------------------
755: dnl Check for libraries needed for LDAP support,
756: dnl and prepended to LIBS any needed libraries.
757: dnl This macro can take an optional parameter with a
758: dnl white space separated list of libraries to check
759: dnl before the default ones.
760:
761: AC_DEFUN([CURL_CHECK_LIBS_LDAP], [
762: AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
763: #
764: AC_MSG_CHECKING([for LDAP libraries])
765: #
766: u_libs=""
767: #
768: ifelse($1,,,[
769: for x_lib in $1; do
770: case "$x_lib" in
771: -l*)
772: l_lib="$x_lib"
773: ;;
774: *)
775: l_lib="-l$x_lib"
776: ;;
777: esac
778: if test -z "$u_libs"; then
779: u_libs="$l_lib"
780: else
781: u_libs="$u_libs $l_lib"
782: fi
783: done
784: ])
785: #
786: curl_cv_save_LIBS="$LIBS"
787: curl_cv_ldap_LIBS="unknown"
788: #
789: for x_nlibs in '' "$u_libs" \
790: '-lldap' \
791: '-lldap -llber' \
792: '-llber -lldap' \
793: '-lldapssl -lldapx -lldapsdk' \
794: '-lldapsdk -lldapx -lldapssl' \
795: '-lldap -llber -lssl -lcrypto' ; do
796:
797: if test "$curl_cv_ldap_LIBS" = "unknown"; then
798: if test -z "$x_nlibs"; then
799: LIBS="$curl_cv_save_LIBS"
800: else
801: LIBS="$x_nlibs $curl_cv_save_LIBS"
802: fi
803: AC_LINK_IFELSE([
804: AC_LANG_PROGRAM([[
805: #undef inline
806: #ifdef HAVE_WINDOWS_H
807: #ifndef WIN32_LEAN_AND_MEAN
808: #define WIN32_LEAN_AND_MEAN
809: #endif
810: #include <windows.h>
811: #else
812: #ifdef HAVE_SYS_TYPES_H
813: #include <sys/types.h>
814: #endif
815: #endif
816: #ifndef NULL
817: #define NULL (void *)0
818: #endif
819: #ifndef LDAP_DEPRECATED
820: #define LDAP_DEPRECATED 1
821: #endif
822: #ifdef NEED_LBER_H
823: #include <lber.h>
824: #endif
825: #ifdef HAVE_LDAP_H
826: #include <ldap.h>
827: #endif
828: ]],[[
829: BerValue *bvp = NULL;
830: BerElement *bep = ber_init(bvp);
831: LDAP *ldp = ldap_init("dummy", LDAP_PORT);
832: int res = ldap_unbind(ldp);
833: ber_free(bep, 1);
834: ]])
835: ],[
836: curl_cv_ldap_LIBS="$x_nlibs"
837: ])
838: fi
839: done
840: #
841: LIBS="$curl_cv_save_LIBS"
842: #
843: case X-"$curl_cv_ldap_LIBS" in
844: X-unknown)
845: AC_MSG_RESULT([cannot find LDAP libraries])
846: ;;
847: X-)
848: AC_MSG_RESULT([no additional lib required])
849: ;;
850: *)
851: if test -z "$curl_cv_save_LIBS"; then
852: LIBS="$curl_cv_ldap_LIBS"
853: else
854: LIBS="$curl_cv_ldap_LIBS $curl_cv_save_LIBS"
855: fi
856: AC_MSG_RESULT([$curl_cv_ldap_LIBS])
857: ;;
858: esac
859: #
860: ])
861:
862:
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
867:
868: AC_DEFUN([CURL_CHECK_HEADER_MALLOC], [
869: AC_CACHE_CHECK([for malloc.h], [curl_cv_header_malloc_h], [
870: AC_COMPILE_IFELSE([
871: AC_LANG_PROGRAM([[
872: #include <malloc.h>
873: ]],[[
874: void *p = malloc(10);
875: void *q = calloc(10,10);
876: free(p);
877: free(q);
878: ]])
879: ],[
880: curl_cv_header_malloc_h="yes"
881: ],[
882: curl_cv_header_malloc_h="no"
883: ])
884: ])
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.])
888: #
889: AC_COMPILE_IFELSE([
890: AC_LANG_PROGRAM([[
891: #include <stdlib.h>
892: ]],[[
893: void *p = malloc(10);
894: void *q = calloc(10,10);
895: free(p);
896: free(q);
897: ]])
898: ],[
899: curl_cv_need_header_malloc_h="no"
900: ],[
901: curl_cv_need_header_malloc_h="yes"
902: ])
903: #
904: case "$curl_cv_need_header_malloc_h" in
905: yes)
906: AC_DEFINE_UNQUOTED(NEED_MALLOC_H, 1,
907: [Define to 1 if you need the malloc.h header file even with stdlib.h])
908: ;;
909: esac
910: fi
911: ])
912:
913:
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.
919:
920: AC_DEFUN([CURL_CHECK_HEADER_MEMORY], [
921: AC_CACHE_CHECK([for memory.h], [curl_cv_header_memory_h], [
922: AC_COMPILE_IFELSE([
923: AC_LANG_PROGRAM([[
924: #include <memory.h>
925: ]],[[
926: void *p = malloc(10);
927: void *q = calloc(10,10);
928: free(p);
929: free(q);
930: ]])
931: ],[
932: curl_cv_header_memory_h="yes"
933: ],[
934: curl_cv_header_memory_h="no"
935: ])
936: ])
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.])
940: #
941: AC_COMPILE_IFELSE([
942: AC_LANG_PROGRAM([[
943: #include <stdlib.h>
944: ]],[[
945: void *p = malloc(10);
946: void *q = calloc(10,10);
947: free(p);
948: free(q);
949: ]])
950: ],[
951: curl_cv_need_header_memory_h="no"
952: ],[
953: curl_cv_need_header_memory_h="yes"
954: ])
955: #
956: case "$curl_cv_need_header_memory_h" in
957: yes)
958: AC_DEFINE_UNQUOTED(NEED_MEMORY_H, 1,
959: [Define to 1 if you need the memory.h header file even with stdlib.h])
960: ;;
961: esac
962: fi
963: ])
964:
965: dnl TYPE_SOCKADDR_STORAGE
966: dnl -------------------------------------------------
967: dnl Check for struct sockaddr_storage. Most IPv6-enabled
968: dnl hosts have it, but AIX 4.3 is one known exception.
969:
970: AC_DEFUN([TYPE_SOCKADDR_STORAGE],
971: [
972: AC_CHECK_TYPE([struct sockaddr_storage],
973: AC_DEFINE(HAVE_STRUCT_SOCKADDR_STORAGE, 1,
974: [if struct sockaddr_storage is defined]), ,
975: [
976: #undef inline
977: #ifdef HAVE_WINDOWS_H
978: #ifndef WIN32_LEAN_AND_MEAN
979: #define WIN32_LEAN_AND_MEAN
980: #endif
981: #include <windows.h>
982: #ifdef HAVE_WINSOCK2_H
983: #include <winsock2.h>
984: #endif
985: #else
986: #ifdef HAVE_SYS_TYPES_H
987: #include <sys/types.h>
988: #endif
989: #ifdef HAVE_SYS_SOCKET_H
990: #include <sys/socket.h>
991: #endif
992: #ifdef HAVE_NETINET_IN_H
993: #include <netinet/in.h>
994: #endif
995: #ifdef HAVE_ARPA_INET_H
996: #include <arpa/inet.h>
997: #endif
998: #endif
999: ])
1000: ])
1001:
1002: dnl CURL_CHECK_FUNC_RECV
1003: dnl -------------------------------------------------
1004: dnl Test if the socket recv() function is available,
1005: dnl and check its return type and the types of its
1006: dnl arguments. If the function succeeds HAVE_RECV
1007: dnl will be defined, defining the types of the arguments
1008: dnl in RECV_TYPE_ARG1, RECV_TYPE_ARG2, RECV_TYPE_ARG3
1009: dnl and RECV_TYPE_ARG4, defining the type of the function
1010: dnl return value in RECV_TYPE_RETV.
1011:
1012: AC_DEFUN([CURL_CHECK_FUNC_RECV], [
1013: AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1014: AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1015: AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1016: #
1017: AC_MSG_CHECKING([for recv])
1018: AC_LINK_IFELSE([
1019: AC_LANG_PROGRAM([[
1020: #undef inline
1021: #ifdef HAVE_WINDOWS_H
1022: #ifndef WIN32_LEAN_AND_MEAN
1023: #define WIN32_LEAN_AND_MEAN
1024: #endif
1025: #include <windows.h>
1026: #ifdef HAVE_WINSOCK2_H
1027: #include <winsock2.h>
1028: #else
1029: #ifdef HAVE_WINSOCK_H
1030: #include <winsock.h>
1031: #endif
1032: #endif
1033: #else
1034: #ifdef HAVE_PROTO_BSDSOCKET_H
1035: #include <proto/bsdsocket.h>
1036: struct Library *SocketBase = NULL;
1037: #endif
1038: #ifdef HAVE_SYS_TYPES_H
1039: #include <sys/types.h>
1040: #endif
1041: #ifdef HAVE_SYS_SOCKET_H
1042: #include <sys/socket.h>
1043: #endif
1044: #endif
1045: ]],[[
1046: recv(0, 0, 0, 0);
1047: ]])
1048: ],[
1049: AC_MSG_RESULT([yes])
1050: curl_cv_recv="yes"
1051: ],[
1052: AC_MSG_RESULT([no])
1053: curl_cv_recv="no"
1054: ])
1055: #
1056: if test "$curl_cv_recv" = "yes"; then
1057: AC_CACHE_CHECK([types of args and return type for recv],
1058: [curl_cv_func_recv_args], [
1059: curl_cv_func_recv_args="unknown"
1060: for recv_retv in 'int' 'ssize_t'; do
1061: for recv_arg1 in 'int' 'ssize_t' 'SOCKET'; do
1062: for recv_arg2 in 'char *' 'void *'; do
1063: for recv_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
1064: for recv_arg4 in 'int' 'unsigned int'; do
1065: if test "$curl_cv_func_recv_args" = "unknown"; then
1066: AC_COMPILE_IFELSE([
1067: AC_LANG_PROGRAM([[
1068: #undef inline
1069: #ifdef HAVE_WINDOWS_H
1070: #ifndef WIN32_LEAN_AND_MEAN
1071: #define WIN32_LEAN_AND_MEAN
1072: #endif
1073: #include <windows.h>
1074: #ifdef HAVE_WINSOCK2_H
1075: #include <winsock2.h>
1076: #else
1077: #ifdef HAVE_WINSOCK_H
1078: #include <winsock.h>
1079: #endif
1080: #endif
1081: #define RECVCALLCONV PASCAL
1082: #else
1083: #ifdef HAVE_PROTO_BSDSOCKET_H
1084: #include <proto/bsdsocket.h>
1085: struct Library *SocketBase = NULL;
1086: #endif
1087: #ifdef HAVE_SYS_TYPES_H
1088: #include <sys/types.h>
1089: #endif
1090: #ifdef HAVE_SYS_SOCKET_H
1091: #include <sys/socket.h>
1092: #endif
1093: #define RECVCALLCONV
1094: #endif
1095: #ifndef HAVE_PROTO_BSDSOCKET_H
1096: extern $recv_retv RECVCALLCONV
1097: recv($recv_arg1, $recv_arg2, $recv_arg3, $recv_arg4);
1098: #endif
1099: ]],[[
1100: $recv_arg1 s=0;
1101: $recv_arg2 buf=0;
1102: $recv_arg3 len=0;
1103: $recv_arg4 flags=0;
1104: $recv_retv res = recv(s, buf, len, flags);
1105: ]])
1106: ],[
1107: curl_cv_func_recv_args="$recv_arg1,$recv_arg2,$recv_arg3,$recv_arg4,$recv_retv"
1108: ])
1109: fi
1110: done
1111: done
1112: done
1113: done
1114: done
1115: ]) # AC-CACHE-CHECK
1116: if test "$curl_cv_func_recv_args" = "unknown"; then
1117: AC_MSG_ERROR([Cannot find proper types to use for recv args])
1118: else
1119: recv_prev_IFS=$IFS; IFS=','
1120: set dummy `echo "$curl_cv_func_recv_args" | sed 's/\*/\*/g'`
1121: IFS=$recv_prev_IFS
1122: shift
1123: #
1124: AC_DEFINE_UNQUOTED(RECV_TYPE_ARG1, $[1],
1125: [Define to the type of arg 1 for recv.])
1126: AC_DEFINE_UNQUOTED(RECV_TYPE_ARG2, $[2],
1127: [Define to the type of arg 2 for recv.])
1128: AC_DEFINE_UNQUOTED(RECV_TYPE_ARG3, $[3],
1129: [Define to the type of arg 3 for recv.])
1130: AC_DEFINE_UNQUOTED(RECV_TYPE_ARG4, $[4],
1131: [Define to the type of arg 4 for recv.])
1132: AC_DEFINE_UNQUOTED(RECV_TYPE_RETV, $[5],
1133: [Define to the function return type for recv.])
1134: #
1135: AC_DEFINE_UNQUOTED(HAVE_RECV, 1,
1136: [Define to 1 if you have the recv function.])
1137: curl_cv_func_recv="yes"
1138: fi
1139: else
1140: AC_MSG_ERROR([Unable to link function recv])
1141: fi
1142: ])
1143:
1144:
1145: dnl CURL_CHECK_FUNC_SEND
1146: dnl -------------------------------------------------
1147: dnl Test if the socket send() function is available,
1148: dnl and check its return type and the types of its
1149: dnl arguments. If the function succeeds HAVE_SEND
1150: dnl will be defined, defining the types of the arguments
1151: dnl in SEND_TYPE_ARG1, SEND_TYPE_ARG2, SEND_TYPE_ARG3
1152: dnl and SEND_TYPE_ARG4, defining the type of the function
1153: dnl return value in SEND_TYPE_RETV, and also defining the
1154: dnl type qualifier of second argument in SEND_QUAL_ARG2.
1155:
1156: AC_DEFUN([CURL_CHECK_FUNC_SEND], [
1157: AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1158: AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1159: AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1160: #
1161: AC_MSG_CHECKING([for send])
1162: AC_LINK_IFELSE([
1163: AC_LANG_PROGRAM([[
1164: #undef inline
1165: #ifdef HAVE_WINDOWS_H
1166: #ifndef WIN32_LEAN_AND_MEAN
1167: #define WIN32_LEAN_AND_MEAN
1168: #endif
1169: #include <windows.h>
1170: #ifdef HAVE_WINSOCK2_H
1171: #include <winsock2.h>
1172: #else
1173: #ifdef HAVE_WINSOCK_H
1174: #include <winsock.h>
1175: #endif
1176: #endif
1177: #else
1178: #ifdef HAVE_PROTO_BSDSOCKET_H
1179: #include <proto/bsdsocket.h>
1180: struct Library *SocketBase = NULL;
1181: #endif
1182: #ifdef HAVE_SYS_TYPES_H
1183: #include <sys/types.h>
1184: #endif
1185: #ifdef HAVE_SYS_SOCKET_H
1186: #include <sys/socket.h>
1187: #endif
1188: #endif
1189: ]],[[
1190: send(0, 0, 0, 0);
1191: ]])
1192: ],[
1193: AC_MSG_RESULT([yes])
1194: curl_cv_send="yes"
1195: ],[
1196: AC_MSG_RESULT([no])
1197: curl_cv_send="no"
1198: ])
1199: #
1200: if test "$curl_cv_send" = "yes"; then
1201: AC_CACHE_CHECK([types of args and return type for send],
1202: [curl_cv_func_send_args], [
1203: curl_cv_func_send_args="unknown"
1204: for send_retv in 'int' 'ssize_t'; do
1205: for send_arg1 in 'int' 'ssize_t' 'SOCKET'; do
1206: for send_arg2 in 'char *' 'void *' 'const char *' 'const void *'; do
1207: for send_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
1208: for send_arg4 in 'int' 'unsigned int'; do
1209: if test "$curl_cv_func_send_args" = "unknown"; then
1210: AC_COMPILE_IFELSE([
1211: AC_LANG_PROGRAM([[
1212: #undef inline
1213: #ifdef HAVE_WINDOWS_H
1214: #ifndef WIN32_LEAN_AND_MEAN
1215: #define WIN32_LEAN_AND_MEAN
1216: #endif
1217: #include <windows.h>
1218: #ifdef HAVE_WINSOCK2_H
1219: #include <winsock2.h>
1220: #else
1221: #ifdef HAVE_WINSOCK_H
1222: #include <winsock.h>
1223: #endif
1224: #endif
1225: #define SENDCALLCONV PASCAL
1226: #else
1227: #ifdef HAVE_PROTO_BSDSOCKET_H
1228: #include <proto/bsdsocket.h>
1229: struct Library *SocketBase = NULL;
1230: #endif
1231: #ifdef HAVE_SYS_TYPES_H
1232: #include <sys/types.h>
1233: #endif
1234: #ifdef HAVE_SYS_SOCKET_H
1235: #include <sys/socket.h>
1236: #endif
1237: #define SENDCALLCONV
1238: #endif
1239: #ifndef HAVE_PROTO_BSDSOCKET_H
1240: extern $send_retv SENDCALLCONV
1241: send($send_arg1, $send_arg2, $send_arg3, $send_arg4);
1242: #endif
1243: ]],[[
1244: $send_arg1 s=0;
1245: $send_arg3 len=0;
1246: $send_arg4 flags=0;
1247: $send_retv res = send(s, 0, len, flags);
1248: ]])
1249: ],[
1250: curl_cv_func_send_args="$send_arg1,$send_arg2,$send_arg3,$send_arg4,$send_retv"
1251: ])
1252: fi
1253: done
1254: done
1255: done
1256: done
1257: done
1258: ]) # AC-CACHE-CHECK
1259: if test "$curl_cv_func_send_args" = "unknown"; then
1260: AC_MSG_ERROR([Cannot find proper types to use for send args])
1261: else
1262: send_prev_IFS=$IFS; IFS=','
1263: set dummy `echo "$curl_cv_func_send_args" | sed 's/\*/\*/g'`
1264: IFS=$send_prev_IFS
1265: shift
1266: #
1267: send_qual_type_arg2=$[2]
1268: #
1269: AC_DEFINE_UNQUOTED(SEND_TYPE_ARG1, $[1],
1270: [Define to the type of arg 1 for send.])
1271: AC_DEFINE_UNQUOTED(SEND_TYPE_ARG3, $[3],
1272: [Define to the type of arg 3 for send.])
1273: AC_DEFINE_UNQUOTED(SEND_TYPE_ARG4, $[4],
1274: [Define to the type of arg 4 for send.])
1275: AC_DEFINE_UNQUOTED(SEND_TYPE_RETV, $[5],
1276: [Define to the function return type for send.])
1277: #
1278: prev_sh_opts=$-
1279: #
1280: case $prev_sh_opts in
1281: *f*)
1282: ;;
1283: *)
1284: set -f
1285: ;;
1286: esac
1287: #
1288: case "$send_qual_type_arg2" in
1289: const*)
1290: send_qual_arg2=const
1291: send_type_arg2=`echo $send_qual_type_arg2 | sed 's/^const //'`
1292: ;;
1293: *)
1294: send_qual_arg2=
1295: send_type_arg2=$send_qual_type_arg2
1296: ;;
1297: esac
1298: #
1299: AC_DEFINE_UNQUOTED(SEND_QUAL_ARG2, $send_qual_arg2,
1300: [Define to the type qualifier of arg 2 for send.])
1301: AC_DEFINE_UNQUOTED(SEND_TYPE_ARG2, $send_type_arg2,
1302: [Define to the type of arg 2 for send.])
1303: #
1304: case $prev_sh_opts in
1305: *f*)
1306: ;;
1307: *)
1308: set +f
1309: ;;
1310: esac
1311: #
1312: AC_DEFINE_UNQUOTED(HAVE_SEND, 1,
1313: [Define to 1 if you have the send function.])
1314: curl_cv_func_send="yes"
1315: fi
1316: else
1317: AC_MSG_ERROR([Unable to link function send])
1318: fi
1319: ])
1320:
1321: dnl CURL_CHECK_MSG_NOSIGNAL
1322: dnl -------------------------------------------------
1323: dnl Check for MSG_NOSIGNAL
1324:
1325: AC_DEFUN([CURL_CHECK_MSG_NOSIGNAL], [
1326: AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1327: AC_CACHE_CHECK([for MSG_NOSIGNAL], [curl_cv_msg_nosignal], [
1328: AC_COMPILE_IFELSE([
1329: AC_LANG_PROGRAM([[
1330: #undef inline
1331: #ifdef HAVE_WINDOWS_H
1332: #ifndef WIN32_LEAN_AND_MEAN
1333: #define WIN32_LEAN_AND_MEAN
1334: #endif
1335: #include <windows.h>
1336: #ifdef HAVE_WINSOCK2_H
1337: #include <winsock2.h>
1338: #else
1339: #ifdef HAVE_WINSOCK_H
1340: #include <winsock.h>
1341: #endif
1342: #endif
1343: #else
1344: #ifdef HAVE_PROTO_BSDSOCKET_H
1345: #include <proto/bsdsocket.h>
1346: struct Library *SocketBase = NULL;
1347: #endif
1348: #ifdef HAVE_SYS_TYPES_H
1349: #include <sys/types.h>
1350: #endif
1351: #ifdef HAVE_SYS_SOCKET_H
1352: #include <sys/socket.h>
1353: #endif
1354: #endif
1355: ]],[[
1356: int flag=MSG_NOSIGNAL;
1357: ]])
1358: ],[
1359: curl_cv_msg_nosignal="yes"
1360: ],[
1361: curl_cv_msg_nosignal="no"
1362: ])
1363: ])
1364: case "$curl_cv_msg_nosignal" in
1365: yes)
1366: AC_DEFINE_UNQUOTED(HAVE_MSG_NOSIGNAL, 1,
1367: [Define to 1 if you have the MSG_NOSIGNAL flag.])
1368: ;;
1369: esac
1370: ])
1371:
1372:
1373: dnl CURL_CHECK_STRUCT_TIMEVAL
1374: dnl -------------------------------------------------
1375: dnl Check for timeval struct
1376:
1377: AC_DEFUN([CURL_CHECK_STRUCT_TIMEVAL], [
1378: AC_REQUIRE([AC_HEADER_TIME])dnl
1379: AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1380: AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1381: AC_CHECK_HEADERS(sys/types.h sys/time.h time.h sys/socket.h)
1382: AC_CACHE_CHECK([for struct timeval], [curl_cv_struct_timeval], [
1383: AC_COMPILE_IFELSE([
1384: AC_LANG_PROGRAM([[
1385: #undef inline
1386: #ifdef HAVE_WINDOWS_H
1387: #ifndef WIN32_LEAN_AND_MEAN
1388: #define WIN32_LEAN_AND_MEAN
1389: #endif
1390: #include <windows.h>
1391: #ifdef HAVE_WINSOCK2_H
1392: #include <winsock2.h>
1393: #else
1394: #ifdef HAVE_WINSOCK_H
1395: #include <winsock.h>
1396: #endif
1397: #endif
1398: #endif
1399: #ifdef HAVE_SYS_TYPES_H
1400: #include <sys/types.h>
1401: #endif
1402: #ifdef HAVE_SYS_TIME_H
1403: #include <sys/time.h>
1404: #ifdef TIME_WITH_SYS_TIME
1405: #include <time.h>
1406: #endif
1407: #else
1408: #ifdef HAVE_TIME_H
1409: #include <time.h>
1410: #endif
1411: #endif
1412: #ifdef HAVE_SYS_SOCKET_H
1413: #include <sys/socket.h>
1414: #endif
1415: ]],[[
1416: struct timeval ts;
1417: ts.tv_sec = 0;
1418: ts.tv_usec = 0;
1419: ]])
1420: ],[
1421: curl_cv_struct_timeval="yes"
1422: ],[
1423: curl_cv_struct_timeval="no"
1424: ])
1425: ])
1426: case "$curl_cv_struct_timeval" in
1427: yes)
1428: AC_DEFINE_UNQUOTED(HAVE_STRUCT_TIMEVAL, 1,
1429: [Define to 1 if you have the timeval struct.])
1430: ;;
1431: esac
1432: ])
1433:
1434:
1435: dnl TYPE_SIG_ATOMIC_T
1436: dnl -------------------------------------------------
1437: dnl Check if the sig_atomic_t type is available, and
1438: dnl verify if it is already defined as volatile.
1439:
1440: AC_DEFUN([TYPE_SIG_ATOMIC_T], [
1441: AC_CHECK_HEADERS(signal.h)
1442: AC_CHECK_TYPE([sig_atomic_t],[
1443: AC_DEFINE(HAVE_SIG_ATOMIC_T, 1,
1444: [Define to 1 if sig_atomic_t is an available typedef.])
1445: ], ,[
1446: #ifdef HAVE_SIGNAL_H
1447: #include <signal.h>
1448: #endif
1449: ])
1450: case "$ac_cv_type_sig_atomic_t" in
1451: yes)
1452: #
1453: AC_MSG_CHECKING([if sig_atomic_t is already defined as volatile])
1454: AC_LINK_IFELSE([
1455: AC_LANG_PROGRAM([[
1456: #ifdef HAVE_SIGNAL_H
1457: #include <signal.h>
1458: #endif
1459: ]],[[
1460: static volatile sig_atomic_t dummy = 0;
1461: ]])
1462: ],[
1463: AC_MSG_RESULT([no])
1464: curl_cv_sig_atomic_t_volatile="no"
1465: ],[
1466: AC_MSG_RESULT([yes])
1467: curl_cv_sig_atomic_t_volatile="yes"
1468: ])
1469: #
1470: if test "$curl_cv_sig_atomic_t_volatile" = "yes"; then
1471: AC_DEFINE(HAVE_SIG_ATOMIC_T_VOLATILE, 1,
1472: [Define to 1 if sig_atomic_t is already defined as volatile.])
1473: fi
1474: ;;
1475: esac
1476: ])
1477:
1478:
1479: dnl TYPE_IN_ADDR_T
1480: dnl -------------------------------------------------
1481: dnl Check for in_addr_t: it is used to receive the return code of inet_addr()
1482: dnl and a few other things.
1483:
1484: AC_DEFUN([TYPE_IN_ADDR_T], [
1485: AC_CHECK_TYPE([in_addr_t], ,[
1486: dnl in_addr_t not available
1487: AC_CACHE_CHECK([for in_addr_t equivalent],
1488: [curl_cv_in_addr_t_equiv], [
1489: curl_cv_in_addr_t_equiv="unknown"
1490: for t in "unsigned long" int size_t unsigned long; do
1491: if test "$curl_cv_in_addr_t_equiv" = "unknown"; then
1492: AC_LINK_IFELSE([
1493: AC_LANG_PROGRAM([[
1494: #undef inline
1495: #ifdef HAVE_WINDOWS_H
1496: #ifndef WIN32_LEAN_AND_MEAN
1497: #define WIN32_LEAN_AND_MEAN
1498: #endif
1499: #include <windows.h>
1500: #ifdef HAVE_WINSOCK2_H
1501: #include <winsock2.h>
1502: #else
1503: #ifdef HAVE_WINSOCK_H
1504: #include <winsock.h>
1505: #endif
1506: #endif
1507: #else
1508: #ifdef HAVE_SYS_TYPES_H
1509: #include <sys/types.h>
1510: #endif
1511: #ifdef HAVE_SYS_SOCKET_H
1512: #include <sys/socket.h>
1513: #endif
1514: #ifdef HAVE_NETINET_IN_H
1515: #include <netinet/in.h>
1516: #endif
1517: #ifdef HAVE_ARPA_INET_H
1518: #include <arpa/inet.h>
1519: #endif
1520: #endif
1521: ]],[[
1522: $t data = inet_addr ("1.2.3.4");
1523: ]])
1524: ],[
1525: curl_cv_in_addr_t_equiv="$t"
1526: ])
1527: fi
1528: done
1529: ])
1530: case "$curl_cv_in_addr_t_equiv" in
1531: unknown)
1532: AC_MSG_ERROR([Cannot find a type to use in place of in_addr_t])
1533: ;;
1534: *)
1535: AC_DEFINE_UNQUOTED(in_addr_t, $curl_cv_in_addr_t_equiv,
1536: [Type to use in place of in_addr_t when system does not provide it.])
1537: ;;
1538: esac
1539: ],[
1540: #undef inline
1541: #ifdef HAVE_WINDOWS_H
1542: #ifndef WIN32_LEAN_AND_MEAN
1543: #define WIN32_LEAN_AND_MEAN
1544: #endif
1545: #include <windows.h>
1546: #ifdef HAVE_WINSOCK2_H
1547: #include <winsock2.h>
1548: #else
1549: #ifdef HAVE_WINSOCK_H
1550: #include <winsock.h>
1551: #endif
1552: #endif
1553: #else
1554: #ifdef HAVE_SYS_TYPES_H
1555: #include <sys/types.h>
1556: #endif
1557: #ifdef HAVE_SYS_SOCKET_H
1558: #include <sys/socket.h>
1559: #endif
1560: #ifdef HAVE_NETINET_IN_H
1561: #include <netinet/in.h>
1562: #endif
1563: #ifdef HAVE_ARPA_INET_H
1564: #include <arpa/inet.h>
1565: #endif
1566: #endif
1567: ])
1568: ])
1569:
1570:
1571: dnl CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC
1572: dnl -------------------------------------------------
1573: dnl Check if monotonic clock_gettime is available.
1574:
1575: AC_DEFUN([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC], [
1576: AC_REQUIRE([AC_HEADER_TIME])dnl
1577: AC_CHECK_HEADERS(sys/types.h sys/time.h time.h)
1578: AC_MSG_CHECKING([for monotonic clock_gettime])
1579: #
1580: if test "x$dontwant_rt" = "xno" ; then
1581: AC_COMPILE_IFELSE([
1582: AC_LANG_PROGRAM([[
1583: #ifdef HAVE_SYS_TYPES_H
1584: #include <sys/types.h>
1585: #endif
1586: #ifdef HAVE_SYS_TIME_H
1587: #include <sys/time.h>
1588: #ifdef TIME_WITH_SYS_TIME
1589: #include <time.h>
1590: #endif
1591: #else
1592: #ifdef HAVE_TIME_H
1593: #include <time.h>
1594: #endif
1595: #endif
1596: ]],[[
1597: struct timespec ts;
1598: (void)clock_gettime(CLOCK_MONOTONIC, &ts);
1599: ]])
1600: ],[
1601: AC_MSG_RESULT([yes])
1602: curl_func_clock_gettime="yes"
1603: ],[
1604: AC_MSG_RESULT([no])
1605: curl_func_clock_gettime="no"
1606: ])
1607: fi
1608: dnl Definition of HAVE_CLOCK_GETTIME_MONOTONIC is intentionally postponed
1609: dnl until library linking and run-time checks for clock_gettime succeed.
1610: ])
1611:
1612:
1613: dnl CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC
1614: dnl -------------------------------------------------
1615: dnl If monotonic clock_gettime is available then,
1616: dnl check and prepended to LIBS any needed libraries.
1617:
1618: AC_DEFUN([CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC], [
1619: AC_REQUIRE([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC])dnl
1620: #
1621: if test "$curl_func_clock_gettime" = "yes"; then
1622: #
1623: AC_MSG_CHECKING([for clock_gettime in libraries])
1624: #
1625: curl_cv_save_LIBS="$LIBS"
1626: curl_cv_gclk_LIBS="unknown"
1627: #
1628: for x_xlibs in '' '-lrt' '-lposix4' ; do
1629: if test "$curl_cv_gclk_LIBS" = "unknown"; then
1630: if test -z "$x_xlibs"; then
1631: LIBS="$curl_cv_save_LIBS"
1632: else
1633: LIBS="$x_xlibs $curl_cv_save_LIBS"
1634: fi
1635: AC_LINK_IFELSE([
1636: AC_LANG_PROGRAM([[
1637: #ifdef HAVE_SYS_TYPES_H
1638: #include <sys/types.h>
1639: #endif
1640: #ifdef HAVE_SYS_TIME_H
1641: #include <sys/time.h>
1642: #ifdef TIME_WITH_SYS_TIME
1643: #include <time.h>
1644: #endif
1645: #else
1646: #ifdef HAVE_TIME_H
1647: #include <time.h>
1648: #endif
1649: #endif
1650: ]],[[
1651: struct timespec ts;
1652: (void)clock_gettime(CLOCK_MONOTONIC, &ts);
1653: ]])
1654: ],[
1655: curl_cv_gclk_LIBS="$x_xlibs"
1656: ])
1657: fi
1658: done
1659: #
1660: LIBS="$curl_cv_save_LIBS"
1661: #
1662: case X-"$curl_cv_gclk_LIBS" in
1663: X-unknown)
1664: AC_MSG_RESULT([cannot find clock_gettime])
1665: AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
1666: curl_func_clock_gettime="no"
1667: ;;
1668: X-)
1669: AC_MSG_RESULT([no additional lib required])
1670: curl_func_clock_gettime="yes"
1671: ;;
1672: *)
1673: if test -z "$curl_cv_save_LIBS"; then
1674: LIBS="$curl_cv_gclk_LIBS"
1675: else
1676: LIBS="$curl_cv_gclk_LIBS $curl_cv_save_LIBS"
1677: fi
1678: AC_MSG_RESULT([$curl_cv_gclk_LIBS])
1679: curl_func_clock_gettime="yes"
1680: ;;
1681: esac
1682: #
1683: dnl only do runtime verification when not cross-compiling
1684: if test "x$cross_compiling" != "xyes" &&
1685: test "$curl_func_clock_gettime" = "yes"; then
1686: AC_MSG_CHECKING([if monotonic clock_gettime works])
1687: CURL_RUN_IFELSE([
1688: AC_LANG_PROGRAM([[
1689: #ifdef HAVE_STDLIB_H
1690: #include <stdlib.h>
1691: #endif
1692: #ifdef HAVE_SYS_TYPES_H
1693: #include <sys/types.h>
1694: #endif
1695: #ifdef HAVE_SYS_TIME_H
1696: #include <sys/time.h>
1697: #ifdef TIME_WITH_SYS_TIME
1698: #include <time.h>
1699: #endif
1700: #else
1701: #ifdef HAVE_TIME_H
1702: #include <time.h>
1703: #endif
1704: #endif
1705: ]],[[
1706: struct timespec ts;
1707: if (0 == clock_gettime(CLOCK_MONOTONIC, &ts))
1708: exit(0);
1709: else
1710: exit(1);
1711: ]])
1712: ],[
1713: AC_MSG_RESULT([yes])
1714: ],[
1715: AC_MSG_RESULT([no])
1716: AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
1717: curl_func_clock_gettime="no"
1718: LIBS="$curl_cv_save_LIBS"
1719: ])
1720: fi
1721: #
1722: case "$curl_func_clock_gettime" in
1723: yes)
1724: AC_DEFINE_UNQUOTED(HAVE_CLOCK_GETTIME_MONOTONIC, 1,
1725: [Define to 1 if you have the clock_gettime function and monotonic timer.])
1726: ;;
1727: esac
1728: #
1729: fi
1730: #
1731: ])
1732:
1733:
1734: dnl CURL_CHECK_LIBS_CONNECT
1735: dnl -------------------------------------------------
1736: dnl Verify if network connect function is already available
1737: dnl using current libraries or if another one is required.
1738:
1739: AC_DEFUN([CURL_CHECK_LIBS_CONNECT], [
1740: AC_REQUIRE([CURL_INCLUDES_WINSOCK2])dnl
1741: AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])dnl
1742: AC_MSG_CHECKING([for connect in libraries])
1743: tst_connect_save_LIBS="$LIBS"
1744: tst_connect_need_LIBS="unknown"
1745: for tst_lib in '' '-lsocket' ; do
1746: if test "$tst_connect_need_LIBS" = "unknown"; then
1747: LIBS="$tst_lib $tst_connect_save_LIBS"
1748: AC_LINK_IFELSE([
1749: AC_LANG_PROGRAM([[
1750: $curl_includes_winsock2
1751: $curl_includes_bsdsocket
1752: #if !defined(HAVE_WINDOWS_H) && !defined(HAVE_PROTO_BSDSOCKET_H)
1753: int connect(int, void*, int);
1754: #endif
1755: ]],[[
1756: if(0 != connect(0, 0, 0))
1757: return 1;
1758: ]])
1759: ],[
1760: tst_connect_need_LIBS="$tst_lib"
1761: ])
1762: fi
1763: done
1764: LIBS="$tst_connect_save_LIBS"
1765: #
1766: case X-"$tst_connect_need_LIBS" in
1767: X-unknown)
1768: AC_MSG_RESULT([cannot find connect])
1769: AC_MSG_ERROR([cannot find connect function in libraries.])
1770: ;;
1771: X-)
1772: AC_MSG_RESULT([yes])
1773: ;;
1774: *)
1775: AC_MSG_RESULT([$tst_connect_need_LIBS])
1776: LIBS="$tst_connect_need_LIBS $tst_connect_save_LIBS"
1777: ;;
1778: esac
1779: ])
1780:
1781:
1782: dnl CURL_DEFINE_UNQUOTED (VARIABLE, [VALUE])
1783: dnl -------------------------------------------------
1784: dnl Like AC_DEFINE_UNQUOTED this macro will define a C preprocessor
1785: dnl symbol that can be further used in custom template configuration
1786: dnl files. This macro, unlike AC_DEFINE_UNQUOTED, does not use a third
1787: dnl argument for the description. Symbol definitions done with this
1788: dnl macro are intended to be exclusively used in handcrafted *.h.in
1789: dnl template files. Contrary to what AC_DEFINE_UNQUOTED does, this one
1790: dnl prevents autoheader generation and insertion of symbol template
1791: dnl stub and definition into the first configuration header file. Do
1792: dnl not use this macro as a replacement for AC_DEFINE_UNQUOTED, each
1793: dnl one serves different functional needs.
1794:
1795: AC_DEFUN([CURL_DEFINE_UNQUOTED], [
1796: cat >>confdefs.h <<_EOF
1797: [@%:@define] $1 ifelse($#, 2, [$2], 1)
1798: _EOF
1799: ])
1800:
1801: dnl CURL_CONFIGURE_PULL_SYS_POLL
1802: dnl -------------------------------------------------
1803: dnl The need for the sys/poll.h inclusion arises mainly to properly
1804: dnl interface AIX systems which define macros 'events' and 'revents'.
1805:
1806: AC_DEFUN([CURL_CONFIGURE_PULL_SYS_POLL], [
1807: AC_REQUIRE([CURL_INCLUDES_POLL])dnl
1808: #
1809: tst_poll_events_macro_defined="unknown"
1810: #
1811: AC_COMPILE_IFELSE([
1812: AC_LANG_PROGRAM([[
1813: $curl_includes_poll
1814: ]],[[
1815: #if defined(events) || defined(revents)
1816: return 0;
1817: #else
1818: force compilation error
1819: #endif
1820: ]])
1821: ],[
1822: tst_poll_events_macro_defined="yes"
1823: ],[
1824: tst_poll_events_macro_defined="no"
1825: ])
1826: #
1827: if test "$tst_poll_events_macro_defined" = "yes"; then
1828: if test "x$ac_cv_header_sys_poll_h" = "xyes"; then
1829: CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_POLL_H])
1830: fi
1831: fi
1832: #
1833: ])
1834:
1835:
1836: dnl CURL_CHECK_FUNC_SELECT
1837: dnl -------------------------------------------------
1838: dnl Test if the socket select() function is available,
1839: dnl and check its return type and the types of its
1840: dnl arguments. If the function succeeds HAVE_SELECT
1841: dnl will be defined, defining the types of the
1842: dnl arguments in SELECT_TYPE_ARG1, SELECT_TYPE_ARG234
1843: dnl and SELECT_TYPE_ARG5, defining the type of the
1844: dnl function return value in SELECT_TYPE_RETV, and
1845: dnl also defining the type qualifier of fifth argument
1846: dnl in SELECT_QUAL_ARG5.
1847:
1848: AC_DEFUN([CURL_CHECK_FUNC_SELECT], [
1849: AC_REQUIRE([CURL_CHECK_STRUCT_TIMEVAL])dnl
1850: AC_CHECK_HEADERS(sys/select.h sys/socket.h)
1851: #
1852: AC_MSG_CHECKING([for select])
1853: AC_LINK_IFELSE([
1854: AC_LANG_PROGRAM([[
1855: #undef inline
1856: #ifdef HAVE_WINDOWS_H
1857: #ifndef WIN32_LEAN_AND_MEAN
1858: #define WIN32_LEAN_AND_MEAN
1859: #endif
1860: #include <windows.h>
1861: #ifdef HAVE_WINSOCK2_H
1862: #include <winsock2.h>
1863: #else
1864: #ifdef HAVE_WINSOCK_H
1865: #include <winsock.h>
1866: #endif
1867: #endif
1868: #endif
1869: #ifdef HAVE_SYS_TYPES_H
1870: #include <sys/types.h>
1871: #endif
1872: #ifdef HAVE_SYS_TIME_H
1873: #include <sys/time.h>
1874: #ifdef TIME_WITH_SYS_TIME
1875: #include <time.h>
1876: #endif
1877: #else
1878: #ifdef HAVE_TIME_H
1879: #include <time.h>
1880: #endif
1881: #endif
1882: #ifndef HAVE_WINDOWS_H
1883: #ifdef HAVE_PROTO_BSDSOCKET_H
1884: #include <proto/bsdsocket.h>
1885: struct Library *SocketBase = NULL;
1886: #define select(a,b,c,d,e) WaitSelect(a,b,c,d,e,0)
1887: #endif
1888: #ifdef HAVE_SYS_SELECT_H
1889: #include <sys/select.h>
1890: #elif defined(HAVE_UNISTD_H)
1891: #include <unistd.h>
1892: #endif
1893: #ifdef HAVE_SYS_SOCKET_H
1894: #include <sys/socket.h>
1895: #endif
1896: #endif
1897: ]],[[
1898: select(0, 0, 0, 0, 0);
1899: ]])
1900: ],[
1901: AC_MSG_RESULT([yes])
1902: curl_cv_select="yes"
1903: ],[
1904: AC_MSG_RESULT([no])
1905: curl_cv_select="no"
1906: ])
1907: #
1908: if test "$curl_cv_select" = "yes"; then
1909: AC_CACHE_CHECK([types of args and return type for select],
1910: [curl_cv_func_select_args], [
1911: curl_cv_func_select_args="unknown"
1912: for sel_retv in 'int' 'ssize_t'; do
1913: for sel_arg1 in 'int' 'ssize_t' 'size_t' 'unsigned long int' 'unsigned int'; do
1914: for sel_arg234 in 'fd_set *' 'int *' 'void *'; do
1915: for sel_arg5 in 'struct timeval *' 'const struct timeval *'; do
1916: if test "$curl_cv_func_select_args" = "unknown"; then
1917: AC_COMPILE_IFELSE([
1918: AC_LANG_PROGRAM([[
1919: #undef inline
1920: #ifdef HAVE_WINDOWS_H
1921: #ifndef WIN32_LEAN_AND_MEAN
1922: #define WIN32_LEAN_AND_MEAN
1923: #endif
1924: #include <windows.h>
1925: #ifdef HAVE_WINSOCK2_H
1926: #include <winsock2.h>
1927: #else
1928: #ifdef HAVE_WINSOCK_H
1929: #include <winsock.h>
1930: #endif
1931: #endif
1932: #define SELECTCALLCONV PASCAL
1933: #endif
1934: #ifdef HAVE_SYS_TYPES_H
1935: #include <sys/types.h>
1936: #endif
1937: #ifdef HAVE_SYS_TIME_H
1938: #include <sys/time.h>
1939: #ifdef TIME_WITH_SYS_TIME
1940: #include <time.h>
1941: #endif
1942: #else
1943: #ifdef HAVE_TIME_H
1944: #include <time.h>
1945: #endif
1946: #endif
1947: #ifndef HAVE_WINDOWS_H
1948: #ifdef HAVE_PROTO_BSDSOCKET_H
1949: #include <proto/bsdsocket.h>
1950: struct Library *SocketBase = NULL;
1951: #define select(a,b,c,d,e) WaitSelect(a,b,c,d,e,0)
1952: #endif
1953: #ifdef HAVE_SYS_SELECT_H
1954: #include <sys/select.h>
1955: #elif defined(HAVE_UNISTD_H)
1956: #include <unistd.h>
1957: #endif
1958: #ifdef HAVE_SYS_SOCKET_H
1959: #include <sys/socket.h>
1960: #endif
1961: #define SELECTCALLCONV
1962: #endif
1963: #ifndef HAVE_STRUCT_TIMEVAL
1964: struct timeval {
1965: long tv_sec;
1966: long tv_usec;
1967: };
1968: #endif
1969: #ifndef HAVE_PROTO_BSDSOCKET_H
1970: extern $sel_retv SELECTCALLCONV
1971: select($sel_arg1,
1972: $sel_arg234,
1973: $sel_arg234,
1974: $sel_arg234,
1975: $sel_arg5);
1976: #endif
1977: ]],[[
1978: $sel_arg1 nfds=0;
1979: $sel_arg234 rfds=0;
1980: $sel_arg234 wfds=0;
1981: $sel_arg234 efds=0;
1982: $sel_retv res = select(nfds, rfds, wfds, efds, 0);
1983: ]])
1984: ],[
1985: curl_cv_func_select_args="$sel_arg1,$sel_arg234,$sel_arg5,$sel_retv"
1986: ])
1987: fi
1988: done
1989: done
1990: done
1991: done
1992: ]) # AC-CACHE-CHECK
1993: if test "$curl_cv_func_select_args" = "unknown"; then
1994: AC_MSG_WARN([Cannot find proper types to use for select args])
1995: AC_MSG_WARN([HAVE_SELECT will not be defined])
1996: else
1997: select_prev_IFS=$IFS; IFS=','
1998: set dummy `echo "$curl_cv_func_select_args" | sed 's/\*/\*/g'`
1999: IFS=$select_prev_IFS
2000: shift
2001: #
2002: sel_qual_type_arg5=$[3]
2003: #
2004: AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG1, $[1],
2005: [Define to the type of arg 1 for select.])
2006: AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG234, $[2],
2007: [Define to the type of args 2, 3 and 4 for select.])
2008: AC_DEFINE_UNQUOTED(SELECT_TYPE_RETV, $[4],
2009: [Define to the function return type for select.])
2010: #
2011: prev_sh_opts=$-
2012: #
2013: case $prev_sh_opts in
2014: *f*)
2015: ;;
2016: *)
2017: set -f
2018: ;;
2019: esac
2020: #
2021: case "$sel_qual_type_arg5" in
2022: const*)
2023: sel_qual_arg5=const
2024: sel_type_arg5=`echo $sel_qual_type_arg5 | sed 's/^const //'`
2025: ;;
2026: *)
2027: sel_qual_arg5=
2028: sel_type_arg5=$sel_qual_type_arg5
2029: ;;
2030: esac
2031: #
2032: AC_DEFINE_UNQUOTED(SELECT_QUAL_ARG5, $sel_qual_arg5,
2033: [Define to the type qualifier of arg 5 for select.])
2034: AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG5, $sel_type_arg5,
2035: [Define to the type of arg 5 for select.])
2036: #
2037: case $prev_sh_opts in
2038: *f*)
2039: ;;
2040: *)
2041: set +f
2042: ;;
2043: esac
2044: #
2045: AC_DEFINE_UNQUOTED(HAVE_SELECT, 1,
2046: [Define to 1 if you have the select function.])
2047: curl_cv_func_select="yes"
2048: fi
2049: fi
2050: ])
2051:
2052:
2053: dnl CURL_VERIFY_RUNTIMELIBS
2054: dnl -------------------------------------------------
2055: dnl Verify that the shared libs found so far can be used when running
2056: dnl programs, since otherwise the situation will create odd configure errors
2057: dnl that are misleading people.
2058: dnl
2059: dnl Make sure this test is run BEFORE the first test in the script that
2060: dnl runs anything, which at the time of this writing is the AC_CHECK_SIZEOF
2061: dnl macro. It must also run AFTER all lib-checking macros are complete.
2062:
2063: AC_DEFUN([CURL_VERIFY_RUNTIMELIBS], [
2064:
2065: dnl this test is of course not sensible if we are cross-compiling!
2066: if test "x$cross_compiling" != xyes; then
2067:
2068: dnl just run a program to verify that the libs checked for previous to this
2069: dnl point also is available run-time!
2070: AC_MSG_CHECKING([run-time libs availability])
2071: CURL_RUN_IFELSE([
2072: int main()
2073: {
2074: return 0;
2075: }
2076: ],
2077: AC_MSG_RESULT([fine]),
2078: AC_MSG_RESULT([failed])
2079: AC_MSG_ERROR([one or more libs available at link-time are not available run-time. Libs used at link-time: $LIBS])
2080: )
2081:
2082: dnl if this test fails, configure has already stopped
2083: fi
2084: ])
2085:
2086:
2087: dnl CURL_CHECK_VARIADIC_MACROS
2088: dnl -------------------------------------------------
2089: dnl Check compiler support of variadic macros
2090:
2091: AC_DEFUN([CURL_CHECK_VARIADIC_MACROS], [
2092: AC_CACHE_CHECK([for compiler support of C99 variadic macro style],
2093: [curl_cv_variadic_macros_c99], [
2094: AC_COMPILE_IFELSE([
2095: AC_LANG_PROGRAM([[
2096: #define c99_vmacro3(first, ...) fun3(first, __VA_ARGS__)
2097: #define c99_vmacro2(first, ...) fun2(first, __VA_ARGS__)
2098: int fun3(int arg1, int arg2, int arg3);
2099: int fun2(int arg1, int arg2);
2100: int fun3(int arg1, int arg2, int arg3)
2101: { return arg1 + arg2 + arg3; }
2102: int fun2(int arg1, int arg2)
2103: { return arg1 + arg2; }
2104: ]],[[
2105: int res3 = c99_vmacro3(1, 2, 3);
2106: int res2 = c99_vmacro2(1, 2);
2107: ]])
2108: ],[
2109: curl_cv_variadic_macros_c99="yes"
2110: ],[
2111: curl_cv_variadic_macros_c99="no"
2112: ])
2113: ])
2114: case "$curl_cv_variadic_macros_c99" in
2115: yes)
2116: AC_DEFINE_UNQUOTED(HAVE_VARIADIC_MACROS_C99, 1,
2117: [Define to 1 if compiler supports C99 variadic macro style.])
2118: ;;
2119: esac
2120: AC_CACHE_CHECK([for compiler support of old gcc variadic macro style],
2121: [curl_cv_variadic_macros_gcc], [
2122: AC_COMPILE_IFELSE([
2123: AC_LANG_PROGRAM([[
2124: #define gcc_vmacro3(first, args...) fun3(first, args)
2125: #define gcc_vmacro2(first, args...) fun2(first, args)
2126: int fun3(int arg1, int arg2, int arg3);
2127: int fun2(int arg1, int arg2);
2128: int fun3(int arg1, int arg2, int arg3)
2129: { return arg1 + arg2 + arg3; }
2130: int fun2(int arg1, int arg2)
2131: { return arg1 + arg2; }
2132: ]],[[
2133: int res3 = gcc_vmacro3(1, 2, 3);
2134: int res2 = gcc_vmacro2(1, 2);
2135: ]])
2136: ],[
2137: curl_cv_variadic_macros_gcc="yes"
2138: ],[
2139: curl_cv_variadic_macros_gcc="no"
2140: ])
2141: ])
2142: case "$curl_cv_variadic_macros_gcc" in
2143: yes)
2144: AC_DEFINE_UNQUOTED(HAVE_VARIADIC_MACROS_GCC, 1,
2145: [Define to 1 if compiler supports old gcc variadic macro style.])
2146: ;;
2147: esac
2148: ])
2149:
2150:
2151: dnl CURL_CHECK_CA_BUNDLE
2152: dnl -------------------------------------------------
2153: dnl Check if a default ca-bundle should be used
2154: dnl
2155: dnl regarding the paths this will scan:
2156: dnl /etc/ssl/certs/ca-certificates.crt Debian systems
2157: dnl /etc/pki/tls/certs/ca-bundle.crt Redhat and Mandriva
2158: dnl /usr/share/ssl/certs/ca-bundle.crt old(er) Redhat
2159: dnl /usr/local/share/certs/ca-root-nss.crt FreeBSD
2160: dnl /etc/ssl/cert.pem OpenBSD, FreeBSD (symlink)
2161: dnl /etc/ssl/certs/ (ca path) SUSE
2162:
2163: AC_DEFUN([CURL_CHECK_CA_BUNDLE], [
2164:
2165: AC_MSG_CHECKING([default CA cert bundle/path])
2166:
2167: AC_ARG_WITH(ca-bundle,
2168: AC_HELP_STRING([--with-ca-bundle=FILE],
2169: [Path to a file containing CA certificates (example: /etc/ca-bundle.crt)])
2170: AC_HELP_STRING([--without-ca-bundle], [Don't use a default CA bundle]),
2171: [
2172: want_ca="$withval"
2173: if test "x$want_ca" = "xyes"; then
2174: AC_MSG_ERROR([--with-ca-bundle=FILE requires a path to the CA bundle])
2175: fi
2176: ],
2177: [ want_ca="unset" ])
2178: AC_ARG_WITH(ca-path,
2179: AC_HELP_STRING([--with-ca-path=DIRECTORY],
2180: [Path to a directory containing CA certificates stored individually, with \
2181: their filenames in a hash format. This option can be used with the OpenSSL, \
2182: GnuTLS and mbedTLS backends. Refer to OpenSSL c_rehash for details. \
2183: (example: /etc/certificates)])
2184: AC_HELP_STRING([--without-ca-path], [Don't use a default CA path]),
2185: [
2186: want_capath="$withval"
2187: if test "x$want_capath" = "xyes"; then
2188: AC_MSG_ERROR([--with-ca-path=DIRECTORY requires a path to the CA path directory])
2189: fi
2190: ],
2191: [ want_capath="unset"])
2192:
2193: ca_warning=" (warning: certs not found)"
2194: capath_warning=" (warning: certs not found)"
2195: check_capath=""
2196:
2197: if test "x$want_ca" != "xno" -a "x$want_ca" != "xunset" -a \
2198: "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
2199: dnl both given
2200: ca="$want_ca"
2201: capath="$want_capath"
2202: elif test "x$want_ca" != "xno" -a "x$want_ca" != "xunset"; then
2203: dnl --with-ca-bundle given
2204: ca="$want_ca"
2205: capath="no"
2206: elif test "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
2207: dnl --with-ca-path given
2208: if test "x$OPENSSL_ENABLED" != "x1" -a "x$GNUTLS_ENABLED" != "x1" -a "x$MBEDTLS_ENABLED" != "x1"; then
2209: AC_MSG_ERROR([--with-ca-path only works with OpenSSL, GnuTLS or mbedTLS])
2210: fi
2211: capath="$want_capath"
2212: ca="no"
2213: else
2214: dnl first try autodetecting a CA bundle , then a CA path
2215: dnl both autodetections can be skipped by --without-ca-*
2216: ca="no"
2217: capath="no"
2218: if test "x$cross_compiling" != "xyes"; then
2219: dnl NOT cross-compiling and...
2220: dnl neither of the --with-ca-* options are provided
2221: if test "x$want_ca" = "xunset"; then
2222: dnl the path we previously would have installed the curl ca bundle
2223: dnl to, and thus we now check for an already existing cert in that
2224: dnl place in case we find no other
2225: if test "x$prefix" != xNONE; then
2226: cac="${prefix}/share/curl/curl-ca-bundle.crt"
2227: else
2228: cac="$ac_default_prefix/share/curl/curl-ca-bundle.crt"
2229: fi
2230:
2231: for a in /etc/ssl/certs/ca-certificates.crt \
2232: /etc/pki/tls/certs/ca-bundle.crt \
2233: /usr/share/ssl/certs/ca-bundle.crt \
2234: /usr/local/share/certs/ca-root-nss.crt \
2235: /etc/ssl/cert.pem \
2236: "$cac"; do
2237: if test -f "$a"; then
2238: ca="$a"
2239: break
2240: fi
2241: done
2242: fi
2243: if test "x$want_capath" = "xunset" -a "x$ca" = "xno" -a \
2244: "x$OPENSSL_ENABLED" = "x1"; then
2245: check_capath="/etc/ssl/certs/"
2246: fi
2247: else
2248: dnl no option given and cross-compiling
2249: AC_MSG_WARN([skipped the ca-cert path detection when cross-compiling])
2250: fi
2251: fi
2252:
2253: if test "x$ca" = "xno" || test -f "$ca"; then
2254: ca_warning=""
2255: fi
2256:
2257: if test "x$capath" != "xno"; then
2258: check_capath="$capath"
2259: fi
2260:
2261: if test ! -z "$check_capath"; then
2262: for a in "$check_capath"; do
2263: 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
2264: if test "x$capath" = "xno"; then
2265: capath="$a"
2266: fi
2267: capath_warning=""
2268: break
2269: fi
2270: done
2271: fi
2272:
2273: if test "x$capath" = "xno"; then
2274: capath_warning=""
2275: fi
2276:
2277: if test "x$ca" != "xno"; then
2278: CURL_CA_BUNDLE='"'$ca'"'
2279: AC_DEFINE_UNQUOTED(CURL_CA_BUNDLE, "$ca", [Location of default ca bundle])
2280: AC_SUBST(CURL_CA_BUNDLE)
2281: AC_MSG_RESULT([$ca])
2282: fi
2283: if test "x$capath" != "xno"; then
2284: CURL_CA_PATH="\"$capath\""
2285: AC_DEFINE_UNQUOTED(CURL_CA_PATH, "$capath", [Location of default ca path])
2286: AC_MSG_RESULT([$capath (capath)])
2287: fi
2288: if test "x$ca" = "xno" && test "x$capath" = "xno"; then
2289: AC_MSG_RESULT([no])
2290: fi
2291:
2292: AC_MSG_CHECKING([whether to use builtin CA store of SSL library])
2293: AC_ARG_WITH(ca-fallback,
2294: AC_HELP_STRING([--with-ca-fallback], [Use the built in CA store of the SSL library])
2295: AC_HELP_STRING([--without-ca-fallback], [Don't use the built in CA store of the SSL library]),
2296: [
2297: if test "x$with_ca_fallback" != "xyes" -a "x$with_ca_fallback" != "xno"; then
2298: AC_MSG_ERROR([--with-ca-fallback only allows yes or no as parameter])
2299: fi
2300: ],
2301: [ with_ca_fallback="no"])
2302: AC_MSG_RESULT([$with_ca_fallback])
2303: if test "x$with_ca_fallback" = "xyes"; then
2304: if test "x$OPENSSL_ENABLED" != "x1" -a "x$GNUTLS_ENABLED" != "x1"; then
2305: AC_MSG_ERROR([--with-ca-fallback only works with OpenSSL or GnuTLS])
2306: fi
2307: AC_DEFINE_UNQUOTED(CURL_CA_FALLBACK, 1, [define "1" to use built in CA store of SSL library ])
2308: fi
2309: ])
2310:
2311: dnl CURL_CHECK_WIN32_LARGEFILE
2312: dnl -------------------------------------------------
2313: dnl Check if curl's WIN32 large file will be used
2314:
2315: AC_DEFUN([CURL_CHECK_WIN32_LARGEFILE], [
2316: AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
2317: AC_MSG_CHECKING([whether build target supports WIN32 file API])
2318: curl_win32_file_api="no"
2319: if test "$curl_cv_header_windows_h" = "yes"; then
2320: if test x"$enable_largefile" != "xno"; then
2321: AC_COMPILE_IFELSE([
2322: AC_LANG_PROGRAM([[
2323: ]],[[
2324: #if !defined(_WIN32_WCE) && \
2325: (defined(__MINGW32__) || \
2326: (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64))))
2327: int dummy=1;
2328: #else
2329: WIN32 large file API not supported.
2330: #endif
2331: ]])
2332: ],[
2333: curl_win32_file_api="win32_large_files"
2334: ])
2335: fi
2336: if test "$curl_win32_file_api" = "no"; then
2337: AC_COMPILE_IFELSE([
2338: AC_LANG_PROGRAM([[
2339: ]],[[
2340: #if defined(_WIN32_WCE) || defined(__MINGW32__) || defined(_MSC_VER)
2341: int dummy=1;
2342: #else
2343: WIN32 small file API not supported.
2344: #endif
2345: ]])
2346: ],[
2347: curl_win32_file_api="win32_small_files"
2348: ])
2349: fi
2350: fi
2351: case "$curl_win32_file_api" in
2352: win32_large_files)
2353: AC_MSG_RESULT([yes (large file enabled)])
2354: AC_DEFINE_UNQUOTED(USE_WIN32_LARGE_FILES, 1,
2355: [Define to 1 if you are building a Windows target with large file support.])
2356: ;;
2357: win32_small_files)
2358: AC_MSG_RESULT([yes (large file disabled)])
2359: AC_DEFINE_UNQUOTED(USE_WIN32_SMALL_FILES, 1,
2360: [Define to 1 if you are building a Windows target without large file support.])
2361: ;;
2362: *)
2363: AC_MSG_RESULT([no])
2364: ;;
2365: esac
2366: ])
2367:
2368: dnl CURL_EXPORT_PCDIR ($pcdir)
2369: dnl ------------------------
2370: dnl if $pcdir is not empty, set PKG_CONFIG_LIBDIR to $pcdir and export
2371: dnl
2372: dnl we need this macro since pkg-config distinguishes among empty and unset
2373: dnl variable while checking PKG_CONFIG_LIBDIR
2374: dnl
2375:
2376: AC_DEFUN([CURL_EXPORT_PCDIR], [
2377: if test -n "$1"; then
2378: PKG_CONFIG_LIBDIR="$1"
2379: export PKG_CONFIG_LIBDIR
2380: fi
2381: ])
2382:
2383: dnl CURL_CHECK_PKGCONFIG ($module, [$pcdir])
2384: dnl ------------------------
2385: dnl search for the pkg-config tool. Set the PKGCONFIG variable to hold the
2386: dnl path to it, or 'no' if not found/present.
2387: dnl
2388: dnl If pkg-config is present, check that it has info about the $module or
2389: dnl return "no" anyway!
2390: dnl
2391: dnl Optionally PKG_CONFIG_LIBDIR may be given as $pcdir.
2392: dnl
2393:
2394: AC_DEFUN([CURL_CHECK_PKGCONFIG], [
2395: if test -n "$PKG_CONFIG"; then
2396: PKGCONFIG="$PKG_CONFIG"
2397: else
2398: AC_PATH_TOOL([PKGCONFIG], [pkg-config], [no],
2399: [$PATH:/usr/bin:/usr/local/bin])
2400: fi
2401:
2402: if test "x$PKGCONFIG" != "xno"; then
2403: AC_MSG_CHECKING([for $1 options with pkg-config])
2404: dnl ask pkg-config about $1
2405: itexists=`CURL_EXPORT_PCDIR([$2]) dnl
2406: $PKGCONFIG --exists $1 >/dev/null 2>&1 && echo 1`
2407:
2408: if test -z "$itexists"; then
2409: dnl pkg-config does not have info about the given module! set the
2410: dnl variable to 'no'
2411: PKGCONFIG="no"
2412: AC_MSG_RESULT([no])
2413: else
2414: AC_MSG_RESULT([found])
2415: fi
2416: fi
2417: ])
2418:
2419:
2420: dnl CURL_GENERATE_CONFIGUREHELP_PM
2421: dnl -------------------------------------------------
2422: dnl Generate test harness configurehelp.pm module, defining and
2423: dnl initializing some perl variables with values which are known
2424: dnl when the configure script runs. For portability reasons, test
2425: dnl harness needs information on how to run the C preprocessor.
2426:
2427: AC_DEFUN([CURL_GENERATE_CONFIGUREHELP_PM], [
2428: AC_REQUIRE([AC_PROG_CPP])dnl
2429: tmp_cpp=`eval echo "$ac_cpp" 2>/dev/null`
2430: if test -z "$tmp_cpp"; then
2431: tmp_cpp='cpp'
2432: fi
2433: cat >./tests/configurehelp.pm <<_EOF
2434: [@%:@] This is a generated file. Do not edit.
2435:
2436: package configurehelp;
2437:
2438: use strict;
2439: use warnings;
2440: use Exporter;
2441:
2442: use vars qw(
2443: @ISA
2444: @EXPORT_OK
2445: \$Cpreprocessor
2446: );
2447:
2448: @ISA = qw(Exporter);
2449:
2450: @EXPORT_OK = qw(
2451: \$Cpreprocessor
2452: );
2453:
2454: \$Cpreprocessor = '$tmp_cpp';
2455:
2456: 1;
2457: _EOF
2458: ])
2459:
2460: dnl CURL_CPP_P
2461: dnl
2462: dnl Check if $cpp -P should be used for extract define values due to gcc 5
2463: dnl splitting up strings and defines between line outputs. gcc by default
2464: dnl (without -P) will show TEST EINVAL TEST as
2465: dnl
2466: dnl # 13 "conftest.c"
2467: dnl TEST
2468: dnl # 13 "conftest.c" 3 4
2469: dnl 22
2470: dnl # 13 "conftest.c"
2471: dnl TEST
2472:
2473: AC_DEFUN([CURL_CPP_P], [
2474: AC_MSG_CHECKING([if cpp -P is needed])
2475: AC_EGREP_CPP([TEST.*TEST], [
2476: #include <errno.h>
2477: TEST EINVAL TEST
2478: ], [cpp=no], [cpp=yes])
2479: AC_MSG_RESULT([$cpp])
2480:
2481: dnl we need cpp -P so check if it works then
2482: if test "x$cpp" = "xyes"; then
2483: AC_MSG_CHECKING([if cpp -P works])
2484: OLDCPPFLAGS=$CPPFLAGS
2485: CPPFLAGS="$CPPFLAGS -P"
2486: AC_EGREP_CPP([TEST.*TEST], [
2487: #include <errno.h>
2488: TEST EINVAL TEST
2489: ], [cpp_p=yes], [cpp_p=no])
2490: AC_MSG_RESULT([$cpp_p])
2491:
2492: if test "x$cpp_p" = "xno"; then
2493: AC_MSG_WARN([failed to figure out cpp -P alternative])
2494: # without -P
2495: CPPPFLAG=""
2496: else
2497: # with -P
2498: CPPPFLAG="-P"
2499: fi
2500: dnl restore CPPFLAGS
2501: CPPFLAGS=$OLDCPPFLAGS
2502: else
2503: # without -P
2504: CPPPFLAG=""
2505: fi
2506: ])
2507:
2508:
2509: dnl CURL_MAC_CFLAGS
2510: dnl
2511: dnl Check if -mmacosx-version-min, -miphoneos-version-min or any
2512: dnl similar are set manually, otherwise do. And set
2513: dnl -Werror=partial-availability.
2514: dnl
2515:
2516: AC_DEFUN([CURL_MAC_CFLAGS], [
2517:
2518: tst_cflags="no"
2519: case $host_os in
2520: darwin*)
2521: tst_cflags="yes"
2522: ;;
2523: esac
2524:
2525: AC_MSG_CHECKING([for good-to-use Mac CFLAGS])
2526: AC_MSG_RESULT([$tst_cflags]);
2527:
2528: if test "$tst_cflags" = "yes"; then
2529: AC_MSG_CHECKING([for *version-min in CFLAGS])
2530: min=""
2531: if test -z "$(echo $CFLAGS | grep m.*os.*-version-min)"; then
2532: min="-mmacosx-version-min=10.8"
2533: CFLAGS="$CFLAGS $min"
2534: fi
2535: if test -z "$min"; then
2536: AC_MSG_RESULT([set by user])
2537: else
2538: AC_MSG_RESULT([$min set])
2539: fi
2540:
2541: old_CFLAGS=$CFLAGS
2542: CFLAGS="$CFLAGS -Werror=partial-availability"
2543: AC_MSG_CHECKING([whether $CC accepts -Werror=partial-availability])
2544: AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
2545: [AC_MSG_RESULT([yes])],
2546: [AC_MSG_RESULT([no])
2547: CFLAGS=$old_CFLAGS])
2548: fi
2549:
2550: ])
2551:
2552:
2553: dnl CURL_SUPPORTS_BUILTIN_AVAILABLE
2554: dnl
2555: dnl Check to see if the compiler supports __builtin_available. This built-in
2556: dnl compiler function first appeared in Apple LLVM 9.0.0. It's so new that, at
2557: dnl the time this macro was written, the function was not yet documented. Its
2558: dnl purpose is to return true if the code is running under a certain OS version
2559: dnl or later.
2560:
2561: AC_DEFUN([CURL_SUPPORTS_BUILTIN_AVAILABLE], [
2562: AC_MSG_CHECKING([to see if the compiler supports __builtin_available()])
2563: AC_COMPILE_IFELSE([
2564: AC_LANG_PROGRAM([[
2565: #include <stdlib.h>
2566: ]],[[
2567: if (__builtin_available(macOS 10.8, iOS 5.0, *)) {}
2568: ]])
2569: ],[
2570: AC_MSG_RESULT([yes])
2571: AC_DEFINE_UNQUOTED(HAVE_BUILTIN_AVAILABLE, 1,
2572: [Define to 1 if you have the __builtin_available function.])
2573: ],[
2574: AC_MSG_RESULT([no])
2575: ])
2576: ])
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to acinclude.m4 CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl