[openssh.git] / configure.in

AC_INIT(ssh.c)

AC_CONFIG_HEADER(config.h)
AC_CANONICAL_HOST

# C Compiler features
if test "$GCC" = "yes"; then CFLAGS="$CFLAGS -Wall"; fi
AC_C_INLINE

# Checks for programs.
AC_PROG_CC
AC_PROG_CPP
AC_PROG_RANLIB
AC_PROG_INSTALL
AC_CHECK_PROG(AR, ar, ar)
AC_PATH_PROG(PERL, perl)
AC_SUBST(PERL)

# Check for some target-specific stuff
case "$host" in
*-*-aix*)
	AFS_LIBS="-lld"
	AC_DEFINE(BROKEN_GETADDRINFO)
	;;
*-*-hpux10*)
	if test -z "$GCC"; then
		CFLAGS="$CFLAGS -Aa"
	fi
	CFLAGS="$CFLAGS -D_HPUX_SOURCE"
	AC_DEFINE(IPADDR_IN_DISPLAY)
	AC_DEFINE(USE_UTMPX)
	AC_MSG_CHECKING(for HPUX trusted system password database)
	if test -f /tcb/files/auth/system/default; then
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_HPUX_TRUSTED_SYSTEM_PW)
		LIBS="$LIBS -lsec"
		AC_MSG_WARN([This configuration is untested])
	else
		AC_MSG_RESULT(no)
		AC_DEFINE(DISABLE_SHADOW)
	fi
	MANTYPE='$(CATMAN)'
	mansubdir=cat
	;;
*-*-irix5*)
	MANTYPE='$(CATMAN)'
	no_libsocket=1
	no_libnsl=1
	;;
*-*-irix6*)
	MANTYPE='$(CATMAN)'
	AC_MSG_WARN([*** Irix 6.x is not tested, please report you experiences *** ])
	no_libsocket=1
	no_libnsl=1
	;;
*-*-linux*)
	no_dev_ptmx=1
	;;
*-*-netbsd*)
	need_dash_r=1
	;;
*-*-solaris*)
	need_dash_r=1
	LDFLAGS="-L/usr/ucblib"
	AC_DEFINE(USE_UTMPX)
	;;
*-*-sysv*)
	AC_DEFINE(USE_UTMPX)
	MANTYPE='$(CATMAN)'
	mansubdir=cat
	LIBS="$LIBS -lgen -lsocket"
	;;
esac

# Checks for libraries.
AC_CHECK_LIB(z, deflate, ,AC_MSG_ERROR([*** zlib missing - please install first ***]))
AC_CHECK_LIB(util, login, AC_DEFINE(HAVE_LIBUTIL_LOGIN) LIBS="$LIBS -lutil")

if test -z "$no_libsocket" ; then
	AC_CHECK_LIB(nsl, yp_match, , )
fi
if test -z "$no_libnsl" ; then
	AC_CHECK_LIB(socket, main, , )
fi

# Checks for header files.
AC_CHECK_HEADERS(bstring.h endian.h lastlog.h login.h maillock.h netdb.h netgroup.h paths.h poll.h pty.h shadow.h security/pam_appl.h sys/bitypes.h sys/bsdtty.h sys/cdefs.h sys/poll.h sys/select.h sys/stropts.h sys/sysmacros.h sys/time.h sys/ttcompat.h stddef.h util.h utmp.h utmpx.h)

# Checks for library functions.
AC_CHECK_FUNCS(arc4random bindresvport_af freeaddrinfo gai_strerror getaddrinfo getnameinfo innetgr md5_crypt mkdtemp openpty rresvport_af setenv seteuid setlogin setproctitle setreuid snprintf strlcat strlcpy updwtmpx vsnprintf _getpty)

AC_CHECK_FUNC(login, 
	[AC_DEFINE(HAVE_LOGIN)],
	[AC_CHECK_LIB(bsd, login, [LIBS="$LIBS -lbsd"; AC_DEFINE(HAVE_LOGIN)])]
)

AC_CHECK_FUNC(daemon, 
	[AC_DEFINE(HAVE_DAEMON)],
	[AC_CHECK_LIB(bsd, daemon, [LIBS="$LIBS -lbsd"; AC_DEFINE(HAVE_DAEMON)])]
)

AC_CHECK_FUNC(getpagesize, 
	[AC_DEFINE(HAVE_GETPAGESIZE)],
	[AC_CHECK_LIB(ucb, getpagesize, [LIBS="$LIBS -lucb"; AC_DEFINE(HAVE_GETPAGESIZE)])]
)

AC_ARG_WITH(pam,
	[  --without-pam           Disable PAM support ],
	[
		if test "x$withval" = "xno" ; then
			no_pam=1
			AC_DEFINE(DISABLE_PAM)
		fi
	]
)
if test -z "$no_pam" -a "x$ac_cv_header_security_pam_appl_h" = "xyes" ; then
	AC_CHECK_LIB(dl, dlopen, , )
	LIBS="$LIBS -lpam"

	# Check PAM strerror arguments (old PAM)
	AC_MSG_CHECKING([whether pam_strerror takes only one argument])
	AC_TRY_COMPILE(
		[
			#include <stdlib.h>
			#include <security/pam_appl.h>
		], 
		[(void)pam_strerror((pam_handle_t *)NULL, -1);], 
		[AC_MSG_RESULT(no)],
		[
			AC_DEFINE(HAVE_OLD_PAM)
			AC_MSG_RESULT(yes)
		]
	) 
fi

# The big search for OpenSSL
AC_ARG_WITH(ssl-dir,
	[  --with-ssl-dir=PATH     Specify path to OpenSSL installation ],
	[
		if test "x$withval" != "$xno" ; then
			tryssldir=$withval
		fi
	]
)

saved_LIBS="$LIBS"
saved_CFLAGS="$CFLAGS"
if test "x$prefix" != "xNONE" ; then
	tryssldir="$tryssldir $prefix"
fi
AC_MSG_CHECKING([for OpenSSL/SSLeay directory])
for ssldir in "" $tryssldir /usr /usr/local/openssl /usr/lib/openssl /usr/local/ssl /usr/lib/ssl /usr/local /usr/pkg /opt /opt/openssl ; do
	if test ! -z "$ssldir" ; then
		LIBS="$saved_LIBS -L$ssldir"
		CFLAGS="$CFLAGS -I$ssldir/include"
		if test "x$need_dash_r" = "x1" ; then
			LIBS="$LIBS -R$ssldir/lib"
		fi
	fi
	LIBS="$LIBS -lcrypto"

	AC_TRY_RUN(
		[
			#include <openssl/rsa.h>
			#include <openssl/bn.h>
			#include <openssl/sha.h>
			int main(void) 
			{RSA *key; char seed[2048];memset(seed, 0, sizeof(seed));
			RAND_seed(seed, sizeof(seed));key=RSA_generate_key(32,3,NULL,NULL);
			return(key==NULL);}
		],
		[
			AC_DEFINE(HAVE_OPENSSL)
			found_crypto=1
			break;
		], []
	)
	AC_TRY_RUN(
		[
			#include <ssl/rsa.h>
			#include <ssl/bn.h>
			#include <ssl/sha.h>
			int main(void) 
			{RSA *key; char seed[2048];memset(seed, 0, sizeof(seed));
			RAND_seed(seed, sizeof(seed));key=RSA_generate_key(32,3,NULL,NULL);
			return(key==NULL);}
		],
		[
			AC_DEFINE(HAVE_SSL)
			found_crypto=1
			break;
		], []
	)
done

if test -z "$found_crypto" ; then
	AC_MSG_ERROR([Could not find working SSLeay / OpenSSL libraries, please install])	
fi
if test -z "$ssldir" ; then
	ssldir="(system)"
else
	CFLAGS="$CFLAGS -I$ssldir/include"
	LDFLAGS="$LDFLAGS -L$ssldir/lib"
	if test "x$need_dash_r" = "x1" ; then
		LDFLAGS="$LDFLAGS -R$ssldir"
	fi
fi
LIBS="$saved_LIBS -lcrypto"
AC_MSG_RESULT($ssldir)

# Checks for data types
AC_CHECK_SIZEOF(char, 1)
AC_CHECK_SIZEOF(short int, 2)
AC_CHECK_SIZEOF(int, 4)
AC_CHECK_SIZEOF(long int, 4)
AC_CHECK_SIZEOF(long long int, 8)

# More checks for data types
AC_MSG_CHECKING([for intXX_t types])
AC_TRY_COMPILE(
	[#include <sys/types.h>], 
	[int16_t a; int32_t b; a = 1235; b = 1235;], 
	[
		AC_DEFINE(HAVE_INTXX_T)
		AC_MSG_RESULT(yes)
		have_intxx_t=1
	],
	[AC_MSG_RESULT(no)]
) 

AC_MSG_CHECKING([for u_intXX_t types])
AC_TRY_COMPILE(
	[#include <sys/types.h>], 
	[u_int16_t c; u_int32_t d; c = 1235; d = 1235;], 
	[
		AC_DEFINE(HAVE_U_INTXX_T)
		AC_MSG_RESULT(yes)
		have_u_intxx_t=1
	],
	[AC_MSG_RESULT(no)]
) 

if test -z "$have_u_intxx_t" -o -z "$have_intxx_t" -a \
           "x$ac_cv_header_sys_bitypes_h" = "xyes"
then
	AC_MSG_CHECKING([for intXX_t and u_intXX_t types in sys/bitypes.h])
	AC_TRY_COMPILE(
		[#include <sys/bitypes.h>], 
		[
			u_int16_t c; u_int32_t d; 
			int16_t e; int32_t f;
			c = 1235; d = 1235;
			e = 1235; f = 1235;
		], 
		[
			AC_DEFINE(HAVE_U_INTXX_T)
			AC_DEFINE(HAVE_INTXX_T)
			AC_MSG_RESULT(yes)
		],
		[AC_MSG_RESULT(no)]
	) 
fi

AC_MSG_CHECKING([for uintXX_t types])
AC_TRY_COMPILE(
	[#include <sys/types.h>], 
	[uint16_t c; uint32_t d; c = 1235; d = 1235;], 
	[
		AC_DEFINE(HAVE_UINTXX_T)
		AC_MSG_RESULT(yes)
	],
	[AC_MSG_RESULT(no)]
) 

AC_MSG_CHECKING([for socklen_t])
AC_TRY_COMPILE(
	[
		#include <sys/types.h>
		#include <sys/socket.h>
	],
	[socklen_t foo; foo = 1235;],
	[
		AC_DEFINE(HAVE_SOCKLEN_T)
		AC_MSG_RESULT(yes)
	],
	[AC_MSG_RESULT(no)]
)

AC_MSG_CHECKING([for size_t])
AC_TRY_COMPILE(
	[#include <sys/types.h>],
	[size_t foo; foo = 1235;],
	[
		AC_DEFINE(HAVE_SIZE_T)
		AC_MSG_RESULT(yes)
	],
	[AC_MSG_RESULT(no)]
)

AC_MSG_CHECKING([for struct sockaddr_storage])
AC_TRY_COMPILE(
	[
		#include <sys/types.h>
		#include <sys/socket.h>
	],
	[struct sockaddr_storage s;],
	[
		AC_DEFINE(HAVE_STRUCT_SOCKADDR_STORAGE)
		AC_MSG_RESULT(yes)
	],
	[AC_MSG_RESULT(no)]
)

AC_MSG_CHECKING([for struct sockaddr_in6])
AC_TRY_COMPILE(
	[#include <netinet/in.h>],
	[struct sockaddr_in6 s; s.sin6_family = 0;],
	[
		AC_DEFINE(HAVE_STRUCT_SOCKADDR_IN6)
		AC_MSG_RESULT(yes)
	],
	[AC_MSG_RESULT(no)]
)

AC_MSG_CHECKING([for struct in6_addr])
AC_TRY_COMPILE(
	[#include <netinet/in.h>],
	[struct in6_addr s; s.s6_addr[0] = 0;],
	[
		AC_DEFINE(HAVE_STRUCT_IN6_ADDR)
		AC_MSG_RESULT(yes)
	],
	[AC_MSG_RESULT(no)]
)

AC_MSG_CHECKING([for struct addrinfo])
AC_TRY_COMPILE(
	[
		#include <sys/types.h>
		#include <sys/socket.h>
		#include <netdb.h>
	],
	[struct addrinfo s; s.ai_flags = AI_PASSIVE;],
	[
		AC_DEFINE(HAVE_STRUCT_ADDRINFO)
		AC_MSG_RESULT(yes)
	],
	[AC_MSG_RESULT(no)]
)

# Checks for structure members
AC_MSG_CHECKING([whether utmp.h has ut_host field])
AC_EGREP_HEADER(ut_host, utmp.h, 
	[AC_DEFINE(HAVE_HOST_IN_UTMP) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmpx.h has ut_host field])
AC_EGREP_HEADER(ut_host, utmpx.h, 
	[AC_DEFINE(HAVE_HOST_IN_UTMPX) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmpx.h has syslen field])
AC_EGREP_HEADER(syslen, utmpx.h, 
	[AC_DEFINE(HAVE_SYSLEN_IN_UTMPX) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmp.h has ut_pid field])
AC_EGREP_HEADER(ut_pid, utmp.h, 
	[AC_DEFINE(HAVE_PID_IN_UTMP) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmp.h has ut_type field])
AC_EGREP_HEADER(ut_type, utmp.h, 
	[AC_DEFINE(HAVE_TYPE_IN_UTMP) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmp.h has ut_tv field])
AC_EGREP_HEADER(ut_tv, utmp.h, 
	[AC_DEFINE(HAVE_TV_IN_UTMP) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmp.h has ut_id field])
AC_EGREP_HEADER(ut_id, utmp.h, 
	[AC_DEFINE(HAVE_ID_IN_UTMP) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmp.h has ut_addr field])
AC_EGREP_HEADER(ut_addr, utmp.h, 
	[AC_DEFINE(HAVE_ADDR_IN_UTMP) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmpx.h has ut_addr field])
AC_EGREP_HEADER(ut_addr, utmpx.h, 
	[AC_DEFINE(HAVE_ADDR_IN_UTMPX) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmp.h has ut_addr_v6 field])
AC_EGREP_HEADER(ut_addr_v6, utmp.h, 
	[AC_DEFINE(HAVE_ADDR_V6_IN_UTMP) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether utmpx.h has ut_addr_v6 field])
AC_EGREP_HEADER(ut_addr_v6, utmpx.h, 
	[AC_DEFINE(HAVE_ADDR_V6_IN_UTMPX) AC_MSG_RESULT(yes); ], 
	[AC_MSG_RESULT(no)]
)

AC_MSG_CHECKING([whether struct sockaddr_storage has ss_family field])
AC_TRY_COMPILE(
	[
		#include <sys/types.h>
		#include <sys/socket.h>
	],
	[struct sockaddr_storage s; s.ss_family = 1;],
	[
		AC_DEFINE(HAVE_SS_FAMILY_IN_SS)
		AC_MSG_RESULT(yes)
	],
	[AC_MSG_RESULT(no)]
)
AC_MSG_CHECKING([whether struct sockaddr_storage has __ss_family field])
AC_TRY_COMPILE(
	[
		#include <sys/types.h>
		#include <sys/socket.h>
	],
	[struct sockaddr_storage s; s.__ss_family = 1;],
	[
		AC_DEFINE(HAVE___SS_FAMILY_IN_SS)
		AC_MSG_RESULT(yes)
	],
	[AC_MSG_RESULT(no)]
)

AC_MSG_CHECKING([whether libc defines __progname])
AC_TRY_LINK([], 
	[extern char *__progname; printf("%s", __progname);], 
	[
		AC_DEFINE(HAVE___PROGNAME)
		AC_MSG_RESULT(yes)
	], 
	[
		AC_MSG_RESULT(no)
	]
)

# Looking for programs, paths and files
AC_ARG_WITH(rsh,
	[  --with-rsh=PATH         Specify path to remote shell program ],
	[
		if test "x$withval" != "$xno" ; then
			AC_DEFINE_UNQUOTED(RSH_PATH, "$withval")
		fi
	],
	[
		AC_PATH_PROG(rsh_path, rsh)
	]
)

AC_ARG_WITH(xauth,
	[  --with-xauth=PATH       Specify path to xauth program ],
	[
		if test "x$withval" != "$xno" ; then
			AC_DEFINE_UNQUOTED(XAUTH_PATH, "$withval")
		fi
	],
	[
		AC_PATH_PROG(xauth_path, xauth)
		if test ! -z "$xauth_path" -a -x "/usr/openwin/bin/xauth" ; then
			xauth_path="/usr/openwin/bin/xauth"
		fi
	]
)

if test ! -z "$xauth_path" ; then
	AC_DEFINE_UNQUOTED(XAUTH_PATH, "$xauth_path")
fi
if test ! -z "$rsh_path" ; then
	AC_DEFINE_UNQUOTED(RSH_PATH, "$rsh_path")
fi

# Check for mail directory (last resort if we cannot get it from headers)
if test ! -z "$MAIL" ; then
	maildir=`dirname $MAIL`
	AC_DEFINE_UNQUOTED(MAIL_DIRECTORY, "$maildir")
fi

# Look for lastlog location
AC_ARG_WITH(lastlog,
	[  --with-lastlog=FILE     Location of lastlog file],
	[
		if test "x$withval" = "xno" ; then
			AC_DEFINE(DISABLE_LASTLOG)
		else
			AC_DEFINE_UNQUOTED(LASTLOG_LOCATION, "$withval")
		fi
	],
	[
		AC_MSG_CHECKING([location of lastlog file])
		for lastlog in /var/log/lastlog /var/adm/lastlog /usr/adm/lastlog  /etc/security/lastlog ; do
			if test -f $lastlog ; then
				gotlastlog="file"
				break
			fi
			if test -d $lastlog ; then
				gotlastlog="dir"
				break
			fi
		done
		if test -z "$gotlastlog" ; then
			AC_MSG_RESULT(not found)
			nolastlog=1
		else
			if test "x$gotlastlog" = "xdir" ; then
				AC_MSG_RESULT(${lastlog}/)
				AC_DEFINE(LASTLOG_IS_DIR)
			else
				AC_MSG_RESULT($lastlog)
				AC_DEFINE_UNQUOTED(LASTLOG_LOCATION, "$lastlog")
			fi
		fi	
	]
)

if test ! -z "$nolastlog" ; then
	AC_MSG_WARN([*** Disabling lastlog support *** ])
	AC_DEFINE(DISABLE_LASTLOG)
fi

if test -z "$no_dev_ptmx" ; then
	AC_CHECK_FILE("/dev/ptmx", 
		[
			AC_DEFINE_UNQUOTED(HAVE_DEV_PTMX)
			have_dev_ptmx=1
		]
	)
fi
AC_CHECK_FILE("/dev/ptc", 
	[
		AC_DEFINE_UNQUOTED(HAVE_DEV_PTS_AND_PTC)
		have_dev_ptc=1
	]
)

# Options from here on. Some of these are preset by platform above

# Check whether user wants GNOME ssh-askpass
AC_MSG_CHECKING([whether to build GNOME ssh-askpass])
AC_ARG_WITH(gnome-askpass,
	[  --with-gnome-askpass    Build the GNOME passphrase requester (default=no)],
	[
		if test x$withval = xno ; then
			GNOME_ASKPASS="";
		else
			GNOME_ASKPASS="gnome-ssh-askpass";
		fi
	])
AC_SUBST(GNOME_ASKPASS)

if test -z "$GNOME_ASKPASS" ; then
	AC_MSG_RESULT(no)
else
	AC_MSG_RESULT(yes)
fi

# Check for user-specified random device, otherwise check /dev/urandom
AC_ARG_WITH(random,
	[  --with-random=FILE      read randomness from FILE (default=/dev/urandom)],
	[
		RANDOM_POOL="$withval";
		AC_DEFINE_UNQUOTED(RANDOM_POOL, "$RANDOM_POOL")
	],
	[
		# Check for random device
		AC_CHECK_FILE("/dev/urandom",
			[
				RANDOM_POOL="/dev/urandom"; 
				AC_SUBST(RANDOM_POOL)
				AC_DEFINE_UNQUOTED(RANDOM_POOL, "$RANDOM_POOL")
			]
		)
	]
)

# Check for EGD pool file
AC_ARG_WITH(egd-pool,
	[  --with-egd-pool=FILE    read randomness from EGD pool FILE (default none)],
	[
		RANDOM_POOL="$withval";
		AC_DEFINE(HAVE_EGD)
		AC_SUBST(RANDOM_POOL)
		AC_DEFINE_UNQUOTED(RANDOM_POOL, "$RANDOM_POOL")
	]
)

# Make sure we have some random number support
if test -z "$RANDOM_POOL" -a -z "$EGD_POOL"; then
	AC_MSG_ERROR([No random device found, and no EGD random pool specified])
fi

AC_ARG_WITH(catman,
	[  --with-catman=man|cat   Install preformatted manpages[no]],
	[
		MANTYPE='$(CATMAN)'
		if test x"$withval" != x"yes" ; then
		   mansubdir=$withval
		else
		   mansubdir=cat
		fi
	], [
		if test -z "$MANTYPE" ; then
			MANTYPE='$(TROFFMAN)'
			mansubdir=man
		fi
	]
)
AC_SUBST(MANTYPE)
AC_SUBST(mansubdir)

# Check whether user wants Kerberos support
AC_ARG_WITH(kerberos4,
	[  --with-kerberos4=PATH   Enable Kerberos 4 support],
	[
		if test "x$withval" != "$xno" ; then
	
			if test "x$withval" != "$xyes" ; then
				CFLAGS="$CFLAGS -I${withval}/include"
				LDFLAGS="$LDFLAGS -L${withval}/lib"
			else
				if test -d /usr/include/kerberosIV ; then
					CFLAGS="$CFLAGS -I/usr/include/kerberosIV"
				fi
			fi

			AC_CHECK_HEADERS(krb.h)
			AC_CHECK_LIB(krb, main)
			if test "$ac_cv_header_krb_h" != yes; then
				AC_MSG_WARN([Cannot find krb.h, build may fail])
			fi
			if test "$ac_cv_lib_krb_main" != yes; then
				AC_MSG_WARN([Cannot find libkrb, build may fail])
			fi

			KLIBS="-lkrb -ldes"
			AC_CHECK_LIB(resolv, dn_expand, , )
			KRB4=yes
			AC_DEFINE(KRB4)
		fi
	]
)

# Check whether user wants AFS support
AC_ARG_WITH(afs,
	[  --with-afs=PATH         Enable AFS support],
	[
		if test "x$withval" != "$xno" ; then

			if test "x$withval" != "$xyes" ; then
				CFLAGS="$CFLAGS -I${withval}/include"
				LFLAGS="$LFLAGS -L${withval}/lib"
			fi

			if test -z "$KRB4" ; then
				AC_MSG_WARN([AFS requires Kerberos IV support, build may fail])
			fi

			LIBS="$LIBS -lkafs"
			if test ! -z "$AFS_LIBS" ; then
				LIBS="$LIBS $AFS_LIBS"
			fi
			AC_DEFINE(AFS)
		fi
	]
)
LIBS="$LIBS $KLIBS"

# Check whether user wants S/Key support
AC_ARG_WITH(skey,
	[  --with-skey             Enable S/Key support],
	[
		if test "x$withval" != "$xno" ; then
			AC_DEFINE(SKEY)
			LIBS="$LIBS -lskey"
		fi
	]
)

# Check whether user wants TCP wrappers support
AC_ARG_WITH(tcp-wrappers,
	[  --with-tcp-wrappers     Enable tcpwrappers support],
	[
		if test "x$withval" != "$xno" ; then
			saved_LIBS="$LIBS"
			LIBS="$LIBS -lwrap"
			AC_MSG_CHECKING(for libwrap)
			AC_TRY_LINK(
				[
					#include <tcpd.h>
					int deny_severity = 0, allow_severity = 0;
				],
				[hosts_access(0);],
				[
					AC_MSG_RESULT(yes)
					AC_DEFINE(LIBWRAP)
				],
				[
					AC_MSG_RESULT(no)
					AC_MSG_WARN([*** libwrap missing - tcpwrapper support disabled ***])
					LIBS="$saved_LIBS"
				]
			)
		fi
	]
)

# Check whether to enable MD5 passwords
AC_ARG_WITH(md5-passwords,
	[  --with-md5-passwords    Enable use of MD5 passwords],
	[
		if test "x$withval" != "$xno" ; then
			AC_DEFINE(HAVE_MD5_PASSWORDS)
		fi
	]
)

# Check whether to enable utmpx support
AC_ARG_WITH(utmpx,
	[  --with-utmpx            Enable utmpx support],
	[
		if test "x$withval" != "xno" ; then
			AC_DEFINE(USE_UTMPX)
		fi
	]
)

# Whether to disable shadow password support
AC_ARG_WITH(shadow,
	[  --without-shadow        Disable shadow password support],
	[
		if test "x$withval" = "xno" ; then	
			AC_DEFINE(DISABLE_SHADOW)
		fi
	]
)

# Use ip address instead of hostname in $DISPLAY
AC_ARG_WITH(ipaddr-display,
	[  --with-ipaddr-display   Use ip address instead of hostname in \$DISPLAY],
	[
		if test "x$withval" = "xno" ; then	
			AC_DEFINE(IPADDR_IN_DISPLAY)
		fi
	]
)

# Whether to mess with the default path
AC_ARG_WITH(default-path,
	[  --with-default-path=PATH Specify default \$PATH environment for server],
	[
		if test "x$withval" != "xno" ; then	
			AC_DEFINE_UNQUOTED(USER_PATH, "$withval")
		fi
	]
)

# Whether to force IPv4 by default (needed on broken glibc Linux)
AC_ARG_WITH(ipv4-default,
	[  --with-ipv4-default     Use IPv4 by connections unless '-6' specified],
	[
		if test "x$withval" != "xno" ; then	
			AC_DEFINE(IPV4_DEFAULT)
		fi
	]
)

# Where to place sshd.pid
piddir=/var/run
AC_ARG_WITH(pid-dir,
	[  --with-pid-dir=PATH     Specify location of ssh.pid file],
	[
		if test "x$withval" != "xno" ; then	
			piddir=$withval
		fi
	]
)
AC_DEFINE_UNQUOTED(PIDDIR, "$piddir")
AC_SUBST(piddir)

AC_OUTPUT(Makefile)
Commit	Line	Data
4cca272e	1	AC_INIT(ssh.c)
5881cd60	2
5881cd60	3	AC_CONFIG_HEADER(config.h)
a7effaac	4	AC_CANONICAL_HOST
5881cd60	5
a0391976	6	# C Compiler features
	7	if test "$GCC" = "yes"; then CFLAGS="$CFLAGS -Wall"; fi
	8	AC_C_INLINE
	9
	10	# Checks for programs.
5881cd60	11	AC_PROG_CC
4cca272e	12	AC_PROG_CPP
5881cd60	13	AC_PROG_RANLIB
cf8dd513	14	AC_PROG_INSTALL
d4f11b59	15	AC_CHECK_PROG(AR, ar, ar)
a0f84251	16	AC_PATH_PROG(PERL, perl)
a0f84251	17	AC_SUBST(PERL)
f498ed15	18
a0391976	19	# Check for some target-specific stuff
a7effaac	20	case "$host" in
9d6b1b96	21	--aix*)
9d6b1b96	22	AFS_LIBS="-lld"
4c8ef3fb	23	AC_DEFINE(BROKEN_GETADDRINFO)
9d6b1b96	24	;;
a7effaac	25	--hpux10*)
	26	if test -z "$GCC"; then
	27	CFLAGS="$CFLAGS -Aa"
	28	fi
	29	CFLAGS="$CFLAGS -D_HPUX_SOURCE"
	30	AC_DEFINE(IPADDR_IN_DISPLAY)
f498ed15	31	AC_DEFINE(USE_UTMPX)
a7effaac	32	AC_MSG_CHECKING(for HPUX trusted system password database)
	33	if test -f /tcb/files/auth/system/default; then
	34	AC_MSG_RESULT(yes)
	35	AC_DEFINE(HAVE_HPUX_TRUSTED_SYSTEM_PW)
	36	LIBS="$LIBS -lsec"
dfb95100	37	AC_MSG_WARN([This configuration is untested])
a7effaac	38	else
	39	AC_MSG_RESULT(no)
	40	AC_DEFINE(DISABLE_SHADOW)
	41	fi
c54a6257	42	MANTYPE='$(CATMAN)'
c54a6257	43	mansubdir=cat
a7effaac	44	;;
d94aa2ae	45	--irix5*)
8eb34e02	46	MANTYPE='$(CATMAN)'
b9795b89	47	no_libsocket=1
	48	no_libnsl=1
	49	;;
	50	--irix6*)
8eb34e02	51	MANTYPE='$(CATMAN)'
8eb34e02	52	AC_MSG_WARN([* Irix 6.x is not tested, please report you experiences * ])
d94aa2ae	53	no_libsocket=1
	54	no_libnsl=1
	55	;;
5cdfe03f	56	--linux*)
	57	no_dev_ptmx=1
	58	;;
d468fc76	59	--netbsd*)
a0391976	60	need_dash_r=1
d468fc76	61	;;
9d6b1b96	62	--solaris*)
a0391976	63	need_dash_r=1
aa6bd60a	64	LDFLAGS="-L/usr/ucblib"
9d6b1b96	65	AC_DEFINE(USE_UTMPX)
	66	;;
	67	--sysv*)
9755cbdb	68	AC_DEFINE(USE_UTMPX)
	69	MANTYPE='$(CATMAN)'
	70	mansubdir=cat
9d6b1b96	71	LIBS="$LIBS -lgen -lsocket"
9d6b1b96	72	;;
a7effaac	73	esac
a7effaac	74
a0391976	75	# Checks for libraries.
4cca272e	76	AC_CHECK_LIB(z, deflate, ,AC_MSG_ERROR([* zlib missing - please install first *]))
4cca272e	77	AC_CHECK_LIB(util, login, AC_DEFINE(HAVE_LIBUTIL_LOGIN) LIBS="$LIBS -lutil")
4cca272e	78
d94aa2ae	79	if test -z "$no_libsocket" ; then
	80	AC_CHECK_LIB(nsl, yp_match, , )
	81	fi
	82	if test -z "$no_libnsl" ; then
	83	AC_CHECK_LIB(socket, main, , )
f74efc8d	84	fi
4cca272e	85
a0391976	86	# Checks for header files.
c54a6257	87	AC_CHECK_HEADERS(bstring.h endian.h lastlog.h login.h maillock.h netdb.h netgroup.h paths.h poll.h pty.h shadow.h security/pam_appl.h sys/bitypes.h sys/bsdtty.h sys/cdefs.h sys/poll.h sys/select.h sys/stropts.h sys/sysmacros.h sys/time.h sys/ttcompat.h stddef.h util.h utmp.h utmpx.h)
4cca272e	88
a0391976	89	# Checks for library functions.
aa6bd60a	90	AC_CHECK_FUNCS(arc4random bindresvport_af freeaddrinfo gai_strerror getaddrinfo getnameinfo innetgr md5_crypt mkdtemp openpty rresvport_af setenv seteuid setlogin setproctitle setreuid snprintf strlcat strlcpy updwtmpx vsnprintf _getpty)
76cd7316	91
beb43d31	92	AC_CHECK_FUNC(login,
	93	[AC_DEFINE(HAVE_LOGIN)],
	94	[AC_CHECK_LIB(bsd, login, [LIBS="$LIBS -lbsd"; AC_DEFINE(HAVE_LOGIN)])]
	95	)
	96
	97	AC_CHECK_FUNC(daemon,
	98	[AC_DEFINE(HAVE_DAEMON)],
	99	[AC_CHECK_LIB(bsd, daemon, [LIBS="$LIBS -lbsd"; AC_DEFINE(HAVE_DAEMON)])]
	100	)
	101
aa6bd60a	102	AC_CHECK_FUNC(getpagesize,
	103	[AC_DEFINE(HAVE_GETPAGESIZE)],
	104	[AC_CHECK_LIB(ucb, getpagesize, [LIBS="$LIBS -lucb"; AC_DEFINE(HAVE_GETPAGESIZE)])]
	105	)
	106
a0391976	107	AC_ARG_WITH(pam,
	108	[ --without-pam Disable PAM support ],
	109	[
	110	if test "x$withval" = "xno" ; then
	111	no_pam=1
	112	AC_DEFINE(DISABLE_PAM)
	113	fi
	114	]
	115	)
	116	if test -z "$no_pam" -a "x$ac_cv_header_security_pam_appl_h" = "xyes" ; then
	117	AC_CHECK_LIB(dl, dlopen, , )
	118	LIBS="$LIBS -lpam"
	119
	120	# Check PAM strerror arguments (old PAM)
	121	AC_MSG_CHECKING([whether pam_strerror takes only one argument])
	122	AC_TRY_COMPILE(
	123	[
	124	#include <stdlib.h>
	125	#include <security/pam_appl.h>
	126	],
	127	[(void)pam_strerror((pam_handle_t *)NULL, -1);],
	128	[AC_MSG_RESULT(no)],
	129	[
	130	AC_DEFINE(HAVE_OLD_PAM)
	131	AC_MSG_RESULT(yes)
	132	]
	133	)
	134	fi
	135
	136	# The big search for OpenSSL
	137	AC_ARG_WITH(ssl-dir,
	138	[ --with-ssl-dir=PATH Specify path to OpenSSL installation ],
	139	[
	140	if test "x$withval" != "$xno" ; then
	141	tryssldir=$withval
	142	fi
	143	]
	144	)
	145
	146	saved_LIBS="$LIBS"
	147	saved_CFLAGS="$CFLAGS"
	148	if test "x$prefix" != "xNONE" ; then
	149	tryssldir="$tryssldir $prefix"
	150	fi
	151	AC_MSG_CHECKING([for OpenSSL/SSLeay directory])
	152	for ssldir in "" $tryssldir /usr /usr/local/openssl /usr/lib/openssl /usr/local/ssl /usr/lib/ssl /usr/local /usr/pkg /opt /opt/openssl ; do
	153	if test ! -z "$ssldir" ; then
	154	LIBS="$saved_LIBS -L$ssldir"
	155	CFLAGS="$CFLAGS -I$ssldir/include"
	156	if test "x$need_dash_r" = "x1" ; then
07055445	157	LIBS="$LIBS -R$ssldir/lib"
a0391976	158	fi
	159	fi
	160	LIBS="$LIBS -lcrypto"
	161
	162	AC_TRY_RUN(
	163	[
	164	#include <openssl/rsa.h>
	165	#include <openssl/bn.h>
	166	#include <openssl/sha.h>
	167	int main(void)
54096dcc	168	{RSA *key; char seed[2048];memset(seed, 0, sizeof(seed));
	169	RAND_seed(seed, sizeof(seed));key=RSA_generate_key(32,3,NULL,NULL);
	170	return(key==NULL);}
a0391976	171	],
	172	[
	173	AC_DEFINE(HAVE_OPENSSL)
	174	found_crypto=1
	175	break;
	176	], []
	177	)
	178	AC_TRY_RUN(
	179	[
	180	#include <ssl/rsa.h>
	181	#include <ssl/bn.h>
	182	#include <ssl/sha.h>
	183	int main(void)
54096dcc	184	{RSA *key; char seed[2048];memset(seed, 0, sizeof(seed));
	185	RAND_seed(seed, sizeof(seed));key=RSA_generate_key(32,3,NULL,NULL);
	186	return(key==NULL);}
a0391976	187	],
	188	[
	189	AC_DEFINE(HAVE_SSL)
	190	found_crypto=1
	191	break;
	192	], []
	193	)
	194	done
	195
	196	if test -z "$found_crypto" ; then
	197	AC_MSG_ERROR([Could not find working SSLeay / OpenSSL libraries, please install])
	198	fi
	199	if test -z "$ssldir" ; then
	200	ssldir="(system)"
	201	else
	202	CFLAGS="$CFLAGS -I$ssldir/include"
	203	LDFLAGS="$LDFLAGS -L$ssldir/lib"
	204	if test "x$need_dash_r" = "x1" ; then
	205	LDFLAGS="$LDFLAGS -R$ssldir"
	206	fi
	207	fi
	208	LIBS="$saved_LIBS -lcrypto"
	209	AC_MSG_RESULT($ssldir)
	210
	211	# Checks for data types
976f7e19	212	AC_CHECK_SIZEOF(char, 1)
2b942fe0	213	AC_CHECK_SIZEOF(short int, 2)
	214	AC_CHECK_SIZEOF(int, 4)
	215	AC_CHECK_SIZEOF(long int, 4)
	216	AC_CHECK_SIZEOF(long long int, 8)
	217
a0391976	218	# More checks for data types
96ad4350	219	AC_MSG_CHECKING([for intXX_t types])
2b942fe0	220	AC_TRY_COMPILE(
	221	[#include <sys/types.h>],
	222	[int16_t a; int32_t b; a = 1235; b = 1235;],
	223	[
	224	AC_DEFINE(HAVE_INTXX_T)
	225	AC_MSG_RESULT(yes)
5cdfe03f	226	have_intxx_t=1
2b942fe0	227	],
	228	[AC_MSG_RESULT(no)]
	229	)
	230
96ad4350	231	AC_MSG_CHECKING([for u_intXX_t types])
2b942fe0	232	AC_TRY_COMPILE(
	233	[#include <sys/types.h>],
	234	[u_int16_t c; u_int32_t d; c = 1235; d = 1235;],
	235	[
	236	AC_DEFINE(HAVE_U_INTXX_T)
	237	AC_MSG_RESULT(yes)
5cdfe03f	238	have_u_intxx_t=1
2b942fe0	239	],
	240	[AC_MSG_RESULT(no)]
	241	)
	242
20af321f	243	if test -z "$have_u_intxx_t" -o -z "$have_intxx_t" -a \
5cdfe03f	244	"x$ac_cv_header_sys_bitypes_h" = "xyes"
	245	then
	246	AC_MSG_CHECKING([for intXX_t and u_intXX_t types in sys/bitypes.h])
	247	AC_TRY_COMPILE(
	248	[#include <sys/bitypes.h>],
	249	[
	250	u_int16_t c; u_int32_t d;
	251	int16_t e; int32_t f;
	252	c = 1235; d = 1235;
	253	e = 1235; f = 1235;
	254	],
	255	[
	256	AC_DEFINE(HAVE_U_INTXX_T)
	257	AC_DEFINE(HAVE_INTXX_T)
	258	AC_MSG_RESULT(yes)
	259	],
	260	[AC_MSG_RESULT(no)]
	261	)
	262	fi
	263
48e671d5	264	AC_MSG_CHECKING([for uintXX_t types])
2b942fe0	265	AC_TRY_COMPILE(
	266	[#include <sys/types.h>],
	267	[uint16_t c; uint32_t d; c = 1235; d = 1235;],
	268	[
	269	AC_DEFINE(HAVE_UINTXX_T)
	270	AC_MSG_RESULT(yes)
	271	],
	272	[AC_MSG_RESULT(no)]
	273	)
	274
48e671d5	275	AC_MSG_CHECKING([for socklen_t])
ea1970a3	276	AC_TRY_COMPILE(
723221b5	277	[
	278	#include <sys/types.h>
	279	#include <sys/socket.h>
	280	],
ea1970a3	281	[socklen_t foo; foo = 1235;],
	282	[
	283	AC_DEFINE(HAVE_SOCKLEN_T)
	284	AC_MSG_RESULT(yes)
	285	],
	286	[AC_MSG_RESULT(no)]
	287	)
	288
48e671d5	289	AC_MSG_CHECKING([for size_t])
e3a93db0	290	AC_TRY_COMPILE(
e3a93db0	291	[#include <sys/types.h>],
e3a93db0	292	[size_t foo; foo = 1235;],
	293	[
	294	AC_DEFINE(HAVE_SIZE_T)
	295	AC_MSG_RESULT(yes)
	296	],
	297	[AC_MSG_RESULT(no)]
	298	)
	299
48e671d5	300	AC_MSG_CHECKING([for struct sockaddr_storage])
48e671d5	301	AC_TRY_COMPILE(
5957fd29	302	[
	303	#include <sys/types.h>
	304	#include <sys/socket.h>
	305	],
48e671d5	306	[struct sockaddr_storage s;],
	307	[
	308	AC_DEFINE(HAVE_STRUCT_SOCKADDR_STORAGE)
	309	AC_MSG_RESULT(yes)
	310	],
	311	[AC_MSG_RESULT(no)]
	312	)
	313
	314	AC_MSG_CHECKING([for struct sockaddr_in6])
	315	AC_TRY_COMPILE(
	316	[#include <netinet/in.h>],
	317	[struct sockaddr_in6 s; s.sin6_family = 0;],
	318	[
	319	AC_DEFINE(HAVE_STRUCT_SOCKADDR_IN6)
	320	AC_MSG_RESULT(yes)
	321	],
	322	[AC_MSG_RESULT(no)]
	323	)
	324
	325	AC_MSG_CHECKING([for struct in6_addr])
	326	AC_TRY_COMPILE(
	327	[#include <netinet/in.h>],
	328	[struct in6_addr s; s.s6_addr[0] = 0;],
	329	[
	330	AC_DEFINE(HAVE_STRUCT_IN6_ADDR)
	331	AC_MSG_RESULT(yes)
	332	],
	333	[AC_MSG_RESULT(no)]
	334	)
	335
	336	AC_MSG_CHECKING([for struct addrinfo])
	337	AC_TRY_COMPILE(
	338	[
5957fd29	339	#include <sys/types.h>
48e671d5	340	#include <sys/socket.h>
	341	#include <netdb.h>
	342	],
	343	[struct addrinfo s; s.ai_flags = AI_PASSIVE;],
	344	[
	345	AC_DEFINE(HAVE_STRUCT_ADDRINFO)
	346	AC_MSG_RESULT(yes)
	347	],
	348	[AC_MSG_RESULT(no)]
	349	)
	350
a0391976	351	# Checks for structure members
f601d847	352	AC_MSG_CHECKING([whether utmp.h has ut_host field])
	353	AC_EGREP_HEADER(ut_host, utmp.h,
	354	[AC_DEFINE(HAVE_HOST_IN_UTMP) AC_MSG_RESULT(yes); ],
	355	[AC_MSG_RESULT(no)]
	356	)
8946db53	357	AC_MSG_CHECKING([whether utmpx.h has ut_host field])
	358	AC_EGREP_HEADER(ut_host, utmpx.h,
	359	[AC_DEFINE(HAVE_HOST_IN_UTMPX) AC_MSG_RESULT(yes); ],
	360	[AC_MSG_RESULT(no)]
	361	)
f498ed15	362	AC_MSG_CHECKING([whether utmpx.h has syslen field])
	363	AC_EGREP_HEADER(syslen, utmpx.h,
	364	[AC_DEFINE(HAVE_SYSLEN_IN_UTMPX) AC_MSG_RESULT(yes); ],
	365	[AC_MSG_RESULT(no)]
	366	)
70e0115b	367	AC_MSG_CHECKING([whether utmp.h has ut_pid field])
	368	AC_EGREP_HEADER(ut_pid, utmp.h,
	369	[AC_DEFINE(HAVE_PID_IN_UTMP) AC_MSG_RESULT(yes); ],
	370	[AC_MSG_RESULT(no)]
	371	)
	372	AC_MSG_CHECKING([whether utmp.h has ut_type field])
	373	AC_EGREP_HEADER(ut_type, utmp.h,
	374	[AC_DEFINE(HAVE_TYPE_IN_UTMP) AC_MSG_RESULT(yes); ],
	375	[AC_MSG_RESULT(no)]
	376	)
	377	AC_MSG_CHECKING([whether utmp.h has ut_tv field])
	378	AC_EGREP_HEADER(ut_tv, utmp.h,
	379	[AC_DEFINE(HAVE_TV_IN_UTMP) AC_MSG_RESULT(yes); ],
	380	[AC_MSG_RESULT(no)]
	381	)
c73a0cb5	382	AC_MSG_CHECKING([whether utmp.h has ut_id field])
	383	AC_EGREP_HEADER(ut_id, utmp.h,
	384	[AC_DEFINE(HAVE_ID_IN_UTMP) AC_MSG_RESULT(yes); ],
	385	[AC_MSG_RESULT(no)]
	386	)
4811cc0b	387	AC_MSG_CHECKING([whether utmp.h has ut_addr field])
	388	AC_EGREP_HEADER(ut_addr, utmp.h,
	389	[AC_DEFINE(HAVE_ADDR_IN_UTMP) AC_MSG_RESULT(yes); ],
	390	[AC_MSG_RESULT(no)]
	391	)
	392	AC_MSG_CHECKING([whether utmpx.h has ut_addr field])
	393	AC_EGREP_HEADER(ut_addr, utmpx.h,
48e671d5	394	[AC_DEFINE(HAVE_ADDR_IN_UTMPX) AC_MSG_RESULT(yes); ],
	395	[AC_MSG_RESULT(no)]
	396	)
	397	AC_MSG_CHECKING([whether utmp.h has ut_addr_v6 field])
	398	AC_EGREP_HEADER(ut_addr_v6, utmp.h,
	399	[AC_DEFINE(HAVE_ADDR_V6_IN_UTMP) AC_MSG_RESULT(yes); ],
	400	[AC_MSG_RESULT(no)]
	401	)
	402	AC_MSG_CHECKING([whether utmpx.h has ut_addr_v6 field])
	403	AC_EGREP_HEADER(ut_addr_v6, utmpx.h,
	404	[AC_DEFINE(HAVE_ADDR_V6_IN_UTMPX) AC_MSG_RESULT(yes); ],
	405	[AC_MSG_RESULT(no)]
	406	)
	407
	408	AC_MSG_CHECKING([whether struct sockaddr_storage has ss_family field])
	409	AC_TRY_COMPILE(
5957fd29	410	[
	411	#include <sys/types.h>
	412	#include <sys/socket.h>
	413	],
48e671d5	414	[struct sockaddr_storage s; s.ss_family = 1;],
	415	[
	416	AC_DEFINE(HAVE_SS_FAMILY_IN_SS)
	417	AC_MSG_RESULT(yes)
	418	],
	419	[AC_MSG_RESULT(no)]
	420	)
	421	AC_MSG_CHECKING([whether struct sockaddr_storage has __ss_family field])
	422	AC_TRY_COMPILE(
5957fd29	423	[
	424	#include <sys/types.h>
	425	#include <sys/socket.h>
	426	],
48e671d5	427	[struct sockaddr_storage s; s.__ss_family = 1;],
	428	[
	429	AC_DEFINE(HAVE___SS_FAMILY_IN_SS)
	430	AC_MSG_RESULT(yes)
	431	],
4811cc0b	432	[AC_MSG_RESULT(no)]
4811cc0b	433	)
8946db53	434
a0391976	435	AC_MSG_CHECKING([whether libc defines __progname])
	436	AC_TRY_LINK([],
	437	[extern char *__progname; printf("%s", __progname);],
	438	[
	439	AC_DEFINE(HAVE___PROGNAME)
	440	AC_MSG_RESULT(yes)
	441	],
	442	[
	443	AC_MSG_RESULT(no)
	444	]
	445	)
	446
	447	# Looking for programs, paths and files
	448	AC_ARG_WITH(rsh,
	449	[ --with-rsh=PATH Specify path to remote shell program ],
	450	[
	451	if test "x$withval" != "$xno" ; then
	452	AC_DEFINE_UNQUOTED(RSH_PATH, "$withval")
	453	fi
	454	],
	455	[
	456	AC_PATH_PROG(rsh_path, rsh)
	457	]
	458	)
	459
	460	AC_ARG_WITH(xauth,
	461	[ --with-xauth=PATH Specify path to xauth program ],
	462	[
	463	if test "x$withval" != "$xno" ; then
	464	AC_DEFINE_UNQUOTED(XAUTH_PATH, "$withval")
	465	fi
	466	],
	467	[
	468	AC_PATH_PROG(xauth_path, xauth)
	469	if test ! -z "$xauth_path" -a -x "/usr/openwin/bin/xauth" ; then
	470	xauth_path="/usr/openwin/bin/xauth"
	471	fi
	472	]
	473	)
	474
	475	if test ! -z "$xauth_path" ; then
	476	AC_DEFINE_UNQUOTED(XAUTH_PATH, "$xauth_path")
	477	fi
	478	if test ! -z "$rsh_path" ; then
	479	AC_DEFINE_UNQUOTED(RSH_PATH, "$rsh_path")
	480	fi
	481
	482	# Check for mail directory (last resort if we cannot get it from headers)
	483	if test ! -z "$MAIL" ; then
	484	maildir=`dirname $MAIL`
	485	AC_DEFINE_UNQUOTED(MAIL_DIRECTORY, "$maildir")
	486	fi
	487
	488	# Look for lastlog location
a7effaac	489	AC_ARG_WITH(lastlog,
cb807f40	490	[ --with-lastlog=FILE Location of lastlog file],
a7effaac	491	[
	492	if test "x$withval" = "xno" ; then
	493	AC_DEFINE(DISABLE_LASTLOG)
	494	else
	495	AC_DEFINE_UNQUOTED(LASTLOG_LOCATION, "$withval")
	496	fi
	497	],
	498	[
	499	AC_MSG_CHECKING([location of lastlog file])
f9507c24	500	for lastlog in /var/log/lastlog /var/adm/lastlog /usr/adm/lastlog /etc/security/lastlog ; do
a7effaac	501	if test -f $lastlog ; then
	502	gotlastlog="file"
	503	break
	504	fi
	505	if test -d $lastlog ; then
	506	gotlastlog="dir"
	507	break
	508	fi
	509	done
	510	if test -z "$gotlastlog" ; then
d94aa2ae	511	AC_MSG_RESULT(not found)
a7effaac	512	nolastlog=1
	513	else
	514	if test "x$gotlastlog" = "xdir" ; then
d94aa2ae	515	AC_MSG_RESULT(${lastlog}/)
a7effaac	516	AC_DEFINE(LASTLOG_IS_DIR)
d94aa2ae	517	else
	518	AC_MSG_RESULT($lastlog)
	519	AC_DEFINE_UNQUOTED(LASTLOG_LOCATION, "$lastlog")
a7effaac	520	fi
a7effaac	521	fi
	522	]
	523	)
	524
	525	if test ! -z "$nolastlog" ; then
	526	AC_MSG_WARN([* Disabling lastlog support * ])
	527	AC_DEFINE(DISABLE_LASTLOG)
	528	fi
f601d847	529
a0391976	530	if test -z "$no_dev_ptmx" ; then
3276571c	531	AC_CHECK_FILE("/dev/ptmx",
	532	[
	533	AC_DEFINE_UNQUOTED(HAVE_DEV_PTMX)
	534	have_dev_ptmx=1
	535	]
	536	)
	537	fi
	538	AC_CHECK_FILE("/dev/ptc",
	539	[
	540	AC_DEFINE_UNQUOTED(HAVE_DEV_PTS_AND_PTC)
	541	have_dev_ptc=1
	542	]
	543	)
	544
a0391976	545	# Options from here on. Some of these are preset by platform above
	546
	547	# Check whether user wants GNOME ssh-askpass
	548	AC_MSG_CHECKING([whether to build GNOME ssh-askpass])
	549	AC_ARG_WITH(gnome-askpass,
	550	[ --with-gnome-askpass Build the GNOME passphrase requester (default=no)],
	551	[
	552	if test x$withval = xno ; then
	553	GNOME_ASKPASS="";
	554	else
	555	GNOME_ASKPASS="gnome-ssh-askpass";
	556	fi
	557	])
	558	AC_SUBST(GNOME_ASKPASS)
	559
	560	if test -z "$GNOME_ASKPASS" ; then
	561	AC_MSG_RESULT(no)
	562	else
	563	AC_MSG_RESULT(yes)
	564	fi
	565
	566	# Check for user-specified random device, otherwise check /dev/urandom
	567	AC_ARG_WITH(random,
	568	[ --with-random=FILE read randomness from FILE (default=/dev/urandom)],
	569	[
	570	RANDOM_POOL="$withval";
	571	AC_DEFINE_UNQUOTED(RANDOM_POOL, "$RANDOM_POOL")
	572	],
	573	[
	574	# Check for random device
	575	AC_CHECK_FILE("/dev/urandom",
	576	[
	577	RANDOM_POOL="/dev/urandom";
	578	AC_SUBST(RANDOM_POOL)
	579	AC_DEFINE_UNQUOTED(RANDOM_POOL, "$RANDOM_POOL")
	580	]
	581	)
	582	]
	583	)
	584
	585	# Check for EGD pool file
	586	AC_ARG_WITH(egd-pool,
	587	[ --with-egd-pool=FILE read randomness from EGD pool FILE (default none)],
	588	[
	589	RANDOM_POOL="$withval";
	590	AC_DEFINE(HAVE_EGD)
	591	AC_SUBST(RANDOM_POOL)
	592	AC_DEFINE_UNQUOTED(RANDOM_POOL, "$RANDOM_POOL")
	593	]
	594	)
	595
	596	# Make sure we have some random number support
	597	if test -z "$RANDOM_POOL" -a -z "$EGD_POOL"; then
	598	AC_MSG_ERROR([No random device found, and no EGD random pool specified])
	599	fi
	600
c54a6257	601	AC_ARG_WITH(catman,
	602	[ --with-catman=man\|cat Install preformatted manpages[no]],
	603	[
	604	MANTYPE='$(CATMAN)'
	605	if test x"$withval" != x"yes" ; then
	606	mansubdir=$withval
	607	else
	608	mansubdir=cat
	609	fi
	610	], [
	611	if test -z "$MANTYPE" ; then
	612	MANTYPE='$(TROFFMAN)'
	613	mansubdir=man
	614	fi
	615	]
	616	)
	617	AC_SUBST(MANTYPE)
	618	AC_SUBST(mansubdir)
0bc5b6fb	619
a0391976	620	# Check whether user wants Kerberos support
91b8065d	621	AC_ARG_WITH(kerberos4,
dfb95100	622	[ --with-kerberos4=PATH Enable Kerberos 4 support],
91b8065d	623	[
0bc5b6fb	624	if test "x$withval" != "$xno" ; then
dfb95100	625
	626	if test "x$withval" != "$xyes" ; then
	627	CFLAGS="$CFLAGS -I${withval}/include"
	628	LDFLAGS="$LDFLAGS -L${withval}/lib"
	629	else
	630	if test -d /usr/include/kerberosIV ; then
	631	CFLAGS="$CFLAGS -I/usr/include/kerberosIV"
	632	fi
	633	fi
	634
	635	AC_CHECK_HEADERS(krb.h)
	636	AC_CHECK_LIB(krb, main)
	637	if test "$ac_cv_header_krb_h" != yes; then
	638	AC_MSG_WARN([Cannot find krb.h, build may fail])
	639	fi
	640	if test "$ac_cv_lib_krb_main" != yes; then
	641	AC_MSG_WARN([Cannot find libkrb, build may fail])
	642	fi
	643
587120ad	644	KLIBS="-lkrb -ldes"
dfb95100	645	AC_CHECK_LIB(resolv, dn_expand, , )
dfb95100	646	KRB4=yes
0bc5b6fb	647	AC_DEFINE(KRB4)
0bc5b6fb	648	fi
91b8065d	649	]
	650	)
	651
a0391976	652	# Check whether user wants AFS support
2b942fe0	653	AC_ARG_WITH(afs,
dfb95100	654	[ --with-afs=PATH Enable AFS support],
91b8065d	655	[
0bc5b6fb	656	if test "x$withval" != "$xno" ; then
dfb95100	657
	658	if test "x$withval" != "$xyes" ; then
	659	CFLAGS="$CFLAGS -I${withval}/include"
	660	LFLAGS="$LFLAGS -L${withval}/lib"
	661	fi
	662
	663	if test -z "$KRB4" ; then
	664	AC_MSG_WARN([AFS requires Kerberos IV support, build may fail])
	665	fi
	666
0bc5b6fb	667	LIBS="$LIBS -lkafs"
dfb95100	668	if test ! -z "$AFS_LIBS" ; then
	669	LIBS="$LIBS $AFS_LIBS"
	670	fi
	671	AC_DEFINE(AFS)
0bc5b6fb	672	fi
91b8065d	673	]
91b8065d	674	)
587120ad	675	LIBS="$LIBS $KLIBS"
91b8065d	676
a0391976	677	# Check whether user wants S/Key support
91b8065d	678	AC_ARG_WITH(skey,
	679	[ --with-skey Enable S/Key support],
	680	[
0bc5b6fb	681	if test "x$withval" != "$xno" ; then
	682	AC_DEFINE(SKEY)
	683	LIBS="$LIBS -lskey"
	684	fi
91b8065d	685	]
	686	)
	687
a0391976	688	# Check whether user wants TCP wrappers support
2ddcfdf3	689	AC_ARG_WITH(tcp-wrappers,
91b8065d	690	[ --with-tcp-wrappers Enable tcpwrappers support],
91b8065d	691	[
0bc5b6fb	692	if test "x$withval" != "$xno" ; then
9fc7867e	693	saved_LIBS="$LIBS"
dfb95100	694	LIBS="$LIBS -lwrap"
9fc7867e	695	AC_MSG_CHECKING(for libwrap)
	696	AC_TRY_LINK(
	697	[
	698	#include <tcpd.h>
	699	int deny_severity = 0, allow_severity = 0;
	700	],
	701	[hosts_access(0);],
	702	[
	703	AC_MSG_RESULT(yes)
	704	AC_DEFINE(LIBWRAP)
	705	],
	706	[
	707	AC_MSG_RESULT(no)
	708	AC_MSG_WARN([* libwrap missing - tcpwrapper support disabled *])
	709	LIBS="$saved_LIBS"
	710	]
	711	)
0bc5b6fb	712	fi
91b8065d	713	]
	714	)
	715
a0391976	716	# Check whether to enable MD5 passwords
2ddcfdf3	717	AC_ARG_WITH(md5-passwords,
caf3bc51	718	[ --with-md5-passwords Enable use of MD5 passwords],
0bc5b6fb	719	[
	720	if test "x$withval" != "$xno" ; then
	721	AC_DEFINE(HAVE_MD5_PASSWORDS)
	722	fi
	723	]
caf3bc51	724	)
caf3bc51	725
a0391976	726	# Check whether to enable utmpx support
92f90c57	727	AC_ARG_WITH(utmpx,
92f90c57	728	[ --with-utmpx Enable utmpx support],
a7effaac	729	[
	730	if test "x$withval" != "xno" ; then
	731	AC_DEFINE(USE_UTMPX)
	732	fi
	733	]
92f90c57	734	)
92f90c57	735
a0391976	736	# Whether to disable shadow password support
a7effaac	737	AC_ARG_WITH(shadow,
	738	[ --without-shadow Disable shadow password support],
	739	[
	740	if test "x$withval" = "xno" ; then
	741	AC_DEFINE(DISABLE_SHADOW)
	742	fi
	743	]
	744	)
	745
a0391976	746	# Use ip address instead of hostname in $DISPLAY
a7effaac	747	AC_ARG_WITH(ipaddr-display,
	748	[ --with-ipaddr-display Use ip address instead of hostname in \$DISPLAY],
	749	[
5957fd29	750	if test "x$withval" = "xno" ; then
a7effaac	751	AC_DEFINE(IPADDR_IN_DISPLAY)
	752	fi
	753	]
	754	)
	755
a0391976	756	# Whether to mess with the default path
c43d69a9	757	AC_ARG_WITH(default-path,
cb807f40	758	[ --with-default-path=PATH Specify default \$PATH environment for server],
	759	[
	760	if test "x$withval" != "xno" ; then
c73a0cb5	761	AC_DEFINE_UNQUOTED(USER_PATH, "$withval")
cb807f40	762	fi
	763	]
	764	)
	765
a0391976	766	# Whether to force IPv4 by default (needed on broken glibc Linux)
59e76f33	767	AC_ARG_WITH(ipv4-default,
	768	[ --with-ipv4-default Use IPv4 by connections unless '-6' specified],
	769	[
	770	if test "x$withval" != "xno" ; then
	771	AC_DEFINE(IPV4_DEFAULT)
	772	fi
	773	]
	774	)
	775
a0391976	776	# Where to place sshd.pid
19d9ac2a	777	piddir=/var/run
47e45e44	778	AC_ARG_WITH(pid-dir,
	779	[ --with-pid-dir=PATH Specify location of ssh.pid file],
	780	[
	781	if test "x$withval" != "xno" ; then
19d9ac2a	782	piddir=$withval
47e45e44	783	fi
	784	]
	785	)
a63a7f37	786	AC_DEFINE_UNQUOTED(PIDDIR, "$piddir")
19d9ac2a	787	AC_SUBST(piddir)
47e45e44	788
5881cd60	789	AC_OUTPUT(Makefile)