path: root/configure.in

dnl Process this file with autoconf to produce a configure script.

dnl !!! WHEN ADDING NEW CONFIGURE TESTS, PLEASE ADD CODE TO MAIN.C !!!
dnl !!! TO DUMP THEIR RESULTS WHEN MUTT -V IS CALLED               !!!

AC_PREREQ(2.12)
AC_INIT(mutt.h)
AM_CONFIG_HEADER(config.h)

mutt_cv_version=`cat $srcdir/VERSION`

AM_INIT_AUTOMAKE(mutt, $mutt_cv_version)

ALL_LINGUAS="de ru it es uk fr pl nl cs id sk ko el zh_TW.Big5 zh_CN.GB2312 pt_BR eo gl sv da lt tr"

AC_CANONICAL_HOST

AC_MSG_CHECKING(for prefix)
if test x$prefix = xNONE; then
	mutt_cv_prefix=$ac_default_prefix
else
	mutt_cv_prefix=$prefix
fi
AC_MSG_RESULT($mutt_cv_prefix)

AC_PROG_CC
AC_ISC_POSIX
AM_C_PROTOTYPES
if test "x$U" != "x"; then
  AC_MSG_ERROR(Compiler not ANSI compliant)
fi
AC_PROG_CPP
AC_PROG_MAKE_SET
AC_PROG_INSTALL
AC_PROG_RANLIB
AC_CHECK_TOOL(AR, ar, ar)

AC_C_INLINE
AC_C_CONST

AC_PATH_PROG(DBX, dbx, no)
AC_PATH_PROG(GDB, gdb, no)
AC_PATH_PROG(SDB, sdb, no)

if test $GDB != no ; then
	DEBUGGER=$GDB
elif test $DBX != no ; then
	DEBUGGER=$DBX 
elif test $SDB != no ; then
	DEBUGGER=$SDB
else
	DEBUGGER=no
fi

AC_SUBST(DEBUGGER)

ac_aux_path_sendmail=/usr/sbin:/usr/lib   
AC_PATH_PROG(SENDMAIL, sendmail, no, $PATH:$ac_aux_path_sendmail)

AC_DEFINE_UNQUOTED(SENDMAIL, "$ac_cv_path_SENDMAIL")

OPS='$(srcdir)/OPS'
if test -f $srcdir/EXPORTABLE ; then
	SUBVERSION="us"
else
	SUBVERSION="i"

	AC_ARG_ENABLE(pgp, [  --disable-pgp              Disable PGP support],
	[	if test x$enableval = xno ; then
			HAVE_PGP=no
		fi
	])

	if test x$HAVE_PGP != xno ; then
		AC_DEFINE(HAVE_PGP)
		PGPAUX_TARGET=pgpring
		AM_CONDITIONAL(NEEDS_PGPEWRAP, true)
		MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS pgp.o pgpinvoke.o pgpkey.o pgplib.o gnupgparse.o pgpmicalg.o pgppacket.o"
		OPS="$OPS \$(srcdir)/OPS.PGP"
	fi

	AC_ARG_WITH(mixmaster, [  --with-mixmaster[=PATH]    Include Mixmaster support],
		[if test -x "$withval" ; then
			MIXMASTER="$withval"
		 else
		 	MIXMASTER="mixmaster"
		 fi
		 OPS="$OPS \$(srcdir)/OPS.MIX"
		 MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS remailer.o"
		 AC_DEFINE_UNQUOTED(MIXMASTER, "$MIXMASTER")
                ])
		
fi
AC_SUBST(OPS)

AC_SUBST(PGPAUX_TARGET)

AC_DEFINE_UNQUOTED(SUBVERSION, "$SUBVERSION")
AC_SUBST(SUBVERSION)

AC_PATH_PROG(ISPELL, ispell, no)
if test $ISPELL != no; then
	AC_DEFINE_UNQUOTED(ISPELL, "$ISPELL")
fi

AC_ARG_WITH(slang, [  --with-slang[=DIR]         Use S-Lang instead of ncurses],
	[AC_CACHE_CHECK([if this is a BSD system], mutt_cv_bsdish,
		[AC_TRY_RUN([#include <sys/param.h>

main ()
{
#ifdef BSD
	exit (0);
#else
	exit (1);
#endif
}],
			mutt_cv_bsdish=yes,
			mutt_cv_bsdish=no,
			mutt_cv_bsdish=no)])
	
	AC_MSG_CHECKING(for S-Lang)
	if test $withval = yes; then
		if test -d $srcdir/../slang; then
			mutt_cv_slang=$srcdir/../slang/src
			CPPFLAGS="$CPPFLAGS -I${mutt_cv_slang}"
			LDFLAGS="$LDFLAGS -L${mutt_cv_slang}/objs"
		else
			if test -d $mutt_cv_prefix/include/slang; then
				CPPFLAGS="$CPPFLAGS -I$mutt_cv_prefix/include/slang"
			elif test -d /usr/include/slang; then
				CPPFLAGS="$CPPFLAGS -I/usr/include/slang"
			fi
			mutt_cv_slang=yes
		fi
	else
		dnl ---Check to see if $withval is a source directory
		if test -f $withval/src/slang.h; then
			mutt_cv_slang=$withval/src
			CPPFLAGS="$CPPFLAGS -I${mutt_cv_slang}"
			LDFLAGS="$LDFLAGS -L${mutt_cv_slang}/objs"
		else
			dnl ---Must be installed somewhere
			mutt_cv_slang=$withval
			if test -d $withval/include/slang; then
				CPPFLAGS="$CPPFLAGS -I${withval}/include/slang"
			elif test -d $withval/include; then
				CPPFLAGS="$CPPFLAGS -I${withval}/include"
			fi
			LDFLAGS="$LDFLAGS -L${withval}/lib"
		fi
	fi
	AC_MSG_RESULT($mutt_cv_slang)
	if test $mutt_cv_bsdish = yes; then
		AC_CHECK_LIB(termlib, main)
	fi
	AC_DEFINE(USE_SLANG_CURSES)
	AC_DEFINE(HAVE_COLOR)
	MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS resize.o"
	
	dnl --- now that we've found it, check the link
	
	AC_CHECK_LIB(slang, SLtt_get_terminfo,
		[MUTTLIBS="$MUTTLIBS -lslang -lm"],
		[AC_MSG_ERROR(unable to compile.  check config.log)], -lm)

	],

	[mutt_cv_curses=/usr
	AC_ARG_WITH(curses, [  --with-curses=DIR          Where ncurses is installed ],
		[if test $withval != yes; then
			mutt_cv_curses=$withval
		fi
		if test x$mutt_cv_curses != x/usr; then
			LDFLAGS="-L${mutt_cv_curses}/lib $LDFLAGS"
			CPPFLAGS="$CPPFLAGS -I${mutt_cv_curses}/include"
		fi])

	AC_CHECK_LIB(ncurses, initscr,

		[MUTTLIBS="$MUTTLIBS -lncurses"
		if test x$mutt_cv_curses = x/usr -a -d /usr/include/ncurses; then
			CPPFLAGS="$CPPFLAGS -I/usr/include/ncurses"
		fi
		AC_CHECK_HEADERS(ncurses.h)],

		[CF_CURSES_LIBS])

	old_LIBS="$LIBS"
	LIBS="$LIBS $MUTTLIBS"
	CF_CHECK_FUNCDECLS([#include <curses.h>], start_color typeahead bkgdset curs_set meta use_default_colors resizeterm)
	if test "$ac_cv_func_decl_start_color" = yes; then
		AC_DEFINE(HAVE_COLOR)
	fi
	if test "$ac_cv_func_decl_resizeterm" = yes; then
		MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS resize.o"
	fi
	LIBS="$old_LIBS"
	])

AC_HEADER_STDC

AC_CHECK_HEADERS(stdarg.h sys/ioctl.h ioctl.h sysexits.h)
AC_CHECK_HEADERS(sys/time.h sys/resource.h)
AC_CHECK_HEADERS(unix.h)

AC_CHECK_FUNCS(setrlimit getsid)

AC_TYPE_SIGNAL

AC_MSG_CHECKING(for sig_atomic_t in signal.h)
AC_EGREP_HEADER(sig_atomic_t,signal.h,dnl
  [
    ac_cv_type_sig_atomic_t=yes;
    AC_EGREP_HEADER(volatile.*sig_atomic_t,
                    signal.h,
                    [
                        is_sig_atomic_t_volatile=yes;
                        AC_MSG_RESULT([yes, volatile])
                    ],
                    [
                        is_sig_atomic_t_volatile=no;
                        AC_MSG_RESULT([yes, non volatile])
                    ])
  ],
  [
    AC_MSG_RESULT(no)
    AC_CHECK_TYPE(sig_atomic_t, int)
    is_sig_atomic_t_volatile=no
  ])
if test $is_sig_atomic_t_volatile = 'yes'
then
    AC_DEFINE(SIG_ATOMIC_VOLATILE_T, sig_atomic_t)
else
    AC_DEFINE(SIG_ATOMIC_VOLATILE_T, [volatile sig_atomic_t])
fi

AC_DECL_SYS_SIGLIST

dnl need this for DEC alpha
AC_CHECK_SIZEOF(long)

AC_TYPE_PID_T

AC_CHECK_FUNCS(fgetpos memmove setegid srand48 strerror)

AC_REPLACE_FUNCS(strcasecmp strdup)

AC_CHECK_FUNC(getopt)
if test $ac_cv_func_getopt = yes; then
	AC_CHECK_HEADERS(getopt.h)
fi

mutt_cv_snprintf=no
SNPRINTFOBJS=""
AC_CHECK_FUNC(snprintf, [AC_DEFINE(HAVE_SNPRINTF)], [mutt_cv_snprintf=yes])
AC_CHECK_FUNC(vsnprintf, [AC_DEFINE(HAVE_VSNPRINTF)], [mutt_cv_snprintf=yes])
if test $mutt_cv_snprintf = yes; then
	LIBOBJS="$LIBOBJS snprintf.o"
fi

dnl SCO uses chsize() instead of ftruncate()
AC_CHECK_FUNCS(ftruncate, break, [AC_CHECK_LIB(x, chsize)])

dnl SCO has strftime() in libintl
AC_CHECK_FUNCS(strftime, break, [AC_CHECK_LIB(intl, strftime)])

dnl AIX may not have fchdir()
AC_CHECK_FUNCS(fchdir, [AC_DEFINE(HAVE_FCHDIR)], [mutt_cv_fchdir=no])

AC_ARG_WITH(regex, [  --with-regex               Use the GNU regex library ],
	[mutt_cv_regex=yes],
	[AC_CHECK_FUNCS(regcomp, mutt_cv_regex=no, mutt_cv_regex=yes)])

if test $mutt_cv_regex = no ; then
AC_CACHE_CHECK([whether your system's regexp library is completely broken], 
	[mutt_cv_regex_broken],
	AC_TRY_RUN([
#include <unistd.h>
#include <regex.h>
main() { regex_t blah ; regmatch_t p; p.rm_eo = p.rm_eo; return regcomp(&blah, "foo.*bar", REG_NOSUB) || regexec (&blah, "foobar", 0, NULL, 0); }],
	mutt_cv_regex_broken=no, mutt_cv_regex_broken=yes, mutt_cv_regex_broken=yes))
	if test $mutt_cv_regex_broken = yes ; then
		echo "Using the included GNU regex instead." >&AC_FD_MSG
		mutt_cv_regex=yes
	fi
fi

if test $mutt_cv_regex = yes; then
	AC_DEFINE(USE_GNU_REGEX)
	LIBOBJS="$LIBOBJS regex.o"
fi


AC_ARG_WITH(homespool, [  --with-homespool[=FILE]    File in user's directory where new mail is spooled], with_homespool=${withval})
if test x$with_homespool != x; then
	if test $with_homespool = yes; then
		with_homespool=mailbox
	fi
	AC_DEFINE_UNQUOTED(MAILPATH, "$with_homespool")
	AC_DEFINE(HOMESPOOL)
	AC_DEFINE(USE_DOTLOCK)
	mutt_cv_setgid=no
else
	AC_ARG_WITH(mailpath, [  --with-mailpath=DIR        Directory where spool mailboxes are located],
		[mutt_cv_mailpath=$withval],
		[ AC_CACHE_CHECK(where new mail is stored, mutt_cv_mailpath,
			[mutt_cv_mailpath=no
			if test -d /var/mail; then
				mutt_cv_mailpath=/var/mail
			elif test -d /var/spool/mail; then
				mutt_cv_mailpath=/var/spool/mail
			elif test -d /usr/spool/mail; then
				mutt_cv_mailpath=/usr/spool/mail
			elif test -d /usr/mail; then
				mutt_cv_mailpath=/usr/mail
			fi])
		])
	if test $mutt_cv_mailpath = no; then
		AC_MSG_ERROR("Could not determine where new mail is stored.")
	fi
	AC_DEFINE_UNQUOTED(MAILPATH, "$mutt_cv_mailpath")

	AC_CACHE_CHECK(if $mutt_cv_mailpath is world writable, mutt_cv_worldwrite, [AC_TRY_RUN([#include <sys/types.h>
#include <sys/stat.h>

int main (int argc, char **argv)
{
	struct stat s;

	stat ("$mutt_cv_mailpath", &s);
	if (s.st_mode & S_IWOTH) exit (0);
	exit (1);
}], mutt_cv_worldwrite=yes, mutt_cv_worldwrite=no, mutt_cv_worldwrite=no)])

	mutt_cv_setgid=no
	if test $mutt_cv_worldwrite = yes; then
		AC_DEFINE(USE_DOTLOCK)
	else

		AC_CACHE_CHECK(if $mutt_cv_mailpath is group writable, mutt_cv_groupwrite, [AC_TRY_RUN([#include <sys/types.h>
#include <sys/stat.h>

int main (int argc, char **argv)
{
	struct stat s;

	stat ("$mutt_cv_mailpath", &s);
	if (s.st_mode & S_IWGRP) exit (0);
	exit (1);
}], mutt_cv_groupwrite=yes, mutt_cv_groupwrite=no, mutt_cv_groupwrite=no)])

		if test $mutt_cv_groupwrite = yes; then
			AC_DEFINE(USE_DOTLOCK)
			AC_DEFINE(USE_SETGID)
			mutt_cv_setgid=yes
		fi
	fi
fi

AC_ARG_ENABLE(external_dotlock, [  --enable-external-dotlock  Force use of an external dotlock program],
	[mutt_cv_external_dotlock="$enableval"])

if test "x$mutt_cv_setgid" = "xyes" || test "x$mutt_cv_fchdir" = "xno" \
	|| test "x$mutt_cv_external_dotlock" = "xyes"
then
	AC_DEFINE(DL_STANDALONE)
	DOTLOCK_TARGET="mutt_dotlock"
else
	MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS dotlock.o"
fi

AC_SUBST(DOTLOCK_TARGET)


AC_MSG_CHECKING(where to put architecture-dependent files)
AC_ARG_WITH(libdir, [  --with-libdir=PATH         Specify where to put arch dependent files],
	[mutt_cv_libdir=$withval],
	[mutt_cv_libdir="${mutt_cv_prefix}/lib/mutt"])
AC_MSG_RESULT($mutt_cv_libdir)

libdir=$mutt_cv_libdir
AC_SUBST(libdir)

AC_MSG_CHECKING(where to put architecture-independent data files)
AC_ARG_WITH(sharedir, [  --with-sharedir=PATH       Specify where to put arch independent files],
	[mutt_cv_sharedir=$withval],
	[if test -d ${mutt_cv_prefix}/share; then
		mutt_cv_sharedir="${mutt_cv_prefix}/share/mutt"
	else
		mutt_cv_sharedir="$libdir"
	fi])
AC_MSG_RESULT($mutt_cv_sharedir)

sharedir=$mutt_cv_sharedir
AC_SUBST(sharedir)

AC_ARG_WITH(iconv, [  --with-iconv=DIR           Where libiconv is installed ],
       [mutt_cv_iconv=$withval
       if test "$mutt_cv_iconv" != yes -a \
		"$mutt_cv_iconv" != no -a \
		"$mutt_cv_iconv" != /usr; then
               CPPFLAGS="-I${mutt_cv_iconv}/include $CPPFLAGS"
               LDFLAGS="-L${mutt_cv_iconv}/lib $LDFLAGS"
       fi])

LIBICONV=

if test "$mutt_cv_iconv" != no; then

AC_CACHE_CHECK(for iconv, mutt_cv_func_iconv,
    [ mutt_cv_func_iconv=no
      mutt_cv_lib_iconv=no
      AC_TRY_LINK([#include <stdlib.h>
#include <iconv.h>],
	[iconv_t cd = iconv_open("",""); iconv(cd,NULL,NULL,NULL,NULL); iconv_close(cd);],
	mutt_cv_func_iconv=yes)
      if test "$mutt_cv_func_iconv" = no; then
	mutt_save_LIBS="$LIBS"
	LIBS="$LIBS -liconv"
	AC_TRY_LINK([#include <stdlib.h>
#include <iconv.h>],
	  [iconv_t cd = iconv_open("",""); iconv(cd,NULL,NULL,NULL,NULL); iconv_close(cd);],
	  mutt_cv_lib_iconv=yes
	  mutt_cv_func_iconv=yes)
	LIBS="$mutt_save_LIBS"
      fi
    ])
if test "$mutt_cv_func_iconv" = no; then
  AC_MSG_ERROR(Unable to find iconv library)
fi
if test "$mutt_cv_lib_iconv" = yes; then
  LIBICONV="-liconv"
fi
AC_DEFINE(HAVE_ICONV)

AC_SUBST(LIBICONV)

dnl (1) Some implementations of iconv won't convert from UTF-8 to UTF-8.
dnl (2) In glibc-2.1.2 and earlier there is a bug that messes up ob and
dnl     obl when args 2 and 3 are 0 (fixed in glibc-2.1.3).
AC_CACHE_CHECK([whether this iconv is good enough], mutt_cv_iconv_good,
	mutt_save_LIBS="$LIBS"
	LIBS="$LIBS $LIBICONV"
	AC_TRY_RUN([
#include <iconv.h>
int main()
{
  iconv_t cd;
changequote(, )dnl
  char buf[4];
changequote([, ])dnl
  char *ob;
  size_t obl;
  ob = buf, obl = sizeof(buf);
  return ((cd = iconv_open("UTF-8", "UTF-8")) != (iconv_t)(-1) &&
	  (iconv(cd, 0, 0, &ob, &obl) ||
	   !(ob == buf && obl == sizeof(buf)) ||
	   iconv_close(cd)));
}
		],
		mutt_cv_iconv_good=yes,
		mutt_cv_iconv_good=no,
		mutt_cv_iconv_good=yes)
	LIBS="$mutt_save_LIBS")
if test "$mutt_cv_iconv_good" = no; then
  AC_MSG_ERROR(Try using libiconv instead)
fi

dnl This is to detect implementations such as the one in glibc-2.1,
dnl which always convert exactly but return the number of characters
dnl converted instead of the number converted inexactly.
AC_CACHE_CHECK([whether iconv is non-transcribing], mutt_cv_iconv_nontrans,
	mutt_save_LIBS="$LIBS"
	LIBS="$LIBS $LIBICONV"
	AC_TRY_RUN([
#include <iconv.h>
#include <string.h>
int main()
{
  iconv_t cd;
  const char *ib;
  char *ob;
  size_t ibl, obl;
  const char *s = "\304\211";
changequote(, )dnl
  char t[3];
changequote([, ])dnl
  ib = s, ibl = 2, ob = t, obl = 3;
  return ((cd = iconv_open("UTF-8", "UTF-8")) == (iconv_t)(-1) ||
	  iconv(cd, &ib, &ibl, &ob, &obl));
}
		],
		mutt_cv_iconv_nontrans=no,
		mutt_cv_iconv_nontrans=yes,
		mutt_cv_iconv_nontrans=no)
	LIBS="$mutt_save_LIBS")
if test "$mutt_cv_iconv_nontrans" = yes; then
  AC_DEFINE(ICONV_NONTRANS, 1)
else
  AC_DEFINE(ICONV_NONTRANS, 0)
fi

else # "$mutt_cv_iconv" != no
  AC_DEFINE(ICONV_NONTRANS, 0)
fi

AC_MSG_CHECKING(where to put the documentation)
AC_ARG_WITH(docdir, [  --with-docdir=PATH         Specify where to put the documentation],
	[mutt_cv_docdir=$withval],
	[mutt_cv_docdir="$mutt_cv_prefix/doc/mutt"])
AC_MSG_RESULT($mutt_cv_docdir)

docdir=$mutt_cv_docdir
AC_SUBST(docdir)

if test x$mutt_cv_setgid = xyes; then
	DOTLOCK_GROUP='mail'
	DOTLOCK_PERMISSION=2755
else
	DOTLOCK_GROUP=''
	DOTLOCK_PERMISSION=755
fi
AC_SUBST(DOTLOCK_GROUP)
AC_SUBST(DOTLOCK_PERMISSION)

AC_ARG_WITH(domain, [  --with-domain=DOMAIN       Specify your DNS domain name ],
	[if test $withval != yes; then
		AC_DEFINE_UNQUOTED(DOMAIN, "$withval")
	fi])

need_socket="no"

dnl -- socket dependencies --

AC_ARG_ENABLE(pop,  [  --enable-pop               Enable POP3 support],
[	if test x$enableval = xyes ; then
		AC_DEFINE(USE_POP)
		MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS pop.o pop_lib.o pop_auth.o"
		need_socket="yes"
		need_md5="yes"
	fi
])

AC_ARG_ENABLE(imap, [  --enable-imap              Enable IMAP support],
[	if test x$enableval = xyes ; then
		AC_DEFINE(USE_IMAP)
		LIBIMAP="-Limap -limap"
		LIBIMAPDEPS="\$(top_srcdir)/imap/imap.h imap/libimap.a"
		need_imap="yes"
		need_socket="yes"
		need_md5="yes"
	fi
])
AM_CONDITIONAL(BUILD_IMAP, test x$need_imap = xyes)

dnl -- end socket dependencies --

if test "$need_socket" = "yes"
then
	AC_CHECK_FUNC(gethostent, , AC_CHECK_LIB(nsl, gethostent))
	AC_CHECK_FUNC(setsockopt, , AC_CHECK_LIB(socket, setsockopt))
	AC_CHECK_FUNCS(getaddrinfo)
	AC_DEFINE(USE_SOCKET)
	MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS account.o mutt_socket.o"
fi

dnl -- imap dependencies --

AC_ARG_WITH(gss,    [    --with-gss[=DIR]         Compile in GSSAPI authentication for IMAP],
	[
	if test "$need_imap" != "yes"
        then
          AC_MSG_ERROR([GSS support is only for IMAP, but IMAP is not enabled])
        fi

	if test "$with_gss" != "no"
	then
	  if test "$with_gss" != "yes"
	  then
	    CPPFLAGS="$CPPFLAGS -I$with_gss/include"
	    LDFLAGS="$LDFLAGS -L$with_gss/lib"
	  fi

  	  saved_LIBS="$LIBS"
          gss_type="none"

          dnl New MIT kerberos V support
          AC_CHECK_LIB(gssapi_krb5, gss_init_sec_context, [
            gss_type="MIT",
            MUTTLIBS="$MUTTLIBS -lgssapi_krb5 -lkrb5 -lk5crypto -lcom_err"
            ],, -lkrb5 -lk5crypto -lcom_err)

          dnl Heimdal kerberos V support
          if test x$gss_type = xnone
          then
            AC_CHECK_LIB(gssapi, gss_init_sec_context, [
              gss_type="Heimdal",
              MUTTLIBS="$MUTTLIBS -lgssapi -lkrb5 -ldes -lasn1 -lroken"
              MUTTLIBS="$MUTTLIBS -lcrypt -lcom_err"
              AC_DEFINE(HAVE_HEIMDAL)
              ],, -lkrb5 -ldes -lasn1 -lroken -lcrypt -lcom_err)
          fi

	  dnl Old MIT Kerberos V
	  dnl Note: older krb5 distributions use -lcrypto instead of
	  dnl -lk5crypto, which collides with OpenSSL.  One way of dealing
	  dnl with that is to extract all objects from krb5's libcrypto
	  dnl and from openssl's libcrypto into the same directory, then
	  dnl to create a new libcrypto from these.
          if test x$gss_type = xnone
          then
            AC_CHECK_LIB(gssapi_krb5, g_order_init, [
              gss_type="OldMIT",
              MUTTLIBS="$MUTTLIBS -lgssapi_krb5 -lkrb5 -lcrypto -lcom_err"
              ],, -lkrb5 -lcrypto -lcom_err)
          fi

          if test x$gss_type = xnone
          then
            AC_CACHE_SAVE
            AC_MSG_ERROR([GSSAPI support not found])
          fi

  	  LIBS="$saved_LIBS"
  	  AC_DEFINE(USE_GSS)
            need_gss="yes"
  	fi

])
AM_CONDITIONAL(USE_GSS, test x$need_gss = xyes)

AC_ARG_WITH(ssl, [    --with-ssl[=PFX]         Compile in SSL socket support for POP/IMAP],
[	if test "$with_ssl" != "no"
	then
	  if test "$need_socket" != "yes"; then
	   AC_MSG_ERROR([SSL support is only useful with POP or IMAP support])
	  fi

	  if test "$with_ssl" != "yes"
	  then
	   LDFLAGS="$LDFLAGS -L$withval/lib"
	   CPPFLAGS="$CPPFLAGS -I$withval/include"
	  fi	
	  saved_LIBS="$LIBS"

	  AC_CHECK_LIB(crypto, X509_new,, AC_MSG_ERROR([Unable to find SSL library]))
	  AC_CHECK_LIB(ssl, SSL_new,, AC_MSG_ERROR([Unable to find SSL library]), -lcrypto)

	  AC_CHECK_FUNCS(RAND_status RAND_egd)

	  AC_DEFINE(USE_SSL)
	  LIBS="$saved_LIBS"
	  MUTTLIBS="$MUTTLIBS -lssl -lcrypto"
	  MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS mutt_ssl.o"
	  need_ssl=yes

          dnl Some systems avoid certain patent-encumbered SSL routines
          AC_CHECK_HEADER(openssl/rc5.h,,AC_DEFINE(NO_RC5))
          AC_CHECK_HEADER(openssl/idea.h,,AC_DEFINE(NO_IDEA))
          AC_CHECK_HEADER(openssl/rsa.h,,AC_DEFINE(NO_RSA))
	fi
])
AM_CONDITIONAL(USE_SSL, test x$need_ssl = xyes)

dnl SSL support via NSS
AC_ARG_WITH(nss, [    --with-nss[=PFX]	Compile in SSL socket support for POP/IMAP via NSS],
[	if test "$with_nss" != no
	then
	  if test "$need_socket" != "yes"; then
	   AC_MSG_ERROR([SSL support is only useful with POP or IMAP support])
	  fi

	  if test "$with_nss" != "yes"
	  then
	   LDFLAGS="$LDFLAGS -L$withval/lib"
	   CPPFLAGS="$CPPFLAGS -I$withval/include -I$withval/public/security"
	  fi	

	  AC_DEFINE(USE_NSS)
	  MUTTLIBS="$MUTTLIBS -lssl -lnss -lcertdb -lcerthi -lcryptohi"
	  MUTTLIBS="$MUTTLIBS -lpk11wrap -lsoftoken -lsecutil -ldbm -lplds4 -lplc4 -lfreebl"
	  MUTTLIBS="$MUTTLIBS -lnspr4"

	  MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS mutt_ssl_nss.o"
	  need_ssl=yes
	fi
])

dnl -- end imap dependencies --

AC_ARG_WITH(sasl, [  --with-sasl[=DIR]          Use Cyrus SASL library for POP/IMAP authentication],
	[
	if test "$need_socket" != "yes"
	then
	  AC_MSG_ERROR([SASL support is only useful with POP or IMAP support])
	fi

	if test "$with_sasl" != "no"
	then
	  if test "$with_sasl" != "yes"
	  then
	    CPPFLAGS="$CPPFLAGS -I$with_sasl/include"
	    LDFLAGS="$LDFLAGS -L$with_sasl/lib"
	  fi

	  saved_LIBS="$LIBS"

	  AC_CHECK_LIB(sasl, sasl_client_init,,
	    AC_MSG_ERROR([could not find libsasl]),)

	  MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS mutt_sasl.o"
	  MUTTLIBS="$MUTTLIBS -lsasl"
	  LIBS="$saved_LIBS"
	  AC_DEFINE(USE_SASL)
	  need_sasl=yes
	  need_md5=no
	fi
	])
AM_CONDITIONAL(USE_SASL, test x$need_sasl = xyes)

if test "$need_md5" = "yes"
then
	MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS md5c.o"
fi

dnl -- end socket --

AC_ARG_ENABLE(debug, [  --enable-debug             Enable debugging support],
	[ if test x$enableval = xyes ; then
		AC_DEFINE(DEBUG)
	  fi
	 ])

AC_ARG_ENABLE(flock, [  --enable-flock             Use flock() to lock files],
	[if test $enableval = yes; then
		AC_DEFINE(USE_FLOCK)
	fi])

mutt_cv_fcntl=yes
AC_ARG_ENABLE(fcntl, [  --disable-fcntl            Do NOT use fcntl() to lock files ],
	[if test $enableval = no; then mutt_cv_fcntl=no; fi])

if test $mutt_cv_fcntl = yes; then
	AC_DEFINE(USE_FCNTL)
fi

mutt_cv_warnings=yes
AC_ARG_ENABLE(warnings, [  --disable-warnings         turn off compiler warnings (not recommended)],
[if test $enableval = no; then
	mutt_cv_warnings=no
fi])

if test x$GCC = xyes -a $mutt_cv_warnings = yes; then
	CFLAGS="-Wall -pedantic $CFLAGS"
fi

AC_ARG_ENABLE(nfs-fix, [  --enable-nfs-fix           Work around an NFS with broken attributes caching ],
	[if test x$enableval = xyes; then
                AC_DEFINE(NFS_ATTRIBUTE_HACK)
        fi])

AC_ARG_ENABLE(buffy-size, [  --enable-buffy-size        Use file size attribute instead of access time ],
	[if test x$enableval = xyes; then
                AC_DEFINE(BUFFY_SIZE)
        fi])

AC_ARG_ENABLE(mailtool, [  --enable-mailtool          Enable Sun mailtool attachments support ],
	[if test x$enableval = xyes; then
                AC_DEFINE(SUN_ATTACHMENT)
        fi])

AC_ARG_ENABLE(locales-fix, [  --enable-locales-fix       The result of isprint() is unreliable ],
	[if test x$enableval = xyes; then
                AC_DEFINE(LOCALES_HACK)
        fi])

AC_ARG_WITH(exec-shell, [  --with-exec-shell=SHELL    Specify alternate shell (ONLY if /bin/sh is broken)],
	[if test $withval != yes; then
		AC_DEFINE_UNQUOTED(EXECSHELL, "$withval")
	fi])

AC_ARG_ENABLE(exact-address, [  --enable-exact-address     Enable regeneration of email addresses],
	[if test $enableval = yes; then
		AC_DEFINE(EXACT_ADDRESS)
	fi])

AC_SUBST(MUTTLIBS)
AC_SUBST(MUTT_LIB_OBJECTS)
AC_SUBST(LIBIMAP)
AC_SUBST(LIBIMAPDEPS)

MUTT_AM_GNU_GETTEXT
CPPFLAGS="$CPPFLAGS -I\$(top_srcdir)/intl"

MUTTLOCALEDIR=$mutt_cv_prefix/$DATADIRNAME/locale
AC_SUBST(MUTTLOCALEDIR)
AC_DEFINE_UNQUOTED(MUTTLOCALEDIR, "$MUTTLOCALEDIR")

AC_CHECK_HEADERS(wchar.h)

AC_CACHE_CHECK([for wchar_t], mutt_cv_wchar_t,
	AC_TRY_COMPILE([
#include <stddef.h>
#include <stdlib.h>
#ifdef HAVE_WCHAR_H
#include <wchar.h>
#endif
		],
		[ wchar_t wc; return 0; ],
		mutt_cv_wchar_t=yes,
		mutt_cv_wchar_t=no))

if test "$mutt_cv_wchar_t" = no; then
	AC_DEFINE(wchar_t, int)
fi

AC_CACHE_CHECK([for wint_t], mutt_cv_wint_t,
	AC_TRY_COMPILE([
#include <stddef.h>
#include <stdlib.h>
#ifdef HAVE_WCHAR_H
#include <wchar.h>
#endif
		],
		[ wint_t wc; return 0; ],
		mutt_cv_wint_t=yes,
		mutt_cv_wint_t=no))

if test "$mutt_cv_wint_t" = no; then
	AC_DEFINE(wint_t, int)
fi

AC_CHECK_HEADERS(wctype.h)
AC_CHECK_FUNCS(iswalnum iswalpha  iswcntrl iswdigit)
AC_CHECK_FUNCS(iswgraph iswlower iswprint iswpunct iswspace iswupper)
AC_CHECK_FUNCS(iswxdigit towupper towlower)

AC_CACHE_CHECK([for mbstate_t], mutt_cv_mbstate_t,
	AC_TRY_COMPILE([
#include <stddef.h>
#include <stdlib.h>
#ifdef HAVE_WCHAR_H
#include <wchar.h>
#endif
		],
		[ mbstate_t s; return 0; ],
		mutt_cv_mbstate_t=yes,
		mutt_cv_mbstate_t=no))

if test "$mutt_cv_mbstate_t" = no; then
	AC_DEFINE(mbstate_t, int)
fi

wc_funcs=maybe
AC_ARG_WITH(wc-funcs, [  --without-wc-funcs         Do not use the system's wchar_t functions],
	wc_funcs=$withval)

if test "$wc_funcs" != yes -a "$wc_funcs" != no; then
	AC_CACHE_CHECK([for wchar_t functions], mutt_cv_wc_funcs,
		mutt_cv_wc_funcs=no
		AC_TRY_LINK([
#define _XOPEN_SOURCE 1
#include <stddef.h>
#include <stdlib.h>
#ifdef HAVE_WCTYPE_H
#include <wctype.h>
#endif
#ifdef HAVE_WCHAR_H
#include <wchar.h>
#endif],
			[mbrtowc(0, 0, 0, 0); wctomb(0, 0); wcwidth(0);
	iswprint(0); iswspace(0); towlower(0); towupper(0); iswalnum(0)],
			mutt_cv_wc_funcs=yes))
	wc_funcs=$mutt_cv_wc_funcs
fi

if test $wc_funcs = yes; then
	AC_DEFINE(HAVE_WC_FUNCS)
fi

AC_CACHE_CHECK([for nl_langinfo and CODESET], mutt_cv_langinfo_codeset,
  [AC_TRY_LINK([#include <langinfo.h>],
    [char* cs = nl_langinfo(CODESET