1 dnl source: configure.in
2 dnl Copyright Gerhard Rieger and contributors (see file CHANGES)
3 dnl Published under the GNU General Public License V.2, see file COPYING
5 dnl Process this file with autoconf to produce a configure script.
8 AC_CONFIG_HEADER(config.h)
10 if test -f /usr/xpg4/bin/fgrep; then
11 FGREP=/usr/xpg4/bin/fgrep # Solaris
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"`
23 AC_MSG_RESULT($SYSDEFS)
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"
33 dnl Checks for programs.
34 AC_PROG_INSTALL(install)
38 AC_CHECK_PROG(AR, ar, ar, gar)
40 # we need to explicitely call this here; otherwise, with --disable-libwrap we
42 AC_LANG_COMPILER_REQUIRE()
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"
51 # ERRONWARN="-errwarn"
58 dnl Checks for header files.
60 AC_CHECK_HEADERS(stdbool.h)
61 AC_CHECK_HEADERS(inttypes.h)
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
75 #include <sys/socket.h>
76 #endif]) # Mac OS X requires including sys/socket.h
77 AC_CHECK_HEADERS(arpa/nameser.h)
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)
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)
96 dnl Link libresolv if necessary (for Mac OS X)
97 AC_SEARCH_LIBS([res_9_init], [resolv])
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))
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]);
117 if test $sc_cv_have_prototype_lib_$1 = yes; then
118 AC_DEFINE(HAVE_PROTOTYPE_LIB_$1)
120 AC_MSG_RESULT($sc_cv_have_prototype_lib_$1)
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]);
132 if test $sc_cv_have_prototype_hstrerror = yes; then
133 AC_DEFINE(HAVE_PROTOTYPE_HSTRERROR)
135 AC_MSG_RESULT($sc_cv_have_prototype_hstrerror)
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);;
144 [AC_DEFINE(WITH_HELP) AC_MSG_RESULT(yes)])
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);;
152 [AC_DEFINE(WITH_STDIO) AC_MSG_RESULT(yes)])
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);;
160 [AC_DEFINE(WITH_FDNUM) AC_MSG_RESULT(yes)])
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);;
168 [AC_DEFINE(WITH_FILE) AC_MSG_RESULT(yes)])
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);;
176 [AC_DEFINE(WITH_CREAT) AC_MSG_RESULT(yes)])
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);;
184 [AC_DEFINE(WITH_GOPEN) AC_MSG_RESULT(yes)])
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);;
192 [AC_DEFINE(WITH_PIPE) AC_MSG_RESULT(yes)])
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);;
200 [AC_DEFINE(WITH_TERMIOS) AC_MSG_RESULT(yes)])
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);;
208 [AC_DEFINE(WITH_UNIX) AC_MSG_RESULT(yes)])
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);;
218 AC_DEFINE(WITH_ABSTRACT_UNIXSOCKET) AC_MSG_RESULT(yes);;
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);;
229 [AC_DEFINE(WITH_IP4) AC_MSG_RESULT(yes)])
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 ;;
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])],
243 #ifdef HAVE_NETINET_IN_H
244 # include <netinet/in.h>
246 AC_CHECK_HEADERS(netinet6/in6.h) # found on OpenBSD and Lion, used for IPV6_*
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
253 [ac_cv_apple_use_rfc_2292=no],
254 [AC_TRY_COMPILE([#define __APPLE_USE_RFC_2292],
255 [#ifndef IPV6_HOPOPTS
258 [ac_cv_apple_use_rfc_2292=yes],
259 [ac_cv_apple_use_rfc_2292=no]
262 if test "$ac_cv_apple_use_rfc_2292" = yes; then
263 AC_DEFINE(__APPLE_USE_RFC_2292)
265 AC_MSG_RESULT($ac_cv_apple_use_rfc_2292)
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);;
275 [AC_DEFINE(WITH_RAWIP) AC_MSG_RESULT(yes)])
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);;
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 ;;
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),
295 AC_MSG_WARN([include file netpacket/packet.h not found, disabling interface])])
297 if test "$WITH_INTERFACE"; then
298 AC_CHECK_HEADER(netinet/if_ether.h,
299 AC_DEFINE(HAVE_NETINET_IF_ETHER_H),
301 AC_MSG_WARN([include file netinet/if_ether.h not found, disabling interface])],
303 #if HAVE_NET_IF_H && HAVE_NETINET_IN_H
305 #include <netinet/in.h>
308 if test "$WITH_INTERFACE"; then
309 AC_DEFINE(WITH_INTERFACE)
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);;
318 [AC_DEFINE(WITH_TCP) AC_MSG_RESULT(yes)])
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);;
326 [AC_DEFINE(WITH_UDP) AC_MSG_RESULT(yes)])
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 ;;
334 [AC_MSG_RESULT(yes); WITH_SCTP=1 ])
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>],
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
348 AC_MSG_WARN([IPPROTO_SCTP undefined, disabling SCTP support])
352 AC_MSG_CHECKING(whether to include vsock support)
353 AC_ARG_ENABLE(vsock, [ --disable-vsock disable vsock support],
354 [case "$enableval" in
355 no) AC_MSG_RESULT(no); WITH_VSOCK= ;;
356 *) AC_MSG_RESULT(yes); WITH_VSOCK=1 ;;
358 [AC_MSG_RESULT(yes); WITH_VSOCK=1 ])
359 if test "$WITH_VSOCK"; then
360 AC_CHECK_HEADER(linux/vm_sockets.h,
361 AC_DEFINE(HAVE_LINUX_VM_SOCKETS_H),
363 AC_MSG_WARN([include file linux/vm_sockets.h not found, disabling vsock])],
365 #if HAVE_SYS_SOCKET_H
366 #include <sys/socket.h>
371 if test "$WITH_VSOCK"; then
372 AC_DEFINE(WITH_VSOCK)
375 AC_MSG_CHECKING(whether to include listen support)
376 AC_ARG_ENABLE(listen, [ --disable-listen disable listen support],
377 [case "$enableval" in
378 no) AC_MSG_RESULT(no);;
379 *) AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes);;
381 [AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes)])
383 AC_MSG_CHECKING(whether to include socks4 support)
384 AC_ARG_ENABLE(socks4, [ --disable-socks4 disable socks4 support],
385 [case "$enableval" in
386 no) AC_MSG_RESULT(no);;
387 *) AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes);;
389 [AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes)])
391 AC_MSG_CHECKING(whether to include socks4a support)
392 AC_ARG_ENABLE(socks4a, [ --disable-socks4a disable socks4a support],
393 [case "$enableval" in
394 no) AC_MSG_RESULT(no);;
395 *) AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes);;
397 [AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes)])
399 AC_MSG_CHECKING(whether to include proxy connect support)
400 AC_ARG_ENABLE(proxy, [ --disable-proxy disable proxy connect support],
401 [case "$enableval" in
402 no) AC_MSG_RESULT(no);;
403 *) AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes);;
405 [AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes)])
407 AC_MSG_CHECKING(whether to include exec support)
408 AC_ARG_ENABLE(exec, [ --disable-exec disable exec support],
409 [case "$enableval" in
410 no) AC_MSG_RESULT(no);;
411 *) AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes);;
413 [AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes)])
415 AC_MSG_CHECKING([whether to include system (shell) support])
416 AC_ARG_ENABLE(system, [ --disable-system disable system (shell) support],
417 [case "$enableval" in
418 no) AC_MSG_RESULT(no);;
419 *) AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes);;
421 [AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes)])
423 AC_MSG_CHECKING(whether to include pty address support)
424 AC_ARG_ENABLE(pty, [ --disable-pty disable pty support],
425 [case "$enableval" in
426 no) AC_MSG_RESULT(no);;
427 *) AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes);;
429 [AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes)])
431 AC_MSG_CHECKING(whether to include fs attributes support)
432 AC_ARG_ENABLE(fs, [ --disable-fs disable fs attributes support],
433 [case "$enableval" in
434 no) AC_MSG_RESULT(no);;
435 *) AC_DEFINE(WITH_FS) AC_MSG_RESULT(yes);;
437 [AC_DEFINE(WITH_FS) AC_MSG_RESULT(yes)])
439 AC_MSG_CHECKING(whether to include readline support)
440 AC_ARG_ENABLE(readline, [ --disable-readline disable readline support],
441 [case "$enableval" in
442 no) AC_MSG_RESULT(no); WITH_READLINE= ;;
443 *) AC_MSG_RESULT(yes); WITH_READLINE=1 ;;
445 [AC_MSG_RESULT(yes); WITH_READLINE=1 ])
447 if test -n "$WITH_READLINE"; then
448 CPPFLAGS_ORIG=$CPPFLAGS
451 sc_usable_readline_found=
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"
459 DLOC="in default location"
461 AC_MSG_CHECKING(for usable readline $DLOC)
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
468 for L in "" "-lcurses" "-lncurses"; do
469 LIBS="$LIBS_ORIG -lreadline $L"
472 #include <readline/readline.h>
473 #include <readline/history.h>],
475 append_history(0, NULL); ],
476 [ sc_usable_readline_found=1
480 if test -n "$sc_usable_readline_found"; then
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)
489 CPPFLAGS=$CPPFLAGS_ORIG
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])
500 AC_MSG_CHECKING(whether to include openssl support)
501 AC_ARG_ENABLE(openssl, [ --disable-openssl disable OpenSSL support],
502 [ case "$enableval" in
503 no) AC_MSG_RESULT(no); WITH_OPENSSL= ;;
504 *) AC_MSG_RESULT(yes); WITH_OPENSSL=1 ;;
506 [ AC_MSG_RESULT(yes); WITH_OPENSSL=1 ])
507 AC_ARG_ENABLE(openssl_base, [ --enable-openssl-base specify directory with include/ and lib/],
508 [ OPENSSL_BASE="$enableval" ],
509 [ unset OPENSSL_BASE ])
511 if test -n "$WITH_OPENSSL"; then
512 if test -n "$OPENSSL_BASE"; then
513 sc_cv_have_openssl_ssl_h=yes; OPENSSL_BASE="$D"
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
524 Ds="/sw /usr/local /opt/freeware /usr/sfw /usr/local/ssl"
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"
538 if test "$sc_cv_have_openssl_ssl_h" = "yes"; then
539 AC_DEFINE(HAVE_OPENSSL_SSL_H)
541 AC_MSG_NOTICE(checked for openssl/ssl.h... $sc_cv_have_openssl_ssl_h)
543 fi # end checking for openssl/ssl.h
546 #if test -n "$WITH_OPENSSL"; then
547 # AC_CHECK_FUNCS(OPENSSL_init_ssl, SSL_library_init)
550 if test -n "$WITH_OPENSSL" -a "$sc_cv_have_openssl_ssl_h" = 'yes'; then
551 # next, we search for the openssl library (libssl.*)
552 # interesting: Linux only requires -lssl, FreeBSD requires -lssl -lcrypto
553 # Note, version OpenSSL 0.9.7j and higher requires -lcrypto even on Linux.
554 AC_MSG_CHECKING(for libssl)
555 AC_CACHE_VAL(sc_cv_have_libssl,
557 if test -n "$OPENSSL_BASE"; then
558 L="$OPENSSL_BASE/lib"; LIBS="$LIBS -L$L -lssl -lcrypto"
560 LIBS="$LIBS -lssl -lcrypto"
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'])
571 if test "$sc_cv_have_libssl" != 'yes'; then
576 if test "$sc_cv_have_libssl" = 'yes'; then
577 AC_DEFINE(HAVE_LIBSSL)
579 AC_MSG_RESULT($sc_cv_have_libssl)
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/")
589 # AC_CHECK_LIB(crypto, main)
590 # AC_CHECK_LIB(ssl, main)
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"
603 if test -n "$WITH_OPENSSL"; then
604 if test "$sc_cv_have_openssl_ssl_h" = "yes" -a "$sc_cv_have_libssl" = "yes"; then
605 AC_DEFINE(WITH_OPENSSL)
607 AC_MSG_WARN([not all components of OpenSSL found, disabling it]);
611 AC_CHECK_FUNCS(OPENSSL_init_ssl SSL_library_init)
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])])
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"])
623 if test -n "$WITH_OPENSSL"; then
624 AC_MSG_CHECKING(whether to include OpenSSL method option)
625 AC_ARG_ENABLE(openssl-method, [ --enable-openssl-method enable OpenSSL method option],
626 [case "$enableval" in
627 no) AC_MSG_RESULT(no);;
628 *) AC_DEFINE(WITH_OPENSSL_METHOD) WITH_OPENSSL_METHOD=1; AC_MSG_RESULT(yes);;
633 AC_MSG_CHECKING(whether to include deprecated resolver option)
634 AC_ARG_ENABLE(res-deprecated, [ --enable-res-deprecated enable deprecated resolver options],
635 [case "$enableval" in
636 no) AC_MSG_RESULT(no);;
637 *) AC_DEFINE(WITH_RES_DEPRECATED) WITH_RES_DEPRECATED=1; AC_MSG_RESULT(yes);;
641 # check for fips support
642 AC_MSG_CHECKING(whether to include openssl fips support)
643 AC_ARG_ENABLE(fips, [ --enable-fips enable OpenSSL FIPS support],
644 [ case "$enableval" in
645 yes) AC_MSG_RESULT(yes); WITH_FIPS=1 ;;
646 *) AC_MSG_RESULT(no); WITH_FIPS= ;;
648 [ AC_MSG_RESULT(no); WITH_FIPS= ])
650 if test -n "$WITH_FIPS"; then
651 if test -n "$WITH_OPENSSL"; then
652 AC_CHECK_PROG(HAVE_FIPSLD, fipsld, 1)
653 if test "$sc_cv_have_openssl_ssl_h" != "yes" -o "$sc_cv_have_libssl" != "yes" -o ! "$HAVE_FIPSLD";
655 AC_MSG_WARN([not all components of OpenSSL found, disabling FIPS]);
659 AC_MSG_WARN([must enable OpenSSL to enable FIPS; use --enable-openssl]);
663 if test -n "$WITH_FIPS"; then
664 AC_MSG_CHECKING(for components of OpenSSL FIPS)
665 # first, we need to find the include file <openssl/fips.h>
666 AC_CACHE_VAL(sc_cv_have_openssl_fips_h,
667 [AC_TRY_COMPILE([#define OPENSSL_FIPS
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;
683 if test "$sv_cv_have_openssl_fips_h" = "yes"; then
684 AC_DEFINE(HAVE_OPENSSL_FIPS_H)
686 AC_MSG_NOTICE(checked for openssl/fips.h... $sc_cv_have_openssl_ssl_h)
689 if test -n "$WITH_FIPS" -a "$sc_cv_have_openssl_fips_h" = 'yes'; then
690 # check for the libcrypto library with fips support
691 AC_MSG_CHECKING(for libcrypto with FIPS support)
692 AC_CACHE_VAL(sc_cv_have_libcrypto,
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"
699 LIBS="$LIBS -lcrypto"
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']
709 if test "$sc_cv_have_libcrypto" != 'yes'; then
714 if test "$sc_cv_have_libcrypto" = 'yes'; then
715 AC_DEFINE(HAVE_LIBCRYPTO)
717 AC_MSG_RESULT($sc_cv_have_libcrypto)
720 if test -n "$WITH_FIPS"; then
721 if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then
723 AC_DEFINE(OPENSSL_FIPS)
725 AC_MSG_WARN([not all components of OpenSSL FIPS found, disabling it]);
729 AC_MSG_CHECKING(whether to include tun/tap address support)
730 AC_ARG_ENABLE(tun, [ --disable-tun disable TUN/TAP support],
731 [case "$enableval" in
732 no) AC_MSG_RESULT(no); WITH_TUN= ;;
733 *) AC_MSG_RESULT(yes); WITH_TUN=1 ;;
735 [AC_MSG_RESULT(yes); WITH_TUN=1 ])
738 if ! test "$ac_cv_header_linux_if_tun_h" = 'yes'; then
739 AC_MSG_WARN(include file linux/if_tun.h not found, disabling TUN)
743 if test -n "$WITH_TUN"; then
747 AC_MSG_CHECKING(whether to include system call tracing)
748 AC_ARG_ENABLE(sycls, [ --disable-sycls disable system call tracing],
749 [case "$enableval" in
750 no) SYCLS=""; SSLCLS=""; AC_MSG_RESULT(no);;
751 *) AC_DEFINE(WITH_SYCLS)
752 SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes);;
754 [AC_DEFINE(WITH_SYCLS)
755 SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes)])
759 AC_MSG_CHECKING(whether to include file descriptor analyzer)
760 AC_ARG_ENABLE(filan, [ --disable-filan disable file descriptor analyzer],
761 [case "$enableval" in
762 no) FILAN=""; AC_MSG_RESULT(no);;
763 *) AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes);;
765 [AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes)])
768 AC_MSG_CHECKING(whether to include retry support)
769 AC_ARG_ENABLE(retry, [ --disable-retry disable retry support],
770 [case "$enableval" in
771 no) AC_MSG_RESULT(no);;
772 *) AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes);;
774 [AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes)])
776 AC_MSG_CHECKING(included message level)
777 AC_ARG_ENABLE(msglevel, [ --enable-msglevel=N set max verbosity to debug,info,notice,warn,error,fatal],
778 [case "$enableval" in
779 0|DEBUG|Debug|debug) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;
780 1|INFO|Info|info) AC_DEFINE(WITH_MSGLEVEL,1) AC_MSG_RESULT(info);;
781 2|NOTICE|Notice|notice) AC_DEFINE(WITH_MSGLEVEL,2) AC_MSG_RESULT(notice);;
782 3|WARN|Warn|warn) AC_DEFINE(WITH_MSGLEVEL,3) AC_MSG_RESULT(warn);;
783 4|ERROR|Error|error) AC_DEFINE(WITH_MSGLEVEL,4) AC_MSG_RESULT(error);;
784 5|FATAL|Fatal|fatal) AC_DEFINE(WITH_MSGLEVEL,5) AC_MSG_RESULT(fatal);;
785 *) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;
787 [AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug)])
791 dnl Checks for typedefs, structures, and compiler characteristics.
803 dnl Check for extra realtime library (for Solaris)
804 AC_CHECK_FUNC(nanosleep, AC_DEFINE(HAVE_NANOSLEEP), AC_CHECK_LIB(rt, nanosleep, [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_NANOSLEEP)]))
805 #AC_CHECK_FUNC(nanosleep, , AC_CHECK_LIB(rt, nanosleep))
807 dnl Checks for library functions.
808 AC_PROG_GCC_TRADITIONAL
812 AC_CHECK_FUNCS(putenv select pselect poll socket strtod strtol)
813 AC_CHECK_FUNCS(strtoul uname getpgid getsid gethostbyname getaddrinfo)
814 AC_CHECK_FUNCS(getprotobynumber getprotobynumber_r)
815 AC_CHECK_FUNCS(setgroups inet_aton)
817 AC_CHECK_FUNCS(grantpt unlockpt)
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
822 dnl Search for cfsetispeed(),cfgetispeed(),cfsetspeed(),cfgetospeed() functions
823 AC_CHECK_FUNCS(cfsetispeed cfgetispeed cfsetospeed cfgetospeed)
825 ###################################
826 # check for prototype and existence of functions that return a pointer
827 # defines in config.h: HAVE_PROTOTYPE_LIB_$1
828 AC_CHECK_PROTOTYPE_LIB(posix_memalign)
829 AC_CHECK_PROTOTYPE_LIB(strdup)
830 AC_CHECK_PROTOTYPE_LIB(strerror)
831 AC_CHECK_PROTOTYPE_LIB(strstr)
832 AC_CHECK_PROTOTYPE_LIB(getipnodebyname)
833 AC_CHECK_PROTOTYPE_LIB(strndup)
834 AC_CHECK_PROTOTYPE_LIB(memrchr)
835 AC_CHECK_PROTOTYPE_LIB(if_indextoname)
836 AC_CHECK_PROTOTYPE_LIB(ptsname)
838 AC_MSG_CHECKING(for long long)
839 AC_CACHE_VAL(sc_cv_type_longlong,
840 [AC_TRY_COMPILE([],[long long s;],
841 [sc_cv_type_longlong=yes],
842 [sc_cv_type_longlong=no])])
843 if test $sc_cv_type_longlong = yes; then
844 AC_DEFINE(HAVE_TYPE_LONGLONG)
846 AC_MSG_RESULT($sc_cv_type_longlong)
848 AC_CHECK_TYPE(sig_atomic_t,AC_DEFINE(HAVE_TYPE_SIG_ATOMIC_T),,[#include "sysincludes.h"])
850 AC_MSG_CHECKING(for bool)
851 AC_CACHE_VAL(sc_cv_type_bool,
852 [AC_TRY_COMPILE([#ifdef HAVE_STDBOOL_H
856 [sc_cv_type_bool=yes],
857 [sc_cv_type_bool=no])])
858 if test $sc_cv_type_bool = yes; then
859 AC_DEFINE(HAVE_TYPE_BOOL)
861 AC_MSG_RESULT($sc_cv_type_bool)
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)
867 AC_MSG_CHECKING(for socklen_t)
868 AC_CACHE_VAL(sc_cv_type_socklen,
869 [AC_TRY_COMPILE([#include <sys/types.h>
870 #include <sys/socket.h>
871 #include <unistd.h>],[socklen_t s;],
872 [sc_cv_type_socklen=yes],
873 [sc_cv_type_socklen=no])])
874 if test $sc_cv_type_socklen = yes; then
875 AC_DEFINE(HAVE_TYPE_SOCKLEN)
877 AC_MSG_RESULT($sc_cv_type_socklen)
879 AC_MSG_CHECKING(for struct stat64)
880 AC_CACHE_VAL(sc_cv_type_stat64,
881 [AC_TRY_COMPILE([#include <sys/stat.h>],[struct stat64 s;],
882 [sc_cv_type_stat64=yes],
883 [sc_cv_type_stat64=no])])
884 if test $sc_cv_type_stat64 = yes; then
885 AC_DEFINE(HAVE_TYPE_STAT64)
887 AC_MSG_RESULT($sc_cv_type_stat64)
889 AC_MSG_CHECKING(for off64_t)
890 AC_CACHE_VAL(sc_cv_type_off64,
891 [AC_TRY_COMPILE([#include <unistd.h>],[off64_t s;],
892 [sc_cv_type_off64=yes],
893 [sc_cv_type_off64=no])])
894 if test $sc_cv_type_off64 = yes; then
895 AC_DEFINE(HAVE_TYPE_OFF64)
897 AC_MSG_RESULT($sc_cv_type_off64)
899 AC_MSG_CHECKING(for sighandler_t)
900 AC_CACHE_VAL(sc_cv_type_sighandler,
901 [AC_TRY_COMPILE([#include <signal.h>],[sighandler_t s;],
902 [sc_cv_type_sighandler=yes],
903 [sc_cv_type_sighandler=no])])
904 if test $sc_cv_type_sighandler = yes; then
905 AC_DEFINE(HAVE_TYPE_SIGHANDLER)
907 AC_MSG_RESULT($sc_cv_type_socklen)
909 AC_MSG_CHECKING(for uint8_t)
910 AC_CACHE_VAL(sc_cv_type_uint8,
911 [AC_TRY_COMPILE([#include <sys/types.h>
915 /* Tru64 has uint8_t etc from netdb.h */
919 #include <unistd.h>],[uint8_t s;],
920 [sc_cv_type_uint8=yes],
921 [sc_cv_type_uint8=no])])
922 if test $sc_cv_type_uint8 = yes; then
923 AC_DEFINE(HAVE_TYPE_UINT8)
925 AC_MSG_RESULT($sc_cv_type_uint8)
927 AC_MSG_CHECKING(for uint16_t)
928 AC_CACHE_VAL(sc_cv_type_uint16,
929 [AC_TRY_COMPILE([#include <sys/types.h>
933 /* Tru64 has uint16_t etc from netdb.h */
937 #include <unistd.h>],[uint16_t s;],
938 [sc_cv_type_uint16=yes],
939 [sc_cv_type_uint16=no])])
940 if test $sc_cv_type_uint16 = yes; then
941 AC_DEFINE(HAVE_TYPE_UINT16)
943 AC_MSG_RESULT($sc_cv_type_uint16)
945 AC_MSG_CHECKING(for uint32_t)
946 AC_CACHE_VAL(sc_cv_type_uint32,
947 [AC_TRY_COMPILE([#include <sys/types.h>
951 /* Tru64 has uint32_t etc from netdb.h */
955 #include <unistd.h>],[uint32_t s;],
956 [sc_cv_type_uint32=yes],
957 [sc_cv_type_uint32=no])])
958 if test $sc_cv_type_uint32 = yes; then
959 AC_DEFINE(HAVE_TYPE_UINT32)
961 AC_MSG_RESULT($sc_cv_type_uint32)
963 AC_MSG_CHECKING(for uint64_t)
964 AC_CACHE_VAL(sc_cv_type_uint64,
965 [AC_TRY_COMPILE([#include <sys/types.h>
969 /* Tru64 has uint32_t etc from netdb.h */
973 #include <unistd.h>],[uint64_t s;],
974 [sc_cv_type_uint64=yes],
975 [sc_cv_type_uint64=no])])
976 if test $sc_cv_type_uint64 = yes; then
977 AC_DEFINE(HAVE_TYPE_UINT64)
979 AC_MSG_RESULT($sc_cv_type_uint64)
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>],
987 #[AC_MSG_RESULT(no)],
988 #[AC_MSG_RESULT(required); AC_DEFINE(_XOPEN_EXTENDED_SOURCE)])
992 AC_MSG_CHECKING(for fdset->fds_bits)
993 AC_TRY_COMPILE([#include <sys/types.h>
994 #if HAVE_SYS_SELECT_H
995 #include <sys/select.h>
997 [fd_set s; s.fds_bits[0]=0;],
998 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_FDS_BITS)],
999 [AC_MSG_RESULT(no);])
1001 AC_MSG_CHECKING(for struct termios . c_ispeed)
1002 AC_TRY_COMPILE([#include <unistd.h>
1004 #include <termios.h>
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);])
1010 AC_MSG_CHECKING(for struct termios . c_ospeed)
1011 AC_TRY_COMPILE([#include <unistd.h>
1013 #include <termios.h>
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);])
1019 AC_MSG_CHECKING(for sa_family_t)
1020 AC_CACHE_VAL(sc_cv_type_sa_family_t,
1021 [AC_TRY_COMPILE([#include <sys/types.h>
1022 #include <sys/socket.h>
1023 #include <netinet/in.h>],[sa_family_t s;],
1024 [sc_cv_type_sa_family_t=yes],
1025 [sc_cv_type_sa_family_t=no])])
1026 if test $sc_cv_type_sa_family_t = yes; then
1027 AC_DEFINE(HAVE_TYPE_SA_FAMILY_T)
1029 AC_MSG_RESULT($sc_cv_type_sa_family_t)
1031 AC_MSG_CHECKING(for struct sock_extended_err)
1032 AC_CACHE_VAL(sc_cv_struct_sock_extended_err,
1033 [AC_TRY_COMPILE([#include <linux/types.h>
1034 #if TIME_WITH_SYS_TIME
1035 #include <sys/time.h>
1037 #if HAVE_LINUX_ERRQUEUE_H
1038 #include <linux/errqueue.h>
1039 #endif],[struct sock_extended_err s;],
1040 [sc_cv_struct_sock_extended_err=yes],
1041 [sc_cv_struct_sock_extended_err=no])])
1042 if test $sc_cv_struct_sock_extended_err = yes; then
1043 AC_DEFINE(HAVE_STRUCT_SOCK_EXTENDED_ERR)
1045 AC_MSG_RESULT($sc_cv_struct_sock_extended_err)
1047 AC_MSG_CHECKING(for struct sigaction.sa_sigaction)
1048 AC_CACHE_VAL(sc_cv_struct_sigaction_sa_sigaction,
1049 [AC_TRY_COMPILE([#include <signal.h>],[struct sigaction s;s.sa_sigaction=0;],
1050 [sc_cv_struct_sigaction_sa_sigaction=yes],
1051 [sc_cv_struct_sigaction_sa_sigaction=no])])
1052 if test $sc_cv_struct_sigaction_sa_sigaction = yes; then
1053 AC_DEFINE(HAVE_STRUCT_SIGACTION_SA_SIGACTION)
1055 AC_MSG_RESULT($sc_cv_struct_sigaction_sa_sigaction)
1057 # there is another issue with termios: OSR requires "#define _SVID3 ..."
1058 # for reasonable termios support. We check this situation using IMAXBEL
1059 AC_MSG_CHECKING(if _SVID3 is helpful)
1060 AC_CACHE_VAL(ac_cv_svid3,
1061 [AC_TRY_COMPILE([#include <termios.h>],
1064 [AC_TRY_COMPILE([#define _SVID3 1
1065 #include <termios.h>],
1071 if test $ac_cv_svid3 = yes; then
1074 AC_MSG_RESULT($ac_cv_svid3)
1077 # Openindiana needs _XPG4_2 for CMSG stuff
1078 AC_MSG_CHECKING(if _XPG4_2 is helpful)
1079 AC_CACHE_VAL(ac_cv_xpg4_2,
1080 [AC_TRY_LINK([#include <sys/socket.h>],
1081 [int i=CMSG_DATA(0)],
1083 [AC_TRY_LINK([#define _XPG4_2 1
1084 #include <sys/socket.h>],
1085 [int i=CMSG_DATA(0)],
1090 if test $ac_cv_xpg4_2 = yes; then
1093 AC_MSG_RESULT($ac_cv_xpg4_2)
1095 # When on Openindiana _XPG4_2 is defined (see above)
1096 # we also need to define __EXTENSIONS__ for basic stuff.
1097 # Note that <sys/procset.h> is important on Openindiana
1098 # but does not exist on Linux
1099 if test "$ac_cv_xpg4_2" = yes; then
1100 AC_MSG_CHECKING(if __EXTENSIONS__ is helpful)
1101 AC_CACHE_VAL(ac_cv___extensions__,
1102 [AC_TRY_COMPILE([#include <sys/procset.h>],
1104 [ac_cv___extensions__=no],
1105 [AC_TRY_COMPILE([#define __EXTENSIONS__ 1
1106 #include <sys/procset.h>],
1108 [ac_cv___extensions__=yes],
1109 [ac_cv___extensions__=no]
1112 if test $ac_cv___extensions__ = yes; then
1113 AC_DEFINE(__EXTENSIONS__)
1115 AC_MSG_RESULT($ac_cv___extensions__)
1118 # When on Openindiana __EXTENSIONS__ is defined (see above)
1119 # _POSIX_PTHREAD_SEMANTICS must be defined for standard ctime_r()
1120 if test "$ac_cv___extensions__" = yes; then
1121 AC_MSG_CHECKING(if _POSIX_PTHREAD_SEMANTICS is helpful)
1122 AC_CACHE_VAL(ac_cv__posix_pthread_semantics,
1123 [AC_TRY_COMPILE([#include <time.h>],
1124 [char *s = ctime_r(0,0);],
1125 [ac_cv__posix_pthread_semantics=no],
1126 [AC_TRY_COMPILE([#define _POSIX_PTHREAD_SEMANTICS 1
1128 [char *s = ctime_r(0,0);],
1129 [ac_cv__posix_pthread_semantics=yes],
1130 [ac_cv__posix_pthread_semantics=no]
1133 if test $ac_cv__posix_pthread_semantics = yes; then
1134 AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
1136 AC_MSG_RESULT($ac_cv__posix_pthread_semantics)
1141 AC_MSG_CHECKING(for struct timespec)
1142 AC_CACHE_VAL(sc_cv_struct_timespec,
1143 [AC_TRY_COMPILE([#include <time.h>
1145 #include <sys/time.h>
1146 #endif],[struct timespec s;],
1147 [sc_cv_struct_timespec=yes],
1148 [sc_cv_struct_timespec=no])])
1149 if test $sc_cv_struct_timespec = yes; then
1150 AC_DEFINE(HAVE_STRUCT_TIMESPEC)
1152 AC_MSG_RESULT($sc_cv_struct_timespec)
1155 # struct linger; FreeBSD requires sys/types.h for sys/socket.h
1156 AC_MSG_CHECKING(for struct linger)
1157 AC_CACHE_VAL(sc_cv_struct_linger,
1158 [AC_TRY_COMPILE([#include <sys/types.h>
1159 #include <sys/socket.h>],[struct linger s;],
1160 [sc_cv_struct_linger=yes],
1161 [sc_cv_struct_linger=no])])
1162 if test $sc_cv_struct_linger = yes; then
1163 AC_DEFINE(HAVE_STRUCT_LINGER)
1165 AC_MSG_RESULT($sc_cv_struct_linger)
1168 # struct ip (for IPv4 header info)
1169 AC_MSG_CHECKING(for struct ip)
1170 AC_CACHE_VAL(sc_cv_struct_ip,
1171 [AC_TRY_COMPILE([#include <netinet/in.h>
1172 #include <netinet/ip.h>],[struct ip s;],
1173 [sc_cv_struct_ip=yes],
1174 [sc_cv_struct_ip=no])])
1175 if test $sc_cv_struct_ip = yes; then
1176 AC_DEFINE(HAVE_STRUCT_IP)
1178 AC_MSG_RESULT($sc_cv_struct_ip)
1180 # struct ip_mreq (for multicasting options)
1181 AC_MSG_CHECKING(for struct ip_mreq)
1182 AC_CACHE_VAL(sc_cv_struct_ip_mreq,
1183 [AC_TRY_COMPILE([#include <sys/types.h>
1184 #include <sys/socket.h>
1185 #include <netinet/in.h>],[struct ip_mreq s;],
1186 [sc_cv_struct_ip_mreq=yes],
1187 [sc_cv_struct_ip_mreq=no])])
1188 if test $sc_cv_struct_ip_mreq = yes; then
1189 AC_DEFINE(HAVE_STRUCT_IP_MREQ)
1191 AC_MSG_RESULT($sc_cv_struct_ip_mreq)
1193 # struct ip_mreqn (for multicasting options)
1194 AC_MSG_CHECKING(for struct ip_mreqn)
1195 AC_CACHE_VAL(sc_cv_struct_ip_mreqn,
1196 [AC_TRY_COMPILE([#include <sys/types.h>
1197 #include <sys/socket.h>
1198 #include <netinet/in.h>
1199 #include <netinet/ip.h>],[struct ip_mreqn s;],
1200 [sc_cv_struct_ip_mreqn=yes],
1201 [sc_cv_struct_ip_mreqn=no])])
1202 if test $sc_cv_struct_ip_mreqn = yes; then
1203 AC_DEFINE(HAVE_STRUCT_IP_MREQN)
1205 AC_MSG_RESULT($sc_cv_struct_ip_mreqn)
1207 # struct ipv6_mreq (for multicasting options)
1208 AC_MSG_CHECKING(for struct ipv6_mreq)
1209 AC_CACHE_VAL(sc_cv_struct_ipv6_mreq,
1210 [AC_TRY_COMPILE([#include <sys/types.h>
1211 #include <sys/socket.h>
1212 #include <netinet/in.h>],[struct ipv6_mreq s;],
1213 [sc_cv_struct_ipv6_mreq=yes],
1214 [sc_cv_struct_ipv6_mreq=no])])
1215 if test $sc_cv_struct_ipv6_mreq = yes; then
1216 AC_DEFINE(HAVE_STRUCT_IPV6_MREQ)
1218 AC_MSG_RESULT($sc_cv_struct_ipv6_mreq)
1220 # struct ip_mreq_source (for multicasting options)
1221 AC_MSG_CHECKING(for struct ip_mreq_source)
1222 AC_CACHE_VAL(sc_cv_struct_ip_mreq_source,
1223 [AC_TRY_COMPILE([#include <sys/types.h>
1224 #include <sys/socket.h>
1225 #include <netinet/in.h>
1226 #include <netinet/ip.h>],[struct ip_mreq_source s;],
1227 [sc_cv_struct_ip_mreq_source=yes],
1228 [sc_cv_struct_ip_mreq_source=no])])
1229 if test $sc_cv_struct_ip_mreq_source = yes; then
1230 AC_DEFINE(HAVE_STRUCT_IP_MREQ_SOURCE)
1232 AC_MSG_RESULT($sc_cv_struct_ip_mreqn)
1235 # struct ifreq (for network interfaces)
1236 AC_MSG_CHECKING(for struct ifreq)
1237 AC_CACHE_VAL(sc_cv_struct_ifreq,
1238 [AC_TRY_COMPILE([#include <sys/types.h>
1239 #include <sys/socket.h>
1240 #include <net/if.h>],[struct ifreq s;],
1241 [sc_cv_struct_ifreq=yes],
1242 [sc_cv_struct_ifreq=no])])
1243 if test $sc_cv_struct_ifreq = yes; then
1244 AC_DEFINE(HAVE_STRUCT_IFREQ)
1246 AC_MSG_RESULT($sc_cv_struct_ifreq)
1248 # struct ifreq.ifr_index
1249 # on most systems that have struct ifreq
1250 AC_MSG_CHECKING(for struct ifreq.ifr_index)
1251 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_index,
1252 [AC_TRY_COMPILE([#include <sys/types.h>
1253 #include <sys/socket.h>
1254 #include <net/if.h>],
1255 [struct ifreq ir;ir.ifr_index=0;],
1256 [sc_cv_struct_ifreq_ifr_index=yes],
1257 [sc_cv_struct_ifreq_ifr_index=no])])
1258 if test $sc_cv_struct_ifreq_ifr_index = yes; then
1259 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_INDEX)
1261 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_index)
1263 # struct ifreq.ifr_ifindex
1264 # Linux has ifr_ifindex instead of ifr_index
1265 AC_MSG_CHECKING(for struct ifreq.ifr_ifindex)
1266 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_ifindex,
1267 [AC_TRY_COMPILE([#include <sys/types.h>
1268 #include <sys/socket.h>
1269 #include <net/if.h>],
1270 [struct ifreq ir;ir.ifr_ifindex=0;],
1271 [sc_cv_struct_ifreq_ifr_ifindex=yes],
1272 [sc_cv_struct_ifreq_ifr_ifindex=no])])
1273 if test $sc_cv_struct_ifreq_ifr_ifindex = yes; then
1274 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_IFINDEX)
1276 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_ifindex)
1279 # some systems have a sa_len field in struct sockaddr and we need to support it
1280 # so we can compare sockaddrs simply with memcmp
1281 AC_MSG_CHECKING(for struct sockaddr.sa_len)
1282 AC_CACHE_VAL(sc_cv_struct_sockaddr_salen,
1283 [AC_TRY_COMPILE([#include <sys/types.h>
1284 #include <sys/socket.h>],
1285 [struct sockaddr sa;sa.sa_len=0;],
1286 [sc_cv_struct_sockaddr_salen=yes],
1287 [sc_cv_struct_sockaddr_salen=no])])
1288 if test $sc_cv_struct_sockaddr_salen = yes; then
1289 AC_DEFINE(HAVE_STRUCT_SOCKADDR_SALEN)
1291 AC_MSG_RESULT($sc_cv_struct_sockaddr_salen)
1293 ### IP6 sockaddr_in6
1295 AC_MSG_CHECKING(for component names of sockaddr_in6)
1296 AC_TRY_COMPILE([#include <sys/types.h>
1297 #include <netinet/in.h>],
1298 [struct sockaddr_in6 sa6;sa6.sin6_addr.s6_addr[0]=0;],
1299 [AC_MSG_RESULT(s6_addr);
1300 AC_DEFINE(HAVE_IP6_SOCKADDR, 0)],
1301 [AC_TRY_COMPILE([#include <sys/types.h>
1302 #include <netinet/in.h>],
1303 [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr.u6_addr16[0]=0;],
1304 [AC_MSG_RESULT(u6_addr.u6_addr16);
1305 AC_DEFINE(HAVE_IP6_SOCKADDR, 1)],
1306 [AC_TRY_COMPILE([#include <sys/types.h>
1307 #include <netinet/in.h>],
1308 [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr16[0]=0;],
1309 [AC_MSG_RESULT(u6_addr16); AC_DEFINE(HAVE_IP6_SOCKADDR, 2)],
1310 [AC_TRY_COMPILE([#include <sys/types.h>
1311 #include <netinet/in.h>],
1312 [struct sockaddr_in6 sa6;sa6.sin6_addr.in6_u.u6_addr16[0]=0;],
1313 [AC_MSG_RESULT(in6_u.u6_addr16);
1314 AC_DEFINE(HAVE_IP6_SOCKADDR, 3)],
1315 [AC_TRY_COMPILE([#include <sys/types.h>
1316 #include <netinet/in.h>],
1317 [struct sockaddr_in6 sa6;sa6.sin6_addr._S6_un._S6_u32[0]=0;],
1318 [AC_MSG_RESULT(_S6_un._S6_u32);
1319 AC_DEFINE(HAVE_IP6_SOCKADDR, 4)],
1320 [AC_TRY_COMPILE([#include <sys/types.h>
1321 #include <netinet/in.h>],
1322 [struct sockaddr_in6 sa6;sa6.sin6_addr.__u6_addr.__u6_addr32[0]=0;],
1323 [AC_MSG_RESULT(__u6_addr.__u6_addr32);
1324 AC_DEFINE(HAVE_IP6_SOCKADDR, 5)],
1326 [AC_MSG_RESULT([none or unknown])]
1329 dnl Check for struct iovec
1330 AC_MSG_CHECKING(for struct iovec)
1331 AC_CACHE_VAL(sc_cv_struct_iovec,
1332 [AC_TRY_COMPILE([#include <sys/uio.h>],[struct iovec s;],
1333 [sc_cv_struct_iovec=yes],
1334 [sc_cv_struct_iovec=no])])
1335 if test $sc_cv_struct_iovec = yes; then
1336 AC_DEFINE(HAVE_STRUCT_IOVEC)
1338 AC_MSG_RESULT($sc_cv_struct_iovec)
1340 dnl check for msg_control in struct msghdr
1341 AC_MSG_CHECKING(for struct msghdr.msg_control)
1342 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrol,
1343 [AC_TRY_COMPILE([#include <sys/types.h>
1344 #include <sys/socket.h>],
1345 [struct msghdr s;s.msg_control=0;],
1346 [sc_cv_struct_msghdr_msgcontrol=yes],
1347 [sc_cv_struct_msghdr_msgcontrol=no])])
1348 if test $sc_cv_struct_msghdr_msgcontrol = yes; then
1349 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROL)
1351 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrol)
1353 dnl check for msg_controllen in struct msghdr
1354 AC_MSG_CHECKING(for struct msghdr.msg_controllen)
1355 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrollen,
1356 [AC_TRY_COMPILE([#include <sys/types.h>
1357 #include <sys/socket.h>],
1358 [struct msghdr s;s.msg_controllen=0;],
1359 [sc_cv_struct_msghdr_msgcontrollen=yes],
1360 [sc_cv_struct_msghdr_msgcontrollen=no])])
1361 if test $sc_cv_struct_msghdr_msgcontrollen = yes; then
1362 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN)
1364 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrollen)
1366 dnl check for msg_flags in struct msghdr
1367 AC_MSG_CHECKING(for struct msghdr.msgflags)
1368 AC_CACHE_VAL(sc_cv_struct_msghdr_msgflags,
1369 [AC_TRY_COMPILE([#include <sys/types.h>
1370 #include <sys/socket.h>],
1371 [struct msghdr s;s.msg_flags=0;],
1372 [sc_cv_struct_msghdr_msgflags=yes],
1373 [sc_cv_struct_msghdr_msgflags=no])])
1374 if test $sc_cv_struct_msghdr_msgflags = yes; then
1375 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGFLAGS)
1377 AC_MSG_RESULT($sc_cv_struct_msghdr_msgflags)
1379 dnl check for struct cmsghdr
1380 AC_MSG_CHECKING(for struct cmsghdr)
1381 AC_CACHE_VAL(sc_cv_struct_cmsghdr,
1382 [AC_TRY_COMPILE([#include <sys/types.h>
1383 #include <sys/socket.h>
1384 #include <net/if.h>],[struct cmsghdr s;],
1385 [sc_cv_struct_cmsghdr=yes],
1386 [sc_cv_struct_cmsghdr=no])])
1387 if test $sc_cv_struct_cmsghdr = yes; then
1388 AC_DEFINE(HAVE_STRUCT_CMSGHDR)
1390 AC_MSG_RESULT($sc_cv_struct_cmsghdr)
1392 dnl check for struct in_pktinfo
1393 AC_MSG_CHECKING(for struct in_pktinfo)
1394 AC_CACHE_VAL(sc_cv_struct_in_pktinfo,
1395 [AC_TRY_COMPILE([#include <sys/types.h>
1396 #include <sys/socket.h>
1397 #include <netinet/in.h>],[struct in_pktinfo s;],
1398 [sc_cv_struct_in_pktinfo=yes],
1399 [sc_cv_struct_in_pktinfo=no])])
1400 if test $sc_cv_struct_in_pktinfo = yes; then
1401 AC_DEFINE(HAVE_STRUCT_IN_PKTINFO)
1403 AC_MSG_RESULT($sc_cv_struct_in_pktinfo)
1405 if test $sc_cv_struct_in_pktinfo = 'yes'; then
1406 dnl check for component ipi_spec_dst in struct in_pktinfo
1407 AC_MSG_CHECKING(for ipi_spec_dst in struct in_pktinfo)
1408 AC_CACHE_VAL(sc_cv_pktinfo_ipi_spec_dst,
1409 [AC_TRY_COMPILE([#include <sys/types.h>
1410 #include <sys/socket.h>
1411 #include <netinet/in.h>],[struct in_pktinfo s; s.ipi_spec_dst],
1412 [sc_cv_pktinfo_ipi_spec_dst=yes],
1413 [sc_cv_pktinfo_ipi_spec_dst=no])])
1414 if test $sc_cv_pktinfo_ipi_spec_dst = yes; then
1415 AC_DEFINE(HAVE_PKTINFO_IPI_SPEC_DST)
1417 AC_MSG_RESULT($sc_cv_pktinfo_ipi_spec_dst)
1420 dnl check for struct in6_pktinfo
1421 AC_MSG_CHECKING(for struct in6_pktinfo)
1422 AC_CACHE_VAL(sc_cv_struct_in6_pktinfo,
1423 [AC_TRY_COMPILE([#include "sysincludes.h"],
1424 [struct in6_pktinfo s;],
1425 [sc_cv_struct_in6_pktinfo=yes],
1426 [sc_cv_struct_in6_pktinfo=no])])
1427 if test $sc_cv_struct_in6_pktinfo = yes; then
1428 AC_DEFINE(HAVE_STRUCT_IN6_PKTINFO)
1430 AC_MSG_RESULT($sc_cv_struct_in6_pktinfo)
1432 dnl check for ip_hl in struct ip
1433 AC_MSG_CHECKING(for struct ip.ip_hl)
1434 AC_CACHE_VAL(sc_cv_struct_ip_ip_hl,
1435 [AC_TRY_COMPILE([#include <sys/types.h>
1436 #include <netinet/in_systm.h>
1437 #include <netinet/in.h>
1438 #include <netinet/ip.h>],
1439 [struct ip s;s.ip_hl=0;],
1440 [sc_cv_struct_ip_ip_hl=yes],
1441 [sc_cv_struct_ip_ip_hl=no])])
1442 if test $sc_cv_struct_ip_ip_hl = yes; then
1443 AC_DEFINE(HAVE_STRUCT_IP_IP_HL)
1445 AC_MSG_RESULT($sc_cv_struct_ip_ip_hl)
1448 dnl Library function checks
1450 dnl Check sigaction()
1451 AC_CHECK_FUNC(sigaction, AC_DEFINE(HAVE_SIGACTION))
1453 dnl Check for 64bit versions of system calls
1454 AC_CHECK_FUNC(stat64, AC_DEFINE(HAVE_STAT64))
1455 AC_CHECK_FUNC(fstat64, AC_DEFINE(HAVE_FSTAT64))
1456 AC_CHECK_FUNC(lstat64, AC_DEFINE(HAVE_LSTAT64))
1457 AC_CHECK_FUNC(lseek64, AC_DEFINE(HAVE_LSEEK64))
1458 AC_CHECK_FUNC(truncate64, AC_DEFINE(HAVE_TRUNCATE64))
1459 AC_CHECK_FUNC(ftruncate64, AC_DEFINE(HAVE_FTRUNCATE64))
1461 AC_CHECK_FUNC(strtoll, AC_DEFINE(HAVE_STRTOLL))
1462 AC_CHECK_FUNC(hstrerror, AC_DEFINE(HAVE_HSTRERROR))
1463 AC_CHECK_FUNC(inet_ntop, AC_DEFINE(HAVE_INET_NTOP))
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>],
1470 # [ac_cv_xopen_source_extended=no],
1471 # [AC_TRY_COMPILE([#define _XOPEN_SOURCE_EXTENDED 1
1472 ## include <netdb.h>],
1474 # [ac_cv_xopen_source_extended=yes],
1475 # [ac_cv_xopen_source_extended=no]
1478 # if test $ac_cv_xopen_source_extended = yes; then
1479 # AC_DEFINE(_XOPEN_SOURCE_EXTENDED)
1481 # AC_MSG_RESULT($ac_cv_xopen_source_extended)
1484 dnl Search for openpty()
1486 AC_CHECK_FUNC(openpty, AC_DEFINE(HAVE_OPENPTY))
1488 AC_CHECK_LIB(bsd, openpty,
1489 [LIBS="-lbsd $LIBS"; AC_DEFINE(HAVE_OPENPTY)])
1491 AC_CHECK_LIB(util, openpty,
1492 [LIBS="-lutil $LIBS"; AC_DEFINE(HAVE_OPENPTY)])
1494 AC_CHECK_LIB(rt, clock_gettime,
1495 [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_CLOCK_GETTIME)])
1497 dnl Search for flock()
1498 # with Linux it's in libc, with AIX in libbsd
1499 AC_CHECK_FUNC(flock, AC_DEFINE(HAVE_FLOCK),
1500 AC_CHECK_LIB(bsd, flock, [LIBS="-lbsd $LIBS"]))
1502 dnl Search for setenv()
1503 AC_CHECK_FUNC(setenv, AC_DEFINE(HAVE_SETENV),
1504 AC_CHECK_LIB(isode, setenv, [LIBS="-lisode $LIBS"]))
1506 dnl Search for unsetenv()
1507 AC_CHECK_FUNC(unsetenv, AC_DEFINE(HAVE_UNSETENV))
1509 AC_CHECK_FUNC(TLS_client_method, AC_DEFINE(HAVE_TLS_client_method) ac_cv_have_tls_client_method=yes, AC_CHECK_LIB(crypt, TLS_client_method, [LIBS=-lcrypt $LIBS]))
1510 AC_CHECK_FUNC(TLS_server_method, AC_DEFINE(HAVE_TLS_server_method) ac_cv_have_tls_server_method=yes, AC_CHECK_LIB(crypt, TLS_server_method, [LIBS=-lcrypt $LIBS]))
1511 AC_CHECK_FUNC(DTLS_client_method, AC_DEFINE(HAVE_DTLS_client_method), AC_CHECK_LIB(crypt, DTLS_client_method, [LIBS=-lcrypt $LIBS]))
1512 AC_CHECK_FUNC(DTLS_server_method, AC_DEFINE(HAVE_DTLS_server_method), AC_CHECK_LIB(crypt, DTLS_server_method, [LIBS=-lcrypt $LIBS]))
1513 if test -n "$WITH_OPENSSL_METHOD" -o -z "$ac_cv_have_tls_client_method" -o -z "$ac_cv_have_tls_server_method" ; then
1514 dnl Search for SSLv2_client_method, SSLv2_server_method
1515 AC_CHECK_FUNC(SSLv2_client_method, AC_DEFINE(HAVE_SSLv2_client_method), AC_CHECK_LIB(crypt, SSLv2_client_method, [LIBS=-lcrypt $LIBS]))
1516 AC_CHECK_FUNC(SSLv2_server_method, AC_DEFINE(HAVE_SSLv2_server_method), AC_CHECK_LIB(crypt, SSLv2_server_method, [LIBS=-lcrypt $LIBS]))
1518 AC_CHECK_FUNC(SSLv3_client_method, AC_DEFINE(HAVE_SSLv3_client_method), AC_CHECK_LIB(crypt, SSLv3_client_method, [LIBS=-lcrypt $LIBS]))
1519 AC_CHECK_FUNC(SSLv3_server_method, AC_DEFINE(HAVE_SSLv3_server_method), AC_CHECK_LIB(crypt, SSLv3_server_method, [LIBS=-lcrypt $LIBS]))
1520 AC_CHECK_FUNC(SSLv23_client_method, AC_DEFINE(HAVE_SSLv23_client_method), AC_CHECK_LIB(crypt, SSLv23_client_method, [LIBS=-lcrypt $LIBS]))
1521 AC_CHECK_FUNC(SSLv23_server_method, AC_DEFINE(HAVE_SSLv23_server_method), AC_CHECK_LIB(crypt, SSLv23_server_method, [LIBS=-lcrypt $LIBS]))
1522 AC_CHECK_FUNC(TLSv1_client_method, AC_DEFINE(HAVE_TLSv1_client_method), AC_CHECK_LIB(crypt, TLSv1_client_method, [LIBS=-lcrypt $LIBS]))
1523 AC_CHECK_FUNC(TLSv1_server_method, AC_DEFINE(HAVE_TLSv1_server_method), AC_CHECK_LIB(crypt, TLSv1_server_method, [LIBS=-lcrypt $LIBS]))
1524 AC_CHECK_FUNC(TLSv1_1_client_method, AC_DEFINE(HAVE_TLSv1_1_client_method), AC_CHECK_LIB(crypt, TLSv1_1_client_method, [LIBS=-lcrypt $LIBS]))
1525 AC_CHECK_FUNC(TLSv1_1_server_method, AC_DEFINE(HAVE_TLSv1_1_server_method), AC_CHECK_LIB(crypt, TLSv1_1_server_method, [LIBS=-lcrypt $LIBS]))
1526 AC_CHECK_FUNC(TLSv1_2_client_method, AC_DEFINE(HAVE_TLSv1_2_client_method), AC_CHECK_LIB(crypt, TLSv1_2_client_method, [LIBS=-lcrypt $LIBS]))
1527 AC_CHECK_FUNC(TLSv1_2_server_method, AC_DEFINE(HAVE_TLSv1_2_server_method), AC_CHECK_LIB(crypt, TLSv1_2_server_method, [LIBS=-lcrypt $LIBS]))
1528 AC_CHECK_FUNC(DTLSv1_client_method, AC_DEFINE(HAVE_DTLSv1_client_method), AC_CHECK_LIB(crypt, DTLSv1_client_method, [LIBS=-lcrypt $LIBS]))
1529 AC_CHECK_FUNC(DTLSv1_server_method, AC_DEFINE(HAVE_DTLSv1_server_method), AC_CHECK_LIB(crypt, DTLSv1_server_method, [LIBS=-lcrypt $LIBS]))
1530 AC_CHECK_FUNC(DTLSv1_2_client_method, AC_DEFINE(HAVE_DTLSv1_2_client_method), AC_CHECK_LIB(crypt, DTLSv1_2_client_method, [LIBS=-lcrypt $LIBS]))
1531 AC_CHECK_FUNC(DTLSv1_2_server_method, AC_DEFINE(HAVE_DTLSv1_2_server_method), AC_CHECK_LIB(crypt, DTLSv1_2_server_method, [LIBS=-lcrypt $LIBS]))
1532 fi # $WITH_OPENSSL_METHOD
1534 AC_CHECK_FUNC(SSL_CTX_set_default_verify_paths, AC_DEFINE(HAVE_SSL_CTX_set_default_verify_paths))
1535 AC_CHECK_FUNC(RAND_egd, AC_DEFINE(HAVE_RAND_egd), AC_CHECK_LIB(crypt, RAND_egd, [LIBS=-lcrypt $LIBS]))
1536 AC_CHECK_FUNC(DH_set0_pqg, AC_DEFINE(HAVE_DH_set0_pqg), AC_CHECK_LIB(crypt, DH_set0_pqg, [LIBS=-lcrypt $LIBS]))
1537 AC_CHECK_FUNC(ASN1_STRING_get0_data, AC_DEFINE(HAVE_ASN1_STRING_get0_data), AC_CHECK_LIB(crypt, ASN1_STRING_get0_data, [LIBS=-lcrypt $LIBS]))
1538 AC_CHECK_FUNC(RAND_status, AC_DEFINE(HAVE_RAND_status))
1539 AC_CHECK_FUNC(SSL_CTX_clear_mode, AC_DEFINE(HAVE_SSL_CTX_clear_mode))
1540 AC_CHECK_FUNC(SSL_set_tlsext_host_name, AC_DEFINE(HAVE_SSL_set_tlsext_host_name))
1541 AC_CHECK_FUNC(SSL_library_init, AC_DEFINE(HAVE_SSL_library_init))
1542 AC_CHECK_FUNC(ERR_error_string, AC_DEFINE(HAVE_ERR_error_string))
1544 AC_MSG_CHECKING(for type EC_KEY)
1545 AC_CACHE_VAL(sc_cv_type_EC_TYPE,
1546 [AC_TRY_COMPILE([#include <openssl/ec.h>
1548 [sc_cv_type_EC_KEY=yes],
1549 [sc_cv_type_EC_KEY=no])])
1550 if test $sc_cv_type_EC_KEY = yes; then
1551 AC_DEFINE(HAVE_TYPE_EC_KEY)
1553 AC_MSG_RESULT($sc_cv_type_EC_KEY)
1559 AC_MSG_CHECKING(if snprintf conforms to C99)
1560 AC_CACHE_VAL(ac_cv_have_c99_snprintf,
1566 exit(snprintf(s,2,"ab")!=2);
1568 [ac_cv_have_c99_snprintf=yes],
1569 [ac_cv_have_c99_snprintf=no],
1570 [ac_cv_have_c99_snprintf=no])])
1571 if test $ac_cv_have_c99_snprintf = yes; then
1572 AC_DEFINE(HAVE_C99_SNPRINTF)
1574 AC_MSG_RESULT($ac_cv_have_c99_snprintf)
1577 AC_MSG_CHECKING(if printf has Z modifier)
1578 AC_CACHE_VAL(ac_cv_have_z_modifier,
1579 if test "$cc" = gcc; then
1586 exit(strcmp(s,"1"));
1588 [ac_cv_have_z_modifier=yes],
1589 [ac_cv_have_z_modifier=no],
1590 [ac_cv_have_z_modifier=no])]
1591 else ac_cv_have_z_modifier=no
1594 if test $ac_cv_have_z_modifier = yes; then
1595 AC_DEFINE(HAVE_FORMAT_Z)
1597 AC_MSG_RESULT($ac_cv_have_z_modifier)
1600 dnl find the number of bits we must shift a value to match the given mask
1601 dnl (e.g., mask 0x00f0 requires shifting with 4)
1602 ## NOTE: some platforms only need one '\' to escape '"' in string constant
1603 define(AC_SHIFT_OFFSET,[
1604 AC_CACHE_CHECK(shift offset of $1, $2,
1605 [LIBS1="$LIBS"; LIBS="" # avoid libwrap allow_severity undefined
1606 conftestoffset="conftestoffset.out"
1611 #include <termios.h>
1614 unsigned int i,n=$1;
1616 if ((f=fopen("$conftestoffset","w"))==NULL){
1617 fprintf(stderr,"\\"$conftestoffset\\": %s\n",strerror(errno)); exit(-1);
1619 if (n==0) {fprintf(stderr,"$1 is 0 (impossible!)\n"); exit(1);}
1620 i=0; while (!(n&1)) {
1623 fprintf(f, "%u", i);
1625 fprintf(f, "-1"); /* anticipate result of xioinitialize assert */
1630 [$2=`cat $conftestoffset`],
1635 AC_DEFINE_UNQUOTED($1_SHIFT, ${$2})
1636 if test "$2" = -1; then
1637 AC_MSG_WARN(please determine $1_SHIFT manually)
1641 AC_SHIFT_OFFSET(CRDLY, sc_cv_sys_crdly_shift)
1642 AC_SHIFT_OFFSET(TABDLY, sc_cv_sys_tabdly_shift)
1643 AC_SHIFT_OFFSET(CSIZE, sc_cv_sys_csize_shift)
1646 dnl Find what physical type (basic C type) is equivalent to the given type.
1647 dnl If possible we try to compile simple test code and get no warning only with
1648 dnl the matching type.
1649 dnl If this method does not seem to work we run test programs that print the
1650 dnl length and signedness of the type.
1652 dnl do we have a -Werror option?
1653 dnl Does the test code compile with -Werror when types fit?
1654 CHANCE_TO_TYPECHECK=1
1655 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1656 AC_TRY_COMPILE([#include <stdlib.h>],[int u; int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)
1659 dnl Does the test code compile without -Werror when types do not fit?
1660 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1661 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)
1664 dnl Does the test code fail to compile with -Werror when types do not fit?
1665 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1666 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1667 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],CHANCE_TO_TYPECHECK=0,)
1671 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1672 AC_MSG_NOTICE(using compile -Werror method to find basic types)
1674 AC_MSG_NOTICE(using code run method to find basic types)
1678 dnl see AC_BASIC_TYPE
1679 define(AC_BASIC_TYPE_GCC,[
1680 AC_CACHE_CHECK(for equivalent simple type of $2, $4,
1681 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1682 dnl echo "echo: trying short for $2" >&2
1683 AC_TRY_COMPILE([$1],[$2 u; short v; return(&u==&v);],
1684 [$4="1 /* short */"],
1685 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u==&v);],
1686 [$4="2 /* unsigned short */"],
1687 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u==&v);],
1689 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u==&v);],
1690 [$4="4 /* unsigned int */"],
1691 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u==&v);],
1692 [$4="5 /* long */"],
1693 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u==&v);],
1694 [$4="6 /* unsigned long */"],
1695 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u==&v);],
1696 [$4="7 /* long long */"],
1697 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u==&v);],
1698 [$4="8 /* unsigned long long */"],
1699 [$4="0 /* unknown, taking default */"
1700 ]) ]) ]) ]) ]) ]) ]) ])
1701 CFLAGS="$CFLAGS1" ])
1702 AC_DEFINE_UNQUOTED($3, ${$4})
1705 dnl see AC_BASIC_TYPE
1706 define(AC_BASIC_TYPE_OTHER,[
1707 AC_CACHE_CHECK(for equivalent simple type of $2, $4,
1710 int main() { return!(sizeof($2)==sizeof(short));}],
1711 # same length as short
1714 int main() { $2 x=-1; return !(x<0);}],
1715 [$4="1 /* short */"],
1716 [$4="2 /* unsigned short */"]),
1717 # length differs from short, try others
1720 int main() { return!(sizeof($2)==sizeof(int));}],
1721 # same length as int
1724 int main() { $2 x=-1; return !(x<0);}],
1726 [$4="4 /* unsigned int */"]),
1727 # length differs from int, try others
1730 int main() { return !(sizeof($2)==sizeof(long));}],
1731 # same length as long
1734 int main() { $2 x=-1; return !(x<0);}],
1735 [$4="5 /* long */"],
1736 [$4="6 /* unsigned long */"] ),
1737 # length differs from long, try others
1740 int main() { return !(sizeof($2)==sizeof(long long));}],
1741 # same length as long long
1744 int main() { $2 x=-1; return !(x<0);}],
1745 [$4="7 /* long long */"],
1746 [$4="8 /* unsigned long long */"] ),
1747 [$4="0 /* unknown */"]
1753 AC_DEFINE_UNQUOTED($3, ${$4})
1756 dnl find what physical type (basic C type) is equivalent to the given type.
1757 dnl arg1: include file(s)
1759 dnl arg3: output variable
1760 dnl arg4: cache variable (might be constructed automatically)
1761 dnl output values: 1..short, 2..unsigned short, 3..int, 4..u-int,
1762 dnl 5..long, 6..u-long; others not yet supported
1763 define(AC_BASIC_TYPE,[
1764 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1765 AC_BASIC_TYPE_GCC([$1],[$2],[$3],[$4])
1767 AC_BASIC_TYPE_OTHER([$1],[$2],[$3],[$4])
1772 dnl See AC_TYPEOF_COMPONENT
1773 dnl This version is for compilers with -Werror or so: gcc, clang, Sun Studio?
1774 define(AC_TYPEOF_COMPONENT_GCC,[
1775 AC_CACHE_CHECK(for basic type of $2.$3, $5,
1776 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1777 AC_TRY_COMPILE([$1],[$2 u;short v; return(&u.$3==&v);],
1778 [$5="1 /* short */"],
1779 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u.$3==&v);],
1780 [$5="2 /* unsigned short */"],
1781 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u.$3==&v);],
1783 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u.$3==&v);],
1784 [$5="4 /* unsigned int */"],
1785 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u.$3==&v);],
1786 [$5="5 /* long */"],
1787 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u.$3==&v);],
1788 [$5="6 /* unsigned long */"],
1789 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u.$3==&v);],
1790 [$5="7 /* long long */"],
1791 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u.$3==&v);],
1792 [$5="8 /* unsigned long long */"],
1793 [$5="0 /* unknown, taking default */"
1794 ]) ]) ]) ]) ]) ]) ]) ])
1795 CFLAGS="$CFLAGS1" ])
1796 AC_DEFINE_UNQUOTED($4, ${$5})
1799 dnl See AC_TYPEOF_COMPONENT
1800 dnl This version is for compilers with no -Werror or so
1801 define(AC_TYPEOF_COMPONENT_OTHER,[
1802 AC_CACHE_CHECK(for basic type of $2.$3, $5,
1805 int main() { $2 x; return!(sizeof(x.$3)==sizeof(short));}],
1806 # same length as short
1809 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
1810 [$5="1 /* short */"],
1811 [$5="2 /* unsigned short */"]),
1812 # length differs from short, try others
1815 int main() { $2 x; return!(sizeof(x.$3)==sizeof(int));}],
1816 # same length as int
1819 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
1821 [$5="4 /* unsigned int */"]),
1822 # length differs from int, try others
1825 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long));}],
1826 # same length as long
1829 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
1830 [$5="5 /* long */"],
1831 [$5="6 /* unsigned long */"] ),
1832 # length differs from long, try others
1835 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long long));}],
1836 # same length as long long
1839 int main() { x $2; x.$3=-1; return !(x.$3<0);}],
1840 [$5="7 /* long long */"],
1841 [$5="8 /* unsigned long long */"] ),
1842 [$5="0 /* unknown */"]
1848 AC_DEFINE_UNQUOTED($4, ${$5})
1851 dnl find what physical type (basic C type) describes the given struct or union
1853 dnl arg1: include file(s); must declare the structure type
1854 dnl arg2: struct name (e.g., "struct stat")
1855 dnl arg3: variable or component (e.g., "st_ino")
1856 dnl arg4: output variable, values see AC_BASIC_TYPE
1857 dnl arg5: cache variable (might be constructed automatically)
1858 define(AC_TYPEOF_COMPONENT,[
1859 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1860 AC_TYPEOF_COMPONENT_GCC([$1],[$2],[$3],[$4],[$5])
1862 AC_TYPEOF_COMPONENT_OTHER([$1],[$2],[$3],[$4],[$5])
1866 AC_BASIC_TYPE([#include <stdint.h>], uint16_t, HAVE_BASIC_UINT16_T, sc_cv_type_uint16_basic)
1867 AC_BASIC_TYPE([#include <stdint.h>], uint32_t, HAVE_BASIC_UINT32_T, sc_cv_type_uint32_basic)
1868 AC_BASIC_TYPE([#include <stdint.h>], uint64_t, HAVE_BASIC_UINT64_T, sc_cv_type_uint64_basic)
1869 AC_BASIC_TYPE([#include <stdint.h>], int16_t, HAVE_BASIC_INT16_T, sc_cv_type_int16_basic)
1870 AC_BASIC_TYPE([#include <stdint.h>], int32_t, HAVE_BASIC_INT32_T, sc_cv_type_int32_basic)
1871 AC_BASIC_TYPE([#include <stdint.h>], int64_t, HAVE_BASIC_INT64_T, sc_cv_type_int64_basic)
1872 AC_BASIC_TYPE([#include <stdlib.h>], size_t, HAVE_BASIC_SIZE_T, sc_cv_type_sizet_basic)
1873 AC_BASIC_TYPE([#include <sys/types.h>
1874 #include <sys/stat.h>
1875 #include <unistd.h>], mode_t, HAVE_BASIC_MODE_T, sc_cv_type_modet_basic)
1876 AC_BASIC_TYPE([#include <sys/types.h>
1877 #include <unistd.h>], pid_t, HAVE_BASIC_PID_T, sc_cv_type_pidt_basic)
1878 AC_BASIC_TYPE([#include <sys/types.h>
1879 #include <unistd.h>], uid_t, HAVE_BASIC_UID_T, sc_cv_type_uidt_basic)
1880 AC_BASIC_TYPE([#include <sys/types.h>
1881 #include <unistd.h>], gid_t, HAVE_BASIC_GID_T, sc_cv_type_gidt_basic)
1883 AC_BASIC_TYPE([#include <time.h>], time_t, HAVE_BASIC_TIME_T,
1884 sc_cv_type_timet_basic)
1886 # this is questionable, might fail on some systems
1887 AC_BASIC_TYPE([#include <sys/types.h>
1888 #include <sys/socket.h>
1889 #include <unistd.h>], socklen_t, HAVE_BASIC_SOCKLEN_T,
1890 sc_cv_type_socklent_basic)
1892 AC_BASIC_TYPE([#include <sys/types.h>
1893 #include <unistd.h>], off_t, HAVE_BASIC_OFF_T, sc_cv_type_off_basic)
1895 AC_BASIC_TYPE([#include <sys/types.h>
1896 #include <unistd.h>], off64_t, HAVE_BASIC_OFF64_T, sc_cv_type_off64_basic)
1898 # oh god, __dev_t in Linux 2.4 is struct{int[2];}, not handled here yet.
1899 AC_BASIC_TYPE([#include <sys/stat.h>], dev_t, HAVE_BASIC_DEV_T, sc_cv_type_dev_basic)
1901 AC_BASIC_TYPE([#include <unistd.h>
1902 #include <termios.h>], speed_t, HAVE_BASIC_SPEED_T, sc_cv_type_spee_t)
1904 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_ino, HAVE_TYPEOF_ST_INO, sc_cv_type_stat_stino_basic)
1905 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_nlink, HAVE_TYPEOF_ST_NLINK, sc_cv_type_stat_stnlink_basic)
1906 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_size, HAVE_TYPEOF_ST_SIZE, sc_cv_type_stat_stsize_basic)
1907 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blksize, HAVE_TYPEOF_ST_BLKSIZE, sc_cv_type_stat_stblksize_basic)
1908 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blocks, HAVE_TYPEOF_ST_BLOCKS, sc_cv_type_stat_stblocks_basic)
1910 if test "$ac_cv_func_stat64" = yes; then
1911 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_dev, HAVE_TYPEOF_ST64_DEV, sc_cv_type_stat64_stdev_basic)
1912 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_ino, HAVE_TYPEOF_ST64_INO, sc_cv_type_stat64_stino_basic)
1913 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_nlink, HAVE_TYPEOF_ST64_NLINK, sc_cv_type_stat64_stnlink_basic)
1914 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_size, HAVE_TYPEOF_ST64_SIZE, sc_cv_type_stat64_stsize_basic)
1915 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blksize, HAVE_TYPEOF_ST64_BLKSIZE, sc_cv_type_stat64_stblksize_basic)
1916 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blocks, HAVE_TYPEOF_ST64_BLOCKS, sc_cv_type_stat64_stblocks_basic)
1919 AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timeval, tv_usec, HAVE_TYPEOF_STRUCT_TIMEVAL_TV_USEC, sc_cv_type_struct_timeval_tv_usec)
1921 AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timespec, tv_nsec, HAVE_TYPEOF_STRUCT_TIMESPEC_TV_NSEC, sc_cv_type_struct_timespec_tv_nsec)
1923 AC_TYPEOF_COMPONENT([#include <sys/types.h>
1924 #include <sys/time.h>
1925 #include <sys/resource.h>],
1926 struct rlimit, rlim_max, HAVE_TYPEOF_RLIM_MAX, sc_cv_type_rlimit_rlimmax_basic)
1928 # Fedora-19 doc says it is socklen_t which is equivalent to unsigned int, but it is equivalent to size_t (x86_64)
1929 AC_TYPEOF_COMPONENT([#include "sysincludes.h"], struct cmsghdr, cmsg_len, HAVE_TYPEOF_STRUCT_CMSGHDR_CMSG_LEN, sc_cv_typeof_struct_cmsghdr_cmsg_len)
1930 ### snprintf, vsnprintf
1932 AC_MSG_CHECKING(for /dev/ptmx)
1933 if test -c /dev/ptmx; then
1934 AC_DEFINE(HAVE_DEV_PTMX, 1)
1938 AC_MSG_CHECKING(for /dev/ptc)
1939 if test -c /dev/ptc; then
1940 AC_DEFINE(HAVE_DEV_PTC)
1947 AC_MSG_CHECKING(for /proc)
1948 if test -d /proc; then
1949 AC_DEFINE(HAVE_PROC_DIR, 1)
1955 AC_MSG_CHECKING(for /proc/*/fd)
1956 if test -d /proc/$$/fd; then
1957 AC_DEFINE(HAVE_PROC_DIR_FD, 1)
1963 dnl "tcpd" "tcpwrappers"
1964 # on some platforms, raw linking with libwrap fails because allow_severity and
1965 # deny_severity are not explicitely defined. Thus we put the libwrap part to
1967 AC_MSG_CHECKING(whether to include libwrap support)
1968 AC_ARG_ENABLE(libwrap, [ --disable-libwrap disable libwrap support],
1969 [ case "$enableval" in
1970 no) AC_MSG_RESULT(no); WITH_LIBWRAP= ;;
1971 *) AC_MSG_RESULT(yes); WITH_LIBWRAP=1 ;;
1973 [ AC_MSG_RESULT(yes); WITH_LIBWRAP=1 ])
1975 # check if we find the components of libwrap ("tcpd" "tcpwrappers")
1976 if test -n "$WITH_LIBWRAP"; then
1977 AC_MSG_CHECKING(for components of libwrap)
1978 # first, we need to find the include file <tcpd.h>
1979 AC_CACHE_VAL(sc_cv_have_tcpd_h,
1980 [AC_TRY_COMPILE([#include <sys/types.h>
1981 #include <tcpd.h>],[;],
1982 [sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT=""],
1983 [sc_cv_have_tcpd_h=no
1984 for D in "/sw" "/usr/local" "/opt/freeware" "/usr/sfw"; do
1987 if test -r "$i"; then
1988 #V_INCL="$V_INCL -I$I"
1989 CPPFLAGS="$CPPFLAGS -I$I"
1990 AC_MSG_NOTICE(found $i)
1991 sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT="$D"
1996 if test "$sc_cv_have_tcpd_h" = "yes"; then
1997 AC_DEFINE(HAVE_TCPD_H)
1999 AC_MSG_NOTICE(checked for tcpd.h... $sc_cv_have_tcpd_h)
2000 fi # end checking for tcpd.h
2001 if test -n "$WITH_LIBWRAP" -a "$sc_cv_have_tcpd_h" = yes; then
2002 # next, we search for the wrap library (libwrap.*)
2003 AC_MSG_CHECKING(for libwrap)
2004 AC_CACHE_VAL(sc_cv_have_libwrap,
2006 if test -n "$LIBWRAP_ROOT"; then
2007 L="$LIBWRAP_ROOT/lib"; LIBS="-L$L -lwrap $LIBS"
2011 AC_TRY_LINK([#include <sys/types.h>
2013 int allow_severity,deny_severity;],[hosts_access(0)],
2014 [sc_cv_have_libwrap='yes'],
2015 [sc_cv_have_libwrap='no'
2016 LIBS="$LIBS -lnsl" # RedHat73
2017 AC_TRY_LINK([#include <sys/types.h>
2019 int allow_severity,deny_severity;],[hosts_access(0)],
2020 [sc_cv_have_libwrap='yes'],
2021 [sc_cv_have_libwrap='no'])
2024 if test "$sc_cv_have_libwrap" != 'yes'; then
2029 if test "$sc_cv_have_libwrap" = 'yes'; then
2030 AC_DEFINE(HAVE_LIBWRAP)
2032 AC_MSG_RESULT($sc_cv_have_libwrap)
2035 if test -n "$WITH_LIBWRAP"; then
2036 if test "$sc_cv_have_tcpd_h" = "yes" -a "$sc_cv_have_libwrap" = "yes"; then
2037 AC_DEFINE(WITH_LIBWRAP)
2039 AC_MSG_WARN([not all components of tcp wrappers found, disabling it]);
2043 # check of hosts_allow_table
2044 if test -n "$WITH_LIBWRAP"; then
2045 AC_MSG_CHECKING(for hosts_allow_table)
2046 AC_CACHE_VAL(sc_cv_have_hosts_allow_table,
2047 [AC_TRY_COMPILE([#include <sys/types.h>
2048 #include <tcpd.h>],[hosts_allow_table="";],
2049 [sc_cv_have_hosts_allow_table=yes],
2050 [sc_cv_have_hosts_allow_table=no])])
2051 if test $sc_cv_have_hosts_allow_table = yes; then
2052 AC_DEFINE(HAVE_HOSTS_ALLOW_TABLE)
2054 AC_MSG_RESULT($sc_cv_have_hosts_allow_table)
2055 fi # test -n "$WITH_LIBWRAP"
2058 if test "$GCC" = yes; then
2062 # FIPS support requires compiling with fipsld.
2063 # fipsld requires the FIPSLD_CC variable to be set to the original CC.
2064 # This check must be done after all other checks that require compiling
2065 # so that fipsld is not used by the configure script itself.
2066 if test -n "$WITH_FIPS"; then
2067 if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then
2069 if test "${FIPSLD+set}" != set ; then
2072 CC="FIPSLD_CC=$CC $FIPSLD"
2077 # autoconf does not seem to provide AC_CHECK_VAR or so
2078 # thus we have to check by foot
2079 AC_MSG_CHECKING(for declaration of environ)
2080 AC_CACHE_VAL(sc_cv_decl_environ,
2081 [AC_TRY_COMPILE([#include <unistd.h>],[char **s = environ;],
2082 [sc_cv_decl_environ=yes],
2083 [sc_cv_decl_environ=no])])
2084 if test $sc_cv_decl_environ = yes; then
2085 AC_DEFINE(HAVE_DECL_ENVIRON)
2087 AC_MSG_RESULT($sc_cv_decl_environ)
2089 # on some systems environ exists but not the declaration
2090 AC_MSG_CHECKING(for var environ)
2091 AC_CACHE_VAL(sc_cv_var_environ,
2092 [AC_TRY_COMPILE([],[extern char **environ; char **s = environ;],
2093 [sc_cv_var_environ=yes],
2094 [sc_cv_var_environ=no])])
2095 if test $sc_cv_var_environ = yes; then
2096 AC_DEFINE(HAVE_VAR_ENVIRON)
2098 AC_MSG_RESULT($sc_cv_var_environ)
2100 # allow BUILD_DATE to be externally set for build reproducibility
2101 if test "$BUILD_DATE"; then
2102 AC_DEFINE_UNQUOTED(BUILD_DATE, ["$BUILD_DATE"])
2104 AC_DEFINE(BUILD_DATE, [__DATE__" "__TIME__])