]>
Commit | Line | Data |
---|---|---|
1 | ||
2 | dnl | |
3 | dnl $Id$ | |
4 | dnl | |
5 | dnl | |
6 | dnl | |
7 | AC_INIT([Squid Web Proxy],[3.HEAD-BZR],[http://www.squid-cache.org/bugs/],[squid]) | |
8 | AC_PREREQ(2.61) | |
9 | AC_CONFIG_HEADERS([include/autoconf.h]) | |
10 | AC_CONFIG_AUX_DIR(cfgaux) | |
11 | AC_CONFIG_SRCDIR([src/main.cc]) | |
12 | AM_INIT_AUTOMAKE([tar-ustar nostdinc]) | |
13 | AC_REVISION($Revision$)dnl | |
14 | AC_PREFIX_DEFAULT(/usr/local/squid) | |
15 | AM_MAINTAINER_MODE | |
16 | ||
17 | m4_include([acinclude/squid-util.m4]) | |
18 | m4_include([acinclude/compiler-flags.m4]) | |
19 | m4_include([acinclude/os-deps.m4]) | |
20 | m4_include([acinclude/krb5.m4]) | |
21 | m4_include([acinclude/pam.m4]) | |
22 | ||
23 | PRESET_CFLAGS="$CFLAGS" | |
24 | PRESET_LDFLAGS="$LDFLAGS" | |
25 | ||
26 | dnl Set default LDFLAGS | |
27 | if test -z "$LDFLAGS"; then | |
28 | LDFLAGS="-g" | |
29 | fi | |
30 | ||
31 | # Check for GNU cc | |
32 | AC_PROG_CC | |
33 | AM_PROG_CC_C_O | |
34 | AC_PROG_CXX | |
35 | AC_LANG([C++]) | |
36 | AC_CANONICAL_HOST | |
37 | ||
38 | AC_MSG_CHECKING([simplified host os]) | |
39 | squid_host_os=`echo $host_os|sed 's/[0-9].*//;s/-.*//g'` | |
40 | squid_host_os_version=`echo $host_os|tr -d "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-"` | |
41 | AC_MSG_RESULT($squid_host_os (version $squid_host_os_version)) | |
42 | # on windows squid_host_os is either mingw or cygwin, version is 32 | |
43 | ||
44 | # test for programs | |
45 | AC_PROG_RANLIB | |
46 | AC_PROG_CPP | |
47 | AC_PROG_INSTALL | |
48 | AC_PROG_LN_S | |
49 | AC_PROG_EGREP | |
50 | ||
51 | AC_PATH_PROG(SH, sh, /bin/sh) | |
52 | AC_PATH_PROG(FALSE, false, /usr/bin/false) | |
53 | AC_PATH_PROG(TRUE, true, /usr/bin/true) | |
54 | AC_PATH_PROG(MV, mv, $FALSE) | |
55 | AC_PATH_PROG(MKDIR, mkdir, $FALSE) | |
56 | AC_PATH_PROG(LN, ln, cp) | |
57 | AC_PATH_PROG(CHMOD, chmod, $FALSE) | |
58 | AC_PATH_PROG(TR, tr, $FALSE) | |
59 | AC_PATH_PROG(RM, rm, $FALSE) | |
60 | AC_PATH_PROG(CPPUNITCONFIG, cppunit-config, false) | |
61 | dnl Libtool 2.2.6 requires: rm -f | |
62 | RM="$RM -f" | |
63 | ||
64 | AC_PATH_PROG(PERL, perl, none) | |
65 | if test "$ac_cv_path_PERL" = "none"; then | |
66 | AC_MSG_FAILURE([Perl is required to compile Squid. Please install Perl and then re-run configure ]) | |
67 | fi | |
68 | AC_PATH_PROG(POD2MAN, pod2man, $FALSE) | |
69 | ||
70 | dnl set $(AR) | |
71 | AC_PATH_PROG(AR, ar, $FALSE) | |
72 | AR_R="$AR r" | |
73 | AC_SUBST(AR_R) | |
74 | ||
75 | squid_opt_enable_werror="yes" # default | |
76 | AC_ARG_ENABLE(strict-error-checking, | |
77 | AS_HELP_STRING([--disable-strict-error-checking],[By default squid is compiled | |
78 | with all possible static compiler error-checks enbled. | |
79 | This flag disables the behavior]), | |
80 | [ | |
81 | if test "${enableval}" = "no" | |
82 | then | |
83 | squid_opt_enable_werror="no" | |
84 | fi | |
85 | ]) | |
86 | ||
87 | use_loadable_modules=1 | |
88 | AC_MSG_CHECKING(whether to use loadable modules) | |
89 | AC_ARG_ENABLE(loadable-modules, | |
90 | AS_HELP_STRING([--disable-loadable-modules],[do not support loadable modules]) , [ | |
91 | case "${enableval}" in | |
92 | yes) use_loadable_modules=yes ;; | |
93 | no) use_loadable_modules=no ;; | |
94 | *) AC_MSG_ERROR(bad value ${enableval} for --disable-loadable-modules) ;; | |
95 | esac | |
96 | AC_MSG_RESULT([$use_loadable_modules, explicitly]) | |
97 | ], [ | |
98 | use_loadable_modules=yes; | |
99 | AC_MSG_RESULT([$use_loadable_modules, implicitly]) | |
100 | ]) | |
101 | ||
102 | AM_CONDITIONAL(USE_LOADABLE_MODULES, test $use_loadable_modules = yes) | |
103 | ||
104 | if test $use_loadable_modules = yes; | |
105 | then | |
106 | AC_DEFINE(USE_LOADABLE_MODULES, 1, [Support Loadable Modules]) | |
107 | AC_ENABLE_SHARED | |
108 | else | |
109 | AC_DISABLE_SHARED | |
110 | fi | |
111 | ||
112 | AC_LIBTOOL_DLOPEN | |
113 | if test $use_loadable_modules = yes; | |
114 | then | |
115 | dnl Linux LTDL v3-v7 macros assume the autoconf 2.62 variable top_build_prefix is defined | |
116 | dnl But from autoconf 2.64 its called ac_top_build_prefix and not automatically added to the Makefile | |
117 | top_build_prefix=${ac_top_build_prefix} | |
118 | AC_SUBST(top_build_prefix) | |
119 | ||
120 | AC_LIBLTDL_CONVENIENCE | |
121 | fi | |
122 | dnl LibTool environment is now prepared for setup. Check that it is usable and initialize. | |
123 | AC_PROG_LIBTOOL | |
124 | AC_LTDL_DLLIB | |
125 | ||
126 | # Do we need these unconditionally for "make distcheck" to work? | |
127 | AC_SUBST(INCLTDL) | |
128 | AC_SUBST(LIBLTDL) | |
129 | ||
130 | if test $use_loadable_modules = yes; | |
131 | then | |
132 | # Why is this needed? Should not AC_LIBTOOL_DLOPEN from libtool do that? | |
133 | LIBADD_DL=${lt_cv_dlopen_libs} | |
134 | AC_SUBST([LIBADD_DL]) | |
135 | fi | |
136 | ||
137 | ||
138 | SQUID_CC_GUESS_VARIANT | |
139 | SQUID_CC_GUESS_OPTIONS | |
140 | ||
141 | ||
142 | REGEXLIB='' # -lregex | |
143 | # LIBREGEX='' # libregex.a | |
144 | ||
145 | dnl find out the exe extension for this platform. | |
146 | dnl If it is not empty, use it for CGI as well. | |
147 | AC_EXEEXT | |
148 | AC_OBJEXT | |
149 | ||
150 | if test -z "$EXEEXT"; then | |
151 | CGIEXT=".cgi" | |
152 | else | |
153 | # automake automatically adds .exe when installing binaries | |
154 | CGIEXT="" | |
155 | fi | |
156 | AC_SUBST(CGIEXT) | |
157 | ||
158 | AM_CONDITIONAL(ENABLE_WIN32SPECIFIC, | |
159 | [test "$squid_host_os" = "mingw" -o "$squid_host_os" = "cygwin"]) | |
160 | AM_CONDITIONAL(USE_IPC_WIN32,[test "$squid_host_os" = "mingw"]) | |
161 | ||
162 | if test $squid_host_os = "mingw"; then | |
163 | AC_PATH_PROG(WIN32_PSAPI, psapi.dll, none) | |
164 | CFLAGS="$CFLAGS -mthreads" | |
165 | CXXFLAGS="$CXXFLAGS -mthreads" | |
166 | if test "$ac_cv_path_WIN32_PSAPI" = "none"; then | |
167 | AC_MSG_NOTICE([PSAPI.DLL is recommended to run Squid on Windows NT Platform]) | |
168 | AC_MSG_NOTICE([Please see PSAPI.DLL section on doc/win32-relnotes.html.]) | |
169 | else | |
170 | AC_DEFINE(HAVE_WIN32_PSAPI,1,[Define if you have PSAPI.DLL on Windows systems]) | |
171 | LIBS="$LIBS -lpsapi" | |
172 | fi | |
173 | MINGW_LIBS="-lmingwex" | |
174 | AC_SUBST(MINGW_LIBS) | |
175 | fi | |
176 | ||
177 | if test -z "$CACHE_HTTP_PORT"; then | |
178 | CACHE_HTTP_PORT="3128" | |
179 | fi | |
180 | if test -z "$CACHE_ICP_PORT"; then | |
181 | CACHE_ICP_PORT="3130" | |
182 | fi | |
183 | ||
184 | dnl Substitutions | |
185 | AC_DEFINE_UNQUOTED(CACHE_HTTP_PORT, $CACHE_HTTP_PORT, | |
186 | [What default TCP port to use for HTTP listening?]) | |
187 | AC_SUBST(CACHE_HTTP_PORT) | |
188 | AC_DEFINE_UNQUOTED(CACHE_ICP_PORT, $CACHE_ICP_PORT, | |
189 | [What default UDP port to use for ICP listening?]) | |
190 | AC_SUBST(CACHE_ICP_PORT) | |
191 | ||
192 | AC_DEFINE_UNQUOTED(CONFIG_HOST_TYPE, "$host",[Host type from configure]) | |
193 | ||
194 | AC_DEFINE_UNQUOTED(SQUID_CONFIGURE_OPTIONS, "$ac_configure_args", | |
195 | [configure command line used to configure Squid]) | |
196 | ||
197 | CACHE_EFFECTIVE_USER="nobody" | |
198 | AC_ARG_WITH(default-user, | |
199 | AS_HELP_STRING([--with-default-user=USER],[System user account for squid permissions. Default: nobody]), | |
200 | [ CACHE_EFFECTIVE_USER="$withval" ] | |
201 | ) | |
202 | AC_SUBST(CACHE_EFFECTIVE_USER) | |
203 | ||
204 | DEFAULT_LOG_DIR="$localstatedir/logs" | |
205 | AC_ARG_WITH(logdir, | |
206 | AS_HELP_STRING([--with-logdir=PATH],[Default location for squid logs. default: $DEFAULT_LOG_DIR]), | |
207 | [ case $withval in | |
208 | yes|no) | |
209 | AC_MSG_ERROR( --with-logdir requires a directory PATH. --with-logdir=PATH ) | |
210 | ;; | |
211 | *) | |
212 | DEFAULT_LOG_DIR="$withval" | |
213 | ;; | |
214 | esac | |
215 | ] | |
216 | ) | |
217 | AC_SUBST(DEFAULT_LOG_DIR) | |
218 | ||
219 | DEFAULT_PIDFILE="$localstatedir/run/squid.pid" | |
220 | AC_ARG_WITH(pidfile, | |
221 | AS_HELP_STRING([--with-pidfile=PATH], | |
222 | [Default location for squid PID file. default: PREFIX/var/run/squid.pid]), | |
223 | [case $withval in | |
224 | yes|no) | |
225 | AC_MSG_ERROR( --with-pidfile requires a file PATH. --with-pidfile=PATH ) | |
226 | ;; | |
227 | *) | |
228 | DEFAULT_PIDFILE="$withval" | |
229 | ;; | |
230 | esac | |
231 | ]) | |
232 | AC_SUBST(DEFAULT_PIDFILE) | |
233 | ||
234 | if test "$GCC" = "yes"; then | |
235 | GCCVER=`$CC -v 2>&1 | awk '$2 == "version" {print $3}'` | |
236 | GCCVER2=`echo $GCCVER | awk '{print $1 * 100}'` | |
237 | case "$host" in | |
238 | i386-*-freebsd*) | |
239 | if test $GCCVER2 -lt 300 ; then | |
240 | AC_MSG_FAILURE([GCC $GCCVER causes a coredump on $host. Try a more recent GCC version]) | |
241 | fi | |
242 | ;; | |
243 | esac | |
244 | unset GCCVER | |
245 | unset GCCVER2 | |
246 | ||
247 | fi | |
248 | ||
249 | dnl Set Default CFLAGS | |
250 | if test -z "$PRESET_CFLAGS"; then | |
251 | if test "$GCC" = "yes"; then | |
252 | case "$host" in | |
253 | *-sun-sunos*) | |
254 | # sunos has too many warnings for this to be useful | |
255 | # motorola too | |
256 | ;; | |
257 | *m88k*) | |
258 | # Motorola cc/ld does not like -02 but is ok on -O | |
259 | CFLAGS=`echo $CFLAGS | sed -e 's/-O[0-9]/-O/'` | |
260 | ;; | |
261 | *) | |
262 | CFLAGS="$squid_cv_cc_option_wall $CFLAGS" | |
263 | ;; | |
264 | esac | |
265 | else | |
266 | case "$host" in | |
267 | *mips-sgi-irix6.*) | |
268 | # suggested by Rafael Seidl <rafaels@cthulhu.engr.sgi.com> | |
269 | CFLAGS="$squid_cv_cc_option_optimize -OPT:Olimit=0:space=OFF \ | |
270 | -woff 1009,1014,1110,1116,1183,1185,1188,1204,1230,1233,1355 \ | |
271 | -Wl,-woff,85,-woff,84,-woff,134 \ | |
272 | -nostdinc -I/usr/include -D_BSD_SIGNALS $CFLAGS" | |
273 | CXXFLAGS="$squid_cv_cc_option_optimize -OPT:Olimit=0:space=OFF \ | |
274 | -woff 1009,1014,1110,1116,1183,1185,1188,1204,1230,1233,1355 \ | |
275 | -Wl,-woff,85,-woff,84,-woff,134 \ | |
276 | -nostdinc -I/usr/include -D_BSD_SIGNALS $CXXFLAGS" | |
277 | ;; | |
278 | alpha-dec-osf4.*) | |
279 | # Mogul says DEC compilers take both -g and -O2 | |
280 | CFLAGS=`echo $CFLAGS | sed -e 's/-g/-g3/'` | |
281 | CFLAGS="$squid_cv_cc_option_optimize $CFLAGS" | |
282 | ;; | |
283 | *) | |
284 | ;; | |
285 | esac | |
286 | fi | |
287 | fi | |
288 | ||
289 | dnl set squid required flags | |
290 | if test "$GCC" = "yes"; then | |
291 | dnl Guido Serassio (serassio@squid-cache.org) 20070811 | |
292 | dnl Using the latest MinGW (gcc 3.4.5 + mingw-runtime 3.13) cannot build with | |
293 | dnl -Werror -Wmissing-prototypes -Wmissing-declarations | |
294 | dnl TODO: check if the problem will be present in any other newer MinGW release. | |
295 | case "$host_os" in | |
296 | mingw|mingw32) | |
297 | SQUID_CFLAGS="$squid_cv_cc_option_wall -Wpointer-arith -Wwrite-strings -Wcomments" | |
298 | ;; | |
299 | *) | |
300 | SQUID_CFLAGS="$squid_cv_cc_option_wall -Wpointer-arith -Wwrite-strings -Wmissing-prototypes -Wmissing-declarations -Wcomments" | |
301 | ;; | |
302 | esac | |
303 | SQUID_CXXFLAGS="$squid_cv_cc_option_wall -Wpointer-arith -Wwrite-strings -Wcomments" | |
304 | else | |
305 | SQUID_CFLAGS= | |
306 | SQUID_CXXFLAGS= | |
307 | fi | |
308 | ||
309 | if test "$squid_opt_enable_werror" = "no" | |
310 | then | |
311 | SQUID_CFLAGS="$SQUID_CFLAGS $squid_cv_cc_option_werror" | |
312 | SQUID_CXXFLAGS="$SQUID_CXXFLAGS $squid_cv_cc_option_werror" | |
313 | fi | |
314 | ||
315 | AC_SUBST(SQUID_CFLAGS) | |
316 | AC_SUBST(SQUID_CXXFLAGS) | |
317 | ||
318 | SQUID_CXX_CHECK_ARG_FHUGEOBJECTS | |
319 | if test "$squid_cv_cxx_arg_fhugeobjects" = "yes"; then | |
320 | SQUID_CXXFLAGS="$SQUID_CXXFLAGS -fhuge-objects" | |
321 | fi | |
322 | # squid_cv_cc_arg_pipe is set by SQUID_CC_GUESS_OPTIONS | |
323 | SQUID_CXXFLAGS="$SQUID_CXXFLAGS $squid_cv_cc_arg_pipe" | |
324 | SQUID_CFLAGS="$SQUID_CFLAGS $squid_cv_cc_arg_pipe" | |
325 | ||
326 | SquidInline="yes" | |
327 | ||
328 | AC_ARG_ENABLE(optimizations, | |
329 | AS_HELP_STRING([--disable-optimizations], | |
330 | [Do not compile Squid with compiler optimizations enabled. | |
331 | Optimization is good for production builds, but not | |
332 | good for debugging. During development, use | |
333 | --disable-optimizations to reduce compilation times | |
334 | and allow easier debugging. This option implicitly | |
335 | also enabled --disable-inline]), | |
336 | [ if test "$enableval" = "no" ; then | |
337 | AC_MSG_NOTICE([Disabling compiler optimizations (-O flag)]) | |
338 | CFLAGS="`echo $CFLAGS | sed -e 's/-O[[0-9]]*//'`" | |
339 | CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-O[[0-9]]*//'`" | |
340 | SquidInline="no" | |
341 | fi | |
342 | ]) | |
343 | ||
344 | AH_TEMPLATE(_USE_INLINE_,[Include inline methods into header file]) | |
345 | AC_ARG_ENABLE(inline, | |
346 | AS_HELP_STRING([--disable-inline], | |
347 | [Do not compile trivial methods as inline. Squid | |
348 | is coded with much of the code able to be inlined. | |
349 | Inlining is good for production builds, but not | |
350 | good for development. During development, use | |
351 | --disable-inline to reduce compilation times and | |
352 | allow incremental builds to be quick. For | |
353 | production builds, or load tests, use | |
354 | --enable-inline to have squid make all trivial | |
355 | methods inlinable by the compiler.]), | |
356 | [ if test "$enableval" = "no" ; then | |
357 | SquidInline="no" | |
358 | fi | |
359 | ]) | |
360 | ||
361 | if test "$SquidInline" = "yes" ; then | |
362 | AC_DEFINE(_SQUID_INLINE_, inline, [Keyword used by squid for inlining methods]) | |
363 | AC_DEFINE(_USE_INLINE_, 1 , [Include inline methods into header file]) | |
364 | else | |
365 | AC_MSG_NOTICE([Inlining optimization disabled]) | |
366 | AC_DEFINE(_SQUID_INLINE_,[], [Keyword used by squid for inlining methods]) | |
367 | fi | |
368 | ||
369 | AC_ARG_ENABLE(debug-cbdata, | |
370 | AS_HELP_STRING([--enable-debug-cbdata], | |
371 | [Provide some debug information in cbdata]), [ | |
372 | if test "$enableval" = "yes" ; then | |
373 | AC_MSG_NOTICE([cbdata debugging enabled]) | |
374 | AC_DEFINE(CBDATA_DEBUG,1, [Enable support for cbdata debug information]) | |
375 | fi | |
376 | ]) | |
377 | ||
378 | dnl Nasty hack to get autoconf 2.64 on Linux to run. | |
379 | dnl all other uses of RUN_IFELSE are wrapped inside CACHE_CHECK which breaks on 2.64 | |
380 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ int main(int argc, char **argv) { return 0; } ]])],[],[],[]) | |
381 | ||
382 | dnl This is a developer only option.. developers know how to set defines | |
383 | dnl | |
384 | dnl AC_ARG_ENABLE(xmalloc-debug, | |
385 | dnl [ --enable-xmalloc-debug Do some simple malloc debugging], | |
386 | dnl [ if test "$enableval" = "yes" ; then | |
387 | dnl AC_MSG_NOTICE([malloc debugging enabled]) | |
388 | dnl AC_DEFINE(XMALLOC_DEBUG,1,[Define to do simple malloc debugging]) | |
389 | dnl fi | |
390 | dnl ]) | |
391 | ||
392 | dnl This is a developer only option.. developers know how to set defines | |
393 | dnl | |
394 | dnl AC_ARG_ENABLE(xmalloc-debug-trace, | |
395 | dnl [ --enable-xmalloc-debug-trace | |
396 | dnl Detailed trace of memory allocations], | |
397 | dnl [ if test "$enableval" = "yes" ; then | |
398 | dnl AC_MSG_NOTICE([malloc debug trace enabled]) | |
399 | dnl AC_DEFINE(XMALLOC_TRACE,1,[Define to have a detailed trace of memory allocations]) | |
400 | dnl AC_DEFINE(XMALLOC_DEBUG,1) | |
401 | dnl fi | |
402 | dnl ]) | |
403 | ||
404 | AH_TEMPLATE(XMALLOC_STATISTICS,[Define to have malloc statistics]) | |
405 | AC_ARG_ENABLE(xmalloc-statistics, | |
406 | AS_HELP_STRING([--enable-xmalloc-statistics], | |
407 | [Show malloc statistics in status page]), [ | |
408 | if test "$enableval" = "yes" ; then | |
409 | AC_MSG_NOTICE([malloc statistics enabled]) | |
410 | AC_DEFINE(XMALLOC_STATISTICS,1) | |
411 | fi | |
412 | ]) | |
413 | ||
414 | squid_opt_aufs_threads="" | |
415 | AC_ARG_WITH(aufs-threads, | |
416 | AS_HELP_STRING([--with-aufs-threads=N_THREADS], | |
417 | [Tune the number of worker threads for the aufs object store.]), [ | |
418 | case $withval in | |
419 | [[0-9]]*) | |
420 | squid_opt_aufs_threads=$withval | |
421 | ;; | |
422 | *) | |
423 | AC_MSG_ERROR(--with-aufs-threads expects a numeric argument) | |
424 | ;; | |
425 | esac | |
426 | ]) | |
427 | if test -n "$squid_opt_aufs_threads"; then | |
428 | AC_MSG_NOTICE([With $squid_opt_aufs_threads aufs threads]) | |
429 | AC_DEFINE_UNQUOTED(AUFS_IO_THREADS,$squid_opt_aufs_threads, | |
430 | [Defines how many threads aufs uses for I/O]) | |
431 | fi | |
432 | ||
433 | AC_ARG_WITH(dl, AS_HELP_STRING([--with-dl],[Use dynamic linking])) | |
434 | if test "$with_dl" = "yes"; then | |
435 | AC_MSG_NOTICE([With dl]) | |
436 | fi | |
437 | ||
438 | AC_MSG_CHECKING([for DiskIO modules to be enabled]) | |
439 | squid_disk_module_candidates="" | |
440 | squid_opt_enable_diskio="auto" #values: no, yes, "auto"(=yes+detect modules) | |
441 | AC_ARG_ENABLE(disk-io, | |
442 | AS_HELP_STRING([--enable-disk-io="list of modules"], | |
443 | [Build support for the list of disk I/O modules. | |
444 | Set without a value or omitted, all available modules will be built. | |
445 | See src/DiskIO for a list of available modules, or | |
446 | Programmers Guide section on DiskIO | |
447 | for details on how to build your custom disk module]), [ | |
448 | case $enableval in | |
449 | yes) | |
450 | ${TRUE} | |
451 | #do nothing, "auto" is ok | |
452 | ;; | |
453 | no) | |
454 | squid_opt_enable_diskio="no" | |
455 | ;; | |
456 | *) | |
457 | squid_opt_enable_diskio="yes" | |
458 | squid_disk_module_candidates=" `echo $enableval| sed -e 's/,/ /g;s/ */ /g'` " | |
459 | SQUID_CLEANUP_MODULES_LIST([squid_disk_module_candidates]) | |
460 | ;; | |
461 | esac | |
462 | ]) | |
463 | ||
464 | # if requested to autodetect, find out what we have | |
465 | if test $squid_opt_enable_diskio = "auto"; then | |
466 | squid_opt_enable_diskio="yes" | |
467 | SQUID_LOOK_FOR_MODULES([$srcdir/src/DiskIO],[squid_disk_module_candidates]) | |
468 | fi | |
469 | ||
470 | AC_MSG_RESULT([${squid_disk_module_candidates:-none}]) | |
471 | SQUID_CHECK_EXISTING_MODULES([$srcdir/src/DiskIO],[squid_disk_module_candidates]) | |
472 | SQUID_DEFINE_BOOL([USE_DISKIO],$squid_opt_enable_diskio, | |
473 | [DiskIO modules are expected to be available.]) | |
474 | ||
475 | ||
476 | ||
477 | dnl Some autoconf.h defines we might enable later... | |
478 | AC_ARG_WITH(pthreads,AS_HELP_STRING([--without-pthreads],[Disable POSIX Threads])) | |
479 | AC_ARG_WITH(aio, AS_HELP_STRING([--without-aio],[Do not use POSIX AIO. Default: auto-detect])) | |
480 | AH_TEMPLATE(USE_DISKIO_AIO, [Whether POSIX AIO support is needed. Automatic]) | |
481 | AH_TEMPLATE(USE_DISKIO_DISKTHREADS, [Whether pthreads support is needed. Automatic]) | |
482 | USE_AIOPS_WIN32=0 | |
483 | squid_opt_use_aio= | |
484 | squid_opt_use_diskthreads= | |
485 | AIOLIB= | |
486 | ||
487 | dnl Setup the module paths etc. | |
488 | DISK_LIBS= | |
489 | DISK_OS_LIBS= | |
490 | DISK_MODULES= | |
491 | DISK_LINKOBJS= | |
492 | for module in $squid_disk_module_candidates none; do | |
493 | # maybe not needed | |
494 | if test "$module" = "none"; then | |
495 | continue | |
496 | fi | |
497 | if ! test -d $srcdir/src/DiskIO/$module; then | |
498 | AC_MSG_ERROR(disk-io $module does not exist) | |
499 | fi | |
500 | case "$module" in | |
501 | DiskDaemon) | |
502 | AC_MSG_NOTICE([Enabling DiskDaemon DiskIO module]) | |
503 | DISK_LIBS="$DISK_LIBS libDiskDaemon.a" | |
504 | DISK_MODULES="$DISK_MODULES DiskDaemon" | |
505 | DISK_PROGRAMS="$DISK_PROGRAMS DiskIO/DiskDaemon/diskd" | |
506 | DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/DiskDaemon/DiskDaemonDiskIOModule.o" | |
507 | ;; | |
508 | DiskThreads) | |
509 | squid_opt_use_diskthreads="yes" | |
510 | LIBPTHREADS= | |
511 | SQUID_STATE_SAVE([diskthreads_state],[SQUID_CFLAGS SQUID_CXXFLAGS]) | |
512 | if test "$with_pthreads" != "no"; then | |
513 | dnl TODO: this needs to be extended to handle more systems and better | |
514 | dnl REF: http://www.openldap.org/lists/openldap-bugs/200006/msg00070.html | |
515 | dnl REF: http://autoconf-archive.cryp.to/acx_pthread.html | |
516 | case "$squid_host_os" in | |
517 | mingw) | |
518 | USE_AIOPS_WIN32=1 | |
519 | AC_MSG_NOTICE([Windows threads support automatically enabled]) | |
520 | ;; | |
521 | freebsd) | |
522 | SQUID_CFLAGS="$SQUID_CFLAGS -D_REENTRANT" | |
523 | SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_REENTRANT" | |
524 | if test "$GCC" = "yes" -a -z "$PRESET_LDFLAGS" ; then | |
525 | LDFLAGS="$LDFLAGS -pthread" | |
526 | fi | |
527 | ;; | |
528 | solaris) | |
529 | if test "$GCC" = "yes" ; then | |
530 | SQUID_CFLAGS="$SQUID_CFLAGS -D_REENTRANT -pthreads" | |
531 | SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_REENTRANT -pthreads" | |
532 | AC_CHECK_LIB(pthread, pthread_create ,[LIBPTHREADS="-lpthread"], | |
533 | [ AC_MSG_NOTICE(pthread library required but cannot be found.) | |
534 | squid_opt_use_diskthreads="no" | |
535 | ]) | |
536 | else | |
537 | dnl test for -lpthread first. libc version is a stub apparently on Solaris. | |
538 | SQUID_CFLAGS="$SQUID_CFLAGS -D_REENTRANT -lpthread" | |
539 | SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_REENTRANT -lpthread" | |
540 | AC_SEARCH_LIBS([pthread_create],[pthread thread],[ | |
541 | LIBPTHREADS="" #in LIBS | |
542 | ],[ | |
543 | AC_MSG_NOTICE(pthread library required but cannot be found.) | |
544 | squid_opt_use_diskthreads="no" | |
545 | ]) | |
546 | fi | |
547 | ;; | |
548 | *) | |
549 | SQUID_CFLAGS="$SQUID_CFLAGS -D_REENTRANT" | |
550 | SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_REENTRANT" | |
551 | AC_CHECK_LIB(pthread, pthread_create ,[LIBPTHREADS="-lpthread"], | |
552 | [ AC_MSG_NOTICE(pthread library required but cannot be found.) | |
553 | squid_opt_use_diskthreads="no" | |
554 | ]) | |
555 | ;; | |
556 | esac | |
557 | else | |
558 | AC_MSG_NOTICE([Native pthreads support manually disabled.]) | |
559 | squid_opt_use_diskthreads="no" | |
560 | fi | |
561 | if test "$squid_opt_use_diskthreads" = "yes" ; then | |
562 | AC_DEFINE(USE_DISKIO_DISKTHREADS, 1, [Whether pthreads support is needed. Automatic]) | |
563 | AC_MSG_NOTICE([Enabling DiskThreads DiskIO module]) | |
564 | DISK_LIBS="$DISK_LIBS libDiskThreads.a" | |
565 | DISK_OS_LIBS="$DISK_OS_LIBS $LIBPTHREADS" | |
566 | DISK_MODULES="$DISK_MODULES DiskThreads" | |
567 | DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/DiskThreads/DiskThreadsDiskIOModule.o" | |
568 | else | |
569 | AC_DEFINE(USE_DISKIO_DISKTHREADS, 0, [Whether pthreads support is needed. Automatic]) | |
570 | AC_MSG_NOTICE([Native pthreads support disabled. DiskThreads module automaticaly disabled.]) | |
571 | SQUID_STATE_ROLLBACK([diskthreads_state]) | |
572 | fi | |
573 | ;; | |
574 | ||
575 | AIO) | |
576 | dnl Check for POSIX AIO availability | |
577 | squid_opt_use_aio="yes" | |
578 | AIOLIB= | |
579 | if test "$with_aio" != "no"; then | |
580 | have_aio_header=no | |
581 | AC_CHECK_HEADERS(aio.h,[have_aio_header=yes]) | |
582 | dnl On some systems POSIX AIO functions are in librt | |
583 | dnl On some systems POSIX AIO functions are in libaio | |
584 | AC_CHECK_LIB(rt,aio_read,[AIOLIB="-lrt"],AC_CHECK_LIB(aio,aio_read,[AIOLIB="-laio"],[])) | |
585 | dnl Enable AIO if the library and headers are found | |
586 | if test "$AIOLIB" != "" && test "$have_aio_header" = "yes"; then | |
587 | AC_MSG_NOTICE([Native POSIX AIO support detected.]) | |
588 | squid_opt_use_aio="yes" | |
589 | else | |
590 | dnl Windows does things differently. We provide wrappers. | |
591 | dnl TODO: Windows really needs its own DiskIO module or its Overlaped IO | |
592 | case "$host_os" in | |
593 | mingw|mingw32) | |
594 | squid_opt_use_aio="yes" | |
595 | AC_MSG_NOTICE([Windows being built. Maybe-enable POSIX AIO.]) | |
596 | ;; | |
597 | *) | |
598 | AC_MSG_NOTICE([Native POSIX AIO support not detected. AIO automatically disabled.]) | |
599 | squid_opt_use_aio="no" | |
600 | ;; | |
601 | esac | |
602 | fi | |
603 | else | |
604 | AC_MSG_NOTICE([POSIX AIO support manually disabled.]) | |
605 | squid_opt_use_aio="no" | |
606 | fi | |
607 | dnl Use the POSIX AIO pieces if we actually need them. | |
608 | if test "$squid_opt_use_aio" = "yes" ; then | |
609 | AC_DEFINE(USE_DISKIO_AIO, 1, [Whether POSIX AIO support is needed. Automatic]) | |
610 | DISK_MODULES="$DISK_MODULES AIO" | |
611 | DISK_LIBS="$DISK_LIBS libAIO.a" | |
612 | DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/AIO/AIODiskIOModule.o" | |
613 | case "$host_os" in | |
614 | mingw|mingw32) | |
615 | USE_AIO_WIN32=1 | |
616 | AC_MSG_NOTICE([Replacing AIO DiskIO module with: Windows overlapped I/O support]) | |
617 | ;; | |
618 | *) | |
619 | AC_MSG_NOTICE([Enabling AIO DiskIO module]) | |
620 | DISK_OS_LIBS="$DISK_OS_LIBS $AIOLIB" | |
621 | ;; | |
622 | esac | |
623 | else | |
624 | AC_DEFINE(USE_DISKIO_AIO, 0, [Whether POSIX AIO support is needed. Automatic]) | |
625 | AC_MSG_NOTICE([AIO DiskIO Module disabled. Missing POSIX AIO support.]) | |
626 | fi | |
627 | ;; | |
628 | ||
629 | Blocking) | |
630 | AC_MSG_NOTICE([Enabling Blocking DiskIO module]) | |
631 | DISK_LIBS="$DISK_LIBS libBlocking.a" | |
632 | DISK_MODULES="$DISK_MODULES Blocking" | |
633 | DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/Blocking/BlockingDiskIOModule.o" | |
634 | ;; | |
635 | ||
636 | *) | |
637 | AC_MSG_NOTICE([Enabling $module DiskIO module]) | |
638 | DISK_LIBS="$DISK_LIBS lib${module}.a" | |
639 | DISK_MODULES="$DISK_MODULES ${module}" | |
640 | DISK_LINKOBJS="$DISK_LINKOBJS DiskIO/${module}/${module}DiskIOModule.o" | |
641 | ;; | |
642 | esac | |
643 | done | |
644 | AC_MSG_NOTICE([IO Modules built: $DISK_MODULES]) | |
645 | AC_SUBST(DISK_MODULES) | |
646 | AC_SUBST(DISK_LIBS) | |
647 | AC_SUBST(DISK_PROGRAMS) | |
648 | AC_SUBST(DISK_LINKOBJS) | |
649 | AC_SUBST(DISK_OS_LIBS) | |
650 | AM_CONDITIONAL([USE_AIOPS_WIN32], [test "$USE_AIOPS_WIN32" = 1]) | |
651 | AM_CONDITIONAL([USE_AIO_WIN32], [test "$USE_AIO_WIN32" = 1]) | |
652 | ||
653 | ||
654 | dnl Check what Storage formats are wanted. | |
655 | dnl This version will error out with a message saying why if a required DiskIO is missing. | |
656 | squid_opt_enable_storeio=auto | |
657 | AC_ARG_ENABLE([storeio], | |
658 | AS_HELP_STRING([--enable-storeio="list of modules"], | |
659 | [Build support for the list of store I/O modules. | |
660 | The default is only to build the "ufs" module. | |
661 | See src/fs for a list of available modules, or | |
662 | Programmers Guide section <not yet written> | |
663 | for details on how to build your custom store module]), | |
664 | [ case $enableval in | |
665 | yes) | |
666 | squid_opt_enable_storeio=auto | |
667 | ;; | |
668 | no) | |
669 | squid_opt_enable_storeio=no | |
670 | ;; | |
671 | *) | |
672 | squid_opt_enable_storeio=yes | |
673 | squid_storeio_module_candidates="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" | |
674 | # ufs is really always needed as it has low-level routines | |
675 | # if it is a dupe it will be cleaned-up later | |
676 | squid_storeio_module_candidates="$squid_storeio_module_candidates ufs" | |
677 | ;; | |
678 | esac | |
679 | ]) | |
680 | if test "$squid_opt_enable_storeio" = "auto"; then | |
681 | squid_opt_enable_storeio=yes | |
682 | AC_MSG_CHECKING([for available StoreIO modules]) | |
683 | SQUID_LOOK_FOR_MODULES([$srcdir/src/fs],[squid_storeio_module_candidates]) | |
684 | # disable coss | |
685 | squid_storeio_module_candidates=`echo $squid_storeio_module_candidates|sed 's/coss//'` | |
686 | AC_MSG_RESULT([$squid_storeio_module_candidates]) | |
687 | fi | |
688 | ||
689 | SQUID_CLEANUP_MODULES_LIST([squid_storeio_module_candidates]) | |
690 | SQUID_CHECK_EXISTING_MODULES([$srcdir/src/fs],[squid_storeio_module_candidates]) | |
691 | AC_MSG_NOTICE([Store modules built: $squid_storeio_module_candidates]) | |
692 | ||
693 | for fs in $squid_storeio_module_candidates none; do | |
694 | case "$fs" in | |
695 | diskd) | |
696 | if test "$squid_disk_module_candidates_Blocking" != "yes" -a \ | |
697 | "$squid_disk_module_candidates_DiskDaemon" != "yes" ; then | |
698 | AC_MSG_ERROR([Storage diskd module requires DiskIO module: Blocking or DiskDaemon]) | |
699 | fi | |
700 | ;; | |
701 | aufs) | |
702 | if test "$squid_disk_module_candidates_Blocking" != "yes" -a \ | |
703 | "$squid_disk_module_candidates_DiskThreads" != "yes" ; then | |
704 | AC_MSG_ERROR([Storage module aufs requires DiskIO module: Blocking or DiskThreads]) | |
705 | fi | |
706 | ;; | |
707 | coss) | |
708 | AC_MSG_WARN([COSS Support is not stable yet in Squid-3. Please do not use.\a]) | |
709 | if ! test "$squid_disk_module_candidates_AIO" = "yes"; then | |
710 | AC_MSG_ERROR([COSS requires POSIX AIO which is not available.]) | |
711 | fi | |
712 | dnl | |
713 | dnl Automake om MinGW needs explicit exe extension | |
714 | dnl for STORE_TESTS substition | |
715 | dnl | |
716 | STORE_TESTS="$STORE_TESTS tests/testCoss$EXEEXT" | |
717 | ;; | |
718 | ufs) | |
719 | STORE_TESTS="$STORE_TESTS tests/testUfs$EXEEXT" | |
720 | esac | |
721 | done | |
722 | ||
723 | dnl hack: need to define those even if not used in the build system to | |
724 | dnl make sure that global FS objects are linked to the squid binary. | |
725 | AH_TEMPLATE(HAVE_FS_UFS, "Define to 1 if ufs filesystem module is build") | |
726 | AH_TEMPLATE(HAVE_FS_AUFS, "Define to 1 if aufs filesystem module is build") | |
727 | AH_TEMPLATE(HAVE_FS_DISKD, "Define to 1 if diskd filesystem module is build") | |
728 | AH_TEMPLATE(HAVE_FS_COSS, "Define to 1 if coss filesystem module is build") | |
729 | ||
730 | ||
731 | dnl got final squid_storeio_module_candidates, build library lists | |
732 | dnl This list will not be needed when each fs library has its own Makefile | |
733 | STORE_LIBS_TO_BUILD= | |
734 | dnl File system libraries to link executables with. | |
735 | dnl These are the same as STORE_LIBS_TO_BUILD, but with a path | |
736 | STORE_LIBS_TO_ADD= | |
737 | for fs in $squid_storeio_module_candidates; do | |
738 | STORE_LIBS_TO_BUILD="$STORE_LIBS_TO_BUILD lib${fs}.la" | |
739 | STORE_LIBS_TO_ADD="$STORE_LIBS_TO_ADD fs/lib${fs}.la" | |
740 | SQUID_TOUPPER_VAR_CONTENTS([fs]) | |
741 | AC_DEFINE_UNQUOTED(HAVE_FS_${fs}, 1) | |
742 | done | |
743 | ||
744 | AC_SUBST(STORE_LIBS_TO_BUILD) | |
745 | AC_SUBST(STORE_LIBS_TO_ADD) | |
746 | AC_SUBST(STORE_TESTS) | |
747 | ||
748 | ||
749 | dnl At lest one removal policy is always needed. | |
750 | dnl 'lru' removal policy is currently hard-coded by name for tests | |
751 | dnl so we must set it as default. | |
752 | REPL_POLICIES="lru" | |
753 | AC_ARG_ENABLE(removal-policies, | |
754 | AS_HELP_STRING([--enable-removal-policies="list of policies"], | |
755 | [Build support for the list of removal policies. | |
756 | The default is only to build the "lru" module. | |
757 | See src/repl for a list of available modules, or | |
758 | Programmers Guide section 9.9 for details on how | |
759 | to build your custom policy]), | |
760 | [ case $enableval in | |
761 | yes) | |
762 | SQUID_LOOK_FOR_MODULES([$srcdir/src/repl],[REPL_POLICIES]) | |
763 | ;; | |
764 | no) | |
765 | ;; | |
766 | *) | |
767 | REPL_POLICIES="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" | |
768 | ;; | |
769 | esac | |
770 | ]) | |
771 | if test -n "$REPL_POLICIES"; then | |
772 | SQUID_CHECK_EXISTING_MODULES([$srcdir/src/repl],[REPL_POLICIES]) | |
773 | AC_MSG_NOTICE([Removal policies to build: $REPL_POLICIES]) | |
774 | REPL_OBJS="repl/lib`echo $REPL_POLICIES|sed -e 's% %.a repl/lib%g'`.a" | |
775 | REPL_LIBS="`echo $REPL_OBJS|sed -e 's%repl/%%g'`" | |
776 | fi | |
777 | AC_SUBST(REPL_POLICIES) | |
778 | AC_SUBST(REPL_OBJS) | |
779 | AC_SUBST(REPL_LIBS) | |
780 | ||
781 | AM_CONDITIONAL(ENABLE_PINGER, false) | |
782 | AC_ARG_ENABLE(icmp, | |
783 | AS_HELP_STRING([--enable-icmp],[Enable ICMP pinging and Network Measurement]), | |
784 | [ if test "$enableval" = "yes" ; then | |
785 | AC_MSG_NOTICE([ICMP enabled]) | |
786 | AC_DEFINE(USE_ICMP,1,[Define to use Squid ICMP and Network Measurement features (highly recommended!)]) | |
787 | AM_CONDITIONAL(ENABLE_PINGER, true) | |
788 | fi | |
789 | ]) | |
790 | ||
791 | AM_CONDITIONAL(USE_DELAY_POOLS, false) | |
792 | AC_ARG_ENABLE(delay-pools, | |
793 | AS_HELP_STRING([--enable-delay-pools],[Enable delay pools to limit bandwidth usage]), | |
794 | [ if test "$enableval" = "yes" ; then | |
795 | AC_MSG_NOTICE([Delay pools enabled]) | |
796 | AC_DEFINE([DELAY_POOLS],1,[Traffic management via "delay pools".]) | |
797 | AM_CONDITIONAL(USE_DELAY_POOLS, true,) | |
798 | fi | |
799 | ]) | |
800 | ||
801 | dnl disable generic/common adaptation support by default | |
802 | squid_opt_use_adaptation=no | |
803 | ||
804 | squid_opt_use_esi=yes | |
805 | AH_TEMPLATE([USE_SQUID_ESI], | |
806 | [Define to enable the ESI processor and Surrogate header support]) | |
807 | AC_ARG_ENABLE(esi, | |
808 | AS_HELP_STRING([--enable-esi], | |
809 | [Enable ESI for accelerators. Benefits from expat or libxml2. | |
810 | Enabling ESI will cause squid reverse proxies to be capable | |
811 | of the Edge Acceleration Specification (www.esi.org).]), | |
812 | [squid_opt_use_esi=$enableval], [squid_opt_use_esi=no]) | |
813 | HAVE_LIBEXPAT=0 | |
814 | EXPATLIB= | |
815 | HAVE_LIBXML2=0 | |
816 | XMLLIB= | |
817 | if test "$squid_opt_use_esi" = "yes" ; then | |
818 | AC_MSG_NOTICE([Enabling ESI processor and Surrogate header support.]) | |
819 | AC_DEFINE(USE_SQUID_ESI,1, | |
820 | [Compile the ESI processor and Surrogate header support]) | |
821 | else | |
822 | AC_MSG_NOTICE([Disabling ESI processor]) | |
823 | fi | |
824 | ||
825 | # ESI support libraries: expat | |
826 | AC_ARG_WITH(expat, AS_HELP_STRING([--without-expat],[Do not use expat for ESI. Default: auto-detect])) | |
827 | if test "$squid_opt_use_esi" = "yes" -a "$with_expat" != "no" ; then | |
828 | AC_CHECK_LIB([expat], [main], [EXPATLIB="-lexpat"; HAVE_LIBEXPAT=1]) | |
829 | AC_CHECK_HEADERS([expat.h]) | |
830 | AC_DEFINE_UNQUOTED(HAVE_LIBEXPAT, $HAVE_LIBEXPAT, [Define to 1 if you have the expat library]) | |
831 | if test "$with_expat" = "yes" && test "$HAVE_LIBEXPAT" != "1" ; then | |
832 | AC_MSG_ERROR([Required library expat is not able to be found.]) | |
833 | fi | |
834 | fi | |
835 | ||
836 | AC_ARG_WITH(libxml2, AS_HELP_STRING([--without-libxml2],[Do not use libxml2 for ESI. Default: auto-detect])) | |
837 | if test "$squid_opt_use_esi" = "yes" -a "$with_libxml2" != "no" ; then | |
838 | AC_CHECK_LIB([xml2], [main], [XMLLIB="-lxml2"; HAVE_LIBXML2=1]) | |
839 | dnl Find the main header and include path... | |
840 | AC_CHECK_HEADERS([libxml/parser.h], [], [ | |
841 | SAVED_CPPFLAGS="$CPPFLAGS" | |
842 | CPPFLAGS="-I/usr/include/libxml2 $CPPFLAGS" | |
843 | unset ac_cv_header_libxml_parser_h | |
844 | AC_CHECK_HEADERS([libxml/parser.h], [ac_cv_libxml2_include=yes], []) | |
845 | CPPFLAGS="$SAVED_CPPFLAGS" | |
846 | ]) | |
847 | if test "x$ac_cv_libxml2_include" = "xyes"; then | |
848 | SQUID_CXXFLAGS="-I/usr/include/libxml2 $SQUID_CXXFLAGS" | |
849 | CPPFLAGS="-I/usr/include/libxml2 $CPPFLAGS" | |
850 | fi | |
851 | dnl Now that we know where to look find the other headers... | |
852 | AC_CHECK_HEADERS(libxml/HTMLparser.h libxml/HTMLtree.h) | |
853 | AC_DEFINE_UNQUOTED(HAVE_LIBXML2, $HAVE_LIBXML2, [Define to 1 if you have the libxml2 library]) | |
854 | if test "$with_libxml2" = "yes" && test "$HAVE_LIBXML2" != "1" ; then | |
855 | AC_MSG_ERROR([Required library libxml2 is not able to be found.]) | |
856 | fi | |
857 | fi | |
858 | ||
859 | AM_CONDITIONAL(USE_ESI, test "$squid_opt_use_esi" = "yes") | |
860 | AM_CONDITIONAL(HAVE_LIBEXPAT, test $HAVE_LIBEXPAT = 1) | |
861 | AC_SUBST(EXPATLIB) | |
862 | AM_CONDITIONAL(HAVE_LIBXML2, test $HAVE_LIBXML2 = 1) | |
863 | AC_SUBST(XMLLIB) | |
864 | ||
865 | # icap argument handling | |
866 | AC_ARG_ENABLE(icap-client, | |
867 | AS_HELP_STRING([--enable-icap-client],[Enable the ICAP client.]), | |
868 | [squid_opt_use_icap_client=$enableval], [squid_opt_use_icap_client=no]) | |
869 | SQUID_DEFINE_BOOL([ICAP_CLIENT],$squid_opt_use_icap_client, | |
870 | [Enable ICAP client features in Squid]) | |
871 | AM_CONDITIONAL(USE_ICAP_CLIENT, [test "$squid_opt_use_icap_client" = "yes" ]) | |
872 | if test "$squid_opt_use_icap_client" = "yes" ; then | |
873 | ICAP_LIBS="icap/libicap.la" | |
874 | squid_opt_use_adaptation=yes | |
875 | else | |
876 | ICAP_LIBS="" | |
877 | fi | |
878 | AC_SUBST(ICAP_LIBS) | |
879 | ||
880 | squid_opt_use_ecap=1 | |
881 | AC_MSG_CHECKING(whether to support eCAP) | |
882 | AC_ARG_ENABLE(ecap, | |
883 | AS_HELP_STRING([--enable-ecap],[support loadable content adaptation modules]), [ | |
884 | case "${enableval}" in | |
885 | yes|no) squid_opt_use_ecap=$enableval ;; | |
886 | *) AC_MSG_ERROR(bad value ${enableval} for --enable-ecap) ;; | |
887 | esac | |
888 | AC_MSG_RESULT([$squid_opt_use_ecap, explicitly]) | |
889 | ], [ | |
890 | squid_opt_use_ecap=no; | |
891 | AC_MSG_RESULT([$squid_opt_use_ecap, implicitly]) | |
892 | ] | |
893 | ) | |
894 | ||
895 | dnl Perform configuration consistency checks for eCAP | |
896 | ECAPLIB="" | |
897 | if test $squid_opt_use_ecap = yes; | |
898 | then | |
899 | dnl eCAP support requires loadable modules, which are enabled by default | |
900 | if test "$use_loadable_modules" != "yes" | |
901 | then | |
902 | AC_MSG_ERROR([eCAP support requires loadable modules. Please do not use --disable-loadable-modules with --enable-ecap.]); | |
903 | fi | |
904 | ||
905 | dnl eCAP support requires libecap | |
906 | AC_CHECK_LIB([ecap], [main], | |
907 | [ECAPLIB="-lecap"], | |
908 | [AC_MSG_FAILURE([eCAP support requires libecap library, but no usable library was found])] | |
909 | ) | |
910 | fi | |
911 | ||
912 | AM_CONDITIONAL(USE_ECAP, test $squid_opt_use_ecap = yes) | |
913 | if test $squid_opt_use_ecap = yes; | |
914 | then | |
915 | AC_DEFINE(USE_ECAP,1,[Enable eCAP support]) | |
916 | ECAP_LIBS="ecap/libecap.la $ECAP_LIBS" | |
917 | squid_opt_use_adaptation=yes | |
918 | else | |
919 | AC_DEFINE(USE_ECAP,0,[Disable eCAP support]) | |
920 | ECAP_LIBS="" | |
921 | fi | |
922 | dnl convenience library | |
923 | AC_SUBST(ECAP_LIBS) | |
924 | dnl -lecap if needed | |
925 | AC_SUBST(ECAPLIB) | |
926 | ||
927 | ||
928 | dnl enable adaptation if requested by specific adaptation mechanisms | |
929 | AM_CONDITIONAL(USE_ADAPTATION, test $squid_opt_use_adaptation = yes) | |
930 | if test $squid_opt_use_adaptation = yes | |
931 | then | |
932 | AC_DEFINE(USE_ADAPTATION,1,[common adaptation support]) | |
933 | ADAPTATION_LIBS="adaptation/libadaptation.la" | |
934 | else | |
935 | AC_DEFINE(USE_ADAPTATION,0,[common adaptation support]) | |
936 | ADAPTATION_LIBS="" | |
937 | fi | |
938 | AC_SUBST(ADAPTATION_LIBS) | |
939 | ||
940 | ||
941 | dnl This is a developer only option. Developers know how to set defines | |
942 | dnl | |
943 | dnl AC_ARG_ENABLE(mem-gen-trace, | |
944 | dnl [ --enable-mem-gen-trace Do trace of memory stuff], | |
945 | dnl [ if test "$enableval" = "yes" ; then | |
946 | dnl AC_MSG_NOTICE([Memory trace (to file) enabled]) | |
947 | dnl AC_DEFINE(MEM_GEN_TRACE,1,[Define for log file trace of mem alloc/free]) | |
948 | dnl fi | |
949 | dnl ]) | |
950 | ||
951 | ||
952 | AC_ARG_ENABLE(useragent-log, | |
953 | AS_HELP_STRING([--enable-useragent-log], | |
954 | [Enable logging of User-Agent header]), [ | |
955 | SQUID_YESNO([$enableval], | |
956 | [unrecognized argument to --enable-useragent-log: $enableval]) | |
957 | enable_useragent_log=$enableval | |
958 | ]) | |
959 | SQUID_DEFINE_BOOL(USE_USERAGENT_LOG,${enable_useragent_log:=no}, | |
960 | [If you want to log User-Agent request header values, define this.]) | |
961 | AC_MSG_NOTICE([User-Agent logging enabled: $enable_useragent_log]) | |
962 | ||
963 | AC_ARG_ENABLE(referer-log, | |
964 | AS_HELP_STRING([--enable-referer-log],[Enable logging of Referer header]), [ | |
965 | SQUID_YESNO([$enableval], | |
966 | [unrecognized argument to --enable-referer-log: $enableval]) | |
967 | ]) | |
968 | SQUID_DEFINE_BOOL(USE_REFERER_LOG,${enable_referer_log:=no}, | |
969 | [If you want to log Referer request header values, define this. | |
970 | By default, they are written to referer.log in the Squid logdir. | |
971 | This feature is deprecated in favour of custom log formats]) | |
972 | AC_MSG_NOTICE([Referer logging enabled: $enable_referer_log]) | |
973 | ||
974 | AC_ARG_ENABLE(wccp, | |
975 | AS_HELP_STRING([--disable-wccp],[Disable Web Cache Coordination Protocol]), [ | |
976 | SQUID_YESNO([$enableval],[unrecognized argument to --disable-wccp: $enableval]) | |
977 | ]) | |
978 | SQUID_DEFINE_BOOL(USE_WCCP, ${enable_wccp:=yes}, [Define to enable WCCP]) | |
979 | AC_MSG_NOTICE([Web Cache Coordination Protocol enabled: $enable_wccp]) | |
980 | ||
981 | AC_ARG_ENABLE(wccpv2, | |
982 | AS_HELP_STRING([--disable-wccpv2], | |
983 | [Disable Web Cache Coordination V2 Protocol]), [ | |
984 | SQUID_YESNO([$enableval], | |
985 | [unrecognized argument to --disable-wccpv2: $enableval]) | |
986 | ]) | |
987 | SQUID_DEFINE_BOOL(USE_WCCPv2,${enable_wccpv2:=yes}, | |
988 | [Define to enable WCCP V2]) | |
989 | AC_MSG_NOTICE([Web Cache Coordination V2 Protocol enabled: $enable_wccpv2]) | |
990 | ||
991 | AC_ARG_ENABLE(kill-parent-hack, | |
992 | AS_HELP_STRING([--enable-kill-parent-hack],[Kill parent on shutdown]), [ | |
993 | SQUID_YESNO([$enableval], | |
994 | [unrecognized argument to --enable-kill-parent-hack: $enableval]) | |
995 | ]) | |
996 | SQUID_DEFINE_BOOL(KILL_PARENT_OPT,${enable_kill_parent_hack:=no}, | |
997 | [A dangerous feature which causes Squid to kill its parent | |
998 | process (presumably the RunCache script) upon receipt | |
999 | of SIGTERM or SIGINT. Deprecated, Use with caution.]) | |
1000 | AC_MSG_NOTICE([Kill parent on shutdown hack enabled: $enable_kill_parent_hack]) | |
1001 | ||
1002 | AC_ARG_ENABLE(snmp, | |
1003 | AS_HELP_STRING([--disable-snmp],[Disable SNMP monitoring support]), [ | |
1004 | SQUID_YESNO([$enableval], | |
1005 | [unrecognized argument to --disable-snmp: $enableval]) | |
1006 | ]) | |
1007 | SQUID_DEFINE_BOOL(SQUID_SNMP,${enable_snmp:=yes}, | |
1008 | [Define to enable SNMP monitoring of Squid]) | |
1009 | AM_CONDITIONAL(USE_SNMP, [test "$enable_snmp" = "yes"]) | |
1010 | if test "$enable_snmp" = "yes"; then | |
1011 | SNMPLIB='../snmplib/libsnmp.a' | |
1012 | makesnmplib=snmplib | |
1013 | fi | |
1014 | AC_MSG_NOTICE([SNMP support enabled: $enable_snmp]) | |
1015 | AC_SUBST(SNMPLIB) | |
1016 | AC_SUBST(makesnmplib) | |
1017 | ||
1018 | AC_ARG_ENABLE(cachemgr-hostname, | |
1019 | AS_HELP_STRING([--enable-cachemgr-hostname=hostname], | |
1020 | [Make cachemgr.cgi default to this host. | |
1021 | If unspecified, uses the name of the build-host]), [ | |
1022 | case $enableval in | |
1023 | yes) | |
1024 | AC_DEFINE(CACHEMGR_HOSTNAME,[getfullhostname()], | |
1025 | [If you are upset that the cachemgr.cgi form comes up with the hostname field blank, then define this to getfullhostname()]) | |
1026 | AC_MSG_NOTICE([Cachemgr default hostname == host where cachemgr runs]) | |
1027 | ;; | |
1028 | no) | |
1029 | : # Nothing to do.. | |
1030 | ;; | |
1031 | *) | |
1032 | AC_DEFINE_UNQUOTED(CACHEMGR_HOSTNAME,"${enableval}") | |
1033 | AC_MSG_NOTICE([Cachemgr default hostname set to ${enableval}]) | |
1034 | ;; | |
1035 | esac | |
1036 | ]) | |
1037 | ||
1038 | AC_ARG_ENABLE(eui, | |
1039 | AS_HELP_STRING([--disable-eui], | |
1040 | [Enable use of ARP / MAC/ EUI (ether address)]), [ | |
1041 | SQUID_YESNO([$enableval],[--disable-eui expects no arguments]) | |
1042 | ]) | |
1043 | if test ${enable_eui:=yes} = "yes" ; then | |
1044 | case "$squid_host_os" in | |
1045 | linux|solaris|freebsd|openbsd|netbsd) | |
1046 | ${TRUE} | |
1047 | ;; | |
1048 | cygwin|mingw) | |
1049 | EUILIB="-liphlpapi" | |
1050 | ;; | |
1051 | *) | |
1052 | AC_MSG_WARN([EUI support probably will not work on host $host.]) | |
1053 | ;; | |
1054 | esac | |
1055 | AC_CHECK_HEADERS( \ | |
1056 | Iphlpapi.h \ | |
1057 | net/if.h \ | |
1058 | net/if_arp.h \ | |
1059 | net/if_dl.h \ | |
1060 | net/route.h \ | |
1061 | netinet/if_ether.h \ | |
1062 | sys/sockio.h \ | |
1063 | sys/sysctl.h \ | |
1064 | sys/ioctl.h \ | |
1065 | ) | |
1066 | fi | |
1067 | AC_MSG_NOTICE([EUI (MAC address) controls enabled: $enable_eui]) | |
1068 | SQUID_DEFINE_BOOL(USE_SQUID_EUI,$enable_eui, | |
1069 | [Define this to include code which lets you use ethernet addresses. This code uses API initially defined in 4.4-BSD.]) | |
1070 | AM_CONDITIONAL(USE_SQUID_EUI, [test "$enable_eui" = "yes" ]) | |
1071 | ||
1072 | ||
1073 | AC_ARG_ENABLE(htcp, | |
1074 | AS_HELP_STRING([--disable-htcp],[Disable HTCP protocol support]), [ | |
1075 | SQUID_YESNO([$enableval], | |
1076 | [unrecognized argument to --disable-htcp: $enableval]) | |
1077 | ]) | |
1078 | SQUID_DEFINE_BOOL([USE_HTCP],${enable_htcp:=yes}, | |
1079 | [Define this to include code for the Hypertext Cache Protocol (HTCP)]) | |
1080 | AM_CONDITIONAL(ENABLE_HTCP, [test "$enable_htcp" = "yes"]) | |
1081 | AC_MSG_NOTICE([HTCP support enabled: $enable_htcp]) | |
1082 | ||
1083 | ||
1084 | # SSL is not enabled by default. | |
1085 | # Default is to use OpenSSL when available | |
1086 | AC_ARG_ENABLE(ssl, | |
1087 | AS_HELP_STRING([--enable-ssl], | |
1088 | [Enable ssl gatewaying support using OpenSSL]), [ | |
1089 | SQUID_YESNO([$enableval], | |
1090 | [unrecognized argument to --enable-ssl: $enableval]) | |
1091 | ]) | |
1092 | # USE_OPENSSL is AC_DEFINED later | |
1093 | # default for ssl is set here | |
1094 | if test ${enable_ssl:=no} = "yes" ; then | |
1095 | if test "$squid_host_os" = "mingw" ; then | |
1096 | SSLLIB='-lssleay32 -leay32 -lgdi32' | |
1097 | else | |
1098 | SSLLIB='-lssl -lcrypto' | |
1099 | fi | |
1100 | if test -z "$with_openssl"; then | |
1101 | with_openssl=yes | |
1102 | fi | |
1103 | if test -z "$with_openssl"; then | |
1104 | with_openssl=yes | |
1105 | fi | |
1106 | fi | |
1107 | AM_CONDITIONAL(ENABLE_SSL,[ test $enable_ssl = "yes" ]) | |
1108 | AC_MSG_NOTICE([SSL gatewaying support enabled: $enable_ssl]) | |
1109 | ||
1110 | dnl User may specify OpenSSL is needed from a non-standard location | |
1111 | AC_ARG_WITH(openssl, | |
1112 | AS_HELP_STRING([--with-openssl=PATH], | |
1113 | [Compile with the OpenSSL libraries. The path to | |
1114 | the OpenSSL development libraries and headers | |
1115 | installation can be specified if outside of the | |
1116 | system standard directories]), [ | |
1117 | case "$with_openssl" in | |
1118 | yes|no) | |
1119 | : # Nothing special to do here | |
1120 | ;; | |
1121 | *) | |
1122 | if test ! -d $withval ; then | |
1123 | AC_MSG_ERROR([--with-openssl path does not point to a directory]) | |
1124 | fi | |
1125 | SSLLIBDIR="$with_openssl/lib" | |
1126 | CPPFLAGS="-I$with_openssl/include $CPPFLAGS" | |
1127 | with_openssl=yes | |
1128 | esac | |
1129 | ]) | |
1130 | SQUID_DEFINE_BOOL(USE_SSL,$enable_ssl, | |
1131 | [Define this to include code for SSL gatewaying support]) | |
1132 | AC_MSG_NOTICE([Using OpenSSL MD5 implementation: ${with_openssl:=no}]) | |
1133 | SQUID_DEFINE_BOOL(USE_OPENSSL,${with_openssl}, | |
1134 | [Define this to make use of the OpenSSL libraries for MD5 calculation rather than Squid-supplied MD5 implementation or if building with SSL encryption]) | |
1135 | if test "$enable_ssl" = "yes"; then | |
1136 | if test -z "$SSLLIB"; then | |
1137 | SSLLIB="-lcrypto" # for MD5 routines | |
1138 | fi | |
1139 | # This is a workaround for RedHat 9 brain damage.. | |
1140 | if test -d /usr/kerberos/include && test -z "$SSLLIBDIR" && test -f /usr/include/openssl/kssl.h; then | |
1141 | AC_MSG_NOTICE([OpenSSL depends on Kerberos]) | |
1142 | SSLLIBDIR="/usr/kerberos/lib" | |
1143 | CPPFLAGS="$CPPFLAGS -I/usr/kerberos/include" | |
1144 | fi | |
1145 | fi | |
1146 | if test -n "$SSLLIBDIR"; then | |
1147 | SSLLIB="-L$SSLLIBDIR $SSLLIB" | |
1148 | fi | |
1149 | AC_SUBST(SSLLIB) | |
1150 | ||
1151 | ||
1152 | AC_ARG_ENABLE(forw-via-db, | |
1153 | AS_HELP_STRING([--enable-forw-via-db],[Enable Forw/Via database]), [ | |
1154 | SQUID_YESNO([$enableval],[unrecognized argument to --enable-forw-via-db: $enableval]) | |
1155 | ]) | |
1156 | SQUID_DEFINE_BOOL(USE_FORW_VIA_DB,${enable_forw_via_db:=no}, | |
1157 | [Enable Forw/Via database]) | |
1158 | AC_MSG_NOTICE([Forw/Via database enabled: $enable_forw_via_db]) | |
1159 | ||
1160 | AC_ARG_ENABLE(cache-digests, | |
1161 | AS_HELP_STRING([--enable-cache-digests], | |
1162 | [Use Cache Digests. See http://wiki.squid-cache.org/SquidFaq/CacheDigests]), | |
1163 | [ | |
1164 | SQUID_YESNO($enableval, | |
1165 | [unrecognized argument to --enable-cache-digests: $enableval]) | |
1166 | ]) | |
1167 | SQUID_DEFINE_BOOL(USE_CACHE_DIGESTS,${enable_cache_digests:=no}, | |
1168 | [Use Cache Digests for locating objects in neighbor caches.]) | |
1169 | AC_MSG_NOTICE([Cache Digests enabled: $enable_cache_digests]) | |
1170 | ||
1171 | ||
1172 | dnl Size of COSS memory buffer | |
1173 | squid_opt_coss_membuf_size=1048576 | |
1174 | AC_ARG_WITH(coss-membuf-size, | |
1175 | AS_HELP_STRING([--with-coss-membuf-size=size], | |
1176 | [COSS membuf size (default $squid_opt_coss_membuf_size bytes)]), [ | |
1177 | case $withval in | |
1178 | [[0-9]]*) squid_opt_coss_membuf_size=$withval ;; | |
1179 | *) AC_MSG_ERROR([--with-coss-membuf-size expects a numeric argument]) ;; | |
1180 | esac | |
1181 | ]) | |
1182 | AC_MSG_NOTICE([Setting COSS membuf size to $squid_opt_coss_membuf_size bytes]) | |
1183 | AC_DEFINE_UNQUOTED(COSS_MEMBUF_SZ, $squid_opt_coss_membuf_size, | |
1184 | [Default COSS membuf size]) | |
1185 | ||
1186 | ################################ | |
1187 | # check for netio plugin stuff # | |
1188 | ################################ | |
1189 | dnl order of these options handling is relevant in case the user | |
1190 | dnl supplies more than one --enable option. Options handled later | |
1191 | dnl override those handled earlier for io loop method manual override | |
1192 | AC_ARG_ENABLE(select, | |
1193 | AS_HELP_STRING([--disable-select],[Disable select(2) support.]), | |
1194 | [ | |
1195 | SQUID_YESNO($enableval,[--disable-select takes no extra argument]) | |
1196 | test $enableval = "yes" && squid_opt_io_loop_engine="select" | |
1197 | ]) | |
1198 | AC_MSG_NOTICE([enabling select syscall for net I/O: ${enable_select:=auto}]) | |
1199 | ||
1200 | AC_ARG_ENABLE(poll, | |
1201 | AS_HELP_STRING([--disable-poll],[Disable poll(2) support.]), | |
1202 | [ | |
1203 | SQUID_YESNO($enableval,[--disable-poll takes no extra argument]) | |
1204 | test $enableval = "yes" && squid_opt_io_loop_engine="poll" | |
1205 | ]) | |
1206 | AC_MSG_NOTICE([enabling poll syscall for net I/O: ${enable_poll:=auto}]) | |
1207 | ||
1208 | # kqueue support is still experiemntal and unstable. Not enabled by default. | |
1209 | AC_ARG_ENABLE(kqueue, | |
1210 | AS_HELP_STRING([--enable-kqueue], | |
1211 | [Enable kqueue(2) support (experimental).]), [ | |
1212 | SQUID_YESNO($enableval,[--enable-kqueue takes no extra argument]) | |
1213 | ]) | |
1214 | if test ${enable_kqueue:=no} = "yes" ; then | |
1215 | AC_CHECK_HEADERS([sys/event.h],[], | |
1216 | [ AC_MSG_ERROR([kqueue support requires sys/event.h header file.]) ]) | |
1217 | squid_opt_io_loop_engine="kqueue" | |
1218 | fi | |
1219 | AC_MSG_NOTICE([enabling kqueue for net I/O: $enable_kqueue]) | |
1220 | ||
1221 | dnl Enable epoll() | |
1222 | AC_ARG_ENABLE(epoll, | |
1223 | AS_HELP_STRING([--disable-epoll],[Disable Linux epoll(2) support.]), | |
1224 | [ | |
1225 | SQUID_YESNO($enableval,[--disable-epoll takes no extra argument]) | |
1226 | test $enableval = "yes" && squid_opt_io_loop_engine="epoll" | |
1227 | ]) | |
1228 | AC_MSG_NOTICE([enabling epoll syscall for net I/O: ${enable_epoll:=auto}]) | |
1229 | ||
1230 | # auto-detect and verify epoll header and library present and working | |
1231 | # logic mapping and loop method selection are performed later | |
1232 | if test "$enable_epoll" != "no" ; then | |
1233 | ||
1234 | # check if libs are needed to support epoll | |
1235 | # note: this code block seems quite generic. Could it be extracted | |
1236 | # into a squid specific configure function? | |
1237 | SQUID_STATE_SAVE(squid_epoll_state) | |
1238 | AC_SEARCH_LIBS(epoll_ctl,[epoll]) | |
1239 | if test "$ac_cv_search_epoll_ctl" = "no" ; then | |
1240 | enable_epoll=no #disable. Needed code not found | |
1241 | elif test "$ac_cv_search_epoll_ctl" = "none required" ; then | |
1242 | EPOLL_LIBS="" | |
1243 | else | |
1244 | EPOLL_LIBS=$ac_cv_search_epoll_ctl | |
1245 | fi | |
1246 | AC_SUBST(EPOLL_LIBS) | |
1247 | SQUID_STATE_ROLLBACK(squid_epoll_state) #de-pollute LIBS | |
1248 | ||
1249 | # epoll requires sys/epoll.h | |
1250 | AC_CHECK_HEADERS([sys/epoll.h]) | |
1251 | ||
1252 | dnl Verify that epoll really works | |
1253 | if test "x$ac_cv_search_epoll_ctl" != 'xno' ; then | |
1254 | SQUID_CHECK_EPOLL | |
1255 | fi | |
1256 | ||
1257 | if test "$enable_epoll" = "yes" -a "$squid_cv_epoll_works" = "no" ; then | |
1258 | AC_MSG_ERROR([Epoll does not work. Force-enabling it is not going to help.]) | |
1259 | fi | |
1260 | fi | |
1261 | ||
1262 | ||
1263 | AC_ARG_ENABLE(http-violations, | |
1264 | AS_HELP_STRING([--disable-http-violations], | |
1265 | [This allows you to remove code which is known to | |
1266 | violate the HTTP protocol specification.]), [ | |
1267 | SQUID_YESNO([$enableval], | |
1268 | [unrecognized argument to --disable-http-violations: $enableval]) | |
1269 | ]) | |
1270 | SQUID_DEFINE_BOOL(HTTP_VIOLATIONS, ${enable_http_violations:=yes}, | |
1271 | [Define to enable code which volates the HTTP standard specification]) | |
1272 | AC_MSG_NOTICE([HTTP violations support enabled: $enable_http_violations]) | |
1273 | ||
1274 | # IPFW Transparent Proxy | |
1275 | AC_ARG_ENABLE(ipfw-transparent, | |
1276 | AS_HELP_STRING([--enable-ipfw-transparent], | |
1277 | [Enable Transparent Proxy support for systems | |
1278 | using FreeBSD IPFW-style firewalling.]), [ | |
1279 | SQUID_YESNO([$enableval], | |
1280 | [unrecognized argument to --enable-ipfw-transparent: $enableval]) | |
1281 | ]) | |
1282 | SQUID_DEFINE_BOOL(IPFW_TRANSPARENT,${enable_ipfw_transparent:=no}, | |
1283 | [Enable support for Transparent Proxy on systems using FreeBSD IPFW-style firewalling.]) | |
1284 | AC_MSG_NOTICE([FreeBSD IPFW-based transparent proxying enabled: $enable_ipfw_transparent]) | |
1285 | ||
1286 | # IP-Filter Transparent Proxy | |
1287 | AC_ARG_ENABLE(ipf-transparent, | |
1288 | AS_HELP_STRING([--enable-ipf-transparent], | |
1289 | [Enable Transparent Proxy support using IPFilter-style firewalling]), [ | |
1290 | SQUID_YESNO([$enableval], | |
1291 | [unrecognized argument to --enable-ipf-transparent: $enableval]) | |
1292 | ]) | |
1293 | #will be AC_DEFINEd later, after checking for appropriate infrastructure | |
1294 | #IPF currently broken. Default-disabled for now. | |
1295 | AC_MSG_NOTICE([IPF-based transparent proxying requested: ${enable_ipf_transparent:=no}]) | |
1296 | ||
1297 | dnl Enable PF Transparent Proxy | |
1298 | AC_ARG_ENABLE(pf-transparent, | |
1299 | AS_HELP_STRING([--enable-pf-transparent], | |
1300 | [Enable Transparent Proxy support for systems using PF network address redirection.]), [ | |
1301 | SQUID_YESNO([$enableval], | |
1302 | [unrecognized argument to --enable-pf-transparent: $enableval]) | |
1303 | ]) | |
1304 | #will be AC_DEFINEd later, after checking for appropriate infrastructure | |
1305 | AC_MSG_NOTICE([PF-based transparent proxying requested: ${enable_pf_transparent:=auto}]) | |
1306 | ||
1307 | # Linux Netfilter Transparent Proxy | |
1308 | AC_ARG_ENABLE(linux-netfilter, | |
1309 | AS_HELP_STRING([--enable-linux-netfilter], | |
1310 | [Enable Transparent Proxy support for Linux (Netfilter)]), [ | |
1311 | SQUID_YESNO([$enableval], | |
1312 | [unrecognized argument to --enable-linux-netfilter: $enableval]) | |
1313 | ]) | |
1314 | AC_MSG_NOTICE([Linux Netfilter support requested: ${enable_linux_netfilter:=auto}]) | |
1315 | #will be AC_DEFINEd later, after checking for appropriate infrastructure | |
1316 | ||
1317 | dnl Enable Large file support | |
1318 | buildmodel="" | |
1319 | squid_opt_enable_large_files=no | |
1320 | ||
1321 | AC_ARG_WITH(large-files, | |
1322 | AS_HELP_STRING([--with-large-files],[Enable support for large files (logs etc).]), | |
1323 | [ if test "x$withval" = "xyes"; then | |
1324 | squid_opt_enable_large_files=yes | |
1325 | fi | |
1326 | ]) | |
1327 | ||
1328 | dnl UNIX Build environment | |
1329 | dnl AS_HELP_STRING is not suited here because it cannot to specify newlines | |
1330 | AC_ARG_WITH(build-environment, | |
1331 | [ --with-build-environment=model | |
1332 | The build environment to use. Normally one of | |
1333 | POSIX_V6_ILP32_OFF32 32 bits | |
1334 | POSIX_V6_ILP32_OFFBIG 32 bits with large file support | |
1335 | POSIX_V6_LP64_OFF64 64 bits | |
1336 | POSIX_V6_LPBIG_OFFBIG large pointers and files | |
1337 | XBS5_ILP32_OFF32 32 bits (legacy) | |
1338 | XBS5_ILP32_OFFBIG 32 bits with large file support (legacy) | |
1339 | XBS5_LP64_OFF64 64 bits (legacy) | |
1340 | XBS5_LPBIG_OFFBIG large pointers and files (legacy) | |
1341 | default The default for your OS], | |
1342 | [ case "$withval" in | |
1343 | yes|no) | |
1344 | AC_MSG_FAILURE([--with-build-environment expects a build environment string as used by getconf]) | |
1345 | ;; | |
1346 | *) | |
1347 | buildmodel="$withval" | |
1348 | ;; | |
1349 | esac | |
1350 | ]) | |
1351 | ||
1352 | if test "$squid_opt_enable_large_files" = "yes" -a -z "$buildmodel"; then | |
1353 | 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 | |
1354 | if test "`getconf _$model 2>/dev/null || true`" = 1 || test "`getconf $model 2>/dev/null || true`" ; then | |
1355 | buildmodel=$model | |
1356 | break | |
1357 | fi | |
1358 | done | |
1359 | if test -z "$buildmodel"; then | |
1360 | AC_MSG_WARN([No suitable build environment found for large files. Trying to use _FILE_OFFSET_BITS=64]) | |
1361 | fi | |
1362 | fi | |
1363 | case "$buildmodel" in | |
1364 | default|"") | |
1365 | if test "$squid_opt_enable_large_files" = "yes" ; then | |
1366 | AC_MSG_NOTICE([Enabling -D_FILE_OFFSET_BITS=64]) | |
1367 | CFLAGS="-D_FILE_OFFSET_BITS=64 $CFLAGS" | |
1368 | CXXFLAGS="-D_FILE_OFFSET_BITS=64 $CXXFLAGS" | |
1369 | fi | |
1370 | ;; | |
1371 | *) | |
1372 | AC_MSG_NOTICE([Using $buildmodel build environment]) | |
1373 | if test "`getconf _$buildmodel 2>/dev/null || true`" = 1 || test "`getconf $buildmodel 2>/dev/null || true`" ; then | |
1374 | : # All fine | |
1375 | else | |
1376 | AC_MSG_ERROR(Build environment $buildmodel not known to getconf.) | |
1377 | fi | |
1378 | CFLAGS="`getconf ${buildmodel}_CFLAGS` $CFLAGS" | |
1379 | CXXFLAGS="`getconf ${buildmodel}_CFLAGS` $CXXFLAGS" | |
1380 | LIBS="`getconf ${buildmodel}_LIBS` $LIBS" | |
1381 | LDFLAGS="`getconf ${buildmodel}_LDFLAGS` $LDFLAGS" | |
1382 | if "$squid_host_os" = "solaris" ; then | |
1383 | ||
1384 | # On Solaris getconf returns for CFLAGS -xarch=generic64, -Xa and -Usun options, and | |
1385 | # for LDFLAGS -xarch=generic64, but: | |
1386 | # "-Xa" is supported only by Sun cc, so we need to remove it when using gcc | |
1387 | # For gcc "-xarch=generic64" must be replaced with "-m64" | |
1388 | # The 'sun' define is needed by ipfilter includes, so we must remove "-Usun" | |
1389 | if test "$GCC" = "yes"; then | |
1390 | AC_MSG_NOTICE([Removing -Xa for gcc/g++ on $host]) | |
1391 | CFLAGS="`echo $CFLAGS | sed -e 's/-Xa//'`" | |
1392 | CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-Xa//'`" | |
1393 | AC_MSG_NOTICE([Replacing -xarch=generic64 with -m64 for gcc/g++ on $host]) | |
1394 | CFLAGS="`echo $CFLAGS | sed -e 's/-xarch=generic64/-m64/'`" | |
1395 | CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-xarch=generic64/-m64/'`" | |
1396 | LDFLAGS="`echo $LDFLAGS | sed -e 's/-xarch=generic64//'`" | |
1397 | fi | |
1398 | AC_MSG_NOTICE([Removing -Usun on $host]) | |
1399 | CFLAGS="`echo $CFLAGS | sed -e 's/-Usun//'`" | |
1400 | CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-Usun//'`" | |
1401 | fi | |
1402 | esac | |
1403 | ||
1404 | dnl Enable Leak Finding Functions | |
1405 | squid_opt_enable_leakfinder=no | |
1406 | AC_ARG_ENABLE(leakfinder, | |
1407 | AS_HELP_STRING([--enable-leakfinder], | |
1408 | [Enable Leak Finding code. Enabling this alone does nothing; | |
1409 | you also have to modify the source code to use the leak | |
1410 | finding functions. Probably Useful for hackers only.]), [ | |
1411 | SQUID_YESNO([$enableval],[unrecognized argument to --enable-leakfinder: $enableval]) | |
1412 | squid_opt_enable_leakfinder=$enableval | |
1413 | ]) | |
1414 | AC_MSG_NOTICE([Leak Finder enabled: $squid_opt_enable_leakfinder]) | |
1415 | SQUID_DEFINE_BOOL(USE_LEAKFINDER,$squid_opt_enable_leakfinder, | |
1416 | [Enable code for assisting in finding memory leaks. Not for the faint of heart]) | |
1417 | AM_CONDITIONAL(MAKE_LEAKFINDER, [test "$squid_opt_enable_leakfinder" = "yes"]) | |
1418 | ||
1419 | ||
1420 | squid_opt_follow_xff="yes" | |
1421 | AC_ARG_ENABLE(follow-x-forwarded-for, | |
1422 | AS_HELP_STRING([--enable-follow-x-forwarded-for],[Enable support for following the X-Forwarded-For | |
1423 | HTTP header to try to find the IP address of the | |
1424 | original or indirect client when a request has | |
1425 | been forwarded through other proxies.]), [ | |
1426 | SQUID_YESNO([$enableval],[unrecognized argument to --enable-follow-x-forwarded-for: $enableval]) | |
1427 | squid_opt_follow_xff=$enableval | |
1428 | ]) | |
1429 | AC_MSG_NOTICE([Support for X-Forwarded-For enabled: $squid_opt_follow_xff]) | |
1430 | SQUID_DEFINE_BOOL([FOLLOW_X_FORWARDED_FOR],$squid_opt_follow_xff, | |
1431 | [Enable following X-Forwarded-For headers]) | |
1432 | ||
1433 | squid_opt_use_ident="yes" | |
1434 | AC_ARG_ENABLE(ident-lookups, | |
1435 | AS_HELP_STRING([--disable-ident-lookups], | |
1436 | [Remove code that supports performing Ident (RFC 931) lookups.]), [ | |
1437 | SQUID_YESNO([$enableval],[unrecognized argument to --disable-ident-lookups: $enableval]) | |
1438 | squid_opt_use_ident=$enableval | |
1439 | ]) | |
1440 | AC_MSG_NOTICE([Support for Ident lookups enabled: $squid_opt_use_ident]) | |
1441 | SQUID_DEFINE_BOOL(USE_IDENT,$squid_opt_use_ident,[Support for Ident (RFC 931) lookups]) | |
1442 | ||
1443 | squid_opt_use_dnsserver="no" | |
1444 | AH_TEMPLATE(USE_DNSSERVERS, | |
1445 | [Use dnsserver processes instead of the internal DNS protocol support]) | |
1446 | AC_ARG_ENABLE(internal-dns, | |
1447 | AS_HELP_STRING([--disable-internal-dns], | |
1448 | [Prevents Squid from directly sending and receiving DNS messages, | |
1449 | and instead enables the old external 'dnsserver' processes.]), [ | |
1450 | if test "$enableval" = "no" ; then | |
1451 | AC_MSG_WARN([Disabling Internal DNS queries]) | |
1452 | squid_opt_use_dnsserver="yes" | |
1453 | AC_DEFINE(USE_DNSSERVERS,1) | |
1454 | else | |
1455 | AC_DEFINE(USE_DNSSERVERS,0) | |
1456 | fi | |
1457 | ]) | |
1458 | AM_CONDITIONAL([USE_DNSSERVER],[test "$squid_opt_use_dnsserver" = "yes" ]) | |
1459 | ||
1460 | ||
1461 | dnl Select Default hosts file location | |
1462 | AC_ARG_ENABLE(default-hostsfile, | |
1463 | AS_HELP_STRING([--enable-default-hostsfile=path],[Select default location for hosts file. | |
1464 | See hosts_file directive in squid.conf for details]), | |
1465 | [ | |
1466 | if test "$enableval" != "none" -a "$enableval" != "no" ; then | |
1467 | if test -f $enableval; then | |
1468 | OPT_DEFAULT_HOSTS=$enableval | |
1469 | else | |
1470 | AC_MSG_WARN([Unable to find $enableval]) | |
1471 | fi | |
1472 | else | |
1473 | OPT_DEFAULT_HOSTS="none" | |
1474 | fi | |
1475 | AC_MSG_NOTICE([Default hosts file set to: $enableval]) | |
1476 | ],[OPT_DEFAULT_HOSTS="/etc/hosts"]) | |
1477 | AC_SUBST(OPT_DEFAULT_HOSTS) | |
1478 | ||
1479 | # Select auth schemes modules to build | |
1480 | AC_ARG_ENABLE(auth, | |
1481 | AS_HELP_STRING([--enable-auth], | |
1482 | [Build global support for authentication. The list of schemes | |
1483 | and helpers to be enabled is defined elsewhere]), [ | |
1484 | SQUID_YESNO([$enableval], | |
1485 | [unrecognized argument to --enable-auth: $enableval]) | |
1486 | ]) | |
1487 | AC_MSG_NOTICE([Authentication support enabled: ${enable_auth:=yes}]) | |
1488 | SQUID_DEFINE_BOOL([USE_AUTH],$enable_auth, | |
1489 | [Enable support for authentication]) | |
1490 | AUTH_MODULES="" | |
1491 | ||
1492 | AC_ARG_ENABLE(auth-basic, | |
1493 | AS_HELP_STRING([--enable-auth-basic="list of helpers"], | |
1494 | [Enable the basic authentication scheme, and build the specified helpers. | |
1495 | Not providing an explicit list of helpers will attempt build of | |
1496 | all possible helpers. Default is to do so. | |
1497 | To disable the basic authentication scheme, use --disable-auth-basic. | |
1498 | To enable but build no helpers, specify "none". | |
1499 | To see available helpers, see the helpers/basic_auth directory. ]),[ | |
1500 | #nothing to do really | |
1501 | ]) | |
1502 | #not specified. Inherit global | |
1503 | if test "x$enable_auth_basic" = "x"; then | |
1504 | enable_auth_basic=$enable_auth | |
1505 | fi | |
1506 | #conflicts with global | |
1507 | if test "$enable_auth_basic" != "no" -a "$enable_auth" = "no" ; then | |
1508 | AC_MSG_ERROR([Basic auth requested but auth disabled]) | |
1509 | fi | |
1510 | #define list of modules to build | |
1511 | if test "$enable_auth_basic" = "yes" ; then | |
1512 | SQUID_LOOK_FOR_MODULES([$srcdir/helpers/basic_auth],[enable_auth_basic]) | |
1513 | fi | |
1514 | #handle the "none" special case | |
1515 | if test "x$enable_auth_basic" = "xnone" ; then | |
1516 | enable_auth_basic="" | |
1517 | fi | |
1518 | BASIC_AUTH_HELPERS="" | |
1519 | #enable_auth_basic contains either "no" or the list of modules to be built | |
1520 | enable_auth_basic="`echo $enable_auth_basic| sed -e 's/,/ /g;s/ */ /g'`" | |
1521 | if test "$enable_auth_basic" != "no" ; then | |
1522 | AUTH_MODULES="$AUTH_MODULES basic" | |
1523 | AC_DEFINE([HAVE_AUTH_MODULE_BASIC],1,[Basic auth module is built]) | |
1524 | for helper in $enable_auth_basic | |
1525 | do | |
1526 | dir="$srcdir/helpers/basic_auth/$helper" | |
1527 | if test -f $dir/config.test && sh $dir/config.test "$@"; then | |
1528 | BASIC_AUTH_HELPERS="$BASIC_AUTH_HELPERS $helper" | |
1529 | # special case | |
1530 | if test "$helper" = "SASL" ; then | |
1531 | squid_require_sasl=yes | |
1532 | fi | |
1533 | elif test -d $srcdir/helpers/basic_auth/$helper ; then | |
1534 | AC_MSG_NOTICE([Basic auth helper $helper ... found but cannot be built]) | |
1535 | fi | |
1536 | done | |
1537 | fi | |
1538 | AC_MSG_NOTICE([Basic auth helpers to be built: $BASIC_AUTH_HELPERS]) | |
1539 | AC_SUBST(BASIC_AUTH_HELPERS) | |
1540 | ||
1541 | AC_ARG_ENABLE(auth-ntlm, | |
1542 | AS_HELP_STRING([--enable-auth-ntlm="list of helpers"], | |
1543 | [Enable the NTLM authentication scheme, and build the specified helpers. | |
1544 | Not providing an explicit list of helpers will attempt build of | |
1545 | all possible helpers. Default is to do so. | |
1546 | To disable the NTLM authentication scheme, use --disable-auth-ntlm. | |
1547 | To enable but build no helpers, specify "none". | |
1548 | To see available helpers, see the helpers/ntlm_auth directory. ]),[ | |
1549 | ]) | |
1550 | if test "x$enable_auth_ntlm" = "x"; then | |
1551 | enable_auth_ntlm=$enable_auth | |
1552 | fi | |
1553 | #conflicts with global | |
1554 | if test "x$enable_auth_ntlm" != "xno" -a "x$enable_auth" = "xno" ; then | |
1555 | AC_MSG_ERROR([NTLM auth requested but auth disabled]) | |
1556 | fi | |
1557 | #define list of modules to build | |
1558 | if test "x$enable_auth_ntlm" = "xyes" ; then | |
1559 | SQUID_LOOK_FOR_MODULES([$srcdir/helpers/ntlm_auth],[enable_auth_ntlm]) | |
1560 | fi | |
1561 | #handle the "none" special case | |
1562 | if test "x$enable_auth_ntlm" = "xnone" ; then | |
1563 | enable_auth_ntlm="" | |
1564 | fi | |
1565 | NTLM_AUTH_HELPERS="" | |
1566 | enable_auth_ntlm="`echo $enable_auth_ntlm| sed -e 's/,/ /g;s/ */ /g'`" | |
1567 | if test "$enable_auth_ntlm" != "no" ; then | |
1568 | AUTH_MODULES="$AUTH_MODULES ntlm" | |
1569 | AC_DEFINE([HAVE_AUTH_MODULE_NTLM],1,[NTLM auth module is built]) | |
1570 | for helper in $enable_auth_ntlm ; do | |
1571 | dir="$srcdir/helpers/ntlm_auth/$helper" | |
1572 | if test -f $dir/config.test && sh $dir/config.test "$@"; then | |
1573 | NTLM_AUTH_HELPERS="$NTLM_AUTH_HELPERS $helper" | |
1574 | elif test -d $srcdir/helpers/ntlm_auth/$helper ; then | |
1575 | AC_MSG_NOTICE([NTLM auth helper $helper ... found but cannot be built]) | |
1576 | fi | |
1577 | done | |
1578 | fi | |
1579 | AC_MSG_NOTICE([NTLM auth helpers built: $NTLM_AUTH_HELPERS]) | |
1580 | AC_SUBST(NTLM_AUTH_HELPERS) | |
1581 | ||
1582 | AC_ARG_ENABLE(auth-negotiate, | |
1583 | AS_HELP_STRING([--enable-auth-negotiate="list of helpers"], | |
1584 | [Enable the Negotiate authentication scheme, and build the specified | |
1585 | helpers. | |
1586 | Not providing an explicit list of helpers will attempt build of | |
1587 | all possible helpers. Default is to do so. | |
1588 | To disable the Negotiate authentication scheme, | |
1589 | use --disable-auth-negotiate. | |
1590 | To enable but build no helpers, specify "none". | |
1591 | To see available helpers, see the helpers/negotiate_auth directory. ]),[ | |
1592 | #nothing to do, really | |
1593 | ]) | |
1594 | if test "x$enable_auth_negotiate" = "x"; then | |
1595 | enable_auth_negotiate=$enable_auth | |
1596 | fi | |
1597 | #conflicts with global | |
1598 | if test "x$enable_auth_negotiate" != "xno" -a "x$enable_auth" = "xno" ; then | |
1599 | AC_MSG_ERROR([Negotiate auth requested but auth disabled]) | |
1600 | fi | |
1601 | #define list of modules to build | |
1602 | if test "x$enable_auth_negotiate" = "xyes" ; then | |
1603 | SQUID_LOOK_FOR_MODULES([$srcdir/helpers/negotiate_auth],[enable_auth_negotiate]) | |
1604 | fi | |
1605 | #handle the "none" special case | |
1606 | if test "x$enable_auth_negotiate" = "xnone" ; then | |
1607 | enable_auth_negotiate="" | |
1608 | fi | |
1609 | NEGOTIATE_AUTH_HELPERS="" | |
1610 | enable_auth_negotiate="`echo $enable_auth_negotiate| sed -e 's/,/ /g;s/ */ /g'`" | |
1611 | if test "$enable_auth_negotiate" != "no" ; then | |
1612 | AUTH_MODULES="$AUTH_MODULES negotiate" | |
1613 | AC_DEFINE([HAVE_AUTH_MODULE_NEGOTIATE],1,[Negotiate auth module is built]) | |
1614 | for helper in $enable_auth_negotiate ; do | |
1615 | dir="$srcdir/helpers/negotiate_auth/$helper" | |
1616 | if test -f $dir/config.test && sh $dir/config.test "$@"; then | |
1617 | NEGOTIATE_AUTH_HELPERS="$NEGOTIATE_AUTH_HELPERS $helper" | |
1618 | elif test -d $srcdir/helpers/negotiate_auth/$helper ; then | |
1619 | AC_MSG_NOTICE([Negotiate auth helper $helper ... found but cannot be built]) | |
1620 | fi | |
1621 | done | |
1622 | fi | |
1623 | AC_MSG_NOTICE([Negotiate auth helpers built: $NEGOTIATE_AUTH_HELPERS]) | |
1624 | AC_SUBST(NEGOTIATE_AUTH_HELPERS) | |
1625 | ||
1626 | AC_ARG_ENABLE(auth-digest, | |
1627 | AS_HELP_STRING([--enable-auth-digest="list of helpers"], | |
1628 | [Enable the Digest authentication scheme, and build the specified helpers. | |
1629 | Not providing an explicit list of helpers will attempt build of | |
1630 | all possible helpers. Default is to do so. | |
1631 | To disable the Digest authentication scheme, use --disable-auth-digest. | |
1632 | To enable but build no helpers, specify "none". | |
1633 | To see available helpers, see the helpers/digest_auth directory. ]),[ | |
1634 | #nothing to do, really | |
1635 | ]) | |
1636 | if test "x$enable_auth_digest" = "x"; then | |
1637 | enable_auth_digest=$enable_auth | |
1638 | fi | |
1639 | #conflicts with global | |
1640 | if test "x$enable_auth_digest" != "xno" -a "x$enable_auth" = "xno" ; then | |
1641 | AC_MSG_ERROR([Digest auth requested but auth disabled]) | |
1642 | fi | |
1643 | #define list of modules to build | |
1644 | if test "x$enable_auth_digest" = "xyes" ; then | |
1645 | SQUID_LOOK_FOR_MODULES([$srcdir/helpers/digest_auth],[enable_auth_digest]) | |
1646 | fi | |
1647 | #handle the "none" special case | |
1648 | if test "x$enable_auth_digest" = "xnone" ; then | |
1649 | enable_auth_digest="" | |
1650 | fi | |
1651 | DIGEST_AUTH_HELPERS="" | |
1652 | enable_auth_digest="`echo $enable_auth_digest| sed -e 's/,/ /g;s/ */ /g'`" | |
1653 | if test "$enable_auth_digest" != "no" ; then | |
1654 | AUTH_MODULES="$AUTH_MODULES digest" | |
1655 | AC_DEFINE([HAVE_AUTH_MODULE_DIGEST],1,[Digest auth module is built]) | |
1656 | for helper in $enable_auth_digest ; do | |
1657 | dir="$srcdir/helpers/digest_auth/$helper" | |
1658 | if test -f $dir/config.test && sh $dir/config.test "$@"; then | |
1659 | DIGEST_AUTH_HELPERS="$DIGEST_AUTH_HELPERS $helper" | |
1660 | elif test -d $srcdir/helpers/digest_auth/$helper ; then | |
1661 | AC_MSG_NOTICE([Digest auth helper $helper ... found but cannot be built]) | |
1662 | fi | |
1663 | done | |
1664 | fi | |
1665 | AC_MSG_NOTICE([Digest auth helpers built: $DIGEST_AUTH_HELPERS]) | |
1666 | AC_SUBST(DIGEST_AUTH_HELPERS) | |
1667 | ||
1668 | dnl Authentication libraries to build | |
1669 | dnl This list will not be needed when each auth library has its own Makefile | |
1670 | dnl this is to be placed AFTER each auth module's handler | |
1671 | AUTH_LIBS_TO_BUILD= | |
1672 | for module in $AUTH_MODULES; do | |
1673 | AUTH_LIBS_TO_BUILD="$AUTH_LIBS_TO_BUILD lib${module}.la" | |
1674 | done | |
1675 | AC_SUBST(AUTH_MODULES) | |
1676 | AC_SUBST(AUTH_LIBS_TO_BUILD) | |
1677 | ||
1678 | dnl Select logging daemon helpers to build | |
1679 | squid_opt_logdaemon_helpers="auto" | |
1680 | AC_ARG_ENABLE(log-daemon-helpers, | |
1681 | AS_HELP_STRING([--enable-log-daemon-helpers="list of helpers"], | |
1682 | [This option selects which logging daemon helpers to | |
1683 | build and install as part of the normal build process | |
1684 | For a list of available helpers see the helpers/log_daemon | |
1685 | directory.]),[ | |
1686 | case "$enableval" in | |
1687 | yes) : ;; | |
1688 | no) squid_opt_logdaemon_helpers="" ;; | |
1689 | *) squid_opt_logdaemon_helpers="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" ;; | |
1690 | esac | |
1691 | ]) | |
1692 | if test "$squid_opt_logdaemon_helpers" = "auto" ; then | |
1693 | squid_opt_logdaemon_helpers="" | |
1694 | SQUID_LOOK_FOR_MODULES([$srcdir/helpers/log_daemon],[squid_opt_logdaemon_helpers]) | |
1695 | fi | |
1696 | for helper in $squid_opt_logdaemon_helpers ; do | |
1697 | dir="$srcdir/helpers/log_daemon/$helper" | |
1698 | if test -f $dir/config.test && sh $dir/config.test "$@"; then | |
1699 | LOG_DAEMON_HELPERS="$LOG_DAEMON_HELPERS $helper" | |
1700 | elif test -d $srcdir/helpers/log_daemon/$helper ; then | |
1701 | AC_MSG_NOTICE([Log daemon helper $helper ... found but cannot be built]) | |
1702 | fi | |
1703 | done | |
1704 | AC_MSG_NOTICE([Log daemon helpers built: $LOG_DAEMON_HELPERS]) | |
1705 | AC_SUBST(LOG_DAEMON_HELPERS) | |
1706 | ||
1707 | dnl | |
1708 | dnl Check Kerberos/GSSAPI/SPNEGO | |
1709 | dnl | |
1710 | SQUID_STATE_SAVE([krbsave]) | |
1711 | ||
1712 | AC_ARG_WITH(krb5-config, | |
1713 | [ --with-krb5-config=PATH specify path to krb5-config @<:@default=detect@:>@], | |
1714 | [ | |
1715 | case "$withval" in | |
1716 | yes) unset krb5confpath ;; | |
1717 | no) krb5confpath=no ;; | |
1718 | *) krb5confpath=$withval ;; | |
1719 | esac | |
1720 | ]) | |
1721 | if test x"$krb5confpath" != xno; then | |
1722 | if test x"$krb5confpath" != x; then | |
1723 | if ! test -x "$krb5confpath"; then | |
1724 | AC_MSG_WARN([krb5-config '$krb5confpath' not executable, ignoring]) | |
1725 | AC_CHECK_PROG(ac_krb5_config, krb5-config, yes, no) | |
1726 | krb5confpath=krb5-config | |
1727 | fi | |
1728 | krb5_config_path=`dirname $krb5confpath` | |
1729 | AC_CHECK_PROG(ac_krb5_config, krb5-config, yes, no, $krb5_config_path) | |
1730 | else | |
1731 | AC_CHECK_PROG(ac_krb5_config,krb5-config,yes,no) | |
1732 | krb5confpath=krb5-config | |
1733 | fi | |
1734 | fi | |
1735 | if test "$ac_krb5_config" = "yes" ; then | |
1736 | ac_heimdal="`$krb5confpath --version 2>/dev/null | grep -i heimdal`" | |
1737 | ac_solaris="`$krb5confpath --version 2>/dev/null | grep -i solaris`" | |
1738 | if test "x$ac_heimdal" != "x" ; then | |
1739 | AC_DEFINE(HAVE_HEIMDAL_KERBEROS,1,[Define to 1 if you have Heimdal Kerberos]) | |
1740 | else | |
1741 | AC_DEFINE(HAVE_MIT_KERBEROS,1,[Define to 1 if you have MIT Kerberos]) | |
1742 | fi | |
1743 | if test "$ac_solaris" != "" ; then | |
1744 | KRB5INCS="`$krb5confpath --cflags krb5 2>/dev/null`" | |
1745 | KRB5LIBS="`$krb5confpath --libs krb5 2>/dev/null`" | |
1746 | KRB5INCS="-I/usr/include/gssapi $KRB5INCS" | |
1747 | KRB5LIBS="-L/usr/lib -R/usr/lib -lgss -lresolv -lsocket -lnsl $KRB5LIBS" | |
1748 | else | |
1749 | KRB5INCS="`$krb5confpath --cflags krb5 2>/dev/null`" | |
1750 | KRB5LIBS="`$krb5confpath --libs krb5 2>/dev/null`" | |
1751 | KRB5INCS="`$krb5confpath --cflags gssapi 2>/dev/null` $KRB5INCS" | |
1752 | KRB5LIBS="`$krb5confpath --libs gssapi 2>/dev/null` $KRB5LIBS" | |
1753 | fi | |
1754 | CPPFLAGS="$CPPFLAGS $KRB5INCS" | |
1755 | LIBS="$LIBS $KRB5LIBS" | |
1756 | AC_CHECK_HEADERS(gssapi.h gssapi/gssapi.h gssapi/gssapi_krb5.h) | |
1757 | if test "x$ac_heimdal" == "x" ; then | |
1758 | AC_CHECK_HEADERS(gssapi/gssapi_generic.h) | |
1759 | AC_CHECK_HEADERS(profile.h) | |
1760 | fi | |
1761 | AC_CHECK_HEADERS(krb5.h com_err.h et/com_err.h) | |
1762 | ||
1763 | SQUID_CHECK_KRB5_SOLARIS_BROKEN_KRB5_H | |
1764 | if test x"$squid_cv_broken_krb5_h" = x"yes"; then | |
1765 | AC_DEFINE(HAVE_BROKEN_SOLARIS_KRB5_H, 1, [Define to 1 if krb5.h is broken for C++]) | |
1766 | fi | |
1767 | ||
1768 | ac_com_error_message=no | |
1769 | if test "x$ac_cv_header_com_err_h" == "xyes" ; then | |
1770 | AC_EGREP_HEADER(error_message,com_err.h,ac_com_error_message=yes) | |
1771 | elif test "x$ac_cv_header_et_com_err_h" == "xyes" ; then | |
1772 | AC_EGREP_HEADER(error_message,et/com_err.h,ac_com_error_message=yes) | |
1773 | fi | |
1774 | ||
1775 | SQUID_CHECK_MAX_SKEW_IN_KRB5_CONTEXT | |
1776 | if test x"$squid_cv_max_skew_context" = x"yes"; then | |
1777 | AC_DEFINE(HAVE_MAX_SKEW_IN_KRB5_CONTEXT, 1, [Define to 1 if max_skew in struct krb5_context]) | |
1778 | fi | |
1779 | ||
1780 | if test `echo $KRB5LIBS | grep -c com_err` -ne 0 -a "x$ac_com_error_message" == "xyes" ; then | |
1781 | AC_CHECK_LIB(com_err,error_message, | |
1782 | AC_DEFINE(HAVE_ERROR_MESSAGE,1, | |
1783 | [Define to 1 if you have error_message]),) | |
1784 | elif test "x$ac_com_error_message" == "xyes" ; then | |
1785 | AC_CHECK_LIB(krb5,error_message, | |
1786 | AC_DEFINE(HAVE_ERROR_MESSAGE,1, | |
1787 | [Define to 1 if you have error_message]),) | |
1788 | fi | |
1789 | AC_CHECK_LIB(krb5,krb5_get_err_text, | |
1790 | AC_DEFINE(HAVE_KRB5_GET_ERR_TEXT,1, | |
1791 | [Define to 1 if you have krb5_get_err_text]),) | |
1792 | AC_CHECK_LIB(krb5,krb5_get_error_message, | |
1793 | AC_DEFINE(HAVE_KRB5_GET_ERROR_MESSAGE,1, | |
1794 | [Define to 1 if you have krb5_get_error_message]),) | |
1795 | AC_CHECK_LIB(krb5,krb5_kt_free_entry, | |
1796 | AC_DEFINE(HAVE_KRB5_KT_FREE_ENTRY,1, | |
1797 | [Define to 1 if you have krb5_kt_free_entry]),) | |
1798 | AC_CHECK_LIB(krb5,krb5_get_init_creds_keytab, | |
1799 | AC_DEFINE(HAVE_GET_INIT_CREDS_KEYTAB,1, | |
1800 | [Define to 1 if you have krb5_get_init_creds_keytab]),) | |
1801 | AC_CHECK_LIB(krb5,krb5_get_max_time_skew, | |
1802 | AC_DEFINE(HAVE_KRB5_GET_MAX_TIME_SKEW,1, | |
1803 | [Define to 1 if you have krb5_get_max_time_skew]),) | |
1804 | AC_CHECK_LIB(krb5,krb5_get_profile, | |
1805 | AC_DEFINE(HAVE_KRB5_GET_PROFILE,1, | |
1806 | [Define to 1 if you have krb5_get_profile]),) | |
1807 | AC_CHECK_LIB(krb5,profile_get_integer, | |
1808 | AC_DEFINE(HAVE_PROFILE_GET_INTEGER,1, | |
1809 | [Define to 1 if you have profile_get_integer]),) | |
1810 | AC_CHECK_LIB(krb5,profile_release, | |
1811 | AC_DEFINE(HAVE_PROFILE_RELEASE,1, | |
1812 | [Define to 1 if you have profile_release]),) | |
1813 | ||
1814 | SQUID_CHECK_KRB5_CONTEXT_MEMORY_CACHE | |
1815 | if test "$squid_cv_memory_cache" = "yes" ; then | |
1816 | AC_DEFINE(HAVE_KRB5_MEMORY_CACHE,1, [Define to 1 if you have MEMORY: cache support]) | |
1817 | fi | |
1818 | ||
1819 | SQUID_CHECK_WORKING_GSSAPI | |
1820 | if test "$squid_cv_working_gssapi" = "yes" ; then | |
1821 | AC_DEFINE(HAVE_GSSAPI, 1, [GSSAPI support]) | |
1822 | fi | |
1823 | ||
1824 | SQUID_CHECK_SPNEGO_SUPPORT | |
1825 | if test "$squid_cv_have_spnego" = "yes" ; then | |
1826 | AC_DEFINE(HAVE_SPNEGO,1, [Define to 1 if you have SPNEGO support]) | |
1827 | fi | |
1828 | ||
1829 | SQUID_CHECK_WORKING_KRB5 | |
1830 | if test "$squid_cv_working_krb5" = "yes" ; then | |
1831 | AC_DEFINE(HAVE_KRB5, 1, [KRB5 support]) | |
1832 | fi | |
1833 | ||
1834 | AC_SUBST(KRB5INCS) | |
1835 | AC_SUBST(KRB5LIBS) | |
1836 | fi | |
1837 | SQUID_STATE_ROLLBACK([krbsave]) | |
1838 | AM_CONDITIONAL(HAVE_SPNEGO, test x"$squid_cv_have_spnego" = x"yes" ) | |
1839 | ||
1840 | dnl Enable "NTLM fail open" | |
1841 | AC_ARG_ENABLE(ntlm-fail-open, | |
1842 | AS_HELP_STRING([--enable-ntlm-fail-open], | |
1843 | [Enable NTLM fail open, where a helper that fails one of the | |
1844 | Authentication steps can allow squid to still authenticate | |
1845 | the user. This has security implications, and is deprecated]), | |
1846 | [ | |
1847 | SQUID_YESNO([$enableval],[--enable-ntlm-fail-open takes no argument]) | |
1848 | ]) | |
1849 | SQUID_DEFINE_BOOL(NTLM_FAIL_OPEN,${enable_ntlm_fail_open:=no}, | |
1850 | [Define if NTLM is allowed to fail gracefully when a helper has problems.]) | |
1851 | AC_MSG_NOTICE([ntlm-fail-open enabled: $enable_ntlm_fail_open]) | |
1852 | ||
1853 | AC_ARG_ENABLE(external-acl-helpers, | |
1854 | AS_HELP_STRING([--enable-external-acl-helpers="list of helpers"], | |
1855 | [Enable external_acl helpers support and thelpers themselves. | |
1856 | Default is to build all buildable helpers and enable support. | |
1857 | To disable support, use --disable-external-acl-helpers. | |
1858 | To build no helpers, specify "none". | |
1859 | To see available helpers, see the helpers/external_acl | |
1860 | directory]), [ | |
1861 | #nothing to do, really | |
1862 | ]) | |
1863 | if test "x${enable_external_acl_helpers:=yes}" = "xyes" ;then | |
1864 | SQUID_LOOK_FOR_MODULES([$srcdir/helpers/external_acl], | |
1865 | [enable_external_acl_helpers]) | |
1866 | fi | |
1867 | if test "x$enable_external_acl_helpers" = "xnone" ; then | |
1868 | enable_external_acl_helpers="" | |
1869 | fi | |
1870 | EXTERNAL_ACL_HELPERS="" | |
1871 | enable_external_acl_helpers="`echo $enable_external_acl_helpers| sed -e 's/,/ /g;s/ */ /g'`" | |
1872 | if test "x$enable_external_acl_helpers" != "xno" ; then | |
1873 | for helper in $enable_external_acl_helpers ; do | |
1874 | dir="$srcdir/helpers/external_acl/$helper" | |
1875 | if test -f $dir/config.test && sh $dir/config.test "$@"; then | |
1876 | EXTERNAL_ACL_HELPERS="$EXTERNAL_ACL_HELPERS $helper" | |
1877 | else | |
1878 | AC_MSG_NOTICE([external acl helper $helper ... found but cannot be built]) | |
1879 | fi | |
1880 | done | |
1881 | fi | |
1882 | AC_MSG_NOTICE([External acl helpers built: $EXTERNAL_ACL_HELPERS]) | |
1883 | AC_SUBST(EXTERNAL_ACL_HELPERS) | |
1884 | ||
1885 | ||
1886 | ||
1887 | dnl Select url_rewrite helpers to build | |
1888 | URL_REWRITE_HELPERS=all | |
1889 | AC_ARG_ENABLE(url-rewrite-helpers, | |
1890 | AC_HELP_STRING([--enable-url-rewrite-helpers="list of helpers"], | |
1891 | [This option selects which url_rewrite helpers to | |
1892 | build and install as part of the normal build | |
1893 | process. For a list of available helpers see the | |
1894 | helpers/url_rewrite directory.]), | |
1895 | [ case "$enableval" in | |
1896 | yes) | |
1897 | URL_REWRITE_HELPERS=all | |
1898 | ;; | |
1899 | no) | |
1900 | URL_REWRITE_HELPERS="" | |
1901 | ;; | |
1902 | *) | |
1903 | URL_REWRITE_HELPERS="`echo $enableval| sed -e 's/,/ /g;s/ */ /g'`" | |
1904 | ;; | |
1905 | esac | |
1906 | ]) | |
1907 | if test "$URL_REWRITE_HELPERS" = "all" ; then | |
1908 | URL_REWRITE_HELPERS="" | |
1909 | for dir in $srcdir/helpers/url_rewrite/*; do | |
1910 | helper="`basename $dir`" | |
1911 | if test -f $dir/config.test && sh $dir/config.test "$@"; then | |
1912 | URL_REWRITE_HELPERS="$URL_REWRITE_HELPERS $helper" | |
1913 | elif test -d $srcdir/helpers/url_rewrite/$helper ; then | |
1914 | AC_MSG_NOTICE([URL re-write helper $helper ... found but cannot be built]) | |
1915 | fi | |
1916 | done | |
1917 | fi | |
1918 | if test -n "$URL_REWRITE_HELPERS"; then | |
1919 | for helper in $URL_REWRITE_HELPERS; do | |
1920 | if test -f $srcdir/helpers/url_rewrite/$helper/Makefile.in; then | |
1921 | : | |
1922 | else | |
1923 | AC_MSG_ERROR(url_rewrite helper $helper does not exist) | |
1924 | fi | |
1925 | done | |
1926 | AC_MSG_NOTICE([url_rewrite helpers built: $URL_REWRITE_HELPERS]) | |
1927 | fi | |
1928 | AC_SUBST(URL_REWRITE_HELPERS) | |
1929 | ||
1930 | ||
1931 | AC_ARG_WITH(valgrind-debug, | |
1932 | AS_HELP_STRING([--with-valgrind-debug], | |
1933 | [Include debug instrumentation for use with valgrind]), | |
1934 | [ case $withval in | |
1935 | yes) | |
1936 | valgrind=1 | |
1937 | ;; | |
1938 | no) | |
1939 | valgrind= | |
1940 | ;; | |
1941 | *) | |
1942 | CPPFLAGS="$CPPFLAGS -I${enableval}/include" | |
1943 | valgrind=1 | |
1944 | ;; | |
1945 | esac | |
1946 | if test $valgrind; then | |
1947 | AC_CHECK_HEADERS(valgrind/memcheck.h, | |
1948 | [ AC_DEFINE(WITH_VALGRIND, 1, [Valgrind memory debugger support]) | |
1949 | AC_MSG_NOTICE([Valgrind debug support enabled]) ], | |
1950 | [ AC_MSG_WARN([Valgrind header not found. Valgrind support disabled.]) ] | |
1951 | ) | |
1952 | fi | |
1953 | ]) | |
1954 | ||
1955 | dnl Disable "memPools" code | |
1956 | #AC_ARG_ENABLE(chunkedmempools, | |
1957 | # AS_HELP_STRING([--enable-chunkedmempools], | |
1958 | # [Enable experimental chunked memPools. Note that this option | |
1959 | # simply sets the default behaviour. Specific classes can override this | |
1960 | # at runtime, and only lib/MemPool.c needs to be altered | |
1961 | # to change the squid-wide default for all classes.]), [ | |
1962 | #SQUID_YESNO([$enableval], | |
1963 | # [--enable-chunkedmempools option takes no arguments]) | |
1964 | #]) | |
1965 | SQUID_DEFINE_BOOL(USE_CHUNKEDMEMPOOLS,${enable_chunkedmempools:=no}, | |
1966 | [Enable chunked Memory Pools support (experimental)]) | |
1967 | #AC_MSG_NOTICE([Chunked MemPools enabled: $enable_chunkedmempools]) | |
1968 | ||
1969 | dnl Enable WIN32 Service compile mode | |
1970 | AC_ARG_ENABLE(win32-service, | |
1971 | AS_HELP_STRING([--enable-win32-service], | |
1972 | [Compile Squid as a WIN32 Service. | |
1973 | Works only on MS-Windows platforms]), | |
1974 | [ if test "$enableval" = "yes" ; then | |
1975 | AC_MSG_NOTICE([Enabling WIN32 run service mode]) | |
1976 | AC_DEFINE(USE_WIN32_SERVICE,1, | |
1977 | [Define Windows NT & Windows 2000 run service mode]) | |
1978 | fi | |
1979 | ]) | |
1980 | ||
1981 | ||
1982 | # Check for Cyrus SASL | |
1983 | if test "$squid_require_sasl" = "yes"; then | |
1984 | AC_CHECK_HEADERS(sasl/sasl.h sasl.h) | |
1985 | AC_CHECK_LIB(sasl2,sasl_errstring,[LIBSASL="-lsasl2"],[ | |
1986 | AC_CHECK_LIB(sasl,sasl_errstring,[LIBSASL="-lsasl"], [ | |
1987 | AC_MSG_ERROR(Neither SASL nor SASL2 found) | |
1988 | ]) | |
1989 | ]) | |
1990 | AC_SUBST(LIBSASL) | |
1991 | fi | |
1992 | ||
1993 | # Disable "unlinkd" code | |
1994 | AC_ARG_ENABLE(unlinkd, | |
1995 | AS_HELP_STRING([--disable-unlinkd],[Do not use unlinkd]), [ | |
1996 | SQUID_YESNO([$enableval], | |
1997 | [unrecognized argument to --disable-unlinkd: $enableval]) | |
1998 | ]) | |
1999 | SQUID_DEFINE_BOOL([USE_UNLINKD],${enable_unlinkd:=yes}, | |
2000 | [Enable useage of unlinkd]) | |
2001 | AM_CONDITIONAL(ENABLE_UNLINKD,test "$enable_unlinkd" = "yes") | |
2002 | AC_MSG_NOTICE([unlinkd enabled: $enable_unlinkd]) | |
2003 | ||
2004 | # Enable backtraces on fatal errors | |
2005 | AC_ARG_ENABLE(stacktraces, | |
2006 | AS_HELP_STRING([--enable-stacktraces], | |
2007 | [Enable automatic call backtrace on fatal errors]), [ | |
2008 | SQUID_YESNO([$enableval], | |
2009 | [unrecognized argument to --enable-stacktraces: $enableval]) | |
2010 | ]) | |
2011 | SQUID_DEFINE_BOOL([PRINT_STACK_TRACE],${enable_stacktraces:=no}, | |
2012 | [Print stack traces on fatal errors]) | |
2013 | AC_MSG_NOTICE([Automatically print stack trace on fatal errors: $enable_stacktraces]) | |
2014 | ||
2015 | ||
2016 | # CPU Profiling options handling | |
2017 | AC_ARG_ENABLE(cpu-profiling, | |
2018 | AS_HELP_STRING([--enable-cpu-profiling], | |
2019 | [Enable instrumentation to try and understand how CPU power | |
2020 | is spent by squid, by enabling specific probes in selected | |
2021 | functions. | |
2022 | New probes can only be added by modifying the source code. | |
2023 | It is meant to help developers in optimizing performance | |
2024 | of Squid internal functions. | |
2025 | If you are not developer you should not enable this, | |
2026 | as it slows squid down somewhat. | |
2027 | See lib/Profiler.c for more details.]), [ | |
2028 | SQUID_YESNO([$enableval], | |
2029 | [unrecognized argument to --enable-cpu-profiling: $enableval]) | |
2030 | ]) | |
2031 | SQUID_DEFINE_BOOL([USE_XPROF_STATS],${enable_cpu_profiling:=no}, | |
2032 | [Define to enable CPU profiling within Squid]) | |
2033 | AM_CONDITIONAL(ENABLE_XPROF_STATS, | |
2034 | test $enable_cpu_profiling = "yes") | |
2035 | AC_MSG_NOTICE([CPU profiling enabled: $enable_cpu_profiling]) | |
2036 | ||
2037 | # Enable X-Accelerator-Vary for Vary support within an accelerator setup | |
2038 | AC_ARG_ENABLE(x-accelerator-vary, | |
2039 | AS_HELP_STRING([--enable-x-accelerator-vary], | |
2040 | [Enable support for the X-Accelerator-Vary | |
2041 | HTTP header. Can be used to indicate | |
2042 | variance within an accelerator setup. | |
2043 | Typically used together with other code | |
2044 | that adds custom HTTP headers to the requests.]), [ | |
2045 | SQUID_YESNO([$enableval], | |
2046 | [unrecognized argument to --enable-x-accelerator-vary: $enableval]) | |
2047 | ]) | |
2048 | SQUID_DEFINE_BOOL([X_ACCELERATOR_VARY],${enable_x_accelerator_vary:=no}, | |
2049 | [Enable support for the X-Accelerator-Vary HTTP header]) | |
2050 | AC_MSG_NOTICE([X-Accelerator-Vary support enabled: $enable_x_accelerator_vary]) | |
2051 | ||
2052 | ||
2053 | AC_ARG_ENABLE(zph-qos, | |
2054 | AS_HELP_STRING([--enable-zph-qos],[Enable ZPH QOS support]), [ | |
2055 | SQUID_YESNO([$enableval], | |
2056 | [unrecognized argument to --enable-zph-qos: $enableval]) | |
2057 | ]) | |
2058 | SQUID_DEFINE_BOOL([USE_ZPH_QOS],${enable_zph_qos:=no}, | |
2059 | [Enable Zero Penalty Hit QOS. When set, Squid will alter the | |
2060 | TOS field of HIT responses to help policing network traffic]) | |
2061 | AC_MSG_NOTICE([ZPH QOS enabled: $enable_zph_qos]) | |
2062 | ||
2063 | dnl --with-maxfd present for compatibility with Squid-2. | |
2064 | dnl undocumented in ./configure --help to encourage using the Squid-3 directive. | |
2065 | AC_ARG_WITH(maxfd,, | |
2066 | [ | |
2067 | case ${withval} in | |
2068 | [[0-9]]*) | |
2069 | squid_filedescriptors_num=$withval | |
2070 | ;; | |
2071 | *) | |
2072 | AC_MSG_ERROR(--with-maxfd expects a numeric argument) | |
2073 | ;; | |
2074 | esac | |
2075 | ]) | |
2076 | AC_ARG_WITH(filedescriptors, | |
2077 | AS_HELP_STRING([--with-filedescriptors=NUMBER],[Force squid to support NUMBER filedescriptors]), | |
2078 | [ | |
2079 | case ${withval} in | |
2080 | [[0-9]]*) | |
2081 | squid_filedescriptors_num=$withval | |
2082 | ;; | |
2083 | *) | |
2084 | AC_MSG_ERROR(--with-filedescriptors expects a numeric argument) | |
2085 | ;; | |
2086 | esac | |
2087 | ]) | |
2088 | ||
2089 | if $CPPUNITCONFIG --help >/dev/null; then | |
2090 | squid_cv_cppunit_version="`$CPPUNITCONFIG --version`" | |
2091 | AC_MSG_NOTICE([using system installed cppunit version $squid_cv_cppunit_version]) | |
2092 | unset squid_cv_cppunit_version | |
2093 | SQUID_CPPUNIT_LIBS="`$CPPUNITCONFIG --libs`" | |
2094 | SQUID_CPPUNIT_LA='' | |
2095 | SQUID_CPPUNIT_INC="`$CPPUNITCONFIG --cflags`" | |
2096 | else | |
2097 | AC_MSG_WARN([cppunit does not appear to be installed. squid does not require this, but code testing with 'make check' will fail.]) | |
2098 | SQUID_CPPUNIT_LA='' | |
2099 | SQUID_CPPUNIT_LIBS='' | |
2100 | SQUID_CPPUNIT_INC='' | |
2101 | fi | |
2102 | ||
2103 | AC_ARG_WITH(cppunit-basedir, | |
2104 | AS_HELP_STRING([--with-cppunit-basedir=PATH],[Path where the cppunit headers are libraries are found | |
2105 | for unit testing.]), | |
2106 | [ if test -f $withval/include/cppunit/TestCase.h; then | |
2107 | AC_MSG_NOTICE([Using cppunit includes from $withval]) | |
2108 | SQUID_CPPUNIT_INC="-I${withval}/include" | |
2109 | else | |
2110 | AC_MSG_ERROR(Cannot find cppunit at $withval) | |
2111 | fi | |
2112 | if test -f $withval/lib/libcppunit.la; then | |
2113 | AC_MSG_NOTICE([Using cppunit lib from $withval]) | |
2114 | SQUID_CPPUNIT_LA="${withval}/lib/libcppunit.la" | |
2115 | SQUID_CPPUNIT_LIBS='$(SQUID_CPPUNIT_LA)' | |
2116 | else | |
2117 | AC_MSG_ERROR(Cannot find cppunit at $withval) | |
2118 | fi | |
2119 | ]) | |
2120 | AC_SUBST(SQUID_CPPUNIT_LIBS) | |
2121 | AC_SUBST(SQUID_CPPUNIT_LA) | |
2122 | AC_SUBST(SQUID_CPPUNIT_INC) | |
2123 | ||
2124 | # Force some compilers to use ANSI features | |
2125 | # | |
2126 | case "$host" in | |
2127 | alpha-dec-osf*) | |
2128 | if test "$ac_cv_prog_CC" = "cc" ; then | |
2129 | AC_MSG_NOTICE([adding '-std1' to cc args for $host]) | |
2130 | CC="cc -std1"; | |
2131 | ac_cv_prog_CC="$CC" | |
2132 | fi | |
2133 | ;; | |
2134 | *-hp-hpux*) | |
2135 | if test "$ac_cv_prog_CC" = "cc" ; then | |
2136 | AC_MSG_NOTICE([adding '-Ae' to cc args for $host]) | |
2137 | CC="cc -Ae"; | |
2138 | ac_cv_prog_CC="$CC" | |
2139 | fi | |
2140 | ;; | |
2141 | esac | |
2142 | ||
2143 | ||
2144 | dnl automake handles this AC_PATH_PROG(MAKEDEPEND, makedepend, $TRUE) | |
2145 | ||
2146 | case "$host" in | |
2147 | *-hp-hpux*) | |
2148 | AC_MSG_NOTICE([Disabling ranlib for HP-UX...]) | |
2149 | RANLIB=":" | |
2150 | ;; | |
2151 | esac | |
2152 | ||
2153 | dnl Check for headers | |
2154 | AC_HEADER_DIRENT | |
2155 | AC_HEADER_STDC | |
2156 | ||
2157 | AC_CHECK_HEADERS( \ | |
2158 | arpa/inet.h \ | |
2159 | arpa/nameser.h \ | |
2160 | assert.h \ | |
2161 | bstring.h \ | |
2162 | cassert \ | |
2163 | crypt.h \ | |
2164 | cstring \ | |
2165 | ctype.h \ | |
2166 | errno.h \ | |
2167 | execinfo.h \ | |
2168 | fcntl.h \ | |
2169 | fnmatch.h \ | |
2170 | getopt.h \ | |
2171 | glob.h \ | |
2172 | gnumalloc.h \ | |
2173 | grp.h \ | |
2174 | iosfwd \ | |
2175 | iomanip \ | |
2176 | iostream \ | |
2177 | ip_compat.h \ | |
2178 | ip_fil_compat.h \ | |
2179 | ip_fil.h \ | |
2180 | ip_nat.h \ | |
2181 | ipl.h \ | |
2182 | libc.h \ | |
2183 | limits.h \ | |
2184 | linux/posix_types.h \ | |
2185 | linux/types.h \ | |
2186 | machine/byte_swap.h \ | |
2187 | malloc.h \ | |
2188 | map \ | |
2189 | math.h \ | |
2190 | memory.h \ | |
2191 | mount.h \ | |
2192 | netdb.h \ | |
2193 | netinet/in.h \ | |
2194 | netinet/in_systm.h \ | |
2195 | netinet/ip_fil_compat.h \ | |
2196 | openssl/err.h \ | |
2197 | openssl/md5.h \ | |
2198 | openssl/ssl.h \ | |
2199 | openssl/x509v3.h \ | |
2200 | netinet/tcp.h \ | |
2201 | openssl/engine.h \ | |
2202 | ostream \ | |
2203 | paths.h \ | |
2204 | poll.h \ | |
2205 | pwd.h \ | |
2206 | shadow.h \ | |
2207 | regex.h \ | |
2208 | sched.h \ | |
2209 | security/pam_appl.h \ | |
2210 | signal.h \ | |
2211 | sstream \ | |
2212 | stdarg.h \ | |
2213 | stddef.h \ | |
2214 | stdexcept \ | |
2215 | stdio.h \ | |
2216 | stdlib.h \ | |
2217 | string \ | |
2218 | string.h \ | |
2219 | strings.h \ | |
2220 | sys/bitypes.h \ | |
2221 | sys/bswap.h \ | |
2222 | sys/endian.h \ | |
2223 | sys/file.h \ | |
2224 | sys/ioctl.h \ | |
2225 | sys/param.h \ | |
2226 | sys/prctl.h \ | |
2227 | sys/md5.h \ | |
2228 | sys/msg.h \ | |
2229 | sys/resource.h \ | |
2230 | sys/select.h\ | |
2231 | sys/socket.h \ | |
2232 | sys/stat.h \ | |
2233 | sys/statvfs.h \ | |
2234 | syscall.h \ | |
2235 | sys/syscall.h \ | |
2236 | sys/time.h \ | |
2237 | sys/types.h \ | |
2238 | sys/un.h \ | |
2239 | sys/vfs.h \ | |
2240 | sys/wait.h \ | |
2241 | syslog.h \ | |
2242 | time.h \ | |
2243 | unistd.h \ | |
2244 | utime.h \ | |
2245 | varargs.h \ | |
2246 | byteswap.h \ | |
2247 | glib.h \ | |
2248 | stdint.h \ | |
2249 | inttypes.h \ | |
2250 | grp.h \ | |
2251 | db.h \ | |
2252 | db_185.h | |
2253 | ) | |
2254 | ||
2255 | CHECK_STRUCT_PAM_CONV | |
2256 | ||
2257 | AC_CHECK_HEADERS( | |
2258 | linux/netfilter_ipv4.h | |
2259 | ,,, | |
2260 | SQUID_DEFAULT_INCLUDES | |
2261 | #if HAVE_LIMITS_H | |
2262 | #include <limits.h> | |
2263 | #endif | |
2264 | /* Netfilter ip(6)tables v1.4.0 has broken headers */ | |
2265 | #if HAVE_NETINET_IN_H | |
2266 | #include <netinet/in.h> | |
2267 | #endif | |
2268 | ) | |
2269 | ||
2270 | dnl *BSD dont include the depenencies for all their net/ and netinet/ files | |
2271 | dnl We must include a few basic type headers for them to work. | |
2272 | AC_CHECK_HEADERS( \ | |
2273 | net/if.h \ | |
2274 | netinet/if_ether.h\ | |
2275 | netinet/icmp6.h \ | |
2276 | netinet/in.h \ | |
2277 | netinet/ip.h \ | |
2278 | netinet/ip6.h \ | |
2279 | netinet/ip_compat.h\ | |
2280 | netinet/ip_fil_compat.h\ | |
2281 | netinet/ip_fil.h\ | |
2282 | netinet/ip_icmp.h \ | |
2283 | netinet/ipl.h \ | |
2284 | netinet/ip_nat.h\ | |
2285 | net/pf/pfvar.h \ | |
2286 | net/pfvar.h \ | |
2287 | sys/mount.h\ | |
2288 | resolv.h \ | |
2289 | ,,, | |
2290 | SQUID_BSDNET_INCLUDES) | |
2291 | ||
2292 | AC_C_CONST | |
2293 | AC_C_BIGENDIAN | |
2294 | ||
2295 | AC_STRUCT_TM | |
2296 | AC_CHECK_MEMBERS([struct tm.tm_gmtoff],,,[ | |
2297 | #if TM_IN_SYS_TIME | |
2298 | #if HAVE_SYS_TIME_H | |
2299 | #include <sys/time.h> | |
2300 | #endif | |
2301 | #elif HAVE_TIME_H | |
2302 | #include <time.h> | |
2303 | #endif | |
2304 | ]) | |
2305 | ||
2306 | AC_CHECK_TYPE(struct mallinfo,AC_DEFINE(HAVE_STRUCT_MALLINFO,1,[The system provides struct mallinfo]),,[ | |
2307 | #if HAVE_SYS_TYPES_H | |
2308 | #include <sys/types.h> | |
2309 | #endif | |
2310 | #if HAVE_MALLOC_H | |
2311 | #include <malloc.h> | |
2312 | #endif]) | |
2313 | ||
2314 | AC_CHECK_MEMBERS([struct mallinfo.mxfast],,,[ | |
2315 | #if HAVE_SYS_TYPES_H | |
2316 | #include <sys/types.h> | |
2317 | #endif | |
2318 | #if HAVE_MALLOC_H | |
2319 | #include <malloc.h> | |
2320 | #endif]) | |
2321 | ||
2322 | dnl Override rusage() detect on MinGW because is emulated in source code | |
2323 | case "$host_os" in | |
2324 | mingw|mingw32) | |
2325 | AC_DEFINE(HAVE_STRUCT_RUSAGE) | |
2326 | ac_cv_func_getrusage='yes' | |
2327 | AC_MSG_NOTICE([Using own rusage on Windows.]) | |
2328 | ;; | |
2329 | *) | |
2330 | AC_CHECK_TYPE(struct rusage,AC_DEFINE(HAVE_STRUCT_RUSAGE,1,[The system provides struct rusage]),,[ | |
2331 | #if HAVE_SYS_TIME_H | |
2332 | #include <sys/time.h> | |
2333 | #endif | |
2334 | #if HAVE_SYS_RESOURCE_H | |
2335 | #include <sys/resource.h> | |
2336 | #endif]) | |
2337 | ;; | |
2338 | esac | |
2339 | ||
2340 | AC_CHECK_MEMBERS([struct iphdr.ip_hl],,,[ | |
2341 | #if HAVE_SYS_TYPES_H | |
2342 | #include <sys/types.h> | |
2343 | #endif | |
2344 | #include <netinet/in.h> | |
2345 | #include <netinet/in_systm.h> | |
2346 | #include <netinet/ip.h> | |
2347 | #if defined (__linux__) || defined (__CYGWIN__) | |
2348 | #define ip_hl ihl | |
2349 | #endif | |
2350 | #ifndef __linux__ | |
2351 | #ifndef __CYGWIN__ | |
2352 | #define iphdr ip | |
2353 | #endif | |
2354 | #endif]) | |
2355 | ||
2356 | dnl Check for typedefs | |
2357 | AC_CHECK_SIZEOF(void *) | |
2358 | ||
2359 | dnl 8 bit integers - int8_t | |
2360 | dnl if this is defined we trust it to be 8 bits | |
2361 | AC_CHECK_TYPE(int8_t,[ | |
2362 | AC_CHECK_SIZEOF(int8_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2363 | AC_DEFINE(HAVE_INT8_T,1,[int8_t is defined in system headers]) | |
2364 | ],,SQUID_DEFAULT_INCLUDES) | |
2365 | ||
2366 | dnl fallback #1 | |
2367 | AC_CHECK_TYPE(char,[ | |
2368 | AC_CHECK_SIZEOF(char,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2369 | AC_DEFINE(HAVE_CHAR,1,[char is defined in system headers]) | |
2370 | ],,SQUID_DEFAULT_INCLUDES) | |
2371 | ||
2372 | dnl unsigned 8 bit ints - u_int8_t | |
2373 | dnl if this is defined we trust it to be 8 bits | |
2374 | AC_CHECK_TYPE(u_int8_t,[ | |
2375 | AC_CHECK_SIZEOF(u_int8_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2376 | AC_DEFINE(HAVE_U_INT8_T,1,[u_int8_t is defined in system headers]) | |
2377 | ],,SQUID_DEFAULT_INCLUDES) | |
2378 | ||
2379 | dnl fallback #1 | |
2380 | dnl if this is defined we trust it to be 8 bits | |
2381 | AC_CHECK_TYPE(uint8_t,[ | |
2382 | AC_CHECK_SIZEOF(uint8_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2383 | AC_DEFINE(HAVE_UINT8_T,1,[uint8_t is defined in system headers]) | |
2384 | ],,SQUID_DEFAULT_INCLUDES) | |
2385 | ||
2386 | dnl 16 bit integers - int16_t | |
2387 | dnl if this is defined we trust it to be 16 bits | |
2388 | AC_CHECK_TYPE(int16_t,[ | |
2389 | AC_CHECK_SIZEOF(int16_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2390 | AC_DEFINE(HAVE_INT16_T,1,[int16_t is defined in system headers]) | |
2391 | ],,SQUID_DEFAULT_INCLUDES) | |
2392 | ||
2393 | dnl fallback #1 | |
2394 | AC_CHECK_TYPE(short,[ | |
2395 | AC_CHECK_SIZEOF(short,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2396 | AC_DEFINE(HAVE_SHORT,1,[short is defined in system headers]) | |
2397 | ],,SQUID_DEFAULT_INCLUDES) | |
2398 | ||
2399 | dnl fallback #2 | |
2400 | AC_CHECK_TYPE(int,[ | |
2401 | AC_CHECK_SIZEOF(int,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2402 | AC_DEFINE(HAVE_INT,1,[int is defined in system headers]) | |
2403 | ],,SQUID_DEFAULT_INCLUDES) | |
2404 | ||
2405 | dnl unsigned 16 bit ints - u_int16_t | |
2406 | dnl if this is defined we trust it to be 16 bits | |
2407 | AC_CHECK_TYPE(u_int16_t,[ | |
2408 | AC_CHECK_SIZEOF(u_int16_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2409 | AC_DEFINE(HAVE_U_INT16_T,1,[u_int16_t is defined in system headers]) | |
2410 | ],,SQUID_DEFAULT_INCLUDES) | |
2411 | ||
2412 | dnl fallback #1 | |
2413 | dnl if this is defined we trust it to be 16 bits | |
2414 | AC_CHECK_TYPE(uint16_t,[ | |
2415 | AC_CHECK_SIZEOF(uint16_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2416 | AC_DEFINE(HAVE_UINT16_T,1,[uint16_t is defined in system headers]) | |
2417 | ],,SQUID_DEFAULT_INCLUDES) | |
2418 | ||
2419 | dnl 32 bit signed int - int32_t | |
2420 | dnl if this is defined we trust it to be 32 bits | |
2421 | AC_CHECK_TYPE(int32_t,[ | |
2422 | AC_CHECK_SIZEOF(int32_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2423 | AC_DEFINE(HAVE_INT32_T,1,[int32_t is defined in system headers]) | |
2424 | ],,SQUID_DEFAULT_INCLUDES) | |
2425 | ||
2426 | dnl fallback #1 | |
2427 | AC_CHECK_TYPE(long,[ | |
2428 | AC_CHECK_SIZEOF(long,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2429 | AC_DEFINE(HAVE_LONG,1,[long is defined in system headers]) | |
2430 | ],,SQUID_DEFAULT_INCLUDES) | |
2431 | ||
2432 | dnl 32 bit unsigned int - u_int32_t | |
2433 | dnl if this is defined we trust it to be 32 bits | |
2434 | AC_CHECK_TYPE(u_int32_t,[ | |
2435 | AC_CHECK_SIZEOF(u_int32_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2436 | AC_DEFINE(HAVE_U_INT32_T,1,[u_int32_t is defined in system headers]) | |
2437 | ],,SQUID_DEFAULT_INCLUDES) | |
2438 | ||
2439 | dnl fallback #1 | |
2440 | dnl if this is defined we trust it to be 32 bits | |
2441 | AC_CHECK_TYPE(uint32_t,[ | |
2442 | AC_CHECK_SIZEOF(uint32_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2443 | AC_DEFINE(HAVE_UINT32_T,1,[uint32_t is defined in system headers]) | |
2444 | ],,SQUID_DEFAULT_INCLUDES) | |
2445 | ||
2446 | dnl 64 bit signed - int64_t | |
2447 | dnl if this is defind we trust it to be 64 bits | |
2448 | AC_CHECK_TYPE(int64_t,[ | |
2449 | AC_CHECK_SIZEOF(int64_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2450 | AC_DEFINE(HAVE_INT64_T,1,[int64_t is defined in system headers]) | |
2451 | ],,SQUID_DEFAULT_INCLUDES) | |
2452 | ||
2453 | dnl fallback #1 | |
2454 | dnl if this is defind we trust it to be 64 bits | |
2455 | AC_CHECK_TYPE(__int64,[ | |
2456 | AC_CHECK_SIZEOF(__int64,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2457 | AC_DEFINE(HAVE___INT64,1,[__int64 is defined in system headers]) | |
2458 | ],,SQUID_DEFAULT_INCLUDES) | |
2459 | ||
2460 | dnl fallback #2 | |
2461 | AC_CHECK_TYPE(long long,[ | |
2462 | AC_CHECK_SIZEOF(long long,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2463 | AC_DEFINE(HAVE_LONG_LONG,1,[long long is defined in system headers]) | |
2464 | ],,SQUID_DEFAULT_INCLUDES) | |
2465 | ||
2466 | dnl 64 bit unsigned - u_int64_t | |
2467 | dnl if this is defind we trust it to be 64 bits | |
2468 | AC_CHECK_TYPE(u_int64_t,[ | |
2469 | AC_CHECK_SIZEOF(u_int64_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2470 | AC_DEFINE(HAVE_U_INT64_T,1,[u_int64_t is defined in system headers]) | |
2471 | ],,SQUID_DEFAULT_INCLUDES) | |
2472 | ||
2473 | dnl fallback #1 | |
2474 | dnl if this is defind we trust it to be 64 bits | |
2475 | AC_CHECK_TYPE(uint64_t,[ | |
2476 | AC_CHECK_SIZEOF(uint64_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2477 | AC_DEFINE(HAVE_UINT64_T,1,[uint64_t is defined in system headers]) | |
2478 | ],,SQUID_DEFAULT_INCLUDES) | |
2479 | ||
2480 | dnl On Solaris 9 x86, gcc may includes a "fixed" set of old system include files | |
2481 | dnl that is incompatible with the updated Solaris header files. | |
2482 | dnl For this reason, we must check if pad128_t and upad128_t are defined. | |
2483 | AC_CHECK_TYPE(pad128_t, | |
2484 | AC_DEFINE(HAVE_PAD128_T,1,[pad128_t is defined in system headers]), | |
2485 | ,SQUID_DEFAULT_INCLUDES) | |
2486 | ||
2487 | AC_CHECK_TYPE(upad128_t, | |
2488 | AC_DEFINE(HAVE_UPAD128_T,1,[upad128_t is defined in system headers]), | |
2489 | ,SQUID_DEFAULT_INCLUDES) | |
2490 | ||
2491 | AC_CHECK_TYPE(pid_t, AC_DEFINE(HAVE_PID_T,1,[pid_t is defined by the system headers]),,SQUID_DEFAULT_INCLUDES) | |
2492 | AC_CHECK_TYPE(size_t, [AC_CHECK_SIZEOF(size_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2493 | AC_DEFINE(HAVE_SIZE_T,1,[size_t is defined by the system headers])],,SQUID_DEFAULT_INCLUDES) | |
2494 | AC_CHECK_TYPE(ssize_t, AC_DEFINE(HAVE_SSIZE_T,1,[ssize_t is defined by the system headers]),,SQUID_DEFAULT_INCLUDES) | |
2495 | AC_CHECK_TYPE(off_t,[ AC_CHECK_SIZEOF(off_t,,SQUID_DEFAULT_SIZEOF_INCLUDES) | |
2496 | AC_DEFINE(HAVE_OFF_T,1,[off_t is defined by the system headers])],,SQUID_DEFAULT_INCLUDES) | |
2497 | AC_CHECK_TYPE(mode_t, AC_DEFINE(HAVE_MODE_T,1,[mode_t is defined by the system headers]),,SQUID_DEFAULT_INCLUDES) | |
2498 | AC_CHECK_TYPE(fd_mask, AC_DEFINE(HAVE_FD_MASK,1,[fd_mask is defined by the system headers]),,SQUID_DEFAULT_INCLUDES) | |
2499 | ||
2500 | dnl Check for special functions | |
2501 | AC_FUNC_ALLOCA | |
2502 | ||
2503 | AC_CHECK_TYPE(socklen_t,AC_DEFINE(HAVE_SOCKLEN_T,1,[socklen_t is defined by the system headers]),,[ | |
2504 | #include <sys/types.h> | |
2505 | #include <sys/socket.h> | |
2506 | #if STDC_HEADERS | |
2507 | #include <stdlib.h> | |
2508 | #include <stddef.h> | |
2509 | #endif]) | |
2510 | ||
2511 | dnl Check for libcap header (assume its not broken unless | |
2512 | use_libcap=auto | |
2513 | AC_ARG_WITH(libcap, AS_HELP_STRING([--without-libcap],[disable usage of Linux capabilities library to control privileges]), | |
2514 | [ if test "x$withval" = "xyes" ; then | |
2515 | AC_MSG_RESULT(libcap forced enabled) | |
2516 | use_libcap=yes | |
2517 | else | |
2518 | AC_MSG_RESULT(libcap forced disabled) | |
2519 | use_libcap=no | |
2520 | fi | |
2521 | ]) | |
2522 | if test "x$use_libcap" != "xno"; then | |
2523 | # cap_clear_flag is the most recent libcap function we require | |
2524 | AC_CHECK_LIB(cap, cap_clear_flag) | |
2525 | if test "x$ac_cv_lib_cap_cap_clear_flag" = xyes; then | |
2526 | use_libcap=yes | |
2527 | else | |
2528 | if test "x$use_libcap" = "xyes"; then | |
2529 | AC_MSG_ERROR([libcap forced enabled but not available or not usable, requires libcap-2.09 or later]) | |
2530 | fi | |
2531 | use_libcap=no | |
2532 | fi | |
2533 | fi | |
2534 | ||
2535 | if test "x$use_libcap" = "xyes"; then | |
2536 | AC_DEFINE(USE_LIBCAP, 1, [use libcap to set capabilities required for TPROXY]) | |
2537 | dnl Check for libcap headader breakage. | |
2538 | AC_CHECK_HEADERS(sys/capability.h) | |
2539 | AC_CACHE_CHECK([for operational libcap2 headers], squid_cv_sys_capability_works, | |
2540 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[ | |
2541 | #include <stdlib.h> | |
2542 | #include <stddef.h> | |
2543 | #include <sys/capability.h> | |
2544 | ]], [[ | |
2545 | capget(NULL, NULL); | |
2546 | capset(NULL, NULL); | |
2547 | ]])],[squid_cv_sys_capability_works=yes],[squid_cv_sys_capability_works=no]) | |
2548 | ) | |
2549 | if test x$squid_cv_sys_capability_works != xyes; then | |
2550 | AC_DEFINE([LIBCAP_BROKEN],1,[if libcap2 headers are broken and clashing with glibc]) | |
2551 | fi | |
2552 | fi | |
2553 | ||
2554 | ||
2555 | AC_CHECK_TYPE(mtyp_t,AC_DEFINE(HAVE_MTYP_T,1,[mtyp_t is defined by the system headers]),,[#include <sys/types.h> | |
2556 | #include <sys/ipc.h> | |
2557 | #include <sys/msg.h>]) | |
2558 | ||
2559 | dnl Check for needed libraries | |
2560 | AC_SEARCH_LIBS([gethostbyname],[nsl resolv bind]) | |
2561 | AC_SEARCH_LIBS([res_init],[resolv]) | |
2562 | AC_SEARCH_LIBS([bind],[socket]) | |
2563 | AC_SEARCH_LIBS([opcom_stack_trace],[opcom_stack]) | |
2564 | AC_SEARCH_LIBS([strlcpy], [bsd]) | |
2565 | AC_SEARCH_LIBS([yp_match], [nsl nss_nis nss_nisplus]) | |
2566 | dnl Check for Winsock only on MinGW, on Cygwin we must use emulated BSD socket API | |
2567 | case "$host_os" in | |
2568 | mingw|mingw32) | |
2569 | AC_MSG_CHECKING(for winsock) | |
2570 | save_LIBS="$LIBS" | |
2571 | for curlib in ws2_32 wsock32; do | |
2572 | LIBS="$LIBS -l$curlib" | |
2573 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <winsock.h>]], [[ | |
2574 | socket(0,0,0); | |
2575 | select(0,NULL,NULL,NULL,NULL); | |
2576 | closesocket(0); | |
2577 | gethostname(NULL,0); | |
2578 | ]])],[have_winsock=yes],[have_winsock=no]) | |
2579 | ||
2580 | if test $have_winsock = yes; then | |
2581 | ac_cv_func_select='yes' | |
2582 | if test $curlib = ws2_32; then | |
2583 | have_winsock=winsock2 | |
2584 | fi | |
2585 | break | |
2586 | fi | |
2587 | LIBS="$save_LIBS" | |
2588 | done | |
2589 | AC_MSG_RESULT($have_winsock) | |
2590 | if test $have_winsock = winsock2; then | |
2591 | AC_CHECK_HEADERS(winsock2.h) | |
2592 | else | |
2593 | AC_CHECK_HEADERS(winsock.h) | |
2594 | fi | |
2595 | ;; | |
2596 | esac | |
2597 | ||
2598 | dnl Ripped from the Samba sources | |
2599 | AC_CACHE_CHECK([for unix domain sockets],squid_cv_unixsocket, [ | |
2600 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
2601 | #include <sys/types.h> | |
2602 | #include <stdlib.h> | |
2603 | #include <stddef.h> | |
2604 | #include <sys/socket.h> | |
2605 | #include <sys/un.h>]], [[ | |
2606 | struct sockaddr_un sunaddr; | |
2607 | sunaddr.sun_family = AF_UNIX; | |
2608 | ]])],[squid_cv_unixsocket=yes],[squid_cv_unixsocket=no])]) | |
2609 | if test x"$squid_cv_unixsocket" = x"yes"; then | |
2610 | AC_DEFINE(HAVE_UNIXSOCKET,1,[Do we have unix sockets? (required for the winbind ntlm helper]) | |
2611 | fi | |
2612 | dnl end rip | |
2613 | ||
2614 | AC_CHECK_LIB(gnumalloc, main) | |
2615 | if test "$ac_cv_lib_gnumalloc_main" = "yes"; then | |
2616 | AC_MSG_NOTICE([Disabling extended malloc functions when using gnumalloc]) | |
2617 | ac_cv_func_mallinfo=no | |
2618 | ac_cv_func_mallocblksize=no | |
2619 | ac_cv_func_mallopt=no | |
2620 | else | |
2621 | case "$host" in | |
2622 | *-sun-solaris*) | |
2623 | AC_MSG_NOTICE([skipping libmalloc check for $host]) | |
2624 | ;; | |
2625 | i386-*-freebsd*) | |
2626 | AC_MSG_NOTICE([skipping libmalloc check for $host]) | |
2627 | ;; | |
2628 | *) | |
2629 | ||
2630 | AC_CHECK_LIB(malloc, main) | |
2631 | ;; | |
2632 | esac | |
2633 | fi | |
2634 | ||
2635 | AC_CHECK_LIB(regex, main, [REGEXLIB="-lregex"]) | |
2636 | case "$host_os" in | |
2637 | mingw|mingw32) | |
2638 | AC_MSG_NOTICE([Use MSVCRT for math functions.]) | |
2639 | ;; | |
2640 | *) | |
2641 | dnl rint() is only used in old C code for now. | |
2642 | AC_LANG_PUSH([C]) | |
2643 | AC_SEARCH_LIBS([rint],[m]) | |
2644 | AC_LANG_POP([C]) | |
2645 | ;; | |
2646 | esac | |
2647 | ||
2648 | dnl Enable IPv6 support | |
2649 | AC_MSG_CHECKING([whether to enable IPv6]) | |
2650 | use_ipng=auto | |
2651 | AC_ARG_ENABLE(ipv6, | |
2652 | AS_HELP_STRING([--disable-ipv6],[Disable IPv6 support]), | |
2653 | [ case $enableval in | |
2654 | yes|no) | |
2655 | use_ipng=$enableval | |
2656 | ;; | |
2657 | *) | |
2658 | ;; | |
2659 | esac | |
2660 | ]) | |
2661 | AC_MSG_RESULT($use_ipng) | |
2662 | ||
2663 | if test "$use_ipng" != "no"; then | |
2664 | SAVED_LIBS="$LIBS" | |
2665 | dnl Solaris 10/11 requires -lsocket | |
2666 | case "$host" in | |
2667 | *-solaris*) | |
2668 | LIBS="$LIBS -lsocket" | |
2669 | ;; | |
2670 | *) | |
2671 | ;; | |
2672 | esac | |
2673 | AC_CACHE_CHECK([if PF_INET6 is available], squid_cv_pf_inet6, | |
2674 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ /* PF_INET6 available check */ | |
2675 | # include <sys/types.h> | |
2676 | # include <sys/socket.h> | |
2677 | int main(int argc, char **argv) { | |
2678 | if (socket(PF_INET6, SOCK_STREAM, 0) < 0) | |
2679 | return 1; | |
2680 | else | |
2681 | return 0; | |
2682 | } | |
2683 | ]])],[squid_cv_pf_inet6="yes" ; SAVED_LIBS="$LIBS"],[squid_cv_pf_inet6="no"],[]) | |
2684 | ) | |
2685 | LIBS="$SAVED_LIBS" | |
2686 | fi | |
2687 | ||
2688 | # NP: semi-silent failure as IPv4-only mode is perfectly usable on this system. | |
2689 | # unless --enable-ipv6 is explicitly used. in which case it's a hard fail. | |
2690 | if test "x$use_ipng" = "xyes" && test "x$squid_cv_pf_inet6" = "xno"; then | |
2691 | AC_MSG_ERROR([IPv6 cannot be built on this system. Basic kernel definitions are missing.]) | |
2692 | elif test "x$use_ipng" = "xauto" && test "x$squid_cv_pf_inet6" = "xno"; then | |
2693 | AC_MSG_WARN([IPv6 cannot be built on this system. Basic kernel definitions are missing.]) | |
2694 | fi | |
2695 | ||
2696 | if test "$use_ipng" != "no" && test "$squid_cv_pf_inet6" = "yes" ; then | |
2697 | AC_DEFINE(USE_IPV6,1,[Enable support for IPv6 ]) | |
2698 | SET_IPV6_SETTINGS="" | |
2699 | use_v4mapped=yes | |
2700 | ||
2701 | dnl Check for forced split-stack mode | |
2702 | AC_MSG_CHECKING([for IPv6 split-stack requirement]) | |
2703 | AC_ARG_WITH(ipv6-split-stack, | |
2704 | AS_HELP_STRING([--with-ipv6-split-stack],[Force-Enable experimental split-stack support for Windows XP and *BSD. Requires IPv6.]), | |
2705 | [ use_v4mapped="no" | |
2706 | AC_MSG_RESULT(yes)], | |
2707 | [ AC_MSG_RESULT(no) ]) | |
2708 | ||
2709 | dnl Check for IPv6 v4-mapping availability | |
2710 | dnl Useful for other OS with hybrid-stack defaults turned OFF | |
2711 | dnl But only usable if it actually works... | |
2712 | if test "$use_v4mapped" = "yes" ; then | |
2713 | AC_MSG_CHECKING([for IPv6 v4-mapping ability]) | |
2714 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ /* IPPROTO_V4MAPPED is usable check */ | |
2715 | # include <sys/types.h> | |
2716 | # include <sys/socket.h> | |
2717 | # include <netinet/in.h> | |
2718 | #if HAVE_NETINET_IN6_H | |
2719 | # include <netinet/in6.h> | |
2720 | #endif | |
2721 | int main(int argc, char **argv) { | |
2722 | int s = socket(PF_INET6, SOCK_STREAM, 0); | |
2723 | int tos = 0; | |
2724 | if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &tos, sizeof(int)) < 0) | |
2725 | return 1; | |
2726 | else | |
2727 | return 0; | |
2728 | } | |
2729 | ]])],[ AC_MSG_RESULT(yes) | |
2730 | use_v4mapped=yes | |
2731 | AC_DEFINE(IPV6_SPECIAL_V4MAPPED, 1, [Enable v4-mapping through v6 sockets]) | |
2732 | ],[ AC_MSG_RESULT(no) | |
2733 | AC_DEFINE(IPV6_SPECIAL_V4MAPPED, 0, [Enable v4-mapping through v6 sockets]) | |
2734 | use_v4mapped=no | |
2735 | ],[]) | |
2736 | fi | |
2737 | ||
2738 | dnl if we can't defer v4-mapping to the OS we are forced to split-stack | |
2739 | dnl the FD table. | |
2740 | AC_MSG_CHECKING([for IPv6 stack type/mode]) | |
2741 | if test "$use_v4mapped" = "yes"; then | |
2742 | AC_DEFINE(IPV6_SPECIAL_V4MAPPED, 1, [Enable v4-mapping through v6 sockets. Requires IPv6 hybrid-stack.]) | |
2743 | AC_DEFINE(IPV6_SPECIAL_SPLITSTACK, 0, [Enable support for IPv6 on split-stack implementations]) | |
2744 | AC_MSG_RESULT(mapping hybrid) | |
2745 | else | |
2746 | AC_DEFINE(IPV6_SPECIAL_V4MAPPED, 0, [Enable v4-mapping through v6 sockets. Requires IPv6 hybrid-stack.]) | |
2747 | AC_DEFINE(IPV6_SPECIAL_SPLITSTACK, 1, [Enable support for IPv6 on split-stack implementations]) | |
2748 | AC_MSG_RESULT(split-stack or BSD non-mapping dual-stack) | |
2749 | fi | |
2750 | ||
2751 | dnl Check whether this OS defines sin6_len as a member of sockaddr_in6 as a backup to ss_len | |
2752 | AC_CACHE_CHECK([for sin6_len field in struct sockaddr_in6], | |
2753 | ac_cv_have_sin6_len_in_struct_sai, [ | |
2754 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
2755 | #include <sys/types.h> | |
2756 | #include <sys/socket.h> | |
2757 | #include <netinet/in.h> | |
2758 | ]], [[ 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" | |
2759 | ]) | |
2760 | ]) | |
2761 | if test "x$ac_cv_have_sin6_len_in_struct_sai" = "xyes" ; then | |
2762 | AC_DEFINE(HAVE_SIN6_LEN_IN_SAI, 1, [Does struct sockaddr_in6 have sin6_len? 1: Yes, 0: No]) | |
2763 | else | |
2764 | AC_DEFINE(HAVE_SIN6_LEN_IN_SAI, 0, [Does struct sockaddr_in6 have sin6_len? 1: Yes, 0: No]) | |
2765 | fi | |
2766 | ||
2767 | else | |
2768 | # IPv6 is not available, but is not explicitly required. Auto-Disable. | |
2769 | AC_DEFINE(USE_IPV6,0,[Enable support for IPv6]) | |
2770 | AC_DEFINE(IPV6_SPECIAL_SPLITSTACK,0,[Enable support for IPv6 on split-stack implementations]) | |
2771 | AC_DEFINE(IPV6_SPECIAL_V4MAPPED,0,[Enable v4-mapping through v6 sockets]) | |
2772 | SET_IPV6_SETTINGS="\#IPv6 Not Available: " | |
2773 | fi | |
2774 | AC_SUBST(SET_IPV6_SETTINGS) | |
2775 | ||
2776 | dnl Check whether this OS defines ss_len as a member of sockaddr_storage | |
2777 | AC_CACHE_CHECK([for ss_len field in struct sockaddr_storage], | |
2778 | ac_cv_have_ss_len_in_struct_ss, [ | |
2779 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
2780 | #include <sys/types.h> | |
2781 | #include <sys/socket.h> | |
2782 | #include <netinet/in.h> | |
2783 | ]], [[ 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" | |
2784 | ]) | |
2785 | ]) | |
2786 | if test "x$ac_cv_have_ss_len_in_struct_ss" = "xyes" ; then | |
2787 | AC_DEFINE(HAVE_SS_LEN_IN_SS, 1, [Does struct sockaddr_storage have ss_len? 1: Yes, 0: No]) | |
2788 | else | |
2789 | AC_DEFINE(HAVE_SS_LEN_IN_SS, 0, [Does struct sockaddr_storage have ss_len? 1: Yes, 0: No]) | |
2790 | fi | |
2791 | ||
2792 | dnl Check whether this OS defines sin_len as a member of sockaddr_in as a backup to ss_len | |
2793 | AC_CACHE_CHECK([for sin_len field in struct sockaddr_in], | |
2794 | ac_cv_have_sin_len_in_struct_sai, [ | |
2795 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
2796 | #include <sys/types.h> | |
2797 | #include <sys/socket.h> | |
2798 | #include <netinet/in.h> | |
2799 | ]], [[ 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" | |
2800 | ]) | |
2801 | ]) | |
2802 | if test "x$ac_cv_have_sin_len_in_struct_sai" = "xyes" ; then | |
2803 | AC_DEFINE(HAVE_SIN_LEN_IN_SAI, 1, [Does struct sockaddr_in have sin_len? 1: Yes, 0: No]) | |
2804 | else | |
2805 | AC_DEFINE(HAVE_SIN_LEN_IN_SAI, 0, [Does struct sockaddr_in have sin_len? 1: Yes, 0: No]) | |
2806 | fi | |
2807 | ||
2808 | dnl Check for libcrypt | |
2809 | CRYPTLIB= | |
2810 | dnl Some of our helpers use crypt(3) which may be in libc, or in | |
2811 | dnl libcrypt (eg FreeBSD) | |
2812 | AC_CHECK_LIB(crypt, crypt, [CRYPTLIB="-lcrypt"]) | |
2813 | dnl Solaris10 provides MD5 natively through libmd5 | |
2814 | AC_CHECK_LIB(md5, MD5Init, [CRYPTLIB="$CRYPTLIB -lmd5"]) | |
2815 | AC_SUBST(CRYPTLIB) | |
2816 | ||
2817 | # check for crypt, may require -lcrypt | |
2818 | SAVED_LIBS="$LIBS" | |
2819 | LIBS="$LIBS $CRYPTLIB" | |
2820 | AC_CHECK_FUNCS(crypt) | |
2821 | LIBS="$SAVED_LIBS" | |
2822 | ||
2823 | ||
2824 | dnl Check for libdl, used by auth_modules/PAM | |
2825 | if test "$with_dl" = "yes"; then | |
2826 | AC_CHECK_LIB(dl, dlopen) | |
2827 | fi | |
2828 | ||
2829 | dnl -lintl is needed on SCO version 3.2v4.2 for strftime() | |
2830 | dnl Robert Side <rside@aiinc.bc.ca> | |
2831 | dnl Mon, 18 Jan 1999 17:48:00 GMT | |
2832 | case "$host" in | |
2833 | *-pc-sco3.2*) | |
2834 | AC_CHECK_LIB(intl, strftime) | |
2835 | ;; | |
2836 | esac | |
2837 | ||
2838 | dnl On MinGW OpenLDAP is not available, so LDAP helpers can be linked | |
2839 | dnl only with Windows LDAP libraries using -lwldap32 | |
2840 | case "$host_os" in | |
2841 | mingw|mingw32) | |
2842 | LDAPLIB="-lwldap32" | |
2843 | LBERLIB="" | |
2844 | ;; | |
2845 | *) | |
2846 | LDAPLIB="-lldap" | |
2847 | dnl LDAP helpers need to know if -llber is needed or not | |
2848 | AC_CHECK_LIB(lber, main, [LBERLIB="-llber"]) | |
2849 | ;; | |
2850 | esac | |
2851 | AC_SUBST(LDAPLIB) | |
2852 | AC_SUBST(LBERLIB) | |
2853 | ||
2854 | dnl Check for libdb | |
2855 | dnl this is not fully functional if db.h is for a differend db version | |
2856 | DBLIB= | |
2857 | ||
2858 | dnl check that dbopen is actually defined in the header | |
2859 | dnl FIXME: in case of failure undef db-related includes etc. | |
2860 | AC_CHECK_DECL(dbopen,,,[ | |
2861 | #if HAVE_SYS_TYPES_H | |
2862 | #include <sys/types.h> | |
2863 | #endif | |
2864 | #if HAVE_LIMITS_H | |
2865 | #include <limits.h> | |
2866 | #endif | |
2867 | #if HAVE_DB_185_H | |
2868 | #include <db_185.h> | |
2869 | #elif HAVE_DB_H | |
2870 | #include <db.h> | |
2871 | #endif]) | |
2872 | ||
2873 | dnl 1.85 | |
2874 | AC_CACHE_CHECK(if dbopen needs -ldb,ac_cv_dbopen_libdb, [ | |
2875 | SAVED_LIBS="$LIBS"; LIBS="$LIBS -ldb" | |
2876 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[ | |
2877 | #if HAVE_SYS_TYPES_H | |
2878 | #include <sys/types.h> | |
2879 | #endif | |
2880 | #if HAVE_LIMITS_H | |
2881 | #include <limits.h> | |
2882 | #endif | |
2883 | #if HAVE_DB_185_H | |
2884 | #include <db_185.h> | |
2885 | #elif HAVE_DB_H | |
2886 | #include <db.h> | |
2887 | #endif]], [[dbopen("", 0, 0, DB_HASH, (void *)0L)]])],[ac_cv_dbopen_libdb="yes"],[ac_cv_dbopen_libdb="no"]) | |
2888 | LIBS="$SAVED_LIBS" | |
2889 | ]) | |
2890 | if test $ac_cv_dbopen_libdb = yes; then | |
2891 | LIB_DB="-ldb" | |
2892 | fi | |
2893 | AC_SUBST(LIB_DB) | |
2894 | ||
2895 | dnl System-specific library modifications | |
2896 | dnl | |
2897 | case "$host" in | |
2898 | i386-*-solaris2.*) | |
2899 | if test "$GCC" = "yes"; then | |
2900 | AC_MSG_NOTICE([Removing -O for gcc on $host]) | |
2901 | CFLAGS="`echo $CFLAGS | sed -e 's/-O[[0-9]]*//'`" | |
2902 | fi | |
2903 | ;; | |
2904 | *-sgi-irix*) | |
2905 | AC_MSG_NOTICE([Removing -lsocket for IRIX...]) | |
2906 | LIBS=`echo $LIBS | sed -e s/-lsocket//` | |
2907 | AC_MSG_NOTICE([Removing -lnsl for IRIX...]) | |
2908 | LIBS=`echo $LIBS | sed -e s/-lnsl//` | |
2909 | ac_cv_lib_nsl_main=no | |
2910 | AC_MSG_NOTICE([Removing -lbsd for IRIX...]) | |
2911 | LIBS=`echo $LIBS | sed -e s/-lbsd//` | |
2912 | ;; | |
2913 | dnl From: c0032033@ws.rz.tu-bs.de (Joerg Schumacher) | |
2914 | dnl Date: Thu, 17 Oct 1996 04:09:30 +0200 | |
2915 | dnl Please change your configure script. AIX doesn't need -lbsd. | |
2916 | *-ibm-aix*) | |
2917 | AC_MSG_NOTICE([Removing -lbsd for AIX...]) | |
2918 | LIBS=`echo $LIBS | sed -e s/-lbsd//` | |
2919 | ;; | |
2920 | *m88k*) | |
2921 | SQUID_CFLAGS="$SQUID_CFLAGS -D_SQUID_MOTOROLA_" | |
2922 | SQUID_CXXFLAGS="$SQUID_CXXFLAGS -D_SQUID_MOTOROLA_" | |
2923 | AC_DEFINE(GETTIMEOFDAY_NO_TZP,1,[If gettimeofday is known to take only one argument]) | |
2924 | ;; | |
2925 | [*-*-solaris2.[0-4]]) | |
2926 | AC_DEFINE(GETTIMEOFDAY_NO_TZP,1) | |
2927 | ;; | |
2928 | [*-sony-newsos[56]*]) | |
2929 | AC_DEFINE(GETTIMEOFDAY_NO_TZP,1) | |
2930 | ;; | |
2931 | esac | |
2932 | ||
2933 | # Remove optimization for GCC 2.95.[123] | |
2934 | # gcc -O[2] on *BSD and Linux (x86) causes pointers to magically become NULL | |
2935 | if test "$GCC" = "yes"; then | |
2936 | GCCVER=`$CC -v 2>&1 | awk '$2 == "version" {print $3}'` | |
2937 | case "$GCCVER" in | |
2938 | [2.95.[123]]) | |
2939 | AC_MSG_NOTICE([Removing -O for gcc on $host with GCC $GCCVER]) | |
2940 | CFLAGS="`echo $CFLAGS | sed -e 's/-O[[0-9]]*//'`" | |
2941 | ;; | |
2942 | esac | |
2943 | fi | |
2944 | ||
2945 | # Recommended by Balint Nagy Endre <bne@CareNet.hu> | |
2946 | case "$host" in | |
2947 | *-univel-sysv4.2MP) | |
2948 | if test `uname -v` = "2.03"; then | |
2949 | AC_MSG_NOTICE([disabling mallinfo for $host]) | |
2950 | ac_cv_func_mallinfo=no | |
2951 | fi | |
2952 | ;; | |
2953 | esac | |
2954 | ||
2955 | dnl This has to be before AC_CHECK_FUNCS | |
2956 | # Disable poll() on certain platforms. Override by setting ac_cv_func_poll | |
2957 | # when running configure. | |
2958 | if test -z "$ac_cv_func_poll"; then | |
2959 | case "$host" in | |
2960 | [alpha-dec-osf3.*]) | |
2961 | # John Kay (jkay@nlanr.net) 19970818 | |
2962 | AC_MSG_NOTICE([disabling poll for $host...]) | |
2963 | ac_cv_func_poll='no' | |
2964 | ;; | |
2965 | [*-hp-hpux*.*]) | |
2966 | # Duane Wessels | |
2967 | AC_MSG_NOTICE([disabling poll for $host...]) | |
2968 | ac_cv_func_poll='no' | |
2969 | ;; | |
2970 | [*-linux-*]) | |
2971 | # Henrik Nordstrom (hno@squid-cache.org) 19980817 | |
2972 | # poll is problematic on Linux. We disable it | |
2973 | # by default until Linux gets it right. | |
2974 | rev=`uname -r | awk -F. '{printf "%03d%03d",$1,$2}'` | |
2975 | if test $rev -lt 002002; then | |
2976 | AC_MSG_NOTICE([disabling poll for $host < 2.2...]) | |
2977 | ac_cv_func_poll='no' | |
2978 | fi | |
2979 | ;; | |
2980 | [powerpc-ibm-aix4.1.*]) | |
2981 | # Mike Laster (mlaster@metavillage.com) 19981021 | |
2982 | AC_MSG_NOTICE([disabling poll for $host...]) | |
2983 | ac_cv_func_poll='no' | |
2984 | ;; | |
2985 | [*-pc-sco3.2*]) | |
2986 | # Robert Side <rside@aiinc.bc.ca> | |
2987 | # Mon, 18 Jan 1999 17:48:00 GMT | |
2988 | AC_MSG_NOTICE([disabling poll for $host...]) | |
2989 | ac_cv_func_poll='no' | |
2990 | ;; | |
2991 | esac | |
2992 | fi | |
2993 | ||
2994 | dnl Override statfs() detect on MinGW becasue is emulated in source code | |
2995 | case "$host_os" in | |
2996 | mingw|mingw32) | |
2997 | ac_cv_func_statfs='yes' | |
2998 | ;; | |
2999 | esac | |
3000 | ||
3001 | dnl Check for library functions | |
3002 | AC_CHECK_FUNCS(\ | |
3003 | backtrace_symbols_fd \ | |
3004 | bcopy \ | |
3005 | bswap_16 \ | |
3006 | bswap_32 \ | |
3007 | bswap16 \ | |
3008 | bswap32 \ | |
3009 | fchmod \ | |
3010 | getdtablesize \ | |
3011 | getpagesize \ | |
3012 | getpass \ | |
3013 | getrlimit \ | |
3014 | getrusage \ | |
3015 | getspnam \ | |
3016 | gettimeofday \ | |
3017 | glob \ | |
3018 | htobe16 \ | |
3019 | htole16 \ | |
3020 | kqueue\ | |
3021 | lrand48 \ | |
3022 | mallinfo \ | |
3023 | mallocblksize \ | |
3024 | mallopt \ | |
3025 | memcpy \ | |
3026 | memmove \ | |
3027 | memset \ | |
3028 | mkstemp \ | |
3029 | mktime \ | |
3030 | mstats \ | |
3031 | poll \ | |
3032 | prctl \ | |
3033 | pthread_attr_setschedparam \ | |
3034 | pthread_attr_setscope \ | |
3035 | pthread_setschedparam \ | |
3036 | pthread_sigmask \ | |
3037 | putenv \ | |
3038 | random \ | |
3039 | regcomp \ | |
3040 | regexec \ | |
3041 | regfree \ | |
3042 | res_init \ | |
3043 | __res_init \ | |
3044 | rint \ | |
3045 | sbrk \ | |
3046 | select \ | |
3047 | seteuid \ | |
3048 | setgroups \ | |
3049 | setpgrp \ | |
3050 | setrlimit \ | |
3051 | setsid \ | |
3052 | sigaction \ | |
3053 | snprintf \ | |
3054 | socketpair \ | |
3055 | srand48 \ | |
3056 | srandom \ | |
3057 | statfs \ | |
3058 | sysconf \ | |
3059 | syslog \ | |
3060 | timegm \ | |
3061 | vsnprintf \ | |
3062 | ) | |
3063 | dnl ... and some we provide local replacements for | |
3064 | AC_REPLACE_FUNCS(\ | |
3065 | drand48 \ | |
3066 | eui64_aton \ | |
3067 | inet_ntop \ | |
3068 | inet_pton \ | |
3069 | initgroups \ | |
3070 | getaddrinfo \ | |
3071 | getnameinfo \ | |
3072 | strerror \ | |
3073 | strsep \ | |
3074 | strtoll \ | |
3075 | tempnam \ | |
3076 | ) | |
3077 | ||
3078 | # Magic which checks whether we are forcing a type of comm loop we | |
3079 | # are actually going to (ab)use. | |
3080 | # Mostly ripped from squid-commloops, thanks to adrian and benno | |
3081 | ||
3082 | if test -n "$squid_opt_io_loop_engine"; then | |
3083 | AC_MSG_NOTICE([choosing user-specified net I/O API $squid_opt_io_loop_engine]) | |
3084 | elif test "$enable_epoll" != "no" && test "$squid_cv_epoll_works" = "yes" ; then | |
3085 | squid_opt_io_loop_engine="epoll" | |
3086 | elif test "$enable_kqueue" != "no" && test "$ac_cv_func_kqueue" = "yes" ; then | |
3087 | squid_opt_io_loop_engine="kqueue" | |
3088 | elif test "$enable_poll" != "no" && test "$ac_cv_func_poll" = "yes" ; then | |
3089 | squid_opt_io_loop_engine="poll" | |
3090 | elif test "$enable_select" != "no" && test "$ac_cv_func_select" = "yes" ; then | |
3091 | squid_opt_io_loop_engine="select" | |
3092 | if test "$squid_host_os" = "mingw" ; then | |
3093 | squid_opt_io_loop_engine="select_win32" | |
3094 | fi | |
3095 | else | |
3096 | AC_MSG_WARN([Eep! Cannot find poll, kqueue, epoll, or select!]) | |
3097 | AC_MSG_WARN([Will try select and hope for the best.]) | |
3098 | squid_opt_io_loop_engine="select" | |
3099 | fi | |
3100 | ||
3101 | AC_MSG_NOTICE([Using ${squid_opt_io_loop_engine} for the IO loop.]) | |
3102 | ||
3103 | AM_CONDITIONAL([USE_POLL], [test $squid_opt_io_loop_engine = poll]) | |
3104 | AM_CONDITIONAL([USE_EPOLL], [test $squid_opt_io_loop_engine = epoll]) | |
3105 | AM_CONDITIONAL([USE_SELECT], [test $squid_opt_io_loop_engine = select]) | |
3106 | AM_CONDITIONAL([USE_SELECT_SIMPLE], [test $squid_opt_io_loop_engine = select_simple]) | |
3107 | AM_CONDITIONAL([USE_SELECT_WIN32], [test $squid_opt_io_loop_engine = select_win32]) | |
3108 | AM_CONDITIONAL([USE_KQUEUE], [test $squid_opt_io_loop_engine = kqueue]) | |
3109 | AM_CONDITIONAL([USE_DEVPOLL], [test $squid_opt_io_loop_engine = devpoll]) | |
3110 | ||
3111 | case $squid_opt_io_loop_engine in | |
3112 | epoll) AC_DEFINE(USE_EPOLL,1,[Use epoll() for the IO loop]) ;; | |
3113 | poll) AC_DEFINE(USE_POLL,1,[Use poll() for the IO loop]) ;; | |
3114 | kqueue) AC_DEFINE(USE_KQUEUE,1,[Use kqueue() for the IO loop]) ;; | |
3115 | select_win32) AC_DEFINE(USE_SELECT_WIN32,1,[Use Winsock select() for the IO loop]) ;; | |
3116 | select) AC_DEFINE(USE_SELECT,1,[Use select() for the IO loop]) ;; | |
3117 | esac | |
3118 | ||
3119 | AC_CACHE_CHECK(if setresuid is actually implemented, ac_cv_func_setresuid, | |
3120 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ | |
3121 | #include <stdlib.h> | |
3122 | int main(int argc, char **argv) { | |
3123 | if(setresuid(-1,-1,-1)) { | |
3124 | perror("setresuid:"); | |
3125 | return 1; | |
3126 | } | |
3127 | return 0; | |
3128 | } | |
3129 | ]])],[ac_cv_func_setresuid="yes"],[ac_cv_func_setresuid="no"],[]) | |
3130 | ) | |
3131 | if test "$ac_cv_func_setresuid" = "yes" ; then | |
3132 | AC_DEFINE(HAVE_SETRESUID,1,[Yay! Another Linux brokenness. Knowing that setresuid() exists is not enough, because RedHat 5.0 declares setresuid() but does not implement it.]) | |
3133 | fi | |
3134 | ||
3135 | SQUID_CHECK_FUNC_STRNSTR | |
3136 | SQUID_CHECK_FUNC_VACOPY | |
3137 | SQUID_CHECK_FUNC___VACOPY | |
3138 | ||
3139 | ||
3140 | dnl IP-Filter support requires ipf header files. These aren't | |
3141 | dnl installed by default, so we need to check for them | |
3142 | if test "$enable_ipf_transparent" != "no" ; then | |
3143 | AC_MSG_CHECKING(for availability of IP-Filter header files) | |
3144 | # hold on to your hats... | |
3145 | if test "$ac_cv_header_ip_compat_h" = "yes" || | |
3146 | test "$ac_cv_header_ip_fil_compat_h" = "yes" || | |
3147 | test "$ac_cv_header_netinet_ip_compat_h" = "yes" || | |
3148 | test "$ac_cv_header_netinet_ip_fil_compat_h" = "yes" ; then | |
3149 | have_ipfilter_compat_header="yes" | |
3150 | fi | |
3151 | if test "$have_ipfilter_compat_header" = "yes" && | |
3152 | test "$ac_cv_header_ip_fil_h" = "yes" && | |
3153 | test "$ac_cv_header_ip_nat_h" = "yes" ; then | |
3154 | enable_ipf_transparent="yes" | |
3155 | elif test "$have_ipfilter_compat_header" = "yes" && | |
3156 | test "$ac_cv_header_netinet_ip_fil_h" = "yes" && | |
3157 | test "$ac_cv_header_netinet_ip_nat_h" = "yes" ; then | |
3158 | enable_ipf_transparent="yes" | |
3159 | else | |
3160 | enable_ipf_transparent="no" | |
3161 | fi | |
3162 | AC_MSG_RESULT($IPF_TRANSPARENT) | |
3163 | fi | |
3164 | AC_MSG_NOTICE([IPF-based transparent proxying enabled: $enable_ipf_transparent]) | |
3165 | SQUID_DEFINE_BOOL([IPF_TRANSPARENT],$enable_ipf_transparent, | |
3166 | [Enable support for IPF-style transparent proxying]) | |
3167 | ||
3168 | if test "$enable_ipf_transparent" = "yes" -a "$squid_host_os" = "solaris" ; then | |
3169 | dnl On Solaris Ipfilter includes expect that SOLARIS2 is defined with the | |
3170 | dnl Solaris minor version (8, 9, 10, ...) | |
3171 | solrev=`uname -r | sh -c 'IFS=. read j n x; echo $n'` | |
3172 | CFLAGS="-DSOLARIS2=$solrev $CFLAGS" | |
3173 | CXXFLAGS="-DSOLARIS2=$solrev $CXXFLAGS" | |
3174 | fi | |
3175 | ||
3176 | dnl PF support requires a header file. | |
3177 | if test "$enable_pf_transparent" != "no" ; then | |
3178 | if test "$ac_cv_header_net_pfvar_h" = "yes" -o \ | |
3179 | "$ac_cv_header_net_pf_pfvar_h" = "yes"; then | |
3180 | if test "$enable_pf_transparent" = "auto" ; then | |
3181 | enable_pf_transparent="yes" | |
3182 | fi | |
3183 | else | |
3184 | if test "$enable_pf_transparent" = "yes" ; then | |
3185 | AC_MSG_ERROR([PF-based transparent proxy requested but needed header not found]) | |
3186 | fi | |
3187 | enable_pf_transparent="no" | |
3188 | fi | |
3189 | fi | |
3190 | SQUID_DEFINE_BOOL([PF_TRANSPARENT],$enable_pf_transparent, | |
3191 | [Enable support for PF-style transparent proxying]) | |
3192 | ||
3193 | if test "$enable_linux_netfilter" != "no" ; then | |
3194 | if test "$ac_cv_header_linux_netfilter_ipv4_h" = "yes"; then | |
3195 | if test "$enable_linux_netfilter" = "auto" ; then | |
3196 | enable_linux_netfilter=yes | |
3197 | fi | |
3198 | else | |
3199 | if test "$enable_linux_netfilter" = "auto" ; then | |
3200 | enable_linux_netfilter=no | |
3201 | else | |
3202 | AC_MSG_ERROR([Linux Netfilter support requested but needed headers not found]) | |
3203 | fi | |
3204 | fi | |
3205 | fi | |
3206 | SQUID_DEFINE_BOOL([LINUX_NETFILTER],$enable_linux_netfilter, | |
3207 | [Enable support for Transparent Proxy on Linux via Netfilter]) | |
3208 | ||
3209 | dnl Netfilter TPROXY depends on libcap but the NAT parts can still work. | |
3210 | AC_MSG_NOTICE([Support for Netfilter-based interception proxy requested: $enable_linux_netfilter]) | |
3211 | if test "$enable_linux_netfilter" = "yes" && test "$use_libcap" != "yes" ; then | |
3212 | AC_MSG_WARN([Missing needed capabilities (libcap or libcap2) for TPROXY]) | |
3213 | AC_MSG_WARN([Linux Transparent Proxy support WILL NOT be enabled]) | |
3214 | AC_MSG_WARN([Reduced support to Interception Proxy]) | |
3215 | # AC_DEFINEd later | |
3216 | fi | |
3217 | ||
3218 | AC_ARG_ENABLE(gnuregex, | |
3219 | AS_HELP_STRING([--enable-gnuregex], | |
3220 | [Compile GNUregex. Unless you have reason to use | |
3221 | this option, you should not enable it. | |
3222 | This library file is usually only required on Windows and | |
3223 | very old Unix boxes which do not have their own regex | |
3224 | library built in.]), | |
3225 | [USE_GNUREGEX=$enableval]) | |
3226 | if test -z "$USE_GNUREGEX" ; then | |
3227 | case "$host" in | |
3228 | *-sun-solaris2.[[0-4]]) | |
3229 | USE_GNUREGEX="yes" | |
3230 | ;; | |
3231 | *-next-nextstep*) | |
3232 | USE_GNUREGEX="yes" | |
3233 | ;; | |
3234 | esac | |
3235 | fi | |
3236 | AC_MSG_CHECKING(if GNUregex needs to be compiled) | |
3237 | if test -z "$USE_GNUREGEX"; then | |
3238 | if test "$ac_cv_func_regcomp" = "no" || test "$USE_GNUREGEX" = "yes" ; then | |
3239 | USE_GNUREGEX="yes" | |
3240 | else | |
3241 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h> | |
3242 | #include <regex.h>]], [[regex_t t; regcomp(&t,"",0);]])],[USE_GNUREGEX="no"],[USE_GNUREGEX="yes"]) | |
3243 | fi | |
3244 | fi | |
3245 | AC_MSG_RESULT($USE_GNUREGEX) | |
3246 | if test "$USE_GNUREGEX" = "yes"; then | |
3247 | # override system regex with ours. Not good. But what was asked for. | |
3248 | REGEXLIB="" | |
3249 | AC_DEFINE(USE_GNUREGEX,1,[Define if we should use GNU regex]) | |
3250 | fi | |
3251 | AC_SUBST(REGEXLIB) | |
3252 | #AC_SUBST(LIBREGEX) | |
3253 | ||
3254 | dnl Not cached since people are likely to tune this | |
3255 | AC_MSG_CHECKING(Default FD_SETSIZE value) | |
3256 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ | |
3257 | #if HAVE_STDIO_H | |
3258 | #include <stdio.h> | |
3259 | #endif | |
3260 | #if HAVE_UNISTD_H | |
3261 | #include <unistd.h> | |
3262 | #endif | |
3263 | #if HAVE_STDLIB_H | |
3264 | #include <stdlib.h> | |
3265 | #endif | |
3266 | #if HAVE_SYS_TIME_H | |
3267 | #include <sys/time.h> | |
3268 | #endif | |
3269 | #if HAVE_SYS_SELECT_H | |
3270 | #include <sys/select.h> | |
3271 | #endif | |
3272 | #if HAVE_SYS_TYPES_H | |
3273 | #include <sys/types.h> | |
3274 | #endif | |
3275 | #if HAVE_WINSOCK_H | |
3276 | #include <winsock.h> | |
3277 | #endif | |
3278 | #if HAVE_WINSOCK2_H | |
3279 | #include <winsock2.h> | |
3280 | #endif | |
3281 | int main(int argc, char **argv) { | |
3282 | FILE *fp = fopen("conftestval", "w"); | |
3283 | fprintf (fp, "%d\n", FD_SETSIZE); | |
3284 | return 0; | |
3285 | } | |
3286 | ]])],[DEFAULT_FD_SETSIZE=`cat conftestval`],[DEFAULT_FD_SETSIZE=256],[DEFAULT_FD_SETSIZE=256]) | |
3287 | AC_MSG_RESULT($DEFAULT_FD_SETSIZE) | |
3288 | AC_DEFINE_UNQUOTED(DEFAULT_FD_SETSIZE, $DEFAULT_FD_SETSIZE, [Default FD_SETSIZE value]) | |
3289 | ||
3290 | ||
3291 | dnl Not cached since people are likely to tune this | |
3292 | AC_MSG_CHECKING(Maximum number of filedescriptors we can open) | |
3293 | dnl damn! FreeBSD pthreads break dup2(). | |
3294 | TLDFLAGS="$LDFLAGS" | |
3295 | if test -n "$squid_filedescriptors_num" ; then | |
3296 | SQUID_MAXFD=$squid_filedescriptors_num | |
3297 | AC_MSG_RESULT($SQUID_MAXFD (user-forced)) | |
3298 | else | |
3299 | case $host in | |
3300 | i386-unknown-freebsd*) | |
3301 | if echo "$LDFLAGS" | grep -q pthread; then | |
3302 | LDFLAGS=`echo $LDFLAGS | sed -e "s/-pthread//"` | |
3303 | fi | |
3304 | esac | |
3305 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ | |
3306 | #include <stdio.h> | |
3307 | #include <unistd.h> | |
3308 | #include <stdlib.h> | |
3309 | #include <sys/time.h> /* needed on FreeBSD */ | |
3310 | #include <sys/param.h> | |
3311 | #include <sys/resource.h> | |
3312 | int main(int argc, char **argv) { | |
3313 | FILE *fp; | |
3314 | int i,j; | |
3315 | #if defined(__CYGWIN32__) || defined (__CYGWIN__) | |
3316 | /* getrlimit and sysconf returns bogous values on cygwin32. | |
3317 | * Number of fds is virtually unlimited in cygwin (sys/param.h) | |
3318 | * __CYGWIN32__ is deprecated. | |
3319 | */ | |
3320 | i = NOFILE; | |
3321 | #else | |
3322 | #if HAVE_SETRLIMIT | |
3323 | struct rlimit rl; | |
3324 | #if defined(RLIMIT_NOFILE) | |
3325 | if (getrlimit(RLIMIT_NOFILE, &rl) < 0) { | |
3326 | perror("getrlimit: RLIMIT_NOFILE"); | |
3327 | } else { | |
3328 | #if defined(__APPLE__) | |
3329 | /* asking for more than OPEN_MAX fails on Leopard */ | |
3330 | rl.rlim_cur = (OPEN_MAX < rl.rlim_max ? OPEN_MAX : rl.rlim_max); | |
3331 | #else | |
3332 | rl.rlim_cur = rl.rlim_max; /* set it to the max */ | |
3333 | #endif | |
3334 | if (setrlimit(RLIMIT_NOFILE, &rl) < 0) { | |
3335 | perror("setrlimit: RLIMIT_NOFILE"); | |
3336 | } | |
3337 | } | |
3338 | #elif defined(RLIMIT_OFILE) | |
3339 | if (getrlimit(RLIMIT_OFILE, &rl) < 0) { | |
3340 | perror("getrlimit: RLIMIT_OFILE"); | |
3341 | } else { | |
3342 | rl.rlim_cur = rl.rlim_max; /* set it to the max */ | |
3343 | if (setrlimit(RLIMIT_OFILE, &rl) < 0) { | |
3344 | perror("setrlimit: RLIMIT_OFILE"); | |
3345 | } | |
3346 | } | |
3347 | #endif /* RLIMIT_NOFILE */ | |
3348 | #endif /* HAVE_SETRLIMIT */ | |
3349 | /* by starting at 2^14, we will never get higher | |
3350 | than 2^15 for SQUID_MAXFD */ | |
3351 | i = j = 1<<14; | |
3352 | while (j) { | |
3353 | j >>= 1; | |
3354 | if (dup2(0, i) < 0) { | |
3355 | i -= j; | |
3356 | } else { | |
3357 | close(i); | |
3358 | i += j; | |
3359 | } | |
3360 | } | |
3361 | i++; | |
3362 | #endif /* IF !DEF CYGWIN */ | |
3363 | fp = fopen("conftestval", "w"); | |
3364 | fprintf (fp, "%d\n", i & ~0x3F); | |
3365 | return 0; | |
3366 | } | |
3367 | ]])],[SQUID_MAXFD=`cat conftestval`],[SQUID_MAXFD=256],[SQUID_MAXFD=256]) | |
3368 | dnl Microsoft MSVCRT.DLL supports 2048 maximum FDs | |
3369 | case "$host_os" in | |
3370 | mingw|mingw32) | |
3371 | SQUID_MAXFD="2048" | |
3372 | ;; | |
3373 | esac | |
3374 | AC_MSG_RESULT($SQUID_MAXFD) | |
3375 | fi | |
3376 | AC_DEFINE_UNQUOTED(SQUID_MAXFD, $SQUID_MAXFD,[Maximum number of open filedescriptors]) | |
3377 | if test "$SQUID_MAXFD" -lt 512 ; then | |
3378 | AC_MSG_WARN([$SQUID_MAXFD may not be enough filedescriptors if your]) | |
3379 | AC_MSG_WARN([cache will be very busy. Please see the FAQ page]) | |
3380 | AC_MSG_WARN([http://wiki.squid-cache.org/SquidFaq/TroubleShooting]) | |
3381 | AC_MSG_WARN([on how to increase your filedescriptor limit]) | |
3382 | fi | |
3383 | LDFLAGS="$TLDFLAGS" | |
3384 | ||
3385 | if test `expr $SQUID_MAXFD % 64` != 0; then | |
3386 | AC_MSG_WARN([$SQUID_MAXFD is not an multiple of 64. This may cause issues on certain platforms.]) | |
3387 | fi | |
3388 | ||
3389 | dnl Not cached since people are likely to tune this | |
3390 | AC_MSG_CHECKING(Default UDP send buffer size) | |
3391 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ | |
3392 | #include <stdlib.h> | |
3393 | #include <stdio.h> | |
3394 | #include <sys/types.h> | |
3395 | #if HAVE_SYS_SOCKET_H | |
3396 | #include <sys/socket.h> | |
3397 | #endif | |
3398 | #if HAVE_NETINET_IN_H | |
3399 | #include <netinet/in.h> | |
3400 | #endif | |
3401 | #if HAVE_WINSOCK_H | |
3402 | #include <winsock.h> | |
3403 | #endif | |
3404 | #if HAVE_WINSOCK2_H | |
3405 | #include <winsock2.h> | |
3406 | #endif | |
3407 | int main(int argc, char **argv) | |
3408 | { | |
3409 | FILE *fp; | |
3410 | int fd,val=0; | |
3411 | #if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) | |
3412 | int len=sizeof(int); | |
3413 | WSADATA wsaData; | |
3414 | WSAStartup(2, &wsaData); | |
3415 | #else | |
3416 | socklen_t len=sizeof(socklen_t); | |
3417 | #endif | |
3418 | if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) return 1; | |
3419 | #if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) | |
3420 | if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char *)&val, &len) < 0) return 1; | |
3421 | WSACleanup(); | |
3422 | #else | |
3423 | if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &val, &len) < 0) return 1; | |
3424 | #endif | |
3425 | if (val<=0) return 1; | |
3426 | fp = fopen("conftestval", "w"); | |
3427 | fprintf (fp, "%d\n", val); | |
3428 | return 0; | |
3429 | } | |
3430 | ]])],[SQUID_DETECT_UDP_SO_SNDBUF=`cat conftestval`],[SQUID_DETECT_UDP_SO_SNDBUF=16384],[SQUID_DETECT_UDP_SO_SNDBUF=16384]) | |
3431 | AC_MSG_RESULT($SQUID_DETECT_UDP_SO_SNDBUF) | |
3432 | AC_DEFINE_UNQUOTED(SQUID_DETECT_UDP_SO_SNDBUF, $SQUID_DETECT_UDP_SO_SNDBUF,[UDP send buffer size]) | |
3433 | ||
3434 | dnl Not cached since people are likely to tune this | |
3435 | AC_MSG_CHECKING(Default UDP receive buffer size) | |
3436 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ | |
3437 | #include <stdlib.h> | |
3438 | #include <stdio.h> | |
3439 | #include <sys/types.h> | |
3440 | #if HAVE_SYS_SOCKET_H | |
3441 | #include <sys/socket.h> | |
3442 | #endif | |
3443 | #if HAVE_NETINET_IN_H | |
3444 | #include <netinet/in.h> | |
3445 | #endif | |
3446 | #if HAVE_WINSOCK_H | |
3447 | #include <winsock.h> | |
3448 | #endif | |
3449 | #if HAVE_WINSOCK2_H | |
3450 | #include <winsock2.h> | |
3451 | #endif | |
3452 | int main(int argc, char **argv) | |
3453 | { | |
3454 | FILE *fp; | |
3455 | int fd,val=0; | |
3456 | #if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) | |
3457 | int len=sizeof(int); | |
3458 | WSADATA wsaData; | |
3459 | WSAStartup(2, &wsaData); | |
3460 | #else | |
3461 | socklen_t len=sizeof(socklen_t); | |
3462 | #endif | |
3463 | if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) return 1; | |
3464 | #if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) | |
3465 | if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char *)&val, &len) < 0) return 1; | |
3466 | WSACleanup(); | |
3467 | #else | |
3468 | if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &val, &len) < 0) return 1; | |
3469 | #endif | |
3470 | if (val <= 0) return 1; | |
3471 | fp = fopen("conftestval", "w"); | |
3472 | fprintf (fp, "%d\n", val); | |
3473 | return 0; | |
3474 | } | |
3475 | ]])],[SQUID_DETECT_UDP_SO_RCVBUF=`cat conftestval`],[SQUID_DETECT_UDP_SO_RCVBUF=16384],[SQUID_DETECT_UDP_SO_RCVBUF=16384]) | |
3476 | AC_MSG_RESULT($SQUID_DETECT_UDP_SO_RCVBUF) | |
3477 | AC_DEFINE_UNQUOTED(SQUID_DETECT_UDP_SO_RCVBUF, $SQUID_DETECT_UDP_SO_RCVBUF,[UDP receive buffer size]) | |
3478 | ||
3479 | dnl Not cached since people are likely to tune this | |
3480 | AC_MSG_CHECKING(Default TCP send buffer size) | |
3481 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ | |
3482 | #include <stdlib.h> | |
3483 | #include <stdio.h> | |
3484 | #include <sys/types.h> | |
3485 | #if HAVE_SYS_SOCKET_H | |
3486 | #include <sys/socket.h> | |
3487 | #endif | |
3488 | #if HAVE_NETINET_IN_H | |
3489 | #include <netinet/in.h> | |
3490 | #endif | |
3491 | #if HAVE_WINSOCK_H | |
3492 | #include <winsock.h> | |
3493 | #endif | |
3494 | #if HAVE_WINSOCK2_H | |
3495 | #include <winsock2.h> | |
3496 | #endif | |
3497 | int main(int argc, char **argv) | |
3498 | { | |
3499 | FILE *fp; | |
3500 | int fd,val=0; | |
3501 | #if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) | |
3502 | int len=sizeof(int); | |
3503 | WSADATA wsaData; | |
3504 | WSAStartup(2, &wsaData); | |
3505 | #else | |
3506 | socklen_t len=sizeof(socklen_t); | |
3507 | #endif | |
3508 | if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) return 1; | |
3509 | #if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) | |
3510 | if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char *)&val, &len) < 0) return 1; | |
3511 | WSACleanup(); | |
3512 | #else | |
3513 | if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &val, &len) < 0) return 1; | |
3514 | #endif | |
3515 | if (val <= 0) return 1; | |
3516 | fp = fopen("conftestval", "w"); | |
3517 | fprintf (fp, "%d\n", val); | |
3518 | return 0; | |
3519 | } | |
3520 | ]])],[SQUID_TCP_SO_SNDBUF=`cat conftestval`],[SQUID_TCP_SO_SNDBUF=16384],[SQUID_TCP_SO_SNDBUF=16384]) | |
3521 | AC_MSG_RESULT($SQUID_TCP_SO_SNDBUF) | |
3522 | if test $SQUID_TCP_SO_SNDBUF -gt 32768; then | |
3523 | AC_MSG_NOTICE([Limiting send buffer size to 32K]) | |
3524 | SQUID_TCP_SO_SNDBUF=32768 | |
3525 | fi | |
3526 | AC_DEFINE_UNQUOTED(SQUID_TCP_SO_SNDBUF, $SQUID_TCP_SO_SNDBUF,[TCP send buffer size]) | |
3527 | ||
3528 | dnl Not cached since people are likely to tune this | |
3529 | AC_MSG_CHECKING(Default TCP receive buffer size) | |
3530 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ | |
3531 | #include <stdlib.h> | |
3532 | #include <stdio.h> | |
3533 | #include <sys/types.h> | |
3534 | #if HAVE_SYS_SOCKET_H | |
3535 | #include <sys/socket.h> | |
3536 | #endif | |
3537 | #if HAVE_NETINET_IN_H | |
3538 | #include <netinet/in.h> | |
3539 | #endif | |
3540 | #if HAVE_WINSOCK_H | |
3541 | #include <winsock.h> | |
3542 | #endif | |
3543 | #if HAVE_WINSOCK2_H | |
3544 | #include <winsock2.h> | |
3545 | #endif | |
3546 | int main(int argc, char **argv) | |
3547 | { | |
3548 | FILE *fp; | |
3549 | int fd,val=0; | |
3550 | #if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) | |
3551 | int len=sizeof(int); | |
3552 | WSADATA wsaData; | |
3553 | WSAStartup(2, &wsaData); | |
3554 | #else | |
3555 | socklen_t len=sizeof(socklen_t); | |
3556 | #endif | |
3557 | if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) return 1; | |
3558 | #if (defined(WIN32) || defined(__WIN32__) || defined(__WIN32)) && !(defined(__CYGWIN32__) || defined(__CYGWIN__)) | |
3559 | if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char *)&val, &len) < 0) return 1; | |
3560 | WSACleanup(); | |
3561 | #else | |
3562 | if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &val, &len) < 0) return 1; | |
3563 | #endif | |
3564 | if (val <= 0) return 1; | |
3565 | fp = fopen("conftestval", "w"); | |
3566 | fprintf (fp, "%d\n", val); | |
3567 | return 0; | |
3568 | } | |
3569 | ]])],[SQUID_TCP_SO_RCVBUF=`cat conftestval`],[SQUID_TCP_SO_RCVBUF=16384],[SQUID_TCP_SO_RCVBUF=16384]) | |
3570 | AC_MSG_RESULT($SQUID_TCP_SO_RCVBUF) | |
3571 | if test $SQUID_TCP_SO_RCVBUF -gt 65535; then | |
3572 | AC_MSG_NOTICE([Limiting receive buffer size to 64K]) | |
3573 | SQUID_TCP_SO_RCVBUF=65535 | |
3574 | fi | |
3575 | AC_DEFINE_UNQUOTED(SQUID_TCP_SO_RCVBUF, $SQUID_TCP_SO_RCVBUF,[TCP receive buffer size]) | |
3576 | AC_CACHE_CHECK(if sys_errlist is already defined, ac_cv_needs_sys_errlist, | |
3577 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>]], [[char *s = sys_errlist;]])],[ac_cv_needs_sys_errlist="no"],[ac_cv_needs_sys_errlist="yes"]) | |
3578 | ) | |
3579 | if test "$ac_cv_needs_sys_errlist" = "yes" ; then | |
3580 | AC_DEFINE(NEED_SYS_ERRLIST,1,[If we need to declare sys_errlist[] as external]) | |
3581 | fi | |
3582 | ||
3583 | dnl Hurd does not supply MAXPATHLEN. we may need to define it outselves. | |
3584 | dnl Other system define it in system headers | |
3585 | AC_CHECK_HEADERS([sys/param.h]) | |
3586 | AC_MSG_CHECKING(for MAXPATHLEN) | |
3587 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <sys/param.h>]],[[int i = MAXPATHLEN;]])],[AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no) | |
3588 | AC_DEFINE(MAXPATHLEN,256,[If MAXPATHLEN has not been defined])]) | |
3589 | ||
3590 | ||
3591 | dnl Not cached since people are likely to change this | |
3592 | AC_MSG_CHECKING(for libresolv _dns_ttl_ hack) | |
3593 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[extern int _dns_ttl_;]], [[return _dns_ttl_;]])],[AC_MSG_RESULT(yes) | |
3594 | AC_DEFINE(LIBRESOLV_DNS_TTL_HACK,1,[If libresolv.a has been hacked to export _dns_ttl_])],[AC_MSG_RESULT(no)]) | |
3595 | ||
3596 | if test "$ac_cv_header_sys_statvfs_h" = "yes" ; then | |
3597 | AC_MSG_CHECKING(for working statvfs() interface) | |
3598 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
3599 | #include <stdlib.h> | |
3600 | #include <stdio.h> | |
3601 | #include <sys/types.h> | |
3602 | #include <sys/statvfs.h> | |
3603 | ]], [[ | |
3604 | struct statvfs sfs; | |
3605 | sfs.f_blocks = sfs.f_bfree = sfs.f_frsize = | |
3606 | sfs.f_files = sfs.f_ffree = 0; | |
3607 | statvfs("/tmp", &sfs); | |
3608 | ]])],[ac_cv_func_statvfs=yes],[ac_cv_func_statvfs=no]) | |
3609 | AC_MSG_RESULT($ac_cv_func_statvfs) | |
3610 | if test "$ac_cv_func_statvfs" = "yes" ; then | |
3611 | AC_DEFINE(HAVE_STATVFS,1,[If your system has statvfs(), and if it actually works!]) | |
3612 | fi | |
3613 | fi | |
3614 | ||
3615 | dnl Detect what resolver fields we have available to use... | |
3616 | AC_CACHE_CHECK(for _res_ext.nsaddr_list, ac_cv_have_res_ext_nsaddr_list, | |
3617 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
3618 | #if HAVE_SYS_TYPES_H | |
3619 | #include <sys/types.h> | |
3620 | #endif | |
3621 | #if HAVE_NETINET_IN_H | |
3622 | #include <netinet/in.h> | |
3623 | #endif | |
3624 | #if HAVE_ARPA_INET_H | |
3625 | #include <arpa/inet.h> | |
3626 | #endif | |
3627 | #if HAVE_ARPA_NAMESER_H | |
3628 | #include <arpa/nameser.h> | |
3629 | #endif | |
3630 | #if HAVE_RESOLV_H | |
3631 | #include <resolv.h> | |
3632 | #endif | |
3633 | ]], [[_res_ext.nsaddr_list[[0]].s_addr;]])],[ac_cv_have_res_ext_nsaddr_list="yes"],[ac_cv_have_res_ext_nsaddr_list="no"])) | |
3634 | if test "$ac_cv_have_res_ext_nsaddr_list" = "yes" ; then | |
3635 | AC_DEFINE(_SQUID_RES_NSADDR6_LARRAY,_res_ext.nsaddr_list,[If _res_ext structure has nsaddr_list member]) | |
3636 | AC_DEFINE(_SQUID_RES_NSADDR6_COUNT,ns6count,[Nameserver Counter for IPv6 _res_ext]) | |
3637 | fi | |
3638 | ||
3639 | if test "$_SQUID_RES_NSADDR6_LIST" = ""; then | |
3640 | AC_CACHE_CHECK(for _res._u._ext.nsaddrs, ac_cv_have_res_ext_nsaddrs, | |
3641 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
3642 | #if HAVE_SYS_TYPES_H | |
3643 | #include <sys/types.h> | |
3644 | #endif | |
3645 | #if HAVE_NETINET_IN_H | |
3646 | #include <netinet/in.h> | |
3647 | #endif | |
3648 | #if HAVE_ARPA_INET_H | |
3649 | #include <arpa/inet.h> | |
3650 | #endif | |
3651 | #if HAVE_ARPA_NAMESER_H | |
3652 | #include <arpa/nameser.h> | |
3653 | #endif | |
3654 | #if HAVE_RESOLV_H | |
3655 | #include <resolv.h> | |
3656 | #endif | |
3657 | ]], [[_res._u._ext.nsaddrs[[0]]->sin6_addr;]])],[ac_cv_have_res_ext_nsaddrs="yes"],[ac_cv_have_res_ext_nsaddrs="no"])) | |
3658 | if test "$ac_cv_have_res_ext_nsaddrs" = "yes" ; then | |
3659 | AC_DEFINE(_SQUID_RES_NSADDR6_LPTR,_res._u._ext.nsaddrs,[If _res structure has _ext.nsaddrs member]) | |
3660 | AC_DEFINE(_SQUID_RES_NSADDR6_COUNT,_res._u._ext.nscount6,[Nameserver Counter for IPv6 _res]) | |
3661 | fi | |
3662 | fi | |
3663 | ||
3664 | AC_CACHE_CHECK(for _res.nsaddr_list, ac_cv_have_res_nsaddr_list, | |
3665 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
3666 | #if HAVE_SYS_TYPES_H | |
3667 | #include <sys/types.h> | |
3668 | #endif | |
3669 | #if HAVE_NETINET_IN_H | |
3670 | #include <netinet/in.h> | |
3671 | #endif | |
3672 | #if HAVE_ARPA_INET_H | |
3673 | #include <arpa/inet.h> | |
3674 | #endif | |
3675 | #if HAVE_ARPA_NAMESER_H | |
3676 | #include <arpa/nameser.h> | |
3677 | #endif | |
3678 | #if HAVE_RESOLV_H | |
3679 | #include <resolv.h> | |
3680 | #endif | |
3681 | ]], [[_res.nsaddr_list[[0]];]])],[ac_cv_have_res_nsaddr_list="yes"],[ac_cv_have_res_nsaddr_list="no"])) | |
3682 | if test $ac_cv_have_res_nsaddr_list = "yes" ; then | |
3683 | AC_DEFINE(_SQUID_RES_NSADDR_LIST,_res.nsaddr_list,[If _res structure has nsaddr_list member]) | |
3684 | AC_DEFINE(_SQUID_RES_NSADDR_COUNT,_res.nscount,[Nameserver counter for IPv4 _res]) | |
3685 | fi | |
3686 | ||
3687 | if test "$_SQUID_RES_NSADDR_LIST" = ""; then | |
3688 | AC_CACHE_CHECK(for _res.ns_list, ac_cv_have_res_ns_list, | |
3689 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
3690 | #if HAVE_SYS_TYPES_H | |
3691 | #include <sys/types.h> | |
3692 | #endif | |
3693 | #if HAVE_NETINET_IN_H | |
3694 | #include <netinet/in.h> | |
3695 | #endif | |
3696 | #if HAVE_ARPA_INET_H | |
3697 | #include <arpa/inet.h> | |
3698 | #endif | |
3699 | #if HAVE_ARPA_NAMESER_H | |
3700 | #include <arpa/nameser.h> | |
3701 | #endif | |
3702 | #if HAVE_RESOLV_H | |
3703 | #include <resolv.h> | |
3704 | #endif | |
3705 | ]], [[_res.ns_list[[0]].addr;]])],[ac_cv_have_res_ns_list="yes"],[ac_cv_have_res_ns_list="no"])) | |
3706 | if test $ac_cv_have_res_ns_list = "yes" ; then | |
3707 | AC_DEFINE(_SQUID_RES_NSADDR_LIST,_res.ns_list,[If _res structure has ns_list member]) | |
3708 | AC_DEFINE(_SQUID_RES_NSADDR_COUNT,_res.nscount,[Nameserver counter for IPv4 _res]) | |
3709 | fi | |
3710 | fi | |
3711 | ||
3712 | dnl Squid will usually attempt to translate when packaging or building from VCS | |
3713 | use_translation="yes" | |
3714 | AC_ARG_ENABLE(translation, | |
3715 | AS_HELP_STRING([--disable-translation],[Prevent Squid generating localized error page templates and manuals. | |
3716 | Which is usually tried, but may not be needed.]), | |
3717 | [ if test "$enableval" = "no" ; then | |
3718 | use_translation=no | |
3719 | fi | |
3720 | ]) | |
3721 | dnl Squid now has .po translation capability, given the right toolkit | |
3722 | if test "$use_translation" = "yes" ; then | |
3723 | AX_WITH_PROG([PO2HTML],[po2html]) | |
3724 | else | |
3725 | PO2HTML="off" | |
3726 | fi | |
3727 | AC_SUBST(PO2HTML) | |
3728 | ||
3729 | dnl Squid now has limited locale handling ... | |
3730 | dnl on error pages | |
3731 | use_errlocale=yes | |
3732 | AC_ARG_ENABLE(auto-locale, | |
3733 | AS_HELP_STRING([--disable-auto-locale],[This prevents Squid providing localized error pages based on the | |
3734 | clients request headers. | |
3735 | When disabled Squid requires explicit language configuration.]), | |
3736 | [ if test "$enableval" = "no" ; then | |
3737 | use_errlocale=no | |
3738 | fi | |
3739 | ]) | |
3740 | if test "$use_errlocale" = "yes" ; then | |
3741 | AC_MSG_NOTICE([Enabling Multi-Language Support]) | |
3742 | AC_DEFINE(USE_ERR_LOCALES,1,[Use multi-language support on error pages]) | |
3743 | else | |
3744 | AC_MSG_WARN([Disabling Multi-Language Support]) | |
3745 | AC_DEFINE(USE_ERR_LOCALES,0,[Use multi-language support on error pages]) | |
3746 | fi | |
3747 | ||
3748 | dnl Need the debugging version of malloc if available | |
3749 | XTRA_OBJS='' | |
3750 | if test "$ac_cv_lib_malloc_main" = "yes" ; then | |
3751 | if test -r /usr/lib/debug/malloc.o ; then | |
3752 | XTRA_OBJS="$XTRA_OBJS /usr/lib/debug/malloc.o" | |
3753 | fi | |
3754 | if test -r /usr/lib/debug/mallocmap.o ; then | |
3755 | XTRA_OBJS="$XTRA_OBJS /usr/lib/debug/mallocmap.o" | |
3756 | fi | |
3757 | fi | |
3758 | AC_SUBST(XTRA_OBJS) | |
3759 | ||
3760 | if test -z "$XTRA_LIBS"; then | |
3761 | XTRA_LIBS="$LIBS" | |
3762 | dnl minor cleanup | |
3763 | XTRA_LIBS=`echo $XTRA_LIBS | sed -e "s/ */ /g"` | |
3764 | LIBS='' | |
3765 | fi | |
3766 | AC_SUBST(XTRA_LIBS) | |
3767 | ||
3768 | dnl Clean up after OSF/1 core dump bug | |
3769 | rm -f core | |
3770 | ||
3771 | AC_CONFIG_FILES([\ | |
3772 | Makefile \ | |
3773 | compat/Makefile \ | |
3774 | lib/Makefile \ | |
3775 | scripts/Makefile \ | |
3776 | src/Makefile \ | |
3777 | src/base/Makefile \ | |
3778 | src/acl/Makefile \ | |
3779 | src/fs/Makefile \ | |
3780 | src/repl/Makefile \ | |
3781 | src/auth/Makefile \ | |
3782 | src/adaptation/Makefile \ | |
3783 | src/adaptation/icap/Makefile \ | |
3784 | src/adaptation/ecap/Makefile \ | |
3785 | src/comm/Makefile \ | |
3786 | src/esi/Makefile \ | |
3787 | src/eui/Makefile \ | |
3788 | src/icmp/Makefile \ | |
3789 | src/ident/Makefile \ | |
3790 | src/ip/Makefile \ | |
3791 | src/log/Makefile \ | |
3792 | contrib/Makefile \ | |
3793 | snmplib/Makefile \ | |
3794 | icons/Makefile \ | |
3795 | errors/Makefile \ | |
3796 | test-suite/Makefile \ | |
3797 | doc/Makefile \ | |
3798 | doc/manuals/Makefile \ | |
3799 | helpers/Makefile \ | |
3800 | helpers/basic_auth/Makefile \ | |
3801 | helpers/basic_auth/DB/Makefile \ | |
3802 | helpers/basic_auth/getpwnam/Makefile \ | |
3803 | helpers/basic_auth/LDAP/Makefile \ | |
3804 | helpers/basic_auth/MSNT/Makefile \ | |
3805 | helpers/basic_auth/MSNT-multi-domain/Makefile \ | |
3806 | helpers/basic_auth/NCSA/Makefile \ | |
3807 | helpers/basic_auth/NIS/Makefile \ | |
3808 | helpers/basic_auth/PAM/Makefile \ | |
3809 | helpers/basic_auth/POP3/Makefile \ | |
3810 | helpers/basic_auth/RADIUS/Makefile \ | |
3811 | helpers/basic_auth/SASL/Makefile \ | |
3812 | helpers/basic_auth/SMB/Makefile \ | |
3813 | helpers/basic_auth/SSPI/Makefile \ | |
3814 | helpers/digest_auth/Makefile \ | |
3815 | helpers/digest_auth/eDirectory/Makefile \ | |
3816 | helpers/digest_auth/file/Makefile \ | |
3817 | helpers/digest_auth/ldap/Makefile \ | |
3818 | helpers/ntlm_auth/Makefile \ | |
3819 | helpers/ntlm_auth/fake/Makefile \ | |
3820 | helpers/ntlm_auth/smb_lm/Makefile \ | |
3821 | helpers/ntlm_auth/smb_lm/smbval/Makefile \ | |
3822 | helpers/ntlm_auth/mswin_sspi/Makefile \ | |
3823 | helpers/negotiate_auth/Makefile \ | |
3824 | helpers/negotiate_auth/kerberos/Makefile \ | |
3825 | helpers/negotiate_auth/mswin_sspi/Makefile \ | |
3826 | helpers/external_acl/Makefile \ | |
3827 | helpers/external_acl/ip_user/Makefile \ | |
3828 | helpers/external_acl/ldap_group/Makefile \ | |
3829 | helpers/external_acl/session/Makefile \ | |
3830 | helpers/external_acl/unix_group/Makefile \ | |
3831 | helpers/external_acl/wbinfo_group/Makefile \ | |
3832 | helpers/external_acl/mswin_ad_group/Makefile \ | |
3833 | helpers/external_acl/mswin_lm_group/Makefile \ | |
3834 | helpers/log_daemon/Makefile \ | |
3835 | helpers/log_daemon/file/Makefile \ | |
3836 | helpers/url_rewrite/Makefile \ | |
3837 | helpers/url_rewrite/fake/Makefile \ | |
3838 | tools/Makefile | |
3839 | ]) | |
3840 | ||
3841 | AC_CONFIG_SUBDIRS(lib/libTrie) | |
3842 | ||
3843 | # must configure libltdl subdir unconditionally for "make distcheck" to work | |
3844 | AC_CONFIG_SUBDIRS(libltdl) | |
3845 | ||
3846 | AC_OUTPUT |