libuuid: make "CONFORMING TO" man sections more explicit

[thirdparty/util-linux.git] / configure.ac

AC_INIT([util-linux],
	m4_esyscmd([tools/git-version-gen .tarball-version]),
	[kzak@redhat.com],,
	[http://www.kernel.org/pub/linux/utils/util-linux/])


AC_PREREQ([2.60])

AC_CONFIG_AUX_DIR([config])
AC_CONFIG_MACRO_DIR([m4])
dnl AC_USE_SYSTEM_EXTENSIONS must be called before any macros that run
dnl the compiler (like AC_PROG_LIBTOOL) to avoid autoconf errors.
AC_USE_SYSTEM_EXTENSIONS
AM_INIT_AUTOMAKE([-Wall foreign 1.10 tar-pax no-dist-gzip dist-xz subdir-objects])

m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])],
			    [AC_SUBST([AM_DEFAULT_VERBOSITY], [1])])
m4_ifdef([AM_PROG_AR], [AM_PROG_AR])

AC_CONFIG_SRCDIR([sys-utils/mount.c])
AC_PREFIX_DEFAULT([/usr])

dnl version details from <major>.<minor>[-<suffix>]
PACKAGE_VERSION_MAJOR=$(echo $PACKAGE_VERSION | awk -F. '{print $1}')
PACKAGE_VERSION_MINOR=$(echo $PACKAGE_VERSION | awk -F. '{
                                                   sub("-.*","",$2); print $2}')
PACKAGE_VERSION_RELEASE=$(echo $PACKAGE_VERSION | awk -F. '{
                     sub("-.*","",$3); print $3 ~ /^@<:@0-9@:>@+$/ ? $3 : 0}')

dnl libblkid version
LIBBLKID_VERSION="$PACKAGE_VERSION_MAJOR.$PACKAGE_VERSION_MINOR.$PACKAGE_VERSION_RELEASE"
LIBBLKID_DATE="01-Mar-2018"
LIBBLKID_LT_MAJOR=1
LIBBLKID_LT_MINOR=1
LIBBLKID_LT_MICRO=0
LIBBLKID_VERSION_INFO=`expr $LIBBLKID_LT_MAJOR + $LIBBLKID_LT_MINOR`:$LIBBLKID_LT_MICRO:$LIBBLKID_LT_MINOR

dnl libuuid version
LIBUUID_VERSION="$PACKAGE_VERSION_MAJOR.$PACKAGE_VERSION_MINOR.$PACKAGE_VERSION_RELEASE"
LIBUUID_LT_MAJOR=1
LIBUUID_LT_MINOR=3
LIBUUID_LT_MICRO=0
LIBUUID_VERSION_INFO=`expr $LIBUUID_LT_MAJOR + $LIBUUID_LT_MINOR`:$LIBUUID_LT_MICRO:$LIBUUID_LT_MINOR

dnl libmount version
LIBMOUNT_VERSION="$PACKAGE_VERSION_MAJOR.$PACKAGE_VERSION_MINOR.$PACKAGE_VERSION_RELEASE"
LIBMOUNT_LT_MAJOR=1
LIBMOUNT_LT_MINOR=1
LIBMOUNT_LT_MICRO=0
LIBMOUNT_VERSION_INFO=`expr $LIBMOUNT_LT_MAJOR + $LIBMOUNT_LT_MINOR`:$LIBMOUNT_LT_MICRO:$LIBMOUNT_LT_MINOR

dnl libsmartcols version
LIBSMARTCOLS_VERSION="$PACKAGE_VERSION_MAJOR.$PACKAGE_VERSION_MINOR.$PACKAGE_VERSION_RELEASE"
LIBSMARTCOLS_LT_MAJOR=1
LIBSMARTCOLS_LT_MINOR=1
LIBSMARTCOLS_LT_MICRO=0
LIBSMARTCOLS_VERSION_INFO=`expr $LIBSMARTCOLS_LT_MAJOR + $LIBSMARTCOLS_LT_MINOR`:$LIBSMARTCOLS_LT_MICRO:$LIBSMARTCOLS_LT_MINOR

dnl libfdisk version
LIBFDISK_VERSION="$PACKAGE_VERSION_MAJOR.$PACKAGE_VERSION_MINOR.$PACKAGE_VERSION_RELEASE"
LIBFDISK_LT_MAJOR=1
LIBFDISK_LT_MINOR=1
LIBFDISK_LT_MICRO=0
LIBFDISK_VERSION_INFO=`expr $LIBFDISK_LT_MAJOR + $LIBFDISK_LT_MINOR`:$LIBFDISK_LT_MICRO:$LIBFDISK_LT_MINOR

# Check whether exec_prefix=/usr:
AS_CASE([$exec_prefix:$prefix],
[NONE:NONE | NONE:/usr | /usr:*],
  [AC_MSG_NOTICE([Default --exec-prefix detected.])
   AS_CASE([$bindir],  ['${exec_prefix}/bin'],  [bindir=/bin;   AC_MSG_NOTICE([  --bindir defaults to /bin])  ])
   AS_CASE([$sbindir], ['${exec_prefix}/sbin'], [sbindir=/sbin; AC_MSG_NOTICE([  --sbindir defaults to /sbin])])
   AS_CASE([$libdir],  ['${exec_prefix}/lib'],  [libdir=/lib;   AC_MSG_NOTICE([  --libdir defaults to /lib])  ])
  ]
)


# default for old versions without $runstatedir
AS_IF([test x"$runstatedir" = x], [runstatedir='${localstatedir}/run'])

# our default if $localstatedir unchanged
AS_CASE([$localstatedir:$runstatedir],
 [NONE:'${localstatedir}/run' | /var:'${localstatedir}/run' | NONE:'/run' ],
   [runstatedir=/run; AC_MSG_NOTICE([  --runstatedir defaults to /run])]
)

AC_SUBST([runstatedir])


# The original default values of {bin,sbin,lib}dir
usrbin_execdir='${exec_prefix}/bin'
AC_SUBST([usrbin_execdir])

usrsbin_execdir='${exec_prefix}/sbin'
AC_SUBST([usrsbin_execdir])

AS_CASE([$libdir],
 ['${exec_prefix}/'* | '${prefix}/'* | /usr/* | "${prefix}"/* ],
   [usrlib_execdir=$libdir],
 [usrlib_execdir='${exec_prefix}'$libdir]
)
AC_SUBST([usrlib_execdir])


AM_PROG_CC_C_O
AC_PROG_MKDIR_P
AC_PROG_CC_STDC
AC_PROG_YACC
AC_CANONICAL_HOST
AC_C_CONST
AC_C_VOLATILE
AC_C_BIGENDIAN

dnl Compiler warnings
UL_WARN_ADD([-fno-common])
UL_WARN_ADD([-Wall])
UL_WARN_ADD([-Werror=sequence-point])
UL_WARN_ADD([-Wextra])
UL_WARN_ADD([-Wextra-semi])
UL_WARN_ADD([-Wembedded-directive])
UL_WARN_ADD([-Wmissing-declarations])
UL_WARN_ADD([-Wmissing-parameter-type])
UL_WARN_ADD([-Wmissing-prototypes])
UL_WARN_ADD([-Wno-missing-field-initializers])
UL_WARN_ADD([-Wredundant-decls])
UL_WARN_ADD([-Wsign-compare])
UL_WARN_ADD([-Wtype-limits])
UL_WARN_ADD([-Wuninitialized])
UL_WARN_ADD([-Wunused-but-set-parameter])
UL_WARN_ADD([-Wunused-but-set-variable])
UL_WARN_ADD([-Wunused-parameter])
UL_WARN_ADD([-Wunused-result])
UL_WARN_ADD([-Wunused-variable])
UL_WARN_ADD([-Wnested-externs])
UL_WARN_ADD([-Wpointer-arith])
UL_WARN_ADD([-Wstrict-prototypes])
UL_WARN_ADD([-Wformat-security])
UL_WARN_ADD([-Wimplicit-function-declaration])
AC_SUBST([WARN_CFLAGS])

UL_WARN_ADD([-Wno-clobbered], [BSD_WARN_CFLAGS])
AC_SUBST([BSD_WARN_CFLAGS])
UL_WARN_ADD([-Wno-unused-parameter], [NO_UNUSED_WARN_CFLAGS])
AC_SUBST([NO_UNUSED_WARN_CFLAGS])


AC_ARG_ENABLE([asan],
  AS_HELP_STRING([--enable-asan], [compile with Address Sanitizer]),
  [], [enable_asan=no]
)
AS_IF([test "x$enable_asan" = xyes], [
  UL_WARN_ADD([-fsanitize=address])
])



dnl libtool-2
LT_INIT

dnl check supported linker flags
AX_CHECK_VSCRIPT

m4_ifndef([PKG_PROG_PKG_CONFIG],
  [m4_fatal([Could not locate the pkg-config autoconf
    macros. These are usually located in /usr/share/aclocal/pkg.m4.
    If your macros are in a different location, try setting the
    environment variable AL_OPTS="-I/other/macro/dir" before running
    ./autogen.sh or autoreconf again.])])
PKG_PROG_PKG_CONFIG

GTK_DOC_CHECK([1.10])
AC_PATH_PROG([XSLTPROC], [xsltproc])

linux_os=no
bsd_os=no
AS_CASE([${host_os}],
  [*linux*],
     [linux_os=yes],
  [*darwin*],
     [darwin_os=yes],
  [*bsd*],
     [bsd_os=yes])
AM_CONDITIONAL([LINUX], [test "x$linux_os" = xyes])
AM_CONDITIONAL([DARWIN], [test "x$darwin_os" = xyes])
AM_CONDITIONAL([BSD], [test "x$bsd_os" = xyes])

AS_IF([test  "x$darwin_os" = xyes], [
  AC_DEFINE([_DARWIN_C_SOURCE], [1], [Enable MAP_ANON in sys/mman.h on Mac OS X])
])

dnl define ARCH_<NAME> conditionals
UL_SET_ARCH([I86], [i?86-*])
UL_SET_ARCH([86_64], [x86_64*])
UL_SET_ARCH([IA64], [ia64*])
UL_SET_ARCH([S390], [s390*])
UL_SET_ARCH([SPARC], [sparc*])
UL_SET_ARCH([PPC], [ppc*|powerpc*])
UL_SET_ARCH([M68K], [m68*])
UL_SET_ARCH([MIPS], [mips*])
UL_SET_ARCH([HPPA], [hppa*|parisc*])

AC_SYS_LARGEFILE
AC_HEADER_ASSERT
AC_STRUCT_TIMEZONE

dnl Don't forget to maintain alternatively allowed versions in autogen.sh!
AM_GNU_GETTEXT_VERSION([0.18.3])
AM_GNU_GETTEXT([external])

AS_IF([test -d "$srcdir/po"], [
  ALL_LINGUAS=`cd $srcdir/po > /dev/null && echo *.po | sed 's/\.po//g'`
], [
  ALL_LINGUAS="af am ar as be bg bn_IN bn ca cs cy da de el en_GB es et eu_ES fa fi fr gl gu he hi hr hu hy id is it ja ka kn ko ku lo lt lv mk ml mr ms my nb nl nn no nso or pa pl pt_BR pt ro ru si sk sl sq sr@Latn sr sv ta te th tr uk ur vi zh_CN zh_TW zu"
])

AC_CHECK_HEADERS([linux/compiler.h linux/blkpg.h linux/major.h], [], [], [
#ifdef HAVE_LINUX_COMPILER_H
#include <linux/compiler.h>
#endif
])
AC_CHECK_HEADERS([ \
	asm/io.h \
	err.h \
	errno.h \
	fcntl.h \
	getopt.h \
	inttypes.h \
	lastlog.h \
	libutil.h \
	linux/btrfs.h \
	linux/cdrom.h \
	linux/falloc.h \
	linux/watchdog.h \
	linux/fd.h \
	linux/raw.h \
	linux/tiocl.h \
	linux/version.h \
	linux/securebits.h \
	linux/net_namespace.h \
	locale.h \
	mntent.h \
	net/if.h \
	net/if_dl.h \
	netinet/in.h \
	paths.h \
	pty.h \
	security/pam_appl.h \
	stdint.h \
	stdio_ext.h \
	stdlib.h \
	endian.h \
	byteswap.h \
	sys/endian.h \
	sys/disk.h \
	sys/disklabel.h \
	sys/file.h \
	sys/io.h \
	sys/ioccom.h \
	sys/ioctl.h \
	sys/mkdev.h \
	sys/mount.h \
	sys/param.h \
	sys/prctl.h \
	sys/resource.h \
	sys/signalfd.h \
	sys/socket.h \
	sys/sockio.h \
	sys/stat.h \
	sys/sysmacros.h \
	sys/swap.h \
	sys/syscall.h \
	sys/time.h \
	sys/timex.h \
	sys/ttydefaults.h \
	sys/types.h \
	sys/ucred.h \
	sys/un.h \
	unistd.h \
	shadow.h \
	utmp.h \
	utmpx.h \
])

AC_CHECK_HEADERS([linux/gsmmux.h ], [], [],
 [#ifdef LINUX_GSMMUX_H
   # include <linux/gsmmux.h>
   #endif
])

AC_CHECK_HEADERS([security/pam_misc.h],
		[AM_CONDITIONAL([HAVE_LINUXPAM], [true])],
		[AM_CONDITIONAL([HAVE_LINUXPAM], [false])], [
#ifdef HAVE_SECURITY_PAM_APPL_H
#include <security/pam_appl.h>
#endif
])

AC_CHECK_HEADERS([linux/blkzoned.h])

AC_CHECK_HEADERS([security/openpam.h], [], [], [
#ifdef HAVE_SECURITY_PAM_APPL_H
#include <security/pam_appl.h>
#endif
])

AC_CHECK_HEADERS([langinfo.h],
		[AM_CONDITIONAL([HAVE_LANGINFO], [true])],
		[AM_CONDITIONAL([HAVE_LANGINFO], [false])])


AC_MSG_CHECKING([whether langinfo.h defines ALTMON_x constants])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#include <langinfo.h>
]], [[
	char *str;
	str = nl_langinfo (ALTMON_1);
	str = nl_langinfo (ALTMON_2);
	str = nl_langinfo (ALTMON_3);
	str = nl_langinfo (ALTMON_4);
	str = nl_langinfo (ALTMON_5);
	str = nl_langinfo (ALTMON_6);
	str = nl_langinfo (ALTMON_7);
	str = nl_langinfo (ALTMON_8);
	str = nl_langinfo (ALTMON_9);
	str = nl_langinfo (ALTMON_10);
	str = nl_langinfo (ALTMON_11);
	str = nl_langinfo (ALTMON_12);
]])], [
	AC_MSG_RESULT([yes])
	AC_DEFINE([HAVE_LANGINFO_ALTMON], [1],
		[Define if langinfo.h defines ALTMON_x constants])
], [
	AC_MSG_RESULT([no])
])


AC_MSG_CHECKING([whether langinfo.h defines _NL_ABALTMON_x constants])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#include <langinfo.h>
]], [[
	char *str;
	str = nl_langinfo (_NL_ABALTMON_1);
	str = nl_langinfo (_NL_ABALTMON_2);
	str = nl_langinfo (_NL_ABALTMON_3);
	str = nl_langinfo (_NL_ABALTMON_4);
	str = nl_langinfo (_NL_ABALTMON_5);
	str = nl_langinfo (_NL_ABALTMON_6);
	str = nl_langinfo (_NL_ABALTMON_7);
	str = nl_langinfo (_NL_ABALTMON_8);
	str = nl_langinfo (_NL_ABALTMON_9);
	str = nl_langinfo (_NL_ABALTMON_10);
	str = nl_langinfo (_NL_ABALTMON_11);
	str = nl_langinfo (_NL_ABALTMON_12);
]])], [
	AC_MSG_RESULT([yes])
	AC_DEFINE([HAVE_LANGINFO_NL_ABALTMON], [1],
		[Define if langinfo.h defines _NL_ABALTMON_x constants])
], [
	AC_MSG_RESULT([no])
])


dnl Convert some ac_cv_header_* variables to have_*
dnl
have_linux_version_h=$ac_cv_header_linux_version_h
have_linux_blkzoned_h=$ac_cv_header_linux_blkzoned_h
have_linux_btrfs_h=$ac_cv_header_linux_btrfs_h
have_linux_raw_h=$ac_cv_header_linux_raw_h
have_linux_securebits_h=$ac_cv_header_linux_securebits_h
have_linux_watchdog_h=$ac_cv_header_linux_watchdog_h
have_security_pam_appl_h=$ac_cv_header_security_pam_appl_h
have_security_pam_misc_h=$ac_cv_header_security_pam_misc_h
have_security_openpam_h=$ac_cv_header_security_openpam_h
have_shadow_h=$ac_cv_header_shadow_h
have_sys_signalfd_h=$ac_cv_header_sys_signalfd_h
have_utmpx_h=$ac_cv_header_utmpx_h

AS_CASE([$linux_os:$have_linux_version_h],
  [yes:no],
    [AC_MSG_ERROR([kernel headers required on Linux])]
)

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <time.h>
#include <unistd.h>
]], [[
    int a = 0;
    struct tm *tm = localtime(0);
    if (a == -1)  /* false */
	sleep(tm->tm_gmtoff);
]])],
[AC_DEFINE([HAVE_TM_GMTOFF], [1], [Does struct tm have a field tm_gmtoff?])
])

AC_CHECK_MEMBERS([struct termios.c_line],,,
    [[#include <termios.h>]])

AC_CHECK_MEMBERS([struct stat.st_mtim.tv_nsec],,,
	[#include <sys/stat.h>])

AC_CHECK_DECLS([_NL_TIME_WEEK_1STDAY],[],[],[[#include <langinfo.h>]])

AC_CHECK_DECL([llseek],
	[AC_DEFINE([HAVE_LLSEEK_PROTOTYPE], [1],
			[Define to 1 if have llseek prototype])],
	[],
	[#include <unistd.h>])

AC_CHECK_DECL([lseek64],
	[AC_DEFINE([HAVE_LSEEK64_PROTOTYPE], [1],
			[Define to 1 if have lseek64 prototype])],
	[],
	[#define _LARGEFILE_SOURCE
	 #define _LARGEFILE64_SOURCE
	 #include <unistd.h>])

AC_CHECK_DECL([environ],
	[AC_DEFINE([HAVE_ENVIRON_DECL], [1],
		[Define to 1 if have **environ prototype])],
)

AC_CHECK_DECL([strsignal],
	[AC_DEFINE([HAVE_STRSIGNAL_DECL], [1],
		[Define to 1 if have strsignal function prototype])],
)

AC_CHECK_DECL([TIOCGLCKTRMIOS],
	      [have_tiocglcktrmios=yes], [have_tiocglcktrmios=no],
              [#include <sys/ioctl.h>])
AC_CHECK_DECL([SOCK_CLOEXEC],
	      [have_sock_cloexec=yes], [have_sock_cloexec=no],
	      [#include <sys/types.h>
               #include <sys/socket.h>])
AC_CHECK_DECL([SOCK_NONBLOCK],
	      [have_sock_nonblock=yes], [have_sock_nonblock=no],
	      [#include <sys/types.h>
               #include <sys/socket.h>])
AC_CHECK_DECL([SO_PASSCRED],
	      [have_so_passcred=yes], [have_so_passcred=no],
	      [#include <sys/types.h>
               #include <sys/socket.h>])

AC_CHECK_FUNCS([ \
	__fpending \
	secure_getenv \
	__secure_getenv \
	eaccess \
	err \
	errx \
	explicit_bzero \
	fsync \
	utimensat \
	getdomainname \
	getdtablesize \
	getexecname \
	getmntinfo \
	getrandom \
	getrlimit \
	getsgnam \
	inotify_init \
	jrand48 \
	lchown \
	llseek \
	lseek64 \
	mempcpy \
	mkostemp \
	nanosleep \
	ntp_gettime \
	personality \
	posix_fadvise \
	prctl \
	qsort_r \
	rpmatch \
	scandirat \
	setprogname \
	setresgid \
	setresuid \
	sched_setattr \
	sched_setscheduler \
	sigqueue \
	srandom \
	strnchr \
	strndup \
	strnlen \
	sysconf \
	sysinfo \
	timegm \
	usleep \
	vwarnx \
	warn \
	warnx \
])
AC_FUNC_FSEEKO

AC_CHECK_FUNCS([openat fstatat unlinkat], [have_openat=yes], [have_openat=no])
AC_CHECK_FUNCS([ioperm iopl], [have_io=yes])
AC_CHECK_FUNCS([futimens], [have_futimens=yes])
AC_CHECK_FUNCS([inotify_init1], [have_inotify_init1=yes])
AC_CHECK_FUNCS([open_memstream], [have_open_memstream=yes],[have_open_memstream=no])
AC_CHECK_FUNCS([reboot], [have_reboot=yes],[have_reboot=no])
AC_CHECK_FUNCS([updwtmpx updwtmpx], [have_gnu_utmpx=yes], [have_gnu_utmpx=no])
AC_CHECK_FUNCS([getusershell], [have_getusershell=yes],[have_getusershell=no])

AM_CONDITIONAL([HAVE_OPENAT], [test "x$have_openat" = xyes])


AC_CHECK_FUNCS([isnan], [],
	[AC_CHECK_LIB([m], [isnan], [MATH_LIBS="-lm"])]
	[AC_CHECK_LIB([m], [__isnan], [MATH_LIBS="-lm"])]
)
AC_SUBST([MATH_LIBS])


dnl lib/mononotic.c may require -lrt
AC_CHECK_FUNCS([clock_gettime], [],
	[AC_CHECK_LIB([rt], [clock_gettime], [REALTIME_LIBS="-lrt"])]
)

have_timer="no"
AC_CHECK_FUNCS([timer_create],
	[have_timer="yes"],
	[AC_CHECK_LIB([rt], [timer_create], [
		have_timer="yes"
		REALTIME_LIBS="-lrt"
	],[
		AC_SEARCH_LIBS([timer_create], [rt], [
			AC_MSG_RESULT(yes)
			have_timer="yes"
			REALTIME_LIBS="-lrt -lpthread"
		],[], [-lpthread]
		)
		])]
)

AC_SUBST([REALTIME_LIBS])


AC_CHECK_LIB([rtas], [rtas_get_sysparm], [
	RTAS_LIBS="-lrtas"
	AC_DEFINE_UNQUOTED([HAVE_LIBRTAS], [1], [Define if librtas exists]), [],
])
AC_SUBST([RTAS_LIBS])


AC_CHECK_MEMBER([struct sockaddr.sa_len],
		AC_DEFINE_UNQUOTED([HAVE_SA_LEN], [1], [Define if struct sockaddr contains sa_len]), [],
	[#include <sys/types.h>
	 #include <sys/socket.h>])

SOCKET_LIBS=
AC_SEARCH_LIBS([socket], [socket],
	[AS_IF([test x"$ac_cv_search_socket" != x"none required"],
		[SOCKET_LIBS="$SOCKET_LIBS -lsocket"])
])
AC_SUBST([SOCKET_LIBS])


have_dirfd=no
AC_CHECK_FUNCS([dirfd], [have_dirfd=yes], [have_dirfd=no])
AS_IF([test x"$have_dirfd" = xno], [
	AC_CHECK_DECLS([dirfd],
		[have_dirfd=yes], [have_dirfd=no],
		[#include <sys/types.h>
		 #include <dirent.h>])
])

have_ddfd=no
AS_IF([test x"$have_dirfd" = xno], [
	AC_CHECK_MEMBERS([DIR.dd_fd],
		[have_ddfd=yes], [have_ddfd=no],
		[#include <sys/types.h>
		 #include <dirent.h>])
])

AS_CASE([$have_dirfd:$have_ddfd],
  [no:no],
    [AC_MSG_ERROR([cannot find a method to get filedescriptor of directory])]
)


AC_MSG_CHECKING([whether program_invocation_short_name is defined])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#include <errno.h>
]], [[
	program_invocation_short_name = "test";
]])], [
	AC_MSG_RESULT([yes])
	AC_DEFINE([HAVE_PROGRAM_INVOCATION_SHORT_NAME], [1],
		[Define if program_invocation_short_name is defined])
], [
	AC_MSG_RESULT([no])
])


AC_MSG_CHECKING([whether __progname is defined])
AC_LINK_IFELSE([AC_LANG_PROGRAM([extern char *__progname;],
	   [if (*__progname == 0) return 1;])],
	   AC_DEFINE([HAVE___PROGNAME], [1], [Define if __progname is defined])
	   AC_MSG_RESULT([yes]),
	   AC_MSG_RESULT([no]))

dnl Static compilation
m4_define([UL_STATIC_PROGRAMS], [losetup, mount, umount, fdisk, sfdisk, blkid, nsenter, unshare])

AC_ARG_ENABLE([static-programs],
  [AS_HELP_STRING([--enable-static-programs=LIST],
      [link static the programs in LIST (comma-separated,
      supported for ]m4_defn([UL_STATIC_PROGRAMS])[)])])

AS_CASE([$enable_static_programs],
  [yes],
    [enable_static_programs=m4_quote(UL_STATIC_PROGRAMS)],
  [no],
    [enable_static_programs=]
)

dnl Set all the individual AM_CONDITIONALs
m4_foreach([UL_PRG], m4_defn([UL_STATIC_PROGRAMS]), [
  AS_CASE([,$enable_static_programs,],
   [*,UL_PRG,*], [static_[]UL_PRG=yes]
  )
  AS_IF([test "x$static_[]UL_PRG" = xyes], [AC_MSG_NOTICE([enable static build: UL_PRG.])])
  AM_CONDITIONAL([HAVE_STATIC_]m4_toupper(UL_PRG),
    [test "x$static_[]UL_PRG" = xyes])
])


AC_ARG_ENABLE([all-programs],
  AS_HELP_STRING([--disable-all-programs], [disable everything, might be overridden by --enable-<name>]),
  [], [enable_all_programs=undefined]
)

AS_CASE([$enable_all_programs],
  [yes], [AC_MSG_WARN([force to build all programs by default])
          ul_default_estate=check],
  [no],  [AC_MSG_WARN([disable all programs by default])
          ul_default_estate=no]
)


AX_CHECK_TLS

AC_DEFUN([UL_SCANF_TYPE_MODIFIER], [dnl
# include <stdio.h>
# include <stdlib.h>
int main()
{
	int i;
	int rc = 1;
	char *s;
	i = sscanf("x", $1, &s);
	if (i == 1  && *s == 'x')
		rc = 0;
	free(s);
	return rc;
}])

AC_CACHE_VAL([scanf_cv_alloc_modifier],
  AC_RUN_IFELSE([AC_LANG_SOURCE([UL_SCANF_TYPE_MODIFIER(["%ms"])])],
    [scanf_cv_alloc_modifier=ms],
    AC_RUN_IFELSE([AC_LANG_SOURCE([UL_SCANF_TYPE_MODIFIER(["%as"])])],
      [scanf_cv_alloc_modifier=as],
      [scanf_cv_alloc_modifier=no]
    )
    ,

    [AC_COMPILE_IFELSE([AC_LANG_SOURCE([
     #include <stdio.h>
     #include <unistd.h>

     #if defined(__GLIBC__) && !defined(__UCLIBC__)

     #if !(__GLIBC_PREREQ(2, 7))
     #error %m is not available
     #endif

     #elif defined(_POSIX_VERSION)

     #if _POSIX_VERSION < 200809L
     #error %m is not available
     #endif

     #else
     #error Your C-library is not supported.
     #endif
     ])],
    [scanf_cv_alloc_modifier=ms],
    [scanf_cv_alloc_modifier=no])]
  )
)

AC_MSG_CHECKING([scanf string alloc modifiers])
AS_CASE([$scanf_cv_alloc_modifier],
  [ms],
    [AC_MSG_RESULT([(%ms) yes])
     AC_DEFINE([HAVE_SCANF_MS_MODIFIER], [1], [scanf %ms modifier])
     have_scanf_alloc_modifier=yes],
  [as],
    [AC_MSG_RESULT([(%as) yes])
     have_scanf_alloc_modifier=yes
     AC_DEFINE([HAVE_SCANF_AS_MODIFIER], [1], [scanf %as modifier])],
  [AC_MSG_RESULT([no])
   have_scanf_alloc_modifier=no]
)


AC_ARG_WITH([util], AS_HELP_STRING([--without-util], [compile without libutil]),
  [], [with_util=auto]
)
AS_IF([test "x$with_util" = xno], [
  AM_CONDITIONAL([HAVE_UTIL], [false])
  have_util=no
], [
  UL_CHECK_LIB([util], [openpty])
])


AC_CHECK_TYPES([union semun], [], [], [[
#include <sys/sem.h>
]])
AC_CHECK_TYPES([loff_t])


AC_ARG_ENABLE([widechar],
  AS_HELP_STRING([--disable-widechar], [do not compile wide character support]),
  [], [enable_widechar=check]
)
UL_BUILD_INIT([widechar])
UL_REQUIRES_COMPILE([widechar], [[
  #include <wchar.h>
  #include <wctype.h>
  #include <stdio.h>
  ]], [[
    wchar_t wc;
    wint_t w;
    w = fgetwc(stdin);
    if (w == WEOF) exit(1);
    wc = w;
    fputwc(wc,stdout);
  ]],
  [wchar_t support])

AS_IF([test "x$build_widechar" = xyes ], [
  AC_DEFINE([HAVE_WIDECHAR], [1], [Do we have wide character support?])
])


AC_CHECK_TYPES([cpu_set_t], [have_cpu_set_t=yes], [], [[
#include <sched.h>
]])

AM_CONDITIONAL([HAVE_CPU_SET_T], [test "x$have_cpu_set_t" = xyes])

AC_CHECK_TYPES([sighandler_t], [], [], [[
#include <signal.h>
]])

AC_CHECK_DECLS([CPU_ALLOC], [], [], [[
#include <sched.h>
]])

# on Solaris, you can't mix and match standards, since we use c99
# aparently at this stage, XOPEN_SOURCE will conflict.  As workaround,
# check for crypt.h and use that without XOPEN_SOURCE.
AC_CHECK_HEADERS([crypt.h])
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#ifdef HAVE_CRYPT_H
#include <crypt.h>
#else
#define _XOPEN_SOURCE
#include <unistd.h>
#endif
]], [[
char *c = crypt("abc","pw");
]])],[],[
  LIBS="$LIBS -lcrypt"
  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
  #ifdef HAVE_CRYPT_H
  #include <crypt.h>
  #else
  #define _XOPEN_SOURCE
  #include <unistd.h>
  #endif
  ]], [[
  char *c = crypt("abc","pw");
  ]])],[
  AC_DEFINE([HAVE_LIBCRYPT], [1], [Do we need -lcrypt?])
  have_libcrypt=yes
  ],[
  AC_MSG_ERROR([crypt() is not available])
  ])
])
AM_CONDITIONAL([HAVE_LIBCRYPT], [test "x$have_libcrypt" = xyes])


AC_ARG_WITH([selinux],
  AS_HELP_STRING([--with-selinux], [compile with SELinux support]),
  [], [with_selinux=no]
)

AS_IF([test "x$with_selinux" = xno], [
  AM_CONDITIONAL([HAVE_SELINUX], [false])
], [
  PKG_CHECK_MODULES([SELINUX], [libselinux >= 2.0],
	[AC_DEFINE([HAVE_LIBSELINUX], [1], [Define if SELinux is available])
	 UL_PKG_STATIC([SELINUX_LIBS_STATIC], [libselinux])
	 AM_CONDITIONAL([HAVE_SELINUX], [true])
	 have_selinux=yes],
	[have_selinux=no])

  AS_CASE([$with_selinux:$have_selinux],
    [yes:no], [AC_MSG_ERROR([SELinux selected but libselinux not found or too old])]
  )

  AS_IF([test "x$have_selinux" = xyes], [
    UL_SET_FLAGS([], [], [$SELINUX_LIBS])
    # This function is missing in old libselinux 1.xx versions
    AC_CHECK_FUNCS([security_get_initial_context])
    UL_RESTORE_FLAGS
  ])
])
AC_SUBST([SELINUX_LIBS])
AC_SUBST([SELINUX_LIBS_STATIC])


AC_ARG_WITH([audit],
  AS_HELP_STRING([--with-audit], [compile with audit support]),
  [], [with_audit=no]
)

AS_IF([test "x$with_audit" = xno], [
  AM_CONDITIONAL([HAVE_AUDIT], [false])
], [
  UL_CHECK_LIB([audit], [audit_log_user_message])
  AS_CASE([$with_audit:$have_audit],
    [yes:no],
      [AC_MSG_ERROR([Audit selected but libaudit not found (or does not support audit_log_user_message())])]
  )
])

AC_ARG_WITH([udev], AS_HELP_STRING([--without-udev], [compile without udev support]),
  [], [with_udev=auto]
)

AS_IF([test "x$with_udev" = xno], [
  AM_CONDITIONAL([HAVE_UDEV], [false])
], [
  UL_CHECK_LIB([udev], [udev_new])
  AS_CASE([$with_udev:$have_udev],
    [yes:no],
      [AC_MSG_ERROR([udev selected but libudev not found])]
  )
])


dnl wide-char ncurses
AC_ARG_WITH([ncursesw],
  AS_HELP_STRING([--with-ncursesw], [build with wide-char ncurses, enabled by default]),
  [], [with_ncursesw=auto]
)
have_ncursesw=no
have_ncursesw_header=no
AS_IF([test "x$with_ncursesw" != xno], [
  UL_NCURSES_CHECK([ncursesw])
  AS_IF([test "x$have_ncursesw" = xyes], [
    AC_CHECK_HEADERS([ncursesw/ncurses.h], [have_ncursesw_header=yes])
    AC_CHECK_HEADERS([ncursesw/term.h])

    # Define HAVE_NCURSES_H only if check for HAVE_NCURSESW_NCURSES_H is
    # unsuccessful to avoid too many *_H permitations in config.h
    AS_IF([test "x$have_ncursesw_header" = xno], [
	   AC_CHECK_HEADERS([ncurses.h], [have_ncursesw_header=yes])
	   AC_CHECK_HEADERS([term.h])
    ])
    AS_IF([test "x$have_ncursesw_header" = xno], [have_ncursesw=no])
  ])
  AS_IF([test "x$have_ncursesw" = xyes], [
    CURSES_LIB_NAME="ncursesw"
    AC_DEFINE([HAVE_LIBNCURSESW], [1], [Define if ncursesw library available])
  ])
])
AS_CASE([$with_ncursesw:$have_ncursesw],
  [yes:no], [AC_MSG_ERROR([ncursesw selected, but library not found])])


dnl non-wide ncurses
AC_ARG_WITH([ncurses],
  AS_HELP_STRING([--with-ncurses], [build with non-wide ncurses, disabled by default]),
  [], [with_ncurses=auto]
)
have_ncurses=no
have_ncurses_header=no
AS_CASE([$with_ncurses:$build_widechar],
  [yes:yes], [AC_MSG_ERROR([wide-char support enabled, but non-wide ncurses selects])])

AS_IF([test "x$have_ncursesw" = xno -a "x$with_ncurses" != xno ], [
  UL_NCURSES_CHECK([ncurses])
  AS_IF([test "x$have_ncurses" = xyes], [
    AC_CHECK_HEADERS([ncurses/ncurses.h], [have_ncurses_header=yes])
    AC_CHECK_HEADERS([ncurses/term.h])

    # Define HAVE_NCURSES_H only if check for HAVE_NCURSES_NCURSES_H is
    # unsuccessful to avoid too many *_H permitations in config.h
    AS_IF([test "x$have_ncurses_header" = xno], [
	   AC_CHECK_HEADERS([ncurses.h], [have_ncurses_header=yes])
	   AC_CHECK_HEADERS([term.h])
    ])
    AS_IF([test "x$have_ncurses_header" = xno], [have_ncurses=no])
  ])
  AS_IF([test "x$have_ncurses" = xyes], [
    CURSES_LIB_NAME="ncurses"
    AC_DEFINE([HAVE_LIBNCURSES], [1], [Define if ncurses library available])
  ])
])
AS_CASE([$with_ncurses:$have_ncurses],
  [yes:no], [AC_MSG_ERROR([ncurses selected, but library not found])])

AC_SUBST([NCURSES_CFLAGS])
AC_SUBST([NCURSES_LIBS])
AM_CONDITIONAL([HAVE_NCURSES], [test "x$have_ncursesw" = xyes -o  "x$have_ncurses" = xyes])


AC_ARG_WITH([slang],
  AS_HELP_STRING([--with-slang], [compile cfdisk with slang rather than ncurses]),
  [], [with_slang=no]
)
have_slang=no
AS_IF([test "x$with_slang" = xyes], [
  AC_CHECK_HEADERS([slang.h slang/slang.h])
  AC_CHECK_HEADERS([slcurses.h slang/slcurses.h],
		   [have_slang=yes], [], [
#ifdef HAVE_SLANG_H
#include <slang.h>
#elif defined(HAVE_SLANG_SLANG_H)
#include <slang/slang.h>
#endif
])
  AS_IF([test "x$have_slang" = xno], [
    AC_MSG_ERROR([slang selected but slcurses.h not found])],
    [CURSES_LIB_NAME=slang
  ])
])
AM_CONDITIONAL([HAVE_SLANG], [test "x$have_slang" = xyes])


AS_IF([test "x$have_slang" = xyes -o "x$have_ncursesw" = xyes -o "x$have_ncurses" = xyes], [
	AC_CHECK_LIB([$CURSES_LIB_NAME], use_default_colors, [
		     AC_DEFINE(HAVE_USE_DEFAULT_COLORS, 1,
			       [Define if curses library has the use_default_colors().])
	])
	AC_CHECK_LIB([$CURSES_LIB_NAME], resizeterm, [
		     AC_DEFINE(HAVE_RESIZETERM, 1,
			       [Define if curses library has the resizeterm().])
	])
])


AC_ARG_WITH([tinfo], AS_HELP_STRING([--without-tinfo], [compile without libtinfo]),
  [], [with_tinfo=auto]
)
have_tinfo=no
have_tinfow=no
AS_IF([test "x$with_tinfo" != xno], [
  AS_IF([test "x$have_ncursesw" = xyes], [
    UL_TINFO_CHECK([tinfow])
  ])
  AS_IF([test "x$have_tinfow" = xno], [
    UL_TINFO_CHECK([tinfo])
  ])
])
AC_SUBST([TINFO_LIBS])
AC_SUBST([TINFO_LIBS_STATIC])
AC_SUBST([TINFO_CFLAGS])
AM_CONDITIONAL([HAVE_TINFO], [test "x$have_tinfo" = xyes -o "x$have_tinfow" = xyes])
AS_IF([test "x$have_tinfo" = xyes -o "x$have_tinfow" = xyes], [
  AC_DEFINE(HAVE_LIBTINFO, 1, [Define if libtinfo or libtinfow available.])
])


AC_ARG_WITH([readline],
  AS_HELP_STRING([--with-readline], [compile with GNU Readline support]),
  [], [with_readline=auto]
)

AS_IF([test "x$with_readline" = xno], [
  AM_CONDITIONAL([HAVE_READLINE], [false])
], [
  UL_CHECK_LIB([readline], [readline])
  AS_CASE([$with_readline:$have_readline],
    [yes:no],
      [AC_MSG_ERROR([readline selected but libreadline not found ])],
    [*:yes],
      [READLINE_LIBS="-lreadline"
       READLINE_LIBS_STATIC="-lreadline $TINFO_LIBS_STATIC"]
  )
])
AC_SUBST([READLINE_LIBS])
AC_SUBST([READLINE_LIBS_STATIC])


AC_ARG_WITH([utempter],
  AS_HELP_STRING([--with-utempter], [compile script(1) with libutempter]),
  [], [with_utempter=no]
)

AS_IF([test "x$with_utempter" = xyes], [
  UL_CHECK_LIB([utempter], [utempter_add_record])
  AS_IF([test "x$have_utempter" = xno], [
    AC_MSG_ERROR([utempter selected but libutempter not found])
  ])
], [
  AM_CONDITIONAL([HAVE_UTEMPTER], [false])
])


dnl
dnl libuuid
dnl
AC_ARG_ENABLE([libuuid],
  AS_HELP_STRING([--disable-libuuid], [do not build libuuid and uuid utilities]),
  [], [UL_DEFAULT_ENABLE([libuuid], [yes])]
)
UL_BUILD_INIT([libuuid])
AC_SUBST([LIBUUID_VERSION])
AC_SUBST([LIBUUID_VERSION_INFO])
AM_CONDITIONAL(BUILD_LIBUUID, test "x$build_libuuid" = xyes)

AC_ARG_ENABLE([libuuid-force-uuidd],
  AS_HELP_STRING([--enable-libuuid-force-uuidd], [support uuidd even though the daemon is not built]),
  [], [enable_libuuid_force_uuidd=no]
)

AS_IF([test "x$build_libuuid" = xyes], [
  AC_DEFINE(HAVE_LIBUUID, 1, [Define to 1 if you have the -luuid.])
])

dnl
dnl libblkid
dnl
AC_ARG_ENABLE([libblkid],
  AS_HELP_STRING([--disable-libblkid], [do not build libblkid and many related utilities]),
  [], [UL_DEFAULT_ENABLE([libblkid], [check])]
)
UL_BUILD_INIT([libblkid])
UL_REQUIRES_HAVE([libblkid], [openat], [openat functions])
AC_SUBST([LIBBLKID_DATE])
AC_SUBST([LIBBLKID_VERSION])
AC_SUBST([LIBBLKID_VERSION_INFO])
AC_DEFINE_UNQUOTED([LIBBLKID_VERSION], ["$LIBBLKID_VERSION"], [libblkid version string])
AC_DEFINE_UNQUOTED([LIBBLKID_DATE], ["$LIBBLKID_DATE"], [libblkid date string])
AS_IF([test "x$build_libblkid" = xyes], [
  AC_DEFINE([HAVE_LIBBLKID], [1], [Define to 1 if you have the -lblkid.])
])
AM_CONDITIONAL([BUILD_LIBBLKID], [test "x$build_libblkid" = xyes])
AM_CONDITIONAL([BUILD_LIBBLKID_TESTS], [test "x$build_libblkid" = xyes -a "x$enable_static" = xyes])

dnl
dnl libmount
dnl
AC_ARG_ENABLE([libmount],
  AS_HELP_STRING([--disable-libmount], [do not build libmount]),
  [], [UL_DEFAULT_ENABLE([libmount], [check])]
)
UL_BUILD_INIT([libmount])
UL_REQUIRES_BUILD([libmount], [libblkid])
UL_REQUIRES_HAVE([libmount], [scanf_alloc_modifier], [scanf string alloc modifier])
AM_CONDITIONAL([BUILD_LIBMOUNT], [test "x$build_libmount" = xyes])
AM_CONDITIONAL([BUILD_LIBMOUNT_TESTS], [test "x$build_libmount" = xyes -a "x$enable_static" = xyes])
AS_IF([test "x$build_libmount" = xyes], [
	AC_DEFINE(HAVE_LIBMOUNT, 1, [Define if libmount available.])
])

AC_SUBST([LIBMOUNT_VERSION])
AC_SUBST([LIBMOUNT_MAJOR_VERSION], $PACKAGE_VERSION_MAJOR)
AC_SUBST([LIBMOUNT_MINOR_VERSION], $PACKAGE_VERSION_MINOR)
AC_SUBST([LIBMOUNT_PATCH_VERSION], $PACKAGE_VERSION_RELEASE)
AC_SUBST([LIBMOUNT_VERSION_INFO])
AC_DEFINE_UNQUOTED([LIBMOUNT_VERSION], ["$LIBMOUNT_VERSION"], [libmount version string])

AC_ARG_ENABLE([libmount-support-mtab],
  AS_HELP_STRING([--enable-libmount-support-mtab], [support /etc/mtab (default is use /proc/self/mountinfo)]),
  [], [enable_libmount_support_mtab=no]
)

AS_IF([test "x$enable_libmount_support_mtab" = xyes], [
  AC_DEFINE([USE_LIBMOUNT_SUPPORT_MTAB], [1], [Define to 1 if want to support mtab.])
])


dnl
dnl libsmartcols
dnl
AC_ARG_ENABLE([libsmartcols],
  AS_HELP_STRING([--disable-libsmartcols], [do not build libsmartcols]),
  [], [UL_DEFAULT_ENABLE([libsmartcols], [yes])]
)
UL_BUILD_INIT([libsmartcols])
AM_CONDITIONAL([BUILD_LIBSMARTCOLS], [test "x$build_libsmartcols" = xyes])

AC_SUBST([LIBSMARTCOLS_VERSION])
AC_SUBST([LIBSMARTCOLS_VERSION_INFO])
AC_DEFINE_UNQUOTED([LIBSMARTCOLS_VERSION], ["$LIBSMARTCOLS_VERSION"], [libsmartcols version string])


dnl
dnl libfdisk
dnl
AC_ARG_ENABLE([libfdisk],
  AS_HELP_STRING([--disable-libfdisk], [do not build libfdisk]),
  [], [UL_DEFAULT_ENABLE([libfdisk], [check])]
)
UL_BUILD_INIT([libfdisk])
UL_REQUIRES_BUILD([libfdisk], [libuuid])
AM_CONDITIONAL([BUILD_LIBFDISK], [test "x$build_libfdisk" = xyes])
AM_CONDITIONAL([BUILD_LIBFDISK_TESTS], [test "x$build_libfdisk" = xyes -a "x$enable_static" = xyes])

AS_IF([test "x$build_libblkid" = xyes],
  [LIBFDISK_PC_REQUIRES="uuid blkid"],[LIBFDISK_PC_REQUIRES="uuid"])
AC_SUBST([LIBFDISK_PC_REQUIRES])

AC_SUBST([LIBFDISK_VERSION])
AC_SUBST([LIBFDISK_MAJOR_VERSION], $PACKAGE_VERSION_MAJOR)
AC_SUBST([LIBFDISK_MINOR_VERSION], $PACKAGE_VERSION_MINOR)
AC_SUBST([LIBFDISK_PATCH_VERSION], $PACKAGE_VERSION_RELEASE)
AC_SUBST([LIBFDISK_VERSION_INFO])
AC_DEFINE_UNQUOTED([LIBFDISK_VERSION], ["$LIBFDISK_VERSION"], [libfdisk version string])


UL_BUILD_INIT([fdisk], [check])
UL_REQUIRES_HAVE([fdisk], [openat], [openat functions])
UL_REQUIRES_BUILD([fdisk], [libfdisk])
UL_REQUIRES_BUILD([fdisk], [libsmartcols])
AM_CONDITIONAL([BUILD_FDISK], [test "x$build_fdisk" = xyes])


UL_BUILD_INIT([sfdisk], [check])
UL_REQUIRES_HAVE([sfdisk], [openat], [openat functions])
UL_REQUIRES_BUILD([sfdisk], [libfdisk])
UL_REQUIRES_BUILD([sfdisk], [libsmartcols])
AM_CONDITIONAL([BUILD_SFDISK], [test "x$build_sfdisk" = xyes])


UL_BUILD_INIT([cfdisk], [check])
UL_REQUIRES_BUILD([cfdisk], [libfdisk])
UL_REQUIRES_BUILD([cfdisk], [libsmartcols])
UL_REQUIRES_HAVE([cfdisk], [open_memstream], [open_memstream function])
UL_REQUIRES_HAVE([cfdisk], [ncursesw,slang,ncurses], [ncursesw, ncurses or slang library])
AM_CONDITIONAL([BUILD_CFDISK], [test "x$build_cfdisk" = xyes])


AC_ARG_ENABLE([mount],
  AS_HELP_STRING([--disable-mount], [do not build mount(8) and umount(8)]),
  [], [UL_DEFAULT_ENABLE([mount], [check])]
)
UL_BUILD_INIT([mount])
UL_REQUIRES_LINUX([mount])
UL_REQUIRES_BUILD([mount], [libmount])
AM_CONDITIONAL([BUILD_MOUNT], [test "x$build_mount" = xyes])


AC_ARG_ENABLE([losetup],
  AS_HELP_STRING([--disable-losetup], [do not build losetup]),
  [], [UL_DEFAULT_ENABLE([losetup], [check])]
)
UL_BUILD_INIT([losetup])
UL_REQUIRES_LINUX([losetup])
UL_REQUIRES_BUILD([losetup], [libsmartcols])
AM_CONDITIONAL([BUILD_LOSETUP], [test "x$build_losetup" = xyes])

AC_ARG_ENABLE([zramctl],
  AS_HELP_STRING([--disable-zramctl], [do not build zramctl]),
  [], [UL_DEFAULT_ENABLE([zramctl], [check])]
)
UL_BUILD_INIT([zramctl])
UL_REQUIRES_LINUX([zramctl])
UL_REQUIRES_BUILD([zramctl], [libsmartcols])
AM_CONDITIONAL([BUILD_ZRAMCTL], [test "x$build_zramctl" = xyes])

AC_ARG_ENABLE([fsck],
  AS_HELP_STRING([--disable-fsck], [do not build fsck]),
  [], [UL_DEFAULT_ENABLE([fsck], [check])]
)
UL_BUILD_INIT([fsck])
UL_REQUIRES_BUILD([fsck], [libmount])
AM_CONDITIONAL([BUILD_FSCK], [test "x$build_fsck" = xyes])


AC_ARG_ENABLE([partx],
  AS_HELP_STRING([--disable-partx], [do not build addpart, delpart, partx]),
  [], [UL_DEFAULT_ENABLE([partx], [check])]
)
UL_BUILD_INIT([partx])
UL_REQUIRES_LINUX([partx])
UL_REQUIRES_BUILD([partx], [libblkid])
UL_REQUIRES_BUILD([partx], [libsmartcols])
AM_CONDITIONAL([BUILD_PARTX], [test "x$build_partx" = xyes])


AC_ARG_ENABLE([uuidd],
  AS_HELP_STRING([--disable-uuidd], [do not build the uuid daemon]),
  [], [UL_DEFAULT_ENABLE([uuidd], [check])]
)
UL_BUILD_INIT([uuidd])
UL_REQUIRES_BUILD([uuidd], [libuuid])
UL_REQUIRES_HAVE([uuidd], [timer], [timer_create function])
UL_REQUIRES_HAVE([uuidd], [sys_signalfd_h], [sys/signalfd.h header])
AS_IF([test "x$build_uuidd" = xyes || test "x$enable_libuuid_force_uuidd" = xyes], [
  AC_DEFINE([HAVE_UUIDD], [1], [Define to 1 if you want to use uuid daemon.])
])
AM_CONDITIONAL([BUILD_UUIDD], [test "x$build_uuidd" = xyes])


UL_BUILD_INIT([uuidgen], [check])
UL_REQUIRES_BUILD([uuidgen], [libuuid])
AM_CONDITIONAL([BUILD_UUIDGEN], [test "x$build_uuidgen" = xyes])

UL_BUILD_INIT([uuidparse], [check])
UL_REQUIRES_BUILD([uuidparse], [libuuid])
UL_REQUIRES_BUILD([uuidparse], [libsmartcols])
AM_CONDITIONAL([BUILD_UUIDPARSE], [test "x$build_uuidparse" = xyes])

UL_BUILD_INIT([blkid], [check])
UL_REQUIRES_BUILD([blkid], [libblkid])
AM_CONDITIONAL([BUILD_BLKID], [test "x$build_blkid" = xyes])

UL_BUILD_INIT([findfs], [check])
UL_REQUIRES_BUILD([findfs], [libblkid])
AM_CONDITIONAL([BUILD_FINDFS], [test "x$build_findfs" = xyes])

UL_BUILD_INIT([wipefs], [check])
UL_REQUIRES_BUILD([wipefs], [libblkid])
UL_REQUIRES_BUILD([wipefs], [libsmartcols])
AM_CONDITIONAL([BUILD_WIPEFS], [test "x$build_wipefs" = xyes])

UL_BUILD_INIT([findmnt], [check])
UL_REQUIRES_BUILD([findmnt], [libmount])
UL_REQUIRES_BUILD([findmnt], [libblkid])
UL_REQUIRES_BUILD([findmnt], [libsmartcols])
AM_CONDITIONAL([BUILD_FINDMNT], [test "x$build_findmnt" = xyes])


AC_ARG_ENABLE([mountpoint],
  AS_HELP_STRING([--disable-mountpoint], [do not build mountpoint]),
  [], [UL_DEFAULT_ENABLE([mountpoint], [check])]
)
UL_BUILD_INIT([mountpoint])
UL_REQUIRES_BUILD([mountpoint], [libmount])
AM_CONDITIONAL([BUILD_MOUNTPOINT], [test "x$build_mountpoint" = xyes])


AC_ARG_ENABLE([fallocate],
  AS_HELP_STRING([--disable-fallocate], [do not build fallocate]),
  [], [UL_DEFAULT_ENABLE([fallocate], [check])]
)
UL_BUILD_INIT([fallocate])
UL_REQUIRES_LINUX([fallocate])
UL_REQUIRES_SYSCALL_CHECK([fallocate], [UL_CHECK_SYSCALL([fallocate])])
AM_CONDITIONAL([BUILD_FALLOCATE], [test "x$build_fallocate" = xyes])

AS_IF([test "x$build_fallocate" = xyes], [
  dnl check for valid fallocate() function
  dnl with 32 bits glibc 2.10, fallocate() exists but not fallocate64()
  dnl when _FILE_OFFSET_BITS==64, fallocate() is redirect to fallocate64()
  dnl and program can't be linked.
  dnl AC_CHECK_FUNC can't catch such errors since it's redefining
  dnl function prototype.
  AC_MSG_CHECKING([for valid fallocate() function])
  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_LINUX_FALLOC_H
# include <linux/falloc.h>
#endif
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#endif
]],[[
   long ret;
   ret = fallocate(0, FALLOC_FL_KEEP_SIZE, 0xfffffffful, 0xfffffffful);
   if (ret != 0) {
      return 1;
   }
   ]])],[
  AC_MSG_RESULT([yes])
  AC_DEFINE([HAVE_FALLOCATE], [1], [Have valid fallocate() function])],[
  AC_MSG_RESULT([no])])
])

AS_IF([test "x$build_fallocate" = xyes], [
  dnl check for valid posix_fallocate() function
  AC_MSG_CHECKING([for valid posix_fallocate() function])
  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_LINUX_FALLOC_H
# include <linux/falloc.h>
#endif
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#endif
]],[[
   long ret;
   ret = posix_fallocate(0, 0xfffffffful, 0xfffffffful);
   if (ret != 0) {
      return 1;
   }
   ]])],[
  AC_MSG_RESULT([yes])
  AC_DEFINE([HAVE_POSIX_FALLOCATE], [1], [Have valid posix_fallocate() function])],[
  AC_MSG_RESULT([no])])
])


AC_ARG_ENABLE([unshare],
  AS_HELP_STRING([--disable-unshare], [do not build unshare]),
  [], [UL_DEFAULT_ENABLE([unshare], [check])]
)
UL_BUILD_INIT([unshare])
UL_REQUIRES_LINUX([unshare])
UL_REQUIRES_SYSCALL_CHECK([unshare], [UL_CHECK_SYSCALL([unshare])])
AM_CONDITIONAL([BUILD_UNSHARE], [test "x$build_unshare" = xyes])
AC_CHECK_FUNCS([unshare])

AC_ARG_ENABLE([nsenter],
  AS_HELP_STRING([--disable-nsenter], [do not build nsenter]),
  [], [UL_DEFAULT_ENABLE([nsenter], [check])]
)
UL_BUILD_INIT([nsenter])
UL_REQUIRES_LINUX([nsenter])
UL_REQUIRES_SYSCALL_CHECK([nsenter], [UL_CHECK_SYSCALL([setns])], [setns])
AM_CONDITIONAL([BUILD_NSENTER], [test "x$build_nsenter" = xyes])
AC_CHECK_FUNCS([setns])


AC_ARG_WITH([cap_ng],
  AS_HELP_STRING([--without-cap-ng], [compile without libcap-ng]),
  [], [with_cap_ng=auto]
)
AS_IF([test "x$with_cap_ng" = xno], [
  AM_CONDITIONAL([HAVE_CAP_NG], [false])
  have_cap_ng=no
],[
  UL_CHECK_LIB([cap-ng], [capng_apply], [cap_ng])
])


AC_ARG_ENABLE([setpriv],
  AS_HELP_STRING([--disable-setpriv], [do not build setpriv]),
  [], [UL_DEFAULT_ENABLE([setpriv], [check])]
)
UL_BUILD_INIT([setpriv])
UL_REQUIRES_LINUX([setpriv])
UL_REQUIRES_HAVE([setpriv], [linux_securebits_h], [securebits.h header file])
UL_REQUIRES_HAVE([setpriv], [cap_ng], [libcap-ng library])
AM_CONDITIONAL([BUILD_SETPRIV], [test "x$build_setpriv" = xyes])


AC_ARG_ENABLE([eject],
  AS_HELP_STRING([--disable-eject], [do not build eject]),
  [], [UL_DEFAULT_ENABLE([eject], [check])]
)
UL_BUILD_INIT([eject])
UL_REQUIRES_LINUX([eject])
UL_REQUIRES_BUILD([eject], [libmount])
AM_CONDITIONAL([BUILD_EJECT], [test "x$build_eject" = xyes])


AC_ARG_ENABLE([agetty],
  AS_HELP_STRING([--disable-agetty], [do not build agetty]),
  [], [UL_DEFAULT_ENABLE([agetty], [check])]
)
UL_BUILD_INIT([agetty])
UL_REQUIRES_HAVE([agetty], [utmpx_h], [utmpx.h header])
UL_REQUIRES_HAVE([agetty], [gnu_utmpx], [GNU utmpx functions])
AM_CONDITIONAL([BUILD_AGETTY], [test "x$build_agetty" = xyes])
AS_IF([test "x$have_futimens" = xyes -a "x$have_inotify_init1" = xyes ], [
  AC_DEFINE([AGETTY_RELOAD], [1], [Enable agetty --reload feature])
],[
  AC_MSG_WARN([futimens or inotify_init1 not found; agetty(8) will not provide ---reload functionality])
])


AC_ARG_ENABLE([plymouth_support],
  AS_HELP_STRING([--disable-plymouth_support], [don not care about plymouth in sylogin(8) and agetty(8)]),
  [], [enable_plymouth_support=check]
)
UL_BUILD_INIT([plymouth_support])
UL_REQUIRES_HAVE([plymouth_support], [tiocglcktrmios], [TIOCGLCKTRMIOS flag])
UL_REQUIRES_HAVE([plymouth_support], [sock_cloexec], [SOCK_CLOEXEC flag])
UL_REQUIRES_HAVE([plymouth_support], [sock_nonblock], [SOCK_NONBLOCK flag])
UL_REQUIRES_HAVE([plymouth_support], [so_passcred], [SO_PASSCRED flag])
AM_CONDITIONAL([USE_PLYMOUTH_SUPPORT], [test "x$build_plymouth_support" = xyes])
AS_IF([test "x$build_plymouth_support" = xyes ], [
    AC_DEFINE([USE_PLYMOUTH_SUPPORT], [1], [Enable plymouth support feature for sulogin and aggety])
])


AC_ARG_WITH([libz],
  AS_HELP_STRING([--without-libz], [compile without libz]),
  [], [with_libz=auto]
)
AS_IF([test "x$with_libz" = xno], [have_z=no], [
  AC_CHECK_LIB([z], [crc32], [have_z=yes], [have_z=no])
])


AC_ARG_ENABLE([cramfs],
  AS_HELP_STRING([--disable-cramfs], [do not build fsck.cramfs, mkfs.cramfs]),
  [], [UL_DEFAULT_ENABLE([cramfs], [check])]
)
UL_BUILD_INIT([cramfs])
UL_REQUIRES_HAVE([cramfs], [z], [z library])
AM_CONDITIONAL([BUILD_CRAMFS], [test "x$build_cramfs" = xyes])


AC_ARG_ENABLE([bfs],
  AS_HELP_STRING([--disable-bfs], [do not build mkfs.bfs]),
  [], [UL_DEFAULT_ENABLE([bfs], [yes])]
)
UL_BUILD_INIT([bfs])
AM_CONDITIONAL([BUILD_BFS], [test "x$build_bfs" = xyes])


AC_ARG_ENABLE([minix],
  AS_HELP_STRING([--disable-minix], [do not build fsck.minix, mkfs.minix]),
  [], [UL_DEFAULT_ENABLE([minix], [yes])]
)
UL_BUILD_INIT([minix])
AM_CONDITIONAL([BUILD_MINIX], [test "x$build_minix" = xyes])


AC_ARG_ENABLE([fdformat],
  AS_HELP_STRING([--disable-fdformat], [do not build fdformat]),
  [], [UL_DEFAULT_ENABLE([fdformat], [check])]
)
UL_BUILD_INIT([fdformat])
UL_REQUIRES_LINUX([fdformat])
AM_CONDITIONAL([BUILD_FDFORMAT], [test "x$build_fdformat" = xyes])


AC_ARG_ENABLE([hwclock],
  AS_HELP_STRING([--disable-hwclock], [do not build hwclock]),
  [], [UL_DEFAULT_ENABLE([hwclock], [check])]
)
have_linuxdummy=$linux_os

UL_BUILD_INIT([hwclock])
UL_REQUIRES_HAVE([hwclock], [io, linuxdummy], [ioperm iopl function or Linux])
AM_CONDITIONAL([BUILD_HWCLOCK], [test "x$build_hwclock" = xyes])


UL_BUILD_INIT([mkfs], [yes])
AM_CONDITIONAL([BUILD_MKFS], [test "x$build_mkfs" = xyes])

UL_BUILD_INIT([isosize], [yes])
AM_CONDITIONAL([BUILD_ISOSIZE], [test "x$build_isosize" = xyes])


UL_BUILD_INIT([fstrim], [check])
UL_REQUIRES_LINUX([fstrim])
UL_REQUIRES_BUILD([fstrim], [libmount])
AM_CONDITIONAL([BUILD_FSTRIM], [test "x$build_fstrim" = xyes])


UL_BUILD_INIT([swapon], [check])
UL_REQUIRES_LINUX([swapon])
UL_REQUIRES_SYSCALL_CHECK([swapon], [UL_CHECK_SYSCALL([swapon])], [swapon])
UL_REQUIRES_SYSCALL_CHECK([swapon], [UL_CHECK_SYSCALL([swapoff])], [swapoff])
UL_REQUIRES_BUILD([swapon], [libblkid])
UL_REQUIRES_BUILD([swapon], [libmount])
UL_REQUIRES_BUILD([swapon], [libsmartcols])
AM_CONDITIONAL([BUILD_SWAPON], [test "x$build_swapon" = xyes])
AC_CHECK_FUNCS([swapon])
AC_CHECK_FUNCS([swapoff])


UL_BUILD_INIT([lsblk], [check])
UL_REQUIRES_LINUX([lsblk])
UL_REQUIRES_BUILD([lsblk], [libblkid])
UL_REQUIRES_BUILD([lsblk], [libmount])
UL_REQUIRES_BUILD([lsblk], [libsmartcols])
AM_CONDITIONAL([BUILD_LSBLK], [test "x$build_lsblk" = xyes])


UL_BUILD_INIT([lscpu], [check])
UL_REQUIRES_LINUX([lscpu])
UL_REQUIRES_BUILD([lscpu], [libsmartcols])
UL_REQUIRES_HAVE([lscpu], [cpu_set_t], [cpu_set_t type])
AM_CONDITIONAL([BUILD_LSCPU], [test "x$build_lscpu" = xyes])


AC_ARG_ENABLE([lslogins],
  AS_HELP_STRING([--disable-lslogins], [do not build lslogins]),
  [], [UL_DEFAULT_ENABLE([lslogins], [check])]
)
UL_BUILD_INIT([lslogins])
UL_REQUIRES_BUILD([lslogins], [libsmartcols])
UL_REQUIRES_HAVE([lslogins], [shadow_h], [shadow.h header])
UL_REQUIRES_HAVE([lslogins], [utmpx_h], [utmpx.h header])
UL_REQUIRES_HAVE([lslogins], [gnu_utmpx], [GNU utmpx functions])
AM_CONDITIONAL([BUILD_LSLOGINS], [test "x$build_lslogins" = xyes])


UL_BUILD_INIT([chcpu], [check])
UL_REQUIRES_LINUX([chcpu])
UL_REQUIRES_HAVE([chcpu], [cpu_set_t], [cpu_set_t type])
AM_CONDITIONAL([BUILD_CHCPU], [test "x$build_chcpu" = xyes])


AC_ARG_ENABLE([wdctl],
  AS_HELP_STRING([--disable-wdctl], [do not build wdctl]),
  [], [UL_DEFAULT_ENABLE([wdctl], [check])]
)
UL_BUILD_INIT([wdctl])
UL_REQUIRES_LINUX([wdctl])
UL_REQUIRES_BUILD([wdctl], [libsmartcols])
UL_REQUIRES_HAVE([wdctl], [linux_watchdog_h], [linux/watchdog.h header file])
AM_CONDITIONAL([BUILD_WDCTL], [test "x$build_wdctl" = xyes])


UL_BUILD_INIT([swaplabel], [check])
UL_REQUIRES_BUILD([swaplabel], [libblkid])
AM_CONDITIONAL([BUILD_SWAPLABEL], [test "x$build_swaplabel" = xyes])


UL_BUILD_INIT([mkswap], [yes])
AM_CONDITIONAL([BUILD_MKSWAP], [test "x$build_mkswap" = xyes])
AS_IF([test "x$build_mkswap" = xyes -a "x$build_libuuid" != xyes], [
  AC_MSG_WARN([uuid library is not found; mkswap(8) will not generate UUIDs])
])


AC_ARG_ENABLE([cal],
  AS_HELP_STRING([--disable-cal], [do not build cal]),
  [], [UL_DEFAULT_ENABLE([cal], [check])]
)
UL_BUILD_INIT([cal])
AM_CONDITIONAL([BUILD_CAL], [test "x$build_cal" = xyes])

AC_ARG_ENABLE([logger],
  AS_HELP_STRING([--disable-logger], [do not build logger]),
  [], [UL_DEFAULT_ENABLE([logger], [check])]
)
UL_BUILD_INIT([logger])
AM_CONDITIONAL([BUILD_LOGGER], [test "x$build_logger" = xyes])

UL_BUILD_INIT([look], [yes])
AM_CONDITIONAL([BUILD_LOOK], [test "x$build_look" = xyes])

UL_BUILD_INIT([mcookie], [yes])
AM_CONDITIONAL([BUILD_MCOOKIE], [test "x$build_mcookie" = xyes])

UL_BUILD_INIT([namei], [yes])
AM_CONDITIONAL([BUILD_NAMEI], [test "x$build_namei" = xyes])

matriplet="$($CC -print-multiarch 2>/dev/null || true)"
if test "x$matriplet" != "x"; then
  AC_DEFINE_UNQUOTED([MULTIARCHTRIPLET], ["$matriplet"],
  ["Multi-arch triplet for whereis library search path"])
fi
UL_BUILD_INIT([whereis], [yes])
AM_CONDITIONAL([BUILD_WHEREIS], [test "x$build_whereis" = xyes])

UL_BUILD_INIT([getopt], [yes])
AM_CONDITIONAL([BUILD_GETOPT], [test "x$build_getopt" = xyes])


UL_BUILD_INIT([blockdev], [check])
UL_REQUIRES_LINUX([blockdev])
AM_CONDITIONAL([BUILD_BLOCKDEV], [test "x$build_blockdev" = xyes])


UL_BUILD_INIT([prlimit], [check])
UL_REQUIRES_LINUX([prlimit])
UL_REQUIRES_BUILD([prlimit], [libsmartcols])
UL_REQUIRES_SYSCALL_CHECK([prlimit], [UL_CHECK_SYSCALL([prlimit64])], [prlimit64])
AM_CONDITIONAL([BUILD_PRLIMIT], [test "x$build_prlimit" = xyes])
AS_IF([test "x$build_prlimit" = xyes], [
  AC_CHECK_FUNCS([prlimit])
])


UL_BUILD_INIT([lslocks], [check])
UL_REQUIRES_LINUX([lslocks])
UL_REQUIRES_BUILD([lslocks], [libmount])
UL_REQUIRES_BUILD([lslocks], [libsmartcols])
AM_CONDITIONAL([BUILD_LSLOCKS], [test "x$build_lslocks" = xyes])


AC_ARG_ENABLE([switch_root],
  AS_HELP_STRING([--disable-switch_root], [do not build switch_root]),
  [], [UL_DEFAULT_ENABLE([switch_root], [check])]
)
UL_BUILD_INIT([switch_root])
UL_REQUIRES_LINUX([switch_root])
UL_REQUIRES_HAVE([switch_root], [openat], [openat function])
AM_CONDITIONAL([BUILD_SWITCH_ROOT], [test "x$build_switch_root" = xyes])


AC_ARG_ENABLE([pivot_root],
  AS_HELP_STRING([--disable-pivot_root], [do not build pivot_root]),
  [], [UL_DEFAULT_ENABLE([pivot_root], [check])]
)
UL_BUILD_INIT([pivot_root])
UL_REQUIRES_LINUX([pivot_root])
UL_REQUIRES_SYSCALL_CHECK([pivot_root], [UL_CHECK_SYSCALL([pivot_root])])
AM_CONDITIONAL([BUILD_PIVOT_ROOT], [test "x$build_pivot_root" = xyes])


UL_BUILD_INIT([flock], [check])
UL_REQUIRES_HAVE([flock], [timer], [timer_create function])
AM_CONDITIONAL([BUILD_FLOCK], [test "x$build_flock" = xyes])


AC_ARG_ENABLE([lsmem],
  AS_HELP_STRING([--disable-lsmem], [do not build lsmem]),
  [], [UL_DEFAULT_ENABLE([lsmem], [check])]
)
UL_BUILD_INIT([lsmem])
UL_REQUIRES_LINUX([lsmem])
UL_REQUIRES_BUILD([lsmem], [libsmartcols])
AM_CONDITIONAL([BUILD_LSMEM], [test "x$build_lsmem" = xyes])


AC_ARG_ENABLE([chmem],
  AS_HELP_STRING([--disable-chmem], [do not build chmem]),
  [], [UL_DEFAULT_ENABLE([chmem], [check])]
)
UL_BUILD_INIT([chmem])
UL_REQUIRES_LINUX([chmem])
AM_CONDITIONAL([BUILD_CHMEM], [test "x$build_chmem" = xyes])

UL_BUILD_INIT([ipcmk], [yes])
AM_CONDITIONAL([BUILD_IPCMK], [test "x$build_ipcmk" = xyes])


AC_ARG_ENABLE([ipcrm],
  AS_HELP_STRING([--disable-ipcrm], [do not build ipcrm]),
  [], [UL_DEFAULT_ENABLE([ipcrm], [yes])]
)
UL_BUILD_INIT([ipcrm])
AM_CONDITIONAL([BUILD_IPCRM], [test "x$build_ipcrm" = xyes])

AC_ARG_ENABLE([ipcs],
  AS_HELP_STRING([--disable-ipcs], [do not build ipcs]),
  [], [UL_DEFAULT_ENABLE([ipcs], [yes])]
)
UL_BUILD_INIT([ipcs])
AM_CONDITIONAL([BUILD_IPCS], [test "x$build_ipcs" = xyes])

UL_BUILD_INIT([lsipc], [check])
UL_REQUIRES_LINUX([lsipc])
UL_REQUIRES_BUILD([lsipc], [libsmartcols])
AM_CONDITIONAL([BUILD_LSIPC], [test "x$build_lsipc" = xyes])

UL_BUILD_INIT([lsns], [check])
UL_REQUIRES_LINUX([lsns])
UL_REQUIRES_BUILD([lsns], [libsmartcols])
UL_REQUIRES_BUILD([lsns], [libmount])
AM_CONDITIONAL([BUILD_LSNS], [test "x$build_lsns" = xyes])

UL_BUILD_INIT([renice], [yes])
AM_CONDITIONAL([BUILD_RENICE], [test "x$build_renice" = xyes])


AC_ARG_ENABLE([rfkill],
  AS_HELP_STRING([--disable-rfkill], [do not build rfkill]),
  [], [UL_DEFAULT_ENABLE([rfkill], [check])]
)
UL_BUILD_INIT([rfkill])
UL_REQUIRES_LINUX([rfkill])
UL_REQUIRES_BUILD([rfkill], [libsmartcols])
AM_CONDITIONAL([BUILD_RFKILL], [test "x$build_rfkill" = xyes])


UL_BUILD_INIT([setsid], [yes])
AM_CONDITIONAL([BUILD_SETSID], [test "x$build_setsid" = xyes])

UL_BUILD_INIT([readprofile], [check])
UL_REQUIRES_LINUX([readprofile])
AM_CONDITIONAL([BUILD_READPROFILE], [test "x$build_readprofile" = xyes])

UL_BUILD_INIT([dmesg], [check])
UL_REQUIRES_LINUX([dmesg])
AM_CONDITIONAL([BUILD_DMESG], [test "x$build_dmesg" = xyes])

UL_BUILD_INIT([ctrlaltdel], [check])
UL_REQUIRES_LINUX([ctrlaltdel])
dnl we assume reboot() to be the 1-argument variant, because even considering
dnl widely used alternative C libraries like uclibc, dietlibc and musl,
dnl reboot() with multiple arguments is yet only found in glibc versions
dnl earlier than 2.x.
UL_REQUIRES_HAVE([ctrlaltdel], [reboot], [reboot function])
AM_CONDITIONAL([BUILD_CTRLALTDEL], [test "x$build_ctrlaltdel" = xyes])

UL_BUILD_INIT([fincore], [check])
UL_REQUIRES_LINUX([fincore])
UL_REQUIRES_BUILD([fincore], [libsmartcols])
AM_CONDITIONAL([BUILD_FINCORE], [test "x$build_fincore" = xyes])

UL_BUILD_INIT([fsfreeze], [check])
UL_REQUIRES_LINUX([fsfreeze])
AM_CONDITIONAL([BUILD_FSFREEZE], [test "x$build_fsfreeze" = xyes])

UL_BUILD_INIT([blkdiscard], [check])
UL_REQUIRES_LINUX([blkdiscard])
AM_CONDITIONAL([BUILD_BLKDISCARD], [test "x$build_blkdiscard" = xyes])

UL_BUILD_INIT([blkzone], [check])
UL_REQUIRES_LINUX([blkzone])
UL_REQUIRES_HAVE([blkzone], [linux_blkzoned_h], [linux/blkzoned.h header])
AM_CONDITIONAL([BUILD_BLKZONE], [test "x$build_blkzone" = xyes])

UL_BUILD_INIT([ldattach], [check])
UL_REQUIRES_LINUX([ldattach])
AM_CONDITIONAL([BUILD_LDATTACH], [test "x$build_ldattach" = xyes])

UL_BUILD_INIT([rtcwake], [check])
UL_REQUIRES_LINUX([rtcwake])
AM_CONDITIONAL([BUILD_RTCWAKE], [test "x$build_rtcwake" = xyes])

UL_BUILD_INIT([setarch], [check])
UL_REQUIRES_LINUX([setarch])
AM_CONDITIONAL([BUILD_SETARCH], [test "x$build_setarch" = xyes])

UL_BUILD_INIT([script], [check])
UL_REQUIRES_HAVE([script], [sys_signalfd_h], [sys/signalfd.h header])
AM_CONDITIONAL([BUILD_SCRIPT], [test "x$build_script" = xyes])

UL_BUILD_INIT([scriptreplay], [yes])
AM_CONDITIONAL([BUILD_SCRIPTREPLAY], [test "x$build_scriptreplay" = xyes])

UL_BUILD_INIT([col], [yes])
AM_CONDITIONAL([BUILD_COL], [test "x$build_col" = xyes])

UL_BUILD_INIT([colcrt], [yes])
AM_CONDITIONAL([BUILD_COLCRT], [test "x$build_colcrt" = xyes])

UL_BUILD_INIT([colrm], [yes])
AM_CONDITIONAL([BUILD_COLRM], [test "x$build_colrm" = xyes])

UL_BUILD_INIT([column], [check])
UL_REQUIRES_BUILD([column], [libsmartcols])
AM_CONDITIONAL([BUILD_COLUMN], [test "x$build_column" = xyes])

UL_BUILD_INIT([hexdump], [yes])
AM_CONDITIONAL([BUILD_HEXDUMP], [test "x$build_hexdump" = xyes])

UL_BUILD_INIT([rev], [yes])
AM_CONDITIONAL([BUILD_REV], [test "x$build_rev" = xyes])


AC_ARG_ENABLE([tunelp],
  AS_HELP_STRING([--enable-tunelp], [build tunelp]),
  [], [UL_DEFAULT_ENABLE([tunelp], [no])]
)
UL_BUILD_INIT([tunelp])
UL_REQUIRES_LINUX([tunelp])
AM_CONDITIONAL([BUILD_TUNELP], [test "x$build_tunelp" = xyes])


AC_ARG_ENABLE([kill],
  AS_HELP_STRING([--disable-kill], [do not build kill]),
  [], [UL_DEFAULT_ENABLE([kill], [check])]
)
UL_BUILD_INIT([kill])
UL_REQUIRES_LINUX([kill])
AM_CONDITIONAL([BUILD_KILL], [test "x$build_kill" = xyes])


AC_ARG_ENABLE([last],
  AS_HELP_STRING([--disable-last], [do not build last]),
  [], [UL_DEFAULT_ENABLE([last], [check])]
)
UL_BUILD_INIT([last])
UL_REQUIRES_HAVE([last], [utmpx_h], [utmpx.h header])
UL_REQUIRES_HAVE([last], [gnu_utmpx], [GNU utmpx functions])
AM_CONDITIONAL([BUILD_LAST], [test "x$build_last" = xyes])


AC_ARG_ENABLE([utmpdump],
  AS_HELP_STRING([--disable-utmpdump], [do not build utmpdump]),
  [], [UL_DEFAULT_ENABLE([utmpdump], [check])]
)
UL_BUILD_INIT([utmpdump])
UL_REQUIRES_HAVE([utmpdump], [utmpx_h], [utmpx.h header])
UL_REQUIRES_HAVE([utmpdump], [gnu_utmpx], [GNU utmpx functions])
AM_CONDITIONAL([BUILD_UTMPDUMP], [test "x$build_utmpdump" = xyes])


AC_ARG_ENABLE([line],
  AS_HELP_STRING([--enable-line], [build line]),
  [], [UL_DEFAULT_ENABLE([line], [no])]
)
UL_BUILD_INIT([line])
AM_CONDITIONAL([BUILD_LINE], [test "x$build_line" = xyes])


AC_ARG_ENABLE([mesg],
  AS_HELP_STRING([--disable-mesg], [do not build mesg]),
  [], [UL_DEFAULT_ENABLE([mesg], [yes])]
)
UL_BUILD_INIT([mesg])
AM_CONDITIONAL([BUILD_MESG], [test "x$build_mesg" = xyes])


AC_ARG_ENABLE([raw],
  AS_HELP_STRING([--disable-raw], [do not build raw]),
  [], [UL_DEFAULT_ENABLE([raw], [check])]
)
UL_BUILD_INIT([raw])
UL_REQUIRES_LINUX([raw])
UL_REQUIRES_HAVE([raw], [linux_raw_h], [raw.h header file])
AM_CONDITIONAL([BUILD_RAW], [test "x$build_raw" = xyes])


AC_ARG_ENABLE([rename],
  AS_HELP_STRING([--disable-rename], [do not build rename]),
  [], [UL_DEFAULT_ENABLE([rename], [yes])]
)
UL_BUILD_INIT([rename])
AM_CONDITIONAL([BUILD_RENAME], [test "x$build_rename" = xyes])


AC_ARG_ENABLE([vipw],
  AS_HELP_STRING([--enable-vipw], [build vipw]),
  [], [UL_DEFAULT_ENABLE([vipw], [no])]
)
UL_BUILD_INIT([vipw])
UL_REQUIRES_HAVE([vipw], [shadow_h], [shadow.h header])
AM_CONDITIONAL([BUILD_VIPW], [test "x$build_vipw" = xyes])


AC_ARG_ENABLE([newgrp],
  AS_HELP_STRING([--enable-newgrp], [build newgrp]),
  [], [UL_DEFAULT_ENABLE([newgrp], [no])]
)
UL_BUILD_INIT([newgrp])
AM_CONDITIONAL([BUILD_NEWGRP], [test "x$build_newgrp" = xyes])


AC_ARG_WITH([user], AS_HELP_STRING([--without-user], [compile without libuser (remote chsh)]),
  [], [with_user=check]
)
have_user=no
AS_IF([test "x$with_user" != xno], [
  PKG_CHECK_MODULES(LIBUSER,[libuser >= 0.58], [have_user=yes], [have_user=no])
  AS_CASE([$with_user:$have_user],
    [yes:no],
      [AC_MSG_ERROR([user selected but libuser not found])],
    [*:yes],
      [AC_DEFINE([HAVE_LIBUSER], [1], [Define if libuser is available])]
  )
  # temporary solution, libuser has stupid .pc where are exported all
  # private dependencies to Requires: instead of Requires.private:
  AS_IF([test "x$have_user" = xyes], [
    LIBUSER_LIBS=-luser
  ])
])
AM_CONDITIONAL([HAVE_USER], [test "x$have_user" = xyes])

AC_ARG_ENABLE([chfn-chsh-password],
  AS_HELP_STRING([--disable-chfn-chsh-password], [do not require the user to enter the password in chfn and chsh]),
  [], [enable_chfn_chsh_password=yes]
)

AC_ARG_ENABLE([chfn-chsh],
  AS_HELP_STRING([--enable-chfn-chsh], [build chfn and chsh]),
  [], [UL_DEFAULT_ENABLE([chfn_chsh], [check])]
)
UL_BUILD_INIT([chfn_chsh])
UL_REQUIRES_HAVE([chfn_chsh], [shadow_h], [shadow.h header])
UL_REQUIRES_HAVE([chfn_chsh], [getusershell], [getusershell function])

AS_IF([test "x$enable_chfn_chsh_password" = xyes -o "x$have_user" = xyes], [
  UL_REQUIRES_HAVE([chfn_chsh], [security_pam_appl_h], [PAM header file])
  AC_DEFINE([CHFN_CHSH_PASSWORD], [1], [Should chfn and chsh require the user to enter the password?])
])
AM_CONDITIONAL([BUILD_CHFN_CHSH], [test "x$build_chfn_chsh" = xyes])
AM_CONDITIONAL([CHFN_CHSH_PASSWORD], [test "x$enable_chfn_chsh_password" = xyes])

AC_ARG_ENABLE([chsh-only-listed],
  AS_HELP_STRING([--disable-chsh-only-listed], [chsh: allow shells not in /etc/shells]),
  [], enable_chsh_only_listed=yes
)

AS_IF([test "x$enable_chsh_only_listed" = xyes], [
  AC_DEFINE([ONLY_LISTED_SHELLS], [1], [Should chsh allow only shells in /etc/shells?])
])


AC_ARG_ENABLE([login],
  AS_HELP_STRING([--disable-login], [do not build login]),
  [], [UL_DEFAULT_ENABLE([login], [check])]
)
UL_BUILD_INIT([login])
UL_REQUIRES_HAVE([login], [security_pam_appl_h], [PAM header file])
UL_REQUIRES_HAVE([login], [security_pam_misc_h, security_openpam_h], [PAM conversation functions])
UL_REQUIRES_HAVE([login], [utmpx_h], [utmpx.h header])
UL_REQUIRES_HAVE([login], [gnu_utmpx], [GNU utmpx functions])
AM_CONDITIONAL([BUILD_LOGIN], [test "x$build_login" = xyes])

AC_ARG_ENABLE([login-chown-vcs],
  AS_HELP_STRING([--enable-login-chown-vcs], [let login chown /dev/vcsN]),
  [], [enable_login_chown_vcs=no]
)

AS_IF([test "x$enable_login_chown_vcs" = xyes], [
  AC_DEFINE([LOGIN_CHOWN_VCS], [1], [Should login chown /dev/vcsN?])
])

AC_ARG_ENABLE([login-stat-mail],
  AS_HELP_STRING([--enable-login-stat-mail], [let login stat() the mailbox]),
  [], [enable_login_stat_mail=no]
)

AS_IF([test "x$enable_login_stat_mail" = xyes], [
  AC_DEFINE([LOGIN_STAT_MAIL], [1], [Should login stat() the mailbox?])
])


AC_ARG_ENABLE([nologin],
  AS_HELP_STRING([--disable-nologin], [do not build nologin]),
  [], [UL_DEFAULT_ENABLE([nologin], [yes])]
)
UL_BUILD_INIT([nologin])
AM_CONDITIONAL([BUILD_NOLOGIN], [test "x$build_nologin" = xyes])


AC_ARG_ENABLE([sulogin],
  AS_HELP_STRING([--disable-sulogin], [do not build sulogin]),
  [], [UL_DEFAULT_ENABLE([sulogin], [check])]
)
UL_BUILD_INIT([sulogin])
UL_REQUIRES_HAVE([sulogin], [shadow_h], [shadow.h header])
AM_CONDITIONAL([BUILD_SULOGIN], [test "x$build_sulogin" = xyes])


AC_ARG_ENABLE([su],
  AS_HELP_STRING([--disable-su], [do not build su]),
  [], [UL_DEFAULT_ENABLE([su], [check])]
)
UL_BUILD_INIT([su])
UL_REQUIRES_HAVE([su], [security_pam_appl_h], [PAM header file])
UL_REQUIRES_HAVE([su], [utmpx_h], [utmpx.h header])
UL_REQUIRES_HAVE([su], [gnu_utmpx], [GNU utmpx functions])
AM_CONDITIONAL([BUILD_SU], [test "x$build_su" = xyes])


AC_ARG_ENABLE([runuser],
  AS_HELP_STRING([--disable-runuser], [do not build runuser]),
  [], [UL_DEFAULT_ENABLE([runuser], [check])]
)
UL_BUILD_INIT([runuser])
UL_REQUIRES_HAVE([runuser], [security_pam_appl_h], [PAM header file])
UL_REQUIRES_HAVE([runuser], [utmpx_h], [utmpx.h header])
UL_REQUIRES_HAVE([runuser], [gnu_utmpx], [GNU utmpx functions])
AM_CONDITIONAL([BUILD_RUNUSER], [test "x$build_runuser" = xyes])


AC_ARG_ENABLE([ul],
  AS_HELP_STRING([--disable-ul], [do not build ul]),
  [], [UL_DEFAULT_ENABLE([ul], [check])]
)
UL_BUILD_INIT([ul])
UL_REQUIRES_HAVE([ul], [ncursesw, ncurses], [ncursesw or ncurses libraries])
AM_CONDITIONAL([BUILD_UL], [test "x$build_ul" = xyes])


AC_ARG_ENABLE([more],
  AS_HELP_STRING([--disable-more], [do not build more]),
  [], [UL_DEFAULT_ENABLE([more], [check])]
)
UL_BUILD_INIT([more])
UL_REQUIRES_HAVE([more], [ncursesw, ncurses], [ncursesw or ncurses libraries])
AM_CONDITIONAL([BUILD_MORE], [test "x$build_more" = xyes])


AC_ARG_ENABLE([pg],
  AS_HELP_STRING([--enable-pg], [build pg]),
  [], [UL_DEFAULT_ENABLE([pg], [no])]
)
UL_BUILD_INIT([pg])
UL_REQUIRES_HAVE([pg], [ncursesw, ncurses], [ncursesw or ncurses library])
AM_CONDITIONAL([BUILD_PG], [test "x$build_pg" = xyes])


AC_ARG_ENABLE([setterm],
  AS_HELP_STRING([--disable-setterm], [do not build setterm]),
  [], [UL_DEFAULT_ENABLE([setterm], [check])]
)
UL_BUILD_INIT([setterm])
UL_REQUIRES_LINUX([setterm])
UL_REQUIRES_HAVE([setterm], [ncursesw, ncurses], [ncursesw or ncurses library])
AM_CONDITIONAL([BUILD_SETTERM], [test "x$build_setterm" = xyes])

# build_schedutils= is just configure-only variable to control
# ionice, taskset and chrt
AC_ARG_ENABLE([schedutils],
  AS_HELP_STRING([--disable-schedutils], [do not build chrt, ionice, taskset]),
  [], [UL_DEFAULT_ENABLE([schedutils], [check])]
)


UL_ENABLE_ALIAS([ionice], [schedutils])
UL_BUILD_INIT([ionice])
UL_REQUIRES_SYSCALL_CHECK([ionice],
	[UL_CHECK_SYSCALL([ioprio_set],
	  [alpha],	[442],
	  [i*86],	[289],
	  [ia64*],	[1274],
	  [powerpc*],	[273],
	  [s390*],	[282],
	  [sparc*],	[196],
	  [sh*],	[288],
	  [x86_64*],	[251])],
	[ioprio_set])

UL_REQUIRES_SYSCALL_CHECK([ionice],
	[UL_CHECK_SYSCALL([ioprio_get],
	  [alpha],	[443],
	  [i*86],	[290],
	  [ia64*],	[1275],
	  [powerpc*],	[274],
	  [s390*],	[283],
	  [sparc*],	[218],
	  [sh*],	[289],
	  [x86_64*],	[252])],
	[ioprio_get])

AM_CONDITIONAL([BUILD_IONICE], [test "x$build_ionice" = xyes])


UL_ENABLE_ALIAS([taskset], [schedutils])
UL_BUILD_INIT([taskset])
UL_REQUIRES_HAVE([taskset], [cpu_set_t], [cpu_set_t type])
UL_REQUIRES_SYSCALL_CHECK([taskset],
	[UL_CHECK_SYSCALL([sched_getaffinity])],
	[sched_getaffinity])
AM_CONDITIONAL([BUILD_TASKSET], [test "x$build_taskset" = xyes])


have_schedsetter=no
AS_IF([test "x$ac_cv_func_sched_setscheduler" = xyes], [have_schedsetter=yes],
      [test "x$ac_cv_func_sched_setattr" = xyes], [have_schedsetter=yes])

UL_ENABLE_ALIAS([chrt], [schedutils])
UL_BUILD_INIT([chrt])
UL_REQUIRES_HAVE([chrt], [schedsetter], [sched_set functions])
AM_CONDITIONAL([BUILD_CHRT], [test "x$build_chrt" = xyes])

AS_IF([test "x$build_chrt" = xyes], [
	UL_CHECK_SYSCALL([sched_setattr])
])


AC_ARG_ENABLE([wall],
  AS_HELP_STRING([--disable-wall], [do not build wall]),
  [], [UL_DEFAULT_ENABLE([wall], [check])]
)
UL_BUILD_INIT([wall])
UL_REQUIRES_HAVE([wall], [utmpx_h], [utmpx.h header])
AM_CONDITIONAL([BUILD_WALL], [test "x$build_wall" = xyes])


AC_ARG_ENABLE([write],
  AS_HELP_STRING([--enable-write], [build write]),
  [], [UL_DEFAULT_ENABLE([write], [no])]
)
UL_BUILD_INIT([write])
UL_REQUIRES_HAVE([write], [utmpx_h], [utmpx.h header])
UL_REQUIRES_HAVE([write], [gnu_utmpx], [GNU utmpx functions])
AM_CONDITIONAL([BUILD_WRITE], [test "x$build_write" = xyes])


AC_ARG_WITH([btrfs],
  AS_HELP_STRING([--with-btrfs], [build with support for btrfs]),
  [], [with_btrfs=check]
)
have_btrfs=no
AS_IF([test "x$with_btrfs" != xno], [
  AS_CASE([$with_btrfs:$have_linux_btrfs_h],
    [yes:no],
    [AC_MSG_ERROR([btrfs selected but linux/btrfs.h not found])],
    [check:no],
       [AC_MSG_WARN([linux/btrfs.h not found, do not build with btrfs support])],
    [*:yes],
       [have_btrfs=yes
	AC_DEFINE([HAVE_BTRFS_SUPPORT], [1], [Define if btrfs stuff is available])]
  )
])
AM_CONDITIONAL([HAVE_BTRFS], [test "x$have_btrfs" = xyes])


AC_ARG_WITH([systemd],
  AS_HELP_STRING([--with-systemd], [build with support for systemd]),
  [], [with_systemd=check]
)

have_systemd=no
AS_IF([test "x$with_systemd" != xno], [
  # new version -- all libsystemd-* libs merged into libsystemd
  PKG_CHECK_MODULES([SYSTEMD], [libsystemd], [have_systemd=yes], [have_systemd=no])
  # old versions
  AS_IF([test "x$have_systemd" != "xyes"], [
    PKG_CHECK_MODULES([SYSTEMD_DAEMON], [libsystemd-daemon],
		      [have_systemd_daemon=yes], [have_systemd_daemon=no])
    PKG_CHECK_MODULES([SYSTEMD_JOURNAL], [libsystemd-journal],
		      [have_systemd_journal=yes], [have_systemd_journal=no])
    AS_IF([test "x$have_systemd_daemon" = "xyes" -a "x$have_systemd_journal" = "xyes" ],[
	   have_systemd=yes])
  ])
  AS_CASE([$with_systemd:$have_systemd],
    [yes:no],
      [AC_MSG_ERROR([systemd expected but libsystemd not found])],
    [*:yes],
       AC_DEFINE([HAVE_LIBSYSTEMD], [1], [Define if libsystemd is available])
  )
])
AM_CONDITIONAL([HAVE_SYSTEMD], [test "x$have_systemd" = xyes])


AC_ARG_WITH([systemdsystemunitdir],
  AS_HELP_STRING([--with-systemdsystemunitdir=DIR], [directory for systemd service files]),
  [], [with_systemdsystemunitdir=`$PKG_CONFIG --variable=systemdsystemunitdir systemd`])

AS_IF([test "x$with_systemdsystemunitdir" != "xno"], [
  AC_SUBST([systemdsystemunitdir], [$with_systemdsystemunitdir])
])


AC_ARG_WITH([smack],
  AS_HELP_STRING([--with-smack], [build with SMACK support]),
  [], [with_smack=no]
)
AS_IF([test "x$with_smack" = xyes], [
  AC_DEFINE([HAVE_SMACK], [1], [Add SMACK support])
])


AC_ARG_WITH([bashcompletiondir],
  AS_HELP_STRING([--with-bashcompletiondir=DIR], [Bash completions directory]),
  [],
  [AS_IF([`$PKG_CONFIG --exists bash-completion`], [
    with_bashcompletiondir=`$PKG_CONFIG --variable=completionsdir bash-completion`
  ], [
    with_bashcompletiondir=${datadir}/bash-completion/completions
  ])
])
AC_SUBST([bashcompletiondir], [$with_bashcompletiondir])

AC_ARG_ENABLE([bash-completion],
  AS_HELP_STRING([--disable-bash-completion], [do not install bash completion files]),
  [], [enable_bash_completion=yes]
)

AM_CONDITIONAL([BUILD_BASH_COMPLETION], [test "x$enable_bash_completion" = xyes])


AC_ARG_WITH([python],
  AS_HELP_STRING([--without-python], [do not build python bindings, use --with-python={2,3} to force version]),
  [], [with_python=check withval=check]
)

have_python=no
have_libpython=no
AS_IF([test "x$with_python" != xno], [
  # We follow distributions default and look for PKG module name "python"
  # (minimal version is 2) but if major version is explicitly specified by
  # --with-python=2 or --with-python=3 then we look for PKG module "python2" or
  # "python3".
  AS_IF([test "x$withval" != xno -a "x$withval" != xyes -a "x$withval" != xcheck],
	[pymajor="$withval"; PYTHON=python${pymajor}], [pymajor="2"])

  # check for python interpreter
  AM_PATH_PYTHON([$pymajor], [have_python=yes], [have_python=no])
  AS_CASE([$with_python:$have_python],
    [yes:no],
      [AC_MSG_ERROR([python selected but python interpreter not found])],
    [check:no],
       [AC_MSG_WARN([python interpreter not found, do not build python bindings])],
    [*:yes],
       # check for python development stuff
       [PKG_CHECK_MODULES([PYTHON], [python-$PYTHON_VERSION],
			  [have_libpython=yes], [have_libpython=no])]
  )
])


AC_ARG_ENABLE([pylibmount],
  AS_HELP_STRING([--disable-pylibmount], [do not build pylibmount]),
  [], [UL_DEFAULT_ENABLE([pylibmount], [check])]
)
UL_BUILD_INIT([pylibmount])
UL_REQUIRES_HAVE([pylibmount], [libpython], [libpython])
UL_REQUIRES_BUILD([pylibmount], [libmount])
AM_CONDITIONAL([BUILD_PYLIBMOUNT], [test "x$build_pylibmount" = "xyes"])

# We need to introduce a verbatim dependency into the Makefile, without automake
# trying to interpret it, so push it as a AM_SUBST_NOTMAKE variable.
verbatim_pylibmount_dependency='

# pylibmountexec module must be installed after usrlib_exec libraries,
# otherwise the libtool relink step will fail to find libmount.la and
# will try -lmount which is possibly not available.
install-pylibmountexecLTLIBRARIES: install-usrlib_execLTLIBRARIES

'
AC_SUBST([verbatim_pylibmount_dependency])
AM_SUBST_NOTMAKE([verbatim_pylibmount_dependency])

AC_ARG_ENABLE([pg-bell],
  AS_HELP_STRING([--disable-pg-bell], [let pg not ring the bell on invalid keys]),
  [], [enable_pg_bell=yes]
)

AS_IF([test "x$enable_pg_bell" = xyes], [
  AC_DEFINE([PG_BELL], [1], [Should pg ring the bell on invalid keys?])
])


AC_DEFUN([FS_PATHS_DEFAULT], [/sbin:/sbin/fs.d:/sbin/fs])
AC_ARG_ENABLE([fs-paths-default],
  AS_HELP_STRING([--enable-fs-paths-default=paths], [default search path for fs helpers @<:@FS_PATHS_DEFAULT@:>@]),
  [AS_CASE([$enableval],
    [yes], [fs_paths_defaults="FS_PATHS_DEFAULT"],
    [no],  [fs_paths_defaults=""],
    [fs_paths_defaults="$enableval"]
  )],
  [fs_paths_defaults="FS_PATHS_DEFAULT"]
)
AC_ARG_ENABLE([fs-paths-extra],
  AS_HELP_STRING([--enable-fs-paths-extra=paths], [additional search paths for fs helpers]),
  [AS_CASE([$enableval],
     [yes|no], [fs_paths_extra=""],
     [fs_paths_extra="$enableval"]
  )],
  [fs_paths_extra=""]
)
fs_paths="$fs_paths_defaults"
AS_IF([test "x$fs_paths_extra" != "x"], [
  AS_IF([test "x$fs_paths" != "x"], [
    fs_paths="${fs_paths}:"
  ])
  fs_paths="${fs_paths}${fs_paths_extra}"
])
AC_DEFINE_UNQUOTED([FS_SEARCH_PATH], "$fs_paths", [search path for fs helpers])


AC_ARG_ENABLE([use-tty-group],
  AS_HELP_STRING([--disable-use-tty-group], [do not install wall and write setgid tty]),
  [], [enable_use_tty_group=yes]
)
AM_CONDITIONAL([USE_TTY_GROUP], [test "x$enable_use_tty_group" = xyes])

AS_IF([test "x$enable_use_tty_group" = xyes], [
  AC_DEFINE([USE_TTY_GROUP], [1], [Should wall and write be installed setgid tty?])
])


AC_ARG_ENABLE([sulogin-emergency-mount],
  AS_HELP_STRING([--enable-sulogin-emergency-mount],
		 [use emergency mount of /dev and /proc for sulogin]),
  [], [enable_sulogin_emergency_mount=no]
)

AS_IF([test "x$enable_sulogin_emergency_mount" = xyes], [
  AC_DEFINE([USE_SULOGIN_EMERGENCY_MOUNT], [1],
	    [Should sulogin use a emergency mount of /dev and /proc?])
])


AC_ARG_ENABLE([usrdir-path],
  AS_HELP_STRING([--enable-usrdir-path], [use only /usr paths in PATH env. variable (recommended on systems with /bin -> /usr/bin symlinks)]),
  [], [enable_usrdir_path=no]
)

AS_IF([test "x$enable_usrdir_path" = xyes], [
  AC_DEFINE([USE_USRDIR_PATHS_ONLY], [1], [Define to 1 to remove /bin and /sbin from PATH env.variable])
])


AC_ARG_ENABLE([makeinstall-chown],
  AS_HELP_STRING([--disable-makeinstall-chown], [do not do chown-like operations during "make install"]),
  [], [enable_makeinstall_chown=yes]
)
AM_CONDITIONAL([MAKEINSTALL_DO_CHOWN], [test "x$enable_makeinstall_chown" = xyes])


AC_ARG_ENABLE([makeinstall-setuid],
  AS_HELP_STRING([--disable-makeinstall-setuid], [do not do setuid chmod operations during "make install"]),
  [], [enable_makeinstall_setuid=yes]
)
AM_CONDITIONAL([MAKEINSTALL_DO_SETUID], [test "x$enable_makeinstall_setuid" = xyes])


AC_ARG_ENABLE([colors-default],
  AS_HELP_STRING([--disable-colors-default], [do not colorize output from utils by default]),
  [], [enable_colors_default=yes]
)
AS_IF([test "x$enable_colors_default" = xyes], [
  AC_DEFINE([USE_COLORS_BY_DEFAULT], [1], [Enables colorized output from utils by default])
])


AC_ARG_VAR([SUID_CFLAGS],
	   [CFLAGS used for binaries which are usually with the suid bit])
AC_ARG_VAR([SUID_LDFLAGS],
	   [LDFLAGS used for binaries which are usually with the suid bit])

AC_ARG_VAR([DAEMON_CFLAGS],
	   [CFLAGS used for binaries which are usually executed as daemons])
AC_ARG_VAR([DAEMON_LDFLAGS],
	   [LDFLAGS used for binaries which are usually executed as daemons])

AC_ARG_VAR([SOLIB_CFLAGS],
	   [CFLAGS used for shared libraries])
AC_ARG_VAR([SOLIB_LDFLAGS],
	   [LDFLAGS used for shared libraries])

AC_ARG_VAR([ADJTIME_PATH],
	   [Path to hwclock adjtime file, default /etc/adjtime])
AS_IF([test "x$ADJTIME_PATH" = x], [ADJTIME_PATH="/etc/adjtime"])
AC_DEFINE_UNQUOTED([CONFIG_ADJTIME_PATH], "$ADJTIME_PATH", [Path to hwclock adjtime file])


LIBS=""


AC_CONFIG_HEADERS([config.h])

#
# Don't use configure.ac to replace install paths! See Makefile PATHFILES for
# more details.
#
AC_CONFIG_FILES([
Makefile
libblkid/docs/Makefile
libblkid/docs/version.xml
libblkid/src/blkid.h
libfdisk/docs/Makefile
libfdisk/docs/version.xml
libfdisk/src/libfdisk.h
libmount/docs/Makefile
libmount/docs/version.xml
libmount/src/libmount.h
libsmartcols/docs/Makefile
libsmartcols/docs/version.xml
libsmartcols/src/libsmartcols.h
po/Makefile.in
])

AC_OUTPUT

AC_MSG_RESULT([
	${PACKAGE}  ${VERSION}

	prefix:            ${prefix}
	exec prefix:       ${exec_prefix}

	runstatedir:       ${runstatedir}
	bindir:            ${bindir}
	sbindir:           ${sbindir}
	libdir:            ${libdir}
	includedir:        ${includedir}
	usrbin_execdir:    ${usrbin_execdir}
	usrsbin_execdir:   ${usrsbin_execdir}
	usrlib_execdir:    ${usrlib_execdir}

	compiler:          ${CC}
	cflags:            ${CFLAGS}
	suid cflags:       ${SUID_CFLAGS}
	ldflags:           ${LDFLAGS}
	suid ldflags:      ${SUID_LDFLAGS}

	Python:            ${PYTHON}
	Python version:    ${PYTHON_VERSION}
	Python libs:       ${pyexecdir}

	Bash completions:  ${with_bashcompletiondir}
	Systemd support:   ${have_systemd}
	Btrfs support:     ${have_btrfs}
	Wide-char support: ${build_widechar}

	warnings:

${WARN_CFLAGS}

	Type 'make' or 'make <utilname>' to compile.
])