Public Git Hosting - socat.git/blob

1 dnl source: configure.in

2 dnl Copyright Gerhard Rieger and contributors (see file CHANGES)

3 dnl Published under the GNU General Public License V.2, see file COPYING

5 dnl Process this file with autoconf to produce a configure script.

6 AC_INIT(socat.c)

8 AC_CONFIG_HEADER(config.h)

10 if test -f /usr/xpg4/bin/fgrep; then

11 FGREP=/usr/xpg4/bin/fgrep # Solaris

12 else

13 FGREP=fgrep

14 fi

16 # find out which defines gcc passes to cpp, so makedepend does not run into

17 # (harmless) "error architecture not supported"

18 AC_MSG_CHECKING(which defines needed for makedepend)

19 __cpp_defs=`gcc -v -E - </dev/null 2>&1 |$FGREP -e '/cpp ' -e '/cc1 '`

20 SYSDEFS=`aa=; for a in $__cpp_defs

21 do case "$a" in -D*) aa="$aa $a";; esac; done; echo "$aa"`

22 AC_SUBST(SYSDEFS)

23 AC_MSG_RESULT($SYSDEFS)

26 # this must come before AC_PROG_CC

27 if test -z "$CFLAGS"; then

28 # if CFLAGS is not set, we preset it to -O

29 # with this setting, we prevent autoconf from defaulting to "-g -O2"

30 export CFLAGS=-O

31 fi

33 dnl Checks for programs.

34 AC_PROG_INSTALL(install)

35 AC_PROG_CC

36 AC_PROG_RANLIB

37 AC_SUBST(AR)

38 AC_CHECK_PROG(AR, ar, ar, gar)

39 #

40 # we need to explicitely call this here; otherwise, with --disable-libwrap we

41 # fail

42 AC_LANG_COMPILER_REQUIRE()

44 if test "$GCC" = yes; then

45 CFLAGS="$CFLAGS -D_GNU_SOURCE -Wall -Wno-parentheses"

46 ERRONWARN="-Werror -O0"

47 elif test "$CC" = "clang"; then

48 CFLAGS="$CFLAGS -D_GNU_SOURCE -Wall -Wno-parentheses"

49 ERRONWARN="-Werror -O0"

50 #elif Sun Studio

51 # ERRONWARN="-errwarn"

52 else

53 ERRONWARN=

54 fi

55 export CFLAGS

58 dnl Checks for header files.

59 AC_HEADER_STDC

60 AC_CHECK_HEADERS(stdbool.h)

61 AC_CHECK_HEADERS(inttypes.h)

62 AC_HEADER_SYS_WAIT

63 AC_CHECK_HEADERS(fcntl.h limits.h strings.h sys/param.h sys/ioctl.h sys/time.h syslog.h unistd.h)

64 AC_CHECK_HEADERS(pwd.h grp.h stdint.h sys/types.h poll.h sys/poll.h sys/socket.h sys/uio.h sys/stat.h netdb.h sys/un.h)

65 AC_CHECK_HEADERS(pty.h)

66 AC_CHECK_HEADERS(netinet/in.h netinet/in_systm.h)

67 AC_CHECK_HEADERS(netinet/ip.h, [], [], [AC_INCLUDES_DEFAULT

68 #if HAVE_NETINET_IN_H && HAVE_NETINET_IN_SYSTM_H

69 #include <netinet/in.h>

70 #include <netinet/in_systm.h>

71 #endif]) # Solaris prerequisites for netinet/ip.h

72 AC_CHECK_HEADERS(netinet/tcp.h)

73 AC_CHECK_HEADER(net/if.h, AC_DEFINE(HAVE_NET_IF_H), [], [AC_INCLUDES_DEFAULT

74 #if HAVE_SYS_SOCKET_H

75 #include <sys/socket.h>

76 #endif]) # Mac OS X requires including sys/socket.h

77 AC_CHECK_HEADERS(arpa/nameser.h)

79 AC_HEADER_RESOLV()

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))

104

105 dnl Check for function prototype and in lib

106 dnl arg1: function name

107 dnl arg2: required include files beyond sysincludes.h

108 define(AC_CHECK_PROTOTYPE_LIB,[

109 AC_MSG_CHECKING(for $1 prototype)

110 AC_CACHE_VAL(sc_cv_have_prototype_lib_$1,

111 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN -Wall $CFLAGS1";

112 AC_TRY_LINK([#include "sysincludes.h"

113 $2],[return(&$1==(void *)&$1);],

114 [sc_cv_have_prototype_lib_$1=yes],

115 [sc_cv_have_prototype_lib_$1=no]);

116 CFLAGS="$CFLAGS1"])

117 if test $sc_cv_have_prototype_lib_$1 = yes; then

118 AC_DEFINE(HAVE_PROTOTYPE_LIB_$1)

119 fi

120 AC_MSG_RESULT($sc_cv_have_prototype_lib_$1)

121 ])

122

123

124 dnl Check for hstrerror prototype

125 AC_MSG_CHECKING(for hstrerror prototype)

126 AC_CACHE_VAL(sc_cv_have_prototype_hstrerror,

127 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')";

128 AC_TRY_COMPILE([#include <netdb.h>],[hstrerror();],

129 [sc_cv_have_prototype_hstrerror=no],

130 [sc_cv_have_prototype_hstrerror=yes]);

131 CFLAGS="$CFLAGS1"])

132 if test $sc_cv_have_prototype_hstrerror = yes; then

133 AC_DEFINE(HAVE_PROTOTYPE_HSTRERROR)

134 fi

135 AC_MSG_RESULT($sc_cv_have_prototype_hstrerror)

136

137

138 AC_MSG_CHECKING(whether to include help)

139 AC_ARG_ENABLE(help, [ --disable-help disable help],

140 [case "$enableval" in

141 no) AC_MSG_RESULT(no);;

142 *) AC_DEFINE(WITH_HELP) AC_MSG_RESULT(yes);;

143 esac],

144 [AC_DEFINE(WITH_HELP) AC_MSG_RESULT(yes)])

145

146 AC_MSG_CHECKING(whether to include STDIO support)

147 AC_ARG_ENABLE(stdio, [ --disable-stdio disable STDIO support],

148 [case "$enableval" in

149 no) AC_MSG_RESULT(no);;

150 *) AC_DEFINE(WITH_STDIO) AC_MSG_RESULT(yes);;

151 esac],

152 [AC_DEFINE(WITH_STDIO) AC_MSG_RESULT(yes)])

153

154 AC_MSG_CHECKING(whether to include FD-number support)

155 AC_ARG_ENABLE(fdnum, [ --disable-fdnum disable FD-number support],

156 [case "$enableval" in

157 no) AC_MSG_RESULT(no);;

158 *) AC_DEFINE(WITH_FDNUM) AC_MSG_RESULT(yes);;

159 esac],

160 [AC_DEFINE(WITH_FDNUM) AC_MSG_RESULT(yes)])

161

162 AC_MSG_CHECKING(whether to include direct file support)

163 AC_ARG_ENABLE(file, [ --disable-file disable direct file support],

164 [case "$enableval" in

165 no) AC_MSG_RESULT(no);;

166 *) AC_DEFINE(WITH_FILE) AC_MSG_RESULT(yes);;

167 esac],

168 [AC_DEFINE(WITH_FILE) AC_MSG_RESULT(yes)])

169

170 AC_MSG_CHECKING(whether to include direct create support)

171 AC_ARG_ENABLE(creat, [ --disable-creat disable direct create support],

172 [case "$enableval" in

173 no) AC_MSG_RESULT(no);;

174 *) AC_DEFINE(WITH_CREAT) AC_MSG_RESULT(yes);;

175 esac],

176 [AC_DEFINE(WITH_CREAT) AC_MSG_RESULT(yes)])

177

178 AC_MSG_CHECKING(whether to include gopen support)

179 AC_ARG_ENABLE(gopen, [ --disable-gopen disable open for UNIX socket support],

180 [case "$enableval" in

181 no) AC_MSG_RESULT(no);;

182 *) AC_DEFINE(WITH_GOPEN) AC_MSG_RESULT(yes);;

183 esac],

184 [AC_DEFINE(WITH_GOPEN) AC_MSG_RESULT(yes)])

185

186 AC_MSG_CHECKING(whether to include explicit pipe support)

187 AC_ARG_ENABLE(pipe, [ --disable-pipe disable pipe support],

188 [case "$enableval" in

189 no) AC_MSG_RESULT(no);;

190 *) AC_DEFINE(WITH_PIPE) AC_MSG_RESULT(yes);;

191 esac],

192 [AC_DEFINE(WITH_PIPE) AC_MSG_RESULT(yes)])

193

194 AC_MSG_CHECKING(whether to include explicit termios support)

195 AC_ARG_ENABLE(termios, [ --disable-termios disable termios support],

196 [case "$enableval" in

197 no) AC_MSG_RESULT(no);;

198 *) AC_DEFINE(WITH_TERMIOS) AC_MSG_RESULT(yes);;

199 esac],

200 [AC_DEFINE(WITH_TERMIOS) AC_MSG_RESULT(yes)])

201

202 AC_MSG_CHECKING(whether to include UNIX socket support)

203 AC_ARG_ENABLE(unix, [ --disable-unix disable UNIX domain socket support],

204 [case "$enableval" in

205 no) AC_MSG_RESULT(no);;

206 *) AC_DEFINE(WITH_UNIX) AC_MSG_RESULT(yes);;

207 esac],

208 [AC_DEFINE(WITH_UNIX) AC_MSG_RESULT(yes)])

209

210 AC_MSG_CHECKING(whether to include abstract UNIX socket support)

211 AC_ARG_ENABLE(abstract_unixsocket, [ --disable-abstract-unixsocket disable abstract UNIX domain socket support],

212 [case "$enableval" in

213 no) AC_MSG_RESULT(no);;

214 *) AC_DEFINE(WITH_ABSTRACT_UNIXSOCKET) AC_MSG_RESULT(yes);;

215 esac],

216 [ case "`uname`" in

217 Linux)

218 AC_DEFINE(WITH_ABSTRACT_UNIXSOCKET) AC_MSG_RESULT(yes);;

219 *)

220 AC_MSG_RESULT(no);;

221 esac])

222

223 AC_MSG_CHECKING(whether to include IPv4 support)

224 AC_ARG_ENABLE(ip4, [ --disable-ip4 disable IPv4 support],

225 [case "$enableval" in

226 no) AC_MSG_RESULT(no);;

227 *) AC_DEFINE(WITH_IP4) AC_MSG_RESULT(yes);;

228 esac],

229 [AC_DEFINE(WITH_IP4) AC_MSG_RESULT(yes)])

230

231 AC_MSG_CHECKING(whether to include IPv6 support)

232 AC_ARG_ENABLE(ip6, [ --disable-ip6 disable IPv6 support],

233 [case "$enableval" in

234 no) AC_MSG_RESULT(no); WITH_IP6= ;;

235 *) AC_MSG_RESULT(yes); WITH_IP6=1 ;;

236 esac],

237 [ AC_MSG_RESULT(yes); WITH_IP6=1 ])

238 if test "$WITH_IP6"; then

239 AC_CHECK_HEADERS([netinet/ip6.h],

240 [AC_DEFINE(HAVE_NETINET_IP6_H) AC_DEFINE(WITH_IP6)],

241 [AC_MSG_WARN([include file netinet/ip6.h not found, disabling IP6])],

242 [AC_INCLUDES_DEFAULT

243 #ifdef HAVE_NETINET_IN_H

244 # include <netinet/in.h>

245 #endif])

246 AC_CHECK_HEADERS(netinet6/in6.h) # found on OpenBSD and Lion, used for IPV6_*

247

248 AC_MSG_CHECKING(if __APPLE_USE_RFC_2292 is helpful)

249 AC_CACHE_VAL(ac_cv_apple_use_rfc_2292,

250 [AC_TRY_COMPILE(,[#ifndef IPV6_HOPOPTS

251 murks;

252 #endif],

253 [ac_cv_apple_use_rfc_2292=no],

254 [AC_TRY_COMPILE([#define __APPLE_USE_RFC_2292],

255 [#ifndef IPV6_HOPOPTS

256 murks;

257 #endif],

258 [ac_cv_apple_use_rfc_2292=yes],

259 [ac_cv_apple_use_rfc_2292=no]

260 )]

261 )])

262 if test "$ac_cv_apple_use_rfc_2292" = yes; then

263 AC_DEFINE(__APPLE_USE_RFC_2292)

264 fi

265 AC_MSG_RESULT($ac_cv_apple_use_rfc_2292)

266

267 fi

268

269 AC_MSG_CHECKING(whether to include raw IP support)

270 AC_ARG_ENABLE(rawip, [ --disable-rawip disable raw IP support],

271 [case "$enableval" in

272 no) AC_MSG_RESULT(no);;

273 *) AC_DEFINE(WITH_RAWIP) AC_MSG_RESULT(yes);;

274 esac],

275 [AC_DEFINE(WITH_RAWIP) AC_MSG_RESULT(yes)])

276

277 AC_MSG_CHECKING(whether to include generic socket support)

278 AC_ARG_ENABLE(genericsocket, [ --disable-genericsocket disable generic socket support],

279 [case "$enableval" in

280 no) AC_MSG_RESULT(no);;

281 *) AC_DEFINE(WITH_GENERICSOCKET) AC_MSG_RESULT(yes);;

282 esac],

283 [AC_DEFINE(WITH_GENERICSOCKET) AC_MSG_RESULT(yes)])

284 AC_MSG_CHECKING(whether to include generic network interface support)

285 AC_ARG_ENABLE(interface, [ --disable-interface disable network interface support],

286 [case "$enableval" in

287 no) AC_MSG_RESULT(no); WITH_INTERFACE= ;;

288 *) AC_MSG_RESULT(yes); WITH_INTERFACE=1 ;;

289 esac],

290 [AC_MSG_RESULT(yes); WITH_INTERFACE=1 ])

291 if test "$WITH_INTERFACE"; then

292 AC_CHECK_HEADER(netpacket/packet.h,

293 AC_DEFINE(HAVE_NETPACKET_PACKET_H),

294 [WITH_INTERFACE=;

295 AC_MSG_WARN([include file netpacket/packet.h not found, disabling interface])])

296 fi

297 if test "$WITH_INTERFACE"; then

298 AC_CHECK_HEADER(netinet/if_ether.h,

299 AC_DEFINE(HAVE_NETINET_IF_ETHER_H),

300 [WITH_INTERFACE=;

301 AC_MSG_WARN([include file netinet/if_ether.h not found, disabling interface])],

302 [AC_INCLUDES_DEFAULT

303 #if HAVE_NET_IF_H && HAVE_NETINET_IN_H

304 #include <net/if.h>

305 #include <netinet/in.h>

306 #endif])

307 fi

308 if test "$WITH_INTERFACE"; then

309 AC_DEFINE(WITH_INTERFACE)

310 fi

311

312 AC_MSG_CHECKING(whether to include TCP support)

313 AC_ARG_ENABLE(tcp, [ --disable-tcp disable TCP support],

314 [case "$enableval" in

315 no) AC_MSG_RESULT(no);;

316 *) AC_DEFINE(WITH_TCP) AC_MSG_RESULT(yes);;

317 esac],

318 [AC_DEFINE(WITH_TCP) AC_MSG_RESULT(yes)])

319

320 AC_MSG_CHECKING(whether to include UDP support)

321 AC_ARG_ENABLE(udp, [ --disable-udp disable UDP support],

322 [case "$enableval" in

323 no) AC_MSG_RESULT(no);;

324 *) AC_DEFINE(WITH_UDP) AC_MSG_RESULT(yes);;

325 esac],

326 [AC_DEFINE(WITH_UDP) AC_MSG_RESULT(yes)])

327

328 AC_MSG_CHECKING(whether to include SCTP support)

329 AC_ARG_ENABLE(sctp, [ --disable-sctp disable SCTP support],

330 [case "$enableval" in

331 no) AC_MSG_RESULT(no); WITH_SCTP= ;;

332 *) AC_MSG_RESULT(yes); WITH_SCTP=1 ;;

333 esac],

334 [AC_MSG_RESULT(yes); WITH_SCTP=1 ])

335

336 if test -n "$WITH_SCTP"; then

337 AC_MSG_CHECKING(for IPPROTO_SCTP)

338 AC_CACHE_VAL(sc_cv_define_ipproto_sctp,

339 [AC_TRY_COMPILE([#include <sys/types.h>

340 #include <netinet/in.h>],

341 [IPPROTO_SCTP;],

342 [sc_cv_define_ipproto_sctp=yes],

343 [sc_cv_define_ipproto_sctp=no])])

344 AC_MSG_RESULT($sc_cv_define_ipproto_sctp)

345 if test $sc_cv_define_ipproto_sctp = yes; then

346 AC_DEFINE(WITH_SCTP)

347 else

348 AC_MSG_WARN([IPPROTO_SCTP undefined, disabling SCTP support])

349 fi

350 fi

351

352 AC_MSG_CHECKING(whether to include listen support)

353 AC_ARG_ENABLE(listen, [ --disable-listen disable listen support],

354 [case "$enableval" in

355 no) AC_MSG_RESULT(no);;

356 *) AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes);;

357 esac],

358 [AC_DEFINE(WITH_LISTEN) AC_MSG_RESULT(yes)])

359

360 AC_MSG_CHECKING(whether to include socks4 support)

361 AC_ARG_ENABLE(socks4, [ --disable-socks4 disable socks4 support],

362 [case "$enableval" in

363 no) AC_MSG_RESULT(no);;

364 *) AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes);;

365 esac],

366 [AC_DEFINE(WITH_SOCKS4) AC_MSG_RESULT(yes)])

367

368 AC_MSG_CHECKING(whether to include socks4a support)

369 AC_ARG_ENABLE(socks4a, [ --disable-socks4a disable socks4a support],

370 [case "$enableval" in

371 no) AC_MSG_RESULT(no);;

372 *) AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes);;

373 esac],

374 [AC_DEFINE(WITH_SOCKS4A) AC_MSG_RESULT(yes)])

375

376 AC_MSG_CHECKING(whether to include proxy connect support)

377 AC_ARG_ENABLE(proxy, [ --disable-proxy disable proxy connect support],

378 [case "$enableval" in

379 no) AC_MSG_RESULT(no);;

380 *) AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes);;

381 esac],

382 [AC_DEFINE(WITH_PROXY) AC_MSG_RESULT(yes)])

383

384 AC_MSG_CHECKING(whether to include exec support)

385 AC_ARG_ENABLE(exec, [ --disable-exec disable exec support],

386 [case "$enableval" in

387 no) AC_MSG_RESULT(no);;

388 *) AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes);;

389 esac],

390 [AC_DEFINE(WITH_EXEC) AC_MSG_RESULT(yes)])

391

392 AC_MSG_CHECKING([whether to include system (shell) support])

393 AC_ARG_ENABLE(system, [ --disable-system disable system (shell) support],

394 [case "$enableval" in

395 no) AC_MSG_RESULT(no);;

396 *) AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes);;

397 esac],

398 [AC_DEFINE(WITH_SYSTEM) AC_MSG_RESULT(yes)])

399

400 AC_MSG_CHECKING(whether to include pty address support)

401 AC_ARG_ENABLE(pty, [ --disable-pty disable pty support],

402 [case "$enableval" in

403 no) AC_MSG_RESULT(no);;

404 *) AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes);;

405 esac],

406 [AC_DEFINE(WITH_PTY) AC_MSG_RESULT(yes)])

407

408 AC_MSG_CHECKING(whether to include ext2 fs attributes support)

409 AC_ARG_ENABLE(ext2, [ --disable-ext2 disable ext2 fs attributes support],

410 [case "$enableval" in

411 no) AC_MSG_RESULT(no);;

412 *) AC_DEFINE(WITH_EXT2) AC_MSG_RESULT(yes);;

413 esac],

414 [AC_DEFINE(WITH_EXT2) AC_MSG_RESULT(yes)])

415

416 AC_MSG_CHECKING(whether to include readline support)

417 AC_ARG_ENABLE(readline, [ --disable-readline disable readline support],

418 [case "$enableval" in

419 no) AC_MSG_RESULT(no); WITH_READLINE= ;;

420 *) AC_MSG_RESULT(yes); WITH_READLINE=1 ;;

421 esac],

422 [AC_MSG_RESULT(yes); WITH_READLINE=1 ])

423

424 if test -n "$WITH_READLINE"; then

425 CPPFLAGS_ORIG=$CPPFLAGS

426 CFLAGS_ORIG=$CFLAGS

427 LIBS_ORIG=$LIBS

428 sc_usable_readline_found=

429

430 for D in "" "/usr/local" "/opt/local" "/sw" "/opt/freeware" "/usr/sfw"; do

431 if test -n "$D" ; then

432 CPPFLAGS="$CPPFLAGS -I$D/include"

433 CFLAGS="$CFLAGS -L$D/lib"

434 DLOC="in location $D"

435 else

436 DLOC="in default location"

437 fi

438 AC_MSG_CHECKING(for usable readline $DLOC)

439

440 # Some systems require -lcurses, some require -lncurses.

441 # Mac OS X 10.4 (and others) ships with libedit masquerading as readline,

442 # but it doesn't work well with socat. It can be recognized by the absence

443 # of append_history.

444

445 for L in "" "-lcurses" "-lncurses"; do

446 LIBS="$LIBS_ORIG -lreadline $L"

447 AC_TRY_LINK(

448 [ #include <stdio.h>

449 #include <readline/readline.h>

450 #include <readline/history.h>],

451 [ readline(NULL);

452 append_history(0, NULL); ],

453 [ sc_usable_readline_found=1

454 break ])

455 done

456

457 if test -n "$sc_usable_readline_found"; then

458 AC_MSG_RESULT(yes)

459 AC_DEFINE(HAVE_READLINE_READLINE_H,1)

460 AC_DEFINE(HAVE_READLINE_HISTORY_H,1)

461 AC_DEFINE(HAVE_LIBREADLINE,1)

462 AC_DEFINE(WITH_READLINE,1)

463 break

464 else

465 AC_MSG_RESULT(no)

466 CPPFLAGS=$CPPFLAGS_ORIG

467 CFLAGS=$CFLAGS_ORIG

468 LIBS=$LIBS_ORIG

469 fi

470 done

471

472 if test -z "$sc_usable_readline_found"; then

473 AC_MSG_WARN([no suitable version of readline found; perhaps you need to install a newer version])

474 fi

475 fi

476

477 AC_MSG_CHECKING(whether to include openssl support)

478 AC_ARG_ENABLE(openssl, [ --disable-openssl disable OpenSSL support],

479 [ case "$enableval" in

480 no) AC_MSG_RESULT(no); WITH_OPENSSL= ;;

481 *) AC_MSG_RESULT(yes); WITH_OPENSSL=1 ;;

482 esac],

483 [ AC_MSG_RESULT(yes); WITH_OPENSSL=1 ])

484 #

485 if test -n "$WITH_OPENSSL"; then

486 AC_MSG_NOTICE(checking for components of OpenSSL)

487 # first, we need to find the include file <openssl/ssl.h>

488 AC_CACHE_VAL(sc_cv_have_openssl_ssl_h,

489 [AC_TRY_COMPILE([#include <openssl/ssl.h>],[;],

490 [sc_cv_have_openssl_ssl_h=yes; OPENSSL_ROOT=""; ],

491 [sc_cv_have_openssl_ssl_h=no

492 for D in "/sw" "/usr/local" "/opt/freeware" "/usr/sfw" "/usr/local/ssl"; do

493 I="$D/include"

494 i="$I/openssl/ssl.h"

495 if test -r "$i"; then

496 #V_INCL="$V_INCL -I$I"

497 CPPFLAGS="$CPPFLAGS -I$I"

498 AC_MSG_NOTICE(found $i)

499 sc_cv_have_openssl_ssl_h=yes; OPENSSL_ROOT="$D"

500 break;

501 fi

502 done])

503 ])

504 if test "$sc_cv_have_openssl_ssl_h" = "yes"; then

505 AC_DEFINE(HAVE_OPENSSL_SSL_H)

506 fi

507 AC_MSG_NOTICE(checked for openssl/ssl.h... $sc_cv_have_openssl_ssl_h)

508 fi # end checking for openssl/ssl.h

509 #

510 if test -n "$WITH_OPENSSL" -a "$sc_cv_have_openssl_ssl_h" = 'yes'; then

511 # next, we search for the openssl library (libssl.*)

512 # interesting: Linux only requires -lssl, FreeBSD requires -lssl -lcrypto

513 # Note, version OpenSSL 0.9.7j requires -lcrypto even on Linux.

514 AC_MSG_CHECKING(for libssl)

515 AC_CACHE_VAL(sc_cv_have_libssl,

516 [ LIBS0="$LIBS"

517 if test -n "$OPENSSL_ROOT"; then

518 L="$OPENSSL_ROOT/lib"; LIBS="$LIBS -L$L -lssl"

519 else

520 LIBS="$LIBS -lssl"

521 fi

522 AC_TRY_LINK([#include <openssl/ssl.h>],

523 [SSL_library_init();ERR_error_string()],

524 [sc_cv_have_libssl='yes'],

525 [ LIBS="$LIBS -lcrypto"

526 AC_TRY_LINK([#include <openssl/ssl.h>],

527 [SSL_library_init()],

528 [sc_cv_have_libssl='yes'],

529 [sc_cv_have_libssl='no'])

530 ])

531 if test "$sc_cv_have_libssl" != 'yes'; then

532 LIBS="$LIBS0"

533 fi

534 ]

535 )

536 if test "$sc_cv_have_libssl" = 'yes'; then

537 AC_DEFINE(HAVE_LIBSSL)

538 fi

539 AC_MSG_RESULT($sc_cv_have_libssl)

540 fi

541 #

542 # # a possible location for openssl (on Sourceforge/Solaris)

543 # AC_CHECK_FILE(/usr/local/ssl/lib, LIBS="$LIBS -L/usr/local/ssl/lib/")

544 # # sometimes on Solaris:

545 # AC_CHECK_FILE(/pkgs/lib, LIBS="$LIBS -L/pkgs/lib/")

546 # # for AIX 5.1 with Linux toolbox:

547 # AC_CHECK_FILE(/opt/freeware/lib, LIBS="$LIBS -L/opt/freeware/lib/")

548 #

549 # AC_CHECK_LIB(crypto, main)

550 # AC_CHECK_LIB(ssl, main)

551 #

552 # # MacOSX has openssl includes in another directory

553 # if test -d /sw/include/; then

554 # V_INCL="$V_INCL -I/sw/include"

555 # # and Solaris at sourceforge here:

556 # elif test -d /usr/local/ssl/include/; then

557 # V_INCL="$V_INCL -I/usr/local/ssl/include"

558 # # and AIX 5.1 with Linux toolbox:

559 # elif test -d /opt/freeware/include; then

560 # V_INCL="$V_INCL -I/opt/freeware/include"

561 # fi

562 #fi

563 if test -n "$WITH_OPENSSL"; then

564 if test "$sc_cv_have_openssl_ssl_h" = "yes" -a "$sc_cv_have_libssl" = "yes"; then

565 AC_DEFINE(WITH_OPENSSL)

566 else

567 AC_MSG_WARN([not all components of OpenSSL found, disabling it]);

568 fi

569 fi

570

571 if test -n "$WITH_OPENSSL"; then

572 AC_MSG_CHECKING(whether to include OpenSSL method option)

573 AC_ARG_ENABLE(openssl-method, [ --enable-openssl-method enable OpenSSL method option],

574 [case "$enableval" in

575 no) AC_MSG_RESULT(no);;

576 *) AC_DEFINE(WITH_OPENSSL_METHOD) WITH_OPENSSL_METHOD=1; AC_MSG_RESULT(yes);;

577 esac],

578 [AC_MSG_RESULT(no)])

579 fi

580

581 AC_MSG_CHECKING(whether to include deprecated resolver option)

582 AC_ARG_ENABLE(res-deprecated, [ --enable-res-deprecated enable deprecated resolver options],

583 [case "$enableval" in

584 no) AC_MSG_RESULT(no);;

585 *) AC_DEFINE(WITH_RES_DEPRECATED) WITH_RES_DEPRECATED=1; AC_MSG_RESULT(yes);;

586 esac],

587 [AC_MSG_RESULT(no)])

588

589 # check for fips support

590 AC_MSG_CHECKING(whether to include openssl fips support)

591 AC_ARG_ENABLE(fips, [ --enable-fips enable OpenSSL FIPS support],

592 [ case "$enableval" in

593 yes) AC_MSG_RESULT(yes); WITH_FIPS=1 ;;

594 *) AC_MSG_RESULT(no); WITH_FIPS= ;;

595 esac],

596 [ AC_MSG_RESULT(no); WITH_FIPS= ])

597

598 if test -n "$WITH_FIPS"; then

599 if test -n "$WITH_OPENSSL"; then

600 AC_CHECK_PROG(HAVE_FIPSLD, fipsld, 1)

601 if test "$sc_cv_have_openssl_ssl_h" != "yes" -o "$sc_cv_have_libssl" != "yes" -o ! "$HAVE_FIPSLD";

602 then

603 AC_MSG_WARN([not all components of OpenSSL found, disabling FIPS]);

604 WITH_FIPS=

605 fi

606 else

607 AC_MSG_WARN([must enable OpenSSL to enable FIPS; use --enable-openssl]);

608 fi

609 fi

610

611 if test -n "$WITH_FIPS"; then

612 AC_MSG_CHECKING(for components of OpenSSL FIPS)

613 # first, we need to find the include file <openssl/fips.h>

614 AC_CACHE_VAL(sc_cv_have_openssl_fips_h,

615 [AC_TRY_COMPILE([#define OPENSSL_FIPS

616 #include <stddef.h>

617 #include <openssl/fips.h>],[;],

618 [sc_cv_have_openssl_fips_h=yes; ],

619 [sv_cv_have_openssl_fips_h=no

620 if test -n "$OPENSSL_ROOT"; then

621 I="$OPENSSL_ROOT/include"

622 i="$I/openssl/fips.h"

623 if test -r "$i"; then

624 AC_MSG_NOTICE(found $i)

625 sc_cv_have_openssl_fips_h=yes;

626 fi

627 fi

628 ]

629 )]

630 )

631 if test "$sv_cv_have_openssl_fips_h" = "yes"; then

632 AC_DEFINE(HAVE_OPENSSL_FIPS_H)

633 fi

634 AC_MSG_NOTICE(checked for openssl/fips.h... $sc_cv_have_openssl_ssl_h)

635 fi

636

637 if test -n "$WITH_FIPS" -a "$sc_cv_have_openssl_fips_h" = 'yes'; then

638 # check for the libcrypto library with fips support

639 AC_MSG_CHECKING(for libcrypto with FIPS support)

640 AC_CACHE_VAL(sc_cv_have_libcrypto,

641 [ LIBS0="$LIBS"

642 echo $LIBS | grep -q "\-lcrypto"

643 if test $? -ne 0; then

644 if test -n "$OPENSSL_ROOT"; then

645 L="$OPENSSL_ROOT/lib"; LIBS="$LIBS -L$L -lcrypto"

646 else

647 LIBS="$LIBS -lcrypto"

648 fi

649 fi

650 AC_TRY_LINK([#define OPENSSL_FIPS

651 #include <openssl/ssl.h>

652 #include <openssl/fips.h>],

653 [int res = FIPS_mode_set(1);],

654 [sc_cv_have_libcrypto='yes'],

655 [sc_cv_have_libcrypto='no']

656 )

657 if test "$sc_cv_have_libcrypto" != 'yes'; then

658 LIBS="$LIBS0"

659 fi

660 ]

661 )

662 if test "$sc_cv_have_libcrypto" = 'yes'; then

663 AC_DEFINE(HAVE_LIBCRYPTO)

664 fi

665 AC_MSG_RESULT($sc_cv_have_libcrypto)

666 fi

667

668 if test -n "$WITH_FIPS"; then

669 if test "$sc_cv_have_openssl_fips_h" = 'yes' -a "$sc_cv_have_libcrypto" = 'yes'; then

670 AC_DEFINE(WITH_FIPS)

671 AC_DEFINE(OPENSSL_FIPS)

672 else

673 AC_MSG_WARN([not all components of OpenSSL FIPS found, disabling it]);

674 fi

675 fi

676

677 AC_MSG_CHECKING(whether to include tun/tap address support)

678 AC_ARG_ENABLE(tun, [ --disable-tun disable TUN/TAP support],

679 [case "$enableval" in

680 no) AC_MSG_RESULT(no); WITH_TUN= ;;

681 *) AC_MSG_RESULT(yes); WITH_TUN=1 ;;

682 esac],

683 [AC_MSG_RESULT(yes); WITH_TUN=1 ])

684

685 #

686 if ! test "$ac_cv_header_linux_if_tun_h" = 'yes'; then

687 AC_MSG_WARN(include file linux/if_tun.h not found, disabling TUN)

688 WITH_TUN=

689 fi

690 #

691 if test -n "$WITH_TUN"; then

692 AC_DEFINE(WITH_TUN)

693 fi

694

695 AC_MSG_CHECKING(whether to include system call tracing)

696 AC_ARG_ENABLE(sycls, [ --disable-sycls disable system call tracing],

697 [case "$enableval" in

698 no) SYCLS=""; SSLCLS=""; AC_MSG_RESULT(no);;

699 *) AC_DEFINE(WITH_SYCLS)

700 SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes);;

701 esac],

702 [AC_DEFINE(WITH_SYCLS)

703 SYCLS="sycls.c"; SSLCLS="sslcls.c"; AC_MSG_RESULT(yes)])

704 AC_SUBST(SYCLS)

705 AC_SUBST(SSLCLS)

706

707 AC_MSG_CHECKING(whether to include file descriptor analyzer)

708 AC_ARG_ENABLE(filan, [ --disable-filan disable file descriptor analyzer],

709 [case "$enableval" in

710 no) FILAN=""; AC_MSG_RESULT(no);;

711 *) AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes);;

712 esac],

713 [AC_DEFINE(WITH_FILAN) FILAN="filan.c"; AC_MSG_RESULT(yes)])

714 AC_SUBST(FILAN)

715

716 AC_MSG_CHECKING(whether to include retry support)

717 AC_ARG_ENABLE(retry, [ --disable-retry disable retry support],

718 [case "$enableval" in

719 no) AC_MSG_RESULT(no);;

720 *) AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes);;

721 esac],

722 [AC_DEFINE(WITH_RETRY) AC_MSG_RESULT(yes)])

723

724 AC_MSG_CHECKING(included message level)

725 AC_ARG_ENABLE(msglevel, [ --enable-msglevel=N set max verbosity to debug,info,notice,warn,error,fatal],

726 [case "$enableval" in

727 0|debug) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;

728 1|info) AC_DEFINE(WITH_MSGLEVEL,1) AC_MSG_RESULT(info);;

729 2|notice) AC_DEFINE(WITH_MSGLEVEL,2) AC_MSG_RESULT(notice);;

730 3|warn) AC_DEFINE(WITH_MSGLEVEL,3) AC_MSG_RESULT(warn);;

731 4|error) AC_DEFINE(WITH_MSGLEVEL,4) AC_MSG_RESULT(error);;

732 5|fatal) AC_DEFINE(WITH_MSGLEVEL,5) AC_MSG_RESULT(fatal);;

733 *) AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug);;

734 esac],

735 [AC_DEFINE(WITH_MSGLEVEL,0) AC_MSG_RESULT(debug)])

736

737 #AC_SUBST(V_INCL)

738

739 dnl Checks for typedefs, structures, and compiler characteristics.

740 AC_C_CONST

741 AC_TYPE_UID_T

742 AC_TYPE_MODE_T

743 AC_TYPE_OFF_T

744 AC_TYPE_PID_T

745 AC_TYPE_SIZE_T

746 AC_STRUCT_ST_BLKSIZE

747 AC_STRUCT_ST_BLOCKS

748 AC_STRUCT_ST_RDEV

749 AC_HEADER_TIME

750

751 dnl Check for extra realtime library (for Solaris)

752 AC_CHECK_FUNC(nanosleep, AC_DEFINE(HAVE_NANOSLEEP), AC_CHECK_LIB(rt, nanosleep, [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_NANOSLEEP)]))

753 #AC_CHECK_FUNC(nanosleep, , AC_CHECK_LIB(rt, nanosleep))

754

755 dnl Checks for library functions.

756 AC_PROG_GCC_TRADITIONAL

757 AC_FUNC_MEMCMP

758 AC_TYPE_SIGNAL

759 AC_FUNC_STRFTIME

760 AC_CHECK_FUNCS(putenv select poll socket strtod strtol)

761 AC_CHECK_FUNCS(strtoul uname getpgid getsid gethostbyname getaddrinfo)

762 AC_CHECK_FUNCS(setgroups inet_aton)

763 AC_CHECK_FUNCS()

764

765 AC_CHECK_FUNCS(grantpt unlockpt)

766

767 # GR AC_CHECK_FUNCS only checks linking, not prototype. This may lead to implicit

768 # function declarations and to SIGSEGV on systems with 32bit int and 64bit pointer

769

770 dnl Search for cfsetispeed(),cfgetispeed(),cfsetspeed(),cfgetospeed() functions

771 AC_CHECK_FUNCS(cfsetispeed cfgetispeed cfsetospeed cfgetospeed)

772

773 ###################################

774 # check for prototype and existence of functions that return a pointer

775 # defines in config.h: HAVE_PROTOTYPE_LIB_$1

776 AC_CHECK_PROTOTYPE_LIB(strdup)

777 AC_CHECK_PROTOTYPE_LIB(strerror)

778 AC_CHECK_PROTOTYPE_LIB(strstr)

779 AC_CHECK_PROTOTYPE_LIB(getipnodebyname)

780 AC_CHECK_PROTOTYPE_LIB(memrchr)

781 AC_CHECK_PROTOTYPE_LIB(if_indextoname)

782 AC_CHECK_PROTOTYPE_LIB(ptsname)

783

784

785 AC_MSG_CHECKING(for long long)

786 AC_CACHE_VAL(sc_cv_type_longlong,

787 [AC_TRY_COMPILE([],[long long s;],

788 [sc_cv_type_longlong=yes],

789 [sc_cv_type_longlong=no])])

790 if test $sc_cv_type_longlong = yes; then

791 AC_DEFINE(HAVE_TYPE_LONGLONG)

792 fi

793 AC_MSG_RESULT($sc_cv_type_longlong)

794

795 AC_CHECK_TYPE(sig_atomic_t,AC_DEFINE(HAVE_TYPE_SIG_ATOMIC_T),,[#include "sysincludes.h"])

796

797 AC_MSG_CHECKING(for bool)

798 AC_CACHE_VAL(sc_cv_type_bool,

799 [AC_TRY_COMPILE([#ifdef HAVE_STDBOOL_H

800 #include <stdbool.h>

801 #endif],

802 [bool b;],

803 [sc_cv_type_bool=yes],

804 [sc_cv_type_bool=no])])

805 if test $sc_cv_type_bool = yes; then

806 AC_DEFINE(HAVE_TYPE_BOOL)

807 fi

808 AC_MSG_RESULT($sc_cv_type_bool)

809

810 # following builtin macro does not check unistd.h and sys/socket.h where

811 # socklen_t might be defined

812 #AC_CHECK_TYPE(socklen_t, int)

813 #

814 AC_MSG_CHECKING(for socklen_t)

815 AC_CACHE_VAL(sc_cv_type_socklen,

816 [AC_TRY_COMPILE([#include <sys/types.h>

817 #include <sys/socket.h>

818 #include <unistd.h>],[socklen_t s;],

819 [sc_cv_type_socklen=yes],

820 [sc_cv_type_socklen=no])])

821 if test $sc_cv_type_socklen = yes; then

822 AC_DEFINE(HAVE_TYPE_SOCKLEN)

823 fi

824 AC_MSG_RESULT($sc_cv_type_socklen)

825

826 AC_MSG_CHECKING(for struct stat64)

827 AC_CACHE_VAL(sc_cv_type_stat64,

828 [AC_TRY_COMPILE([#include <sys/stat.h>],[struct stat64 s;],

829 [sc_cv_type_stat64=yes],

830 [sc_cv_type_stat64=no])])

831 if test $sc_cv_type_stat64 = yes; then

832 AC_DEFINE(HAVE_TYPE_STAT64)

833 fi

834 AC_MSG_RESULT($sc_cv_type_stat64)

835

836 AC_MSG_CHECKING(for off64_t)

837 AC_CACHE_VAL(sc_cv_type_off64,

838 [AC_TRY_COMPILE([#include <unistd.h>],[off64_t s;],

839 [sc_cv_type_off64=yes],

840 [sc_cv_type_off64=no])])

841 if test $sc_cv_type_off64 = yes; then

842 AC_DEFINE(HAVE_TYPE_OFF64)

843 fi

844 AC_MSG_RESULT($sc_cv_type_off64)

845

846 AC_MSG_CHECKING(for sighandler_t)

847 AC_CACHE_VAL(sc_cv_type_sighandler,

848 [AC_TRY_COMPILE([#include <signal.h>],[sighandler_t s;],

849 [sc_cv_type_sighandler=yes],

850 [sc_cv_type_sighandler=no])])

851 if test $sc_cv_type_sighandler = yes; then

852 AC_DEFINE(HAVE_TYPE_SIGHANDLER)

853 fi

854 AC_MSG_RESULT($sc_cv_type_socklen)

855

856 AC_MSG_CHECKING(for uint8_t)

857 AC_CACHE_VAL(sc_cv_type_uint8,

858 [AC_TRY_COMPILE([#include <sys/types.h>

859 #if HAVE_STDINT_H

860 #include <stdint.h>

861 #endif

862 /* Tru64 has uint8_t etc from netdb.h */

863 #if HAVE_NETDB_H

864 #include <netdb.h>

865 #endif

866 #include <unistd.h>],[uint8_t s;],

867 [sc_cv_type_uint8=yes],

868 [sc_cv_type_uint8=no])])

869 if test $sc_cv_type_uint8 = yes; then

870 AC_DEFINE(HAVE_TYPE_UINT8)

871 fi

872 AC_MSG_RESULT($sc_cv_type_uint8)

873

874 AC_MSG_CHECKING(for uint16_t)

875 AC_CACHE_VAL(sc_cv_type_uint16,

876 [AC_TRY_COMPILE([#include <sys/types.h>

877 #if HAVE_STDINT_H

878 #include <stdint.h>

879 #endif

880 /* Tru64 has uint16_t etc from netdb.h */

881 #if HAVE_NETDB_H

882 #include <netdb.h>

883 #endif

884 #include <unistd.h>],[uint16_t s;],

885 [sc_cv_type_uint16=yes],

886 [sc_cv_type_uint16=no])])

887 if test $sc_cv_type_uint16 = yes; then

888 AC_DEFINE(HAVE_TYPE_UINT16)

889 fi

890 AC_MSG_RESULT($sc_cv_type_uint16)

891

892 AC_MSG_CHECKING(for uint32_t)

893 AC_CACHE_VAL(sc_cv_type_uint32,

894 [AC_TRY_COMPILE([#include <sys/types.h>

895 #if HAVE_STDINT_H

896 #include <stdint.h>

897 #endif

898 /* Tru64 has uint32_t etc from netdb.h */

899 #if HAVE_NETDB_H

900 #include <netdb.h>

901 #endif

902 #include <unistd.h>],[uint32_t s;],

903 [sc_cv_type_uint32=yes],

904 [sc_cv_type_uint32=no])])

905 if test $sc_cv_type_uint32 = yes; then

906 AC_DEFINE(HAVE_TYPE_UINT32)

907 fi

908 AC_MSG_RESULT($sc_cv_type_uint32)

909

910 AC_MSG_CHECKING(for uint64_t)

911 AC_CACHE_VAL(sc_cv_type_uint64,

912 [AC_TRY_COMPILE([#include <sys/types.h>

913 #if HAVE_STDINT_H

914 #include <stdint.h>

915 #endif

916 /* Tru64 has uint32_t etc from netdb.h */

917 #if HAVE_NETDB_H

918 #include <netdb.h>

919 #endif

920 #include <unistd.h>],[uint64_t s;],

921 [sc_cv_type_uint64=yes],

922 [sc_cv_type_uint64=no])])

923 if test $sc_cv_type_uint64 = yes; then

924 AC_DEFINE(HAVE_TYPE_UINT64)

925 fi

926 AC_MSG_RESULT($sc_cv_type_uint64)

927

928 ### AIX 4.1 needs _XOPEN_EXTENDED_SOURCE for syslog headers,

929 # but then gets problems with 3rd arg of getsockaddr...

930 #AC_MSG_CHECKING(for _XOPEN_EXTENDED_SOURCE requirement)

931 #CFLAGS="-Werror -Wall"

932 #AC_TRY_COMPILE([#include <sys/syslog.h>],

933 #[syslog(0," ");],

934 #[AC_MSG_RESULT(no)],

935 #[AC_MSG_RESULT(required); AC_DEFINE(_XOPEN_EXTENDED_SOURCE)])

936

937

938 ### fds_bits

939 AC_MSG_CHECKING(for fdset->fds_bits)

940 AC_TRY_COMPILE([#include <sys/types.h>

941 #if HAVE_SYS_SELECT_H

942 #include <sys/select.h>

943 #endif],

944 [fd_set s; s.fds_bits[0]=0;],

945 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_FDS_BITS)],

946 [AC_MSG_RESULT(no);])

947

948 AC_MSG_CHECKING(for struct termios . c_ispeed)

949 AC_TRY_COMPILE([#include <unistd.h>

950 #if HAVE_TERMIOS_H

951 #include <termios.h>

952 #endif],

953 [struct termios s; s.c_ispeed=0;],

954 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_STRUCT_TERMIOS_C_ISPEED)],

955 [AC_MSG_RESULT(no);])

956

957 AC_MSG_CHECKING(for struct termios . c_ospeed)

958 AC_TRY_COMPILE([#include <unistd.h>

959 #if HAVE_TERMIOS_H

960 #include <termios.h>

961 #endif],

962 [struct termios s; s.c_ospeed=0;],

963 [AC_MSG_RESULT(yes); AC_DEFINE(HAVE_STRUCT_TERMIOS_C_OSPEED)],

964 [AC_MSG_RESULT(no);])

965

966 AC_MSG_CHECKING(for sa_family_t)

967 AC_CACHE_VAL(sc_cv_type_sa_family_t,

968 [AC_TRY_COMPILE([#include <sys/types.h>

969 #include <sys/socket.h>

970 #include <netinet/in.h>],[sa_family_t s;],

971 [sc_cv_type_sa_family_t=yes],

972 [sc_cv_type_sa_family_t=no])])

973 if test $sc_cv_type_sa_family_t = yes; then

974 AC_DEFINE(HAVE_TYPE_SA_FAMILY_T)

975 fi

976 AC_MSG_RESULT($sc_cv_type_sa_family_t)

977

978 AC_MSG_CHECKING(for struct sock_extended_err)

979 AC_CACHE_VAL(sc_cv_struct_sock_extended_err,

980 [AC_TRY_COMPILE([#include <linux/types.h>

981 #if TIME_WITH_SYS_TIME

982 #include <sys/time.h>

983 #endif

984 #if HAVE_LINUX_ERRQUEUE_H

985 #include <linux/errqueue.h>

986 #endif],[struct sock_extended_err s;],

987 [sc_cv_struct_sock_extended_err=yes],

988 [sc_cv_struct_sock_extended_err=no])])

989 if test $sc_cv_struct_sock_extended_err = yes; then

990 AC_DEFINE(HAVE_STRUCT_SOCK_EXTENDED_ERR)

991 fi

992 AC_MSG_RESULT($sc_cv_struct_sock_extended_err)

993

994 AC_MSG_CHECKING(for struct sigaction.sa_sigaction)

995 AC_CACHE_VAL(sc_cv_struct_sigaction_sa_sigaction,

996 [AC_TRY_COMPILE([#include <signal.h>],[struct sigaction s;s.sa_sigaction=0;],

997 [sc_cv_struct_sigaction_sa_sigaction=yes],

998 [sc_cv_struct_sigaction_sa_sigaction=no])])

999 if test $sc_cv_struct_sigaction_sa_sigaction = yes; then

1000 AC_DEFINE(HAVE_STRUCT_SIGACTION_SA_SIGACTION)

1001 fi

1002 AC_MSG_RESULT($sc_cv_struct_sigaction_sa_sigaction)

1003

1004 # there is another issue with termios: OSR requires "#define _SVID3 ..."

1005 # for reasonable termios support. We check this situation using IMAXBEL

1006 AC_MSG_CHECKING(if _SVID3 is helpful)

1007 AC_CACHE_VAL(ac_cv_svid3,

1008 [AC_TRY_COMPILE([#include <termios.h>],

1009 [int i=IMAXBEL],

1010 [ac_cv_svid3=no],

1011 [AC_TRY_COMPILE([#define _SVID3 1

1012 #include <termios.h>],

1013 [int i=IMAXBEL],

1014 [ac_cv_svid3=yes],

1015 [ac_cv_svid3=no]

1016 )]

1017 )])

1018 if test $ac_cv_svid3 = yes; then

1019 AC_DEFINE(_SVID3)

1020 fi

1021 AC_MSG_RESULT($ac_cv_svid3)

1022

1023

1024 # Openindiana needs _XPG4_2 for CMSG stuff

1025 AC_MSG_CHECKING(if _XPG4_2 is helpful)

1026 AC_CACHE_VAL(ac_cv_xpg4_2,

1027 [AC_TRY_LINK([#include <sys/socket.h>],

1028 [int i=CMSG_DATA(0)],

1029 [ac_cv_xpg4_2=no],

1030 [AC_TRY_LINK([#define _XPG4_2 1

1031 #include <sys/socket.h>],

1032 [int i=CMSG_DATA(0)],

1033 [ac_cv_xpg4_2=yes],

1034 [ac_cv_xpg4_2=no]

1035 )]

1036 )])

1037 if test $ac_cv_xpg4_2 = yes; then

1038 AC_DEFINE(_XPG4_2)

1039 fi

1040 AC_MSG_RESULT($ac_cv_xpg4_2)

1041

1042 # When on Openindiana _XPG4_2 is defined (see above)

1043 # we also need to define __EXTENSIONS__ for basic stuff.

1044 # Note that <sys/procset.h> is important on Openindiana

1045 # but does not exist on Linux

1046 if test "$ac_cv_xpg4_2" = yes; then

1047 AC_MSG_CHECKING(if __EXTENSIONS__ is helpful)

1048 AC_CACHE_VAL(ac_cv___extensions__,

1049 [AC_TRY_COMPILE([#include <sys/procset.h>],

1050 [procset_t *s=0;],

1051 [ac_cv___extensions__=no],

1052 [AC_TRY_COMPILE([#define __EXTENSIONS__ 1

1053 #include <sys/procset.h>],

1054 [procset_t *s=0;],

1055 [ac_cv___extensions__=yes],

1056 [ac_cv___extensions__=no]

1057 )]

1058 )])

1059 if test $ac_cv___extensions__ = yes; then

1060 AC_DEFINE(__EXTENSIONS__)

1061 fi

1062 AC_MSG_RESULT($ac_cv___extensions__)

1063 fi

1064

1065 # When on Openindiana __EXTENSIONS__ is defined (see above)

1066 # _POSIX_PTHREAD_SEMANTICS must be defined for standard ctime_r()

1067 if test "$ac_cv___extensions__" = yes; then

1068 AC_MSG_CHECKING(if _POSIX_PTHREAD_SEMANTICS is helpful)

1069 AC_CACHE_VAL(ac_cv__posix_pthread_semantics,

1070 [AC_TRY_COMPILE([#include <time.h>],

1071 [char *s = ctime_r(0,0);],

1072 [ac_cv__posix_pthread_semantics=no],

1073 [AC_TRY_COMPILE([#define _POSIX_PTHREAD_SEMANTICS 1

1074 #include <time.h>],

1075 [char *s = ctime_r(0,0);],

1076 [ac_cv__posix_pthread_semantics=yes],

1077 [ac_cv__posix_pthread_semantics=no]

1078 )]

1079 )])

1080 if test $ac_cv__posix_pthread_semantics = yes; then

1081 AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)

1082 fi

1083 AC_MSG_RESULT($ac_cv__posix_pthread_semantics)

1084 fi

1085

1086

1087 # struct timespec

1088 AC_MSG_CHECKING(for struct timespec)

1089 AC_CACHE_VAL(sc_cv_struct_timespec,

1090 [AC_TRY_COMPILE([#include <time.h>

1091 #if HAVE_SYS_TIME_H

1092 #include <sys/time.h>

1093 #endif],[struct timespec s;],

1094 [sc_cv_struct_timespec=yes],

1095 [sc_cv_struct_timespec=no])])

1096 if test $sc_cv_struct_timespec = yes; then

1097 AC_DEFINE(HAVE_STRUCT_TIMESPEC)

1098 fi

1099 AC_MSG_RESULT($sc_cv_struct_timespec)

1100

1101

1102 # struct linger; FreeBSD requires sys/types.h for sys/socket.h

1103 AC_MSG_CHECKING(for struct linger)

1104 AC_CACHE_VAL(sc_cv_struct_linger,

1105 [AC_TRY_COMPILE([#include <sys/types.h>

1106 #include <sys/socket.h>],[struct linger s;],

1107 [sc_cv_struct_linger=yes],

1108 [sc_cv_struct_linger=no])])

1109 if test $sc_cv_struct_linger = yes; then

1110 AC_DEFINE(HAVE_STRUCT_LINGER)

1111 fi

1112 AC_MSG_RESULT($sc_cv_struct_linger)

1113

1114

1115 # struct ip (for IPv4 header info)

1116 AC_MSG_CHECKING(for struct ip)

1117 AC_CACHE_VAL(sc_cv_struct_ip,

1118 [AC_TRY_COMPILE([#include <netinet/ip.h>],[struct ip s;],

1119 [sc_cv_struct_ip=yes],

1120 [sc_cv_struct_ip=no])])

1121 if test $sc_cv_struct_ip = yes; then

1122 AC_DEFINE(HAVE_STRUCT_IP)

1123 fi

1124 AC_MSG_RESULT($sc_cv_struct_ip)

1125

1126 # struct ip_mreq (for multicasting options)

1127 AC_MSG_CHECKING(for struct ip_mreq)

1128 AC_CACHE_VAL(sc_cv_struct_ip_mreq,

1129 [AC_TRY_COMPILE([#include <sys/types.h>

1130 #include <sys/socket.h>

1131 #include <netinet/in.h>],[struct ip_mreq s;],

1132 [sc_cv_struct_ip_mreq=yes],

1133 [sc_cv_struct_ip_mreq=no])])

1134 if test $sc_cv_struct_ip_mreq = yes; then

1135 AC_DEFINE(HAVE_STRUCT_IP_MREQ)

1136 fi

1137 AC_MSG_RESULT($sc_cv_struct_ip_mreq)

1138

1139 # struct ip_mreqn (for multicasting options)

1140 AC_MSG_CHECKING(for struct ip_mreqn)

1141 AC_CACHE_VAL(sc_cv_struct_ip_mreqn,

1142 [AC_TRY_COMPILE([#include <sys/types.h>

1143 #include <sys/socket.h>

1144 #include <netinet/ip.h>],[struct ip_mreqn s;],

1145 [sc_cv_struct_ip_mreqn=yes],

1146 [sc_cv_struct_ip_mreqn=no])])

1147 if test $sc_cv_struct_ip_mreqn = yes; then

1148 AC_DEFINE(HAVE_STRUCT_IP_MREQN)

1149 fi

1150 AC_MSG_RESULT($sc_cv_struct_ip_mreqn)

1151

1152 # struct ipv6_mreq (for multicasting options)

1153 AC_MSG_CHECKING(for struct ipv6_mreq)

1154 AC_CACHE_VAL(sc_cv_struct_ipv6_mreq,

1155 [AC_TRY_COMPILE([#include <sys/types.h>

1156 #include <sys/socket.h>

1157 #include <netinet/in.h>],[struct ipv6_mreq s;],

1158 [sc_cv_struct_ipv6_mreq=yes],

1159 [sc_cv_struct_ipv6_mreq=no])])

1160 if test $sc_cv_struct_ipv6_mreq = yes; then

1161 AC_DEFINE(HAVE_STRUCT_IPV6_MREQ)

1162 fi

1163 AC_MSG_RESULT($sc_cv_struct_ipv6_mreq)

1164

1165

1166 # struct ifreq (for network interfaces)

1167 AC_MSG_CHECKING(for struct ifreq)

1168 AC_CACHE_VAL(sc_cv_struct_ifreq,

1169 [AC_TRY_COMPILE([#include <sys/types.h>

1170 #include <sys/socket.h>

1171 #include <net/if.h>],[struct ifreq s;],

1172 [sc_cv_struct_ifreq=yes],

1173 [sc_cv_struct_ifreq=no])])

1174 if test $sc_cv_struct_ifreq = yes; then

1175 AC_DEFINE(HAVE_STRUCT_IFREQ)

1176 fi

1177 AC_MSG_RESULT($sc_cv_struct_ifreq)

1178

1179 # struct ifreq.ifr_index

1180 # on most systems that have struct ifreq

1181 AC_MSG_CHECKING(for struct ifreq.ifr_index)

1182 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_index,

1183 [AC_TRY_COMPILE([#include <sys/types.h>

1184 #include <sys/socket.h>

1185 #include <net/if.h>],

1186 [struct ifreq ir;ir.ifr_index=0;],

1187 [sc_cv_struct_ifreq_ifr_index=yes],

1188 [sc_cv_struct_ifreq_ifr_index=no])])

1189 if test $sc_cv_struct_ifreq_ifr_index = yes; then

1190 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_INDEX)

1191 fi

1192 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_index)

1193

1194 # struct ifreq.ifr_ifindex

1195 # Linux has ifr_ifindex instead of ifr_index

1196 AC_MSG_CHECKING(for struct ifreq.ifr_ifindex)

1197 AC_CACHE_VAL(sc_cv_struct_ifreq_ifr_ifindex,

1198 [AC_TRY_COMPILE([#include <sys/types.h>

1199 #include <sys/socket.h>

1200 #include <net/if.h>],

1201 [struct ifreq ir;ir.ifr_ifindex=0;],

1202 [sc_cv_struct_ifreq_ifr_ifindex=yes],

1203 [sc_cv_struct_ifreq_ifr_ifindex=no])])

1204 if test $sc_cv_struct_ifreq_ifr_ifindex = yes; then

1205 AC_DEFINE(HAVE_STRUCT_IFREQ_IFR_IFINDEX)

1206 fi

1207 AC_MSG_RESULT($sc_cv_struct_ifreq_ifr_ifindex)

1208

1209

1210 # some systems have a sa_len field in struct sockaddr and we need to support it

1211 # so we can compare sockaddrs simply with memcmp

1212 AC_MSG_CHECKING(for struct sockaddr.sa_len)

1213 AC_CACHE_VAL(sc_cv_struct_sockaddr_salen,

1214 [AC_TRY_COMPILE([#include <sys/types.h>

1215 #include <sys/socket.h>],

1216 [struct sockaddr sa;sa.sa_len=0;],

1217 [sc_cv_struct_sockaddr_salen=yes],

1218 [sc_cv_struct_sockaddr_salen=no])])

1219 if test $sc_cv_struct_sockaddr_salen = yes; then

1220 AC_DEFINE(HAVE_STRUCT_SOCKADDR_SALEN)

1221 fi

1222 AC_MSG_RESULT($sc_cv_struct_sockaddr_salen)

1223

1224 ### IP6 sockaddr_in6

1225

1226 AC_MSG_CHECKING(for component names of sockaddr_in6)

1227 AC_TRY_COMPILE([#include <sys/types.h>

1228 #include <netinet/in.h>],

1229 [struct sockaddr_in6 sa6;sa6.sin6_addr.s6_addr[0]=0;],

1230 [AC_MSG_RESULT(s6_addr);

1231 AC_DEFINE(HAVE_IP6_SOCKADDR, 0)],

1232 [AC_TRY_COMPILE([#include <sys/types.h>

1233 #include <netinet/in.h>],

1234 [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr.u6_addr16[0]=0;],

1235 [AC_MSG_RESULT(u6_addr.u6_addr16);

1236 AC_DEFINE(HAVE_IP6_SOCKADDR, 1)],

1237 [AC_TRY_COMPILE([#include <sys/types.h>

1238 #include <netinet/in.h>],

1239 [struct sockaddr_in6 sa6;sa6.sin6_addr.u6_addr16[0]=0;],

1240 [AC_MSG_RESULT(u6_addr16); AC_DEFINE(HAVE_IP6_SOCKADDR, 2)],

1241 [AC_TRY_COMPILE([#include <sys/types.h>

1242 #include <netinet/in.h>],

1243 [struct sockaddr_in6 sa6;sa6.sin6_addr.in6_u.u6_addr16[0]=0;],

1244 [AC_MSG_RESULT(in6_u.u6_addr16);

1245 AC_DEFINE(HAVE_IP6_SOCKADDR, 3)],

1246 [AC_TRY_COMPILE([#include <sys/types.h>

1247 #include <netinet/in.h>],

1248 [struct sockaddr_in6 sa6;sa6.sin6_addr._S6_un._S6_u32[0]=0;],

1249 [AC_MSG_RESULT(_S6_un._S6_u32);

1250 AC_DEFINE(HAVE_IP6_SOCKADDR, 4)],

1251 [AC_TRY_COMPILE([#include <sys/types.h>

1252 #include <netinet/in.h>],

1253 [struct sockaddr_in6 sa6;sa6.sin6_addr.__u6_addr.__u6_addr32[0]=0;],

1254 [AC_MSG_RESULT(__u6_addr.__u6_addr32);

1255 AC_DEFINE(HAVE_IP6_SOCKADDR, 5)],

1256

1257 [AC_MSG_RESULT([none or unknown])]

1258 )])])])])])

1259

1260 dnl Check for struct iovec

1261 AC_MSG_CHECKING(for struct iovec)

1262 AC_CACHE_VAL(sc_cv_struct_iovec,

1263 [AC_TRY_COMPILE([#include <sys/uio.h>],[struct iovec s;],

1264 [sc_cv_struct_iovec=yes],

1265 [sc_cv_struct_iovec=no])])

1266 if test $sc_cv_struct_iovec = yes; then

1267 AC_DEFINE(HAVE_STRUCT_IOVEC)

1268 fi

1269 AC_MSG_RESULT($sc_cv_struct_iovec)

1270

1271 dnl check for msg_control in struct msghdr

1272 AC_MSG_CHECKING(for struct msghdr.msg_control)

1273 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrol,

1274 [AC_TRY_COMPILE([#include <sys/types.h>

1275 #include <sys/socket.h>],

1276 [struct msghdr s;s.msg_control=0;],

1277 [sc_cv_struct_msghdr_msgcontrol=yes],

1278 [sc_cv_struct_msghdr_msgcontrol=no])])

1279 if test $sc_cv_struct_msghdr_msgcontrol = yes; then

1280 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROL)

1281 fi

1282 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrol)

1283

1284 dnl check for msg_controllen in struct msghdr

1285 AC_MSG_CHECKING(for struct msghdr.msg_controllen)

1286 AC_CACHE_VAL(sc_cv_struct_msghdr_msgcontrollen,

1287 [AC_TRY_COMPILE([#include <sys/types.h>

1288 #include <sys/socket.h>],

1289 [struct msghdr s;s.msg_controllen=0;],

1290 [sc_cv_struct_msghdr_msgcontrollen=yes],

1291 [sc_cv_struct_msghdr_msgcontrollen=no])])

1292 if test $sc_cv_struct_msghdr_msgcontrollen = yes; then

1293 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGCONTROLLEN)

1294 fi

1295 AC_MSG_RESULT($sc_cv_struct_msghdr_msgcontrollen)

1296

1297 dnl check for msg_flags in struct msghdr

1298 AC_MSG_CHECKING(for struct msghdr.msgflags)

1299 AC_CACHE_VAL(sc_cv_struct_msghdr_msgflags,

1300 [AC_TRY_COMPILE([#include <sys/types.h>

1301 #include <sys/socket.h>],

1302 [struct msghdr s;s.msg_flags=0;],

1303 [sc_cv_struct_msghdr_msgflags=yes],

1304 [sc_cv_struct_msghdr_msgflags=no])])

1305 if test $sc_cv_struct_msghdr_msgflags = yes; then

1306 AC_DEFINE(HAVE_STRUCT_MSGHDR_MSGFLAGS)

1307 fi

1308 AC_MSG_RESULT($sc_cv_struct_msghdr_msgflags)

1309

1310 dnl check for struct cmsghdr

1311 AC_MSG_CHECKING(for struct cmsghdr)

1312 AC_CACHE_VAL(sc_cv_struct_cmsghdr,

1313 [AC_TRY_COMPILE([#include <sys/types.h>

1314 #include <sys/socket.h>

1315 #include <net/if.h>],[struct cmsghdr s;],

1316 [sc_cv_struct_cmsghdr=yes],

1317 [sc_cv_struct_cmsghdr=no])])

1318 if test $sc_cv_struct_cmsghdr = yes; then

1319 AC_DEFINE(HAVE_STRUCT_CMSGHDR)

1320 fi

1321 AC_MSG_RESULT($sc_cv_struct_cmsghdr)

1322

1323 dnl check for struct in_pktinfo

1324 AC_MSG_CHECKING(for struct in_pktinfo)

1325 AC_CACHE_VAL(sc_cv_struct_in_pktinfo,

1326 [AC_TRY_COMPILE([#include <sys/types.h>

1327 #include <sys/socket.h>

1328 #include <netinet/in.h>],[struct in_pktinfo s;],

1329 [sc_cv_struct_in_pktinfo=yes],

1330 [sc_cv_struct_in_pktinfo=no])])

1331 if test $sc_cv_struct_in_pktinfo = yes; then

1332 AC_DEFINE(HAVE_STRUCT_IN_PKTINFO)

1333 fi

1334 AC_MSG_RESULT($sc_cv_struct_in_pktinfo)

1335

1336 if test $sc_cv_struct_in_pktinfo = 'yes'; then

1337 dnl check for component ipi_spec_dst in struct in_pktinfo

1338 AC_MSG_CHECKING(for ipi_spec_dst in struct in_pktinfo)

1339 AC_CACHE_VAL(sc_cv_pktinfo_ipi_spec_dst,

1340 [AC_TRY_COMPILE([#include <sys/types.h>

1341 #include <sys/socket.h>

1342 #include <netinet/in.h>],[struct in_pktinfo s; s.ipi_spec_dst],

1343 [sc_cv_pktinfo_ipi_spec_dst=yes],

1344 [sc_cv_pktinfo_ipi_spec_dst=no])])

1345 if test $sc_cv_pktinfo_ipi_spec_dst = yes; then

1346 AC_DEFINE(HAVE_PKTINFO_IPI_SPEC_DST)

1347 fi

1348 AC_MSG_RESULT($sc_cv_pktinfo_ipi_spec_dst)

1349 fi

1350

1351 dnl check for struct in6_pktinfo

1352 AC_MSG_CHECKING(for struct in6_pktinfo)

1353 AC_CACHE_VAL(sc_cv_struct_in6_pktinfo,

1354 [AC_TRY_COMPILE([#include "sysincludes.h"],

1355 [struct in6_pktinfo s;],

1356 [sc_cv_struct_in6_pktinfo=yes],

1357 [sc_cv_struct_in6_pktinfo=no])])

1358 if test $sc_cv_struct_in6_pktinfo = yes; then

1359 AC_DEFINE(HAVE_STRUCT_IN6_PKTINFO)

1360 fi

1361 AC_MSG_RESULT($sc_cv_struct_in6_pktinfo)

1362

1363 dnl check for ip_hl in struct ip

1364 AC_MSG_CHECKING(for struct ip.ip_hl)

1365 AC_CACHE_VAL(sc_cv_struct_ip_ip_hl,

1366 [AC_TRY_COMPILE([#include <sys/types.h>

1367 #include <netinet/in_systm.h>

1368 #include <netinet/in.h>

1369 #include <netinet/ip.h>],

1370 [struct ip s;s.ip_hl=0;],

1371 [sc_cv_struct_ip_ip_hl=yes],

1372 [sc_cv_struct_ip_ip_hl=no])])

1373 if test $sc_cv_struct_ip_ip_hl = yes; then

1374 AC_DEFINE(HAVE_STRUCT_IP_IP_HL)

1375 fi

1376 AC_MSG_RESULT($sc_cv_struct_ip_ip_hl)

1377

1378

1379 dnl Library function checks

1380

1381 dnl Check sigaction()

1382 AC_CHECK_FUNC(sigaction, AC_DEFINE(HAVE_SIGACTION))

1383

1384 dnl Check for 64bit versions of system calls

1385 AC_CHECK_FUNC(stat64, AC_DEFINE(HAVE_STAT64))

1386 AC_CHECK_FUNC(fstat64, AC_DEFINE(HAVE_FSTAT64))

1387 AC_CHECK_FUNC(lstat64, AC_DEFINE(HAVE_LSTAT64))

1388 AC_CHECK_FUNC(lseek64, AC_DEFINE(HAVE_LSEEK64))

1389 AC_CHECK_FUNC(truncate64, AC_DEFINE(HAVE_TRUNCATE64))

1390 AC_CHECK_FUNC(ftruncate64, AC_DEFINE(HAVE_FTRUNCATE64))

1391

1392 AC_CHECK_FUNC(strtoll, AC_DEFINE(HAVE_STRTOLL))

1393 AC_CHECK_FUNC(hstrerror, AC_DEFINE(HAVE_HSTRERROR))

1394 AC_CHECK_FUNC(inet_ntop, AC_DEFINE(HAVE_INET_NTOP))

1395

1396 #if test "$ac_cv_func_hstrerror" = "yes"; then

1397 # AC_MSG_CHECKING(if _XOPEN_SOURCE_EXTENDED is helpful)

1398 # AC_CACHE_VAL(ac_cv_xopen_source_extended,

1399 # [AC_TRY_COMPILE([#include <netdb.h>],

1400 # [hstrerror()],

1401 # [ac_cv_xopen_source_extended=no],

1402 # [AC_TRY_COMPILE([#define _XOPEN_SOURCE_EXTENDED 1

1403 ## include <netdb.h>],

1404 # [hstrerror()],

1405 # [ac_cv_xopen_source_extended=yes],

1406 # [ac_cv_xopen_source_extended=no]

1407 # )]

1408 # )])

1409 # if test $ac_cv_xopen_source_extended = yes; then

1410 # AC_DEFINE(_XOPEN_SOURCE_EXTENDED)

1411 # fi

1412 # AC_MSG_RESULT($ac_cv_xopen_source_extended)

1413 #fi

1414

1415 dnl Search for openpty()

1416 # MacOS

1417 AC_CHECK_FUNC(openpty, AC_DEFINE(HAVE_OPENPTY))

1418 # AIX

1419 AC_CHECK_LIB(bsd, openpty,

1420 [LIBS="-lbsd $LIBS"; AC_DEFINE(HAVE_OPENPTY)])

1421 # Linux 2.4

1422 AC_CHECK_LIB(util, openpty,

1423 [LIBS="-lutil $LIBS"; AC_DEFINE(HAVE_OPENPTY)])

1424

1425 AC_CHECK_LIB(rt, clock_gettime,

1426 [LIBS="-lrt $LIBS"; AC_DEFINE(HAVE_CLOCK_GETTIME)])

1427

1428 dnl Search for flock()

1429 # with Linux it's in libc, with AIX in libbsd

1430 AC_CHECK_FUNC(flock, AC_DEFINE(HAVE_FLOCK),

1431 AC_CHECK_LIB(bsd, flock, [LIBS="-lbsd $LIBS"]))

1432

1433 dnl Search for setenv()

1434 AC_CHECK_FUNC(setenv, AC_DEFINE(HAVE_SETENV),

1435 AC_CHECK_LIB(isode, setenv, [LIBS="-lisode $LIBS"]))

1436

1437 dnl Search for unsetenv()

1438 AC_CHECK_FUNC(unsetenv, AC_DEFINE(HAVE_UNSETENV))

1439

1440 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]))

1441 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]))

1442 if test -n "$WITH_OPENSSL_METHOD" -o -z "$ac_cv_have_tls_client_method" -o -z "$ac_cv_have_tls_server_method" ; then

1443 dnl Search for SSLv2_client_method, SSLv2_server_method

1444 AC_CHECK_FUNC(SSLv2_client_method, AC_DEFINE(HAVE_SSLv2_client_method), AC_CHECK_LIB(crypt, SSLv2_client_method, [LIBS=-lcrypt $LIBS]))

1445 AC_CHECK_FUNC(SSLv2_server_method, AC_DEFINE(HAVE_SSLv2_server_method), AC_CHECK_LIB(crypt, SSLv2_server_method, [LIBS=-lcrypt $LIBS]))

1446 dnl

1447 AC_CHECK_FUNC(SSLv3_client_method, AC_DEFINE(HAVE_SSLv3_client_method), AC_CHECK_LIB(crypt, SSLv3_client_method, [LIBS=-lcrypt $LIBS]))

1448 AC_CHECK_FUNC(SSLv3_server_method, AC_DEFINE(HAVE_SSLv3_server_method), AC_CHECK_LIB(crypt, SSLv3_server_method, [LIBS=-lcrypt $LIBS]))

1449 AC_CHECK_FUNC(SSLv23_client_method, AC_DEFINE(HAVE_SSLv23_client_method), AC_CHECK_LIB(crypt, SSLv23_client_method, [LIBS=-lcrypt $LIBS]))

1450 AC_CHECK_FUNC(SSLv23_server_method, AC_DEFINE(HAVE_SSLv23_server_method), AC_CHECK_LIB(crypt, SSLv23_server_method, [LIBS=-lcrypt $LIBS]))

1451 AC_CHECK_FUNC(TLSv1_client_method, AC_DEFINE(HAVE_TLSv1_client_method), AC_CHECK_LIB(crypt, TLSv1_client_method, [LIBS=-lcrypt $LIBS]))

1452 AC_CHECK_FUNC(TLSv1_server_method, AC_DEFINE(HAVE_TLSv1_server_method), AC_CHECK_LIB(crypt, TLSv1_server_method, [LIBS=-lcrypt $LIBS]))

1453 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]))

1454 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]))

1455 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]))

1456 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]))

1457 AC_CHECK_FUNC(DTLSv1_client_method, AC_DEFINE(HAVE_DTLSv1_client_method), AC_CHECK_LIB(crypt, DTLSv1_client_method, [LIBS=-lcrypt $LIBS]))

1458 AC_CHECK_FUNC(DTLSv1_server_method, AC_DEFINE(HAVE_DTLSv1_server_method), AC_CHECK_LIB(crypt, DTLSv1_server_method, [LIBS=-lcrypt $LIBS]))

1459 fi # $WITH_OPENSSL_METHOD

1460

1461 AC_CHECK_FUNC(SSL_CTX_set_default_verify_paths, AC_DEFINE(HAVE_SSL_CTX_set_default_verify_paths))

1462 AC_CHECK_FUNC(RAND_egd, AC_DEFINE(HAVE_RAND_egd), AC_CHECK_LIB(crypt, RAND_egd, [LIBS=-lcrypt $LIBS]))

1463 AC_CHECK_FUNC(DH_set0_pqg, AC_DEFINE(HAVE_DH_set0_pqg), AC_CHECK_LIB(crypt, DH_set0_pqg, [LIBS=-lcrypt $LIBS]))

1464 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]))

1465 AC_CHECK_FUNC(RAND_status, AC_DEFINE(HAVE_RAND_status))

1466

1467 AC_MSG_CHECKING(for type EC_KEY)

1468 AC_CACHE_VAL(sc_cv_type_EC_TYPE,

1469 [AC_TRY_COMPILE([#include <openssl/ec.h>

1470 ],[EC_KEY *s;],

1471 [sc_cv_type_EC_KEY=yes],

1472 [sc_cv_type_EC_KEY=no])])

1473 if test $sc_cv_type_EC_KEY = yes; then

1474 AC_DEFINE(HAVE_TYPE_EC_KEY)

1475 fi

1476 AC_MSG_RESULT($sc_cv_type_EC_KEY)

1477

1478

1479 dnl Run time checks

1480

1481

1482 AC_MSG_CHECKING(if snprintf conforms to C99)

1483 AC_CACHE_VAL(ac_cv_have_c99_snprintf,

1484 [AC_TRY_RUN([

1485 #include <stdio.h>

1486 #include <stdlib.h>

1487 int main(void){

1488 char s[2];

1489 exit(snprintf(s,2,"ab")!=2);

1490 }],

1491 [ac_cv_have_c99_snprintf=yes],

1492 [ac_cv_have_c99_snprintf=no],

1493 [ac_cv_have_c99_snprintf=no])])

1494 if test $ac_cv_have_c99_snprintf = yes; then

1495 AC_DEFINE(HAVE_C99_SNPRINTF)

1496 fi

1497 AC_MSG_RESULT($ac_cv_have_c99_snprintf)

1498

1499

1500 AC_MSG_CHECKING(if printf has Z modifier)

1501 AC_CACHE_VAL(ac_cv_have_z_modifier,

1502 if test "$cc" = gcc; then

1503 [AC_TRY_RUN([

1504 #include <stdlib.h>

1505 #include <stdio.h>

1506 int main(void){

1507 char s[16];

1508 sprintf(s,"%Zu",1);

1509 exit(strcmp(s,"1"));

1510 }],

1511 [ac_cv_have_z_modifier=yes],

1512 [ac_cv_have_z_modifier=no],

1513 [ac_cv_have_z_modifier=no])]

1514 else ac_cv_have_z_modifier=no

1515 fi

1516 )

1517 if test $ac_cv_have_z_modifier = yes; then

1518 AC_DEFINE(HAVE_FORMAT_Z)

1519 fi

1520 AC_MSG_RESULT($ac_cv_have_z_modifier)

1521

1522

1523 dnl find the number of bits we must shift a value to match the given mask

1524 dnl (e.g., mask 0x00f0 requires shifting with 4)

1525 ## NOTE: some platforms only need one '\' to escape '"' in string constant

1526 define(AC_SHIFT_OFFSET,[

1527 AC_CACHE_CHECK(shift offset of $1, $2,

1528 [LIBS1="$LIBS"; LIBS="" # avoid libwrap allow_severity undefined

1529 conftestoffset="conftestoffset.out"

1530 AC_TRY_RUN([

1531 #include <errno.h>

1532 #include <stdlib.h>

1533 #include <stdio.h>

1534 #include <termios.h>

1535 #include <string.h>

1536 int main(){

1537 unsigned int i,n=$1;

1538 FILE *f;

1539 if ((f=fopen("$conftestoffset","w"))==NULL){

1540 fprintf(stderr,"\\"$conftestoffset\\": %s\n",strerror(errno)); exit(-1);

1541 }

1542 if (n==0) {fprintf(stderr,"$1 is 0 (impossible!)\n"); exit(1);}

1543 i=0; while (!(n&1)) {

1544 n>>=1; ++i; }

1545 if (3<<i == $1) {

1546 fprintf(f, "%u", i);

1547 } else {

1548 fprintf(f, "-1"); /* anticipate result of xioinitialize assert */

1549 }

1550 exit(0);

1551 }

1552 ],

1553 [$2=`cat $conftestoffset`],

1554 [$2=-1],

1555 [$2=-1]

1556 )

1557 LIBS="$LIBS1"])

1558 AC_DEFINE_UNQUOTED($1_SHIFT, ${$2})

1559 if test "$2" = -1; then

1560 AC_MSG_WARN(please determine $1_SHIFT manually)

1561 fi

1562 ])

1563

1564 AC_SHIFT_OFFSET(CRDLY, sc_cv_sys_crdly_shift)

1565 AC_SHIFT_OFFSET(TABDLY, sc_cv_sys_tabdly_shift)

1566 AC_SHIFT_OFFSET(CSIZE, sc_cv_sys_csize_shift)

1567

1568

1569 dnl Find what physical type (basic C type) is equivalent to the given type.

1570 dnl If possible we try to compile simple test code and get no warning only with

1571 dnl the matching type.

1572 dnl If this method does not seem to work we run test programs that print the

1573 dnl length and signedness of the type.

1574

1575 dnl do we have a -Werror option?

1576 dnl Does the test code compile with -Werror when types fit?

1577 CHANCE_TO_TYPECHECK=1

1578 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"

1579 AC_TRY_COMPILE([#include <stdlib.h>],[int u; int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)

1580 CFLAGS="$CFLAGS1"

1581

1582 dnl Does the test code compile without -Werror when types do not fit?

1583 if test "$CHANCE_TO_TYPECHECK" -ne 0; then

1584 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],,CHANCE_TO_TYPECHECK=0)

1585 fi

1586

1587 dnl Does the test code fail to compile with -Werror when types do not fit?

1588 if test "$CHANCE_TO_TYPECHECK" -ne 0; then

1589 CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"

1590 AC_TRY_COMPILE([#include <stdlib.h>],[int u; unsigned int v; exit(&u==&v);],CHANCE_TO_TYPECHECK=0,)

1591 CFLAGS="$CFLAGS1"

1592 fi

1593

1594 if test "$CHANCE_TO_TYPECHECK" -ne 0; then

1595 AC_MSG_NOTICE(using compile -Werror method to find basic types)

1596 else

1597 AC_MSG_NOTICE(using code run method to find basic types)

1598 fi

1599

1600

1601 dnl see AC_BASIC_TYPE

1602 define(AC_BASIC_TYPE_GCC,[

1603 AC_CACHE_CHECK(for equivalent simple type of $2, $4,

1604 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"

1605 dnl echo "echo: trying short for $2" >&2

1606 AC_TRY_COMPILE([$1],[$2 u; short v; return(&u==&v);],

1607 [$4="1 /* short */"],

1608 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u==&v);],

1609 [$4="2 /* unsigned short */"],

1610 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u==&v);],

1611 [$4="3 /* int */"],

1612 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u==&v);],

1613 [$4="4 /* unsigned int */"],

1614 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u==&v);],

1615 [$4="5 /* long */"],

1616 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u==&v);],

1617 [$4="6 /* unsigned long */"],

1618 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u==&v);],

1619 [$4="7 /* long long */"],

1620 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u==&v);],

1621 [$4="8 /* unsigned long long */"],

1622 [$4="0 /* unknown, taking default */"

1623 ]) ]) ]) ]) ]) ]) ]) ])

1624 CFLAGS="$CFLAGS1" ])

1625 AC_DEFINE_UNQUOTED($3, ${$4})

1626 ])

1627

1628 dnl see AC_BASIC_TYPE

1629 define(AC_BASIC_TYPE_OTHER,[

1630 AC_CACHE_CHECK(for equivalent simple type of $2, $4,

1631 [AC_TRY_RUN([

1632 $1

1633 int main() { return!(sizeof($2)==sizeof(short));}],

1634 # same length as short

1635 AC_TRY_RUN([

1636 $1

1637 int main() { $2 x=-1; return !(x<0);}],

1638 [$4="1 /* short */"],

1639 [$4="2 /* unsigned short */"]),

1640 # length differs from short, try others

1641 AC_TRY_RUN([

1642 $1

1643 int main() { return!(sizeof($2)==sizeof(int));}],

1644 # same length as int

1645 AC_TRY_RUN([

1646 $1

1647 int main() { $2 x=-1; return !(x<0);}],

1648 [$4="3 /* int */"],

1649 [$4="4 /* unsigned int */"]),

1650 # length differs from int, try others

1651 AC_TRY_RUN([

1652 $1

1653 int main() { return !(sizeof($2)==sizeof(long));}],

1654 # same length as long

1655 AC_TRY_RUN([

1656 $1

1657 int main() { $2 x=-1; return !(x<0);}],

1658 [$4="5 /* long */"],

1659 [$4="6 /* unsigned long */"] ),

1660 # length differs from long, try others

1661 AC_TRY_RUN([

1662 $1

1663 int main() { return !(sizeof($2)==sizeof(long long));}],

1664 # same length as long long

1665 AC_TRY_RUN([

1666 $1

1667 int main() { $2 x=-1; return !(x<0);}],

1668 [$4="7 /* long long */"],

1669 [$4="8 /* unsigned long long */"] ),

1670 [$4="0 /* unknown */"]

1671 )

1672 )

1673 )

1674 )

1675 ])

1676 AC_DEFINE_UNQUOTED($3, ${$4})

1677 ])

1678

1679 dnl find what physical type (basic C type) is equivalent to the given type.

1680 dnl arg1: include file(s)

1681 dnl arg2: type name

1682 dnl arg3: output variable

1683 dnl arg4: cache variable (might be constructed automatically)

1684 dnl output values: 1..short, 2..unsigned short, 3..int, 4..u-int,

1685 dnl 5..long, 6..u-long; others not yet supported

1686 define(AC_BASIC_TYPE,[

1687 if test "$CHANCE_TO_TYPECHECK" -ne 0; then

1688 AC_BASIC_TYPE_GCC([$1],[$2],[$3],[$4])

1689 else

1690 AC_BASIC_TYPE_OTHER([$1],[$2],[$3],[$4])

1691 fi

1692 ])

1693

1694

1695 dnl See AC_TYPEOF_COMPONENT

1696 dnl This version is for compilers with -Werror or so: gcc, clang, Sun Studio?

1697 define(AC_TYPEOF_COMPONENT_GCC,[

1698 AC_CACHE_CHECK(for basic type of $2.$3, $5,

1699 [CFLAGS1="$CFLAGS"; CFLAGS="$ERRONWARN $(echo "$CFLAGS1" | sed -e 's@-Wall@@g')"

1700 AC_TRY_COMPILE([$1],[$2 u;short v; return(&u.$3==&v);],

1701 [$5="1 /* short */"],

1702 [AC_TRY_COMPILE([$1],[$2 u; unsigned short v; return(&u.$3==&v);],

1703 [$5="2 /* unsigned short */"],

1704 [AC_TRY_COMPILE([$1],[$2 u; int v; return(&u.$3==&v);],

1705 [$5="3 /* int */"],

1706 [AC_TRY_COMPILE([$1],[$2 u; unsigned int v; return(&u.$3==&v);],

1707 [$5="4 /* unsigned int */"],

1708 [AC_TRY_COMPILE([$1],[$2 u; long v; return(&u.$3==&v);],

1709 [$5="5 /* long */"],

1710 [AC_TRY_COMPILE([$1],[$2 u; unsigned long v; return(&u.$3==&v);],

1711 [$5="6 /* unsigned long */"],

1712 [AC_TRY_COMPILE([$1],[$2 u; long long v; return(&u.$3==&v);],

1713 [$5="7 /* long long */"],

1714 [AC_TRY_COMPILE([$1],[$2 u; unsigned long long v; return(&u.$3==&v);],

1715 [$5="8 /* unsigned long long */"],

1716 [$5="0 /* unknown, taking default */"

1717 ]) ]) ]) ]) ]) ]) ]) ])

1718 CFLAGS="$CFLAGS1" ])

1719 AC_DEFINE_UNQUOTED($4, ${$5})

1720 ])

1721

1722 dnl See AC_TYPEOF_COMPONENT

1723 dnl This version is for compilers with no -Werror or so

1724 define(AC_TYPEOF_COMPONENT_OTHER,[

1725 AC_CACHE_CHECK(for basic type of $2.$3, $5,

1726 [AC_TRY_RUN([

1727 $1

1728 int main() { $2 x; return!(sizeof(x.$3)==sizeof(short));}],

1729 # same length as short

1730 AC_TRY_RUN([

1731 $1

1732 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],

1733 [$5="1 /* short */"],

1734 [$5="2 /* unsigned short */"]),

1735 # length differs from short, try others

1736 AC_TRY_RUN([

1737 $1

1738 int main() { $2 x; return!(sizeof(x.$3)==sizeof(int));}],

1739 # same length as int

1740 AC_TRY_RUN([

1741 $1

1742 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],

1743 [$5="3 /* int */"],

1744 [$5="4 /* unsigned int */"]),

1745 # length differs from int, try others

1746 AC_TRY_RUN([

1747 $1

1748 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long));}],

1749 # same length as long

1750 AC_TRY_RUN([

1751 $1

1752 int main() { $2 x; x.$3=-1; return !(x.$3<0);}],

1753 [$5="5 /* long */"],

1754 [$5="6 /* unsigned long */"] ),

1755 # length differs from long, try others

1756 AC_TRY_RUN([

1757 $1

1758 int main() { $2 x; return !(sizeof(x.$3)==sizeof(long long));}],

1759 # same length as long long

1760 AC_TRY_RUN([

1761 $1

1762 int main() { x $2; x.$3=-1; return !(x.$3<0);}],

1763 [$5="7 /* long long */"],

1764 [$5="8 /* unsigned long long */"] ),

1765 [$5="0 /* unknown */"]

1766 )

1767 )

1768 )

1769 )

1770 ])

1771 AC_DEFINE_UNQUOTED($4, ${$5})

1772 ])

1773

1774 dnl find what physical type (basic C type) describes the given struct or union

1775 dnl component.

1776 dnl arg1: include file(s); must declare the structure type

1777 dnl arg2: struct name (e.g., "struct stat")

1778 dnl arg3: variable or component (e.g., "st_ino")

1779 dnl arg4: output variable, values see AC_BASIC_TYPE

1780 dnl arg5: cache variable (might be constructed automatically)

1781 define(AC_TYPEOF_COMPONENT,[

1782 if test "$CHANCE_TO_TYPECHECK" -ne 0; then

1783 AC_TYPEOF_COMPONENT_GCC([$1],[$2],[$3],[$4],[$5])

1784 else

1785 AC_TYPEOF_COMPONENT_OTHER([$1],[$2],[$3],[$4],[$5])

1786 fi

1787 ])

1788

1789 AC_BASIC_TYPE([#include <stdlib.h>], size_t, HAVE_BASIC_SIZE_T, sc_cv_type_sizet_basic)

1790 AC_BASIC_TYPE([#include <sys/types.h>

1791 #include <sys/stat.h>

1792 #include <unistd.h>], mode_t, HAVE_BASIC_MODE_T, sc_cv_type_modet_basic)

1793 AC_BASIC_TYPE([#include <sys/types.h>

1794 #include <unistd.h>], pid_t, HAVE_BASIC_PID_T, sc_cv_type_pidt_basic)

1795 AC_BASIC_TYPE([#include <sys/types.h>

1796 #include <unistd.h>], uid_t, HAVE_BASIC_UID_T, sc_cv_type_uidt_basic)

1797 AC_BASIC_TYPE([#include <sys/types.h>

1798 #include <unistd.h>], gid_t, HAVE_BASIC_GID_T, sc_cv_type_gidt_basic)

1799

1800 AC_BASIC_TYPE([#include <time.h>], time_t, HAVE_BASIC_TIME_T,

1801 sc_cv_type_timet_basic)

1802

1803 # this is questionable, might fail on some systems

1804 AC_BASIC_TYPE([#include <sys/types.h>

1805 #include <sys/socket.h>

1806 #include <unistd.h>], socklen_t, HAVE_BASIC_SOCKLEN_T,

1807 sc_cv_type_socklent_basic)

1808

1809 AC_BASIC_TYPE([#include <sys/types.h>

1810 #include <unistd.h>], off_t, HAVE_BASIC_OFF_T, sc_cv_type_off_basic)

1811

1812 AC_BASIC_TYPE([#include <sys/types.h>

1813 #include <unistd.h>], off64_t, HAVE_BASIC_OFF64_T, sc_cv_type_off64_basic)

1814

1815 # oh god, __dev_t in Linux 2.4 is struct{int[2];}, not handled here yet.

1816 AC_BASIC_TYPE([#include <sys/stat.h>], dev_t, HAVE_BASIC_DEV_T, sc_cv_type_dev_basic)

1817

1818 AC_BASIC_TYPE([#include <unistd.h>

1819 #include <termios.h>], speed_t, HAVE_BASIC_SPEED_T, sc_cv_type_spee_t)

1820

1821 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_ino, HAVE_TYPEOF_ST_INO, sc_cv_type_stat_stino_basic)

1822 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_nlink, HAVE_TYPEOF_ST_NLINK, sc_cv_type_stat_stnlink_basic)

1823 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_size, HAVE_TYPEOF_ST_SIZE, sc_cv_type_stat_stsize_basic)

1824 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blksize, HAVE_TYPEOF_ST_BLKSIZE, sc_cv_type_stat_stblksize_basic)

1825 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat, st_blocks, HAVE_TYPEOF_ST_BLOCKS, sc_cv_type_stat_stblocks_basic)

1826 #

1827 if test "$ac_cv_func_stat64" = yes; then

1828 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_dev, HAVE_TYPEOF_ST64_DEV, sc_cv_type_stat64_stdev_basic)

1829 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_ino, HAVE_TYPEOF_ST64_INO, sc_cv_type_stat64_stino_basic)

1830 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_nlink, HAVE_TYPEOF_ST64_NLINK, sc_cv_type_stat64_stnlink_basic)

1831 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_size, HAVE_TYPEOF_ST64_SIZE, sc_cv_type_stat64_stsize_basic)

1832 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blksize, HAVE_TYPEOF_ST64_BLKSIZE, sc_cv_type_stat64_stblksize_basic)

1833 AC_TYPEOF_COMPONENT([#include <sys/stat.h>], struct stat64, st_blocks, HAVE_TYPEOF_ST64_BLOCKS, sc_cv_type_stat64_stblocks_basic)

1834 fi

1835

1836 AC_TYPEOF_COMPONENT([#include <sys/time.h>], struct timeval, tv_usec, HAVE_TYPEOF_STRUCT_TIMEVAL_TV_USEC, sc_cv_type_struct_timeval_tv_usec)

1837

1838 AC_TYPEOF_COMPONENT([#include <sys/types.h>

1839 #include <sys/time.h>

1840 #include <sys/resource.h>],

1841 struct rlimit, rlim_max, HAVE_TYPEOF_RLIM_MAX, sc_cv_type_rlimit_rlimmax_basic)

1842

1843 # Fedora-19 doc says it is socklen_t which is equivalent to unsigned int, but it is equivalent to size_t (x86_64)

1844 AC_TYPEOF_COMPONENT([#include "sysincludes.h"], struct cmsghdr, cmsg_len, HAVE_TYPEOF_STRUCT_CMSGHDR_CMSG_LEN, sc_cv_typeof_struct_cmsghdr_cmsg_len)

1845 ### snprintf, vsnprintf

1846

1847

1848 AC_MSG_CHECKING(for /dev/ptmx)

1849 if test -c /dev/ptmx; then

1850 AC_DEFINE(HAVE_DEV_PTMX, 1)

1851 AC_MSG_RESULT(yes)

1852 else

1853 AC_MSG_RESULT(no)

1854 AC_MSG_CHECKING(for /dev/ptc)

1855 if test -c /dev/ptc; then

1856 AC_DEFINE(HAVE_DEV_PTC)