HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

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

468,283 bytesGit mode 100755Download original fileLGPL-2.1-or-later

Git blob: aaf8830b28df24259c9ca79d57929ab5449e46af

Lines 2001–3000 of 11,559

                '''
[Network]
Domains=~.
[DHCPv4]
UseDNS=no
'''
            ),
        )
 
 
class NetworkdNetDevTests(unittest.TestCase, Utilities):
    def setUp(self):
        setup_common()
 
    def tearDown(self):
        tear_down_common()
 
    def test_dropin_and_name_conflict(self):
        copy_network_unit('10-dropin-test.netdev', '15-name-conflict-test.netdev')
        start_networkd()
 
        self.wait_online('dropin-test:off', setup_state='unmanaged')
 
        output = check_output('ip link show dropin-test')
        print(output)
        self.assertRegex(output, '00:50:56:c0:00:28')
 
    @expectedFailureIfModuleIsNotAvailable('bareudp')
    def test_bareudp(self):
        copy_network_unit('25-bareudp.netdev', '26-netdev-link-local-addressing-yes.network')
        start_networkd()
 
        self.wait_online('bareudp99:degraded')
        self.networkctl_check_unit('bareudp99', '25-bareudp', '26-netdev-link-local-addressing-yes')
 
        output = check_output('ip -d link show bareudp99')
        print(output)
        self.assertRegex(output, 'dstport 1000 ')
        self.assertRegex(output, 'ethertype ip ')
        self.assertRegex(output, 'srcportmin 1001 ')
 
        touch_network_unit('25-bareudp.netdev', '26-netdev-link-local-addressing-yes.network')
        networkctl_reload()
        self.wait_online('bareudp99:degraded')
 
    @expectedFailureIfModuleIsNotAvailable('batman-adv')
    def test_batadv(self):
        copy_network_unit('25-batadv.netdev', '26-netdev-link-local-addressing-yes.network')
        start_networkd()
 
        self.wait_online('batadv99:degraded')
        self.networkctl_check_unit('batadv99', '25-batadv', '26-netdev-link-local-addressing-yes')
 
        output = check_output('ip -d link show batadv99')
        print(output)
        self.assertRegex(output, 'batadv')
 
        touch_network_unit('25-batadv.netdev', '26-netdev-link-local-addressing-yes.network')
        networkctl_reload()
        self.wait_online('batadv99:degraded')
 
    def test_bridge(self):
        copy_network_unit('25-bridge.netdev', '25-bridge-configure-without-carrier.network')
        start_networkd()
 
        self.wait_online('bridge99:no-carrier')
        self.networkctl_check_unit('bridge99', '25-bridge', '25-bridge-configure-without-carrier')
 
        tick = os.sysconf('SC_CLK_TCK')
        self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge', 'hello_time')) / tick))
        self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge', 'max_age')) / tick))
        self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge', 'forward_delay')) / tick))
        self.assertEqual(9, round(float(read_link_attr('bridge99', 'bridge', 'ageing_time')) / tick))
        self.assertEqual(9, int(read_link_attr('bridge99', 'bridge', 'priority')))
        self.assertEqual(1, int(read_link_attr('bridge99', 'bridge', 'multicast_querier')))
        self.assertEqual(1, int(read_link_attr('bridge99', 'bridge', 'multicast_snooping')))
        self.assertEqual(1, int(read_link_attr('bridge99', 'bridge', 'stp_state')))
        self.assertEqual(3, int(read_link_attr('bridge99', 'bridge', 'multicast_igmp_version')))
        self.assertEqual(1, int(read_link_attr('bridge99', 'bridge', 'no_linklocal_learn')))
 
        output = networkctl_status('bridge99')
        print(output)
        self.assertRegex(output, 'Priority: 9')
        self.assertRegex(output, 'STP: yes')
        self.assertRegex(output, 'Multicast IGMP Version: 3')
        if 'FDB Max Learned' in output:
            self.assertRegex(output, 'FDB Max Learned: 4')
 
        output = check_output('ip -d link show bridge99')
        print(output)
        self.assertIn('vlan_filtering 1 ', output)
        self.assertIn('vlan_protocol 802.1ad ', output)
        self.assertIn('vlan_default_pvid 9 ', output)
        if 'fdb_max_learned' in output:
            self.assertIn('fdb_max_learned 4 ', output)
 
    def test_bond(self):
        copy_network_unit('25-bond.netdev', '25-bond-balanced-tlb.netdev', '25-bond-property.netdev')
        start_networkd()
 
        self.wait_online('bond99:off', 'bond98:off', 'bond97:off', setup_state='unmanaged')
        self.networkctl_check_unit('bond99', '25-bond')
        self.networkctl_check_unit('bond98', '25-bond-balanced-tlb')
        self.networkctl_check_unit('bond97', '25-bond-property')
 
        self.check_link_attr('bond99', 'bonding', 'mode', '802.3ad 4')
        self.check_link_attr('bond99', 'bonding', 'xmit_hash_policy', 'layer3+4 1')
        self.check_link_attr('bond99', 'bonding', 'miimon', '1000')
        self.check_link_attr('bond99', 'bonding', 'lacp_rate', 'fast 1')
        self.check_link_attr('bond99', 'bonding', 'updelay', '2000')
        self.check_link_attr('bond99', 'bonding', 'downdelay', '2000')
        self.check_link_attr('bond99', 'bonding', 'resend_igmp', '4')
        self.check_link_attr('bond99', 'bonding', 'min_links', '1')
        self.check_link_attr('bond99', 'bonding', 'ad_actor_sys_prio', '1218')
        self.check_link_attr('bond99', 'bonding', 'ad_user_port_key', '811')
        self.check_link_attr('bond99', 'bonding', 'ad_actor_system', '00:11:22:33:44:55')
 
        self.check_link_attr('bond98', 'bonding', 'mode', 'balance-tlb 5')
        self.check_link_attr('bond98', 'bonding', 'tlb_dynamic_lb', '1')
 
        output = networkctl_status('bond99')
        print(output)
        self.assertIn('Mode: 802.3ad', output)
        self.assertIn('Miimon: 1s', output)
        self.assertIn('Updelay: 2s', output)
        self.assertIn('Downdelay: 2s', output)
 
        output = networkctl_status('bond98')
        print(output)
        self.assertIn('Mode: balance-tlb', output)
 
        output = networkctl_status('bond97')
        print(output)
 
        self.check_link_attr('bond97', 'bonding', 'arp_missed_max', '10')
        self.check_link_attr('bond97', 'bonding', 'peer_notif_delay', '300000')
 
    def check_vlan(self, id, flags):
        self.wait_online('test1:degraded', 'vlan99:routable')
        self.networkctl_check_unit('vlan99', '21-vlan', '21-vlan')
        self.networkctl_check_unit('test1', '11-dummy', '21-vlan-test1')
 
        output = check_output('ip -d link show test1')
        print(output)
        self.assertRegex(output, ' mtu 2000 ')
 
        output = check_output('ip -d link show vlan99')
        print(output)
        self.assertIn(' mtu 2000 ', output)
        if flags:
            self.assertIn('REORDER_HDR', output)
            self.assertIn('LOOSE_BINDING', output)
            self.assertIn('GVRP', output)
            self.assertIn('MVRP', output)
        else:
            self.assertNotIn('REORDER_HDR', output)
            self.assertNotIn('LOOSE_BINDING', output)
            self.assertNotIn('GVRP', output)
            self.assertNotIn('MVRP', output)
        self.assertIn(f' id {id} ', output)
        self.assertIn('ingress-qos-map { 4:100 7:13 }', output)
        self.assertIn('egress-qos-map { 0:1 1:3 6:6 7:7 10:3 }', output)
 
        output = check_output('ip -4 address show dev test1')
        print(output)
        self.assertRegex(output, 'inet 192.168.24.5/24 brd 192.168.24.255 scope global test1')
        self.assertRegex(output, 'inet 192.168.25.5/24 brd 192.168.25.255 scope global test1')
 
        output = check_output('ip -4 address show dev vlan99')
        print(output)
        self.assertRegex(output, 'inet 192.168.23.5/24 brd 192.168.23.255 scope global vlan99')
 
    def test_vlan(self):
        copy_network_unit(
            '21-vlan.netdev',
            '11-dummy.netdev',
            '21-vlan.network',
            '21-vlan-test1.network',
        )
        start_networkd()
        self.check_vlan(id=99, flags=True)
 
        # Test for reloading .netdev file. See issue #34907.
        with open(
            os.path.join(network_unit_dir, '21-vlan.netdev.d/override.conf'), mode='a', encoding='utf-8'
        ) as f:
            f.write('[VLAN]\nId=42\n')
 
        # VLAN ID cannot be changed, so we need to remove the existing netdev.
        check_output('ip link del vlan99')
        networkctl_reload()
        self.check_vlan(id=42, flags=True)
 
        with open(
            os.path.join(network_unit_dir, '21-vlan.netdev.d/override.conf'), mode='a', encoding='utf-8'
        ) as f:
            f.write('''
[VLAN]
GVRP=no
MVRP=no
LooseBinding=no
ReorderHeader=no
''')
 
        # flags can be changed, hence it is not necessary to remove the existing netdev.
        networkctl_reload()
        self.check_vlan(id=42, flags=False)
 
    def test_vlan_on_bond(self):
        # For issue #24377 (https://github.com/systemd/systemd/issues/24377),
        # which is fixed by b05e52000b4eee764b383cc3031da0a3739e996e (PR#24020).
 
        copy_network_unit(
            '21-bond-802.3ad.netdev',
            '21-bond-802.3ad.network',
            '21-vlan-on-bond.netdev',
            '21-vlan-on-bond.network',
        )
        start_networkd()
        self.wait_online('bond99:off')
        self.wait_operstate('vlan99', operstate='off', setup_state='configuring', setup_timeout=10)
        self.networkctl_check_unit('vlan99', '21-vlan-on-bond', '21-vlan-on-bond')
        self.networkctl_check_unit('bond99', '21-bond-802.3ad', '21-bond-802.3ad')
 
        self.check_networkd_log('vlan99: Could not bring up interface, ignoring: Network is down')
 
        copy_network_unit('11-dummy.netdev', '12-dummy.netdev', '21-dummy-bond-slave.network')
        networkctl_reload()
        self.wait_online('test1:enslaved', 'dummy98:enslaved', 'bond99:carrier', 'vlan99:routable')
 
    def test_macvtap(self):
        first = True
        for mode in ['private', 'vepa', 'bridge', 'passthru']:
            if first:
                first = False
            else:
                self.tearDown()
 
            print(f'### test_macvtap(mode={mode})')
            with self.subTest(mode=mode):
                copy_network_unit(
                    '21-macvtap.netdev',
                    '26-netdev-link-local-addressing-yes.network',
                    '11-dummy.netdev',
                    '25-macvtap.network',
                )
                with open(
                    os.path.join(network_unit_dir, '21-macvtap.netdev'), mode='a', encoding='utf-8'
                ) as f:
                    f.write('[MACVTAP]\nMode=' + mode)
                start_networkd()
 
                self.wait_online(
                    'macvtap99:degraded',
                    'test1:carrier' if mode == 'passthru' else 'test1:degraded',
                )
                self.networkctl_check_unit('macvtap99', '21-macvtap', '26-netdev-link-local-addressing-yes')
                self.networkctl_check_unit('test1', '11-dummy', '25-macvtap')
 
                output = check_output('ip -d link show macvtap99')
                print(output)
                self.assertRegex(output, 'macvtap mode ' + mode + ' ')
 
                touch_network_unit('21-macvtap.netdev')
                networkctl_reload()
                self.wait_online(
                    'macvtap99:degraded',
                    'test1:carrier' if mode == 'passthru' else 'test1:degraded',
                )
 
    @expectedFailureIfModuleIsNotAvailable('macvlan')
    def test_macvlan(self):
        first = True
        for mode in ['private', 'vepa', 'bridge', 'passthru']:
            if first:
                first = False
            else:
                self.tearDown()
 
            print(f'### test_macvlan(mode={mode})')
            with self.subTest(mode=mode):
                copy_network_unit(
                    '21-macvlan.netdev',
                    '26-netdev-link-local-addressing-yes.network',
                    '11-dummy.netdev',
                    '25-macvlan.network',
                )
                with open(
                    os.path.join(network_unit_dir, '21-macvlan.netdev'), mode='a', encoding='utf-8'
                ) as f:
                    f.write('[MACVLAN]\nMode=' + mode)
                start_networkd()
 
                self.wait_online(
                    'macvlan99:degraded',
                    'test1:carrier' if mode == 'passthru' else 'test1:degraded',
                )
                self.networkctl_check_unit('macvlan99', '21-macvlan', '26-netdev-link-local-addressing-yes')
                self.networkctl_check_unit('test1', '11-dummy', '25-macvlan')
 
                output = check_output('ip -d link show test1')
                print(output)
                self.assertIn(' mtu 2000 ', output)
 
                output = check_output('ip -d link show macvlan99')
                print(output)
                self.assertIn(' mtu 2000 ', output)
                self.assertIn(f' macvlan mode {mode} ', output)
 
                remove_link('test1')
                time.sleep(1)
 
                check_output('ip link add test1 type dummy')
                self.wait_online(
                    'macvlan99:degraded',
                    'test1:carrier' if mode == 'passthru' else 'test1:degraded',
                )
 
                output = check_output('ip -d link show test1')
                print(output)
                self.assertIn(' mtu 2000 ', output)
 
                output = check_output('ip -d link show macvlan99')
                print(output)
                self.assertIn(' mtu 2000 ', output)
                self.assertIn(f' macvlan mode {mode} ', output)
                self.assertIn(' bcqueuelen 1234 ', output)
                if ' bclim ' in output:  # This is new in kernel and iproute2 v6.4
                    self.assertIn(' bclim 2147483647 ', output)
 
                touch_network_unit('21-macvlan.netdev')
                networkctl_reload()
                self.wait_online(
                    'macvlan99:degraded',
                    'test1:carrier' if mode == 'passthru' else 'test1:degraded',
                )
 
    @expectedFailureIfModuleIsNotAvailable('ipvlan')
    def test_ipvlan(self):
        first = True
        for mode, flag in [['L2', 'private'], ['L3', 'vepa'], ['L3S', 'bridge']]:
            if first:
                first = False
            else:
                self.tearDown()
 
            print(f'### test_ipvlan(mode={mode}, flag={flag})')
            with self.subTest(mode=mode, flag=flag):
                copy_network_unit(
                    '25-ipvlan.netdev',
                    '26-netdev-link-local-addressing-yes.network',
                    '11-dummy.netdev',
                    '25-ipvlan.network',
                )
                with open(
                    os.path.join(network_unit_dir, '25-ipvlan.netdev'), mode='a', encoding='utf-8'
                ) as f:
                    f.write('[IPVLAN]\nMode=' + mode + '\nFlags=' + flag)
 
                start_networkd()
                self.wait_online('ipvlan99:degraded', 'test1:degraded')
                self.networkctl_check_unit('ipvlan99', '25-ipvlan', '26-netdev-link-local-addressing-yes')
                self.networkctl_check_unit('test1', '11-dummy', '25-ipvlan')
 
                output = check_output('ip -d link show ipvlan99')
                print(output)
                self.assertRegex(output, 'ipvlan  *mode ' + mode.lower() + ' ' + flag)
 
                touch_network_unit('25-ipvlan.netdev')
                networkctl_reload()
                self.wait_online('ipvlan99:degraded', 'test1:degraded')
 
    @expectedFailureIfModuleIsNotAvailable('hsr')
    def test_hsr(self):
        first = True
        for proto, supervision in [['hsr', 9], ['prp', 127]]:
            if first:
                first = False
            else:
                self.tearDown()
 
            print(f'### test_hsr(proto={proto}, supervision={supervision})')
            with self.subTest(proto=proto, supervision=supervision):
                copy_network_unit(
                    '25-hsr.netdev',
                    '25-hsr.network',
                    '11-dummy.netdev',
                    '11-dummy.network',
                    '12-dummy.netdev',
                    '12-dummy-no-address.network',
                )
                with open(os.path.join(network_unit_dir, '25-hsr.netdev'), mode='a', encoding='utf-8') as f:
                    f.write('Protocol=' + proto + '\nSupervision=' + str(supervision))
 
                start_networkd()
                self.wait_online('hsr99:degraded')
                self.networkctl_check_unit('hsr99', '25-hsr', '25-hsr')
                self.networkctl_check_unit('test1', '11-dummy', '11-dummy')
                self.networkctl_check_unit('dummy98', '12-dummy', '12-dummy-no-address')
 
                output = check_output('ip -d link show hsr99')
                print(output)
                self.assertRegex(output, 'hsr slave1 test1 slave2 dummy98')
                self.assertRegex(output, f'supervision 01:15:4e:00:01:{supervision:02x}')
                self.assertRegex(output, 'proto ' + ('0' if proto == 'hsr' else '1') + ' ')
 
                touch_network_unit('25-hsr.netdev')
                networkctl_reload()
                self.wait_online('hsr99:degraded')
 
    @expectedFailureIfModuleIsNotAvailable('ipvtap')
    def test_ipvtap(self):
        first = True
        for mode, flag in [['L2', 'private'], ['L3', 'vepa'], ['L3S', 'bridge']]:
            if first:
                first = False
            else:
                self.tearDown()
 
            print(f'### test_ipvtap(mode={mode}, flag={flag})')
            with self.subTest(mode=mode, flag=flag):
                copy_network_unit(
                    '25-ipvtap.netdev',
                    '26-netdev-link-local-addressing-yes.network',
                    '11-dummy.netdev',
                    '25-ipvtap.network',
                )
                with open(
                    os.path.join(network_unit_dir, '25-ipvtap.netdev'), mode='a', encoding='utf-8'
                ) as f:
                    f.write('[IPVTAP]\nMode=' + mode + '\nFlags=' + flag)
 
                start_networkd()
                self.wait_online('ipvtap99:degraded', 'test1:degraded')
                self.networkctl_check_unit('ipvtap99', '25-ipvtap', '26-netdev-link-local-addressing-yes')
                self.networkctl_check_unit('test1', '11-dummy', '25-ipvtap')
 
                output = check_output('ip -d link show ipvtap99')
                print(output)
                self.assertRegex(output, 'ipvtap  *mode ' + mode.lower() + ' ' + flag)
 
                touch_network_unit('25-ipvtap.netdev')
                networkctl_reload()
                self.wait_online('ipvtap99:degraded', 'test1:degraded')
 
    def test_veth(self):
        copy_network_unit(
            '25-veth.netdev',
            '26-netdev-link-local-addressing-yes.network',
            '25-veth-mtu.netdev',
        )
        start_networkd()
 
        self.wait_online(
            'veth99:degraded',
            'veth-peer:degraded',
            'veth-mtu:degraded',
            'veth-mtu-peer:degraded',
        )
        self.networkctl_check_unit('veth99', '25-veth', '26-netdev-link-local-addressing-yes')
        self.networkctl_check_unit('veth-peer', '25-veth', '26-netdev-link-local-addressing-yes')
        self.networkctl_check_unit('veth-mtu', '25-veth-mtu', '26-netdev-link-local-addressing-yes')
        self.networkctl_check_unit('veth-mtu-peer', '25-veth-mtu', '26-netdev-link-local-addressing-yes')
 
        output = check_output('ip -d link show veth99')
        print(output)
        self.assertRegex(output, 'link/ether 12:34:56:78:9a:bc')
        output = check_output('ip -d link show veth-peer')
        print(output)
        self.assertRegex(output, 'link/ether 12:34:56:78:9a:bd')
 
        output = check_output('ip -d link show veth-mtu')
        print(output)
        self.assertRegex(output, 'link/ether 12:34:56:78:9a:be')
        self.assertRegex(output, 'mtu 1800')
        output = check_output('ip -d link show veth-mtu-peer')
        print(output)
        self.assertRegex(output, 'link/ether 12:34:56:78:9a:bf')
        self.assertRegex(output, 'mtu 1800')
 
        touch_network_unit(
            '25-veth.netdev',
            '26-netdev-link-local-addressing-yes.network',
            '25-veth-mtu.netdev',
        )
        networkctl_reload()
        self.wait_online(
            'veth99:degraded',
            'veth-peer:degraded',
            'veth-mtu:degraded',
            'veth-mtu-peer:degraded',
        )
 
    def check_tuntap(self, attached):
        pid = networkd_pid()
        name = psutil.Process(pid).name()[:15]
 
        output = check_output('ip -d -oneline tuntap show')
        print(output)
        # fmt: off
        self.assertRegex(output, r'testtap99: tap pi (multi_queue |)vnet_hdr persist filter.*\tAttached to processes:')
        self.assertRegex(output, r'testtun99: tun pi (multi_queue |)vnet_hdr persist filter.*\tAttached to processes:')
        # fmt: on
 
        if attached:
            self.assertRegex(output, rf'testtap99: .*{name}\({pid}\)')
            self.assertRegex(output, rf'testtun99: .*{name}\({pid}\)')
            self.assertRegex(output, r'testtap99: .*systemd\(1\)')
            self.assertRegex(output, r'testtun99: .*systemd\(1\)')
 
            output = check_output('ip -d link show testtun99')
            print(output)
            self.assertIn('tun type tun pi on vnet_hdr on multi_queue', output)
            self.assertIn('UP,LOWER_UP', output)
 
            output = check_output('ip -d link show testtap99')
            print(output)
            self.assertIn('tun type tap pi on vnet_hdr on multi_queue', output)
            self.assertIn('UP,LOWER_UP', output)
 
        else:
            self.assertNotIn(f'{name}({pid})', output)
            self.assertNotIn('systemd(1)', output)
 
            for _ in range(20):
                output = check_output('ip -d link show testtun99')
                print(output)
                self.assertIn('tun type tun pi on vnet_hdr on multi_queue', output)
                if 'NO-CARRIER' in output:
                    break
                time.sleep(0.5)
            else:
                self.fail()
 
            for _ in range(20):
                output = check_output('ip -d link show testtap99')
                print(output)
                self.assertIn('tun type tap pi on vnet_hdr on multi_queue', output)
                if 'NO-CARRIER' in output:
                    break
                time.sleep(0.5)
            else:
                self.fail()
 
    def test_tuntap(self):
        copy_network_unit('25-tun.netdev', '25-tap.netdev', '26-netdev-link-local-addressing-yes.network')
        start_networkd()
        self.wait_online('testtun99:degraded', 'testtap99:degraded')
        self.networkctl_check_unit('testtap99', '25-tap', '26-netdev-link-local-addressing-yes')
        self.networkctl_check_unit('testtun99', '25-tun', '26-netdev-link-local-addressing-yes')
 
        self.check_tuntap(True)
 
        touch_network_unit('25-tun.netdev', '25-tap.netdev', '26-netdev-link-local-addressing-yes.network')
        networkctl_reload()
        self.wait_online('testtun99:degraded', 'testtap99:degraded')
 
        self.check_tuntap(True)
 
        remove_network_unit('26-netdev-link-local-addressing-yes.network')
        restart_networkd()
        self.wait_online('testtun99:degraded', 'testtap99:degraded', setup_state='unmanaged')
        self.networkctl_check_unit('testtap99', '25-tap')
        self.networkctl_check_unit('testtun99', '25-tun')
 
        self.check_tuntap(True)
 
        clear_network_units()
        unmanage_existing_links()
        restart_networkd()
        self.wait_online('testtun99:off', 'testtap99:off', setup_state='unmanaged')
        self.networkctl_check_unit('testtap99')
        self.networkctl_check_unit('testtun99')
 
        self.check_tuntap(False)
 
    @expectedFailureIfModuleIsNotAvailable('vrf')
    def test_vrf(self):
        copy_network_unit('25-vrf.netdev', '26-netdev-link-local-addressing-yes.network')
        start_networkd()
 
        self.wait_online('vrf99:carrier')
        self.networkctl_check_unit('vrf99', '25-vrf', '26-netdev-link-local-addressing-yes')
 
        touch_network_unit('25-vrf.netdev', '26-netdev-link-local-addressing-yes.network')
        networkctl()
        self.wait_online('vrf99:carrier')
 
    @expectedFailureIfModuleIsNotAvailable('vcan')
    def test_vcan(self):
        copy_network_unit(
            '25-vcan.netdev',
            '26-netdev-link-local-addressing-yes.network',
            '25-vcan98.netdev',
            '25-vcan98.network',
        )
        start_networkd()
 
        self.wait_online('vcan99:carrier', 'vcan98:carrier')
        # For can devices, 'carrier' is the default required operational state.
        self.wait_online('vcan99', 'vcan98')
        self.networkctl_check_unit('vcan99', '25-vcan', '26-netdev-link-local-addressing-yes')
        self.networkctl_check_unit('vcan98', '25-vcan98', '25-vcan98')
 
        # https://github.com/systemd/systemd/issues/30140
        output = check_output('ip -d link show vcan99')
        print(output)
        self.assertIn('mtu 16 ', output)
 
        output = check_output('ip -d link show vcan98')
        print(output)
        self.assertIn('mtu 16 ', output)
 
        touch_network_unit(
            '25-vcan.netdev',
            '26-netdev-link-local-addressing-yes.network',
            '25-vcan98.netdev',
            '25-vcan98.network',
        )
        networkctl_reload()
        self.wait_online('vcan99:carrier', 'vcan98:carrier')
 
    @expectedFailureIfModuleIsNotAvailable('vxcan')
    def test_vxcan(self):
        copy_network_unit('25-vxcan.netdev', '26-netdev-link-local-addressing-yes.network')
        start_networkd()
 
        self.wait_online('vxcan99:carrier', 'vxcan-peer:carrier')
        # For can devices, 'carrier' is the default required operational state.
        self.wait_online('vxcan99', 'vxcan-peer')
        self.networkctl_check_unit('vxcan99', '25-vxcan', '26-netdev-link-local-addressing-yes')
        self.networkctl_check_unit('vxcan-peer', '25-vxcan', '26-netdev-link-local-addressing-yes')
 
        touch_network_unit('25-vxcan.netdev', '26-netdev-link-local-addressing-yes.network')
        networkctl()
        self.wait_online('vxcan99:carrier', 'vxcan-peer:carrier')
 
    @expectedFailureIfModuleIsNotAvailable('wireguard')
    def test_wireguard(self):
        copy_credential(
            '25-wireguard-endpoint-peer0-cred.txt',
            'network.wireguard.peer0.endpoint',
        )
        copy_credential(
            '25-wireguard-preshared-key-peer2-cred.txt',
            'network.wireguard.peer2.psk',
        )
        copy_credential(
            '25-wireguard-no-peer-private-key-cred.txt',
            'network.wireguard.private.25-wireguard-no-peer',
        )
 
        copy_network_unit(
            '25-wireguard.netdev',
            '25-wireguard.network',
            '25-wireguard-23-peers.netdev',
            '25-wireguard-23-peers.network',
            '25-wireguard-public-key.txt',
            '25-wireguard-preshared-key.txt',
            '25-wireguard-private-key.txt',
            '25-wireguard-no-peer.netdev',
            '25-wireguard-no-peer.network',
        )
        start_networkd()
        self.wait_online('wg99:routable', 'wg98:routable', 'wg97:carrier')
        self.networkctl_check_unit('wg99', '25-wireguard', '25-wireguard')
        self.networkctl_check_unit('wg98', '25-wireguard-23-peers', '25-wireguard-23-peers')
        self.networkctl_check_unit('wg97', '25-wireguard-no-peer', '25-wireguard-no-peer')
 
        output = check_output('ip -4 address show dev wg99')
        print(output)
        self.assertIn('inet 192.168.124.1/24 scope global wg99', output)
 
        output = check_output('ip -4 address show dev wg99')
        print(output)
        self.assertIn('inet 169.254.11.1/24 scope link wg99', output)
 
        output = check_output('ip -6 address show dev wg99')
        print(output)
        self.assertIn('inet6 fe80::1/64 scope link', output)
 
        output = check_output('ip -4 address show dev wg98')
        print(output)
        self.assertIn('inet 192.168.123.123/24 scope global wg98', output)
 
        output = check_output('ip -6 address show dev wg98')
        print(output)
        self.assertIn('inet6 fd8d:4d6d:3ccb:500::1/64 scope global', output)
 
        output = check_output('ip -4 route show dev wg99 table 1234')
        print(output)
        self.assertIn('192.168.26.0/24 proto static scope link metric 123', output)
 
        output = check_output('ip -6 route show dev wg99 table 1234')
        print(output)
        self.assertIn('fd31:bf08:57cb::/48 proto static metric 123 pref medium', output)
 
        output = check_output('ip -6 route show dev wg98 table 1234')
        print(output)
        self.assertIn('fd8d:4d6d:3ccb:500:c79:2339:edce:ece1 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:1dbf:ca8a:32d3:dd81 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:1e54:1415:35d0:a47c proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:270d:b5dd:4a3f:8909 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:5660:679d:3532:94d8 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:6825:573f:30f3:9472 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:6f2e:6888:c6fd:dfb9 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:8d4d:bab:7280:a09a proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:900c:d437:ec27:8822 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:9742:9931:5217:18d5 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:9c11:d820:2e96:9be0 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:a072:80da:de4f:add1 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:a3f3:df38:19b0:721 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:a94b:cd6a:a32d:90e6 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:b39c:9cdc:755a:ead3 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:b684:4f81:2e3e:132e proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:bad5:495d:8e9c:3427 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:bfe5:c3c3:5d77:fcb proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:c624:6bf7:4c09:3b59 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:d4f9:5dc:9296:a1a proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:dcdd:d33b:90c9:6088 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:e2e1:ae15:103f:f376 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:500:f349:c4f0:10c1:6b4 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:c79:2339:edce::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:1dbf:ca8a:32d3::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:1e54:1415:35d0::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:270d:b5dd:4a3f::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:5660:679d:3532::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:6825:573f:30f3::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:6f2e:6888:c6fd::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:8d4d:bab:7280::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:900c:d437:ec27::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:9742:9931:5217::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:9c11:d820:2e96::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:a072:80da:de4f::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:a3f3:df38:19b0::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:a94b:cd6a:a32d::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:b39c:9cdc:755a::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:b684:4f81:2e3e::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:bad5:495d:8e9c::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:bfe5:c3c3:5d77::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:c624:6bf7:4c09::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:d4f9:5dc:9296::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:dcdd:d33b:90c9::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:e2e1:ae15:103f::/96 proto static metric 123 pref medium', output)
        self.assertIn('fd8d:4d6d:3ccb:f349:c4f0:10c1::/96 proto static metric 123 pref medium', output)
 
        if shutil.which('wg'):
            call('wg')
 
            output = check_output('wg show wg99 listen-port')
            self.assertEqual(output, '51820')
            output = check_output('wg show wg99 fwmark')
            self.assertEqual(output, '0x4d2')
            output = check_output('wg show wg99 private-key')
            self.assertEqual(output, 'EEGlnEPYJV//kbvvIqxKkQwOiS+UENyPncC4bF46ong=')
            output = check_output('wg show wg99 allowed-ips')
            # fmt: off
            self.assertIn('9uioxkGzjvGjkse3V35I9AhorWfIjBcrf3UPMS0bw2c=\t192.168.124.3/32', output)
            self.assertIn('TTiCUpCxS7zDn/ax4p5W6Evg41r8hOrnWQw2Sq6Nh10=\t192.168.124.2/32', output)
            self.assertIn('lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=\tfdbc:bae2:7871:e1fe:793:8636::/96 fdbc:bae2:7871:500:e1fe:793:8636:dad1/128', output)
            self.assertIn('RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\t192.168.26.0/24 fd31:bf08:57cb::/48', output)
            # fmt: on
            output = check_output('wg show wg99 persistent-keepalive')
            self.assertIn('9uioxkGzjvGjkse3V35I9AhorWfIjBcrf3UPMS0bw2c=\toff', output)
            self.assertIn('TTiCUpCxS7zDn/ax4p5W6Evg41r8hOrnWQw2Sq6Nh10=\toff', output)
            self.assertIn('lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=\toff', output)
            self.assertIn('RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\t20', output)
            output = check_output('wg show wg99 endpoints')
            self.assertIn('9uioxkGzjvGjkse3V35I9AhorWfIjBcrf3UPMS0bw2c=\t(none)', output)
            self.assertIn('TTiCUpCxS7zDn/ax4p5W6Evg41r8hOrnWQw2Sq6Nh10=\t(none)', output)
            self.assertIn('lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=\t(none)', output)
            self.assertIn('RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\t192.168.27.3:51820', output)
            output = check_output('wg show wg99 preshared-keys')
            # fmt: off
            self.assertIn('9uioxkGzjvGjkse3V35I9AhorWfIjBcrf3UPMS0bw2c=\t6Fsg8XN0DE6aPQgAX4r2oazEYJOGqyHUz3QRH/jCB+I=', output)
            self.assertIn('TTiCUpCxS7zDn/ax4p5W6Evg41r8hOrnWQw2Sq6Nh10=\tit7nd33chCT/tKT2ZZWfYyp43Zs+6oif72hexnSNMqA=', output)
            self.assertIn('lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=\tcPLOy1YUrEI0EMMIycPJmOo0aTu3RZnw8bL5meVD6m0=', output)
            self.assertIn('RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\tIIWIV17wutHv7t4cR6pOT91z6NSz/T8Arh0yaywhw3M=', output)
            # fmt: on
 
            output = check_output('wg show wg98 private-key')
            self.assertEqual(output, 'CJQUtcS9emY2fLYqDlpSZiE/QJyHkPWr+WHtZLZ90FU=')
 
            output = check_output('wg show wg97 listen-port')
            self.assertEqual(output, '51821')
            output = check_output('wg show wg97 fwmark')
            self.assertEqual(output, '0x4d3')
 
        touch_network_unit(
            '25-wireguard.netdev',
            '25-wireguard.network',
            '25-wireguard-23-peers.netdev',
            '25-wireguard-23-peers.network',
            '25-wireguard-public-key.txt',
            '25-wireguard-preshared-key.txt',
            '25-wireguard-private-key.txt',
            '25-wireguard-no-peer.netdev',
            '25-wireguard-no-peer.network',
        )
        networkctl_reload()
        self.wait_online('wg99:routable', 'wg98:routable', 'wg97:carrier')
 
    def test_geneve(self):
        copy_network_unit('25-geneve.netdev', '26-netdev-link-local-addressing-yes.network')
        start_networkd()
 
        self.wait_online('geneve99:degraded')
        self.networkctl_check_unit('geneve99', '25-geneve', '26-netdev-link-local-addressing-yes')
 
        output = check_output('ip -d link show geneve99')
        print(output)
        self.assertRegex(output, '192.168.22.1')
        self.assertRegex(output, '6082')
        self.assertRegex(output, 'udpcsum')
        self.assertRegex(output, 'udp6zerocsumrx')
 
        touch_network_unit('25-geneve.netdev', '26-netdev-link-local-addressing-yes.network')
        networkctl_reload()
        self.wait_online('geneve99:degraded')
 
    def _test_ipip_tunnel(self, mode):
        copy_network_unit(
            '12-dummy.netdev',
            '25-ipip.network',
            '25-ipip-tunnel.netdev',
            '25-tunnel.network',
            '25-ipip-tunnel-local-any.netdev',
            '25-tunnel-local-any.network',
            '25-ipip-tunnel-remote-any.netdev',
            '25-tunnel-remote-any.network',
            '25-ipip-tunnel-any-any.netdev',
            '25-tunnel-any-any.network',
        )
 
        if mode:
            for netdev in [
                '25-ipip-tunnel.netdev',
                '25-ipip-tunnel-local-any.netdev',
                '25-ipip-tunnel-remote-any.netdev',
                '25-ipip-tunnel-any-any.netdev',
            ]:
                with open(os.path.join(network_unit_dir, netdev), mode='a', encoding='utf-8') as f:
                    f.write(f'[Tunnel]\nMode={mode}\n')
        else:
            mode = 'ipip'  # kernel default
 
        start_networkd()
        self.wait_online(
            'ipiptun99:routable',
            'ipiptun98:routable',
            'ipiptun97:routable',
            'ipiptun96:routable',
            'dummy98:degraded',
        )
 
        output = check_output('ip -d link show ipiptun99')
        print(output)
        self.assertIn(f'ipip {mode} remote 192.169.224.239 local 192.168.223.238 dev dummy98', output)
        output = check_output('ip -d link show ipiptun98')
        print(output)
        self.assertIn(f'ipip {mode} remote 192.169.224.239 local any dev dummy98', output)
        output = check_output('ip -d link show ipiptun97')
        print(output)
        self.assertIn(f'ipip {mode} remote any local 192.168.223.238 dev dummy98', output)
        output = check_output('ip -d link show ipiptun96')
        print(output)
        self.assertIn(f'ipip {mode} remote any local any dev dummy98', output)
 
        touch_network_unit(
            '25-ipip-tunnel.netdev',
            '25-ipip-tunnel-local-any.netdev',
            '25-ipip-tunnel-remote-any.netdev',
            '25-ipip-tunnel-any-any.netdev',
        )
        networkctl_reload()
        self.wait_online(
            'ipiptun99:routable',
            'ipiptun98:routable',
            'ipiptun97:routable',
            'ipiptun96:routable',
            'dummy98:degraded',
        )
 
    def test_ipip_tunnel(self):
        first = True
        for mode in [None, 'ipip', 'any']:
            if first:
                first = False
            else:
                self.tearDown()
 
            print(f'### test_ipip_tunnel(mode={mode})')
            with self.subTest(mode=mode):
                self._test_ipip_tunnel(mode)
 
    def test_gre_tunnel(self):
        copy_network_unit(
            '12-dummy.netdev',
            '25-gretun.network',
            '25-gre-tunnel.netdev',
            '25-tunnel.network',
            '25-gre-tunnel-local-any.netdev',
            '25-tunnel-local-any.network',
            '25-gre-tunnel-remote-any.netdev',
            '25-tunnel-remote-any.network',
            '25-gre-tunnel-any-any.netdev',
            '25-tunnel-any-any.network',
        )
        start_networkd()
        self.wait_online(
            'gretun99:routable',
            'gretun98:routable',
            'gretun97:routable',
            'gretun96:routable',
            'dummy98:degraded',
        )
        self.networkctl_check_unit('gretun99', '25-gre-tunnel', '25-tunnel')
        self.networkctl_check_unit('gretun98', '25-gre-tunnel-local-any', '25-tunnel-local-any')
        self.networkctl_check_unit('gretun97', '25-gre-tunnel-remote-any', '25-tunnel-remote-any')
        self.networkctl_check_unit('gretun96', '25-gre-tunnel-any-any', '25-tunnel-any-any')
        self.networkctl_check_unit('dummy98', '12-dummy', '25-gretun')
 
        output = check_output('ip -d link show gretun99')
        print(output)
        self.assertRegex(output, 'gre remote 10.65.223.239 local 10.65.223.238 dev dummy98')
        self.assertRegex(output, 'ikey 1.2.3.103')
        self.assertRegex(output, 'okey 1.2.4.103')
        self.assertRegex(output, 'iseq')
        self.assertRegex(output, 'oseq')
        output = check_output('ip -d link show gretun98')
        print(output)
        self.assertRegex(output, 'gre remote 10.65.223.239 local any dev dummy98')
        self.assertRegex(output, 'ikey 0.0.0.104')
        self.assertRegex(output, 'okey 0.0.0.104')
        self.assertNotRegex(output, 'iseq')
        self.assertNotRegex(output, 'oseq')
        output = check_output('ip -d link show gretun97')
        print(output)
        self.assertRegex(output, 'gre remote any local 10.65.223.238 dev dummy98')
        self.assertRegex(output, 'ikey 0.0.0.105')
        self.assertRegex(output, 'okey 0.0.0.105')
        self.assertNotRegex(output, 'iseq')
        self.assertNotRegex(output, 'oseq')
        output = check_output('ip -d link show gretun96')
        print(output)
        self.assertRegex(output, 'gre remote any local any dev dummy98')
        self.assertRegex(output, 'ikey 0.0.0.106')
        self.assertRegex(output, 'okey 0.0.0.106')
        self.assertNotRegex(output, 'iseq')
        self.assertNotRegex(output, 'oseq')
 
        touch_network_unit(
            '25-gre-tunnel.netdev',
            '25-gre-tunnel-local-any.netdev',
            '25-gre-tunnel-remote-any.netdev',
            '25-gre-tunnel-any-any.netdev',
        )
        networkctl_reload()
        self.wait_online(
            'gretun99:routable',
            'gretun98:routable',
            'gretun97:routable',
            'gretun96:routable',
            'dummy98:degraded',
        )
 
    def test_ip6gre_tunnel(self):
        copy_network_unit(
            '12-dummy.netdev',
            '25-ip6gretun.network',
            '25-ip6gre-tunnel.netdev',
            '25-tunnel.network',
            '25-ip6gre-tunnel-local-any.netdev',
            '25-tunnel-local-any.network',
            '25-ip6gre-tunnel-remote-any.netdev',
            '25-tunnel-remote-any.network',
            '25-ip6gre-tunnel-any-any.netdev',
            '25-tunnel-any-any.network',
        )
        start_networkd()
 
        self.wait_online(
            'ip6gretun99:routable',
            'ip6gretun98:routable',
            'ip6gretun97:routable',
            'ip6gretun96:routable',
            'dummy98:degraded',
        )
 
        output = check_output('ip -d link show ip6gretun99')
        print(output)
        self.assertRegex(output, 'ip6gre remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')  # fmt: skip
        output = check_output('ip -d link show ip6gretun98')
        print(output)
        self.assertRegex(output, 'ip6gre remote 2001:473:fece:cafe::5179 local any dev dummy98')
        output = check_output('ip -d link show ip6gretun97')
        print(output)
        self.assertRegex(output, 'ip6gre remote any local 2a00:ffde:4567:edde::4987 dev dummy98')
        output = check_output('ip -d link show ip6gretun96')
        print(output)