Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/curl/acinclude.m4 @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 #***************************************************************************
2 # _ _ ____ _
3 # Project ___| | | | _ \| |
4 # / __| | | | |_) | |
5 # | (__| |_| | _ <| |___
6 # \___|\___/|_| \_\_____|
7 #
8 # Copyright (C) 1998 - 2018, 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 #endif
1891 #ifdef HAVE_SYS_SOCKET_H
1892 #include <sys/socket.h>
1893 #endif
1894 #endif
1895 ]],[[
1896 select(0, 0, 0, 0, 0);
1897 ]])
1898 ],[
1899 AC_MSG_RESULT([yes])
1900 curl_cv_select="yes"
1901 ],[
1902 AC_MSG_RESULT([no])
1903 curl_cv_select="no"
1904 ])
1905 #
1906 if test "$curl_cv_select" = "yes"; then
1907 AC_CACHE_CHECK([types of args and return type for select],
1908 [curl_cv_func_select_args], [
1909 curl_cv_func_select_args="unknown"
1910 for sel_retv in 'int' 'ssize_t'; do
1911 for sel_arg1 in 'int' 'ssize_t' 'size_t' 'unsigned long int' 'unsigned int'; do
1912 for sel_arg234 in 'fd_set *' 'int *' 'void *'; do
1913 for sel_arg5 in 'struct timeval *' 'const struct timeval *'; do
1914 if test "$curl_cv_func_select_args" = "unknown"; then
1915 AC_COMPILE_IFELSE([
1916 AC_LANG_PROGRAM([[
1917 #undef inline
1918 #ifdef HAVE_WINDOWS_H
1919 #ifndef WIN32_LEAN_AND_MEAN
1920 #define WIN32_LEAN_AND_MEAN
1921 #endif
1922 #include <windows.h>
1923 #ifdef HAVE_WINSOCK2_H
1924 #include <winsock2.h>
1925 #else
1926 #ifdef HAVE_WINSOCK_H
1927 #include <winsock.h>
1928 #endif
1929 #endif
1930 #define SELECTCALLCONV PASCAL
1931 #endif
1932 #ifdef HAVE_SYS_TYPES_H
1933 #include <sys/types.h>
1934 #endif
1935 #ifdef HAVE_SYS_TIME_H
1936 #include <sys/time.h>
1937 #ifdef TIME_WITH_SYS_TIME
1938 #include <time.h>
1939 #endif
1940 #else
1941 #ifdef HAVE_TIME_H
1942 #include <time.h>
1943 #endif
1944 #endif
1945 #ifndef HAVE_WINDOWS_H
1946 #ifdef HAVE_PROTO_BSDSOCKET_H
1947 #include <proto/bsdsocket.h>
1948 struct Library *SocketBase = NULL;
1949 #define select(a,b,c,d,e) WaitSelect(a,b,c,d,e,0)
1950 #endif
1951 #ifdef HAVE_SYS_SELECT_H
1952 #include <sys/select.h>
1953 #endif
1954 #ifdef HAVE_SYS_SOCKET_H
1955 #include <sys/socket.h>
1956 #endif
1957 #define SELECTCALLCONV
1958 #endif
1959 #ifndef HAVE_STRUCT_TIMEVAL
1960 struct timeval {
1961 long tv_sec;
1962 long tv_usec;
1963 };
1964 #endif
1965 #ifndef HAVE_PROTO_BSDSOCKET_H
1966 extern $sel_retv SELECTCALLCONV
1967 select($sel_arg1,
1968 $sel_arg234,
1969 $sel_arg234,
1970 $sel_arg234,
1971 $sel_arg5);
1972 #endif
1973 ]],[[
1974 $sel_arg1 nfds=0;
1975 $sel_arg234 rfds=0;
1976 $sel_arg234 wfds=0;
1977 $sel_arg234 efds=0;
1978 $sel_retv res = select(nfds, rfds, wfds, efds, 0);
1979 ]])
1980 ],[
1981 curl_cv_func_select_args="$sel_arg1,$sel_arg234,$sel_arg5,$sel_retv"
1982 ])
1983 fi
1984 done
1985 done
1986 done
1987 done
1988 ]) # AC-CACHE-CHECK
1989 if test "$curl_cv_func_select_args" = "unknown"; then
1990 AC_MSG_WARN([Cannot find proper types to use for select args])
1991 AC_MSG_WARN([HAVE_SELECT will not be defined])
1992 else
1993 select_prev_IFS=$IFS; IFS=','
1994 set dummy `echo "$curl_cv_func_select_args" | sed 's/\*/\*/g'`
1995 IFS=$select_prev_IFS
1996 shift
1997 #
1998 sel_qual_type_arg5=$[3]
1999 #
2000 AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG1, $[1],
2001 [Define to the type of arg 1 for select.])
2002 AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG234, $[2],
2003 [Define to the type of args 2, 3 and 4 for select.])
2004 AC_DEFINE_UNQUOTED(SELECT_TYPE_RETV, $[4],
2005 [Define to the function return type for select.])
2006 #
2007 prev_sh_opts=$-
2008 #
2009 case $prev_sh_opts in
2010 *f*)
2011 ;;
2012 *)
2013 set -f
2014 ;;
2015 esac
2016 #
2017 case "$sel_qual_type_arg5" in
2018 const*)
2019 sel_qual_arg5=const
2020 sel_type_arg5=`echo $sel_qual_type_arg5 | sed 's/^const //'`
2021 ;;
2022 *)
2023 sel_qual_arg5=
2024 sel_type_arg5=$sel_qual_type_arg5
2025 ;;
2026 esac
2027 #
2028 AC_DEFINE_UNQUOTED(SELECT_QUAL_ARG5, $sel_qual_arg5,
2029 [Define to the type qualifier of arg 5 for select.])
2030 AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG5, $sel_type_arg5,
2031 [Define to the type of arg 5 for select.])
2032 #
2033 case $prev_sh_opts in
2034 *f*)
2035 ;;
2036 *)
2037 set +f
2038 ;;
2039 esac
2040 #
2041 AC_DEFINE_UNQUOTED(HAVE_SELECT, 1,
2042 [Define to 1 if you have the select function.])
2043 curl_cv_func_select="yes"
2044 fi
2045 fi
2046 ])
2047
2048
2049 dnl CURL_VERIFY_RUNTIMELIBS
2050 dnl -------------------------------------------------
2051 dnl Verify that the shared libs found so far can be used when running
2052 dnl programs, since otherwise the situation will create odd configure errors
2053 dnl that are misleading people.
2054 dnl
2055 dnl Make sure this test is run BEFORE the first test in the script that
2056 dnl runs anything, which at the time of this writing is the AC_CHECK_SIZEOF
2057 dnl macro. It must also run AFTER all lib-checking macros are complete.
2058
2059 AC_DEFUN([CURL_VERIFY_RUNTIMELIBS], [
2060
2061 dnl this test is of course not sensible if we are cross-compiling!
2062 if test "x$cross_compiling" != xyes; then
2063
2064 dnl just run a program to verify that the libs checked for previous to this
2065 dnl point also is available run-time!
2066 AC_MSG_CHECKING([run-time libs availability])
2067 CURL_RUN_IFELSE([
2068 int main()
2069 {
2070 return 0;
2071 }
2072 ],
2073 AC_MSG_RESULT([fine]),
2074 AC_MSG_RESULT([failed])
2075 AC_MSG_ERROR([one or more libs available at link-time are not available run-time. Libs used at link-time: $LIBS])
2076 )
2077
2078 dnl if this test fails, configure has already stopped
2079 fi
2080 ])
2081
2082
2083 dnl CURL_CHECK_VARIADIC_MACROS
2084 dnl -------------------------------------------------
2085 dnl Check compiler support of variadic macros
2086
2087 AC_DEFUN([CURL_CHECK_VARIADIC_MACROS], [
2088 AC_CACHE_CHECK([for compiler support of C99 variadic macro style],
2089 [curl_cv_variadic_macros_c99], [
2090 AC_COMPILE_IFELSE([
2091 AC_LANG_PROGRAM([[
2092 #define c99_vmacro3(first, ...) fun3(first, __VA_ARGS__)
2093 #define c99_vmacro2(first, ...) fun2(first, __VA_ARGS__)
2094 int fun3(int arg1, int arg2, int arg3);
2095 int fun2(int arg1, int arg2);
2096 int fun3(int arg1, int arg2, int arg3)
2097 { return arg1 + arg2 + arg3; }
2098 int fun2(int arg1, int arg2)
2099 { return arg1 + arg2; }
2100 ]],[[
2101 int res3 = c99_vmacro3(1, 2, 3);
2102 int res2 = c99_vmacro2(1, 2);
2103 ]])
2104 ],[
2105 curl_cv_variadic_macros_c99="yes"
2106 ],[
2107 curl_cv_variadic_macros_c99="no"
2108 ])
2109 ])
2110 case "$curl_cv_variadic_macros_c99" in
2111 yes)
2112 AC_DEFINE_UNQUOTED(HAVE_VARIADIC_MACROS_C99, 1,
2113 [Define to 1 if compiler supports C99 variadic macro style.])
2114 ;;
2115 esac
2116 AC_CACHE_CHECK([for compiler support of old gcc variadic macro style],
2117 [curl_cv_variadic_macros_gcc], [
2118 AC_COMPILE_IFELSE([
2119 AC_LANG_PROGRAM([[
2120 #define gcc_vmacro3(first, args...) fun3(first, args)
2121 #define gcc_vmacro2(first, args...) fun2(first, args)
2122 int fun3(int arg1, int arg2, int arg3);
2123 int fun2(int arg1, int arg2);
2124 int fun3(int arg1, int arg2, int arg3)
2125 { return arg1 + arg2 + arg3; }
2126 int fun2(int arg1, int arg2)
2127 { return arg1 + arg2; }
2128 ]],[[
2129 int res3 = gcc_vmacro3(1, 2, 3);
2130 int res2 = gcc_vmacro2(1, 2);
2131 ]])
2132 ],[
2133 curl_cv_variadic_macros_gcc="yes"
2134 ],[
2135 curl_cv_variadic_macros_gcc="no"
2136 ])
2137 ])
2138 case "$curl_cv_variadic_macros_gcc" in
2139 yes)
2140 AC_DEFINE_UNQUOTED(HAVE_VARIADIC_MACROS_GCC, 1,
2141 [Define to 1 if compiler supports old gcc variadic macro style.])
2142 ;;
2143 esac
2144 ])
2145
2146
2147 dnl CURL_CHECK_CA_BUNDLE
2148 dnl -------------------------------------------------
2149 dnl Check if a default ca-bundle should be used
2150 dnl
2151 dnl regarding the paths this will scan:
2152 dnl /etc/ssl/certs/ca-certificates.crt Debian systems
2153 dnl /etc/pki/tls/certs/ca-bundle.crt Redhat and Mandriva
2154 dnl /usr/share/ssl/certs/ca-bundle.crt old(er) Redhat
2155 dnl /usr/local/share/certs/ca-root-nss.crt FreeBSD
2156 dnl /etc/ssl/cert.pem OpenBSD, FreeBSD (symlink)
2157 dnl /etc/ssl/certs/ (ca path) SUSE
2158
2159 AC_DEFUN([CURL_CHECK_CA_BUNDLE], [
2160
2161 AC_MSG_CHECKING([default CA cert bundle/path])
2162
2163 AC_ARG_WITH(ca-bundle,
2164 AC_HELP_STRING([--with-ca-bundle=FILE],
2165 [Path to a file containing CA certificates (example: /etc/ca-bundle.crt)])
2166 AC_HELP_STRING([--without-ca-bundle], [Don't use a default CA bundle]),
2167 [
2168 want_ca="$withval"
2169 if test "x$want_ca" = "xyes"; then
2170 AC_MSG_ERROR([--with-ca-bundle=FILE requires a path to the CA bundle])
2171 fi
2172 ],
2173 [ want_ca="unset" ])
2174 AC_ARG_WITH(ca-path,
2175 AC_HELP_STRING([--with-ca-path=DIRECTORY],
2176 [Path to a directory containing CA certificates stored individually, with \
2177 their filenames in a hash format. This option can be used with OpenSSL, \
2178 GnuTLS and PolarSSL backends. Refer to OpenSSL c_rehash for details. \
2179 (example: /etc/certificates)])
2180 AC_HELP_STRING([--without-ca-path], [Don't use a default CA path]),
2181 [
2182 want_capath="$withval"
2183 if test "x$want_capath" = "xyes"; then
2184 AC_MSG_ERROR([--with-ca-path=DIRECTORY requires a path to the CA path directory])
2185 fi
2186 ],
2187 [ want_capath="unset"])
2188
2189 ca_warning=" (warning: certs not found)"
2190 capath_warning=" (warning: certs not found)"
2191 check_capath=""
2192
2193 if test "x$want_ca" != "xno" -a "x$want_ca" != "xunset" -a \
2194 "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
2195 dnl both given
2196 ca="$want_ca"
2197 capath="$want_capath"
2198 elif test "x$want_ca" != "xno" -a "x$want_ca" != "xunset"; then
2199 dnl --with-ca-bundle given
2200 ca="$want_ca"
2201 capath="no"
2202 elif test "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
2203 dnl --with-ca-path given
2204 if test "x$OPENSSL_ENABLED" != "x1" -a "x$GNUTLS_ENABLED" != "x1" -a "x$POLARSSL_ENABLED" != "x1"; then
2205 AC_MSG_ERROR([--with-ca-path only works with OpenSSL, GnuTLS or PolarSSL])
2206 fi
2207 capath="$want_capath"
2208 ca="no"
2209 else
2210 dnl first try autodetecting a CA bundle , then a CA path
2211 dnl both autodetections can be skipped by --without-ca-*
2212 ca="no"
2213 capath="no"
2214 if test "x$cross_compiling" != "xyes"; then
2215 dnl NOT cross-compiling and...
2216 dnl neither of the --with-ca-* options are provided
2217 if test "x$want_ca" = "xunset"; then
2218 dnl the path we previously would have installed the curl ca bundle
2219 dnl to, and thus we now check for an already existing cert in that
2220 dnl place in case we find no other
2221 if test "x$prefix" != xNONE; then
2222 cac="${prefix}/share/curl/curl-ca-bundle.crt"
2223 else
2224 cac="$ac_default_prefix/share/curl/curl-ca-bundle.crt"
2225 fi
2226
2227 for a in /etc/ssl/certs/ca-certificates.crt \
2228 /etc/pki/tls/certs/ca-bundle.crt \
2229 /usr/share/ssl/certs/ca-bundle.crt \
2230 /usr/local/share/certs/ca-root-nss.crt \
2231 /etc/ssl/cert.pem \
2232 "$cac"; do
2233 if test -f "$a"; then
2234 ca="$a"
2235 break
2236 fi
2237 done
2238 fi
2239 if test "x$want_capath" = "xunset" -a "x$ca" = "xno" -a \
2240 "x$OPENSSL_ENABLED" = "x1"; then
2241 check_capath="/etc/ssl/certs/"
2242 fi
2243 else
2244 dnl no option given and cross-compiling
2245 AC_MSG_WARN([skipped the ca-cert path detection when cross-compiling])
2246 fi
2247 fi
2248
2249 if test "x$ca" = "xno" || test -f "$ca"; then
2250 ca_warning=""
2251 fi
2252
2253 if test "x$capath" != "xno"; then
2254 check_capath="$capath"
2255 fi
2256
2257 if test ! -z "$check_capath"; then
2258 for a in "$check_capath"; do
2259 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
2260 if test "x$capath" = "xno"; then
2261 capath="$a"
2262 fi
2263 capath_warning=""
2264 break
2265 fi
2266 done
2267 fi
2268
2269 if test "x$capath" = "xno"; then
2270 capath_warning=""
2271 fi
2272
2273 if test "x$ca" != "xno"; then
2274 CURL_CA_BUNDLE='"'$ca'"'
2275 AC_DEFINE_UNQUOTED(CURL_CA_BUNDLE, "$ca", [Location of default ca bundle])
2276 AC_SUBST(CURL_CA_BUNDLE)
2277 AC_MSG_RESULT([$ca])
2278 fi
2279 if test "x$capath" != "xno"; then
2280 CURL_CA_PATH="\"$capath\""
2281 AC_DEFINE_UNQUOTED(CURL_CA_PATH, "$capath", [Location of default ca path])
2282 AC_MSG_RESULT([$capath (capath)])
2283 fi
2284 if test "x$ca" = "xno" && test "x$capath" = "xno"; then
2285 AC_MSG_RESULT([no])
2286 fi
2287
2288 AC_MSG_CHECKING([whether to use builtin CA store of SSL library])
2289 AC_ARG_WITH(ca-fallback,
2290 AC_HELP_STRING([--with-ca-fallback], [Use the built in CA store of the SSL library])
2291 AC_HELP_STRING([--without-ca-fallback], [Don't use the built in CA store of the SSL library]),
2292 [
2293 if test "x$with_ca_fallback" != "xyes" -a "x$with_ca_fallback" != "xno"; then
2294 AC_MSG_ERROR([--with-ca-fallback only allows yes or no as parameter])
2295 fi
2296 ],
2297 [ with_ca_fallback="no"])
2298 AC_MSG_RESULT([$with_ca_fallback])
2299 if test "x$with_ca_fallback" = "xyes"; then
2300 if test "x$OPENSSL_ENABLED" != "x1" -a "x$GNUTLS_ENABLED" != "x1"; then
2301 AC_MSG_ERROR([--with-ca-fallback only works with OpenSSL or GnuTLS])
2302 fi
2303 AC_DEFINE_UNQUOTED(CURL_CA_FALLBACK, 1, [define "1" to use built in CA store of SSL library ])
2304 fi
2305 ])
2306
2307 dnl CURL_CHECK_WIN32_LARGEFILE
2308 dnl -------------------------------------------------
2309 dnl Check if curl's WIN32 large file will be used
2310
2311 AC_DEFUN([CURL_CHECK_WIN32_LARGEFILE], [
2312 AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
2313 AC_MSG_CHECKING([whether build target supports WIN32 file API])
2314 curl_win32_file_api="no"
2315 if test "$curl_cv_header_windows_h" = "yes"; then
2316 if test x"$enable_largefile" != "xno"; then
2317 AC_COMPILE_IFELSE([
2318 AC_LANG_PROGRAM([[
2319 ]],[[
2320 #if !defined(_WIN32_WCE) && \
2321 (defined(__MINGW32__) || \
2322 (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64))))
2323 int dummy=1;
2324 #else
2325 WIN32 large file API not supported.
2326 #endif
2327 ]])
2328 ],[
2329 curl_win32_file_api="win32_large_files"
2330 ])
2331 fi
2332 if test "$curl_win32_file_api" = "no"; then
2333 AC_COMPILE_IFELSE([
2334 AC_LANG_PROGRAM([[
2335 ]],[[
2336 #if defined(_WIN32_WCE) || defined(__MINGW32__) || defined(_MSC_VER)
2337 int dummy=1;
2338 #else
2339 WIN32 small file API not supported.
2340 #endif
2341 ]])
2342 ],[
2343 curl_win32_file_api="win32_small_files"
2344 ])
2345 fi
2346 fi
2347 case "$curl_win32_file_api" in
2348 win32_large_files)
2349 AC_MSG_RESULT([yes (large file enabled)])
2350 AC_DEFINE_UNQUOTED(USE_WIN32_LARGE_FILES, 1,
2351 [Define to 1 if you are building a Windows target with large file support.])
2352 ;;
2353 win32_small_files)
2354 AC_MSG_RESULT([yes (large file disabled)])
2355 AC_DEFINE_UNQUOTED(USE_WIN32_SMALL_FILES, 1,
2356 [Define to 1 if you are building a Windows target without large file support.])
2357 ;;
2358 *)
2359 AC_MSG_RESULT([no])
2360 ;;
2361 esac
2362 ])
2363
2364 dnl CURL_EXPORT_PCDIR ($pcdir)
2365 dnl ------------------------
2366 dnl if $pcdir is not empty, set PKG_CONFIG_LIBDIR to $pcdir and export
2367 dnl
2368 dnl we need this macro since pkg-config distinguishes among empty and unset
2369 dnl variable while checking PKG_CONFIG_LIBDIR
2370 dnl
2371
2372 AC_DEFUN([CURL_EXPORT_PCDIR], [
2373 if test -n "$1"; then
2374 PKG_CONFIG_LIBDIR="$1"
2375 export PKG_CONFIG_LIBDIR
2376 fi
2377 ])
2378
2379 dnl CURL_CHECK_PKGCONFIG ($module, [$pcdir])
2380 dnl ------------------------
2381 dnl search for the pkg-config tool. Set the PKGCONFIG variable to hold the
2382 dnl path to it, or 'no' if not found/present.
2383 dnl
2384 dnl If pkg-config is present, check that it has info about the $module or
2385 dnl return "no" anyway!
2386 dnl
2387 dnl Optionally PKG_CONFIG_LIBDIR may be given as $pcdir.
2388 dnl
2389
2390 AC_DEFUN([CURL_CHECK_PKGCONFIG], [
2391 if test -n "$PKG_CONFIG"; then
2392 PKGCONFIG="$PKG_CONFIG"
2393 else
2394 AC_PATH_TOOL([PKGCONFIG], [pkg-config], [no],
2395 [$PATH:/usr/bin:/usr/local/bin])
2396 fi
2397
2398 if test "x$PKGCONFIG" != "xno"; then
2399 AC_MSG_CHECKING([for $1 options with pkg-config])
2400 dnl ask pkg-config about $1
2401 itexists=`CURL_EXPORT_PCDIR([$2]) dnl
2402 $PKGCONFIG --exists $1 >/dev/null 2>&1 && echo 1`
2403
2404 if test -z "$itexists"; then
2405 dnl pkg-config does not have info about the given module! set the
2406 dnl variable to 'no'
2407 PKGCONFIG="no"
2408 AC_MSG_RESULT([no])
2409 else
2410 AC_MSG_RESULT([found])
2411 fi
2412 fi
2413 ])
2414
2415
2416 dnl CURL_GENERATE_CONFIGUREHELP_PM
2417 dnl -------------------------------------------------
2418 dnl Generate test harness configurehelp.pm module, defining and
2419 dnl initializing some perl variables with values which are known
2420 dnl when the configure script runs. For portability reasons, test
2421 dnl harness needs information on how to run the C preprocessor.
2422
2423 AC_DEFUN([CURL_GENERATE_CONFIGUREHELP_PM], [
2424 AC_REQUIRE([AC_PROG_CPP])dnl
2425 tmp_cpp=`eval echo "$ac_cpp" 2>/dev/null`
2426 if test -z "$tmp_cpp"; then
2427 tmp_cpp='cpp'
2428 fi
2429 cat >./tests/configurehelp.pm <<_EOF
2430 [@%:@] This is a generated file. Do not edit.
2431
2432 package configurehelp;
2433
2434 use strict;
2435 use warnings;
2436 use Exporter;
2437
2438 use vars qw(
2439 @ISA
2440 @EXPORT_OK
2441 \$Cpreprocessor
2442 );
2443
2444 @ISA = qw(Exporter);
2445
2446 @EXPORT_OK = qw(
2447 \$Cpreprocessor
2448 );
2449
2450 \$Cpreprocessor = '$tmp_cpp';
2451
2452 1;
2453 _EOF
2454 ])
2455
2456 dnl CURL_CPP_P
2457 dnl
2458 dnl Check if $cpp -P should be used for extract define values due to gcc 5
2459 dnl splitting up strings and defines between line outputs. gcc by default
2460 dnl (without -P) will show TEST EINVAL TEST as
2461 dnl
2462 dnl # 13 "conftest.c"
2463 dnl TEST
2464 dnl # 13 "conftest.c" 3 4
2465 dnl 22
2466 dnl # 13 "conftest.c"
2467 dnl TEST
2468
2469 AC_DEFUN([CURL_CPP_P], [
2470 AC_MSG_CHECKING([if cpp -P is needed])
2471 AC_EGREP_CPP([TEST.*TEST], [
2472 #include <errno.h>
2473 TEST EINVAL TEST
2474 ], [cpp=no], [cpp=yes])
2475 AC_MSG_RESULT([$cpp])
2476
2477 dnl we need cpp -P so check if it works then
2478 if test "x$cpp" = "xyes"; then
2479 AC_MSG_CHECKING([if cpp -P works])
2480 OLDCPPFLAGS=$CPPFLAGS
2481 CPPFLAGS="$CPPFLAGS -P"
2482 AC_EGREP_CPP([TEST.*TEST], [
2483 #include <errno.h>
2484 TEST EINVAL TEST
2485 ], [cpp_p=yes], [cpp_p=no])
2486 AC_MSG_RESULT([$cpp_p])
2487
2488 if test "x$cpp_p" = "xno"; then
2489 AC_MSG_WARN([failed to figure out cpp -P alternative])
2490 # without -P
2491 CPPPFLAG=""
2492 else
2493 # with -P
2494 CPPPFLAG="-P"
2495 fi
2496 dnl restore CPPFLAGS
2497 CPPFLAGS=$OLDCPPFLAGS
2498 else
2499 # without -P
2500 CPPPFLAG=""
2501 fi
2502 ])
2503
2504
2505 dnl CURL_MAC_CFLAGS
2506 dnl
2507 dnl Check if -mmacosx-version-min, -miphoneos-version-min or any
2508 dnl similar are set manually, otherwise do. And set
2509 dnl -Werror=partial-availability.
2510 dnl
2511
2512 AC_DEFUN([CURL_MAC_CFLAGS], [
2513
2514 tst_cflags="no"
2515 case $host_os in
2516 darwin*)
2517 tst_cflags="yes"
2518 ;;
2519 esac
2520
2521 AC_MSG_CHECKING([for good-to-use Mac CFLAGS])
2522 AC_MSG_RESULT([$tst_cflags]);
2523
2524 if test "$tst_cflags" = "yes"; then
2525 AC_MSG_CHECKING([for *version-min in CFLAGS])
2526 min=""
2527 if test -z "$(echo $CFLAGS | grep m.*os.*-version-min)"; then
2528 min="-mmacosx-version-min=10.8"
2529 CFLAGS="$CFLAGS $min"
2530 fi
2531 if test -z "$min"; then
2532 AC_MSG_RESULT([set by user])
2533 else
2534 AC_MSG_RESULT([$min set])
2535 fi
2536
2537 old_CFLAGS=$CFLAGS
2538 CFLAGS="$CFLAGS -Werror=partial-availability"
2539 AC_MSG_CHECKING([whether $CC accepts -Werror=partial-availability])
2540 AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
2541 [AC_MSG_RESULT([yes])],
2542 [AC_MSG_RESULT([no])
2543 CFLAGS=$old_CFLAGS])
2544 fi
2545
2546 ])
2547
2548
2549 dnl CURL_SUPPORTS_BUILTIN_AVAILABLE
2550 dnl
2551 dnl Check to see if the compiler supports __builtin_available. This built-in
2552 dnl compiler function first appeared in Apple LLVM 9.0.0. It's so new that, at
2553 dnl the time this macro was written, the function was not yet documented. Its
2554 dnl purpose is to return true if the code is running under a certain OS version
2555 dnl or later.
2556
2557 AC_DEFUN([CURL_SUPPORTS_BUILTIN_AVAILABLE], [
2558 AC_MSG_CHECKING([to see if the compiler supports __builtin_available()])
2559 AC_COMPILE_IFELSE([
2560 AC_LANG_PROGRAM([[
2561 #include <stdlib.h>
2562 ]],[[
2563 if (__builtin_available(macOS 10.8, iOS 5.0, *)) {}
2564 ]])
2565 ],[
2566 AC_MSG_RESULT([yes])
2567 AC_DEFINE_UNQUOTED(HAVE_BUILTIN_AVAILABLE, 1,
2568 [Define to 1 if you have the __builtin_available function.])
2569 ],[
2570 AC_MSG_RESULT([no])
2571 ])
2572 ])