dnl configure.in -- main autoconf macro definition file
dnl
dnl Process this file with autoconf to produce a configure script.
dnl This file is part of the Kannel WAP and SMS gateway project.

dnl initialization

AC_PREREQ(2.13)

AC_INIT(gw/alt_charsets.h)
AC_CONFIG_HEADER(config.h)
AC_SUBST(SHELL)
AC_CONFIG_AUX_DIR(.)
AC_SET_TERMINAL_SEQUENCES()

dnl Check gateway version number.
VERSION=`head -1 VERSION`
if test "x$VERSION" = "xcvs"; then
  AC_MSG_CHECKING([cvs checkout date])
  AC_CVS_DATE(CVS_DATE)
  AC_MSG_RESULT([$CVS_DATE])
  VERSION="$VERSION-$CVS_DATE"
fi
AC_DEFINE_UNQUOTED(GW_NAME, "Kannel")
AC_DEFINE_UNQUOTED(VERSION, "$VERSION")
AC_SUBST(VERSION)
AC_CONFIG_SECTION([Configuring for Kannel gateway version $VERSION])

dnl Solaris pkgadd support definitions
PKGADD_PKG="KANNELgateway"
PKGADD_NAME="Kannel - WAP and SMS gateway"
PKGADD_VENDOR="www.kannel.org"
AC_SUBST(PKGADD_PKG)
AC_SUBST(PKGADD_NAME)
AC_SUBST(PKGADD_VENDOR)

dnl Target installation directory for documentation
AC_SUBST(docdir)
docdir='${prefix}/share/doc/kannel'

dnl Checks system type.
AC_CONFIG_SECTION([Running system checks])
AC_CANONICAL_HOST

dnl Apply system specific rules.
dnl Executable extension for systems that need one, i.e. Cygwin
dnl Set the LIBTOOL to be used to create libs
EXE_EXT=""
LIBTOOL="ar rc"
case "$host" in
  *-sun-solaris*) 
    CFLAGS="$CFLAGS -DSunOS=1"
    ;;
  *-cygwin*)
    EXE_EXT=".exe"
    ;;
  *apple-darwin*) 
    CFLAGS="$CFLAGS -DDARWIN=1" 
    LIBTOOL="libtool -static -o" 
esac
AC_SUBST(EXE_EXT)
AC_SUBST(LIBTOOL)

AC_ARG_WITH(cflags,
[  --with-cflags=FLAGS     use FLAGS for CFLAGS],
CFLAGS="$CFLAGS $withval")

AC_ARG_WITH(libs,
[  --with-libs=FLAGS       use FLAGS for extra libraries],
LIBS="$LIBS $withval")

dnl Checks for programs.
AC_PROG_CC
AC_PROG_INSTALL
AC_PROG_RANLIB
AC_PROG_YACC
AC_PROG_LEX
AC_PATH_PROG(CONVERT, convert)
AC_PATH_PROG(PERL, perl)

dnl Checks for libraries.

AC_CHECK_LIB(m, log)
AC_CHECK_LIB(socket, accept)
AC_CHECK_LIB(nsl, inet_ntoa)
AC_CHECK_LIB(resolv, inet_ntop)
AC_CHECK_LIB(bind, inet_ntop)
AC_CHECK_LIB(pthread, pthread_exit)
AC_CHECK_LIB(iconv, libiconv)
if test -z "$pthread"; then
	AC_CHECK_LIB(c_r, pthread_exit, [LIBS="$LIBS -lc_r"])
fi


dnl Checks for header files.

AC_HEADER_STDC
AC_CHECK_HEADERS(sys/ioctl.h sys/time.h sys/types.h unistd.h sys/poll.h)
AC_CHECK_HEADERS(pthread.h getopt.h syslog.h iconv.h)

dnl Checks for typedefs, structures, and compiler characteristics.

AC_TRY_COMPILE(, [char *func = __FUNCTION__;], 
    	       AC_DEFINE(HAVE___FUNCTION__))
AC_TRY_COMPILE(, [char *func = __func__;], 
    	       AC_DEFINE(HAVE___FUNC__))


dnl Checks for library functions.

AC_CHECK_FUNCS(gettimeofday select socket strdup getopt_long)
AC_CHECK_FUNC(getopt, , LIBOBJS="$LIBOBJS utils/attgetopt.o")
AC_SUBST(LIBOBJS)

dnl Extra feature checks

dnl GW_HAVE_TYPE_FROM(HDRNAME, TYPE, HAVENAME, DESCRIPTION)
AC_DEFUN(GW_HAVE_TYPE_FROM, [
	AC_CACHE_CHECK([for $2 in <$1>], gw_cv_type_$3,
		AC_TRY_COMPILE([#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#include <$1>
], [$2 foo;],
			gw_cv_type_$3=yes, gw_cv_type_$3=no))
	if test $gw_cv_type_$3 = yes; then
		AC_DEFINE($3, 1, $4)
	fi
])

dnl GW_HAVE_FUNC_FROM(HDRNAME, FUNC, HAVENAME, DESCRIPTION)
AC_DEFUN(GW_HAVE_FUNC_FROM, [
	AC_CACHE_CHECK([for $2 in <$1>], gw_cv_func_$3,
		AC_TRY_COMPILE([#include <$1>], [void *foo = $2;],
			gw_cv_func_$3=yes, gw_cv_func_$3=no))
	if test $gw_cv_func_$3 = yes; then
		AC_DEFINE($3, 1, $4)
	fi
])

GW_HAVE_TYPE_FROM(sys/socket.h,
	socklen_t,
	HAVE_SOCKLEN_T,
	[Defined if there is a socklen_t in <sys/socket.h>])

GW_HAVE_FUNC_FROM(stdio.h, getopt, HAVE_GETOPT_IN_STDIO_H,
    	    	  [Does <stdio.h> declare getopt()?])
GW_HAVE_FUNC_FROM(unistd.h, getopt, HAVE_GETOPT_IN_UNISTD_H,
    	    	  [Does <unistd.h> declare getopt()?])


dnl Misfeature checks

AC_CONFIG_SECTION([Checking POSIX threads support])
AC_MSG_CHECKING(for working pthreads)
AC_TRY_RUN([#include <pthread.h>
#include <unistd.h>
int pid;
void testpid(void* foo);
int main(void){
    pthread_t child;
    pid=getpid();
    pthread_create(&child,NULL,(void*)testpid,NULL);
    pthread_join(child,NULL);
    return 0;
}
void testpid(void* foo){
    int mypid=getpid();
    if(mypid!=pid){
        /* Pthreads states that all threads should have the same PID
         * we dont!
         */
        exit(1);
    }else{
        exit(0);
    }
}
],echo yes , echo no ;CFLAGS="$CFLAGS -DBROKEN_PTHREADS=1", echo  Cross compiling - assuming they work)


dnl Check if we have libxml2 installed and which version it is.
dnl Kannel requires currently at least version 2.2.5 of libxml2.

AC_CONFIG_SECTION([Checking for libxml2 support])
xml_ver_required="2.2.5"
AC_PATH_PROGS(XML_CONFIG, xml2-config xml-config, no)
if test "$XML_CONFIG" = "no"; then
  AC_MSG_ERROR([You MUST have the libxml2 (aka gnome-xml) library installed])
else
  AC_MSG_CHECKING([libxml version])
  xml_version=`$XML_CONFIG --version`
  AC_MSG_RESULT([$xml_version])
  AC_CHECK_VERSION($xml_version, $xml_ver_required, 
  [ LIBS="$LIBS `$XML_CONFIG --libs`"
    CFLAGS="$CFLAGS `$XML_CONFIG --cflags`"
  ],[
    AC_MSG_ERROR([libxml2 version $xml_version is too old. You need at least $xml_ver_required])
  ])
fi
                                       

dnl DocBook stuff

AC_CONFIG_SECTION([Configuring DocBook support])
AC_CHECK_PROG(JADE, jade, jade, :)
AC_CHECK_PROG(JADETEX, jadetex, jadetex, :)
AC_CHECK_PROG(PDFJADETEX, pdfjadetex, pdfjadetex, :)
AC_CHECK_PROG(DVIPS, dvips, dvips, :)
AC_CHECK_PROG(FIG2DEV, fig2dev, fig2dev, :)
AC_CHECK_PROG(CONVERT, convert, convert, :)
AC_SUBST(HTML_DSL)
found=""
for loc in /usr /usr/local; do
  if test "x$found" = "x" ; then 
    for file in ${loc}/lib/sgml/stylesheet/dsssl/docbook/nwalsh/html/docbook.dsl \
	${loc}/lib/sgml/stylesheets/nwalsh-modular/html/docbook.dsl \
	${loc}/share/sgml/docbook/dsssl-stylesheets-1.59/html/docbook.dsl \
	${loc}/share/sgml/docbook/dsssl-stylesheets/html/docbook.dsl \
        ${loc}/share/sgml/docbook/dsssl/modular/html/docbook.dsl ; do
      if test "x$found" = "x" ; then 
	AC_CHECK_FILE($file,HTML_DSL=$file; found=1)
      fi
    done
  fi
done
AC_SUBST(TEX_DSL)
found=""
for loc in /usr /usr/local; do
  if test "x$found" = "x" ; then 
    for file in ${loc}/lib/sgml/stylesheet/dsssl/docbook/nwalsh/print/docbook.dsl \
	${loc}/lib/sgml/stylesheets/nwalsh-modular/print/docbook.dsl \
	${loc}/share/sgml/docbook/dsssl-stylesheets-1.59/print/docbook.dsl \
	${loc}/share/sgml/docbook/dsssl-stylesheets/print/docbook.dsl \
        ${loc}/share/sgml/docbook/dsssl/modular/print/docbook.dsl ; do
      if test "x$found" = "x" ; then 
	AC_CHECK_FILE($file,TEX_DSL=$file; found=1)
      fi
    done
  fi    
done

dnl Implement --enable-warnings option.

AC_ARG_ENABLE(warnings,
[  --enable-warnings       enable compilation warnings (default: disabled)], [
  echo enabling compilation warnings
  if test -n "$GCC"; then
    CFLAGS="$CFLAGS -Wall"
    CFLAGS="$CFLAGS -Wmissing-prototypes"
    CFLAGS="$CFLAGS -Wmissing-declarations"
    CFLAGS="$CFLAGS -Wnested-externs"
    CFLAGS="$CFLAGS -Winline"
    #CFLAGS="$CFLAGS -Wstrict-prototypes"
    #CFLAGS="$CFLAGS -Wredundant-decls"
    #CFLAGS="$CFLAGS -Wconversion"
  fi
])

dnl Implement --enable-docs option.

AC_SUBST(DOCSTARGET)
if test "x$HTML_DSL" = "x" -o "x$TEX_DSL" = "x"
then
	DOCSTARGET="no-docs"
else
	DOCSTARGET="docs"
fi

AC_ARG_ENABLE(docs,
[  --enable-docs           enable building of documentation (default: enabled)], [
  if test "$enableval" = "yes"
  then
      DOCSTARGET="docs"
  else
      DOCSTARGET="no-docs"
  fi
])
case "$DOCSTARGET" in
no-docs) AC_MSG_RESULT(Not building documentation.) ;;
docs) AC_MSG_RESULT(Documentation will be built as well.) ;;
esac

dnl Implement --enable-drafts option.

AC_SUBST(DOCDRAFTS)
DOCDRAFTS="IGNORE"

AC_ARG_ENABLE(drafts,
[  --enable-drafts         enable building of documentation drafts (default: disabled)], [
  if test "$enableval" = "yes"
  then
      DOCDRAFTS="INCLUDE"
  else
      DOCDRAFTS="IGNORE"
  fi
])
if test "x$DOCSTARGET" = "xdocs"
then
    case "$DOCDRAFTS" in
    INCLUDE) AC_MSG_RESULT(Documentation will include drafts.) ;;
    esac
fi


AC_CONFIG_SECTION([Configuring parameters])

dnl Implement --with-suffix=version option.

SUFFIX=""

AC_ARG_WITH(suffix,
[  --with-suffix           set suffix for binaries (default: -\$VERSION)], [
  if test "x$withval" != "x" ; then
  	SUFFIX=$withval
  fi
])

dnl Implement --enable-suffix option.

AC_ARG_ENABLE(suffix,
[  --enable-suffix         enable suffix for binaries (default: disabled)], [
  if test "$enableval" = "yes" ; then
    SUFFIX="-$VERSION"
  else
    SUFFIX=""
  fi
])

if test "x$SUFFIX" != "x" ; then
  AC_MSG_CHECKING(whether to append suffix to binary)
  AC_MSG_RESULT($SUFFIX)
fi

AC_DEFINE_UNQUOTED(SUFFIX, "$SUFFIX")
AC_SUBST(SUFFIX)


dnl Implement --with-defaults=speed/debug option.

AC_ARG_WITH(defaults,
[  --with-defaults         set default configure options: speed/debug (default: native malloc + assertions)
                          this will set assertion checking and malloc wrapper accordingly
			  speed = native malloc + no assertions
			  debug = checking malloc + assertions], [
  case "$withval" in
  speed) assertiondefault=no
         mallocdefault=native
         ;;
  debug) assertiondefault=yes
         mallocdefault=check
         ;;
  *) echo "unknown --with-defaults parameter $withval"
     exit 1
     ;;
  esac
], [
  dnl defaults to native malloc but with assertions
  assertiondefault=yes
  mallocdefault=native
])


dnl Implement --with-malloc=[native|check|slow] option.

AC_MSG_CHECKING(which malloc to use)
AC_ARG_WITH(malloc,
[  --with-malloc           select malloc wrapper to use: native/check/slow (default: native)], [
  case "$withval" in
  native) AC_DEFINE(USE_GWMEM_NATIVE)
          AC_MSG_RESULT(native malloc)
          ;;
  check) AC_DEFINE(USE_GWMEM_CHECK)
         AC_MSG_RESULT(checking malloc)
         ;;
  slow) AC_DEFINE(USE_GWMEM_SLOW)
        AC_MSG_RESULT(slow malloc)
	;;
  *) echo "Unknown malloc wrapper $withval. Oops."; exit 1 ;;
  esac
], [
  case "$mallocdefault" in
  check) AC_DEFINE(USE_GWMEM_CHECK)
     AC_MSG_RESULT(checking malloc)
     ;;
  slow) AC_DEFINE(USE_GWMEM_SLOW)
        AC_MSG_RESULT(slow malloc)
	;;
  *) AC_DEFINE(USE_GWMEM_NATIVE)
          AC_MSG_RESULT(native malloc)
          ;;
  esac
])


dnl Implement --disable-assertions option.

AC_ARG_ENABLE(assertions,
[  --disable-assertions    turn off assertion checking], [
  if test "$enableval" = "no"
  then
    echo disabling assertion checking
    AC_DEFINE(NO_GWASSERT)
  fi
], [
  if test "$assertiondefault" = "no"
  then
    echo disabling assertion checking
    AC_DEFINE(NO_GWASSERT)
  fi
])


dnl Implement the --enable-pam option.

AC_ARG_ENABLE(pam,
[  --enable-pam	          enable pam authentication (default: disabled)], [
    if test "$enableval" = "yes"
    then
	AC_CHECK_LIB(pam, pam_end)
	AC_CHECK_LIB(dl,main)
	AC_CHECK_HEADERS(security/pam_appl.h)
	PAMTARGET="pam"
    else
	PAMTARGET="no-pam"
    fi
])
case "$PAMTARGET" in
no-pam) echo pam authentication is disabled. ;;
pam) echo pam authentication is enabled. ;;
esac


dnl Implement --enable-debug option.

AC_ARG_ENABLE(debug,
[  --enable-debug	  enable non-reentrant debugging for wmls compiler (default: disabled)], [
  echo enabling WMLScript compiler debugging
  if test -n "$GCC"; then
    CFLAGS="$CFLAGS -Wall"
  fi
  AC_DEFINE(WS_DEBUG)
])


dnl Implement --enable-localtime option.

AC_ARG_ENABLE(localtime,
[  --enable-localtime	  log file time stamps in local time, not GMT (default: enabled)], [
  if test "$enableval" = yes; then
      echo enabling local time
      AC_DEFINE(LOG_TIMESTAMP_LOCALTIME)
  fi
],[
  echo enabling local time
  AC_DEFINE(LOG_TIMESTAMP_LOCALTIME)
])


dnl --enable-mutex-stats option.

AC_ARG_ENABLE(mutex-stats,
[  --enable-mutex-stats    produce information about lock contention], [
  if test "$enableval" = yes; then
      AC_DEFINE(MUTEX_STATS)
  fi
])


dnl --enable-cookies option.

AC_ARG_ENABLE(cookies,
[  --enable-cookies        enable cookie support for WSP (default: disabled)], [
  if test "$enableval" = yes; then
      AC_DEFINE(ENABLE_COOKIES)
  fi
])


dnl --enable-start-stop-daemon option.

AC_ARG_ENABLE(start-stop-daemon,
[  --enable-start-stop-daemon  compile the start-stop-daemon program], [
  if test "$enableval" = yes; then
     STARTSTOPDAEMONSRC="utils/start-stop-daemon.c"
  fi
])
AC_SUBST(STARTSTOPDAEMONSRC)


dnl Implement the --with-ssl option. 

AC_CONFIG_SECTION([Configuring OpenSSL support])
AC_ARG_WITH(ssl,
[  --with-ssl[=DIR]        where to look for OpenSSL libs and header files
                          DIR points to the installation [/usr/local/ssl]],
[ if test -d "$withval"; then 
    ssllib="$withval/lib"; 
    sslinc="$withval/include"
  else
    AC_MSG_ERROR(Unable to find OpenSSL libs and/or directories at $withval)
  fi
])


dnl Implement --enable-ssl option.

AC_MSG_CHECKING([whether to compile with SSL support])
AC_ARG_ENABLE(ssl,
[  --enable-ssl            enable SSL client and server support (default: enabled)], [
  if test "$enableval" = no ; then
    AC_MSG_RESULT(disabled)
    ssl=no
  else
    ssl=yes
  fi
],[
  ssl=yes
])

if test "$ssl" = "yes" ; then
  dnl test only if --with-ssl has not been used
  if test "x$ssllib" = "x" && test "x$sslinc" = "x"; then
    for loc in /usr/lib /usr/local/ssl/lib /usr/local/openssl/lib; do 
      if test -f "$loc/libssl.a"; then
        ssllib="$loc"
      fi
    done
    for loc in /usr/include/ssl /usr/include/openssl /usr/local/ssl/include \
               /usr/local/openssl/include; do
      if test -d "$loc"; then
        sslinc="$loc"
      fi
    done
  fi
  AC_MSG_RESULT(trying $ssllib $sslinc)
fi


dnl Implement the SSL library checking routine. 
dnl This will define HAVE_LIBSSL in config.h

if test "x$ssllib" != "x" && test "x$sslinc" != "x"; then
  CFLAGS="$CFLAGS -I$sslinc"
  LIBS="$LIBS -L$ssllib"

  AC_PATH_PROG(OPENSSL, openssl, no)
  if test "$OPENSSL" = "yes"; then
    AC_MSG_CHECKING([openssl version])
    openssl_version=`$OPENSSL version | awk '{print $2}'`
    AC_MSG_RESULT([$openssl_version])
  fi
  AC_CHECK_LIB(crypto, CRYPTO_lock,
  [ LIBS="$LIBS -lcrypto"
    AC_CHECK_LIB(ssl, SSL_library_init,
    [ AC_CHECK_LIB(ssl, SSL_connect)
      AC_CHECK_HEADERS(openssl/x509.h openssl/rsa.h openssl/crypto.h \
                       openssl/pem.h openssl/ssl.h openssl/err.h)
      AC_MSG_CHECKING(whether the OpenSSL library is multithread-enabled)
      AC_TRY_RUN([ 
        #define OPENSSL_THREAD_DEFINES
        #include <openssl/opensslconf.h>
        int main(void) {
        #if defined(THREADS)
          exit(0);
        #else
          exit(1);
        #endif
        }
      ], [
        AC_MSG_RESULT(yes)
        AC_DEFINE(HAVE_LIBSSL)
        LIBS="$LIBS -lssl"
        AC_MSG_CHECKING([whether to compile with SSL support])
	AC_MSG_RESULT(yes)
      ], [
        AC_ARG_ENABLE(ssl-thread-test,
        [  --disable-ssl-thread-test  disable the multithread test for the OpenSSL library
                          this will force to continue even if the test fails],
        [ if test "$enableval" = no ; then
            AC_MSG_RESULT([no, continue forced])
          fi
        ], [
          AC_MSG_RESULT(no)
          AC_MSG_ERROR(Either get a multithread-enabled SSL or configure with --disable-ssl)
        ])
      ], echo "Cross-compiling; make sure your SSL library is multithread-enabled"
      )
    ])
  ])
fi


AC_CONFIG_SECTION([Configuring DB support])

dnl Implement the --with-mysql option. 

AC_ARG_WITH(mysql,
[  --with-mysql[=DIR]      where to look for MySQL libs and header files
                          DIR points to the installation [/usr/local/mysql]],
[ if test -d "$withval"; then 
    mysqlloc="$withval"; 
  else
    AC_MSG_ERROR(Unable to find MySQL libs and/or directories at $withval)
  fi
])


dnl Implement the --enable-mysql option. This will set HAVE_MYSQL in config.h
dnl accordingly and enable the usage of the libmysqlclient routines.

AC_MSG_CHECKING([whether to compile with MySQL support])
AC_ARG_ENABLE(mysql,
[  --enable-mysql          enable MySQL storage (default: disabled)], [
  if test "$enableval" != yes ; then
    AC_MSG_RESULT(disabled)
else
  dnl test only if --with-mysql has not been used
  if test "x$mysqlloc" = "x" ; then
    AC_MSG_RESULT(searching)
    AC_PATH_PROGS(MYSQL_CONFIG, mysql_config, no)
    dnl check for MySQL 4.x style mysql_config information
    if test "$MYSQL_CONFIG" = "no"; then
      dnl mysql-3.x style 
      found=""
      for loc in /usr /usr/local ; do 
        if test "x$found" = "x" ; then 
          AC_MSG_CHECKING([for MySQL client support in])
          AC_MSG_RESULT($loc)
          AC_CHECK_FILE("$loc/include/mysql/mysql.h", 
            [CFLAGS="$CFLAGS -I$loc/include/mysql"; LIBS="$LIBS -L$loc/lib/mysql -lmysqlclient"]; found=1,
            [AC_CHECK_FILE("$loc/include/mysql.h", 
              [CFLAGS="$CFLAGS -I$loc/include"; LIBS="$LIBS -L$loc/lib -lmysqlclient"]; found=1
             )]
          )
	fi
      done
      if test "x$found" != "x1" ; then 
        AC_MSG_ERROR(Unable to find mysql.h)
      fi
    else
      dnl mysql-4.x style 
      AC_MSG_CHECKING([mysql version])
      mysql_version=`$MYSQL_CONFIG --version`
      AC_MSG_RESULT([$mysql_version])
      LIBS="$LIBS `$MYSQL_CONFIG --libs`"
      CFLAGS="$CFLAGS `$MYSQL_CONFIG --cflags`"
    fi
  else
      AC_MSG_RESULT(searching in $mysqlloc)
      AC_CHECK_FILE("$mysqlloc/include/mysql/mysql.h", 
        [CFLAGS="$CFLAGS -I$mysqlloc/include/mysql"; LIBS="$LIBS -L$mysqlloc/lib/mysql -lmysqlclient"],
        [AC_CHECK_FILE("$mysqlloc/include/mysql.h", 
          [CFLAGS="$CFLAGS -I$mysqlloc/include"; LIBS="$LIBS -L$mysqlloc/lib -lmysqlclient"],
          [AC_MSG_ERROR(Unable to find mysql.h under $mysqlloc)]
         )]
      )
  fi
  AC_CHECK_HEADERS(mysql/mysql.h mysql/mysql_com.h mysql/mysql_version.h)
  AC_CHECK_LIB(mysqlclient, mysql_init) 
  AC_DEFINE(HAVE_MYSQL)
  AC_MSG_CHECKING([whether to compile with MySQL support])
  AC_MSG_RESULT(yes)
  MYSQL="yes"
  fi
],[
  AC_MSG_RESULT(disabled)
])


dnl Implement the --enable-sdb option. This will set HAVE_SDB in config.h
dnl accordingly and enable the usage of the libsdb routines.

AC_MSG_CHECKING([whether to compile with LibSDB support])
AC_ARG_ENABLE(sdb,
[  --enable-sdb            enable LibSDB storage (default: disabled)], [
  if test "$enableval" != yes; then
    AC_MSG_RESULT(disabled)
  else
    AC_MSG_RESULT(searching)
    AC_PATH_PROGS(SDB_CONFIG, sdb-config, no)
    if test "$SDB_CONFIG" = "no"; then
      AC_MSG_ERROR(Unable to find sdb-config in path for SDB support)
    else
      AC_MSG_CHECKING([sdb version])
      sdb_version=`$SDB_CONFIG --version`
      AC_MSG_RESULT([$sdb_version])
      LIBS="$LIBS `$SDB_CONFIG --libs`"
      CFLAGS="$CFLAGS `$SDB_CONFIG --cflags`"
      AC_CHECK_HEADERS(sdb.h)
      dnl AC_CHECK_LIB(sdb, sdb_init, [LIBS="`$SDB_CONFIG --libs`"]) 
      AC_CHECK_FUNCS(sdb_init)
      AC_DEFINE(HAVE_SDB)
      AC_DEFINE_UNQUOTED(LIBSDB_VERSION, "$sdb_version")
      SDB="yes"
    fi
  fi
],[
  AC_MSG_RESULT(disabled)
])


dnl Implement the --with-dlr option.
dnl Checks which external DLR storage should be used. 

AC_ARG_WITH(dlr,
[  --with-dlr[=TYPE]       select DLR storage to use: internal/mysql/sdb (default: internal)], 
[ AC_CONFIG_SECTION([Configuring DLR support]) 
  AC_MSG_CHECKING([for DLR storage type])
  AC_MSG_RESULT($withval)
  case "$withval" in
  internal)
    ;;
  mysql)
    if test "$MYSQL" != "yes"; then
      AC_MSG_ERROR(Option --with-dlr=mysql requires MySQL client support)
    else
      AC_DEFINE(DLR_MYSQL)
    fi
    ;;
  sdb)
    if test "$SDB" != "yes"; then
      AC_MSG_ERROR(Option --with-dlr=sdb requires SDB support)
    else
      AC_DEFINE(DLR_SDB)
    fi
    ;;
  *) 
    AC_MSG_ERROR(Unknown DLR storage support!)
    exit 1 
    ;;
  esac
])


dnl Implement the --with-wtls option.
dnl Check to see if we should include WTLS support, and which library to use.

AC_ARG_WITH(wtls,
[  --with-wtls[=TYPE]      select WTLS version to use: openssl/baltimore], 
[ AC_CONFIG_SECTION([Configuring WTLS support]) 
  AC_MSG_CHECKING([for WTLS library])
  AC_MSG_RESULT($withval)
  case "$withval" in
  openssl) 
 	OLDLIBS="$LIBS"
	LIBS="$LIBS -L/usr/local/ssl/lib -lcrypto"
    AC_CHECK_LIB(crypto, RSA_new,
    [ AC_CHECK_HEADERS(openssl/objects.h openssl/rc5.h, 
        AC_DEFINE(HAVE_WTLS_OPENSSL),
        AC_MSG_WARN(OpenSSL installation seems to lack RC5 algorithm!)
      )
	])
	;;
  baltimore) 
    AC_MSG_ERROR(This WTLS library is yet not supported!)
    ;;
  *) 
    AC_MSG_ERROR(Unknown WTLS libary support!)
    exit 1 
    ;;
  esac
])

dnl Final Output

AC_CONFIG_SECTION([Generating output files]) 
AC_OUTPUT(Makefile)