configure.in

AC_SUBST(off_t_fmt) 
AC_SUBST(pid_t_fmt)
AC_SUBST(int64_literal) 
AC_SUBST(uint64_literal) 
AC_SUBST(stdint) 
AC_SUBST(bigendian)
AC_SUBST(aprlfs)
AC_SUBST(have_iovec)
AC_SUBST(ino_t_value)

dnl ----------------------------- Checking for string functions
AC_CHECK_FUNCS(strnicmp, have_strnicmp="1", have_strnicmp="0")
AC_CHECK_FUNCS(strncasecmp, have_strncasecmp="1", have_strncasecmp="0")
AC_CHECK_FUNCS(stricmp, have_stricmp="1", have_stricmp="0")
AC_CHECK_FUNCS(strcasecmp, have_strcasecmp="1", have_strcasecmp="0")
AC_CHECK_FUNCS(strdup, have_strdup="1", have_strdup="0")
AC_CHECK_FUNCS(strstr, have_strstr="1", have_strstr="0")
AC_CHECK_FUNCS(memchr, have_memchr="1", have_memchr="0")
AC_CHECK_FUNC($int64_strfn, have_int64_strfn="1", have_int64_strfn="0")

dnl ----------------------------- We have a fallback position
if test "$have_int64_strfn" = "0" && test "$int64_strfn" = "strtoll"; then
    int64_strfn="strtoq"
    AC_CHECK_FUNC(strtoq, [have_int64_strfn=1], [have_int64_strfn=0])
fi

if test "$have_int64_strfn" = "1"; then
  AC_DEFINE_UNQUOTED(APR_INT64_STRFN, [$int64_strfn],
      [Define as function which can be used for conversion of strings to apr_int64_t])
fi

AC_SUBST(have_strnicmp)
AC_SUBST(have_strncasecmp)
AC_SUBST(have_stricmp)
AC_SUBST(have_strcasecmp)
AC_SUBST(have_strdup)
AC_SUBST(have_strstr)
AC_SUBST(have_memchr)

if test "$off_t_strfn" = "apr_strtoi64" && test "$have_int64_strfn" = "1"; then
    off_t_strfn=$int64_strfn
fi
AC_DEFINE_UNQUOTED(APR_OFF_T_STRFN, [$off_t_strfn],
          [Define as function used for conversion of strings to apr_off_t])

dnl ----------------------------- Checking for DSO support
echo "${nl}Checking for DSO..."
AC_ARG_ENABLE(dso,
  [  --disable-dso           Disable DSO support ],
  [if test "x$enableval" = "xyes"; then
      dsotype=any
   else
      dsotype=$enableval
   fi
  ], [dsotype=any])

if test "$dsotype" = "any"; then
    if test "$dsotype" = "any"; then
      case $host in
        *darwin[[0-8]]\.*) 
          # Original Darwin, not for 9.0!:
          AC_CHECK_FUNC(NSLinkModule, [dsotype=dyld]);;
        hppa*-hpux[[1-9]]\.*|hppa*-hpux1[[01]]*)
          # shl is specific to parisc hpux SOM binaries, not used for 64 bit
          AC_CHECK_LIB(dld, shl_load, [have_shl=1])
          if test "$ac_cv_sizeof_voidp$have_shl" = "41"; then
            dsotype=shl; APR_ADDTO(LIBS,-ldld)
          fi;;
        *mingw*|*-os2*)
          # several 'other's below probably belong up here.  If they always
          # use a platform implementation and shouldn't test the dlopen/dlfcn
          # features, then bring them up here.
          # But if they -should- optionally use dlfcn, and/or need the config
          # detection of dlopen/dlsym, do not move them up.
          dsotype=other ;;
      esac
    fi
    # Normal POSIX:
    if test "$dsotype" = "any"; then
      AC_CHECK_FUNC(dlopen, [dsotype=dlfcn])
    fi
    if test "$dsotype" = "any"; then
      AC_CHECK_LIB(dl, dlopen, [dsotype=dlfcn; APR_ADDTO(LIBS,-ldl)])
    fi
    if test "$dsotype" = "dlfcn"; then
        # ReliantUnix has dlopen() in libc but dlsym() in libdl :(
        AC_CHECK_FUNC(dlsym, [], 
          [AC_CHECK_LIB(dl, dlsym, 
             [APR_ADDTO(LIBS, -ldl)],
             [dsotype=any
              echo "Weird: dlopen() was found but dlsym() was not found!"])])
    fi
    if test "$dsotype" = "any"; then
      # BeOS:
      AC_CHECK_LIB(root, load_image, [dsotype=other])
    fi
    # Everything else:
    if test "$dsotype" = "any"; then
        case $host in
        *os390|*os400|*-aix*)
          # Some -aix5 will use dl, no hassles.  Keep that pattern here.
          dsotype=other ;;
        *-hpux*)
          if test "$have_shl" = "1"; then
            dsotype=shl; APR_ADDTO(LIBS,-ldld)
          fi;;
        esac
    fi
fi

if test "$dsotype" = "any"; then
    AC_MSG_ERROR([Could not detect suitable DSO implementation])
elif test "$dsotype" = "no"; then
    aprdso="0"
else
    case "$dsotype" in
    dlfcn) AC_DEFINE(DSO_USE_DLFCN, 1, [Define if DSO support uses dlfcn.h]);;
    shl)   AC_DEFINE(DSO_USE_SHL, 1, [Define if DSO support uses shl_load]);;
    dyld)  AC_DEFINE(DSO_USE_DYLD, 1, [Define if DSO support uses dyld.h]);;
    other) ;; # Use whatever is in dso/OSDIR
    *) AC_MSG_ERROR([Unknown DSO implementation "$dsotype"]);;
    esac
    aprdso="1"
    apr_modules="$apr_modules dso"
fi

AC_SUBST(aprdso)

dnl ----------------------------- Checking for Processes
echo "${nl}Checking for Processes..."

AC_CHECK_FUNCS(waitpid)

AC_ARG_ENABLE(other-child,
  [  --enable-other-child    Enable reliable child processes ],
  [ if test "$enableval" = "yes"; then
        oc="1"
    else
        oc="0"
    fi ],
  [ oc=1 ] ) 
  
AC_SUBST(oc) 

if test -z "$have_proc_invoked"; then
  have_proc_invoked="0"
fi

AC_SUBST(have_proc_invoked)

AC_MSG_CHECKING(for Variable Length Arrays)
APR_TRY_COMPILE_NO_WARNING([],
[
    int foo[argc];
    foo[0] = 0;
], vla_msg=yes, vla_msg=no )
AC_MSG_RESULT([$vla_msg])
if test "$vla_msg" = "yes"; then
    AC_DEFINE(HAVE_VLA, 1, [Define if C compiler supports VLA])
fi

AC_CACHE_CHECK(struct rlimit,ac_cv_struct_rlimit,[
AC_TRY_RUN([
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
main()
{
    struct rlimit limit;
    limit.rlim_cur = 0;
    limit.rlim_max = 0;
    exit(0);
}], [
    ac_cv_struct_rlimit=yes ], [
    ac_cv_struct_rlimit=no ], [
    ac_cv_struct_rlimit=no ] ) ] )
struct_rlimit=0
test "x$ac_cv_struct_rlimit" = xyes && struct_rlimit=1
AC_SUBST(struct_rlimit)

dnl ----------------------------- Checking for Locking Characteristics 
echo "${nl}Checking for Locking..."

AC_CHECK_FUNCS(semget semctl flock)
AC_CHECK_HEADERS(semaphore.h OS.h)
AC_SEARCH_LIBS(sem_open, rt)
AC_CHECK_FUNCS(sem_close sem_unlink sem_post sem_wait create_sem)

# Some systems return ENOSYS from sem_open.
AC_CACHE_CHECK(for working sem_open,ac_cv_func_sem_open,[
AC_TRY_RUN([
#include <errno.h>
#include <stdlib.h>
#include <fcntl.h>
#include <semaphore.h>
#ifndef SEM_FAILED
#define SEM_FAILED (-1)
#endif
main()
{
    sem_t *psem;
    const char *sem_name = "/apr_autoconf";

    psem = sem_open(sem_name, O_CREAT, 0644, 1);
    if (psem == (sem_t *)SEM_FAILED) {
	exit(1);
    }
    sem_close(psem);
    psem = sem_open(sem_name, O_CREAT | O_EXCL, 0644, 1);
    if (psem != (sem_t *)SEM_FAILED) {
        sem_close(psem);
        exit(1);
    }
    sem_unlink(sem_name);
    exit(0);
}], [ac_cv_func_sem_open=yes], [ac_cv_func_sem_open=no],
[ac_cv_func_sem_open=no])])

# It's stupid, but not all platforms have union semun, even those that need it.
AC_MSG_CHECKING(for union semun in sys/sem.h)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
],[
union semun arg;
semctl(0, 0, 0, arg);
], [have_union_semun="1" union_semun=yes ]
msg=yes, [
have_union_semun="0"
msg=no ] )
AC_MSG_RESULT([$msg])
AC_SUBST(have_union_semun)

dnl Checks for libraries.
APR_CHECK_DEFINE(LOCK_EX, sys/file.h)
APR_CHECK_DEFINE(F_SETLK, fcntl.h)
APR_CHECK_DEFINE(SEM_UNDO, sys/sem.h)

# We are assuming that if the platform doesn't have POLLIN, it doesn't have
# any POLL definitions.
APR_CHECK_DEFINE_FILES(POLLIN, poll.h sys/poll.h)

if test "$threads" = "1"; then
    APR_CHECK_DEFINE(PTHREAD_PROCESS_SHARED, pthread.h)
    AC_CHECK_FUNCS(pthread_mutexattr_setpshared)
    # Some systems have setpshared and define PROCESS_SHARED, but don't 
    # really support PROCESS_SHARED locks.  So, we must validate that we 
    # can go through the steps without receiving some sort of system error.
    # Linux and older versions of AIX have this problem.
    APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED func:pthread_mutexattr_setpshared, [
      AC_CACHE_CHECK([for working PROCESS_SHARED locks], apr_cv_process_shared_works, [
      AC_TRY_RUN([
#include <sys/types.h>
#include <pthread.h>
        int main()
        {
            pthread_mutex_t mutex;
            pthread_mutexattr_t attr;
            if (pthread_mutexattr_init(&attr))
                exit(1);
            if (pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED))
                exit(2);
            if (pthread_mutex_init(&mutex, &attr))
                exit(3);
            if (pthread_mutexattr_destroy(&attr))
                exit(4);
            if (pthread_mutex_destroy(&mutex))
                exit(5);
            exit(0);
        }], [apr_cv_process_shared_works=yes], [apr_cv_process_shared_works=no])])
      # Override detection of pthread_mutexattr_setpshared
      ac_cv_func_pthread_mutexattr_setpshared=$apr_cv_process_shared_works])

    if test "$ac_cv_func_pthread_mutexattr_setpshared" = "yes"; then
        APR_CHECK_PTHREAD_ROBUST_SHARED_MUTEX
    fi
fi

# See which lock mechanisms we can support on this system.
APR_IFALLYES(header:semaphore.h func:sem_open func:sem_close dnl
             func:sem_unlink func:sem_post func:sem_wait,
             hasposixser="1", hasposixser="0")
APR_IFALLYES(func:semget func:semctl define:SEM_UNDO, hassysvser="1", 
             hassysvser="0")
APR_IFALLYES(func:flock define:LOCK_EX, hasflockser="1", hasflockser="0")
APR_IFALLYES(header:fcntl.h define:F_SETLK, hasfcntlser="1", hasfcntlser="0")
# note: the current APR use of shared mutex requires /dev/zero
APR_IFALLYES(header:pthread.h define:PTHREAD_PROCESS_SHARED dnl
             func:pthread_mutexattr_setpshared dnl
             file:/dev/zero,
             hasprocpthreadser="1", hasprocpthreadser="0")
APR_IFALLYES(header:OS.h func:create_sem, hasbeossem="1", hasbeossem="0")

# See which lock mechanism we'll select by default on this system.
# The last APR_DECIDE to execute sets the default.
# At this stage, we match the ordering in Apache 1.3
# which is (highest to lowest): sysvsem -> fcntl -> flock.
# POSIX semaphores and cross-process pthread mutexes are not
# used by default since they have less desirable behaviour when
# e.g. a process holding the mutex segfaults.
# The BEOSSEM decision doesn't require any substitutions but is
# included here to prevent the fcntl() branch being selected
# from the decision making.
APR_BEGIN_DECISION([apr_lock implementation method])
APR_IFALLYES(func:flock define:LOCK_EX,
            APR_DECIDE(USE_FLOCK_SERIALIZE, [4.2BSD-style flock()]))
APR_IFALLYES(header:fcntl.h define:F_SETLK,
            APR_DECIDE(USE_FCNTL_SERIALIZE, [SVR4-style fcntl()]))
APR_IFALLYES(func:semget func:semctl define:SEM_UNDO,
            APR_DECIDE(USE_SYSVSEM_SERIALIZE, [SysV IPC semget()]))
APR_IFALLYES(header:OS.h func:create_sem, 
            APR_DECIDE(USE_BEOSSEM, [BeOS Semaphores])) 
if test "x$apr_lock_method" != "x"; then
    APR_DECISION_FORCE($apr_lock_method)
fi
APR_END_DECISION
AC_DEFINE_UNQUOTED($ac_decision)

flockser="0"
sysvser="0"
posixser="0"
procpthreadser="0"
fcntlser="0"
case $ac_decision in
    USE_FLOCK_SERIALIZE )
        flockser="1"
        ;;
    USE_FCNTL_SERIALIZE )
        fcntlser="1"
        ;;
    USE_SYSVSEM_SERIALIZE )
        sysvser="1"
        ;;
    USE_POSIXSEM_SERIALIZE )
        posixser="1"
        ;;
    USE_PROC_PTHREAD_SERIALIZE )
        procpthreadser="1"
        ;;
    USE_BEOSSEM )
        beossem="1"
        ;;
esac

if test $hasfcntlser = "1"; then
AC_MSG_CHECKING(if fcntl returns EACCES when F_SETLK is already held)
AC_TRY_RUN([
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#if defined(HAVE_UNISTD_H)
#include <unistd.h>
#endif
#include <fcntl.h>
#include <errno.h>

int fd;
struct flock proc_mutex_lock_it = {0};
const char *fname = "conftest.fcntl";

int main()
{
    int rc, status;;
    proc_mutex_lock_it.l_whence = SEEK_SET;   /* from current point */
    proc_mutex_lock_it.l_type = F_WRLCK;      /* set exclusive/write lock */

    fd = creat(fname, S_IRWXU);
    unlink(fname);

    if (rc = lockit()) {
        exit(-1);
    }

    if (fork()) {
        wait(&status);
    }
    else {
      return(lockit());
    }

    close(fd);
    exit(WEXITSTATUS(status) != EACCES);
}

int lockit() {
    int rc;
    do {
        rc = fcntl(fd, F_SETLK, &proc_mutex_lock_it);
    } while ( rc < 0 && errno == EINTR);

    return (rc < 0) ? errno : 0;
}], [apr_fcntl_tryacquire_eacces=1], [apr_fcntl_tryacquire_eacces=0], [apr_fcntl_tryacquire_eacces=0])
fi

if test "$apr_fcntl_tryacquire_eacces" = "1"; then
  AC_DEFINE(FCNTL_TRYACQUIRE_EACCES, 1, [Define if fcntl returns EACCES when F_SETLK is already held])
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi


AC_SUBST(hasflockser)
AC_SUBST(hassysvser)
AC_SUBST(hasposixser)
AC_SUBST(hasfcntlser)
AC_SUBST(hasprocpthreadser)
AC_SUBST(flockser)
AC_SUBST(sysvser)
AC_SUBST(posixser)
AC_SUBST(fcntlser)
AC_SUBST(procpthreadser)
AC_SUBST(pthreadser)

AC_MSG_CHECKING(if all interprocess locks affect threads)
if test "x$apr_process_lock_is_global" = "xyes"; then
    proclockglobal="1"
    AC_MSG_RESULT(yes)
else
    proclockglobal="0"
    AC_MSG_RESULT(no)
fi

AC_SUBST(proclockglobal)

AC_MSG_CHECKING(if POSIX sems affect threads in the same process)
if test "x$apr_posixsem_is_global" = "xyes"; then
  AC_DEFINE(POSIXSEM_IS_GLOBAL, 1, 
            [Define if POSIX semaphores affect threads within the process])
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(if SysV sems affect threads in the same process)
if test "x$apr_sysvsem_is_global" = "xyes"; then
  AC_DEFINE(SYSVSEM_IS_GLOBAL, 1,
            [Define if SysV semaphores affect threads within the process])
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(if fcntl locks affect threads in the same process)
if test "x$apr_fcntl_is_global" = "xyes"; then
  AC_DEFINE(FCNTL_IS_GLOBAL, 1,
            [Define if fcntl locks affect threads within the process])
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(if flock locks affect threads in the same process)
if test "x$apr_flock_is_global" = "xyes"; then
  AC_DEFINE(FLOCK_IS_GLOBAL, 1,
            [Define if flock locks affect threads within the process])
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

dnl ----------------------------- Checking for /dev/random 
AC_MSG_CHECKING(for entropy source)

why_no_rand=""

AC_ARG_WITH(egd, 
  [  --with-egd[[=DIR]]        use EGD-compatible socket],
  [ AC_DEFINE(HAVE_EGD, 1, [Define if EGD is supported])
    if test "$withval" = "yes"; then
        AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["/var/run/egd-pool","/dev/egd-pool","/etc/egd-pool","/etc/entropy"], 
         [Define to list of paths to EGD sockets])
    else
        AC_DEFINE_UNQUOTED(EGD_DEFAULT_SOCKET, ["$withval"])
    fi
    AC_MSG_RESULT(EGD-compatible daemon)
    rand="1"
  ])

if test "$rand" != "1"; then
  AC_ARG_WITH(devrandom,
    [  --with-devrandom[[=DEV]]  use /dev/random or compatible [[searches by default]]],
    [ apr_devrandom="$withval" ], [ apr_devrandom="yes" ])

  if test "$apr_devrandom" = "yes"; then
    # /dev/random on OpenBSD doesn't provide random data, so
    # prefer /dev/arandom, which does; see random(4).
    for f in /dev/arandom /dev/urandom /dev/random; do
      if test -r $f; then
        apr_devrandom=$f
        rand=1
        break
      fi
    done
  elif test "$apr_devrandom" != "no"; then
    if test -r "$apr_devrandom"; then
      rand="1"
    else
      AC_ERROR([$apr_devrandom not found or unreadable.])
    fi
  fi

  if test "$rand" = "1"; then
    case $host in
      *os390)
        if test $os_version -lt 1700; then
          rand="0"
          why_no_rand=" ($apr_devrandom unusable on z/OS before V1R7)"
        fi
        ;;
    esac
  fi

  if test "$rand" = "1"; then
    AC_DEFINE_UNQUOTED(DEV_RANDOM, ["$apr_devrandom"], [Define to path of random device])
    AC_MSG_RESULT([$apr_devrandom])
  fi
fi

if test "$rand" != "1"; then
    case $host in
        # we have built in support for OS/2
        *-os2*)
            AC_MSG_RESULT([Using OS/2 builtin random])
            rand="1"
            ;;
        *)
            if test "$rand" != "1"; then
              if test "$ac_cv_lib_truerand_main" = "yes"; then
                AC_DEFINE(HAVE_TRUERAND, 1, [Define if truerand is supported])
                AC_MSG_RESULT(truerand)
                rand="1"
              else
                AC_MSG_RESULT(not found$why_no_rand)
                rand="0"
              fi
            fi
            ;;
    esac
fi

AC_SUBST(rand)

dnl ----------------------------- Checking for File Info Support 
echo "${nl}Checking for File Info Support..."
AC_CHECK_MEMBERS([struct stat.st_blocks, struct stat.st_atimensec,
struct stat.st_ctimensec, struct stat.st_mtimensec, struct stat.st_atim.tv_nsec,
struct stat.st_ctim.tv_nsec, struct stat.st_mtim.tv_nsec,
struct stat.st_atime_n, struct stat.st_ctime_n, struct stat.st_mtime_n],,,[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif])

APR_CHECK_DIRENT_INODE
APR_CHECK_DIRENT_TYPE

dnl ----------------------------- Checking for UUID Support 
echo "${nl}Checking for OS UUID Support..."

AC_CHECK_HEADERS(uuid.h uuid/uuid.h sys/uuid.h, break)

apr_revert_save_LIBS=$LIBS

# Prefer the flavor(s) that live in libc;
AC_SEARCH_LIBS(uuid_create, uuid)
AC_SEARCH_LIBS(uuid_generate, uuid)
if test "$ac_cv_search_uuid_create" = "none required" -o \
        "$ac_cv_search_uuid_generate" = "none required"; then
 LIBS=$apr_revert_save_LIBS
fi

AC_CHECK_FUNCS(uuid_create uuid_generate)

AC_CACHE_CHECK([for os uuid usability], [apr_cv_osuuid], [
# Ensure this test closely mirrors misc/unix/rand.c!
uuid_includes="
#if defined(HAVE_SYS_TYPES_H)
#include <sys/types.h>
#endif
#if defined(HAVE_UNISTD_H)
#include <unistd.h>
#endif
#if defined(HAVE_UUID_H)
#include <uuid.h>
#elif defined(HAVE_UUID_UUID_H)
#include <uuid/uuid.h>
#elif defined(HAVE_SYS_UUID_H)
#include <sys/uuid.h>
#endif
"
 apr_cv_osuuid=no
 if test $ac_cv_func_uuid_create = yes; then
  AC_TRY_LINK([$uuid_includes], [
    uuid_t g;
    uint32_t s;
    uuid_create(&g, &s);
    if (s == uuid_s_ok) s = 0;
  ], [apr_cv_osuuid=yes], [apr_cv_func_uuid_create=no])
 fi
 if test $ac_cv_func_uuid_generate = yes; then
  AC_TRY_LINK([$uuid_includes], [
    uuid_t g;
    uuid_generate(g);
  ], [apr_cv_osuuid=yes], [apr_cv_func_uuid_generate=no])
 fi 
])

if test $apr_cv_osuuid = yes; then
  osuuid="1"
else
  osuuid="0"
  LIBS=$apr_revert_save_LIBS
fi
AC_SUBST(osuuid)


dnl ----------------------------- Checking for Time Support 
echo "${nl}Checking for Time Support..."

AC_CHECK_MEMBERS([struct tm.tm_gmtoff, struct tm.__tm_gmtoff],,,[
#include <sys/types.h>
#include <time.h>])

dnl ----------------------------- Checking for Networking Support 
echo "${nl}Checking for Networking support..."
APR_TYPE_IN_ADDR
if test "$ac_cv_type_in_addr" = "yes"; then
  have_in_addr="1"
else
  have_in_addr="0"
fi

AC_MSG_CHECKING([if fd == socket on this platform])
if test "x$file_as_socket" != "x0" ; then
    file_as_socket="1";
    echo "yes"
else
    echo "no"
fi

AC_SUBST(have_in_addr)
AC_SUBST(file_as_socket)

if test "$ac_cv_func_poll $file_as_socket" = "yes 1"; then
    AC_DEFINE(WAITIO_USES_POLL, 1,
              [Define if apr_wait_for_io_or_timeout() uses poll(2)])
fi

# Check the types only if we have gethostbyname_r
if test "$ac_cv_func_gethostbyname_r" = "yes"; then
    APR_CHECK_GETHOSTBYNAME_R_STYLE
fi

# Check the types only if we have getservbyname_r
if test "$ac_cv_func_getservbyname_r" = "yes"; then
    APR_CHECK_GETSERVBYNAME_R_STYLE
fi

APR_CHECK_TCP_NODELAY_INHERITED
APR_CHECK_O_NONBLOCK_INHERITED
APR_CHECK_TCP_NODELAY_WITH_CORK

# Look for a way of corking TCP...
APR_CHECK_DEFINE(TCP_CORK, netinet/tcp.h)
APR_CHECK_DEFINE(TCP_NOPUSH, netinet/tcp.h)
apr_tcp_nopush_flag="0"
have_corkable_tcp="0"
if test "x$ac_cv_define_TCP_CORK" = "xyes"; then
    apr_tcp_nopush_flag="TCP_CORK"
    have_corkable_tcp="1"
else
    case $host in
        *linux*)
            AC_EGREP_CPP(yes,[
#include <linux/socket.h>
#ifdef TCP_CORK
yes
#endif
            ],[
                apr_tcp_nopush_flag="3"
                have_corkable_tcp="1"
            ])
            ;;
        *)
            ;;
    esac
fi
if test "x$ac_cv_define_TCP_NOPUSH" = "xyes"; then
    apr_tcp_nopush_flag="TCP_NOPUSH"
    have_corkable_tcp="1"
fi

APR_CHECK_DEFINE(SO_ACCEPTFILTER, sys/socket.h)
if test "x$ac_cv_define_SO_ACCEPTFILTER" = "xyes"; then
    acceptfilter="1"
else
    acceptfilter="0"
fi

APR_CHECK_SCTP
APR_CHECK_MCAST

AC_SUBST(apr_tcp_nopush_flag)
AC_SUBST(have_corkable_tcp)
AC_SUBST(acceptfilter)
AC_SUBST(have_sctp)

AC_CHECK_FUNCS(set_h_errno)

echo "${nl}Checking for IPv6 Networking support..."
dnl Start of checking for IPv6 support...

AC_ARG_ENABLE(ipv6,
  [  --disable-ipv6          Disable IPv6 support in APR.],
  [ if test "$enableval" = "no"; then
        user_disabled_ipv6=1
    fi ],
  [ user_disabled_ipv6=0 ] )

case $host in
  *)
    broken_ipv6=0
esac

AC_SEARCH_LIBS(getaddrinfo, socket inet6)
AC_SEARCH_LIBS(gai_strerror, socket inet6)
AC_SEARCH_LIBS(getnameinfo, socket inet6)
AC_CHECK_FUNCS(gai_strerror)
APR_CHECK_WORKING_GETADDRINFO
APR_CHECK_NEGATIVE_EAI
APR_CHECK_WORKING_GETNAMEINFO
APR_CHECK_SOCKADDR_IN6
APR_CHECK_SOCKADDR_STORAGE
APR_CHECK_SOCKADDR_UN

have_ipv6="0"
if test "$user_disabled_ipv6" = 1; then
    ipv6_result="no -- disabled by user"
else
    if test "x$broken_ipv6" = "x0"; then
        if test "x$have_sockaddr_in6" = "x1"; then
            if test "x$ac_cv_working_getaddrinfo" = "xyes"; then
                if test "x$ac_cv_working_getnameinfo" = "xyes"; then
                    APR_CHECK_GETADDRINFO_ADDRCONFIG
                    have_ipv6="1"
                    ipv6_result="yes"
                else
                    ipv6_result="no -- no getnameinfo"
                fi
            else
                ipv6_result="no -- no working getaddrinfo"
            fi
        else
            ipv6_result="no -- no sockaddr_in6"
        fi
    else
        ipv6_result="no -- the platform has known problems supporting IPv6"
    fi
fi

AC_MSG_CHECKING(if APR supports IPv6)
AC_MSG_RESULT($ipv6_result)

AC_SUBST(have_ipv6)

# hstrerror is only needed if IPv6 is not enabled,
# so getaddrinfo/gai_strerror are not used.
if test $have_ipv6 = 0; then
  AC_SEARCH_LIBS(hstrerror, resolv,
    [AC_DEFINE(HAVE_HSTRERROR, 1, [Define if hstrerror is present])])
fi

dnl Check for langinfo support

AC_CHECK_HEADERS(langinfo.h)
AC_CHECK_FUNCS(nl_langinfo)

dnl ------------------------------ Defaults for some platform nuances

dnl Do we have a Win32-centric Unicode FS?
APR_SETIFNULL(have_unicode_fs, [0])
AC_SUBST(have_unicode_fs)

APR_SETIFNULL(apr_has_xthread_files, [0])
AC_SUBST(apr_has_xthread_files)

APR_SETIFNULL(apr_procattr_user_set_requires_password, [0])
AC_SUBST(apr_procattr_user_set_requires_password)

APR_SETIFNULL(apr_thread_func, [])
AC_SUBST(apr_thread_func)

APR_SETIFNULL(apr_has_user, [1])
AC_SUBST(apr_has_user)

dnl ----------------------------- Finalize the variables

echo "${nl}Restore user-defined environment settings..."

APR_RESTORE_THE_ENVIRONMENT(CPPFLAGS, EXTRA_)
APR_RESTORE_THE_ENVIRONMENT(CFLAGS, EXTRA_)
APR_RESTORE_THE_ENVIRONMENT(LDFLAGS, EXTRA_)
APR_RESTORE_THE_ENVIRONMENT(LIBS, EXTRA_)
APR_RESTORE_THE_ENVIRONMENT(INCLUDES, EXTRA_)
AC_SUBST(NOTEST_CPPFLAGS)
AC_SUBST(NOTEST_CFLAGS)
AC_SUBST(NOTEST_LDFLAGS)
AC_SUBST(NOTEST_LIBS)
AC_SUBST(NOTEST_INCLUDES)

dnl ----------------------------- Construct the files

AC_SUBST(INTERNAL_CPPFLAGS)
AC_SUBST(LDLIBS)
AC_SUBST(INCLUDES)
AC_SUBST(AR)
AC_SUBST(RM)
AC_SUBST(OSDIR)
AC_SUBST(DEFAULT_OSDIR)
AC_SUBST(EXEEXT)
AC_SUBST(LIBTOOL_LIBS)

# Use -no-install or -no-fast-install to link the test 
# programs on all platforms but Darwin, where it would cause
# the programs to be linked against installed versions of
# libapr instead of those just built.
case $host in
    *-apple-darwin*)
        LT_NO_INSTALL=""
        ;;
    *-mingw*)
        LT_NO_INSTALL="-no-fast-install"
        ;;
    *)
        LT_NO_INSTALL="-no-install"
        ;;
esac
AC_SUBST(LT_NO_INSTALL)

#
# BSD/OS (BSDi) needs to use a different include syntax in the Makefiles
#
case $host in
*bsdi*)
    # Check whether they've installed GNU make
    if make --version > /dev/null 2>&1; then 
	INCLUDE_RULES="include $apr_buildout/apr_rules.mk"
	INCLUDE_OUTPUTS="include $apr_srcdir/build-outputs.mk"
    else
	# BSDi make
	INCLUDE_RULES=".include \"$apr_buildout/apr_rules.mk\""
	INCLUDE_OUTPUTS=".include \"$apr_srcdir/build-outputs.mk\""
    fi
    ;;
*)
    INCLUDE_RULES="include $apr_buildout/apr_rules.mk"
    INCLUDE_OUTPUTS="include $apr_srcdir/build-outputs.mk"
    ;;
esac
AC_SUBST(INCLUDE_RULES)
AC_SUBST(INCLUDE_OUTPUTS)

AC_CONFIG_FILES([Makefile
                 include/apr.h
                 build/apr_rules.mk
                 build/pkg/pkginfo
                 apr-$APR_MAJOR_VERSION-config:apr-config.in
                 apr.pc])

if test -d $srcdir/test; then
   AC_CONFIG_FILES([test/Makefile test/internal/Makefile])
fi

dir=include/arch/unix
test -d $dir || $MKDIR $dir

AC_CONFIG_COMMANDS([default], [
# Commands run at the end of config.status:
for i in $APR_SAVE_HEADERS; do
  if cmp -s $i $i.save 2>/dev/null; then
    mv $i.save $i
    AC_MSG_NOTICE([$i is unchanged])
  fi
  rm -f $i.save
done
chmod +x apr-$APR_MAJOR_VERSION-config
],[
dnl This section is expanded by configure UNQUOTED so variable 
dnl references must be backslash-escaped as necessary.

# Commands run at the beginning of config.status:
APR_SAVE_HEADERS="include/apr.h include/arch/unix/apr_private.h"
APR_MAJOR_VERSION=$APR_MAJOR_VERSION
APR_PLATFORM=$host

for apri in \${APR_SAVE_HEADERS}; do
  test -r \${apri} && mv \${apri} \${apri}.save
done
])

AC_OUTPUT