Add global access control.

[openldap] / build / openldap.m4

diff --git a/build/openldap.m4 b/build/openldap.m4
index e04cebc9d58a6d9fa6880e2f12b2c5cb93846555..2db4042fb098a5a0d04b58a88f2a266a5c748844 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


@@ -120,8 +149,7 @@ dnl
 dnl ====================================================================
 dnl Check if system uses EBCDIC instead of ASCII
 AC_DEFUN([OL_CPP_EBCDIC], [# test for EBCDIC
 dnl ====================================================================
 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>


@@ -129,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


@@ -183,15 +210,13 @@ 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
 if test $ol_cv_struct_passwd_pw_gecos = yes ; then
        AC_DEFINE(HAVE_PW_GECOS,1, [define if struct passwd has pw_gecos])
 fi


@@ -200,156 +225,189 @@ dnl
 dnl --------------------------------------------------------------------
 dnl Check if struct passwd has pw_passwd
 AC_DEFUN([OL_STRUCT_PASSWD_PW_PASSWD], [# test for pw_passwd in struct passwd
 dnl --------------------------------------------------------------------
 dnl Check if struct passwd has pw_passwd
 AC_DEFUN([OL_STRUCT_PASSWD_PW_PASSWD], [# test for pw_passwd in struct passwd

-AC_MSG_CHECKING([struct passwd for pw_passwd])
-AC_CACHE_VAL(ol_cv_struct_passwd_pw_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])])
        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])])

-AC_MSG_RESULT($ol_cv_struct_passwd_pw_passwd)

 if test $ol_cv_struct_passwd_pw_passwd = yes ; then
        AC_DEFINE(HAVE_PW_PASSWD,1, [define if struct passwd has pw_passwd])
 fi
 ])
 dnl
 dnl ====================================================================
 if test $ol_cv_struct_passwd_pw_passwd = yes ; then
        AC_DEFINE(HAVE_PW_PASSWD,1, [define if struct passwd has pw_passwd])
 fi
 ])
 dnl
 dnl ====================================================================

-dnl Check if db.h is Berkeley DB2
+dnl Berkeley DB macros

 dnl
 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 --------------------------------------------------------------------

-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])
+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"
+
+       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"
 ])
        LIBS="$ol_LIBS"
 ])

-])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
-])
- 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 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
-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! 

 
 

-       ol_cv_header_db=$ac_cv_header_db_185_h
-else
-       ol_cv_header_db=$ac_cv_header_db_h
+       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 ) {
+#if (DB_VERSION_MAJOR > 3) || (DB_VERSION_MINOR >= 1)
+               rc = env->open( env, NULL, flags, 0 );
+#else
+               rc = env->open( env, NULL, NULL, flags, 0 );
+#endif
+       }
+
+#else
+       DB_ENV env;
+       memset( &env, '\0', sizeof(env) );
+
+       rc = db_appinit( NULL, NULL, &env, flags );
+
+       if( rc == 0 ) {
+               db_appexit( &env );
+       }
+#endif
+#if DB_VERSION_MAJOR > 2
+#if (DB_VERSION_MAJOR > 3) || (DB_VERSION_MINOR >= 1)
+       env->remove( env, NULL, DB_FORCE);
+#else
+       env->remove( env, NULL, NULL, DB_FORCE);
+#endif
+#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


@@ -511,7 +569,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)
 


@@ -519,7 +577,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)
 


@@ -534,46 +592,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'


@@ -600,7 +741,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])


@@ -627,8 +768,7 @@ dnl
 dnl ====================================================================
 dnl Check for POSIX Regex
 AC_DEFUN([OL_POSIX_REGEX], [
 dnl ====================================================================
 dnl Check for POSIX Regex
 AC_DEFUN([OL_POSIX_REGEX], [

-AC_MSG_CHECKING([for compatible POSIX regex])
-AC_CACHE_VAL(ol_cv_c_posix_regex,[
+AC_CACHE_CHECK([for compatible POSIX regex],ol_cv_c_posix_regex,[

        AC_TRY_RUN([
 #include <sys/types.h>
 #include <regex.h>
        AC_TRY_RUN([
 #include <sys/types.h>
 #include <regex.h>


@@ -655,15 +795,12 @@ main()
        [ol_cv_c_posix_regex=yes],
        [ol_cv_c_posix_regex=no],
        [ol_cv_c_posix_regex=cross])])
        [ol_cv_c_posix_regex=yes],
        [ol_cv_c_posix_regex=no],
        [ol_cv_c_posix_regex=cross])])

-AC_MSG_RESULT($ol_cv_c_posix_regex)

 ])
 dnl
 dnl ====================================================================
 dnl Check if toupper() requires islower() to be called first
 AC_DEFUN([OL_C_UPPER_LOWER],
 ])
 dnl
 dnl ====================================================================
 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()


@@ -676,7 +813,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


@@ -687,32 +823,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


@@ -729,23 +866,45 @@ 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 ====================================================================
   fi
  ])dnl
 dnl
 dnl ====================================================================

-dnl Define socklen_t if not defined in signal.h
+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([
 AC_DEFUN(OL_TYPE_SOCKLEN_T,
  [AC_CACHE_CHECK(for socklen_t, ol_cv_type_socklen_t,
     [AC_TRY_COMPILE([


@@ -758,7 +917,35 @@ AC_DEFUN(OL_TYPE_SOCKLEN_T,
 ], [socklen_t len;],
                ol_cv_type_socklen_t=yes, ol_cv_type_socklen_t=no)])
   if test $ol_cv_type_socklen_t = no; then
 ], [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)
+    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


@@ -768,13 +955,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


@@ -805,19 +1010,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,


@@ -840,22 +1062,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,