• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
23dnl CURL_CHECK_DEF (SYMBOL, [INCLUDES], [SILENT])
24dnl -------------------------------------------------
25dnl Use the C preprocessor to find out if the given object-style symbol
26dnl is defined and get its expansion. This macro will not use default
27dnl includes even if no INCLUDES argument is given. This macro will run
28dnl silently when invoked with three arguments. If the expansion would
29dnl result in a set of double-quoted strings the returned expansion will
30dnl actually be a single double-quoted string concatenating all them.
31
32AC_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(
49ifelse($2,,,[$2])[[
50#ifdef $1
51CURL_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
77dnl CURL_CHECK_DEF_CC (SYMBOL, [INCLUDES], [SILENT])
78dnl -------------------------------------------------
79dnl Use the C compiler to find out only if the given symbol is defined
80dnl or not, this can not find out its expansion. This macro will not use
81dnl default includes even if no INCLUDES argument is given. This macro
82dnl will run silently when invoked with three arguments.
83
84AC_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(
89ifelse($2,,,[$2])[[
90int 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
115dnl CURL_CHECK_LIB_XNET
116dnl -------------------------------------------------
117dnl Verify if X/Open network library is required.
118
119AC_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([[
124int 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
143dnl CURL_CHECK_AIX_ALL_SOURCE
144dnl -------------------------------------------------
145dnl Provides a replacement of traditional AC_AIX with
146dnl an uniform behaviour across all autoconf versions,
147dnl and with our own placement rules.
148
149AC_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
172dnl CURL_CHECK_HEADER_WINDOWS
173dnl -------------------------------------------------
174dnl Check for compilable and valid windows.h header
175
176AC_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
207dnl CURL_CHECK_NATIVE_WINDOWS
208dnl -------------------------------------------------
209dnl Check if building a native Windows target
210
211AC_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
238dnl CURL_CHECK_HEADER_WINSOCK
239dnl -------------------------------------------------
240dnl Check for compilable and valid winsock.h header
241
242AC_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
275dnl CURL_CHECK_HEADER_WINSOCK2
276dnl -------------------------------------------------
277dnl Check for compilable and valid winsock2.h header
278
279AC_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
312dnl CURL_CHECK_HEADER_WS2TCPIP
313dnl -------------------------------------------------
314dnl Check for compilable and valid ws2tcpip.h header
315
316AC_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
350dnl CURL_CHECK_HEADER_WINLDAP
351dnl -------------------------------------------------
352dnl Check for compilable and valid winldap.h header
353
354AC_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
390dnl CURL_CHECK_HEADER_WINBER
391dnl -------------------------------------------------
392dnl Check for compilable and valid winber.h header
393
394AC_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
432dnl CURL_CHECK_HEADER_LBER
433dnl -------------------------------------------------
434dnl Check for compilable and valid lber.h header,
435dnl and check if it is needed even with ldap.h
436
437AC_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
513dnl CURL_CHECK_HEADER_LDAP
514dnl -------------------------------------------------
515dnl Check for compilable and valid ldap.h header
516
517AC_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
559dnl CURL_CHECK_HEADER_LDAP_SSL
560dnl -------------------------------------------------
561dnl Check for compilable and valid ldap_ssl.h header
562
563AC_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
607dnl CURL_CHECK_HEADER_LDAPSSL
608dnl -------------------------------------------------
609dnl Check for compilable and valid ldapssl.h header
610
611AC_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
659dnl CURL_CHECK_LIBS_WINLDAP
660dnl -------------------------------------------------
661dnl Check for libraries needed for WINLDAP support,
662dnl and prepended to LIBS any needed libraries.
663dnl This macro can take an optional parameter with a
664dnl white space separated list of libraries to check
665dnl before the WINLDAP default ones.
666
667AC_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
753dnl CURL_CHECK_LIBS_LDAP
754dnl -------------------------------------------------
755dnl Check for libraries needed for LDAP support,
756dnl and prepended to LIBS any needed libraries.
757dnl This macro can take an optional parameter with a
758dnl white space separated list of libraries to check
759dnl before the default ones.
760
761AC_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
863dnl CURL_CHECK_HEADER_MALLOC
864dnl -------------------------------------------------
865dnl Check for compilable and valid malloc.h header,
866dnl and check if it is needed even with stdlib.h
867
868AC_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
914dnl CURL_CHECK_HEADER_MEMORY
915dnl -------------------------------------------------
916dnl Check for compilable and valid memory.h header,
917dnl and check if it is needed even with stdlib.h for
918dnl memory related functions.
919
920AC_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
965dnl TYPE_SOCKADDR_STORAGE
966dnl -------------------------------------------------
967dnl Check for struct sockaddr_storage. Most IPv6-enabled
968dnl hosts have it, but AIX 4.3 is one known exception.
969
970AC_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
1002dnl CURL_CHECK_FUNC_RECV
1003dnl -------------------------------------------------
1004dnl Test if the socket recv() function is available,
1005dnl and check its return type and the types of its
1006dnl arguments. If the function succeeds HAVE_RECV
1007dnl will be defined, defining the types of the arguments
1008dnl in RECV_TYPE_ARG1, RECV_TYPE_ARG2, RECV_TYPE_ARG3
1009dnl and RECV_TYPE_ARG4, defining the type of the function
1010dnl return value in RECV_TYPE_RETV.
1011
1012AC_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>
1036struct 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>
1085struct 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
1145dnl CURL_CHECK_FUNC_SEND
1146dnl -------------------------------------------------
1147dnl Test if the socket send() function is available,
1148dnl and check its return type and the types of its
1149dnl arguments. If the function succeeds HAVE_SEND
1150dnl will be defined, defining the types of the arguments
1151dnl in SEND_TYPE_ARG1, SEND_TYPE_ARG2, SEND_TYPE_ARG3
1152dnl and SEND_TYPE_ARG4, defining the type of the function
1153dnl return value in SEND_TYPE_RETV, and also defining the
1154dnl type qualifier of second argument in SEND_QUAL_ARG2.
1155
1156AC_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>
1180struct 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>
1229struct 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
1321dnl CURL_CHECK_MSG_NOSIGNAL
1322dnl -------------------------------------------------
1323dnl Check for MSG_NOSIGNAL
1324
1325AC_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>
1346struct 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
1373dnl CURL_CHECK_STRUCT_TIMEVAL
1374dnl -------------------------------------------------
1375dnl Check for timeval struct
1376
1377AC_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
1435dnl TYPE_SIG_ATOMIC_T
1436dnl -------------------------------------------------
1437dnl Check if the sig_atomic_t type is available, and
1438dnl verify if it is already defined as volatile.
1439
1440AC_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
1479dnl TYPE_IN_ADDR_T
1480dnl -------------------------------------------------
1481dnl Check for in_addr_t: it is used to receive the return code of inet_addr()
1482dnl and a few other things.
1483
1484AC_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
1571dnl CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC
1572dnl -------------------------------------------------
1573dnl Check if monotonic clock_gettime is available.
1574
1575AC_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
1613dnl CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC
1614dnl -------------------------------------------------
1615dnl If monotonic clock_gettime is available then,
1616dnl check and prepended to LIBS any needed libraries.
1617
1618AC_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
1734dnl CURL_CHECK_LIBS_CONNECT
1735dnl -------------------------------------------------
1736dnl Verify if network connect function is already available
1737dnl using current libraries or if another one is required.
1738
1739AC_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
1782dnl CURL_DEFINE_UNQUOTED (VARIABLE, [VALUE])
1783dnl -------------------------------------------------
1784dnl Like AC_DEFINE_UNQUOTED this macro will define a C preprocessor
1785dnl symbol that can be further used in custom template configuration
1786dnl files. This macro, unlike AC_DEFINE_UNQUOTED, does not use a third
1787dnl argument for the description. Symbol definitions done with this
1788dnl macro are intended to be exclusively used in handcrafted *.h.in
1789dnl template files. Contrary to what AC_DEFINE_UNQUOTED does, this one
1790dnl prevents autoheader generation and insertion of symbol template
1791dnl stub and definition into the first configuration header file. Do
1792dnl not use this macro as a replacement for AC_DEFINE_UNQUOTED, each
1793dnl one serves different functional needs.
1794
1795AC_DEFUN([CURL_DEFINE_UNQUOTED], [
1796cat >>confdefs.h <<_EOF
1797[@%:@define] $1 ifelse($#, 2, [$2], 1)
1798_EOF
1799])
1800
1801dnl CURL_CONFIGURE_PULL_SYS_POLL
1802dnl -------------------------------------------------
1803dnl The need for the sys/poll.h inclusion arises mainly to properly
1804dnl interface AIX systems which define macros 'events' and 'revents'.
1805
1806AC_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
1836dnl CURL_CHECK_FUNC_SELECT
1837dnl -------------------------------------------------
1838dnl Test if the socket select() function is available,
1839dnl and check its return type and the types of its
1840dnl arguments. If the function succeeds HAVE_SELECT
1841dnl will be defined, defining the types of the
1842dnl arguments in SELECT_TYPE_ARG1, SELECT_TYPE_ARG234
1843dnl and SELECT_TYPE_ARG5, defining the type of the
1844dnl function return value in SELECT_TYPE_RETV, and
1845dnl also defining the type qualifier of fifth argument
1846dnl in SELECT_QUAL_ARG5.
1847
1848AC_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>
1885struct 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>
1948struct 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
2049dnl CURL_VERIFY_RUNTIMELIBS
2050dnl -------------------------------------------------
2051dnl Verify that the shared libs found so far can be used when running
2052dnl programs, since otherwise the situation will create odd configure errors
2053dnl that are misleading people.
2054dnl
2055dnl Make sure this test is run BEFORE the first test in the script that
2056dnl runs anything, which at the time of this writing is the AC_CHECK_SIZEOF
2057dnl macro. It must also run AFTER all lib-checking macros are complete.
2058
2059AC_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([
2068int 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
2083dnl CURL_CHECK_VARIADIC_MACROS
2084dnl -------------------------------------------------
2085dnl Check compiler support of variadic macros
2086
2087AC_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
2147dnl CURL_CHECK_CA_BUNDLE
2148dnl -------------------------------------------------
2149dnl Check if a default ca-bundle should be used
2150dnl
2151dnl regarding the paths this will scan:
2152dnl /etc/ssl/certs/ca-certificates.crt Debian systems
2153dnl /etc/pki/tls/certs/ca-bundle.crt Redhat and Mandriva
2154dnl /usr/share/ssl/certs/ca-bundle.crt old(er) Redhat
2155dnl /usr/local/share/certs/ca-root-nss.crt FreeBSD
2156dnl /etc/ssl/cert.pem OpenBSD, FreeBSD (symlink)
2157dnl /etc/ssl/certs/ (ca path) SUSE
2158
2159AC_DEFUN([CURL_CHECK_CA_BUNDLE], [
2160
2161  AC_MSG_CHECKING([default CA cert bundle/path])
2162
2163  AC_ARG_WITH(ca-bundle,
2164AC_HELP_STRING([--with-ca-bundle=FILE],
2165[Path to a file containing CA certificates (example: /etc/ca-bundle.crt)])
2166AC_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,
2175AC_HELP_STRING([--with-ca-path=DIRECTORY],
2176[Path to a directory containing CA certificates stored individually, with \
2177their filenames in a hash format. This option can be used with OpenSSL, \
2178GnuTLS and PolarSSL backends. Refer to OpenSSL c_rehash for details. \
2179(example: /etc/certificates)])
2180AC_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,
2290AC_HELP_STRING([--with-ca-fallback], [Use the built in CA store of the SSL library])
2291AC_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
2307dnl CURL_CHECK_WIN32_LARGEFILE
2308dnl -------------------------------------------------
2309dnl Check if curl's WIN32 large file will be used
2310
2311AC_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
2364dnl CURL_EXPORT_PCDIR ($pcdir)
2365dnl ------------------------
2366dnl if $pcdir is not empty, set PKG_CONFIG_LIBDIR to $pcdir and export
2367dnl
2368dnl we need this macro since pkg-config distinguishes among empty and unset
2369dnl variable while checking PKG_CONFIG_LIBDIR
2370dnl
2371
2372AC_DEFUN([CURL_EXPORT_PCDIR], [
2373    if test -n "$1"; then
2374      PKG_CONFIG_LIBDIR="$1"
2375      export PKG_CONFIG_LIBDIR
2376    fi
2377])
2378
2379dnl CURL_CHECK_PKGCONFIG ($module, [$pcdir])
2380dnl ------------------------
2381dnl search for the pkg-config tool. Set the PKGCONFIG variable to hold the
2382dnl path to it, or 'no' if not found/present.
2383dnl
2384dnl If pkg-config is present, check that it has info about the $module or
2385dnl return "no" anyway!
2386dnl
2387dnl Optionally PKG_CONFIG_LIBDIR may be given as $pcdir.
2388dnl
2389
2390AC_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
2416dnl CURL_GENERATE_CONFIGUREHELP_PM
2417dnl -------------------------------------------------
2418dnl Generate test harness configurehelp.pm module, defining and
2419dnl initializing some perl variables with values which are known
2420dnl when the configure script runs. For portability reasons, test
2421dnl harness needs information on how to run the C preprocessor.
2422
2423AC_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
2432package configurehelp;
2433
2434use strict;
2435use warnings;
2436use Exporter;
2437
2438use 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
24521;
2453_EOF
2454])
2455
2456dnl CURL_CPP_P
2457dnl
2458dnl Check if $cpp -P should be used for extract define values due to gcc 5
2459dnl splitting up strings and defines between line outputs. gcc by default
2460dnl (without -P) will show TEST EINVAL TEST as
2461dnl
2462dnl # 13 "conftest.c"
2463dnl TEST
2464dnl # 13 "conftest.c" 3 4
2465dnl     22
2466dnl # 13 "conftest.c"
2467dnl            TEST
2468
2469AC_DEFUN([CURL_CPP_P], [
2470  AC_MSG_CHECKING([if cpp -P is needed])
2471  AC_EGREP_CPP([TEST.*TEST], [
2472 #include <errno.h>
2473TEST 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>
2484TEST 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
2505dnl CURL_MAC_CFLAGS
2506dnl
2507dnl Check if -mmacosx-version-min, -miphoneos-version-min or any
2508dnl similar are set manually, otherwise do. And set
2509dnl -Werror=partial-availability.
2510dnl
2511
2512AC_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
2549dnl CURL_SUPPORTS_BUILTIN_AVAILABLE
2550dnl
2551dnl Check to see if the compiler supports __builtin_available. This built-in
2552dnl compiler function first appeared in Apple LLVM 9.0.0. It's so new that, at
2553dnl the time this macro was written, the function was not yet documented. Its
2554dnl purpose is to return true if the code is running under a certain OS version
2555dnl or later.
2556
2557AC_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])
2573