dnl $Id: acsite.m4,v 1.72 2007/07/28 16:45:05 ca Exp $

dnl ##########################################################################
dnl ###  SM_UNSIGNED_SIZE_T - check for unsigned size_t
dnl ##########################################################################

AC_DEFUN([SM_UNSIGNED_SIZE_T], [
  AC_CACHE_CHECK([for unsigned size_t],
    sm_cv_unsigned_size_t,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <sys/types.h>

int main()
{
	size_t v;

	v = 0;
	--v;
	if (v > 0)
		exit(0);
	exit(1);
}
>>changequote([, ]),
      sm_cv_unsigned_size_t=yes,
      sm_cv_unsigned_size_t=no,
      sm_cv_unsigned_size_t=no
    )]
  )
  if test "$sm_cv_unsigned_size_t" = "yes"; then
    AC_DEFINE(HAVE_UNSIGNED_SIZE_T, 1, [Define if your system size_t is unsigned ])
  fi
])

dnl ##########################################################################
dnl ###  SM_UNSIGNED_CHAR - check for unsigned char
dnl ##########################################################################

AC_DEFUN([SM_UNSIGNED_CHAR], [
  AC_CACHE_CHECK([for unsigned char],
    sm_cv_unsigned_char,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <sys/types.h>

int main()
{
	char v;

	v = 0;
	--v;
	if (v > 0)
		exit(0);
	exit(1);
}
>>changequote([, ]),
      sm_cv_unsigned_char=yes,
      sm_cv_unsigned_char=no,
      sm_cv_unsigned_char=no
    )]
  )
  if test "$sm_cv_unsigned_char" = "yes"; then
    AC_DEFINE(HAVE_UNSIGNED_CHAR, 1, [Define if your system char is unsigned ])
  fi
])

dnl ##########################################################################
dnl ###  SM_STATFS_4ARGS - check for four-argument statfs call
dnl ##########################################################################

AC_DEFUN([SM_STATFS_4ARGS], [
  AC_CACHE_CHECK([for four-argument statfs call],
    sm_cv_statfs_4args,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#if HAVE_SYS_STATFS_H
#include <sys/statfs.h>
#endif
#if HAVE_SYS_MOUNT_H
#include <sys/param.h>
#include <sys/mount.h>
#endif

int main()
{
	char *dir;
	struct statfs fs;

	dir = ".";
	if (statfs(dir, &fs, sizeof fs, 0) == 0)
		exit(0);
	exit(1);
}
>>changequote([, ]),
      sm_cv_statfs_4args=yes,
      sm_cv_statfs_4args=no,
      sm_cv_statfs_4args=no
    )]
  )
  if test "$sm_cv_statfs_4args" = "yes"; then
    AC_DEFINE(HAVE_STATFS_4ARGS, 1, [Define if statfs uses four arguments])
  fi
])

dnl ##########################################################################
dnl ###  SM_FUNC_SNPRINTF - check for working snprintf()
dnl ##########################################################################

AC_DEFUN([SM_FUNC_SNPRINTF], [
  AC_CACHE_CHECK([for working snprintf],
    sm_cv_func_snprintf_works,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>

typedef struct {
  int length;
  char *test;
  int retval;
  char *result;
} test_t;

const test_t tests[] = {
  { 10, "12345678901234567890", 20, "123456789" },
#if 0
  { 0, "12345678901234567890", 20, NULL },
  { -1, "12345678901234567890", -1, NULL },
#endif
  { 0, NULL, 0, NULL }
};

int main() {
  char test1[1024];
  int i;

  for (i = 0; tests[i].test; i++) {
    memset(test1, 'X', sizeof(test1));
    if ((snprintf(test1, tests[i].length, "%s", tests[i].test)
         != tests[i].retval) ||
        (tests[i].result && strcmp(tests[i].result, test1)))
      exit(1);
  }

  exit(0);
}
>>changequote([, ]),
      sm_cv_func_snprintf_works=yes,
      sm_cv_func_snprintf_works=no,
      sm_cv_func_snprintf_works=no
    )]
  )
  if test "$sm_cv_func_snprintf_works" = "yes"; then
    AC_DEFINE(HAVE_SNPRINTF, 1, [Define if your system has a working snprintf])
  else
    LIBOBJS="$LIBOBJS snprintf.o"
  fi
])

dnl ##########################################################################
dnl ###  SM_TYPE - check for arbitrary type in arbitrary header file(s)
dnl ##########################################################################

dnl ### Usage: SM_TYPE(type_t, default, [ #include <hdr1.h> ... ])
AC_DEFUN([SM_TYPE], [
  AC_CACHE_CHECK(if $1 is defined, sm_cv_type_$1,
    AC_TRY_LINK($3,
      $1 x;,
      sm_cv_type_$1=yes,
      sm_cv_type_$1=no
    )
  )
  if test "$sm_cv_type_$1" != "yes"; then
    AC_DEFINE($1, $2, Define if your system does not have $1)
  fi
])

dnl ##########################################################################
dnl ###  SM_LIB_WRAP - check for TCP Wrappers library
dnl ##########################################################################

AC_DEFUN([SM_LIB_WRAP], [
  AC_CHECK_HEADERS(tcpd.h)
  if test "$ac_cv_header_tcpd_h" = "yes"; then
    sm_old_libs="$LIBS"
    LIBS="$LIBS -lwrap"
    AC_CACHE_CHECK([for libwrap library], sm_cv_lib_wrap_hosts_ctl,
      AC_TRY_LINK(
        [
          #include <stdio.h>
          #include <tcpd.h>
          int allow_severity;
          int deny_severity;
        ], [
          hosts_ctl("test", STRING_UNKNOWN, "10.0.0.1", STRING_UNKNOWN);
        ],
        sm_cv_lib_wrap_hosts_ctl=yes,
        sm_cv_lib_wrap_hosts_ctl=no
      )
    )
    if test "$sm_cv_lib_wrap_hosts_ctl" = "yes"; then
      AC_DEFINE(HAVE_LIBWRAP, 1, [Define if you have libwrap])
    else
      LIBS="$sm_old_libs"
    fi
  fi
])

dnl ##########################################################################
dnl ###  SM_CHECK_RES_SEARCH - check for broken res_search()
dnl ##########################################################################

AC_DEFUN([SM_CHECK_RES_SEARCH], [
  AC_CACHE_CHECK([for broken res_search],
    sm_cv_func_broken_res_search,
    AC_TRY_RUN(
      [
	#include <sys/types.h>
	#include <netinet/in.h>
	#include <arpa/nameser.h>
	#include <resolv.h>

	int main()
	{
	  unsigned char answer[1024];

	  if (res_search("unknown.sendmail.org", C_IN, T_MX,
		         answer, sizeof(answer)) == -1
	      && h_errno == 0)
	    exit(0);

	  exit(1);
	}
      ],
      sm_cv_func_broken_res_search=yes,
      sm_cv_func_broken_res_search=no
    )
  )
  if test "$sm_cv_func_broken_res_search" = "yes"; then
    AC_DEFINE(BROKEN_RES_SEARCH, 1,
              [Define if res_search sets h_errno to 0 on unknown hosts])
  fi
])

dnl dnl ##########################################################################
dnl dnl ###  SM_CHECK_DN_EXPAND - check for dn_expand()
dnl dnl ##########################################################################
dnl 
dnl AC_DEFUN([SM_CHECK_DN_EXPAND], [
dnl   AC_CACHE_CHECK([for dn_expand libraries],
dnl     sm_cv_func_dn_expand,
dnl 	AC_TRY_COMPILE(
dnl       [
dnl 	#include <sys/types.h>
dnl 	#include <netinet/in.h>
dnl 	#include <arpa/nameser.h>
dnl 	#include <resolv.h>
dnl 	#include <netdb.h>
dnl 
dnl 	int main()
dnl 	{
dnl 	  int n;
dnl 	  unsigned char msg[1024], *eomorig, *comp_dn;
dnl 	  char expand[1024];
dnl 
dnl 	  n = dn_expand(msg, eomorig, comp_dn, expand, sizeof(expand));
dnl 	}
dnl       ],
dnl       sm_cv_func_dn_expand=yes,
dnl       sm_cv_func_dn_expand=no
dnl     )
dnl   )
dnl   if test "$sm_cv_func_dn_expand" = "yes"; then
dnl     AC_DEFINE(DN_EXPAND_NEEDS_LIBRESOLV, 1,
dnl               [Define if dn_expand needs libresolv])
dnl   fi
dnl ])


dnl ##########################################################################
dnl ###  SM_TYPE_ACCEPT - check for type of 3rd arg to accept()
dnl ##########################################################################

AC_DEFUN([SM_TYPE_ACCEPT], [
  AC_CHECK_FUNCS(accept)
  if test "$ac_cv_func_accept" = "yes"; then
    AC_CACHE_CHECK([for type of argument 3 of accept],
      sm_cv_type_accept_arg3,
      for sm_type in 'socklen_t' 'size_t' 'unsigned long'  'unsigned int' 'int'; do
	AC_TRY_COMPILE(
	  [
	    #include <sys/types.h>
	    #include <sys/socket.h>
	  ], [
	    extern int accept(int, struct sockaddr *, $sm_type *);
          ],
          [ sm_cv_type_accept_arg3=$sm_type; break ]
        )
      done
      if test "$sm_cv_type_accept_arg3" = ""; then
	sm_cv_type_accept_arg3="int";
      fi
    )
    if test "$sm_cv_type_accept_arg3" != ""; then
      AC_DEFINE_UNQUOTED(socklen_T, $sm_cv_type_accept_arg3,
                         [Define to the type of the 3rd arg to accept()])
    fi
  fi
])

dnl ##########################################################################
dnl ###  SM_TYPE_GETSOCKOPT - check for type of 5th arg to getsockopt()
dnl ##########################################################################

AC_DEFUN([SM_TYPE_GETSOCKOPT], [
  AC_CHECK_FUNCS(getsockopt)
  if test "$ac_cv_func_getsockopt" = "yes"; then
    AC_CACHE_CHECK([for type of argument 5 of getsockopt],
      sm_cv_type_getsockopt_arg5,
      for sm_type in 'socklen_t' 'size_t' 'int'; do
	AC_TRY_COMPILE(
	  [
	    #include <sys/types.h>
	    #include <sys/socket.h>
	  ], [
	    extern int getsockopt(int, int, int, void *, $sm_type *);
          ],
          [ sm_cv_type_getsockopt_arg5=$sm_type; break ]
        )
      done
      if test "$sm_cv_type_getsockopt_arg5" = ""; then
	sm_cv_type_getsockopt_arg5="int";
      fi
    )
    if test "$sm_cv_type_getsockopt_arg5" != ""; then
      AC_DEFINE_UNQUOTED(sockoptlen_T, $sm_cv_type_getsockopt_arg5,
                         [Define to the type of the 5th arg to getsockopt()])
    fi
  fi
])

dnl ##########################################################################
dnl ###  SM_TYPE_GETPWNAME_R - check for POSIX conformance of getpwnam_r()
dnl ##########################################################################

AC_DEFUN([SM_TYPE_GETPWNAME_R], [
  AC_CHECK_FUNCS(getpwnam_r)
    AC_CACHE_CHECK([for POSIX conformance of getpwnam_r],
      sm_cv_posix_getpwnam_r,
	[AC_TRY_LINK(
changequote(<<, >>)<<
#ifndef _POSIX_PTHREAD_SEMANTICS
#define _POSIX_PTHREAD_SEMANTICS 1
#endif
#include <pwd.h>
int r;
struct passwd *pwent;
struct passwd pwentb;
char buf[1024];
	  >>,
	  <<
	    r = getpwnam_r("root", &pwentb, buf, sizeof(buf), &pwent);
>>changequote([, ]),
      sm_cv_posix_getpwnam_r=yes,
      sm_cv_posix_getpwnam_r=no
        )]
    )
  if test "$sm_cv_posix_getpwnam_r" = "yes"; then
	AC_DEFINE_UNQUOTED(POSIX_GETPWNAM_R, 1, [Define if getpwnam_r() conforms to POSIX])
  fi
])


dnl ##########################################################################
dnl ###  SM_SIGWAIT - check for interface to sigwait()
dnl ##########################################################################

AC_DEFUN([SM_SIGWAIT], [
  AC_CHECK_FUNCS(sigwait)
  if test "$ac_cv_func_sigwait" = "yes"; then
    AC_CACHE_CHECK([whether sigwait takes only one argument],
      sm_cv_func_sigwait_one_arg,
      AC_TRY_COMPILE(
	[
	  #include <signal.h>
	], [
	  extern int sigwait(sigset_t *);
	],
	sm_cv_func_sigwait_one_arg=yes,
	sm_cv_func_sigwait_one_arg=no
      )
    )
    if test "$sm_cv_func_sigwait_one_arg" = "yes"; then
      AC_DEFINE(SIGWAIT_ONE_ARG, 1, [Define if sigwait() takes only one arg])
    fi
  fi
])

dnl ##########################################################################
dnl ###  SM_TYPE_CTIME_R - check ctime_r() parameters:
dnl ###  char *ctime_r(const time_t *clock, char *buf);
dnl ###  char *ctime_r(const time_t *clock, char *buf, int buflen);
dnl ##########################################################################

AC_DEFUN([SM_TYPE_CTIME_R], [
  AC_CHECK_FUNCS(ctime_r)
  if test "$ac_cv_func_ctime_r" = "yes"; then
    AC_CACHE_CHECK([ctime_r API], sm_cv_type_ctime_r,
	AC_TRY_COMPILE(
	  [
	    #include <sys/types.h>
	    #include <sys/socket.h>
	  ], [
	    extern char *ctime_r(const time_t *_clock, char *_buf);
	  ],
	  [ sm_cv_type_ctime_r=2 ],
	    AC_TRY_COMPILE(
	      [
	        #include <sys/types.h>
	        #include <sys/socket.h>
	      ], [
	        extern char *ctime_r(const time_t *_clock, char *_buf, int _buflen);
	      ],
	      [ sm_cv_type_ctime_r=3 ],
	   )
	)
      if test "$sm_cv_type_ctime_r" = ""; then
	sm_cv_type_ctime_r=0;
      fi
    )
    if test "$sm_cv_type_ctime_r" != ""; then
      AC_DEFINE_UNQUOTED(SM_CTIME_R_API, $sm_cv_type_ctime_r,
			 [Specify API of ctime_r()])
    fi
  fi
])

dnl ##########################################################################
dnl ###  SM_SAFE_CTYPE ctype.h misbehaves with non-ASCII characters.
dnl ##########################################################################

AC_DEFUN([SM_SAFE_CTYPE], [
  AC_CACHE_CHECK([for safe ctype],
    sm_cv_safe_ctype,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <ctype.h>

int main()
{
	int v;
	char upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+-=|~,./;'[]<>?:{}  ";
	char lower[] = "abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=|~,./;'[]<>?:{}  ";

	v = EOF;
	if (isalnum(v))
		exit(1);
	if (isprint(v))
		exit(1);
	upper[sizeof(upper) - 2] = '\"';
	lower[sizeof(lower) - 2] = '\"';
	for (v = 128; v < 256; v++)
		if (isalnum(v))
			exit(1);
	for (v = 0; v < sizeof(upper); v++)
	{
		if (tolower(upper[v]) != lower[v])
			exit(1);
		if (toupper(lower[v]) != upper[v])
			exit(1);
	}
	exit(0);
}
>>changequote([, ]),
      sm_cv_safe_ctype=yes,
      sm_cv_safe_ctype=no,
      sm_cv_safe_ctype=no
    )]
  )
  if test "$sm_cv_safe_ctype" = "yes"; then
    AC_DEFINE(HAVE_SAFE_CTYPE, 1, [Define if your system ctype is 8 bit safe ])
  fi
])

dnl ##########################################################################
dnl ###  SM___PROGNAME - check for __progname
dnl ##########################################################################

AC_DEFUN([SM___PROGNAME], [
  AC_CACHE_CHECK([for __progname],
    sm_cv___progname,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>

extern char **__progname;
int main()
{
	printf("%s\n", __progname);
	exit(0);
}
>>changequote([, ]),
      sm_cv___progname=yes,
      sm_cv___progname=no,
      sm_cv___progname=no
    )]
  )
  if test "$sm_cv___progname" = "yes"; then
    AC_DEFINE(HAVE___PROGNAME, 1, [Define if your system has char *__progname ])
  fi
])

dnl ##########################################################################
dnl ###  SM_MSGHDR_MSG_CONTROL - check if msghdr{} has msg_control member.
dnl ##########################################################################

AC_DEFUN([SM_MSGHDR_MSG_CONTROL], [
AC_CACHE_CHECK(if msghdr{} has msg_control member, ac_cv_msghdr_has_msg_control,
	AC_TRY_COMPILE([
#		include <sys/types.h>
#		include <sys/socket.h>],
		[unsigned int i = sizeof(((struct msghdr *)0)->msg_control)],
	ac_cv_msghdr_has_msg_control=yes,
	ac_cv_msghdr_has_msg_control=no))
if test $ac_cv_msghdr_has_msg_control = yes ; then
	AC_DEFINE(HAVE_MSGHDR_MSG_CONTROL, 1, [Define if msghdr{} has msg_control member])
fi
])

dnl ##########################################################################
dnl ###  SM_SOCK_UN_SUN_LEN - check if sockaddr_un has sun_len member.
dnl ##########################################################################

AC_DEFUN([SM_SOCK_UN_SUN_LEN], [
AC_CACHE_CHECK(if sockaddr_un has sun_len member, ac_cv_sock_un_sun_len,
	AC_TRY_COMPILE([
#		include <sys/types.h>
#		include <sys/socket.h>
#		include <sys/un.h>],
		[unsigned int i = sizeof(((struct sockaddr_un *)0)->sun_len)],
	ac_cv_sock_un_sun_len=yes,
	ac_cv_sock_un_sun_len=no))
if test $ac_cv_sock_un_sun_len = yes ; then
	AC_DEFINE(HAVE_SOCK_UN_SUN_LEN, 1, [Define if sockaddr_un has sun_len member])
fi
])

dnl ##########################################################################
dnl ###  SM_RUSAGE_MEMBER - Check if rusage{} has XYZ member.
dnl ##########################################################################

AC_DEFUN([SM_RUSAGE_MEMBER], [
AC_CACHE_CHECK(if rusage{} has $1 member, ac_cv_rusage_has_$1,
	AC_TRY_COMPILE([
#		include <sys/time.h>
#		include <sys/resource.h>],
		[unsigned int i = sizeof(((struct rusage *)0)->$1)],
	ac_cv_rusage_has_$1=yes,
	ac_cv_rusage_has_$1=no))
if test $ac_cv_rusage_has_$1 = yes ; then
	AC_DEFINE(SM_RUSAGE_$1, 1, [Define if rusage{} has $1 member])
fi
])

dnl ##########################################################################
dnl ###  SM_STAT_MEMBER - Check if stat{} has XYZ member.
dnl ##########################################################################

AC_DEFUN([SM_STAT_MEMBER], [
AC_CACHE_CHECK(if stat{} has $1 member, ac_cv_stat_has_$1,
	AC_TRY_COMPILE([
#		include <sys/types.h>
#		include <sys/stat.h>],
		[unsigned int i = sizeof(((struct stat *)0)->$1)],
	ac_cv_stat_has_$1=yes,
	ac_cv_stat_has_$1=no))
if test $ac_cv_stat_has_$1 = yes ; then
	AC_DEFINE(SM_STAT_$1, 1, [Define if stat{} has $1 member])
fi
])


dnl ##########################################################################
dnl ###  SM_INET_BLKSIZE stat(inet-sock) returns useful value for blksize
dnl ##########################################################################

AC_DEFUN([SM_INET_BLKSIZE], [
  AC_CACHE_CHECK([stat(inet-sock) returns useful value for blksize],
    sm_cv_stblksz_inet,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>

int
main(int argc, char **argv)
{
	int fd, r, sockt;
	struct stat st;

	sockt = PF_INET;
	if (argc > 1)
	{
		if (strcasecmp(argv[1], "unix") == 0)
			sockt = PF_UNIX;
		else if (strcasecmp(argv[1], "inet") == 0)
			sockt = PF_INET;
		else return -1;
	}
	fd = socket(sockt, SOCK_STREAM, 0);
	if (fd == -1)
		return -1;
	r = fstat(fd, &st);
	if (r == -1)
		return -1;
	if (st.st_blksize < 256)
		return 1;
	return 0;
}
>>changequote([, ]),
      sm_cv_stblksz_inet=yes,
      sm_cv_stblksz_inet=no,
      sm_cv_stblksz_inet=no
    )]
  )
  if test "$sm_cv_stblksz_inet" = "yes"; then
    AC_DEFINE(HAVE_STBLKSZ_INET, 1, [Define if your system returns useful blksize for inet sockets])
  fi
])


dnl ##########################################################################
dnl ###  SM_FREE_NULL - check whether free(NULL) is ok
dnl ##########################################################################

AC_DEFUN([SM_FREE_NULL], [
  AC_CACHE_CHECK([for free(NULL)],
    sm_cv_free_null,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <stdlib.h>

int main()
{
	free(0);
	exit(0);
}
>>changequote([, ]),
      sm_cv_free_null=yes,
      sm_cv_free_null=no,
      sm_cv_free_null=no
    )]
  )
  if test "$sm_cv_free_null" = "yes"; then
    AC_DEFINE(HAVE_FREE_NULL, 1, [Define if your system allows free(NULL)])
  fi
])

dnl ##########################################################################
dnl ###  SM_STRFTIME_E - check whether strftime() supports %e
dnl ##########################################################################

AC_DEFUN([SM_STRFTIME_E], [
  AC_CACHE_CHECK([strftime() supports %e],
    sm_cv_strftime_e,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <sys/types.h>
#include <time.h>

int main(int argc, char **argv)
{
	size_t r;
	time_t t;
	struct tm *ttm;
	char buf[64];

	t = (time_t) 10000;
	ttm = localtime(&t);
	buf[0] = '\0';
	r = strftime(buf, sizeof(buf), "%e", ttm);
	return strcmp(" 1", buf) == 0;
}
>>changequote([, ]),
      sm_cv_strftime_e=yes,
      sm_cv_strftime_e=no,
      sm_cv_strftime_e=no
    )]
  )
  if test "$sm_cv_strftime_e" = "yes"; then
    AC_DEFINE(HAVE_STRFTIME_E, 1, [Define if strftime() supports %e])
  fi
])


dnl ##########################################################################
dnl ###  Berkeley DB 4.x (x > 0)
dnl ##########################################################################

define(BERKELEY_DB4x_FUNC,
changequote(<<, >>)<<
#include <stdio.h>
#include <db.h>

#if DB_VERSION_MAJOR != 4 || (DB_VERSION_MINOR < 1 || DB_VERSION_MINOR > 5)
# error  wrong DB version, need 4.[1-5]
_DB_VERSION_MAJOR DB_VERSION_MAJOR
_DB_VERSION_MINOR DB_VERSION_MINOR
#endif

int
main(int argc, char **argv)
{
	DB *db;
	int ret;

	ret = db_create(&db, 0, 0);
	return 0;
}
>>changequote([, ]))

define(BERKELEY_DB4x_FULL,
changequote(<<, >>)<<
#include <stdio.h>
#include <db.h>
#define BDB_NAME "bdb"
static int
bdb_open(void)
{
	int r;
	unsigned int flags;
	int major_v, minor_v, patch_v;
	char *dbfile, *dbh;
	DB *dbp;
	DB_ENV *dbenv;
	DB_TXN *db_txn;

	dbp = NULL;
	dbenv = NULL;
	db_txn = NULL;
	dbfile = NULL;
	(void) db_version(&major_v, &minor_v, &patch_v);
	if (major_v != DB_VERSION_MAJOR || minor_v != DB_VERSION_MINOR)
		return -1;
	r = db_env_create(&dbenv, 0);
	if (r != 0)
	{
		dbenv->err(dbenv, r, "db_env_create");
		goto error;
	}
	flags = DB_CREATE | DB_INIT_MPOOL | DB_INIT_TXN |
			DB_INIT_LOCK | DB_PRIVATE | DB_RECOVER;
	dbh = BDB_NAME;
	r  = dbenv->open(dbenv, dbh, flags, 0600);
	if (r != 0)
	{
		dbenv->err(dbenv, r,
			"where=DB_ENV->open, dbhome=%s", dbh);
		goto error;
	}

	/* Create and initialize database object, open the database. */
	r = db_create(&dbp, dbenv, 0);
	if (r != 0)
		goto error;

	db_txn = NULL;
	r = dbenv->txn_begin(dbenv, NULL, &db_txn, 0);
	if (r != 0)
		goto error;

	dbfile = BDB_NAME;

	flags = DB_CREATE;
	r = dbp->open(dbp, db_txn, dbfile, NULL, DB_BTREE, flags, 0600);
	if (r != 0)
	{
		dbp->err(dbp, r, "where=db->open, db=%s", BDB_NAME);
		if (db_txn != NULL)
		{
			(void) db_txn->abort(db_txn);
			db_txn = NULL;
		}
		goto error;
	}

	if (db_txn != NULL)
	{
		r = db_txn->commit(db_txn, 0);
		db_txn = NULL;
		if (r != 0)
			goto error;
	}

	return 0;

  error:
	if (dbp != NULL)
		(void) dbp->close(dbp, 0);
	if (dbenv != NULL)
		(void) dbenv->close(dbenv, 0);
	return r;
}

int
main(int argc, char **argv)
{
	int r;

	(void) unlink(BDB_NAME "/bdb");
	(void) unlink(BDB_NAME "/log.0000000001");
	(void) unlink(BDB_NAME);
	(void) rmdir(BDB_NAME);
	(void) mkdir(BDB_NAME, 0775);
	r = bdb_open();
	(void) unlink(BDB_NAME "/bdb");
	(void) unlink(BDB_NAME "/log.0000000001");
	(void) rmdir(BDB_NAME);
	return r;
}
>>changequote([, ]))

AC_DEFUN([BERKELEY_DB4x_CHK_LIB],
[
	DBLIBS="db-4.5 db4.5 db45 db4-4.5 db-4.4 db4.4 db44 db4-4.4 db-4.3 db4.3 db43 db4-4.3 db-4.2 db4.2 db42 db4-4.2 db-4.1 db4.1 db41 db-4 db4 db"
	dnl if lib is specified: try static (lib.a)
	bdb_wo_fdatasync="unknown"
	if test -d "$with_bdb_lib"; then
	    BDB_LIBADD="$with_bdb_lib"
	    for dbname in $DBLIBS
	    do
	        BDB2_SAVE_LIBS=$LIBS
	        LIBS="$LIBS $BDB_LIBADD/lib${dbname}.a"
		AC_TRY_RUN(BERKELEY_DB4x_FUNC,
			MTA_DB_LIB="$BDB_LIBADD/lib${dbname}.a";
			dblib="berkeley"; break, dblib="no")

	        if test $dblib = "no" -a $fdatasync_in_lrt; then
	          BDB3_SAVE_LIBS=$LIBS
	          LIBS="$LIBS $MTA_FDATASYNC_LIB"
	          AC_TRY_RUN([BERKELEY_DB4x_FUNC],
			MTA_DB_LIB="$BDB_LIBADD/lib${dbname}.a $MTA_FDATASYNC_LIB";
			dblib="berkeley"; break, dblib="no")
	          LIBS=$BDB3_SAVE_LIBS
	        fi

	        LIBS=$BDB2_SAVE_LIBS
	    done
	else
	    for dbname in $DBLIBS
	    do
	        BDB2_SAVE_LIBS=$LIBS
	        LIBS="$LIBS -l${dbname}"
		AC_TRY_RUN(BERKELEY_DB4x_FUNC,
			MTA_DB_LIB="-l${dbname}";
			dblib="berkeley"; break, dblib="no")

	        if test $dblib = "no" -a $fdatasync_in_lrt; then
	          BDB3_SAVE_LIBS=$LIBS
	          LIBS="$LIBS $MTA_FDATASYNC_LIB"
	          AC_TRY_RUN([BERKELEY_DB4x_FUNC],
			MTA_DB_LIB="-l${dbname} $MTA_FDATASYNC_LIB";
			dblib="berkeley"; break, dblib="no")
	          LIBS=$BDB3_SAVE_LIBS
	        fi

	        LIBS=$BDB2_SAVE_LIBS
	    done
	fi

	if test $dblib != "no" -a $fdatasync_in_lrt; then
	  BDB3_SAVE_LIBS=$LIBS
	  LIBS="$LIBS $MTA_DB_LIB"
	  AC_TRY_RUN([BERKELEY_DB4x_FULL],
		bdb_wo_fdatasync="ok", bdb_wo_fdatasync="no")
	  LIBS=$BDB3_SAVE_LIBS
	  if test $bdb_wo_fdatasync = "no"; then
	    BDB3_SAVE_LIBS=$LIBS
	    LIBS="$LIBS $MTA_DB_LIB $MTA_FDATASYNC_LIB"
	    AC_TRY_RUN([BERKELEY_DB4x_FULL],
		MTA_DB_LIB="$MTA_DB_LIBS $MTA_FDATASYNC_LIB";
		dblib="berkeley"; break, dblib="no")
	    LIBS=$BDB3_SAVE_LIBS
	  fi
	fi
])

AC_DEFUN([BERKELEY_DB4x_CHK],
[
	if test -d "$with_bdb_inc"; then
	    CPPFLAGS="$CPPFLAGS -I$with_bdb_inc"
	    BDB_INCADD="-I$with_bdb_inc"
	else
	    BDB_INCADD=""
	fi

	AC_CHECK_HEADER(db.h,
                       	BERKELEY_DB4x_CHK_LIB()
			MTA_DB_INC=$BDB_INCADD,
                        dblib="no")
])

AC_DEFUN([SM_BERKELEYDB4], [
  AC_CACHE_CHECK([for Berkeley DB 4.x],
    sm_cv_berkeleyDB4,
    [
	BDB_SAVE_LIBS=$LIBS
	BDB_SAVE_LDFLAGS=$LDFLAGS
	LIBS="$LIBS $MTA_DB_LIB"
	if test -d "$with_bdb_lib"; then
	    LDFLAGS="$LDFLAGS -L$with_bdb_lib"
	fi
AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <db.h>

/*
**  If you change this, change also include/sm/bdb.h
*/
#if DB_VERSION_MAJOR != 4 || (DB_VERSION_MINOR < 1 && DB_VERSION_MINOR > 4)
# error  wrong DB version, need 4.x (x > 0)
#endif
#define DB_CACHE_SIZE	1024

int
main(int argc, char **argv)
{
	char *name;
	DBTYPE dbtype;
	DB *db;
	int flags, ret;

	db = NULL;
	flags = DB_CREATE;
	dbtype = DB_HASH;
	ret = db_create(&db, NULL, 0);
	name = "dbtest.db";
	if (ret == 0 && db != NULL)
	{
		ret = db->set_cachesize(db, 0, DB_CACHE_SIZE, 0);
		if (ret != 0)
		{
			(void) db->close(db, 0);
			exit(1);
		}
	}
	if (ret == 0 && db != NULL)
	{
		ret = db->open(db, NULL, name, NULL, dbtype, flags, 0640);
		if (ret != 0)
		{
			(void) db->close(db, 0);
			exit(1);
		}
		(void) db->close(db, 0);
	}
	unlink(name);
	exit(0);
}
>>changequote([, ]),
      sm_cv_berkeleyDB4=yes,
      sm_cv_berkeleyDB4=no,
      sm_cv_berkeleyDB4=no
    )]
	LIBS=$BDB_SAVE_LIBS
	LDFLAGS=$BDB_SAVE_LDFLAGS
  )
  if test "$sm_cv_berkeleyDB4" = "yes"; then
    AC_DEFINE(HAVE_BERKELEYDB4, 1, [Define if Berkeley DB 4.x (x > 0) is available])
  fi
])


dnl ##########################################################################
dnl ###  SYS_NERR
dnl ##########################################################################

AC_DEFUN([SM_SYS_NERR], [
  AC_CACHE_CHECK([for sys_nerr],
    sm_cv_sys_nerr,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <string.h>

int
main(int argc, char **argv)
{
	return (sys_nerr > 0) ? 0 : 1;
}
>>changequote([, ]),
      sm_cv_sys_nerr=yes,
      sm_cv_sys_nerr=no,
      sm_cv_sys_nerr=no
    )]
  )
  if test "$sm_cv_sys_nerr" = "yes"; then
    AC_DEFINE(HAVE_SYS_NERR, 1, [Define if sys_nerr is available])
  fi
])

dnl ##########################################################################
dnl ###  SYS_ERRLIST
dnl ##########################################################################

AC_DEFUN([SM_SYS_ERRLIST], [
  AC_CACHE_CHECK([for sys_errlist],
    sm_cv_sys_errlist,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <string.h>

int
main(int argc, char **argv)
{
	/* hopefully errno==1 is defined */
	return (sys_errlist[1]) ? 0 : 1;
}
>>changequote([, ]),
      sm_cv_sys_errlist=yes,
      sm_cv_sys_errlist=no,
      sm_cv_sys_errlist=no
    )]
  )
  if test "$sm_cv_sys_errlist" = "yes"; then
    AC_DEFINE(HAVE_SYS_ERRLIST, 1, [Define if sys_errlist is available])
  fi
])


dnl ##########################################################################
dnl ###  PTHREAD_RWLOCK_INIT
dnl ##########################################################################

AC_DEFUN([SM_PTHREAD_RWLOCK_INIT], [
  AC_CACHE_CHECK([for pthread_rwlock_init],
    sm_cv_pthread_rwlock_init,
    [AC_TRY_RUN(
changequote(<<, >>)<<
#include <pthread.h>

int
main(int argc, char **argv)
{
	pthread_rwlock_t rwl;

	if (pthread_rwlock_init(&rwl, 0) != 0)
		exit(1);
	pthread_rwlock_destroy(&rwl);
	exit(0);
}
>>changequote([, ]),
      sm_cv_pthread_rwlock_init=yes,
      sm_cv_pthread_rwlock_init=no,
      sm_cv_pthread_rwlock_init=no
    )]
  )
  if test "$sm_cv_pthread_rwlock_init" = "yes"; then
    AC_DEFINE(HAVE_PTHREAD_RWLOCK_INIT, 1, [Define if pthread_rwlock_init is available])
  fi
])

dnl ##########################################################################
dnl ###  SM_TLS
dnl ##########################################################################

AC_DEFUN([SM_TLS], [
 AC_ARG_ENABLE(TLS, [  --enable-TLS           enable STARTTLS (check libraries) ],
  smtls=$enableval,
  smtls=yes)
  AC_MSG_CHECKING(TLS support)
  MTA_TLS_LIB=""
  if test "$smtls" != no; then
    AC_CHECK_LIB(crypto, BIO_write,
	MTA_TLS_LIB="$MTA_TLS_LIB -lcrypto"; lcrypto="yes", lcrypto="no")
    TLS_SAVE_LIBS=$LIBS
    LIBS="$LIBS $MTA_TLS_LIB"
    AC_CHECK_LIB(ssl, SSL_CTX_new,
	MTA_TLS_LIB="-lssl $MTA_TLS_LIB"; lssl="yes", lssl="no")
    if test "$lcrypto" != no -a "lssl" != no; then
      AC_CACHE_CHECK([for OpenSSL availability],
        sm_cv_openssl,
        [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <openssl/ssl.h>

int main(int argc, char **argv)
{
	unsigned int linkversion;

	linkversion = (unsigned int) SSLeay();
	fprintf(stderr,
		"OpenSSL versions:\n"
		"compiled against: version=0x%08x\n"
		"linked against:   version=0x%08x\n"
		, (unsigned int) OPENSSL_VERSION_NUMBER, linkversion);
	exit(((unsigned int) OPENSSL_VERSION_NUMBER == linkversion)
		? 0 : 1);
}
>>changequote([, ]),
        sm_cv_openssl=yes,
        sm_cv_openssl=no,
        sm_cv_openssl=no
        )]
      )
      if test "$sm_cv_openssl" != no; then
        AC_DEFINE(MTA_USE_TLS, 1, [Define if TLS is available and should be used])
        AC_MSG_RESULT(enabled)
      else
        AC_MSG_RESULT(disabled due to failure in test compilation)
      fi
    else
      AC_MSG_RESULT(disabled due to missing libraries)
    fi
    LIBS=$TLS_SAVE_LIBS
  else
    AC_MSG_RESULT(disabled)
  fi
  AC_SUBST(MTA_TLS_LIB)
])

dnl ##########################################################################
dnl ###  SM_SASL
dnl ##########################################################################

AC_DEFUN([SM_SASL], [
 AC_ARG_ENABLE(SASL, [  --enable-SASL          enable SASL (check libraries) ],
  smsasl=$enableval,
  smsasl=yes)
  AC_MSG_CHECKING(SASL support)
  MTA_SASL_LIB=""
  MTA_SASL_INC=""
  if test "$smsasl" = yes; then
    SASL_SAVE_LDFLAGS=$LDFLAGS
    SASL_SAVE_CFLAGS=$CFLAGS
    SASL_SAVE_CPPFLAGS=$CPPFLAGS
    SASL_SAVE_LIBS=$LIBS
    SASL_ADD_L=""
    if test -d "$with_sasl_lib"; then
      SASL_ADD_L="-L$with_sasl_lib"
      LDFLAGS="$LDFLAGS $SASL_ADD_L"
    fi
    SM_SASL_LIB="-lsasl2"
    AC_CHECK_LIB(sasl, sasl_server_init, [SM_SASL_LIB="-lsasl"])
    AC_CHECK_LIB(sasl2, sasl_server_init, [SM_SASL_LIB="-lsasl2"])
    LIBS="$LIBS $SM_SASL_LIB"
    AC_CHECK_FUNCS([sasl_version_info])
    if test -d "$with_sasl_inc"; then
      CPPFLAGS="$CPPFLAGS -I$with_sasl_inc"
      SASL_INCADD="-I$with_sasl_inc"
    else
      SASL_INCADD=""
    fi
    AC_CHECK_HEADER(sasl/sasl.h,
		[MTA_SASL_INC=$SASL_INCADD; sm_cv_cyrus_saslhdr="yes"],
		[sm_cv_cyrus_saslhdr="no"])
    if test "$sm_cv_cyrus_saslhdr" = yes; then
    AC_CACHE_CHECK([for Cyrus SASL v2 availability],
      sm_cv_cyrus_saslv2,
      [AC_TRY_RUN([
#include <stdio.h>
#include <sasl/sasl.h>

#if !HAVE_SASL_VERSION_INFO
void sasl_version_info(const char **implementation,
		       const char **version_string,
		       int *version_major,
		       int *version_minor,
		       int *version_step,
		       int *version_patch)
{
	int v;
	sasl_version(implementation, &v);
	if (version_major)
		*version_major = (v >> 24) & 0xff;
	if (version_minor)
		*version_minor = (v >> 16) & 0xff;
	if (version_step)
		*version_step = v & 0xffff;
	if (version_patch)
		*version_patch = 0;
}
#endif

int main(int argc, char **argv)
{
	const char *implementation, *version_string;
	int r, version_major, version_minor, version_step, version_patch;

	sasl_version_info(&implementation, &version_string,
                          &version_major, &version_minor, &version_step,
                          &version_patch);
	if (version_major != 2)
		exit(1);
	r = sasl_server_init(NULL, "sendmail");
	exit(0);
}],
      sm_cv_cyrus_saslv2=yes,
      sm_cv_cyrus_saslv2=no,
      sm_cv_cyrus_saslv2=no
      )]
    )
    fi
    if test "$sm_cv_cyrus_saslv2" = yes; then
      MTA_SASL_LIB="$SASL_ADD_L $SM_SASL_LIB"
      AC_DEFINE(MTA_USE_SASL, 1, [Define if SASL is available and should be used])
      AC_MSG_RESULT(enabled)
    else
      AC_MSG_RESULT(disabled due to failure in test compilation)
    fi
    LIBS=$SASL_SAVE_LIBS
    CFLAGS=$SASL_SAVE_CFLAGS
    LDFLAGS=$SASL_SAVE_LDFLAGS
    CPPFLAGS=$SASL_SAVE_CPPFLAGS
  else
    AC_MSG_RESULT(disabled)
  fi
  AC_SUBST(MTA_SASL_LIB)
  AC_SUBST(MTA_SASL_INC)
])


dnl ##########################################################################
dnl ###  SM_RES_QUERY_PROTOTYPE - check whether res_query prototype is available
dnl ##########################################################################

AC_DEFUN([SM_RES_QUERY_PROTOTYPE], [
  AC_CACHE_CHECK([check whether res_query prototype is available],
    sm_cv_res_query_prototype,
    AC_TRY_COMPILE([
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <resolv.h>],
	[
	int (*resfunc)(const char *, int, int, unsigned char *, int);
	resfunc = res_query;
	],
      sm_cv_res_query_prototype=yes,
      sm_cv_res_query_prototype=no
    )
  )
  if test "$sm_cv_res_query_prototype" = "yes"; then
    AC_DEFINE(HAVE_RES_QUERY_PROTOTYPE, 1, [Define if your system has res_query() prototype])
  fi
])


dnl ##########################################################################
dnl ###  SM_NEED_NAMESER_COMPAT_H - check whether nameser_compat.h is needed
dnl ##########################################################################

AC_DEFUN([SM_NEED_NAMESER_COMPAT_H], [
  AC_CHECK_HEADERS(arpa/nameser_compat.h)
  AC_CHECK_HEADERS(arpa/nameser8_compat.h)
  AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <arpa/nameser.h>

int main()
{
	int i;
	HEADER hp;

	i = T_MX;
	i += hp.qdcount;
	exit(0);
}
>>changequote([, ]),
      sm_cv_need_nameser_compat_h=no,
      sm_cv_need_nameser_compat_h=maybe,
      sm_cv_need_nameser_compat_h=maybe
  )
  if test "$sm_cv_need_nameser_compat_h" = "maybe"; then
    if test "$ac_cv_header_arpa_nameser8_compat_h" = "yes"; then
      AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <arpa/nameser.h>
#include <arpa/nameser8_compat.h>

int main()
{
	int i;
	HEADER hp;

	i = T_MX;
	i += hp.qdcount;
	exit(0);
}
>>changequote([, ]),
        sm_cv_need_nameser8_compat_h=yes,
        sm_cv_need_nameser8_compat_h=no,
        sm_cv_need_nameser8_compat_h=no
      )
      if test "$sm_cv_need_nameser8_compat_h" = "yes"; then
        AC_DEFINE(NEED_NAMESER8_COMPAT, 1, [Define if your system needs arpa/nameser8_compat.h])
      fi
    fi
    if test "$ac_cv_header_arpa_nameser_compat_h" = "yes" -a "$sm_cv_need_nameser8_compat_h" = "no"; then
      AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <arpa/nameser.h>
#include <arpa/nameser_compat.h>

int main()
{
	int i;
	HEADER hp;

	i = T_MX;
	i += hp.qdcount;
	exit(0);
}
>>changequote([, ]),
        sm_cv_need_nameser_compat_h=yes,
        sm_cv_need_nameser_compat_h=no,
        sm_cv_need_nameser_compat_h=no
      )
    fi
    if test "$sm_cv_need_nameser_compat_h" = "yes"; then
      AC_DEFINE(NEED_NAMESER_COMPAT, 1, [Define if your system needs arpa/nameser_compat.h])
    fi
  fi
])


dnl ##########################################################################
dnl ###  SM_SHA
dnl ##########################################################################

dnl check for SHA1
dnl AC_CHECK_HEADERS(sha1.h)
dnl AC_CHECK_FUNCS(SHA1Init SHA1Update SHA1Final)
dnl AC_CHECK_FUNCS(SHA1_Init SHA1_Update SHA1_Final)
dnl AC_CHECK_LIB(crypto, SHA1)

AC_DEFUN([SM_SHA], [
  MTA_SHA_LIB=""
  AC_CHECK_HEADERS(openssl/sha.h)
  if test "$ac_cv_header_openssl_sha_h" = "yes"; then
    SM_OLD_LIBS="$LIBS"
    LIBS="$LIBS -lcrypto"
    AC_CACHE_CHECK([check whether SHA1 works],
      sm_cv_sha1,
      [AC_TRY_RUN(
changequote(<<, >>)<<
#include <stdio.h>
#include <openssl/sha.h>

int main()
{
	unsigned char md[SHA_DIGEST_LENGTH];
	const char *d = "sha1 test";
	unsigned long n;

	n = strlen(d);
	SHA1(d, n, md);
	exit(0);
}
>>changequote([, ]),
      sm_cv_sha1=yes,
      sm_cv_sha1=no,
      sm_cv_sha1=no
      )]
    )
    if test "$sm_cv_sha1" = "yes"; then
      AC_DEFINE(HAVE_SHA1, 1, [Define if your system has a working SHA1() function])
      AC_CHECK_LIB(crypto, SHA1, MTA_SHA_LIB="-lcrypto", )
    fi
    LIBS="$SM_OLD_LIBS"
  fi
  AC_SUBST(MTA_SHA_LIB)
])

dnl ##########################################################################
dnl ###  SM_NEED_PROTO(includes, function)
dnl ##########################################################################

AC_DEFUN(SM_NEED_PROTO, [
if test "$ac_cv_func_$2" = yes; then
AC_CACHE_CHECK([if $2 needs a prototype], ac_cv_func_$2_noproto,
AC_TRY_COMPILE([$1],
[struct foo { int foo; } xx;
extern int $2 (struct foo*);
$2(&xx);
],
eval "ac_cv_func_$2_noproto=yes",
eval "ac_cv_func_$2_noproto=no"))
define([foo], [NEED_]translit($2, [a-z], [A-Z])[_PROTO])
if test "$ac_cv_func_$2_noproto" = yes; then
	AC_DEFINE(foo, 1, [define if the system is missing a prototype for $2()])
fi
undefine([foo])
fi
])


dnl ##########################################################################
dnl ###  SM_TINYCDB
dnl ##########################################################################

AC_DEFUN([SM_TINYCDB], [
 AC_ARG_ENABLE(TINYCDB, [  --enable-tinycdb           enable tinycdb (check libraries) ],
  smtinycdb=$enableval,
  smtinycdb=yes)
  AC_CHECK_HEADERS(cdb.h)
  if test "$ac_cv_header_cdb_h" = "yes"; then
    AC_MSG_CHECKING(tinycdb support)
    MTA_TINYCDB_LIB=""
    if test "$smtinycdb" != no; then
      AC_CHECK_LIB(cdb, cdb_init,
	MTA_TINYCDB_LIB="-lcdb $MTA_TINYCDB_LIB"; sm_cv_tinycdb="yes", sm_cv_tinycdb="no")
      if test "$sm_cv_tinycdb" != no; then
        AC_DEFINE(MTA_USE_TINYCDB, 1, [Define if TINYCDB is available and should be used])
        AC_MSG_RESULT(enabled)
      else
        AC_MSG_RESULT(disabled due to missing libraries)
      fi
    else
      AC_MSG_RESULT(disabled)
    fi
  else
    AC_MSG_RESULT(missing cdb.h)
  fi
  AC_SUBST(MTA_TINYCDB_LIB)
])