dnl CURL_CHECK_DEF (SYMBOL, [INCLUDES], [SILENT])

dnl -------------------------------------------------

dnl Use the C preprocessor to find out if the given object-style symbol

dnl is defined and get its expansion. This macro will not use default

dnl includes even if no INCLUDES argument is given. This macro will run

dnl silently when invoked with three arguments. If the expansion would

dnl result in a set of double-quoted strings the returned expansion will

dnl actually be a single double-quoted string concatenating all them.

AC_DEFUN([CURL_CHECK_DEF], [

  AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl

  AS_VAR_PUSHDEF([ac_Def], [curl_cv_def_$1])dnl

  if test -z "$SED"; then

    AC_MSG_ERROR([SED not set. Cannot continue without SED being set.])

  fi

  if test -z "$GREP"; then

    AC_MSG_ERROR([GREP not set. Cannot continue without GREP being set.])

  fi

  ifelse($3,,[AC_MSG_CHECKING([for preprocessor definition of $1])])

  tmp_exp=""

  AC_PREPROC_IFELSE([

    AC_LANG_SOURCE(

ifelse($2,,,[$2])[[

#ifdef $1

CURL_DEF_TOKEN $1

#endif

    ]])

  ],[

    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \

      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \

      "$SED" 's/.*CURL_DEF_TOKEN[[ ]][[ ]]*//' 2>/dev/null | \

      "$SED" 's/[["]][[ ]]*[["]]//g' 2>/dev/null`

    if test -z "$tmp_exp" || test "$tmp_exp" = "$1"; then

      tmp_exp=""

    fi

  ])

  if test -z "$tmp_exp"; then

    AS_VAR_SET(ac_HaveDef, no)

    ifelse($3,,[AC_MSG_RESULT([no])])

  else

    AS_VAR_SET(ac_HaveDef, yes)

    AS_VAR_SET(ac_Def, $tmp_exp)

    ifelse($3,,[AC_MSG_RESULT([$tmp_exp])])

  fi

  AS_VAR_POPDEF([ac_Def])dnl

  AS_VAR_POPDEF([ac_HaveDef])dnl

])

dnl CURL_CHECK_DEF_CC (SYMBOL, [INCLUDES], [SILENT])

dnl -------------------------------------------------

dnl Use the C compiler to find out only if the given symbol is defined

dnl or not, this can not find out its expansion. This macro will not use

dnl default includes even if no INCLUDES argument is given. This macro

dnl will run silently when invoked with three arguments.

AC_DEFUN([CURL_CHECK_DEF_CC], [

  AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl

  ifelse($3,,[AC_MSG_CHECKING([for compiler definition of $1])])

  AC_COMPILE_IFELSE([

    AC_LANG_SOURCE(

ifelse($2,,,[$2])[[

int main (void)

{

#ifdef $1

  return 0;

#else

  force compilation error

#endif

}

    ]])

  ],[

    tst_symbol_defined="yes"

  ],[

    tst_symbol_defined="no"

  ])

  if test "$tst_symbol_defined" = "yes"; then

    AS_VAR_SET(ac_HaveDef, yes)

    ifelse($3,,[AC_MSG_RESULT([yes])])

  else

    AS_VAR_SET(ac_HaveDef, no)

    ifelse($3,,[AC_MSG_RESULT([no])])

  fi

  AS_VAR_POPDEF([ac_HaveDef])dnl

])

dnl CARES_CHECK_LIB_XNET

dnl -------------------------------------------------

dnl Verify if X/Open network library is required.

AC_DEFUN([CARES_CHECK_LIB_XNET], [

  AC_MSG_CHECKING([if X/Open network library is required])

  tst_lib_xnet_required="no"

  AC_COMPILE_IFELSE([

    AC_LANG_SOURCE([[

int main (void)

{

#if defined(__hpux) && defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600)

  return 0;

#elif defined(__hpux) && defined(_XOPEN_SOURCE_EXTENDED)

  return 0;

#else

  force compilation error

#endif

}

    ]])

  ],[

    tst_lib_xnet_required="yes"

    LIBS="$LIBS -lxnet"

  ])

  AC_MSG_RESULT([$tst_lib_xnet_required])

])

dnl CARES_CHECK_AIX_ALL_SOURCE

dnl -------------------------------------------------

dnl Provides a replacement of traditional AC_AIX with

dnl an uniform behaviour across all autoconf versions,

dnl and with our own placement rules.

AC_DEFUN([CARES_CHECK_AIX_ALL_SOURCE], [

  AH_VERBATIM([_ALL_SOURCE],

    [/* Define to 1 if OS is AIX. */

#ifndef _ALL_SOURCE

#  undef _ALL_SOURCE

#endif])

  AC_BEFORE([$0], [AC_SYS_LARGEFILE])dnl

  AC_BEFORE([$0], [CARES_CONFIGURE_REENTRANT])dnl

  AC_MSG_CHECKING([if OS is AIX (to define _ALL_SOURCE)])

  AC_EGREP_CPP([yes_this_is_aix],[

#ifdef _AIX

   yes_this_is_aix

#endif

  ],[

    AC_MSG_RESULT([yes])

    AC_DEFINE(_ALL_SOURCE)

  ],[

    AC_MSG_RESULT([no])

  ])

])

dnl CURL_CHECK_HEADER_WINDOWS

dnl -------------------------------------------------

dnl Check for compilable and valid windows.h header

AC_DEFUN([CURL_CHECK_HEADER_WINDOWS], [

  AC_CACHE_CHECK([for windows.h], [ac_cv_header_windows_h], [

    AC_COMPILE_IFELSE([

      AC_LANG_PROGRAM([[

#undef inline

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

      ]],[[

#if defined(__CYGWIN__) || defined(__CEGCC__)

        HAVE_WINDOWS_H shall not be defined.

#else

        int dummy=2*WINVER;

#endif

      ]])

    ],[

      ac_cv_header_windows_h="yes"

    ],[

      ac_cv_header_windows_h="no"

    ])

  ])

  case "$ac_cv_header_windows_h" in

    yes)

      AC_DEFINE_UNQUOTED(HAVE_WINDOWS_H, 1,

        [Define to 1 if you have the windows.h header file.])

      AC_DEFINE_UNQUOTED(WIN32_LEAN_AND_MEAN, 1,

        [Define to avoid automatic inclusion of winsock.h])

      ;;

  esac

])

dnl CURL_CHECK_NATIVE_WINDOWS

dnl -------------------------------------------------

dnl Check if building a native Windows target

AC_DEFUN([CURL_CHECK_NATIVE_WINDOWS], [

  AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl

  AC_CACHE_CHECK([whether build target is a native Windows one], [ac_cv_native_windows], [

    if test "$ac_cv_header_windows_h" = "no"; then

      ac_cv_native_windows="no"

    else

      AC_COMPILE_IFELSE([

        AC_LANG_PROGRAM([[

        ]],[[

#if defined(__MINGW32__) || defined(__MINGW32CE__) || \

   (defined(_MSC_VER) && (defined(_WIN32) || defined(_WIN64)))

          int dummy=1;

#else

          Not a native Windows build target.

#endif

        ]])

      ],[

        ac_cv_native_windows="yes"

      ],[

        ac_cv_native_windows="no"

      ])

    fi

  ])

  AM_CONDITIONAL(DOING_NATIVE_WINDOWS, test "x$ac_cv_native_windows" = xyes)

])

dnl CURL_CHECK_HEADER_WINSOCK

dnl -------------------------------------------------

dnl Check for compilable and valid winsock.h header

AC_DEFUN([CURL_CHECK_HEADER_WINSOCK], [

  AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl

  AC_CACHE_CHECK([for winsock.h], [ac_cv_header_winsock_h], [

    AC_COMPILE_IFELSE([

      AC_LANG_PROGRAM([[

#undef inline

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

#include <winsock.h>

      ]],[[

#if defined(__CYGWIN__) || defined(__CEGCC__)

        HAVE_WINSOCK_H shall not be defined.

#else

        int dummy=WSACleanup();

#endif

      ]])

    ],[

      ac_cv_header_winsock_h="yes"

    ],[

      ac_cv_header_winsock_h="no"

    ])

  ])

  case "$ac_cv_header_winsock_h" in

    yes)

      AC_DEFINE_UNQUOTED(HAVE_WINSOCK_H, 1,

        [Define to 1 if you have the winsock.h header file.])

      ;;

  esac

])

dnl CURL_CHECK_HEADER_WINSOCK2

dnl -------------------------------------------------

dnl Check for compilable and valid winsock2.h header

AC_DEFUN([CURL_CHECK_HEADER_WINSOCK2], [

  AC_REQUIRE([CURL_CHECK_HEADER_WINDOWS])dnl

  AC_CACHE_CHECK([for winsock2.h], [ac_cv_header_winsock2_h], [

    AC_COMPILE_IFELSE([

      AC_LANG_PROGRAM([[

#undef inline

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

#include <winsock2.h>

      ]],[[

#if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)

        HAVE_WINSOCK2_H shall not be defined.

#else

        int dummy=2*IPPROTO_ESP;

#endif

      ]])

    ],[

      ac_cv_header_winsock2_h="yes"

    ],[

      ac_cv_header_winsock2_h="no"

    ])

  ])

  case "$ac_cv_header_winsock2_h" in

    yes)

      AC_DEFINE_UNQUOTED(HAVE_WINSOCK2_H, 1,

        [Define to 1 if you have the winsock2.h header file.])

      ;;

  esac

])

dnl CURL_CHECK_HEADER_WS2TCPIP

dnl -------------------------------------------------

dnl Check for compilable and valid ws2tcpip.h header

AC_DEFUN([CURL_CHECK_HEADER_WS2TCPIP], [

  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl

  AC_CACHE_CHECK([for ws2tcpip.h], [ac_cv_header_ws2tcpip_h], [

    AC_COMPILE_IFELSE([

      AC_LANG_PROGRAM([[

#undef inline

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

#include <winsock2.h>

#include <ws2tcpip.h>

      ]],[[

#if defined(__CYGWIN__) || defined(__CEGCC__) || defined(__MINGW32CE__)

        HAVE_WS2TCPIP_H shall not be defined.

#else

        int dummy=2*IP_PKTINFO;

#endif

      ]])

    ],[

      ac_cv_header_ws2tcpip_h="yes"

    ],[

      ac_cv_header_ws2tcpip_h="no"

    ])

  ])

  case "$ac_cv_header_ws2tcpip_h" in

    yes)

      AC_DEFINE_UNQUOTED(HAVE_WS2TCPIP_H, 1,

        [Define to 1 if you have the ws2tcpip.h header file.])

      ;;

  esac

])

dnl CURL_CHECK_HEADER_MALLOC

dnl -------------------------------------------------

dnl Check for compilable and valid malloc.h header,

dnl and check if it is needed even with stdlib.h

AC_DEFUN([CURL_CHECK_HEADER_MALLOC], [

  AC_CACHE_CHECK([for malloc.h], [ac_cv_header_malloc_h], [

    AC_COMPILE_IFELSE([

      AC_LANG_PROGRAM([[

#include <malloc.h>

      ]],[[

        void *p = malloc(10);

        void *q = calloc(10,10);

        free(p);

        free(q);

      ]])

    ],[

      ac_cv_header_malloc_h="yes"

    ],[

      ac_cv_header_malloc_h="no"

    ])

  ])

  if test "$ac_cv_header_malloc_h" = "yes"; then

    AC_DEFINE_UNQUOTED(HAVE_MALLOC_H, 1,

      [Define to 1 if you have the malloc.h header file.])

    #

    AC_COMPILE_IFELSE([

      AC_LANG_PROGRAM([[

#include <stdlib.h>

      ]],[[

        void *p = malloc(10);

        void *q = calloc(10,10);

        free(p);

        free(q);

      ]])

    ],[

      curl_cv_need_header_malloc_h="no"

    ],[

      curl_cv_need_header_malloc_h="yes"

    ])

    #

    case "$curl_cv_need_header_malloc_h" in

      yes)

        AC_DEFINE_UNQUOTED(NEED_MALLOC_H, 1,

          [Define to 1 if you need the malloc.h header file even with stdlib.h])

        ;;

    esac

  fi

])

dnl CURL_CHECK_HEADER_MEMORY

dnl -------------------------------------------------

dnl Check for compilable and valid memory.h header,

dnl and check if it is needed even with stdlib.h for

dnl memory related functions.

AC_DEFUN([CURL_CHECK_HEADER_MEMORY], [

  AC_CACHE_CHECK([for memory.h], [ac_cv_header_memory_h], [

    AC_COMPILE_IFELSE([

      AC_LANG_PROGRAM([[

#include <memory.h>

      ]],[[

        void *p = malloc(10);

        void *q = calloc(10,10);

        free(p);

        free(q);

      ]])

    ],[

      ac_cv_header_memory_h="yes"

    ],[

      ac_cv_header_memory_h="no"

    ])

  ])

  if test "$ac_cv_header_memory_h" = "yes"; then

    AC_DEFINE_UNQUOTED(HAVE_MEMORY_H, 1,

      [Define to 1 if you have the memory.h header file.])

    #

    AC_COMPILE_IFELSE([

      AC_LANG_PROGRAM([[

#include <stdlib.h>

      ]],[[

        void *p = malloc(10);

        void *q = calloc(10,10);

        free(p);

        free(q);

      ]])

    ],[

      curl_cv_need_header_memory_h="no"

    ],[

      curl_cv_need_header_memory_h="yes"

    ])

    #

    case "$curl_cv_need_header_memory_h" in

      yes)

        AC_DEFINE_UNQUOTED(NEED_MEMORY_H, 1,

          [Define to 1 if you need the memory.h header file even with stdlib.h])

        ;;

    esac

  fi

])

dnl CURL_CHECK_FUNC_GETNAMEINFO

dnl -------------------------------------------------

dnl Test if the getnameinfo function is available,

dnl and check the types of five of its arguments.

dnl If the function succeeds HAVE_GETNAMEINFO will be

dnl defined, defining the types of the arguments in

dnl GETNAMEINFO_TYPE_ARG1, GETNAMEINFO_TYPE_ARG2,

dnl GETNAMEINFO_TYPE_ARG46 and GETNAMEINFO_TYPE_ARG7,

dnl and also defining the type qualifier of first

dnl argument in GETNAMEINFO_QUAL_ARG1.

AC_DEFUN([CURL_CHECK_FUNC_GETNAMEINFO], [

  AC_REQUIRE([CURL_CHECK_HEADER_WS2TCPIP])dnl

  AC_CHECK_HEADERS(sys/types.h sys/socket.h netdb.h)

  #

  AC_MSG_CHECKING([for getnameinfo])

  AC_LINK_IFELSE([

    AC_LANG_FUNC_LINK_TRY([getnameinfo])

  ],[

    AC_MSG_RESULT([yes])

    curl_cv_getnameinfo="yes"

  ],[

    AC_MSG_RESULT([no])

    curl_cv_getnameinfo="no"

  ])

  #

  if test "$curl_cv_getnameinfo" != "yes"; then

    AC_MSG_CHECKING([deeper for getnameinfo])

    AC_LINK_IFELSE([

      AC_LANG_PROGRAM([[

      ]],[[

        getnameinfo();

      ]])

    ],[

      AC_MSG_RESULT([yes])

      curl_cv_getnameinfo="yes"

    ],[

      AC_MSG_RESULT([but still no])

      curl_cv_getnameinfo="no"

    ])

  fi

  #

  if test "$curl_cv_getnameinfo" != "yes"; then

    AC_MSG_CHECKING([deeper and deeper for getnameinfo])

    AC_LINK_IFELSE([

      AC_LANG_PROGRAM([[

#undef inline

#ifdef HAVE_WINDOWS_H

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

#ifdef HAVE_WINSOCK2_H

#include <winsock2.h>

#ifdef HAVE_WS2TCPIP_H

#include <ws2tcpip.h>

#endif

#endif

#else

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#ifdef HAVE_NETDB_H

#include <netdb.h>

#endif

#endif

      ]],[[

        getnameinfo(0, 0, 0, 0, 0, 0, 0);

      ]])

    ],[

      AC_MSG_RESULT([yes])

      curl_cv_getnameinfo="yes"

    ],[

      AC_MSG_RESULT([but still no])

      curl_cv_getnameinfo="no"

    ])

  fi

  #

  if test "$curl_cv_getnameinfo" = "yes"; then

    AC_CACHE_CHECK([types of arguments for getnameinfo],

      [curl_cv_func_getnameinfo_args], [

      curl_cv_func_getnameinfo_args="unknown"

      for gni_arg1 in 'struct sockaddr *' 'const struct sockaddr *' 'void *'; do

        for gni_arg2 in 'socklen_t' 'size_t' 'int'; do

          for gni_arg46 in 'size_t' 'int' 'socklen_t' 'unsigned int' 'DWORD'; do

            for gni_arg7 in 'int' 'unsigned int'; do

              if test "$curl_cv_func_getnameinfo_args" = "unknown"; then

                AC_COMPILE_IFELSE([

                  AC_LANG_PROGRAM([[

#undef inline

#ifdef HAVE_WINDOWS_H

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#if (!defined(_WIN32_WINNT)) || (_WIN32_WINNT < 0x0501)

#undef _WIN32_WINNT

#define _WIN32_WINNT 0x0501

#endif

#include <windows.h>

#ifdef HAVE_WINSOCK2_H

#include <winsock2.h>

#ifdef HAVE_WS2TCPIP_H

#include <ws2tcpip.h>

#endif

#endif

#define GNICALLCONV WSAAPI

#else

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#ifdef HAVE_NETDB_H

#include <netdb.h>

#endif

#define GNICALLCONV

#endif

                    extern int GNICALLCONV getnameinfo($gni_arg1, $gni_arg2,

                                           char *, $gni_arg46,

                                           char *, $gni_arg46,

                                           $gni_arg7);

                  ]],[[

                    $gni_arg2 salen=0;

                    $gni_arg46 hostlen=0;

                    $gni_arg46 servlen=0;

                    $gni_arg7 flags=0;

                    int res = getnameinfo(0, salen, 0, hostlen, 0, servlen, flags);

                  ]])

                ],[

                  curl_cv_func_getnameinfo_args="$gni_arg1,$gni_arg2,$gni_arg46,$gni_arg7"

                ])

              fi

            done

          done

        done

      done

    ]) # AC-CACHE-CHECK

    if test "$curl_cv_func_getnameinfo_args" = "unknown"; then

      AC_MSG_WARN([Cannot find proper types to use for getnameinfo args])

      AC_MSG_WARN([HAVE_GETNAMEINFO will not be defined])

    else

      gni_prev_IFS=$IFS; IFS=','

      set dummy `echo "$curl_cv_func_getnameinfo_args" | sed 's/\*/\*/g'`

      IFS=$gni_prev_IFS

      shift

      #

      gni_qual_type_arg1=$[1]

      #

      AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG2, $[2],

        [Define to the type of arg 2 for getnameinfo.])

      AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG46, $[3],

        [Define to the type of args 4 and 6 for getnameinfo.])

      AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG7, $[4],

        [Define to the type of arg 7 for getnameinfo.])

      #

      prev_sh_opts=$-

      #

      case $prev_sh_opts in

        *f*)

          ;;

        *)

          set -f

          ;;

      esac

      #

      case "$gni_qual_type_arg1" in

        const*)

          gni_qual_arg1=const

          gni_type_arg1=`echo $gni_qual_type_arg1 | sed 's/^const //'`

        ;;

        *)

          gni_qual_arg1=

          gni_type_arg1=$gni_qual_type_arg1

        ;;

      esac

      #

      AC_DEFINE_UNQUOTED(GETNAMEINFO_QUAL_ARG1, $gni_qual_arg1,

        [Define to the type qualifier of arg 1 for getnameinfo.])

      AC_DEFINE_UNQUOTED(GETNAMEINFO_TYPE_ARG1, $gni_type_arg1,

        [Define to the type of arg 1 for getnameinfo.])

      #

      case $prev_sh_opts in

        *f*)

          ;;

        *)

          set +f

          ;;

      esac

      #

      AC_DEFINE_UNQUOTED(HAVE_GETNAMEINFO, 1,

        [Define to 1 if you have the getnameinfo function.])

      ac_cv_func_getnameinfo="yes"

    fi

  fi

])

dnl TYPE_SOCKADDR_STORAGE

dnl -------------------------------------------------

dnl Check for struct sockaddr_storage. Most IPv6-enabled

dnl hosts have it, but AIX 4.3 is one known exception.

AC_DEFUN([TYPE_SOCKADDR_STORAGE],

[

   AC_CHECK_TYPE([struct sockaddr_storage],

        AC_DEFINE(HAVE_STRUCT_SOCKADDR_STORAGE, 1,

                  [if struct sockaddr_storage is defined]), ,

   [

#undef inline

#ifdef HAVE_WINDOWS_H

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

#ifdef HAVE_WINSOCK2_H

#include <winsock2.h>

#endif

#else

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#ifdef HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#ifdef HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#endif

   ])

])

dnl CURL_CHECK_NI_WITHSCOPEID

dnl -------------------------------------------------

dnl Check for working NI_WITHSCOPEID in getnameinfo()

AC_DEFUN([CURL_CHECK_NI_WITHSCOPEID], [

  AC_REQUIRE([CURL_CHECK_FUNC_GETNAMEINFO])dnl

  AC_REQUIRE([TYPE_SOCKADDR_STORAGE])dnl

  AC_CHECK_HEADERS(stdio.h sys/types.h sys/socket.h \

                   netdb.h netinet/in.h arpa/inet.h)

  #

  AC_CACHE_CHECK([for working NI_WITHSCOPEID],

    [ac_cv_working_ni_withscopeid], [

    AC_RUN_IFELSE([

      AC_LANG_PROGRAM([[

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_STDIO_H

#include <stdio.h>

#endif

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#ifdef HAVE_NETDB_H

#include <netdb.h>

#endif

#ifdef HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#ifdef HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

      ]],[[

#if defined(NI_WITHSCOPEID) && defined(HAVE_GETNAMEINFO)

#ifdef HAVE_STRUCT_SOCKADDR_STORAGE

        struct sockaddr_storage sa;

#else

        unsigned char sa[256];

#endif

        char hostbuf[NI_MAXHOST];

        int rc;

        GETNAMEINFO_TYPE_ARG2 salen = (GETNAMEINFO_TYPE_ARG2)sizeof(sa);

        GETNAMEINFO_TYPE_ARG46 hostlen = (GETNAMEINFO_TYPE_ARG46)sizeof(hostbuf);

        GETNAMEINFO_TYPE_ARG7 flags = NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;

        int fd = socket(AF_INET6, SOCK_STREAM, 0);

        if(fd < 0) {

          perror("socket()");

          return 1; /* Error creating socket */

        }

        rc = getsockname(fd, (GETNAMEINFO_TYPE_ARG1)&sa, &salen);

        if(rc) {

          perror("getsockname()");

          return 2; /* Error retrieving socket name */

        }

        rc = getnameinfo((GETNAMEINFO_TYPE_ARG1)&sa, salen, hostbuf, hostlen, NULL, 0, flags);

        if(rc) {

          printf("rc = %s\n", gai_strerror(rc));

          return 3; /* Error translating socket address */

        }

        return 0; /* Ok, NI_WITHSCOPEID works */

#else

        return 4; /* Error, NI_WITHSCOPEID not defined or no getnameinfo() */

#endif

      ]]) # AC-LANG-PROGRAM

    ],[

      # Exit code == 0. Program worked.

      ac_cv_working_ni_withscopeid="yes"

    ],[

      # Exit code != 0. Program failed.

      ac_cv_working_ni_withscopeid="no"

    ],[

      # Program is not run when cross-compiling. So we assume

      # NI_WITHSCOPEID will work if we are able to compile it.

      AC_COMPILE_IFELSE([

        AC_LANG_PROGRAM([[

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

        ]],[[

          unsigned int dummy= NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;

        ]])

      ],[

        ac_cv_working_ni_withscopeid="yes"

      ],[

        ac_cv_working_ni_withscopeid="no"

      ]) # AC-COMPILE-IFELSE

    ]) # AC-RUN-IFELSE

  ]) # AC-CACHE-CHECK

  case "$ac_cv_working_ni_withscopeid" in

    yes)

      AC_DEFINE(HAVE_NI_WITHSCOPEID, 1,

        [Define to 1 if NI_WITHSCOPEID exists and works.])

      ;;

  esac

])

dnl CURL_CHECK_FUNC_RECV

dnl -------------------------------------------------

dnl Test if the socket recv() function is available,

dnl and check its return type and the types of its

dnl arguments. If the function succeeds HAVE_RECV

dnl will be defined, defining the types of the arguments

dnl in RECV_TYPE_ARG1, RECV_TYPE_ARG2, RECV_TYPE_ARG3

dnl and RECV_TYPE_ARG4, defining the type of the function

dnl return value in RECV_TYPE_RETV.

AC_DEFUN([CURL_CHECK_FUNC_RECV], [

  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK])dnl

  AC_REQUIRE([CURL_CHECK_HEADER_WINSOCK2])dnl

  AC_CHECK_HEADERS(sys/types.h sys/socket.h)

  #

  AC_MSG_CHECKING([for recv])

  AC_LINK_IFELSE([

    AC_LANG_PROGRAM([[

#undef inline

#ifdef HAVE_WINDOWS_H

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

#ifdef HAVE_WINSOCK2_H

#include <winsock2.h>

#else

#ifdef HAVE_WINSOCK_H

#include <winsock.h>

#endif

#endif

#else

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#endif

    ]],[[

      recv(0, 0, 0, 0);

    ]])

  ],[

    AC_MSG_RESULT([yes])

    curl_cv_recv="yes"

  ],[

    AC_MSG_RESULT([no])

    curl_cv_recv="no"

  ])

  #

  if test "$curl_cv_recv" = "yes"; then

    AC_CACHE_CHECK([types of args and return type for recv],

      [curl_cv_func_recv_args], [

      curl_cv_func_recv_args="unknown"

      for recv_retv in 'int' 'ssize_t'; do

        for recv_arg1 in 'int' 'ssize_t' 'SOCKET'; do

          for recv_arg2 in 'char *' 'void *'; do

            for recv_arg3 in 'size_t' 'int' 'socklen_t' 'unsigned int'; do

              for recv_arg4 in 'int' 'unsigned int'; do

                if test "$curl_cv_func_recv_args" = "unknown"; then

                  AC_COMPILE_IFELSE([

                    AC_LANG_PROGRAM([[

#undef inline

#ifdef HAVE_WINDOWS_H

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

#ifdef HAVE_WINSOCK2_H

#include <winsock2.h>

#else

#ifdef HAVE_WINSOCK_H

#include <winsock.h>

#endif

#endif

#define RECVCALLCONV PASCAL

#else

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#define RECVCALLCONV

#endif

                      extern $recv_retv RECVCALLCONV

                      recv($recv_arg1, $recv_arg2, $recv_arg3, $recv_arg4);

                    ]],[[

                      $recv_arg1 s=0;

                      $recv_arg2 buf=0;

                      $recv_arg3 len=0;

                      $recv_arg4 flags=0;

                      $recv_retv res = recv(s, buf, len, flags);

                    ]])

                  ],[

                    curl_cv_func_recv_args="$recv_arg1,$recv_arg2,$recv_arg3,$recv_arg4,$recv_retv"

                  ])

                fi

              done

            done

          done

        done

      done

    ]) # AC-CACHE-CHECK

    if test "$curl_cv_func_recv_args" = "unknown"; then

      AC_MSG_ERROR([Cannot find proper types to use for recv args])

    else

      recv_prev_IFS=$IFS; IFS=','

      set dummy `echo "$curl_cv_func_recv_args" | sed 's/\*/\*/g'`

      IFS=$recv_prev_IFS

      shift

      #

      AC_DEFINE_UNQUOTED(RECV_TYPE_ARG1, $[1],