# This file is part of libmicrohttpd.

# (C) 2006-2017 Christian Grothoff (and other contributing authors)

#

# libmicrohttpd is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published

# by the Free Software Foundation; either version 3, or (at your

# option) any later version.

#

# libmicrohttpd is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with libmicrohttpd; see the file COPYING.  If not, write to the

# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

# Boston, MA 02110-1301, USA.

#

#

# Process this file with autoconf to produce a configure script.

#

#

AC_PREREQ([2.64])

LT_PREREQ([2.4.0])

AC_INIT([GNU Libmicrohttpd],[0.9.59],[libmicrohttpd@gnu.org])

AM_INIT_AUTOMAKE([silent-rules] [subdir-objects])

AC_CONFIG_HEADERS([MHD_config.h])

AC_CONFIG_MACRO_DIR([m4])

LIB_VERSION_CURRENT=58

LIB_VERSION_REVISION=0

LIB_VERSION_AGE=46

AC_SUBST(LIB_VERSION_CURRENT)

AC_SUBST(LIB_VERSION_REVISION)

AC_SUBST(LIB_VERSION_AGE)

AC_MSG_CHECKING([[whether z/OS special settings are required]])

if test `uname -s` = "OS/390"

then

# configure binaries for z/OS

  if test -z "$CC"

  then

    CC=`pwd`"/contrib/xcc"

    chmod +x $CC || true

  fi

  if test -z "$CPP"

  then

    CPP="c89 -E"

  fi

  if test -z "$CXXCPP"

  then

    CXXCPP="c++ -E -+"

  fi

  AC_MSG_RESULT([[yes]])

#  _CCC_CCMODE=1

#  _C89_CCMODE=1

else

  AC_MSG_RESULT([[no]])

fi

# Checks for programs.

AC_PROG_AWK

AC_PROG_INSTALL

AC_PROG_LN_S

AC_PROG_MAKE_SET

AC_CANONICAL_HOST

AC_PROG_CC_STDC

MHD_SYS_EXT

LT_INIT([win32-dll])

LT_LANG([Windows Resource])

# Workaround for libgcrypt

AS_IF([[test "x$lt_sysroot" != "x" && test "x$SYSROOT" = "x"]], [[SYSROOT="$lt_sysroot"]])

PACKAGE_VERSION_MAJOR='m4_car(m4_unquote(m4_split(AC_PACKAGE_VERSION, [\.])))'

PACKAGE_VERSION_MINOR='m4_argn(2, m4_unquote(m4_split(AC_PACKAGE_VERSION, [\.])))'

PACKAGE_VERSION_SUBMINOR='m4_argn(3, m4_unquote(m4_split(AC_PACKAGE_VERSION, [\.])))'

AS_VAR_ARITH([MHD_W32_DLL_SUFF],[[$LIB_VERSION_CURRENT - $LIB_VERSION_AGE]])

AC_SUBST([PACKAGE_VERSION_MAJOR])

AC_SUBST([PACKAGE_VERSION_MINOR])

AC_SUBST([PACKAGE_VERSION_SUBMINOR])

AC_SUBST([MHD_W32_DLL_SUFF])

AC_CONFIG_FILES([src/microhttpd/microhttpd_dll_res.rc])

MHD_LIB_CPPFLAGS=""

MHD_LIB_CFLAGS=""

MHD_LIB_LDFLAGS=""

MHD_LIBDEPS=""

# for pkg-config

MHD_REQ_PRIVATE=''

MHD_LIBDEPS_PKGCFG=''

AH_TEMPLATE([[HAVE_STDBOOL_H]], [Define to 1 if you have the <stdbool.h> header file and <stdbool.h> defines 'bool' type.])

AH_TEMPLATE([[HAVE_REAL_BOOL]], [Define to 1 if you have the real boolean type.])

AH_TEMPLATE([[bool]], [Define to type name which will be used as boolean type.])

AC_CHECK_HEADER([stdbool.h],

  [

   AC_CHECK_TYPE([bool],

     [

      AC_DEFINE([[HAVE_STDBOOL_H]], [[1]])

      AC_DEFINE([[HAVE_REAL_BOOL]], [[1]])

     ],

     [

      AC_MSG_WARN([[Header <stdbool.h> is present, but "bool" type cannot be detected. Check compiler flags.]])

      AC_DEFINE([[bool]], [[int]])

     ], [

#include <stdbool.h>

        ]

   )

  ],

  [

   AC_CHECK_TYPE([bool],

     [AC_DEFINE([[HAVE_REAL_BOOL]], [[1]])],

     [

      AC_CHECK_TYPE([_Bool],

        [

         AC_DEFINE([[HAVE_REAL_BOOL]], [[1]])

         AC_DEFINE([[bool]], [[_Bool]])

        ],

        [

         AC_DEFINE([[bool]], [[int]])

        ], []

      )

     ], []

   )

  ],

  [AC_INCLUDES_DEFAULT]

)

AC_CACHE_CHECK([[whether "true" is defined or builtin]], [[mhd_cv_macro_true_defined]],

  [AC_COMPILE_IFELSE(

     [AC_LANG_PROGRAM(

        [[

#ifdef HAVE_STDBOOL_H

#include <stdbool.h>

#endif

        ]], [[

#if defined(true)

    /* dummy */

#else

    (void)true;

#endif

        ]])

     ], [[mhd_cv_macro_true_defined='yes']], [[mhd_cv_macro_true_defined='no']])

  ])

AS_VAR_IF([[mhd_cv_macro_true_defined]], [["yes"]], [[:]],

  [AC_DEFINE([[true]],[[(!0)]], [Define to value interpreted by compiler as boolean "true", if "true" is not defined by system headers.])])

AC_CACHE_CHECK([[whether "false" is defined or builtin]], [[mhd_cv_macro_false_defined]],

  [AC_COMPILE_IFELSE(

     [AC_LANG_PROGRAM(

        [[

#ifdef HAVE_STDBOOL_H

#include <stdbool.h>

#endif

        ]], [[

#if !defined(false)

    (void)false;

#else

    /* dummy */

#endif

        ]])

     ], [[mhd_cv_macro_false_defined='yes']], [[mhd_cv_macro_false_defined='no']])

  ])

AS_VAR_IF([[mhd_cv_macro_false_defined]], [["yes"]], [[:]],

  [AC_DEFINE([[false]],[[0]], [Define to value interpreted by compiler as boolean "false", if "false" is not defined by system headers.])])

AC_CACHE_CHECK([[whether "true" and "false" could be used]], [[mhd_cv_macro_true_false_valid]],

  [AC_COMPILE_IFELSE(

     [AC_LANG_PROGRAM(

        [[

#ifdef HAVE_STDBOOL_H

#include <stdbool.h>

#endif

        ]], [[

          int var1[true ? 1 : -1] = { 1 };

          int var2[false ? -1 : 1] = { 2 };

          int var3[!true ? -1 : 1] = { 3 };

          int var4[!false ? 1 : -1] = { 4 };

          if (var1[0] == var2[0] || var3[0] == var4[0])

            return 1;

        ]])

     ], [[mhd_cv_macro_true_false_valid='yes']], [[mhd_cv_macro_true_false_valid='no']])

  ])

AS_VAR_IF([[mhd_cv_macro_true_false_valid]], [["yes"]], [[:]],

  [AC_MSG_ERROR([[Value of "true" or value of "false" is not valid. Check config.log for details.]])])

AX_CHECK_COMPILE_FLAG([[-Werror=attributes]],

  [

   save_CFLAGS="$CFLAGS"

   CFLAGS="$CFLAGS -Werror=attributes"

   AC_MSG_CHECKING([[whether -Werror=attributes actually works]])

   AC_COMPILE_IFELSE([AC_LANG_PROGRAM(

       [[__attribute__((non_existing_attrb_dummy)) int SimpleFunc(void) {return 3;}]], [[int r = SimpleFunc(); if (r) return r;]])],

     [

       AC_MSG_RESULT([[no]])

       errattr_CFLAGS=""

     ], [

       AC_MSG_RESULT([[yes]])

       errattr_CFLAGS="-Werror=attributes"

     ])

   CFLAGS="$save_CFLAGS"

  ],

                      [[errattr_CFLAGS=""]], [], [])

AC_MSG_CHECKING([[for function inline keywords suppoted by $CC]])

save_CFLAGS="$CFLAGS"

CFLAGS="$CFLAGS $errattr_CFLAGS"

inln_prfx="none"

# Prefer always inline functions

for inln_prfx_chk in InlineWithAttr __forceinline inline __inline__ __inline _inline _Inline; do

  # Try to link to avoid "symbol undefined" problems at build time

  AS_IF([[test "x$inln_prfx_chk" = "xInlineWithAttr"]],

    [

     AS_IF([[test "x$errattr_CFLAGS" = "x"]],

       [[ # Skip test with attribute as negative result can't be detected

          inln_prfx_chk="__forceinline" # use next value

       ]],[[inln_prfx_chk="inline __attribute__((always_inline))"]])

    ])

  AC_LINK_IFELSE(

    [

     AC_LANG_PROGRAM(

       [[

#ifdef __cplusplus

#error This test is only for C.

choke me

#endif

#ifdef HAVE_STDBOOL_H

#include <stdbool.h>

#endif

         static $inln_prfx_chk bool cmpfn(int x, int y)

         { return x > y; }

         static $inln_prfx_chk int sumfn(int x, int y)

         { return x + y; }

       ]],[[

       int a = 1, b = 100, c;

       if (cmpfn(a, b))

         c = sumfn(a, b);

       else

         c = 0 - sumfn(a, b);

       ]])

    ],

    [[ inln_prfx="$inln_prfx_chk" ]])

  test "x$inln_prfx" != "xnone" && break

done

AS_IF([[test "x$inln_prfx" != "xnone"]],

      [

       AC_DEFINE([INLINE_FUNC],[1],[Define to 1 if your C compiler supports inline functions.])

       AC_DEFINE_UNQUOTED([_MHD_static_inline],[static $inln_prfx],[Define to prefix which will be used with MHD static inline functions.])

      ], [

       AC_DEFINE([_MHD_static_inline],[static],[Define to prefix which will be used with MHD static inline functions.])

      ])

AC_MSG_RESULT([[$inln_prfx]])

CFLAGS="$save_CFLAGS"

# Check system type

shutdown_trig_select='no'

AC_MSG_CHECKING([[for target host OS]])

case "$host_os" in

*darwin* | *rhapsody* | *macosx*)

     AC_DEFINE_UNQUOTED(OSX,1,[This is an OS X system])

     CFLAGS="-no-cpp-precomp -fno-common $CFLAGS"

     mhd_host_os='Darwin'

     AC_MSG_RESULT([[$mhd_host_os]])

     ;;

freebsd*)

     AC_DEFINE_UNQUOTED(SOMEBSD,1,[This is a BSD system])

     AC_DEFINE_UNQUOTED(FREEBSD,1,[This is a FreeBSD system])

     mhd_host_os='FreeBSD'

     AC_MSG_RESULT([[$mhd_host_os]])

     ;;

openbsd*)

     AC_DEFINE_UNQUOTED(SOMEBSD,1,[This is a BSD system])

     AC_DEFINE_UNQUOTED(OPENBSD,1,[This is an OpenBSD system])

     mhd_host_os='OpenBSD'

     AC_MSG_RESULT([[$mhd_host_os]])

     ;;

netbsd*)

     AC_DEFINE_UNQUOTED(SOMEBSD,1,[This is a BSD system])

     AC_DEFINE_UNQUOTED(NETBSD,1,[This is a NetBSD system])

     mhd_host_os='NetBSD'

     AC_MSG_RESULT([[$mhd_host_os]])

     ;;

*solaris*)

     AC_DEFINE_UNQUOTED(SOLARIS,1,[This is a Solaris system])

     AC_DEFINE_UNQUOTED(_REENTRANT,1,[Need with solaris or errno doesnt work])

     mhd_host_os='Solaris'

     AC_MSG_RESULT([[$mhd_host_os]])

     AC_SEARCH_LIBS(gethostbyname, nsl)

     AC_SEARCH_LIBS(socket, socket)

     ;;

*arm-linux*)

     AC_DEFINE_UNQUOTED(LINUX,1,[This is a Linux kernel])

     mhd_host_os='ARM Linux'

     AC_MSG_RESULT([[$mhd_host_os]])

     CFLAGS="-fPIC -pipe $CFLAGS"

     ;;

*linux*)

     AC_DEFINE_UNQUOTED(LINUX,1,[This is a Linux kernel])

     mhd_host_os='Linux'

     AC_MSG_RESULT([[$mhd_host_os]])

     ;;

*cygwin*)

     AC_DEFINE_UNQUOTED(CYGWIN,1,[This is a Cygwin system])

     mhd_host_os='Windows (Cygwin)'

     AC_MSG_RESULT([[$mhd_host_os]])

     os_is_windows=yes

     ;;

*mingw*)

     AC_DEFINE_UNQUOTED(MINGW,1,[This is a MinGW system])

     AC_DEFINE_UNQUOTED(WINDOWS,1,[This is a Windows system])

     mhd_host_os='Windows (MinGW)'

     AC_MSG_RESULT([[$mhd_host_os]])

     LIBS="$LIBS -lws2_32"

     AC_CHECK_HEADERS([winsock2.h ws2tcpip.h], [], [AC_MSG_ERROR([[Winsock2 headers are required for W32]])], [AC_INCLUDES_DEFAULT])

     AC_CACHE_CHECK([for MS lib utility], [ac_cv_use_ms_lib_tool],

       [[mslibcheck=`lib 2>&1`

        if [[ $mslibcheck = "Microsoft (R) Library Manager"* ]]; then

          ac_cv_use_ms_lib_tool=yes

        else

          ac_cv_use_ms_lib_tool=no

        fi

         ]])

     if test "x$ac_cv_use_ms_lib_tool" = "xyes"; then

       AC_SUBST([MS_LIB_TOOL], [[lib]])

     fi

     AC_SUBST([lt_cv_objdir])

     os_is_windows=yes

     os_is_native_w32=yes

     ;;

*openedition*)

     AC_DEFINE_UNQUOTED(OS390,1,[This is a OS/390 system])

     mhd_host_os='OS/390'

     AC_MSG_RESULT([[$mhd_host_os]])

    ;;

gnu*)

     AC_DEFINE([[GNU_HURD]], [[1]], [Define to `1' if host machine runs on GNU Hurd.])

     mhd_host_os='GNU Hurd'

     AC_MSG_RESULT([[$mhd_host_os]])

    ;;

*)

     mhd_host_os='unrecognised OS'

     AC_MSG_RESULT([[$mhd_host_os]])

     AC_MSG_WARN([Unrecognised OS $host_os])

     AC_DEFINE_UNQUOTED(OTHEROS,1,[Some strange OS])

;;

esac

AM_CONDITIONAL([CYGWIN_TARGET], [[test "x$os_is_windows" = "xyes" && \

                                  test "x${os_is_native_w32}" != "xyes"]])

AC_ARG_WITH([threads],

   [AS_HELP_STRING([--with-threads=LIB],[choose threading library (posix, w32, auto) [auto]])],

   [], [with_threads='auto'])

AS_CASE([[$with_threads]],

  [[win32]], [[with_threads='w32']],

  [[pthreads]], [[with_threads='posix']],

  [[posix]], [[:]],

  [[w32]], [[:]],

  [[auto]], [[:]],

    [AC_MSG_ERROR([[incorrect parameter "$with_threads" specified for --with-threads]])]

)

# Check for posix threads support, regardless of configure parameters as

# testsuite use only posix threads.

AX_PTHREAD(

  [

    mhd_have_posix_threads='yes'

    AC_DEFINE([[HAVE_PTHREAD_H]],[[1]],[Define to 1 if you have the <pthread.h> header file.])

  ],[[mhd_have_posix_threads='no']])

AM_CONDITIONAL([HAVE_POSIX_THREADS],[test "x$mhd_have_posix_threads" = "xyes"])

mhd_have_w32_threads='no'

AS_IF([[test "x$with_threads" = "xauto"]],

 [

 AS_IF([[test "x$os_is_windows" = "xyes"]],

   [

    AC_MSG_CHECKING([[for W32 threads]])

    AC_LINK_IFELSE(

      [AC_LANG_PROGRAM([[

#include <windows.h>

         ]], [ HANDLE h = CreateThread(NULL, 0, NULL, NULL, 0, NULL);])]

      , [[mhd_have_w32_threads='yes']], [[mhd_have_w32_threads='no']]

      )

    AC_MSG_RESULT([[$mhd_have_w32_threads]])

   ])

 ]

)

AC_MSG_CHECKING([[for threading lib to use with libmicrohttpd]])

AS_IF([[test "x$with_threads" = "xposix"]],

  [ # forced posix threads

    AS_IF([[test "x$mhd_have_posix_threads" = "xyes"]], [[ USE_THREADS='posix' ]],

      [ AS_IF([[test "x$os_is_windows" = "xyes"]] ,

          [ AC_MSG_ERROR([[Posix threads are not available. Try to configure --with-threads=auto]])],

          [ AC_MSG_ERROR([[No threading lib is available. Consider installing pthreads]])] )

      ])

    ] ,

  [[ test "x$with_threads" = "xw32" ]] ,

  [ # forced w32 threads

    AS_IF([[test "x$mhd_have_w32_threads" = "xyes"]],

      [[ USE_THREADS='w32' ]],

      [ AC_MSG_ERROR([[W32 threads are not available. Try to configure --with-threads=auto]])])

    ] ,

    [ # automatic threads lib selection

      AS_IF([[test "x$os_is_native_w32" = "xyes" && test "x$mhd_have_w32_threads" = "xyes"]] ,

        [[ USE_THREADS='w32' ]] ,

        [[ test "x$mhd_have_posix_threads" = "xyes" ]], [[ USE_THREADS='posix' ]],

        [[ test "x$mhd_have_w32_threads" = "xyes" ]], [[ USE_THREADS='w32' ]],

        [ AC_MSG_ERROR([[No threading lib is available. Consider installing pthreads]]) ]

        )

    ]

  )

if test "x$USE_THREADS" = "xposix"; then

  CC="$PTHREAD_CC"

  AC_DEFINE([MHD_USE_POSIX_THREADS],[1],[define to use pthreads])

  MHD_LIB_CFLAGS="$MHD_LIB_CFLAGS $PTHREAD_CFLAGS"

  MHD_LIBDEPS="$PTHREAD_LIBS $MHD_LIBDEPS"

  MHD_LIBDEPS_PKGCFG="$PTHREAD_LIBS $MHD_LIBDEPS_PKGCFG"

elif test "x$USE_THREADS" = "xw32"; then

  AC_DEFINE([MHD_USE_W32_THREADS],[1],[define to use W32 threads])

fi

AM_CONDITIONAL([USE_POSIX_THREADS], [test "x$USE_THREADS" = "xposix"])

AM_CONDITIONAL([USE_W32_THREADS], [test "x$USE_THREADS" = "xw32"])

AC_MSG_RESULT([[$USE_THREADS]])

AC_ARG_ENABLE([[thread-names]],

   [AS_HELP_STRING([--disable-thread-names [auto] ],[do not set names on MHD generated threads])],

   [], [enable_thread_names='auto'])

if test "x$enable_thread_names" != "xno" && test "x$USE_THREADS" = "xposix"; then

  # Check for thread name function

  HAVE_THREAD_NAME_FUNC="no"

  SAVE_LIBS="$LIBS"

  SAVE_CFLAGS="$CFLAGS"

  LIBS="$PTHREAD_LIBS $LIBS"

  CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

  AC_CHECK_HEADERS([pthread_np.h],[],[],

    [

AC_INCLUDES_DEFAULT

      [

#include <pthread.h>

      ]

    ])

  # Try to find how to set thread name by thread attributes.

  # If pthread_attr_setname_np(3) is not declared, it's not possible to detect

  # form of pthread_attr_setname_np(3) due to C "feature" "implicit declaration".

  AC_CHECK_DECL([[pthread_attr_setname_np]],[],[],[[

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H

#include <pthread_np.h>

#endif

]])

  AS_IF([[test "x$ac_cv_have_decl_pthread_attr_setname_np" = "xyes"]],

    [AC_MSG_CHECKING([[for pthread_attr_setname_np(3) in NetBSD or OSF1 form]])

     AC_LINK_IFELSE(

      [AC_LANG_PROGRAM([[

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H

#include <pthread_np.h>

#endif

]], [[

      pthread_attr_t thr_attr;

      pthread_attr_init(&thr_attr);

      pthread_attr_setname_np(&thr_attr, "name", 0);

      pthread_attr_destroy(&thr_attr);

        ]])],

        [AC_DEFINE([[HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD]], [[1]], [Define if you have NetBSD form (or OSF1 form) of pthread_attr_setname_np(3) function.])

         HAVE_THREAD_NAME_FUNC="yes"

         AC_MSG_RESULT([[yes]])],

        [AC_MSG_RESULT([[no]])]

        )

    ])

  AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes" && test "x$ac_cv_have_decl_pthread_attr_setname_np" = "xyes"]],

    [AC_MSG_CHECKING([[for pthread_attr_setname_np(3) in IBM i form]])

     AC_LINK_IFELSE(

      [AC_LANG_PROGRAM([[

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H

#include <pthread_np.h>

#endif

]], [[

      pthread_attr_t thr_attr;

      pthread_attr_init(&thr_attr);

      pthread_attr_setname_np(&thr_attr, "name");

      pthread_attr_destroy(&thr_attr);

        ]])],

        [AC_DEFINE([[HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI]], [[1]], [Define if you have IBM i form of pthread_attr_setname_np(3) function.])

         HAVE_THREAD_NAME_FUNC="yes"

         AC_MSG_RESULT([[yes]])],

        [AC_MSG_RESULT([[no]])]

        )

    ])

  # Try to find how to set thread name for started thread - less convinent

  # than setting name by attributes.

  # If pthread_setname_np(3) is not declared, it's not possible to detect

  # form of pthread_setname_np(3) due to C "feature" "implicit declaration".

  AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes"]],

    [AC_CHECK_DECL([[pthread_setname_np]],[],[],[[

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H

#include <pthread_np.h>

#endif

       ]])

    ])

  AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes" && test "x$ac_cv_have_decl_pthread_setname_np" = "xyes"]],

    [AC_MSG_CHECKING([[for pthread_setname_np(3) in NetBSD or OSF1 form]])

     AC_LINK_IFELSE(

      [AC_LANG_PROGRAM([[

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H

#include <pthread_np.h>

#endif

]], [[int res = pthread_setname_np(pthread_self(), "name", 0);]])],

        [AC_DEFINE([[HAVE_PTHREAD_SETNAME_NP_NETBSD]], [[1]], [Define if you have NetBSD form (or OSF1 form) of pthread_setname_np(3) function.])

         HAVE_THREAD_NAME_FUNC="yes"

         AC_MSG_RESULT([[yes]])],

        [AC_MSG_RESULT([[no]])]

        )

    ])

  AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes" && test "x$ac_cv_have_decl_pthread_setname_np" = "xyes"]],

    [AC_MSG_CHECKING([[for pthread_setname_np(3) in GNU/Linux form]])

     AC_LINK_IFELSE(

       [AC_LANG_PROGRAM([[

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H

#include <pthread_np.h>

#endif

]], [[int res = pthread_setname_np(pthread_self(), "name");]])],

        [AC_DEFINE([[HAVE_PTHREAD_SETNAME_NP_GNU]], [[1]], [Define if you have GNU/Linux form of pthread_setname_np(3) function.])

         HAVE_THREAD_NAME_FUNC="yes"

         AC_MSG_RESULT([[yes]])],

        [AC_MSG_RESULT([[no]])]

        )

    ])

  AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes" && test "x$ac_cv_have_decl_pthread_setname_np" = "xyes"]],

    [AC_MSG_CHECKING([[for pthread_setname_np(3) in Darwin form]])

     AC_LINK_IFELSE(

       [AC_LANG_PROGRAM([[

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H

#include <pthread_np.h>

#endif

]], [[int res = pthread_setname_np("name");]])],

        [AC_DEFINE([[HAVE_PTHREAD_SETNAME_NP_DARWIN]], [[1]], [Define if you have Darwin form of pthread_setname_np(3) function.])

         HAVE_THREAD_NAME_FUNC="yes"

         AC_MSG_RESULT([[yes]])],

        [AC_MSG_RESULT([[no]])]

        )

    ])

  AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes"]],

    [

     AC_CHECK_DECL([[pthread_set_name_np]],

       [

        AC_MSG_CHECKING([[for pthread_set_name_np(3) in FreeBSD form]])

        AC_LINK_IFELSE(

          [AC_LANG_PROGRAM([[

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H

#include <pthread_np.h>

#endif

]], [[pthread_set_name_np(pthread_self(), "name");]])],

          [AC_DEFINE([[HAVE_PTHREAD_SET_NAME_NP_FREEBSD]], [[1]], [Define if you have FreeBSD form of pthread_set_name_np(3) function.])

           HAVE_THREAD_NAME_FUNC="yes"

           AC_MSG_RESULT([[yes]])],

          [AC_MSG_RESULT([[no]])]

          )

       ],[],[[

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H

#include <pthread_np.h>

#endif

       ]]

     )

    ])

  LIBS="$SAVE_LIBS"

  CFLAGS="$SAVE_CFLAGS"

fi

AS_IF(

  [[test "x$enable_thread_names" != "xno"]],

  [

    AC_MSG_CHECKING([[whether to enable thread names]])

    AC_COMPILE_IFELSE(

     [AC_LANG_PROGRAM([], [[

#ifdef MHD_NO_THREAD_NAMES

#error Thread names are disabled.

choke me

#endif

/* Keep in sync with mhd_threads.h */

#if defined(MHD_USE_POSIX_THREADS) && (defined(HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD) || defined(HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI) || \

    defined(HAVE_PTHREAD_SETNAME_NP_GNU) || defined(HAVE_PTHREAD_SET_NAME_NP_FREEBSD) || defined(HAVE_PTHREAD_SETNAME_NP_DARWIN) || \

    defined(HAVE_PTHREAD_SETNAME_NP_NETBSD) )

int a = 1;

#elif defined(MHD_USE_W32_THREADS) && defined(_MSC_FULL_VER)

int b = 2;

#else

#error No thread name function is available.

choke me

#endif

       ]])

     ], [

       enable_thread_names='yes'

     ], [

       AS_IF([[test "x$enable_thread_names" = "xyes"]],

         [

           AC_MSG_RESULT([[no]])

           AC_MSG_ERROR([[thread names was explicitly requested, but thread name function is not available]])

         ])

       enable_thread_names='no'

     ])

  AC_MSG_RESULT([[$enable_thread_names]])

  ])

AS_IF([[test "x$enable_thread_names" = "xno"]],

  [AC_DEFINE([[MHD_NO_THREAD_NAMES]], [[1]], [Define to 1 to disable setting name on generated threads])])

AM_CONDITIONAL(HAVE_W32, [test "x$os_is_native_w32" = "xyes"])

w32_shared_lib_exp=no

if test "x$enable_shared" = "xyes" && test "x$os_is_native_w32" = "xyes"; then

  if test "x$ac_cv_use_ms_lib_tool" = "xyes" || test -n "$DLLTOOL"; then

    w32_shared_lib_exp=yes

  else

    AC_MSG_WARN([[GNU dlltool or MS lib.exe is required for creating shared library export on W32]])

    AC_MSG_WARN([[Export library libmicrohttpd.lib will not be created]])

  fi

fi

AM_CONDITIONAL(W32_SHARED_LIB_EXP, [test "x$w32_shared_lib_exp" = "xyes"])

AM_CONDITIONAL(USE_MS_LIB_TOOL, [test "x$ac_cv_use_ms_lib_tool" = "xyes"])

MHD_CHECK_SOCKET_SHUTDOWN_TRIGGER([AC_DEFINE([HAVE_LISTEN_SHUTDOWN],[1],[can use shutdown on listen sockets])])

AM_CONDITIONAL([HAVE_LISTEN_SHUTDOWN], [test "x$mhd_cv_host_shtdwn_trgr_select" = "xyes"])

# set GCC options

# use '-fno-strict-aliasing', but only if the compiler

# and linker can take it

AX_CHECK_LINK_FLAG([-fno-strict-aliasing],

  [AX_APPEND_COMPILE_FLAGS([-fno-strict-aliasing])])

AC_C_BIGENDIAN

AC_CHECK_PROG([HAVE_CURL_BINARY],[curl],[yes],[no])

AM_CONDITIONAL([HAVE_CURL_BINARY],[test "x$HAVE_CURL_BINARY" = "xyes"])

AC_CHECK_PROG([HAVE_MAKEINFO_BINARY],[makeinfo],[yes],[no])

AM_CONDITIONAL([HAVE_MAKEINFO_BINARY],[test "x$HAVE_MAKEINFO_BINARY" = "xyes"])

AM_CONDITIONAL(W32_STATIC_LIB, [test "x$os_is_native_w32" = "xyes"  && test "x$enable_static" = "xyes"])

AC_ARG_ENABLE([[doc]],

  [AS_HELP_STRING([[--disable-doc]], [do not build any documentation])], ,

    [enable_doc=yes])

test "x$enable_doc" = "xno" || enable_doc=yes

AM_CONDITIONAL([BUILD_DOC], [test "x$enable_doc" = "xyes"])

AC_ARG_ENABLE([[examples]],

  [AS_HELP_STRING([[--disable-examples]], [do not build any examples])], ,

    [enable_examples=yes])

test "x$enable_examples" = "xno" || enable_examples=yes

AM_CONDITIONAL([BUILD_EXAMPLES], [test "x$enable_examples" = "xyes"])

AC_ARG_ENABLE([[poll]],

  [AS_HELP_STRING([[--enable-poll[=ARG]]], [enable poll support (yes, no, auto) [auto]])],

    [enable_poll=${enableval}],

    [enable_poll='auto']

  )

if test "$enable_poll" != "no"; then

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

    AC_CHECK_HEADERS([poll.h],

      [

        AC_CHECK_FUNCS([poll], [have_poll='yes'], [have_poll='no'])

      ], [], [AC_INCLUDES_DEFAULT])

  else

    AC_MSG_CHECKING([for WSAPoll()])

    AC_LINK_IFELSE([

      AC_LANG_PROGRAM([[

#include <winsock2.h>

       ]], [[

WSAPOLLFD fda[2];

WSAPoll(fda, 2, 0);]])],

        [

          have_poll='yes'

          AC_DEFINE([HAVE_POLL],[1])

        ], [have_poll='no'])

    AC_MSG_RESULT([$have_poll])

  fi

  if test "$enable_poll" = "yes" && test "$have_poll" != "yes"; then

    AC_MSG_ERROR([[Support for poll was explicitly requested but cannot be enabled on this platform.]])

  fi

  enable_poll="$have_poll"

fi

AC_ARG_ENABLE([[epoll]],

  [AS_HELP_STRING([[--enable-epoll[=ARG]]], [enable epoll support (yes, no, auto) [auto]])],

    [enable_epoll=${enableval}],

    [enable_epoll='auto']

  )

if test "$enable_epoll" != "no"; then

  AX_HAVE_EPOLL

  if test "${ax_cv_have_epoll}" = "yes"; then

    AC_DEFINE([[EPOLL_SUPPORT]],[[1]],[Define to 1 to enable epoll support])

    enable_epoll='yes'

  else

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

      AC_MSG_ERROR([[Support for epoll was explicitly requested but cannot be enabled on this platform.]])

    fi

    enable_epoll='no'

  fi

fi

if test "x$enable_epoll" = "xyes"; then

  AC_CACHE_CHECK([for epoll_create1()], [mhd_cv_have_epoll_create1], [

    AC_LINK_IFELSE([

      AC_LANG_PROGRAM([[

#include <sys/epoll.h>

        ]], [[

int fd;

fd = epoll_create1(EPOLL_CLOEXEC);]])],

      [mhd_cv_have_epoll_create1=yes],

      [mhd_cv_have_epoll_create1=no])])

  AS_IF([test "x$mhd_cv_have_epoll_create1" = "xyes"],[

    AC_DEFINE([[HAVE_EPOLL_CREATE1]], [[1]], [Define if you have epoll_create1 function.])])

fi

# Check for headers that are ALWAYS required

AC_CHECK_HEADERS([fcntl.h math.h errno.h limits.h stdio.h locale.h sys/stat.h sys/types.h], [], [AC_MSG_ERROR([Compiling libmicrohttpd requires standard UNIX headers files])], [AC_INCLUDES_DEFAULT])

# Check for optional headers

AC_CHECK_HEADERS([sys/types.h sys/time.h sys/msg.h time.h sys/mman.h sys/ioctl.h \

  sys/socket.h sys/select.h netdb.h netinet/in.h netinet/ip.h netinet/tcp.h arpa/inet.h \

  endian.h machine/endian.h sys/endian.h sys/param.h sys/machine.h sys/byteorder.h machine/param.h sys/isa_defs.h \

  inttypes.h stddef.h unistd.h \

  sockLib.h inetLib.h net/if.h], [], [], [AC_INCLUDES_DEFAULT])

AC_CHECK_HEADER([[search.h]],

  [

   gl_FUNC_TSEARCH

   AS_IF([[test "x$HAVE_TSEARCH" = "x1" && test "x$REPLACE_TSEARCH" != "x1"]],

     [AC_DEFINE([[HAVE_SEARCH_H]], [[1]],

       [Define to 1 if you have the <search.h> header file and your system have properly functioning tsearch(), tfind() and tdelete() functions])])

  ],

  [], [AC_INCLUDES_DEFAULT])

AM_CONDITIONAL([MHD_HAVE_TSEARCH], [[test "x$ac_cv_header_search_h" = xyes && test "x$HAVE_TSEARCH" = "x1" && test "x$REPLACE_TSEARCH" != "x1"]])

# Check for generic functions

AC_CHECK_FUNCS([rand random])

AC_CHECK_MEMBER([struct sockaddr_in.sin_len],

   [ AC_DEFINE(HAVE_SOCKADDR_IN_SIN_LEN, 1, [Do we have sockaddr_in.sin_len?])

   ],

   [],

   [

#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

   ])

AC_CHECK_DECLS([getsockname],

  [

   AC_CHECK_FUNCS([getsockname],

     [

      AC_CACHE_CHECK([[whether getsockname() is usable]], [[mhc_cv_getsockname_usable]],

        [

         AC_RUN_IFELSE(

           [

            AC_LANG_SOURCE(

             [[

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#ifdef HAVE_WINSOCK2_H

#include <winsock2.h>

#endif

#ifdef HAVE_WS2TCPIP_H

#include <ws2tcpip.h>

#endif

#ifdef HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#ifdef HAVE_NETINET_IP_H

#include <netinet/ip.h>

#endif

#ifdef HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

static void zr_mem(void *ptr, socklen_t size)

{ char *mem = ptr; while(size--) {mem[0] = 0; mem++;} }

int main(void)

{

  const socklen_t c_addr_size = (socklen_t)sizeof(struct sockaddr_in);

  struct sockaddr_in sa;

  socklen_t addr_size;

  int ret = 1;

#if !defined(_WIN32) || defined(__CYGWIN__)

  int sckt;

  const int invld_sckt = -1;

#else

  SOCKET sckt;

  const SOCKET invld_sckt = INVALID_SOCKET;

  WSADATA wsa_data;

  if (0 != WSAStartup(MAKEWORD(2, 2), &wsa_data) || MAKEWORD(2, 2) != wsa_data.wVersion)

    return 20;

#endif

  sckt = socket (PF_INET, SOCK_STREAM, 0);

  if (invld_sckt != sckt)

  {

    zr_mem(&sa, c_addr_size);

    sa.sin_family = AF_INET;

#if HAVE_SOCKADDR_IN_SIN_LEN

    sa.sin_len = c_addr_size;

#endif

    if (0 == bind (sckt, (struct sockaddr *)&sa, c_addr_size))

    {

      if (0 == listen (sckt, 1))

      {

        addr_size = c_addr_size;

        if (0 == getsockname (sckt, (struct sockaddr  *)&sa, &addr_size))

        {

          if (c_addr_size >= addr_size)

          {

            if (0 != ntohs(sa.sin_port))

            { ret = 0;

            } else ret = 7;

          } else ret = 6;

        } else ret = 5;

      } else ret = 4;

    } else ret = 3;

  } else ret = 2;

#if !defined(_WIN32) || defined(__CYGWIN__)

  close (sckt);

#else

  closesocket (sckt);

  WSACleanup();

#endif

  return ret;

}

             ]]

            )

           ],

           [[mhc_cv_getsockname_usable='yes']],

           [[mhc_cv_getsockname_usable='no']],

           [[mhc_cv_getsockname_usable='assuming yes']]

         )

        ]

      )

      AS_VAR_IF([[mhc_cv_getsockname_usable]], [["no"]], [:],

        [AC_DEFINE([[MHD_USE_GETSOCKNAME]], [[1]], [Define if you have usable `getsockname' function.])])

     ]

   )

  ], [],

  [[

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif