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)

ifdef([AC_LIBOBJ], , [define([AC_LIBOBJ], [LIB[]OBJS="$LIBOBJS $1.o"])])

ALL_LINGUAS="de ru it es uk fr pl nl cs id sk ko el zh_TW zh_CN pt_BR eo gl sv da lt tr ja hu et ca bg"

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)

# The following templates should be used with newer automakes
# instead of acconfig.h
#
#AH_TEMPLATE([sig_atomic_t],
#            [/* Define to `int' if <signal.h> doesn't define.])
#AH_TEMPLATE([HAVE_START_COLOR],
#            [Define if you have start_color, as a function or macro.])
#AH_TEMPLATE([HAVE_TYPEAHEAD],
#            [Define if you have typeahead, as a function or macro.])
#AH_TEMPLATE([HAVE_BKGDSET],
#            [Define if you have bkgdset, as a function or macro.])
#AH_TEMPLATE([HAVE_CURS_SET],
#            [Define if you have curs_set, as a function or macro.])
#AH_TEMPLATE([HAVE_META],
#            [Define if you have meta, as a function or macro.])
#AH_TEMPLATE([HAVE_USE_DEFAULT_COLORS],
#            [Define if you have use_default_colors, as a function or macro.])
#AH_TEMPLATE([HAVE_RESIZETERM],
#            [Define if you have resizeterm, as a function or macro.])
#AH_TEMPLATE([SIG_ATOMIC_VOLATILE_T],
#            [Some systems declare sig_atomic_t as volatile, some others -- no.
#             This define will have value `sig_atomic_t' or
#             `volatile sig_atomic_t' accordingly.])
#AH_TEMPLATE([ICONV_NONTRANS],
#            [Define as 1 if iconv() only converts exactly and we should treat
#             all return values other than (size_t)(-1) as equivalent.])


ac_aux_path_sendmail=/usr/sbin:/usr/lib
AC_PATH_PROG(SENDMAIL, sendmail, /usr/sbin/sendmail, $PATH:$ac_aux_path_sendmail)
AC_DEFINE_UNQUOTED(SENDMAIL,"$ac_cv_path_SENDMAIL",[ Where to find sendmail on your system. ])

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(CRYPT_BACKEND_CLASSIC_PGP,1,
                    [ Define if you want classic PGP support. ])
                PGPAUX_TARGET="pgpring pgpewrap"
                MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS pgp.o pgpinvoke.o pgpkey.o pgplib.o gnupgparse.o pgpmicalg.o pgppacket.o"
        fi

 	AC_ARG_ENABLE(smime, [  --disable-smime            Disable SMIME support],
 	[	if test x$enableval = xno ; then
 			have_smime=no
 		fi
 	])
 
 	if test x$have_smime != xno ; then
 		AC_DEFINE(CRYPT_BACKEND_CLASSIC_SMIME,1,
                  [ Define if you want clasic S/MIME support. ])
 		MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS smime.o "
		SMIMEAUX_TARGET="smime_keys"
 	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",
                         [ Where to find mixmaster on your system. ])
                ])

fi
# We now require all OPS
OPS="$OPS \$(srcdir)/OPS.PGP \$(srcdir)/OPS.SMIME \$(srcdir)/OPS.CRYPT "
AC_SUBST(OPS)


AC_SUBST(PGPAUX_TARGET)
AC_SUBST(SMIMEAUX_TARGET)

AC_DEFINE_UNQUOTED(SUBVERSION,"$SUBVERSION",[ Is this the international version? ])
AC_SUBST(SUBVERSION)

AC_PATH_PROG(ISPELL, ispell, no)
if test $ISPELL != no; then
        AC_DEFINE_UNQUOTED(ISPELL,"$ISPELL",[ Where to find ispell on your system. ])
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,1,
                [ Define if you compile with SLang instead of curses/ncurses. ])
        AC_DEFINE(HAVE_COLOR,1,[ Define if your curses library supports 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_FUNC(initscr,,[
	cf_ncurses="ncurses"
	for lib in ncurses ncursesw
	do
		AC_CHECK_LIB($lib, waddnwstr, [cf_ncurses="$lib"; break])
	done
        AC_CHECK_LIB($cf_ncurses, initscr,
                [MUTTLIBS="$MUTTLIBS -l$cf_ncurses"
                if test x$mutt_cv_curses = x/usr -a -d /usr/include/ncurses; then
                        CPPFLAGS="$CPPFLAGS -I/usr/include/ncurses"
                fi
		
                if test "$cf_ncurses" = ncursesw; then
			AC_CHECK_HEADERS(ncursesw/ncurses.h,[cf_cv_ncurses_header="ncursesw/ncurses.h"])
		else
			AC_CHECK_HEADERS(ncurses.h,[cf_cv_ncurses_header="ncurses.h"])
		fi],

                [CF_CURSES_LIBS])
		])

        old_LIBS="$LIBS"
        LIBS="$LIBS $MUTTLIBS"
        CF_CHECK_FUNCDECLS([#include <${cf_cv_ncurses_header-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,1,[ Define if your curses library supports 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,
  [
    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 For MD5 and SHA1 on 64-bit systems
AC_C_BIGENDIAN
AC_CHECK_HEADERS(inttypes.h stdint.h)
dnl This is the method autoconf-2.50's new AC_CHECK_TYPE macro uses.
dnl We need to be backwards compatible to autoconf 2.13, though. -lh
AC_MSG_CHECKING(for uint32_t)
AC_TRY_COMPILE([
#include <sys/types.h>
#if HAVE_INTTYPES_H
#include <inttypes.h>
#else
#if HAVE_STDINT_H
#include <stdint.h>
#endif
#endif],
[if ((uint32_t *) 0)
  return 0;
if (sizeof (uint32_t))
  return 0;
],[
    AC_DEFINE(HAVE_UINT32_T,1,[ Define if you have the uint32_t type. ])
    AC_MSG_RESULT(yes)
  ], AC_MSG_RESULT(no)
)
AC_CHECK_SIZEOF(int)
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_FUNCS(snprintf, , [mutt_cv_snprintf=yes])
AC_CHECK_FUNCS(vsnprintf, , [mutt_cv_snprintf=yes])
if test $mutt_cv_snprintf = yes; then
        AC_LIBOBJ(snprintf)
fi

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

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

dnl AIX may not have fchdir()
AC_CHECK_FUNCS(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,1,[ Define if you want to use the included regex.c. ])
        AC_LIBOBJ(regex)
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",[ Where new mail is spooled. ])
        AC_DEFINE(HOMESPOOL,1,
          [Is mail spooled to the user's home directory?  If defined,
           MAILPATH should be set to the filename of the spool mailbox
           relative the the home directory.
           use: configure --with-homespool=FILE])
        AC_DEFINE(USE_DOTLOCK,1,[ Define to use dotlocking for mailboxes. ])
        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",[ Where new mail is spooled. ])

        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,1,[ Define to use dotlocking for mailboxes. ])
        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,1,[ Define to use dotlocking for mailboxes. ])
                        AC_DEFINE(USE_SETGID,1,[ Define if mutt should run setgid "mail". ])
                        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,1,[ Define if you want to use an external dotlocking program. ])
        DOTLOCK_TARGET="mutt_dotlock"
else
        MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS dotlock.o"
fi

AC_SUBST(DOTLOCK_TARGET)


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",[ Define your domain name. ])
        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,1,[ Define if you want support for the POP3 protocol. ])
                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,1,[ Define if you want support for the IMAP protocol. ])
                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_MSG_CHECKING([for socklen_t])
        AC_EGREP_HEADER(socklen_t, sys/socket.h, AC_MSG_RESULT([yes]),
                AC_MSG_RESULT([no])
                AC_DEFINE(socklen_t,int,
                        [ Define to 'int' if <sys/socket.h> doesn't have it. ]))
        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,1,
                [ Include code for socket support. Set automatically if you enable POP3 or IMAP ])
        MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS account.o mutt_socket.o mutt_tunnel.o"
fi

dnl -- imap dependencies --

AC_ARG_WITH(gss, [    --with-gss[=PFX]         Compile in GSSAPI authentication for IMAP], 
    gss_prefix="$withval", gss_prefix="no")
if test "$gss_prefix" != "no"
then
  if test "$need_imap" = "yes"
  then
    MUTT_AM_PATH_GSSAPI(gss_prefix)
    AC_MSG_CHECKING(GSSAPI implementation)
    AC_MSG_RESULT($GSSAPI_IMPL)
    if test "$GSSAPI_IMPL" = "none"
    then
      AC_CACHE_SAVE
      AC_MSG_RESULT([GSSAPI libraries not found])
    fi
    if test "$GSSAPI_IMPL" = "Heimdal"
    then
      AC_DEFINE(HAVE_HEIMDAL,1,[ Define if your GSSAPI implementation is Heimdal ])
    fi
    CPPFLAGS="$CPPFLAGS $GSSAPI_CFLAGS"
    MUTTLIBS="$MUTTLIBS $GSSAPI_LIBS"
    AC_DEFINE(USE_GSS,1,[ Define if you have GSSAPI libraries available ])
    need_gss="yes"
  else
    AC_MSG_WARN([GSS was requested but IMAP is not enabled])
  fi
fi
AM_CONDITIONAL(USE_GSS, test x$need_gss = xyes)

dnl -- end imap dependencies --

AC_ARG_WITH(ssl, [  --with-ssl[=PFX]           Compile in SSL 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,1,[ Define if you want support for SSL. ])
          LIBS="$saved_LIBS"
          MUTTLIBS="$MUTTLIBS -lssl -lcrypto"
          MUTT_LIB_OBJECTS="$MUTT_LIB_OBJECTS mutt_ssl.o"
          need_ssl=yes

        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 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,1,[ Define if you want support for SSL via the NSS library. ])
          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
])

AC_ARG_WITH(sasl, [  --with-sasl[=PFX]          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,1,
                  [ Define if want to use the Cyrus SASL library for POP/IMAP authentication. ])
          need_sasl=yes
        fi
        ])
AM_CONDITIONAL(USE_SASL, test x$need_sasl = xyes)

AC_ARG_WITH(sasl2, [  --with-sasl2[=PFX]         Use Cyrus SASL libra