mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager
synced 2024-07-03 08:08:46 +00:00
d115dcec50
We are planning on completely dropping Autotools in the future. This breaks the build process with an argument to ignore the deprecation, so that anyone building NM is warned of this change.
1504 lines
58 KiB
Plaintext
1504 lines
58 KiB
Plaintext
AC_PREREQ([2.63])
|
|
|
|
dnl The NM version number
|
|
dnl
|
|
dnl NOTE: When incrementing version also:
|
|
dnl - add corresponding NM_VERSION_x_y_z macros in
|
|
dnl "shared/nm-version-macros.h.in"
|
|
dnl - update number in meson.build
|
|
m4_define([nm_major_version], [1])
|
|
m4_define([nm_minor_version], [49])
|
|
m4_define([nm_micro_version], [0])
|
|
m4_define([nm_version],
|
|
[nm_major_version.nm_minor_version.nm_micro_version])
|
|
|
|
AC_INIT([NetworkManager], [nm_version],
|
|
[http://bugzilla.gnome.org/enter_bug.cgi?product=NetworkManager],
|
|
[NetworkManager])
|
|
|
|
deprecation_message() {
|
|
echo "Building with Autotools is deprecated; meson is the recommended way to build NetworkManager."
|
|
echo "To learn more, see the CONTRIBUTING.md file."
|
|
echo "To ignore this, pass '--disable-autotools-deprecation' when configuring."
|
|
exit 1
|
|
}
|
|
|
|
AC_ARG_ENABLE([autotools-deprecation],
|
|
AS_HELP_STRING([--disable-autotools-deprecation],
|
|
[Building with autotools is deprecated, passing this argument overrides this error.]),
|
|
[ test "$enableval" != "no" && deprecation_message ],
|
|
[ deprecation_message ]
|
|
)
|
|
|
|
AC_CONFIG_HEADERS([config.h])
|
|
AC_CONFIG_MACRO_DIR([m4])
|
|
AC_CONFIG_AUX_DIR([build-aux])
|
|
AC_REQUIRE_AUX_FILE([tap-driver.sh])
|
|
|
|
AM_INIT_AUTOMAKE(1.12 foreign tar-pax no-dist-gzip dist-xz -Wno-portability) dnl NB: Do not [quote] this parameter.
|
|
AM_MAINTAINER_MODE([enable])
|
|
AM_SILENT_RULES([yes])
|
|
|
|
dnl Define _SYSTEM_EXTENSIONS for various things like strcasestr()
|
|
AC_USE_SYSTEM_EXTENSIONS
|
|
|
|
dnl
|
|
dnl Require programs
|
|
dnl
|
|
AC_PROG_CC
|
|
AM_PROG_CC_C_O
|
|
|
|
# C++ only required if --enable-qt=yes
|
|
AC_PROG_CXX
|
|
|
|
AC_PROG_LN_S
|
|
AC_PROG_MKDIR_P
|
|
|
|
# Prefer gcc-* variants; the ones libtool would choose don't work with LTO
|
|
AC_CHECK_TOOLS(AR, [gcc-ar ar], false)
|
|
AC_CHECK_TOOLS(RANLIB, [gcc-ranlib ranlib], :)
|
|
AC_CHECK_TOOLS(NM, [$BINUTILS_NM gcc-nm nm])
|
|
|
|
dnl Initialize libtool
|
|
LT_PREREQ([2.2])
|
|
LT_INIT([disable-static])
|
|
|
|
dnl Version stuff
|
|
NM_MAJOR_VERSION=nm_major_version
|
|
NM_MINOR_VERSION=nm_minor_version
|
|
NM_MICRO_VERSION=nm_micro_version
|
|
NM_VERSION=nm_version
|
|
AC_SUBST(NM_MAJOR_VERSION)
|
|
AC_SUBST(NM_MINOR_VERSION)
|
|
AC_SUBST(NM_MICRO_VERSION)
|
|
AC_SUBST(NM_VERSION)
|
|
|
|
GIT_SHA_RECORD(NM_GIT_SHA)
|
|
|
|
dnl
|
|
dnl Checks for typedefs, structures, and compiler characteristics.
|
|
dnl
|
|
AC_TYPE_PID_T
|
|
AC_CHECK_SIZEOF(pid_t)
|
|
AC_CHECK_SIZEOF(uid_t)
|
|
AC_CHECK_SIZEOF(gid_t)
|
|
AC_CHECK_SIZEOF(dev_t)
|
|
AC_CHECK_SIZEOF(ino_t)
|
|
AC_CHECK_SIZEOF(time_t)
|
|
AC_CHECK_SIZEOF(rlim_t,,[[#include <sys/resource.h>]])
|
|
|
|
AC_CHECK_DECLS([
|
|
explicit_bzero],
|
|
[], [], [[
|
|
#include <string.h>
|
|
]])
|
|
|
|
AC_CHECK_DECLS([
|
|
reallocarray],
|
|
[], [], [[
|
|
#include <malloc.h>
|
|
#include <stdlib.h>
|
|
]])
|
|
|
|
AC_CHECK_DECLS([
|
|
memfd_create],
|
|
[], [], [[
|
|
#include <sys/mman.h>
|
|
]])
|
|
|
|
AC_CHECK_DECLS([
|
|
pidfd_open],
|
|
[], [], [[
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <sys/wait.h>
|
|
]])
|
|
|
|
AC_CHECK_DECLS([
|
|
pidfd_send_signal],
|
|
[], [], [[
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <sys/wait.h>
|
|
]])
|
|
|
|
AC_CHECK_DECLS([
|
|
rt_sigqueueinfo],
|
|
[], [], [[
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <sys/wait.h>
|
|
]])
|
|
|
|
AC_CHECK_HEADERS(sys/auxv.h)
|
|
AC_CHECK_HEADERS(threads.h,
|
|
[],
|
|
[AC_DEFINE([HAVE_THREADS_H], [0], [Define to 1 if you have the <threads.h> header file.])])
|
|
|
|
AC_CHECK_DECLS([getrandom],
|
|
[AC_DEFINE([USE_SYS_RANDOM_H], [1], [sys/random.h is usable])
|
|
AC_DEFINE([HAVE_GETRANDOM], [1], [has getrandom])
|
|
],
|
|
[AC_CHECK_DECLS([getrandom],
|
|
[AC_DEFINE([USE_SYS_RANDOM_H], [0], [sys/random.h is usable])
|
|
AC_DEFINE([HAVE_GETRANDOM], [1], [has getrandom])],
|
|
[AC_DEFINE([USE_SYS_RANDOM_H], [0], [sys/random.h is usable])
|
|
AC_DEFINE([HAVE_GETRANDOM], [0], [has getrandom])],
|
|
[[#include <linux/random.h>
|
|
]])],
|
|
[[#include <sys/random.h>
|
|
]])
|
|
|
|
dnl
|
|
dnl translation support
|
|
dnl
|
|
AM_GNU_GETTEXT([external])
|
|
# Remove AM_GNU_GETTEXT_VERSION once autoreconf supports REQUIRE_VERSION
|
|
AM_GNU_GETTEXT_VERSION([0.19.8])
|
|
AM_GNU_GETTEXT_REQUIRE_VERSION([0.19.8])
|
|
|
|
GETTEXT_PACKAGE=NetworkManager
|
|
AC_SUBST(GETTEXT_PACKAGE)
|
|
AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE", [Gettext package])
|
|
|
|
# autoconf 2.70 adds option --runstatedir. To make the directory also configurable
|
|
# on older versions, add --with-runstatedir option. Note that this option overwrites
|
|
# --runstatedir (should it be set). If you know to use autoconf >= 2.70, you should
|
|
# instead use --runstatedir.
|
|
AC_ARG_WITH([runstatedir],
|
|
AS_HELP_STRING([--with-runstatedir=DIR],
|
|
[Directory for /var/run. Defaults to $localstatedir/run. In autoconf >= 2.70, you should instead use --runstatedir option. This option takes precedence over --runstatedir.]),
|
|
[runstatedir="$withval"])
|
|
AS_IF([test -z "$runstatedir"], runstatedir="$localstatedir/run")
|
|
AC_SUBST(runstatedir)
|
|
|
|
# NetworkManager paths
|
|
AC_SUBST(nmbinary, '${sbindir}'/$PACKAGE, [NetworkManager binary executable])
|
|
AC_SUBST(nmconfdir, '${sysconfdir}'/$PACKAGE, [NetworkManager configuration directory])
|
|
AC_SUBST(nmlibdir, '${prefix}'/lib/$PACKAGE, [NetworkManager library directory])
|
|
AC_SUBST(nmdatadir, '${datadir}'/$PACKAGE, [NetworkManager shared data directory])
|
|
AC_SUBST(nmstatedir, '${localstatedir}'/lib/$PACKAGE, [NetworkManager persistent state directory])
|
|
AC_SUBST(nmrundir, '${runstatedir}'/$PACKAGE, [NetworkManager runtime state directory])
|
|
|
|
AC_CHECK_FUNCS([__secure_getenv secure_getenv])
|
|
|
|
# Alternative configuration plugins
|
|
AC_ARG_ENABLE(ifcfg-rh, AS_HELP_STRING([--enable-ifcfg-rh], [enable ifcfg-rh configuration plugin (Fedora/RHEL) (deprecated)]))
|
|
AC_ARG_ENABLE(ifupdown, AS_HELP_STRING([--enable-ifupdown], [enable ifupdown configuration plugin (Debian/Ubuntu)]))
|
|
# Default alternative plugins by distribution
|
|
AS_IF([test -z "$enable_ifupdown" -a -f /etc/debian_version], enable_ifupdown=yes)
|
|
# Otherwise, plugins default to "no"
|
|
AS_IF([test -z "$enable_ifcfg_rh"], enable_ifcfg_rh=no)
|
|
AS_IF([test -z "$enable_ifupdown"], enable_ifupdown=no)
|
|
# Create automake conditionals
|
|
AM_CONDITIONAL(CONFIG_PLUGIN_IFCFG_RH, test "$enable_ifcfg_rh" = "yes")
|
|
AM_CONDITIONAL(CONFIG_PLUGIN_IFUPDOWN, test "$enable_ifupdown" = "yes")
|
|
|
|
AC_ARG_WITH(config-plugins-default,
|
|
AS_HELP_STRING([--with-config-plugins-default=PLUGINS],
|
|
[Default configuration option for main.plugins setting, used as fallback if the configuration option is unset]),
|
|
[config_plugins_default="$withval"], [config_plugins_default=""])
|
|
|
|
AC_DEFINE_UNQUOTED(NM_CONFIG_DEFAULT_MAIN_PLUGINS, "$config_plugins_default", [Default configuration option for main.plugins setting])
|
|
|
|
if test "$enable_ifcfg_rh" = "yes"; then
|
|
DISTRO_NETWORK_SERVICE=network.service
|
|
fi
|
|
AC_SUBST(DISTRO_NETWORK_SERVICE)
|
|
|
|
if test "$enable_ifcfg_rh" = yes; then
|
|
AC_DEFINE(WITH_CONFIG_PLUGIN_IFCFG_RH, 1, [Build with ifcfg-rh settings plugin])
|
|
else
|
|
AC_DEFINE(WITH_CONFIG_PLUGIN_IFCFG_RH, 0, [Build with ifcfg-rh settings plugin])
|
|
fi
|
|
|
|
if test "$enable_ifupdown" = yes; then
|
|
AC_DEFINE(WITH_CONFIG_PLUGIN_IFUPDOWN, 1, [Build with ifupdown settings plugin])
|
|
else
|
|
AC_DEFINE(WITH_CONFIG_PLUGIN_IFUPDOWN, 0, [Build with ifupdown settings plugin])
|
|
fi
|
|
|
|
# Code coverage
|
|
GNOME_CODE_COVERAGE
|
|
|
|
dnl
|
|
dnl Distribution version string
|
|
dnl
|
|
AC_ARG_WITH(dist-version,
|
|
AS_HELP_STRING([--with-dist-version=<NM-distribution-version>],
|
|
[Define the NM''s distribution version string]),
|
|
ac_distver=$withval, ac_distver=$NM_VERSION)
|
|
AC_DEFINE_UNQUOTED(NM_DIST_VERSION, "$ac_distver", [Define the distribution version string])
|
|
AC_SUBST(NM_DIST_VERSION, "$ac_distver")
|
|
|
|
AC_ARG_ENABLE(wifi, AS_HELP_STRING([--enable-wifi], [enable Wi-Fi support]))
|
|
if test "${enable_wifi}" != "no"; then
|
|
enable_wifi='yes'
|
|
fi
|
|
AM_CONDITIONAL(WITH_WIFI, test "${enable_wifi}" = "yes")
|
|
|
|
dnl
|
|
dnl Default to using WEXT but allow it to be disabled
|
|
dnl
|
|
AC_ARG_WITH(wext,
|
|
AS_HELP_STRING([--with-wext=yes],
|
|
[Enable or disable Linux Wireless Extensions]),
|
|
ac_with_wext=$withval, ac_with_wext="$enable_wifi")
|
|
if test "$ac_with_wext" != 'no'; then
|
|
ac_with_wext='yes'
|
|
fi
|
|
if test x"$ac_with_wext" = x"yes"; then
|
|
if test "$enable_wifi" != "yes"; then
|
|
AC_MSG_ERROR(Enabling WEXT support and disabling Wi-Fi makes no sense)
|
|
fi
|
|
AC_DEFINE(HAVE_WEXT, 1, [Define if you have Linux Wireless Extensions support])
|
|
else
|
|
AC_DEFINE(HAVE_WEXT, 0, [Define if you have Linux Wireless Extensions support])
|
|
fi
|
|
AM_CONDITIONAL(WITH_WEXT, test x"${ac_with_wext}" = x"yes")
|
|
|
|
dnl
|
|
dnl Default to using wpa_supplicant but allow IWD as wifi backend
|
|
dnl
|
|
AC_ARG_WITH(iwd,
|
|
AS_HELP_STRING([--with-iwd=yes],
|
|
[Support IWD as wifi-backend in addition to wpa_supplicant (experimental)]),
|
|
ac_with_iwd=$withval, ac_with_iwd="no")
|
|
if test "$ac_with_iwd" != 'no'; then
|
|
ac_with_iwd='yes'
|
|
fi
|
|
if test x"$ac_with_iwd" = x"yes"; then
|
|
if test "$enable_wifi" != "yes"; then
|
|
AC_MSG_ERROR(Enabling IWD support and disabling Wi-Fi makes no sense)
|
|
fi
|
|
AC_DEFINE(WITH_IWD, 1, [Define to compile with the IWD wifi-backend])
|
|
else
|
|
AC_DEFINE(WITH_IWD, 0, [Define to compile without the IWD wifi-backend])
|
|
fi
|
|
AM_CONDITIONAL(WITH_IWD, test x"${ac_with_iwd}" = x"yes")
|
|
|
|
dnl
|
|
dnl Checks for libdl - on certain platforms its part of libc
|
|
dnl
|
|
AC_SEARCH_LIBS([dlopen], [dl dld],
|
|
[test "$ac_cv_search_dlopen" = "none required" || AC_SUBST([DL_LIBS], "$ac_cv_search_dlopen"]),
|
|
[])
|
|
|
|
PKG_CHECK_MODULES(GLIB, [gio-unix-2.0 >= 2.42 gmodule-2.0])
|
|
|
|
AC_SUBST(LOG_DRIVER, '$(top_srcdir)/build-aux/test-driver')
|
|
|
|
GLIB_CFLAGS="$GLIB_CFLAGS -DGLIB_VERSION_MIN_REQUIRED=GLIB_VERSION_2_42 -DGLIB_VERSION_MAX_ALLOWED=GLIB_VERSION_2_42"
|
|
|
|
AC_SUBST(GLIB_CFLAGS)
|
|
AC_SUBST(GLIB_LIBS)
|
|
|
|
GOBJECT_INTROSPECTION_CHECK([0.9.6])
|
|
|
|
PKG_CHECK_MODULES([LIBUDEV], [libudev >= 175])
|
|
|
|
# Qt4
|
|
PKG_CHECK_MODULES(QT, [QtCore >= 4 QtDBus QtNetwork], [have_qt=yes],[have_qt=no])
|
|
AC_ARG_ENABLE(qt,
|
|
AS_HELP_STRING([--enable-qt], [enable Qt examples]),
|
|
[enable_qt=${enableval}], [enable_qt=${have_qt}])
|
|
if test "${enable_qt}" = "yes"; then
|
|
if test x"$have_qt" = x"no"; then
|
|
AC_MSG_ERROR(Qt development headers are required)
|
|
fi
|
|
# Check for moc-qt4 and if not found then moc
|
|
QT4_BINDIR=`$PKG_CONFIG QtCore --variable moc_location`
|
|
AC_CHECK_PROGS(MOC, [moc-qt4 moc],, [$QT4_BINDIR:$PATH])
|
|
fi
|
|
AM_CONDITIONAL(WITH_QT, test "${enable_qt}" = "yes")
|
|
|
|
AC_ARG_WITH(udev-dir,
|
|
AS_HELP_STRING([--with-udev-dir=DIR],
|
|
[Absolute path of the udev base directory. Set to 'no' not to install the udev rules]),
|
|
[], [with_udev_dir="yes"])
|
|
if test "$with_udev_dir" != 'no'; then
|
|
if test "$with_udev_dir" = 'yes' -o "$with_udev_dir" = "" ; then
|
|
with_udev_dir="\${prefix}/lib/udev"
|
|
else
|
|
if printf '%s' "$with_udev_dir" | grep -v -q '^/'; then
|
|
AC_MSG_ERROR([--with-udev-dir must be an absolute path or 'yes' or 'no'. Instead it is '$with_udev_dir'])
|
|
fi
|
|
fi
|
|
UDEV_DIR="$with_udev_dir"
|
|
AC_SUBST(UDEV_DIR)
|
|
fi
|
|
AM_CONDITIONAL(WITH_UDEV_DIR, test "$with_udev_dir" != 'no')
|
|
|
|
# systemd unit support
|
|
AC_ARG_WITH([systemdsystemunitdir],
|
|
AS_HELP_STRING([--with-systemdsystemunitdir=DIR],
|
|
[Directory for systemd service files]))
|
|
# default location
|
|
AS_IF([test -z "$with_systemdsystemunitdir" && $PKG_CONFIG systemd],
|
|
with_systemdsystemunitdir=`$PKG_CONFIG systemd '--define-variable=prefix=${prefix}' '--define-variable=root_prefix=${prefix}' --variable systemdsystemunitdir`)
|
|
AS_IF([test -z "$with_systemdsystemunitdir"], with_systemdsystemunitdir=no)
|
|
# add conditional and subst
|
|
AM_CONDITIONAL(HAVE_SYSTEMD, [test "$with_systemdsystemunitdir" != no])
|
|
if test "$with_systemdsystemunitdir" != no; then
|
|
AC_SUBST([systemdsystemunitdir], [$with_systemdsystemunitdir])
|
|
fi
|
|
|
|
# Hostname persist mode
|
|
AC_ARG_WITH(hostname-persist,
|
|
AS_HELP_STRING([--with-hostname-persist=default|suse|gentoo|slackware],
|
|
[Hostname persist method]))
|
|
|
|
AS_IF([test "$with_hostname_persist" = "suse"], hostname_persist=suse)
|
|
AS_IF([test "$with_hostname_persist" = "gentoo"], hostname_persist=gentoo)
|
|
AS_IF([test "$with_hostname_persist" = "slackware"], hostname_persist=slackware)
|
|
AS_IF([test "$with_hostname_persist" = "default"], hostname_persist=default)
|
|
# if the method was not explicitly set, try to guess it from the enabled plugins
|
|
AS_IF([test -z "$hostname_persist" -a -f /etc/SuSE-release], hostname_persist=suse)
|
|
AS_IF([test -z "$hostname_persist" -a -f /etc/gentoo-release], hostname_persist=gentoo)
|
|
AS_IF([test -z "$hostname_persist" -a -f /etc/slackware-version], hostname_persist=slackware)
|
|
AS_IF([test -z "$hostname_persist"], hostname_persist=default)
|
|
|
|
if test "$hostname_persist" = suse; then
|
|
AC_DEFINE(HOSTNAME_PERSIST_SUSE, 1, [Enable SuSE hostname persist method])
|
|
elif test "$hostname_persist" = gentoo; then
|
|
AC_DEFINE(HOSTNAME_PERSIST_GENTOO, 1, [Enable Gentoo hostname persist method])
|
|
elif test "$hostname_persist" = slackware; then
|
|
AC_DEFINE(HOSTNAME_PERSIST_SLACKWARE, 1, [Enable Slackware hostname persist method])
|
|
fi
|
|
|
|
PKG_CHECK_MODULES(LIBSYSTEMD, [libsystemd >= 209],
|
|
[AC_DEFINE([HAVE_LIBSYSTEMD], 1, [Define to 1 if libsystemd is available])],
|
|
[AC_DEFINE([HAVE_LIBSYSTEMD], 0, [Define to 1 if libsystemd is available])])
|
|
|
|
AC_ARG_WITH(systemd-journal,
|
|
AS_HELP_STRING([--with-systemd-journal=yes|no],
|
|
[Use systemd journal for logging]))
|
|
have_systemd_journal=no
|
|
if test "$with_systemd_journal" != "no"; then
|
|
PKG_CHECK_MODULES(SYSTEMD_JOURNAL, [libsystemd >= 209], [have_systemd_journal=yes],
|
|
[PKG_CHECK_MODULES(SYSTEMD_JOURNAL,
|
|
[libsystemd-journal],
|
|
[have_systemd_journal=yes],
|
|
[have_systemd_journal=no])])
|
|
if test "$have_systemd_journal" != "yes"; then
|
|
if test "$with_systemd_journal" = "yes"; then
|
|
AC_MSG_ERROR([Missing systemd-journald support])
|
|
fi
|
|
fi
|
|
fi
|
|
if test "$have_systemd_journal" = "yes"; then
|
|
AC_DEFINE([SYSTEMD_JOURNAL], 1, [Define to 1 if libsystemd-journald is available])
|
|
else
|
|
AC_DEFINE([SYSTEMD_JOURNAL], 0, [Define to 1 if libsystemd-journald is available])
|
|
fi
|
|
|
|
AC_ARG_WITH(config-logging-backend-default,
|
|
AS_HELP_STRING([--with-config-logging-backend-default=backend],
|
|
[Default value for logging.backend]),
|
|
nm_config_logging_backend_default="$withval",
|
|
nm_config_logging_backend_default="")
|
|
|
|
if test "$nm_config_logging_backend_default" != 'syslog' \
|
|
-a "$nm_config_logging_backend_default" != 'journal'; then
|
|
# unknown backend. Reset to default. Silently accept the invalid value to
|
|
# be future proof.
|
|
nm_config_logging_backend_default=''
|
|
fi
|
|
if test "$nm_config_logging_backend_default" = ""; then
|
|
if test "$have_systemd_journal" = "yes"; then
|
|
nm_config_logging_backend_default='journal'
|
|
else
|
|
nm_config_logging_backend_default='syslog'
|
|
fi
|
|
fi
|
|
AC_DEFINE_UNQUOTED(NM_CONFIG_DEFAULT_LOGGING_BACKEND, "$nm_config_logging_backend_default", [Default configuration option for logging.backend])
|
|
NM_CONFIG_DEFAULT_LOGGING_BACKEND_TEXT="$nm_config_logging_backend_default"
|
|
AC_SUBST(NM_CONFIG_DEFAULT_LOGGING_BACKEND_TEXT)
|
|
|
|
AC_ARG_WITH(config-migrate-ifcfg-rh-default,
|
|
AS_HELP_STRING([--with-config-migrate-ifcfg-rh-default=yes|no],
|
|
[Default value for main.migrate-ifcfg-rh]),
|
|
nm_config_migrate_ifcfg_rh_default="$withval",
|
|
nm_config_migrate_ifcfg_rh_default="no")
|
|
|
|
if test "$nm_config_migrate_ifcfg_rh_default" = yes; then
|
|
if test "$enable_ifcfg_rh" = no; then
|
|
AC_MSG_ERROR([ifcfg-rh migration can be enabled by default only when the ifcfg-rh plugin is enabled])
|
|
fi
|
|
AC_DEFINE(NM_CONFIG_DEFAULT_MAIN_MIGRATE_IFCFG_RH, "true", [The default value of the main.migrate-ifcfg-rh configuration option])
|
|
NM_CONFIG_DEFAULT_MAIN_MIGRATE_IFCFG_RH_TEXT='true'
|
|
elif test "$nm_config_migrate_ifcfg_rh_default" = no; then
|
|
AC_DEFINE(NM_CONFIG_DEFAULT_MAIN_MIGRATE_IFCFG_RH, "false", [The default value of the main.migrate-ifcfg-rh configuration option])
|
|
NM_CONFIG_DEFAULT_MAIN_MIGRATE_IFCFG_RH_TEXT='false'
|
|
else
|
|
AC_MSG_ERROR([The value of --with-config-migrate-ifcfg-rh-default must be either "yes" or "no".])
|
|
fi
|
|
AC_SUBST(NM_CONFIG_DEFAULT_MAIN_MIGRATE_IFCFG_RH_TEXT)
|
|
|
|
AC_ARG_WITH(config-wifi-backend-default,
|
|
AS_HELP_STRING([--with-config-wifi-backend-default=backend],
|
|
[Default value for wifi.backend]),
|
|
nm_config_wifi_backend_default="$withval",
|
|
nm_config_wifi_backend_default="wpa_supplicant")
|
|
|
|
if test "$nm_config_wifi_backend_default" != 'iwd' \
|
|
-a "$nm_config_wifi_backend_default" != 'wpa_supplicant'; then
|
|
AC_MSG_ERROR([The default Wi-Fi backend must be either wpa_supplicant or iwd.])
|
|
fi
|
|
if test "$nm_config_wifi_backend_default" = "iwd"; then
|
|
if test "$ac_with_iwd" != "yes"; then
|
|
AC_MSG_ERROR([Setting the default Wi-Fi backend to iwd requires iwd support.])
|
|
fi
|
|
fi
|
|
AC_DEFINE_UNQUOTED(NM_CONFIG_DEFAULT_WIFI_BACKEND, "$nm_config_wifi_backend_default", [Default configuration option for wifi.backend])
|
|
NM_CONFIG_DEFAULT_WIFI_BACKEND_TEXT="$nm_config_wifi_backend_default"
|
|
AC_SUBST(NM_CONFIG_DEFAULT_WIFI_BACKEND_TEXT)
|
|
|
|
# Session tracking support
|
|
AC_ARG_WITH(systemd-logind,
|
|
AS_HELP_STRING([--with-systemd-logind=yes|no],
|
|
[Support systemd session tracking]))
|
|
AC_ARG_WITH(consolekit,
|
|
AS_HELP_STRING([--with-consolekit=yes|no],
|
|
[Support consolekit session tracking]))
|
|
AC_ARG_WITH(session-tracking,
|
|
AS_HELP_STRING([--with-session-tracking=systemd|elogind|consolekit|no],
|
|
[Compatibility option to choose one session tracking module]))
|
|
# backwards compatibility
|
|
AS_IF([test "$with_session_tracking" = "ck"], [use_consolekit="yes" use_systemd_logind="no" use_elogind="no"])
|
|
AS_IF([test "$with_session_tracking" = "consolekit"], [use_consolekit="yes" use_systemd_logind="no" use_elogind="no"])
|
|
AS_IF([test "$with_session_tracking" = "systemd"], [use_consolekit="no" use_systemd_logind="yes" use_elogind="no"])
|
|
AS_IF([test "$with_session_tracking" = "elogind"], [use_consolekit="no" use_systemd_logind="no" use_elogind="yes"])
|
|
AS_IF([test "$with_session_tracking" = "no"], [use_consolekit="no" use_systemd_logind="no" use_elogind="no"])
|
|
AS_IF([test "$with_session_tracking" = "none"], [use_consolekit="no" use_systemd_logind="no" use_elogind="no"])
|
|
# current options
|
|
AS_IF([test -n "$with_systemd_logind" ], [use_systemd_logind="$with_systemd_logind"])
|
|
AS_IF([test -n "$with_consolekit" ], [use_consolekit="$with_consolekit"])
|
|
# defaults
|
|
AS_IF([test -z "$use_systemd_logind"], [use_systemd_logind="auto"])
|
|
AS_IF([test -z "$use_consolekit"], [use_consolekit="yes"])
|
|
# output
|
|
session_tracking=
|
|
if test "$use_systemd_logind" = "yes" -o "$use_systemd_logind" = "auto"; then
|
|
PKG_CHECK_MODULES(SYSTEMD_LOGIN, [libsystemd], [have_systemd_logind=yes], [PKG_CHECK_MODULES(SYSTEMD_LOGIN, [libsystemd-login], [have_systemd_logind=yes], [have_systemd_logind=no])])
|
|
else
|
|
have_systemd_logind=no
|
|
fi
|
|
if test "$use_systemd_logind" = "yes" -a "$have_systemd_logind" = "no"; then
|
|
AC_MSG_ERROR([You must have libsystemd installed to build with systemd-logind support.])
|
|
fi
|
|
if test "$have_systemd_logind" = "yes"; then
|
|
AC_DEFINE([SESSION_TRACKING_SYSTEMD], 1, [Define to 1 if libsystemd-login is available])
|
|
session_tracking="$session_tracking, systemd-logind"
|
|
else
|
|
AC_DEFINE([SESSION_TRACKING_SYSTEMD], 0, [Define to 1 if libsystemd-login is available])
|
|
fi
|
|
|
|
if test "$use_elogind" = "yes" -a "$have_systemd_logind" = "yes"; then
|
|
AC_MSG_ERROR([Cannot enable systemd-logind together with elogind.])
|
|
fi
|
|
if test "$use_elogind" = "yes"; then
|
|
PKG_CHECK_MODULES(SYSTEMD_LOGIN, [libelogind], [have_elogind=yes], [PKG_CHECK_MODULES(SYSTEMD_LOGIN, [libelogind], [have_elogind=yes], [have_elogind=no])])
|
|
else
|
|
have_elogind=no
|
|
fi
|
|
if test "$use_elogind" = "yes" -a "$have_elogind" = "no"; then
|
|
AC_MSG_ERROR([You must have libelogind installed to build with elogind support.])
|
|
fi
|
|
if test "$have_elogind" = "yes"; then
|
|
AC_DEFINE([SESSION_TRACKING_ELOGIND], 1, [Define to 1 if libelogin is available])
|
|
session_tracking="$session_tracking, elogind"
|
|
else
|
|
AC_DEFINE([SESSION_TRACKING_ELOGIND], 0, [Define to 1 if libelogin is available])
|
|
fi
|
|
|
|
if test "$use_consolekit" = "yes"; then
|
|
AC_DEFINE([SESSION_TRACKING_CONSOLEKIT], 1, [Define to 1 if ConsoleKit is available])
|
|
session_tracking="$session_tracking, consolekit"
|
|
else
|
|
AC_DEFINE([SESSION_TRACKING_CONSOLEKIT], 0, [Define to 1 if ConsoleKit is available])
|
|
fi
|
|
session_tracking="$(printf '%s' "${session_tracking}" | sed 's/^, //')"
|
|
|
|
AC_ARG_WITH(suspend-resume,
|
|
AS_HELP_STRING([--with-suspend-resume=systemd|elogind|consolekit],
|
|
[Build NetworkManager with specific suspend/resume support]))
|
|
if test "z$with_suspend_resume" = "z"; then
|
|
PKG_CHECK_EXISTS([libsystemd >= 209], [have_systemd_inhibit=yes],
|
|
[PKG_CHECK_EXISTS([libsystemd-login >= 183], [have_systemd_inhibit=yes], [have_systemd_inhibit=no])])
|
|
if test "z${have_systemd_inhibit}" = "zyes"; then
|
|
# Use systemd if it's new enough
|
|
with_suspend_resume="systemd"
|
|
else
|
|
PKG_CHECK_EXISTS([libelogind >= 219], [have_elogind_inhibit=yes],
|
|
[PKG_CHECK_EXISTS([libelogind >= 219], [have_elogind_inhibit=yes], [have_elogind_inhibit=no])])
|
|
if test "z${have_elogind_inhibit}" = "zyes"; then
|
|
# Use elogind if it's new enough
|
|
with_suspend_resume="elogind"
|
|
else
|
|
# Fallback to consolekit
|
|
with_suspend_resume="consolekit"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
case $with_suspend_resume in
|
|
systemd)
|
|
PKG_CHECK_MODULES(SYSTEMD_INHIBIT, [libsystemd >= 209],,
|
|
[PKG_CHECK_MODULES(SYSTEMD_INHIBIT, [libsystemd-login >= 183])])
|
|
AC_DEFINE([SUSPEND_RESUME_SYSTEMD], 1, [Define to 1 to use systemd suspend api])
|
|
;;
|
|
elogind)
|
|
PKG_CHECK_MODULES(ELOGIND_INHIBIT, [libelogind >= 219],,
|
|
[PKG_CHECK_MODULES(ELOGIND_INHIBIT, [libelogind >= 219])])
|
|
AC_DEFINE([SUSPEND_RESUME_ELOGIND], 1, [Define to 1 to use elogind suspend api])
|
|
;;
|
|
consolekit)
|
|
AC_DEFINE([SUSPEND_RESUME_CONSOLEKIT], 1, [Define to 1 to use ConsoleKit2 suspend api])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR(--with-suspend-resume must be one of [systemd, elogind, consolekit])
|
|
;;
|
|
esac
|
|
|
|
# eBPF support
|
|
AC_ARG_WITH(ebpf,
|
|
AS_HELP_STRING([--with-ebpf=yes|no|auto], [Build with eBPF support [default=auto]]),
|
|
[], [with_ebpf=auto])
|
|
# 'auto' means 'false' because there are still some issues.
|
|
if test "$with_ebpf" = "yes" ; then
|
|
AC_CHECK_HEADER(linux/bpf.h, [have_ebpf=yes], [have_ebpf=no])
|
|
else
|
|
have_ebpf=no
|
|
fi
|
|
if test "$with_ebpf" = "yes" -a "$have_ebpf" = "no"; then
|
|
AC_MSG_ERROR([--with-ebpf=yes requires eBPF kernel header])
|
|
fi
|
|
AM_CONDITIONAL(WITH_EBPF, test "${have_ebpf}" = "yes")
|
|
|
|
# SELinux support
|
|
AC_ARG_WITH(selinux,
|
|
AS_HELP_STRING([--with-selinux=yes|no|auto], [Build with SELinux [default=auto]]),
|
|
[], [with_selinux=auto])
|
|
if test "$with_selinux" = "yes" -o "$with_selinux" = "auto"; then
|
|
PKG_CHECK_MODULES(SELINUX, libselinux, [have_selinux=yes], [have_selinux=no])
|
|
else
|
|
have_selinux=no
|
|
fi
|
|
if test "$with_selinux" = "yes" -a "$have_selinux" = "no"; then
|
|
AC_MSG_ERROR([You must have libselinux installed to build --with-selinux=yes.])
|
|
fi
|
|
if test "$have_selinux" = "yes"; then
|
|
AC_DEFINE(HAVE_SELINUX, 1, [Define if you have SELinux support])
|
|
else
|
|
AC_DEFINE(HAVE_SELINUX, 0, [Define if you have SELinux support])
|
|
fi
|
|
|
|
# libaudit support
|
|
AC_ARG_WITH(libaudit, AS_HELP_STRING([--with-libaudit=yes|yes-disabled-by-default|no|auto], [Build with audit daemon support [default=auto]. yes-disabled-by-default enables support, but disables it unless explicitly configured via NetworkManager.conf]),,[with_libaudit=auto])
|
|
if test "$with_libaudit" = "yes" -o "$with_libaudit" = "yes-disabled-by-default" -o "$with_libaudit" = "auto"; then
|
|
PKG_CHECK_MODULES(LIBAUDIT, audit, [have_libaudit=yes], [have_libaudit=no])
|
|
if test "$with_libaudit" != "auto" -a "$have_libaudit" = "no"; then
|
|
AC_MSG_ERROR([You must have libaudit installed to build --with-libaudit=$with_libaudit.])
|
|
fi
|
|
else
|
|
have_libaudit=no
|
|
fi
|
|
if test "$have_libaudit" = "yes"; then
|
|
AC_DEFINE(HAVE_LIBAUDIT, 1, [Define if you have libaudit support])
|
|
if test "$with_libaudit" = "yes-disabled-by-default"; then
|
|
AC_DEFINE(NM_CONFIG_DEFAULT_LOGGING_AUDIT, "false", [The default value of the logging.audit configuration option])
|
|
NM_CONFIG_DEFAULT_LOGGING_AUDIT_TEXT='false'
|
|
else
|
|
AC_DEFINE(NM_CONFIG_DEFAULT_LOGGING_AUDIT, "true", [The default value of the logging.audit configuration option])
|
|
NM_CONFIG_DEFAULT_LOGGING_AUDIT_TEXT='true'
|
|
fi
|
|
else
|
|
AC_DEFINE(HAVE_LIBAUDIT, 0, [Define if you have libaudit support])
|
|
AC_DEFINE(NM_CONFIG_DEFAULT_LOGGING_AUDIT, "false", [The default value of the logging.audit configuration option])
|
|
NM_CONFIG_DEFAULT_LOGGING_AUDIT_TEXT='false'
|
|
fi
|
|
AC_SUBST(NM_CONFIG_DEFAULT_LOGGING_AUDIT_TEXT)
|
|
|
|
# uuid library
|
|
PKG_CHECK_MODULES(UUID, uuid)
|
|
|
|
# Teamd control checks
|
|
|
|
PKG_CHECK_MODULES(JANSSON, [jansson >= 2.7], [have_jansson=yes], [have_jansson=no])
|
|
if test "$have_jansson" = "yes"; then
|
|
AC_DEFINE(WITH_JANSSON, 1, [Define if JANSSON is enabled])
|
|
|
|
AC_CHECK_TOOLS(READELF, [eu-readelf readelf])
|
|
JANSSON_LIBDIR=`$PKG_CONFIG --variable=libdir jansson`
|
|
JANSSON_SONAME=`$READELF -d $JANSSON_LIBDIR/libjansson.so |sed -n 's/.*SONAME.*\[[\([^]]*\)]]/\1/p'`
|
|
|
|
if test "$JANSSON_SONAME" = ""; then
|
|
AC_MSG_ERROR(Unable to locate the Jansson library)
|
|
fi
|
|
AC_DEFINE_UNQUOTED(JANSSON_SONAME, "$JANSSON_SONAME", [Define to path to the Jansson shared library])
|
|
else
|
|
have_jansson=no
|
|
JANSSON_SONAME=
|
|
AC_DEFINE(WITH_JANSSON, 0, [Define if JANSSON is enabled])
|
|
fi
|
|
AM_CONDITIONAL(WITH_JANSSON, test "${have_jansson}" = "yes")
|
|
|
|
PKG_CHECK_MODULES(LIBTEAMDCTL, [libteamdctl >= 1.9], [have_teamdctl=yes],[have_teamdctl=no])
|
|
if test "$have_jansson" = "yes" -a "$have_teamdctl" = "yes"; then
|
|
have_team_prereq=yes
|
|
else
|
|
have_team_prereq=no
|
|
fi
|
|
|
|
AC_ARG_ENABLE(teamdctl,
|
|
AS_HELP_STRING([--enable-teamdctl], [enable Teamd control support]),
|
|
[enable_teamdctl=${enableval}], [enable_teamdctl=${have_team_prereq}])
|
|
if test "${enable_teamdctl}" = "yes"; then
|
|
if test "$have_teamdctl" = "no"; then
|
|
AC_MSG_ERROR(Libteamdctl is required for team support)
|
|
fi
|
|
if test "$have_jansson" = "no"; then
|
|
AC_MSG_ERROR(Jansson is required for team support)
|
|
fi
|
|
# temporary bug workaround
|
|
LIBTEAMDCTL_CFLAGS=`echo $LIBTEAMDCTL_CFLAGS | sed -e 's:/teamdctl.h::'`
|
|
fi
|
|
AM_CONDITIONAL(WITH_TEAMDCTL, test "${enable_teamdctl}" = "yes")
|
|
|
|
# we usually compile with polkit support. --enable-polkit=yes|no only sets the
|
|
# default configuration for main.auth-polkit. User can always enable/disable polkit
|
|
# authorization via config.
|
|
AC_ARG_ENABLE(polkit,
|
|
AS_HELP_STRING([--enable-polkit=yes|no|root-only],
|
|
[set default value for auth-polkit configuration option. This value can be overwritten by NM configuration. 'disabled' is an alias for 'no']),
|
|
[enable_polkit=${enableval}], [enable_polkit=yes])
|
|
if test "${enable_polkit}" = "root-only" ; then
|
|
enable_polkit='root-only'
|
|
elif test "${enable_polkit}" != "no" -a "${enable_polkit}" != "disabled" ; then
|
|
enable_polkit=true
|
|
else
|
|
enable_polkit=false
|
|
fi
|
|
AC_DEFINE_UNQUOTED(NM_CONFIG_DEFAULT_MAIN_AUTH_POLKIT, "$enable_polkit", [The default value of the auth-polkit configuration option])
|
|
AC_SUBST(NM_CONFIG_DEFAULT_MAIN_AUTH_POLKIT_TEXT, "$enable_polkit")
|
|
|
|
AC_ARG_WITH([polkit-agent-helper-1],
|
|
AS_HELP_STRING([--with-polkit-agent-helper-1=/path/to/polkit-agent-helper-1],
|
|
[Path to the polkit-agent-helper-1 binary from polkit]),
|
|
POLKIT_AGENT_HELPER_1_PATH="$withval",
|
|
POLKIT_AGENT_HELPER_1_PATH="")
|
|
if test -z "$POLKIT_AGENT_HELPER_1_PATH" ; then
|
|
for p in /usr/libexec/polkit-agent-helper-1 \
|
|
/usr/lib/polkit-1/polkit-agent-helper-1 \
|
|
/usr/lib/policykit-1/polkit-agent-helper-1 ; do
|
|
if test -f "$p" ; then
|
|
POLKIT_AGENT_HELPER_1_PATH="$p"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
test -z "$POLKIT_AGENT_HELPER_1_PATH" && POLKIT_AGENT_HELPER_1_PATH=/usr/lib/polkit-1/polkit-agent-helper-1
|
|
if test "$POLKIT_AGENT_HELPER_1_PATH" = "${POLKIT_AGENT_HELPER_1_PATH#/}" ; then
|
|
AC_MSG_ERROR(["polkit_agent_helper_1 must be an absolute path, but is '$POLKIT_AGENT_HELPER_1_PATH'"])
|
|
fi
|
|
AC_DEFINE_UNQUOTED([POLKIT_AGENT_HELPER_1_PATH],
|
|
["$POLKIT_AGENT_HELPER_1_PATH"],
|
|
[path to polkit-agent-helper-1 binary])
|
|
|
|
AC_ARG_ENABLE(modify-system, AS_HELP_STRING([--enable-modify-system], [Allow users to modify system connections]))
|
|
if test "${enable_modify_system}" = "yes"; then
|
|
NM_MODIFY_SYSTEM_POLICY="yes"
|
|
else
|
|
NM_MODIFY_SYSTEM_POLICY="auth_admin_keep"
|
|
fi
|
|
AC_SUBST(NM_MODIFY_SYSTEM_POLICY)
|
|
|
|
AC_ARG_ENABLE(firewalld-zone,
|
|
AS_HELP_STRING([--enable-firewalld-zone], [Install and use firewalld zone for shared mode]),
|
|
[enable_firewalld_zone=${enableval}],
|
|
[enable_firewalld_zone=yes])
|
|
|
|
if test "${enable_firewalld_zone}" = "yes"; then
|
|
AC_DEFINE(WITH_FIREWALLD_ZONE, 1, [Define if NetworkManager uses a custom zone for shared mode])
|
|
else
|
|
AC_DEFINE(WITH_FIREWALLD_ZONE, 0, [Define if NetworkManager uses a custom zone for shared mode])
|
|
fi
|
|
AM_CONDITIONAL(WITH_FIREWALLD_ZONE, test "${enable_firewalld_zone}" = "yes")
|
|
|
|
PKG_CHECK_MODULES(GNUTLS, [gnutls >= 2.12], [have_crypto_gnutls=yes], [have_crypto_gnutls=no])
|
|
PKG_CHECK_MODULES(NSS, [nss], [have_crypto_nss=yes], [have_crypto_nss=yes])
|
|
if test "${have_crypto_nss}" = "yes"; then
|
|
# Work around a pkg-config bug (fdo #29801) where exists != usable
|
|
FOO=`$PKG_CONFIG --cflags --libs nss`
|
|
if test x"$?" != "x0"; then
|
|
have_crypto_nss=no
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL(HAVE_CRYPTO_GNUTLS, test "${have_crypto_gnutls}" = 'yes')
|
|
AM_CONDITIONAL(HAVE_CRYPTO_NSS, test "${have_crypto_nss}" = 'yes')
|
|
|
|
AC_ARG_WITH(crypto,
|
|
AS_HELP_STRING([--with-crypto=nss|gnutls|null],
|
|
[Cryptography library to use for certificate and key operations]),
|
|
with_crypto=$withval,
|
|
with_crypto=nss)
|
|
if test "$with_crypto" = 'nss'; then
|
|
if test "${have_crypto_nss}" != "yes"; then
|
|
AC_MSG_ERROR([No usable NSS found for --with-crypto=nss])
|
|
fi
|
|
elif test "$with_crypto" = 'gnutls'; then
|
|
if test "${have_crypto_gnutls}" != "yes"; then
|
|
AC_MSG_ERROR([No usable gnutls found for --with-crypto=gnutls])
|
|
fi
|
|
elif test "$with_crypto" = 'null'; then
|
|
:
|
|
else
|
|
AC_MSG_ERROR([Please choose either 'nss', 'gnutls' or 'null' for certificate and crypto operations])
|
|
fi
|
|
AM_CONDITIONAL(WITH_NSS, test "$with_crypto" = 'nss')
|
|
AM_CONDITIONAL(WITH_GNUTLS, test "$with_crypto" = 'gnutls')
|
|
|
|
GLIB_MAKEFILE='$(top_srcdir)/Makefile.glib'
|
|
AC_SUBST(GLIB_MAKEFILE)
|
|
GLIB_MKENUMS=`$PKG_CONFIG --variable=glib_mkenums glib-2.0`
|
|
AC_SUBST(GLIB_MKENUMS)
|
|
|
|
AC_ARG_WITH(dbus-sys-dir,
|
|
AS_HELP_STRING([--with-dbus-sys-dir=DIR], [where D-BUS system.d directory is]))
|
|
if test -n "$with_dbus_sys_dir" ; then
|
|
DBUS_SYS_DIR="$with_dbus_sys_dir"
|
|
else
|
|
DBUS_SYS_DIR="${datadir}/dbus-1/system.d"
|
|
fi
|
|
AC_SUBST(DBUS_SYS_DIR)
|
|
|
|
# pppd
|
|
NM_PPP_VERSION_2_5_OR_NEWER=0
|
|
PPPD_VERSION=2.4.9
|
|
PKG_CHECK_EXISTS([pppd], [
|
|
PPPD_VERSION=`$PKG_CONFIG --modversion pppd`
|
|
PPPD_CFLAGS=`$PKG_CONFIG --cflags pppd`
|
|
NM_PPP_VERSION_2_5_OR_NEWER=1
|
|
])
|
|
|
|
AC_ARG_ENABLE(ppp,
|
|
AS_HELP_STRING([--enable-ppp], [enable PPP/PPPoE support]),
|
|
[enable_ppp=${enableval}], [enable_ppp=yes])
|
|
if test "${enable_ppp}" = "yes"; then
|
|
if test -z "$PPPD_CFLAGS" ; then
|
|
AC_CHECK_HEADERS(pppd/pppd.h,,
|
|
AC_MSG_ERROR("couldn't find pppd.h. pppd development headers are required."),)
|
|
fi
|
|
AC_SUBST(PPPD_CFLAGS, ["$PPPD_CFLAGS"])
|
|
AC_DEFINE(WITH_PPP, 1, [Define if you have PPP support])
|
|
else
|
|
AC_DEFINE(WITH_PPP, 0, [Define if you have PPP support])
|
|
fi
|
|
AM_CONDITIONAL(WITH_PPP, test "${enable_ppp}" = "yes")
|
|
|
|
AC_ARG_WITH([pppd-plugin-dir],
|
|
AS_HELP_STRING([--with-pppd-plugin-dir=DIR], [path to the pppd plugins directory]))
|
|
if test -n "$with_pppd_plugin_dir" ; then
|
|
PPPD_PLUGIN_DIR="$with_pppd_plugin_dir"
|
|
else
|
|
PPPD_PLUGIN_DIR="${libdir}/pppd/$PPPD_VERSION"
|
|
fi
|
|
AC_SUBST(PPPD_PLUGIN_DIR)
|
|
AC_DEFINE_UNQUOTED(NM_PPP_VERSION_2_5_OR_NEWER, $NM_PPP_VERSION_2_5_OR_NEWER, [The detected ppp API version])
|
|
|
|
AC_ARG_WITH(pppd, AS_HELP_STRING([--with-pppd=/path/to/pppd], [path to pppd binary]))
|
|
if test "x${with_pppd}" = x; then
|
|
AC_PATH_PROG(PPPD_PATH, pppd, [], $PATH:/sbin:/usr/sbin)
|
|
else
|
|
PPPD_PATH="$with_pppd"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(PPPD_PATH, "$PPPD_PATH", [Define to path of pppd binary])
|
|
AC_SUBST(PPPD_PATH)
|
|
|
|
# ModemManager1 with libmm-glib
|
|
AC_ARG_WITH(modem-manager-1,
|
|
AS_HELP_STRING([--with-modem-manager-1],
|
|
[Enable new ModemManager1 interface support]),
|
|
[], [with_modem_manager_1=auto])
|
|
if test "${with_modem_manager_1}" != "no"; then
|
|
PKG_CHECK_MODULES(MM_GLIB,
|
|
[mm-glib >= 0.7.991],
|
|
[have_libmm_glib=yes],
|
|
[have_libmm_glib=no])
|
|
|
|
if test "${have_libmm_glib}" = "no"; then
|
|
if test "${with_modem_manager_1}" = "yes"; then
|
|
AC_MSG_ERROR([Couldn't find libmm-glib])
|
|
else
|
|
with_modem_manager_1="no"
|
|
fi
|
|
else
|
|
with_modem_manager_1="yes"
|
|
|
|
PKG_CHECK_MODULES(MOBILE_BROADBAND_PROVIDER_INFO, [mobile-broadband-provider-info],
|
|
[MOBILE_BROADBAND_PROVIDER_INFO_DATABASE=`$PKG_CONFIG --variable=database mobile-broadband-provider-info`],
|
|
[MOBILE_BROADBAND_PROVIDER_INFO_DATABASE="$prefix/share/mobile-broadband-provider-info/serviceproviders.xml"])
|
|
AC_DEFINE_UNQUOTED([MOBILE_BROADBAND_PROVIDER_INFO_DATABASE],
|
|
["$MOBILE_BROADBAND_PROVIDER_INFO_DATABASE"],
|
|
[Mobile Broadband Service Provider Information Database location])
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL(WITH_MODEM_MANAGER_1, test "${with_modem_manager_1}" = "yes")
|
|
|
|
|
|
|
|
|
|
# Bluez5 DUN support
|
|
PKG_CHECK_MODULES(BLUEZ5, [bluez >= 5], [have_bluez5=yes],[have_bluez5=no])
|
|
AC_ARG_ENABLE(bluez5-dun,
|
|
AS_HELP_STRING([--enable-bluez5-dun], [enable Bluez5 DUN support]),
|
|
[enable_bluez5_dun=${enableval}], [enable_bluez5_dun=${have_bluez5}])
|
|
if test "${enable_bluez5_dun}" = "yes"; then
|
|
if test x"$have_bluez5" = x"no"; then
|
|
AC_MSG_ERROR(Bluez 5.x development headers are required)
|
|
fi
|
|
AC_DEFINE(WITH_BLUEZ5_DUN, 1, [Define if you have Bluez 5 libraries])
|
|
else
|
|
AC_DEFINE(WITH_BLUEZ5_DUN, 0, [Define if you have Bluez 5 libraries])
|
|
fi
|
|
AM_CONDITIONAL(WITH_BLUEZ5_DUN, test "${enable_bluez5_dun}" = "yes")
|
|
|
|
# OFONO
|
|
AC_ARG_WITH(ofono,
|
|
AS_HELP_STRING([--with-ofono], [Enable oFono support (experimental)]),
|
|
[], [with_ofono=no])
|
|
if test "${with_ofono}" = "yes"; then
|
|
AC_DEFINE(WITH_OFONO, 1, [Define if you have oFono support (experimental)])
|
|
else
|
|
AC_DEFINE(WITH_OFONO, 0, [Define if you have oFono support (experimental)])
|
|
fi
|
|
AM_CONDITIONAL(WITH_OFONO, test "${with_ofono}" = "yes")
|
|
|
|
# DHCP client support with dhcpcanon
|
|
AC_ARG_WITH([dhcpcanon],
|
|
AS_HELP_STRING([--with-dhcpcanon=yes|no|path], [Enable dhcpcanon support (experimental)]))
|
|
if test "$with_dhcpcanon" != "no"; then
|
|
with_dhcpcanon_="$with_dhcpcanon"
|
|
AC_PATH_PROGS(with_dhcpcanon, dhcpcanon, no, /sbin:/usr/sbin:/usr/local/sbin:/usr/bin:/usr/local/bin)
|
|
if test "$with_dhcpcanon" = "no"; then
|
|
if test "$with_dhcpcanon_" = yes; then
|
|
AC_MSG_WARN([dhcpcanon not found, assume path /sbin/dhcpcanon])
|
|
with_dhcpcanon=/sbin/dhcpcanon
|
|
fi
|
|
fi
|
|
fi
|
|
if test "$with_dhcpcanon" != "no"; then
|
|
AC_DEFINE(WITH_DHCPCANON, 1, [Define if you have dhcpcanon])
|
|
AC_DEFINE_UNQUOTED(DHCPCANON_PATH, "$with_dhcpcanon", [Define path to dhcpcanon])
|
|
else
|
|
AC_DEFINE(WITH_DHCPCANON, 0, [Define if you have dhcpcanon])
|
|
fi
|
|
|
|
# Open vSwitch integration
|
|
AC_ARG_ENABLE(ovs, AS_HELP_STRING([--enable-ovs], [enable Open vSwitch support]))
|
|
if test "${enable_ovs}" != "no"; then
|
|
enable_ovs='yes'
|
|
if test "$have_jansson" = "no"; then
|
|
AC_MSG_ERROR(Jansson is required for ovs support)
|
|
fi
|
|
fi
|
|
AM_CONDITIONAL(WITH_OPENVSWITCH, test "${enable_ovs}" = "yes")
|
|
if test "${enable_ovs}" = "yes" ; then
|
|
AC_DEFINE(WITH_OPENVSWITCH, 1, [Whether we build with OVS plugin])
|
|
else
|
|
AC_DEFINE(WITH_OPENVSWITCH, 0, [Whether we build with OVS plugin])
|
|
fi
|
|
|
|
# DHCP client support
|
|
AC_ARG_WITH([dhclient],
|
|
AS_HELP_STRING([--with-dhclient=yes|no|path], [Enable dhclient support]))
|
|
if test "$with_dhclient" != "no"; then
|
|
with_dhclient_="$with_dhclient"
|
|
AC_PATH_PROGS(with_dhclient, dhclient, no, /sbin:/usr/sbin:/usr/local/sbin)
|
|
if test "$with_dhclient" = "no"; then
|
|
if test "$with_dhclient_" = yes; then
|
|
AC_MSG_WARN([dhclient not found, assume path /usr/sbin/dhclient])
|
|
with_dhclient=/usr/sbin/dhclient
|
|
fi
|
|
fi
|
|
fi
|
|
if test "$with_dhclient" != "no"; then
|
|
AC_DEFINE(WITH_DHCLIENT, 1, [Define if you have dhclient])
|
|
AC_DEFINE_UNQUOTED(DHCLIENT_PATH, "$with_dhclient", [Define path to dhclient])
|
|
else
|
|
AC_DEFINE(WITH_DHCLIENT, 0, [Define if you have dhclient])
|
|
fi
|
|
|
|
AC_ARG_WITH([dhcpcd],
|
|
AS_HELP_STRING([--with-dhcpcd=yes|no|path], [Enable dhcpcd 4.x support]))
|
|
if test "$with_dhcpcd" != "no"; then
|
|
with_dhcpcd_="$with_dhcpcd"
|
|
AC_PATH_PROGS(with_dhcpcd, dhcpcd, no, /sbin:/usr/sbin:/usr/local/sbin)
|
|
if test "$with_dhcpcd" = "no"; then
|
|
if test "$with_dhcpcd_" = yes; then
|
|
AC_MSG_WARN([dhcpcd not found, assume path /usr/sbin/dhcpcd])
|
|
with_dhcpcd=/usr/sbin/dhcpcd
|
|
fi
|
|
fi
|
|
fi
|
|
if test "$with_dhcpcd" != "no"; then
|
|
AC_DEFINE(WITH_DHCPCD, 1, [Define if you have dhcpcd])
|
|
AC_DEFINE_UNQUOTED(DHCPCD_PATH, "$with_dhcpcd", [Define path to dhcpcd])
|
|
else
|
|
AC_DEFINE(WITH_DHCPCD, 0, [Define if you have dhcpcd])
|
|
fi
|
|
|
|
AC_ARG_WITH(config-dhcp-default,
|
|
AS_HELP_STRING([--with-config-dhcp-default=dhclient|dhcpcd|internal],
|
|
[Default configuration option for main.dhcp setting, used as fallback if the configuration option is unset [default=internal]]),
|
|
[config_dhcp_default="$withval"], [config_dhcp_default=""])
|
|
if test "$config_dhcp_default" = yes -o "$config_dhcp_default" = no -o -z "$config_dhcp_default"; then
|
|
config_dhcp_default='internal'
|
|
fi
|
|
AC_DEFINE_UNQUOTED(NM_CONFIG_DEFAULT_MAIN_DHCP, "$config_dhcp_default", [Default configuration option for main.dhcp setting])
|
|
AC_SUBST(NM_CONFIG_DEFAULT_MAIN_DHCP, $config_dhcp_default)
|
|
|
|
AC_ARG_WITH(resolvconf, AS_HELP_STRING([--with-resolvconf=yes|no|path], [Enable resolvconf support]))
|
|
AC_ARG_WITH(netconfig, AS_HELP_STRING([--with-netconfig=yes|no], [Enable SUSE netconfig support]))
|
|
AC_ARG_WITH(config-dns-rc-manager-default, AS_HELP_STRING([--with-config-dns-rc-manager-default=auto|symlink|file|netconfig|resolvconf], [Configure default value for main.rc-manager setting]), [config_dns_rc_manager_default=$withval])
|
|
if test "$config_dns_rc_manager_default" != "" -a \
|
|
"$config_dns_rc_manager_default" != auto -a \
|
|
"$config_dns_rc_manager_default" != file -a \
|
|
"$config_dns_rc_manager_default" != symlink -a \
|
|
"$config_dns_rc_manager_default" != netconfig -a \
|
|
"$config_dns_rc_manager_default" != resolvconf; then
|
|
AC_MSG_WARN([Unknown --with-config-dns-rc-manager-default=$config_dns_rc_manager_default setting.])
|
|
config_dns_rc_manager_default=auto
|
|
fi
|
|
# Use netconfig by default on SUSE
|
|
AS_IF([test -z "$with_netconfig" -a -f /etc/SuSE-release], with_netconfig=yes)
|
|
# Otherwise, default to "no"
|
|
AS_IF([test -z "$with_resolvconf"], with_resolvconf=no)
|
|
AS_IF([test -z "$with_netconfig"], with_netconfig=no)
|
|
|
|
if test "$with_resolvconf" = "yes"; then
|
|
AC_PATH_PROGS(with_resolvconf, resolvconf, 'yes', /sbin:/usr/sbin:/usr/local/sbin)
|
|
if test "$with_resolvconf" = "yes"; then
|
|
AC_MSG_ERROR(cannot find resolvconf in path. Set the path explicitly via --with-resolvconf=PATH.)
|
|
fi
|
|
fi
|
|
|
|
if test "$with_netconfig" = "yes"; then
|
|
AC_PATH_PROGS(with_netconfig, netconfig, yes, /sbin:/usr/sbin:/usr/local/sbin)
|
|
if test "$with_netconfig" = "yes"; then
|
|
AC_MSG_ERROR(cannot find netconfig in path. Set the path explicitly via --with-netconfig=PATH.)
|
|
fi
|
|
fi
|
|
|
|
if test "$with_resolvconf" != "no"; then
|
|
AC_DEFINE_UNQUOTED(RESOLVCONF_PATH, "$with_resolvconf", [Path to resolvconf])
|
|
fi
|
|
if test "$with_netconfig" != "no"; then
|
|
AC_DEFINE_UNQUOTED(NETCONFIG_PATH, "$with_netconfig", [Path to netconfig])
|
|
fi
|
|
AC_DEFINE_UNQUOTED(NM_CONFIG_DEFAULT_MAIN_RC_MANAGER, "$config_dns_rc_manager_default", [Default value for main.rc-manager setting (--with-config-dns-rc-manager-default)])
|
|
AC_SUBST(NM_CONFIG_DEFAULT_MAIN_RC_MANAGER, $config_dns_rc_manager_default)
|
|
|
|
AC_ARG_WITH(iptables,
|
|
AS_HELP_STRING([--with-iptables=/usr/sbin/iptables], [path to iptables]))
|
|
if test "x${with_iptables}" = x; then
|
|
AC_PATH_PROG(IPTABLES_PATH, iptables, [], $PATH:/sbin:/usr/sbin)
|
|
if test "x$IPTABLES_PATH" = x; then
|
|
IPTABLES_PATH='/usr/sbin/iptables'
|
|
fi
|
|
else
|
|
IPTABLES_PATH="$with_iptables"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(IPTABLES_PATH, "$IPTABLES_PATH", [Define to path of iptables binary])
|
|
AC_SUBST(IPTABLES_PATH)
|
|
|
|
AC_ARG_WITH(nft,
|
|
AS_HELP_STRING([--with-nft=/usr/sbin/nft], [path to nft]))
|
|
if test "x${with_nft}" = x; then
|
|
AC_PATH_PROG(NFT_PATH, nft, [], $PATH:/sbin:/usr/sbin)
|
|
if test "x$NFT_PATH" = x; then
|
|
NFT_PATH='/usr/sbin/nft'
|
|
fi
|
|
else
|
|
NFT_PATH="$with_nft"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(NFT_PATH, "$NFT_PATH", [Define to path of nft binary])
|
|
AC_SUBST(NFT_PATH)
|
|
|
|
AC_ARG_WITH(modprobe,
|
|
AS_HELP_STRING([--with-modprobe=/sbin/modprobe], [path to modprobe]))
|
|
if test "x${with_modprobe}" = x; then
|
|
AC_PATH_PROG(MODPROBE_PATH, modprobe, [], $PATH:/sbin:/usr/sbin)
|
|
if test "x$MODPROBE_PATH" = x; then
|
|
MODPROBE_PATH='/sbin/modprobe'
|
|
fi
|
|
else
|
|
MODPROBE_PATH="$with_modprobe"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(MODPROBE_PATH, "$MODPROBE_PATH", [Define to path of modprobe binary])
|
|
AC_SUBST(MODPROBE_PATH)
|
|
|
|
AC_ARG_WITH(dnsmasq,
|
|
AS_HELP_STRING([--with-dnsmasq=/path/to/dnsmasq], [path to dnsmasq]))
|
|
if test "x${with_dnsmasq}" = x; then
|
|
AC_PATH_PROG(DNSMASQ_PATH, dnsmasq, [], $PATH:/sbin:/usr/sbin)
|
|
else
|
|
DNSMASQ_PATH="$with_dnsmasq"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(DNSMASQ_PATH, "$DNSMASQ_PATH", [Define to path of dnsmasq binary])
|
|
AC_SUBST(DNSMASQ_PATH)
|
|
|
|
# system CA certificates path
|
|
AC_ARG_WITH(system-ca-path,
|
|
AS_HELP_STRING([--with-system-ca-path=/path/to/ssl/certs], [path to system CA certificates]))
|
|
if test "x${with_system_ca_path}" = x; then
|
|
SYSTEM_CA_PATH=/etc/ssl/certs
|
|
else
|
|
SYSTEM_CA_PATH="$with_system_ca_path"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(SYSTEM_CA_PATH, "$SYSTEM_CA_PATH", [Define to path to system CA certificates])
|
|
AC_SUBST(SYSTEM_CA_PATH)
|
|
|
|
AC_ARG_WITH(kernel-firmware-dir,
|
|
AS_HELP_STRING([--with-kernel-firmware-dir=DIR], [where kernel firmware directory is [default=/lib/firmware]]))
|
|
if test -n "$with_kernel_firmware_dir" ; then
|
|
KERNEL_FIRMWARE_DIR="$with_kernel_firmware_dir"
|
|
else
|
|
KERNEL_FIRMWARE_DIR="/lib/firmware"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(KERNEL_FIRMWARE_DIR, "$KERNEL_FIRMWARE_DIR", [Define to path of the kernel firmware directory])
|
|
AC_SUBST(KERNEL_FIRMWARE_DIR)
|
|
|
|
PKG_CHECK_MODULES(LIBPSL, [libpsl >= 0.1], [have_libpsl=yes],[have_libpsl=no])
|
|
AC_ARG_WITH(libpsl,
|
|
AS_HELP_STRING([--with-libpsl=yes|no], [Link against libpsl]),
|
|
[], [with_libpsl=${have_libpsl}])
|
|
if test "$with_libpsl" != "no"; then
|
|
if test "$have_libpsl" != "yes"; then
|
|
AC_MSG_ERROR(libpsl library not found)
|
|
fi
|
|
with_libpsl='yes'
|
|
AC_DEFINE(WITH_LIBPSL, 1, [Define if you have libpsl])
|
|
else
|
|
AC_DEFINE(WITH_LIBPSL, 0, [Define if you have libpsl])
|
|
fi
|
|
AM_CONDITIONAL(WITH_LIBPSL, test "$with_libpsl" != "no")
|
|
|
|
have_libcurl=''
|
|
|
|
AC_ARG_ENABLE(concheck,
|
|
AS_HELP_STRING([--enable-concheck], [enable connectivity checking support]),
|
|
[enable_concheck=${enableval}], [enable_concheck=yes])
|
|
if test "${enable_concheck}" = "yes"; then
|
|
PKG_CHECK_MODULES(LIBCURL, [libcurl >= 7.24.0], [have_libcurl=yes], [have_libcurl=no])
|
|
if test "$have_libcurl" != "yes"; then
|
|
AC_MSG_ERROR(--enable-concheck requires libcurl library.)
|
|
fi
|
|
AC_DEFINE(WITH_CONCHECK, 1, [Define if you want connectivity checking support])
|
|
else
|
|
enable_concheck=no
|
|
AC_DEFINE(WITH_CONCHECK, 0, [Define if you want connectivity checking support])
|
|
fi
|
|
|
|
PKG_CHECK_MODULES(LIBNDP, [libndp])
|
|
|
|
AX_LIB_READLINE
|
|
|
|
AC_ARG_WITH(nmcli,
|
|
AS_HELP_STRING([--with-nmcli=yes|no], [Build nmcli]),
|
|
[],
|
|
[with_nmcli=yes])
|
|
if test "$with_nmcli" = yes; then
|
|
if test "$with_readline" = none; then
|
|
AC_MSG_FAILURE([nmcli requires readline library. Use --with-readline or --with-nmcli=no])
|
|
fi
|
|
build_nmcli=yes
|
|
elif test "$with_nmcli" = no; then
|
|
build_nmcli=no
|
|
else
|
|
AC_MSG_ERROR([invalid --with-nmcli option. Valid options are --with-nmcli=yes|no])
|
|
fi
|
|
AM_CONDITIONAL(BUILD_NMCLI, test "$build_nmcli" = yes)
|
|
|
|
AC_ARG_WITH(nm-cloud-setup,
|
|
AS_HELP_STRING([--with-nm-cloud-setup=yes|no], [Build nm-cloud-setup, a tool for automatically configuring networking in cloud]))
|
|
if test "$with_nm_cloud_setup" != no; then
|
|
if test "$have_libcurl" = ""; then
|
|
PKG_CHECK_MODULES(LIBCURL, [libcurl >= 7.24.0], [have_libcurl=yes], [have_libcurl=no])
|
|
fi
|
|
if test "$have_libcurl" != "yes"; then
|
|
AC_MSG_ERROR(--with-nm-cloud-setup requires libcurl library.)
|
|
fi
|
|
with_nm_cloud_setup=yes
|
|
fi
|
|
AM_CONDITIONAL(BUILD_NM_CLOUD_SETUP, test "$with_nm_cloud_setup" = yes)
|
|
|
|
AC_ARG_WITH(nmtui,
|
|
AS_HELP_STRING([--with-nmtui=yes|no], [Build nmtui]))
|
|
if test "$with_nmtui" != no; then
|
|
PKG_CHECK_MODULES(NEWT, [libnewt >= 0.52.15], [build_nmtui=yes], [build_nmtui=no])
|
|
else
|
|
build_nmtui=no
|
|
fi
|
|
if test "$with_nmtui" = yes -a "$build_nmtui" = no; then
|
|
AC_MSG_ERROR([You must have libnewt installed to build nmtui.])
|
|
fi
|
|
AM_CONDITIONAL(BUILD_NMTUI, test "$build_nmtui" = yes)
|
|
|
|
if test $(( ${NM_MINOR_VERSION} % 2 )) = "1"; then
|
|
# A development version
|
|
more_warnings_default=error
|
|
more_asserts_default=100
|
|
more_logging_default=yes
|
|
else
|
|
# A release version
|
|
more_warnings_default=yes
|
|
more_asserts_default=0
|
|
more_logging_default=no
|
|
fi
|
|
|
|
NM_COMPILER_WARNINGS(AM_CFLAGS, ${more_warnings_default})
|
|
|
|
for w in \
|
|
-Wno-nonnull-compare \
|
|
; do
|
|
NM_COMPILER_WARNING_FLAG(LIBSYSTEMD_NM_CFLAGS, "$w")
|
|
done
|
|
AC_SUBST(LIBSYSTEMD_NM_CFLAGS)
|
|
|
|
CC_CHECK_FLAGS_APPEND([with_cflags], [CFLAGS], [\
|
|
-fno-strict-aliasing \
|
|
])
|
|
AM_CFLAGS="$AM_CFLAGS $with_cflags"
|
|
|
|
AC_ARG_ENABLE(more-asserts,
|
|
AS_HELP_STRING([--enable-more-asserts],
|
|
[Enable more assertions for debugging [default=auto]. Deprecated option. Use --with-more-asserts=level]))
|
|
if test "${enable_more_asserts}" = "yes"; then
|
|
more_asserts=100
|
|
fi
|
|
AC_ARG_WITH(more-asserts,
|
|
AS_HELP_STRING([--with-more-asserts=level], [Enable more assertions for debugging (0 = none, 100 = all) [default=auto]]),
|
|
[more_asserts=${with_more_asserts}],
|
|
[])
|
|
if test "${more_asserts}" = "no"; then
|
|
more_asserts=0
|
|
else
|
|
if test "${more_asserts}" = "yes"; then
|
|
more_asserts=100
|
|
fi
|
|
fi
|
|
if test "${more_asserts}" = ""; then
|
|
more_asserts=${more_asserts_default}
|
|
fi
|
|
AC_DEFINE_UNQUOTED(NM_MORE_ASSERTS, $more_asserts, [Define if more asserts are enabled])
|
|
|
|
AC_ARG_ENABLE(more-logging, AS_HELP_STRING([--enable-more-logging], [Enable more debug logging [default=auto]]))
|
|
if test "${enable_more_logging}" = ""; then
|
|
enable_more_logging=${more_logging_default}
|
|
fi
|
|
if test "${enable_more_logging}" = "yes"; then
|
|
AC_DEFINE(NM_MORE_LOGGING, [1], [Define if more debug logging is enabled])
|
|
else
|
|
AC_DEFINE(NM_MORE_LOGGING, [0], [Define if more debug logging is enabled])
|
|
fi
|
|
|
|
NM_LTO
|
|
NM_LD_GC
|
|
|
|
AC_ARG_WITH(address-sanitizer,
|
|
AS_HELP_STRING([--with-address-sanitizer=yes|no|exec], [Enable address sanitizer [default=no]]))
|
|
if test "$with_address_sanitizer" = yes -o "$with_address_sanitizer" = "exec"; then
|
|
CC_CHECK_FLAGS_APPEND([asan_cflags], [CFLAGS], [-fsanitize=address])
|
|
AS_IF([test -z "$asan_cflags"],
|
|
[AC_MSG_ERROR([*** -fsanitize=address is not supported])])
|
|
|
|
sanitizer_exec_cflags="$sanitizer_exec_cflags -fsanitize=address"
|
|
sanitizer_exec_ldflags="$sanitizer_exec_ldflags -Wc,-fsanitize=address"
|
|
AC_DEFINE(ASAN_BUILD, 1, [Whether NM is built with address sanitizer])
|
|
|
|
if test "$with_address_sanitizer" = "yes"; then
|
|
sanitizer_lib_cflags="$sanitizer_lib_cflags -fsanitize=address"
|
|
sanitizer_lib_ldflags="$sanitizer_lib_ldflags -Wc,-fsanitize=address"
|
|
sanitizers="${sanitizers}address "
|
|
asan_options="ASAN_OPTIONS=detect_leaks=0"
|
|
else
|
|
sanitizers="${sanitizers}address(executables-only) "
|
|
fi
|
|
elif test "$with_address_sanitizer" = "" -o "$with_address_sanitizer" = no; then
|
|
with_address_sanitizer=no
|
|
else
|
|
AC_MSG_ERROR(["Invalid asan option --with-address-sanitizer=$with_address_sanitizer"])
|
|
fi
|
|
|
|
AC_ARG_ENABLE(undefined-sanitizer,
|
|
AS_HELP_STRING([--enable-undefined-sanitizer],
|
|
[Compile with undefined behavior sanitizer [default=no]]))
|
|
if test "${enable_undefined_sanitizer}" = "yes"; then
|
|
CC_CHECK_FLAGS_APPEND([ubsan_cflags], [CFLAGS], [-fsanitize=undefined])
|
|
AS_IF([test -z "$ubsan_cflags"],
|
|
[AC_MSG_ERROR([*** -fsanitize=undefined is not supported])])
|
|
|
|
sanitizer_exec_cflags="$sanitizer_exec_cflags -fsanitize=undefined"
|
|
sanitizer_lib_cflags="$sanitizer_lib_cflags -fsanitize=undefined"
|
|
sanitizer_exec_ldflags="$sanitizer_exec_ldflags -Wc,-fsanitize=undefined"
|
|
sanitizer_lib_ldflags="$sanitizer_lib_ldflags -Wc,-fsanitize=undefined"
|
|
sanitizers="${sanitizers}undefined-behavior "
|
|
elif test "$enable_undefined_sanitizer" = "" -o "$enable_undefined_sanitizer" = no; then
|
|
enable_undefined_sanitizer=no
|
|
else
|
|
AC_MSG_ERROR(["Invalid asan option --enable-undefined-sanitizer=$enable_undefined_sanitizer"])
|
|
fi
|
|
|
|
if test -n "$sanitizers"; then
|
|
sanitizers="${sanitizers% }"
|
|
AC_SUBST(SANITIZER_ENV, ["$asan_options"])
|
|
AC_SUBST(SANITIZER_EXEC_CFLAGS, ["$sanitizer_exec_cflags -DVALGRIND=1 -fno-omit-frame-pointer"])
|
|
AC_SUBST(SANITIZER_LIB_CFLAGS, ["$sanitizer_lib_cflags -DVALGRIND=1 -fno-omit-frame-pointer"])
|
|
AC_SUBST(SANITIZER_EXEC_LDFLAGS, [$sanitizer_exec_ldflags])
|
|
AC_SUBST(SANITIZER_LIB_LDFLAGS, [$sanitizer_lib_ldflags])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([CC support C11 _Generic()])
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int foo(void); static const char *const buf[1] = { "a" }; int foo() { int a = 0; int b = _Generic (a, int: 4) + _Generic(buf, const char *const*: 5); return b + a; }]],
|
|
[[foo();]])],
|
|
[cc_support_generic=1],
|
|
[cc_support_generic=0])
|
|
AC_MSG_RESULT($cc_support_generic)
|
|
AC_DEFINE_UNQUOTED(_NM_CC_SUPPORT_GENERIC, $cc_support_generic, [Define whether the compiler supports C11 _Generic()])
|
|
|
|
AC_MSG_CHECKING([CC support gcc __auto_type])
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int foo(void); int foo() { int a = 0; __auto_type b = a; return b + a; }]],
|
|
[[foo();]])],
|
|
[cc_support_auto_type=1],
|
|
[cc_support_auto_type=0])
|
|
AC_MSG_RESULT($cc_support_auto_type)
|
|
AC_DEFINE_UNQUOTED(_NM_CC_SUPPORT_AUTO_TYPE, $cc_support_auto_type, [Define whether the compiler support gcc __auto_type])
|
|
|
|
dnl -------------------------
|
|
dnl Vala bindings
|
|
dnl -------------------------
|
|
|
|
VAPIGEN_CHECK(0.17.1.24)
|
|
AC_CONFIG_COMMANDS([vapi], [$MKDIR_P vapi])
|
|
|
|
# Tests, utilities and documentation
|
|
AC_ARG_ENABLE(tests, AS_HELP_STRING([--enable-tests=root|yes|no], [Build NetworkManager tests [default=yes]]))
|
|
AC_ARG_WITH(valgrind,
|
|
AS_HELP_STRING([--with-valgrind=yes|no|path], [Use valgrind to memory-check the tests [default=no]]))
|
|
# Fallback to --with-tests
|
|
AC_ARG_WITH(tests,
|
|
AS_HELP_STRING([--with-tests], [Build NetworkManager tests (deprecated)]))
|
|
AS_IF([test -n "$with_tests"], enable_tests="$with_tests")
|
|
# Default to --enable-tests --with-valgrind=no
|
|
AS_IF([test -z "$enable_tests"], enable_tests="yes")
|
|
AS_IF([test -z "$with_valgrind"], with_valgrind="no")
|
|
# Normalize values
|
|
AS_IF([test "$enable_tests" != "yes" -a "$enable_tests" != "root"], enable_tests="no")
|
|
# Search for tools
|
|
AS_IF([test "$with_valgrind" = "yes"],
|
|
[AC_PATH_PROGS(with_valgrind, valgrind, no)])
|
|
# Add conditionals and substitutions
|
|
AM_CONDITIONAL(ENABLE_TESTS, test "$enable_tests" != "no")
|
|
AM_CONDITIONAL(REQUIRE_ROOT_TESTS, test "$enable_tests" = "root")
|
|
AC_ARG_WITH(valgrind-suppressions,
|
|
AS_HELP_STRING([--with-valgrind-suppressions=path], [Use specific valgrind suppression file]))
|
|
if test "$with_valgrind" = no; then
|
|
with_valgrind_suppressions=
|
|
else
|
|
if test "$with_valgrind_suppressions" = ""; then
|
|
with_valgrind_suppressions='$(top_srcdir)/valgrind.suppressions'
|
|
fi
|
|
fi
|
|
AC_SUBST(NM_LOG_COMPILER, 'LOG_COMPILER = "$(top_srcdir)/tools/run-nm-test.sh" --called-from-make "$(abs_top_builddir)" "$(LIBTOOL)" "$(with_valgrind)" "'"$with_valgrind_suppressions"'" --launch-dbus=auto')
|
|
|
|
AX_PTHREAD([], [AC_MSG_ERROR([Threads are required for the NetworkManager tests])])
|
|
|
|
if test -n "$PYTHON" ; then
|
|
AM_PATH_PYTHON([], [], [])
|
|
else
|
|
AM_PATH_PYTHON([3], [], [PYTHON=])
|
|
if test -z "$PYTHON"; then
|
|
AM_PATH_PYTHON([], [], [])
|
|
fi
|
|
fi
|
|
AC_SUBST(PYTHON, [$PYTHON])
|
|
AC_DEFINE_UNQUOTED(TEST_NM_PYTHON, "$PYTHON", [Define python path for test binary])
|
|
|
|
GTK_DOC_CHECK(1.0)
|
|
|
|
# check if we can build setting property documentation
|
|
build_docs=no
|
|
if test -n "$INTROSPECTION_MAKEFILE"; then
|
|
# If g-i is installed we know we have python, but we might not have pygobject
|
|
if ! "$PYTHON" -c 'from gi.repository import GObject' > /dev/null 2>&1; then
|
|
AC_MSG_ERROR(["--enable-introspection aims to build the settings documentation. This requires GObject introspection for python (pygobject)])
|
|
fi
|
|
|
|
AC_PATH_PROG(PERL, perl)
|
|
if test -z "$PERL"; then
|
|
AC_MSG_ERROR([--enable-introspection requires perl])
|
|
fi
|
|
AC_PATH_PROG(XSLTPROC, xsltproc)
|
|
if test -z "$XSLTPROC"; then
|
|
AC_MSG_ERROR([--enable-introspection requires xsltproc])
|
|
fi
|
|
|
|
have_introspection=yes
|
|
if test "$enable_gtk_doc" = "yes"; then
|
|
build_docs=yes
|
|
fi
|
|
else
|
|
if test "$enable_gtk_doc" = "yes"; then
|
|
# large parts of the documentation require introspection/pygobject to extract
|
|
# the documentation out of the source files. You cannot enable gtk-doc without alone.
|
|
AC_MSG_ERROR(["--enable-gtk-doc requires --enable-introspection"])
|
|
fi
|
|
have_introspection=no
|
|
fi
|
|
|
|
# check for pregenerated manpages and documentation to be installed
|
|
use_pregen_docs=no
|
|
if test "$build_docs" != "yes" -a \
|
|
-f "$srcdir"/man/NetworkManager-dispatcher.8 -a \
|
|
-f "$srcdir"/man/NetworkManager-wait-online.service.8 -a \
|
|
-f "$srcdir"/man/NetworkManager.8 -a \
|
|
-f "$srcdir"/man/NetworkManager.conf.5 -a \
|
|
-f "$srcdir"/man/nm-online.1 -a \
|
|
-f "$srcdir"/man/nmcli-examples.7 -a \
|
|
-f "$srcdir"/man/nmcli.1 -a \
|
|
-f "$srcdir"/man/nmtui.1 -a \
|
|
\
|
|
-f "$srcdir"/man/nm-openvswitch.7 -a \
|
|
-f "$srcdir"/man/nm-cloud-setup.8 -a \
|
|
\
|
|
-f "$srcdir"/man/nm-settings-dbus.5 -a \
|
|
-f "$srcdir"/man/nm-settings-ifcfg-rh.5 -a \
|
|
-f "$srcdir"/man/nm-settings-keyfile.5 -a \
|
|
-f "$srcdir"/man/nm-settings-nmcli.5 -a \
|
|
\
|
|
-f "$srcdir"/man/nm-settings-dbus.xml -a \
|
|
-f "$srcdir"/man/nm-settings-ifcfg-rh.xml -a \
|
|
-f "$srcdir"/man/nm-settings-keyfile.xml -a \
|
|
-f "$srcdir"/man/nm-settings-nmcli.xml -a \
|
|
\
|
|
-f "$srcdir"/docs/api/settings-spec.xml; then
|
|
use_pregen_docs=yes
|
|
fi
|
|
|
|
AM_CONDITIONAL(BUILD_DOCS, test "$build_docs" = "yes")
|
|
AM_CONDITIONAL(HAVE_DOCS, test "$build_docs" = "yes" -o "$use_pregen_docs" = "yes")
|
|
AC_SUBST(AM_CFLAGS)
|
|
|
|
AC_CONFIG_FILES([
|
|
Makefile
|
|
po/Makefile.in
|
|
data/org.freedesktop.NetworkManager.policy.in
|
|
docs/api/Makefile
|
|
docs/api/version.xml
|
|
docs/libnm/Makefile
|
|
docs/libnm/version.xml
|
|
src/libnm-client-impl/libnm.pc
|
|
src/libnm-core-public/nm-version-macros.h
|
|
])
|
|
AC_OUTPUT
|
|
|
|
# Print build configuration
|
|
echo
|
|
echo "System paths:"
|
|
echo " prefix: $prefix"
|
|
echo " exec_prefix: $exec_prefix"
|
|
echo " sysconfdir: $sysconfdir"
|
|
echo " localstatedir: $localstatedir"
|
|
echo " runstatedir: $runstatedir"
|
|
echo " datarootdir: $datarootdir"
|
|
echo " datadir: $datadir"
|
|
echo " systemdunitdir: $with_systemdsystemunitdir"
|
|
echo " udev-dir: $with_udev_dir"
|
|
echo " nmbinary: $nmbinary"
|
|
echo " nmconfdir: $nmconfdir"
|
|
echo " nmlibdir: $nmlibdir"
|
|
echo " nmdatadir: $nmdatadir"
|
|
echo " nmstatedir: $nmstatedir"
|
|
echo " nmrundir: $nmrundir"
|
|
echo " system-ca-path: $with_system_ca_path"
|
|
echo " dbus-sys-dir: $DBUS_SYS_DIR"
|
|
echo
|
|
|
|
echo "Platform:"
|
|
echo " session tracking: $session_tracking"
|
|
echo " suspend/resume: $with_suspend_resume"
|
|
if test "${enable_modify_system}" = "yes"; then
|
|
echo " policykit: main.auth-polkit=${enable_polkit} (permissive modify.system)"
|
|
else
|
|
echo " policykit: main.auth-polkit=${enable_polkit} (restrictive modify.system)"
|
|
fi
|
|
echo " polkit-agent-helper-1: $POLKIT_AGENT_HELPER_1_PATH"
|
|
echo " selinux: $have_selinux"
|
|
echo " systemd-journald: $have_systemd_journal (default: logging.backend=${nm_config_logging_backend_default})"
|
|
echo " hostname persist: ${hostname_persist}"
|
|
echo " libaudit: $have_libaudit (default: logging.audit=${NM_CONFIG_DEFAULT_LOGGING_AUDIT_TEXT})"
|
|
echo
|
|
|
|
echo "Features:"
|
|
echo " wext: $ac_with_wext"
|
|
echo " wifi: $enable_wifi"
|
|
echo " ppp: $enable_ppp ${PPPD_PATH} plugins:${PPPD_PLUGIN_DIR}"
|
|
echo " modemmanager-1: $with_modem_manager_1"
|
|
echo " ofono: $with_ofono"
|
|
echo " concheck: $enable_concheck"
|
|
echo " libteamdctl: $enable_teamdctl"
|
|
echo " ovs: $enable_ovs"
|
|
echo " nmcli: $build_nmcli"
|
|
echo " nmtui: $build_nmtui"
|
|
echo " nm-cloud-setup: $with_nm_cloud_setup"
|
|
echo " iwd: $ac_with_iwd"
|
|
echo " jansson: $have_jansson${JANSSON_SONAME:+ (soname: $JANSSON_SONAME)}"
|
|
echo " iptables: $IPTABLES_PATH"
|
|
echo " nft: $NFT_PATH"
|
|
echo " modprobe: $MODPROBE_PATH"
|
|
echo
|
|
|
|
echo "Configuration plugins (main.plugins=${config_plugins_default})"
|
|
echo " ifcfg-rh: ${enable_ifcfg_rh}"
|
|
echo " default value of main.migrate-ifcfg-rh: ${nm_config_migrate_ifcfg_rh_default}"
|
|
echo " ifupdown: ${enable_ifupdown}"
|
|
echo
|
|
|
|
echo "Handlers for /etc/resolv.conf:"
|
|
echo " resolvconf: ${with_resolvconf}"
|
|
echo " netconfig: ${with_netconfig}"
|
|
echo " config-dns-rc-manager-default: ${config_dns_rc_manager_default}"
|
|
echo
|
|
|
|
echo "DHCP clients (default $config_dhcp_default):"
|
|
echo " dhcpcanon: $with_dhcpcanon"
|
|
echo " dhclient: $with_dhclient"
|
|
echo " dhcpcd: $with_dhcpcd"
|
|
echo
|
|
|
|
echo "Miscellaneous:"
|
|
echo " have introspection: $have_introspection"
|
|
echo " build documentation and manpages: $build_docs"
|
|
echo " install pregenerated documentation and manpages: $use_pregen_docs"
|
|
echo " install and use firewalld shared zone: $enable_firewalld_zone"
|
|
echo " tests: $enable_tests"
|
|
echo " more-asserts: $more_asserts"
|
|
echo " more-logging: $enable_more_logging"
|
|
echo " more-warnings: $set_more_warnings"
|
|
echo " valgrind: $with_valgrind $with_valgrind_suppressions"
|
|
echo " code coverage: $enable_code_coverage"
|
|
echo " LTO: $enable_lto"
|
|
echo " linker garbage collection: $enable_ld_gc"
|
|
echo " crypto: $with_crypto (have-gnutls: $have_crypto_gnutls, have-nss: $have_crypto_nss)"
|
|
echo " sanitizers: $sanitizers"
|
|
echo " Mozilla Public Suffix List: $with_libpsl"
|
|
echo " eBPF: $have_ebpf"
|
|
echo " readline: $with_readline"
|
|
echo " python: $PYTHON"
|
|
echo
|