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