The Tcpdump Group git mirrors - tcpdump/blob

3 dnl

4 dnl Redistribution and use in source and binary forms, with or without

5 dnl modification, are permitted provided that: (1) source code distributions

6 dnl retain the above copyright notice and this paragraph in its entirety, (2)

7 dnl distributions including binary code include the above copyright notice and

8 dnl this paragraph in its entirety in the documentation or other materials

9 dnl provided with the distribution, and (3) all advertising materials mentioning

10 dnl features or use of this software display the following acknowledgement:

11 dnl ``This product includes software developed by the University of California,

12 dnl Lawrence Berkeley Laboratory and its contributors.'' Neither the name of

13 dnl the University nor the names of its contributors may be used to endorse

14 dnl or promote products derived from this software without specific prior

15 dnl written permission.

16 dnl THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED

17 dnl WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF

18 dnl MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

19 dnl

20 dnl LBL autoconf macros

21 dnl

23 dnl

24 dnl Do whatever AC_LBL_C_INIT work is necessary before using AC_PROG_CC.

25 dnl

26 dnl It appears that newer versions of autoconf (2.64 and later) will,

27 dnl if you use AC_TRY_COMPILE in a macro, stick AC_PROG_CC at the

28 dnl beginning of the macro, even if the macro itself calls AC_PROG_CC.

29 dnl See the "Prerequisite Macros" and "Expanded Before Required" sections

30 dnl in the Autoconf documentation.

31 dnl

32 dnl This causes a steaming heap of fail in our case, as we were, in

33 dnl AC_LBL_C_INIT, doing the tests we now do in AC_LBL_C_INIT_BEFORE_CC,

34 dnl calling AC_PROG_CC, and then doing the tests we now do in

35 dnl AC_LBL_C_INIT. Now, we run AC_LBL_C_INIT_BEFORE_CC, AC_PROG_CC,

36 dnl and AC_LBL_C_INIT at the top level.

37 dnl

38 AC_DEFUN(AC_LBL_C_INIT_BEFORE_CC,

39 [

40 AC_BEFORE([$0], [AC_LBL_C_INIT])

41 AC_BEFORE([$0], [AC_PROG_CC])

42 AC_BEFORE([$0], [AC_LBL_FIXINCLUDES])

43 AC_BEFORE([$0], [AC_LBL_DEVEL])

44 AC_ARG_WITH(gcc, [ --without-gcc don't use gcc])

45 $1=""

46 if test "${srcdir}" != "." ; then

47 $1="-I$srcdir"

48 fi

49 if test "${CFLAGS+set}" = set; then

50 LBL_CFLAGS="$CFLAGS"

51 fi

52 if test -z "$CC" ; then

53 case "$host_os" in

55 bsdi*)

56 AC_CHECK_PROG(SHLICC2, shlicc2, yes, no)

57 if test $SHLICC2 = yes ; then

58 CC=shlicc2

59 export CC

60 fi

61 ;;

62 esac

63 fi

64 if test -z "$CC" -a "$with_gcc" = no ; then

65 CC=cc

66 export CC

67 fi

68 ])

70 dnl

71 dnl Determine which compiler we're using (cc or gcc)

72 dnl If using gcc, determine the version number

73 dnl If using cc:

74 dnl require that it support ansi prototypes

75 dnl use -O (AC_PROG_CC will use -g -O2 on gcc, so we don't need to

76 dnl do that ourselves for gcc)

77 dnl add -g flags, as appropriate

78 dnl explicitly specify /usr/local/include

79 dnl

80 dnl NOTE WELL: with newer versions of autoconf, "gcc" means any compiler

81 dnl that defines __GNUC__, which means clang, for example, counts as "gcc".

82 dnl

83 dnl usage:

84 dnl

85 dnl AC_LBL_C_INIT(copt, incls)

86 dnl

87 dnl results:

88 dnl

89 dnl $1 (copt set)

90 dnl $2 (incls set)

91 dnl CC

92 dnl LDFLAGS

93 dnl LBL_CFLAGS

94 dnl

95 AC_DEFUN(AC_LBL_C_INIT,

96 [

97 AC_BEFORE([$0], [AC_LBL_FIXINCLUDES])

98 AC_BEFORE([$0], [AC_LBL_DEVEL])

99 AC_BEFORE([$0], [AC_LBL_SHLIBS_INIT])

100 if test "$GCC" = yes ; then

101 #

102 # -Werror forces warnings to be errors.

103 #

104 ac_lbl_cc_force_warning_errors=-Werror

105

106 #

107 # Use -ffloat-store so that, on 32-bit x86, we don't

108 # do 80-bit arithmetic with the FPU; that way we should

109 # get the same results for floating-point calculations

110 # on x86-32 and x86-64.

111 #

112 AC_LBL_CHECK_COMPILER_OPT($1, -ffloat-store)

113 else

114 $2="$$2 -I/usr/local/include"

115 LDFLAGS="$LDFLAGS -L/usr/local/lib"

116

117 case "$host_os" in

118

119 darwin*)

120 #

121 # This is assumed either to be GCC or clang, both

122 # of which use -Werror to force warnings to be errors.

123 #

124 ac_lbl_cc_force_warning_errors=-Werror

125 ;;

126

127 hpux*)

128 #

129 # HP C, which is what we presume we're using, doesn't

130 # exit with a non-zero exit status if we hand it an

131 # invalid -W flag, can't be forced to do so even with

132 # +We, and doesn't handle GCC-style -W flags, so we

133 # don't want to try using GCC-style -W flags.

134 #

135 ac_lbl_cc_dont_try_gcc_dashW=yes

136 ;;

137

138 irix*)

139 #

140 # MIPS C, which is what we presume we're using, doesn't

141 # necessarily exit with a non-zero exit status if we

142 # hand it an invalid -W flag, can't be forced to do

143 # so, and doesn't handle GCC-style -W flags, so we

144 # don't want to try using GCC-style -W flags.

145 #

146 ac_lbl_cc_dont_try_gcc_dashW=yes

147 #

148 # It also, apparently, defaults to "char" being

149 # unsigned, unlike most other C implementations;

150 # I suppose we could say "signed char" whenever

151 # we want to guarantee a signed "char", but let's

152 # just force signed chars.

153 #

154 # -xansi is normally the default, but the

155 # configure script was setting it; perhaps -cckr

156 # was the default in the Old Days. (Then again,

157 # that would probably be for backwards compatibility

158 # in the days when ANSI C was Shiny and New, i.e.

159 # 1989 and the early '90's, so maybe we can just

160 # drop support for those compilers.)

161 #

162 # -g is equivalent to -g2, which turns off

163 # optimization; we choose -g3, which generates

164 # debugging information but doesn't turn off

165 # optimization (even if the optimization would

166 # cause inaccuracies in debugging).

167 #

168 $1="$$1 -xansi -signed -g3"

169 ;;

170

171 osf*)

172 #

173 # Presumed to be DEC OSF/1, Digital UNIX, or

174 # Tru64 UNIX.

175 #

176 # The DEC C compiler, which is what we presume we're

177 # using, doesn't exit with a non-zero exit status if we

178 # hand it an invalid -W flag, can't be forced to do

179 # so, and doesn't handle GCC-style -W flags, so we

180 # don't want to try using GCC-style -W flags.

181 #

182 ac_lbl_cc_dont_try_gcc_dashW=yes

183 #

184 # -g is equivalent to -g2, which turns off

185 # optimization; we choose -g3, which generates

186 # debugging information but doesn't turn off

187 # optimization (even if the optimization would

188 # cause inaccuracies in debugging).

189 #

190 $1="$$1 -g3"

191 ;;

192

193 solaris*)

194 #

195 # Assumed to be Sun C, which requires -errwarn to force

196 # warnings to be treated as errors.

197 #

198 ac_lbl_cc_force_warning_errors=-errwarn

199 ;;

200

201 ultrix*)

202 AC_MSG_CHECKING(that Ultrix $CC hacks const in prototypes)

203 AC_CACHE_VAL(ac_cv_lbl_cc_const_proto,

204 AC_TRY_COMPILE(

205 [#include <sys/types.h>],

206 [struct a { int b; };

207 void c(const struct a *)],

208 ac_cv_lbl_cc_const_proto=yes,

209 ac_cv_lbl_cc_const_proto=no))

210 AC_MSG_RESULT($ac_cv_lbl_cc_const_proto)

211 if test $ac_cv_lbl_cc_const_proto = no ; then

212 AC_DEFINE(const,[],

213 [to handle Ultrix compilers that don't support const in prototypes])

214 fi

215 ;;

216 esac

217 $1="$$1 -O"

218 fi

219 ])

220

221 dnl

222 dnl Check whether, if you pass an unknown warning option to the

223 dnl compiler, it fails or just prints a warning message and succeeds.

224 dnl Set ac_lbl_unknown_warning_option_error to the appropriate flag

225 dnl to force an error if it would otherwise just print a warning message

226 dnl and succeed.

227 dnl

228 AC_DEFUN(AC_LBL_CHECK_UNKNOWN_WARNING_OPTION_ERROR,

229 [

230 AC_MSG_CHECKING([whether the compiler fails when given an unknown warning option])

231 save_CFLAGS="$CFLAGS"

232 CFLAGS="$CFLAGS -Wxyzzy-this-will-never-succeed-xyzzy"

233 AC_TRY_COMPILE(

234 [],

235 [return 0],

236 [

237 AC_MSG_RESULT([no])

238 #

239 # We're assuming this is clang, where

240 # -Werror=unknown-warning-option is the appropriate

241 # option to force the compiler to fail.

242 #

243 ac_lbl_unknown_warning_option_error="-Werror=unknown-warning-option"

244 ],

245 [

246 AC_MSG_RESULT([yes])

247 ])

248 CFLAGS="$save_CFLAGS"

249 ])

250

251 dnl

252 dnl Check whether the compiler option specified as the second argument

253 dnl is supported by the compiler and, if so, add it to the macro

254 dnl specified as the first argument

255 dnl

256 AC_DEFUN(AC_LBL_CHECK_COMPILER_OPT,

257 [

258 AC_MSG_CHECKING([whether the compiler supports the $2 option])

259 save_CFLAGS="$CFLAGS"

260 CFLAGS="$CFLAGS $ac_lbl_unknown_warning_option_error $2"

261 AC_TRY_COMPILE(

262 [],

263 [return 0],

264 [

265 AC_MSG_RESULT([yes])

266 CFLAGS="$save_CFLAGS"

267 $1="$$1 $2"

268 ],

269 [

270 AC_MSG_RESULT([no])

271 CFLAGS="$save_CFLAGS"

272 ])

273 ])

274

275 dnl

276 dnl Check whether the compiler supports an option to generate

277 dnl Makefile-style dependency lines

278 dnl

279 dnl GCC uses -M for this. Non-GCC compilers that support this

280 dnl use a variety of flags, including but not limited to -M.

281 dnl

282 dnl We test whether the flag in question is supported, as older

283 dnl versions of compilers might not support it.

284 dnl

285 dnl We don't try all the possible flags, just in case some flag means

286 dnl "generate dependencies" on one compiler but means something else

287 dnl on another compiler.

288 dnl

289 dnl Most compilers that support this send the output to the standard

290 dnl output by default. IBM's XLC, however, supports -M but sends

291 dnl the output to {sourcefile-basename}.u, and AIX has no /dev/stdout

292 dnl to work around that, so we don't bother with XLC.

293 dnl

294 AC_DEFUN(AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT,

295 [

296 AC_MSG_CHECKING([whether the compiler supports generating dependencies])

297 if test "$GCC" = yes ; then

298 #

299 # GCC, or a compiler deemed to be GCC by AC_PROG_CC (even

300 # though it's not); we assume that, in this case, the flag

301 # would be -M.

302 #

303 ac_lbl_dependency_flag="-M"

304 else

305 #

306 # Not GCC or a compiler deemed to be GCC; what platform is

307 # this? (We're assuming that if the compiler isn't GCC

308 # it's the compiler from the vendor of the OS; that won't

309 # necessarily be true for x86 platforms, where it might be

310 # the Intel C compiler.)

311 #

312 case "$host_os" in

313

314 irix*|osf*|darwin*)

315 #

316 # MIPS C for IRIX, DEC C, and clang all use -M.

317 #

318 ac_lbl_dependency_flag="-M"

319 ;;

320

321 solaris*)

322 #

323 # Sun C uses -xM.

324 #

325 ac_lbl_dependency_flag="-xM"

326 ;;

327

328 hpux*)

329 #

330 # HP's older C compilers don't support this.

331 # HP's newer C compilers support this with

332 # either +M or +Make; the older compilers

333 # interpret +M as something completely

334 # different, so we use +Make so we don't

335 # think it works with the older compilers.

336 #

337 ac_lbl_dependency_flag="+Make"

338 ;;

339

340 *)

341 #

342 # Not one of the above; assume no support for

343 # generating dependencies.

344 #

345 ac_lbl_dependency_flag=""

346 ;;

347 esac

348 fi

349

350 #

351 # Is ac_lbl_dependency_flag defined and, if so, does the compiler

352 # complain about it?

353 #

354 # Note: clang doesn't seem to exit with an error status when handed

355 # an unknown non-warning error, even if you pass it

356 # -Werror=unknown-warning-option. However, it always supports

357 # -M, so the fact that this test always succeeds with clang

358 # isn't an issue.

359 #

360 if test ! -z "$ac_lbl_dependency_flag"; then

361 AC_LANG_CONFTEST(

362 [AC_LANG_SOURCE([[int main(void) { return 0; }]])])

363 echo "$CC" $ac_lbl_dependency_flag conftest.c >&5

364 if "$CC" $ac_lbl_dependency_flag conftest.c >/dev/null 2>&1; then

365 AC_MSG_RESULT([yes, with $ac_lbl_dependency_flag])

366 DEPENDENCY_CFLAG="$ac_lbl_dependency_flag"

367 MKDEP='${srcdir}/mkdep'

368 else

369 AC_MSG_RESULT([no])

370 #

371 # We can't run mkdep, so have "make depend" do

372 # nothing.

373 #

374 MKDEP=:

375 fi

376 rm -rf conftest*

377 else

378 AC_MSG_RESULT([no])

379 #

380 # We can't run mkdep, so have "make depend" do

381 # nothing.

382 #

383 MKDEP=:

384 fi

385 AC_SUBST(DEPENDENCY_CFLAG)

386 AC_SUBST(MKDEP)

387 ])

388

389 #

390 # Try compiling a sample of the type of code that appears in

391 # gencode.c with "inline", "__inline__", and "__inline".

392 #

393 # Autoconf's AC_C_INLINE, at least in autoconf 2.13, isn't good enough,

394 # as it just tests whether a function returning "int" can be inlined;

395 # at least some versions of HP's C compiler can inline that, but can't

396 # inline a function that returns a struct pointer.

397 #

398 # Make sure we use the V_CCOPT flags, because some of those might

399 # disable inlining.

400 #

401 AC_DEFUN(AC_LBL_C_INLINE,

402 [AC_MSG_CHECKING(for inline)

403 save_CFLAGS="$CFLAGS"

404 CFLAGS="$V_CCOPT"

405 AC_CACHE_VAL(ac_cv_lbl_inline, [

406 ac_cv_lbl_inline=""

407 ac_lbl_cc_inline=no

408 for ac_lbl_inline in inline __inline__ __inline

409 do

410 AC_TRY_COMPILE(

411 [#define inline $ac_lbl_inline

412 static inline struct iltest *foo(void);

413 struct iltest {

414 int iltest1;

415 int iltest2;

416 };

417

418 static inline struct iltest *

419 foo()

420 {

421 static struct iltest xxx;

422

423 return &xxx;

424 }],,ac_lbl_cc_inline=yes,)

425 if test "$ac_lbl_cc_inline" = yes ; then

426 break;

427 fi

428 done

429 if test "$ac_lbl_cc_inline" = yes ; then

430 ac_cv_lbl_inline=$ac_lbl_inline

431 fi])

432 CFLAGS="$save_CFLAGS"

433 if test ! -z "$ac_cv_lbl_inline" ; then

434 AC_MSG_RESULT($ac_cv_lbl_inline)

435 else

436 AC_MSG_RESULT(no)

437 fi

438 AC_DEFINE_UNQUOTED(inline, $ac_cv_lbl_inline, [Define as token for inline if inlining supported])])

439

440 dnl

441 dnl Use pfopen.c if available and pfopen() not in standard libraries

442 dnl Require libpcap

443 dnl Look for libpcap in ..

444 dnl Use the installed libpcap if there is no local version

445 dnl

446 dnl usage:

447 dnl

448 dnl AC_LBL_LIBPCAP(pcapdep, incls)

449 dnl

450 dnl results:

451 dnl

452 dnl $1 (pcapdep set)

453 dnl $2 (incls appended)

454 dnl LIBS

455 dnl LBL_LIBS

456 dnl

457 AC_DEFUN(AC_LBL_LIBPCAP,

458 [AC_REQUIRE([AC_LBL_LIBRARY_NET])

459 dnl

460 dnl save a copy before locating libpcap.a

461 dnl

462 LBL_LIBS="$LIBS"

463 pfopen=/usr/examples/packetfilter/pfopen.c

464 if test -f $pfopen ; then

465 AC_CHECK_FUNCS(pfopen)

466 if test $ac_cv_func_pfopen = "no" ; then

467 AC_MSG_RESULT(Using $pfopen)

468 LIBS="$LIBS $pfopen"

469 fi

470 fi

471 libpcap=FAIL

472 AC_MSG_CHECKING(for local pcap library)

473 AC_ARG_WITH([system-libpcap],

474 [AS_HELP_STRING([--with-system-libpcap], [don't use local pcap library])])

475 if test "x$with_system_libpcap" != xyes ; then

476 lastdir=FAIL

477 places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \

478 egrep '/libpcap-[[0-9]]+\.[[0-9]]+(\.[[0-9]]*)?([[ab]][[0-9]]*|-PRE-GIT)?$'`

479 places2=`ls .. | sed -e 's,/$,,' -e "s,^,../," | \

480 egrep '/libpcap-[[0-9]]+\.[[0-9]]+(\.[[0-9]]*)?([[ab]][[0-9]]*|-PRE-GIT)?$'`

481 for dir in $places $srcdir/../libpcap ../libpcap $srcdir/libpcap $places2 ; do

482 basedir=`echo $dir | sed -e 's/[[ab]][[0-9]]*$//' | \

483 sed -e 's/-PRE-GIT$//' `

484 if test $lastdir = $basedir ; then

485 dnl skip alphas when an actual release is present

486 continue;

487 fi

488 lastdir=$dir

489 if test -r $dir/libpcap.a ; then

490 libpcap=$dir/libpcap.a

491 d=$dir

492 dnl continue and select the last one that exists

493 fi

494 done

495 fi

496 if test $libpcap = FAIL ; then

497 AC_MSG_RESULT(not found)

498

499 #

500 # Look for pcap-config.

501 #

502 AC_PATH_TOOL(PCAP_CONFIG, pcap-config)

503 if test -n "$PCAP_CONFIG" ; then

504 #

505 # Found - use it to get the include flags for

506 # libpcap and the flags to link with libpcap.

507 #

508 # Please read section 11.6 "Shell Substitutions"

509 # in the autoconf manual before doing anything

510 # to this that involves quoting. Especially note

511 # the statement "There is just no portable way to use

512 # double-quoted strings inside double-quoted back-quoted

513 # expressions (pfew!)."

514 #

515 cflags=`"$PCAP_CONFIG" --cflags`

516 $2="$cflags $$2"

517 libpcap=`"$PCAP_CONFIG" --libs`

518 else

519 #

520 # Not found; look for pcap.

521 #

522 AC_CHECK_LIB(pcap, main, libpcap="-lpcap")

523 if test $libpcap = FAIL ; then

524 AC_MSG_ERROR(see the INSTALL doc for more info)

525 fi

526 dnl

527 dnl Some versions of Red Hat Linux put "pcap.h" in

528 dnl "/usr/include/pcap"; had the LBL folks done so,

529 dnl that would have been a good idea, but for

530 dnl the Red Hat folks to do so just breaks source

531 dnl compatibility with other systems.

532 dnl

533 dnl We work around this by assuming that, as we didn't

534 dnl find a local libpcap, libpcap is in /usr/lib or

535 dnl /usr/local/lib and that the corresponding header

536 dnl file is under one of those directories; if we don't

537 dnl find it in either of those directories, we check to

538 dnl see if it's in a "pcap" subdirectory of them and,

539 dnl if so, add that subdirectory to the "-I" list.

540 dnl

541 dnl (We now also put pcap.h in /usr/include/pcap, but we

542 dnl leave behind a /usr/include/pcap.h that includes it,

543 dnl so you can still just include <pcap.h>.)

544 dnl

545 AC_MSG_CHECKING(for extraneous pcap header directories)

546 if test $ ! -r /usr/local/include/pcap.h $ -a \

547 $ ! -r /usr/include/pcap.h $; then

548 if test -r /usr/local/include/pcap/pcap.h; then

549 d="/usr/local/include/pcap"

550 elif test -r /usr/include/pcap/pcap.h; then

551 d="/usr/include/pcap"

552 fi

553 fi

554 if test -z "$d" ; then

555 AC_MSG_RESULT(not found)

556 else

557 $2="-I$d $$2"

558 AC_MSG_RESULT(found -- -I$d added)

559 fi

560 fi

561 else

562 $1=$libpcap

563 places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \

564 egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`

565 places2=`ls .. | sed -e 's,/$,,' -e "s,^,../," | \

566 egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`

567 pcapH=FAIL

568 if test -r $d/pcap.h; then

569 pcapH=$d

570 else

571 for dir in $places $srcdir/../libpcap ../libpcap $srcdir/libpcap $places2 ; do

572 if test -r $dir/pcap.h ; then

573 pcapH=$dir

574 fi

575 done

576 fi

577

578 if test $pcapH = FAIL ; then

579 AC_MSG_ERROR(cannot find pcap.h: see INSTALL)

580 fi

581 $2="-I$pcapH $$2"

582 AC_MSG_RESULT($libpcap)

583 AC_PATH_PROG(PCAP_CONFIG, pcap-config,, $d)

584 if test -n "$PCAP_CONFIG"; then

585 #

586 # The libpcap directory has a pcap-config script.

587 # Use it to get any additioal libraries needed

588 # to link with the libpcap archive library in

589 # that directory.

590 #

591 # Please read section 11.6 "Shell Substitutions"

592 # in the autoconf manual before doing anything

593 # to this that involves quoting. Especially note

594 # the statement "There is just no portable way to use

595 # double-quoted strings inside double-quoted back-quoted

596 # expressions (pfew!)."

597 #

598 additional_libs=`"$PCAP_CONFIG" --additional-libs --static`

599 libpcap="$libpcap $additional_libs"

600 fi

601 fi

602 LIBS="$libpcap $LIBS"

603 if ! test -n "$PCAP_CONFIG" ; then

604 #

605 # We don't have pcap-config; find out any additional link flags

606 # we need. (If we have pcap-config, we assume it tells us what

607 # we need.)

608 #

609 case "$host_os" in

610

611 aix*)

612 #

613 # If libpcap is DLPI-based, we have to use /lib/pse.exp if

614 # present, as we use the STREAMS routines.

615 #

616 # (XXX - true only if we're linking with a static libpcap?)

617 #

618 pseexe="/lib/pse.exp"

619 AC_MSG_CHECKING(for $pseexe)

620 if test -f $pseexe ; then

621 AC_MSG_RESULT(yes)

622 LIBS="$LIBS -I:$pseexe"

623 fi

624

625 #

626 # If libpcap is BPF-based, we need "-lodm" and "-lcfg", as

627 # we use them to load the BPF module.

628 #

629 # (XXX - true only if we're linking with a static libpcap?)

630 #

631 LIBS="$LIBS -lodm -lcfg"

632 ;;

633 esac

634 fi

635

636 dnl

637 dnl Check for "pcap_loop()", to make sure we found a working

638 dnl libpcap and have all the right other libraries with which

639 dnl to link. (Otherwise, the checks below will fail, not

640 dnl because the routines are missing from the library, but

641 dnl because we aren't linking properly with libpcap, and

642 dnl that will cause confusing errors at build time.)

643 dnl

644 AC_CHECK_FUNC(pcap_loop,,

645 [

646 AC_MSG_ERROR(

647 [Report this to tcpdump-workers@lists.tcpdump.org, and include the

648 config.log file in your report. If you have downloaded libpcap from

649 tcpdump.org, and built it yourself, please also include the config.log

650 file from the libpcap source directory, the Makefile from the libpcap

651 source directory, and the output of the make process for libpcap, as

652 this could be a problem with the libpcap that was built, and we will

653 not be able to determine why this is happening, and thus will not be

654 able to fix it, without that information, as we have not been able to

655 reproduce this problem ourselves.])

656 ])

657 ])

658

659 dnl

660 dnl Define RETSIGTYPE and RETSIGVAL

661 dnl

662 dnl usage:

663 dnl

664 dnl AC_LBL_TYPE_SIGNAL

665 dnl

666 dnl results:

667 dnl

668 dnl RETSIGTYPE (defined)

669 dnl RETSIGVAL (defined)

670 dnl

671 AC_DEFUN(AC_LBL_TYPE_SIGNAL,

672 [AC_BEFORE([$0], [AC_LBL_LIBPCAP])

673 AC_TYPE_SIGNAL

674 if test "$ac_cv_type_signal" = void ; then

675 AC_DEFINE(RETSIGVAL,[],[return value of signal handlers])

676 else

677 AC_DEFINE(RETSIGVAL,(0),[return value of signal handlers])

678 fi

679 case "$host_os" in

680

681 irix*)

682 AC_DEFINE(_BSD_SIGNALS,1,[get BSD semantics on Irix])

683 ;;

684

685 *)

686 dnl prefer sigaction() to sigset()

687 AC_CHECK_FUNCS(sigaction)

688 if test $ac_cv_func_sigaction = no ; then

689 AC_CHECK_FUNCS(sigset)

690 fi

691 ;;

692 esac])

693

694 dnl

695 dnl If using gcc, make sure we have ANSI ioctl definitions

696 dnl

697 dnl usage:

698 dnl

699 dnl AC_LBL_FIXINCLUDES

700 dnl

701 AC_DEFUN(AC_LBL_FIXINCLUDES,

702 [if test "$GCC" = yes ; then

703 AC_MSG_CHECKING(for ANSI ioctl definitions)

704 AC_CACHE_VAL(ac_cv_lbl_gcc_fixincludes,

705 AC_TRY_COMPILE(

706 [/*

707 * This generates a "duplicate case value" when fixincludes

708 * has not be run.

709 */

710 # include <sys/types.h>

711 # include <sys/time.h>

712 # include <sys/ioctl.h>

713 # ifdef HAVE_SYS_IOCCOM_H

714 # include <sys/ioccom.h>

715 # endif],

716 [switch (0) {

717 case _IO('A', 1):;

718 case _IO('B', 1):;

719 }],

720 ac_cv_lbl_gcc_fixincludes=yes,

721 ac_cv_lbl_gcc_fixincludes=no))

722 AC_MSG_RESULT($ac_cv_lbl_gcc_fixincludes)

723 if test $ac_cv_lbl_gcc_fixincludes = no ; then

724 # Don't cache failure

725 unset ac_cv_lbl_gcc_fixincludes

726 AC_MSG_ERROR(see the INSTALL for more info)

727 fi

728 fi])

729

730 dnl

731 dnl Checks to see if union wait is used with WEXITSTATUS()

732 dnl

733 dnl usage:

734 dnl

735 dnl AC_LBL_UNION_WAIT

736 dnl

737 dnl results:

738 dnl

739 dnl DECLWAITSTATUS (defined)

740 dnl

741 AC_DEFUN(AC_LBL_UNION_WAIT,

742 [AC_MSG_CHECKING(if union wait is used)

743 AC_CACHE_VAL(ac_cv_lbl_union_wait,

744 AC_TRY_COMPILE([

745 # include <sys/types.h>

746 # include <sys/wait.h>],

747 [int status;

748 u_int i = WEXITSTATUS(status);

749 u_int j = waitpid(0, &status, 0);],

750 ac_cv_lbl_union_wait=no,

751 ac_cv_lbl_union_wait=yes))

752 AC_MSG_RESULT($ac_cv_lbl_union_wait)

753 if test $ac_cv_lbl_union_wait = yes ; then

754 AC_DEFINE(DECLWAITSTATUS,union wait,[type for wait])

755 else

756 AC_DEFINE(DECLWAITSTATUS,int,[type for wait])

757 fi])

758

759 dnl

760 dnl Checks to see if the sockaddr struct has the 4.4 BSD sa_len member

761 dnl

762 dnl usage:

763 dnl

764 dnl AC_LBL_SOCKADDR_SA_LEN

765 dnl

766 dnl results:

767 dnl

768 dnl HAVE_SOCKADDR_SA_LEN (defined)

769 dnl

770 AC_DEFUN(AC_LBL_SOCKADDR_SA_LEN,

771 [AC_MSG_CHECKING(if sockaddr struct has the sa_len member)

772 AC_CACHE_VAL(ac_cv_lbl_sockaddr_has_sa_len,

773 AC_TRY_COMPILE([

774 # include <sys/types.h>

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

776 [u_int i = sizeof(((struct sockaddr *)0)->sa_len)],

777 ac_cv_lbl_sockaddr_has_sa_len=yes,

778 ac_cv_lbl_sockaddr_has_sa_len=no))

779 AC_MSG_RESULT($ac_cv_lbl_sockaddr_has_sa_len)

780 if test $ac_cv_lbl_sockaddr_has_sa_len = yes ; then

781 AC_DEFINE(HAVE_SOCKADDR_SA_LEN,1,[if struct sockaddr has the sa_len member])

782 fi])

783

784 dnl

785 dnl Checks to see if -R is used

786 dnl

787 dnl usage:

788 dnl

789 dnl AC_LBL_HAVE_RUN_PATH

790 dnl

791 dnl results:

792 dnl

793 dnl ac_cv_lbl_have_run_path (yes or no)

794 dnl

795 AC_DEFUN(AC_LBL_HAVE_RUN_PATH,

796 [AC_MSG_CHECKING(for ${CC-cc} -R)

797 AC_CACHE_VAL(ac_cv_lbl_have_run_path,

798 [echo 'main(){}' > conftest.c

799 ${CC-cc} -o conftest conftest.c -R/a1/b2/c3 >conftest.out 2>&1

800 if test ! -s conftest.out ; then

801 ac_cv_lbl_have_run_path=yes

802 else

803 ac_cv_lbl_have_run_path=no

804 fi

805 rm -f -r conftest*])

806 AC_MSG_RESULT($ac_cv_lbl_have_run_path)

807 ])

808

809 dnl

810 dnl Check whether a given format can be used to print 64-bit integers

811 dnl

812 AC_DEFUN(AC_LBL_CHECK_64BIT_FORMAT,

813 [

814 AC_MSG_CHECKING([whether %$1x can be used to format 64-bit integers])

815 AC_RUN_IFELSE(

816 [

817 AC_LANG_SOURCE(

818 [[

819 # ifdef HAVE_INTTYPES_H

820 #include <inttypes.h>

821 # endif

822 #include <stdio.h>

823 #include <sys/types.h>

824

825 main()

826 {

827 uint64_t t = 1;

828 char strbuf[16+1];

829 sprintf(strbuf, "%016$1x", t << 32);

830 if (strcmp(strbuf, "0000000100000000") == 0)

831 exit(0);

832 else

833 exit(1);

834 }

835 ]])

836 ],

837 [

838 AC_DEFINE(PRId64, "$1d", [define if the platform doesn't define PRId64])

839 AC_DEFINE(PRIo64, "$1o", [define if the platform doesn't define PRIo64])

840 AC_DEFINE(PRIx64, "$1x", [define if the platform doesn't define PRIu64])

841 AC_DEFINE(PRIu64, "$1u", [define if the platform doesn't define PRIx64])

842 AC_MSG_RESULT(yes)

843 ],

844 [

845 AC_MSG_RESULT(no)

846 $2

847 ])

848 ])

849

850 dnl

851 dnl Checks to see if unaligned memory accesses fail

852 dnl

853 dnl usage:

854 dnl

855 dnl AC_LBL_UNALIGNED_ACCESS

856 dnl

857 dnl results:

858 dnl

859 dnl LBL_ALIGN (DEFINED)

860 dnl

861 AC_DEFUN(AC_LBL_UNALIGNED_ACCESS,

862 [AC_MSG_CHECKING(if unaligned accesses fail)

863 AC_CACHE_VAL(ac_cv_lbl_unaligned_fail,

864 [case "$host_cpu" in

865

866 #

867 # These are CPU types where:

868 #

869 # the CPU faults on an unaligned access, but at least some

870 # OSes that support that CPU catch the fault and simulate

871 # the unaligned access (e.g., Alpha/{Digital,Tru64} UNIX) -

872 # the simulation is slow, so we don't want to use it;

873 #

874 # the CPU, I infer (from the old

875 #

876 # XXX: should also check that they don't do weird things (like on arm)

877 #

878 # comment) doesn't fault on unaligned accesses, but doesn't

879 # do a normal unaligned fetch, either (e.g., presumably, ARM);

880 #

881 # for whatever reason, the test program doesn't work

882 # (this has been claimed to be the case for several of those

883 # CPUs - I don't know what the problem is; the problem

884 # was reported as "the test program dumps core" for SuperH,

885 # but that's what the test program is *supposed* to do -

886 # it dumps core before it writes anything, so the test

887 # for an empty output file should find an empty output

888 # file and conclude that unaligned accesses don't work).

889 #

890 # This run-time test won't work if you're cross-compiling, so

891 # in order to support cross-compiling for a particular CPU,

892 # we have to wire in the list of CPU types anyway, as far as

893 # I know, so perhaps we should just have a set of CPUs on

894 # which we know it doesn't work, a set of CPUs on which we

895 # know it does work, and have the script just fail on other

896 # cpu types and update it when such a failure occurs.

897 #

898 alpha*|arm*|bfin*|hp*|mips*|sh*|sparc*|ia64|nv1)

899 ac_cv_lbl_unaligned_fail=yes

900 ;;

901

902 *)

903 cat >conftest.c <<EOF

904 # include <sys/types.h>

905 # include <sys/wait.h>

906 # include <stdio.h>

907 unsigned char a[[5]] = { 1, 2, 3, 4, 5 };

908 main() {

909 unsigned int i;

910 pid_t pid;

911 int status;

912 /* avoid "core dumped" message */

913 pid = fork();

914 if (pid < 0)

915 exit(2);

916 if (pid > 0) {

917 /* parent */

918 pid = waitpid(pid, &status, 0);

919 if (pid < 0)

920 exit(3);

921 exit(!WIFEXITED(status));

922 }

923 /* child */

924 i = *(unsigned int *)&a[[1]];

925 printf("%d\n", i);

926 exit(0);

927 }

928 EOF

929 ${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS \

930 conftest.c $LIBS >/dev/null 2>&1

931 if test ! -x conftest ; then

932 dnl failed to compile for some reason

933 ac_cv_lbl_unaligned_fail=yes

934 else

935 ./conftest >conftest.out

936 if test ! -s conftest.out ; then

937 ac_cv_lbl_unaligned_fail=yes

938 else

939 ac_cv_lbl_unaligned_fail=no

940 fi

941 fi

942 rm -f -r conftest* core core.conftest

943 ;;

944 esac])

945 AC_MSG_RESULT($ac_cv_lbl_unaligned_fail)

946 if test $ac_cv_lbl_unaligned_fail = yes ; then

947 AC_DEFINE(LBL_ALIGN,1,[if unaligned access fails])

948 fi])

949

950 dnl

951 dnl If the file .devel exists:

952 dnl Add some warning flags if the compiler supports them

953 dnl If an os prototype include exists, symlink os-proto.h to it

954 dnl

955 dnl usage:

956 dnl

957 dnl AC_LBL_DEVEL(copt)

958 dnl

959 dnl results:

960 dnl

961 dnl $1 (copt appended)

962 dnl HAVE_OS_PROTO_H (defined)

963 dnl os-proto.h (symlinked)

964 dnl

965 AC_DEFUN(AC_LBL_DEVEL,

966 [rm -f os-proto.h

967 if test "${LBL_CFLAGS+set}" = set; then

968 $1="$$1 ${LBL_CFLAGS}"

969 fi

970 if test -f .devel ; then

971 #

972 # Skip all the warning option stuff on some compilers.

973 #

974 if test "$ac_lbl_cc_dont_try_gcc_dashW" != yes; then

975 AC_LBL_CHECK_UNKNOWN_WARNING_OPTION_ERROR()

976 AC_LBL_CHECK_COMPILER_OPT($1, -Wall)

977 AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-prototypes)

978 AC_LBL_CHECK_COMPILER_OPT($1, -Wstrict-prototypes)

979 AC_LBL_CHECK_COMPILER_OPT($1, -Wwrite-strings)

980 AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-arith)

981 AC_LBL_CHECK_COMPILER_OPT($1, -Wcast-qual)

982 AC_LBL_CHECK_COMPILER_OPT($1, -Wshadow)

983 AC_LBL_CHECK_COMPILER_OPT($1, -Wdeclaration-after-statement)

984 AC_LBL_CHECK_COMPILER_OPT($1, -pedantic)

985 AC_LBL_CHECK_COMPILER_OPT($1, -Wold-style-definition)

986 AC_LBL_CHECK_COMPILER_OPT($1, -W)

987 fi

988 AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT()

989 #

990 # We used to set -n32 for IRIX 6 when not using GCC (presumed

991 # to mean that we're using MIPS C or MIPSpro C); it specified

992 # the "new" faster 32-bit ABI, introduced in IRIX 6.2. I'm

993 # not sure why that would be something to do *only* with a

994 # .devel file; why should the ABI for which we produce code

995 # depend on .devel?

996 #

997 os=`echo $host_os | sed -e 's/$[[0-9]][[0-9]]*$[[^0-9]].*$/\1/'`

998 name="lbl/os-$os.h"

999 if test -f $name ; then

1000 ln -s $name os-proto.h

1001 AC_DEFINE(HAVE_OS_PROTO_H, 1,

1002 [if there's an os_proto.h for this platform, to use additional prototypes])

1003 else

1004 AC_MSG_WARN(can't find $name)

1005 fi

1006 fi])

1007

1008 dnl

1009 dnl Improved version of AC_CHECK_LIB

1010 dnl

1011 dnl Thanks to John Hawkinson (jhawk@mit.edu)

1012 dnl

1013 dnl usage:

1014 dnl

1015 dnl AC_LBL_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [,

1016 dnl ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])

1017 dnl

1018 dnl results:

1019 dnl

1020 dnl LIBS

1021 dnl

1022 dnl XXX - "AC_LBL_LIBRARY_NET" was redone to use "AC_SEARCH_LIBS"

1023 dnl rather than "AC_LBL_CHECK_LIB", so this isn't used any more.

1024 dnl We keep it around for reference purposes in case it's ever

1025 dnl useful in the future.

1026 dnl

1027

1028 define(AC_LBL_CHECK_LIB,

1029 [AC_MSG_CHECKING([for $2 in -l$1])

1030 dnl Use a cache variable name containing the library, function

1031 dnl name, and extra libraries to link with, because the test really is

1032 dnl for library $1 defining function $2, when linked with potinal

1033 dnl library $5, not just for library $1. Separate tests with the same

1034 dnl $1 and different $2's or $5's may have different results.

1035 ac_lib_var=`echo $1['_']$2['_']$5 | sed 'y%./+- %__p__%'`

1036 AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var,

1037 [ac_save_LIBS="$LIBS"

1038 LIBS="-l$1 $5 $LIBS"

1039 AC_TRY_LINK(dnl

1040 ifelse([$2], [main], , dnl Avoid conflicting decl of main.

1041 [/* Override any gcc2 internal prototype to avoid an error. */

1042 ]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus

1043 extern "C"

1044 #endif

1045 ])dnl

1046 [/* We use char because int might match the return type of a gcc2

1047 builtin and then its argument prototype would still apply. */

1048 char $2();

1049 ]),

1050 [$2()],

1051 eval "ac_cv_lbl_lib_$ac_lib_var=yes",

1052 eval "ac_cv_lbl_lib_$ac_lib_var=no")

1053 LIBS="$ac_save_LIBS"

1054 ])dnl

1055 if eval "test \"`echo '$ac_cv_lbl_lib_'$ac_lib_var`\" = yes"; then

1056 AC_MSG_RESULT(yes)

1057 ifelse([$3], ,

1058 [changequote(, )dnl

1059 ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \

1060 -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`

1061 changequote([, ])dnl

1062 AC_DEFINE_UNQUOTED($ac_tr_lib)

1063 LIBS="-l$1 $LIBS"

1064 ], [$3])

1065 else

1066 AC_MSG_RESULT(no)

1067 ifelse([$4], , , [$4

1068 ])dnl

1069 fi

1070 ])

1071

1072 dnl

1073 dnl AC_LBL_LIBRARY_NET

1074 dnl

1075 dnl This test is for network applications that need socket() and

1076 dnl gethostbyname() -ish functions. Under Solaris, those applications

1077 dnl need to link with "-lsocket -lnsl". Under IRIX, they need to link

1078 dnl with "-lnsl" but should *not* link with "-lsocket" because

1079 dnl libsocket.a breaks a number of things (for instance:

1080 dnl gethostbyname() under IRIX 5.2, and snoop sockets under most

1081 dnl versions of IRIX).

1082 dnl

1083 dnl Unfortunately, many application developers are not aware of this,

1084 dnl and mistakenly write tests that cause -lsocket to be used under

1085 dnl IRIX. It is also easy to write tests that cause -lnsl to be used

1086 dnl under operating systems where neither are necessary (or useful),

1087 dnl such as SunOS 4.1.4, which uses -lnsl for TLI.

1088 dnl

1089 dnl This test exists so that every application developer does not test

1090 dnl this in a different, and subtly broken fashion.

1091

1092 dnl It has been argued that this test should be broken up into two

1093 dnl seperate tests, one for the resolver libraries, and one for the

1094 dnl libraries necessary for using Sockets API. Unfortunately, the two

1095 dnl are carefully intertwined and allowing the autoconf user to use

1096 dnl them independantly potentially results in unfortunate ordering

1097 dnl dependancies -- as such, such component macros would have to

1098 dnl carefully use indirection and be aware if the other components were

1099 dnl executed. Since other autoconf macros do not go to this trouble,

1100 dnl and almost no applications use sockets without the resolver, this

1101 dnl complexity has not been implemented.

1102 dnl

1103 dnl The check for libresolv is in case you are attempting to link

1104 dnl statically and happen to have a libresolv.a lying around (and no

1105 dnl libnsl.a).

1106 dnl

1107 AC_DEFUN(AC_LBL_LIBRARY_NET, [

1108 # Most operating systems have gethostbyname() in the default searched

1109 # libraries (i.e. libc):

1110 # Some OSes (eg. Solaris) place it in libnsl

1111 # Some strange OSes (SINIX) have it in libsocket:

1112 AC_SEARCH_LIBS(gethostbyname, nsl socket resolv)

1113 # Unfortunately libsocket sometimes depends on libnsl and

1114 # AC_SEARCH_LIBS isn't up to the task of handling dependencies like this.

1115 if test "$ac_cv_search_gethostbyname" = "no"

1116 then

1117 AC_CHECK_LIB(socket, gethostbyname,

1118 LIBS="-lsocket -lnsl $LIBS", , -lnsl)

1119 fi

1120 AC_SEARCH_LIBS(socket, socket, ,

1121 AC_CHECK_LIB(socket, socket, LIBS="-lsocket -lnsl $LIBS", , -lnsl))

1122 # DLPI needs putmsg under HPUX so test for -lstr while we're at it

1123 AC_SEARCH_LIBS(putmsg, str)

1124 ])

1125

1127 dnl

1128 dnl Redistribution and use in source and binary forms, with or without

1129 dnl modification, are permitted provided that the following conditions

1130 dnl are met:

1131 dnl 1. Redistributions of source code must retain the above copyright

1132 dnl notice, this list of conditions and the following disclaimer.

1133 dnl 2. Redistributions in binary form must reproduce the above copyright

1134 dnl notice, this list of conditions and the following disclaimer in the

1135 dnl documentation and/or other materials provided with the distribution.

1136 dnl 3. Neither the name of the project nor the names of its contributors

1137 dnl may be used to endorse or promote products derived from this software

1138 dnl without specific prior written permission.

1139 dnl

1140 dnl THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND

1141 dnl ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

1142 dnl IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

1143 dnl ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE

1144 dnl FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

1145 dnl DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

1146 dnl OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

1147 dnl HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

1148 dnl LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

1149 dnl OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

1150 dnl SUCH DAMAGE.

1151

1152 dnl

1153 dnl Test for __attribute__

1154 dnl

1155

1156 AC_DEFUN(AC_C___ATTRIBUTE__, [

1157 AC_MSG_CHECKING(for __attribute__)

1158 AC_CACHE_VAL(ac_cv___attribute__, [

1159 AC_COMPILE_IFELSE([

1160 AC_LANG_SOURCE([[

1161 #include <stdlib.h>

1162

1163 static void foo(void) __attribute__ ((noreturn));

1164

1165 static void

1166 foo(void)

1167 {

1168 exit(1);

1169 }

1170

1171 int

1172 main(int argc, char **argv)

1173 {

1174 foo();

1175 }

1176 ]])],

1177 ac_cv___attribute__=yes,

1178 ac_cv___attribute__=no)])

1179 if test "$ac_cv___attribute__" = "yes"; then

1180 AC_DEFINE(HAVE___ATTRIBUTE__, 1, [define if your compiler has __attribute__])

1181 else

1182 #

1183 # We can't use __attribute__, so we can't use __attribute__((unused)),

1184 # so we define _U_ to an empty string.

1185 #

1186 V_DEFS="$V_DEFS -D_U_=\"\""

1187 fi

1188 AC_MSG_RESULT($ac_cv___attribute__)

1189 ])

1190

1191

1192 dnl

1193 dnl Test whether __attribute__((unused)) can be used without warnings

1194 dnl

1195

1196 AC_DEFUN(AC_C___ATTRIBUTE___UNUSED, [

1197 AC_MSG_CHECKING([whether __attribute__((unused)) can be used without warnings])

1198 AC_CACHE_VAL(ac_cv___attribute___unused, [

1199 save_CFLAGS="$CFLAGS"

1200 CFLAGS="$CFLAGS $ac_lbl_cc_force_warning_errors"

1201 AC_COMPILE_IFELSE([

1202 AC_LANG_SOURCE([[

1203 #include <stdlib.h>

1204 #include <stdio.h>

1205

1206 int

1207 main(int argc __attribute((unused)), char **argv __attribute((unused)))

1208 {

1209 printf("Hello, world!\n");

1210 return 0;

1211 }

1212 ]])],

1213 ac_cv___attribute___unused=yes,

1214 ac_cv___attribute___unused=no)])

1215 CFLAGS="$save_CFLAGS"

1216 if test "$ac_cv___attribute___unused" = "yes"; then

1217 V_DEFS="$V_DEFS -D_U_=\"__attribute__((unused))\""

1218 else

1219 V_DEFS="$V_DEFS -D_U_=\"\""

1220 fi

1221 AC_MSG_RESULT($ac_cv___attribute___unused)

1222 ])

1223

1224 dnl

1225 dnl Test whether __attribute__((format)) can be used without warnings

1226 dnl

1227

1228 AC_DEFUN(AC_C___ATTRIBUTE___FORMAT, [

1229 AC_MSG_CHECKING([whether __attribute__((format)) can be used without warnings])

1230 AC_CACHE_VAL(ac_cv___attribute___format, [

1231 save_CFLAGS="$CFLAGS"

1232 CFLAGS="$CFLAGS $ac_lbl_cc_force_warning_errors"

1233 AC_COMPILE_IFELSE([

1234 AC_LANG_SOURCE([[

1235 #include <stdlib.h>

1236

1237 extern int foo(const char *fmt, ...)

1238 __attribute__ ((format (printf, 1, 2)));

1239

1240 int

1241 main(int argc, char **argv)

1242 {

1243 foo("%s", "test");

1244 }

1245 ]])],

1246 ac_cv___attribute___format=yes,

1247 ac_cv___attribute___format=no)])

1248 CFLAGS="$save_CFLAGS"

1249 if test "$ac_cv___attribute___format" = "yes"; then

1250 AC_DEFINE(__ATTRIBUTE___FORMAT_OK, 1,

1251 [define if your compiler allows __attribute__((format)) without a warning])

1252 fi

1253 AC_MSG_RESULT($ac_cv___attribute___format)

1254 ])

1255

1256 dnl

1257 dnl Test whether __attribute__((format)) can be applied to function

1258 dnl pointers

1259 dnl

1260

1261 AC_DEFUN(AC_C___ATTRIBUTE___FORMAT_FUNCTION_POINTER, [

1262 AC_MSG_CHECKING([whether __attribute__((format)) can be applied to function pointers])

1263 AC_CACHE_VAL(ac_cv___attribute___format_function_pointer, [

1264 AC_COMPILE_IFELSE([

1265 AC_LANG_SOURCE([[

1266 #include <stdlib.h>

1267

1268 extern int (*foo)(const char *fmt, ...)

1269 __attribute__ ((format (printf, 1, 2)));

1270

1271 int

1272 main(int argc, char **argv)

1273 {

1274 (*foo)("%s", "test");

1275 }

1276 ]])],

1277 ac_cv___attribute___format_function_pointer=yes,

1278 ac_cv___attribute___format_function_pointer=no)])

1279 if test "$ac_cv___attribute___format_function_pointer" = "yes"; then

1280 AC_DEFINE(__ATTRIBUTE___FORMAT_OK_FOR_FUNCTION_POINTERS, 1,

1281 [define if your compiler allows __attribute__((format)) to be applied to function pointers])

1282 fi

1283 AC_MSG_RESULT($ac_cv___attribute___format_function_pointer)

1284 ])

1285

1286 AC_DEFUN(AC_C___ATTRIBUTE___NORETURN_FUNCTION_POINTER, [

1287 AC_MSG_CHECKING([whether __attribute__((noreturn)) can be applied to function pointers without warnings])

1288 AC_CACHE_VAL(ac_cv___attribute___noreturn_function_pointer, [

1289 save_CFLAGS="$CFLAGS"

1290 CFLAGS="$CFLAGS $ac_lbl_cc_force_warning_errors"

1291 AC_COMPILE_IFELSE([

1292 AC_LANG_SOURCE([[

1293 #include <stdlib.h>

1294

1295 extern int (*foo)(int i)

1296 __attribute__ ((noreturn));

1297

1298 int

1299 main(int argc, char **argv)

1300 {

1301 (*foo)(1);

1302 }

1303 ]])],

1304 ac_cv___attribute___noreturn_function_pointer=yes,

1305 ac_cv___attribute___noreturn_function_pointer=no)])

1306 CFLAGS="$save_CFLAGS"

1307 if test "$ac_cv___attribute___noreturn_function_pointer" = "yes"; then

1308 AC_DEFINE(__ATTRIBUTE___NORETURN_OK_FOR_FUNCTION_POINTERS, 1,

1309 [define if your compiler allows __attribute__((noreturn)) to be applied to function pointers])

1310 fi

1311 AC_MSG_RESULT($ac_cv___attribute___noreturn_function_pointer)

1312 ])

1313

1314 AC_DEFUN(AC_LBL_SSLEAY,

1315 [

1316 #

1317 # Find the last component of $libdir; it's not necessarily

1318 # "lib" - it might be "lib64" on, for example, x86-64

1319 # Linux systems.

1320 #

1321 # We assume the directory in which we're looking for

1322 # libcrypto has a subdirectory with that as its name.

1323 #

1324 tmplib=`echo "$libdir" | sed 's,.*/,,'`

1325

1326 #

1327 # XXX - is there a better way to check if a given library is

1328 # in a given directory than checking each of the possible

1329 # shared library suffixes?

1330 #

1331 # Are there any other suffixes we need to look for? Do we

1332 # have to worry about ".so.{version}"?

1333 #

1334 # Or should we just look for "libcrypto.*"?

1335 #

1336 if test -d "$1/$tmplib" -a \( -f "$1/$tmplib/libcrypto.a" -o \

1337 -f "$1/$tmplib/libcrypto.so" -o \

1338 -f "$1/$tmplib/libcrypto.sl" -o \

1339 -f "$1/$tmplib/libcrypto.dylib" \); then

1340 ac_cv_ssleay_path="$1"

1341 fi

1342

1343 #

1344 # Make sure we have the headers as well.

1345 #

1346 if test -d "$1/include/openssl" -a -f "$1/include/openssl/des.h"; then

1347 incdir="-I$1/include"

1348 fi

1349 ])