diff -ruN squid-3.1.9-orig/configure.in squid-3.1.9/configure.in --- squid-3.1.9-orig/configure.in 2010-10-25 13:35:32.000000000 +0200 +++ squid-3.1.9/configure.in 2010-10-30 01:55:25.000000000 +0200 @@ -186,6 +186,21 @@ ) AC_SUBST(DEFAULT_LOG_DIR) +DEFAULT_SWAPDIR="$localstatedir/cache" +AC_ARG_WITH(swapdir, + AS_HELP_STRING([--with-swapdir=PATH],[Default location for squid SWAP files. default: $DEFAULT_SWAPDIR]), + [ case $withval in + yes|no) + AC_MSG_ERROR( --with-swapdir requires a directory PATH. --with-swapdir=PATH ) + ;; + *) + DEFAULT_SWAPDIR="$withval" + ;; + esac + ] +) +AC_SUBST(DEFAULT_SWAPDIR) + DEFAULT_PIDFILE="$localstatedir/run/squid.pid" AC_ARG_WITH(pidfile, AS_HELP_STRING([--with-pidfile=PATH],[Default location for squid PID file. default: PREFIX/var/run/squid.pid]), diff -ruN squid-3.1.9-orig/configure.in.orig squid-3.1.9/configure.in.orig --- squid-3.1.9-orig/configure.in.orig 1970-01-01 01:00:00.000000000 +0100 +++ squid-3.1.9/configure.in.orig 2010-10-25 13:35:32.000000000 +0200 @@ -0,0 +1,3958 @@ + +dnl +dnl $Id$ +dnl +AC_INIT([Squid Web Proxy],[3.1.9],[http://www.squid-cache.org/bugs/],[squid]) +AC_PREREQ(2.61) +AC_CONFIG_HEADERS([include/autoconf.h]) +AC_CONFIG_AUX_DIR(cfgaux) +AC_CONFIG_SRCDIR([src/main.cc]) +AM_INIT_AUTOMAKE([tar-ustar nostdinc]) +AC_REVISION($Revision$)dnl +AC_PREFIX_DEFAULT(/usr/local/squid) +AM_MAINTAINER_MODE + +PRESET_CFLAGS="$CFLAGS" +PRESET_LDFLAGS="$LDFLAGS" + +dnl Set default LDFLAGS +if test -z "$LDFLAGS"; then + LDFLAGS="-g" +fi + +dnl Check for GNU cc +AC_PROG_CC +AM_PROG_CC_C_O +AC_PROG_CXX +AC_LANG([C++]) +AC_CANONICAL_HOST + +dnl Make the squid top srcdir available to sub-packages as --with-squid=PATH +new_configure_args="$ac_configure_args --with-squid=$ac_abs_confdir" +ac_configure_args="$new_configure_args" + +squid_disable_werror="no" +AC_ARG_ENABLE(strict-error-checking, + AS_HELP_STRING([--disable-strict-error-checking],[By default squid is compiled + with all possible static compiler error-checks enbled. + This flag disables the behavior]), +[ + if test "${enableval}" = "no" + then + squid_disable_werror="yes" + fi +]) + +use_loadable_modules=1 +AC_MSG_CHECKING(whether to use loadable modules) +AC_ARG_ENABLE(loadable-modules, + AS_HELP_STRING([--disable-loadable-modules],[do not support loadable modules]) , + [ + case "${enableval}" in + yes) use_loadable_modules=yes ;; + no) use_loadable_modules=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for --disable-loadable-modules) ;; + esac + AC_MSG_RESULT([$use_loadable_modules, explicitly]) + ], + [ + use_loadable_modules=yes; + AC_MSG_RESULT([$use_loadable_modules, implicitly]) + ] +) + +AM_CONDITIONAL(USE_LOADABLE_MODULES, test $use_loadable_modules = yes) + +if test $use_loadable_modules = yes; +then + AC_DEFINE(USE_LOADABLE_MODULES, 1, [Support Loadable Modules]) + AC_ENABLE_SHARED +else + AC_DISABLE_SHARED +fi + +LT_INIT([dlopen]) +if ! test "${ac_top_build_prefix}" = ""; +then + # LTDL v3-v7 macros assume the autoconf 2.62 variable top_build_prefix is defined + # But from autoconf 2.64 its called ac_top_build_prefix and not automatically added to the Makefile + # This fixes Linux LTDLv3-v7, and BSD LTDL v2.2 + top_build_prefix=${ac_top_build_prefix} + AC_SUBST(top_build_prefix) +fi +LTDL_INIT +LT_LIB_DLLOAD + +# Do we need these unconditionally for "make distcheck" to work? +AC_SUBST(INCLTDL) +AC_SUBST(LIBLTDL) + +if test $use_loadable_modules = yes; +then + # Why is this needed? Should not LT_INIT (or LT_LIB_DLLOAD) from libtool do that? + LIBADD_DL=${lt_cv_dlopen_libs} + AC_SUBST([LIBADD_DL]) +fi + +AC_PROG_RANLIB + + +CRYPTLIB='' +REGEXLIB='' # -lregex +# LIBREGEX='' # libregex.a + +dnl find out the exe extension for this platform. If it's not empty, use it for CGI's as well. +AC_EXEEXT +AC_OBJEXT + +if test -z "$EXEEXT"; then + CGIEXT=".cgi" +else + # automake automatically adds .exe when installing binaries + CGIEXT="" +fi +AC_SUBST(CGIEXT) + +dnl this should be expanded to a list of platform sensible support requirements. +dnl (adding an option like --enable-cygwin-support doesn't make sense :]) - R Collins 2001 +case "$host_os" in +mingw|mingw32|cygwin|cygwin32) + AM_CONDITIONAL(ENABLE_WIN32SPECIFIC, true) + ;; +*) + AM_CONDITIONAL(ENABLE_WIN32SPECIFIC, false) + ;; +esac + +case "$host_os" in +mingw|mingw32) + AC_PATH_PROG(WIN32_PSAPI, psapi.dll, none) + CFLAGS="$CFLAGS -mthreads" + CXXFLAGS="$CXXFLAGS -mthreads" + if test "$ac_cv_path_WIN32_PSAPI" = "none"; then + AC_MSG_NOTICE([PSAPI.DLL is recommended to run Squid on Windows NT Platform]) + AC_MSG_NOTICE([Please see PSAPI.DLL section on doc/win32-relnotes.html.]) + else + AC_DEFINE(HAVE_WIN32_PSAPI,1,[Define if you have PSAPI.DLL on Windows systems]) + LIBS="$LIBS -lpsapi" + fi + MINGW_LIBS="-lmingwex" + AM_CONDITIONAL(USE_IPC_WIN32, true) + AC_SUBST(MINGW_LIBS) + ;; +*) + AM_CONDITIONAL(USE_IPC_WIN32, false) + ;; +esac + +if test -z "$CACHE_HTTP_PORT"; then + CACHE_HTTP_PORT="3128" +fi +if test -z "$CACHE_ICP_PORT"; then + CACHE_ICP_PORT="3130" +fi + +dnl Substitutions +AC_DEFINE_UNQUOTED(CACHE_HTTP_PORT, $CACHE_HTTP_PORT, +[What default TCP port to use for HTTP listening?]) +AC_SUBST(CACHE_HTTP_PORT) +AC_DEFINE_UNQUOTED(CACHE_ICP_PORT, $CACHE_ICP_PORT, +[What default UDP port to use for ICP listening?]) +AC_SUBST(CACHE_ICP_PORT) + +AC_DEFINE_UNQUOTED(CONFIG_HOST_TYPE, "$host",[Host type from configure]) + +AC_DEFINE_UNQUOTED(SQUID_CONFIGURE_OPTIONS, "$ac_configure_args", [configure command line used to configure Squid]) + +CACHE_EFFECTIVE_USER="nobody" +AC_ARG_WITH(default-user, + AS_HELP_STRING([--with-default-user=USER],[System user account for squid permissions. Default: nobody]), + [ CACHE_EFFECTIVE_USER="$withval" ] +) +AC_SUBST(CACHE_EFFECTIVE_USER) + +DEFAULT_LOG_DIR="$localstatedir/logs" +AC_ARG_WITH(logdir, + AS_HELP_STRING([--with-logdir=PATH],[Default location for squid logs. default: $DEFAULT_LOG_DIR]), + [ case $withval in + yes|no) + AC_MSG_ERROR( --with-logdir requires a directory PATH. --with-logdir=PATH ) + ;; + *) + DEFAULT_LOG_DIR="$withval" + ;; + esac + ] +) +AC_SUBST(DEFAULT_LOG_DIR) + +DEFAULT_PIDFILE="$localstatedir/run/squid.pid" +AC_ARG_WITH(pidfile, + AS_HELP_STRING([--with-pidfile=PATH],[Default location for squid PID file. default: PREFIX/var/run/squid.pid]), + [ case $withval in + yes|no) + AC_MSG_ERROR( --with-pidfile requires a file PATH. --with-pidfile=PATH ) + ;; + *) + DEFAULT_PIDFILE="$withval" + ;; + esac + ] +) +AC_SUBST(DEFAULT_PIDFILE) + +dnl Gerben Wierda +case "$host" in + mab-next-nextstep3) + CC="$CC -arch m68k -arch i486 -arch hppa -arch sparc" + ;; +esac + +if test "$GCC" = "yes"; then + GCCVER=`$CC -v 2>&1 | awk '$2 == "version" {print $3}'` + GCCVER2=`echo $GCCVER | awk '{print $1 * 100}'` + case "$host" in + i386-*-freebsd*) + if test $GCCVER2 -lt 300 ; then + AC_MSG_FAILURE([GCC $GCCVER causes a coredump on $host. Try a more recent GCC version]) + sleep 5 + fi + ;; + esac + unset GCCVER + unset GCCVER2 +fi + +dnl Set Default CFLAGS +if test -z "$PRESET_CFLAGS"; then + if test "$GCC" = "yes"; then + case "$host" in + *-sun-sunos*) + # sunos has too many warnings for this to be useful + # motorola too + ;; + *m88k*) + # Motorola cc/ld does not like -02 but is ok on -O + CFLAGS=`echo $CFLAGS | sed -e 's/-O[0-9]/-O/'` + ;; + *) + CFLAGS="-Wall $CFLAGS" + ;; + esac + else + case "$host" in + *mips-sgi-irix6.*) + # suggested by Rafael Seidl + CFLAGS="-O3 -OPT:Olimit=0:space=OFF \ + -woff 1009,1014,1110,1116,1183,1185,1188,1204,1230,1233,1355 \ + -Wl,-woff,85,-woff,84,-woff,134 \ + -nostdinc -I/usr/include -D_BSD_SIGNALS $CFLAGS" + CXXFLAGS="-O3 -OPT:Olimit=0:space=OFF \ + -woff 1009,1014,1110,1116,1183,1185,1188,1204,1230,1233,1355 \ + -Wl,-woff,85,-woff,84,-woff,134 \ + -nostdinc -I/usr/include -D_BSD_SIGNALS $CXXFLAGS" + ;; + alpha-dec-osf4.*) + # Mogul says DEC compilers take both -g and -O2 + CFLAGS=`echo $CFLAGS | sed -e 's/-g/-g3/'` + CFLAGS="-O2 $CFLAGS" + ;; + *) + ;; + esac + fi +fi + +dnl set squid required flags +if test "$GCC" = "yes"; then +dnl Guido Serassio (serassio@squid-cache.org) 20070811 +dnl Using the latest MinGW (gcc 3.4.5 + mingw-runtime 3.13) cannot build with +dnl -Werror -Wmissing-prototypes -Wmissing-declarations +dnl TODO: check if the problem will be present in any other newer MinGW release. + case "$host_os" in + mingw|mingw32) + SQUID_CFLAGS="-Wall -Wpointer-arith -Wwrite-strings -Wcomments" + ;; + *) + SQUID_CFLAGS="-Wall -Wpointer-arith -Wwrite-strings -Wmissing-prototypes -Wmissing-declarations -Wcomments" + ;; + esac + SQUID_CXXFLAGS="-Wall -Wpointer-arith -Wwrite-strings -Wcomments" + if test "$squid_disable_werror" = "no" + then + SQUID_CFLAGS="$SQUID_CFLAGS -Werror" + SQUID_CXXFLAGS="$SQUID_CXXFLAGS -Werror" + fi +else + SQUID_CFLAGS= + SQUID_CXXFLAGS= +fi +AC_SUBST(SQUID_CFLAGS) +AC_SUBST(SQUID_CXXFLAGS) + +if test "$GCC" = "yes"; then + AC_TEST_CHECKFORHUGEOBJECTS + SQUID_CXXFLAGS="$SQUID_CXXFLAGS $HUGE_OBJECT_FLAG" +fi + +dnl Set LDFLAGS +if test -z "$PRESET_LDFLAGS"; then + if test "$GCC" = "yes"; then + case "$host" in + *mips-sgi-irix6.*) + # Silence Linker warnings 84, 85 and 134 + LDFLAGS="-Wl,-woff,85 -Wl,-woff,84 -Wl,-woff,134 $LDFLAGS" + ;; + *) + # nothing + ;; + esac + else + case "$host" in + *) + # nothing + ;; + esac + fi +fi + +SquidInline="yes" + +AC_ARG_ENABLE(optimizations, + AS_HELP_STRING([--disable-optimizations],[Don't compile Squid with compiler optimizations enabled. + Optimization is good for production builds, but not + good for debugging. During development, use + --disable-optimizations to reduce compilation times + and allow easier debugging. This option implicitly + also enabled --disable-inline]), +[ if test "$enableval" = "no" ; then + AC_MSG_NOTICE([Disabling compiler optimizations (-O flag)]) + CFLAGS="`echo $CFLAGS | sed -e 's/-O[[0-9]]*//'`" + CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-O[[0-9]]*//'`" + SquidInline="no" + fi +]) + +AC_ARG_ENABLE(inline, + AS_HELP_STRING([--disable-inline],[Don't compile trivial methods as inline. Squid + is coded with much of the code able to be inlined. + Inlining is good for production builds, but not + good for development. During development, use + --disable-inline to reduce compilation times and + allow incremental builds to be quick. For + production builds, or load tests, use + --enable-inline to have squid make all trivial + methods inlinable by the compiler.]), +[ if test "$enableval" = "no" ; then + SquidInline="no" + fi +]) + +if test "$SquidInline" = "yes" ; then + AC_DEFINE(_SQUID_INLINE_, inline, [Keyword used by squid for inlining methods]) + AC_DEFINE(_USE_INLINE_,, [Include inline methods into header file]) +else + AC_MSG_NOTICE([Inlining optimization disabled]) + AC_DEFINE(_SQUID_INLINE_,, [Keyword used by squid for inlining methods]) +fi + +AC_ARG_ENABLE(debug-cbdata, + AS_HELP_STRING([--enable-debug-cbdata],[Provide some debug information in cbdata]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([cbdata debugging enabled]) + AC_DEFINE(CBDATA_DEBUG,1,[Enable for cbdata debug information]) + fi +]) + +dnl Nasty hack to get autoconf 2.64 on Linux to run. +dnl all other uses of RUN_IFELSE are wrapped inside CACHE_CHECK which breaks on 2.64 +AC_RUN_IFELSE([AC_LANG_SOURCE([[ int main(int argc, char **argv) { return 0; } ]])],[],[],[:]) + +dnl This is a developer only option.. developers know how to set defines +dnl +dnl AC_ARG_ENABLE(xmalloc-debug, +dnl [ --enable-xmalloc-debug Do some simple malloc debugging], +dnl [ if test "$enableval" = "yes" ; then +dnl AC_MSG_NOTICE([malloc debugging enabled]) +dnl AC_DEFINE(XMALLOC_DEBUG,1,[Define to do simple malloc debugging]) +dnl fi +dnl ]) + +dnl This is a developer only option.. developers know how to set defines +dnl +dnl AC_ARG_ENABLE(xmalloc-debug-trace, +dnl [ --enable-xmalloc-debug-trace +dnl Detailed trace of memory allocations], +dnl [ if test "$enableval" = "yes" ; then +dnl AC_MSG_NOTICE([malloc debug trace enabled]) +dnl AC_DEFINE(XMALLOC_TRACE,1,[Define to have a detailed trace of memory allocations]) +dnl AC_DEFINE(XMALLOC_DEBUG,1) +dnl fi +dnl ]) + +AC_ARG_ENABLE(xmalloc-statistics, + AS_HELP_STRING([--enable-xmalloc-statistics],[Show malloc statistics in status page]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([malloc statistics enabled]) + AC_DEFINE(XMALLOC_STATISTICS,1,[Define to have malloc statistics]) + fi +]) + +AC_ARG_ENABLE(async-io, + AS_HELP_STRING([--enable-async-io[=N_THREADS]],[Shorthand for "--with-aufs-threads=N_THREADS --with-pthreads + --enable-storeio=ufs,aufs"]), +[ case $enableval in + yes) + with_pthreads="yes" + STORE_MODULES="ufs aufs" + ;; + no) + ;; + *) + aufs_io_threads=$enableval + with_pthreads="yes" + STORE_MODULES="ufs aufs" + ;; + esac +]) + +AC_ARG_WITH(aufs-threads, + AS_HELP_STRING([--with-aufs-threads=N_THREADS],[Tune the number of worker threads for the aufs object store.]), +[ case $withval in + [[0-9]]*) + aufs_io_threads=$withval + ;; + *) + AC_MSG_ERROR(--with-aufs-threads expects a numeric argument) + ;; + esac +]) +if test "$aufs_io_threads"; then + AC_MSG_NOTICE([With $aufs_io_threads aufs threads]) + AC_DEFINE_UNQUOTED(AUFS_IO_THREADS,$aufs_io_threads, + [Defines how many threads aufs uses for I/O]) +fi + +AC_ARG_WITH(dl, + AS_HELP_STRING([--with-dl],[Use dynamic linking])) +if test "$with_dl" = "yes"; then + AC_MSG_NOTICE([With dl]) +fi + +AC_ARG_ENABLE(disk-io, + AS_HELP_STRING([--enable-disk-io="list of modules"],[Build support for the list of disk I/O modules. + Set without a value or omitted, all available modules will be built. + See src/DiskIO for a list of available modules, or + Programmers Guide section on DiskIO + for details on how to build your custom disk module]), +[ case $enableval in + yes) + for dir in $srcdir/src/DiskIO/*; do + module="`basename $dir`" + if test -d "$dir" && test "$module" != CVS; then + AC_MSG_NOTICE([Autodetected $module DiskIO module]) + MAYBE_DISK_MODULES="$MAYBE_DISK_MODULES $module" + fi + done + AC_DEFINE(USE_DISKIO,1,[DiskIO modules are expected to be available.]) + ;; + no) + AC_DEFINE(USE_DISKIO,0,[DiskIO modules are expected to be available.]) + ;; + *) + MAYBE_DISK_MODULES=" `echo $enableval| sed -e 's/,/ /g;s/ */ /g'` " + AC_DEFINE(USE_DISKIO,1,[DiskIO modules are expected to be available.]) + ;; + esac +], +[ if test -z "$MAYBE_DISK_MODULES"; then + AC_MSG_NOTICE([Enabling all available DiskIO modules (default)...]) + for dir in $srcdir/src/DiskIO/*; do + module="`basename $dir`" + if test -d "$dir" && test "$module" != CVS; then + AC_MSG_NOTICE([Autodetected $module DiskIO module]) + MAYBE_DISK_MODULES="$MAYBE_DISK_MODULES $module" + fi + done + AC_DEFINE(USE_DISKIO,1,[DiskIO modules are expected to be available.]) +fi ]) + +dnl Some autoconf.h defines we might enable later... +USE_AIOPS_WIN32=0 +use_aio= +use_diskthreads= +AIOLIB= + +dnl Setup the module paths etc. +FOUND_DISKIO_AIO= +FOUND_DISKIO_BLOCKING= +FOUND_DISKIO_DISKDAEMON= +FOUND_DISKIO_DISKTHREADS= +DISK_LIBS= +DISK_OS_LIBS= +DISK_MODULES= +DISK_LINKOBJS= +for module in $MAYBE_DISK_MODULES none; do + if test "$module" = "none"; then + continue + fi + if ! test -d $srcdir/src/DiskIO/$module; then + AC_MSG_ERROR(disk-io $module does not exist) + fi + case "$module" in + DiskDaemon) + if test "$FOUND_DISKIO_DISKDAEMON" = "yes" ; then + AC_MSG_ERROR([DiskIO DiskDaemon module listed twice.]) + fi + FOUND_DISKIO_DISKDAEMON="yes" + AC_MSG_NOTICE([Enabling DiskDaemon DiskIO module]) + DISK_LIBS="$DISK_LIBS libDiskDaemon.a" + DISK_MODULES="$DISK_MODULES DiskDaemon" + DISK_PROGRAMS="$DISK_PROGRAMS DiskIO/DiskDaemon/diskd" + DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/DiskDaemon/DiskDaemonDiskIOModule.o" + ;; + DiskThreads) + if test "$FOUND_DISKIO_DISKTHREADS" = "yes" ; then + AC_MSG_ERROR([DiskIO DiskThreads module listed twice.]) + fi + FOUND_DISKIO_DISKTHREADS="yes" + use_diskthreads="yes" + LIBPTHREADS= + SAVE_SQUID_CFLAGS="$SQUID_CFLAGS" + SAVE_SQUID_CXXFLAGS="$SQUID_CXXFLAGS" + AC_ARG_WITH(pthreads,AS_HELP_STRING([--without-pthreads],[Disable POSIX Threads])) + if test "$with_pthreads" != "no"; then + dnl TODO: this needs to be extended to handle more systems and better + dnl REF: http://www.openldap.org/lists/openldap-bugs/200006/msg00070.html + dnl REF: http://autoconf-archive.cryp.to/acx_pthread.html + case "$host" in + mingw|mingw32) + USE_AIOPS_WIN32=1 + AC_MSG_NOTICE([Windows threads support automatically enabled]) + ;; + i386-unknown-freebsd*) + SQUID_CFLAGS="$SQUID_CFLAGS -D_REENTRANT" + SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_REENTRANT" + if test "$GCC" = "yes" ; then + if test -z "$PRESET_LDFLAGS"; then + LDFLAGS="$LDFLAGS -pthread" + fi + fi + ;; + *-solaris2.*) + if test "$GCC" = "yes" ; then + SQUID_CFLAGS="$SQUID_CFLAGS -D_REENTRANT -pthreads" + SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_REENTRANT -pthreads" + AC_CHECK_LIB(pthread, main,[LIBPTHREADS="-lpthread"], + [ AC_MSG_NOTICE(pthread library required but cannot be found.) + use_diskthreads="no" + ]) + else + dnl test for -lpthread first. libc version is a stub apparently on Solaris. + SQUID_CFLAGS="$SQUID_CFLAGS -D_REENTRANT -lpthread" + SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_REENTRANT -lpthread" + AC_CHECK_LIB(pthread, main,[LIBPTHREADS="-lpthread"], + [ SQUID_CFLAGS="$SAVE_SQUID_CFLAGS -D_REENTRANT -lpthread -mt" + SQUID_CXXFLAGS="$SAVE_SQUID_CXXFLAGS -D_REENTRANT -lpthread -mt" + AC_CHECK_LIB(pthread, main,[LIBPTHREADS="-lpthread"], + [ AC_MSG_NOTICE(pthread library required but cannot be found.) + use_diskthreads="no" + ]) + ]) + fi + ;; + *) + SQUID_CFLAGS="$SQUID_CFLAGS -D_REENTRANT" + SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_REENTRANT" + AC_CHECK_LIB(pthread, main,[LIBPTHREADS="-lpthread"], + [ AC_MSG_NOTICE(pthread library required but cannot be found.) + use_diskthreads="no" + ]) + ;; + esac + else + AC_MSG_NOTICE([Native pthreads support manually disabled.]) + use_diskthreads="no" + fi + if test "$use_diskthreads" = "yes" ; then + AC_DEFINE(USE_DISKIO_DISKTHREADS, 1, [Whether pthreads support is needed. Automatic]) + AC_MSG_NOTICE([Enabling DiskThreads DiskIO module]) + DISK_LIBS="$DISK_LIBS libDiskThreads.a" + DISK_OS_LIBS="$DISK_OS_LIBS $LIBPTHREADS" + DISK_MODULES="$DISK_MODULES DiskThreads" + DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/DiskThreads/DiskThreadsDiskIOModule.o" + else + AC_DEFINE(USE_DISKIO_DISKTHREADS, 0, [Whether pthreads support is needed. Automatic]) + AC_MSG_NOTICE([Native pthreads support disabled. DiskThreads module automaticaly disabled.]) + SQUID_CFLAGS="$SAVE_SQUID_CFLAGS" + SQUID_CXXFLAGS="$SAVE_SQUID_CXXFLAGS" + fi + ;; + + AIO) + if test "$FOUND_DISKIO_AIO" = "yes" ; then + AC_MSG_ERROR([DiskIO AIO module listed twice.]) + fi + FOUND_DISKIO_AIO="yes" + dnl Check for POSIX AIO availability + use_aio="yes" + AIOLIB= + AC_ARG_WITH(aio, AS_HELP_STRING([--without-aio],[Do not use POSIX AIO. Default: auto-detect])) + if test "$with_aio" != "no"; then + have_aio_header=no + AC_CHECK_HEADERS(aio.h,[have_aio_header=yes]) + dnl On some systems POSIX AIO functions are in librt + dnl On some systems POSIX AIO functions are in libaio + AC_CHECK_LIB(rt,aio_read,[AIOLIB="-lrt"],AC_CHECK_LIB(aio,aio_read,[AIOLIB="-laio"],[])) + dnl Enable AIO if the library and headers are found + if test "$AIOLIB" != "" && test "$have_aio_header" = "yes"; then + AC_MSG_NOTICE([Native POSIX AIO support detected.]) + use_aio="yes" + else + dnl Windows does things differently. We provide wrappers. + dnl TODO: Windows really needs its own DiskIO module or its Overlaped IO + case "$host_os" in + mingw|mingw32) + use_aio="yes" + AC_MSG_NOTICE([Windows being built. Maybe-enable POSIX AIO.]) + ;; + *) + AC_MSG_NOTICE([Native POSIX AIO support not detected. AIO automatically disabled.]) + use_aio="no" + ;; + esac + fi + else + AC_MSG_NOTICE([POSIX AIO support manually disabled.]) + use_aio="no" + fi + dnl Use the POSIX AIO pieces if we actually need them. + if test "$use_aio" = "yes" ; then + AC_DEFINE(USE_DISKIO_AIO, 1, [Whether POSIX AIO support is needed. Automatic]) + DISK_MODULES="$DISK_MODULES AIO" + DISK_LIBS="$DISK_LIBS libAIO.a" + DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/AIO/AIODiskIOModule.o" + case "$host_os" in + mingw|mingw32) + USE_AIO_WIN32=1 + AC_MSG_NOTICE([Replacing AIO DiskIO module with: Windows overlapped I/O support]) + ;; + *) + AC_MSG_NOTICE([Enabling AIO DiskIO module]) + DISK_OS_LIBS="$DISK_OS_LIBS $AIOLIB" + ;; + esac + else + AC_DEFINE(USE_DISKIO_AIO, 0, [Whether POSIX AIO support is needed. Automatic]) + AC_MSG_NOTICE([AIO DiskIO Module disabled. Missing POSIX AIO support.]) + fi + ;; + + Blocking) + if test "$FOUND_DISKIO_BLOCKING" = "yes" ; then + AC_MSG_ERROR([DiskIO Blocking module listed twice.]) + fi + FOUND_DISKIO_BLOCKING="yes" + AC_MSG_NOTICE([Enabling Blocking DiskIO module]) + DISK_LIBS="$DISK_LIBS libBlocking.a" + DISK_MODULES="$DISK_MODULES Blocking" + DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/Blocking/BlockingDiskIOModule.o" + ;; + + *) + AC_MSG_NOTICE([Enabling $module DiskIO module]) + DISK_LIBS="$DISK_LIBS lib${module}.a" + DISK_MODULES="$DISK_MODULES ${module}" + DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/${module}/${module}DiskIOModule.o" + ;; + esac +done +AC_MSG_NOTICE([IO Modules built: $DISK_MODULES]) +AC_SUBST(DISK_MODULES) +AC_SUBST(DISK_LIBS) +AC_SUBST(DISK_PROGRAMS) +AC_SUBST(DISK_LINKOBJS) +AC_SUBST(DISK_OS_LIBS) +AM_CONDITIONAL([USE_AIOPS_WIN32], [test "$USE_AIOPS_WIN32" = 1]) +AM_CONDITIONAL([USE_AIO_WIN32], [test "$USE_AIO_WIN32" = 1]) + + +dnl Check what Storage formats are wanted. +dnl This version will error out with a message saying why if a required DiskIO is missing. +AC_ARG_ENABLE(storeio, + AS_HELP_STRING([--enable-storeio="list of modules"],[Build support for the list of store I/O modules. + The default is only to build the "ufs" module. + See src/fs for a list of available modules, or + Programmers Guide section + for details on how to build your custom store module]), +[ case $enableval in + yes) + for dir in $srcdir/src/fs/*; do + module="`basename $dir`" + if test -d "$dir" && test "$module" != CVS && test "$module" != coss; then + STORE_MODULES="$STORE_MODULES $module" + fi + done + ;; + no) + ;; + *) + STORE_MODULES="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" + ;; + esac +], +[ if test -z "$STORE_MODULES"; then + STORE_MODULES="ufs" + fi +]) +if test -n "$STORE_MODULES"; then + dnl ensure that all modules a) exist and b) only include once. + STORE_MODULES_FULL=$STORE_MODULES + STORE_MODULES= + for module in $STORE_MODULES_FULL; do + have_mod=`echo "$STORE_MODULES" | grep "$module"` + if test "$have_mod" != ""; then + AC_MSG_NOTICE([Removing duplicate $module from storeio]) + elif test -d $srcdir/src/fs/$module; then + STORE_MODULES="$STORE_MODULES $module" + else + AC_MSG_ERROR(storeio $module does not exist) + fi + done + AC_MSG_NOTICE([Store modules built: $STORE_MODULES]) +fi +for fs in $STORE_MODULES none; do + case "$fs" in + diskd) + if ! test "$FOUND_DISKIO_BLOCKING" = "yes" && ! test "$FOUND_DISKIO_DISKDAEMON" = "yes" ; then + AC_MSG_ERROR([Storage diskd module requires DiskIO modules: Blocking or DiskDaemon]) + fi + NEED_UFS="true" + ;; + aufs) + if ! test "$FOUND_DISKIO_BLOCKING" = "yes" && ! test "$FOUND_DISKIO_DISKTHREADS" = "yes" ; then + AC_MSG_ERROR([Storage diskd module requires DiskIO modules: Blocking or DiskThreads]) + fi + NEED_UFS="true" + ;; + coss) + if ! test "$FOUND_DISKIO_AIO" = "yes"; then + AC_MSG_ERROR([COSS requires POSIX AIO which is not available.]) + fi + dnl + dnl Automake om MinGW needs explicit exe extension + dnl for STORE_TESTS substition + dnl + STORE_TESTS="$STORE_TESTS tests/testCoss$EXEEXT" + ;; + ufs) + UFS_FOUND="true" + STORE_TESTS="$STORE_TESTS tests/testUfs$EXEEXT" + esac +done + +if test -z "$UFS_FOUND" && test -n "$NEED_UFS"; then + AC_MSG_NOTICE([Adding UFS, as it contains core logic for diskd and aufs]) + STORE_MODULES="$STORE_MODULES ufs" + dnl + dnl Automake om MinGW needs explicit exe extension + dnl for STORE_TESTS substition + dnl + STORE_TESTS="$STORE_TESTS tests/testUfs$EXEEXT" +fi + +AH_TEMPLATE(HAVE_FS_UFS, "Define to 1 if ufs filesystem module is build") +AH_TEMPLATE(HAVE_FS_AUFS, "Define to 1 if aufs filesystem module is build") +AH_TEMPLATE(HAVE_FS_DISKD, "Define to 1 if diskd filesystem module is build") +AH_TEMPLATE(HAVE_FS_COSS, "Define to 1 if coss filesystem module is build") + + +dnl got final STORE_MODULES, build library lists +dnl This list will not be needed when each fs library has its own Makefile +STORE_LIBS_TO_BUILD= +dnl File system libraries to link executables with. +dnl These are the same as STORE_LIBS_TO_BUILD, but with a path +STORE_LIBS_TO_ADD= +for fs in $STORE_MODULES; do + STORE_LIBS_TO_BUILD="$STORE_LIBS_TO_BUILD lib${fs}.la" + STORE_LIBS_TO_ADD="$STORE_LIBS_TO_ADD fs/lib${fs}.la" + HAVE_FS_TYPE=HAVE_FS_`echo $fs | sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'` + AC_DEFINE_UNQUOTED($HAVE_FS_TYPE, 1) +done + +AC_SUBST(STORE_LIBS_TO_BUILD) +AC_SUBST(STORE_LIBS_TO_ADD) +AC_SUBST(STORE_TESTS) + + +dnl At lest one removal policy is always needed. +dnl 'lru' removal policy is currently hard-coded by name for tests +dnl so we must set it as default. +REPL_POLICIES="lru" +AC_ARG_ENABLE(removal-policies, + AS_HELP_STRING([--enable-removal-policies="list of policies"],[Build support for the list of removal policies. + The default is only to build the "lru" module. + See src/repl for a list of available modules, or + Programmers Guide section 9.9 for details on how + to build your custom policy]), +[ case $enableval in + yes) + for dir in $srcdir/src/repl/*; do + module="`basename $dir`" + if test -d "$dir" && test "$module" != CVS && test "$module" != "lru"; then + REPL_POLICIES="$REPL_POLICIES $module" + fi + done + ;; + no) + ;; + *) + REPL_POLICIES="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" + ;; + esac +]) +if test -n "$REPL_POLICIES"; then + for module in $REPL_POLICIES; do + if test -d $srcdir/src/repl/$module; then + : + else + AC_MSG_ERROR(Removal policy $module does not exist) + fi + done + AC_MSG_NOTICE([Removal policies built: $REPL_POLICIES]) + REPL_OBJS="repl/lib`echo $REPL_POLICIES|sed -e 's% %.a repl/lib%g'`.a" + REPL_LIBS="`echo $REPL_OBJS|sed -e 's%repl/%%g'`" +fi +AC_SUBST(REPL_POLICIES) +AC_SUBST(REPL_OBJS) +AC_SUBST(REPL_LIBS) + +AM_CONDITIONAL(ENABLE_PINGER, false) +AC_ARG_ENABLE(icmp, + AS_HELP_STRING([--enable-icmp],[Enable ICMP pinging and Network Measurement]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([ICMP enabled]) + AC_DEFINE(USE_ICMP,1,[Define to use Squid's ICMP and Network Measurement features (highly recommended!)]) + AM_CONDITIONAL(ENABLE_PINGER, true) + fi +]) + +AM_CONDITIONAL(USE_DELAY_POOLS, false) +AC_ARG_ENABLE(delay-pools, + AS_HELP_STRING([--enable-delay-pools],[Enable delay pools to limit bandwidth usage]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Delay pools enabled]) + AC_DEFINE([DELAY_POOLS],1,[Traffic management via "delay pools".]) + AM_CONDITIONAL(USE_DELAY_POOLS, true,) + fi +]) + +dnl disable generic/common adaptation support by default +use_adaptation=no + +use_esi=yes +AC_ARG_ENABLE(esi, + AS_HELP_STRING([--enable-esi],[Enable ESI for accelerators. Benefits from expat or libxml2. + Enabling ESI will cause squid reverse proxies to be capable of the + Edge Acceleration Specification (www.esi.org).]), + use_esi=$enableval, use_esi=no) +HAVE_LIBEXPAT=0 +EXPATLIB= +HAVE_LIBXML2=0 +XMLLIB= +if test "$use_esi" = "yes" ; then + AC_MSG_NOTICE([Enabling ESI processor and Surrogate header support.]) + AC_DEFINE(USE_SQUID_ESI,1,[Compile the ESI processor and Surrogate header support]) + + AC_ARG_WITH(expat, AS_HELP_STRING([--without-expat],[Do not use expat for ESI. Default: auto-detect])) + if test "$with_expat" != "no" ; then + AC_CHECK_LIB([expat], [main], [EXPATLIB="-lexpat"; HAVE_LIBEXPAT=1]) + AC_CHECK_HEADERS([expat.h]) + AC_DEFINE_UNQUOTED(HAVE_LIBEXPAT, $HAVE_LIBEXPAT, [Define to 1 if you have the expat library]) + if test "$with_expat" = "yes" && test "$HAVE_LIBEXPAT" != "1" ; then + AC_MSG_ERROR([Required library expat is not able to be found.]) + fi + fi + + AC_ARG_WITH(libxml2, AS_HELP_STRING([--without-libxml2],[Do not use libxml2 for ESI. Default: auto-detect])) + if test "$with_libxml2" != "no" ; then + AC_CHECK_LIB([xml2], [main], [XMLLIB="-lxml2"; HAVE_LIBXML2=1]) + dnl Find the main header and include path... + AC_CHECK_HEADERS([libxml/parser.h], [], [ + SAVED_CPPFLAGS="$CPPFLAGS" + CPPFLAGS="-I/usr/include/libxml2 $CPPFLAGS" + unset ac_cv_header_libxml_parser_h + AC_CHECK_HEADERS([libxml/parser.h], [ac_cv_libxml2_include=yes], []) + CPPFLAGS="$SAVED_CPPFLAGS" + ]) + if test "x$ac_cv_libxml2_include" = "xyes"; then + SQUID_CXXFLAGS="-I/usr/include/libxml2 $SQUID_CXXFLAGS" + CPPFLAGS="-I/usr/include/libxml2 $CPPFLAGS" + fi + dnl Now that we know where to look find the other headers... + AC_CHECK_HEADERS(libxml/HTMLparser.h libxml/HTMLtree.h) + AC_DEFINE_UNQUOTED(HAVE_LIBXML2, $HAVE_LIBXML2, [Define to 1 if you have the libxml2 library]) + if test "$with_libxml2" = "yes" && test "$HAVE_LIBXML2" != "1" ; then + AC_MSG_ERROR([Required library libxml2 is not able to be found.]) + fi + fi + +else + AC_MSG_NOTICE([Disabling ESI processor and Surrogate header support.]) +fi +AM_CONDITIONAL(USE_ESI, test "$use_esi" = "yes") +AM_CONDITIONAL(HAVE_LIBEXPAT, test $HAVE_LIBEXPAT = 1) +AC_SUBST(EXPATLIB) +AM_CONDITIONAL(HAVE_LIBXML2, test $HAVE_LIBXML2 = 1) +AC_SUBST(XMLLIB) + +AM_CONDITIONAL(USE_ICAP_CLIENT, false) +AC_ARG_ENABLE(icap-client, + AS_HELP_STRING([--enable-icap-client],[Enable the ICAP client.]), + use_icap_client=$enableval, use_icap_client=no) +if test "$use_icap_client" = "yes" ; then + AC_DEFINE(ICAP_CLIENT,1,[Enable ICAP client features in Squid]) + AM_CONDITIONAL(USE_ICAP_CLIENT, true) + ICAP_LIBS="icap/libicap.la" + use_adaptation=yes +else + AC_DEFINE(ICAP_CLIENT,0,[Enable ICAP client features in Squid]) + ICAP_LIBS="" +fi +AC_SUBST(ICAP_LIBS) + +use_ecap=1 +AC_MSG_CHECKING(whether to support eCAP) +AC_ARG_ENABLE(ecap, + AS_HELP_STRING([--enable-ecap],[support loadable content adaptation modules]), + [ + case "${enableval}" in + yes) use_ecap=yes ;; + no) use_ecap=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for --enable-ecap) ;; + esac + AC_MSG_RESULT([$use_ecap, explicitly]) + ], + [ + use_ecap=no; + AC_MSG_RESULT([$use_ecap, implicitly]) + ] +) + +dnl Perform configuration consistency checks for eCAP +ECAPLIB="" +if test $use_ecap = yes; +then + dnl eCAP support requires loadable modules, which are enabled by default + if test "$use_loadable_modules" != "yes" + then + AC_MSG_ERROR([eCAP support requires loadable modules. Please do not use --disable-loadable-modules with --enable-ecap.]); + fi + + dnl eCAP support requires libecap + AC_CHECK_LIB([ecap], [main], + [ECAPLIB="-lecap"], + [AC_MSG_FAILURE([eCAP support requires libecap library, but no usable library was found])] + ) +fi + +AM_CONDITIONAL(USE_ECAP, test $use_ecap = yes) +if test $use_ecap = yes; +then + AC_DEFINE(USE_ECAP,1,[Enable eCAP support]) + ECAP_LIBS="ecap/libecap.la $ECAP_LIBS" + use_adaptation=yes +else + AC_DEFINE(USE_ECAP,0,[Disable eCAP support]) + ECAP_LIBS="" +fi +dnl convenience library +AC_SUBST(ECAP_LIBS) +dnl -lecap if needed +AC_SUBST(ECAPLIB) + + +dnl enable adaptation if requested by specific adaptation mechanisms +AM_CONDITIONAL(USE_ADAPTATION, test $use_adaptation = yes) +if test $use_adaptation = yes +then + AC_DEFINE(USE_ADAPTATION,1,[common adaptation support]) + ADAPTATION_LIBS="adaptation/libadaptation.la" +else + AC_DEFINE(USE_ADAPTATION,0,[common adaptation support]) + ADAPTATION_LIBS="" +fi +AC_SUBST(ADAPTATION_LIBS) + + +dnl This is a developer only option. Developers know how to set defines +dnl +dnl AC_ARG_ENABLE(mem-gen-trace, +dnl [ --enable-mem-gen-trace Do trace of memory stuff], +dnl [ if test "$enableval" = "yes" ; then +dnl AC_MSG_NOTICE([Memory trace (to file) enabled]) +dnl AC_DEFINE(MEM_GEN_TRACE,1,[Define for log file trace of mem alloc/free]) +dnl fi +dnl ]) + +AC_ARG_ENABLE(useragent-log, + AS_HELP_STRING([--enable-useragent-log],[Enable logging of User-Agent header]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([User-Agent logging enabled]) + AC_DEFINE(USE_USERAGENT_LOG,1,[If you want to log User-Agent request header values, define this. + By default, they are written to useragent.log in the Squid log + directory.]) + fi +]) + +AC_ARG_ENABLE(referer-log, + AS_HELP_STRING([--enable-referer-log],[Enable logging of Referer header]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Referer logging enabled]) + AC_DEFINE(USE_REFERER_LOG,1,[If you want to log Referer request header values, define this. + By default, they are written to referer.log in the Squid log + directory.]) + fi +]) + +USE_WCCP=1 +AC_ARG_ENABLE(wccp, + AS_HELP_STRING([--disable-wccp],[Disable Web Cache Coordination Protocol]), +[ if test "$enableval" = "no" ; then + AC_MSG_NOTICE([Web Cache Coordination Protocol disabled]) + USE_WCCP=0 + fi +]) +if test $USE_WCCP = 1; then + AC_DEFINE(USE_WCCP, 1, [Define to enable WCCP]) +fi + +USE_WCCPv2=1 +AC_ARG_ENABLE(wccpv2, + AS_HELP_STRING([--disable-wccpv2],[Disable Web Cache Coordination V2 Protocol]), +[ if test "$enableval" = "no" ; then + AC_MSG_NOTICE(["Web Cache Coordination V2 Protocol disabled]) + USE_WCCPv2=0 + fi +]) +if test $USE_WCCPv2 = 1; then + AC_DEFINE(USE_WCCPv2, 1, [Define to enable WCCP V2]) +fi + +AC_ARG_ENABLE(kill-parent-hack, + AS_HELP_STRING([--enable-kill-parent-hack],[Kill parent on shutdown]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Kill parent on shutdown]) + AC_DEFINE(KILL_PARENT_OPT,1,[A dangerous feature which causes Squid to kill its parent process upon receipt of SIGTERM or SIGINT. Use with caution.]) + fi +]) + +USE_SNMP=true +AC_ARG_ENABLE(snmp, + AS_HELP_STRING([--disable-snmp],[Disable SNMP monitoring support]), +[ if test "$enableval" = "no" ; then + AC_MSG_NOTICE([SNMP monitoring disabled]) + USE_SNMP= + fi +]) +if test x"$USE_SNMP" = xtrue; then + AC_DEFINE(SQUID_SNMP,1,[Define to enable SNMP monitoring of Squid]) + SNMPLIB='../snmplib/libsnmp.a' + makesnmplib=snmplib +fi +AM_CONDITIONAL(USE_SNMP, [test x$USE_SNMP = xtrue]) +AC_SUBST(SNMPLIB) +AC_SUBST(makesnmplib) + +AC_ARG_ENABLE(cachemgr-hostname, + AS_HELP_STRING([--enable-cachemgr-hostname=hostname],[Make cachemgr.cgi default to this host. + If unspecified, uses the name of the build-host]), +[ case $enableval in + yes) + AC_DEFINE(CACHEMGR_HOSTNAME,[getfullhostname()], + [If you are upset that the cachemgr.cgi form comes up with the hostname field blank, then define this to getfullhostname()]) + AC_MSG_NOTICE([Cachemgr default hostname == host where cachemgr runs]) + ;; + no) + : # Nothing to do.. + ;; + *) + AC_DEFINE_UNQUOTED(CACHEMGR_HOSTNAME,"${enableval}") + AC_MSG_NOTICE([Cachemgr default hostname set to ${enableval}]) + ;; + esac +]) + +AM_CONDITIONAL(ENABLE_ARP_ACL, false) +AC_ARG_ENABLE(arp-acl, + AS_HELP_STRING([--enable-arp-acl],[Enable use of ARP ACL lists (ether address)]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([ARP ACL lists enabled (ether address)]) + case "$host" in + *-linux-*) + ;; + *-solaris*) + ;; + *-freebsd*) + ;; + *-openbsd*) + ;; + *-netbsd*) + ;; + *-cygwin*) + LIBS="$LIBS -liphlpapi" + ;; + *-mingw*) + LIBS="$LIBS -liphlpapi" + ;; + *) + AC_MSG_WARN([ARP ACL support probably won't work on $host.]) + sleep 10 + ;; + esac + AC_DEFINE(USE_ARP_ACL,1,[Define this to include code which lets you specify access control elements based on ethernet hardware addresses. This code uses functions found in 4.4 BSD derviations (e.g. FreeBSD, ?).]) + AM_CONDITIONAL(ENABLE_ARP_ACL, true) + fi +]) + +USE_HTCP=true +AM_CONDITIONAL(ENABLE_HTCP, false) +AC_ARG_ENABLE(htcp, + AS_HELP_STRING([--disable-htcp],[Disable HTCP protocol support]), +[ if test "$enableval" = "no" ; then + AC_MSG_NOTICE([HTCP support disabled]) + fi +]) +if test x$USE_HTCP = xtrue; then + AC_DEFINE(USE_HTCP,1, [Define this to include code for the Hypertext Cache Protocol (HTCP)]) +fi +AM_CONDITIONAL(ENABLE_HTCP, [test x$USE_HTCP = xtrue]) + +dnl SSL is not enabled by default. +AM_CONDITIONAL(ENABLE_SSL, false) + +dnl Default is to use OpenSSL when available +AC_ARG_ENABLE(ssl, + AS_HELP_STRING([--enable-ssl],[Enable ssl gatewaying support using OpenSSL]), +[ if test "$enableval" != "no"; then + AC_MSG_NOTICE([SSL gatewaying using OpenSSL enabled]) + AC_DEFINE(USE_SSL,1,[Define this to include code for SSL encryption.]) + AM_CONDITIONAL(ENABLE_SSL, true) + case "$host_os" in + mingw|mingw32) + dnl Native Windows port of OpenSSL needs -lgdi32 + SSLLIB='-lssleay32 -leay32 -lgdi32' + ;; + *) + SSLLIB='-lssl -lcrypto' + ;; + esac + USE_OPENSSL=1 + fi +]) + +dnl User may specify OpenSSL is needed from a non-standard location +AC_ARG_WITH(openssl, + AS_HELP_STRING([--with-openssl{=PATH}],[Compile with the OpenSSL libraries. The path to + the OpenSSL development libraries and headers + installation can be specified if outside of the + system standard directories]), +[ + case "$with_openssl" in + yes) + USE_OPENSSL=1 + ;; + no) + USE_OPENSSL= + ;; + *) + SSLLIBDIR="$with_openssl/lib" + CPPFLAGS="-I$with_openssl/include $CPPFLAGS" + USE_OPENSSL=1 + esac +]) +if test -n "$USE_OPENSSL"; then + AC_MSG_NOTICE([Using OpenSSL MD5 implementation]) + AC_DEFINE(USE_OPENSSL,1,[Define this to make use of the OpenSSL libraries for MD5 calculation rather than Squid's own MD5 implementation or if building with SSL encryption (USE_SSL)]) + if test -z "$SSLLIB"; then + SSLLIB="-lcrypto" # for MD5 routines + fi + dnl This is a workaround for RedHat 9 brain damage.. + if test -d /usr/kerberos/include && test -z "$SSLLIBDIR" && test -f /usr/include/openssl/kssl.h; then + AC_MSG_NOTICE([OpenSSL depends on Kerberos]) + SSLLIBDIR="/usr/kerberos/lib" + CPPFLAGS="$CPPFLAGS -I/usr/kerberos/include" + fi +fi +if test -n "$SSLLIBDIR"; then + SSLLIB="-L$SSLLIBDIR $SSLLIB" +fi +AC_SUBST(SSLLIB) + + +AC_ARG_ENABLE(forw-via-db, + AS_HELP_STRING([--enable-forw-via-db],[Enable Forw/Via database]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([FORW-VIA enabled]) + AC_DEFINE(FORW_VIA_DB,1,[Enable Forw/Via database]) + fi +]) + +AC_ARG_ENABLE(cache-digests, + AS_HELP_STRING([--enable-cache-digests],[Use Cache Digests. + See http://wiki.squid-cache.org/SquidFaq/CacheDigests]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Cache Disgests enabled]) + AC_DEFINE(USE_CACHE_DIGESTS,1,[Use Cache Digests for locating objects in neighbor caches. This code is still semi-experimental.]) + fi +]) + +dnl Size of COSS memory buffer +AC_ARG_WITH(coss-membuf-size, + AS_HELP_STRING([--with-coss-membuf-size=size],[COSS membuf size (default 1048576 bytes)]), +[ if test -n "$withval" -a "x$withval" != "xno" ; then + AC_MSG_NOTICE([Setting COSS membuf size to $with_coss_membuf_size bytes]) + AC_DEFINE_UNQUOTED(COSS_MEMBUF_SZ, $with_coss_membuf_size,[Define if you want to set the COSS membuf size]) + fi +]) + +dnl check for netio plugin stuff + +dnl Enable poll() +disable_poll= +AC_ARG_ENABLE(poll, + AS_HELP_STRING([--disable-poll],[Disable poll(2) support.]), +[ + case "$enableval" in + yes) + AC_MSG_WARN([Forcing poll() to be enabled]) + SELECT_TYPE="poll" + ;; + no) + AC_MSG_WARN([Forcing poll() to be disabled]) + disable_poll=true + ;; + esac +]) + +dnl Enable select() +disable_select= +AC_ARG_ENABLE(select, + AS_HELP_STRING([--disable-select],[Disable select(2) support.]), +[ + case "$enableval" in + yes) + AC_MSG_WARN([Forcing select() to be enabled]) + SELECT_TYPE="select" + ;; + no) + AC_MSG_WARN([Forcing select() to be disabled]) + disable_select=true + ;; + esac +]) + +dnl Enable kqueue() +dnl kqueue support is still experiemntal and unstable. Not enabled by default. +disable_kqueue=true +AC_ARG_ENABLE(kqueue, + AS_HELP_STRING([--enable-kqueue],[Enable kqueue(2) support (experimental).]), +[ + case "$enableval" in + yes) + AC_MSG_WARN([Forcing kqueue() to be enabled]) + SELECT_TYPE="kqueue" + AC_CHECK_HEADERS([sys/event.h],[], + [ AC_MSG_ERROR([kqueue support requires sys/event.h header file.]) ]) + ;; + no) + AC_MSG_WARN([Forcing kqueue() to be disabled]) + disable_kqueue=true + ;; + *) + AC_CHECK_HEADERS([sys/event.h]) + ;; +esac +]) + +dnl Enable epoll() +disable_epoll= +force_epoll="no" +AC_ARG_ENABLE(epoll, + AS_HELP_STRING([--disable-epoll],[Disable Linux epoll(2) support.]), +[ + case "$enableval" in + yes) + AC_MSG_WARN([Forcing epoll() to be enabled]) + SELECT_TYPE="epoll" + force_epoll="yes" + ;; + no) + AC_MSG_WARN([Forcing epoll() to be disabled]) + disable_epoll=true + ;; +esac +]) +dnl auto-detect and verify epoll header and library present and working +if test -z "$disable_epoll"; then + + # Check for libepoll + EPOLL_LIB= + AC_CHECK_LIB(epoll, epoll_ctl, [EPOLL_LIBS="-lepoll"]) + AC_SUBST(EPOLL_LIBS) + + dnl on some systems it is provided by libc + dnl not to worry, the working test below will catch them + dnl and we don't want to force additional libraries + + + # Check for epoll_ctl, may need -lepoll + SAVED_LIBS="$LIBS" + LIBS="$LIBS $EPOLL_LIBS" + AC_CHECK_FUNCS(epoll_ctl) + LIBS="$SAVED_LIBS" + + dnl epoll requires sys/epoll.h + AC_CHECK_HEADERS([sys/epoll.h]) + + dnl Verify that epoll really works + if test $ac_cv_func_epoll_ctl = yes; then + AC_CACHE_CHECK(if epoll works, ac_cv_epoll_works, + AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include +#include +#include +int main(int argc, char **argv) +{ + int fd = epoll_create(256); + if (fd < 0) { + perror("epoll_create:"); + return 1; + } + return 0; +} + ]])],[ac_cv_epoll_works=yes],[ac_cv_epoll_works=no],[:])) + fi + + if test "$force_epoll" = "yes" && test "$ac_cv_epoll_works" = "no" ; then + AC_MSG_ERROR([Epoll does not work. Force-enabling it is not going to help.]) + fi +fi + +dnl Enable solaris /dev/poll +enable_devpoll=auto +AC_ARG_ENABLE(devpoll, + AS_HELP_STRING([--disable-devpoll],[Disable Solaris /dev/poll support.]), +[ + case "$enableval" in + yes) + AC_MSG_WARN([Forcing devpoll() to be enabled]) + SELECT_TYPE="devpoll" + enable_devpoll="yes" + ;; + no) + AC_MSG_WARN([Forcing devpoll() to be disabled]) + enable_devpoll=no + ;; +esac +]) +dnl auto-detect and verify devpoll header and library present and working +if test "x$enable_devpoll" != "xno"; then + + # Check for /dev/poll + AC_CHECK_FUNCS(ioctl) + AC_CHECK_FUNCS(write) + + dnl devpoll requires sys/devpoll.h + AC_CHECK_HEADERS([sys/devpoll.h],,[ + if test "x$enable_devpoll" = "xyes"; then + AC_MSG_ERROR([--enable-devpoll specified but /dev/poll headers not found]) + fi + enable_devpoll=no]) + + dnl Verify that /dev/poll really works + if test "$ac_cv_func_ioctl" = "yes" && test "$ac_cv_func_write" = "yes"; then + AC_CACHE_CHECK(if /dev/poll works, ac_cv_devpoll_works, + AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include +#include +#include +#include +int main(int argc, char **argv) +{ + int fd = open("/dev/poll", O_RDWR); + if (fd < 0) { + perror("devpoll_create:"); + return 1; + } + return 0; +} + ]])],[ac_cv_devpoll_works=yes],[ac_cv_devpoll_works=no],[:])) + fi + + if test "x$enable_devpoll" = "xyes" && test "x$ac_cv_devpoll_works" = "xno" ; then + AC_MSG_ERROR([/dev/poll does not work. Force-enabling it is not going to help.]) + fi +fi + +dnl Disable HTTP violations +http_violations=1 +AC_ARG_ENABLE(http-violations, + AS_HELP_STRING([--disable-http-violations],[This allows you to remove code which is known to + violate the HTTP protocol specification.]), +[ if test "$enableval" = "no" ; then + AC_MSG_NOTICE([Disabling HTTP Violations]) + http_violations=0 + fi +]) +if test $http_violations = 1; then + AC_DEFINE(HTTP_VIOLATIONS, 1,[By default (for now anyway) Squid includes options which allows the cache administrator to violate the HTTP protocol specification in terms of cache behaviour. Setting this to '0' will disable such code.]) +else + AC_DEFINE(HTTP_VIOLATIONS, 0) +fi + +dnl Enable IPFW Transparent Proxy +AC_ARG_ENABLE(ipfw-transparent, + AS_HELP_STRING([--enable-ipfw-transparent],[Enable Transparent Proxy support for systems + using FreeBSD IPFW style redirection.]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([IPFW Transparent Proxy enabled]) + AC_DEFINE(IPFW_TRANSPARENT,1,[Enable support for Transparent Proxy on systems using FreeBSD IPFW address redirection.]) + IPFW_TRANSPARENT="yes" + else + AC_DEFINE(IPFW_TRANSPARENT,0,[Enable support for Transparent Proxy on systems using FreeBSD IPFW address redirection.]) + fi +]) + +dnl Enable IP-Filter Transparent Proxy +AC_ARG_ENABLE(ipf-transparent, + AS_HELP_STRING([--enable-ipf-transparent],[Enable Transparent Proxy support for systems + using IP-Filter network address redirection.]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([IP-Filter Transparent Proxy enabled]) + AC_DEFINE(IPF_TRANSPARENT,1,[Enable support for Transparent Proxy on systems using IP-Filter address redirection. This provides "masquerading" support for non Linux system.]) + IPF_TRANSPARENT="yes" + else + AC_DEFINE(IPF_TRANSPARENT,0,[Enable support for Transparent Proxy on systems using IP-Filter address redirection. This provides "masquerading" support for non Linux system.]) + fi +]) + +dnl Enable PF Transparent Proxy +AC_ARG_ENABLE(pf-transparent, + AS_HELP_STRING([--enable-pf-transparent],[Enable Transparent Proxy support for systems + using PF network address redirection.]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([PF Transparent Proxy enabled]) + AC_DEFINE(PF_TRANSPARENT,1,[Enable support for Transparent Proxy on systems using PF address redirection. This provides "masquerading" support for OpenBSD.]) + PF_TRANSPARENT="yes" + else + AC_DEFINE(PF_TRANSPARENT,0,[Enable support for Transparent Proxy on systems using PF address redirection. This provides "masquerading" support for OpenBSD.]) + fi +]) + +dnl Enable Linux Netfilter Transparent Proxy +AC_ARG_ENABLE(linux-netfilter, + AS_HELP_STRING([--enable-linux-netfilter],[Enable Transparent Proxy support for Linux (Netfilter)]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Linux (Netfilter) Transparent Proxy enabled]) + AC_DEFINE(LINUX_NETFILTER,1,[Enable support for Transparent Proxy on Linux (Netfilter) systems]) + LINUX_NETFILTER="yes" + else + AC_DEFINE(LINUX_NETFILTER,0,[Enable support for Transparent Proxy on Linux (Netfilter) systems]) + fi +]) + +dnl Enable Large file support +buildmodel="" +needlargefiles= + +AC_ARG_WITH(large-files, + AS_HELP_STRING([--with-large-files],[Enable support for large files (logs etc).]), +[ if test "x$withval" = "xyes"; then + needlargefiles=1 + fi +]) + +dnl UNIX Build environment +dnl AS_HELP_STRING is not suited here because it doesn't allow to specify newlines +AC_ARG_WITH(build-environment, +[ --with-build-environment=model + The build environment to use. Normally one of + POSIX_V6_ILP32_OFF32 32 bits + POSIX_V6_ILP32_OFFBIG 32 bits with large file support + POSIX_V6_LP64_OFF64 64 bits + POSIX_V6_LPBIG_OFFBIG large pointers and files + XBS5_ILP32_OFF32 32 bits (legacy) + XBS5_ILP32_OFFBIG 32 bits with large file support (legacy) + XBS5_LP64_OFF64 64 bits (legacy) + XBS5_LPBIG_OFFBIG large pointers and files (legacy) + default The default for your OS], +[ case "$withval" in + yes|no) + AC_MSG_FAILURE(["--with-build-environment expects a build environment string as used by getconf]) + ;; + *) + buildmodel="$withval" + ;; + esac +]) + +if test $needlargefiles && test -z "$buildmodel"; then + for model in POSIX_V6_LPBIG_OFFBIG XBS5_LPBIG_OFFBIG POSIX_V6_LP64_OFF64 XBS5_LP64_OFF64 POSIX_V6_ILP32_OFFBIG XBS5_ILP32_OFFBIG; do + if test "`getconf _$model 2>/dev/null || true`" = 1 || test "`getconf $model 2>/dev/null || true`" ; then + buildmodel=$model + break + fi + done + if test -z "$buildmodel"; then + AC_MSG_WARN(["No suitable build environment found for large files. Trying to use _FILE_OFFSET_BITS=64]) + sleep 1 + fi +fi +case "$buildmodel" in +default|"") + if test "$needlargefiles"; then + AC_MSG_NOTICE([Enabling -D_FILE_OFFSET_BITS=64]) + CFLAGS="-D_FILE_OFFSET_BITS=64 $CFLAGS" + CXXFLAGS="-D_FILE_OFFSET_BITS=64 $CXXFLAGS" + fi + ;; +*) + AC_MSG_NOTICE([Using $buildmodel build environment]) + if test "`getconf _$buildmodel 2>/dev/null || true`" = 1 || test "`getconf $buildmodel 2>/dev/null || true`" ; then + : # All fine + else + AC_MSG_ERROR(Build environment $buildmodel not known to getconf.) + fi + CFLAGS="`getconf ${buildmodel}_CFLAGS` $CFLAGS" + CXXFLAGS="`getconf ${buildmodel}_CFLAGS` $CXXFLAGS" + LIBS="`getconf ${buildmodel}_LIBS` $LIBS" + LDFLAGS="`getconf ${buildmodel}_LDFLAGS` $LDFLAGS" + case "$host" in +dnl +dnl On Solaris getconf returns for CFLAGS -xarch=generic64, -Xa and -Usun options, and +dnl for LDFLAGS -xarch=generic64, but: +dnl "-Xa" is supported only by Sun cc, so we need to remove it when using gcc +dnl For gcc "-xarch=generic64" must be replaced with "-m64" +dnl The 'sun' define is needed by ipfilter includes, so we must remove "-Usun" + *-solaris*) + if test "$GCC" = "yes"; then + AC_MSG_NOTICE([Removing -Xa for gcc/g++ on $host]) + CFLAGS="`echo $CFLAGS | sed -e 's/-Xa//'`" + CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-Xa//'`" + AC_MSG_NOTICE([Replacing -xarch=generic64 with -m64 for gcc/g++ on $host]) + CFLAGS="`echo $CFLAGS | sed -e 's/-xarch=generic64/-m64/'`" + CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-xarch=generic64/-m64/'`" + LDFLAGS="`echo $LDFLAGS | sed -e 's/-xarch=generic64//'`" + fi + AC_MSG_NOTICE([Removing -Usun on $host]) + CFLAGS="`echo $CFLAGS | sed -e 's/-Usun//'`" + CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-Usun//'`" + ;; +dnl +dnl On Irix 6.x getconf returns options valid only for the SGI MipsPRO compiler, +dnl so we must adjust something to avoid gcc errors. +dnl On Irix 6.x 32/64 bit we must replace "-n32" with "-mabi=n32" in CFLAGS and +dnl remove "-n32" from LDFLAGS +dnl On Irix 6.x 64 bit we must replace "-64" with "-mabi=64" in CFLAGS and remove +dnl "-64" from LDFLAGS + *-sgi-irix6.*) + if test "$GCC" = "yes"; then + CFLAGS="`echo $CFLAGS | sed -e 's/-n32/-mabi=n32/'`" + CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-n32/-mabi=n32/'`" + LDFLAGS="`echo $LDFLAGS | sed -e 's/-n32//'`" + CFLAGS="`echo $CFLAGS | sed -e 's/-64/-mabi=64/'`" + CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-64/-mabi=64/'`" + LDFLAGS="`echo $LDFLAGS | sed -e 's/-64//'`" + fi + ;; + *) + ;; + esac + ;; +esac + +dnl Enable Linux transparent proxy support for obsolete TPROXY +AC_ARG_ENABLE(linux-tproxy, + AS_HELP_STRING([--enable-linux-tproxy],[Enable real Transparent Proxy support for Netfilter TPROXY + (version 2).]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Linux Netfilter/TPROXY v2 enabled]) + AC_DEFINE(LINUX_TPROXY2, 1, [Enable real Transparent Proxy support for Netfilter TPROXY v2.]) + LINUX_TPROXY2="yes" + if test -z "$LINUX_NETFILTER"; then + AC_MSG_NOTICE([Linux-Netfilter Transparent Proxy automatically enabled]) + LINUX_NETFILTER="yes" + fi + else + AC_DEFINE(LINUX_TPROXY2, 0, [Enable real Transparent Proxy support for Netfilter TPROXY v2.]) + fi +]) + +AM_CONDITIONAL(MAKE_LEAKFINDER, false) +dnl Enable Leak Finding Functions +AC_ARG_ENABLE(leakfinder, + AS_HELP_STRING([--enable-leakfinder],[Enable Leak Finding code. Enabling this alone + does nothing; you also have to modify the source + code to use the leak finding functions. Probably + Useful for hackers only.]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Leak-Finding enabled]) + AC_DEFINE(USE_LEAKFINDER,1,[Enable code for assisting in finding memory leaks. Hacker stuff only.]) + USE_LEAKFINDER="yes" + AM_CONDITIONAL(MAKE_LEAKFINDER, true) + fi +]) + +follow_xff=1 +AC_ARG_ENABLE(follow-x-forwarded-for, + AS_HELP_STRING([--enable-follow-x-forwarded-for],[Enable support for following the X-Forwarded-For + HTTP header to try to find the IP address of the + original or indirect client when a request has + been forwarded through other proxies.]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([follow X-Forwarded-For enabled]) + follow_xff=1 + fi +]) +if test $follow_xff = 1; then + AC_DEFINE(FOLLOW_X_FORWARDED_FOR, 1, [Enable following X-Forwarded-For headers]) +else + AC_DEFINE(FOLLOW_X_FORWARDED_FOR, 0) +fi + +use_ident=1 +AC_ARG_ENABLE(ident-lookups, + AS_HELP_STRING([--disable-ident-lookups],[This allows you to remove code that performs Ident (RFC 931) lookups.]), +[ if test "$enableval" = "no" ; then + AC_MSG_NOTICE([Disabling Ident Lookups]) + use_ident=0 + fi +]) +if test $use_ident = 1; then + AC_DEFINE(USE_IDENT, 1,[Compile in support for Ident (RFC 931) lookups? Enabled by default.]) +else + AC_DEFINE(USE_IDENT, 0) +fi + +AM_CONDITIONAL(USE_DNSSERVER, false) +use_dnsserver= +AC_ARG_ENABLE(internal-dns, + AS_HELP_STRING([--disable-internal-dns],[Prevents Squid from directly sending and receiving DNS messages, + and instead enables the old external 'dnsserver' processes.]), +[ if test "$enableval" = "no" ; then + AC_MSG_WARN([Disabling Internal DNS queries]) + use_dnsserver="yes" + fi +]) +if test "$use_dnsserver" = "yes"; then + AC_DEFINE(USE_DNSSERVERS,1,[Use dnsserver processes instead of the internal DNS protocol support]) + AM_CONDITIONAL(USE_DNSSERVER, true) +fi + +dnl Select Default hosts file location +AC_ARG_ENABLE(default-hostsfile, + AS_HELP_STRING([--enable-default-hostsfile=path],[Select default location for hosts file. + See hosts_file directive in squid.conf for details]), +[ + if test "$enableval" != "none" ; then + if test -f $enableval; then + OPT_DEFAULT_HOSTS=$enableval + else + AC_MSG_WARN([Unable to find $enableval]) + sleep 5 + fi + else + OPT_DEFAULT_HOSTS="none" + fi + AC_MSG_NOTICE([Default hosts file set to: $enableval]) +],[OPT_DEFAULT_HOSTS="/etc/hosts"]) +AC_SUBST(OPT_DEFAULT_HOSTS) + +dnl Select auth schemes modules to build +AC_ARG_ENABLE(auth, + AS_HELP_STRING([--enable-auth="list of auth scheme modules"],[Build support for the list of authentication schemes. + The default is to build support for the Basic scheme. + See src/auth for a list of available modules, or + Programmers Guide section authentication schemes + for details on how to build your custom auth scheme + module]), +[ case $enableval in + yes) + for dir in $srcdir/src/auth/*; do + module="`basename $dir`" + if test -d "$dir" && test "$module" != CVS; then + AUTH_MODULES="$AUTH_MODULES $module" + fi + done + ;; + no) + ;; + *) + AUTH_MODULES="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" + ;; + esac +], +[ if test -z "$AUTH_MODULES"; then + AUTH_MODULES="ntlm basic digest negotiate" + fi +]) +if test -n "$AUTH_MODULES"; then + for module in $AUTH_MODULES; do + if test -d $srcdir/src/auth/$module; then + : + else + AC_MSG_ERROR(Auth scheme $module does not exist) + fi + eval AUTH_MODULE_${module}=yes + done + AC_MSG_NOTICE([Auth scheme modules built: $AUTH_MODULES]) +else + AC_MSG_WARN([Auth scheme modules built: None]) +fi +dnl Authentication libraries to build +dnl This list will not be needed when each auth library has its own Makefile +AUTH_LIBS_TO_BUILD= +for module in $AUTH_MODULES; do + AUTH_LIBS_TO_BUILD="$AUTH_LIBS_TO_BUILD lib${module}.la" +done +AC_SUBST(AUTH_MODULES) +AC_SUBST(AUTH_LIBS_TO_BUILD) + +dnl bundled auth modules, in order to have handy defines for the cppunit testsuite +test -n "$AUTH_MODULE_basic" && AC_DEFINE([HAVE_AUTH_MODULE_BASIC],1,[Basic auth module is built]) +test -n "$AUTH_MODULE_digest" && AC_DEFINE([HAVE_AUTH_MODULE_DIGEST],1,[Digest auth module is built]) +test -n "$AUTH_MODULE_ntlm" && AC_DEFINE([HAVE_AUTH_MODULE_NTLM],1,[NTLM auth module is built]) +test -n "$AUTH_MODULE_negotiate" && AC_DEFINE([HAVE_AUTH_MODULE_NEGOTIATE],1,[Negotiate auth module is built]) + +dnl Select basic auth scheme helpers to build +if test -n "$AUTH_MODULE_basic"; then + BASIC_AUTH_HELPERS="all" +fi +AC_ARG_ENABLE(basic-auth-helpers, + AS_HELP_STRING([--enable-basic-auth-helpers="list of helpers"],[This option selects which basic scheme proxy_auth + helpers to build and install as part of the normal + build process. For a list of available + helpers see the helpers/basic_auth directory.]), +[ case "$enableval" in + yes) + BASIC_AUTH_HELPERS="all" + ;; + no) + BASIC_AUTH_HELPERS="" + ;; + *) + if test -z "$AUTH_MODULE_basic"; then + AC_MSG_WARN([Basic auth helpers selected without the basic scheme enabled]) + sleep 15 + fi + BASIC_AUTH_HELPERS="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" + ;; + esac +]) +if test "$BASIC_AUTH_HELPERS" = "all" ; then + BASIC_AUTH_HELPERS="" + for dir in $srcdir/helpers/basic_auth/*; do + helper="`basename $dir`" + if test -f $dir/config.test && sh $dir/config.test "$@"; then + BASIC_AUTH_HELPERS="$BASIC_AUTH_HELPERS $helper" + fi + done +fi +if test -n "$BASIC_AUTH_HELPERS"; then + for helper in $BASIC_AUTH_HELPERS; do + if test -d $srcdir/helpers/basic_auth/$helper; then + case $helper in + SASL) + require_sasl=yes + ;; + esac + else + AC_MSG_ERROR(Basic auth helper $helper does not exist) + fi + done + AC_MSG_NOTICE([Basic auth helpers built: $BASIC_AUTH_HELPERS]) +fi +AC_SUBST(BASIC_AUTH_HELPERS) + +dnl Select ntlm auth helpers to build +if test -n "$AUTH_MODULE_ntlm"; then + NTLM_AUTH_HELPERS="all" +fi +AC_ARG_ENABLE(ntlm-auth-helpers, + AS_HELP_STRING([--enable-ntlm-auth-helpers="list of helpers"],[This option selects which proxy_auth ntlm helpers + to build and install as part of the normal build + process. For a list of available helpers see + the helpers/ntlm_auth directory.]), +[ case "$enableval" in + yes) + NTLM_AUTH_HELPERS="all" + ;; + no) + NTLM_AUTH_HELPERS="" + ;; + *) + NTLM_AUTH_HELPERS="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" + ;; + esac +]) +if test "$NTLM_AUTH_HELPERS" = "all" ; then + NTLM_AUTH_HELPERS="" + for dir in $srcdir/helpers/ntlm_auth/*; do + helper="`basename $dir`" + if test -f $dir/config.test && sh $dir/config.test "$@"; then + NTLM_AUTH_HELPERS="$NTLM_AUTH_HELPERS $helper" + fi + done +fi +if test -n "$NTLM_AUTH_HELPERS"; then + for helper in $NTLM_AUTH_HELPERS; do + if test -d $srcdir/helpers/ntlm_auth/$helper; then + : + else + AC_MSG_ERROR(NTLM Auth helper $helper does not exist) + fi + done + AC_MSG_NOTICE([NTLM auth helpers built: $NTLM_AUTH_HELPERS]) +fi +AC_SUBST(NTLM_AUTH_HELPERS) + +dnl Select negotiate auth helpers to build +if test -n "$AUTH_MODULE_negotiate"; then + NEGOTIATE_AUTH_HELPERS="all" +fi +AC_ARG_ENABLE(negotiate-auth-helpers, + AS_HELP_STRING([--enable-negotiate-auth-helpers="list of helpers"],[This option selects which proxy_auth negotiate helpers + to build and install as part of the normal build + process. For a list of available helpers see + the helpers/negotiate_auth directory.]), +[ case "$enableval" in + yes) + NEGOTIATE_AUTH_HELPERS="all" + ;; + no) + NEGOTIATE_AUTH_HELPERS="" + ;; + *) + NEGOTIATE_AUTH_HELPERS="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" + ;; + esac +]) +if test "$NEGOTIATE_AUTH_HELPERS" = "all" ; then + NEGOTIATE_AUTH_HELPERS="" + for dir in $srcdir/helpers/negotiate_auth/*; do + helper="`basename $dir`" + if test -f $dir/config.test && sh $dir/config.test "$@"; then + NEGOTIATE_AUTH_HELPERS="$NEGOTIATE_AUTH_HELPERS $helper" + fi + done +fi +if test -n "$NEGOTIATE_AUTH_HELPERS"; then + for helper in $NEGOTIATE_AUTH_HELPERS; do + if test -d $srcdir/helpers/negotiate_auth/$helper; then + : + else + AC_MSG_ERROR(Negotiate Auth helper $helper does not exist) + fi + done + AC_MSG_NOTICE([Negotiate auth helpers built: $NEGOTIATE_AUTH_HELPERS]) +fi +AC_SUBST(NEGOTIATE_AUTH_HELPERS) +AC_CONFIG_SUBDIRS(helpers/negotiate_auth/squid_kerb_auth) + +dnl Select digest auth scheme helpers to build +if test -n "$AUTH_MODULE_digest"; then + DIGEST_AUTH_HELPERS=all +fi +AC_ARG_ENABLE(digest-auth-helpers, + AS_HELP_STRING([--enable-digest-auth-helpers="list of helpers"],[This option selects which digest scheme authentication + helpers to build and install as part of the normal build + process. For a list of available helpers see the + helpers/digest_auth directory.]), +[ case "$enableval" in + yes) + DIGEST_AUTH_HELPERS="all" + ;; + no) + DIGEST_AUTH_HELPERS="" + ;; + *) + DIGEST_AUTH_HELPERS="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" + ;; + esac +]) +if test "$DIGEST_AUTH_HELPERS" = "all" ; then + DIGEST_AUTH_HELPERS="" + for dir in $srcdir/helpers/digest_auth/*; do + helper="`basename $dir`" + if test -f $dir/config.test && sh $dir/config.test "$@"; then + DIGEST_AUTH_HELPERS="$DIGEST_AUTH_HELPERS $helper" + fi + done +fi +if test -n "$DIGEST_AUTH_HELPERS"; then + for helper in $DIGEST_AUTH_HELPERS; do + if test -f $srcdir/helpers/digest_auth/$helper/Makefile.in; then + : + else + AC_MSG_ERROR(digest auth helper $helper does not exist) + fi + done + AC_MSG_NOTICE([Digest auth helpers built: $DIGEST_AUTH_HELPERS]) +fi +AC_SUBST(DIGEST_AUTH_HELPERS) + +dnl Enable "NTLM fail open" +AC_ARG_ENABLE(ntlm-fail-open, + AS_HELP_STRING([--enable-ntlm-fail-open],[Enable NTLM fail open, where a helper that fails one of the + Authentication steps can allow squid to still authenticate + the user.]), +[ if test "$enableval" = "yes" ; then + AC_DEFINE(NTLM_FAIL_OPEN,1,[Define if NTLM is allowed to fail gracefully when a helper has problems. WARNING: This has security implications. DO NOT enable unless you KNOW you need it.]) + fi +]) + +dnl Select external_acl helpers to build +EXTERNAL_ACL_HELPERS=all +AC_ARG_ENABLE(external-acl-helpers, + AS_HELP_STRING([--enable-external-acl-helpers="list of helpers"],[This option selects which external_acl helpers to + build and install as part of the normal build + process. For a list of available helpers see the + helpers/external_acl directory.]), +[ case "$enableval" in + yes) + EXTERNAL_ACL_HELPERS=all + ;; + no) + EXTERNAL_ACL_HELPERS="" + ;; + *) + EXTERNAL_ACL_HELPERS="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" + ;; + esac +]) +if test "$EXTERNAL_ACL_HELPERS" = "all" ; then + EXTERNAL_ACL_HELPERS="" + for dir in $srcdir/helpers/external_acl/*; do + helper="`basename $dir`" + if test -f $dir/config.test && sh $dir/config.test "$@"; then + EXTERNAL_ACL_HELPERS="$EXTERNAL_ACL_HELPERS $helper" + fi + done +fi +if test -n "$EXTERNAL_ACL_HELPERS"; then + for helper in $EXTERNAL_ACL_HELPERS; do + if test -f $srcdir/helpers/external_acl/$helper/Makefile.in; then + : + else + AC_MSG_ERROR(external acl helper $helper does not exist) + fi + done + AC_MSG_NOTICE([External acl helpers built: $EXTERNAL_ACL_HELPERS]) +fi +AC_SUBST(EXTERNAL_ACL_HELPERS) + +AC_ARG_WITH(valgrind-debug, + AS_HELP_STRING([--with-valgrind-debug],[Include debug instrumentation for use with valgrind]), +[ case $withval in + yes) + valgrind=1 + ;; + no) + valgrind= + ;; + *) + CPPFLAGS="$CPPFLAGS -I${enableval}/include" + valgrind=1 + ;; + esac + if test $valgrind; then + AC_CHECK_HEADERS(valgrind/memcheck.h, + [ AC_DEFINE(WITH_VALGRIND, 1, [Valgrind memory debugger support]) + AC_MSG_NOTICE([Valgrind debug support enabled]) ], + [ AC_MSG_ERROR([Valgrind header not found. Valgrind support cannot be built.]) ] + ) + fi +]) + +dnl Disable "memPools" code +#AC_ARG_ENABLE(chunkedmempools, +# AS_HELP_STRING([--enable-chunkedmempools], +# [Enable experimental chunked memPools. Note that this option +# simply sets the default behaviour. Specific classes can override this +# at runtime, and only lib/MemPool.c needs to be altered +# to change the squid-wide default for all classes.]), [ +# if test "x$enableval" = "xyes" ; then +# AC_DEFINE(USE_CHUNKEDMEMPOOLS, 1, [Define to Enable chunked Memory Pools support (experimental)]) +# else +# AC_MSG_NOTICE([chunked memPools disabled]) +# AC_DEFINE(USE_CHUNKEDMEMPOOLS, 0, [Define to Enable chunked Memory Pools support (experimental)]) +# fi +#], +#[ AC_MSG_NOTICE([chunked memPools disabled]) + AC_DEFINE(USE_CHUNKEDMEMPOOLS, 0, [Define to Enable chunked Memory Pools support (experimental)]) +#]) + +dnl Enable WIN32 Service compile mode +AC_ARG_ENABLE(win32-service, + AS_HELP_STRING([--enable-win32-service],[Compile Squid as a WIN32 Service. + Works only on MS-Windows platforms (NT and up).]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Enabling WIN32 run service mode]) + AC_DEFINE(USE_WIN32_SERVICE,1,[Define Windows NT & Windows 2000 run service mode]) + fi +]) + + +dnl Check for Cyrus SASL +if test "$require_sasl" = "yes"; then + AC_CHECK_HEADERS(sasl/sasl.h sasl.h) + if test "$ac_cv_header_sasl_sasl_h" = "yes"; then + AC_MSG_NOTICE([using SASL2]) + LIBSASL="-lsasl2" + else + if test "$ac_cv_header_sasl_h" = "yes"; then + AC_MSG_NOTICE([using SASL]) + LIBSASL="-lsasl" + else + AC_MSG_ERROR(Neither SASL nor SASL2 found) + fi + fi + AC_SUBST(LIBSASL) +fi + +dnl Disable "unlinkd" code +AC_ARG_ENABLE(unlinkd, + AS_HELP_STRING([--disable-unlinkd],[Do not use unlinkd]), +[ if test "$enableval" = "no" ; then + use_unlinkd=no + else + use_unlinkd=yes + fi +],[ + # Here we should probably use some magic depending on the selected + # storage models + use_unlinkd=yes +]) +if test "$use_unlinkd" = "yes"; then + AC_MSG_NOTICE([unlinkd enabled]) + AC_DEFINE(USE_UNLINKD,1,[Define this if unlinkd is required (strongly recommended for ufs storage type)]) + AM_CONDITIONAL(ENABLE_UNLINKD, true) +else + AC_MSG_NOTICE([unlinkd disabled]) + AM_CONDITIONAL(ENABLE_UNLINKD, false) +fi + +dnl Enable backtraces on fatal errors +AC_ARG_ENABLE(stacktraces, + AS_HELP_STRING([--enable-stacktraces],[Enable automatic call backtrace on fatal errors]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Enabling automatic stack backtraces on fatal errors]) + AC_DEFINE(PRINT_STACK_TRACE, 1,[Print stacktraces on fatal errors]) + fi +]) + +AM_CONDITIONAL(ENABLE_XPROF_STATS, false) +dnl Enable USE_XPROF_STATS +AC_ARG_ENABLE(cpu-profiling, + AS_HELP_STRING([--enable-cpu-profiling],[Enable instrumentation to try and understand how CPU power + is spent by squid, by enabling specific probes in selected + functions. New probes can only be added by modifying the source code. + It is meant to help developers in optimizing performance + of Squid internal functions. + If you are not developer you shouldn't enable this, + as it slows squid down somewhat. See lib/Profiler.c for more details.]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Enabling cpu-profiling]) + AC_DEFINE(USE_XPROF_STATS, 1,[Define to enable CPU profiling within Squid]) + AM_CONDITIONAL(ENABLE_XPROF_STATS, true) + fi +]) + +dnl Enable X-Accelerator-Vary for Vary support within an accelerator setup +AC_ARG_ENABLE(x-accelerator-vary, + AS_HELP_STRING([--enable-x-accelerator-vary],[Enable support for the X-Accelerator-Vary + HTTP header. Can be used to indicate + variance within an accelerator setup. + Typically used together with other code + that adds custom HTTP headers to the requests.]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([Enabling support for X-Accelerator-Vary]) + AC_DEFINE(X_ACCELERATOR_VARY, 1, [Enable support for the X-Accelerator-Vary HTTP header]) + fi +]) + +AC_ARG_ENABLE(zph-qos, + AS_HELP_STRING([--enable-zph-qos],[Enable ZPH QOS support]), +[ if test "$enableval" = "yes" ; then + AC_MSG_NOTICE([ZPH QOS enabled]) + AC_DEFINE(USE_ZPH_QOS,1, + [ Define this to use Squid's ZPH (Zero Penalty Hit) QOS features. + When enabled, Squid will alter TOS field of HIT responses for better QOS on intermediate routing/shaping devices.]) + fi +]) + +dnl --with-maxfd present for compatibility with Squid-2. +dnl undocumented in ./configure --help to encourage using the Squid-3 directive. +AC_ARG_WITH(maxfd,, +[ + case ${withval} in + [[0-9]]*) + squid_filedescriptors_num=$withval + ;; + *) + AC_MSG_ERROR(--with-maxfd expects a numeric argument) + ;; + esac +]) +AC_ARG_WITH(filedescriptors, + AS_HELP_STRING([--with-filedescriptors=NUMBER],[Force squid to support NUMBER filedescriptors]), +[ + case ${withval} in + [[0-9]]*) + squid_filedescriptors_num=$withval + ;; + *) + AC_MSG_ERROR(--with-filedescriptors expects a numeric argument) + ;; + esac +]) + +AC_PATH_PROG(CPPUNITCONFIG, cppunit-config, false) +if $CPPUNITCONFIG --help >/dev/null; then + AC_MSG_NOTICE([using system installed cppunit]) + SQUID_CPPUNIT_LIBS="`$CPPUNITCONFIG --libs`" + SQUID_CPPUNIT_LA='' + SQUID_CPPUNIT_INC="`$CPPUNITCONFIG --cflags`" +else + AC_MSG_WARN([cppunit does not appear to be installed. squid does not require this, but code testing with 'make check' will fail.]) + SQUID_CPPUNIT_LA='' + SQUID_CPPUNIT_LIBS='' + SQUID_CPPUNIT_INC='' +fi + +AC_ARG_WITH(cppunit-basedir, + AS_HELP_STRING([--with-cppunit-basedir=PATH],[Path where the cppunit headers are libraries are found + for unit testing.]), +[ if test -f $withval/include/cppunit/TestCase.h; then + AC_MSG_NOTICE([Using cppunit includes from $withval]) + SQUID_CPPUNIT_INC="-I${withval}/include" + else + AC_MSG_ERROR(Cannot find cppunit at $withval) + fi + if test -f $withval/lib/libcppunit.la; then + AC_MSG_NOTICE([Using cppunit lib from $withval]) + SQUID_CPPUNIT_LA="${withval}/lib/libcppunit.la" + SQUID_CPPUNIT_LIBS='$(SQUID_CPPUNIT_LA)' + else + AC_MSG_ERROR(Cannot find cppunit at $withval) + fi +]) +AC_SUBST(SQUID_CPPUNIT_LIBS) +AC_SUBST(SQUID_CPPUNIT_LA) +AC_SUBST(SQUID_CPPUNIT_INC) + +# Force some compilers to use ANSI features +# +case "$host" in + alpha-dec-osf*) + if test "$ac_cv_prog_CC" = "cc" ; then + AC_MSG_NOTICE([adding '-std1' to cc args for $host]) + CC="cc -std1"; + ac_cv_prog_CC="$CC" + fi + ;; + *-hp-hpux*) + if test "$ac_cv_prog_CC" = "cc" ; then + AC_MSG_NOTICE([adding '-Ae' to cc args for $host]) + CC="cc -Ae"; + ac_cv_prog_CC="$CC" + fi + ;; +esac + +dnl Check for programs +AC_PROG_CPP +AC_PROG_INSTALL +AC_PROG_LN_S +AC_PATH_PROG(SH, sh, /bin/sh) +AC_PATH_PROG(FALSE, false, /usr/bin/false) +AC_PATH_PROG(TRUE, true, /usr/bin/true) +AC_PATH_PROG(MV, mv, $FALSE) +AC_PATH_PROG(MKDIR, mkdir, $FALSE) +AC_PATH_PROG(LN, ln, cp) +AC_PATH_PROG(CHMOD, chmod, $FALSE) + +AC_PATH_PROG(RM, rm, $FALSE) +dnl Libtool 2.2.6 requires: rm -f +RM="$RM -f" + +dnl automake handles this AC_PATH_PROG(MAKEDEPEND, makedepend, $TRUE) +AC_PROG_EGREP + +AC_PATH_PROG(PERL, perl, none) +if test "$ac_cv_path_PERL" = "none"; then + AC_MSG_FAILURE([Perl is required to compile Squid. Please install Perl and then re-run configure ]) +fi + +case "$host" in + *-hp-hpux*) + AC_MSG_NOTICE([Disabling 'ranlib' for HP-UX...]) + RANLIB=":" + ;; +esac + +dnl set $(AR) +AC_PATH_PROG(AR, ar, $FALSE) +AR_R="$AR r" +case "$host" in + *-next-nextstep3) + AR="libtool -o" + ;; +esac +AC_SUBST(AR_R) + +dnl Check for headers +AC_HEADER_DIRENT +AC_HEADER_STDC + +AC_CHECK_HEADERS( \ + arpa/inet.h \ + arpa/nameser.h \ + assert.h \ + bstring.h \ + cassert \ + crypt.h \ + cstring \ + ctype.h \ + errno.h \ + execinfo.h \ + fcntl.h \ + fnmatch.h \ + getopt.h \ + glob.h \ + gnumalloc.h \ + grp.h \ + iosfwd \ + iomanip \ + iostream \ + ip_compat.h \ + ip_fil_compat.h \ + ip_fil.h \ + ip_nat.h \ + ipl.h \ + libc.h \ + libgen.h \ + limits.h \ + linux/posix_types.h \ + linux/types.h \ + machine/byte_swap.h \ + malloc.h \ + math.h \ + memory.h \ + mount.h \ + netdb.h \ + netinet/in.h \ + netinet/in_systm.h \ + netinet/ip_fil_compat.h \ + openssl/err.h \ + openssl/md5.h \ + openssl/ssl.h \ + openssl/x509v3.h \ + netinet/tcp.h \ + openssl/engine.h \ + ostream \ + paths.h \ + poll.h \ + pwd.h \ + shadow.h \ + regex.h \ + sched.h \ + security/pam_appl.h \ + signal.h \ + sstream \ + stdarg.h \ + stddef.h \ + stdexcept \ + stdio.h \ + stdlib.h \ + string \ + string.h \ + strings.h \ + sys/bitypes.h \ + sys/bswap.h \ + sys/endian.h \ + sys/file.h \ + sys/ioctl.h \ + sys/param.h \ + sys/prctl.h \ + sys/md5.h \ + sys/msg.h \ + sys/resource.h \ + sys/select.h\ + sys/socket.h \ + sys/stat.h \ + sys/statvfs.h \ + syscall.h \ + sys/syscall.h \ + sys/time.h \ + sys/types.h \ + sys/un.h \ + sys/vfs.h \ + sys/wait.h \ + syslog.h \ + time.h \ + unistd.h \ + utime.h \ + varargs.h \ + byteswap.h \ + glib.h \ + stdint.h \ + inttypes.h \ + grp.h \ + db.h \ + db_185.h +) + +AC_CHECK_HEADERS( + linux/netfilter_ipv4.h \ + linux/netfilter_ipv4/ip_tproxy.h \ +,,, +SQUID_DEFAULT_INCLUDES +#if HAVE_LIMITS_H +#include +#endif +/* Netfilter ip(6)tables v1.4.0 has broken headers */ +#if HAVE_NETINET_IN_H +#include +#endif +) + +dnl *BSD dont include the depenencies for all their net/ and netinet/ files +dnl We must include a few basic type headers for them to work. +AC_CHECK_HEADERS( \ + net/if.h \ + netinet/if_ether.h\ + netinet/icmp6.h \ + netinet/in.h \ + netinet/ip.h \ + netinet/ip6.h \ + netinet/ip_compat.h\ + netinet/ip_fil_compat.h\ + netinet/ip_fil.h\ + netinet/ip_icmp.h \ + netinet/ipl.h \ + netinet/ip_nat.h\ + net/pf/pfvar.h \ + net/pfvar.h \ + sys/mount.h\ + resolv.h \ +,,, +SQUID_BSDNET_INCLUDES) + +AC_C_CONST +AC_C_BIGENDIAN + +AC_STRUCT_TM +AC_CHECK_MEMBERS([struct tm.tm_gmtoff],,,[ +#if TM_IN_SYS_TIME +#if HAVE_SYS_TIME_H +#include +#endif +#elif HAVE_TIME_H +#include +#endif +]) + +AC_CHECK_TYPE(struct mallinfo,AC_DEFINE(HAVE_STRUCT_MALLINFO,1,[The system provides struct mallinfo]),,[ +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_MALLOC_H +#include +#endif]) + +AC_CHECK_MEMBERS([struct mallinfo.mxfast],,,[ +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_MALLOC_H +#include +#endif]) + +dnl Override rusage() detect on MinGW because is emulated in source code +case "$host_os" in + mingw|mingw32) + AC_DEFINE(HAVE_STRUCT_RUSAGE) + ac_cv_func_getrusage='yes' + AC_MSG_NOTICE([Using own rusage on Windows.]) + ;; + *) + AC_CHECK_TYPE(struct rusage,AC_DEFINE(HAVE_STRUCT_RUSAGE,1,[The system provides struct rusage]),,[ +#if HAVE_SYS_TIME_H +#include +#endif +#if HAVE_SYS_RESOURCE_H +#include +#endif]) + ;; +esac + +AC_CHECK_MEMBERS([struct iphdr.ip_hl],,,[ +#if HAVE_SYS_TYPES_H +#include +#endif +#include +#include +#include +#if defined (__linux__) || defined (__CYGWIN__) +#define ip_hl ihl +#endif +#ifndef __linux__ +#ifndef __CYGWIN__ +#define iphdr ip +#endif +#endif]) + +dnl Check for typedefs +AC_CHECK_SIZEOF(void *) + +dnl 8 bit integers - int8_t +dnl if this is defined we trust it to be 8 bits +AC_CHECK_TYPE(int8_t,[ + AC_CHECK_SIZEOF(int8_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_INT8_T,1,[int8_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #1 +AC_CHECK_TYPE(char,[ + AC_CHECK_SIZEOF(char,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_CHAR,1,[char is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl unsigned 8 bit ints - u_int8_t +dnl if this is defined we trust it to be 8 bits +AC_CHECK_TYPE(u_int8_t,[ + AC_CHECK_SIZEOF(u_int8_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_U_INT8_T,1,[u_int8_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #1 +dnl if this is defined we trust it to be 8 bits +AC_CHECK_TYPE(uint8_t,[ + AC_CHECK_SIZEOF(uint8_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_UINT8_T,1,[uint8_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl 16 bit integers - int16_t +dnl if this is defined we trust it to be 16 bits +AC_CHECK_TYPE(int16_t,[ + AC_CHECK_SIZEOF(int16_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_INT16_T,1,[int16_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #1 +AC_CHECK_TYPE(short,[ + AC_CHECK_SIZEOF(short,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_SHORT,1,[short is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #2 +AC_CHECK_TYPE(int,[ + AC_CHECK_SIZEOF(int,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_INT,1,[int is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl unsigned 16 bit ints - u_int16_t +dnl if this is defined we trust it to be 16 bits +AC_CHECK_TYPE(u_int16_t,[ + AC_CHECK_SIZEOF(u_int16_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_U_INT16_T,1,[u_int16_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #1 +dnl if this is defined we trust it to be 16 bits +AC_CHECK_TYPE(uint16_t,[ + AC_CHECK_SIZEOF(uint16_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_UINT16_T,1,[uint16_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl 32 bit signed int - int32_t +dnl if this is defined we trust it to be 32 bits +AC_CHECK_TYPE(int32_t,[ + AC_CHECK_SIZEOF(int32_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_INT32_T,1,[int32_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #1 +AC_CHECK_TYPE(long,[ + AC_CHECK_SIZEOF(long,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_LONG,1,[long is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl 32 bit unsigned int - u_int32_t +dnl if this is defined we trust it to be 32 bits +AC_CHECK_TYPE(u_int32_t,[ + AC_CHECK_SIZEOF(u_int32_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_U_INT32_T,1,[u_int32_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #1 +dnl if this is defined we trust it to be 32 bits +AC_CHECK_TYPE(uint32_t,[ + AC_CHECK_SIZEOF(uint32_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_UINT32_T,1,[uint32_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl 64 bit signed - int64_t +dnl if this is defind we trust it to be 64 bits +AC_CHECK_TYPE(int64_t,[ + AC_CHECK_SIZEOF(int64_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_INT64_T,1,[int64_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #1 +dnl if this is defind we trust it to be 64 bits +AC_CHECK_TYPE(__int64,[ + AC_CHECK_SIZEOF(__int64,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE___INT64,1,[__int64 is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #2 +AC_CHECK_TYPE(long long,[ + AC_CHECK_SIZEOF(long long,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_LONG_LONG,1,[long long is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl 64 bit unsigned - u_int64_t +dnl if this is defind we trust it to be 64 bits +AC_CHECK_TYPE(u_int64_t,[ + AC_CHECK_SIZEOF(u_int64_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_U_INT64_T,1,[u_int64_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) + +dnl fallback #1 +dnl if this is defind we trust it to be 64 bits +AC_CHECK_TYPE(uint64_t,[ + AC_CHECK_SIZEOF(uint64_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_UINT64_T,1,[uint64_t is defined in system headers]) + ],,SQUID_DEFAULT_INCLUDES) +#need the define for overflow checks +AC_CHECK_SIZEOF(off_t) + +dnl On Solaris 9 x86, gcc may includes a "fixed" set of old system include files +dnl that is incompatible with the updated Solaris header files. +dnl For this reason, we must check if pad128_t and upad128_t are defined. +AC_CHECK_TYPE(pad128_t, + AC_DEFINE(HAVE_PAD128_T,1,[pad128_t is defined in system headers]), + ,SQUID_DEFAULT_INCLUDES) + +AC_CHECK_TYPE(upad128_t, + AC_DEFINE(HAVE_UPAD128_T,1,[upad128_t is defined in system headers]), + ,SQUID_DEFAULT_INCLUDES) + +AC_CHECK_TYPE(pid_t, AC_DEFINE(HAVE_PID_T,1,[pid_t is defined by the system headers]),,SQUID_DEFAULT_INCLUDES) +AC_CHECK_TYPE(size_t, [AC_CHECK_SIZEOF(size_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_SIZE_T,1,[size_t is defined by the system headers])],,SQUID_DEFAULT_INCLUDES) +AC_CHECK_TYPE(ssize_t, AC_DEFINE(HAVE_SSIZE_T,1,[ssize_t is defined by the system headers]),,SQUID_DEFAULT_INCLUDES) +AC_CHECK_TYPE(off_t,[ AC_CHECK_SIZEOF(off_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) + AC_DEFINE(HAVE_OFF_T,1,[off_t is defined by the system headers])],,SQUID_DEFAULT_INCLUDES) +AC_CHECK_TYPE(mode_t, AC_DEFINE(HAVE_MODE_T,1,[mode_t is defined by the system headers]),,SQUID_DEFAULT_INCLUDES) +AC_CHECK_TYPE(fd_mask, AC_DEFINE(HAVE_FD_MASK,1,[fd_mask is defined by the system headers]),,SQUID_DEFAULT_INCLUDES) + +dnl On AIX uchar is pre-defined by the headers +AC_CHECK_TYPE(uchar,[AC_DEFINE([HAVE_UCHAR],[1],[uchar is defined in system headers])],,SQUID_DEFAULT_INCLUDES) + +dnl Check for special functions +AC_FUNC_ALLOCA + +AC_CHECK_TYPE(socklen_t,AC_DEFINE(HAVE_SOCKLEN_T,1,[socklen_t is defined by the system headers]),,[ +#include +#include +#if STDC_HEADERS +#include +#include +#endif]) + +dnl Check for libcap header (assume its not broken unless +use_libcap=auto +AC_ARG_WITH(libcap, AS_HELP_STRING([--without-libcap],[disable usage of Linux capabilities library to control privileges]), +[ if test "x$withval" = "xyes" ; then + AC_MSG_RESULT(libcap forced enabled) + use_libcap=yes + else + AC_MSG_RESULT(libcap forced disabled) + use_libcap=no + fi +]) +if test "x$use_libcap" != "xno"; then + # cap_clear_flag is the most recent libcap function we require + AC_CHECK_LIB(cap, cap_clear_flag) + if test "x$ac_cv_lib_cap_cap_clear_flag" = xyes; then + use_libcap=yes + else + if test "x$use_libcap" = "xyes"; then + AC_MSG_ERROR([libcap forced enabled but not available or not usable, requires libcap-2.09 or later]) + fi + use_libcap=no + fi +fi + +if test "x$use_libcap" = "xyes"; then + AC_DEFINE(USE_LIBCAP, 1, [use libcap to set capabilities required for TPROXY]) + dnl Check for libcap headader breakage. + AC_CHECK_HEADERS(sys/capability.h) + AC_CACHE_CHECK([for operational libcap2 headers], squid_cv_sys_capability_works, + AC_LINK_IFELSE([AC_LANG_PROGRAM([[ +#include +#include +#include +]], [[ +capget(NULL, NULL); +capset(NULL, NULL); + ]])],[squid_cv_sys_capability_works=yes],[squid_cv_sys_capability_works=no]) + ) + if test x$squid_cv_sys_capability_works != xyes; then + AC_DEFINE([LIBCAP_BROKEN],1,[if libcap2 headers are broken and clashing with glibc]) + fi +fi + + +AC_CHECK_TYPE(mtyp_t,AC_DEFINE(HAVE_MTYP_T,1,[mtyp_t is defined by the system headers]),,[#include +#include +#include ]) + +dnl Check for needed libraries +AC_SEARCH_LIBS([gethostbyname],[nsl resolv bind]) +AC_SEARCH_LIBS([res_init],[resolv]) +AC_SEARCH_LIBS([bind],[socket]) +AC_SEARCH_LIBS([opcom_stack_trace],[opcom_stack]) +AC_SEARCH_LIBS([strlcpy], [bsd]) +AC_SEARCH_LIBS([yp_match], [nsl nss_nis nss_nisplus]) +dnl Check for Winsock only on MinGW, on Cygwin we must use emulated BSD socket API +case "$host_os" in + mingw|mingw32) + AC_MSG_CHECKING(for winsock) + save_LIBS="$LIBS" + for curlib in ws2_32 wsock32; do + LIBS="$LIBS -l$curlib" + AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ + socket(0,0,0); + select(0,NULL,NULL,NULL,NULL); + closesocket(0); + gethostname(NULL,0); + ]])],[have_winsock=yes],[have_winsock=no]) + + if test $have_winsock = yes; then + ac_cv_func_select='yes' + if test $curlib = ws2_32; then + have_winsock=winsock2 + fi + break + fi + LIBS="$save_LIBS" + done + AC_MSG_RESULT($have_winsock) + if test $have_winsock = winsock2; then + AC_CHECK_HEADERS(winsock2.h) + else + AC_CHECK_HEADERS(winsock.h) + fi + ;; +esac + +dnl Ripped from the Samba sources +AC_CACHE_CHECK([for unix domain sockets],squid_cv_unixsocket, [ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#include +#include +#include +#include +#include ]], [[ + struct sockaddr_un sunaddr; + sunaddr.sun_family = AF_UNIX; +]])],[squid_cv_unixsocket=yes],[squid_cv_unixsocket=no])]) +if test x"$squid_cv_unixsocket" = x"yes"; then + AC_DEFINE(HAVE_UNIXSOCKET,1,[Do we have unix sockets? (required for the winbind ntlm helper]) +fi +dnl end rip + + AC_CHECK_LIB(gnumalloc, main) + if test "$ac_cv_lib_gnumalloc_main" = "yes"; then + AC_MSG_NOTICE([Disabling extended malloc functions when using gnumalloc]) + ac_cv_func_mallinfo=no + ac_cv_func_mallocblksize=no + ac_cv_func_mallopt=no + else + case "$host" in + *-sun-solaris*) + AC_MSG_NOTICE([skipping libmalloc check for $host]) + ;; + i386-*-freebsd*) + AC_MSG_NOTICE([skipping libmalloc check for $host]) + ;; + *) + + AC_CHECK_LIB(malloc, main) + ;; + esac + fi + +AC_CHECK_LIB(regex, main, [REGEXLIB="-lregex"]) +case "$host_os" in +mingw|mingw32) + AC_MSG_NOTICE([Use MSVCRT for math functions.]) + ;; + *) + dnl rint() and log() are only used in old C code for now. + AC_LANG_PUSH([C]) + AC_SEARCH_LIBS([rint],[m]) + AC_SEARCH_LIBS([log],[m]) + AC_LANG_POP([C]) + ;; +esac + +dnl Enable IPv6 support +AC_MSG_CHECKING([whether to enable IPv6]) +use_ipng=yes +AC_ARG_ENABLE(ipv6, + AS_HELP_STRING([--disable-ipv6],[Disable IPv6 support. The default is to probe system capabilities on startup.]), +[ case $enableval in + yes|no) + use_ipng=$enableval + ;; + *) + ;; + esac +]) +AC_MSG_RESULT($use_ipng) + +if test "$use_ipng" != "no"; then + AC_DEFINE(USE_IPV6,1,[Enable support for IPv6 ]) +else + AC_DEFINE(USE_IPV6,0,[Enable support for IPv6 ]) +fi + +dnl Check whether this OS defines sin6_len as a member of sockaddr_in6 as a backup to ss_len +AC_CACHE_CHECK([for sin6_len field in struct sockaddr_in6], + ac_cv_have_sin6_len_in_struct_sai, [ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#include +#include +#include + ]], [[ struct sockaddr_in6 s; s.sin6_len = 1; ]])],[ ac_cv_have_sin6_len_in_struct_sai="yes" ],[ ac_cv_have_sin6_len_in_struct_sai="no" + ]) +]) +if test "x$ac_cv_have_sin6_len_in_struct_sai" = "xyes" ; then + AC_DEFINE(HAVE_SIN6_LEN_IN_SAI, 1, [Does struct sockaddr_in6 have sin6_len? 1: Yes, 0: No]) +else + AC_DEFINE(HAVE_SIN6_LEN_IN_SAI, 0, [Does struct sockaddr_in6 have sin6_len? 1: Yes, 0: No]) +fi + +dnl Check whether this OS defines ss_len as a member of sockaddr_storage +AC_CACHE_CHECK([for ss_len field in struct sockaddr_storage], + ac_cv_have_ss_len_in_struct_ss, [ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#include +#include +#include + ]], [[ struct sockaddr_storage s; s.ss_len = 1; ]])],[ ac_cv_have_ss_len_in_struct_ss="yes" ],[ ac_cv_have_ss_len_in_struct_ss="no" + ]) +]) +if test "x$ac_cv_have_ss_len_in_struct_ss" = "xyes" ; then + AC_DEFINE(HAVE_SS_LEN_IN_SS, 1, [Does struct sockaddr_storage have ss_len? 1: Yes, 0: No]) +else + AC_DEFINE(HAVE_SS_LEN_IN_SS, 0, [Does struct sockaddr_storage have ss_len? 1: Yes, 0: No]) +fi + +dnl Check whether this OS defines sin_len as a member of sockaddr_in as a backup to ss_len +AC_CACHE_CHECK([for sin_len field in struct sockaddr_in], + ac_cv_have_sin_len_in_struct_sai, [ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#include +#include +#include + ]], [[ struct sockaddr_in s; s.sin_len = 1; ]])],[ ac_cv_have_sin_len_in_struct_sai="yes" ],[ ac_cv_have_sin_len_in_struct_sai="no" + ]) +]) +if test "x$ac_cv_have_sin_len_in_struct_sai" = "xyes" ; then + AC_DEFINE(HAVE_SIN_LEN_IN_SAI, 1, [Does struct sockaddr_in have sin_len? 1: Yes, 0: No]) +else + AC_DEFINE(HAVE_SIN_LEN_IN_SAI, 0, [Does struct sockaddr_in have sin_len? 1: Yes, 0: No]) +fi + +dnl Check for libcrypt +dnl Some of our helpers use crypt(3) which may be in libc, or in +dnl libcrypt (eg FreeBSD) +AC_CHECK_LIB(crypt, crypt, [CRYPTLIB="-lcrypt"]) +dnl Solaris10 provides MD5 natively through libmd5 +AC_CHECK_LIB(md5, MD5Init, [CRYPTLIB="$CRYPTLIB -lmd5"]) +AC_SUBST(CRYPTLIB) + +dnl Check for libdl, used by auth_modules/PAM +if test "$with_dl" = "yes"; then + AC_CHECK_LIB(dl, dlopen) +fi + +dnl -lintl is needed on SCO version 3.2v4.2 for strftime() +dnl Robert Side +dnl Mon, 18 Jan 1999 17:48:00 GMT +case "$host" in + *-pc-sco3.2*) + AC_CHECK_LIB(intl, strftime) + ;; +esac + +dnl On MinGW OpenLDAP is not available, so LDAP helpers can be linked +dnl only with Windows LDAP libraries using -lwldap32 +case "$host_os" in +mingw|mingw32) + LIB_LDAP="-lwldap32" + LIB_LBER="" + ;; +*) + LIB_LDAP="-lldap" + dnl LDAP helpers need to know if -llber is needed or not + AC_CHECK_LIB(lber, main, [LIB_LBER="-llber"]) + ;; +esac +AC_SUBST(LIB_LDAP) +AC_SUBST(LIB_LBER) + +dnl Check for libdb +dnl this is not fully functional if db.h is for a differend db version +DBLIB= + +dnl check that dbopen is actually defined in the header +dnl FIXME: in case of failure undef db-related includes etc. +AC_CHECK_DECL(dbopen,,,[ +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_LIMITS_H +#include +#endif +#if HAVE_DB_185_H +#include +#elif HAVE_DB_H +#include +#endif]) + +dnl 1.85 +AC_CACHE_CHECK(if dbopen needs -ldb,ac_cv_dbopen_libdb, [ +SAVED_LIBS="$LIBS"; LIBS="$LIBS -ldb" + AC_LINK_IFELSE([AC_LANG_PROGRAM([[ +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_LIMITS_H +#include +#endif +#if HAVE_DB_185_H +#include +#elif HAVE_DB_H +#include +#endif]], [[dbopen("", 0, 0, DB_HASH, (void *)0L)]])],[ac_cv_dbopen_libdb="yes"],[ac_cv_dbopen_libdb="no"]) +LIBS="$SAVED_LIBS" +]) +if test $ac_cv_dbopen_libdb = yes; then + LIB_DB="-ldb" +fi +AC_SUBST(LIB_DB) + +dnl System-specific library modifications +dnl +case "$host" in + i386-*-solaris2.*) + if test "$GCC" = "yes"; then + AC_MSG_NOTICE([Removing -O for gcc on $host]) + CFLAGS="`echo $CFLAGS | sed -e 's/-O[[0-9]]*//'`" + fi + ;; + *-sgi-irix*) + AC_MSG_NOTICE([Removing -lsocket for IRIX...]) + LIBS=`echo $LIBS | sed -e s/-lsocket//` + AC_MSG_NOTICE([Removing -lnsl for IRIX...]) + LIBS=`echo $LIBS | sed -e s/-lnsl//` + ac_cv_lib_nsl_main=no + AC_MSG_NOTICE([Removing -lbsd for IRIX...]) + LIBS=`echo $LIBS | sed -e s/-lbsd//` + ;; +dnl From: c0032033@ws.rz.tu-bs.de (Joerg Schumacher) +dnl Date: Thu, 17 Oct 1996 04:09:30 +0200 +dnl Please change your configure script. AIX doesn't need -lbsd. + *-ibm-aix*) + AC_MSG_NOTICE([Removing -lbsd for AIX...]) + LIBS=`echo $LIBS | sed -e s/-lbsd//` + AC_MSG_CHECKING(for aix xlc c++ comments support) + AC_LANG_PUSH([C]) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[//c++ cmt]])],[AIX_CPPCMT_SUPPORT=yes],[AIX_CPPCMT_SUPPORT=no]) + AC_MSG_RESULT($AIX_CPPCMT_SUPPORT) + if test -n `echo $CC | grep cc` 2>/dev/null && \ + test -n `cc -qversion 2>/dev/null | grep "IBM XL C/C++ for AIX"` 2>/dev/null;then + if test "$AIX_CPPCMT_SUPPORT"="no";then + SQUID_CFLAGS="-qcpluscmt $SQUID_CFLAGS" + fi + fi + AC_LANG_POP([C]) + ;; + *m88k*) + SQUID_CFLAGS="$SQUID_CFLAGS -D_SQUID_MOTOROLA_" + SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_SQUID_MOTOROLA_" + AC_DEFINE(GETTIMEOFDAY_NO_TZP,1,[If gettimeofday is known to take only one argument]) + ;; + [*-*-solaris2.[0-4]]) + AC_DEFINE(GETTIMEOFDAY_NO_TZP,1) + ;; + [*-sony-newsos[56]*]) + AC_DEFINE(GETTIMEOFDAY_NO_TZP,1) + ;; +esac + +# Remove optimization for GCC 2.95.[123] +# gcc -O[2] on *BSD and Linux (x86) causes pointers to magically become NULL +if test "$GCC" = "yes"; then + GCCVER=`$CC -v 2>&1 | awk '$2 == "version" {print $3}'` + case "$GCCVER" in + [2.95.[123]]) + AC_MSG_NOTICE([Removing -O for gcc on $host with GCC $GCCVER]) + CFLAGS="`echo $CFLAGS | sed -e 's/-O[[0-9]]*//'`" + ;; + esac +fi + +# Recommended by Balint Nagy Endre +case "$host" in + *-univel-sysv4.2MP) + if test `uname -v` = "2.03"; then + AC_MSG_NOTICE([disabling mallinfo for $host]) + ac_cv_func_mallinfo=no + fi + ;; +esac + +dnl This has to be before AC_CHECK_FUNCS +# Disable poll() on certain platforms. Override by setting ac_cv_func_poll +# when running configure. +if test -z "$ac_cv_func_poll"; then + case "$host" in + [alpha-dec-osf3.*]) + # John Kay (jkay@nlanr.net) 19970818 + AC_MSG_NOTICE([disabling poll for $host...]) + ac_cv_func_poll='no' + ;; + [*-hp-hpux*.*]) + # Duane Wessels + AC_MSG_NOTICE([disabling poll for $host...]) + ac_cv_func_poll='no' + ;; + [*-linux-*]) + # Henrik Nordstrom (hno@squid-cache.org) 19980817 + # poll is problematic on Linux. We disable it + # by default until Linux gets it right. + rev=`uname -r | awk -F. '{printf "%03d%03d",$1,$2}'` + if test $rev -lt 002002; then + AC_MSG_NOTICE([disabling poll for $host < 2.2...]) + ac_cv_func_poll='no' + fi + ;; + [powerpc-ibm-aix4.1.*]) + # Mike Laster (mlaster@metavillage.com) 19981021 + AC_MSG_NOTICE([disabling poll for $host...]) + ac_cv_func_poll='no' + ;; + [*-pc-sco3.2*]) + # Robert Side + # Mon, 18 Jan 1999 17:48:00 GMT + AC_MSG_NOTICE([disabling poll for $host...]) + ac_cv_func_poll='no' + ;; + esac +fi + +dnl Override statfs() detect on MinGW becasue is emulated in source code +case "$host_os" in +mingw|mingw32) + ac_cv_func_statfs='yes' + ;; +esac + +dnl Check for library functions +AC_CHECK_FUNCS(\ + backtrace_symbols_fd \ + bcopy \ + bswap_16 \ + bswap_32 \ + bswap16 \ + bswap32 \ + fchmod \ + getdtablesize \ + getpagesize \ + getpass \ + getrlimit \ + getrusage \ + getspnam \ + gettimeofday \ + glob \ + htobe16 \ + htole16 \ + kqueue\ + lrand48 \ + mallinfo \ + mallocblksize \ + mallopt \ + memcpy \ + memmove \ + memset \ + mkstemp \ + mktime \ + mstats \ + poll \ + prctl \ + pthread_attr_setschedparam \ + pthread_attr_setscope \ + pthread_setschedparam \ + pthread_sigmask \ + putenv \ + random \ + regcomp \ + regexec \ + regfree \ + res_init \ + __res_init \ + rint \ + sbrk \ + select \ + seteuid \ + setgroups \ + setpgrp \ + setrlimit \ + setsid \ + sigaction \ + snprintf \ + socketpair \ + srand48 \ + srandom \ + statfs \ + sysconf \ + syslog \ + timegm \ + vsnprintf \ +) +dnl ... and some we provide local replacements for +AC_REPLACE_FUNCS(\ + drand48 \ + inet_ntop \ + inet_pton \ + initgroups \ + getaddrinfo \ + getnameinfo \ + strerror \ + strsep \ + strtoll \ + tempnam \ +) + +# check for crypt, may require -lcrypt +SAVED_LIBS="$LIBS" +LIBS="$LIBS $CRYPTLIB" +AC_CHECK_FUNCS(crypt) +LIBS="$SAVED_LIBS" + +dnl Magic which checks whether we are forcing a type of comm loop we +dnl are actually going to (ab)use + +dnl Actually do the define magic now +dnl mostly ripped from squid-commloops, thanks to adrian and benno + +if test -n "$SELECT_TYPE"; then + : # Already decided above. Nothing to do here +elif test -z "$disable_epoll" && test "$ac_cv_epoll_works" = "yes" ; then + SELECT_TYPE="epoll" +elif test -z "$disable_kqueue" && test "$ac_cv_func_kqueue" = "yes" ; then + SELECT_TYPE="kqueue" +elif test -z "$disable_poll" && test "$ac_cv_func_poll" = "yes" ; then + SELECT_TYPE="poll" +elif test "x$enable_devpoll" != "xno" && test "x$ac_cv_devpoll_works" = "xyes"; then + SELECT_TYPE="devpoll" +elif test -z "$disable_select" && test "$ac_cv_func_select" = "yes" ; then + case "$host_os" in + mingw|mingw32) + SELECT_TYPE="select_win32" + ;; + *) + SELECT_TYPE="select" + ;; + esac +else + AC_MSG_WARN([Eep! Cannot find epoll, kqueue, /dev/poll, poll or select!]) + AC_MSG_WARN([I'll try select and hope for the best.]) + SELECT_TYPE="select" + AC_DEFINE(USE_SELECT,1) +fi + +AC_MSG_NOTICE([Using ${SELECT_TYPE} for the IO loop.]) + +AM_CONDITIONAL([USE_POLL], [test $SELECT_TYPE = poll]) +AM_CONDITIONAL([USE_EPOLL], [test $SELECT_TYPE = epoll]) +AM_CONDITIONAL([USE_SELECT], [test $SELECT_TYPE = select]) +AM_CONDITIONAL([USE_SELECT_SIMPLE], [test $SELECT_TYPE = select_simple]) +AM_CONDITIONAL([USE_SELECT_WIN32], [test $SELECT_TYPE = select_win32]) +AM_CONDITIONAL([USE_KQUEUE], [test $SELECT_TYPE = kqueue]) +AM_CONDITIONAL([USE_DEVPOLL], [test $SELECT_TYPE = devpoll]) + +case $SELECT_TYPE in +epoll) + AC_DEFINE(USE_EPOLL,1,[Use epoll() for the IO loop]) + ;; +devpoll) + AC_DEFINE(USE_DEVPOLL,1,[Use /dev/poll for the IO loop]) + ;; +poll) + AC_DEFINE(USE_POLL,1,[Use poll() for the IO loop]) + ;; +kqueue) + AC_DEFINE(USE_KQUEUE,1,[Use kqueue() for the IO loop]) + ;; +select_win32) + AC_DEFINE(USE_SELECT_WIN32,1,[Use Winsock select() for the IO loop]) + ;; +select) + AC_DEFINE(USE_SELECT,1,[Use select() for the IO loop]) + ;; +esac + + + +dnl Yay! Another Linux brokenness. Its not good enough +dnl to know that setresuid() exists, because RedHat 5.0 declares +dnl setresuid() but doesn't implement it. +dnl +AC_CACHE_CHECK(if setresuid is implemented, ac_cv_func_setresuid, + AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include + int main(int argc, char **argv) { + if(setresuid(-1,-1,-1)) { + perror("setresuid:"); + return 1; + } + return 0; + } + ]])],[ac_cv_func_setresuid="yes"],[ac_cv_func_setresuid="no"],[:]) +) +if test "$ac_cv_func_setresuid" = "yes" ; then + AC_DEFINE(HAVE_SETRESUID,1,[Yay! Another Linux brokenness. Its not good enough to know that setresuid() exists, because RedHat 5.0 declare setresuid() but doesn't implement it.]) +fi + +dnl Yay! This one is a MacOSX brokenness. Its not good enough +dnl to know that strnstr() exists, because MacOSX 10.4 have a bad +dnl copy that crashes with a buffer over-run! +dnl +AC_CACHE_CHECK(if strnstr is well implemented, ac_cv_func_strnstr, + AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include +#include +#include + // we expect this to succeed, or crash on over-run. + // if it passes otherwise we may need a better check. +int main(int argc, char **argv) +{ + int size = 20; + char *str = malloc(size); + memset(str, 'x', size); + strnstr(str, "fubar", size); + return 0; +} + ]])],[ac_cv_func_strnstr="yes"],[ac_cv_func_strnstr="no"],[:]) +) +if test "$ac_cv_func_strnstr" = "yes" ; then + AC_DEFINE(HAVE_STRNSTR,1,[Yay! We have a working strnstr!]) +else + AC_DEFINE(HAVE_STRNSTR,0,[Yay! A MacOS X brokenness. Its not good enough to know that strnstr() exists, because MacOSX 10.4 and earlier may have a buffer overrun.]) +fi + +dnl +dnl Test for va_copy +dnl +AC_CACHE_CHECK(if va_copy is implemented, ac_cv_func_va_copy, + AC_RUN_IFELSE([AC_LANG_SOURCE([[ + #include + #include + int f (int i, ...) { + va_list args1, args2; + va_start (args1, i); + va_copy (args2, args1); + if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42) + return 1; + va_end (args1); va_end (args2); + return 0; + } + int main(int argc, char **argv) { return f (0, 42); } + ]])],[ac_cv_func_va_copy="yes"],[ac_cv_func_va_copy="no"],[:]) +) +if test "$ac_cv_func_va_copy" = "yes" ; then + AC_DEFINE(HAVE_VA_COPY, 1, [If your system have va_copy]) +fi + +dnl +dnl Some systems support __va_copy +dnl +AC_CACHE_CHECK(if __va_copy is implemented, ac_cv_func___va_copy, + AC_RUN_IFELSE([AC_LANG_SOURCE([[ + #include + #include + int f (int i, ...) { + va_list args1, args2; + va_start (args1, i); + __va_copy (args2, args1); + if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42) + return 1; + va_end (args1); va_end (args2); + return 0; + } + int main(int argc, char **argv) { return f (0, 42); } + ]])],[ac_cv_func___va_copy="yes"],[ac_cv_func___va_copy="no"],[:]) +) +if test "$ac_cv_func___va_copy" = "yes" ; then + AC_DEFINE(HAVE___VA_COPY, 1, [Some systems have __va_copy instead of va_copy]) +fi + +dnl IP-Filter support requires ipf header files. These aren't +dnl installed by default, so we need to check for them +if test "$IPF_TRANSPARENT" ; then + AC_MSG_CHECKING(if IP-Filter header files are installed) + # hold on to your hats... + if test "$ac_cv_header_ip_compat_h" = "yes" || + test "$ac_cv_header_ip_fil_compat_h" = "yes" || + test "$ac_cv_header_netinet_ip_compat_h" = "yes" || + test "$ac_cv_header_netinet_ip_fil_compat_h" = "yes" ; then + have_ipfilter_compat_header="yes" + fi + if test "x$have_ipfilter_compat_header" = "xyes" && + test "$ac_cv_header_ip_fil_h" = "yes" && + test "$ac_cv_header_ip_nat_h" = "yes" ; then + IPF_TRANSPARENT="yes" + AC_DEFINE(IPF_TRANSPARENT, 1) + elif test "$have_ipfilter_compat_header" = "yes" && + test "$ac_cv_header_netinet_ip_fil_h" = "yes" && + test "$ac_cv_header_netinet_ip_nat_h" = "yes" ; then + IPF_TRANSPARENT="yes" + AC_DEFINE(IPF_TRANSPARENT, 1) + else + IPF_TRANSPARENT="no" + AC_DEFINE(IPF_TRANSPARENT, 0) + fi + AC_MSG_RESULT($IPF_TRANSPARENT) +fi +if test "$IPF_TRANSPARENT" = "no" ; then + AC_MSG_WARN([Cannot find necessary IP-Filter header files]) + AC_MSG_WARN([Transparent Proxy support WILL NOT be enabled]) + sleep 10 +elif test "$IPF_TRANSPARENT" = "yes" ; then +dnl On Solaris Ipfilter includes expect that SOLARIS2 is defined with the +dnl Solaris minor version (8, 9, 10, ...) + case "$host" in + *-solaris*) + solrev=`uname -r | sh -c 'IFS=. read j n x; echo $n'` + CFLAGS="-DSOLARIS2=$solrev $CFLAGS" + CXXFLAGS="-DSOLARIS2=$solrev $CXXFLAGS" + ;; + *) + ;; + esac +fi + +dnl PF support requires a header file. +if test "$PF_TRANSPARENT" ; then + AC_MSG_CHECKING(if PF header file is installed) + # hold on to your hats... + if test "$ac_cv_header_net_pfvar_h" = "yes" || test "$ac_cv_header_net_pf_pfvar_h" = "yes"; then + PF_TRANSPARENT="yes" + AC_DEFINE(PF_TRANSPARENT, 1) + else + PF_TRANSPARENT="no" + AC_DEFINE(PF_TRANSPARENT, 0) + fi + AC_MSG_RESULT($PF_TRANSPARENT) +fi +if test "$PF_TRANSPARENT" = "no" ; then + AC_MSG_WARN([Cannot find necessary PF header file]) + AC_MSG_WARN([Transparent Proxy support WILL NOT be enabled]) + sleep 10 +fi + +dnl Linux-Netfilter support requires Linux 2.4 kernel header files. +dnl Shamelessly copied from above +if test "$LINUX_NETFILTER" ; then + AC_MSG_CHECKING(if Linux (Netfilter) kernel header files are installed) + # hold on to your hats... + if test "$ac_cv_header_linux_netfilter_ipv4_h" = "yes"; then + LINUX_NETFILTER="yes" + AC_DEFINE(LINUX_NETFILTER, 1) + else + LINUX_NETFILTER="no" + AC_DEFINE(LINUX_NETFILTER, 0) + fi + AC_MSG_RESULT($LINUX_NETFILTER) +fi +if test "$LINUX_NETFILTER" = "no" ; then + AC_MSG_WARN([Cannot find necessary Linux kernel (Netfilter) header files]) + AC_MSG_WARN([Linux Transparent and Intercepting Proxy support WILL NOT be enabled]) + LINUX_TPROXY2="no" + AC_DEFINE(LINUX_TPROXY2, 0, [Enable real Transparent Proxy support for Netfilter TPROXY v2.]) + sleep 10 +fi +dnl Netfilter TPROXY depends on libcap but the NAT parts can still work. +if test "$LINUX_NETFILTER" = "yes" && test "$use_libcap" != "yes" ; then + AC_MSG_WARN([Missing needed capabilities (libcap or libcap2) for TPROXY]) + AC_MSG_WARN([Linux Transparent Proxy support WILL NOT be enabled]) + AC_MSG_WARN([Reduced support to Interception Proxy]) + LINUX_TPROXY2="no" + AC_DEFINE(LINUX_TPROXY2, 0, [Enable real Transparent Proxy support for Netfilter TPROXY v2.]) + sleep 10 +fi + +dnl Linux Netfilter/TPROXYv2 support requires some specific header files +dnl Shamelessly copied from above +if test "$LINUX_TPROXY2"; then + if test "$use_libcap" = "yes"; then + AC_MSG_CHECKING(if TPROXYv2 header files are installed) + # hold on to your hats... + if test "$ac_cv_header_linux_netfilter_ipv4_ip_tproxy_h" = "yes" && test "$LINUX_NETFILTER" = "yes"; then + LINUX_TPROXY2="yes" + AC_DEFINE(LINUX_TPROXY2, 1, [Enable real Transparent Proxy support for Netfilter TPROXY v2.]) + else + LINUX_TPROXY2="no" + AC_DEFINE(LINUX_TPROXY2, 0, [Enable real Transparent Proxy support for Netfilter TPROXY v2.]) + fi + AC_MSG_RESULT($LINUX_TPROXY2) + if test "$LINUX_TPROXY2" = "no" && test "$LINUX_NETFILTER" = "yes"; then + AC_MSG_WARN([Cannot find TPROXY v2 headers, you need to patch the kernel with ]) + AC_MSG_WARN([tproxy package from:]) + AC_MSG_WARN([ - lynx http://www.balabit.com/downloads/files/tproxy/]) + AC_MSG_WARN([Or select the '--enable-linux-netfilter' option instead for Netfilter support.]) + sleep 10 + fi + else + AC_MSG_WARN([Missing needed capabilities (libcap or libcap2) for TPROXY v2]) + AC_MSG_WARN([Linux Transparent Proxy support WILL NOT be enabled]) + LINUX_TPROXY2="no" + AC_DEFINE(LINUX_TPROXY2, 0, [Enable real Transparent Proxy support for Netfilter TPROXY v2.]) + sleep 10 + fi +fi + +AC_ARG_ENABLE(gnuregex, + AS_HELP_STRING([--enable-gnuregex],[Compile GNUregex. Unless you have reason to use + this option, you should not enable it. + This library file is usually only required on Windows and + very old Unix boxes which do not have their own regex + library built in.]), +[USE_GNUREGEX=$enableval]) +if test -z "$USE_GNUREGEX" ; then + case "$host" in + *-sun-solaris2.[[0-4]]) + USE_GNUREGEX="yes" + ;; + *-next-nextstep*) + USE_GNUREGEX="yes" + ;; + esac +fi +AC_MSG_CHECKING(if GNUregex needs to be compiled) +if test -z "$USE_GNUREGEX"; then +if test "$ac_cv_func_regcomp" = "no" || test "$USE_GNUREGEX" = "yes" ; then + USE_GNUREGEX="yes" +else + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include +#include ]], [[regex_t t; regcomp(&t,"",0);]])],[USE_GNUREGEX="no"],[USE_GNUREGEX="yes"]) +fi +fi +AC_MSG_RESULT($USE_GNUREGEX) +if test "$USE_GNUREGEX" = "yes"; then + # override system regex with ours. Not good. But what was asked for. + REGEXLIB="" + AC_DEFINE(USE_GNUREGEX,1,[Define if we should use GNU regex]) +fi +AC_SUBST(REGEXLIB) +#AC_SUBST(LIBREGEX) + +dnl Not cached since people are likely to tune this +AC_MSG_CHECKING(Default FD_SETSIZE value) +AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#if HAVE_STDIO_H +#include +#endif +#if HAVE_UNISTD_H +#include +#endif +#if HAVE_STDLIB_H +#include +#endif +#if HAVE_SYS_TIME_H +#include +#endif +#if HAVE_SYS_SELECT_H +#include +#endif +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_WINSOCK_H +#include +#endif +#if HAVE_WINSOCK2_H +#include +#endif +int main(int argc, char **argv) { + FILE *fp = fopen("conftestval", "w"); + fprintf (fp, "%d\n", FD_SETSIZE); + return 0; +} +]])],[DEFAULT_FD_SETSIZE=`cat conftestval`],[DEFAULT_FD_SETSIZE=256],[DEFAULT_FD_SETSIZE=256]) +AC_MSG_RESULT($DEFAULT_FD_SETSIZE) +AC_DEFINE_UNQUOTED(DEFAULT_FD_SETSIZE, $DEFAULT_FD_SETSIZE, [Default FD_SETSIZE value]) + + +dnl Not cached since people are likely to tune this +AC_MSG_CHECKING(Maximum number of filedescriptors we can open) +dnl damn! FreeBSD's pthreads breaks dup2(). +TLDFLAGS="$LDFLAGS" +if test -n "$squid_filedescriptors_num" ; then + SQUID_MAXFD=$squid_filedescriptors_num + AC_MSG_RESULT($SQUID_MAXFD (user-forced)) +else + case $host in + i386-unknown-freebsd*) + if echo "$LDFLAGS" | grep -q pthread; then + LDFLAGS=`echo $LDFLAGS | sed -e "s/-pthread//"` + fi + esac + AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include +#include +#include +#include /* needed on FreeBSD */ +#include +#include +int main(int argc, char **argv) { + FILE *fp; + int i,j; +#if defined(__CYGWIN32__) || defined (__CYGWIN__) + /* getrlimit and sysconf returns bogous values on cygwin32. + * Number of fds is virtually unlimited in cygwin (sys/param.h) + * __CYGWIN32__ is deprecated. + */ + i = NOFILE; +#else +#if HAVE_SETRLIMIT + struct rlimit rl; +#if defined(RLIMIT_NOFILE) + if (getrlimit(RLIMIT_NOFILE, &rl) < 0) { + perror("getrlimit: RLIMIT_NOFILE"); + } else { +#if defined(__APPLE__) + /* asking for more than OPEN_MAX fails on Leopard */ + rl.rlim_cur = (OPEN_MAX < rl.rlim_max ? OPEN_MAX : rl.rlim_max); +#else + rl.rlim_cur = rl.rlim_max; /* set it to the max */ +#endif + if (setrlimit(RLIMIT_NOFILE, &rl) < 0) { + perror("setrlimit: RLIMIT_NOFILE"); + } + } +#elif defined(RLIMIT_OFILE) + if (getrlimit(RLIMIT_OFILE, &rl) < 0) { + perror("getrlimit: RLIMIT_OFILE"); + } else { + rl.rlim_cur = rl.rlim_max; /* set it to the max */ + if (setrlimit(RLIMIT_OFILE, &rl) < 0) { + perror("setrlimit: RLIMIT_OFILE"); + } + } +#endif /* RLIMIT_NOFILE */ +#endif /* HAVE_SETRLIMIT */ + /* by starting at 2^14, we will never get higher + than 2^15 for SQUID_MAXFD */ + i = j = 1<<14; + while (j) { + j >>= 1; + if (dup2(0, i) < 0) { + i -= j; + } else { + close(i); + i += j; + } + } + i++; +#endif /* IF !DEF CYGWIN */ + fp = fopen("conftestval", "w"); + fprintf (fp, "%d\n", i & ~0x3F); + return 0; +} + ]])],[SQUID_MAXFD=`cat conftestval`],[SQUID_MAXFD=256],[SQUID_MAXFD=256]) + dnl Microsoft MSVCRT.DLL supports 2048 maximum FDs + case "$host_os" in + mingw|mingw32) + SQUID_MAXFD="2048" + ;; + esac + AC_MSG_RESULT($SQUID_MAXFD) +fi +AC_DEFINE_UNQUOTED(SQUID_MAXFD, $SQUID_MAXFD,[Maximum number of open filedescriptors]) +if test "$SQUID_MAXFD" -lt 512 ; then + AC_MSG_WARN([$SQUID_MAXFD may not be enough filedescriptors if your]) + AC_MSG_WARN([cache will be very busy. Please see the FAQ page]) + AC_MSG_WARN([http://wiki.squid-cache.org/SquidFaq/TroubleShooting]) + AC_MSG_WARN([on how to increase your filedescriptor limit]) + sleep 10 +fi +LDFLAGS="$TLDFLAGS" + +if test `expr $SQUID_MAXFD % 64` != 0; then + AC_MSG_WARN([$SQUID_MAXFD is not an multiple of 64. This may cause issues on certain platforms.]) + sleep 10 +fi + +dnl Not cached since people are likely to tune this +AC_MSG_CHECKING(Default UDP send buffer size) +AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include +#include +#include +#if HAVE_SYS_SOCKET_H +#include +#endif +#if HAVE_NETINET_IN_H +#include +#endif +#if HAVE_WINSOCK_H +#include +#endif +#if HAVE_WINSOCK2_H +#include +#endif +int main(int argc, char **argv) +{ + FILE *fp; + int fd,val=0; +#if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) + int len=sizeof(int); + WSADATA wsaData; + WSAStartup(2, &wsaData); +#else + socklen_t len=sizeof(socklen_t); +#endif + if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) return 1; +#if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) + if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char *)&val, &len) < 0) return 1; + WSACleanup(); +#else + if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &val, &len) < 0) return 1; +#endif + if (val<=0) return 1; + fp = fopen("conftestval", "w"); + fprintf (fp, "%d\n", val); + return 0; +} +]])],[SQUID_DETECT_UDP_SO_SNDBUF=`cat conftestval`],[SQUID_DETECT_UDP_SO_SNDBUF=16384],[SQUID_DETECT_UDP_SO_SNDBUF=16384]) +AC_MSG_RESULT($SQUID_DETECT_UDP_SO_SNDBUF) +AC_DEFINE_UNQUOTED(SQUID_DETECT_UDP_SO_SNDBUF, $SQUID_DETECT_UDP_SO_SNDBUF,[UDP send buffer size]) + +dnl Not cached since people are likely to tune this +AC_MSG_CHECKING(Default UDP receive buffer size) +AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include +#include +#include +#if HAVE_SYS_SOCKET_H +#include +#endif +#if HAVE_NETINET_IN_H +#include +#endif +#if HAVE_WINSOCK_H +#include +#endif +#if HAVE_WINSOCK2_H +#include +#endif +int main(int argc, char **argv) +{ + FILE *fp; + int fd,val=0; +#if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) + int len=sizeof(int); + WSADATA wsaData; + WSAStartup(2, &wsaData); +#else + socklen_t len=sizeof(socklen_t); +#endif + if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) return 1; +#if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) + if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char *)&val, &len) < 0) return 1; + WSACleanup(); +#else + if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &val, &len) < 0) return 1; +#endif + if (val <= 0) return 1; + fp = fopen("conftestval", "w"); + fprintf (fp, "%d\n", val); + return 0; +} +]])],[SQUID_DETECT_UDP_SO_RCVBUF=`cat conftestval`],[SQUID_DETECT_UDP_SO_RCVBUF=16384],[SQUID_DETECT_UDP_SO_RCVBUF=16384]) +AC_MSG_RESULT($SQUID_DETECT_UDP_SO_RCVBUF) +AC_DEFINE_UNQUOTED(SQUID_DETECT_UDP_SO_RCVBUF, $SQUID_DETECT_UDP_SO_RCVBUF,[UDP receive buffer size]) + +dnl Not cached since people are likely to tune this +AC_MSG_CHECKING(Default TCP send buffer size) +AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include +#include +#include +#if HAVE_SYS_SOCKET_H +#include +#endif +#if HAVE_NETINET_IN_H +#include +#endif +#if HAVE_WINSOCK_H +#include +#endif +#if HAVE_WINSOCK2_H +#include +#endif +int main(int argc, char **argv) +{ + FILE *fp; + int fd,val=0; +#if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) + int len=sizeof(int); + WSADATA wsaData; + WSAStartup(2, &wsaData); +#else + socklen_t len=sizeof(socklen_t); +#endif + if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) return 1; +#if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) + if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char *)&val, &len) < 0) return 1; + WSACleanup(); +#else + if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &val, &len) < 0) return 1; +#endif + if (val <= 0) return 1; + fp = fopen("conftestval", "w"); + fprintf (fp, "%d\n", val); + return 0; +} +]])],[SQUID_TCP_SO_SNDBUF=`cat conftestval`],[SQUID_TCP_SO_SNDBUF=16384],[SQUID_TCP_SO_SNDBUF=16384]) +AC_MSG_RESULT($SQUID_TCP_SO_SNDBUF) +if test $SQUID_TCP_SO_SNDBUF -gt 32768; then + AC_MSG_NOTICE([Limiting send buffer size to 32K]) + SQUID_TCP_SO_SNDBUF=32768 +fi +AC_DEFINE_UNQUOTED(SQUID_TCP_SO_SNDBUF, $SQUID_TCP_SO_SNDBUF,[TCP send buffer size]) + +dnl Not cached since people are likely to tune this +AC_MSG_CHECKING(Default TCP receive buffer size) +AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include +#include +#include +#if HAVE_SYS_SOCKET_H +#include +#endif +#if HAVE_NETINET_IN_H +#include +#endif +#if HAVE_WINSOCK_H +#include +#endif +#if HAVE_WINSOCK2_H +#include +#endif +int main(int argc, char **argv) +{ + FILE *fp; + int fd,val=0; +#if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) + int len=sizeof(int); + WSADATA wsaData; + WSAStartup(2, &wsaData); +#else + socklen_t len=sizeof(socklen_t); +#endif + if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) return 1; +#if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) + if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char *)&val, &len) < 0) return 1; + WSACleanup(); +#else + if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &val, &len) < 0) return 1; +#endif + if (val <= 0) return 1; + fp = fopen("conftestval", "w"); + fprintf (fp, "%d\n", val); + return 0; +} +]])],[SQUID_TCP_SO_RCVBUF=`cat conftestval`],[SQUID_TCP_SO_RCVBUF=16384],[SQUID_TCP_SO_RCVBUF=16384]) +AC_MSG_RESULT($SQUID_TCP_SO_RCVBUF) +if test $SQUID_TCP_SO_RCVBUF -gt 65535; then + AC_MSG_NOTICE([Limiting receive buffer size to 64K]) + SQUID_TCP_SO_RCVBUF=65535 +fi +AC_DEFINE_UNQUOTED(SQUID_TCP_SO_RCVBUF, $SQUID_TCP_SO_RCVBUF,[TCP receive buffer size]) +AC_CACHE_CHECK(if sys_errlist is already defined, ac_cv_needs_sys_errlist, + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[char *s = sys_errlist;]])],[ac_cv_needs_sys_errlist="no"],[ac_cv_needs_sys_errlist="yes"]) +) +if test "$ac_cv_needs_sys_errlist" = "yes" ; then + AC_DEFINE(NEED_SYS_ERRLIST,1,[If we need to declare sys_errlist[] as external]) +fi + +dnl Not cached since people are likely to change this +AC_MSG_CHECKING(for libresolv _dns_ttl_ hack) +AC_LINK_IFELSE([AC_LANG_PROGRAM([[extern int _dns_ttl_;]], [[return _dns_ttl_;]])],[AC_MSG_RESULT(yes) +AC_DEFINE(LIBRESOLV_DNS_TTL_HACK,1,[If libresolv.a has been hacked to export _dns_ttl_])],[AC_MSG_RESULT(no)]) + +if test "$ac_cv_header_sys_statvfs_h" = "yes" ; then +AC_MSG_CHECKING(for working statvfs() interface) +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#include +#include +#include +#include +]], [[ +struct statvfs sfs; +sfs.f_blocks = sfs.f_bfree = sfs.f_frsize = +sfs.f_files = sfs.f_ffree = 0; +statvfs("/tmp", &sfs); +]])],[ac_cv_func_statvfs=yes],[ac_cv_func_statvfs=no]) +AC_MSG_RESULT($ac_cv_func_statvfs) +if test "$ac_cv_func_statvfs" = "yes" ; then + AC_DEFINE(HAVE_STATVFS,1,[If your system has statvfs(), and if it actually works!]) +fi +fi + +dnl Detect what resolver fields we have available to use... +AC_CACHE_CHECK(for _res_ext.nsaddr_list, ac_cv_have_res_ext_nsaddr_list, +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_NETINET_IN_H +#include +#endif +#if HAVE_ARPA_INET_H +#include +#endif +#if HAVE_ARPA_NAMESER_H +#include +#endif +#if HAVE_RESOLV_H +#include +#endif +]], [[_res_ext.nsaddr_list[[0]].s_addr;]])],[ac_cv_have_res_ext_nsaddr_list="yes"],[ac_cv_have_res_ext_nsaddr_list="no"])) +if test "$ac_cv_have_res_ext_nsaddr_list" = "yes" ; then + AC_DEFINE(_SQUID_RES_NSADDR6_LARRAY,_res_ext.nsaddr_list,[If _res_ext structure has nsaddr_list member]) + AC_DEFINE(_SQUID_RES_NSADDR6_COUNT,ns6count,[Nameserver Counter for IPv6 _res_ext]) +fi + +if test "$_SQUID_RES_NSADDR6_LIST" = ""; then +AC_CACHE_CHECK(for _res._u._ext.nsaddrs, ac_cv_have_res_ext_nsaddrs, +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_NETINET_IN_H +#include +#endif +#if HAVE_ARPA_INET_H +#include +#endif +#if HAVE_ARPA_NAMESER_H +#include +#endif +#if HAVE_RESOLV_H +#include +#endif +]], [[_res._u._ext.nsaddrs[[0]]->sin6_addr;]])],[ac_cv_have_res_ext_nsaddrs="yes"],[ac_cv_have_res_ext_nsaddrs="no"])) +if test "$ac_cv_have_res_ext_nsaddrs" = "yes" ; then + AC_DEFINE(_SQUID_RES_NSADDR6_LPTR,_res._u._ext.nsaddrs,[If _res structure has _ext.nsaddrs member]) + AC_DEFINE(_SQUID_RES_NSADDR6_COUNT,_res._u._ext.nscount6,[Nameserver Counter for IPv6 _res]) +fi +fi + +AC_CACHE_CHECK(for _res.nsaddr_list, ac_cv_have_res_nsaddr_list, +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_NETINET_IN_H +#include +#endif +#if HAVE_ARPA_INET_H +#include +#endif +#if HAVE_ARPA_NAMESER_H +#include +#endif +#if HAVE_RESOLV_H +#include +#endif +]], [[_res.nsaddr_list[[0]];]])],[ac_cv_have_res_nsaddr_list="yes"],[ac_cv_have_res_nsaddr_list="no"])) +if test $ac_cv_have_res_nsaddr_list = "yes" ; then + AC_DEFINE(_SQUID_RES_NSADDR_LIST,_res.nsaddr_list,[If _res structure has nsaddr_list member]) + AC_DEFINE(_SQUID_RES_NSADDR_COUNT,_res.nscount,[Nameserver counter for IPv4 _res]) +fi + +if test "$_SQUID_RES_NSADDR_LIST" = ""; then +AC_CACHE_CHECK(for _res.ns_list, ac_cv_have_res_ns_list, +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_NETINET_IN_H +#include +#endif +#if HAVE_ARPA_INET_H +#include +#endif +#if HAVE_ARPA_NAMESER_H +#include +#endif +#if HAVE_RESOLV_H +#include +#endif +]], [[_res.ns_list[[0]].addr;]])],[ac_cv_have_res_ns_list="yes"],[ac_cv_have_res_ns_list="no"])) +if test $ac_cv_have_res_ns_list = "yes" ; then + AC_DEFINE(_SQUID_RES_NSADDR_LIST,_res.ns_list,[If _res structure has ns_list member]) + AC_DEFINE(_SQUID_RES_NSADDR_COUNT,_res.nscount,[Nameserver counter for IPv4 _res]) +fi +fi + +dnl Squid will usually attempt to translate when packaging or building from VCS +use_translation="yes" +AC_ARG_ENABLE(translation, + AS_HELP_STRING([--disable-translation],[Prevent Squid generating localized error page templates and manuals. + Which is usually tried, but may not be needed.]), +[ if test "$enableval" = "no" ; then + use_translation=no + fi +]) +dnl Squid now has .po translation capability, given the right toolkit +if test "$use_translation" = "yes" ; then + AX_WITH_PROG([PO2HTML],[po2html]) +else + PO2HTML="off" +fi +AC_SUBST(PO2HTML) + +dnl Squid now has limited locale handling ... +dnl on error pages +use_errlocale=yes +AC_ARG_ENABLE(auto-locale, + AS_HELP_STRING([--disable-auto-locale],[This prevents Squid providing localized error pages based on the + clients request headers. + When disabled Squid requires explicit language configuration.]), +[ if test "$enableval" = "no" ; then + use_errlocale=no + fi +]) +if test "$use_errlocale" = "yes" ; then + AC_MSG_NOTICE([Enabling Multi-Language Support]) + AC_DEFINE(USE_ERR_LOCALES,1,[Use multi-language support on error pages]) +else + AC_MSG_WARN([Disabling Multi-Language Support]) + AC_DEFINE(USE_ERR_LOCALES,0,[Use multi-language support on error pages]) +fi + +dnl Need the debugging version of malloc if available +XTRA_OBJS='' +if test "$ac_cv_lib_malloc_main" = "yes" ; then + if test -r /usr/lib/debug/malloc.o ; then + XTRA_OBJS="$XTRA_OBJS /usr/lib/debug/malloc.o" + fi + if test -r /usr/lib/debug/mallocmap.o ; then + XTRA_OBJS="$XTRA_OBJS /usr/lib/debug/mallocmap.o" + fi +fi +AC_SUBST(XTRA_OBJS) + +if test -z "$XTRA_LIBS"; then + XTRA_LIBS="$LIBS" + dnl minor cleanup + XTRA_LIBS=`echo $XTRA_LIBS | sed -e "s/ */ /g"` + LIBS='' +fi +AC_SUBST(XTRA_LIBS) + +dnl Clean up after OSF/1 core dump bug +rm -f core + +AC_CONFIG_FILES([\ + Makefile \ + compat/Makefile \ + lib/Makefile \ + scripts/Makefile \ + src/Makefile \ + src/base/Makefile \ + src/acl/Makefile \ + src/fs/Makefile \ + src/repl/Makefile \ + src/auth/Makefile \ + src/adaptation/Makefile \ + src/adaptation/icap/Makefile \ + src/adaptation/ecap/Makefile \ + src/esi/Makefile \ + src/icmp/Makefile \ + src/ident/Makefile \ + src/ip/Makefile \ + contrib/Makefile \ + snmplib/Makefile \ + icons/Makefile \ + errors/Makefile \ + test-suite/Makefile \ + doc/Makefile \ + helpers/Makefile \ + helpers/basic_auth/Makefile \ + helpers/basic_auth/LDAP/Makefile \ + helpers/basic_auth/MSNT/Makefile \ + helpers/basic_auth/NCSA/Makefile \ + helpers/basic_auth/PAM/Makefile \ + helpers/basic_auth/SMB/Makefile \ + helpers/basic_auth/mswin_sspi/Makefile \ + helpers/basic_auth/YP/Makefile \ + helpers/basic_auth/getpwnam/Makefile \ + helpers/basic_auth/multi-domain-NTLM/Makefile \ + helpers/basic_auth/SASL/Makefile \ + helpers/basic_auth/POP3/Makefile \ + helpers/basic_auth/DB/Makefile \ + helpers/basic_auth/squid_radius_auth/Makefile \ + helpers/digest_auth/Makefile \ + helpers/digest_auth/password/Makefile \ + helpers/digest_auth/ldap/Makefile \ + helpers/digest_auth/eDirectory/Makefile \ + helpers/ntlm_auth/Makefile \ + helpers/ntlm_auth/fakeauth/Makefile \ + helpers/ntlm_auth/no_check/Makefile \ + helpers/ntlm_auth/smb_lm/Makefile \ + helpers/ntlm_auth/smb_lm/smbval/Makefile \ + helpers/ntlm_auth/mswin_sspi/Makefile \ + helpers/negotiate_auth/Makefile \ + helpers/negotiate_auth/mswin_sspi/Makefile \ + helpers/external_acl/Makefile \ + helpers/external_acl/ip_user/Makefile \ + helpers/external_acl/ldap_group/Makefile \ + helpers/external_acl/session/Makefile \ + helpers/external_acl/unix_group/Makefile \ + helpers/external_acl/wbinfo_group/Makefile \ + helpers/external_acl/mswin_ad_group/Makefile \ + helpers/external_acl/mswin_lm_group/Makefile \ + tools/Makefile +]) + +AC_CONFIG_SUBDIRS(lib/libTrie) + +# must configure libltdl subdir unconditionally for "make distcheck" to work +#AC_CONFIG_SUBDIRS(libltdl) + +AC_OUTPUT diff -ruN squid-3.1.9-orig/src/Makefile.am squid-3.1.9/src/Makefile.am --- squid-3.1.9-orig/src/Makefile.am 2010-10-25 13:34:23.000000000 +0200 +++ squid-3.1.9/src/Makefile.am 2010-10-30 01:55:25.000000000 +0200 @@ -721,7 +721,7 @@ DEFAULT_STORE_LOG = $(DEFAULT_LOG_PREFIX)/store.log DEFAULT_PID_FILE = $(DEFAULT_PIDFILE) DEFAULT_NETDB_FILE = $(DEFAULT_LOG_PREFIX)/netdb.state -DEFAULT_SWAP_DIR = $(localstatedir)/cache +DEFAULT_SWAP_DIR = $(DEFAULT_SWAPDIR) DEFAULT_PINGER = $(libexecdir)/`echo pinger | sed '$(transform);s/$$/$(EXEEXT)/'` DEFAULT_UNLINKD = $(libexecdir)/`echo unlinkd | sed '$(transform);s/$$/$(EXEEXT)/'` DEFAULT_DISKD = $(libexecdir)/`echo diskd | sed '$(transform);s/$$/$(EXEEXT)/'` diff -ruN squid-3.1.9-orig/src/Makefile.am.orig squid-3.1.9/src/Makefile.am.orig --- squid-3.1.9-orig/src/Makefile.am.orig 1970-01-01 01:00:00.000000000 +0100 +++ squid-3.1.9/src/Makefile.am.orig 2010-10-25 13:34:23.000000000 +0200 @@ -0,0 +1,2202 @@ +# +# Makefile for the Squid Object Cache server +# +# Uncomment and customize the following to suit your needs: +# + +include $(top_srcdir)/src/Common.am + +AUTOMAKE_OPTIONS = subdir-objects +if USE_DNSSERVER +DNSSOURCE = dns.cc +DNSSERVER = dnsserver +else +DNSSOURCE = dns_internal.cc +DNSSERVER = +endif + +DNSSOURCE += \ + DnsLookupDetails.h \ + DnsLookupDetails.cc + +SNMP_ALL_SOURCE = \ + snmp_core.cc \ + snmp_agent.cc +if USE_SNMP +SNMP_SOURCE = $(SNMP_ALL_SOURCE) +else +SNMP_SOURCE = +endif + +LOADABLE_MODULES_SOURCES = \ + LoadableModule.h \ + LoadableModule.cc \ + LoadableModules.h \ + LoadableModules.cc + +SUBDIRS = base acl fs repl auth ip icmp ident + +if USE_ADAPTATION +SUBDIRS += adaptation +endif + +if USE_ESI +SUBDIRS += esi +ESI_LOCAL_LIBS = \ + esi/libesi.la \ + $(top_builddir)/lib/libTrie/src/libTrie.a +ESI_LIBS = $(ESI_LOCAL_LIBS) \ + $(XMLLIB) \ + $(EXPATLIB) +else +ESI_LIBS = +endif + +DELAY_POOL_ALL_SOURCE = \ + CommonPool.h \ + CompositePoolNode.h \ + delay_pools.cc \ + DelayId.cc \ + DelayId.h \ + DelayIdComposite.h \ + DelayBucket.cc \ + DelayBucket.h \ + DelayConfig.cc \ + DelayConfig.h \ + DelayPool.cc \ + DelayPool.h \ + DelayPools.h \ + DelaySpec.cc \ + DelaySpec.h \ + DelayTagged.cc \ + DelayTagged.h \ + DelayUser.cc \ + DelayUser.h \ + DelayVector.cc \ + DelayVector.h \ + NullDelayId.cc \ + NullDelayId.h +if USE_DELAY_POOLS +DELAY_POOL_SOURCE = $(DELAY_POOL_ALL_SOURCE) +else +DELAY_POOL_SOURCE = +endif + +if ENABLE_XPROF_STATS +XPROF_STATS_SOURCE = ProfStats.cc +else +XPROF_STATS_SOURCE = +endif + +if ENABLE_HTCP +HTCPSOURCE = htcp.cc htcp.h +endif + +if MAKE_LEAKFINDER +LEAKFINDERSOURCE = LeakFinder.cc +else +LEAKFINDERSOURCE = +endif + +if ENABLE_UNLINKD +UNLINKDSOURCE = unlinkd.cc +UNLINKD = unlinkd +else +UNLINKDSOURCE = +UNLINKD = +endif + +SSL_ALL_SOURCE = \ + ssl_support.cc \ + ssl_support.h + +if ENABLE_SSL +SSL_SOURCE = $(SSL_ALL_SOURCE) +else +SSL_SOURCE = +endif + +WIN32_ALL_SOURCE = \ + win32.cc \ + WinSvc.cc +if ENABLE_WIN32SPECIFIC +WIN32_SOURCE = win32.cc +WINSVC_SOURCE = WinSvc.cc +else +WIN32_SOURCE = +WINSVC_SOURCE = +endif + +if USE_IPC_WIN32 +IPC_SOURCE = ipc_win32.cc +else +IPC_SOURCE = ipc.cc +endif + +AIO_WIN32_ALL_SOURCES = \ + DiskIO/AIO/aio_win32.cc \ + DiskIO/AIO/aio_win32.h +if USE_AIO_WIN32 +AIO_WIN32_SOURCES = $(AIO_WIN32_ALL_SOURCES) +else +AIO_WIN32_SOURCES = +endif + +if USE_AIOPS_WIN32 +AIOPS_SOURCE = DiskIO/DiskThreads/aiops_win32.cc +else +AIOPS_SOURCE = DiskIO/DiskThreads/aiops.cc +endif + +EXTRA_LIBRARIES = libAIO.a libBlocking.a libDiskDaemon.a libDiskThreads.a +noinst_LIBRARIES = $(DISK_LIBS) +noinst_LTLIBRARIES = libsquid.la + +# libraries used by many targets +COMMON_LIBS = \ + base/libbase.la \ + libsquid.la \ + auth/libacls.la \ + ident/libident.la \ + acl/libacls.la \ + acl/libstate.la \ + auth/libauth.la \ + acl/libapi.la \ + ip/libip.la \ + fs/libfs.la + +EXTRA_PROGRAMS = \ + DiskIO/DiskDaemon/diskd \ + unlinkd \ + dnsserver \ + recv-announce \ + tests/testUfs \ + tests/testCoss \ + tests/testNull \ + ufsdump + +## cfgen is used when building squid +## ufsdump is a debug utility, it is possibly useful for end users with cache +## corruption, but at this point we do not install it. +noinst_PROGRAMS = \ + cf_gen + +sbin_PROGRAMS = \ + squid + +bin_PROGRAMS = + + +libexec_PROGRAMS = \ + $(DNSSERVER) \ + $(DISK_PROGRAMS) \ + $(UNLINKD) + +cf_gen_SOURCES = cf_gen.cc +nodist_cf_gen_HEADER = cf_gen_defines.cci +cf_gen_LDADD= \ + ../compat/libcompat.la \ + -L../lib -lmiscutil \ + $(EPOLL_LIBS) \ + $(MINGW_LIBS) \ + $(XTRA_LIBS) +cf_gen.$(OBJEXT): cf_gen_defines.cci + +## cf_gen.cc needs src/cf_gen_defines.cci +INCLUDES += -I$(top_builddir)/src + + +ACL_REGISTRATION_SOURCES = AclRegs.cc AuthReg.cc + +DISKIO_SOURCE = \ + DiskIO/DiskIOModule.cc \ + DiskIO/ReadRequest.cc \ + DiskIO/ReadRequest.h \ + DiskIO/WriteRequest.cc \ + DiskIO/WriteRequest.h \ + DiskIO/DiskFile.h \ + DiskIO/DiskIOStrategy.h \ + DiskIO/IORequestor.h \ + DiskIO/DiskIOModule.h \ + DiskIO/ReadRequest.h + +DISKIO_GEN_SOURCE = \ + DiskIO/DiskIOModules_gen.cc + +DiskIO/DiskIOModules_gen.cc: Makefile + $(SHELL) $(srcdir)/DiskIO/modules.sh $(DISK_MODULES) > DiskIO/DiskIOModules_gen.cc + + +EXTRA_squid_SOURCES = \ + $(AIO_WIN32_ALL_SOURCES) \ + $(all_AUTHMODULES) \ + ConfigOption.h \ + $(DELAY_POOL_ALL_SOURCE) \ + dns.cc \ + dnsserver.cc \ + dns_internal.cc \ + DnsLookupDetails.cc \ + DnsLookupDetails.h \ + htcp.cc \ + htcp.h \ + ipc.cc \ + ipc_win32.cc \ + ProfStats.cc \ + LeakFinder.cc \ + LeakFinder.h \ + $(SNMP_ALL_SOURCE) \ + $(UNLINKDSOURCE) \ + $(SSL_ALL_SOURCE) \ + $(WIN32_ALL_SOURCE) \ + $(LOADABLE_MODULES_SOURCES) \ + DiskIO/DiskThreads/aiops.cc \ + DiskIO/DiskThreads/aiops_win32.cc + +squid_COMMSOURCES = \ + comm_select.cc \ + comm_select.h \ + comm_select_win32.cc \ + comm_poll.cc \ + comm_poll.h \ + comm_devpoll.cc \ + comm_epoll.cc \ + comm_epoll.h \ + comm_kqueue.cc \ + comm_kqueue.h + + +# common library for all the binaries and tests. This is kindof a catch all +# and smaller libraries split from this are encouraged. Using lt convenience +# libraries, dependencies should not be a problem either. +libsquid_la_SOURCES = \ + comm.cc \ + comm.h \ + CommCalls.cc \ + CommCalls.h \ + DescriptorSet.cc \ + DescriptorSet.h \ + SquidConfig.cc \ + TextException.cc \ + TextException.h + +squid_SOURCES = \ + $(ACL_REGISTRATION_SOURCES) \ + access_log.cc \ + AccessLogEntry.h \ + AsyncEngine.cc \ + AsyncEngine.h \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + cache_manager.cc \ + CacheManager.h \ + carp.cc \ + cbdata.cc \ + cbdata.h \ + ChunkedCodingParser.cc \ + ChunkedCodingParser.h \ + client_db.cc \ + client_side.cc \ + client_side.h \ + client_side_reply.cc \ + client_side_reply.h \ + client_side_request.cc \ + client_side_request.h \ + ClientInfo.h \ + BodyPipe.cc \ + BodyPipe.h \ + ClientInfo.h \ + ClientRequestContext.h \ + clientStream.cc \ + clientStream.h \ + CommIO.h \ + CompletionDispatcher.cc \ + CompletionDispatcher.h \ + $(squid_COMMSOURCES) \ + CommRead.h \ + ConfigOption.cc \ + ConfigParser.cc \ + ConfigParser.h \ + ConnectionDetail.h \ + debug.cc \ + Debug.h \ + defines.h \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + $(DISKIO_SOURCE) \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + enums.h \ + errorpage.cc \ + errorpage.h \ + ETag.cc \ + event.cc \ + event.h \ + EventLoop.h \ + EventLoop.cc \ + external_acl.cc \ + ExternalACL.h \ + ExternalACLEntry.cc \ + ExternalACLEntry.h \ + fd.cc \ + fde.cc \ + fde.h \ + filemap.cc \ + forward.cc \ + forward.h \ + fqdncache.cc \ + ftp.cc \ + Generic.h \ + globals.h \ + gopher.cc \ + helper.cc \ + helper.h \ + HierarchyLogEntry.h \ + $(HTCPSOURCE) \ + http.cc \ + http.h \ + HttpStatusCode.h \ + HttpStatusLine.cc \ + HttpStatusLine.h \ + HttpHdrCc.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrSc.h \ + HttpHdrScTarget.cc \ + HttpHdrScTarget.h \ + HttpHdrContRange.cc \ + HttpHdrContRange.h \ + HttpHeader.cc \ + HttpHeader.h \ + HttpHeaderMask.h \ + HttpHeaderRange.h \ + HttpHeaderTools.cc \ + HttpBody.cc \ + HttpMsg.cc \ + HttpMsg.h \ + HttpReply.cc \ + HttpReply.h \ + HttpRequest.cc \ + HttpRequest.h \ + HttpRequestMethod.cc \ + HttpRequestMethod.h \ + HttpVersion.h \ + ICP.h \ + icp_v2.cc \ + icp_v3.cc \ + int.cc \ + internal.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + $(LEAKFINDERSOURCE) \ + list.cc \ + logfile.cc \ + main.cc \ + mem.cc \ + mem_node.cc \ + mem_node.h \ + Mem.h \ + MemBuf.cc \ + MemObject.cc \ + MemObject.h \ + mime.cc \ + mime_header.cc \ + multicast.cc \ + neighbors.cc \ + Packer.cc \ + Packer.h \ + Parsing.cc \ + Parsing.h \ + $(XPROF_STATS_SOURCE) \ + pconn.cc \ + pconn.h \ + PeerDigest.h \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + PeerSelectState.h \ + PingData.h \ + protos.h \ + redirect.cc \ + referer.cc \ + refresh.cc \ + RemovalPolicy.cc \ + RemovalPolicy.h \ + send-announce.cc \ + $(SNMP_SOURCE) \ + squid.h \ + SquidMath.h \ + SquidMath.cc \ + SquidNew.cc \ + $(SSL_SOURCE) \ + stat.cc \ + StatHist.cc \ + String.cc \ + stmem.cc \ + stmem.h \ + store.cc \ + Store.h \ + StoreFileSystem.cc \ + StoreFileSystem.h \ + StoreHashIndex.h \ + store_io.cc \ + StoreIOBuffer.h \ + StoreIOState.cc \ + StoreIOState.h \ + store_client.cc \ + StoreClient.h \ + store_digest.cc \ + store_dir.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreMeta.cc \ + StoreMeta.h \ + StoreMetaMD5.cc \ + StoreMetaMD5.h \ + StoreMetaSTD.cc \ + StoreMetaSTD.h \ + StoreMetaSTDLFS.cc \ + StoreMetaSTDLFS.h \ + StoreMetaObjSize.h \ + StoreMetaUnpacker.cc \ + StoreMetaUnpacker.h \ + StoreMetaURL.cc \ + StoreMetaURL.h \ + StoreMetaVary.cc \ + StoreMetaVary.h \ + StoreSearch.h \ + StoreSwapLogData.cc \ + StoreSwapLogData.h \ + Server.cc \ + Server.h \ + structs.h \ + SwapDir.cc \ + SwapDir.h \ + time.cc \ + tools.cc \ + tunnel.cc \ + typedefs.h \ + $(UNLINKDSOURCE) \ + url.cc \ + URL.h \ + URLScheme.cc \ + URLScheme.h \ + urn.cc \ + useragent.cc \ + wccp.cc \ + wccp2.cc \ + whois.cc \ + wordlist.cc \ + wordlist.h \ + $(WIN32_SOURCE) \ + $(WINSVC_SOURCE) + +noinst_HEADERS = \ + client_side_request.cci \ + MemBuf.cci \ + MemBuf.h \ + Store.cci \ + StoreEntryStream.h \ + String.cci \ + SquidString.h \ + SquidTime.h + +nodist_squid_SOURCES = \ + $(DISKIO_GEN_SOURCE) \ + repl_modules.cc \ + cf_parser.cci \ + globals.cc \ + string_arrays.c + +squid_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + ../compat/libcompat.la \ + -L../lib \ + $(XTRA_OBJS) \ + $(DISK_LINKOBJS) \ + $(REPL_OBJS) \ + $(DISK_LIBS) \ + $(DISK_OS_LIBS) \ + $(CRYPTLIB) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(SSLLIB) \ + -lmiscutil \ + $(EPOLL_LIBS) \ + $(MINGW_LIBS) \ + $(XTRA_LIBS) +squid_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(DISK_LIBS) \ + $(DISK_LINKOBJS) \ + $(REPL_OBJS) \ + $(SNMPLIB) \ + ${ADAPTATION_LIBS} \ + $(ESI_LOCAL_LIBS) \ + $(COMMON_LIBS) + +if USE_LOADABLE_MODULES +squid_SOURCES += $(LOADABLE_MODULES_SOURCES) +squid_LDADD += \ + $(LIBLTDL) +squid_LDFLAGS = \ + -export-dynamic -dlopen force +# when static module linking is supported and enabled: +# squid_LDFLAGS = \ +# -all-static -dlopen self +# +endif + + +unlinkd_SOURCES = unlinkd_daemon.cc SquidNew.cc + +dnsserver_SOURCES = dnsserver.cc SquidNew.cc stub_debug.cc +recv_announce_SOURCES = recv-announce.cc SquidNew.cc + +## What requires what.. +## many things want ACLChecklist.cc +## ACLChecklist.cc wants AuthUserRequest.cc +## ACLChecklist.cc wants AuthScheme.cc +## ACLChecklist.cc wants ACLProxyAuth.cc directly +## ACLProxyAuth.cc wants ACLUserData +## ACLProxyAuth.cc wants ACLRegexData +## cache_cf.cc wants libauth.la +## cache_cf.cc wants Swapdir +## cache_cf.cc wants ProtoPort +## client_side wants client_db +## client_db wants SNMP_SOURCE +## snmp_core wants ACLStringData +## SwapDir wants ConfigOption +## tools.cc wants ip/libip.la +## client_side.cc wants ip/libip.la +## mem.cc wants ClientInfo.h +## libbase.la wants cbdata.* +## libbase.la wants MemBuf.* +ufsdump_SOURCES = \ + ClientInfo.h \ + cbdata.h \ + cbdata.cc \ + debug.cc \ + int.cc \ + mem.cc \ + MemBuf.cc \ + MemBuf.cci \ + MemBuf.h \ + store_key_md5.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + String.cc \ + time.cc \ + ufsdump.cc \ + dlink.h \ + dlink.cc \ + HttpRequestMethod.cc \ + RemovalPolicy.cc \ + squid.h \ + $(WIN32_SOURCE) \ + tests/stub_fd.cc +ufsdump_LDADD = \ + $(COMMON_LIBS) \ + $(XTRA_OBJS) \ + $(REPL_OBJS) \ + $(CRYPTLIB) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + $(SSLLIB) \ + -L$(top_builddir)/lib -lmiscutil \ + $(EPOLL_LIBS) \ + $(MINGW_LIBS) \ + $(XTRA_LIBS) +ufsdump_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(COMMON_LIBS) \ + $(DISK_LIBS) \ + $(DISK_LINKOBJS) \ + $(REPL_OBJS) + +nodist_ufsdump_SOURCES = \ + globals.cc + +BUILT_SOURCES = \ + cf_gen_defines.cci \ + cf_parser.cci \ + globals.cc \ + string_arrays.c \ + repl_modules.cc + +sysconf_DATA = \ + squid.conf.default \ + squid.conf.documented \ + mime.conf.default + +data_DATA = \ + mib.txt + +LDADD = $(COMMON_LIBS)\ + -L../lib \ + -lmiscutil \ + $(EPOLL_LIBS) \ + $(MINGW_LIBS) \ + $(XTRA_LIBS) + +EXTRA_DIST = \ + cf_gen_defines \ + cf.data.pre \ + cf.data.depend \ + DiskIO/modules.sh \ + mk-globals-c.pl \ + mk-globals-c.awk \ + mk-string-arrays.pl \ + mk-string-arrays.awk \ + repl_modules.sh \ + stub_debug.cc \ + mib.txt \ + mime.conf.default + +libAIO_a_SOURCES = \ + $(AIO_WIN32_SOURCES) \ + DiskIO/AIO/async_io.h \ + DiskIO/AIO/AIODiskFile.cc \ + DiskIO/AIO/AIODiskFile.h \ + DiskIO/AIO/AIODiskIOStrategy.cc \ + DiskIO/AIO/AIODiskIOStrategy.h \ + DiskIO/AIO/AIODiskIOModule.cc \ + DiskIO/AIO/AIODiskIOModule.h + +libBlocking_a_SOURCES = \ + DiskIO/Blocking/BlockingFile.cc \ + DiskIO/Blocking/BlockingFile.h \ + DiskIO/Blocking/BlockingIOStrategy.cc \ + DiskIO/Blocking/BlockingIOStrategy.h \ + DiskIO/Blocking/BlockingDiskIOModule.cc \ + DiskIO/Blocking/BlockingDiskIOModule.h + +libDiskDaemon_a_SOURCES = \ + DiskIO/DiskDaemon/DiskdFile.cc \ + DiskIO/DiskDaemon/DiskdFile.h \ + DiskIO/DiskDaemon/DiskdIOStrategy.cc \ + DiskIO/DiskDaemon/DiskdIOStrategy.h \ + DiskIO/DiskDaemon/diomsg.h \ + DiskIO/DiskDaemon/DiskDaemonDiskIOModule.cc \ + DiskIO/DiskDaemon/DiskDaemonDiskIOModule.h + +libDiskThreads_a_SOURCES = \ + $(AIOPS_SOURCE) \ + DiskIO/DiskThreads/async_io.cc \ + DiskIO/DiskThreads/DiskThreads.h \ + DiskIO/DiskThreads/DiskThreadsDiskFile.cc \ + DiskIO/DiskThreads/DiskThreadsDiskFile.h \ + DiskIO/DiskThreads/DiskThreadsDiskIOModule.cc \ + DiskIO/DiskThreads/DiskThreadsDiskIOModule.h \ + DiskIO/DiskThreads/DiskThreadsIOStrategy.cc \ + DiskIO/DiskThreads/DiskThreadsIOStrategy.h + +DiskIO_DiskDaemon_diskd_SOURCES = DiskIO/DiskDaemon/diskd.cc +DiskIO_DiskDaemon_diskd_LDADD = $(top_builddir)/lib/libmiscutil.a $(XTRA_LIBS) + + +DEFAULT_HTTP_PORT = $(CACHE_HTTP_PORT) +DEFAULT_ICP_PORT = $(CACHE_ICP_PORT) +DEFAULT_PREFIX = $(prefix) +DEFAULT_CONFIG_DIR = $(sysconfdir) +DEFAULT_CONFIG_FILE = $(DEFAULT_CONFIG_DIR)/squid.conf +DEFAULT_MIME_TABLE = $(DEFAULT_CONFIG_DIR)/mime.conf +DEFAULT_DNSSERVER = $(libexecdir)/`echo dnsserver | sed '$(transform);s/$$/$(EXEEXT)/'` +DEFAULT_LOG_PREFIX = $(DEFAULT_LOG_DIR) +DEFAULT_CACHE_LOG = $(DEFAULT_LOG_PREFIX)/cache.log +DEFAULT_ACCESS_LOG = $(DEFAULT_LOG_PREFIX)/access.log +DEFAULT_STORE_LOG = $(DEFAULT_LOG_PREFIX)/store.log +DEFAULT_PID_FILE = $(DEFAULT_PIDFILE) +DEFAULT_NETDB_FILE = $(DEFAULT_LOG_PREFIX)/netdb.state +DEFAULT_SWAP_DIR = $(localstatedir)/cache +DEFAULT_PINGER = $(libexecdir)/`echo pinger | sed '$(transform);s/$$/$(EXEEXT)/'` +DEFAULT_UNLINKD = $(libexecdir)/`echo unlinkd | sed '$(transform);s/$$/$(EXEEXT)/'` +DEFAULT_DISKD = $(libexecdir)/`echo diskd | sed '$(transform);s/$$/$(EXEEXT)/'` +DEFAULT_ICON_DIR = $(datadir)/icons +DEFAULT_ERROR_DIR = $(datadir)/errors +DEFAULT_HOSTS = $(OPT_DEFAULT_HOSTS) + +# Make location configure settings available to the code +DEFS += -DDEFAULT_CONFIG_FILE=\"$(DEFAULT_CONFIG_FILE)\" -DDEFAULT_SQUID_DATA_DIR=\"$(datadir)\" -DDEFAULT_SQUID_CONFIG_DIR=\"$(sysconfdir)\" + +snmp_core.o snmp_agent.o: ../snmplib/libsnmp.a $(top_srcdir)/include/cache_snmp.h + +globals.cc: globals.h mk-globals-c.pl + $(AWK) -f $(srcdir)/mk-globals-c.awk < $(srcdir)/globals.h > $@ || ($(RM) -f $@ && exit 1) + +string_arrays.c: enums.h mk-string-arrays.pl + $(AWK) -f $(srcdir)/mk-string-arrays.awk < $(srcdir)/enums.h > $@ || ($(RM) -f $@ && exit 1) + +cache_diff: cache_diff.o debug.o globals.o store_key_md5.o + $(CC) -o $@ $(LDFLAGS) $@.o debug.o globals.o store_key_md5.o $(STD_APP_LIBS) + +test_cache_digest: test_cache_digest.o CacheDigest.o debug.o globals.o store_key_md5.o + $(CC) -o $@ $(LDFLAGS) $@.o CacheDigest.o debug.o globals.o store_key_md5.o $(STD_APP_LIBS) + +## If autodependency works well this is not needed anymore +cache_cf.o: cf_parser.cci + +# squid.conf.default is built by cf_gen when making cf_parser.cci +squid.conf.default squid.conf.documented: cf_parser.cci + true + +cf_parser.cci: cf.data cf_gen$(EXEEXT) + ./cf_gen cf.data $(srcdir)/cf.data.depend + +cf_gen_defines.cci: $(srcdir)/cf_gen_defines $(srcdir)/cf.data.pre + $(AWK) -f $(srcdir)/cf_gen_defines <$(srcdir)/cf.data.pre >$@ || ($(RM) -f $@ && exit 1) + + +## FIXME: generate a sed command file from configure. Then this doesn't +## depend on the Makefile. +cf.data: cf.data.pre Makefile + sed \ + -e "s%[@]DEFAULT_HTTP_PORT[@]%$(DEFAULT_HTTP_PORT)%g" \ + -e "s%[@]DEFAULT_ICP_PORT[@]%$(DEFAULT_ICP_PORT)%g" \ + -e "s%[@]DEFAULT_CACHE_EFFECTIVE_USER[@]%${CACHE_EFFECTIVE_USER}%g" \ + -e "s%[@]DEFAULT_MIME_TABLE[@]%$(DEFAULT_MIME_TABLE)%g" \ + -e "s%[@]DEFAULT_DNSSERVER[@]%$(DEFAULT_DNSSERVER)%g" \ + -e "s%[@]DEFAULT_UNLINKD[@]%$(DEFAULT_UNLINKD)%g" \ + -e "s%[@]DEFAULT_PINGER[@]%$(DEFAULT_PINGER)%g" \ + -e "s%[@]DEFAULT_DISKD[@]%$(DEFAULT_DISKD)%g" \ + -e "s%[@]DEFAULT_CACHE_LOG[@]%$(DEFAULT_CACHE_LOG)%g" \ + -e "s%[@]DEFAULT_ACCESS_LOG[@]%$(DEFAULT_ACCESS_LOG)%g" \ + -e "s%[@]DEFAULT_STORE_LOG[@]%$(DEFAULT_STORE_LOG)%g" \ + -e "s%[@]DEFAULT_PID_FILE[@]%$(DEFAULT_PID_FILE)%g" \ + -e "s%[@]DEFAULT_NETDB_FILE[@]%$(DEFAULT_NETDB_FILE)%g" \ + -e "s%[@]DEFAULT_SWAP_DIR[@]%$(DEFAULT_SWAP_DIR)%g" \ + -e "s%[@]DEFAULT_ICON_DIR[@]%$(DEFAULT_ICON_DIR)%g" \ + -e "s%[@]DEFAULT_CONFIG_DIR[@]%$(DEFAULT_CONFIG_DIR)%g" \ + -e "s%[@]DEFAULT_PREFIX[@]%$(DEFAULT_PREFIX)%g" \ + -e "s%[@]DEFAULT_HOSTS[@]%$(DEFAULT_HOSTS)%g" \ + -e "s%[@]SQUID[@]%SQUID\ $(VERSION)%g" \ + < $(srcdir)/cf.data.pre >$@ + +repl_modules.cc: repl_modules.sh Makefile + $(SHELL) $(srcdir)/repl_modules.sh $(REPL_POLICIES) > repl_modules.cc + +install-data-local: install-sysconfDATA install-dataDATA + @if test -f $(DESTDIR)$(DEFAULT_MIME_TABLE) ; then \ + echo "$@ will not overwrite existing $(DESTDIR)$(DEFAULT_MIME_TABLE)" ; \ + else \ + echo "$(INSTALL_DATA) $(srcdir)/mime.conf.default $(DESTDIR)$(DEFAULT_MIME_TABLE)" ;\ + $(INSTALL_DATA) $(srcdir)/mime.conf.default $(DESTDIR)$(DEFAULT_MIME_TABLE); \ + fi + @if test -f $(DESTDIR)$(DEFAULT_CONFIG_FILE) ; then \ + echo "$@ will not overwrite existing $(DESTDIR)$(DEFAULT_CONFIG_FILE)" ; \ + else \ + echo "$(INSTALL_DATA) squid.conf.default $(DESTDIR)$(DEFAULT_CONFIG_FILE)"; \ + $(INSTALL_DATA) squid.conf.default $(DESTDIR)$(DEFAULT_CONFIG_FILE); \ + fi + echo "$(INSTALL_DATA) squid.conf.default $(DESTDIR)$(DEFAULT_CONFIG_FILE).default"; \ + $(INSTALL_DATA) squid.conf.default $(DESTDIR)$(DEFAULT_CONFIG_FILE).default; \ + echo "$(INSTALL_DATA) squid.conf.documented $(DESTDIR)$(DEFAULT_CONFIG_FILE).documented"; \ + $(INSTALL_DATA) squid.conf.documented $(DESTDIR)$(DEFAULT_CONFIG_FILE).documented; \ + $(mkinstalldirs) $(DESTDIR)$(DEFAULT_LOG_PREFIX); \ + $(mkinstalldirs) $(DESTDIR)$(DEFAULT_SWAP_DIR); \ + $(mkinstalldirs) $(DESTDIR)`dirname $(DEFAULT_PIDFILE)` + +uninstall-local: squid.conf.default + @$(SHELL) $(top_srcdir)/scripts/remove-cfg.sh "$(RM)" $(DESTDIR)$(DEFAULT_MIME_TABLE) $(srcdir)/mime.conf.default + @$(SHELL) $(top_srcdir)/scripts/remove-cfg.sh "$(RM)" $(DESTDIR)$(DEFAULT_CONFIG_FILE) squid.conf.default + +CLEANFILES += cf_gen_defines.cci cf.data cf_parser.cci squid.conf.default squid.conf.documented \ + globals.cc string_arrays.c repl_modules.cc DiskIO/DiskIOModules_gen.cc \ + test_tools.cc *.a + +test_tools.cc: $(top_srcdir)/test-suite/test_tools.cc + cp $(top_srcdir)/test-suite/test_tools.cc . + +# stock tools for unit tests - library independent versions of dlink_list +# etc. +# globals.cc is needed by test_tools.cc. +# Neither of these should be disted from here. +TESTSOURCES= \ + test_tools.cc \ + globals.cc + +# sources needed by those tests that need event.cc; incomplete +TEST_CALL_SOURCES = \ + event.cc + + +check_PROGRAMS+= tests/testAuth \ + tests/testACLMaxUserIP \ + tests/testBoilerplate \ + tests/testCacheManager \ + tests/testDiskIO \ + tests/testEvent \ + tests/testEventLoop \ + tests/test_http_range \ + tests/testHttpReply \ + tests/testHttpRequest \ + tests/testStore \ + tests/testString \ + tests/testURL \ + $(STORE_TESTS) + +## NP: required to run the above list. check_PROGRAMS only builds the binaries... +TESTS += $(check_PROGRAMS) + +### Template for new Unit Test Program +## - add tests/testX to check_PROGRAMS above. +## - copy template below and substitue X for class name +## - add other component .(h|cc) files needed to link and run tests +## +##NP: (TESTSOURCES) defines stub debugs() and new/delete for testing +## +#tests_testX_SOURCES=\ +# tests/testX.h \ +# tests/testX.cc \ +# tests/testMain.cc \ +# X.h \ +# X.cc +#nodist_tests_testX_SOURCES=\ +# $(TESTSOURCES) +#tests_testX_LDFLAGS = $(LIBADD_DL) +#tests_testX_LDADD=\ +# $(SQUID_CPPUNIT_LIBS) \ +# $(SQUID_CPPUNIT_LA) \ +# -L../lib -lmiscutil +#tests_testX_DEPENDENCIES= $(SQUID_CPPUNIT_LA) \ +# $(top_builddir)/lib/libmiscutil.a + + +# - add other component .(h|cc) files needed to link and run tests +tests_testHttpReply_SOURCES=\ + tests/testHttpReply.h \ + tests/testHttpReply.cc \ + tests/testMain.cc \ + cbdata.h \ + cbdata.cc \ + ETag.cc \ + HttpBody.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.h \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.h \ + HttpHdrSc.cc \ + HttpHdrScTarget.h \ + HttpHdrScTarget.cc \ + HttpHeader.h \ + HttpHeader.cc \ + HttpHeaderMask.h \ + HttpHeaderTools.cc \ + HttpMsg.h \ + HttpMsg.cc \ + HttpReply.h \ + HttpReply.cc \ + HttpStatusCode.h \ + HttpStatusLine.h \ + HttpStatusLine.cc \ + mem.cc \ + MemBuf.h \ + MemBuf.cc \ + mime_header.cc \ + Packer.h \ + Packer.cc \ + tests/stub_cache_manager.cc \ + tests/stub_StatHist.cc \ + tests/stub_store.cc \ + SquidString.h \ + String.cc \ + SquidTime.h \ + time.cc +nodist_tests_testHttpReply_SOURCES=\ + $(TESTSOURCES) +tests_testHttpReply_LDFLAGS = $(LIBADD_DL) +tests_testHttpReply_LDADD=\ + acl/libapi.la \ + acl/libstate.la \ + auth/libauth.la \ + ip/libip.la \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + -L../lib -lmiscutil \ + $(XTRA_LIBS) +tests_testHttpReply_DEPENDENCIES= $(SQUID_CPPUNIT_LA) \ + $(top_builddir)/lib/libmiscutil.a + +tests_testAuth_SOURCES = \ + tests/testAuth.cc tests/testMain.cc tests/testAuth.h \ + ConfigParser.cc \ + tests/stub_acl.cc tests/stub_cache_cf.cc \ + tests/stub_helper.cc cbdata.cc String.cc \ + tests/stub_store.cc HttpHeaderTools.cc HttpHeader.cc mem.cc ClientInfo.h \ + MemBuf.cc HttpHdrContRange.cc Packer.cc HttpHdrCc.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc url.cc \ + StatHist.cc HttpHdrRange.cc ETag.cc tests/stub_errorpage.cc \ + tests/stub_HttpRequest.cc tests/stub_DelayId.cc \ + tests/stub_MemObject.cc mem_node.cc \ + tests/stub_cache_manager.cc \ + stmem.cc \ + tests/stub_comm.cc \ + tests/stub_http.cc \ + HttpMsg.cc \ + HttpRequestMethod.cc \ + tests/stub_mime.cc \ + tests/stub_access_log.cc \ + time.cc \ + URLScheme.cc \ + $(TEST_CALL_SOURCES) \ + wordlist.cc +## acl.cc cache_cf.cc tools.cc \ +## helper.cc String.cc cbdata.cc HttpHeaderTools.cc store.cc cache_manager.cc \ +## HttpHeader.cc url.cc mem.cc HttpRequest.cc Packer.cc access_log.cc \ +## MemBuf.cc StatHist.cc logfile.cc +nodist_tests_testAuth_SOURCES = \ + $(TESTSOURCES) + +tests_testAuth_LDADD= \ + $(COMMON_LIBS) \ + -L../lib -lmiscutil \ + $(REGEXLIB) \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testAuth_LDFLAGS = $(LIBADD_DL) +tests_testAuth_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(SQUID_CPPUNIT_LA) + +## Tests for the ACLMaxUserIP class +## acl needs wordlist. wordlist needs MemBug +## MemBuf needs mem, MemBuf needs event, +## event needs cbdata. +## ACLMaxUserUP needs libauth.la +## ACLMaxUserIP needs ACLChecklist +## AuthUser request needs HttpHeader, which brings in +## ETag.cc \ +## HttpHeader.cc \ +## HttpHeaderTools.cc \ +## HttpHdrContRange.cc \ +## HttpHdrCc.cc \ +## HttpHdrRange.cc \ +## HttpHdrSc.cc \ +## HttpHdrScTarget.cc \ +## Packer.cc \ +## StatHist.cc \ +## String.cc \ +tests_testACLMaxUserIP_SOURCES= \ + cbdata.cc \ + ClientInfo.h \ + ConfigParser.cc \ + ETag.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrCc.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + mem_node.cc \ + Packer.cc \ + Parsing.cc \ + StatHist.cc \ + stmem.cc \ + String.cc \ + $(TEST_CALL_SOURCES) \ + tests/stub_cache_cf.cc \ + tests/stub_comm.cc \ + tests/stub_DelayId.cc \ + tests/stub_MemObject.cc \ + tests/stub_store.cc \ + tests/stub_cache_manager.cc \ + tests/testACLMaxUserIP.cc \ + tests/testACLMaxUserIP.h \ + tests/testMain.cc \ + time.cc \ + mem.cc \ + MemBuf.cc \ + wordlist.cc +nodist_tests_testACLMaxUserIP_SOURCES= \ + $(TESTSOURCES) +tests_testACLMaxUserIP_LDADD= \ + $(COMMON_LIBS) \ + -L../lib -lmiscutil \ + $(REGEXLIB) \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testACLMaxUserIP_LDFLAGS = $(LIBADD_DL) +tests_testACLMaxUserIP_DEPENDENCIES = \ + $(SQUID_CPPUNIT_LA) + +## a demonstration test that does nothing but shows the salient points +## involved in writing tests. +tests_testBoilerplate_SOURCES = \ + tests/testBoilerplate.cc \ + tests/testMain.cc \ + tests/testBoilerplate.h \ + time.cc +nodist_tests_testBoilerplate_SOURCES = \ + $(TESTSOURCES) +tests_testBoilerplate_LDADD= \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testBoilerplate_LDFLAGS = $(LIBADD_DL) +tests_testBoilerplate_DEPENDENCIES = \ + $(SQUID_CPPUNIT_LA) + +## Tests of the CacheManager module. +tests_testCacheManager_SOURCES = \ + debug.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + String.cc \ + tests/testCacheManager.cc \ + tests/testCacheManager.h \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + RemovalPolicy.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc +nodist_tests_testCacheManager_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c +tests_testCacheManager_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testCacheManager_LDFLAGS = $(LIBADD_DL) +tests_testCacheManager_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +tests_testDiskIO_SOURCES = \ + $(SWAP_TEST_SOURCES) \ + tests/testDiskIO.cc \ + tests/testDiskIO.h \ + tests/testMain.cc \ + tests/stub_cache_manager.cc +nodist_tests_testDiskIO_SOURCES= \ + $(SWAP_TEST_GEN_SOURCES) \ + SquidMath.cc \ + SquidMath.h +tests_testDiskIO_LDADD = \ + $(SWAP_TEST_LDADD) \ + $(DISK_LIBS) \ + $(DISK_OS_LIBS) \ + $(COMMON_LIBS) \ + SquidConfig.o \ + $(XTRA_LIBS) + +tests_testDiskIO_LDFLAGS = $(LIBADD_DL) +tests_testDiskIO_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(DISK_LIBS) \ + $(SWAP_TEST_DS) \ + $(SQUID_CPPUNIT_LA) + +## Tests of the Even module. +tests_testEvent_SOURCES = \ + debug.cc \ + EventLoop.h \ + EventLoop.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + RemovalPolicy.cc \ + String.cc \ + tests/CapturingStoreEntry.h \ + tests/testEvent.cc \ + tests/testEvent.h \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc +nodist_tests_testEvent_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c +tests_testEvent_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testEvent_LDFLAGS = $(LIBADD_DL) +tests_testEvent_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +## Tests of the EventLoop module. +tests_testEventLoop_SOURCES = \ + debug.cc \ + EventLoop.h \ + EventLoop.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + RemovalPolicy.cc \ + String.cc \ + tests/testEventLoop.cc \ + tests/testEventLoop.h \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc +nodist_tests_testEventLoop_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c +tests_testEventLoop_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testEventLoop_LDFLAGS = $(LIBADD_DL) +tests_testEventLoop_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +tests_test_http_range_SOURCES = \ + tests/test_http_range.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + cache_manager.cc \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + debug.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + int.cc \ + internal.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + list.cc \ + logfile.cc \ + mem.cc \ + mem_node.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + multicast.cc \ + neighbors.cc \ + Parsing.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + pconn.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + RemovalPolicy.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_key_md5.cc \ + store_io.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + String.cc \ + SwapDir.cc \ + $(TEST_CALL_SOURCES) \ + time.cc \ + tools.cc \ + tunnel.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc \ + Packer.cc \ + MemBuf.cc +nodist_tests_test_http_range_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c +tests_test_http_range_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_test_http_range_LDFLAGS = $(LIBADD_DL) +tests_test_http_range_DEPENDENCIES = \ + $(SQUID_CPPUNIT_LA) + + +## Tests of the HttpRequest module. +tests_testHttpRequest_SOURCES = \ + debug.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + String.cc \ + tests/testHttpRequest.h \ + tests/testHttpRequest.cc \ + tests/testHttpRequestMethod.h \ + tests/testHttpRequestMethod.cc \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + RemovalPolicy.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc +nodist_tests_testHttpRequest_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c +tests_testHttpRequest_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testHttpRequest_LDFLAGS = $(LIBADD_DL) +tests_testHttpRequest_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +# TODO:mime.cc drags in HttpReply.cc +# delay pools need client_side_request.cc +# store_key_md5 wants the method. +STORE_TEST_SOURCES=\ + $(TEST_CALL_SOURCES) \ + $(DELAY_POOL_SOURCE) \ + CacheDigest.cc \ + ConfigParser.cc \ + EventLoop.cc \ + HttpMsg.cc \ + RemovalPolicy.cc \ + store_dir.cc \ + store.cc \ + HttpRequestMethod.cc \ + store_key_md5.cc \ + Parsing.cc \ + ConfigOption.cc \ + SwapDir.cc \ + tests/stub_acl.cc tests/stub_cache_cf.cc \ + tests/stub_helper.cc cbdata.cc String.cc \ + tests/stub_comm.cc \ + tests/stub_client_side_request.cc \ + tests/stub_http.cc \ + mem_node.cc \ + stmem.cc \ + tests/stub_mime.cc \ + HttpHeaderTools.cc HttpHeader.cc mem.cc ClientInfo.h \ + MemBuf.cc HttpHdrContRange.cc Packer.cc HttpHdrCc.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc url.cc \ + StatHist.cc HttpHdrRange.cc ETag.cc tests/stub_errorpage.cc \ + tests/stub_HttpRequest.cc tests/stub_access_log.cc \ + refresh.cc \ + tests/stub_store_client.cc \ + tests/stub_tools.cc \ + tests/testStoreSupport.cc \ + tests/testStoreSupport.h \ + time.cc \ + URLScheme.cc \ + wordlist.cc + +STORE_TEST_GEN_SOURCES = \ + $(TESTSOURCES) \ + string_arrays.c + +## why so many sources? well httpHeaderTools requites ACLChecklist & friends. +## first line - what we are testing. +tests_testStore_SOURCES= \ + tests/stub_store_swapout.cc \ + tests/testMain.cc \ + tests/stub_MemObject.cc \ + tests/testStore.cc \ + tests/testStore.h \ + tests/CapturingStoreEntry.h \ + tests/testStoreEntryStream.cc \ + tests/testStoreEntryStream.h \ + tests/testStoreController.cc \ + tests/testStoreController.h \ + tests/testStoreHashIndex.cc \ + tests/testStoreHashIndex.h \ + tests/TestSwapDir.cc \ + tests/TestSwapDir.h \ + tests/stub_fd.cc \ + tests/stub_HttpReply.cc \ + tests/stub_cache_manager.cc \ + $(STORE_TEST_SOURCES) + +nodist_tests_testStore_SOURCES= \ + $(STORE_TEST_GEN_SOURCES) \ + SquidMath.cc \ + SquidMath.h + +tests_testStore_LDADD= \ + $(COMMON_LIBS) \ + -L../lib -lmiscutil \ + $(REGEXLIB) \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testStore_LDFLAGS = $(LIBADD_DL) +tests_testStore_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(SQUID_CPPUNIT_LA) + +## string needs mem.cc. +## mem.cc needs ClientInfo.h +## libsquid pulls in SquidConfig and children. stub them. +tests_testString_SOURCES = \ + ClientInfo.h \ + mem.cc \ + String.cc \ + tests/testMain.cc \ + tests/testString.cc \ + tests/testString.h \ + tests/stub_cache_manager.cc \ + time.cc +nodist_tests_testString_SOURCES = \ + $(TESTSOURCES) +tests_testString_LDADD = \ + $(COMMON_LIBS) \ + -L../lib -lmiscutil \ + $(REGEXLIB) \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testString_LDFLAGS = $(LIBADD_DL) +tests_testString_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(SQUID_CPPUNIT_LA) + +SWAP_TEST_SOURCES = \ + tests/stub_internal.cc \ + tests/stub_CommIO.cc \ + tests/stub_store_rebuild.cc \ + fd.cc \ + disk.cc \ + filemap.cc \ + HttpBody.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + int.cc \ + list.cc \ + MemObject.cc \ + StoreSwapLogData.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreFileSystem.cc \ + store_io.cc \ + store_swapout.cc \ + store_swapmeta.cc \ + $(UNLINKDSOURCE) \ + $(WIN32_SOURCE) \ + $(STORE_TEST_SOURCES) \ + $(DISKIO_SOURCE) + +SWAP_TEST_GEN_SOURCES = \ + $(STORE_TEST_GEN_SOURCES) \ + $(DISKIO_GEN_SOURCE) + +SWAP_TEST_LDADD = \ + $(REGEXLIB) \ + $(COMMON_LIBS) \ + $(REPL_OBJS) \ + $(DISK_LIBS) \ + $(DISK_OS_LIBS) \ + -L../lib -lmiscutil \ + acl/libapi.la \ + $(SQUID_CPPUNIT_LIBS) \ + $(XTRA_LIBS) +SWAP_TEST_DS =\ + $(top_builddir)/lib/libmiscutil.a \ + repl_modules.o \ + $(DISK_LIBS) \ + $(COMMON_LIBS) \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +tests_testUfs_SOURCES = \ + tests/testUfs.cc \ + tests/testMain.cc \ + tests/testUfs.h \ + tests/stub_cache_manager.cc \ + $(SWAP_TEST_SOURCES) +nodist_tests_testUfs_SOURCES = \ + $(SWAP_TEST_GEN_SOURCES) \ + SquidMath.cc \ + SquidMath.h +tests_testUfs_LDADD = \ + $(SWAP_TEST_LDADD) \ + $(COMMON_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testUfs_LDFLAGS = $(LIBADD_DL) +tests_testUfs_DEPENDENCIES = \ + $(SWAP_TEST_DS) + +tests_testCoss_SOURCES = \ + tests/testCoss.cc \ + tests/testMain.cc \ + tests/testCoss.h \ + tests/stub_cache_manager.cc \ + $(SWAP_TEST_SOURCES) +nodist_tests_testCoss_SOURCES = \ + $(SWAP_TEST_GEN_SOURCES) +tests_testCoss_LDADD = \ + libsquid.la \ + $(SWAP_TEST_LDADD) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testCoss_LDFLAGS = $(LIBADD_DL) +tests_testCoss_DEPENDENCIES = \ + $(SWAP_TEST_DS) + +tests_testNull_SOURCES = \ + tests/testNull.cc \ + tests/testMain.cc \ + tests/testNull.h \ + $(SWAP_TEST_SOURCES) +nodist_tests_testNull_SOURCES = \ + $(SWAP_TEST_GEN_SOURCES) +tests_testNull_LDADD = \ + $(SWAP_TEST_LDADD) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testNull_LDFLAGS = $(LIBADD_DL) +tests_testNull_DEPENDENCIES = \ + $(SWAP_TEST_DS) + +## Tests of the URL module. +## TODO: Trim this down once the insanity is over. +tests_testURL_SOURCES = \ + debug.cc \ + url.cc \ + URLScheme.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + RemovalPolicy.cc \ + String.cc \ + tests/testURL.cc \ + tests/testURL.h \ + tests/testURLScheme.cc \ + tests/testURLScheme.h \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc +nodist_tests_testURL_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c +tests_testURL_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REGEXLIB) \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) +tests_testURL_LDFLAGS = $(LIBADD_DL) +tests_testURL_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + + +TESTS += testHeaders + +## Special Universal .h dependency test script +## aborts if error encountered +testHeaders: $(srcdir)/*.h $(srcdir)/DiskIO/*.h $(srcdir)/DiskIO/*/*.h + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO/AIO" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO/Blocking" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO/DiskDaemon" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO/DiskThreads" || exit 1 +## src/repl/ has no .h files and its own makefile. + +CLEANFILES += testHeaders +.PHONY: testHeaders + diff -ruN squid-3.1.9-orig/src/Makefile.in squid-3.1.9/src/Makefile.in --- squid-3.1.9-orig/src/Makefile.in 2010-10-25 13:35:02.000000000 +0200 +++ squid-3.1.9/src/Makefile.in 2010-10-30 01:55:25.000000000 +0200 @@ -1982,7 +1982,7 @@ DEFAULT_STORE_LOG = $(DEFAULT_LOG_PREFIX)/store.log DEFAULT_PID_FILE = $(DEFAULT_PIDFILE) DEFAULT_NETDB_FILE = $(DEFAULT_LOG_PREFIX)/netdb.state -DEFAULT_SWAP_DIR = $(localstatedir)/cache +DEFAULT_SWAP_DIR = $(DEFAULT_SWAPDIR) DEFAULT_PINGER = $(libexecdir)/`echo pinger | sed '$(transform);s/$$/$(EXEEXT)/'` DEFAULT_UNLINKD = $(libexecdir)/`echo unlinkd | sed '$(transform);s/$$/$(EXEEXT)/'` DEFAULT_DISKD = $(libexecdir)/`echo diskd | sed '$(transform);s/$$/$(EXEEXT)/'` diff -ruN squid-3.1.9-orig/src/Makefile.in.orig squid-3.1.9/src/Makefile.in.orig --- squid-3.1.9-orig/src/Makefile.in.orig 1970-01-01 01:00:00.000000000 +0100 +++ squid-3.1.9/src/Makefile.in.orig 2010-10-25 13:35:02.000000000 +0200 @@ -0,0 +1,4640 @@ +# Makefile.in generated by automake 1.10.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# +# Makefile for the Squid Object Cache server +# +# Uncomment and customize the following to suit your needs: +# + + + + + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +DIST_COMMON = $(noinst_HEADERS) $(srcdir)/Makefile.am \ + $(srcdir)/Makefile.in $(top_srcdir)/src/Common.am +check_PROGRAMS = tests/testAuth$(EXEEXT) \ + tests/testACLMaxUserIP$(EXEEXT) tests/testBoilerplate$(EXEEXT) \ + tests/testCacheManager$(EXEEXT) tests/testDiskIO$(EXEEXT) \ + tests/testEvent$(EXEEXT) tests/testEventLoop$(EXEEXT) \ + tests/test_http_range$(EXEEXT) tests/testHttpReply$(EXEEXT) \ + tests/testHttpRequest$(EXEEXT) tests/testStore$(EXEEXT) \ + tests/testString$(EXEEXT) tests/testURL$(EXEEXT) \ + $(STORE_TESTS) +@USE_LOADABLE_MODULES_TRUE@am__append_1 = $(INCLTDL) +@USE_ADAPTATION_TRUE@am__append_2 = adaptation +@USE_ESI_TRUE@am__append_3 = esi +EXTRA_PROGRAMS = DiskIO/DiskDaemon/diskd$(EXEEXT) unlinkd$(EXEEXT) \ + dnsserver$(EXEEXT) recv-announce$(EXEEXT) \ + tests/testUfs$(EXEEXT) tests/testCoss$(EXEEXT) \ + tests/testNull$(EXEEXT) ufsdump$(EXEEXT) +noinst_PROGRAMS = cf_gen$(EXEEXT) +sbin_PROGRAMS = squid$(EXEEXT) +bin_PROGRAMS = +libexec_PROGRAMS = $(am__EXEEXT_1) $(DISK_PROGRAMS) $(am__EXEEXT_2) +@USE_LOADABLE_MODULES_TRUE@am__append_4 = $(LOADABLE_MODULES_SOURCES) +@USE_LOADABLE_MODULES_TRUE@am__append_5 = \ +@USE_LOADABLE_MODULES_TRUE@ $(LIBLTDL) + +subdir = src +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \ + $(top_srcdir)/configure.in +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/include/autoconf.h +CONFIG_CLEAN_FILES = +LIBRARIES = $(noinst_LIBRARIES) +ARFLAGS = cru +libAIO_a_AR = $(AR) $(ARFLAGS) +libAIO_a_LIBADD = +am__libAIO_a_SOURCES_DIST = DiskIO/AIO/aio_win32.cc \ + DiskIO/AIO/aio_win32.h DiskIO/AIO/async_io.h \ + DiskIO/AIO/AIODiskFile.cc DiskIO/AIO/AIODiskFile.h \ + DiskIO/AIO/AIODiskIOStrategy.cc DiskIO/AIO/AIODiskIOStrategy.h \ + DiskIO/AIO/AIODiskIOModule.cc DiskIO/AIO/AIODiskIOModule.h +am__dirstamp = $(am__leading_dot)dirstamp +am__objects_1 = DiskIO/AIO/aio_win32.$(OBJEXT) +@USE_AIO_WIN32_TRUE@am__objects_2 = $(am__objects_1) +am_libAIO_a_OBJECTS = $(am__objects_2) \ + DiskIO/AIO/AIODiskFile.$(OBJEXT) \ + DiskIO/AIO/AIODiskIOStrategy.$(OBJEXT) \ + DiskIO/AIO/AIODiskIOModule.$(OBJEXT) +libAIO_a_OBJECTS = $(am_libAIO_a_OBJECTS) +libBlocking_a_AR = $(AR) $(ARFLAGS) +libBlocking_a_LIBADD = +am_libBlocking_a_OBJECTS = DiskIO/Blocking/BlockingFile.$(OBJEXT) \ + DiskIO/Blocking/BlockingIOStrategy.$(OBJEXT) \ + DiskIO/Blocking/BlockingDiskIOModule.$(OBJEXT) +libBlocking_a_OBJECTS = $(am_libBlocking_a_OBJECTS) +libDiskDaemon_a_AR = $(AR) $(ARFLAGS) +libDiskDaemon_a_LIBADD = +am_libDiskDaemon_a_OBJECTS = DiskIO/DiskDaemon/DiskdFile.$(OBJEXT) \ + DiskIO/DiskDaemon/DiskdIOStrategy.$(OBJEXT) \ + DiskIO/DiskDaemon/DiskDaemonDiskIOModule.$(OBJEXT) +libDiskDaemon_a_OBJECTS = $(am_libDiskDaemon_a_OBJECTS) +libDiskThreads_a_AR = $(AR) $(ARFLAGS) +libDiskThreads_a_LIBADD = +am__libDiskThreads_a_SOURCES_DIST = DiskIO/DiskThreads/aiops.cc \ + DiskIO/DiskThreads/aiops_win32.cc \ + DiskIO/DiskThreads/async_io.cc \ + DiskIO/DiskThreads/DiskThreads.h \ + DiskIO/DiskThreads/DiskThreadsDiskFile.cc \ + DiskIO/DiskThreads/DiskThreadsDiskFile.h \ + DiskIO/DiskThreads/DiskThreadsDiskIOModule.cc \ + DiskIO/DiskThreads/DiskThreadsDiskIOModule.h \ + DiskIO/DiskThreads/DiskThreadsIOStrategy.cc \ + DiskIO/DiskThreads/DiskThreadsIOStrategy.h +@USE_AIOPS_WIN32_FALSE@am__objects_3 = \ +@USE_AIOPS_WIN32_FALSE@ DiskIO/DiskThreads/aiops.$(OBJEXT) +@USE_AIOPS_WIN32_TRUE@am__objects_3 = DiskIO/DiskThreads/aiops_win32.$(OBJEXT) +am_libDiskThreads_a_OBJECTS = $(am__objects_3) \ + DiskIO/DiskThreads/async_io.$(OBJEXT) \ + DiskIO/DiskThreads/DiskThreadsDiskFile.$(OBJEXT) \ + DiskIO/DiskThreads/DiskThreadsDiskIOModule.$(OBJEXT) \ + DiskIO/DiskThreads/DiskThreadsIOStrategy.$(OBJEXT) +libDiskThreads_a_OBJECTS = $(am_libDiskThreads_a_OBJECTS) +LTLIBRARIES = $(noinst_LTLIBRARIES) +libsquid_la_LIBADD = +am_libsquid_la_OBJECTS = comm.lo CommCalls.lo DescriptorSet.lo \ + SquidConfig.lo TextException.lo +libsquid_la_OBJECTS = $(am_libsquid_la_OBJECTS) +am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(libexecdir)" \ + "$(DESTDIR)$(sbindir)" "$(DESTDIR)$(datadir)" \ + "$(DESTDIR)$(sysconfdir)" +binPROGRAMS_INSTALL = $(INSTALL_PROGRAM) +@USE_DNSSERVER_TRUE@am__EXEEXT_1 = dnsserver$(EXEEXT) +@ENABLE_UNLINKD_TRUE@am__EXEEXT_2 = unlinkd$(EXEEXT) +libexecPROGRAMS_INSTALL = $(INSTALL_PROGRAM) +sbinPROGRAMS_INSTALL = $(INSTALL_PROGRAM) +PROGRAMS = $(bin_PROGRAMS) $(libexec_PROGRAMS) $(noinst_PROGRAMS) \ + $(sbin_PROGRAMS) +am_DiskIO_DiskDaemon_diskd_OBJECTS = \ + DiskIO/DiskDaemon/diskd.$(OBJEXT) +DiskIO_DiskDaemon_diskd_OBJECTS = \ + $(am_DiskIO_DiskDaemon_diskd_OBJECTS) +am__DEPENDENCIES_1 = +DiskIO_DiskDaemon_diskd_DEPENDENCIES = \ + $(top_builddir)/lib/libmiscutil.a $(am__DEPENDENCIES_1) +am_cf_gen_OBJECTS = cf_gen.$(OBJEXT) +cf_gen_OBJECTS = $(am_cf_gen_OBJECTS) +cf_gen_DEPENDENCIES = ../compat/libcompat.la $(am__DEPENDENCIES_1) \ + $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) +am_dnsserver_OBJECTS = dnsserver.$(OBJEXT) SquidNew.$(OBJEXT) \ + stub_debug.$(OBJEXT) +dnsserver_OBJECTS = $(am_dnsserver_OBJECTS) +dnsserver_LDADD = $(LDADD) +dnsserver_DEPENDENCIES = $(COMMON_LIBS) $(am__DEPENDENCIES_1) \ + $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) +am_recv_announce_OBJECTS = recv-announce.$(OBJEXT) SquidNew.$(OBJEXT) +recv_announce_OBJECTS = $(am_recv_announce_OBJECTS) +recv_announce_LDADD = $(LDADD) +recv_announce_DEPENDENCIES = $(COMMON_LIBS) $(am__DEPENDENCIES_1) \ + $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) +am__squid_SOURCES_DIST = AclRegs.cc AuthReg.cc access_log.cc \ + AccessLogEntry.h AsyncEngine.cc AsyncEngine.h cache_cf.cc \ + ProtoPort.cc ProtoPort.h CacheDigest.cc cache_manager.cc \ + CacheManager.h carp.cc cbdata.cc cbdata.h \ + ChunkedCodingParser.cc ChunkedCodingParser.h client_db.cc \ + client_side.cc client_side.h client_side_reply.cc \ + client_side_reply.h client_side_request.cc \ + client_side_request.h ClientInfo.h BodyPipe.cc BodyPipe.h \ + ClientRequestContext.h clientStream.cc clientStream.h CommIO.h \ + CompletionDispatcher.cc CompletionDispatcher.h comm_select.cc \ + comm_select.h comm_select_win32.cc comm_poll.cc comm_poll.h \ + comm_devpoll.cc comm_epoll.cc comm_epoll.h comm_kqueue.cc \ + comm_kqueue.h CommRead.h ConfigOption.cc ConfigParser.cc \ + ConfigParser.h ConnectionDetail.h debug.cc Debug.h defines.h \ + CommonPool.h CompositePoolNode.h delay_pools.cc DelayId.cc \ + DelayId.h DelayIdComposite.h DelayBucket.cc DelayBucket.h \ + DelayConfig.cc DelayConfig.h DelayPool.cc DelayPool.h \ + DelayPools.h DelaySpec.cc DelaySpec.h DelayTagged.cc \ + DelayTagged.h DelayUser.cc DelayUser.h DelayVector.cc \ + DelayVector.h NullDelayId.cc NullDelayId.h disk.cc \ + DiskIO/DiskIOModule.cc DiskIO/ReadRequest.cc \ + DiskIO/ReadRequest.h DiskIO/WriteRequest.cc \ + DiskIO/WriteRequest.h DiskIO/DiskFile.h \ + DiskIO/DiskIOStrategy.h DiskIO/IORequestor.h \ + DiskIO/DiskIOModule.h dlink.h dlink.cc dns_internal.cc \ + DnsLookupDetails.h DnsLookupDetails.cc dns.cc enums.h \ + errorpage.cc errorpage.h ETag.cc event.cc event.h EventLoop.h \ + EventLoop.cc external_acl.cc ExternalACL.h ExternalACLEntry.cc \ + ExternalACLEntry.h fd.cc fde.cc fde.h filemap.cc forward.cc \ + forward.h fqdncache.cc ftp.cc Generic.h globals.h gopher.cc \ + helper.cc helper.h HierarchyLogEntry.h htcp.cc htcp.h http.cc \ + http.h HttpStatusCode.h HttpStatusLine.cc HttpStatusLine.h \ + HttpHdrCc.cc HttpHdrRange.cc HttpHdrSc.cc HttpHdrSc.h \ + HttpHdrScTarget.cc HttpHdrScTarget.h HttpHdrContRange.cc \ + HttpHdrContRange.h HttpHeader.cc HttpHeader.h HttpHeaderMask.h \ + HttpHeaderRange.h HttpHeaderTools.cc HttpBody.cc HttpMsg.cc \ + HttpMsg.h HttpReply.cc HttpReply.h HttpRequest.cc \ + HttpRequest.h HttpRequestMethod.cc HttpRequestMethod.h \ + HttpVersion.h ICP.h icp_v2.cc icp_v3.cc int.cc internal.cc \ + ipc.cc ipc_win32.cc ipcache.cc LeakFinder.cc list.cc \ + logfile.cc main.cc mem.cc mem_node.cc mem_node.h Mem.h \ + MemBuf.cc MemObject.cc MemObject.h mime.cc mime_header.cc \ + multicast.cc neighbors.cc Packer.cc Packer.h Parsing.cc \ + Parsing.h ProfStats.cc pconn.cc pconn.h PeerDigest.h \ + peer_digest.cc peer_select.cc peer_sourcehash.cc \ + peer_userhash.cc PeerSelectState.h PingData.h protos.h \ + redirect.cc referer.cc refresh.cc RemovalPolicy.cc \ + RemovalPolicy.h send-announce.cc snmp_core.cc snmp_agent.cc \ + squid.h SquidMath.h SquidMath.cc SquidNew.cc ssl_support.cc \ + ssl_support.h stat.cc StatHist.cc String.cc stmem.cc stmem.h \ + store.cc Store.h StoreFileSystem.cc StoreFileSystem.h \ + StoreHashIndex.h store_io.cc StoreIOBuffer.h StoreIOState.cc \ + StoreIOState.h store_client.cc StoreClient.h store_digest.cc \ + store_dir.cc store_key_md5.cc store_log.cc store_rebuild.cc \ + store_swapin.cc store_swapmeta.cc store_swapout.cc \ + StoreMeta.cc StoreMeta.h StoreMetaMD5.cc StoreMetaMD5.h \ + StoreMetaSTD.cc StoreMetaSTD.h StoreMetaSTDLFS.cc \ + StoreMetaSTDLFS.h StoreMetaObjSize.h StoreMetaUnpacker.cc \ + StoreMetaUnpacker.h StoreMetaURL.cc StoreMetaURL.h \ + StoreMetaVary.cc StoreMetaVary.h StoreSearch.h \ + StoreSwapLogData.cc StoreSwapLogData.h Server.cc Server.h \ + structs.h SwapDir.cc SwapDir.h time.cc tools.cc tunnel.cc \ + typedefs.h unlinkd.cc url.cc URL.h URLScheme.cc URLScheme.h \ + urn.cc useragent.cc wccp.cc wccp2.cc whois.cc wordlist.cc \ + wordlist.h win32.cc WinSvc.cc LoadableModule.h \ + LoadableModule.cc LoadableModules.h LoadableModules.cc +am__objects_4 = AclRegs.$(OBJEXT) AuthReg.$(OBJEXT) +am__objects_5 = comm_select.$(OBJEXT) comm_select_win32.$(OBJEXT) \ + comm_poll.$(OBJEXT) comm_devpoll.$(OBJEXT) \ + comm_epoll.$(OBJEXT) comm_kqueue.$(OBJEXT) +am__objects_6 = delay_pools.$(OBJEXT) DelayId.$(OBJEXT) \ + DelayBucket.$(OBJEXT) DelayConfig.$(OBJEXT) \ + DelayPool.$(OBJEXT) DelaySpec.$(OBJEXT) DelayTagged.$(OBJEXT) \ + DelayUser.$(OBJEXT) DelayVector.$(OBJEXT) \ + NullDelayId.$(OBJEXT) +@USE_DELAY_POOLS_TRUE@am__objects_7 = $(am__objects_6) +am__objects_8 = DiskIO/DiskIOModule.$(OBJEXT) \ + DiskIO/ReadRequest.$(OBJEXT) DiskIO/WriteRequest.$(OBJEXT) +@USE_DNSSERVER_FALSE@am__objects_9 = dns_internal.$(OBJEXT) \ +@USE_DNSSERVER_FALSE@ DnsLookupDetails.$(OBJEXT) +@USE_DNSSERVER_TRUE@am__objects_9 = dns.$(OBJEXT) \ +@USE_DNSSERVER_TRUE@ DnsLookupDetails.$(OBJEXT) +@ENABLE_HTCP_TRUE@am__objects_10 = htcp.$(OBJEXT) +@USE_IPC_WIN32_FALSE@am__objects_11 = ipc.$(OBJEXT) +@USE_IPC_WIN32_TRUE@am__objects_11 = ipc_win32.$(OBJEXT) +@MAKE_LEAKFINDER_TRUE@am__objects_12 = LeakFinder.$(OBJEXT) +@ENABLE_XPROF_STATS_TRUE@am__objects_13 = ProfStats.$(OBJEXT) +am__objects_14 = snmp_core.$(OBJEXT) snmp_agent.$(OBJEXT) +@USE_SNMP_TRUE@am__objects_15 = $(am__objects_14) +am__objects_16 = ssl_support.$(OBJEXT) +@ENABLE_SSL_TRUE@am__objects_17 = $(am__objects_16) +@ENABLE_UNLINKD_TRUE@am__objects_18 = unlinkd.$(OBJEXT) +@ENABLE_WIN32SPECIFIC_TRUE@am__objects_19 = win32.$(OBJEXT) +@ENABLE_WIN32SPECIFIC_TRUE@am__objects_20 = WinSvc.$(OBJEXT) +am__objects_21 = LoadableModule.$(OBJEXT) LoadableModules.$(OBJEXT) +@USE_LOADABLE_MODULES_TRUE@am__objects_22 = $(am__objects_21) +am_squid_OBJECTS = $(am__objects_4) access_log.$(OBJEXT) \ + AsyncEngine.$(OBJEXT) cache_cf.$(OBJEXT) ProtoPort.$(OBJEXT) \ + CacheDigest.$(OBJEXT) cache_manager.$(OBJEXT) carp.$(OBJEXT) \ + cbdata.$(OBJEXT) ChunkedCodingParser.$(OBJEXT) \ + client_db.$(OBJEXT) client_side.$(OBJEXT) \ + client_side_reply.$(OBJEXT) client_side_request.$(OBJEXT) \ + BodyPipe.$(OBJEXT) clientStream.$(OBJEXT) \ + CompletionDispatcher.$(OBJEXT) $(am__objects_5) \ + ConfigOption.$(OBJEXT) ConfigParser.$(OBJEXT) debug.$(OBJEXT) \ + $(am__objects_7) disk.$(OBJEXT) $(am__objects_8) \ + dlink.$(OBJEXT) $(am__objects_9) errorpage.$(OBJEXT) \ + ETag.$(OBJEXT) event.$(OBJEXT) EventLoop.$(OBJEXT) \ + external_acl.$(OBJEXT) ExternalACLEntry.$(OBJEXT) fd.$(OBJEXT) \ + fde.$(OBJEXT) filemap.$(OBJEXT) forward.$(OBJEXT) \ + fqdncache.$(OBJEXT) ftp.$(OBJEXT) gopher.$(OBJEXT) \ + helper.$(OBJEXT) $(am__objects_10) http.$(OBJEXT) \ + HttpStatusLine.$(OBJEXT) HttpHdrCc.$(OBJEXT) \ + HttpHdrRange.$(OBJEXT) HttpHdrSc.$(OBJEXT) \ + HttpHdrScTarget.$(OBJEXT) HttpHdrContRange.$(OBJEXT) \ + HttpHeader.$(OBJEXT) HttpHeaderTools.$(OBJEXT) \ + HttpBody.$(OBJEXT) HttpMsg.$(OBJEXT) HttpReply.$(OBJEXT) \ + HttpRequest.$(OBJEXT) HttpRequestMethod.$(OBJEXT) \ + icp_v2.$(OBJEXT) icp_v3.$(OBJEXT) int.$(OBJEXT) \ + internal.$(OBJEXT) $(am__objects_11) ipcache.$(OBJEXT) \ + $(am__objects_12) list.$(OBJEXT) logfile.$(OBJEXT) \ + main.$(OBJEXT) mem.$(OBJEXT) mem_node.$(OBJEXT) \ + MemBuf.$(OBJEXT) MemObject.$(OBJEXT) mime.$(OBJEXT) \ + mime_header.$(OBJEXT) multicast.$(OBJEXT) neighbors.$(OBJEXT) \ + Packer.$(OBJEXT) Parsing.$(OBJEXT) $(am__objects_13) \ + pconn.$(OBJEXT) peer_digest.$(OBJEXT) peer_select.$(OBJEXT) \ + peer_sourcehash.$(OBJEXT) peer_userhash.$(OBJEXT) \ + redirect.$(OBJEXT) referer.$(OBJEXT) refresh.$(OBJEXT) \ + RemovalPolicy.$(OBJEXT) send-announce.$(OBJEXT) \ + $(am__objects_15) SquidMath.$(OBJEXT) SquidNew.$(OBJEXT) \ + $(am__objects_17) stat.$(OBJEXT) StatHist.$(OBJEXT) \ + String.$(OBJEXT) stmem.$(OBJEXT) store.$(OBJEXT) \ + StoreFileSystem.$(OBJEXT) store_io.$(OBJEXT) \ + StoreIOState.$(OBJEXT) store_client.$(OBJEXT) \ + store_digest.$(OBJEXT) store_dir.$(OBJEXT) \ + store_key_md5.$(OBJEXT) store_log.$(OBJEXT) \ + store_rebuild.$(OBJEXT) store_swapin.$(OBJEXT) \ + store_swapmeta.$(OBJEXT) store_swapout.$(OBJEXT) \ + StoreMeta.$(OBJEXT) StoreMetaMD5.$(OBJEXT) \ + StoreMetaSTD.$(OBJEXT) StoreMetaSTDLFS.$(OBJEXT) \ + StoreMetaUnpacker.$(OBJEXT) StoreMetaURL.$(OBJEXT) \ + StoreMetaVary.$(OBJEXT) StoreSwapLogData.$(OBJEXT) \ + Server.$(OBJEXT) SwapDir.$(OBJEXT) time.$(OBJEXT) \ + tools.$(OBJEXT) tunnel.$(OBJEXT) $(am__objects_18) \ + url.$(OBJEXT) URLScheme.$(OBJEXT) urn.$(OBJEXT) \ + useragent.$(OBJEXT) wccp.$(OBJEXT) wccp2.$(OBJEXT) \ + whois.$(OBJEXT) wordlist.$(OBJEXT) $(am__objects_19) \ + $(am__objects_20) $(am__objects_22) +am__EXTRA_squid_SOURCES_DIST = DiskIO/AIO/aio_win32.cc \ + DiskIO/AIO/aio_win32.h ConfigOption.h CommonPool.h \ + CompositePoolNode.h delay_pools.cc DelayId.cc DelayId.h \ + DelayIdComposite.h DelayBucket.cc DelayBucket.h DelayConfig.cc \ + DelayConfig.h DelayPool.cc DelayPool.h DelayPools.h \ + DelaySpec.cc DelaySpec.h DelayTagged.cc DelayTagged.h \ + DelayUser.cc DelayUser.h DelayVector.cc DelayVector.h \ + NullDelayId.cc NullDelayId.h dns.cc dnsserver.cc \ + dns_internal.cc DnsLookupDetails.cc DnsLookupDetails.h htcp.cc \ + htcp.h ipc.cc ipc_win32.cc ProfStats.cc LeakFinder.cc \ + LeakFinder.h snmp_core.cc snmp_agent.cc unlinkd.cc \ + ssl_support.cc ssl_support.h win32.cc WinSvc.cc \ + LoadableModule.h LoadableModule.cc LoadableModules.h \ + LoadableModules.cc DiskIO/DiskThreads/aiops.cc \ + DiskIO/DiskThreads/aiops_win32.cc +am__objects_23 = DiskIO/DiskIOModules_gen.$(OBJEXT) +nodist_squid_OBJECTS = $(am__objects_23) repl_modules.$(OBJEXT) \ + globals.$(OBJEXT) string_arrays.$(OBJEXT) +squid_OBJECTS = $(am_squid_OBJECTS) $(nodist_squid_OBJECTS) +@USE_ESI_TRUE@am__DEPENDENCIES_2 = $(ESI_LOCAL_LIBS) \ +@USE_ESI_TRUE@ $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) +@USE_LOADABLE_MODULES_TRUE@am__DEPENDENCIES_3 = $(am__DEPENDENCIES_1) +squid_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(squid_LDFLAGS) $(LDFLAGS) -o $@ +am__objects_24 = event.$(OBJEXT) +am_tests_testACLMaxUserIP_OBJECTS = cbdata.$(OBJEXT) \ + ConfigParser.$(OBJEXT) ETag.$(OBJEXT) HttpHeader.$(OBJEXT) \ + HttpHeaderTools.$(OBJEXT) HttpHdrContRange.$(OBJEXT) \ + HttpHdrRange.$(OBJEXT) HttpHdrCc.$(OBJEXT) HttpHdrSc.$(OBJEXT) \ + HttpHdrScTarget.$(OBJEXT) mem_node.$(OBJEXT) Packer.$(OBJEXT) \ + Parsing.$(OBJEXT) StatHist.$(OBJEXT) stmem.$(OBJEXT) \ + String.$(OBJEXT) $(am__objects_24) \ + tests/stub_cache_cf.$(OBJEXT) tests/stub_comm.$(OBJEXT) \ + tests/stub_DelayId.$(OBJEXT) tests/stub_MemObject.$(OBJEXT) \ + tests/stub_store.$(OBJEXT) tests/stub_cache_manager.$(OBJEXT) \ + tests/testACLMaxUserIP.$(OBJEXT) tests/testMain.$(OBJEXT) \ + time.$(OBJEXT) mem.$(OBJEXT) MemBuf.$(OBJEXT) \ + wordlist.$(OBJEXT) +am__objects_25 = test_tools.$(OBJEXT) globals.$(OBJEXT) +nodist_tests_testACLMaxUserIP_OBJECTS = $(am__objects_25) +tests_testACLMaxUserIP_OBJECTS = $(am_tests_testACLMaxUserIP_OBJECTS) \ + $(nodist_tests_testACLMaxUserIP_OBJECTS) +tests_testACLMaxUserIP_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testACLMaxUserIP_LDFLAGS) $(LDFLAGS) -o $@ +am_tests_testAuth_OBJECTS = tests/testAuth.$(OBJEXT) \ + tests/testMain.$(OBJEXT) ConfigParser.$(OBJEXT) \ + tests/stub_acl.$(OBJEXT) tests/stub_cache_cf.$(OBJEXT) \ + tests/stub_helper.$(OBJEXT) cbdata.$(OBJEXT) String.$(OBJEXT) \ + tests/stub_store.$(OBJEXT) HttpHeaderTools.$(OBJEXT) \ + HttpHeader.$(OBJEXT) mem.$(OBJEXT) MemBuf.$(OBJEXT) \ + HttpHdrContRange.$(OBJEXT) Packer.$(OBJEXT) \ + HttpHdrCc.$(OBJEXT) HttpHdrSc.$(OBJEXT) \ + HttpHdrScTarget.$(OBJEXT) url.$(OBJEXT) StatHist.$(OBJEXT) \ + HttpHdrRange.$(OBJEXT) ETag.$(OBJEXT) \ + tests/stub_errorpage.$(OBJEXT) \ + tests/stub_HttpRequest.$(OBJEXT) tests/stub_DelayId.$(OBJEXT) \ + tests/stub_MemObject.$(OBJEXT) mem_node.$(OBJEXT) \ + tests/stub_cache_manager.$(OBJEXT) stmem.$(OBJEXT) \ + tests/stub_comm.$(OBJEXT) tests/stub_http.$(OBJEXT) \ + HttpMsg.$(OBJEXT) HttpRequestMethod.$(OBJEXT) \ + tests/stub_mime.$(OBJEXT) tests/stub_access_log.$(OBJEXT) \ + time.$(OBJEXT) URLScheme.$(OBJEXT) $(am__objects_24) \ + wordlist.$(OBJEXT) +nodist_tests_testAuth_OBJECTS = $(am__objects_25) +tests_testAuth_OBJECTS = $(am_tests_testAuth_OBJECTS) \ + $(nodist_tests_testAuth_OBJECTS) +tests_testAuth_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testAuth_LDFLAGS) $(LDFLAGS) -o $@ +am_tests_testBoilerplate_OBJECTS = tests/testBoilerplate.$(OBJEXT) \ + tests/testMain.$(OBJEXT) time.$(OBJEXT) +nodist_tests_testBoilerplate_OBJECTS = $(am__objects_25) +tests_testBoilerplate_OBJECTS = $(am_tests_testBoilerplate_OBJECTS) \ + $(nodist_tests_testBoilerplate_OBJECTS) +tests_testBoilerplate_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testBoilerplate_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testCacheManager_SOURCES_DIST = debug.cc HttpRequest.cc \ + HttpRequestMethod.cc mem.cc String.cc \ + tests/testCacheManager.cc tests/testCacheManager.h \ + tests/testMain.cc time.cc access_log.cc BodyPipe.cc \ + cache_manager.cc cache_cf.cc ProtoPort.cc ProtoPort.h \ + CacheDigest.cc carp.cc cbdata.cc ChunkedCodingParser.cc \ + client_db.cc client_side.cc client_side_reply.cc \ + client_side_request.cc ClientInfo.h clientStream.cc \ + comm_select.cc comm_select.h comm_select_win32.cc comm_poll.cc \ + comm_poll.h comm_devpoll.cc comm_epoll.cc comm_epoll.h \ + comm_kqueue.cc comm_kqueue.h ConfigOption.cc ConfigParser.cc \ + CommonPool.h CompositePoolNode.h delay_pools.cc DelayId.cc \ + DelayId.h DelayIdComposite.h DelayBucket.cc DelayBucket.h \ + DelayConfig.cc DelayConfig.h DelayPool.cc DelayPool.h \ + DelayPools.h DelaySpec.cc DelaySpec.h DelayTagged.cc \ + DelayTagged.h DelayUser.cc DelayUser.h DelayVector.cc \ + DelayVector.h NullDelayId.cc NullDelayId.h disk.cc dlink.h \ + dlink.cc dns_internal.cc DnsLookupDetails.h \ + DnsLookupDetails.cc dns.cc errorpage.cc ETag.cc \ + external_acl.cc ExternalACLEntry.cc fd.cc fde.cc forward.cc \ + fqdncache.cc ftp.cc gopher.cc helper.cc htcp.cc htcp.h http.cc \ + HttpBody.cc HttpHeader.cc HttpHeaderTools.cc HttpHdrCc.cc \ + HttpHdrContRange.cc HttpHdrRange.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc HttpMsg.cc HttpReply.cc HttpStatusLine.cc \ + icp_v2.cc icp_v3.cc ipc.cc ipc_win32.cc ipcache.cc int.cc \ + internal.cc list.cc logfile.cc multicast.cc mem_node.cc \ + MemBuf.cc MemObject.cc mime.cc mime_header.cc neighbors.cc \ + Packer.cc Parsing.cc pconn.cc peer_digest.cc peer_select.cc \ + peer_sourcehash.cc peer_userhash.cc redirect.cc referer.cc \ + refresh.cc RemovalPolicy.cc Server.cc snmp_core.cc \ + snmp_agent.cc ssl_support.cc ssl_support.h SquidMath.h \ + SquidMath.cc stat.cc StatHist.cc stmem.cc store.cc \ + store_client.cc store_digest.cc store_dir.cc store_io.cc \ + store_key_md5.cc store_log.cc store_rebuild.cc store_swapin.cc \ + store_swapmeta.cc store_swapout.cc StoreFileSystem.cc \ + StoreIOState.cc StoreMeta.cc StoreMetaMD5.cc StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc StoreMetaUnpacker.cc StoreMetaURL.cc \ + StoreMetaVary.cc StoreSwapLogData.cc event.cc tools.cc \ + tunnel.cc SwapDir.cc url.cc URLScheme.cc urn.cc useragent.cc \ + wccp2.cc whois.cc win32.cc wordlist.cc +am_tests_testCacheManager_OBJECTS = debug.$(OBJEXT) \ + HttpRequest.$(OBJEXT) HttpRequestMethod.$(OBJEXT) \ + mem.$(OBJEXT) String.$(OBJEXT) \ + tests/testCacheManager.$(OBJEXT) tests/testMain.$(OBJEXT) \ + time.$(OBJEXT) access_log.$(OBJEXT) BodyPipe.$(OBJEXT) \ + cache_manager.$(OBJEXT) cache_cf.$(OBJEXT) ProtoPort.$(OBJEXT) \ + CacheDigest.$(OBJEXT) carp.$(OBJEXT) cbdata.$(OBJEXT) \ + ChunkedCodingParser.$(OBJEXT) client_db.$(OBJEXT) \ + client_side.$(OBJEXT) client_side_reply.$(OBJEXT) \ + client_side_request.$(OBJEXT) clientStream.$(OBJEXT) \ + $(am__objects_5) ConfigOption.$(OBJEXT) ConfigParser.$(OBJEXT) \ + $(am__objects_7) disk.$(OBJEXT) dlink.$(OBJEXT) \ + $(am__objects_9) errorpage.$(OBJEXT) ETag.$(OBJEXT) \ + external_acl.$(OBJEXT) ExternalACLEntry.$(OBJEXT) fd.$(OBJEXT) \ + fde.$(OBJEXT) forward.$(OBJEXT) fqdncache.$(OBJEXT) \ + ftp.$(OBJEXT) gopher.$(OBJEXT) helper.$(OBJEXT) \ + $(am__objects_10) http.$(OBJEXT) HttpBody.$(OBJEXT) \ + HttpHeader.$(OBJEXT) HttpHeaderTools.$(OBJEXT) \ + HttpHdrCc.$(OBJEXT) HttpHdrContRange.$(OBJEXT) \ + HttpHdrRange.$(OBJEXT) HttpHdrSc.$(OBJEXT) \ + HttpHdrScTarget.$(OBJEXT) HttpMsg.$(OBJEXT) \ + HttpReply.$(OBJEXT) HttpStatusLine.$(OBJEXT) icp_v2.$(OBJEXT) \ + icp_v3.$(OBJEXT) $(am__objects_11) ipcache.$(OBJEXT) \ + int.$(OBJEXT) internal.$(OBJEXT) list.$(OBJEXT) \ + logfile.$(OBJEXT) multicast.$(OBJEXT) mem_node.$(OBJEXT) \ + MemBuf.$(OBJEXT) MemObject.$(OBJEXT) mime.$(OBJEXT) \ + mime_header.$(OBJEXT) neighbors.$(OBJEXT) Packer.$(OBJEXT) \ + Parsing.$(OBJEXT) pconn.$(OBJEXT) peer_digest.$(OBJEXT) \ + peer_select.$(OBJEXT) peer_sourcehash.$(OBJEXT) \ + peer_userhash.$(OBJEXT) redirect.$(OBJEXT) referer.$(OBJEXT) \ + refresh.$(OBJEXT) RemovalPolicy.$(OBJEXT) Server.$(OBJEXT) \ + $(am__objects_15) $(am__objects_17) SquidMath.$(OBJEXT) \ + stat.$(OBJEXT) StatHist.$(OBJEXT) stmem.$(OBJEXT) \ + store.$(OBJEXT) store_client.$(OBJEXT) store_digest.$(OBJEXT) \ + store_dir.$(OBJEXT) store_io.$(OBJEXT) store_key_md5.$(OBJEXT) \ + store_log.$(OBJEXT) store_rebuild.$(OBJEXT) \ + store_swapin.$(OBJEXT) store_swapmeta.$(OBJEXT) \ + store_swapout.$(OBJEXT) StoreFileSystem.$(OBJEXT) \ + StoreIOState.$(OBJEXT) StoreMeta.$(OBJEXT) \ + StoreMetaMD5.$(OBJEXT) StoreMetaSTD.$(OBJEXT) \ + StoreMetaSTDLFS.$(OBJEXT) StoreMetaUnpacker.$(OBJEXT) \ + StoreMetaURL.$(OBJEXT) StoreMetaVary.$(OBJEXT) \ + StoreSwapLogData.$(OBJEXT) $(am__objects_24) tools.$(OBJEXT) \ + tunnel.$(OBJEXT) SwapDir.$(OBJEXT) url.$(OBJEXT) \ + URLScheme.$(OBJEXT) urn.$(OBJEXT) useragent.$(OBJEXT) \ + wccp2.$(OBJEXT) whois.$(OBJEXT) $(am__objects_19) \ + wordlist.$(OBJEXT) +nodist_tests_testCacheManager_OBJECTS = globals.$(OBJEXT) \ + repl_modules.$(OBJEXT) string_arrays.$(OBJEXT) +tests_testCacheManager_OBJECTS = $(am_tests_testCacheManager_OBJECTS) \ + $(nodist_tests_testCacheManager_OBJECTS) +tests_testCacheManager_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testCacheManager_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testCoss_SOURCES_DIST = tests/testCoss.cc tests/testMain.cc \ + tests/testCoss.h tests/stub_cache_manager.cc \ + tests/stub_internal.cc tests/stub_CommIO.cc \ + tests/stub_store_rebuild.cc fd.cc disk.cc filemap.cc \ + HttpBody.cc HttpReply.cc HttpStatusLine.cc int.cc list.cc \ + MemObject.cc StoreSwapLogData.cc StoreIOState.cc StoreMeta.cc \ + StoreMetaMD5.cc StoreMetaSTD.cc StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc StoreMetaURL.cc StoreMetaVary.cc \ + StoreFileSystem.cc store_io.cc store_swapout.cc \ + store_swapmeta.cc unlinkd.cc win32.cc event.cc CommonPool.h \ + CompositePoolNode.h delay_pools.cc DelayId.cc DelayId.h \ + DelayIdComposite.h DelayBucket.cc DelayBucket.h DelayConfig.cc \ + DelayConfig.h DelayPool.cc DelayPool.h DelayPools.h \ + DelaySpec.cc DelaySpec.h DelayTagged.cc DelayTagged.h \ + DelayUser.cc DelayUser.h DelayVector.cc DelayVector.h \ + NullDelayId.cc NullDelayId.h CacheDigest.cc ConfigParser.cc \ + EventLoop.cc HttpMsg.cc RemovalPolicy.cc store_dir.cc store.cc \ + HttpRequestMethod.cc store_key_md5.cc Parsing.cc \ + ConfigOption.cc SwapDir.cc tests/stub_acl.cc \ + tests/stub_cache_cf.cc tests/stub_helper.cc cbdata.cc \ + String.cc tests/stub_comm.cc tests/stub_client_side_request.cc \ + tests/stub_http.cc mem_node.cc stmem.cc tests/stub_mime.cc \ + HttpHeaderTools.cc HttpHeader.cc mem.cc ClientInfo.h MemBuf.cc \ + HttpHdrContRange.cc Packer.cc HttpHdrCc.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc url.cc StatHist.cc HttpHdrRange.cc ETag.cc \ + tests/stub_errorpage.cc tests/stub_HttpRequest.cc \ + tests/stub_access_log.cc refresh.cc tests/stub_store_client.cc \ + tests/stub_tools.cc tests/testStoreSupport.cc \ + tests/testStoreSupport.h time.cc URLScheme.cc wordlist.cc \ + DiskIO/DiskIOModule.cc DiskIO/ReadRequest.cc \ + DiskIO/ReadRequest.h DiskIO/WriteRequest.cc \ + DiskIO/WriteRequest.h DiskIO/DiskFile.h \ + DiskIO/DiskIOStrategy.h DiskIO/IORequestor.h \ + DiskIO/DiskIOModule.h +am__objects_26 = $(am__objects_24) $(am__objects_7) \ + CacheDigest.$(OBJEXT) ConfigParser.$(OBJEXT) \ + EventLoop.$(OBJEXT) HttpMsg.$(OBJEXT) RemovalPolicy.$(OBJEXT) \ + store_dir.$(OBJEXT) store.$(OBJEXT) \ + HttpRequestMethod.$(OBJEXT) store_key_md5.$(OBJEXT) \ + Parsing.$(OBJEXT) ConfigOption.$(OBJEXT) SwapDir.$(OBJEXT) \ + tests/stub_acl.$(OBJEXT) tests/stub_cache_cf.$(OBJEXT) \ + tests/stub_helper.$(OBJEXT) cbdata.$(OBJEXT) String.$(OBJEXT) \ + tests/stub_comm.$(OBJEXT) \ + tests/stub_client_side_request.$(OBJEXT) \ + tests/stub_http.$(OBJEXT) mem_node.$(OBJEXT) stmem.$(OBJEXT) \ + tests/stub_mime.$(OBJEXT) HttpHeaderTools.$(OBJEXT) \ + HttpHeader.$(OBJEXT) mem.$(OBJEXT) MemBuf.$(OBJEXT) \ + HttpHdrContRange.$(OBJEXT) Packer.$(OBJEXT) \ + HttpHdrCc.$(OBJEXT) HttpHdrSc.$(OBJEXT) \ + HttpHdrScTarget.$(OBJEXT) url.$(OBJEXT) StatHist.$(OBJEXT) \ + HttpHdrRange.$(OBJEXT) ETag.$(OBJEXT) \ + tests/stub_errorpage.$(OBJEXT) \ + tests/stub_HttpRequest.$(OBJEXT) \ + tests/stub_access_log.$(OBJEXT) refresh.$(OBJEXT) \ + tests/stub_store_client.$(OBJEXT) tests/stub_tools.$(OBJEXT) \ + tests/testStoreSupport.$(OBJEXT) time.$(OBJEXT) \ + URLScheme.$(OBJEXT) wordlist.$(OBJEXT) +am__objects_27 = tests/stub_internal.$(OBJEXT) \ + tests/stub_CommIO.$(OBJEXT) tests/stub_store_rebuild.$(OBJEXT) \ + fd.$(OBJEXT) disk.$(OBJEXT) filemap.$(OBJEXT) \ + HttpBody.$(OBJEXT) HttpReply.$(OBJEXT) \ + HttpStatusLine.$(OBJEXT) int.$(OBJEXT) list.$(OBJEXT) \ + MemObject.$(OBJEXT) StoreSwapLogData.$(OBJEXT) \ + StoreIOState.$(OBJEXT) StoreMeta.$(OBJEXT) \ + StoreMetaMD5.$(OBJEXT) StoreMetaSTD.$(OBJEXT) \ + StoreMetaSTDLFS.$(OBJEXT) StoreMetaUnpacker.$(OBJEXT) \ + StoreMetaURL.$(OBJEXT) StoreMetaVary.$(OBJEXT) \ + StoreFileSystem.$(OBJEXT) store_io.$(OBJEXT) \ + store_swapout.$(OBJEXT) store_swapmeta.$(OBJEXT) \ + $(am__objects_18) $(am__objects_19) $(am__objects_26) \ + $(am__objects_8) +am_tests_testCoss_OBJECTS = tests/testCoss.$(OBJEXT) \ + tests/testMain.$(OBJEXT) tests/stub_cache_manager.$(OBJEXT) \ + $(am__objects_27) +am__objects_28 = $(am__objects_25) string_arrays.$(OBJEXT) +am__objects_29 = $(am__objects_28) $(am__objects_23) +nodist_tests_testCoss_OBJECTS = $(am__objects_29) +tests_testCoss_OBJECTS = $(am_tests_testCoss_OBJECTS) \ + $(nodist_tests_testCoss_OBJECTS) +am__DEPENDENCIES_4 = $(am__DEPENDENCIES_1) $(COMMON_LIBS) \ + $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \ + $(am__DEPENDENCIES_1) acl/libapi.la $(am__DEPENDENCIES_1) \ + $(am__DEPENDENCIES_1) +tests_testCoss_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testCoss_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testDiskIO_SOURCES_DIST = tests/stub_internal.cc \ + tests/stub_CommIO.cc tests/stub_store_rebuild.cc fd.cc disk.cc \ + filemap.cc HttpBody.cc HttpReply.cc HttpStatusLine.cc int.cc \ + list.cc MemObject.cc StoreSwapLogData.cc StoreIOState.cc \ + StoreMeta.cc StoreMetaMD5.cc StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc StoreMetaUnpacker.cc StoreMetaURL.cc \ + StoreMetaVary.cc StoreFileSystem.cc store_io.cc \ + store_swapout.cc store_swapmeta.cc unlinkd.cc win32.cc \ + event.cc CommonPool.h CompositePoolNode.h delay_pools.cc \ + DelayId.cc DelayId.h DelayIdComposite.h DelayBucket.cc \ + DelayBucket.h DelayConfig.cc DelayConfig.h DelayPool.cc \ + DelayPool.h DelayPools.h DelaySpec.cc DelaySpec.h \ + DelayTagged.cc DelayTagged.h DelayUser.cc DelayUser.h \ + DelayVector.cc DelayVector.h NullDelayId.cc NullDelayId.h \ + CacheDigest.cc ConfigParser.cc EventLoop.cc HttpMsg.cc \ + RemovalPolicy.cc store_dir.cc store.cc HttpRequestMethod.cc \ + store_key_md5.cc Parsing.cc ConfigOption.cc SwapDir.cc \ + tests/stub_acl.cc tests/stub_cache_cf.cc tests/stub_helper.cc \ + cbdata.cc String.cc tests/stub_comm.cc \ + tests/stub_client_side_request.cc tests/stub_http.cc \ + mem_node.cc stmem.cc tests/stub_mime.cc HttpHeaderTools.cc \ + HttpHeader.cc mem.cc ClientInfo.h MemBuf.cc \ + HttpHdrContRange.cc Packer.cc HttpHdrCc.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc url.cc StatHist.cc HttpHdrRange.cc ETag.cc \ + tests/stub_errorpage.cc tests/stub_HttpRequest.cc \ + tests/stub_access_log.cc refresh.cc tests/stub_store_client.cc \ + tests/stub_tools.cc tests/testStoreSupport.cc \ + tests/testStoreSupport.h time.cc URLScheme.cc wordlist.cc \ + DiskIO/DiskIOModule.cc DiskIO/ReadRequest.cc \ + DiskIO/ReadRequest.h DiskIO/WriteRequest.cc \ + DiskIO/WriteRequest.h DiskIO/DiskFile.h \ + DiskIO/DiskIOStrategy.h DiskIO/IORequestor.h \ + DiskIO/DiskIOModule.h tests/testDiskIO.cc tests/testDiskIO.h \ + tests/testMain.cc tests/stub_cache_manager.cc +am_tests_testDiskIO_OBJECTS = $(am__objects_27) \ + tests/testDiskIO.$(OBJEXT) tests/testMain.$(OBJEXT) \ + tests/stub_cache_manager.$(OBJEXT) +nodist_tests_testDiskIO_OBJECTS = $(am__objects_29) \ + SquidMath.$(OBJEXT) +tests_testDiskIO_OBJECTS = $(am_tests_testDiskIO_OBJECTS) \ + $(nodist_tests_testDiskIO_OBJECTS) +tests_testDiskIO_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testDiskIO_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testEvent_SOURCES_DIST = debug.cc EventLoop.h EventLoop.cc \ + HttpRequest.cc HttpRequestMethod.cc mem.cc RemovalPolicy.cc \ + String.cc tests/CapturingStoreEntry.h tests/testEvent.cc \ + tests/testEvent.h tests/testMain.cc time.cc access_log.cc \ + BodyPipe.cc cache_manager.cc cache_cf.cc ProtoPort.cc \ + ProtoPort.h CacheDigest.cc carp.cc cbdata.cc \ + ChunkedCodingParser.cc client_db.cc client_side.cc \ + client_side_reply.cc client_side_request.cc ClientInfo.h \ + clientStream.cc comm_select.cc comm_select.h \ + comm_select_win32.cc comm_poll.cc comm_poll.h comm_devpoll.cc \ + comm_epoll.cc comm_epoll.h comm_kqueue.cc comm_kqueue.h \ + ConfigOption.cc ConfigParser.cc CommonPool.h \ + CompositePoolNode.h delay_pools.cc DelayId.cc DelayId.h \ + DelayIdComposite.h DelayBucket.cc DelayBucket.h DelayConfig.cc \ + DelayConfig.h DelayPool.cc DelayPool.h DelayPools.h \ + DelaySpec.cc DelaySpec.h DelayTagged.cc DelayTagged.h \ + DelayUser.cc DelayUser.h DelayVector.cc DelayVector.h \ + NullDelayId.cc NullDelayId.h disk.cc dlink.h dlink.cc \ + dns_internal.cc DnsLookupDetails.h DnsLookupDetails.cc dns.cc \ + errorpage.cc ETag.cc external_acl.cc ExternalACLEntry.cc fd.cc \ + fde.cc forward.cc fqdncache.cc ftp.cc gopher.cc helper.cc \ + htcp.cc htcp.h http.cc HttpBody.cc HttpHeader.cc \ + HttpHeaderTools.cc HttpHdrCc.cc HttpHdrContRange.cc \ + HttpHdrRange.cc HttpHdrSc.cc HttpHdrScTarget.cc HttpMsg.cc \ + HttpReply.cc HttpStatusLine.cc icp_v2.cc icp_v3.cc ipc.cc \ + ipc_win32.cc ipcache.cc int.cc internal.cc list.cc logfile.cc \ + multicast.cc mem_node.cc MemBuf.cc MemObject.cc mime.cc \ + mime_header.cc neighbors.cc Packer.cc Parsing.cc pconn.cc \ + peer_digest.cc peer_select.cc peer_sourcehash.cc \ + peer_userhash.cc redirect.cc referer.cc refresh.cc Server.cc \ + snmp_core.cc snmp_agent.cc ssl_support.cc ssl_support.h \ + SquidMath.h SquidMath.cc stat.cc StatHist.cc stmem.cc store.cc \ + store_client.cc store_digest.cc store_dir.cc store_io.cc \ + store_key_md5.cc store_log.cc store_rebuild.cc store_swapin.cc \ + store_swapmeta.cc store_swapout.cc StoreFileSystem.cc \ + StoreIOState.cc StoreMeta.cc StoreMetaMD5.cc StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc StoreMetaUnpacker.cc StoreMetaURL.cc \ + StoreMetaVary.cc StoreSwapLogData.cc event.cc tools.cc \ + tunnel.cc SwapDir.cc url.cc URLScheme.cc urn.cc useragent.cc \ + wccp2.cc whois.cc win32.cc wordlist.cc +am_tests_testEvent_OBJECTS = debug.$(OBJEXT) EventLoop.$(OBJEXT) \ + HttpRequest.$(OBJEXT) HttpRequestMethod.$(OBJEXT) \ + mem.$(OBJEXT) RemovalPolicy.$(OBJEXT) String.$(OBJEXT) \ + tests/testEvent.$(OBJEXT) tests/testMain.$(OBJEXT) \ + time.$(OBJEXT) access_log.$(OBJEXT) BodyPipe.$(OBJEXT) \ + cache_manager.$(OBJEXT) cache_cf.$(OBJEXT) ProtoPort.$(OBJEXT) \ + CacheDigest.$(OBJEXT) carp.$(OBJEXT) cbdata.$(OBJEXT) \ + ChunkedCodingParser.$(OBJEXT) client_db.$(OBJEXT) \ + client_side.$(OBJEXT) client_side_reply.$(OBJEXT) \ + client_side_request.$(OBJEXT) clientStream.$(OBJEXT) \ + $(am__objects_5) ConfigOption.$(OBJEXT) ConfigParser.$(OBJEXT) \ + $(am__objects_7) disk.$(OBJEXT) dlink.$(OBJEXT) \ + $(am__objects_9) errorpage.$(OBJEXT) ETag.$(OBJEXT) \ + external_acl.$(OBJEXT) ExternalACLEntry.$(OBJEXT) fd.$(OBJEXT) \ + fde.$(OBJEXT) forward.$(OBJEXT) fqdncache.$(OBJEXT) \ + ftp.$(OBJEXT) gopher.$(OBJEXT) helper.$(OBJEXT) \ + $(am__objects_10) http.$(OBJEXT) HttpBody.$(OBJEXT) \ + HttpHeader.$(OBJEXT) HttpHeaderTools.$(OBJEXT) \ + HttpHdrCc.$(OBJEXT) HttpHdrContRange.$(OBJEXT) \ + HttpHdrRange.$(OBJEXT) HttpHdrSc.$(OBJEXT) \ + HttpHdrScTarget.$(OBJEXT) HttpMsg.$(OBJEXT) \ + HttpReply.$(OBJEXT) HttpStatusLine.$(OBJEXT) icp_v2.$(OBJEXT) \ + icp_v3.$(OBJEXT) $(am__objects_11) ipcache.$(OBJEXT) \ + int.$(OBJEXT) internal.$(OBJEXT) list.$(OBJEXT) \ + logfile.$(OBJEXT) multicast.$(OBJEXT) mem_node.$(OBJEXT) \ + MemBuf.$(OBJEXT) MemObject.$(OBJEXT) mime.$(OBJEXT) \ + mime_header.$(OBJEXT) neighbors.$(OBJEXT) Packer.$(OBJEXT) \ + Parsing.$(OBJEXT) pconn.$(OBJEXT) peer_digest.$(OBJEXT) \ + peer_select.$(OBJEXT) peer_sourcehash.$(OBJEXT) \ + peer_userhash.$(OBJEXT) redirect.$(OBJEXT) referer.$(OBJEXT) \ + refresh.$(OBJEXT) Server.$(OBJEXT) $(am__objects_15) \ + $(am__objects_17) SquidMath.$(OBJEXT) stat.$(OBJEXT) \ + StatHist.$(OBJEXT) stmem.$(OBJEXT) store.$(OBJEXT) \ + store_client.$(OBJEXT) store_digest.$(OBJEXT) \ + store_dir.$(OBJEXT) store_io.$(OBJEXT) store_key_md5.$(OBJEXT) \ + store_log.$(OBJEXT) store_rebuild.$(OBJEXT) \ + store_swapin.$(OBJEXT) store_swapmeta.$(OBJEXT) \ + store_swapout.$(OBJEXT) StoreFileSystem.$(OBJEXT) \ + StoreIOState.$(OBJEXT) StoreMeta.$(OBJEXT) \ + StoreMetaMD5.$(OBJEXT) StoreMetaSTD.$(OBJEXT) \ + StoreMetaSTDLFS.$(OBJEXT) StoreMetaUnpacker.$(OBJEXT) \ + StoreMetaURL.$(OBJEXT) StoreMetaVary.$(OBJEXT) \ + StoreSwapLogData.$(OBJEXT) $(am__objects_24) tools.$(OBJEXT) \ + tunnel.$(OBJEXT) SwapDir.$(OBJEXT) url.$(OBJEXT) \ + URLScheme.$(OBJEXT) urn.$(OBJEXT) useragent.$(OBJEXT) \ + wccp2.$(OBJEXT) whois.$(OBJEXT) $(am__objects_19) \ + wordlist.$(OBJEXT) +nodist_tests_testEvent_OBJECTS = globals.$(OBJEXT) \ + repl_modules.$(OBJEXT) string_arrays.$(OBJEXT) +tests_testEvent_OBJECTS = $(am_tests_testEvent_OBJECTS) \ + $(nodist_tests_testEvent_OBJECTS) +tests_testEvent_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testEvent_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testEventLoop_SOURCES_DIST = debug.cc EventLoop.h \ + EventLoop.cc HttpRequest.cc HttpRequestMethod.cc mem.cc \ + RemovalPolicy.cc String.cc tests/testEventLoop.cc \ + tests/testEventLoop.h tests/testMain.cc time.cc access_log.cc \ + BodyPipe.cc cache_manager.cc cache_cf.cc ProtoPort.cc \ + ProtoPort.h CacheDigest.cc carp.cc cbdata.cc \ + ChunkedCodingParser.cc client_db.cc client_side.cc \ + client_side_reply.cc client_side_request.cc ClientInfo.h \ + clientStream.cc comm_select.cc comm_select.h \ + comm_select_win32.cc comm_poll.cc comm_poll.h comm_devpoll.cc \ + comm_epoll.cc comm_epoll.h comm_kqueue.cc comm_kqueue.h \ + ConfigOption.cc ConfigParser.cc CommonPool.h \ + CompositePoolNode.h delay_pools.cc DelayId.cc DelayId.h \ + DelayIdComposite.h DelayBucket.cc DelayBucket.h DelayConfig.cc \ + DelayConfig.h DelayPool.cc DelayPool.h DelayPools.h \ + DelaySpec.cc DelaySpec.h DelayTagged.cc DelayTagged.h \ + DelayUser.cc DelayUser.h DelayVector.cc DelayVector.h \ + NullDelayId.cc NullDelayId.h disk.cc dlink.h dlink.cc \ + dns_internal.cc DnsLookupDetails.h DnsLookupDetails.cc dns.cc \ + errorpage.cc ETag.cc external_acl.cc ExternalACLEntry.cc fd.cc \ + fde.cc forward.cc fqdncache.cc ftp.cc gopher.cc helper.cc \ + htcp.cc htcp.h http.cc HttpBody.cc HttpHeader.cc \ + HttpHeaderTools.cc HttpHdrCc.cc HttpHdrContRange.cc \ + HttpHdrRange.cc HttpHdrSc.cc HttpHdrScTarget.cc HttpMsg.cc \ + HttpReply.cc HttpStatusLine.cc icp_v2.cc icp_v3.cc ipc.cc \ + ipc_win32.cc ipcache.cc int.cc internal.cc list.cc logfile.cc \ + multicast.cc mem_node.cc MemBuf.cc MemObject.cc mime.cc \ + mime_header.cc neighbors.cc Packer.cc Parsing.cc pconn.cc \ + peer_digest.cc peer_select.cc peer_sourcehash.cc \ + peer_userhash.cc redirect.cc referer.cc refresh.cc Server.cc \ + snmp_core.cc snmp_agent.cc ssl_support.cc ssl_support.h \ + SquidMath.h SquidMath.cc stat.cc StatHist.cc stmem.cc store.cc \ + store_client.cc store_digest.cc store_dir.cc store_io.cc \ + store_key_md5.cc store_log.cc store_rebuild.cc store_swapin.cc \ + store_swapmeta.cc store_swapout.cc StoreFileSystem.cc \ + StoreIOState.cc StoreMeta.cc StoreMetaMD5.cc StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc StoreMetaUnpacker.cc StoreMetaURL.cc \ + StoreMetaVary.cc StoreSwapLogData.cc event.cc tools.cc \ + tunnel.cc SwapDir.cc url.cc URLScheme.cc urn.cc useragent.cc \ + wccp2.cc whois.cc win32.cc wordlist.cc +am_tests_testEventLoop_OBJECTS = debug.$(OBJEXT) EventLoop.$(OBJEXT) \ + HttpRequest.$(OBJEXT) HttpRequestMethod.$(OBJEXT) \ + mem.$(OBJEXT) RemovalPolicy.$(OBJEXT) String.$(OBJEXT) \ + tests/testEventLoop.$(OBJEXT) tests/testMain.$(OBJEXT) \ + time.$(OBJEXT) access_log.$(OBJEXT) BodyPipe.$(OBJEXT) \ + cache_manager.$(OBJEXT) cache_cf.$(OBJEXT) ProtoPort.$(OBJEXT) \ + CacheDigest.$(OBJEXT) carp.$(OBJEXT) cbdata.$(OBJEXT) \ + ChunkedCodingParser.$(OBJEXT) client_db.$(OBJEXT) \ + client_side.$(OBJEXT) client_side_reply.$(OBJEXT) \ + client_side_request.$(OBJEXT) clientStream.$(OBJEXT) \ + $(am__objects_5) ConfigOption.$(OBJEXT) ConfigParser.$(OBJEXT) \ + $(am__objects_7) disk.$(OBJEXT) dlink.$(OBJEXT) \ + $(am__objects_9) errorpage.$(OBJEXT) ETag.$(OBJEXT) \ + external_acl.$(OBJEXT) ExternalACLEntry.$(OBJEXT) fd.$(OBJEXT) \ + fde.$(OBJEXT) forward.$(OBJEXT) fqdncache.$(OBJEXT) \ + ftp.$(OBJEXT) gopher.$(OBJEXT) helper.$(OBJEXT) \ + $(am__objects_10) http.$(OBJEXT) HttpBody.$(OBJEXT) \ + HttpHeader.$(OBJEXT) HttpHeaderTools.$(OBJEXT) \ + HttpHdrCc.$(OBJEXT) HttpHdrContRange.$(OBJEXT) \ + HttpHdrRange.$(OBJEXT) HttpHdrSc.$(OBJEXT) \ + HttpHdrScTarget.$(OBJEXT) HttpMsg.$(OBJEXT) \ + HttpReply.$(OBJEXT) HttpStatusLine.$(OBJEXT) icp_v2.$(OBJEXT) \ + icp_v3.$(OBJEXT) $(am__objects_11) ipcache.$(OBJEXT) \ + int.$(OBJEXT) internal.$(OBJEXT) list.$(OBJEXT) \ + logfile.$(OBJEXT) multicast.$(OBJEXT) mem_node.$(OBJEXT) \ + MemBuf.$(OBJEXT) MemObject.$(OBJEXT) mime.$(OBJEXT) \ + mime_header.$(OBJEXT) neighbors.$(OBJEXT) Packer.$(OBJEXT) \ + Parsing.$(OBJEXT) pconn.$(OBJEXT) peer_digest.$(OBJEXT) \ + peer_select.$(OBJEXT) peer_sourcehash.$(OBJEXT) \ + peer_userhash.$(OBJEXT) redirect.$(OBJEXT) referer.$(OBJEXT) \ + refresh.$(OBJEXT) Server.$(OBJEXT) $(am__objects_15) \ + $(am__objects_17) SquidMath.$(OBJEXT) stat.$(OBJEXT) \ + StatHist.$(OBJEXT) stmem.$(OBJEXT) store.$(OBJEXT) \ + store_client.$(OBJEXT) store_digest.$(OBJEXT) \ + store_dir.$(OBJEXT) store_io.$(OBJEXT) store_key_md5.$(OBJEXT) \ + store_log.$(OBJEXT) store_rebuild.$(OBJEXT) \ + store_swapin.$(OBJEXT) store_swapmeta.$(OBJEXT) \ + store_swapout.$(OBJEXT) StoreFileSystem.$(OBJEXT) \ + StoreIOState.$(OBJEXT) StoreMeta.$(OBJEXT) \ + StoreMetaMD5.$(OBJEXT) StoreMetaSTD.$(OBJEXT) \ + StoreMetaSTDLFS.$(OBJEXT) StoreMetaUnpacker.$(OBJEXT) \ + StoreMetaURL.$(OBJEXT) StoreMetaVary.$(OBJEXT) \ + StoreSwapLogData.$(OBJEXT) $(am__objects_24) tools.$(OBJEXT) \ + tunnel.$(OBJEXT) SwapDir.$(OBJEXT) url.$(OBJEXT) \ + URLScheme.$(OBJEXT) urn.$(OBJEXT) useragent.$(OBJEXT) \ + wccp2.$(OBJEXT) whois.$(OBJEXT) $(am__objects_19) \ + wordlist.$(OBJEXT) +nodist_tests_testEventLoop_OBJECTS = globals.$(OBJEXT) \ + repl_modules.$(OBJEXT) string_arrays.$(OBJEXT) +tests_testEventLoop_OBJECTS = $(am_tests_testEventLoop_OBJECTS) \ + $(nodist_tests_testEventLoop_OBJECTS) +tests_testEventLoop_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testEventLoop_LDFLAGS) $(LDFLAGS) -o $@ +am_tests_testHttpReply_OBJECTS = tests/testHttpReply.$(OBJEXT) \ + tests/testMain.$(OBJEXT) cbdata.$(OBJEXT) ETag.$(OBJEXT) \ + HttpBody.$(OBJEXT) HttpHdrCc.$(OBJEXT) \ + HttpHdrContRange.$(OBJEXT) HttpHdrRange.$(OBJEXT) \ + HttpHdrSc.$(OBJEXT) HttpHdrScTarget.$(OBJEXT) \ + HttpHeader.$(OBJEXT) HttpHeaderTools.$(OBJEXT) \ + HttpMsg.$(OBJEXT) HttpReply.$(OBJEXT) HttpStatusLine.$(OBJEXT) \ + mem.$(OBJEXT) MemBuf.$(OBJEXT) mime_header.$(OBJEXT) \ + Packer.$(OBJEXT) tests/stub_cache_manager.$(OBJEXT) \ + tests/stub_StatHist.$(OBJEXT) tests/stub_store.$(OBJEXT) \ + String.$(OBJEXT) time.$(OBJEXT) +nodist_tests_testHttpReply_OBJECTS = $(am__objects_25) +tests_testHttpReply_OBJECTS = $(am_tests_testHttpReply_OBJECTS) \ + $(nodist_tests_testHttpReply_OBJECTS) +tests_testHttpReply_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testHttpReply_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testHttpRequest_SOURCES_DIST = debug.cc HttpRequest.cc \ + HttpRequestMethod.cc mem.cc String.cc tests/testHttpRequest.h \ + tests/testHttpRequest.cc tests/testHttpRequestMethod.h \ + tests/testHttpRequestMethod.cc tests/testMain.cc time.cc \ + access_log.cc BodyPipe.cc cache_manager.cc cache_cf.cc \ + ProtoPort.cc ProtoPort.h CacheDigest.cc carp.cc cbdata.cc \ + ChunkedCodingParser.cc client_db.cc client_side.cc \ + client_side_reply.cc client_side_request.cc ClientInfo.h \ + clientStream.cc comm_select.cc comm_select.h \ + comm_select_win32.cc comm_poll.cc comm_poll.h comm_devpoll.cc \ + comm_epoll.cc comm_epoll.h comm_kqueue.cc comm_kqueue.h \ + ConfigOption.cc ConfigParser.cc CommonPool.h \ + CompositePoolNode.h delay_pools.cc DelayId.cc DelayId.h \ + DelayIdComposite.h DelayBucket.cc DelayBucket.h DelayConfig.cc \ + DelayConfig.h DelayPool.cc DelayPool.h DelayPools.h \ + DelaySpec.cc DelaySpec.h DelayTagged.cc DelayTagged.h \ + DelayUser.cc DelayUser.h DelayVector.cc DelayVector.h \ + NullDelayId.cc NullDelayId.h disk.cc dlink.h dlink.cc \ + dns_internal.cc DnsLookupDetails.h DnsLookupDetails.cc dns.cc \ + errorpage.cc ETag.cc external_acl.cc ExternalACLEntry.cc fd.cc \ + fde.cc forward.cc fqdncache.cc ftp.cc gopher.cc helper.cc \ + htcp.cc htcp.h http.cc HttpBody.cc HttpHeader.cc \ + HttpHeaderTools.cc HttpHdrCc.cc HttpHdrContRange.cc \ + HttpHdrRange.cc HttpHdrSc.cc HttpHdrScTarget.cc HttpMsg.cc \ + HttpReply.cc HttpStatusLine.cc icp_v2.cc icp_v3.cc ipc.cc \ + ipc_win32.cc ipcache.cc int.cc internal.cc list.cc logfile.cc \ + multicast.cc mem_node.cc MemBuf.cc MemObject.cc mime.cc \ + mime_header.cc neighbors.cc Packer.cc Parsing.cc pconn.cc \ + peer_digest.cc peer_select.cc peer_sourcehash.cc \ + peer_userhash.cc redirect.cc referer.cc refresh.cc \ + RemovalPolicy.cc Server.cc snmp_core.cc snmp_agent.cc \ + ssl_support.cc ssl_support.h SquidMath.h SquidMath.cc stat.cc \ + StatHist.cc stmem.cc store.cc store_client.cc store_digest.cc \ + store_dir.cc store_io.cc store_key_md5.cc store_log.cc \ + store_rebuild.cc store_swapin.cc store_swapmeta.cc \ + store_swapout.cc StoreFileSystem.cc StoreIOState.cc \ + StoreMeta.cc StoreMetaMD5.cc StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc StoreMetaUnpacker.cc StoreMetaURL.cc \ + StoreMetaVary.cc StoreSwapLogData.cc event.cc tools.cc \ + tunnel.cc SwapDir.cc url.cc URLScheme.cc urn.cc useragent.cc \ + wccp2.cc whois.cc win32.cc wordlist.cc +am_tests_testHttpRequest_OBJECTS = debug.$(OBJEXT) \ + HttpRequest.$(OBJEXT) HttpRequestMethod.$(OBJEXT) \ + mem.$(OBJEXT) String.$(OBJEXT) tests/testHttpRequest.$(OBJEXT) \ + tests/testHttpRequestMethod.$(OBJEXT) tests/testMain.$(OBJEXT) \ + time.$(OBJEXT) access_log.$(OBJEXT) BodyPipe.$(OBJEXT) \ + cache_manager.$(OBJEXT) cache_cf.$(OBJEXT) ProtoPort.$(OBJEXT) \ + CacheDigest.$(OBJEXT) carp.$(OBJEXT) cbdata.$(OBJEXT) \ + ChunkedCodingParser.$(OBJEXT) client_db.$(OBJEXT) \ + client_side.$(OBJEXT) client_side_reply.$(OBJEXT) \ + client_side_request.$(OBJEXT) clientStream.$(OBJEXT) \ + $(am__objects_5) ConfigOption.$(OBJEXT) ConfigParser.$(OBJEXT) \ + $(am__objects_7) disk.$(OBJEXT) dlink.$(OBJEXT) \ + $(am__objects_9) errorpage.$(OBJEXT) ETag.$(OBJEXT) \ + external_acl.$(OBJEXT) ExternalACLEntry.$(OBJEXT) fd.$(OBJEXT) \ + fde.$(OBJEXT) forward.$(OBJEXT) fqdncache.$(OBJEXT) \ + ftp.$(OBJEXT) gopher.$(OBJEXT) helper.$(OBJEXT) \ + $(am__objects_10) http.$(OBJEXT) HttpBody.$(OBJEXT) \ + HttpHeader.$(OBJEXT) HttpHeaderTools.$(OBJEXT) \ + HttpHdrCc.$(OBJEXT) HttpHdrContRange.$(OBJEXT) \ + HttpHdrRange.$(OBJEXT) HttpHdrSc.$(OBJEXT) \ + HttpHdrScTarget.$(OBJEXT) HttpMsg.$(OBJEXT) \ + HttpReply.$(OBJEXT) HttpStatusLine.$(OBJEXT) icp_v2.$(OBJEXT) \ + icp_v3.$(OBJEXT) $(am__objects_11) ipcache.$(OBJEXT) \ + int.$(OBJEXT) internal.$(OBJEXT) list.$(OBJEXT) \ + logfile.$(OBJEXT) multicast.$(OBJEXT) mem_node.$(OBJEXT) \ + MemBuf.$(OBJEXT) MemObject.$(OBJEXT) mime.$(OBJEXT) \ + mime_header.$(OBJEXT) neighbors.$(OBJEXT) Packer.$(OBJEXT) \ + Parsing.$(OBJEXT) pconn.$(OBJEXT) peer_digest.$(OBJEXT) \ + peer_select.$(OBJEXT) peer_sourcehash.$(OBJEXT) \ + peer_userhash.$(OBJEXT) redirect.$(OBJEXT) referer.$(OBJEXT) \ + refresh.$(OBJEXT) RemovalPolicy.$(OBJEXT) Server.$(OBJEXT) \ + $(am__objects_15) $(am__objects_17) SquidMath.$(OBJEXT) \ + stat.$(OBJEXT) StatHist.$(OBJEXT) stmem.$(OBJEXT) \ + store.$(OBJEXT) store_client.$(OBJEXT) store_digest.$(OBJEXT) \ + store_dir.$(OBJEXT) store_io.$(OBJEXT) store_key_md5.$(OBJEXT) \ + store_log.$(OBJEXT) store_rebuild.$(OBJEXT) \ + store_swapin.$(OBJEXT) store_swapmeta.$(OBJEXT) \ + store_swapout.$(OBJEXT) StoreFileSystem.$(OBJEXT) \ + StoreIOState.$(OBJEXT) StoreMeta.$(OBJEXT) \ + StoreMetaMD5.$(OBJEXT) StoreMetaSTD.$(OBJEXT) \ + StoreMetaSTDLFS.$(OBJEXT) StoreMetaUnpacker.$(OBJEXT) \ + StoreMetaURL.$(OBJEXT) StoreMetaVary.$(OBJEXT) \ + StoreSwapLogData.$(OBJEXT) $(am__objects_24) tools.$(OBJEXT) \ + tunnel.$(OBJEXT) SwapDir.$(OBJEXT) url.$(OBJEXT) \ + URLScheme.$(OBJEXT) urn.$(OBJEXT) useragent.$(OBJEXT) \ + wccp2.$(OBJEXT) whois.$(OBJEXT) $(am__objects_19) \ + wordlist.$(OBJEXT) +nodist_tests_testHttpRequest_OBJECTS = globals.$(OBJEXT) \ + repl_modules.$(OBJEXT) string_arrays.$(OBJEXT) +tests_testHttpRequest_OBJECTS = $(am_tests_testHttpRequest_OBJECTS) \ + $(nodist_tests_testHttpRequest_OBJECTS) +tests_testHttpRequest_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testHttpRequest_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testNull_SOURCES_DIST = tests/testNull.cc tests/testMain.cc \ + tests/testNull.h tests/stub_internal.cc tests/stub_CommIO.cc \ + tests/stub_store_rebuild.cc fd.cc disk.cc filemap.cc \ + HttpBody.cc HttpReply.cc HttpStatusLine.cc int.cc list.cc \ + MemObject.cc StoreSwapLogData.cc StoreIOState.cc StoreMeta.cc \ + StoreMetaMD5.cc StoreMetaSTD.cc StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc StoreMetaURL.cc StoreMetaVary.cc \ + StoreFileSystem.cc store_io.cc store_swapout.cc \ + store_swapmeta.cc unlinkd.cc win32.cc event.cc CommonPool.h \ + CompositePoolNode.h delay_pools.cc DelayId.cc DelayId.h \ + DelayIdComposite.h DelayBucket.cc DelayBucket.h DelayConfig.cc \ + DelayConfig.h DelayPool.cc DelayPool.h DelayPools.h \ + DelaySpec.cc DelaySpec.h DelayTagged.cc DelayTagged.h \ + DelayUser.cc DelayUser.h DelayVector.cc DelayVector.h \ + NullDelayId.cc NullDelayId.h CacheDigest.cc ConfigParser.cc \ + EventLoop.cc HttpMsg.cc RemovalPolicy.cc store_dir.cc store.cc \ + HttpRequestMethod.cc store_key_md5.cc Parsing.cc \ + ConfigOption.cc SwapDir.cc tests/stub_acl.cc \ + tests/stub_cache_cf.cc tests/stub_helper.cc cbdata.cc \ + String.cc tests/stub_comm.cc tests/stub_client_side_request.cc \ + tests/stub_http.cc mem_node.cc stmem.cc tests/stub_mime.cc \ + HttpHeaderTools.cc HttpHeader.cc mem.cc ClientInfo.h MemBuf.cc \ + HttpHdrContRange.cc Packer.cc HttpHdrCc.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc url.cc StatHist.cc HttpHdrRange.cc ETag.cc \ + tests/stub_errorpage.cc tests/stub_HttpRequest.cc \ + tests/stub_access_log.cc refresh.cc tests/stub_store_client.cc \ + tests/stub_tools.cc tests/testStoreSupport.cc \ + tests/testStoreSupport.h time.cc URLScheme.cc wordlist.cc \ + DiskIO/DiskIOModule.cc DiskIO/ReadRequest.cc \ + DiskIO/ReadRequest.h DiskIO/WriteRequest.cc \ + DiskIO/WriteRequest.h DiskIO/DiskFile.h \ + DiskIO/DiskIOStrategy.h DiskIO/IORequestor.h \ + DiskIO/DiskIOModule.h +am_tests_testNull_OBJECTS = tests/testNull.$(OBJEXT) \ + tests/testMain.$(OBJEXT) $(am__objects_27) +nodist_tests_testNull_OBJECTS = $(am__objects_29) +tests_testNull_OBJECTS = $(am_tests_testNull_OBJECTS) \ + $(nodist_tests_testNull_OBJECTS) +tests_testNull_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testNull_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testStore_SOURCES_DIST = tests/stub_store_swapout.cc \ + tests/testMain.cc tests/stub_MemObject.cc tests/testStore.cc \ + tests/testStore.h tests/CapturingStoreEntry.h \ + tests/testStoreEntryStream.cc tests/testStoreEntryStream.h \ + tests/testStoreController.cc tests/testStoreController.h \ + tests/testStoreHashIndex.cc tests/testStoreHashIndex.h \ + tests/TestSwapDir.cc tests/TestSwapDir.h tests/stub_fd.cc \ + tests/stub_HttpReply.cc tests/stub_cache_manager.cc event.cc \ + CommonPool.h CompositePoolNode.h delay_pools.cc DelayId.cc \ + DelayId.h DelayIdComposite.h DelayBucket.cc DelayBucket.h \ + DelayConfig.cc DelayConfig.h DelayPool.cc DelayPool.h \ + DelayPools.h DelaySpec.cc DelaySpec.h DelayTagged.cc \ + DelayTagged.h DelayUser.cc DelayUser.h DelayVector.cc \ + DelayVector.h NullDelayId.cc NullDelayId.h CacheDigest.cc \ + ConfigParser.cc EventLoop.cc HttpMsg.cc RemovalPolicy.cc \ + store_dir.cc store.cc HttpRequestMethod.cc store_key_md5.cc \ + Parsing.cc ConfigOption.cc SwapDir.cc tests/stub_acl.cc \ + tests/stub_cache_cf.cc tests/stub_helper.cc cbdata.cc \ + String.cc tests/stub_comm.cc tests/stub_client_side_request.cc \ + tests/stub_http.cc mem_node.cc stmem.cc tests/stub_mime.cc \ + HttpHeaderTools.cc HttpHeader.cc mem.cc ClientInfo.h MemBuf.cc \ + HttpHdrContRange.cc Packer.cc HttpHdrCc.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc url.cc StatHist.cc HttpHdrRange.cc ETag.cc \ + tests/stub_errorpage.cc tests/stub_HttpRequest.cc \ + tests/stub_access_log.cc refresh.cc tests/stub_store_client.cc \ + tests/stub_tools.cc tests/testStoreSupport.cc \ + tests/testStoreSupport.h time.cc URLScheme.cc wordlist.cc +am_tests_testStore_OBJECTS = tests/stub_store_swapout.$(OBJEXT) \ + tests/testMain.$(OBJEXT) tests/stub_MemObject.$(OBJEXT) \ + tests/testStore.$(OBJEXT) tests/testStoreEntryStream.$(OBJEXT) \ + tests/testStoreController.$(OBJEXT) \ + tests/testStoreHashIndex.$(OBJEXT) tests/TestSwapDir.$(OBJEXT) \ + tests/stub_fd.$(OBJEXT) tests/stub_HttpReply.$(OBJEXT) \ + tests/stub_cache_manager.$(OBJEXT) $(am__objects_26) +nodist_tests_testStore_OBJECTS = $(am__objects_28) SquidMath.$(OBJEXT) +tests_testStore_OBJECTS = $(am_tests_testStore_OBJECTS) \ + $(nodist_tests_testStore_OBJECTS) +tests_testStore_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testStore_LDFLAGS) $(LDFLAGS) -o $@ +am_tests_testString_OBJECTS = mem.$(OBJEXT) String.$(OBJEXT) \ + tests/testMain.$(OBJEXT) tests/testString.$(OBJEXT) \ + tests/stub_cache_manager.$(OBJEXT) time.$(OBJEXT) +nodist_tests_testString_OBJECTS = $(am__objects_25) +tests_testString_OBJECTS = $(am_tests_testString_OBJECTS) \ + $(nodist_tests_testString_OBJECTS) +tests_testString_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testString_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testURL_SOURCES_DIST = debug.cc url.cc URLScheme.cc \ + HttpRequest.cc HttpRequestMethod.cc mem.cc RemovalPolicy.cc \ + String.cc tests/testURL.cc tests/testURL.h \ + tests/testURLScheme.cc tests/testURLScheme.h tests/testMain.cc \ + time.cc access_log.cc BodyPipe.cc cache_manager.cc cache_cf.cc \ + ProtoPort.cc ProtoPort.h CacheDigest.cc carp.cc cbdata.cc \ + ChunkedCodingParser.cc client_db.cc client_side.cc \ + client_side_reply.cc client_side_request.cc ClientInfo.h \ + clientStream.cc comm_select.cc comm_select.h \ + comm_select_win32.cc comm_poll.cc comm_poll.h comm_devpoll.cc \ + comm_epoll.cc comm_epoll.h comm_kqueue.cc comm_kqueue.h \ + ConfigOption.cc ConfigParser.cc CommonPool.h \ + CompositePoolNode.h delay_pools.cc DelayId.cc DelayId.h \ + DelayIdComposite.h DelayBucket.cc DelayBucket.h DelayConfig.cc \ + DelayConfig.h DelayPool.cc DelayPool.h DelayPools.h \ + DelaySpec.cc DelaySpec.h DelayTagged.cc DelayTagged.h \ + DelayUser.cc DelayUser.h DelayVector.cc DelayVector.h \ + NullDelayId.cc NullDelayId.h disk.cc dlink.h dlink.cc \ + dns_internal.cc DnsLookupDetails.h DnsLookupDetails.cc dns.cc \ + errorpage.cc ETag.cc external_acl.cc ExternalACLEntry.cc fd.cc \ + fde.cc forward.cc fqdncache.cc ftp.cc gopher.cc helper.cc \ + htcp.cc htcp.h http.cc HttpBody.cc HttpHeader.cc \ + HttpHeaderTools.cc HttpHdrCc.cc HttpHdrContRange.cc \ + HttpHdrRange.cc HttpHdrSc.cc HttpHdrScTarget.cc HttpMsg.cc \ + HttpReply.cc HttpStatusLine.cc icp_v2.cc icp_v3.cc ipc.cc \ + ipc_win32.cc ipcache.cc int.cc internal.cc list.cc logfile.cc \ + multicast.cc mem_node.cc MemBuf.cc MemObject.cc mime.cc \ + mime_header.cc neighbors.cc Packer.cc Parsing.cc pconn.cc \ + peer_digest.cc peer_select.cc peer_sourcehash.cc \ + peer_userhash.cc redirect.cc referer.cc refresh.cc Server.cc \ + snmp_core.cc snmp_agent.cc ssl_support.cc ssl_support.h \ + SquidMath.h SquidMath.cc stat.cc StatHist.cc stmem.cc store.cc \ + store_client.cc store_digest.cc store_dir.cc store_io.cc \ + store_key_md5.cc store_log.cc store_rebuild.cc store_swapin.cc \ + store_swapmeta.cc store_swapout.cc StoreFileSystem.cc \ + StoreIOState.cc StoreMeta.cc StoreMetaMD5.cc StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc StoreMetaUnpacker.cc StoreMetaURL.cc \ + StoreMetaVary.cc StoreSwapLogData.cc event.cc tools.cc \ + tunnel.cc SwapDir.cc urn.cc useragent.cc wccp2.cc whois.cc \ + win32.cc wordlist.cc +am_tests_testURL_OBJECTS = debug.$(OBJEXT) url.$(OBJEXT) \ + URLScheme.$(OBJEXT) HttpRequest.$(OBJEXT) \ + HttpRequestMethod.$(OBJEXT) mem.$(OBJEXT) \ + RemovalPolicy.$(OBJEXT) String.$(OBJEXT) \ + tests/testURL.$(OBJEXT) tests/testURLScheme.$(OBJEXT) \ + tests/testMain.$(OBJEXT) time.$(OBJEXT) access_log.$(OBJEXT) \ + BodyPipe.$(OBJEXT) cache_manager.$(OBJEXT) cache_cf.$(OBJEXT) \ + ProtoPort.$(OBJEXT) CacheDigest.$(OBJEXT) carp.$(OBJEXT) \ + cbdata.$(OBJEXT) ChunkedCodingParser.$(OBJEXT) \ + client_db.$(OBJEXT) client_side.$(OBJEXT) \ + client_side_reply.$(OBJEXT) client_side_request.$(OBJEXT) \ + clientStream.$(OBJEXT) $(am__objects_5) ConfigOption.$(OBJEXT) \ + ConfigParser.$(OBJEXT) $(am__objects_7) disk.$(OBJEXT) \ + dlink.$(OBJEXT) $(am__objects_9) errorpage.$(OBJEXT) \ + ETag.$(OBJEXT) external_acl.$(OBJEXT) \ + ExternalACLEntry.$(OBJEXT) fd.$(OBJEXT) fde.$(OBJEXT) \ + forward.$(OBJEXT) fqdncache.$(OBJEXT) ftp.$(OBJEXT) \ + gopher.$(OBJEXT) helper.$(OBJEXT) $(am__objects_10) \ + http.$(OBJEXT) HttpBody.$(OBJEXT) HttpHeader.$(OBJEXT) \ + HttpHeaderTools.$(OBJEXT) HttpHdrCc.$(OBJEXT) \ + HttpHdrContRange.$(OBJEXT) HttpHdrRange.$(OBJEXT) \ + HttpHdrSc.$(OBJEXT) HttpHdrScTarget.$(OBJEXT) \ + HttpMsg.$(OBJEXT) HttpReply.$(OBJEXT) HttpStatusLine.$(OBJEXT) \ + icp_v2.$(OBJEXT) icp_v3.$(OBJEXT) $(am__objects_11) \ + ipcache.$(OBJEXT) int.$(OBJEXT) internal.$(OBJEXT) \ + list.$(OBJEXT) logfile.$(OBJEXT) multicast.$(OBJEXT) \ + mem_node.$(OBJEXT) MemBuf.$(OBJEXT) MemObject.$(OBJEXT) \ + mime.$(OBJEXT) mime_header.$(OBJEXT) neighbors.$(OBJEXT) \ + Packer.$(OBJEXT) Parsing.$(OBJEXT) pconn.$(OBJEXT) \ + peer_digest.$(OBJEXT) peer_select.$(OBJEXT) \ + peer_sourcehash.$(OBJEXT) peer_userhash.$(OBJEXT) \ + redirect.$(OBJEXT) referer.$(OBJEXT) refresh.$(OBJEXT) \ + Server.$(OBJEXT) $(am__objects_15) $(am__objects_17) \ + SquidMath.$(OBJEXT) stat.$(OBJEXT) StatHist.$(OBJEXT) \ + stmem.$(OBJEXT) store.$(OBJEXT) store_client.$(OBJEXT) \ + store_digest.$(OBJEXT) store_dir.$(OBJEXT) store_io.$(OBJEXT) \ + store_key_md5.$(OBJEXT) store_log.$(OBJEXT) \ + store_rebuild.$(OBJEXT) store_swapin.$(OBJEXT) \ + store_swapmeta.$(OBJEXT) store_swapout.$(OBJEXT) \ + StoreFileSystem.$(OBJEXT) StoreIOState.$(OBJEXT) \ + StoreMeta.$(OBJEXT) StoreMetaMD5.$(OBJEXT) \ + StoreMetaSTD.$(OBJEXT) StoreMetaSTDLFS.$(OBJEXT) \ + StoreMetaUnpacker.$(OBJEXT) StoreMetaURL.$(OBJEXT) \ + StoreMetaVary.$(OBJEXT) StoreSwapLogData.$(OBJEXT) \ + $(am__objects_24) tools.$(OBJEXT) tunnel.$(OBJEXT) \ + SwapDir.$(OBJEXT) urn.$(OBJEXT) useragent.$(OBJEXT) \ + wccp2.$(OBJEXT) whois.$(OBJEXT) $(am__objects_19) \ + wordlist.$(OBJEXT) +nodist_tests_testURL_OBJECTS = globals.$(OBJEXT) \ + repl_modules.$(OBJEXT) string_arrays.$(OBJEXT) +tests_testURL_OBJECTS = $(am_tests_testURL_OBJECTS) \ + $(nodist_tests_testURL_OBJECTS) +tests_testURL_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testURL_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_testUfs_SOURCES_DIST = tests/testUfs.cc tests/testMain.cc \ + tests/testUfs.h tests/stub_cache_manager.cc \ + tests/stub_internal.cc tests/stub_CommIO.cc \ + tests/stub_store_rebuild.cc fd.cc disk.cc filemap.cc \ + HttpBody.cc HttpReply.cc HttpStatusLine.cc int.cc list.cc \ + MemObject.cc StoreSwapLogData.cc StoreIOState.cc StoreMeta.cc \ + StoreMetaMD5.cc StoreMetaSTD.cc StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc StoreMetaURL.cc StoreMetaVary.cc \ + StoreFileSystem.cc store_io.cc store_swapout.cc \ + store_swapmeta.cc unlinkd.cc win32.cc event.cc CommonPool.h \ + CompositePoolNode.h delay_pools.cc DelayId.cc DelayId.h \ + DelayIdComposite.h DelayBucket.cc DelayBucket.h DelayConfig.cc \ + DelayConfig.h DelayPool.cc DelayPool.h DelayPools.h \ + DelaySpec.cc DelaySpec.h DelayTagged.cc DelayTagged.h \ + DelayUser.cc DelayUser.h DelayVector.cc DelayVector.h \ + NullDelayId.cc NullDelayId.h CacheDigest.cc ConfigParser.cc \ + EventLoop.cc HttpMsg.cc RemovalPolicy.cc store_dir.cc store.cc \ + HttpRequestMethod.cc store_key_md5.cc Parsing.cc \ + ConfigOption.cc SwapDir.cc tests/stub_acl.cc \ + tests/stub_cache_cf.cc tests/stub_helper.cc cbdata.cc \ + String.cc tests/stub_comm.cc tests/stub_client_side_request.cc \ + tests/stub_http.cc mem_node.cc stmem.cc tests/stub_mime.cc \ + HttpHeaderTools.cc HttpHeader.cc mem.cc ClientInfo.h MemBuf.cc \ + HttpHdrContRange.cc Packer.cc HttpHdrCc.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc url.cc StatHist.cc HttpHdrRange.cc ETag.cc \ + tests/stub_errorpage.cc tests/stub_HttpRequest.cc \ + tests/stub_access_log.cc refresh.cc tests/stub_store_client.cc \ + tests/stub_tools.cc tests/testStoreSupport.cc \ + tests/testStoreSupport.h time.cc URLScheme.cc wordlist.cc \ + DiskIO/DiskIOModule.cc DiskIO/ReadRequest.cc \ + DiskIO/ReadRequest.h DiskIO/WriteRequest.cc \ + DiskIO/WriteRequest.h DiskIO/DiskFile.h \ + DiskIO/DiskIOStrategy.h DiskIO/IORequestor.h \ + DiskIO/DiskIOModule.h +am_tests_testUfs_OBJECTS = tests/testUfs.$(OBJEXT) \ + tests/testMain.$(OBJEXT) tests/stub_cache_manager.$(OBJEXT) \ + $(am__objects_27) +nodist_tests_testUfs_OBJECTS = $(am__objects_29) SquidMath.$(OBJEXT) +tests_testUfs_OBJECTS = $(am_tests_testUfs_OBJECTS) \ + $(nodist_tests_testUfs_OBJECTS) +tests_testUfs_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_testUfs_LDFLAGS) $(LDFLAGS) -o $@ +am__tests_test_http_range_SOURCES_DIST = tests/test_http_range.cc \ + access_log.cc BodyPipe.cc cache_cf.cc ProtoPort.cc ProtoPort.h \ + cache_manager.cc CacheDigest.cc carp.cc cbdata.cc \ + ChunkedCodingParser.cc client_db.cc client_side.cc \ + client_side_reply.cc client_side_request.cc ClientInfo.h \ + clientStream.cc comm_select.cc comm_select.h \ + comm_select_win32.cc comm_poll.cc comm_poll.h comm_devpoll.cc \ + comm_epoll.cc comm_epoll.h comm_kqueue.cc comm_kqueue.h \ + ConfigOption.cc ConfigParser.cc debug.cc CommonPool.h \ + CompositePoolNode.h delay_pools.cc DelayId.cc DelayId.h \ + DelayIdComposite.h DelayBucket.cc DelayBucket.h DelayConfig.cc \ + DelayConfig.h DelayPool.cc DelayPool.h DelayPools.h \ + DelaySpec.cc DelaySpec.h DelayTagged.cc DelayTagged.h \ + DelayUser.cc DelayUser.h DelayVector.cc DelayVector.h \ + NullDelayId.cc NullDelayId.h disk.cc dlink.h dlink.cc \ + dns_internal.cc DnsLookupDetails.h DnsLookupDetails.cc dns.cc \ + errorpage.cc ETag.cc external_acl.cc ExternalACLEntry.cc fd.cc \ + fde.cc forward.cc fqdncache.cc ftp.cc gopher.cc helper.cc \ + htcp.cc htcp.h http.cc HttpBody.cc HttpHdrCc.cc \ + HttpHdrContRange.cc HttpHdrRange.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc HttpHeader.cc HttpHeaderTools.cc HttpMsg.cc \ + HttpReply.cc HttpRequest.cc HttpRequestMethod.cc \ + HttpStatusLine.cc icp_v2.cc icp_v3.cc int.cc internal.cc \ + ipc.cc ipc_win32.cc ipcache.cc list.cc logfile.cc mem.cc \ + mem_node.cc MemObject.cc mime.cc mime_header.cc multicast.cc \ + neighbors.cc Parsing.cc peer_digest.cc peer_select.cc \ + peer_sourcehash.cc peer_userhash.cc pconn.cc redirect.cc \ + referer.cc refresh.cc RemovalPolicy.cc Server.cc snmp_core.cc \ + snmp_agent.cc ssl_support.cc ssl_support.h SquidMath.h \ + SquidMath.cc stat.cc StatHist.cc stmem.cc store.cc \ + store_client.cc store_digest.cc store_dir.cc store_key_md5.cc \ + store_io.cc store_log.cc store_rebuild.cc store_swapin.cc \ + store_swapmeta.cc store_swapout.cc StoreFileSystem.cc \ + StoreIOState.cc StoreMeta.cc StoreMetaMD5.cc StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc StoreMetaUnpacker.cc StoreMetaURL.cc \ + StoreMetaVary.cc StoreSwapLogData.cc String.cc SwapDir.cc \ + event.cc time.cc tools.cc tunnel.cc url.cc URLScheme.cc urn.cc \ + useragent.cc wccp2.cc whois.cc win32.cc wordlist.cc Packer.cc \ + MemBuf.cc +am_tests_test_http_range_OBJECTS = tests/test_http_range.$(OBJEXT) \ + access_log.$(OBJEXT) BodyPipe.$(OBJEXT) cache_cf.$(OBJEXT) \ + ProtoPort.$(OBJEXT) cache_manager.$(OBJEXT) \ + CacheDigest.$(OBJEXT) carp.$(OBJEXT) cbdata.$(OBJEXT) \ + ChunkedCodingParser.$(OBJEXT) client_db.$(OBJEXT) \ + client_side.$(OBJEXT) client_side_reply.$(OBJEXT) \ + client_side_request.$(OBJEXT) clientStream.$(OBJEXT) \ + $(am__objects_5) ConfigOption.$(OBJEXT) ConfigParser.$(OBJEXT) \ + debug.$(OBJEXT) $(am__objects_7) disk.$(OBJEXT) \ + dlink.$(OBJEXT) $(am__objects_9) errorpage.$(OBJEXT) \ + ETag.$(OBJEXT) external_acl.$(OBJEXT) \ + ExternalACLEntry.$(OBJEXT) fd.$(OBJEXT) fde.$(OBJEXT) \ + forward.$(OBJEXT) fqdncache.$(OBJEXT) ftp.$(OBJEXT) \ + gopher.$(OBJEXT) helper.$(OBJEXT) $(am__objects_10) \ + http.$(OBJEXT) HttpBody.$(OBJEXT) HttpHdrCc.$(OBJEXT) \ + HttpHdrContRange.$(OBJEXT) HttpHdrRange.$(OBJEXT) \ + HttpHdrSc.$(OBJEXT) HttpHdrScTarget.$(OBJEXT) \ + HttpHeader.$(OBJEXT) HttpHeaderTools.$(OBJEXT) \ + HttpMsg.$(OBJEXT) HttpReply.$(OBJEXT) HttpRequest.$(OBJEXT) \ + HttpRequestMethod.$(OBJEXT) HttpStatusLine.$(OBJEXT) \ + icp_v2.$(OBJEXT) icp_v3.$(OBJEXT) int.$(OBJEXT) \ + internal.$(OBJEXT) $(am__objects_11) ipcache.$(OBJEXT) \ + list.$(OBJEXT) logfile.$(OBJEXT) mem.$(OBJEXT) \ + mem_node.$(OBJEXT) MemObject.$(OBJEXT) mime.$(OBJEXT) \ + mime_header.$(OBJEXT) multicast.$(OBJEXT) neighbors.$(OBJEXT) \ + Parsing.$(OBJEXT) peer_digest.$(OBJEXT) peer_select.$(OBJEXT) \ + peer_sourcehash.$(OBJEXT) peer_userhash.$(OBJEXT) \ + pconn.$(OBJEXT) redirect.$(OBJEXT) referer.$(OBJEXT) \ + refresh.$(OBJEXT) RemovalPolicy.$(OBJEXT) Server.$(OBJEXT) \ + $(am__objects_15) $(am__objects_17) SquidMath.$(OBJEXT) \ + stat.$(OBJEXT) StatHist.$(OBJEXT) stmem.$(OBJEXT) \ + store.$(OBJEXT) store_client.$(OBJEXT) store_digest.$(OBJEXT) \ + store_dir.$(OBJEXT) store_key_md5.$(OBJEXT) store_io.$(OBJEXT) \ + store_log.$(OBJEXT) store_rebuild.$(OBJEXT) \ + store_swapin.$(OBJEXT) store_swapmeta.$(OBJEXT) \ + store_swapout.$(OBJEXT) StoreFileSystem.$(OBJEXT) \ + StoreIOState.$(OBJEXT) StoreMeta.$(OBJEXT) \ + StoreMetaMD5.$(OBJEXT) StoreMetaSTD.$(OBJEXT) \ + StoreMetaSTDLFS.$(OBJEXT) StoreMetaUnpacker.$(OBJEXT) \ + StoreMetaURL.$(OBJEXT) StoreMetaVary.$(OBJEXT) \ + StoreSwapLogData.$(OBJEXT) String.$(OBJEXT) SwapDir.$(OBJEXT) \ + $(am__objects_24) time.$(OBJEXT) tools.$(OBJEXT) \ + tunnel.$(OBJEXT) url.$(OBJEXT) URLScheme.$(OBJEXT) \ + urn.$(OBJEXT) useragent.$(OBJEXT) wccp2.$(OBJEXT) \ + whois.$(OBJEXT) $(am__objects_19) wordlist.$(OBJEXT) \ + Packer.$(OBJEXT) MemBuf.$(OBJEXT) +nodist_tests_test_http_range_OBJECTS = globals.$(OBJEXT) \ + repl_modules.$(OBJEXT) string_arrays.$(OBJEXT) +tests_test_http_range_OBJECTS = $(am_tests_test_http_range_OBJECTS) \ + $(nodist_tests_test_http_range_OBJECTS) +tests_test_http_range_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(tests_test_http_range_LDFLAGS) $(LDFLAGS) -o $@ +am__ufsdump_SOURCES_DIST = ClientInfo.h cbdata.h cbdata.cc debug.cc \ + int.cc mem.cc MemBuf.cc MemBuf.cci MemBuf.h store_key_md5.cc \ + StoreMeta.cc StoreMetaMD5.cc StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc StoreMetaUnpacker.cc StoreMetaURL.cc \ + StoreMetaVary.cc String.cc time.cc ufsdump.cc dlink.h dlink.cc \ + HttpRequestMethod.cc RemovalPolicy.cc squid.h win32.cc \ + tests/stub_fd.cc +am_ufsdump_OBJECTS = cbdata.$(OBJEXT) debug.$(OBJEXT) int.$(OBJEXT) \ + mem.$(OBJEXT) MemBuf.$(OBJEXT) store_key_md5.$(OBJEXT) \ + StoreMeta.$(OBJEXT) StoreMetaMD5.$(OBJEXT) \ + StoreMetaSTD.$(OBJEXT) StoreMetaSTDLFS.$(OBJEXT) \ + StoreMetaUnpacker.$(OBJEXT) StoreMetaURL.$(OBJEXT) \ + StoreMetaVary.$(OBJEXT) String.$(OBJEXT) time.$(OBJEXT) \ + ufsdump.$(OBJEXT) dlink.$(OBJEXT) HttpRequestMethod.$(OBJEXT) \ + RemovalPolicy.$(OBJEXT) $(am__objects_19) \ + tests/stub_fd.$(OBJEXT) +nodist_ufsdump_OBJECTS = globals.$(OBJEXT) +ufsdump_OBJECTS = $(am_ufsdump_OBJECTS) $(nodist_ufsdump_OBJECTS) +am_unlinkd_OBJECTS = unlinkd_daemon.$(OBJEXT) SquidNew.$(OBJEXT) +unlinkd_OBJECTS = $(am_unlinkd_OBJECTS) +unlinkd_LDADD = $(LDADD) +unlinkd_DEPENDENCIES = $(COMMON_LIBS) $(am__DEPENDENCIES_1) \ + $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/cfgaux/depcomp +am__depfiles_maybe = depfiles +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +CCLD = $(CC) +LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \ + $(LDFLAGS) -o $@ +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \ + $(LDFLAGS) -o $@ +SOURCES = $(libAIO_a_SOURCES) $(libBlocking_a_SOURCES) \ + $(libDiskDaemon_a_SOURCES) $(libDiskThreads_a_SOURCES) \ + $(libsquid_la_SOURCES) $(DiskIO_DiskDaemon_diskd_SOURCES) \ + $(cf_gen_SOURCES) $(dnsserver_SOURCES) \ + $(recv_announce_SOURCES) $(squid_SOURCES) \ + $(EXTRA_squid_SOURCES) $(nodist_squid_SOURCES) \ + $(tests_testACLMaxUserIP_SOURCES) \ + $(nodist_tests_testACLMaxUserIP_SOURCES) \ + $(tests_testAuth_SOURCES) $(nodist_tests_testAuth_SOURCES) \ + $(tests_testBoilerplate_SOURCES) \ + $(nodist_tests_testBoilerplate_SOURCES) \ + $(tests_testCacheManager_SOURCES) \ + $(nodist_tests_testCacheManager_SOURCES) \ + $(tests_testCoss_SOURCES) $(nodist_tests_testCoss_SOURCES) \ + $(tests_testDiskIO_SOURCES) $(nodist_tests_testDiskIO_SOURCES) \ + $(tests_testEvent_SOURCES) $(nodist_tests_testEvent_SOURCES) \ + $(tests_testEventLoop_SOURCES) \ + $(nodist_tests_testEventLoop_SOURCES) \ + $(tests_testHttpReply_SOURCES) \ + $(nodist_tests_testHttpReply_SOURCES) \ + $(tests_testHttpRequest_SOURCES) \ + $(nodist_tests_testHttpRequest_SOURCES) \ + $(tests_testNull_SOURCES) $(nodist_tests_testNull_SOURCES) \ + $(tests_testStore_SOURCES) $(nodist_tests_testStore_SOURCES) \ + $(tests_testString_SOURCES) $(nodist_tests_testString_SOURCES) \ + $(tests_testURL_SOURCES) $(nodist_tests_testURL_SOURCES) \ + $(tests_testUfs_SOURCES) $(nodist_tests_testUfs_SOURCES) \ + $(tests_test_http_range_SOURCES) \ + $(nodist_tests_test_http_range_SOURCES) $(ufsdump_SOURCES) \ + $(nodist_ufsdump_SOURCES) $(unlinkd_SOURCES) +DIST_SOURCES = $(am__libAIO_a_SOURCES_DIST) $(libBlocking_a_SOURCES) \ + $(libDiskDaemon_a_SOURCES) \ + $(am__libDiskThreads_a_SOURCES_DIST) $(libsquid_la_SOURCES) \ + $(DiskIO_DiskDaemon_diskd_SOURCES) $(cf_gen_SOURCES) \ + $(dnsserver_SOURCES) $(recv_announce_SOURCES) \ + $(am__squid_SOURCES_DIST) $(am__EXTRA_squid_SOURCES_DIST) \ + $(tests_testACLMaxUserIP_SOURCES) $(tests_testAuth_SOURCES) \ + $(tests_testBoilerplate_SOURCES) \ + $(am__tests_testCacheManager_SOURCES_DIST) \ + $(am__tests_testCoss_SOURCES_DIST) \ + $(am__tests_testDiskIO_SOURCES_DIST) \ + $(am__tests_testEvent_SOURCES_DIST) \ + $(am__tests_testEventLoop_SOURCES_DIST) \ + $(tests_testHttpReply_SOURCES) \ + $(am__tests_testHttpRequest_SOURCES_DIST) \ + $(am__tests_testNull_SOURCES_DIST) \ + $(am__tests_testStore_SOURCES_DIST) \ + $(tests_testString_SOURCES) $(am__tests_testURL_SOURCES_DIST) \ + $(am__tests_testUfs_SOURCES_DIST) \ + $(am__tests_test_http_range_SOURCES_DIST) \ + $(am__ufsdump_SOURCES_DIST) $(unlinkd_SOURCES) +RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ + html-recursive info-recursive install-data-recursive \ + install-dvi-recursive install-exec-recursive \ + install-html-recursive install-info-recursive \ + install-pdf-recursive install-ps-recursive install-recursive \ + installcheck-recursive installdirs-recursive pdf-recursive \ + ps-recursive uninstall-recursive +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = `echo $$p | sed -e 's|^.*/||'`; +dataDATA_INSTALL = $(INSTALL_DATA) +sysconfDATA_INSTALL = $(INSTALL_DATA) +DATA = $(data_DATA) $(sysconf_DATA) +HEADERS = $(noinst_HEADERS) +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +ETAGS = etags +CTAGS = ctags +DIST_SUBDIRS = base acl fs repl auth ip icmp ident adaptation esi +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +ADAPTATION_LIBS = @ADAPTATION_LIBS@ +ALLOCA = @ALLOCA@ +AMTAR = @AMTAR@ +AR = @AR@ +ARGZ_H = @ARGZ_H@ +AR_R = @AR_R@ +AUTH_LIBS_TO_BUILD = @AUTH_LIBS_TO_BUILD@ +AUTH_MODULES = @AUTH_MODULES@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +BASIC_AUTH_HELPERS = @BASIC_AUTH_HELPERS@ +CACHE_EFFECTIVE_USER = @CACHE_EFFECTIVE_USER@ +CACHE_HTTP_PORT = @CACHE_HTTP_PORT@ +CACHE_ICP_PORT = @CACHE_ICP_PORT@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CGIEXT = @CGIEXT@ +CHMOD = @CHMOD@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CPPUNITCONFIG = @CPPUNITCONFIG@ +CRYPTLIB = @CRYPTLIB@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFAULT_LOG_DIR = @DEFAULT_LOG_DIR@ +DEFAULT_PIDFILE = @DEFAULT_PIDFILE@ + +# Make location configure settings available to the code +DEFS = @DEFS@ -DDEFAULT_CONFIG_FILE=\"$(DEFAULT_CONFIG_FILE)\" \ + -DDEFAULT_SQUID_DATA_DIR=\"$(datadir)\" \ + -DDEFAULT_SQUID_CONFIG_DIR=\"$(sysconfdir)\" +DEPDIR = @DEPDIR@ +DIGEST_AUTH_HELPERS = @DIGEST_AUTH_HELPERS@ +DISK_LIBS = @DISK_LIBS@ +DISK_LINKOBJS = @DISK_LINKOBJS@ +DISK_MODULES = @DISK_MODULES@ +DISK_OS_LIBS = @DISK_OS_LIBS@ +DISK_PROGRAMS = @DISK_PROGRAMS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECAPLIB = @ECAPLIB@ +ECAP_LIBS = @ECAP_LIBS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EPOLL_LIBS = @EPOLL_LIBS@ +EXEEXT = @EXEEXT@ +EXPATLIB = @EXPATLIB@ +EXTERNAL_ACL_HELPERS = @EXTERNAL_ACL_HELPERS@ +FALSE = @FALSE@ +FGREP = @FGREP@ +GREP = @GREP@ +ICAP_LIBS = @ICAP_LIBS@ +INCLTDL = @INCLTDL@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBADD_DL = @LIBADD_DL@ +LIBADD_DLD_LINK = @LIBADD_DLD_LINK@ +LIBADD_DLOPEN = @LIBADD_DLOPEN@ +LIBADD_SHL_LOAD = @LIBADD_SHL_LOAD@ +LIBLTDL = @LIBLTDL@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBSASL = @LIBSASL@ +LIBTOOL = @LIBTOOL@ +LIB_DB = @LIB_DB@ +LIB_LBER = @LIB_LBER@ +LIB_LDAP = @LIB_LDAP@ +LIPO = @LIPO@ +LN = @LN@ +LN_S = @LN_S@ +LTDLDEPS = @LTDLDEPS@ +LTDLINCL = @LTDLINCL@ +LTDLOPEN = @LTDLOPEN@ +LTLIBOBJS = @LTLIBOBJS@ +LT_CONFIG_H = @LT_CONFIG_H@ +LT_DLLOADERS = @LT_DLLOADERS@ +LT_DLPREOPEN = @LT_DLPREOPEN@ +MAINT = @MAINT@ +MAKEINFO = @MAKEINFO@ +MINGW_LIBS = @MINGW_LIBS@ +MKDIR = @MKDIR@ +MKDIR_P = @MKDIR_P@ +MV = @MV@ +NEGOTIATE_AUTH_HELPERS = @NEGOTIATE_AUTH_HELPERS@ +NM = @NM@ +NMEDIT = @NMEDIT@ +NTLM_AUTH_HELPERS = @NTLM_AUTH_HELPERS@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OPT_DEFAULT_HOSTS = @OPT_DEFAULT_HOSTS@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PO2HTML = @PO2HTML@ +RANLIB = @RANLIB@ +REGEXLIB = @REGEXLIB@ +REPL_LIBS = @REPL_LIBS@ +REPL_OBJS = @REPL_OBJS@ +REPL_POLICIES = @REPL_POLICIES@ +RM = @RM@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SH = @SH@ +SHELL = @SHELL@ +SNMPLIB = @SNMPLIB@ +SQUID_CFLAGS = @SQUID_CFLAGS@ +SQUID_CPPUNIT_INC = @SQUID_CPPUNIT_INC@ +SQUID_CPPUNIT_LA = @SQUID_CPPUNIT_LA@ +SQUID_CPPUNIT_LIBS = @SQUID_CPPUNIT_LIBS@ +SQUID_CXXFLAGS = @SQUID_CXXFLAGS@ +SSLLIB = @SSLLIB@ +STORE_LIBS_TO_ADD = @STORE_LIBS_TO_ADD@ +STORE_LIBS_TO_BUILD = @STORE_LIBS_TO_BUILD@ +STORE_TESTS = @STORE_TESTS@ +STRIP = @STRIP@ +TRUE = @TRUE@ +VERSION = @VERSION@ +WIN32_PSAPI = @WIN32_PSAPI@ +XMLLIB = @XMLLIB@ +XTRA_LIBS = @XTRA_LIBS@ +XTRA_OBJS = @XTRA_OBJS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +lt_ECHO = @lt_ECHO@ +ltdl_LIBOBJS = @ltdl_LIBOBJS@ +ltdl_LTLIBOBJS = @ltdl_LTLIBOBJS@ +makesnmplib = @makesnmplib@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +subdirs = @subdirs@ +sys_symbol_underscore = @sys_symbol_underscore@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CFLAGS = $(SQUID_CFLAGS) +AM_CXXFLAGS = $(SQUID_CXXFLAGS) +CLEANFILES = cf_gen_defines.cci cf.data cf_parser.cci \ + squid.conf.default squid.conf.documented globals.cc \ + string_arrays.c repl_modules.cc DiskIO/DiskIOModules_gen.cc \ + test_tools.cc *.a testHeaders +TESTS = $(check_PROGRAMS) testHeaders +INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/include -I$(top_srcdir)/src \ + -I$(top_builddir)/include $(SQUID_CPPUNIT_INC) $(am__append_1) \ + -I$(top_builddir)/src +AUTOMAKE_OPTIONS = subdir-objects +@USE_DNSSERVER_FALSE@DNSSOURCE = dns_internal.cc DnsLookupDetails.h \ +@USE_DNSSERVER_FALSE@ DnsLookupDetails.cc +@USE_DNSSERVER_TRUE@DNSSOURCE = dns.cc DnsLookupDetails.h \ +@USE_DNSSERVER_TRUE@ DnsLookupDetails.cc +@USE_DNSSERVER_FALSE@DNSSERVER = +@USE_DNSSERVER_TRUE@DNSSERVER = dnsserver +SNMP_ALL_SOURCE = \ + snmp_core.cc \ + snmp_agent.cc + +@USE_SNMP_FALSE@SNMP_SOURCE = +@USE_SNMP_TRUE@SNMP_SOURCE = $(SNMP_ALL_SOURCE) +LOADABLE_MODULES_SOURCES = \ + LoadableModule.h \ + LoadableModule.cc \ + LoadableModules.h \ + LoadableModules.cc + +SUBDIRS = base acl fs repl auth ip icmp ident $(am__append_2) \ + $(am__append_3) +@USE_ESI_TRUE@ESI_LOCAL_LIBS = \ +@USE_ESI_TRUE@ esi/libesi.la \ +@USE_ESI_TRUE@ $(top_builddir)/lib/libTrie/src/libTrie.a + +@USE_ESI_FALSE@ESI_LIBS = +@USE_ESI_TRUE@ESI_LIBS = $(ESI_LOCAL_LIBS) \ +@USE_ESI_TRUE@ $(XMLLIB) \ +@USE_ESI_TRUE@ $(EXPATLIB) + +DELAY_POOL_ALL_SOURCE = \ + CommonPool.h \ + CompositePoolNode.h \ + delay_pools.cc \ + DelayId.cc \ + DelayId.h \ + DelayIdComposite.h \ + DelayBucket.cc \ + DelayBucket.h \ + DelayConfig.cc \ + DelayConfig.h \ + DelayPool.cc \ + DelayPool.h \ + DelayPools.h \ + DelaySpec.cc \ + DelaySpec.h \ + DelayTagged.cc \ + DelayTagged.h \ + DelayUser.cc \ + DelayUser.h \ + DelayVector.cc \ + DelayVector.h \ + NullDelayId.cc \ + NullDelayId.h + +@USE_DELAY_POOLS_FALSE@DELAY_POOL_SOURCE = +@USE_DELAY_POOLS_TRUE@DELAY_POOL_SOURCE = $(DELAY_POOL_ALL_SOURCE) +@ENABLE_XPROF_STATS_FALSE@XPROF_STATS_SOURCE = +@ENABLE_XPROF_STATS_TRUE@XPROF_STATS_SOURCE = ProfStats.cc +@ENABLE_HTCP_TRUE@HTCPSOURCE = htcp.cc htcp.h +@MAKE_LEAKFINDER_FALSE@LEAKFINDERSOURCE = +@MAKE_LEAKFINDER_TRUE@LEAKFINDERSOURCE = LeakFinder.cc +@ENABLE_UNLINKD_FALSE@UNLINKDSOURCE = +@ENABLE_UNLINKD_TRUE@UNLINKDSOURCE = unlinkd.cc +@ENABLE_UNLINKD_FALSE@UNLINKD = +@ENABLE_UNLINKD_TRUE@UNLINKD = unlinkd +SSL_ALL_SOURCE = \ + ssl_support.cc \ + ssl_support.h + +@ENABLE_SSL_FALSE@SSL_SOURCE = +@ENABLE_SSL_TRUE@SSL_SOURCE = $(SSL_ALL_SOURCE) +WIN32_ALL_SOURCE = \ + win32.cc \ + WinSvc.cc + +@ENABLE_WIN32SPECIFIC_FALSE@WIN32_SOURCE = +@ENABLE_WIN32SPECIFIC_TRUE@WIN32_SOURCE = win32.cc +@ENABLE_WIN32SPECIFIC_FALSE@WINSVC_SOURCE = +@ENABLE_WIN32SPECIFIC_TRUE@WINSVC_SOURCE = WinSvc.cc +@USE_IPC_WIN32_FALSE@IPC_SOURCE = ipc.cc +@USE_IPC_WIN32_TRUE@IPC_SOURCE = ipc_win32.cc +AIO_WIN32_ALL_SOURCES = \ + DiskIO/AIO/aio_win32.cc \ + DiskIO/AIO/aio_win32.h + +@USE_AIO_WIN32_FALSE@AIO_WIN32_SOURCES = +@USE_AIO_WIN32_TRUE@AIO_WIN32_SOURCES = $(AIO_WIN32_ALL_SOURCES) +@USE_AIOPS_WIN32_FALSE@AIOPS_SOURCE = DiskIO/DiskThreads/aiops.cc +@USE_AIOPS_WIN32_TRUE@AIOPS_SOURCE = DiskIO/DiskThreads/aiops_win32.cc +EXTRA_LIBRARIES = libAIO.a libBlocking.a libDiskDaemon.a libDiskThreads.a +noinst_LIBRARIES = $(DISK_LIBS) +noinst_LTLIBRARIES = libsquid.la + +# libraries used by many targets +COMMON_LIBS = \ + base/libbase.la \ + libsquid.la \ + auth/libacls.la \ + ident/libident.la \ + acl/libacls.la \ + acl/libstate.la \ + auth/libauth.la \ + acl/libapi.la \ + ip/libip.la \ + fs/libfs.la + +cf_gen_SOURCES = cf_gen.cc +nodist_cf_gen_HEADER = cf_gen_defines.cci +cf_gen_LDADD = \ + ../compat/libcompat.la \ + -L../lib -lmiscutil \ + $(EPOLL_LIBS) \ + $(MINGW_LIBS) \ + $(XTRA_LIBS) + +ACL_REGISTRATION_SOURCES = AclRegs.cc AuthReg.cc +DISKIO_SOURCE = \ + DiskIO/DiskIOModule.cc \ + DiskIO/ReadRequest.cc \ + DiskIO/ReadRequest.h \ + DiskIO/WriteRequest.cc \ + DiskIO/WriteRequest.h \ + DiskIO/DiskFile.h \ + DiskIO/DiskIOStrategy.h \ + DiskIO/IORequestor.h \ + DiskIO/DiskIOModule.h \ + DiskIO/ReadRequest.h + +DISKIO_GEN_SOURCE = \ + DiskIO/DiskIOModules_gen.cc + +EXTRA_squid_SOURCES = \ + $(AIO_WIN32_ALL_SOURCES) \ + $(all_AUTHMODULES) \ + ConfigOption.h \ + $(DELAY_POOL_ALL_SOURCE) \ + dns.cc \ + dnsserver.cc \ + dns_internal.cc \ + DnsLookupDetails.cc \ + DnsLookupDetails.h \ + htcp.cc \ + htcp.h \ + ipc.cc \ + ipc_win32.cc \ + ProfStats.cc \ + LeakFinder.cc \ + LeakFinder.h \ + $(SNMP_ALL_SOURCE) \ + $(UNLINKDSOURCE) \ + $(SSL_ALL_SOURCE) \ + $(WIN32_ALL_SOURCE) \ + $(LOADABLE_MODULES_SOURCES) \ + DiskIO/DiskThreads/aiops.cc \ + DiskIO/DiskThreads/aiops_win32.cc + +squid_COMMSOURCES = \ + comm_select.cc \ + comm_select.h \ + comm_select_win32.cc \ + comm_poll.cc \ + comm_poll.h \ + comm_devpoll.cc \ + comm_epoll.cc \ + comm_epoll.h \ + comm_kqueue.cc \ + comm_kqueue.h + + +# common library for all the binaries and tests. This is kindof a catch all +# and smaller libraries split from this are encouraged. Using lt convenience +# libraries, dependencies should not be a problem either. +libsquid_la_SOURCES = \ + comm.cc \ + comm.h \ + CommCalls.cc \ + CommCalls.h \ + DescriptorSet.cc \ + DescriptorSet.h \ + SquidConfig.cc \ + TextException.cc \ + TextException.h + +squid_SOURCES = $(ACL_REGISTRATION_SOURCES) access_log.cc \ + AccessLogEntry.h AsyncEngine.cc AsyncEngine.h cache_cf.cc \ + ProtoPort.cc ProtoPort.h CacheDigest.cc cache_manager.cc \ + CacheManager.h carp.cc cbdata.cc cbdata.h \ + ChunkedCodingParser.cc ChunkedCodingParser.h client_db.cc \ + client_side.cc client_side.h client_side_reply.cc \ + client_side_reply.h client_side_request.cc \ + client_side_request.h ClientInfo.h BodyPipe.cc BodyPipe.h \ + ClientInfo.h ClientRequestContext.h clientStream.cc \ + clientStream.h CommIO.h CompletionDispatcher.cc \ + CompletionDispatcher.h $(squid_COMMSOURCES) CommRead.h \ + ConfigOption.cc ConfigParser.cc ConfigParser.h \ + ConnectionDetail.h debug.cc Debug.h defines.h \ + $(DELAY_POOL_SOURCE) disk.cc $(DISKIO_SOURCE) dlink.h dlink.cc \ + $(DNSSOURCE) enums.h errorpage.cc errorpage.h ETag.cc event.cc \ + event.h EventLoop.h EventLoop.cc external_acl.cc ExternalACL.h \ + ExternalACLEntry.cc ExternalACLEntry.h fd.cc fde.cc fde.h \ + filemap.cc forward.cc forward.h fqdncache.cc ftp.cc Generic.h \ + globals.h gopher.cc helper.cc helper.h HierarchyLogEntry.h \ + $(HTCPSOURCE) http.cc http.h HttpStatusCode.h \ + HttpStatusLine.cc HttpStatusLine.h HttpHdrCc.cc \ + HttpHdrRange.cc HttpHdrSc.cc HttpHdrSc.h HttpHdrScTarget.cc \ + HttpHdrScTarget.h HttpHdrContRange.cc HttpHdrContRange.h \ + HttpHeader.cc HttpHeader.h HttpHeaderMask.h HttpHeaderRange.h \ + HttpHeaderTools.cc HttpBody.cc HttpMsg.cc HttpMsg.h \ + HttpReply.cc HttpReply.h HttpRequest.cc HttpRequest.h \ + HttpRequestMethod.cc HttpRequestMethod.h HttpVersion.h ICP.h \ + icp_v2.cc icp_v3.cc int.cc internal.cc $(IPC_SOURCE) \ + ipcache.cc $(LEAKFINDERSOURCE) list.cc logfile.cc main.cc \ + mem.cc mem_node.cc mem_node.h Mem.h MemBuf.cc MemObject.cc \ + MemObject.h mime.cc mime_header.cc multicast.cc neighbors.cc \ + Packer.cc Packer.h Parsing.cc Parsing.h $(XPROF_STATS_SOURCE) \ + pconn.cc pconn.h PeerDigest.h peer_digest.cc peer_select.cc \ + peer_sourcehash.cc peer_userhash.cc PeerSelectState.h \ + PingData.h protos.h redirect.cc referer.cc refresh.cc \ + RemovalPolicy.cc RemovalPolicy.h send-announce.cc \ + $(SNMP_SOURCE) squid.h SquidMath.h SquidMath.cc SquidNew.cc \ + $(SSL_SOURCE) stat.cc StatHist.cc String.cc stmem.cc stmem.h \ + store.cc Store.h StoreFileSystem.cc StoreFileSystem.h \ + StoreHashIndex.h store_io.cc StoreIOBuffer.h StoreIOState.cc \ + StoreIOState.h store_client.cc StoreClient.h store_digest.cc \ + store_dir.cc store_key_md5.cc store_log.cc store_rebuild.cc \ + store_swapin.cc store_swapmeta.cc store_swapout.cc \ + StoreMeta.cc StoreMeta.h StoreMetaMD5.cc StoreMetaMD5.h \ + StoreMetaSTD.cc StoreMetaSTD.h StoreMetaSTDLFS.cc \ + StoreMetaSTDLFS.h StoreMetaObjSize.h StoreMetaUnpacker.cc \ + StoreMetaUnpacker.h StoreMetaURL.cc StoreMetaURL.h \ + StoreMetaVary.cc StoreMetaVary.h StoreSearch.h \ + StoreSwapLogData.cc StoreSwapLogData.h Server.cc Server.h \ + structs.h SwapDir.cc SwapDir.h time.cc tools.cc tunnel.cc \ + typedefs.h $(UNLINKDSOURCE) url.cc URL.h URLScheme.cc \ + URLScheme.h urn.cc useragent.cc wccp.cc wccp2.cc whois.cc \ + wordlist.cc wordlist.h $(WIN32_SOURCE) $(WINSVC_SOURCE) \ + $(am__append_4) +noinst_HEADERS = \ + client_side_request.cci \ + MemBuf.cci \ + MemBuf.h \ + Store.cci \ + StoreEntryStream.h \ + String.cci \ + SquidString.h \ + SquidTime.h + +nodist_squid_SOURCES = \ + $(DISKIO_GEN_SOURCE) \ + repl_modules.cc \ + cf_parser.cci \ + globals.cc \ + string_arrays.c + +squid_LDADD = $(COMMON_LIBS) icmp/libicmp.la icmp/libicmp-core.la \ + ../compat/libcompat.la -L../lib $(XTRA_OBJS) $(DISK_LINKOBJS) \ + $(REPL_OBJS) $(DISK_LIBS) $(DISK_OS_LIBS) $(CRYPTLIB) \ + $(REGEXLIB) $(SNMPLIB) ${ADAPTATION_LIBS} $(ESI_LIBS) \ + $(SSLLIB) -lmiscutil $(EPOLL_LIBS) $(MINGW_LIBS) $(XTRA_LIBS) \ + $(am__append_5) +squid_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(DISK_LIBS) \ + $(DISK_LINKOBJS) \ + $(REPL_OBJS) \ + $(SNMPLIB) \ + ${ADAPTATION_LIBS} \ + $(ESI_LOCAL_LIBS) \ + $(COMMON_LIBS) + +@USE_LOADABLE_MODULES_TRUE@squid_LDFLAGS = \ +@USE_LOADABLE_MODULES_TRUE@ -export-dynamic -dlopen force + +# when static module linking is supported and enabled: +# squid_LDFLAGS = \ +# -all-static -dlopen self +# +unlinkd_SOURCES = unlinkd_daemon.cc SquidNew.cc +dnsserver_SOURCES = dnsserver.cc SquidNew.cc stub_debug.cc +recv_announce_SOURCES = recv-announce.cc SquidNew.cc +ufsdump_SOURCES = \ + ClientInfo.h \ + cbdata.h \ + cbdata.cc \ + debug.cc \ + int.cc \ + mem.cc \ + MemBuf.cc \ + MemBuf.cci \ + MemBuf.h \ + store_key_md5.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + String.cc \ + time.cc \ + ufsdump.cc \ + dlink.h \ + dlink.cc \ + HttpRequestMethod.cc \ + RemovalPolicy.cc \ + squid.h \ + $(WIN32_SOURCE) \ + tests/stub_fd.cc + +ufsdump_LDADD = \ + $(COMMON_LIBS) \ + $(XTRA_OBJS) \ + $(REPL_OBJS) \ + $(CRYPTLIB) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + $(SSLLIB) \ + -L$(top_builddir)/lib -lmiscutil \ + $(EPOLL_LIBS) \ + $(MINGW_LIBS) \ + $(XTRA_LIBS) + +ufsdump_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(COMMON_LIBS) \ + $(DISK_LIBS) \ + $(DISK_LINKOBJS) \ + $(REPL_OBJS) + +nodist_ufsdump_SOURCES = \ + globals.cc + +BUILT_SOURCES = \ + cf_gen_defines.cci \ + cf_parser.cci \ + globals.cc \ + string_arrays.c \ + repl_modules.cc + +sysconf_DATA = \ + squid.conf.default \ + squid.conf.documented \ + mime.conf.default + +data_DATA = \ + mib.txt + +LDADD = $(COMMON_LIBS)\ + -L../lib \ + -lmiscutil \ + $(EPOLL_LIBS) \ + $(MINGW_LIBS) \ + $(XTRA_LIBS) + +EXTRA_DIST = \ + cf_gen_defines \ + cf.data.pre \ + cf.data.depend \ + DiskIO/modules.sh \ + mk-globals-c.pl \ + mk-globals-c.awk \ + mk-string-arrays.pl \ + mk-string-arrays.awk \ + repl_modules.sh \ + stub_debug.cc \ + mib.txt \ + mime.conf.default + +libAIO_a_SOURCES = \ + $(AIO_WIN32_SOURCES) \ + DiskIO/AIO/async_io.h \ + DiskIO/AIO/AIODiskFile.cc \ + DiskIO/AIO/AIODiskFile.h \ + DiskIO/AIO/AIODiskIOStrategy.cc \ + DiskIO/AIO/AIODiskIOStrategy.h \ + DiskIO/AIO/AIODiskIOModule.cc \ + DiskIO/AIO/AIODiskIOModule.h + +libBlocking_a_SOURCES = \ + DiskIO/Blocking/BlockingFile.cc \ + DiskIO/Blocking/BlockingFile.h \ + DiskIO/Blocking/BlockingIOStrategy.cc \ + DiskIO/Blocking/BlockingIOStrategy.h \ + DiskIO/Blocking/BlockingDiskIOModule.cc \ + DiskIO/Blocking/BlockingDiskIOModule.h + +libDiskDaemon_a_SOURCES = \ + DiskIO/DiskDaemon/DiskdFile.cc \ + DiskIO/DiskDaemon/DiskdFile.h \ + DiskIO/DiskDaemon/DiskdIOStrategy.cc \ + DiskIO/DiskDaemon/DiskdIOStrategy.h \ + DiskIO/DiskDaemon/diomsg.h \ + DiskIO/DiskDaemon/DiskDaemonDiskIOModule.cc \ + DiskIO/DiskDaemon/DiskDaemonDiskIOModule.h + +libDiskThreads_a_SOURCES = \ + $(AIOPS_SOURCE) \ + DiskIO/DiskThreads/async_io.cc \ + DiskIO/DiskThreads/DiskThreads.h \ + DiskIO/DiskThreads/DiskThreadsDiskFile.cc \ + DiskIO/DiskThreads/DiskThreadsDiskFile.h \ + DiskIO/DiskThreads/DiskThreadsDiskIOModule.cc \ + DiskIO/DiskThreads/DiskThreadsDiskIOModule.h \ + DiskIO/DiskThreads/DiskThreadsIOStrategy.cc \ + DiskIO/DiskThreads/DiskThreadsIOStrategy.h + +DiskIO_DiskDaemon_diskd_SOURCES = DiskIO/DiskDaemon/diskd.cc +DiskIO_DiskDaemon_diskd_LDADD = $(top_builddir)/lib/libmiscutil.a $(XTRA_LIBS) +DEFAULT_HTTP_PORT = $(CACHE_HTTP_PORT) +DEFAULT_ICP_PORT = $(CACHE_ICP_PORT) +DEFAULT_PREFIX = $(prefix) +DEFAULT_CONFIG_DIR = $(sysconfdir) +DEFAULT_CONFIG_FILE = $(DEFAULT_CONFIG_DIR)/squid.conf +DEFAULT_MIME_TABLE = $(DEFAULT_CONFIG_DIR)/mime.conf +DEFAULT_DNSSERVER = $(libexecdir)/`echo dnsserver | sed '$(transform);s/$$/$(EXEEXT)/'` +DEFAULT_LOG_PREFIX = $(DEFAULT_LOG_DIR) +DEFAULT_CACHE_LOG = $(DEFAULT_LOG_PREFIX)/cache.log +DEFAULT_ACCESS_LOG = $(DEFAULT_LOG_PREFIX)/access.log +DEFAULT_STORE_LOG = $(DEFAULT_LOG_PREFIX)/store.log +DEFAULT_PID_FILE = $(DEFAULT_PIDFILE) +DEFAULT_NETDB_FILE = $(DEFAULT_LOG_PREFIX)/netdb.state +DEFAULT_SWAP_DIR = $(localstatedir)/cache +DEFAULT_PINGER = $(libexecdir)/`echo pinger | sed '$(transform);s/$$/$(EXEEXT)/'` +DEFAULT_UNLINKD = $(libexecdir)/`echo unlinkd | sed '$(transform);s/$$/$(EXEEXT)/'` +DEFAULT_DISKD = $(libexecdir)/`echo diskd | sed '$(transform);s/$$/$(EXEEXT)/'` +DEFAULT_ICON_DIR = $(datadir)/icons +DEFAULT_ERROR_DIR = $(datadir)/errors +DEFAULT_HOSTS = $(OPT_DEFAULT_HOSTS) + +# stock tools for unit tests - library independent versions of dlink_list +# etc. +# globals.cc is needed by test_tools.cc. +# Neither of these should be disted from here. +TESTSOURCES = \ + test_tools.cc \ + globals.cc + + +# sources needed by those tests that need event.cc; incomplete +TEST_CALL_SOURCES = \ + event.cc + + +### Template for new Unit Test Program +#tests_testX_SOURCES=\ +# tests/testX.h \ +# tests/testX.cc \ +# tests/testMain.cc \ +# X.h \ +# X.cc +#nodist_tests_testX_SOURCES=\ +# $(TESTSOURCES) +#tests_testX_LDFLAGS = $(LIBADD_DL) +#tests_testX_LDADD=\ +# $(SQUID_CPPUNIT_LIBS) \ +# $(SQUID_CPPUNIT_LA) \ +# -L../lib -lmiscutil +#tests_testX_DEPENDENCIES= $(SQUID_CPPUNIT_LA) \ +# $(top_builddir)/lib/libmiscutil.a + +# - add other component .(h|cc) files needed to link and run tests +tests_testHttpReply_SOURCES = \ + tests/testHttpReply.h \ + tests/testHttpReply.cc \ + tests/testMain.cc \ + cbdata.h \ + cbdata.cc \ + ETag.cc \ + HttpBody.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.h \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.h \ + HttpHdrSc.cc \ + HttpHdrScTarget.h \ + HttpHdrScTarget.cc \ + HttpHeader.h \ + HttpHeader.cc \ + HttpHeaderMask.h \ + HttpHeaderTools.cc \ + HttpMsg.h \ + HttpMsg.cc \ + HttpReply.h \ + HttpReply.cc \ + HttpStatusCode.h \ + HttpStatusLine.h \ + HttpStatusLine.cc \ + mem.cc \ + MemBuf.h \ + MemBuf.cc \ + mime_header.cc \ + Packer.h \ + Packer.cc \ + tests/stub_cache_manager.cc \ + tests/stub_StatHist.cc \ + tests/stub_store.cc \ + SquidString.h \ + String.cc \ + SquidTime.h \ + time.cc + +nodist_tests_testHttpReply_SOURCES = \ + $(TESTSOURCES) + +tests_testHttpReply_LDFLAGS = $(LIBADD_DL) +tests_testHttpReply_LDADD = \ + acl/libapi.la \ + acl/libstate.la \ + auth/libauth.la \ + ip/libip.la \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + -L../lib -lmiscutil \ + $(XTRA_LIBS) + +tests_testHttpReply_DEPENDENCIES = $(SQUID_CPPUNIT_LA) \ + $(top_builddir)/lib/libmiscutil.a + +tests_testAuth_SOURCES = \ + tests/testAuth.cc tests/testMain.cc tests/testAuth.h \ + ConfigParser.cc \ + tests/stub_acl.cc tests/stub_cache_cf.cc \ + tests/stub_helper.cc cbdata.cc String.cc \ + tests/stub_store.cc HttpHeaderTools.cc HttpHeader.cc mem.cc ClientInfo.h \ + MemBuf.cc HttpHdrContRange.cc Packer.cc HttpHdrCc.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc url.cc \ + StatHist.cc HttpHdrRange.cc ETag.cc tests/stub_errorpage.cc \ + tests/stub_HttpRequest.cc tests/stub_DelayId.cc \ + tests/stub_MemObject.cc mem_node.cc \ + tests/stub_cache_manager.cc \ + stmem.cc \ + tests/stub_comm.cc \ + tests/stub_http.cc \ + HttpMsg.cc \ + HttpRequestMethod.cc \ + tests/stub_mime.cc \ + tests/stub_access_log.cc \ + time.cc \ + URLScheme.cc \ + $(TEST_CALL_SOURCES) \ + wordlist.cc + +nodist_tests_testAuth_SOURCES = \ + $(TESTSOURCES) + +tests_testAuth_LDADD = \ + $(COMMON_LIBS) \ + -L../lib -lmiscutil \ + $(REGEXLIB) \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testAuth_LDFLAGS = $(LIBADD_DL) +tests_testAuth_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(SQUID_CPPUNIT_LA) + +tests_testACLMaxUserIP_SOURCES = \ + cbdata.cc \ + ClientInfo.h \ + ConfigParser.cc \ + ETag.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrCc.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + mem_node.cc \ + Packer.cc \ + Parsing.cc \ + StatHist.cc \ + stmem.cc \ + String.cc \ + $(TEST_CALL_SOURCES) \ + tests/stub_cache_cf.cc \ + tests/stub_comm.cc \ + tests/stub_DelayId.cc \ + tests/stub_MemObject.cc \ + tests/stub_store.cc \ + tests/stub_cache_manager.cc \ + tests/testACLMaxUserIP.cc \ + tests/testACLMaxUserIP.h \ + tests/testMain.cc \ + time.cc \ + mem.cc \ + MemBuf.cc \ + wordlist.cc + +nodist_tests_testACLMaxUserIP_SOURCES = \ + $(TESTSOURCES) + +tests_testACLMaxUserIP_LDADD = \ + $(COMMON_LIBS) \ + -L../lib -lmiscutil \ + $(REGEXLIB) \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testACLMaxUserIP_LDFLAGS = $(LIBADD_DL) +tests_testACLMaxUserIP_DEPENDENCIES = \ + $(SQUID_CPPUNIT_LA) + +tests_testBoilerplate_SOURCES = \ + tests/testBoilerplate.cc \ + tests/testMain.cc \ + tests/testBoilerplate.h \ + time.cc + +nodist_tests_testBoilerplate_SOURCES = \ + $(TESTSOURCES) + +tests_testBoilerplate_LDADD = \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testBoilerplate_LDFLAGS = $(LIBADD_DL) +tests_testBoilerplate_DEPENDENCIES = \ + $(SQUID_CPPUNIT_LA) + +tests_testCacheManager_SOURCES = \ + debug.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + String.cc \ + tests/testCacheManager.cc \ + tests/testCacheManager.h \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + RemovalPolicy.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc + +nodist_tests_testCacheManager_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c + +tests_testCacheManager_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testCacheManager_LDFLAGS = $(LIBADD_DL) +tests_testCacheManager_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +tests_testDiskIO_SOURCES = \ + $(SWAP_TEST_SOURCES) \ + tests/testDiskIO.cc \ + tests/testDiskIO.h \ + tests/testMain.cc \ + tests/stub_cache_manager.cc + +nodist_tests_testDiskIO_SOURCES = \ + $(SWAP_TEST_GEN_SOURCES) \ + SquidMath.cc \ + SquidMath.h + +tests_testDiskIO_LDADD = \ + $(SWAP_TEST_LDADD) \ + $(DISK_LIBS) \ + $(DISK_OS_LIBS) \ + $(COMMON_LIBS) \ + SquidConfig.o \ + $(XTRA_LIBS) + +tests_testDiskIO_LDFLAGS = $(LIBADD_DL) +tests_testDiskIO_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(DISK_LIBS) \ + $(SWAP_TEST_DS) \ + $(SQUID_CPPUNIT_LA) + +tests_testEvent_SOURCES = \ + debug.cc \ + EventLoop.h \ + EventLoop.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + RemovalPolicy.cc \ + String.cc \ + tests/CapturingStoreEntry.h \ + tests/testEvent.cc \ + tests/testEvent.h \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc + +nodist_tests_testEvent_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c + +tests_testEvent_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testEvent_LDFLAGS = $(LIBADD_DL) +tests_testEvent_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +tests_testEventLoop_SOURCES = \ + debug.cc \ + EventLoop.h \ + EventLoop.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + RemovalPolicy.cc \ + String.cc \ + tests/testEventLoop.cc \ + tests/testEventLoop.h \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc + +nodist_tests_testEventLoop_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c + +tests_testEventLoop_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testEventLoop_LDFLAGS = $(LIBADD_DL) +tests_testEventLoop_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +tests_test_http_range_SOURCES = \ + tests/test_http_range.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + cache_manager.cc \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + debug.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + int.cc \ + internal.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + list.cc \ + logfile.cc \ + mem.cc \ + mem_node.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + multicast.cc \ + neighbors.cc \ + Parsing.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + pconn.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + RemovalPolicy.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_key_md5.cc \ + store_io.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + String.cc \ + SwapDir.cc \ + $(TEST_CALL_SOURCES) \ + time.cc \ + tools.cc \ + tunnel.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc \ + Packer.cc \ + MemBuf.cc + +nodist_tests_test_http_range_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c + +tests_test_http_range_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_test_http_range_LDFLAGS = $(LIBADD_DL) +tests_test_http_range_DEPENDENCIES = \ + $(SQUID_CPPUNIT_LA) + +tests_testHttpRequest_SOURCES = \ + debug.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + String.cc \ + tests/testHttpRequest.h \ + tests/testHttpRequest.cc \ + tests/testHttpRequestMethod.h \ + tests/testHttpRequestMethod.cc \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + RemovalPolicy.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + url.cc \ + URLScheme.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc + +nodist_tests_testHttpRequest_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c + +tests_testHttpRequest_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(REGEXLIB) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testHttpRequest_LDFLAGS = $(LIBADD_DL) +tests_testHttpRequest_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + + +# TODO:mime.cc drags in HttpReply.cc +# delay pools need client_side_request.cc +# store_key_md5 wants the method. +STORE_TEST_SOURCES = \ + $(TEST_CALL_SOURCES) \ + $(DELAY_POOL_SOURCE) \ + CacheDigest.cc \ + ConfigParser.cc \ + EventLoop.cc \ + HttpMsg.cc \ + RemovalPolicy.cc \ + store_dir.cc \ + store.cc \ + HttpRequestMethod.cc \ + store_key_md5.cc \ + Parsing.cc \ + ConfigOption.cc \ + SwapDir.cc \ + tests/stub_acl.cc tests/stub_cache_cf.cc \ + tests/stub_helper.cc cbdata.cc String.cc \ + tests/stub_comm.cc \ + tests/stub_client_side_request.cc \ + tests/stub_http.cc \ + mem_node.cc \ + stmem.cc \ + tests/stub_mime.cc \ + HttpHeaderTools.cc HttpHeader.cc mem.cc ClientInfo.h \ + MemBuf.cc HttpHdrContRange.cc Packer.cc HttpHdrCc.cc HttpHdrSc.cc \ + HttpHdrScTarget.cc url.cc \ + StatHist.cc HttpHdrRange.cc ETag.cc tests/stub_errorpage.cc \ + tests/stub_HttpRequest.cc tests/stub_access_log.cc \ + refresh.cc \ + tests/stub_store_client.cc \ + tests/stub_tools.cc \ + tests/testStoreSupport.cc \ + tests/testStoreSupport.h \ + time.cc \ + URLScheme.cc \ + wordlist.cc + +STORE_TEST_GEN_SOURCES = \ + $(TESTSOURCES) \ + string_arrays.c + +tests_testStore_SOURCES = \ + tests/stub_store_swapout.cc \ + tests/testMain.cc \ + tests/stub_MemObject.cc \ + tests/testStore.cc \ + tests/testStore.h \ + tests/CapturingStoreEntry.h \ + tests/testStoreEntryStream.cc \ + tests/testStoreEntryStream.h \ + tests/testStoreController.cc \ + tests/testStoreController.h \ + tests/testStoreHashIndex.cc \ + tests/testStoreHashIndex.h \ + tests/TestSwapDir.cc \ + tests/TestSwapDir.h \ + tests/stub_fd.cc \ + tests/stub_HttpReply.cc \ + tests/stub_cache_manager.cc \ + $(STORE_TEST_SOURCES) + +nodist_tests_testStore_SOURCES = \ + $(STORE_TEST_GEN_SOURCES) \ + SquidMath.cc \ + SquidMath.h + +tests_testStore_LDADD = \ + $(COMMON_LIBS) \ + -L../lib -lmiscutil \ + $(REGEXLIB) \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testStore_LDFLAGS = $(LIBADD_DL) +tests_testStore_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(SQUID_CPPUNIT_LA) + +tests_testString_SOURCES = \ + ClientInfo.h \ + mem.cc \ + String.cc \ + tests/testMain.cc \ + tests/testString.cc \ + tests/testString.h \ + tests/stub_cache_manager.cc \ + time.cc + +nodist_tests_testString_SOURCES = \ + $(TESTSOURCES) + +tests_testString_LDADD = \ + $(COMMON_LIBS) \ + -L../lib -lmiscutil \ + $(REGEXLIB) \ + $(SQUID_CPPUNIT_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testString_LDFLAGS = $(LIBADD_DL) +tests_testString_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(SQUID_CPPUNIT_LA) + +SWAP_TEST_SOURCES = \ + tests/stub_internal.cc \ + tests/stub_CommIO.cc \ + tests/stub_store_rebuild.cc \ + fd.cc \ + disk.cc \ + filemap.cc \ + HttpBody.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + int.cc \ + list.cc \ + MemObject.cc \ + StoreSwapLogData.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreFileSystem.cc \ + store_io.cc \ + store_swapout.cc \ + store_swapmeta.cc \ + $(UNLINKDSOURCE) \ + $(WIN32_SOURCE) \ + $(STORE_TEST_SOURCES) \ + $(DISKIO_SOURCE) + +SWAP_TEST_GEN_SOURCES = \ + $(STORE_TEST_GEN_SOURCES) \ + $(DISKIO_GEN_SOURCE) + +SWAP_TEST_LDADD = \ + $(REGEXLIB) \ + $(COMMON_LIBS) \ + $(REPL_OBJS) \ + $(DISK_LIBS) \ + $(DISK_OS_LIBS) \ + -L../lib -lmiscutil \ + acl/libapi.la \ + $(SQUID_CPPUNIT_LIBS) \ + $(XTRA_LIBS) + +SWAP_TEST_DS = \ + $(top_builddir)/lib/libmiscutil.a \ + repl_modules.o \ + $(DISK_LIBS) \ + $(COMMON_LIBS) \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +tests_testUfs_SOURCES = \ + tests/testUfs.cc \ + tests/testMain.cc \ + tests/testUfs.h \ + tests/stub_cache_manager.cc \ + $(SWAP_TEST_SOURCES) + +nodist_tests_testUfs_SOURCES = \ + $(SWAP_TEST_GEN_SOURCES) \ + SquidMath.cc \ + SquidMath.h + +tests_testUfs_LDADD = \ + $(SWAP_TEST_LDADD) \ + $(COMMON_LIBS) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testUfs_LDFLAGS = $(LIBADD_DL) +tests_testUfs_DEPENDENCIES = \ + $(SWAP_TEST_DS) + +tests_testCoss_SOURCES = \ + tests/testCoss.cc \ + tests/testMain.cc \ + tests/testCoss.h \ + tests/stub_cache_manager.cc \ + $(SWAP_TEST_SOURCES) + +nodist_tests_testCoss_SOURCES = \ + $(SWAP_TEST_GEN_SOURCES) + +tests_testCoss_LDADD = \ + libsquid.la \ + $(SWAP_TEST_LDADD) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testCoss_LDFLAGS = $(LIBADD_DL) +tests_testCoss_DEPENDENCIES = \ + $(SWAP_TEST_DS) + +tests_testNull_SOURCES = \ + tests/testNull.cc \ + tests/testMain.cc \ + tests/testNull.h \ + $(SWAP_TEST_SOURCES) + +nodist_tests_testNull_SOURCES = \ + $(SWAP_TEST_GEN_SOURCES) + +tests_testNull_LDADD = \ + $(SWAP_TEST_LDADD) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testNull_LDFLAGS = $(LIBADD_DL) +tests_testNull_DEPENDENCIES = \ + $(SWAP_TEST_DS) + +tests_testURL_SOURCES = \ + debug.cc \ + url.cc \ + URLScheme.cc \ + HttpRequest.cc \ + HttpRequestMethod.cc \ + mem.cc \ + RemovalPolicy.cc \ + String.cc \ + tests/testURL.cc \ + tests/testURL.h \ + tests/testURLScheme.cc \ + tests/testURLScheme.h \ + tests/testMain.cc \ + time.cc \ + access_log.cc \ + BodyPipe.cc \ + cache_manager.cc \ + cache_cf.cc \ + ProtoPort.cc \ + ProtoPort.h \ + CacheDigest.cc \ + carp.cc \ + cbdata.cc \ + ChunkedCodingParser.cc \ + client_db.cc \ + client_side.cc \ + client_side_reply.cc \ + client_side_request.cc \ + ClientInfo.h \ + clientStream.cc \ + $(squid_COMMSOURCES) \ + ConfigOption.cc \ + ConfigParser.cc \ + $(DELAY_POOL_SOURCE) \ + disk.cc \ + dlink.h \ + dlink.cc \ + $(DNSSOURCE) \ + errorpage.cc \ + ETag.cc \ + external_acl.cc \ + ExternalACLEntry.cc \ + fd.cc \ + fde.cc \ + forward.cc \ + fqdncache.cc \ + ftp.cc \ + gopher.cc \ + helper.cc \ + $(HTCPSOURCE) \ + http.cc \ + HttpBody.cc \ + HttpHeader.cc \ + HttpHeaderTools.cc \ + HttpHdrCc.cc \ + HttpHdrContRange.cc \ + HttpHdrRange.cc \ + HttpHdrSc.cc \ + HttpHdrScTarget.cc \ + HttpMsg.cc \ + HttpReply.cc \ + HttpStatusLine.cc \ + icp_v2.cc \ + icp_v3.cc \ + $(IPC_SOURCE) \ + ipcache.cc \ + int.cc \ + internal.cc \ + list.cc \ + logfile.cc \ + multicast.cc \ + mem_node.cc \ + MemBuf.cc \ + MemObject.cc \ + mime.cc \ + mime_header.cc \ + neighbors.cc \ + Packer.cc \ + Parsing.cc \ + pconn.cc \ + peer_digest.cc \ + peer_select.cc \ + peer_sourcehash.cc \ + peer_userhash.cc \ + redirect.cc \ + referer.cc \ + refresh.cc \ + Server.cc \ + $(SNMP_SOURCE) \ + $(SSL_SOURCE) \ + SquidMath.h \ + SquidMath.cc \ + stat.cc \ + StatHist.cc \ + stmem.cc \ + store.cc \ + store_client.cc \ + store_digest.cc \ + store_dir.cc \ + store_io.cc \ + store_key_md5.cc \ + store_log.cc \ + store_rebuild.cc \ + store_swapin.cc \ + store_swapmeta.cc \ + store_swapout.cc \ + StoreFileSystem.cc \ + StoreIOState.cc \ + StoreMeta.cc \ + StoreMetaMD5.cc \ + StoreMetaSTD.cc \ + StoreMetaSTDLFS.cc \ + StoreMetaUnpacker.cc \ + StoreMetaURL.cc \ + StoreMetaVary.cc \ + StoreSwapLogData.cc \ + $(TEST_CALL_SOURCES) \ + tools.cc \ + tunnel.cc \ + SwapDir.cc \ + urn.cc \ + useragent.cc \ + wccp2.cc \ + whois.cc \ + $(WIN32_SOURCE) \ + wordlist.cc + +nodist_tests_testURL_SOURCES = \ + globals.cc \ + repl_modules.cc \ + string_arrays.c + +tests_testURL_LDADD = \ + $(COMMON_LIBS) \ + icmp/libicmp.la icmp/libicmp-core.la \ + $(REGEXLIB) \ + $(REPL_OBJS) \ + ${ADAPTATION_LIBS} \ + $(ESI_LIBS) \ + $(SNMPLIB) \ + -L../lib -lmiscutil \ + $(SQUID_CPPUNIT_LIBS) \ + $(SQUID_CPPUNIT_LA) \ + $(SSLLIB) \ + $(XTRA_LIBS) + +tests_testURL_LDFLAGS = $(LIBADD_DL) +tests_testURL_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ + $(REPL_OBJS) \ + $(SQUID_CPPUNIT_LA) + +all: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) all-recursive + +.SUFFIXES: +.SUFFIXES: .c .cc .lo .o .obj +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(top_srcdir)/src/Common.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +clean-noinstLIBRARIES: + -test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES) +DiskIO/AIO/$(am__dirstamp): + @$(MKDIR_P) DiskIO/AIO + @: > DiskIO/AIO/$(am__dirstamp) +DiskIO/AIO/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) DiskIO/AIO/$(DEPDIR) + @: > DiskIO/AIO/$(DEPDIR)/$(am__dirstamp) +DiskIO/AIO/aio_win32.$(OBJEXT): DiskIO/AIO/$(am__dirstamp) \ + DiskIO/AIO/$(DEPDIR)/$(am__dirstamp) +DiskIO/AIO/AIODiskFile.$(OBJEXT): DiskIO/AIO/$(am__dirstamp) \ + DiskIO/AIO/$(DEPDIR)/$(am__dirstamp) +DiskIO/AIO/AIODiskIOStrategy.$(OBJEXT): DiskIO/AIO/$(am__dirstamp) \ + DiskIO/AIO/$(DEPDIR)/$(am__dirstamp) +DiskIO/AIO/AIODiskIOModule.$(OBJEXT): DiskIO/AIO/$(am__dirstamp) \ + DiskIO/AIO/$(DEPDIR)/$(am__dirstamp) +libAIO.a: $(libAIO_a_OBJECTS) $(libAIO_a_DEPENDENCIES) + -rm -f libAIO.a + $(libAIO_a_AR) libAIO.a $(libAIO_a_OBJECTS) $(libAIO_a_LIBADD) + $(RANLIB) libAIO.a +DiskIO/Blocking/$(am__dirstamp): + @$(MKDIR_P) DiskIO/Blocking + @: > DiskIO/Blocking/$(am__dirstamp) +DiskIO/Blocking/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) DiskIO/Blocking/$(DEPDIR) + @: > DiskIO/Blocking/$(DEPDIR)/$(am__dirstamp) +DiskIO/Blocking/BlockingFile.$(OBJEXT): \ + DiskIO/Blocking/$(am__dirstamp) \ + DiskIO/Blocking/$(DEPDIR)/$(am__dirstamp) +DiskIO/Blocking/BlockingIOStrategy.$(OBJEXT): \ + DiskIO/Blocking/$(am__dirstamp) \ + DiskIO/Blocking/$(DEPDIR)/$(am__dirstamp) +DiskIO/Blocking/BlockingDiskIOModule.$(OBJEXT): \ + DiskIO/Blocking/$(am__dirstamp) \ + DiskIO/Blocking/$(DEPDIR)/$(am__dirstamp) +libBlocking.a: $(libBlocking_a_OBJECTS) $(libBlocking_a_DEPENDENCIES) + -rm -f libBlocking.a + $(libBlocking_a_AR) libBlocking.a $(libBlocking_a_OBJECTS) $(libBlocking_a_LIBADD) + $(RANLIB) libBlocking.a +DiskIO/DiskDaemon/$(am__dirstamp): + @$(MKDIR_P) DiskIO/DiskDaemon + @: > DiskIO/DiskDaemon/$(am__dirstamp) +DiskIO/DiskDaemon/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) DiskIO/DiskDaemon/$(DEPDIR) + @: > DiskIO/DiskDaemon/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskDaemon/DiskdFile.$(OBJEXT): \ + DiskIO/DiskDaemon/$(am__dirstamp) \ + DiskIO/DiskDaemon/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskDaemon/DiskdIOStrategy.$(OBJEXT): \ + DiskIO/DiskDaemon/$(am__dirstamp) \ + DiskIO/DiskDaemon/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskDaemon/DiskDaemonDiskIOModule.$(OBJEXT): \ + DiskIO/DiskDaemon/$(am__dirstamp) \ + DiskIO/DiskDaemon/$(DEPDIR)/$(am__dirstamp) +libDiskDaemon.a: $(libDiskDaemon_a_OBJECTS) $(libDiskDaemon_a_DEPENDENCIES) + -rm -f libDiskDaemon.a + $(libDiskDaemon_a_AR) libDiskDaemon.a $(libDiskDaemon_a_OBJECTS) $(libDiskDaemon_a_LIBADD) + $(RANLIB) libDiskDaemon.a +DiskIO/DiskThreads/$(am__dirstamp): + @$(MKDIR_P) DiskIO/DiskThreads + @: > DiskIO/DiskThreads/$(am__dirstamp) +DiskIO/DiskThreads/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) DiskIO/DiskThreads/$(DEPDIR) + @: > DiskIO/DiskThreads/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskThreads/aiops.$(OBJEXT): \ + DiskIO/DiskThreads/$(am__dirstamp) \ + DiskIO/DiskThreads/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskThreads/aiops_win32.$(OBJEXT): \ + DiskIO/DiskThreads/$(am__dirstamp) \ + DiskIO/DiskThreads/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskThreads/async_io.$(OBJEXT): \ + DiskIO/DiskThreads/$(am__dirstamp) \ + DiskIO/DiskThreads/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskThreads/DiskThreadsDiskFile.$(OBJEXT): \ + DiskIO/DiskThreads/$(am__dirstamp) \ + DiskIO/DiskThreads/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskThreads/DiskThreadsDiskIOModule.$(OBJEXT): \ + DiskIO/DiskThreads/$(am__dirstamp) \ + DiskIO/DiskThreads/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskThreads/DiskThreadsIOStrategy.$(OBJEXT): \ + DiskIO/DiskThreads/$(am__dirstamp) \ + DiskIO/DiskThreads/$(DEPDIR)/$(am__dirstamp) +libDiskThreads.a: $(libDiskThreads_a_OBJECTS) $(libDiskThreads_a_DEPENDENCIES) + -rm -f libDiskThreads.a + $(libDiskThreads_a_AR) libDiskThreads.a $(libDiskThreads_a_OBJECTS) $(libDiskThreads_a_LIBADD) + $(RANLIB) libDiskThreads.a + +clean-noinstLTLIBRARIES: + -test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES) + @list='$(noinst_LTLIBRARIES)'; for p in $$list; do \ + dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \ + test "$$dir" != "$$p" || dir=.; \ + echo "rm -f \"$${dir}/so_locations\""; \ + rm -f "$${dir}/so_locations"; \ + done +libsquid.la: $(libsquid_la_OBJECTS) $(libsquid_la_DEPENDENCIES) + $(CXXLINK) $(libsquid_la_OBJECTS) $(libsquid_la_LIBADD) $(LIBS) +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)" + @list='$(bin_PROGRAMS)'; for p in $$list; do \ + p1=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + if test -f $$p \ + || test -f $$p1 \ + ; then \ + f=`echo "$$p1" | sed 's,^.*/,,;$(transform);s/$$/$(EXEEXT)/'`; \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(binPROGRAMS_INSTALL) '$$p' '$(DESTDIR)$(bindir)/$$f'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(binPROGRAMS_INSTALL) "$$p" "$(DESTDIR)$(bindir)/$$f" || exit 1; \ + else :; fi; \ + done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; for p in $$list; do \ + f=`echo "$$p" | sed 's,^.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/'`; \ + echo " rm -f '$(DESTDIR)$(bindir)/$$f'"; \ + rm -f "$(DESTDIR)$(bindir)/$$f"; \ + done + +clean-binPROGRAMS: + @list='$(bin_PROGRAMS)'; for p in $$list; do \ + f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f $$p $$f"; \ + rm -f $$p $$f ; \ + done + +clean-checkPROGRAMS: + @list='$(check_PROGRAMS)'; for p in $$list; do \ + f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f $$p $$f"; \ + rm -f $$p $$f ; \ + done +install-libexecPROGRAMS: $(libexec_PROGRAMS) + @$(NORMAL_INSTALL) + test -z "$(libexecdir)" || $(MKDIR_P) "$(DESTDIR)$(libexecdir)" + @list='$(libexec_PROGRAMS)'; for p in $$list; do \ + p1=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + if test -f $$p \ + || test -f $$p1 \ + ; then \ + f=`echo "$$p1" | sed 's,^.*/,,;$(transform);s/$$/$(EXEEXT)/'`; \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(libexecPROGRAMS_INSTALL) '$$p' '$(DESTDIR)$(libexecdir)/$$f'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(libexecPROGRAMS_INSTALL) "$$p" "$(DESTDIR)$(libexecdir)/$$f" || exit 1; \ + else :; fi; \ + done + +uninstall-libexecPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(libexec_PROGRAMS)'; for p in $$list; do \ + f=`echo "$$p" | sed 's,^.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/'`; \ + echo " rm -f '$(DESTDIR)$(libexecdir)/$$f'"; \ + rm -f "$(DESTDIR)$(libexecdir)/$$f"; \ + done + +clean-libexecPROGRAMS: + @list='$(libexec_PROGRAMS)'; for p in $$list; do \ + f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f $$p $$f"; \ + rm -f $$p $$f ; \ + done + +clean-noinstPROGRAMS: + @list='$(noinst_PROGRAMS)'; for p in $$list; do \ + f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f $$p $$f"; \ + rm -f $$p $$f ; \ + done +install-sbinPROGRAMS: $(sbin_PROGRAMS) + @$(NORMAL_INSTALL) + test -z "$(sbindir)" || $(MKDIR_P) "$(DESTDIR)$(sbindir)" + @list='$(sbin_PROGRAMS)'; for p in $$list; do \ + p1=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + if test -f $$p \ + || test -f $$p1 \ + ; then \ + f=`echo "$$p1" | sed 's,^.*/,,;$(transform);s/$$/$(EXEEXT)/'`; \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(sbinPROGRAMS_INSTALL) '$$p' '$(DESTDIR)$(sbindir)/$$f'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(sbinPROGRAMS_INSTALL) "$$p" "$(DESTDIR)$(sbindir)/$$f" || exit 1; \ + else :; fi; \ + done + +uninstall-sbinPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(sbin_PROGRAMS)'; for p in $$list; do \ + f=`echo "$$p" | sed 's,^.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/'`; \ + echo " rm -f '$(DESTDIR)$(sbindir)/$$f'"; \ + rm -f "$(DESTDIR)$(sbindir)/$$f"; \ + done + +clean-sbinPROGRAMS: + @list='$(sbin_PROGRAMS)'; for p in $$list; do \ + f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f $$p $$f"; \ + rm -f $$p $$f ; \ + done +DiskIO/DiskDaemon/diskd.$(OBJEXT): DiskIO/DiskDaemon/$(am__dirstamp) \ + DiskIO/DiskDaemon/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskDaemon/diskd$(EXEEXT): $(DiskIO_DiskDaemon_diskd_OBJECTS) $(DiskIO_DiskDaemon_diskd_DEPENDENCIES) DiskIO/DiskDaemon/$(am__dirstamp) + @rm -f DiskIO/DiskDaemon/diskd$(EXEEXT) + $(CXXLINK) $(DiskIO_DiskDaemon_diskd_OBJECTS) $(DiskIO_DiskDaemon_diskd_LDADD) $(LIBS) +cf_gen$(EXEEXT): $(cf_gen_OBJECTS) $(cf_gen_DEPENDENCIES) + @rm -f cf_gen$(EXEEXT) + $(CXXLINK) $(cf_gen_OBJECTS) $(cf_gen_LDADD) $(LIBS) +dnsserver$(EXEEXT): $(dnsserver_OBJECTS) $(dnsserver_DEPENDENCIES) + @rm -f dnsserver$(EXEEXT) + $(CXXLINK) $(dnsserver_OBJECTS) $(dnsserver_LDADD) $(LIBS) +recv-announce$(EXEEXT): $(recv_announce_OBJECTS) $(recv_announce_DEPENDENCIES) + @rm -f recv-announce$(EXEEXT) + $(CXXLINK) $(recv_announce_OBJECTS) $(recv_announce_LDADD) $(LIBS) +DiskIO/$(am__dirstamp): + @$(MKDIR_P) DiskIO + @: > DiskIO/$(am__dirstamp) +DiskIO/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) DiskIO/$(DEPDIR) + @: > DiskIO/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskIOModule.$(OBJEXT): DiskIO/$(am__dirstamp) \ + DiskIO/$(DEPDIR)/$(am__dirstamp) +DiskIO/ReadRequest.$(OBJEXT): DiskIO/$(am__dirstamp) \ + DiskIO/$(DEPDIR)/$(am__dirstamp) +DiskIO/WriteRequest.$(OBJEXT): DiskIO/$(am__dirstamp) \ + DiskIO/$(DEPDIR)/$(am__dirstamp) +DiskIO/DiskIOModules_gen.$(OBJEXT): DiskIO/$(am__dirstamp) \ + DiskIO/$(DEPDIR)/$(am__dirstamp) +squid$(EXEEXT): $(squid_OBJECTS) $(squid_DEPENDENCIES) + @rm -f squid$(EXEEXT) + $(squid_LINK) $(squid_OBJECTS) $(squid_LDADD) $(LIBS) +tests/$(am__dirstamp): + @$(MKDIR_P) tests + @: > tests/$(am__dirstamp) +tests/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) tests/$(DEPDIR) + @: > tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_cache_cf.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_comm.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_DelayId.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_MemObject.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_store.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_cache_manager.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testACLMaxUserIP.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testMain.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testACLMaxUserIP$(EXEEXT): $(tests_testACLMaxUserIP_OBJECTS) $(tests_testACLMaxUserIP_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testACLMaxUserIP$(EXEEXT) + $(tests_testACLMaxUserIP_LINK) $(tests_testACLMaxUserIP_OBJECTS) $(tests_testACLMaxUserIP_LDADD) $(LIBS) +tests/testAuth.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_acl.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_helper.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_errorpage.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_HttpRequest.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_http.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_mime.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_access_log.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testAuth$(EXEEXT): $(tests_testAuth_OBJECTS) $(tests_testAuth_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testAuth$(EXEEXT) + $(tests_testAuth_LINK) $(tests_testAuth_OBJECTS) $(tests_testAuth_LDADD) $(LIBS) +tests/testBoilerplate.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testBoilerplate$(EXEEXT): $(tests_testBoilerplate_OBJECTS) $(tests_testBoilerplate_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testBoilerplate$(EXEEXT) + $(tests_testBoilerplate_LINK) $(tests_testBoilerplate_OBJECTS) $(tests_testBoilerplate_LDADD) $(LIBS) +tests/testCacheManager.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testCacheManager$(EXEEXT): $(tests_testCacheManager_OBJECTS) $(tests_testCacheManager_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testCacheManager$(EXEEXT) + $(tests_testCacheManager_LINK) $(tests_testCacheManager_OBJECTS) $(tests_testCacheManager_LDADD) $(LIBS) +tests/testCoss.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_internal.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_CommIO.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_store_rebuild.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_client_side_request.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_store_client.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_tools.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testStoreSupport.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testCoss$(EXEEXT): $(tests_testCoss_OBJECTS) $(tests_testCoss_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testCoss$(EXEEXT) + $(tests_testCoss_LINK) $(tests_testCoss_OBJECTS) $(tests_testCoss_LDADD) $(LIBS) +tests/testDiskIO.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testDiskIO$(EXEEXT): $(tests_testDiskIO_OBJECTS) $(tests_testDiskIO_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testDiskIO$(EXEEXT) + $(tests_testDiskIO_LINK) $(tests_testDiskIO_OBJECTS) $(tests_testDiskIO_LDADD) $(LIBS) +tests/testEvent.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testEvent$(EXEEXT): $(tests_testEvent_OBJECTS) $(tests_testEvent_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testEvent$(EXEEXT) + $(tests_testEvent_LINK) $(tests_testEvent_OBJECTS) $(tests_testEvent_LDADD) $(LIBS) +tests/testEventLoop.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testEventLoop$(EXEEXT): $(tests_testEventLoop_OBJECTS) $(tests_testEventLoop_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testEventLoop$(EXEEXT) + $(tests_testEventLoop_LINK) $(tests_testEventLoop_OBJECTS) $(tests_testEventLoop_LDADD) $(LIBS) +tests/testHttpReply.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_StatHist.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testHttpReply$(EXEEXT): $(tests_testHttpReply_OBJECTS) $(tests_testHttpReply_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testHttpReply$(EXEEXT) + $(tests_testHttpReply_LINK) $(tests_testHttpReply_OBJECTS) $(tests_testHttpReply_LDADD) $(LIBS) +tests/testHttpRequest.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testHttpRequestMethod.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testHttpRequest$(EXEEXT): $(tests_testHttpRequest_OBJECTS) $(tests_testHttpRequest_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testHttpRequest$(EXEEXT) + $(tests_testHttpRequest_LINK) $(tests_testHttpRequest_OBJECTS) $(tests_testHttpRequest_LDADD) $(LIBS) +tests/testNull.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testNull$(EXEEXT): $(tests_testNull_OBJECTS) $(tests_testNull_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testNull$(EXEEXT) + $(tests_testNull_LINK) $(tests_testNull_OBJECTS) $(tests_testNull_LDADD) $(LIBS) +tests/stub_store_swapout.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testStore.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testStoreEntryStream.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testStoreController.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testStoreHashIndex.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/TestSwapDir.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_fd.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/stub_HttpReply.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testStore$(EXEEXT): $(tests_testStore_OBJECTS) $(tests_testStore_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testStore$(EXEEXT) + $(tests_testStore_LINK) $(tests_testStore_OBJECTS) $(tests_testStore_LDADD) $(LIBS) +tests/testString.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testString$(EXEEXT): $(tests_testString_OBJECTS) $(tests_testString_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testString$(EXEEXT) + $(tests_testString_LINK) $(tests_testString_OBJECTS) $(tests_testString_LDADD) $(LIBS) +tests/testURL.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testURLScheme.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testURL$(EXEEXT): $(tests_testURL_OBJECTS) $(tests_testURL_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testURL$(EXEEXT) + $(tests_testURL_LINK) $(tests_testURL_OBJECTS) $(tests_testURL_LDADD) $(LIBS) +tests/testUfs.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/testUfs$(EXEEXT): $(tests_testUfs_OBJECTS) $(tests_testUfs_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/testUfs$(EXEEXT) + $(tests_testUfs_LINK) $(tests_testUfs_OBJECTS) $(tests_testUfs_LDADD) $(LIBS) +tests/test_http_range.$(OBJEXT): tests/$(am__dirstamp) \ + tests/$(DEPDIR)/$(am__dirstamp) +tests/test_http_range$(EXEEXT): $(tests_test_http_range_OBJECTS) $(tests_test_http_range_DEPENDENCIES) tests/$(am__dirstamp) + @rm -f tests/test_http_range$(EXEEXT) + $(tests_test_http_range_LINK) $(tests_test_http_range_OBJECTS) $(tests_test_http_range_LDADD) $(LIBS) +ufsdump$(EXEEXT): $(ufsdump_OBJECTS) $(ufsdump_DEPENDENCIES) + @rm -f ufsdump$(EXEEXT) + $(CXXLINK) $(ufsdump_OBJECTS) $(ufsdump_LDADD) $(LIBS) +unlinkd$(EXEEXT): $(unlinkd_OBJECTS) $(unlinkd_DEPENDENCIES) + @rm -f unlinkd$(EXEEXT) + $(CXXLINK) $(unlinkd_OBJECTS) $(unlinkd_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + -rm -f DiskIO/AIO/AIODiskFile.$(OBJEXT) + -rm -f DiskIO/AIO/AIODiskIOModule.$(OBJEXT) + -rm -f DiskIO/AIO/AIODiskIOStrategy.$(OBJEXT) + -rm -f DiskIO/AIO/aio_win32.$(OBJEXT) + -rm -f DiskIO/Blocking/BlockingDiskIOModule.$(OBJEXT) + -rm -f DiskIO/Blocking/BlockingFile.$(OBJEXT) + -rm -f DiskIO/Blocking/BlockingIOStrategy.$(OBJEXT) + -rm -f DiskIO/DiskDaemon/DiskDaemonDiskIOModule.$(OBJEXT) + -rm -f DiskIO/DiskDaemon/DiskdFile.$(OBJEXT) + -rm -f DiskIO/DiskDaemon/DiskdIOStrategy.$(OBJEXT) + -rm -f DiskIO/DiskDaemon/diskd.$(OBJEXT) + -rm -f DiskIO/DiskIOModule.$(OBJEXT) + -rm -f DiskIO/DiskIOModules_gen.$(OBJEXT) + -rm -f DiskIO/DiskThreads/DiskThreadsDiskFile.$(OBJEXT) + -rm -f DiskIO/DiskThreads/DiskThreadsDiskIOModule.$(OBJEXT) + -rm -f DiskIO/DiskThreads/DiskThreadsIOStrategy.$(OBJEXT) + -rm -f DiskIO/DiskThreads/aiops.$(OBJEXT) + -rm -f DiskIO/DiskThreads/aiops_win32.$(OBJEXT) + -rm -f DiskIO/DiskThreads/async_io.$(OBJEXT) + -rm -f DiskIO/ReadRequest.$(OBJEXT) + -rm -f DiskIO/WriteRequest.$(OBJEXT) + -rm -f tests/TestSwapDir.$(OBJEXT) + -rm -f tests/stub_CommIO.$(OBJEXT) + -rm -f tests/stub_DelayId.$(OBJEXT) + -rm -f tests/stub_HttpReply.$(OBJEXT) + -rm -f tests/stub_HttpRequest.$(OBJEXT) + -rm -f tests/stub_MemObject.$(OBJEXT) + -rm -f tests/stub_StatHist.$(OBJEXT) + -rm -f tests/stub_access_log.$(OBJEXT) + -rm -f tests/stub_acl.$(OBJEXT) + -rm -f tests/stub_cache_cf.$(OBJEXT) + -rm -f tests/stub_cache_manager.$(OBJEXT) + -rm -f tests/stub_client_side_request.$(OBJEXT) + -rm -f tests/stub_comm.$(OBJEXT) + -rm -f tests/stub_errorpage.$(OBJEXT) + -rm -f tests/stub_fd.$(OBJEXT) + -rm -f tests/stub_helper.$(OBJEXT) + -rm -f tests/stub_http.$(OBJEXT) + -rm -f tests/stub_internal.$(OBJEXT) + -rm -f tests/stub_mime.$(OBJEXT) + -rm -f tests/stub_store.$(OBJEXT) + -rm -f tests/stub_store_client.$(OBJEXT) + -rm -f tests/stub_store_rebuild.$(OBJEXT) + -rm -f tests/stub_store_swapout.$(OBJEXT) + -rm -f tests/stub_tools.$(OBJEXT) + -rm -f tests/testACLMaxUserIP.$(OBJEXT) + -rm -f tests/testAuth.$(OBJEXT) + -rm -f tests/testBoilerplate.$(OBJEXT) + -rm -f tests/testCacheManager.$(OBJEXT) + -rm -f tests/testCoss.$(OBJEXT) + -rm -f tests/testDiskIO.$(OBJEXT) + -rm -f tests/testEvent.$(OBJEXT) + -rm -f tests/testEventLoop.$(OBJEXT) + -rm -f tests/testHttpReply.$(OBJEXT) + -rm -f tests/testHttpRequest.$(OBJEXT) + -rm -f tests/testHttpRequestMethod.$(OBJEXT) + -rm -f tests/testMain.$(OBJEXT) + -rm -f tests/testNull.$(OBJEXT) + -rm -f tests/testStore.$(OBJEXT) + -rm -f tests/testStoreController.$(OBJEXT) + -rm -f tests/testStoreEntryStream.$(OBJEXT) + -rm -f tests/testStoreHashIndex.$(OBJEXT) + -rm -f tests/testStoreSupport.$(OBJEXT) + -rm -f tests/testString.$(OBJEXT) + -rm -f tests/testURL.$(OBJEXT) + -rm -f tests/testURLScheme.$(OBJEXT) + -rm -f tests/testUfs.$(OBJEXT) + -rm -f tests/test_http_range.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AclRegs.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AsyncEngine.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AuthReg.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BodyPipe.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CacheDigest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ChunkedCodingParser.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CommCalls.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CompletionDispatcher.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ConfigOption.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ConfigParser.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DelayBucket.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DelayConfig.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DelayId.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DelayPool.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DelaySpec.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DelayTagged.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DelayUser.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DelayVector.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DescriptorSet.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DnsLookupDetails.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ETag.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/EventLoop.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ExternalACLEntry.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpBody.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpHdrCc.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpHdrContRange.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpHdrRange.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpHdrSc.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpHdrScTarget.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpHeader.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpHeaderTools.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpMsg.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpReply.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpRequest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpRequestMethod.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HttpStatusLine.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LeakFinder.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LoadableModule.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LoadableModules.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MemBuf.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MemObject.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/NullDelayId.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Packer.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Parsing.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ProfStats.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ProtoPort.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/RemovalPolicy.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Server.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SquidConfig.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SquidMath.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SquidNew.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StatHist.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreFileSystem.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreIOState.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreMeta.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreMetaMD5.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreMetaSTD.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreMetaSTDLFS.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreMetaURL.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreMetaUnpacker.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreMetaVary.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StoreSwapLogData.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/String.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SwapDir.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/TextException.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/URLScheme.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/WinSvc.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/access_log.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cache_cf.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cache_manager.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/carp.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cbdata.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cf_gen.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/clientStream.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/client_db.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/client_side.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/client_side_reply.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/client_side_request.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/comm.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/comm_devpoll.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/comm_epoll.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/comm_kqueue.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/comm_poll.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/comm_select.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/comm_select_win32.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/debug.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/delay_pools.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/disk.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dlink.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dns.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dns_internal.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dnsserver.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/errorpage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/event.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/external_acl.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fd.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fde.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/filemap.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fqdncache.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ftp.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/globals.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gopher.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/helper.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/htcp.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/http.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/icp_v2.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/icp_v3.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/int.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/internal.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipc.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipc_win32.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipcache.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/list.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/logfile.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mem.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mem_node.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mime.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mime_header.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/multicast.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/neighbors.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pconn.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/peer_digest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/peer_select.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/peer_sourcehash.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/peer_userhash.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/recv-announce.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/redirect.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/referer.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/refresh.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/repl_modules.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/send-announce.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/snmp_agent.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/snmp_core.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ssl_support.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stat.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stmem.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_client.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_digest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_dir.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_io.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_key_md5.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_log.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_rebuild.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_swapin.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_swapmeta.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/store_swapout.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/string_arrays.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stub_debug.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_tools.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/time.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tools.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tunnel.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ufsdump.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/unlinkd.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/unlinkd_daemon.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/url.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/urn.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/useragent.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/wccp.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/wccp2.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/whois.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/win32.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/wordlist.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/$(DEPDIR)/DiskIOModule.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/$(DEPDIR)/DiskIOModules_gen.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/$(DEPDIR)/ReadRequest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/$(DEPDIR)/WriteRequest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/AIO/$(DEPDIR)/AIODiskFile.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/AIO/$(DEPDIR)/AIODiskIOModule.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/AIO/$(DEPDIR)/AIODiskIOStrategy.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/AIO/$(DEPDIR)/aio_win32.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/Blocking/$(DEPDIR)/BlockingDiskIOModule.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/Blocking/$(DEPDIR)/BlockingFile.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/Blocking/$(DEPDIR)/BlockingIOStrategy.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskDaemon/$(DEPDIR)/DiskDaemonDiskIOModule.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskDaemon/$(DEPDIR)/DiskdFile.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskDaemon/$(DEPDIR)/DiskdIOStrategy.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskDaemon/$(DEPDIR)/diskd.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskThreads/$(DEPDIR)/DiskThreadsDiskFile.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskThreads/$(DEPDIR)/DiskThreadsDiskIOModule.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskThreads/$(DEPDIR)/DiskThreadsIOStrategy.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskThreads/$(DEPDIR)/aiops.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskThreads/$(DEPDIR)/aiops_win32.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@DiskIO/DiskThreads/$(DEPDIR)/async_io.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/TestSwapDir.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_CommIO.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_DelayId.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_HttpReply.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_HttpRequest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_MemObject.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_StatHist.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_access_log.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_acl.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_cache_cf.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_cache_manager.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_client_side_request.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_comm.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_errorpage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_fd.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_helper.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_http.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_internal.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_mime.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_store.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_store_client.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_store_rebuild.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_store_swapout.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/stub_tools.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testACLMaxUserIP.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testAuth.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testBoilerplate.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testCacheManager.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testCoss.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testDiskIO.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testEvent.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testEventLoop.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testHttpReply.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testHttpRequest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testHttpRequestMethod.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testMain.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testNull.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testStore.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testStoreController.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testStoreEntryStream.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testStoreHashIndex.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testStoreSupport.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testString.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testURL.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testURLScheme.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/testUfs.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@tests/$(DEPDIR)/test_http_range.Po@am__quote@ + +.c.o: +@am__fastdepCC_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCC_TRUE@ mv -f $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c -o $@ $< + +.c.obj: +@am__fastdepCC_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCC_TRUE@ mv -f $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.c.lo: +@am__fastdepCC_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCC_TRUE@ mv -f $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $< + +.cc.o: +@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ mv -f $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ mv -f $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ mv -f $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + -rm -rf DiskIO/DiskDaemon/.libs DiskIO/DiskDaemon/_libs + -rm -rf tests/.libs tests/_libs +install-dataDATA: $(data_DATA) + @$(NORMAL_INSTALL) + test -z "$(datadir)" || $(MKDIR_P) "$(DESTDIR)$(datadir)" + @list='$(data_DATA)'; for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + f=$(am__strip_dir) \ + echo " $(dataDATA_INSTALL) '$$d$$p' '$(DESTDIR)$(datadir)/$$f'"; \ + $(dataDATA_INSTALL) "$$d$$p" "$(DESTDIR)$(datadir)/$$f"; \ + done + +uninstall-dataDATA: + @$(NORMAL_UNINSTALL) + @list='$(data_DATA)'; for p in $$list; do \ + f=$(am__strip_dir) \ + echo " rm -f '$(DESTDIR)$(datadir)/$$f'"; \ + rm -f "$(DESTDIR)$(datadir)/$$f"; \ + done +install-sysconfDATA: $(sysconf_DATA) + @$(NORMAL_INSTALL) + test -z "$(sysconfdir)" || $(MKDIR_P) "$(DESTDIR)$(sysconfdir)" + @list='$(sysconf_DATA)'; for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + f=$(am__strip_dir) \ + echo " $(sysconfDATA_INSTALL) '$$d$$p' '$(DESTDIR)$(sysconfdir)/$$f'"; \ + $(sysconfDATA_INSTALL) "$$d$$p" "$(DESTDIR)$(sysconfdir)/$$f"; \ + done + +uninstall-sysconfDATA: + @$(NORMAL_UNINSTALL) + @list='$(sysconf_DATA)'; for p in $$list; do \ + f=$(am__strip_dir) \ + echo " rm -f '$(DESTDIR)$(sysconfdir)/$$f'"; \ + rm -f "$(DESTDIR)$(sysconfdir)/$$f"; \ + done + +# This directory's subdirectories are mostly independent; you can cd +# into them and run `make' without going through this Makefile. +# To change the values of `make' variables: instead of editing Makefiles, +# (1) if the variable is set in `config.status', edit `config.status' +# (which will cause the Makefiles to be regenerated when you run `make'); +# (2) otherwise, pass the desired values on the `make' command line. +$(RECURSIVE_TARGETS): + @failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +$(RECURSIVE_CLEAN_TARGETS): + @failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + rev=''; for subdir in $$list; do \ + if test "$$subdir" = "."; then :; else \ + rev="$$subdir $$rev"; \ + fi; \ + done; \ + rev="$$rev ."; \ + target=`echo $@ | sed s/-recursive//`; \ + for subdir in $$rev; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done && test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done +ctags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonemtpy = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$tags $$unique; \ + fi +ctags: CTAGS +CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$tags$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$tags $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && cd $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) $$here + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +check-TESTS: $(TESTS) + @failed=0; all=0; xfail=0; xpass=0; skip=0; ws='[ ]'; \ + srcdir=$(srcdir); export srcdir; \ + list=' $(TESTS) '; \ + if test -n "$$list"; then \ + for tst in $$list; do \ + if test -f ./$$tst; then dir=./; \ + elif test -f $$tst; then dir=; \ + else dir="$(srcdir)/"; fi; \ + if $(TESTS_ENVIRONMENT) $${dir}$$tst; then \ + all=`expr $$all + 1`; \ + case " $(XFAIL_TESTS) " in \ + *$$ws$$tst$$ws*) \ + xpass=`expr $$xpass + 1`; \ + failed=`expr $$failed + 1`; \ + echo "XPASS: $$tst"; \ + ;; \ + *) \ + echo "PASS: $$tst"; \ + ;; \ + esac; \ + elif test $$? -ne 77; then \ + all=`expr $$all + 1`; \ + case " $(XFAIL_TESTS) " in \ + *$$ws$$tst$$ws*) \ + xfail=`expr $$xfail + 1`; \ + echo "XFAIL: $$tst"; \ + ;; \ + *) \ + failed=`expr $$failed + 1`; \ + echo "FAIL: $$tst"; \ + ;; \ + esac; \ + else \ + skip=`expr $$skip + 1`; \ + echo "SKIP: $$tst"; \ + fi; \ + done; \ + if test "$$failed" -eq 0; then \ + if test "$$xfail" -eq 0; then \ + banner="All $$all tests passed"; \ + else \ + banner="All $$all tests behaved as expected ($$xfail expected failures)"; \ + fi; \ + else \ + if test "$$xpass" -eq 0; then \ + banner="$$failed of $$all tests failed"; \ + else \ + banner="$$failed of $$all tests did not behave as expected ($$xpass unexpected passes)"; \ + fi; \ + fi; \ + dashes="$$banner"; \ + skipped=""; \ + if test "$$skip" -ne 0; then \ + skipped="($$skip tests were not run)"; \ + test `echo "$$skipped" | wc -c` -le `echo "$$banner" | wc -c` || \ + dashes="$$skipped"; \ + fi; \ + report=""; \ + if test "$$failed" -ne 0 && test -n "$(PACKAGE_BUGREPORT)"; then \ + report="Please report to $(PACKAGE_BUGREPORT)"; \ + test `echo "$$report" | wc -c` -le `echo "$$banner" | wc -c` || \ + dashes="$$report"; \ + fi; \ + dashes=`echo "$$dashes" | sed s/./=/g`; \ + echo "$$dashes"; \ + echo "$$banner"; \ + test -z "$$skipped" || echo "$$skipped"; \ + test -z "$$report" || echo "$$report"; \ + echo "$$dashes"; \ + test "$$failed" -eq 0; \ + else :; fi + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \ + fi; \ + cp -pR $$d/$$file $(distdir)$$dir || exit 1; \ + else \ + test -f $(distdir)/$$file \ + || cp -p $$d/$$file $(distdir)/$$file \ + || exit 1; \ + fi; \ + done + list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + distdir=`$(am__cd) $(distdir) && pwd`; \ + top_distdir=`$(am__cd) $(top_distdir) && pwd`; \ + (cd $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$top_distdir" \ + distdir="$$distdir/$$subdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + distdir) \ + || exit 1; \ + fi; \ + done +check-am: all-am + $(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS) + $(MAKE) $(AM_MAKEFLAGS) check-TESTS +check: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) check-recursive +all-am: Makefile $(LIBRARIES) $(LTLIBRARIES) $(PROGRAMS) $(DATA) \ + $(HEADERS) +installdirs: installdirs-recursive +installdirs-am: + for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(libexecdir)" "$(DESTDIR)$(sbindir)" "$(DESTDIR)$(datadir)" "$(DESTDIR)$(sysconfdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +uninstall: uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -rm -f DiskIO/$(DEPDIR)/$(am__dirstamp) + -rm -f DiskIO/$(am__dirstamp) + -rm -f DiskIO/AIO/$(DEPDIR)/$(am__dirstamp) + -rm -f DiskIO/AIO/$(am__dirstamp) + -rm -f DiskIO/Blocking/$(DEPDIR)/$(am__dirstamp) + -rm -f DiskIO/Blocking/$(am__dirstamp) + -rm -f DiskIO/DiskDaemon/$(DEPDIR)/$(am__dirstamp) + -rm -f DiskIO/DiskDaemon/$(am__dirstamp) + -rm -f DiskIO/DiskThreads/$(DEPDIR)/$(am__dirstamp) + -rm -f DiskIO/DiskThreads/$(am__dirstamp) + -rm -f tests/$(DEPDIR)/$(am__dirstamp) + -rm -f tests/$(am__dirstamp) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." + -test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES) +clean: clean-recursive + +clean-am: clean-binPROGRAMS clean-checkPROGRAMS clean-generic \ + clean-libexecPROGRAMS clean-libtool clean-noinstLIBRARIES \ + clean-noinstLTLIBRARIES clean-noinstPROGRAMS \ + clean-sbinPROGRAMS mostlyclean-am + +distclean: distclean-recursive + -rm -rf ./$(DEPDIR) DiskIO/$(DEPDIR) DiskIO/AIO/$(DEPDIR) DiskIO/Blocking/$(DEPDIR) DiskIO/DiskDaemon/$(DEPDIR) DiskIO/DiskThreads/$(DEPDIR) tests/$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +info: info-recursive + +info-am: + +install-data-am: install-data-local install-dataDATA + +install-dvi: install-dvi-recursive + +install-exec-am: install-binPROGRAMS install-libexecPROGRAMS \ + install-sbinPROGRAMS install-sysconfDATA + +install-html: install-html-recursive + +install-info: install-info-recursive + +install-man: + +install-pdf: install-pdf-recursive + +install-ps: install-ps-recursive + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -rf ./$(DEPDIR) DiskIO/$(DEPDIR) DiskIO/AIO/$(DEPDIR) DiskIO/Blocking/$(DEPDIR) DiskIO/DiskDaemon/$(DEPDIR) DiskIO/DiskThreads/$(DEPDIR) tests/$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: uninstall-binPROGRAMS uninstall-dataDATA \ + uninstall-libexecPROGRAMS uninstall-local \ + uninstall-sbinPROGRAMS uninstall-sysconfDATA + +.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) install-am \ + install-strip + +.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ + all all-am check check-TESTS check-am clean clean-binPROGRAMS \ + clean-checkPROGRAMS clean-generic clean-libexecPROGRAMS \ + clean-libtool clean-noinstLIBRARIES clean-noinstLTLIBRARIES \ + clean-noinstPROGRAMS clean-sbinPROGRAMS ctags ctags-recursive \ + distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-binPROGRAMS \ + install-data install-data-am install-data-local \ + install-dataDATA install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libexecPROGRAMS install-man \ + install-pdf install-pdf-am install-ps install-ps-am \ + install-sbinPROGRAMS install-strip install-sysconfDATA \ + installcheck installcheck-am installdirs installdirs-am \ + maintainer-clean maintainer-clean-generic mostlyclean \ + mostlyclean-compile mostlyclean-generic mostlyclean-libtool \ + pdf pdf-am ps ps-am tags tags-recursive uninstall uninstall-am \ + uninstall-binPROGRAMS uninstall-dataDATA \ + uninstall-libexecPROGRAMS uninstall-local \ + uninstall-sbinPROGRAMS uninstall-sysconfDATA + + +$(OBJS): $(top_srcdir)/include/version.h $(top_builddir)/include/autoconf.h +cf_gen.$(OBJEXT): cf_gen_defines.cci + +DiskIO/DiskIOModules_gen.cc: Makefile + $(SHELL) $(srcdir)/DiskIO/modules.sh $(DISK_MODULES) > DiskIO/DiskIOModules_gen.cc + +snmp_core.o snmp_agent.o: ../snmplib/libsnmp.a $(top_srcdir)/include/cache_snmp.h + +globals.cc: globals.h mk-globals-c.pl + $(AWK) -f $(srcdir)/mk-globals-c.awk < $(srcdir)/globals.h > $@ || ($(RM) -f $@ && exit 1) + +string_arrays.c: enums.h mk-string-arrays.pl + $(AWK) -f $(srcdir)/mk-string-arrays.awk < $(srcdir)/enums.h > $@ || ($(RM) -f $@ && exit 1) + +cache_diff: cache_diff.o debug.o globals.o store_key_md5.o + $(CC) -o $@ $(LDFLAGS) $@.o debug.o globals.o store_key_md5.o $(STD_APP_LIBS) + +test_cache_digest: test_cache_digest.o CacheDigest.o debug.o globals.o store_key_md5.o + $(CC) -o $@ $(LDFLAGS) $@.o CacheDigest.o debug.o globals.o store_key_md5.o $(STD_APP_LIBS) + +cache_cf.o: cf_parser.cci + +# squid.conf.default is built by cf_gen when making cf_parser.cci +squid.conf.default squid.conf.documented: cf_parser.cci + true + +cf_parser.cci: cf.data cf_gen$(EXEEXT) + ./cf_gen cf.data $(srcdir)/cf.data.depend + +cf_gen_defines.cci: $(srcdir)/cf_gen_defines $(srcdir)/cf.data.pre + $(AWK) -f $(srcdir)/cf_gen_defines <$(srcdir)/cf.data.pre >$@ || ($(RM) -f $@ && exit 1) + +cf.data: cf.data.pre Makefile + sed \ + -e "s%[@]DEFAULT_HTTP_PORT[@]%$(DEFAULT_HTTP_PORT)%g" \ + -e "s%[@]DEFAULT_ICP_PORT[@]%$(DEFAULT_ICP_PORT)%g" \ + -e "s%[@]DEFAULT_CACHE_EFFECTIVE_USER[@]%${CACHE_EFFECTIVE_USER}%g" \ + -e "s%[@]DEFAULT_MIME_TABLE[@]%$(DEFAULT_MIME_TABLE)%g" \ + -e "s%[@]DEFAULT_DNSSERVER[@]%$(DEFAULT_DNSSERVER)%g" \ + -e "s%[@]DEFAULT_UNLINKD[@]%$(DEFAULT_UNLINKD)%g" \ + -e "s%[@]DEFAULT_PINGER[@]%$(DEFAULT_PINGER)%g" \ + -e "s%[@]DEFAULT_DISKD[@]%$(DEFAULT_DISKD)%g" \ + -e "s%[@]DEFAULT_CACHE_LOG[@]%$(DEFAULT_CACHE_LOG)%g" \ + -e "s%[@]DEFAULT_ACCESS_LOG[@]%$(DEFAULT_ACCESS_LOG)%g" \ + -e "s%[@]DEFAULT_STORE_LOG[@]%$(DEFAULT_STORE_LOG)%g" \ + -e "s%[@]DEFAULT_PID_FILE[@]%$(DEFAULT_PID_FILE)%g" \ + -e "s%[@]DEFAULT_NETDB_FILE[@]%$(DEFAULT_NETDB_FILE)%g" \ + -e "s%[@]DEFAULT_SWAP_DIR[@]%$(DEFAULT_SWAP_DIR)%g" \ + -e "s%[@]DEFAULT_ICON_DIR[@]%$(DEFAULT_ICON_DIR)%g" \ + -e "s%[@]DEFAULT_CONFIG_DIR[@]%$(DEFAULT_CONFIG_DIR)%g" \ + -e "s%[@]DEFAULT_PREFIX[@]%$(DEFAULT_PREFIX)%g" \ + -e "s%[@]DEFAULT_HOSTS[@]%$(DEFAULT_HOSTS)%g" \ + -e "s%[@]SQUID[@]%SQUID\ $(VERSION)%g" \ + < $(srcdir)/cf.data.pre >$@ + +repl_modules.cc: repl_modules.sh Makefile + $(SHELL) $(srcdir)/repl_modules.sh $(REPL_POLICIES) > repl_modules.cc + +install-data-local: install-sysconfDATA install-dataDATA + @if test -f $(DESTDIR)$(DEFAULT_MIME_TABLE) ; then \ + echo "$@ will not overwrite existing $(DESTDIR)$(DEFAULT_MIME_TABLE)" ; \ + else \ + echo "$(INSTALL_DATA) $(srcdir)/mime.conf.default $(DESTDIR)$(DEFAULT_MIME_TABLE)" ;\ + $(INSTALL_DATA) $(srcdir)/mime.conf.default $(DESTDIR)$(DEFAULT_MIME_TABLE); \ + fi + @if test -f $(DESTDIR)$(DEFAULT_CONFIG_FILE) ; then \ + echo "$@ will not overwrite existing $(DESTDIR)$(DEFAULT_CONFIG_FILE)" ; \ + else \ + echo "$(INSTALL_DATA) squid.conf.default $(DESTDIR)$(DEFAULT_CONFIG_FILE)"; \ + $(INSTALL_DATA) squid.conf.default $(DESTDIR)$(DEFAULT_CONFIG_FILE); \ + fi + echo "$(INSTALL_DATA) squid.conf.default $(DESTDIR)$(DEFAULT_CONFIG_FILE).default"; \ + $(INSTALL_DATA) squid.conf.default $(DESTDIR)$(DEFAULT_CONFIG_FILE).default; \ + echo "$(INSTALL_DATA) squid.conf.documented $(DESTDIR)$(DEFAULT_CONFIG_FILE).documented"; \ + $(INSTALL_DATA) squid.conf.documented $(DESTDIR)$(DEFAULT_CONFIG_FILE).documented; \ + $(mkinstalldirs) $(DESTDIR)$(DEFAULT_LOG_PREFIX); \ + $(mkinstalldirs) $(DESTDIR)$(DEFAULT_SWAP_DIR); \ + $(mkinstalldirs) $(DESTDIR)`dirname $(DEFAULT_PIDFILE)` + +uninstall-local: squid.conf.default + @$(SHELL) $(top_srcdir)/scripts/remove-cfg.sh "$(RM)" $(DESTDIR)$(DEFAULT_MIME_TABLE) $(srcdir)/mime.conf.default + @$(SHELL) $(top_srcdir)/scripts/remove-cfg.sh "$(RM)" $(DESTDIR)$(DEFAULT_CONFIG_FILE) squid.conf.default + +test_tools.cc: $(top_srcdir)/test-suite/test_tools.cc + cp $(top_srcdir)/test-suite/test_tools.cc . + +testHeaders: $(srcdir)/*.h $(srcdir)/DiskIO/*.h $(srcdir)/DiskIO/*/*.h + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO/AIO" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO/Blocking" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO/DiskDaemon" || exit 1 + $(SHELL) $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(srcdir)/DiskIO/DiskThreads" || exit 1 +.PHONY: testHeaders +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: