configure.ac

   1 dnl source: configure.ac
   2 dnl Copyright Gerhard Rieger and contributors (see file CHANGES)
   3 dnl Published under the GNU General Public License V.2, see file COPYING
   4
   5 dnl Process this file with autoconf to produce a configure script.
   6 AC_INIT(socat.c)
   7
   8 AC_CONFIG_HEADER(config.h)
   9
  10 if test -f /usr/xpg4/bin/fgrep; then
  11    FGREP=/usr/xpg4/bin/fgrep   # Solaris
  12 else
  13    FGREP=fgrep
  14 fi
  15
  16 # find out which defines gcc passes to cpp, so makedepend does not run into
  17 # (harmless) "error architecture not supported"
  18 AC_MSG_CHECKING(which defines needed for makedepend)
  19 __cpp_defs=`gcc -v -E - </dev/null 2>&1 |$FGREP -e '/cpp ' -e '/cc1 '`
  20 SYSDEFS=`aa=; for a in $__cpp_defs
  21         do case "$a" in -D*) aa="$aa $a";; esac; done; echo "$aa"`
  22 AC_SUBST(SYSDEFS)
  23 AC_MSG_RESULT($SYSDEFS)
  24
  25
  26 # this must come before AC_PROG_CC
  27 if test -z "$CFLAGS"; then
  28    # if CFLAGS is not set, we preset it to -O
  29    # with this setting, we prevent autoconf from defaulting to "-g -O2"
  30    export CFLAGS=-O
  31 fi
  32
  33 dnl Checks for programs.
  34 AC_PROG_INSTALL(install)
  35 AC_PROG_CC
  36 AC_PROG_RANLIB
  37 AC_SUBST(AR)
  38 AC_CHECK_PROG(AR, ar, ar, gar)
  39 #
  40 # we need to explicitely call this here; otherwise, with --disable-libwrap we
  41 # fail
  42 AC_LANG_COMPILER_REQUIRE()
  43
  44 if test "$GCC" = yes; then
  45    CFLAGS="$CFLAGS -D_GNU_SOURCE -Wall -Wno-parentheses"
  46    ERRONWARN="-Werror -O0"
  47 elif test "$CC" = "clang"; then
  48    CFLAGS="$CFLAGS -D_GNU_SOURCE -Wall -Wno-parentheses"
  49    ERRONWARN="-Werror -O0"
  50 #elif Sun Studio
  51 #   ERRONWARN="-errwarn"
  52 else
  53    ERRONWARN=
  54 fi
  55 export CFLAGS
  56
  57
  58 dnl Checks for header files.
  59 AC_HEADER_STDC
  60 AC_CHECK_HEADERS(stdbool.h)
  61 AC_CHECK_HEADERS(inttypes.h)
  62 AC_HEADER_SYS_WAIT
  63 AC_CHECK_HEADERS(fcntl.h limits.h strings.h sys/param.h sys/ioctl.h sys/time.h syslog.h unistd.h)
  64 AC_CHECK_HEADERS(pwd.h grp.h stdint.h sys/types.h poll.h sys/poll.h sys/socket.h sys/uio.h sys/stat.h netdb.h sys/un.h)
  65 AC_CHECK_HEADERS(pty.h)
  66 AC_CHECK_HEADERS(netinet/in.h netinet/in_systm.h)
  67 AC_CHECK_HEADERS(netinet/ip.h, [], [], [AC_INCLUDES_DEFAULT
  68         #if HAVE_NETINET_IN_H && HAVE_NETINET_IN_SYSTM_H
  69         #include <netinet/in.h>
  70         #include <netinet/in_systm.h>
  71         #endif])        # Solaris prerequisites for netinet/ip.h
  72 AC_CHECK_HEADERS(netinet/tcp.h)
  73 AC_CHECK_HEADER(net/if.h, AC_DEFINE(HAVE_NET_IF_H), [], [AC_INCLUDES_DEFAULT
  74         #if HAVE_SYS_SOCKET_H
  75         #include <sys/socket.h>
  76         #endif])        # Mac OS X requires including sys/socket.h
  77 AC_CHECK_HEADERS(arpa/nameser.h)
  78
  79 AC_HEADER_RESOLV()
  80
  81 AC_CHECK_HEADERS(termios.h linux/if_tun.h)
  82 AC_CHECK_HEADERS(net/if_dl.h)
  83 AC_CHECK_HEADERS(linux/types.h)
  84 AC_CHECK_HEADER(linux/errqueue.h, AC_DEFINE(HAVE_LINUX_ERRQUEUE_H), [], [#include <sys/time.h>
  85 #include <linux/types.h>])
  86 AC_CHECK_HEADERS(sys/utsname.h sys/select.h sys/file.h)
  87 AC_CHECK_HEADERS(util.h bsd/libutil.h libutil.h sys/stropts.h regex.h)
  88 AC_CHECK_HEADERS(linux/fs.h linux/ext2_fs.h)
  89
  90 dnl Checks for setgrent, getgrent and endgrent.
  91 AC_CHECK_FUNCS(setgrent getgrent endgrent)
  92 dnl Checks for getgrouplist() /* BSD */
  93 AC_CHECK_FUNCS(getgrouplist)
  94 AC_CHECK_FUNCS(cfmakeraw)
  95
  96 dnl Link libresolv if necessary (for Mac OS X)
  97 AC_SEARCH_LIBS([res_9_init], [resolv])
  98
  99
 100 dnl Check for extra socket library (for Solaris)
 101 AC_CHECK_FUNC(hstrerror,  , AC_CHECK_LIB(resolv, hstrerror, [LIBS="$LIBS -lresolv"; AC_DEFINE(HAVE_HSTRERROR)]))
 102 AC_CHECK_FUNC(gethostent, , AC_CHECK_LIB(nsl, gethostent))
 103 AC_CHECK_FUNC(setsockopt, , AC_CHECK_LIB(socket, setsockopt))
 104
 105 dnl Check for function prototype and in lib
 106 dnl arg1: function name
 107 dnl arg2: required include files beyond sysincludes.h
 108 define(AC_CHECK_PROTOTYPE_LIB,[
 109 AC_MSG_CHECKING(for $1 prototype)
 110 AC_CACHE_VAL(sc_cv_have_prototype_lib_$1,
 111 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN -Wall $CFLAGS1";
 112  AC_TRY_LINK([#include "sysincludes.h"
 113 $2],[return(&$1==(void *)&$1);],
 114  [sc_cv_have_prototype_lib_$1=yes],
 115  [sc_cv_have_prototype_lib_$1=no]);
 116  CFLAGS="$CFLAGS1"])
 117 if test $sc_cv_have_prototype_lib_$1 = yes; then
 118    AC_DEFINE(HAVE_PROTOTYPE_LIB_$1)
 119 fi
 120 AC_MSG_RESULT($sc_cv_have_prototype_lib_$1)
 121 ])
 122
 123
 124 dnl Check for hstrerror prototype
 125 AC_MSG_CHECKING(for hstrerror prototype)
 126 AC_CACHE_VAL(sc_cv_have_prototype_hstrerror,
 127 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')";
 128  AC_TRY_COMPILE([#include <netdb.h>],[hstrerror();],
 129  [sc_cv_have_prototype_hstrerror=no],
 130  [sc_cv_have_prototype_hstrerror=yes]);
 131  CFLAGS="$CFLAGS1"])
 132 if test $sc_cv_have_prototype_hstrerror = yes; then
 133    AC_DEFINE(HAVE_PROTOTYPE_HSTRERROR)
 134 fi
 135 AC_MSG_RESULT($sc_cv_have_prototype_hstrerror)
 136
 137 # getprotobynumber_r() is not standardized
 138 AC_MSG_CHECKING(for getprotobynumber_r() variant)
 139 AC_CACHE_VAL(sc_cv_getprotobynumber_r,
 140 [AC_TRY_COMPILE([#include <stddef.h>
 141 #include <netdb.h>],[getprotobynumber_r(1,NULL,NULL,1024,NULL);],
 142 [sc_cv_getprotobynumber_r=1; tmp_bynum_variant=Linux],
 143  [AC_TRY_COMPILE([#include <stddef.h>
 144  #include <netdb.h>],[getprotobynumber_r(1,NULL,NULL,1024);],
 145  [sc_cv_getprotobynumber_r=2; tmp_bynum_variant=Solaris],
 146   [AC_TRY_COMPILE([#include <stddef.h>
 147   #include <netdb.h>],[getprotobynumber_r(1,NULL,NULL);],
 148   [sc_cv_getprotobynumber_r=3; tmp_bynum_variant=AIX],
 149
 150   [sc_cv_getprotobynumber_r=]
 151 )])])])
 152 if test "$sc_cv_getprotobynumber_r"; then
 153    AC_DEFINE_UNQUOTED(HAVE_GETPROTOBYNUMBER_R, $sc_cv_getprotobynumber_r)
 154 fi
 155 AC_MSG_RESULT($sc_cv_getprotobynumber_r /* $tmp_bynum_variant */)
 156
 157
 158 AC_MSG_CHECKING(whether to include help)
 159 AC_ARG_ENABLE(help, [  --disable-help          disable help],
 160               [case "$enableval" in
 161                no) AC_MSG_RESULT(no);;
 162                *) AC_DEFINE(WITH_HELP) AC_MSG_RESULT(yes);;
 163                esac],
 164                [AC_DEFINE(WITH_HELP) AC_MSG_RESULT(yes)])
 165
 166 AC_MSG_CHECKING(whether to include STDIO support)
 167 AC_ARG_ENABLE(stdio, [  --disable-stdio         disable STDIO support],
 168               [case "$enableval" in
 169                no) AC_MSG_RESULT(no);;
 170                *) AC_DEFINE(WITH_STDIO) AC_MSG_RESULT(yes);;
 171                esac],
 172                [AC_DEFINE(WITH_STDIO) AC_MSG_RESULT(yes)])
 173
 174 AC_MSG_CHECKING(whether to include FD-number support)
 175 AC_ARG_ENABLE(fdnum, [  --disable-fdnum         disable FD-number support],
 176               [case "$enableval" in
 177                no) AC_MSG_RESULT(no);;
 178                *) AC_DEFINE(WITH_FDNUM) AC_MSG_RESULT(yes);;
 179                esac],
 180                [AC_DEFINE(WITH_FDNUM) AC_MSG_RESULT(yes)])
 181
 182 AC_MSG_CHECKING(whether to include direct file support)
 183 AC_ARG_ENABLE(file, [  --disable-file          disable direct file support],
 184               [case "$enableval" in
 185                no) AC_MSG_RESULT(no);;
 186                *) AC_DEFINE(WITH_FILE) AC_MSG_RESULT(yes);;
 187                esac],
 188                [AC_DEFINE(WITH_FILE) AC_MSG_RESULT(yes)])
 189
 190 AC_MSG_CHECKING(whether to include direct create support)
 191 AC_ARG_ENABLE(creat, [  --disable-creat         disable direct create support],
 192               [case "$enableval" in
 193                no) AC_MSG_RESULT(no);;
 194                *) AC_DEFINE(WITH_CREAT) AC_MSG_RESULT(yes);;
 195                esac],
 196                [AC_DEFINE(WITH_CREAT) AC_MSG_RESULT(yes)])
 197
 198 AC_MSG_CHECKING(whether to include gopen support)
 199 AC_ARG_ENABLE(gopen, [  --disable-gopen         disable open for UNIX socket support],
 200               [case "$enableval" in
 201                no) AC_MSG_RESULT(no);;
 202                *) AC_DEFINE(WITH_GOPEN) AC_MSG_RESULT(yes);;
 203                esac],
 204                [AC_DEFINE(WITH_GOPEN) AC_MSG_RESULT(yes)])
 205
 206 AC_MSG_CHECKING(whether to include explicit pipe support)
 207 AC_ARG_ENABLE(pipe, [  --disable-pipe          disable pipe support],
 208               [case "$enableval" in
 209                no) AC_MSG_RESULT(no);;
 210                *) AC_DEFINE(WITH_PIPE) AC_MSG_RESULT(yes);;
 211                esac],
 212                [AC_DEFINE(WITH_PIPE) AC_MSG_RESULT(yes)])
 213
 214 AC_MSG_CHECKING(whether to include explicit termios support)
 215 AC_ARG_ENABLE(termios, [  --disable-termios       disable termios support],
 216               [case "$enableval" in
 217                no) AC_MSG_RESULT(no);;
 218                *) AC_DEFINE(WITH_TERMIOS) AC_MSG_RESULT(yes);;
 219                esac],
 220                [AC_DEFINE(WITH_TERMIOS) AC_MSG_RESULT(yes)])
 221
 222 AC_MSG_CHECKING(whether to include UNIX socket support)
 223 AC_ARG_ENABLE(unix, [  --disable-unix          disable UNIX domain socket support],
 224               [case "$enableval" in
 225                no) AC_MSG_RESULT(no);;
 226                *) AC_DEFINE(WITH_UNIX) AC_MSG_RESULT(yes);;
 227                esac],
 228                [AC_DEFINE(WITH_UNIX) AC_MSG_RESULT(yes)])
 229
 230 AC_MSG_CHECKING(whether to include abstract UNIX socket support)
 231 AC_ARG_ENABLE(abstract_unixsocket, [  --disable-abstract-unixsocket   disable abstract UNIX domain socket support],
 232               [case "$enableval" in
 233                no) AC_MSG_RESULT(no);;
 234                *) AC_DEFINE(WITH_ABSTRACT_UNIXSOCKET) AC_MSG_RESULT(yes);;
 235                esac],
 236               [ case "`uname`" in
 237                 Linux)
 238                     AC_DEFINE(WITH_ABSTRACT_UNIXSOCKET) AC_MSG_RESULT(yes);;
 239                 *)
 240                     AC_MSG_RESULT(no);;
 241                 esac])
 242
 243 AC_MSG_CHECKING(whether to include IPv4 support)
 244 AC_ARG_ENABLE(ip4, [  --disable-ip4           disable IPv4 support],
 245               [case "$enableval" in
 246                no) AC_MSG_RESULT(no);;
 247                *) AC_DEFINE(WITH_IP4) AC_MSG_RESULT(yes);;
 248                esac],
 249                [AC_DEFINE(WITH_IP4) AC_MSG_RESULT(yes)])
 250
 251 AC_MSG_CHECKING(whether to include IPv6 support)
 252 AC_ARG_ENABLE(ip6, [  --disable-ip6           disable IPv6 support],
 253               [case "$enableval" in
 254                no) AC_MSG_RESULT(no); WITH_IP6= ;;
 255                *) AC_MSG_RESULT(yes); WITH_IP6=1 ;;
 256                esac],
 257               [ AC_MSG_RESULT(yes);  WITH_IP6=1 ])
 258 if test "$WITH_IP6"; then
 259   AC_CHECK_HEADERS([netinet/ip6.h],
 260     [AC_DEFINE(HAVE_NETINET_IP6_H) AC_DEFINE(WITH_IP6)],
 261     [AC_MSG_WARN([include file netinet/ip6.h not found, disabling IP6])],
 262     [AC_INCLUDES_DEFAULT
 263      #ifdef HAVE_NETINET_IN_H
 264      # include <netinet/in.h>
 265      #endif
 266      #ifdef HAVE_NETINET_IP_H
 267      # include <netinet/ip.h>
 268      #endif])
 269   AC_CHECK_HEADERS(netinet6/in6.h)      # found on OpenBSD and Lion, used for IPV6_*
 270
 271 AC_MSG_CHECKING(if __APPLE_USE_RFC_2292 is helpful)
 272 AC_CACHE_VAL(ac_cv_apple_use_rfc_2292,
 273  [AC_TRY_COMPILE(,[#ifndef IPV6_HOPOPTS
 274   murks;
 275 #endif],
 276  [ac_cv_apple_use_rfc_2292=no],
 277  [AC_TRY_COMPILE([#define __APPLE_USE_RFC_2292],
 278  [#ifndef IPV6_HOPOPTS
 279   murks;
 280 #endif],
 281    [ac_cv_apple_use_rfc_2292=yes],
 282    [ac_cv_apple_use_rfc_2292=no]
 283  )]
 284 )])
 285 if test "$ac_cv_apple_use_rfc_2292" = yes; then
 286   AC_DEFINE(__APPLE_USE_RFC_2292)
 287 fi
 288 AC_MSG_RESULT($ac_cv_apple_use_rfc_2292)
 289
 290 fi
 291
 292 AC_MSG_CHECKING(whether to include raw IP support)
 293 AC_ARG_ENABLE(rawip, [  --disable-rawip         disable raw IP support],
 294               [case "$enableval" in
 295                no) AC_MSG_RESULT(no);;
 296                *) AC_DEFINE(WITH_RAWIP) AC_MSG_RESULT(yes);;
 297                esac],
 298                [AC_DEFINE(WITH_RAWIP) AC_MSG_RESULT(yes)])
 299
 300 AC_MSG_CHECKING(whether to include generic socket support)
 301 AC_ARG_ENABLE(genericsocket, [  --disable-genericsocket disable generic socket support],
 302               [case "$enableval" in
 303                no) AC_MSG_RESULT(no);;
 304                *) AC_DEFINE(WITH_GENERICSOCKET) AC_MSG_RESULT(yes);;
 305                esac],
 306                [AC_DEFINE(WITH_GENERICSOCKET) AC_MSG_RESULT(yes)])
 307 AC_MSG_CHECKING(whether to include generic network interface support)
 308 AC_ARG_ENABLE(interface, [  --disable-interface  disable network interface support],
 309               [case "$enableval" in
 310                no) AC_MSG_RESULT(no); WITH_INTERFACE= ;;
 311                *) AC_MSG_RESULT(yes); WITH_INTERFACE=1 ;;
 312                esac],
 313                [AC_MSG_RESULT(yes);  WITH_INTERFACE=1 ])
 314 if test "$WITH_INTERFACE"; then
 315   AC_CHECK_HEADER(netpacket/packet.h,
 316     AC_DEFINE(HAVE_NETPACKET_PACKET_H),
 317     [WITH_INTERFACE=;
 318      AC_MSG_WARN([include file netpacket/packet.h not found, disabling interface])])
 319 fi
 320 if test "$WITH_INTERFACE"; then
 321   AC_CHECK_HEADER(netinet/if_ether.h,
 322     AC_DEFINE(HAVE_NETINET_IF_ETHER_H),
 323     [WITH_INTERFACE=;
 324      AC_MSG_WARN([include file netinet/if_ether.h not found, disabling interface])],
 325      [AC_INCLUDES_DEFAULT
 326      #if HAVE_NET_IF_H && HAVE_NETINET_IN_H
 327      #include <net/if.h>
 328      #include <netinet/in.h>
 329      #endif])
 330 fi
 331 if test "$WITH_INTERFACE"; then
 332    AC_DEFINE(WITH_INTERFACE)
 333 fi
 334
 335 AC_MSG_CHECKING(whether to include TCP support)
 336 AC_ARG_ENABLE(tcp, [  --disable-tcp           disable TCP support],
 337               [case "$enableval" in
 338                no) AC_MSG_RESULT(no);;
 339                *) AC_DEFINE(WITH_TCP) AC_MSG_RESULT(yes);;
 340                esac],
 341                [AC_DEFINE(WITH_TCP) AC_MSG_RESULT(yes)])
 342
 343 AC_MSG_CHECKING(whether to include UDP support)
 344 AC_ARG_ENABLE(udp, [  --disable-udp           disable UDP support],
 345               [case "$enableval" in
 346                no) AC_MSG_RESULT(no);;
 347                *) AC_DEFINE(WITH_UDP) AC_MSG_RESULT(yes);;
 348                esac],
 349                [AC_DEFINE(WITH_UDP) AC_MSG_RESULT(yes)])
 350
 351 AC_MSG_CHECKING(whether to include SCTP support)
 352 AC_ARG_ENABLE(sctp, [  --disable-sctp           disable SCTP support],
 353               [case "$enableval" in
 354                no) AC_MSG_RESULT(no); WITH_SCTP= ;;
 355                *) AC_MSG_RESULT(yes); WITH_SCTP=1 ;;
 356                esac],
 357                [AC_MSG_RESULT(yes);   WITH_SCTP=1 ])
 358
 359 if test -n "$WITH_SCTP"; then
 360 AC_MSG_CHECKING(for IPPROTO_SCTP)
 361 AC_CACHE_VAL(sc_cv_define_ipproto_sctp,
 362 [AC_TRY_COMPILE([#include <sys/types.h>
 363 #include <netinet/in.h>],
 364 [IPPROTO_SCTP;],
 365 [sc_cv_define_ipproto_sctp=yes],
 366 [sc_cv_define_ipproto_sctp=no])])
 367 AC_MSG_RESULT($sc_cv_define_ipproto_sctp)
 368 if test $sc_cv_define_ipproto_sctp = yes; then
 369    AC_DEFINE(WITH_SCTP)
 370 else
 371    AC_MSG_WARN([IPPROTO_SCTP undefined, disabling SCTP support])
 372 fi
 373 fi
 374
 375 AC_MSG_CHECKING(whether to include vsock support)
 376 AC_ARG_ENABLE(vsock, [  --disable-vsock         disable vsock support],
 377               [case "$enableval" in
 378                no) AC_MSG_RESULT(no); WITH_VSOCK= ;;
 379                *) AC_MSG_RESULT(yes); WITH_VSOCK=1 ;;
 380                esac],
 381                [AC_MSG_RESULT(yes);  WITH_VSOCK=1 ])
 382 if test "$WITH_VSOCK"; then
 383   AC_CHECK_HEADER(linux/vm_sockets.h,
 384     AC_DEFINE(HAVE_LINUX_VM_SOCKETS_H),
 385     [WITH_VSOCK=;
 386      AC_MSG_WARN([include file linux/vm_sockets.h not found, disabling vsock])],
 387     [AC_INCLUDES_DEFAULT
 388     #if HAVE_SYS_SOCKET_H
 389     #include <sys/socket.h>
 390     #endif
 391     ]
 392  )
 393 fi
 394 if test "$WITH_VSOCK"; then
 395    AC_DEFINE(WITH_VSOCK)
 396 fi
 397
 398 AC_MSG_CHECKING(whether to include listen support)
 399 AC_ARG_ENABLE(listen, [  --disable-listen        disable listen support],
 400               [case "$enableval" in
 401                no) AC_MSG_RESULT(no);;
 402                *) AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes);;
 403                esac],
 404                [AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes)])
 405
 406 AC_MSG_CHECKING(whether to include socks4 support)
 407 AC_ARG_ENABLE(socks4, [  --disable-socks4        disable socks4 support],
 408               [case "$enableval" in
 409                no) AC_MSG_RESULT(no);;
 410                *) AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes);;
 411                esac],
 412                [AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes)])
 413
 414 AC_MSG_CHECKING(whether to include socks4a support)
 415 AC_ARG_ENABLE(socks4a, [  --disable-socks4a       disable socks4a support],
 416               [case "$enableval" in
 417                no) AC_MSG_RESULT(no);;
 418                *) AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes);;
 419                esac],
 420                [AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes)])
 421
 422 AC_MSG_CHECKING(whether to include proxy connect support)
 423 AC_ARG_ENABLE(proxy, [  --disable-proxy         disable proxy connect support],
 424               [case "$enableval" in
 425                no) AC_MSG_RESULT(no);;
 426                *) AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes);;
 427                esac],
 428                [AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes)])
 429
 430 AC_MSG_CHECKING(whether to include exec support)
 431 AC_ARG_ENABLE(exec, [  --disable-exec          disable exec support],
 432               [case "$enableval" in
 433                no) AC_MSG_RESULT(no);;
 434                *) AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes);;
 435                esac],
 436                [AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes)])
 437
 438 AC_MSG_CHECKING([whether to include system (shell) support])
 439 AC_ARG_ENABLE(system, [  --disable-system        disable system (shell) support],
 440               [case "$enableval" in
 441                no) AC_MSG_RESULT(no);;
 442                *) AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes);;
 443                esac],
 444                [AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes)])
 445
 446 AC_MSG_CHECKING(whether to include pty address support)
 447 AC_ARG_ENABLE(pty, [  --disable-pty           disable pty support],
 448               [case "$enableval" in
 449                no) AC_MSG_RESULT(no);;
 450                *) AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes);;
 451                esac],
 452                [AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes)])
 453
 454 AC_MSG_CHECKING(whether to include fs attributes support)
 455 AC_ARG_ENABLE(fs, [  --disable-fs            disable fs attributes support],
 456               [case "$enableval" in
 457                no) AC_MSG_RESULT(no);;
 458                *) AC_DEFINE(WITH_FS) AC_MSG_RESULT(yes);;
 459                esac],
 460                [AC_DEFINE(WITH_FS) AC_MSG_RESULT(yes)])
 461
 462 AC_MSG_CHECKING(whether to include readline support)
 463 AC_ARG_ENABLE(readline, [  --disable-readline      disable readline support],
 464               [case "$enableval" in
 465                no) AC_MSG_RESULT(no); WITH_READLINE= ;;
 466                *) AC_MSG_RESULT(yes); WITH_READLINE=1 ;;
 467                esac],
 468                [AC_MSG_RESULT(yes);   WITH_READLINE=1 ])
 469
 470 if test -n "$WITH_READLINE"; then
 471   CPPFLAGS_ORIG=$CPPFLAGS
 472   CFLAGS_ORIG=$CFLAGS
 473   LIBS_ORIG=$LIBS
 474   sc_usable_readline_found=
 475
 476   for D in "" "/usr/local" "/opt/local" "/sw" "/opt/freeware" "/usr/sfw"; do
 477     if test -n "$D" ; then
 478       CPPFLAGS="$CPPFLAGS -I$D/include"
 479       CFLAGS="$CFLAGS -L$D/lib"
 480       DLOC="in location $D"
 481     else
 482       DLOC="in default location"
 483     fi
 484     AC_MSG_CHECKING(for usable readline $DLOC)
 485
 486     # Some systems require -lcurses, some require -lncurses.
 487     # Mac OS X 10.4 (and others) ships with libedit masquerading as readline,
 488     # but it doesn't work well with socat. It can be recognized by the absence
 489     # of append_history.
 490
 491     for L in "" "-lcurses" "-lncurses"; do
 492       LIBS="$LIBS_ORIG -lreadline $L"
 493       AC_TRY_LINK(
 494         [ #include <stdio.h>
 495           #include <readline/readline.h>
 496           #include <readline/history.h>],
 497         [ readline(NULL);
 498           append_history(0, NULL); ],
 499         [ sc_usable_readline_found=1
 500           break ])
 501     done
 502
 503     if test -n "$sc_usable_readline_found"; then
 504       AC_MSG_RESULT(yes)
 505       AC_DEFINE(HAVE_READLINE_READLINE_H,1)
 506       AC_DEFINE(HAVE_READLINE_HISTORY_H,1)
 507       AC_DEFINE(HAVE_LIBREADLINE,1)
 508       AC_DEFINE(WITH_READLINE,1)
 509       break
 510     else
 511       AC_MSG_RESULT(no)
 512       CPPFLAGS=$CPPFLAGS_ORIG
 513       CFLAGS=$CFLAGS_ORIG
 514       LIBS=$LIBS_ORIG
 515     fi
 516   done
 517
 518   if test -z "$sc_usable_readline_found"; then
 519     AC_MSG_WARN([no suitable version of readline found; perhaps you need to install a newer version])
 520   fi
 521 fi
 522
 523 AC_MSG_CHECKING(whether to include openssl support)
 524 AC_ARG_ENABLE(openssl, [  --disable-openssl       disable OpenSSL support],
 525   [ case "$enableval" in
 526     no) AC_MSG_RESULT(no); WITH_OPENSSL= ;;
 527     *) AC_MSG_RESULT(yes); WITH_OPENSSL=1 ;;
 528    esac],
 529    [ AC_MSG_RESULT(yes);   WITH_OPENSSL=1 ])
 530 AC_ARG_ENABLE(openssl_base, [  --enable-openssl-base   specify directory with include/ and lib/],
 531     [ OPENSSL_BASE="$enableval" ],
 532     [ unset OPENSSL_BASE ])
 533 #
 534 if test -n "$WITH_OPENSSL"; then
 535  if test -n "$OPENSSL_BASE"; then
 536     sc_cv_have_openssl_ssl_h=yes; OPENSSL_BASE="$D"
 537  else
 538   AC_MSG_NOTICE(checking for components of OpenSSL)
 539   # first, we need to find the include file <openssl/ssl.h>
 540   AC_CACHE_VAL(sc_cv_have_openssl_ssl_h,
 541     [AC_TRY_COMPILE([#include <openssl/ssl.h>],[;],
 542       [sc_cv_have_openssl_ssl_h=yes; OPENSSL_BASE=""; ],
 543       [sc_cv_have_openssl_ssl_h=no
 544        if [ "$OPENSSL_BASE" ]; then
 545           Ds="$OPENSSL_BASE"
 546        else
 547           Ds="/sw /usr/local /opt/freeware /usr/sfw /usr/local/ssl"
 548        fi
 549        for D in $Ds; do
 550         I="$D/include"
 551         i="$I/openssl/ssl.h"
 552         if test -r "$i"; then
 553           #V_INCL="$V_INCL -I$I"
 554           CPPFLAGS="$CPPFLAGS -I$I"
 555           AC_MSG_NOTICE(found $i)
 556           sc_cv_have_openssl_ssl_h=yes; OPENSSL_BASE="$D"
 557           break;
 558         fi
 559       done])
 560   ])
 561   if test "$sc_cv_have_openssl_ssl_h" = "yes"; then
 562     AC_DEFINE(HAVE_OPENSSL_SSL_H)
 563   fi
 564   AC_MSG_NOTICE(checked for openssl/ssl.h... $sc_cv_have_openssl_ssl_h)
 565  fi
 566 fi      # end checking for openssl/ssl.h
 567 #
 568
 569 #if test -n "$WITH_OPENSSL"; then
 570 #  AC_CHECK_FUNCS(OPENSSL_init_ssl, SSL_library_init)
 571 #fi
 572
 573 if test -n "$WITH_OPENSSL" -a "$sc_cv_have_openssl_ssl_h" = 'yes'; then
 574   # next, we search for the openssl library (libssl.*)
 575   # interesting: Linux only requires -lssl, FreeBSD requires -lssl -lcrypto
 576   # Note, version OpenSSL 0.9.7j and higher requires -lcrypto even on Linux.
 577   AC_MSG_CHECKING(for libssl)
 578   AC_CACHE_VAL(sc_cv_have_libssl,
 579     [ LIBS0="$LIBS"
 580       if test -n "$OPENSSL_BASE"; then
 581         L="$OPENSSL_BASE/lib"; LIBS="$LIBS -L$L -lssl -lcrypto"
 582       else
 583         LIBS="$LIBS -lssl -lcrypto"
 584       fi
 585       AC_TRY_LINK([#include <openssl/ssl.h>],
 586        [SSL_library_init();ERR_error_string()],
 587        [sc_cv_have_libssl='yes'],
 588        [ LIBS="$LIBS -lcrypto"
 589        AC_TRY_LINK([#include <openssl/ssl.h>],
 590        [SSL_library_init()],
 591           [sc_cv_have_libssl='yes'],
 592           [sc_cv_have_libssl='no'])
 593         ])
 594       if test "$sc_cv_have_libssl" != 'yes'; then
 595         LIBS="$LIBS0"
 596       fi
 597     ]
 598   )
 599   if test "$sc_cv_have_libssl" = 'yes'; then
 600     AC_DEFINE(HAVE_LIBSSL)
 601   fi
 602   AC_MSG_RESULT($sc_cv_have_libssl)
 603 fi
 604 #
 605 #    # a possible location for openssl (on Sourceforge/Solaris)
 606 #    AC_CHECK_FILE(/usr/local/ssl/lib, LIBS="$LIBS -L/usr/local/ssl/lib/")
 607 #    # sometimes on Solaris:
 608 #    AC_CHECK_FILE(/pkgs/lib, LIBS="$LIBS -L/pkgs/lib/")
 609 #    # for AIX 5.1 with Linux toolbox:
 610 #    AC_CHECK_FILE(/opt/freeware/lib, LIBS="$LIBS -L/opt/freeware/lib/")
 611 #
 612 #    AC_CHECK_LIB(crypto, main)
 613 #    AC_CHECK_LIB(ssl, main)
 614 #
 615 #    # MacOSX has openssl includes in another directory
 616 #    if test -d /sw/include/; then
 617 #       V_INCL="$V_INCL -I/sw/include"
 618 #    # and Solaris at sourceforge here:
 619 #    elif test -d /usr/local/ssl/include/; then
 620 #       V_INCL="$V_INCL -I/usr/local/ssl/include"
 621 #    # and AIX 5.1 with Linux toolbox:
 622 #    elif test -d /opt/freeware/include; then
 623 #       V_INCL="$V_INCL -I/opt/freeware/include"
 624 #    fi
 625 #fi
 626 if test -n "$WITH_OPENSSL"; then
 627   if test "$sc_cv_have_openssl_ssl_h" = "yes" -a "$sc_cv_have_libssl" = "yes"; then
 628     AC_DEFINE(WITH_OPENSSL)
 629   else
 630     AC_MSG_WARN([not all components of OpenSSL found, disabling it]);
 631   fi
 632 fi
 633
 634 AC_CHECK_FUNCS(OPENSSL_init_ssl SSL_library_init)
 635
 636 #; sc_cv_have_SSL_library_init='yes'; AC_DEFINE(HAVE_SSL_library_init)
 637 #if test -n "$WITH_OPENSSL"; then
 638 #     AC_CHECK_LIB(crypto, CRYPTO_new_ex_data, [], [AC_MSG_ERROR([library 'crypto' is required for OpenSSL])])
 639 #     FOUND_SSL_LIB="no"
 640 #     AC_CHECK_LIB(ssl, OPENSSL_init_ssl, [FOUND_SSL_LIB="yes"])
 641 #     AC_CHECK_LIB(ssl, SSL_library_init, [FOUND_SSL_LIB="yes"])
 642 #     AS_IF([test "x$FOUND_SSL_LIB" = xno], [AC_MSG_ERROR([library 'ssl' is required for OpenSSL; WITH_OPENSSL=])])
 643 #     AS_IF([test "x$FOUND_SSL_LIB" = xyes], [LIBS="$LIBS -L$L -lssl -lcrypto"])
 644 #fi
 645
 646 if test -n "$WITH_OPENSSL"; then
 647 AC_MSG_CHECKING(whether to include OpenSSL method option)
 648 AC_ARG_ENABLE(openssl-method, [  --enable-openssl-method       enable OpenSSL method option],
 649               [case "$enableval" in
 650                no) AC_MSG_RESULT(no);;
 651                *) AC_DEFINE(WITH_OPENSSL_METHOD) WITH_OPENSSL_METHOD=1; AC_MSG_RESULT(yes);;
 652                esac],
 653                [AC_MSG_RESULT(no)])
 654 fi
 655
 656 AC_MSG_CHECKING(whether to include deprecated resolver option)
 657 AC_ARG_ENABLE(res-deprecated, [  --enable-res-deprecated       enable deprecated resolver options],
 658               [case "$enableval" in
 659                no) AC_MSG_RESULT(no);;
 660                *) AC_DEFINE(WITH_RES_DEPRECATED) WITH_RES_DEPRECATED=1; AC_MSG_RESULT(yes);;
 661                esac],
 662                [AC_MSG_RESULT(no)])
 663
 664 # check for fips support
 665 AC_MSG_CHECKING(whether to include openssl fips support)
 666 AC_ARG_ENABLE(fips, [  --enable-fips          enable OpenSSL FIPS support],
 667   [ case "$enableval" in
 668     yes) AC_MSG_RESULT(yes); WITH_FIPS=1 ;;
 669     *) AC_MSG_RESULT(no); WITH_FIPS= ;;
 670    esac],
 671    [ AC_MSG_RESULT(no);   WITH_FIPS= ])
 672
 673 if test -n "$WITH_FIPS"; then
 674   if test -n "$WITH_OPENSSL"; then
 675     AC_CHECK_PROG(HAVE_FIPSLD, fipsld, 1)
 676     if test "$sc_cv_have_openssl_ssl_h" != "yes" -o "$sc_cv_have_libssl" != "yes" -o ! "$HAVE_FIPSLD";
 677  then
 678       AC_MSG_WARN([not all components of OpenSSL found, disabling FIPS]);
 679       WITH_FIPS=
 680     fi
 681   else
 682     AC_MSG_WARN([must enable OpenSSL to enable FIPS; use --enable-openssl]);
 683   fi
 684 fi
 685
 686 if test -n "$WITH_FIPS"; then
 687   AC_MSG_CHECKING(for components of OpenSSL FIPS)
 688   # first, we need to find the include file <openssl/fips.h>
 689   AC_CACHE_VAL(sc_cv_have_openssl_fips_h,
 690     [AC_TRY_COMPILE([#define OPENSSL_FIPS
 691 #include <stddef.h>
 692 #include <openssl/fips.h>],[;],
 693       [sc_cv_have_openssl_fips_h=yes; ],
 694       [sv_cv_have_openssl_fips_h=no
 695         if test -n "$OPENSSL_BASE"; then
 696           I="$OPENSSL_BASE/include"
 697           i="$I/openssl/fips.h"
 698           if test -r "$i"; then
 699             AC_MSG_NOTICE(found $i)
 700             sc_cv_have_openssl_fips_h=yes;
 701           fi
 702         fi
 703       ]
 704     )]
 705   )
 706   if test "$sv_cv_have_openssl_fips_h" = "yes"; then
 707     AC_DEFINE(HAVE_OPENSSL_FIPS_H)
 708   fi
 709   AC_MSG_NOTICE(checked for openssl/fips.h... $sc_cv_have_openssl_ssl_h)
 710 fi
 711
 712 if test -n "$WITH_FIPS" -a "$sc_cv_have_openssl_fips_h" = 'yes'; then
 713   # check for the libcrypto library with fips support
 714   AC_MSG_CHECKING(for libcrypto with FIPS support)
 715   AC_CACHE_VAL(sc_cv_have_libcrypto,
 716     [ LIBS0="$LIBS"
 717       echo $LIBS | grep -q "\-lcrypto"
 718       if test $? -ne 0; then
 719         if test -n "$OPENSSL_BASE"; then
 720           L="$OPENSSL_BASE/lib"; LIBS="$LIBS -L$L -lcrypto"
 721         else
 722           LIBS="$LIBS -lcrypto"
 723         fi
 724       fi
 725       AC_TRY_LINK([#define OPENSSL_FIPS
 726 #include <openssl/ssl.h>
 727 #include <openssl/fips.h>],
 728         [int res = FIPS_mode_set(1);],
 729         [sc_cv_have_libcrypto='yes'],
 730         [sc_cv_have_libcrypto='no']
 731       )
 732       if test "$sc_cv_have_libcrypto" != 'yes'; then
 733         LIBS="$LIBS0"
 734       fi
 735     ]
 736   )
 737   if test "$sc_cv_have_libcrypto" = 'yes'; then
 738     AC_DEFINE(HAVE_LIBCRYPTO)
 739   fi
 740   AC_MSG_RESULT($sc_cv_have_libcrypto)
 741 fi
 742
 743 if test -n "$WITH_FIPS"; then
 744   if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then
 745     AC_DEFINE(WITH_FIPS)
 746     AC_DEFINE(OPENSSL_FIPS)
 747   else
 748     AC_MSG_WARN([not all components of OpenSSL FIPS found, disabling it]);
 749   fi
 750 fi
 751
 752 AC_MSG_CHECKING(whether to include tun/tap address support)
 753 AC_ARG_ENABLE(tun, [  --disable-tun           disable TUN/TAP support],
 754               [case "$enableval" in
 755                no) AC_MSG_RESULT(no);  WITH_TUN= ;;
 756                *)  AC_MSG_RESULT(yes); WITH_TUN=1 ;;
 757                esac],
 758                [AC_MSG_RESULT(yes);    WITH_TUN=1 ])
 759
 760 #
 761 if ! test "$ac_cv_header_linux_if_tun_h" = 'yes'; then
 762   AC_MSG_WARN(include file linux/if_tun.h not found, disabling TUN)
 763   WITH_TUN=
 764 fi
 765 #
 766 if test -n "$WITH_TUN"; then
 767   AC_DEFINE(WITH_TUN)
 768 fi
 769
 770 AC_MSG_CHECKING(whether to include system call tracing)
 771 AC_ARG_ENABLE(sycls, [  --disable-sycls         disable system call tracing],
 772               [case "$enableval" in
 773                no) SYCLS=""; SSLCLS=""; AC_MSG_RESULT(no);;
 774                *) AC_DEFINE(WITH_SYCLS)
 775                  SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes);;
 776                esac],
 777                [AC_DEFINE(WITH_SYCLS)
 778                  SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes)])
 779 AC_SUBST(SYCLS)
 780 AC_SUBST(SSLCLS)
 781
 782 AC_MSG_CHECKING(whether to include file descriptor analyzer)
 783 AC_ARG_ENABLE(filan, [  --disable-filan         disable file descriptor analyzer],
 784               [case "$enableval" in
 785                no) FILAN=""; AC_MSG_RESULT(no);;
 786                *) AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes);;
 787                esac],
 788                [AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes)])
 789 AC_SUBST(FILAN)
 790
 791 AC_MSG_CHECKING(whether to include retry support)
 792 AC_ARG_ENABLE(retry, [  --disable-retry         disable retry support],
 793               [case "$enableval" in
 794                no) AC_MSG_RESULT(no);;
 795                *) AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes);;
 796                esac],
 797                [AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes)])
 798
 799 AC_MSG_CHECKING(included message level)
 800 AC_ARG_ENABLE(msglevel, [  --enable-msglevel=N     set max verbosity to debug,info,notice,warn,error,fatal],
 801               [case "$enableval" in
 802                0|DEBUG|Debug|debug) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;
 803                1|INFO|Info|info)  AC_DEFINE(WITH_MSGLEVEL,1) AC_MSG_RESULT(info);;
 804                2|NOTICE|Notice|notice) AC_DEFINE(WITH_MSGLEVEL,2) AC_MSG_RESULT(notice);;
 805                3|WARN|Warn|warn) AC_DEFINE(WITH_MSGLEVEL,3) AC_MSG_RESULT(warn);;
 806                4|ERROR|Error|error) AC_DEFINE(WITH_MSGLEVEL,4) AC_MSG_RESULT(error);;
 807                5|FATAL|Fatal|fatal) AC_DEFINE(WITH_MSGLEVEL,5) AC_MSG_RESULT(fatal);;
 808                *) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;
 809                esac],
 810                [AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug)])
 811
 812 #AC_SUBST(V_INCL)
 813
 814 dnl Checks for typedefs, structures, and compiler characteristics.
 815 AC_C_CONST
 816 AC_TYPE_UID_T
 817 AC_TYPE_MODE_T
 818 AC_TYPE_OFF_T
 819 AC_TYPE_PID_T
 820 AC_TYPE_SIZE_T
 821 AC_STRUCT_ST_BLKSIZE
 822 AC_STRUCT_ST_BLOCKS
 823 AC_STRUCT_ST_RDEV
 824 AC_HEADER_TIME
 825
 826 dnl Check for extra realtime library (for Solaris)
 827 AC_CHECK_FUNC(nanosleep, AC_DEFINE(HAVE_NANOSLEEP), AC_CHECK_LIB(rt, nanosleep, [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_NANOSLEEP)]))
 828 #AC_CHECK_FUNC(nanosleep, , AC_CHECK_LIB(rt, nanosleep))
 829
 830 dnl Checks for library functions.
 831 AC_PROG_GCC_TRADITIONAL
 832 AC_FUNC_MEMCMP
 833 AC_TYPE_SIGNAL
 834 AC_FUNC_STRFTIME
 835 AC_CHECK_FUNCS(putenv select pselect poll socket strtod strtol)
 836 AC_CHECK_FUNCS(strtoul uname getpgid getsid gethostbyname getaddrinfo)
 837 AC_CHECK_FUNCS(getprotobynumber)
 838 AC_CHECK_FUNCS(setgroups inet_aton)
 839
 840 AC_CHECK_FUNCS(grantpt unlockpt)
 841
 842 # GR AC_CHECK_FUNCS only checks linking, not prototype. This may lead to implicit
 843 # function declarations and to SIGSEGV on systems with 32bit int and 64bit pointer
 844
 845 dnl Search for cfsetispeed(),cfgetispeed(),cfsetspeed(),cfgetospeed() functions
 846 AC_CHECK_FUNCS(cfsetispeed cfgetispeed cfsetospeed cfgetospeed)
 847
 848 ###################################
 849 # check for prototype and existence of functions that return a pointer
 850 # defines in config.h: HAVE_PROTOTYPE_LIB_$1
 851 AC_CHECK_PROTOTYPE_LIB(posix_memalign)
 852 AC_CHECK_PROTOTYPE_LIB(strdup)
 853 AC_CHECK_PROTOTYPE_LIB(strerror)
 854 AC_CHECK_PROTOTYPE_LIB(strstr)
 855 AC_CHECK_PROTOTYPE_LIB(getipnodebyname)
 856 AC_CHECK_PROTOTYPE_LIB(strndup)
 857 AC_CHECK_PROTOTYPE_LIB(memrchr)
 858 AC_CHECK_PROTOTYPE_LIB(if_indextoname)
 859 AC_CHECK_PROTOTYPE_LIB(ptsname)
 860
 861 AC_MSG_CHECKING(for long long)
 862 AC_CACHE_VAL(sc_cv_type_longlong,
 863 [AC_TRY_COMPILE([],[long long s;],
 864 [sc_cv_type_longlong=yes],
 865 [sc_cv_type_longlong=no])])
 866 if test $sc_cv_type_longlong = yes; then
 867    AC_DEFINE(HAVE_TYPE_LONGLONG)
 868 fi
 869 AC_MSG_RESULT($sc_cv_type_longlong)
 870
 871 AC_CHECK_TYPE(sig_atomic_t,AC_DEFINE(HAVE_TYPE_SIG_ATOMIC_T),,[#include "sysincludes.h"])
 872
 873 AC_MSG_CHECKING(for bool)
 874 AC_CACHE_VAL(sc_cv_type_bool,
 875 [AC_TRY_COMPILE([#ifdef HAVE_STDBOOL_H
 876    #include <stdbool.h>
 877    #endif],
 878 [bool b;],
 879 [sc_cv_type_bool=yes],
 880 [sc_cv_type_bool=no])])
 881 if test $sc_cv_type_bool = yes; then
 882    AC_DEFINE(HAVE_TYPE_BOOL)
 883 fi
 884 AC_MSG_RESULT($sc_cv_type_bool)
 885
 886 # following builtin macro does not check unistd.h and sys/socket.h where
 887 # socklen_t might be defined
 888 #AC_CHECK_TYPE(socklen_t, int)
 889 #
 890 AC_MSG_CHECKING(for socklen_t)
 891 AC_CACHE_VAL(sc_cv_type_socklen,
 892 [AC_TRY_COMPILE([#include <sys/types.h>
 893 #include <sys/socket.h>
 894 #include <unistd.h>],[socklen_t s;],
 895 [sc_cv_type_socklen=yes],
 896 [sc_cv_type_socklen=no])])
 897 if test $sc_cv_type_socklen = yes; then
 898    AC_DEFINE(HAVE_TYPE_SOCKLEN)
 899 fi
 900 AC_MSG_RESULT($sc_cv_type_socklen)
 901
 902 AC_MSG_CHECKING(for struct stat64)
 903 AC_CACHE_VAL(sc_cv_type_stat64,
 904 [AC_TRY_COMPILE([#include <sys/stat.h>],[struct stat64 s;],
 905 [sc_cv_type_stat64=yes],
 906 [sc_cv_type_stat64=no])])
 907 if test $sc_cv_type_stat64 = yes; then
 908    AC_DEFINE(HAVE_TYPE_STAT64)
 909 fi
 910 AC_MSG_RESULT($sc_cv_type_stat64)
 911
 912 AC_MSG_CHECKING(for off64_t)
 913 AC_CACHE_VAL(sc_cv_type_off64,
 914 [AC_TRY_COMPILE([#include <unistd.h>],[off64_t s;],
 915 [sc_cv_type_off64=yes],
 916 [sc_cv_type_off64=no])])
 917 if test $sc_cv_type_off64 = yes; then
 918    AC_DEFINE(HAVE_TYPE_OFF64)
 919 fi
 920 AC_MSG_RESULT($sc_cv_type_off64)
 921
 922 AC_MSG_CHECKING(for sighandler_t)
 923 AC_CACHE_VAL(sc_cv_type_sighandler,
 924 [AC_TRY_COMPILE([#include <signal.h>],[sighandler_t s;],
 925 [sc_cv_type_sighandler=yes],
 926 [sc_cv_type_sighandler=no])])
 927 if test $sc_cv_type_sighandler = yes; then
 928    AC_DEFINE(HAVE_TYPE_SIGHANDLER)
 929 fi
 930 AC_MSG_RESULT($sc_cv_type_socklen)
 931
 932 AC_MSG_CHECKING(for uint8_t)
 933 AC_CACHE_VAL(sc_cv_type_uint8,
 934 [AC_TRY_COMPILE([#include <sys/types.h>
 935 #if HAVE_STDINT_H
 936 #include <stdint.h>
 937 #endif
 938 /* Tru64 has uint8_t etc from netdb.h */
 939 #if HAVE_NETDB_H
 940 #include <netdb.h>
 941 #endif
 942 #include <unistd.h>],[uint8_t s;],
 943 [sc_cv_type_uint8=yes],
 944 [sc_cv_type_uint8=no])])
 945 if test $sc_cv_type_uint8 = yes; then
 946    AC_DEFINE(HAVE_TYPE_UINT8)
 947 fi
 948 AC_MSG_RESULT($sc_cv_type_uint8)
 949
 950 AC_MSG_CHECKING(for uint16_t)
 951 AC_CACHE_VAL(sc_cv_type_uint16,
 952 [AC_TRY_COMPILE([#include <sys/types.h>
 953 #if HAVE_STDINT_H
 954 #include <stdint.h>
 955 #endif
 956 /* Tru64 has uint16_t etc from netdb.h */
 957 #if HAVE_NETDB_H
 958 #include <netdb.h>
 959 #endif
 960 #include <unistd.h>],[uint16_t s;],
 961 [sc_cv_type_uint16=yes],
 962 [sc_cv_type_uint16=no])])
 963 if test $sc_cv_type_uint16 = yes; then
 964    AC_DEFINE(HAVE_TYPE_UINT16)
 965 fi
 966 AC_MSG_RESULT($sc_cv_type_uint16)
 967
 968 AC_MSG_CHECKING(for uint32_t)
 969 AC_CACHE_VAL(sc_cv_type_uint32,
 970 [AC_TRY_COMPILE([#include <sys/types.h>
 971 #if HAVE_STDINT_H
 972 #include <stdint.h>
 973 #endif
 974 /* Tru64 has uint32_t etc from netdb.h */
 975 #if HAVE_NETDB_H
 976 #include <netdb.h>
 977 #endif
 978 #include <unistd.h>],[uint32_t s;],
 979 [sc_cv_type_uint32=yes],
 980 [sc_cv_type_uint32=no])])
 981 if test $sc_cv_type_uint32 = yes; then
 982    AC_DEFINE(HAVE_TYPE_UINT32)
 983 fi
 984 AC_MSG_RESULT($sc_cv_type_uint32)
 985
 986 AC_MSG_CHECKING(for uint64_t)
 987 AC_CACHE_VAL(sc_cv_type_uint64,
 988 [AC_TRY_COMPILE([#include <sys/types.h>
 989 #if HAVE_STDINT_H
 990 #include <stdint.h>
 991 #endif
 992 /* Tru64 has uint32_t etc from netdb.h */
 993 #if HAVE_NETDB_H
 994 #include <netdb.h>
 995 #endif
 996 #include <unistd.h>],[uint64_t s;],
 997 [sc_cv_type_uint64=yes],
 998 [sc_cv_type_uint64=no])])
 999 if test $sc_cv_type_uint64 = yes; then
1000    AC_DEFINE(HAVE_TYPE_UINT64)
1001 fi
1002 AC_MSG_RESULT($sc_cv_type_uint64)
1003
1004 ### AIX 4.1 needs _XOPEN_EXTENDED_SOURCE for syslog headers,
1005 # but then gets problems with 3rd arg of getsockaddr...
1006 #AC_MSG_CHECKING(for _XOPEN_EXTENDED_SOURCE requirement)
1007 #CFLAGS="-Werror -Wall"
1008 #AC_TRY_COMPILE([#include <sys/syslog.h>],
1009 #[syslog(0," ");],
1010 #[AC_MSG_RESULT(no)],
1011 #[AC_MSG_RESULT(required); AC_DEFINE(_XOPEN_EXTENDED_SOURCE)])
1012
1013
1014 ### fds_bits
1015 AC_MSG_CHECKING(for fdset->fds_bits)
1016 AC_TRY_COMPILE([#include <sys/types.h>
1017 #if HAVE_SYS_SELECT_H
1018 #include <sys/select.h>
1019 #endif],
1020 [fd_set s; s.fds_bits[0]=0;],
1021 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_FDS_BITS)],
1022 [AC_MSG_RESULT(no);])
1023
1024 AC_MSG_CHECKING(for struct termios . c_ispeed)
1025 AC_TRY_COMPILE([#include <unistd.h>
1026 #if HAVE_TERMIOS_H
1027 #include <termios.h>
1028 #endif],
1029 [struct termios s; s.c_ispeed=0;],
1030 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_STRUCT_TERMIOS_C_ISPEED)],
1031 [AC_MSG_RESULT(no);])
1032
1033 AC_MSG_CHECKING(for struct termios . c_ospeed)
1034 AC_TRY_COMPILE([#include <unistd.h>
1035 #if HAVE_TERMIOS_H
1036 #include <termios.h>
1037 #endif],
1038 [struct termios s; s.c_ospeed=0;],
1039 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_STRUCT_TERMIOS_C_OSPEED)],
1040 [AC_MSG_RESULT(no);])
1041
1042 AC_MSG_CHECKING(for sa_family_t)
1043 AC_CACHE_VAL(sc_cv_type_sa_family_t,
1044 [AC_TRY_COMPILE([#include <sys/types.h>
1045 #include <sys/socket.h>
1046 #include <netinet/in.h>],[sa_family_t s;],
1047 [sc_cv_type_sa_family_t=yes],
1048 [sc_cv_type_sa_family_t=no])])
1049 if test $sc_cv_type_sa_family_t = yes; then
1050    AC_DEFINE(HAVE_TYPE_SA_FAMILY_T)
1051 fi
1052 AC_MSG_RESULT($sc_cv_type_sa_family_t)
1053
1054 AC_MSG_CHECKING(for struct sock_extended_err)
1055 AC_CACHE_VAL(sc_cv_struct_sock_extended_err,
1056 [AC_TRY_COMPILE([#include <linux/types.h>
1057 #if TIME_WITH_SYS_TIME
1058 #include <sys/time.h>
1059 #endif
1060 #if HAVE_LINUX_ERRQUEUE_H
1061 #include <linux/errqueue.h>
1062 #endif],[struct sock_extended_err s;],
1063 [sc_cv_struct_sock_extended_err=yes],
1064 [sc_cv_struct_sock_extended_err=no])])
1065 if test $sc_cv_struct_sock_extended_err = yes; then
1066    AC_DEFINE(HAVE_STRUCT_SOCK_EXTENDED_ERR)
1067 fi
1068 AC_MSG_RESULT($sc_cv_struct_sock_extended_err)
1069
1070 AC_MSG_CHECKING(for struct sigaction.sa_sigaction)
1071 AC_CACHE_VAL(sc_cv_struct_sigaction_sa_sigaction,
1072 [AC_TRY_COMPILE([#include <signal.h>],[struct sigaction s;s.sa_sigaction=0;],
1073 [sc_cv_struct_sigaction_sa_sigaction=yes],
1074 [sc_cv_struct_sigaction_sa_sigaction=no])])
1075 if test $sc_cv_struct_sigaction_sa_sigaction = yes; then
1076    AC_DEFINE(HAVE_STRUCT_SIGACTION_SA_SIGACTION)
1077 fi
1078 AC_MSG_RESULT($sc_cv_struct_sigaction_sa_sigaction)
1079
1080 # there is another issue with termios: OSR requires "#define _SVID3 ..."
1081 # for reasonable termios support. We check this situation using IMAXBEL
1082 AC_MSG_CHECKING(if _SVID3 is helpful)
1083 AC_CACHE_VAL(ac_cv_svid3,
1084  [AC_TRY_COMPILE([#include <termios.h>],
1085  [int i=IMAXBEL],
1086  [ac_cv_svid3=no],
1087  [AC_TRY_COMPILE([#define _SVID3 1
1088 #include <termios.h>],
1089    [int i=IMAXBEL],
1090    [ac_cv_svid3=yes],
1091    [ac_cv_svid3=no]
1092  )]
1093 )])
1094 if test $ac_cv_svid3 = yes; then
1095   AC_DEFINE(_SVID3)
1096 fi
1097 AC_MSG_RESULT($ac_cv_svid3)
1098
1099
1100 # Openindiana needs _XPG4_2 for CMSG stuff
1101 AC_MSG_CHECKING(if _XPG4_2 is helpful)
1102 AC_CACHE_VAL(ac_cv_xpg4_2,
1103  [AC_TRY_LINK([#include <sys/socket.h>],
1104  [int i=CMSG_DATA(0)],
1105  [ac_cv_xpg4_2=no],
1106  [AC_TRY_LINK([#define _XPG4_2 1
1107 #include <sys/socket.h>],
1108    [int i=CMSG_DATA(0)],
1109    [ac_cv_xpg4_2=yes],
1110    [ac_cv_xpg4_2=no]
1111  )]
1112 )])
1113 if test $ac_cv_xpg4_2 = yes; then
1114   AC_DEFINE(_XPG4_2)
1115 fi
1116 AC_MSG_RESULT($ac_cv_xpg4_2)
1117
1118 # When on Openindiana _XPG4_2 is defined (see above)
1119 # we also need to define __EXTENSIONS__ for basic stuff.
1120 # Note that <sys/procset.h> is important on Openindiana
1121 # but does not exist on Linux
1122 if test "$ac_cv_xpg4_2" = yes; then
1123  AC_MSG_CHECKING(if __EXTENSIONS__ is helpful)
1124  AC_CACHE_VAL(ac_cv___extensions__,
1125   [AC_TRY_COMPILE([#include <sys/procset.h>],
1126   [procset_t *s=0;],
1127   [ac_cv___extensions__=no],
1128   [AC_TRY_COMPILE([#define __EXTENSIONS__ 1
1129 #include <sys/procset.h>],
1130     [procset_t *s=0;],
1131     [ac_cv___extensions__=yes],
1132     [ac_cv___extensions__=no]
1133   )]
1134  )])
1135  if test $ac_cv___extensions__ = yes; then
1136    AC_DEFINE(__EXTENSIONS__)
1137  fi
1138  AC_MSG_RESULT($ac_cv___extensions__)
1139 fi
1140
1141 # When on Openindiana __EXTENSIONS__ is defined (see above)
1142 # _POSIX_PTHREAD_SEMANTICS must be defined for standard ctime_r()
1143 if test "$ac_cv___extensions__" = yes; then
1144  AC_MSG_CHECKING(if _POSIX_PTHREAD_SEMANTICS is helpful)
1145  AC_CACHE_VAL(ac_cv__posix_pthread_semantics,
1146   [AC_TRY_COMPILE([#include <time.h>],
1147   [char *s = ctime_r(0,0);],
1148   [ac_cv__posix_pthread_semantics=no],
1149   [AC_TRY_COMPILE([#define _POSIX_PTHREAD_SEMANTICS 1
1150 #include <time.h>],
1151     [char *s = ctime_r(0,0);],
1152     [ac_cv__posix_pthread_semantics=yes],
1153     [ac_cv__posix_pthread_semantics=no]
1154   )]
1155  )])
1156  if test $ac_cv__posix_pthread_semantics = yes; then
1157    AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
1158  fi
1159  AC_MSG_RESULT($ac_cv__posix_pthread_semantics)
1160 fi
1161
1162
1163 # struct timespec
1164 AC_MSG_CHECKING(for struct timespec)
1165 AC_CACHE_VAL(sc_cv_struct_timespec,
1166 [AC_TRY_COMPILE([#include <time.h>
1167 #if HAVE_SYS_TIME_H
1168 #include <sys/time.h>
1169 #endif],[struct timespec s;],
1170 [sc_cv_struct_timespec=yes],
1171 [sc_cv_struct_timespec=no])])
1172 if test $sc_cv_struct_timespec = yes; then
1173    AC_DEFINE(HAVE_STRUCT_TIMESPEC)
1174 fi
1175 AC_MSG_RESULT($sc_cv_struct_timespec)
1176
1177
1178 # struct linger; FreeBSD requires sys/types.h for sys/socket.h
1179 AC_MSG_CHECKING(for struct linger)
1180 AC_CACHE_VAL(sc_cv_struct_linger,
1181 [AC_TRY_COMPILE([#include <sys/types.h>
1182 #include <sys/socket.h>],[struct linger s;],
1183 [sc_cv_struct_linger=yes],
1184 [sc_cv_struct_linger=no])])
1185 if test $sc_cv_struct_linger = yes; then
1186    AC_DEFINE(HAVE_STRUCT_LINGER)
1187 fi
1188 AC_MSG_RESULT($sc_cv_struct_linger)
1189
1190
1191 # struct ip (for IPv4 header info)
1192 AC_MSG_CHECKING(for struct ip)
1193 AC_CACHE_VAL(sc_cv_struct_ip,
1194 [AC_TRY_COMPILE([#include <netinet/in.h>
1195 #include <netinet/ip.h>],[struct ip s;],
1196 [sc_cv_struct_ip=yes],
1197 [sc_cv_struct_ip=no])])
1198 if test $sc_cv_struct_ip = yes; then
1199    AC_DEFINE(HAVE_STRUCT_IP)
1200 fi
1201 AC_MSG_RESULT($sc_cv_struct_ip)
1202
1203 # struct ip_mreq (for multicasting options)
1204 AC_MSG_CHECKING(for struct ip_mreq)
1205 AC_CACHE_VAL(sc_cv_struct_ip_mreq,
1206 [AC_TRY_COMPILE([#include <sys/types.h>
1207 #include <sys/socket.h>
1208 #include <netinet/in.h>],[struct ip_mreq s;],
1209 [sc_cv_struct_ip_mreq=yes],
1210 [sc_cv_struct_ip_mreq=no])])
1211 if test $sc_cv_struct_ip_mreq = yes; then
1212    AC_DEFINE(HAVE_STRUCT_IP_MREQ)
1213 fi
1214 AC_MSG_RESULT($sc_cv_struct_ip_mreq)
1215
1216 # struct ip_mreqn (for multicasting options)
1217 AC_MSG_CHECKING(for struct ip_mreqn)
1218 AC_CACHE_VAL(sc_cv_struct_ip_mreqn,
1219 [AC_TRY_COMPILE([#include <sys/types.h>
1220 #include <sys/socket.h>
1221 #include <netinet/in.h>
1222 #include <netinet/ip.h>],[struct ip_mreqn s;],
1223 [sc_cv_struct_ip_mreqn=yes],
1224 [sc_cv_struct_ip_mreqn=no])])
1225 if test $sc_cv_struct_ip_mreqn = yes; then
1226    AC_DEFINE(HAVE_STRUCT_IP_MREQN)
1227 fi
1228 AC_MSG_RESULT($sc_cv_struct_ip_mreqn)
1229
1230 # struct ipv6_mreq (for multicasting options)
1231 AC_MSG_CHECKING(for struct ipv6_mreq)
1232 AC_CACHE_VAL(sc_cv_struct_ipv6_mreq,
1233 [AC_TRY_COMPILE([#include <sys/types.h>
1234 #include <sys/socket.h>
1235 #include <netinet/in.h>],[struct ipv6_mreq s;],
1236 [sc_cv_struct_ipv6_mreq=yes],
1237 [sc_cv_struct_ipv6_mreq=no])])
1238 if test $sc_cv_struct_ipv6_mreq = yes; then
1239    AC_DEFINE(HAVE_STRUCT_IPV6_MREQ)
1240 fi
1241 AC_MSG_RESULT($sc_cv_struct_ipv6_mreq)
1242
1243 # struct ip_mreq_source (for multicasting options)
1244 AC_MSG_CHECKING(for struct ip_mreq_source)
1245 AC_CACHE_VAL(sc_cv_struct_ip_mreq_source,
1246 [AC_TRY_COMPILE([#include <sys/types.h>
1247 #include <sys/socket.h>
1248 #include <netinet/in.h>
1249 #include <netinet/ip.h>],[struct ip_mreq_source s;],
1250 [sc_cv_struct_ip_mreq_source=yes],
1251 [sc_cv_struct_ip_mreq_source=no])])
1252 if test $sc_cv_struct_ip_mreq_source = yes; then
1253    AC_DEFINE(HAVE_STRUCT_IP_MREQ_SOURCE)
1254 fi
1255 AC_MSG_RESULT($sc_cv_struct_ip_mreqn)
1256
1257
1258 # struct ifreq (for network interfaces)
1259 AC_MSG_CHECKING(for struct ifreq)
1260 AC_CACHE_VAL(sc_cv_struct_ifreq,
1261 [AC_TRY_COMPILE([#include <sys/types.h>
1262 #include <sys/socket.h>
1263 #include <net/if.h>],[struct ifreq s;],
1264 [sc_cv_struct_ifreq=yes],
1265 [sc_cv_struct_ifreq=no])])
1266 if test $sc_cv_struct_ifreq = yes; then
1267    AC_DEFINE(HAVE_STRUCT_IFREQ)
1268 fi
1269 AC_MSG_RESULT($sc_cv_struct_ifreq)
1270
1271 # struct ifreq.ifr_index
1272 # on most systems that have struct ifreq
1273 AC_MSG_CHECKING(for struct ifreq.ifr_index)
1274 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_index,
1275 [AC_TRY_COMPILE([#include <sys/types.h>
1276 #include <sys/socket.h>
1277 #include <net/if.h>],
1278 [struct ifreq ir;ir.ifr_index=0;],
1279 [sc_cv_struct_ifreq_ifr_index=yes],
1280 [sc_cv_struct_ifreq_ifr_index=no])])
1281 if test $sc_cv_struct_ifreq_ifr_index = yes; then
1282    AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_INDEX)
1283 fi
1284 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_index)
1285
1286 # struct ifreq.ifr_ifindex
1287 # Linux has ifr_ifindex instead of ifr_index
1288 AC_MSG_CHECKING(for struct ifreq.ifr_ifindex)
1289 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_ifindex,
1290 [AC_TRY_COMPILE([#include <sys/types.h>
1291 #include <sys/socket.h>
1292 #include <net/if.h>],
1293 [struct ifreq ir;ir.ifr_ifindex=0;],
1294 [sc_cv_struct_ifreq_ifr_ifindex=yes],
1295 [sc_cv_struct_ifreq_ifr_ifindex=no])])
1296 if test $sc_cv_struct_ifreq_ifr_ifindex = yes; then
1297    AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_IFINDEX)
1298 fi
1299 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_ifindex)
1300
1301
1302 # some systems have a sa_len field in struct sockaddr and we need to support it
1303 # so we can compare sockaddrs simply with memcmp
1304 AC_MSG_CHECKING(for struct sockaddr.sa_len)
1305 AC_CACHE_VAL(sc_cv_struct_sockaddr_salen,
1306 [AC_TRY_COMPILE([#include <sys/types.h>
1307 #include <sys/socket.h>],
1308 [struct sockaddr sa;sa.sa_len=0;],
1309 [sc_cv_struct_sockaddr_salen=yes],
1310 [sc_cv_struct_sockaddr_salen=no])])
1311 if test $sc_cv_struct_sockaddr_salen = yes; then
1312    AC_DEFINE(HAVE_STRUCT_SOCKADDR_SALEN)
1313 fi
1314 AC_MSG_RESULT($sc_cv_struct_sockaddr_salen)
1315
1316 ### IP6 sockaddr_in6
1317
1318 AC_MSG_CHECKING(for component names of sockaddr_in6)
1319 AC_TRY_COMPILE([#include <sys/types.h>
1320 #include <netinet/in.h>],
1321 [struct sockaddr_in6 sa6;sa6.sin6_addr.s6_addr[0]=0;],
1322 [AC_MSG_RESULT(s6_addr);
1323  AC_DEFINE(HAVE_IP6_SOCKADDR, 0)],
1324 [AC_TRY_COMPILE([#include <sys/types.h>
1325 #include <netinet/in.h>],
1326  [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr.u6_addr16[0]=0;],
1327  [AC_MSG_RESULT(u6_addr.u6_addr16);
1328   AC_DEFINE(HAVE_IP6_SOCKADDR, 1)],
1329  [AC_TRY_COMPILE([#include <sys/types.h>
1330 #include <netinet/in.h>],
1331   [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr16[0]=0;],
1332   [AC_MSG_RESULT(u6_addr16); AC_DEFINE(HAVE_IP6_SOCKADDR, 2)],
1333   [AC_TRY_COMPILE([#include <sys/types.h>
1334 #include <netinet/in.h>],
1335    [struct sockaddr_in6 sa6;sa6.sin6_addr.in6_u.u6_addr16[0]=0;],
1336    [AC_MSG_RESULT(in6_u.u6_addr16);
1337     AC_DEFINE(HAVE_IP6_SOCKADDR, 3)],
1338    [AC_TRY_COMPILE([#include <sys/types.h>
1339 #include <netinet/in.h>],
1340     [struct sockaddr_in6 sa6;sa6.sin6_addr._S6_un._S6_u32[0]=0;],
1341     [AC_MSG_RESULT(_S6_un._S6_u32);
1342      AC_DEFINE(HAVE_IP6_SOCKADDR, 4)],
1343     [AC_TRY_COMPILE([#include <sys/types.h>
1344 #include <netinet/in.h>],
1345      [struct sockaddr_in6 sa6;sa6.sin6_addr.__u6_addr.__u6_addr32[0]=0;],
1346      [AC_MSG_RESULT(__u6_addr.__u6_addr32);
1347       AC_DEFINE(HAVE_IP6_SOCKADDR, 5)],
1348
1349     [AC_MSG_RESULT([none or unknown])]
1350 )])])])])])
1351
1352 dnl Check for struct iovec
1353 AC_MSG_CHECKING(for struct iovec)
1354 AC_CACHE_VAL(sc_cv_struct_iovec,
1355 [AC_TRY_COMPILE([#include <sys/uio.h>],[struct iovec s;],
1356 [sc_cv_struct_iovec=yes],
1357 [sc_cv_struct_iovec=no])])
1358 if test $sc_cv_struct_iovec = yes; then
1359    AC_DEFINE(HAVE_STRUCT_IOVEC)
1360 fi
1361 AC_MSG_RESULT($sc_cv_struct_iovec)
1362
1363 dnl check for msg_control in struct msghdr
1364 AC_MSG_CHECKING(for struct msghdr.msg_control)
1365 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrol,
1366 [AC_TRY_COMPILE([#include <sys/types.h>
1367 #include <sys/socket.h>],
1368 [struct msghdr s;s.msg_control=0;],
1369 [sc_cv_struct_msghdr_msgcontrol=yes],
1370 [sc_cv_struct_msghdr_msgcontrol=no])])
1371 if test $sc_cv_struct_msghdr_msgcontrol = yes; then
1372    AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROL)
1373 fi
1374 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrol)
1375
1376 dnl check for msg_controllen in struct msghdr
1377 AC_MSG_CHECKING(for struct msghdr.msg_controllen)
1378 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrollen,
1379 [AC_TRY_COMPILE([#include <sys/types.h>
1380 #include <sys/socket.h>],
1381 [struct msghdr s;s.msg_controllen=0;],
1382 [sc_cv_struct_msghdr_msgcontrollen=yes],
1383 [sc_cv_struct_msghdr_msgcontrollen=no])])
1384 if test $sc_cv_struct_msghdr_msgcontrollen = yes; then
1385    AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN)
1386 fi
1387 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrollen)
1388
1389 dnl check for msg_flags in struct msghdr
1390 AC_MSG_CHECKING(for struct msghdr.msgflags)
1391 AC_CACHE_VAL(sc_cv_struct_msghdr_msgflags,
1392 [AC_TRY_COMPILE([#include <sys/types.h>
1393 #include <sys/socket.h>],
1394 [struct msghdr s;s.msg_flags=0;],
1395 [sc_cv_struct_msghdr_msgflags=yes],
1396 [sc_cv_struct_msghdr_msgflags=no])])
1397 if test $sc_cv_struct_msghdr_msgflags = yes; then
1398    AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGFLAGS)
1399 fi
1400 AC_MSG_RESULT($sc_cv_struct_msghdr_msgflags)
1401
1402 dnl check for struct cmsghdr
1403 AC_MSG_CHECKING(for struct cmsghdr)
1404 AC_CACHE_VAL(sc_cv_struct_cmsghdr,
1405 [AC_TRY_COMPILE([#include <sys/types.h>
1406 #include <sys/socket.h>
1407 #include <net/if.h>],[struct cmsghdr s;],
1408 [sc_cv_struct_cmsghdr=yes],
1409 [sc_cv_struct_cmsghdr=no])])
1410 if test $sc_cv_struct_cmsghdr = yes; then
1411    AC_DEFINE(HAVE_STRUCT_CMSGHDR)
1412 fi
1413 AC_MSG_RESULT($sc_cv_struct_cmsghdr)
1414
1415 dnl check for struct in_pktinfo
1416 AC_MSG_CHECKING(for struct in_pktinfo)
1417 AC_CACHE_VAL(sc_cv_struct_in_pktinfo,
1418 [AC_TRY_COMPILE([#include <sys/types.h>
1419 #include <sys/socket.h>
1420 #include <netinet/in.h>],[struct in_pktinfo s;],
1421 [sc_cv_struct_in_pktinfo=yes],
1422 [sc_cv_struct_in_pktinfo=no])])
1423 if test $sc_cv_struct_in_pktinfo = yes; then
1424    AC_DEFINE(HAVE_STRUCT_IN_PKTINFO)
1425 fi
1426 AC_MSG_RESULT($sc_cv_struct_in_pktinfo)
1427
1428 if test $sc_cv_struct_in_pktinfo = 'yes'; then
1429    dnl check for component ipi_spec_dst in struct in_pktinfo
1430    AC_MSG_CHECKING(for ipi_spec_dst in struct in_pktinfo)
1431    AC_CACHE_VAL(sc_cv_pktinfo_ipi_spec_dst,
1432    [AC_TRY_COMPILE([#include <sys/types.h>
1433    #include <sys/socket.h>
1434    #include <netinet/in.h>],[struct in_pktinfo s; s.ipi_spec_dst],
1435    [sc_cv_pktinfo_ipi_spec_dst=yes],
1436    [sc_cv_pktinfo_ipi_spec_dst=no])])
1437    if test $sc_cv_pktinfo_ipi_spec_dst = yes; then
1438       AC_DEFINE(HAVE_PKTINFO_IPI_SPEC_DST)
1439    fi
1440    AC_MSG_RESULT($sc_cv_pktinfo_ipi_spec_dst)
1441 fi
1442
1443 dnl check for struct in6_pktinfo
1444 AC_MSG_CHECKING(for struct in6_pktinfo)
1445 AC_CACHE_VAL(sc_cv_struct_in6_pktinfo,
1446 [AC_TRY_COMPILE([#include "sysincludes.h"],
1447 [struct in6_pktinfo s;],
1448 [sc_cv_struct_in6_pktinfo=yes],
1449 [sc_cv_struct_in6_pktinfo=no])])
1450 if test $sc_cv_struct_in6_pktinfo = yes; then
1451    AC_DEFINE(HAVE_STRUCT_IN6_PKTINFO)
1452 fi
1453 AC_MSG_RESULT($sc_cv_struct_in6_pktinfo)
1454
1455 dnl check for ip_hl in struct ip
1456 AC_MSG_CHECKING(for struct ip.ip_hl)
1457 AC_CACHE_VAL(sc_cv_struct_ip_ip_hl,
1458 [AC_TRY_COMPILE([#include <sys/types.h>
1459 #include <netinet/in_systm.h>
1460 #include <netinet/in.h>
1461 #include <netinet/ip.h>],
1462 [struct ip s;s.ip_hl=0;],
1463 [sc_cv_struct_ip_ip_hl=yes],
1464 [sc_cv_struct_ip_ip_hl=no])])
1465 if test $sc_cv_struct_ip_ip_hl = yes; then
1466    AC_DEFINE(HAVE_STRUCT_IP_IP_HL)
1467 fi
1468 AC_MSG_RESULT($sc_cv_struct_ip_ip_hl)
1469
1470
1471 dnl Library function checks
1472
1473 dnl Check sigaction()
1474 AC_CHECK_FUNC(sigaction, AC_DEFINE(HAVE_SIGACTION))
1475
1476 dnl Check for 64bit versions of system calls
1477 AC_CHECK_FUNC(stat64, AC_DEFINE(HAVE_STAT64))
1478 AC_CHECK_FUNC(fstat64, AC_DEFINE(HAVE_FSTAT64))
1479 AC_CHECK_FUNC(lstat64, AC_DEFINE(HAVE_LSTAT64))
1480 AC_CHECK_FUNC(lseek64, AC_DEFINE(HAVE_LSEEK64))
1481 AC_CHECK_FUNC(truncate64, AC_DEFINE(HAVE_TRUNCATE64))
1482 AC_CHECK_FUNC(ftruncate64, AC_DEFINE(HAVE_FTRUNCATE64))
1483
1484 AC_CHECK_FUNC(strtoll, AC_DEFINE(HAVE_STRTOLL))
1485 AC_CHECK_FUNC(hstrerror, AC_DEFINE(HAVE_HSTRERROR))
1486 AC_CHECK_FUNC(inet_ntop, AC_DEFINE(HAVE_INET_NTOP))
1487
1488 #if test "$ac_cv_func_hstrerror" = "yes"; then
1489 #  AC_MSG_CHECKING(if _XOPEN_SOURCE_EXTENDED is helpful)
1490 #  AC_CACHE_VAL(ac_cv_xopen_source_extended,
1491 #   [AC_TRY_COMPILE([#include <netdb.h>],
1492 #   [hstrerror()],
1493 #   [ac_cv_xopen_source_extended=no],
1494 #   [AC_TRY_COMPILE([#define _XOPEN_SOURCE_EXTENDED 1
1495 ##  include <netdb.h>],
1496 #     [hstrerror()],
1497 #     [ac_cv_xopen_source_extended=yes],
1498 #     [ac_cv_xopen_source_extended=no]
1499 #   )]
1500 #  )])
1501 #  if test $ac_cv_xopen_source_extended = yes; then
1502 #    AC_DEFINE(_XOPEN_SOURCE_EXTENDED)
1503 #  fi
1504 #  AC_MSG_RESULT($ac_cv_xopen_source_extended)
1505 #fi
1506
1507 dnl Search for openpty()
1508 # MacOS
1509 AC_CHECK_FUNC(openpty, AC_DEFINE(HAVE_OPENPTY))
1510 # AIX
1511 AC_CHECK_LIB(bsd, openpty,
1512   [LIBS="-lbsd $LIBS"; AC_DEFINE(HAVE_OPENPTY)])
1513 # Linux 2.4
1514 AC_CHECK_LIB(util, openpty,
1515   [LIBS="-lutil $LIBS"; AC_DEFINE(HAVE_OPENPTY)])
1516
1517 AC_CHECK_PROTOTYPE_LIB(gettimeofday)
1518
1519 AC_CHECK_LIB(rt, clock_gettime,
1520                  [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_CLOCK_GETTIME)])
1521
1522 dnl Search for flock()
1523 # with Linux it's in libc, with AIX in libbsd
1524 AC_CHECK_FUNC(flock, AC_DEFINE(HAVE_FLOCK),
1525         AC_CHECK_LIB(bsd, flock, [LIBS="-lbsd $LIBS"]))
1526
1527 dnl Search for setenv()
1528 AC_CHECK_FUNC(setenv, AC_DEFINE(HAVE_SETENV),
1529         AC_CHECK_LIB(isode, setenv, [LIBS="-lisode $LIBS"]))
1530
1531 dnl Search for unsetenv()
1532 AC_CHECK_FUNC(unsetenv, AC_DEFINE(HAVE_UNSETENV))
1533
1534 AC_CHECK_FUNC(TLS_client_method, AC_DEFINE(HAVE_TLS_client_method) ac_cv_have_tls_client_method=yes, AC_CHECK_LIB(crypt, TLS_client_method, [LIBS=-lcrypt $LIBS]))
1535 AC_CHECK_FUNC(TLS_server_method, AC_DEFINE(HAVE_TLS_server_method) ac_cv_have_tls_server_method=yes, AC_CHECK_LIB(crypt, TLS_server_method, [LIBS=-lcrypt $LIBS]))
1536 AC_CHECK_FUNC(DTLS_client_method, AC_DEFINE(HAVE_DTLS_client_method), AC_CHECK_LIB(crypt, DTLS_client_method, [LIBS=-lcrypt $LIBS]))
1537 AC_CHECK_FUNC(DTLS_server_method, AC_DEFINE(HAVE_DTLS_server_method), AC_CHECK_LIB(crypt, DTLS_server_method, [LIBS=-lcrypt $LIBS]))
1538 if test -n "$WITH_OPENSSL_METHOD" -o -z "$ac_cv_have_tls_client_method" -o -z "$ac_cv_have_tls_server_method" ; then
1539 dnl Search for SSLv2_client_method, SSLv2_server_method
1540 AC_CHECK_FUNC(SSLv2_client_method, AC_DEFINE(HAVE_SSLv2_client_method), AC_CHECK_LIB(crypt, SSLv2_client_method, [LIBS=-lcrypt $LIBS]))
1541 AC_CHECK_FUNC(SSLv2_server_method, AC_DEFINE(HAVE_SSLv2_server_method), AC_CHECK_LIB(crypt, SSLv2_server_method, [LIBS=-lcrypt $LIBS]))
1542 dnl
1543 AC_CHECK_FUNC(SSLv3_client_method, AC_DEFINE(HAVE_SSLv3_client_method), AC_CHECK_LIB(crypt, SSLv3_client_method, [LIBS=-lcrypt $LIBS]))
1544 AC_CHECK_FUNC(SSLv3_server_method, AC_DEFINE(HAVE_SSLv3_server_method), AC_CHECK_LIB(crypt, SSLv3_server_method, [LIBS=-lcrypt $LIBS]))
1545 AC_CHECK_FUNC(SSLv23_client_method, AC_DEFINE(HAVE_SSLv23_client_method), AC_CHECK_LIB(crypt, SSLv23_client_method, [LIBS=-lcrypt $LIBS]))
1546 AC_CHECK_FUNC(SSLv23_server_method, AC_DEFINE(HAVE_SSLv23_server_method), AC_CHECK_LIB(crypt, SSLv23_server_method, [LIBS=-lcrypt $LIBS]))
1547 AC_CHECK_FUNC(TLSv1_client_method, AC_DEFINE(HAVE_TLSv1_client_method), AC_CHECK_LIB(crypt, TLSv1_client_method, [LIBS=-lcrypt $LIBS]))
1548 AC_CHECK_FUNC(TLSv1_server_method, AC_DEFINE(HAVE_TLSv1_server_method), AC_CHECK_LIB(crypt, TLSv1_server_method, [LIBS=-lcrypt $LIBS]))
1549 AC_CHECK_FUNC(TLSv1_1_client_method, AC_DEFINE(HAVE_TLSv1_1_client_method), AC_CHECK_LIB(crypt, TLSv1_1_client_method, [LIBS=-lcrypt $LIBS]))
1550 AC_CHECK_FUNC(TLSv1_1_server_method, AC_DEFINE(HAVE_TLSv1_1_server_method), AC_CHECK_LIB(crypt, TLSv1_1_server_method, [LIBS=-lcrypt $LIBS]))
1551 AC_CHECK_FUNC(TLSv1_2_client_method, AC_DEFINE(HAVE_TLSv1_2_client_method), AC_CHECK_LIB(crypt, TLSv1_2_client_method, [LIBS=-lcrypt $LIBS]))
1552 AC_CHECK_FUNC(TLSv1_2_server_method, AC_DEFINE(HAVE_TLSv1_2_server_method), AC_CHECK_LIB(crypt, TLSv1_2_server_method, [LIBS=-lcrypt $LIBS]))
1553 AC_CHECK_FUNC(DTLSv1_client_method, AC_DEFINE(HAVE_DTLSv1_client_method), AC_CHECK_LIB(crypt, DTLSv1_client_method, [LIBS=-lcrypt $LIBS]))
1554 AC_CHECK_FUNC(DTLSv1_server_method, AC_DEFINE(HAVE_DTLSv1_server_method), AC_CHECK_LIB(crypt, DTLSv1_server_method, [LIBS=-lcrypt $LIBS]))
1555 AC_CHECK_FUNC(DTLSv1_2_client_method, AC_DEFINE(HAVE_DTLSv1_2_client_method), AC_CHECK_LIB(crypt, DTLSv1_2_client_method, [LIBS=-lcrypt $LIBS]))
1556 AC_CHECK_FUNC(DTLSv1_2_server_method, AC_DEFINE(HAVE_DTLSv1_2_server_method), AC_CHECK_LIB(crypt, DTLSv1_2_server_method, [LIBS=-lcrypt $LIBS]))
1557 fi # $WITH_OPENSSL_METHOD
1558
1559 AC_CHECK_FUNC(SSL_CTX_set_default_verify_paths, AC_DEFINE(HAVE_SSL_CTX_set_default_verify_paths))
1560 AC_CHECK_FUNC(RAND_egd, AC_DEFINE(HAVE_RAND_egd), AC_CHECK_LIB(crypt, RAND_egd, [LIBS=-lcrypt $LIBS]))
1561 AC_CHECK_FUNC(DH_set0_pqg, AC_DEFINE(HAVE_DH_set0_pqg), AC_CHECK_LIB(crypt, DH_set0_pqg, [LIBS=-lcrypt $LIBS]))
1562 AC_CHECK_FUNC(ASN1_STRING_get0_data, AC_DEFINE(HAVE_ASN1_STRING_get0_data), AC_CHECK_LIB(crypt, ASN1_STRING_get0_data, [LIBS=-lcrypt $LIBS]))
1563 AC_CHECK_FUNC(RAND_status, AC_DEFINE(HAVE_RAND_status))
1564 AC_CHECK_FUNC(SSL_CTX_clear_mode, AC_DEFINE(HAVE_SSL_CTX_clear_mode))
1565 AC_CHECK_FUNC(SSL_set_tlsext_host_name, AC_DEFINE(HAVE_SSL_set_tlsext_host_name))
1566 AC_CHECK_FUNC(SSL_library_init, AC_DEFINE(HAVE_SSL_library_init))
1567 AC_CHECK_FUNC(ERR_error_string, AC_DEFINE(HAVE_ERR_error_string))
1568
1569 AC_MSG_CHECKING(for type EC_KEY)
1570 AC_CACHE_VAL(sc_cv_type_EC_TYPE,
1571 [AC_TRY_COMPILE([#include <openssl/ec.h>
1572 ],[EC_KEY *s;],
1573 [sc_cv_type_EC_KEY=yes],
1574 [sc_cv_type_EC_KEY=no])])
1575 if test $sc_cv_type_EC_KEY = yes; then
1576    AC_DEFINE(HAVE_TYPE_EC_KEY)
1577 fi
1578 AC_MSG_RESULT($sc_cv_type_EC_KEY)
1579
1580
1581 dnl Run time checks
1582
1583
1584 AC_MSG_CHECKING(if snprintf conforms to C99)
1585 AC_CACHE_VAL(ac_cv_have_c99_snprintf,
1586 [AC_TRY_RUN([
1587 #include <stdio.h>
1588 #include <stdlib.h>
1589 int main(void){
1590 char s[2];
1591 exit(snprintf(s,2,"ab")!=2);
1592 }],
1593 [ac_cv_have_c99_snprintf=yes],
1594 [ac_cv_have_c99_snprintf=no],
1595 [ac_cv_have_c99_snprintf=no])])
1596 if test $ac_cv_have_c99_snprintf = yes; then
1597    AC_DEFINE(HAVE_C99_SNPRINTF)
1598 fi
1599 AC_MSG_RESULT($ac_cv_have_c99_snprintf)
1600
1601
1602 AC_MSG_CHECKING(if printf has Z modifier)
1603 AC_CACHE_VAL(ac_cv_have_z_modifier,
1604 if test "$cc" = gcc; then
1605 [AC_TRY_RUN([
1606 #include <stdlib.h>
1607 #include <stdio.h>
1608 int main(void){
1609 char s[16];
1610 sprintf(s,"%Zu",1);
1611 exit(strcmp(s,"1"));
1612 }],
1613 [ac_cv_have_z_modifier=yes],
1614 [ac_cv_have_z_modifier=no],
1615 [ac_cv_have_z_modifier=no])]
1616 else ac_cv_have_z_modifier=no
1617 fi
1618 )
1619 if test $ac_cv_have_z_modifier = yes; then
1620    AC_DEFINE(HAVE_FORMAT_Z)
1621 fi
1622 AC_MSG_RESULT($ac_cv_have_z_modifier)
1623
1624
1625 dnl find the number of bits we must shift a value to match the given mask
1626 dnl (e.g., mask 0x00f0 requires shifting with 4)
1627 ## NOTE: some platforms only need one '\' to escape '"' in string constant
1628 define(AC_SHIFT_OFFSET,[
1629 AC_CACHE_CHECK(shift offset of $1, $2,
1630 [LIBS1="$LIBS"; LIBS="" # avoid libwrap allow_severity undefined
1631  conftestoffset="conftestoffset.out"
1632  AC_TRY_RUN([
1633  #include <errno.h>
1634  #include <stdlib.h>
1635  #include <stdio.h>
1636  #include <termios.h>
1637  #include <string.h>
1638  int main(){
1639     unsigned int i,n=$1;
1640     FILE *f;
1641     if ((f=fopen("$conftestoffset","w"))==NULL){
1642        fprintf(stderr,"\\"$conftestoffset\\": %s\n",strerror(errno)); exit(-1);
1643     }
1644     if (n==0) {fprintf(stderr,"$1 is 0 (impossible!)\n"); exit(1);}
1645     i=0; while (!(n&1)) {
1646        n>>=1; ++i; }
1647     if (3<<i == $1) {
1648        fprintf(f, "%u", i);
1649     } else {
1650        fprintf(f, "-1");        /* anticipate result of xioinitialize assert */
1651     }
1652     exit(0);
1653  }
1654  ],
1655  [$2=`cat $conftestoffset`],
1656  [$2=-1],
1657  [$2=-1]
1658 )
1659  LIBS="$LIBS1"])
1660 AC_DEFINE_UNQUOTED($1_SHIFT, ${$2})
1661 if test "$2" = -1; then
1662 AC_MSG_WARN(please determine $1_SHIFT manually)
1663 fi
1664 ])
1665
1666 AC_SHIFT_OFFSET(CRDLY,  sc_cv_sys_crdly_shift)
1667 AC_SHIFT_OFFSET(TABDLY, sc_cv_sys_tabdly_shift)
1668 AC_SHIFT_OFFSET(CSIZE,  sc_cv_sys_csize_shift)
1669
1670
1671 dnl Find what physical type (basic C type) is equivalent to the given type.
1672 dnl If possible we try to compile simple test code and get no warning only with
1673 dnl the matching type.
1674 dnl If this method does not seem to work we run test programs that print the
1675 dnl length and signedness of the type.
1676
1677 dnl do we have a -Werror option?
1678 dnl Does the test code compile with -Werror when types fit?
1679 CHANCE_TO_TYPECHECK=1
1680 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1681 AC_TRY_COMPILE([#include <stdlib.h>],[int u; int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)
1682 CFLAGS="$CFLAGS1"
1683
1684 dnl Does the test code compile without -Werror when types do not fit?
1685 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1686  AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)
1687 fi
1688
1689 dnl Does the test code fail to compile with -Werror when types do not fit?
1690 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1691  CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1692  AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],CHANCE_TO_TYPECHECK=0,)
1693  CFLAGS="$CFLAGS1"
1694 fi
1695
1696 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1697    AC_MSG_NOTICE(using compile -Werror method to find basic types)
1698 else
1699    AC_MSG_NOTICE(using code run method to find basic types)
1700 fi
1701
1702
1703 dnl see AC_BASIC_TYPE
1704 define(AC_BASIC_TYPE_GCC,[
1705 AC_CACHE_CHECK(for equivalent simple type of $2, $4,
1706 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1707  dnl echo "echo: trying short for $2" >&2
1708  AC_TRY_COMPILE([$1],[$2 u; short v; return(&u==&v);],
1709  [$4="1 /* short */"],
1710  [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u==&v);],
1711   [$4="2 /* unsigned short */"],
1712   [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u==&v);],
1713    [$4="3 /* int */"],
1714    [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u==&v);],
1715     [$4="4 /* unsigned int */"],
1716     [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u==&v);],
1717      [$4="5 /* long */"],
1718      [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u==&v);],
1719       [$4="6 /* unsigned long */"],
1720       [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u==&v);],
1721        [$4="7 /* long long */"],
1722        [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u==&v);],
1723         [$4="8 /* unsigned long long */"],
1724         [$4="0 /* unknown, taking default */"
1725 ]) ]) ]) ]) ]) ]) ]) ])
1726  CFLAGS="$CFLAGS1" ])
1727 AC_DEFINE_UNQUOTED($3, ${$4})
1728 ])
1729
1730 dnl see AC_BASIC_TYPE
1731 define(AC_BASIC_TYPE_OTHER,[
1732 AC_CACHE_CHECK(for equivalent simple type of $2, $4,
1733 [AC_TRY_RUN([
1734 $1
1735 int main() { return!(sizeof($2)==sizeof(short));}],
1736  # same length as short
1737  AC_TRY_RUN([
1738 $1
1739 int main() { $2 x=-1; return !(x<0);}],
1740   [$4="1 /* short */"],
1741   [$4="2 /* unsigned short */"]),
1742  # length differs from short, try others
1743  AC_TRY_RUN([
1744 $1
1745 int main() { return!(sizeof($2)==sizeof(int));}],
1746   # same length as int
1747   AC_TRY_RUN([
1748 $1
1749 int main() { $2 x=-1; return !(x<0);}],
1750    [$4="3 /* int */"],
1751    [$4="4 /* unsigned int */"]),
1752   # length differs from int, try others
1753   AC_TRY_RUN([
1754 $1
1755 int main() { return !(sizeof($2)==sizeof(long));}],
1756    # same length as long
1757    AC_TRY_RUN([
1758 $1
1759 int main() { $2 x=-1; return !(x<0);}],
1760     [$4="5 /* long */"],
1761     [$4="6 /* unsigned long */"] ),
1762    # length differs from long, try others
1763    AC_TRY_RUN([
1764 $1
1765 int main() { return !(sizeof($2)==sizeof(long long));}],
1766    # same length as long long
1767      AC_TRY_RUN([
1768 $1
1769 int main() { $2 x=-1; return !(x<0);}],
1770      [$4="7 /* long long */"],
1771      [$4="8 /* unsigned long long */"] ),
1772      [$4="0 /* unknown */"]
1773    )
1774   )
1775  )
1776 )
1777 ])
1778 AC_DEFINE_UNQUOTED($3, ${$4})
1779 ])
1780
1781 dnl find what physical type (basic C type) is equivalent to the given type.
1782 dnl arg1: include file(s)
1783 dnl arg2: type name
1784 dnl arg3: output variable
1785 dnl arg4: cache variable (might be constructed automatically)
1786 dnl   output values: 1..short, 2..unsigned short, 3..int, 4..u-int,
1787 dnl                  5..long, 6..u-long; others not yet supported
1788 define(AC_BASIC_TYPE,[
1789    if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1790       AC_BASIC_TYPE_GCC([$1],[$2],[$3],[$4])
1791    else
1792       AC_BASIC_TYPE_OTHER([$1],[$2],[$3],[$4])
1793    fi
1794 ])
1795
1796
1797 dnl See AC_TYPEOF_COMPONENT
1798 dnl This version is for compilers with -Werror or so: gcc, clang, Sun Studio?
1799 define(AC_TYPEOF_COMPONENT_GCC,[
1800 AC_CACHE_CHECK(for basic type of $2.$3, $5,
1801 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1802 AC_TRY_COMPILE([$1],[$2 u;short v; return(&u.$3==&v);],
1803 [$5="1 /* short */"],
1804 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u.$3==&v);],
1805  [$5="2 /* unsigned short */"],
1806  [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u.$3==&v);],
1807   [$5="3 /* int */"],
1808   [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u.$3==&v);],
1809    [$5="4 /* unsigned int */"],
1810    [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u.$3==&v);],
1811     [$5="5 /* long */"],
1812     [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u.$3==&v);],
1813      [$5="6 /* unsigned long */"],
1814      [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u.$3==&v);],
1815       [$5="7 /* long long */"],
1816       [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u.$3==&v);],
1817        [$5="8 /* unsigned long long */"],
1818        [$5="0 /* unknown, taking default */"
1819 ]) ]) ]) ]) ]) ]) ]) ])
1820  CFLAGS="$CFLAGS1" ])
1821 AC_DEFINE_UNQUOTED($4, ${$5})
1822 ])
1823
1824 dnl See AC_TYPEOF_COMPONENT
1825 dnl This version is for compilers with no -Werror or so
1826 define(AC_TYPEOF_COMPONENT_OTHER,[
1827 AC_CACHE_CHECK(for basic type of $2.$3, $5,
1828 [AC_TRY_RUN([
1829 $1
1830 int main() { $2 x; return!(sizeof(x.$3)==sizeof(short));}],
1831  # same length as short
1832  AC_TRY_RUN([
1833 $1
1834 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
1835   [$5="1 /* short */"],
1836   [$5="2 /* unsigned short */"]),
1837  # length differs from short, try others
1838  AC_TRY_RUN([
1839 $1
1840 int main() { $2 x; return!(sizeof(x.$3)==sizeof(int));}],
1841   # same length as int
1842   AC_TRY_RUN([
1843 $1
1844 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
1845    [$5="3 /* int */"],
1846    [$5="4 /* unsigned int */"]),
1847   # length differs from int, try others
1848   AC_TRY_RUN([
1849 $1
1850 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long));}],
1851    # same length as long
1852    AC_TRY_RUN([
1853 $1
1854 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
1855     [$5="5 /* long */"],
1856     [$5="6 /* unsigned long */"] ),
1857    # length differs from long, try others
1858    AC_TRY_RUN([
1859 $1
1860 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long long));}],
1861    # same length as long long
1862      AC_TRY_RUN([
1863 $1
1864 int main() { x $2; x.$3=-1; return !(x.$3<0);}],
1865      [$5="7 /* long long */"],
1866      [$5="8 /* unsigned long long */"] ),
1867      [$5="0 /* unknown */"]
1868    )
1869   )
1870  )
1871 )
1872 ])
1873 AC_DEFINE_UNQUOTED($4, ${$5})
1874 ])
1875
1876 dnl find what physical type (basic C type) describes the given struct or union
1877 dnl component.
1878 dnl arg1: include file(s); must declare the structure type
1879 dnl arg2: struct name (e.g., "struct stat")
1880 dnl arg3: variable or component (e.g., "st_ino")
1881 dnl arg4: output variable, values see AC_BASIC_TYPE
1882 dnl arg5: cache variable (might be constructed automatically)
1883 define(AC_TYPEOF_COMPONENT,[
1884    if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1885       AC_TYPEOF_COMPONENT_GCC([$1],[$2],[$3],[$4],[$5])
1886    else
1887       AC_TYPEOF_COMPONENT_OTHER([$1],[$2],[$3],[$4],[$5])
1888    fi
1889 ])
1890
1891 AC_BASIC_TYPE([#include <stdint.h>], uint16_t, HAVE_BASIC_UINT16_T, sc_cv_type_uint16_basic)
1892 AC_BASIC_TYPE([#include <stdint.h>], uint32_t, HAVE_BASIC_UINT32_T, sc_cv_type_uint32_basic)
1893 AC_BASIC_TYPE([#include <stdint.h>], uint64_t, HAVE_BASIC_UINT64_T, sc_cv_type_uint64_basic)
1894 AC_BASIC_TYPE([#include <stdint.h>], int16_t,  HAVE_BASIC_INT16_T,  sc_cv_type_int16_basic)
1895 AC_BASIC_TYPE([#include <stdint.h>], int32_t,  HAVE_BASIC_INT32_T,  sc_cv_type_int32_basic)
1896 AC_BASIC_TYPE([#include <stdint.h>], int64_t,  HAVE_BASIC_INT64_T,  sc_cv_type_int64_basic)
1897 AC_BASIC_TYPE([#include <stdlib.h>], size_t, HAVE_BASIC_SIZE_T, sc_cv_type_sizet_basic)
1898 AC_BASIC_TYPE([#include <sys/types.h>
1899 #include <sys/stat.h>
1900 #include <unistd.h>], mode_t, HAVE_BASIC_MODE_T, sc_cv_type_modet_basic)
1901 AC_BASIC_TYPE([#include <sys/types.h>
1902 #include <unistd.h>], pid_t, HAVE_BASIC_PID_T, sc_cv_type_pidt_basic)
1903 AC_BASIC_TYPE([#include <sys/types.h>
1904 #include <unistd.h>], uid_t, HAVE_BASIC_UID_T, sc_cv_type_uidt_basic)
1905 AC_BASIC_TYPE([#include <sys/types.h>
1906 #include <unistd.h>], gid_t, HAVE_BASIC_GID_T, sc_cv_type_gidt_basic)
1907
1908 AC_BASIC_TYPE([#include <time.h>], time_t, HAVE_BASIC_TIME_T,
1909         sc_cv_type_timet_basic)
1910
1911 # this is questionable, might fail on some systems
1912 AC_BASIC_TYPE([#include <sys/types.h>
1913 #include <sys/socket.h>
1914 #include <unistd.h>], socklen_t, HAVE_BASIC_SOCKLEN_T,
1915         sc_cv_type_socklent_basic)
1916
1917 AC_BASIC_TYPE([#include <sys/types.h>
1918 #include <unistd.h>], off_t, HAVE_BASIC_OFF_T, sc_cv_type_off_basic)
1919
1920 AC_BASIC_TYPE([#include <sys/types.h>
1921 #include <unistd.h>], off64_t, HAVE_BASIC_OFF64_T, sc_cv_type_off64_basic)
1922
1923 # oh god, __dev_t in Linux 2.4 is struct{int[2];}, not handled here yet.
1924 AC_BASIC_TYPE([#include <sys/stat.h>], dev_t, HAVE_BASIC_DEV_T, sc_cv_type_dev_basic)
1925
1926 AC_BASIC_TYPE([#include <unistd.h>
1927 #include <termios.h>], speed_t, HAVE_BASIC_SPEED_T, sc_cv_type_spee_t)
1928
1929 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_ino, HAVE_TYPEOF_ST_INO, sc_cv_type_stat_stino_basic)
1930 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_nlink, HAVE_TYPEOF_ST_NLINK, sc_cv_type_stat_stnlink_basic)
1931 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_size, HAVE_TYPEOF_ST_SIZE, sc_cv_type_stat_stsize_basic)
1932 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blksize, HAVE_TYPEOF_ST_BLKSIZE, sc_cv_type_stat_stblksize_basic)
1933 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blocks, HAVE_TYPEOF_ST_BLOCKS, sc_cv_type_stat_stblocks_basic)
1934 #
1935 if test "$ac_cv_func_stat64" = yes; then
1936 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_dev, HAVE_TYPEOF_ST64_DEV, sc_cv_type_stat64_stdev_basic)
1937 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_ino, HAVE_TYPEOF_ST64_INO, sc_cv_type_stat64_stino_basic)
1938 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_nlink, HAVE_TYPEOF_ST64_NLINK, sc_cv_type_stat64_stnlink_basic)
1939 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_size, HAVE_TYPEOF_ST64_SIZE, sc_cv_type_stat64_stsize_basic)
1940 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blksize, HAVE_TYPEOF_ST64_BLKSIZE, sc_cv_type_stat64_stblksize_basic)
1941 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blocks, HAVE_TYPEOF_ST64_BLOCKS, sc_cv_type_stat64_stblocks_basic)
1942 fi
1943
1944 AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timeval, tv_usec, HAVE_TYPEOF_STRUCT_TIMEVAL_TV_USEC, sc_cv_type_struct_timeval_tv_usec)
1945
1946 AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timespec, tv_nsec, HAVE_TYPEOF_STRUCT_TIMESPEC_TV_NSEC, sc_cv_type_struct_timespec_tv_nsec)
1947
1948 AC_TYPEOF_COMPONENT([#include <sys/types.h>
1949 #include <sys/time.h>
1950 #include <sys/resource.h>],
1951 struct rlimit, rlim_max, HAVE_TYPEOF_RLIM_MAX, sc_cv_type_rlimit_rlimmax_basic)
1952
1953 # Fedora-19 doc says it is socklen_t which is equivalent to unsigned int, but it is equivalent to size_t (x86_64)
1954 AC_TYPEOF_COMPONENT([#include "sysincludes.h"], struct cmsghdr, cmsg_len, HAVE_TYPEOF_STRUCT_CMSGHDR_CMSG_LEN, sc_cv_typeof_struct_cmsghdr_cmsg_len)
1955 ### snprintf, vsnprintf
1956
1957 AC_MSG_CHECKING(for /dev/ptmx)
1958 if test -c /dev/ptmx; then
1959   AC_DEFINE(HAVE_DEV_PTMX, 1)
1960   AC_MSG_RESULT(yes)
1961 else
1962   AC_MSG_RESULT(no)
1963   AC_MSG_CHECKING(for /dev/ptc)
1964   if test -c /dev/ptc; then
1965     AC_DEFINE(HAVE_DEV_PTC)
1966     AC_MSG_RESULT(yes)
1967   else
1968     AC_MSG_RESULT(no)
1969   fi
1970 fi
1971
1972 AC_MSG_CHECKING(for /proc)
1973 if test -d /proc; then
1974   AC_DEFINE(HAVE_PROC_DIR, 1)
1975   AC_MSG_RESULT(yes)
1976 else
1977   AC_MSG_RESULT(no)
1978 fi
1979
1980 AC_MSG_CHECKING(for /proc/*/fd)
1981 if test -d /proc/$$/fd; then
1982   AC_DEFINE(HAVE_PROC_DIR_FD, 1)
1983   AC_MSG_RESULT(yes)
1984 else
1985   AC_MSG_RESULT(no)
1986 fi
1987
1988 dnl "tcpd" "tcpwrappers"
1989 # on some platforms, raw linking with libwrap fails because allow_severity and
1990 # deny_severity are not explicitely defined. Thus we put the libwrap part to
1991 # the end
1992 AC_MSG_CHECKING(whether to include libwrap support)
1993 AC_ARG_ENABLE(libwrap, [  --disable-libwrap       disable libwrap support],
1994   [ case "$enableval" in
1995     no) AC_MSG_RESULT(no); WITH_LIBWRAP= ;;
1996     *) AC_MSG_RESULT(yes); WITH_LIBWRAP=1 ;;
1997    esac],
1998    [ AC_MSG_RESULT(yes);   WITH_LIBWRAP=1 ])
1999 #
2000 # check if we find the components of libwrap ("tcpd" "tcpwrappers")
2001 if test -n "$WITH_LIBWRAP"; then
2002   AC_MSG_CHECKING(for components of libwrap)
2003   # first, we need to find the include file <tcpd.h>
2004   AC_CACHE_VAL(sc_cv_have_tcpd_h,
2005     [AC_TRY_COMPILE([#include <sys/types.h>
2006 #include <tcpd.h>],[;],
2007       [sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT=""],
2008       [sc_cv_have_tcpd_h=no
2009        for D in "/sw" "/usr/local" "/opt/freeware" "/usr/sfw"; do
2010         I="$D/include"
2011         i="$I/tcpd.h"
2012         if test -r "$i"; then
2013           #V_INCL="$V_INCL -I$I"
2014           CPPFLAGS="$CPPFLAGS -I$I"
2015           AC_MSG_NOTICE(found $i)
2016           sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT="$D"
2017           break;
2018         fi
2019       done])
2020   ])
2021   if test "$sc_cv_have_tcpd_h" = "yes"; then
2022     AC_DEFINE(HAVE_TCPD_H)
2023   fi
2024   AC_MSG_NOTICE(checked for tcpd.h... $sc_cv_have_tcpd_h)
2025 fi      # end checking for tcpd.h
2026 if test -n "$WITH_LIBWRAP" -a "$sc_cv_have_tcpd_h" = yes; then
2027   # next, we search for the wrap library (libwrap.*)
2028   AC_MSG_CHECKING(for libwrap)
2029   AC_CACHE_VAL(sc_cv_have_libwrap,
2030     [ LIBS0="$LIBS"
2031       if test -n "$LIBWRAP_ROOT"; then
2032         L="$LIBWRAP_ROOT/lib"; LIBS="-L$L -lwrap $LIBS"
2033       else
2034         LIBS="-lwrap $LIBS"
2035       fi
2036       AC_TRY_LINK([#include <sys/types.h>
2037 #include <tcpd.h>
2038 int allow_severity,deny_severity;],[hosts_access(0)],
2039       [sc_cv_have_libwrap='yes'],
2040       [sc_cv_have_libwrap='no'
2041         LIBS="$LIBS -lnsl"      # RedHat73
2042         AC_TRY_LINK([#include <sys/types.h>
2043 #include <tcpd.h>
2044 int allow_severity,deny_severity;],[hosts_access(0)],
2045           [sc_cv_have_libwrap='yes'],
2046           [sc_cv_have_libwrap='no'])
2047       ]
2048       )
2049       if test "$sc_cv_have_libwrap" != 'yes'; then
2050         LIBS="$LIBS0"
2051       fi
2052     ]
2053   )
2054   if test "$sc_cv_have_libwrap" = 'yes'; then
2055     AC_DEFINE(HAVE_LIBWRAP)
2056   fi
2057   AC_MSG_RESULT($sc_cv_have_libwrap)
2058 fi
2059 #
2060 if test -n "$WITH_LIBWRAP"; then
2061   if test "$sc_cv_have_tcpd_h" = "yes" -a "$sc_cv_have_libwrap" = "yes"; then
2062     AC_DEFINE(WITH_LIBWRAP)
2063   else
2064     AC_MSG_WARN([not all components of tcp wrappers found, disabling it]);
2065   fi
2066 fi
2067
2068 # check of hosts_allow_table
2069 if test -n "$WITH_LIBWRAP"; then
2070   AC_MSG_CHECKING(for hosts_allow_table)
2071   AC_CACHE_VAL(sc_cv_have_hosts_allow_table,
2072     [AC_TRY_COMPILE([#include <sys/types.h>
2073 #include <tcpd.h>],[hosts_allow_table="";],
2074       [sc_cv_have_hosts_allow_table=yes],
2075       [sc_cv_have_hosts_allow_table=no])])
2076   if test $sc_cv_have_hosts_allow_table = yes; then
2077     AC_DEFINE(HAVE_HOSTS_ALLOW_TABLE)
2078   fi
2079   AC_MSG_RESULT($sc_cv_have_hosts_allow_table)
2080 fi # test -n "$WITH_LIBWRAP"
2081
2082
2083 if test "$GCC" = yes; then
2084    CFLAGS="$CFLAGS"
2085 fi
2086
2087 # FIPS support requires compiling with fipsld.
2088 # fipsld requires the FIPSLD_CC variable to be set to the original CC.
2089 # This check must be done after all other checks that require compiling
2090 # so that fipsld is not used by the configure script itself.
2091 if test -n "$WITH_FIPS"; then
2092   if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then
2093     FIPSLD_CC=$CC
2094     if test "${FIPSLD+set}" != set ; then
2095         FIPSLD=fipsld
2096     fi
2097     CC="FIPSLD_CC=$CC $FIPSLD"
2098   fi
2099 fi
2100 AC_SUBST(FIPSLD_CC)
2101
2102 # autoconf does not seem to provide AC_CHECK_VAR or so
2103 # thus we have to check by foot
2104 AC_MSG_CHECKING(for declaration of environ)
2105 AC_CACHE_VAL(sc_cv_decl_environ,
2106 [AC_TRY_COMPILE([#include <unistd.h>],[char **s = environ;],
2107 [sc_cv_decl_environ=yes],
2108 [sc_cv_decl_environ=no])])
2109 if test $sc_cv_decl_environ = yes; then
2110    AC_DEFINE(HAVE_DECL_ENVIRON)
2111 fi
2112 AC_MSG_RESULT($sc_cv_decl_environ)
2113
2114 # on some systems environ exists but not the declaration
2115 AC_MSG_CHECKING(for var environ)
2116 AC_CACHE_VAL(sc_cv_var_environ,
2117 [AC_TRY_COMPILE([],[extern char **environ; char **s = environ;],
2118 [sc_cv_var_environ=yes],
2119 [sc_cv_var_environ=no])])
2120 if test $sc_cv_var_environ = yes; then
2121    AC_DEFINE(HAVE_VAR_ENVIRON)
2122 fi
2123 AC_MSG_RESULT($sc_cv_var_environ)
2124
2125 # allow BUILD_DATE to be externally set for build reproducibility
2126 if test "$BUILD_DATE"; then
2127   AC_DEFINE_UNQUOTED(BUILD_DATE, ["$BUILD_DATE"])
2128 else
2129   AC_DEFINE(BUILD_DATE, [__DATE__" "__TIME__])
2130 fi
2131
2132 AC_OUTPUT(Makefile)