The Tcpdump Group git mirrors - tcpdump/blob - aclocal.m4

   1 dnl @(#) $Header: /tcpdump/master/tcpdump/aclocal.m4,v 1.116 2008-09-25 21:45:50 guy Exp $ (LBL)
   2 dnl
   3 dnl Copyright (c) 1995, 1996, 1997, 1998
   4 dnl     The Regents of the University of California.  All rights reserved.
   5 dnl
   6 dnl Redistribution and use in source and binary forms, with or without
   7 dnl modification, are permitted provided that: (1) source code distributions
   8 dnl retain the above copyright notice and this paragraph in its entirety, (2)
   9 dnl distributions including binary code include the above copyright notice and
  10 dnl this paragraph in its entirety in the documentation or other materials
  11 dnl provided with the distribution, and (3) all advertising materials mentioning
  12 dnl features or use of this software display the following acknowledgement:
  13 dnl ``This product includes software developed by the University of California,
  14 dnl Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  15 dnl the University nor the names of its contributors may be used to endorse
  16 dnl or promote products derived from this software without specific prior
  17 dnl written permission.
  18 dnl THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  19 dnl WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  20 dnl MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21 dnl
  22 dnl LBL autoconf macros
  23 dnl
  24
  25 dnl
  26 dnl Determine which compiler we're using (cc or gcc)
  27 dnl If using gcc, determine the version number
  28 dnl If using cc, require that it support ansi prototypes
  29 dnl If using gcc, use -O2 (otherwise use -O)
  30 dnl If using cc, explicitly specify /usr/local/include
  31 dnl
  32 dnl usage:
  33 dnl
  34 dnl     AC_LBL_C_INIT(copt, incls)
  35 dnl
  36 dnl results:
  37 dnl
  38 dnl     $1 (copt set)
  39 dnl     $2 (incls set)
  40 dnl     CC
  41 dnl     LDFLAGS
  42 dnl     ac_cv_lbl_gcc_vers
  43 dnl     LBL_CFLAGS
  44 dnl
  45 AC_DEFUN(AC_LBL_C_INIT,
  46     [AC_PREREQ(2.12)
  47     AC_BEFORE([$0], [AC_PROG_CC])
  48     AC_BEFORE([$0], [AC_LBL_FIXINCLUDES])
  49     AC_BEFORE([$0], [AC_LBL_DEVEL])
  50     AC_ARG_WITH(gcc, [  --without-gcc           don't use gcc])
  51     $1="-O"
  52     $2=""
  53     if test "${srcdir}" != "." ; then
  54             $2="-I\$(srcdir)"
  55     fi
  56     if test "${CFLAGS+set}" = set; then
  57             LBL_CFLAGS="$CFLAGS"
  58     fi
  59     if test -z "$CC" ; then
  60             case "$host_os" in
  61
  62             bsdi*)
  63                     AC_CHECK_PROG(SHLICC2, shlicc2, yes, no)
  64                     if test $SHLICC2 = yes ; then
  65                             CC=shlicc2
  66                             export CC
  67                     fi
  68                     ;;
  69             esac
  70     fi
  71     if test -z "$CC" -a "$with_gcc" = no ; then
  72             CC=cc
  73             export CC
  74     fi
  75     AC_PROG_CC
  76     if test "$GCC" = yes ; then
  77             if test "$SHLICC2" = yes ; then
  78                     ac_cv_lbl_gcc_vers=2
  79                     $1="-O2"
  80             else
  81                     AC_MSG_CHECKING(gcc version)
  82                     AC_CACHE_VAL(ac_cv_lbl_gcc_vers,
  83                         ac_cv_lbl_gcc_vers=`$CC -v 2>&1 | \
  84                             sed -e '/^gcc version /!d' \
  85                                 -e 's/^gcc version //' \
  86                                 -e 's/ .*//' -e 's/^[[[^0-9]]]*//' \
  87                                 -e 's/\..*//'`)
  88                     AC_MSG_RESULT($ac_cv_lbl_gcc_vers)
  89                     if test $ac_cv_lbl_gcc_vers -gt 1 ; then
  90                             $1="-O2"
  91                     fi
  92             fi
  93     else
  94             AC_MSG_CHECKING(that $CC handles ansi prototypes)
  95             AC_CACHE_VAL(ac_cv_lbl_cc_ansi_prototypes,
  96                 AC_TRY_COMPILE(
  97                     [#include <sys/types.h>],
  98                     [int frob(int, char *)],
  99                     ac_cv_lbl_cc_ansi_prototypes=yes,
 100                     ac_cv_lbl_cc_ansi_prototypes=no))
 101             AC_MSG_RESULT($ac_cv_lbl_cc_ansi_prototypes)
 102             if test $ac_cv_lbl_cc_ansi_prototypes = no ; then
 103                     case "$host_os" in
 104
 105                     hpux*)
 106                             AC_MSG_CHECKING(for HP-UX ansi compiler ($CC -Aa -D_HPUX_SOURCE))
 107                             savedcflags="$CFLAGS"
 108                             CFLAGS="-Aa -D_HPUX_SOURCE $CFLAGS"
 109                             AC_CACHE_VAL(ac_cv_lbl_cc_hpux_cc_aa,
 110                                 AC_TRY_COMPILE(
 111                                     [#include <sys/types.h>],
 112                                     [int frob(int, char *)],
 113                                     ac_cv_lbl_cc_hpux_cc_aa=yes,
 114                                     ac_cv_lbl_cc_hpux_cc_aa=no))
 115                             AC_MSG_RESULT($ac_cv_lbl_cc_hpux_cc_aa)
 116                             if test $ac_cv_lbl_cc_hpux_cc_aa = no ; then
 117                                     AC_MSG_ERROR(see the INSTALL doc for more info)
 118                             fi
 119                             CFLAGS="$savedcflags"
 120                             $1="-Aa $$1"
 121                             AC_DEFINE(_HPUX_SOURCE,1,[needed on HP-UX])
 122                             ;;
 123
 124                     osf*)
 125                             AC_MSG_CHECKING(for ansi mode in DEC compiler ($CC -std1))
 126                             savedcflags="$CFLAGS"
 127                             CFLAGS="-std1"
 128                             AC_CACHE_VAL(ac_cv_lbl_cc_osf1_cc_std1,
 129                                 AC_TRY_COMPILE(
 130                                     [#include <sys/types.h>],
 131                                     [int frob(int, char *)],
 132                                     ac_cv_lbl_cc_osf1_cc_std1=yes,
 133                                     ac_cv_lbl_cc_osf1_cc_std1=no))
 134                             AC_MSG_RESULT($ac_cv_lbl_cc_osf1_cc_std1)
 135                             if test $ac_cv_lbl_cc_osf1_cc_std1 = no ; then
 136                                     AC_MSG_ERROR(see the INSTALL doc for more info)
 137                             fi
 138                             CFLAGS="$savedcflags"
 139                             $1="-std1 $$1"
 140                             ;;
 141
 142                     *)
 143                             AC_MSG_ERROR(see the INSTALL doc for more info)
 144                             ;;
 145                     esac
 146             fi
 147             $2="$$2 -I/usr/local/include"
 148             LDFLAGS="$LDFLAGS -L/usr/local/lib"
 149
 150             case "$host_os" in
 151
 152             irix*)
 153                     $1="$$1 -xansi -signed -O"
 154                     ;;
 155
 156             osf*)
 157                     #
 158                     # Presumed to be DEC OSF/1, Digital UNIX, or
 159                     # Tru64 UNIX.
 160                     #
 161                     $1="$$1 -O"
 162                     ;;
 163
 164             ultrix*)
 165                     AC_MSG_CHECKING(that Ultrix $CC hacks const in prototypes)
 166                     AC_CACHE_VAL(ac_cv_lbl_cc_const_proto,
 167                         AC_TRY_COMPILE(
 168                             [#include <sys/types.h>],
 169                             [struct a { int b; };
 170                             void c(const struct a *)],
 171                             ac_cv_lbl_cc_const_proto=yes,
 172                             ac_cv_lbl_cc_const_proto=no))
 173                     AC_MSG_RESULT($ac_cv_lbl_cc_const_proto)
 174                     if test $ac_cv_lbl_cc_const_proto = no ; then
 175                             AC_DEFINE(const,[],
 176                                 [to handle Ultrix compilers that don't support const in prototypes])
 177                     fi
 178                     ;;
 179             esac
 180     fi
 181 ])
 182
 183
 184 #
 185 # Try compiling a sample of the type of code that appears in
 186 # gencode.c with "inline", "__inline__", and "__inline".
 187 #
 188 # Autoconf's AC_C_INLINE, at least in autoconf 2.13, isn't good enough,
 189 # as it just tests whether a function returning "int" can be inlined;
 190 # at least some versions of HP's C compiler can inline that, but can't
 191 # inline a function that returns a struct pointer.
 192 #
 193 # Make sure we use the V_CCOPT flags, because some of those might
 194 # disable inlining.
 195 #
 196 AC_DEFUN(AC_LBL_C_INLINE,
 197     [AC_MSG_CHECKING(for inline)
 198     save_CFLAGS="$CFLAGS"
 199     CFLAGS="$V_CCOPT"
 200     AC_CACHE_VAL(ac_cv_lbl_inline, [
 201         ac_cv_lbl_inline=""
 202         ac_lbl_cc_inline=no
 203         for ac_lbl_inline in inline __inline__ __inline
 204         do
 205             AC_TRY_COMPILE(
 206                 [#define inline $ac_lbl_inline
 207                 static inline struct iltest *foo(void);
 208                 struct iltest {
 209                     int iltest1;
 210                     int iltest2;
 211                 };
 212
 213                 static inline struct iltest *
 214                 foo()
 215                 {
 216                     static struct iltest xxx;
 217
 218                     return &xxx;
 219                 }],,ac_lbl_cc_inline=yes,)
 220             if test "$ac_lbl_cc_inline" = yes ; then
 221                 break;
 222             fi
 223         done
 224         if test "$ac_lbl_cc_inline" = yes ; then
 225             ac_cv_lbl_inline=$ac_lbl_inline
 226         fi])
 227     CFLAGS="$save_CFLAGS"
 228     if test ! -z "$ac_cv_lbl_inline" ; then
 229         AC_MSG_RESULT($ac_cv_lbl_inline)
 230     else
 231         AC_MSG_RESULT(no)
 232     fi
 233     AC_DEFINE_UNQUOTED(inline, $ac_cv_lbl_inline, [Define as token for inline if inlining supported])])
 234
 235 dnl
 236 dnl Use pfopen.c if available and pfopen() not in standard libraries
 237 dnl Require libpcap
 238 dnl Look for libpcap in ..
 239 dnl Use the installed libpcap if there is no local version
 240 dnl
 241 dnl usage:
 242 dnl
 243 dnl     AC_LBL_LIBPCAP(pcapdep, incls)
 244 dnl
 245 dnl results:
 246 dnl
 247 dnl     $1 (pcapdep set)
 248 dnl     $2 (incls appended)
 249 dnl     LIBS
 250 dnl     LBL_LIBS
 251 dnl
 252 AC_DEFUN(AC_LBL_LIBPCAP,
 253     [AC_REQUIRE([AC_LBL_LIBRARY_NET])
 254     dnl
 255     dnl save a copy before locating libpcap.a
 256     dnl
 257     LBL_LIBS="$LIBS"
 258     pfopen=/usr/examples/packetfilter/pfopen.c
 259     if test -f $pfopen ; then
 260             AC_CHECK_FUNCS(pfopen)
 261             if test $ac_cv_func_pfopen = "no" ; then
 262                     AC_MSG_RESULT(Using $pfopen)
 263                     LIBS="$LIBS $pfopen"
 264             fi
 265     fi
 266     AC_MSG_CHECKING(for local pcap library)
 267     libpcap=FAIL
 268     lastdir=FAIL
 269     places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
 270         egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
 271     for dir in $places $srcdir/../libpcap $srcdir/libpcap ; do
 272             basedir=`echo $dir | sed -e 's/[[ab]][[0-9]]*$//'`
 273             if test $lastdir = $basedir ; then
 274                     dnl skip alphas when an actual release is present
 275                     continue;
 276             fi
 277             lastdir=$dir
 278             if test -r $dir/libpcap.a ; then
 279                     libpcap=$dir/libpcap.a
 280                     d=$dir
 281                     dnl continue and select the last one that exists
 282             fi
 283     done
 284     if test $libpcap = FAIL ; then
 285             AC_MSG_RESULT(not found)
 286
 287             #
 288             # Look for pcap-config.
 289             #
 290             AC_PATH_PROG(PCAP_CONFIG, pcap-config)
 291             if test -n "$PCAP_CONFIG" ; then
 292                 #
 293                 # Found - use it to get the include flags for
 294                 # libpcap and the flags to link with libpcap.
 295                 #
 296                 $2="`\"$PCAP_CONFIG\" --cflags` $$2"
 297                 libpcap="`\"$PCAP_CONFIG\" --libs`"
 298             else
 299                 #
 300                 # Not found; look for pcap.
 301                 #
 302                 AC_CHECK_LIB(pcap, main, libpcap="-lpcap")
 303                 if test $libpcap = FAIL ; then
 304                     AC_MSG_ERROR(see the INSTALL doc for more info)
 305                 fi
 306                 dnl
 307                 dnl Some versions of Red Hat Linux put "pcap.h" in
 308                 dnl "/usr/include/pcap"; had the LBL folks done so,
 309                 dnl that would have been a good idea, but for
 310                 dnl the Red Hat folks to do so just breaks source
 311                 dnl compatibility with other systems.
 312                 dnl
 313                 dnl We work around this by assuming that, as we didn't
 314                 dnl find a local libpcap, libpcap is in /usr/lib or
 315                 dnl /usr/local/lib and that the corresponding header
 316                 dnl file is under one of those directories; if we don't
 317                 dnl find it in either of those directories, we check to
 318                 dnl see if it's in a "pcap" subdirectory of them and,
 319                 dnl if so, add that subdirectory to the "-I" list.
 320                 dnl
 321                 dnl (We now also put pcap.h in /usr/include/pcap, but we
 322                 dnl leave behind a /usr/include/pcap.h that includes it,
 323                 dnl so you can still just include <pcap.h>.)
 324                 dnl
 325                 AC_MSG_CHECKING(for extraneous pcap header directories)
 326                 if test \( ! -r /usr/local/include/pcap.h \) -a \
 327                         \( ! -r /usr/include/pcap.h \); then
 328                     if test -r /usr/local/include/pcap/pcap.h; then
 329                         d="/usr/local/include/pcap"
 330                     elif test -r /usr/include/pcap/pcap.h; then
 331                         d="/usr/include/pcap"
 332                     fi
 333                 fi
 334                 if test -z "$d" ; then
 335                     AC_MSG_RESULT(not found)
 336                 else
 337                     $2="-I$d $$2"
 338                     AC_MSG_RESULT(found -- -I$d added)
 339                 fi
 340             fi
 341     else
 342             $1=$libpcap
 343             places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
 344                         egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
 345             if test -r $d/pcap.h; then
 346                     $2="-I$d $$2"
 347             elif test -r $places/pcap.h; then
 348                     $2="-I$places $$2"
 349             else
 350                     AC_MSG_ERROR(cannot find pcap.h, see INSTALL)
 351             fi
 352             AC_MSG_RESULT($libpcap)
 353             AC_PATH_PROG(PCAP_CONFIG, pcap-config,, $d)
 354             if test -n "$PCAP_CONFIG"; then
 355                 #
 356                 # The libpcap directory has a pcap-config script.
 357                 # Use it to get any additioal libraries needed
 358                 # to link with the libpcap archive library in
 359                 # that directory
 360                 #
 361                 libpcap="$libpcap `\"$PCAP_CONFIG\" --additional-libs --static`"
 362             fi
 363     fi
 364     LIBS="$libpcap $LIBS"
 365     if ! test -n "$PCAP_CONFIG" ; then
 366         #
 367         # We don't have pcap-config; find out any additional link flags
 368         # we need.  (If we have pcap-config, we assume it tells us what
 369         # we need.)
 370         #
 371         case "$host_os" in
 372
 373         aix*)
 374             #
 375             # If libpcap is DLPI-based, we have to use /lib/pse.exp if
 376             # present, as we use the STREAMS routines.
 377             #
 378             # (XXX - true only if we're linking with a static libpcap?)
 379             #
 380             pseexe="/lib/pse.exp"
 381             AC_MSG_CHECKING(for $pseexe)
 382             if test -f $pseexe ; then
 383                     AC_MSG_RESULT(yes)
 384                     LIBS="$LIBS -I:$pseexe"
 385             fi
 386
 387             #
 388             # If libpcap is BPF-based, we need "-lodm" and "-lcfg", as
 389             # we use them to load the BPF module.
 390             #
 391             # (XXX - true only if we're linking with a static libpcap?)
 392             #
 393             LIBS="$LIBS -lodm -lcfg"
 394             ;;
 395         esac
 396     fi
 397
 398     dnl
 399     dnl Check for "pcap_list_datalinks()", "pcap_set_datalink()",
 400     dnl and "pcap_datalink_name_to_val()", and use substitute versions
 401     dnl if they're not present.
 402     dnl
 403     AC_CHECK_FUNC(pcap_list_datalinks,
 404         AC_DEFINE(HAVE_PCAP_LIST_DATALINKS),
 405         [
 406             AC_LIBOBJ(datalinks)
 407         ])
 408     AC_CHECK_FUNC(pcap_set_datalink,
 409         AC_DEFINE(HAVE_PCAP_SET_DATALINK))
 410     AC_CHECK_FUNC(pcap_datalink_name_to_val,
 411         [
 412             AC_DEFINE(HAVE_PCAP_DATALINK_NAME_TO_VAL)
 413             AC_CHECK_FUNC(pcap_datalink_val_to_description,
 414                 AC_DEFINE(HAVE_PCAP_DATALINK_VAL_TO_DESCRIPTION),
 415                 [
 416                     AC_LIBOBJ(dlnames)
 417                 ])
 418         ],
 419         [
 420             AC_LIBOBJ(dlnames)
 421         ])
 422
 423     dnl
 424     dnl Check for "pcap_breakloop()"; you can't substitute for it if
 425     dnl it's absent (it has hooks into the live capture routines),
 426     dnl so just define the HAVE_ value if it's there.
 427     dnl
 428     AC_CHECK_FUNCS(pcap_breakloop)
 429
 430     dnl
 431     dnl Check for "pcap_dump_ftell()" and use a substitute version
 432     dnl if it's not present.
 433     AC_CHECK_FUNC(pcap_dump_ftell,
 434         AC_DEFINE(HAVE_PCAP_DUMP_FTELL),
 435         [
 436             AC_LIBOBJ(pcap_dump_ftell)
 437         ])
 438 ])
 439
 440 dnl
 441 dnl Define RETSIGTYPE and RETSIGVAL
 442 dnl
 443 dnl usage:
 444 dnl
 445 dnl     AC_LBL_TYPE_SIGNAL
 446 dnl
 447 dnl results:
 448 dnl
 449 dnl     RETSIGTYPE (defined)
 450 dnl     RETSIGVAL (defined)
 451 dnl
 452 AC_DEFUN(AC_LBL_TYPE_SIGNAL,
 453     [AC_BEFORE([$0], [AC_LBL_LIBPCAP])
 454     AC_TYPE_SIGNAL
 455     if test "$ac_cv_type_signal" = void ; then
 456             AC_DEFINE(RETSIGVAL,[],[return value of signal handlers])
 457     else
 458             AC_DEFINE(RETSIGVAL,(0),[return value of signal handlers])
 459     fi
 460     case "$host_os" in
 461
 462     irix*)
 463             AC_DEFINE(_BSD_SIGNALS,1,[get BSD semantics on Irix])
 464             ;;
 465
 466     *)
 467             dnl prefer sigaction() to sigset()
 468             AC_CHECK_FUNCS(sigaction)
 469             if test $ac_cv_func_sigaction = no ; then
 470                     AC_CHECK_FUNCS(sigset)
 471             fi
 472             ;;
 473     esac])
 474
 475 dnl
 476 dnl If using gcc, make sure we have ANSI ioctl definitions
 477 dnl
 478 dnl usage:
 479 dnl
 480 dnl     AC_LBL_FIXINCLUDES
 481 dnl
 482 AC_DEFUN(AC_LBL_FIXINCLUDES,
 483     [if test "$GCC" = yes ; then
 484             AC_MSG_CHECKING(for ANSI ioctl definitions)
 485             AC_CACHE_VAL(ac_cv_lbl_gcc_fixincludes,
 486                 AC_TRY_COMPILE(
 487                     [/*
 488                      * This generates a "duplicate case value" when fixincludes
 489                      * has not be run.
 490                      */
 491 #               include <sys/types.h>
 492 #               include <sys/time.h>
 493 #               include <sys/ioctl.h>
 494 #               ifdef HAVE_SYS_IOCCOM_H
 495 #               include <sys/ioccom.h>
 496 #               endif],
 497                     [switch (0) {
 498                     case _IO('A', 1):;
 499                     case _IO('B', 1):;
 500                     }],
 501                     ac_cv_lbl_gcc_fixincludes=yes,
 502                     ac_cv_lbl_gcc_fixincludes=no))
 503             AC_MSG_RESULT($ac_cv_lbl_gcc_fixincludes)
 504             if test $ac_cv_lbl_gcc_fixincludes = no ; then
 505                     # Don't cache failure
 506                     unset ac_cv_lbl_gcc_fixincludes
 507                     AC_MSG_ERROR(see the INSTALL for more info)
 508             fi
 509     fi])
 510
 511 dnl
 512 dnl Checks to see if union wait is used with WEXITSTATUS()
 513 dnl
 514 dnl usage:
 515 dnl
 516 dnl     AC_LBL_UNION_WAIT
 517 dnl
 518 dnl results:
 519 dnl
 520 dnl     DECLWAITSTATUS (defined)
 521 dnl
 522 AC_DEFUN(AC_LBL_UNION_WAIT,
 523     [AC_MSG_CHECKING(if union wait is used)
 524     AC_CACHE_VAL(ac_cv_lbl_union_wait,
 525         AC_TRY_COMPILE([
 526 #       include <sys/types.h>
 527 #       include <sys/wait.h>],
 528             [int status;
 529             u_int i = WEXITSTATUS(status);
 530             u_int j = waitpid(0, &status, 0);],
 531             ac_cv_lbl_union_wait=no,
 532             ac_cv_lbl_union_wait=yes))
 533     AC_MSG_RESULT($ac_cv_lbl_union_wait)
 534     if test $ac_cv_lbl_union_wait = yes ; then
 535             AC_DEFINE(DECLWAITSTATUS,union wait,[type for wait])
 536     else
 537             AC_DEFINE(DECLWAITSTATUS,int,[type for wait])
 538     fi])
 539
 540 dnl
 541 dnl Checks to see if the sockaddr struct has the 4.4 BSD sa_len member
 542 dnl
 543 dnl usage:
 544 dnl
 545 dnl     AC_LBL_SOCKADDR_SA_LEN
 546 dnl
 547 dnl results:
 548 dnl
 549 dnl     HAVE_SOCKADDR_SA_LEN (defined)
 550 dnl
 551 AC_DEFUN(AC_LBL_SOCKADDR_SA_LEN,
 552     [AC_MSG_CHECKING(if sockaddr struct has the sa_len member)
 553     AC_CACHE_VAL(ac_cv_lbl_sockaddr_has_sa_len,
 554         AC_TRY_COMPILE([
 555 #       include <sys/types.h>
 556 #       include <sys/socket.h>],
 557         [u_int i = sizeof(((struct sockaddr *)0)->sa_len)],
 558         ac_cv_lbl_sockaddr_has_sa_len=yes,
 559         ac_cv_lbl_sockaddr_has_sa_len=no))
 560     AC_MSG_RESULT($ac_cv_lbl_sockaddr_has_sa_len)
 561     if test $ac_cv_lbl_sockaddr_has_sa_len = yes ; then
 562             AC_DEFINE(HAVE_SOCKADDR_SA_LEN,1,[if struct sockaddr has the sa_len member])
 563     fi])
 564
 565 dnl
 566 dnl Checks to see if -R is used
 567 dnl
 568 dnl usage:
 569 dnl
 570 dnl     AC_LBL_HAVE_RUN_PATH
 571 dnl
 572 dnl results:
 573 dnl
 574 dnl     ac_cv_lbl_have_run_path (yes or no)
 575 dnl
 576 AC_DEFUN(AC_LBL_HAVE_RUN_PATH,
 577     [AC_MSG_CHECKING(for ${CC-cc} -R)
 578     AC_CACHE_VAL(ac_cv_lbl_have_run_path,
 579         [echo 'main(){}' > conftest.c
 580         ${CC-cc} -o conftest conftest.c -R/a1/b2/c3 >conftest.out 2>&1
 581         if test ! -s conftest.out ; then
 582                 ac_cv_lbl_have_run_path=yes
 583         else
 584                 ac_cv_lbl_have_run_path=no
 585         fi
 586         rm -f conftest*])
 587     AC_MSG_RESULT($ac_cv_lbl_have_run_path)
 588     ])
 589
 590 dnl
 591 dnl Check whether a given format can be used to print 64-bit integers
 592 dnl
 593 AC_DEFUN(AC_LBL_CHECK_64BIT_FORMAT,
 594   [
 595     AC_MSG_CHECKING([whether %$1x can be used to format 64-bit integers])
 596     AC_RUN_IFELSE(
 597       [
 598         AC_LANG_SOURCE(
 599           [[
 600 #           ifdef HAVE_INTTYPES_H
 601             #include <inttypes.h>
 602 #           endif
 603 #           ifdef HAVE_SYS_BITYPES_H
 604             #include <sys/bitypes.h>
 605 #           endif
 606             #include <stdio.h>
 607             #include <sys/types.h>
 608
 609             main()
 610             {
 611               u_int64_t t = 1;
 612               char strbuf[16+1];
 613               sprintf(strbuf, "%016$1x", t << 32);
 614               if (strcmp(strbuf, "0000000100000000") == 0)
 615                 exit(0);
 616               else
 617                 exit(1);
 618             }
 619           ]])
 620       ],
 621       [
 622         AC_DEFINE(PRId64, "$1d")
 623         AC_DEFINE(PRIo64, "$1o")
 624         AC_DEFINE(PRIx64, "$1x")
 625         AC_DEFINE(PRIu64, "$1u")
 626         AC_MSG_RESULT(yes)
 627       ],
 628       [
 629         AC_MSG_RESULT(no)
 630         $2
 631       ])
 632   ])
 633
 634 dnl
 635 dnl Checks to see if unaligned memory accesses fail
 636 dnl
 637 dnl usage:
 638 dnl
 639 dnl     AC_LBL_UNALIGNED_ACCESS
 640 dnl
 641 dnl results:
 642 dnl
 643 dnl     LBL_ALIGN (DEFINED)
 644 dnl
 645 AC_DEFUN(AC_LBL_UNALIGNED_ACCESS,
 646     [AC_MSG_CHECKING(if unaligned accesses fail)
 647     AC_CACHE_VAL(ac_cv_lbl_unaligned_fail,
 648         [case "$host_cpu" in
 649
 650         #
 651         # These are CPU types where:
 652         #
 653         #       the CPU faults on an unaligned access, but at least some
 654         #       OSes that support that CPU catch the fault and simulate
 655         #       the unaligned access (e.g., Alpha/{Digital,Tru64} UNIX) -
 656         #       the simulation is slow, so we don't want to use it;
 657         #
 658         #       the CPU, I infer (from the old
 659         #
 660         # XXX: should also check that they don't do weird things (like on arm)
 661         #
 662         #       comment) doesn't fault on unaligned accesses, but doesn't
 663         #       do a normal unaligned fetch, either (e.g., presumably, ARM);
 664         #
 665         #       for whatever reason, the test program doesn't work
 666         #       (this has been claimed to be the case for several of those
 667         #       CPUs - I don't know what the problem is; the problem
 668         #       was reported as "the test program dumps core" for SuperH,
 669         #       but that's what the test program is *supposed* to do -
 670         #       it dumps core before it writes anything, so the test
 671         #       for an empty output file should find an empty output
 672         #       file and conclude that unaligned accesses don't work).
 673         #
 674         # This run-time test won't work if you're cross-compiling, so
 675         # in order to support cross-compiling for a particular CPU,
 676         # we have to wire in the list of CPU types anyway, as far as
 677         # I know, so perhaps we should just have a set of CPUs on
 678         # which we know it doesn't work, a set of CPUs on which we
 679         # know it does work, and have the script just fail on other
 680         # cpu types and update it when such a failure occurs.
 681         #
 682         alpha*|arm*|bfin*|hp*|mips*|sh*|sparc*|ia64|nv1)
 683                 ac_cv_lbl_unaligned_fail=yes
 684                 ;;
 685
 686         *)
 687                 cat >conftest.c <<EOF
 688 #               include <sys/types.h>
 689 #               include <sys/wait.h>
 690 #               include <stdio.h>
 691                 unsigned char a[[5]] = { 1, 2, 3, 4, 5 };
 692                 main() {
 693                 unsigned int i;
 694                 pid_t pid;
 695                 int status;
 696                 /* avoid "core dumped" message */
 697                 pid = fork();
 698                 if (pid <  0)
 699                         exit(2);
 700                 if (pid > 0) {
 701                         /* parent */
 702                         pid = waitpid(pid, &status, 0);
 703                         if (pid < 0)
 704                                 exit(3);
 705                         exit(!WIFEXITED(status));
 706                 }
 707                 /* child */
 708                 i = *(unsigned int *)&a[[1]];
 709                 printf("%d\n", i);
 710                 exit(0);
 711                 }
 712 EOF
 713                 ${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS \
 714                     conftest.c $LIBS >/dev/null 2>&1
 715                 if test ! -x conftest ; then
 716                         dnl failed to compile for some reason
 717                         ac_cv_lbl_unaligned_fail=yes
 718                 else
 719                         ./conftest >conftest.out
 720                         if test ! -s conftest.out ; then
 721                                 ac_cv_lbl_unaligned_fail=yes
 722                         else
 723                                 ac_cv_lbl_unaligned_fail=no
 724                         fi
 725                 fi
 726                 rm -f conftest* core core.conftest
 727                 ;;
 728         esac])
 729     AC_MSG_RESULT($ac_cv_lbl_unaligned_fail)
 730     if test $ac_cv_lbl_unaligned_fail = yes ; then
 731             AC_DEFINE(LBL_ALIGN,1,[if unaligned access fails])
 732     fi])
 733
 734 dnl
 735 dnl If using gcc and the file .devel exists:
 736 dnl     Compile with -g (if supported) and -Wall
 737 dnl     If using gcc 2 or later, do extra prototype checking and some other
 738 dnl     checks
 739 dnl     If an os prototype include exists, symlink os-proto.h to it
 740 dnl
 741 dnl usage:
 742 dnl
 743 dnl     AC_LBL_DEVEL(copt)
 744 dnl
 745 dnl results:
 746 dnl
 747 dnl     $1 (copt appended)
 748 dnl     HAVE_OS_PROTO_H (defined)
 749 dnl     os-proto.h (symlinked)
 750 dnl
 751 AC_DEFUN(AC_LBL_DEVEL,
 752     [rm -f os-proto.h
 753     if test "${LBL_CFLAGS+set}" = set; then
 754             $1="$$1 ${LBL_CFLAGS}"
 755     fi
 756     if test -f .devel ; then
 757             if test "$GCC" = yes ; then
 758                     if test "${LBL_CFLAGS+set}" != set; then
 759                             if test "$ac_cv_prog_cc_g" = yes ; then
 760                                     $1="-g $$1"
 761                             fi
 762                             $1="$$1 -Wall"
 763                             if test $ac_cv_lbl_gcc_vers -gt 1 ; then
 764                                     $1="$$1 -Wmissing-prototypes -Wstrict-prototypes -Wwrite-strings -Wpointer-arith -W"
 765                             fi
 766                     fi
 767             else
 768                     case "$host_os" in
 769
 770                     irix6*)
 771                             V_CCOPT="$V_CCOPT -n32"
 772                             ;;
 773
 774                     *)
 775                             ;;
 776                     esac
 777             fi
 778             os=`echo $host_os | sed -e 's/\([[0-9]][[0-9]]*\)[[^0-9]].*$/\1/'`
 779             name="lbl/os-$os.h"
 780             if test -f $name ; then
 781                     ln -s $name os-proto.h
 782                     AC_DEFINE(HAVE_OS_PROTO_H, 1,
 783                         [if there's an os_proto.h for this platform, to use additional prototypes])
 784             else
 785                     AC_MSG_WARN(can't find $name)
 786             fi
 787     fi])
 788
 789 dnl
 790 dnl Improved version of AC_CHECK_LIB
 791 dnl
 792 dnl Thanks to John Hawkinson (jhawk@mit.edu)
 793 dnl
 794 dnl usage:
 795 dnl
 796 dnl     AC_LBL_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [,
 797 dnl         ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
 798 dnl
 799 dnl results:
 800 dnl
 801 dnl     LIBS
 802 dnl
 803 dnl XXX - "AC_LBL_LIBRARY_NET" was redone to use "AC_SEARCH_LIBS"
 804 dnl rather than "AC_LBL_CHECK_LIB", so this isn't used any more.
 805 dnl We keep it around for reference purposes in case it's ever
 806 dnl useful in the future.
 807 dnl
 808
 809 define(AC_LBL_CHECK_LIB,
 810 [AC_MSG_CHECKING([for $2 in -l$1])
 811 dnl Use a cache variable name containing the library, function
 812 dnl name, and extra libraries to link with, because the test really is
 813 dnl for library $1 defining function $2, when linked with potinal
 814 dnl library $5, not just for library $1.  Separate tests with the same
 815 dnl $1 and different $2's or $5's may have different results.
 816 ac_lib_var=`echo $1['_']$2['_']$5 | sed 'y%./+- %__p__%'`
 817 AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var,
 818 [ac_save_LIBS="$LIBS"
 819 LIBS="-l$1 $5 $LIBS"
 820 AC_TRY_LINK(dnl
 821 ifelse([$2], [main], , dnl Avoid conflicting decl of main.
 822 [/* Override any gcc2 internal prototype to avoid an error.  */
 823 ]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
 824 extern "C"
 825 #endif
 826 ])dnl
 827 [/* We use char because int might match the return type of a gcc2
 828     builtin and then its argument prototype would still apply.  */
 829 char $2();
 830 ]),
 831             [$2()],
 832             eval "ac_cv_lbl_lib_$ac_lib_var=yes",
 833             eval "ac_cv_lbl_lib_$ac_lib_var=no")
 834 LIBS="$ac_save_LIBS"
 835 ])dnl
 836 if eval "test \"`echo '$ac_cv_lbl_lib_'$ac_lib_var`\" = yes"; then
 837   AC_MSG_RESULT(yes)
 838   ifelse([$3], ,
 839 [changequote(, )dnl
 840   ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \
 841     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
 842 changequote([, ])dnl
 843   AC_DEFINE_UNQUOTED($ac_tr_lib)
 844   LIBS="-l$1 $LIBS"
 845 ], [$3])
 846 else
 847   AC_MSG_RESULT(no)
 848 ifelse([$4], , , [$4
 849 ])dnl
 850 fi
 851 ])
 852
 853 dnl
 854 dnl AC_LBL_LIBRARY_NET
 855 dnl
 856 dnl This test is for network applications that need socket() and
 857 dnl gethostbyname() -ish functions.  Under Solaris, those applications
 858 dnl need to link with "-lsocket -lnsl".  Under IRIX, they need to link
 859 dnl with "-lnsl" but should *not* link with "-lsocket" because
 860 dnl libsocket.a breaks a number of things (for instance:
 861 dnl gethostbyname() under IRIX 5.2, and snoop sockets under most
 862 dnl versions of IRIX).
 863 dnl
 864 dnl Unfortunately, many application developers are not aware of this,
 865 dnl and mistakenly write tests that cause -lsocket to be used under
 866 dnl IRIX.  It is also easy to write tests that cause -lnsl to be used
 867 dnl under operating systems where neither are necessary (or useful),
 868 dnl such as SunOS 4.1.4, which uses -lnsl for TLI.
 869 dnl
 870 dnl This test exists so that every application developer does not test
 871 dnl this in a different, and subtly broken fashion.
 872
 873 dnl It has been argued that this test should be broken up into two
 874 dnl seperate tests, one for the resolver libraries, and one for the
 875 dnl libraries necessary for using Sockets API. Unfortunately, the two
 876 dnl are carefully intertwined and allowing the autoconf user to use
 877 dnl them independantly potentially results in unfortunate ordering
 878 dnl dependancies -- as such, such component macros would have to
 879 dnl carefully use indirection and be aware if the other components were
 880 dnl executed. Since other autoconf macros do not go to this trouble,
 881 dnl and almost no applications use sockets without the resolver, this
 882 dnl complexity has not been implemented.
 883 dnl
 884 dnl The check for libresolv is in case you are attempting to link
 885 dnl statically and happen to have a libresolv.a lying around (and no
 886 dnl libnsl.a).
 887 dnl
 888 AC_DEFUN(AC_LBL_LIBRARY_NET, [
 889     # Most operating systems have gethostbyname() in the default searched
 890     # libraries (i.e. libc):
 891     # Some OSes (eg. Solaris) place it in libnsl
 892     # Some strange OSes (SINIX) have it in libsocket:
 893     AC_SEARCH_LIBS(gethostbyname, nsl socket resolv)
 894     # Unfortunately libsocket sometimes depends on libnsl and
 895     # AC_SEARCH_LIBS isn't up to the task of handling dependencies like this.
 896     if test "$ac_cv_search_gethostbyname" = "no"
 897     then
 898         AC_CHECK_LIB(socket, gethostbyname,
 899                      LIBS="-lsocket -lnsl $LIBS", , -lnsl)
 900     fi
 901     AC_SEARCH_LIBS(socket, socket, ,
 902         AC_CHECK_LIB(socket, socket, LIBS="-lsocket -lnsl $LIBS", , -lnsl))
 903     # DLPI needs putmsg under HPUX so test for -lstr while we're at it
 904     AC_SEARCH_LIBS(putmsg, str)
 905     ])
 906
 907 dnl Copyright (c) 1999 WIDE Project. All rights reserved.
 908 dnl
 909 dnl Redistribution and use in source and binary forms, with or without
 910 dnl modification, are permitted provided that the following conditions
 911 dnl are met:
 912 dnl 1. Redistributions of source code must retain the above copyright
 913 dnl    notice, this list of conditions and the following disclaimer.
 914 dnl 2. Redistributions in binary form must reproduce the above copyright
 915 dnl    notice, this list of conditions and the following disclaimer in the
 916 dnl    documentation and/or other materials provided with the distribution.
 917 dnl 3. Neither the name of the project nor the names of its contributors
 918 dnl    may be used to endorse or promote products derived from this software
 919 dnl    without specific prior written permission.
 920 dnl
 921 dnl THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 922 dnl ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 923 dnl IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 924 dnl ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 925 dnl FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 926 dnl DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 927 dnl OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 928 dnl HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 929 dnl LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 930 dnl OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 931 dnl SUCH DAMAGE.
 932
 933 dnl
 934 dnl Checks to see if AF_INET6 is defined
 935 AC_DEFUN(AC_CHECK_AF_INET6, [
 936         AC_MSG_CHECKING(for AF_INET6)
 937         AC_CACHE_VAL($1,
 938         AC_TRY_COMPILE([
 939 #               include <sys/types.h>
 940 #               include <sys/socket.h>],
 941                 [int a = AF_INET6],
 942                 $1=yes,
 943                 $1=no))
 944         AC_MSG_RESULT($$1)
 945                 if test $$1 = yes ; then
 946                         AC_DEFINE(HAVE_AF_INET6)
 947         fi
 948 ])
 949
 950 dnl
 951 dnl Checks to see if the sockaddr struct has the 4.4 BSD sa_len member
 952 dnl borrowed from LBL libpcap
 953 AC_DEFUN(AC_CHECK_SA_LEN, [
 954         AC_MSG_CHECKING(if sockaddr struct has sa_len member)
 955         AC_CACHE_VAL($1,
 956         AC_TRY_COMPILE([
 957 #               include <sys/types.h>
 958 #               include <sys/socket.h>],
 959                 [u_int i = sizeof(((struct sockaddr *)0)->sa_len)],
 960                 $1=yes,
 961                 $1=no))
 962         AC_MSG_RESULT($$1)
 963                 if test $$1 = yes ; then
 964                         AC_DEFINE(HAVE_SOCKADDR_SA_LEN)
 965         fi
 966 ])
 967
 968 dnl
 969 dnl Checks for addrinfo structure
 970 AC_DEFUN(AC_STRUCT_ADDRINFO, [
 971         AC_MSG_CHECKING(for addrinfo)
 972         AC_CACHE_VAL($1,
 973         AC_TRY_COMPILE([
 974 #               include <netdb.h>],
 975                 [struct addrinfo a],
 976                 $1=yes,
 977                 $1=no))
 978         AC_MSG_RESULT($$1)
 979         if test $$1 = yes; then
 980                 AC_DEFINE(HAVE_ADDRINFO)
 981         else
 982                 AC_DEFINE(NEED_ADDRINFO_H)
 983         fi
 984 ])
 985
 986 dnl
 987 dnl Checks for NI_MAXSERV
 988 AC_DEFUN(AC_NI_MAXSERV, [
 989         AC_MSG_CHECKING(for NI_MAXSERV)
 990         AC_CACHE_VAL($1,
 991         AC_EGREP_CPP(yes, [#include <netdb.h>
 992 #ifdef NI_MAXSERV
 993 yes
 994 #endif],
 995                 $1=yes,
 996                 $1=no))
 997         AC_MSG_RESULT($$1)
 998         if test $$1 != yes; then
 999                 AC_DEFINE(NEED_ADDRINFO_H)
1000         fi
1001 ])
1002
1003 dnl
1004 dnl Checks for NI_NAMEREQD
1005 AC_DEFUN(AC_NI_NAMEREQD, [
1006         AC_MSG_CHECKING(for NI_NAMEREQD)
1007         AC_CACHE_VAL($1,
1008         AC_EGREP_CPP(yes, [#include <netdb.h>
1009 #ifdef NI_NOFQDN
1010 yes
1011 #endif],
1012                 $1=yes,
1013                 $1=no))
1014         AC_MSG_RESULT($$1)
1015         if test $$1 != yes; then
1016                 AC_DEFINE(NEED_ADDRINFO_H)
1017         fi
1018 ])
1019
1020 dnl
1021 dnl Checks for sockaddr_storage structure
1022 AC_DEFUN(AC_STRUCT_SA_STORAGE, [
1023         AC_MSG_CHECKING(for sockaddr_storage)
1024         AC_CACHE_VAL($1,
1025         AC_TRY_COMPILE([
1026 #               include <sys/types.h>
1027 #               include <sys/socket.h>],
1028                 [struct sockaddr_storage s],
1029                 $1=yes,
1030                 $1=no))
1031         AC_MSG_RESULT($$1)
1032         if test $$1 = yes; then
1033                 AC_DEFINE(HAVE_SOCKADDR_STORAGE)
1034         fi
1035 ])
1036
1037 dnl
1038 dnl Checks for macro of IP address size
1039 AC_DEFUN(AC_CHECK_ADDRSZ, [
1040         $1=yes
1041 dnl check for INADDRSZ
1042         AC_MSG_CHECKING(for INADDRSZ)
1043         AC_CACHE_VAL(ac_cv_inaddrsz,
1044         AC_TRY_COMPILE([
1045 #               include <arpa/nameser.h>],
1046                 [int a = INADDRSZ],
1047                 ac_cv_inaddrsz=yes,
1048                 ac_cv_inaddrsz=no))
1049         AC_MSG_RESULT($ac_cv_inaddrsz)
1050         if test $ac_cv_inaddrsz = yes; then
1051                 AC_DEFINE(HAVE_INADDRSZ)
1052         else
1053                 $1=no
1054         fi
1055 dnl check for IN6ADDRSZ
1056         AC_MSG_CHECKING(for IN6ADDRSZ)
1057         AC_CACHE_VAL(ac_cv_in6addrsz,
1058         AC_TRY_COMPILE([
1059 #               include <arpa/nameser.h>],
1060                 [int a = IN6ADDRSZ],
1061                 ac_cv_in6addrsz=yes,
1062                 ac_cv_in6addrsz=no))
1063         AC_MSG_RESULT($ac_cv_in6addrsz)
1064         if test $ac_cv_in6addrsz = yes; then
1065                 AC_DEFINE(HAVE_IN6ADDRSZ)
1066         else
1067                 $1=no
1068         fi
1069 ])
1070
1071 dnl
1072 dnl check for RES_USE_INET6
1073 AC_DEFUN(AC_CHECK_RES_USE_INET6, [
1074         AC_MSG_CHECKING(for RES_USE_INET6)
1075         AC_CACHE_VAL($1,
1076         AC_TRY_COMPILE([
1077 #               include <sys/types.h>
1078 #               include <netinet/in.h>
1079 #               include <resolv.h>],
1080                 [int a = RES_USE_INET6],
1081                 $1=yes,
1082                 $1=no))
1083         AC_MSG_RESULT($$1)
1084         if test $$1 = yes; then
1085                 AC_DEFINE(HAVE_RES_USE_INET6)
1086         fi
1087 ])
1088
1089 dnl
1090 dnl check for AAAA
1091 AC_DEFUN(AC_CHECK_AAAA, [
1092         AC_MSG_CHECKING(for AAAA)
1093         AC_CACHE_VAL($1,
1094         AC_TRY_COMPILE([
1095 #               include <sys/types.h>
1096 #               include <arpa/nameser.h>],
1097                 [int a = T_AAAA],
1098                 $1=yes,
1099                 $1=no))
1100         AC_MSG_RESULT($$1)
1101         if test $$1 = yes; then
1102                 AC_DEFINE(HAVE_AAAA)
1103         fi
1104 ])
1105
1106 dnl
1107 dnl check for struct res_state_ext
1108 AC_DEFUN(AC_STRUCT_RES_STATE_EXT, [
1109         AC_MSG_CHECKING(for res_state_ext)
1110         AC_CACHE_VAL($1,
1111         AC_TRY_COMPILE([
1112 #               include <sys/types.h>
1113 #               include <netinet/in.h>
1114 #               include <netinet6/in6.h>
1115 #               include <resolv.h>],
1116                 [struct __res_state_ext e],
1117                 $1=yes,
1118                 $1=no))
1119         AC_MSG_RESULT($$1)
1120         if test $$1 = yes; then
1121                 AC_DEFINE(HAVE_RES_STATE_EXT)
1122         fi
1123 ])
1124
1125 dnl
1126 dnl check for struct res_state_ext
1127 AC_DEFUN(AC_STRUCT_RES_STATE, [
1128         AC_MSG_CHECKING(for nsort in res_state)
1129         AC_CACHE_VAL($1,
1130         AC_TRY_COMPILE([
1131 #               include <sys/types.h>
1132 #               include <netinet/in.h>
1133 #               include <netinet6/in6.h>
1134 #               include <resolv.h>],
1135                 [struct __res_state e; e.nsort = 0],
1136                 $1=yes,
1137                 $1=no))
1138         AC_MSG_RESULT($$1)
1139         if test $$1 = yes; then
1140                 AC_DEFINE(HAVE_NEW_RES_STATE)
1141         fi
1142 ])
1143
1144 dnl
1145 dnl check for h_errno
1146 AC_DEFUN(AC_VAR_H_ERRNO, [
1147         AC_MSG_CHECKING(for h_errno)
1148         AC_CACHE_VAL(ac_cv_var_h_errno,
1149         AC_TRY_COMPILE([
1150 #               include <sys/types.h>
1151 #               include <netdb.h>],
1152                 [int foo = h_errno;],
1153                 ac_cv_var_h_errno=yes,
1154                 ac_cv_var_h_errno=no))
1155         AC_MSG_RESULT($ac_cv_var_h_errno)
1156         if test "$ac_cv_var_h_errno" = "yes"; then
1157                 AC_DEFINE(HAVE_H_ERRNO)
1158         fi
1159 ])
1160
1161 dnl
1162 dnl Test for __attribute__
1163 dnl
1164
1165 AC_DEFUN(AC_C___ATTRIBUTE__, [
1166 AC_MSG_CHECKING(for __attribute__)
1167 AC_CACHE_VAL(ac_cv___attribute__, [
1168 AC_COMPILE_IFELSE(
1169   AC_LANG_SOURCE([[
1170 #include <stdlib.h>
1171
1172 static void foo(void) __attribute__ ((noreturn));
1173
1174 static void
1175 foo(void)
1176 {
1177   exit(1);
1178 }
1179
1180 int
1181 main(int argc, char **argv)
1182 {
1183   foo();
1184 }
1185   ]]),
1186 ac_cv___attribute__=yes,
1187 ac_cv___attribute__=no)])
1188 if test "$ac_cv___attribute__" = "yes"; then
1189   AC_DEFINE(HAVE___ATTRIBUTE__, 1, [define if your compiler has __attribute__])
1190   V_DEFS="$V_DEFS -D_U_=\"__attribute__((unused))\""
1191 else
1192   V_DEFS="$V_DEFS -D_U_=\"\""
1193 fi
1194 AC_MSG_RESULT($ac_cv___attribute__)
1195 ])
1196
1197
1198 dnl
1199 dnl Test whether __attribute__((format)) can be applied to function
1200 dnl pointers
1201 dnl
1202
1203 AC_DEFUN(AC_C___ATTRIBUTE___FORMAT_FUNCTION_POINTER, [
1204 AC_MSG_CHECKING([whether __attribute__((format)) can be applied to function pointers])
1205 AC_CACHE_VAL(ac_cv___attribute___format_function_pointer, [
1206 AC_COMPILE_IFELSE(
1207   AC_LANG_SOURCE([[
1208 #include <stdlib.h>
1209
1210 extern int (*foo)(const char *fmt, ...)
1211                   __attribute__ ((format (printf, 1, 2)));
1212
1213 int
1214 main(int argc, char **argv)
1215 {
1216   (*foo)("%s", "test");
1217 }
1218   ]]),
1219 ac_cv___attribute___format_function_pointer=yes,
1220 ac_cv___attribute___format_function_pointer=no)])
1221 if test "$ac_cv___attribute___format_function_pointer" = "yes"; then
1222   AC_DEFINE(__ATTRIBUTE___FORMAT_OK_FOR_FUNCTION_POINTERS, 1,
1223     [define if your compiler allows __attribute__((format)) to be applied to function pointers])
1224 fi
1225 AC_MSG_RESULT($ac_cv___attribute___format_function_pointer)
1226 ])
1227
1228 AC_DEFUN(AC_LBL_SSLEAY,
1229     [
1230         #
1231         # Find the last component of $libdir; it's not necessarily
1232         # "lib" - it might be "lib64" on, for example, x86-64
1233         # Linux systems.
1234         #
1235         # We assume the directory in which we're looking for
1236         # libcrypto has a subdirectory with that as its name.
1237         #
1238         tmplib=`echo "$libdir" | sed 's,.*/,,'`
1239
1240         #
1241         # XXX - is there a better way to check if a given library is
1242         # in a given directory than checking each of the possible
1243         # shared library suffixes?
1244         #
1245         # Are there any other suffixes we need to look for?  Do we
1246         # have to worry about ".so.{version}"?
1247         #
1248         # Or should we just look for "libcrypto.*"?
1249         #
1250         if test -d "$1/$tmplib" -a \( -f "$1/$tmplib/libcrypto.a" -o \
1251                                     -f "$1/$tmplib/libcrypto.so" -o \
1252                                     -f "$1/$tmplib/libcrypto.sl" -o \
1253                                     -f "$1/$tmplib/libcrypto.dylib" \); then
1254                 ac_cv_ssleay_path="$1"
1255         fi
1256
1257         #
1258         # Make sure we have the headers as well.
1259         #
1260         if test -d "$1/include/openssl" -a -f "$1/include/openssl/des.h"; then
1261                 incdir="-I$1/include"
1262         fi
1263 ])