937a200089
This is actually a fully functional build except: * All internal shared libraries are static linked to make sure there is no interference with ports (and to reduce build time). * It does not have the python/perl/etc plugin or API support. * By default, it installs as "svnlite" rather than "svn". * If WITH_SVN added in make.conf, you get "svn". * If WITHOUT_SVNLITE is in make.conf, this is completely disabled. To be absolutely clear, this is not intended for any use other than checking out freebsd source and committing, like we once did with cvs. It should be usable for small scale local repositories that don't need the python/perl plugin architecture.
2810 lines
78 KiB
Plaintext
2810 lines
78 KiB
Plaintext
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)
|
|
|
|
dnl Hard-coded top of apr_private.h:
|
|
AH_TOP([
|
|
#ifndef APR_PRIVATE_H
|
|
#define APR_PRIVATE_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 BEOS && !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 */
|
|
|
|
/*
|
|
* Include common private declarations.
|
|
*/
|
|
#include "../apr_private_common.h"
|
|
#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
|
|
echo "Configuring APR library"
|
|
echo "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)
|
|
|
|
echo "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)
|
|
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 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"
|
|
echo "(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_PROG(AS, as, as)
|
|
AC_CHECK_PROG(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
|
|
echo "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
|
|
echo "using aplibtool"
|
|
LIBTOOL="$srcdir/build/aplibtool"
|
|
gcc $CFLAGS $CPPFLAGS -o $LIBTOOL.exe $LIBTOOL.c
|
|
;;
|
|
*)
|
|
if test "x$LTFLAGS" = "x"; then
|
|
LTFLAGS='--silent'
|
|
fi
|
|
if test "$experimental_libtool" = "yes"; then
|
|
# Use a custom-made libtool replacement
|
|
echo "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
|
|
eval `grep "^shlibpath_var=[[A-Z_]]*$" $apr_builddir/libtool`
|
|
if test "x$shlibpath_var" = "x"; then
|
|
shlibpath_var=REPLACE_WITH_YOUR_SHLIBPATH_VAR
|
|
fi
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
AC_ARG_WITH(installbuilddir, [ --with-installbuilddir=DIR location to store APR build files (defaults to '${datadir}/build')],
|
|
[ installbuilddir=$withval ], [ installbuilddir="${datadir}/build-${APR_MAJOR_VERSION}" ] )
|
|
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 $(COMPILE) -o $@ -c $< && touch $@'
|
|
LT_VERSION="-version-info `$get_version libtool $version_hdr APR`"
|
|
link="\$(LIBTOOL) \$(LTFLAGS) --mode=link \$(LT_LDFLAGS) \$(COMPILE) \$(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"
|
|
;;
|
|
*)
|
|
;;
|
|
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='
|
|
'
|
|
echo "${nl}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])
|
|
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
|
|
])
|
|
|
|
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)
|
|
;;
|
|
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
|
|
|
|
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
|
|
;;
|
|
*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 ;;
|
|
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_version=`uname -r | sed -e 's/\(.\)\.\(.\)\.\(.\).*/\1\2\3/'`
|
|
;;
|
|
*os390)
|
|
os_version=`uname -r | sed -e 's/\.//g'`
|
|
;;
|
|
*)
|
|
os_version=OS_VERSION_IS_NOT_SET
|
|
;;
|
|
esac
|
|
|
|
echo "${nl}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
|
|
echo "${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=no
|
|
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
|
|
echo "APR will use threads"
|
|
AC_CHECK_LIB(c_r, readdir,
|
|
AC_DEFINE(READDIR_IS_THREAD_SAFE, 1,
|
|
[Define if 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
|
|
echo "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_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
|
|
|
|
# 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
|
|
AC_CACHE_CHECK([for accept4 support], [apr_cv_accept4],
|
|
[AC_TRY_RUN([
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
#include <sys/wait.h>
|
|
#include <signal.h>
|
|
#include <errno.h>
|
|
|
|
#define A4_SOCK "./apr_accept4_test_socket"
|
|
|
|
int main()
|
|
{
|
|
pid_t pid;
|
|
int fd;
|
|
struct sockaddr_un loc, rem;
|
|
socklen_t rem_sz;
|
|
|
|
if ((pid = fork())) {
|
|
int status;
|
|
|
|
unlink(A4_SOCK);
|
|
|
|
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
|
|
goto cleanup_failure2;
|
|
|
|
loc.sun_family = AF_UNIX;
|
|
strncpy(loc.sun_path, A4_SOCK, sizeof(loc.sun_path) - 1);
|
|
|
|
if (bind(fd, (struct sockaddr *) &loc,
|
|
sizeof(struct sockaddr_un)) == -1)
|
|
goto cleanup_failure;
|
|
|
|
if (listen(fd, 5) == -1)
|
|
goto cleanup_failure;
|
|
|
|
rem_sz = sizeof(struct sockaddr_un);
|
|
if (accept4(fd, (struct sockaddr *) &rem, &rem_sz, 0) == -1) {
|
|
goto cleanup_failure;
|
|
}
|
|
else {
|
|
close(fd);
|
|
waitpid(pid, &status, 0);
|
|
unlink(A4_SOCK);
|
|
return 0;
|
|
}
|
|
|
|
cleanup_failure:
|
|
close(fd);
|
|
cleanup_failure2:
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, &status, 0);
|
|
unlink(A4_SOCK);
|
|
return 1;
|
|
}
|
|
else {
|
|
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
|
|
return 1; /* this will be bad: we'll hang */
|
|
|
|
loc.sun_family = AF_UNIX;
|
|
strncpy(loc.sun_path, A4_SOCK, sizeof(loc.sun_path) - 1);
|
|
|
|
while(connect(fd, (struct sockaddr *) &loc,
|
|
sizeof(struct sockaddr_un)) == -1 &&
|
|
(errno==ENOENT || errno==ECONNREFUSED))
|
|
;
|
|
|
|
close(fd);
|
|
return 0;
|
|
}
|
|
}], [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 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
|
|
|
|
# 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
|
|
AC_CACHE_CHECK([for accept4 support], [apr_cv_accept4],
|
|
[AC_TRY_RUN([
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
#include <sys/wait.h>
|
|
#include <signal.h>
|
|
#include <errno.h>
|
|
|
|
#define A4_SOCK "./apr_accept4_test_socket"
|
|
|
|
int main()
|
|
{
|
|
pid_t pid;
|
|
int fd;
|
|
struct sockaddr_un loc, rem;
|
|
socklen_t rem_sz;
|
|
|
|
if ((pid = fork())) {
|
|
int status;
|
|
|
|
unlink(A4_SOCK);
|
|
|
|
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
|
|
goto cleanup_failure2;
|
|
|
|
loc.sun_family = AF_UNIX;
|
|
strncpy(loc.sun_path, A4_SOCK, sizeof(loc.sun_path) - 1);
|
|
|
|
if (bind(fd, (struct sockaddr *) &loc,
|
|
sizeof(struct sockaddr_un)) == -1)
|
|
goto cleanup_failure;
|
|
|
|
if (listen(fd, 5) == -1)
|
|
goto cleanup_failure;
|
|
|
|
rem_sz = sizeof(struct sockaddr_un);
|
|
if (accept4(fd, (struct sockaddr *) &rem, &rem_sz, 0) == -1) {
|
|
goto cleanup_failure;
|
|
}
|
|
else {
|
|
close(fd);
|
|
waitpid(pid, &status, 0);
|
|
unlink(A4_SOCK);
|
|
return 0;
|
|
}
|
|
|
|
cleanup_failure:
|
|
close(fd);
|
|
cleanup_failure2:
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, &status, 0);
|
|
unlink(A4_SOCK);
|
|
return 1;
|
|
}
|
|
else {
|
|
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
|
|
return 1; /* this will be bad: we'll hang */
|
|
|
|
loc.sun_family = AF_UNIX;
|
|
strncpy(loc.sun_path, A4_SOCK, sizeof(loc.sun_path) - 1);
|
|
|
|
while(connect(fd, (struct sockaddr *) &loc,
|
|
sizeof(struct sockaddr_un)) == -1 &&
|
|
(errno==ENOENT || errno==ECONNREFUSED))
|
|
;
|
|
|
|
close(fd);
|
|
return 0;
|
|
}
|
|
}], [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 missing POSIX thread functions
|
|
AC_CHECK_FUNCS([getpwnam_r getpwuid_r getgrnam_r getgrgid_r])
|
|
|
|
dnl ----------------------------- Checking for Shared Memory Support
|
|
echo "${nl}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 kernel/OS.h os2.h windows.h])
|
|
AC_CHECK_FUNCS([mmap munmap shm_open shm_unlink shmget shmat shmdt shmctl \
|
|
create_area])
|
|
|
|
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_MSG_CHECKING(for mmap that can map /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])
|
|
|
|
AC_MSG_RESULT($ac_cv_file__dev_zero)
|
|
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_version -le "240"; then
|
|
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])])
|
|
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_version -le "240"; 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_version -lt 240; then
|
|
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
|
|
echo "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 mkstemp])
|
|
|
|
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(
|
|
ByteOrder.h \
|
|
conio.h \
|
|
crypt.h \
|
|
ctype.h \
|
|
dir.h \
|
|
dirent.h \
|
|
dl.h \
|
|
dlfcn.h \
|
|
errno.h \
|
|
fcntl.h \
|
|
grp.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 \
|
|
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)
|
|
|
|
# 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(arpa_ineth)
|
|
AC_SUBST(conioh)
|
|
AC_SUBST(ctypeh)
|
|
AC_SUBST(crypth)
|
|
AC_SUBST(errnoh)
|
|
AC_SUBST(direnth)
|
|
AC_SUBST(fcntlh)
|
|
AC_SUBST(ioh)
|
|
AC_SUBST(limitsh)
|
|
AC_SUBST(netdbh)
|
|
AC_SUBST(sys_syslimitsh)
|
|
AC_SUBST(netinet_inh)
|
|
AC_SUBST(netinet_sctph)
|
|
AC_SUBST(netinet_sctp_uioh)
|
|
AC_SUBST(netinet_tcph)
|
|
AC_SUBST(stdargh)
|
|
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_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)
|
|
|
|
# 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 (experimental)],
|
|
[ 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 ]
|
|
)
|
|
|
|
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(int, 4)
|
|
AC_CHECK_SIZEOF(long, 4)
|
|
AC_CHECK_SIZEOF(short, 2)
|
|
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.
|
|
if 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"
|
|
long_value=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"
|
|
long_value=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"
|
|
long_value="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"
|
|
long_value="__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
|
|
|
|
APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>], pid_t, 8)
|
|
|
|
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"
|
|
long_value="__int64"
|
|
int64_strfn="_strtoi64"
|
|
;;
|
|
esac
|
|
|
|
APR_CHECK_TYPES_COMPATIBLE(ssize_t, int, [ssize_t_fmt="d"])
|
|
APR_CHECK_TYPES_COMPATIBLE(ssize_t, long, [ssize_t_fmt="ld"])
|
|
APR_CHECK_TYPES_COMPATIBLE(size_t, unsigned int, [size_t_fmt="u"])
|
|
APR_CHECK_TYPES_COMPATIBLE(size_t, unsigned long, [size_t_fmt="lu"])
|
|
|
|
APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>], ssize_t, 8)
|
|
|
|
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\""
|
|
|
|
APR_CHECK_SIZEOF_EXTENDED([#include <stddef.h>], size_t, 8)
|
|
|
|
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\""
|
|
|
|
APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>], off_t, 8)
|
|
|
|
if test "${ac_cv_sizeof_off_t}${apr_cv_use_lfs64}" = "4yes"; then
|
|
# Enable LFS
|
|
aprlfs=1
|
|
AC_CHECK_FUNCS([mmap64 sendfile64 sendfilev64 mkstemp64 readdir64_r])
|
|
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'
|
|
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'
|
|
elif test "$ac_cv_type_off_t" = "yes"; then
|
|
off_t_value=off_t
|
|
# off_t is more commonly a long than an int; prefer that case
|
|
# where int and long are the same size.
|
|
if test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_long"; then
|
|
off_t_fmt='#define APR_OFF_T_FMT "ld"'
|
|
off_t_strfn='strtol'
|
|
elif test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_int"; then
|
|
off_t_fmt='#define APR_OFF_T_FMT "d"'
|
|
off_t_strfn='strtoi'
|
|
elif test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_long_long"; then
|
|
off_t_fmt='#define APR_OFF_T_FMT APR_INT64_T_FMT'
|
|
off_t_strfn='apr_strtoi64'
|
|
else
|
|
AC_ERROR([could not determine the size of off_t])
|
|
fi
|
|
# 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'
|
|
;;
|
|
esac
|
|
else
|
|
# Fallback on int
|
|
off_t_value=apr_int32_t
|
|
off_t_fmt=d
|
|
off_t_strfn='strtoi'
|
|
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
|
|
APR_CHECK_SIZEOF_EXTENDED(AC_INCLUDES_DEFAULT, ino_t, $ac_cv_sizeof_long)
|
|
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
|
|
|
|
APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>
|
|
#include <sys/uio.h>],struct iovec,0)
|
|
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(long_value)
|
|
AC_SUBST(int64_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)
|
|
|
|
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)
|
|
|
|
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
|
|
echo "${nl}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
|
|
echo "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
|
|
echo "${nl}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>
|
|
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
|
|
echo "${nl}Checking for Locking..."
|
|
|
|
AC_CHECK_FUNCS(semget semctl flock)
|
|
AC_CHECK_HEADERS(semaphore.h OS.h)
|
|
AC_SEARCH_LIBS(sem_open, rt)
|
|
AC_CHECK_FUNCS(sem_close sem_unlink sem_post sem_wait create_sem)
|
|
|
|
# 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_mutexattr_setpshared)
|
|
# 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>
|
|
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 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")
|
|
|
|
# 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 define:SEM_UNDO,
|
|
APR_DECIDE(USE_SYSVSEM_SERIALIZE, [SysV IPC semget()]))
|
|
APR_IFALLYES(header:OS.h func:create_sem,
|
|
APR_DECIDE(USE_BEOSSEM, [BeOS Semaphores]))
|
|
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 )
|
|
flockser="1"
|
|
;;
|
|
USE_FCNTL_SERIALIZE )
|
|
fcntlser="1"
|
|
;;
|
|
USE_SYSVSEM_SERIALIZE )
|
|
sysvser="1"
|
|
;;
|
|
USE_POSIXSEM_SERIALIZE )
|
|
posixser="1"
|
|
;;
|
|
USE_PROC_PTHREAD_SERIALIZE )
|
|
procpthreadser="1"
|
|
;;
|
|
USE_BEOSSEM )
|
|
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>
|
|
|
|
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_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
|
|
AC_ARG_WITH(devrandom,
|
|
[ --with-devrandom[[=DEV]] use /dev/random or compatible [[searches by default]]],
|
|
[ apr_devrandom="$withval" ], [ apr_devrandom="yes" ])
|
|
|
|
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])
|
|
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
|
|
echo "${nl}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
|
|
echo "${nl}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
|
|
echo "${nl}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
|
|
echo "${nl}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";
|
|
echo "yes"
|
|
else
|
|
echo "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)
|
|
|
|
echo "${nl}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)
|
|
APR_CHECK_WORKING_GETADDRINFO
|
|
APR_CHECK_NEGATIVE_EAI
|
|
APR_CHECK_WORKING_GETNAMEINFO
|
|
APR_CHECK_SOCKADDR_IN6
|
|
APR_CHECK_SOCKADDR_STORAGE
|
|
|
|
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 ----------------------------- Finalize the variables
|
|
|
|
echo "${nl}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(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 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="" ;;
|
|
*) 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
|
|
|
|
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
|