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

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