Diff for /configure.in between versions 1.2.2.31 and 1.2.2.31.2.28

version 1.2.2.31, 1999/01/19 22:14:38 version 1.2.2.31.2.28, 1999/09/22 16:01:40
Line 7  dnl license is available at http://www.O Line 7  dnl license is available at http://www.O
 dnl in file LICENSE in the top-level directory of the distribution.  dnl in file LICENSE in the top-level directory of the distribution.
 dnl  dnl
   
   dnl Disable config.cache!
   define([AC_CACHE_LOAD], )dnl
   define([AC_CACHE_SAVE], )dnl
   
 dnl Configure.in for OpenLDAP  dnl Configure.in for OpenLDAP
 AC_INIT(include/ldap.h)dnl  AC_INIT(include/ldap.h)dnl
 AC_CONFIG_AUX_DIR(build)dnl  AC_CONFIG_AUX_DIR(build)dnl
 AM_INIT_AUTOMAKE(openldap,[1.1], [no ac_define])dnl  AM_INIT_AUTOMAKE(openldap,[1.2], [no ac_define])dnl
   
 dnl Do not use AutoConf 2.12; it produces a configuration script  dnl We use autoconf features new to 2.13.
 dnl that causes an "internal 2K buffer" error on HPUX when run  dnl     aclocal.m4 should be built using aclocal from automake 1.4
 dnl with /bin/sh.  Autoconf 2.10 seems to be okay.  AC_PREREQ(2.13)dnl Required Autoconf version
 AC_PREREQ(2.10)dnl Required Autoconf version  
   
 AC_CONFIG_HEADER(include/portable.h)dnl  AC_CONFIG_HEADER(include/portable.h)dnl
   
Line 40  AC_ARG_WITH(subdir, [  --with-subdir=DIR Line 43  AC_ARG_WITH(subdir, [  --with-subdir=DIR
 AC_SUBST(ldap_subdir)dnl  AC_SUBST(ldap_subdir)dnl
   
 OL_ARG_ENABLE(debug,[  --enable-debug   enable debugging], yes)dnl  OL_ARG_ENABLE(debug,[  --enable-debug   enable debugging], yes)dnl
 dnl OL_ARG_ENABLE(syslog,[  --enable-syslog     enable syslog support], auto)dnl  
 OL_ARG_ENABLE(proctitle,[  --enable-proctitle   enable proctitle support], yes)dnl  OL_ARG_ENABLE(proctitle,[  --enable-proctitle   enable proctitle support], yes)dnl
 OL_ARG_ENABLE(libui,[  --enable-libui   enable library user interface], yes)dnl  OL_ARG_ENABLE(libui,[  --enable-libui   enable library user interface], yes)dnl
 OL_ARG_ENABLE(cache,[  --enable-cache   enable caching], yes)dnl  OL_ARG_ENABLE(cache,[  --enable-cache   enable caching], yes)dnl
Line 51  OL_ARG_ENABLE(x_compile,[  --enable-x-co Line 53  OL_ARG_ENABLE(x_compile,[  --enable-x-co
         no, [yes no])dnl          no, [yes no])dnl
   
 dnl General "with" options  dnl General "with" options
   OL_ARG_ENABLE(dmalloc,[  --enable-dmalloc       enable debug malloc support], no)dnl
   
 OL_ARG_WITH(kerberos,[  --with-kerberos use Kerberos],  OL_ARG_WITH(kerberos,[  --with-kerberos use Kerberos],
         auto, [auto k5 k4 afs yes no])          auto, [auto k5 k4 afs yes no])
 OL_ARG_WITH(threads,[  --with-threads   use threads],  OL_ARG_WITH(threads,[  --with-threads   use threads],
Line 77  OL_ARG_ENABLE(rlookups,[    --enable-rlo Line 81  OL_ARG_ENABLE(rlookups,[    --enable-rlo
 dnl SLAPD Backend options  dnl SLAPD Backend options
 OL_ARG_ENABLE(ldbm,[    --enable-ldbm   enable ldbm backend], yes)dnl  OL_ARG_ENABLE(ldbm,[    --enable-ldbm   enable ldbm backend], yes)dnl
 OL_ARG_WITH(ldbm_api,[      --with-ldbm-api     use LDBM API], auto,  OL_ARG_WITH(ldbm_api,[      --with-ldbm-api     use LDBM API], auto,
         [auto db2 db gdbm ndbm manual])          [auto db2 db mdbm gdbm ndbm manual])
 OL_ARG_WITH(ldbm_type,[      --with-ldbm-type   use LDBM type], auto,  OL_ARG_WITH(ldbm_type,[      --with-ldbm-type   use LDBM type], auto,
         [auto btree hash])          [auto btree hash])
   
Line 95  dnl AM_ENABLE_SHARED Line 99  dnl AM_ENABLE_SHARED
   
 dnl General "enable" options  dnl General "enable" options
 # validate options  # validate options
 if test $ol_enable_referrals = no ; then  if test $ol_enable_dns = yes ; then
         if test $ol_enable_dns = yes ; then          if test $ol_enable_referrals = no ; then
                 AC_MSG_WARN([dns disabled, ignoring --enable-dns argument])                  AC_MSG_ERROR([DNS requires --enable-referrals])
           fi
           if test $ol_enable_referrals = auto ; then
                   AC_MSG_WARN([DNS requires referrals, adding --enable-referrals])
                   ol_enable_referrals=yes
         fi          fi
         ol_enable_dns=no  
 fi  fi
   
 if test $ol_enable_slapd = no ; then  if test $ol_enable_slapd = no ; then
Line 172  else Line 179  else
                 $ol_with_ldbm_type = btree ; then                  $ol_with_ldbm_type = btree ; then
                 AC_MSG_ERROR([GDBM only supports LDBM type hash])                  AC_MSG_ERROR([GDBM only supports LDBM type hash])
         fi          fi
           if test $ol_with_ldbm_api = mdbm -a \
                   $ol_with_ldbm_type = btree ; then
                   AC_MSG_ERROR([MDBM only supports LDBM type hash])
           fi
         if test $ol_with_ldbm_api = ndbm -a \          if test $ol_with_ldbm_api = ndbm -a \
                 $ol_with_ldbm_type = btree ; then                  $ol_with_ldbm_type = btree ; then
                 AC_MSG_ERROR([NDBM only supports LDBM type hash])                  AC_MSG_ERROR([NDBM only supports LDBM type hash])
Line 243  AC_AIX Line 254  AC_AIX
 AC_ISC_POSIX  AC_ISC_POSIX
 AC_MINIX  AC_MINIX
   
   dnl BeOS requires -lbe -lroot -lnet
   AC_CHECK_LIB(be, be_app,
           [LIBS="$LIBS -lbe -lroot -lnet"], :,
           [-lroot -lnet])
   
 dnl OpenLDAP requires STDC features  dnl OpenLDAP requires STDC features
 AM_PROG_CC_STDC  AM_PROG_CC_STDC
 if test "X${am_cv_prog_cc_stdc}" = "Xno" ; then  if test "X${am_cv_prog_cc_stdc}" = "Xno" ; then
Line 290  AC_CHECK_LIB(V3, sigset) Line 306  AC_CHECK_LIB(V3, sigset)
 # ISODE tests  # ISODE tests
 ol_link_isode=no  ol_link_isode=no
 if test $ol_enable_ldapd != no ; then  if test $ol_enable_ldapd != no ; then
           AC_MSG_WARN([ldapd support deprecated.  Manual intervention required.])
         dnl look for ISODE libraries          dnl look for ISODE libraries
         AC_CHECK_LIB(xtpp, main, [          AC_CHECK_LIB(xtpp, main, [
                 ol_link_isode=yes                  ol_link_isode=yes
                 AC_DEFINE(HAVE_XTPP,1)                  AC_DEFINE(HAVE_XTPP,1, [define if you have -lxttp])
                 LDAPD_LIBS="$LDAPD_LIBS -lxtpp -lxtdsap -lxtisode -losi"                  LDAPD_LIBS="$LDAPD_LIBS -lxtpp -lxtdsap -lxtisode -losi"
                 ],:,[-lxtdsap -lxtisode -losi])                  ],:,[-lxtdsap -lxtisode -losi])
         AC_CHECK_LIB(dsap, main, [          AC_CHECK_LIB(dsap, main, [
                 ol_link_isode=yes                  ol_link_isode=yes
                 AC_DEFINE(HAVE_DSAP,1)                  AC_DEFINE(HAVE_DSAP,1, [define if you have -ldsap])
                 LDAPD_LIBS="$LDAPD_LIBS -ldsap"                  LDAPD_LIBS="$LDAPD_LIBS -ldsap"
                 ],:,[-lisode])                  ],:,[-lisode])
         AC_CHECK_LIB(isode, main, [          AC_CHECK_LIB(isode, main, [
                 ol_link_isode=yes                  ol_link_isode=yes
                 AC_DEFINE(HAVE_ISODE,1)                  AC_DEFINE(HAVE_ISODE,1, [define if you have -lisode])
                 LDAPD_LIBS="$LDAPD_LIBS -lisode"                  LDAPD_LIBS="$LDAPD_LIBS -lisode"
                 ],:)                  ],:)
 fi  fi
   
 if test $ol_link_isode != no; then  if test $ol_link_isode != no; then
         AC_CHECK_LIB(pp, main, [          AC_CHECK_LIB(pp, main, [
                 AC_DEFINE(HAVE_PP,1)                  AC_DEFINE(HAVE_PP,1, [define if you have -lpp])
                 LDAPD_LIBS="-lpp $LDAPD_LIBS"                  LDAPD_LIBS="-lpp $LDAPD_LIBS"
                 ],:)                  ],:)
   
Line 333  if test $ol_with_kerberos = auto -o $ol_ Line 350  if test $ol_with_kerberos = auto -o $ol_
                         ol_with_kerberos=found                          ol_with_kerberos=found
                         ol_link_kerberos=yes                          ol_link_kerberos=yes
   
                         AC_DEFINE(HAVE_KERBEROS)  
                         KRB_LIBS="-lkrb4 -lkrb5 -ldes425"                          KRB_LIBS="-lkrb4 -lkrb5 -ldes425"
   
                           LIBS="$KRB_LIBS $LIBS"
   
                           AC_CACHE_CHECK([for des_debug in Kerberos libraries],
                                   [ol_cv_var_des_debug], [
                                   dnl save the flags
                                   save_LIBS="$LIBS"
                                   LIBS="$KRB_LIBS $LIBS"
                                   AC_TRY_LINK([
   #include <kerberosIV/krb.h>
   #include <kerberosIV/des.h>
   extern int des_debug;
   ],[
   des_debug = 1;
   ],                              ol_cv_var_des_debug=yes, ol_cv_var_des_debug=no)
                                   dnl restore the LIBS
                                   LIBS="$save_LIBS"
                           ])
   
                           if test $ol_cv_var_des_debug = yes ; then
                                   AC_DEFINE(HAVE_DES_DEBUG,1,
                                           [define if you have Kerberos des_debug])
                           fi
   
                           LIBS="$save_LIBS"
                 fi                  fi
         fi          fi
 fi  fi
Line 349  if test $ol_with_kerberos = auto -o $ol_ Line 390  if test $ol_with_kerberos = auto -o $ol_
                         ol_with_kerberos=found                          ol_with_kerberos=found
                         ol_link_kerberos=yes                          ol_link_kerberos=yes
   
                         AC_DEFINE(HAVE_KERBEROS)  
                         KRB_LIBS="-lkrb -ldes"                          KRB_LIBS="-lkrb -ldes"
                 fi                  fi
         fi          fi
 fi  fi
   
 dnl     if test $ol_link_kerberos = yes ; then  if test $ol_link_kerberos = yes ; then
 dnl             save_LIBS=$LIBS          AC_DEFINE(HAVE_KERBEROS, 1, [define if you have Kerberos])
 dnl             LIBS="$KRB_LIBS $LIBS"  fi
 dnl             AC_CHECK_FUNCS(des_string_to_key)  
 dnl             LIBS=$save_LIBS  
 dnl fi  
   
 ol_link_threads=no  ol_link_threads=no
 if test $ol_with_threads = auto -o $ol_with_threads = yes \  if test $ol_with_threads = auto -o $ol_with_threads = yes \
Line 372  if test $ol_with_threads = auto -o $ol_w Line 409  if test $ol_with_threads = auto -o $ol_w
                 OL_POSIX_THREAD_VERSION                  OL_POSIX_THREAD_VERSION
   
                 if test $ol_cv_pthread_version = final ; then                  if test $ol_cv_pthread_version = final ; then
                         AC_DEFINE(HAVE_PTHREADS_FINAL)                          AC_DEFINE(HAVE_PTHREADS_FINAL,1,
                                   [define if pthreads API compatible with final spec])
                 elif test $ol_cv_pthread_version = draft4 ; then                  elif test $ol_cv_pthread_version = draft4 ; then
                         AC_DEFINE(HAVE_PTHREADS_D4)                          AC_DEFINE(HAVE_PTHREADS_D4,1,
                                   [define if pthreads API compatible with draft4 spec])
                 else                  else
                         AC_MSG_ERROR([unknown pthread version])                          AC_MSG_ERROR([unknown pthread version])
                 fi                  fi
Line 385  if test $ol_with_threads = auto -o $ol_w Line 424  if test $ol_with_threads = auto -o $ol_w
                 OL_LINUX_THREADS                  OL_LINUX_THREADS
   
                 if test $ol_cv_linux_threads = yes ; then                  if test $ol_cv_linux_threads = yes ; then
                         AC_DEFINE(HAVE_LINUX_THREADS,1)                          AC_DEFINE(HAVE_LINUX_THREADS,1,
                                   [define if you have LinuxThreads])
                 fi                  fi
   
                 dnl Now the hard part, how to link                  dnl Now the hard part, how to link?
                   dnl
                   dnl currently supported checks:
                   dnl
                   dnl Check for no flags 
                   dnl     pthread_create() in $LIBS
                   dnl
                   dnl Check special pthread (final) flags
                   dnl     pthread_create() with -kthread (FreeBSD)
                   dnl     pthread_create() with -pthread (FreeBSD/Digital Unix)
                   dnl     pthread_create() with -pthreads (?)
                   dnl     pthread_create() with -thread (?)
                   dnl     pthread_create() with -mt (Solaris)
                   dnl
                   dnl Check pthread (final) libraries
                   dnl     pthread_mutex_unlock() in -lpthread -lmach -lexc -lc_r (OSF/1)
                   dnl     pthread_mutex_lock() in -lpthread -lmach -lexc (OSF/1)
                   dnl     pthread_mutex_trylock() in -lpthread -lexc (OSF/1)
                   dnl     pthread_create() in -lpthread (many)
                   dnl     pthread_create() in -lc_r (FreeBSD)
                   dnl     pthread_create() in -lpthreads (many)
                   dnl     pthread_join() -Wl,-woff,85 -lpthreads (IRIX)
                   dnl     pthread_create() in HP-UX -lpthread (HP-UX 11)
                   dnl
                   dnl Check pthread (draft4) flags (to be depreciated)
                   dnl     pthread_create() with -threads (OSF/1)
                   dnl
                   dnl Check pthread (final) libraries (to be depreciated)
                   dnl     pthread_mutex_unlock() in -lpthreads -lmach -lexc -lc_r (OSF/1)
                   dnl     pthread_mutex_lock() in -lpthreads -lmach -lexc (OSF/1)
                   dnl     pthread_mutex_trylock() in -lpthreads -lexc (OSF/1)
                   dnl
   
                 dnl Check for pthread support in current $LIBS                  dnl pthread_create in $LIBS
                 AC_CHECK_FUNC(pthread_create,[ol_link_threads=yes])                  AC_CHECK_FUNC(pthread_create,[ol_link_threads=yes])
   
                 if test $ol_link_threads = no ; then                  if test $ol_link_threads = no ; then
                           dnl try -kthread
                           AC_CACHE_CHECK([for pthread_create with -kthread],
                                   [ol_cv_kthread_flag], [
                                   dnl save the flags
                                   save_LIBS="$LIBS"
                                   LIBS="-kthread $LIBS"
                                   AC_TRY_LINK([#include <pthread.h>],
                                           [pthread_create(NULL,NULL,NULL,NULL);],
                                           [ol_cv_kthread_flag=yes], [ol_cv_kthread_flag=no])
                                   dnl restore the LIBS
                                   LIBS="$save_LIBS"
                           ])
   
                           if test $ol_cv_kthread_flag = yes ; then
                                   LTHREAD_LIBS="$LTHREAD_LIBS -kthread"
                                   ol_link_threads=posix
                           fi
                   fi
   
                   if test $ol_link_threads = no ; then
                         dnl try -pthread                          dnl try -pthread
                         AC_CACHE_CHECK([for pthread_create with -pthread],                          AC_CACHE_CHECK([for pthread_create with -pthread],
                                 [ol_cv_pthread_flag], [                                  [ol_cv_pthread_flag], [
                                 dnl save the flags                                  dnl save the flags
                                 save_LIBS="$LIBS"                                  save_LIBS="$LIBS"
                                 LIBS="-pthread $LIBS"                                  LIBS="-pthread $LIBS"
                                 AC_TRY_LINK([char pthread();],[                                  AC_TRY_LINK([#include <pthread.h>],
                                         pthread_create();                                          [pthread_create(NULL,NULL,NULL,NULL);],
                                         ], ol_cv_pthread_flag=yes, ol_cv_pthread_flag=no)                                          [ol_cv_pthread_flag=yes], [ol_cv_pthread_flag=no])
                                 dnl restore the LIBS                                  dnl restore the LIBS
                                 LIBS="$save_LIBS"                                  LIBS="$save_LIBS"
                         ])                          ])
Line 420  if test $ol_with_threads = auto -o $ol_w Line 511  if test $ol_with_threads = auto -o $ol_w
                                 dnl save the flags                                  dnl save the flags
                                 save_LIBS="$LIBS"                                  save_LIBS="$LIBS"
                                 LIBS="-pthreads $LIBS"                                  LIBS="-pthreads $LIBS"
                                 AC_TRY_LINK([char pthread();],[                                  AC_TRY_LINK([#include <pthread.h>],
                                         pthread_create();                                          [pthread_create(NULL,NULL,NULL,NULL);],
                                         ], ol_cv_pthreads_flag=yes, ol_cv_pthreads_flag=no)                                          [ol_cv_pthreads_flag=yes], [ol_cv_pthreads_flag=no])
                                 dnl restore the LIBS                                  dnl restore the LIBS
                                 LIBS="$save_LIBS"                                  LIBS="$save_LIBS"
                         ])                          ])
Line 440  if test $ol_with_threads = auto -o $ol_w Line 531  if test $ol_with_threads = auto -o $ol_w
                                 dnl save the flags                                  dnl save the flags
                                 save_LIBS="$LIBS"                                  save_LIBS="$LIBS"
                                 LIBS="-thread $LIBS"                                  LIBS="-thread $LIBS"
                                 AC_TRY_LINK([char pthread();],[                                  AC_TRY_LINK([char pthread_create();],
                                         pthread_create();                                          [pthread_create();],
                                         ], ol_cv_thread_flag=yes, ol_cv_thread_flag=no)                                          [ol_cv_thread_flag=yes], [ol_cv_thread_flag=no])
                                 dnl restore the LIBS                                  dnl restore the LIBS
                                 LIBS="$save_LIBS"                                  LIBS="$save_LIBS"
                         ])                          ])
Line 454  if test $ol_with_threads = auto -o $ol_w Line 545  if test $ol_with_threads = auto -o $ol_w
                 fi                  fi
   
                 if test $ol_link_threads = no ; then                  if test $ol_link_threads = no ; then
                         dnl try DEC Threads -lpthread -lexc                          dnl try -mt
                           AC_CACHE_CHECK([for pthread_create with -mt],
                                   [ol_cv_thread_flag], [
                                   dnl save the flags
                                   save_LIBS="$LIBS"
                                   LIBS="-mt $LIBS"
                                   AC_TRY_LINK([char pthread_create();],
                                           [pthread_create();],
                                           [ol_cv_thread_flag=yes], [ol_cv_thread_flag=no])
                                   dnl restore the LIBS
                                   LIBS="$save_LIBS"
                           ])
   
                           if test $ol_cv_thread_flag = yes ; then
                                   LTHREAD_LIBS="$LTHREAD_LIBS -mt"
                                   ol_link_threads=posix
                           fi
                   fi
   
                   if test $ol_link_threads = no ; then
                           dnl try DEC Threads -lpthread -lmach -lexc -lc_r
                           save_LIBS="$LIBS"
                           AC_CHECK_LIB(pthread, pthread_mutex_unlock, [
                                   ol_link_threads=posix
                                   LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lmach -lexc -lc_r"
                                   if test $ol_with_yielding_select = auto ; then
                                           ol_with_yielding_select=yes
                                   fi
                                   ],:,[-lmach -lexc -lc_r])
                           LIBS="$save_LIBS"
                   fi
   
                   if test $ol_link_threads = no ; then
                           dnl try DEC Threads -lpthread -lmach -lexc
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(pthread, pthread_mutex_lock, [                          AC_CHECK_LIB(pthread, pthread_mutex_lock, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lexc"                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lmach -lexc"
                                 if test $ol_with_yielding_select = auto ; then                                  if test $ol_with_yielding_select = auto ; then
                                         ol_with_yielding_select=yes                                          ol_with_yielding_select=yes
                                 fi                                  fi
                                 ],,[-lexc])                                  ],:,[-lmach -lexc])
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
                 if test $ol_link_threads = no ; then                  if test $ol_link_threads = no ; then
                         dnl try DEC Threads -lpthreads -lmach -lexc -lc_r                          dnl try DEC Threads -lpthread -lexc
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(pthreads, pthread_mutex_unlock, [                          AC_CHECK_LIB(pthread, pthread_mutex_trylock, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lmach -lexc -lc_r"                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lexc"
                                 if test $ol_with_yielding_select = auto ; then                                  if test $ol_with_yielding_select = auto ; then
                                         ol_with_yielding_select=yes                                          ol_with_yielding_select=yes
                                 fi                                  fi
                                 ],,[-lmach -lexc -lc_r])                                  ],:,[-lexc])
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 484  if test $ol_with_threads = auto -o $ol_w Line 608  if test $ol_with_threads = auto -o $ol_w
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(pthread, pthread_create, [                          AC_CHECK_LIB(pthread, pthread_create, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthread"])                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthread"],:)
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 493  if test $ol_with_threads = auto -o $ol_w Line 617  if test $ol_with_threads = auto -o $ol_w
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(c_r, pthread_create, [                          AC_CHECK_LIB(c_r, pthread_create, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lc_r"])                                  LTHREAD_LIBS="$LTHREAD_LIBS -lc_r"],:)
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 502  if test $ol_with_threads = auto -o $ol_w Line 626  if test $ol_with_threads = auto -o $ol_w
                         save_LIBS="$LIBS"                          save_LIBS="$LIBS"
                         AC_CHECK_LIB(pthreads, pthread_create, [                          AC_CHECK_LIB(pthreads, pthread_create, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"])                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"],:)
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 513  if test $ol_with_threads = auto -o $ol_w Line 637  if test $ol_with_threads = auto -o $ol_w
                         AC_CHECK_LIB(pthreads, pthread_join, [                          AC_CHECK_LIB(pthreads, pthread_join, [
                                 ol_link_threads=posix                                  ol_link_threads=posix
                                 LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"                                  LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"
                                 ],[-Wl,-woff,85])                                  ],:,[-Wl,-woff,85])
                         LIBS="$save_LIBS"                          LIBS="$save_LIBS"
                 fi                  fi
   
Line 548  if test $ol_with_threads = auto -o $ol_w Line 672  if test $ol_with_threads = auto -o $ol_w
                         fi                          fi
                 fi                  fi
   
                   if test $ol_link_threads = no ; then
                           dnl try -threads
                           AC_CACHE_CHECK([for pthread_create with -threads],
                                   [ol_cv_thread_flag], [
                                   dnl save the flags
                                   save_LIBS="$LIBS"
                                   LIBS="-threads $LIBS"
                                   AC_TRY_LINK([char pthread_create();],[
                                           pthread_create();
                                           ], ol_cv_thread_flag=yes, ol_cv_thread_flag=no)
                                   dnl restore the LIBS
                                   LIBS="$save_LIBS"
                           ])
   
                           if test $ol_cv_thread_flag = yes ; then
                                   LTHREAD_LIBS="$LTHREAD_LIBS -threads"
                                   ol_link_threads=posix
                           fi
                   fi
   
                   if test $ol_link_threads = no ; then
                           dnl try DEC Threads -lpthreads -lmach -lexc -lc_r
                           save_LIBS="$LIBS"
                           AC_CHECK_LIB(pthreads, pthread_mutex_unlock, [
                                   ol_link_threads=posix
                                   LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lmach -lexc -lc_r"
                                   if test $ol_with_yielding_select = auto ; then
                                           ol_with_yielding_select=yes
                                   fi
                                   ],:,[-lmach -lexc -lc_r])
                           LIBS="$save_LIBS"
                   fi
   
                   if test $ol_link_threads = no ; then
                           dnl try DEC Threads -lpthreads -lmach -lexc
                           save_LIBS="$LIBS"
                           AC_CHECK_LIB(pthreads, pthread_mutex_lock, [
                                   ol_link_threads=posix
                                   LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lmach -lexc"
                                   if test $ol_with_yielding_select = auto ; then
                                           ol_with_yielding_select=yes
                                   fi
                                   ],:,[-lmach -lexc])
                           LIBS="$save_LIBS"
                   fi
   
                   if test $ol_link_threads = no ; then
                           dnl try DEC Threads -lpthreads -lexc
                           save_LIBS="$LIBS"
                           AC_CHECK_LIB(pthreads, pthread_mutex_trylock, [
                                   ol_link_threads=posix
                                   LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lexc"
                                   if test $ol_with_yielding_select = auto ; then
                                           ol_with_yielding_select=yes
                                   fi
                                   ],:,[-lexc])
                           LIBS="$save_LIBS"
                   fi
   
                 if test $ol_link_threads != no ; then                  if test $ol_link_threads != no ; then
                         AC_DEFINE(HAVE_PTHREADS)                          AC_DEFINE(HAVE_PTHREADS,1,
                                   [define if you have POSIX Threads])
   
                         dnl save flags                          dnl save flags
                         save_CPPFLAGS="$CPPFLAGS"                          save_CPPFLAGS="$CPPFLAGS"
Line 573  if test $ol_with_threads = auto -o $ol_w Line 757  if test $ol_with_threads = auto -o $ol_w
                         if test $ac_cv_func_sched_yield = no -a \                          if test $ac_cv_func_sched_yield = no -a \
                                 $ac_cv_func_pthread_yield = no ; then                                  $ac_cv_func_pthread_yield = no ; then
                                 dnl Solaris has sched_yield() in -lposix4                                  dnl Solaris has sched_yield() in -lposix4
                                 AC_CHECK_LIB(posix4, sched_yield,                                  dnl but we'll use thr_yield instead.
                                         [LTHREAD_LIBS="$LTHREAD_LIBS -lposix4"                                  AC_CHECK_FUNCS(thr_yield)
                                         AC_DEFINE(HAVE_SCHED_YIELD,1)  
                                         ac_cv_func_sched_yield=yes],  
                                         [ac_cv_func_sched_yield=no])  
                         fi                          fi
                         if test $ac_cv_func_sched_yield = no -a \                          if test $ac_cv_func_sched_yield = no -a \
                                 $ac_cv_func_pthread_yield = no ; then                                  $ac_cv_func_pthread_yield = no -a \
                                   "$ac_cv_func_thr_yield" = no ; then
                                 AC_MSG_WARN([could not locate sched_yield() or pthread_yield()])                                  AC_MSG_WARN([could not locate sched_yield() or pthread_yield()])
                         fi                          fi
   
                         dnl Check functions for compatibility                          dnl Check functions for compatibility
                         AC_CHECK_FUNCS(pthread_kill pthread_detach)                          AC_CHECK_FUNCS(pthread_kill)
   
                         AC_CHECK_FUNCS( \                          dnl Check for pthread_detach with <pthread.h> inclusion
                                 pthread_attr_create pthread_attr_init \                          dnl as it's symbol may have been mangled.
                                 pthread_attr_destroy pthread_attr_delete \                          AC_CACHE_CHECK([for pthread_detach with <pthread.h>],
                                 pthread_attr_setdetachstate pthread_attr_setdetach_np \                                  [ol_cv_func_pthread_detach], [
                         )                                  dnl save the flags
                                   AC_TRY_LINK([#include <pthread.h>],
                                           [pthread_detach(NULL);],
                                           [ol_cv_func_pthread_detach=yes],
                                           [ol_cv_func_pthread_detach=no])
                           ])
   
                           if test $ol_cv_func_pthread_detach = no ; then
                                   AC_MSG_ERROR([could not locate pthread_detach()])
                           fi
   
                           AC_DEFINE(HAVE_PTHREAD_DETACH,1,
                                   [define if you have pthread_detach function])
   
                         dnl Check for setconcurreny functions                          dnl Check for setconcurreny functions
                         AC_CHECK_FUNCS( \                          AC_CHECK_FUNCS( \
                                 pthread_setconcurrency \                                  pthread_setconcurrency \
                                   pthread_getconcurrency \
                                 thr_setconcurrency \                                  thr_setconcurrency \
                                   thr_getconcurrency \
                         )                          )
   
                         AC_MSG_CHECKING([if pthread_create() works])                          AC_MSG_CHECKING([if pthread_create() works])
Line 761  if test $ol_with_threads = auto -o $ol_w Line 957  if test $ol_with_threads = auto -o $ol_w
   
                 if test $ol_link_threads != no ; then                  if test $ol_link_threads != no ; then
                         : check for cthread specific functionality here                          : check for cthread specific functionality here
                         AC_DEFINE(HAVE_MACH_CTHREADS,1)                          AC_DEFINE(HAVE_MACH_CTHREADS,1,
                                   [define if you have Mach Cthreads])
                 else                  else
                         AC_MSG_ERROR([could not link with Mach CThreads])                          AC_MSG_ERROR([could not link with Mach CThreads])
                 fi                  fi
Line 781  if test $ol_with_threads = auto -o $ol_w Line 978  if test $ol_with_threads = auto -o $ol_w
                 AC_CHECK_LIB(thread, thr_create, [have_thr=yes], [have_thr=no])                  AC_CHECK_LIB(thread, thr_create, [have_thr=yes], [have_thr=no])
   
                 if test $have_thr = yes ; then                  if test $have_thr = yes ; then
                         AC_DEFINE(HAVE_THR)                          AC_DEFINE(HAVE_THR,1,
                                   [if you have Solaris LWP (thr) package])
                         LTHREAD_LIBS="$LTHREAD_LIBS -lthread"                          LTHREAD_LIBS="$LTHREAD_LIBS -lthread"
                         ol_link_threads=thr                          ol_link_threads=thr
   
Line 789  if test $ol_with_threads = auto -o $ol_w Line 987  if test $ol_with_threads = auto -o $ol_w
                                 ol_with_yielding_select=yes                                  ol_with_yielding_select=yes
                         fi                          fi
   
                         AC_CACHE_CHECK([for misplaced posix thread in headers],                          dnl Check for setconcurreny functions
                                 [ol_cv_header_misplaced_pthreads], [                          AC_CHECK_FUNCS( \
                                 AC_TRY_COMPILE([                                  thr_setconcurrency \
 #include <sys/types.h>                                  thr_getconcurrency \
 typedef double pthread_t;                          )
                                 ], [  
                                 pthread_t thread = 0.0;  
                                 ],  
                                 [ol_cv_header_misplaced_pthreads=no],  
                                 [ol_cv_header_misplaced_pthreads=yes])  
                         ])  
   
                         if test "$ol_cv_header_misplaced_pthreads" = yes ; then  
                                 AC_MSG_ERROR([pthread types are misplaced, use --with-threads=posix]);  
                         fi  
                 fi                  fi
         fi          fi
   
Line 813  typedef double pthread_t; Line 1001  typedef double pthread_t;
                 AC_CHECK_LIB(lwp, lwp_create, [have_lwp=yes], [have_lwp=no])                  AC_CHECK_LIB(lwp, lwp_create, [have_lwp=yes], [have_lwp=no])
   
                 if test $have_lwp = yes ; then                  if test $have_lwp = yes ; then
                         AC_DEFINE(HAVE_LWP)                          AC_DEFINE(HAVE_LWP,1,
                                   [if you have SunOS LWP package])
                         LTHREAD_LIBS="$LTHREAD_LIBS -llwp"                          LTHREAD_LIBS="$LTHREAD_LIBS -llwp"
                         ol_link_threads=lwp                          ol_link_threads=lwp
   
Line 825  typedef double pthread_t; Line 1014  typedef double pthread_t;
 fi  fi
   
 if test $ol_with_yielding_select = yes ; then  if test $ol_with_yielding_select = yes ; then
         AC_DEFINE(HAVE_YIELDING_SELECT,1)          AC_DEFINE(HAVE_YIELDING_SELECT,1,
                   [define if select implicitly yields])
 fi  fi
   
 if test $ol_with_threads = manual ; then  if test $ol_with_threads = manual ; then
Line 852  if test $ol_link_threads != no ; then Line 1042  if test $ol_link_threads != no ; then
         AC_DEFINE(_THREAD_SAFE,1)          AC_DEFINE(_THREAD_SAFE,1)
         AC_DEFINE(THREADSAFE,1)          AC_DEFINE(THREADSAFE,1)
         AC_DEFINE(_THREADSAFE,1)          AC_DEFINE(_THREADSAFE,1)
           AC_DEFINE(_SGI_MP_SOURCE,1)
   
         dnl this might cause the errno symbol to be          dnl this might cause the errno symbol to be
         dnl replaced with a function to get a thread specific errno.          dnl replaced with a function to get a thread specific errno.
Line 859  if test $ol_link_threads != no ; then Line 1050  if test $ol_link_threads != no ; then
         dnl with the thread libraries          dnl with the thread libraries
         AC_CACHE_CHECK([for thread specific errno],          AC_CACHE_CHECK([for thread specific errno],
                 [ol_cv_errno_thread_specific], [                  [ol_cv_errno_thread_specific], [
                 AC_TRY_LINK([                  AC_TRY_LINK([#include <errno.h>], [int x = errno;],
 #include <errno.h>  
                         ], [  
 int x = errno;  
                         ],  
                         [ol_cv_errno_thread_specific=yes],                          [ol_cv_errno_thread_specific=yes],
                         [ol_cv_errno_thread_specific=no])                          [ol_cv_errno_thread_specific=no])
         ])          ])
Line 886  if test $ol_link_threads = no ; then Line 1073  if test $ol_link_threads = no ; then
                 ol_with_threads=no                  ol_with_threads=no
         fi          fi
   
         AC_CACHE_CHECK([for misplaced posix thread in headers],          AC_DEFINE(NO_THREADS,1,
                 [ol_cv_header_misplaced_pthreads], [                  [define if you have (or want) no threads])
                 AC_TRY_COMPILE([  
 #include <sys/types.h>  
 typedef double pthread_t;  
                         ], [  
                                 pthread_t thread = 0.0;  
                         ],  
                         [ol_cv_header_misplaced_pthreads=no],  
                         [ol_cv_header_misplaced_pthreads=yes])  
         ])  
   
         if test "$ol_cv_header_misplaced_pthreads" = yes ; then  
                 AC_MSG_ERROR([pthread types are misplaced, use --with-threads=posix]);  
         fi  
   
         AC_DEFINE(NO_THREADS,1)  
         LTHREAD_LIBS=""          LTHREAD_LIBS=""
 fi  fi
   
Line 976  if test $ol_with_ldbm_api = auto -o $ol_ Line 1148  if test $ol_with_ldbm_api = auto -o $ol_
         fi          fi
 fi  fi
   
   if test $ol_with_ldbm_api = auto -o $ol_with_ldbm_api = mdbm ; then
           OL_MDBM
   
           if test $ol_cv_mdbm = yes ; then
                   ol_link_ldbm=mdbm
                   ol_with_ldbm_api=mdbm
                   if test $ol_cv_lib_mdbm != yes ; then
                           LDBM_LIBS="$LDBM_LIBS $ol_cv_lib_mdbm"
                   fi
           fi
   fi
   
 if test $ol_with_ldbm_api = auto ; then  if test $ol_with_ldbm_api = auto ; then
         AC_MSG_WARN([skipping automatic checking for NDBM, must be manually enabled.])          AC_MSG_WARN([skipping automatic checking for NDBM, must be manually enabled.])
 elif test $ol_with_ldbm_api = ndbm ; then  elif test $ol_with_ldbm_api = ndbm ; then
Line 1001  if test $ol_link_ldbm = no -a $ol_enable Line 1185  if test $ol_link_ldbm = no -a $ol_enable
         ol_enable_ldbm=no          ol_enable_ldbm=no
 fi  fi
   
 if test $ol_enable_wrappers = yes ; then  if test $ol_enable_wrappers != no ; then
         AC_CHECK_LIB(wrap, main,          AC_CHECK_HEADERS(tcpd.h)
                 [have_wrappers=yes], [have_wrappers=no])  
           if test $ac_cv_header_tcpd_h != yes ; then
                   have_wrappers=no
           else
                   AC_TRY_COMPILE([
   int allow_severity = 0;
   int deny_severity  = 0;
                   ],[hosts_access()],[have_wrappers=yes],[have_wrappers=no])
           fi
   
         if test $have_wrappers = yes ; then          if test $have_wrappers = yes ; then
                 AC_DEFINE(HAVE_TCPD)                  AC_DEFINE(HAVE_TCPD,1, [define if you have -lwrap])
                 SLAPD_LIBS="$SLAPD_LIBS -lwrap"                  WRAP_LIBS="-lwrap"
   
                   dnl We add another check for -lnsl since some libwrap's
                   dnl need it, but it isn't always included from above
                   AC_CHECK_LIB(nsl, main)
         else          else
                 AC_MSG_WARN(could not find -lwrap)                  AC_MSG_WARN(could not find -lwrap)
                 if test $ol_enable_wrappers = yes ; then                  if test $ol_enable_wrappers = yes ; then
Line 1016  if test $ol_enable_wrappers = yes ; then Line 1212  if test $ol_enable_wrappers = yes ; then
   
                 AC_MSG_WARN(disabling wrappers support)                  AC_MSG_WARN(disabling wrappers support)
                 ol_enable_wrappers=no                  ol_enable_wrappers=no
                   WRAP_LIBS=""
         fi          fi
   fi
   
   if test $ol_enable_dmalloc != no ; then
           AC_CHECK_HEADERS(dmalloc.h)
           AC_CHECK_LIB(dmalloc, dmalloc_shutdown)
 fi  fi
   
 # ud needs termcap (should insert check here)  # ud needs termcap (should insert check here)
Line 1027  AC_CHECK_HEADERS(termcap.h ncurses.h) Line 1228  AC_CHECK_HEADERS(termcap.h ncurses.h)
 if test $ol_link_termcap = no ; then  if test $ol_link_termcap = no ; then
         AC_CHECK_LIB(termcap, tputs, [have_termcap=yes], [have_termcap=no])          AC_CHECK_LIB(termcap, tputs, [have_termcap=yes], [have_termcap=no])
         if test $have_termcap = yes ; then          if test $have_termcap = yes ; then
                 AC_DEFINE(HAVE_TERMCAP)                  AC_DEFINE(HAVE_TERMCAP, 1, [define if you have -ltermcap])
                 ol_link_termcap=yes                  ol_link_termcap=yes
                 TERMCAP_LIBS=-ltermcap                  TERMCAP_LIBS=-ltermcap
         fi          fi
Line 1036  fi Line 1237  fi
 if test $ol_link_termcap = no ; then  if test $ol_link_termcap = no ; then
         AC_CHECK_LIB(ncurses, initscr, [have_ncurses=yes], [have_ncurses=no])          AC_CHECK_LIB(ncurses, initscr, [have_ncurses=yes], [have_ncurses=no])
         if test $have_ncurses = yes ; then          if test $have_ncurses = yes ; then
                 AC_DEFINE(HAVE_NCURSES)                  AC_DEFINE(HAVE_NCURSES, 1, [define if you have -lncurses])
                 ol_link_termcap=yes                  ol_link_termcap=yes
                 TERMCAP_LIBS=-lncurses                  TERMCAP_LIBS=-lncurses
         fi          fi
 fi  fi
   
 if test $ol_link_termcap = no ; then  if test $ol_link_termcap = no ; then
         AC_DEFINE(NO_TERMCAP,1)          AC_DEFINE(NO_TERMCAP,1, [define if you have no termcap support])
         TERMCAP_LIBS=          TERMCAP_LIBS=
 fi  fi
   
Line 1092  AC_HEADER_DIRENT Line 1293  AC_HEADER_DIRENT
 AC_HEADER_SYS_WAIT  AC_HEADER_SYS_WAIT
 AM_HEADER_TIOCGWINSZ_NEEDS_SYS_IOCTL  AM_HEADER_TIOCGWINSZ_NEEDS_SYS_IOCTL
 if test $am_cv_sys_posix_termios = yes ; then  if test $am_cv_sys_posix_termios = yes ; then
         AC_DEFINE(HAVE_POSIX_TERMIOS,1)          AC_DEFINE(HAVE_POSIX_TERMIOS,1,
                   [define if you have POSIX termios])
 fi  fi
   
 AC_CHECK_HEADERS(       \  AC_CHECK_HEADERS(       \
           arpa/nameser.h  \
         crypt.h                 \          crypt.h                 \
         errno.h                 \          errno.h                 \
         fcntl.h                 \          fcntl.h                 \
Line 1108  AC_CHECK_HEADERS( \ Line 1311  AC_CHECK_HEADERS( \
         regex.h                 \          regex.h                 \
         psap.h                  \          psap.h                  \
         pwd.h                   \          pwd.h                   \
           resolv.h                \
         sgtty.h                 \          sgtty.h                 \
         stdarg.h                \          stdarg.h                \
         stddef.h                \          stddef.h                \
Line 1119  AC_CHECK_HEADERS( \ Line 1323  AC_CHECK_HEADERS( \
         sys/ioctl.h             \          sys/ioctl.h             \
         sys/param.h             \          sys/param.h             \
         sys/resource.h  \          sys/resource.h  \
           sys/select.h    \
         sys/socket.h    \          sys/socket.h    \
         sys/syslog.h    \          sys/syslog.h    \
         sys/time.h              \          sys/time.h              \
Line 1145  OL_C_UPPER_LOWER Line 1350  OL_C_UPPER_LOWER
 AC_C_CONST  AC_C_CONST
   
 if test $cross_compiling = yes ; then  if test $cross_compiling = yes ; then
         AC_DEFINE(CROSS_COMPILING, 1)          AC_DEFINE(CROSS_COMPILING, 1, [define if cross compiling])
 else  else
         AC_C_BIGENDIAN          AC_C_BIGENDIAN
         AC_CHECK_SIZEOF(short)           AC_CHECK_SIZEOF(short) 
Line 1166  if test $ac_cv_func_vprintf = yes ; then Line 1371  if test $ac_cv_func_vprintf = yes ; then
         AC_CHECK_FUNCS(vsnprintf vsprintf)          AC_CHECK_FUNCS(vsnprintf vsprintf)
 fi  fi
   
 AC_FUNC_WAIT3  
   
 AC_CHECK_FUNCS(         \  AC_CHECK_FUNCS(         \
         bcopy                   \          bcopy                   \
           closesocket             \
         flock                   \          flock                   \
         getdtablesize   \          getdtablesize   \
         gethostname             \          gethostname             \
Line 1211  dnl Sort out defines Line 1415  dnl Sort out defines
 if test "$ol_enable_debug" != no ; then  if test "$ol_enable_debug" != no ; then
         AC_DEFINE(LDAP_DEBUG,1)          AC_DEFINE(LDAP_DEBUG,1)
 fi  fi
 dnl     if test "$ol_enable_syslog" != no ; then  
 dnl             AC_DEFINE(LDAP_SYSLOG,1)  
 dnl     fi  
 if test "$ol_enable_libui" = yes ; then  if test "$ol_enable_libui" = yes ; then
         AC_DEFINE(LDAP_LIBUI,1)          AC_DEFINE(LDAP_LIBUI,1)
 fi  fi
Line 1292  AC_SUBST(SLURPD_LIBS) Line 1493  AC_SUBST(SLURPD_LIBS)
 AC_SUBST(LDBM_LIBS)  AC_SUBST(LDBM_LIBS)
 AC_SUBST(LTHREAD_LIBS)  AC_SUBST(LTHREAD_LIBS)
 AC_SUBST(LUTIL_LIBS)  AC_SUBST(LUTIL_LIBS)
   AC_SUBST(WRAP_LIBS)
 AC_SUBST(KRB_LIBS)  AC_SUBST(KRB_LIBS)
 AC_SUBST(TERMCAP_LIBS)  AC_SUBST(TERMCAP_LIBS)
   

Removed from v.1.2.2.31  
changed lines
  Added in v.1.2.2.31.2.28


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org