# SPDX-License-Identifier: LGPL-2.1+

project(

  'NetworkManager', 'c',

# NOTE: When incrementing version also:

#  - add corresponding NM_VERSION_x_y_z macros in

#    "shared/nm-version-macros.h.in"

#  - update number in configure.ac

  version: '1.26.0',

  license: 'GPL2+',

  default_options: [

    'buildtype=debugoptimized',

    'c_std=gnu11',

  ],

  meson_version: '>= 0.47.2',

)

nm_name = meson.project_name()

nm_version = meson.project_version()

version_array = nm_version.split('.')

nm_major_version = version_array[0].to_int()

nm_minor_version = version_array[1].to_int()

nm_micro_version = version_array[2].to_int()

nm_id_prefix = 'NM'

nm_gir_version = '1.0'

# Distribution version string

dist_version = get_option('dist_version')

if dist_version == ''

  dist_version = nm_version

endif

nm_prefix = get_option('prefix')

nm_bindir = join_paths(nm_prefix, get_option('bindir'))

nm_datadir = join_paths(nm_prefix, get_option('datadir'))

nm_includedir = join_paths(nm_prefix, get_option('includedir'))

nm_libdir = join_paths(nm_prefix, get_option('libdir'))

nm_libexecdir = join_paths(nm_prefix, get_option('libexecdir'))

nm_localedir = join_paths(nm_prefix, get_option('localedir'))

nm_localstatedir = join_paths(nm_prefix, get_option('localstatedir'))

nm_mandir = join_paths(nm_prefix, get_option('mandir'))

nm_runstatedir = join_paths(nm_localstatedir, 'run')

nm_sbindir = join_paths(nm_prefix, get_option('sbindir'))

nm_sysconfdir = join_paths(nm_prefix, get_option('sysconfdir'))

nm_pkgsbindir = join_paths(nm_sbindir, nm_name)

nm_pkgconfdir = join_paths(nm_sysconfdir, nm_name)

nm_pkgdatadir = join_paths(nm_datadir, nm_name)

nm_pkgincludedir = join_paths(nm_includedir, nm_name)

nm_pkglibdir = join_paths(nm_prefix, 'lib', nm_name)

nm_pkgrundir = join_paths(nm_runstatedir, nm_name)

nm_pkgstatedir = join_paths(nm_localstatedir, 'lib', nm_name)

nm_vpndir = join_paths(nm_libdir, nm_name)

nm_plugindir = join_paths(nm_libdir, nm_name, dist_version)

libnm_name = 'libnm'

current = 1

revision = 0

age = 1

libnm_version = '@0@.@1@.@2@'.format(current - age, age, revision)

libnm_pkgincludedir = join_paths(nm_includedir, libnm_name)

nm_debug = get_option('buildtype').contains('debug')

gnome = import('gnome')

i18n = import('i18n')

pkg = import('pkgconfig')

source_root = meson.current_source_dir()

build_root = meson.current_build_dir()

po_dir = join_paths(meson.source_root(), 'po')

intltool_merge = find_program('intltool-merge')

intltool_cache = join_paths(po_dir, '.intltool-merge-cache')

intltool_desktop_cmd = [intltool_merge, '-d', '-u', '-c', intltool_cache, po_dir, '@INPUT@', '@OUTPUT@']

intltool_xml_cmd = [intltool_merge, '-x', '-u', '-c', intltool_cache, po_dir, '@INPUT@', '@OUTPUT@']

top_inc = include_directories('.')

perl = find_program('perl')

xsltproc = find_program('xsltproc')

check_exports = find_program(join_paths(source_root, 'tools', 'check-exports.sh'))

cc = meson.get_compiler('c')

config_h = configuration_data()

# defines

set_defines = [

  ['GETTEXT_PACKAGE', nm_name],

  ['PACKAGE_STRING', '@0@ @1@'.format(nm_name, nm_version)],

  ['VERSION', nm_version],

]

default_test_timeout = 90

foreach define: set_defines

  config_h.set_quoted(define[0], define[1])

endforeach

# headers

config_h.set10('HAVE_SYS_AUXV_H', cc.has_header('sys/auxv.h'))

use_sys_random = cc.has_function('getrandom', prefix: '#include <sys/random.h>')

config_h.set10('USE_SYS_RANDOM_H', use_sys_random)

config_h.set10('HAVE_GETRANDOM', use_sys_random or cc.has_function('getrandom', prefix: '#include <linux/random.h>'))

config_h.set10('HAVE_PIDFD_OPEN', cc.has_function('pidfd_open', prefix: '''#include <stdlib.h>

                                                                           #include <unistd.h>

                                                                           #include <signal.h>

                                                                           #include <sys/wait.h>'''))

config_h.set10('HAVE_PIDFD_SEND_SIGNAL', cc.has_function('pidfd_send_signal', prefix: '''#include <stdlib.h>

                                                                                         #include <unistd.h>

                                                                                         #include <signal.h>

                                                                                         #include <sys/wait.h>'''))

config_h.set10('HAVE_RT_SIGQUEUEINFO', cc.has_function('rt_sigqueueinfo', prefix: '''#include <stdlib.h>

                                                                                     #include <unistd.h>

                                                                                     #include <signal.h>

                                                                                     #include <sys/wait.h>'''))

config_h.set('HAVE_SECURE_GETENV', cc.has_function('secure_getenv'))

config_h.set('HAVE___SECURE_GETENV', cc.has_function('__secure_getenv'))

config_h.set10('HAVE_DECL_REALLOCARRAY', cc.has_function('reallocarray', prefix: '#include <malloc.h>'))

config_h.set10('HAVE_DECL_EXPLICIT_BZERO', cc.has_function('explicit_bzero', prefix: '#include <string.h>'))

config_h.set10('HAVE_DECL_MEMFD_CREATE', cc.has_function('memfd_create', prefix: '#include <sys/mman.h>'))

# types

config_h.set('SIZEOF_PID_T', cc.sizeof('pid_t', prefix : '#include <sys/types.h>'))

config_h.set('SIZEOF_UID_T', cc.sizeof('uid_t', prefix : '#include <sys/types.h>'))

config_h.set('SIZEOF_GID_T', cc.sizeof('gid_t', prefix : '#include <sys/types.h>'))

config_h.set('SIZEOF_DEV_T', cc.sizeof('dev_t', prefix : '#include <sys/types.h>'))

config_h.set('SIZEOF_INO_T', cc.sizeof('ino_t', prefix : '#include <sys/types.h>'))

config_h.set('SIZEOF_TIME_T', cc.sizeof('time_t', prefix : '#include <sys/time.h>'))

config_h.set('SIZEOF_RLIM_T', cc.sizeof('rlim_t', prefix : '#include <sys/resource.h>'))

# compiler flags

common_flags = []

common_ldflags = []

enable_ld_gc = get_option('ld_gc')

if enable_ld_gc

  test_c_flags = [

    '-fdata-sections',

    '-ffunction-sections',

  ]

  test_ldflags = ['-Wl,--gc-sections']

  foreach cflag: test_c_flags

    assert(cc.has_argument(cflag), 'Unused symbol eviction requested but not supported. Use -Dld_gc=false to build without it.')

  endforeach

  foreach ldflag: test_ldflags

    assert(cc.has_link_argument(ldflag), 'Linker garbage collection requested but not supported. Use -Dld_gc=false to build without it.')

  endforeach

  common_flags += test_c_flags

  common_ldflags += test_ldflags

endif

enable_lto = get_option('b_lto')

if enable_lto

  # meson already adds '-flto'

  lto_flag = '-flto-partition=none'

  assert(cc.has_argument(lto_flag), '-flto-partition=none not supported. Disable link-time optimization with -Db_lto=false.')

  common_flags += lto_flag

  common_ldflags += lto_flag

endif

if nm_debug

  common_flags += cc.get_supported_arguments([

    '-Wall',

    '-Wextra',

    '-Wdeclaration-after-statement',

    '-Wfloat-equal',

    '-Wformat-nonliteral',

    '-Wformat-security',

    '-Wimplicit-function-declaration',

    '-Winit-self',

    '-Wlogical-op',

    '-Wmissing-declarations',

    '-Wmissing-include-dirs',

    '-Wmissing-prototypes',

    '-Wpointer-arith',

    '-Wshadow',

    '-Wshift-negative-value',

    '-Wstrict-prototypes',

    '-Wundef',

    '-Wvla',

    '-Wno-duplicate-decl-specifier',

    '-Wno-format-truncation',

    '-Wno-format-y2k',

    '-Wno-gnu-variable-sized-type-not-at-end',

    '-Wno-missing-field-initializers',

    '-Wno-pragmas',

    '-Wno-sign-compare',

    '-Wno-tautological-constant-out-of-range-compare',

    '-Wno-unknown-pragmas',

    '-Wno-unused-parameter',

    '-Wparentheses-equality',

    '-Wpointer-arith',

    '-Wshadow',

    '-Wstrict-prototypes',

    '-Wtypedef-redefinition',

    '-Wundef',

    '-Wunknown-attributes',

    '-fno-strict-aliasing',

  ])

  if cc.has_argument('-Wimplicit-fallthrough')

    if cc.compiles('''

                   int main(int argc, char **argv) {

                       int r = 0;

                       switch (argc) {

                       case 0:

                           r++;

                           /* fall-through */

                       case 1:

                           r++;

                           break;

                       }

                       return r;

                   }

                   ''',

                   args: '-Werror=implicit-fallthrough',

                   name: '-Werror=implicit-fallthrough')

      common_flags += '-Wimplicit-fallthrough'

    endif

  endif

endif

add_project_arguments(common_flags, language: 'c')

add_project_link_arguments(common_ldflags, language: 'c')

linker_script_binary   = join_paths(source_root, 'linker-script-binary.ver')

linker_script_devices  = join_paths(source_root, 'linker-script-devices.ver')

linker_script_settings = join_paths(source_root, 'linker-script-settings.ver')

ldflags_linker_script_binary   = [ '-Wl,--version-script,@0@'.format(linker_script_binary) ]

ldflags_linker_script_devices  = [ '-Wl,--version-script,@0@'.format(linker_script_devices) ]

ldflags_linker_script_settings = [ '-Wl,--version-script,@0@'.format(linker_script_settings) ]

uuid_dep = dependency('uuid')

libelogind_dep = dependency('libelogind', version: '>= 219', required: false)

libudev_dep = dependency('libudev', version: '>= 175')

dbus_dep = dependency('dbus-1', version: '>= 1.1')

libndp_dep = dependency('libndp')

jansson_dep = dependency('jansson', version: '>= 2.5', required: false)

config_h.set10('WITH_JANSSON', jansson_dep.found())

if jansson_dep.found()

  jansson_libdir = jansson_dep.get_pkgconfig_variable('libdir')

  res = run_command(find_program('eu-readelf', 'readelf'), '-d', join_paths(jansson_libdir, 'libjansson.so'))

  jansson_soname = ''

  foreach line: res.stdout().split('\n')

    if line.strip().contains('SONAME')

       jansson_soname = line.split('[')[1].split(']')[0]

    endif

  endforeach

  assert(jansson_soname != '', 'Unable to determine Jansson SONAME')

  config_h.set_quoted('JANSSON_SONAME', jansson_soname)

endif

libsystemd_dep = dependency('libsystemd', version: '>= 209', required: false)

libsystemd_login_dep = dependency('libsystemd-login', version: '>= 183', required: false)

config_h.set10('HAVE_LIBSYSTEMD', libsystemd_dep.found())

systemd_dep = dependency('systemd', required: false)

have_systemd_200 = systemd_dep.found() and systemd_dep.version().version_compare('>= 200')

gio_unix_dep = dependency('gio-unix-2.0', version: '>= 2.40')

glib_dep = declare_dependency(

  dependencies: [

    gio_unix_dep,

    dependency('gmodule-2.0'),

  ],

  compile_args: [

    '-DGLIB_VERSION_MIN_REQUIRED=GLIB_VERSION_2_40',

    '-DGLIB_VERSION_MAX_ALLOWED=GLIB_VERSION_2_40',

  ]

)

if run_command('test', '-e', '/etc/sysconfig/network-scripts').returncode() == 0

  distro = 'redhat'

elif run_command('test', '-e', '/etc/SuSE-release').returncode() == 0

  distro = 'suse'

elif run_command('test', '-e', '/etc/debian_version').returncode() == 0

  distro = 'debian'

elif run_command('test', '-e', '/etc/gentoo-release').returncode() == 0

  distro = 'gentoo'

else

  distro = 'unknown'

endif

enable_ifcfg_rh = get_option('ifcfg_rh') or (distro == 'redhat')

enable_ifupdown = get_option('ifupdown') or (distro == 'debian')

config_plugins_default = get_option('config_plugins_default')

if config_plugins_default == ''

  config_plugins = []

  if enable_ifcfg_rh

    config_plugins += ['ifcfg-rh']

  endif

  if enable_ifupdown

    config_plugins += ['ifupdown']

  endif

  config_plugins_default = ','.join(config_plugins)

endif

config_h.set_quoted('NM_CONFIG_DEFAULT_MAIN_PLUGINS', config_plugins_default)

config_h.set_quoted('NM_DIST_VERSION', dist_version)

enable_wifi = get_option('wifi')

enable_iwd = get_option('iwd')

assert((not enable_iwd) or enable_wifi, 'Enabling iwd support requires Wi-Fi support as well')

config_h.set10('WITH_IWD', enable_iwd)

enable_wext = get_option('wext')

config_h.set10('HAVE_WEXT', enable_wext)

# Checks for libdl - on certain platforms its part of libc

dl_dep = cc.find_library('dl')

'''

dl_deps = []

dl_dep = cc.find_library('dl')

if dl_dep.found() and cc.has_function('dlopen')

  dl_deps += dl_dep

else

  dl_dep = dependency('dl', required: false)

  if dl_dep.found() and cc.has_function('dlopen', dependencies: dl_dep)

    dl_deps += dl_dep

  else

    dld_dep = dependency('dld', required: false)

    if dld_dep.found() and cc.has_function('dlopen', dependencies: dld_dep)

      dl_deps += dld_dep

    endif

  endif

endif

'''

# introspection support

enable_introspection = get_option('introspection')

if enable_introspection

  gir_dep = dependency('gobject-introspection-1.0', version: '>= 0.9.6', required: false)

  assert(gir_dep.found(), 'introspection support was requested, but the gobject-introspection library is not available. Use -Dintrospection=false to build without it.')

endif

udev_udevdir = get_option('udev_dir')

install_udevdir = (udev_udevdir != 'no')

if install_udevdir and udev_udevdir == ''

  udev_udevdir = dependency('udev').get_pkgconfig_variable('udevdir')

endif

systemd_systemdsystemunitdir = get_option('systemdsystemunitdir')

install_systemdunitdir = (systemd_systemdsystemunitdir != 'no')

if install_systemdunitdir and systemd_systemdsystemunitdir == ''

  assert(systemd_dep.found(), 'systemd required but not found, please provide a valid systemd user unit dir or disable it')

  systemd_systemdsystemunitdir = systemd_dep.get_pkgconfig_variable('systemdsystemunitdir')

endif

enable_systemd_journal = get_option('systemd_journal')

if enable_systemd_journal

  assert(libsystemd_dep.found(), 'Missing systemd-journald support')

endif

config_h.set10('SYSTEMD_JOURNAL', enable_systemd_journal)

config_logging_backend_default = get_option('config_logging_backend_default')

if config_logging_backend_default == 'default'

  config_logging_backend_default = (enable_systemd_journal ? 'journal' : 'syslog')

endif

config_h.set_quoted('NM_CONFIG_DEFAULT_LOGGING_BACKEND', config_logging_backend_default)

session_tracking = get_option('session_tracking')

session_trackers = []

if session_tracking == 'systemd'

  logind_dep = libsystemd_dep

  if not logind_dep.found()

    logind_dep = dependency('libsystemd-login', required: false)

    assert(logind_dep.found(), 'You must have libsystemd or libsystemd-login installed to build with systemd-logind support')

  endif

  session_trackers += 'systemd-logind'

  config_h.set10('SESSION_TRACKING_SYSTEMD', true)

  config_h.set10('SESSION_TRACKING_ELOGIND', false)

elif session_tracking == 'elogind'

  logind_dep = libelogind_dep

  assert(logind_dep.found() and libelogind_dep.version().version_compare('>= 229'), 'You must have libelogind installed to build with elogind support.')

  session_trackers += 'elogind'

  config_h.set10('SESSION_TRACKING_SYSTEMD', false)

  config_h.set10('SESSION_TRACKING_ELOGIND', true)

else

  config_h.set10('SESSION_TRACKING_SYSTEMD', false)

  config_h.set10('SESSION_TRACKING_ELOGIND', false)

  logind_dep = dependency('', required:false)

endif

session_tracking_consolekit = get_option('session_tracking_consolekit')

if session_tracking_consolekit

  session_trackers += 'consolekit'

endif

config_h.set10('SESSION_TRACKING_CONSOLEKIT', session_tracking_consolekit)

hostname_persist = get_option('hostname_persist')

config_h.set('HOSTNAME_PERSIST_SUSE', (hostname_persist == 'suse'))

config_h.set('HOSTNAME_PERSIST_GENTOO', (hostname_persist == 'gentoo'))

config_h.set('HOSTNAME_PERSIST_SLACKWARE', (hostname_persist == 'slackware'))

suspend_resume = get_option('suspend_resume')

if suspend_resume == 'auto'

  if libsystemd_dep.found() or libsystemd_login_dep.found()

    suspend_resume = 'systemd'

  elif libelogind_dep.found()

    suspend_resume = 'elogind'

  elif session_tracking_consolekit

    suspend_resume = 'consolekit'

  else

    suspend_resume = 'upower'

  endif

endif

if suspend_resume == 'systemd'

  if libsystemd_dep.found()

    system_inhibit_dep = libsystemd_dep

  elif libsystemd_login_dep.found()

    system_inhibit_dep = libsystemd_login_dep

  else

    error('Need libsystemd for suspend_resume=systemd')

  endif

  config_h.set('SUSPEND_RESUME_SYSTEMD', true)

elif suspend_resume == 'elogind'

  assert(libelogind_dep.found(), 'Need libelogind for suspend_resume=elogind')

  system_inhibit_dep = libelogind_dep

  config_h.set('SUSPEND_RESUME_ELOGIND', true)

elif suspend_resume == 'consolekit'

  config_h.set('SUSPEND_RESUME_CONSOLEKIT', true)

elif suspend_resume == 'upower'

  config_h.set('SUSPEND_RESUME_UPOWER', true)

else

  error('bug')

endif

# SELinux support

enable_selinux = get_option('selinux')

if enable_selinux

  selinux_dep = dependency('libselinux', required: false)

  assert(selinux_dep.found(), 'You must have libselinux installed to build. Use -Dselinux=false to disable it')

endif

config_h.set10('HAVE_SELINUX', enable_selinux)

# eBPF support

ebpf_opt = get_option('ebpf')

# 'auto' means 'false', because there are still issues.

if ebpf_opt != 'true'

  enable_ebpf = false

else

  enable_ebpf = true

  if not cc.has_header('linux/bpf.h')

    assert(ebpf_opt != 'true', 'eBPF requires kernel support')

    enable_ebpf = false

  endif

endif

# libaudit support

libaudit = get_option('libaudit')

enable_libaudit = libaudit.contains('yes')

if enable_libaudit

  libaudit_dep = dependency('audit', required: false)

  assert(libaudit_dep.found(), 'You must have libaudit installed to build. Use -Dlibaudit=no to disable it')

endif

config_default_logging_audit = (libaudit == 'yes').to_string()

config_h.set_quoted('NM_CONFIG_DEFAULT_LOGGING_AUDIT', config_default_logging_audit)

config_h.set10('HAVE_LIBAUDIT', enable_libaudit)

# Teamd control checks

enable_teamdctl = get_option('teamdctl')

if enable_teamdctl

  assert(jansson_dep.found(), 'You must have jansson installed to build. Use -Dteamdctl=false to disable it')

  libteamdctl_dep = dependency('libteamdctl', version: '>= 1.9')

  assert(libteamdctl_dep.found(), 'You must have libteamdctl installed to build. Use -Dteamdctl=false to disable it')

endif

enable_json_validation = get_option('json_validation')

if enable_json_validation

  assert(jansson_dep.found(), 'jansson is needed for team configuration validation. Use -Djson_validation=false to disable it')

endif

config_h.set10('WITH_JSON_VALIDATION', enable_json_validation)

# polkit

enable_polkit = get_option('polkit')

if enable_polkit

  # FIXME: policydir should be relative to `datadir`, not `prefix`. Fixed in https://gitlab.freedesktop.org/polkit/polkit/merge_requests/2

  polkit_gobject_policydir = dependency('polkit-gobject-1').get_pkgconfig_variable('policydir', define_variable: ['prefix', nm_prefix])

endif

config_auth_polkit_default = get_option('config_auth_polkit_default')

if config_auth_polkit_default == 'default'

  config_auth_polkit_default = (enable_polkit ? 'true' : 'false')

endif

config_h.set_quoted('NM_CONFIG_DEFAULT_MAIN_AUTH_POLKIT', config_auth_polkit_default)

enable_modify_system = get_option('modify_system')

polkit_agent_dep = dependency('polkit-agent-1', version: '>= 0.97', required : false)

if polkit_agent_dep.found()

	config_h.set_quoted('POLKIT_PACKAGE_PREFIX', polkit_agent_dep.get_pkgconfig_variable('prefix'))

else

	config_h.set_quoted('POLKIT_PACKAGE_PREFIX', '/usr')

endif

crypto = get_option('crypto')

if crypto == 'nss'

    crypto_dep = dependency('nss', required: false)

    assert(crypto_dep.found(), 'Requires nss crypto support')

elif crypto == 'gnutls'

    crypto_dep = dependency(

      'gnutls',

      version: '>= 2.12',

      required: false,

    )

    assert(crypto_dep.found(), 'Requires gnutls crypto support')

else

  error('bug')

endif

dbus_conf_dir = get_option('dbus_conf_dir')

if dbus_conf_dir == ''

  assert(dbus_dep.found(), 'D-Bus required but not found, please provide a valid system bus config dir')

  dbus_conf_dir = join_paths(dbus_dep.get_pkgconfig_variable('sysconfdir', define_variable: ['sysconfdir', nm_sysconfdir]), 'dbus-1', 'system.d')

endif

dbus_interfaces_dir = dbus_dep.get_pkgconfig_variable('interfaces_dir',  define_variable: ['datadir', nm_datadir])

dbus_system_bus_services_dir = dbus_dep.get_pkgconfig_variable('system_bus_services_dir', define_variable: ['datadir', nm_datadir])

enable_firewalld_zone = get_option('firewalld_zone')

config_h.set10('WITH_FIREWALLD_ZONE', enable_firewalld_zone)

# pppd

enable_ppp = get_option('ppp')

if enable_ppp

  assert(cc.has_header('pppd/pppd.h'), 'couldn\'t find pppd.h. pppd development headers are required')

  pppd_path = get_option('pppd')

  if pppd_path == ''

    pppd = find_program('pppd', '/sbin/pppd', '/usr/sbin/pppd', required: false)

    assert(pppd.found(), 'pppd required but not found, please provide a valid pppd path or use -Dppp=false to disable it')

    pppd_path = pppd.path()

  endif

  config_h.set_quoted('PPPD_PATH', pppd_path)

  pppd_plugin_dir = get_option('pppd_plugin_dir')

  if pppd_plugin_dir == ''

    pppd_plugin_dir = join_paths(nm_libdir, 'pppd', '2.4.5')

  endif

endif

config_h.set10('WITH_PPP', enable_ppp)

# ModemManager1 with libmm-glib

enable_modem_manager = get_option('modem_manager')

if enable_modem_manager

  mm_glib_dep = dependency('mm-glib', version: '>= 0.7.991')

  mobile_broadband_provider_info_database = dependency('mobile-broadband-provider-info').get_pkgconfig_variable('database')

  config_h.set_quoted('MOBILE_BROADBAND_PROVIDER_INFO_DATABASE', mobile_broadband_provider_info_database)

endif

# Bluez5 DUN support

enable_bluez5_dun = get_option('bluez5_dun')

if enable_bluez5_dun

  bluez5_dep = dependency('bluez', version: '>= 5', required: false)

  assert(bluez5_dep.found(), 'Bluez 5.x development headers are required')

endif

config_h.set10('WITH_BLUEZ5_DUN', enable_bluez5_dun)

# OFONO

enable_ofono = get_option('ofono')

config_h.set10('WITH_OFONO', enable_ofono)

# DHCP client support

config_dhcp_default = get_option('config_dhcp_default')

config_h.set_quoted('NM_CONFIG_DEFAULT_MAIN_DHCP', config_dhcp_default)

dhcp_summary = ''

foreach client : [ 'dhclient', 'dhcpcd', 'dhcpcanon' ]

  client_path = get_option(client)

  client_enable = (client_path != 'no')

  if client_enable

    if client_path == ''

      client_prog = find_program(client,

                                 '/sbin/' + client,

                                 '/usr/sbin/pppd/' + client,

                                 '/usr/local/sbin/' + client,

                                 required : false)

      if client_prog.found()

        client_path = client_prog.path()

      else

        client_path = '/usr/sbin/' + client

        message('@0@ not found, assume path @1@'.format(client, client_path))

      endif

    endif

    config_h.set_quoted(client.to_upper() + '_PATH', client_path)

  endif

  if config_dhcp_default == client and not client_enable

    error(client + ' has not been enabled. Please don\'t disable it or use another configuration option for main.dhcp setting')

  endif

  config_h.set10('WITH_' + client.to_upper(), client_enable)

  dhcp_summary += ('  ' + client + ': ' + client_enable.to_string())

  if (client_enable)

    dhcp_summary += (' ' + client_path)

  endif

  dhcp_summary += '\n'

endforeach

# Open vSwitch integration

enable_ovs = get_option('ovs')

if enable_ovs

  assert(jansson_dep.found(), 'jansson is needed for Open vSwitch integration. Use -Dovs=false to disable it')

endif

# DNS resolv.conf managers

config_dns_rc_manager_default = get_option('config_dns_rc_manager_default')

config_h.set_quoted('NM_CONFIG_DEFAULT_MAIN_RC_MANAGER', config_dns_rc_manager_default)

resolv_conf_summary = ''

foreach prog_name : ['resolvconf', 'netconfig']

  prog_path = get_option(prog_name)

  prog_enable = (prog_path != 'no')

  if prog_enable

    if prog_path == ''

      prog = find_program(prog_name,

                          '/usr/' + prog_name,

                          '/usr/sbin/' + prog_name,

                          '/usr/local/sbin/' + prog_name,

                          required : false)

      if prog.found()

        prog_path = prog.path()

      else

        prog_enable = false

      endif

    endif

  endif

  if prog_enable

    config_h.set_quoted(prog_name.to_upper() + '_PATH', prog_path)

  elif config_dns_rc_manager_default == prog_name

    error(prog_name + ' has not been enabled. Please don\'t disable it or use another configuration option for main.rc-manager setting')

  endif

  resolv_conf_summary += '  ' + prog_name + ': ' + prog_enable.to_string()

  if prog_enable

    resolv_conf_summary += ' ' + prog_path

  endif

  resolv_conf_summary += '\n'

endforeach

# external misc tools paths

default_paths = ['/sbin', '/usr/sbin']

dnssec_ts_paths = ['/usr/local/libexec',

                   '/usr/local/lib',

                   '/usr/local/lib/dnssec-trigger',

                   '/usr/libexec',

                   '/usr/lib',

                   '/usr/lib/dnssec-trigger']

# 0: cmdline option, 1: paths, 2: fallback

progs = [['iptables',       default_paths,   '/sbin/iptables'],

         ['dnsmasq',        default_paths,   ''],

         ['dnssec_trigger', dnssec_ts_paths, join_paths(nm_libexecdir, 'dnssec-trigger-script') ],

        ]

foreach prog : progs

  path = get_option(prog[0])

  if path == ''

    search_paths = [ prog[0] ]

    foreach path : prog[1]

      search_paths += (path + '/' + prog[0])

    endforeach

    exe = find_program(search_paths, required : false)

    path = exe.found() ? exe.path() : prog[2]

  endif

  name = prog[0].to_upper() + '_PATH'

  config_h.set_quoted(name, path)

endforeach

# system CA certificates path

system_ca_path = get_option('system_ca_path')

config_h.set_quoted('SYSTEM_CA_PATH', system_ca_path)

# kernel firmware dir

kernel_firmware_dir = get_option('kernel_firmware_dir')

config_h.set_quoted('KERNEL_FIRMWARE_DIR', kernel_firmware_dir)

enable_libpsl = get_option('libpsl')

if enable_libpsl

  libpsl_dep = dependency('libpsl', version: '>= 0.1')

endif

config_h.set10('WITH_LIBPSL', enable_libpsl)

libcurl_dep = dependency('libcurl', version: '>= 7.24.0', required: false)

enable_concheck = get_option('concheck')

if enable_concheck

  assert(libcurl_dep.found(), 'concheck requires libcurl library. Use -Dconcheck=false to disable it')

endif

config_h.set10('WITH_CONCHECK', enable_concheck)

enable_nmcli = get_option('nmcli')

if enable_nmcli

  # FIXME: check for readline

  # AX_LIB_READLINE

  readline_dep = declare_dependency(link_args: '-lreadline')

  '''

  foreach readline_lib: ['-lreadline', '-ledit', '-leditline']

    if not is_variable('readline_dep')

      foreach termcap_lib: ['', '-lncurses', '-ltermcap', '-lcurses']

        test_dep = declare_dependency(link_args: ' '.join([readline_lib, termcap_lib]))

        if cc.has_function('readline', dependencies: test_dep) and cc.has_header('readline', dependencies: test_dep)

          readline_dep = test_dep

        endif

      endforeach

    endif

  endforeach

  '''

  assert(readline_dep.found(), 'readline library with terminfo support is required (one of readline, edit, or editline, AND one of ncurses, curses, or termcap)')

endif

enable_nmtui = get_option('nmtui')

if enable_nmtui

  newt_dep = dependency('libnewt', version: '>= 0.52.15', required: false)

  assert(newt_dep.found(), 'You must have libnewt installed to build nmtui. Use -Dnmtui=false to disable it')

endif

enable_nm_cloud_setup = get_option('nm_cloud_setup')

if enable_nm_cloud_setup

  assert(libcurl_dep.found(), 'nm-cloud-setup requires libcurl library. Use -Dnm_cloud_setup=false to disable it')

endif

more_asserts = get_option('more_asserts')

if more_asserts == 'no'

  more_asserts = 0

elif more_asserts == 'all'

  more_asserts = 100

else

  more_asserts = more_asserts.to_int()

endif

config_h.set('NM_MORE_ASSERTS', more_asserts)

more_logging = get_option('more_logging')

config_h.set10('NM_MORE_LOGGING', more_logging)

generic_support_src = 'int main() { int a = 0; int b = _Generic (a, int: 4); return b + a; };'

config_h.set10('_NM_CC_SUPPORT_GENERIC', cc.compiles(generic_support_src))

auto_support_src = 'int main() { int a = 0; __auto_type b = a; return b + a; };'

config_h.set10('_NM_CC_SUPPORT_AUTO_TYPE', cc.compiles(auto_support_src))

# Vala bindings

vapi_opt = get_option('vapi')

if vapi_opt == 'false'

  enable_vapi = false

else

  vala_req_version = '>= 0.17.1.24'

  enable_vapi = true

  if not enable_introspection

    assert(vapi_opt != 'true', 'vala api require GObject introspection. Use -Dvapi=false to disable it')

    enable_vapi = false

  endif

  if enable_vapi and not add_languages('vala', required: false)

    assert(vapi_opt != 'true', 'vala is required to build. Use -Dvapi=false to disable it')

    enable_vapi = false

  endif

  if enable_vapi and not meson.get_compiler('vala').version().version_compare(vala_req_version)

    assert(vapi_opt != 'true', 'vala ' + vala_req_version + ' is required to build. Use -Dvapi=false to disable it')

    enable_vapi = false

  endif

endif

# Tests, utilities and documentation

tests = get_option('tests')

enable_tests = (tests != 'no')

require_root_tests = (tests == 'root')

test_script = find_program(join_paths(source_root, 'tools', 'run-nm-test.sh'))

# valgrind

locations = get_option('valgrind')

enable_valgrind = (locations != ['no'])

if enable_valgrind

  valgrind = find_program(locations, required: false)

  enable_valgrind = valgrind.found()

endif

if enable_valgrind

  valgrind_suppressions_path = get_option('valgrind_suppressions')

  if valgrind_suppressions_path == ''

    valgrind_suppressions_path = join_paths(source_root, 'valgrind.suppressions')

  endif

endif

test_args = [

  '--called-from-make',

  build_root,

  '',

  enable_valgrind ? valgrind.path() : '',

  enable_valgrind ? valgrind_suppressions_path : '',

  '--launch-dbus=auto',

]

py3 = import('python3')

python = py3.find_python()

if python.found()

  config_h.set_quoted('TEST_NM_PYTHON', python.path())

endif

data_conf = configuration_data()

data_conf.set('DISTRO_NETWORK_SERVICE',                  (enable_ifcfg_rh ? 'network.service' : ''))

data_conf.set('NM_CONFIG_DEFAULT_LOGGING_AUDIT_TEXT',    config_default_logging_audit)

data_conf.set('NM_CONFIG_DEFAULT_LOGGING_BACKEND_TEXT',  config_logging_backend_default)

data_conf.set('NM_CONFIG_DEFAULT_MAIN_AUTH_POLKIT_TEXT', config_auth_polkit_default)

data_conf.set('NM_CONFIG_DEFAULT_MAIN_DHCP',             config_dhcp_default)

data_conf.set('NM_CONFIG_DEFAULT_MAIN_RC_MANAGER',       config_dns_rc_manager_default)

data_conf.set('NM_MAJOR_VERSION',                        nm_major_version)

data_conf.set('NM_MICRO_VERSION',                        nm_micro_version)

data_conf.set('NM_MINOR_VERSION',                        nm_minor_version)

data_conf.set('NM_MODIFY_SYSTEM_POLICY',                 (enable_modify_system ? 'yes' : 'auth_admin_keep'))

data_conf.set('NM_VERSION',                              nm_version)

data_conf.set('VERSION',                                 nm_version)

data_conf.set('bindir',                                  nm_bindir)

data_conf.set('libexecdir',                              nm_libexecdir)

data_conf.set('localstatedir',                           nm_localstatedir)

data_conf.set('nmrundir',                                nm_pkgrundir)

data_conf.set('nmstatedir',                              nm_pkgstatedir)

data_conf.set('sbindir',                                 nm_sbindir)

data_conf.set('sysconfdir',                              nm_sysconfdir)

# 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; 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