1 dnl source: configure.ac
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=`$CC -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"
35 dnl Checks for programs.
36 AC_PROG_INSTALL(install)
40 AC_CHECK_PROG(AR, ar, ar, gar)
42 # we need to explicitely call this here; otherwise, with --disable-libwrap we
44 AC_LANG_COMPILER_REQUIRE()
46 if test "$GCC" = yes; then
47 CFLAGS="$CFLAGS -D_GNU_SOURCE -Wall -Wno-parentheses"
48 ERRONWARN="-Werror -O0"
49 elif test "$CC" = "clang"; then
50 CFLAGS="$CFLAGS -D_GNU_SOURCE -Wall -Wno-parentheses"
51 ERRONWARN="-Werror -O0"
53 # ERRONWARN="-errwarn"
60 dnl Checks for header files.
62 AC_CHECK_HEADERS(stdbool.h)
63 AC_CHECK_HEADERS(inttypes.h)
65 AC_CHECK_HEADERS(fcntl.h limits.h strings.h sys/param.h sys/ioctl.h sys/time.h syslog.h unistd.h)
66 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)
67 AC_CHECK_HEADERS(pty.h)
68 AC_CHECK_HEADERS(netinet/in.h netinet/in_systm.h)
69 AC_CHECK_HEADERS(netinet/ip.h, [], [], [AC_INCLUDES_DEFAULT
70 #if HAVE_NETINET_IN_H && HAVE_NETINET_IN_SYSTM_H
71 #include <netinet/in.h>
72 #include <netinet/in_systm.h>
73 #endif]) # Solaris prerequisites for netinet/ip.h
74 AC_CHECK_HEADERS(netinet/tcp.h)
75 AC_CHECK_HEADER(net/if.h, AC_DEFINE(HAVE_NET_IF_H), [], [AC_INCLUDES_DEFAULT
77 #include <sys/socket.h>
78 #endif]) # Mac OS X requires including sys/socket.h
79 AC_CHECK_HEADERS(arpa/nameser.h)
83 AC_CHECK_HEADERS(termios.h linux/if_tun.h)
84 AC_CHECK_HEADERS(net/if_dl.h)
85 AC_CHECK_HEADERS(linux/types.h)
86 AC_CHECK_HEADER(linux/errqueue.h, AC_DEFINE(HAVE_LINUX_ERRQUEUE_H), [], [#include <sys/time.h>
87 #include <linux/types.h>])
88 AC_CHECK_HEADERS(sys/utsname.h sys/select.h sys/file.h)
89 AC_CHECK_HEADERS(util.h bsd/libutil.h libutil.h sys/stropts.h regex.h)
90 AC_CHECK_HEADERS(linux/fs.h linux/ext2_fs.h)
92 dnl Checks for setgrent, getgrent and endgrent.
93 AC_CHECK_FUNCS(setgrent getgrent endgrent)
94 dnl Checks for getgrouplist() /* BSD */
95 AC_CHECK_FUNCS(getgrouplist)
96 AC_CHECK_FUNCS(cfmakeraw)
98 dnl Link libresolv if necessary (for Mac OS X)
99 AC_SEARCH_LIBS([res_9_init], [resolv])
102 dnl Check for extra socket library (for Solaris)
103 AC_CHECK_FUNC(hstrerror, , AC_CHECK_LIB(resolv, hstrerror, [LIBS="$LIBS -lresolv"; AC_DEFINE(HAVE_HSTRERROR)]))
104 AC_CHECK_FUNC(gethostent, , AC_CHECK_LIB(nsl, gethostent))
105 AC_CHECK_FUNC(setsockopt, , AC_CHECK_LIB(socket, setsockopt))
107 dnl Check for function prototype and in lib
108 dnl arg1: function name
109 dnl arg2: required include files beyond sysincludes.h
110 define(AC_CHECK_PROTOTYPE_LIB,[
111 AC_MSG_CHECKING(for $1 prototype)
112 AC_CACHE_VAL(sc_cv_have_prototype_lib_$1,
113 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN -Wall $CFLAGS1";
114 AC_TRY_LINK([#include "sysincludes.h"
115 $2],[return(&$1==(void *)&$1);],
116 [sc_cv_have_prototype_lib_$1=yes],
117 [sc_cv_have_prototype_lib_$1=no]);
119 if test $sc_cv_have_prototype_lib_$1 = yes; then
120 AC_DEFINE(HAVE_PROTOTYPE_LIB_$1)
122 AC_MSG_RESULT($sc_cv_have_prototype_lib_$1)
126 dnl Check for hstrerror prototype
127 AC_MSG_CHECKING(for hstrerror prototype)
128 AC_CACHE_VAL(sc_cv_have_prototype_hstrerror,
129 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')";
130 AC_TRY_COMPILE([#include <netdb.h>],[hstrerror();],
131 [sc_cv_have_prototype_hstrerror=no],
132 [sc_cv_have_prototype_hstrerror=yes]);
134 if test $sc_cv_have_prototype_hstrerror = yes; then
135 AC_DEFINE(HAVE_PROTOTYPE_HSTRERROR)
137 AC_MSG_RESULT($sc_cv_have_prototype_hstrerror)
139 # getprotobynumber_r() is not standardized
140 AC_MSG_CHECKING(for getprotobynumber_r() variant)
141 AC_CACHE_VAL(sc_cv_getprotobynumber_r,
142 [AC_TRY_LINK([#include <stddef.h>
143 #include <netdb.h>],[getprotobynumber_r(1,NULL,NULL,1024,NULL);],
144 [sc_cv_getprotobynumber_r=1; tmp_bynum_variant=Linux],
145 [AC_TRY_LINK([#include <stddef.h>
146 #include <netdb.h>],[getprotobynumber_r(1,NULL,NULL,1024);],
147 [sc_cv_getprotobynumber_r=2; tmp_bynum_variant=Solaris],
148 [AC_TRY_LINK([#include <stddef.h>
149 #include <netdb.h>],[getprotobynumber_r(1,NULL,NULL);],
150 [sc_cv_getprotobynumber_r=3; tmp_bynum_variant=AIX],
152 [sc_cv_getprotobynumber_r=]
154 if test "$sc_cv_getprotobynumber_r"; then
155 AC_DEFINE_UNQUOTED(HAVE_GETPROTOBYNUMBER_R, $sc_cv_getprotobynumber_r)
157 AC_MSG_RESULT($sc_cv_getprotobynumber_r /* $tmp_bynum_variant */)
160 AC_MSG_CHECKING(whether to include help)
161 AC_ARG_ENABLE(help, [ --disable-help disable help],
162 [case "$enableval" in
163 no) AC_MSG_RESULT(no);;
164 *) AC_DEFINE(WITH_HELP) AC_MSG_RESULT(yes);;
166 [AC_DEFINE(WITH_HELP) AC_MSG_RESULT(yes)])
168 AC_MSG_CHECKING(whether to include transfer statistics)
169 AC_ARG_ENABLE(stats, [ --disable-stats disable stats],
170 [case "$enableval" in
171 no) AC_MSG_RESULT(no);;
172 *) AC_DEFINE(WITH_STATS) AC_MSG_RESULT(yes);;
174 [AC_DEFINE(WITH_STATS) AC_MSG_RESULT(yes)])
176 AC_MSG_CHECKING(whether to include STDIO support)
177 AC_ARG_ENABLE(stdio, [ --disable-stdio disable STDIO support],
178 [case "$enableval" in
179 no) AC_MSG_RESULT(no);;
180 *) AC_DEFINE(WITH_STDIO) AC_MSG_RESULT(yes);;
182 [AC_DEFINE(WITH_STDIO) AC_MSG_RESULT(yes)])
184 AC_MSG_CHECKING(whether to include FD-number support)
185 AC_ARG_ENABLE(fdnum, [ --disable-fdnum disable FD-number support],
186 [case "$enableval" in
187 no) AC_MSG_RESULT(no);;
188 *) AC_DEFINE(WITH_FDNUM) AC_MSG_RESULT(yes);;
190 [AC_DEFINE(WITH_FDNUM) AC_MSG_RESULT(yes)])
192 AC_MSG_CHECKING(whether to include direct file support)
193 AC_ARG_ENABLE(file, [ --disable-file disable direct file support],
194 [case "$enableval" in
195 no) AC_MSG_RESULT(no);;
196 *) AC_DEFINE(WITH_FILE) AC_MSG_RESULT(yes);;
198 [AC_DEFINE(WITH_FILE) AC_MSG_RESULT(yes)])
200 AC_MSG_CHECKING(whether to include direct create support)
201 AC_ARG_ENABLE(creat, [ --disable-creat disable direct create support],
202 [case "$enableval" in
203 no) AC_MSG_RESULT(no);;
204 *) AC_DEFINE(WITH_CREAT) AC_MSG_RESULT(yes);;
206 [AC_DEFINE(WITH_CREAT) AC_MSG_RESULT(yes)])
208 AC_MSG_CHECKING(whether to include gopen support)
209 AC_ARG_ENABLE(gopen, [ --disable-gopen disable open for UNIX socket support],
210 [case "$enableval" in
211 no) AC_MSG_RESULT(no);;
212 *) AC_DEFINE(WITH_GOPEN) AC_MSG_RESULT(yes);;
214 [AC_DEFINE(WITH_GOPEN) AC_MSG_RESULT(yes)])
216 AC_MSG_CHECKING(whether to include explicit pipe support)
217 AC_ARG_ENABLE(pipe, [ --disable-pipe disable pipe support],
218 [case "$enableval" in
219 no) AC_MSG_RESULT(no);;
220 *) AC_DEFINE(WITH_PIPE) AC_MSG_RESULT(yes);;
222 [AC_DEFINE(WITH_PIPE) AC_MSG_RESULT(yes)])
224 AC_MSG_CHECKING(whether to include explicit socketpair support)
225 AC_ARG_ENABLE(socketpair, [ --disable-socketpair disable socketpair support],
226 [case "$enableval" in
227 no) AC_MSG_RESULT(no);;
228 *) AC_DEFINE(WITH_SOCKETPAIR) AC_MSG_RESULT(yes);;
230 [AC_DEFINE(WITH_SOCKETPAIR) AC_MSG_RESULT(yes)])
232 AC_MSG_CHECKING(whether to include explicit termios support)
233 AC_ARG_ENABLE(termios, [ --disable-termios disable termios support],
234 [case "$enableval" in
235 no) AC_MSG_RESULT(no);;
236 *) AC_DEFINE(WITH_TERMIOS) AC_MSG_RESULT(yes);;
238 [AC_DEFINE(WITH_TERMIOS) AC_MSG_RESULT(yes)])
240 AC_MSG_CHECKING(whether to include UNIX socket support)
241 AC_ARG_ENABLE(unix, [ --disable-unix disable UNIX domain socket support],
242 [case "$enableval" in
243 no) AC_MSG_RESULT(no);;
244 *) AC_DEFINE(WITH_UNIX) AC_MSG_RESULT(yes);;
246 [AC_DEFINE(WITH_UNIX) AC_MSG_RESULT(yes)])
248 AC_MSG_CHECKING(whether to include abstract UNIX socket support)
249 AC_ARG_ENABLE(abstract_unixsocket, [ --disable-abstract-unixsocket disable abstract UNIX domain socket support],
250 [case "$enableval" in
251 no) AC_MSG_RESULT(no);;
252 *) AC_DEFINE(WITH_ABSTRACT_UNIXSOCKET) AC_MSG_RESULT(yes);;
256 AC_DEFINE(WITH_ABSTRACT_UNIXSOCKET) AC_MSG_RESULT(yes);;
261 AC_MSG_CHECKING(whether to include IPv4 support)
262 AC_ARG_ENABLE(ip4, [ --disable-ip4 disable IPv4 support],
263 [case "$enableval" in
264 no) AC_MSG_RESULT(no);;
265 *) AC_DEFINE(WITH_IP4) AC_MSG_RESULT(yes);;
267 [AC_DEFINE(WITH_IP4) AC_MSG_RESULT(yes)])
269 AC_MSG_CHECKING(whether to include IPv6 support)
270 AC_ARG_ENABLE(ip6, [ --disable-ip6 disable IPv6 support],
271 [case "$enableval" in
272 no) AC_MSG_RESULT(no); WITH_IP6= ;;
273 *) AC_MSG_RESULT(yes); WITH_IP6=1 ;;
275 [ AC_MSG_RESULT(yes); WITH_IP6=1 ])
276 if test "$WITH_IP6"; then
277 AC_CHECK_HEADERS([netinet/ip6.h],
278 [AC_DEFINE(HAVE_NETINET_IP6_H) AC_DEFINE(WITH_IP6)],
279 [AC_MSG_WARN([include file netinet/ip6.h not found, disabling IP6])],
281 #ifdef HAVE_NETINET_IN_H
282 # include <netinet/in.h>
284 #ifdef HAVE_NETINET_IP_H
285 # include <netinet/ip.h>
287 AC_CHECK_HEADERS(netinet6/in6.h) # found on OpenBSD and Lion, used for IPV6_*
289 AC_MSG_CHECKING(if __APPLE_USE_RFC_2292 is helpful)
290 AC_CACHE_VAL(ac_cv_apple_use_rfc_2292,
291 [AC_TRY_COMPILE(,[#ifndef IPV6_HOPOPTS
294 [ac_cv_apple_use_rfc_2292=no],
295 [AC_TRY_COMPILE([#define __APPLE_USE_RFC_2292],
296 [#ifndef IPV6_HOPOPTS
299 [ac_cv_apple_use_rfc_2292=yes],
300 [ac_cv_apple_use_rfc_2292=no]
303 if test "$ac_cv_apple_use_rfc_2292" = yes; then
304 AC_DEFINE(__APPLE_USE_RFC_2292)
306 AC_MSG_RESULT($ac_cv_apple_use_rfc_2292)
310 AC_MSG_CHECKING(whether to include raw IP support)
311 AC_ARG_ENABLE(rawip, [ --disable-rawip disable raw IP support],
312 [case "$enableval" in
313 no) AC_MSG_RESULT(no);;
314 *) AC_DEFINE(WITH_RAWIP) AC_MSG_RESULT(yes);;
316 [AC_DEFINE(WITH_RAWIP) AC_MSG_RESULT(yes)])
318 AC_MSG_CHECKING(whether to include generic socket support)
319 AC_ARG_ENABLE(genericsocket, [ --disable-genericsocket disable generic socket support],
320 [case "$enableval" in
321 no) AC_MSG_RESULT(no);;
322 *) AC_DEFINE(WITH_GENERICSOCKET) AC_MSG_RESULT(yes);;
324 [AC_DEFINE(WITH_GENERICSOCKET) AC_MSG_RESULT(yes)])
326 AC_MSG_CHECKING(whether to include generic network interface support)
327 AC_ARG_ENABLE(interface, [ --disable-interface disable network interface support],
328 [case "$enableval" in
329 no) AC_MSG_RESULT(no); WITH_INTERFACE= ;;
330 *) AC_MSG_RESULT(yes); WITH_INTERFACE=1 ;;
332 [AC_MSG_RESULT(yes); WITH_INTERFACE=1 ])
334 AC_MSG_CHECKING(whether to include TCP support)
335 AC_ARG_ENABLE(tcp, [ --disable-tcp disable TCP support],
336 [case "$enableval" in
337 no) AC_MSG_RESULT(no);;
338 *) AC_DEFINE(WITH_TCP) AC_MSG_RESULT(yes);;
340 [AC_DEFINE(WITH_TCP) AC_MSG_RESULT(yes)])
342 AC_MSG_CHECKING(whether to include UDP support)
343 AC_ARG_ENABLE(udp, [ --disable-udp disable UDP support],
344 [case "$enableval" in
345 no) AC_MSG_RESULT(no);;
346 *) AC_DEFINE(WITH_UDP) AC_MSG_RESULT(yes);;
348 [AC_DEFINE(WITH_UDP) AC_MSG_RESULT(yes)])
350 AC_MSG_CHECKING(whether to include UDP-Lite support)
351 AC_ARG_ENABLE(udplite, [ --disable-udplite disable UDP-Lite support],
352 [case "$enableval" in
353 no) AC_MSG_RESULT(no); WITH_UDPLITE= ;;
354 *) AC_MSG_RESULT(yes); WITH_UDPLITE=1 ;;
356 [AC_MSG_RESULT(yes); WITH_UDPLITE=1 ])
357 if test -n "$WITH_UDPLITE"; then
358 AC_MSG_CHECKING(for IPPROTO_UDPLITE)
359 AC_TRY_COMPILE([#include <sys/types.h>
360 #include <netinet/in.h>],
362 [ AC_MSG_RESULT(yes); WITH_UDPLITE=1],
363 [ AC_MSG_RESULT(no); WITH_UDPLITE=])
364 if test "$WITH_UDPLITE"; then
365 AC_DEFINE(WITH_UDPLITE)
369 AC_MSG_CHECKING(whether to include SCTP support)
370 AC_ARG_ENABLE(sctp, [ --disable-sctp disable SCTP support],
371 [case "$enableval" in
372 no) AC_MSG_RESULT(no); WITH_SCTP= ;;
373 *) AC_MSG_RESULT(yes); WITH_SCTP=1 ;;
375 [AC_MSG_RESULT(yes); WITH_SCTP=1 ])
377 if test -n "$WITH_SCTP"; then
378 AC_MSG_CHECKING(for IPPROTO_SCTP)
379 AC_CACHE_VAL(sc_cv_define_ipproto_sctp,
380 [AC_TRY_COMPILE([#include <sys/types.h>
381 #include <netinet/in.h>],
383 [sc_cv_define_ipproto_sctp=yes],
384 [sc_cv_define_ipproto_sctp=no])])
385 AC_MSG_RESULT($sc_cv_define_ipproto_sctp)
386 if test $sc_cv_define_ipproto_sctp = yes; then
389 AC_MSG_WARN([IPPROTO_SCTP undefined, disabling SCTP support])
393 AC_MSG_CHECKING(whether to include DCCP support)
394 AC_ARG_ENABLE(dccp, [ --disable-dccp disable DCCP support],
395 [case "$enableval" in
396 no) AC_MSG_RESULT(no); WITH_DCCP= ;;
397 *) AC_MSG_RESULT(yes); WITH_DCCP=1 ;;
399 [AC_MSG_RESULT(yes); WITH_DCCP=1 ])
401 if test -n "$WITH_DCCP"; then
402 AC_MSG_CHECKING(for IPPROTO_DCCP)
403 AC_CACHE_VAL(sc_cv_define_ipproto_dccp,
404 [AC_TRY_COMPILE([#include <sys/types.h>
405 #include <netinet/in.h>],
407 [sc_cv_define_ipproto_dccp=yes],
408 [sc_cv_define_ipproto_dccp=no])])
409 AC_MSG_RESULT($sc_cv_define_ipproto_dccp)
410 if test $sc_cv_define_ipproto_dccp = yes; then
412 AC_CHECK_HEADER(linux/dccp.h,
413 AC_DEFINE(HAVE_LINUX_DCCP_H))
415 AC_MSG_WARN([IPPROTO_DCCP undefined, disabling DCCP support])
419 AC_MSG_CHECKING(whether to include vsock support)
420 AC_ARG_ENABLE(vsock, [ --disable-vsock disable vsock support],
421 [case "$enableval" in
422 no) AC_MSG_RESULT(no); WITH_VSOCK= ;;
423 *) AC_MSG_RESULT(yes); WITH_VSOCK=1 ;;
425 [AC_MSG_RESULT(yes); WITH_VSOCK=1 ])
426 if test "$WITH_VSOCK"; then
427 AC_CHECK_HEADER(linux/vm_sockets.h,
428 AC_DEFINE(HAVE_LINUX_VM_SOCKETS_H),
430 AC_MSG_WARN([include file linux/vm_sockets.h not found, disabling vsock])],
432 #if HAVE_SYS_SOCKET_H
433 #include <sys/socket.h>
438 if test "$WITH_VSOCK"; then
439 AC_DEFINE(WITH_VSOCK)
442 AC_ARG_ENABLE(namespaces, [ --disable-namespaces disable Linux namespaces support],
443 [case "$enableval" in
444 no) TRY_NAMESPACES= ;;
445 *) TRY_NAMESPACES=1 ;;
448 if test "TRY_NAMESPACES"; then
449 AC_TRY_LINK([#include <sched.h>],
452 [TRY_NAMESPACES=failed])
454 AC_MSG_CHECKING(whether to include Linux namespaces support)
455 if test "$TRY_NAMESPACES" = 1; then
457 AC_DEFINE(WITH_NAMESPACES)
458 AC_DEFINE(HAVE_SCHED_H)
459 AC_DEFINE(HAVE_SETNS)
460 elif test "$TRY_NAMESPACES" = yes; then
461 AC_MSG_RESULT(NO (failed))
466 AC_MSG_CHECKING(whether to include listen support)
467 AC_ARG_ENABLE(listen, [ --disable-listen disable listen support],
468 [case "$enableval" in
469 no) AC_MSG_RESULT(no);;
470 *) AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes);;
472 [AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes)])
474 AC_MSG_CHECKING(whether to include POSIX MQ support)
475 AC_ARG_ENABLE(posixmq, [ --disable-posixmq disable POSIX MQ support],
476 [case "$enableval" in
477 no) AC_MSG_RESULT(no)
479 *) WITH_POSIXMQ=1; AC_MSG_RESULT(yes);;
481 [WITH_POSIXMQ=1; AC_MSG_RESULT(yes)])
482 if test "$WITH_POSIXMQ"; then
484 Linux) AC_DEFINE(WITH_POSIXMQ)
486 *) AC_MSG_WARN([POSIX MQ currently implemented for Linux only])
491 AC_MSG_CHECKING(whether to include socks4 support)
492 AC_ARG_ENABLE(socks4, [ --disable-socks4 disable socks4 support],
493 [case "$enableval" in
494 no) AC_MSG_RESULT(no);;
495 *) AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes);;
497 [AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes)])
499 AC_MSG_CHECKING(whether to include socks4a support)
500 AC_ARG_ENABLE(socks4a, [ --disable-socks4a disable socks4a support],
501 [case "$enableval" in
502 no) AC_MSG_RESULT(no);;
503 *) AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes);;
505 [AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes)])
507 AC_MSG_CHECKING(whether to include socks5 support)
508 AC_ARG_ENABLE(socks5, [ --disable-socks5 disable socks5 support],
509 [case "$enableval" in
510 no) AC_MSG_RESULT(no);;
511 *) AC_DEFINE(WITH_SOCKS5) AC_MSG_RESULT(yes);;
513 [AC_DEFINE(WITH_SOCKS5) AC_MSG_RESULT(yes)])
515 AC_MSG_CHECKING(whether to include proxy connect support)
516 AC_ARG_ENABLE(proxy, [ --disable-proxy disable proxy connect support],
517 [case "$enableval" in
518 no) AC_MSG_RESULT(no);;
519 *) AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes);;
521 [AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes)])
523 AC_MSG_CHECKING(whether to include exec support)
524 AC_ARG_ENABLE(exec, [ --disable-exec disable exec support],
525 [case "$enableval" in
526 no) AC_MSG_RESULT(no);;
527 *) AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes);;
529 [AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes)])
531 AC_MSG_CHECKING([whether to include system (shell) support])
532 AC_ARG_ENABLE(system, [ --disable-system disable system (shell) support],
533 [case "$enableval" in
534 no) AC_MSG_RESULT(no);;
535 *) AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes);;
537 [AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes)])
539 AC_MSG_CHECKING([whether to include shell invocation support])
540 AC_ARG_ENABLE(shell, [ --disable-shell disable shell invocation support],
541 [case "$enableval" in
542 no) AC_MSG_RESULT(no);;
543 *) AC_DEFINE(WITH_SHELL) AC_MSG_RESULT(yes);;
545 [AC_DEFINE(WITH_SHELL) AC_MSG_RESULT(yes)])
547 AC_MSG_CHECKING(whether to include pty address support)
548 AC_ARG_ENABLE(pty, [ --disable-pty disable pty support],
549 [case "$enableval" in
550 no) AC_MSG_RESULT(no);;
551 *) AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes);;
553 [AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes)])
555 AC_MSG_CHECKING(whether to include fs attributes support)
556 AC_ARG_ENABLE(fs, [ --disable-fs disable fs attributes support],
557 [case "$enableval" in
558 no) AC_MSG_RESULT(no);;
559 *) AC_DEFINE(WITH_FS) AC_MSG_RESULT(yes);;
561 [AC_DEFINE(WITH_FS) AC_MSG_RESULT(yes)])
563 AC_MSG_CHECKING(whether to include readline support)
564 AC_ARG_ENABLE(readline, [ --disable-readline disable readline support],
565 [case "$enableval" in
566 no) AC_MSG_RESULT(no); WITH_READLINE= ;;
567 *) AC_MSG_RESULT(yes); WITH_READLINE=1 ;;
569 [AC_MSG_RESULT(yes); WITH_READLINE=1 ])
571 if test -n "$WITH_READLINE"; then
572 CPPFLAGS_ORIG=$CPPFLAGS
575 sc_usable_readline_found=
577 for D in "" "/usr/local" "/opt/local" "/sw" "/opt/freeware" "/usr/sfw"; do
578 if test -n "$D" ; then
579 CPPFLAGS="$CPPFLAGS -I$D/include"
580 CFLAGS="$CFLAGS -L$D/lib"
581 DLOC="in location $D"
583 DLOC="in default location"
585 AC_MSG_CHECKING(for usable readline $DLOC)
587 # Some systems require -lcurses, some require -lncurses.
588 # Mac OS X 10.4 (and others) ships with libedit masquerading as readline,
589 # but it doesn't work well with socat. It can be recognized by the absence
592 for L in "" "-lcurses" "-lncurses"; do
593 LIBS="$LIBS_ORIG -lreadline $L"
596 #include <readline/readline.h>
597 #include <readline/history.h>],
599 append_history(0, NULL); ],
600 [ sc_usable_readline_found=1
604 if test -n "$sc_usable_readline_found"; then
606 AC_DEFINE(HAVE_READLINE_READLINE_H,1)
607 AC_DEFINE(HAVE_READLINE_HISTORY_H,1)
608 AC_DEFINE(HAVE_LIBREADLINE,1)
609 AC_DEFINE(WITH_READLINE,1)
613 CPPFLAGS=$CPPFLAGS_ORIG
619 if test -z "$sc_usable_readline_found"; then
620 AC_MSG_WARN([no suitable version of readline found; perhaps you need to install a newer version])
624 AC_MSG_CHECKING(whether to include openssl support)
625 AC_ARG_ENABLE(openssl, [ --disable-openssl disable OpenSSL support],
626 [ case "$enableval" in
627 no) AC_MSG_RESULT(no); WITH_OPENSSL= ;;
628 *) AC_MSG_RESULT(yes); WITH_OPENSSL=1 ;;
630 [ AC_MSG_RESULT(yes); WITH_OPENSSL=1 ])
631 AC_ARG_ENABLE(openssl_base, [ --enable-openssl-base specify directory with include/ and lib/],
632 [ OPENSSL_BASE="$enableval" ],
633 [ unset OPENSSL_BASE ])
635 if test -n "$WITH_OPENSSL"; then
636 if test -n "$OPENSSL_BASE"; then
637 sc_cv_have_openssl_ssl_h=yes;
638 CPPFLAGS="-I$OPENSSL_BASE/include $CPPFLAGS"
640 AC_MSG_NOTICE(checking for components of OpenSSL)
641 # first, we need to find the include file <openssl/ssl.h>
642 AC_CACHE_VAL(sc_cv_have_openssl_ssl_h,
643 [AC_TRY_COMPILE([#include <openssl/ssl.h>],[;],
644 [sc_cv_have_openssl_ssl_h=yes; OPENSSL_BASE=""; ],
645 [sc_cv_have_openssl_ssl_h=no
646 if test "$OPENSSL_BASE"; then
649 Ds="/sw /usr/local /opt/freeware /usr/sfw /usr/local/ssl"
654 if test -r "$i"; then
655 #V_INCL="$V_INCL -I$I"
656 CPPFLAGS="$CPPFLAGS -I$I"
657 AC_MSG_NOTICE(found $i)
658 sc_cv_have_openssl_ssl_h=yes; OPENSSL_BASE="$D"
663 if test "$sc_cv_have_openssl_ssl_h" = "yes"; then
664 AC_DEFINE(HAVE_OPENSSL_SSL_H)
666 AC_MSG_NOTICE(checked for openssl/ssl.h... $sc_cv_have_openssl_ssl_h)
668 fi # end checking for openssl/ssl.h
671 #if test -n "$WITH_OPENSSL"; then
672 # AC_CHECK_FUNCS(OPENSSL_init_ssl, SSL_library_init)
675 if test -n "$WITH_OPENSSL" -a "$sc_cv_have_openssl_ssl_h" = 'yes'; then
676 # next, we search for the openssl library (libssl.*)
677 # interesting: Linux only requires -lssl, FreeBSD requires -lssl -lcrypto
678 # Note, version OpenSSL 0.9.7j and higher requires -lcrypto even on Linux.
679 AC_MSG_CHECKING(for libssl)
680 AC_CACHE_VAL(sc_cv_have_libssl,
682 if test -n "$OPENSSL_BASE"; then
683 L="$OPENSSL_BASE/lib"; LIBS="$LIBS -L$L -lssl -lcrypto"
685 LIBS="$LIBS -lssl -lcrypto"
687 AC_TRY_LINK([#include <openssl/ssl.h>
688 #include <openssl/err.h>
690 [SSL_library_init();ERR_error_string()],
691 [sc_cv_have_libssl='yes'],
692 [ LIBS="$LIBS -lcrypto"
693 AC_TRY_LINK([#include <openssl/ssl.h>],
694 [SSL_library_init()],
695 [sc_cv_have_libssl='yes'],
696 [sc_cv_have_libssl='no'])
698 if test "$sc_cv_have_libssl" != 'yes'; then
703 if test "$sc_cv_have_libssl" = 'yes'; then
704 AC_DEFINE(HAVE_LIBSSL)
706 AC_MSG_RESULT($sc_cv_have_libssl)
709 # # a possible location for openssl (on Sourceforge/Solaris)
710 # AC_CHECK_FILE(/usr/local/ssl/lib, LIBS="$LIBS -L/usr/local/ssl/lib/")
711 # # sometimes on Solaris:
712 # AC_CHECK_FILE(/pkgs/lib, LIBS="$LIBS -L/pkgs/lib/")
713 # # for AIX 5.1 with Linux toolbox:
714 # AC_CHECK_FILE(/opt/freeware/lib, LIBS="$LIBS -L/opt/freeware/lib/")
716 # AC_CHECK_LIB(crypto, main)
717 # AC_CHECK_LIB(ssl, main)
719 # # MacOSX has openssl includes in another directory
720 # if test -d /sw/include/; then
721 # V_INCL="$V_INCL -I/sw/include"
722 # # and Solaris at sourceforge here:
723 # elif test -d /usr/local/ssl/include/; then
724 # V_INCL="$V_INCL -I/usr/local/ssl/include"
725 # # and AIX 5.1 with Linux toolbox:
726 # elif test -d /opt/freeware/include; then
727 # V_INCL="$V_INCL -I/opt/freeware/include"
730 if test -n "$WITH_OPENSSL"; then
731 if test "$sc_cv_have_openssl_ssl_h" = "yes" -a "$sc_cv_have_libssl" = "yes"; then
732 AC_DEFINE(WITH_OPENSSL)
734 AC_MSG_WARN([not all components of OpenSSL found, disabling it]);
738 # Guarded for OpenBSD
739 AC_CHECK_FUNCS(OPENSSL_init_ssl SSL_library_init OPENSSL_INIT_new)
740 AC_CHECK_TYPE(OPENSSL_INIT_SETTINGS, AC_DEFINE(HAVE_TYPE_OPENSSL_INIT_SETTINGS),,[#include "openssl.h"])
742 #; sc_cv_have_SSL_library_init='yes'; AC_DEFINE(HAVE_SSL_library_init)
743 #if test -n "$WITH_OPENSSL"; then
744 # AC_CHECK_LIB(crypto, CRYPTO_new_ex_data, [], [AC_MSG_ERROR([library 'crypto' is required for OpenSSL])])
746 # AC_CHECK_LIB(ssl, OPENSSL_init_ssl, [FOUND_SSL_LIB="yes"])
747 # AC_CHECK_LIB(ssl, SSL_library_init, [FOUND_SSL_LIB="yes"])
748 # AS_IF([test "x$FOUND_SSL_LIB" = xno], [AC_MSG_ERROR([library 'ssl' is required for OpenSSL; WITH_OPENSSL=])])
749 # AS_IF([test "x$FOUND_SSL_LIB" = xyes], [LIBS="$LIBS -L$L -lssl -lcrypto"])
752 if test -n "$WITH_OPENSSL"; then
753 AC_MSG_CHECKING(whether to include OpenSSL method option)
754 AC_ARG_ENABLE(openssl-method, [ --enable-openssl-method enable OpenSSL method option],
755 [case "$enableval" in
756 no) AC_MSG_RESULT(no);;
757 *) AC_DEFINE(WITH_OPENSSL_METHOD) WITH_OPENSSL_METHOD=1; AC_MSG_RESULT(yes);;
762 AC_MSG_CHECKING(whether to include undocumented resolver related options)
763 AC_ARG_ENABLE(resolve, [ --enable-resolve enable undocumented resolver options],
764 [case "$enableval" in
765 no) AC_MSG_RESULT(no);;
766 *) AC_DEFINE(WITH_RESOLVE) AC_MSG_RESULT(yes);;
768 [AC_DEFINE(WITH_RESOLVE) AC_MSG_RESULT(yes)])
770 AC_MSG_CHECKING(whether to include deprecated resolver option)
771 AC_ARG_ENABLE(res-deprecated, [ --enable-res-deprecated enable deprecated resolver options],
772 [case "$enableval" in
773 no) AC_MSG_RESULT(no);;
774 *) AC_DEFINE(WITH_RES_DEPRECATED) WITH_RES_DEPRECATED=1; AC_MSG_RESULT(yes);;
778 # check for fips support
779 AC_MSG_CHECKING(whether to include openssl fips support)
780 AC_ARG_ENABLE(fips, [ --enable-fips enable OpenSSL FIPS support],
781 [ case "$enableval" in
782 yes) AC_MSG_RESULT(yes); WITH_FIPS=1 ;;
783 *) AC_MSG_RESULT(no); WITH_FIPS= ;;
785 [ AC_MSG_RESULT(no); WITH_FIPS= ])
787 if test -n "$WITH_FIPS"; then
788 if test -n "$WITH_OPENSSL"; then
789 AC_CHECK_PROG(HAVE_FIPSLD, fipsld, 1)
790 if test "$sc_cv_have_openssl_ssl_h" != "yes" -o "$sc_cv_have_libssl" != "yes" -o ! "$HAVE_FIPSLD";
792 AC_MSG_WARN([not all components of OpenSSL found, disabling FIPS]);
796 AC_MSG_WARN([must enable OpenSSL to enable FIPS; use --enable-openssl]);
800 if test -n "$WITH_FIPS"; then
801 AC_MSG_CHECKING(for components of OpenSSL FIPS)
802 # first, we need to find the include file <openssl/fips.h>
803 AC_CACHE_VAL(sc_cv_have_openssl_fips_h,
804 [AC_TRY_COMPILE([#define OPENSSL_FIPS
806 #include <openssl/fips.h>],[;],
807 [sc_cv_have_openssl_fips_h=yes; ],
808 [sv_cv_have_openssl_fips_h=no
809 if test -n "$OPENSSL_BASE"; then
810 I="$OPENSSL_BASE/include"
811 i="$I/openssl/fips.h"
812 if test -r "$i"; then
813 AC_MSG_NOTICE(found $i)
814 sc_cv_have_openssl_fips_h=yes;
820 if test "$sv_cv_have_openssl_fips_h" = "yes"; then
821 AC_DEFINE(HAVE_OPENSSL_FIPS_H)
823 AC_MSG_NOTICE(checked for openssl/fips.h... $sc_cv_have_openssl_ssl_h)
826 if test -n "$WITH_FIPS" -a "$sc_cv_have_openssl_fips_h" = 'yes'; then
827 # check for the libcrypto library with fips support
828 AC_MSG_CHECKING(for libcrypto with FIPS support)
829 AC_CACHE_VAL(sc_cv_have_libcrypto,
831 echo $LIBS | grep -q "\-lcrypto"
832 if test $? -ne 0; then
833 if test -n "$OPENSSL_BASE"; then
834 L="$OPENSSL_BASE/lib"; LIBS="$LIBS -L$L -lcrypto"
836 LIBS="$LIBS -lcrypto"
839 AC_TRY_LINK([#define OPENSSL_FIPS
840 #include <openssl/ssl.h>
841 #include <openssl/fips.h>],
842 [int res = FIPS_mode_set(1);],
843 [sc_cv_have_libcrypto='yes'],
844 [sc_cv_have_libcrypto='no']
846 if test "$sc_cv_have_libcrypto" != 'yes'; then
851 if test "$sc_cv_have_libcrypto" = 'yes'; then
852 AC_DEFINE(HAVE_LIBCRYPTO)
854 AC_MSG_RESULT($sc_cv_have_libcrypto)
857 if test -n "$WITH_FIPS"; then
858 if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then
860 AC_DEFINE(OPENSSL_FIPS)
862 AC_MSG_WARN([not all components of OpenSSL FIPS found, disabling it]);
866 AC_MSG_CHECKING(whether to include tun/tap address support)
867 AC_ARG_ENABLE(tun, [ --disable-tun disable TUN/TAP support],
868 [case "$enableval" in
869 no) AC_MSG_RESULT(no); WITH_TUN= ;;
870 *) AC_MSG_RESULT(yes); WITH_TUN=1 ;;
872 [AC_MSG_RESULT(yes); WITH_TUN=1 ])
875 if ! test "$ac_cv_header_linux_if_tun_h" = 'yes'; then
876 AC_MSG_WARN(include file linux/if_tun.h not found, disabling TUN)
880 if test -n "$WITH_TUN"; then
884 if test "$WITH_INTERFACE"; then
885 AC_CHECK_HEADER(netinet/if_ether.h,
886 AC_DEFINE(HAVE_NETINET_IF_ETHER_H),
888 AC_MSG_WARN([include file netinet/if_ether.h not found, disabling interface])],
890 #if HAVE_NET_IF_H && HAVE_NETINET_IN_H
892 #include <netinet/in.h>
896 if test "$WITH_INTERFACE" || test "$WITH_TUN"; then
897 AC_CHECK_HEADER(linux/if_packet.h,
898 AC_DEFINE(HAVE_LINUX_IF_PACKET_H),
900 AC_MSG_WARN([include file linux/if_packet.h not found, disabling interface])])
902 if test "$WITH_INTERFACE"; then
903 AC_DEFINE(WITH_INTERFACE)
906 AC_MSG_CHECKING(whether to include system call tracing)
907 AC_ARG_ENABLE(sycls, [ --disable-sycls disable system call tracing],
908 [case "$enableval" in
909 no) SYCLS=""; SSLCLS=""; AC_MSG_RESULT(no);;
910 *) AC_DEFINE(WITH_SYCLS)
911 SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes);;
913 [AC_DEFINE(WITH_SYCLS)
914 SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes)])
918 AC_MSG_CHECKING(whether to include file descriptor analyzer)
919 AC_ARG_ENABLE(filan, [ --disable-filan disable file descriptor analyzer],
920 [case "$enableval" in
921 no) FILAN=""; AC_MSG_RESULT(no);;
922 *) AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes);;
924 [AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes)])
927 AC_MSG_CHECKING(whether to include retry support)
928 AC_ARG_ENABLE(retry, [ --disable-retry disable retry support],
929 [case "$enableval" in
930 no) AC_MSG_RESULT(no);;
931 *) AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes);;
933 [AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes)])
935 AC_MSG_CHECKING(included message level)
936 AC_ARG_ENABLE(msglevel, [ --enable-msglevel=N set max verbosity to debug,info,notice,warn,error,fatal],
937 [case "$enableval" in
938 0|DEBUG|Debug|debug) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;
939 1|INFO|Info|info) AC_DEFINE(WITH_MSGLEVEL,1) AC_MSG_RESULT(info);;
940 2|NOTICE|Notice|notice) AC_DEFINE(WITH_MSGLEVEL,2) AC_MSG_RESULT(notice);;
941 3|WARN|Warn|warn) AC_DEFINE(WITH_MSGLEVEL,3) AC_MSG_RESULT(warn);;
942 4|ERROR|Error|error) AC_DEFINE(WITH_MSGLEVEL,4) AC_MSG_RESULT(error);;
943 5|FATAL|Fatal|fatal) AC_DEFINE(WITH_MSGLEVEL,5) AC_MSG_RESULT(fatal);;
944 *) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;
946 [AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug)])
948 AC_MSG_CHECKING(default IP version)
949 AC_ARG_ENABLE(default-ipv, [ --enable-default-ipv=N set default/preferred IP version to "0" (none), "4", "6"],
950 [case "$enableval" in
951 "") AC_DEFINE(WITH_DEFAULT_IPV, '0') AC_MSG_RESULT("0");;
952 4) AC_DEFINE(WITH_DEFAULT_IPV, '4') AC_MSG_RESULT("4");;
953 6) AC_DEFINE(WITH_DEFAULT_IPV, '6') AC_MSG_RESULT("6");;
954 *) AC_DEFINE(WITH_DEFAULT_IPV, '0') AC_MSG_RESULT("0");;
956 [AC_DEFINE(WITH_DEFAULT_IPV, '0') AC_MSG_RESULT("0")])
960 dnl Checks for typedefs, structures, and compiler characteristics.
972 dnl Check for extra realtime library (for Solaris)
973 AC_CHECK_FUNC(nanosleep, AC_DEFINE(HAVE_NANOSLEEP), AC_CHECK_LIB(rt, nanosleep, [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_NANOSLEEP)]))
974 #AC_CHECK_FUNC(nanosleep, , AC_CHECK_LIB(rt, nanosleep))
976 dnl Checks for library functions.
977 AC_PROG_GCC_TRADITIONAL
981 AC_CHECK_FUNCS(putenv select pselect poll socket strtod strtol)
982 AC_CHECK_FUNCS(strtoul uname getpgid getsid gethostbyname getaddrinfo)
983 AC_CHECK_FUNCS(getprotobynumber)
984 AC_CHECK_FUNCS(setgroups inet_aton)
986 AC_CHECK_FUNCS(grantpt unlockpt)
988 # GR AC_CHECK_FUNCS only checks linking, not prototype. This may lead to implicit
989 # function declarations and to SIGSEGV on systems with 32bit int and 64bit pointer
991 dnl Search for cfsetispeed(),cfgetispeed(),cfsetspeed(),cfgetospeed() functions
992 AC_CHECK_FUNCS(cfsetispeed cfgetispeed cfsetospeed cfgetospeed)
994 ###################################
995 # check for prototype and existence of functions that return a pointer
996 # defines in config.h: HAVE_PROTOTYPE_LIB_$1
997 AC_CHECK_PROTOTYPE_LIB(posix_memalign)
998 AC_CHECK_PROTOTYPE_LIB(strdup)
999 AC_CHECK_PROTOTYPE_LIB(strerror)
1000 AC_CHECK_PROTOTYPE_LIB(strstr)
1001 AC_CHECK_PROTOTYPE_LIB(getipnodebyname)
1002 AC_CHECK_PROTOTYPE_LIB(strndup)
1003 AC_CHECK_PROTOTYPE_LIB(memrchr)
1004 AC_CHECK_PROTOTYPE_LIB(if_indextoname)
1005 AC_CHECK_PROTOTYPE_LIB(ptsname)
1007 AC_MSG_CHECKING(for long long)
1008 AC_CACHE_VAL(sc_cv_type_longlong,
1009 [AC_TRY_COMPILE([],[long long s;],
1010 [sc_cv_type_longlong=yes],
1011 [sc_cv_type_longlong=no])])
1012 if test $sc_cv_type_longlong = yes; then
1013 AC_DEFINE(HAVE_TYPE_LONGLONG)
1015 AC_MSG_RESULT($sc_cv_type_longlong)
1017 AC_CHECK_TYPE(sig_atomic_t,AC_DEFINE(HAVE_TYPE_SIG_ATOMIC_T),,[#include "sysincludes.h"])
1019 AC_MSG_CHECKING(for bool)
1020 AC_CACHE_VAL(sc_cv_type_bool,
1021 [AC_TRY_COMPILE([#ifdef HAVE_STDBOOL_H
1022 #include <stdbool.h>
1025 [sc_cv_type_bool=yes],
1026 [sc_cv_type_bool=no])])
1027 if test $sc_cv_type_bool = yes; then
1028 AC_DEFINE(HAVE_TYPE_BOOL)
1030 AC_MSG_RESULT($sc_cv_type_bool)
1032 # following builtin macro does not check unistd.h and sys/socket.h where
1033 # socklen_t might be defined
1034 #AC_CHECK_TYPE(socklen_t, int)
1036 AC_MSG_CHECKING(for socklen_t)
1037 AC_CACHE_VAL(sc_cv_type_socklen,
1038 [AC_TRY_COMPILE([#include <sys/types.h>
1039 #include <sys/socket.h>
1040 #include <unistd.h>],[socklen_t s;],
1041 [sc_cv_type_socklen=yes],
1042 [sc_cv_type_socklen=no])])
1043 if test $sc_cv_type_socklen = yes; then
1044 AC_DEFINE(HAVE_TYPE_SOCKLEN)
1046 AC_MSG_RESULT($sc_cv_type_socklen)
1048 AC_MSG_CHECKING(for struct stat64)
1049 AC_CACHE_VAL(sc_cv_type_stat64,
1050 [AC_TRY_COMPILE([#include <sys/stat.h>],[struct stat64 s;],
1051 [sc_cv_type_stat64=yes],
1052 [sc_cv_type_stat64=no])])
1053 if test $sc_cv_type_stat64 = yes; then
1054 AC_DEFINE(HAVE_TYPE_STAT64)
1056 AC_MSG_RESULT($sc_cv_type_stat64)
1058 AC_MSG_CHECKING(for off64_t)
1059 AC_CACHE_VAL(sc_cv_type_off64,
1060 [AC_TRY_COMPILE([#include <unistd.h>],[off64_t s;],
1061 [sc_cv_type_off64=yes],
1062 [sc_cv_type_off64=no])])
1063 if test $sc_cv_type_off64 = yes; then
1064 AC_DEFINE(HAVE_TYPE_OFF64)
1066 AC_MSG_RESULT($sc_cv_type_off64)
1068 AC_MSG_CHECKING(for sighandler_t)
1069 AC_CACHE_VAL(sc_cv_type_sighandler,
1070 [AC_TRY_COMPILE([#include <signal.h>],[sighandler_t s;],
1071 [sc_cv_type_sighandler=yes],
1072 [sc_cv_type_sighandler=no])])
1073 if test $sc_cv_type_sighandler = yes; then
1074 AC_DEFINE(HAVE_TYPE_SIGHANDLER)
1076 AC_MSG_RESULT($sc_cv_type_socklen)
1078 AC_MSG_CHECKING(for uint8_t)
1079 AC_CACHE_VAL(sc_cv_type_uint8,
1080 [AC_TRY_COMPILE([#include <sys/types.h>
1084 /* Tru64 has uint8_t etc from netdb.h */
1088 #include <unistd.h>],[uint8_t s;],
1089 [sc_cv_type_uint8=yes],
1090 [sc_cv_type_uint8=no])])
1091 if test $sc_cv_type_uint8 = yes; then
1092 AC_DEFINE(HAVE_TYPE_UINT8)
1094 AC_MSG_RESULT($sc_cv_type_uint8)
1096 AC_MSG_CHECKING(for uint16_t)
1097 AC_CACHE_VAL(sc_cv_type_uint16,
1098 [AC_TRY_COMPILE([#include <sys/types.h>
1102 /* Tru64 has uint16_t etc from netdb.h */
1106 #include <unistd.h>],[uint16_t s;],
1107 [sc_cv_type_uint16=yes],
1108 [sc_cv_type_uint16=no])])
1109 if test $sc_cv_type_uint16 = yes; then
1110 AC_DEFINE(HAVE_TYPE_UINT16)
1112 AC_MSG_RESULT($sc_cv_type_uint16)
1114 AC_MSG_CHECKING(for uint32_t)
1115 AC_CACHE_VAL(sc_cv_type_uint32,
1116 [AC_TRY_COMPILE([#include <sys/types.h>
1120 /* Tru64 has uint32_t etc from netdb.h */
1124 #include <unistd.h>],[uint32_t s;],
1125 [sc_cv_type_uint32=yes],
1126 [sc_cv_type_uint32=no])])
1127 if test $sc_cv_type_uint32 = yes; then
1128 AC_DEFINE(HAVE_TYPE_UINT32)
1130 AC_MSG_RESULT($sc_cv_type_uint32)
1132 AC_MSG_CHECKING(for uint64_t)
1133 AC_CACHE_VAL(sc_cv_type_uint64,
1134 [AC_TRY_COMPILE([#include <sys/types.h>
1138 /* Tru64 has uint32_t etc from netdb.h */
1142 #include <unistd.h>],[uint64_t s;],
1143 [sc_cv_type_uint64=yes],
1144 [sc_cv_type_uint64=no])])
1145 if test $sc_cv_type_uint64 = yes; then
1146 AC_DEFINE(HAVE_TYPE_UINT64)
1148 AC_MSG_RESULT($sc_cv_type_uint64)
1150 ### AIX 4.1 needs _XOPEN_EXTENDED_SOURCE for syslog headers,
1151 # but then gets problems with 3rd arg of getsockaddr...
1152 #AC_MSG_CHECKING(for _XOPEN_EXTENDED_SOURCE requirement)
1153 #CFLAGS="-Werror -Wall"
1154 #AC_TRY_COMPILE([#include <sys/syslog.h>],
1156 #[AC_MSG_RESULT(no)],
1157 #[AC_MSG_RESULT(required); AC_DEFINE(_XOPEN_EXTENDED_SOURCE)])
1161 AC_MSG_CHECKING(for fdset->fds_bits)
1162 AC_TRY_COMPILE([#include <sys/types.h>
1163 #if HAVE_SYS_SELECT_H
1164 #include <sys/select.h>
1166 [fd_set s; s.fds_bits[0]=0;],
1167 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_FDS_BITS)],
1168 [AC_MSG_RESULT(no);])
1170 AC_MSG_CHECKING(for struct termios . c_ispeed)
1171 AC_TRY_COMPILE([#include <unistd.h>
1173 #include <termios.h>
1175 [struct termios s; s.c_ispeed=0;],
1176 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_STRUCT_TERMIOS_C_ISPEED)],
1177 [AC_MSG_RESULT(no);])
1179 AC_MSG_CHECKING(for struct termios . c_ospeed)
1180 AC_TRY_COMPILE([#include <unistd.h>
1182 #include <termios.h>
1184 [struct termios s; s.c_ospeed=0;],
1185 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_STRUCT_TERMIOS_C_OSPEED)],
1186 [AC_MSG_RESULT(no);])
1188 AC_MSG_CHECKING(for sa_family_t)
1189 AC_CACHE_VAL(sc_cv_type_sa_family_t,
1190 [AC_TRY_COMPILE([#include <sys/types.h>
1191 #include <sys/socket.h>
1192 #include <netinet/in.h>],[sa_family_t s;],
1193 [sc_cv_type_sa_family_t=yes],
1194 [sc_cv_type_sa_family_t=no])])
1195 if test $sc_cv_type_sa_family_t = yes; then
1196 AC_DEFINE(HAVE_TYPE_SA_FAMILY_T)
1198 AC_MSG_RESULT($sc_cv_type_sa_family_t)
1200 AC_MSG_CHECKING(for struct sock_extended_err)
1201 AC_CACHE_VAL(sc_cv_struct_sock_extended_err,
1202 [AC_TRY_COMPILE([#include <linux/types.h>
1203 #if TIME_WITH_SYS_TIME
1204 #include <sys/time.h>
1206 #if HAVE_LINUX_ERRQUEUE_H
1207 #include <linux/errqueue.h>
1208 #endif],[struct sock_extended_err s;],
1209 [sc_cv_struct_sock_extended_err=yes],
1210 [sc_cv_struct_sock_extended_err=no])])
1211 if test $sc_cv_struct_sock_extended_err = yes; then
1212 AC_DEFINE(HAVE_STRUCT_SOCK_EXTENDED_ERR)
1214 AC_MSG_RESULT($sc_cv_struct_sock_extended_err)
1216 AC_MSG_CHECKING(for struct sigaction.sa_sigaction)
1217 AC_CACHE_VAL(sc_cv_struct_sigaction_sa_sigaction,
1218 [AC_TRY_COMPILE([#include <signal.h>],[struct sigaction s;s.sa_sigaction=0;],
1219 [sc_cv_struct_sigaction_sa_sigaction=yes],
1220 [sc_cv_struct_sigaction_sa_sigaction=no])])
1221 if test $sc_cv_struct_sigaction_sa_sigaction = yes; then
1222 AC_DEFINE(HAVE_STRUCT_SIGACTION_SA_SIGACTION)
1224 AC_MSG_RESULT($sc_cv_struct_sigaction_sa_sigaction)
1226 # there is another issue with termios: OSR requires "#define _SVID3 ..."
1227 # for reasonable termios support. We check this situation using IMAXBEL
1228 AC_MSG_CHECKING(if _SVID3 is helpful)
1229 AC_CACHE_VAL(ac_cv_svid3,
1230 [AC_TRY_COMPILE([#include <termios.h>],
1233 [AC_TRY_COMPILE([#define _SVID3 1
1234 #include <termios.h>],
1240 if test $ac_cv_svid3 = yes; then
1243 AC_MSG_RESULT($ac_cv_svid3)
1246 # Openindiana needs _XPG4_2 for CMSG stuff
1247 AC_MSG_CHECKING(if _XPG4_2 is helpful)
1248 AC_CACHE_VAL(ac_cv_xpg4_2,
1249 [AC_TRY_LINK([#include <sys/socket.h>],
1250 [int i=CMSG_DATA(0)],
1252 [AC_TRY_LINK([#define _XPG4_2 1
1253 #include <sys/socket.h>],
1254 [int i=CMSG_DATA(0)],
1259 if test $ac_cv_xpg4_2 = yes; then
1262 AC_MSG_RESULT($ac_cv_xpg4_2)
1264 # When on Openindiana _XPG4_2 is defined (see above)
1265 # we also need to define __EXTENSIONS__ for basic stuff.
1266 # Note that <sys/procset.h> is important on Openindiana
1267 # but does not exist on Linux
1268 if test "$ac_cv_xpg4_2" = yes; then
1269 AC_MSG_CHECKING(if __EXTENSIONS__ is helpful)
1270 AC_CACHE_VAL(ac_cv___extensions__,
1271 [AC_TRY_COMPILE([#include <sys/procset.h>],
1273 [ac_cv___extensions__=no],
1274 [AC_TRY_COMPILE([#define __EXTENSIONS__ 1
1275 #include <sys/procset.h>],
1277 [ac_cv___extensions__=yes],
1278 [ac_cv___extensions__=no]
1281 if test $ac_cv___extensions__ = yes; then
1282 AC_DEFINE(__EXTENSIONS__)
1284 AC_MSG_RESULT($ac_cv___extensions__)
1287 # When on Openindiana __EXTENSIONS__ is defined (see above)
1288 # _POSIX_PTHREAD_SEMANTICS must be defined for standard ctime_r()
1289 if test "$ac_cv___extensions__" = yes; then
1290 AC_MSG_CHECKING(if _POSIX_PTHREAD_SEMANTICS is helpful)
1291 AC_CACHE_VAL(ac_cv__posix_pthread_semantics,
1292 [AC_TRY_COMPILE([#include <time.h>],
1293 [char *s = ctime_r(0,0);],
1294 [ac_cv__posix_pthread_semantics=no],
1295 [AC_TRY_COMPILE([#define _POSIX_PTHREAD_SEMANTICS 1
1297 [char *s = ctime_r(0,0);],
1298 [ac_cv__posix_pthread_semantics=yes],
1299 [ac_cv__posix_pthread_semantics=no]
1302 if test $ac_cv__posix_pthread_semantics = yes; then
1303 AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
1305 AC_MSG_RESULT($ac_cv__posix_pthread_semantics)
1310 AC_MSG_CHECKING(for struct timespec)
1311 AC_CACHE_VAL(sc_cv_struct_timespec,
1312 [AC_TRY_COMPILE([#include <time.h>
1314 #include <sys/time.h>
1315 #endif],[struct timespec s;],
1316 [sc_cv_struct_timespec=yes],
1317 [sc_cv_struct_timespec=no])])
1318 if test $sc_cv_struct_timespec = yes; then
1319 AC_DEFINE(HAVE_STRUCT_TIMESPEC)
1321 AC_MSG_RESULT($sc_cv_struct_timespec)
1324 # struct linger; FreeBSD requires sys/types.h for sys/socket.h
1325 AC_MSG_CHECKING(for struct linger)
1326 AC_CACHE_VAL(sc_cv_struct_linger,
1327 [AC_TRY_COMPILE([#include <sys/types.h>
1328 #include <sys/socket.h>],[struct linger s;],
1329 [sc_cv_struct_linger=yes],
1330 [sc_cv_struct_linger=no])])
1331 if test $sc_cv_struct_linger = yes; then
1332 AC_DEFINE(HAVE_STRUCT_LINGER)
1334 AC_MSG_RESULT($sc_cv_struct_linger)
1337 # struct ip (for IPv4 header info)
1338 AC_MSG_CHECKING(for struct ip)
1339 AC_CACHE_VAL(sc_cv_struct_ip,
1340 [AC_TRY_COMPILE([#include <netinet/in.h>
1341 #include <netinet/ip.h>],[struct ip s;],
1342 [sc_cv_struct_ip=yes],
1343 [sc_cv_struct_ip=no])])
1344 if test $sc_cv_struct_ip = yes; then
1345 AC_DEFINE(HAVE_STRUCT_IP)
1347 AC_MSG_RESULT($sc_cv_struct_ip)
1349 # struct ip_mreq (for multicasting options)
1350 AC_MSG_CHECKING(for struct ip_mreq)
1351 AC_CACHE_VAL(sc_cv_struct_ip_mreq,
1352 [AC_TRY_COMPILE([#include <sys/types.h>
1353 #include <sys/socket.h>
1354 #include <netinet/in.h>],[struct ip_mreq s;],
1355 [sc_cv_struct_ip_mreq=yes],
1356 [sc_cv_struct_ip_mreq=no])])
1357 if test $sc_cv_struct_ip_mreq = yes; then
1358 AC_DEFINE(HAVE_STRUCT_IP_MREQ)
1360 AC_MSG_RESULT($sc_cv_struct_ip_mreq)
1362 # struct ip_mreqn (for multicasting options)
1363 AC_MSG_CHECKING(for struct ip_mreqn)
1364 AC_CACHE_VAL(sc_cv_struct_ip_mreqn,
1365 [AC_TRY_COMPILE([#include <sys/types.h>
1366 #include <sys/socket.h>
1367 #include <netinet/in.h>
1368 #include <netinet/ip.h>],[struct ip_mreqn s;],
1369 [sc_cv_struct_ip_mreqn=yes],
1370 [sc_cv_struct_ip_mreqn=no])])
1371 if test $sc_cv_struct_ip_mreqn = yes; then
1372 AC_DEFINE(HAVE_STRUCT_IP_MREQN)
1374 AC_MSG_RESULT($sc_cv_struct_ip_mreqn)
1376 # struct ipv6_mreq (for multicasting options)
1377 AC_MSG_CHECKING(for struct ipv6_mreq)
1378 AC_CACHE_VAL(sc_cv_struct_ipv6_mreq,
1379 [AC_TRY_COMPILE([#include <sys/types.h>
1380 #include <sys/socket.h>
1381 #include <netinet/in.h>],[struct ipv6_mreq s;],
1382 [sc_cv_struct_ipv6_mreq=yes],
1383 [sc_cv_struct_ipv6_mreq=no])])
1384 if test $sc_cv_struct_ipv6_mreq = yes; then
1385 AC_DEFINE(HAVE_STRUCT_IPV6_MREQ)
1387 AC_MSG_RESULT($sc_cv_struct_ipv6_mreq)
1389 # struct ip_mreq_source (for multicasting options)
1390 AC_MSG_CHECKING(for struct ip_mreq_source)
1391 AC_CACHE_VAL(sc_cv_struct_ip_mreq_source,
1392 [AC_TRY_COMPILE([#include <sys/types.h>
1393 #include <sys/socket.h>
1394 #include <netinet/in.h>
1395 #include <netinet/ip.h>],[struct ip_mreq_source s;],
1396 [sc_cv_struct_ip_mreq_source=yes],
1397 [sc_cv_struct_ip_mreq_source=no])])
1398 if test $sc_cv_struct_ip_mreq_source = yes; then
1399 AC_DEFINE(HAVE_STRUCT_IP_MREQ_SOURCE)
1401 AC_MSG_RESULT($sc_cv_struct_ip_mreqn)
1403 # struct group_source_req (for multicasting options)
1404 AC_MSG_CHECKING(for struct group_source_req)
1405 AC_CACHE_VAL(sc_cv_struct_group_source_req,
1406 [AC_TRY_COMPILE([#include <sys/types.h>
1407 #include <sys/socket.h>
1408 #include <netinet/in.h>
1409 #include <netinet/ip.h>],[struct group_source_req s;],
1410 [sc_cv_struct_group_source_req=yes],
1411 [sc_cv_struct_group_source_req=no])])
1412 if test $sc_cv_struct_group_source_req = yes; then
1413 AC_DEFINE(HAVE_STRUCT_GROUP_SOURCE_REQ)
1415 AC_MSG_RESULT($sc_cv_struct_group_source_req)
1418 # struct ifreq (for network interfaces)
1419 AC_MSG_CHECKING(for struct ifreq)
1420 AC_CACHE_VAL(sc_cv_struct_ifreq,
1421 [AC_TRY_COMPILE([#include <sys/types.h>
1422 #include <sys/socket.h>
1423 #include <net/if.h>],[struct ifreq s;],
1424 [sc_cv_struct_ifreq=yes],
1425 [sc_cv_struct_ifreq=no])])
1426 if test $sc_cv_struct_ifreq = yes; then
1427 AC_DEFINE(HAVE_STRUCT_IFREQ)
1429 AC_MSG_RESULT($sc_cv_struct_ifreq)
1431 # struct ifreq.ifr_index
1432 # on most systems that have struct ifreq
1433 AC_MSG_CHECKING(for struct ifreq.ifr_index)
1434 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_index,
1435 [AC_TRY_COMPILE([#include <sys/types.h>
1436 #include <sys/socket.h>
1437 #include <net/if.h>],
1438 [struct ifreq ir;ir.ifr_index=0;],
1439 [sc_cv_struct_ifreq_ifr_index=yes],
1440 [sc_cv_struct_ifreq_ifr_index=no])])
1441 if test $sc_cv_struct_ifreq_ifr_index = yes; then
1442 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_INDEX)
1444 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_index)
1446 # struct ifreq.ifr_ifindex
1447 # Linux has ifr_ifindex instead of ifr_index
1448 AC_MSG_CHECKING(for struct ifreq.ifr_ifindex)
1449 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_ifindex,
1450 [AC_TRY_COMPILE([#include <sys/types.h>
1451 #include <sys/socket.h>
1452 #include <net/if.h>],
1453 [struct ifreq ir;ir.ifr_ifindex=0;],
1454 [sc_cv_struct_ifreq_ifr_ifindex=yes],
1455 [sc_cv_struct_ifreq_ifr_ifindex=no])])
1456 if test $sc_cv_struct_ifreq_ifr_ifindex = yes; then
1457 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_IFINDEX)
1459 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_ifindex)
1462 # some systems have a sa_len field in struct sockaddr and we need to support it
1463 # so we can compare sockaddrs simply with memcmp
1464 AC_MSG_CHECKING(for struct sockaddr.sa_len)
1465 AC_CACHE_VAL(sc_cv_struct_sockaddr_salen,
1466 [AC_TRY_COMPILE([#include <sys/types.h>
1467 #include <sys/socket.h>],
1468 [struct sockaddr sa;sa.sa_len=0;],
1469 [sc_cv_struct_sockaddr_salen=yes],
1470 [sc_cv_struct_sockaddr_salen=no])])
1471 if test $sc_cv_struct_sockaddr_salen = yes; then
1472 AC_DEFINE(HAVE_STRUCT_SOCKADDR_SALEN)
1474 AC_MSG_RESULT($sc_cv_struct_sockaddr_salen)
1476 ### IP6 sockaddr_in6
1478 AC_MSG_CHECKING(for component names of sockaddr_in6)
1479 AC_TRY_COMPILE([#include <sys/types.h>
1480 #include <netinet/in.h>],
1481 [struct sockaddr_in6 sa6;sa6.sin6_addr.s6_addr[0]=0;],
1482 [AC_MSG_RESULT(s6_addr);
1483 AC_DEFINE(HAVE_IP6_SOCKADDR, 0)],
1484 [AC_TRY_COMPILE([#include <sys/types.h>
1485 #include <netinet/in.h>],
1486 [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr.u6_addr16[0]=0;],
1487 [AC_MSG_RESULT(u6_addr.u6_addr16);
1488 AC_DEFINE(HAVE_IP6_SOCKADDR, 1)],
1489 [AC_TRY_COMPILE([#include <sys/types.h>
1490 #include <netinet/in.h>],
1491 [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr16[0]=0;],
1492 [AC_MSG_RESULT(u6_addr16); AC_DEFINE(HAVE_IP6_SOCKADDR, 2)],
1493 [AC_TRY_COMPILE([#include <sys/types.h>
1494 #include <netinet/in.h>],
1495 [struct sockaddr_in6 sa6;sa6.sin6_addr.in6_u.u6_addr16[0]=0;],
1496 [AC_MSG_RESULT(in6_u.u6_addr16);
1497 AC_DEFINE(HAVE_IP6_SOCKADDR, 3)],
1498 [AC_TRY_COMPILE([#include <sys/types.h>
1499 #include <netinet/in.h>],
1500 [struct sockaddr_in6 sa6;sa6.sin6_addr._S6_un._S6_u32[0]=0;],
1501 [AC_MSG_RESULT(_S6_un._S6_u32);
1502 AC_DEFINE(HAVE_IP6_SOCKADDR, 4)],
1503 [AC_TRY_COMPILE([#include <sys/types.h>
1504 #include <netinet/in.h>],
1505 [struct sockaddr_in6 sa6;sa6.sin6_addr.__u6_addr.__u6_addr32[0]=0;],
1506 [AC_MSG_RESULT(__u6_addr.__u6_addr32);
1507 AC_DEFINE(HAVE_IP6_SOCKADDR, 5)],
1509 [AC_MSG_RESULT([none or unknown])]
1512 dnl Check for struct iovec
1513 AC_MSG_CHECKING(for struct iovec)
1514 AC_CACHE_VAL(sc_cv_struct_iovec,
1515 [AC_TRY_COMPILE([#include <sys/uio.h>],[struct iovec s;],
1516 [sc_cv_struct_iovec=yes],
1517 [sc_cv_struct_iovec=no])])
1518 if test $sc_cv_struct_iovec = yes; then
1519 AC_DEFINE(HAVE_STRUCT_IOVEC)
1521 AC_MSG_RESULT($sc_cv_struct_iovec)
1523 dnl check for msg_control in struct msghdr
1524 AC_MSG_CHECKING(for struct msghdr.msg_control)
1525 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrol,
1526 [AC_TRY_COMPILE([#include <sys/types.h>
1527 #include <sys/socket.h>],
1528 [struct msghdr s;s.msg_control=0;],
1529 [sc_cv_struct_msghdr_msgcontrol=yes],
1530 [sc_cv_struct_msghdr_msgcontrol=no])])
1531 if test $sc_cv_struct_msghdr_msgcontrol = yes; then
1532 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROL)
1534 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrol)
1536 dnl check for msg_controllen in struct msghdr
1537 AC_MSG_CHECKING(for struct msghdr.msg_controllen)
1538 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrollen,
1539 [AC_TRY_COMPILE([#include <sys/types.h>
1540 #include <sys/socket.h>],
1541 [struct msghdr s;s.msg_controllen=0;],
1542 [sc_cv_struct_msghdr_msgcontrollen=yes],
1543 [sc_cv_struct_msghdr_msgcontrollen=no])])
1544 if test $sc_cv_struct_msghdr_msgcontrollen = yes; then
1545 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN)
1547 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrollen)
1549 dnl check for msg_flags in struct msghdr
1550 AC_MSG_CHECKING(for struct msghdr.msgflags)
1551 AC_CACHE_VAL(sc_cv_struct_msghdr_msgflags,
1552 [AC_TRY_COMPILE([#include <sys/types.h>
1553 #include <sys/socket.h>],
1554 [struct msghdr s;s.msg_flags=0;],
1555 [sc_cv_struct_msghdr_msgflags=yes],
1556 [sc_cv_struct_msghdr_msgflags=no])])
1557 if test $sc_cv_struct_msghdr_msgflags = yes; then
1558 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGFLAGS)
1560 AC_MSG_RESULT($sc_cv_struct_msghdr_msgflags)
1562 dnl check for struct cmsghdr
1563 AC_MSG_CHECKING(for struct cmsghdr)
1564 AC_CACHE_VAL(sc_cv_struct_cmsghdr,
1565 [AC_TRY_COMPILE([#include <sys/types.h>
1566 #include <sys/socket.h>
1567 #include <net/if.h>],[struct cmsghdr s;],
1568 [sc_cv_struct_cmsghdr=yes],
1569 [sc_cv_struct_cmsghdr=no])])
1570 if test $sc_cv_struct_cmsghdr = yes; then
1571 AC_DEFINE(HAVE_STRUCT_CMSGHDR)
1573 AC_MSG_RESULT($sc_cv_struct_cmsghdr)
1575 dnl check for struct in_pktinfo
1576 AC_MSG_CHECKING(for struct in_pktinfo)
1577 AC_CACHE_VAL(sc_cv_struct_in_pktinfo,
1578 [AC_TRY_COMPILE([#include <sys/types.h>
1579 #include <sys/socket.h>
1580 #include <netinet/in.h>],[struct in_pktinfo s;],
1581 [sc_cv_struct_in_pktinfo=yes],
1582 [sc_cv_struct_in_pktinfo=no])])
1583 if test $sc_cv_struct_in_pktinfo = yes; then
1584 AC_DEFINE(HAVE_STRUCT_IN_PKTINFO)
1586 AC_MSG_RESULT($sc_cv_struct_in_pktinfo)
1588 if test $sc_cv_struct_in_pktinfo = 'yes'; then
1589 dnl check for component ipi_spec_dst in struct in_pktinfo
1590 AC_MSG_CHECKING(for ipi_spec_dst in struct in_pktinfo)
1591 AC_CACHE_VAL(sc_cv_pktinfo_ipi_spec_dst,
1592 [AC_TRY_COMPILE([#include <sys/types.h>
1593 #include <sys/socket.h>
1594 #include <netinet/in.h>],[struct in_pktinfo s; s.ipi_spec_dst],
1595 [sc_cv_pktinfo_ipi_spec_dst=yes],
1596 [sc_cv_pktinfo_ipi_spec_dst=no])])
1597 if test $sc_cv_pktinfo_ipi_spec_dst = yes; then
1598 AC_DEFINE(HAVE_PKTINFO_IPI_SPEC_DST)
1600 AC_MSG_RESULT($sc_cv_pktinfo_ipi_spec_dst)
1603 dnl check for struct in6_pktinfo
1604 AC_MSG_CHECKING(for struct in6_pktinfo)
1605 AC_CACHE_VAL(sc_cv_struct_in6_pktinfo,
1606 [AC_TRY_COMPILE([#include "sysincludes.h"],
1607 [struct in6_pktinfo s;],
1608 [sc_cv_struct_in6_pktinfo=yes],
1609 [sc_cv_struct_in6_pktinfo=no])])
1610 if test $sc_cv_struct_in6_pktinfo = yes; then
1611 AC_DEFINE(HAVE_STRUCT_IN6_PKTINFO)
1613 AC_MSG_RESULT($sc_cv_struct_in6_pktinfo)
1615 dnl check for struct tpacket_auxdata
1616 AC_MSG_CHECKING(for struct tpacket_auxdata)
1617 AC_CACHE_VAL(sc_cv_struct_tpacket_auxdata,
1618 [AC_TRY_COMPILE([#include "sysincludes.h"],
1619 [struct tpacket_auxdata s;],
1620 [sc_cv_struct_tpacket_auxdata=yes],
1621 [sc_cv_struct_tpacket_auxdata=no])])
1622 if test $sc_cv_struct_tpacket_auxdata = yes; then
1623 AC_DEFINE(HAVE_STRUCT_TPACKET_AUXDATA)
1625 AC_MSG_RESULT($sc_cv_struct_tpacket_auxdata)
1627 AC_MSG_CHECKING(for tp_vlan_tpid in struct tpacket_auxdata)
1628 AC_CACHE_VAL(sc_cv_struct_tpacket_auxdata_tp_vlan_tpid,
1629 [AC_TRY_COMPILE([#include "sysincludes.h"],
1630 [struct tpacket_auxdata s; s.tp_vlan_tpid=0],
1631 [sc_cv_struct_tpacket_auxdata_tp_vlan_tpid=yes],
1632 [sc_cv_struct_tpacket_auxdata_tp_vlan_tpid=no])])
1633 if test $sc_cv_struct_tpacket_auxdata_tp_vlan_tpid = yes; then
1634 AC_DEFINE(HAVE_STRUCT_TPACKET_AUXDATA_TP_VLAN_TPID)
1636 AC_MSG_RESULT($sc_cv_struct_tpacket_auxdata)
1638 dnl check for ip_hl in struct ip
1639 AC_MSG_CHECKING(for struct ip.ip_hl)
1640 AC_CACHE_VAL(sc_cv_struct_ip_ip_hl,
1641 [AC_TRY_COMPILE([#include <sys/types.h>
1642 #include <netinet/in_systm.h>
1643 #include <netinet/in.h>
1644 #include <netinet/ip.h>],
1645 [struct ip s;s.ip_hl=0;],
1646 [sc_cv_struct_ip_ip_hl=yes],
1647 [sc_cv_struct_ip_ip_hl=no])])
1648 if test $sc_cv_struct_ip_ip_hl = yes; then
1649 AC_DEFINE(HAVE_STRUCT_IP_IP_HL)
1651 AC_MSG_RESULT($sc_cv_struct_ip_ip_hl)
1654 dnl Library function checks
1656 dnl Check sigaction()
1657 AC_CHECK_FUNC(sigaction, AC_DEFINE(HAVE_SIGACTION))
1659 dnl Check for 64bit versions of system calls
1660 AC_CHECK_FUNC(stat64, AC_DEFINE(HAVE_STAT64))
1661 AC_CHECK_FUNC(fstat64, AC_DEFINE(HAVE_FSTAT64))
1662 AC_CHECK_FUNC(lstat64, AC_DEFINE(HAVE_LSTAT64))
1663 AC_CHECK_FUNC(lseek64, AC_DEFINE(HAVE_LSEEK64))
1664 AC_CHECK_FUNC(truncate64, AC_DEFINE(HAVE_TRUNCATE64))
1665 AC_CHECK_FUNC(ftruncate64, AC_DEFINE(HAVE_FTRUNCATE64))
1667 AC_CHECK_FUNC(strtoll, AC_DEFINE(HAVE_STRTOLL))
1668 AC_CHECK_FUNC(hstrerror, AC_DEFINE(HAVE_HSTRERROR))
1669 AC_CHECK_FUNC(inet_ntop, AC_DEFINE(HAVE_INET_NTOP))
1671 #if test "$ac_cv_func_hstrerror" = "yes"; then
1672 # AC_MSG_CHECKING(if _XOPEN_SOURCE_EXTENDED is helpful)
1673 # AC_CACHE_VAL(ac_cv_xopen_source_extended,
1674 # [AC_TRY_COMPILE([#include <netdb.h>],
1676 # [ac_cv_xopen_source_extended=no],
1677 # [AC_TRY_COMPILE([#define _XOPEN_SOURCE_EXTENDED 1
1678 ## include <netdb.h>],
1680 # [ac_cv_xopen_source_extended=yes],
1681 # [ac_cv_xopen_source_extended=no]
1684 # if test $ac_cv_xopen_source_extended = yes; then
1685 # AC_DEFINE(_XOPEN_SOURCE_EXTENDED)
1687 # AC_MSG_RESULT($ac_cv_xopen_source_extended)
1690 dnl Search for openpty()
1692 AC_CHECK_FUNC(openpty, AC_DEFINE(HAVE_OPENPTY))
1694 AC_CHECK_LIB(bsd, openpty,
1695 [LIBS="-lbsd $LIBS"; AC_DEFINE(HAVE_OPENPTY)])
1697 AC_CHECK_LIB(util, openpty,
1698 [LIBS="-lutil $LIBS"; AC_DEFINE(HAVE_OPENPTY)])
1700 AC_CHECK_PROTOTYPE_LIB(gettimeofday)
1702 AC_CHECK_FUNC(clock_gettime, AC_DEFINE(HAVE_CLOCK_GETTIME), AC_CHECK_LIB(rt, clock_gettime, [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_CLOCK_GETTIME)]))
1704 dnl Search for flock()
1705 # with Linux it's in libc, with AIX in libbsd
1706 AC_CHECK_FUNC(flock, AC_DEFINE(HAVE_FLOCK),
1707 AC_CHECK_LIB(bsd, flock, [LIBS="-lbsd $LIBS"]))
1709 dnl Search for setenv()
1710 AC_CHECK_FUNC(setenv, AC_DEFINE(HAVE_SETENV),
1711 AC_CHECK_LIB(isode, setenv, [LIBS="-lisode $LIBS"]))
1713 dnl Search for unsetenv()
1714 AC_CHECK_FUNC(unsetenv, AC_DEFINE(HAVE_UNSETENV))
1716 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]))
1717 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]))
1718 AC_CHECK_FUNC(DTLS_client_method, AC_DEFINE(HAVE_DTLS_client_method), AC_CHECK_LIB(crypt, DTLS_client_method, [LIBS=-lcrypt $LIBS]))
1719 AC_CHECK_FUNC(DTLS_server_method, AC_DEFINE(HAVE_DTLS_server_method), AC_CHECK_LIB(crypt, DTLS_server_method, [LIBS=-lcrypt $LIBS]))
1720 if test -n "$WITH_OPENSSL_METHOD" -o -z "$ac_cv_have_tls_client_method" -o -z "$ac_cv_have_tls_server_method" ; then
1721 dnl Search for SSLv2_client_method, SSLv2_server_method
1722 AC_CHECK_FUNC(SSLv2_client_method, AC_DEFINE(HAVE_SSLv2_client_method), AC_CHECK_LIB(crypt, SSLv2_client_method, [LIBS=-lcrypt $LIBS]))
1723 AC_CHECK_FUNC(SSLv2_server_method, AC_DEFINE(HAVE_SSLv2_server_method), AC_CHECK_LIB(crypt, SSLv2_server_method, [LIBS=-lcrypt $LIBS]))
1725 AC_CHECK_FUNC(SSLv3_client_method, AC_DEFINE(HAVE_SSLv3_client_method), AC_CHECK_LIB(crypt, SSLv3_client_method, [LIBS=-lcrypt $LIBS]))
1726 AC_CHECK_FUNC(SSLv3_server_method, AC_DEFINE(HAVE_SSLv3_server_method), AC_CHECK_LIB(crypt, SSLv3_server_method, [LIBS=-lcrypt $LIBS]))
1727 AC_CHECK_FUNC(SSLv23_client_method, AC_DEFINE(HAVE_SSLv23_client_method), AC_CHECK_LIB(crypt, SSLv23_client_method, [LIBS=-lcrypt $LIBS]))
1728 AC_CHECK_FUNC(SSLv23_server_method, AC_DEFINE(HAVE_SSLv23_server_method), AC_CHECK_LIB(crypt, SSLv23_server_method, [LIBS=-lcrypt $LIBS]))
1729 AC_CHECK_FUNC(TLSv1_client_method, AC_DEFINE(HAVE_TLSv1_client_method), AC_CHECK_LIB(crypt, TLSv1_client_method, [LIBS=-lcrypt $LIBS]))
1730 AC_CHECK_FUNC(TLSv1_server_method, AC_DEFINE(HAVE_TLSv1_server_method), AC_CHECK_LIB(crypt, TLSv1_server_method, [LIBS=-lcrypt $LIBS]))
1731 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]))
1732 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]))
1733 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]))
1734 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]))
1735 AC_CHECK_FUNC(DTLSv1_client_method, AC_DEFINE(HAVE_DTLSv1_client_method), AC_CHECK_LIB(crypt, DTLSv1_client_method, [LIBS=-lcrypt $LIBS]))
1736 AC_CHECK_FUNC(DTLSv1_server_method, AC_DEFINE(HAVE_DTLSv1_server_method), AC_CHECK_LIB(crypt, DTLSv1_server_method, [LIBS=-lcrypt $LIBS]))
1737 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]))
1738 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]))
1739 fi # $WITH_OPENSSL_METHOD
1741 AC_CHECK_FUNC(SSL_CTX_set_default_verify_paths, AC_DEFINE(HAVE_SSL_CTX_set_default_verify_paths))
1742 AC_CHECK_FUNC(RAND_egd, AC_DEFINE(HAVE_RAND_egd), AC_CHECK_LIB(crypt, RAND_egd, [LIBS=-lcrypt $LIBS]))
1743 AC_CHECK_FUNC(DH_set0_pqg, AC_DEFINE(HAVE_DH_set0_pqg), AC_CHECK_LIB(crypt, DH_set0_pqg, [LIBS=-lcrypt $LIBS]))
1744 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]))
1745 AC_CHECK_FUNC(RAND_status, AC_DEFINE(HAVE_RAND_status))
1746 AC_CHECK_FUNC(SSL_CTX_clear_mode, AC_DEFINE(HAVE_SSL_CTX_clear_mode))
1747 AC_CHECK_FUNC(SSL_set_tlsext_host_name, AC_DEFINE(HAVE_SSL_set_tlsext_host_name))
1748 AC_CHECK_FUNC(SSL_CTX_set_tlsext_max_fragment_length, AC_DEFINE(HAVE_SSL_CTX_set_tlsext_max_fragment_length))
1750 AC_MSG_CHECKING(if SSL_CTX_set_max_send_fragment exists)
1751 AC_CACHE_VAL(ac_cv_have_SSL_CTX_set_max_send_fragment,
1752 [AC_TRY_COMPILE([#include <openssl/ssl.h>],[
1753 #ifndef SSL_CTX_set_max_send_fragment
1754 #error "SSL_CTX_set_max_send_fragment not found"
1757 [ac_cv_have_SSL_CTX_set_max_send_fragment=yes],
1758 [ac_cv_have_SSL_CTX_set_max_send_fragment=no])]
1760 if test $ac_cv_have_SSL_CTX_set_max_send_fragment = yes; then
1761 AC_DEFINE(HAVE_SSL_CTX_set_max_send_fragment)
1763 AC_MSG_RESULT($ac_cv_have_SSL_CTX_set_max_send_fragment)
1765 AC_CHECK_FUNC(SSL_library_init, AC_DEFINE(HAVE_SSL_library_init))
1766 AC_CHECK_FUNC(ERR_error_string, AC_DEFINE(HAVE_ERR_error_string))
1768 AC_MSG_CHECKING(for type EC_KEY)
1769 AC_CACHE_VAL(sc_cv_type_EC_TYPE,
1770 [AC_TRY_COMPILE([#include <openssl/ec.h>
1772 [sc_cv_type_EC_KEY=yes],
1773 [sc_cv_type_EC_KEY=no])])
1774 if test $sc_cv_type_EC_KEY = yes; then
1775 AC_DEFINE(HAVE_TYPE_EC_KEY)
1777 AC_MSG_RESULT($sc_cv_type_EC_KEY)
1783 AC_MSG_CHECKING(if snprintf conforms to C99)
1784 AC_CACHE_VAL(ac_cv_have_c99_snprintf,
1790 exit(snprintf(s,2,"ab")!=2);
1792 [ac_cv_have_c99_snprintf=yes],
1793 [ac_cv_have_c99_snprintf=no],
1794 [ac_cv_have_c99_snprintf=no])])
1795 if test $ac_cv_have_c99_snprintf = yes; then
1796 AC_DEFINE(HAVE_C99_SNPRINTF)
1798 AC_MSG_RESULT($ac_cv_have_c99_snprintf)
1801 AC_MSG_CHECKING(if printf has Z modifier)
1802 AC_CACHE_VAL(ac_cv_have_z_modifier,
1803 if test "$cc" = gcc; then
1810 exit(strcmp(s,"1"));
1812 [ac_cv_have_z_modifier=yes],
1813 [ac_cv_have_z_modifier=no],
1814 [ac_cv_have_z_modifier=no])]
1815 else ac_cv_have_z_modifier=no
1818 if test $ac_cv_have_z_modifier = yes; then
1819 AC_DEFINE(HAVE_FORMAT_Z)
1821 AC_MSG_RESULT($ac_cv_have_z_modifier)
1824 dnl find the number of bits we must shift a value to match the given mask
1825 dnl (e.g., mask 0x00f0 requires shifting with 4)
1826 ## NOTE: some platforms only need one '\' to escape '"' in string constant
1827 define(AC_SHIFT_OFFSET,[
1828 AC_CACHE_CHECK(shift offset of $1, $2,
1829 [LIBS1="$LIBS"; LIBS="" # avoid libwrap allow_severity undefined
1830 conftestoffset="conftestoffset.out"
1835 #include <termios.h>
1838 unsigned int i,n=$1;
1840 if ((f=fopen("$conftestoffset","w"))==NULL){
1841 fprintf(stderr,"\\"$conftestoffset\\": %s\n",strerror(errno)); exit(-1);
1843 if (n==0) {fprintf(stderr,"$1 is 0 (impossible!)\n"); exit(1);}
1844 i=0; while (!(n&1)) {
1847 fprintf(f, "%u", i);
1849 fprintf(f, "-1"); /* anticipate result of xioinitialize assert */
1854 [$2=`cat $conftestoffset`],
1859 AC_DEFINE_UNQUOTED($1_SHIFT, ${$2})
1860 if test "$2" = -1; then
1861 AC_MSG_WARN(please determine $1_SHIFT manually)
1865 AC_SHIFT_OFFSET(CRDLY, sc_cv_sys_crdly_shift)
1866 AC_SHIFT_OFFSET(TABDLY, sc_cv_sys_tabdly_shift)
1867 AC_SHIFT_OFFSET(CSIZE, sc_cv_sys_csize_shift)
1870 dnl Find what physical type (basic C type) is equivalent to the given type.
1871 dnl If possible we try to compile simple test code and get no warning only with
1872 dnl the matching type.
1873 dnl If this method does not seem to work we run test programs that print the
1874 dnl length and signedness of the type.
1876 dnl do we have a -Werror option?
1877 dnl Does the test code compile with -Werror when types fit?
1878 CHANCE_TO_TYPECHECK=1
1879 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1880 AC_TRY_COMPILE([#include <stdlib.h>],[int u; int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)
1883 dnl Does the test code compile without -Werror when types do not fit?
1884 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1885 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)
1888 dnl Does the test code fail to compile with -Werror when types do not fit?
1889 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1890 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1891 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],CHANCE_TO_TYPECHECK=0,)
1895 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1896 AC_MSG_NOTICE(using compile -Werror method to find basic types)
1898 AC_MSG_NOTICE(using code run method to find basic types)
1902 dnl see AC_BASIC_TYPE
1903 define(AC_BASIC_TYPE_GCC,[
1904 AC_CACHE_CHECK(for equivalent simple type of $2, $4,
1905 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
1906 dnl echo "echo: trying short for $2" >&2
1907 AC_TRY_COMPILE([$1],[$2 u; short v; return(&u==&v);],
1908 [$4="1 /* short */"],
1909 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u==&v);],
1910 [$4="2 /* unsigned short */"],
1911 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u==&v);],
1913 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u==&v);],
1914 [$4="4 /* unsigned int */"],
1915 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u==&v);],
1916 [$4="5 /* long */"],
1917 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u==&v);],
1918 [$4="6 /* unsigned long */"],
1919 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u==&v);],
1920 [$4="7 /* long long */"],
1921 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u==&v);],
1922 [$4="8 /* unsigned long long */"],
1923 [$4="0 /* unknown, taking default */"
1924 ]) ]) ]) ]) ]) ]) ]) ])
1925 CFLAGS="$CFLAGS1" ])
1926 AC_DEFINE_UNQUOTED($3, ${$4})
1929 dnl see AC_BASIC_TYPE
1930 define(AC_BASIC_TYPE_OTHER,[
1931 AC_CACHE_CHECK(for equivalent simple type of $2, $4,
1934 int main() { return!(sizeof($2)==sizeof(short));}],
1935 # same length as short
1938 int main() { $2 x=-1; return !(x<0);}],
1939 [$4="1 /* short */"],
1940 [$4="2 /* unsigned short */"]),
1941 # length differs from short, try others
1944 int main() { return!(sizeof($2)==sizeof(int));}],
1945 # same length as int
1948 int main() { $2 x=-1; return !(x<0);}],
1950 [$4="4 /* unsigned int */"]),
1951 # length differs from int, try others
1954 int main() { return !(sizeof($2)==sizeof(long));}],
1955 # same length as long
1958 int main() { $2 x=-1; return !(x<0);}],
1959 [$4="5 /* long */"],
1960 [$4="6 /* unsigned long */"] ),
1961 # length differs from long, try others
1964 int main() { return !(sizeof($2)==sizeof(long long));}],
1965 # same length as long long
1968 int main() { $2 x=-1; return !(x<0);}],
1969 [$4="7 /* long long */"],
1970 [$4="8 /* unsigned long long */"] ),
1971 [$4="0 /* unknown */"]
1977 AC_DEFINE_UNQUOTED($3, ${$4})
1980 dnl find what physical type (basic C type) is equivalent to the given type.
1981 dnl arg1: include file(s)
1983 dnl arg3: output variable
1984 dnl arg4: cache variable (might be constructed automatically)
1985 dnl output values: 1..short, 2..unsigned short, 3..int, 4..u-int,
1986 dnl 5..long, 6..u-long; others not yet supported
1987 define(AC_BASIC_TYPE,[
1988 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
1989 AC_BASIC_TYPE_GCC([$1],[$2],[$3],[$4])
1991 AC_BASIC_TYPE_OTHER([$1],[$2],[$3],[$4])
1996 dnl See AC_TYPEOF_COMPONENT
1997 dnl This version is for compilers with -Werror or so: gcc, clang, Sun Studio?
1998 define(AC_TYPEOF_COMPONENT_GCC,[
1999 AC_CACHE_CHECK(for basic type of $2.$3, $5,
2000 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"
2001 AC_TRY_COMPILE([$1],[$2 u;short v; return(&u.$3==&v);],
2002 [$5="1 /* short */"],
2003 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u.$3==&v);],
2004 [$5="2 /* unsigned short */"],
2005 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u.$3==&v);],
2007 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u.$3==&v);],
2008 [$5="4 /* unsigned int */"],
2009 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u.$3==&v);],
2010 [$5="5 /* long */"],
2011 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u.$3==&v);],
2012 [$5="6 /* unsigned long */"],
2013 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u.$3==&v);],
2014 [$5="7 /* long long */"],
2015 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u.$3==&v);],
2016 [$5="8 /* unsigned long long */"],
2017 [$5="0 /* unknown, taking default */"
2018 ]) ]) ]) ]) ]) ]) ]) ])
2019 CFLAGS="$CFLAGS1" ])
2020 AC_DEFINE_UNQUOTED($4, ${$5})
2023 dnl See AC_TYPEOF_COMPONENT
2024 dnl This version is for compilers with no -Werror or so
2025 define(AC_TYPEOF_COMPONENT_OTHER,[
2026 AC_CACHE_CHECK(for basic type of $2.$3, $5,
2029 int main() { $2 x; return!(sizeof(x.$3)==sizeof(short));}],
2030 # same length as short
2033 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
2034 [$5="1 /* short */"],
2035 [$5="2 /* unsigned short */"]),
2036 # length differs from short, try others
2039 int main() { $2 x; return!(sizeof(x.$3)==sizeof(int));}],
2040 # same length as int
2043 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
2045 [$5="4 /* unsigned int */"]),
2046 # length differs from int, try others
2049 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long));}],
2050 # same length as long
2053 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],
2054 [$5="5 /* long */"],
2055 [$5="6 /* unsigned long */"] ),
2056 # length differs from long, try others
2059 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long long));}],
2060 # same length as long long
2063 int main() { x $2; x.$3=-1; return !(x.$3<0);}],
2064 [$5="7 /* long long */"],
2065 [$5="8 /* unsigned long long */"] ),
2066 [$5="0 /* unknown */"]
2072 AC_DEFINE_UNQUOTED($4, ${$5})
2075 dnl find what physical type (basic C type) describes the given struct or union
2077 dnl arg1: include file(s); must declare the structure type
2078 dnl arg2: struct name (e.g., "struct stat")
2079 dnl arg3: variable or component (e.g., "st_ino")
2080 dnl arg4: output variable, values see AC_BASIC_TYPE
2081 dnl arg5: cache variable (might be constructed automatically)
2082 define(AC_TYPEOF_COMPONENT,[
2083 if test "$CHANCE_TO_TYPECHECK" -ne 0; then
2084 AC_TYPEOF_COMPONENT_GCC([$1],[$2],[$3],[$4],[$5])
2086 AC_TYPEOF_COMPONENT_OTHER([$1],[$2],[$3],[$4],[$5])
2090 AC_BASIC_TYPE([#include <stdint.h>], uint16_t, HAVE_BASIC_UINT16_T, sc_cv_type_uint16_basic)
2091 AC_BASIC_TYPE([#include <stdint.h>], uint32_t, HAVE_BASIC_UINT32_T, sc_cv_type_uint32_basic)
2092 AC_BASIC_TYPE([#include <stdint.h>], uint64_t, HAVE_BASIC_UINT64_T, sc_cv_type_uint64_basic)
2093 AC_BASIC_TYPE([#include <stdint.h>], int16_t, HAVE_BASIC_INT16_T, sc_cv_type_int16_basic)
2094 AC_BASIC_TYPE([#include <stdint.h>], int32_t, HAVE_BASIC_INT32_T, sc_cv_type_int32_basic)
2095 AC_BASIC_TYPE([#include <stdint.h>], int64_t, HAVE_BASIC_INT64_T, sc_cv_type_int64_basic)
2096 AC_BASIC_TYPE([#include <stdlib.h>], size_t, HAVE_BASIC_SIZE_T, sc_cv_type_sizet_basic)
2097 AC_BASIC_TYPE([#include <sys/types.h>
2098 #include <sys/stat.h>
2099 #include <unistd.h>], mode_t, HAVE_BASIC_MODE_T, sc_cv_type_modet_basic)
2100 AC_BASIC_TYPE([#include <sys/types.h>
2101 #include <unistd.h>], pid_t, HAVE_BASIC_PID_T, sc_cv_type_pidt_basic)
2102 AC_BASIC_TYPE([#include <sys/types.h>
2103 #include <unistd.h>], uid_t, HAVE_BASIC_UID_T, sc_cv_type_uidt_basic)
2104 AC_BASIC_TYPE([#include <sys/types.h>
2105 #include <unistd.h>], gid_t, HAVE_BASIC_GID_T, sc_cv_type_gidt_basic)
2107 AC_BASIC_TYPE([#include <time.h>], time_t, HAVE_BASIC_TIME_T,
2108 sc_cv_type_timet_basic)
2110 # this is questionable, might fail on some systems
2111 AC_BASIC_TYPE([#include <sys/types.h>
2112 #include <sys/socket.h>
2113 #include <unistd.h>], socklen_t, HAVE_BASIC_SOCKLEN_T,
2114 sc_cv_type_socklent_basic)
2116 AC_BASIC_TYPE([#include <sys/types.h>
2117 #include <unistd.h>], off_t, HAVE_BASIC_OFF_T, sc_cv_type_off_basic)
2119 AC_BASIC_TYPE([#include <sys/types.h>
2120 #include <unistd.h>], off64_t, HAVE_BASIC_OFF64_T, sc_cv_type_off64_basic)
2122 # oh god, __dev_t in Linux 2.4 is struct{int[2];}, not handled here yet.
2123 AC_BASIC_TYPE([#include <sys/stat.h>], dev_t, HAVE_BASIC_DEV_T, sc_cv_type_dev_basic)
2125 AC_BASIC_TYPE([#include <unistd.h>
2126 #include <termios.h>], speed_t, HAVE_BASIC_SPEED_T, sc_cv_type_spee_t)
2128 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_ino, HAVE_TYPEOF_ST_INO, sc_cv_type_stat_stino_basic)
2129 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_nlink, HAVE_TYPEOF_ST_NLINK, sc_cv_type_stat_stnlink_basic)
2130 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_size, HAVE_TYPEOF_ST_SIZE, sc_cv_type_stat_stsize_basic)
2131 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blksize, HAVE_TYPEOF_ST_BLKSIZE, sc_cv_type_stat_stblksize_basic)
2132 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blocks, HAVE_TYPEOF_ST_BLOCKS, sc_cv_type_stat_stblocks_basic)
2134 if test "$ac_cv_func_stat64" = yes; then
2135 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_dev, HAVE_TYPEOF_ST64_DEV, sc_cv_type_stat64_stdev_basic)
2136 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_ino, HAVE_TYPEOF_ST64_INO, sc_cv_type_stat64_stino_basic)
2137 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_nlink, HAVE_TYPEOF_ST64_NLINK, sc_cv_type_stat64_stnlink_basic)
2138 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_size, HAVE_TYPEOF_ST64_SIZE, sc_cv_type_stat64_stsize_basic)
2139 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blksize, HAVE_TYPEOF_ST64_BLKSIZE, sc_cv_type_stat64_stblksize_basic)
2140 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blocks, HAVE_TYPEOF_ST64_BLOCKS, sc_cv_type_stat64_stblocks_basic)
2143 AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timeval, tv_usec, HAVE_TYPEOF_STRUCT_TIMEVAL_TV_USEC, sc_cv_type_struct_timeval_tv_usec)
2145 AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timespec, tv_nsec, HAVE_TYPEOF_STRUCT_TIMESPEC_TV_NSEC, sc_cv_type_struct_timespec_tv_nsec)
2147 AC_TYPEOF_COMPONENT([#include <sys/types.h>
2148 #include <sys/time.h>
2149 #include <sys/resource.h>],
2150 struct rlimit, rlim_max, HAVE_TYPEOF_RLIM_MAX, sc_cv_type_rlimit_rlimmax_basic)
2152 # Fedora-19 doc says it is socklen_t which is equivalent to unsigned int, but it is equivalent to size_t (x86_64)
2153 AC_TYPEOF_COMPONENT([#include "sysincludes.h"], struct cmsghdr, cmsg_len, HAVE_TYPEOF_STRUCT_CMSGHDR_CMSG_LEN, sc_cv_typeof_struct_cmsghdr_cmsg_len)
2154 ### snprintf, vsnprintf
2156 AC_MSG_CHECKING(for /dev/ptmx)
2157 if test -c /dev/ptmx; then
2158 AC_DEFINE(HAVE_DEV_PTMX, 1)
2162 AC_MSG_CHECKING(for /dev/ptc)
2163 if test -c /dev/ptc; then
2164 AC_DEFINE(HAVE_DEV_PTC)
2171 AC_MSG_CHECKING(for /proc)
2172 if test -d /proc; then
2173 AC_DEFINE(HAVE_PROC_DIR, 1)
2179 AC_MSG_CHECKING(for /proc/*/fd)
2180 if test -d /proc/$$/fd; then
2181 AC_DEFINE(HAVE_PROC_DIR_FD, 1)
2187 # On Solaris family, we have to use /proc/$$/path/N
2188 AC_MSG_CHECKING(for /proc/*/path)
2189 if test -d /proc/$$/path; then
2190 AC_DEFINE(HAVE_PROC_DIR_PATH, 1)
2196 # On Solaris family there is not dirent.d_type
2197 AC_MSG_CHECKING(for d_type in struct dirent)
2198 AC_CACHE_VAL(sc_cv_dirent_d_type,
2199 [AC_TRY_COMPILE([#include <dirent.h>],[struct dirent d; d.d_type],
2200 [sc_cv_dirent_d_type=yes],
2201 [sc_cv_dirent_d_type=no])])
2202 if test $sc_cv_dirent_d_type = yes; then
2203 AC_DEFINE(HAVE_DIRENT_D_TYPE)
2205 AC_MSG_RESULT($sc_cv_dirent_d_type)
2207 # Some OSes have undocumented _res.retrans, _res.retry components
2208 AC_MSG_CHECKING(for _res.retrans)
2209 AC_TRY_COMPILE([#include <resolv.h>],
2210 [_res.retrans == 0],
2211 [AC_MSG_RESULT(yes);
2212 AC_DEFINE(HAVE_RES_RETRANS, 1)],
2213 [AC_MSG_RESULT(no)])
2214 AC_MSG_CHECKING(for _res.retry)
2215 AC_TRY_COMPILE([#include <resolv.h>],
2217 [AC_MSG_RESULT(yes);
2218 AC_DEFINE(HAVE_RES_RETRY, 1)],
2219 [AC_MSG_RESULT(no)])
2220 AC_MSG_CHECKING(for _res.nsaddr_list)
2221 AC_TRY_COMPILE([#include <resolv.h>],
2222 [_res.nsaddr_list[0].sin_family == 0],
2223 [AC_MSG_RESULT(yes);
2224 AC_DEFINE(HAVE_RES_NSADDR_LIST, 1)],
2225 [AC_MSG_RESULT(no)])
2228 dnl "tcpd" "tcpwrappers"
2229 # on some platforms, raw linking with libwrap fails because allow_severity and
2230 # deny_severity are not explicitely defined. Thus we put the libwrap part to
2232 AC_MSG_CHECKING(whether to include libwrap support)
2233 AC_ARG_ENABLE(libwrap, [ --disable-libwrap disable libwrap support],
2234 [ case "$enableval" in
2235 no) AC_MSG_RESULT(no); WITH_LIBWRAP= ;;
2236 *) AC_MSG_RESULT(yes); WITH_LIBWRAP=1 ;;
2238 [ AC_MSG_RESULT(yes); WITH_LIBWRAP=1 ])
2240 # check if we find the components of libwrap ("tcpd" "tcpwrappers")
2241 if test -n "$WITH_LIBWRAP"; then
2242 AC_MSG_CHECKING(for components of libwrap)
2243 # first, we need to find the include file <tcpd.h>
2244 AC_CACHE_VAL(sc_cv_have_tcpd_h,
2245 [AC_TRY_COMPILE([#include <sys/types.h>
2246 #include <tcpd.h>],[;],
2247 [sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT=""],
2248 [sc_cv_have_tcpd_h=no
2249 for D in "/sw" "/usr/local" "/opt/freeware" "/usr/sfw"; do
2252 if test -r "$i"; then
2253 #V_INCL="$V_INCL -I$I"
2254 CPPFLAGS="$CPPFLAGS -I$I"
2255 AC_MSG_NOTICE(found $i)
2256 sc_cv_have_tcpd_h=yes; LIBWRAP_ROOT="$D"
2261 if test "$sc_cv_have_tcpd_h" = "yes"; then
2262 AC_DEFINE(HAVE_TCPD_H)
2264 AC_MSG_NOTICE(checked for tcpd.h... $sc_cv_have_tcpd_h)
2265 fi # end checking for tcpd.h
2266 if test -n "$WITH_LIBWRAP" -a "$sc_cv_have_tcpd_h" = yes; then
2267 # next, we search for the wrap library (libwrap.*)
2268 AC_MSG_CHECKING(for libwrap)
2269 AC_CACHE_VAL(sc_cv_have_libwrap,
2271 if test -n "$LIBWRAP_ROOT"; then
2272 L="$LIBWRAP_ROOT/lib"; LIBS="-L$L -lwrap $LIBS"
2276 AC_TRY_LINK([#include <sys/types.h>
2278 int allow_severity,deny_severity;],[hosts_access(0)],
2279 [sc_cv_have_libwrap='yes'],
2280 [sc_cv_have_libwrap='no'
2281 LIBS="$LIBS -lnsl" # RedHat73
2282 AC_TRY_LINK([#include <sys/types.h>
2284 int allow_severity,deny_severity;],[hosts_access(0)],
2285 [sc_cv_have_libwrap='yes'],
2286 [sc_cv_have_libwrap='no'])
2289 if test "$sc_cv_have_libwrap" != 'yes'; then
2294 if test "$sc_cv_have_libwrap" = 'yes'; then
2295 AC_DEFINE(HAVE_LIBWRAP)
2297 AC_MSG_RESULT($sc_cv_have_libwrap)
2300 if test -n "$WITH_LIBWRAP"; then
2301 if test "$sc_cv_have_tcpd_h" = "yes" -a "$sc_cv_have_libwrap" = "yes"; then
2302 AC_DEFINE(WITH_LIBWRAP)
2304 AC_MSG_WARN([not all components of tcp wrappers found, disabling it]);
2308 # check of hosts_allow_table
2309 if test -n "$WITH_LIBWRAP"; then
2310 AC_MSG_CHECKING(for hosts_allow_table)
2311 AC_CACHE_VAL(sc_cv_have_hosts_allow_table,
2312 [AC_TRY_COMPILE([#include <sys/types.h>
2313 #include <tcpd.h>],[hosts_allow_table="";],
2314 [sc_cv_have_hosts_allow_table=yes],
2315 [sc_cv_have_hosts_allow_table=no])])
2316 if test $sc_cv_have_hosts_allow_table = yes; then
2317 AC_DEFINE(HAVE_HOSTS_ALLOW_TABLE)
2319 AC_MSG_RESULT($sc_cv_have_hosts_allow_table)
2320 fi # test -n "$WITH_LIBWRAP"
2323 if test "$GCC" = yes; then
2327 # FIPS support requires compiling with fipsld.
2328 # fipsld requires the FIPSLD_CC variable to be set to the original CC.
2329 # This check must be done after all other checks that require compiling
2330 # so that fipsld is not used by the configure script itself.
2331 if test -n "$WITH_FIPS"; then
2332 if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then
2334 if test "${FIPSLD+set}" != set ; then
2337 CC="FIPSLD_CC=$CC $FIPSLD"
2342 # autoconf does not seem to provide AC_CHECK_VAR or so
2343 # thus we have to check by foot
2344 AC_MSG_CHECKING(for declaration of environ)
2345 AC_CACHE_VAL(sc_cv_decl_environ,
2346 [AC_TRY_COMPILE([#include <unistd.h>],[char **s = environ;],
2347 [sc_cv_decl_environ=yes],
2348 [sc_cv_decl_environ=no])])
2349 if test $sc_cv_decl_environ = yes; then
2350 AC_DEFINE(HAVE_DECL_ENVIRON)
2352 AC_MSG_RESULT($sc_cv_decl_environ)
2354 # on some systems environ exists but not the declaration
2355 AC_MSG_CHECKING(for var environ)
2356 AC_CACHE_VAL(sc_cv_var_environ,
2357 [AC_TRY_COMPILE([],[extern char **environ; char **s = environ;],
2358 [sc_cv_var_environ=yes],
2359 [sc_cv_var_environ=no])])
2360 if test $sc_cv_var_environ = yes; then
2361 AC_DEFINE(HAVE_VAR_ENVIRON)
2363 AC_MSG_RESULT($sc_cv_var_environ)
2365 # allow BUILD_DATE to be externally set for build reproducibility
2366 if test "$SOURCE_DATE_EPOCH"; then
2367 DATE_FMT="%d %b %Y %H:%M:%S"
2368 BUILD_DATE=$(LC_ALL=C date -u -d "@$SOURCE_DATE_EPOCH" "+$DATE_FMT")
2369 AC_DEFINE_UNQUOTED(BUILD_DATE, ["$BUILD_DATE"])
2370 elif test "$BUILD_DATE"; then
2371 AC_DEFINE_UNQUOTED(BUILD_DATE, ["$BUILD_DATE"])
2373 AC_DEFINE(BUILD_DATE, [__DATE__" "__TIME__])