1 dnl source: configure.in
2 dnl Copyright Gerhard Rieger
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 listen support)
353 AC_ARG_ENABLE(listen, [ --disable-listen disable listen support],
354 [case "$enableval" in
355 no) AC_MSG_RESULT(no);;
356 *) AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes);;
358 [AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes)])
360 AC_MSG_CHECKING(whether to include socks4 support)
361 AC_ARG_ENABLE(socks4, [ --disable-socks4 disable socks4 support],
362 [case "$enableval" in
363 no) AC_MSG_RESULT(no);;
364 *) AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes);;
366 [AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes)])
368 AC_MSG_CHECKING(whether to include socks4a support)
369 AC_ARG_ENABLE(socks4a, [ --disable-socks4a disable socks4a support],
370 [case "$enableval" in
371 no) AC_MSG_RESULT(no);;
372 *) AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes);;
374 [AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes)])
376 AC_MSG_CHECKING(whether to include proxy connect support)
377 AC_ARG_ENABLE(proxy, [ --disable-proxy disable proxy connect support],
378 [case "$enableval" in
379 no) AC_MSG_RESULT(no);;
380 *) AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes);;
382 [AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes)])
384 AC_MSG_CHECKING(whether to include exec support)
385 AC_ARG_ENABLE(exec, [ --disable-exec disable exec support],
386 [case "$enableval" in
387 no) AC_MSG_RESULT(no);;
388 *) AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes);;
390 [AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes)])
392 AC_MSG_CHECKING([whether to include system (shell) support])
393 AC_ARG_ENABLE(system, [ --disable-system disable system (shell) support],
394 [case "$enableval" in
395 no) AC_MSG_RESULT(no);;
396 *) AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes);;
398 [AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes)])
400 AC_MSG_CHECKING(whether to include pty address support)
401 AC_ARG_ENABLE(pty, [ --disable-pty disable pty support],
402 [case "$enableval" in
403 no) AC_MSG_RESULT(no);;
404 *) AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes);;
406 [AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes)])
408 AC_MSG_CHECKING(whether to include ext2 fs attributes support)
409 AC_ARG_ENABLE(ext2, [ --disable-ext2 disable ext2 fs attributes support],
410 [case "$enableval" in
411 no) AC_MSG_RESULT(no);;
412 *) AC_DEFINE(WITH_EXT2) AC_MSG_RESULT(yes);;
414 [AC_DEFINE(WITH_EXT2) AC_MSG_RESULT(yes)])
416 AC_MSG_CHECKING(whether to include readline support)
417 AC_ARG_ENABLE(readline, [ --disable-readline disable readline support],
418 [case "$enableval" in
419 no) AC_MSG_RESULT(no); WITH_READLINE= ;;
420 *) AC_MSG_RESULT(yes); WITH_READLINE=1 ;;
422 [AC_MSG_RESULT(yes); WITH_READLINE=1 ])
424 if test -n "$WITH_READLINE"; then
425 CPPFLAGS_ORIG=$CPPFLAGS
428 sc_usable_readline_found=
430 for D in "" "/usr/local" "/opt/local" "/sw" "/opt/freeware" "/usr/sfw"; do
431 if test -n "$D" ; then
432 CPPFLAGS="$CPPFLAGS -I$D/include"
433 CFLAGS="$CFLAGS -L$D/lib"
434 DLOC="in location $D"
436 DLOC="in default location"
438 AC_MSG_CHECKING(for usable readline $DLOC)
440 # Some systems require -lcurses, some require -lncurses.
441 # Mac OS X 10.4 (and others) ships with libedit masquerading as readline,
442 # but it doesn't work well with socat. It can be recognized by the absence
445 for L in "" "-lcurses" "-lncurses"; do
446 LIBS="$LIBS_ORIG -lreadline $L"
449 #include <readline/readline.h>
450 #include <readline/history.h>],
452 append_history(0, NULL); ],
453 [ sc_usable_readline_found=1
457 if test -n "$sc_usable_readline_found"; then
459 AC_DEFINE(HAVE_READLINE_READLINE_H,1)
460 AC_DEFINE(HAVE_READLINE_HISTORY_H,1)
461 AC_DEFINE(HAVE_LIBREADLINE,1)
462 AC_DEFINE(WITH_READLINE,1)
466 CPPFLAGS=$CPPFLAGS_ORIG
472 if test -z "$sc_usable_readline_found"; then
473 AC_MSG_WARN([no suitable version of readline found; perhaps you need to install a newer version])
477 AC_MSG_CHECKING(whether to include openssl support)
478 AC_ARG_ENABLE(openssl, [ --disable-openssl disable OpenSSL support],
479 [ case "$enableval" in
480 no) AC_MSG_RESULT(no); WITH_OPENSSL= ;;
481 *) AC_MSG_RESULT(yes); WITH_OPENSSL=1 ;;
483 [ AC_MSG_RESULT(yes); WITH_OPENSSL=1 ])
485 if test -n "$WITH_OPENSSL"; then
486 AC_MSG_NOTICE(checking for components of OpenSSL)
487 # first, we need to find the include file <openssl/ssl.h>
488 AC_CACHE_VAL(sc_cv_have_openssl_ssl_h,
489 [AC_TRY_COMPILE([#include <openssl/ssl.h>],[;],
490 [sc_cv_have_openssl_ssl_h=yes; OPENSSL_ROOT=""; ],
491 [sc_cv_have_openssl_ssl_h=no
492 for D in "/sw" "/usr/local" "/opt/freeware" "/usr/sfw" "/usr/local/ssl"; do
495 if test -r "$i"; then
496 #V_INCL="$V_INCL -I$I"
497 CPPFLAGS="$CPPFLAGS -I$I"
498 AC_MSG_NOTICE(found $i)
499 sc_cv_have_openssl_ssl_h=yes; OPENSSL_ROOT="$D"
504 if test "$sc_cv_have_openssl_ssl_h" = "yes"; then
505 AC_DEFINE(HAVE_OPENSSL_SSL_H)
507 AC_MSG_NOTICE(checked for openssl/ssl.h... $sc_cv_have_openssl_ssl_h)
508 fi # end checking for openssl/ssl.h
510 if test -n "$WITH_OPENSSL" -a "$sc_cv_have_openssl_ssl_h" = 'yes'; then
511 # next, we search for the openssl library (libssl.*)
512 # interesting: Linux only requires -lssl, FreeBSD requires -lssl -lcrypto
513 # Note, version OpenSSL 0.9.7j requires -lcrypto even on Linux.
514 AC_MSG_CHECKING(for libssl)
515 AC_CACHE_VAL(sc_cv_have_libssl,
517 if test -n "$OPENSSL_ROOT"; then
518 L="$OPENSSL_ROOT/lib"; LIBS="$LIBS -L$L -lssl"
522 AC_TRY_LINK([#include <openssl/ssl.h>],
523 [SSL_library_init();ERR_error_string()],
524 [sc_cv_have_libssl='yes'],
525 [ LIBS="$LIBS -lcrypto"
526 AC_TRY_LINK([#include <openssl/ssl.h>],
527 [SSL_library_init()],
528 [sc_cv_have_libssl='yes'],
529 [sc_cv_have_libssl='no'])
531 if test "$sc_cv_have_libssl" != 'yes'; then
536 if test "$sc_cv_have_libssl" = 'yes'; then
537 AC_DEFINE(HAVE_LIBSSL)
539 AC_MSG_RESULT($sc_cv_have_libssl)
542 # # a possible location for openssl (on Sourceforge/Solaris)
543 # AC_CHECK_FILE(/usr/local/ssl/lib, LIBS="$LIBS -L/usr/local/ssl/lib/")
544 # # sometimes on Solaris:
545 # AC_CHECK_FILE(/pkgs/lib, LIBS="$LIBS -L/pkgs/lib/")
546 # # for AIX 5.1 with Linux toolbox:
547 # AC_CHECK_FILE(/opt/freeware/lib, LIBS="$LIBS -L/opt/freeware/lib/")
549 # AC_CHECK_LIB(crypto, main)
550 # AC_CHECK_LIB(ssl, main)
552 # # MacOSX has openssl includes in another directory
553 # if test -d /sw/include/; then
554 # V_INCL="$V_INCL -I/sw/include"
555 # # and Solaris at sourceforge here:
556 # elif test -d /usr/local/ssl/include/; then
557 # V_INCL="$V_INCL -I/usr/local/ssl/include"
558 # # and AIX 5.1 with Linux toolbox:
559 # elif test -d /opt/freeware/include; then
560 # V_INCL="$V_INCL -I/opt/freeware/include"
563 if test -n "$WITH_OPENSSL"; then
564 if test "$sc_cv_have_openssl_ssl_h" = "yes" -a "$sc_cv_have_libssl" = "yes"; then
565 AC_DEFINE(WITH_OPENSSL)
567 AC_MSG_WARN([not all components of OpenSSL found, disabling it]);
571 # check for fips support
572 AC_MSG_CHECKING(whether to include openssl fips support)
573 AC_ARG_ENABLE(fips, [ --enable-fips enable OpenSSL FIPS support],
574 [ case "$enableval" in
575 yes) AC_MSG_RESULT(yes); WITH_FIPS=1 ;;
576 *) AC_MSG_RESULT(no); WITH_FIPS= ;;
578 [ AC_MSG_RESULT(no); WITH_FIPS= ])
580 if test -n "$WITH_FIPS"; then
581 if test -n "$WITH_OPENSSL"; then
582 AC_CHECK_PROG(HAVE_FIPSLD, fipsld, 1)
583 if test "$sc_cv_have_openssl_ssl_h" != "yes" -o "$sc_cv_have_libssl" != "yes" -o ! "$HAVE_FIPSLD";
585 AC_MSG_WARN([not all components of OpenSSL found, disabling FIPS]);
589 AC_MSG_WARN([must enable OpenSSL to enable FIPS; use --enable-openssl]);
593 if test -n "$WITH_FIPS"; then
594 AC_MSG_CHECKING(for components of OpenSSL FIPS)
595 # first, we need to find the include file <openssl/fips.h>
596 AC_CACHE_VAL(sc_cv_have_openssl_fips_h,
597 [AC_TRY_COMPILE([#define OPENSSL_FIPS
599 #include <openssl/fips.h>],[;],
600 [sc_cv_have_openssl_fips_h=yes; ],
601 [sv_cv_have_openssl_fips_h=no
602 if test -n "$OPENSSL_ROOT"; then
603 I="$OPENSSL_ROOT/include"
604 i="$I/openssl/fips.h"
605 if test -r "$i"; then
606 AC_MSG_NOTICE(found $i)
607 sc_cv_have_openssl_fips_h=yes;
613 if test "$sv_cv_have_openssl_fips_h" = "yes"; then
614 AC_DEFINE(HAVE_OPENSSL_FIPS_H)
616 AC_MSG_NOTICE(checked for openssl/fips.h... $sc_cv_have_openssl_ssl_h)
619 if test -n "$WITH_FIPS" -a "$sc_cv_have_openssl_fips_h" = 'yes'; then
620 # check for the libcrypto library with fips support
621 AC_MSG_CHECKING(for libcrypto with FIPS support)
622 AC_CACHE_VAL(sc_cv_have_libcrypto,
624 echo $LIBS | grep -q "\-lcrypto"
625 if test $? -ne 0; then
626 if test -n "$OPENSSL_ROOT"; then
627 L="$OPENSSL_ROOT/lib"; LIBS="$LIBS -L$L -lcrypto"
629 LIBS="$LIBS -lcrypto"
632 AC_TRY_LINK([#define OPENSSL_FIPS
633 #include <openssl/ssl.h>
634 #include <openssl/fips.h>],
635 [int res = FIPS_mode_set(1);],
636 [sc_cv_have_libcrypto='yes'],
637 [sc_cv_have_libcrypto='no']
639 if test "$sc_cv_have_libcrypto" != 'yes'; then
644 if test "$sc_cv_have_libcrypto" = 'yes'; then
645 AC_DEFINE(HAVE_LIBCRYPTO)
647 AC_MSG_RESULT($sc_cv_have_libcrypto)
650 if test -n "$WITH_FIPS"; then
651 if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then
653 AC_DEFINE(OPENSSL_FIPS)
655 AC_MSG_WARN([not all components of OpenSSL FIPS found, disabling it]);
659 AC_MSG_CHECKING(whether to include tun/tap address support)
660 AC_ARG_ENABLE(tun, [ --disable-tun disable TUN/TAP support],
661 [case "$enableval" in
662 no) AC_MSG_RESULT(no); WITH_TUN= ;;
663 *) AC_MSG_RESULT(yes); WITH_TUN=1 ;;
665 [AC_MSG_RESULT(yes); WITH_TUN=1 ])
668 if ! test "$ac_cv_header_linux_if_tun_h" = 'yes'; then
669 AC_MSG_WARN(include file linux/if_tun.h not found, disabling TUN)
673 if test -n "$WITH_TUN"; then
677 AC_MSG_CHECKING(whether to include system call tracing)
678 AC_ARG_ENABLE(sycls, [ --disable-sycls disable system call tracing],
679 [case "$enableval" in
680 no) SYCLS=""; SSLCLS=""; AC_MSG_RESULT(no);;
681 *) AC_DEFINE(WITH_SYCLS)
682 SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes);;
684 [AC_DEFINE(WITH_SYCLS)
685 SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes)])
689 AC_MSG_CHECKING(whether to include file descriptor analyzer)
690 AC_ARG_ENABLE(filan, [ --disable-filan disable file descriptor analyzer],
691 [case "$enableval" in
692 no) FILAN=""; AC_MSG_RESULT(no);;
693 *) AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes);;
695 [AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes)])
698 AC_MSG_CHECKING(whether to include retry support)
699 AC_ARG_ENABLE(retry, [ --disable-retry disable retry support],
700 [case "$enableval" in
701 no) AC_MSG_RESULT(no);;
702 *) AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes);;
704 [AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes)])
706 AC_MSG_CHECKING(included message level)
707 AC_ARG_ENABLE(msglevel, [ --enable-msglevel=N set max verbosity to debug,info,notice,warn,error,fatal],
708 [case "$enableval" in
709 debug) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;
710 info) AC_DEFINE(WITH_MSGLEVEL,1) AC_MSG_RESULT(info);;
711 notice) AC_DEFINE(WITH_MSGLEVEL,2) AC_MSG_RESULT(notice);;
712 warn) AC_DEFINE(WITH_MSGLEVEL,3) AC_MSG_RESULT(warn);;
713 error) AC_DEFINE(WITH_MSGLEVEL,4) AC_MSG_RESULT(error);;
714 fatal) AC_DEFINE(WITH_MSGLEVEL,5) AC_MSG_RESULT(fatal);;
715 *) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;
717 [AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug)])
721 dnl Checks for typedefs, structures, and compiler characteristics.
733 dnl Check for extra realtime library (for Solaris)
734 AC_CHECK_FUNC(nanosleep, AC_DEFINE(HAVE_NANOSLEEP), AC_CHECK_LIB(rt, nanosleep, [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_NANOSLEEP)]))
735 #AC_CHECK_FUNC(nanosleep, , AC_CHECK_LIB(rt, nanosleep))
737 dnl Checks for library functions.
738 AC_PROG_GCC_TRADITIONAL
742 AC_CHECK_FUNCS(putenv select poll socket strtod strtol)
743 AC_CHECK_FUNCS(strtoul uname getpgid getsid getaddrinfo)
744 AC_CHECK_FUNCS(setgroups inet_aton)
747 AC_CHECK_FUNCS(grantpt unlockpt)
749 # GR AC_CHECK_FUNCS only checks linking, not prototype. This may lead to implicit
750 # function declarations and to SIGSEGV on systems with 32bit int and 64bit pointer
752 ###################################
753 # check for prototype and existence of functions that return a pointer
754 # defines in config.h: HAVE_PROTOTYPE_LIB_$1
755 AC_CHECK_PROTOTYPE_LIB(strdup)
756 AC_CHECK_PROTOTYPE_LIB(strerror)
757 AC_CHECK_PROTOTYPE_LIB(strstr)
758 AC_CHECK_PROTOTYPE_LIB(getipnodebyname)
759 AC_CHECK_PROTOTYPE_LIB(memrchr)
760 AC_CHECK_PROTOTYPE_LIB(if_indextoname)
761 AC_CHECK_PROTOTYPE_LIB(ptsname)
764 AC_MSG_CHECKING(for long long)
765 AC_CACHE_VAL(sc_cv_type_longlong,
766 [AC_TRY_COMPILE([],[long long s;],
767 [sc_cv_type_longlong=yes],
768 [sc_cv_type_longlong=no])])
769 if test $sc_cv_type_longlong = yes; then
770 AC_DEFINE(HAVE_TYPE_LONGLONG)
772 AC_MSG_RESULT($sc_cv_type_longlong)
774 AC_CHECK_TYPE(sig_atomic_t,AC_DEFINE(HAVE_TYPE_SIG_ATOMIC_T),,[#include "sysincludes.h"])
776 AC_MSG_CHECKING(for bool)
777 AC_CACHE_VAL(sc_cv_type_bool,
778 [AC_TRY_COMPILE([#ifdef HAVE_STDBOOL_H
782 [sc_cv_type_bool=yes],
783 [sc_cv_type_bool=no])])
784 if test $sc_cv_type_bool = yes; then
785 AC_DEFINE(HAVE_TYPE_BOOL)
787 AC_MSG_RESULT($sc_cv_type_bool)
789 # following builtin macro does not check unistd.h and sys/socket.h where
790 # socklen_t might be defined
791 #AC_CHECK_TYPE(socklen_t, int)
793 AC_MSG_CHECKING(for socklen_t)
794 AC_CACHE_VAL(sc_cv_type_socklen,
795 [AC_TRY_COMPILE([#include <sys/types.h>
796 #include <sys/socket.h>
797 #include <unistd.h>],[socklen_t s;],
798 [sc_cv_type_socklen=yes],
799 [sc_cv_type_socklen=no])])
800 if test $sc_cv_type_socklen = yes; then
801 AC_DEFINE(HAVE_TYPE_SOCKLEN)
803 AC_MSG_RESULT($sc_cv_type_socklen)
805 AC_MSG_CHECKING(for struct stat64)
806 AC_CACHE_VAL(sc_cv_type_stat64,
807 [AC_TRY_COMPILE([#include <sys/stat.h>],[struct stat64 s;],
808 [sc_cv_type_stat64=yes],
809 [sc_cv_type_stat64=no])])
810 if test $sc_cv_type_stat64 = yes; then
811 AC_DEFINE(HAVE_TYPE_STAT64)
813 AC_MSG_RESULT($sc_cv_type_stat64)
815 AC_MSG_CHECKING(for off64_t)
816 AC_CACHE_VAL(sc_cv_type_off64,
817 [AC_TRY_COMPILE([#include <unistd.h>],[off64_t s;],
818 [sc_cv_type_off64=yes],
819 [sc_cv_type_off64=no])])
820 if test $sc_cv_type_off64 = yes; then
821 AC_DEFINE(HAVE_TYPE_OFF64)
823 AC_MSG_RESULT($sc_cv_type_off64)
825 AC_MSG_CHECKING(for sighandler_t)
826 AC_CACHE_VAL(sc_cv_type_sighandler,
827 [AC_TRY_COMPILE([#include <signal.h>],[sighandler_t s;],
828 [sc_cv_type_sighandler=yes],
829 [sc_cv_type_sighandler=no])])
830 if test $sc_cv_type_sighandler = yes; then
831 AC_DEFINE(HAVE_TYPE_SIGHANDLER)
833 AC_MSG_RESULT($sc_cv_type_socklen)
835 AC_MSG_CHECKING(for uint8_t)
836 AC_CACHE_VAL(sc_cv_type_uint8,
837 [AC_TRY_COMPILE([#include <sys/types.h>
841 /* Tru64 has uint8_t etc from netdb.h */
845 #include <unistd.h>],[uint8_t s;],
846 [sc_cv_type_uint8=yes],
847 [sc_cv_type_uint8=no])])
848 if test $sc_cv_type_uint8 = yes; then
849 AC_DEFINE(HAVE_TYPE_UINT8)
851 AC_MSG_RESULT($sc_cv_type_uint8)
853 AC_MSG_CHECKING(for uint16_t)
854 AC_CACHE_VAL(sc_cv_type_uint16,
855 [AC_TRY_COMPILE([#include <sys/types.h>
859 /* Tru64 has uint16_t etc from netdb.h */
863 #include <unistd.h>],[uint16_t s;],
864 [sc_cv_type_uint16=yes],
865 [sc_cv_type_uint16=no])])
866 if test $sc_cv_type_uint16 = yes; then
867 AC_DEFINE(HAVE_TYPE_UINT16)
869 AC_MSG_RESULT($sc_cv_type_uint16)
871 AC_MSG_CHECKING(for uint32_t)
872 AC_CACHE_VAL(sc_cv_type_uint32,
873 [AC_TRY_COMPILE([#include <sys/types.h>
877 /* Tru64 has uint32_t etc from netdb.h */
881 #include <unistd.h>],[uint32_t s;],
882 [sc_cv_type_uint32=yes],
883 [sc_cv_type_uint32=no])])
884 if test $sc_cv_type_uint32 = yes; then
885 AC_DEFINE(HAVE_TYPE_UINT32)
887 AC_MSG_RESULT($sc_cv_type_uint32)
889 AC_MSG_CHECKING(for uint64_t)
890 AC_CACHE_VAL(sc_cv_type_uint64,
891 [AC_TRY_COMPILE([#include <sys/types.h>
895 /* Tru64 has uint32_t etc from netdb.h */
899 #include <unistd.h>],[uint64_t s;],
900 [sc_cv_type_uint64=yes],
901 [sc_cv_type_uint64=no])])
902 if test $sc_cv_type_uint64 = yes; then
903 AC_DEFINE(HAVE_TYPE_UINT64)
905 AC_MSG_RESULT($sc_cv_type_uint64)
907 ### AIX 4.1 needs _XOPEN_EXTENDED_SOURCE for syslog headers,
908 # but then gets problems with 3rd arg of getsockaddr...
909 #AC_MSG_CHECKING(for _XOPEN_EXTENDED_SOURCE requirement)
910 #CFLAGS="-Werror -Wall"
911 #AC_TRY_COMPILE([#include <sys/syslog.h>],
913 #[AC_MSG_RESULT(no)],
914 #[AC_MSG_RESULT(required); AC_DEFINE(_XOPEN_EXTENDED_SOURCE)])
919 AC_MSG_CHECKING(for fdset->fds_bits)
920 AC_TRY_COMPILE([#include <sys/types.h>
921 #if HAVE_SYS_SELECT_H
922 #include <sys/select.h>
924 [fd_set s; s.fds_bits[0]=0;],
925 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_FDS_BITS)],
926 [AC_MSG_RESULT(no);])
928 AC_MSG_CHECKING(for sa_family_t)
929 AC_CACHE_VAL(sc_cv_type_sa_family_t,
930 [AC_TRY_COMPILE([#include <sys/types.h>
931 #include <sys/socket.h>
932 #include <netinet/in.h>],[sa_family_t s;],
933 [sc_cv_type_sa_family_t=yes],
934 [sc_cv_type_sa_family_t=no])])
935 if test $sc_cv_type_sa_family_t = yes; then
936 AC_DEFINE(HAVE_TYPE_SA_FAMILY_T)
938 AC_MSG_RESULT($sc_cv_type_sa_family_t)
940 AC_MSG_CHECKING(for struct sock_extended_err)
941 AC_CACHE_VAL(sc_cv_struct_sock_extended_err,
942 [AC_TRY_COMPILE([#include <linux/types.h>
943 #if TIME_WITH_SYS_TIME
944 #include <sys/time.h>
946 #if HAVE_LINUX_ERRQUEUE_H
947 #include <linux/errqueue.h>
948 #endif],[struct sock_extended_err s;],
949 [sc_cv_struct_sock_extended_err=yes],
950 [sc_cv_struct_sock_extended_err=no])])
951 if test $sc_cv_struct_sock_extended_err = yes; then
952 AC_DEFINE(HAVE_STRUCT_SOCK_EXTENDED_ERR)
954 AC_MSG_RESULT($sc_cv_struct_sock_extended_err)
956 AC_MSG_CHECKING(for struct sigaction.sa_sigaction)
957 AC_CACHE_VAL(sc_cv_struct_sigaction_sa_sigaction,
958 [AC_TRY_COMPILE([#include <signal.h>],[struct sigaction s;s.sa_sigaction=0;],
959 [sc_cv_struct_sigaction_sa_sigaction=yes],
960 [sc_cv_struct_sigaction_sa_sigaction=no])])
961 if test $sc_cv_struct_sigaction_sa_sigaction = yes; then
962 AC_DEFINE(HAVE_STRUCT_SIGACTION_SA_SIGACTION)
964 AC_MSG_RESULT($sc_cv_struct_sigaction_sa_sigaction)
966 ### struct termios .c_ispeed
967 AC_MSG_CHECKING(for termios.c_ispeed)
968 AC_CACHE_VAL(sc_cv_termios_ispeed,
969 [AC_TRY_COMPILE([#include <termios.h>],
970 [struct termios t; t.c_ispeed=0;],
971 [sc_cv_termios_ispeed=yes],
972 [sc_cv_termios_ispeed=no])])
973 if test $sc_cv_termios_ispeed = yes; then
974 AC_DEFINE(HAVE_TERMIOS_ISPEED)
976 AC_MSG_RESULT($sc_cv_termios_ispeed)
978 if test $sc_cv_termios_ispeed = yes; then
979 AC_MSG_CHECKING(for offset of c_ispeed in struct termios)
980 LIBS1="$LIBS"; LIBS="" # avoid libwrap allow_severity undefined
981 AC_CACHE_VAL(ac_cv_ispeed_offset,
982 [conftestspeedoff="conftestspeedoff.out"
992 if ((f=fopen("$conftestspeedoff","w"))==NULL){
993 fprintf(stderr,"\\"$conftestspeedoff\\": %s\n",strerror(errno)); exit(-1);
995 fprintf(f, "%d", ((char*)&t.c_ispeed-(char*)&t)/sizeof(speed_t));
999 [ac_cv_ispeed_offset=`cat $conftestspeedoff`],
1000 [ac_cv_ispeed_offset=-1],
1001 [ac_cv_ispeed_offset=-1] #!
1004 AC_MSG_RESULT($ac_cv_ispeed_offset)
1005 if test $ac_cv_ispeed_offset -ge 0; then
1006 AC_DEFINE_UNQUOTED(ISPEED_OFFSET, $ac_cv_ispeed_offset)
1010 # there is another issue with termios: OSR requires "#define _SVID3 ..."
1011 # for reasonable termios support. We check this situation using IMAXBEL
1012 AC_MSG_CHECKING(if _SVID3 is helpful)
1013 AC_CACHE_VAL(ac_cv_svid3,
1014 [AC_TRY_COMPILE([#include <termios.h>],
1017 [AC_TRY_COMPILE([#define _SVID3 1
1018 #include <termios.h>],
1024 if test $ac_cv_svid3 = yes; then
1027 AC_MSG_RESULT($ac_cv_svid3)
1030 # Openindiana needs _XPG4_2 for CMSG stuff
1031 AC_MSG_CHECKING(if _XPG4_2 is helpful)
1032 AC_CACHE_VAL(ac_cv_xpg4_2,
1033 [AC_TRY_LINK([#include <sys/socket.h>],
1034 [int i=CMSG_DATA(0)],
1036 [AC_TRY_LINK([#define _XPG4_2 1
1037 #include <sys/socket.h>],
1038 [int i=CMSG_DATA(0)],
1043 if test $ac_cv_xpg4_2 = yes; then
1046 AC_MSG_RESULT($ac_cv_xpg4_2)
1048 # When on Openindiana _XPG4_2 is defined (see above)
1049 # we also need to define __EXTENSIONS__ for basic stuff.
1050 # Note that <sys/procset.h> is important on Openindiana
1051 # but does not exist on Linux
1052 if test "$ac_cv_xpg4_2" = yes; then
1053 AC_MSG_CHECKING(if __EXTENSIONS__ is helpful)
1054 AC_CACHE_VAL(ac_cv___extensions__,
1055 [AC_TRY_COMPILE([#include <sys/procset.h>],
1057 [ac_cv___extensions__=no],
1058 [AC_TRY_COMPILE([#define __EXTENSIONS__ 1
1059 #include <sys/procset.h>],
1061 [ac_cv___extensions__=yes],
1062 [ac_cv___extensions__=no]
1065 if test $ac_cv___extensions__ = yes; then
1066 AC_DEFINE(__EXTENSIONS__)
1068 AC_MSG_RESULT($ac_cv___extensions__)
1071 # When on Openindiana __EXTENSIONS__ is defined (see above)
1072 # _POSIX_PTHREAD_SEMANTICS must be defined for standard ctime_r()
1073 if test "$ac_cv___extensions__" = yes; then
1074 AC_MSG_CHECKING(if _POSIX_PTHREAD_SEMANTICS is helpful)
1075 AC_CACHE_VAL(ac_cv__posix_pthread_semantics,
1076 [AC_TRY_COMPILE([#include <time.h>],
1077 [char *s = ctime_r(0,0);],
1078 [ac_cv__posix_pthread_semantics=no],
1079 [AC_TRY_COMPILE([#define _POSIX_PTHREAD_SEMANTICS 1
1081 [char *s = ctime_r(0,0);],
1082 [ac_cv__posix_pthread_semantics=yes],
1083 [ac_cv__posix_pthread_semantics=no]
1086 if test $ac_cv__posix_pthread_semantics = yes; then
1087 AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
1089 AC_MSG_RESULT($ac_cv__posix_pthread_semantics)
1094 AC_MSG_CHECKING(for struct timespec)
1095 AC_CACHE_VAL(sc_cv_struct_timespec,
1096 [AC_TRY_COMPILE([#include <time.h>
1098 #include <sys/time.h>
1099 #endif],[struct timespec s;],
1100 [sc_cv_struct_timespec=yes],
1101 [sc_cv_struct_timespec=no])])
1102 if test $sc_cv_struct_timespec = yes; then
1103 AC_DEFINE(HAVE_STRUCT_TIMESPEC)
1105 AC_MSG_RESULT($sc_cv_struct_timespec)
1108 # struct linger; FreeBSD requires sys/types.h for sys/socket.h
1109 AC_MSG_CHECKING(for struct linger)
1110 AC_CACHE_VAL(sc_cv_struct_linger,
1111 [AC_TRY_COMPILE([#include <sys/types.h>
1112 #include <sys/socket.h>],[struct linger s;],
1113 [sc_cv_struct_linger=yes],
1114 [sc_cv_struct_linger=no])])
1115 if test $sc_cv_struct_linger = yes; then
1116 AC_DEFINE(HAVE_STRUCT_LINGER)
1118 AC_MSG_RESULT($sc_cv_struct_linger)
1121 # struct ip_mreq (for multicasting options)
1122 AC_MSG_CHECKING(for struct ip_mreq)
1123 AC_CACHE_VAL(sc_cv_struct_ip_mreq,
1124 [AC_TRY_COMPILE([#include <sys/types.h>
1125 #include <sys/socket.h>
1126 #include <netinet/in.h>],[struct ip_mreq s;],
1127 [sc_cv_struct_ip_mreq=yes],
1128 [sc_cv_struct_ip_mreq=no])])
1129 if test $sc_cv_struct_ip_mreq = yes; then
1130 AC_DEFINE(HAVE_STRUCT_IP_MREQ)
1132 AC_MSG_RESULT($sc_cv_struct_ip_mreq)
1134 # struct ip_mreqn (for multicasting options)
1135 AC_MSG_CHECKING(for struct ip_mreqn)
1136 AC_CACHE_VAL(sc_cv_struct_ip_mreqn,
1137 [AC_TRY_COMPILE([#include <sys/types.h>
1138 #include <sys/socket.h>
1139 #include <netinet/ip.h>],[struct ip_mreqn s;],
1140 [sc_cv_struct_ip_mreqn=yes],
1141 [sc_cv_struct_ip_mreqn=no])])
1142 if test $sc_cv_struct_ip_mreqn = yes; then
1143 AC_DEFINE(HAVE_STRUCT_IP_MREQN)
1145 AC_MSG_RESULT($sc_cv_struct_ip_mreqn)
1147 # struct ipv6_mreq (for multicasting options)
1148 AC_MSG_CHECKING(for struct ipv6_mreq)
1149 AC_CACHE_VAL(sc_cv_struct_ipv6_mreq,
1150 [AC_TRY_COMPILE([#include <sys/types.h>
1151 #include <sys/socket.h>
1152 #include <netinet/in.h>],[struct ipv6_mreq s;],
1153 [sc_cv_struct_ipv6_mreq=yes],
1154 [sc_cv_struct_ipv6_mreq=no])])
1155 if test $sc_cv_struct_ipv6_mreq = yes; then
1156 AC_DEFINE(HAVE_STRUCT_IPV6_MREQ)
1158 AC_MSG_RESULT($sc_cv_struct_ipv6_mreq)
1161 # struct ifreq (for network interfaces)
1162 AC_MSG_CHECKING(for struct ifreq)
1163 AC_CACHE_VAL(sc_cv_struct_ifreq,
1164 [AC_TRY_COMPILE([#include <sys/types.h>
1165 #include <sys/socket.h>
1166 #include <net/if.h>],[struct ifreq s;],
1167 [sc_cv_struct_ifreq=yes],
1168 [sc_cv_struct_ifreq=no])])
1169 if test $sc_cv_struct_ifreq = yes; then
1170 AC_DEFINE(HAVE_STRUCT_IFREQ)
1172 AC_MSG_RESULT($sc_cv_struct_ifreq)
1174 # struct ifreq.ifr_index
1175 # on most systems that have struct ifreq
1176 AC_MSG_CHECKING(for struct ifreq.ifr_index)
1177 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_index,
1178 [AC_TRY_COMPILE([#include <sys/types.h>
1179 #include <sys/socket.h>
1180 #include <net/if.h>],
1181 [struct ifreq ir;ir.ifr_index=0;],
1182 [sc_cv_struct_ifreq_ifr_index=yes],
1183 [sc_cv_struct_ifreq_ifr_index=no])])
1184 if test $sc_cv_struct_ifreq_ifr_index = yes; then
1185 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_INDEX)
1187 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_index)
1189 # struct ifreq.ifr_ifindex
1190 # Linux has ifr_ifindex instead of ifr_index
1191 AC_MSG_CHECKING(for struct ifreq.ifr_ifindex)
1192 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_ifindex,
1193 [AC_TRY_COMPILE([#include <sys/types.h>
1194 #include <sys/socket.h>
1195 #include <net/if.h>],
1196 [struct ifreq ir;ir.ifr_ifindex=0;],
1197 [sc_cv_struct_ifreq_ifr_ifindex=yes],
1198 [sc_cv_struct_ifreq_ifr_ifindex=no])])
1199 if test $sc_cv_struct_ifreq_ifr_ifindex = yes; then
1200 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_IFINDEX)
1202 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_ifindex)
1205 # some systems have a sa_len field in struct sockaddr and we need to support it
1206 # so we can compare sockaddrs simply with memcmp
1207 AC_MSG_CHECKING(for struct sockaddr.sa_len)
1208 AC_CACHE_VAL(sc_cv_struct_sockaddr_salen,
1209 [AC_TRY_COMPILE([#include <sys/types.h>
1210 #include <sys/socket.h>],
1211 [struct sockaddr sa;sa.sa_len=0;],
1212 [sc_cv_struct_sockaddr_salen=yes],
1213 [sc_cv_struct_sockaddr_salen=no])])
1214 if test $sc_cv_struct_sockaddr_salen = yes; then
1215 AC_DEFINE(HAVE_STRUCT_SOCKADDR_SALEN)
1217 AC_MSG_RESULT($sc_cv_struct_sockaddr_salen)
1219 ### IP6 sockaddr_in6
1221 AC_MSG_CHECKING(for component names of sockaddr_in6)
1222 AC_TRY_COMPILE([#include <sys/types.h>
1223 #include <netinet/in.h>],
1224 [struct sockaddr_in6 sa6;sa6.sin6_addr.s6_addr[0]=0;],
1225 [AC_MSG_RESULT(s6_addr);
1226 AC_DEFINE(HAVE_IP6_SOCKADDR, 0)],
1227 [AC_TRY_COMPILE([#include <sys/types.h>
1228 #include <netinet/in.h>],
1229 [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr.u6_addr16[0]=0;],
1230 [AC_MSG_RESULT(u6_addr.u6_addr16);
1231 AC_DEFINE(HAVE_IP6_SOCKADDR, 1)],
1232 [AC_TRY_COMPILE([#include <sys/types.h>
1233 #include <netinet/in.h>],
1234 [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr16[0]=0;],
1235 [AC_MSG_RESULT(u6_addr16); AC_DEFINE(HAVE_IP6_SOCKADDR, 2)],
1236 [AC_TRY_COMPILE([#include <sys/types.h>
1237 #include <netinet/in.h>],
1238 [struct sockaddr_in6 sa6;sa6.sin6_addr.in6_u.u6_addr16[0]=0;],
1239 [AC_MSG_RESULT(in6_u.u6_addr16);
1240 AC_DEFINE(HAVE_IP6_SOCKADDR, 3)],
1241 [AC_TRY_COMPILE([#include <sys/types.h>
1242 #include <netinet/in.h>],
1243 [struct sockaddr_in6 sa6;sa6.sin6_addr._S6_un._S6_u32[0]=0;],
1244 [AC_MSG_RESULT(_S6_un._S6_u32);
1245 AC_DEFINE(HAVE_IP6_SOCKADDR, 4)],
1246 [AC_TRY_COMPILE([#include <sys/types.h>
1247 #include <netinet/in.h>],
1248 [struct sockaddr_in6 sa6;sa6.sin6_addr.__u6_addr.__u6_addr32[0]=0;],
1249 [AC_MSG_RESULT(__u6_addr.__u6_addr32);
1250 AC_DEFINE(HAVE_IP6_SOCKADDR, 5)],
1252 [AC_MSG_RESULT([none or unknown])]
1255 dnl Check for struct iovec
1256 AC_MSG_CHECKING(for struct iovec)
1257 AC_CACHE_VAL(sc_cv_struct_iovec,
1258 [AC_TRY_COMPILE([#include <sys/uio.h>],[struct iovec s;],
1259 [sc_cv_struct_iovec=yes],
1260 [sc_cv_struct_iovec=no])])
1261 if test $sc_cv_struct_iovec = yes; then
1262 AC_DEFINE(HAVE_STRUCT_IOVEC)
1264 AC_MSG_RESULT($sc_cv_struct_iovec)
1266 dnl check for msg_control in struct msghdr
1267 AC_MSG_CHECKING(for struct msghdr.msg_control)
1268 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrol,
1269 [AC_TRY_COMPILE([#include <sys/types.h>
1270 #include <sys/socket.h>],
1271 [struct msghdr s;s.msg_control=0;],
1272 [sc_cv_struct_msghdr_msgcontrol=yes],
1273 [sc_cv_struct_msghdr_msgcontrol=no])])
1274 if test $sc_cv_struct_msghdr_msgcontrol = yes; then
1275 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROL)
1277 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrol)
1279 dnl check for msg_controllen in struct msghdr
1280 AC_MSG_CHECKING(for struct msghdr.msg_controllen)
1281 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrollen,
1282 [AC_TRY_COMPILE([#include <sys/types.h>
1283 #include <sys/socket.h>],
1284 [struct msghdr s;s.msg_controllen=0;],
1285 [sc_cv_struct_msghdr_msgcontrollen=yes],
1286 [sc_cv_struct_msghdr_msgcontrollen=no])])
1287 if test $sc_cv_struct_msghdr_msgcontrollen = yes; then
1288 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN)
1290 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrollen)
1292 dnl check for msg_flags in struct msghdr
1293 AC_MSG_CHECKING(for struct msghdr.msgflags)
1294 AC_CACHE_VAL(sc_cv_struct_msghdr_msgflags,
1295 [AC_TRY_COMPILE([#include <sys/types.h>
1296 #include <sys/socket.h>],
1297 [struct msghdr s;s.msg_flags=0;],
1298 [sc_cv_struct_msghdr_msgflags=yes],
1299 [sc_cv_struct_msghdr_msgflags=no])])
1300 if test $sc_cv_struct_msghdr_msgflags = yes; then
1301 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGFLAGS)
1303 AC_MSG_RESULT($sc_cv_struct_msghdr_msgflags)
1305 dnl check for struct cmsghdr
1306 AC_MSG_CHECKING(for struct cmsghdr)
1307 AC_CACHE_VAL(sc_cv_struct_cmsghdr,
1308 [AC_TRY_COMPILE([#include <sys/types.h>
1309 #include <sys/socket.h>
1310 #include <net/if.h>],[struct cmsghdr s;],
1311 [sc_cv_struct_cmsghdr=yes],
1312 [sc_cv_struct_cmsghdr=no])])
1313 if test $sc_cv_struct_cmsghdr = yes; then
1314 AC_DEFINE(HAVE_STRUCT_CMSGHDR)
1316 AC_MSG_RESULT($sc_cv_struct_cmsghdr)
1318 dnl check for struct in_pktinfo
1319 AC_MSG_CHECKING(for struct in_pktinfo)
1320 AC_CACHE_VAL(sc_cv_struct_in_pktinfo,
1321 [AC_TRY_COMPILE([#include <sys/types.h>
1322 #include <sys/socket.h>
1323 #include <netinet/in.h>],[struct in_pktinfo s;],
1324 [sc_cv_struct_in_pktinfo=yes],
1325 [sc_cv_struct_in_pktinfo=no])])
1326 if test $sc_cv_struct_in_pktinfo = yes; then
1327 AC_DEFINE(HAVE_STRUCT_IN_PKTINFO)
1329 AC_MSG_RESULT($sc_cv_struct_in_pktinfo)
1331 if test $sc_cv_struct_in_pktinfo = 'yes'; then
1332 dnl check for component ipi_spec_dst in struct in_pktinfo
1333 AC_MSG_CHECKING(for ipi_spec_dst in struct in_pktinfo)
1334 AC_CACHE_VAL(sc_cv_pktinfo_ipi_spec_dst,
1335 [AC_TRY_COMPILE([#include <sys/types.h>
1336 #include <sys/socket.h>
1337 #include <netinet/in.h>],[struct in_pktinfo s; s.ipi_spec_dst],
1338 [sc_cv_pktinfo_ipi_spec_dst=yes],
1339 [sc_cv_pktinfo_ipi_spec_dst=no])])
1340 if test $sc_cv_pktinfo_ipi_spec_dst = yes; then
1341 AC_DEFINE(HAVE_PKTINFO_IPI_SPEC_DST)
1343 AC_MSG_RESULT($sc_cv_pktinfo_ipi_spec_dst)
1346 dnl check for struct in6_pktinfo
1347 AC_MSG_CHECKING(for struct in6_pktinfo)
1348 AC_CACHE_VAL(sc_cv_struct_in6_pktinfo,
1349 [AC_TRY_COMPILE([#include "sysincludes.h"],
1350 [struct in6_pktinfo s;],
1351 [sc_cv_struct_in6_pktinfo=yes],
1352 [sc_cv_struct_in6_pktinfo=no])])
1353 if test $sc_cv_struct_in6_pktinfo = yes; then
1354 AC_DEFINE(HAVE_STRUCT_IN6_PKTINFO)
1356 AC_MSG_RESULT($sc_cv_struct_in6_pktinfo)
1358 dnl check for ip_hl in struct ip
1359 AC_MSG_CHECKING(for struct ip.ip_hl)
1360 AC_CACHE_VAL(sc_cv_struct_ip_ip_hl,
1361 [AC_TRY_COMPILE([#include <sys/types.h>
1362 #include <netinet/in_systm.h>
1363 #include <netinet/in.h>
1364 #include <netinet/ip.h>],
1365 [struct ip s;s.ip_hl=0;],
1366 [sc_cv_struct_ip_ip_hl=yes],
1367 [sc_cv_struct_ip_ip_hl=no])])
1368 if test $sc_cv_struct_ip_ip_hl = yes; then
1369 AC_DEFINE(HAVE_STRUCT_IP_IP_HL)
1371 AC_MSG_RESULT($sc_cv_struct_ip_ip_hl)
1374 dnl Library function checks
1376 dnl Check sigaction()
1377 AC_CHECK_FUNC(sigaction, AC_DEFINE(HAVE_SIGACTION))
1379 dnl Check for 64bit versions of system calls
1380 AC_CHECK_FUNC(stat64, AC_DEFINE(HAVE_STAT64))
1381 AC_CHECK_FUNC(fstat64, AC_DEFINE(HAVE_FSTAT64))
1382 AC_CHECK_FUNC(lstat64, AC_DEFINE(HAVE_LSTAT64))
1383 AC_CHECK_FUNC(lseek64, AC_DEFINE(HAVE_LSEEK64))
1384 AC_CHECK_FUNC(truncate64, AC_DEFINE(HAVE_TRUNCATE64))
1385 AC_CHECK_FUNC(ftruncate64, AC_DEFINE(HAVE_FTRUNCATE64))
1387 AC_CHECK_FUNC(strtoll, AC_DEFINE(HAVE_STRTOLL))
1388 AC_CHECK_FUNC(hstrerror, AC_DEFINE(HAVE_HSTRERROR))
1389 AC_CHECK_FUNC(inet_ntop, AC_DEFINE(HAVE_INET_NTOP))
1391 #if test "$ac_cv_func_hstrerror" = "yes"; then
1392 # AC_MSG_CHECKING(if _XOPEN_SOURCE_EXTENDED is helpful)
1393 # AC_CACHE_VAL(ac_cv_xopen_source_extended,
1394 # [AC_TRY_COMPILE([#include <netdb.h>],
1396 # [ac_cv_xopen_source_extended=no],
1397 # [AC_TRY_COMPILE([#define _XOPEN_SOURCE_EXTENDED 1
1398 ## include <netdb.h>],
1400 # [ac_cv_xopen_source_extended=yes],
1401 # [ac_cv_xopen_source_extended=no]
1404 # if test $ac_cv_xopen_source_extended = yes; then
1405 # AC_DEFINE(_XOPEN_SOURCE_EXTENDED)
1407 # AC_MSG_RESULT($ac_cv_xopen_source_extended)
1410 dnl Search for openpty()
1412 AC_CHECK_FUNC(openpty, AC_DEFINE(HAVE_OPENPTY))
1414 AC_CHECK_LIB(bsd, openpty,
1415 [LIBS="-lbsd $LIBS"; AC_DEFINE(HAVE_OPENPTY)])
1417 AC_CHECK_LIB(util, openpty,
1418 [LIBS="-lutil $LIBS"; AC_DEFINE(HAVE_OPENPTY)])
1420 AC_CHECK_LIB(rt, clock_gettime,
1421 [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_CLOCK_GETTIME)])
1423 dnl Search for flock()
1424 # with Linux it's in libc, with AIX in libbsd
1425 AC_CHECK_FUNC(flock, AC_DEFINE(HAVE_FLOCK),
1426 AC_CHECK_LIB(bsd, flock, [LIBS="-lbsd $LIBS"]))
1428 dnl Search for setenv()
1429 AC_CHECK_FUNC(setenv, AC_DEFINE(HAVE_SETENV),
1430 AC_CHECK_LIB(isode, setenv, [LIBS="-lisode $LIBS"]))
1432 dnl Search for unsetenv()
1433 AC_CHECK_FUNC(unsetenv, AC_DEFINE(HAVE_UNSETENV))
1435 dnl Search for SSLv2_client_method, SSLv2_server_method
1436 AC_CHECK_FUNC(SSLv2_client_method, AC_DEFINE(HAVE_SSLv2_client_method), AC_CHECK_LIB(crypt, SSLv2_client_method, [LIBS=-lcrypt $LIBS]))
1437 AC_CHECK_FUNC(SSLv2_server_method, AC_DEFINE(HAVE_SSLv2_server_method), AC_CHECK_LIB(crypt, SSLv2_server_method, [LIBS=-lcrypt $LIBS]))
1439 AC_CHECK_FUNC(SSL_CTX_set_default_verify_paths, AC_DEFINE(HAVE_SSL_CTX_set_default_verify_paths))
1441 AC_CHECK_FUNC(SSLv3_client_method, AC_DEFINE(HAVE_SSLv3_client_method), AC_CHECK_LIB(crypt, SSLv3_client_method, [LIBS=-lcrypt $LIBS]))
1442 AC_CHECK_FUNC(SSLv3_server_method, AC_DEFINE(HAVE_SSLv3_server_method), AC_CHECK_LIB(crypt, SSLv3_server_method, [LIBS=-lcrypt $LIBS]))
1443 AC_CHECK_FUNC(SSLv23_client_method, AC_DEFINE(HAVE_SSLv23_client_method), AC_CHECK_LIB(crypt, SSLv23_client_method, [LIBS=-lcrypt $LIBS]))
1444 AC_CHECK_FUNC(SSLv23_server_method, AC_DEFINE(HAVE_SSLv23_server_method), AC_CHECK_LIB(crypt, SSLv23_server_method, [LIBS=-lcrypt $LIBS]))
1445 AC_CHECK_FUNC(TLSv1_client_method, AC_DEFINE(HAVE_TLSv1_client_method), AC_CHECK_LIB(crypt, TLSv1_client_method, [LIBS=-lcrypt $LIBS]))
1446 AC_CHECK_FUNC(TLSv1_server_method, AC_DEFINE(HAVE_TLSv1_server_method), AC_CHECK_LIB(crypt, TLSv1_server_method, [LIBS=-lcrypt $LIBS]))
1447 AC_CHECK_FUNC(TLSv1_1_client_method, AC_DEFINE(HAVE_TLSv1_1_client_method), AC_CHECK_LIB(crypt, TLSv1_1_client_method, [LIBS=-lcrypt $LIBS]))
1448 AC_CHECK_FUNC(TLSv1_1_server_method, AC_DEFINE(HAVE_TLSv1_1_server_method), AC_CHECK_LIB(crypt, TLSv1_1_server_method, [LIBS=-lcrypt $LIBS]))
1449 AC_CHECK_FUNC(TLSv1_2_client_method, AC_DEFINE(HAVE_TLSv1_2_client_method), AC_CHECK_LIB(crypt, TLSv1_2_client_method, [LIBS=-lcrypt $LIBS]))
1450 AC_CHECK_FUNC(TLSv1_2_server_method, AC_DEFINE(HAVE_TLSv1_2_server_method), AC_CHECK_LIB(crypt, TLSv1_2_server_method, [LIBS=-lcrypt $LIBS]))
1451 AC_CHECK_FUNC(DTLSv1_client_method, AC_DEFINE(HAVE_DTLSv1_client_method), AC_CHECK_LIB(crypt, DTLSv1_client_method, [LIBS=-lcrypt $LIBS]))
1452 AC_CHECK_FUNC(DTLSv1_server_method, AC_DEFINE(HAVE_DTLSv1_server_method), AC_CHECK_LIB(crypt, DTLSv1_server_method, [LIBS=-lcrypt $LIBS]))
1457 AC_MSG_CHECKING(if snprintf conforms to C99)
1458 AC_CACHE_VAL(ac_cv_have_c99_snprintf,
1464 exit(snprintf(s,2,"ab")!=2);
1466 [ac_cv_have_c99_snprintf=yes],
1467 [ac_cv_have_c99_snprintf=no],
1468 [ac_cv_have_c99_snprintf=no])])
1469 if test $ac_cv_have_c99_snprintf = yes; then
1470 AC_DEFINE(HAVE_C99_SNPRINTF)
1472 AC_MSG_RESULT($ac_cv_have_c99_snprintf)
1475 AC_MSG_CHECKING(if printf has Z modifier)
1476 AC_CACHE_VAL(ac_cv_have_z_modifier,
1477 if test "$cc" = gcc; then
1484 exit(strcmp(s,"1"));
1486 [ac_cv_have_z_modifier=yes],
1487 [ac_cv_have_z_modifier=no],
1488 [ac_cv_have_z_modifier=no])]
1489 else ac_cv_have_z_modifier=no
1492 if test $ac_cv_have_z_modifier = yes; then
1493 AC_DEFINE(HAVE_FORMAT_Z)
1495 AC_MSG_RESULT($ac_cv_have_z_modifier)
1498 dnl find the number of bits we must shift a value to match the given mask
1499 dnl (e.g., mask 0x00f0 requires shifting with 4)
1500 ## NOTE: some platforms only need one '\' to escape '"' in string constant
1501 define(AC_SHIFT_OFFSET,[
1502 AC_CACHE_CHECK(shift offset of $1, $2,
1503 [LIBS1="$LIBS"; LIBS="" # avoid libwrap allow_severity undefined
1504 conftestoffset="conftestoffset.out"
1509 #include <termios.h>
1512 unsigned int i,n=$1;
1514 if ((f=fopen("$conftestoffset","w"))==NULL){
1515 fprintf(stderr,"\\"$conftestoffset\\": %s\n",strerror(errno)); exit(-1);
1517 if (n==0) {fprintf(stderr,"$1 is 0 (impossible!)\n"); exit(1);}
1518 i=0; while (!(n&1)) {
1521 fprintf(f, "%u", i);
1523 fprintf(f, "-1"); /* anticipate result of xioinitialize assert */
1528 [$2=`cat $conftestoffset`],
1533 AC_DEFINE_UNQUOTED($1_SHIFT, ${$2})
1534 if test "$2" = -1; then
1535 AC_MSG_WARN(please determine $1_SHIFT manually)
1539 AC_SHIFT_OFFSET(CRDLY, sc_cv_sys_crdly_shift)
1540 AC_SHIFT_OFFSET(TABDLY, sc_cv_sys_tabdly_shift)
1541 AC_SHIFT_OFFSET(CSIZE, sc_cv_sys_csize_shift)
1544 dnl Find what physical type (basic C type) is equivalent to the given type.
1545 dnl If possible we try to compile simple test code and get no warning only with
1546 dnl the matching type.
1547 dnl If this method does not seem to work we run test programs that print the
1548 dnl length and signedness of the type.
1550 dnl do we have a -Werror option?
1551 dnl Does the test code compile with -Werror when types fit?
1552 CHANCE_TO_TYPECHECK=1
1553 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1554 AC_TRY_COMPILE([#include <stdlib.h>],[int u; int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)
1557 dnl Does the test code compile without -Werror when types do not fit?
1558 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1559 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)
1562 dnl Does the test code fail to compile with -Werror when types do not fit?
1563 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1564 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1565 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],CHANCE_TO_TYPECHECK=0,)
1569 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1570 AC_MSG_NOTICE(using compile -Werror method to find basic types)
1572 AC_MSG_NOTICE(using code run method to find basic types)
1576 dnl see AC_BASIC_TYPE
1577 define(AC_BASIC_TYPE_GCC,[
1578 AC_CACHE_CHECK(for equivalent simple type of $2, $4,
1579 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1580 dnl echo "echo: trying short for $2" >&2
1581 AC_TRY_COMPILE([$1],[$2 u; short v; return(&u==&v);],
1582 [$4="1 /* short */"],
1583 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u==&v);],
1584 [$4="2 /* unsigned short */"],
1585 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u==&v);],
1587 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u==&v);],
1588 [$4="4 /* unsigned int */"],
1589 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u==&v);],
1590 [$4="5 /* long */"],
1591 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u==&v);],
1592 [$4="6 /* unsigned long */"],
1593 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u==&v);],
1594 [$4="7 /* long long */"],
1595 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u==&v);],
1596 [$4="8 /* unsigned long long */"],
1597 [$4="0 /* unknown, taking default */"
1598 ]) ]) ]) ]) ]) ]) ]) ])
1599 CFLAGS="$CFLAGS1" ])
1600 AC_DEFINE_UNQUOTED($3, ${$4})
1603 dnl see AC_BASIC_TYPE
1604 define(AC_BASIC_TYPE_OTHER,[
1605 AC_CACHE_CHECK(for equivalent simple type of $2, $4,
1608 int main() { return!(sizeof($2)==sizeof(short));}],
1609 # same length as short
1612 int main() { $2 x=-1; return !(x<0);}],
1613 [$4="1 /* short */"],
1614 [$4="2 /* unsigned short */"]),
1615 # length differs from short, try others
1618 int main() { return!(sizeof($2)==sizeof(int));}],
1619 # same length as int
1622 int main() { $2 x=-1; return !(x<0);}],
1624 [$4="4 /* unsigned int */"]),
1625 # length differs from int, try others
1628 int main() { return !(sizeof($2)==sizeof(long));}],
1629 # same length as long
1632 int main() { $2 x=-1; return !(x<0);}],
1633 [$4="5 /* long */"],
1634 [$4="6 /* unsigned long */"] ),
1635 # length differs from long, try others
1638 int main() { return !(sizeof($2)==sizeof(long long));}],
1639 # same length as long long
1642 int main() { $2 x=-1; return !(x<0);}],
1643 [$4="7 /* long long */"],
1644 [$4="8 /* unsigned long long */"] ),
1645 [$4="0 /* unknown */"]
1651 AC_DEFINE_UNQUOTED($3, ${$4})
1654 dnl find what physical type (basic C type) is equivalent to the given type.
1655 dnl arg1: include file(s)
1657 dnl arg3: output variable
1658 dnl arg4: cache variable (might be constructed automatically)
1659 dnl output values: 1..short, 2..unsigned short, 3..int, 4..u-int,
1660 dnl 5..long, 6..u-long; others not yet supported
1661 define(AC_BASIC_TYPE,[
1662 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1663 AC_BASIC_TYPE_GCC([$1],[$2],[$3],[$4])
1665 AC_BASIC_TYPE_OTHER([$1],[$2],[$3],[$4])
1670 dnl See AC_TYPEOF_COMPONENT
1671 dnl This version is for compilers with -Werror or so: gcc, clang, Sun Studio?
1672 define(AC_TYPEOF_COMPONENT_GCC,[
1673 AC_CACHE_CHECK(for basic type of $2.$3, $5,
1674 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1675 AC_TRY_COMPILE([$1],[$2 u;short v; return(&u.$3==&v);],
1676 [$5="1 /* short */"],
1677 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u.$3==&v);],
1678 [$5="2 /* unsigned short */"],
1679 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u.$3==&v);],
1681 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u.$3==&v);],
1682 [$5="4 /* unsigned int */"],
1683 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u.$3==&v);],
1684 [$5="5 /* long */"],
1685 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u.$3==&v);],
1686 [$5="6 /* unsigned long */"],
1687 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u.$3==&v);],
1688 [$5="7 /* long long */"],
1689 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u.$3==&v);],
1690 [$5="8 /* unsigned long long */"],
1691 [$5="0 /* unknown, taking default */"
1692 ]) ]) ]) ]) ]) ]) ]) ])
1693 CFLAGS="$CFLAGS1" ])
1694 AC_DEFINE_UNQUOTED($4, ${$5})
1697 dnl See AC_TYPEOF_COMPONENT
1698 dnl This version is for compilers with no -Werror or so
1699 define(AC_TYPEOF_COMPONENT_OTHER,[
1700 AC_CACHE_CHECK(for basic type of $2.$3, $5,
1703 int main() { $2 x; return!(sizeof(x.$3)==sizeof(short));}],
1704 # same length as short
1707 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
1708 [$5="1 /* short */"],
1709 [$5="2 /* unsigned short */"]),
1710 # length differs from short, try others
1713 int main() { $2 x; return!(sizeof(x.$3)==sizeof(int));}],
1714 # same length as int
1717 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
1719 [$5="4 /* unsigned int */"]),
1720 # length differs from int, try others
1723 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long));}],
1724 # same length as long
1727 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
1728 [$5="5 /* long */"],
1729 [$5="6 /* unsigned long */"] ),
1730 # length differs from long, try others
1733 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long long));}],
1734 # same length as long long
1737 int main() { x $2; x.$3=-1; return !(x.$3<0);}],
1738 [$5="7 /* long long */"],
1739 [$5="8 /* unsigned long long */"] ),
1740 [$5="0 /* unknown */"]
1746 AC_DEFINE_UNQUOTED($4, ${$5})
1749 dnl find what physical type (basic C type) describes the given struct or union
1751 dnl arg1: include file(s); must declare the structure type
1752 dnl arg2: struct name (e.g., "struct stat")
1753 dnl arg3: variable or component (e.g., "st_ino")
1754 dnl arg4: output variable, values see AC_BASIC_TYPE
1755 dnl arg5: cache variable (might be constructed automatically)
1756 define(AC_TYPEOF_COMPONENT,[
1757 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1758 AC_TYPEOF_COMPONENT_GCC([$1],[$2],[$3],[$4],[$5])
1760 AC_TYPEOF_COMPONENT_OTHER([$1],[$2],[$3],[$4],[$5])
1764 AC_BASIC_TYPE([#include <stdlib.h>], size_t, HAVE_BASIC_SIZE_T, sc_cv_type_sizet_basic)
1765 AC_BASIC_TYPE([#include <sys/types.h>
1766 #include <sys/stat.h>
1767 #include <unistd.h>], mode_t, HAVE_BASIC_MODE_T, sc_cv_type_modet_basic)
1768 AC_BASIC_TYPE([#include <sys/types.h>
1769 #include <unistd.h>], pid_t, HAVE_BASIC_PID_T, sc_cv_type_pidt_basic)
1770 AC_BASIC_TYPE([#include <sys/types.h>
1771 #include <unistd.h>], uid_t, HAVE_BASIC_UID_T, sc_cv_type_uidt_basic)
1772 AC_BASIC_TYPE([#include <sys/types.h>
1773 #include <unistd.h>], gid_t, HAVE_BASIC_GID_T, sc_cv_type_gidt_basic)
1775 AC_BASIC_TYPE([#include <time.h>], time_t, HAVE_BASIC_TIME_T,
1776 sc_cv_type_timet_basic)
1778 # this is questionable, might fail on some systems
1779 AC_BASIC_TYPE([#include <sys/types.h>
1780 #include <sys/socket.h>
1781 #include <unistd.h>], socklen_t, HAVE_BASIC_SOCKLEN_T,
1782 sc_cv_type_socklent_basic)
1784 AC_BASIC_TYPE([#include <sys/types.h>
1785 #include <unistd.h>], off_t, HAVE_BASIC_OFF_T, sc_cv_type_off_basic)
1787 AC_BASIC_TYPE([#include <sys/types.h>
1788 #include <unistd.h>], off64_t, HAVE_BASIC_OFF64_T, sc_cv_type_off64_basic)
1790 # oh god, __dev_t in Linux 2.4 is struct{int[2];}, not handled here yet.
1791 AC_BASIC_TYPE([#include <sys/stat.h>], dev_t, HAVE_BASIC_DEV_T, sc_cv_type_dev_basic)
1793 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_ino, HAVE_TYPEOF_ST_INO, sc_cv_type_stat_stino_basic)
1794 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_nlink, HAVE_TYPEOF_ST_NLINK, sc_cv_type_stat_stnlink_basic)
1795 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_size, HAVE_TYPEOF_ST_SIZE, sc_cv_type_stat_stsize_basic)
1796 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blksize, HAVE_TYPEOF_ST_BLKSIZE, sc_cv_type_stat_stblksize_basic)
1797 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blocks, HAVE_TYPEOF_ST_BLOCKS, sc_cv_type_stat_stblocks_basic)
1799 if test "$ac_cv_func_stat64" = yes; then
1800 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_dev, HAVE_TYPEOF_ST64_DEV, sc_cv_type_stat64_stdev_basic)
1801 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_ino, HAVE_TYPEOF_ST64_INO, sc_cv_type_stat64_stino_basic)
1802 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_nlink, HAVE_TYPEOF_ST64_NLINK, sc_cv_type_stat64_stnlink_basic)
1803 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_size, HAVE_TYPEOF_ST64_SIZE, sc_cv_type_stat64_stsize_basic)
1804 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blksize, HAVE_TYPEOF_ST64_BLKSIZE, sc_cv_type_stat64_stblksize_basic)
1805 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blocks, HAVE_TYPEOF_ST64_BLOCKS, sc_cv_type_stat64_stblocks_basic)
1808 AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timeval, tv_usec, HAVE_TYPEOF_STRUCT_TIMEVAL_TV_USEC, sc_cv_type_struct_timeval_tv_usec)
1810 AC_TYPEOF_COMPONENT([#include <sys/types.h>
1811 #include <sys/time.h>
1812 #include <sys/resource.h>],
1813 struct rlimit, rlim_max, HAVE_TYPEOF_RLIM_MAX, sc_cv_type_rlimit_rlimmax_basic)
1815 # Fedora-19 doc says it is socklen_t which is equivalent to unsigned int, but it is equivalent to size_t (x86_64)
1816 AC_TYPEOF_COMPONENT([#include "sysincludes.h"], struct cmsghdr, cmsg_len, HAVE_TYPEOF_STRUCT_CMSGHDR_CMSG_LEN, sc_cv_typeof_struct_cmsghdr_cmsg_len)
1817 ### snprintf, vsnprintf
1820 AC_MSG_CHECKING(for /dev/ptmx)
1821 if test -c /dev/ptmx; then
1822 AC_DEFINE(HAVE_DEV_PTMX, 1)
1826 AC_MSG_CHECKING(for /dev/ptc)
1827 if test -c /dev/ptc; then
1828 AC_DEFINE(HAVE_DEV_PTC)
1835 AC_MSG_CHECKING(for /proc)
1836 if test -d /proc; then
1837 AC_DEFINE(HAVE_PROC_DIR, 1)
1843 AC_MSG_CHECKING(for /proc/*/fd)
1844 if test -d /proc/$$/fd; then
1845 AC_DEFINE(HAVE_PROC_DIR_FD, 1)
1851 dnl "tcpd" "tcpwrappers"
1852 # on some platforms, raw linking with libwrap fails because allow_severity and
1853 # deny_severity are not explicitely defined. Thus we put the libwrap part to
1855 AC_MSG_CHECKING(whether to include libwrap support)
1856 AC_ARG_ENABLE(libwrap, [ --disable-libwrap disable libwrap support],
1857 [ case "$enableval" in
1858 no) AC_MSG_RESULT(no); WITH_LIBWRAP= ;;
1859 *) AC_MSG_RESULT(yes); WITH_LIBWRAP=1 ;;
1861 [ AC_MSG_RESULT(yes); WITH_LIBWRAP=1 ])
1863 # check if we find the components of libwrap ("tcpd" "tcpwrappers")
1864 if test -n "$WITH_LIBWRAP"; then
1865 AC_MSG_CHECKING(for components of libwrap)
1866 # first, we need to find the include file <tcpd.h>
1867 AC_CACHE_VAL(sc_cv_have_tcpd_h,
1868 [AC_TRY_COMPILE([#include <sys/types.h>
1869 #include <tcpd.h>],[;],
1870 [sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT=""],
1871 [sc_cv_have_tcpd_h=no
1872 for D in "/sw" "/usr/local" "/opt/freeware" "/usr/sfw"; do
1875 if test -r "$i"; then
1876 #V_INCL="$V_INCL -I$I"
1877 CPPFLAGS="$CPPFLAGS -I$I"
1878 AC_MSG_NOTICE(found $i)
1879 sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT="$D"
1884 if test "$sc_cv_have_tcpd_h" = "yes"; then
1885 AC_DEFINE(HAVE_TCPD_H)
1887 AC_MSG_NOTICE(checked for tcpd.h... $sc_cv_have_tcpd_h)
1888 fi # end checking for tcpd.h
1889 if test -n "$WITH_LIBWRAP" -a "$sc_cv_have_tcpd_h" = yes; then
1890 # next, we search for the wrap library (libwrap.*)
1891 AC_MSG_CHECKING(for libwrap)
1892 AC_CACHE_VAL(sc_cv_have_libwrap,
1894 if test -n "$LIBWRAP_ROOT"; then
1895 L="$LIBWRAP_ROOT/lib"; LIBS="-L$L -lwrap $LIBS"
1899 AC_TRY_LINK([#include <sys/types.h>
1901 int allow_severity,deny_severity;],[hosts_access(0)],
1902 [sc_cv_have_libwrap='yes'],
1903 [sc_cv_have_libwrap='no'
1904 LIBS="$LIBS -lnsl" # RedHat73
1905 AC_TRY_LINK([#include <sys/types.h>
1907 int allow_severity,deny_severity;],[hosts_access(0)],
1908 [sc_cv_have_libwrap='yes'],
1909 [sc_cv_have_libwrap='no'])
1912 if test "$sc_cv_have_libwrap" != 'yes'; then
1917 if test "$sc_cv_have_libwrap" = 'yes'; then
1918 AC_DEFINE(HAVE_LIBWRAP)
1920 AC_MSG_RESULT($sc_cv_have_libwrap)
1923 if test -n "$WITH_LIBWRAP"; then
1924 if test "$sc_cv_have_tcpd_h" = "yes" -a "$sc_cv_have_libwrap" = "yes"; then
1925 AC_DEFINE(WITH_LIBWRAP)
1927 AC_MSG_WARN([not all components of tcp wrappers found, disabling it]);
1931 # check of hosts_allow_table
1932 if test -n "$WITH_LIBWRAP"; then
1933 AC_MSG_CHECKING(for hosts_allow_table)
1934 AC_CACHE_VAL(sc_cv_have_hosts_allow_table,
1935 [AC_TRY_COMPILE([#include <sys/types.h>
1936 #include <tcpd.h>],[hosts_allow_table="";],
1937 [sc_cv_have_hosts_allow_table=yes],
1938 [sc_cv_have_hosts_allow_table=no])])
1939 if test $sc_cv_have_hosts_allow_table = yes; then
1940 AC_DEFINE(HAVE_HOSTS_ALLOW_TABLE)
1942 AC_MSG_RESULT($sc_cv_have_hosts_allow_table)
1943 fi # test -n "$WITH_LIBWRAP"
1946 if test "$GCC" = yes; then
1950 # FIPS support requires compiling with fipsld.
1951 # fipsld requires the FIPSLD_CC variable to be set to the original CC.
1952 # This check must be done after all other checks that require compiling
1953 # so that fipsld is not used by the configure script itself.
1954 if test -n "$WITH_FIPS"; then
1955 if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then
1957 if test "${FIPSLD+set}" != set ; then
1960 CC="FIPSLD_CC=$CC $FIPSLD"
1965 # autoconf does not seem to provide AC_CHECK_VAR or so
1966 # thus we have to check by foot
1967 AC_MSG_CHECKING(for declaration of environ)
1968 AC_CACHE_VAL(sc_cv_decl_environ,
1969 [AC_TRY_COMPILE([#include <unistd.h>],[char **s = environ;],
1970 [sc_cv_decl_environ=yes],
1971 [sc_cv_decl_environ=no])])
1972 if test $sc_cv_decl_environ = yes; then
1973 AC_DEFINE(HAVE_DECL_ENVIRON)
1975 AC_MSG_RESULT($sc_cv_decl_environ)
1977 # on some systems environ exists but not the declaration
1978 AC_MSG_CHECKING(for var environ)
1979 AC_CACHE_VAL(sc_cv_var_environ,
1980 [AC_TRY_COMPILE([],[extern char **environ; char **s = environ;],
1981 [sc_cv_var_environ=yes],
1982 [sc_cv_var_environ=no])])
1983 if test $sc_cv_var_environ = yes; then
1984 AC_DEFINE(HAVE_VAR_ENVIRON)
1986 AC_MSG_RESULT($sc_cv_var_environ)
1988 # allow BUILD_DATE to be externally set for build reproducibility
1989 if test "$BUILD_DATE"; then
1990 AC_DEFINE_UNQUOTED(BUILD_DATE, ["$BUILD_DATE"])
1992 AC_DEFINE(BUILD_DATE, [__DATE__" "__TIME__])