configure.ac

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