configure.in

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