| 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="16-Nov-2020" |
| 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]) ]) |
| AS_CASE([$libdir], ['${exec_prefix}/lib64'],[libdir=/lib64; AC_MSG_NOTICE([ --libdir defaults to /lib64]) ]) |
| ] |
| ) |
| |
| |
| # 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]) |
| |
| # static configuration maintaned by packages (e.g. /usr/lib) |
| AC_ARG_VAR([SYSCONFSTATICDIR], |
| [Path to static system configuration, default ${prefix}/lib]) |
| AS_IF([test "x$SYSCONFSTATICDIR" = x], |
| [sysconfstaticdir='${prefix}/lib'], |
| [sysconfstaticdir=$SYSCONFSTATICDIR]) |
| AC_SUBST([sysconfstaticdir]) |
| |
| |
| 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([-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]) |
| UL_WARN_ADD([-Wdiscarded-qualifiers]) |
| UL_WARN_ADD([-Waddress-of-packed-member]) |
| |
| AC_ARG_ENABLE([werror], |
| AS_HELP_STRING([--enable-werror], [make all compiler warnings into errors]), |
| [], [enable_werror=no] |
| ) |
| AS_IF([test "x$enable_werror" = xyes], [ |
| UL_WARN_ADD([-Werror]) |
| ],[ |
| UL_WARN_ADD([-Werror=sequence-point]) |
| ]) |
| |
| AC_SUBST([WARN_CFLAGS]) |
| |
| |
| UL_WARN_ADD([-Wno-clobbered], [BSD_WARN_CFLAGS]) |
| AC_SUBST([BSD_WARN_CFLAGS]) |
| |
| UL_WARN_ADD([-Wno-cast-function-type], [PYTHON_WARN_CFLAGS]) |
| AC_SUBST([PYTHON_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]) |
| ASAN_LDFLAGS="-fsanitize=address" |
| ]) |
| AC_SUBST([ASAN_LDFLAGS]) |
| |
| AC_ARG_ENABLE([ubsan], |
| AS_HELP_STRING([--enable-ubsan], [compile with UBsan]), |
| [], [enable_ubsan=no] |
| ) |
| AS_IF([test "x$enable_ubsan" = xyes], [ |
| UL_WARN_ADD([-fsanitize=undefined]) |
| UBSAN_LDFLAGS="-fsanitize=undefined" |
| ]) |
| AC_SUBST([UBSAN_LDFLAGS]) |
| |
| 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. Make sure pkg-config is installed.])]) |
| PKG_PROG_PKG_CONFIG |
| PKG_INSTALLDIR(['${usrlib_execdir}/pkgconfig']) |
| |
| 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 \ |
| linux/capability.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 \ |
| ]) |
| |
| # There is a collision in old kernel-headers. The both files mount.h and fs.h |
| # define MS_* macros. Fixed by kernel commit e462ec50cb5fad19f6003a3d8087f4a0945dd2b1. |
| # |
| AC_CHECK_HEADERS([linux/fs.h ], [], [], |
| [#ifdef HAVE_SYS_MOUNT_H |
| # include <linux/fs.h> |
| # include <sys/mount.h> |
| #endif |
| ]) |
| |
| 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_H], [true])], |
| [AM_CONDITIONAL([HAVE_LANGINFO_H], [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_capability_h=$ac_cv_header_linux_capability_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 |
| have_pty_h=$ac_cv_header_pty_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([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([ \ |
| clearenv \ |
| __fpurge \ |
| fpurge \ |
| __fpending \ |
| secure_getenv \ |
| __secure_getenv \ |
| eaccess \ |
| err \ |
| errx \ |
| explicit_bzero \ |
| fmemopen \ |
| fsync \ |
| utimensat \ |
| getdomainname \ |
| getdtablesize \ |
| getexecname \ |
| getmntinfo \ |
| getrandom \ |
| getrlimit \ |
| getsgnam \ |
| inotify_init \ |
| jrand48 \ |
| lchown \ |
| llseek \ |
| mempcpy \ |
| mkostemp \ |
| nanosleep \ |
| ntp_gettime \ |
| personality \ |
| pidfd_open \ |
| pidfd_send_signal \ |
| 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]) |
| |
| have_setns_syscall="yes" |
| UL_CHECK_SYSCALL([setns]) |
| AS_IF([test "x$ul_cv_syscall_setns" = xno], [ |
| have_setns_syscall="no" |
| ]) |
| |
| UL_CHECK_SYSCALL([pidfd_open]) |
| UL_CHECK_SYSCALL([pidfd_send_signal]) |
| |
| 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_DEFINE_UNQUOTED([HAVE_TIMER_CREATE], [1], [Define if timer_create exist in -lrt]) |
| ],[ |
| AC_SEARCH_LIBS([timer_create], [rt], [ |
| AC_MSG_RESULT(yes) |
| have_timer="yes" |
| REALTIME_LIBS="-lrt -lpthread" |
| AC_DEFINE_UNQUOTED([HAVE_TIMER_CREATE], [1], [Define if timer_create exist in -lrt -lpthread]) |
| ],[], [-lpthread] |
| ) |
| ])] |
| ) |
| |
| AC_SUBST([REALTIME_LIBS]) |
| |
| AS_IF([test x"$have_timer" = xno], [ |
| AC_CHECK_FUNCS([setitimer], [have_timer="yes"], [have_timer="no"]) |
| ]) |
| |
| |
| 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>]) |
| ]) |
| |
| AM_CONDITIONAL([HAVE_DIRFD], [test "x$have_dirfd" = xyes -o "x$have_ddfd" = xyes]) |
| |
| |
| 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 |
| |
| have_pty=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]) |
| ]) |
| |
| AS_IF([test "x$have_pty_h" = xyes -a "x$have_sys_signalfd_h" = xyes -a "x$have_util" = xyes], [ |
| AM_CONDITIONAL([HAVE_PTY], [true]) |
| AC_DEFINE([HAVE_PTY], [1], [have PTY support]) |
| have_pty=yes |
| ], [ |
| AM_CONDITIONAL([HAVE_PTY], [false]) |
| ]) |
| |
| 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> |
| #include <stdlib.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 |
| # apparently at this stage, XOPEN_SOURCE will conflict. As workaround, |
| # check for crypt.h and use that without XOPEN_SOURCE. |
| have_crypt=no |
| 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"); |
| ]])],[ |
| have_libcrypt=no |
| have_crypt=yes |
| ],[ |
| 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 |
| have_crypt=yes |
| ],[ |
| AC_MSG_WARN([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([--without-ncursesw], [do not build with wide-char ncurses]), |
| [], [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]), |
| [], [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([--without-readline], [do not build 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]) |
| UL_REQUIRES_HAVE([libblkid], [dirfd,ddfd], [dirfd or ddfd function]) |
| 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], [dirfd,ddfd], [dirfd or ddfd function]) |
| 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.]) |
| AS_IF([test "x$have_setns_syscall" = "xyes"], [ |
| AC_DEFINE([USE_LIBMOUNT_SUPPORT_NAMESPACES], [1], [Define to 1 if want to support namepaces.]) |
| ],[ |
| AC_MSG_WARN([libmount will be compiled without namespaces support]) |
| ]) |
| ]) |
| |
| 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]) |
| |
| |
| AC_ARG_ENABLE([fdisks], |
| AS_HELP_STRING([--disable-fdisks], [do not build fdisk(8), sfdisk(8) and cfdisk(8)]), |
| [], [UL_DEFAULT_ENABLE([fdisks], [check])] |
| ) |
| enable_fdisk=$enable_fdisks |
| enable_sfdisk=$enable_fdisks |
| enable_cfdisk=$enable_fdisks |
| |
| UL_BUILD_INIT([fdisk]) |
| UL_REQUIRES_HAVE([fdisk], [openat], [openat functions]) |
| UL_REQUIRES_HAVE([fdisk], [dirfd,ddfd], [dirfd or ddfd function]) |
| UL_REQUIRES_BUILD([fdisk], [libfdisk]) |
| UL_REQUIRES_BUILD([fdisk], [libsmartcols]) |
| AM_CONDITIONAL([BUILD_FDISK], [test "x$build_fdisk" = xyes]) |
| |
| |
| UL_BUILD_INIT([sfdisk]) |
| UL_REQUIRES_HAVE([sfdisk], [openat], [openat functions]) |
| UL_REQUIRES_HAVE([sfdisk], [dirfd,ddfd], [dirfd or ddfd function]) |
| UL_REQUIRES_BUILD([sfdisk], [libfdisk]) |
| UL_REQUIRES_BUILD([sfdisk], [libsmartcols]) |
| AM_CONDITIONAL([BUILD_SFDISK], [test "x$build_sfdisk" = xyes]) |
| |
| |
| UL_BUILD_INIT([cfdisk]) |
| 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]) |
| |
| AC_ARG_ENABLE([wipefs], |
| AS_HELP_STRING([--disable-wipefs], [do not build wipefs]), |
| [], [UL_DEFAULT_ENABLE([wipefs], [check])] |
| ) |
| UL_BUILD_INIT([wipefs]) |
| 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])]) |
| UL_REQUIRES_HAVE([unshare], [linux_capability_h], [linux/capability.h header file]) |
| 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_HAVE([nsenter], [setns_syscall], [setns syscall]) |
| 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], [linux/securebits.h header file]) |
| UL_REQUIRES_HAVE([setpriv], [linux_capability_h], [linux/capability.h header file]) |
| UL_REQUIRES_HAVE([setpriv], [cap_ng], [libcap-ng library]) |
| AM_CONDITIONAL([BUILD_SETPRIV], [test "x$build_setpriv" = xyes]) |
| |
| PKG_CHECK_MODULES([PCRE], [libpcre2-8], [have_pcre=yes], [have_pcre=no]) |
| AS_IF([test "x$have_pcre" = xyes ], [ |
| AC_DEFINE([HAVE_PCRE], [1], [Define if libpcre2 is available]) |
| ]) |
| AM_CONDITIONAL([HAVE_PCRE], [test "x$have_pcre" = xyes]) |
| |
| AC_ARG_ENABLE([hardlink], |
| AS_HELP_STRING([--disable-hardlink], [do not build hardlink]), |
| [], [UL_DEFAULT_ENABLE([hardlink], [check])] |
| ) |
| UL_BUILD_INIT([hardlink]) |
| AM_CONDITIONAL([BUILD_HARDLINK], [test "x$build_hardlink" = 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], [do 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_WITH([libmagic], |
| AS_HELP_STRING([--without-libmagic], [compile without libmagic]), |
| [], [with_libmagic=auto] |
| ) |
| AS_IF([test "x$with_libmagic" = xno], [have_magic=no], [ |
| AC_CHECK_LIB([magic], [magic_open], [ |
| AC_DEFINE([HAVE_MAGIC], [1], [Define to 1 if you have the libmagic present.]) |
| MAGIC_LIBS="-lmagic" |
| ]) |
| ]) |
| AC_SUBST([MAGIC_LIBS]) |
| |
| |
| 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]) |
| |
| AC_ARG_ENABLE([hwclock_cmos], |
| AS_HELP_STRING([--disable-hwclock-cmos], [do not use CMOS clock]), |
| [], [enable_hwclock_cmos=check] |
| ) |
| UL_BUILD_INIT([hwclock_cmos]) |
| UL_REQUIRES_BUILD([hwclock_cmos], [hwclock]) |
| UL_REQUIRES_ARCH([hwclock_cmos], [i?86-*,x86_64*]) |
| AM_CONDITIONAL([USE_HWCLOCK_CMOS], [test "x$build_hwclock_cmos" = xyes]) |
| AS_IF([test "x$build_hwclock_cmos" = xyes ], [ |
| AC_DEFINE([USE_HWCLOCK_CMOS], [1], [Define to 1 if want to use CMOS clock.]) |
| ]) |
| |
| AC_ARG_ENABLE([hwclock_gplv3], |
| AS_HELP_STRING([--disable-hwclock-gplv3], [do not use datetime parsing GPLv3 code]), |
| [], [enable_hwclock_gplv3=yes] |
| ) |
| AM_CONDITIONAL([USE_HWCLOCK_GPLv3_DATETIME], [test "x$enable_hwclock_gplv3" = xyes]) |
| AS_IF([test "x$enable_hwclock_gplv3" = xyes ], [ |
| AC_DEFINE([USE_HWCLOCK_GPLv3_DATETIME], [1], [use datetime parsing GPLv3 code to hwclock]) |
| ]) |
| |
| |
| 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]) |
| UL_REQUIRES_HAVE([switch_root], [dirfd,ddfd], [dirfd or ddfd 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/setitimer 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]) |
| |
| |
| AC_ARG_ENABLE([irqtop], |
| AS_HELP_STRING([--disable-irqtop], [do not build irqtop]), |
| [], [UL_DEFAULT_ENABLE([irqtop], [check])] |
| ) |
| UL_BUILD_INIT([irqtop]) |
| UL_REQUIRES_LINUX([irqtop]) |
| UL_REQUIRES_BUILD([irqtop], [libsmartcols]) |
| UL_REQUIRES_HAVE([irqtop], [open_memstream], [open_memstream function]) |
| UL_REQUIRES_HAVE([irqtop], [ncursesw,slang,ncurses], [ncursesw, ncurses or slang library]) |
| AM_CONDITIONAL([BUILD_IRQTOP], [test "x$build_irqtop" = xyes]) |
| |
| AC_ARG_ENABLE([lsirq], |
| AS_HELP_STRING([--disable-lsirq], [do not build lsirq]), |
| [], [UL_DEFAULT_ENABLE([lsirq], [check])] |
| ) |
| UL_BUILD_INIT([lsirq]) |
| UL_REQUIRES_LINUX([lsirq]) |
| UL_REQUIRES_BUILD([lsirq], [libsmartcols]) |
| AM_CONDITIONAL([BUILD_LSIRQ], [test "x$build_lsirq" = xyes]) |
| |
| |
| UL_BUILD_INIT([choom], [check]) |
| UL_REQUIRES_LINUX([choom]) |
| AM_CONDITIONAL([BUILD_CHOOM], [test "x$build_choom" = 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], [pty]) |
| 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([scriptlive], [check]) |
| UL_REQUIRES_HAVE([scriptlive], [pty]) |
| AM_CONDITIONAL([BUILD_SCRIPTLIVE], [test "x$build_scriptlive" = 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]) |
| UL_REQUIRES_HAVE([newgrp], [crypt], [crypt function]) |
| 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([--disable-chfn-chsh], [do not 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], [crypt], [crypt function]) |
| 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]) |
| UL_REQUIRES_LINUX([more]) |
| 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([--without-btrfs], [do not build with btrfs support]), |
| [], [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([--without-systemd], [do not build with systemd support]), |
| [], [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 unit files (requires systemd support)]), |
| [], [with_systemdsystemunitdir=check] |
| ) |
| AS_IF([test "x$with_systemdsystemunitdir" = xcheck], [ |
| AS_IF([test "x$have_systemd" = xyes], [ |
| with_systemdsystemunitdir=`$PKG_CONFIG --variable=systemdsystemunitdir systemd` |
| ],[ |
| with_systemdsystemunitdir=no |
| ]) |
| ]) |
| 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([econf], |
| AS_HELP_STRING([--without-econf], [do not use libeconf]), |
| [], [with_econf=check] |
| ) |
| |
| have_econf=no |
| AS_IF([test "x$with_econf" != xno], [ |
| PKG_CHECK_MODULES([ECONF], [libeconf], [have_econf=yes], [have_econf=no]) |
| AS_CASE([$with_econf:$have_econf], |
| [yes:no], |
| [AC_MSG_ERROR([libeconf expected but libeconf not found])], |
| [*:yes], |
| AC_DEFINE([HAVE_LIBECONF], [1], [Define if libeconf is available]) |
| ) |
| ]) |
| AM_CONDITIONAL([HAVE_ECONF], [test "x$have_econf" = xyes]) |
| |
| AC_ARG_WITH([vendordir], |
| AS_HELP_STRING([--with-vendordir=DIR], [Direcotry for distribution provided configuration files]), |
| [], [] |
| ) |
| AC_SUBST([vendordir], [$with_vendordir]) |
| AM_CONDITIONAL([USE_VENDORDIR], [test "x$with_vendordir" != x]) |
| AS_IF([test "x$with_vendordir" != x], [ |
| AC_DEFINE([USE_VENDORDIR], [1], [Define to 1 to use vendordir]) |
| ]) |
| |
| |
| 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_WITH([cryptsetup], |
| AS_HELP_STRING([--with-cryptsetup], [compile with cryptsetup support]), |
| [], [with_cryptsetup=no] |
| ) |
| |
| AS_IF([test "x$with_cryptsetup" = xno], [ |
| AM_CONDITIONAL([HAVE_CRYPTSETUP], [false]) |
| AM_CONDITIONAL([CRYPTSETUP_VIA_DLOPEN], [false]) |
| ], [ |
| PKG_CHECK_MODULES([CRYPTSETUP], [libcryptsetup], |
| [AC_DEFINE([HAVE_CRYPTSETUP], [1], [Define if cryptsetup is available]) |
| UL_PKG_STATIC([CRYPTSETUP_LIBS_STATIC], [libcryptsetup]) |
| AM_CONDITIONAL([HAVE_CRYPTSETUP], [true]) |
| SAVE_CFLAGS="$CFLAGS" |
| CFLAGS="$CRYPTSETUP_CFLAGS $CFLAGS" |
| SAVE_LIBS="$LIBS" |
| LIBS="$CRYPTSETUP_LIBS $LIBS" |
| AC_CHECK_LIB([cryptsetup], [crypt_activate_by_signed_key], [ |
| AC_DEFINE_UNQUOTED([HAVE_CRYPT_ACTIVATE_BY_SIGNED_KEY], [1], [Define if crypt_activate_by_signed_key exist in -lcryptsetup]) |
| ]) |
| AS_IF([test "x$with_cryptsetup" = xdlopen], [ |
| LIBS="-ldl $LIBS" |
| AC_CHECK_LIB([dl], [dlsym], [ |
| AC_DEFINE([CRYPTSETUP_VIA_DLOPEN], [1], [Define if cryptsetup is to be loaded via dlopen]) |
| AM_CONDITIONAL([CRYPTSETUP_VIA_DLOPEN], [true]) |
| ], [AC_MSG_ERROR([libdl required to build with cryptsetup support])]) |
| ], [ |
| AM_CONDITIONAL([CRYPTSETUP_VIA_DLOPEN], [false]) |
| ]) |
| CFLAGS="$SAVE_CFLAGS" |
| LIBS="$SAVE_LIBS" |
| have_cryptsetup=yes], |
| [have_cryptsetup=no |
| AM_CONDITIONAL([HAVE_CRYPTSETUP], [false]) |
| AM_CONDITIONAL([CRYPTSETUP_VIA_DLOPEN], [false]) |
| ]) |
| |
| AS_CASE([$with_cryptsetup:$have_cryptsetup], |
| [yes:no], [AC_MSG_WARN([cryptsetup selected but libcryptsetup not found])] |
| ) |
| ]) |
| AC_SUBST([CRYPTSETUP_LIBS]) |
| AC_SUBST([CRYPTSETUP_LIBS_STATIC]) |
| |
| |
| 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} |
| vendordir: ${with_vendordir} |
| |
| compiler: ${CC} |
| cflags: ${CFLAGS} |
| suid cflags: ${SUID_CFLAGS} |
| ldflags: ${LDFLAGS} |
| suid ldflags: ${SUID_LDFLAGS} |
| ASAN enabled: ${enable_asan} |
| |
| Python: ${PYTHON} |
| Python version: ${PYTHON_VERSION} |
| Python libs: ${pyexecdir} |
| |
| Bash completions: ${with_bashcompletiondir} |
| Systemd support: ${have_systemd} |
| Systemd unitdir: ${with_systemdsystemunitdir} |
| libeconf support: ${have_econf} |
| Btrfs support: ${have_btrfs} |
| Wide-char support: ${build_widechar} |
| |
| warnings: |
| |
| ${WARN_CFLAGS} |
| |
| Type 'make' or 'make <utilname>' to compile. |
| ]) |
