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

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

44 $1=""

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

46 $1="-I$srcdir"

47 fi

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

49 LBL_CFLAGS="$CFLAGS"

50 fi

51 if test -z "$CC" ; then

52 case "$host_os" in

54 bsdi*)

55 AC_CHECK_PROG(SHLICC2, shlicc2, yes, no)

56 if test $SHLICC2 = yes ; then

57 CC=shlicc2

58 export CC

59 fi

60 ;;

61 esac

62 fi

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

64 CC=cc

65 export CC

66 fi

67 ])

69 dnl

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

71 dnl If using gcc, determine the version number

72 dnl If using cc:

73 dnl require that it support ansi prototypes

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

75 dnl do that ourselves for gcc)

76 dnl add -g flags, as appropriate

77 dnl explicitly specify /usr/local/include

78 dnl

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

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

81 dnl

82 dnl usage:

83 dnl

84 dnl AC_LBL_C_INIT(copt, incls)

85 dnl

86 dnl results:

87 dnl

88 dnl $1 (copt set)

89 dnl $2 (incls set)

90 dnl CC

91 dnl LDFLAGS

92 dnl LBL_CFLAGS

93 dnl

94 AC_DEFUN(AC_LBL_C_INIT,

95 [

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

97 if test "$GCC" = yes ; then

98 #

99 # -Werror forces warnings to be errors.

100 #

101 ac_lbl_cc_force_warning_errors=-Werror

102 else

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

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

105

106 case "$host_os" in

107

108 darwin*)

109 #

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

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

112 #

113 ac_lbl_cc_force_warning_errors=-Werror

114 ;;

115

116 hpux*)

117 #

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

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

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

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

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

123 #

124 ac_lbl_cc_dont_try_gcc_dashW=yes

125 ;;

126

127 irix*)

128 #

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

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

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

132 # so, 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 # It also, apparently, defaults to "char" being

138 # unsigned, unlike most other C implementations;

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

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

141 # just force signed chars.

142 #

143 # -xansi is normally the default, but the

144 # configure script was setting it; perhaps -cckr

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

146 # that would probably be for backwards compatibility

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

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

149 # drop support for those compilers.)

150 #

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

152 # optimization; we choose -g3, which generates

153 # debugging information but doesn't turn off

154 # optimization (even if the optimization would

155 # cause inaccuracies in debugging).

156 #

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

158 ;;

159

160 osf*)

161 #

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

163 # Tru64 UNIX.

164 #

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

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

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

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

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

170 #

171 ac_lbl_cc_dont_try_gcc_dashW=yes

172 #

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

174 # optimization; we choose -g3, which generates

175 # debugging information but doesn't turn off

176 # optimization (even if the optimization would

177 # cause inaccuracies in debugging).

178 #

179 $1="$$1 -g3"

180 ;;

181

182 solaris*)

183 #

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

185 # warnings to be treated as errors.

186 #

187 ac_lbl_cc_force_warning_errors=-errwarn

188 ;;

189

190 ultrix*)

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

192 AC_CACHE_VAL(ac_cv_lbl_cc_const_proto,

193 AC_TRY_COMPILE(

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

195 [struct a { int b; };

196 void c(const struct a *)],

197 ac_cv_lbl_cc_const_proto=yes,

198 ac_cv_lbl_cc_const_proto=no))

199 AC_MSG_RESULT($ac_cv_lbl_cc_const_proto)

200 if test $ac_cv_lbl_cc_const_proto = no ; then

201 AC_DEFINE(const,[],

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

203 fi

204 ;;

205 esac

206 $1="$$1 -O"

207 fi

208 ])

209

210 dnl

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

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

213 dnl specified as the first argument

214 dnl

215 AC_DEFUN(AC_LBL_CHECK_COMPILER_OPT,

216 [

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

218 save_CFLAGS="$CFLAGS"

219 CFLAGS="$CFLAGS $2"

220 #

221 # XXX - yes, this depends on the way AC_LANG_WERROR works,

222 # but no mechanism is provided to turn AC_LANG_WERROR on

223 # *and then turn it back off*, so that we *only* do it when

224 # testing compiler options - 15 years after somebody asked

225 # for it:

226 #

227 # https://autoconf.gnu.narkive.com/gTAVmfKD/how-to-cancel-flags-set-by-ac-lang-werror

228 #

229 save_ac_c_werror_flag="$ac_c_werror_flag"

230 ac_c_werror_flag=yes

231 #

232 # We use AC_LANG_SOURCE() so that we can control the complete

233 # content of the program being compiled. We do not, for example,

234 # want the default "int main()" that AC_LANG_PROGRAM() generates,

235 # as it will generate a warning with -Wold-style-definition, meaning

236 # that we would treat it as not working, as the test will fail if

237 # *any* error output, including a warning due to the flag we're

238 # testing, is generated; see

239 #

240 # https://www.postgresql.org/message-id/2192993.1591682589%40sss.pgh.pa.us

241 # https://www.postgresql.org/message-id/2192993.1591682589%40sss.pgh.pa.us

242 #

243 # This may, as per those two messages, be fixed in autoconf 2.70,

244 # but we only require 2.64 or newer for now.

245 #

246 AC_COMPILE_IFELSE(

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

248 [

249 AC_MSG_RESULT([yes])

250 CFLAGS="$save_CFLAGS"

251 $1="$$1 $2"

252 ],

253 [

254 AC_MSG_RESULT([no])

255 CFLAGS="$save_CFLAGS"

256 ])

257 ac_c_werror_flag="$save_ac_c_werror_flag"

258 ])

259

260 dnl

261 dnl Check whether the compiler supports an option to generate

262 dnl Makefile-style dependency lines

263 dnl

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

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

266 dnl

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

268 dnl versions of compilers might not support it.

269 dnl

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

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

272 dnl on another compiler.

273 dnl

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

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

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

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

278 dnl

279 AC_DEFUN(AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT,

280 [

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

282 if test "$GCC" = yes ; then

283 #

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

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

286 # would be -M.

287 #

288 ac_lbl_dependency_flag="-M"

289 else

290 #

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

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

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

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

295 # the Intel C compiler.)

296 #

297 case "$host_os" in

298

299 irix*|osf*|darwin*)

300 #

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

302 #

303 ac_lbl_dependency_flag="-M"

304 ;;

305

306 solaris*)

307 #

308 # Sun C uses -xM.

309 #

310 ac_lbl_dependency_flag="-xM"

311 ;;

312

313 hpux*)

314 #

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

316 # HP's newer C compilers support this with

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

318 # interpret +M as something completely

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

320 # think it works with the older compilers.

321 #

322 ac_lbl_dependency_flag="+Make"

323 ;;

324

325 *)

326 #

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

328 # generating dependencies.

329 #

330 ac_lbl_dependency_flag=""

331 ;;

332 esac

333 fi

334

335 #

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

337 # complain about it?

338 #

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

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

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

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

343 # isn't an issue.

344 #

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

346 AC_LANG_CONFTEST(

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

348 if AC_RUN_LOG([eval "$CC $ac_lbl_dependency_flag conftest.c >/dev/null 2>&1"]); then

349 AC_MSG_RESULT([yes, with $ac_lbl_dependency_flag])

350 DEPENDENCY_CFLAG="$ac_lbl_dependency_flag"

351 MKDEP='${top_srcdir}/mkdep'

352 else

353 AC_MSG_RESULT([no])

354 #

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

356 # nothing.

357 #

358 MKDEP=:

359 fi

360 rm -rf conftest*

361 else

362 AC_MSG_RESULT([no])

363 #

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

365 # nothing.

366 #

367 MKDEP=:

368 fi

369 AC_SUBST(DEPENDENCY_CFLAG)

370 AC_SUBST(MKDEP)

371 ])

372

373 #

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

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

376 #

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

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

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

380 # inline a function that returns a struct pointer.

381 #

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

383 # disable inlining.

384 #

385 AC_DEFUN(AC_LBL_C_INLINE,

386 [AC_MSG_CHECKING(for inline)

387 save_CFLAGS="$CFLAGS"

388 CFLAGS="$V_CCOPT"

389 AC_CACHE_VAL(ac_cv_lbl_inline, [

390 ac_cv_lbl_inline=""

391 ac_lbl_cc_inline=no

392 for ac_lbl_inline in inline __inline__ __inline

393 do

394 AC_TRY_COMPILE(

395 [#define inline $ac_lbl_inline

396 static inline struct iltest *foo(void);

397 struct iltest {

398 int iltest1;

399 int iltest2;

400 };

401

402 static inline struct iltest *

403 foo()

404 {

405 static struct iltest xxx;

406

407 return &xxx;

408 }],,ac_lbl_cc_inline=yes,)

409 if test "$ac_lbl_cc_inline" = yes ; then

410 break;

411 fi

412 done

413 if test "$ac_lbl_cc_inline" = yes ; then

414 ac_cv_lbl_inline=$ac_lbl_inline

415 fi])

416 CFLAGS="$save_CFLAGS"

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

418 AC_MSG_RESULT($ac_cv_lbl_inline)

419 else

420 AC_MSG_RESULT(no)

421 fi

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

423

424 dnl

425 dnl Require libpcap

426 dnl Look for libpcap in directories under ..; those are local versions.

427 dnl Look for an installed libpcap if there is no local version or if

428 dnl the user said not to look for a local version.

429 dnl

430 dnl usage:

431 dnl

432 dnl AC_LBL_LIBPCAP(pcapdep, incls)

433 dnl

434 dnl results:

435 dnl

436 dnl $1 (pcapdep set)

437 dnl $2 (incls appended)

438 dnl LIBS

439 dnl

440 AC_DEFUN(AC_LBL_LIBPCAP,

441 [AC_REQUIRE([AC_LBL_LIBRARY_NET])

442 libpcap=FAIL

443 AC_MSG_CHECKING([whether to look for a local libpcap])

444 AC_ARG_ENABLE(local-libpcap,

445 AS_HELP_STRING([--disable-local-libpcap],

446 [don't look for a local libpcap @<:@default=check for a local libpcap@:>@]),,

447 enableval=yes)

448 case "$enableval" in

449

450 no)

451 AC_MSG_RESULT(no)

452 #

453 # Don't look for a local libpcap.

454 #

455 using_local_libpcap=no

456 ;;

457

458 *)

459 AC_MSG_RESULT(yes)

460 #

461 # Look for a local pcap library.

462 #

463 AC_MSG_CHECKING(for local pcap library)

464 lastdir=FAIL

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

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

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

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

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

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

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

472 if test $lastdir = $basedir ; then

473 dnl skip alphas when an actual release is present

474 continue;

475 fi

476 lastdir=$dir

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

478 libpcap=$dir/libpcap.a

479 local_pcap_dir=$dir

480 dnl continue and select the last one that exists

481 fi

482 done

483 if test $libpcap = FAIL ; then

484 #

485 # We didn't find a local libpcap.

486 #

487 AC_MSG_RESULT(not found)

488 using_local_libpcap=no;

489 else

490 #

491 # We found a local libpcap.

492 #

493 AC_MSG_RESULT($libpcap)

494 using_local_libpcap=yes

495 fi

496 ;;

497 esac

498

499 if test $using_local_libpcap = no ; then

500 #

501 # We didn't find a local libpcap.

502 # Look for an installed pkg-config.

503 #

504 AC_PATH_TOOL(PKG_CONFIG, pkg-config)

505 if test -n "$PKG_CONFIG" ; then

506 #

507 # We have it. Are there .pc files for libpcap?

508 #

509 # --exists was introduced in pkg-config 0.4.0; that

510 # dates back to late 2000, so we won't worry about

511 # earlier releases that lack it.

512 #

513 AC_MSG_CHECKING(whether there are .pc files for libpcap)

514 if "$PKG_CONFIG" libpcap --exists ; then

515 #

516 # Yes, so we can use pkg-config to get configuration

517 # information for libpcap.

518 #

519 AC_MSG_RESULT(yes)

520 pkg_config_usable=yes

521 else

522 #

523 # No, so we can't use pkg-config to get configuration

524 # information for libpcap.

525 #

526 AC_MSG_RESULT(no)

527 pkg_config_usable=no

528 fi

529 else

530 #

531 # We don't have it, so we obviously can't use it.

532 #

533 pkg_config_usable=no

534 fi

535 if test "$pkg_config_usable" = "yes" ; then

536 #

537 # Found both - use pkg-config to get the include flags for

538 # libpcap and the flags to link with libpcap.

539 #

540 # Please read section 11.6 "Shell Substitutions"

541 # in the autoconf manual before doing anything

542 # to this that involves quoting. Especially note

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

544 # double-quoted strings inside double-quoted back-quoted

545 # expressions (pfew!)."

546 #

547 cflags=`"$PKG_CONFIG" libpcap --cflags`

548 $2="$cflags $$2"

549 libpcap=`"$PKG_CONFIG" libpcap --libs`

550 else

551 #

552 # No pkg-config

553 # Look for an installed pcap-config.

554 #

555 AC_PATH_TOOL(PCAP_CONFIG, pcap-config)

556 if test -n "$PCAP_CONFIG" ; then

557 #

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

559 # libpcap and the flags to link with libpcap.

560 #

561 # If this is a vendor-supplied pcap-config, which

562 # we define as being "a pcap-config in /usr/bin

563 # or /usr/ccs/bin" (the latter is for Solaris and

564 # Sun/Oracle Studio), there are some issues. Work

565 # around them.

566 #

567 if test $ "$PCAP_CONFIG" = "/usr/bin/pcap-config" $ -o \

568 $ "$PCAP_CONFIG" = "/usr/ccs/bin/pcap-config" $ ; then

569 #

570 # It's vendor-supplied.

571 #

572 case "$host_os" in

573

574 darwin*)

575 #

576 # This is macOS or another Darwin-based OS.

577 #

578 # That means that /usr/bin/pcap-config it

579 # may provide -I/usr/local/include with --cflags

580 # and -L/usr/local/lib with --libs, rather than

581 # pointing to the OS-supplied library and

582 # Xcode-supplied headers. Remember that, so we

583 # ignore those values.

584 #

585 _broken_apple_pcap_config=yes

586 ;;

587

588 solaris*)

589 #

590 # This is Solaris 2 or later, i.e. SunOS 5.x.

591 #

592 # At least on Solaris 11; there's /usr/bin/pcap-config,

593 # which reports -L/usr/lib with --libs, causing

594 # the 32-bit libraries to be found, and there's

595 # /usr/bin/{64bitarch}/pcap-config, where {64bitarch}

596 # is a name for the 64-bit version of the instruction

597 # set, which reports -L /usr/lib/{64bitarch}, causing

598 # the 64-bit libraries to be found.

599 #

600 # So if we're building 64-bit targets, we replace

601 # PCAP_CONFIG with /usr/bin/{64bitarch}; we get

602 # {64bitarch} as the output of "isainfo -n".

603 #

604 # Are we building 32-bit or 64-bit? Get the

605 # size of void *, and check that.

606 #

607 AC_CHECK_SIZEOF([void *])

608 if test ac_cv_sizeof_void_p -eq 8 ; then

609 isainfo_output=`isainfo -n`

610 if test ! -z "$isainfo_output" ; then

611 #

612 # Success - change PCAP_CONFIG.

613 #

614 PCAP_CONFIG=`echo $PCAP_CONFIG | sed "s;/bin/;/bin/$isainfo_output/;"`

615 fi

616 fi

617 ;;

618 esac

619 fi

620 #

621 # Please read section 11.6 "Shell Substitutions"

622 # in the autoconf manual before doing anything

623 # to this that involves quoting. Especially note

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

625 # double-quoted strings inside double-quoted back-quoted

626 # expressions (pfew!)."

627 #

628 cflags=`"$PCAP_CONFIG" --cflags`

629 #

630 # Work around macOS (and probably other Darwin) brokenness,

631 # by not adding /usr/local/include if it's from the broken

632 # Apple pcap-config.

633 #

634 if test "$_broken_apple_pcap_config" = "yes" ; then

635 #

636 # Strip -I/usr/local/include with sed.

637 #

638 cflags=`echo $cflags | sed 's;-I/usr/local/include;;'`

639 fi

640 $2="$cflags $$2"

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

642 #

643 # Work around macOS (and probably other Darwin) brokenness,

644 # by not adding /usr/local/lib if it's from the broken

645 # Apple pcap-config.

646 #

647 if test "$_broken_apple_pcap_config" = "yes" ; then

648 #

649 # Strip -L/usr/local/lib with sed.

650 #

651 libpcap=`echo $libpcap | sed 's;-L/usr/local/lib;;'`

652 fi

653 else

654 #

655 # Not found; look for an installed pcap.

656 #

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

658 if test $libpcap = FAIL ; then

659 AC_MSG_ERROR(see the INSTALL.md file for more info)

660 fi

661 dnl

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

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

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

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

666 dnl compatibility with other systems.

667 dnl

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

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

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

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

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

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

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

675 dnl

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

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

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

679 dnl

680 AC_MSG_CHECKING(for extraneous pcap header directories)

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

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

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

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

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

686 d="/usr/include/pcap"

687 fi

688 fi

689 if test -z "$d" ; then

690 AC_MSG_RESULT(not found)

691 else

692 $2="-I$d $$2"

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

694 fi

695 fi

696 fi

697 else

698 #

699 # We found a local libpcap. Add it to the dependencies for

700 # tcpdump.

701 #

702 $1=$libpcap

703

704 #

705 # Look for its pcap-config script.

706 #

707 AC_PATH_PROG(PCAP_CONFIG, pcap-config,, $local_pcap_dir)

708

709 if test -n "$PCAP_CONFIG"; then

710 #

711 # We don't want its --cflags or --libs output, because

712 # those presume it's installed. For the C compiler flags,

713 # we add the source directory for the local libpcap, so

714 # we pick up its header files.

715 #

716 # We do, however, want its additional libraries, as required

717 # when linking statically, because it makes calls to

718 # routines in those libraries, so we'll need to link with

719 # them, because we'll be linking statically with it.

720 #

721 # If it supports --static-pcap-only. use that, as we will be

722 # linking with a static libpcap but won't be linking

723 # statically with any of the libraries on which it depends;

724 # those libraries might not even have static versions

725 # installed.

726 #

727 # That means we need to find out the libraries on which

728 # libpcap directly depends, so we can link with them, but we

729 # don't need to link with the libraries on which those

730 # libraries depend as, on all UN*Xes with which I'm

731 # familiar, the libraries on which a shared library depends

732 # are stored in the library and are automatically loaded by

733 # the run-time linker, without the executable having to be

734 # linked with those libraries. (This allows a library to be

735 # changed to depend on more libraries without breaking that

736 # library's ABI.)

737 #

738 # The only way to test for that support is to see if the

739 # script contains the string "static-pcap-only"; we can't

740 # try using that flag and checking for errors, as the

741 # versions of the script that didn't have that flag wouldn't

742 # report or return an error for an unsupported command-line

743 # flag. Those older versions provided, with --static, only

744 # the libraries on which libpcap depends, not the

745 # dependencies of those libraries; the versions with

746 # --static-pcap-only provide all the dependencies with

747 # --static, for the benefit of programs that are completely

748 # statically linked, and provide only the direct

749 # dependencies with --static-pcap-only.

750 #

751 if grep -s -q "static-pcap-only" "$PCAP_CONFIG"

752 then

753 static_opt="--static-pcap-only"

754 else

755 static_opt="--static"

756 fi

757 $2="-I$local_pcap_dir $$2"

758 additional_libs=`"$PCAP_CONFIG" $static_opt --additional-libs`

759 libpcap="$libpcap $additional_libs"

760 else

761 #

762 # It doesn't have a pcap-config script.

763 # Make sure it has a pcap.h file.

764 #

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

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

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

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

769 pcapH=FAIL

770 if test -r $local_pcap_dir/pcap.h; then

771 pcapH=$local_pcap_dir

772 else

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

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

775 pcapH=$dir

776 fi

777 done

778 fi

779

780 if test $pcapH = FAIL ; then

781 AC_MSG_ERROR(cannot find pcap.h: see the INSTALL.md file)

782 fi

783

784 #

785 # Force the compiler to look for header files in the

786 # directory containing pcap.h.

787 #

788 $2="-I$pcapH $$2"

789 fi

790 fi

791

792 if test -z "$PKG_CONFIG" -a -z "$PCAP_CONFIG"; then

793 #

794 # We don't have pkg-config or pcap-config; find out any additional

795 # link flags we need. (If we have pkg-config or pcap-config, we

796 # assume it tells us what we need.)

797 #

798 case "$host_os" in

799

800 aix*)

801 #

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

803 # present, as we use the STREAMS routines.

804 #

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

806 #

807 pseexe="/lib/pse.exp"

808 AC_MSG_CHECKING(for $pseexe)

809 if test -f $pseexe ; then

810 AC_MSG_RESULT(yes)

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

812 fi

813

814 #

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

816 # we use them to load the BPF module.

817 #

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

819 #

820 LIBS="$LIBS -lodm -lcfg"

821 ;;

822

823 solaris*)

824 # libdlpi is needed for Solaris 11 and later.

825 AC_CHECK_LIB(dlpi, dlpi_walk, LIBS="$LIBS -ldlpi" LDFLAGS="-L/lib $LDFLAGS", ,-L/lib)

826 ;;

827 esac

828 fi

829

830 LIBS="$libpcap $LIBS"

831

832 dnl

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

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

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

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

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

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

839 dnl

840 AC_CHECK_FUNC(pcap_loop,,

841 [

842 AC_MSG_ERROR(

843 [This is a bug, please follow the guidelines in CONTRIBUTING.md and include the

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

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

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

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

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

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

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

851 reproduce this problem ourselves.])

852 ])

853 ])

854

855 dnl

856 dnl If the file .devel exists:

857 dnl Add some warning flags if the compiler supports them

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

859 dnl

860 dnl usage:

861 dnl

862 dnl AC_LBL_DEVEL(copt)

863 dnl

864 dnl results:

865 dnl

866 dnl $1 (copt appended)

867 dnl HAVE_OS_PROTO_H (defined)

868 dnl os-proto.h (symlinked)

869 dnl

870 AC_DEFUN(AC_LBL_DEVEL,

871 [rm -f os-proto.h

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

873 $1="$$1 ${LBL_CFLAGS}"

874 fi

875 if test -f .devel ; then

876 #

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

878 #

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

880 AC_LBL_CHECK_COMPILER_OPT($1, -W)

881 AC_LBL_CHECK_COMPILER_OPT($1, -Wall)

882 AC_LBL_CHECK_COMPILER_OPT($1, -Wassign-enum)

883 AC_LBL_CHECK_COMPILER_OPT($1, -Wcast-qual)

884 AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-prototypes)

885 AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-variable-declarations)

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

887 AC_LBL_CHECK_COMPILER_OPT($1, -Wpedantic)

888 AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-arith)

889 AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-sign)

890 AC_LBL_CHECK_COMPILER_OPT($1, -Wshadow)

891 AC_LBL_CHECK_COMPILER_OPT($1, -Wsign-compare)

892 AC_LBL_CHECK_COMPILER_OPT($1, -Wstrict-prototypes)

893 AC_LBL_CHECK_COMPILER_OPT($1, -Wunreachable-code-return)

894 AC_LBL_CHECK_COMPILER_OPT($1, -Wused-but-marked-unused)

895 AC_LBL_CHECK_COMPILER_OPT($1, -Wwrite-strings)

896 fi

897 AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT()

898 #

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

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

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

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

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

904 # depend on .devel?

905 #

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

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

908 if test -f $name ; then

909 ln -s $name os-proto.h

910 AC_DEFINE(HAVE_OS_PROTO_H, 1,

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

912 else

913 AC_MSG_WARN(can't find $name)

914 fi

915 fi])

916

917 dnl

918 dnl Improved version of AC_CHECK_LIB

919 dnl

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

921 dnl

922 dnl usage:

923 dnl

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

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

926 dnl

927 dnl results:

928 dnl

929 dnl LIBS

930 dnl

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

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

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

934 dnl useful in the future.

935 dnl

936

937 define(AC_LBL_CHECK_LIB,

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

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

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

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

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

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

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

945 AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var,

946 [ac_save_LIBS="$LIBS"

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

948 AC_TRY_LINK(dnl

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

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

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

952 extern "C"

953 #endif

954 ])dnl

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

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

957 char $2();

958 ]),

959 [$2()],

960 eval "ac_cv_lbl_lib_$ac_lib_var=yes",

961 eval "ac_cv_lbl_lib_$ac_lib_var=no")

962 LIBS="$ac_save_LIBS"

963 ])dnl

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

965 AC_MSG_RESULT(yes)

966 ifelse([$3], ,

967 [changequote(, )dnl

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

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

970 changequote([, ])dnl

971 AC_DEFINE_UNQUOTED($ac_tr_lib)

972 LIBS="-l$1 $LIBS"

973 ], [$3])

974 else

975 AC_MSG_RESULT(no)

976 ifelse([$4], , , [$4

977 ])dnl

978 fi

979 ])

980

981 dnl

982 dnl AC_LBL_LIBRARY_NET

983 dnl

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

985 dnl gethostbyaddr() -ish functions. Under Solaris, those applications

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

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

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

989 dnl gethostbyaddr() under IRIX 5.2, and snoop sockets under most

990 dnl versions of IRIX).

991 dnl

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

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

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

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

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

997 dnl

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

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

1000

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

1002 dnl separate tests, one for the resolver libraries, and one for the

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

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

1005 dnl them independently potentially results in unfortunate ordering

1006 dnl dependencies -- as such, such component macros would have to

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

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

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

1010 dnl complexity has not been implemented.

1011 dnl

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

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

1014 dnl libnsl.a).

1015 dnl

1016 AC_DEFUN(AC_LBL_LIBRARY_NET, [

1017 # Most operating systems have gethostbyaddr() in the default searched

1018 # libraries (i.e. libc):

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

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

1021 AC_SEARCH_LIBS(gethostbyaddr, network nsl socket resolv)

1022 # Unfortunately libsocket sometimes depends on libnsl and

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

1024 if test "$ac_cv_search_gethostbyaddr" = "no"

1025 then

1026 AC_CHECK_LIB(socket, gethostbyaddr,

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

1028 fi

1029 AC_SEARCH_LIBS(socket, socket, ,

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

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

1032 AC_SEARCH_LIBS(putmsg, str)

1033 ])