configure.in revision f7869168597ac562d7eadb86e8cbb9bd7c7b571a
AC_INIT(src)
AM_CONFIG_HEADER(config.h)
AM_INIT_AUTOMAKE(dovecot, 1.0-test13)
AM_MAINTAINER_MODE
AC_ISC_POSIX
AC_PROG_CC
AC_PROG_CPP
AC_STDC_HEADERS
AC_C_INLINE
AC_ARG_PROGRAM
AM_PROG_LIBTOOL
AM_ICONV
AC_CHECK_HEADERS(sys/select.h)
# check posix headers
AC_CHECK_HEADERS(sys/time.h)
AC_ARG_ENABLE(ipv6,
[ --enable-ipv6 Enable IPv6 support (default)],
if test x$enableval = xno; then
want_ipv6=no
else
want_ipv6=yes
fi,
want_ipv6=yes)
AC_ARG_ENABLE(debug,
[ --enable-debug Enable some extra checks for debugging],
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(file-offset-size,
[ --with-file-offset-size=BITS Set size of file offsets. Usually 32 or 64.
(default: 64 if available)],
preferred_off_t_bits=$withval,
preferred_off_t_bits=64)
AC_ARG_WITH(mem-align,
[ --with-mem-align=BYTES Set the memory alignment (default: 8)],
mem_align=$withval,
mem_align=8)
AC_ARG_WITH(passwd,
[ --with-passwd Build with /etc/passwd support (default)],
if test x$withval = xno; then
want_passwd=no
else
want_passwd=yes
fi,
want_passwd=yes)
AC_ARG_WITH(passwd-file,
[ --with-passwd-file Build with passwd-like file support (default)],
if test x$withval = xno; then
want_passwd_file=no
else
want_passwd_file=yes
fi,
want_passwd_file=yes)
AC_ARG_WITH(shadow,
[ --with-shadow Build with shadow password support (default)],
if test x$withval = xno; then
want_shadow=no
else
want_shadow=yes
fi,
want_shadow=yes)
AC_ARG_WITH(pam,
[ --with-pam Build with PAM support (default)],
if test x$withval = xno; then
want_pam=no
else
want_pam=yes
fi,
want_pam=yes)
AC_ARG_WITH(bsdauth,
[ --with-bsdauth Build with BSD authentication support (default)],
if test x$withval = xno; then
want_bsdauth=no
else
want_bsdauth=yes
fi,
want_bsdauth=yes)
AC_ARG_WITH(ldap,
[ --with-ldap Build with LDAP support],
if test x$withval = xno; then
want_ldap=no
else
want_ldap=yes
fi,
want_ldap=no)
AC_ARG_WITH(vpopmail,
[ --with-vpopmail Build with vpopmail support (default)],
if test x$withval = xno; then
want_vpopmail=no
else
want_vpopmail=yes
fi,
want_vpopmail=yes)
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(pgsql,
[ --with-pgsql Build with PostgreSQL support],
if test x$withval = xno; then
want_pgsql=no
else
want_pgsql=yes
fi,
want_pgsql=no)
AC_ARG_WITH(mysql,
[ --with-mysql Build with MySQL support],
if test x$withval = xno; then
want_mysql=no
else
want_mysql=yes
fi,
want_mysql=no)
AC_ARG_WITH(cyrus-sasl2,
[ --with-cyrus-sasl2 Build with Cyrus SASL 2 library support],
if test x$withval = xno; then
want_cyrus_sasl2=no
else
want_cyrus_sasl2=yes
fi,
want_cyrus_sasl2=no)
AC_ARG_WITH(ssl,
[ --with-ssl=[gnutls|openssl] Build with GNUTLS (default) or OpenSSL],
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=yes
want_openssl=yes
fi, [
want_gnutls=yes
want_openssl=yes
])
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(gc,
[ --with-gc Use Boehm garbage collector (currently broken)],
if test x$withval = xyes; then
want_gc=yes
else
if test "x$withval" = xno; then
want_gc=no
else
want_gc=yes
fi
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(storages,
[ --with-storages Build specified mail storage formats (maildir,mbox)], [
mail_storages=`echo "$withval"|sed 's/,/ /g'` ],
mail_storages="maildir mbox")
AC_ARG_WITH(moduledir,
[ --with-moduledir=DIR Base directory for dynamically loadable modules],
moduledir="$withval",
moduledir=$libdir/dovecot
)
AC_SUBST(moduledir)
dnl * gcc specific options
if test "x$ac_cv_prog_gcc" = "xyes"; then
# -Wcast-qual -Wcast-align -Wconversion # 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"
fi
dnl **
dnl ** just some generic stuff...
dnl **
AC_CHECK_FUNC(socket, [], [
AC_CHECK_LIB(socket, socket, [
LIBS="$LIBS -lsocket"
])
])
AC_CHECK_FUNC(inet_addr, [], [
AC_CHECK_LIB(nsl, inet_addr, [
LIBS="$LIBS -lnsl"
])
])
AC_CHECK_FUNC(fdatasync, [
have_fdatasync=yes
], [
AC_CHECK_LIB(rt, fdatasync, [
have_fdatasync=yes
LIBS="$LIBS -lrt"
])
])
if test "$have_fdatasync" = "yes"; then
AC_DEFINE(HAVE_FDATASYNC,, Define if you have fdatasync())
fi
dnl * after -lsocket and -lnsl tests, inet_aton() may be in them
AC_CHECK_FUNCS(fcntl flock inet_aton sigaction getpagesize madvise \
strcasecmp stricmp vsnprintf vsyslog writev pread \
setrlimit setproctitle)
dnl * poll/select?
AC_CHECK_FUNC(poll, [
AC_DEFINE(IOLOOP_POLL,, Implement I/O loop with poll())
], [
AC_DEFINE(IOLOOP_SELECT,, Implement I/O loop with select())
])
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_DEFINE(IOLOOP_NOTIFY_DNOTIFY,, Use Linux dnotify)
], [
AC_DEFINE(IOLOOP_NOTIFY_NONE,, No special notify support)
])
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 * 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_prog_gcc" = "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_TRY_COMPILE([
#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_TRY_COMPILE([
#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_TRY_RUN([
#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
visible="`expr $size \* 8`bit (unknown type)"
fi
])
fi
typeof_$1=$result
AC_MSG_RESULT($visible)
])
dnl * off_t checks, try to make it 64bit
AC_DEFINE_UNQUOTED(_FILE_OFFSET_BITS, $preferred_off_t_bits,
[If set to 64, enables 64bit off_t for some systems (eg. Linux, Solaris)])
AC_TYPEOF(off_t, long int long-long)
case "$typeof_off_t" in
int)
offt_max=INT_MAX
uofft_fmt="u"
AC_DEFINE(UOFF_T_INT,, Define if off_t is int)
offt_bits=`expr 8 \* $ac_cv_sizeof_int`
;;
long)
offt_max=LONG_MAX
uofft_fmt="lu"
AC_DEFINE(UOFF_T_LONG,, Define if off_t is long)
offt_bits=`expr 8 \* $ac_cv_sizeof_long`
;;
"long long")
offt_max=LLONG_MAX
uofft_fmt="llu"
AC_DEFINE(UOFF_T_LONG_LONG,, Define if off_t is long long)
offt_bits=`expr 8 \* $ac_cv_sizeof_long_long`
;;
*)
AC_ERROR([Unsupported off_t type])
;;
esac
dnl * Do we have struct dirent->d_type
AC_TRY_COMPILE([
#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_TRY_COMPILE([
#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_MSG_CHECKING([whether size_t is signed])
AC_TRY_RUN([
#include <sys/types.h>
int main() {
/* return 0 if we're signed */
exit((size_t)(int)-1 <= 0 ? 0 : 1);
}
], [
AC_MSG_RESULT(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_ERROR([aborting])
fi
echo "..ignoring as requested.."
], [
AC_MSG_RESULT(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_TRY_COMPILE([
#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_TRY_COMPILE([
#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_MSG_CHECKING([how large time_t values gmtime() accepts])
AC_TRY_RUN([
#include <stdio.h>
#include <time.h>
int main() {
FILE *f;
int bits;
time_t t;
for (bits = 1, t = 1; t > 0; ++bits, t <<= 1) {
if (gmtime(&t) == NULL) {
bits--;
break;
}
}
f = fopen("conftest.temp", "w");
if (f == NULL) {
perror("fopen()");
return 1;
}
fprintf(f, "%d", bits);
fclose(f);
return 0;
}
], [
max_bits=`cat conftest.temp`
rm -f conftest.temp
AC_MSG_RESULT($max_bits)
], [
AC_MSG_RESULT([check failed, assuming 31])
max_bits=31
])
AC_DEFINE_UNQUOTED(TIME_T_MAX_BITS, $max_bits, max. time_t bits gmtime() can handle)
dnl * do we have struct iovec
AC_MSG_CHECKING([for struct iovec])
AC_CACHE_VAL(i_cv_struct_iovec,
[AC_TRY_COMPILE([
#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_TRY_COMPILE([
#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_prog_gcc" = "xyes"; then
CFLAGS=`echo $CFLAGS|sed 's/ -W\b//'`
fi
])
dnl * Do we have RLIMIT_AS?
AC_TRY_COMPILE([
#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_TRY_COMPILE([
#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_COMPILE([
#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_MSG_CHECKING([whether shared mmaps get updated by write()s])
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;
}
], [
AC_MSG_RESULT(yes)
], [
AC_MSG_RESULT(no)
AC_DEFINE(MMAP_CONFLICTS_WRITE,, [Define if shared mmaps don't get updated by write()s])
])
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_COMPILE([
#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_COMPILE([
#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 ***
dnl *** va_copy checks (from GLIB)
dnl ***
AC_CACHE_CHECK([for an implementation of va_copy()],lib_cv_va_copy,[
AC_TRY_RUN([
#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_TRY_RUN([
#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_TRY_RUN([
#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" = "yes" && test "$have_ssl" = "no"; then
if pkg-config --exists openssl; 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
])
],, -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 = yes && test "$have_ssl" = no; then
AC_CHECK_LIB(gnutls, gnutls_global_init, [
AC_CHECK_HEADERS(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
])
],, -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" = "yes"; then
AC_CHECK_LIB(gc, GC_malloc, [
AC_DEFINE(USE_GC,, Define if you want to use Boehm GC)
LIBS="$LIBS -lgc"
], [
want_gc=no
])
fi
dnl **
dnl ** userdb and passdb checks
dnl **
need_crypt=no
userdb=""
passdb=""
if test $want_static_userdb = yes; then
need_crypt=yes
AC_DEFINE(USERDB_STATIC,, Build with static userdb support)
userdb="$userdb static"
fi
if test $want_passwd = yes; then
need_crypt=yes
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 = yes; then
need_crypt=yes
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 = yes; then
AC_CHECK_FUNC(getspnam, [
AC_CHECK_HEADER(shadow.h, [
need_crypt=yes
AC_DEFINE(PASSDB_SHADOW,, Build with shadow support)
passdb="$passdb shadow"
])
])
fi
if test $want_pam = yes; 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())
])
fi
])
fi
if test $want_bsdauth = yes; then
AC_CHECK_FUNC(auth_userokay, [
AC_DEFINE(PASSDB_BSDAUTH,, Build with BSD authentication support)
passdb="$passdb bsdauth"
])
fi
if test $want_ldap = yes; then
AC_CHECK_LIB(ldap, ldap_init, [
AC_CHECK_HEADER(ldap.h, [
AUTH_LIBS="$AUTH_LIBS -lldap"
AC_DEFINE(USERDB_LDAP,, Build with LDAP support)
AC_DEFINE(PASSDB_LDAP,, Build with LDAP support)
userdb="$userdb ldap"
passdb="$passdb ldap"
])
])
fi
if test $want_pgsql = yes; 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
if test -f "$i/$j/libpq.so" || test -f "$i/$j/libpq.a"; then
PGSQL_LIBDIR=$i/$j
fi
done
done
old_LIBS=$LIBS
if test "$PGSQL_LIBDIR" != ""; then
LIBS="$LIBS -L$PGSQL_LIBDIR"
fi
AC_CHECK_LIB(pq, PQconnectdb, [
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
AUTH_CFLAGS="$AUTH_CFLAGS -I$PGSQL_INCLUDE"
fi
if test "$PGSQL_LIBDIR" != ""; then
AUTH_LIBS="$AUTH_LIBS -L$PGSQL_LIBDIR"
fi
AUTH_LIBS="$AUTH_LIBS -lpq"
AC_DEFINE(USERDB_PGSQL,, Build with PostgreSQL support)
AC_DEFINE(PASSDB_PGSQL,, Build with PostgreSQL support)
userdb="$userdb pgsql"
passdb="$passdb pgsql"
])
CPPFLAGS=$old_CPPFLAGS
])
LIBS=$old_LIBS
fi
if test $want_mysql = yes; then
AC_CHECK_LIB(mysqlclient, mysql_init, [
AC_CHECK_HEADER(mysql.h,, [
AC_CHECK_HEADER(mysql/mysql.h, [
AUTH_CFLAGS="$AUTH_CFLAGS -DHAVE_MYSQL_MYSQL_H"
], want_mysql = no)
])
], want_mysql = no)
if test $want_mysql = yes; then
AUTH_LIBS="$AUTH_LIBS -lmysqlclient"
AC_DEFINE(USERDB_MYSQL,, Build with MySQL support)
AC_DEFINE(PASSDB_MYSQL,, Build with MySQL support)
userdb="$userdb mysql"
passdb="$passdb mysql"
fi
fi
if test $want_vpopmail = yes; then
vpopmail_home="`echo ~vpopmail`"
vpop_libdeps="$vpopmail_home/etc/lib_deps"
AC_MSG_CHECKING([for vpopmail configuration at $vpop_libdeps])
if test -f $vpop_libdeps; then
need_crypt=yes
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
want_vpopmail=no
AC_MSG_RESULT(not found)
fi
fi
if test $want_cyrus_sasl2 = yes; then
AC_CHECK_LIB(sasl2, sasl_server_start, [
AC_CHECK_HEADER(sasl/sasl.h, [
AC_DEFINE(USE_CYRUS_SASL2,,
Define if you want to use Cyrus SASL library)
AUTH_LIBS="$AUTH_LIBS -lsasl2"
])
])
fi
if test $need_crypt = yes; then
AC_CHECK_LIB(crypt, crypt, [
AUTH_LIBS="-lcrypt $AUTH_LIBS"
], [
AC_CHECK_FUNC(crypt,, [
AC_ERROR([crypt() wasn't found])
])
])
fi
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)
userdb="$userdb (modules)"
passdb="$passdb (modules)"
AC_SUBST(MODULE_LIBS)
fi
AC_SUBST(AUTH_CFLAGS)
AC_SUBST(AUTH_LIBS)
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 **
if test "x$want_ipv6" = "xyes"; then
AC_MSG_CHECKING([for IPv6])
AC_CACHE_VAL(i_cv_type_in6_addr,
[AC_TRY_COMPILE([
#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)
fi
AC_MSG_RESULT($i_cv_type_in6_addr)
fi
dnl **
dnl ** storage classes
dnl **
maildir_libs="../lib-storage/index/maildir/libstorage_maildir.a"
mbox_libs="../lib-storage/index/mbox/libstorage_mbox.a"
index_libs="../lib-storage/index/libstorage_index.a ../lib-index/libindex.a"
STORAGE_LIBS=
for storage in $mail_storages; do
STORAGE_LIBS="$STORAGE_LIBS `eval \"echo \\$${storage}_libs\"`"
done
STORAGE_LIBS="$STORAGE_LIBS $index_libs"
AC_SUBST(STORAGE_LIBS)
dnl **
dnl ** capabilities
dnl **
capability="IMAP4rev1 SORT THREAD=REFERENCES MULTIAPPEND UNSELECT LITERAL+ IDLE CHILDREN LISTEXT NAMESPACE"
AC_DEFINE_UNQUOTED(CAPABILITY_STRING, "$capability", IMAP capabilities)
CFLAGS="$CFLAGS $EXTRA_CFLAGS"
AC_OUTPUT(
Makefile
dnl **
dnl ** register the storage classes
dnl **
dnl * do it after AC_OUTPUT(), so we know that the directory exists.
dnl * it doesn't when building in different directory
echo "/* this file is generated by configure */" > $file
echo '#include "lib.h"' >> $file
echo '#include "mail-storage.h"' >> $file
for storage in $mail_storages; do
echo "extern struct mail_storage ${storage}_storage;" >> $file
done
echo "void mail_storage_register_all(void) {" >> $file
for storage in $mail_storages; do
echo "mail_storage_class_register(&${storage}_storage);" >> $file
done
echo "}" >> $file
echo
echo "Install prefix ...................... : $prefix"
echo "File offsets ........................ : ${offt_bits}bit"
echo "Building with SSL support ........... : $have_ssl"
echo "Building with IPv6 support .......... : $want_ipv6"
echo "Building with pop3 server ........... : $want_pop3d"
echo "Building with user database modules . :$userdb"
echo "Building with password lookup modules :$passdb"