configure.in revision 5543a380177054ea6217272d626332f44edb7c8f
AC_PREREQ([2.59])
AC_INIT([dovecot],[1.1.rc3],[dovecot@dovecot.org])
AC_CONFIG_SRCDIR([src])
AM_INIT_AUTOMAKE
AM_MAINTAINER_MODE
AC_ISC_POSIX
AC_PROG_CC
AC_PROG_CPP
AC_PROG_CXX # lucene plugin needs this
AC_HEADER_STDC
AC_C_INLINE
AC_PROG_LIBTOOL
AM_ICONV
AC_ARG_ENABLE(ipv6,
[ --enable-ipv6 Enable IPv6 support (auto)],
if test x$enableval = xno || test x$enableval = xauto; then
want_ipv6=$enableval
else
want_ipv6=yes
fi,
want_ipv6=auto)
AC_ARG_ENABLE(debug,
[ --enable-debug Enable some extra expensive checks for developers],
if test x$enableval = xyes; then
AC_DEFINE(DEBUG,, Build with extra debugging checks)
fi)
AC_ARG_ENABLE(asserts,
[ --enable-asserts Enable asserts (default)],
if test x$enableval = xno; then
AC_DEFINE(DISABLE_ASSERTS,, Disable asserts)
fi)
AC_ARG_WITH(mem-align,
[ --with-mem-align=BYTES Set the memory alignment (default: 8)],
mem_align=$withval,
mem_align=8)
AC_ARG_WITH(ioloop,
[ --with-ioloop=IOLOOP Specify the I/O loop method to use
(epoll, kqueue, poll; best for the fastest available;
default is best)],
ioloop=$withval,
ioloop=best)
AC_ARG_WITH(notify,
[ --with-notify=NOTIFY Specify the file system notification method to use
(inotify, kqueue, dnotify, none;
default is detected in the above order)],
notify=$withval,
notify=)
AC_ARG_WITH(linux-quota,
[ --with-linux-quota=n Linux quota version to use (default: system's)],
AC_DEFINE_UNQUOTED(_LINUX_QUOTA_VERSION, $withval,
[Linux quota version to use])
)
AC_ARG_WITH(passwd,
[ --with-passwd Build with /etc/passwd support (default)],
if test x$withval = xno || test x$withval = xauto; then
want_passwd=$withval
else
want_passwd=yes
fi,
want_passwd=yes)
AC_ARG_WITH(nss,
[ --with-nss Build with NSS module support (auto)],
if test x$withval = xno || test x$withval = xauto; then
want_nss=$withval
else
want_nss=yes
fi,
want_nss=auto)
AC_ARG_WITH(passwd-file,
[ --with-passwd-file Build with passwd-like file support (default)],
if test x$withval = xno || test x$withval = xauto; then
want_passwd_file=$withval
else
want_passwd_file=yes
fi,
want_passwd_file=yes)
AC_ARG_WITH(shadow,
[ --with-shadow Build with shadow password support (auto)],
if test x$withval = xno || test x$withval = xauto; then
want_shadow=$withval
else
want_shadow=yes
fi,
want_shadow=auto)
AC_ARG_WITH(pam,
[ --with-pam Build with PAM support (auto)],
if test x$withval = xno || test x$withval = xauto; then
want_pam=$withval
else
want_pam=yes
fi,
want_pam=auto)
AC_ARG_WITH(checkpassword,
[ --with-checkpassword Build with checkpassword support (default)],
if test x$withval = xno || test x$withval = xauto; then
want_checkpassword=$withval
else
want_checkpassword=yes
fi,
want_checkpassword=yes)
AC_ARG_WITH(bsdauth,
[ --with-bsdauth Build with BSD authentication support (auto)],
if test x$withval = xno || test x$withval = xauto; then
want_bsdauth=$withval
else
want_bsdauth=yes
fi,
want_bsdauth=auto)
AC_ARG_WITH(gssapi,
[ --with-gssapi=yes|plugin Build with GSSAPI authentication support],
if test x$withval = xno || test x$withval = xauto; then
want_gssapi=$withval
want_gssapi_plugin=no
elif test x$withval = xplugin; then
want_gssapi=yes
want_gssapi_plugin=yes
else
want_gssapi=yes
want_gssapi_plugin=no
fi,
want_gssapi=no)
AC_ARG_WITH(sia,
[ --with-sia Build with Tru64 SIA support],
if test x$withval = xno || test x$withval = xauto; then
want_sia=$withval
else
want_sia=yes
fi,
want_sia=no)
AC_ARG_WITH(ldap,
[ --with-ldap=yes|plugin Build with LDAP support],
if test x$withval = xno || test x$withval = xauto; then
want_ldap=$withval
want_ldap_plugin=no
elif test x$withval = xplugin; then
want_ldap=yes
want_ldap_plugin=yes
else
want_ldap=yes
want_ldap_plugin=no
fi,
want_ldap=no)
AC_ARG_WITH(vpopmail,
[ --with-vpopmail Build with vpopmail support (auto)],
if test x$withval = xno; then
want_vpopmail=no
else
if test x$withval = xyes || test x$withval = xauto; then
vpopmail_home="`echo ~vpopmail`"
want_vpopmail=$withval
else
vpopmail_home="$withval"
want_vpopmail=yes
fi
fi, [
want_vpopmail=auto
vpopmail_home="`echo ~vpopmail`"
])
AC_ARG_WITH(static-userdb,
[ --with-static-userdb Build with static userdb support (default)],
if test x$withval = xno; then
want_static_userdb=no
else
want_static_userdb=yes
fi,
want_static_userdb=yes)
AC_ARG_WITH(prefetch-userdb,
[ --with-prefetch-userdb Build with prefetch userdb support (default)],
if test x$withval = xno; then
want_prefetch_userdb=no
else
want_prefetch_userdb=yes
fi,
want_prefetch_userdb=yes)
AC_ARG_WITH(db,
[ --with-db Build with Berkeley DB support],
if test x$withval = xno || test x$withval = xauto; then
want_db=$withval
else
want_db=yes
fi,
want_db=no)
dnl The --with-sql is useful only if Dovecot is being built with all the SQL
dnl drivers as modules. If any SQL driver is built-in, this option is ignored.
AC_ARG_WITH(sql,
[ --with-sql=yes|plugin Build with generic SQL support],
if test x$withval = xno; then
want_sql=no
elif test x$withval = xplugin; then
want_sql=yes
want_sql_plugins=yes
else
want_sql=yes
want_sql_plugins=no
fi,
want_sql=no)
AC_ARG_WITH(pgsql,
[ --with-pgsql Build with PostgreSQL driver support],
if test x$withval = xno || test x$withval = xauto; then
want_pgsql=$withval
else
want_pgsql=yes
fi,
want_pgsql=no)
AC_ARG_WITH(mysql,
[ --with-mysql Build with MySQL driver support],
if test x$withval = xno || test x$withval = xauto; then
want_mysql=$withval
else
want_mysql=yes
fi,
want_mysql=no)
AC_ARG_WITH(sqlite,
[ --with-sqlite Build with SQLite3 driver support],
if test x$withval = xno || test x$withval = xauto; then
want_sqlite=$withval
else
want_sqlite=yes
fi,
want_sqlite=no)
AC_ARG_WITH(lucene,
[ --with-lucene Build with CLucene full text search support],
if test x$withval = xno || test x$withval = xauto; then
want_lucene=$withval
else
want_lucene=yes
fi,
want_lucene=no)
AM_CONDITIONAL(BUILD_LUCENE, test "$want_lucene" = "yes")
AC_ARG_WITH(ssl,
[ --with-ssl=gnutls|openssl Build with GNUTLS or OpenSSL (default)],
if test x$withval = xno; then
want_gnutls=no
want_openssl=no
elif test x$withval = xgnutls; then
want_gnutls=yes
want_openssl=no
elif test x$withval = xopenssl; then
want_gnutls=no
want_openssl=yes
else
want_gnutls=no
want_openssl=yes
fi, [
want_gnutls=no
want_openssl=auto
])
AC_ARG_WITH(ssldir,
[ --with-ssldir=DIR SSL base directory for certificates (/etc/ssl)],
ssldir="$withval",
ssldir=/etc/ssl
)
AC_SUBST(ssldir)
AC_ARG_WITH(rundir,
[ --with-rundir=DIR Runtime data directory (LOCALSTATEDIR/run/dovecot)],
rundir="$withval",
rundir=$localstatedir/run/$PACKAGE_NAME
)
AC_SUBST(rundir)
AC_ARG_WITH(statedir,
[ --with-statedir=DIR Permanent data directory (LOCALSTATEDIR/lib/dovecot)],
statedir="$withval",
statedir=$localstatedir/lib/$PACKAGE_NAME
)
AC_SUBST(statedir)
AC_ARG_WITH(gc,
[ --with-gc Use Boehm garbage collector],
if test x$withval = xno || test x$withval = xauto; then
want_gc=$withval
else
want_gc=yes
fi,
want_gc=no)
AC_ARG_WITH(pop3d,
[ --with-pop3d Build POP3 server (default)],
if test x$withval = xno; then
want_pop3d=no
else
want_pop3d=yes
fi,
want_pop3d=yes)
AM_CONDITIONAL(BUILD_POP3D, test "$want_pop3d" = "yes")
AC_ARG_WITH(deliver,
[ --with-deliver Build mail delivery agent (default)],
if test x$withval = xno; then
want_deliver=no
else
want_deliver=yes
fi,
want_deliver=yes)
AM_CONDITIONAL(BUILD_DELIVER, test "$want_deliver" = "yes")
AC_ARG_WITH(storages,
[ --with-storages Build with specified mail storage formats
(maildir mbox dbox cydir raw)], [
if test "$withval" = "yes" -o "$withval" = "no"; then
AC_MSG_ERROR([--with-storages needs storage list as parameter])
fi
mail_storages=`echo "$withval"|sed 's/,/ /g'` ],
mail_storages="maildir mbox dbox cydir raw")
AC_SUBST(mail_storages)
AC_ARG_WITH(sql-drivers,
[ --with-sql-drivers Build with specified SQL drivers (all)], [
sql_drivers=`echo "$withval"|sed 's/,/ /g'` ],
sql_drivers="all")
if test "$sql_drivers" = "all" -o "$sql_drivers" = "yes"; then
all_sql_drivers=yes
sql_drivers=
elif test "$sql_drivers" = "no"; then
# --without-sql-drivers given
sql_drivers=
fi
AC_ARG_WITH(moduledir,
[ --with-moduledir=DIR Base directory for dynamically loadable modules],
moduledir="$withval",
moduledir=$libdir/dovecot
)
AC_SUBST(moduledir)
AC_ARG_WITH(docs,
[ --with-docs Install documentation (default)],
if test x$withval = xno; then
want_docs=no
else
want_docs=yes
fi,
want_docs=yes)
AM_CONDITIONAL(BUILD_DOCS, test "$want_docs" = "yes")
AC_ARG_ENABLE(header-install,
[ --enable-header-install Install development headers],
if test x$enableval = xno; then
want_headers=no
else
want_headers=yes
fi,
want_headers=no)
AM_CONDITIONAL(INSTALL_HEADERS, test "$want_headers" = "yes")
dnl * gcc specific options
if test "x$ac_cv_c_compiler_gnu" = "xyes"; then
# -Wcast-qual -Wcast-align -Wconversion -Wunreachable-code # too many warnings
# -Wstrict-prototypes -Wredundant-decls # may give warnings in some systems
# -Wmissing-format-attribute -Wmissing-noreturn -Wwrite-strings # a couple of warnings
CFLAGS="$CFLAGS -Wall -W -Wmissing-prototypes -Wmissing-declarations -Wpointer-arith -Wchar-subscripts -Wformat=2 -Wbad-function-cast"
AC_TRY_COMPILE([
#if __GNUC__ < 4
# error old gcc
#endif
],,[
# gcc4
CFLAGS="$CFLAGS -Wstrict-aliasing=2"
])
# Use std=gnu99 if we have new enough gcc
old_cflags=$CFLAGS
CFLAGS="-std=gnu99"
AC_TRY_COMPILE([
],, [
CFLAGS="$CFLAGS $old_cflags"
], [
CFLAGS="$old_cflags"
])
fi
dnl **
dnl ** just some generic stuff...
dnl **
AC_SEARCH_LIBS(socket, socket)
AC_SEARCH_LIBS(inet_addr, nsl)
AC_SEARCH_LIBS(fdatasync, rt, [
AC_DEFINE(HAVE_FDATASYNC,, Define if you have fdatasync())
])
AC_CHECK_LIB(cap, cap_init, [
AC_DEFINE(HAVE_LIBCAP,, libcap is installed for cap_init())
LIBCAP="-lcap"
])
AC_SUBST(LIBCAP)
dnl * after -lsocket and -lnsl tests, inet_aton() may be in them
AC_CHECK_FUNCS(fcntl flock lockf inet_aton sigaction getpagesize madvise \
strcasecmp stricmp vsyslog writev pread \
setrlimit setproctitle seteuid setreuid setegid setresgid \
strtoull strtouq setpriority quotactl getmntent kqueue kevent \
backtrace_symbols walkcontext dirfd \
malloc_usable_size)
dnl * I/O loop function
have_ioloop=no
if test "$ioloop" = "best" || test "$ioloop" = "epoll"; then
AC_CACHE_CHECK([whether we can use epoll],epoll_works,[
AC_TRY_RUN([
#include <sys/epoll.h>
int main()
{
return epoll_create(5) < 1;
}
], [
epoll_works=yes
], [
epoll_works=no
])
])
if test $epoll_works = yes; then
AC_DEFINE(IOLOOP_EPOLL,, Implement I/O loop with Linux 2.6 epoll())
have_ioloop=yes
ioloop=epoll
else
if test "$ioloop" = "epoll" ; then
AC_MSG_ERROR([epoll ioloop requested but epoll_create() is not available])
fi
fi
fi
if test "$ioloop" = "best" || test "$ioloop" = "kqueue"; then
if test "$ac_cv_func_kqueue" = yes && test "$ac_cv_func_kevent" = yes; then
AC_DEFINE(IOLOOP_KQUEUE,, [Implement I/O loop with BSD kqueue()])
ioloop=kqueue
have_ioloop=yes
elif test "$ioloop" = "kqueue"; then
AC_MSG_ERROR([kqueue ioloop requested but kqueue() is not available])
fi
fi
if test "$ioloop" = "best" || test "$ioloop" = "poll"; then
AC_CHECK_FUNC(poll, [
AC_DEFINE(IOLOOP_POLL,, Implement I/O loop with poll())
ioloop=poll
have_ioloop=yes
])
fi
if test "$have_ioloop" = "no"; then
AC_DEFINE(IOLOOP_SELECT,, Implement I/O loop with select())
ioloop="select"
fi
have_notify=none
if test "$notify" = "" || test "$notify" = "inotify" ; then
dnl * inotify?
AC_CACHE_CHECK([whether we can use inotify],inotify_works,[
AC_TRY_RUN([
#define _GNU_SOURCE
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/inotify.h>
#include <stdio.h>
int main()
{
int wd, fd;
char * fn = "/tmp";
fd = inotify_init ();
if (fd < 0)
{
perror ("inotify_init");
return 1;
}
wd = inotify_add_watch (fd, fn, IN_ALL_EVENTS);
if (wd < 0)
{
perror ("inotify_add_watch");
return 2;
}
inotify_rm_watch (fd, wd);
close (fd);
return 0;
}
], [
inotify_works=yes
], [
inotify_works=no
])
])
if test $inotify_works = yes; then
have_notify=inotify
notify=inotify
AC_DEFINE(IOLOOP_NOTIFY_INOTIFY,, Use Linux inotify)
else
if test "$notify" = "inotify"; then
AC_MSG_ERROR([inotify requested but not available])
notify=""
fi
fi
fi
if (test "$notify" = "" && test "$ioloop" = kqueue) || test "$notify" = "kqueue"; then
AC_MSG_CHECKING([if we can use BSD kqueue() notify])
dnl * BSD kqueue() notify
if test "$ac_cv_func_kqueue" = yes && test "$ac_cv_func_kevent" = yes ; then
have_notify=kqueue
notify=kqueue
AC_MSG_RESULT("yes")
AC_DEFINE(IOLOOP_NOTIFY_KQUEUE,,
Use BSD kqueue directory changes notificaton)
else
AC_MSG_RESULT("no")
if test "$notfify" = "kqueue" ; then
AC_MSG_ERROR([kqueue notify requested but kqueue() is not available])
notify=""
fi
fi
fi
if test "$notify" = "" || test "$notify" = "dnotify"; then
AC_MSG_CHECKING([whether we can use dnotify])
dnl * dnotify?
AC_TRY_COMPILE([
#define _GNU_SOURCE
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
], [
fcntl(0, F_SETSIG, SIGRTMIN);
fcntl(0, F_NOTIFY, DN_CREATE | DN_DELETE | DN_RENAME | DN_MULTISHOT);
], [
AC_MSG_RESULT(yes)
AC_DEFINE(IOLOOP_NOTIFY_DNOTIFY,, Use Linux dnotify)
have_notify=dnotify
notify=dnotify
], [
AC_MSG_RESULT(no)
if test "$notify" = "dnotify"; then
AC_MSG_ERROR([dnotify requested but not available])
fi
])
fi
if test "$have_notify" = "none"; then
AC_DEFINE(IOLOOP_NOTIFY_NONE,, No special notify support)
fi
dnl * GLIBC?
AC_TRY_COMPILE([
#include <stdlib.h>
#ifdef __GLIBC__
we have glibc
#endif
],,, [
AC_DEFINE(PREAD_WRAPPERS,, Define if pread/pwrite needs _XOPEN_SOURCE 500)
])
dnl * Old glibcs have broken posix_fallocate(). Make sure not to use it.
AC_TRY_LINK([
#define _XOPEN_SOURCE 600
#include <stdlib.h>
#if defined(__GLIBC__) && (__GLIBC__ < 2 || __GLIBC_MINOR__ < 7)
possibly broken posix_fallocate
#endif
], [
posix_fallocate(0, 0, 0);
], [
AC_DEFINE(HAVE_POSIX_FALLOCATE,, Define if you have a working posix_fallocate())
])
dnl * OS specific options
case "$host_os" in
hpux*)
CFLAGS="$CFLAGS -D_XOPEN_SOURCE_EXTENDED"
;;
*)
;;
esac
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(void *)
AC_CHECK_SIZEOF(long long)
AC_DEFUN([AC_TYPEOF], [
dnl * first check if we can get the size with redefining typedefs
order="$2"
if test "$2" = ""; then
order="int long long-long"
fi
result=""
visible="unknown"
AC_MSG_CHECKING([type of $1])
if test "x$ac_cv_c_compiler_gnu" = "xyes"; then
dnl * try with printf() + -Werror
old_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -Werror"
for type in $order; do
case "$type" in
int)
fmt="%d"
;;
unsigned-int)
fmt="%u"
;;
long)
fmt="%ld"
;;
unsigned-long)
fmt="%lu"
;;
long-long)
fmt="%lld"
;;
unsigned-long-long)
fmt="%llu"
;;
*)
fmt=""
;;
esac
if test "$fmt" != ""; then
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
#include <stdio.h>
]], [[
printf("$fmt", ($1)0);
]])],[
if test "$result" != ""; then
dnl * warning check isn't working
result=""
visible="unknown"
break
fi
result="`echo $type|sed 's/-/ /g'`"
visible="$result"
],[])
fi
done
CFLAGS="$old_CFLAGS"
fi
if test "$result" = ""; then
for type in $order; do
type="`echo $type|sed 's/-/ /g'`"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
typedef $type $1;
]], [[]])],[
if test "$result" != ""; then
dnl * compiler allows redefining to anything
result=""
visible="unknown"
break
fi
result="$type"
visible="$type"
],[])
done
fi
if test "$result" = ""; then
dnl * check with sizes
dnl * older autoconfs don't include sys/types.h, so do it manually
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <stdio.h>
#include <sys/types.h>
int main() {
FILE *f=fopen("conftestval", "w");
if (!f) exit(1);
fprintf(f, "%d\n", sizeof($1));
exit(0);
}
]])],[
size=`cat conftestval`
rm -f conftestval
for type in $order; do
actype="ac_cv_sizeof_`echo $type|sed 's/-/_/g'`"
if test "$size" = "`eval echo \\$$actype`"; then
result="`echo $type|sed 's/-/ /g'`"
visible="`expr $size \* 8`bit (using $result)"
break
fi
done
if test "$result" = ""; then
result=unknown
visible="`expr $size \* 8`bit (unknown type)"
fi
],[],[])
fi
typeof_$1=$result
AC_MSG_RESULT($visible)
])
AC_SYS_LARGEFILE
AC_CHECK_TYPES(_Bool)
AC_CHECK_TYPE(uoff_t, [
have_uoff_t=yes
AC_DEFINE(HAVE_UOFF_T,, Define if you have a native uoff_t type)
], [
have_uoff_t=no
])
AC_TYPEOF(off_t, long int long-long)
case "$typeof_off_t" in
int)
offt_max=INT_MAX
uofft_fmt="u"
if test "$have_uoff_t" != "yes"; then
AC_DEFINE(UOFF_T_INT,, Define if off_t is int)
fi
offt_bits=`expr 8 \* $ac_cv_sizeof_int`
;;
long)
offt_max=LONG_MAX
uofft_fmt="lu"
if test "$have_uoff_t" != "yes"; then
AC_DEFINE(UOFF_T_LONG,, Define if off_t is long)
fi
offt_bits=`expr 8 \* $ac_cv_sizeof_long`
;;
"long long")
offt_max=LLONG_MAX
uofft_fmt="llu"
if test "$have_uoff_t" != "yes"; then
AC_DEFINE(UOFF_T_LONG_LONG,, Define if off_t is long long)
fi
offt_bits=`expr 8 \* $ac_cv_sizeof_long_long`
;;
*)
AC_MSG_ERROR([Unsupported off_t type])
;;
esac
dnl * Do we have struct dirent->d_type
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <dirent.h>
]], [[
struct dirent d;
d.d_type = DT_DIR;
]])],[
AC_DEFINE(HAVE_DIRENT_D_TYPE,, Define if you have struct dirent->d_type)
],[])
dnl * Do we have OFF_T_MAX?
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <limits.h>
#include <sys/types.h>
]], [[
off_t i = OFF_T_MAX;
]])],[
:
],[
AC_DEFINE_UNQUOTED(OFF_T_MAX, $offt_max, Maximum value of off_t)
])
AC_DEFINE_UNQUOTED(PRIuUOFF_T, "$uofft_fmt", printf() format for uoff_t)
dnl * make sure size_t isn't signed. we'd probably work fine with it, but
dnl * it's more likely vulnerable to buffer overflows. Anyway, C99 specifies
dnl * that it's unsigned and only some old systems define it as signed.
AC_CACHE_CHECK([whether size_t is signed],signed_size_t,[
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <sys/types.h>
int main() {
/* return 0 if we're signed */
exit((size_t)(int)-1 <= 0 ? 0 : 1);
}
]])],[
signed_size_t=yes
echo
echo "Your system's size_t is a signed integer, Dovecot isn't designed to"
echo "support it. It probably works just fine, but it's less resistant to"
echo "buffer overflows. If you're not worried about this and still want to"
echo "compile Dovecot, set ignore_signed_size=1 environment."
if test "$ignore_signed_size" = ""; then
AC_MSG_ERROR([aborting])
fi
echo "..ignoring as requested.."
],[
signed_size_t=no
],[])
])
dnl Note: we check size_t rather than ssize_t here, because on OSX 10.2
dnl ssize_t = int and size_t = unsigned long. We're mostly concerned about
dnl printf format here, so check the size_t one.
AC_TYPEOF(size_t, unsigned-int unsigned-long unsigned-long-long)
case "$typeof_size_t" in
"unsigned long")
ssizet_max=LONG_MAX
sizet_fmt="lu"
;;
"unsigned long long")
ssizet_max=LLONG_MAX
sizet_fmt="llu"
;;
*)
dnl older systems didn't have ssize_t, default to int
ssizet_max=INT_MAX
sizet_fmt="u"
if test "$typeof_size_t" = ""; then
AC_DEFINE(size_t, unsigned int, Define to 'unsigned int' if you don't have it)
AC_DEFINE(ssize_t, int, Define to 'int' if you don't have it)
fi
;;
esac
AC_DEFINE_UNQUOTED(SSIZE_T_MAX, $ssizet_max, Maximum value of ssize_t)
AC_DEFINE_UNQUOTED(PRIuSIZE_T, "$sizet_fmt", printf() format for size_t)
AC_DEFUN([AC_CHECKTYPE2], [
AC_MSG_CHECKING([for $1])
AC_CACHE_VAL(i_cv_type_$1,
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
$2]], [[$1 t;]])],[i_cv_type_$1=yes],[i_cv_type_$1=no])])
AC_MSG_RESULT($i_cv_type_$1)
])
dnl some systems don't have stdint.h, but still have some of the types
dnl defined elsewhere
AC_CHECK_HEADER(stdint.h, [
stdint_include="#include <stdint.h>"
])
AC_CHECKTYPE2(uintmax_t, [$stdint_include])
if test $i_cv_type_uintmax_t = yes; then
AC_DEFINE(HAVE_UINTMAX_T,, Define if you have uintmax_t (C99 type))
fi
dnl use separate check, eg. Solaris 8 has uintmax_t but not uint_fast32_t
AC_CHECKTYPE2(uint_fast32_t, [$stdint_include])
if test $i_cv_type_uint_fast32_t = yes; then
AC_DEFINE(HAVE_UINT_FAST32_T,, Define if you have uint_fast32_t (C99 type))
fi
AC_CHECKTYPE2(socklen_t, [#include <sys/socket.h>])
if test $i_cv_type_socklen_t = yes; then
AC_DEFINE(HAVE_SOCKLEN_T,, Define to 'int' if you don't have socklen_t)
fi
AC_DEFINE_UNQUOTED(MEM_ALIGN_SIZE, $mem_align, Required memory alignment)
dnl * find random source
AC_MSG_CHECKING([for /dev/urandom])
if test -c /dev/urandom || test -s /dev/urandom; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_DEV_URANDOM,, Define if you have /dev/urandom)
have_random_source=yes
else
AC_MSG_RESULT(no)
AC_CHECK_HEADER(openssl/rand.h, [
AC_DEFINE(HAVE_OPENSSL_RAND_H,, Define if you have openssl/rand.h)
RAND_LIBS=-lcrypto
])
fi
AC_SUBST(RAND_LIBS)
dnl * do we have tm_gmtoff
AC_MSG_CHECKING([for tm_gmtoff])
AC_CACHE_VAL(i_cv_field_tm_gmtoff,
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <time.h>]],
[[struct tm *tm; return tm->tm_gmtoff;]])],
[i_cv_field_tm_gmtoff=yes],
[i_cv_field_tm_gmtoff=no])])
if test $i_cv_field_tm_gmtoff = yes; then
AC_DEFINE(HAVE_TM_GMTOFF,, Define if you have struct tm->tm_gmtoff)
fi
AC_MSG_RESULT($i_cv_field_tm_gmtoff)
dnl * how large time_t values does gmtime() accept?
AC_CACHE_CHECK([how large time_t values gmtime() accepts],gmtime_max_time_t,[
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <stdio.h>
#include <time.h>
int main() {
FILE *f;
int bits;
for (bits = 1; bits < sizeof(time_t)*8; bits++) {
time_t t = ((time_t)1 << bits) - 1;
if (gmtime(&t) == NULL) {
bits--;
break;
}
}
if (bits > 40) {
/* Solaris 9 breaks after 55 bits. Perhaps other systems break earlier.
Let's just do the same as Cyrus folks and limit it to 40 bits. */
bits = 40;
}
f = fopen("conftest.temp", "w");
if (f == NULL) {
perror("fopen()");
return 1;
}
fprintf(f, "%d", bits);
fclose(f);
return 0;
}
]])],[
gmtime_max_time_t=`cat conftest.temp`
rm -f conftest.temp
], [
printf "check failed, assuming "
gmtime_max_time_t=31
],[])
])
AC_DEFINE_UNQUOTED(TIME_T_MAX_BITS, $gmtime_max_time_t, max. time_t bits gmtime() can handle)
AC_CACHE_CHECK([whether time_t is signed],signed_time_t,[
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <sys/types.h>
int main() {
/* return 0 if we're signed */
exit((time_t)(int)-1 <= 0 ? 0 : 1);
}
]])],[
signed_time_t=yes
], [
signed_time_t=no
])
])
if test $signed_time_t = yes; then
AC_DEFINE(TIME_T_SIGNED,, Define if your time_t is signed)
fi
dnl * do we have struct iovec
AC_MSG_CHECKING([for struct iovec])
AC_CACHE_VAL(i_cv_struct_iovec,
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>]],
[[struct iovec *iovec;]])],
[i_cv_struct_iovec=yes],
[i_cv_struct_iovec=no])])
if test $i_cv_struct_iovec = yes; then
AC_DEFINE(HAVE_STRUCT_IOVEC,, Define if you have struct iovec)
fi
AC_MSG_RESULT($i_cv_struct_iovec)
dnl * is dev_t an integer or something else?
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
struct test { dev_t a; };
static struct test t = { 0 };
]], [[]])],[],[
AC_DEFINE(DEV_T_STRUCT,, Define if your dev_t is a structure instead of integer type)
dnl we can't initialize structures, so don't warn about them either
if test "x$ac_cv_c_compiler_gnu" = "xyes"; then
CFLAGS=`echo $CFLAGS|sed 's/ -W\b//'`
fi
])
dnl * Do we have RLIMIT_AS?
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
]], [[
struct rlimit r;
getrlimit(RLIMIT_AS, &r);
]])],[
AC_DEFINE(HAVE_RLIMIT_AS,, Define if you have RLIMIT_AS for setrlimit())
],[])
dnl * Do we have RLIMIT_NPROC?
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
]], [[
struct rlimit r;
getrlimit(RLIMIT_NPROC, &r);
]])],[
AC_DEFINE(HAVE_RLIMIT_NPROC,, Define if you have RLIMIT_NPROC for setrlimit())
],[])
dnl * Linux compatible mremap()
AC_MSG_CHECKING([Linux compatible mremap()])
AC_TRY_LINK([
#include <unistd.h>
#define __USE_GNU
#include <sys/mman.h>
], [
mremap(0, 0, 0, MREMAP_MAYMOVE);
], [
AC_DEFINE(HAVE_LINUX_MREMAP,, Define if you have Linux-compatible mremap())
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
dnl * If mmap() plays nicely with write()
AC_CACHE_CHECK([whether shared mmaps get updated by write()s],mmap_plays_with_write,[
AC_TRY_RUN([
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
int main() {
/* return 0 if we're signed */
int f = open("conftest.mmap", O_RDWR|O_CREAT|O_TRUNC);
void *mem;
if (f == -1) {
perror("open()");
return 1;
}
unlink("conftest.mmap");
write(f, "1", 2);
mem = mmap(NULL, 2, PROT_READ|PROT_WRITE, MAP_SHARED, f, 0);
if (mem == MAP_FAILED) {
perror("mmap()");
return 1;
}
strcpy(mem, "2");
msync(mem, 2, MS_SYNC);
lseek(f, 0, SEEK_SET);
write(f, "3", 2);
return strcmp(mem, "3") == 0 ? 0 : 1;
}
], [
mmap_plays_with_write=yes
], [
mmap_plays_with_write=no
])
])
if test $mmap_plays_with_write = no; then
AC_DEFINE(MMAP_CONFLICTS_WRITE,, [Define if shared mmaps don't get updated by write()s])
fi
dnl * see if fd passing works
AC_CACHE_CHECK([whether fd passing works],fd_passing,[
for i in 1 2; do
old_cflags="$CFLAGS"
CFLAGS="$CFLAGS -I$srcdir/src/lib $srcdir/src/lib/fdpass.c"
if test $i = 2; then
CFLAGS="$CFLAGS -DBUGGY_CMSG_MACROS"
fi
AC_TRY_RUN([
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include "fdpass.h"
int main(void)
{
int fd[2], send_fd, recv_fd, status;
struct stat st, st2;
char data;
send_fd = open("conftest.fdpass", O_CREAT|O_WRONLY);
if (send_fd == -1) return 2;
unlink("conftest.fdpass");
if (fstat(send_fd, &st) < 0) return 2;
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0) return 2;
switch (fork()) {
case -1:
return 2;
case 0:
alarm(1);
if (fd_send(fd[0], send_fd, &data, 1) != 1) return 2;
return 0;
default:
alarm(2);
if (wait(&status) == -1)
return 2;
if (status != 0)
return status;
if (fd_read(fd[1], &data, 1, &recv_fd) != 1) return 1;
if (fstat(recv_fd, &st2) < 0) return 2;
return st.st_ino == st2.st_ino ? 0 : 1;
}
}
], [
CFLAGS=$old_cflags
if test $i = 2; then
fd_passing=buggy_cmsg_macros
else
fd_passing=yes
fi
break
], [
dnl no, try with BUGGY_CMSG_MACROS
CFLAGS=$old_cflags
fd_passing=no
])
done
]);
if test $fd_passing = buggy_cmsg_macros; then
AC_DEFINE(BUGGY_CMSG_MACROS,, Define if you have buggy CMSG macros)
fi
dnl * Solaris compatible sendfile()
AC_CHECK_LIB(sendfile, sendfile, [
LIBS="$LIBS -lsendfile"
AC_DEFINE(HAVE_SOLARIS_SENDFILE,, Define if you have Solaris-compatible sendfile())
], [
dnl * Linux compatible sendfile() - don't check if Solaris one was found.
dnl * This seems to pass with Solaris for some reason..
AC_MSG_CHECKING([Linux compatible sendfile()])
AC_TRY_LINK([
#undef _FILE_OFFSET_BITS
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sendfile.h>
], [
sendfile(0, 0, (void *) 0, 0);
], [
AC_DEFINE(HAVE_LINUX_SENDFILE,, Define if you have Linux-compatible sendfile())
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
dnl * FreeBSD compatible sendfile()
AC_MSG_CHECKING([FreeBSD compatible sendfile()])
AC_TRY_LINK([
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
], [
struct sf_hdtr hdtr;
sendfile(0, 0, 0, 0, &hdtr, (void *) 0, 0);
], [
AC_DEFINE(HAVE_FREEBSD_SENDFILE,, Define if you have FreeBSD-compatible sendfile())
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
])
dnl * Check for crypt() if unistd.h compiles with _XOPEN_SOURCE + _XPG6
dnl * Add other macros there too "just in case".
AC_MSG_CHECKING([if we should use _XPG6 macro for crypt()])
AC_TRY_COMPILE([
#define _XOPEN_SOURCE 4
#define _XOPEN_SOURCE_EXTENDED 1
#define _XOPEN_VERSION 4
#define _XPG4_2
#define _XPG6
#include <unistd.h>
], [
crypt("a", "b");
], [
AC_DEFINE(CRYPT_USE_XPG6,, Define if _XPG6 macro is needed for crypt())
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
AC_MSG_CHECKING([if struct stat has tv_nsec fields])
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
], [
struct stat st;
unsigned long x = st.st_mtim.tv_nsec;
return 0;
], [
AC_DEFINE(HAVE_STAT_TV_NSEC,, Define if you have tv_nsec fields in struct stat)
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
dnl * Check if statvfs() can be used to find out block device for files
AC_MSG_CHECKING([if statvfs.f_mntfromname exists])
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/statvfs.h>
], [
struct statvfs buf;
char *p = buf.f_mntfromname;
statvfs(".", &buf);
], [
AC_DEFINE(HAVE_STATVFS_MNTFROMNAME,, Define if you have statvfs.f_mntfromname)
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
dnl * Check if statvfs() can be used to find out block device for files
AC_MSG_CHECKING([if statvfs.f_mntfromname exists])
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/statvfs.h>
], [
struct statvfs buf;
char *p = buf.f_mntfromname;
statvfs(".", &buf);
], [
AC_DEFINE(HAVE_STATVFS_MNTFROMNAME,, Define if you have statvfs.f_mntfromname)
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
dnl * Check if statfs() can be used to find out block device for files
AC_MSG_CHECKING([if statfs.f_mntfromname exists])
AC_TRY_COMPILE([
#include <sys/param.h>
#include <sys/mount.h>
], [
struct statfs buf;
char *p = buf.f_mntfromname;
statfs(".", &buf);
], [
AC_DEFINE(HAVE_STATFS_MNTFROMNAME,, Define if you have statfs.f_mntfromname)
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
dnl * Check if we have struct dqblk.dqb_curblocks
AC_MSG_CHECKING([if struct dqblk.dqb_curblocks exists])
AC_TRY_COMPILE([
#include <sys/types.h>
#include "$srcdir/src/plugins/quota/quota-fs.h"
], [
struct dqblk dqblk;
unsigned int x = dqblk.dqb_curblocks;
], [
AC_DEFINE(HAVE_STRUCT_DQBLK_CURBLOCKS,, Define if struct sqblk.dqb_curblocks exists)
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
dnl * Check if we have struct dqblk.dqb_curspace
AC_MSG_CHECKING([if struct dqblk.dqb_curspace exists])
AC_TRY_COMPILE([
#include <sys/types.h>
#include "$srcdir/src/plugins/quota/quota-fs.h"
], [
struct dqblk dqblk;
unsigned int x = dqblk.dqb_curspace;
], [
AC_DEFINE(HAVE_STRUCT_DQBLK_CURSPACE,, Define if struct sqblk.dqb_curspace exists)
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
dnl * Check if we have Q_QUOTACTL ioctl (Solaris)
AC_MSG_CHECKING([if struct Q_QUOTACTL ioctl exists])
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/fs/ufs_quota.h>
], [
struct quotctl ctl;
ioctl(0, Q_QUOTACTL, &ctl);
], [
AC_DEFINE(HAVE_Q_QUOTACTL,, Define if Q_QUOTACTL exists)
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
])
dnl ***
dnl *** C99 vsnprintf()?
dnl ***
AC_CACHE_CHECK([for C99 vsnprintf()],c99_vsnprintf,[
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <stdio.h>
#include <stdarg.h>
static int f(const char *fmt, ...) {
va_list args;
char buf[13];
int ret;
va_start(args, fmt);
ret = vsnprintf(buf, 11, fmt, args) != 12 || buf[11-1] != '\0';
va_end(args);
return ret;
}
int main() {
return f("hello %s%d", "world", 1);
}]])],
[c99_vsnprintf=yes],
[c99_vsnprintf=no],
[])
])
if test $c99_vsnprintf = no; then
AC_ERROR([You don't appear to have C99 compatible vsnprintf() call])
fi
dnl ***
dnl *** va_copy checks (from GLIB)
dnl ***
AC_CACHE_CHECK([for an implementation of va_copy()],lib_cv_va_copy,[
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <stdarg.h>
void f (int i, ...) {
va_list args1, args2;
va_start (args1, i);
va_copy (args2, args1);
if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
exit (1);
va_end (args1); va_end (args2);
}
int main() {
f (0, 42);
return 0;
}]])],
[lib_cv_va_copy=yes],
[lib_cv_va_copy=no],[])
])
AC_CACHE_CHECK([for an implementation of __va_copy()],lib_cv___va_copy,[
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <stdarg.h>
void f (int i, ...) {
va_list args1, args2;
va_start (args1, i);
__va_copy (args2, args1);
if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
exit (1);
va_end (args1); va_end (args2);
}
int main() {
f (0, 42);
return 0;
}]])],
[lib_cv___va_copy=yes],
[lib_cv___va_copy=no],[])
])
if test "x$lib_cv_va_copy" = "xyes"; then
va_copy_func=va_copy
else if test "x$lib_cv___va_copy" = "xyes"; then
va_copy_func=__va_copy
fi
fi
if test -n "$va_copy_func"; then
AC_DEFINE_UNQUOTED(VA_COPY,$va_copy_func,[A 'va_copy' style function])
fi
AC_CACHE_CHECK([whether va_lists can be copied by value],lib_cv_va_val_copy,[
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <stdarg.h>
void f (int i, ...) {
va_list args1, args2;
va_start (args1, i);
args2 = args1;
if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
exit (1);
va_end (args1); va_end (args2);
}
int main() {
f (0, 42);
return 0;
}]])],
[lib_cv_va_val_copy=yes],
[lib_cv_va_val_copy=no],[])
])
if test "x$lib_cv_va_val_copy" = "xno"; then
AC_DEFINE(VA_COPY_AS_ARRAY,1, ['va_lists' cannot be copies as values])
fi
dnl **
dnl ** SSL
dnl **
have_ssl=no
if test $want_openssl != no && test $have_ssl = no; then
if pkg-config --exists openssl 2>/dev/null; then
PKG_CHECK_MODULES(SSL, openssl)
CFLAGS="$CFLAGS $SSL_CFLAGS"
have_openssl=yes
else
AC_CHECK_LIB(ssl, SSL_read, [
AC_CHECK_HEADERS(openssl/ssl.h openssl/err.h, [
SSL_LIBS="-lssl -lcrypto"
AC_SUBST(SSL_LIBS)
have_openssl=yes
], [
if test $want_openssl = yes; then
AC_ERROR([Can't build with OpenSSL: openssl/ssl.h or openssl/err.h not found])
fi
])
], [
if test $want_openssl = yes; then
AC_ERROR([Can't build with OpenSSL: libssl not found])
fi
], -lcrypto)
fi
if test "$have_openssl" = "yes"; then
AC_DEFINE(HAVE_OPENSSL,, Build with OpenSSL support)
have_ssl="yes (OpenSSL)"
fi
fi
if test $want_gnutls != no && test $have_ssl = no; then
AC_CHECK_LIB(gnutls, gnutls_global_init, [
AC_CHECK_HEADER(gnutls/gnutls.h, [
AC_DEFINE(HAVE_GNUTLS,, Build with GNUTLS support)
SSL_LIBS="-lgnutls -lgcrypt"
AC_SUBST(SSL_LIBS)
have_ssl="yes (GNUTLS)"
have_gnutls=yes
], [
if test $want_gnutls = yes; then
AC_ERROR([Can't build with GNUTLS: gnutls/gnutls.h not found])
fi
])
], [
if test $want_gnutls = yes; then
AC_ERROR([Can't build with GNUTLS: libgnutls not found])
fi
], -lgcrypt)
fi
if test "$have_ssl" != "no"; then
AC_DEFINE(HAVE_SSL,, Build with SSL/TLS support)
fi
dnl **
dnl ** Garbage Collector
dnl **
if test $want_gc != no; then
AC_CHECK_LIB(gc, GC_malloc, [
AC_DEFINE(USE_GC,, Define if you want to use Boehm GC)
LIBS="$LIBS -lgc"
], [
if test $want_gc = yes; then
AC_ERROR([Can't build with GC: libgc not found])
fi
])
fi
dnl **
dnl ** userdb and passdb checks
dnl **
userdb=""
passdb=""
if test $want_static_userdb != no; then
AC_DEFINE(USERDB_STATIC,, Build with static userdb support)
userdb="$userdb static"
fi
if test $want_prefetch_userdb != no; then
AC_DEFINE(USERDB_PREFETCH,, Build with prefetch userdb support)
userdb="$userdb prefetch"
fi
if test $want_passwd != no; then
AC_DEFINE(USERDB_PASSWD,, Build with passwd support)
AC_DEFINE(PASSDB_PASSWD,, Build with passwd support)
userdb="$userdb passwd"
passdb="$passdb passwd"
fi
if test $want_passwd_file != no; then
AC_DEFINE(USERDB_PASSWD_FILE,, Build with passwd-file support)
AC_DEFINE(PASSDB_PASSWD_FILE,, Build with passwd-file support)
userdb="$userdb passwd-file"
passdb="$passdb passwd-file"
fi
if test $want_shadow != no; then
AC_CHECK_FUNC(getspnam, [
AC_CHECK_HEADER(shadow.h, [
AC_DEFINE(PASSDB_SHADOW,, Build with shadow support)
passdb="$passdb shadow"
], [
if test $want_shadow = yes; then
AC_ERROR([Can't build with shadow support: shadow.h not found])
fi
])
], [
if test $want_shadow = yes; then
AC_ERROR([Can't build with shadow support: getspnam() not found])
fi
])
fi
if test $want_pam != no; then
AC_CHECK_LIB(pam, pam_start, [
have_pam=no
AC_CHECK_HEADER(security/pam_appl.h, [
AC_DEFINE(HAVE_SECURITY_PAM_APPL_H,,
Define if you have security/pam_appl.h)
have_pam=yes
])
AC_CHECK_HEADER(pam/pam_appl.h, [
AC_DEFINE(HAVE_PAM_PAM_APPL_H,,
Define if you have pam/pam_appl.h)
have_pam=yes
])
if test "$have_pam" = "yes"; then
AUTH_LIBS="$AUTH_LIBS -lpam"
AC_DEFINE(PASSDB_PAM,, Build with PAM support)
passdb="$passdb pam"
AC_CHECK_LIB(pam, pam_setcred, [
AC_DEFINE(HAVE_PAM_SETCRED,,
Define if you have pam_setcred())
])
elif test $want_pam = yes; then
AC_ERROR([Can't build with PAM support: pam_appl.h not found])
fi
], [
if test $want_pam = yes; then
AC_ERROR([Can't build with PAM support: libpam not found])
fi
])
fi
if test $want_checkpassword != no; then
AC_DEFINE(USERDB_CHECKPASSWORD,, Build with checkpassword userdb support)
AC_DEFINE(PASSDB_CHECKPASSWORD,, Build with checkpassword passdb support)
userdb="$userdb checkpassword"
passdb="$passdb checkpassword"
fi
if test $want_bsdauth != no; then
AC_CHECK_FUNC(auth_userokay, [
AC_DEFINE(PASSDB_BSDAUTH,, Build with BSD authentication support)
passdb="$passdb bsdauth"
], [
if test $want_bsdauth = yes; then
AC_ERROR([Can't build with BSD authentication support: auth_userokay() not found])
fi
])
fi
have_gssapi=no
if test $want_gssapi != no; then
AC_CHECK_PROG(KRB5CONFIG, krb5-config, YES, NO)
if test $KRB5CONFIG = YES; then
# we have a kludgy check here to check that we have
# version >= v1.3. Although this doesn't work right with
# non-MIT kerberos versioning..
if `krb5-config --version|grep -v '1\.2' > /dev/null`; then
KRB5_LIBS=`krb5-config --libs gssapi`
KRB5_CFLAGS=`krb5-config --cflags gssapi`
AC_SUBST(KRB5_LIBS)
AC_SUBST(KRB5_CFLAGS)
# Although krb5-config exists, all systems still don't
# have gssapi.h
old_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS `krb5-config --cflags gssapi`"
AC_CHECK_HEADER([gssapi/gssapi.h], [
AC_DEFINE(HAVE_GSSAPI_GSSAPI_H,, GSSAPI headers in gssapi/gssapi.h)
have_gssapi=yes
])
AC_CHECK_HEADER([gssapi/gssapi_ext.h], [
AC_DEFINE(HAVE_GSSAPI_GSSAPI_EXT_H,, GSSAPI headers in gssapi/gssapi_ext.h)
])
AC_CHECK_HEADER([gssapi.h], [
AC_DEFINE(HAVE_GSSAPI_H,, GSSAPI headers in gssapi.h)
have_gssapi=yes
])
if test $have_gssapi = yes; then
AC_DEFINE(HAVE_GSSAPI,, Build with GSSAPI support)
AC_CHECK_LIB(gss, __gss_userok, [
AC_DEFINE(HAVE___GSS_USEROK,,
Define if you have __gss_userok())
KRB5_LIBS="$KRB5_LIBS -lgss"
],, $KRB5_LIBS)
if test x$want_gssapi_plugin != xyes; then
AUTH_LIBS="$AUTH_LIBS $KRB5_LIBS"
AUTH_CFLAGS="$AUTH_CFLAGS `krb5-config --cflags gssapi`"
AC_DEFINE(BUILTIN_GSSAPI,, GSSAPI support is built in)
else
have_gssapi_plugin=yes
fi
else
if test $want_gssapi = yes; then
AC_ERROR([Can't build with GSSAPI support: gssapi.h not found])
fi
fi
CFLAGS=$old_CFLAGS
else
if test $want_gssapi = yes; then
AC_ERROR([Can't build with GSSAPI support: v1.2 library not supported])
fi
fi
else
if test $want_gssapi = yes; then
AC_ERROR([Can't build with GSSAPI support: krb5-config not found])
fi
fi
fi
AM_CONDITIONAL(GSSAPI_PLUGIN, test "$have_gssapi_plugin" = "yes")
if test $want_sia != no; then
AC_CHECK_FUNC(sia_validate_user, [
AC_DEFINE(PASSDB_SIA,, Build with Tru64 SIA support)
passdb="$passdb sia"
AUTH_LIBS="$AUTH_LIBS -depth_ring_search"
], [
if test $want_sia = yes; then
AC_ERROR([Can't build with SIA support: sia_validate_user() not found])
fi
])
fi
if test $want_ldap != no; then
AC_CHECK_LIB(ldap, ldap_init, [
AC_CHECK_HEADER(ldap.h, [
AC_CHECK_LIB(ldap, ldap_initialize, [
AC_DEFINE(LDAP_HAVE_INITIALIZE,, Define if you have ldap_initialize)
])
AC_CHECK_LIB(ldap, ldap_start_tls_s, [
AC_DEFINE(LDAP_HAVE_START_TLS_S,, Define if you have ldap_start_tls_s)
])
LDAP_LIBS=-lldap
AC_SUBST(LDAP_LIBS)
if test $want_ldap_plugin != yes; then
AUTH_LIBS="$AUTH_LIBS $LDAP_LIBS"
AC_DEFINE(BUILTIN_LDAP,, LDAP support is built in)
fi
AC_DEFINE(USERDB_LDAP,, Build with LDAP support)
AC_DEFINE(PASSDB_LDAP,, Build with LDAP support)
userdb="$userdb ldap"
passdb="$passdb ldap"
if test $want_ldap_plugin = yes; then
have_ldap_plugin=yes
userdb="$userdb (plugin)"
passdb="$passdb (plugin)"
fi
], [
if test $want_ldap = yes; then
AC_ERROR([Can't build with LDAP support: ldap.h not found])
fi
])
], [
if test $want_ldap = yes; then
AC_ERROR([Can't build with LDAP support: libldap not found])
fi
])
fi
AM_CONDITIONAL(LDAP_PLUGIN, test "$have_ldap_plugin" = "yes")
dict_drivers=client
if test $want_db != no; then
AC_MSG_CHECKING([db_env_create in -ldb])
old_LIBS=$LIBS
LIBS="$LIBS -ldb"
AC_TRY_LINK([
#include <db.h>
], [
db_env_create(0, 0);
], [
AC_MSG_RESULT(yes)
AC_CHECK_HEADER(db.h, [
DICT_LIBS="$DICT_LIBS -ldb"
dict_drivers="$dict_drivers db"
AC_DEFINE(BUILD_DB,, Build with Berkeley DB support)
], [
if test $want_db = yes; then
AC_ERROR([Can't build with db support: db.h not found])
fi
])
], [
AC_MSG_RESULT(no)
if test $want_db = yes; then
AC_ERROR([Can't build with db support: libdb not found])
fi
])
LIBS=$old_LIBS
fi
if test $want_pgsql != no; then
# based on code from PHP
for i in /usr /usr/local /usr/local/pgsql; do
if test -r "$i/$j/libpq-fe.h"; then
PGSQL_INCLUDE=$i/$j
fi
done
for lib in lib lib64; do
if test -f "$i/$j/libpq.so" || test -f "$i/$j/libpq.a"; then
PGSQL_LIBDIR=$i/$j
fi
done
done
done
old_LIBS=$LIBS
if test "$PGSQL_LIBDIR" != ""; then
LIBS="$LIBS -L$PGSQL_LIBDIR"
fi
AC_CHECK_LIB(pq, PQconnectdb, [
AC_CHECK_LIB(pq, PQescapeStringConn, [
AC_DEFINE(HAVE_PQESCAPE_STRING_CONN,, Define if libpq has PQescapeStringConn function)
])
old_CPPFLAGS=$CPPFLAGS
if test "$PGSQL_INCLUDE" != ""; then
CPPFLAGS="$CPPFLAGS -I $PGSQL_INCLUDE"
fi
AC_CHECK_HEADER(libpq-fe.h, [
if test "$PGSQL_INCLUDE" != ""; then
PGSQL_CFLAGS="$PGSQL_CFLAGS -I$PGSQL_INCLUDE"
fi
if test "$PGSQL_LIBDIR" != ""; then
PGSQL_LIBS="$PGSQL_LIBS -L$PGSQL_LIBDIR"
fi
PGSQL_LIBS="$PGSQL_LIBS -lpq"
AC_DEFINE(HAVE_PGSQL,, Build with PostgreSQL support)
found_sql_drivers="$found_sql_drivers pgsql"
if test "$all_sql_drivers" = "yes"; then
sql_drivers="$sql_drivers pgsql"
fi
], [
if test $want_pgsql = yes; then
AC_ERROR([Can't build with PostgreSQL support: libpq-fe.h not found])
fi
])
CPPFLAGS=$old_CPPFLAGS
], [
if test $want_pgsql = yes; then
AC_ERROR([Can't build with PostgreSQL support: libpq not found])
fi
])
LIBS=$old_LIBS
fi
if test $want_mysql != no; then
# based on code from PHP
for i in /usr /usr/local /usr/local/mysql; do
for j in include include/mysql ""; do
if test -r "$i/$j/mysql.h"; then
MYSQL_INCLUDE=$i/$j
fi
done
for j in lib lib/mysql lib64 lib64/mysql ""; do
if test -f "$i/$j/libmysqlclient.so" || test -f "$i/$j/libmysqlclient.a"; then
MYSQL_LIBDIR=$i/$j
fi
done
done
old_LIBS=$LIBS
if test "$MYSQL_LIBDIR" != ""; then
LIBS="$LIBS -L$MYSQL_LIBDIR"
fi
mysql_lib=""
LIBS="$LIBS -lz -lm"
AC_CHECK_LIB(mysqlclient, mysql_init, [
old_CPPFLAGS=$CPPFLAGS
if test "$MYSQL_INCLUDE" != ""; then
CPPFLAGS="$CPPFLAGS -I $MYSQL_INCLUDE"
fi
AC_CHECK_HEADER(mysql.h, [
if test "$MYSQL_INCLUDE" != ""; then
MYSQL_CFLAGS="$MYSQL_CFLAGS -I$MYSQL_INCLUDE"
fi
if test "$MYSQL_LIBDIR" != ""; then
MYSQL_LIBS="$MYSQL_LIBS -L$MYSQL_LIBDIR"
fi
MYSQL_LIBS="$MYSQL_LIBS -lmysqlclient -lz -lm"
AC_CHECK_LIB(mysqlclient, mysql_ssl_set, [
AC_DEFINE(HAVE_MYSQL_SSL,, Define if your MySQL library has SSL functions)
if test "x$have_openssl" = "yes"; then
ssl_define="#define HAVE_OPENSSL"
else
ssl_define=""
fi
AC_TRY_COMPILE([
$ssl_define
#include <mysql.h>
], [
mysql_set_ssl(0, 0, 0, 0, 0, 0);
], [
AC_DEFINE(HAVE_MYSQL_SSL_CIPHER,, Define if your MySQL library supports setting cipher)
])
])
AC_DEFINE(HAVE_MYSQL,, Build with MySQL support)
found_sql_drivers="$found_sql_drivers mysql"
], [
if test $want_mysql = yes; then
AC_ERROR([Can't build with MySQL support: mysql.h not found])
fi
])
CPPFLAGS=$old_CPPFLAGS
], [
if test $want_mysql = yes; then
AC_ERROR([Can't build with MySQL support: libmysqlclient not found])
fi
])
LIBS=$old_LIBS
fi
if test $want_sqlite != no; then
AC_CHECK_LIB(sqlite3, sqlite3_open, [
AC_CHECK_HEADER(sqlite3.h, [
SQLITE_LIBS="$SQLITE_LIBS -lsqlite3 -lz"
AC_DEFINE(HAVE_SQLITE,, Build with SQLite3 support)
found_sql_drivers="$found_sql_drivers sqlite"
], [
if test $want_sqlite = yes; then
AC_ERROR([Can't build with SQLite support: sqlite3.h not found])
fi
])
], [
if test $want_sqlite = yes; then
AC_ERROR([Can't build with SQLite support: libsqlite3 not found])
fi
])
fi
SQL_CFLAGS="$MYSQL_CFLAGS $PGSQL_CFLAGS $SQLITE_CFLAGS"
if test "$want_sql_plugins" != "yes"; then
SQL_LIBS="$MYSQL_LIBS $PGSQL_LIBS $SQLITE_LIBS"
fi
if test "$found_sql_drivers" != "" -o "$want_sql" != "no"; then
if test "$all_sql_drivers" = "yes"; then
sql_drivers="$found_sql_drivers"
fi
AC_DEFINE(PASSDB_SQL,, Build with SQL support)
AC_DEFINE(USERDB_SQL,, Build with SQL support)
AUTH_LIBS="$AUTH_LIBS $SQL_LIBS"
passdb="$passdb sql"
userdb="$userdb sql"
fi
if test $want_vpopmail != no; then
vpop_libdeps="$vpopmail_home/etc/lib_deps"
AC_MSG_CHECKING([for vpopmail configuration at $vpop_libdeps])
if test -f $vpop_libdeps; then
AUTH_CFLAGS="$AUTH_CFLAGS `cat $vpopmail_home/etc/inc_deps` $CFLAGS"
AUTH_LIBS="$AUTH_LIBS `cat $vpop_libdeps`"
AC_DEFINE(USERDB_VPOPMAIL,, Build with vpopmail support)
AC_DEFINE(PASSDB_VPOPMAIL,, Build with vpopmail support)
userdb="$userdb vpopmail"
passdb="$passdb vpopmail"
AC_MSG_RESULT(found)
else
AC_MSG_RESULT(not found)
if test $want_vpopmail = yes; then
AC_ERROR([Can't build with vpopmail support: $vpop_libdeps not found])
fi
fi
fi
AC_CHECK_FUNC(crypt,, [
AC_CHECK_LIB(crypt, crypt, [
AUTH_LIBS="-lcrypt $AUTH_LIBS"
], [
AC_MSG_ERROR([crypt() wasn't found])
])
])
dnl * dynamic modules?
have_modules=no
AC_CHECK_FUNC(dlopen, [
have_modules=yes
MODULE_LIBS="-export-dynamic"
], [
AC_CHECK_LIB(dl, dlopen, [
have_modules=yes
MODULE_LIBS="-export-dynamic -ldl"
])
])
if test $have_modules = yes; then
AC_DEFINE(HAVE_MODULES,, Define if you have dynamic module support)
AC_SUBST(MODULE_LIBS)
fi
have_nss=no
if test $want_nss != no; then
if test $have_modules != yes; then
if test $want_nss = yes; then
AC_ERROR([Can't build with NSS support: Dynamic modules not supported])
fi
else
AC_TRY_COMPILE([
#include <nss.h>
], [
enum nss_status status = NSS_STATUS_TRYAGAIN;
], [
AC_DEFINE(USERDB_NSS,, Build with NSS module support)
userdb="$userdb nss"
have_nss=yes
], [
if test $want_nss = yes; then
AC_ERROR([Can't build with NSS support: nss.h not found or not usable])
fi
])
fi
fi
AC_SUBST(AUTH_CFLAGS)
AC_SUBST(AUTH_LIBS)
AC_SUBST(SQL_CFLAGS)
AC_SUBST(SQL_LIBS)
AC_SUBST(MYSQL_CFLAGS)
AC_SUBST(MYSQL_LIBS)
AC_SUBST(PGSQL_CFLAGS)
AC_SUBST(PGSQL_LIBS)
AC_SUBST(SQLITE_CFLAGS)
AC_SUBST(SQLITE_LIBS)
AC_SUBST(DICT_LIBS)
AC_SUBST(dict_drivers)
dnl **
dnl ** Index file compatibility flags
dnl **
dnl * currently just checking for endianess
AC_C_BIGENDIAN
if test $ac_cv_c_bigendian = yes; then
flags=0
else
flags=1
fi
AC_DEFINE_UNQUOTED(MAIL_INDEX_COMPAT_FLAGS, $flags, Index file compatibility flags)
dnl **
dnl ** IPv6 support
dnl **
have_ipv6=no
if test "$want_ipv6" != no; then
AC_MSG_CHECKING([for IPv6])
AC_CACHE_VAL(i_cv_type_in6_addr,
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>]],
[[struct in6_addr i;]])],
[i_cv_type_in6_addr=yes],
[i_cv_type_in6_addr=no])])
if test $i_cv_type_in6_addr = yes; then
AC_DEFINE(HAVE_IPV6,, Build with IPv6 support)
have_ipv6=yes
elif test $want_ipv6 = yes; then
AC_ERROR([IPv6 support not found])
fi
AC_MSG_RESULT($i_cv_type_in6_addr)
fi
dnl **
dnl ** storage classes
dnl **
maildir_libs='$(top_builddir)/src/lib-storage/index/maildir/libstorage_maildir.a'
mbox_libs='$(top_builddir)/src/lib-storage/index/mbox/libstorage_mbox.a'
dbox_libs='$(top_builddir)/src/lib-storage/index/dbox/libstorage_dbox.a'
cydir_libs='$(top_builddir)/src/lib-storage/index/cydir/libstorage_cydir.a'
raw_libs='$(top_builddir)/src/lib-storage/index/raw/libstorage_raw.a'
CORE_LIBS='$(top_builddir)/src/lib-storage/index/libstorage_index.a $(top_builddir)/src/lib-storage/libstorage.a $(top_builddir)/src/lib-index/libindex.a'
deliver_storage="raw"
STORAGE_LIBS=
for storage in $mail_storages; do
if test "$storage" = "$deliver_storage"; then
deliver_storage=""
fi
STORAGE_LIBS="$STORAGE_LIBS `eval echo \\$${storage}_libs`"
done
STORAGE_LIBS="$STORAGE_LIBS $CORE_LIBS"
AC_SUBST(STORAGE_LIBS)
AC_DEFINE_UNQUOTED(MAIL_STORAGES, "$mail_storages", List of compiled in mail storages)
if test -n "$deliver_storage" && test "$want_deliver" = yes; then
AC_ERROR([If you remove raw from storages, you need to build --without-deliver])
fi
dnl **
dnl ** SQL drivers
dnl **
build_pgsql=no
build_mysql=no
build_sqlite=no
for driver in $sql_drivers; do
if test "$driver" = "pgsql"; then
AC_DEFINE(BUILD_PGSQL,, Built-in PostgreSQL support)
build_pgsql=yes
elif test "$driver" = "mysql"; then
AC_DEFINE(BUILD_MYSQL,, Built-in MySQL support)
build_mysql=yes
elif test "$driver" = "sqlite"; then
AC_DEFINE(BUILD_SQLITE,, Built-in SQLite support)
build_sqlite=yes
fi
done
AC_SUBST(sql_drivers)
AM_CONDITIONAL(BUILD_PGSQL, test "$build_pgsql" = "yes")
AM_CONDITIONAL(BUILD_MYSQL, test "$build_mysql" = "yes")
AM_CONDITIONAL(BUILD_SQLITE, test "$build_sqlite" = "yes")
AM_CONDITIONAL(SQL_PLUGINS, test "$want_sql_plugins" = "yes")
dnl **
dnl ** Plugins
dnl **
have_zlib=no
AC_CHECK_HEADER(zlib.h, [
have_zlib=yes
])
AM_CONDITIONAL(BUILD_ZLIB, test "$have_zlib" = "yes")
RPCGEN=${RPCGEN-rpcgen}
RPCGEN=
fi
AC_SUBST(RPCGEN)
have_rquota=no
if test -f /usr/include/rpcsvc/rquota.x && test -n "$RPCGEN"; then
AC_DEFINE(HAVE_RQUOTA,, Define if you wish to retrieve quota of NFS mounted mailboxes)
have_rquota=yes
fi
AM_CONDITIONAL(HAVE_RQUOTA, test "$have_rquota" = "yes")
dnl **
dnl ** capabilities
dnl **
capability="IMAP4rev1 SASL-IR SORT THREAD=REFERENCES MULTIAPPEND UNSELECT LITERAL+ IDLE CHILDREN NAMESPACE LOGIN-REFERRALS UIDPLUS LIST-EXTENDED I18NLEVEL=1 ENABLE CONDSTORE QRESYNC ESEARCH"
AC_DEFINE_UNQUOTED(CAPABILITY_STRING, "$capability", IMAP capabilities)
CFLAGS="$CFLAGS $EXTRA_CFLAGS"
if test "$docdir" = ""; then
dnl docdir supported only by autoconf v2.59c and later
docdir='${datadir}/doc/${PACKAGE_TARNAME}'
fi
AC_SUBST(docdir)
AC_CONFIG_HEADERS([config.h])
AC_CONFIG_FILES([
Makefile
AC_OUTPUT
if test "$want_sql_plugins" = "yes"; then
sql_drivers="$sql_drivers (plugins)"
fi
echo
echo "Install prefix ...................... : $prefix"
echo "File offsets ........................ : ${offt_bits}bit"
echo "I/O loop method ..................... : $ioloop"
echo "File change notification method ..... : $have_notify"
echo "Building with SSL support ........... : $have_ssl"
echo "Building with IPv6 support .......... : $have_ipv6"
echo "Building with pop3 server ........... : $want_pop3d"
echo "Building with mail delivery agent .. : $want_deliver"
echo "Building with GSSAPI support ........ : $have_gssapi"
echo "Building with user database modules . :$userdb"
echo "Building with password lookup modules :$passdb"
echo "Building with SQL drivers ............:$sql_drivers"