contrib/apr/configure.in

   1 dnl
   2 dnl Autoconf configuration file for APR
   3 dnl
   4 dnl Process this file with autoconf to produce a configure script.
   5 dnl Use ./buildconf to prepare build files and run autoconf for APR.
   6
   7 AC_PREREQ(2.59)
   8
   9 AC_INIT(build/apr_common.m4)
  10 AC_CONFIG_HEADER(include/arch/unix/apr_private.h)
  11 AC_CONFIG_AUX_DIR(build)
  12 AC_CONFIG_MACRO_DIR(build)
  13
  14 dnl
  15 dnl Include our own M4 macros along with those for libtool
  16 dnl
  17 sinclude(build/apr_common.m4)
  18 sinclude(build/apr_network.m4)
  19 sinclude(build/apr_threads.m4)
  20 sinclude(build/apr_win32.m4)
  21 sinclude(build/apr_hints.m4)
  22 sinclude(build/libtool.m4)
  23 sinclude(build/ltsugar.m4)
  24 sinclude(build/argz.m4)
  25 sinclude(build/ltoptions.m4)
  26 sinclude(build/ltversion.m4)
  27 sinclude(build/lt~obsolete.m4)
  28
  29 dnl Hard-coded top of apr_private.h:
  30 AH_TOP([
  31 #ifndef APR_PRIVATE_H
  32 #define APR_PRIVATE_H
  33 ])
  34
  35 dnl Hard-coded inclusion at the tail end of apr_private.h:
  36 AH_BOTTOM([
  37 /* switch this on if we have a BeOS version below BONE */
  38 #if defined(BEOS) && !defined(HAVE_BONE_VERSION)
  39 #define BEOS_R5 1
  40 #else
  41 #define BEOS_BONE 1
  42 #endif
  43
  44 /*
  45  * Darwin 10's default compiler (gcc42) builds for both 64 and
  46  * 32 bit architectures unless specifically told not to.
  47  * In those cases, we need to override types depending on how
  48  * we're being built at compile time.
  49  * NOTE: This is an ugly work-around for Darwin's
  50  * concept of universal binaries, a single package
  51  * (executable, lib, etc...) which contains both 32
  52  * and 64 bit versions. The issue is that if APR is
  53  * built universally, if something else is compiled
  54  * against it, some bit sizes will depend on whether
  55  * it is 32 or 64 bit. This is determined by the __LP64__
  56  * flag. Since we need to support both, we have to
  57  * handle OS X unqiuely.
  58  */
  59 #ifdef DARWIN_10
  60
  61 #undef APR_OFF_T_STRFN
  62 #undef APR_INT64_STRFN
  63 #undef SIZEOF_LONG
  64 #undef SIZEOF_SIZE_T
  65 #undef SIZEOF_SSIZE_T
  66 #undef SIZEOF_VOIDP
  67 #undef SIZEOF_STRUCT_IOVEC
  68
  69 #ifdef __LP64__
  70  #define APR_INT64_STRFN strtol
  71  #define SIZEOF_LONG    8
  72  #define SIZEOF_SIZE_T  8
  73  #define SIZEOF_SSIZE_T 8
  74  #define SIZEOF_VOIDP   8
  75  #define SIZEOF_STRUCT_IOVEC 16
  76 #else
  77  #define APR_INT64_STRFN strtoll
  78  #define SIZEOF_LONG    4
  79  #define SIZEOF_SIZE_T  4
  80  #define SIZEOF_SSIZE_T 4
  81  #define SIZEOF_VOIDP   4
  82  #define SIZEOF_STRUCT_IOVEC 8
  83 #endif
  84
  85 #undef APR_OFF_T_STRFN
  86 #define APR_OFF_T_STRFN APR_INT64_STRFN
  87
  88
  89 #undef SETPGRP_VOID
  90 #ifdef __DARWIN_UNIX03
  91  #define SETPGRP_VOID 1
  92 #else
  93 /* #undef SETPGRP_VOID */
  94 #endif
  95
  96 #endif /* DARWIN_10 */
  97
  98 /*
  99  * Include common private declarations.
 100  */
 101 #include "../apr_private_common.h"
 102 #endif /* APR_PRIVATE_H */
 103 ])
 104
 105 dnl Save user-defined environment settings for later restoration
 106 dnl
 107 APR_SAVE_THE_ENVIRONMENT(CPPFLAGS)
 108 APR_SAVE_THE_ENVIRONMENT(CFLAGS)
 109 APR_SAVE_THE_ENVIRONMENT(LDFLAGS)
 110 APR_SAVE_THE_ENVIRONMENT(LIBS)
 111 APR_SAVE_THE_ENVIRONMENT(INCLUDES)
 112
 113 dnl Generate ./config.nice for reproducing runs of configure
 114 dnl
 115 APR_CONFIG_NICE(config.nice)
 116
 117 AC_CANONICAL_SYSTEM
 118 echo "Configuring APR library"
 119 echo "Platform: $host"
 120
 121 dnl Some initial steps for configuration.  We setup the default directory
 122 dnl and which files are to be configured.
 123
 124 dnl Setup the directory macros now
 125
 126 # Absolute source/build directory
 127 apr_srcdir=`(cd $srcdir && pwd)`
 128 apr_builddir=`pwd`
 129 AC_SUBST(apr_srcdir)
 130 AC_SUBST(apr_builddir)
 131
 132 if test "$apr_builddir" != "$apr_srcdir"; then
 133   USE_VPATH=1
 134   APR_CONFIG_LOCATION=build
 135 else
 136   APR_CONFIG_LOCATION=source
 137 fi
 138
 139 AC_SUBST(APR_CONFIG_LOCATION)
 140
 141 # Libtool might need this symbol -- it must point to the location of
 142 # the generated libtool script (not necessarily the "top" build dir).
 143 #
 144 top_builddir="$apr_builddir"
 145 AC_SUBST(top_builddir)
 146
 147 # Directory containing apr build macros, helpers, and make rules
 148 # NOTE: make rules (apr_rules.mk) will be in the builddir for vpath
 149 #
 150 apr_buildout=$apr_builddir/build
 151 apr_builders=$apr_srcdir/build
 152 AC_SUBST(apr_builders)
 153
 154 MKDIR=$apr_builders/mkdir.sh
 155
 156 dnl Initialize mkdir -p functionality.
 157 APR_MKDIR_P_CHECK($apr_builders/mkdir.sh)
 158
 159 # get our version information
 160 get_version="$apr_builders/get-version.sh"
 161 version_hdr="$apr_srcdir/include/apr_version.h"
 162 APR_MAJOR_VERSION="`$get_version major $version_hdr APR`"
 163 APR_DOTTED_VERSION="`$get_version all $version_hdr APR`"
 164
 165 AC_SUBST(APR_DOTTED_VERSION)
 166 AC_SUBST(APR_MAJOR_VERSION)
 167
 168 echo "APR Version: ${APR_DOTTED_VERSION}"
 169
 170 dnl Enable the layout handling code, then reparse the prefix-style
 171 dnl arguments due to autoconf being a PITA.
 172 APR_ENABLE_LAYOUT(apr)
 173 APR_PARSE_ARGUMENTS
 174
 175 dnl Set optional CC hints here in case autoconf makes an inappropriate choice.
 176 dnl This allows us to suggest what the compiler should be, but still
 177 dnl allows the user to override CC externally.
 178 APR_CC_HINTS
 179
 180 dnl Do the various CC checks *before* preloading values. The preload code
 181 dnl may need to use compiler characteristics to make decisions. This macro
 182 dnl can only be used once within a configure script, so this prevents a
 183 dnl preload section from invoking the macro to get compiler info.
 184 AC_PROG_CC
 185
 186 dnl AC_PROG_SED is only avaliable in recent autoconf versions.
 187 dnl Use AC_CHECK_PROG instead if AC_PROG_SED is not present.
 188 ifdef([AC_PROG_SED],
 189       [AC_PROG_SED],
 190       [AC_CHECK_PROG(SED, sed, sed)])
 191
 192 dnl Preload
 193 APR_PRELOAD
 194
 195 dnl These added to allow default directories to be used...
 196 DEFAULT_OSDIR="unix"
 197 echo "(Default will be ${DEFAULT_OSDIR})"
 198
 199 apr_modules="file_io network_io threadproc misc locks time mmap shmem user memory atomic poll support random"
 200
 201 dnl Checks for programs.
 202 AC_PROG_MAKE_SET
 203 AC_PROG_CPP
 204 AC_PROG_AWK
 205 AC_PROG_LN_S
 206 AC_PROG_RANLIB
 207 AC_PROG_INSTALL
 208 AC_CHECK_PROG(RM, rm, rm)
 209 AC_CHECK_PROG(AS, as, as)
 210 AC_CHECK_PROG(ASCPP, cpp, cpp)
 211 AC_CHECK_TOOL(AR, ar, ar)
 212
 213 dnl Various OS checks that apparently set required flags
 214 ifdef([AC_USE_SYSTEM_EXTENSIONS], [
 215 AC_USE_SYSTEM_EXTENSIONS
 216 ], [
 217 AC_AIX
 218 AC_MINIX
 219 ])
 220
 221 AC_ISC_POSIX
 222 APR_EBCDIC
 223
 224 dnl this is our library name
 225 APR_LIBNAME="apr${libsuffix}"
 226 AC_SUBST(APR_LIBNAME)
 227
 228 dnl prep libtool
 229 dnl
 230 echo "performing libtool configuration..."
 231
 232 AC_ARG_ENABLE(experimental-libtool,[  --enable-experimental-libtool Use experimental custom libtool],
 233   [experimental_libtool=$enableval],[experimental_libtool=no])
 234
 235 dnl Workarounds for busted Libtool 2.x when we don't call AC_PROG_LIBTOOL
 236 if test "x$Xsed" = "x"; then
 237   Xsed="$SED -e 1s/^X//"
 238 fi
 239
 240 case $host in
 241 *-os2*)
 242     # Use a custom-made libtool replacement
 243     echo "using aplibtool"
 244     LIBTOOL="$srcdir/build/aplibtool"
 245     gcc $CFLAGS $CPPFLAGS -o $LIBTOOL.exe $LIBTOOL.c
 246     ;;
 247 *)
 248     if test "x$LTFLAGS" = "x"; then
 249         LTFLAGS='--silent'
 250     fi
 251     if test "$experimental_libtool" = "yes"; then
 252         # Use a custom-made libtool replacement
 253         echo "using jlibtool"
 254         LIBTOOL="$apr_builddir/libtool"
 255         LIBTOOL_SRC="$apr_srcdir/build/jlibtool.c"
 256         $CC $CFLAGS $CPPFLAGS -o $LIBTOOL $LIBTOOL_SRC
 257         eval `$apr_builddir/libtool --config | grep "^shlibpath_var=[[A-Z_]]*$"`
 258         if test "x$shlibpath_var" = "x"; then
 259             shlibpath_var=REPLACE_WITH_YOUR_SHLIBPATH_VAR
 260         fi
 261     else
 262     dnl libtoolize requires that the following not be indented
 263     dnl should become LT_INIT(win32-dll)
 264 AC_LIBTOOL_WIN32_DLL
 265 AC_PROG_LIBTOOL
 266         # get libtool's setting of shlibpath_var
 267         if test "x$shlibpath_var" = "x"; then
 268             eval `grep "^shlibpath_var=[[A-Z_]]*$" $apr_builddir/libtool`
 269         fi
 270         if test "x$shlibpath_var" = "x"; then
 271             AC_MSG_NOTICE([SHLIBPATH variable could not be determined])
 272             shlibpath_var=REPLACE_WITH_YOUR_SHLIBPATH_VAR
 273         fi
 274     fi
 275     ;;
 276 esac
 277
 278 AC_ARG_WITH(installbuilddir, [  --with-installbuilddir=DIR location to store APR build files],
 279   [ installbuilddir=$withval ] )
 280 AC_SUBST(installbuilddir)
 281
 282 AC_ARG_WITH(libtool, [  --without-libtool       avoid using libtool to link the library],
 283   [ use_libtool=$withval ], [ use_libtool="yes" ] )
 284
 285 if test "x$use_libtool" = "xyes"; then
 286       lt_compile='$(LIBTOOL) $(LTFLAGS) --mode=compile $(COMPILE) -o $@ -c $< && touch $@'
 287       LT_VERSION="-version-info `$get_version libtool $version_hdr APR`"
 288       link="\$(LIBTOOL) \$(LTFLAGS) --mode=link \$(COMPILE) \$(LT_LDFLAGS) \$(LT_VERSION) \$(ALL_LDFLAGS) -o \$@"
 289       so_ext='lo'
 290       lib_target='-rpath $(libdir) $(OBJECTS)'
 291       export_lib_target='-rpath \$(libdir) \$(OBJECTS)'
 292 else
 293       lt_compile='$(COMPILE) -o $@ -c $<'
 294       link='$(AR) cr $(TARGET_LIB) $(OBJECTS); $(RANLIB) $(TARGET_LIB)'
 295       so_ext='o'
 296       lib_target=''
 297       export_lib_target=''
 298 fi
 299
 300 case $host in
 301     *-solaris2*)
 302         apr_platform_runtime_link_flag="-R"
 303         ;;
 304     *-mingw* | *-cygwin*)
 305         LT_LDFLAGS="$LT_LDFLAGS -no-undefined"
 306         ;;
 307     *)
 308         ;;
 309 esac
 310
 311 AC_SUBST(lt_compile)
 312 AC_SUBST(link)
 313 AC_SUBST(so_ext)
 314 AC_SUBST(lib_target)
 315 AC_SUBST(export_lib_target)
 316 AC_SUBST(shlibpath_var)
 317 AC_SUBST(LTFLAGS)
 318 AC_SUBST(LT_LDFLAGS)
 319 AC_SUBST(LT_VERSION)
 320
 321 dnl ----------------------------- Checks for compiler flags
 322 nl='
 323 '
 324 echo "${nl}Check for compiler flags..."
 325
 326 dnl AC_PROG_CC sets -g in CFLAGS (and -O2 for gcc) by default.
 327 dnl On OS/390 this causes the compiler to insert extra debugger
 328 dnl hook instructions.  That's fine for debug/maintainer builds, not fine
 329 dnl otherwise.
 330
 331 case $host in
 332     *os390)
 333         if test "$ac_test_CFLAGS" != set; then
 334            APR_REMOVEFROM(CFLAGS,-g)
 335         fi
 336         ;;
 337 esac
 338
 339 AC_ARG_ENABLE(debug,[  --enable-debug          Turn on debugging and compile time warnings],
 340   [APR_ADDTO(CFLAGS,-g)
 341    if test "$GCC" = "yes"; then
 342      APR_ADDTO(CFLAGS,-Wall)
 343    elif test "$AIX_XLC" = "yes"; then
 344      APR_ADDTO(CFLAGS,-qfullpath)
 345    fi
 346 ])dnl
 347
 348 AC_ARG_ENABLE(maintainer-mode,[  --enable-maintainer-mode  Turn on debugging and compile time warnings],
 349   [APR_ADDTO(CFLAGS,-g)
 350    if test "$GCC" = "yes"; then
 351      APR_ADDTO(CFLAGS,[-Wall -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations])
 352       case `($CC --version) 2>/dev/null` in
 353         *clang-900* | *"clang version 5.0.0"*)
 354           APR_ADDTO(CFLAGS,[-Wno-error=strict-prototypes])
 355           ;;
 356       esac
 357    elif test "$AIX_XLC" = "yes"; then
 358      APR_ADDTO(CFLAGS,-qfullpath -qinitauto=FE -qcheck=all -qinfo=pro)
 359    fi
 360 ])dnl
 361
 362 AC_ARG_ENABLE(profile,[  --enable-profile        Turn on profiling for the build (GCC)],
 363   if test "$GCC" = "yes"; then
 364     APR_ADDTO(CFLAGS, -pg)
 365     APR_REMOVEFROM(CFLAGS, -g)
 366     if test "$host" = "i586-pc-beos"; then
 367         APR_REMOVEFROM(CFLAGS, -O2)
 368         APR_ADDTO(CFLAGS, -O1)
 369         APR_ADDTO(LDFLAGS, -p)
 370     fi
 371   fi
 372 )dnl
 373
 374 AC_ARG_ENABLE(pool-debug,
 375   [  --enable-pool-debug[[=yes|no|verbose|verbose-alloc|lifetime|owner|all]]    Turn on pools debugging],
 376   [ if test -z "$enableval"; then
 377         APR_ADDTO(CPPFLAGS, -DAPR_POOL_DEBUG=1)
 378     elif test ! "$enableval" = "no"; then
 379         apr_pool_debug=1
 380
 381         for i in $enableval
 382         do
 383             flag=0
 384
 385             case $i in
 386             yes)
 387                 flag=1
 388                 ;;
 389             verbose)
 390                 flag=2
 391                 ;;
 392             lifetime)
 393                 flag=4
 394                 ;;
 395             owner)
 396                 flag=8
 397                 ;;
 398             verbose-alloc)
 399                 flag=16
 400                 ;;
 401             all)
 402                 apr_pool_debug=31
 403                 ;;
 404             *)
 405                 ;;
 406             esac
 407
 408             if test $flag -gt 0; then
 409                 apr_pool_debug=`expr '(' $apr_pool_debug - $apr_pool_debug % \
 410                     '(' $flag '*' 2 ')' ')' + $flag + $apr_pool_debug % $flag`
 411             fi
 412         done
 413
 414         APR_ADDTO(CPPFLAGS, -DAPR_POOL_DEBUG=$apr_pool_debug)
 415     fi
 416   ])
 417
 418 if test "$host" = "i586-pc-beos"; then
 419   AC_ARG_ENABLE(malloc-debug,[  --enable-malloc-debug   Switch on malloc_debug for BeOS],
 420     APR_REMOVEFROM(CFLAGS, -O2)
 421     APR_ADDTO(CPPFLAGS, -fcheck-memory-usage -D_KERNEL_MODE)
 422   ) dnl
 423 fi
 424
 425 # this is the place to put specific options for platform/compiler
 426 # combinations
 427 case "$host:$CC" in
 428     *-hp-hpux*:cc )
 429         APR_ADDTO(CFLAGS,[-Ae +Z])
 430         case $host in
 431           ia64-* )
 432             ;;
 433           * )
 434             if echo "$CFLAGS " | grep '+DA' >/dev/null; then :
 435             else
 436               APR_ADDTO(CFLAGS,[+DAportable])
 437             fi
 438             ;;
 439         esac
 440         ;;
 441     powerpc-*-beos:mwcc* )
 442         APR_SETVAR(CPP,[mwcc -E])
 443         APR_SETVAR(CC,mwcc)
 444         APR_SETVAR(AR,ar)
 445         ;;
 446     dnl If building static APR, both the APR build and the app build
 447     dnl need -DAPR_DECLARE_STATIC to generate the right linkage from
 448     dnl APR_DECLARE et al.
 449     dnl If building dynamic APR, the APR build needs APR_DECLARE_EXPORT
 450     dnl and the app build should have neither define.
 451     *-mingw* | *-cygwin*)
 452         if test "$enable_shared" = "yes"; then
 453             APR_ADDTO(INTERNAL_CPPFLAGS, -DAPR_DECLARE_EXPORT)
 454         else
 455             APR_ADDTO(CPPFLAGS, -DAPR_DECLARE_STATIC)
 456         fi
 457         ;;
 458 esac
 459
 460 AC_CACHE_CHECK([whether the compiler provides atomic builtins], [ap_cv_atomic_builtins],
 461 [AC_TRY_RUN([
 462 int main()
 463 {
 464     unsigned long val = 1010, tmp, *mem = &val;
 465
 466     if (__sync_fetch_and_add(&val, 1010) != 1010 || val != 2020)
 467         return 1;
 468
 469     tmp = val;
 470
 471     if (__sync_fetch_and_sub(mem, 1010) != tmp || val != 1010)
 472         return 1;
 473
 474     if (__sync_sub_and_fetch(&val, 1010) != 0 || val != 0)
 475         return 1;
 476
 477     tmp = 3030;
 478
 479     if (__sync_val_compare_and_swap(mem, 0, tmp) != 0 || val != tmp)
 480         return 1;
 481
 482     if (__sync_lock_test_and_set(&val, 4040) != 3030)
 483         return 1;
 484
 485     mem = &tmp;
 486
 487     if (__sync_val_compare_and_swap(&mem, &tmp, &val) != &tmp)
 488         return 1;
 489
 490     __sync_synchronize();
 491
 492     if (mem != &val)
 493         return 1;
 494
 495     return 0;
 496 }], [ap_cv_atomic_builtins=yes], [ap_cv_atomic_builtins=no], [ap_cv_atomic_builtins=no])])
 497
 498 if test "$ap_cv_atomic_builtins" = "yes"; then
 499     AC_DEFINE(HAVE_ATOMIC_BUILTINS, 1, [Define if compiler provides atomic builtins])
 500 fi
 501
 502 case $host in
 503     powerpc-405-*)
 504         # The IBM ppc405cr processor has a bugged stwcx instruction.
 505         AC_DEFINE(PPC405_ERRATA, 1, [Define on PowerPC 405 where errata 77 applies])
 506         ;;
 507     *)
 508         ;;
 509 esac
 510
 511 dnl Check the depend program we can use
 512 APR_CHECK_DEPEND
 513
 514 proc_mutex_is_global=0
 515
 516 config_subdirs="none"
 517 INSTALL_SUBDIRS="none"
 518 OBJECTS_PLATFORM='$(OBJECTS_unix)'
 519
 520 case $host in
 521    i386-ibm-aix* | *-ibm-aix[[1-2]].* | *-ibm-aix3.* | *-ibm-aix4.1 | *-ibm-aix4.1.* | *-ibm-aix4.2 | *-ibm-aix4.2.*)
 522        OSDIR="aix"
 523        APR_ADDTO(LDFLAGS,-lld)
 524        eolstr="\\n"
 525        OBJECTS_PLATFORM='$(OBJECTS_aix)'
 526        ;;
 527    *-os2*)
 528        APR_ADDTO(CPPFLAGS,-DOS2)
 529        APR_ADDTO(CFLAGS,-Zmt)
 530        AC_CHECK_LIB(bsd, random)
 531        OSDIR="os2"
 532        enable_threads="system_threads"
 533        eolstr="\\r\\n"
 534        file_as_socket="0"
 535        proc_mutex_is_global=1
 536        OBJECTS_PLATFORM='$(OBJECTS_os2)'
 537        ;;
 538    *beos*)
 539        OSDIR="beos"
 540        APR_ADDTO(CPPFLAGS,-DBEOS)
 541        enable_threads="system_threads"
 542        native_mmap_emul="1"
 543        APR_CHECK_DEFINE(BONE_VERSION, sys/socket.h)
 544        eolstr="\\n"
 545        osver=`uname -r`
 546        proc_mutex_is_global=1
 547        OBJECTS_PLATFORM='$(OBJECTS_beos)'
 548        case $osver in
 549           5.0.4)
 550              file_as_socket="1"
 551              ;;
 552           *)
 553              file_as_socket="0"
 554              ;;
 555        esac
 556        ;;
 557    *apple-darwin*)
 558        ac_cv_func_fdatasync="no" # Mac OS X wrongly reports it has fdatasync()
 559        OSDIR="unix"
 560        eolstr="\\n"
 561        ;;
 562    *os390)
 563        OSDIR="os390"
 564        OBJECTS_PLATFORM='$(OBJECTS_os390)'
 565        eolstr="\\n"
 566        ;;
 567    *os400)
 568        OSDIR="as400"
 569        eolstr="\\n"
 570        ;;
 571    *mingw*)
 572        OSDIR="win32"
 573        enable_threads="system_threads"
 574        eolstr="\\r\\n"
 575        file_as_socket=0
 576        proc_mutex_is_global=1
 577        OBJECTS_PLATFORM='$(OBJECTS_win32)'
 578        ;;
 579    *cygwin*)
 580        OSDIR="unix"
 581        enable_threads="no"
 582        eolstr="\\n"
 583        ;;
 584    *hpux10* )
 585        enable_threads="no"
 586        OSDIR="unix"
 587        eolstr="\\n"
 588        ;;
 589    *darwin* )
 590        ac_cv_func_fdatasync="no" # Mac OS X wrongly reports it has fdatasync()
 591        OSDIR="unix"
 592        eolstr="\\n"
 593        ;;
 594    *)
 595        OSDIR="unix"
 596        eolstr="\\n"
 597        ;;
 598 esac
 599
 600 AC_SUBST(OBJECTS_PLATFORM)
 601
 602 # Check whether LFS has explicitly been disabled
 603 AC_ARG_ENABLE(lfs,[  --disable-lfs           Disable large file support on 32-bit platforms],
 604 [apr_lfs_choice=$enableval], [apr_lfs_choice=yes])
 605
 606 if test "$apr_lfs_choice" = "yes"; then
 607    # Check whether the transitional LFS API is sufficient
 608    AC_CACHE_CHECK([whether to enable -D_LARGEFILE64_SOURCE], [apr_cv_use_lfs64], [
 609    apr_save_CPPFLAGS=$CPPFLAGS
 610    CPPFLAGS="$CPPFLAGS -D_LARGEFILE64_SOURCE"
 611    AC_TRY_RUN([
 612 #include <sys/types.h>
 613 #include <sys/stat.h>
 614 #include <fcntl.h>
 615 #include <stdlib.h>
 616 #include <stdio.h>
 617 #include <unistd.h>
 618
 619 void main(void)
 620 {
 621     int fd, ret = 0;
 622     struct stat64 st;
 623     off64_t off = 4242;
 624
 625     if (sizeof(off64_t) != 8 || sizeof(off_t) != 4)
 626        exit(1);
 627     if ((fd = open("conftest.lfs", O_LARGEFILE|O_CREAT|O_WRONLY, 0644)) < 0)
 628        exit(2);
 629     if (ftruncate64(fd, off) != 0)
 630        ret = 3;
 631     else if (fstat64(fd, &st) != 0 || st.st_size != off)
 632        ret = 4;
 633     else if (lseek64(fd, off, SEEK_SET) != off)
 634        ret = 5;
 635     else if (close(fd) != 0)
 636        ret = 6;
 637     else if (lstat64("conftest.lfs", &st) != 0 || st.st_size != off)
 638        ret = 7;
 639     else if (stat64("conftest.lfs", &st) != 0 || st.st_size != off)
 640        ret = 8;
 641     unlink("conftest.lfs");
 642
 643     exit(ret);
 644 }], [apr_cv_use_lfs64=yes], [apr_cv_use_lfs64=no], [apr_cv_use_lfs64=no])
 645    CPPFLAGS=$apr_save_CPPFLAGS])
 646    if test "$apr_cv_use_lfs64" = "yes"; then
 647       APR_ADDTO(CPPFLAGS, [-D_LARGEFILE64_SOURCE])
 648    fi
 649 fi
 650
 651 AC_ARG_ENABLE(nonportable-atomics,
 652 [  --enable-nonportable-atomics  Use optimized atomic code which may produce nonportable binaries],
 653 [if test $enableval = yes; then
 654    force_generic_atomics=no
 655  else
 656    force_generic_atomics=yes
 657  fi
 658 ],
 659 [case $host_cpu in
 660    i[[456]]86) force_generic_atomics=yes ;;
 661    *) force_generic_atomics=no
 662       case $host in
 663          *solaris2.10*)
 664             AC_TRY_COMPILE(
 665                 [#include <atomic.h>],
 666                 [void *ptr = NULL; atomic_cas_ptr(&ptr, NULL, NULL);],,
 667                 [force_generic_atomics=yes]
 668             )
 669             if test $force_generic_atomics = yes; then
 670                 AC_MSG_NOTICE([nonportable atomic support disabled, system needs Patch-ID 118884 or 118885])
 671             fi
 672             ;;
 673       esac
 674       ;;
 675 esac
 676 ])
 677
 678 if test $force_generic_atomics = yes; then
 679    AC_DEFINE([USE_ATOMICS_GENERIC], 1,
 680              [Define if use of generic atomics is requested])
 681 fi
 682
 683 AC_SUBST(proc_mutex_is_global)
 684 AC_SUBST(eolstr)
 685 AC_SUBST(INSTALL_SUBDIRS)
 686
 687 # For some platforms we need a version string which allows easy numeric
 688 # comparisons.
 689 case $host in
 690     *freebsd*)
 691         if test -x /sbin/sysctl; then
 692             os_version=`/sbin/sysctl -n kern.osreldate`
 693         else
 694             os_version=000000
 695         fi
 696         ;;
 697     *linux*)
 698         os_major=[`uname -r | sed -e 's/\([1-9][0-9]*\)\..*/\1/'`]
 699         os_minor=[`uname -r | sed -e 's/[1-9][0-9]*\.\([0-9]\+\)\..*/\1/'`]
 700         if test $os_major -lt 2 -o \( $os_major -eq 2 -a $os_minor -lt 4 \); then
 701             AC_MSG_WARN([Configured for pre-2.4 Linux $os_major.$os_minor])
 702             os_pre24linux=1
 703         else
 704             os_pre24linux=0
 705             AC_MSG_NOTICE([Configured for Linux $os_major.$os_minor])
 706         fi
 707         ;;
 708     *os390)
 709         os_version=`uname -r | sed -e 's/\.//g'`
 710         ;;
 711     *)
 712         os_version=OS_VERSION_IS_NOT_SET
 713         ;;
 714 esac
 715
 716 echo "${nl}Checking for libraries..."
 717
 718 dnl ----------------------------- Checks for Any required Libraries
 719 dnl Note: Autoconf will always append LIBS with an extra " " in AC_CHECK_LIB.
 720 dnl It should check for LIBS being empty and set LIBS equal to the new value
 721 dnl without the extra " " in that case, but they didn't do that.  So, we
 722 dnl end up LIBS="-lm -lcrypt -lnsl  -ldl" which is an annoyance.
 723 case $host in
 724    *mingw*)
 725       APR_ADDTO(LIBS,[-lshell32 -ladvapi32 -lws2_32 -lrpcrt4 -lmswsock])
 726       ac_cv_func_CreateFileMapping=yes
 727       ;;
 728    *)
 729       AC_SEARCH_LIBS(gethostbyname, nsl)
 730       AC_SEARCH_LIBS(gethostname, nsl)
 731       AC_SEARCH_LIBS(socket, socket)
 732       AC_SEARCH_LIBS(crypt, crypt ufc)
 733       AC_CHECK_LIB(truerand, main)
 734       AC_SEARCH_LIBS(modf, m)
 735        ;;
 736 esac
 737
 738 dnl ----------------------------- Checking for Threads
 739 echo "${nl}Checking for Threads..."
 740
 741 if test -z "$enable_threads"; then
 742         AC_ARG_ENABLE(threads,
 743         [  --enable-threads        Enable threading support in APR.],
 744         [ enable_threads=$enableval] ,
 745         [ APR_CHECK_PTHREADS_H([ enable_threads="pthread" ] ,
 746                                [ enable_threads="no" ] ) ] )
 747 fi
 748
 749 if test "$enable_threads" = "no"; then
 750     threads="0"
 751     pthreadh="0"
 752     pthreadser="0"
 753 else
 754     if test "$enable_threads" = "pthread"; then
 755 # We have specified pthreads for our threading library, just make sure
 756 # that we have everything we need
 757       APR_PTHREADS_CHECK_SAVE
 758       APR_PTHREADS_CHECK
 759       APR_CHECK_PTHREADS_H([
 760           threads="1"
 761           pthreadh="1"
 762           pthreadser="1" ], [
 763           threads="0"
 764           pthreadh="0"
 765           pthreadser="0"
 766           APR_PTHREADS_CHECK_RESTORE ] )
 767     elif test "$enable_threads" = "system_threads"; then
 768         threads="1"
 769         pthreadh="0"
 770         pthreadser="0"
 771     else
 772 # We basically specified that we wanted threads, but not how to implement
 773 # them.  In this case, just look for pthreads.  In the future, we can check
 774 # for other threading libraries as well.
 775       APR_PTHREADS_CHECK_SAVE
 776       APR_PTHREADS_CHECK
 777       APR_CHECK_PTHREADS_H([
 778           threads="1"
 779           pthreadh="1"
 780           pthreadser="1" ], [
 781           threads="0"
 782           pthreadser="0"
 783           pthreadh="0"
 784           APR_PTHREADS_CHECK_RESTORE ] )
 785     fi
 786     if test "$pthreadh" = "1"; then
 787         APR_CHECK_PTHREAD_GETSPECIFIC_TWO_ARGS
 788         APR_CHECK_PTHREAD_ATTR_GETDETACHSTATE_ONE_ARG
 789         APR_CHECK_PTHREAD_RECURSIVE_MUTEX
 790         AC_CHECK_FUNCS([pthread_key_delete pthread_rwlock_init \
 791                         pthread_attr_setguardsize pthread_yield])
 792
 793         if test "$ac_cv_func_pthread_rwlock_init" = "yes"; then
 794             dnl ----------------------------- Checking for pthread_rwlock_t
 795             AC_CACHE_CHECK([for pthread_rwlock_t], [apr_cv_type_rwlock_t],
 796             AC_TRY_COMPILE([#include <sys/types.h>
 797 #include <pthread.h>], [pthread_rwlock_t *rwlock;],
 798               [apr_cv_type_rwlock_t=yes], [apr_cv_type_rwlock_t=no],
 799               [apr_cv_type_rwlock_t=no]))
 800             if test "$apr_cv_type_rwlock_t" = "yes"; then
 801                AC_DEFINE(HAVE_PTHREAD_RWLOCKS, 1, [Define if pthread rwlocks are available])
 802             fi
 803         fi
 804
 805         if test "$ac_cv_func_pthread_yield" = "no"; then
 806             dnl ----------------------------- Checking for sched_yield
 807             AC_CHECK_HEADERS([sched.h])
 808             AC_CHECK_FUNCS([sched_yield])
 809         fi
 810     fi
 811 fi
 812
 813 ac_cv_define_READDIR_IS_THREAD_SAFE=yes
 814 ac_cv_define_GETHOSTBYNAME_IS_THREAD_SAFE=no
 815 ac_cv_define_GETHOSTBYADDR_IS_THREAD_SAFE=no
 816 ac_cv_define_GETSERVBYNAME_IS_THREAD_SAFE=no
 817 if test "$threads" = "1"; then
 818     echo "APR will use threads"
 819     AC_DEFINE(READDIR_IS_THREAD_SAFE, 1, [Modern readdir is thread safe])
 820     if test "x$apr_gethostbyname_is_thread_safe" = "x"; then
 821         AC_CHECK_LIB(c_r, gethostbyname, apr_gethostbyname_is_thread_safe=yes)
 822     fi
 823     if test "$apr_gethostbyname_is_thread_safe" = "yes"; then
 824         AC_DEFINE(GETHOSTBYNAME_IS_THREAD_SAFE, 1,
 825                   [Define if gethostbyname is thread safe])
 826     fi
 827     if test "x$apr_gethostbyaddr_is_thread_safe" = "x"; then
 828         AC_CHECK_LIB(c_r, gethostbyaddr, apr_gethostbyaddr_is_thread_safe=yes)
 829     fi
 830     if test "$apr_gethostbyaddr_is_thread_safe" = "yes"; then
 831         AC_DEFINE(GETHOSTBYADDR_IS_THREAD_SAFE, 1,
 832                   [Define if gethostbyaddr is thread safe])
 833     fi
 834     if test "x$apr_getservbyname_is_thread_safe" = "x"; then
 835         AC_CHECK_LIB(c_r, getservbyname, apr_getservbyname_is_thread_safe=yes)
 836     fi
 837     if test "$apr_getservbyname_is_thread_safe" = "yes"; then
 838         AC_DEFINE(GETSERVBYNAME_IS_THREAD_SAFE, 1,
 839                   [Define if getservbyname is thread safe])
 840     fi
 841     AC_CHECK_FUNCS(gethostbyname_r gethostbyaddr_r getservbyname_r)
 842 else
 843     echo "APR will be non-threaded"
 844 fi
 845
 846 dnl Electric Fence malloc checker.
 847 dnl --with-efence specifies the path to Electric Fence.
 848 dnl This test should remain after the threads checks since libefence
 849 dnl may depend on libpthread.
 850 AC_ARG_WITH(efence,
 851   [  --with-efence[[=DIR]]     path to Electric Fence installation],
 852   [ apr_efence_dir="$withval"
 853     if test "$apr_efence_dir" != "yes"; then
 854       APR_ADDTO(LDFLAGS,[-L$apr_efence_dir/lib])
 855       if test "x$apr_platform_runtime_link_flag" != "x"; then
 856           APR_ADDTO(LDFLAGS,
 857                     [$apr_platform_runtime_link_flag$apr_efence_dir/lib])
 858       fi
 859     fi
 860     AC_CHECK_LIB(efence, malloc,
 861                  [ APR_ADDTO(LIBS,-lefence) ],
 862                  [ AC_MSG_ERROR(Electric Fence requested but not detected) ])
 863   ])
 864
 865 AC_ARG_WITH(valgrind,
 866   [  --with-valgrind[[=DIR]]   Enable code to teach valgrind about apr pools
 867                           (optionally: set path to valgrind headers) ],
 868   [ if test "$withval" != no; then
 869       if test "$withval" = yes; then
 870         withval=/usr/include/valgrind
 871       fi
 872       APR_ADDTO(CPPFLAGS, -I$withval)
 873       AC_CHECK_HEADERS(valgrind.h memcheck.h)
 874       APR_IFALLYES(header:valgrind.h header:memcheck.h,
 875         [AC_DEFINE(HAVE_VALGRIND, 1, [Compile in valgrind support]) ],
 876         [AC_MSG_ERROR(valgrind headers not found) ]
 877       )
 878     fi ]
 879 )
 880
 881 AC_CHECK_FUNCS(sigsuspend, [ have_sigsuspend="1" ], [ have_sigsuspend="0" ])
 882 AC_CHECK_FUNCS(sigwait, [ have_sigwait="1" ], [ have_sigwait="0" ])
 883 dnl AC_CHECK_FUNCS doesn't work for this on Tru64 since the function
 884 dnl is renamed in signal.h.  Todo: Autodetect
 885 case $host in
 886     *alpha*-dec-osf* )
 887         have_sigwait="1"
 888         ;;
 889 esac
 890
 891 AC_SUBST(threads)
 892 AC_SUBST(have_sigsuspend)
 893 AC_SUBST(have_sigwait)
 894
 895 AC_CHECK_FUNCS(poll kqueue port_create)
 896
 897 # Check for the Linux epoll interface; epoll* may be available in libc
 898 # but return ENOSYS on a pre-2.6 kernel, so do a run-time check.
 899 AC_CACHE_CHECK([for epoll support], [apr_cv_epoll],
 900 [AC_TRY_RUN([
 901 #include <sys/epoll.h>
 902 #include <unistd.h>
 903
 904 int main()
 905 {
 906     return epoll_create(5) == -1;
 907 }], [apr_cv_epoll=yes], [apr_cv_epoll=no], [apr_cv_epoll=no])])
 908
 909 if test "$apr_cv_epoll" = "yes"; then
 910    AC_DEFINE([HAVE_EPOLL], 1, [Define if the epoll interface is supported])
 911 fi
 912
 913 dnl ----------------------------- Checking for extended file descriptor handling
 914 # test for epoll_create1
 915 AC_CACHE_CHECK([for epoll_create1 support], [apr_cv_epoll_create1],
 916 [AC_TRY_RUN([
 917 #include <sys/epoll.h>
 918 #include <unistd.h>
 919
 920 int main()
 921 {
 922     return epoll_create1(0) == -1;
 923 }], [apr_cv_epoll_create1=yes], [apr_cv_epoll_create1=no], [apr_cv_epoll_create1=no])])
 924
 925 if test "$apr_cv_epoll_create1" = "yes"; then
 926    AC_DEFINE([HAVE_EPOLL_CREATE1], 1, [Define if epoll_create1 function is supported])
 927 fi
 928
 929 # test for dup3
 930 AC_CACHE_CHECK([for dup3 support], [apr_cv_dup3],
 931 [AC_TRY_RUN([
 932 #include <unistd.h>
 933
 934 int main()
 935 {
 936     return dup3(STDOUT_FILENO, STDERR_FILENO, 0) == -1;
 937 }], [apr_cv_dup3=yes], [apr_cv_dup3=no], [apr_cv_dup3=no])])
 938
 939 if test "$apr_cv_dup3" = "yes"; then
 940    AC_DEFINE([HAVE_DUP3], 1, [Define if dup3 function is supported])
 941 fi
 942
 943 # Test for accept4().  Create a non-blocking socket, bind it to
 944 # an unspecified port & address (kernel picks), and attempt to
 945 # call accept4() on it.  If the syscall is wired up (i.e. the
 946 # kernel is new enough), it should return EAGAIN.
 947 AC_CACHE_CHECK([for accept4 support], [apr_cv_accept4],
 948 [AC_TRY_RUN([
 949 #include <sys/types.h>
 950 #include <sys/socket.h>
 951 #include <sys/wait.h>
 952 #include <netinet/in.h>
 953 #include <netinet/tcp.h>
 954 #include <errno.h>
 955 #include <string.h>
 956 #include <unistd.h>
 957 #include <fcntl.h>
 958
 959 int main(int argc, char **argv)
 960 {
 961     int fd, flags;
 962     struct sockaddr_in sin;
 963
 964     if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
 965         return 1;
 966     flags = fcntl(fd, F_GETFL);
 967     if (flags == -1 || fcntl(fd, F_SETFL, flags|O_NONBLOCK) == -1)
 968         return 5;
 969
 970     memset(&sin, 0, sizeof sin);
 971     sin.sin_family = AF_INET;
 972
 973     if (bind(fd, (struct sockaddr *) &sin, sizeof sin) == -1)
 974         return 2;
 975
 976     if (listen(fd, 5) == -1)
 977         return 3;
 978
 979     if (accept4(fd, NULL, 0, SOCK_NONBLOCK) == 0
 980         || errno == EAGAIN || errno == EWOULDBLOCK)
 981         return 0;
 982
 983     return 4;
 984 }], [apr_cv_accept4=yes], [apr_cv_accept4=no], [apr_cv_accept4=no])])
 985
 986 if test "$apr_cv_accept4" = "yes"; then
 987    AC_DEFINE([HAVE_ACCEPT4], 1, [Define if accept4 function is supported])
 988 fi
 989
 990 AC_CACHE_CHECK([for SOCK_CLOEXEC support], [apr_cv_sock_cloexec],
 991 [AC_TRY_RUN([
 992 #include <sys/types.h>
 993 #include <sys/socket.h>
 994
 995 int main()
 996 {
 997     return socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC, 0) == -1;
 998 }], [apr_cv_sock_cloexec=yes], [apr_cv_sock_cloexec=no], [apr_cv_sock_cloexec=no])])
 999
1000 if test "$apr_cv_sock_cloexec" = "yes"; then
1001    AC_DEFINE([HAVE_SOCK_CLOEXEC], 1, [Define if the SOCK_CLOEXEC flag is supported])
1002 fi
1003
1004 dnl ----------------------------- Checking for fdatasync: OS X doesn't have it
1005 AC_CHECK_FUNCS(fdatasync)
1006
1007 dnl ----------------------------- Checking for extended file descriptor handling
1008 # test for epoll_create1
1009 AC_CACHE_CHECK([for epoll_create1 support], [apr_cv_epoll_create1],
1010 [AC_TRY_RUN([
1011 #include <sys/epoll.h>
1012 #include <unistd.h>
1013
1014 int main()
1015 {
1016     return epoll_create1(0) == -1;
1017 }], [apr_cv_epoll_create1=yes], [apr_cv_epoll_create1=no], [apr_cv_epoll_create1=no])])
1018
1019 if test "$apr_cv_epoll_create1" = "yes"; then
1020    AC_DEFINE([HAVE_EPOLL_CREATE1], 1, [Define if epoll_create1 function is supported])
1021 fi
1022
1023 # Check for z/OS async i/o support.
1024 AC_CACHE_CHECK([for asio -> message queue support], [apr_cv_aio_msgq],
1025 [AC_TRY_RUN([
1026 #define _AIO_OS390
1027 #include <aio.h>
1028
1029 int main()
1030 {
1031     struct aiocb a;
1032
1033     a.aio_notifytype = AIO_MSGQ;  /* use IPC message queue for notification */
1034
1035     return aio_cancel(2, NULL) == -1;
1036 }], [apr_cv_aio_msgq=yes], [apr_cv_aio_msgq=no], [apr_cv_aio_msgq=no])])
1037
1038 if test "$apr_cv_aio_msgq" = "yes"; then
1039    AC_DEFINE([HAVE_AIO_MSGQ], 1, [Define if async i/o supports message q's])
1040 fi
1041
1042 # test for dup3
1043 AC_CACHE_CHECK([for dup3 support], [apr_cv_dup3],
1044 [AC_TRY_RUN([
1045 #include <unistd.h>
1046
1047 int main()
1048 {
1049     return dup3(STDOUT_FILENO, STDERR_FILENO, 0) == -1;
1050 }], [apr_cv_dup3=yes], [apr_cv_dup3=no], [apr_cv_dup3=no])])
1051
1052 if test "$apr_cv_dup3" = "yes"; then
1053    AC_DEFINE([HAVE_DUP3], 1, [Define if dup3 function is supported])
1054 fi
1055
1056 # test for accept4
1057 AC_CACHE_CHECK([for accept4 support], [apr_cv_accept4],
1058 [AC_TRY_RUN([
1059 #include <unistd.h>
1060 #include <sys/types.h>
1061 #include <sys/socket.h>
1062 #include <sys/un.h>
1063 #include <sys/wait.h>
1064 #include <signal.h>
1065 #include <errno.h>
1066
1067 #define A4_SOCK "./apr_accept4_test_socket"
1068
1069 int main()
1070 {
1071     pid_t pid;
1072     int fd;
1073     struct sockaddr_un loc, rem;
1074     socklen_t rem_sz;
1075
1076     if ((pid = fork())) {
1077         int status;
1078
1079         unlink(A4_SOCK);
1080
1081         if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
1082             goto cleanup_failure2;
1083
1084         loc.sun_family = AF_UNIX;
1085         strncpy(loc.sun_path, A4_SOCK, sizeof(loc.sun_path) - 1);
1086
1087         if (bind(fd, (struct sockaddr *) &loc,
1088                  sizeof(struct sockaddr_un)) == -1)
1089             goto cleanup_failure;
1090
1091         if (listen(fd, 5) == -1)
1092             goto cleanup_failure;
1093
1094         rem_sz = sizeof(struct sockaddr_un);
1095         if (accept4(fd, (struct sockaddr *) &rem, &rem_sz, 0) == -1) {
1096             goto cleanup_failure;
1097         }
1098         else {
1099             close(fd);
1100             waitpid(pid, &status, 0);
1101             unlink(A4_SOCK);
1102             return 0;
1103         }
1104
1105 cleanup_failure:
1106         close(fd);
1107 cleanup_failure2:
1108         kill(pid, SIGKILL);
1109         waitpid(pid, &status, 0);
1110         unlink(A4_SOCK);
1111         return 1;
1112     }
1113     else {
1114         if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
1115             return 1; /* this will be bad: we'll hang */
1116
1117         loc.sun_family = AF_UNIX;
1118         strncpy(loc.sun_path, A4_SOCK, sizeof(loc.sun_path) - 1);
1119
1120         while(connect(fd, (struct sockaddr *) &loc,
1121                       sizeof(struct sockaddr_un)) == -1 &&
1122               (errno==ENOENT || errno==ECONNREFUSED))
1123             ;
1124
1125         close(fd);
1126         return 0;
1127     }
1128 }], [apr_cv_accept4=yes], [apr_cv_accept4=no], [apr_cv_accept4=no])])
1129
1130 if test "$apr_cv_accept4" = "yes"; then
1131    AC_DEFINE([HAVE_ACCEPT4], 1, [Define if accept4 function is supported])
1132 fi
1133
1134 AC_CACHE_CHECK([for SOCK_CLOEXEC support], [apr_cv_sock_cloexec],
1135 [AC_TRY_RUN([
1136 #include <sys/types.h>
1137 #include <sys/socket.h>
1138
1139 int main()
1140 {
1141     return socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC, 0) == -1;
1142 }], [apr_cv_sock_cloexec=yes], [apr_cv_sock_cloexec=no], [apr_cv_sock_cloexec=no])])
1143
1144 if test "$apr_cv_sock_cloexec" = "yes"; then
1145    AC_DEFINE([HAVE_SOCK_CLOEXEC], 1, [Define if the SOCK_CLOEXEC flag is supported])
1146 fi
1147
1148 dnl ----------------------------- Checking for missing POSIX thread functions
1149 AC_CHECK_FUNCS([getpwnam_r getpwuid_r getgrnam_r getgrgid_r])
1150
1151 dnl ----------------------------- Checking for Shared Memory Support
1152 echo "${nl}Checking for Shared Memory Support..."
1153
1154 # The real-time POSIX extensions (e.g. shm_*, sem_*) may only
1155 # be available if linking against librt.
1156 AC_SEARCH_LIBS(shm_open, rt)
1157
1158 case $host in
1159  *-sysv*)
1160    ac_includes_default="$ac_includes_default
1161 #if HAVE_SYS_MUTEX_H /* needed to define lock_t for sys/shm.h */
1162 # include <sys/mutex.h>
1163 #endif";;
1164 esac
1165
1166 AC_CHECK_HEADERS([sys/types.h sys/mman.h sys/ipc.h sys/mutex.h \
1167                   sys/shm.h sys/file.h sys/socket.h kernel/OS.h os2.h windows.h])
1168 AC_CHECK_HEADERS([net/if.h],[],[],
1169 [
1170 #ifdef HAVE_SYS_SOCKET_H
1171 #include <sys/socket.h>
1172 #endif
1173 #include <net/if.h>
1174 ])
1175 AC_CHECK_FUNCS([mmap munmap shm_open shm_unlink shmget shmat shmdt shmctl \
1176                 create_area mprotect])
1177
1178 APR_CHECK_DEFINE(MAP_ANON, sys/mman.h)
1179 AC_CHECK_FILE(/dev/zero)
1180
1181 # Not all systems can mmap /dev/zero (such as HP-UX).  Check for that.
1182 if test "$ac_cv_func_mmap" = "yes" &&
1183    test "$ac_cv_file__dev_zero" = "yes"; then
1184     AC_MSG_CHECKING(for mmap that can map /dev/zero)
1185     AC_TRY_RUN([
1186 #include <sys/types.h>
1187 #include <sys/stat.h>
1188 #include <fcntl.h>
1189 #ifdef HAVE_SYS_MMAN_H
1190 #include <sys/mman.h>
1191 #endif
1192     int main()
1193     {
1194         int fd;
1195         void *m;
1196         fd = open("/dev/zero", O_RDWR);
1197         if (fd < 0) {
1198             return 1;
1199         }
1200         m = mmap(0, sizeof(void*), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
1201         if (m == (void *)-1) {  /* aka MAP_FAILED */
1202             return 2;
1203         }
1204         if (munmap(m, sizeof(void*)) < 0) {
1205             return 3;
1206         }
1207         return 0;
1208     }], [], [ac_cv_file__dev_zero=no], [ac_cv_file__dev_zero=no])
1209
1210     AC_MSG_RESULT($ac_cv_file__dev_zero)
1211 fi
1212
1213 # Now we determine which one is our anonymous shmem preference.
1214 haveshmgetanon="0"
1215 havemmapzero="0"
1216 havemmapanon="0"
1217 APR_BEGIN_DECISION([anonymous shared memory allocation method])
1218 APR_IFALLYES(header:sys/ipc.h header:sys/shm.h header:sys/file.h dnl
1219              func:shmget func:shmat func:shmdt func:shmctl,
1220              [haveshmgetanon="1"
1221               APR_DECIDE(USE_SHMEM_SHMGET_ANON, [SysV IPC shmget()])])
1222 APR_IFALLYES(header:sys/mman.h func:mmap func:munmap file:/dev/zero,
1223              [havemmapzero="1"
1224               APR_DECIDE(USE_SHMEM_MMAP_ZERO,
1225                   [SVR4-style mmap() on /dev/zero])])
1226 APR_IFALLYES(header:sys/mman.h func:mmap func:munmap define:MAP_ANON,
1227              [havemmapanon="1"
1228               APR_DECIDE(USE_SHMEM_MMAP_ANON,
1229                   [4.4BSD-style mmap() via MAP_ANON])])
1230 APR_IFALLYES(header:os2.h,
1231              [haveos2shm="1"
1232               APR_DECIDE(USE_SHMEM_OS2_ANON, [OS/2 DosAllocSharedMem()])])
1233 APR_IFALLYES(header:kernel/OS.h func:create_area,
1234              [havebeosshm="1"
1235               APR_DECIDE(USE_SHMEM_BEOS_ANON,
1236                          [BeOS areas])])
1237 APR_IFALLYES(header:windows.h func:CreateFileMapping,
1238              [havewin32shm="1"
1239               APR_DECIDE(USE_SHMEM_WIN32_ANON,
1240                          [Windows CreateFileMapping()])])
1241 case $host in
1242     *linux* )
1243         # Linux has problems with MM_SHMT_MMANON even though it reports
1244         # that it has it.
1245         # FIXME - find exact 2.3 version that MMANON was fixed in.  It is
1246         # confirmed fixed in 2.4 series.
1247         if test $os_pre24linux -eq 1; then
1248             AC_MSG_WARN([Disabling anon mmap() support for Linux pre-2.4])
1249             APR_DECISION_OVERRIDE(USE_SHMEM_MMAP_ZERO USE_SHMEM_SHMGET_ANON)
1250         fi
1251         ;;
1252     *hpux11* )
1253         APR_DECISION_OVERRIDE(USE_SHMEM_SHMGET_ANON)
1254         ;;
1255 esac
1256 APR_END_DECISION
1257 AC_DEFINE_UNQUOTED($ac_decision)
1258
1259 useshmgetanon="0"
1260 usemmapzero="0"
1261 usemmapanon="0"
1262
1263 case $ac_decision in
1264     USE_SHMEM_SHMGET_ANON )
1265         useshmgetanon="1"
1266         ;;
1267     USE_SHMEM_MMAP_ZERO )
1268         usemmapzero="1"
1269         ;;
1270     USE_SHMEM_MMAP_ANON )
1271         usemmapanon="1"
1272         ;;
1273 esac
1274
1275 AC_SUBST(useshmgetanon)
1276 AC_SUBST(usemmapzero)
1277 AC_SUBST(usemmapanon)
1278 AC_SUBST(haveshmgetanon)
1279 AC_SUBST(havemmapzero)
1280 AC_SUBST(havemmapanon)
1281
1282 # Now we determine which one is our name-based shmem preference.
1283 havemmaptmp="0"
1284 havemmapshm="0"
1285 haveshmget="0"
1286 havebeosarea="0"
1287 haveos2shm="0"
1288 havewin32shm="0"
1289 APR_BEGIN_DECISION([namebased memory allocation method])
1290 APR_IFALLYES(header:sys/mman.h func:mmap func:munmap,
1291              [havemmaptmp="1"
1292               APR_DECIDE(USE_SHMEM_MMAP_TMP,
1293                   [Classical mmap() on temporary file])])
1294 APR_IFALLYES(header:sys/mman.h func:mmap func:munmap func:shm_open dnl
1295              func:shm_unlink,
1296              [havemmapshm="1"
1297               APR_DECIDE(USE_SHMEM_MMAP_SHM,
1298                   [mmap() via POSIX.1 shm_open() on temporary file])])
1299 APR_IFALLYES(header:sys/ipc.h header:sys/shm.h header:sys/file.h dnl
1300              func:shmget func:shmat func:shmdt func:shmctl,
1301              [haveshmget="1"
1302               APR_DECIDE(USE_SHMEM_SHMGET, [SysV IPC shmget()])])
1303 APR_IFALLYES(header:kernel/OS.h func:create_area,
1304              [havebeosshm="1"
1305               APR_DECIDE(USE_SHMEM_BEOS, [BeOS areas])])
1306 APR_IFALLYES(header:os2.h,
1307              [haveos2shm="1"
1308               APR_DECIDE(USE_SHMEM_OS2, [OS/2 DosAllocSharedMem()])])
1309 APR_IFALLYES(header:windows.h,
1310              [havewin32shm="1"
1311               APR_DECIDE(USE_SHMEM_WIN32, [Windows shared memory])])
1312 AC_ARG_ENABLE(posix-shm,
1313 [  --enable-posix-shm      Use POSIX shared memory (shm_open) if available],
1314 [
1315 if test "$havemmapshm" = "1"; then
1316   APR_DECISION_OVERRIDE(USE_SHMEM_MMAP_SHM)
1317 fi
1318 ])
1319 case $host in
1320     *linux* )
1321         # Linux pre-2.4 had problems with MM_SHMT_MMANON even though
1322         # it reports that it has it.
1323         if test $os_pre24linux -eq 1; then
1324             APR_DECISION_OVERRIDE(USE_SHMEM_MMAP_TMP USE_SHMEM_MMAP_SHM dnl
1325                                   USE_SHMEM_SHMGET)
1326         fi
1327         ;;
1328 esac
1329 APR_END_DECISION
1330 AC_DEFINE_UNQUOTED($ac_decision)
1331
1332 usemmaptmp="0"
1333 usemmapshm="0"
1334 useshmget="0"
1335 usebeosarea="0"
1336 useos2shm="0"
1337 usewin32shm="0"
1338
1339 case $ac_decision in
1340     USE_SHMEM_MMAP_TMP )
1341         usemmaptmp="1"
1342         ;;
1343     USE_SHMEM_MMAP_SHM )
1344         usemmapshm="1"
1345         ;;
1346     USE_SHMEM_SHMGET )
1347         useshmget="1"
1348         ;;
1349     USE_SHMEM_BEOS )
1350         usebeosarea="1"
1351         ;;
1352     USE_SHMEM_OS2 )
1353         useos2shm="1"
1354         ;;
1355     USE_SHMEM_WIN32 )
1356         usewin32shm="1"
1357         ;;
1358 esac
1359
1360 # Do we have any shared memory support?
1361 if test "$usemmaptmp$usemmapshm$usemmapzero$useshmget$usemmapanon$usebeosarea$useos2shm$usewin32shm" = "00000000"; then
1362   sharedmem="0"
1363 else
1364   sharedmem="1"
1365 fi
1366
1367 AC_SUBST(usemmaptmp)
1368 AC_SUBST(usemmapshm)
1369 AC_SUBST(useshmget)
1370 AC_SUBST(usebeosarea)
1371 AC_SUBST(useos2shm)
1372 AC_SUBST(usewin32shm)
1373 AC_SUBST(havemmaptmp)
1374 AC_SUBST(havemmapshm)
1375 AC_SUBST(haveshmget)
1376 AC_SUBST(havebeosarea)
1377 AC_SUBST(haveos2shm)
1378 AC_SUBST(havewin32shm)
1379 AC_SUBST(sharedmem)
1380
1381 dnl ----------------------------- Checks for Any required Functions
1382 dnl Checks for library functions. (N.B. poll is further down)
1383
1384 AC_FUNC_ALLOCA
1385
1386 AC_CHECK_FUNCS([calloc setsid isinf isnan \
1387                 getenv putenv setenv unsetenv \
1388                 writev getifaddrs utime utimes])
1389 AC_CHECK_FUNCS(setrlimit, [ have_setrlimit="1" ], [ have_setrlimit="0" ])
1390 AC_CHECK_FUNCS(getrlimit, [ have_getrlimit="1" ], [ have_getrlimit="0" ])
1391 sendfile="0"
1392 AC_CHECK_LIB(sendfile, sendfilev)
1393 AC_CHECK_FUNCS(sendfile send_file sendfilev, [ sendfile="1" ])
1394
1395 dnl THIS MUST COME AFTER THE THREAD TESTS - FreeBSD doesn't always have a
1396 dnl threaded poll() and we don't want to use sendfile on early FreeBSD
1397 dnl systems if we are also using threads.
1398
1399 AC_ARG_WITH(sendfile, [  --with-sendfile         Override decision to use sendfile],
1400   [ if test "$withval" = "yes"; then
1401         sendfile="1"
1402     else
1403         sendfile="0"
1404     fi ], [
1405     orig_sendfile=$sendfile
1406     case $host in
1407         *freebsd*)
1408             # FreeBSD < 4.2 has issues with threads+sendfile
1409             if test $os_version -le "401999"; then
1410                 if test "$threads" = "1"; then
1411                     sendfile="0"
1412                 fi
1413             fi
1414             ;;
1415         *alpha*-dec-osf* )
1416             sendfile="0"
1417             ;;
1418         s390-*-linux-gnu)
1419             # disable sendfile support for 2.2 on S/390
1420             if test $os_pre24linux -eq 1; then
1421                 AC_MSG_WARN([Disabled sendfile support for Linux 2.2 on S/390])
1422                 sendfile="0"
1423             fi
1424             ;;
1425         *aix*)
1426             # compiler-independent check for 64-bit build
1427             AC_CHECK_SIZEOF(void*, 4)
1428             if test "x$ac_cv_sizeof_voidp" = "x8"; then
1429                 # sendfile not working for 64-bit build
1430                 sendfile="0"
1431             fi
1432             ;;
1433     esac
1434     if test "$orig_sendfile" != "$sendfile"; then
1435       echo "sendfile support disabled to avoid system problem"
1436     fi ] )
1437 AC_SUBST(sendfile)
1438
1439 AC_CHECK_FUNCS(sigaction, [ have_sigaction="1" ], [ have_sigaction="0" ])
1440 AC_DECL_SYS_SIGLIST
1441
1442 AC_CHECK_FUNCS(fork, [ fork="1" ], [ fork="0" ])
1443 APR_CHECK_INET_ADDR
1444 APR_CHECK_INET_NETWORK
1445 AC_SUBST(apr_inaddr_none)
1446 AC_CHECK_FUNC(_getch)
1447 AC_CHECK_FUNCS(strerror_r, [ strerror_r="1" ], [ strerror_r="0" ])
1448 if test "$strerror_r" = "1"; then
1449   APR_CHECK_STRERROR_R_RC
1450 fi
1451 AC_CHECK_FUNCS(mmap, [ mmap="1" ], [ mmap="0" ])
1452 if test "$native_mmap_emul" = "1"; then
1453     mmap="1"
1454 fi
1455 AC_CHECK_FUNCS(memmove, [ have_memmove="1" ], [have_memmove="0" ])
1456 AC_CHECK_FUNCS([getpass getpassphrase gmtime_r localtime_r])
1457 case $host in
1458     *-hp-hpux*)
1459         dnl mkstemp is limited to 26 temporary files (a-z); use APR replacement
1460         ;;
1461     *)
1462         AC_CHECK_FUNCS(mkstemp)
1463         ;;
1464 esac
1465
1466 AC_SUBST(fork)
1467 AC_SUBST(have_inet_addr)
1468 AC_SUBST(tcp_nodelay_inherited)
1469 AC_SUBST(o_nonblock_inherited)
1470 AC_SUBST(have_inet_network)
1471 AC_SUBST(have_sigaction)
1472 AC_SUBST(have_setrlimit)
1473 AC_SUBST(have_getrlimit)
1474 AC_SUBST(mmap)
1475 AC_SUBST(have_memmove)
1476
1477 APR_CHECK_SIGWAIT_ONE_ARG
1478
1479 dnl ----------------------------- Checks for Any required Headers
1480 AC_HEADER_STDC
1481
1482 APR_FLAG_HEADERS(
1483     ByteOrder.h         \
1484     conio.h             \
1485     crypt.h             \
1486     ctype.h             \
1487     dir.h               \
1488     dirent.h            \
1489     dl.h                \
1490     dlfcn.h             \
1491     errno.h             \
1492     fcntl.h             \
1493     grp.h               \
1494     inttypes.h          \
1495     io.h                \
1496     limits.h            \
1497     mach-o/dyld.h       \
1498     malloc.h            \
1499     memory.h            \
1500     netdb.h             \
1501     osreldate.h         \
1502     poll.h              \
1503     process.h           \
1504     pwd.h               \
1505     semaphore.h         \
1506     signal.h            \
1507     stdarg.h            \
1508     stddef.h            \
1509     stdio.h             \
1510     stdlib.h            \
1511     string.h            \
1512     strings.h           \
1513     sysapi.h            \
1514     sysgtime.h          \
1515     termios.h           \
1516     time.h              \
1517     tpfeq.h             \
1518     tpfio.h             \
1519     unistd.h            \
1520     unix.h              \
1521     windows.h           \
1522     winsock2.h          \
1523     arpa/inet.h         \
1524     kernel/OS.h         \
1525     net/errno.h         \
1526     netinet/in.h        \
1527     netinet/sctp.h      \
1528     netinet/sctp_uio.h  \
1529     sys/file.h          \
1530     sys/ioctl.h         \
1531     sys/mman.h          \
1532     sys/param.h         \
1533     sys/poll.h          \
1534     sys/resource.h      \
1535     sys/select.h        \
1536     sys/sem.h           \
1537     sys/sendfile.h      \
1538     sys/signal.h        \
1539     sys/socket.h        \
1540     sys/sockio.h        \
1541     sys/stat.h          \
1542     sys/sysctl.h        \
1543     sys/syslimits.h     \
1544     sys/time.h          \
1545     sys/types.h         \
1546     sys/uio.h           \
1547     sys/un.h            \
1548     sys/wait.h)
1549
1550 # IRIX 6.5 has a problem in <netinet/tcp.h> which prevents it from
1551 # being included by itself.  Check for <netinet/tcp.h> manually,
1552 # including another header file first.
1553 AC_CACHE_CHECK([for netinet/tcp.h], [apr_cv_hdr_netinet_tcp_h],
1554 [AC_TRY_CPP(
1555 [#ifdef HAVE_NETINET_IN_H
1556 #include <netinet/in.h>
1557 #endif
1558 #include <netinet/tcp.h>
1559 ], [apr_cv_hdr_netinet_tcp_h=yes], [apr_cv_hdr_netinet_tcp_h=no])])
1560 if test "$apr_cv_hdr_netinet_tcp_h" = "yes"; then
1561    netinet_tcph=1
1562    AC_DEFINE([HAVE_NETINET_TCP_H], 1, [Defined if netinet/tcp.h is present])
1563 else
1564    netinet_tcph=0
1565 fi
1566
1567 AC_SUBST(arpa_ineth)
1568 AC_SUBST(conioh)
1569 AC_SUBST(ctypeh)
1570 AC_SUBST(crypth)
1571 AC_SUBST(errnoh)
1572 AC_SUBST(direnth)
1573 AC_SUBST(fcntlh)
1574 AC_SUBST(inttypesh)
1575 AC_SUBST(ioh)
1576 AC_SUBST(limitsh)
1577 AC_SUBST(netdbh)
1578 AC_SUBST(sys_syslimitsh)
1579 AC_SUBST(netinet_inh)
1580 AC_SUBST(netinet_sctph)
1581 AC_SUBST(netinet_sctp_uioh)
1582 AC_SUBST(netinet_tcph)
1583 AC_SUBST(stdargh)
1584 AC_SUBST(stdioh)
1585 AC_SUBST(stdlibh)
1586 AC_SUBST(stringh)
1587 AC_SUBST(stringsh)
1588 AC_SUBST(sys_ioctlh)
1589 AC_SUBST(sys_sendfileh)
1590 AC_SUBST(sys_signalh)
1591 AC_SUBST(sys_socketh)
1592 AC_SUBST(sys_sockioh)
1593 AC_SUBST(sys_typesh)
1594 AC_SUBST(sys_timeh)
1595 AC_SUBST(sys_uioh)
1596 AC_SUBST(sys_unh)
1597 AC_SUBST(timeh)
1598 AC_SUBST(unistdh)
1599 AC_SUBST(signalh)
1600 AC_SUBST(sys_waith)
1601 AC_SUBST(processh)
1602 AC_SUBST(pthreadh)
1603 AC_SUBST(semaphoreh)
1604 AC_SUBST(windowsh)
1605 AC_SUBST(winsock2h)
1606
1607 # Checking for h_errno in <netdb.h>
1608 if test "$netdbh" = "1"; then
1609   APR_CHECK_H_ERRNO_FLAG
1610   if test "$ac_cv_h_errno_cflags" = "no"; then
1611     AC_MSG_ERROR([can not find h_errno in netdb.h])
1612   fi
1613 fi
1614
1615 AC_ARG_ENABLE(allocator-uses-mmap,
1616   [  --enable-allocator-uses-mmap    Use mmap in apr_allocator instead of malloc ],
1617   [ if test "$enableval" = "yes"; then
1618         APR_IFALLYES(header:sys/mman.h func:mmap func:munmap define:MAP_ANON,
1619                      [AC_DEFINE(APR_ALLOCATOR_USES_MMAP, 1,
1620                                 [Define if apr_allocator should use mmap]) ],
1621                      [AC_MSG_ERROR([mmap()/MAP_ANON not supported]) ]
1622                     )
1623     fi ]
1624 )
1625
1626 AC_ARG_ENABLE(allocator-guard-pages,
1627   [  --enable-allocator-guard-pages  Use guard pages in apr_allocator
1628                                   (implies --enable-allocator-uses-mmap) ] ,
1629   [ if test "$enableval" = "yes"; then
1630         APR_IFALLYES(header:sys/mman.h func:mmap func:munmap func:mprotect define:MAP_ANON,
1631                      [AC_DEFINE(APR_ALLOCATOR_GUARD_PAGES, 1,
1632                                 [Define if apr_allocator should use guard pages]) ],
1633                      [AC_MSG_ERROR([mmap()/MAP_ANON/mprotect() not supported]) ]
1634                    )
1635     fi ]
1636 )
1637
1638
1639 AC_ARG_ENABLE(pool-concurrency-check,
1640   [  --enable-pool-concurrency-check Check for concurrent usage of memory pools],
1641   [ if test "$enableval" = "yes"; then
1642     AC_DEFINE(APR_POOL_CONCURRENCY_CHECK, 1,
1643                [Define if pool functions should abort if concurrent usage is detected])
1644     fi ]
1645 )
1646
1647 dnl ----------------------------- Checks for standard typedefs
1648 AC_TYPE_OFF_T
1649 AC_TYPE_PID_T
1650 AC_TYPE_SIZE_T
1651 AC_TYPE_UID_T
1652 AC_CHECK_TYPE(ssize_t, int)
1653 AC_C_INLINE
1654 AC_C_CONST
1655 AC_FUNC_SETPGRP
1656
1657 APR_CHECK_SOCKLEN_T
1658
1659 dnl Checks for pointer size
1660 AC_CHECK_SIZEOF(void*, 4)
1661
1662 if test "x$ac_cv_sizeof_voidp" != "x"; then
1663     voidp_size=$ac_cv_sizeof_voidp
1664 else
1665     AC_ERROR([Cannot determine size of void*])
1666 fi
1667
1668 dnl Checks for integer size
1669 AC_CHECK_SIZEOF(char, 1)
1670 AC_CHECK_SIZEOF(short, 2)
1671 AC_CHECK_SIZEOF(int, 4)
1672 AC_CHECK_SIZEOF(long, 4)
1673 AC_CHECK_SIZEOF(long long, 8)
1674
1675 if test "$ac_cv_sizeof_short" = "2"; then
1676     short_value=short
1677 fi
1678 if test "$ac_cv_sizeof_int" = "4"; then
1679     int_value=int
1680 fi
1681
1682 # Now we need to find what apr_int64_t (sizeof == 8) will be.
1683 # The first match is our preference (use inttypes if available).
1684 APR_IFALLYES(header:stdint.h header:inttypes.h, hasinttypes="1", hasinttypes="0")
1685 if test "$hasinttypes" = "1"; then
1686     int64_literal='#define APR_INT64_C(val) INT64_C(val)'
1687     uint64_literal='#define APR_UINT64_C(val) UINT64_C(val)'
1688     int64_t_fmt='#define APR_INT64_T_FMT PRId64'
1689     uint64_t_fmt='#define APR_UINT64_T_FMT PRIu64'
1690     uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT PRIx64'
1691     int64_value="int64_t"
1692     uint64_value="uint64_t"
1693     APR_CHECK_TYPES_FMT_COMPATIBLE(int64_t, int, d, [
1694         int64_strfn="strtoi"
1695     ], [
1696     APR_CHECK_TYPES_FMT_COMPATIBLE(int64_t, long, ld, [
1697         int64_strfn="strtol"
1698     ], [
1699     APR_CHECK_TYPES_FMT_COMPATIBLE(int64_t, long long, lld, [
1700         int64_strfn="strtoll"
1701     ], [
1702         AC_ERROR([could not determine the string function for int64_t])
1703     ])])])
1704 elif test "$ac_cv_sizeof_int" = "8"; then
1705     int64_literal='#define APR_INT64_C(val) (val)'
1706     uint64_literal='#define APR_UINT64_C(val) (val##U)'
1707     int64_t_fmt='#define APR_INT64_T_FMT "d"'
1708     uint64_t_fmt='#define APR_UINT64_T_FMT "u"'
1709     uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "x"'
1710     int64_value="int"
1711     uint64_value="unsigned int"
1712     int64_strfn="strtoi"
1713 elif test "$ac_cv_sizeof_long" = "8"; then
1714     int64_literal='#define APR_INT64_C(val) (val##L)'
1715     uint64_literal='#define APR_UINT64_C(val) (val##UL)'
1716     int64_t_fmt='#define APR_INT64_T_FMT "ld"'
1717     uint64_t_fmt='#define APR_UINT64_T_FMT "lu"'
1718     uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "lx"'
1719     int64_value="long"
1720     uint64_value="unsigned long"
1721     int64_strfn="strtol"
1722 elif test "$ac_cv_sizeof_long_long" = "8"; then
1723     int64_literal='#define APR_INT64_C(val) (val##LL)'
1724     uint64_literal='#define APR_UINT64_C(val) (val##ULL)'
1725     # Linux, Solaris, FreeBSD all support ll with printf.
1726     # BSD 4.4 originated 'q'.  Solaris is more popular and
1727     # doesn't support 'q'.  Solaris wins.  Exceptions can
1728     # go to the OS-dependent section.
1729     int64_t_fmt='#define APR_INT64_T_FMT "lld"'
1730     uint64_t_fmt='#define APR_UINT64_T_FMT "llu"'
1731     uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "llx"'
1732     int64_value="long long"
1733     uint64_value="unsigned long long"
1734     int64_strfn="strtoll"
1735 elif test "$ac_cv_sizeof_longlong" = "8"; then
1736     int64_literal='#define APR_INT64_C(val) (val##LL)'
1737     uint64_literal='#define APR_UINT64_C(val) (val##ULL)'
1738     int64_t_fmt='#define APR_INT64_T_FMT "qd"'
1739     uint64_t_fmt='#define APR_UINT64_T_FMT "qu"'
1740     uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "qx"'
1741     int64_value="__int64"
1742     uint64_value="unsigned __int64"
1743     int64_strfn="strtoll"
1744 else
1745     # int64_literal may be overriden if your compiler thinks you have
1746     # a 64-bit value but APR does not agree.
1747     AC_ERROR([could not detect a 64-bit integer type])
1748 fi
1749
1750 # If present, allow the C99 macro INT64_C to override our conversion.
1751 #
1752 # HP-UX's ANSI C compiler provides this without any includes, so we
1753 # will first look for INT64_C without adding stdint.h
1754 AC_CACHE_CHECK([for INT64_C], [apr_cv_define_INT64_C], [
1755 AC_EGREP_CPP(YES_IS_DEFINED,
1756 [#ifdef INT64_C
1757 YES_IS_DEFINED
1758 #endif], [apr_cv_define_INT64_C=yes], [
1759     # Now check for INT64_C in stdint.h
1760     AC_EGREP_CPP(YES_IS_DEFINED, [#include <stdint.h>
1761 #ifdef INT64_C
1762 YES_IS_DEFINED
1763 #endif], [apr_cv_define_INT64_C=yes], [apr_cv_define_INT64_C=no])])])
1764
1765 if test "$apr_cv_define_INT64_C" = "yes"; then
1766     int64_literal='#define APR_INT64_C(val) INT64_C(val)'
1767     uint64_literal='#define APR_UINT64_C(val) UINT64_C(val)'
1768     stdint=1
1769 else
1770     stdint=0
1771 fi
1772
1773 if test "$ac_cv_type_size_t" = "yes"; then
1774     size_t_value="size_t"
1775 else
1776     size_t_value="apr_int32_t"
1777 fi
1778 if test "$ac_cv_type_ssize_t" = "yes"; then
1779     ssize_t_value="ssize_t"
1780 else
1781     ssize_t_value="apr_int32_t"
1782 fi
1783 if test "$ac_cv_socklen_t" = "yes"; then
1784     socklen_t_value="socklen_t"
1785     case $host in
1786         *-hp-hpux*)
1787             if test "$ac_cv_sizeof_long" = "8"; then
1788                 # 64-bit HP-UX requires 32-bit socklens in
1789                 # kernel, but user-space declarations say
1790                 # 64-bit (socklen_t == size_t == long).
1791                 # This will result in many compile warnings,
1792                 # but we're functionally busted otherwise.
1793                 socklen_t_value="int"
1794             fi
1795             ;;
1796     esac
1797 else
1798     socklen_t_value="int"
1799 fi
1800
1801 APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>], pid_t, 8)
1802
1803 if test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_short"; then
1804     pid_t_fmt='#define APR_PID_T_FMT "hd"'
1805 elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_int"; then
1806     pid_t_fmt='#define APR_PID_T_FMT "d"'
1807 elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_long"; then
1808     pid_t_fmt='#define APR_PID_T_FMT "ld"'
1809 elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_long_long"; then
1810     pid_t_fmt='#define APR_PID_T_FMT APR_INT64_T_FMT'
1811 else
1812     pid_t_fmt='#error Can not determine the proper size for pid_t'
1813 fi
1814
1815 # Basically, we have tried to figure out the correct format strings
1816 # for APR types which vary between platforms, but we don't always get
1817 # it right.
1818 case $host in
1819    s390*linux*)
1820        # uniquely, the 31-bit Linux/s390 uses "unsigned long int"
1821        # for size_t rather than "unsigned int":
1822        size_t_fmt="lu"
1823        ssize_t_fmt="ld"
1824        ;;
1825    *-os2*)
1826        size_t_fmt="lu"
1827        ;;
1828    *-solaris*)
1829        if test "$ac_cv_sizeof_long" = "8"; then
1830          pid_t_fmt='#define APR_PID_T_FMT "d"'
1831        else
1832          pid_t_fmt='#define APR_PID_T_FMT "ld"'
1833        fi
1834        ;;
1835    *aix4*|*aix5*)
1836        ssize_t_fmt="ld"
1837        size_t_fmt="lu"
1838        ;;
1839     *beos*)
1840         ssize_t_fmt="ld"
1841         size_t_fmt="ld"
1842         ;;
1843     *apple-darwin*)
1844         osver=`uname -r`
1845         case $osver in
1846            [[0-7]].*)
1847               ssize_t_fmt="d"
1848               ;;
1849            *)
1850               ssize_t_fmt="ld"
1851               ;;
1852         esac
1853         size_t_fmt="lu"
1854         ;;
1855     *-mingw*)
1856         int64_t_fmt='#define APR_INT64_T_FMT "I64d"'
1857         uint64_t_fmt='#define APR_UINT64_T_FMT "I64u"'
1858         uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "I64x"'
1859         int64_value="__int64"
1860         uint64_value="unsigned __int64"
1861         int64_strfn="_strtoi64"
1862         ;;
1863 esac
1864
1865 dnl I would expect much of the above to go away with new compile test
1866 APR_CHECK_TYPES_FMT_COMPATIBLE(ssize_t, long, ld, [ssize_t_fmt="ld"], [
1867 APR_CHECK_TYPES_FMT_COMPATIBLE(ssize_t, int, d, [ssize_t_fmt="d"])
1868 ])
1869 APR_CHECK_TYPES_FMT_COMPATIBLE(size_t, unsigned long, lu, [size_t_fmt="lu"], [
1870 APR_CHECK_TYPES_FMT_COMPATIBLE(size_t, unsigned int, u, [size_t_fmt="u"])
1871 ])
1872
1873 APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>], ssize_t, 8)
1874
1875 dnl the else cases below should no longer occur;
1876 AC_MSG_CHECKING([which format to use for apr_ssize_t])
1877 if test -n "$ssize_t_fmt"; then
1878     AC_MSG_RESULT(%$ssize_t_fmt)
1879 elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_int"; then
1880     ssize_t_fmt="d"
1881     AC_MSG_RESULT(%d)
1882 elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_long"; then
1883     ssize_t_fmt="ld"
1884     AC_MSG_RESULT(%ld)
1885 else
1886     AC_ERROR([could not determine the proper format for apr_ssize_t])
1887 fi
1888
1889 ssize_t_fmt="#define APR_SSIZE_T_FMT \"$ssize_t_fmt\""
1890
1891 APR_CHECK_SIZEOF_EXTENDED([#include <stddef.h>], size_t, 8)
1892
1893 # else cases below should no longer occur;
1894 AC_MSG_CHECKING([which format to use for apr_size_t])
1895 if test -n "$size_t_fmt"; then
1896     AC_MSG_RESULT(%$size_t_fmt)
1897 elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_int"; then
1898     size_t_fmt="d"
1899     AC_MSG_RESULT(%d)
1900 elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_long"; then
1901     size_t_fmt="ld"
1902     AC_MSG_RESULT(%ld)
1903 else
1904     AC_ERROR([could not determine the proper format for apr_size_t])
1905 fi
1906
1907 size_t_fmt="#define APR_SIZE_T_FMT \"$size_t_fmt\""
1908
1909 APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>], off_t, 8)
1910
1911 if test "${ac_cv_sizeof_off_t}${apr_cv_use_lfs64}" = "4yes"; then
1912     # Enable LFS
1913     aprlfs=1
1914     AC_CHECK_FUNCS([mmap64 sendfile64 sendfilev64 readdir64_r])
1915     case $host in
1916         *-hp-hpux*)
1917             dnl mkstemp64 is limited to 26 temporary files (a-z); use APR replacement
1918             ;;
1919         *)
1920             AC_CHECK_FUNCS(mkstemp64)
1921             ;;
1922     esac
1923 elif test "${ac_cv_sizeof_off_t}" != "${ac_cv_sizeof_size_t}"; then
1924     # unsure of using -gt above is as portable, can can't forsee where
1925     # off_t can legitimately be smaller than size_t
1926     aprlfs=1
1927 else
1928     aprlfs=0
1929 fi
1930
1931 AC_MSG_CHECKING([which type to use for apr_off_t])
1932 if test "${ac_cv_sizeof_off_t}${apr_cv_use_lfs64}" = "4yes"; then
1933     # LFS is go!
1934     off_t_fmt='#define APR_OFF_T_FMT APR_INT64_T_FMT'
1935     off_t_value='off64_t'
1936     off_t_strfn='apr_strtoi64'
1937 elif test "${ac_cv_sizeof_off_t}x${ac_cv_sizeof_long}" = "4x4"; then
1938     # Special case: off_t may change size with _FILE_OFFSET_BITS
1939     # on 32-bit systems with LFS support.  To avoid compatibility
1940     # issues when other packages do define _FILE_OFFSET_BITS,
1941     # hard-code apr_off_t to long.
1942     off_t_value=long
1943     off_t_fmt='#define APR_OFF_T_FMT "ld"'
1944     off_t_strfn='strtol'
1945 elif test "$ac_cv_type_off_t" = "yes"; then
1946     # off_t is more commonly a long than an int; prefer that case
1947     # where int and long are the same size and interchangable.
1948     off_t_value=off_t
1949     APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, long, ld, [
1950         off_t_fmt="#define APR_OFF_T_FMT \"ld\""
1951         off_t_strfn='strtol'
1952     ], [
1953     APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, int, d, [
1954         off_t_fmt="#define APR_OFF_T_FMT \"d\""
1955         off_t_strfn='strtoi'
1956     ], [
1957     APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, long long, lld, [
1958         off_t_fmt="#define APR_OFF_T_FMT \"lld\""
1959         off_t_strfn='strtoll'
1960     ], [
1961     APR_CHECK_TYPES_FMT_COMPATIBLE(off_t, $int64_value, I64d, [
1962         off_t_fmt="#define APR_OFF_T_FMT APR_INT64_T_FMT"
1963         off_t_strfn='apr_strtoi64'], [
1964     # Per OS tuning...
1965     case $host in
1966     *-mingw*)
1967         off_t_value=apr_int64_t
1968         off_t_fmt='#define APR_OFF_T_FMT "I64d"'
1969         off_t_strfn='_strtoi64'
1970         ;;
1971     *)
1972         AC_ERROR([could not determine the size of off_t])
1973         ;;
1974     esac
1975     ])])])])
1976 else
1977    # Fallback on int
1978    off_t_value=apr_int32_t
1979    off_t_fmt=d
1980    off_t_strfn='strtoi'
1981 fi
1982 AC_MSG_RESULT($off_t_value)
1983
1984 # Regardless of whether _LARGEFILE64_SOURCE is used, on some
1985 # platforms _FILE_OFFSET_BITS will affect the size of ino_t and hence
1986 # the build-time ABI may be different from the apparent ABI when using
1987 # APR with another package which *does* define _FILE_OFFSET_BITS.
1988 # (Exactly as per the case above with off_t where LFS is *not* used)
1989 #
1990 # To be safe, hard-code apr_ino_t as 'unsigned long' or 'unsigned int'
1991 # iff that is exactly the size of ino_t here; otherwise use ino_t as existing
1992 # releases did.  To be correct, apr_ino_t should have been made an
1993 # ino64_t as apr_off_t is off64_t, but this can't be done now without
1994 # breaking ABI.
1995
1996 # Per OS tuning...
1997 case $host in
1998 *mingw*)
1999     ino_t_value=apr_int64_t
2000     ;;
2001 *)
2002     ino_t_value=ino_t
2003     APR_CHECK_SIZEOF_EXTENDED(AC_INCLUDES_DEFAULT, ino_t, $ac_cv_sizeof_long)
2004     if test $ac_cv_sizeof_ino_t = 4; then
2005         if test $ac_cv_sizeof_long = 4; then
2006             ino_t_value="unsigned long"
2007         else
2008             ino_t_value="unsigned int"
2009         fi
2010     fi
2011     ;;
2012 esac
2013 AC_MSG_NOTICE([using $ino_t_value for ino_t])
2014
2015 # Checks for endianness
2016 AC_C_BIGENDIAN
2017 if test $ac_cv_c_bigendian = yes; then
2018     bigendian=1
2019 else
2020     bigendian=0
2021 fi
2022
2023 APR_CHECK_SIZEOF_EXTENDED([#include <sys/types.h>
2024 #include <sys/uio.h>],struct iovec,0)
2025 if test "$ac_cv_sizeof_struct_iovec" = "0"; then
2026     have_iovec=0
2027 else
2028     have_iovec=1
2029 fi
2030
2031 AC_SUBST(voidp_size)
2032 AC_SUBST(short_value)
2033 AC_SUBST(int_value)
2034 AC_SUBST(int64_value)
2035 AC_SUBST(uint64_value)
2036 AC_SUBST(off_t_value)
2037 AC_SUBST(size_t_value)
2038 AC_SUBST(ssize_t_value)
2039 AC_SUBST(socklen_t_value)
2040 AC_SUBST(int64_t_fmt)
2041 AC_SUBST(uint64_t_fmt)
2042 AC_SUBST(uint64_t_hex_fmt)
2043 AC_SUBST(ssize_t_fmt)
2044 AC_SUBST(size_t_fmt)
2045 AC_SUBST(off_t_fmt)
2046 AC_SUBST(pid_t_fmt)
2047 AC_SUBST(int64_literal)
2048 AC_SUBST(uint64_literal)
2049 AC_SUBST(stdint)
2050 AC_SUBST(bigendian)
2051 AC_SUBST(aprlfs)
2052 AC_SUBST(have_iovec)
2053 AC_SUBST(ino_t_value)
2054
2055 dnl ----------------------------- Checking for string functions
2056 AC_CHECK_FUNCS(strnicmp, have_strnicmp="1", have_strnicmp="0")
2057 AC_CHECK_FUNCS(strncasecmp, have_strncasecmp="1", have_strncasecmp="0")
2058 AC_CHECK_FUNCS(stricmp, have_stricmp="1", have_stricmp="0")
2059 AC_CHECK_FUNCS(strcasecmp, have_strcasecmp="1", have_strcasecmp="0")
2060 AC_CHECK_FUNCS(strdup, have_strdup="1", have_strdup="0")
2061 AC_CHECK_FUNCS(strstr, have_strstr="1", have_strstr="0")
2062 AC_CHECK_FUNCS(memchr, have_memchr="1", have_memchr="0")
2063 AC_CHECK_FUNC($int64_strfn, have_int64_strfn="1", have_int64_strfn="0")
2064
2065 dnl ----------------------------- We have a fallback position
2066 if test "$have_int64_strfn" = "0" && test "$int64_strfn" = "strtoll"; then
2067     int64_strfn="strtoq"
2068     AC_CHECK_FUNC(strtoq, [have_int64_strfn=1], [have_int64_strfn=0])
2069 fi
2070
2071 if test "$have_int64_strfn" = "1"; then
2072   AC_DEFINE_UNQUOTED(APR_INT64_STRFN, [$int64_strfn],
2073       [Define as function which can be used for conversion of strings to apr_int64_t])
2074 fi
2075
2076 AC_SUBST(have_strnicmp)
2077 AC_SUBST(have_strncasecmp)
2078 AC_SUBST(have_stricmp)
2079 AC_SUBST(have_strcasecmp)
2080 AC_SUBST(have_strdup)
2081 AC_SUBST(have_strstr)
2082 AC_SUBST(have_memchr)
2083
2084 if test "$off_t_strfn" = "apr_strtoi64" && test "$have_int64_strfn" = "1"; then
2085     off_t_strfn=$int64_strfn
2086 fi
2087 AC_DEFINE_UNQUOTED(APR_OFF_T_STRFN, [$off_t_strfn],
2088           [Define as function used for conversion of strings to apr_off_t])
2089
2090 dnl ----------------------------- Checking for DSO support
2091 echo "${nl}Checking for DSO..."
2092 AC_ARG_ENABLE(dso,
2093   [  --disable-dso           Disable DSO support ],
2094   [if test "x$enableval" = "xyes"; then
2095       dsotype=any
2096    else
2097       dsotype=$enableval
2098    fi
2099   ], [dsotype=any])
2100
2101 if test "$dsotype" = "any"; then
2102     if test "$dsotype" = "any"; then
2103       case $host in
2104         *darwin[[0-8]]\.*)
2105           # Original Darwin, not for 9.0!:
2106           AC_CHECK_FUNC(NSLinkModule, [dsotype=dyld]);;
2107         hppa*-hpux[[1-9]]\.*|hppa*-hpux1[[01]]*)
2108           # shl is specific to parisc hpux SOM binaries, not used for 64 bit
2109           AC_CHECK_LIB(dld, shl_load, [have_shl=1])
2110           if test "$ac_cv_sizeof_voidp$have_shl" = "41"; then
2111             dsotype=shl; APR_ADDTO(LIBS,-ldld)
2112           fi;;
2113         *mingw*|*-os2*)
2114           # several 'other's below probably belong up here.  If they always
2115           # use a platform implementation and shouldn't test the dlopen/dlfcn
2116           # features, then bring them up here.
2117           # But if they -should- optionally use dlfcn, and/or need the config
2118           # detection of dlopen/dlsym, do not move them up.
2119           dsotype=other ;;
2120       esac
2121     fi
2122     # Normal POSIX:
2123     if test "$dsotype" = "any"; then
2124       AC_CHECK_FUNC(dlopen, [dsotype=dlfcn])
2125     fi
2126     if test "$dsotype" = "any"; then
2127       AC_CHECK_LIB(dl, dlopen, [dsotype=dlfcn; APR_ADDTO(LIBS,-ldl)])
2128     fi
2129     if test "$dsotype" = "dlfcn"; then
2130         # ReliantUnix has dlopen() in libc but dlsym() in libdl :(
2131         AC_CHECK_FUNC(dlsym, [],
2132           [AC_CHECK_LIB(dl, dlsym,
2133              [APR_ADDTO(LIBS, -ldl)],
2134              [dsotype=any
2135               echo "Weird: dlopen() was found but dlsym() was not found!"])])
2136     fi
2137     if test "$dsotype" = "any"; then
2138       # BeOS:
2139       AC_CHECK_LIB(root, load_image, [dsotype=other])
2140     fi
2141     # Everything else:
2142     if test "$dsotype" = "any"; then
2143         case $host in
2144         *os390|*os400|*-aix*)
2145           # Some -aix5 will use dl, no hassles.  Keep that pattern here.
2146           dsotype=other ;;
2147         *-hpux*)
2148           if test "$have_shl" = "1"; then
2149             dsotype=shl; APR_ADDTO(LIBS,-ldld)
2150           fi;;
2151         esac
2152     fi
2153 fi
2154
2155 if test "$dsotype" = "any"; then
2156     AC_MSG_ERROR([Could not detect suitable DSO implementation])
2157 elif test "$dsotype" = "no"; then
2158     aprdso="0"
2159 else
2160     case "$dsotype" in
2161     dlfcn) AC_DEFINE(DSO_USE_DLFCN, 1, [Define if DSO support uses dlfcn.h]);;
2162     shl)   AC_DEFINE(DSO_USE_SHL, 1, [Define if DSO support uses shl_load]);;
2163     dyld)  AC_DEFINE(DSO_USE_DYLD, 1, [Define if DSO support uses dyld.h]);;
2164     other) ;; # Use whatever is in dso/OSDIR
2165     *) AC_MSG_ERROR([Unknown DSO implementation "$dsotype"]);;
2166     esac
2167     aprdso="1"
2168     apr_modules="$apr_modules dso"
2169 fi
2170
2171 AC_SUBST(aprdso)
2172
2173 dnl ----------------------------- Checking for Processes
2174 echo "${nl}Checking for Processes..."
2175
2176 AC_CHECK_FUNCS(waitpid)
2177
2178 AC_ARG_ENABLE(other-child,
2179   [  --enable-other-child    Enable reliable child processes ],
2180   [ if test "$enableval" = "yes"; then
2181         oc="1"
2182     else
2183         oc="0"
2184     fi ],
2185   [ oc=1 ] )
2186
2187 AC_SUBST(oc)
2188
2189 if test -z "$have_proc_invoked"; then
2190   have_proc_invoked="0"
2191 fi
2192
2193 AC_SUBST(have_proc_invoked)
2194
2195 AC_MSG_CHECKING(for Variable Length Arrays)
2196 APR_TRY_COMPILE_NO_WARNING([],
2197 [
2198     int foo[argc];
2199     foo[0] = 0;
2200 ], vla_msg=yes, vla_msg=no )
2201 AC_MSG_RESULT([$vla_msg])
2202 if test "$vla_msg" = "yes"; then
2203     AC_DEFINE(HAVE_VLA, 1, [Define if C compiler supports VLA])
2204 fi
2205
2206 AC_CACHE_CHECK(struct rlimit,ac_cv_struct_rlimit,[
2207 AC_TRY_RUN([
2208 #include <sys/types.h>
2209 #include <sys/time.h>
2210 #include <sys/resource.h>
2211 main()
2212 {
2213     struct rlimit limit;
2214     limit.rlim_cur = 0;
2215     limit.rlim_max = 0;
2216     exit(0);
2217 }], [
2218     ac_cv_struct_rlimit=yes ], [
2219     ac_cv_struct_rlimit=no ], [
2220     ac_cv_struct_rlimit=no ] ) ] )
2221 struct_rlimit=0
2222 test "x$ac_cv_struct_rlimit" = xyes && struct_rlimit=1
2223 AC_SUBST(struct_rlimit)
2224
2225 dnl ----------------------------- Checking for Locking Characteristics
2226 echo "${nl}Checking for Locking..."
2227
2228 AC_CHECK_FUNCS(semget semctl semop semtimedop flock)
2229 APR_IFALLYES(func:semtimedop, have_semtimedop="1", have_semtimedop="0")
2230
2231 AC_CHECK_HEADERS(semaphore.h)
2232 AC_SEARCH_LIBS(sem_open, rt)
2233 AC_CHECK_FUNCS(sem_close sem_unlink sem_post sem_wait sem_timedwait)
2234 APR_IFALLYES(func:sem_timedwait, have_sem_timedwait="1", have_sem_timedwait="0")
2235
2236 AC_CHECK_HEADERS(OS.h)
2237 AC_CHECK_FUNCS(create_sem acquire_sem acquire_sem_etc)
2238 APR_IFALLYES(header:OS.h func:acquire_sem_etc, have_acquire_sem_etc="1", have_acquire_sem_etc="0")
2239
2240 # Some systems return ENOSYS from sem_open.
2241 AC_CACHE_CHECK(for working sem_open,ac_cv_func_sem_open,[
2242 AC_TRY_RUN([
2243 #include <errno.h>
2244 #include <stdlib.h>
2245 #include <fcntl.h>
2246 #include <semaphore.h>
2247 #ifndef SEM_FAILED
2248 #define SEM_FAILED (-1)
2249 #endif
2250 main()
2251 {
2252     sem_t *psem;
2253     const char *sem_name = "/apr_autoconf";
2254
2255     psem = sem_open(sem_name, O_CREAT, 0644, 1);
2256     if (psem == (sem_t *)SEM_FAILED) {
2257         exit(1);
2258     }
2259     sem_close(psem);
2260     psem = sem_open(sem_name, O_CREAT | O_EXCL, 0644, 1);
2261     if (psem != (sem_t *)SEM_FAILED) {
2262         sem_close(psem);
2263         exit(1);
2264     }
2265     sem_unlink(sem_name);
2266     exit(0);
2267 }], [ac_cv_func_sem_open=yes], [ac_cv_func_sem_open=no],
2268 [ac_cv_func_sem_open=no])])
2269
2270 # It's stupid, but not all platforms have union semun, even those that need it.
2271 AC_MSG_CHECKING(for union semun in sys/sem.h)
2272 AC_TRY_COMPILE([
2273 #include <sys/types.h>
2274 #include <sys/ipc.h>
2275 #include <sys/sem.h>
2276 ],[
2277 union semun arg;
2278 semctl(0, 0, 0, arg);
2279 ], [have_union_semun="1" union_semun=yes ]
2280 msg=yes, [
2281 have_union_semun="0"
2282 msg=no ] )
2283 AC_MSG_RESULT([$msg])
2284 AC_SUBST(have_union_semun)
2285
2286 dnl Checks for libraries.
2287 APR_CHECK_DEFINE(LOCK_EX, sys/file.h)
2288 APR_CHECK_DEFINE(F_SETLK, fcntl.h)
2289 APR_CHECK_DEFINE(SEM_UNDO, sys/sem.h)
2290
2291 # We are assuming that if the platform doesn't have POLLIN, it doesn't have
2292 # any POLL definitions.
2293 APR_CHECK_DEFINE_FILES(POLLIN, poll.h sys/poll.h)
2294
2295 if test "$threads" = "1"; then
2296     APR_CHECK_DEFINE(PTHREAD_PROCESS_SHARED, pthread.h)
2297     AC_CHECK_FUNCS(pthread_mutex_timedlock pthread_mutexattr_setpshared)
2298     APR_IFALLYES(header:pthread.h func:pthread_mutex_timedlock,
2299                  have_pthread_mutex_timedlock="1", have_pthread_mutex_timedlock="0")
2300     AC_SUBST(have_pthread_mutex_timedlock)
2301     # Some systems have setpshared and define PROCESS_SHARED, but don't
2302     # really support PROCESS_SHARED locks.  So, we must validate that we
2303     # can go through the steps without receiving some sort of system error.
2304     # Linux and older versions of AIX have this problem.
2305     APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED func:pthread_mutexattr_setpshared, [
2306       AC_CACHE_CHECK([for working PROCESS_SHARED locks], apr_cv_process_shared_works, [
2307       AC_TRY_RUN([
2308 #include <sys/types.h>
2309 #include <pthread.h>
2310         int main()
2311         {
2312             pthread_mutex_t mutex;
2313             pthread_mutexattr_t attr;
2314             if (pthread_mutexattr_init(&attr))
2315                 exit(1);
2316             if (pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED))
2317                 exit(2);
2318             if (pthread_mutex_init(&mutex, &attr))
2319                 exit(3);
2320             if (pthread_mutexattr_destroy(&attr))
2321                 exit(4);
2322             if (pthread_mutex_destroy(&mutex))
2323                 exit(5);
2324             exit(0);
2325         }], [apr_cv_process_shared_works=yes], [apr_cv_process_shared_works=no])])
2326       # Override detection of pthread_mutexattr_setpshared
2327       ac_cv_func_pthread_mutexattr_setpshared=$apr_cv_process_shared_works])
2328
2329     if test "$ac_cv_func_pthread_mutexattr_setpshared" = "yes"; then
2330         APR_CHECK_PTHREAD_ROBUST_SHARED_MUTEX
2331     fi
2332 fi
2333
2334 # See which lock mechanisms we can support on this system.
2335 APR_IFALLYES(header:semaphore.h func:sem_open func:sem_close dnl
2336              func:sem_unlink func:sem_post func:sem_wait,
2337              hasposixser="1", hasposixser="0")
2338 APR_IFALLYES(func:semget func:semctl func:semop define:SEM_UNDO,
2339              hassysvser="1", hassysvser="0")
2340 APR_IFALLYES(func:flock define:LOCK_EX, hasflockser="1", hasflockser="0")
2341 APR_IFALLYES(header:fcntl.h define:F_SETLK, hasfcntlser="1", hasfcntlser="0")
2342 # note: the current APR use of shared mutex requires /dev/zero
2343 APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED dnl
2344              func:pthread_mutexattr_setpshared dnl
2345              file:/dev/zero,
2346              hasprocpthreadser="1", hasprocpthreadser="0")
2347 APR_IFALLYES(header:OS.h func:create_sem, hasbeossem="1", hasbeossem="0")
2348
2349 AC_CHECK_FUNCS(pthread_condattr_setpshared)
2350 APR_IFALLYES(header:pthread.h func:pthread_condattr_setpshared,
2351              have_pthread_condattr_setpshared="1", have_pthread_condattr_setpshared="0")
2352 AC_SUBST(have_pthread_condattr_setpshared)
2353
2354 # See which lock mechanism we'll select by default on this system.
2355 # The last APR_DECIDE to execute sets the default.
2356 # At this stage, we match the ordering in Apache 1.3
2357 # which is (highest to lowest): sysvsem -> fcntl -> flock.
2358 # POSIX semaphores and cross-process pthread mutexes are not
2359 # used by default since they have less desirable behaviour when
2360 # e.g. a process holding the mutex segfaults.
2361 # The BEOSSEM decision doesn't require any substitutions but is
2362 # included here to prevent the fcntl() branch being selected
2363 # from the decision making.
2364 APR_BEGIN_DECISION([apr_lock implementation method])
2365 APR_IFALLYES(func:flock define:LOCK_EX,
2366             APR_DECIDE(USE_FLOCK_SERIALIZE, [4.2BSD-style flock()]))
2367 APR_IFALLYES(header:fcntl.h define:F_SETLK,
2368             APR_DECIDE(USE_FCNTL_SERIALIZE, [SVR4-style fcntl()]))
2369 APR_IFALLYES(func:semget func:semctl func:semop define:SEM_UNDO,
2370             APR_DECIDE(USE_SYSVSEM_SERIALIZE, [SysV IPC semget()]))
2371 APR_IFALLYES(header:OS.h func:create_sem func:acquire_sem func:acquire_sem_etc,
2372             APR_DECIDE(USE_BEOSSEM, [BeOS Semaphores]))
2373 # pthread mutex both pshared and robust[_np] is the best default
2374 case "$apr_cv_mutex_robust_shared" in
2375 "yes"|"np")
2376     APR_DECIDE(USE_PROC_PTHREAD_SERIALIZE, [pthread pshared mutex])
2377     ;;
2378 *)
2379     ;;
2380 esac
2381 if test "x$apr_lock_method" != "x"; then
2382     APR_DECISION_FORCE($apr_lock_method)
2383 fi
2384 APR_END_DECISION
2385 AC_DEFINE_UNQUOTED($ac_decision)
2386
2387 flockser="0"
2388 sysvser="0"
2389 posixser="0"
2390 procpthreadser="0"
2391 fcntlser="0"
2392 case $ac_decision in
2393     USE_FLOCK_SERIALIZE )
2394         flockser="1"
2395         ;;
2396     USE_FCNTL_SERIALIZE )
2397         fcntlser="1"
2398         ;;
2399     USE_SYSVSEM_SERIALIZE )
2400         sysvser="1"
2401         ;;
2402     USE_POSIXSEM_SERIALIZE )
2403         posixser="1"
2404         ;;
2405     USE_PROC_PTHREAD_SERIALIZE )
2406         procpthreadser="1"
2407         ;;
2408     USE_BEOSSEM )
2409         beossem="1"
2410         ;;
2411 esac
2412
2413 if test $hasfcntlser = "1"; then
2414 AC_MSG_CHECKING(if fcntl returns EACCES when F_SETLK is already held)
2415 AC_TRY_RUN([
2416 #ifdef HAVE_STDLIB_H
2417 #include <stdlib.h>
2418 #endif
2419 #ifdef HAVE_SYS_TYPES_H
2420 #include <sys/types.h>
2421 #endif
2422 #ifdef HAVE_SYS_STAT_H
2423 #include <sys/stat.h>
2424 #endif
2425 #ifdef HAVE_SYS_WAIT_H
2426 #include <sys/wait.h>
2427 #endif
2428 #if defined(HAVE_UNISTD_H)
2429 #include <unistd.h>
2430 #endif
2431 #include <fcntl.h>
2432 #include <errno.h>
2433
2434 int fd;
2435 struct flock proc_mutex_lock_it = {0};
2436 const char *fname = "conftest.fcntl";
2437
2438 int main()
2439 {
2440     int rc, status;;
2441     proc_mutex_lock_it.l_whence = SEEK_SET;   /* from current point */
2442     proc_mutex_lock_it.l_type = F_WRLCK;      /* set exclusive/write lock */
2443
2444     fd = creat(fname, S_IRWXU);
2445     unlink(fname);
2446
2447     if (rc = lockit()) {
2448         exit(-1);
2449     }
2450
2451     if (fork()) {
2452         wait(&status);
2453     }
2454     else {
2455       return(lockit());
2456     }
2457
2458     close(fd);
2459     exit(WEXITSTATUS(status) != EACCES);
2460 }
2461
2462 int lockit() {
2463     int rc;
2464     do {
2465         rc = fcntl(fd, F_SETLK, &proc_mutex_lock_it);
2466     } while ( rc < 0 && errno == EINTR);
2467
2468     return (rc < 0) ? errno : 0;
2469 }], [apr_fcntl_tryacquire_eacces=1], [apr_fcntl_tryacquire_eacces=0], [apr_fcntl_tryacquire_eacces=0])
2470 fi
2471
2472 if test "$apr_fcntl_tryacquire_eacces" = "1"; then
2473   AC_DEFINE(FCNTL_TRYACQUIRE_EACCES, 1, [Define if fcntl returns EACCES when F_SETLK is already held])
2474   AC_MSG_RESULT(yes)
2475 else
2476   AC_MSG_RESULT(no)
2477 fi
2478
2479
2480 AC_SUBST(hasflockser)
2481 AC_SUBST(hassysvser)
2482 AC_SUBST(hasposixser)
2483 AC_SUBST(hasfcntlser)
2484 AC_SUBST(hasprocpthreadser)
2485 AC_SUBST(flockser)
2486 AC_SUBST(sysvser)
2487 AC_SUBST(posixser)
2488 AC_SUBST(fcntlser)
2489 AC_SUBST(procpthreadser)
2490 AC_SUBST(pthreadser)
2491
2492 AC_MSG_CHECKING(if all interprocess locks affect threads)
2493 if test "x$apr_process_lock_is_global" = "xyes"; then
2494     proclockglobal="1"
2495     AC_MSG_RESULT(yes)
2496 else
2497     proclockglobal="0"
2498     AC_MSG_RESULT(no)
2499 fi
2500
2501 AC_SUBST(proclockglobal)
2502
2503 AC_MSG_CHECKING(if POSIX sems affect threads in the same process)
2504 if test "x$apr_posixsem_is_global" = "xyes"; then
2505   AC_DEFINE(POSIXSEM_IS_GLOBAL, 1,
2506             [Define if POSIX semaphores affect threads within the process])
2507   AC_MSG_RESULT(yes)
2508 else
2509   AC_MSG_RESULT(no)
2510 fi
2511
2512 AC_MSG_CHECKING(if SysV sems affect threads in the same process)
2513 if test "x$apr_sysvsem_is_global" = "xyes"; then
2514   AC_DEFINE(SYSVSEM_IS_GLOBAL, 1,
2515             [Define if SysV semaphores affect threads within the process])
2516   AC_MSG_RESULT(yes)
2517 else
2518   AC_MSG_RESULT(no)
2519 fi
2520
2521 AC_MSG_CHECKING(if fcntl locks affect threads in the same process)
2522 if test "x$apr_fcntl_is_global" = "xyes"; then
2523   AC_DEFINE(FCNTL_IS_GLOBAL, 1,
2524             [Define if fcntl locks affect threads within the process])
2525   AC_MSG_RESULT(yes)
2526 else
2527   AC_MSG_RESULT(no)
2528 fi
2529
2530 AC_MSG_CHECKING(if flock locks affect threads in the same process)
2531 if test "x$apr_flock_is_global" = "xyes"; then
2532   AC_DEFINE(FLOCK_IS_GLOBAL, 1,
2533             [Define if flock locks affect threads within the process])
2534   AC_MSG_RESULT(yes)
2535 else
2536   AC_MSG_RESULT(no)
2537 fi
2538
2539 dnl ----------------------------- Checking for /dev/random
2540 AC_CHECK_HEADERS(sys/random.h)
2541 AC_CHECK_FUNCS(getrandom)
2542
2543 AC_CHECK_HEADERS(sys/syscall.h)
2544 AC_CHECK_HEADERS(linux/random.h)
2545 AC_CHECK_DECLS([SYS_getrandom], [], [], [#include <sys/syscall.h>])
2546
2547 AC_CHECK_FUNCS(arc4random_buf)
2548
2549 AC_MSG_CHECKING(for entropy source)
2550
2551 why_no_rand=""
2552
2553 AC_ARG_WITH(egd,
2554   [  --with-egd[[=DIR]]        use EGD-compatible socket],
2555   [ AC_DEFINE(HAVE_EGD, 1, [Define if EGD is supported])
2556     if test "$withval" = "yes"; then
2557         AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["/var/run/egd-pool","/dev/egd-pool","/etc/egd-pool","/etc/entropy"],
2558          [Define to list of paths to EGD sockets])
2559     else
2560         AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["$withval"])
2561     fi
2562     AC_MSG_RESULT(EGD-compatible daemon)
2563     rand="1"
2564   ])
2565
2566 if test "$rand" != "1"; then
2567   if test "$ac_cv_func_getrandom" = yes; then
2568     rand="getrandom"
2569   elif test "$ac_cv_have_decl_SYS_getrandom" = yes; then
2570     rand="SYS_getrandom"
2571   elif test "$ac_cv_func_arc4random_buf" = yes; then
2572     rand="arc4random"
2573   fi
2574 fi
2575
2576 if test "$rand" != "1"; then
2577   AC_ARG_WITH(devrandom,
2578     [  --with-devrandom[[=DEV]]  use /dev/random or compatible [[searches by default]]],
2579     [ apr_devrandom="$withval" ], [ apr_devrandom="no" ])
2580   if test "$apr_devrandom" = "no"; then
2581     if test -z "$rand"; then
2582       apr_devrandom="yes"
2583     else
2584       apr_devrandom="no"
2585     fi
2586   fi
2587
2588   if test "$apr_devrandom" = "yes"; then
2589     # /dev/random on OpenBSD doesn't provide random data, so
2590     # prefer /dev/arandom, which does; see random(4).
2591     for f in /dev/arandom /dev/urandom /dev/random; do
2592       if test -r $f; then
2593         apr_devrandom=$f
2594         rand="1"
2595         break
2596       fi
2597     done
2598   elif test "$apr_devrandom" != "no"; then
2599     if test -r "$apr_devrandom"; then
2600       rand="1"
2601     else
2602       AC_ERROR([$apr_devrandom not found or unreadable.])
2603     fi
2604   fi
2605
2606   if test "$rand" = "1"; then
2607     case $host in
2608       *os390)
2609         if test $os_version -lt 1700; then
2610           rand="0"
2611           why_no_rand=" ($apr_devrandom unusable on z/OS before V1R7)"
2612         fi
2613         ;;
2614     esac
2615   fi
2616
2617   if test "$rand" = "1"; then
2618     AC_DEFINE_UNQUOTED(DEV_RANDOM, ["$apr_devrandom"], [Define to path of random device])
2619     AC_MSG_RESULT([$apr_devrandom])
2620   elif test -n "$rand"; then
2621     AC_DEFINE_UNQUOTED(SYS_RANDOM, ["$rand"], [Define system call of random])
2622     AC_MSG_RESULT([$rand])
2623     rand="1"
2624   fi
2625 fi
2626
2627 if test "$rand" != "1"; then
2628     case $host in
2629         # we have built in support for OS/2
2630         *-os2*)
2631             AC_MSG_RESULT([Using OS/2 builtin random])
2632             rand="1"
2633             ;;
2634         *)
2635             if test "$rand" != "1"; then
2636               if test "$ac_cv_lib_truerand_main" = "yes"; then
2637                 AC_DEFINE(HAVE_TRUERAND, 1, [Define if truerand is supported])
2638                 AC_MSG_RESULT(truerand)
2639                 rand="1"
2640               else
2641                 AC_MSG_RESULT(not found$why_no_rand)
2642                 rand="0"
2643               fi
2644             fi
2645             ;;
2646     esac
2647 fi
2648
2649 AC_SUBST(rand)
2650
2651 dnl ----------------------------- Checking for File Info Support
2652 echo "${nl}Checking for File Info Support..."
2653 AC_CHECK_MEMBERS([struct stat.st_blocks, struct stat.st_atimensec,
2654 struct stat.st_ctimensec, struct stat.st_mtimensec, struct stat.st_atim.tv_nsec,
2655 struct stat.st_ctim.tv_nsec, struct stat.st_mtim.tv_nsec,
2656 struct stat.st_atime_n, struct stat.st_ctime_n, struct stat.st_mtime_n],,,[
2657 #ifdef HAVE_SYS_TYPES_H
2658 #include <sys/types.h>
2659 #endif
2660 #ifdef HAVE_SYS_STAT_H
2661 #include <sys/stat.h>
2662 #endif
2663 #ifdef HAVE_UNISTD_H
2664 #include <unistd.h>
2665 #endif])
2666
2667 APR_CHECK_DIRENT_INODE
2668 APR_CHECK_DIRENT_TYPE
2669
2670 dnl ----------------------------- Checking for UUID Support
2671 echo "${nl}Checking for OS UUID Support..."
2672
2673 AC_CHECK_HEADERS(uuid.h uuid/uuid.h sys/uuid.h, break)
2674
2675 apr_revert_save_LIBS=$LIBS
2676
2677 # Prefer the flavor(s) that live in libc;
2678 AC_SEARCH_LIBS(uuid_create, uuid)
2679 AC_SEARCH_LIBS(uuid_generate, uuid)
2680 if test "$ac_cv_search_uuid_create" = "none required" -o \
2681         "$ac_cv_search_uuid_generate" = "none required"; then
2682  LIBS=$apr_revert_save_LIBS
2683 fi
2684
2685 AC_CHECK_FUNCS(uuid_create uuid_generate)
2686
2687 AC_CACHE_CHECK([for os uuid usability], [apr_cv_osuuid], [
2688 # Ensure this test closely mirrors misc/unix/rand.c!
2689 uuid_includes="
2690 #if defined(HAVE_SYS_TYPES_H)
2691 #include <sys/types.h>
2692 #endif
2693 #if defined(HAVE_UNISTD_H)
2694 #include <unistd.h>
2695 #endif
2696 #if defined(HAVE_UUID_H)
2697 #include <uuid.h>
2698 #elif defined(HAVE_UUID_UUID_H)
2699 #include <uuid/uuid.h>
2700 #elif defined(HAVE_SYS_UUID_H)
2701 #include <sys/uuid.h>
2702 #endif
2703 "
2704  apr_cv_osuuid=no
2705  if test $ac_cv_func_uuid_create = yes; then
2706   AC_TRY_LINK([$uuid_includes], [
2707     uuid_t g;
2708     uint32_t s;
2709     uuid_create(&g, &s);
2710     if (s == uuid_s_ok) s = 0;
2711   ], [apr_cv_osuuid=yes], [apr_cv_func_uuid_create=no])
2712  fi
2713  if test $ac_cv_func_uuid_generate = yes; then
2714   AC_TRY_LINK([$uuid_includes], [
2715     uuid_t g;
2716     uuid_generate(g);
2717   ], [apr_cv_osuuid=yes], [apr_cv_func_uuid_generate=no])
2718  fi
2719 ])
2720
2721 if test $apr_cv_osuuid = yes; then
2722   osuuid="1"
2723 else
2724   osuuid="0"
2725   LIBS=$apr_revert_save_LIBS
2726 fi
2727 AC_SUBST(osuuid)
2728
2729
2730 dnl ----------------------------- Checking for Time Support
2731 echo "${nl}Checking for Time Support..."
2732
2733 AC_CHECK_MEMBERS([struct tm.tm_gmtoff, struct tm.__tm_gmtoff],,,[
2734 #include <sys/types.h>
2735 #include <time.h>])
2736
2737 dnl ----------------------------- Checking for Networking Support
2738 echo "${nl}Checking for Networking support..."
2739 APR_TYPE_IN_ADDR
2740 if test "$ac_cv_type_in_addr" = "yes"; then
2741   have_in_addr="1"
2742 else
2743   have_in_addr="0"
2744 fi
2745
2746 AC_MSG_CHECKING([if fd == socket on this platform])
2747 if test "x$file_as_socket" != "x0" ; then
2748     file_as_socket="1";
2749     echo "yes"
2750 else
2751     echo "no"
2752 fi
2753
2754 AC_SUBST(have_in_addr)
2755 AC_SUBST(file_as_socket)
2756
2757 if test "$ac_cv_func_poll $file_as_socket" = "yes 1"; then
2758     AC_DEFINE(WAITIO_USES_POLL, 1,
2759               [Define if apr_wait_for_io_or_timeout() uses poll(2)])
2760 fi
2761
2762 # Check the types only if we have gethostbyname_r
2763 if test "$ac_cv_func_gethostbyname_r" = "yes"; then
2764     APR_CHECK_GETHOSTBYNAME_R_STYLE
2765 fi
2766
2767 # Check the types only if we have getservbyname_r
2768 if test "$ac_cv_func_getservbyname_r" = "yes"; then
2769     APR_CHECK_GETSERVBYNAME_R_STYLE
2770 fi
2771
2772 APR_CHECK_TCP_NODELAY_INHERITED
2773 APR_CHECK_O_NONBLOCK_INHERITED
2774 APR_CHECK_TCP_NODELAY_WITH_CORK
2775
2776 # Look for a way of corking TCP...
2777 APR_CHECK_DEFINE(TCP_CORK, netinet/tcp.h)
2778 APR_CHECK_DEFINE(TCP_NOPUSH, netinet/tcp.h)
2779 apr_tcp_nopush_flag="0"
2780 have_corkable_tcp="0"
2781 if test "x$ac_cv_define_TCP_CORK" = "xyes"; then
2782     apr_tcp_nopush_flag="TCP_CORK"
2783     have_corkable_tcp="1"
2784 else
2785     case $host in
2786         *linux*)
2787             AC_EGREP_CPP(yes,[
2788 #include <linux/socket.h>
2789 #ifdef TCP_CORK
2790 yes
2791 #endif
2792             ],[
2793                 apr_tcp_nopush_flag="3"
2794                 have_corkable_tcp="1"
2795             ])
2796             ;;
2797         *)
2798             ;;
2799     esac
2800 fi
2801 if test "x$ac_cv_define_TCP_NOPUSH" = "xyes"; then
2802     apr_tcp_nopush_flag="TCP_NOPUSH"
2803     have_corkable_tcp="1"
2804 fi
2805
2806 APR_CHECK_DEFINE(SO_ACCEPTFILTER, sys/socket.h)
2807 if test "x$ac_cv_define_SO_ACCEPTFILTER" = "xyes"; then
2808     acceptfilter="1"
2809 else
2810     acceptfilter="0"
2811 fi
2812
2813 APR_CHECK_SCTP
2814 APR_CHECK_MCAST
2815
2816 AC_SUBST(apr_tcp_nopush_flag)
2817 AC_SUBST(have_corkable_tcp)
2818 AC_SUBST(acceptfilter)
2819 AC_SUBST(have_sctp)
2820
2821 AC_CHECK_FUNCS(set_h_errno)
2822
2823 echo "${nl}Checking for IPv6 Networking support..."
2824 dnl Start of checking for IPv6 support...
2825
2826 AC_ARG_ENABLE(ipv6,
2827   [  --disable-ipv6          Disable IPv6 support in APR.],
2828   [ if test "$enableval" = "no"; then
2829         user_disabled_ipv6=1
2830     fi ],
2831   [ user_disabled_ipv6=0 ] )
2832
2833 case $host in
2834   *)
2835     broken_ipv6=0
2836 esac
2837
2838 AC_SEARCH_LIBS(getaddrinfo, socket inet6)
2839 AC_SEARCH_LIBS(gai_strerror, socket inet6)
2840 AC_SEARCH_LIBS(getnameinfo, socket inet6)
2841 AC_CHECK_FUNCS(gai_strerror if_nametoindex if_indextoname)
2842 APR_CHECK_WORKING_GETADDRINFO
2843 APR_CHECK_NEGATIVE_EAI
2844 APR_CHECK_WORKING_GETNAMEINFO
2845 APR_CHECK_SOCKADDR_IN6
2846 APR_CHECK_SOCKADDR_STORAGE
2847 APR_CHECK_SOCKADDR_UN
2848
2849 have_ipv6="0"
2850 if test "$user_disabled_ipv6" = 1; then
2851     ipv6_result="no -- disabled by user"
2852 else
2853     if test "x$broken_ipv6" = "x0"; then
2854         if test "x$have_sockaddr_in6" = "x1"; then
2855             if test "x$ac_cv_working_getaddrinfo" = "xyes"; then
2856                 if test "x$ac_cv_working_getnameinfo" = "xyes"; then
2857                     APR_CHECK_GETADDRINFO_ADDRCONFIG
2858                     have_ipv6="1"
2859                     ipv6_result="yes"
2860                 else
2861                     ipv6_result="no -- no getnameinfo"
2862                 fi
2863             else
2864                 ipv6_result="no -- no working getaddrinfo"
2865             fi
2866         else
2867             ipv6_result="no -- no sockaddr_in6"
2868         fi
2869     else
2870         ipv6_result="no -- the platform has known problems supporting IPv6"
2871     fi
2872 fi
2873
2874 AC_MSG_CHECKING(if APR supports IPv6)
2875 AC_MSG_RESULT($ipv6_result)
2876
2877 AC_SUBST(have_ipv6)
2878
2879 AC_ARG_ENABLE(timedlocks,
2880   [  --disable-timedlocks         Disable timed locks ],
2881   [apr_has_timedlocks="0"], [apr_has_timedlocks="1"]
2882 )
2883 AC_SUBST(apr_has_timedlocks)
2884
2885 # hstrerror is only needed if IPv6 is not enabled,
2886 # so getaddrinfo/gai_strerror are not used.
2887 if test $have_ipv6 = 0; then
2888   AC_SEARCH_LIBS(hstrerror, resolv,
2889     [AC_DEFINE(HAVE_HSTRERROR, 1, [Define if hstrerror is present])])
2890 fi
2891
2892 dnl Check for langinfo support
2893
2894 AC_CHECK_HEADERS(langinfo.h)
2895 AC_CHECK_FUNCS(nl_langinfo)
2896
2897 dnl ------------------------------ Defaults for some platform nuances
2898
2899 dnl Do we have a Win32-centric Unicode FS?
2900 APR_SETIFNULL(have_unicode_fs, [0])
2901 AC_SUBST(have_unicode_fs)
2902
2903 APR_SETIFNULL(apr_has_xthread_files, [0])
2904 AC_SUBST(apr_has_xthread_files)
2905
2906 APR_SETIFNULL(apr_procattr_user_set_requires_password, [0])
2907 AC_SUBST(apr_procattr_user_set_requires_password)
2908
2909 APR_SETIFNULL(apr_thread_func, [])
2910 AC_SUBST(apr_thread_func)
2911
2912 APR_SETIFNULL(apr_has_user, [1])
2913 AC_SUBST(apr_has_user)
2914
2915 dnl ----------------------------- Finalize the variables
2916
2917 echo "${nl}Restore user-defined environment settings..."
2918
2919 APR_RESTORE_THE_ENVIRONMENT(CPPFLAGS, EXTRA_)
2920 APR_RESTORE_THE_ENVIRONMENT(CFLAGS, EXTRA_)
2921 APR_RESTORE_THE_ENVIRONMENT(LDFLAGS, EXTRA_)
2922 APR_RESTORE_THE_ENVIRONMENT(LIBS, EXTRA_)
2923 APR_RESTORE_THE_ENVIRONMENT(INCLUDES, EXTRA_)
2924 AC_SUBST(NOTEST_CPPFLAGS)
2925 AC_SUBST(NOTEST_CFLAGS)
2926 AC_SUBST(NOTEST_LDFLAGS)
2927 AC_SUBST(NOTEST_LIBS)
2928 AC_SUBST(NOTEST_INCLUDES)
2929
2930 dnl ----------------------------- Construct the files
2931
2932 AC_SUBST(INTERNAL_CPPFLAGS)
2933 AC_SUBST(LDLIBS)
2934 AC_SUBST(INCLUDES)
2935 AC_SUBST(AR)
2936 AC_SUBST(RM)
2937 AC_SUBST(OSDIR)
2938 AC_SUBST(DEFAULT_OSDIR)
2939 AC_SUBST(EXEEXT)
2940 AC_SUBST(LIBTOOL_LIBS)
2941
2942 # Use -no-install or -no-fast-install to link the test
2943 # programs on all platforms but Darwin, where it would cause
2944 # the programs to be linked against installed versions of
2945 # libapr instead of those just built.
2946 case $host in
2947     *-apple-darwin*)
2948         LT_NO_INSTALL=""
2949         ;;
2950     *-mingw*)
2951         LT_NO_INSTALL="-no-fast-install"
2952         ;;
2953     *)
2954         LT_NO_INSTALL="-no-install"
2955         ;;
2956 esac
2957 AC_SUBST(LT_NO_INSTALL)
2958
2959 #
2960 # BSD/OS (BSDi) needs to use a different include syntax in the Makefiles
2961 #
2962 case $host in
2963 *bsdi*)
2964     # Check whether they've installed GNU make
2965     if make --version > /dev/null 2>&1; then
2966         INCLUDE_RULES="include $apr_buildout/apr_rules.mk"
2967         INCLUDE_OUTPUTS="include $apr_srcdir/build-outputs.mk"
2968     else
2969         # BSDi make
2970         INCLUDE_RULES=".include \"$apr_buildout/apr_rules.mk\""
2971         INCLUDE_OUTPUTS=".include \"$apr_srcdir/build-outputs.mk\""
2972     fi
2973     ;;
2974 *)
2975     INCLUDE_RULES="include $apr_buildout/apr_rules.mk"
2976     INCLUDE_OUTPUTS="include $apr_srcdir/build-outputs.mk"
2977     ;;
2978 esac
2979 AC_SUBST(INCLUDE_RULES)
2980 AC_SUBST(INCLUDE_OUTPUTS)
2981
2982 AC_CONFIG_FILES([Makefile
2983                  include/apr.h
2984                  build/apr_rules.mk
2985                  build/pkg/pkginfo
2986                  apr-$APR_MAJOR_VERSION-config:apr-config.in
2987                  apr.pc])
2988
2989 if test -d $srcdir/test; then
2990    AC_CONFIG_FILES([test/Makefile test/internal/Makefile])
2991 fi
2992
2993 dir=include/arch/unix
2994 test -d $dir || $MKDIR $dir
2995
2996 AC_CONFIG_COMMANDS([default], [
2997 # Commands run at the end of config.status:
2998 for i in $APR_SAVE_HEADERS; do
2999   if cmp -s $i $i.save 2>/dev/null; then
3000     mv $i.save $i
3001     AC_MSG_NOTICE([$i is unchanged])
3002   fi
3003   rm -f $i.save
3004 done
3005 chmod +x apr-$APR_MAJOR_VERSION-config
3006 ],[
3007 dnl This section is expanded by configure UNQUOTED so variable
3008 dnl references must be backslash-escaped as necessary.
3009
3010 # Commands run at the beginning of config.status:
3011 APR_SAVE_HEADERS="include/apr.h include/arch/unix/apr_private.h"
3012 APR_MAJOR_VERSION=$APR_MAJOR_VERSION
3013 APR_PLATFORM=$host
3014
3015 for apri in \${APR_SAVE_HEADERS}; do
3016   test -r \${apri} && mv \${apri} \${apri}.save
3017 done
3018 ])
3019
3020 AC_OUTPUT