Revamp chapter 1

[openldap] / build / openldap.m4

diff --git a/build/openldap.m4 b/build/openldap.m4
index be67f8a666d45a0355bef2bd4177db2cb00432de..a12b0a2577d9dff5a6aa7e0435c95afbf2ebab2c 100644 (file)
--- a/build/openldap.m4
+++ b/build/openldap.m4
@@ -1,4 +1,6 @@
-dnl Copyright 1998-1999 The OpenLDAP Foundation,  All Rights Reserved.
+dnl $OpenLDAP$
+dnl
+dnl Copyright 1998-2000 The OpenLDAP Foundation,  All Rights Reserved.

 dnl COPYING RESTRICTIONS APPLY, See COPYRIGHT file
 dnl
 dnl OpenLDAP Autoconf Macros
 dnl COPYING RESTRICTIONS APPLY, See COPYRIGHT file
 dnl
 dnl OpenLDAP Autoconf Macros


@@ -54,6 +56,33 @@ dnl AC_VERBOSE(OpenLDAP --with-$1 $ol_with_$1)
 ])dnl
 dnl
 dnl ====================================================================
 ])dnl
 dnl
 dnl ====================================================================

+dnl
+AC_DEFUN(AC_COMPILE_CHECK_SIZEOF,
+[changequote(<<, >>)dnl 
+dnl The name to #define. 
+define(<<AC_TYPE_NAME>>, translit(sizeof_$1, [a-z *], [A-Z_P]))dnl 
+dnl The cache variable name. 
+define(<<AC_CV_NAME>>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl 
+changequote([, ])dnl 
+AC_MSG_CHECKING(size of $1) 
+AC_CACHE_VAL(AC_CV_NAME, 
+[for ac_size in 4 8 1 2 16 $2 ; do # List sizes in rough order of prevalence. 
+  AC_TRY_COMPILE([#include "confdefs.h" 
+#include <sys/types.h> 
+$2 
+], [switch (0) case 0: case (sizeof ($1) == $ac_size):;], AC_CV_NAME=$ac_size) 
+  if test x$AC_CV_NAME != x ; then break; fi 
+done 
+]) 
+if test x$AC_CV_NAME = x ; then 
+  AC_MSG_ERROR([cannot determine a size for $1]) 
+fi 
+AC_MSG_RESULT($AC_CV_NAME) 
+AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [The number of bytes in type $1]) 
+undefine([AC_TYPE_NAME])dnl 
+undefine([AC_CV_NAME])dnl 
+])
+dnl ====================================================================

 dnl check if hard links are supported.
 dnl
 AC_DEFUN([OL_PROG_LN_H], [# test for ln hardlink support
 dnl check if hard links are supported.
 dnl
 AC_DEFUN([OL_PROG_LN_H], [# test for ln hardlink support


@@ -79,10 +108,48 @@ AC_SUBST(LN_H)dnl
 ])dnl
 dnl
 dnl ====================================================================
 ])dnl
 dnl
 dnl ====================================================================

+dnl Check for dependency generation flag
+AC_DEFUN([OL_MKDEPEND], [# test for make depend flag
+OL_MKDEP=
+OL_MKDEP_FLAGS=
+if test -z "${MKDEP}"; then
+       OL_MKDEP="${CC-cc}"
+       if test -z "${MKDEP_FLAGS}"; then
+               AC_CACHE_CHECK([for ${OL_MKDEP} depend flag], ol_cv_mkdep, [
+                       ol_cv_mkdep=no
+                       for flag in "-M" "-xM"; do
+                               cat > conftest.c <<EOF
+ noCode;
+EOF
+                               if AC_TRY_COMMAND($OL_MKDEP $flag conftest.c) \
+                                       | egrep '^conftest\.'"${ac_objext}" >/dev/null 2>&1
+                               then
+                                       if test ! -f conftest."${ac_object}" ; then
+                                               ol_cv_mkdep=$flag
+                                               OL_MKDEP_FLAGS="$flag"
+                                               break
+                                       fi
+                               fi
+                       done
+                       rm -f conftest*
+               ])
+       else
+               cc_cv_mkdep=yes
+               OL_MKDEP_FLAGS="${MKDEP_FLAGS}"
+       fi
+else
+       cc_cv_mkdep=yes
+       OL_MKDEP="${MKDEP}"
+       OL_MKDEP_FLAGS="${MKDEP_FLAGS}"
+fi
+AC_SUBST(OL_MKDEP)
+AC_SUBST(OL_MKDEP_FLAGS)
+])
+dnl
+dnl ====================================================================

 dnl Check if system uses EBCDIC instead of ASCII
 AC_DEFUN([OL_CPP_EBCDIC], [# test for EBCDIC
 dnl Check if system uses EBCDIC instead of ASCII
 AC_DEFUN([OL_CPP_EBCDIC], [# test for EBCDIC

-AC_MSG_CHECKING([for EBCDIC])
-AC_CACHE_VAL(ol_cv_cpp_ebcdic,[
+AC_CACHE_CHECK([for EBCDIC],ol_cv_cpp_ebcdic,[

        AC_TRY_CPP([
 #if !('M' == 0xd4)
 #include <__ASCII__/generate_error.h>
        AC_TRY_CPP([
 #if !('M' == 0xd4)
 #include <__ASCII__/generate_error.h>


@@ -90,7 +157,6 @@ AC_CACHE_VAL(ol_cv_cpp_ebcdic,[
 ],
        [ol_cv_cpp_ebcdic=yes],
        [ol_cv_cpp_ebcdic=no])])
 ],
        [ol_cv_cpp_ebcdic=yes],
        [ol_cv_cpp_ebcdic=no])])

-AC_MSG_RESULT($ol_cv_cpp_ebcdic)

 if test $ol_cv_cpp_ebcdic = yes ; then
        AC_DEFINE(HAVE_EBCDIC,1, [define if system uses EBCDIC instead of ASCII])
 fi
 if test $ol_cv_cpp_ebcdic = yes ; then
        AC_DEFINE(HAVE_EBCDIC,1, [define if system uses EBCDIC instead of ASCII])
 fi


@@ -144,156 +210,194 @@ dnl
 dnl ====================================================================
 dnl Check if struct passwd has pw_gecos
 AC_DEFUN([OL_STRUCT_PASSWD_PW_GECOS], [# test for pw_gecos in struct passwd
 dnl ====================================================================
 dnl Check if struct passwd has pw_gecos
 AC_DEFUN([OL_STRUCT_PASSWD_PW_GECOS], [# test for pw_gecos in struct passwd

-AC_MSG_CHECKING([struct passwd for pw_gecos])
-AC_CACHE_VAL(ol_cv_struct_passwd_pw_gecos,[
+AC_CACHE_CHECK([struct passwd for pw_gecos],ol_cv_struct_passwd_pw_gecos,[

        AC_TRY_COMPILE([#include <pwd.h>],[
        struct passwd pwd;
        pwd.pw_gecos = pwd.pw_name;
 ],
        [ol_cv_struct_passwd_pw_gecos=yes],
        [ol_cv_struct_passwd_pw_gecos=no])])
        AC_TRY_COMPILE([#include <pwd.h>],[
        struct passwd pwd;
        pwd.pw_gecos = pwd.pw_name;
 ],
        [ol_cv_struct_passwd_pw_gecos=yes],
        [ol_cv_struct_passwd_pw_gecos=no])])

-AC_MSG_RESULT($ol_cv_struct_passwd_pw_gecos)

 if test $ol_cv_struct_passwd_pw_gecos = yes ; then
        AC_DEFINE(HAVE_PW_GECOS,1, [define if struct passwd has pw_gecos])
 fi
 ])
 dnl
 if test $ol_cv_struct_passwd_pw_gecos = yes ; then
        AC_DEFINE(HAVE_PW_GECOS,1, [define if struct passwd has pw_gecos])
 fi
 ])
 dnl

-dnl ====================================================================
-dnl Check if db.h is Berkeley DB2
-dnl
-dnl defines ol_cv_header_db2 to 'yes' or 'no'
-dnl
-dnl uses:
-dnl            AC_CHECK_HEADERS(db.h)
-dnl
-AC_DEFUN([OL_HEADER_BERKELEY_DB2],
-[AC_CHECK_HEADERS(db.h)
-if test $ac_cv_header_db_h = yes ; then
-       AC_CACHE_CHECK([if db.h is DB2], [ol_cv_header_db2],[
-               AC_EGREP_CPP(__db_version_2,[
-#                      include <db.h>
-                       /* this check could be improved */
-#                      ifdef DB_VERSION_MAJOR
-#                              if DB_VERSION_MAJOR == 2
-                                       __db_version_2
-#                              endif
-#                      endif
-               ], ol_cv_header_db2=yes, ol_cv_header_db2=no)])
-else
-       ol_cv_header_db2=no
-fi
-])dnl
-dnl --------------------------------------------------------------------
-dnl Check if Berkeley DB2 library exists
-dnl Check for dbopen in standard libraries or -ldb
-dnl
-dnl defines ol_cv_lib_db2 to '-ldb' or 'no'
-dnl
-dnl uses:
-dnl            AC_CHECK_LIB(db,db_open)
-dnl
-AC_DEFUN([OL_LIB_BERKELEY_DB2],
-[AC_CACHE_CHECK([for DB2 library], [ol_cv_lib_db2],
-[      ol_LIBS="$LIBS"
-       AC_CHECK_LIB(db,db_open,[ol_cv_lib_db2=-ldb],[ol_cv_lib_db2=no])
-       LIBS="$ol_LIBS"
-])
-])dnl
-dnl

 dnl --------------------------------------------------------------------
 dnl --------------------------------------------------------------------

-dnl Check if Berkeley db2 exists
-dnl
-dnl defines ol_cv_berkeley_db2 to 'yes' or 'no'
-dnl 
-dnl uses:
-dnl            OL_LIB_BERKELEY_DB2
-dnl            OL_HEADER_BERKELEY_DB2
-dnl
-AC_DEFUN([OL_BERKELEY_DB2],
-[AC_REQUIRE([OL_LIB_BERKELEY_DB2])
- AC_REQUIRE([OL_HEADER_BERKELEY_DB2])
- AC_CACHE_CHECK([for Berkeley DB2], [ol_cv_berkeley_db2], [
-       if test "$ol_cv_lib_db2" = no -o "$ol_cv_header_db2" = no ; then
-               ol_cv_berkeley_db2=no
-       else
-               ol_cv_berkeley_db2=yes
-       fi
+dnl Check if struct passwd has pw_passwd
+AC_DEFUN([OL_STRUCT_PASSWD_PW_PASSWD], [# test for pw_passwd in struct passwd
+AC_CACHE_CHECK([struct passwd for pw_passwd],ol_cv_struct_passwd_pw_passwd,[
+       AC_TRY_COMPILE([#include <pwd.h>],[
+       struct passwd pwd;
+       pwd.pw_passwd = pwd.pw_name;
+],
+       [ol_cv_struct_passwd_pw_passwd=yes],
+       [ol_cv_struct_passwd_pw_passwd=no])])
+if test $ol_cv_struct_passwd_pw_passwd = yes ; then
+       AC_DEFINE(HAVE_PW_PASSWD,1, [define if struct passwd has pw_passwd])
+fi

 ])
 ])

- if test $ol_cv_berkeley_db2 = yes ; then
-       AC_DEFINE(HAVE_BERKELEY_DB2,1, [define if Berkeley DBv2 is available])
- fi
-])dnl

 dnl
 dnl ====================================================================
 dnl
 dnl ====================================================================

-dnl Check for db.h/db_185.h is Berkeley DB
-dnl
-dnl defines ol_cv_header_db to 'yes' or 'no'
-dnl
-dnl uses:
-dnl            OL_HEADER_BERKELEY_DB2
-dnl            AC_CHECK_HEADERS(db_185.h)
+dnl Berkeley DB macros

 dnl
 dnl

-AC_DEFUN([OL_HEADER_BERKELEY_DB],
-[AC_REQUIRE([OL_HEADER_BERKELEY_DB2])
-AC_CHECK_HEADERS(db_185.h)
-if test "$ol_cv_header_db2" = yes ; then
-       dnl db.h is db2! 
+dnl --------------------------------------------------------------------
+dnl Try to link
+AC_DEFUN([OL_BERKELEY_DB_TRY],
+[if test $ol_cv_lib_db = no ; then
+       AC_CACHE_CHECK([for Berkeley DB link (]ifelse($2,,default,$2)[)],[$1],
+[
+       ol_DB_LIB=ifelse($2,,,$2)
+       ol_LIBS=$LIBS
+       LIBS="$ol_DB_LIB $LIBS"

 
 

-       ol_cv_header_db=$ac_cv_header_db_185_h
-else
-       ol_cv_header_db=$ac_cv_header_db_h
+       AC_TRY_LINK([
+#ifdef HAVE_DB_185_H
+# include <db_185.h>
+#else
+# include <db.h>
+#endif
+
+#ifndef DB_VERSION_MAJOR
+# define DB_VERSION_MAJOR 1
+#endif
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+],[
+#if DB_VERSION_MAJOR > 2
+       db_env_create( NULL, 0 );
+#elif DB_VERSION_MAJOR > 1
+       db_appexit( NULL );
+#else
+       (void) dbopen( NULL, 0, 0, 0, NULL);
+#endif
+],[$1=yes],[$1=no])
+
+       LIBS="$ol_LIBS"
+])
+
+       if test $$1 = yes ; then
+               ol_cv_lib_db=ifelse($2,,yes,$2)
+       fi

 fi
 fi

-])dnl
+])

 dnl
 dnl --------------------------------------------------------------------
 dnl
 dnl --------------------------------------------------------------------

-dnl Check if Berkeley DB library exists
-dnl Check for dbopen in standard libraries or -ldb
-dnl
-dnl defines ol_cv_lib_db to 'yes' or '-ldb' or 'no'
-dnl            'yes' implies dbopen is in $LIBS
-dnl
-dnl uses:
-dnl            AC_CHECK_FUNC(dbopen)
-dnl            AC_CHECK_LIB(db,dbopen)
+dnl Try to locate appropriate library
+AC_DEFUN([OL_BERKELEY_DB_LINK],
+[ol_cv_lib_db=no
+OL_BERKELEY_DB_TRY(ol_cv_db_none)
+OL_BERKELEY_DB_TRY(ol_cv_db_db,[-ldb])
+OL_BERKELEY_DB_TRY(ol_cv_db_db3,[-ldb3])
+OL_BERKELEY_DB_TRY(ol_cv_db_db2,[-ldb2])
+OL_BERKELEY_DB_TRY(ol_cv_db_db1,[-ldb1])
+])

 dnl
 dnl

-AC_DEFUN([OL_LIB_BERKELEY_DB],
-[AC_CACHE_CHECK([for Berkeley DB library], [ol_cv_lib_db],
-[
-       AC_CHECK_HEADERS(db1/db.h)
+dnl --------------------------------------------------------------------
+dnl Check if Berkeley DB supports DB_THREAD
+AC_DEFUN([OL_BERKELEY_DB_THREAD],
+[AC_CACHE_CHECK([for Berkeley DB thread support], [ol_cv_berkeley_db_thread], [

        ol_LIBS="$LIBS"
        ol_LIBS="$LIBS"

-       AC_CHECK_FUNC(dbopen,[ol_cv_lib_db=yes], [
-               AC_CHECK_LIB(db1,dbopen,[ol_cv_lib_db=-ldb1],[
-                       AC_CHECK_LIB(db,dbopen,[ol_cv_lib_db=-ldb],
-                       [ol_cv_lib_db=no])
-               ])
-       ])
+       if test $ol_cv_lib_db != yes ; then
+               LIBS="$ol_cv_lib_db"
+       fi
+
+       AC_TRY_RUN([
+#ifdef HAVE_DB_185_H
+       choke me;
+#else
+#include <db.h>
+#endif
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+main()
+{
+       int rc;
+       u_int32_t flags = DB_CREATE | DB_THREAD;
+
+
+#if DB_VERSION_MAJOR > 2
+       DB_ENV *env = NULL;
+
+       rc = db_env_create( &env, 0 );
+
+       if( rc == 0 ) {
+               rc = env->open( env, NULL, NULL, flags, 0 );
+       }
+
+#else
+       DB_ENV env;
+       memset( &env, '\0', sizeof(env) );
+
+       rc = db_appinit( NULL, NULL, &env, flags );
+
+       if( rc == 0 ) {
+               db_appexit( &env );
+       }
+#endif
+
+       return rc;
+}],
+       [ol_cv_berkeley_db_thread=yes],
+       [ol_cv_berkeley_db_thread=no],
+       [ol_cv_berkeley_db_thread=cross])
+

        LIBS="$ol_LIBS"
        LIBS="$ol_LIBS"

-])
-])dnl
+
+       if test $ol_cv_berkeley_db_thread != no ; then
+               AC_DEFINE(HAVE_BERKELEY_DB_THREAD, 1,
+                       [define if Berkeley DB has DB_THREAD support])
+       fi
+])])dnl

 dnl
 dnl --------------------------------------------------------------------
 dnl
 dnl --------------------------------------------------------------------

-dnl Check if Berkeley DB exists
-dnl
-dnl defines ol_cv_berkeley_db to 'yes' or 'no'
-dnl 
-dnl uses:
-dnl            OL_LIB_BERKELEY_DB
-dnl            OL_HEADER_BERKELEY_DB
-dnl
+dnl Find any DB

 AC_DEFUN([OL_BERKELEY_DB],
 AC_DEFUN([OL_BERKELEY_DB],

-[AC_REQUIRE([OL_LIB_BERKELEY_DB])
- AC_REQUIRE([OL_HEADER_BERKELEY_DB])
- AC_CACHE_CHECK([for Berkeley DB], [ol_cv_berkeley_db], [
-       if test "$ol_cv_lib_db" = no -o "$ol_cv_header_db" = no ; then
-               ol_cv_berkeley_db=no
-       else
+[ol_cv_berkeley_db=no
+AC_CHECK_HEADERS(db.h)
+if test $ac_cv_header_db_h = yes; then
+       OL_BERKELEY_DB_LINK
+       if test "$ol_cv_lib_db" != no ; then

                ol_cv_berkeley_db=yes
                ol_cv_berkeley_db=yes

+               OL_BERKELEY_DB_THREAD

        fi
        fi

+fi
+])
+dnl
+dnl --------------------------------------------------------------------
+dnl Find old Berkeley DB 1.85/1.86
+AC_DEFUN([OL_BERKELEY_COMPAT_DB],
+[ol_cv_berkeley_db=no
+AC_CHECK_HEADERS(db_185.h db.h)
+if test $ac_cv_header_db_185_h = yes -o $ac_cv_header_db_h = yes; then
+       AC_CACHE_CHECK([if Berkeley DB header compatibility], [ol_cv_header_db1],[
+               AC_EGREP_CPP(__db_version_1,[
+#if HAVE_DB_185_H
+#      include <db_185.h>
+#else
+#      include <db.h>
+#endif
+
+ /* this check could be improved */
+#ifndef DB_VERSION_MAJOR
+#      define DB_VERSION_MAJOR 1
+#endif
+
+#if DB_VERSION_MAJOR == 1 
+       __db_version_1
+#endif
+],     [ol_cv_header_db1=yes], [ol_cv_header_db1=no])])
+
+       if test ol_cv_header_db1=yes ; then
+               OL_BERKELEY_DB_LINK
+               if test "$ol_cv_lib_db" != no ; then
+                       ol_cv_berkeley_db=yes
+               fi
+       fi
+fi

 ])
 ])

- if test $ol_cv_berkeley_db = yes ; then
-       AC_DEFINE(HAVE_BERKELEY_DB,1, [define if Berkeley DB is available])
- fi
-])dnl

 dnl
 dnl ====================================================================
 dnl Check if GDBM library exists
 dnl
 dnl ====================================================================
 dnl Check if GDBM library exists


@@ -455,7 +559,7 @@ AC_DEFUN([OL_POSIX_THREAD_VERSION],
 #              include <pthread.h>
                /* this check could be improved */
 #              ifdef PTHREAD_ONCE_INIT
 #              include <pthread.h>
                /* this check could be improved */
 #              ifdef PTHREAD_ONCE_INIT

-                       pthread_version_final
+                       pthread_version_final;

 #              endif
        ], ol_pthread_final=yes, ol_pthread_final=no)
 
 #              endif
        ], ol_pthread_final=yes, ol_pthread_final=no)
 


@@ -463,7 +567,7 @@ AC_DEFUN([OL_POSIX_THREAD_VERSION],
 #              include <pthread.h>
                /* this check could be improved */
 #              ifdef pthread_once_init
 #              include <pthread.h>
                /* this check could be improved */
 #              ifdef pthread_once_init

-                       pthread_version_draft4
+                       pthread_version_draft4;

 #              endif
        ], ol_pthread_draft4=yes, ol_pthread_draft4=no)
 
 #              endif
        ], ol_pthread_draft4=yes, ol_pthread_draft4=no)
 


@@ -478,46 +582,129 @@ AC_DEFUN([OL_POSIX_THREAD_VERSION],
 ])dnl
 dnl
 dnl --------------------------------------------------------------------
 ])dnl
 dnl
 dnl --------------------------------------------------------------------

-AC_DEFUN([OL_PTHREAD_TRY_LINK], [# Pthread try link: $1 ($2)
-       if test "$ol_link_threads" = no ; then
-               # try $1
-               AC_CACHE_CHECK([for pthread link with $1], [$2], [
-                       # save the flags
-                       ol_LIBS="$LIBS"
-                       LIBS="$1 $LIBS"
-
-                       AC_TRY_LINK([
+AC_DEFUN([OL_PTHREAD_TEST_INCLUDES],
+[/* pthread test headers */

 #include <pthread.h>
 #ifndef NULL
 #define NULL (void*)0
 #endif
 #include <pthread.h>
 #ifndef NULL
 #define NULL (void*)0
 #endif

-],[
+
+static void *task(p)
+       void *p;
+{
+       return (void *) (p == NULL);
+}
+])
+AC_DEFUN([OL_PTHREAD_TEST_FUNCTION],[
+       /* pthread test function */

        pthread_t t;
        pthread_t t;

+       int status;
+#if HAVE_PTHREADS_FINAL && defined(PTHREAD_CREATE_UNDETACHED)
+       /* This system (e.g. AIX) defaults detached; must override */
+       pthread_attr_t attr;
+
+       status = pthread_attr_init(&attr);
+       if( status ) exit( status );
+
+       status = pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_UNDETACHED);
+       if( status ) exit( status );
+
+#define        ATTR    &attr
+#else
+#if HAVE_PTHREADS_D4
+#define        ATTR    pthread_attr_default
+#else
+#define        ATTR    NULL
+#endif
+#endif
+       /* make sure pthread_create() isn't just a stub */
+       status = pthread_create(&t, ATTR, task, NULL);
+       if( status ) exit( status );

 
 

+       /* make sure pthread_detach() isn't just a stub */

 #if HAVE_PTHREADS_D4
 #if HAVE_PTHREADS_D4

-       pthread_create(&t, pthread_attr_default, NULL, NULL);
-       pthread_detach( &t );
+       status = pthread_detach( &t );

 #else
 #else

-       pthread_create(&t, NULL, NULL, NULL);
-       pthread_detach( t );
+       status = pthread_detach( t );

 #endif
 #endif

+

 #ifdef HAVE_LINUX_THREADS
        pthread_kill_other_threads_np();
 #endif
 #ifdef HAVE_LINUX_THREADS
        pthread_kill_other_threads_np();
 #endif

-], [$2=yes], [$2=no])
+
+       exit( status );
+])
+
+AC_DEFUN([OL_PTHREAD_TEST_PROGRAM],
+[OL_PTHREAD_TEST_INCLUDES
+
+int main(argc, argv)
+       int argc;
+       char **argv;
+{
+OL_PTHREAD_TEST_FUNCTION
+}
+])
+dnl --------------------------------------------------------------------
+AC_DEFUN([OL_PTHREAD_TRY], [# Pthread try link: $1 ($2)
+if test "$ol_link_threads" = no ; then
+       # try $1
+       AC_CACHE_CHECK([for pthread link with $1], [$2], [
+               # save the flags
+               ol_LIBS="$LIBS"
+               LIBS="$1 $LIBS"
+
+               AC_TRY_RUN(OL_PTHREAD_TEST_PROGRAM,
+                       [$2=yes], [$2=no],
+                       [AC_TRY_LINK(OL_PTHREAD_TEST_INCLUDES,OL_PTHREAD_TEST_FUNCTION,
+                               [$2=yes], [$2=no])])

 
                # restore the LIBS
                LIBS="$ol_LIBS"
 
                # restore the LIBS
                LIBS="$ol_LIBS"

-               ])
+       ])

 
 

-               if test $$2 = yes ; then
-                       ol_link_pthreads="$1"
-                       ol_link_threads=posix
-               fi
+       if test $$2 = yes ; then
+               ol_link_pthreads="$1"
+               ol_link_threads=posix

        fi
        fi

+fi

 ])
 dnl
 dnl ====================================================================
 ])
 dnl
 dnl ====================================================================

+dnl Check GNU Pth pthread Header
+dnl
+dnl defines ol_cv_header linux_threads to 'yes' or 'no'
+dnl            'no' implies pthreads.h is not LinuxThreads or pthreads.h
+dnl            doesn't exists.  Existance of pthread.h should separately
+dnl            checked.
+dnl 
+AC_DEFUN([OL_HEADER_GNU_PTH_PTHREAD_H], [
+       AC_CACHE_CHECK([for GNU Pth pthread.h],
+               [ol_cv_header_gnu_pth_pthread_h],
+               [AC_EGREP_CPP(__gnu_pth__,
+                       [#include <pthread.h>
+#ifdef _POSIX_THREAD_IS_GNU_PTH
+       __gnu_pth__;
+#endif
+],
+                       [ol_cv_header_gnu_pth_pthread_h=yes],
+                       [ol_cv_header_gnu_pth_pthread_h=no])
+               ])
+])dnl
+dnl ====================================================================
+dnl Check for NT Threads
+AC_DEFUN([OL_NT_THREADS], [
+       AC_CACHE_CHECK([for NT Threads], [ol_cv_nt_threads], [
+               AC_CHECK_FUNC(_beginthread,
+                       [ol_cv_nt_threads=yes],
+                       [ol_cv_nt_threads=no])
+       ])
+
+       if test $ol_cv_nt_threads = yes ; then
+               AC_DEFINE(HAVE_NT_THREADS,1,[if you have NT Threads])
+       fi
+])
+dnl ====================================================================

 dnl Check LinuxThreads Header
 dnl
 dnl defines ol_cv_header linux_threads to 'yes' or 'no'
 dnl Check LinuxThreads Header
 dnl
 dnl defines ol_cv_header linux_threads to 'yes' or 'no'


@@ -544,7 +731,7 @@ dnl defines ol_cv_sys_linux_threads to 'yes' or 'no'
 dnl    'no' implies pthreads implementation is not LinuxThreads.
 dnl 
 AC_DEFUN([OL_SYS_LINUX_THREADS], [
 dnl    'no' implies pthreads implementation is not LinuxThreads.
 dnl 
 AC_DEFUN([OL_SYS_LINUX_THREADS], [

-       AC_CHECK_FUNC(pthread_kill_other_threads_np)
+       AC_CHECK_FUNCS(pthread_kill_other_threads_np)

        AC_CACHE_CHECK([for LinuxThreads implementation],
                [ol_cv_sys_linux_threads],
                [ol_cv_sys_linux_threads=$ac_cv_func_pthread_kill_other_threads_np])
        AC_CACHE_CHECK([for LinuxThreads implementation],
                [ol_cv_sys_linux_threads],
                [ol_cv_sys_linux_threads=$ac_cv_func_pthread_kill_other_threads_np])


@@ -569,11 +756,41 @@ AC_DEFUN([OL_LINUX_THREADS], [
 ])dnl
 dnl
 dnl ====================================================================
 ])dnl
 dnl
 dnl ====================================================================

+dnl Check for POSIX Regex
+AC_DEFUN([OL_POSIX_REGEX], [
+AC_CACHE_CHECK([for compatible POSIX regex],ol_cv_c_posix_regex,[
+       AC_TRY_RUN([
+#include <sys/types.h>
+#include <regex.h>
+static char *pattern, *string;
+main()
+{
+       int rc;
+       regex_t re;
+
+       pattern = "^A";
+
+       if(regcomp(&re, pattern, 0)) {
+               return -1;
+       }
+       
+       string = "ALL MATCH";
+       
+       rc = regexec(&re, string, 0, (void*)0, 0);
+
+       regfree(&re);
+
+       return rc;
+}],
+       [ol_cv_c_posix_regex=yes],
+       [ol_cv_c_posix_regex=no],
+       [ol_cv_c_posix_regex=cross])])
+])
+dnl
+dnl ====================================================================

 dnl Check if toupper() requires islower() to be called first
 AC_DEFUN([OL_C_UPPER_LOWER],
 dnl Check if toupper() requires islower() to be called first
 AC_DEFUN([OL_C_UPPER_LOWER],

-[
-AC_MSG_CHECKING([if toupper() requires islower()])
-AC_CACHE_VAL(ol_cv_c_upper_lower,[
+[AC_CACHE_CHECK([if toupper() requires islower()],ol_cv_c_upper_lower,[

        AC_TRY_RUN([
 #include <ctype.h>
 main()
        AC_TRY_RUN([
 #include <ctype.h>
 main()


@@ -586,7 +803,6 @@ main()
        [ol_cv_c_upper_lower=no],
        [ol_cv_c_upper_lower=yes],
        [ol_cv_c_upper_lower=safe])])
        [ol_cv_c_upper_lower=no],
        [ol_cv_c_upper_lower=yes],
        [ol_cv_c_upper_lower=safe])])

-AC_MSG_RESULT($ol_cv_c_upper_lower)

 if test $ol_cv_c_upper_lower != no ; then
        AC_DEFINE(C_UPPER_LOWER,1, [define if toupper() requires islower()])
 fi
 if test $ol_cv_c_upper_lower != no ; then
        AC_DEFINE(C_UPPER_LOWER,1, [define if toupper() requires islower()])
 fi


@@ -597,32 +813,33 @@ dnl Check for declaration of sys_errlist in one of stdio.h and errno.h.
 dnl Declaration of sys_errlist on BSD4.4 interferes with our declaration.
 dnl Reported by Keith Bostic.
 AC_DEFUN([OL_SYS_ERRLIST],
 dnl Declaration of sys_errlist on BSD4.4 interferes with our declaration.
 dnl Reported by Keith Bostic.
 AC_DEFUN([OL_SYS_ERRLIST],

-[
-AC_MSG_CHECKING([declaration of sys_errlist])
-AC_CACHE_VAL(ol_cv_dcl_sys_errlist,[
+[AC_CACHE_CHECK([declaration of sys_errlist],ol_cv_dcl_sys_errlist,[

        AC_TRY_COMPILE([
 #include <stdio.h>
 #include <sys/types.h>
        AC_TRY_COMPILE([
 #include <stdio.h>
 #include <sys/types.h>

-#include <errno.h> ],
+#include <errno.h>
+#ifdef WINNT
+#include <stdlib.h>
+#endif ],

        [char *c = (char *) *sys_errlist],
        [char *c = (char *) *sys_errlist],

-       [ol_cv_dcl_sys_errlist=yes],
+       [ol_cv_dcl_sys_errlist=yes
+       ol_cv_have_sys_errlist=yes],

        [ol_cv_dcl_sys_errlist=no])])
        [ol_cv_dcl_sys_errlist=no])])

-AC_MSG_RESULT($ol_cv_dcl_sys_errlist)
+#

 # It's possible (for near-UNIX clones) that sys_errlist doesn't exist
 if test $ol_cv_dcl_sys_errlist = no ; then
        AC_DEFINE(DECL_SYS_ERRLIST,1,
                [define if sys_errlist is not declared in stdio.h or errno.h])
 # It's possible (for near-UNIX clones) that sys_errlist doesn't exist
 if test $ol_cv_dcl_sys_errlist = no ; then
        AC_DEFINE(DECL_SYS_ERRLIST,1,
                [define if sys_errlist is not declared in stdio.h or errno.h])

-       AC_MSG_CHECKING([existence of sys_errlist])
-       AC_CACHE_VAL(ol_cv_have_sys_errlist,[
+
+       AC_CACHE_CHECK([existence of sys_errlist],ol_cv_have_sys_errlist,[

                AC_TRY_LINK([#include <errno.h>],
                        [char *c = (char *) *sys_errlist],
                        [ol_cv_have_sys_errlist=yes],
                        [ol_cv_have_sys_errlist=no])])
                AC_TRY_LINK([#include <errno.h>],
                        [char *c = (char *) *sys_errlist],
                        [ol_cv_have_sys_errlist=yes],
                        [ol_cv_have_sys_errlist=no])])

-       AC_MSG_RESULT($ol_cv_have_sys_errlist)
-       if test $ol_cv_have_sys_errlist = yes ; then
-               AC_DEFINE(HAVE_SYS_ERRLIST,1,
-                       [define if you actually have sys_errlist in your libs])
-       fi
+fi
+if test $ol_cv_have_sys_errlist = yes ; then
+       AC_DEFINE(HAVE_SYS_ERRLIST,1,
+               [define if you actually have sys_errlist in your libs])

 fi
 ])dnl
 dnl
 fi
 ])dnl
 dnl


@@ -639,18 +856,86 @@ AC_DEFUN(OL_C_VOLATILE,
   if test $ol_cv_c_volatile = yes; then
     : 
   else
   if test $ol_cv_c_volatile = yes; then
     : 
   else

-    AC_DEFINE(volatile,)
+    AC_DEFINE(volatile,,[define as empty if volatile is not supported])

   fi
  ])dnl
 dnl
 dnl ====================================================================
   fi
  ])dnl
 dnl
 dnl ====================================================================

+dnl Look for fetch(3)
+AC_DEFUN([OL_LIB_FETCH],
+[ol_LIBS=$LIBS
+LIBS="-lfetch -lcom_err $LIBS"
+AC_CACHE_CHECK([fetch(3) library],ol_cv_lib_fetch,[
+       AC_TRY_LINK([
+#include <sys/param.h>
+#include <stdio.h>
+#include <fetch.h>],
+       [struct url *u = fetchParseURL("file:///"); ],
+       [ol_cv_lib_fetch=yes],
+       [ol_cv_lib_fetch=no])])
+LIBS=$ol_LIBS
+if test $ol_cv_lib_fetch != no ; then
+       ol_link_fetch="-lfetch -lcom_err"
+       AC_DEFINE(HAVE_FETCH,1,
+               [define if you actually have FreeBSD fetch(3)])
+fi
+])dnl
+dnl
+dnl ====================================================================

 dnl Define sig_atomic_t if not defined in signal.h
 AC_DEFUN(OL_TYPE_SIG_ATOMIC_T,
  [AC_CACHE_CHECK(for sig_atomic_t, ol_cv_type_sig_atomic_t,
     [AC_TRY_COMPILE([#include <signal.h>], [sig_atomic_t atomic;],
                ol_cv_type_sig_atomic_t=yes, ol_cv_type_sig_atomic_t=no)])
   if test $ol_cv_type_sig_atomic_t = no; then
 dnl Define sig_atomic_t if not defined in signal.h
 AC_DEFUN(OL_TYPE_SIG_ATOMIC_T,
  [AC_CACHE_CHECK(for sig_atomic_t, ol_cv_type_sig_atomic_t,
     [AC_TRY_COMPILE([#include <signal.h>], [sig_atomic_t atomic;],
                ol_cv_type_sig_atomic_t=yes, ol_cv_type_sig_atomic_t=no)])
   if test $ol_cv_type_sig_atomic_t = no; then

-    AC_DEFINE(sig_atomic_t, int)
+    AC_DEFINE(sig_atomic_t,int,
+               [define to atomic type if sig_atomic_t is not available])
+  fi
+ ])dnl
+dnl
+dnl ====================================================================
+dnl Define socklen_t if not defined in sys/types.h or sys/socket.h
+AC_DEFUN(OL_TYPE_SOCKLEN_T,
+ [AC_CACHE_CHECK(for socklen_t, ol_cv_type_socklen_t,
+    [AC_TRY_COMPILE([
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+], [socklen_t len;],
+               ol_cv_type_socklen_t=yes, ol_cv_type_socklen_t=no)])
+  if test $ol_cv_type_socklen_t = no; then
+    AC_DEFINE(socklen_t, int,
+               [define to int if socklen_t is not available])
+  fi
+ ])dnl
+dnl
+dnl ====================================================================
+dnl Define inet_aton is available
+AC_DEFUN(OL_FUNC_INET_ATON,
+ [AC_CACHE_CHECK([for inet_aton()], ol_cv_func_inet_aton,
+    [AC_TRY_LINK([
+#ifdef HAVE_SYS_TYPES_H
+#      include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#      include <sys/socket.h>
+#      ifdef HAVE_SYS_SELECT_H
+#              include <sys/select.h>
+#      endif
+#      include <netinet/in.h>
+#      ifdef HAVE_ARPA_INET_H
+#              include <arpa/inet.h>
+#      endif
+#endif
+], [struct in_addr in;
+int rc = inet_aton( "255.255.255.255", &in );],
+               ol_cv_func_inet_aton=yes, ol_cv_func_inet_aton=no)])
+  if test $ol_cv_func_inet_aton != no; then
+    AC_DEFINE(HAVE_INET_ATON, 1,
+               [define to you inet_aton(3) is available])

   fi
  ])dnl
 dnl
   fi
  ])dnl
 dnl


@@ -660,13 +945,31 @@ AC_DEFUN(OL_FUNC_CTIME_R_NARGS,
  [AC_CACHE_CHECK(number of arguments of ctime_r, ol_cv_func_ctime_r_nargs,
    [AC_TRY_COMPILE([#include <time.h>],
                [time_t ti; char *buffer; ctime_r(&ti,buffer,32);],
  [AC_CACHE_CHECK(number of arguments of ctime_r, ol_cv_func_ctime_r_nargs,
    [AC_TRY_COMPILE([#include <time.h>],
                [time_t ti; char *buffer; ctime_r(&ti,buffer,32);],

-                       ol_cv_func_ctime_r_nargs=3,
-                       [AC_TRY_COMPILE([#include <time.h>],
-                               [time_t ti; char *buffer; ctime_r(&ti,buffer);],
-                                       ol_cv_func_ctime_r_nargs=2,
-                                       ol_cv_func_ctime_r_nargs=0)])])
+                       ol_cv_func_ctime_r_nargs3=yes,
+                       ol_cv_func_ctime_r_nargs3=no)
+
+       AC_TRY_COMPILE([#include <time.h>],
+               [time_t ti; char *buffer; ctime_r(&ti,buffer);],
+                       ol_cv_func_ctime_r_nargs2=yes,
+                       ol_cv_func_ctime_r_nargs2=no)
+
+       if test $ol_cv_func_ctime_r_nargs3 = yes -a \
+               $ol_cv_func_ctime_r_nargs2 = no ; then
+
+               ol_cv_func_ctime_r_nargs=3
+
+       elif test $ol_cv_func_ctime_r_nargs3 = no -a \
+               $ol_cv_func_ctime_r_nargs2 = yes ; then
+
+               ol_cv_func_ctime_r_nargs=2
+
+       else
+               ol_cv_func_ctime_r_nargs=0
+       fi
+  ])
+

   if test $ol_cv_func_ctime_r_nargs -gt 1 ; then
   if test $ol_cv_func_ctime_r_nargs -gt 1 ; then

-    AC_DEFINE_UNQUOTED(CTIME_R_NARGS, $ol_cv_func_ctime_r_nargs,
+       AC_DEFINE_UNQUOTED(CTIME_R_NARGS, $ol_cv_func_ctime_r_nargs,

                [set to the number of arguments ctime_r() expects])
   fi
 ])dnl
                [set to the number of arguments ctime_r() expects])
   fi
 ])dnl


@@ -697,19 +1000,36 @@ AC_DEFUN(OL_FUNC_GETHOSTBYNAME_R_NARGS,
                int bufsize=BUFSIZE;int h_errno;
                (void)gethostbyname_r("segovia.cs.purdue.edu", &hent,
                        buffer, bufsize, &h_errno);],
                int bufsize=BUFSIZE;int h_errno;
                (void)gethostbyname_r("segovia.cs.purdue.edu", &hent,
                        buffer, bufsize, &h_errno);],

-               ol_cv_func_gethostbyname_r_nargs=5, 
-               [AC_TRY_COMPILE([#include <sys/types.h>
+               ol_cv_func_gethostbyname_r_nargs5=yes, 
+               ol_cv_func_gethostbyname_r_nargs5=no)
+
+       AC_TRY_COMPILE([#include <sys/types.h>

 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #define BUFSIZE (sizeof(struct hostent)+10)],
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #define BUFSIZE (sizeof(struct hostent)+10)],

-                       [struct hostent hent;struct hostent *rhent;
-                       char buffer[BUFSIZE];
-                       int bufsize=BUFSIZE;int h_errno;
-                       (void)gethostbyname_r("localhost", &hent, buffer, bufsize,
-                               &rhent, &h_errno);],
-                       ol_cv_func_gethostbyname_r_nargs=6,
-                       ol_cv_func_gethostbyname_r_nargs=0)])])
+               [struct hostent hent;struct hostent *rhent;
+               char buffer[BUFSIZE];
+               int bufsize=BUFSIZE;int h_errno;
+               (void)gethostbyname_r("localhost", &hent, buffer, bufsize,
+                       &rhent, &h_errno);],
+               ol_cv_func_gethostbyname_r_nargs6=yes,
+               ol_cv_func_gethostbyname_r_nargs6=no)
+
+       if test $ol_cv_func_gethostbyname_r_nargs5 = yes -a \
+               $ol_cv_func_gethostbyname_r_nargs6 = no ; then
+
+               ol_cv_func_gethostbyname_r_nargs=5
+
+       elif test $ol_cv_func_gethostbyname_r_nargs5 = no -a \
+               $ol_cv_func_gethostbyname_r_nargs6 = yes ; then
+
+               ol_cv_func_gethostbyname_r_nargs=6
+
+       else
+               ol_cv_func_gethostbyname_r_nargs=0
+       fi
+  ])

   if test $ol_cv_func_gethostbyname_r_nargs -gt 1 ; then
        AC_DEFINE_UNQUOTED(GETHOSTBYNAME_R_NARGS,
                $ol_cv_func_gethostbyname_r_nargs,
   if test $ol_cv_func_gethostbyname_r_nargs -gt 1 ; then
        AC_DEFINE_UNQUOTED(GETHOSTBYNAME_R_NARGS,
                $ol_cv_func_gethostbyname_r_nargs,


@@ -732,22 +1052,39 @@ AC_DEFUN(OL_FUNC_GETHOSTBYADDR_R_NARGS,
            int bufsize=BUFSIZE;int h_errno;
                (void)gethostbyaddr_r( (void *)&(add.s_addr),
                        alen, AF_INET, &hent, buffer, bufsize, &h_errno);],
            int bufsize=BUFSIZE;int h_errno;
                (void)gethostbyaddr_r( (void *)&(add.s_addr),
                        alen, AF_INET, &hent, buffer, bufsize, &h_errno);],

-               ol_cv_func_gethostbyaddr_r_nargs=7,
-               [AC_TRY_COMPILE([#include <sys/types.h>
+               ol_cv_func_gethostbyaddr_r_nargs7=yes,
+               ol_cv_func_gethostbyaddr_r_nargs7=no)
+
+       AC_TRY_COMPILE([#include <sys/types.h>

 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #define BUFSIZE (sizeof(struct hostent)+10)],
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #define BUFSIZE (sizeof(struct hostent)+10)],

-                       [struct hostent hent;
-                       struct hostent *rhent; char buffer[BUFSIZE]; 
-                       struct in_addr add;
-                       size_t alen=sizeof(struct in_addr);
-                       int bufsize=BUFSIZE;int h_errno;
-                       (void)gethostbyaddr_r( (void *)&(add.s_addr),
-                               alen, AF_INET, &hent, buffer, bufsize, 
-                               &rhent, &h_errno);],
-                       ol_cv_func_gethostbyaddr_r_nargs=8,
-                       ol_cv_func_gethostbyaddr_r_nargs=0)])])
+               [struct hostent hent;
+               struct hostent *rhent; char buffer[BUFSIZE]; 
+               struct in_addr add;
+               size_t alen=sizeof(struct in_addr);
+               int bufsize=BUFSIZE;int h_errno;
+               (void)gethostbyaddr_r( (void *)&(add.s_addr),
+                       alen, AF_INET, &hent, buffer, bufsize, 
+                       &rhent, &h_errno);],
+               ol_cv_func_gethostbyaddr_r_nargs8=yes,
+               ol_cv_func_gethostbyaddr_r_nargs8=no)
+
+       if test $ol_cv_func_gethostbyaddr_r_nargs7 = yes -a \
+               $ol_cv_func_gethostbyaddr_r_nargs8 = no ; then
+
+               ol_cv_func_gethostbyaddr_r_nargs=7
+
+       elif test $ol_cv_func_gethostbyaddr_r_nargs7 = no -a \
+               $ol_cv_func_gethostbyaddr_r_nargs8 = yes ; then
+
+               ol_cv_func_gethostbyaddr_r_nargs=8
+
+       else
+               ol_cv_func_gethostbyaddr_r_nargs=0
+       fi
+  ])

   if test $ol_cv_func_gethostbyaddr_r_nargs -gt 1 ; then
     AC_DEFINE_UNQUOTED(GETHOSTBYADDR_R_NARGS,
                $ol_cv_func_gethostbyaddr_r_nargs,
   if test $ol_cv_func_gethostbyaddr_r_nargs -gt 1 ; then
     AC_DEFINE_UNQUOTED(GETHOSTBYADDR_R_NARGS,
                $ol_cv_func_gethostbyaddr_r_nargs,