1dnl source: configure.ac 2dnl Copyright Gerhard Rieger and contributors (see file CHANGES) 3dnl Published under the GNU General Public License V.2, see file COPYING 4 5dnl Process this file with autoconf to produce a configure script. 6AC_INIT(socat.c) 7 8AC_CONFIG_HEADER(config.h) 9 10if test -f /usr/xpg4/bin/fgrep; then 11 FGREP=/usr/xpg4/bin/fgrep # Solaris 12else 13 FGREP=fgrep 14fi 15 16# find out which defines gcc passes to cpp, so makedepend does not run into 17# (harmless) "error architecture not supported" 18AC_MSG_CHECKING(which defines needed for makedepend) 19__cpp_defs=`gcc -v -E - </dev/null 2>&1 |$FGREP -e '/cpp ' -e '/cc1 '` 20SYSDEFS=`aa=; for a in $__cpp_defs 21 do case "$a" in -D*) aa="$aa $a";; esac; done; echo "$aa"` 22AC_SUBST(SYSDEFS) 23AC_MSG_RESULT($SYSDEFS) 24 25 26# this must come before AC_PROG_CC 27if 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 31fi 32 33dnl Checks for programs. 34AC_PROG_INSTALL(install) 35AC_PROG_CC 36AC_PROG_RANLIB 37AC_SUBST(AR) 38AC_CHECK_PROG(AR, ar, ar, gar) 39# 40# we need to explicitely call this here; otherwise, with --disable-libwrap we 41# fail 42AC_LANG_COMPILER_REQUIRE() 43 44if test "$GCC" = yes; then 45 CFLAGS="$CFLAGS -D_GNU_SOURCE -Wall -Wno-parentheses" 46 ERRONWARN="-Werror -O0" 47elif test "$CC" = "clang"; then 48 CFLAGS="$CFLAGS -D_GNU_SOURCE -Wall -Wno-parentheses" 49 ERRONWARN="-Werror -O0" 50#elif Sun Studio 51# ERRONWARN="-errwarn" 52else 53 ERRONWARN= 54fi 55export CFLAGS 56 57 58dnl Checks for header files. 59AC_HEADER_STDC 60AC_CHECK_HEADERS(stdbool.h) 61AC_CHECK_HEADERS(inttypes.h) 62AC_HEADER_SYS_WAIT 63AC_CHECK_HEADERS(fcntl.h limits.h strings.h sys/param.h sys/ioctl.h sys/time.h syslog.h unistd.h) 64AC_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) 65AC_CHECK_HEADERS(pty.h) 66AC_CHECK_HEADERS(netinet/in.h netinet/in_systm.h) 67AC_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 72AC_CHECK_HEADERS(netinet/tcp.h) 73AC_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 77AC_CHECK_HEADERS(arpa/nameser.h) 78 79AC_HEADER_RESOLV() 80 81AC_CHECK_HEADERS(termios.h linux/if_tun.h) 82AC_CHECK_HEADERS(net/if_dl.h) 83AC_CHECK_HEADERS(linux/types.h) 84AC_CHECK_HEADER(linux/errqueue.h, AC_DEFINE(HAVE_LINUX_ERRQUEUE_H), [], [#include <sys/time.h> 85#include <linux/types.h>]) 86AC_CHECK_HEADERS(sys/utsname.h sys/select.h sys/file.h) 87AC_CHECK_HEADERS(util.h bsd/libutil.h libutil.h sys/stropts.h regex.h) 88AC_CHECK_HEADERS(linux/fs.h linux/ext2_fs.h) 89 90dnl Checks for setgrent, getgrent and endgrent. 91AC_CHECK_FUNCS(setgrent getgrent endgrent) 92dnl Checks for getgrouplist() /* BSD */ 93AC_CHECK_FUNCS(getgrouplist) 94AC_CHECK_FUNCS(cfmakeraw) 95 96dnl Link libresolv if necessary (for Mac OS X) 97AC_SEARCH_LIBS([res_9_init], [resolv]) 98 99 100dnl Check for extra socket library (for Solaris) 101AC_CHECK_FUNC(hstrerror, , AC_CHECK_LIB(resolv, hstrerror, [LIBS="$LIBS -lresolv"; AC_DEFINE(HAVE_HSTRERROR)])) 102AC_CHECK_FUNC(gethostent, , AC_CHECK_LIB(nsl, gethostent)) 103AC_CHECK_FUNC(setsockopt, , AC_CHECK_LIB(socket, setsockopt)) 104 105dnl Check for function prototype and in lib 106dnl arg1: function name 107dnl arg2: required include files beyond sysincludes.h 108define(AC_CHECK_PROTOTYPE_LIB,[ 109AC_MSG_CHECKING(for $1 prototype) 110AC_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"]) 117if test $sc_cv_have_prototype_lib_$1 = yes; then 118 AC_DEFINE(HAVE_PROTOTYPE_LIB_$1) 119fi 120AC_MSG_RESULT($sc_cv_have_prototype_lib_$1) 121]) 122 123 124dnl Check for hstrerror prototype 125AC_MSG_CHECKING(for hstrerror prototype) 126AC_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"]) 132if test $sc_cv_have_prototype_hstrerror = yes; then 133 AC_DEFINE(HAVE_PROTOTYPE_HSTRERROR) 134fi 135AC_MSG_RESULT($sc_cv_have_prototype_hstrerror) 136 137 138AC_MSG_CHECKING(whether to include help) 139AC_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 146AC_MSG_CHECKING(whether to include STDIO support) 147AC_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 154AC_MSG_CHECKING(whether to include FD-number support) 155AC_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 162AC_MSG_CHECKING(whether to include direct file support) 163AC_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 170AC_MSG_CHECKING(whether to include direct create support) 171AC_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 178AC_MSG_CHECKING(whether to include gopen support) 179AC_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 186AC_MSG_CHECKING(whether to include explicit pipe support) 187AC_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 194AC_MSG_CHECKING(whether to include explicit termios support) 195AC_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 202AC_MSG_CHECKING(whether to include UNIX socket support) 203AC_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 210AC_MSG_CHECKING(whether to include abstract UNIX socket support) 211AC_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 223AC_MSG_CHECKING(whether to include IPv4 support) 224AC_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 231AC_MSG_CHECKING(whether to include IPv6 support) 232AC_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 ]) 238if 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 248AC_MSG_CHECKING(if __APPLE_USE_RFC_2292 is helpful) 249AC_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)]) 262if test "$ac_cv_apple_use_rfc_2292" = yes; then 263 AC_DEFINE(__APPLE_USE_RFC_2292) 264fi 265AC_MSG_RESULT($ac_cv_apple_use_rfc_2292) 266 267fi 268 269AC_MSG_CHECKING(whether to include raw IP support) 270AC_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 277AC_MSG_CHECKING(whether to include generic socket support) 278AC_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)]) 284AC_MSG_CHECKING(whether to include generic network interface support) 285AC_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 ]) 291if 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])]) 296fi 297if 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]) 307fi 308if test "$WITH_INTERFACE"; then 309 AC_DEFINE(WITH_INTERFACE) 310fi 311 312AC_MSG_CHECKING(whether to include TCP support) 313AC_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 320AC_MSG_CHECKING(whether to include UDP support) 321AC_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 328AC_MSG_CHECKING(whether to include SCTP support) 329AC_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 336if test -n "$WITH_SCTP"; then 337AC_MSG_CHECKING(for IPPROTO_SCTP) 338AC_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])]) 344AC_MSG_RESULT($sc_cv_define_ipproto_sctp) 345if test $sc_cv_define_ipproto_sctp = yes; then 346 AC_DEFINE(WITH_SCTP) 347else 348 AC_MSG_WARN([IPPROTO_SCTP undefined, disabling SCTP support]) 349fi 350fi 351 352AC_MSG_CHECKING(whether to include vsock support) 353AC_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 ]) 359if 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 ) 370fi 371if test "$WITH_VSOCK"; then 372 AC_DEFINE(WITH_VSOCK) 373fi 374 375AC_MSG_CHECKING(whether to include listen support) 376AC_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 383AC_MSG_CHECKING(whether to include socks4 support) 384AC_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 391AC_MSG_CHECKING(whether to include socks4a support) 392AC_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 399AC_MSG_CHECKING(whether to include proxy connect support) 400AC_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 407AC_MSG_CHECKING(whether to include exec support) 408AC_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 415AC_MSG_CHECKING([whether to include system (shell) support]) 416AC_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 423AC_MSG_CHECKING(whether to include pty address support) 424AC_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 431AC_MSG_CHECKING(whether to include fs attributes support) 432AC_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 439AC_MSG_CHECKING(whether to include readline support) 440AC_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 447if 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 498fi 499 500AC_MSG_CHECKING(whether to include openssl support) 501AC_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 ]) 507AC_ARG_ENABLE(openssl_base, [ --enable-openssl-base specify directory with include/ and lib/], 508 [ OPENSSL_BASE="$enableval" ], 509 [ unset OPENSSL_BASE ]) 510# 511if 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 543fi # 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 550if 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) 580fi 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 603if 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 609fi 610 611AC_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 623if test -n "$WITH_OPENSSL"; then 624AC_MSG_CHECKING(whether to include OpenSSL method option) 625AC_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)]) 631fi 632 633AC_MSG_CHECKING(whether to include deprecated resolver option) 634AC_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 642AC_MSG_CHECKING(whether to include openssl fips support) 643AC_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 650if 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 661fi 662 663if 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) 687fi 688 689if 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) 718fi 719 720if 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 727fi 728 729AC_MSG_CHECKING(whether to include tun/tap address support) 730AC_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# 738if ! 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= 741fi 742# 743if test -n "$WITH_TUN"; then 744 AC_DEFINE(WITH_TUN) 745fi 746 747AC_MSG_CHECKING(whether to include system call tracing) 748AC_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)]) 756AC_SUBST(SYCLS) 757AC_SUBST(SSLCLS) 758 759AC_MSG_CHECKING(whether to include file descriptor analyzer) 760AC_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)]) 766AC_SUBST(FILAN) 767 768AC_MSG_CHECKING(whether to include retry support) 769AC_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 776AC_MSG_CHECKING(included message level) 777AC_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 791dnl Checks for typedefs, structures, and compiler characteristics. 792AC_C_CONST 793AC_TYPE_UID_T 794AC_TYPE_MODE_T 795AC_TYPE_OFF_T 796AC_TYPE_PID_T 797AC_TYPE_SIZE_T 798AC_STRUCT_ST_BLKSIZE 799AC_STRUCT_ST_BLOCKS 800AC_STRUCT_ST_RDEV 801AC_HEADER_TIME 802 803dnl Check for extra realtime library (for Solaris) 804AC_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 807dnl Checks for library functions. 808AC_PROG_GCC_TRADITIONAL 809AC_FUNC_MEMCMP 810AC_TYPE_SIGNAL 811AC_FUNC_STRFTIME 812AC_CHECK_FUNCS(putenv select pselect poll socket strtod strtol) 813AC_CHECK_FUNCS(strtoul uname getpgid getsid gethostbyname getaddrinfo) 814AC_CHECK_FUNCS(getprotobynumber getprotobynumber_r) 815AC_CHECK_FUNCS(setgroups inet_aton) 816 817AC_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 822dnl Search for cfsetispeed(),cfgetispeed(),cfsetspeed(),cfgetospeed() functions 823AC_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 828AC_CHECK_PROTOTYPE_LIB(posix_memalign) 829AC_CHECK_PROTOTYPE_LIB(strdup) 830AC_CHECK_PROTOTYPE_LIB(strerror) 831AC_CHECK_PROTOTYPE_LIB(strstr) 832AC_CHECK_PROTOTYPE_LIB(getipnodebyname) 833AC_CHECK_PROTOTYPE_LIB(strndup) 834AC_CHECK_PROTOTYPE_LIB(memrchr) 835AC_CHECK_PROTOTYPE_LIB(if_indextoname) 836AC_CHECK_PROTOTYPE_LIB(ptsname) 837 838AC_MSG_CHECKING(for long long) 839AC_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])]) 843if test $sc_cv_type_longlong = yes; then 844 AC_DEFINE(HAVE_TYPE_LONGLONG) 845fi 846AC_MSG_RESULT($sc_cv_type_longlong) 847 848AC_CHECK_TYPE(sig_atomic_t,AC_DEFINE(HAVE_TYPE_SIG_ATOMIC_T),,[#include "sysincludes.h"]) 849 850AC_MSG_CHECKING(for bool) 851AC_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])]) 858if test $sc_cv_type_bool = yes; then 859 AC_DEFINE(HAVE_TYPE_BOOL) 860fi 861AC_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# 867AC_MSG_CHECKING(for socklen_t) 868AC_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])]) 874if test $sc_cv_type_socklen = yes; then 875 AC_DEFINE(HAVE_TYPE_SOCKLEN) 876fi 877AC_MSG_RESULT($sc_cv_type_socklen) 878 879AC_MSG_CHECKING(for struct stat64) 880AC_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])]) 884if test $sc_cv_type_stat64 = yes; then 885 AC_DEFINE(HAVE_TYPE_STAT64) 886fi 887AC_MSG_RESULT($sc_cv_type_stat64) 888 889AC_MSG_CHECKING(for off64_t) 890AC_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])]) 894if test $sc_cv_type_off64 = yes; then 895 AC_DEFINE(HAVE_TYPE_OFF64) 896fi 897AC_MSG_RESULT($sc_cv_type_off64) 898 899AC_MSG_CHECKING(for sighandler_t) 900AC_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])]) 904if test $sc_cv_type_sighandler = yes; then 905 AC_DEFINE(HAVE_TYPE_SIGHANDLER) 906fi 907AC_MSG_RESULT($sc_cv_type_socklen) 908 909AC_MSG_CHECKING(for uint8_t) 910AC_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])]) 922if test $sc_cv_type_uint8 = yes; then 923 AC_DEFINE(HAVE_TYPE_UINT8) 924fi 925AC_MSG_RESULT($sc_cv_type_uint8) 926 927AC_MSG_CHECKING(for uint16_t) 928AC_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])]) 940if test $sc_cv_type_uint16 = yes; then 941 AC_DEFINE(HAVE_TYPE_UINT16) 942fi 943AC_MSG_RESULT($sc_cv_type_uint16) 944 945AC_MSG_CHECKING(for uint32_t) 946AC_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])]) 958if test $sc_cv_type_uint32 = yes; then 959 AC_DEFINE(HAVE_TYPE_UINT32) 960fi 961AC_MSG_RESULT($sc_cv_type_uint32) 962 963AC_MSG_CHECKING(for uint64_t) 964AC_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])]) 976if test $sc_cv_type_uint64 = yes; then 977 AC_DEFINE(HAVE_TYPE_UINT64) 978fi 979AC_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 992AC_MSG_CHECKING(for fdset->fds_bits) 993AC_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 1001AC_MSG_CHECKING(for struct termios . c_ispeed) 1002AC_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 1010AC_MSG_CHECKING(for struct termios . c_ospeed) 1011AC_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 1019AC_MSG_CHECKING(for sa_family_t) 1020AC_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])]) 1026if test $sc_cv_type_sa_family_t = yes; then 1027 AC_DEFINE(HAVE_TYPE_SA_FAMILY_T) 1028fi 1029AC_MSG_RESULT($sc_cv_type_sa_family_t) 1030 1031AC_MSG_CHECKING(for struct sock_extended_err) 1032AC_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])]) 1042if test $sc_cv_struct_sock_extended_err = yes; then 1043 AC_DEFINE(HAVE_STRUCT_SOCK_EXTENDED_ERR) 1044fi 1045AC_MSG_RESULT($sc_cv_struct_sock_extended_err) 1046 1047AC_MSG_CHECKING(for struct sigaction.sa_sigaction) 1048AC_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])]) 1052if test $sc_cv_struct_sigaction_sa_sigaction = yes; then 1053 AC_DEFINE(HAVE_STRUCT_SIGACTION_SA_SIGACTION) 1054fi 1055AC_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 1059AC_MSG_CHECKING(if _SVID3 is helpful) 1060AC_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)]) 1071if test $ac_cv_svid3 = yes; then 1072 AC_DEFINE(_SVID3) 1073fi 1074AC_MSG_RESULT($ac_cv_svid3) 1075 1076 1077# Openindiana needs _XPG4_2 for CMSG stuff 1078AC_MSG_CHECKING(if _XPG4_2 is helpful) 1079AC_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)]) 1090if test $ac_cv_xpg4_2 = yes; then 1091 AC_DEFINE(_XPG4_2) 1092fi 1093AC_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 1099if 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__) 1116fi 1117 1118# When on Openindiana __EXTENSIONS__ is defined (see above) 1119# _POSIX_PTHREAD_SEMANTICS must be defined for standard ctime_r() 1120if 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) 1137fi 1138 1139 1140# struct timespec 1141AC_MSG_CHECKING(for struct timespec) 1142AC_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])]) 1149if test $sc_cv_struct_timespec = yes; then 1150 AC_DEFINE(HAVE_STRUCT_TIMESPEC) 1151fi 1152AC_MSG_RESULT($sc_cv_struct_timespec) 1153 1154 1155# struct linger; FreeBSD requires sys/types.h for sys/socket.h 1156AC_MSG_CHECKING(for struct linger) 1157AC_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])]) 1162if test $sc_cv_struct_linger = yes; then 1163 AC_DEFINE(HAVE_STRUCT_LINGER) 1164fi 1165AC_MSG_RESULT($sc_cv_struct_linger) 1166 1167 1168# struct ip (for IPv4 header info) 1169AC_MSG_CHECKING(for struct ip) 1170AC_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])]) 1175if test $sc_cv_struct_ip = yes; then 1176 AC_DEFINE(HAVE_STRUCT_IP) 1177fi 1178AC_MSG_RESULT($sc_cv_struct_ip) 1179 1180# struct ip_mreq (for multicasting options) 1181AC_MSG_CHECKING(for struct ip_mreq) 1182AC_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])]) 1188if test $sc_cv_struct_ip_mreq = yes; then 1189 AC_DEFINE(HAVE_STRUCT_IP_MREQ) 1190fi 1191AC_MSG_RESULT($sc_cv_struct_ip_mreq) 1192 1193# struct ip_mreqn (for multicasting options) 1194AC_MSG_CHECKING(for struct ip_mreqn) 1195AC_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])]) 1202if test $sc_cv_struct_ip_mreqn = yes; then 1203 AC_DEFINE(HAVE_STRUCT_IP_MREQN) 1204fi 1205AC_MSG_RESULT($sc_cv_struct_ip_mreqn) 1206 1207# struct ipv6_mreq (for multicasting options) 1208AC_MSG_CHECKING(for struct ipv6_mreq) 1209AC_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])]) 1215if test $sc_cv_struct_ipv6_mreq = yes; then 1216 AC_DEFINE(HAVE_STRUCT_IPV6_MREQ) 1217fi 1218AC_MSG_RESULT($sc_cv_struct_ipv6_mreq) 1219 1220# struct ip_mreq_source (for multicasting options) 1221AC_MSG_CHECKING(for struct ip_mreq_source) 1222AC_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])]) 1229if test $sc_cv_struct_ip_mreq_source = yes; then 1230 AC_DEFINE(HAVE_STRUCT_IP_MREQ_SOURCE) 1231fi 1232AC_MSG_RESULT($sc_cv_struct_ip_mreqn) 1233 1234 1235# struct ifreq (for network interfaces) 1236AC_MSG_CHECKING(for struct ifreq) 1237AC_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])]) 1243if test $sc_cv_struct_ifreq = yes; then 1244 AC_DEFINE(HAVE_STRUCT_IFREQ) 1245fi 1246AC_MSG_RESULT($sc_cv_struct_ifreq) 1247 1248# struct ifreq.ifr_index 1249# on most systems that have struct ifreq 1250AC_MSG_CHECKING(for struct ifreq.ifr_index) 1251AC_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])]) 1258if test $sc_cv_struct_ifreq_ifr_index = yes; then 1259 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_INDEX) 1260fi 1261AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_index) 1262 1263# struct ifreq.ifr_ifindex 1264# Linux has ifr_ifindex instead of ifr_index 1265AC_MSG_CHECKING(for struct ifreq.ifr_ifindex) 1266AC_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])]) 1273if test $sc_cv_struct_ifreq_ifr_ifindex = yes; then 1274 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_IFINDEX) 1275fi 1276AC_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 1281AC_MSG_CHECKING(for struct sockaddr.sa_len) 1282AC_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])]) 1288if test $sc_cv_struct_sockaddr_salen = yes; then 1289 AC_DEFINE(HAVE_STRUCT_SOCKADDR_SALEN) 1290fi 1291AC_MSG_RESULT($sc_cv_struct_sockaddr_salen) 1292 1293### IP6 sockaddr_in6 1294 1295AC_MSG_CHECKING(for component names of sockaddr_in6) 1296AC_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 1329dnl Check for struct iovec 1330AC_MSG_CHECKING(for struct iovec) 1331AC_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])]) 1335if test $sc_cv_struct_iovec = yes; then 1336 AC_DEFINE(HAVE_STRUCT_IOVEC) 1337fi 1338AC_MSG_RESULT($sc_cv_struct_iovec) 1339 1340dnl check for msg_control in struct msghdr 1341AC_MSG_CHECKING(for struct msghdr.msg_control) 1342AC_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])]) 1348if test $sc_cv_struct_msghdr_msgcontrol = yes; then 1349 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROL) 1350fi 1351AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrol) 1352 1353dnl check for msg_controllen in struct msghdr 1354AC_MSG_CHECKING(for struct msghdr.msg_controllen) 1355AC_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])]) 1361if test $sc_cv_struct_msghdr_msgcontrollen = yes; then 1362 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN) 1363fi 1364AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrollen) 1365 1366dnl check for msg_flags in struct msghdr 1367AC_MSG_CHECKING(for struct msghdr.msgflags) 1368AC_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])]) 1374if test $sc_cv_struct_msghdr_msgflags = yes; then 1375 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGFLAGS) 1376fi 1377AC_MSG_RESULT($sc_cv_struct_msghdr_msgflags) 1378 1379dnl check for struct cmsghdr 1380AC_MSG_CHECKING(for struct cmsghdr) 1381AC_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])]) 1387if test $sc_cv_struct_cmsghdr = yes; then 1388 AC_DEFINE(HAVE_STRUCT_CMSGHDR) 1389fi 1390AC_MSG_RESULT($sc_cv_struct_cmsghdr) 1391 1392dnl check for struct in_pktinfo 1393AC_MSG_CHECKING(for struct in_pktinfo) 1394AC_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])]) 1400if test $sc_cv_struct_in_pktinfo = yes; then 1401 AC_DEFINE(HAVE_STRUCT_IN_PKTINFO) 1402fi 1403AC_MSG_RESULT($sc_cv_struct_in_pktinfo) 1404 1405if 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) 1418fi 1419 1420dnl check for struct in6_pktinfo 1421AC_MSG_CHECKING(for struct in6_pktinfo) 1422AC_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])]) 1427if test $sc_cv_struct_in6_pktinfo = yes; then 1428 AC_DEFINE(HAVE_STRUCT_IN6_PKTINFO) 1429fi 1430AC_MSG_RESULT($sc_cv_struct_in6_pktinfo) 1431 1432dnl check for ip_hl in struct ip 1433AC_MSG_CHECKING(for struct ip.ip_hl) 1434AC_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])]) 1442if test $sc_cv_struct_ip_ip_hl = yes; then 1443 AC_DEFINE(HAVE_STRUCT_IP_IP_HL) 1444fi 1445AC_MSG_RESULT($sc_cv_struct_ip_ip_hl) 1446 1447 1448dnl Library function checks 1449 1450dnl Check sigaction() 1451AC_CHECK_FUNC(sigaction, AC_DEFINE(HAVE_SIGACTION)) 1452 1453dnl Check for 64bit versions of system calls 1454AC_CHECK_FUNC(stat64, AC_DEFINE(HAVE_STAT64)) 1455AC_CHECK_FUNC(fstat64, AC_DEFINE(HAVE_FSTAT64)) 1456AC_CHECK_FUNC(lstat64, AC_DEFINE(HAVE_LSTAT64)) 1457AC_CHECK_FUNC(lseek64, AC_DEFINE(HAVE_LSEEK64)) 1458AC_CHECK_FUNC(truncate64, AC_DEFINE(HAVE_TRUNCATE64)) 1459AC_CHECK_FUNC(ftruncate64, AC_DEFINE(HAVE_FTRUNCATE64)) 1460 1461AC_CHECK_FUNC(strtoll, AC_DEFINE(HAVE_STRTOLL)) 1462AC_CHECK_FUNC(hstrerror, AC_DEFINE(HAVE_HSTRERROR)) 1463AC_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 1484dnl Search for openpty() 1485# MacOS 1486AC_CHECK_FUNC(openpty, AC_DEFINE(HAVE_OPENPTY)) 1487# AIX 1488AC_CHECK_LIB(bsd, openpty, 1489 [LIBS="-lbsd $LIBS"; AC_DEFINE(HAVE_OPENPTY)]) 1490# Linux 2.4 1491AC_CHECK_LIB(util, openpty, 1492 [LIBS="-lutil $LIBS"; AC_DEFINE(HAVE_OPENPTY)]) 1493 1494AC_CHECK_PROTOTYPE_LIB(gettimeofday) 1495 1496AC_CHECK_LIB(rt, clock_gettime, 1497 [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_CLOCK_GETTIME)]) 1498 1499dnl Search for flock() 1500# with Linux it's in libc, with AIX in libbsd 1501AC_CHECK_FUNC(flock, AC_DEFINE(HAVE_FLOCK), 1502 AC_CHECK_LIB(bsd, flock, [LIBS="-lbsd $LIBS"])) 1503 1504dnl Search for setenv() 1505AC_CHECK_FUNC(setenv, AC_DEFINE(HAVE_SETENV), 1506 AC_CHECK_LIB(isode, setenv, [LIBS="-lisode $LIBS"])) 1507 1508dnl Search for unsetenv() 1509AC_CHECK_FUNC(unsetenv, AC_DEFINE(HAVE_UNSETENV)) 1510 1511AC_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])) 1512AC_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])) 1513AC_CHECK_FUNC(DTLS_client_method, AC_DEFINE(HAVE_DTLS_client_method), AC_CHECK_LIB(crypt, DTLS_client_method, [LIBS=-lcrypt $LIBS])) 1514AC_CHECK_FUNC(DTLS_server_method, AC_DEFINE(HAVE_DTLS_server_method), AC_CHECK_LIB(crypt, DTLS_server_method, [LIBS=-lcrypt $LIBS])) 1515if test -n "$WITH_OPENSSL_METHOD" -o -z "$ac_cv_have_tls_client_method" -o -z "$ac_cv_have_tls_server_method" ; then 1516dnl Search for SSLv2_client_method, SSLv2_server_method 1517AC_CHECK_FUNC(SSLv2_client_method, AC_DEFINE(HAVE_SSLv2_client_method), AC_CHECK_LIB(crypt, SSLv2_client_method, [LIBS=-lcrypt $LIBS])) 1518AC_CHECK_FUNC(SSLv2_server_method, AC_DEFINE(HAVE_SSLv2_server_method), AC_CHECK_LIB(crypt, SSLv2_server_method, [LIBS=-lcrypt $LIBS])) 1519dnl 1520AC_CHECK_FUNC(SSLv3_client_method, AC_DEFINE(HAVE_SSLv3_client_method), AC_CHECK_LIB(crypt, SSLv3_client_method, [LIBS=-lcrypt $LIBS])) 1521AC_CHECK_FUNC(SSLv3_server_method, AC_DEFINE(HAVE_SSLv3_server_method), AC_CHECK_LIB(crypt, SSLv3_server_method, [LIBS=-lcrypt $LIBS])) 1522AC_CHECK_FUNC(SSLv23_client_method, AC_DEFINE(HAVE_SSLv23_client_method), AC_CHECK_LIB(crypt, SSLv23_client_method, [LIBS=-lcrypt $LIBS])) 1523AC_CHECK_FUNC(SSLv23_server_method, AC_DEFINE(HAVE_SSLv23_server_method), AC_CHECK_LIB(crypt, SSLv23_server_method, [LIBS=-lcrypt $LIBS])) 1524AC_CHECK_FUNC(TLSv1_client_method, AC_DEFINE(HAVE_TLSv1_client_method), AC_CHECK_LIB(crypt, TLSv1_client_method, [LIBS=-lcrypt $LIBS])) 1525AC_CHECK_FUNC(TLSv1_server_method, AC_DEFINE(HAVE_TLSv1_server_method), AC_CHECK_LIB(crypt, TLSv1_server_method, [LIBS=-lcrypt $LIBS])) 1526AC_CHECK_FUNC(TLSv1_1_client_method, AC_DEFINE(HAVE_TLSv1_1_client_method), AC_CHECK_LIB(crypt, TLSv1_1_client_method, [LIBS=-lcrypt $LIBS])) 1527AC_CHECK_FUNC(TLSv1_1_server_method, AC_DEFINE(HAVE_TLSv1_1_server_method), AC_CHECK_LIB(crypt, TLSv1_1_server_method, [LIBS=-lcrypt $LIBS])) 1528AC_CHECK_FUNC(TLSv1_2_client_method, AC_DEFINE(HAVE_TLSv1_2_client_method), AC_CHECK_LIB(crypt, TLSv1_2_client_method, [LIBS=-lcrypt $LIBS])) 1529AC_CHECK_FUNC(TLSv1_2_server_method, AC_DEFINE(HAVE_TLSv1_2_server_method), AC_CHECK_LIB(crypt, TLSv1_2_server_method, [LIBS=-lcrypt $LIBS])) 1530AC_CHECK_FUNC(DTLSv1_client_method, AC_DEFINE(HAVE_DTLSv1_client_method), AC_CHECK_LIB(crypt, DTLSv1_client_method, [LIBS=-lcrypt $LIBS])) 1531AC_CHECK_FUNC(DTLSv1_server_method, AC_DEFINE(HAVE_DTLSv1_server_method), AC_CHECK_LIB(crypt, DTLSv1_server_method, [LIBS=-lcrypt $LIBS])) 1532AC_CHECK_FUNC(DTLSv1_2_client_method, AC_DEFINE(HAVE_DTLSv1_2_client_method), AC_CHECK_LIB(crypt, DTLSv1_2_client_method, [LIBS=-lcrypt $LIBS])) 1533AC_CHECK_FUNC(DTLSv1_2_server_method, AC_DEFINE(HAVE_DTLSv1_2_server_method), AC_CHECK_LIB(crypt, DTLSv1_2_server_method, [LIBS=-lcrypt $LIBS])) 1534fi # $WITH_OPENSSL_METHOD 1535 1536AC_CHECK_FUNC(SSL_CTX_set_default_verify_paths, AC_DEFINE(HAVE_SSL_CTX_set_default_verify_paths)) 1537AC_CHECK_FUNC(RAND_egd, AC_DEFINE(HAVE_RAND_egd), AC_CHECK_LIB(crypt, RAND_egd, [LIBS=-lcrypt $LIBS])) 1538AC_CHECK_FUNC(DH_set0_pqg, AC_DEFINE(HAVE_DH_set0_pqg), AC_CHECK_LIB(crypt, DH_set0_pqg, [LIBS=-lcrypt $LIBS])) 1539AC_CHECK_FUNC(ASN1_STRING_get0_data, AC_DEFINE(HAVE_ASN1_STRING_get0_data), AC_CHECK_LIB(crypt, ASN1_STRING_get0_data, [LIBS=-lcrypt $LIBS])) 1540AC_CHECK_FUNC(RAND_status, AC_DEFINE(HAVE_RAND_status)) 1541AC_CHECK_FUNC(SSL_CTX_clear_mode, AC_DEFINE(HAVE_SSL_CTX_clear_mode)) 1542AC_CHECK_FUNC(SSL_set_tlsext_host_name, AC_DEFINE(HAVE_SSL_set_tlsext_host_name)) 1543AC_CHECK_FUNC(SSL_library_init, AC_DEFINE(HAVE_SSL_library_init)) 1544AC_CHECK_FUNC(ERR_error_string, AC_DEFINE(HAVE_ERR_error_string)) 1545 1546AC_MSG_CHECKING(for type EC_KEY) 1547AC_CACHE_VAL(sc_cv_type_EC_TYPE, 1548[AC_TRY_COMPILE([#include <openssl/ec.h> 1549],[EC_KEY *s;], 1550[sc_cv_type_EC_KEY=yes], 1551[sc_cv_type_EC_KEY=no])]) 1552if test $sc_cv_type_EC_KEY = yes; then 1553 AC_DEFINE(HAVE_TYPE_EC_KEY) 1554fi 1555AC_MSG_RESULT($sc_cv_type_EC_KEY) 1556 1557 1558dnl Run time checks 1559 1560 1561AC_MSG_CHECKING(if snprintf conforms to C99) 1562AC_CACHE_VAL(ac_cv_have_c99_snprintf, 1563[AC_TRY_RUN([ 1564#include <stdio.h> 1565#include <stdlib.h> 1566int main(void){ 1567char s[2]; 1568exit(snprintf(s,2,"ab")!=2); 1569}], 1570[ac_cv_have_c99_snprintf=yes], 1571[ac_cv_have_c99_snprintf=no], 1572[ac_cv_have_c99_snprintf=no])]) 1573if test $ac_cv_have_c99_snprintf = yes; then 1574 AC_DEFINE(HAVE_C99_SNPRINTF) 1575fi 1576AC_MSG_RESULT($ac_cv_have_c99_snprintf) 1577 1578 1579AC_MSG_CHECKING(if printf has Z modifier) 1580AC_CACHE_VAL(ac_cv_have_z_modifier, 1581if test "$cc" = gcc; then 1582[AC_TRY_RUN([ 1583#include <stdlib.h> 1584#include <stdio.h> 1585int main(void){ 1586char s[16]; 1587sprintf(s,"%Zu",1); 1588exit(strcmp(s,"1")); 1589}], 1590[ac_cv_have_z_modifier=yes], 1591[ac_cv_have_z_modifier=no], 1592[ac_cv_have_z_modifier=no])] 1593else ac_cv_have_z_modifier=no 1594fi 1595) 1596if test $ac_cv_have_z_modifier = yes; then 1597 AC_DEFINE(HAVE_FORMAT_Z) 1598fi 1599AC_MSG_RESULT($ac_cv_have_z_modifier) 1600 1601 1602dnl find the number of bits we must shift a value to match the given mask 1603dnl (e.g., mask 0x00f0 requires shifting with 4) 1604## NOTE: some platforms only need one '\' to escape '"' in string constant 1605define(AC_SHIFT_OFFSET,[ 1606AC_CACHE_CHECK(shift offset of $1, $2, 1607[LIBS1="$LIBS"; LIBS="" # avoid libwrap allow_severity undefined 1608 conftestoffset="conftestoffset.out" 1609 AC_TRY_RUN([ 1610 #include <errno.h> 1611 #include <stdlib.h> 1612 #include <stdio.h> 1613 #include <termios.h> 1614 #include <string.h> 1615 int main(){ 1616 unsigned int i,n=$1; 1617 FILE *f; 1618 if ((f=fopen("$conftestoffset","w"))==NULL){ 1619 fprintf(stderr,"\\"$conftestoffset\\": %s\n",strerror(errno)); exit(-1); 1620 } 1621 if (n==0) {fprintf(stderr,"$1 is 0 (impossible!)\n"); exit(1);} 1622 i=0; while (!(n&1)) { 1623 n>>=1; ++i; } 1624 if (3<<i == $1) { 1625 fprintf(f, "%u", i); 1626 } else { 1627 fprintf(f, "-1"); /* anticipate result of xioinitialize assert */ 1628 } 1629 exit(0); 1630 } 1631 ], 1632 [$2=`cat $conftestoffset`], 1633 [$2=-1], 1634 [$2=-1] 1635) 1636 LIBS="$LIBS1"]) 1637AC_DEFINE_UNQUOTED($1_SHIFT, ${$2}) 1638if test "$2" = -1; then 1639AC_MSG_WARN(please determine $1_SHIFT manually) 1640fi 1641]) 1642 1643AC_SHIFT_OFFSET(CRDLY, sc_cv_sys_crdly_shift) 1644AC_SHIFT_OFFSET(TABDLY, sc_cv_sys_tabdly_shift) 1645AC_SHIFT_OFFSET(CSIZE, sc_cv_sys_csize_shift) 1646 1647 1648dnl Find what physical type (basic C type) is equivalent to the given type. 1649dnl If possible we try to compile simple test code and get no warning only with 1650dnl the matching type. 1651dnl If this method does not seem to work we run test programs that print the 1652dnl length and signedness of the type. 1653 1654dnl do we have a -Werror option? 1655dnl Does the test code compile with -Werror when types fit? 1656CHANCE_TO_TYPECHECK=1 1657CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')" 1658AC_TRY_COMPILE([#include <stdlib.h>],[int u; int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0) 1659CFLAGS="$CFLAGS1" 1660 1661dnl Does the test code compile without -Werror when types do not fit? 1662if test "$CHANCE_TO_TYPECHECK" -ne 0; then 1663 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0) 1664fi 1665 1666dnl Does the test code fail to compile with -Werror when types do not fit? 1667if test "$CHANCE_TO_TYPECHECK" -ne 0; then 1668 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')" 1669 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],CHANCE_TO_TYPECHECK=0,) 1670 CFLAGS="$CFLAGS1" 1671fi 1672 1673if test "$CHANCE_TO_TYPECHECK" -ne 0; then 1674 AC_MSG_NOTICE(using compile -Werror method to find basic types) 1675else 1676 AC_MSG_NOTICE(using code run method to find basic types) 1677fi 1678 1679 1680dnl see AC_BASIC_TYPE 1681define(AC_BASIC_TYPE_GCC,[ 1682AC_CACHE_CHECK(for equivalent simple type of $2, $4, 1683[CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')" 1684 dnl echo "echo: trying short for $2" >&2 1685 AC_TRY_COMPILE([$1],[$2 u; short v; return(&u==&v);], 1686 [$4="1 /* short */"], 1687 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u==&v);], 1688 [$4="2 /* unsigned short */"], 1689 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u==&v);], 1690 [$4="3 /* int */"], 1691 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u==&v);], 1692 [$4="4 /* unsigned int */"], 1693 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u==&v);], 1694 [$4="5 /* long */"], 1695 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u==&v);], 1696 [$4="6 /* unsigned long */"], 1697 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u==&v);], 1698 [$4="7 /* long long */"], 1699 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u==&v);], 1700 [$4="8 /* unsigned long long */"], 1701 [$4="0 /* unknown, taking default */" 1702]) ]) ]) ]) ]) ]) ]) ]) 1703 CFLAGS="$CFLAGS1" ]) 1704AC_DEFINE_UNQUOTED($3, ${$4}) 1705]) 1706 1707dnl see AC_BASIC_TYPE 1708define(AC_BASIC_TYPE_OTHER,[ 1709AC_CACHE_CHECK(for equivalent simple type of $2, $4, 1710[AC_TRY_RUN([ 1711$1 1712int main() { return!(sizeof($2)==sizeof(short));}], 1713 # same length as short 1714 AC_TRY_RUN([ 1715$1 1716int main() { $2 x=-1; return !(x<0);}], 1717 [$4="1 /* short */"], 1718 [$4="2 /* unsigned short */"]), 1719 # length differs from short, try others 1720 AC_TRY_RUN([ 1721$1 1722int main() { return!(sizeof($2)==sizeof(int));}], 1723 # same length as int 1724 AC_TRY_RUN([ 1725$1 1726int main() { $2 x=-1; return !(x<0);}], 1727 [$4="3 /* int */"], 1728 [$4="4 /* unsigned int */"]), 1729 # length differs from int, try others 1730 AC_TRY_RUN([ 1731$1 1732int main() { return !(sizeof($2)==sizeof(long));}], 1733 # same length as long 1734 AC_TRY_RUN([ 1735$1 1736int main() { $2 x=-1; return !(x<0);}], 1737 [$4="5 /* long */"], 1738 [$4="6 /* unsigned long */"] ), 1739 # length differs from long, try others 1740 AC_TRY_RUN([ 1741$1 1742int main() { return !(sizeof($2)==sizeof(long long));}], 1743 # same length as long long 1744 AC_TRY_RUN([ 1745$1 1746int main() { $2 x=-1; return !(x<0);}], 1747 [$4="7 /* long long */"], 1748 [$4="8 /* unsigned long long */"] ), 1749 [$4="0 /* unknown */"] 1750 ) 1751 ) 1752 ) 1753) 1754]) 1755AC_DEFINE_UNQUOTED($3, ${$4}) 1756]) 1757 1758dnl find what physical type (basic C type) is equivalent to the given type. 1759dnl arg1: include file(s) 1760dnl arg2: type name 1761dnl arg3: output variable 1762dnl arg4: cache variable (might be constructed automatically) 1763dnl output values: 1..short, 2..unsigned short, 3..int, 4..u-int, 1764dnl 5..long, 6..u-long; others not yet supported 1765define(AC_BASIC_TYPE,[ 1766 if test "$CHANCE_TO_TYPECHECK" -ne 0; then 1767 AC_BASIC_TYPE_GCC([$1],[$2],[$3],[$4]) 1768 else 1769 AC_BASIC_TYPE_OTHER([$1],[$2],[$3],[$4]) 1770 fi 1771]) 1772 1773 1774dnl See AC_TYPEOF_COMPONENT 1775dnl This version is for compilers with -Werror or so: gcc, clang, Sun Studio? 1776define(AC_TYPEOF_COMPONENT_GCC,[ 1777AC_CACHE_CHECK(for basic type of $2.$3, $5, 1778[CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')" 1779AC_TRY_COMPILE([$1],[$2 u;short v; return(&u.$3==&v);], 1780[$5="1 /* short */"], 1781[AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u.$3==&v);], 1782 [$5="2 /* unsigned short */"], 1783 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u.$3==&v);], 1784 [$5="3 /* int */"], 1785 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u.$3==&v);], 1786 [$5="4 /* unsigned int */"], 1787 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u.$3==&v);], 1788 [$5="5 /* long */"], 1789 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u.$3==&v);], 1790 [$5="6 /* unsigned long */"], 1791 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u.$3==&v);], 1792 [$5="7 /* long long */"], 1793 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u.$3==&v);], 1794 [$5="8 /* unsigned long long */"], 1795 [$5="0 /* unknown, taking default */" 1796]) ]) ]) ]) ]) ]) ]) ]) 1797 CFLAGS="$CFLAGS1" ]) 1798AC_DEFINE_UNQUOTED($4, ${$5}) 1799]) 1800 1801dnl See AC_TYPEOF_COMPONENT 1802dnl This version is for compilers with no -Werror or so 1803define(AC_TYPEOF_COMPONENT_OTHER,[ 1804AC_CACHE_CHECK(for basic type of $2.$3, $5, 1805[AC_TRY_RUN([ 1806$1 1807int main() { $2 x; return!(sizeof(x.$3)==sizeof(short));}], 1808 # same length as short 1809 AC_TRY_RUN([ 1810$1 1811int main() { $2 x; x.$3=-1; return !(x.$3<0);}], 1812 [$5="1 /* short */"], 1813 [$5="2 /* unsigned short */"]), 1814 # length differs from short, try others 1815 AC_TRY_RUN([ 1816$1 1817int main() { $2 x; return!(sizeof(x.$3)==sizeof(int));}], 1818 # same length as int 1819 AC_TRY_RUN([ 1820$1 1821int main() { $2 x; x.$3=-1; return !(x.$3<0);}], 1822 [$5="3 /* int */"], 1823 [$5="4 /* unsigned int */"]), 1824 # length differs from int, try others 1825 AC_TRY_RUN([ 1826$1 1827int main() { $2 x; return !(sizeof(x.$3)==sizeof(long));}], 1828 # same length as long 1829 AC_TRY_RUN([ 1830$1 1831int main() { $2 x; x.$3=-1; return !(x.$3<0);}], 1832 [$5="5 /* long */"], 1833 [$5="6 /* unsigned long */"] ), 1834 # length differs from long, try others 1835 AC_TRY_RUN([ 1836$1 1837int main() { $2 x; return !(sizeof(x.$3)==sizeof(long long));}], 1838 # same length as long long 1839 AC_TRY_RUN([ 1840$1 1841int main() { x $2; x.$3=-1; return !(x.$3<0);}], 1842 [$5="7 /* long long */"], 1843 [$5="8 /* unsigned long long */"] ), 1844 [$5="0 /* unknown */"] 1845 ) 1846 ) 1847 ) 1848) 1849]) 1850AC_DEFINE_UNQUOTED($4, ${$5}) 1851]) 1852 1853dnl find what physical type (basic C type) describes the given struct or union 1854dnl component. 1855dnl arg1: include file(s); must declare the structure type 1856dnl arg2: struct name (e.g., "struct stat") 1857dnl arg3: variable or component (e.g., "st_ino") 1858dnl arg4: output variable, values see AC_BASIC_TYPE 1859dnl arg5: cache variable (might be constructed automatically) 1860define(AC_TYPEOF_COMPONENT,[ 1861 if test "$CHANCE_TO_TYPECHECK" -ne 0; then 1862 AC_TYPEOF_COMPONENT_GCC([$1],[$2],[$3],[$4],[$5]) 1863 else 1864 AC_TYPEOF_COMPONENT_OTHER([$1],[$2],[$3],[$4],[$5]) 1865 fi 1866]) 1867 1868AC_BASIC_TYPE([#include <stdint.h>], uint16_t, HAVE_BASIC_UINT16_T, sc_cv_type_uint16_basic) 1869AC_BASIC_TYPE([#include <stdint.h>], uint32_t, HAVE_BASIC_UINT32_T, sc_cv_type_uint32_basic) 1870AC_BASIC_TYPE([#include <stdint.h>], uint64_t, HAVE_BASIC_UINT64_T, sc_cv_type_uint64_basic) 1871AC_BASIC_TYPE([#include <stdint.h>], int16_t, HAVE_BASIC_INT16_T, sc_cv_type_int16_basic) 1872AC_BASIC_TYPE([#include <stdint.h>], int32_t, HAVE_BASIC_INT32_T, sc_cv_type_int32_basic) 1873AC_BASIC_TYPE([#include <stdint.h>], int64_t, HAVE_BASIC_INT64_T, sc_cv_type_int64_basic) 1874AC_BASIC_TYPE([#include <stdlib.h>], size_t, HAVE_BASIC_SIZE_T, sc_cv_type_sizet_basic) 1875AC_BASIC_TYPE([#include <sys/types.h> 1876#include <sys/stat.h> 1877#include <unistd.h>], mode_t, HAVE_BASIC_MODE_T, sc_cv_type_modet_basic) 1878AC_BASIC_TYPE([#include <sys/types.h> 1879#include <unistd.h>], pid_t, HAVE_BASIC_PID_T, sc_cv_type_pidt_basic) 1880AC_BASIC_TYPE([#include <sys/types.h> 1881#include <unistd.h>], uid_t, HAVE_BASIC_UID_T, sc_cv_type_uidt_basic) 1882AC_BASIC_TYPE([#include <sys/types.h> 1883#include <unistd.h>], gid_t, HAVE_BASIC_GID_T, sc_cv_type_gidt_basic) 1884 1885AC_BASIC_TYPE([#include <time.h>], time_t, HAVE_BASIC_TIME_T, 1886 sc_cv_type_timet_basic) 1887 1888# this is questionable, might fail on some systems 1889AC_BASIC_TYPE([#include <sys/types.h> 1890#include <sys/socket.h> 1891#include <unistd.h>], socklen_t, HAVE_BASIC_SOCKLEN_T, 1892 sc_cv_type_socklent_basic) 1893 1894AC_BASIC_TYPE([#include <sys/types.h> 1895#include <unistd.h>], off_t, HAVE_BASIC_OFF_T, sc_cv_type_off_basic) 1896 1897AC_BASIC_TYPE([#include <sys/types.h> 1898#include <unistd.h>], off64_t, HAVE_BASIC_OFF64_T, sc_cv_type_off64_basic) 1899 1900# oh god, __dev_t in Linux 2.4 is struct{int[2];}, not handled here yet. 1901AC_BASIC_TYPE([#include <sys/stat.h>], dev_t, HAVE_BASIC_DEV_T, sc_cv_type_dev_basic) 1902 1903AC_BASIC_TYPE([#include <unistd.h> 1904#include <termios.h>], speed_t, HAVE_BASIC_SPEED_T, sc_cv_type_spee_t) 1905 1906AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_ino, HAVE_TYPEOF_ST_INO, sc_cv_type_stat_stino_basic) 1907AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_nlink, HAVE_TYPEOF_ST_NLINK, sc_cv_type_stat_stnlink_basic) 1908AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_size, HAVE_TYPEOF_ST_SIZE, sc_cv_type_stat_stsize_basic) 1909AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blksize, HAVE_TYPEOF_ST_BLKSIZE, sc_cv_type_stat_stblksize_basic) 1910AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blocks, HAVE_TYPEOF_ST_BLOCKS, sc_cv_type_stat_stblocks_basic) 1911# 1912if test "$ac_cv_func_stat64" = yes; then 1913AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_dev, HAVE_TYPEOF_ST64_DEV, sc_cv_type_stat64_stdev_basic) 1914AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_ino, HAVE_TYPEOF_ST64_INO, sc_cv_type_stat64_stino_basic) 1915AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_nlink, HAVE_TYPEOF_ST64_NLINK, sc_cv_type_stat64_stnlink_basic) 1916AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_size, HAVE_TYPEOF_ST64_SIZE, sc_cv_type_stat64_stsize_basic) 1917AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blksize, HAVE_TYPEOF_ST64_BLKSIZE, sc_cv_type_stat64_stblksize_basic) 1918AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blocks, HAVE_TYPEOF_ST64_BLOCKS, sc_cv_type_stat64_stblocks_basic) 1919fi 1920 1921AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timeval, tv_usec, HAVE_TYPEOF_STRUCT_TIMEVAL_TV_USEC, sc_cv_type_struct_timeval_tv_usec) 1922 1923AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timespec, tv_nsec, HAVE_TYPEOF_STRUCT_TIMESPEC_TV_NSEC, sc_cv_type_struct_timespec_tv_nsec) 1924 1925AC_TYPEOF_COMPONENT([#include <sys/types.h> 1926#include <sys/time.h> 1927#include <sys/resource.h>], 1928struct rlimit, rlim_max, HAVE_TYPEOF_RLIM_MAX, sc_cv_type_rlimit_rlimmax_basic) 1929 1930# Fedora-19 doc says it is socklen_t which is equivalent to unsigned int, but it is equivalent to size_t (x86_64) 1931AC_TYPEOF_COMPONENT([#include "sysincludes.h"], struct cmsghdr, cmsg_len, HAVE_TYPEOF_STRUCT_CMSGHDR_CMSG_LEN, sc_cv_typeof_struct_cmsghdr_cmsg_len) 1932### snprintf, vsnprintf 1933 1934AC_MSG_CHECKING(for /dev/ptmx) 1935if test -c /dev/ptmx; then 1936 AC_DEFINE(HAVE_DEV_PTMX, 1) 1937 AC_MSG_RESULT(yes) 1938else 1939 AC_MSG_RESULT(no) 1940 AC_MSG_CHECKING(for /dev/ptc) 1941 if test -c /dev/ptc; then 1942 AC_DEFINE(HAVE_DEV_PTC) 1943 AC_MSG_RESULT(yes) 1944 else 1945 AC_MSG_RESULT(no) 1946 fi 1947fi 1948 1949AC_MSG_CHECKING(for /proc) 1950if test -d /proc; then 1951 AC_DEFINE(HAVE_PROC_DIR, 1) 1952 AC_MSG_RESULT(yes) 1953else 1954 AC_MSG_RESULT(no) 1955fi 1956 1957AC_MSG_CHECKING(for /proc/*/fd) 1958if test -d /proc/$$/fd; then 1959 AC_DEFINE(HAVE_PROC_DIR_FD, 1) 1960 AC_MSG_RESULT(yes) 1961else 1962 AC_MSG_RESULT(no) 1963fi 1964 1965dnl "tcpd" "tcpwrappers" 1966# on some platforms, raw linking with libwrap fails because allow_severity and 1967# deny_severity are not explicitely defined. Thus we put the libwrap part to 1968# the end 1969AC_MSG_CHECKING(whether to include libwrap support) 1970AC_ARG_ENABLE(libwrap, [ --disable-libwrap disable libwrap support], 1971 [ case "$enableval" in 1972 no) AC_MSG_RESULT(no); WITH_LIBWRAP= ;; 1973 *) AC_MSG_RESULT(yes); WITH_LIBWRAP=1 ;; 1974 esac], 1975 [ AC_MSG_RESULT(yes); WITH_LIBWRAP=1 ]) 1976# 1977# check if we find the components of libwrap ("tcpd" "tcpwrappers") 1978if test -n "$WITH_LIBWRAP"; then 1979 AC_MSG_CHECKING(for components of libwrap) 1980 # first, we need to find the include file <tcpd.h> 1981 AC_CACHE_VAL(sc_cv_have_tcpd_h, 1982 [AC_TRY_COMPILE([#include <sys/types.h> 1983#include <tcpd.h>],[;], 1984 [sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT=""], 1985 [sc_cv_have_tcpd_h=no 1986 for D in "/sw" "/usr/local" "/opt/freeware" "/usr/sfw"; do 1987 I="$D/include" 1988 i="$I/tcpd.h" 1989 if test -r "$i"; then 1990 #V_INCL="$V_INCL -I$I" 1991 CPPFLAGS="$CPPFLAGS -I$I" 1992 AC_MSG_NOTICE(found $i) 1993 sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT="$D" 1994 break; 1995 fi 1996 done]) 1997 ]) 1998 if test "$sc_cv_have_tcpd_h" = "yes"; then 1999 AC_DEFINE(HAVE_TCPD_H) 2000 fi 2001 AC_MSG_NOTICE(checked for tcpd.h... $sc_cv_have_tcpd_h) 2002fi # end checking for tcpd.h 2003if test -n "$WITH_LIBWRAP" -a "$sc_cv_have_tcpd_h" = yes; then 2004 # next, we search for the wrap library (libwrap.*) 2005 AC_MSG_CHECKING(for libwrap) 2006 AC_CACHE_VAL(sc_cv_have_libwrap, 2007 [ LIBS0="$LIBS" 2008 if test -n "$LIBWRAP_ROOT"; then 2009 L="$LIBWRAP_ROOT/lib"; LIBS="-L$L -lwrap $LIBS" 2010 else 2011 LIBS="-lwrap $LIBS" 2012 fi 2013 AC_TRY_LINK([#include <sys/types.h> 2014#include <tcpd.h> 2015int allow_severity,deny_severity;],[hosts_access(0)], 2016 [sc_cv_have_libwrap='yes'], 2017 [sc_cv_have_libwrap='no' 2018 LIBS="$LIBS -lnsl" # RedHat73 2019 AC_TRY_LINK([#include <sys/types.h> 2020#include <tcpd.h> 2021int allow_severity,deny_severity;],[hosts_access(0)], 2022 [sc_cv_have_libwrap='yes'], 2023 [sc_cv_have_libwrap='no']) 2024 ] 2025 ) 2026 if test "$sc_cv_have_libwrap" != 'yes'; then 2027 LIBS="$LIBS0" 2028 fi 2029 ] 2030 ) 2031 if test "$sc_cv_have_libwrap" = 'yes'; then 2032 AC_DEFINE(HAVE_LIBWRAP) 2033 fi 2034 AC_MSG_RESULT($sc_cv_have_libwrap) 2035fi 2036# 2037if test -n "$WITH_LIBWRAP"; then 2038 if test "$sc_cv_have_tcpd_h" = "yes" -a "$sc_cv_have_libwrap" = "yes"; then 2039 AC_DEFINE(WITH_LIBWRAP) 2040 else 2041 AC_MSG_WARN([not all components of tcp wrappers found, disabling it]); 2042 fi 2043fi 2044 2045# check of hosts_allow_table 2046if test -n "$WITH_LIBWRAP"; then 2047 AC_MSG_CHECKING(for hosts_allow_table) 2048 AC_CACHE_VAL(sc_cv_have_hosts_allow_table, 2049 [AC_TRY_COMPILE([#include <sys/types.h> 2050#include <tcpd.h>],[hosts_allow_table="";], 2051 [sc_cv_have_hosts_allow_table=yes], 2052 [sc_cv_have_hosts_allow_table=no])]) 2053 if test $sc_cv_have_hosts_allow_table = yes; then 2054 AC_DEFINE(HAVE_HOSTS_ALLOW_TABLE) 2055 fi 2056 AC_MSG_RESULT($sc_cv_have_hosts_allow_table) 2057fi # test -n "$WITH_LIBWRAP" 2058 2059 2060if test "$GCC" = yes; then 2061 CFLAGS="$CFLAGS" 2062fi 2063 2064# FIPS support requires compiling with fipsld. 2065# fipsld requires the FIPSLD_CC variable to be set to the original CC. 2066# This check must be done after all other checks that require compiling 2067# so that fipsld is not used by the configure script itself. 2068if test -n "$WITH_FIPS"; then 2069 if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then 2070 FIPSLD_CC=$CC 2071 if test "${FIPSLD+set}" != set ; then 2072 FIPSLD=fipsld 2073 fi 2074 CC="FIPSLD_CC=$CC $FIPSLD" 2075 fi 2076fi 2077AC_SUBST(FIPSLD_CC) 2078 2079# autoconf does not seem to provide AC_CHECK_VAR or so 2080# thus we have to check by foot 2081AC_MSG_CHECKING(for declaration of environ) 2082AC_CACHE_VAL(sc_cv_decl_environ, 2083[AC_TRY_COMPILE([#include <unistd.h>],[char **s = environ;], 2084[sc_cv_decl_environ=yes], 2085[sc_cv_decl_environ=no])]) 2086if test $sc_cv_decl_environ = yes; then 2087 AC_DEFINE(HAVE_DECL_ENVIRON) 2088fi 2089AC_MSG_RESULT($sc_cv_decl_environ) 2090 2091# on some systems environ exists but not the declaration 2092AC_MSG_CHECKING(for var environ) 2093AC_CACHE_VAL(sc_cv_var_environ, 2094[AC_TRY_COMPILE([],[extern char **environ; char **s = environ;], 2095[sc_cv_var_environ=yes], 2096[sc_cv_var_environ=no])]) 2097if test $sc_cv_var_environ = yes; then 2098 AC_DEFINE(HAVE_VAR_ENVIRON) 2099fi 2100AC_MSG_RESULT($sc_cv_var_environ) 2101 2102# allow BUILD_DATE to be externally set for build reproducibility 2103if test "$BUILD_DATE"; then 2104 AC_DEFINE_UNQUOTED(BUILD_DATE, ["$BUILD_DATE"]) 2105else 2106 AC_DEFINE(BUILD_DATE, [__DATE__" "__TIME__]) 2107fi 2108 2109AC_OUTPUT(Makefile) 2110