| dnl |
| dnl Autoconf configuration file for APR |
| dnl |
| dnl Process this file with autoconf to produce a configure script. |
| dnl Use ./buildconf to prepare build files and run autoconf for APR. |
| |
| AC_PREREQ(2.59) |
| |
| AC_INIT(build/apr_common.m4) |
| AC_CONFIG_HEADER(include/arch/unix/apr_private.h) |
| AC_CONFIG_AUX_DIR(build) |
| AC_CONFIG_MACRO_DIR(build) |
| |
| dnl |
| dnl Include our own M4 macros along with those for libtool |
| dnl |
| sinclude(build/apr_common.m4) |
| sinclude(build/apr_network.m4) |
| sinclude(build/apr_threads.m4) |
| sinclude(build/apr_win32.m4) |
| sinclude(build/apr_hints.m4) |
| sinclude(build/libtool.m4) |
| sinclude(build/ltsugar.m4) |
| sinclude(build/argz.m4) |
| sinclude(build/ltoptions.m4) |
| sinclude(build/ltversion.m4) |
| sinclude(build/lt~obsolete.m4) |
| |
| sinclude(build/apu-conf.m4) |
| sinclude(build/xml.m4) |
| sinclude(build/apu-hints.m4) |
| sinclude(build/crypto.m4) |
| sinclude(build/dbm.m4) |
| sinclude(build/dbd.m4) |
| sinclude(build/dso.m4) |
| sinclude(build/iconv.m4) |
| |
| sinclude(build/ax_prog_cc_for_build.m4) |
| |
| dnl Hard-coded top of apr_private.h: |
| AH_TOP([ |
| #ifndef APR_PRIVATE_H |
| #define APR_PRIVATE_H |
| |
| /* Pick up publicly advertised headers and symbols before the |
| * APR internal private headers and symbols |
| */ |
| #include <apr.h> |
| ]) |
| |
| dnl Hard-coded inclusion at the tail end of apr_private.h: |
| AH_BOTTOM([ |
| /* switch this on if we have a BeOS version below BONE */ |
| #if defined(BEOS) && !defined(HAVE_BONE_VERSION) |
| #define BEOS_R5 1 |
| #else |
| #define BEOS_BONE 1 |
| #endif |
| |
| /* |
| * Darwin 10's default compiler (gcc42) builds for both 64 and |
| * 32 bit architectures unless specifically told not to. |
| * In those cases, we need to override types depending on how |
| * we're being built at compile time. |
| * NOTE: This is an ugly work-around for Darwin's |
| * concept of universal binaries, a single package |
| * (executable, lib, etc...) which contains both 32 |
| * and 64 bit versions. The issue is that if APR is |
| * built universally, if something else is compiled |
| * against it, some bit sizes will depend on whether |
| * it is 32 or 64 bit. This is determined by the __LP64__ |
| * flag. Since we need to support both, we have to |
| * handle OS X unqiuely. |
| */ |
| #ifdef DARWIN_10 |
| |
| #undef APR_OFF_T_STRFN |
| #undef APR_INT64_STRFN |
| #undef SIZEOF_LONG |
| #undef SIZEOF_SIZE_T |
| #undef SIZEOF_SSIZE_T |
| #undef SIZEOF_VOIDP |
| #undef SIZEOF_STRUCT_IOVEC |
| |
| #ifdef __LP64__ |
| #define APR_INT64_STRFN strtol |
| #define SIZEOF_LONG 8 |
| #define SIZEOF_SIZE_T 8 |
| #define SIZEOF_SSIZE_T 8 |
| #define SIZEOF_VOIDP 8 |
| #define SIZEOF_STRUCT_IOVEC 16 |
| #else |
| #define APR_INT64_STRFN strtoll |
| #define SIZEOF_LONG 4 |
| #define SIZEOF_SIZE_T 4 |
| #define SIZEOF_SSIZE_T 4 |
| #define SIZEOF_VOIDP 4 |
| #define SIZEOF_STRUCT_IOVEC 8 |
| #endif |
| |
| #undef APR_OFF_T_STRFN |
| #define APR_OFF_T_STRFN APR_INT64_STRFN |
| |
| |
| #undef SETPGRP_VOID |
| #ifdef __DARWIN_UNIX03 |
| #define SETPGRP_VOID 1 |
| #else |
| /* #undef SETPGRP_VOID */ |
| #endif |
| |
| #endif /* DARWIN_10 */ |
| |
| #endif /* APR_PRIVATE_H */ |
| ]) |
| |
| dnl Save user-defined environment settings for later restoration |
| dnl |
| APR_SAVE_THE_ENVIRONMENT(CPPFLAGS) |
| APR_SAVE_THE_ENVIRONMENT(CFLAGS) |
| APR_SAVE_THE_ENVIRONMENT(LDFLAGS) |
| APR_SAVE_THE_ENVIRONMENT(LIBS) |
| APR_SAVE_THE_ENVIRONMENT(INCLUDES) |
| |
| dnl Generate ./config.nice for reproducing runs of configure |
| dnl |
| APR_CONFIG_NICE(config.nice) |
| |
| AC_CANONICAL_SYSTEM |
| AC_MSG_NOTICE([Configuring APR library]) |
| AC_MSG_NOTICE([Platform: $host]) |
| |
| dnl Some initial steps for configuration. We setup the default directory |
| dnl and which files are to be configured. |
| |
| dnl Setup the directory macros now |
| |
| # Absolute source/build directory |
| apr_srcdir=`(cd $srcdir && pwd)` |
| apr_builddir=`pwd` |
| AC_SUBST(apr_srcdir) |
| AC_SUBST(apr_builddir) |
| |
| if test "$apr_builddir" != "$apr_srcdir"; then |
| USE_VPATH=1 |
| APR_CONFIG_LOCATION=build |
| else |
| APR_CONFIG_LOCATION=source |
| fi |
| |
| AC_SUBST(APR_CONFIG_LOCATION) |
| |
| # Libtool might need this symbol -- it must point to the location of |
| # the generated libtool script (not necessarily the "top" build dir). |
| # |
| top_builddir="$apr_builddir" |
| AC_SUBST(top_builddir) |
| |
| # Directory containing apr build macros, helpers, and make rules |
| # NOTE: make rules (apr_rules.mk) will be in the builddir for vpath |
| # |
| apr_buildout=$apr_builddir/build |
| apr_builders=$apr_srcdir/build |
| AC_SUBST(apr_builders) |
| |
| MKDIR=$apr_builders/mkdir.sh |
| |
| dnl Initialize mkdir -p functionality. |
| APR_MKDIR_P_CHECK($apr_builders/mkdir.sh) |
| |
| # get our version information |
| get_version="$apr_builders/get-version.sh" |
| version_hdr="$apr_srcdir/include/apr_version.h" |
| APR_MAJOR_VERSION="`$get_version major $version_hdr APR`" |
| APR_DOTTED_VERSION="`$get_version all $version_hdr APR`" |
| |
| AC_SUBST(APR_DOTTED_VERSION) |
| AC_SUBST(APR_MAJOR_VERSION) |
| |
| AC_MSG_NOTICE([APR Version: ${APR_DOTTED_VERSION}]) |
| |
| dnl Enable the layout handling code, then reparse the prefix-style |
| dnl arguments due to autoconf being a PITA. |
| APR_ENABLE_LAYOUT(apr) |
| dnl This must be synchronized to the prefix of the apr layout, to make |
| dnl configure --help print the correct default. |
| AC_PREFIX_DEFAULT([/usr/local/apr]) |
| APR_PARSE_ARGUMENTS |
| |
| dnl Set optional CC hints here in case autoconf makes an inappropriate choice. |
| dnl This allows us to suggest what the compiler should be, but still |
| dnl allows the user to override CC externally. |
| APR_CC_HINTS |
| |
| dnl Do the various CC checks *before* preloading values. The preload code |
| dnl may need to use compiler characteristics to make decisions. This macro |
| dnl can only be used once within a configure script, so this prevents a |
| dnl preload section from invoking the macro to get compiler info. |
| AC_PROG_CC |
| |
| dnl Check build CC for gen_test_char compiling which is executed at build time. |
| AX_PROG_CC_FOR_BUILD |
| |
| dnl AC_PROG_SED is only avaliable in recent autoconf versions. |
| dnl Use AC_CHECK_PROG instead if AC_PROG_SED is not present. |
| ifdef([AC_PROG_SED], |
| [AC_PROG_SED], |
| [AC_CHECK_PROG(SED, sed, sed)]) |
| |
| dnl Preload |
| APR_PRELOAD |
| |
| dnl These added to allow default directories to be used... |
| DEFAULT_OSDIR="unix" |
| AC_MSG_NOTICE([(Default will be ${DEFAULT_OSDIR})]) |
| |
| apr_modules="file_io network_io threadproc misc locks time mmap shmem user memory atomic poll support random" |
| |
| dnl Checks for programs. |
| AC_PROG_MAKE_SET |
| AC_PROG_CPP |
| AC_PROG_AWK |
| AC_PROG_LN_S |
| AC_PROG_RANLIB |
| AC_PROG_INSTALL |
| AC_CHECK_PROG(RM, rm, rm) |
| AC_CHECK_TOOL(AS, as, as) |
| AC_CHECK_TOOL(ASCPP, cpp, cpp) |
| AC_CHECK_TOOL(AR, ar, ar) |
| |
| dnl Various OS checks that apparently set required flags |
| ifdef([AC_USE_SYSTEM_EXTENSIONS], [ |
| AC_USE_SYSTEM_EXTENSIONS |
| ], [ |
| AC_AIX |
| AC_MINIX |
| ]) |
| |
| AC_ISC_POSIX |
| APR_EBCDIC |
| |
| dnl this is our library name |
| APR_LIBNAME="apr${libsuffix}" |
| AC_SUBST(APR_LIBNAME) |
| |
| dnl prep libtool |
| dnl |
| AC_MSG_NOTICE([performing libtool configuration...]) |
| |
| AC_ARG_ENABLE(experimental-libtool,[ --enable-experimental-libtool Use experimental custom libtool], |
| [experimental_libtool=$enableval],[experimental_libtool=no]) |
| |
| dnl Workarounds for busted Libtool 2.x when we don't call AC_PROG_LIBTOOL |
| if test "x$Xsed" = "x"; then |
| Xsed="$SED -e 1s/^X//" |
| fi |
| |
| case $host in |
| *-os2*) |
| # Use a custom-made libtool replacement |
| AC_MSG_NOTICE([using aplibtool]) |
| LIBTOOL="$apr_builddir/build/aplibtool" |
| LIBTOOL_SRC="$apr_srcdir/build/aplibtool.c" |
| $CC $CFLAGS $CPPFLAGS -o $LIBTOOL.exe $LIBTOOL_SRC |
| ;; |
| *) |
| if test "x$LTFLAGS" = "x"; then |
| LTFLAGS='--silent' |
| fi |
| if test "$experimental_libtool" = "yes"; then |
| # Use a custom-made libtool replacement |
| AC_MSG_NOTICE([using jlibtool]) |
| LIBTOOL="$apr_builddir/libtool" |
| LIBTOOL_SRC="$apr_srcdir/build/jlibtool.c" |
| $CC $CFLAGS $CPPFLAGS -o $LIBTOOL $LIBTOOL_SRC |
| eval `$apr_builddir/libtool --config | grep "^shlibpath_var=[[A-Z_]]*$"` |
| if test "x$shlibpath_var" = "x"; then |
| shlibpath_var=REPLACE_WITH_YOUR_SHLIBPATH_VAR |
| fi |
| else |
| dnl libtoolize requires that the following not be indented |
| dnl should become LT_INIT(win32-dll) |
| AC_LIBTOOL_WIN32_DLL |
| AC_PROG_LIBTOOL |
| # get libtool's setting of shlibpath_var |
| if test "x$shlibpath_var" = "x"; then |
| eval `grep "^shlibpath_var=[[A-Z_]]*$" $apr_builddir/libtool` |
| fi |
| if test "x$shlibpath_var" = "x"; then |
| AC_MSG_NOTICE([SHLIBPATH variable could not be determined]) |
| shlibpath_var=REPLACE_WITH_YOUR_SHLIBPATH_VAR |
| fi |
| fi |
| ;; |
| esac |
| |
| AC_ARG_WITH(installbuilddir, [ --with-installbuilddir=DIR location to store APR build files], |
| [ installbuilddir=$withval ] ) |
| AC_SUBST(installbuilddir) |
| |
| AC_ARG_WITH(libtool, [ --without-libtool avoid using libtool to link the library], |
| [ use_libtool=$withval ], [ use_libtool="yes" ] ) |
| |
| if test "x$use_libtool" = "xyes"; then |
| lt_compile='$(LIBTOOL) $(LTFLAGS) --mode=compile --tag=CC $(COMPILE) -o $@ -c $< && touch $@' |
| LT_VERSION="-version-info `$get_version libtool $version_hdr APR`" |
| link="\$(LIBTOOL) \$(LTFLAGS) --mode=link --tag=CC \$(COMPILE) \$(LT_LDFLAGS) \$(LT_VERSION) \$(ALL_LDFLAGS) -o \$@" |
| so_ext='lo' |
| lib_target='-rpath $(libdir) $(OBJECTS)' |
| export_lib_target='-rpath \$(libdir) \$(OBJECTS)' |
| else |
| lt_compile='$(COMPILE) -o $@ -c $<' |
| link='$(AR) cr $(TARGET_LIB) $(OBJECTS); $(RANLIB) $(TARGET_LIB)' |
| so_ext='o' |
| lib_target='' |
| export_lib_target='' |
| fi |
| |
| case $host in |
| *-solaris2*) |
| apr_platform_runtime_link_flag="-R" |
| ;; |
| *-mingw* | *-cygwin*) |
| LT_LDFLAGS="$LT_LDFLAGS -no-undefined" |
| ;; |
| *) |
| ;; |
| esac |
| |
| AC_SUBST(lt_compile) |
| AC_SUBST(link) |
| AC_SUBST(so_ext) |
| AC_SUBST(lib_target) |
| AC_SUBST(export_lib_target) |
| AC_SUBST(shlibpath_var) |
| AC_SUBST(LTFLAGS) |
| AC_SUBST(LT_LDFLAGS) |
| AC_SUBST(LT_VERSION) |
| |
| dnl ----------------------------- Checks for compiler flags |
| nl=' |
| ' |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Check for compiler flags...]) |
| |
| dnl AC_PROG_CC sets -g in CFLAGS (and -O2 for gcc) by default. |
| dnl On OS/390 this causes the compiler to insert extra debugger |
| dnl hook instructions. That's fine for debug/maintainer builds, not fine |
| dnl otherwise. |
| |
| case $host in |
| *os390) |
| if test "$ac_test_CFLAGS" != set; then |
| APR_REMOVEFROM(CFLAGS,-g) |
| fi |
| ;; |
| esac |
| |
| AC_ARG_ENABLE(debug,[ --enable-debug Turn on debugging and compile time warnings], |
| [APR_ADDTO(CFLAGS,-g) |
| if test "$GCC" = "yes"; then |
| APR_ADDTO(CFLAGS,-Wall) |
| elif test "$AIX_XLC" = "yes"; then |
| APR_ADDTO(CFLAGS,-qfullpath) |
| fi |
| ])dnl |
| |
| AC_ARG_ENABLE(maintainer-mode,[ --enable-maintainer-mode Turn on debugging and compile time warnings], |
| [APR_ADDTO(CFLAGS,-g) |
| if test "$GCC" = "yes"; then |
| APR_ADDTO(CFLAGS,[-Wall -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations]) |
| case `($CC --version) 2>/dev/null` in |
| *clang-900* | *"clang version 5.0.0"*) |
| APR_ADDTO(CFLAGS,[-Wno-error=strict-prototypes]) |
| ;; |
| esac |
| elif test "$AIX_XLC" = "yes"; then |
| APR_ADDTO(CFLAGS,-qfullpath -qinitauto=FE -qcheck=all -qinfo=pro) |
| fi |
| ])dnl |
| |
| AC_ARG_ENABLE(profile,[ --enable-profile Turn on profiling for the build (GCC)], |
| if test "$GCC" = "yes"; then |
| APR_ADDTO(CFLAGS, -pg) |
| APR_REMOVEFROM(CFLAGS, -g) |
| if test "$host" = "i586-pc-beos"; then |
| APR_REMOVEFROM(CFLAGS, -O2) |
| APR_ADDTO(CFLAGS, -O1) |
| APR_ADDTO(LDFLAGS, -p) |
| fi |
| fi |
| )dnl |
| |
| AC_ARG_ENABLE(pool-debug, |
| [ --enable-pool-debug[[=yes|no|verbose|verbose-alloc|lifetime|owner|all]] Turn on pools debugging], |
| [ if test -z "$enableval"; then |
| APR_ADDTO(CPPFLAGS, -DAPR_POOL_DEBUG=1) |
| elif test ! "$enableval" = "no"; then |
| apr_pool_debug=1 |
| |
| for i in $enableval |
| do |
| flag=0 |
| |
| case $i in |
| yes) |
| flag=1 |
| ;; |
| verbose) |
| flag=2 |
| ;; |
| lifetime) |
| flag=4 |
| ;; |
| owner) |
| flag=8 |
| ;; |
| verbose-alloc) |
| flag=16 |
| ;; |
| all) |
| apr_pool_debug=31 |
| ;; |
| *) |
| ;; |
| esac |
| |
| if test $flag -gt 0; then |
| apr_pool_debug=`expr '(' $apr_pool_debug - $apr_pool_debug % \ |
| '(' $flag '*' 2 ')' ')' + $flag + $apr_pool_debug % $flag` |
| fi |
| done |
| |
| APR_ADDTO(CPPFLAGS, -DAPR_POOL_DEBUG=$apr_pool_debug) |
| fi |
| ]) |
| |
| AC_ARG_ENABLE(thread-debug, |
| [ --enable-thread-debug Turn on run-time thread debugging tests], |
| [ if test $enableval = yes; then |
| APR_ADDTO(CPPFLAGS, [-DAPR_THREAD_DEBUG=1]) |
| fi |
| ]) |
| |
| if test "$host" = "i586-pc-beos"; then |
| AC_ARG_ENABLE(malloc-debug,[ --enable-malloc-debug Switch on malloc_debug for BeOS], |
| APR_REMOVEFROM(CFLAGS, -O2) |
| APR_ADDTO(CPPFLAGS, -fcheck-memory-usage -D_KERNEL_MODE) |
| ) dnl |
| fi |
| |
| # this is the place to put specific options for platform/compiler |
| # combinations |
| case "$host:$CC" in |
| *-hp-hpux*:cc ) |
| APR_ADDTO(CFLAGS,[-Ae +Z]) |
| case $host in |
| ia64-* ) |
| ;; |
| * ) |
| if echo "$CFLAGS " | grep '+DA' >/dev/null; then : |
| else |
| APR_ADDTO(CFLAGS,[+DAportable]) |
| fi |
| ;; |
| esac |
| ;; |
| powerpc-*-beos:mwcc* ) |
| APR_SETVAR(CPP,[mwcc -E]) |
| APR_SETVAR(CC,mwcc) |
| APR_SETVAR(AR,ar) |
| ;; |
| |
| dnl If building static APR, both the APR build and the app build |
| dnl need -DAPR_DECLARE_STATIC to generate the right linkage from |
| dnl APR_DECLARE et al. |
| dnl If building dynamic APR, the APR build needs APR_DECLARE_EXPORT |
| dnl and the app build should have neither define. |
| *-mingw* | *-cygwin*) |
| if test "$enable_shared" = "yes"; then |
| APR_ADDTO(INTERNAL_CPPFLAGS, -DAPR_DECLARE_EXPORT) |
| else |
| APR_ADDTO(CPPFLAGS, -DAPR_DECLARE_STATIC) |
| fi |
| ;; |
| esac |
| |
| AC_CACHE_CHECK([whether the compiler provides atomic builtins], [ap_cv_atomic_builtins], |
| [AC_TRY_RUN([ |
| int main() |
| { |
| unsigned long val = 1010, tmp, *mem = &val; |
| |
| if (__sync_fetch_and_add(&val, 1010) != 1010 || val != 2020) |
| return 1; |
| |
| tmp = val; |
| |
| if (__sync_fetch_and_sub(mem, 1010) != tmp || val != 1010) |
| return 1; |
| |
| if (__sync_sub_and_fetch(&val, 1010) != 0 || val != 0) |
| return 1; |
| |
| tmp = 3030; |
| |
| if (__sync_val_compare_and_swap(mem, 0, tmp) != 0 || val != tmp) |
| return 1; |
| |
| if (__sync_lock_test_and_set(&val, 4040) != 3030) |
| return 1; |
| |
| mem = &tmp; |
| |
| if (__sync_val_compare_and_swap(&mem, &tmp, &val) != &tmp) |
| return 1; |
| |
| __sync_synchronize(); |
| |
| if (mem != &val) |
| return 1; |
| |
| return 0; |
| }], [ap_cv_atomic_builtins=yes], [ap_cv_atomic_builtins=no], [ap_cv_atomic_builtins=no])]) |
| |
| if test "$ap_cv_atomic_builtins" = "yes"; then |
| AC_DEFINE(HAVE_ATOMIC_BUILTINS, 1, [Define if compiler provides atomic builtins]) |
| fi |
| |
| AC_CACHE_CHECK([whether the compiler handles weak symbols], [ap_cv_weak_symbols], |
| [AC_TRY_RUN([ |
| __attribute__ ((weak)) |
| int weak_noop(void) |
| { |
| return 0; |
| } |
| int main() |
| { |
| return weak_noop(); |
| }], [ap_cv_weak_symbols=yes], [ap_cv_weak_symbols=no], [ap_cv_weak_symbols=no])]) |
| |
| if test "$ap_cv_weak_symbols" = "yes"; then |
| AC_DEFINE(HAVE_WEAK_SYMBOLS, 1, [Define if compiler handles weak symbols]) |
| fi |
| |
| case $host in |
| powerpc-405-*) |
| # The IBM ppc405cr processor has a bugged stwcx instruction. |
| AC_DEFINE(PPC405_ERRATA, 1, [Define on PowerPC 405 where errata 77 applies]) |
| ;; |
| *) |
| ;; |
| esac |
| |
| dnl Check the depend program we can use |
| APR_CHECK_DEPEND |
| |
| proc_mutex_is_global=0 |
| |
| config_subdirs="none" |
| INSTALL_SUBDIRS="none" |
| OBJECTS_PLATFORM='$(OBJECTS_unix)' |
| |
| case $host in |
| i386-ibm-aix* | *-ibm-aix[[1-2]].* | *-ibm-aix3.* | *-ibm-aix4.1 | *-ibm-aix4.1.* | *-ibm-aix4.2 | *-ibm-aix4.2.*) |
| OSDIR="aix" |
| APR_ADDTO(LDFLAGS,-lld) |
| eolstr="\\n" |
| OBJECTS_PLATFORM='$(OBJECTS_aix)' |
| ;; |
| *-os2*) |
| APR_ADDTO(CPPFLAGS,-DOS2) |
| APR_ADDTO(CFLAGS,-Zmt) |
| AC_CHECK_LIB(bsd, random) |
| OSDIR="os2" |
| enable_threads="system_threads" |
| eolstr="\\r\\n" |
| file_as_socket="0" |
| proc_mutex_is_global=1 |
| OBJECTS_PLATFORM='$(OBJECTS_os2)' |
| ;; |
| *beos*) |
| OSDIR="beos" |
| APR_ADDTO(CPPFLAGS,-DBEOS) |
| enable_threads="system_threads" |
| native_mmap_emul="1" |
| APR_CHECK_DEFINE(BONE_VERSION, sys/socket.h) |
| eolstr="\\n" |
| osver=`uname -r` |
| proc_mutex_is_global=1 |
| OBJECTS_PLATFORM='$(OBJECTS_beos)' |
| case $osver in |
| 5.0.4) |
| file_as_socket="1" |
| ;; |
| *) |
| file_as_socket="0" |
| ;; |
| esac |
| ;; |
| *apple-darwin*) |
| ac_cv_func_fdatasync="no" # Mac OS X wrongly reports it has fdatasync() |
| OSDIR="unix" |
| eolstr="\\n" |
| ;; |
| *os390) |
| OSDIR="os390" |
| OBJECTS_PLATFORM='$(OBJECTS_os390)' |
| eolstr="\\n" |
| ;; |
| *os400) |
| OSDIR="as400" |
| eolstr="\\n" |
| ;; |
| *mingw*) |
| OSDIR="win32" |
| enable_threads="system_threads" |
| eolstr="\\r\\n" |
| file_as_socket=0 |
| proc_mutex_is_global=1 |
| OBJECTS_PLATFORM='$(OBJECTS_win32)' |
| ;; |
| *cygwin*) |
| OSDIR="unix" |
| enable_threads="no" |
| eolstr="\\n" |
| ;; |
| *hpux10* ) |
| enable_threads="no" |
| OSDIR="unix" |
| eolstr="\\n" |
| ;; |
| *) |
| OSDIR="unix" |
| eolstr="\\n" |
| ;; |
| esac |
| |
| AC_SUBST(OBJECTS_PLATFORM) |
| |
| # Check whether LFS has explicitly been disabled |
| AC_ARG_ENABLE(lfs,[ --disable-lfs Disable large file support on 32-bit platforms], |
| [apr_lfs_choice=$enableval], [apr_lfs_choice=yes]) |
| |
| if test "$apr_lfs_choice" = "yes"; then |
| # Check whether the transitional LFS API is sufficient |
| AC_CACHE_CHECK([whether to enable -D_LARGEFILE64_SOURCE], [apr_cv_use_lfs64], [ |
| apr_save_CPPFLAGS=$CPPFLAGS |
| CPPFLAGS="$CPPFLAGS -D_LARGEFILE64_SOURCE" |
| AC_TRY_RUN([ |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| |
| void main(void) |
| { |
| int fd, ret = 0; |
| struct stat64 st; |
| off64_t off = 4242; |
| |
| if (sizeof(off64_t) != 8 || sizeof(off_t) != 4) |
| exit(1); |
| if ((fd = open("conftest.lfs", O_LARGEFILE|O_CREAT|O_WRONLY, 0644)) < 0) |
| exit(2); |
| if (ftruncate64(fd, off) != 0) |
| ret = 3; |
| else if (fstat64(fd, &st) != 0 || st.st_size != off) |
| ret = 4; |
| else if (lseek64(fd, off, SEEK_SET) != off) |
| ret = 5; |
| else if (close(fd) != 0) |
| ret = 6; |
| else if (lstat64("conftest.lfs", &st) != 0 || st.st_size != off) |
| ret = 7; |
| else if (stat64("conftest.lfs", &st) != 0 || st.st_size != off) |
| ret = 8; |
| unlink("conftest.lfs"); |
| |
| exit(ret); |
| }], [apr_cv_use_lfs64=yes], [apr_cv_use_lfs64=no], [apr_cv_use_lfs64=no]) |
| CPPFLAGS=$apr_save_CPPFLAGS]) |
| if test "$apr_cv_use_lfs64" = "yes"; then |
| APR_ADDTO(CPPFLAGS, [-D_LARGEFILE64_SOURCE]) |
| fi |
| fi |
| |
| AC_ARG_ENABLE(nonportable-atomics, |
| [ --enable-nonportable-atomics Use optimized atomic code which may produce nonportable binaries], |
| [if test $enableval = yes; then |
| force_generic_atomics=no |
| else |
| force_generic_atomics=yes |
| fi |
| ], |
| [case $host_cpu in |
| i[[456]]86) force_generic_atomics=yes ;; |
| *) force_generic_atomics=no |
| case $host in |
| *solaris2.10*) |
| AC_TRY_COMPILE( |
| [#include <atomic.h>], |
| [void *ptr = NULL; atomic_cas_ptr(&ptr, NULL, NULL);],, |
| [force_generic_atomics=yes] |
| ) |
| if test $force_generic_atomics = yes; then |
| AC_MSG_NOTICE([nonportable atomic support disabled, system needs Patch-ID 118884 or 118885]) |
| fi |
| ;; |
| esac |
| ;; |
| esac |
| ]) |
| |
| if test $force_generic_atomics = yes; then |
| AC_DEFINE([USE_ATOMICS_GENERIC], 1, |
| [Define if use of generic atomics is requested]) |
| fi |
| |
| AC_SUBST(proc_mutex_is_global) |
| AC_SUBST(eolstr) |
| AC_SUBST(INSTALL_SUBDIRS) |
| |
| # For some platforms we need a version string which allows easy numeric |
| # comparisons. |
| case $host in |
| *freebsd*) |
| if test -x /sbin/sysctl; then |
| os_version=`/sbin/sysctl -n kern.osreldate` |
| else |
| os_version=000000 |
| fi |
| ;; |
| *linux*) |
| os_major=[`uname -r | sed -e 's/\([1-9][0-9]*\)\..*/\1/'`] |
| os_minor=[`uname -r | sed -e 's/[1-9][0-9]*\.\([0-9]\+\)\..*/\1/'`] |
| if test $os_major -lt 2 -o \( $os_major -eq 2 -a $os_minor -lt 4 \); then |
| AC_MSG_WARN([Configured for pre-2.4 Linux $os_major.$os_minor]) |
| os_pre24linux=1 |
| else |
| os_pre24linux=0 |
| AC_MSG_NOTICE([Configured for Linux $os_major.$os_minor]) |
| fi |
| ;; |
| *os390) |
| os_version=`uname -r | sed -e 's/\.//g'` |
| ;; |
| *) |
| os_version=OS_VERSION_IS_NOT_SET |
| ;; |
| esac |
| |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for libraries...]) |
| |
| dnl ----------------------------- Checks for Any required Libraries |
| dnl Note: Autoconf will always append LIBS with an extra " " in AC_CHECK_LIB. |
| dnl It should check for LIBS being empty and set LIBS equal to the new value |
| dnl without the extra " " in that case, but they didn't do that. So, we |
| dnl end up LIBS="-lm -lcrypt -lnsl -ldl" which is an annoyance. |
| case $host in |
| *-mingw*) |
| APR_ADDTO(LIBS,[-lshell32 -ladvapi32 -lws2_32 -lrpcrt4 -lmswsock]) |
| ac_cv_func_CreateFileMapping=yes |
| ;; |
| *) |
| AC_SEARCH_LIBS(gethostbyname, nsl) |
| AC_SEARCH_LIBS(gethostname, nsl) |
| AC_SEARCH_LIBS(socket, socket) |
| AC_SEARCH_LIBS(crypt, crypt ufc) |
| AC_CHECK_LIB(truerand, main) |
| AC_SEARCH_LIBS(modf, m) |
| ;; |
| esac |
| |
| dnl ----------------------------- Checking for Threads |
| AC_MSG_NOTICE([${nl}Checking for Threads...]) |
| |
| if test -z "$enable_threads"; then |
| AC_ARG_ENABLE(threads, |
| [ --enable-threads Enable threading support in APR.], |
| [ enable_threads=$enableval] , |
| [ APR_CHECK_PTHREADS_H([ enable_threads="pthread" ] , |
| [ enable_threads="no" ] ) ] ) |
| fi |
| |
| if test "$enable_threads" = "no"; then |
| threads="0" |
| pthreadh="0" |
| pthreadser="0" |
| else |
| if test "$enable_threads" = "pthread"; then |
| # We have specified pthreads for our threading library, just make sure |
| # that we have everything we need |
| APR_PTHREADS_CHECK_SAVE |
| APR_PTHREADS_CHECK |
| APR_CHECK_PTHREADS_H([ |
| threads="1" |
| pthreadh="1" |
| pthreadser="1" ], [ |
| threads="0" |
| pthreadh="0" |
| pthreadser="0" |
| APR_PTHREADS_CHECK_RESTORE ] ) |
| elif test "$enable_threads" = "system_threads"; then |
| threads="1" |
| pthreadh="0" |
| pthreadser="0" |
| else |
| # We basically specified that we wanted threads, but not how to implement |
| # them. In this case, just look for pthreads. In the future, we can check |
| # for other threading libraries as well. |
| APR_PTHREADS_CHECK_SAVE |
| APR_PTHREADS_CHECK |
| APR_CHECK_PTHREADS_H([ |
| threads="1" |
| pthreadh="1" |
| pthreadser="1" ], [ |
| threads="0" |
| pthreadser="0" |
| pthreadh="0" |
| APR_PTHREADS_CHECK_RESTORE ] ) |
| fi |
| if test "$pthreadh" = "1"; then |
| APR_CHECK_PTHREAD_GETSPECIFIC_TWO_ARGS |
| APR_CHECK_PTHREAD_ATTR_GETDETACHSTATE_ONE_ARG |
| APR_CHECK_PTHREAD_RECURSIVE_MUTEX |
| AC_CHECK_FUNCS([pthread_key_delete pthread_rwlock_init \ |
| pthread_attr_setguardsize pthread_yield]) |
| |
| if test "$ac_cv_func_pthread_rwlock_init" = "yes"; then |
| dnl ----------------------------- Checking for pthread_rwlock_t |
| AC_CACHE_CHECK([for pthread_rwlock_t], [apr_cv_type_rwlock_t], |
| AC_TRY_COMPILE([#include <sys/types.h> |
| #include <pthread.h>], [pthread_rwlock_t *rwlock;], |
| [apr_cv_type_rwlock_t=yes], [apr_cv_type_rwlock_t=no], |
| [apr_cv_type_rwlock_t=no])) |
| if test "$apr_cv_type_rwlock_t" = "yes"; then |
| AC_DEFINE(HAVE_PTHREAD_RWLOCKS, 1, [Define if pthread rwlocks are available]) |
| fi |
| fi |
| |
| if test "$ac_cv_func_pthread_yield" = "no"; then |
| dnl ----------------------------- Checking for sched_yield |
| AC_CHECK_HEADERS([sched.h]) |
| AC_CHECK_FUNCS([sched_yield]) |
| fi |
| fi |
| fi |
| |
| ac_cv_define_READDIR_IS_THREAD_SAFE=yes |
| ac_cv_define_GETHOSTBYNAME_IS_THREAD_SAFE=no |
| ac_cv_define_GETHOSTBYADDR_IS_THREAD_SAFE=no |
| ac_cv_define_GETSERVBYNAME_IS_THREAD_SAFE=no |
| if test "$threads" = "1"; then |
| AC_MSG_NOTICE([APR will use threads]) |
| AC_DEFINE(READDIR_IS_THREAD_SAFE, 1, [Modern readdir is thread safe]) |
| if test "x$apr_gethostbyname_is_thread_safe" = "x"; then |
| AC_CHECK_LIB(c_r, gethostbyname, apr_gethostbyname_is_thread_safe=yes) |
| fi |
| if test "$apr_gethostbyname_is_thread_safe" = "yes"; then |
| AC_DEFINE(GETHOSTBYNAME_IS_THREAD_SAFE, 1, |
| [Define if gethostbyname is thread safe]) |
| fi |
| if test "x$apr_gethostbyaddr_is_thread_safe" = "x"; then |
| AC_CHECK_LIB(c_r, gethostbyaddr, apr_gethostbyaddr_is_thread_safe=yes) |
| fi |
| if test "$apr_gethostbyaddr_is_thread_safe" = "yes"; then |
| AC_DEFINE(GETHOSTBYADDR_IS_THREAD_SAFE, 1, |
| [Define if gethostbyaddr is thread safe]) |
| fi |
| if test "x$apr_getservbyname_is_thread_safe" = "x"; then |
| AC_CHECK_LIB(c_r, getservbyname, apr_getservbyname_is_thread_safe=yes) |
| fi |
| if test "$apr_getservbyname_is_thread_safe" = "yes"; then |
| AC_DEFINE(GETSERVBYNAME_IS_THREAD_SAFE, 1, |
| [Define if getservbyname is thread safe]) |
| fi |
| AC_CHECK_FUNCS(gethostbyname_r gethostbyaddr_r getservbyname_r) |
| else |
| AC_MSG_NOTICE([APR will be non-threaded]) |
| fi |
| |
| dnl Electric Fence malloc checker. |
| dnl --with-efence specifies the path to Electric Fence. |
| dnl This test should remain after the threads checks since libefence |
| dnl may depend on libpthread. |
| AC_ARG_WITH(efence, |
| [ --with-efence[[=DIR]] path to Electric Fence installation], |
| [ apr_efence_dir="$withval" |
| if test "$apr_efence_dir" != "yes"; then |
| APR_ADDTO(LDFLAGS,[-L$apr_efence_dir/lib]) |
| if test "x$apr_platform_runtime_link_flag" != "x"; then |
| APR_ADDTO(LDFLAGS, |
| [$apr_platform_runtime_link_flag$apr_efence_dir/lib]) |
| fi |
| fi |
| AC_CHECK_LIB(efence, malloc, |
| [ APR_ADDTO(LIBS,-lefence) ], |
| [ AC_MSG_ERROR(Electric Fence requested but not detected) ]) |
| ]) |
| |
| AC_ARG_WITH(valgrind, |
| [ --with-valgrind[[=DIR]] Enable code to teach valgrind about apr pools |
| (optionally: set path to valgrind headers) ], |
| [ if test "$withval" != no; then |
| if test "$withval" = yes; then |
| withval=/usr/include/valgrind |
| fi |
| APR_ADDTO(CPPFLAGS, -I$withval) |
| AC_CHECK_HEADERS(valgrind.h memcheck.h) |
| APR_IFALLYES(header:valgrind.h header:memcheck.h, |
| [AC_DEFINE(HAVE_VALGRIND, 1, [Compile in valgrind support]) ], |
| [AC_MSG_ERROR(valgrind headers not found) ] |
| ) |
| fi ] |
| ) |
| |
| AC_CHECK_FUNCS(sigsuspend, [ have_sigsuspend="1" ], [ have_sigsuspend="0" ]) |
| AC_CHECK_FUNCS(sigwait, [ have_sigwait="1" ], [ have_sigwait="0" ]) |
| dnl AC_CHECK_FUNCS doesn't work for this on Tru64 since the function |
| dnl is renamed in signal.h. Todo: Autodetect |
| case $host in |
| *alpha*-dec-osf* ) |
| have_sigwait="1" |
| ;; |
| esac |
| |
| AC_SUBST(threads) |
| AC_SUBST(have_sigsuspend) |
| AC_SUBST(have_sigwait) |
| |
| AC_CHECK_FUNCS(poll kqueue port_create) |
| |
| # Check for the Linux epoll interface; epoll* may be available in libc |
| # but return ENOSYS on a pre-2.6 kernel, so do a run-time check. |
| AC_CACHE_CHECK([for epoll support], [apr_cv_epoll], |
| [AC_TRY_RUN([ |
| #include <sys/epoll.h> |
| #include <unistd.h> |
| |
| int main() |
| { |
| return epoll_create(5) == -1; |
| }], [apr_cv_epoll=yes], [apr_cv_epoll=no], [apr_cv_epoll=no])]) |
| |
| if test "$apr_cv_epoll" = "yes"; then |
| AC_DEFINE([HAVE_EPOLL], 1, [Define if the epoll interface is supported]) |
| fi |
| |
| dnl ----------------------------- Checking for extended file descriptor handling |
| # test for epoll_create1 |
| AC_CACHE_CHECK([for epoll_create1 support], [apr_cv_epoll_create1], |
| [AC_TRY_RUN([ |
| #include <sys/epoll.h> |
| #include <unistd.h> |
| |
| int main() |
| { |
| return epoll_create1(0) == -1; |
| }], [apr_cv_epoll_create1=yes], [apr_cv_epoll_create1=no], [apr_cv_epoll_create1=no])]) |
| |
| if test "$apr_cv_epoll_create1" = "yes"; then |
| AC_DEFINE([HAVE_EPOLL_CREATE1], 1, [Define if epoll_create1 function is supported]) |
| fi |
| |
| # Check for z/OS async i/o support. |
| AC_CACHE_CHECK([for asio -> message queue support], [apr_cv_aio_msgq], |
| [AC_TRY_RUN([ |
| #define _AIO_OS390 |
| #include <aio.h> |
| |
| int main() |
| { |
| struct aiocb a; |
| |
| a.aio_notifytype = AIO_MSGQ; /* use IPC message queue for notification */ |
| |
| return aio_cancel(2, NULL) == -1; |
| }], [apr_cv_aio_msgq=yes], [apr_cv_aio_msgq=no], [apr_cv_aio_msgq=no])]) |
| |
| if test "$apr_cv_aio_msgq" = "yes"; then |
| AC_DEFINE([HAVE_AIO_MSGQ], 1, [Define if async i/o supports message q's]) |
| fi |
| |
| # test for dup3 |
| AC_CACHE_CHECK([for dup3 support], [apr_cv_dup3], |
| [AC_TRY_RUN([ |
| #include <unistd.h> |
| |
| int main() |
| { |
| return dup3(STDOUT_FILENO, STDERR_FILENO, 0) == -1; |
| }], [apr_cv_dup3=yes], [apr_cv_dup3=no], [apr_cv_dup3=no])]) |
| |
| if test "$apr_cv_dup3" = "yes"; then |
| AC_DEFINE([HAVE_DUP3], 1, [Define if dup3 function is supported]) |
| fi |
| |
| # Test for accept4(). Create a non-blocking socket, bind it to |
| # an unspecified port & address (kernel picks), and attempt to |
| # call accept4() on it. If the syscall is wired up (i.e. the |
| # kernel is new enough), it should return EAGAIN. |
| AC_CACHE_CHECK([for accept4 support], [apr_cv_accept4], |
| [AC_TRY_RUN([ |
| #include <sys/types.h> |
| #include <sys/socket.h> |
| #include <sys/wait.h> |
| #include <netinet/in.h> |
| #include <netinet/tcp.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| |
| int main(int argc, char **argv) |
| { |
| int fd, flags; |
| struct sockaddr_in sin; |
| |
| if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) |
| return 1; |
| flags = fcntl(fd, F_GETFL); |
| if (flags == -1 || fcntl(fd, F_SETFL, flags|O_NONBLOCK) == -1) |
| return 5; |
| |
| memset(&sin, 0, sizeof sin); |
| sin.sin_family = AF_INET; |
| |
| if (bind(fd, (struct sockaddr *) &sin, sizeof sin) == -1) |
| return 2; |
| |
| if (listen(fd, 5) == -1) |
| return 3; |
| |
| if (accept4(fd, NULL, 0, SOCK_NONBLOCK) == 0 |
| || errno == EAGAIN || errno == EWOULDBLOCK) |
| return 0; |
| |
| return 4; |
| }], [apr_cv_accept4=yes], [apr_cv_accept4=no], [apr_cv_accept4=no])]) |
| |
| if test "$apr_cv_accept4" = "yes"; then |
| AC_DEFINE([HAVE_ACCEPT4], 1, [Define if accept4 function is supported]) |
| fi |
| |
| AC_CACHE_CHECK([for SOCK_CLOEXEC support], [apr_cv_sock_cloexec], |
| [AC_TRY_RUN([ |
| #include <sys/types.h> |
| #include <sys/socket.h> |
| |
| int main() |
| { |
| return socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC, 0) == -1; |
| }], [apr_cv_sock_cloexec=yes], [apr_cv_sock_cloexec=no], [apr_cv_sock_cloexec=no])]) |
| |
| if test "$apr_cv_sock_cloexec" = "yes"; then |
| AC_DEFINE([HAVE_SOCK_CLOEXEC], 1, [Define if the SOCK_CLOEXEC flag is supported]) |
| fi |
| |
| dnl ----------------------------- Checking for fdatasync: OS X doesn't have it |
| AC_CHECK_FUNCS(fdatasync) |
| |
| dnl ----------------------------- Checking for missing POSIX thread functions |
| AC_CHECK_FUNCS([getpwnam_r getpwuid_r getgrnam_r getgrgid_r]) |
| |
| dnl ----------------------------- Checking for Shared Memory Support |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for Shared Memory Support...]) |
| |
| # The real-time POSIX extensions (e.g. shm_*, sem_*) may only |
| # be available if linking against librt. |
| AC_SEARCH_LIBS(shm_open, rt) |
| |
| case $host in |
| *-sysv*) |
| ac_includes_default="$ac_includes_default |
| #if HAVE_SYS_MUTEX_H /* needed to define lock_t for sys/shm.h */ |
| # include <sys/mutex.h> |
| #endif";; |
| esac |
| |
| AC_CHECK_HEADERS([sys/types.h sys/mman.h sys/ipc.h sys/mutex.h \ |
| sys/shm.h sys/file.h sys/socket.h kernel/OS.h os2.h windows.h]) |
| AC_CHECK_HEADERS([net/if.h],[],[], |
| [ |
| #ifdef HAVE_SYS_SOCKET_H |
| #include <sys/socket.h> |
| #endif |
| #include <net/if.h> |
| ]) |
| AC_CHECK_FUNCS([mmap munmap shm_open shm_unlink shmget shmat shmdt shmctl \ |
| create_area mprotect]) |
| |
| APR_CHECK_DEFINE(MAP_ANON, sys/mman.h) |
| AC_CHECK_FILE(/dev/zero) |
| |
| # Not all systems can mmap /dev/zero (such as HP-UX). Check for that. |
| if test "$ac_cv_func_mmap" = "yes" && |
| test "$ac_cv_file__dev_zero" = "yes"; then |
| AC_CACHE_CHECK([for mmap that can map /dev/zero], |
| [ac_cv_mmap__dev_zero], |
| [AC_TRY_RUN([#include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #ifdef HAVE_SYS_MMAN_H |
| #include <sys/mman.h> |
| #endif |
| int main() |
| { |
| int fd; |
| void *m; |
| fd = open("/dev/zero", O_RDWR); |
| if (fd < 0) { |
| return 1; |
| } |
| m = mmap(0, sizeof(void*), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); |
| if (m == (void *)-1) { /* aka MAP_FAILED */ |
| return 2; |
| } |
| if (munmap(m, sizeof(void*)) < 0) { |
| return 3; |
| } |
| return 0; |
| }], [], [ac_cv_file__dev_zero=no], [ac_cv_file__dev_zero=no])]) |
| fi |
| |
| # Now we determine which one is our anonymous shmem preference. |
| haveshmgetanon="0" |
| havemmapzero="0" |
| havemmapanon="0" |
| APR_BEGIN_DECISION([anonymous shared memory allocation method]) |
| APR_IFALLYES(header:sys/ipc.h header:sys/shm.h header:sys/file.h dnl |
| func:shmget func:shmat func:shmdt func:shmctl, |
| [haveshmgetanon="1" |
| APR_DECIDE(USE_SHMEM_SHMGET_ANON, [SysV IPC shmget()])]) |
| APR_IFALLYES(header:sys/mman.h func:mmap func:munmap file:/dev/zero, |
| [havemmapzero="1" |
| APR_DECIDE(USE_SHMEM_MMAP_ZERO, |
| [SVR4-style mmap() on /dev/zero])]) |
| APR_IFALLYES(header:sys/mman.h func:mmap func:munmap define:MAP_ANON, |
| [havemmapanon="1" |
| APR_DECIDE(USE_SHMEM_MMAP_ANON, |
| [4.4BSD-style mmap() via MAP_ANON])]) |
| APR_IFALLYES(header:os2.h, |
| [haveos2shm="1" |
| APR_DECIDE(USE_SHMEM_OS2_ANON, [OS/2 DosAllocSharedMem()])]) |
| APR_IFALLYES(header:kernel/OS.h func:create_area, |
| [havebeosshm="1" |
| APR_DECIDE(USE_SHMEM_BEOS_ANON, |
| [BeOS areas])]) |
| APR_IFALLYES(header:windows.h func:CreateFileMapping, |
| [havewin32shm="1" |
| APR_DECIDE(USE_SHMEM_WIN32_ANON, |
| [Windows CreateFileMapping()])]) |
| case $host in |
| *linux* ) |
| # Linux has problems with MM_SHMT_MMANON even though it reports |
| # that it has it. |
| # FIXME - find exact 2.3 version that MMANON was fixed in. It is |
| # confirmed fixed in 2.4 series. |
| if test $os_pre24linux -eq 1; then |
| AC_MSG_WARN([Disabling anon mmap() support for Linux pre-2.4]) |
| APR_DECISION_OVERRIDE(USE_SHMEM_MMAP_ZERO USE_SHMEM_SHMGET_ANON) |
| fi |
| ;; |
| *hpux11* ) |
| APR_DECISION_OVERRIDE(USE_SHMEM_SHMGET_ANON) |
| ;; |
| esac |
| APR_END_DECISION |
| AC_DEFINE_UNQUOTED($ac_decision) |
| |
| useshmgetanon="0" |
| usemmapzero="0" |
| usemmapanon="0" |
| |
| case $ac_decision in |
| USE_SHMEM_SHMGET_ANON ) |
| useshmgetanon="1" |
| ;; |
| USE_SHMEM_MMAP_ZERO ) |
| usemmapzero="1" |
| ;; |
| USE_SHMEM_MMAP_ANON ) |
| usemmapanon="1" |
| ;; |
| esac |
| |
| AC_SUBST(useshmgetanon) |
| AC_SUBST(usemmapzero) |
| AC_SUBST(usemmapanon) |
| AC_SUBST(haveshmgetanon) |
| AC_SUBST(havemmapzero) |
| AC_SUBST(havemmapanon) |
| |
| # Now we determine which one is our name-based shmem preference. |
| havemmaptmp="0" |
| havemmapshm="0" |
| haveshmget="0" |
| havebeosarea="0" |
| haveos2shm="0" |
| havewin32shm="0" |
| APR_BEGIN_DECISION([namebased memory allocation method]) |
| APR_IFALLYES(header:sys/mman.h func:mmap func:munmap, |
| [havemmaptmp="1" |
| APR_DECIDE(USE_SHMEM_MMAP_TMP, |
| [Classical mmap() on temporary file])]) |
| APR_IFALLYES(header:sys/mman.h func:mmap func:munmap func:shm_open dnl |
| func:shm_unlink, |
| [havemmapshm="1" |
| APR_DECIDE(USE_SHMEM_MMAP_SHM, |
| [mmap() via POSIX.1 shm_open() on temporary file])]) |
| APR_IFALLYES(header:sys/ipc.h header:sys/shm.h header:sys/file.h dnl |
| func:shmget func:shmat func:shmdt func:shmctl, |
| [haveshmget="1" |
| APR_DECIDE(USE_SHMEM_SHMGET, [SysV IPC shmget()])]) |
| APR_IFALLYES(header:kernel/OS.h func:create_area, |
| [havebeosshm="1" |
| APR_DECIDE(USE_SHMEM_BEOS, [BeOS areas])]) |
| APR_IFALLYES(header:os2.h, |
| [haveos2shm="1" |
| APR_DECIDE(USE_SHMEM_OS2, [OS/2 DosAllocSharedMem()])]) |
| APR_IFALLYES(header:windows.h, |
| [havewin32shm="1" |
| APR_DECIDE(USE_SHMEM_WIN32, [Windows shared memory])]) |
| AC_ARG_ENABLE(posix-shm, |
| [ --enable-posix-shm Use POSIX shared memory (shm_open) if available], |
| [ |
| if test "$havemmapshm" = "1"; then |
| APR_DECISION_OVERRIDE(USE_SHMEM_MMAP_SHM) |
| fi |
| ]) |
| case $host in |
| *linux* ) |
| # Linux pre-2.4 had problems with MM_SHMT_MMANON even though |
| # it reports that it has it. |
| if test $os_pre24linux -eq 1; then |
| APR_DECISION_OVERRIDE(USE_SHMEM_MMAP_TMP USE_SHMEM_MMAP_SHM dnl |
| USE_SHMEM_SHMGET) |
| fi |
| ;; |
| esac |
| APR_END_DECISION |
| AC_DEFINE_UNQUOTED($ac_decision) |
| |
| usemmaptmp="0" |
| usemmapshm="0" |
| useshmget="0" |
| usebeosarea="0" |
| useos2shm="0" |
| usewin32shm="0" |
| |
| case $ac_decision in |
| USE_SHMEM_MMAP_TMP ) |
| usemmaptmp="1" |
| ;; |
| USE_SHMEM_MMAP_SHM ) |
| usemmapshm="1" |
| ;; |
| USE_SHMEM_SHMGET ) |
| useshmget="1" |
| ;; |
| USE_SHMEM_BEOS ) |
| usebeosarea="1" |
| ;; |
| USE_SHMEM_OS2 ) |
| useos2shm="1" |
| ;; |
| USE_SHMEM_WIN32 ) |
| usewin32shm="1" |
| ;; |
| esac |
| |
| # Do we have any shared memory support? |
| if test "$usemmaptmp$usemmapshm$usemmapzero$useshmget$usemmapanon$usebeosarea$useos2shm$usewin32shm" = "00000000"; then |
| sharedmem="0" |
| else |
| sharedmem="1" |
| fi |
| |
| AC_SUBST(usemmaptmp) |
| AC_SUBST(usemmapshm) |
| AC_SUBST(useshmget) |
| AC_SUBST(usebeosarea) |
| AC_SUBST(useos2shm) |
| AC_SUBST(usewin32shm) |
| AC_SUBST(havemmaptmp) |
| AC_SUBST(havemmapshm) |
| AC_SUBST(haveshmget) |
| AC_SUBST(havebeosarea) |
| AC_SUBST(haveos2shm) |
| AC_SUBST(havewin32shm) |
| AC_SUBST(sharedmem) |
| |
| dnl ----------------------------- Checks for Any required Functions |
| dnl Checks for library functions. (N.B. poll is further down) |
| |
| AC_FUNC_ALLOCA |
| |
| AC_CHECK_FUNCS([calloc setsid isinf isnan \ |
| getenv putenv setenv unsetenv \ |
| writev getifaddrs utime utimes]) |
| AC_CHECK_FUNCS(setrlimit, [ have_setrlimit="1" ], [ have_setrlimit="0" ]) |
| AC_CHECK_FUNCS(getrlimit, [ have_getrlimit="1" ], [ have_getrlimit="0" ]) |
| sendfile="0" |
| AC_CHECK_LIB(sendfile, sendfilev) |
| AC_CHECK_FUNCS(sendfile send_file sendfilev, [ sendfile="1" ]) |
| |
| dnl THIS MUST COME AFTER THE THREAD TESTS - FreeBSD doesn't always have a |
| dnl threaded poll() and we don't want to use sendfile on early FreeBSD |
| dnl systems if we are also using threads. |
| |
| AC_ARG_WITH(sendfile, [ --with-sendfile Override decision to use sendfile], |
| [ if test "$withval" = "yes"; then |
| sendfile="1" |
| else |
| sendfile="0" |
| fi ], [ |
| orig_sendfile=$sendfile |
| case $host in |
| *freebsd*) |
| # FreeBSD < 4.2 has issues with threads+sendfile |
| if test $os_version -le "401999"; then |
| if test "$threads" = "1"; then |
| sendfile="0" |
| fi |
| fi |
| ;; |
| *alpha*-dec-osf* ) |
| sendfile="0" |
| ;; |
| s390-*-linux-gnu) |
| # disable sendfile support for 2.2 on S/390 |
| if test $os_pre24linux -eq 1; then |
| AC_MSG_WARN([Disabled sendfile support for Linux 2.2 on S/390]) |
| sendfile="0" |
| fi |
| ;; |
| *aix*) |
| # compiler-independent check for 64-bit build |
| AC_CHECK_SIZEOF(void*, 4) |
| if test "x$ac_cv_sizeof_voidp" = "x8"; then |
| # sendfile not working for 64-bit build |
| sendfile="0" |
| fi |
| ;; |
| esac |
| if test "$orig_sendfile" != "$sendfile"; then |
| AC_MSG_NOTICE([sendfile support disabled to avoid system problem]) |
| fi ] ) |
| AC_SUBST(sendfile) |
| |
| AC_CHECK_FUNCS(sigaction, [ have_sigaction="1" ], [ have_sigaction="0" ]) |
| AC_DECL_SYS_SIGLIST |
| |
| AC_CHECK_FUNCS(fork, [ fork="1" ], [ fork="0" ]) |
| APR_CHECK_INET_ADDR |
| APR_CHECK_INET_NETWORK |
| AC_SUBST(apr_inaddr_none) |
| AC_CHECK_FUNC(_getch) |
| AC_CHECK_FUNCS(strerror_r, [ strerror_r="1" ], [ strerror_r="0" ]) |
| if test "$strerror_r" = "1"; then |
| APR_CHECK_STRERROR_R_RC |
| fi |
| AC_CHECK_FUNCS(mmap, [ mmap="1" ], [ mmap="0" ]) |
| if test "$native_mmap_emul" = "1"; then |
| mmap="1" |
| fi |
| AC_CHECK_FUNCS(memmove, [ have_memmove="1" ], [have_memmove="0" ]) |
| AC_CHECK_FUNCS([getpass getpassphrase gmtime_r localtime_r]) |
| case $host in |
| *-hp-hpux*) |
| dnl mkstemp is limited to 26 temporary files (a-z); use APR replacement |
| ;; |
| *) |
| AC_CHECK_FUNCS(mkstemp mkostemp) |
| ;; |
| esac |
| |
| AC_SUBST(fork) |
| AC_SUBST(have_inet_addr) |
| AC_SUBST(tcp_nodelay_inherited) |
| AC_SUBST(o_nonblock_inherited) |
| AC_SUBST(have_inet_network) |
| AC_SUBST(have_sigaction) |
| AC_SUBST(have_setrlimit) |
| AC_SUBST(have_getrlimit) |
| AC_SUBST(mmap) |
| AC_SUBST(have_memmove) |
| |
| APR_CHECK_SIGWAIT_ONE_ARG |
| |
| dnl ----------------------------- Checks for Any required Headers |
| AC_HEADER_STDC |
| |
| APR_FLAG_HEADERS( |
| aio.h \ |
| ByteOrder.h \ |
| conio.h \ |
| crypt.h \ |
| ctype.h \ |
| dir.h \ |
| dirent.h \ |
| dl.h \ |
| dlfcn.h \ |
| errno.h \ |
| fcntl.h \ |
| grp.h \ |
| ifaddrs.h \ |
| inttypes.h \ |
| io.h \ |
| limits.h \ |
| mach-o/dyld.h \ |
| malloc.h \ |
| memory.h \ |
| netdb.h \ |
| osreldate.h \ |
| poll.h \ |
| process.h \ |
| pwd.h \ |
| semaphore.h \ |
| signal.h \ |
| stdarg.h \ |
| stddef.h \ |
| stdio.h \ |
| stdlib.h \ |
| string.h \ |
| strings.h \ |
| sysapi.h \ |
| sysgtime.h \ |
| termios.h \ |
| time.h \ |
| tpfeq.h \ |
| tpfio.h \ |
| unistd.h \ |
| unix.h \ |
| windows.h \ |
| winsock2.h \ |
| ws2tcpip.h \ |
| arpa/inet.h \ |
| kernel/OS.h \ |
| net/errno.h \ |
| netinet/in.h \ |
| netinet/sctp.h \ |
| netinet/sctp_uio.h \ |
| sys/file.h \ |
| sys/ioctl.h \ |
| sys/mman.h \ |
| sys/param.h \ |
| sys/poll.h \ |
| sys/resource.h \ |
| sys/select.h \ |
| sys/sem.h \ |
| sys/sendfile.h \ |
| sys/signal.h \ |
| sys/socket.h \ |
| sys/sockio.h \ |
| sys/stat.h \ |
| sys/sysctl.h \ |
| sys/syslimits.h \ |
| sys/time.h \ |
| sys/types.h \ |
| sys/uio.h \ |
| sys/un.h \ |
| sys/wait.h) |
| |
| # Windows' <mswsock.h> requires <windows.h> first |
| AC_CACHE_CHECK([for mswsock.h], [apr_cv_hdr_mswsock_h], |
| [AC_TRY_CPP( |
| [#include <windows.h> |
| #include <mswsock.h> |
| ], [apr_cv_hdr_mswsock_h=yes], [apr_cv_hdr_mswsock_h=no])]) |
| if test "$apr_cv_hdr_mswsock_h" = "yes"; then |
| mswsockh=1 |
| else |
| mswsockh=0 |
| fi |
| |
| # IRIX 6.5 has a problem in <netinet/tcp.h> which prevents it from |
| # being included by itself. Check for <netinet/tcp.h> manually, |
| # including another header file first. |
| AC_CACHE_CHECK([for netinet/tcp.h], [apr_cv_hdr_netinet_tcp_h], |
| [AC_TRY_CPP( |
| [#ifdef HAVE_NETINET_IN_H |
| #include <netinet/in.h> |
| #endif |
| #include <netinet/tcp.h> |
| ], [apr_cv_hdr_netinet_tcp_h=yes], [apr_cv_hdr_netinet_tcp_h=no])]) |
| if test "$apr_cv_hdr_netinet_tcp_h" = "yes"; then |
| netinet_tcph=1 |
| AC_DEFINE([HAVE_NETINET_TCP_H], 1, [Defined if netinet/tcp.h is present]) |
| else |
| netinet_tcph=0 |
| fi |
| |
| AC_SUBST(aioh) |
| AC_SUBST(arpa_ineth) |
| AC_SUBST(conioh) |
| AC_SUBST(ctypeh) |
| AC_SUBST(crypth) |
| AC_SUBST(errnoh) |
| AC_SUBST(direnth) |
| AC_SUBST(fcntlh) |
| AC_SUBST(ifaddrsh) |
| AC_SUBST(inttypesh) |
| AC_SUBST(ioh) |
| AC_SUBST(limitsh) |
| AC_SUBST(mswsockh) |
| AC_SUBST(netdbh) |
| AC_SUBST(netinet_inh) |
| AC_SUBST(netinet_sctph) |
| AC_SUBST(netinet_sctp_uioh) |
| AC_SUBST(netinet_tcph) |
| AC_SUBST(stdargh) |
| AC_SUBST(stddefh) |
| AC_SUBST(stdioh) |
| AC_SUBST(stdlibh) |
| AC_SUBST(stringh) |
| AC_SUBST(stringsh) |
| AC_SUBST(sys_ioctlh) |
| AC_SUBST(sys_sendfileh) |
| AC_SUBST(sys_signalh) |
| AC_SUBST(sys_socketh) |
| AC_SUBST(sys_sockioh) |
| AC_SUBST(sys_syslimitsh) |
| AC_SUBST(sys_typesh) |
| AC_SUBST(sys_timeh) |
| AC_SUBST(sys_uioh) |
| AC_SUBST(sys_unh) |
| AC_SUBST(timeh) |
| AC_SUBST(unistdh) |
| AC_SUBST(signalh) |
| AC_SUBST(sys_waith) |
| AC_SUBST(processh) |
| AC_SUBST(pthreadh) |
| AC_SUBST(semaphoreh) |
| AC_SUBST(windowsh) |
| AC_SUBST(winsock2h) |
| AC_SUBST(ws2tcpiph) |
| |
| # Checking for h_errno in <netdb.h> |
| if test "$netdbh" = "1"; then |
| APR_CHECK_H_ERRNO_FLAG |
| if test "$ac_cv_h_errno_cflags" = "no"; then |
| AC_MSG_ERROR([can not find h_errno in netdb.h]) |
| fi |
| fi |
| |
| AC_ARG_ENABLE(allocator-uses-mmap, |
| [ --enable-allocator-uses-mmap Use mmap in apr_allocator instead of malloc ], |
| [ if test "$enableval" = "yes"; then |
| APR_IFALLYES(header:sys/mman.h func:mmap func:munmap define:MAP_ANON, |
| [AC_DEFINE(APR_ALLOCATOR_USES_MMAP, 1, |
| [Define if apr_allocator should use mmap]) ], |
| [AC_MSG_ERROR([mmap()/MAP_ANON not supported]) ] |
| ) |
| fi ] |
| ) |
| |
| AC_ARG_ENABLE(allocator-guard-pages, |
| [ --enable-allocator-guard-pages Use guard pages in apr_allocator |
| (implies --enable-allocator-uses-mmap) ] , |
| [ if test "$enableval" = "yes"; then |
| APR_IFALLYES(header:sys/mman.h func:mmap func:munmap func:mprotect define:MAP_ANON, |
| [AC_DEFINE(APR_ALLOCATOR_GUARD_PAGES, 1, |
| [Define if apr_allocator should use guard pages]) ], |
| [AC_MSG_ERROR([mmap()/MAP_ANON/mprotect() not supported]) ] |
| ) |
| fi ] |
| ) |
| |
| |
| AC_ARG_ENABLE(pool-concurrency-check, |
| [ --enable-pool-concurrency-check Check for concurrent usage of memory pools], |
| [ if test "$enableval" = "yes"; then |
| AC_DEFINE(APR_POOL_CONCURRENCY_CHECK, 1, |
| [Define if pool functions should abort if concurrent usage is detected]) |
| fi ] |
| ) |
| |
| dnl ----------------------------- Checks for standard typedefs |
| AC_TYPE_OFF_T |
| AC_TYPE_PID_T |
| AC_TYPE_SIZE_T |
| AC_TYPE_UID_T |
| AC_CHECK_TYPE(ssize_t, int) |
| AC_C_INLINE |
| AC_C_CONST |
| AC_FUNC_SETPGRP |
| |
| APR_CHECK_SOCKLEN_T |
| |
| dnl Checks for pointer size |
| AC_CHECK_SIZEOF(void*, 4) |
| |
| if test "x$ac_cv_sizeof_voidp" != "x"; then |
| voidp_size=$ac_cv_sizeof_voidp |
| else |
| AC_ERROR([Cannot determine size of void*]) |
| fi |
| |
| dnl Checks for integer size |
| AC_CHECK_SIZEOF(char, 1) |
| AC_CHECK_SIZEOF(short, 2) |
| AC_CHECK_SIZEOF(int, 4) |
| AC_CHECK_SIZEOF(long, 4) |
| AC_CHECK_SIZEOF(long long, 8) |
| |
| if test "$ac_cv_sizeof_short" = "2"; then |
| short_value=short |
| fi |
| if test "$ac_cv_sizeof_int" = "4"; then |
| int_value=int |
| fi |
| |
| # Now we need to find what apr_int64_t (sizeof == 8) will be. |
| # The first match is our preference (use inttypes if available). |
| APR_IFALLYES(header:stdint.h header:inttypes.h, hasinttypes="1", hasinttypes="0") |
| if test "$hasinttypes" = "1"; then |
| int64_literal='#define APR_INT64_C(val) INT64_C(val)' |
| uint64_literal='#define APR_UINT64_C(val) UINT64_C(val)' |
| int64_t_fmt='#define APR_INT64_T_FMT PRId64' |
| uint64_t_fmt='#define APR_UINT64_T_FMT PRIu64' |
| uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT PRIx64' |
| int64_value="int64_t" |
| uint64_value="uint64_t" |
| APR_CHECK_TYPES_FMT_COMPATIBLE(int64_t, int, d, [ |
| int64_strfn="strtoi" |
| ], [ |
| APR_CHECK_TYPES_FMT_COMPATIBLE(int64_t, long, ld, [ |
| int64_strfn="strtol" |
| ], [ |
| APR_CHECK_TYPES_FMT_COMPATIBLE(int64_t, long long, lld, [ |
| int64_strfn="strtoll" |
| ], [ |
| AC_ERROR([could not determine the string function for int64_t]) |
| ])])]) |
| elif test "$ac_cv_sizeof_int" = "8"; then |
| int64_literal='#define APR_INT64_C(val) (val)' |
| uint64_literal='#define APR_UINT64_C(val) (val##U)' |
| int64_t_fmt='#define APR_INT64_T_FMT "d"' |
| uint64_t_fmt='#define APR_UINT64_T_FMT "u"' |
| uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "x"' |
| int64_value="int" |
| uint64_value="unsigned int" |
| int64_strfn="strtoi" |
| elif test "$ac_cv_sizeof_long" = "8"; then |
| int64_literal='#define APR_INT64_C(val) (val##L)' |
| uint64_literal='#define APR_UINT64_C(val) (val##UL)' |
| int64_t_fmt='#define APR_INT64_T_FMT "ld"' |
| uint64_t_fmt='#define APR_UINT64_T_FMT "lu"' |
| uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "lx"' |
| int64_value="long" |
| uint64_value="unsigned long" |
| int64_strfn="strtol" |
| elif test "$ac_cv_sizeof_long_long" = "8"; then |
| int64_literal='#define APR_INT64_C(val) (val##LL)' |
| uint64_literal='#define APR_UINT64_C(val) (val##ULL)' |
| # Linux, Solaris, FreeBSD all support ll with printf. |
| # BSD 4.4 originated 'q'. Solaris is more popular and |
| # doesn't support 'q'. Solaris wins. Exceptions can |
| # go to the OS-dependent section. |
| int64_t_fmt='#define APR_INT64_T_FMT "lld"' |
| uint64_t_fmt='#define APR_UINT64_T_FMT "llu"' |
| uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "llx"' |
| int64_value="long long" |
| uint64_value="unsigned long long" |
| int64_strfn="strtoll" |
| elif test "$ac_cv_sizeof_longlong" = "8"; then |
| int64_literal='#define APR_INT64_C(val) (val##LL)' |
| uint64_literal='#define APR_UINT64_C(val) (val##ULL)' |
| int64_t_fmt='#define APR_INT64_T_FMT "qd"' |
| uint64_t_fmt='#define APR_UINT64_T_FMT "qu"' |
| uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "qx"' |
| int64_value="__int64" |
| uint64_value="unsigned __int64" |
| int64_strfn="strtoll" |
| else |
| # int64_literal may be overriden if your compiler thinks you have |
| # a 64-bit value but APR does not agree. |
| AC_ERROR([could not detect a 64-bit integer type]) |
| fi |
| |
| # If present, allow the C99 macro INT64_C to override our conversion. |
| # |
| # HP-UX's ANSI C compiler provides this without any includes, so we |
| # will first look for INT64_C without adding stdint.h |
| AC_CACHE_CHECK([for INT64_C], [apr_cv_define_INT64_C], [ |
| AC_EGREP_CPP(YES_IS_DEFINED, |
| [#ifdef INT64_C |
| YES_IS_DEFINED |
| #endif], [apr_cv_define_INT64_C=yes], [ |
| # Now check for INT64_C in stdint.h |
| AC_EGREP_CPP(YES_IS_DEFINED, [#include <stdint.h> |
| #ifdef INT64_C |
| YES_IS_DEFINED |
| #endif], [apr_cv_define_INT64_C=yes], [apr_cv_define_INT64_C=no])])]) |
| |
| if test "$apr_cv_define_INT64_C" = "yes"; then |
| int64_literal='#define APR_INT64_C(val) INT64_C(val)' |
| uint64_literal='#define APR_UINT64_C(val) UINT64_C(val)' |
| stdint=1 |
| else |
| stdint=0 |
| fi |
| |
| if test "$ac_cv_type_size_t" = "yes"; then |
| size_t_value="size_t" |
| else |
| size_t_value="apr_int32_t" |
| fi |
| if test "$ac_cv_type_ssize_t" = "yes"; then |
| ssize_t_value="ssize_t" |
| else |
| ssize_t_value="apr_int32_t" |
| fi |
| if test "$ac_cv_socklen_t" = "yes"; then |
| socklen_t_value="socklen_t" |
| case $host in |
| *-hp-hpux*) |
| if test "$ac_cv_sizeof_long" = "8"; then |
| # 64-bit HP-UX requires 32-bit socklens in |
| # kernel, but user-space declarations say |
| # 64-bit (socklen_t == size_t == long). |
| # This will result in many compile warnings, |
| # but we're functionally busted otherwise. |
| socklen_t_value="int" |
| fi |
| ;; |
| esac |
| else |
| socklen_t_value="int" |
| fi |
| |
| AC_CHECK_SIZEOF(pid_t) |
| |
| if test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_short"; then |
| pid_t_fmt='#define APR_PID_T_FMT "hd"' |
| elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_int"; then |
| pid_t_fmt='#define APR_PID_T_FMT "d"' |
| elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_long"; then |
| pid_t_fmt='#define APR_PID_T_FMT "ld"' |
| elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_long_long"; then |
| pid_t_fmt='#define APR_PID_T_FMT APR_INT64_T_FMT' |
| else |
| pid_t_fmt='#error Can not determine the proper size for pid_t' |
| fi |
| |
| # Basically, we have tried to figure out the correct format strings |
| # for APR types which vary between platforms, but we don't always get |
| # it right. |
| case $host in |
| s390*linux*) |
| # uniquely, the 31-bit Linux/s390 uses "unsigned long int" |
| # for size_t rather than "unsigned int": |
| size_t_fmt="lu" |
| ssize_t_fmt="ld" |
| ;; |
| *-os2*) |
| size_t_fmt="lu" |
| ;; |
| *-solaris*) |
| if test "$ac_cv_sizeof_long" = "8"; then |
| pid_t_fmt='#define APR_PID_T_FMT "d"' |
| else |
| pid_t_fmt='#define APR_PID_T_FMT "ld"' |
| fi |
| ;; |
| *aix4*|*aix5*) |
| ssize_t_fmt="ld" |
| size_t_fmt="lu" |
| ;; |
| *beos*) |
| ssize_t_fmt="ld" |
| size_t_fmt="ld" |
| ;; |
| *apple-darwin*) |
| osver=`uname -r` |
| case $osver in |
| [[0-7]].*) |
| ssize_t_fmt="d" |
| ;; |
| *) |
| ssize_t_fmt="ld" |
| ;; |
| esac |
| size_t_fmt="lu" |
| ;; |
| *-mingw*) |
| int64_t_fmt='#define APR_INT64_T_FMT "I64d"' |
| uint64_t_fmt='#define APR_UINT64_T_FMT "I64u"' |
| uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "I64x"' |
| int64_value="__int64" |
| uint64_value="unsigned __int64" |
| int64_strfn="_strtoi64" |
| ;; |
| esac |
| |
| dnl I would expect much of the above to go away with new compile test |
| APR_CHECK_TYPES_FMT_COMPATIBLE(ssize_t, long, ld, [ssize_t_fmt="ld"], [ |
| APR_CHECK_TYPES_FMT_COMPATIBLE(ssize_t, int, d, [ssize_t_fmt="d"]) |
| ]) |
| APR_CHECK_TYPES_FMT_COMPATIBLE(size_t, unsigned long, lu, [size_t_fmt="lu"], [ |
| APR_CHECK_TYPES_FMT_COMPATIBLE(size_t, unsigned int, u, [size_t_fmt="u"]) |
| ]) |
| |
| AC_CHECK_SIZEOF(ssize_t) |
| |
| dnl the else cases below should no longer occur; |
| AC_MSG_CHECKING([which format to use for apr_ssize_t]) |
| if test -n "$ssize_t_fmt"; then |
| AC_MSG_RESULT(%$ssize_t_fmt) |
| elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_int"; then |
| ssize_t_fmt="d" |
| AC_MSG_RESULT(%d) |
| elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_long"; then |
| ssize_t_fmt="ld" |
| AC_MSG_RESULT(%ld) |
| else |
| AC_ERROR([could not determine the proper format for apr_ssize_t]) |
| fi |
| |
| ssize_t_fmt="#define APR_SSIZE_T_FMT \"$ssize_t_fmt\"" |
| |
| AC_CHECK_SIZEOF(size_t) |
| |
| # else cases below should no longer occur; |
| AC_MSG_CHECKING([which format to use for apr_size_t]) |
| if test -n "$size_t_fmt"; then |
| AC_MSG_RESULT(%$size_t_fmt) |
| elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_int"; then |
| size_t_fmt="d" |
| AC_MSG_RESULT(%d) |
| elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_long"; then |
| size_t_fmt="ld" |
| AC_MSG_RESULT(%ld) |
| else |
| AC_ERROR([could not determine the proper format for apr_size_t]) |
| fi |
| |
| size_t_fmt="#define APR_SIZE_T_FMT \"$size_t_fmt\"" |
| |
| AC_CHECK_SIZEOF(off_t) |
| |
| if test "${ac_cv_sizeof_off_t}${apr_cv_use_lfs64}" = "4yes"; then |
| # Enable LFS |
| aprlfs=1 |
| AC_CHECK_FUNCS([mmap64 sendfile64 sendfilev64 readdir64_r]) |
| case $host in |
| *-hp-hpux*) |
| dnl mkstemp64 is limited to 26 temporary files (a-z); use APR replacement |
| ;; |
| *) |
| AC_CHECK_FUNCS(mkstemp64 mkostemp64) |
| ;; |
| esac |
| elif test "${ac_cv_sizeof_off_t}" != "${ac_cv_sizeof_size_t}"; then |
| # unsure of using -gt above is as portable, can can't forsee where |
| # off_t can legitimately be smaller than size_t |
| aprlfs=1 |
| else |
| aprlfs=0 |
| fi |
| |
| AC_MSG_CHECKING([which type to use for apr_off_t]) |
| if test "${ac_cv_sizeof_off_t}${apr_cv_use_lfs64}" = "4yes"; then |
| # LFS is go! |
| off_t_fmt='#define APR_OFF_T_FMT APR_INT64_T_FMT' |
| off_t_value='off64_t' |
| off_t_strfn='apr_strtoi64' |
| off_t_size=8 |
| elif test "${ac_cv_sizeof_off_t}x${ac_cv_sizeof_long}" = "4x4"; then |
| # Special case: off_t may change size with _FILE_OFFSET_BITS |
| # on 32-bit systems with LFS support. To avoid compatibility |
| # issues when other packages do define _FILE_OFFSET_BITS, |
| # hard-code apr_off_t to long. |
| off_t_value=long |
| off_t_fmt='#define APR_OFF_T_FMT "ld"' |
| off_t_strfn='strtol' |
| off_t_size="$ac_cv_sizeof_long" |
| elif test "$ac_cv_type_off_t" = "yes"; then |
| # off_t is more commonly a long than an int; prefer that case |
| # where int and long are the same size and interchangable. |
| off_t_value=off_t |
| off_t_size="$ac_cv_sizeof_off_t" |
| APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, long, ld, [ |
| off_t_fmt="#define APR_OFF_T_FMT \"ld\"" |
| off_t_strfn='strtol' |
| ], [ |
| APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, int, d, [ |
| off_t_fmt="#define APR_OFF_T_FMT \"d\"" |
| off_t_strfn='strtoi' |
| ], [ |
| APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, long long, lld, [ |
| off_t_fmt="#define APR_OFF_T_FMT \"lld\"" |
| off_t_strfn='strtoll' |
| ], [ |
| APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, $int64_value, I64d, [ |
| off_t_fmt="#define APR_OFF_T_FMT APR_INT64_T_FMT" |
| off_t_strfn='apr_strtoi64'], [ |
| # Per OS tuning... |
| case $host in |
| *-mingw*) |
| off_t_value=apr_int64_t |
| off_t_fmt='#define APR_OFF_T_FMT "I64d"' |
| off_t_strfn='_strtoi64' |
| off_t_size=8 |
| ;; |
| *) |
| AC_ERROR([could not determine the size of off_t]) |
| ;; |
| esac |
| ])])])]) |
| else |
| # Fallback on int |
| off_t_value=int |
| off_t_fmt='#define APR_OFF_T_FMT "d"' |
| off_t_strfn='strtoi' |
| off_t_size=4 |
| fi |
| AC_MSG_RESULT($off_t_value) |
| |
| |
| # Regardless of whether _LARGEFILE64_SOURCE is used, on some |
| # platforms _FILE_OFFSET_BITS will affect the size of ino_t and hence |
| # the build-time ABI may be different from the apparent ABI when using |
| # APR with another package which *does* define _FILE_OFFSET_BITS. |
| # (Exactly as per the case above with off_t where LFS is *not* used) |
| # |
| # To be safe, hard-code apr_ino_t as 'unsigned long' or 'unsigned int' |
| # iff that is exactly the size of ino_t here; otherwise use ino_t as existing |
| # releases did. To be correct, apr_ino_t should have been made an |
| # ino64_t as apr_off_t is off64_t, but this can't be done now without |
| # breaking ABI. |
| |
| # Per OS tuning... |
| case $host in |
| *mingw*) |
| ino_t_value=apr_int64_t |
| ;; |
| *) |
| ino_t_value=ino_t |
| AC_CHECK_SIZEOF(ino_t) |
| if test $ac_cv_sizeof_ino_t = 4; then |
| if test $ac_cv_sizeof_long = 4; then |
| ino_t_value="unsigned long" |
| else |
| ino_t_value="unsigned int" |
| fi |
| fi |
| ;; |
| esac |
| AC_MSG_NOTICE([using $ino_t_value for ino_t]) |
| |
| # Checks for endianness |
| AC_C_BIGENDIAN |
| if test $ac_cv_c_bigendian = yes; then |
| bigendian=1 |
| else |
| bigendian=0 |
| fi |
| |
| AC_CHECK_SIZEOF(struct iovec,,[AC_INCLUDES_DEFAULT |
| #include <sys/uio.h>]) |
| if test "$ac_cv_sizeof_struct_iovec" = "0"; then |
| have_iovec=0 |
| else |
| have_iovec=1 |
| fi |
| |
| AC_SUBST(voidp_size) |
| AC_SUBST(short_value) |
| AC_SUBST(int_value) |
| AC_SUBST(int64_value) |
| AC_SUBST(uint64_value) |
| AC_SUBST(off_t_value) |
| AC_SUBST(size_t_value) |
| AC_SUBST(ssize_t_value) |
| AC_SUBST(socklen_t_value) |
| AC_SUBST(int64_t_fmt) |
| AC_SUBST(uint64_t_fmt) |
| AC_SUBST(uint64_t_hex_fmt) |
| AC_SUBST(ssize_t_fmt) |
| AC_SUBST(size_t_fmt) |
| AC_SUBST(off_t_fmt) |
| AC_SUBST(pid_t_fmt) |
| AC_SUBST(int64_literal) |
| AC_SUBST(uint64_literal) |
| AC_SUBST(stdint) |
| AC_SUBST(bigendian) |
| AC_SUBST(aprlfs) |
| AC_SUBST(have_iovec) |
| AC_SUBST(ino_t_value) |
| AC_SUBST(off_t_size) |
| |
| dnl ----------------------------- Checking for string functions |
| AC_CHECK_FUNCS(strnicmp, have_strnicmp="1", have_strnicmp="0") |
| AC_CHECK_FUNCS(strncasecmp, have_strncasecmp="1", have_strncasecmp="0") |
| AC_CHECK_FUNCS(stricmp, have_stricmp="1", have_stricmp="0") |
| AC_CHECK_FUNCS(strcasecmp, have_strcasecmp="1", have_strcasecmp="0") |
| AC_CHECK_FUNCS(strdup, have_strdup="1", have_strdup="0") |
| AC_CHECK_FUNCS(strstr, have_strstr="1", have_strstr="0") |
| AC_CHECK_FUNCS(memchr, have_memchr="1", have_memchr="0") |
| AC_CHECK_FUNC($int64_strfn, have_int64_strfn="1", have_int64_strfn="0") |
| |
| dnl ----------------------------- We have a fallback position |
| if test "$have_int64_strfn" = "0" && test "$int64_strfn" = "strtoll"; then |
| int64_strfn="strtoq" |
| AC_CHECK_FUNC(strtoq, [have_int64_strfn=1], [have_int64_strfn=0]) |
| fi |
| |
| if test "$have_int64_strfn" = "1"; then |
| AC_DEFINE_UNQUOTED(APR_INT64_STRFN, [$int64_strfn], |
| [Define as function which can be used for conversion of strings to apr_int64_t]) |
| fi |
| |
| AC_SUBST(have_strnicmp) |
| AC_SUBST(have_strncasecmp) |
| AC_SUBST(have_stricmp) |
| AC_SUBST(have_strcasecmp) |
| AC_SUBST(have_strdup) |
| AC_SUBST(have_strstr) |
| AC_SUBST(have_memchr) |
| |
| AC_CACHE_CHECK([for memset_s support], [apr_cv_memset_s], |
| [AC_TRY_RUN([ |
| #ifdef HAVE_STRING_H |
| #define __STDC_WANT_LIB_EXT1__ 1 |
| #include <string.h> |
| #endif |
| |
| int main(int argc, const char **argv) |
| { |
| char buf[1] = {1}; |
| return memset_s(buf, sizeof buf, 0, sizeof buf) != 0 || *buf != '\0'; |
| }], [apr_cv_memset_s=yes], [apr_cv_memset_s=no], [apr_cv_memset_s=no])]) |
| |
| if test "$apr_cv_memset_s" = "yes"; then |
| AC_DEFINE([HAVE_MEMSET_S], 1, [Define if memset_s function is supported]) |
| fi |
| |
| AC_CACHE_CHECK([for explicit_bzero support], [apr_cv_explicit_bzero], |
| [AC_TRY_RUN([ |
| #ifdef HAVE_STRING_H |
| #include <string.h> |
| #endif |
| #ifdef HAVE_STRINGS_H |
| #include <strings.h> |
| #endif |
| |
| int main(int argc, const char **argv) |
| { |
| char buf[1] = {1}; |
| explicit_bzero(buf, sizeof buf); |
| return *buf != '\0'; |
| }], [apr_cv_explicit_bzero=yes], [apr_cv_explicit_bzero=no], [apr_cv_explicit_bzero=no])]) |
| |
| if test "$apr_cv_explicit_bzero" = "yes"; then |
| AC_DEFINE([HAVE_EXPLICIT_BZERO], 1, [Define if explicit_bzero function is supported]) |
| fi |
| |
| if test "$off_t_strfn" = "apr_strtoi64" && test "$have_int64_strfn" = "1"; then |
| off_t_strfn=$int64_strfn |
| fi |
| AC_DEFINE_UNQUOTED(APR_OFF_T_STRFN, [$off_t_strfn], |
| [Define as function used for conversion of strings to apr_off_t]) |
| |
| dnl ----------------------------- Checking for DSO support |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for DSO...]) |
| |
| AC_ARG_ENABLE(dso, |
| [ --disable-dso Disable DSO support ], |
| [if test "x$enableval" = "xyes"; then |
| dsotype=any |
| else |
| dsotype=$enableval |
| fi |
| ], [dsotype=any]) |
| |
| if test "$dsotype" = "any"; then |
| if test "$dsotype" = "any"; then |
| case $host in |
| *darwin[[0-8]]\.*) |
| # Original Darwin, not for 9.0!: |
| AC_CHECK_FUNC(NSLinkModule, [dsotype=dyld]);; |
| hppa*-hpux[[1-9]]\.*|hppa*-hpux1[[01]]*) |
| # shl is specific to parisc hpux SOM binaries, not used for 64 bit |
| AC_CHECK_LIB(dld, shl_load, [have_shl=1]) |
| if test "$ac_cv_sizeof_voidp$have_shl" = "41"; then |
| dsotype=shl; APR_ADDTO(LIBS,-ldld) |
| fi;; |
| *-mingw*|*-os2*) |
| # several 'other's below probably belong up here. If they always |
| # use a platform implementation and shouldn't test the dlopen/dlfcn |
| # features, then bring them up here. |
| # But if they -should- optionally use dlfcn, and/or need the config |
| # detection of dlopen/dlsym, do not move them up. |
| dsotype=other ;; |
| esac |
| fi |
| # Normal POSIX: |
| if test "$dsotype" = "any"; then |
| AC_CHECK_FUNC(dlopen, [dsotype=dlfcn]) |
| fi |
| if test "$dsotype" = "any"; then |
| AC_CHECK_LIB(dl, dlopen, [dsotype=dlfcn; APR_ADDTO(LIBS,-ldl)]) |
| fi |
| if test "$dsotype" = "dlfcn"; then |
| # ReliantUnix has dlopen() in libc but dlsym() in libdl :( |
| AC_CHECK_FUNC(dlsym, [], |
| [AC_CHECK_LIB(dl, dlsym, |
| [APR_ADDTO(LIBS, -ldl)], |
| [dsotype=any |
| AC_MSG_WARN([Weird: dlopen() was found but dlsym() was not found!])])]) |
| fi |
| if test "$dsotype" = "any"; then |
| # BeOS: |
| AC_CHECK_LIB(root, load_image, [dsotype=other]) |
| fi |
| # Everything else: |
| if test "$dsotype" = "any"; then |
| case $host in |
| *os390|*os400|*-aix*) |
| # Some -aix5 will use dl, no hassles. Keep that pattern here. |
| dsotype=other ;; |
| *-hpux*) |
| if test "$have_shl" = "1"; then |
| dsotype=shl; APR_ADDTO(LIBS,-ldld) |
| fi;; |
| esac |
| fi |
| fi |
| |
| if test "$dsotype" = "any"; then |
| AC_MSG_ERROR([Could not detect suitable DSO implementation]) |
| elif test "$dsotype" = "no"; then |
| aprdso="0" |
| else |
| case "$dsotype" in |
| dlfcn) AC_DEFINE(DSO_USE_DLFCN, 1, [Define if DSO support uses dlfcn.h]);; |
| shl) AC_DEFINE(DSO_USE_SHL, 1, [Define if DSO support uses shl_load]);; |
| dyld) AC_DEFINE(DSO_USE_DYLD, 1, [Define if DSO support uses dyld.h]);; |
| other) ;; # Use whatever is in dso/OSDIR |
| *) AC_MSG_ERROR([Unknown DSO implementation "$dsotype"]);; |
| esac |
| aprdso="1" |
| apr_modules="$apr_modules dso" |
| fi |
| |
| AC_SUBST(aprdso) |
| |
| dnl ----------------------------- Checking for Processes |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for Processes...]) |
| |
| AC_CHECK_FUNCS(waitpid) |
| |
| AC_ARG_ENABLE(other-child, |
| [ --enable-other-child Enable reliable child processes ], |
| [ if test "$enableval" = "yes"; then |
| oc="1" |
| else |
| oc="0" |
| fi ], |
| [ oc=1 ] ) |
| |
| AC_SUBST(oc) |
| |
| if test -z "$have_proc_invoked"; then |
| have_proc_invoked="0" |
| fi |
| |
| AC_SUBST(have_proc_invoked) |
| |
| AC_MSG_CHECKING(for Variable Length Arrays) |
| APR_TRY_COMPILE_NO_WARNING([], |
| [ |
| int foo[argc]; |
| foo[0] = 0; |
| ], vla_msg=yes, vla_msg=no ) |
| AC_MSG_RESULT([$vla_msg]) |
| if test "$vla_msg" = "yes"; then |
| AC_DEFINE(HAVE_VLA, 1, [Define if C compiler supports VLA]) |
| fi |
| |
| AC_CACHE_CHECK(struct rlimit,ac_cv_struct_rlimit,[ |
| AC_TRY_RUN([ |
| #include <sys/types.h> |
| #include <sys/time.h> |
| #include <sys/resource.h> |
| #include <stdlib.h> |
| main() |
| { |
| struct rlimit limit; |
| limit.rlim_cur = 0; |
| limit.rlim_max = 0; |
| exit(0); |
| }], [ |
| ac_cv_struct_rlimit=yes ], [ |
| ac_cv_struct_rlimit=no ], [ |
| ac_cv_struct_rlimit=no ] ) ] ) |
| struct_rlimit=0 |
| test "x$ac_cv_struct_rlimit" = xyes && struct_rlimit=1 |
| AC_SUBST(struct_rlimit) |
| |
| dnl ----------------------------- Checking for Locking Characteristics |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for Locking...]) |
| |
| AC_CHECK_FUNCS(semget semctl semop semtimedop flock) |
| APR_IFALLYES(func:semtimedop, have_semtimedop="1", have_semtimedop="0") |
| |
| AC_CHECK_HEADERS(semaphore.h) |
| AC_SEARCH_LIBS(sem_open, rt) |
| AC_CHECK_FUNCS(sem_close sem_unlink sem_post sem_wait sem_timedwait) |
| APR_IFALLYES(func:sem_timedwait, have_sem_timedwait="1", have_sem_timedwait="0") |
| |
| AC_CHECK_HEADERS(OS.h) |
| AC_CHECK_FUNCS(create_sem acquire_sem acquire_sem_etc) |
| APR_IFALLYES(header:OS.h func:acquire_sem_etc, have_acquire_sem_etc="1", have_acquire_sem_etc="0") |
| |
| # Some systems return ENOSYS from sem_open. |
| AC_CACHE_CHECK(for working sem_open,ac_cv_func_sem_open,[ |
| AC_TRY_RUN([ |
| #include <errno.h> |
| #include <stdlib.h> |
| #include <fcntl.h> |
| #include <semaphore.h> |
| #ifndef SEM_FAILED |
| #define SEM_FAILED (-1) |
| #endif |
| main() |
| { |
| sem_t *psem; |
| const char *sem_name = "/apr_autoconf"; |
| |
| psem = sem_open(sem_name, O_CREAT, 0644, 1); |
| if (psem == (sem_t *)SEM_FAILED) { |
| exit(1); |
| } |
| sem_close(psem); |
| psem = sem_open(sem_name, O_CREAT | O_EXCL, 0644, 1); |
| if (psem != (sem_t *)SEM_FAILED) { |
| sem_close(psem); |
| exit(1); |
| } |
| sem_unlink(sem_name); |
| exit(0); |
| }], [ac_cv_func_sem_open=yes], [ac_cv_func_sem_open=no], |
| [ac_cv_func_sem_open=no])]) |
| |
| # It's stupid, but not all platforms have union semun, even those that need it. |
| AC_MSG_CHECKING(for union semun in sys/sem.h) |
| AC_TRY_COMPILE([ |
| #include <sys/types.h> |
| #include <sys/ipc.h> |
| #include <sys/sem.h> |
| ],[ |
| union semun arg; |
| semctl(0, 0, 0, arg); |
| ], [have_union_semun="1" union_semun=yes ] |
| msg=yes, [ |
| have_union_semun="0" |
| msg=no ] ) |
| AC_MSG_RESULT([$msg]) |
| AC_SUBST(have_union_semun) |
| |
| dnl Checks for libraries. |
| APR_CHECK_DEFINE(LOCK_EX, sys/file.h) |
| APR_CHECK_DEFINE(F_SETLK, fcntl.h) |
| APR_CHECK_DEFINE(SEM_UNDO, sys/sem.h) |
| |
| # We are assuming that if the platform doesn't have POLLIN, it doesn't have |
| # any POLL definitions. |
| APR_CHECK_DEFINE_FILES(POLLIN, poll.h sys/poll.h) |
| |
| if test "$threads" = "1"; then |
| APR_CHECK_DEFINE(PTHREAD_PROCESS_SHARED, pthread.h) |
| AC_CHECK_FUNCS(pthread_mutex_timedlock pthread_mutexattr_setpshared) |
| APR_IFALLYES(header:pthread.h func:pthread_mutex_timedlock, |
| have_pthread_mutex_timedlock="1", have_pthread_mutex_timedlock="0") |
| AC_SUBST(have_pthread_mutex_timedlock) |
| # Some systems have setpshared and define PROCESS_SHARED, but don't |
| # really support PROCESS_SHARED locks. So, we must validate that we |
| # can go through the steps without receiving some sort of system error. |
| # Linux and older versions of AIX have this problem. |
| APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED func:pthread_mutexattr_setpshared, [ |
| AC_CACHE_CHECK([for working PROCESS_SHARED locks], apr_cv_process_shared_works, [ |
| AC_TRY_RUN([ |
| #include <sys/types.h> |
| #include <pthread.h> |
| #include <stdlib.h> |
| int main() |
| { |
| pthread_mutex_t mutex; |
| pthread_mutexattr_t attr; |
| if (pthread_mutexattr_init(&attr)) |
| exit(1); |
| if (pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED)) |
| exit(2); |
| if (pthread_mutex_init(&mutex, &attr)) |
| exit(3); |
| if (pthread_mutexattr_destroy(&attr)) |
| exit(4); |
| if (pthread_mutex_destroy(&mutex)) |
| exit(5); |
| exit(0); |
| }], [apr_cv_process_shared_works=yes], [apr_cv_process_shared_works=no])]) |
| # Override detection of pthread_mutexattr_setpshared |
| ac_cv_func_pthread_mutexattr_setpshared=$apr_cv_process_shared_works]) |
| |
| if test "$ac_cv_func_pthread_mutexattr_setpshared" = "yes"; then |
| APR_CHECK_PTHREAD_ROBUST_SHARED_MUTEX |
| fi |
| fi |
| |
| # See which lock mechanisms we can support on this system. |
| APR_IFALLYES(header:semaphore.h func:sem_open func:sem_close dnl |
| func:sem_unlink func:sem_post func:sem_wait, |
| hasposixser="1", hasposixser="0") |
| APR_IFALLYES(func:semget func:semctl func:semop define:SEM_UNDO, |
| hassysvser="1", hassysvser="0") |
| APR_IFALLYES(func:flock define:LOCK_EX, hasflockser="1", hasflockser="0") |
| APR_IFALLYES(header:fcntl.h define:F_SETLK, hasfcntlser="1", hasfcntlser="0") |
| # note: the current APR use of shared mutex requires /dev/zero |
| APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED dnl |
| func:pthread_mutexattr_setpshared dnl |
| file:/dev/zero, |
| hasprocpthreadser="1", hasprocpthreadser="0") |
| APR_IFALLYES(header:OS.h func:create_sem, hasbeossem="1", hasbeossem="0") |
| |
| AC_CHECK_FUNCS(pthread_condattr_setpshared) |
| APR_IFALLYES(header:pthread.h func:pthread_condattr_setpshared, |
| have_pthread_condattr_setpshared="1", have_pthread_condattr_setpshared="0") |
| AC_SUBST(have_pthread_condattr_setpshared) |
| |
| # See which lock mechanism we'll select by default on this system. |
| # The last APR_DECIDE to execute sets the default. |
| # At this stage, we match the ordering in Apache 1.3 |
| # which is (highest to lowest): sysvsem -> fcntl -> flock. |
| # POSIX semaphores and cross-process pthread mutexes are not |
| # used by default since they have less desirable behaviour when |
| # e.g. a process holding the mutex segfaults. |
| # The BEOSSEM decision doesn't require any substitutions but is |
| # included here to prevent the fcntl() branch being selected |
| # from the decision making. |
| APR_BEGIN_DECISION([apr_lock implementation method]) |
| APR_IFALLYES(func:flock define:LOCK_EX, |
| APR_DECIDE(USE_FLOCK_SERIALIZE, [4.2BSD-style flock()])) |
| APR_IFALLYES(header:fcntl.h define:F_SETLK, |
| APR_DECIDE(USE_FCNTL_SERIALIZE, [SVR4-style fcntl()])) |
| APR_IFALLYES(func:semget func:semctl func:semop define:SEM_UNDO, |
| APR_DECIDE(USE_SYSVSEM_SERIALIZE, [SysV IPC semget()])) |
| APR_IFALLYES(header:OS.h func:create_sem func:acquire_sem func:acquire_sem_etc, |
| APR_DECIDE(USE_BEOSSEM, [BeOS Semaphores])) |
| # pthread mutex both pshared and robust[_np] is the best default |
| case "$hasprocpthreadser:$apr_cv_mutex_robust_shared" in |
| "1:yes" | "1:np") |
| APR_DECIDE(USE_PROC_PTHREAD_SERIALIZE, [pthread pshared mutex]) |
| ;; |
| *) |
| ;; |
| esac |
| if test "x$apr_lock_method" != "x"; then |
| APR_DECISION_FORCE($apr_lock_method) |
| fi |
| APR_END_DECISION |
| AC_DEFINE_UNQUOTED($ac_decision) |
| |
| flockser="0" |
| sysvser="0" |
| posixser="0" |
| procpthreadser="0" |
| fcntlser="0" |
| case $ac_decision in |
| USE_FLOCK_SERIALIZE ) |
| hasflockser="1" |
| flockser="1" |
| ;; |
| USE_FCNTL_SERIALIZE ) |
| hasfcntlser="1" |
| fcntlser="1" |
| ;; |
| USE_SYSVSEM_SERIALIZE ) |
| hassysvser="1" |
| sysvser="1" |
| ;; |
| USE_POSIXSEM_SERIALIZE ) |
| hasposixser="1" |
| posixser="1" |
| ;; |
| USE_PROC_PTHREAD_SERIALIZE ) |
| hasprocpthreadser="1" |
| procpthreadser="1" |
| ;; |
| USE_BEOSSEM ) |
| hasbeossem="1" |
| beossem="1" |
| ;; |
| esac |
| |
| if test $hasfcntlser = "1"; then |
| AC_MSG_CHECKING(if fcntl returns EACCES when F_SETLK is already held) |
| AC_TRY_RUN([ |
| #ifdef HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| #ifdef HAVE_SYS_TYPES_H |
| #include <sys/types.h> |
| #endif |
| #ifdef HAVE_SYS_STAT_H |
| #include <sys/stat.h> |
| #endif |
| #ifdef HAVE_SYS_WAIT_H |
| #include <sys/wait.h> |
| #endif |
| #if defined(HAVE_UNISTD_H) |
| #include <unistd.h> |
| #endif |
| #include <fcntl.h> |
| #include <errno.h> |
| #ifdef HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| int fd; |
| struct flock proc_mutex_lock_it = {0}; |
| const char *fname = "conftest.fcntl"; |
| |
| int main() |
| { |
| int rc, status;; |
| proc_mutex_lock_it.l_whence = SEEK_SET; /* from current point */ |
| proc_mutex_lock_it.l_type = F_WRLCK; /* set exclusive/write lock */ |
| |
| fd = creat(fname, S_IRWXU); |
| unlink(fname); |
| |
| if (rc = lockit()) { |
| exit(-1); |
| } |
| |
| if (fork()) { |
| wait(&status); |
| } |
| else { |
| return(lockit()); |
| } |
| |
| close(fd); |
| exit(WEXITSTATUS(status) != EACCES); |
| } |
| |
| int lockit() { |
| int rc; |
| do { |
| rc = fcntl(fd, F_SETLK, &proc_mutex_lock_it); |
| } while ( rc < 0 && errno == EINTR); |
| |
| return (rc < 0) ? errno : 0; |
| }], [apr_fcntl_tryacquire_eacces=1], [apr_fcntl_tryacquire_eacces=0], [apr_fcntl_tryacquire_eacces=0]) |
| fi |
| |
| if test "$apr_fcntl_tryacquire_eacces" = "1"; then |
| AC_DEFINE(FCNTL_TRYACQUIRE_EACCES, 1, [Define if fcntl returns EACCES when F_SETLK is already held]) |
| AC_MSG_RESULT(yes) |
| else |
| AC_MSG_RESULT(no) |
| fi |
| |
| |
| AC_SUBST(hasflockser) |
| AC_SUBST(hassysvser) |
| AC_SUBST(hasposixser) |
| AC_SUBST(hasfcntlser) |
| AC_SUBST(hasprocpthreadser) |
| AC_SUBST(flockser) |
| AC_SUBST(sysvser) |
| AC_SUBST(posixser) |
| AC_SUBST(fcntlser) |
| AC_SUBST(procpthreadser) |
| AC_SUBST(pthreadser) |
| |
| AC_MSG_CHECKING(if all interprocess locks affect threads) |
| if test "x$apr_process_lock_is_global" = "xyes"; then |
| proclockglobal="1" |
| AC_MSG_RESULT(yes) |
| else |
| proclockglobal="0" |
| AC_MSG_RESULT(no) |
| fi |
| |
| AC_SUBST(proclockglobal) |
| |
| AC_MSG_CHECKING(if POSIX sems affect threads in the same process) |
| if test "x$apr_posixsem_is_global" = "xyes"; then |
| AC_DEFINE(POSIXSEM_IS_GLOBAL, 1, |
| [Define if POSIX semaphores affect threads within the process]) |
| AC_MSG_RESULT(yes) |
| else |
| AC_MSG_RESULT(no) |
| fi |
| |
| AC_MSG_CHECKING(if SysV sems affect threads in the same process) |
| if test "x$apr_sysvsem_is_global" = "xyes"; then |
| AC_DEFINE(SYSVSEM_IS_GLOBAL, 1, |
| [Define if SysV semaphores affect threads within the process]) |
| AC_MSG_RESULT(yes) |
| else |
| AC_MSG_RESULT(no) |
| fi |
| |
| AC_MSG_CHECKING(if fcntl locks affect threads in the same process) |
| if test "x$apr_fcntl_is_global" = "xyes"; then |
| AC_DEFINE(FCNTL_IS_GLOBAL, 1, |
| [Define if fcntl locks affect threads within the process]) |
| AC_MSG_RESULT(yes) |
| else |
| AC_MSG_RESULT(no) |
| fi |
| |
| AC_MSG_CHECKING(if flock locks affect threads in the same process) |
| if test "x$apr_flock_is_global" = "xyes"; then |
| AC_DEFINE(FLOCK_IS_GLOBAL, 1, |
| [Define if flock locks affect threads within the process]) |
| AC_MSG_RESULT(yes) |
| else |
| AC_MSG_RESULT(no) |
| fi |
| |
| dnl ----------------------------- Checking for /dev/random |
| AC_CHECK_HEADERS(sys/random.h) |
| AC_CHECK_FUNCS(getrandom) |
| |
| AC_CHECK_HEADERS(sys/syscall.h) |
| AC_CHECK_HEADERS(linux/random.h) |
| AC_CHECK_DECLS([SYS_getrandom], [], [], [#include <sys/syscall.h>]) |
| |
| AC_CHECK_FUNCS(arc4random_buf) |
| |
| AC_MSG_CHECKING(for entropy source) |
| |
| why_no_rand="" |
| |
| AC_ARG_WITH(egd, |
| [ --with-egd[[=DIR]] use EGD-compatible socket], |
| [ AC_DEFINE(HAVE_EGD, 1, [Define if EGD is supported]) |
| if test "$withval" = "yes"; then |
| AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["/var/run/egd-pool","/dev/egd-pool","/etc/egd-pool","/etc/entropy"], |
| [Define to list of paths to EGD sockets]) |
| else |
| AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["$withval"]) |
| fi |
| AC_MSG_RESULT(EGD-compatible daemon) |
| rand="1" |
| ]) |
| |
| if test "$rand" != "1"; then |
| if test "$ac_cv_func_getrandom" = yes; then |
| rand="getrandom" |
| elif test "$ac_cv_have_decl_SYS_getrandom" = yes; then |
| rand="SYS_getrandom" |
| elif test "$ac_cv_func_arc4random_buf" = yes; then |
| rand="arc4random" |
| fi |
| fi |
| |
| if test "$rand" != "1"; then |
| AC_ARG_WITH(devrandom, |
| [ --with-devrandom[[=DEV]] use /dev/random or compatible [[searches by default]]], |
| [ apr_devrandom="$withval" ], [ apr_devrandom="no" ]) |
| if test "$apr_devrandom" = "no"; then |
| if test -z "$rand"; then |
| apr_devrandom="yes" |
| else |
| apr_devrandom="no" |
| fi |
| fi |
| |
| if test "$apr_devrandom" = "yes"; then |
| # /dev/random on OpenBSD doesn't provide random data, so |
| # prefer /dev/arandom, which does; see random(4). |
| for f in /dev/arandom /dev/urandom /dev/random; do |
| if test -r $f; then |
| apr_devrandom=$f |
| rand="1" |
| break |
| fi |
| done |
| elif test "$apr_devrandom" != "no"; then |
| if test -r "$apr_devrandom"; then |
| rand="1" |
| else |
| AC_ERROR([$apr_devrandom not found or unreadable.]) |
| fi |
| fi |
| |
| if test "$rand" = "1"; then |
| case $host in |
| *os390) |
| if test $os_version -lt 1700; then |
| rand="0" |
| why_no_rand=" ($apr_devrandom unusable on z/OS before V1R7)" |
| fi |
| ;; |
| esac |
| fi |
| |
| if test "$rand" = "1"; then |
| AC_DEFINE_UNQUOTED(DEV_RANDOM, ["$apr_devrandom"], [Define to path of random device]) |
| AC_MSG_RESULT([$apr_devrandom]) |
| elif test -n "$rand"; then |
| AC_DEFINE_UNQUOTED(SYS_RANDOM, ["$rand"], [Define system call of random]) |
| AC_MSG_RESULT([$rand]) |
| rand="1" |
| fi |
| fi |
| |
| if test "$rand" != "1"; then |
| case $host in |
| # we have built in support for OS/2 |
| *-os2*) |
| AC_MSG_RESULT([Using OS/2 builtin random]) |
| rand="1" |
| ;; |
| *) |
| if test "$rand" != "1"; then |
| if test "$ac_cv_lib_truerand_main" = "yes"; then |
| AC_DEFINE(HAVE_TRUERAND, 1, [Define if truerand is supported]) |
| AC_MSG_RESULT(truerand) |
| rand="1" |
| else |
| AC_MSG_RESULT(not found$why_no_rand) |
| rand="0" |
| fi |
| fi |
| ;; |
| esac |
| fi |
| |
| AC_SUBST(rand) |
| |
| dnl ----------------------------- Checking for File Info Support |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for File Info Support...]) |
| AC_CHECK_MEMBERS([struct stat.st_blocks, struct stat.st_atimensec, |
| struct stat.st_ctimensec, struct stat.st_mtimensec, struct stat.st_atim.tv_nsec, |
| struct stat.st_ctim.tv_nsec, struct stat.st_mtim.tv_nsec, |
| struct stat.st_atime_n, struct stat.st_ctime_n, struct stat.st_mtime_n],,,[ |
| #ifdef HAVE_SYS_TYPES_H |
| #include <sys/types.h> |
| #endif |
| #ifdef HAVE_SYS_STAT_H |
| #include <sys/stat.h> |
| #endif |
| #ifdef HAVE_UNISTD_H |
| #include <unistd.h> |
| #endif]) |
| |
| APR_CHECK_DIRENT_INODE |
| APR_CHECK_DIRENT_TYPE |
| |
| dnl ----------------------------- Checking for UUID Support |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for OS UUID Support...]) |
| |
| AC_CHECK_HEADERS(uuid.h uuid/uuid.h sys/uuid.h, break) |
| |
| apr_revert_save_LIBS=$LIBS |
| |
| # Prefer the flavor(s) that live in libc; |
| AC_SEARCH_LIBS(uuid_create, uuid) |
| AC_SEARCH_LIBS(uuid_generate, uuid) |
| if test "$ac_cv_search_uuid_create" = "none required" -o \ |
| "$ac_cv_search_uuid_generate" = "none required"; then |
| LIBS=$apr_revert_save_LIBS |
| fi |
| |
| AC_CHECK_FUNCS(uuid_create uuid_generate) |
| |
| AC_CACHE_CHECK([for os uuid usability], [apr_cv_osuuid], [ |
| # Ensure this test closely mirrors misc/unix/rand.c! |
| uuid_includes=" |
| #if defined(HAVE_SYS_TYPES_H) |
| #include <sys/types.h> |
| #endif |
| #if defined(HAVE_UNISTD_H) |
| #include <unistd.h> |
| #endif |
| #if defined(HAVE_UUID_H) |
| #include <uuid.h> |
| #elif defined(HAVE_UUID_UUID_H) |
| #include <uuid/uuid.h> |
| #elif defined(HAVE_SYS_UUID_H) |
| #include <sys/uuid.h> |
| #endif |
| " |
| apr_cv_osuuid=no |
| if test $ac_cv_func_uuid_create = yes; then |
| AC_TRY_LINK([$uuid_includes], [ |
| uuid_t g; |
| uint32_t s; |
| uuid_create(&g, &s); |
| if (s == uuid_s_ok) s = 0; |
| ], [apr_cv_osuuid=yes], [apr_cv_func_uuid_create=no]) |
| fi |
| if test $ac_cv_func_uuid_generate = yes; then |
| AC_TRY_LINK([$uuid_includes], [ |
| uuid_t g; |
| uuid_generate(g); |
| ], [apr_cv_osuuid=yes], [apr_cv_func_uuid_generate=no]) |
| fi |
| ]) |
| |
| if test $apr_cv_osuuid = yes; then |
| osuuid="1" |
| else |
| osuuid="0" |
| LIBS=$apr_revert_save_LIBS |
| fi |
| AC_SUBST(osuuid) |
| |
| |
| dnl ----------------------------- Checking for Time Support |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for Time Support...]) |
| |
| AC_CHECK_MEMBERS([struct tm.tm_gmtoff, struct tm.__tm_gmtoff],,,[ |
| #include <sys/types.h> |
| #include <time.h>]) |
| |
| dnl ----------------------------- Checking for Networking Support |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for Networking support...]) |
| APR_TYPE_IN_ADDR |
| if test "$ac_cv_type_in_addr" = "yes"; then |
| have_in_addr="1" |
| else |
| have_in_addr="0" |
| fi |
| |
| AC_MSG_CHECKING([if fd == socket on this platform]) |
| if test "x$file_as_socket" != "x0" ; then |
| file_as_socket="1"; |
| AC_MSG_RESULT([yes]) |
| else |
| AC_MSG_RESULT([no]) |
| fi |
| |
| AC_SUBST(have_in_addr) |
| AC_SUBST(file_as_socket) |
| |
| if test "$ac_cv_func_poll $file_as_socket" = "yes 1"; then |
| AC_DEFINE(WAITIO_USES_POLL, 1, |
| [Define if apr_wait_for_io_or_timeout() uses poll(2)]) |
| fi |
| |
| # Check the types only if we have gethostbyname_r |
| if test "$ac_cv_func_gethostbyname_r" = "yes"; then |
| APR_CHECK_GETHOSTBYNAME_R_STYLE |
| fi |
| |
| # Check the types only if we have getservbyname_r |
| if test "$ac_cv_func_getservbyname_r" = "yes"; then |
| APR_CHECK_GETSERVBYNAME_R_STYLE |
| fi |
| |
| APR_CHECK_TCP_NODELAY_INHERITED |
| APR_CHECK_O_NONBLOCK_INHERITED |
| APR_CHECK_TCP_NODELAY_WITH_CORK |
| |
| # Look for a way of corking TCP... |
| APR_CHECK_DEFINE(TCP_CORK, netinet/tcp.h) |
| APR_CHECK_DEFINE(TCP_NOPUSH, netinet/tcp.h) |
| apr_tcp_nopush_flag="0" |
| have_corkable_tcp="0" |
| if test "x$ac_cv_define_TCP_CORK" = "xyes"; then |
| apr_tcp_nopush_flag="TCP_CORK" |
| have_corkable_tcp="1" |
| else |
| case $host in |
| *linux*) |
| AC_EGREP_CPP(yes,[ |
| #include <linux/socket.h> |
| #ifdef TCP_CORK |
| yes |
| #endif |
| ],[ |
| apr_tcp_nopush_flag="3" |
| have_corkable_tcp="1" |
| ]) |
| ;; |
| *) |
| ;; |
| esac |
| fi |
| if test "x$ac_cv_define_TCP_NOPUSH" = "xyes"; then |
| apr_tcp_nopush_flag="TCP_NOPUSH" |
| have_corkable_tcp="1" |
| fi |
| |
| APR_CHECK_DEFINE(SO_ACCEPTFILTER, sys/socket.h) |
| if test "x$ac_cv_define_SO_ACCEPTFILTER" = "xyes"; then |
| acceptfilter="1" |
| else |
| acceptfilter="0" |
| fi |
| |
| APR_CHECK_SCTP |
| APR_CHECK_MCAST |
| |
| AC_SUBST(apr_tcp_nopush_flag) |
| AC_SUBST(have_corkable_tcp) |
| AC_SUBST(acceptfilter) |
| AC_SUBST(have_sctp) |
| |
| AC_CHECK_FUNCS(set_h_errno) |
| |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Checking for IPv6 Networking support...]) |
| dnl Start of checking for IPv6 support... |
| |
| AC_ARG_ENABLE(ipv6, |
| [ --disable-ipv6 Disable IPv6 support in APR.], |
| [ if test "$enableval" = "no"; then |
| user_disabled_ipv6=1 |
| fi ], |
| [ user_disabled_ipv6=0 ] ) |
| |
| case $host in |
| *) |
| broken_ipv6=0 |
| esac |
| |
| AC_SEARCH_LIBS(getaddrinfo, socket inet6) |
| AC_SEARCH_LIBS(gai_strerror, socket inet6) |
| AC_SEARCH_LIBS(getnameinfo, socket inet6) |
| AC_CHECK_FUNCS(gai_strerror if_nametoindex if_indextoname) |
| APR_CHECK_WORKING_GETADDRINFO |
| APR_CHECK_NEGATIVE_EAI |
| APR_CHECK_WORKING_GETNAMEINFO |
| APR_CHECK_SOCKADDR_IN6 |
| APR_CHECK_SOCKADDR_STORAGE |
| APR_CHECK_SOCKADDR_UN |
| |
| have_ipv6="0" |
| if test "$user_disabled_ipv6" = 1; then |
| ipv6_result="no -- disabled by user" |
| else |
| if test "x$broken_ipv6" = "x0"; then |
| if test "x$have_sockaddr_in6" = "x1"; then |
| if test "x$ac_cv_working_getaddrinfo" = "xyes"; then |
| if test "x$ac_cv_working_getnameinfo" = "xyes"; then |
| APR_CHECK_GETADDRINFO_ADDRCONFIG |
| have_ipv6="1" |
| ipv6_result="yes" |
| else |
| ipv6_result="no -- no getnameinfo" |
| fi |
| else |
| ipv6_result="no -- no working getaddrinfo" |
| fi |
| else |
| ipv6_result="no -- no sockaddr_in6" |
| fi |
| else |
| ipv6_result="no -- the platform has known problems supporting IPv6" |
| fi |
| fi |
| |
| AC_MSG_CHECKING(if APR supports IPv6) |
| AC_MSG_RESULT($ipv6_result) |
| |
| AC_SUBST(have_ipv6) |
| |
| # hstrerror is only needed if IPv6 is not enabled, |
| # so getaddrinfo/gai_strerror are not used. |
| if test $have_ipv6 = 0; then |
| AC_SEARCH_LIBS(hstrerror, resolv, |
| [AC_DEFINE(HAVE_HSTRERROR, 1, [Define if hstrerror is present])]) |
| fi |
| |
| dnl Check for langinfo support |
| |
| AC_CHECK_HEADERS(langinfo.h) |
| AC_CHECK_FUNCS(nl_langinfo) |
| |
| dnl ------------------------------ Defaults for some platform nuances |
| |
| dnl Do we have a Win32-centric Unicode FS? |
| APR_SETIFNULL(have_unicode_fs, [0]) |
| AC_SUBST(have_unicode_fs) |
| |
| APR_SETIFNULL(apr_has_xthread_files, [0]) |
| AC_SUBST(apr_has_xthread_files) |
| |
| APR_SETIFNULL(apr_procattr_user_set_requires_password, [0]) |
| AC_SUBST(apr_procattr_user_set_requires_password) |
| |
| APR_SETIFNULL(apr_thread_func, []) |
| AC_SUBST(apr_thread_func) |
| |
| APR_SETIFNULL(apr_has_user, [1]) |
| AC_SUBST(apr_has_user) |
| |
| dnl ------------------------------ APR-util stuff |
| |
| APU_PRELOAD |
| |
| dnl Find crypto libraries |
| APU_CHECK_CRYPTO |
| |
| dnl Find DBM and DBD backends to use. |
| APU_CHECK_DBM |
| APU_CHECK_DBD |
| APU_CHECK_DBD_MYSQL |
| APU_CHECK_DBD_SQLITE3 |
| APU_CHECK_DBD_SQLITE2 |
| APU_CHECK_DBD_ORACLE |
| APU_CHECK_DBD_ODBC |
| |
| dnl select an XML parser |
| APU_FIND_XML |
| |
| dnl Find iconv implementations |
| APU_FIND_ICONV |
| |
| dnl Enable DSO build; must be last: |
| APR_MODULAR_DSO |
| |
| AC_SEARCH_LIBS(crypt, crypt ufc) |
| AC_MSG_CHECKING(if system crypt() function is threadsafe) |
| if test "x$apu_crypt_threadsafe" = "x1"; then |
| AC_DEFINE(APU_CRYPT_THREADSAFE, 1, [Define if the system crypt() function is threadsafe]) |
| msg="yes" |
| else |
| msg="no" |
| fi |
| AC_MSG_RESULT([$msg]) |
| |
| AC_CHECK_FUNCS(crypt_r, [ crypt_r="1" ], [ crypt_r="0" ]) |
| if test "$crypt_r" = "1"; then |
| APU_CHECK_CRYPT_R_STYLE |
| fi |
| |
| APRUTIL_LIBNAME="aprutil${libsuffix}" |
| AC_SUBST(APRUTIL_LIBNAME) |
| |
| # Set up destination directory for DSOs. |
| APR_DSO_LIBDIR="\${libdir}/apr-${APR_MAJOR_VERSION}" |
| # Set APU_HAVE_MODULES appropriately for the Makefile |
| if test -n "$APR_DSO_MODULES"; then |
| APR_HAVE_MODULES=yes |
| else |
| APR_HAVE_MODULES=no |
| fi |
| APR_EXPAND_VAR(abs_dso_libdir, $APR_DSO_LIBDIR) |
| AC_DEFINE_UNQUOTED([APR_DSO_LIBDIR], ["$abs_dso_libdir"], |
| [Define to be absolute path to DSO directory]) |
| AC_SUBST(APR_HAVE_MODULES) |
| AC_SUBST(APR_DSO_LIBDIR) |
| AC_SUBST(APR_DSO_MODULES) |
| AC_SUBST(EXTRA_OBJECTS) |
| |
| dnl XXX FIXME; used for -lexpat, -liconv etc? |
| AC_SUBST(APRUTIL_EXPORT_LIBS) |
| |
| dnl |
| dnl Prep all the flags and stuff for compilation and export to other builds |
| dnl |
| APR_ADDTO(LIBS, [$APRUTIL_LIBS]) |
| |
| AC_SUBST(LDFLAGS) |
| |
| |
| |
| dnl ----------------------------- Finalize the variables |
| |
| AC_MSG_NOTICE([]) |
| AC_MSG_NOTICE([Restore user-defined environment settings...]) |
| |
| APR_RESTORE_THE_ENVIRONMENT(CPPFLAGS, EXTRA_) |
| APR_RESTORE_THE_ENVIRONMENT(CFLAGS, EXTRA_) |
| APR_RESTORE_THE_ENVIRONMENT(LDFLAGS, EXTRA_) |
| APR_RESTORE_THE_ENVIRONMENT(LIBS, EXTRA_) |
| APR_RESTORE_THE_ENVIRONMENT(INCLUDES, EXTRA_) |
| AC_SUBST(NOTEST_CPPFLAGS) |
| AC_SUBST(NOTEST_CFLAGS) |
| AC_SUBST(NOTEST_LDFLAGS) |
| AC_SUBST(NOTEST_LIBS) |
| AC_SUBST(NOTEST_INCLUDES) |
| |
| dnl ----------------------------- Construct the files |
| |
| AC_SUBST(INTERNAL_CPPFLAGS) |
| AC_SUBST(LDLIBS) |
| AC_SUBST(INCLUDES) |
| AC_SUBST(AR) |
| AC_SUBST(RM) |
| AC_SUBST(OSDIR) |
| AC_SUBST(DEFAULT_OSDIR) |
| AC_SUBST(EXEEXT) |
| AC_SUBST(LIBTOOL_LIBS) |
| |
| # Use -no-install or -no-fast-install to link the test |
| # programs on all platforms but Darwin, where it would cause |
| # the programs to be linked against installed versions of |
| # libapr instead of those just built. |
| case $host in |
| *-apple-darwin*) |
| LT_NO_INSTALL="" |
| ;; |
| *-mingw*) |
| LT_NO_INSTALL="-no-fast-install" |
| ;; |
| *) |
| LT_NO_INSTALL="-no-install" |
| ;; |
| esac |
| AC_SUBST(LT_NO_INSTALL) |
| |
| # |
| # BSD/OS (BSDi) needs to use a different include syntax in the Makefiles |
| # |
| case $host in |
| *bsdi*) |
| # Check whether they've installed GNU make |
| if make --version > /dev/null 2>&1; then |
| INCLUDE_RULES="include $apr_buildout/apr_rules.mk" |
| INCLUDE_OUTPUTS="include $apr_srcdir/build-outputs.mk" |
| else |
| # BSDi make |
| INCLUDE_RULES=".include \"$apr_buildout/apr_rules.mk\"" |
| INCLUDE_OUTPUTS=".include \"$apr_srcdir/build-outputs.mk\"" |
| fi |
| ;; |
| *) |
| INCLUDE_RULES="include $apr_buildout/apr_rules.mk" |
| INCLUDE_OUTPUTS="include $apr_srcdir/build-outputs.mk" |
| ;; |
| esac |
| AC_SUBST(INCLUDE_RULES) |
| AC_SUBST(INCLUDE_OUTPUTS) |
| |
| AC_CONFIG_FILES([Makefile |
| include/apr.h |
| build/apr_rules.mk |
| build/pkg/pkginfo |
| apr-$APR_MAJOR_VERSION-config:apr-config.in |
| apr.pc]) |
| |
| if test -d $srcdir/test; then |
| AC_CONFIG_FILES([test/Makefile test/internal/Makefile]) |
| fi |
| |
| AC_CONFIG_FILES([include/private/apu_select_dbm.h |
| include/apu_want.h]) |
| |
| dir=include/arch/unix |
| test -d $dir || $MKDIR $dir |
| |
| AC_CONFIG_COMMANDS([default], [ |
| # Commands run at the end of config.status: |
| for i in $APR_SAVE_HEADERS; do |
| if cmp -s $i $i.save 2>/dev/null; then |
| mv $i.save $i |
| AC_MSG_NOTICE([$i is unchanged]) |
| fi |
| rm -f $i.save |
| done |
| chmod +x apr-$APR_MAJOR_VERSION-config |
| ],[ |
| dnl This section is expanded by configure UNQUOTED so variable |
| dnl references must be backslash-escaped as necessary. |
| |
| # Commands run at the beginning of config.status: |
| APR_SAVE_HEADERS="include/apr.h include/arch/unix/apr_private.h" |
| APR_MAJOR_VERSION=$APR_MAJOR_VERSION |
| APR_PLATFORM=$host |
| |
| for apri in \${APR_SAVE_HEADERS}; do |
| test -r \${apri} && mv \${apri} \${apri}.save |
| done |
| ]) |
| |
| AC_OUTPUT |