test/test-network/systemd-networkd-tests.py

   1 #!/usr/bin/env python3
   2 # SPDX-License-Identifier: LGPL-2.1+
   3 # systemd-networkd tests
   4
   5 import argparse
   6 import os
   7 import re
   8 import shutil
   9 import signal
  10 import subprocess
  11 import sys
  12 import time
  13 import unittest
  14 from shutil import copytree
  15
  16 network_unit_file_path='/run/systemd/network'
  17 networkd_runtime_directory='/run/systemd/netif'
  18 networkd_ci_path='/run/networkd-ci'
  19 network_sysctl_ipv6_path='/proc/sys/net/ipv6/conf'
  20 network_sysctl_ipv4_path='/proc/sys/net/ipv4/conf'
  21
  22 dnsmasq_pid_file='/run/networkd-ci/test-test-dnsmasq.pid'
  23 dnsmasq_log_file='/run/networkd-ci/test-dnsmasq-log-file'
  24
  25 networkd_bin='/usr/lib/systemd/systemd-networkd'
  26 wait_online_bin='/usr/lib/systemd/systemd-networkd-wait-online'
  27 networkctl_bin='/usr/bin/networkctl'
  28 use_valgrind=False
  29 enable_debug=False
  30 env = {}
  31 asan_options=None
  32 lsan_options=None
  33 ubsan_options=None
  34
  35 def check_output(*command, **kwargs):
  36     # This replaces both check_output and check_call (output can be ignored)
  37     command = command[0].split() + list(command[1:])
  38     return subprocess.check_output(command, universal_newlines=True, **kwargs).rstrip()
  39
  40 def call(*command, **kwargs):
  41     command = command[0].split() + list(command[1:])
  42     return subprocess.call(command, universal_newlines=True, **kwargs)
  43
  44 def run(*command, **kwargs):
  45     command = command[0].split() + list(command[1:])
  46     return subprocess.run(command, universal_newlines=True, **kwargs)
  47
  48 def is_module_available(module_name):
  49     lsmod_output = check_output('lsmod')
  50     module_re = re.compile(rf'^{re.escape(module_name)}\b', re.MULTILINE)
  51     return module_re.search(lsmod_output) or not call('modprobe', module_name)
  52
  53 def expectedFailureIfModuleIsNotAvailable(module_name):
  54     def f(func):
  55         if not is_module_available(module_name):
  56             return unittest.expectedFailure(func)
  57         return func
  58
  59     return f
  60
  61 def expectedFailureIfERSPANModuleIsNotAvailable():
  62     def f(func):
  63         rc = call('ip link add dev erspan99 type erspan seq key 30 local 192.168.1.4 remote 192.168.1.1 erspan_ver 1 erspan 123')
  64         if rc == 0:
  65             call('ip link del erspan99')
  66             return func
  67         else:
  68             return unittest.expectedFailure(func)
  69
  70     return f
  71
  72 def expectedFailureIfRoutingPolicyPortRangeIsNotAvailable():
  73     def f(func):
  74         rc = call('ip rule add from 192.168.100.19 sport 1123-1150 dport 3224-3290 table 7')
  75         if rc == 0:
  76             call('ip rule del from 192.168.100.19 sport 1123-1150 dport 3224-3290 table 7')
  77             return func
  78         else:
  79             return unittest.expectedFailure(func)
  80
  81     return f
  82
  83 def expectedFailureIfRoutingPolicyIPProtoIsNotAvailable():
  84     def f(func):
  85         rc = call('ip rule add not from 192.168.100.19 ipproto tcp table 7')
  86         if rc == 0:
  87             call('ip rule del not from 192.168.100.19 ipproto tcp table 7')
  88             return func
  89         else:
  90             return unittest.expectedFailure(func)
  91
  92     return f
  93
  94 def expectedFailureIfEthtoolDoesNotSupportDriver():
  95     def f(func):
  96         support = False
  97         rc = call('ip link add name dummy99 type dummy')
  98         if rc == 0:
  99             ret = run('udevadm info -w10s /sys/class/net/dummy99', stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 100             if ret.returncode == 0 and 'E: ID_NET_DRIVER=dummy' in ret.stdout.rstrip():
 101                 support = True
 102             call('ip link del dummy99')
 103
 104         if support:
 105             return func
 106         else:
 107             return unittest.expectedFailure(func)
 108
 109     return f
 110
 111 def setUpModule():
 112     os.makedirs(network_unit_file_path, exist_ok=True)
 113     os.makedirs(networkd_ci_path, exist_ok=True)
 114
 115     shutil.rmtree(networkd_ci_path)
 116     copytree(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'conf'), networkd_ci_path)
 117
 118     check_output('systemctl stop systemd-networkd.socket')
 119     check_output('systemctl stop systemd-networkd.service')
 120
 121     drop_in = [
 122         '[Service]',
 123         'Restart=no',
 124         'ExecStart=',
 125     ]
 126     if use_valgrind:
 127         drop_in += [
 128             'ExecStart=!!valgrind --track-origins=yes --leak-check=full --show-leak-kinds=all ' + networkd_bin,
 129             'PrivateTmp=yes'
 130         ]
 131     else:
 132         drop_in += ['ExecStart=!!' + networkd_bin]
 133     if enable_debug:
 134         drop_in += ['Environment=SYSTEMD_LOG_LEVEL=debug']
 135     if asan_options:
 136         drop_in += ['Environment=ASAN_OPTIONS="' + asan_options + '"']
 137     if lsan_options:
 138         drop_in += ['Environment=LSAN_OPTIONS="' + lsan_options + '"']
 139     if ubsan_options:
 140         drop_in += ['Environment=UBSAN_OPTIONS="' + ubsan_options + '"']
 141     if asan_options or lsan_options or ubsan_options:
 142         drop_in += ['SystemCallFilter=']
 143     if use_valgrind or asan_options or lsan_options or ubsan_options:
 144         drop_in += ['MemoryDenyWriteExecute=no']
 145
 146     os.makedirs('/run/systemd/system/systemd-networkd.service.d', exist_ok=True)
 147     with open('/run/systemd/system/systemd-networkd.service.d/00-override.conf', mode='w') as f:
 148         f.write('\n'.join(drop_in))
 149
 150     check_output('systemctl daemon-reload')
 151     print(check_output('systemctl cat systemd-networkd.service'))
 152
 153 def tearDownModule():
 154     shutil.rmtree(networkd_ci_path)
 155
 156     check_output('systemctl stop systemd-networkd.service')
 157
 158     shutil.rmtree('/run/systemd/system/systemd-networkd.service.d')
 159     check_output('systemctl daemon-reload')
 160
 161     check_output('systemctl start systemd-networkd.socket')
 162     check_output('systemctl start systemd-networkd.service')
 163
 164 def read_link_attr(link, dev, attribute):
 165     with open(os.path.join(os.path.join(os.path.join('/sys/class/net/', link), dev), attribute)) as f:
 166         return f.readline().strip()
 167
 168 def read_bridge_port_attr(bridge, link, attribute):
 169     path_bridge = os.path.join('/sys/devices/virtual/net', bridge)
 170     path_port = 'lower_' + link + '/brport'
 171     path = os.path.join(path_bridge, path_port)
 172
 173     with open(os.path.join(path, attribute)) as f:
 174         return f.readline().strip()
 175
 176 def link_exists(link):
 177     return os.path.exists(os.path.join('/sys/class/net', link))
 178
 179 def remove_links(links):
 180     for link in links:
 181         if link_exists(link):
 182             call('ip link del dev', link)
 183     time.sleep(1)
 184
 185 def remove_fou_ports(ports):
 186     for port in ports:
 187         call('ip fou del port', port, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 188
 189 def remove_routing_policy_rule_tables(tables):
 190     for table in tables:
 191         rc = 0
 192         while rc == 0:
 193             rc = call('ip rule del table', table, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 194
 195 def remove_routes(routes):
 196     for route_type, addr in routes:
 197         call('ip route del', route_type, addr, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 198
 199 def l2tp_tunnel_remove(tunnel_ids):
 200     output = check_output('ip l2tp show tunnel')
 201     for tid in tunnel_ids:
 202         words='Tunnel ' + tid + ', encap'
 203         if words in output:
 204             call('ip l2tp del tunnel tid', tid)
 205     time.sleep(1)
 206
 207 def read_ipv6_sysctl_attr(link, attribute):
 208     with open(os.path.join(os.path.join(network_sysctl_ipv6_path, link), attribute)) as f:
 209         return f.readline().strip()
 210
 211 def read_ipv4_sysctl_attr(link, attribute):
 212     with open(os.path.join(os.path.join(network_sysctl_ipv4_path, link), attribute)) as f:
 213         return f.readline().strip()
 214
 215 def copy_unit_to_networkd_unit_path(*units):
 216     print()
 217     for unit in units:
 218         shutil.copy(os.path.join(networkd_ci_path, unit), network_unit_file_path)
 219         if (os.path.exists(os.path.join(networkd_ci_path, unit + '.d'))):
 220             copytree(os.path.join(networkd_ci_path, unit + '.d'), os.path.join(network_unit_file_path, unit + '.d'))
 221
 222 def remove_unit_from_networkd_path(units):
 223     for unit in units:
 224         if (os.path.exists(os.path.join(network_unit_file_path, unit))):
 225             os.remove(os.path.join(network_unit_file_path, unit))
 226             if (os.path.exists(os.path.join(network_unit_file_path, unit + '.d'))):
 227                 shutil.rmtree(os.path.join(network_unit_file_path, unit + '.d'))
 228
 229 def warn_about_firewalld():
 230     rc = call('systemctl -q is-active firewalld.service')
 231     if rc == 0:
 232         print('\nWARNING: firewalld.service is active. The test may fail.')
 233
 234 def start_dnsmasq(additional_options='', ipv4_range='192.168.5.10,192.168.5.200', ipv6_range='2600::10,2600::20', lease_time='1h'):
 235     warn_about_firewalld()
 236     dnsmasq_command = f'dnsmasq -8 /var/run/networkd-ci/test-dnsmasq-log-file --log-queries=extra --log-dhcp --pid-file=/var/run/networkd-ci/test-test-dnsmasq.pid --conf-file=/dev/null --interface=veth-peer --enable-ra --dhcp-range={ipv6_range},{lease_time} --dhcp-range={ipv4_range},{lease_time} -R --dhcp-leasefile=/var/run/networkd-ci/lease --dhcp-option=26,1492 --dhcp-option=option:router,192.168.5.1 --dhcp-option=33,192.168.5.4,192.168.5.5 --port=0 ' + additional_options
 237     check_output(dnsmasq_command)
 238
 239 def stop_dnsmasq(pid_file):
 240     if os.path.exists(pid_file):
 241         with open(pid_file, 'r') as f:
 242             pid = f.read().rstrip(' \t\r\n\0')
 243             os.kill(int(pid), signal.SIGTERM)
 244
 245         os.remove(pid_file)
 246
 247 def search_words_in_dnsmasq_log(words, show_all=False):
 248     if os.path.exists(dnsmasq_log_file):
 249         with open (dnsmasq_log_file) as in_file:
 250             contents = in_file.read()
 251             if show_all:
 252                 print(contents)
 253             for line in contents.splitlines():
 254                 if words in line:
 255                     in_file.close()
 256                     print("%s, %s" % (words, line))
 257                     return True
 258     return False
 259
 260 def remove_lease_file():
 261     if os.path.exists(os.path.join(networkd_ci_path, 'lease')):
 262         os.remove(os.path.join(networkd_ci_path, 'lease'))
 263
 264 def remove_log_file():
 265     if os.path.exists(dnsmasq_log_file):
 266         os.remove(dnsmasq_log_file)
 267
 268 def start_networkd(sleep_sec=5, remove_state_files=True):
 269     if (remove_state_files and
 270         os.path.exists(os.path.join(networkd_runtime_directory, 'state'))):
 271         check_output('systemctl stop systemd-networkd')
 272         os.remove(os.path.join(networkd_runtime_directory, 'state'))
 273         check_output('systemctl start systemd-networkd')
 274     else:
 275         check_output('systemctl restart systemd-networkd')
 276     if sleep_sec > 0:
 277         time.sleep(sleep_sec)
 278
 279 def wait_online(links_with_operstate, timeout='20s', bool_any=False):
 280     args = wait_online_cmd + [f'--timeout={timeout}'] + [f'--interface={link}' for link in links_with_operstate]
 281     if bool_any:
 282         args += ['--any']
 283     try:
 284         check_output(*args, env=env)
 285     except subprocess.CalledProcessError:
 286         for link in links_with_operstate:
 287             output = check_output(*networkctl_cmd, 'status', link.split(':')[0], env=env)
 288             print(output)
 289         raise
 290
 291 def get_operstate(link, show_status=True, setup_state='configured'):
 292     output = check_output(*networkctl_cmd, 'status', link, env=env)
 293     if show_status:
 294         print(output)
 295     for line in output.splitlines():
 296         if 'State:' in line and (not setup_state or setup_state in line):
 297             return line.split()[1]
 298     return None
 299
 300 class Utilities():
 301     def check_link_exists(self, link):
 302         self.assertTrue(link_exists(link))
 303
 304     def check_operstate(self, link, expected, show_status=True, setup_state='configured'):
 305         self.assertRegex(get_operstate(link, show_status, setup_state), expected)
 306
 307     def wait_address(self, link, address_regex, scope='global', ipv='', timeout_sec=100):
 308         for i in range(timeout_sec):
 309             if i > 0:
 310                 time.sleep(1)
 311             output = check_output(f'ip {ipv} address show dev {link} scope {scope}')
 312             if re.search(address_regex, output):
 313                 break
 314         else:
 315             self.assertRegex(output, address_regex)
 316
 317 class NetworkctlTests(unittest.TestCase, Utilities):
 318
 319     links = [
 320         'test1',
 321         'veth99',
 322     ]
 323
 324     units = [
 325         '11-dummy.netdev',
 326         '11-dummy-mtu.netdev',
 327         '11-dummy.network',
 328         '25-veth.netdev',
 329         'netdev-link-local-addressing-yes.network',
 330     ]
 331
 332     def setUp(self):
 333         remove_links(self.links)
 334
 335     def tearDown(self):
 336         remove_links(self.links)
 337         remove_unit_from_networkd_path(self.units)
 338
 339     def test_glob(self):
 340         copy_unit_to_networkd_unit_path('11-dummy.netdev', '11-dummy.network')
 341         start_networkd(0)
 342
 343         wait_online(['test1:degraded'])
 344
 345         output = check_output(*networkctl_cmd, 'list', env=env)
 346         self.assertRegex(output, '1 lo ')
 347         self.assertRegex(output, 'test1')
 348
 349         output = check_output(*networkctl_cmd, 'list', 'test1', env=env)
 350         self.assertNotRegex(output, '1 lo ')
 351         self.assertRegex(output, 'test1')
 352
 353         output = check_output(*networkctl_cmd, 'list', 'te*', env=env)
 354         self.assertNotRegex(output, '1 lo ')
 355         self.assertRegex(output, 'test1')
 356
 357         output = check_output(*networkctl_cmd, 'status', 'te*', env=env)
 358         self.assertNotRegex(output, '1: lo ')
 359         self.assertRegex(output, 'test1')
 360
 361         output = check_output(*networkctl_cmd, 'status', 'tes[a-z][0-9]', env=env)
 362         self.assertNotRegex(output, '1: lo ')
 363         self.assertRegex(output, 'test1')
 364
 365     def test_mtu(self):
 366         copy_unit_to_networkd_unit_path('11-dummy-mtu.netdev', '11-dummy.network')
 367         start_networkd(0)
 368
 369         wait_online(['test1:degraded'])
 370
 371         output = check_output(*networkctl_cmd, 'status', 'test1', env=env)
 372         self.assertRegex(output, 'MTU: 1600')
 373
 374     @expectedFailureIfEthtoolDoesNotSupportDriver()
 375     def test_udev_driver(self):
 376         copy_unit_to_networkd_unit_path('11-dummy.netdev', '11-dummy.network',
 377                                         '25-veth.netdev', 'netdev-link-local-addressing-yes.network')
 378         start_networkd(0)
 379
 380         wait_online(['test1:degraded', 'veth99:degraded', 'veth-peer:degraded'])
 381
 382         output = check_output(*networkctl_cmd, 'status', 'test1', env=env)
 383         self.assertRegex(output, 'Driver: dummy')
 384
 385         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
 386         self.assertRegex(output, 'Driver: veth')
 387
 388         output = check_output(*networkctl_cmd, 'status', 'veth-peer', env=env)
 389         self.assertRegex(output, 'Driver: veth')
 390
 391     def test_delete_links(self):
 392         copy_unit_to_networkd_unit_path('11-dummy.netdev', '11-dummy.network',
 393                                         '25-veth.netdev', 'netdev-link-local-addressing-yes.network')
 394         start_networkd(0)
 395
 396         wait_online(['test1:degraded', 'veth99:degraded', 'veth-peer:degraded'])
 397
 398         check_output(*networkctl_cmd, 'delete', 'test1', 'veth99')
 399         self.assertFalse(link_exists('test1'))
 400         self.assertFalse(link_exists('veth99'))
 401         self.assertFalse(link_exists('veth-peer'))
 402
 403 class NetworkdNetDevTests(unittest.TestCase, Utilities):
 404
 405     links =[
 406         '6rdtun99',
 407         'bond99',
 408         'bridge99',
 409         'dropin-test',
 410         'dummy98',
 411         'erspan98',
 412         'erspan99',
 413         'geneve99',
 414         'gretap96',
 415         'gretap98',
 416         'gretap99',
 417         'gretun96',
 418         'gretun97',
 419         'gretun98',
 420         'gretun99',
 421         'ip6gretap98',
 422         'ip6gretap99',
 423         'ip6gretun97',
 424         'ip6gretun98',
 425         'ip6gretun99',
 426         'ip6tnl97',
 427         'ip6tnl98',
 428         'ip6tnl99',
 429         'ipiptun96',
 430         'ipiptun97',
 431         'ipiptun98',
 432         'ipiptun99',
 433         'ipvlan99',
 434         'ipvtap99',
 435         'isataptun99',
 436         'macvlan99',
 437         'macvtap99',
 438         'nlmon99',
 439         'sittun96',
 440         'sittun97',
 441         'sittun98',
 442         'sittun99',
 443         'tap99',
 444         'test1',
 445         'tun99',
 446         'vcan99',
 447         'veth99',
 448         'vlan99',
 449         'vrf99',
 450         'vti6tun97',
 451         'vti6tun98',
 452         'vti6tun99',
 453         'vtitun97',
 454         'vtitun98',
 455         'vtitun99',
 456         'vxcan99',
 457         'vxlan99',
 458         'wg98',
 459         'wg99']
 460
 461     units = [
 462         '10-dropin-test.netdev',
 463         '11-dummy.netdev',
 464         '11-dummy.network',
 465         '12-dummy.netdev',
 466         '15-name-conflict-test.netdev',
 467         '21-macvlan.netdev',
 468         '21-macvtap.netdev',
 469         '21-vlan-test1.network',
 470         '21-vlan.netdev',
 471         '21-vlan.network',
 472         '25-6rd-tunnel.netdev',
 473         '25-bond.netdev',
 474         '25-bond-balanced-tlb.netdev',
 475         '25-bridge.netdev',
 476         '25-bridge-configure-without-carrier.network',
 477         '25-bridge.network',
 478         '25-erspan-tunnel-local-any.netdev',
 479         '25-erspan-tunnel.netdev',
 480         '25-fou-gretap.netdev',
 481         '25-fou-gre.netdev',
 482         '25-fou-ipip.netdev',
 483         '25-fou-ipproto-gre.netdev',
 484         '25-fou-ipproto-ipip.netdev',
 485         '25-fou-sit.netdev',
 486         '25-geneve.netdev',
 487         '25-gretap-tunnel-local-any.netdev',
 488         '25-gretap-tunnel.netdev',
 489         '25-gre-tunnel-local-any.netdev',
 490         '25-gre-tunnel-remote-any.netdev',
 491         '25-gre-tunnel.netdev',
 492         '25-ip6gretap-tunnel-local-any.netdev',
 493         '25-ip6gretap-tunnel.netdev',
 494         '25-ip6gre-tunnel-local-any.netdev',
 495         '25-ip6gre-tunnel-remote-any.netdev',
 496         '25-ip6gre-tunnel.netdev',
 497         '25-ip6tnl-tunnel-remote-any.netdev',
 498         '25-ip6tnl-tunnel-local-any.netdev',
 499         '25-ip6tnl-tunnel.netdev',
 500         '25-ipip-tunnel-independent.netdev',
 501         '25-ipip-tunnel-local-any.netdev',
 502         '25-ipip-tunnel-remote-any.netdev',
 503         '25-ipip-tunnel.netdev',
 504         '25-ipvlan.netdev',
 505         '25-ipvtap.netdev',
 506         '25-isatap-tunnel.netdev',
 507         '25-macsec.key',
 508         '25-macsec.netdev',
 509         '25-macsec.network',
 510         '25-nlmon.netdev',
 511         '25-sit-tunnel-local-any.netdev',
 512         '25-sit-tunnel-remote-any.netdev',
 513         '25-sit-tunnel.netdev',
 514         '25-tap.netdev',
 515         '25-tun.netdev',
 516         '25-tunnel-local-any.network',
 517         '25-tunnel-remote-any.network',
 518         '25-tunnel.network',
 519         '25-vcan.netdev',
 520         '25-veth.netdev',
 521         '25-vrf.netdev',
 522         '25-vti6-tunnel-local-any.netdev',
 523         '25-vti6-tunnel-remote-any.netdev',
 524         '25-vti6-tunnel.netdev',
 525         '25-vti-tunnel-local-any.netdev',
 526         '25-vti-tunnel-remote-any.netdev',
 527         '25-vti-tunnel.netdev',
 528         '25-vxcan.netdev',
 529         '25-vxlan.netdev',
 530         '25-wireguard-23-peers.netdev',
 531         '25-wireguard-23-peers.network',
 532         '25-wireguard-preshared-key.txt',
 533         '25-wireguard-private-key.txt',
 534         '25-wireguard.netdev',
 535         '25-wireguard.network',
 536         '6rd.network',
 537         'erspan.network',
 538         'gre.network',
 539         'gretap.network',
 540         'gretun.network',
 541         'ip6gretap.network',
 542         'ip6gretun.network',
 543         'ip6tnl.network',
 544         'ipip.network',
 545         'ipvlan.network',
 546         'ipvtap.network',
 547         'isatap.network',
 548         'macsec.network',
 549         'macvlan.network',
 550         'macvtap.network',
 551         'netdev-link-local-addressing-yes.network',
 552         'sit.network',
 553         'vti6.network',
 554         'vti.network',
 555         'vxlan-test1.network',
 556         'vxlan.network']
 557
 558     fou_ports = [
 559         '55555',
 560         '55556']
 561
 562     def setUp(self):
 563         remove_fou_ports(self.fou_ports)
 564         remove_links(self.links)
 565
 566     def tearDown(self):
 567         remove_fou_ports(self.fou_ports)
 568         remove_links(self.links)
 569         remove_unit_from_networkd_path(self.units)
 570
 571     def test_dropin_and_name_conflict(self):
 572         copy_unit_to_networkd_unit_path('10-dropin-test.netdev', '15-name-conflict-test.netdev')
 573         start_networkd(0)
 574
 575         wait_online(['dropin-test:off'])
 576
 577         output = check_output('ip link show dropin-test')
 578         print(output)
 579         self.assertRegex(output, '00:50:56:c0:00:28')
 580
 581     def test_wait_online_any(self):
 582         copy_unit_to_networkd_unit_path('25-bridge.netdev', '25-bridge.network', '11-dummy.netdev', '11-dummy.network')
 583         start_networkd(0)
 584
 585         wait_online(['bridge99', 'test1:degraded'], bool_any=True)
 586
 587         self.check_operstate('bridge99', '(?:off|no-carrier)', setup_state='configuring')
 588         self.check_operstate('test1', 'degraded')
 589
 590     def test_bridge(self):
 591         copy_unit_to_networkd_unit_path('25-bridge.netdev', '25-bridge-configure-without-carrier.network')
 592         start_networkd(0)
 593
 594         wait_online(['bridge99:no-carrier'])
 595
 596         tick = os.sysconf('SC_CLK_TCK')
 597         self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge', 'hello_time')) / tick))
 598         self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge', 'max_age')) / tick))
 599         self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge','forward_delay')) / tick))
 600         self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge','ageing_time')) / tick))
 601         self.assertEqual(9,         int(read_link_attr('bridge99', 'bridge','priority')))
 602         self.assertEqual(1,         int(read_link_attr('bridge99', 'bridge','multicast_querier')))
 603         self.assertEqual(1,         int(read_link_attr('bridge99', 'bridge','multicast_snooping')))
 604         self.assertEqual(1,         int(read_link_attr('bridge99', 'bridge','stp_state')))
 605
 606     def test_bond(self):
 607         copy_unit_to_networkd_unit_path('25-bond.netdev', '25-bond-balanced-tlb.netdev')
 608         start_networkd(0)
 609
 610         wait_online(['bond99:off', 'bond98:off'])
 611
 612         self.assertEqual('802.3ad 4',         read_link_attr('bond99', 'bonding', 'mode'))
 613         self.assertEqual('layer3+4 1',        read_link_attr('bond99', 'bonding', 'xmit_hash_policy'))
 614         self.assertEqual('1000',              read_link_attr('bond99', 'bonding', 'miimon'))
 615         self.assertEqual('fast 1',            read_link_attr('bond99', 'bonding', 'lacp_rate'))
 616         self.assertEqual('2000',              read_link_attr('bond99', 'bonding', 'updelay'))
 617         self.assertEqual('2000',              read_link_attr('bond99', 'bonding', 'downdelay'))
 618         self.assertEqual('4',                 read_link_attr('bond99', 'bonding', 'resend_igmp'))
 619         self.assertEqual('1',                 read_link_attr('bond99', 'bonding', 'min_links'))
 620         self.assertEqual('1218',              read_link_attr('bond99', 'bonding', 'ad_actor_sys_prio'))
 621         self.assertEqual('811',               read_link_attr('bond99', 'bonding', 'ad_user_port_key'))
 622         self.assertEqual('00:11:22:33:44:55', read_link_attr('bond99', 'bonding', 'ad_actor_system'))
 623
 624         self.assertEqual('balance-tlb 5',     read_link_attr('bond98', 'bonding', 'mode'))
 625         self.assertEqual('1',                 read_link_attr('bond98', 'bonding', 'tlb_dynamic_lb'))
 626
 627     def test_vlan(self):
 628         copy_unit_to_networkd_unit_path('21-vlan.netdev', '11-dummy.netdev',
 629                                         '21-vlan.network', '21-vlan-test1.network')
 630         start_networkd(0)
 631
 632         wait_online(['test1:degraded', 'vlan99:routable'])
 633
 634         output = check_output('ip -d link show test1')
 635         print(output)
 636         self.assertRegex(output, ' mtu 2000 ')
 637
 638         output = check_output('ip -d link show vlan99')
 639         print(output)
 640         self.assertRegex(output, ' mtu 2000 ')
 641         self.assertRegex(output, 'REORDER_HDR')
 642         self.assertRegex(output, 'LOOSE_BINDING')
 643         self.assertRegex(output, 'GVRP')
 644         self.assertRegex(output, 'MVRP')
 645         self.assertRegex(output, ' id 99 ')
 646
 647         output = check_output('ip -4 address show dev test1')
 648         print(output)
 649         self.assertRegex(output, 'inet 192.168.24.5/24 brd 192.168.24.255 scope global test1')
 650         self.assertRegex(output, 'inet 192.168.25.5/24 brd 192.168.25.255 scope global test1')
 651
 652         output = check_output('ip -4 address show dev vlan99')
 653         print(output)
 654         self.assertRegex(output, 'inet 192.168.23.5/24 brd 192.168.23.255 scope global vlan99')
 655
 656     def test_macvtap(self):
 657         for mode in ['private', 'vepa', 'bridge', 'passthru']:
 658             with self.subTest(mode=mode):
 659                 if mode != 'private':
 660                     self.tearDown()
 661                 copy_unit_to_networkd_unit_path('21-macvtap.netdev', 'netdev-link-local-addressing-yes.network',
 662                                                 '11-dummy.netdev', 'macvtap.network')
 663                 with open(os.path.join(network_unit_file_path, '21-macvtap.netdev'), mode='a') as f:
 664                     f.write('[MACVTAP]\nMode=' + mode)
 665                 start_networkd(0)
 666
 667                 wait_online(['macvtap99:degraded', 'test1:degraded'])
 668
 669                 output = check_output('ip -d link show macvtap99')
 670                 print(output)
 671                 self.assertRegex(output, 'macvtap mode ' + mode + ' ')
 672
 673     def test_macvlan(self):
 674         for mode in ['private', 'vepa', 'bridge', 'passthru']:
 675             with self.subTest(mode=mode):
 676                 if mode != 'private':
 677                     self.tearDown()
 678                 copy_unit_to_networkd_unit_path('21-macvlan.netdev', 'netdev-link-local-addressing-yes.network',
 679                                                 '11-dummy.netdev', 'macvlan.network')
 680                 with open(os.path.join(network_unit_file_path, '21-macvlan.netdev'), mode='a') as f:
 681                     f.write('[MACVLAN]\nMode=' + mode)
 682                 start_networkd(0)
 683
 684                 wait_online(['macvlan99:degraded', 'test1:degraded'])
 685
 686                 output = check_output('ip -d link show test1')
 687                 print(output)
 688                 self.assertRegex(output, ' mtu 2000 ')
 689
 690                 output = check_output('ip -d link show macvlan99')
 691                 print(output)
 692                 self.assertRegex(output, ' mtu 2000 ')
 693                 self.assertRegex(output, 'macvlan mode ' + mode + ' ')
 694
 695     @expectedFailureIfModuleIsNotAvailable('ipvlan')
 696     def test_ipvlan(self):
 697         for mode, flag in [['L2', 'private'], ['L3', 'vepa'], ['L3S', 'bridge']]:
 698             with self.subTest(mode=mode, flag=flag):
 699                 if mode != 'L2':
 700                     self.tearDown()
 701                 copy_unit_to_networkd_unit_path('25-ipvlan.netdev', 'netdev-link-local-addressing-yes.network',
 702                                                 '11-dummy.netdev', 'ipvlan.network')
 703                 with open(os.path.join(network_unit_file_path, '25-ipvlan.netdev'), mode='a') as f:
 704                     f.write('[IPVLAN]\nMode=' + mode + '\nFlags=' + flag)
 705
 706                 start_networkd(0)
 707                 wait_online(['ipvlan99:degraded', 'test1:degraded'])
 708
 709                 output = check_output('ip -d link show ipvlan99')
 710                 print(output)
 711                 self.assertRegex(output, 'ipvlan  *mode ' + mode.lower() + ' ' + flag)
 712
 713     @expectedFailureIfModuleIsNotAvailable('ipvtap')
 714     def test_ipvtap(self):
 715         for mode, flag in [['L2', 'private'], ['L3', 'vepa'], ['L3S', 'bridge']]:
 716             with self.subTest(mode=mode, flag=flag):
 717                 if mode != 'L2':
 718                     self.tearDown()
 719                 copy_unit_to_networkd_unit_path('25-ipvtap.netdev', 'netdev-link-local-addressing-yes.network',
 720                                                 '11-dummy.netdev', 'ipvtap.network')
 721                 with open(os.path.join(network_unit_file_path, '25-ipvtap.netdev'), mode='a') as f:
 722                     f.write('[IPVTAP]\nMode=' + mode + '\nFlags=' + flag)
 723
 724                 start_networkd(0)
 725                 wait_online(['ipvtap99:degraded', 'test1:degraded'])
 726
 727                 output = check_output('ip -d link show ipvtap99')
 728                 print(output)
 729                 self.assertRegex(output, 'ipvtap  *mode ' + mode.lower() + ' ' + flag)
 730
 731     def test_veth(self):
 732         copy_unit_to_networkd_unit_path('25-veth.netdev', 'netdev-link-local-addressing-yes.network')
 733         start_networkd(0)
 734
 735         wait_online(['veth99:degraded', 'veth-peer:degraded'])
 736
 737         output = check_output('ip -d link show veth99')
 738         print(output)
 739         self.assertRegex(output, 'link/ether 12:34:56:78:9a:bc')
 740         output = check_output('ip -d link show veth-peer')
 741         print(output)
 742         self.assertRegex(output, 'link/ether 12:34:56:78:9a:bd')
 743
 744     def test_tun(self):
 745         copy_unit_to_networkd_unit_path('25-tun.netdev')
 746         start_networkd(0)
 747
 748         wait_online(['tun99:off'])
 749
 750         output = check_output('ip -d link show tun99')
 751         print(output)
 752         # Old ip command does not support IFF_ flags
 753         self.assertRegex(output, 'tun (?:type tun pi on vnet_hdr on multi_queue|addrgenmode) ')
 754
 755     def test_tap(self):
 756         copy_unit_to_networkd_unit_path('25-tap.netdev')
 757         start_networkd(0)
 758
 759         wait_online(['tap99:off'])
 760
 761         output = check_output('ip -d link show tap99')
 762         print(output)
 763         # Old ip command does not support IFF_ flags
 764         self.assertRegex(output, 'tun (?:type tap pi on vnet_hdr on multi_queue|addrgenmode) ')
 765
 766     @expectedFailureIfModuleIsNotAvailable('vrf')
 767     def test_vrf(self):
 768         copy_unit_to_networkd_unit_path('25-vrf.netdev', 'netdev-link-local-addressing-yes.network')
 769         start_networkd(0)
 770
 771         wait_online(['vrf99:carrier'])
 772
 773     @expectedFailureIfModuleIsNotAvailable('vcan')
 774     def test_vcan(self):
 775         copy_unit_to_networkd_unit_path('25-vcan.netdev', 'netdev-link-local-addressing-yes.network')
 776         start_networkd(0)
 777
 778         wait_online(['vcan99:carrier'])
 779
 780     @expectedFailureIfModuleIsNotAvailable('vxcan')
 781     def test_vxcan(self):
 782         copy_unit_to_networkd_unit_path('25-vxcan.netdev', 'netdev-link-local-addressing-yes.network')
 783         start_networkd(0)
 784
 785         wait_online(['vxcan99:carrier', 'vxcan-peer:carrier'])
 786
 787     @expectedFailureIfModuleIsNotAvailable('wireguard')
 788     def test_wireguard(self):
 789         copy_unit_to_networkd_unit_path('25-wireguard.netdev', '25-wireguard.network',
 790                                         '25-wireguard-23-peers.netdev', '25-wireguard-23-peers.network',
 791                                         '25-wireguard-preshared-key.txt', '25-wireguard-private-key.txt')
 792         start_networkd(0)
 793         wait_online(['wg99:carrier', 'wg98:routable'])
 794
 795         if shutil.which('wg'):
 796             call('wg')
 797
 798             output = check_output('wg show wg99 listen-port')
 799             self.assertRegex(output, '51820')
 800             output = check_output('wg show wg99 fwmark')
 801             self.assertRegex(output, '0x4d2')
 802             output = check_output('wg show wg99 allowed-ips')
 803             self.assertRegex(output, r'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t192.168.26.0/24 fd31:bf08:57cb::/48')
 804             self.assertRegex(output, r'lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=\tfdbc:bae2:7871:e1fe:793:8636::/96 fdbc:bae2:7871:500:e1fe:793:8636:dad1/128')
 805             output = check_output('wg show wg99 persistent-keepalive')
 806             self.assertRegex(output, r'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t20')
 807             output = check_output('wg show wg99 endpoints')
 808             self.assertRegex(output, r'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t192.168.27.3:51820')
 809             output = check_output('wg show wg99 private-key')
 810             self.assertRegex(output, r'EEGlnEPYJV//kbvvIqxKkQwOiS\+UENyPncC4bF46ong=')
 811             output = check_output('wg show wg99 preshared-keys')
 812             self.assertRegex(output, r'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=  IIWIV17wutHv7t4cR6pOT91z6NSz/T8Arh0yaywhw3M=')
 813             self.assertRegex(output, r'lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=     cPLOy1YUrEI0EMMIycPJmOo0aTu3RZnw8bL5meVD6m0=')
 814
 815             output = check_output('wg show wg98 private-key')
 816             self.assertRegex(output, r'CJQUtcS9emY2fLYqDlpSZiE/QJyHkPWr\+WHtZLZ90FU=')
 817
 818     def test_geneve(self):
 819         copy_unit_to_networkd_unit_path('25-geneve.netdev', 'netdev-link-local-addressing-yes.network')
 820         start_networkd(0)
 821
 822         wait_online(['geneve99:degraded'])
 823
 824         output = check_output('ip -d link show geneve99')
 825         print(output)
 826         self.assertRegex(output, '192.168.22.1')
 827         self.assertRegex(output, '6082')
 828         self.assertRegex(output, 'udpcsum')
 829         self.assertRegex(output, 'udp6zerocsumrx')
 830
 831     def test_ipip_tunnel(self):
 832         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ipip.network',
 833                                         '25-ipip-tunnel.netdev', '25-tunnel.network',
 834                                         '25-ipip-tunnel-local-any.netdev', '25-tunnel-local-any.network',
 835                                         '25-ipip-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
 836         start_networkd(0)
 837         wait_online(['ipiptun99:routable', 'ipiptun98:routable', 'ipiptun97:routable', 'dummy98:degraded'])
 838
 839         output = check_output('ip -d link show ipiptun99')
 840         print(output)
 841         self.assertRegex(output, 'ipip (?:ipip |)remote 192.169.224.239 local 192.168.223.238 dev dummy98')
 842         output = check_output('ip -d link show ipiptun98')
 843         print(output)
 844         self.assertRegex(output, 'ipip (?:ipip |)remote 192.169.224.239 local any dev dummy98')
 845         output = check_output('ip -d link show ipiptun97')
 846         print(output)
 847         self.assertRegex(output, 'ipip (?:ipip |)remote any local 192.168.223.238 dev dummy98')
 848
 849     def test_gre_tunnel(self):
 850         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'gretun.network',
 851                                         '25-gre-tunnel.netdev', '25-tunnel.network',
 852                                         '25-gre-tunnel-local-any.netdev', '25-tunnel-local-any.network',
 853                                         '25-gre-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
 854         start_networkd(0)
 855         wait_online(['gretun99:routable', 'gretun98:routable', 'gretun97:routable', 'dummy98:degraded'])
 856
 857         output = check_output('ip -d link show gretun99')
 858         print(output)
 859         self.assertRegex(output, 'gre remote 10.65.223.239 local 10.65.223.238 dev dummy98')
 860         self.assertRegex(output, 'ikey 1.2.3.103')
 861         self.assertRegex(output, 'okey 1.2.4.103')
 862         self.assertRegex(output, 'iseq')
 863         self.assertRegex(output, 'oseq')
 864         output = check_output('ip -d link show gretun98')
 865         print(output)
 866         self.assertRegex(output, 'gre remote 10.65.223.239 local any dev dummy98')
 867         self.assertRegex(output, 'ikey 0.0.0.104')
 868         self.assertRegex(output, 'okey 0.0.0.104')
 869         self.assertNotRegex(output, 'iseq')
 870         self.assertNotRegex(output, 'oseq')
 871         output = check_output('ip -d link show gretun97')
 872         print(output)
 873         self.assertRegex(output, 'gre remote any local 10.65.223.238 dev dummy98')
 874         self.assertRegex(output, 'ikey 0.0.0.105')
 875         self.assertRegex(output, 'okey 0.0.0.105')
 876         self.assertNotRegex(output, 'iseq')
 877         self.assertNotRegex(output, 'oseq')
 878
 879     def test_ip6gre_tunnel(self):
 880         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ip6gretun.network',
 881                                         '25-ip6gre-tunnel.netdev', '25-tunnel.network',
 882                                         '25-ip6gre-tunnel-local-any.netdev', '25-tunnel-local-any.network',
 883                                         '25-ip6gre-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
 884         start_networkd(5)
 885
 886         # Old kernels seem not to support IPv6LL address on ip6gre tunnel, So please do not use wait_online() here.
 887
 888         self.check_link_exists('dummy98')
 889         self.check_link_exists('ip6gretun99')
 890         self.check_link_exists('ip6gretun98')
 891         self.check_link_exists('ip6gretun97')
 892
 893         output = check_output('ip -d link show ip6gretun99')
 894         print(output)
 895         self.assertRegex(output, 'ip6gre remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
 896         output = check_output('ip -d link show ip6gretun98')
 897         print(output)
 898         self.assertRegex(output, 'ip6gre remote 2001:473:fece:cafe::5179 local any dev dummy98')
 899         output = check_output('ip -d link show ip6gretun97')
 900         print(output)
 901         self.assertRegex(output, 'ip6gre remote any local 2a00:ffde:4567:edde::4987 dev dummy98')
 902
 903     def test_gretap_tunnel(self):
 904         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'gretap.network',
 905                                         '25-gretap-tunnel.netdev', '25-tunnel.network',
 906                                         '25-gretap-tunnel-local-any.netdev', '25-tunnel-local-any.network')
 907         start_networkd(0)
 908         wait_online(['gretap99:routable', 'gretap98:routable', 'dummy98:degraded'])
 909
 910         output = check_output('ip -d link show gretap99')
 911         print(output)
 912         self.assertRegex(output, 'gretap remote 10.65.223.239 local 10.65.223.238 dev dummy98')
 913         self.assertRegex(output, 'ikey 0.0.0.106')
 914         self.assertRegex(output, 'okey 0.0.0.106')
 915         self.assertRegex(output, 'iseq')
 916         self.assertRegex(output, 'oseq')
 917         output = check_output('ip -d link show gretap98')
 918         print(output)
 919         self.assertRegex(output, 'gretap remote 10.65.223.239 local any dev dummy98')
 920         self.assertRegex(output, 'ikey 0.0.0.107')
 921         self.assertRegex(output, 'okey 0.0.0.107')
 922         self.assertRegex(output, 'iseq')
 923         self.assertRegex(output, 'oseq')
 924
 925     def test_ip6gretap_tunnel(self):
 926         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ip6gretap.network',
 927                                         '25-ip6gretap-tunnel.netdev', '25-tunnel.network',
 928                                         '25-ip6gretap-tunnel-local-any.netdev', '25-tunnel-local-any.network')
 929         start_networkd(0)
 930         wait_online(['ip6gretap99:routable', 'ip6gretap98:routable', 'dummy98:degraded'])
 931
 932         output = check_output('ip -d link show ip6gretap99')
 933         print(output)
 934         self.assertRegex(output, 'ip6gretap remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
 935         output = check_output('ip -d link show ip6gretap98')
 936         print(output)
 937         self.assertRegex(output, 'ip6gretap remote 2001:473:fece:cafe::5179 local any dev dummy98')
 938
 939     def test_vti_tunnel(self):
 940         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'vti.network',
 941                                         '25-vti-tunnel.netdev', '25-tunnel.network',
 942                                         '25-vti-tunnel-local-any.netdev', '25-tunnel-local-any.network',
 943                                         '25-vti-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
 944         start_networkd(0)
 945         wait_online(['vtitun99:routable', 'vtitun98:routable', 'vtitun97:routable', 'dummy98:degraded'])
 946
 947         output = check_output('ip -d link show vtitun99')
 948         print(output)
 949         self.assertRegex(output, 'vti remote 10.65.223.239 local 10.65.223.238 dev dummy98')
 950         output = check_output('ip -d link show vtitun98')
 951         print(output)
 952         self.assertRegex(output, 'vti remote 10.65.223.239 local any dev dummy98')
 953         output = check_output('ip -d link show vtitun97')
 954         print(output)
 955         self.assertRegex(output, 'vti remote any local 10.65.223.238 dev dummy98')
 956
 957     def test_vti6_tunnel(self):
 958         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'vti6.network',
 959                                         '25-vti6-tunnel.netdev', '25-tunnel.network',
 960                                         '25-vti6-tunnel-local-any.netdev', '25-tunnel-local-any.network',
 961                                         '25-vti6-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
 962         start_networkd(0)
 963         wait_online(['vti6tun99:routable', 'vti6tun98:routable', 'vti6tun97:routable', 'dummy98:degraded'])
 964
 965         output = check_output('ip -d link show vti6tun99')
 966         print(output)
 967         self.assertRegex(output, 'vti6 remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
 968         output = check_output('ip -d link show vti6tun98')
 969         print(output)
 970         self.assertRegex(output, 'vti6 remote 2001:473:fece:cafe::5179 local (?:any|::) dev dummy98')
 971         output = check_output('ip -d link show vti6tun97')
 972         print(output)
 973         self.assertRegex(output, 'vti6 remote (?:any|::) local 2a00:ffde:4567:edde::4987 dev dummy98')
 974
 975     def test_ip6tnl_tunnel(self):
 976         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'ip6tnl.network',
 977                                         '25-ip6tnl-tunnel.netdev', '25-tunnel.network',
 978                                         '25-ip6tnl-tunnel-local-any.netdev', '25-tunnel-local-any.network',
 979                                         '25-ip6tnl-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
 980         start_networkd(0)
 981         wait_online(['ip6tnl99:routable', 'ip6tnl98:routable', 'ip6tnl97:routable', 'dummy98:degraded'])
 982
 983         output = check_output('ip -d link show ip6tnl99')
 984         print(output)
 985         self.assertRegex(output, 'ip6tnl ip6ip6 remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
 986         output = check_output('ip -d link show ip6tnl98')
 987         print(output)
 988         self.assertRegex(output, 'ip6tnl ip6ip6 remote 2001:473:fece:cafe::5179 local (?:any|::) dev dummy98')
 989         output = check_output('ip -d link show ip6tnl97')
 990         print(output)
 991         self.assertRegex(output, 'ip6tnl ip6ip6 remote (?:any|::) local 2a00:ffde:4567:edde::4987 dev dummy98')
 992
 993     def test_sit_tunnel(self):
 994         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'sit.network',
 995                                         '25-sit-tunnel.netdev', '25-tunnel.network',
 996                                         '25-sit-tunnel-local-any.netdev', '25-tunnel-local-any.network',
 997                                         '25-sit-tunnel-remote-any.netdev', '25-tunnel-remote-any.network')
 998         start_networkd(0)
 999         wait_online(['sittun99:routable', 'sittun98:routable', 'sittun97:routable', 'dummy98:degraded'])
1000
1001         output = check_output('ip -d link show sittun99')
1002         print(output)
1003         self.assertRegex(output, "sit (?:ip6ip |)remote 10.65.223.239 local 10.65.223.238 dev dummy98")
1004         output = check_output('ip -d link show sittun98')
1005         print(output)
1006         self.assertRegex(output, "sit (?:ip6ip |)remote 10.65.223.239 local any dev dummy98")
1007         output = check_output('ip -d link show sittun97')
1008         print(output)
1009         self.assertRegex(output, "sit (?:ip6ip |)remote any local 10.65.223.238 dev dummy98")
1010
1011     def test_isatap_tunnel(self):
1012         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'isatap.network',
1013                                         '25-isatap-tunnel.netdev', '25-tunnel.network')
1014         start_networkd(0)
1015         wait_online(['isataptun99:routable', 'dummy98:degraded'])
1016
1017         output = check_output('ip -d link show isataptun99')
1018         print(output)
1019         self.assertRegex(output, "isatap ")
1020
1021     def test_6rd_tunnel(self):
1022         copy_unit_to_networkd_unit_path('12-dummy.netdev', '6rd.network',
1023                                         '25-6rd-tunnel.netdev', '25-tunnel.network')
1024         start_networkd(0)
1025         wait_online(['sittun99:routable', 'dummy98:degraded'])
1026
1027         output = check_output('ip -d link show sittun99')
1028         print(output)
1029         self.assertRegex(output, '6rd-prefix 2602::/24')
1030
1031     @expectedFailureIfERSPANModuleIsNotAvailable()
1032     def test_erspan_tunnel(self):
1033         copy_unit_to_networkd_unit_path('12-dummy.netdev', 'erspan.network',
1034                                         '25-erspan-tunnel.netdev', '25-tunnel.network',
1035                                         '25-erspan-tunnel-local-any.netdev', '25-tunnel-local-any.network')
1036         start_networkd(0)
1037         wait_online(['erspan99:routable', 'erspan98:routable', 'dummy98:degraded'])
1038
1039         output = check_output('ip -d link show erspan99')
1040         print(output)
1041         self.assertRegex(output, 'erspan remote 172.16.1.100 local 172.16.1.200')
1042         self.assertRegex(output, 'ikey 0.0.0.101')
1043         self.assertRegex(output, 'okey 0.0.0.101')
1044         self.assertRegex(output, 'iseq')
1045         self.assertRegex(output, 'oseq')
1046         output = check_output('ip -d link show erspan98')
1047         print(output)
1048         self.assertRegex(output, 'erspan remote 172.16.1.100 local any')
1049         self.assertRegex(output, '102')
1050         self.assertRegex(output, 'ikey 0.0.0.102')
1051         self.assertRegex(output, 'okey 0.0.0.102')
1052         self.assertRegex(output, 'iseq')
1053         self.assertRegex(output, 'oseq')
1054
1055     def test_tunnel_independent(self):
1056         copy_unit_to_networkd_unit_path('25-ipip-tunnel-independent.netdev', 'netdev-link-local-addressing-yes.network')
1057         start_networkd(0)
1058
1059         wait_online(['ipiptun99:carrier'])
1060
1061     @expectedFailureIfModuleIsNotAvailable('fou')
1062     def test_fou(self):
1063         # The following redundant check is necessary for CentOS CI.
1064         # Maybe, error handling in lookup_id() in sd-netlink/generic-netlink.c needs to be updated.
1065         self.assertTrue(is_module_available('fou'))
1066
1067         copy_unit_to_networkd_unit_path('25-fou-ipproto-ipip.netdev', '25-fou-ipproto-gre.netdev',
1068                                         '25-fou-ipip.netdev', '25-fou-sit.netdev',
1069                                         '25-fou-gre.netdev', '25-fou-gretap.netdev')
1070         start_networkd(0)
1071
1072         wait_online(['ipiptun96:off', 'sittun96:off', 'gretun96:off', 'gretap96:off'])
1073
1074         output = check_output('ip fou show')
1075         print(output)
1076         self.assertRegex(output, 'port 55555 ipproto 4')
1077         self.assertRegex(output, 'port 55556 ipproto 47')
1078
1079         output = check_output('ip -d link show ipiptun96')
1080         print(output)
1081         self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55555')
1082         output = check_output('ip -d link show sittun96')
1083         print(output)
1084         self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55555')
1085         output = check_output('ip -d link show gretun96')
1086         print(output)
1087         self.assertRegex(output, 'encap fou encap-sport 1001 encap-dport 55556')
1088         output = check_output('ip -d link show gretap96')
1089         print(output)
1090         self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55556')
1091
1092     def test_vxlan(self):
1093         copy_unit_to_networkd_unit_path('25-vxlan.netdev', 'vxlan.network',
1094                                         '11-dummy.netdev', 'vxlan-test1.network')
1095         start_networkd(0)
1096
1097         wait_online(['test1:degraded', 'vxlan99:degraded'])
1098
1099         output = check_output('ip -d link show vxlan99')
1100         print(output)
1101         self.assertRegex(output, '999')
1102         self.assertRegex(output, '5555')
1103         self.assertRegex(output, 'l2miss')
1104         self.assertRegex(output, 'l3miss')
1105         self.assertRegex(output, 'udpcsum')
1106         self.assertRegex(output, 'udp6zerocsumtx')
1107         self.assertRegex(output, 'udp6zerocsumrx')
1108         self.assertRegex(output, 'remcsumtx')
1109         self.assertRegex(output, 'remcsumrx')
1110         self.assertRegex(output, 'gbp')
1111
1112         output = check_output('bridge fdb show dev vxlan99')
1113         print(output)
1114         self.assertRegex(output, '00:11:22:33:44:55 dst 10.0.0.5 self permanent')
1115         self.assertRegex(output, '00:11:22:33:44:66 dst 10.0.0.6 self permanent')
1116         self.assertRegex(output, '00:11:22:33:44:77 dst 10.0.0.7 self permanent')
1117
1118     def test_macsec(self):
1119         copy_unit_to_networkd_unit_path('25-macsec.netdev', '25-macsec.network', '25-macsec.key',
1120                                         'macsec.network', '12-dummy.netdev')
1121         start_networkd(0)
1122
1123         wait_online(['dummy98:degraded', 'macsec99:routable'])
1124
1125         output = check_output('ip -d link show macsec99')
1126         print(output)
1127         self.assertRegex(output, 'macsec99@dummy98')
1128         self.assertRegex(output, 'macsec sci [0-9a-f]*000b')
1129         self.assertRegex(output, 'encrypt on')
1130
1131         output = check_output('ip macsec show macsec99')
1132         print(output)
1133         self.assertRegex(output, 'encrypt on')
1134         self.assertRegex(output, 'TXSC: [0-9a-f]*000b on SA 1')
1135         self.assertRegex(output, '0: PN [0-9]*, state on, key 01000000000000000000000000000000')
1136         self.assertRegex(output, '1: PN [0-9]*, state on, key 02030000000000000000000000000000')
1137         self.assertRegex(output, 'RXSC: c619528fe6a00100, state on')
1138         self.assertRegex(output, '0: PN [0-9]*, state on, key 02030405000000000000000000000000')
1139         self.assertRegex(output, '1: PN [0-9]*, state on, key 02030405060000000000000000000000')
1140         self.assertRegex(output, '2: PN [0-9]*, state off, key 02030405060700000000000000000000')
1141         self.assertRegex(output, '3: PN [0-9]*, state off, key 02030405060708000000000000000000')
1142         self.assertNotRegex(output, 'key 02030405067080900000000000000000')
1143         self.assertRegex(output, 'RXSC: 8c16456c83a90002, state on')
1144         self.assertRegex(output, '0: PN [0-9]*, state off, key 02030400000000000000000000000000')
1145
1146     def test_nlmon(self):
1147         copy_unit_to_networkd_unit_path('25-nlmon.netdev', 'netdev-link-local-addressing-yes.network')
1148         start_networkd(0)
1149
1150         wait_online(['nlmon99:carrier'])
1151
1152 class NetworkdL2TPTests(unittest.TestCase, Utilities):
1153
1154     links =[
1155         'l2tp-ses1',
1156         'l2tp-ses2',
1157         'l2tp-ses3',
1158         'l2tp-ses4',
1159         'test1']
1160
1161     units = [
1162         '11-dummy.netdev',
1163         '25-l2tp-dummy.network',
1164         '25-l2tp-ip.netdev',
1165         '25-l2tp-udp.netdev']
1166
1167     l2tp_tunnel_ids = [ '10' ]
1168
1169     def setUp(self):
1170         l2tp_tunnel_remove(self.l2tp_tunnel_ids)
1171         remove_links(self.links)
1172
1173     def tearDown(self):
1174         l2tp_tunnel_remove(self.l2tp_tunnel_ids)
1175         remove_links(self.links)
1176         remove_unit_from_networkd_path(self.units)
1177
1178     @expectedFailureIfModuleIsNotAvailable('l2tp_eth')
1179     def test_l2tp_udp(self):
1180         copy_unit_to_networkd_unit_path('11-dummy.netdev', '25-l2tp-dummy.network', '25-l2tp-udp.netdev')
1181         start_networkd(0)
1182
1183         wait_online(['test1:routable', 'l2tp-ses1:off', 'l2tp-ses2:off'])
1184
1185         output = check_output('ip l2tp show tunnel tunnel_id 10')
1186         print(output)
1187         self.assertRegex(output, "Tunnel 10, encap UDP")
1188         self.assertRegex(output, "From 192.168.30.100 to 192.168.30.101")
1189         self.assertRegex(output, "Peer tunnel 11")
1190         self.assertRegex(output, "UDP source / dest ports: 3000/4000")
1191         self.assertRegex(output, "UDP checksum: enabled")
1192
1193         output = check_output('ip l2tp show session tid 10 session_id 15')
1194         print(output)
1195         self.assertRegex(output, "Session 15 in tunnel 10")
1196         self.assertRegex(output, "Peer session 16, tunnel 11")
1197         self.assertRegex(output, "interface name: l2tp-ses1")
1198
1199         output = check_output('ip l2tp show session tid 10 session_id 17')
1200         print(output)
1201         self.assertRegex(output, "Session 17 in tunnel 10")
1202         self.assertRegex(output, "Peer session 18, tunnel 11")
1203         self.assertRegex(output, "interface name: l2tp-ses2")
1204
1205     @expectedFailureIfModuleIsNotAvailable('l2tp_ip')
1206     def test_l2tp_ip(self):
1207         copy_unit_to_networkd_unit_path('11-dummy.netdev', '25-l2tp-dummy.network', '25-l2tp-ip.netdev')
1208         start_networkd(0)
1209
1210         wait_online(['test1:routable', 'l2tp-ses3:off', 'l2tp-ses4:off'])
1211
1212         output = check_output('ip l2tp show tunnel tunnel_id 10')
1213         print(output)
1214         self.assertRegex(output, "Tunnel 10, encap IP")
1215         self.assertRegex(output, "From 192.168.30.100 to 192.168.30.101")
1216         self.assertRegex(output, "Peer tunnel 12")
1217
1218         output = check_output('ip l2tp show session tid 10 session_id 25')
1219         print(output)
1220         self.assertRegex(output, "Session 25 in tunnel 10")
1221         self.assertRegex(output, "Peer session 26, tunnel 12")
1222         self.assertRegex(output, "interface name: l2tp-ses3")
1223
1224         output = check_output('ip l2tp show session tid 10 session_id 27')
1225         print(output)
1226         self.assertRegex(output, "Session 27 in tunnel 10")
1227         self.assertRegex(output, "Peer session 28, tunnel 12")
1228         self.assertRegex(output, "interface name: l2tp-ses4")
1229
1230 class NetworkdNetworkTests(unittest.TestCase, Utilities):
1231     links = [
1232         'bond199',
1233         'dummy98',
1234         'dummy99',
1235         'test1']
1236
1237     units = [
1238         '11-dummy.netdev',
1239         '12-dummy.netdev',
1240         '23-active-slave.network',
1241         '24-keep-configuration-static.network',
1242         '24-search-domain.network',
1243         '25-address-link-section.network',
1244         '25-address-preferred-lifetime-zero-ipv6.network',
1245         '25-address-static.network',
1246         '25-bind-carrier.network',
1247         '25-bond-active-backup-slave.netdev',
1248         '25-fibrule-invert.network',
1249         '25-fibrule-port-range.network',
1250         '25-ipv6-address-label-section.network',
1251         '25-neighbor-section.network',
1252         '25-link-local-addressing-no.network',
1253         '25-link-local-addressing-yes.network',
1254         '25-link-section-unmanaged.network',
1255         '25-route-ipv6-src.network',
1256         '25-route-static.network',
1257         '25-sysctl-disable-ipv6.network',
1258         '25-sysctl.network',
1259         'configure-without-carrier.network',
1260         'routing-policy-rule-dummy98.network',
1261         'routing-policy-rule-test1.network']
1262
1263     routing_policy_rule_tables = ['7', '8']
1264     routes = [['blackhole', '202.54.1.2'], ['unreachable', '202.54.1.3'], ['prohibit', '202.54.1.4']]
1265
1266     def setUp(self):
1267         remove_routing_policy_rule_tables(self.routing_policy_rule_tables)
1268         remove_routes(self.routes)
1269         remove_links(self.links)
1270
1271     def tearDown(self):
1272         remove_routing_policy_rule_tables(self.routing_policy_rule_tables)
1273         remove_routes(self.routes)
1274         remove_links(self.links)
1275         remove_unit_from_networkd_path(self.units)
1276
1277     def test_address_static(self):
1278         copy_unit_to_networkd_unit_path('25-address-static.network', '12-dummy.netdev')
1279         start_networkd(0)
1280
1281         wait_online(['dummy98:routable'])
1282
1283         output = check_output('ip -4 address show dev dummy98')
1284         print(output)
1285         self.assertRegex(output, 'inet 10.1.2.3/16 brd 10.1.255.255 scope global dummy98')
1286         self.assertRegex(output, 'inet 10.1.2.4/16 brd 10.1.255.255 scope global secondary dummy98')
1287         self.assertRegex(output, 'inet 10.2.2.4/16 brd 10.2.255.255 scope global dummy98')
1288
1289         # invalid sections
1290         self.assertNotRegex(output, '10.10.0.1/16')
1291         self.assertNotRegex(output, '10.10.0.2/16')
1292
1293         output = check_output('ip -4 address show dev dummy98 label 32')
1294         self.assertRegex(output, 'inet 10.3.2.3/16 brd 10.3.255.255 scope global 32')
1295
1296         output = check_output('ip -4 address show dev dummy98 label 33')
1297         self.assertRegex(output, 'inet 10.4.2.3 peer 10.4.2.4/16 scope global 33')
1298
1299         output = check_output('ip -4 address show dev dummy98 label 34')
1300         self.assertRegex(output, 'inet 192.168.[0-9]*.1/24 brd 192.168.[0-9]*.255 scope global 34')
1301
1302         output = check_output('ip -4 address show dev dummy98 label 35')
1303         self.assertRegex(output, 'inet 172.[0-9]*.0.1/16 brd 172.[0-9]*.255.255 scope global 35')
1304
1305         output = check_output('ip -6 address show dev dummy98')
1306         print(output)
1307         self.assertRegex(output, 'inet6 2001:db8:0:f101::15/64 scope global')
1308         self.assertRegex(output, 'inet6 2001:db8:0:f101::16/64 scope global')
1309         self.assertRegex(output, 'inet6 2001:db8:0:f102::15/64 scope global')
1310         self.assertRegex(output, 'inet6 2001:db8:0:f102::16/64 scope global')
1311         self.assertRegex(output, 'inet6 2001:db8:0:f103::20 peer 2001:db8:0:f103::10/128 scope global')
1312         self.assertRegex(output, 'inet6 fd[0-9a-f:]*1/64 scope global')
1313
1314     def test_address_preferred_lifetime_zero_ipv6(self):
1315         copy_unit_to_networkd_unit_path('25-address-preferred-lifetime-zero-ipv6.network', '12-dummy.netdev')
1316         start_networkd(5)
1317
1318         self.check_link_exists('dummy98')
1319         self.check_operstate('dummy98', 'routable', setup_state='configuring')
1320
1321         output = check_output('ip address show dummy98')
1322         print(output)
1323         self.assertRegex(output, 'inet 10.2.3.4/16 brd 10.2.255.255 scope link deprecated dummy98')
1324         self.assertRegex(output, 'inet6 2001:db8:0:f101::1/64 scope global')
1325
1326     def test_configure_without_carrier(self):
1327         copy_unit_to_networkd_unit_path('configure-without-carrier.network', '11-dummy.netdev')
1328         start_networkd(0)
1329         wait_online(['test1:routable'])
1330
1331         output = check_output(*networkctl_cmd, 'status', 'test1')
1332         print(output)
1333         self.assertRegex(output, '192.168.0.15')
1334         self.assertRegex(output, '192.168.0.1')
1335         self.assertRegex(output, 'routable')
1336
1337     def test_routing_policy_rule(self):
1338         copy_unit_to_networkd_unit_path('routing-policy-rule-test1.network', '11-dummy.netdev')
1339         start_networkd(0)
1340         wait_online(['test1:degraded'])
1341
1342         output = check_output('ip rule')
1343         print(output)
1344         self.assertRegex(output, '111')
1345         self.assertRegex(output, 'from 192.168.100.18')
1346         self.assertRegex(output, r'tos (?:0x08|throughput)\s')
1347         self.assertRegex(output, 'iif test1')
1348         self.assertRegex(output, 'oif test1')
1349         self.assertRegex(output, 'lookup 7')
1350
1351     def test_routing_policy_rule_issue_11280(self):
1352         copy_unit_to_networkd_unit_path('routing-policy-rule-test1.network', '11-dummy.netdev',
1353                                         'routing-policy-rule-dummy98.network', '12-dummy.netdev')
1354
1355         for trial in range(3):
1356             # Remove state files only first time
1357             start_networkd(0, remove_state_files=(trial == 0))
1358             wait_online(['test1:degraded', 'dummy98:degraded'])
1359             time.sleep(1)
1360
1361             output = check_output('ip rule list table 7')
1362             print(output)
1363             self.assertRegex(output, '111:      from 192.168.100.18 tos (?:0x08|throughput) iif test1 oif test1 lookup 7')
1364
1365             output = check_output('ip rule list table 8')
1366             print(output)
1367             self.assertRegex(output, '112:      from 192.168.101.18 tos (?:0x08|throughput) iif dummy98 oif dummy98 lookup 8')
1368
1369     @expectedFailureIfRoutingPolicyPortRangeIsNotAvailable()
1370     def test_routing_policy_rule_port_range(self):
1371         copy_unit_to_networkd_unit_path('25-fibrule-port-range.network', '11-dummy.netdev')
1372         start_networkd(0)
1373         wait_online(['test1:degraded'])
1374
1375         output = check_output('ip rule')
1376         print(output)
1377         self.assertRegex(output, '111')
1378         self.assertRegex(output, 'from 192.168.100.18')
1379         self.assertRegex(output, '1123-1150')
1380         self.assertRegex(output, '3224-3290')
1381         self.assertRegex(output, 'tcp')
1382         self.assertRegex(output, 'lookup 7')
1383
1384     @expectedFailureIfRoutingPolicyIPProtoIsNotAvailable()
1385     def test_routing_policy_rule_invert(self):
1386         copy_unit_to_networkd_unit_path('25-fibrule-invert.network', '11-dummy.netdev')
1387         start_networkd(0)
1388         wait_online(['test1:degraded'])
1389
1390         output = check_output('ip rule')
1391         print(output)
1392         self.assertRegex(output, '111')
1393         self.assertRegex(output, 'not.*?from.*?192.168.100.18')
1394         self.assertRegex(output, 'tcp')
1395         self.assertRegex(output, 'lookup 7')
1396
1397     def test_route_static(self):
1398         copy_unit_to_networkd_unit_path('25-route-static.network', '12-dummy.netdev')
1399         start_networkd(0)
1400         wait_online(['dummy98:routable'])
1401
1402         output = check_output('ip -6 route show dev dummy98')
1403         print(output)
1404         self.assertRegex(output, '2001:1234:5:8fff:ff:ff:ff:ff proto static')
1405         self.assertRegex(output, '2001:1234:5:8f63::1 proto kernel')
1406
1407         output = check_output('ip -6 route show dev dummy98 default')
1408         self.assertRegex(output, 'default via 2001:1234:5:8fff:ff:ff:ff:ff proto static metric 1024 pref medium')
1409
1410         output = check_output('ip -4 route show dev dummy98')
1411         print(output)
1412         self.assertRegex(output, '149.10.124.48/28 proto kernel scope link src 149.10.124.58')
1413         self.assertRegex(output, '149.10.124.64 proto static scope link')
1414         self.assertRegex(output, '169.254.0.0/16 proto static scope link metric 2048')
1415         self.assertRegex(output, '192.168.1.1 proto static initcwnd 20')
1416         self.assertRegex(output, '192.168.1.2 proto static initrwnd 30')
1417
1418         output = check_output('ip -4 route show dev dummy98 default')
1419         self.assertRegex(output, 'default via 149.10.125.65 proto static onlink')
1420         self.assertRegex(output, 'default via 149.10.124.64 proto static')
1421         self.assertRegex(output, 'default proto static')
1422
1423         output = check_output('ip route show type blackhole')
1424         print(output)
1425         self.assertRegex(output, 'blackhole 202.54.1.2 proto static')
1426
1427         output = check_output('ip route show type unreachable')
1428         print(output)
1429         self.assertRegex(output, 'unreachable 202.54.1.3 proto static')
1430
1431         output = check_output('ip route show type prohibit')
1432         print(output)
1433         self.assertRegex(output, 'prohibit 202.54.1.4 proto static')
1434
1435     def test_ip_route_ipv6_src_route(self):
1436         # a dummy device does not make the addresses go through tentative state, so we
1437         # reuse a bond from an earlier test, which does make the addresses go through
1438         # tentative state, and do our test on that
1439         copy_unit_to_networkd_unit_path('23-active-slave.network', '25-route-ipv6-src.network', '25-bond-active-backup-slave.netdev', '12-dummy.netdev')
1440         start_networkd(0)
1441         wait_online(['dummy98:enslaved', 'bond199:routable'])
1442
1443         output = check_output('ip -6 route list dev bond199')
1444         print(output)
1445         self.assertRegex(output, 'abcd::/16')
1446         self.assertRegex(output, 'src')
1447         self.assertRegex(output, '2001:1234:56:8f63::2')
1448
1449     def test_ip_link_mac_address(self):
1450         copy_unit_to_networkd_unit_path('25-address-link-section.network', '12-dummy.netdev')
1451         start_networkd(0)
1452         wait_online(['dummy98:degraded'])
1453
1454         output = check_output('ip link show dummy98')
1455         print(output)
1456         self.assertRegex(output, '00:01:02:aa:bb:cc')
1457
1458     def test_ip_link_unmanaged(self):
1459         copy_unit_to_networkd_unit_path('25-link-section-unmanaged.network', '12-dummy.netdev')
1460         start_networkd(5)
1461
1462         self.check_link_exists('dummy98')
1463
1464         self.check_operstate('dummy98', 'off', setup_state='unmanaged')
1465
1466     def test_ipv6_address_label(self):
1467         copy_unit_to_networkd_unit_path('25-ipv6-address-label-section.network', '12-dummy.netdev')
1468         start_networkd(0)
1469         wait_online(['dummy98:degraded'])
1470
1471         output = check_output('ip addrlabel list')
1472         print(output)
1473         self.assertRegex(output, '2004:da8:1::/64')
1474
1475     def test_ipv6_neighbor(self):
1476         copy_unit_to_networkd_unit_path('25-neighbor-section.network', '12-dummy.netdev')
1477         start_networkd(0)
1478         wait_online(['dummy98:degraded'], timeout='40s')
1479
1480         output = check_output('ip neigh list dev dummy98')
1481         print(output)
1482         self.assertRegex(output, '192.168.10.1.*00:00:5e:00:02:65.*PERMANENT')
1483         self.assertRegex(output, '2004:da8:1::1.*00:00:5e:00:02:66.*PERMANENT')
1484
1485     def test_link_local_addressing(self):
1486         copy_unit_to_networkd_unit_path('25-link-local-addressing-yes.network', '11-dummy.netdev',
1487                                         '25-link-local-addressing-no.network', '12-dummy.netdev')
1488         start_networkd(0)
1489         wait_online(['test1:degraded', 'dummy98:carrier'])
1490
1491         output = check_output('ip address show dev test1')
1492         print(output)
1493         self.assertRegex(output, 'inet .* scope link')
1494         self.assertRegex(output, 'inet6 .* scope link')
1495
1496         output = check_output('ip address show dev dummy98')
1497         print(output)
1498         self.assertNotRegex(output, 'inet6* .* scope link')
1499
1500         '''
1501         Documentation/networking/ip-sysctl.txt
1502
1503         addr_gen_mode - INTEGER
1504         Defines how link-local and autoconf addresses are generated.
1505
1506         0: generate address based on EUI64 (default)
1507         1: do no generate a link-local address, use EUI64 for addresses generated
1508            from autoconf
1509         2: generate stable privacy addresses, using the secret from
1510            stable_secret (RFC7217)
1511         3: generate stable privacy addresses, using a random secret if unset
1512         '''
1513
1514         test1_addr_gen_mode = ''
1515         if os.path.exists(os.path.join(os.path.join(network_sysctl_ipv6_path, 'test1'), 'stable_secret')):
1516             with open(os.path.join(os.path.join(network_sysctl_ipv6_path, 'test1'), 'stable_secret')) as f:
1517                 try:
1518                     f.readline()
1519                 except IOError:
1520                     # if stable_secret is unset, then EIO is returned
1521                     test1_addr_gen_mode = '0'
1522                 else:
1523                     test1_addr_gen_mode = '2'
1524         else:
1525             test1_addr_gen_mode = '0'
1526
1527         if os.path.exists(os.path.join(os.path.join(network_sysctl_ipv6_path, 'test1'), 'addr_gen_mode')):
1528             self.assertEqual(read_ipv6_sysctl_attr('test1', 'addr_gen_mode'), test1_addr_gen_mode)
1529
1530         if os.path.exists(os.path.join(os.path.join(network_sysctl_ipv6_path, 'dummy98'), 'addr_gen_mode')):
1531             self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'addr_gen_mode'), '1')
1532
1533     def test_sysctl(self):
1534         copy_unit_to_networkd_unit_path('25-sysctl.network', '12-dummy.netdev')
1535         start_networkd(0)
1536         wait_online(['dummy98:degraded'])
1537
1538         self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'forwarding'), '1')
1539         self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'use_tempaddr'), '2')
1540         self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'dad_transmits'), '3')
1541         self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'hop_limit'), '5')
1542         self.assertEqual(read_ipv6_sysctl_attr('dummy98', 'proxy_ndp'), '1')
1543         self.assertEqual(read_ipv4_sysctl_attr('dummy98', 'forwarding'),'1')
1544         self.assertEqual(read_ipv4_sysctl_attr('dummy98', 'proxy_arp'), '1')
1545
1546     def test_sysctl_disable_ipv6(self):
1547         copy_unit_to_networkd_unit_path('25-sysctl-disable-ipv6.network', '12-dummy.netdev')
1548
1549         print('## Disable ipv6')
1550         check_output('sysctl net.ipv6.conf.all.disable_ipv6=1')
1551         check_output('sysctl net.ipv6.conf.default.disable_ipv6=1')
1552
1553         start_networkd(0)
1554         wait_online(['dummy98:routable'])
1555
1556         output = check_output('ip -4 address show dummy98')
1557         print(output)
1558         self.assertRegex(output, 'inet 10.2.3.4/16 brd 10.2.255.255 scope global dummy98')
1559         output = check_output('ip -6 address show dummy98')
1560         print(output)
1561         self.assertEqual(output, '')
1562         output = check_output('ip -4 route show dev dummy98')
1563         print(output)
1564         self.assertEqual(output, '10.2.0.0/16 proto kernel scope link src 10.2.3.4')
1565         output = check_output('ip -6 route show dev dummy98')
1566         print(output)
1567         self.assertEqual(output, '')
1568
1569         check_output('ip link del dummy98')
1570
1571         print('## Enable ipv6')
1572         check_output('sysctl net.ipv6.conf.all.disable_ipv6=0')
1573         check_output('sysctl net.ipv6.conf.default.disable_ipv6=0')
1574
1575         start_networkd(0)
1576         wait_online(['dummy98:routable'])
1577
1578         output = check_output('ip -4 address show dummy98')
1579         print(output)
1580         self.assertRegex(output, 'inet 10.2.3.4/16 brd 10.2.255.255 scope global dummy98')
1581         output = check_output('ip -6 address show dummy98')
1582         print(output)
1583         self.assertRegex(output, 'inet6 2607:5300:203:3906::/64 scope global')
1584         self.assertRegex(output, 'inet6 .* scope link')
1585         output = check_output('ip -4 route show dev dummy98')
1586         print(output)
1587         self.assertEqual(output, '10.2.0.0/16 proto kernel scope link src 10.2.3.4')
1588         output = check_output('ip -6 route show dev dummy98')
1589         print(output)
1590         self.assertRegex(output, 'default via 2607:5300:203:39ff:ff:ff:ff:ff proto static')
1591
1592     def test_bind_carrier(self):
1593         copy_unit_to_networkd_unit_path('25-bind-carrier.network', '11-dummy.netdev')
1594         start_networkd(0)
1595         wait_online(['test1:routable'])
1596
1597         check_output('ip link add dummy98 type dummy')
1598         check_output('ip link set dummy98 up')
1599         time.sleep(2)
1600         output = check_output('ip address show test1')
1601         print(output)
1602         self.assertRegex(output, 'UP,LOWER_UP')
1603         self.assertRegex(output, 'inet 192.168.10.30/24 brd 192.168.10.255 scope global test1')
1604         self.check_operstate('test1', 'routable')
1605
1606         check_output('ip link add dummy99 type dummy')
1607         check_output('ip link set dummy99 up')
1608         time.sleep(2)
1609         output = check_output('ip address show test1')
1610         print(output)
1611         self.assertRegex(output, 'UP,LOWER_UP')
1612         self.assertRegex(output, 'inet 192.168.10.30/24 brd 192.168.10.255 scope global test1')
1613         self.check_operstate('test1', 'routable')
1614
1615         check_output('ip link del dummy98')
1616         time.sleep(2)
1617         output = check_output('ip address show test1')
1618         print(output)
1619         self.assertRegex(output, 'UP,LOWER_UP')
1620         self.assertRegex(output, 'inet 192.168.10.30/24 brd 192.168.10.255 scope global test1')
1621         self.check_operstate('test1', 'routable')
1622
1623         check_output('ip link del dummy99')
1624         time.sleep(2)
1625         output = check_output('ip address show test1')
1626         print(output)
1627         self.assertNotRegex(output, 'UP,LOWER_UP')
1628         self.assertRegex(output, 'DOWN')
1629         self.assertNotRegex(output, '192.168.10')
1630         self.check_operstate('test1', 'off')
1631
1632         check_output('ip link add dummy98 type dummy')
1633         check_output('ip link set dummy98 up')
1634         time.sleep(2)
1635         output = check_output('ip address show test1')
1636         print(output)
1637         self.assertRegex(output, 'UP,LOWER_UP')
1638         self.assertRegex(output, 'inet 192.168.10.30/24 brd 192.168.10.255 scope global test1')
1639         self.check_operstate('test1', 'routable')
1640
1641     def test_domain(self):
1642         copy_unit_to_networkd_unit_path('12-dummy.netdev', '24-search-domain.network')
1643         start_networkd(0)
1644         wait_online(['dummy98:routable'])
1645
1646         output = check_output(*networkctl_cmd, 'status', 'dummy98', env=env)
1647         print(output)
1648         self.assertRegex(output, 'Address: 192.168.42.100')
1649         self.assertRegex(output, 'DNS: 192.168.42.1')
1650         self.assertRegex(output, 'Search Domains: one')
1651
1652     def test_keep_configuration_static(self):
1653         check_output('systemctl stop systemd-networkd')
1654
1655         check_output('ip link add name dummy98 type dummy')
1656         check_output('ip address add 10.1.2.3/16 dev dummy98')
1657         check_output('ip address add 10.2.3.4/16 dev dummy98 valid_lft 600 preferred_lft 500')
1658         output = check_output('ip address show dummy98')
1659         print(output)
1660         self.assertRegex(output, 'inet 10.1.2.3/16 scope global dummy98')
1661         self.assertRegex(output, 'inet 10.2.3.4/16 scope global dynamic dummy98')
1662         output = check_output('ip route show dev dummy98')
1663         print(output)
1664
1665         copy_unit_to_networkd_unit_path('24-keep-configuration-static.network')
1666         start_networkd(0)
1667         wait_online(['dummy98:routable'])
1668
1669         output = check_output('ip address show dummy98')
1670         print(output)
1671         self.assertRegex(output, 'inet 10.1.2.3/16 scope global dummy98')
1672         self.assertNotRegex(output, 'inet 10.2.3.4/16 scope global dynamic dummy98')
1673
1674 class NetworkdBondTests(unittest.TestCase, Utilities):
1675     links = [
1676         'bond199',
1677         'bond99',
1678         'dummy98',
1679         'test1']
1680
1681     units = [
1682         '11-dummy.netdev',
1683         '12-dummy.netdev',
1684         '23-active-slave.network',
1685         '23-bond199.network',
1686         '23-primary-slave.network',
1687         '23-test1-bond199.network',
1688         '25-bond-active-backup-slave.netdev',
1689         '25-bond.netdev',
1690         'bond99.network',
1691         'bond-slave.network']
1692
1693     def setUp(self):
1694         remove_links(self.links)
1695
1696     def tearDown(self):
1697         remove_links(self.links)
1698         remove_unit_from_networkd_path(self.units)
1699
1700     def test_bond_active_slave(self):
1701         copy_unit_to_networkd_unit_path('23-active-slave.network', '23-bond199.network', '25-bond-active-backup-slave.netdev', '12-dummy.netdev')
1702         start_networkd()
1703
1704         self.check_link_exists('dummy98')
1705         self.check_link_exists('bond199')
1706
1707         output = check_output('ip -d link show bond199')
1708         print(output)
1709         self.assertRegex(output, 'active_slave dummy98')
1710
1711     def test_bond_primary_slave(self):
1712         copy_unit_to_networkd_unit_path('23-primary-slave.network', '23-test1-bond199.network', '25-bond-active-backup-slave.netdev', '11-dummy.netdev')
1713         start_networkd()
1714
1715         self.check_link_exists('test1')
1716         self.check_link_exists('bond199')
1717
1718         output = check_output('ip -d link show bond199')
1719         print(output)
1720         self.assertRegex(output, 'primary test1')
1721
1722     def test_bond_operstate(self):
1723         copy_unit_to_networkd_unit_path('25-bond.netdev', '11-dummy.netdev', '12-dummy.netdev',
1724                                         'bond99.network','bond-slave.network')
1725         start_networkd()
1726
1727         self.check_link_exists('bond99')
1728         self.check_link_exists('dummy98')
1729         self.check_link_exists('test1')
1730
1731         output = check_output('ip -d link show dummy98')
1732         print(output)
1733         self.assertRegex(output, 'SLAVE,UP,LOWER_UP')
1734
1735         output = check_output('ip -d link show test1')
1736         print(output)
1737         self.assertRegex(output, 'SLAVE,UP,LOWER_UP')
1738
1739         output = check_output('ip -d link show bond99')
1740         print(output)
1741         self.assertRegex(output, 'MASTER,UP,LOWER_UP')
1742
1743         self.check_operstate('dummy98', 'enslaved')
1744         self.check_operstate('test1', 'enslaved')
1745         self.check_operstate('bond99', 'routable')
1746
1747         check_output('ip link set dummy98 down')
1748         time.sleep(2)
1749
1750         self.check_operstate('dummy98', 'off')
1751         self.check_operstate('test1', 'enslaved')
1752         self.check_operstate('bond99', 'degraded-carrier')
1753
1754         check_output('ip link set dummy98 up')
1755         time.sleep(2)
1756
1757         self.check_operstate('dummy98', 'enslaved')
1758         self.check_operstate('test1', 'enslaved')
1759         self.check_operstate('bond99', 'routable')
1760
1761         check_output('ip link set dummy98 down')
1762         check_output('ip link set test1 down')
1763         time.sleep(2)
1764
1765         self.check_operstate('dummy98', 'off')
1766         self.check_operstate('test1', 'off')
1767
1768         for trial in range(30):
1769             if trial > 0:
1770                 time.sleep(1)
1771             output = check_output('ip address show bond99')
1772             print(output)
1773             if get_operstate('bond99') == 'no-carrier':
1774                 break
1775         else:
1776             # Huh? Kernel does not recognize that all slave interfaces are down?
1777             # Let's confirm that networkd's operstate is consistent with ip's result.
1778             self.assertNotRegex(output, 'NO-CARRIER')
1779
1780 class NetworkdBridgeTests(unittest.TestCase, Utilities):
1781     links = [
1782         'bridge99',
1783         'dummy98',
1784         'test1']
1785
1786     units = [
1787         '11-dummy.netdev',
1788         '12-dummy.netdev',
1789         '26-bridge.netdev',
1790         '26-bridge-slave-interface-1.network',
1791         '26-bridge-slave-interface-2.network',
1792         'bridge99-ignore-carrier-loss.network',
1793         'bridge99.network']
1794
1795     def setUp(self):
1796         remove_links(self.links)
1797
1798     def tearDown(self):
1799         remove_links(self.links)
1800         remove_unit_from_networkd_path(self.units)
1801
1802     def test_bridge_property(self):
1803         copy_unit_to_networkd_unit_path('11-dummy.netdev', '12-dummy.netdev', '26-bridge.netdev',
1804                                         '26-bridge-slave-interface-1.network', '26-bridge-slave-interface-2.network',
1805                                         'bridge99.network')
1806         start_networkd()
1807
1808         self.check_link_exists('dummy98')
1809         self.check_link_exists('test1')
1810         self.check_link_exists('bridge99')
1811
1812         output = check_output('ip -d link show test1')
1813         print(output)
1814         self.assertRegex(output, 'master')
1815         self.assertRegex(output, 'bridge')
1816
1817         output = check_output('ip -d link show dummy98')
1818         print(output)
1819         self.assertRegex(output, 'master')
1820         self.assertRegex(output, 'bridge')
1821
1822         output = check_output('ip addr show bridge99')
1823         print(output)
1824         self.assertRegex(output, '192.168.0.15/24')
1825
1826         output = check_output('bridge -d link show dummy98')
1827         print(output)
1828         self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'hairpin_mode'), '1')
1829         self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'path_cost'), '400')
1830         self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'unicast_flood'), '1')
1831         self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'multicast_flood'), '0')
1832         self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'multicast_fast_leave'), '1')
1833         if (os.path.exists('/sys/devices/virtual/net/bridge99/lower_dummy98/brport/neigh_suppress')):
1834             self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'neigh_suppress'), '1')
1835         self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'learning'), '0')
1836
1837         # CONFIG_BRIDGE_IGMP_SNOOPING=y
1838         if (os.path.exists('/sys/devices/virtual/net/bridge00/lower_dummy98/brport/multicast_to_unicast')):
1839             self.assertEqual(read_bridge_port_attr('bridge99', 'dummy98', 'multicast_to_unicast'), '1')
1840
1841         self.check_operstate('test1', 'enslaved')
1842         self.check_operstate('dummy98', 'enslaved')
1843         self.check_operstate('bridge99', 'routable')
1844
1845         check_output('ip address add 192.168.0.16/24 dev bridge99')
1846         time.sleep(1)
1847
1848         output = check_output('ip addr show bridge99')
1849         print(output)
1850         self.assertRegex(output, '192.168.0.16/24')
1851
1852         self.check_operstate('bridge99', 'routable')
1853
1854         self.assertEqual(call('ip link del test1'), 0)
1855         time.sleep(3)
1856
1857         self.check_operstate('bridge99', 'degraded-carrier')
1858
1859         check_output('ip link del dummy98')
1860         time.sleep(3)
1861
1862         self.check_operstate('bridge99', 'no-carrier')
1863
1864         output = check_output('ip address show bridge99')
1865         print(output)
1866         self.assertRegex(output, 'NO-CARRIER')
1867         self.assertNotRegex(output, '192.168.0.15/24')
1868         self.assertNotRegex(output, '192.168.0.16/24')
1869
1870     def test_bridge_ignore_carrier_loss(self):
1871         copy_unit_to_networkd_unit_path('11-dummy.netdev', '12-dummy.netdev', '26-bridge.netdev',
1872                                         '26-bridge-slave-interface-1.network', '26-bridge-slave-interface-2.network',
1873                                         'bridge99-ignore-carrier-loss.network')
1874         call('ip rule del table 100')
1875
1876         start_networkd()
1877
1878         self.check_link_exists('dummy98')
1879         self.check_link_exists('test1')
1880         self.check_link_exists('bridge99')
1881
1882         check_output('ip address add 192.168.0.16/24 dev bridge99')
1883         time.sleep(1)
1884
1885         check_output('ip link del test1')
1886         check_output('ip link del dummy98')
1887         time.sleep(3)
1888
1889         output = check_output('ip address show bridge99')
1890         print(output)
1891         self.assertRegex(output, 'NO-CARRIER')
1892         self.assertRegex(output, 'inet 192.168.0.15/24 brd 192.168.0.255 scope global bridge99')
1893         self.assertRegex(output, 'inet 192.168.0.16/24 scope global secondary bridge99')
1894
1895         call('ip rule del table 100')
1896
1897     def test_bridge_ignore_carrier_loss_frequent_loss_and_gain(self):
1898         copy_unit_to_networkd_unit_path('26-bridge.netdev', '26-bridge-slave-interface-1.network',
1899                                         'bridge99-ignore-carrier-loss.network')
1900
1901         call('ip rule del table 100')
1902
1903         start_networkd()
1904
1905         self.check_link_exists('bridge99')
1906
1907         check_output('ip link add dummy98 type dummy')
1908         check_output('ip link set dummy98 up')
1909         check_output('ip link del dummy98')
1910
1911         check_output('ip link add dummy98 type dummy')
1912         check_output('ip link set dummy98 up')
1913         check_output('ip link del dummy98')
1914
1915         check_output('ip link add dummy98 type dummy')
1916         check_output('ip link set dummy98 up')
1917         check_output('ip link del dummy98')
1918
1919         check_output('ip link add dummy98 type dummy')
1920         check_output('ip link set dummy98 up')
1921
1922         for trial in range(30):
1923             if trial > 0:
1924                 time.sleep(1)
1925             if get_operstate('bridge99') == 'routable' and get_operstate('dummy98') == 'enslaved':
1926                 break
1927         else:
1928             self.assertTrue(False)
1929
1930         output = check_output('ip address show bridge99')
1931         print(output)
1932         self.assertRegex(output, 'inet 192.168.0.15/24 brd 192.168.0.255 scope global bridge99')
1933
1934         output = check_output('ip rule list table 100')
1935         print(output)
1936         self.assertEqual(output, '0:    from all to 8.8.8.8 lookup 100')
1937
1938         call('ip rule del table 100')
1939
1940 class NetworkdLLDPTests(unittest.TestCase, Utilities):
1941     links = ['veth99']
1942
1943     units = [
1944         '23-emit-lldp.network',
1945         '24-lldp.network',
1946         '25-veth.netdev']
1947
1948     def setUp(self):
1949         remove_links(self.links)
1950
1951     def tearDown(self):
1952         remove_links(self.links)
1953         remove_unit_from_networkd_path(self.units)
1954
1955     def test_lldp(self):
1956         copy_unit_to_networkd_unit_path('23-emit-lldp.network', '24-lldp.network', '25-veth.netdev')
1957         start_networkd(0)
1958         wait_online(['veth99:degraded', 'veth-peer:degraded'])
1959
1960         output = check_output(*networkctl_cmd, 'lldp', env=env)
1961         print(output)
1962         self.assertRegex(output, 'veth-peer')
1963         self.assertRegex(output, 'veth99')
1964
1965 class NetworkdRATests(unittest.TestCase, Utilities):
1966     links = ['veth99']
1967
1968     units = [
1969         '25-veth.netdev',
1970         'ipv6-prefix.network',
1971         'ipv6-prefix-veth.network']
1972
1973     def setUp(self):
1974         remove_links(self.links)
1975
1976     def tearDown(self):
1977         remove_links(self.links)
1978         remove_unit_from_networkd_path(self.units)
1979
1980     def test_ipv6_prefix_delegation(self):
1981         warn_about_firewalld()
1982         copy_unit_to_networkd_unit_path('25-veth.netdev', 'ipv6-prefix.network', 'ipv6-prefix-veth.network')
1983         start_networkd(0)
1984         wait_online(['veth99:routable', 'veth-peer:degraded'])
1985
1986         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
1987         print(output)
1988         self.assertRegex(output, '2002:da8:1:0')
1989
1990 class NetworkdDHCPServerTests(unittest.TestCase, Utilities):
1991     links = ['veth99']
1992
1993     units = [
1994         '25-veth.netdev',
1995         'dhcp-client.network',
1996         'dhcp-client-timezone-router.network',
1997         'dhcp-server.network',
1998         'dhcp-server-timezone-router.network']
1999
2000     def setUp(self):
2001         remove_links(self.links)
2002
2003     def tearDown(self):
2004         remove_links(self.links)
2005         remove_unit_from_networkd_path(self.units)
2006
2007     def test_dhcp_server(self):
2008         warn_about_firewalld()
2009         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-client.network', 'dhcp-server.network')
2010         start_networkd(0)
2011         wait_online(['veth99:routable', 'veth-peer:routable'])
2012
2013         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2014         print(output)
2015         self.assertRegex(output, '192.168.5.*')
2016         self.assertRegex(output, 'Gateway: 192.168.5.1')
2017         self.assertRegex(output, 'DNS: 192.168.5.1')
2018         self.assertRegex(output, 'NTP: 192.168.5.1')
2019
2020     def test_emit_router_timezone(self):
2021         warn_about_firewalld()
2022         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-client-timezone-router.network', 'dhcp-server-timezone-router.network')
2023         start_networkd(0)
2024         wait_online(['veth99:routable', 'veth-peer:routable'])
2025
2026         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2027         print(output)
2028         self.assertRegex(output, 'Gateway: 192.168.5.*')
2029         self.assertRegex(output, '192.168.5.*')
2030         self.assertRegex(output, 'Europe/Berlin')
2031
2032 class NetworkdDHCPClientTests(unittest.TestCase, Utilities):
2033     links = [
2034         'veth99',
2035         'vrf99']
2036
2037     units = [
2038         '25-veth.netdev',
2039         '25-vrf.netdev',
2040         '25-vrf.network',
2041         'dhcp-client-anonymize.network',
2042         'dhcp-client-gateway-onlink-implicit.network',
2043         'dhcp-client-ipv4-dhcp-settings.network',
2044         'dhcp-client-ipv4-only-ipv6-disabled.network',
2045         'dhcp-client-ipv4-only.network',
2046         'dhcp-client-ipv6-only.network',
2047         'dhcp-client-ipv6-rapid-commit.network',
2048         'dhcp-client-keep-configuration-dhcp-on-stop.network',
2049         'dhcp-client-keep-configuration-dhcp.network',
2050         'dhcp-client-listen-port.network',
2051         'dhcp-client-route-metric.network',
2052         'dhcp-client-route-table.network',
2053         'dhcp-client-vrf.network',
2054         'dhcp-client-with-ipv4ll-fallback-with-dhcp-server.network',
2055         'dhcp-client-with-ipv4ll-fallback-without-dhcp-server.network',
2056         'dhcp-client.network',
2057         'dhcp-server-veth-peer.network',
2058         'dhcp-v4-server-veth-peer.network',
2059         'static.network']
2060
2061     def setUp(self):
2062         stop_dnsmasq(dnsmasq_pid_file)
2063         remove_links(self.links)
2064
2065     def tearDown(self):
2066         stop_dnsmasq(dnsmasq_pid_file)
2067         remove_lease_file()
2068         remove_log_file()
2069         remove_links(self.links)
2070         remove_unit_from_networkd_path(self.units)
2071
2072     def test_dhcp_client_ipv6_only(self):
2073         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv6-only.network')
2074
2075         start_networkd(0)
2076         wait_online(['veth-peer:carrier'])
2077         start_dnsmasq()
2078         wait_online(['veth99:routable', 'veth-peer:routable'])
2079
2080         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2081         print(output)
2082         self.assertRegex(output, '2600::')
2083         self.assertNotRegex(output, '192.168.5')
2084
2085         # Confirm that ipv6 token is not set in the kernel
2086         output = check_output('ip token show dev veth99')
2087         print(output)
2088         self.assertRegex(output, 'token :: dev veth99')
2089
2090     def test_dhcp_client_ipv4_only(self):
2091         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv4-only-ipv6-disabled.network')
2092
2093         start_networkd(0)
2094         wait_online(['veth-peer:carrier'])
2095         start_dnsmasq()
2096         wait_online(['veth99:routable', 'veth-peer:routable'])
2097
2098         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2099         print(output)
2100         self.assertNotRegex(output, '2600::')
2101         self.assertRegex(output, '192.168.5')
2102
2103     def test_dhcp_client_ipv4_ipv6(self):
2104         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv6-only.network',
2105                                         'dhcp-client-ipv4-only.network')
2106         start_networkd(0)
2107         wait_online(['veth-peer:carrier'])
2108         start_dnsmasq()
2109         wait_online(['veth99:routable', 'veth-peer:routable'])
2110
2111         # link become 'routable' when at least one protocol provide an valid address.
2112         self.wait_address('veth99', r'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic', ipv='-4')
2113         self.wait_address('veth99', r'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)', ipv='-6')
2114
2115         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2116         print(output)
2117         self.assertRegex(output, '2600::')
2118         self.assertRegex(output, '192.168.5')
2119
2120     def test_dhcp_client_settings(self):
2121         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv4-dhcp-settings.network')
2122
2123         start_networkd(0)
2124         wait_online(['veth-peer:carrier'])
2125         start_dnsmasq()
2126         wait_online(['veth99:routable', 'veth-peer:routable'])
2127
2128         print('## ip address show dev veth99')
2129         output = check_output('ip address show dev veth99')
2130         print(output)
2131         self.assertRegex(output, '12:34:56:78:9a:bc')
2132         self.assertRegex(output, '192.168.5')
2133         self.assertRegex(output, '1492')
2134
2135         # issue #8726
2136         print('## ip route show table main dev veth99')
2137         output = check_output('ip route show table main dev veth99')
2138         print(output)
2139         self.assertNotRegex(output, 'proto dhcp')
2140
2141         print('## ip route show table 211 dev veth99')
2142         output = check_output('ip route show table 211 dev veth99')
2143         print(output)
2144         self.assertRegex(output, 'default via 192.168.5.1 proto dhcp')
2145         self.assertRegex(output, '192.168.5.0/24 via 192.168.5.5 proto dhcp')
2146         self.assertRegex(output, '192.168.5.1 proto dhcp scope link')
2147
2148         print('## dnsmasq log')
2149         self.assertTrue(search_words_in_dnsmasq_log('vendor class: SusantVendorTest', True))
2150         self.assertTrue(search_words_in_dnsmasq_log('DHCPDISCOVER(veth-peer) 12:34:56:78:9a:bc'))
2151         self.assertTrue(search_words_in_dnsmasq_log('client provides name: test-hostname'))
2152         self.assertTrue(search_words_in_dnsmasq_log('26:mtu'))
2153
2154     def test_dhcp6_client_settings_rapidcommit_true(self):
2155         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv6-only.network')
2156         start_networkd(0)
2157         wait_online(['veth-peer:carrier'])
2158         start_dnsmasq()
2159         wait_online(['veth99:routable', 'veth-peer:routable'])
2160
2161         output = check_output('ip address show dev veth99')
2162         print(output)
2163         self.assertRegex(output, '12:34:56:78:9a:bc')
2164         self.assertTrue(search_words_in_dnsmasq_log('14:rapid-commit', True))
2165
2166     def test_dhcp6_client_settings_rapidcommit_false(self):
2167         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-ipv6-rapid-commit.network')
2168         start_networkd(0)
2169         wait_online(['veth-peer:carrier'])
2170         start_dnsmasq()
2171         wait_online(['veth99:routable', 'veth-peer:routable'])
2172
2173         output = check_output('ip address show dev veth99')
2174         print(output)
2175         self.assertRegex(output, '12:34:56:78:9a:bc')
2176         self.assertFalse(search_words_in_dnsmasq_log('14:rapid-commit', True))
2177
2178     def test_dhcp_client_settings_anonymize(self):
2179         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-anonymize.network')
2180         start_networkd(0)
2181         wait_online(['veth-peer:carrier'])
2182         start_dnsmasq()
2183         wait_online(['veth99:routable', 'veth-peer:routable'])
2184
2185         self.assertFalse(search_words_in_dnsmasq_log('VendorClassIdentifier=SusantVendorTest', True))
2186         self.assertFalse(search_words_in_dnsmasq_log('test-hostname'))
2187         self.assertFalse(search_words_in_dnsmasq_log('26:mtu'))
2188
2189     def test_dhcp_client_listen_port(self):
2190         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-listen-port.network')
2191         start_networkd(0)
2192         wait_online(['veth-peer:carrier'])
2193         start_dnsmasq('--dhcp-alternate-port=67,5555')
2194         wait_online(['veth99:routable', 'veth-peer:routable'])
2195
2196         # link become 'routable' when at least one protocol provide an valid address.
2197         self.wait_address('veth99', r'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic', ipv='-4')
2198         self.wait_address('veth99', r'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)', ipv='-6')
2199
2200         output = check_output('ip -4 address show dev veth99')
2201         print(output)
2202         self.assertRegex(output, '192.168.5.* dynamic')
2203
2204     def test_dhcp_route_table_id(self):
2205         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-v4-server-veth-peer.network', 'dhcp-client-route-table.network')
2206         start_networkd(0)
2207         wait_online(['veth-peer:carrier'])
2208         start_dnsmasq()
2209         wait_online(['veth99:routable', 'veth-peer:routable'])
2210
2211         output = check_output('ip route show table 12')
2212         print(output)
2213         self.assertRegex(output, 'veth99 proto dhcp')
2214         self.assertRegex(output, '192.168.5.1')
2215
2216     def test_dhcp_route_metric(self):
2217         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-v4-server-veth-peer.network', 'dhcp-client-route-metric.network')
2218         start_networkd(0)
2219         wait_online(['veth-peer:carrier'])
2220         start_dnsmasq()
2221         wait_online(['veth99:routable', 'veth-peer:routable'])
2222
2223         output = check_output('ip route show dev veth99')
2224         print(output)
2225         self.assertRegex(output, 'metric 24')
2226
2227     def test_dhcp_keep_configuration_dhcp(self):
2228         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-v4-server-veth-peer.network', 'dhcp-client-keep-configuration-dhcp.network')
2229         start_networkd(0)
2230         wait_online(['veth-peer:carrier'])
2231         start_dnsmasq(lease_time='2m')
2232         wait_online(['veth99:routable', 'veth-peer:routable'])
2233
2234         output = check_output('ip address show dev veth99 scope global')
2235         print(output)
2236         self.assertRegex(output, r'192.168.5.*')
2237
2238         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2239         print(output)
2240         self.assertRegex(output, r'192.168.5.*')
2241
2242         # Stopping dnsmasq as networkd won't be allowed to renew the DHCP lease.
2243         stop_dnsmasq(dnsmasq_pid_file)
2244
2245         # Sleep for 120 sec as the dnsmasq minimum lease time can only be set to 120
2246         print('Wait for the dynamic address to be expired')
2247         time.sleep(125)
2248
2249         print('The lease address should be kept after lease expired')
2250         output = check_output('ip address show dev veth99 scope global')
2251         print(output)
2252         self.assertRegex(output, r'192.168.5.*')
2253
2254         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2255         print(output)
2256         self.assertRegex(output, r'192.168.5.*')
2257
2258         check_output('systemctl stop systemd-networkd')
2259
2260         print('The lease address should be kept after networkd stopped')
2261         output = check_output('ip address show dev veth99 scope global')
2262         print(output)
2263         self.assertRegex(output, r'192.168.5.*')
2264
2265         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2266         print(output)
2267         self.assertRegex(output, r'192.168.5.*')
2268
2269         check_output('systemctl start systemd-networkd')
2270         wait_online(['veth-peer:routable'])
2271
2272         print('Still the lease address should be kept after networkd restarted')
2273         output = check_output('ip address show dev veth99 scope global')
2274         print(output)
2275         self.assertRegex(output, r'192.168.5.*')
2276
2277         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2278         print(output)
2279         self.assertRegex(output, r'192.168.5.*')
2280
2281     def test_dhcp_keep_configuration_dhcp_on_stop(self):
2282         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-v4-server-veth-peer.network', 'dhcp-client-keep-configuration-dhcp-on-stop.network')
2283         start_networkd(0)
2284         wait_online(['veth-peer:carrier'])
2285         start_dnsmasq(lease_time='2m')
2286         wait_online(['veth99:routable', 'veth-peer:routable'])
2287
2288         output = check_output('ip address show dev veth99 scope global')
2289         print(output)
2290         self.assertRegex(output, r'192.168.5.*')
2291
2292         stop_dnsmasq(dnsmasq_pid_file)
2293         check_output('systemctl stop systemd-networkd')
2294
2295         output = check_output('ip address show dev veth99 scope global')
2296         print(output)
2297         self.assertRegex(output, r'192.168.5.*')
2298
2299         start_networkd(0)
2300         wait_online(['veth-peer:routable'])
2301
2302         output = check_output('ip address show dev veth99 scope global')
2303         print(output)
2304         self.assertNotRegex(output, r'192.168.5.*')
2305
2306     def test_dhcp_client_reuse_address_as_static(self):
2307         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client.network')
2308         start_networkd(0)
2309         wait_online(['veth-peer:carrier'])
2310         start_dnsmasq()
2311         wait_online(['veth99:routable', 'veth-peer:routable'])
2312
2313         # link become 'routable' when at least one protocol provide an valid address.
2314         self.wait_address('veth99', r'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic', ipv='-4')
2315         self.wait_address('veth99', r'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)', ipv='-6')
2316
2317         output = check_output('ip address show dev veth99 scope global')
2318         print(output)
2319         self.assertRegex(output, '192.168.5')
2320         self.assertRegex(output, '2600::')
2321
2322         ipv4_address = re.search(r'192.168.5.[0-9]*/24', output)
2323         ipv6_address = re.search(r'2600::[0-9a-f:]*/128', output)
2324         static_network = '\n'.join(['[Match]', 'Name=veth99', '[Network]', 'IPv6AcceptRA=no', 'Address=' + ipv4_address.group(), 'Address=' + ipv6_address.group()])
2325         print(static_network)
2326
2327         remove_unit_from_networkd_path(['dhcp-client.network'])
2328
2329         with open(os.path.join(network_unit_file_path, 'static.network'), mode='w') as f:
2330             f.write(static_network)
2331
2332         # When networkd started, the links are already configured, so let's wait for 5 seconds
2333         # the links to be re-configured.
2334         start_networkd(5)
2335         wait_online(['veth99:routable', 'veth-peer:routable'])
2336
2337         output = check_output('ip -4 address show dev veth99 scope global')
2338         print(output)
2339         self.assertRegex(output, '192.168.5')
2340         self.assertRegex(output, 'valid_lft forever preferred_lft forever')
2341
2342         output = check_output('ip -6 address show dev veth99 scope global')
2343         print(output)
2344         self.assertRegex(output, '2600::')
2345         self.assertRegex(output, 'valid_lft forever preferred_lft forever')
2346
2347     @expectedFailureIfModuleIsNotAvailable('vrf')
2348     def test_dhcp_client_vrf(self):
2349         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network', 'dhcp-client-vrf.network',
2350                                         '25-vrf.netdev', '25-vrf.network')
2351         start_networkd(0)
2352         wait_online(['veth-peer:carrier'])
2353         start_dnsmasq()
2354         wait_online(['veth99:routable', 'veth-peer:routable', 'vrf99:carrier'])
2355
2356         # link become 'routable' when at least one protocol provide an valid address.
2357         self.wait_address('veth99', r'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic', ipv='-4')
2358         self.wait_address('veth99', r'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)', ipv='-6')
2359
2360         print('## ip -d link show dev vrf99')
2361         output = check_output('ip -d link show dev vrf99')
2362         print(output)
2363         self.assertRegex(output, 'vrf table 42')
2364
2365         print('## ip address show vrf vrf99')
2366         output = check_output('ip address show vrf vrf99')
2367         print(output)
2368         self.assertRegex(output, 'inet 169.254.[0-9]*.[0-9]*/16 brd 169.254.255.255 scope link veth99')
2369         self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
2370         self.assertRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)')
2371         self.assertRegex(output, 'inet6 .* scope link')
2372
2373         print('## ip address show dev veth99')
2374         output = check_output('ip address show dev veth99')
2375         print(output)
2376         self.assertRegex(output, 'inet 169.254.[0-9]*.[0-9]*/16 brd 169.254.255.255 scope link veth99')
2377         self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
2378         self.assertRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global (?:dynamic noprefixroute|noprefixroute dynamic)')
2379         self.assertRegex(output, 'inet6 .* scope link')
2380
2381         print('## ip route show vrf vrf99')
2382         output = check_output('ip route show vrf vrf99')
2383         print(output)
2384         self.assertRegex(output, 'default via 192.168.5.1 dev veth99 proto dhcp src 192.168.5.')
2385         self.assertRegex(output, 'default dev veth99 proto static scope link')
2386         self.assertRegex(output, '169.254.0.0/16 dev veth99 proto kernel scope link src 169.254')
2387         self.assertRegex(output, '192.168.5.0/24 dev veth99 proto kernel scope link src 192.168.5')
2388         self.assertRegex(output, '192.168.5.0/24 via 192.168.5.5 dev veth99 proto dhcp')
2389         self.assertRegex(output, '192.168.5.1 dev veth99 proto dhcp scope link src 192.168.5')
2390
2391         print('## ip route show table main dev veth99')
2392         output = check_output('ip route show table main dev veth99')
2393         print(output)
2394         self.assertEqual(output, '')
2395
2396     def test_dhcp_client_gateway_onlink_implicit(self):
2397         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
2398                                         'dhcp-client-gateway-onlink-implicit.network')
2399         start_networkd(0)
2400         wait_online(['veth-peer:carrier'])
2401         start_dnsmasq()
2402         wait_online(['veth99:routable', 'veth-peer:routable'])
2403
2404         output = check_output(*networkctl_cmd, 'status', 'veth99', env=env)
2405         print(output)
2406         self.assertRegex(output, '192.168.5')
2407
2408         output = check_output('ip route list dev veth99 10.0.0.0/8')
2409         print(output)
2410         self.assertRegex(output, 'onlink')
2411         output = check_output('ip route list dev veth99 192.168.100.0/24')
2412         print(output)
2413         self.assertRegex(output, 'onlink')
2414
2415     def test_dhcp_client_with_ipv4ll_fallback_with_dhcp_server(self):
2416         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
2417                                         'dhcp-client-with-ipv4ll-fallback-with-dhcp-server.network')
2418         start_networkd(0)
2419         wait_online(['veth-peer:carrier'])
2420         start_dnsmasq(lease_time='2m')
2421         wait_online(['veth99:routable', 'veth-peer:routable'])
2422
2423         output = check_output('ip address show dev veth99')
2424         print(output)
2425
2426         output = check_output('ip -6 address show dev veth99 scope global dynamic')
2427         self.assertNotRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global dynamic')
2428         output = check_output('ip -6 address show dev veth99 scope link')
2429         self.assertRegex(output, 'inet6 .* scope link')
2430         output = check_output('ip -4 address show dev veth99 scope global dynamic')
2431         self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
2432         output = check_output('ip -4 address show dev veth99 scope link')
2433         self.assertNotRegex(output, 'inet .* scope link')
2434
2435         print('Wait for the dynamic address to be expired')
2436         time.sleep(130)
2437
2438         output = check_output('ip address show dev veth99')
2439         print(output)
2440
2441         output = check_output('ip -6 address show dev veth99 scope global dynamic')
2442         self.assertNotRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global dynamic')
2443         output = check_output('ip -6 address show dev veth99 scope link')
2444         self.assertRegex(output, 'inet6 .* scope link')
2445         output = check_output('ip -4 address show dev veth99 scope global dynamic')
2446         self.assertRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
2447         output = check_output('ip -4 address show dev veth99 scope link')
2448         self.assertNotRegex(output, 'inet .* scope link')
2449
2450         search_words_in_dnsmasq_log('DHCPOFFER', show_all=True)
2451
2452     def test_dhcp_client_with_ipv4ll_fallback_without_dhcp_server(self):
2453         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
2454                                         'dhcp-client-with-ipv4ll-fallback-without-dhcp-server.network')
2455         start_networkd(0)
2456         wait_online(['veth99:degraded', 'veth-peer:routable'])
2457
2458         output = check_output('ip address show dev veth99')
2459         print(output)
2460
2461         output = check_output('ip -6 address show dev veth99 scope global dynamic')
2462         self.assertNotRegex(output, 'inet6 2600::[0-9a-f]*/128 scope global dynamic')
2463         output = check_output('ip -6 address show dev veth99 scope link')
2464         self.assertRegex(output, 'inet6 .* scope link')
2465         output = check_output('ip -4 address show dev veth99 scope global dynamic')
2466         self.assertNotRegex(output, 'inet 192.168.5.[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
2467         output = check_output('ip -4 address show dev veth99 scope link')
2468         self.assertRegex(output, 'inet .* scope link')
2469
2470     def test_dhcp_client_route_remove_on_renew(self):
2471         copy_unit_to_networkd_unit_path('25-veth.netdev', 'dhcp-server-veth-peer.network',
2472                                         'dhcp-client-ipv4-only-ipv6-disabled.network')
2473         start_networkd(0)
2474         wait_online(['veth-peer:carrier'])
2475         start_dnsmasq(ipv4_range='192.168.5.100,192.168.5.199', lease_time='2m')
2476         wait_online(['veth99:routable', 'veth-peer:routable'])
2477
2478         # test for issue #12490
2479
2480         output = check_output('ip -4 address show dev veth99 scope global dynamic')
2481         print(output)
2482         self.assertRegex(output, 'inet 192.168.5.1[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
2483         address1=None
2484         for line in output.splitlines():
2485             if 'brd 192.168.5.255 scope global dynamic veth99' in line:
2486                 address1 = line.split()[1].split('/')[0]
2487                 break
2488
2489         output = check_output('ip -4 route show dev veth99')
2490         print(output)
2491         self.assertRegex(output, f'default via 192.168.5.1 proto dhcp src {address1} metric 1024')
2492         self.assertRegex(output, f'192.168.5.1 proto dhcp scope link src {address1} metric 1024')
2493
2494         stop_dnsmasq(dnsmasq_pid_file)
2495         start_dnsmasq(ipv4_range='192.168.5.200,192.168.5.250', lease_time='2m')
2496
2497         print('Wait for the dynamic address to be expired')
2498         time.sleep(130)
2499
2500         output = check_output('ip -4 address show dev veth99 scope global dynamic')
2501         print(output)
2502         self.assertRegex(output, 'inet 192.168.5.2[0-9]*/24 brd 192.168.5.255 scope global dynamic veth99')
2503         address2=None
2504         for line in output.splitlines():
2505             if 'brd 192.168.5.255 scope global dynamic veth99' in line:
2506                 address2 = line.split()[1].split('/')[0]
2507                 break
2508
2509         self.assertNotEqual(address1, address2)
2510
2511         output = check_output('ip -4 route show dev veth99')
2512         print(output)
2513         self.assertNotRegex(output, f'default via 192.168.5.1 proto dhcp src {address1} metric 1024')
2514         self.assertNotRegex(output, f'192.168.5.1 proto dhcp scope link src {address1} metric 1024')
2515         self.assertRegex(output, f'default via 192.168.5.1 proto dhcp src {address2} metric 1024')
2516         self.assertRegex(output, f'192.168.5.1 proto dhcp scope link src {address2} metric 1024')
2517
2518 if __name__ == '__main__':
2519     parser = argparse.ArgumentParser()
2520     parser.add_argument('--build-dir', help='Path to build dir', dest='build_dir')
2521     parser.add_argument('--networkd', help='Path to systemd-networkd', dest='networkd_bin')
2522     parser.add_argument('--wait-online', help='Path to systemd-networkd-wait-online', dest='wait_online_bin')
2523     parser.add_argument('--networkctl', help='Path to networkctl', dest='networkctl_bin')
2524     parser.add_argument('--valgrind', help='Enable valgrind', dest='use_valgrind', type=bool, nargs='?', const=True, default=use_valgrind)
2525     parser.add_argument('--debug', help='Generate debugging logs', dest='enable_debug', type=bool, nargs='?', const=True, default=enable_debug)
2526     parser.add_argument('--asan-options', help='ASAN options', dest='asan_options')
2527     parser.add_argument('--lsan-options', help='LSAN options', dest='lsan_options')
2528     parser.add_argument('--ubsan-options', help='UBSAN options', dest='ubsan_options')
2529     ns, args = parser.parse_known_args(namespace=unittest)
2530
2531     if ns.build_dir:
2532         if ns.networkd_bin or ns.wait_online_bin or ns.networkctl_bin:
2533             print('WARNING: --networkd, --wait-online, or --networkctl options are ignored when --build-dir is specified.')
2534         networkd_bin = os.path.join(ns.build_dir, 'systemd-networkd')
2535         wait_online_bin = os.path.join(ns.build_dir, 'systemd-networkd-wait-online')
2536         networkctl_bin = os.path.join(ns.build_dir, 'networkctl')
2537     else:
2538         if ns.networkd_bin:
2539             networkd_bin = ns.networkd_bin
2540         if ns.wait_online_bin:
2541             wait_online_bin = ns.wait_online_bin
2542         if ns.networkctl_bin:
2543             networkctl_bin = ns.networkctl_bin
2544
2545     use_valgrind = ns.use_valgrind
2546     enable_debug = ns.enable_debug
2547     asan_options = ns.asan_options
2548     lsan_options = ns.lsan_options
2549     ubsan_options = ns.ubsan_options
2550
2551     if use_valgrind:
2552         networkctl_cmd = ['valgrind', '--track-origins=yes', '--leak-check=full', '--show-leak-kinds=all', networkctl_bin]
2553         wait_online_cmd = ['valgrind', '--track-origins=yes', '--leak-check=full', '--show-leak-kinds=all', wait_online_bin]
2554     else:
2555         networkctl_cmd = [networkctl_bin]
2556         wait_online_cmd = [wait_online_bin]
2557
2558     if enable_debug:
2559         env.update({ 'SYSTEMD_LOG_LEVEL' : 'debug' })
2560     if asan_options:
2561         env.update({ 'ASAN_OPTIONS' : asan_options })
2562     if lsan_options:
2563         env.update({ 'LSAN_OPTIONS' : lsan_options })
2564     if ubsan_options:
2565         env.update({ 'UBSAN_OPTIONS' : ubsan_options })
2566
2567     sys.argv[1:] = args
2568     unittest.main(testRunner=unittest.TextTestRunner(stream=sys.stdout,
2569                                                      verbosity=3))