"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "configure.in" between
apr-1.6.5.tar.bz2 and apr-1.7.0.tar.bz2

About: APR (Apache Portable Runtime) project offers software libraries that provide a predictable and consistent interface to underlying platform-specific implementations (APR core library).

configure.in  (apr-1.6.5.tar.bz2)	:	configure.in  (apr-1.7.0.tar.bz2)
skipping to change at line 266		skipping to change at line 266
eval `$apr_builddir/libtool --config | grep "^shlibpath_var=[[A-Z_]]*$"`		eval `$apr_builddir/libtool --config | grep "^shlibpath_var=[[A-Z_]]*$"`
if test "x$shlibpath_var" = "x"; then		if test "x$shlibpath_var" = "x"; then
shlibpath_var=REPLACE_WITH_YOUR_SHLIBPATH_VAR		shlibpath_var=REPLACE_WITH_YOUR_SHLIBPATH_VAR
fi		fi
else		else
dnl libtoolize requires that the following not be indented		dnl libtoolize requires that the following not be indented
dnl should become LT_INIT(win32-dll)		dnl should become LT_INIT(win32-dll)
AC_LIBTOOL_WIN32_DLL		AC_LIBTOOL_WIN32_DLL
AC_PROG_LIBTOOL		AC_PROG_LIBTOOL
# get libtool's setting of shlibpath_var		# get libtool's setting of shlibpath_var
eval `grep "^shlibpath_var=[[A-Z_]]*$" $apr_builddir/libtool`
if test "x$shlibpath_var" = "x"; then		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		shlibpath_var=REPLACE_WITH_YOUR_SHLIBPATH_VAR
fi		fi
fi		fi
;;		;;
esac		esac
AC_ARG_WITH(installbuilddir, [ --with-installbuilddir=DIR location to store APR build files],		AC_ARG_WITH(installbuilddir, [ --with-installbuilddir=DIR location to store APR build files],
[ installbuilddir=$withval ] )		[ installbuilddir=$withval ] )
AC_SUBST(installbuilddir)		AC_SUBST(installbuilddir)
skipping to change at line 809		skipping to change at line 812
fi		fi
if test "$ac_cv_func_pthread_yield" = "no"; then		if test "$ac_cv_func_pthread_yield" = "no"; then
dnl ----------------------------- Checking for sched_yield		dnl ----------------------------- Checking for sched_yield
AC_CHECK_HEADERS([sched.h])		AC_CHECK_HEADERS([sched.h])
AC_CHECK_FUNCS([sched_yield])		AC_CHECK_FUNCS([sched_yield])
fi		fi
fi		fi
fi		fi
ac_cv_define_READDIR_IS_THREAD_SAFE=no		ac_cv_define_READDIR_IS_THREAD_SAFE=yes
ac_cv_define_GETHOSTBYNAME_IS_THREAD_SAFE=no		ac_cv_define_GETHOSTBYNAME_IS_THREAD_SAFE=no
ac_cv_define_GETHOSTBYADDR_IS_THREAD_SAFE=no		ac_cv_define_GETHOSTBYADDR_IS_THREAD_SAFE=no
ac_cv_define_GETSERVBYNAME_IS_THREAD_SAFE=no		ac_cv_define_GETSERVBYNAME_IS_THREAD_SAFE=no
if test "$threads" = "1"; then		if test "$threads" = "1"; then
echo "APR will use threads"		echo "APR will use threads"
AC_CHECK_LIB(c_r, readdir,		AC_DEFINE(READDIR_IS_THREAD_SAFE, 1, [Modern readdir is thread safe])
AC_DEFINE(READDIR_IS_THREAD_SAFE, 1,
[Define if readdir is thread safe]))
if test "x$apr_gethostbyname_is_thread_safe" = "x"; then		if test "x$apr_gethostbyname_is_thread_safe" = "x"; then
AC_CHECK_LIB(c_r, gethostbyname, apr_gethostbyname_is_thread_safe=yes)		AC_CHECK_LIB(c_r, gethostbyname, apr_gethostbyname_is_thread_safe=yes)
fi		fi
if test "$apr_gethostbyname_is_thread_safe" = "yes"; then		if test "$apr_gethostbyname_is_thread_safe" = "yes"; then
AC_DEFINE(GETHOSTBYNAME_IS_THREAD_SAFE, 1,		AC_DEFINE(GETHOSTBYNAME_IS_THREAD_SAFE, 1,
[Define if gethostbyname is thread safe])		[Define if gethostbyname is thread safe])
fi		fi
if test "x$apr_gethostbyaddr_is_thread_safe" = "x"; then		if test "x$apr_gethostbyaddr_is_thread_safe" = "x"; then
AC_CHECK_LIB(c_r, gethostbyaddr, apr_gethostbyaddr_is_thread_safe=yes)		AC_CHECK_LIB(c_r, gethostbyaddr, apr_gethostbyaddr_is_thread_safe=yes)
fi		fi
skipping to change at line 1492		skipping to change at line 1493
conio.h \		conio.h \
crypt.h \		crypt.h \
ctype.h \		ctype.h \
dir.h \		dir.h \
dirent.h \		dirent.h \
dl.h \		dl.h \
dlfcn.h \		dlfcn.h \
errno.h \		errno.h \
fcntl.h \		fcntl.h \
grp.h \		grp.h \
		inttypes.h \
io.h \		io.h \
limits.h \		limits.h \
mach-o/dyld.h \		mach-o/dyld.h \
malloc.h \		malloc.h \
memory.h \		memory.h \
netdb.h \		netdb.h \
osreldate.h \		osreldate.h \
poll.h \		poll.h \
process.h \		process.h \
pwd.h \		pwd.h \
skipping to change at line 1571		skipping to change at line 1573
netinet_tcph=0		netinet_tcph=0
fi		fi
AC_SUBST(arpa_ineth)		AC_SUBST(arpa_ineth)
AC_SUBST(conioh)		AC_SUBST(conioh)
AC_SUBST(ctypeh)		AC_SUBST(ctypeh)
AC_SUBST(crypth)		AC_SUBST(crypth)
AC_SUBST(errnoh)		AC_SUBST(errnoh)
AC_SUBST(direnth)		AC_SUBST(direnth)
AC_SUBST(fcntlh)		AC_SUBST(fcntlh)
		AC_SUBST(inttypesh)
AC_SUBST(ioh)		AC_SUBST(ioh)
AC_SUBST(limitsh)		AC_SUBST(limitsh)
AC_SUBST(netdbh)		AC_SUBST(netdbh)
AC_SUBST(sys_syslimitsh)		AC_SUBST(sys_syslimitsh)
AC_SUBST(netinet_inh)		AC_SUBST(netinet_inh)
AC_SUBST(netinet_sctph)		AC_SUBST(netinet_sctph)
AC_SUBST(netinet_sctp_uioh)		AC_SUBST(netinet_sctp_uioh)
AC_SUBST(netinet_tcph)		AC_SUBST(netinet_tcph)
AC_SUBST(stdargh)		AC_SUBST(stdargh)
AC_SUBST(stdioh)		AC_SUBST(stdioh)
skipping to change at line 1665		skipping to change at line 1668
AC_CHECK_SIZEOF(void*, 4)		AC_CHECK_SIZEOF(void*, 4)
if test "x$ac_cv_sizeof_voidp" != "x"; then		if test "x$ac_cv_sizeof_voidp" != "x"; then
voidp_size=$ac_cv_sizeof_voidp		voidp_size=$ac_cv_sizeof_voidp
else		else
AC_ERROR([Cannot determine size of void*])		AC_ERROR([Cannot determine size of void*])
fi		fi
dnl Checks for integer size		dnl Checks for integer size
AC_CHECK_SIZEOF(char, 1)		AC_CHECK_SIZEOF(char, 1)
		AC_CHECK_SIZEOF(short, 2)
AC_CHECK_SIZEOF(int, 4)		AC_CHECK_SIZEOF(int, 4)
AC_CHECK_SIZEOF(long, 4)		AC_CHECK_SIZEOF(long, 4)
AC_CHECK_SIZEOF(short, 2)
AC_CHECK_SIZEOF(long long, 8)		AC_CHECK_SIZEOF(long long, 8)
if test "$ac_cv_sizeof_short" = "2"; then		if test "$ac_cv_sizeof_short" = "2"; then
short_value=short		short_value=short
fi		fi
if test "$ac_cv_sizeof_int" = "4"; then		if test "$ac_cv_sizeof_int" = "4"; then
int_value=int		int_value=int
fi		fi
# Now we need to find what apr_int64_t (sizeof == 8) will be.		# Now we need to find what apr_int64_t (sizeof == 8) will be.
# The first match is our preference.		# The first match is our preference (use inttypes if available).
if test "$ac_cv_sizeof_int" = "8"; then		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)'		int64_literal='#define APR_INT64_C(val) (val)'
uint64_literal='#define APR_UINT64_C(val) (val##U)'		uint64_literal='#define APR_UINT64_C(val) (val##U)'
int64_t_fmt='#define APR_INT64_T_FMT "d"'		int64_t_fmt='#define APR_INT64_T_FMT "d"'
uint64_t_fmt='#define APR_UINT64_T_FMT "u"'		uint64_t_fmt='#define APR_UINT64_T_FMT "u"'
uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "x"'		uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "x"'
int64_value="int"		int64_value="int"
long_value=int		uint64_value="unsigned int"
int64_strfn="strtoi"		int64_strfn="strtoi"
elif test "$ac_cv_sizeof_long" = "8"; then		elif test "$ac_cv_sizeof_long" = "8"; then
int64_literal='#define APR_INT64_C(val) (val##L)'		int64_literal='#define APR_INT64_C(val) (val##L)'
uint64_literal='#define APR_UINT64_C(val) (val##UL)'		uint64_literal='#define APR_UINT64_C(val) (val##UL)'
int64_t_fmt='#define APR_INT64_T_FMT "ld"'		int64_t_fmt='#define APR_INT64_T_FMT "ld"'
uint64_t_fmt='#define APR_UINT64_T_FMT "lu"'		uint64_t_fmt='#define APR_UINT64_T_FMT "lu"'
uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "lx"'		uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "lx"'
int64_value="long"		int64_value="long"
long_value=long		uint64_value="unsigned long"
int64_strfn="strtol"		int64_strfn="strtol"
elif test "$ac_cv_sizeof_long_long" = "8"; then		elif test "$ac_cv_sizeof_long_long" = "8"; then
int64_literal='#define APR_INT64_C(val) (val##LL)'		int64_literal='#define APR_INT64_C(val) (val##LL)'
uint64_literal='#define APR_UINT64_C(val) (val##ULL)'		uint64_literal='#define APR_UINT64_C(val) (val##ULL)'
# Linux, Solaris, FreeBSD all support ll with printf.		# Linux, Solaris, FreeBSD all support ll with printf.
# BSD 4.4 originated 'q'. Solaris is more popular and		# BSD 4.4 originated 'q'. Solaris is more popular and
# doesn't support 'q'. Solaris wins. Exceptions can		# doesn't support 'q'. Solaris wins. Exceptions can
# go to the OS-dependent section.		# go to the OS-dependent section.
int64_t_fmt='#define APR_INT64_T_FMT "lld"'		int64_t_fmt='#define APR_INT64_T_FMT "lld"'
uint64_t_fmt='#define APR_UINT64_T_FMT "llu"'		uint64_t_fmt='#define APR_UINT64_T_FMT "llu"'
uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "llx"'		uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "llx"'
int64_value="long long"		int64_value="long long"
long_value="long long"		uint64_value="unsigned long long"
int64_strfn="strtoll"		int64_strfn="strtoll"
elif test "$ac_cv_sizeof_longlong" = "8"; then		elif test "$ac_cv_sizeof_longlong" = "8"; then
int64_literal='#define APR_INT64_C(val) (val##LL)'		int64_literal='#define APR_INT64_C(val) (val##LL)'
uint64_literal='#define APR_UINT64_C(val) (val##ULL)'		uint64_literal='#define APR_UINT64_C(val) (val##ULL)'
int64_t_fmt='#define APR_INT64_T_FMT "qd"'		int64_t_fmt='#define APR_INT64_T_FMT "qd"'
uint64_t_fmt='#define APR_UINT64_T_FMT "qu"'		uint64_t_fmt='#define APR_UINT64_T_FMT "qu"'
uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "qx"'		uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "qx"'
int64_value="__int64"		int64_value="__int64"
long_value="__int64"		uint64_value="unsigned __int64"
int64_strfn="strtoll"		int64_strfn="strtoll"
else		else
# int64_literal may be overriden if your compiler thinks you have		# int64_literal may be overriden if your compiler thinks you have
# a 64-bit value but APR does not agree.		# a 64-bit value but APR does not agree.
AC_ERROR([could not detect a 64-bit integer type])		AC_ERROR([could not detect a 64-bit integer type])
fi		fi
# If present, allow the C99 macro INT64_C to override our conversion.		# 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		# HP-UX's ANSI C compiler provides this without any includes, so we
skipping to change at line 1834		skipping to change at line 1858
ssize_t_fmt="ld"		ssize_t_fmt="ld"
;;		;;
esac		esac
size_t_fmt="lu"		size_t_fmt="lu"
;;		;;
*-mingw*)		*-mingw*)
int64_t_fmt='#define APR_INT64_T_FMT "I64d"'		int64_t_fmt='#define APR_INT64_T_FMT "I64d"'
uint64_t_fmt='#define APR_UINT64_T_FMT "I64u"'		uint64_t_fmt='#define APR_UINT64_T_FMT "I64u"'
uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "I64x"'		uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "I64x"'
int64_value="__int64"		int64_value="__int64"
long_value="__int64"		uint64_value="unsigned __int64"
int64_strfn="_strtoi64"		int64_strfn="_strtoi64"
;;		;;
esac		esac
APR_CHECK_TYPES_COMPATIBLE(ssize_t, int, [ssize_t_fmt="d"])		dnl I would expect much of the above to go away with new compile test
APR_CHECK_TYPES_COMPATIBLE(ssize_t, long, [ssize_t_fmt="ld"])		APR_CHECK_TYPES_FMT_COMPATIBLE(ssize_t, long, ld, [ssize_t_fmt="ld"], [
APR_CHECK_TYPES_COMPATIBLE(size_t, unsigned int, [size_t_fmt="u"])		APR_CHECK_TYPES_FMT_COMPATIBLE(ssize_t, int, d, [ssize_t_fmt="d"])
APR_CHECK_TYPES_COMPATIBLE(size_t, unsigned long, [size_t_fmt="lu"])		])
		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"])
		])
APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>], ssize_t, 8)		APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>], ssize_t, 8)
		dnl the else cases below should no longer occur;
AC_MSG_CHECKING([which format to use for apr_ssize_t])		AC_MSG_CHECKING([which format to use for apr_ssize_t])
if test -n "$ssize_t_fmt"; then		if test -n "$ssize_t_fmt"; then
AC_MSG_RESULT(%$ssize_t_fmt)		AC_MSG_RESULT(%$ssize_t_fmt)
elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_int"; then		elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_int"; then
ssize_t_fmt="d"		ssize_t_fmt="d"
AC_MSG_RESULT(%d)		AC_MSG_RESULT(%d)
elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_long"; then		elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_long"; then
ssize_t_fmt="ld"		ssize_t_fmt="ld"
AC_MSG_RESULT(%ld)		AC_MSG_RESULT(%ld)
else		else
AC_ERROR([could not determine the proper format for apr_ssize_t])		AC_ERROR([could not determine the proper format for apr_ssize_t])
fi		fi
ssize_t_fmt="#define APR_SSIZE_T_FMT \"$ssize_t_fmt\""		ssize_t_fmt="#define APR_SSIZE_T_FMT \"$ssize_t_fmt\""
APR_CHECK_SIZEOF_EXTENDED([#include <stddef.h>], size_t, 8)		APR_CHECK_SIZEOF_EXTENDED([#include <stddef.h>], size_t, 8)
		# else cases below should no longer occur;
AC_MSG_CHECKING([which format to use for apr_size_t])		AC_MSG_CHECKING([which format to use for apr_size_t])
if test -n "$size_t_fmt"; then		if test -n "$size_t_fmt"; then
AC_MSG_RESULT(%$size_t_fmt)		AC_MSG_RESULT(%$size_t_fmt)
elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_int"; then		elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_int"; then
size_t_fmt="d"		size_t_fmt="d"
AC_MSG_RESULT(%d)		AC_MSG_RESULT(%d)
elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_long"; then		elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_long"; then
size_t_fmt="ld"		size_t_fmt="ld"
AC_MSG_RESULT(%ld)		AC_MSG_RESULT(%ld)
else		else
skipping to change at line 1915		skipping to change at line 1944
off_t_strfn='apr_strtoi64'		off_t_strfn='apr_strtoi64'
elif test "${ac_cv_sizeof_off_t}x${ac_cv_sizeof_long}" = "4x4"; then		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		# Special case: off_t may change size with _FILE_OFFSET_BITS
# on 32-bit systems with LFS support. To avoid compatibility		# on 32-bit systems with LFS support. To avoid compatibility
# issues when other packages do define _FILE_OFFSET_BITS,		# issues when other packages do define _FILE_OFFSET_BITS,
# hard-code apr_off_t to long.		# hard-code apr_off_t to long.
off_t_value=long		off_t_value=long
off_t_fmt='#define APR_OFF_T_FMT "ld"'		off_t_fmt='#define APR_OFF_T_FMT "ld"'
off_t_strfn='strtol'		off_t_strfn='strtol'
elif test "$ac_cv_type_off_t" = "yes"; then		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		# off_t is more commonly a long than an int; prefer that case
# where int and long are the same size.		# where int and long are the same size and interchangable.
if test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_long"; then		off_t_value=off_t
off_t_fmt='#define APR_OFF_T_FMT "ld"'		APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, long, ld, [
		off_t_fmt="#define APR_OFF_T_FMT \"ld\""
off_t_strfn='strtol'		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"'		APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, int, d, [
		off_t_fmt="#define APR_OFF_T_FMT \"d\""
off_t_strfn='strtoi'		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'		APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, long long, lld, [
off_t_strfn='apr_strtoi64'		off_t_fmt="#define APR_OFF_T_FMT \"lld\""
else		off_t_strfn='strtoll'
AC_ERROR([could not determine the size of off_t])		], [
fi		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...		# Per OS tuning...
case $host in		case $host in
*-mingw*)		*-mingw*)
off_t_value=apr_int64_t		off_t_value=apr_int64_t
off_t_fmt='#define APR_OFF_T_FMT "I64d"'		off_t_fmt='#define APR_OFF_T_FMT "I64d"'
off_t_strfn='_strtoi64'		off_t_strfn='_strtoi64'
;;		;;
		*)
		AC_ERROR([could not determine the size of off_t])
		;;
esac		esac
		])])])])
else		else
# Fallback on int		# Fallback on int
off_t_value=apr_int32_t		off_t_value=apr_int32_t
off_t_fmt=d		off_t_fmt=d
off_t_strfn='strtoi'		off_t_strfn='strtoi'
fi		fi
AC_MSG_RESULT($off_t_value)		AC_MSG_RESULT($off_t_value)
# Regardless of whether _LARGEFILE64_SOURCE is used, on some		# Regardless of whether _LARGEFILE64_SOURCE is used, on some
# platforms _FILE_OFFSET_BITS will affect the size of ino_t and hence		# platforms _FILE_OFFSET_BITS will affect the size of ino_t and hence
skipping to change at line 1996		skipping to change at line 2032
#include <sys/uio.h>],struct iovec,0)		#include <sys/uio.h>],struct iovec,0)
if test "$ac_cv_sizeof_struct_iovec" = "0"; then		if test "$ac_cv_sizeof_struct_iovec" = "0"; then
have_iovec=0		have_iovec=0
else		else
have_iovec=1		have_iovec=1
fi		fi
AC_SUBST(voidp_size)		AC_SUBST(voidp_size)
AC_SUBST(short_value)		AC_SUBST(short_value)
AC_SUBST(int_value)		AC_SUBST(int_value)
AC_SUBST(long_value)
AC_SUBST(int64_value)		AC_SUBST(int64_value)
		AC_SUBST(uint64_value)
AC_SUBST(off_t_value)		AC_SUBST(off_t_value)
AC_SUBST(size_t_value)		AC_SUBST(size_t_value)
AC_SUBST(ssize_t_value)		AC_SUBST(ssize_t_value)
AC_SUBST(socklen_t_value)		AC_SUBST(socklen_t_value)
AC_SUBST(int64_t_fmt)		AC_SUBST(int64_t_fmt)
AC_SUBST(uint64_t_fmt)		AC_SUBST(uint64_t_fmt)
AC_SUBST(uint64_t_hex_fmt)		AC_SUBST(uint64_t_hex_fmt)
AC_SUBST(ssize_t_fmt)		AC_SUBST(ssize_t_fmt)
AC_SUBST(size_t_fmt)		AC_SUBST(size_t_fmt)
AC_SUBST(off_t_fmt)		AC_SUBST(off_t_fmt)
skipping to change at line 2190		skipping to change at line 2226
ac_cv_struct_rlimit=yes ], [		ac_cv_struct_rlimit=yes ], [
ac_cv_struct_rlimit=no ], [		ac_cv_struct_rlimit=no ], [
ac_cv_struct_rlimit=no ] ) ] )		ac_cv_struct_rlimit=no ] ) ] )
struct_rlimit=0		struct_rlimit=0
test "x$ac_cv_struct_rlimit" = xyes && struct_rlimit=1		test "x$ac_cv_struct_rlimit" = xyes && struct_rlimit=1
AC_SUBST(struct_rlimit)		AC_SUBST(struct_rlimit)
dnl ----------------------------- Checking for Locking Characteristics		dnl ----------------------------- Checking for Locking Characteristics
echo "${nl}Checking for Locking..."		echo "${nl}Checking for Locking..."
AC_CHECK_FUNCS(semget semctl flock)		AC_CHECK_FUNCS(semget semctl semop semtimedop flock)
AC_CHECK_HEADERS(semaphore.h OS.h)		APR_IFALLYES(func:semtimedop, have_semtimedop="1", have_semtimedop="0")
		AC_CHECK_HEADERS(semaphore.h)
AC_SEARCH_LIBS(sem_open, rt)		AC_SEARCH_LIBS(sem_open, rt)
AC_CHECK_FUNCS(sem_close sem_unlink sem_post sem_wait create_sem)		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_ac
		quire_sem_etc="0")
# Some systems return ENOSYS from sem_open.		# Some systems return ENOSYS from sem_open.
AC_CACHE_CHECK(for working sem_open,ac_cv_func_sem_open,[		AC_CACHE_CHECK(for working sem_open,ac_cv_func_sem_open,[
AC_TRY_RUN([		AC_TRY_RUN([
#include <errno.h>		#include <errno.h>
#include <stdlib.h>		#include <stdlib.h>
#include <fcntl.h>		#include <fcntl.h>
#include <semaphore.h>		#include <semaphore.h>
#ifndef SEM_FAILED		#ifndef SEM_FAILED
#define SEM_FAILED (-1)		#define SEM_FAILED (-1)
skipping to change at line 2252		skipping to change at line 2295
APR_CHECK_DEFINE(LOCK_EX, sys/file.h)		APR_CHECK_DEFINE(LOCK_EX, sys/file.h)
APR_CHECK_DEFINE(F_SETLK, fcntl.h)		APR_CHECK_DEFINE(F_SETLK, fcntl.h)
APR_CHECK_DEFINE(SEM_UNDO, sys/sem.h)		APR_CHECK_DEFINE(SEM_UNDO, sys/sem.h)
# We are assuming that if the platform doesn't have POLLIN, it doesn't have		# We are assuming that if the platform doesn't have POLLIN, it doesn't have
# any POLL definitions.		# any POLL definitions.
APR_CHECK_DEFINE_FILES(POLLIN, poll.h sys/poll.h)		APR_CHECK_DEFINE_FILES(POLLIN, poll.h sys/poll.h)
if test "$threads" = "1"; then		if test "$threads" = "1"; then
APR_CHECK_DEFINE(PTHREAD_PROCESS_SHARED, pthread.h)		APR_CHECK_DEFINE(PTHREAD_PROCESS_SHARED, pthread.h)
AC_CHECK_FUNCS(pthread_mutexattr_setpshared)		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		# Some systems have setpshared and define PROCESS_SHARED, but don't
# really support PROCESS_SHARED locks. So, we must validate that we		# really support PROCESS_SHARED locks. So, we must validate that we
# can go through the steps without receiving some sort of system error.		# can go through the steps without receiving some sort of system error.
# Linux and older versions of AIX have this problem.		# Linux and older versions of AIX have this problem.
APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED func:pthread_mut exattr_setpshared, [		APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED func:pthread_mut exattr_setpshared, [
AC_CACHE_CHECK([for working PROCESS_SHARED locks], apr_cv_process_shared_w orks, [		AC_CACHE_CHECK([for working PROCESS_SHARED locks], apr_cv_process_shared_w orks, [
AC_TRY_RUN([		AC_TRY_RUN([
#include <sys/types.h>		#include <sys/types.h>
#include <pthread.h>		#include <pthread.h>
int main()		int main()
skipping to change at line 2290		skipping to change at line 2336
if test "$ac_cv_func_pthread_mutexattr_setpshared" = "yes"; then		if test "$ac_cv_func_pthread_mutexattr_setpshared" = "yes"; then
APR_CHECK_PTHREAD_ROBUST_SHARED_MUTEX		APR_CHECK_PTHREAD_ROBUST_SHARED_MUTEX
fi		fi
fi		fi
# See which lock mechanisms we can support on this system.		# See which lock mechanisms we can support on this system.
APR_IFALLYES(header:semaphore.h func:sem_open func:sem_close dnl		APR_IFALLYES(header:semaphore.h func:sem_open func:sem_close dnl
func:sem_unlink func:sem_post func:sem_wait,		func:sem_unlink func:sem_post func:sem_wait,
hasposixser="1", hasposixser="0")		hasposixser="1", hasposixser="0")
APR_IFALLYES(func:semget func:semctl define:SEM_UNDO, hassysvser="1",		APR_IFALLYES(func:semget func:semctl func:semop define:SEM_UNDO,
hassysvser="0")		hassysvser="1", hassysvser="0")
APR_IFALLYES(func:flock define:LOCK_EX, hasflockser="1", hasflockser="0")		APR_IFALLYES(func:flock define:LOCK_EX, hasflockser="1", hasflockser="0")
APR_IFALLYES(header:fcntl.h define:F_SETLK, hasfcntlser="1", hasfcntlser="0")		APR_IFALLYES(header:fcntl.h define:F_SETLK, hasfcntlser="1", hasfcntlser="0")
# note: the current APR use of shared mutex requires /dev/zero		# note: the current APR use of shared mutex requires /dev/zero
APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED dnl		APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED dnl
func:pthread_mutexattr_setpshared dnl		func:pthread_mutexattr_setpshared dnl
file:/dev/zero,		file:/dev/zero,
hasprocpthreadser="1", hasprocpthreadser="0")		hasprocpthreadser="1", hasprocpthreadser="0")
APR_IFALLYES(header:OS.h func:create_sem, hasbeossem="1", hasbeossem="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_setpsha
		red="0")
		AC_SUBST(have_pthread_condattr_setpshared)
# See which lock mechanism we'll select by default on this system.		# See which lock mechanism we'll select by default on this system.
# The last APR_DECIDE to execute sets the default.		# The last APR_DECIDE to execute sets the default.
# At this stage, we match the ordering in Apache 1.3		# At this stage, we match the ordering in Apache 1.3
# which is (highest to lowest): sysvsem -> fcntl -> flock.		# which is (highest to lowest): sysvsem -> fcntl -> flock.
# POSIX semaphores and cross-process pthread mutexes are not		# POSIX semaphores and cross-process pthread mutexes are not
# used by default since they have less desirable behaviour when		# used by default since they have less desirable behaviour when
# e.g. a process holding the mutex segfaults.		# e.g. a process holding the mutex segfaults.
# The BEOSSEM decision doesn't require any substitutions but is		# The BEOSSEM decision doesn't require any substitutions but is
# included here to prevent the fcntl() branch being selected		# included here to prevent the fcntl() branch being selected
# from the decision making.		# from the decision making.
APR_BEGIN_DECISION([apr_lock implementation method])		APR_BEGIN_DECISION([apr_lock implementation method])
APR_IFALLYES(func:flock define:LOCK_EX,		APR_IFALLYES(func:flock define:LOCK_EX,
APR_DECIDE(USE_FLOCK_SERIALIZE, [4.2BSD-style flock()]))		APR_DECIDE(USE_FLOCK_SERIALIZE, [4.2BSD-style flock()]))
APR_IFALLYES(header:fcntl.h define:F_SETLK,		APR_IFALLYES(header:fcntl.h define:F_SETLK,
APR_DECIDE(USE_FCNTL_SERIALIZE, [SVR4-style fcntl()]))		APR_DECIDE(USE_FCNTL_SERIALIZE, [SVR4-style fcntl()]))
APR_IFALLYES(func:semget func:semctl define:SEM_UNDO,		APR_IFALLYES(func:semget func:semctl func:semop define:SEM_UNDO,
APR_DECIDE(USE_SYSVSEM_SERIALIZE, [SysV IPC semget()]))		APR_DECIDE(USE_SYSVSEM_SERIALIZE, [SysV IPC semget()]))
APR_IFALLYES(header:OS.h func:create_sem,		APR_IFALLYES(header:OS.h func:create_sem func:acquire_sem func:acquire_sem_etc,
APR_DECIDE(USE_BEOSSEM, [BeOS Semaphores]))		APR_DECIDE(USE_BEOSSEM, [BeOS Semaphores]))
		# pthread mutex both pshared and robust[_np] is the best default
		case "$apr_cv_mutex_robust_shared" in
		"yes"|"np")
		APR_DECIDE(USE_PROC_PTHREAD_SERIALIZE, [pthread pshared mutex])
		;;
		*)
		;;
		esac
if test "x$apr_lock_method" != "x"; then		if test "x$apr_lock_method" != "x"; then
APR_DECISION_FORCE($apr_lock_method)		APR_DECISION_FORCE($apr_lock_method)
fi		fi
APR_END_DECISION		APR_END_DECISION
AC_DEFINE_UNQUOTED($ac_decision)		AC_DEFINE_UNQUOTED($ac_decision)
flockser="0"		flockser="0"
sysvser="0"		sysvser="0"
posixser="0"		posixser="0"
procpthreadser="0"		procpthreadser="0"
skipping to change at line 2478		skipping to change at line 2537
AC_MSG_CHECKING(if flock locks affect threads in the same process)		AC_MSG_CHECKING(if flock locks affect threads in the same process)
if test "x$apr_flock_is_global" = "xyes"; then		if test "x$apr_flock_is_global" = "xyes"; then
AC_DEFINE(FLOCK_IS_GLOBAL, 1,		AC_DEFINE(FLOCK_IS_GLOBAL, 1,
[Define if flock locks affect threads within the process])		[Define if flock locks affect threads within the process])
AC_MSG_RESULT(yes)		AC_MSG_RESULT(yes)
else		else
AC_MSG_RESULT(no)		AC_MSG_RESULT(no)
fi		fi
dnl ----------------------------- Checking for /dev/random		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)		AC_MSG_CHECKING(for entropy source)
why_no_rand=""		why_no_rand=""
AC_ARG_WITH(egd,		AC_ARG_WITH(egd,
[ --with-egd[[=DIR]] use EGD-compatible socket],		[ --with-egd[[=DIR]] use EGD-compatible socket],
[ AC_DEFINE(HAVE_EGD, 1, [Define if EGD is supported])		[ AC_DEFINE(HAVE_EGD, 1, [Define if EGD is supported])
if test "$withval" = "yes"; then		if test "$withval" = "yes"; then
AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["/var/run/egd-pool","/dev/egd-po ol","/etc/egd-pool","/etc/entropy"],		AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["/var/run/egd-pool","/dev/egd-po ol","/etc/egd-pool","/etc/entropy"],
[Define to list of paths to EGD sockets])		[Define to list of paths to EGD sockets])
else		else
AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["$withval"])		AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["$withval"])
fi		fi
AC_MSG_RESULT(EGD-compatible daemon)		AC_MSG_RESULT(EGD-compatible daemon)
rand="1"		rand="1"
])		])
if test "$rand" != "1"; then		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,		AC_ARG_WITH(devrandom,
[ --with-devrandom[[=DEV]] use /dev/random or compatible [[searches by def ault]]],		[ --with-devrandom[[=DEV]] use /dev/random or compatible [[searches by def ault]]],
[ apr_devrandom="$withval" ], [ apr_devrandom="yes" ])		[ 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		if test "$apr_devrandom" = "yes"; then
# /dev/random on OpenBSD doesn't provide random data, so		# /dev/random on OpenBSD doesn't provide random data, so
# prefer /dev/arandom, which does; see random(4).		# prefer /dev/arandom, which does; see random(4).
for f in /dev/arandom /dev/urandom /dev/random; do		for f in /dev/arandom /dev/urandom /dev/random; do
if test -r $f; then		if test -r $f; then
apr_devrandom=$f		apr_devrandom=$f
rand=1		rand="1"
break		break
fi		fi
done		done
elif test "$apr_devrandom" != "no"; then		elif test "$apr_devrandom" != "no"; then
if test -r "$apr_devrandom"; then		if test -r "$apr_devrandom"; then
rand="1"		rand="1"
else		else
AC_ERROR([$apr_devrandom not found or unreadable.])		AC_ERROR([$apr_devrandom not found or unreadable.])
fi		fi
fi		fi
skipping to change at line 2532		skipping to change at line 2617
rand="0"		rand="0"
why_no_rand=" ($apr_devrandom unusable on z/OS before V1R7)"		why_no_rand=" ($apr_devrandom unusable on z/OS before V1R7)"
fi		fi
;;		;;
esac		esac
fi		fi
if test "$rand" = "1"; then		if test "$rand" = "1"; then
AC_DEFINE_UNQUOTED(DEV_RANDOM, ["$apr_devrandom"], [Define to path of random device])		AC_DEFINE_UNQUOTED(DEV_RANDOM, ["$apr_devrandom"], [Define to path of random device])
AC_MSG_RESULT([$apr_devrandom])		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
fi		fi
if test "$rand" != "1"; then		if test "$rand" != "1"; then
case $host in		case $host in
# we have built in support for OS/2		# we have built in support for OS/2
*-os2*)		*-os2*)
AC_MSG_RESULT([Using OS/2 builtin random])		AC_MSG_RESULT([Using OS/2 builtin random])
rand="1"		rand="1"
;;		;;
skipping to change at line 2748		skipping to change at line 2837
[ user_disabled_ipv6=0 ] )		[ user_disabled_ipv6=0 ] )
case $host in		case $host in
*)		*)
broken_ipv6=0		broken_ipv6=0
esac		esac
AC_SEARCH_LIBS(getaddrinfo, socket inet6)		AC_SEARCH_LIBS(getaddrinfo, socket inet6)
AC_SEARCH_LIBS(gai_strerror, socket inet6)		AC_SEARCH_LIBS(gai_strerror, socket inet6)
AC_SEARCH_LIBS(getnameinfo, socket inet6)		AC_SEARCH_LIBS(getnameinfo, socket inet6)
AC_CHECK_FUNCS(gai_strerror)		AC_CHECK_FUNCS(gai_strerror if_nametoindex if_indextoname)
APR_CHECK_WORKING_GETADDRINFO		APR_CHECK_WORKING_GETADDRINFO
APR_CHECK_NEGATIVE_EAI		APR_CHECK_NEGATIVE_EAI
APR_CHECK_WORKING_GETNAMEINFO		APR_CHECK_WORKING_GETNAMEINFO
APR_CHECK_SOCKADDR_IN6		APR_CHECK_SOCKADDR_IN6
APR_CHECK_SOCKADDR_STORAGE		APR_CHECK_SOCKADDR_STORAGE
APR_CHECK_SOCKADDR_UN		APR_CHECK_SOCKADDR_UN
have_ipv6="0"		have_ipv6="0"
if test "$user_disabled_ipv6" = 1; then		if test "$user_disabled_ipv6" = 1; then
ipv6_result="no -- disabled by user"		ipv6_result="no -- disabled by user"
skipping to change at line 2786		skipping to change at line 2875
else		else
ipv6_result="no -- the platform has known problems supporting IPv6"		ipv6_result="no -- the platform has known problems supporting IPv6"
fi		fi
fi		fi
AC_MSG_CHECKING(if APR supports IPv6)		AC_MSG_CHECKING(if APR supports IPv6)
AC_MSG_RESULT($ipv6_result)		AC_MSG_RESULT($ipv6_result)
AC_SUBST(have_ipv6)		AC_SUBST(have_ipv6)
		AC_ARG_ENABLE(timedlocks,
		[ --disable-timedlocks Disable timed locks ],
		[apr_has_timedlocks="0"], [apr_has_timedlocks="1"]
		)
		AC_SUBST(apr_has_timedlocks)
# hstrerror is only needed if IPv6 is not enabled,		# hstrerror is only needed if IPv6 is not enabled,
# so getaddrinfo/gai_strerror are not used.		# so getaddrinfo/gai_strerror are not used.
if test $have_ipv6 = 0; then		if test $have_ipv6 = 0; then
AC_SEARCH_LIBS(hstrerror, resolv,		AC_SEARCH_LIBS(hstrerror, resolv,
[AC_DEFINE(HAVE_HSTRERROR, 1, [Define if hstrerror is present])])		[AC_DEFINE(HAVE_HSTRERROR, 1, [Define if hstrerror is present])])
fi		fi
dnl Check for langinfo support		dnl Check for langinfo support
AC_CHECK_HEADERS(langinfo.h)		AC_CHECK_HEADERS(langinfo.h)
End of changes. 41 change blocks.
41 lines changed or deleted		140 lines changed or added

---