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