acinclude.m4

   1 #***************************************************************************
   2 #                                  _   _ ____  _
   3 #  Project                     ___| | | |  _ \| |
   4 #                             / __| | | | |_) | |
   5 #                            | (__| |_| |  _ <| |___
   6 #                             \___|\___/|_| \_\_____|
   7 #
   8 # Copyright (C) 1998 - 2008, 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 http://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 # $Id$
  22 #***************************************************************************
  23
  24
  25 dnl CURL_CHECK_COMPILER_HALT_ON_ERROR
  26 dnl -------------------------------------------------
  27 dnl Verifies if the compiler actually halts after the
  28 dnl compilation phase without generating any object
  29 dnl code file, when the source compiles with errors.
  30
  31 AC_DEFUN([CURL_CHECK_COMPILER_HALT_ON_ERROR], [
  32   AC_MSG_CHECKING([if compiler halts on compilation errors])
  33   AC_COMPILE_IFELSE([
  34     AC_LANG_PROGRAM([[
  35     ]],[[
  36       force compilation error
  37     ]])
  38   ],[
  39     AC_MSG_RESULT([no])
  40     AC_MSG_ERROR([compiler does not halt on compilation errors.])
  41   ],[
  42     AC_MSG_RESULT([yes])
  43   ])
  44 ])
  45
  46
  47 dnl CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
  48 dnl -------------------------------------------------
  49 dnl Verifies if the compiler actually halts after the
  50 dnl compilation phase without generating any object
  51 dnl code file, when the source code tries to define a
  52 dnl type for a constant array with negative dimension.
  53
  54 AC_DEFUN([CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE], [
  55   AC_REQUIRE([CURL_CHECK_COMPILER_HALT_ON_ERROR])dnl
  56   AC_MSG_CHECKING([if compiler halts on negative sized arrays])
  57   AC_COMPILE_IFELSE([
  58     AC_LANG_PROGRAM([[
  59       typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
  60     ]],[[
  61       bad_t dummy;
  62     ]])
  63   ],[
  64     AC_MSG_RESULT([no])
  65     AC_MSG_ERROR([compiler does not halt on negative sized arrays.])
  66   ],[
  67     AC_MSG_RESULT([yes])
  68   ])
  69 ])
  70
  71
  72 dnl CURL_CHECK_DEF (SYMBOL, [INCLUDES], [SILENT])
  73 dnl -------------------------------------------------
  74 dnl Use the C preprocessor to find out if the given object-style symbol
  75 dnl is defined and get its expansion. This macro will not use default
  76 dnl includes even if no INCLUDES argument is given. This macro will run
  77 dnl silently when invoked with three arguments. If the expansion would
  78 dnl result in a set of double-quoted strings the returned expansion will
  79 dnl actually be a single double-quoted string concatenating all them.
  80
  81 AC_DEFUN([CURL_CHECK_DEF], [
  82   AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
  83   AS_VAR_PUSHDEF([ac_Def], [curl_cv_def_$1])dnl
  84   if test -z "$SED"; then
  85     AC_MSG_ERROR([SED not set. Cannot continue without SED being set.])
  86   fi
  87   if test -z "$GREP"; then
  88     AC_MSG_ERROR([GREP not set. Cannot continue without GREP being set.])
  89   fi
  90   ifelse($3,,[AC_MSG_CHECKING([for preprocessor definition of $1])])
  91   tmp_exp=""
  92   AC_PREPROC_IFELSE([
  93     AC_LANG_SOURCE(
  94 ifelse($2,,,[$2])[[
  95 #ifdef $1
  96 CURL_DEF_TOKEN $1
  97 #endif
  98     ]])
  99   ],[
 100     tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
 101       "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
 102       "$SED" 's/.*CURL_DEF_TOKEN[[ ]]//' 2>/dev/null | \
 103       "$SED" 's/[["]][[ ]]*[["]]//g' 2>/dev/null`
 104     if test -z "$tmp_exp" || test "$tmp_exp" = "$1"; then
 105       tmp_exp=""
 106     fi
 107   ])
 108   if test -z "$tmp_exp"; then
 109     AS_VAR_SET(ac_HaveDef, no)
 110     ifelse($3,,[AC_MSG_RESULT([no])])
 111   else
 112     AS_VAR_SET(ac_HaveDef, yes)
 113     AS_VAR_SET(ac_Def, $tmp_exp)
 114     ifelse($3,,[AC_MSG_RESULT([$tmp_exp])])
 115   fi
 116   AS_VAR_POPDEF([ac_Def])dnl
 117   AS_VAR_POPDEF([ac_HaveDef])dnl
 118 ])
 119
 120
 121 dnl CURL_CHECK_AIX_ALL_SOURCE
 122 dnl -------------------------------------------------
 123 dnl Provides a replacement of traditional AC_AIX with
 124 dnl an uniform behaviour across all autoconf versions,
 125 dnl and with our own placement rules.
 126
 127 AC_DEFUN([CURL_CHECK_AIX_ALL_SOURCE], [
 128   AH_VERBATIM([_ALL_SOURCE],
 129     [/* Define to 1 if OS is AIX. */
 130 #ifndef _ALL_SOURCE
 131 #  undef _ALL_SOURCE
 132 #endif])
 133   AC_BEFORE([$0], [AC_SYS_LARGEFILE])dnl
 134   AC_BEFORE([$0], [CURL_CONFIGURE_REENTRANT])dnl
 135   AC_MSG_CHECKING([if OS is AIX (to define _ALL_SOURCE)])
 136   AC_EGREP_CPP([yes_this_is_aix],[
 137 #ifdef _AIX
 138    yes_this_is_aix
 139 #endif
 140   ],[
 141     AC_MSG_RESULT([yes])
 142     AC_DEFINE(_ALL_SOURCE)
 143   ],[
 144     AC_MSG_RESULT([no])
 145   ])
 146 ])
 147
 148
 149 dnl CURL_CHECK_HEADER_WINDOWS
 150 dnl -------------------------------------------------
 151 dnl Check for compilable and valid windows.h header
 152
 153 AC_DEFUN([CURL_CHECK_HEADER_WINDOWS], [
 154   AC_CACHE_CHECK([for windows.h], [ac_cv_header_windows_h], [
 155     AC_COMPILE_IFELSE([
 156       AC_LANG_PROGRAM([[
 157 #undef inline
 158 #ifndef WIN32_LEAN_AND_MEAN
 159 #define WIN32_LEAN_AND_MEAN
 160 #endif
 161 #include <windows.h>
 162       ]],[[
 163 #if defined(__CYGWIN__) || defined(__CEGCC__)
 164         HAVE_WINDOWS_H shall not be defined.
 165 #else
 166         int dummy=2*WINVER;
 167 #endif
 168       ]])
 169     ],[
 170       ac_cv_header_windows_h="yes"
 171     ],[
 172       ac_cv_header_windows_h="no"
 173     ])
 174   ])
 175   case "$ac_cv_header_windows_h" in
 176     yes)
 177       AC_DEFINE_UNQUOTED(HAVE_WINDOWS_H, 1,
 178         [Define to 1 if you have the windows.h header file.])
 179       AC_DEFINE_UNQUOTED(WIN32_LEAN_AND_MEAN, 1,
 180         [Define to avoid automatic inclusion of winsock.h])
 181       ;;
 182   esac
 183 ])
 184
 185
 186 dnl CURL_CHECK_NATIVE_WINDOWS
 187 dnl -------------------------------------------------
 188 dnl Check if building a native Windows target
 189
 190 AC_DEFUN([CURL_CHECK_NATIVE_WINDOWS], [
 191   AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
 192   AC_CACHE_CHECK([whether build target is a native Windows one], [ac_cv_native_windows], [
 193     if test "$ac_cv_header_windows_h" = "no"; then
 194       ac_cv_native_windows="no"
 195     else
 196       AC_COMPILE_IFELSE([
 197         AC_LANG_PROGRAM([[
 198         ]],[[
 199 #if defined(__MINGW32__) || defined(__MINGW32CE__) || \
 200    (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64)))
 201           int dummy=1;
 202 #else
 203           Not a native Windows build target.
 204 #endif
 205         ]])
 206       ],[
 207         ac_cv_native_windows="yes"
 208       ],[
 209         ac_cv_native_windows="no"
 210       ])
 211     fi
 212   ])
 213   case "$ac_cv_native_windows" in
 214     yes)
 215       AC_DEFINE_UNQUOTED(NATIVE_WINDOWS, 1,
 216         [Define to 1 if you are building a native Windows target.])
 217       ;;
 218   esac
 219 ])
 220
 221
 222 dnl CURL_CHECK_HEADER_WINSOCK
 223 dnl -------------------------------------------------
 224 dnl Check for compilable and valid winsock.h header
 225
 226 AC_DEFUN([CURL_CHECK_HEADER_WINSOCK], [
 227   AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
 228   AC_CACHE_CHECK([for winsock.h], [ac_cv_header_winsock_h], [
 229     AC_COMPILE_IFELSE([
 230       AC_LANG_PROGRAM([[
 231 #undef inline
 232 #ifndef WIN32_LEAN_AND_MEAN
 233 #define WIN32_LEAN_AND_MEAN
 234 #endif
 235 #include <windows.h>
 236 #include <winsock.h>
 237       ]],[[
 238 #if defined(__CYGWIN__) || defined(__CEGCC__)
 239         HAVE_WINSOCK_H shall not be defined.
 240 #else
 241         int dummy=WSACleanup();
 242 #endif
 243       ]])
 244     ],[
 245       ac_cv_header_winsock_h="yes"
 246     ],[
 247       ac_cv_header_winsock_h="no"
 248     ])
 249   ])
 250   case "$ac_cv_header_winsock_h" in
 251     yes)
 252       AC_DEFINE_UNQUOTED(HAVE_WINSOCK_H, 1,
 253         [Define to 1 if you have the winsock.h header file.])
 254       ;;
 255   esac
 256 ])
 257
 258
 259 dnl CURL_CHECK_HEADER_WINSOCK2
 260 dnl -------------------------------------------------
 261 dnl Check for compilable and valid winsock2.h header
 262
 263 AC_DEFUN([CURL_CHECK_HEADER_WINSOCK2], [
 264   AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
 265   AC_CACHE_CHECK([for winsock2.h], [ac_cv_header_winsock2_h], [
 266     AC_COMPILE_IFELSE([
 267       AC_LANG_PROGRAM([[
 268 #undef inline
 269 #ifndef WIN32_LEAN_AND_MEAN
 270 #define WIN32_LEAN_AND_MEAN
 271 #endif
 272 #include <windows.h>
 273 #include <winsock2.h>
 274       ]],[[
 275 #if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
 276         HAVE_WINSOCK2_H shall not be defined.
 277 #else
 278         int dummy=2*IPPROTO_ESP;
 279 #endif
 280       ]])
 281     ],[
 282       ac_cv_header_winsock2_h="yes"
 283     ],[
 284       ac_cv_header_winsock2_h="no"
 285     ])
 286   ])
 287   case "$ac_cv_header_winsock2_h" in
 288     yes)
 289       AC_DEFINE_UNQUOTED(HAVE_WINSOCK2_H, 1,
 290         [Define to 1 if you have the winsock2.h header file.])
 291       ;;
 292   esac
 293 ])
 294
 295
 296 dnl CURL_CHECK_HEADER_WS2TCPIP
 297 dnl -------------------------------------------------
 298 dnl Check for compilable and valid ws2tcpip.h header
 299
 300 AC_DEFUN([CURL_CHECK_HEADER_WS2TCPIP], [
 301   AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
 302   AC_CACHE_CHECK([for ws2tcpip.h], [ac_cv_header_ws2tcpip_h], [
 303     AC_COMPILE_IFELSE([
 304       AC_LANG_PROGRAM([[
 305 #undef inline
 306 #ifndef WIN32_LEAN_AND_MEAN
 307 #define WIN32_LEAN_AND_MEAN
 308 #endif
 309 #include <windows.h>
 310 #include <winsock2.h>
 311 #include <ws2tcpip.h>
 312       ]],[[
 313 #if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)
 314         HAVE_WS2TCPIP_H shall not be defined.
 315 #else
 316         int dummy=2*IP_PKTINFO;
 317 #endif
 318       ]])
 319     ],[
 320       ac_cv_header_ws2tcpip_h="yes"
 321     ],[
 322       ac_cv_header_ws2tcpip_h="no"
 323     ])
 324   ])
 325   case "$ac_cv_header_ws2tcpip_h" in
 326     yes)
 327       AC_DEFINE_UNQUOTED(HAVE_WS2TCPIP_H, 1,
 328         [Define to 1 if you have the ws2tcpip.h header file.])
 329       ;;
 330   esac
 331 ])
 332
 333
 334 dnl CURL_CHECK_HEADER_WINLDAP
 335 dnl -------------------------------------------------
 336 dnl Check for compilable and valid winldap.h header
 337
 338 AC_DEFUN([CURL_CHECK_HEADER_WINLDAP], [
 339   AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
 340   AC_CACHE_CHECK([for winldap.h], [ac_cv_header_winldap_h], [
 341     AC_COMPILE_IFELSE([
 342       AC_LANG_PROGRAM([[
 343 #undef inline
 344 #ifdef HAVE_WINDOWS_H
 345 #ifndef WIN32_LEAN_AND_MEAN
 346 #define WIN32_LEAN_AND_MEAN
 347 #endif
 348 #include <windows.h>
 349 #endif
 350 #include <winldap.h>
 351       ]],[[
 352 #if defined(__CYGWIN__) || defined(__CEGCC__)
 353         HAVE_WINLDAP_H shall not be defined.
 354 #else
 355         LDAP *ldp = ldap_init("dummy", LDAP_PORT);
 356         ULONG res = ldap_unbind(ldp);
 357 #endif
 358       ]])
 359     ],[
 360       ac_cv_header_winldap_h="yes"
 361     ],[
 362       ac_cv_header_winldap_h="no"
 363     ])
 364   ])
 365   case "$ac_cv_header_winldap_h" in
 366     yes)
 367       AC_DEFINE_UNQUOTED(HAVE_WINLDAP_H, 1,
 368         [Define to 1 if you have the winldap.h header file.])
 369       ;;
 370   esac
 371 ])
 372
 373
 374 dnl CURL_CHECK_HEADER_WINBER
 375 dnl -------------------------------------------------
 376 dnl Check for compilable and valid winber.h header
 377
 378 AC_DEFUN([CURL_CHECK_HEADER_WINBER], [
 379   AC_REQUIRE([CURL_CHECK_HEADER_WINLDAP])dnl
 380   AC_CACHE_CHECK([for winber.h], [ac_cv_header_winber_h], [
 381     AC_COMPILE_IFELSE([
 382       AC_LANG_PROGRAM([[
 383 #undef inline
 384 #ifdef HAVE_WINDOWS_H
 385 #ifndef WIN32_LEAN_AND_MEAN
 386 #define WIN32_LEAN_AND_MEAN
 387 #endif
 388 #include <windows.h>
 389 #endif
 390 #include <winldap.h>
 391 #include <winber.h>
 392       ]],[[
 393 #if defined(__CYGWIN__) || defined(__CEGCC__)
 394         HAVE_WINBER_H shall not be defined.
 395 #else
 396         BERVAL *bvp = NULL;
 397         BerElement *bep = ber_init(bvp);
 398         ber_free(bep, 1);
 399 #endif
 400       ]])
 401     ],[
 402       ac_cv_header_winber_h="yes"
 403     ],[
 404       ac_cv_header_winber_h="no"
 405     ])
 406   ])
 407   case "$ac_cv_header_winber_h" in
 408     yes)
 409       AC_DEFINE_UNQUOTED(HAVE_WINBER_H, 1,
 410         [Define to 1 if you have the winber.h header file.])
 411       ;;
 412   esac
 413 ])
 414
 415
 416 dnl CURL_CHECK_HEADER_LBER
 417 dnl -------------------------------------------------
 418 dnl Check for compilable and valid lber.h header,
 419 dnl and check if it is needed even with ldap.h
 420
 421 AC_DEFUN([CURL_CHECK_HEADER_LBER], [
 422   AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
 423   AC_CACHE_CHECK([for lber.h], [ac_cv_header_lber_h], [
 424     AC_COMPILE_IFELSE([
 425       AC_LANG_PROGRAM([[
 426 #undef inline
 427 #ifdef HAVE_WINDOWS_H
 428 #ifndef WIN32_LEAN_AND_MEAN
 429 #define WIN32_LEAN_AND_MEAN
 430 #endif
 431 #include <windows.h>
 432 #else
 433 #ifdef HAVE_SYS_TYPES_H
 434 #include <sys/types.h>
 435 #endif
 436 #endif
 437 #ifndef NULL
 438 #define NULL (void *)0
 439 #endif
 440 #include <lber.h>
 441       ]],[[
 442         BerValue *bvp = NULL;
 443         BerElement *bep = ber_init(bvp);
 444         ber_free(bep, 1);
 445       ]])
 446     ],[
 447       ac_cv_header_lber_h="yes"
 448     ],[
 449       ac_cv_header_lber_h="no"
 450     ])
 451   ])
 452   if test "$ac_cv_header_lber_h" = "yes"; then
 453     AC_DEFINE_UNQUOTED(HAVE_LBER_H, 1,
 454       [Define to 1 if you have the lber.h header file.])
 455     #
 456     AC_COMPILE_IFELSE([
 457       AC_LANG_PROGRAM([[
 458 #undef inline
 459 #ifdef HAVE_WINDOWS_H
 460 #ifndef WIN32_LEAN_AND_MEAN
 461 #define WIN32_LEAN_AND_MEAN
 462 #endif
 463 #include <windows.h>
 464 #else
 465 #ifdef HAVE_SYS_TYPES_H
 466 #include <sys/types.h>
 467 #endif
 468 #endif
 469 #ifndef NULL
 470 #define NULL (void *)0
 471 #endif
 472 #ifndef LDAP_DEPRECATED
 473 #define LDAP_DEPRECATED 1
 474 #endif
 475 #include <ldap.h>
 476       ]],[[
 477         BerValue *bvp = NULL;
 478         BerElement *bep = ber_init(bvp);
 479         ber_free(bep, 1);
 480       ]])
 481     ],[
 482       curl_cv_need_header_lber_h="no"
 483     ],[
 484       curl_cv_need_header_lber_h="yes"
 485     ])
 486     #
 487     case "$curl_cv_need_header_lber_h" in
 488       yes)
 489         AC_DEFINE_UNQUOTED(NEED_LBER_H, 1,
 490           [Define to 1 if you need the lber.h header file even with ldap.h])
 491         ;;
 492     esac
 493   fi
 494 ])
 495
 496
 497 dnl CURL_CHECK_HEADER_LDAP
 498 dnl -------------------------------------------------
 499 dnl Check for compilable and valid ldap.h header
 500
 501 AC_DEFUN([CURL_CHECK_HEADER_LDAP], [
 502   AC_REQUIRE([CURL_CHECK_HEADER_LBER])dnl
 503   AC_CACHE_CHECK([for ldap.h], [ac_cv_header_ldap_h], [
 504     AC_COMPILE_IFELSE([
 505       AC_LANG_PROGRAM([[
 506 #undef inline
 507 #ifdef HAVE_WINDOWS_H
 508 #ifndef WIN32_LEAN_AND_MEAN
 509 #define WIN32_LEAN_AND_MEAN
 510 #endif
 511 #include <windows.h>
 512 #else
 513 #ifdef HAVE_SYS_TYPES_H
 514 #include <sys/types.h>
 515 #endif
 516 #endif
 517 #ifndef LDAP_DEPRECATED
 518 #define LDAP_DEPRECATED 1
 519 #endif
 520 #ifdef NEED_LBER_H
 521 #include <lber.h>
 522 #endif
 523 #include <ldap.h>
 524       ]],[[
 525         LDAP *ldp = ldap_init("dummy", LDAP_PORT);
 526         int res = ldap_unbind(ldp);
 527       ]])
 528     ],[
 529       ac_cv_header_ldap_h="yes"
 530     ],[
 531       ac_cv_header_ldap_h="no"
 532     ])
 533   ])
 534   case "$ac_cv_header_ldap_h" in
 535     yes)
 536       AC_DEFINE_UNQUOTED(HAVE_LDAP_H, 1,
 537         [Define to 1 if you have the ldap.h header file.])
 538       ;;
 539   esac
 540 ])
 541
 542
 543 dnl CURL_CHECK_HEADER_LDAP_SSL
 544 dnl -------------------------------------------------
 545 dnl Check for compilable and valid ldap_ssl.h header
 546
 547 AC_DEFUN([CURL_CHECK_HEADER_LDAP_SSL], [
 548   AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
 549   AC_CACHE_CHECK([for ldap_ssl.h], [ac_cv_header_ldap_ssl_h], [
 550     AC_COMPILE_IFELSE([
 551       AC_LANG_PROGRAM([[
 552 #undef inline
 553 #ifdef HAVE_WINDOWS_H
 554 #ifndef WIN32_LEAN_AND_MEAN
 555 #define WIN32_LEAN_AND_MEAN
 556 #endif
 557 #include <windows.h>
 558 #else
 559 #ifdef HAVE_SYS_TYPES_H
 560 #include <sys/types.h>
 561 #endif
 562 #endif
 563 #ifndef LDAP_DEPRECATED
 564 #define LDAP_DEPRECATED 1
 565 #endif
 566 #ifdef NEED_LBER_H
 567 #include <lber.h>
 568 #endif
 569 #ifdef HAVE_LDAP_H
 570 #include <ldap.h>
 571 #endif
 572 #include <ldap_ssl.h>
 573       ]],[[
 574         LDAP *ldp = ldapssl_init("dummy", LDAPS_PORT, 1);
 575       ]])
 576     ],[
 577       ac_cv_header_ldap_ssl_h="yes"
 578     ],[
 579       ac_cv_header_ldap_ssl_h="no"
 580     ])
 581   ])
 582   case "$ac_cv_header_ldap_ssl_h" in
 583     yes)
 584       AC_DEFINE_UNQUOTED(HAVE_LDAP_SSL_H, 1,
 585         [Define to 1 if you have the ldap_ssl.h header file.])
 586       ;;
 587   esac
 588 ])
 589
 590
 591 dnl CURL_CHECK_HEADER_LDAPSSL
 592 dnl -------------------------------------------------
 593 dnl Check for compilable and valid ldapssl.h header
 594
 595 AC_DEFUN([CURL_CHECK_HEADER_LDAPSSL], [
 596   AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
 597   AC_CACHE_CHECK([for ldapssl.h], [ac_cv_header_ldapssl_h], [
 598     AC_COMPILE_IFELSE([
 599       AC_LANG_PROGRAM([[
 600 #undef inline
 601 #ifdef HAVE_WINDOWS_H
 602 #ifndef WIN32_LEAN_AND_MEAN
 603 #define WIN32_LEAN_AND_MEAN
 604 #endif
 605 #include <windows.h>
 606 #else
 607 #ifdef HAVE_SYS_TYPES_H
 608 #include <sys/types.h>
 609 #endif
 610 #endif
 611 #ifndef NULL
 612 #define NULL (void *)0
 613 #endif
 614 #ifndef LDAP_DEPRECATED
 615 #define LDAP_DEPRECATED 1
 616 #endif
 617 #ifdef NEED_LBER_H
 618 #include <lber.h>
 619 #endif
 620 #ifdef HAVE_LDAP_H
 621 #include <ldap.h>
 622 #endif
 623 #include <ldapssl.h>
 624       ]],[[
 625         char *cert_label = NULL;
 626         LDAP *ldp = ldap_ssl_init("dummy", LDAPS_PORT, cert_label);
 627       ]])
 628     ],[
 629       ac_cv_header_ldapssl_h="yes"
 630     ],[
 631       ac_cv_header_ldapssl_h="no"
 632     ])
 633   ])
 634   case "$ac_cv_header_ldapssl_h" in
 635     yes)
 636       AC_DEFINE_UNQUOTED(HAVE_LDAPSSL_H, 1,
 637         [Define to 1 if you have the ldapssl.h header file.])
 638       ;;
 639   esac
 640 ])
 641
 642
 643 dnl CURL_CHECK_LIBS_WINLDAP
 644 dnl -------------------------------------------------
 645 dnl Check for libraries needed for WINLDAP support,
 646 dnl and prepended to LIBS any needed libraries.
 647 dnl This macro can take an optional parameter with a
 648 dnl white space separated list of libraries to check
 649 dnl before the WINLDAP default ones.
 650
 651 AC_DEFUN([CURL_CHECK_LIBS_WINLDAP], [
 652   AC_REQUIRE([CURL_CHECK_HEADER_WINBER])dnl
 653   #
 654   AC_MSG_CHECKING([for WINLDAP libraries])
 655   #
 656   u_libs=""
 657   #
 658   ifelse($1,,,[
 659     for x_lib in $1; do
 660       case "$x_lib" in
 661         -l*)
 662           l_lib="$x_lib"
 663           ;;
 664         *)
 665           l_lib="-l$x_lib"
 666           ;;
 667       esac
 668       if test -z "$u_libs"; then
 669         u_libs="$l_lib"
 670       else
 671         u_libs="$u_libs $l_lib"
 672       fi
 673     done
 674   ])
 675   #
 676   curl_cv_save_LIBS="$LIBS"
 677   curl_cv_ldap_LIBS="unknown"
 678   #
 679   for x_nlibs in '' "$u_libs" \
 680     '-lwldap32' ; do
 681     if test "$curl_cv_ldap_LIBS" = "unknown"; then
 682       if test -z "$x_nlibs"; then
 683         LIBS="$curl_cv_save_LIBS"
 684       else
 685         LIBS="$x_nlibs $curl_cv_save_LIBS"
 686       fi
 687       AC_LINK_IFELSE([
 688         AC_LANG_PROGRAM([[
 689 #undef inline
 690 #ifdef HAVE_WINDOWS_H
 691 #ifndef WIN32_LEAN_AND_MEAN
 692 #define WIN32_LEAN_AND_MEAN
 693 #endif
 694 #include <windows.h>
 695 #ifdef HAVE_WINLDAP_H
 696 #include <winldap.h>
 697 #endif
 698 #ifdef HAVE_WINBER_H
 699 #include <winber.h>
 700 #endif
 701 #endif
 702         ]],[[
 703           BERVAL *bvp = NULL;
 704           BerElement *bep = ber_init(bvp);
 705           LDAP *ldp = ldap_init("dummy", LDAP_PORT);
 706           ULONG res = ldap_unbind(ldp);
 707           ber_free(bep, 1);
 708         ]])
 709       ],[
 710         curl_cv_ldap_LIBS="$x_nlibs"
 711       ])
 712     fi
 713   done
 714   #
 715   LIBS="$curl_cv_save_LIBS"
 716   #
 717   case X-"$curl_cv_ldap_LIBS" in
 718     X-unknown)
 719       AC_MSG_RESULT([cannot find WINLDAP libraries])
 720       ;;
 721     X-)
 722       AC_MSG_RESULT([no additional lib required])
 723       ;;
 724     *)
 725       if test -z "$curl_cv_save_LIBS"; then
 726         LIBS="$curl_cv_ldap_LIBS"
 727       else
 728         LIBS="$curl_cv_ldap_LIBS $curl_cv_save_LIBS"
 729       fi
 730       AC_MSG_RESULT([$curl_cv_ldap_LIBS])
 731       ;;
 732   esac
 733   #
 734 ])
 735
 736
 737 dnl CURL_CHECK_LIBS_LDAP
 738 dnl -------------------------------------------------
 739 dnl Check for libraries needed for LDAP support,
 740 dnl and prepended to LIBS any needed libraries.
 741 dnl This macro can take an optional parameter with a
 742 dnl white space separated list of libraries to check
 743 dnl before the default ones.
 744
 745 AC_DEFUN([CURL_CHECK_LIBS_LDAP], [
 746   AC_REQUIRE([CURL_CHECK_HEADER_LDAP])dnl
 747   #
 748   AC_MSG_CHECKING([for LDAP libraries])
 749   #
 750   u_libs=""
 751   #
 752   ifelse($1,,,[
 753     for x_lib in $1; do
 754       case "$x_lib" in
 755         -l*)
 756           l_lib="$x_lib"
 757           ;;
 758         *)
 759           l_lib="-l$x_lib"
 760           ;;
 761       esac
 762       if test -z "$u_libs"; then
 763         u_libs="$l_lib"
 764       else
 765         u_libs="$u_libs $l_lib"
 766       fi
 767     done
 768   ])
 769   #
 770   curl_cv_save_LIBS="$LIBS"
 771   curl_cv_ldap_LIBS="unknown"
 772   #
 773   for x_nlibs in '' "$u_libs" \
 774     '-lldap' \
 775     '-llber -lldap' \
 776     '-lldap -llber' \
 777     '-lldapssl -lldapx -lldapsdk' \
 778     '-lldapsdk -lldapx -lldapssl' ; do
 779     if test "$curl_cv_ldap_LIBS" = "unknown"; then
 780       if test -z "$x_nlibs"; then
 781         LIBS="$curl_cv_save_LIBS"
 782       else
 783         LIBS="$x_nlibs $curl_cv_save_LIBS"
 784       fi
 785       AC_LINK_IFELSE([
 786         AC_LANG_PROGRAM([[
 787 #undef inline
 788 #ifdef HAVE_WINDOWS_H
 789 #ifndef WIN32_LEAN_AND_MEAN
 790 #define WIN32_LEAN_AND_MEAN
 791 #endif
 792 #include <windows.h>
 793 #else
 794 #ifdef HAVE_SYS_TYPES_H
 795 #include <sys/types.h>
 796 #endif
 797 #endif
 798 #ifndef NULL
 799 #define NULL (void *)0
 800 #endif
 801 #ifndef LDAP_DEPRECATED
 802 #define LDAP_DEPRECATED 1
 803 #endif
 804 #ifdef NEED_LBER_H
 805 #include <lber.h>
 806 #endif
 807 #ifdef HAVE_LDAP_H
 808 #include <ldap.h>
 809 #endif
 810         ]],[[
 811           BerValue *bvp = NULL;
 812           BerElement *bep = ber_init(bvp);
 813           LDAP *ldp = ldap_init("dummy", LDAP_PORT);
 814           int res = ldap_unbind(ldp);
 815           ber_free(bep, 1);
 816         ]])
 817       ],[
 818         curl_cv_ldap_LIBS="$x_nlibs"
 819       ])
 820     fi
 821   done
 822   #
 823   LIBS="$curl_cv_save_LIBS"
 824   #
 825   case X-"$curl_cv_ldap_LIBS" in
 826     X-unknown)
 827       AC_MSG_RESULT([cannot find LDAP libraries])
 828       ;;
 829     X-)
 830       AC_MSG_RESULT([no additional lib required])
 831       ;;
 832     *)
 833       if test -z "$curl_cv_save_LIBS"; then
 834         LIBS="$curl_cv_ldap_LIBS"
 835       else
 836         LIBS="$curl_cv_ldap_LIBS $curl_cv_save_LIBS"
 837       fi
 838       AC_MSG_RESULT([$curl_cv_ldap_LIBS])
 839       ;;
 840   esac
 841   #
 842 ])
 843
 844
 845 dnl CURL_CHECK_HEADER_MALLOC
 846 dnl -------------------------------------------------
 847 dnl Check for compilable and valid malloc.h header,
 848 dnl and check if it is needed even with stdlib.h
 849
 850 AC_DEFUN([CURL_CHECK_HEADER_MALLOC], [
 851   AC_CACHE_CHECK([for malloc.h], [ac_cv_header_malloc_h], [
 852     AC_COMPILE_IFELSE([
 853       AC_LANG_PROGRAM([[
 854 #include <malloc.h>
 855       ]],[[
 856         void *p = malloc(10);
 857         void *q = calloc(10,10);
 858         free(p);
 859         free(q);
 860       ]])
 861     ],[
 862       ac_cv_header_malloc_h="yes"
 863     ],[
 864       ac_cv_header_malloc_h="no"
 865     ])
 866   ])
 867   if test "$ac_cv_header_malloc_h" = "yes"; then
 868     AC_DEFINE_UNQUOTED(HAVE_MALLOC_H, 1,
 869       [Define to 1 if you have the malloc.h header file.])
 870     #
 871     AC_COMPILE_IFELSE([
 872       AC_LANG_PROGRAM([[
 873 #include <stdlib.h>
 874       ]],[[
 875         void *p = malloc(10);
 876         void *q = calloc(10,10);
 877         free(p);
 878         free(q);
 879       ]])
 880     ],[
 881       curl_cv_need_header_malloc_h="no"
 882     ],[
 883       curl_cv_need_header_malloc_h="yes"
 884     ])
 885     #
 886     case "$curl_cv_need_header_malloc_h" in
 887       yes)
 888         AC_DEFINE_UNQUOTED(NEED_MALLOC_H, 1,
 889           [Define to 1 if you need the malloc.h header file even with stdlib.h])
 890         ;;
 891     esac
 892   fi
 893 ])
 894
 895
 896 dnl CURL_CHECK_TYPE_SOCKLEN_T
 897 dnl -------------------------------------------------
 898 dnl Check for existing socklen_t type, and provide
 899 dnl an equivalent type if socklen_t not available
 900
 901 AC_DEFUN([CURL_CHECK_TYPE_SOCKLEN_T], [
 902   AC_REQUIRE([CURL_CHECK_HEADER_WS2TCPIP])dnl
 903   AC_CHECK_TYPE([socklen_t], ,[
 904     dnl socklen_t not available
 905     AC_CACHE_CHECK([for socklen_t equivalent],
 906       [curl_cv_socklen_t_equiv], [
 907       curl_cv_socklen_t_equiv="unknown"
 908       for arg1 in 'int' 'SOCKET'; do
 909         for arg2 in "struct sockaddr" void; do
 910           for t in int size_t unsigned long "unsigned long"; do
 911             if test "$curl_cv_socklen_t_equiv" = "unknown"; then
 912               AC_COMPILE_IFELSE([
 913                 AC_LANG_PROGRAM([[
 914 #undef inline
 915 #ifdef HAVE_WINDOWS_H
 916 #ifndef WIN32_LEAN_AND_MEAN
 917 #define WIN32_LEAN_AND_MEAN
 918 #endif
 919 #include <windows.h>
 920 #ifdef HAVE_WINSOCK2_H
 921 #include <winsock2.h>
 922 #else
 923 #ifdef HAVE_WINSOCK_H
 924 #include <winsock.h>
 925 #endif
 926 #endif
 927 #define GETPEERNCALLCONV PASCAL
 928 #else
 929 #ifdef HAVE_SYS_TYPES_H
 930 #include <sys/types.h>
 931 #endif
 932 #ifdef HAVE_SYS_SOCKET_H
 933 #include <sys/socket.h>
 934 #endif
 935 #define GETPEERNCALLCONV
 936 #endif
 937                   extern int GETPEERNCALLCONV getpeername($arg1, $arg2 *, $t *);
 938                 ]],[[
 939                   $t len=0;
 940                   getpeername(0,0,&len);
 941                 ]])
 942               ],[
 943                 curl_cv_socklen_t_equiv="$t"
 944               ])
 945             fi
 946           done
 947         done
 948       done
 949     ])
 950     case "$curl_cv_socklen_t_equiv" in
 951       unknown)
 952         AC_MSG_ERROR([Cannot find a type to use in place of socklen_t])
 953         ;;
 954       *)
 955         AC_DEFINE_UNQUOTED(socklen_t, $curl_cv_socklen_t_equiv,
 956           [Type to use in place of socklen_t when system does not provide it.])
 957         ;;
 958     esac
 959   ],[
 960 #undef inline
 961 #ifdef HAVE_WINDOWS_H
 962 #ifndef WIN32_LEAN_AND_MEAN
 963 #define WIN32_LEAN_AND_MEAN
 964 #endif
 965 #include <windows.h>
 966 #ifdef HAVE_WINSOCK2_H
 967 #include <winsock2.h>
 968 #ifdef HAVE_WS2TCPIP_H
 969 #include <ws2tcpip.h>
 970 #endif
 971 #endif
 972 #else
 973 #ifdef HAVE_SYS_TYPES_H
 974 #include <sys/types.h>
 975 #endif
 976 #ifdef HAVE_SYS_SOCKET_H
 977 #include <sys/socket.h>
 978 #endif
 979 #endif
 980   ])
 981 ])
 982
 983
 984 dnl CURL_CHECK_FUNC_GETNAMEINFO
 985 dnl -------------------------------------------------
 986 dnl Test if the getnameinfo function is available,
 987 dnl and check the types of five of its arguments.
 988 dnl If the function succeeds HAVE_GETNAMEINFO will be
 989 dnl defined, defining the types of the arguments in
 990 dnl GETNAMEINFO_TYPE_ARG1, GETNAMEINFO_TYPE_ARG2,
 991 dnl GETNAMEINFO_TYPE_ARG46 and GETNAMEINFO_TYPE_ARG7,
 992 dnl and also defining the type qualifier of first
 993 dnl argument in GETNAMEINFO_QUAL_ARG1.
 994
 995 AC_DEFUN([CURL_CHECK_FUNC_GETNAMEINFO], [
 996   AC_REQUIRE([CURL_CHECK_HEADER_WS2TCPIP])dnl
 997   AC_REQUIRE([CURL_CHECK_TYPE_SOCKLEN_T])dnl
 998   AC_CHECK_HEADERS(sys/types.h sys/socket.h netdb.h)
 999   #
1000   AC_MSG_CHECKING([for getnameinfo])
1001   AC_LINK_IFELSE([
1002     AC_LANG_FUNC_LINK_TRY([getnameinfo])
1003   ],[
1004     AC_MSG_RESULT([yes])
1005     curl_cv_getnameinfo="yes"
1006   ],[
1007     AC_MSG_RESULT([no])
1008     curl_cv_getnameinfo="no"
1009   ])
1010   #
1011   if test "$curl_cv_getnameinfo" != "yes"; then
1012     AC_MSG_CHECKING([deeper for getnameinfo])
1013     AC_LINK_IFELSE([
1014       AC_LANG_PROGRAM([[
1015       ]],[[
1016         getnameinfo();
1017       ]])
1018     ],[
1019       AC_MSG_RESULT([yes])
1020       curl_cv_getnameinfo="yes"
1021     ],[
1022       AC_MSG_RESULT([but still no])
1023       curl_cv_getnameinfo="no"
1024     ])
1025   fi
1026   #
1027   if test "$curl_cv_getnameinfo" != "yes"; then
1028     AC_MSG_CHECKING([deeper and deeper for getnameinfo])
1029     AC_LINK_IFELSE([
1030       AC_LANG_PROGRAM([[
1031 #undef inline
1032 #ifdef HAVE_WINDOWS_H
1033 #ifndef WIN32_LEAN_AND_MEAN
1034 #define WIN32_LEAN_AND_MEAN
1035 #endif
1036 #include <windows.h>
1037 #ifdef HAVE_WINSOCK2_H
1038 #include <winsock2.h>
1039 #ifdef HAVE_WS2TCPIP_H
1040 #include <ws2tcpip.h>
1041 #endif
1042 #endif
1043 #else
1044 #ifdef HAVE_SYS_TYPES_H
1045 #include <sys/types.h>
1046 #endif
1047 #ifdef HAVE_SYS_SOCKET_H
1048 #include <sys/socket.h>
1049 #endif
1050 #ifdef HAVE_NETDB_H
1051 #include <netdb.h>
1052 #endif
1053 #endif
1054       ]],[[
1055         getnameinfo(0, 0, 0, 0, 0, 0, 0);
1056       ]])
1057     ],[
1058       AC_MSG_RESULT([yes])
1059       curl_cv_getnameinfo="yes"
1060     ],[
1061       AC_MSG_RESULT([but still no])
1062       curl_cv_getnameinfo="no"
1063     ])
1064   fi
1065   #
1066   if test "$curl_cv_getnameinfo" = "yes"; then
1067     AC_CACHE_CHECK([types of arguments for getnameinfo],
1068       [curl_cv_func_getnameinfo_args], [
1069       curl_cv_func_getnameinfo_args="unknown"
1070       for gni_arg1 in 'struct sockaddr *' 'const struct sockaddr *' 'void *'; do
1071         for gni_arg2 in 'socklen_t' 'size_t' 'int'; do
1072           for gni_arg46 in 'size_t' 'int' 'socklen_t' 'unsigned int' 'DWORD'; do
1073             for gni_arg7 in 'int' 'unsigned int'; do
1074               if test "$curl_cv_func_getnameinfo_args" = "unknown"; then
1075                 AC_COMPILE_IFELSE([
1076                   AC_LANG_PROGRAM([[
1077 #undef inline
1078 #ifdef HAVE_WINDOWS_H
1079 #ifndef WIN32_LEAN_AND_MEAN
1080 #define WIN32_LEAN_AND_MEAN
1081 #endif
1082 #if (!defined(_WIN32_WINNT)) || (_WIN32_WINNT < 0x0501)
1083 #undef _WIN32_WINNT
1084 #define _WIN32_WINNT 0x0501
1085 #endif
1086 #include <windows.h>
1087 #ifdef HAVE_WINSOCK2_H
1088 #include <winsock2.h>
1089 #ifdef HAVE_WS2TCPIP_H
1090 #include <ws2tcpip.h>
1091 #endif
1092 #endif
1093 #define GNICALLCONV WSAAPI
1094 #else
1095 #ifdef HAVE_SYS_TYPES_H
1096 #include <sys/types.h>
1097 #endif
1098 #ifdef HAVE_SYS_SOCKET_H
1099 #include <sys/socket.h>
1100 #endif
1101 #ifdef HAVE_NETDB_H
1102 #include <netdb.h>
1103 #endif
1104 #define GNICALLCONV
1105 #endif
1106                     extern int GNICALLCONV getnameinfo($gni_arg1, $gni_arg2,
1107                                            char *, $gni_arg46,
1108                                            char *, $gni_arg46,
1109                                            $gni_arg7);
1110                   ]],[[
1111                     $gni_arg2 salen=0;
1112                     $gni_arg46 hostlen=0;
1113                     $gni_arg46 servlen=0;
1114                     $gni_arg7 flags=0;
1115                     int res = getnameinfo(0, salen, 0, hostlen, 0, servlen, flags);
1116                   ]])
1117                 ],[
1118                   curl_cv_func_getnameinfo_args="$gni_arg1,$gni_arg2,$gni_arg46,$gni_arg7"
1119                 ])
1120               fi
1121             done
1122           done
1123         done
1124       done
1125     ]) # AC-CACHE-CHECK
1126     if test "$curl_cv_func_getnameinfo_args" = "unknown"; then
1127       AC_MSG_WARN([Cannot find proper types to use for getnameinfo args])
1128       AC_MSG_WARN([HAVE_GETNAMEINFO will not be defined])
1129     else
1130       gni_prev_IFS=$IFS; IFS=','
1131       set dummy `echo "$curl_cv_func_getnameinfo_args" | sed 's/\*/\*/g'`
1132       IFS=$gni_prev_IFS
1133       shift
1134       #
1135       gni_qual_type_arg1=$[1]
1136       #
1137       AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG2, $[2],
1138         [Define to the type of arg 2 for getnameinfo.])
1139       AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG46, $[3],
1140         [Define to the type of args 4 and 6 for getnameinfo.])
1141       AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG7, $[4],
1142         [Define to the type of arg 7 for getnameinfo.])
1143       #
1144       prev_sh_opts=$-
1145       #
1146       case $prev_sh_opts in
1147         *f*)
1148           ;;
1149         *)
1150           set -f
1151           ;;
1152       esac
1153       #
1154       case "$gni_qual_type_arg1" in
1155         const*)
1156           gni_qual_arg1=const
1157           gni_type_arg1=`echo $gni_qual_type_arg1 | sed 's/^const //'`
1158         ;;
1159         *)
1160           gni_qual_arg1=
1161           gni_type_arg1=$gni_qual_type_arg1
1162         ;;
1163       esac
1164       #
1165       AC_DEFINE_UNQUOTED(GETNAMEINFO_QUAL_ARG1, $gni_qual_arg1,
1166         [Define to the type qualifier of arg 1 for getnameinfo.])
1167       AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG1, $gni_type_arg1,
1168         [Define to the type of arg 1 for getnameinfo.])
1169       #
1170       case $prev_sh_opts in
1171         *f*)
1172           ;;
1173         *)
1174           set +f
1175           ;;
1176       esac
1177       #
1178       AC_DEFINE_UNQUOTED(HAVE_GETNAMEINFO, 1,
1179         [Define to 1 if you have the getnameinfo function.])
1180       ac_cv_func_getnameinfo="yes"
1181     fi
1182   fi
1183 ])
1184
1185
1186 dnl TYPE_SOCKADDR_STORAGE
1187 dnl -------------------------------------------------
1188 dnl Check for struct sockaddr_storage. Most IPv6-enabled
1189 dnl hosts have it, but AIX 4.3 is one known exception.
1190
1191 AC_DEFUN([TYPE_SOCKADDR_STORAGE],
1192 [
1193    AC_CHECK_TYPE([struct sockaddr_storage],
1194         AC_DEFINE(HAVE_STRUCT_SOCKADDR_STORAGE, 1,
1195                   [if struct sockaddr_storage is defined]), ,
1196    [
1197 #undef inline
1198 #ifdef HAVE_WINDOWS_H
1199 #ifndef WIN32_LEAN_AND_MEAN
1200 #define WIN32_LEAN_AND_MEAN
1201 #endif
1202 #include <windows.h>
1203 #ifdef HAVE_WINSOCK2_H
1204 #include <winsock2.h>
1205 #endif
1206 #else
1207 #ifdef HAVE_SYS_TYPES_H
1208 #include <sys/types.h>
1209 #endif
1210 #ifdef HAVE_SYS_SOCKET_H
1211 #include <sys/socket.h>
1212 #endif
1213 #ifdef HAVE_NETINET_IN_H
1214 #include <netinet/in.h>
1215 #endif
1216 #ifdef HAVE_ARPA_INET_H
1217 #include <arpa/inet.h>
1218 #endif
1219 #endif
1220    ])
1221 ])
1222
1223
1224 dnl CURL_CHECK_NI_WITHSCOPEID
1225 dnl -------------------------------------------------
1226 dnl Check for working NI_WITHSCOPEID in getnameinfo()
1227
1228 AC_DEFUN([CURL_CHECK_NI_WITHSCOPEID], [
1229   AC_REQUIRE([CURL_CHECK_FUNC_GETNAMEINFO])dnl
1230   AC_REQUIRE([TYPE_SOCKADDR_STORAGE])dnl
1231   AC_CHECK_HEADERS(stdio.h sys/types.h sys/socket.h \
1232                    netdb.h netinet/in.h arpa/inet.h)
1233   #
1234   AC_CACHE_CHECK([for working NI_WITHSCOPEID],
1235     [ac_cv_working_ni_withscopeid], [
1236     AC_RUN_IFELSE([
1237       AC_LANG_PROGRAM([[
1238 #ifdef HAVE_STDIO_H
1239 #include <stdio.h>
1240 #endif
1241 #ifdef HAVE_SYS_TYPES_H
1242 #include <sys/types.h>
1243 #endif
1244 #ifdef HAVE_SYS_SOCKET_H
1245 #include <sys/socket.h>
1246 #endif
1247 #ifdef HAVE_NETDB_H
1248 #include <netdb.h>
1249 #endif
1250 #ifdef HAVE_NETINET_IN_H
1251 #include <netinet/in.h>
1252 #endif
1253 #ifdef HAVE_ARPA_INET_H
1254 #include <arpa/inet.h>
1255 #endif
1256       ]],[[
1257 #if defined(NI_WITHSCOPEID) && defined(HAVE_GETNAMEINFO)
1258 #ifdef HAVE_STRUCT_SOCKADDR_STORAGE
1259         struct sockaddr_storage sa;
1260 #else
1261         unsigned char sa[256];
1262 #endif
1263         char hostbuf[NI_MAXHOST];
1264         int rc;
1265         GETNAMEINFO_TYPE_ARG2 salen = (GETNAMEINFO_TYPE_ARG2)sizeof(sa);
1266         GETNAMEINFO_TYPE_ARG46 hostlen = (GETNAMEINFO_TYPE_ARG46)sizeof(hostbuf);
1267         GETNAMEINFO_TYPE_ARG7 flags = NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;
1268         int fd = socket(AF_INET6, SOCK_STREAM, 0);
1269         if(fd < 0) {
1270           perror("socket()");
1271           return 1; /* Error creating socket */
1272         }
1273         rc = getsockname(fd, (GETNAMEINFO_TYPE_ARG1)&sa, &salen);
1274         if(rc) {
1275           perror("getsockname()");
1276           return 2; /* Error retrieving socket name */
1277         }
1278         rc = getnameinfo((GETNAMEINFO_TYPE_ARG1)&sa, salen, hostbuf, hostlen, NULL, 0, flags);
1279         if(rc) {
1280           printf("rc = %s\n", gai_strerror(rc));
1281           return 3; /* Error translating socket address */
1282         }
1283         return 0; /* Ok, NI_WITHSCOPEID works */
1284 #else
1285         return 4; /* Error, NI_WITHSCOPEID not defined or no getnameinfo() */
1286 #endif
1287       ]]) # AC-LANG-PROGRAM
1288     ],[
1289       # Exit code == 0. Program worked.
1290       ac_cv_working_ni_withscopeid="yes"
1291     ],[
1292       # Exit code != 0. Program failed.
1293       ac_cv_working_ni_withscopeid="no"
1294     ],[
1295       # Program is not run when cross-compiling. So we assume
1296       # NI_WITHSCOPEID will work if we are able to compile it.
1297       AC_COMPILE_IFELSE([
1298         AC_LANG_PROGRAM([[
1299 #include <sys/types.h>
1300 #include <sys/socket.h>
1301 #include <netdb.h>
1302         ]],[[
1303           unsigned int dummy= NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;
1304         ]])
1305       ],[
1306         ac_cv_working_ni_withscopeid="yes"
1307       ],[
1308         ac_cv_working_ni_withscopeid="no"
1309       ]) # AC-COMPILE-IFELSE
1310     ]) # AC-RUN-IFELSE
1311   ]) # AC-CACHE-CHECK
1312   case "$ac_cv_working_ni_withscopeid" in
1313     yes)
1314       AC_DEFINE(HAVE_NI_WITHSCOPEID, 1,
1315         [Define to 1 if NI_WITHSCOPEID exists and works.])
1316       ;;
1317   esac
1318 ])
1319
1320
1321 dnl CURL_CHECK_FUNC_RECV
1322 dnl -------------------------------------------------
1323 dnl Test if the socket recv() function is available,
1324 dnl and check its return type and the types of its
1325 dnl arguments. If the function succeeds HAVE_RECV
1326 dnl will be defined, defining the types of the arguments
1327 dnl in RECV_TYPE_ARG1, RECV_TYPE_ARG2, RECV_TYPE_ARG3
1328 dnl and RECV_TYPE_ARG4, defining the type of the function
1329 dnl return value in RECV_TYPE_RETV.
1330
1331 AC_DEFUN([CURL_CHECK_FUNC_RECV], [
1332   AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1333   AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1334   AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1335   #
1336   AC_MSG_CHECKING([for recv])
1337   AC_LINK_IFELSE([
1338     AC_LANG_PROGRAM([[
1339 #undef inline
1340 #ifdef HAVE_WINDOWS_H
1341 #ifndef WIN32_LEAN_AND_MEAN
1342 #define WIN32_LEAN_AND_MEAN
1343 #endif
1344 #include <windows.h>
1345 #ifdef HAVE_WINSOCK2_H
1346 #include <winsock2.h>
1347 #else
1348 #ifdef HAVE_WINSOCK_H
1349 #include <winsock.h>
1350 #endif
1351 #endif
1352 #else
1353 #ifdef HAVE_SYS_TYPES_H
1354 #include <sys/types.h>
1355 #endif
1356 #ifdef HAVE_SYS_SOCKET_H
1357 #include <sys/socket.h>
1358 #endif
1359 #endif
1360     ]],[[
1361       recv(0, 0, 0, 0);
1362     ]])
1363   ],[
1364     AC_MSG_RESULT([yes])
1365     curl_cv_recv="yes"
1366   ],[
1367     AC_MSG_RESULT([no])
1368     curl_cv_recv="no"
1369   ])
1370   #
1371   if test "$curl_cv_recv" = "yes"; then
1372     AC_CACHE_CHECK([types of args and return type for recv],
1373       [curl_cv_func_recv_args], [
1374       curl_cv_func_recv_args="unknown"
1375       for recv_retv in 'int' 'ssize_t'; do
1376         for recv_arg1 in 'int' 'ssize_t' 'SOCKET'; do
1377           for recv_arg2 in 'char *' 'void *'; do
1378             for recv_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
1379               for recv_arg4 in 'int' 'unsigned int'; do
1380                 if test "$curl_cv_func_recv_args" = "unknown"; then
1381                   AC_COMPILE_IFELSE([
1382                     AC_LANG_PROGRAM([[
1383 #undef inline
1384 #ifdef HAVE_WINDOWS_H
1385 #ifndef WIN32_LEAN_AND_MEAN
1386 #define WIN32_LEAN_AND_MEAN
1387 #endif
1388 #include <windows.h>
1389 #ifdef HAVE_WINSOCK2_H
1390 #include <winsock2.h>
1391 #else
1392 #ifdef HAVE_WINSOCK_H
1393 #include <winsock.h>
1394 #endif
1395 #endif
1396 #define RECVCALLCONV PASCAL
1397 #else
1398 #ifdef HAVE_SYS_TYPES_H
1399 #include <sys/types.h>
1400 #endif
1401 #ifdef HAVE_SYS_SOCKET_H
1402 #include <sys/socket.h>
1403 #endif
1404 #define RECVCALLCONV
1405 #endif
1406                       extern $recv_retv RECVCALLCONV
1407                       recv($recv_arg1, $recv_arg2, $recv_arg3, $recv_arg4);
1408                     ]],[[
1409                       $recv_arg1 s=0;
1410                       $recv_arg2 buf=0;
1411                       $recv_arg3 len=0;
1412                       $recv_arg4 flags=0;
1413                       $recv_retv res = recv(s, buf, len, flags);
1414                     ]])
1415                   ],[
1416                     curl_cv_func_recv_args="$recv_arg1,$recv_arg2,$recv_arg3,$recv_arg4,$recv_retv"
1417                   ])
1418                 fi
1419               done
1420             done
1421           done
1422         done
1423       done
1424     ]) # AC-CACHE-CHECK
1425     if test "$curl_cv_func_recv_args" = "unknown"; then
1426       AC_MSG_ERROR([Cannot find proper types to use for recv args])
1427     else
1428       recv_prev_IFS=$IFS; IFS=','
1429       set dummy `echo "$curl_cv_func_recv_args" | sed 's/\*/\*/g'`
1430       IFS=$recv_prev_IFS
1431       shift
1432       #
1433       AC_DEFINE_UNQUOTED(RECV_TYPE_ARG1, $[1],
1434         [Define to the type of arg 1 for recv.])
1435       AC_DEFINE_UNQUOTED(RECV_TYPE_ARG2, $[2],
1436         [Define to the type of arg 2 for recv.])
1437       AC_DEFINE_UNQUOTED(RECV_TYPE_ARG3, $[3],
1438         [Define to the type of arg 3 for recv.])
1439       AC_DEFINE_UNQUOTED(RECV_TYPE_ARG4, $[4],
1440         [Define to the type of arg 4 for recv.])
1441       AC_DEFINE_UNQUOTED(RECV_TYPE_RETV, $[5],
1442         [Define to the function return type for recv.])
1443       #
1444       AC_DEFINE_UNQUOTED(HAVE_RECV, 1,
1445         [Define to 1 if you have the recv function.])
1446       ac_cv_func_recv="yes"
1447     fi
1448   else
1449     AC_MSG_ERROR([Unable to link function recv])
1450   fi
1451 ])
1452
1453
1454 dnl CURL_CHECK_FUNC_SEND
1455 dnl -------------------------------------------------
1456 dnl Test if the socket send() function is available,
1457 dnl and check its return type and the types of its
1458 dnl arguments. If the function succeeds HAVE_SEND
1459 dnl will be defined, defining the types of the arguments
1460 dnl in SEND_TYPE_ARG1, SEND_TYPE_ARG2, SEND_TYPE_ARG3
1461 dnl and SEND_TYPE_ARG4, defining the type of the function
1462 dnl return value in SEND_TYPE_RETV, and also defining the
1463 dnl type qualifier of second argument in SEND_QUAL_ARG2.
1464
1465 AC_DEFUN([CURL_CHECK_FUNC_SEND], [
1466   AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1467   AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1468   AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1469   #
1470   AC_MSG_CHECKING([for send])
1471   AC_LINK_IFELSE([
1472     AC_LANG_PROGRAM([[
1473 #undef inline
1474 #ifdef HAVE_WINDOWS_H
1475 #ifndef WIN32_LEAN_AND_MEAN
1476 #define WIN32_LEAN_AND_MEAN
1477 #endif
1478 #include <windows.h>
1479 #ifdef HAVE_WINSOCK2_H
1480 #include <winsock2.h>
1481 #else
1482 #ifdef HAVE_WINSOCK_H
1483 #include <winsock.h>
1484 #endif
1485 #endif
1486 #else
1487 #ifdef HAVE_SYS_TYPES_H
1488 #include <sys/types.h>
1489 #endif
1490 #ifdef HAVE_SYS_SOCKET_H
1491 #include <sys/socket.h>
1492 #endif
1493 #endif
1494     ]],[[
1495       send(0, 0, 0, 0);
1496     ]])
1497   ],[
1498     AC_MSG_RESULT([yes])
1499     curl_cv_send="yes"
1500   ],[
1501     AC_MSG_RESULT([no])
1502     curl_cv_send="no"
1503   ])
1504   #
1505   if test "$curl_cv_send" = "yes"; then
1506     AC_CACHE_CHECK([types of args and return type for send],
1507       [curl_cv_func_send_args], [
1508       curl_cv_func_send_args="unknown"
1509       for send_retv in 'int' 'ssize_t'; do
1510         for send_arg1 in 'int' 'ssize_t' 'SOCKET'; do
1511           for send_arg2 in 'char *' 'void *' 'const char *' 'const void *'; do
1512             for send_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
1513               for send_arg4 in 'int' 'unsigned int'; do
1514                 if test "$curl_cv_func_send_args" = "unknown"; then
1515                   AC_COMPILE_IFELSE([
1516                     AC_LANG_PROGRAM([[
1517 #undef inline
1518 #ifdef HAVE_WINDOWS_H
1519 #ifndef WIN32_LEAN_AND_MEAN
1520 #define WIN32_LEAN_AND_MEAN
1521 #endif
1522 #include <windows.h>
1523 #ifdef HAVE_WINSOCK2_H
1524 #include <winsock2.h>
1525 #else
1526 #ifdef HAVE_WINSOCK_H
1527 #include <winsock.h>
1528 #endif
1529 #endif
1530 #define SENDCALLCONV PASCAL
1531 #else
1532 #ifdef HAVE_SYS_TYPES_H
1533 #include <sys/types.h>
1534 #endif
1535 #ifdef HAVE_SYS_SOCKET_H
1536 #include <sys/socket.h>
1537 #endif
1538 #define SENDCALLCONV
1539 #endif
1540                       extern $send_retv SENDCALLCONV
1541                       send($send_arg1, $send_arg2, $send_arg3, $send_arg4);
1542                     ]],[[
1543                       $send_arg1 s=0;
1544                       $send_arg3 len=0;
1545                       $send_arg4 flags=0;
1546                       $send_retv res = send(s, 0, len, flags);
1547                     ]])
1548                   ],[
1549                     curl_cv_func_send_args="$send_arg1,$send_arg2,$send_arg3,$send_arg4,$send_retv"
1550                   ])
1551                 fi
1552               done
1553             done
1554           done
1555         done
1556       done
1557     ]) # AC-CACHE-CHECK
1558     if test "$curl_cv_func_send_args" = "unknown"; then
1559       AC_MSG_ERROR([Cannot find proper types to use for send args])
1560     else
1561       send_prev_IFS=$IFS; IFS=','
1562       set dummy `echo "$curl_cv_func_send_args" | sed 's/\*/\*/g'`
1563       IFS=$send_prev_IFS
1564       shift
1565       #
1566       send_qual_type_arg2=$[2]
1567       #
1568       AC_DEFINE_UNQUOTED(SEND_TYPE_ARG1, $[1],
1569         [Define to the type of arg 1 for send.])
1570       AC_DEFINE_UNQUOTED(SEND_TYPE_ARG3, $[3],
1571         [Define to the type of arg 3 for send.])
1572       AC_DEFINE_UNQUOTED(SEND_TYPE_ARG4, $[4],
1573         [Define to the type of arg 4 for send.])
1574       AC_DEFINE_UNQUOTED(SEND_TYPE_RETV, $[5],
1575         [Define to the function return type for send.])
1576       #
1577       prev_sh_opts=$-
1578       #
1579       case $prev_sh_opts in
1580         *f*)
1581           ;;
1582         *)
1583           set -f
1584           ;;
1585       esac
1586       #
1587       case "$send_qual_type_arg2" in
1588         const*)
1589           send_qual_arg2=const
1590           send_type_arg2=`echo $send_qual_type_arg2 | sed 's/^const //'`
1591         ;;
1592         *)
1593           send_qual_arg2=
1594           send_type_arg2=$send_qual_type_arg2
1595         ;;
1596       esac
1597       #
1598       AC_DEFINE_UNQUOTED(SEND_QUAL_ARG2, $send_qual_arg2,
1599         [Define to the type qualifier of arg 2 for send.])
1600       AC_DEFINE_UNQUOTED(SEND_TYPE_ARG2, $send_type_arg2,
1601         [Define to the type of arg 2 for send.])
1602       #
1603       case $prev_sh_opts in
1604         *f*)
1605           ;;
1606         *)
1607           set +f
1608           ;;
1609       esac
1610       #
1611       AC_DEFINE_UNQUOTED(HAVE_SEND, 1,
1612         [Define to 1 if you have the send function.])
1613       ac_cv_func_send="yes"
1614     fi
1615   else
1616     AC_MSG_ERROR([Unable to link function send])
1617   fi
1618 ])
1619
1620
1621 dnl CURL_CHECK_FUNC_RECVFROM
1622 dnl -------------------------------------------------
1623 dnl Test if the socket recvfrom() function is available,
1624 dnl and check its return type and the types of its
1625 dnl arguments. If the function succeeds HAVE_RECVFROM
1626 dnl will be defined, defining the types of the arguments
1627 dnl in RECVFROM_TYPE_ARG1, RECVFROM_TYPE_ARG2, and so on
1628 dnl to RECVFROM_TYPE_ARG6, defining also the type of the
1629 dnl function return value in RECVFROM_TYPE_RETV.
1630 dnl Notice that the types returned for pointer arguments
1631 dnl will actually be the type pointed by the pointer.
1632
1633 AC_DEFUN([CURL_CHECK_FUNC_RECVFROM], [
1634   AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1635   AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1636   AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1637   #
1638   AC_MSG_CHECKING([for recvfrom])
1639   AC_LINK_IFELSE([
1640     AC_LANG_PROGRAM([[
1641 #undef inline
1642 #ifdef HAVE_WINDOWS_H
1643 #ifndef WIN32_LEAN_AND_MEAN
1644 #define WIN32_LEAN_AND_MEAN
1645 #endif
1646 #include <windows.h>
1647 #ifdef HAVE_WINSOCK2_H
1648 #include <winsock2.h>
1649 #else
1650 #ifdef HAVE_WINSOCK_H
1651 #include <winsock.h>
1652 #endif
1653 #endif
1654 #else
1655 #ifdef HAVE_SYS_TYPES_H
1656 #include <sys/types.h>
1657 #endif
1658 #ifdef HAVE_SYS_SOCKET_H
1659 #include <sys/socket.h>
1660 #endif
1661 #endif
1662     ]],[[
1663       recvfrom(0, 0, 0, 0, 0, 0);
1664     ]])
1665   ],[
1666     AC_MSG_RESULT([yes])
1667     curl_cv_recvfrom="yes"
1668   ],[
1669     AC_MSG_RESULT([no])
1670     curl_cv_recvfrom="no"
1671   ])
1672   #
1673   if test "$curl_cv_recvfrom" = "yes"; then
1674     AC_CACHE_CHECK([types of args and return type for recvfrom],
1675       [curl_cv_func_recvfrom_args], [
1676       curl_cv_func_recvfrom_args="unknown"
1677       for recvfrom_retv in 'int' 'ssize_t'; do
1678         for recvfrom_arg1 in 'int' 'ssize_t' 'SOCKET'; do
1679           for recvfrom_arg2 in 'char *' 'void *'; do
1680             for recvfrom_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do
1681               for recvfrom_arg4 in 'int' 'unsigned int'; do
1682                 for recvfrom_arg5 in 'struct sockaddr *' 'void *'; do
1683                   for recvfrom_arg6 in 'socklen_t *' 'int *' 'unsigned int *' 'size_t *' 'void *'; do
1684                     if test "$curl_cv_func_recvfrom_args" = "unknown"; then
1685                       AC_COMPILE_IFELSE([
1686                         AC_LANG_PROGRAM([[
1687 #undef inline
1688 #ifdef HAVE_WINDOWS_H
1689 #ifndef WIN32_LEAN_AND_MEAN
1690 #define WIN32_LEAN_AND_MEAN
1691 #endif
1692 #include <windows.h>
1693 #ifdef HAVE_WINSOCK2_H
1694 #include <winsock2.h>
1695 #else
1696 #ifdef HAVE_WINSOCK_H
1697 #include <winsock.h>
1698 #endif
1699 #endif
1700 #define RECVFROMCALLCONV PASCAL
1701 #else
1702 #ifdef HAVE_SYS_TYPES_H
1703 #include <sys/types.h>
1704 #endif
1705 #ifdef HAVE_SYS_SOCKET_H
1706 #include <sys/socket.h>
1707 #endif
1708 #define RECVFROMCALLCONV
1709 #endif
1710                           extern $recvfrom_retv RECVFROMCALLCONV
1711                           recvfrom($recvfrom_arg1, $recvfrom_arg2,
1712                                    $recvfrom_arg3, $recvfrom_arg4,
1713                                    $recvfrom_arg5, $recvfrom_arg6);
1714                         ]],[[
1715                           $recvfrom_arg1 s=0;
1716                           $recvfrom_arg2 buf=0;
1717                           $recvfrom_arg3 len=0;
1718                           $recvfrom_arg4 flags=0;
1719                           $recvfrom_arg5 addr=0;
1720                           $recvfrom_arg6 addrlen=0;
1721                           $recvfrom_retv res=0;
1722                           res = recvfrom(s, buf, len, flags, addr, addrlen);
1723                         ]])
1724                       ],[
1725                         curl_cv_func_recvfrom_args="$recvfrom_arg1,$recvfrom_arg2,$recvfrom_arg3,$recvfrom_arg4,$recvfrom_arg5,$recvfrom_arg6,$recvfrom_retv"
1726                       ])
1727                     fi
1728                   done
1729                 done
1730               done
1731             done
1732           done
1733         done
1734       done
1735     ]) # AC-CACHE-CHECK
1736     # Nearly last minute change for this release starts here
1737     AC_DEFINE_UNQUOTED(HAVE_RECVFROM, 1,
1738       [Define to 1 if you have the recvfrom function.])
1739     ac_cv_func_recvfrom="yes"
1740     # Nearly last minute change for this release ends here
1741     if test "$curl_cv_func_recvfrom_args" = "unknown"; then
1742       AC_MSG_WARN([Cannot find proper types to use for recvfrom args])
1743     else
1744       recvfrom_prev_IFS=$IFS; IFS=','
1745       set dummy `echo "$curl_cv_func_recvfrom_args" | sed 's/\*/\*/g'`
1746       IFS=$recvfrom_prev_IFS
1747       shift
1748       #
1749       recvfrom_ptrt_arg2=$[2]
1750       recvfrom_ptrt_arg5=$[5]
1751       recvfrom_ptrt_arg6=$[6]
1752       #
1753       AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG1, $[1],
1754         [Define to the type of arg 1 for recvfrom.])
1755       AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG3, $[3],
1756         [Define to the type of arg 3 for recvfrom.])
1757       AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG4, $[4],
1758         [Define to the type of arg 4 for recvfrom.])
1759       AC_DEFINE_UNQUOTED(RECVFROM_TYPE_RETV, $[7],
1760         [Define to the function return type for recvfrom.])
1761       #
1762       prev_sh_opts=$-
1763       #
1764       case $prev_sh_opts in
1765         *f*)
1766           ;;
1767         *)
1768           set -f
1769           ;;
1770       esac
1771       #
1772       recvfrom_type_arg2=`echo $recvfrom_ptrt_arg2 | sed 's/ \*//'`
1773       recvfrom_type_arg5=`echo $recvfrom_ptrt_arg5 | sed 's/ \*//'`
1774       recvfrom_type_arg6=`echo $recvfrom_ptrt_arg6 | sed 's/ \*//'`
1775       #
1776       AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG2, $recvfrom_type_arg2,
1777         [Define to the type pointed by arg 2 for recvfrom.])
1778       AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG5, $recvfrom_type_arg5,
1779         [Define to the type pointed by arg 5 for recvfrom.])
1780       AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG6, $recvfrom_type_arg6,
1781         [Define to the type pointed by arg 6 for recvfrom.])
1782       #
1783       if test "$recvfrom_type_arg2" = "void"; then
1784         AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG2_IS_VOID, 1,
1785           [Define to 1 if the type pointed by arg 2 for recvfrom is void.])
1786       fi
1787       if test "$recvfrom_type_arg5" = "void"; then
1788         AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG5_IS_VOID, 1,
1789           [Define to 1 if the type pointed by arg 5 for recvfrom is void.])
1790       fi
1791       if test "$recvfrom_type_arg6" = "void"; then
1792         AC_DEFINE_UNQUOTED(RECVFROM_TYPE_ARG6_IS_VOID, 1,
1793           [Define to 1 if the type pointed by arg 6 for recvfrom is void.])
1794       fi
1795       #
1796       case $prev_sh_opts in
1797         *f*)
1798           ;;
1799         *)
1800           set +f
1801           ;;
1802       esac
1803       #
1804       AC_DEFINE_UNQUOTED(HAVE_RECVFROM, 1,
1805         [Define to 1 if you have the recvfrom function.])
1806       ac_cv_func_recvfrom="yes"
1807     fi
1808   else
1809     AC_MSG_WARN([Unable to link function recvfrom])
1810   fi
1811 ])
1812
1813
1814 dnl CURL_CHECK_MSG_NOSIGNAL
1815 dnl -------------------------------------------------
1816 dnl Check for MSG_NOSIGNAL
1817
1818 AC_DEFUN([CURL_CHECK_MSG_NOSIGNAL], [
1819   AC_CHECK_HEADERS(sys/types.h sys/socket.h)
1820   AC_CACHE_CHECK([for MSG_NOSIGNAL], [ac_cv_msg_nosignal], [
1821     AC_COMPILE_IFELSE([
1822       AC_LANG_PROGRAM([[
1823 #undef inline
1824 #ifdef HAVE_WINDOWS_H
1825 #ifndef WIN32_LEAN_AND_MEAN
1826 #define WIN32_LEAN_AND_MEAN
1827 #endif
1828 #include <windows.h>
1829 #ifdef HAVE_WINSOCK2_H
1830 #include <winsock2.h>
1831 #else
1832 #ifdef HAVE_WINSOCK_H
1833 #include <winsock.h>
1834 #endif
1835 #endif
1836 #else
1837 #ifdef HAVE_SYS_TYPES_H
1838 #include <sys/types.h>
1839 #endif
1840 #ifdef HAVE_SYS_SOCKET_H
1841 #include <sys/socket.h>
1842 #endif
1843 #endif
1844       ]],[[
1845         int flag=MSG_NOSIGNAL;
1846       ]])
1847     ],[
1848       ac_cv_msg_nosignal="yes"
1849     ],[
1850       ac_cv_msg_nosignal="no"
1851     ])
1852   ])
1853   case "$ac_cv_msg_nosignal" in
1854     yes)
1855       AC_DEFINE_UNQUOTED(HAVE_MSG_NOSIGNAL, 1,
1856         [Define to 1 if you have the MSG_NOSIGNAL flag.])
1857       ;;
1858   esac
1859 ])
1860
1861
1862 dnl CURL_CHECK_STRUCT_TIMEVAL
1863 dnl -------------------------------------------------
1864 dnl Check for timeval struct
1865
1866 AC_DEFUN([CURL_CHECK_STRUCT_TIMEVAL], [
1867   AC_REQUIRE([AC_HEADER_TIME])dnl
1868   AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl
1869   AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl
1870   AC_CHECK_HEADERS(sys/types.h sys/time.h time.h)
1871   AC_CACHE_CHECK([for struct timeval], [ac_cv_struct_timeval], [
1872     AC_COMPILE_IFELSE([
1873       AC_LANG_PROGRAM([[
1874 #undef inline
1875 #ifdef HAVE_WINDOWS_H
1876 #ifndef WIN32_LEAN_AND_MEAN
1877 #define WIN32_LEAN_AND_MEAN
1878 #endif
1879 #include <windows.h>
1880 #ifdef HAVE_WINSOCK2_H
1881 #include <winsock2.h>
1882 #else
1883 #ifdef HAVE_WINSOCK_H
1884 #include <winsock.h>
1885 #endif
1886 #endif
1887 #endif
1888 #ifdef HAVE_SYS_TYPES_H
1889 #include <sys/types.h>
1890 #endif
1891 #ifdef HAVE_SYS_TIME_H
1892 #include <sys/time.h>
1893 #ifdef TIME_WITH_SYS_TIME
1894 #include <time.h>
1895 #endif
1896 #else
1897 #ifdef HAVE_TIME_H
1898 #include <time.h>
1899 #endif
1900 #endif
1901       ]],[[
1902         struct timeval ts;
1903         ts.tv_sec  = 0;
1904         ts.tv_usec = 0;
1905       ]])
1906     ],[
1907       ac_cv_struct_timeval="yes"
1908     ],[
1909       ac_cv_struct_timeval="no"
1910     ])
1911   ])
1912   case "$ac_cv_struct_timeval" in
1913     yes)
1914       AC_DEFINE_UNQUOTED(HAVE_STRUCT_TIMEVAL, 1,
1915         [Define to 1 if you have the timeval struct.])
1916       ;;
1917   esac
1918 ])
1919
1920
1921 dnl TYPE_SIG_ATOMIC_T
1922 dnl -------------------------------------------------
1923 dnl Check if the sig_atomic_t type is available, and
1924 dnl verify if it is already defined as volatile.
1925
1926 AC_DEFUN([TYPE_SIG_ATOMIC_T], [
1927   AC_CHECK_HEADERS(signal.h)
1928   AC_CHECK_TYPE([sig_atomic_t],[
1929     AC_DEFINE(HAVE_SIG_ATOMIC_T, 1,
1930       [Define to 1 if sig_atomic_t is an available typedef.])
1931   ], ,[
1932 #ifdef HAVE_SIGNAL_H
1933 #include <signal.h>
1934 #endif
1935   ])
1936   case "$ac_cv_type_sig_atomic_t" in
1937     yes)
1938       #
1939       AC_MSG_CHECKING([if sig_atomic_t is already defined as volatile])
1940       AC_LINK_IFELSE([
1941         AC_LANG_PROGRAM([[
1942 #ifdef HAVE_SIGNAL_H
1943 #include <signal.h>
1944 #endif
1945         ]],[[
1946           static volatile sig_atomic_t dummy = 0;
1947         ]])
1948       ],[
1949         AC_MSG_RESULT([no])
1950         ac_cv_sig_atomic_t_volatile="no"
1951       ],[
1952         AC_MSG_RESULT([yes])
1953         ac_cv_sig_atomic_t_volatile="yes"
1954       ])
1955       #
1956       if test "$ac_cv_sig_atomic_t_volatile" = "yes"; then
1957         AC_DEFINE(HAVE_SIG_ATOMIC_T_VOLATILE, 1,
1958           [Define to 1 if sig_atomic_t is already defined as volatile.])
1959       fi
1960       ;;
1961   esac
1962 ])
1963
1964
1965 dnl CURL_CHECK_NONBLOCKING_SOCKET
1966 dnl -------------------------------------------------
1967 dnl Check for how to set a socket to non-blocking state. There seems to exist
1968 dnl four known different ways, with the one used almost everywhere being POSIX
1969 dnl and XPG3, while the other different ways for different systems (old BSD,
1970 dnl Windows and Amiga).
1971 dnl
1972 dnl There are two known platforms (AIX 3.x and SunOS 4.1.x) where the
1973 dnl O_NONBLOCK define is found but does not work. This condition is attempted
1974 dnl to get caught in this script by using an excessive number of #ifdefs...
1975
1976 AC_DEFUN([CURL_CHECK_NONBLOCKING_SOCKET], [
1977   AC_MSG_CHECKING([non-blocking sockets style])
1978   nonblock="unknown"
1979   #
1980   AC_COMPILE_IFELSE([
1981     AC_LANG_PROGRAM([[
1982 /* headers for O_NONBLOCK test */
1983 #include <sys/types.h>
1984 #include <unistd.h>
1985 #include <fcntl.h>
1986 /* */
1987 #if defined(sun) || defined(__sun__) || \
1988     defined(__SUNPRO_C) || defined(__SUNPRO_CC)
1989 # if defined(__SVR4) || defined(__srv4__)
1990 #  define PLATFORM_SOLARIS
1991 # else
1992 #  define PLATFORM_SUNOS4
1993 # endif
1994 #endif
1995 #if (defined(_AIX) || defined(__xlC__)) && !defined(_AIX41)
1996 # define PLATFORM_AIX_V3
1997 #endif
1998 /* */
1999 #if defined(PLATFORM_SUNOS4) || defined(PLATFORM_AIX_V3) || defined(__BEOS__)
2000 #error "O_NONBLOCK does not work on this platform"
2001 #endif
2002     ]],[[
2003       /* O_NONBLOCK source test */
2004       int socket;
2005       int flags = fcntl(socket, F_SETFL, flags | O_NONBLOCK);
2006     ]])
2007   ],[
2008     dnl the O_NONBLOCK test was fine
2009     nonblock="O_NONBLOCK"
2010     AC_DEFINE(HAVE_O_NONBLOCK, 1,
2011       [use O_NONBLOCK for non-blocking sockets])
2012   ])
2013   #
2014   if test "$nonblock" = "unknown"; then
2015     AC_COMPILE_IFELSE([
2016       AC_LANG_PROGRAM([[
2017 /* headers for FIONBIO test */
2018 #include <unistd.h>
2019 #include <stropts.h>
2020       ]],[[
2021         /* FIONBIO source test (old-style unix) */
2022         int socket;
2023         int flags = ioctl(socket, FIONBIO, &flags);
2024       ]])
2025     ],[
2026       dnl FIONBIO test was good
2027       nonblock="FIONBIO"
2028       AC_DEFINE(HAVE_FIONBIO, 1,
2029         [use FIONBIO for non-blocking sockets])
2030     ])
2031   fi
2032   #
2033   if test "$nonblock" = "unknown"; then
2034     AC_COMPILE_IFELSE([
2035       AC_LANG_PROGRAM([[
2036 /* headers for ioctlsocket test (Windows) */
2037 #undef inline
2038 #ifdef HAVE_WINDOWS_H
2039 #ifndef WIN32_LEAN_AND_MEAN
2040 #define WIN32_LEAN_AND_MEAN
2041 #endif
2042 #include <windows.h>
2043 #ifdef HAVE_WINSOCK2_H
2044 #include <winsock2.h>
2045 #else
2046 #ifdef HAVE_WINSOCK_H
2047 #include <winsock.h>
2048 #endif
2049 #endif
2050 #endif
2051       ]],[[
2052         /* ioctlsocket source code (Windows) */
2053         SOCKET sd;
2054         unsigned long flags = 0;
2055         sd = socket(0, 0, 0);
2056         ioctlsocket(sd, FIONBIO, &flags);
2057       ]])
2058     ],[
2059       dnl ioctlsocket test was good
2060       nonblock="ioctlsocket"
2061       AC_DEFINE(HAVE_IOCTLSOCKET, 1,
2062         [use ioctlsocket() for non-blocking sockets])
2063     ])
2064   fi
2065   #
2066   if test "$nonblock" = "unknown"; then
2067     AC_LINK_IFELSE([
2068       AC_LANG_PROGRAM([[
2069 /* headers for IoctlSocket test (Amiga?) */
2070 #include <sys/ioctl.h>
2071       ]],[[
2072         /* IoctlSocket source code (Amiga?) */
2073         int socket;
2074         int flags = IoctlSocket(socket, FIONBIO, (long)1);
2075       ]])
2076     ],[
2077       dnl Ioctlsocket test was good
2078       nonblock="IoctlSocket"
2079       AC_DEFINE(HAVE_IOCTLSOCKET_CASE, 1,
2080         [use Ioctlsocket() for non-blocking sockets])
2081     ])
2082   fi
2083   #
2084   if test "$nonblock" = "unknown"; then
2085     AC_COMPILE_IFELSE([
2086       AC_LANG_PROGRAM([[
2087 /* headers for SO_NONBLOCK test (BeOS) */
2088 #include <socket.h>
2089       ]],[[
2090         /* SO_NONBLOCK source code (BeOS) */
2091         long b = 1;
2092         int socket;
2093         int flags = setsockopt(socket, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
2094       ]])
2095     ],[
2096       dnl the SO_NONBLOCK test was good
2097       nonblock="SO_NONBLOCK"
2098       AC_DEFINE(HAVE_SO_NONBLOCK, 1,
2099         [use SO_NONBLOCK for non-blocking sockets])
2100     ])
2101   fi
2102   #
2103   AC_MSG_RESULT($nonblock)
2104   #
2105   if test "$nonblock" = "unknown"; then
2106     AC_DEFINE(HAVE_DISABLED_NONBLOCKING, 1,
2107       [disabled non-blocking sockets])
2108     AC_MSG_WARN([non-block sockets disabled])
2109   fi
2110 ])
2111
2112
2113 dnl TYPE_IN_ADDR_T
2114 dnl -------------------------------------------------
2115 dnl Check for in_addr_t: it is used to receive the return code of inet_addr()
2116 dnl and a few other things.
2117
2118 AC_DEFUN([TYPE_IN_ADDR_T], [
2119   AC_CHECK_TYPE([in_addr_t], ,[
2120     dnl in_addr_t not available
2121     AC_CACHE_CHECK([for in_addr_t equivalent],
2122       [curl_cv_in_addr_t_equiv], [
2123       curl_cv_in_addr_t_equiv="unknown"
2124       for t in "unsigned long" int size_t unsigned long; do
2125         if test "$curl_cv_in_addr_t_equiv" = "unknown"; then
2126           AC_LINK_IFELSE([
2127             AC_LANG_PROGRAM([[
2128 #undef inline
2129 #ifdef HAVE_WINDOWS_H
2130 #ifndef WIN32_LEAN_AND_MEAN
2131 #define WIN32_LEAN_AND_MEAN
2132 #endif
2133 #include <windows.h>
2134 #ifdef HAVE_WINSOCK2_H
2135 #include <winsock2.h>
2136 #else
2137 #ifdef HAVE_WINSOCK_H
2138 #include <winsock.h>
2139 #endif
2140 #endif
2141 #else
2142 #ifdef HAVE_SYS_TYPES_H
2143 #include <sys/types.h>
2144 #endif
2145 #ifdef HAVE_SYS_SOCKET_H
2146 #include <sys/socket.h>
2147 #endif
2148 #ifdef HAVE_NETINET_IN_H
2149 #include <netinet/in.h>
2150 #endif
2151 #ifdef HAVE_ARPA_INET_H
2152 #include <arpa/inet.h>
2153 #endif
2154 #endif
2155             ]],[[
2156               $t data = inet_addr ("1.2.3.4");
2157             ]])
2158           ],[
2159             curl_cv_in_addr_t_equiv="$t"
2160           ])
2161         fi
2162       done
2163     ])
2164     case "$curl_cv_in_addr_t_equiv" in
2165       unknown)
2166         AC_MSG_ERROR([Cannot find a type to use in place of in_addr_t])
2167         ;;
2168       *)
2169         AC_DEFINE_UNQUOTED(in_addr_t, $curl_cv_in_addr_t_equiv,
2170           [Type to use in place of in_addr_t when system does not provide it.])
2171         ;;
2172     esac
2173   ],[
2174 #undef inline
2175 #ifdef HAVE_WINDOWS_H
2176 #ifndef WIN32_LEAN_AND_MEAN
2177 #define WIN32_LEAN_AND_MEAN
2178 #endif
2179 #include <windows.h>
2180 #ifdef HAVE_WINSOCK2_H
2181 #include <winsock2.h>
2182 #else
2183 #ifdef HAVE_WINSOCK_H
2184 #include <winsock.h>
2185 #endif
2186 #endif
2187 #else
2188 #ifdef HAVE_SYS_TYPES_H
2189 #include <sys/types.h>
2190 #endif
2191 #ifdef HAVE_SYS_SOCKET_H
2192 #include <sys/socket.h>
2193 #endif
2194 #ifdef HAVE_NETINET_IN_H
2195 #include <netinet/in.h>
2196 #endif
2197 #ifdef HAVE_ARPA_INET_H
2198 #include <arpa/inet.h>
2199 #endif
2200 #endif
2201   ])
2202 ])
2203
2204
2205 dnl CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC
2206 dnl -------------------------------------------------
2207 dnl Check if monotonic clock_gettime is available.
2208
2209 AC_DEFUN([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC], [
2210   AC_REQUIRE([AC_HEADER_TIME])dnl
2211   AC_CHECK_HEADERS(sys/types.h sys/time.h time.h)
2212   AC_MSG_CHECKING([for monotonic clock_gettime])
2213   AC_COMPILE_IFELSE([
2214     AC_LANG_PROGRAM([[
2215 #ifdef HAVE_SYS_TYPES_H
2216 #include <sys/types.h>
2217 #endif
2218 #ifdef HAVE_SYS_TIME_H
2219 #include <sys/time.h>
2220 #ifdef TIME_WITH_SYS_TIME
2221 #include <time.h>
2222 #endif
2223 #else
2224 #ifdef HAVE_TIME_H
2225 #include <time.h>
2226 #endif
2227 #endif
2228     ]],[[
2229       struct timespec ts;
2230       (void)clock_gettime(CLOCK_MONOTONIC, &ts);
2231     ]])
2232   ],[
2233     AC_MSG_RESULT([yes])
2234     ac_cv_func_clock_gettime="yes"
2235   ],[
2236     AC_MSG_RESULT([no])
2237     ac_cv_func_clock_gettime="no"
2238   ])
2239   dnl Definition of HAVE_CLOCK_GETTIME_MONOTONIC is intentionally postponed
2240   dnl until library linking and run-time checks for clock_gettime succeed.
2241 ])
2242
2243
2244 dnl CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC
2245 dnl -------------------------------------------------
2246 dnl If monotonic clock_gettime is available then,
2247 dnl check and prepended to LIBS any needed libraries.
2248
2249 AC_DEFUN([CURL_CHECK_LIBS_CLOCK_GETTIME_MONOTONIC], [
2250   AC_REQUIRE([CURL_CHECK_FUNC_CLOCK_GETTIME_MONOTONIC])dnl
2251   #
2252   if test "$ac_cv_func_clock_gettime" = "yes"; then
2253     #
2254     AC_MSG_CHECKING([for clock_gettime in libraries])
2255     #
2256     curl_cv_save_LIBS="$LIBS"
2257     curl_cv_gclk_LIBS="unknown"
2258     #
2259     for x_xlibs in '' '-lrt' '-lposix4' ; do
2260       if test "$curl_cv_gclk_LIBS" = "unknown"; then
2261         if test -z "$x_xlibs"; then
2262           LIBS="$curl_cv_save_LIBS"
2263         else
2264           LIBS="$x_xlibs $curl_cv_save_LIBS"
2265         fi
2266         AC_LINK_IFELSE([
2267           AC_LANG_PROGRAM([[
2268 #ifdef HAVE_SYS_TYPES_H
2269 #include <sys/types.h>
2270 #endif
2271 #ifdef HAVE_SYS_TIME_H
2272 #include <sys/time.h>
2273 #ifdef TIME_WITH_SYS_TIME
2274 #include <time.h>
2275 #endif
2276 #else
2277 #ifdef HAVE_TIME_H
2278 #include <time.h>
2279 #endif
2280 #endif
2281           ]],[[
2282             struct timespec ts;
2283             (void)clock_gettime(CLOCK_MONOTONIC, &ts);
2284           ]])
2285         ],[
2286           curl_cv_gclk_LIBS="$x_xlibs"
2287         ])
2288       fi
2289     done
2290     #
2291     LIBS="$curl_cv_save_LIBS"
2292     #
2293     case X-"$curl_cv_gclk_LIBS" in
2294       X-unknown)
2295         AC_MSG_RESULT([cannot find clock_gettime])
2296         AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
2297         ac_cv_func_clock_gettime="no"
2298         ;;
2299       X-)
2300         AC_MSG_RESULT([no additional lib required])
2301         ac_cv_func_clock_gettime="yes"
2302         ;;
2303       *)
2304         if test -z "$curl_cv_save_LIBS"; then
2305           LIBS="$curl_cv_gclk_LIBS"
2306         else
2307           LIBS="$curl_cv_gclk_LIBS $curl_cv_save_LIBS"
2308         fi
2309         AC_MSG_RESULT([$curl_cv_gclk_LIBS])
2310         ac_cv_func_clock_gettime="yes"
2311         ;;
2312     esac
2313     #
2314     dnl only do runtime verification when not cross-compiling
2315     if test "x$cross_compiling" != "xyes" &&
2316       test "$ac_cv_func_clock_gettime" = "yes"; then
2317       AC_MSG_CHECKING([if monotonic clock_gettime works])
2318       AC_RUN_IFELSE([
2319         AC_LANG_PROGRAM([[
2320 #ifdef HAVE_SYS_TYPES_H
2321 #include <sys/types.h>
2322 #endif
2323 #ifdef HAVE_SYS_TIME_H
2324 #include <sys/time.h>
2325 #ifdef TIME_WITH_SYS_TIME
2326 #include <time.h>
2327 #endif
2328 #else
2329 #ifdef HAVE_TIME_H
2330 #include <time.h>
2331 #endif
2332 #endif
2333         ]],[[
2334           struct timespec ts;
2335           if (0 == clock_gettime(CLOCK_MONOTONIC, &ts))
2336             exit(0);
2337           else
2338             exit(1);
2339         ]])
2340       ],[
2341         AC_MSG_RESULT([yes])
2342       ],[
2343         AC_MSG_RESULT([no])
2344         AC_MSG_WARN([HAVE_CLOCK_GETTIME_MONOTONIC will not be defined])
2345         ac_cv_func_clock_gettime="no"
2346         LIBS="$curl_cv_save_LIBS"
2347       ])
2348     fi
2349     #
2350     case "$ac_cv_func_clock_gettime" in
2351       yes)
2352         AC_DEFINE_UNQUOTED(HAVE_CLOCK_GETTIME_MONOTONIC, 1,
2353           [Define to 1 if you have the clock_gettime function and monotonic timer.])
2354         ;;
2355     esac
2356     #
2357   fi
2358   #
2359 ])
2360
2361
2362 dnl CURL_CHECK_FUNC_SELECT
2363 dnl -------------------------------------------------
2364 dnl Test if the socket select() function is available,
2365 dnl and check its return type and the types of its
2366 dnl arguments. If the function succeeds HAVE_SELECT
2367 dnl will be defined, defining the types of the
2368 dnl arguments in SELECT_TYPE_ARG1, SELECT_TYPE_ARG234
2369 dnl and SELECT_TYPE_ARG5, defining the type of the
2370 dnl function return value in SELECT_TYPE_RETV, and
2371 dnl also defining the type qualifier of fifth argument
2372 dnl in SELECT_QUAL_ARG5.
2373
2374 AC_DEFUN([CURL_CHECK_FUNC_SELECT], [
2375   AC_REQUIRE([CURL_CHECK_STRUCT_TIMEVAL])dnl
2376   AC_CHECK_HEADERS(sys/select.h sys/socket.h)
2377   #
2378   AC_MSG_CHECKING([for select])
2379   AC_LINK_IFELSE([
2380     AC_LANG_PROGRAM([[
2381 #undef inline
2382 #ifdef HAVE_WINDOWS_H
2383 #ifndef WIN32_LEAN_AND_MEAN
2384 #define WIN32_LEAN_AND_MEAN
2385 #endif
2386 #include <windows.h>
2387 #ifdef HAVE_WINSOCK2_H
2388 #include <winsock2.h>
2389 #else
2390 #ifdef HAVE_WINSOCK_H
2391 #include <winsock.h>
2392 #endif
2393 #endif
2394 #endif
2395 #ifdef HAVE_SYS_TYPES_H
2396 #include <sys/types.h>
2397 #endif
2398 #ifdef HAVE_SYS_TIME_H
2399 #include <sys/time.h>
2400 #ifdef TIME_WITH_SYS_TIME
2401 #include <time.h>
2402 #endif
2403 #else
2404 #ifdef HAVE_TIME_H
2405 #include <time.h>
2406 #endif
2407 #endif
2408 #ifndef HAVE_WINDOWS_H
2409 #ifdef HAVE_SYS_SELECT_H
2410 #include <sys/select.h>
2411 #endif
2412 #ifdef HAVE_SYS_SOCKET_H
2413 #include <sys/socket.h>
2414 #endif
2415 #endif
2416     ]],[[
2417       select(0, 0, 0, 0, 0);
2418     ]])
2419   ],[
2420     AC_MSG_RESULT([yes])
2421     curl_cv_select="yes"
2422   ],[
2423     AC_MSG_RESULT([no])
2424     curl_cv_select="no"
2425   ])
2426   #
2427   if test "$curl_cv_select" = "yes"; then
2428     AC_CACHE_CHECK([types of args and return type for select],
2429       [curl_cv_func_select_args], [
2430       curl_cv_func_select_args="unknown"
2431       for sel_retv in 'int' 'ssize_t'; do
2432         for sel_arg1 in 'int' 'ssize_t' 'size_t' 'unsigned long int' 'unsigned int'; do
2433           for sel_arg234 in 'fd_set *' 'int *' 'void *'; do
2434             for sel_arg5 in 'struct timeval *' 'const struct timeval *'; do
2435               if test "$curl_cv_func_select_args" = "unknown"; then
2436                 AC_COMPILE_IFELSE([
2437                   AC_LANG_PROGRAM([[
2438 #undef inline
2439 #ifdef HAVE_WINDOWS_H
2440 #ifndef WIN32_LEAN_AND_MEAN
2441 #define WIN32_LEAN_AND_MEAN
2442 #endif
2443 #include <windows.h>
2444 #ifdef HAVE_WINSOCK2_H
2445 #include <winsock2.h>
2446 #else
2447 #ifdef HAVE_WINSOCK_H
2448 #include <winsock.h>
2449 #endif
2450 #endif
2451 #define SELECTCALLCONV PASCAL
2452 #endif
2453 #ifdef HAVE_SYS_TYPES_H
2454 #include <sys/types.h>
2455 #endif
2456 #ifdef HAVE_SYS_TIME_H
2457 #include <sys/time.h>
2458 #ifdef TIME_WITH_SYS_TIME
2459 #include <time.h>
2460 #endif
2461 #else
2462 #ifdef HAVE_TIME_H
2463 #include <time.h>
2464 #endif
2465 #endif
2466 #ifndef HAVE_WINDOWS_H
2467 #ifdef HAVE_SYS_SELECT_H
2468 #include <sys/select.h>
2469 #endif
2470 #ifdef HAVE_SYS_SOCKET_H
2471 #include <sys/socket.h>
2472 #endif
2473 #define SELECTCALLCONV
2474 #endif
2475 #ifndef HAVE_STRUCT_TIMEVAL
2476                     struct timeval {
2477                       long tv_sec;
2478                       long tv_usec;
2479                     };
2480 #endif
2481                     extern $sel_retv SELECTCALLCONV select($sel_arg1,
2482                                                            $sel_arg234,
2483                                                            $sel_arg234,
2484                                                            $sel_arg234,
2485                                                            $sel_arg5);
2486                   ]],[[
2487                     $sel_arg1   nfds=0;
2488                     $sel_arg234 rfds=0;
2489                     $sel_arg234 wfds=0;
2490                     $sel_arg234 efds=0;
2491                     $sel_retv res = select(nfds, rfds, wfds, efds, 0);
2492                   ]])
2493                 ],[
2494                   curl_cv_func_select_args="$sel_arg1,$sel_arg234,$sel_arg5,$sel_retv"
2495                 ])
2496               fi
2497             done
2498           done
2499         done
2500       done
2501     ]) # AC-CACHE-CHECK
2502     if test "$curl_cv_func_select_args" = "unknown"; then
2503       AC_MSG_WARN([Cannot find proper types to use for select args])
2504       AC_MSG_WARN([HAVE_SELECT will not be defined])
2505     else
2506       select_prev_IFS=$IFS; IFS=','
2507       set dummy `echo "$curl_cv_func_select_args" | sed 's/\*/\*/g'`
2508       IFS=$select_prev_IFS
2509       shift
2510       #
2511       sel_qual_type_arg5=$[3]
2512       #
2513       AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG1, $[1],
2514         [Define to the type of arg 1 for select.])
2515       AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG234, $[2],
2516         [Define to the type of args 2, 3 and 4 for select.])
2517       AC_DEFINE_UNQUOTED(SELECT_TYPE_RETV, $[4],
2518         [Define to the function return type for select.])
2519       #
2520       prev_sh_opts=$-
2521       #
2522       case $prev_sh_opts in
2523         *f*)
2524           ;;
2525         *)
2526           set -f
2527           ;;
2528       esac
2529       #
2530       case "$sel_qual_type_arg5" in
2531         const*)
2532           sel_qual_arg5=const
2533           sel_type_arg5=`echo $sel_qual_type_arg5 | sed 's/^const //'`
2534         ;;
2535         *)
2536           sel_qual_arg5=
2537           sel_type_arg5=$sel_qual_type_arg5
2538         ;;
2539       esac
2540       #
2541       AC_DEFINE_UNQUOTED(SELECT_QUAL_ARG5, $sel_qual_arg5,
2542         [Define to the type qualifier of arg 5 for select.])
2543       AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG5, $sel_type_arg5,
2544         [Define to the type of arg 5 for select.])
2545       #
2546       case $prev_sh_opts in
2547         *f*)
2548           ;;
2549         *)
2550           set +f
2551           ;;
2552       esac
2553       #
2554       AC_DEFINE_UNQUOTED(HAVE_SELECT, 1,
2555         [Define to 1 if you have the select function.])
2556       ac_cv_func_select="yes"
2557     fi
2558   fi
2559 ])
2560
2561
2562 dnl ************************************************************
2563 dnl check for working getaddrinfo() that works with AI_NUMERICHOST
2564 dnl
2565 AC_DEFUN([CURL_CHECK_WORKING_GETADDRINFO],[
2566   AC_CACHE_CHECK(for working getaddrinfo, ac_cv_working_getaddrinfo,[
2567   AC_TRY_RUN( [
2568 #include <netdb.h>
2569 #include <sys/types.h>
2570 #include <sys/socket.h>
2571
2572 int main(void)
2573 {
2574     struct addrinfo hints, *ai;
2575     int error;
2576
2577     memset(&hints, 0, sizeof(hints));
2578     hints.ai_flags = AI_NUMERICHOST;
2579     hints.ai_family = AF_UNSPEC;
2580     hints.ai_socktype = SOCK_STREAM;
2581     error = getaddrinfo("127.0.0.1", "8080", &hints, &ai);
2582     if (error) {
2583         return 1;
2584     }
2585     return 0;
2586 }
2587 ],[
2588   ac_cv_working_getaddrinfo="yes"
2589 ],[
2590   ac_cv_working_getaddrinfo="no"
2591 ],[
2592   ac_cv_working_getaddrinfo="yes"
2593 ])])
2594 if test "$ac_cv_working_getaddrinfo" = "yes"; then
2595   AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if getaddrinfo exists and works])
2596   AC_DEFINE(ENABLE_IPV6, 1, [Define if you want to enable IPv6 support])
2597
2598   IPV6_ENABLED=1
2599   AC_SUBST(IPV6_ENABLED)
2600 fi
2601 ])
2602
2603
2604 AC_DEFUN([CURL_CHECK_LOCALTIME_R],
2605 [
2606   dnl check for localtime_r
2607   AC_CHECK_FUNCS(localtime_r,[
2608     AC_MSG_CHECKING(whether localtime_r is declared)
2609     AC_EGREP_CPP(localtime_r,[
2610 #undef _REENTRANT
2611 #include <time.h>],[
2612       AC_MSG_RESULT(yes)],[
2613       AC_MSG_RESULT(no)
2614       AC_MSG_CHECKING(whether localtime_r with -D_REENTRANT is declared)
2615       AC_EGREP_CPP(localtime_r,[
2616 #undef _REENTRANT
2617 #define _REENTRANT
2618 #include <time.h>],[
2619         AC_MSG_RESULT(yes)],
2620         AC_MSG_RESULT(no))])])
2621 ])
2622
2623 dnl
2624 dnl This function checks for strerror_r(). If it isn't found at first, it
2625 dnl retries with _THREAD_SAFE defined, as that is what AIX seems to require
2626 dnl in order to find this function.
2627 dnl
2628 dnl If the function is found, it will then proceed to check how the function
2629 dnl actually works: glibc-style or POSIX-style.
2630 dnl
2631 dnl glibc:
2632 dnl      char *strerror_r(int errnum, char *buf, size_t n);
2633 dnl
2634 dnl  What this one does is to return the error string (no surprises there),
2635 dnl  but it doesn't usually copy anything into buf!  The 'buf' and 'n'
2636 dnl  parameters are only meant as an optional working area, in case strerror_r
2637 dnl  needs it.  A quick test on a few systems shows that it's generally not
2638 dnl  touched at all.
2639 dnl
2640 dnl POSIX:
2641 dnl      int strerror_r(int errnum, char *buf, size_t n);
2642 dnl
2643 AC_DEFUN([CURL_CHECK_STRERROR_R],
2644 [
2645   AC_CHECK_FUNCS(strerror_r)
2646
2647   if test "x$ac_cv_func_strerror_r" = "xyes"; then
2648
2649     AC_MSG_CHECKING(whether strerror_r is declared)
2650     AC_EGREP_CPP(strerror_r,[
2651 #undef _REENTRANT
2652 #include <string.h>],[
2653       AC_MSG_RESULT(yes)],[
2654       AC_MSG_RESULT(no)
2655       AC_MSG_CHECKING(whether strerror_r with -D_REENTRANT is declared)
2656       AC_EGREP_CPP(strerror_r,[
2657 #undef _REENTRANT
2658 #define _REENTRANT
2659 #include <string.h>],[
2660         AC_MSG_RESULT(yes)],
2661         AC_MSG_RESULT(no)
2662         AC_DEFINE(HAVE_NO_STRERROR_R_DECL, 1, [we have no strerror_r() proto])
2663        ) dnl with _THREAD_SAFE
2664     ]) dnl plain cpp for it
2665
2666     dnl determine if this strerror_r() is glibc or POSIX
2667     AC_MSG_CHECKING([for a glibc strerror_r API])
2668     AC_TRY_RUN([
2669 #include <string.h>
2670 #include <errno.h>
2671 int
2672 main () {
2673   char buffer[1024]; /* big enough to play with */
2674   char *string =
2675     strerror_r(EACCES, buffer, sizeof(buffer));
2676     /* this should've returned a string */
2677     if(!string || !string[0])
2678       return 99;
2679     return 0;
2680 }
2681 ],
2682     GLIBC_STRERROR_R="1"
2683     AC_DEFINE(HAVE_GLIBC_STRERROR_R, 1, [we have a glibc-style strerror_r()])
2684     AC_MSG_RESULT([yes]),
2685     AC_MSG_RESULT([no]),
2686
2687     dnl Use an inferior method of strerror_r detection while cross-compiling
2688     AC_EGREP_CPP(yes, [
2689 #include <features.h>
2690 #ifdef __GLIBC__
2691 yes
2692 #endif
2693 ],
2694       dnl looks like glibc, so assume a glibc-style strerror_r()
2695       GLIBC_STRERROR_R="1"
2696       AC_DEFINE(HAVE_GLIBC_STRERROR_R, 1, [we have a glibc-style strerror_r()])
2697       AC_MSG_RESULT([yes]),
2698       AC_MSG_NOTICE([cannot determine strerror_r() style: edit lib/config.h manually!])
2699     ) dnl while cross-compiling
2700     )
2701
2702     if test -z "$GLIBC_STRERROR_R"; then
2703
2704       AC_MSG_CHECKING([for a POSIX strerror_r API])
2705       AC_TRY_RUN([
2706 #include <string.h>
2707 #include <errno.h>
2708 int
2709 main () {
2710   char buffer[1024]; /* big enough to play with */
2711   int error =
2712     strerror_r(EACCES, buffer, sizeof(buffer));
2713     /* This should've returned zero, and written an error string in the
2714        buffer.*/
2715     if(!buffer[0] || error)
2716       return 99;
2717     return 0;
2718 }
2719 ],
2720       AC_DEFINE(HAVE_POSIX_STRERROR_R, 1, [we have a POSIX-style strerror_r()])
2721       AC_MSG_RESULT([yes]),
2722       AC_MSG_RESULT([no]) ,
2723       dnl cross-compiling!
2724       AC_MSG_NOTICE([cannot determine strerror_r() style: edit lib/config.h manually!])
2725     )
2726
2727     fi dnl if not using glibc API
2728
2729   fi dnl we have a strerror_r
2730
2731 ])
2732
2733 AC_DEFUN([CURL_CHECK_INET_NTOA_R],
2734 [
2735   dnl determine if function definition for inet_ntoa_r exists.
2736   AC_CHECK_FUNCS(inet_ntoa_r,[
2737     AC_MSG_CHECKING(whether inet_ntoa_r is declared)
2738     AC_EGREP_CPP(inet_ntoa_r,[
2739 #undef _REENTRANT
2740 #include <arpa/inet.h>],[
2741       AC_DEFINE(HAVE_INET_NTOA_R_DECL, 1, [inet_ntoa_r() is declared])
2742       AC_MSG_RESULT(yes)],[
2743       AC_MSG_RESULT(no)
2744       AC_MSG_CHECKING(whether inet_ntoa_r with -D_REENTRANT is declared)
2745       AC_EGREP_CPP(inet_ntoa_r,[
2746 #undef _REENTRANT
2747 #define _REENTRANT
2748 #include <arpa/inet.h>],[
2749         AC_DEFINE(HAVE_INET_NTOA_R_DECL, 1, [inet_ntoa_r() is declared])
2750         AC_MSG_RESULT(yes)],
2751         AC_MSG_RESULT(no))])])
2752 ])
2753
2754
2755 dnl CURL_CHECK_GETHOSTBYADDR_R
2756 dnl -------------------------------------------------
2757 dnl check number of arguments for gethostbyaddr_r, it
2758 dnl might take either 5, 7, or 8 arguments.
2759
2760 AC_DEFUN([CURL_CHECK_GETHOSTBYADDR_R], [
2761   #
2762   AC_MSG_CHECKING([for gethostbyaddr_r])
2763   AC_LINK_IFELSE([
2764     AC_LANG_FUNC_LINK_TRY([gethostbyaddr_r])
2765   ],[
2766     AC_MSG_RESULT([yes])
2767     tmp_cv_gethostbyaddr_r="yes"
2768   ],[
2769     AC_MSG_RESULT([no])
2770     tmp_cv_gethostbyaddr_r="no"
2771   ])
2772   #
2773   if test "$tmp_cv_gethostbyaddr_r" != "yes"; then
2774     AC_MSG_CHECKING([deeper for gethostbyaddr_r])
2775     AC_LINK_IFELSE([
2776       AC_LANG_PROGRAM([[
2777       ]],[[
2778         gethostbyaddr_r();
2779       ]])
2780     ],[
2781       AC_MSG_RESULT([yes])
2782       tmp_cv_gethostbyaddr_r="yes"
2783     ],[
2784       AC_MSG_RESULT([but still no])
2785       tmp_cv_gethostbyaddr_r="no"
2786     ])
2787   fi
2788   #
2789   if test "$tmp_cv_gethostbyaddr_r" = "yes"; then
2790
2791     ac_cv_gethostbyaddr_r_args="unknown"
2792
2793     AC_MSG_CHECKING([if gethostbyaddr_r takes 5 arguments])
2794     AC_COMPILE_IFELSE([
2795       AC_LANG_PROGRAM([[
2796 #undef _REENTRANT
2797 #include <sys/types.h>
2798 #include <netdb.h>
2799       ]],[[
2800         char * address;
2801         int length;
2802         int type;
2803         struct hostent h;
2804         struct hostent_data hdata;
2805         int rc;
2806         rc = gethostbyaddr_r(address, length, type, &h, &hdata);
2807       ]])
2808     ],[
2809       AC_MSG_RESULT([yes])
2810       AC_DEFINE(HAVE_GETHOSTBYADDR_R_5, 1, [gethostbyaddr_r() takes 5 args])
2811       ac_cv_gethostbyaddr_r_args="5"
2812     ],[
2813       AC_MSG_RESULT([no])
2814     ])
2815
2816     if test "$ac_cv_gethostbyaddr_r_args" = "unknown"; then
2817       AC_MSG_CHECKING([if gethostbyaddr_r with -D_REENTRANT takes 5 arguments])
2818       AC_COMPILE_IFELSE([
2819         AC_LANG_PROGRAM([[
2820 #undef _REENTRANT
2821 #define _REENTRANT
2822 #include <sys/types.h>
2823 #include <netdb.h>
2824         ]],[[
2825           char * address;
2826           int length;
2827           int type;
2828           struct hostent h;
2829           struct hostent_data hdata;
2830           int rc;
2831           rc = gethostbyaddr_r(address, length, type, &h, &hdata);
2832         ]])
2833       ],[
2834         AC_MSG_RESULT([yes])
2835         AC_DEFINE(HAVE_GETHOSTBYADDR_R_5, 1, [gethostbyaddr_r() takes 5 args])
2836         ac_cv_gethostbyaddr_r_args="5"
2837       ],[
2838         AC_MSG_RESULT([no])
2839       ])
2840     fi
2841
2842     if test "$ac_cv_gethostbyaddr_r_args" = "unknown"; then
2843       AC_MSG_CHECKING([if gethostbyaddr_r takes 7 arguments])
2844       AC_COMPILE_IFELSE([
2845         AC_LANG_PROGRAM([[
2846 #undef _REENTRANT
2847 #include <sys/types.h>
2848 #include <netdb.h>
2849         ]],[[
2850           char * address;
2851           int length;
2852           int type;
2853           struct hostent h;
2854           char buffer[8192];
2855           int h_errnop;
2856           struct hostent * hp;
2857           hp = gethostbyaddr_r(address, length, type, &h,
2858                                buffer, 8192, &h_errnop);
2859         ]])
2860       ],[
2861         AC_MSG_RESULT([yes])
2862         AC_DEFINE(HAVE_GETHOSTBYADDR_R_7, 1, [gethostbyaddr_r() takes 7 args])
2863         ac_cv_gethostbyaddr_r_args="7"
2864       ],[
2865         AC_MSG_RESULT([no])
2866       ])
2867     fi
2868
2869     if test "$ac_cv_gethostbyaddr_r_args" = "unknown"; then
2870       AC_MSG_CHECKING([if gethostbyaddr_r with -D_REENTRANT takes 7 arguments])
2871       AC_COMPILE_IFELSE([
2872         AC_LANG_PROGRAM([[
2873 #undef _REENTRANT
2874 #define _REENTRANT
2875 #include <sys/types.h>
2876 #include <netdb.h>
2877         ]],[[
2878           char * address;
2879           int length;
2880           int type;
2881           struct hostent h;
2882           char buffer[8192];
2883           int h_errnop;
2884           struct hostent * hp;
2885           hp = gethostbyaddr_r(address, length, type, &h,
2886                                buffer, 8192, &h_errnop);
2887         ]])
2888       ],[
2889         AC_MSG_RESULT([yes])
2890         AC_DEFINE(HAVE_GETHOSTBYADDR_R_7, 1, [gethostbyaddr_r() takes 7 args])
2891         ac_cv_gethostbyaddr_r_args="7"
2892       ],[
2893         AC_MSG_RESULT([no])
2894       ])
2895     fi
2896
2897     if test "$ac_cv_gethostbyaddr_r_args" = "unknown"; then
2898       AC_MSG_CHECKING([if gethostbyaddr_r takes 8 arguments])
2899       AC_COMPILE_IFELSE([
2900         AC_LANG_PROGRAM([[
2901 #undef _REENTRANT
2902 #include <sys/types.h>
2903 #include <netdb.h>
2904         ]],[[
2905           char * address;
2906           int length;
2907           int type;
2908           struct hostent h;
2909           char buffer[8192];
2910           int h_errnop;
2911           struct hostent * hp;
2912           int rc;
2913           rc = gethostbyaddr_r(address, length, type, &h,
2914                                buffer, 8192, &hp, &h_errnop);
2915         ]])
2916       ],[
2917         AC_MSG_RESULT([yes])
2918         AC_DEFINE(HAVE_GETHOSTBYADDR_R_8, 1, [gethostbyaddr_r() takes 8 args])
2919         ac_cv_gethostbyaddr_r_args="8"
2920       ],[
2921         AC_MSG_RESULT([no])
2922       ])
2923     fi
2924
2925     if test "$ac_cv_gethostbyaddr_r_args" = "unknown"; then
2926       AC_MSG_CHECKING([if gethostbyaddr_r with -D_REENTRANT takes 8 arguments])
2927       AC_COMPILE_IFELSE([
2928         AC_LANG_PROGRAM([[
2929 #undef _REENTRANT
2930 #define _REENTRANT
2931 #include <sys/types.h>
2932 #include <netdb.h>
2933         ]],[[
2934           char * address;
2935           int length;
2936           int type;
2937           struct hostent h;
2938           char buffer[8192];
2939           int h_errnop;
2940           struct hostent * hp;
2941           int rc;
2942           rc = gethostbyaddr_r(address, length, type, &h,
2943                                buffer, 8192, &hp, &h_errnop);
2944         ]])
2945       ],[
2946         AC_MSG_RESULT([yes])
2947         AC_DEFINE(HAVE_GETHOSTBYADDR_R_8, 1, [gethostbyaddr_r() takes 8 args])
2948         ac_cv_gethostbyaddr_r_args="8"
2949       ],[
2950         AC_MSG_RESULT([no])
2951       ])
2952     fi
2953
2954     if test "$ac_cv_gethostbyaddr_r_args" = "unknown"; then
2955       AC_MSG_WARN([Cannot find out how to use gethostbyaddr_r])
2956       AC_MSG_WARN([HAVE_GETHOSTBYADDR_R will not be defined])
2957       ac_cv_func_gethostbyaddr_r="no"
2958     else
2959       AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYADDR_R, 1,
2960         [Define to 1 if you have the gethostbyaddr_r function.])
2961       ac_cv_func_gethostbyaddr_r="yes"
2962     fi
2963
2964   else
2965     ac_cv_func_gethostbyaddr_r="no"
2966   fi
2967 ])
2968
2969
2970 dnl CURL_CHECK_GETHOSTBYNAME_R
2971 dnl -------------------------------------------------
2972 dnl check number of arguments for gethostbyname_r, it
2973 dnl might take either 3, 5, or 6 arguments.
2974
2975 AC_DEFUN([CURL_CHECK_GETHOSTBYNAME_R], [
2976   #
2977   AC_MSG_CHECKING([for gethostbyname_r])
2978   AC_LINK_IFELSE([
2979     AC_LANG_FUNC_LINK_TRY([gethostbyname_r])
2980   ],[
2981     AC_MSG_RESULT([yes])
2982     tmp_cv_gethostbyname_r="yes"
2983   ],[
2984     AC_MSG_RESULT([no])
2985     tmp_cv_gethostbyname_r="no"
2986   ])
2987   #
2988   if test "$tmp_cv_gethostbyname_r" != "yes"; then
2989     AC_MSG_CHECKING([deeper for gethostbyname_r])
2990     AC_LINK_IFELSE([
2991       AC_LANG_PROGRAM([[
2992       ]],[[
2993         gethostbyname_r();
2994       ]])
2995     ],[
2996       AC_MSG_RESULT([yes])
2997       tmp_cv_gethostbyname_r="yes"
2998     ],[
2999       AC_MSG_RESULT([but still no])
3000       tmp_cv_gethostbyname_r="no"
3001     ])
3002   fi
3003   #
3004   if test "$tmp_cv_gethostbyname_r" = "yes"; then
3005
3006     ac_cv_gethostbyname_r_args="unknown"
3007
3008     AC_MSG_CHECKING([if gethostbyname_r takes 3 arguments])
3009     AC_COMPILE_IFELSE([
3010       AC_LANG_PROGRAM([[
3011 #undef _REENTRANT
3012 #include <string.h>
3013 #include <sys/types.h>
3014 #include <netdb.h>
3015 #undef NULL
3016 #define NULL (void *)0
3017         int
3018         gethostbyname_r(const char *, struct hostent *,
3019                         struct hostent_data *);
3020       ]],[[
3021         struct hostent_data data;
3022         gethostbyname_r(NULL, NULL, NULL);
3023       ]])
3024     ],[
3025       AC_MSG_RESULT([yes])
3026       AC_DEFINE(HAVE_GETHOSTBYNAME_R_3, 1, [gethostbyname_r() takes 3 args])
3027       ac_cv_gethostbyname_r_args="3"
3028     ],[
3029       AC_MSG_RESULT([no])
3030     ])
3031
3032     if test "$ac_cv_gethostbyname_r_args" = "unknown"; then
3033       AC_MSG_CHECKING([if gethostbyname_r with -D_REENTRANT takes 3 arguments])
3034       AC_COMPILE_IFELSE([
3035         AC_LANG_PROGRAM([[
3036 #undef _REENTRANT
3037 #define _REENTRANT
3038 #include <string.h>
3039 #include <sys/types.h>
3040 #include <netdb.h>
3041 #undef NULL
3042 #define NULL (void *)0
3043           int
3044           gethostbyname_r(const char *, struct hostent *,
3045                           struct hostent_data *);
3046         ]],[[
3047           struct hostent_data data;
3048           gethostbyname_r(NULL, NULL, NULL);
3049         ]])
3050       ],[
3051         AC_MSG_RESULT([yes])
3052         AC_DEFINE(HAVE_GETHOSTBYNAME_R_3, 1, [gethostbyname_r() takes 3 args])
3053         ac_cv_gethostbyname_r_args="3"
3054       ],[
3055         AC_MSG_RESULT([no])
3056       ])
3057     fi
3058
3059     if test "$ac_cv_gethostbyname_r_args" = "unknown"; then
3060       AC_MSG_CHECKING([if gethostbyname_r takes 5 arguments])
3061       AC_COMPILE_IFELSE([
3062         AC_LANG_PROGRAM([[
3063 #undef _REENTRANT
3064 #include <sys/types.h>
3065 #include <netdb.h>
3066 #undef NULL
3067 #define NULL (void *)0
3068           struct hostent *
3069           gethostbyname_r(const char *, struct hostent *,
3070                           char *, int, int *);
3071         ]],[[
3072           gethostbyname_r(NULL, NULL, NULL, 0, NULL);
3073         ]])
3074       ],[
3075         AC_MSG_RESULT([yes])
3076         AC_DEFINE(HAVE_GETHOSTBYNAME_R_5, 1, [gethostbyname_r() takes 5 args])
3077         ac_cv_gethostbyname_r_args="5"
3078       ],[
3079         AC_MSG_RESULT([no])
3080       ])
3081     fi
3082
3083     if test "$ac_cv_gethostbyname_r_args" = "unknown"; then
3084       AC_MSG_CHECKING([if gethostbyname_r with -D_REENTRANT takes 5 arguments])
3085       AC_COMPILE_IFELSE([
3086         AC_LANG_PROGRAM([[
3087 #undef _REENTRANT
3088 #define _REENTRANT
3089 #include <sys/types.h>
3090 #include <netdb.h>
3091 #undef NULL
3092 #define NULL (void *)0
3093           struct hostent *
3094           gethostbyname_r(const char *, struct hostent *,
3095                           char *, int, int *);
3096         ]],[[
3097           gethostbyname_r(NULL, NULL, NULL, 0, NULL);
3098         ]])
3099       ],[
3100         AC_MSG_RESULT([yes])
3101         AC_DEFINE(HAVE_GETHOSTBYNAME_R_5, 1, [gethostbyname_r() takes 5 args])
3102         ac_cv_gethostbyname_r_args="5"
3103       ],[
3104         AC_MSG_RESULT([no])
3105       ])
3106     fi
3107
3108     if test "$ac_cv_gethostbyname_r_args" = "unknown"; then
3109       AC_MSG_CHECKING([if gethostbyname_r takes 6 arguments])
3110       AC_COMPILE_IFELSE([
3111         AC_LANG_PROGRAM([[
3112 #undef _REENTRANT
3113 #include <sys/types.h>
3114 #include <netdb.h>
3115 #undef NULL
3116 #define NULL (void *)0
3117           int
3118           gethostbyname_r(const char *, struct hostent *,
3119                           char *, size_t, struct hostent **, int *);
3120         ]],[[
3121           gethostbyname_r(NULL, NULL, NULL, 0, NULL, NULL);
3122         ]])
3123       ],[
3124         AC_MSG_RESULT([yes])
3125         AC_DEFINE(HAVE_GETHOSTBYNAME_R_6, 1, [gethostbyname_r() takes 6 args])
3126         ac_cv_gethostbyname_r_args="6"
3127       ],[
3128         AC_MSG_RESULT([no])
3129       ])
3130     fi
3131
3132     if test "$ac_cv_gethostbyname_r_args" = "unknown"; then
3133       AC_MSG_CHECKING([if gethostbyname_r with -D_REENTRANT takes 6 arguments])
3134       AC_COMPILE_IFELSE([
3135         AC_LANG_PROGRAM([[
3136 #undef _REENTRANT
3137 #define _REENTRANT
3138 #include <sys/types.h>
3139 #include <netdb.h>
3140 #undef NULL
3141 #define NULL (void *)0
3142           int
3143           gethostbyname_r(const char *, struct hostent *,
3144                           char *, size_t, struct hostent **, int *);
3145         ]],[[
3146           gethostbyname_r(NULL, NULL, NULL, 0, NULL, NULL);
3147         ]])
3148       ],[
3149         AC_MSG_RESULT([yes])
3150         AC_DEFINE(HAVE_GETHOSTBYNAME_R_6, 1, [gethostbyname_r() takes 6 args])
3151         ac_cv_gethostbyname_r_args="6"
3152       ],[
3153         AC_MSG_RESULT([no])
3154       ])
3155     fi
3156
3157     if test "$ac_cv_gethostbyname_r_args" = "unknown"; then
3158       AC_MSG_WARN([Cannot find out how to use gethostbyname_r])
3159       AC_MSG_WARN([HAVE_GETHOSTBYNAME_R will not be defined])
3160       ac_cv_func_gethostbyname_r="no"
3161     else
3162       AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYNAME_R, 1,
3163         [Define to 1 if you have the gethostbyname_r function.])
3164       ac_cv_func_gethostbyname_r="yes"
3165     fi
3166
3167   else
3168     ac_cv_func_gethostbyname_r="no"
3169   fi
3170 ])
3171
3172
3173 dnl **********************************************************************
3174 dnl CURL_DETECT_ICC ([ACTION-IF-YES])
3175 dnl
3176 dnl check if this is the Intel ICC compiler, and if so run the ACTION-IF-YES
3177 dnl sets the $ICC variable to "yes" or "no"
3178 dnl **********************************************************************
3179 AC_DEFUN([CURL_DETECT_ICC],
3180 [
3181     ICC="no"
3182     AC_MSG_CHECKING([for icc in use])
3183     if test "$GCC" = "yes"; then
3184        dnl check if this is icc acting as gcc in disguise
3185        AC_EGREP_CPP([^__INTEL_COMPILER], [__INTEL_COMPILER],
3186          dnl action if the text is found, this it has not been replaced by the
3187          dnl cpp
3188          ICC="no",
3189          dnl the text was not found, it was replaced by the cpp
3190          ICC="yes"
3191          AC_MSG_RESULT([yes])
3192          [$1]
3193        )
3194     fi
3195     if test "$ICC" = "no"; then
3196         # this is not ICC
3197         AC_MSG_RESULT([no])
3198     fi
3199 ])
3200
3201 dnl We create a function for detecting which compiler we use and then set as
3202 dnl pendantic compiler options as possible for that particular compiler. The
3203 dnl options are only used for debug-builds.
3204
3205 AC_DEFUN([CURL_CC_DEBUG_OPTS],
3206 [
3207     if test "z$ICC" = "z"; then
3208       CURL_DETECT_ICC
3209     fi
3210
3211     if test "$GCC" = "yes"; then
3212
3213        dnl figure out gcc version!
3214        AC_MSG_CHECKING([gcc version])
3215        gccver=`$CC -dumpversion`
3216        num1=`echo $gccver | cut -d . -f1`
3217        num2=`echo $gccver | cut -d . -f2`
3218        gccnum=`(expr $num1 "*" 100 + $num2) 2>/dev/null`
3219        AC_MSG_RESULT($gccver)
3220
3221        if test "$ICC" = "yes"; then
3222          dnl this is icc, not gcc.
3223
3224          dnl ICC warnings we ignore:
3225          dnl * 269 warns on our "%Od" printf formatters for curl_off_t output:
3226          dnl   "invalid format string conversion"
3227          dnl * 279 warns on static conditions in while expressions
3228          dnl * 981 warns on "operands are evaluated in unspecified order"
3229          dnl * 1418 "external definition with no prior declaration"
3230          dnl * 1419 warns on "external declaration in primary source file"
3231          dnl   which we know and do on purpose.
3232
3233          WARN="-wd279,269,981,1418,1419"
3234          WARN=""
3235
3236          if test "$gccnum" -gt "600"; then
3237             dnl icc 6.0 and older doesn't have the -Wall flag
3238             WARN="-Wall $WARN"
3239          fi
3240        else dnl $ICC = yes
3241          dnl this is a set of options we believe *ALL* gcc versions support:
3242          WARN="-W -Wall -Wwrite-strings -pedantic -Wpointer-arith -Wnested-externs -Winline -Wmissing-prototypes"
3243
3244          dnl -Wcast-align is a bit too annoying on all gcc versions ;-)
3245
3246          if test "$gccnum" -ge "207"; then
3247            dnl gcc 2.7 or later
3248            WARN="$WARN -Wmissing-declarations"
3249          fi
3250
3251          if test "$gccnum" -gt "295"; then
3252            dnl only if the compiler is newer than 2.95 since we got lots of
3253            dnl "`_POSIX_C_SOURCE' is not defined" in system headers with
3254            dnl gcc 2.95.4 on FreeBSD 4.9!
3255            WARN="$WARN -Wundef -Wno-long-long -Wsign-compare -Wshadow -Wno-multichar"
3256          fi
3257
3258          if test "$gccnum" -ge "296"; then
3259            dnl gcc 2.96 or later
3260            WARN="$WARN -Wfloat-equal"
3261          fi
3262
3263          if test "$gccnum" -gt "296"; then
3264            dnl this option does not exist in 2.96
3265            WARN="$WARN -Wno-format-nonliteral"
3266          fi
3267
3268          dnl -Wunreachable-code seems totally unreliable on my gcc 3.3.2 on
3269          dnl on i686-Linux as it gives us heaps with false positives.
3270          dnl Also, on gcc 4.0.X it is totally unbearable and complains all
3271          dnl over making it unusable for generic purposes. Let's not use it.
3272
3273          if test "$gccnum" -ge "303"; then
3274            dnl gcc 3.3 and later
3275            WARN="$WARN -Wendif-labels -Wstrict-prototypes"
3276          fi
3277
3278          if test "$gccnum" -ge "304"; then
3279            # try these on gcc 3.4
3280            WARN="$WARN -Wdeclaration-after-statement"
3281          fi
3282
3283          for flag in $CPPFLAGS; do
3284            case "$flag" in
3285             -I*)
3286               dnl Include path, provide a -isystem option for the same dir
3287               dnl to prevent warnings in those dirs. The -isystem was not very
3288               dnl reliable on earlier gcc versions.
3289               add=`echo $flag | sed 's/^-I/-isystem /g'`
3290               WARN="$WARN $add"
3291               ;;
3292            esac
3293          done
3294
3295        fi dnl $ICC = no
3296
3297        CFLAGS="$CFLAGS $WARN"
3298
3299       AC_MSG_NOTICE([Added this set of compiler options: $WARN])
3300
3301     else dnl $GCC = yes
3302
3303       AC_MSG_NOTICE([Added no extra compiler options])
3304
3305     fi dnl $GCC = yes
3306
3307     dnl strip off optimizer flags
3308     NEWFLAGS=""
3309     for flag in $CFLAGS; do
3310       case "$flag" in
3311       -O*)
3312         dnl echo "cut off $flag"
3313         ;;
3314       *)
3315         NEWFLAGS="$NEWFLAGS $flag"
3316         ;;
3317       esac
3318     done
3319     CFLAGS=$NEWFLAGS
3320
3321 ]) # AC-DEFUN
3322
3323
3324
3325 # This is only a temporary fix. This macro is here to replace the broken one
3326 # delivered by the automake project (including the 1.9.6 release). As soon as
3327 # they ship a working version we SHOULD remove this work-around.
3328
3329 AC_DEFUN([AM_MISSING_HAS_RUN],
3330 [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
3331 test x"${MISSING+set}" = xset || MISSING="\${SHELL} \"$am_aux_dir/missing\""
3332 # Use eval to expand $SHELL
3333 if eval "$MISSING --run true"; then
3334   am_missing_run="$MISSING --run "
3335 else
3336   am_missing_run=
3337   AC_MSG_WARN([`missing' script is too old or missing])
3338 fi
3339 ])
3340
3341
3342 dnl CURL_VERIFY_RUNTIMELIBS
3343 dnl -------------------------------------------------
3344 dnl Verify that the shared libs found so far can be used when running
3345 dnl programs, since otherwise the situation will create odd configure errors
3346 dnl that are misleading people.
3347 dnl
3348 dnl Make sure this test is run BEFORE the first test in the script that
3349 dnl runs anything, which at the time of this writing is the AC_CHECK_SIZEOF
3350 dnl macro. It must also run AFTER all lib-checking macros are complete.
3351
3352 AC_DEFUN([CURL_VERIFY_RUNTIMELIBS], [
3353
3354   dnl this test is of course not sensible if we are cross-compiling!
3355   if test "x$cross_compiling" != xyes; then
3356
3357     dnl just run a program to verify that the libs checked for previous to this
3358     dnl point also is available run-time!
3359     AC_MSG_CHECKING([run-time libs availability])
3360     AC_TRY_RUN([
3361 main()
3362 {
3363   return 0;
3364 }
3365 ],
3366     AC_MSG_RESULT([fine]),
3367     AC_MSG_RESULT([failed])
3368     AC_MSG_ERROR([one or more libs available at link-time are not available run-time. Libs used at link-time: $LIBS])
3369     )
3370
3371     dnl if this test fails, configure has already stopped
3372   fi
3373 ])
3374
3375
3376 dnl CURL_CHECK_VARIADIC_MACROS
3377 dnl -------------------------------------------------
3378 dnl Check compiler support of variadic macros
3379
3380 AC_DEFUN([CURL_CHECK_VARIADIC_MACROS], [
3381   AC_CACHE_CHECK([for compiler support of C99 variadic macro style],
3382     [curl_cv_variadic_macros_c99], [
3383     AC_COMPILE_IFELSE([
3384       AC_LANG_PROGRAM([[
3385 #define c99_vmacro3(first, ...) fun3(first, __VA_ARGS__)
3386 #define c99_vmacro2(first, ...) fun2(first, __VA_ARGS__)
3387         int fun3(int arg1, int arg2, int arg3);
3388         int fun2(int arg1, int arg2);
3389         int fun3(int arg1, int arg2, int arg3)
3390         { return arg1 + arg2 + arg3; }
3391         int fun2(int arg1, int arg2)
3392         { return arg1 + arg2; }
3393       ]],[[
3394         int res3 = c99_vmacro3(1, 2, 3);
3395         int res2 = c99_vmacro2(1, 2);
3396       ]])
3397     ],[
3398       curl_cv_variadic_macros_c99="yes"
3399     ],[
3400       curl_cv_variadic_macros_c99="no"
3401     ])
3402   ])
3403   case "$curl_cv_variadic_macros_c99" in
3404     yes)
3405       AC_DEFINE_UNQUOTED(HAVE_VARIADIC_MACROS_C99, 1,
3406         [Define to 1 if compiler supports C99 variadic macro style.])
3407       ;;
3408   esac
3409   AC_CACHE_CHECK([for compiler support of old gcc variadic macro style],
3410     [curl_cv_variadic_macros_gcc], [
3411     AC_COMPILE_IFELSE([
3412       AC_LANG_PROGRAM([[
3413 #define gcc_vmacro3(first, args...) fun3(first, args)
3414 #define gcc_vmacro2(first, args...) fun2(first, args)
3415         int fun3(int arg1, int arg2, int arg3);
3416         int fun2(int arg1, int arg2);
3417         int fun3(int arg1, int arg2, int arg3)
3418         { return arg1 + arg2 + arg3; }
3419         int fun2(int arg1, int arg2)
3420         { return arg1 + arg2; }
3421       ]],[[
3422         int res3 = gcc_vmacro3(1, 2, 3);
3423         int res2 = gcc_vmacro2(1, 2);
3424       ]])
3425     ],[
3426       curl_cv_variadic_macros_gcc="yes"
3427     ],[
3428       curl_cv_variadic_macros_gcc="no"
3429     ])
3430   ])
3431   case "$curl_cv_variadic_macros_gcc" in
3432     yes)
3433       AC_DEFINE_UNQUOTED(HAVE_VARIADIC_MACROS_GCC, 1,
3434         [Define to 1 if compiler supports old gcc variadic macro style.])
3435       ;;
3436   esac
3437 ])
3438
3439
3440 dnl CURL_CHECK_CA_BUNDLE
3441 dnl -------------------------------------------------
3442 dnl Check if a default ca-bundle should be used
3443 dnl
3444 dnl regarding the paths this will scan:
3445 dnl /etc/ssl/certs/ca-certificates.crt Debian systems
3446 dnl /etc/pki/tls/certs/ca-bundle.crt Redhat and Mandriva
3447 dnl /usr/share/ssl/certs/ca-bundle.crt old(er) Redhat
3448 dnl /usr/local/share/certs/ca-root.crt FreeBSD
3449 dnl /etc/ssl/certs/ (ca path) SUSE
3450
3451 AC_DEFUN([CURL_CHECK_CA_BUNDLE], [
3452
3453   AC_MSG_CHECKING([default CA cert bundle/path])
3454
3455   AC_ARG_WITH(ca-bundle,
3456 AC_HELP_STRING([--with-ca-bundle=FILE], [File name to use as CA bundle])
3457 AC_HELP_STRING([--without-ca-bundle], [Don't use a default CA bundle]),
3458   [
3459     want_ca="$withval"
3460     if test "x$want_ca" = "xyes"; then
3461       AC_MSG_ERROR([--with-ca-bundle=FILE requires a path to the CA bundle])
3462     fi
3463   ],
3464   [ want_ca="unset" ])
3465   AC_ARG_WITH(ca-path,
3466 AC_HELP_STRING([--with-ca-path=DIRECTORY], [Directory to use as CA path])
3467 AC_HELP_STRING([--without-ca-path], [Don't use a default CA path]),
3468   [
3469     want_capath="$withval"
3470     if test "x$want_capath" = "xyes"; then
3471       AC_MSG_ERROR([--with-ca-path=DIRECTORY requires a path to the CA path directory])
3472     fi
3473   ],
3474   [ want_capath="unset"])
3475
3476   if test "x$want_ca" != "xno" -a "x$want_ca" != "xunset" -a \
3477           "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
3478     dnl both given
3479     AC_MSG_ERROR([Can't specify both --with-ca-bundle and --with-ca-path.])
3480   elif test "x$want_ca" != "xno" -a "x$want_ca" != "xunset"; then
3481     dnl --with-ca-bundle given
3482     ca="$want_ca"
3483     capath="no"
3484   elif test "x$want_capath" != "xno" -a "x$want_capath" != "xunset"; then
3485     dnl --with-ca-path given
3486     if test "x$OPENSSL_ENABLED" != "x1"; then
3487       AC_MSG_ERROR([--with-ca-path only works with openSSL])
3488     fi
3489     capath="$want_capath"
3490     ca="no"
3491   else
3492     dnl neither of --with-ca-* given
3493     dnl first try autodetecting a CA bundle , then a CA path
3494     dnl both autodetections can be skipped by --without-ca-*
3495     ca="no"
3496     capath="no"
3497     if test "x$want_ca" = "xunset"; then
3498       dnl the path we previously would have installed the curl ca bundle
3499       dnl to, and thus we now check for an already existing cert in that place
3500       dnl in case we find no other
3501       if test "x$prefix" != xNONE; then
3502         cac="${prefix}/share/curl/curl-ca-bundle.crt"
3503       else
3504         cac="$ac_default_prefix/share/curl/curl-ca-bundle.crt"
3505       fi
3506
3507       for a in /etc/ssl/certs/ca-certificates.crt \
3508                /etc/pki/tls/certs/ca-bundle.crt \
3509                /usr/share/ssl/certs/ca-bundle.crt \
3510                /usr/local/share/certs/ca-root.crt \
3511                "$cac"; do
3512         if test -f "$a"; then
3513           ca="$a"
3514           break
3515         fi
3516       done
3517     fi
3518     if test "x$want_capath" = "xunset" -a "x$ca" = "xno" -a \
3519             "x$OPENSSL_ENABLED" = "x1"; then
3520       for a in /etc/ssl/certs/; do
3521         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
3522           capath="$a"
3523           break
3524         fi
3525       done
3526     fi
3527   fi
3528
3529
3530
3531   if test "x$ca" != "xno"; then
3532     CURL_CA_BUNDLE='"'$ca'"'
3533     AC_DEFINE_UNQUOTED(CURL_CA_BUNDLE, "$ca", [Location of default ca bundle])
3534     AC_SUBST(CURL_CA_BUNDLE)
3535     AC_MSG_RESULT([$ca])
3536   elif test "x$capath" != "xno"; then
3537     CURL_CA_PATH="\"$capath\""
3538     AC_DEFINE_UNQUOTED(CURL_CA_PATH, "$capath", [Location of default ca path])
3539     AC_MSG_RESULT([$capath (capath)])
3540   else
3541     AC_MSG_RESULT([no])
3542   fi
3543 ])
3544
3545
3546 dnl CURL_DEFINE_UNQUOTED (VARIABLE, [VALUE])
3547 dnl -------------------------------------------------
3548 dnl Like AC_DEFINE_UNQUOTED this macro will define a C preprocessor
3549 dnl symbol that can be further used in custom template configuration
3550 dnl files. This macro, unlike AC_DEFINE_UNQUOTED, does not use a third
3551 dnl argument for the description. Symbol definitions done with this
3552 dnl macro are intended to be exclusively used in handcrafted *.h.in
3553 dnl template files. Contrary to what AC_DEFINE_UNQUOTED does, this one
3554 dnl prevents autoheader generation and insertion of symbol template
3555 dnl stub and definition into the first configuration header file. Do
3556 dnl not use this macro as a replacement for AC_DEFINE_UNQUOTED, each
3557 dnl one serves different functional needs.
3558
3559 AC_DEFUN([CURL_DEFINE_UNQUOTED], [
3560 cat >>confdefs.h <<_EOF
3561 [@%:@define] $1 ifelse($#, 2, [$2], 1)
3562 _EOF
3563 ])
3564
3565
3566 dnl CURL_INCLUDES_INTTYPES
3567 dnl -------------------------------------------------
3568 dnl Set up variable with list of headers that must be
3569 dnl included when inttypes.h is to be included.
3570
3571 AC_DEFUN([CURL_INCLUDES_INTTYPES], [
3572 curl_includes_inttypes="\
3573 /* includes start */
3574 #ifdef HAVE_SYS_TYPES_H
3575 # include <sys/types.h>
3576 #endif
3577 #ifdef HAVE_STDINT_H
3578 # include <stdint.h>
3579 #endif
3580 #ifdef HAVE_INTTYPES_H
3581 # include <inttypes.h>
3582 #endif
3583 /* includes end */"
3584   AC_CHECK_HEADERS(
3585     sys/types.h stdint.h inttypes.h,
3586     [], [], [$curl_includes_inttypes])
3587 ])
3588
3589
3590 dnl CURL_CONFIGURE_LONG
3591 dnl -------------------------------------------------
3592 dnl Find out the size of long as reported by sizeof() and define
3593 dnl CURL_SIZEOF_LONG as appropriate to be used in template file
3594 dnl include/curl/curlbuild.h.in to properly configure the library.
3595 dnl The size of long is a build time characteristic and as such
3596 dnl must be recorded in curlbuild.h
3597
3598 AC_DEFUN([CURL_CONFIGURE_LONG], [
3599   if test -z "$ac_cv_sizeof_long" ||
3600     test "$ac_cv_sizeof_long" -eq "0"; then
3601     AC_MSG_ERROR([cannot find out size of long.])
3602   fi
3603   CURL_DEFINE_UNQUOTED([CURL_SIZEOF_LONG], [$ac_cv_sizeof_long])
3604 ])
3605
3606
3607 dnl DO_CURL_OFF_T_CHECK (TYPE, SIZE)
3608 dnl -------------------------------------------------
3609 dnl Internal macro for CURL_CONFIGURE_CURL_OFF_T
3610
3611 AC_DEFUN([DO_CURL_OFF_T_CHECK], [
3612   AC_REQUIRE([CURL_INCLUDES_INTTYPES])dnl
3613   if test "$curl_typeof_curl_off_t" = "unknown" && test ! -z "$1"; then
3614     tmp_includes=""
3615     tmp_source=""
3616     tmp_fmt=""
3617     case AS_TR_SH([$1]) in
3618       int64_t)
3619         tmp_includes="$curl_includes_inttypes"
3620         tmp_source="char f@<:@@:>@ = PRId64;"
3621         tmp_fmt="PRId64"
3622         ;;
3623       int32_t)
3624         tmp_includes="$curl_includes_inttypes"
3625         tmp_source="char f@<:@@:>@ = PRId32;"
3626         tmp_fmt="PRId32"
3627         ;;
3628       int16_t)
3629         tmp_includes="$curl_includes_inttypes"
3630         tmp_source="char f@<:@@:>@ = PRId16;"
3631         tmp_fmt="PRId16"
3632         ;;
3633     esac
3634     AC_COMPILE_IFELSE([
3635       AC_LANG_PROGRAM([[
3636         $tmp_includes
3637         typedef $1 curl_off_t;
3638         typedef char dummy_arr[sizeof(curl_off_t) == $2 ? 1 : -1];
3639       ]],[[
3640         $tmp_source
3641         curl_off_t dummy;
3642       ]])
3643     ],[
3644       if test -z "$tmp_fmt"; then
3645         curl_typeof_curl_off_t="$1"
3646         curl_sizeof_curl_off_t="$2"
3647       else
3648         CURL_CHECK_DEF([$tmp_fmt], [$curl_includes_inttypes], [silent])
3649         AS_VAR_PUSHDEF([tmp_HaveFmtDef], [curl_cv_have_def_$tmp_fmt])dnl
3650         AS_VAR_PUSHDEF([tmp_FmtDef], [curl_cv_def_$tmp_fmt])dnl
3651         if test AS_VAR_GET(tmp_HaveFmtDef) = "yes"; then
3652           curl_format_curl_off_t=AS_VAR_GET(tmp_FmtDef)
3653           curl_typeof_curl_off_t="$1"
3654           curl_sizeof_curl_off_t="$2"
3655         fi
3656         AS_VAR_POPDEF([tmp_FmtDef])dnl
3657         AS_VAR_POPDEF([tmp_HaveFmtDef])dnl
3658       fi
3659     ])
3660   fi
3661 ])
3662
3663
3664 dnl DO_CURL_OFF_T_SUFFIX_CHECK (TYPE)
3665 dnl -------------------------------------------------
3666 dnl Internal macro for CURL_CONFIGURE_CURL_OFF_T
3667
3668 AC_DEFUN([DO_CURL_OFF_T_SUFFIX_CHECK], [
3669   AC_REQUIRE([CURL_INCLUDES_INTTYPES])dnl
3670   AC_MSG_CHECKING([constant suffix string for curl_off_t])
3671   #
3672   curl_suffix_curl_off_t="unknown"
3673   curl_suffix_curl_off_tu="unknown"
3674   #
3675   case AS_TR_SH([$1]) in
3676     long_long | __longlong | __longlong_t)
3677       tst_suffixes="LL::"
3678       ;;
3679     long)
3680       tst_suffixes="L::"
3681       ;;
3682     int)
3683       tst_suffixes="::"
3684       ;;
3685     __int64 | int64_t)
3686       tst_suffixes="LL:i64::"
3687       ;;
3688     __int32 | int32_t)
3689       tst_suffixes="L:i32::"
3690       ;;
3691     __int16 | int16_t)
3692       tst_suffixes="L:i16::"
3693       ;;
3694     *)
3695       AC_MSG_ERROR([unexpected data type $1])
3696       ;;
3697   esac
3698   #
3699   old_IFS=$IFS; IFS=':'
3700   for tmp_ssuf in $tst_suffixes ; do
3701     IFS=$old_IFS
3702     if test "x$curl_suffix_curl_off_t" = "xunknown"; then
3703       case $tmp_ssuf in
3704         i64 | i32 | i16)
3705           tmp_usuf="u$tmp_ssuf"
3706           ;;
3707         LL | L)
3708           tmp_usuf="U$tmp_ssuf"
3709           ;;
3710         *)
3711           tmp_usuf=""
3712           ;;
3713       esac
3714       AC_COMPILE_IFELSE([
3715         AC_LANG_PROGRAM([[
3716           $curl_includes_inttypes
3717           typedef $1 new_t;
3718         ]],[[
3719           new_t s1;
3720           new_t s2;
3721           s1 = -10$tmp_ssuf ;
3722           s2 =  20$tmp_ssuf ;
3723           if(s1 > s2)
3724             return 1;
3725         ]])
3726       ],[
3727         curl_suffix_curl_off_t="$tmp_ssuf"
3728         curl_suffix_curl_off_tu="$tmp_usuf"
3729       ])
3730     fi
3731   done
3732   IFS=$old_IFS
3733   #
3734   if test "x$curl_suffix_curl_off_t" = "xunknown"; then
3735     AC_MSG_ERROR([cannot find constant suffix string for curl_off_t.])
3736   else
3737     AC_MSG_RESULT([$curl_suffix_curl_off_t])
3738     AC_MSG_CHECKING([constant suffix string for unsigned curl_off_t])
3739     AC_MSG_RESULT([$curl_suffix_curl_off_tu])
3740   fi
3741   #
3742 ])
3743
3744
3745 dnl CURL_CONFIGURE_CURL_OFF_T
3746 dnl -------------------------------------------------
3747 dnl Find out suitable curl_off_t data type definition and associated
3748 dnl items, and make the appropriate definitions used in template file
3749 dnl include/curl/curlbuild.h.in to properly configure the library.
3750
3751 AC_DEFUN([CURL_CONFIGURE_CURL_OFF_T], [
3752   AC_REQUIRE([CURL_INCLUDES_INTTYPES])dnl
3753   #
3754   AC_BEFORE([$0],[AC_SYS_LARGEFILE])dnl
3755   AC_BEFORE([$0],[CURL_CONFIGURE_REENTRANT])dnl
3756   AC_BEFORE([$0],[CURL_CHECK_AIX_ALL_SOURCE])dnl
3757   #
3758   if test -z "$SED"; then
3759     AC_MSG_ERROR([SED not set. Cannot continue without SED being set.])
3760   fi
3761   #
3762   AC_CHECK_SIZEOF(long)
3763   AC_CHECK_SIZEOF(void*)
3764   #
3765   if test -z "$ac_cv_sizeof_long" ||
3766     test "$ac_cv_sizeof_long" -eq "0"; then
3767     AC_MSG_ERROR([cannot find out size of long.])
3768   fi
3769   if test -z "$ac_cv_sizeof_voidp" ||
3770      test "$ac_cv_sizeof_voidp" -eq "0"; then
3771     AC_MSG_ERROR([cannot find out size of void*.])
3772   fi
3773   #
3774   x_LP64_long=""
3775   x_LP32_long=""
3776   x_LP16_long=""
3777   #
3778   if test "$ac_cv_sizeof_long" -eq "8" &&
3779      test "$ac_cv_sizeof_voidp" -ge "8"; then
3780     x_LP64_long="long"
3781   elif test "$ac_cv_sizeof_long" -eq "4" &&
3782        test "$ac_cv_sizeof_voidp" -ge "4"; then
3783     x_LP32_long="long"
3784   elif test "$ac_cv_sizeof_long" -eq "2" &&
3785        test "$ac_cv_sizeof_voidp" -ge "2"; then
3786     x_LP16_long="long"
3787   fi
3788   #
3789   dnl DO_CURL_OFF_T_CHECK results are stored in next 3 vars
3790   #
3791   curl_typeof_curl_off_t="unknown"
3792   curl_sizeof_curl_off_t="unknown"
3793   curl_format_curl_off_t="unknown"
3794   curl_format_curl_off_tu="unknown"
3795   #
3796   if test "$curl_typeof_curl_off_t" = "unknown"; then
3797     AC_MSG_CHECKING([for 64-bit curl_off_t data type])
3798     for t8 in          \
3799       "$x_LP64_long"   \
3800       'int64_t'        \
3801       '__int64'        \
3802       'long long'      \
3803       '__longlong'     \
3804       '__longlong_t'   ; do
3805       DO_CURL_OFF_T_CHECK([$t8], [8])
3806     done
3807     AC_MSG_RESULT([$curl_typeof_curl_off_t])
3808   fi
3809   if test "$curl_typeof_curl_off_t" = "unknown"; then
3810     AC_MSG_CHECKING([for 32-bit curl_off_t data type])
3811     for t4 in          \
3812       "$x_LP32_long"   \
3813       'int32_t'        \
3814       '__int32'        \
3815       'int'            ; do
3816       DO_CURL_OFF_T_CHECK([$t4], [4])
3817     done
3818     AC_MSG_RESULT([$curl_typeof_curl_off_t])
3819   fi
3820   if test "$curl_typeof_curl_off_t" = "unknown"; then
3821     AC_MSG_CHECKING([for 16-bit curl_off_t data type])
3822     for t2 in          \
3823       "$x_LP16_long"   \
3824       'int16_t'        \
3825       '__int16'        \
3826       'int'            ; do
3827       DO_CURL_OFF_T_CHECK([$t2], [2])
3828     done
3829     AC_MSG_RESULT([$curl_typeof_curl_off_t])
3830   fi
3831   if test "$curl_typeof_curl_off_t" = "unknown"; then
3832     AC_MSG_ERROR([cannot find data type for curl_off_t.])
3833   fi
3834   #
3835   AC_MSG_CHECKING([size of curl_off_t])
3836   AC_MSG_RESULT([$curl_sizeof_curl_off_t])
3837   #
3838   AC_MSG_CHECKING([formatting string directive for curl_off_t])
3839   if test "$curl_format_curl_off_t" != "unknown"; then
3840     x_pull_headers="yes"
3841     curl_format_curl_off_t=`echo "$curl_format_curl_off_t" | "$SED" 's/[["]]//g'`
3842     curl_format_curl_off_tu=`echo "$curl_format_curl_off_t" | "$SED" 's/i$/u/'`
3843     curl_format_curl_off_tu=`echo "$curl_format_curl_off_tu" | "$SED" 's/d$/u/'`
3844     curl_format_curl_off_tu=`echo "$curl_format_curl_off_tu" | "$SED" 's/D$/U/'`
3845   else
3846     x_pull_headers="no"
3847     case AS_TR_SH([$curl_typeof_curl_off_t]) in
3848       long_long | __longlong | __longlong_t)
3849         curl_format_curl_off_t="lld"
3850         curl_format_curl_off_tu="llu"
3851         ;;
3852       long)
3853         curl_format_curl_off_t="ld"
3854         curl_format_curl_off_tu="lu"
3855         ;;
3856       int)
3857         curl_format_curl_off_t="d"
3858         curl_format_curl_off_tu="u"
3859         ;;
3860       __int64)
3861         curl_format_curl_off_t="I64d"
3862         curl_format_curl_off_tu="I64u"
3863         ;;
3864       __int32)
3865         curl_format_curl_off_t="I32d"
3866         curl_format_curl_off_tu="I32u"
3867         ;;
3868       __int16)
3869         curl_format_curl_off_t="I16d"
3870         curl_format_curl_off_tu="I16u"
3871         ;;
3872       *)
3873         AC_MSG_ERROR([cannot find print format string for curl_off_t.])
3874         ;;
3875     esac
3876   fi
3877   AC_MSG_RESULT(["$curl_format_curl_off_t"])
3878   #
3879   AC_MSG_CHECKING([formatting string directive for unsigned curl_off_t])
3880   AC_MSG_RESULT(["$curl_format_curl_off_tu"])
3881   #
3882   DO_CURL_OFF_T_SUFFIX_CHECK([$curl_typeof_curl_off_t])
3883   #
3884   if test "$x_pull_headers" = "yes"; then
3885     if test "x$ac_cv_header_sys_types_h" = "xyes"; then
3886       CURL_DEFINE_UNQUOTED([CURL_PULL_SYS_TYPES_H])
3887     fi
3888     if test "x$ac_cv_header_stdint_h" = "xyes"; then
3889       CURL_DEFINE_UNQUOTED([CURL_PULL_STDINT_H])
3890     fi
3891     if test "x$ac_cv_header_inttypes_h" = "xyes"; then
3892       CURL_DEFINE_UNQUOTED([CURL_PULL_INTTYPES_H])
3893     fi
3894   fi
3895   #
3896   CURL_DEFINE_UNQUOTED([CURL_TYPEOF_CURL_OFF_T], [$curl_typeof_curl_off_t])
3897   CURL_DEFINE_UNQUOTED([CURL_FORMAT_CURL_OFF_T], ["$curl_format_curl_off_t"])
3898   CURL_DEFINE_UNQUOTED([CURL_FORMAT_CURL_OFF_TU], ["$curl_format_curl_off_tu"])
3899   CURL_DEFINE_UNQUOTED([CURL_FORMAT_OFF_T], ["%$curl_format_curl_off_t"])
3900   CURL_DEFINE_UNQUOTED([CURL_SIZEOF_CURL_OFF_T], [$curl_sizeof_curl_off_t])
3901   CURL_DEFINE_UNQUOTED([CURL_SUFFIX_CURL_OFF_T], [$curl_suffix_curl_off_t])
3902   CURL_DEFINE_UNQUOTED([CURL_SUFFIX_CURL_OFF_TU], [$curl_suffix_curl_off_tu])
3903   #
3904 ])
3905
3906
3907 dnl CURL_CHECK_WIN32_LARGEFILE
3908 dnl -------------------------------------------------
3909 dnl Check if curl's WIN32 large file will be used
3910
3911 AC_DEFUN([CURL_CHECK_WIN32_LARGEFILE], [
3912   AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl
3913   AC_MSG_CHECKING([whether build target supports WIN32 file API])
3914   curl_win32_file_api="no"
3915   if test "$ac_cv_header_windows_h" = "yes"; then
3916     if test x"$enable_largefile" != "xno"; then
3917       AC_COMPILE_IFELSE([
3918         AC_LANG_PROGRAM([[
3919         ]],[[
3920 #if !defined(_WIN32_WCE) && \
3921     (defined(__MINGW32__) || \
3922     (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64))))
3923           int dummy=1;
3924 #else
3925           WIN32 large file API not supported.
3926 #endif
3927         ]])
3928       ],[
3929         curl_win32_file_api="win32_large_files"
3930       ])
3931     fi
3932     if test "$curl_win32_file_api" = "no"; then
3933       AC_COMPILE_IFELSE([
3934         AC_LANG_PROGRAM([[
3935         ]],[[
3936 #if defined(_WIN32_WCE) || defined(__MINGW32__) || defined(_MSC_VER)
3937           int dummy=1;
3938 #else
3939           WIN32 small file API not supported.
3940 #endif
3941         ]])
3942       ],[
3943         curl_win32_file_api="win32_small_files"
3944       ])
3945     fi
3946   fi
3947   case "$curl_win32_file_api" in
3948     win32_large_files)
3949       AC_MSG_RESULT([yes (large file enabled)])
3950       AC_DEFINE_UNQUOTED(USE_WIN32_LARGE_FILES, 1,
3951         [Define to 1 if you are building a Windows target with large file support.])
3952       ;;
3953     win32_small_files)
3954       AC_MSG_RESULT([yes (large file disabled)])
3955       AC_DEFINE_UNQUOTED(USE_WIN32_LARGE_FILES, 1,
3956         [Define to 1 if you are building a Windows target without large file support.])
3957       ;;
3958     *)
3959       AC_MSG_RESULT([no])
3960       ;;
3961   esac
3962 ])