dnl $Id: configure.in 1808 2007-04-15 01:46:13Z aturner $

AC_INIT(tcpreplay)
AC_CONFIG_SRCDIR(src/tcpreplay.c)
AM_CONFIG_HEADER(src/config.h)
AC_CONFIG_AUX_DIR(config)
AM_MAINTAINER_MODE
AM_WITH_DMALLOC
AC_PROG_LIBTOOL

dnl Set version info here!
MAJOR_VERSION=3
MINOR_VERSION=0
MICRO_VERSION=RC1
TCPREPLAY_VERSION=$MAJOR_VERSION.$MINOR_VERSION.$MICRO_VERSION

dnl Release is only used for the RPM spec file
TCPREPLAY_RELEASE=1

AC_DEFINE(PACKAGE, [tcpreplay], [This is our package name])
AC_DEFINE_UNQUOTED(VERSION, "$TCPREPLAY_VERSION", [What is our version?])
AC_SUBST(TCPREPLAY_VERSION)
AC_SUBST(TCPREPLAY_RELEASE)

CFLAGS="$CFLAGS -Wall -O2 -funroll-loops -std=gnu99"

dnl Determine OS
AC_CANONICAL_BUILD
AC_CANONICAL_HOST
AC_CANONICAL_TARGET
AC_SUBST(host)
AC_SUBST(build)
AC_SUBST(target)

AC_MSG_CHECKING([for cygwin development environment])
if test `echo $target | grep -c cygwin` -gt 0 ; then
   AC_DEFINE([HAVE_WIN32], [1], [Windows/Cygwin])
   AC_MSG_RESULT(yes)
else
   AC_MSG_RESULT(no)
fi


AM_INIT_AUTOMAKE(tcpreplay, $TCPREPLAY_VERSION, nodefine)

dnl Checks for programs.
AC_PROG_INSTALL
AC_PROG_LIBTOOL
AC_PROG_CC
AC_PROG_CC_STDC
AC_PROG_CXX
AC_PROG_CPP
AC_PROG_LN_S
AC_PROG_RANLIB
AC_PROG_AWK
AC_PROG_MAKE_SET
AC_EXEEXT
AC_PATH_PROG(PRINTF, printf)
AC_PATH_PROG(AUTOGEN, autogen)

AC_HEADER_STDC
AC_HEADER_MAJOR

dnl Checks for typedefs, structures, and compiler characteristics.
AC_TYPE_SIZE_T
AC_HEADER_TIME
AC_C_CONST
AC_C_INLINE
AC_SYS_LARGEFILE

dnl Check for functions
AC_FUNC_FSEEKO

dnl Check for types.
AC_CHECK_TYPE(u_int8_t, uint8_t)
AC_CHECK_TYPE(u_int16_t, uint16_t)
AC_CHECK_TYPE(u_int32_t, uint32_t)
AC_CHECK_TYPE(u_int64_t, uint64_t)

dnl Older versions of GCC don't support these options
AC_MSG_CHECKING(for $CC -Wextra support)
OLD_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS -Wextra"
wextra=""
AC_COMPILE_IFELSE([#include <stdlib.h>
    int main(int argc, char *argv[]) { return(0); }],
    [ AC_MSG_RESULT(yes) 
      wextra="-Wextra" ],
    [ AC_MSG_RESULT(no) ])
CFLAGS="$OLD_CFLAGS $wextra"

AC_MSG_CHECKING(for $CC -Wno-variadic-macros support)
OLD_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS -Wno-variadic-macros"
wno_variadic_macros=""
AC_COMPILE_IFELSE([#include <stdlib.h>
    int main(int argc, char *argv[]) { return(0); }],
    [ AC_MSG_RESULT(yes) 
      wno_variadic_macros="-Wno-variadic-macros" ],
    [ AC_MSG_RESULT(no) ])
CFLAGS="$OLD_CFLAGS $wno_variadic_macros"

AC_MSG_CHECKING(for $CC -Wfatal-errors support)
OLD_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS -Wfatal-errors"
wfatal_errors=""
AC_COMPILE_IFELSE([#include <stdlib.h>
    int main(int argc, char *argv[]) { return(0); }],
    [ AC_MSG_RESULT(yes) 
      wfatal_errors="-Wfatal-errors" ],
    [ AC_MSG_RESULT(no) ])
CFLAGS="$OLD_CFLAGS $wfatal_errors"


dnl Check for other header files
AC_CHECK_HEADERS([fcntl.h stddef.h sys/socket.h  arpa/inet.h sys/time.h signal.h string.h strings.h sys/types.h sys/select.h netinet/in.h poll.h sys/poll.h unistd.h sys/param.h])

dnl OpenBSD has special requirements
AC_CHECK_HEADERS([sys/sysctl.h net/route.h], [], [], [
[#if HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
]])


dnl Checks for libraries.
AC_CHECK_LIB(socket, socket)
AC_CHECK_LIB(nsl, gethostbyname)
AC_CHECK_LIB(rt, nanosleep)

dnl Checks for library functions.
AC_FUNC_MALLOC
AC_FUNC_MEMCMP
AC_TYPE_SIGNAL
AC_FUNC_VPRINTF
AC_CHECK_MEMBERS([struct timeval.tv_sec])

AC_CHECK_FUNCS([gettimeofday ctime memset regcomp strdup strchr strerror strtol strncpy strtoull poll ntohll mmap snprintf vsnprintf])

dnl Look for strlcpy since some BSD's have it
AC_CHECK_FUNCS([strlcpy],have_strlcpy=true,have_strlcpy=false)
AM_CONDITIONAL(SYSTEM_STRLCPY, [test x$have_strlcpy = xtrue])

AC_C_BIGENDIAN
AM_CONDITIONAL([WORDS_BIGENDIAN], [ test x$ac_cv_c_bigendian = xyes ])


dnl Enable debugging in code/compiler options
debug=no
AC_ARG_ENABLE(debug,
    AC_HELP_STRING([--enable-debug], [Enable debugging code and support for the -d option]),
    [ if test x$enableval = xyes; then
        debug=yes
	CFLAGS="-ggdb -std=gnu99 -Wall $wextra $wfatal_errors $wno_variadic_macros"
# We may also want to add:
#         -Wformat-security -Wswitch-default -Wunused-paramter -Wpadded"
         AC_SUBST(debug_flag)
         AC_DEFINE([DEBUG], [1], [Enable debuging code and support for the -d option]) 
      fi])


AC_ARG_ENABLE(pedantic,
    AC_HELP_STRING([--enable-pedantic], [Enable gcc's -pedantic option]),
    [ if test x$enableval = xyes; then
        CFLAGS="$CFLAGS -pedantic"
      fi ])

dnl Enable Efense
AC_ARG_ENABLE(efence,
    AC_HELP_STRING([--enable-efence], [Enable Electric Fence memory debugger]),
    [ if test x$enableval = xyes; then
          CFLAGS="$CFLAGS -lefence"
          AC_DEFINE([EFENCE], [1], [Enable Electric Fence memory debugger])
      fi])

dnl Enable Gprof
AC_ARG_ENABLE(gprof,
    AC_HELP_STRING([--enable-gprof], [Enable GNU Profiler]),
    [ if test x$enableval = xyes; then
          if test $debug = yes; then
              CFLAGS="$CFLAGS -pg"
          else 
              # GPROF requires gdb
              CFLAGS="$CFLAGS -ggdb -pg -fprofile-arcs"
          fi
          AC_DEFINE([GPROF], [1], [Enable GNU Profiler])
      fi])

dnl Use 64bits for packet counters
AC_ARG_ENABLE(64bits,
    AC_HELP_STRING([--enable-64bits], [Use 64bit packet counters]),
    [ if test x$enableval = xyes; then
         AC_DEFINE([ENABLE_64BITS], [1], [Use 64bit packet counters])
         AC_MSG_NOTICE([Using u_int64_t for packet counters])
      else
         AC_MSG_NOTICE([Using u_int32_t for packet counters])
      fi
    ])


AC_ARG_ENABLE(force-bpf,
	AC_HELP_STRING([--enable-force-bpf], [Force using BPF for sending packets]),
	[ AC_DEFINE([FORCE_INJECT_BPF], [1], [Force using BPF for sending packet])])

AC_ARG_ENABLE(force-pf, 
	AC_HELP_STRING([--enable-force-pf], [Force using Linux's PF_PACKET for sending packets]),
	[ AC_DEFINE([FORCE_INJECT_PF], [1], [Force using Linux's PF_PACKET for sending packets])])

AC_ARG_ENABLE(force-libnet,
	AC_HELP_STRING([--enable-force-libnet], [Force using libnet for sending packets]),
	[ AC_DEFINE([FORCE_INJECT_LIBNET], [1], [Force using libnet for sending packets])])
		
AC_ARG_ENABLE(force-inject,
	AC_HELP_STRING([--enable-force-inject], [Force using libpcap's pcap_inject() for sending packets]),
	[ AC_DEFINE([FORCE_INJECT_PCAP_INJECT],[1], [Force using libpcap's pcap_inject() for sending packets])])

AC_ARG_ENABLE(force-sendpacket,
	AC_HELP_STRING([--enable-force-sendpacket], [Force using libpcap's pcap_sendpacket() for sending packets]),
	[ AC_DEFINE([FORCE_INJECT_PCAP_SENDPACKET], [1], [Force using libpcap's pcap_sendpacket() for sending packets])])

tcpreplay_edit=no
AC_ARG_ENABLE(tcpreplay-edit,
	AC_HELP_STRING([--enable-tcpreplay-edit], [Link packet editing code with tcpreplay]),
	[ AC_DEFINE([TCPREPLAY_EDIT], [1], [Link packet editing code with tcpreplay])
	tcpreplay_edit=yes
	])

AM_CONDITIONAL([ENABLE_TCPREPLAY_EDIT], [test x$tcpreplay_edit = xyes])


dnl Dynamic link libraries
dynamic_link=no
AC_ARG_ENABLE(dynamic-link,
    AC_HELP_STRING([--enable-dynamic-link], [Dynamically link libraries]),
    [ if test x$enableval = xyes; then
        AC_DEFINE([ENABLE_DYNAMIC_LINK], [1], [Enable dynamically linking libs])
        dynamic_link=yes
      fi
    ])

dnl Check for inet_aton and inet_pton
AC_CHECK_FUNC(inet_aton, 
    AC_DEFINE([HAVE_INET_ATON], [1], [Do we have inet_aton?]) 
    inet_aton=yes, 
    inet_aton=no)
AC_CHECK_FUNC(inet_pton, 
    AC_DEFINE([HAVE_INET_PTON], [1], [Do we have inet_pton?]) 
    inet_pton=yes, 
    inet_pton=no)
AC_CHECK_FUNC(inet_ntop, 
    AC_DEFINE([HAVE_INET_NTOP], [1], [Do we have inet_ntop?]) 
    inet_ntop=yes, 
    inet_ntop=no)

if test "$inet_ntop" = "no" -a "$inet_pton" = "no" ; then
	AC_MSG_ERROR([We need either inet_ntop or inet_pton])
fi

if test "$inet_aton" = "no" ; then
    AC_MSG_ERROR([We need inet_aton])
fi

AC_CHECK_FUNC(inet_addr, 
    AC_DEFINE([HAVE_INET_ADDR], [1], [Do we have inet_addr?]) 
    inet_addr=yes, 
    inet_addr=no)

if test x$inet_addr = no ; then
    AC_MSG_ERROR([We need inet_addr.  See bug 26])
fi

dnl Enable flowreplay
flowreplay=no
AC_ARG_ENABLE(flowreplay,
    AC_HELP_STRING([--enable-flowreplay], [Enable building flowreplay (alpha)]),
    [ if test x$enableval = xyes; then
         flowreplay=yes
         AC_DEFINE([ENABLE_FLOWREPLAY], [1], [Enable building flowreplay (alpha)]) 
      fi])

AM_CONDITIONAL([ENABLE_FLOWREPLAY], [test x$flowreplay = xyes])

dnl ##################################################
dnl Checks for libnet (shamelessly horked from dsniff)
dnl ##################################################
foundnet=no
trynetdir=/usr/local
AC_MSG_CHECKING(for libnet)
AC_ARG_WITH(libnet,
    AC_HELP_STRING([--with-libnet=DIR], [Use libnet in DIR]),
    [trynetdir=$withval])

for testdir in $trynetdir /usr/local /opt/local /usr ; do
    if test -f "${testdir}/include/libnet.h" -a $foundnet = no ; then
     LNETINC="${testdir}/include/libnet.h"
     LNETINCDIR="$testdir/include"
     if test $dynamic_link = yes; then
         LNETLIB="-L${testdir}/lib -lnet"
     elif test -f "${testdir}/lib64/libnet.a" ; then
         LNETLIB="${testdir}/lib64/libnet.a"
     else
         LNETLIB="${testdir}/lib/libnet.a"
     fi
     foundnet=$testdir
    fi
done

if test $foundnet = no ; then
    AC_MSG_RESULT(no)
else 
    AC_MSG_RESULT($foundnet) 
	AC_DEFINE([HAVE_LIBNET], [1], [Enable libnet support])
fi

AC_SUBST(LNETINC)
AC_SUBST(LNETLIB)

if test $foundnet = yes ; then
	OLDLIBS="$LIBS"
	OLDCFLAGS="$CFLAGS"
	LIBS="$LNETLIB"
	CFLAGS="$CFLAGS -I$LNETINCDIR"


	dnl Check to see what version of libnet
	dnl this code has been reduced a lot, but probably still could be
	dnl reduced quite a bit more if we chose too
	AC_MSG_CHECKING(for libnet version)

	AC_TRY_RUN([
#include <string.h>
#define LIBNET_LIL_ENDIAN 1
#include "$LNETINC"
#define LIB_TEST "1.0"
	/* 
	 * simple proggy to test the version of libnet
	 * returns zero if it's 1.0.x 
	 * or one otherwise
	 */
	int
	main (int argc, char *argv[])
	{
	        if (strncmp(LIB_TEST, LIBNET_VERSION, 3) == 0)
	                exit(0);
	        exit(1);
	}],
	        libnet_ver_10=yes
	        AC_MSG_RESULT(1.0.x), 
	        libnet_ver_10=no,
	        libnet_ver_10=no
	        )

	AC_TRY_RUN([
#include <string.h>
#include "$LNETINC"
#define LIB_TEST "1.1"
	/* 
	 * simple proggy to test the version of libnet
	 * returns zero if it's 1.0.x 
	 * or one otherwise
	 */
	int
	main (int argc, char *argv[])
	{
	        if (strncmp(LIB_TEST, LIBNET_VERSION, 3) == 0)
	                exit(0);
	        exit(1);
	}],
	        libnet_ver_11=yes
	        AC_MSG_RESULT(1.1.x), 
	        libnet_ver_11=no,
	        libnet_ver_11=no
	        )


	if test $libnet_ver_10 = no -a $libnet_ver_11 = no ; then
	        AC_MSG_RESULT(unknown)
	        AC_MSG_ERROR(Unable to determine version of libnet)
	fi

	if test $libnet_ver_10 = yes ; then
	          AC_MSG_ERROR(Libnet version 1.0.x is no longer supported.
	                Please upgrade to 1.1.0 or better)
	fi


	dnl restore LIBS & CFLAGS
	LIBS="$OLDLIBS"
	CFLAGS="$OLDCFLAGS"

fi 

dnl END OF if test $foundnet = yes

dnl #####################################################
dnl Checks for libpcap
dnl #####################################################
foundpcap=no
trypcapdir=/usr/local
AC_MSG_CHECKING(for libpcap)
AC_ARG_WITH(libpcap,
    AC_HELP_STRING([--with-libpcap=DIR], [Use libpcap in DIR]),
    [trypcapdir=$withval])

	for testdir in $trypcapdir /usr/local /opt/local /usr ; do 
    	if test -f "${testdir}/include/pcap.h" -a $foundpcap = no ; then
        	LPCAPINC="${testdir}/include/pcap.h"
	        LPCAPINCDIR="${testdir}/include"
	        if test $dynamic_link = yes; then
				if test -f "${testdir}/lib/libpcap.a" ; then
		            LPCAPLIB="-L${testdir}/lib -lpcap"
				elif test -f "${testdir}/lib64/libpcap.a" ; then
					LPCAPLIB="-L${testdir}/lib64 -lpcap"
				else
					AC_ERROR([Unable to find libpcap in ${testdir}])
				fi
	        elif test -f "${testdir}/lib64/libpcap.a" ; then
	            LPCAPLIB="${testdir}/lib64/libpcap.a"
	        elif test -f "${testdir}/lib/libpcap.a" ; then
	            LPCAPLIB="${testdir}/lib/libpcap.a"
	        elif test -f "${testdir}/lib/libwpcap.a" ; then
	            LPCAPLIB="${testdir}/lib/libwpcap.a"
				AC_DEFINE([HAVE_WINPCAP], [1], [Do we have WinPcap?])
		 	else
				AC_ERROR([Unable to find matching library for header file in ${testdir}])
			fi
        	foundpcap=$testdir
     	fi
	done

	if test $foundpcap = no ; then
		AC_MSG_RESULT(no)
		AC_ERROR(libpcap not found)
	else
		AC_MSG_RESULT($foundpcap)
	fi

AC_SUBST(LPCAPINC)
AC_SUBST(LPCAPLIB)

dnl Checks to see what version of libpcap we've got
OLDLIBS="$LIBS"
OLDCFLAGS="$CFLAGS -I$LPCAPINCDIR"
LIBS="$LPCAPLIB"
CFLAGS="$CFLAGS -I$LPCAPINCDIR"


have_libnet=no
dnl Check to see what version of libpcap
dnl this code has been reduced a lot, but probably still could be
dnl reduced quite a bit more if we chose too
AC_MSG_CHECKING(for libpcap version)

AC_RUN_IFELSE(AC_LANG_PROGRAM([[
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "$LPCAPINC"
#define PCAP_TEST "0.8"
]], [[
/* 
 * simple proggy to test the version of libpcap
 * returns zero if version >= 0.8.0
 * or one otherwise
 */
    if (strncmp(pcap_lib_version(), PCAP_TEST, 3) >= 0)
            exit(0);

    /* winpcap? */
    if (strncmp(pcap_lib_version(), "WinPcap", 7) == 0)
	    exit(0);

    exit(1);
]]), [
    libpcap_ver8=yes
], [
    libpcap_ver8=no
])

AC_RUN_IFELSE(AC_LANG_PROGRAM([[
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "$LPCAPINC"
#define PCAP_TEST "0.7.2"
extern const char pcap_version[[]]; /* double up since autoconf escapes things */
]], [[
/* 
 * simple proggy to test the version of libpcap
 * returns zero if version >= 0.7.2
 * or one otherwise
 */

    if (strncmp(pcap_version, PCAP_TEST, 5) >= 0)
            exit(0);
    
    exit(1);
]]), [
    libpcap_ver7=yes
], [
    libpcap_ver7=no
])

if test $libpcap_ver8 = yes ; then
    AC_MSG_RESULT(>= 0.8.0)
elif test $libpcap_ver7 = yes ; then
    AC_MSG_RESULT(>= 0.7.2)
else 
    AC_MSG_ERROR([Libpcap versions < 0.7.2 are not supported
    Please upgrade to version 0.7.2 or better])
fi

dnl Check to see if we've got pcap_datalink_val_to_name()
AC_MSG_CHECKING(for pcap_datalink_val_to_description)
AC_LINK_IFELSE(AC_LANG_PROGRAM([[
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "$LPCAPINC"
]],[[
    if (strcmp(pcap_datalink_val_to_description(1), "Ethernet (10Mb)") == 0)
        exit(0);
    exit(1);
]]),[
    have_dlt_to_desc=yes
    AC_MSG_RESULT(yes)
], [
    have_dlt_to_desc=no
    AC_MSG_RESULT(no)
])

if test $have_dlt_to_desc = yes ; then
    AC_DEFINE([HAVE_DLT_VAL_TO_DESC], [1], 
              [Does libpcap have dlt_val_to_desc?])
fi

dnl Check to see if we've got pcap_dump_fopen()
AC_MSG_CHECKING(for pcap_dump_fopen)
AC_LINK_IFELSE(AC_LANG_PROGRAM([[
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "$LPCAPINC"
]],[[
	pcap_dumper_t *dump;
	pcap_t *pcap;
	FILE *foo;
	dump = pcap_dump_fopen(pcap, foo);
]]),[
    have_pcap_dump_fopen=yes
    AC_MSG_RESULT(yes)
], [
    have_pcap_dump_fopen=no
    AC_MSG_RESULT(no)
])

if test $have_pcap_dump_fopen = yes ; then
    AC_DEFINE([HAVE_PCAP_DUMP_FOPEN], [1], 
              [Does libpcap have pcap_dump_fopen?])
else
	AC_MSG_NOTICE([--verbose mode requires libpcap >= 0.9.0])
fi

dnl Check to see if we've got pcap_snapshot_override()
AC_MSG_CHECKING(for pcap_snapshot_override)
AC_LINK_IFELSE(AC_LANG_PROGRAM([[
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "$LPCAPINC"
]],[[
	pcap_t *pcap;
	pcap_snapshot_override(pcap, 1);
	exit(0);
]]),[
    have_pcap_snapshot_override=yes
    AC_MSG_RESULT(yes)
], [
    have_pcap_snapshot_override=no
    AC_MSG_RESULT(no)
])

if test $have_pcap_snapshot_override = yes ; then
    AC_DEFINE([HAVE_PCAP_SNAPSHOT_OVERRIDE], [1], 
              [Does libpcap have pcap_snapshot_override()?])
fi


have_pcap_inject=no
dnl Check to see if we've got pcap_inject()
AC_MSG_CHECKING(for pcap_inject sending support)
AC_TRY_COMPILE([
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "$LPCAPINC"
],[
	pcap_t *pcap;
	char *buf;
    pcap_inject(pcap, (void *)buf, 0);
],[
	AC_DEFINE([HAVE_PCAP_INJECT], [1], 
              [Does libpcap have pcap_inject?])
	AC_MSG_RESULT(yes)
	have_pcap_inject=yes
],[
	AC_MSG_RESULT(no)
])

have_pcap_version=no
dnl Check to see if we have pcap_version[]
AC_MSG_CHECKING(for pcap_version[])
AC_TRY_COMPILE([
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "$LPCAPINC"
extern char pcap_version[];
],[
	printf("%s", pcap_version);
],[
	AC_DEFINE([HAVE_PCAP_VERSION],[1], [Does libpcap have pcap_version[]])
	AC_MSG_RESULT(yes)
],[
	AC_MSG_RESULT(no)
])

have_pcap_sendpacket=no
dnl Check to see if we've got pcap_sendpacket()
AC_MSG_CHECKING(for pcap_sendpacket sending support)
AC_TRY_COMPILE([
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "$LPCAPINC"
],[
	pcap_t *pcap;
	u_char *buf;
    pcap_sendpacket(pcap, buf, 0);
],[
	AC_DEFINE([HAVE_PCAP_SENDPACKET], [1], 
              [Does libpcap have pcap_sendpacket?])
	AC_MSG_RESULT(yes)
	have_pcap_sendpacket=yes
],[
	AC_MSG_RESULT(no)
])

have_pf=no
dnl Check for linux PF_PACKET support
AC_MSG_CHECKING(for PF_PACKET socket sending support)
AC_TRY_COMPILE([
#include <sys/socket.h>
#include <netpacket/packet.h>
#include <net/ethernet.h>     /* the L2 protocols */
#include <netinet/in.h>       /* htons */
],[
	int pf_socket;
	pf_socket = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
],[
	AC_DEFINE([HAVE_PF_PACKET], [1],
		[Do we have Linux PF_PACKET socket support?])
	AC_MSG_RESULT(yes)
	have_pf=yes
],[
	AC_MSG_RESULT(no)
])

have_bpf=no
dnl Check for BSD's BPF
AC_MSG_CHECKING(for BPF device sending support)
AC_TRY_RUN([
#include <stdio.h>
#include <stdlib.h>
#include <net/bpf.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <net/bpf.h>
#include <errno.h>

int 
main(int argc, char *argv[]) {
	int fd;
	
	fd = open("/dev/bpf0", O_RDONLY, 0);
	
	/* if we opened it, we're good */
	if (fd > 1)
		exit(0);
		
	/* if we got EBUSY or permission denied it exists, so we're good */
	if (fd < 0 && (errno == EBUSY || errno == 13))
		exit(0);
		
	/* else suck, no good */
    exit(-1);
}],
	[
    AC_DEFINE([HAVE_BPF], [1], 
              [Do we have BPF device support?])
	AC_MSG_RESULT(yes)
	have_bpf=yes
	])


dnl Make sure we have a valid packet injection mechanisim
if test $have_bpf = no -a $have_pcap_inject = no -a $have_pcap_sendpacket = no \
	-a $have_libnet = no -a $have_pf = no ; then
	AC_MSG_ERROR([Unable to find a supported method to send packets])
fi

dnl Libpcap support doesn't give us a method to get the hardware address of the
dnl interfaces which prevents us from doing proper filtering to prevent bridging loops
enable_tcpbridge=yes
if test $have_bpf = no -a $have_libnet = no -a $have_pf = no ; then
	AC_MSG_NOTICE([tcpbridge support disabled without BPF, Libnet or Linux PF_PACKET])
	enable_tcpbridge=no
fi

# ADT: Commented for now
# AM_CONDITIONAL(ENABLE_TCPBRIDGE, [test $enable_tcpbridge = yes])

dnl Older versions of libpcap are missing some DLT types
dnl If doesn't exist, we'll define them in src/common/fakepcap.h
AC_MSG_CHECKING(for DLT_LINUX_SLL in libpcap)
AC_TRY_COMPILE([#include "$LPCAPINC"], 
               [ int foo;
                 foo = DLT_LINUX_SLL ],
                [ AC_DEFINE([HAVE_DLT_LINUX_SLL], [1], 
					[Does pcap.h include a header with DLT_LINUX_SLL?])
                  AC_MSG_RESULT(yes)
                ], 
                AC_MSG_RESULT(no)
               )

AC_MSG_CHECKING(for DLT_C_HDLC in libpcap)
AC_TRY_COMPILE([#include "$LPCAPINC"],
               [ int foo;
                 foo = DLT_C_HDLC ],
                [ AC_DEFINE([HAVE_DLT_C_HDLC], [1], 
					[Does pcap.h include a header with DLT_C_HDLC?])
                  AC_MSG_RESULT(yes)
                ],
                AC_MSG_RESULT(no)   
               )

PCAP_BPF_H_FILE="$LPCAPINCDIR/pcap-bpf.h"
AC_MSG_CHECKING(for $PCAP_BPF_H_FILE)
AC_TRY_COMPILE([#include <sys/types.h>
                #include <sys/time.h>
                #include "$PCAP_BPF_H_FILE"],
               [ int foo;
                 foo = BPF_MAJOR_VERSION; ],
               [ AC_DEFINE([INCLUDE_PCAP_BPF_HEADER], [1],
                           [What is the path (if any) to the pcap-bpf.h
                            header?])
                 AC_MSG_RESULT(yes)
                 AC_SUBST(PCAP_BPF_H_FILE)
               ],
               AC_MSG_RESULT(no)
               )

foundbpfheader=no
AC_MSG_CHECKING(for libpcap bpf header)
	for testfile in $LPCAPINCDIR/pcap/bpf.h $LPCAPINCDIR/pcap-bpf.h ; do
    	if test -f "${testfile}" -a $foundbpfheader = no ; then
			AC_TRY_COMPILE([
				#include <sys/types.h>
				#include <sys/time.h>
				#include "$testfile"],
			[
				int foo;
				foo = BPF_MAJOR_VERSION;
			],
			[
				foundbpfheader=yes
				PCAP_BPF_H_FILE=$testfile
				AC_SUBST(PCAP_BPF_H_FILE)
				AC_DEFINE([INCLUDE_PCAP_BPF_HEADER], [1],
					[What is the path (if any) to the libpcap bpf header file?])
				AC_MSG_RESULT($testfile)
			],
				AC_MSG_RESULT(no)
			)
		fi
	done
dnl restore LIBS & CFLAGS
LIBS="$OLDLIBS"
CFLAGS="$OLDCFLAGS"


dnl ##################################################
dnl # Check for pcapnav
dnl ##################################################
pcapnav_ver=no
pcncfg=no
AC_ARG_WITH(pcapnav-config,
    AC_HELP_STRING([--with-pcapnav-config=FILE], [Use given pcapnav-config]),
    [ AC_MSG_CHECKING(for pcapnav-config)
    if test -x $withval ; then
	pcncfg=$withval
	AC_MSG_RESULT($pcncfg)
    elif test x$withval = xno ; then
	AC_MSG_RESULT(no)
	else
	AC_MSG_RESULT([Can't find pcapnav-config: disabling offset jump feature])
    fi ],
    [ AC_PATH_PROG(pcncfg,[pcapnav-config], [no] ) ]
)

if test $pcncfg != no ; then
    LNAVLIB=`$pcncfg --libs`
    LNAV_CFLAGS=`$pcncfg --cflags`
    PCAPNAV_VERSION=`$pcncfg --version`
    AC_SUBST(LNAVLIB)
    AC_SUBST(LNAV_CFLAGS)
    AC_DEFINE_UNQUOTED(PCAPNAV_VERSION, "$PCAPNAV_VERSION", 
                       [libpcapnav's version?])

dnl Check to see what version of libpcapnav
dnl this code has been reduced a lot, but probably still could be
dnl reduced quite a bit more if we chose too
        AC_MSG_CHECKING(for libpcapnav version)
        AC_TRY_RUN([
#include <string.h>
#define PCAPNAV_TEST "0.4"
/* 
 * simple proggy to test the version of libpcapnav
 * returns zero if version >= 0.4
 * or one otherwise
 */

int
main (int argc, char *argv[])
{
	if (strncmp(PCAPNAV_VERSION, PCAPNAV_TEST, 3) >= 0)
		exit(0);
	exit(1);
}],
     	libpcapnav_ver=yes
       	AC_MSG_RESULT(>= 0.4),
       	libpcapnav_ver=no
       	AC_MSG_RESULT(< 0.4),
       	libpcapnav_ver=no
       	)


if test x$libpcapnav_ver = xno ; then
     	AC_MSG_WARN([Libpcapnav versions < 0.4 are not supported.
    Please upgrade to version 0.4 or better.
    Disabling offset jump feature.])
else
    AC_DEFINE([HAVE_PCAPNAV], [1], [Do we have libpcapnav?])
fi

fi # checking pcapnav version


dnl (shamelessly ripped off from libpcap)
dnl Checks to see if unaligned memory accesses fail
dnl
dnl     FORCE_ALIGN (DEFINED)
dnl
AC_MSG_CHECKING(for requires strict byte alignment)
AC_CACHE_VAL(unaligned_fail,
        [case "$host_cpu" in

        # XXX: should also check that they don't do weird things (like on arm)
        alpha*|arm*|hp*|mips*|sparc*|ia64)
                unaligned_fail=yes
                ;;

        *)
                cat >conftest.c <<EOF
		#include <sys/types.h>
		#include <sys/wait.h>
		#include <stdio.h>
                unsigned char a[[5]] = { 1, 2, 3, 4, 5 };
                main() {
                unsigned int i;
                pid_t pid;
                int status;
                /* avoid "core dumped" message */
                pid = fork();
                if (pid <  0)
                        exit(2);
                if (pid > 0) {
                        /* parent */
                        pid = waitpid(pid, &status, 0);
                        if (pid < 0)
                                exit(3);
                        exit(!WIFEXITED(status));
                }
                /* child */
                i = *(unsigned int *)&a[[1]];
                printf("%d\n", i);
                exit(0);
                }
EOF
                ${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS \
                    conftest.c $LIBS >/dev/null 2>&1
                if test ! -x conftest ; then
                        dnl failed to compile for some reason
                        unaligned_fail=yes
                else
                        ./conftest >conftest.out
                        if test ! -s conftest.out ; then
                                unaligned_fail=yes
                        else
                                unaligned_fail=no
                        fi
                fi
                rm -f conftest* core core.conftest
                ;;
        esac])
    AC_MSG_RESULT($unaligned_fail)
    if test $unaligned_fail = yes ; then
            AC_DEFINE([FORCE_ALIGN],[1],[Are we strictly aligned?])
    fi

dnl ##################################################
dnl # Check for tcpdump.
dnl ##################################################

td=no
AC_ARG_WITH(tcpdump,
    AC_HELP_STRING([--with-tcpdump=FILE], [Path to tcpdump binary]),
    [ if test -x $withval ; then
          td=$withval
          AC_MSG_RESULT([Using tcpdump in $td])
      else
          AC_MSG_RESULT([Error: $withval does not exist or is not executable])
      fi ],
    [ AC_PATH_PROG(td, tcpdump, "no", [$PATH:/usr/sbin:/sbin:/usr/local/sbin]) ])
           

if test "$td" = "no"; then
    AC_MSG_WARN([Unable to find tcpdump.  Please specify --with-tcpdump.
                 Disabling --verbose])
else
    AC_DEFINE([HAVE_TCPDUMP], [1], [Do we have tcpdump?])
    AC_DEFINE_UNQUOTED(TCPDUMP_BINARY, "$td", [The tcpdump binary initially used])
fi


AM_CONDITIONAL([ENABLE_TCPDUMP], test "$td" != "no" -a x$have_pcap_dump_fopen = xyes)
if test x$td != xno -a x$have_pcap_dump_fopen = xyes ; then
	AC_DEFINE([ENABLE_VERBOSE], [1], [Do we have tcpdump and pcap_dump_fopen()?])
else
	AC_MSG_WARN([Your version of libpcap is too old for --verbose support])
fi

dnl No 'make test' when cross compile

AC_MSG_CHECKING( for 'make test' profile)
if test "$host" != "$build" ; then
	AC_MSG_WARN(Unable to do tests when cross-compiling)
fi

dnl Allows user to choose which nic to use for testing purposes
AC_ARG_WITH(testnic,
    AC_HELP_STRING([--with-testnic=NIC], [Select which network card to use for testing]),
    [ nic1=$withval
      nic2=$withval
      AC_MSG_RESULT([Using --with-testnic=$withval])],
    [
dnl these need to be dynamic based on OS
case $host in
	*-*-linux*)
	nic1=eth0
	nic2=eth0
	AC_MSG_RESULT(Linux)
	;;

	*-*-solaris*)
	nic1=hme0
	nic2=hme0
	AC_MSG_RESULT(Solaris)
	;;

	*-*-sunos*)
	nic1=hme0
	nic2=hme0
	AC_MSG_RESULT(SunOS)
	;;

	*-apple-darwin*)
	nic1=en0
	nic2=en0
	AC_MSG_RESULT(Apple OS X)
	;;

    *-*-openbsd*)
    nic1=xl0
    nic2=xl0
    AC_MSG_RESULT(OpenBSD)
    ;;

	*-*-cygwin)
	AC_MSG_RESULT(Win32/Cygwin)
	nic1=%0
	nic2=%0
	;;
	
	*)
	AC_MSG_RESULT([$host is unknown!  Using first non-loopback interface])
	nic1=%0
	nic2=%0
	;;
esac])


AC_ARG_WITH(testnic2,
    AC_HELP_STRING([--with-testnic2=NIC2], [Select an optional 2nd network card to use for testing]),
    [ nic2=$withval ])

AC_MSG_NOTICE([Using $nic1 for 1st test network interface card])
AC_MSG_NOTICE([Using $nic2 for 2nd test network interface card])
AC_SUBST(nic1)
AC_SUBST(nic2)

LIBOPTS_CHECK

AC_OUTPUT([Makefile
           doxygen.cfg
           lib/Makefile
           docs/Makefile
           src/Makefile
           src/common/Makefile
           src/tcpedit/Makefile
           src/flow/Makefile
           src/defines.h
           test/Makefile
           test/config
           scripts/Makefile
           tcpreplay.spec])