luna - curl/m4/curl-functions.m4

   1#***************************************************************************
   2#                                  _   _ ____  _
   3#  Project                     ___| | | |  _ \| |
   4#                             / __| | | | |_) | |
   5#                            | (__| |_| |  _ <| |___
   6#                             \___|\___/|_| \_\_____|
   7#
   8# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9#
  10# This software is licensed as described in the file COPYING, which
  11# you should have received as part of this distribution. The terms
  12# are also available at https://curl.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# SPDX-License-Identifier: curl
  22#
  23#***************************************************************************
  24
  25dnl File version for 'aclocal' use. Keep it a single number.
  26dnl serial 73
  27
  28dnl CURL_INCLUDES_ARPA_INET
  29dnl -------------------------------------------------
  30dnl Set up variable with list of headers that must be
  31dnl included when arpa/inet.h is to be included.
  32
  33AC_DEFUN([CURL_INCLUDES_ARPA_INET], [
  34curl_includes_arpa_inet="\
  35/* includes start */
  36#ifdef HAVE_SYS_TYPES_H
  37#  include <sys/types.h>
  38#endif
  39#ifdef HAVE_NETINET_IN_H
  40#  include <netinet/in.h>
  41#endif
  42#ifdef HAVE_ARPA_INET_H
  43#  include <arpa/inet.h>
  44#endif
  45#ifdef _WIN32
  46#include <winsock2.h>
  47#include <ws2tcpip.h>
  48#else
  49#include <sys/socket.h>
  50#endif
  51/* includes end */"
  52  AC_CHECK_HEADERS(
  53    sys/types.h netinet/in.h arpa/inet.h,
  54    [], [], [$curl_includes_arpa_inet])
  55])
  56
  57
  58dnl CURL_INCLUDES_FCNTL
  59dnl -------------------------------------------------
  60dnl Set up variable with list of headers that must be
  61dnl included when fcntl.h is to be included.
  62
  63AC_DEFUN([CURL_INCLUDES_FCNTL], [
  64curl_includes_fcntl="\
  65/* includes start */
  66#ifdef HAVE_SYS_TYPES_H
  67#  include <sys/types.h>
  68#endif
  69#ifdef HAVE_UNISTD_H
  70#  include <unistd.h>
  71#endif
  72#ifdef HAVE_FCNTL_H
  73#  include <fcntl.h>
  74#endif
  75/* includes end */"
  76  AC_CHECK_HEADERS(
  77    sys/types.h unistd.h fcntl.h,
  78    [], [], [$curl_includes_fcntl])
  79])
  80
  81
  82dnl CURL_INCLUDES_IFADDRS
  83dnl -------------------------------------------------
  84dnl Set up variable with list of headers that must be
  85dnl included when ifaddrs.h is to be included.
  86
  87AC_DEFUN([CURL_INCLUDES_IFADDRS], [
  88curl_includes_ifaddrs="\
  89/* includes start */
  90#ifdef HAVE_SYS_TYPES_H
  91#  include <sys/types.h>
  92#endif
  93#ifndef _WIN32
  94#  include <sys/socket.h>
  95#endif
  96#ifdef HAVE_NETINET_IN_H
  97#  include <netinet/in.h>
  98#endif
  99#ifdef HAVE_IFADDRS_H
 100#  include <ifaddrs.h>
 101#endif
 102/* includes end */"
 103  AC_CHECK_HEADERS(
 104    sys/types.h netinet/in.h ifaddrs.h,
 105    [], [], [$curl_includes_ifaddrs])
 106])
 107
 108
 109dnl CURL_INCLUDES_LIBGEN
 110dnl -------------------------------------------------
 111dnl Set up variable with list of headers that must be
 112dnl included when libgen.h is to be included.
 113
 114AC_DEFUN([CURL_INCLUDES_LIBGEN], [
 115curl_includes_libgen="\
 116/* includes start */
 117#ifdef HAVE_SYS_TYPES_H
 118#  include <sys/types.h>
 119#endif
 120#ifdef HAVE_LIBGEN_H
 121#  include <libgen.h>
 122#endif
 123/* includes end */"
 124  AC_CHECK_HEADERS(
 125    sys/types.h libgen.h,
 126    [], [], [$curl_includes_libgen])
 127])
 128
 129
 130dnl CURL_INCLUDES_NETDB
 131dnl -------------------------------------------------
 132dnl Set up variable with list of headers that must be
 133dnl included when netdb.h is to be included.
 134
 135AC_DEFUN([CURL_INCLUDES_NETDB], [
 136curl_includes_netdb="\
 137/* includes start */
 138#ifdef HAVE_SYS_TYPES_H
 139#  include <sys/types.h>
 140#endif
 141#ifdef HAVE_NETDB_H
 142#  include <netdb.h>
 143#endif
 144/* includes end */"
 145  AC_CHECK_HEADERS(
 146    sys/types.h netdb.h,
 147    [], [], [$curl_includes_netdb])
 148])
 149
 150
 151dnl CURL_INCLUDES_SETJMP
 152dnl -------------------------------------------------
 153dnl Set up variable with list of headers that must be
 154dnl included when setjmp.h is to be included.
 155
 156AC_DEFUN([CURL_INCLUDES_SETJMP], [
 157curl_includes_setjmp="\
 158/* includes start */
 159#ifdef HAVE_SYS_TYPES_H
 160#  include <sys/types.h>
 161#endif
 162#include <setjmp.h>
 163/* includes end */"
 164  AC_CHECK_HEADERS(
 165    sys/types.h,
 166    [], [], [$curl_includes_setjmp])
 167])
 168
 169
 170dnl CURL_INCLUDES_SIGNAL
 171dnl -------------------------------------------------
 172dnl Set up variable with list of headers that must be
 173dnl included when signal.h is to be included.
 174
 175AC_DEFUN([CURL_INCLUDES_SIGNAL], [
 176curl_includes_signal="\
 177/* includes start */
 178#ifdef HAVE_SYS_TYPES_H
 179#  include <sys/types.h>
 180#endif
 181#include <signal.h>
 182/* includes end */"
 183  AC_CHECK_HEADERS(
 184    sys/types.h,
 185    [], [], [$curl_includes_signal])
 186])
 187
 188
 189dnl CURL_INCLUDES_STDLIB
 190dnl -------------------------------------------------
 191dnl Set up variable with list of headers that must be
 192dnl included when stdlib.h is to be included.
 193
 194AC_DEFUN([CURL_INCLUDES_STDLIB], [
 195curl_includes_stdlib="\
 196/* includes start */
 197#ifdef HAVE_SYS_TYPES_H
 198#  include <sys/types.h>
 199#endif
 200#include <stdlib.h>
 201/* includes end */"
 202  AC_CHECK_HEADERS(
 203    sys/types.h,
 204    [], [], [$curl_includes_stdlib])
 205])
 206
 207
 208dnl CURL_INCLUDES_STRING
 209dnl -------------------------------------------------
 210dnl Set up variable with list of headers that must be
 211dnl included when string(s).h is to be included.
 212
 213AC_DEFUN([CURL_INCLUDES_STRING], [
 214curl_includes_string="\
 215/* includes start */
 216#ifdef HAVE_SYS_TYPES_H
 217#  include <sys/types.h>
 218#endif
 219#include <string.h>
 220#ifdef HAVE_STRINGS_H
 221#  include <strings.h>
 222#endif
 223/* includes end */"
 224  AC_CHECK_HEADERS(
 225    sys/types.h strings.h,
 226    [], [], [$curl_includes_string])
 227])
 228
 229
 230dnl CURL_INCLUDES_STROPTS
 231dnl -------------------------------------------------
 232dnl Set up variable with list of headers that must be
 233dnl included when stropts.h is to be included.
 234
 235AC_DEFUN([CURL_INCLUDES_STROPTS], [
 236curl_includes_stropts="\
 237/* includes start */
 238#ifdef HAVE_SYS_TYPES_H
 239#  include <sys/types.h>
 240#endif
 241#ifdef HAVE_UNISTD_H
 242#  include <unistd.h>
 243#endif
 244#ifndef _WIN32
 245#  include <sys/socket.h>
 246#endif
 247#ifdef HAVE_SYS_IOCTL_H
 248#  include <sys/ioctl.h>
 249#endif
 250#ifdef HAVE_STROPTS_H
 251#  include <stropts.h>
 252#endif
 253/* includes end */"
 254  AC_CHECK_HEADERS(
 255    sys/types.h unistd.h sys/ioctl.h stropts.h,
 256    [], [], [$curl_includes_stropts])
 257])
 258
 259
 260dnl CURL_INCLUDES_SYS_SOCKET
 261dnl -------------------------------------------------
 262dnl Set up variable with list of headers that must be
 263dnl included when sys/socket.h is to be included.
 264
 265AC_DEFUN([CURL_INCLUDES_SYS_SOCKET], [
 266curl_includes_sys_socket="\
 267/* includes start */
 268#ifdef HAVE_SYS_TYPES_H
 269#  include <sys/types.h>
 270#endif
 271#ifndef _WIN32
 272#  include <sys/socket.h>
 273#endif
 274/* includes end */"
 275  AC_CHECK_HEADERS(
 276    sys/types.h,
 277    [], [], [$curl_includes_sys_socket])
 278])
 279
 280
 281dnl CURL_INCLUDES_SYS_TYPES
 282dnl -------------------------------------------------
 283dnl Set up variable with list of headers that must be
 284dnl included when sys/types.h is to be included.
 285
 286AC_DEFUN([CURL_INCLUDES_SYS_TYPES], [
 287curl_includes_sys_types="\
 288/* includes start */
 289#ifdef HAVE_SYS_TYPES_H
 290#  include <sys/types.h>
 291#endif
 292/* includes end */"
 293  AC_CHECK_HEADERS(
 294    sys/types.h,
 295    [], [], [$curl_includes_sys_types])
 296])
 297
 298
 299dnl CURL_INCLUDES_SYS_XATTR
 300dnl -------------------------------------------------
 301dnl Set up variable with list of headers that must be
 302dnl included when sys/xattr.h is to be included.
 303
 304AC_DEFUN([CURL_INCLUDES_SYS_XATTR], [
 305curl_includes_sys_xattr="\
 306/* includes start */
 307#ifdef HAVE_SYS_TYPES_H
 308#  include <sys/types.h>
 309#endif
 310#ifdef HAVE_SYS_XATTR_H
 311#  include <sys/xattr.h>
 312#endif
 313/* includes end */"
 314  AC_CHECK_HEADERS(
 315    sys/types.h sys/xattr.h,
 316    [], [], [$curl_includes_sys_xattr])
 317])
 318
 319dnl CURL_INCLUDES_TIME
 320dnl -------------------------------------------------
 321dnl Set up variable with list of headers that must be
 322dnl included when time.h is to be included.
 323
 324AC_DEFUN([CURL_INCLUDES_TIME], [
 325curl_includes_time="\
 326/* includes start */
 327#ifdef HAVE_SYS_TYPES_H
 328#  include <sys/types.h>
 329#endif
 330#if !defined(_WIN32) || defined(__MINGW32__)
 331#  include <sys/time.h>
 332#endif
 333#include <time.h>
 334/* includes end */"
 335  AC_CHECK_HEADERS(
 336    sys/types.h,
 337    [], [], [$curl_includes_time])
 338])
 339
 340
 341dnl CURL_INCLUDES_UNISTD
 342dnl -------------------------------------------------
 343dnl Set up variable with list of headers that must be
 344dnl included when unistd.h is to be included.
 345
 346AC_DEFUN([CURL_INCLUDES_UNISTD], [
 347curl_includes_unistd="\
 348/* includes start */
 349#ifdef HAVE_SYS_TYPES_H
 350#  include <sys/types.h>
 351#endif
 352#ifdef HAVE_UNISTD_H
 353#  include <unistd.h>
 354#endif
 355/* includes end */"
 356  AC_CHECK_HEADERS(
 357    sys/types.h unistd.h,
 358    [], [], [$curl_includes_unistd])
 359])
 360
 361
 362dnl CURL_INCLUDES_WINSOCK2
 363dnl -------------------------------------------------
 364dnl Set up variable with list of headers that must be
 365dnl included when winsock2.h is to be included.
 366
 367AC_DEFUN([CURL_INCLUDES_WINSOCK2], [
 368curl_includes_winsock2="\
 369/* includes start */
 370#ifdef _WIN32
 371#  ifndef WIN32_LEAN_AND_MEAN
 372#  define WIN32_LEAN_AND_MEAN
 373#  endif
 374#  include <winsock2.h>
 375#endif
 376/* includes end */"
 377  CURL_CHECK_NATIVE_WINDOWS
 378])
 379
 380
 381dnl CURL_INCLUDES_WS2TCPIP
 382dnl -------------------------------------------------
 383dnl Set up variable with list of headers that must be
 384dnl included when ws2tcpip.h is to be included.
 385
 386AC_DEFUN([CURL_INCLUDES_WS2TCPIP], [
 387curl_includes_ws2tcpip="\
 388/* includes start */
 389#ifdef _WIN32
 390#  ifndef WIN32_LEAN_AND_MEAN
 391#  define WIN32_LEAN_AND_MEAN
 392#  endif
 393#  include <winsock2.h>
 394#  include <ws2tcpip.h>
 395#endif
 396/* includes end */"
 397  CURL_CHECK_NATIVE_WINDOWS
 398])
 399
 400
 401dnl CURL_INCLUDES_BSDSOCKET
 402dnl -------------------------------------------------
 403dnl Set up variable with list of headers that must be
 404dnl included when bsdsocket.h is to be included.
 405
 406AC_DEFUN([CURL_INCLUDES_BSDSOCKET], [
 407curl_includes_bsdsocket="\
 408/* includes start */
 409#ifdef HAVE_PROTO_BSDSOCKET_H
 410#  define __NO_NET_API
 411#  define __USE_INLINE__
 412#  include <proto/bsdsocket.h>
 413#  ifdef HAVE_SYS_IOCTL_H
 414#    include <sys/ioctl.h>
 415#  endif
 416#  ifdef __amigaos4__
 417struct SocketIFace *ISocket = NULL;
 418#  else
 419struct Library *SocketBase = NULL;
 420#  endif
 421#  define select(a, b, c, d, e)  WaitSelect(a, b, c, d, e, 0)
 422#endif
 423/* includes end */"
 424  AC_CHECK_HEADERS(
 425    proto/bsdsocket.h,
 426    [], [], [$curl_includes_bsdsocket])
 427])
 428
 429dnl CURL_INCLUDES_NETIF
 430dnl -------------------------------------------------
 431dnl Set up variable with list of headers that must be
 432dnl included when net/if.h is to be included.
 433
 434AC_DEFUN([CURL_INCLUDES_NETIF], [
 435curl_includes_netif="\
 436/* includes start */
 437#ifdef HAVE_NET_IF_H
 438#  include <net/if.h>
 439#endif
 440/* includes end */"
 441  AC_CHECK_HEADERS(
 442    net/if.h,
 443    [], [], [$curl_includes_netif])
 444])
 445
 446
 447dnl CURL_PREPROCESS_CALLCONV
 448dnl -------------------------------------------------
 449dnl Set up variable with a preprocessor block which
 450dnl defines function calling convention.
 451
 452AC_DEFUN([CURL_PREPROCESS_CALLCONV], [
 453curl_preprocess_callconv="\
 454/* preprocess start */
 455#ifdef _WIN32
 456#  define FUNCALLCONV __stdcall
 457#else
 458#  define FUNCALLCONV
 459#endif
 460/* preprocess end */"
 461])
 462
 463
 464dnl CURL_CHECK_FUNC_ALARM
 465dnl -------------------------------------------------
 466dnl Verify if alarm is available, prototyped, and
 467dnl can be compiled. If all of these are true, and
 468dnl usage has not been previously disallowed with
 469dnl shell variable curl_disallow_alarm, then
 470dnl HAVE_ALARM is defined.
 471
 472AC_DEFUN([CURL_CHECK_FUNC_ALARM], [
 473  AC_REQUIRE([CURL_INCLUDES_UNISTD])
 474
 475  tst_links_alarm="unknown"
 476  tst_proto_alarm="unknown"
 477  tst_compi_alarm="unknown"
 478  tst_allow_alarm="unknown"
 479
 480  AC_MSG_CHECKING([if alarm can be linked])
 481  AC_LINK_IFELSE([
 482    AC_LANG_FUNC_LINK_TRY([alarm])
 483  ],[
 484    AC_MSG_RESULT([yes])
 485    tst_links_alarm="yes"
 486  ],[
 487    AC_MSG_RESULT([no])
 488    tst_links_alarm="no"
 489  ])
 490
 491  if test "$tst_links_alarm" = "yes"; then
 492    AC_MSG_CHECKING([if alarm is prototyped])
 493    AC_EGREP_CPP([alarm],[
 494      $curl_includes_unistd
 495    ],[
 496      AC_MSG_RESULT([yes])
 497      tst_proto_alarm="yes"
 498    ],[
 499      AC_MSG_RESULT([no])
 500      tst_proto_alarm="no"
 501    ])
 502  fi
 503
 504  if test "$tst_proto_alarm" = "yes"; then
 505    AC_MSG_CHECKING([if alarm is compilable])
 506    AC_COMPILE_IFELSE([
 507      AC_LANG_PROGRAM([[
 508        $curl_includes_unistd
 509      ]],[[
 510        if(alarm(0) != 0)
 511          return 1;
 512      ]])
 513    ],[
 514      AC_MSG_RESULT([yes])
 515      tst_compi_alarm="yes"
 516    ],[
 517      AC_MSG_RESULT([no])
 518      tst_compi_alarm="no"
 519    ])
 520  fi
 521
 522  if test "$tst_compi_alarm" = "yes"; then
 523    AC_MSG_CHECKING([if alarm usage allowed])
 524    if test "x$curl_disallow_alarm" != "xyes"; then
 525      AC_MSG_RESULT([yes])
 526      tst_allow_alarm="yes"
 527    else
 528      AC_MSG_RESULT([no])
 529      tst_allow_alarm="no"
 530    fi
 531  fi
 532
 533  AC_MSG_CHECKING([if alarm might be used])
 534  if test "$tst_links_alarm" = "yes" &&
 535     test "$tst_proto_alarm" = "yes" &&
 536     test "$tst_compi_alarm" = "yes" &&
 537     test "$tst_allow_alarm" = "yes"; then
 538    AC_MSG_RESULT([yes])
 539    AC_DEFINE_UNQUOTED(HAVE_ALARM, 1,
 540      [Define to 1 if you have the alarm function.])
 541    curl_cv_func_alarm="yes"
 542  else
 543    AC_MSG_RESULT([no])
 544    curl_cv_func_alarm="no"
 545  fi
 546])
 547
 548
 549dnl CURL_CHECK_FUNC_BASENAME
 550dnl -------------------------------------------------
 551dnl Verify if basename is available, prototyped, and
 552dnl can be compiled. If all of these are true, and
 553dnl usage has not been previously disallowed with
 554dnl shell variable curl_disallow_basename, then
 555dnl HAVE_BASENAME is defined.
 556
 557AC_DEFUN([CURL_CHECK_FUNC_BASENAME], [
 558  AC_REQUIRE([CURL_INCLUDES_STRING])
 559  AC_REQUIRE([CURL_INCLUDES_LIBGEN])
 560  AC_REQUIRE([CURL_INCLUDES_UNISTD])
 561
 562  tst_links_basename="unknown"
 563  tst_proto_basename="unknown"
 564  tst_compi_basename="unknown"
 565  tst_allow_basename="unknown"
 566
 567  AC_MSG_CHECKING([if basename can be linked])
 568  AC_LINK_IFELSE([
 569    AC_LANG_FUNC_LINK_TRY([basename])
 570  ],[
 571    AC_MSG_RESULT([yes])
 572    tst_links_basename="yes"
 573  ],[
 574    AC_MSG_RESULT([no])
 575    tst_links_basename="no"
 576  ])
 577
 578  if test "$tst_links_basename" = "yes"; then
 579    AC_MSG_CHECKING([if basename is prototyped])
 580    AC_EGREP_CPP([basename],[
 581      $curl_includes_string
 582      $curl_includes_libgen
 583      $curl_includes_unistd
 584    ],[
 585      AC_MSG_RESULT([yes])
 586      tst_proto_basename="yes"
 587    ],[
 588      AC_MSG_RESULT([no])
 589      tst_proto_basename="no"
 590    ])
 591  fi
 592
 593  if test "$tst_proto_basename" = "yes"; then
 594    AC_MSG_CHECKING([if basename is compilable])
 595    AC_COMPILE_IFELSE([
 596      AC_LANG_PROGRAM([[
 597        $curl_includes_string
 598        $curl_includes_libgen
 599        $curl_includes_unistd
 600      ]],[[
 601        if(basename(0) != 0)
 602          return 1;
 603      ]])
 604    ],[
 605      AC_MSG_RESULT([yes])
 606      tst_compi_basename="yes"
 607    ],[
 608      AC_MSG_RESULT([no])
 609      tst_compi_basename="no"
 610    ])
 611  fi
 612
 613  if test "$tst_compi_basename" = "yes"; then
 614    AC_MSG_CHECKING([if basename usage allowed])
 615    if test "x$curl_disallow_basename" != "xyes"; then
 616      AC_MSG_RESULT([yes])
 617      tst_allow_basename="yes"
 618    else
 619      AC_MSG_RESULT([no])
 620      tst_allow_basename="no"
 621    fi
 622  fi
 623
 624  AC_MSG_CHECKING([if basename might be used])
 625  if test "$tst_links_basename" = "yes" &&
 626     test "$tst_proto_basename" = "yes" &&
 627     test "$tst_compi_basename" = "yes" &&
 628     test "$tst_allow_basename" = "yes"; then
 629    AC_MSG_RESULT([yes])
 630    AC_DEFINE_UNQUOTED(HAVE_BASENAME, 1,
 631      [Define to 1 if you have the basename function.])
 632    curl_cv_func_basename="yes"
 633  else
 634    AC_MSG_RESULT([no])
 635    curl_cv_func_basename="no"
 636  fi
 637])
 638
 639
 640dnl CURL_CHECK_FUNC_CLOSESOCKET
 641dnl -------------------------------------------------
 642dnl Verify if closesocket is available, prototyped, and
 643dnl can be compiled. If all of these are true, and
 644dnl usage has not been previously disallowed with
 645dnl shell variable curl_disallow_closesocket, then
 646dnl HAVE_CLOSESOCKET is defined.
 647
 648AC_DEFUN([CURL_CHECK_FUNC_CLOSESOCKET], [
 649  AC_REQUIRE([CURL_INCLUDES_WINSOCK2])
 650
 651  tst_links_closesocket="unknown"
 652  tst_proto_closesocket="unknown"
 653  tst_compi_closesocket="unknown"
 654  tst_allow_closesocket="unknown"
 655
 656  AC_MSG_CHECKING([if closesocket can be linked])
 657  AC_LINK_IFELSE([
 658    AC_LANG_PROGRAM([[
 659      $curl_includes_winsock2
 660    ]],[[
 661      if(closesocket(0) != 0)
 662        return 1;
 663    ]])
 664  ],[
 665    AC_MSG_RESULT([yes])
 666    tst_links_closesocket="yes"
 667  ],[
 668    AC_MSG_RESULT([no])
 669    tst_links_closesocket="no"
 670  ])
 671
 672  if test "$tst_links_closesocket" = "yes"; then
 673    AC_MSG_CHECKING([if closesocket is prototyped])
 674    AC_EGREP_CPP([closesocket],[
 675      $curl_includes_winsock2
 676    ],[
 677      AC_MSG_RESULT([yes])
 678      tst_proto_closesocket="yes"
 679    ],[
 680      AC_MSG_RESULT([no])
 681      tst_proto_closesocket="no"
 682    ])
 683  fi
 684
 685  if test "$tst_proto_closesocket" = "yes"; then
 686    AC_MSG_CHECKING([if closesocket is compilable])
 687    AC_COMPILE_IFELSE([
 688      AC_LANG_PROGRAM([[
 689        $curl_includes_winsock2
 690      ]],[[
 691        if(closesocket(0) != 0)
 692          return 1;
 693      ]])
 694    ],[
 695      AC_MSG_RESULT([yes])
 696      tst_compi_closesocket="yes"
 697    ],[
 698      AC_MSG_RESULT([no])
 699      tst_compi_closesocket="no"
 700    ])
 701  fi
 702
 703  if test "$tst_compi_closesocket" = "yes"; then
 704    AC_MSG_CHECKING([if closesocket usage allowed])
 705    if test "x$curl_disallow_closesocket" != "xyes"; then
 706      AC_MSG_RESULT([yes])
 707      tst_allow_closesocket="yes"
 708    else
 709      AC_MSG_RESULT([no])
 710      tst_allow_closesocket="no"
 711    fi
 712  fi
 713
 714  AC_MSG_CHECKING([if closesocket might be used])
 715  if test "$tst_links_closesocket" = "yes" &&
 716     test "$tst_proto_closesocket" = "yes" &&
 717     test "$tst_compi_closesocket" = "yes" &&
 718     test "$tst_allow_closesocket" = "yes"; then
 719    AC_MSG_RESULT([yes])
 720    AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET, 1,
 721      [Define to 1 if you have the closesocket function.])
 722    curl_cv_func_closesocket="yes"
 723  else
 724    AC_MSG_RESULT([no])
 725    curl_cv_func_closesocket="no"
 726  fi
 727])
 728
 729
 730dnl CURL_CHECK_FUNC_CLOSESOCKET_CAMEL
 731dnl -------------------------------------------------
 732dnl Verify if CloseSocket is available, prototyped, and
 733dnl can be compiled. If all of these are true, and
 734dnl usage has not been previously disallowed with
 735dnl shell variable curl_disallow_closesocket_camel,
 736dnl then HAVE_CLOSESOCKET_CAMEL is defined.
 737
 738AC_DEFUN([CURL_CHECK_FUNC_CLOSESOCKET_CAMEL], [
 739  AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])
 740  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])
 741
 742  tst_links_closesocket_camel="unknown"
 743  tst_compi_closesocket_camel="unknown"
 744  tst_allow_closesocket_camel="unknown"
 745
 746  AC_MSG_CHECKING([if CloseSocket can be linked])
 747  AC_LINK_IFELSE([
 748    AC_LANG_PROGRAM([[
 749      $curl_includes_bsdsocket
 750      $curl_includes_sys_socket
 751    ]],[[
 752      if(CloseSocket(0) != 0)
 753        return 1;
 754    ]])
 755  ],[
 756    AC_MSG_RESULT([yes])
 757    tst_links_closesocket_camel="yes"
 758  ],[
 759    AC_MSG_RESULT([no])
 760    tst_links_closesocket_camel="no"
 761  ])
 762
 763  if test "$tst_links_closesocket_camel" = "yes"; then
 764    AC_MSG_CHECKING([if CloseSocket is compilable])
 765    AC_COMPILE_IFELSE([
 766      AC_LANG_PROGRAM([[
 767        $curl_includes_bsdsocket
 768        $curl_includes_sys_socket
 769      ]],[[
 770        if(CloseSocket(0) != 0)
 771          return 1;
 772      ]])
 773    ],[
 774      AC_MSG_RESULT([yes])
 775      tst_compi_closesocket_camel="yes"
 776    ],[
 777      AC_MSG_RESULT([no])
 778      tst_compi_closesocket_camel="no"
 779    ])
 780  fi
 781
 782  if test "$tst_compi_closesocket_camel" = "yes"; then
 783    AC_MSG_CHECKING([if CloseSocket usage allowed])
 784    if test "x$curl_disallow_closesocket_camel" != "xyes"; then
 785      AC_MSG_RESULT([yes])
 786      tst_allow_closesocket_camel="yes"
 787    else
 788      AC_MSG_RESULT([no])
 789      tst_allow_closesocket_camel="no"
 790    fi
 791  fi
 792
 793  AC_MSG_CHECKING([if CloseSocket might be used])
 794  if test "$tst_links_closesocket_camel" = "yes" &&
 795     test "$tst_compi_closesocket_camel" = "yes" &&
 796     test "$tst_allow_closesocket_camel" = "yes"; then
 797    AC_MSG_RESULT([yes])
 798    AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET_CAMEL, 1,
 799      [Define to 1 if you have the CloseSocket camel case function.])
 800    curl_cv_func_closesocket_camel="yes"
 801  else
 802    AC_MSG_RESULT([no])
 803    curl_cv_func_closesocket_camel="no"
 804  fi
 805])
 806
 807dnl CURL_CHECK_FUNC_FCNTL
 808dnl -------------------------------------------------
 809dnl Verify if fcntl is available, prototyped, and
 810dnl can be compiled. If all of these are true, and
 811dnl usage has not been previously disallowed with
 812dnl shell variable curl_disallow_fcntl, then
 813dnl HAVE_FCNTL is defined.
 814
 815AC_DEFUN([CURL_CHECK_FUNC_FCNTL], [
 816  AC_REQUIRE([CURL_INCLUDES_FCNTL])
 817
 818  tst_links_fcntl="unknown"
 819  tst_proto_fcntl="unknown"
 820  tst_compi_fcntl="unknown"
 821  tst_allow_fcntl="unknown"
 822
 823  AC_MSG_CHECKING([if fcntl can be linked])
 824  AC_LINK_IFELSE([
 825    AC_LANG_FUNC_LINK_TRY([fcntl])
 826  ],[
 827    AC_MSG_RESULT([yes])
 828    tst_links_fcntl="yes"
 829  ],[
 830    AC_MSG_RESULT([no])
 831    tst_links_fcntl="no"
 832  ])
 833
 834  if test "$tst_links_fcntl" = "yes"; then
 835    AC_MSG_CHECKING([if fcntl is prototyped])
 836    AC_EGREP_CPP([fcntl],[
 837      $curl_includes_fcntl
 838    ],[
 839      AC_MSG_RESULT([yes])
 840      tst_proto_fcntl="yes"
 841    ],[
 842      AC_MSG_RESULT([no])
 843      tst_proto_fcntl="no"
 844    ])
 845  fi
 846
 847  if test "$tst_proto_fcntl" = "yes"; then
 848    AC_MSG_CHECKING([if fcntl is compilable])
 849    AC_COMPILE_IFELSE([
 850      AC_LANG_PROGRAM([[
 851        $curl_includes_fcntl
 852      ]],[[
 853        if(fcntl(0, 0, 0) != 0)
 854          return 1;
 855      ]])
 856    ],[
 857      AC_MSG_RESULT([yes])
 858      tst_compi_fcntl="yes"
 859    ],[
 860      AC_MSG_RESULT([no])
 861      tst_compi_fcntl="no"
 862    ])
 863  fi
 864
 865  if test "$tst_compi_fcntl" = "yes"; then
 866    AC_MSG_CHECKING([if fcntl usage allowed])
 867    if test "x$curl_disallow_fcntl" != "xyes"; then
 868      AC_MSG_RESULT([yes])
 869      tst_allow_fcntl="yes"
 870    else
 871      AC_MSG_RESULT([no])
 872      tst_allow_fcntl="no"
 873    fi
 874  fi
 875
 876  AC_MSG_CHECKING([if fcntl might be used])
 877  if test "$tst_links_fcntl" = "yes" &&
 878     test "$tst_proto_fcntl" = "yes" &&
 879     test "$tst_compi_fcntl" = "yes" &&
 880     test "$tst_allow_fcntl" = "yes"; then
 881    AC_MSG_RESULT([yes])
 882    AC_DEFINE_UNQUOTED(HAVE_FCNTL, 1,
 883      [Define to 1 if you have the fcntl function.])
 884    curl_cv_func_fcntl="yes"
 885    CURL_CHECK_FUNC_FCNTL_O_NONBLOCK
 886  else
 887    AC_MSG_RESULT([no])
 888    curl_cv_func_fcntl="no"
 889  fi
 890])
 891
 892
 893dnl CURL_CHECK_FUNC_FCNTL_O_NONBLOCK
 894dnl -------------------------------------------------
 895dnl Verify if fcntl with status flag O_NONBLOCK is
 896dnl available, can be compiled, and seems to work. If
 897dnl all of these are true, then HAVE_FCNTL_O_NONBLOCK
 898dnl is defined.
 899
 900AC_DEFUN([CURL_CHECK_FUNC_FCNTL_O_NONBLOCK], [
 901
 902  tst_compi_fcntl_o_nonblock="unknown"
 903  tst_allow_fcntl_o_nonblock="unknown"
 904
 905  case $host_os in
 906    sunos4* | aix3*)
 907      dnl O_NONBLOCK does not work on these platforms
 908      curl_disallow_fcntl_o_nonblock="yes"
 909      ;;
 910  esac
 911
 912  if test "$curl_cv_func_fcntl" = "yes"; then
 913    AC_MSG_CHECKING([if fcntl O_NONBLOCK is compilable])
 914    AC_COMPILE_IFELSE([
 915      AC_LANG_PROGRAM([[
 916        $curl_includes_fcntl
 917      ]],[[
 918        int flags = 0;
 919        if(fcntl(0, F_SETFL, flags | O_NONBLOCK) != 0)
 920          return 1;
 921      ]])
 922    ],[
 923      AC_MSG_RESULT([yes])
 924      tst_compi_fcntl_o_nonblock="yes"
 925    ],[
 926      AC_MSG_RESULT([no])
 927      tst_compi_fcntl_o_nonblock="no"
 928    ])
 929  fi
 930
 931  if test "$tst_compi_fcntl_o_nonblock" = "yes"; then
 932    AC_MSG_CHECKING([if fcntl O_NONBLOCK usage allowed])
 933    if test "x$curl_disallow_fcntl_o_nonblock" != "xyes"; then
 934      AC_MSG_RESULT([yes])
 935      tst_allow_fcntl_o_nonblock="yes"
 936    else
 937      AC_MSG_RESULT([no])
 938      tst_allow_fcntl_o_nonblock="no"
 939    fi
 940  fi
 941
 942  AC_MSG_CHECKING([if fcntl O_NONBLOCK might be used])
 943  if test "$tst_compi_fcntl_o_nonblock" = "yes" &&
 944     test "$tst_allow_fcntl_o_nonblock" = "yes"; then
 945    AC_MSG_RESULT([yes])
 946    AC_DEFINE_UNQUOTED(HAVE_FCNTL_O_NONBLOCK, 1,
 947      [Define to 1 if you have a working fcntl O_NONBLOCK function.])
 948    curl_cv_func_fcntl_o_nonblock="yes"
 949  else
 950    AC_MSG_RESULT([no])
 951    curl_cv_func_fcntl_o_nonblock="no"
 952  fi
 953])
 954
 955
 956dnl CURL_CHECK_FUNC_FREEADDRINFO
 957dnl -------------------------------------------------
 958dnl Verify if freeaddrinfo is available, prototyped,
 959dnl and can be compiled. If all of these are true,
 960dnl and usage has not been previously disallowed with
 961dnl shell variable curl_disallow_freeaddrinfo, then
 962dnl HAVE_FREEADDRINFO is defined.
 963
 964AC_DEFUN([CURL_CHECK_FUNC_FREEADDRINFO], [
 965  AC_REQUIRE([CURL_INCLUDES_WS2TCPIP])
 966  AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])
 967  AC_REQUIRE([CURL_INCLUDES_NETDB])
 968
 969  tst_links_freeaddrinfo="unknown"
 970  tst_proto_freeaddrinfo="unknown"
 971  tst_compi_freeaddrinfo="unknown"
 972  tst_allow_freeaddrinfo="unknown"
 973
 974  AC_MSG_CHECKING([if freeaddrinfo can be linked])
 975  AC_LINK_IFELSE([
 976    AC_LANG_PROGRAM([[
 977      $curl_includes_ws2tcpip
 978      $curl_includes_sys_socket
 979      $curl_includes_netdb
 980    ]],[[
 981      freeaddrinfo(0);
 982    ]])
 983  ],[
 984    AC_MSG_RESULT([yes])
 985    tst_links_freeaddrinfo="yes"
 986  ],[
 987    AC_MSG_RESULT([no])
 988    tst_links_freeaddrinfo="no"
 989  ])
 990
 991  if test "$tst_links_freeaddrinfo" = "yes"; then
 992    AC_MSG_CHECKING([if freeaddrinfo is prototyped])
 993    AC_EGREP_CPP([freeaddrinfo],[
 994      $curl_includes_ws2tcpip
 995      $curl_includes_sys_socket
 996      $curl_includes_netdb
 997    ],[
 998      AC_MSG_RESULT([yes])
 999      tst_proto_freeaddrinfo="yes"
1000    ],[
1001      AC_MSG_RESULT([no])
1002      tst_proto_freeaddrinfo="no"
1003    ])
1004  fi
1005
1006  if test "$tst_proto_freeaddrinfo" = "yes"; then
1007    AC_MSG_CHECKING([if freeaddrinfo is compilable])
1008    AC_COMPILE_IFELSE([
1009      AC_LANG_PROGRAM([[
1010        $curl_includes_ws2tcpip
1011        $curl_includes_sys_socket
1012        $curl_includes_netdb
1013      ]],[[
1014        freeaddrinfo(0);
1015      ]])
1016    ],[
1017      AC_MSG_RESULT([yes])
1018      tst_compi_freeaddrinfo="yes"
1019    ],[
1020      AC_MSG_RESULT([no])
1021      tst_compi_freeaddrinfo="no"
1022    ])
1023  fi
1024
1025  if test "$tst_compi_freeaddrinfo" = "yes"; then
1026    AC_MSG_CHECKING([if freeaddrinfo usage allowed])
1027    if test "x$curl_disallow_freeaddrinfo" != "xyes"; then
1028      AC_MSG_RESULT([yes])
1029      tst_allow_freeaddrinfo="yes"
1030    else
1031      AC_MSG_RESULT([no])
1032      tst_allow_freeaddrinfo="no"
1033    fi
1034  fi
1035
1036  AC_MSG_CHECKING([if freeaddrinfo might be used])
1037  if test "$tst_links_freeaddrinfo" = "yes" &&
1038     test "$tst_proto_freeaddrinfo" = "yes" &&
1039     test "$tst_compi_freeaddrinfo" = "yes" &&
1040     test "$tst_allow_freeaddrinfo" = "yes"; then
1041    AC_MSG_RESULT([yes])
1042    AC_DEFINE_UNQUOTED(HAVE_FREEADDRINFO, 1,
1043      [Define to 1 if you have the freeaddrinfo function.])
1044    curl_cv_func_freeaddrinfo="yes"
1045  else
1046    AC_MSG_RESULT([no])
1047    curl_cv_func_freeaddrinfo="no"
1048  fi
1049])
1050
1051
1052dnl CURL_CHECK_FUNC_FSETXATTR
1053dnl -------------------------------------------------
1054dnl Verify if fsetxattr is available, prototyped, and
1055dnl can be compiled. If all of these are true, and
1056dnl usage has not been previously disallowed with
1057dnl shell variable curl_disallow_fsetxattr, then
1058dnl HAVE_FSETXATTR is defined.
1059
1060AC_DEFUN([CURL_CHECK_FUNC_FSETXATTR], [
1061  AC_REQUIRE([CURL_INCLUDES_SYS_XATTR])
1062
1063  tst_links_fsetxattr="unknown"
1064  tst_proto_fsetxattr="unknown"
1065  tst_compi_fsetxattr="unknown"
1066  tst_allow_fsetxattr="unknown"
1067  tst_nargs_fsetxattr="unknown"
1068
1069  AC_MSG_CHECKING([if fsetxattr can be linked])
1070  AC_LINK_IFELSE([
1071    AC_LANG_FUNC_LINK_TRY([fsetxattr])
1072  ],[
1073    AC_MSG_RESULT([yes])
1074    tst_links_fsetxattr="yes"
1075  ],[
1076    AC_MSG_RESULT([no])
1077    tst_links_fsetxattr="no"
1078  ])
1079
1080  if test "$tst_links_fsetxattr" = "yes"; then
1081    AC_MSG_CHECKING([if fsetxattr is prototyped])
1082    AC_EGREP_CPP([fsetxattr],[
1083      $curl_includes_sys_xattr
1084    ],[
1085      AC_MSG_RESULT([yes])
1086      tst_proto_fsetxattr="yes"
1087    ],[
1088      AC_MSG_RESULT([no])
1089      tst_proto_fsetxattr="no"
1090    ])
1091  fi
1092
1093  if test "$tst_proto_fsetxattr" = "yes"; then
1094    if test "$tst_nargs_fsetxattr" = "unknown"; then
1095      AC_MSG_CHECKING([if fsetxattr takes 5 args.])
1096      AC_COMPILE_IFELSE([
1097        AC_LANG_PROGRAM([[
1098          $curl_includes_sys_xattr
1099        ]],[[
1100          if(fsetxattr(0, "", 0, 0, 0) != 0)
1101            return 1;
1102        ]])
1103      ],[
1104        AC_MSG_RESULT([yes])
1105        tst_compi_fsetxattr="yes"
1106        tst_nargs_fsetxattr="5"
1107      ],[
1108        AC_MSG_RESULT([no])
1109        tst_compi_fsetxattr="no"
1110      ])
1111    fi
1112    if test "$tst_nargs_fsetxattr" = "unknown"; then
1113      AC_MSG_CHECKING([if fsetxattr takes 6 args.])
1114      AC_COMPILE_IFELSE([
1115        AC_LANG_PROGRAM([[
1116          $curl_includes_sys_xattr
1117        ]],[[
1118          if(fsetxattr(0, 0, 0, 0, 0, 0) != 0)
1119            return 1;
1120        ]])
1121      ],[
1122        AC_MSG_RESULT([yes])
1123        tst_compi_fsetxattr="yes"
1124        tst_nargs_fsetxattr="6"
1125      ],[
1126        AC_MSG_RESULT([no])
1127        tst_compi_fsetxattr="no"
1128      ])
1129    fi
1130    AC_MSG_CHECKING([if fsetxattr is compilable])
1131    if test "$tst_compi_fsetxattr" = "yes"; then
1132      AC_MSG_RESULT([yes])
1133    else
1134      AC_MSG_RESULT([no])
1135    fi
1136  fi
1137
1138  if test "$tst_compi_fsetxattr" = "yes"; then
1139    AC_MSG_CHECKING([if fsetxattr usage allowed])
1140    if test "x$curl_disallow_fsetxattr" != "xyes"; then
1141      AC_MSG_RESULT([yes])
1142      tst_allow_fsetxattr="yes"
1143    else
1144      AC_MSG_RESULT([no])
1145      tst_allow_fsetxattr="no"
1146    fi
1147  fi
1148
1149  AC_MSG_CHECKING([if fsetxattr might be used])
1150  if test "$tst_links_fsetxattr" = "yes" &&
1151     test "$tst_proto_fsetxattr" = "yes" &&
1152     test "$tst_compi_fsetxattr" = "yes" &&
1153     test "$tst_allow_fsetxattr" = "yes"; then
1154    AC_MSG_RESULT([yes])
1155    AC_DEFINE_UNQUOTED(HAVE_FSETXATTR, 1,
1156      [Define to 1 if you have the fsetxattr function.])
1157    dnl AC_DEFINE_UNQUOTED(FSETXATTR_ARGS, $tst_nargs_fsetxattr,
1158    dnl   [Specifies the number of arguments to fsetxattr])
1159
1160    if test "$tst_nargs_fsetxattr" -eq "5"; then
1161      AC_DEFINE(HAVE_FSETXATTR_5, 1, [fsetxattr() takes 5 args])
1162    elif test "$tst_nargs_fsetxattr" -eq "6"; then
1163      AC_DEFINE(HAVE_FSETXATTR_6, 1, [fsetxattr() takes 6 args])
1164    fi
1165
1166    curl_cv_func_fsetxattr="yes"
1167  else
1168    AC_MSG_RESULT([no])
1169    curl_cv_func_fsetxattr="no"
1170  fi
1171])
1172
1173
1174dnl CURL_CHECK_FUNC_GETADDRINFO
1175dnl -------------------------------------------------
1176dnl Verify if getaddrinfo is available, prototyped, can
1177dnl be compiled and seems to work. If all of these are
1178dnl true, and usage has not been previously disallowed
1179dnl with shell variable curl_disallow_getaddrinfo, then
1180dnl HAVE_GETADDRINFO is defined. Additionally when
1181dnl HAVE_GETADDRINFO gets defined this also attempts
1182dnl to find out if getaddrinfo happens to be thread-safe,
1183dnl defining HAVE_GETADDRINFO_THREADSAFE when true.
1184
1185AC_DEFUN([CURL_CHECK_FUNC_GETADDRINFO], [
1186  AC_REQUIRE([CURL_INCLUDES_WS2TCPIP])
1187  AC_REQUIRE([CURL_INCLUDES_STDLIB])
1188  AC_REQUIRE([CURL_INCLUDES_STRING])
1189  AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])
1190  AC_REQUIRE([CURL_INCLUDES_NETDB])
1191  AC_REQUIRE([CURL_CHECK_NATIVE_WINDOWS])
1192
1193  tst_links_getaddrinfo="unknown"
1194  tst_proto_getaddrinfo="unknown"
1195  tst_compi_getaddrinfo="unknown"
1196  tst_works_getaddrinfo="unknown"
1197  tst_allow_getaddrinfo="unknown"
1198  tst_tsafe_getaddrinfo="unknown"
1199
1200  AC_MSG_CHECKING([if getaddrinfo can be linked])
1201  AC_LINK_IFELSE([
1202    AC_LANG_PROGRAM([[
1203      $curl_includes_ws2tcpip
1204      $curl_includes_sys_socket
1205      $curl_includes_netdb
1206    ]],[[
1207      struct addrinfo *ai = 0;
1208      if(getaddrinfo(0, 0, 0, &ai) != 0)
1209        return 1;
1210    ]])
1211  ],[
1212    AC_MSG_RESULT([yes])
1213    tst_links_getaddrinfo="yes"
1214  ],[
1215    AC_MSG_RESULT([no])
1216    tst_links_getaddrinfo="no"
1217  ])
1218
1219  if test "$tst_links_getaddrinfo" = "yes"; then
1220    AC_MSG_CHECKING([if getaddrinfo is prototyped])
1221    AC_EGREP_CPP([getaddrinfo],[
1222      $curl_includes_ws2tcpip
1223      $curl_includes_sys_socket
1224      $curl_includes_netdb
1225    ],[
1226      AC_MSG_RESULT([yes])
1227      tst_proto_getaddrinfo="yes"
1228    ],[
1229      AC_MSG_RESULT([no])
1230      tst_proto_getaddrinfo="no"
1231    ])
1232  fi
1233
1234  if test "$tst_proto_getaddrinfo" = "yes"; then
1235    AC_MSG_CHECKING([if getaddrinfo is compilable])
1236    AC_COMPILE_IFELSE([
1237      AC_LANG_PROGRAM([[
1238        $curl_includes_ws2tcpip
1239        $curl_includes_sys_socket
1240        $curl_includes_netdb
1241      ]],[[
1242        struct addrinfo *ai = 0;
1243        if(getaddrinfo(0, 0, 0, &ai) != 0)
1244          return 1;
1245      ]])
1246    ],[
1247      AC_MSG_RESULT([yes])
1248      tst_compi_getaddrinfo="yes"
1249    ],[
1250      AC_MSG_RESULT([no])
1251      tst_compi_getaddrinfo="no"
1252    ])
1253  fi
1254
1255  dnl only do runtime verification when not cross-compiling
1256  if test "$cross_compiling" != "yes" &&
1257    test "$tst_compi_getaddrinfo" = "yes"; then
1258    AC_MSG_CHECKING([if getaddrinfo seems to work])
1259    CURL_RUN_IFELSE([
1260      AC_LANG_PROGRAM([[
1261        $curl_includes_ws2tcpip
1262        $curl_includes_stdlib
1263        $curl_includes_string
1264        $curl_includes_sys_socket
1265        $curl_includes_netdb
1266      ]],[[
1267        struct addrinfo hints;
1268        struct addrinfo *ai = 0;
1269        int error;
1270        int exitcode;
1271
1272        #ifdef _WIN32
1273        WSADATA wsa;
1274        if(WSAStartup(MAKEWORD(2, 2), &wsa))
1275          return 2;
1276        #endif
1277
1278        memset(&hints, 0, sizeof(hints));
1279        hints.ai_flags = AI_NUMERICHOST;
1280        hints.ai_family = AF_UNSPEC;
1281        hints.ai_socktype = SOCK_STREAM;
1282        error = getaddrinfo("127.0.0.1", 0, &hints, &ai);
1283        if(error || !ai)
1284          exitcode = 1; /* fail */
1285        else {
1286          freeaddrinfo(ai);
1287          exitcode = 0;
1288        }
1289        #ifdef _WIN32
1290        WSACleanup();
1291        #endif
1292        return exitcode;
1293      ]])
1294    ],[
1295      AC_MSG_RESULT([yes])
1296      tst_works_getaddrinfo="yes"
1297    ],[
1298      AC_MSG_RESULT([no])
1299      tst_works_getaddrinfo="no"
1300    ])
1301  fi
1302
1303  if test "$tst_compi_getaddrinfo" = "yes" &&
1304    test "$tst_works_getaddrinfo" != "no"; then
1305    AC_MSG_CHECKING([if getaddrinfo usage allowed])
1306    if test "x$curl_disallow_getaddrinfo" != "xyes"; then
1307      AC_MSG_RESULT([yes])
1308      tst_allow_getaddrinfo="yes"
1309    else
1310      AC_MSG_RESULT([no])
1311      tst_allow_getaddrinfo="no"
1312    fi
1313  fi
1314
1315  AC_MSG_CHECKING([if getaddrinfo might be used])
1316  if test "$tst_proto_getaddrinfo" = "yes" &&
1317     test "$tst_compi_getaddrinfo" = "yes" &&
1318     test "$tst_allow_getaddrinfo" = "yes" &&
1319     test "$tst_works_getaddrinfo" != "no"; then
1320    AC_MSG_RESULT([yes])
1321    AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO, 1,
1322      [Define to 1 if you have a working getaddrinfo function.])
1323    curl_cv_func_getaddrinfo="yes"
1324  else
1325    AC_MSG_RESULT([no])
1326    curl_cv_func_getaddrinfo="no"
1327    curl_cv_func_getaddrinfo_threadsafe="no"
1328  fi
1329
1330  if test "$curl_cv_func_getaddrinfo" = "yes"; then
1331    AC_MSG_CHECKING([if getaddrinfo is thread-safe])
1332    if test "$curl_cv_apple" = "yes"; then
1333      dnl Darwin 6.0 and macOS 10.2.X and newer
1334      tst_tsafe_getaddrinfo="yes"
1335    fi
1336    case $host_os in
1337      aix[[1234]].* | aix5.[[01]].*)
1338        dnl AIX 5.1 and older
1339        tst_tsafe_getaddrinfo="no"
1340        ;;
1341      aix*)
1342        dnl AIX 5.2 and newer
1343        tst_tsafe_getaddrinfo="yes"
1344        ;;
1345      darwin[[12345]].*)
1346        dnl Darwin 5.0 and macOS 10.1.X and older
1347        tst_tsafe_getaddrinfo="no"
1348        ;;
1349      freebsd[[1234]].* | freebsd5.[[1234]]*)
1350        dnl FreeBSD 5.4 and older
1351        tst_tsafe_getaddrinfo="no"
1352        ;;
1353      freebsd*)
1354        dnl FreeBSD 5.5 and newer
1355        tst_tsafe_getaddrinfo="yes"
1356        ;;
1357      hpux[[123456789]].* | hpux10.* | hpux11.0* | hpux11.10*)
1358        dnl HP-UX 11.10 and older
1359        tst_tsafe_getaddrinfo="no"
1360        ;;
1361      hpux*)
1362        dnl HP-UX 11.11 and newer
1363        tst_tsafe_getaddrinfo="yes"
1364        ;;
1365      midnightbsd*)
1366        dnl all MidnightBSD versions
1367        tst_tsafe_getaddrinfo="yes"
1368        ;;
1369      netbsd[[123]].*)
1370        dnl NetBSD 3.X and older
1371        tst_tsafe_getaddrinfo="no"
1372        ;;
1373      netbsd*)
1374        dnl NetBSD 4.X and newer
1375        tst_tsafe_getaddrinfo="yes"
1376        ;;
1377      *bsd*)
1378        dnl All other BSD's
1379        tst_tsafe_getaddrinfo="no"
1380        ;;
1381      solaris2*)
1382        dnl Solaris which have it
1383        tst_tsafe_getaddrinfo="yes"
1384        ;;
1385    esac
1386    if test "$tst_tsafe_getaddrinfo" = "unknown" &&
1387       test "$curl_cv_native_windows" = "yes"; then
1388      tst_tsafe_getaddrinfo="yes"
1389    fi
1390    if test "$tst_tsafe_getaddrinfo" = "unknown"; then
1391      tst_tsafe_getaddrinfo="yes"
1392    fi
1393    AC_MSG_RESULT([$tst_tsafe_getaddrinfo])
1394    if test "$tst_tsafe_getaddrinfo" = "yes"; then
1395      AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO_THREADSAFE, 1,
1396        [Define to 1 if the getaddrinfo function is thread-safe.])
1397      curl_cv_func_getaddrinfo_threadsafe="yes"
1398    else
1399      curl_cv_func_getaddrinfo_threadsafe="no"
1400    fi
1401  fi
1402])
1403
1404
1405dnl CURL_CHECK_FUNC_GETHOSTBYNAME_R
1406dnl -------------------------------------------------
1407dnl Verify if gethostbyname_r is available, prototyped,
1408dnl and can be compiled. If all of these are true, and
1409dnl usage has not been previously disallowed with
1410dnl shell variable curl_disallow_gethostbyname_r, then
1411dnl HAVE_GETHOSTBYNAME_R is defined.
1412
1413AC_DEFUN([CURL_CHECK_FUNC_GETHOSTBYNAME_R], [
1414  AC_REQUIRE([CURL_INCLUDES_NETDB])
1415
1416  tst_links_gethostbyname_r="unknown"
1417  tst_proto_gethostbyname_r="unknown"
1418  tst_compi_gethostbyname_r="unknown"
1419  tst_allow_gethostbyname_r="unknown"
1420  tst_nargs_gethostbyname_r="unknown"
1421
1422  AC_MSG_CHECKING([if gethostbyname_r can be linked])
1423  AC_LINK_IFELSE([
1424    AC_LANG_FUNC_LINK_TRY([gethostbyname_r])
1425  ],[
1426    AC_MSG_RESULT([yes])
1427    tst_links_gethostbyname_r="yes"
1428  ],[
1429    AC_MSG_RESULT([no])
1430    tst_links_gethostbyname_r="no"
1431  ])
1432
1433  if test "$tst_links_gethostbyname_r" = "yes"; then
1434    AC_MSG_CHECKING([if gethostbyname_r is prototyped])
1435    AC_EGREP_CPP([gethostbyname_r],[
1436      $curl_includes_netdb
1437    ],[
1438      AC_MSG_RESULT([yes])
1439      tst_proto_gethostbyname_r="yes"
1440    ],[
1441      AC_MSG_RESULT([no])
1442      tst_proto_gethostbyname_r="no"
1443    ])
1444  fi
1445
1446  if test "$tst_proto_gethostbyname_r" = "yes"; then
1447    if test "$tst_nargs_gethostbyname_r" = "unknown"; then
1448      AC_MSG_CHECKING([if gethostbyname_r takes 3 args.])
1449      AC_COMPILE_IFELSE([
1450        AC_LANG_PROGRAM([[
1451          $curl_includes_netdb
1452          $curl_includes_bsdsocket
1453        ]],[[
1454          if(gethostbyname_r(0, 0, 0) != 0)
1455            return 1;
1456        ]])
1457      ],[
1458        AC_MSG_RESULT([yes])
1459        tst_compi_gethostbyname_r="yes"
1460        tst_nargs_gethostbyname_r="3"
1461      ],[
1462        AC_MSG_RESULT([no])
1463        tst_compi_gethostbyname_r="no"
1464      ])
1465    fi
1466    if test "$tst_nargs_gethostbyname_r" = "unknown"; then
1467      AC_MSG_CHECKING([if gethostbyname_r takes 5 args.])
1468      AC_COMPILE_IFELSE([
1469        AC_LANG_PROGRAM([[
1470          $curl_includes_netdb
1471          $curl_includes_bsdsocket
1472        ]],[[
1473          if(gethostbyname_r(0, 0, 0, 0, 0) != 0)
1474            return 1;
1475        ]])
1476      ],[
1477        AC_MSG_RESULT([yes])
1478        tst_compi_gethostbyname_r="yes"
1479        tst_nargs_gethostbyname_r="5"
1480      ],[
1481        AC_MSG_RESULT([no])
1482        tst_compi_gethostbyname_r="no"
1483      ])
1484    fi
1485    if test "$tst_nargs_gethostbyname_r" = "unknown"; then
1486      AC_MSG_CHECKING([if gethostbyname_r takes 6 args.])
1487      AC_COMPILE_IFELSE([
1488        AC_LANG_PROGRAM([[
1489          $curl_includes_netdb
1490          $curl_includes_bsdsocket
1491        ]],[[
1492          if(gethostbyname_r(0, 0, 0, 0, 0, 0) != 0)
1493            return 1;
1494        ]])
1495      ],[
1496        AC_MSG_RESULT([yes])
1497        tst_compi_gethostbyname_r="yes"
1498        tst_nargs_gethostbyname_r="6"
1499      ],[
1500        AC_MSG_RESULT([no])
1501        tst_compi_gethostbyname_r="no"
1502      ])
1503    fi
1504    AC_MSG_CHECKING([if gethostbyname_r is compilable])
1505    if test "$tst_compi_gethostbyname_r" = "yes"; then
1506      AC_MSG_RESULT([yes])
1507    else
1508      AC_MSG_RESULT([no])
1509    fi
1510  fi
1511
1512  if test "$tst_compi_gethostbyname_r" = "yes"; then
1513    AC_MSG_CHECKING([if gethostbyname_r usage allowed])
1514    if test "x$curl_disallow_gethostbyname_r" != "xyes"; then
1515      AC_MSG_RESULT([yes])
1516      tst_allow_gethostbyname_r="yes"
1517    else
1518      AC_MSG_RESULT([no])
1519      tst_allow_gethostbyname_r="no"
1520    fi
1521  fi
1522
1523  AC_MSG_CHECKING([if gethostbyname_r might be used])
1524  if test "$tst_links_gethostbyname_r" = "yes" &&
1525     test "$tst_proto_gethostbyname_r" = "yes" &&
1526     test "$tst_compi_gethostbyname_r" = "yes" &&
1527     test "$tst_allow_gethostbyname_r" = "yes"; then
1528    AC_MSG_RESULT([yes])
1529    AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYNAME_R, 1,
1530      [Define to 1 if you have the gethostbyname_r function.])
1531    dnl AC_DEFINE_UNQUOTED(GETHOSTBYNAME_R_ARGS, $tst_nargs_gethostbyname_r,
1532    dnl   [Specifies the number of arguments to gethostbyname_r])
1533
1534    if test "$tst_nargs_gethostbyname_r" -eq "3"; then
1535      AC_DEFINE(HAVE_GETHOSTBYNAME_R_3, 1, [gethostbyname_r() takes 3 args])
1536    elif test "$tst_nargs_gethostbyname_r" -eq "5"; then
1537      AC_DEFINE(HAVE_GETHOSTBYNAME_R_5, 1, [gethostbyname_r() takes 5 args])
1538    elif test "$tst_nargs_gethostbyname_r" -eq "6"; then
1539      AC_DEFINE(HAVE_GETHOSTBYNAME_R_6, 1, [gethostbyname_r() takes 6 args])
1540    fi
1541
1542    curl_cv_func_gethostbyname_r="yes"
1543  else
1544    AC_MSG_RESULT([no])
1545    curl_cv_func_gethostbyname_r="no"
1546  fi
1547])
1548
1549
1550dnl CURL_CHECK_FUNC_GETHOSTNAME
1551dnl -------------------------------------------------
1552dnl Verify if gethostname is available, prototyped, and
1553dnl can be compiled. If all of these are true, and
1554dnl usage has not been previously disallowed with
1555dnl shell variable curl_disallow_gethostname, then
1556dnl HAVE_GETHOSTNAME is defined.
1557
1558AC_DEFUN([CURL_CHECK_FUNC_GETHOSTNAME], [
1559  AC_REQUIRE([CURL_INCLUDES_WINSOCK2])
1560  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])
1561  AC_REQUIRE([CURL_INCLUDES_UNISTD])
1562  AC_REQUIRE([CURL_PREPROCESS_CALLCONV])
1563
1564  tst_links_gethostname="unknown"
1565  tst_proto_gethostname="unknown"
1566  tst_compi_gethostname="unknown"
1567  tst_allow_gethostname="unknown"
1568
1569  AC_MSG_CHECKING([if gethostname can be linked])
1570  AC_LINK_IFELSE([
1571    AC_LANG_PROGRAM([[
1572      $curl_includes_winsock2
1573      $curl_includes_unistd
1574      $curl_includes_bsdsocket
1575    ]],[[
1576      char s[1];
1577      if(gethostname((void *)s, 0) != 0)
1578        return 1;
1579    ]])
1580  ],[
1581    AC_MSG_RESULT([yes])
1582    tst_links_gethostname="yes"
1583  ],[
1584    AC_MSG_RESULT([no])
1585    tst_links_gethostname="no"
1586  ])
1587
1588  if test "$tst_links_gethostname" = "yes"; then
1589    AC_MSG_CHECKING([if gethostname is prototyped])
1590    AC_EGREP_CPP([gethostname],[
1591      $curl_includes_winsock2
1592      $curl_includes_unistd
1593      $curl_includes_bsdsocket
1594    ],[
1595      AC_MSG_RESULT([yes])
1596      tst_proto_gethostname="yes"
1597    ],[
1598      AC_MSG_RESULT([no])
1599      tst_proto_gethostname="no"
1600    ])
1601  fi
1602
1603  if test "$tst_proto_gethostname" = "yes"; then
1604    AC_MSG_CHECKING([if gethostname is compilable])
1605    AC_COMPILE_IFELSE([
1606      AC_LANG_PROGRAM([[
1607        $curl_includes_winsock2
1608        $curl_includes_unistd
1609        $curl_includes_bsdsocket
1610      ]],[[
1611        char s[1];
1612        if(gethostname((void *)s, 0) != 0)
1613          return 1;
1614      ]])
1615    ],[
1616      AC_MSG_RESULT([yes])
1617      tst_compi_gethostname="yes"
1618    ],[
1619      AC_MSG_RESULT([no])
1620      tst_compi_gethostname="no"
1621    ])
1622  fi
1623
1624  if test "$tst_compi_gethostname" = "yes"; then
1625    AC_MSG_CHECKING([for gethostname arg 2 data type])
1626    tst_gethostname_type_arg2="unknown"
1627    for tst_arg1 in 'char *' 'unsigned char *' 'void *'; do
1628      for tst_arg2 in 'int' 'unsigned int' 'size_t'; do
1629        if test "$tst_gethostname_type_arg2" = "unknown"; then
1630          AC_COMPILE_IFELSE([
1631            AC_LANG_PROGRAM([[
1632              $curl_includes_winsock2
1633              $curl_includes_unistd
1634              $curl_includes_bsdsocket
1635              $curl_preprocess_callconv
1636              #if defined(_WIN32) && defined(WINSOCK_API_LINKAGE)
1637              WINSOCK_API_LINKAGE
1638              #else
1639              extern
1640              #endif
1641              int FUNCALLCONV gethostname($tst_arg1, $tst_arg2);
1642            ]],[[
1643              char s[1];
1644              if(gethostname(($tst_arg1)s, 0) != 0)
1645                return 1;
1646            ]])
1647          ],[
1648            tst_gethostname_type_arg2="$tst_arg2"
1649          ])
1650        fi
1651      done
1652    done
1653    AC_MSG_RESULT([$tst_gethostname_type_arg2])
1654    if test "$tst_gethostname_type_arg2" != "unknown"; then
1655      AC_DEFINE_UNQUOTED(GETHOSTNAME_TYPE_ARG2, $tst_gethostname_type_arg2,
1656        [Define to the type of arg 2 for gethostname.])
1657    fi
1658  fi
1659
1660  if test "$tst_compi_gethostname" = "yes"; then
1661    AC_MSG_CHECKING([if gethostname usage allowed])
1662    if test "x$curl_disallow_gethostname" != "xyes"; then
1663      AC_MSG_RESULT([yes])
1664      tst_allow_gethostname="yes"
1665    else
1666      AC_MSG_RESULT([no])
1667      tst_allow_gethostname="no"
1668    fi
1669  fi
1670
1671  AC_MSG_CHECKING([if gethostname might be used])
1672  if test "$tst_links_gethostname" = "yes" &&
1673     test "$tst_proto_gethostname" = "yes" &&
1674     test "$tst_compi_gethostname" = "yes" &&
1675     test "$tst_allow_gethostname" = "yes"; then
1676    AC_MSG_RESULT([yes])
1677    AC_DEFINE_UNQUOTED(HAVE_GETHOSTNAME, 1,
1678      [Define to 1 if you have the gethostname function.])
1679    curl_cv_func_gethostname="yes"
1680  else
1681    AC_MSG_RESULT([no])
1682    curl_cv_func_gethostname="no"
1683  fi
1684])
1685
1686dnl CURL_CHECK_FUNC_GETPEERNAME
1687dnl -------------------------------------------------
1688dnl Verify if getpeername is available, prototyped, and
1689dnl can be compiled. If all of these are true, and
1690dnl usage has not been previously disallowed with
1691dnl shell variable curl_disallow_getpeername, then
1692dnl HAVE_GETPEERNAME is defined.
1693
1694AC_DEFUN([CURL_CHECK_FUNC_GETPEERNAME], [
1695  AC_REQUIRE([CURL_INCLUDES_WINSOCK2])
1696  AC_REQUIRE([CURL_INCLUDES_UNISTD])
1697  AC_REQUIRE([CURL_PREPROCESS_CALLCONV])
1698  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])
1699
1700  tst_links_getpeername="unknown"
1701  tst_proto_getpeername="unknown"
1702  tst_compi_getpeername="unknown"
1703  tst_allow_getpeername="unknown"
1704
1705  AC_MSG_CHECKING([if getpeername can be linked])
1706  AC_LINK_IFELSE([
1707    AC_LANG_PROGRAM([[
1708      $curl_includes_winsock2
1709      $curl_includes_bsdsocket
1710      $curl_includes_sys_socket
1711    ]],[[
1712      if(getpeername(0, (void *)0, (void *)0) != 0)
1713        return 1;
1714    ]])
1715  ],[
1716    AC_MSG_RESULT([yes])
1717    tst_links_getpeername="yes"
1718  ],[
1719    AC_MSG_RESULT([no])
1720    tst_links_getpeername="no"
1721  ])
1722
1723  if test "$tst_links_getpeername" = "yes"; then
1724    AC_MSG_CHECKING([if getpeername is prototyped])
1725    AC_EGREP_CPP([getpeername],[
1726      $curl_includes_winsock2
1727      $curl_includes_bsdsocket
1728      $curl_includes_sys_socket
1729    ],[
1730      AC_MSG_RESULT([yes])
1731      tst_proto_getpeername="yes"
1732    ],[
1733      AC_MSG_RESULT([no])
1734      tst_proto_getpeername="no"
1735    ])
1736  fi
1737
1738  if test "$tst_proto_getpeername" = "yes"; then
1739    AC_MSG_CHECKING([if getpeername is compilable])
1740    AC_COMPILE_IFELSE([
1741      AC_LANG_PROGRAM([[
1742        $curl_includes_winsock2
1743        $curl_includes_bsdsocket
1744        $curl_includes_sys_socket
1745      ]],[[
1746        if(getpeername(0, (void *)0, (void *)0) != 0)
1747          return 1;
1748      ]])
1749    ],[
1750      AC_MSG_RESULT([yes])
1751      tst_compi_getpeername="yes"
1752    ],[
1753      AC_MSG_RESULT([no])
1754      tst_compi_getpeername="no"
1755    ])
1756  fi
1757
1758  if test "$tst_compi_getpeername" = "yes"; then
1759    AC_MSG_CHECKING([if getpeername usage allowed])
1760    if test "x$curl_disallow_getpeername" != "xyes"; then
1761      AC_MSG_RESULT([yes])
1762      tst_allow_getpeername="yes"
1763    else
1764      AC_MSG_RESULT([no])
1765      tst_allow_getpeername="no"
1766    fi
1767  fi
1768
1769  AC_MSG_CHECKING([if getpeername might be used])
1770  if test "$tst_links_getpeername" = "yes" &&
1771     test "$tst_proto_getpeername" = "yes" &&
1772     test "$tst_compi_getpeername" = "yes" &&
1773     test "$tst_allow_getpeername" = "yes"; then
1774    AC_MSG_RESULT([yes])
1775    AC_DEFINE_UNQUOTED(HAVE_GETPEERNAME, 1,
1776      [Define to 1 if you have the getpeername function.])
1777    curl_cv_func_getpeername="yes"
1778  else
1779    AC_MSG_RESULT([no])
1780    curl_cv_func_getpeername="no"
1781  fi
1782])
1783
1784dnl CURL_CHECK_FUNC_GETSOCKNAME
1785dnl -------------------------------------------------
1786dnl Verify if getsockname is available, prototyped, and
1787dnl can be compiled. If all of these are true, and
1788dnl usage has not been previously disallowed with
1789dnl shell variable curl_disallow_getsockname, then
1790dnl HAVE_GETSOCKNAME is defined.
1791
1792AC_DEFUN([CURL_CHECK_FUNC_GETSOCKNAME], [
1793  AC_REQUIRE([CURL_INCLUDES_WINSOCK2])
1794  AC_REQUIRE([CURL_INCLUDES_UNISTD])
1795  AC_REQUIRE([CURL_PREPROCESS_CALLCONV])
1796  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])
1797
1798  tst_links_getsockname="unknown"
1799  tst_proto_getsockname="unknown"
1800  tst_compi_getsockname="unknown"
1801  tst_allow_getsockname="unknown"
1802
1803  AC_MSG_CHECKING([if getsockname can be linked])
1804  AC_LINK_IFELSE([
1805    AC_LANG_PROGRAM([[
1806      $curl_includes_winsock2
1807      $curl_includes_bsdsocket
1808      $curl_includes_sys_socket
1809    ]],[[
1810      if(getsockname(0, (void *)0, (void *)0) != 0)
1811        return 1;
1812    ]])
1813  ],[
1814    AC_MSG_RESULT([yes])
1815    tst_links_getsockname="yes"
1816  ],[
1817    AC_MSG_RESULT([no])
1818    tst_links_getsockname="no"
1819  ])
1820
1821  if test "$tst_links_getsockname" = "yes"; then
1822    AC_MSG_CHECKING([if getsockname is prototyped])
1823    AC_EGREP_CPP([getsockname],[
1824      $curl_includes_winsock2
1825      $curl_includes_bsdsocket
1826      $curl_includes_sys_socket
1827    ],[
1828      AC_MSG_RESULT([yes])
1829      tst_proto_getsockname="yes"
1830    ],[
1831      AC_MSG_RESULT([no])
1832      tst_proto_getsockname="no"
1833    ])
1834  fi
1835
1836  if test "$tst_proto_getsockname" = "yes"; then
1837    AC_MSG_CHECKING([if getsockname is compilable])
1838    AC_COMPILE_IFELSE([
1839      AC_LANG_PROGRAM([[
1840        $curl_includes_winsock2
1841        $curl_includes_bsdsocket
1842        $curl_includes_sys_socket
1843      ]],[[
1844        if(getsockname(0, (void *)0, (void *)0) != 0)
1845          return 1;
1846      ]])
1847    ],[
1848      AC_MSG_RESULT([yes])
1849      tst_compi_getsockname="yes"
1850    ],[
1851      AC_MSG_RESULT([no])
1852      tst_compi_getsockname="no"
1853    ])
1854  fi
1855
1856  if test "$tst_compi_getsockname" = "yes"; then
1857    AC_MSG_CHECKING([if getsockname usage allowed])
1858    if test "x$curl_disallow_getsockname" != "xyes"; then
1859      AC_MSG_RESULT([yes])
1860      tst_allow_getsockname="yes"
1861    else
1862      AC_MSG_RESULT([no])
1863      tst_allow_getsockname="no"
1864    fi
1865  fi
1866
1867  AC_MSG_CHECKING([if getsockname might be used])
1868  if test "$tst_links_getsockname" = "yes" &&
1869     test "$tst_proto_getsockname" = "yes" &&
1870     test "$tst_compi_getsockname" = "yes" &&
1871     test "$tst_allow_getsockname" = "yes"; then
1872    AC_MSG_RESULT([yes])
1873    AC_DEFINE_UNQUOTED(HAVE_GETSOCKNAME, 1,
1874      [Define to 1 if you have the getsockname function.])
1875    curl_cv_func_getsockname="yes"
1876  else
1877    AC_MSG_RESULT([no])
1878    curl_cv_func_getsockname="no"
1879  fi
1880])
1881
1882
1883dnl CURL_CHECK_FUNC_GETIFADDRS
1884dnl -------------------------------------------------
1885dnl Verify if getifaddrs is available, prototyped, can
1886dnl be compiled and seems to work. If all of these are
1887dnl true, and usage has not been previously disallowed
1888dnl with shell variable curl_disallow_getifaddrs, then
1889dnl HAVE_GETIFADDRS is defined.
1890
1891AC_DEFUN([CURL_CHECK_FUNC_GETIFADDRS], [
1892  AC_REQUIRE([CURL_INCLUDES_STDLIB])
1893  AC_REQUIRE([CURL_INCLUDES_IFADDRS])
1894
1895  tst_links_getifaddrs="unknown"
1896  tst_proto_getifaddrs="unknown"
1897  tst_compi_getifaddrs="unknown"
1898  tst_works_getifaddrs="unknown"
1899  tst_allow_getifaddrs="unknown"
1900
1901  AC_MSG_CHECKING([if getifaddrs can be linked])
1902  AC_LINK_IFELSE([
1903    AC_LANG_FUNC_LINK_TRY([getifaddrs])
1904  ],[
1905    AC_MSG_RESULT([yes])
1906    tst_links_getifaddrs="yes"
1907  ],[
1908    AC_MSG_RESULT([no])
1909    tst_links_getifaddrs="no"
1910  ])
1911
1912  if test "$tst_links_getifaddrs" = "yes"; then
1913    AC_MSG_CHECKING([if getifaddrs is prototyped])
1914    AC_EGREP_CPP([getifaddrs],[
1915      $curl_includes_ifaddrs
1916    ],[
1917      AC_MSG_RESULT([yes])
1918      tst_proto_getifaddrs="yes"
1919    ],[
1920      AC_MSG_RESULT([no])
1921      tst_proto_getifaddrs="no"
1922    ])
1923  fi
1924
1925  if test "$tst_proto_getifaddrs" = "yes"; then
1926    AC_MSG_CHECKING([if getifaddrs is compilable])
1927    AC_COMPILE_IFELSE([
1928      AC_LANG_PROGRAM([[
1929        $curl_includes_ifaddrs
1930      ]],[[
1931        if(getifaddrs(0) != 0)
1932          return 1;
1933      ]])
1934    ],[
1935      AC_MSG_RESULT([yes])
1936      tst_compi_getifaddrs="yes"
1937    ],[
1938      AC_MSG_RESULT([no])
1939      tst_compi_getifaddrs="no"
1940    ])
1941  fi
1942
1943  dnl only do runtime verification when not cross-compiling
1944  if test "$cross_compiling" != "yes" &&
1945    test "$tst_compi_getifaddrs" = "yes"; then
1946    AC_MSG_CHECKING([if getifaddrs seems to work])
1947    CURL_RUN_IFELSE([
1948      AC_LANG_PROGRAM([[
1949        $curl_includes_stdlib
1950        $curl_includes_ifaddrs
1951      ]],[[
1952        struct ifaddrs *ifa = 0;
1953        int error;
1954
1955        error = getifaddrs(&ifa);
1956        if(error || !ifa)
1957          return 1; /* fail */
1958        else {
1959          freeifaddrs(ifa);
1960          return 0;
1961        }
1962      ]])
1963    ],[
1964      AC_MSG_RESULT([yes])
1965      tst_works_getifaddrs="yes"
1966    ],[
1967      AC_MSG_RESULT([no])
1968      tst_works_getifaddrs="no"
1969    ])
1970  fi
1971
1972  if test "$tst_compi_getifaddrs" = "yes" &&
1973    test "$tst_works_getifaddrs" != "no"; then
1974    AC_MSG_CHECKING([if getifaddrs usage allowed])
1975    if test "x$curl_disallow_getifaddrs" != "xyes"; then
1976      AC_MSG_RESULT([yes])
1977      tst_allow_getifaddrs="yes"
1978    else
1979      AC_MSG_RESULT([no])
1980      tst_allow_getifaddrs="no"
1981    fi
1982  fi
1983
1984  AC_MSG_CHECKING([if getifaddrs might be used])
1985  if test "$tst_links_getifaddrs" = "yes" &&
1986     test "$tst_proto_getifaddrs" = "yes" &&
1987     test "$tst_compi_getifaddrs" = "yes" &&
1988     test "$tst_allow_getifaddrs" = "yes" &&
1989     test "$tst_works_getifaddrs" != "no"; then
1990    AC_MSG_RESULT([yes])
1991    AC_DEFINE_UNQUOTED(HAVE_GETIFADDRS, 1,
1992      [Define to 1 if you have a working getifaddrs function.])
1993    curl_cv_func_getifaddrs="yes"
1994  else
1995    AC_MSG_RESULT([no])
1996    curl_cv_func_getifaddrs="no"
1997  fi
1998])
1999
2000
2001dnl CURL_CHECK_FUNC_GMTIME_R
2002dnl -------------------------------------------------
2003dnl Verify if gmtime_r is available, prototyped, can
2004dnl be compiled and seems to work. If all of these are
2005dnl true, and usage has not been previously disallowed
2006dnl with shell variable curl_disallow_gmtime_r, then
2007dnl HAVE_GMTIME_R is defined.
2008
2009AC_DEFUN([CURL_CHECK_FUNC_GMTIME_R], [
2010  AC_REQUIRE([CURL_INCLUDES_STDLIB])
2011  AC_REQUIRE([CURL_INCLUDES_TIME])
2012
2013  tst_links_gmtime_r="unknown"
2014  tst_proto_gmtime_r="unknown"
2015  tst_compi_gmtime_r="unknown"
2016  tst_works_gmtime_r="unknown"
2017  tst_allow_gmtime_r="unknown"
2018
2019  AC_MSG_CHECKING([if gmtime_r can be linked])
2020  AC_LINK_IFELSE([
2021    AC_LANG_FUNC_LINK_TRY([gmtime_r])
2022  ],[
2023    AC_MSG_RESULT([yes])
2024    tst_links_gmtime_r="yes"
2025  ],[
2026    AC_MSG_RESULT([no])
2027    tst_links_gmtime_r="no"
2028  ])
2029
2030  if test "$tst_links_gmtime_r" = "yes"; then
2031    AC_MSG_CHECKING([if gmtime_r is prototyped])
2032    AC_EGREP_CPP([gmtime_r],[
2033      $curl_includes_time
2034    ],[
2035      AC_MSG_RESULT([yes])
2036      tst_proto_gmtime_r="yes"
2037    ],[
2038      AC_MSG_RESULT([no])
2039      tst_proto_gmtime_r="no"
2040    ])
2041  fi
2042
2043  if test "$tst_proto_gmtime_r" = "yes"; then
2044    AC_MSG_CHECKING([if gmtime_r is compilable])
2045    AC_COMPILE_IFELSE([
2046      AC_LANG_PROGRAM([[
2047        $curl_includes_time
2048      ]],[[
2049        time_t tm = 1170352587;
2050        struct tm result;
2051        if(gmtime_r(&tm, &result) == 0)
2052          return 1;
2053        (void)result;
2054      ]])
2055    ],[
2056      AC_MSG_RESULT([yes])
2057      tst_compi_gmtime_r="yes"
2058    ],[
2059      AC_MSG_RESULT([no])
2060      tst_compi_gmtime_r="no"
2061    ])
2062  fi
2063
2064  dnl only do runtime verification when not cross-compiling
2065  if test "$cross_compiling" != "yes" &&
2066    test "$tst_compi_gmtime_r" = "yes"; then
2067    AC_MSG_CHECKING([if gmtime_r seems to work])
2068    CURL_RUN_IFELSE([
2069      AC_LANG_PROGRAM([[
2070        $curl_includes_stdlib
2071        $curl_includes_time
2072      ]],[[
2073        time_t local = 1170352587;
2074        struct tm *gmt = 0;
2075        struct tm result;
2076        gmt = gmtime_r(&local, &result);
2077        (void)result;
2078        if(gmt)
2079          return 0;
2080        else
2081          return 1;
2082      ]])
2083    ],[
2084      AC_MSG_RESULT([yes])
2085      tst_works_gmtime_r="yes"
2086    ],[
2087      AC_MSG_RESULT([no])
2088      tst_works_gmtime_r="no"
2089    ])
2090  fi
2091
2092  if test "$tst_compi_gmtime_r" = "yes" &&
2093    test "$tst_works_gmtime_r" != "no"; then
2094    AC_MSG_CHECKING([if gmtime_r usage allowed])
2095    if test "x$curl_disallow_gmtime_r" != "xyes"; then
2096      AC_MSG_RESULT([yes])
2097      tst_allow_gmtime_r="yes"
2098    else
2099      AC_MSG_RESULT([no])
2100      tst_allow_gmtime_r="no"
2101    fi
2102  fi
2103
2104  AC_MSG_CHECKING([if gmtime_r might be used])
2105  if test "$tst_links_gmtime_r" = "yes" &&
2106     test "$tst_proto_gmtime_r" = "yes" &&
2107     test "$tst_compi_gmtime_r" = "yes" &&
2108     test "$tst_allow_gmtime_r" = "yes" &&
2109     test "$tst_works_gmtime_r" != "no"; then
2110    AC_MSG_RESULT([yes])
2111    AC_DEFINE_UNQUOTED(HAVE_GMTIME_R, 1,
2112      [Define to 1 if you have a working gmtime_r function.])
2113    curl_cv_func_gmtime_r="yes"
2114  else
2115    AC_MSG_RESULT([no])
2116    curl_cv_func_gmtime_r="no"
2117  fi
2118])
2119
2120
2121dnl CURL_CHECK_FUNC_LOCALTIME_R
2122dnl -------------------------------------------------
2123dnl Verify if localtime_r is available, prototyped, can
2124dnl be compiled and seems to work. If all of these are
2125dnl true, and usage has not been previously disallowed
2126dnl with shell variable curl_disallow_localtime_r, then
2127dnl HAVE_LOCALTIME_R is defined.
2128
2129AC_DEFUN([CURL_CHECK_FUNC_LOCALTIME_R], [
2130  AC_REQUIRE([CURL_INCLUDES_STDLIB])
2131  AC_REQUIRE([CURL_INCLUDES_TIME])
2132
2133  tst_links_localtime_r="unknown"
2134  tst_proto_localtime_r="unknown"
2135  tst_compi_localtime_r="unknown"
2136  tst_works_localtime_r="unknown"
2137  tst_allow_localtime_r="unknown"
2138
2139  AC_MSG_CHECKING([if localtime_r can be linked])
2140  AC_LINK_IFELSE([
2141    AC_LANG_FUNC_LINK_TRY([localtime_r])
2142  ],[
2143    AC_MSG_RESULT([yes])
2144    tst_links_localtime_r="yes"
2145  ],[
2146    AC_MSG_RESULT([no])
2147    tst_links_localtime_r="no"
2148  ])
2149
2150  if test "$tst_links_localtime_r" = "yes"; then
2151    AC_MSG_CHECKING([if localtime_r is prototyped])
2152    AC_EGREP_CPP([localtime_r],[
2153      $curl_includes_time
2154    ],[
2155      AC_MSG_RESULT([yes])
2156      tst_proto_localtime_r="yes"
2157    ],[
2158      AC_MSG_RESULT([no])
2159      tst_proto_localtime_r="no"
2160    ])
2161  fi
2162
2163  if test "$tst_proto_localtime_r" = "yes"; then
2164    AC_MSG_CHECKING([if localtime_r is compilable])
2165    AC_COMPILE_IFELSE([
2166      AC_LANG_PROGRAM([[
2167        $curl_includes_time
2168      ]],[[
2169        time_t clock = 1170352587;
2170        struct tm result;
2171        if(localtime_r(&clock, &result) != 0)
2172          return 1;
2173        (void)result;
2174      ]])
2175    ],[
2176      AC_MSG_RESULT([yes])
2177      tst_compi_localtime_r="yes"
2178    ],[
2179      AC_MSG_RESULT([no])
2180      tst_compi_localtime_r="no"
2181    ])
2182  fi
2183
2184  dnl only do runtime verification when not cross-compiling
2185  if test "$cross_compiling" != "yes" &&
2186    test "$tst_compi_localtime_r" = "yes"; then
2187    AC_MSG_CHECKING([if localtime_r seems to work])
2188    CURL_RUN_IFELSE([
2189      AC_LANG_PROGRAM([[
2190        $curl_includes_stdlib
2191        $curl_includes_time
2192      ]],[[
2193        time_t clock = 1170352587;
2194        struct tm *tmp = 0;
2195        struct tm result;
2196        tmp = localtime_r(&clock, &result);
2197        (void)result;
2198        if(tmp)
2199          return 0;
2200        else
2201          return 1;
2202      ]])
2203    ],[
2204      AC_MSG_RESULT([yes])
2205      tst_works_localtime_r="yes"
2206    ],[
2207      AC_MSG_RESULT([no])
2208      tst_works_localtime_r="no"
2209    ])
2210  fi
2211
2212  if test "$tst_compi_localtime_r" = "yes" &&
2213    test "$tst_works_localtime_r" != "no"; then
2214    AC_MSG_CHECKING([if localtime_r usage allowed])
2215    if test "x$curl_disallow_localtime_r" != "xyes"; then
2216      AC_MSG_RESULT([yes])
2217      tst_allow_localtime_r="yes"
2218    else
2219      AC_MSG_RESULT([no])
2220      tst_allow_localtime_r="no"
2221    fi
2222  fi
2223
2224  AC_MSG_CHECKING([if localtime_r might be used])
2225  if test "$tst_links_localtime_r" = "yes" &&
2226     test "$tst_proto_localtime_r" = "yes" &&
2227     test "$tst_compi_localtime_r" = "yes" &&
2228     test "$tst_allow_localtime_r" = "yes" &&
2229     test "$tst_works_localtime_r" != "no"; then
2230    AC_MSG_RESULT([yes])
2231    AC_DEFINE_UNQUOTED(HAVE_LOCALTIME_R, 1,
2232      [Define to 1 if you have a working localtime_r function.])
2233    curl_cv_func_localtime_r="yes"
2234  else
2235    AC_MSG_RESULT([no])
2236    curl_cv_func_localtime_r="no"
2237  fi
2238])
2239
2240
2241dnl CURL_CHECK_FUNC_INET_NTOP
2242dnl -------------------------------------------------
2243dnl Verify if inet_ntop is available, prototyped, can
2244dnl be compiled and seems to work. If all of these are
2245dnl true, and usage has not been previously disallowed
2246dnl with shell variable curl_disallow_inet_ntop, then
2247dnl HAVE_INET_NTOP is defined.
2248
2249AC_DEFUN([CURL_CHECK_FUNC_INET_NTOP], [
2250  AC_REQUIRE([CURL_INCLUDES_STDLIB])
2251  AC_REQUIRE([CURL_INCLUDES_ARPA_INET])
2252  AC_REQUIRE([CURL_INCLUDES_STRING])
2253
2254  tst_links_inet_ntop="unknown"
2255  tst_proto_inet_ntop="unknown"
2256  tst_compi_inet_ntop="unknown"
2257  tst_works_inet_ntop="unknown"
2258  tst_allow_inet_ntop="unknown"
2259
2260  AC_MSG_CHECKING([if inet_ntop can be linked])
2261  AC_LINK_IFELSE([
2262    AC_LANG_FUNC_LINK_TRY([inet_ntop])
2263  ],[
2264    AC_MSG_RESULT([yes])
2265    tst_links_inet_ntop="yes"
2266  ],[
2267    AC_MSG_RESULT([no])
2268    tst_links_inet_ntop="no"
2269  ])
2270
2271  if test "$tst_links_inet_ntop" = "yes"; then
2272    AC_MSG_CHECKING([if inet_ntop is prototyped])
2273    AC_EGREP_CPP([inet_ntop],[
2274      $curl_includes_arpa_inet
2275    ],[
2276      AC_MSG_RESULT([yes])
2277      tst_proto_inet_ntop="yes"
2278    ],[
2279      AC_MSG_RESULT([no])
2280      tst_proto_inet_ntop="no"
2281    ])
2282  fi
2283
2284  if test "$tst_proto_inet_ntop" = "yes"; then
2285    AC_MSG_CHECKING([if inet_ntop is compilable])
2286    AC_COMPILE_IFELSE([
2287      AC_LANG_PROGRAM([[
2288        $curl_includes_arpa_inet
2289      ]],[[
2290        char ipv4res[sizeof("255.255.255.255")];
2291        unsigned char ipv4a[5] = "";
2292        if(inet_ntop(0, ipv4a, ipv4res, 0) != 0)
2293          return 1;
2294      ]])
2295    ],[
2296      AC_MSG_RESULT([yes])
2297      tst_compi_inet_ntop="yes"
2298    ],[
2299      AC_MSG_RESULT([no])
2300      tst_compi_inet_ntop="no"
2301    ])
2302  fi
2303
2304  dnl only do runtime verification when not cross-compiling
2305  if test "$cross_compiling" != "yes" &&
2306    test "$tst_compi_inet_ntop" = "yes"; then
2307    AC_MSG_CHECKING([if inet_ntop seems to work])
2308    CURL_RUN_IFELSE([
2309      AC_LANG_PROGRAM([[
2310        $curl_includes_stdlib
2311        $curl_includes_arpa_inet
2312        $curl_includes_string
2313      ]],[[
2314        char ipv6res[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
2315        char ipv4res[sizeof("255.255.255.255")];
2316        unsigned char ipv6a[26];
2317        unsigned char ipv4a[5];
2318        const char *ipv6ptr = 0;
2319        const char *ipv4ptr = 0;
2320        /* - */
2321        ipv4res[0] = '\0';
2322        ipv4a[0] = 0xc0;
2323        ipv4a[1] = 0xa8;
2324        ipv4a[2] = 0x64;
2325        ipv4a[3] = 0x01;
2326        ipv4a[4] = 0x01;
2327        /* - */
2328        ipv4ptr = inet_ntop(AF_INET, ipv4a, ipv4res, sizeof(ipv4res));
2329        if(!ipv4ptr)
2330          return 1; /* fail */
2331        if(ipv4ptr != ipv4res)
2332          return 1; /* fail */
2333        if(!ipv4ptr[0])
2334          return 1; /* fail */
2335        if(memcmp(ipv4res, "192.168.100.1", 13) != 0)
2336          return 1; /* fail */
2337        /* - */
2338        ipv6res[0] = '\0';
2339        memset(ipv6a, 0, sizeof(ipv6a));
2340        ipv6a[0] = 0xfe;
2341        ipv6a[1] = 0x80;
2342        ipv6a[8] = 0x02;
2343        ipv6a[9] = 0x14;
2344        ipv6a[10] = 0x4f;
2345        ipv6a[11] = 0xff;
2346        ipv6a[12] = 0xfe;
2347        ipv6a[13] = 0x0b;
2348        ipv6a[14] = 0x76;
2349        ipv6a[15] = 0xc8;
2350        ipv6a[25] = 0x01;
2351        /* - */
2352        ipv6ptr = inet_ntop(AF_INET6, ipv6a, ipv6res, sizeof(ipv6res));
2353        if(!ipv6ptr)
2354          return 1; /* fail */
2355        if(ipv6ptr != ipv6res)
2356          return 1; /* fail */
2357        if(!ipv6ptr[0])
2358          return 1; /* fail */
2359        if(memcmp(ipv6res, "fe80::214:4fff:fe0b:76c8", 24) != 0)
2360          return 1; /* fail */
2361        /* - */
2362        return 0;
2363      ]])
2364    ],[
2365      AC_MSG_RESULT([yes])
2366      tst_works_inet_ntop="yes"
2367    ],[
2368      AC_MSG_RESULT([no])
2369      tst_works_inet_ntop="no"
2370    ])
2371  fi
2372
2373  if test "$tst_compi_inet_ntop" = "yes" &&
2374    test "$tst_works_inet_ntop" != "no"; then
2375    AC_MSG_CHECKING([if inet_ntop usage allowed])
2376    if test "x$curl_disallow_inet_ntop" != "xyes"; then
2377      AC_MSG_RESULT([yes])
2378      tst_allow_inet_ntop="yes"
2379    else
2380      AC_MSG_RESULT([no])
2381      tst_allow_inet_ntop="no"
2382    fi
2383  fi
2384
2385  AC_MSG_CHECKING([if inet_ntop might be used])
2386  if test "$tst_links_inet_ntop" = "yes" &&
2387     test "$tst_proto_inet_ntop" = "yes" &&
2388     test "$tst_compi_inet_ntop" = "yes" &&
2389     test "$tst_allow_inet_ntop" = "yes" &&
2390     test "$tst_works_inet_ntop" != "no"; then
2391    AC_MSG_RESULT([yes])
2392    AC_DEFINE_UNQUOTED(HAVE_INET_NTOP, 1,
2393      [Define to 1 if you have an IPv6 capable working inet_ntop function.])
2394    curl_cv_func_inet_ntop="yes"
2395  else
2396    AC_MSG_RESULT([no])
2397    curl_cv_func_inet_ntop="no"
2398  fi
2399])
2400
2401
2402dnl CURL_CHECK_FUNC_INET_PTON
2403dnl -------------------------------------------------
2404dnl Verify if inet_pton is available, prototyped, can
2405dnl be compiled and seems to work. If all of these are
2406dnl true, and usage has not been previously disallowed
2407dnl with shell variable curl_disallow_inet_pton, then
2408dnl HAVE_INET_PTON is defined.
2409
2410AC_DEFUN([CURL_CHECK_FUNC_INET_PTON], [
2411  AC_REQUIRE([CURL_INCLUDES_STDLIB])
2412  AC_REQUIRE([CURL_INCLUDES_ARPA_INET])
2413  AC_REQUIRE([CURL_INCLUDES_STRING])
2414
2415  tst_links_inet_pton="unknown"
2416  tst_proto_inet_pton="unknown"
2417  tst_compi_inet_pton="unknown"
2418  tst_works_inet_pton="unknown"
2419  tst_allow_inet_pton="unknown"
2420
2421  AC_MSG_CHECKING([if inet_pton can be linked])
2422  AC_LINK_IFELSE([
2423    AC_LANG_FUNC_LINK_TRY([inet_pton])
2424  ],[
2425    AC_MSG_RESULT([yes])
2426    tst_links_inet_pton="yes"
2427  ],[
2428    AC_MSG_RESULT([no])
2429    tst_links_inet_pton="no"
2430  ])
2431
2432  if test "$tst_links_inet_pton" = "yes"; then
2433    AC_MSG_CHECKING([if inet_pton is prototyped])
2434    AC_EGREP_CPP([inet_pton],[
2435      $curl_includes_arpa_inet
2436    ],[
2437      AC_MSG_RESULT([yes])
2438      tst_proto_inet_pton="yes"
2439    ],[
2440      AC_MSG_RESULT([no])
2441      tst_proto_inet_pton="no"
2442    ])
2443  fi
2444
2445  if test "$tst_proto_inet_pton" = "yes"; then
2446    AC_MSG_CHECKING([if inet_pton is compilable])
2447    AC_COMPILE_IFELSE([
2448      AC_LANG_PROGRAM([[
2449        $curl_includes_arpa_inet
2450      ]],[[
2451        unsigned char ipv4a[4 + 1] = "";
2452        const char *ipv4src = "192.168.100.1";
2453        if(inet_pton(0, ipv4src, ipv4a) != 0)
2454          return 1;
2455      ]])
2456    ],[
2457      AC_MSG_RESULT([yes])
2458      tst_compi_inet_pton="yes"
2459    ],[
2460      AC_MSG_RESULT([no])
2461      tst_compi_inet_pton="no"
2462    ])
2463  fi
2464
2465  dnl only do runtime verification when not cross-compiling
2466  if test "$cross_compiling" != "yes" &&
2467    test "$tst_compi_inet_pton" = "yes"; then
2468    AC_MSG_CHECKING([if inet_pton seems to work])
2469    CURL_RUN_IFELSE([
2470      AC_LANG_PROGRAM([[
2471        $curl_includes_stdlib
2472        $curl_includes_arpa_inet
2473        $curl_includes_string
2474      ]],[[
2475        unsigned char ipv6a[16 + 1];
2476        unsigned char ipv4a[4 + 1];
2477        const char *ipv6src = "fe80::214:4fff:fe0b:76c8";
2478        const char *ipv4src = "192.168.100.1";
2479        /* - */
2480        memset(ipv4a, 1, sizeof(ipv4a));
2481        if(inet_pton(AF_INET, ipv4src, ipv4a) != 1)
2482          return 1; /* fail */
2483        /* - */
2484        if((ipv4a[0] != 0xc0) ||
2485           (ipv4a[1] != 0xa8) ||
2486           (ipv4a[2] != 0x64) ||
2487           (ipv4a[3] != 0x01) ||
2488           (ipv4a[4] != 0x01))
2489          return 1; /* fail */
2490        /* - */
2491        memset(ipv6a, 1, sizeof(ipv6a));
2492        if(inet_pton(AF_INET6, ipv6src, ipv6a) != 1)
2493          return 1; /* fail */
2494        /* - */
2495        if((ipv6a[0]  != 0xfe) ||
2496           (ipv6a[1]  != 0x80) ||
2497           (ipv6a[8]  != 0x02) ||
2498           (ipv6a[9]  != 0x14) ||
2499           (ipv6a[10] != 0x4f) ||
2500           (ipv6a[11] != 0xff) ||
2501           (ipv6a[12] != 0xfe) ||
2502           (ipv6a[13] != 0x0b) ||
2503           (ipv6a[14] != 0x76) ||
2504           (ipv6a[15] != 0xc8) ||
2505           (ipv6a[16] != 0x01))
2506          return 1; /* fail */
2507        /* - */
2508        if((ipv6a[2] != 0x0) ||
2509           (ipv6a[3] != 0x0) ||
2510           (ipv6a[4] != 0x0) ||
2511           (ipv6a[5] != 0x0) ||
2512           (ipv6a[6] != 0x0) ||
2513           (ipv6a[7] != 0x0))
2514          return 1; /* fail */
2515        /* - */
2516        return 0;
2517      ]])
2518    ],[
2519      AC_MSG_RESULT([yes])
2520      tst_works_inet_pton="yes"
2521    ],[
2522      AC_MSG_RESULT([no])
2523      tst_works_inet_pton="no"
2524    ])
2525  fi
2526
2527  if test "$tst_compi_inet_pton" = "yes" &&
2528    test "$tst_works_inet_pton" != "no"; then
2529    AC_MSG_CHECKING([if inet_pton usage allowed])
2530    if test "x$curl_disallow_inet_pton" != "xyes"; then
2531      AC_MSG_RESULT([yes])
2532      tst_allow_inet_pton="yes"
2533    else
2534      AC_MSG_RESULT([no])
2535      tst_allow_inet_pton="no"
2536    fi
2537  fi
2538
2539  AC_MSG_CHECKING([if inet_pton might be used])
2540  if test "$tst_links_inet_pton" = "yes" &&
2541     test "$tst_proto_inet_pton" = "yes" &&
2542     test "$tst_compi_inet_pton" = "yes" &&
2543     test "$tst_allow_inet_pton" = "yes" &&
2544     test "$tst_works_inet_pton" != "no"; then
2545    AC_MSG_RESULT([yes])
2546    AC_DEFINE_UNQUOTED(HAVE_INET_PTON, 1,
2547      [Define to 1 if you have an IPv6 capable working inet_pton function.])
2548    curl_cv_func_inet_pton="yes"
2549  else
2550    AC_MSG_RESULT([no])
2551    curl_cv_func_inet_pton="no"
2552  fi
2553])
2554
2555
2556dnl CURL_CHECK_FUNC_IOCTL
2557dnl -------------------------------------------------
2558dnl Verify if ioctl is available, prototyped, and
2559dnl can be compiled. If all of these are true, and
2560dnl usage has not been previously disallowed with
2561dnl shell variable curl_disallow_ioctl, then
2562dnl curl_cv_func_ioctl is set to "yes".
2563
2564AC_DEFUN([CURL_CHECK_FUNC_IOCTL], [
2565  AC_REQUIRE([CURL_INCLUDES_STROPTS])
2566
2567  tst_links_ioctl="unknown"
2568  tst_proto_ioctl="unknown"
2569  tst_compi_ioctl="unknown"
2570  tst_allow_ioctl="unknown"
2571
2572  AC_MSG_CHECKING([if ioctl can be linked])
2573  AC_LINK_IFELSE([
2574    AC_LANG_FUNC_LINK_TRY([ioctl])
2575  ],[
2576    AC_MSG_RESULT([yes])
2577    tst_links_ioctl="yes"
2578  ],[
2579    AC_MSG_RESULT([no])
2580    tst_links_ioctl="no"
2581  ])
2582
2583  if test "$tst_links_ioctl" = "yes"; then
2584    AC_MSG_CHECKING([if ioctl is prototyped])
2585    AC_EGREP_CPP([ioctl],[
2586      $curl_includes_stropts
2587    ],[
2588      AC_MSG_RESULT([yes])
2589      tst_proto_ioctl="yes"
2590    ],[
2591      AC_MSG_RESULT([no])
2592      tst_proto_ioctl="no"
2593    ])
2594  fi
2595
2596  if test "$tst_proto_ioctl" = "yes"; then
2597    AC_MSG_CHECKING([if ioctl is compilable])
2598    AC_COMPILE_IFELSE([
2599      AC_LANG_PROGRAM([[
2600        $curl_includes_stropts
2601      ]],[[
2602        if(ioctl(0, 0, 0) != 0)
2603          return 1;
2604      ]])
2605    ],[
2606      AC_MSG_RESULT([yes])
2607      tst_compi_ioctl="yes"
2608    ],[
2609      AC_MSG_RESULT([no])
2610      tst_compi_ioctl="no"
2611    ])
2612  fi
2613
2614  if test "$tst_compi_ioctl" = "yes"; then
2615    AC_MSG_CHECKING([if ioctl usage allowed])
2616    if test "x$curl_disallow_ioctl" != "xyes"; then
2617      AC_MSG_RESULT([yes])
2618      tst_allow_ioctl="yes"
2619    else
2620      AC_MSG_RESULT([no])
2621      tst_allow_ioctl="no"
2622    fi
2623  fi
2624
2625  AC_MSG_CHECKING([if ioctl might be used])
2626  if test "$tst_links_ioctl" = "yes" &&
2627     test "$tst_proto_ioctl" = "yes" &&
2628     test "$tst_compi_ioctl" = "yes" &&
2629     test "$tst_allow_ioctl" = "yes"; then
2630    AC_MSG_RESULT([yes])
2631    curl_cv_func_ioctl="yes"
2632    CURL_CHECK_FUNC_IOCTL_FIONBIO
2633    CURL_CHECK_FUNC_IOCTL_SIOCGIFADDR
2634  else
2635    AC_MSG_RESULT([no])
2636    curl_cv_func_ioctl="no"
2637  fi
2638])
2639
2640
2641dnl CURL_CHECK_FUNC_IOCTL_FIONBIO
2642dnl -------------------------------------------------
2643dnl Verify if ioctl with the FIONBIO command is
2644dnl available, can be compiled, and seems to work. If
2645dnl all of these are true, then HAVE_IOCTL_FIONBIO
2646dnl is defined.
2647
2648AC_DEFUN([CURL_CHECK_FUNC_IOCTL_FIONBIO], [
2649
2650  tst_compi_ioctl_fionbio="unknown"
2651  tst_allow_ioctl_fionbio="unknown"
2652
2653  if test "$curl_cv_func_ioctl" = "yes"; then
2654    AC_MSG_CHECKING([if ioctl FIONBIO is compilable])
2655    AC_COMPILE_IFELSE([
2656      AC_LANG_PROGRAM([[
2657        $curl_includes_stropts
2658      ]],[[
2659        int flags = 0;
2660        if(ioctl(0, FIONBIO, &flags) != 0)
2661          return 1;
2662      ]])
2663    ],[
2664      AC_MSG_RESULT([yes])
2665      tst_compi_ioctl_fionbio="yes"
2666    ],[
2667      AC_MSG_RESULT([no])
2668      tst_compi_ioctl_fionbio="no"
2669    ])
2670  fi
2671
2672  if test "$tst_compi_ioctl_fionbio" = "yes"; then
2673    AC_MSG_CHECKING([if ioctl FIONBIO usage allowed])
2674    if test "x$curl_disallow_ioctl_fionbio" != "xyes"; then
2675      AC_MSG_RESULT([yes])
2676      tst_allow_ioctl_fionbio="yes"
2677    else
2678      AC_MSG_RESULT([no])
2679      tst_allow_ioctl_fionbio="no"
2680    fi
2681  fi
2682
2683  AC_MSG_CHECKING([if ioctl FIONBIO might be used])
2684  if test "$tst_compi_ioctl_fionbio" = "yes" &&
2685     test "$tst_allow_ioctl_fionbio" = "yes"; then
2686    AC_MSG_RESULT([yes])
2687    AC_DEFINE_UNQUOTED(HAVE_IOCTL_FIONBIO, 1,
2688      [Define to 1 if you have a working ioctl FIONBIO function.])
2689    curl_cv_func_ioctl_fionbio="yes"
2690  else
2691    AC_MSG_RESULT([no])
2692    curl_cv_func_ioctl_fionbio="no"
2693  fi
2694])
2695
2696
2697dnl CURL_CHECK_FUNC_IOCTL_SIOCGIFADDR
2698dnl -------------------------------------------------
2699dnl Verify if ioctl with the SIOCGIFADDR command is available,
2700dnl struct ifreq is defined, they can be compiled, and seem to
2701dnl work. If all of these are true, then HAVE_IOCTL_SIOCGIFADDR
2702dnl is defined.
2703
2704AC_DEFUN([CURL_CHECK_FUNC_IOCTL_SIOCGIFADDR], [
2705
2706  tst_compi_ioctl_siocgifaddr="unknown"
2707  tst_allow_ioctl_siocgifaddr="unknown"
2708
2709  if test "$curl_cv_func_ioctl" = "yes"; then
2710    AC_MSG_CHECKING([if ioctl SIOCGIFADDR is compilable])
2711    AC_COMPILE_IFELSE([
2712      AC_LANG_PROGRAM([[
2713        $curl_includes_stropts
2714        #include <net/if.h>
2715      ]],[[
2716        struct ifreq ifr;
2717        if(ioctl(0, SIOCGIFADDR, &ifr) != 0)
2718          return 1;
2719      ]])
2720    ],[
2721      AC_MSG_RESULT([yes])
2722      tst_compi_ioctl_siocgifaddr="yes"
2723    ],[
2724      AC_MSG_RESULT([no])
2725      tst_compi_ioctl_siocgifaddr="no"
2726    ])
2727  fi
2728
2729  if test "$tst_compi_ioctl_siocgifaddr" = "yes"; then
2730    AC_MSG_CHECKING([if ioctl SIOCGIFADDR usage allowed])
2731    if test "x$curl_disallow_ioctl_siocgifaddr" != "xyes"; then
2732      AC_MSG_RESULT([yes])
2733      tst_allow_ioctl_siocgifaddr="yes"
2734    else
2735      AC_MSG_RESULT([no])
2736      tst_allow_ioctl_siocgifaddr="no"
2737    fi
2738  fi
2739
2740  AC_MSG_CHECKING([if ioctl SIOCGIFADDR might be used])
2741  if test "$tst_compi_ioctl_siocgifaddr" = "yes" &&
2742     test "$tst_allow_ioctl_siocgifaddr" = "yes"; then
2743    AC_MSG_RESULT([yes])
2744    AC_DEFINE_UNQUOTED(HAVE_IOCTL_SIOCGIFADDR, 1,
2745      [Define to 1 if you have a working ioctl SIOCGIFADDR function.])
2746    curl_cv_func_ioctl_siocgifaddr="yes"
2747  else
2748    AC_MSG_RESULT([no])
2749    curl_cv_func_ioctl_siocgifaddr="no"
2750  fi
2751])
2752
2753
2754dnl CURL_CHECK_FUNC_IOCTLSOCKET
2755dnl -------------------------------------------------
2756dnl Verify if ioctlsocket is available, prototyped, and
2757dnl can be compiled. If all of these are true, and
2758dnl usage has not been previously disallowed with
2759dnl shell variable curl_disallow_ioctlsocket, then
2760dnl HAVE_IOCTLSOCKET is defined.
2761
2762AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET], [
2763  AC_REQUIRE([CURL_INCLUDES_WINSOCK2])
2764
2765  tst_links_ioctlsocket="unknown"
2766  tst_proto_ioctlsocket="unknown"
2767  tst_compi_ioctlsocket="unknown"
2768  tst_allow_ioctlsocket="unknown"
2769
2770  AC_MSG_CHECKING([if ioctlsocket can be linked])
2771  AC_LINK_IFELSE([
2772    AC_LANG_PROGRAM([[
2773      $curl_includes_winsock2
2774    ]],[[
2775      if(ioctlsocket(0, 0, 0) != 0)
2776        return 1;
2777    ]])
2778  ],[
2779    AC_MSG_RESULT([yes])
2780    tst_links_ioctlsocket="yes"
2781  ],[
2782    AC_MSG_RESULT([no])
2783    tst_links_ioctlsocket="no"
2784  ])
2785
2786  if test "$tst_links_ioctlsocket" = "yes"; then
2787    AC_MSG_CHECKING([if ioctlsocket is prototyped])
2788    AC_EGREP_CPP([ioctlsocket],[
2789      $curl_includes_winsock2
2790    ],[
2791      AC_MSG_RESULT([yes])
2792      tst_proto_ioctlsocket="yes"
2793    ],[
2794      AC_MSG_RESULT([no])
2795      tst_proto_ioctlsocket="no"
2796    ])
2797  fi
2798
2799  if test "$tst_proto_ioctlsocket" = "yes"; then
2800    AC_MSG_CHECKING([if ioctlsocket is compilable])
2801    AC_COMPILE_IFELSE([
2802      AC_LANG_PROGRAM([[
2803        $curl_includes_winsock2
2804      ]],[[
2805        if(ioctlsocket(0, 0, 0) != 0)
2806          return 1;
2807      ]])
2808    ],[
2809      AC_MSG_RESULT([yes])
2810      tst_compi_ioctlsocket="yes"
2811    ],[
2812      AC_MSG_RESULT([no])
2813      tst_compi_ioctlsocket="no"
2814    ])
2815  fi
2816
2817  if test "$tst_compi_ioctlsocket" = "yes"; then
2818    AC_MSG_CHECKING([if ioctlsocket usage allowed])
2819    if test "x$curl_disallow_ioctlsocket" != "xyes"; then
2820      AC_MSG_RESULT([yes])
2821      tst_allow_ioctlsocket="yes"
2822    else
2823      AC_MSG_RESULT([no])
2824      tst_allow_ioctlsocket="no"
2825    fi
2826  fi
2827
2828  AC_MSG_CHECKING([if ioctlsocket might be used])
2829  if test "$tst_links_ioctlsocket" = "yes" &&
2830     test "$tst_proto_ioctlsocket" = "yes" &&
2831     test "$tst_compi_ioctlsocket" = "yes" &&
2832     test "$tst_allow_ioctlsocket" = "yes"; then
2833    AC_MSG_RESULT([yes])
2834    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET, 1,
2835      [Define to 1 if you have the ioctlsocket function.])
2836    curl_cv_func_ioctlsocket="yes"
2837    CURL_CHECK_FUNC_IOCTLSOCKET_FIONBIO
2838  else
2839    AC_MSG_RESULT([no])
2840    curl_cv_func_ioctlsocket="no"
2841  fi
2842])
2843
2844
2845dnl CURL_CHECK_FUNC_IOCTLSOCKET_FIONBIO
2846dnl -------------------------------------------------
2847dnl Verify if ioctlsocket with the FIONBIO command is
2848dnl available, can be compiled, and seems to work. If
2849dnl all of these are true, then HAVE_IOCTLSOCKET_FIONBIO
2850dnl is defined.
2851
2852AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET_FIONBIO], [
2853
2854  tst_compi_ioctlsocket_fionbio="unknown"
2855  tst_allow_ioctlsocket_fionbio="unknown"
2856
2857  if test "$curl_cv_func_ioctlsocket" = "yes"; then
2858    AC_MSG_CHECKING([if ioctlsocket FIONBIO is compilable])
2859    AC_COMPILE_IFELSE([
2860      AC_LANG_PROGRAM([[
2861        $curl_includes_winsock2
2862      ]],[[
2863        unsigned long flags = 0;
2864        if(ioctlsocket(0, FIONBIO, &flags) != 0)
2865          return 1;
2866      ]])
2867    ],[
2868      AC_MSG_RESULT([yes])
2869      tst_compi_ioctlsocket_fionbio="yes"
2870    ],[
2871      AC_MSG_RESULT([no])
2872      tst_compi_ioctlsocket_fionbio="no"
2873    ])
2874  fi
2875
2876  if test "$tst_compi_ioctlsocket_fionbio" = "yes"; then
2877    AC_MSG_CHECKING([if ioctlsocket FIONBIO usage allowed])
2878    if test "x$curl_disallow_ioctlsocket_fionbio" != "xyes"; then
2879      AC_MSG_RESULT([yes])
2880      tst_allow_ioctlsocket_fionbio="yes"
2881    else
2882      AC_MSG_RESULT([no])
2883      tst_allow_ioctlsocket_fionbio="no"
2884    fi
2885  fi
2886
2887  AC_MSG_CHECKING([if ioctlsocket FIONBIO might be used])
2888  if test "$tst_compi_ioctlsocket_fionbio" = "yes" &&
2889     test "$tst_allow_ioctlsocket_fionbio" = "yes"; then
2890    AC_MSG_RESULT([yes])
2891    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_FIONBIO, 1,
2892      [Define to 1 if you have a working ioctlsocket FIONBIO function.])
2893    curl_cv_func_ioctlsocket_fionbio="yes"
2894  else
2895    AC_MSG_RESULT([no])
2896    curl_cv_func_ioctlsocket_fionbio="no"
2897  fi
2898])
2899
2900
2901dnl CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL
2902dnl -------------------------------------------------
2903dnl Verify if IoctlSocket is available, prototyped, and
2904dnl can be compiled. If all of these are true, and
2905dnl usage has not been previously disallowed with
2906dnl shell variable curl_disallow_ioctlsocket_camel,
2907dnl then HAVE_IOCTLSOCKET_CAMEL is defined.
2908
2909AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL], [
2910  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])
2911
2912  tst_links_ioctlsocket_camel="unknown"
2913  tst_compi_ioctlsocket_camel="unknown"
2914  tst_allow_ioctlsocket_camel="unknown"
2915
2916  AC_MSG_CHECKING([if IoctlSocket can be linked])
2917  AC_LINK_IFELSE([
2918    AC_LANG_PROGRAM([[
2919      $curl_includes_bsdsocket
2920    ]],[[
2921      if(IoctlSocket(0, 0, 0) != 0)
2922        return 1;
2923    ]])
2924  ],[
2925    AC_MSG_RESULT([yes])
2926    tst_links_ioctlsocket_camel="yes"
2927  ],[
2928    AC_MSG_RESULT([no])
2929    tst_links_ioctlsocket_camel="no"
2930  ])
2931
2932  if test "$tst_links_ioctlsocket_camel" = "yes"; then
2933    AC_MSG_CHECKING([if IoctlSocket is compilable])
2934    AC_COMPILE_IFELSE([
2935      AC_LANG_PROGRAM([[
2936        $curl_includes_bsdsocket
2937      ]],[[
2938        if(IoctlSocket(0, 0, 0) != 0)
2939          return 1;
2940      ]])
2941    ],[
2942      AC_MSG_RESULT([yes])
2943      tst_compi_ioctlsocket_camel="yes"
2944    ],[
2945      AC_MSG_RESULT([no])
2946      tst_compi_ioctlsocket_camel="no"
2947    ])
2948  fi
2949
2950  if test "$tst_compi_ioctlsocket_camel" = "yes"; then
2951    AC_MSG_CHECKING([if IoctlSocket usage allowed])
2952    if test "x$curl_disallow_ioctlsocket_camel" != "xyes"; then
2953      AC_MSG_RESULT([yes])
2954      tst_allow_ioctlsocket_camel="yes"
2955    else
2956      AC_MSG_RESULT([no])
2957      tst_allow_ioctlsocket_camel="no"
2958    fi
2959  fi
2960
2961  AC_MSG_CHECKING([if IoctlSocket might be used])
2962  if test "$tst_links_ioctlsocket_camel" = "yes" &&
2963     test "$tst_compi_ioctlsocket_camel" = "yes" &&
2964     test "$tst_allow_ioctlsocket_camel" = "yes"; then
2965    AC_MSG_RESULT([yes])
2966    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL, 1,
2967      [Define to 1 if you have the IoctlSocket camel case function.])
2968    curl_cv_func_ioctlsocket_camel="yes"
2969    CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
2970  else
2971    AC_MSG_RESULT([no])
2972    curl_cv_func_ioctlsocket_camel="no"
2973  fi
2974])
2975
2976
2977dnl CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
2978dnl -------------------------------------------------
2979dnl Verify if IoctlSocket with FIONBIO command is available,
2980dnl can be compiled, and seems to work. If all of these are
2981dnl true, then HAVE_IOCTLSOCKET_CAMEL_FIONBIO is defined.
2982
2983AC_DEFUN([CURL_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO], [
2984  AC_REQUIRE([CURL_INCLUDES_BSDSOCKET])
2985
2986  tst_compi_ioctlsocket_camel_fionbio="unknown"
2987  tst_allow_ioctlsocket_camel_fionbio="unknown"
2988
2989  if test "$curl_cv_func_ioctlsocket_camel" = "yes"; then
2990    AC_MSG_CHECKING([if IoctlSocket FIONBIO is compilable])
2991    AC_COMPILE_IFELSE([
2992      AC_LANG_PROGRAM([[
2993        $curl_includes_bsdsocket
2994      ]],[[
2995        long flags = 0;
2996        if(IoctlSocket(0, FIONBIO, &flags) != 0)
2997          return 1;
2998      ]])
2999    ],[
3000      AC_MSG_RESULT([yes])
3001      tst_compi_ioctlsocket_camel_fionbio="yes"
3002    ],[
3003      AC_MSG_RESULT([no])
3004      tst_compi_ioctlsocket_camel_fionbio="no"
3005    ])
3006  fi
3007
3008  if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes"; then
3009    AC_MSG_CHECKING([if IoctlSocket FIONBIO usage allowed])
3010    if test "x$curl_disallow_ioctlsocket_camel_fionbio" != "xyes"; then
3011      AC_MSG_RESULT([yes])
3012      tst_allow_ioctlsocket_camel_fionbio="yes"
3013    else
3014      AC_MSG_RESULT([no])
3015      tst_allow_ioctlsocket_camel_fionbio="no"
3016    fi
3017  fi
3018
3019  AC_MSG_CHECKING([if IoctlSocket FIONBIO might be used])
3020  if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes" &&
3021     test "$tst_allow_ioctlsocket_camel_fionbio" = "yes"; then
3022    AC_MSG_RESULT([yes])
3023    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL_FIONBIO, 1,
3024      [Define to 1 if you have a working IoctlSocket camel case FIONBIO function.])
3025    curl_cv_func_ioctlsocket_camel_fionbio="yes"
3026  else
3027    AC_MSG_RESULT([no])
3028    curl_cv_func_ioctlsocket_camel_fionbio="no"
3029  fi
3030])
3031
3032
3033dnl CURL_CHECK_FUNC_MEMRCHR
3034dnl -------------------------------------------------
3035dnl Verify if memrchr is available, prototyped, and
3036dnl can be compiled. If all of these are true, and
3037dnl usage has not been previously disallowed with
3038dnl shell variable curl_disallow_memrchr, then
3039dnl HAVE_MEMRCHR is defined.
3040
3041AC_DEFUN([CURL_CHECK_FUNC_MEMRCHR], [
3042  AC_REQUIRE([CURL_INCLUDES_STRING])
3043
3044  tst_links_memrchr="unknown"
3045  tst_macro_memrchr="unknown"
3046  tst_proto_memrchr="unknown"
3047  tst_compi_memrchr="unknown"
3048  tst_allow_memrchr="unknown"
3049
3050  AC_MSG_CHECKING([if memrchr can be linked])
3051  AC_LINK_IFELSE([
3052    AC_LANG_FUNC_LINK_TRY([memrchr])
3053  ],[
3054    AC_MSG_RESULT([yes])
3055    tst_links_memrchr="yes"
3056  ],[
3057    AC_MSG_RESULT([no])
3058    tst_links_memrchr="no"
3059  ])
3060
3061  if test "$tst_links_memrchr" = "no"; then
3062    AC_MSG_CHECKING([if memrchr seems a macro])
3063    AC_LINK_IFELSE([
3064      AC_LANG_PROGRAM([[
3065        $curl_includes_string
3066      ]],[[
3067        if(memrchr("", 0, 0) != 0)
3068          return 1;
3069      ]])
3070    ],[
3071      AC_MSG_RESULT([yes])
3072      tst_macro_memrchr="yes"
3073    ],[
3074      AC_MSG_RESULT([no])
3075      tst_macro_memrchr="no"
3076    ])
3077  fi
3078
3079  if test "$tst_links_memrchr" = "yes"; then
3080    AC_MSG_CHECKING([if memrchr is prototyped])
3081    AC_EGREP_CPP([memrchr],[
3082      $curl_includes_string
3083    ],[
3084      AC_MSG_RESULT([yes])
3085      tst_proto_memrchr="yes"
3086    ],[
3087      AC_MSG_RESULT([no])
3088      tst_proto_memrchr="no"
3089    ])
3090  fi
3091
3092  if test "$tst_proto_memrchr" = "yes" ||
3093     test "$tst_macro_memrchr" = "yes"; then
3094    AC_MSG_CHECKING([if memrchr is compilable])
3095    AC_COMPILE_IFELSE([
3096      AC_LANG_PROGRAM([[
3097        $curl_includes_string
3098      ]],[[
3099        if(memrchr("", 0, 0) != 0)
3100          return 1;
3101      ]])
3102    ],[
3103      AC_MSG_RESULT([yes])
3104      tst_compi_memrchr="yes"
3105    ],[
3106      AC_MSG_RESULT([no])
3107      tst_compi_memrchr="no"
3108    ])
3109  fi
3110
3111  if test "$tst_compi_memrchr" = "yes"; then
3112    AC_MSG_CHECKING([if memrchr usage allowed])
3113    if test "x$curl_disallow_memrchr" != "xyes"; then
3114      AC_MSG_RESULT([yes])
3115      tst_allow_memrchr="yes"
3116    else
3117      AC_MSG_RESULT([no])
3118      tst_allow_memrchr="no"
3119    fi
3120  fi
3121
3122  AC_MSG_CHECKING([if memrchr might be used])
3123  if (test "$tst_proto_memrchr" = "yes" ||
3124      test "$tst_macro_memrchr" = "yes") &&
3125     test "$tst_compi_memrchr" = "yes" &&
3126     test "$tst_allow_memrchr" = "yes"; then
3127    AC_MSG_RESULT([yes])
3128    AC_DEFINE_UNQUOTED(HAVE_MEMRCHR, 1,
3129      [Define to 1 if you have the memrchr function or macro.])
3130    curl_cv_func_memrchr="yes"
3131  else
3132    AC_MSG_RESULT([no])
3133    curl_cv_func_memrchr="no"
3134  fi
3135])
3136
3137
3138dnl CURL_CHECK_FUNC_SIGACTION
3139dnl -------------------------------------------------
3140dnl Verify if sigaction is available, prototyped, and
3141dnl can be compiled. If all of these are true, and
3142dnl usage has not been previously disallowed with
3143dnl shell variable curl_disallow_sigaction, then
3144dnl HAVE_SIGACTION is defined.
3145
3146AC_DEFUN([CURL_CHECK_FUNC_SIGACTION], [
3147  AC_REQUIRE([CURL_INCLUDES_SIGNAL])
3148
3149  tst_links_sigaction="unknown"
3150  tst_proto_sigaction="unknown"
3151  tst_compi_sigaction="unknown"
3152  tst_allow_sigaction="unknown"
3153
3154  AC_MSG_CHECKING([if sigaction can be linked])
3155  AC_LINK_IFELSE([
3156    AC_LANG_FUNC_LINK_TRY([sigaction])
3157  ],[
3158    AC_MSG_RESULT([yes])
3159    tst_links_sigaction="yes"
3160  ],[
3161    AC_MSG_RESULT([no])
3162    tst_links_sigaction="no"
3163  ])
3164
3165  if test "$tst_links_sigaction" = "yes"; then
3166    AC_MSG_CHECKING([if sigaction is prototyped])
3167    AC_EGREP_CPP([sigaction],[
3168      $curl_includes_signal
3169    ],[
3170      AC_MSG_RESULT([yes])
3171      tst_proto_sigaction="yes"
3172    ],[
3173      AC_MSG_RESULT([no])
3174      tst_proto_sigaction="no"
3175    ])
3176  fi
3177
3178  if test "$tst_proto_sigaction" = "yes"; then
3179    AC_MSG_CHECKING([if sigaction is compilable])
3180    AC_COMPILE_IFELSE([
3181      AC_LANG_PROGRAM([[
3182        $curl_includes_signal
3183      ]],[[
3184        if(sigaction(0, 0, 0) != 0)
3185          return 1;
3186      ]])
3187    ],[
3188      AC_MSG_RESULT([yes])
3189      tst_compi_sigaction="yes"
3190    ],[
3191      AC_MSG_RESULT([no])
3192      tst_compi_sigaction="no"
3193    ])
3194  fi
3195
3196  if test "$tst_compi_sigaction" = "yes"; then
3197    AC_MSG_CHECKING([if sigaction usage allowed])
3198    if test "x$curl_disallow_sigaction" != "xyes"; then
3199      AC_MSG_RESULT([yes])
3200      tst_allow_sigaction="yes"
3201    else
3202      AC_MSG_RESULT([no])
3203      tst_allow_sigaction="no"
3204    fi
3205  fi
3206
3207  AC_MSG_CHECKING([if sigaction might be used])
3208  if test "$tst_links_sigaction" = "yes" &&
3209     test "$tst_proto_sigaction" = "yes" &&
3210     test "$tst_compi_sigaction" = "yes" &&
3211     test "$tst_allow_sigaction" = "yes"; then
3212    AC_MSG_RESULT([yes])
3213    AC_DEFINE_UNQUOTED(HAVE_SIGACTION, 1,
3214      [Define to 1 if you have the sigaction function.])
3215    curl_cv_func_sigaction="yes"
3216  else
3217    AC_MSG_RESULT([no])
3218    curl_cv_func_sigaction="no"
3219  fi
3220])
3221
3222
3223dnl CURL_CHECK_FUNC_SIGINTERRUPT
3224dnl -------------------------------------------------
3225dnl Verify if siginterrupt is available, prototyped, and
3226dnl can be compiled. If all of these are true, and
3227dnl usage has not been previously disallowed with
3228dnl shell variable curl_disallow_siginterrupt, then
3229dnl HAVE_SIGINTERRUPT is defined.
3230
3231AC_DEFUN([CURL_CHECK_FUNC_SIGINTERRUPT], [
3232  AC_REQUIRE([CURL_INCLUDES_SIGNAL])
3233
3234  tst_links_siginterrupt="unknown"
3235  tst_proto_siginterrupt="unknown"
3236  tst_compi_siginterrupt="unknown"
3237  tst_allow_siginterrupt="unknown"
3238
3239  AC_MSG_CHECKING([if siginterrupt can be linked])
3240  AC_LINK_IFELSE([
3241    AC_LANG_FUNC_LINK_TRY([siginterrupt])
3242  ],[
3243    AC_MSG_RESULT([yes])
3244    tst_links_siginterrupt="yes"
3245  ],[
3246    AC_MSG_RESULT([no])
3247    tst_links_siginterrupt="no"
3248  ])
3249
3250  if test "$tst_links_siginterrupt" = "yes"; then
3251    AC_MSG_CHECKING([if siginterrupt is prototyped])
3252    AC_EGREP_CPP([siginterrupt],[
3253      $curl_includes_signal
3254    ],[
3255      AC_MSG_RESULT([yes])
3256      tst_proto_siginterrupt="yes"
3257    ],[
3258      AC_MSG_RESULT([no])
3259      tst_proto_siginterrupt="no"
3260    ])
3261  fi
3262
3263  if test "$tst_proto_siginterrupt" = "yes"; then
3264    AC_MSG_CHECKING([if siginterrupt is compilable])
3265    AC_COMPILE_IFELSE([
3266      AC_LANG_PROGRAM([[
3267        $curl_includes_signal
3268      ]],[[
3269        if(siginterrupt(0, 0) != 0)
3270          return 1;
3271      ]])
3272    ],[
3273      AC_MSG_RESULT([yes])
3274      tst_compi_siginterrupt="yes"
3275    ],[
3276      AC_MSG_RESULT([no])
3277      tst_compi_siginterrupt="no"
3278    ])
3279  fi
3280
3281  if test "$tst_compi_siginterrupt" = "yes"; then
3282    AC_MSG_CHECKING([if siginterrupt usage allowed])
3283    if test "x$curl_disallow_siginterrupt" != "xyes"; then
3284      AC_MSG_RESULT([yes])
3285      tst_allow_siginterrupt="yes"
3286    else
3287      AC_MSG_RESULT([no])
3288      tst_allow_siginterrupt="no"
3289    fi
3290  fi
3291
3292  AC_MSG_CHECKING([if siginterrupt might be used])
3293  if test "$tst_links_siginterrupt" = "yes" &&
3294     test "$tst_proto_siginterrupt" = "yes" &&
3295     test "$tst_compi_siginterrupt" = "yes" &&
3296     test "$tst_allow_siginterrupt" = "yes"; then
3297    AC_MSG_RESULT([yes])
3298    AC_DEFINE_UNQUOTED(HAVE_SIGINTERRUPT, 1,
3299      [Define to 1 if you have the siginterrupt function.])
3300    curl_cv_func_siginterrupt="yes"
3301  else
3302    AC_MSG_RESULT([no])
3303    curl_cv_func_siginterrupt="no"
3304  fi
3305])
3306
3307
3308dnl CURL_CHECK_FUNC_SIGNAL
3309dnl -------------------------------------------------
3310dnl Verify if signal is available, prototyped, and
3311dnl can be compiled. If all of these are true, and
3312dnl usage has not been previously disallowed with
3313dnl shell variable curl_disallow_signal, then
3314dnl HAVE_SIGNAL is defined.
3315
3316AC_DEFUN([CURL_CHECK_FUNC_SIGNAL], [
3317  AC_REQUIRE([CURL_INCLUDES_SIGNAL])
3318
3319  tst_links_signal="unknown"
3320  tst_proto_signal="unknown"
3321  tst_compi_signal="unknown"
3322  tst_allow_signal="unknown"
3323
3324  AC_MSG_CHECKING([if signal can be linked])
3325  AC_LINK_IFELSE([
3326    AC_LANG_FUNC_LINK_TRY([signal])
3327  ],[
3328    AC_MSG_RESULT([yes])
3329    tst_links_signal="yes"
3330  ],[
3331    AC_MSG_RESULT([no])
3332    tst_links_signal="no"
3333  ])
3334
3335  if test "$tst_links_signal" = "yes"; then
3336    AC_MSG_CHECKING([if signal is prototyped])
3337    AC_EGREP_CPP([signal],[
3338      $curl_includes_signal
3339    ],[
3340      AC_MSG_RESULT([yes])
3341      tst_proto_signal="yes"
3342    ],[
3343      AC_MSG_RESULT([no])
3344      tst_proto_signal="no"
3345    ])
3346  fi
3347
3348  if test "$tst_proto_signal" = "yes"; then
3349    AC_MSG_CHECKING([if signal is compilable])
3350    AC_COMPILE_IFELSE([
3351      AC_LANG_PROGRAM([[
3352        $curl_includes_signal
3353      ]],[[
3354        if(signal(0, 0) != 0)
3355          return 1;
3356      ]])
3357    ],[
3358      AC_MSG_RESULT([yes])
3359      tst_compi_signal="yes"
3360    ],[
3361      AC_MSG_RESULT([no])
3362      tst_compi_signal="no"
3363    ])
3364  fi
3365
3366  if test "$tst_compi_signal" = "yes"; then
3367    AC_MSG_CHECKING([if signal usage allowed])
3368    if test "x$curl_disallow_signal" != "xyes"; then
3369      AC_MSG_RESULT([yes])
3370      tst_allow_signal="yes"
3371    else
3372      AC_MSG_RESULT([no])
3373      tst_allow_signal="no"
3374    fi
3375  fi
3376
3377  AC_MSG_CHECKING([if signal might be used])
3378  if test "$tst_links_signal" = "yes" &&
3379     test "$tst_proto_signal" = "yes" &&
3380     test "$tst_compi_signal" = "yes" &&
3381     test "$tst_allow_signal" = "yes"; then
3382    AC_MSG_RESULT([yes])
3383    AC_DEFINE_UNQUOTED(HAVE_SIGNAL, 1,
3384      [Define to 1 if you have the signal function.])
3385    curl_cv_func_signal="yes"
3386  else
3387    AC_MSG_RESULT([no])
3388    curl_cv_func_signal="no"
3389  fi
3390])
3391
3392
3393dnl CURL_CHECK_FUNC_SIGSETJMP
3394dnl -------------------------------------------------
3395dnl Verify if sigsetjmp is available, prototyped, and
3396dnl can be compiled. If all of these are true, and
3397dnl usage has not been previously disallowed with
3398dnl shell variable curl_disallow_sigsetjmp, then
3399dnl HAVE_SIGSETJMP is defined.
3400
3401AC_DEFUN([CURL_CHECK_FUNC_SIGSETJMP], [
3402  AC_REQUIRE([CURL_INCLUDES_SETJMP])
3403
3404  tst_links_sigsetjmp="unknown"
3405  tst_macro_sigsetjmp="unknown"
3406  tst_proto_sigsetjmp="unknown"
3407  tst_compi_sigsetjmp="unknown"
3408  tst_allow_sigsetjmp="unknown"
3409
3410  AC_MSG_CHECKING([if sigsetjmp can be linked])
3411  AC_LINK_IFELSE([
3412    AC_LANG_FUNC_LINK_TRY([sigsetjmp])
3413  ],[
3414    AC_MSG_RESULT([yes])
3415    tst_links_sigsetjmp="yes"
3416  ],[
3417    AC_MSG_RESULT([no])
3418    tst_links_sigsetjmp="no"
3419  ])
3420
3421  if test "$tst_links_sigsetjmp" = "no"; then
3422    AC_MSG_CHECKING([if sigsetjmp seems a macro])
3423    AC_LINK_IFELSE([
3424      AC_LANG_PROGRAM([[
3425        $curl_includes_setjmp
3426      ]],[[
3427        sigjmp_buf env;
3428        if(sigsetjmp(env, 0) != 0)
3429          return 1;
3430      ]])
3431    ],[
3432      AC_MSG_RESULT([yes])
3433      tst_macro_sigsetjmp="yes"
3434    ],[
3435      AC_MSG_RESULT([no])
3436      tst_macro_sigsetjmp="no"
3437    ])
3438  fi
3439
3440  if test "$tst_links_sigsetjmp" = "yes"; then
3441    AC_MSG_CHECKING([if sigsetjmp is prototyped])
3442    AC_EGREP_CPP([sigsetjmp],[
3443      $curl_includes_setjmp
3444    ],[
3445      AC_MSG_RESULT([yes])
3446      tst_proto_sigsetjmp="yes"
3447    ],[
3448      AC_MSG_RESULT([no])
3449      tst_proto_sigsetjmp="no"
3450    ])
3451  fi
3452
3453  if test "$tst_proto_sigsetjmp" = "yes" ||
3454     test "$tst_macro_sigsetjmp" = "yes"; then
3455    AC_MSG_CHECKING([if sigsetjmp is compilable])
3456    AC_COMPILE_IFELSE([
3457      AC_LANG_PROGRAM([[
3458        $curl_includes_setjmp
3459      ]],[[
3460        sigjmp_buf env;
3461        if(sigsetjmp(env, 0) != 0)
3462          return 1;
3463      ]])
3464    ],[
3465      AC_MSG_RESULT([yes])
3466      tst_compi_sigsetjmp="yes"
3467    ],[
3468      AC_MSG_RESULT([no])
3469      tst_compi_sigsetjmp="no"
3470    ])
3471  fi
3472
3473  if test "$tst_compi_sigsetjmp" = "yes"; then
3474    AC_MSG_CHECKING([if sigsetjmp usage allowed])
3475    if test "x$curl_disallow_sigsetjmp" != "xyes"; then
3476      AC_MSG_RESULT([yes])
3477      tst_allow_sigsetjmp="yes"
3478    else
3479      AC_MSG_RESULT([no])
3480      tst_allow_sigsetjmp="no"
3481    fi
3482  fi
3483
3484  AC_MSG_CHECKING([if sigsetjmp might be used])
3485  if (test "$tst_proto_sigsetjmp" = "yes" ||
3486      test "$tst_macro_sigsetjmp" = "yes") &&
3487     test "$tst_compi_sigsetjmp" = "yes" &&
3488     test "$tst_allow_sigsetjmp" = "yes"; then
3489    AC_MSG_RESULT([yes])
3490    AC_DEFINE_UNQUOTED(HAVE_SIGSETJMP, 1,
3491      [Define to 1 if you have the sigsetjmp function or macro.])
3492    curl_cv_func_sigsetjmp="yes"
3493  else
3494    AC_MSG_RESULT([no])
3495    curl_cv_func_sigsetjmp="no"
3496  fi
3497])
3498
3499
3500dnl CURL_CHECK_FUNC_SOCKET
3501dnl -------------------------------------------------
3502dnl Verify if socket is available, prototyped, and
3503dnl can be compiled. If all of these are true, and
3504dnl usage has not been previously disallowed with
3505dnl shell variable curl_disallow_socket, then
3506dnl HAVE_SOCKET is defined.
3507
3508AC_DEFUN([CURL_CHECK_FUNC_SOCKET], [
3509  AC_REQUIRE([CURL_INCLUDES_WINSOCK2])
3510  AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])
3511
3512  tst_links_socket="unknown"
3513  tst_proto_socket="unknown"
3514  tst_compi_socket="unknown"
3515  tst_allow_socket="unknown"
3516
3517  AC_MSG_CHECKING([if socket can be linked])
3518  AC_LINK_IFELSE([
3519    AC_LANG_PROGRAM([[
3520      $curl_includes_winsock2
3521      $curl_includes_bsdsocket
3522      $curl_includes_sys_socket
3523    ]],[[
3524      if(socket(0, 0, 0) != 0)
3525        return 1;
3526    ]])
3527  ],[
3528    AC_MSG_RESULT([yes])
3529    tst_links_socket="yes"
3530  ],[
3531    AC_MSG_RESULT([no])
3532    tst_links_socket="no"
3533  ])
3534
3535  if test "$tst_links_socket" = "yes"; then
3536    AC_MSG_CHECKING([if socket is prototyped])
3537    AC_EGREP_CPP([socket],[
3538      $curl_includes_winsock2
3539      $curl_includes_bsdsocket
3540      $curl_includes_sys_socket
3541    ],[
3542      AC_MSG_RESULT([yes])
3543      tst_proto_socket="yes"
3544    ],[
3545      AC_MSG_RESULT([no])
3546      tst_proto_socket="no"
3547    ])
3548  fi
3549
3550  if test "$tst_proto_socket" = "yes"; then
3551    AC_MSG_CHECKING([if socket is compilable])
3552    AC_COMPILE_IFELSE([
3553      AC_LANG_PROGRAM([[
3554        $curl_includes_winsock2
3555        $curl_includes_bsdsocket
3556        $curl_includes_sys_socket
3557      ]],[[
3558        if(socket(0, 0, 0) != 0)
3559          return 1;
3560      ]])
3561    ],[
3562      AC_MSG_RESULT([yes])
3563      tst_compi_socket="yes"
3564    ],[
3565      AC_MSG_RESULT([no])
3566      tst_compi_socket="no"
3567    ])
3568  fi
3569
3570  if test "$tst_compi_socket" = "yes"; then
3571    AC_MSG_CHECKING([if socket usage allowed])
3572    if test "x$curl_disallow_socket" != "xyes"; then
3573      AC_MSG_RESULT([yes])
3574      tst_allow_socket="yes"
3575    else
3576      AC_MSG_RESULT([no])
3577      tst_allow_socket="no"
3578    fi
3579  fi
3580
3581  AC_MSG_CHECKING([if socket might be used])
3582  if test "$tst_links_socket" = "yes" &&
3583     test "$tst_proto_socket" = "yes" &&
3584     test "$tst_compi_socket" = "yes" &&
3585     test "$tst_allow_socket" = "yes"; then
3586    AC_MSG_RESULT([yes])
3587    AC_DEFINE_UNQUOTED(HAVE_SOCKET, 1,
3588      [Define to 1 if you have the socket function.])
3589    curl_cv_func_socket="yes"
3590  else
3591    AC_MSG_RESULT([no])
3592    curl_cv_func_socket="no"
3593  fi
3594])
3595
3596
3597dnl CURL_CHECK_FUNC_SOCKETPAIR
3598dnl -------------------------------------------------
3599dnl Verify if socketpair is available, prototyped, and
3600dnl can be compiled. If all of these are true, and
3601dnl usage has not been previously disallowed with
3602dnl shell variable curl_disallow_socketpair, then
3603dnl HAVE_SOCKETPAIR is defined.
3604
3605AC_DEFUN([CURL_CHECK_FUNC_SOCKETPAIR], [
3606  AC_REQUIRE([CURL_INCLUDES_SYS_SOCKET])
3607
3608  tst_links_socketpair="unknown"
3609  tst_proto_socketpair="unknown"
3610  tst_compi_socketpair="unknown"
3611  tst_allow_socketpair="unknown"
3612
3613  AC_MSG_CHECKING([if socketpair can be linked])
3614  AC_LINK_IFELSE([
3615    AC_LANG_FUNC_LINK_TRY([socketpair])
3616  ],[
3617    AC_MSG_RESULT([yes])
3618    tst_links_socketpair="yes"
3619  ],[
3620    AC_MSG_RESULT([no])
3621    tst_links_socketpair="no"
3622  ])
3623
3624  if test "$tst_links_socketpair" = "yes"; then
3625    AC_MSG_CHECKING([if socketpair is prototyped])
3626    AC_EGREP_CPP([socketpair],[
3627      $curl_includes_sys_socket
3628    ],[
3629      AC_MSG_RESULT([yes])
3630      tst_proto_socketpair="yes"
3631    ],[
3632      AC_MSG_RESULT([no])
3633      tst_proto_socketpair="no"
3634    ])
3635  fi
3636
3637  if test "$tst_proto_socketpair" = "yes"; then
3638    AC_MSG_CHECKING([if socketpair is compilable])
3639    AC_COMPILE_IFELSE([
3640      AC_LANG_PROGRAM([[
3641        $curl_includes_sys_socket
3642      ]],[[
3643        int sv[2];
3644        if(socketpair(0, 0, 0, sv) != 0)
3645          return 1;
3646      ]])
3647    ],[
3648      AC_MSG_RESULT([yes])
3649      tst_compi_socketpair="yes"
3650    ],[
3651      AC_MSG_RESULT([no])
3652      tst_compi_socketpair="no"
3653    ])
3654  fi
3655
3656  if test "$tst_compi_socketpair" = "yes"; then
3657    AC_MSG_CHECKING([if socketpair usage allowed])
3658    if test "x$curl_disallow_socketpair" != "xyes"; then
3659      AC_MSG_RESULT([yes])
3660      tst_allow_socketpair="yes"
3661    else
3662      AC_MSG_RESULT([no])
3663      tst_allow_socketpair="no"
3664    fi
3665  fi
3666
3667  AC_MSG_CHECKING([if socketpair might be used])
3668  if test "$tst_links_socketpair" = "yes" &&
3669     test "$tst_proto_socketpair" = "yes" &&
3670     test "$tst_compi_socketpair" = "yes" &&
3671     test "$tst_allow_socketpair" = "yes"; then
3672    AC_MSG_RESULT([yes])
3673    AC_DEFINE_UNQUOTED(HAVE_SOCKETPAIR, 1,
3674      [Define to 1 if you have the socketpair function.])
3675    curl_cv_func_socketpair="yes"
3676  else
3677    AC_MSG_RESULT([no])
3678    curl_cv_func_socketpair="no"
3679  fi
3680])
3681
3682
3683dnl CURL_CHECK_FUNC_STRCASECMP
3684dnl -------------------------------------------------
3685dnl Verify if strcasecmp is available, prototyped, and
3686dnl can be compiled. If all of these are true, and
3687dnl usage has not been previously disallowed with
3688dnl shell variable curl_disallow_strcasecmp, then
3689dnl HAVE_STRCASECMP is defined.
3690
3691AC_DEFUN([CURL_CHECK_FUNC_STRCASECMP], [
3692  AC_REQUIRE([CURL_INCLUDES_STRING])
3693
3694  tst_links_strcasecmp="unknown"
3695  tst_proto_strcasecmp="unknown"
3696  tst_compi_strcasecmp="unknown"
3697  tst_allow_strcasecmp="unknown"
3698
3699  AC_MSG_CHECKING([if strcasecmp can be linked])
3700  AC_LINK_IFELSE([
3701    AC_LANG_FUNC_LINK_TRY([strcasecmp])
3702  ],[
3703    AC_MSG_RESULT([yes])
3704    tst_links_strcasecmp="yes"
3705  ],[
3706    AC_MSG_RESULT([no])
3707    tst_links_strcasecmp="no"
3708  ])
3709
3710  if test "$tst_links_strcasecmp" = "yes"; then
3711    AC_MSG_CHECKING([if strcasecmp is prototyped])
3712    AC_EGREP_CPP([strcasecmp],[
3713      $curl_includes_string
3714    ],[
3715      AC_MSG_RESULT([yes])
3716      tst_proto_strcasecmp="yes"
3717    ],[
3718      AC_MSG_RESULT([no])
3719      tst_proto_strcasecmp="no"
3720    ])
3721  fi
3722
3723  if test "$tst_proto_strcasecmp" = "yes"; then
3724    AC_MSG_CHECKING([if strcasecmp is compilable])
3725    AC_COMPILE_IFELSE([
3726      AC_LANG_PROGRAM([[
3727        $curl_includes_string
3728      ]],[[
3729        if(strcasecmp("", "") != 0)
3730          return 1;
3731      ]])
3732    ],[
3733      AC_MSG_RESULT([yes])
3734      tst_compi_strcasecmp="yes"
3735    ],[
3736      AC_MSG_RESULT([no])
3737      tst_compi_strcasecmp="no"
3738    ])
3739  fi
3740
3741  if test "$tst_compi_strcasecmp" = "yes"; then
3742    AC_MSG_CHECKING([if strcasecmp usage allowed])
3743    if test "x$curl_disallow_strcasecmp" != "xyes"; then
3744      AC_MSG_RESULT([yes])
3745      tst_allow_strcasecmp="yes"
3746    else
3747      AC_MSG_RESULT([no])
3748      tst_allow_strcasecmp="no"
3749    fi
3750  fi
3751
3752  AC_MSG_CHECKING([if strcasecmp might be used])
3753  if test "$tst_links_strcasecmp" = "yes" &&
3754     test "$tst_proto_strcasecmp" = "yes" &&
3755     test "$tst_compi_strcasecmp" = "yes" &&
3756     test "$tst_allow_strcasecmp" = "yes"; then
3757    AC_MSG_RESULT([yes])
3758    AC_DEFINE_UNQUOTED(HAVE_STRCASECMP, 1,
3759      [Define to 1 if you have the strcasecmp function.])
3760    curl_cv_func_strcasecmp="yes"
3761  else
3762    AC_MSG_RESULT([no])
3763    curl_cv_func_strcasecmp="no"
3764  fi
3765])
3766
3767dnl CURL_CHECK_FUNC_STRCMPI
3768dnl -------------------------------------------------
3769dnl Verify if strcmpi is available, prototyped, and
3770dnl can be compiled. If all of these are true, and
3771dnl usage has not been previously disallowed with
3772dnl shell variable curl_disallow_strcmpi, then
3773dnl HAVE_STRCMPI is defined.
3774
3775AC_DEFUN([CURL_CHECK_FUNC_STRCMPI], [
3776  AC_REQUIRE([CURL_INCLUDES_STRING])
3777
3778  tst_links_strcmpi="unknown"
3779  tst_proto_strcmpi="unknown"
3780  tst_compi_strcmpi="unknown"
3781  tst_allow_strcmpi="unknown"
3782
3783  AC_MSG_CHECKING([if strcmpi can be linked])
3784  AC_LINK_IFELSE([
3785    AC_LANG_FUNC_LINK_TRY([strcmpi])
3786  ],[
3787    AC_MSG_RESULT([yes])
3788    tst_links_strcmpi="yes"
3789  ],[
3790    AC_MSG_RESULT([no])
3791    tst_links_strcmpi="no"
3792  ])
3793
3794  if test "$tst_links_strcmpi" = "yes"; then
3795    AC_MSG_CHECKING([if strcmpi is prototyped])
3796    AC_EGREP_CPP([strcmpi],[
3797      $curl_includes_string
3798    ],[
3799      AC_MSG_RESULT([yes])
3800      tst_proto_strcmpi="yes"
3801    ],[
3802      AC_MSG_RESULT([no])
3803      tst_proto_strcmpi="no"
3804    ])
3805  fi
3806
3807  if test "$tst_proto_strcmpi" = "yes"; then
3808    AC_MSG_CHECKING([if strcmpi is compilable])
3809    AC_COMPILE_IFELSE([
3810      AC_LANG_PROGRAM([[
3811        $curl_includes_string
3812      ]],[[
3813        if(strcmpi(0, 0) != 0)
3814          return 1;
3815      ]])
3816    ],[
3817      AC_MSG_RESULT([yes])
3818      tst_compi_strcmpi="yes"
3819    ],[
3820      AC_MSG_RESULT([no])
3821      tst_compi_strcmpi="no"
3822    ])
3823  fi
3824
3825  if test "$tst_compi_strcmpi" = "yes"; then
3826    AC_MSG_CHECKING([if strcmpi usage allowed])
3827    if test "x$curl_disallow_strcmpi" != "xyes"; then
3828      AC_MSG_RESULT([yes])
3829      tst_allow_strcmpi="yes"
3830    else
3831      AC_MSG_RESULT([no])
3832      tst_allow_strcmpi="no"
3833    fi
3834  fi
3835
3836  AC_MSG_CHECKING([if strcmpi might be used])
3837  if test "$tst_links_strcmpi" = "yes" &&
3838     test "$tst_proto_strcmpi" = "yes" &&
3839     test "$tst_compi_strcmpi" = "yes" &&
3840     test "$tst_allow_strcmpi" = "yes"; then
3841    AC_MSG_RESULT([yes])
3842    AC_DEFINE_UNQUOTED(HAVE_STRCMPI, 1,
3843      [Define to 1 if you have the strcmpi function.])
3844    curl_cv_func_strcmpi="yes"
3845  else
3846    AC_MSG_RESULT([no])
3847    curl_cv_func_strcmpi="no"
3848  fi
3849])
3850
3851
3852dnl CURL_CHECK_FUNC_STRERROR_R
3853dnl -------------------------------------------------
3854dnl Verify if strerror_r is available, prototyped, can be compiled and
3855dnl seems to work. If all of these are true, and usage has not been
3856dnl previously disallowed with shell variable curl_disallow_strerror_r,
3857dnl then HAVE_STRERROR_R is defined, as well as one of
3858dnl HAVE_GLIBC_STRERROR_R or HAVE_POSIX_STRERROR_R.
3859dnl
3860dnl glibc-style strerror_r:
3861dnl
3862dnl      char *strerror_r(int errnum, char *workbuf, size_t bufsize);
3863dnl
3864dnl  glibc-style strerror_r returns a pointer to the error string,
3865dnl  and might use the provided workbuf as a scratch area if needed. A
3866dnl  quick test on a few systems shows that it is usually not used at all.
3867dnl
3868dnl POSIX-style strerror_r:
3869dnl
3870dnl      int strerror_r(int errnum, char *resultbuf, size_t bufsize);
3871dnl
3872dnl  POSIX-style strerror_r returns 0 upon successful completion and the
3873dnl  error string in the provided resultbuf.
3874dnl
3875
3876AC_DEFUN([CURL_CHECK_FUNC_STRERROR_R], [
3877  AC_REQUIRE([CURL_INCLUDES_STDLIB])
3878  AC_REQUIRE([CURL_INCLUDES_STRING])
3879
3880  tst_links_strerror_r="unknown"
3881  tst_proto_strerror_r="unknown"
3882  tst_compi_strerror_r="unknown"
3883  tst_glibc_strerror_r="unknown"
3884  tst_posix_strerror_r="unknown"
3885  tst_allow_strerror_r="unknown"
3886  tst_works_glibc_strerror_r="unknown"
3887  tst_works_posix_strerror_r="unknown"
3888  tst_glibc_strerror_r_type_arg3="unknown"
3889  tst_posix_strerror_r_type_arg3="unknown"
3890
3891  AC_MSG_CHECKING([if strerror_r can be linked])
3892  AC_LINK_IFELSE([
3893    AC_LANG_FUNC_LINK_TRY([strerror_r])
3894  ],[
3895    AC_MSG_RESULT([yes])
3896    tst_links_strerror_r="yes"
3897  ],[
3898    AC_MSG_RESULT([no])
3899    tst_links_strerror_r="no"
3900  ])
3901
3902  if test "$tst_links_strerror_r" = "yes"; then
3903    AC_MSG_CHECKING([if strerror_r is prototyped])
3904    AC_EGREP_CPP([strerror_r],[
3905      $curl_includes_string
3906    ],[
3907      AC_MSG_RESULT([yes])
3908      tst_proto_strerror_r="yes"
3909    ],[
3910      AC_MSG_RESULT([no])
3911      tst_proto_strerror_r="no"
3912    ])
3913  fi
3914
3915  if test "$tst_proto_strerror_r" = "yes"; then
3916    AC_MSG_CHECKING([if strerror_r is compilable])
3917    AC_COMPILE_IFELSE([
3918      AC_LANG_PROGRAM([[
3919        $curl_includes_string
3920      ]],[[
3921        char s[1];
3922        if(strerror_r(0, s, 0) != 0)
3923          return 1;
3924      ]])
3925    ],[
3926      AC_MSG_RESULT([yes])
3927      tst_compi_strerror_r="yes"
3928    ],[
3929      AC_MSG_RESULT([no])
3930      tst_compi_strerror_r="no"
3931    ])
3932  fi
3933
3934  if test "$tst_compi_strerror_r" = "yes"; then
3935    AC_MSG_CHECKING([if strerror_r is glibc like])
3936    tst_glibc_strerror_r_type_arg3="unknown"
3937    for arg3 in 'size_t' 'int' 'unsigned int'; do
3938      if test "$tst_glibc_strerror_r_type_arg3" = "unknown"; then
3939        AC_COMPILE_IFELSE([
3940          AC_LANG_PROGRAM([[
3941            $curl_includes_string
3942            char *strerror_r(int errnum, char *workbuf, $arg3 bufsize);
3943          ]],[[
3944            char s[1];
3945            if(strerror_r(0, s, 0) != 0)
3946              return 1;
3947            (void)s;
3948          ]])
3949        ],[
3950          tst_glibc_strerror_r_type_arg3="$arg3"
3951        ])
3952      fi
3953    done
3954    case "$tst_glibc_strerror_r_type_arg3" in
3955      unknown)
3956        AC_MSG_RESULT([no])
3957        tst_glibc_strerror_r="no"
3958        ;;
3959      *)
3960        AC_MSG_RESULT([yes])
3961        tst_glibc_strerror_r="yes"
3962        ;;
3963    esac
3964  fi
3965
3966  dnl only do runtime verification when not cross-compiling
3967  if test "$cross_compiling" != "yes" &&
3968    test "$tst_glibc_strerror_r" = "yes"; then
3969    AC_MSG_CHECKING([if strerror_r seems to work])
3970    CURL_RUN_IFELSE([
3971      AC_LANG_PROGRAM([[
3972        $curl_includes_stdlib
3973        $curl_includes_string
3974        #include <errno.h>
3975      ]],[[
3976        char buffer[1024];
3977        char *string = 0;
3978        buffer[0] = '\0';
3979        string = strerror_r(EACCES, buffer, sizeof(buffer));
3980        if(!string)
3981          return 1; /* fail */
3982        if(!string[0])
3983          return 1; /* fail */
3984        else
3985          return 0;
3986      ]])
3987    ],[
3988      AC_MSG_RESULT([yes])
3989      tst_works_glibc_strerror_r="yes"
3990    ],[
3991      AC_MSG_RESULT([no])
3992      tst_works_glibc_strerror_r="no"
3993    ])
3994  fi
3995
3996  if test "$tst_compi_strerror_r" = "yes" &&
3997    test "$tst_works_glibc_strerror_r" != "yes"; then
3998    AC_MSG_CHECKING([if strerror_r is POSIX like])
3999    tst_posix_strerror_r_type_arg3="unknown"
4000    for arg3 in 'size_t' 'int' 'unsigned int'; do
4001      if test "$tst_posix_strerror_r_type_arg3" = "unknown"; then
4002        AC_COMPILE_IFELSE([
4003          AC_LANG_PROGRAM([[
4004            $curl_includes_string
4005            int strerror_r(int errnum, char *resultbuf, $arg3 bufsize);
4006          ]],[[
4007            char s[1];
4008            if(strerror_r(0, s, 0) != 0)
4009              return 1;
4010            (void)s;
4011          ]])
4012        ],[
4013          tst_posix_strerror_r_type_arg3="$arg3"
4014        ])
4015      fi
4016    done
4017    case "$tst_posix_strerror_r_type_arg3" in
4018      unknown)
4019        AC_MSG_RESULT([no])
4020        tst_posix_strerror_r="no"
4021        ;;
4022      *)
4023        AC_MSG_RESULT([yes])
4024        tst_posix_strerror_r="yes"
4025        ;;
4026    esac
4027  fi
4028
4029  dnl only do runtime verification when not cross-compiling
4030  if test "$cross_compiling" != "yes" &&
4031    test "$tst_posix_strerror_r" = "yes"; then
4032    AC_MSG_CHECKING([if strerror_r seems to work])
4033    CURL_RUN_IFELSE([
4034      AC_LANG_PROGRAM([[
4035        $curl_includes_stdlib
4036        $curl_includes_string
4037        #include <errno.h>
4038      ]],[[
4039        char buffer[1024];
4040        int error = 1;
4041        buffer[0] = '\0';
4042        error = strerror_r(EACCES, buffer, sizeof(buffer));
4043        if(error)
4044          return 1; /* fail */
4045        if(buffer[0] == '\0')
4046          return 1; /* fail */
4047        else
4048          return 0;
4049      ]])
4050    ],[
4051      AC_MSG_RESULT([yes])
4052      tst_works_posix_strerror_r="yes"
4053    ],[
4054      AC_MSG_RESULT([no])
4055      tst_works_posix_strerror_r="no"
4056    ])
4057  fi
4058
4059  if test "$tst_works_glibc_strerror_r" = "yes"; then
4060    tst_posix_strerror_r="no"
4061  fi
4062  if test "$tst_works_posix_strerror_r" = "yes"; then
4063    tst_glibc_strerror_r="no"
4064  fi
4065  if test "$tst_glibc_strerror_r" = "yes" &&
4066    test "$tst_works_glibc_strerror_r" != "no" &&
4067    test "$tst_posix_strerror_r" != "yes"; then
4068    tst_allow_strerror_r="check"
4069  fi
4070  if test "$tst_posix_strerror_r" = "yes" &&
4071    test "$tst_works_posix_strerror_r" != "no" &&
4072    test "$tst_glibc_strerror_r" != "yes"; then
4073    tst_allow_strerror_r="check"
4074  fi
4075  if test "$tst_allow_strerror_r" = "check"; then
4076    AC_MSG_CHECKING([if strerror_r usage allowed])
4077    if test "x$curl_disallow_strerror_r" != "xyes"; then
4078      AC_MSG_RESULT([yes])
4079      tst_allow_strerror_r="yes"
4080    else
4081      AC_MSG_RESULT([no])
4082      tst_allow_strerror_r="no"
4083    fi
4084  fi
4085
4086  AC_MSG_CHECKING([if strerror_r might be used])
4087  if test "$tst_links_strerror_r" = "yes" &&
4088     test "$tst_proto_strerror_r" = "yes" &&
4089     test "$tst_compi_strerror_r" = "yes" &&
4090     test "$tst_allow_strerror_r" = "yes"; then
4091    AC_MSG_RESULT([yes])
4092    if test "$tst_glibc_strerror_r" = "yes"; then
4093      AC_DEFINE_UNQUOTED(HAVE_STRERROR_R, 1,
4094        [Define to 1 if you have the strerror_r function.])
4095      AC_DEFINE_UNQUOTED(HAVE_GLIBC_STRERROR_R, 1,
4096        [Define to 1 if you have a working glibc-style strerror_r function.])
4097    fi
4098    if test "$tst_posix_strerror_r" = "yes"; then
4099      AC_DEFINE_UNQUOTED(HAVE_STRERROR_R, 1,
4100        [Define to 1 if you have the strerror_r function.])
4101      AC_DEFINE_UNQUOTED(HAVE_POSIX_STRERROR_R, 1,
4102        [Define to 1 if you have a working POSIX-style strerror_r function.])
4103    fi
4104    curl_cv_func_strerror_r="yes"
4105  else
4106    AC_MSG_RESULT([no])
4107    curl_cv_func_strerror_r="no"
4108  fi
4109
4110  if test "$tst_compi_strerror_r" = "yes" &&
4111     test "$tst_allow_strerror_r" = "unknown"; then
4112    AC_MSG_WARN([cannot determine strerror_r() style: edit lib/curl_config.h manually.])
4113  fi
4114])
4115
4116
4117dnl CURL_CHECK_FUNC_STRICMP
4118dnl -------------------------------------------------
4119dnl Verify if stricmp is available, prototyped, and
4120dnl can be compiled. If all of these are true, and
4121dnl usage has not been previously disallowed with
4122dnl shell variable curl_disallow_stricmp, then
4123dnl HAVE_STRICMP is defined.
4124
4125AC_DEFUN([CURL_CHECK_FUNC_STRICMP], [
4126  AC_REQUIRE([CURL_INCLUDES_STRING])
4127
4128  tst_links_stricmp="unknown"
4129  tst_proto_stricmp="unknown"
4130  tst_compi_stricmp="unknown"
4131  tst_allow_stricmp="unknown"
4132
4133  AC_MSG_CHECKING([if stricmp can be linked])
4134  AC_LINK_IFELSE([
4135    AC_LANG_FUNC_LINK_TRY([stricmp])
4136  ],[
4137    AC_MSG_RESULT([yes])
4138    tst_links_stricmp="yes"
4139  ],[
4140    AC_MSG_RESULT([no])
4141    tst_links_stricmp="no"
4142  ])
4143
4144  if test "$tst_links_stricmp" = "yes"; then
4145    AC_MSG_CHECKING([if stricmp is prototyped])
4146    AC_EGREP_CPP([stricmp],[
4147      $curl_includes_string
4148    ],[
4149      AC_MSG_RESULT([yes])
4150      tst_proto_stricmp="yes"
4151    ],[
4152      AC_MSG_RESULT([no])
4153      tst_proto_stricmp="no"
4154    ])
4155  fi
4156
4157  if test "$tst_proto_stricmp" = "yes"; then
4158    AC_MSG_CHECKING([if stricmp is compilable])
4159    AC_COMPILE_IFELSE([
4160      AC_LANG_PROGRAM([[
4161        $curl_includes_string
4162      ]],[[
4163        if(stricmp(0, 0) != 0)
4164          return 1;
4165      ]])
4166    ],[
4167      AC_MSG_RESULT([yes])
4168      tst_compi_stricmp="yes"
4169    ],[
4170      AC_MSG_RESULT([no])
4171      tst_compi_stricmp="no"
4172    ])
4173  fi
4174
4175  if test "$tst_compi_stricmp" = "yes"; then
4176    AC_MSG_CHECKING([if stricmp usage allowed])
4177    if test "x$curl_disallow_stricmp" != "xyes"; then
4178      AC_MSG_RESULT([yes])
4179      tst_allow_stricmp="yes"
4180    else
4181      AC_MSG_RESULT([no])
4182      tst_allow_stricmp="no"
4183    fi
4184  fi
4185
4186  AC_MSG_CHECKING([if stricmp might be used])
4187  if test "$tst_links_stricmp" = "yes" &&
4188     test "$tst_proto_stricmp" = "yes" &&
4189     test "$tst_compi_stricmp" = "yes" &&
4190     test "$tst_allow_stricmp" = "yes"; then
4191    AC_MSG_RESULT([yes])
4192    AC_DEFINE_UNQUOTED(HAVE_STRICMP, 1,
4193      [Define to 1 if you have the stricmp function.])
4194    curl_cv_func_stricmp="yes"
4195  else
4196    AC_MSG_RESULT([no])
4197    curl_cv_func_stricmp="no"
4198  fi
4199])
4200
4201
4202dnl CURL_CHECK_FUNC_MEMSET_S
4203dnl -------------------------------------------------
4204dnl Verify if memset_s is available, prototyped, and
4205dnl can be compiled. If all of these are true, and
4206dnl usage has not been previously disallowed with
4207dnl shell variable curl_disallow_memset_s, then
4208dnl HAVE_MEMSET_S is defined.
4209
4210AC_DEFUN([CURL_CHECK_FUNC_MEMSET_S], [
4211  AC_REQUIRE([CURL_INCLUDES_STRING])
4212
4213  tst_links_memset_s="unknown"
4214  tst_proto_memset_s="unknown"
4215  tst_compi_memset_s="unknown"
4216  tst_allow_memset_s="unknown"
4217
4218  AC_MSG_CHECKING([if memset_s can be linked])
4219  AC_LINK_IFELSE([
4220    AC_LANG_FUNC_LINK_TRY([memset_s])
4221  ],[
4222    AC_MSG_RESULT([yes])
4223    tst_links_memset_s="yes"
4224  ],[
4225    AC_MSG_RESULT([no])
4226    tst_links_memset_s="no"
4227  ])
4228
4229  if test "$tst_links_memset_s" = "yes"; then
4230    AC_MSG_CHECKING([if memset_s is prototyped])
4231    AC_EGREP_CPP([memset_s],[
4232      $curl_includes_string
4233    ],[
4234      AC_MSG_RESULT([yes])
4235      tst_proto_memset_s="yes"
4236    ],[
4237      AC_MSG_RESULT([no])
4238      tst_proto_memset_s="no"
4239    ])
4240  fi
4241
4242  if test "$tst_proto_memset_s" = "yes"; then
4243    AC_MSG_CHECKING([if memset_s is compilable])
4244    AC_COMPILE_IFELSE([
4245      AC_LANG_PROGRAM([[
4246        $curl_includes_string
4247      ]],[[
4248        char buf[2];
4249        if(memset_s(buf, sizeof(buf), 0, sizeof(buf)) != 0)
4250          return 1;
4251      ]])
4252    ],[
4253      AC_MSG_RESULT([yes])
4254      tst_compi_memset_s="yes"
4255    ],[
4256      AC_MSG_RESULT([no])
4257      tst_compi_memset_s="no"
4258    ])
4259  fi
4260
4261  if test "$tst_compi_memset_s" = "yes"; then
4262    AC_MSG_CHECKING([if memset_s usage allowed])
4263    if test "x$curl_disallow_memset_s" != "xyes"; then
4264      AC_MSG_RESULT([yes])
4265      tst_allow_memset_s="yes"
4266    else
4267      AC_MSG_RESULT([no])
4268      tst_allow_memset_s="no"
4269    fi
4270  fi
4271
4272  AC_MSG_CHECKING([if memset_s might be used])
4273  if test "$tst_links_memset_s" = "yes" &&
4274     test "$tst_proto_memset_s" = "yes" &&
4275     test "$tst_compi_memset_s" = "yes" &&
4276     test "$tst_allow_memset_s" = "yes"; then
4277    AC_MSG_RESULT([yes])
4278    AC_DEFINE_UNQUOTED(HAVE_MEMSET_S, 1,
4279      [Define to 1 if you have the memset_s function.])
4280    curl_cv_func_memset_s="yes"
4281  else
4282    AC_MSG_RESULT([no])
4283    curl_cv_func_memset_s="no"
4284  fi
4285])
4286
4287dnl CURL_RUN_IFELSE
4288dnl -------------------------------------------------
4289dnl Wrapper macro to use instead of AC_RUN_IFELSE. It
4290dnl sets LD_LIBRARY_PATH locally for this run only, from the
4291dnl CURL_LIBRARY_PATH variable. It keeps the LD_LIBRARY_PATH
4292dnl changes contained within this macro.
4293
4294AC_DEFUN([CURL_RUN_IFELSE], [
4295  if test "$curl_cv_apple" = "yes"; then
4296    AC_RUN_IFELSE([AC_LANG_SOURCE([$1])], $2, $3, $4)
4297  else
4298    oldcc=$CC
4299    old=$LD_LIBRARY_PATH
4300    CC="sh ./run-compiler"
4301    LD_LIBRARY_PATH=$CURL_LIBRARY_PATH:$old
4302    export LD_LIBRARY_PATH
4303    AC_RUN_IFELSE([AC_LANG_SOURCE([$1])], $2, $3, $4)
4304    # restore
4305    LD_LIBRARY_PATH=$old
4306    CC=$oldcc
4307  fi
4308])
4309
4310dnl CURL_COVERAGE
4311dnl --------------------------------------------------
4312dnl Switch on options and libs to build with gcc's code coverage.
4313dnl
4314
4315AC_DEFUN([CURL_COVERAGE],[
4316  AC_REQUIRE([AC_PROG_SED])
4317  AC_REQUIRE([AC_ARG_ENABLE])
4318  AC_MSG_CHECKING([for code coverage support])
4319  coverage="no"
4320  curl_coverage_msg="disabled"
4321
4322  dnl check if enabled by argument
4323  AC_ARG_ENABLE(code-coverage,
4324    AS_HELP_STRING([--enable-code-coverage], [Provide code coverage]),
4325    coverage="$enableval")
4326
4327  dnl if not gcc or clang switch off again
4328  AS_IF([test "$compiler_id" != "GNU_C" && test "$compiler_id" != "CLANG" && test "$compiler_id" != "APPLECLANG"], coverage="no" )
4329  AC_MSG_RESULT($coverage)
4330
4331  if test "x$coverage" = "xyes"; then
4332    curl_coverage_msg="enabled"
4333
4334    CPPFLAGS="$CPPFLAGS -DNDEBUG"
4335    CFLAGS="$CFLAGS -O0 -g"
4336
4337    if test "$compiler_id" = "GNU_C"; then
4338      AC_CHECK_TOOL([GCOV], [gcov], [gcov])
4339      if test -z "$GCOV"; then
4340        AC_MSG_ERROR([needs gcov for code coverage])
4341      fi
4342      AC_CHECK_PROG([LCOV], [lcov], [lcov])
4343      if test -z "$LCOV"; then
4344        AC_MSG_ERROR([needs lcov for code coverage])
4345      fi
4346      CFLAGS="$CFLAGS -ftest-coverage -fprofile-arcs"
4347      LIBS="$LIBS -lgcov"
4348    else
4349      CFLAGS="$CFLAGS -fprofile-instr-generate -fcoverage-mapping"
4350      LDFLAGS="$LDFLAGS -fprofile-instr-generate -fcoverage-mapping"
4351    fi
4352  fi
4353])
4354
4355dnl CURL_ATOMIC
4356dnl -------------------------------------------------------------
4357dnl Check if _Atomic works. But only check if stdatomic.h exists.
4358dnl
4359
4360AC_DEFUN([CURL_ATOMIC],[
4361  AC_CHECK_HEADERS(stdatomic.h, [
4362    AC_MSG_CHECKING([if _Atomic is available])
4363    AC_LINK_IFELSE([
4364      AC_LANG_PROGRAM([[
4365        $curl_includes_unistd
4366      ]],[[
4367        _Atomic int i = 0;
4368        i = 4;  // Force an atomic-write operation.
4369        (void)i;
4370      ]])
4371    ],[
4372      AC_MSG_RESULT([yes])
4373      AC_DEFINE_UNQUOTED(HAVE_ATOMIC, 1,
4374        [Define to 1 if you have _Atomic support.])
4375      tst_atomic="yes"
4376    ],[
4377      AC_MSG_RESULT([no])
4378      tst_atomic="no"
4379    ])
4380  ])
4381])
4382
4383dnl Rewrite inspired by the functionality once provided by
4384dnl AX_COMPILE_CHECK_SIZEOF. Uses the switch() "trick" to find the size of the
4385dnl given type.
4386dnl
4387dnl This code fails to compile:
4388dnl
4389dnl   switch() { case 0: case 0: }
4390dnl
4391dnl By making the second case number a boolean check, it fails to compile the
4392dnl test code when the boolean is false and thus creating a zero, making it a
4393dnl duplicated case label. If the boolean equals true, it becomes a one, the
4394dnl code compiles and we know it was a match.
4395dnl
4396dnl The check iterates over all possible sizes and stops as soon it compiles
4397dnl error-free.
4398dnl
4399dnl Usage:
4400dnl
4401dnl    CURL_SIZEOF(TYPE, [HEADERS])
4402dnl
4403
4404AC_DEFUN([CURL_SIZEOF], [
4405  dnl The #define name to make autoheader put the name in curl_config.h.in
4406  define(TYPE, translit(sizeof_$1, [a-z *], [A-Z_P]))
4407
4408  AC_MSG_CHECKING(size of $1)
4409  r=0
4410  dnl Check the sizes in a reasonable order
4411  for typesize in 8 4 2 16 1; do
4412    AC_COMPILE_IFELSE([
4413      AC_LANG_PROGRAM([[
4414        #include <sys/types.h>
4415        $2
4416      ]],[
4417        switch(0) {
4418        case 0:
4419        case (sizeof($1) == $typesize):;
4420        }
4421      ])
4422    ],[
4423      r=$typesize
4424    ],[
4425      r=0
4426    ])
4427    dnl get out of the loop once matched
4428    if test "$r" -gt 0; then
4429      break;
4430    fi
4431  done
4432  if test "$r" -eq 0; then
4433    AC_MSG_ERROR([Failed to find size of $1])
4434  fi
4435  AC_MSG_RESULT($r)
4436  dnl lowercase and underscore instead of space
4437  tname=`echo "ac_cv_sizeof_$1" | tr A-Z a-z | tr " " "_"`
4438  eval "$tname=$r"
4439
4440  AC_DEFINE_UNQUOTED(TYPE, [$r], [Size of $1 in number of bytes])
4441])