No OneTemporary
Actions

Size

50 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/interface-definitions/include/constraint/interface-name.xml.i b/interface-definitions/include/constraint/interface-name.xml.i
	index 1b14eabf5..3e7c4e667 100644
	--- a/interface-definitions/include/constraint/interface-name.xml.i
	+++ b/interface-definitions/include/constraint/interface-name.xml.i
	@@ -1,4 +1,4 @@
	<!-- include start from constraint/interface-name.xml.i -->
	-<regex>(bond\|br\|dum\|en\|ersp\|eth\|gnv\|ifb\|lan\|l2tp\|l2tpeth\|macsec\|peth\|ppp\|pppoe\|pptp\|sstp\|tun\|veth\|vti\|vtun\|vxlan\|wg\|wlan\|wwan)[0-9]+(.\d+)?\|lo</regex>
	+<regex>(bond\|br\|dum\|en\|ersp\|eth\|gnv\|ifb\|ipoe\|lan\|l2tp\|l2tpeth\|macsec\|peth\|ppp\|pppoe\|pptp\|sstp\|sstpc\|tun\|veth\|vti\|vtun\|vxlan\|wg\|wlan\|wwan)[0-9]+(.\d+)?\|lo</regex>
	<validator name="file-path --lookup-path /sys/class/net --directory"/>
	<!-- include end -->
	diff --git a/python/vyos/configverify.py b/python/vyos/configverify.py
	index 27055c863..85423142d 100644
	--- a/python/vyos/configverify.py
	+++ b/python/vyos/configverify.py
	@@ -1,462 +1,467 @@
	# Copyright 2020-2023 VyOS maintainers and contributors <maintainers@vyos.io>
	#
	# This library is free software; you can redistribute it and/or
	# modify it under the terms of the GNU Lesser General Public
	# License as published by the Free Software Foundation; either
	# version 2.1 of the License, or (at your option) any later version.
	#
	# This library is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	# Lesser General Public License for more details.
	#
	# You should have received a copy of the GNU Lesser General Public
	# License along with this library. If not, see <http://www.gnu.org/licenses/>.

	# The sole purpose of this module is to hold common functions used in
	# all kinds of implementations to verify the CLI configuration.
	# It is started by migrating the interfaces to the new get_config_dict()
	# approach which will lead to a lot of code that can be reused.

	# NOTE: imports should be as local as possible to the function which
	# makes use of it!

	from vyos import ConfigError
	from vyos.utils.dict import dict_search
	from vyos.utils.dict import dict_search_recursive

	def verify_mtu(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation if the specified MTU can be used by the underlaying
	hardware.
	"""
	from vyos.ifconfig import Interface
	if 'mtu' in config:
	mtu = int(config['mtu'])

	tmp = Interface(config['ifname'])
	# Not all interfaces support min/max MTU
	# https://vyos.dev/T5011
	try:
	min_mtu = tmp.get_min_mtu()
	max_mtu = tmp.get_max_mtu()
	except: # Fallback to defaults
	min_mtu = 68
	max_mtu = 9000

	if mtu < min_mtu:
	raise ConfigError(f'Interface MTU too low, ' \
	f'minimum supported MTU is {min_mtu}!')
	if mtu > max_mtu:
	raise ConfigError(f'Interface MTU too high, ' \
	f'maximum supported MTU is {max_mtu}!')

	def verify_mtu_parent(config, parent):
	if 'mtu' not in config or 'mtu' not in parent:
	return

	mtu = int(config['mtu'])
	parent_mtu = int(parent['mtu'])
	if mtu > parent_mtu:
	raise ConfigError(f'Interface MTU ({mtu}) too high, ' \
	f'parent interface MTU is {parent_mtu}!')

	def verify_mtu_ipv6(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation if the specified MTU can be used when IPv6 is
	configured on the interface. IPv6 requires a 1280 bytes MTU.
	"""
	from vyos.template import is_ipv6
	if 'mtu' in config:
	# IPv6 minimum required link mtu
	min_mtu = 1280
	if int(config['mtu']) < min_mtu:
	interface = config['ifname']
	error_msg = f'IPv6 address will be configured on interface "{interface}",\n' \
	f'the required minimum MTU is {min_mtu}!'

	if 'address' in config:
	for address in config['address']:
	if address in ['dhcpv6'] or is_ipv6(address):
	raise ConfigError(error_msg)

	tmp = dict_search('ipv6.address.no_default_link_local', config)
	if tmp == None: raise ConfigError('link-local ' + error_msg)

	tmp = dict_search('ipv6.address.autoconf', config)
	if tmp != None: raise ConfigError(error_msg)

	tmp = dict_search('ipv6.address.eui64', config)
	if tmp != None: raise ConfigError(error_msg)

	def verify_vrf(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of VRF configuration.
	"""
	from netifaces import interfaces
	if 'vrf' in config and config['vrf'] != 'default':
	if config['vrf'] not in interfaces():
	raise ConfigError('VRF "{vrf}" does not exist'.format(**config))

	if 'is_bridge_member' in config:
	raise ConfigError(
	'Interface "{ifname}" cannot be both a member of VRF "{vrf}" '
	'and bridge "{is_bridge_member}"!'.format(**config))

	def verify_bond_bridge_member(config):
	"""
	Checks if interface has a VRF configured and is also part of a bond or
	bridge, which is not allowed!
	"""
	if 'vrf' in config:
	ifname = config['ifname']
	if 'is_bond_member' in config:
	raise ConfigError(f'Can not add interface "{ifname}" to bond, it has a VRF assigned!')
	if 'is_bridge_member' in config:
	raise ConfigError(f'Can not add interface "{ifname}" to bridge, it has a VRF assigned!')

	def verify_tunnel(config):
	"""
	This helper is used to verify the common part of the tunnel
	"""
	from vyos.template import is_ipv4
	from vyos.template import is_ipv6

	if 'encapsulation' not in config:
	raise ConfigError('Must configure the tunnel encapsulation for '\
	'{ifname}!'.format(**config))

	if 'source_address' not in config and 'source_interface' not in config:
	raise ConfigError('source-address or source-interface required for tunnel!')

	if 'remote' not in config and config['encapsulation'] != 'gre':
	raise ConfigError('remote ip address is mandatory for tunnel')

	if config['encapsulation'] in ['ipip6', 'ip6ip6', 'ip6gre', 'ip6gretap', 'ip6erspan']:
	error_ipv6 = 'Encapsulation mode requires IPv6'
	if 'source_address' in config and not is_ipv6(config['source_address']):
	raise ConfigError(f'{error_ipv6} source-address')

	if 'remote' in config and not is_ipv6(config['remote']):
	raise ConfigError(f'{error_ipv6} remote')
	else:
	error_ipv4 = 'Encapsulation mode requires IPv4'
	if 'source_address' in config and not is_ipv4(config['source_address']):
	raise ConfigError(f'{error_ipv4} source-address')

	if 'remote' in config and not is_ipv4(config['remote']):
	raise ConfigError(f'{error_ipv4} remote address')

	if config['encapsulation'] in ['sit', 'gretap', 'ip6gretap']:
	if 'source_interface' in config:
	encapsulation = config['encapsulation']
	raise ConfigError(f'Option source-interface can not be used with ' \
	f'encapsulation "{encapsulation}"!')
	elif config['encapsulation'] == 'gre':
	if 'source_address' in config and is_ipv6(config['source_address']):
	raise ConfigError('Can not use local IPv6 address is for mGRE tunnels')

	def verify_eapol(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of EAPoL configuration.
	"""
	if 'eapol' in config:
	if 'certificate' not in config['eapol']:
	raise ConfigError('Certificate must be specified when using EAPoL!')

	if 'pki' not in config or 'certificate' not in config['pki']:
	raise ConfigError('Invalid certificate specified for EAPoL')

	cert_name = config['eapol']['certificate']
	if cert_name not in config['pki']['certificate']:
	raise ConfigError('Invalid certificate specified for EAPoL')

	cert = config['pki']['certificate'][cert_name]

	if 'certificate' not in cert or 'private' not in cert or 'key' not in cert['private']:
	raise ConfigError('Invalid certificate/private key specified for EAPoL')

	if 'password_protected' in cert['private']:
	raise ConfigError('Encrypted private key cannot be used for EAPoL')

	if 'ca_certificate' in config['eapol']:
	if 'ca' not in config['pki']:
	raise ConfigError('Invalid CA certificate specified for EAPoL')

	for ca_cert_name in config['eapol']['ca_certificate']:
	if ca_cert_name not in config['pki']['ca']:
	raise ConfigError('Invalid CA certificate specified for EAPoL')

	ca_cert = config['pki']['ca'][ca_cert_name]

	if 'certificate' not in ca_cert:
	raise ConfigError('Invalid CA certificate specified for EAPoL')

	def verify_mirror_redirect(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of mirror and redirect interface configuration via tc(8)

	It makes no sense to mirror traffic back at yourself!
	"""
	import os
	if {'mirror', 'redirect'} <= set(config):
	raise ConfigError('Mirror and redirect can not be enabled at the same time!')

	if 'mirror' in config:
	for direction, mirror_interface in config['mirror'].items():
	if not os.path.exists(f'/sys/class/net/{mirror_interface}'):
	raise ConfigError(f'Requested mirror interface "{mirror_interface}" '\
	'does not exist!')

	if mirror_interface == config['ifname']:
	raise ConfigError(f'Can not mirror "{direction}" traffic back '\
	'the originating interface!')

	if 'redirect' in config:
	redirect_ifname = config['redirect']
	if not os.path.exists(f'/sys/class/net/{redirect_ifname}'):
	raise ConfigError(f'Requested redirect interface "{redirect_ifname}" '\
	'does not exist!')

	if ('mirror' in config or 'redirect' in config) and dict_search('traffic_policy.in', config) is not None:
	# XXX: support combination of limiting and redirect/mirror - this is an
	# artificial limitation
	raise ConfigError('Can not use ingress policy together with mirror or redirect!')

	def verify_authentication(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of authentication for either PPPoE or WWAN interfaces.

	If authentication CLI option is defined, both username and password must
	be set!
	"""
	if 'authentication' not in config:
	return
	if not {'username', 'password'} <= set(config['authentication']):
	raise ConfigError('Authentication requires both username and ' \
	'password to be set!')

	def verify_address(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of IP address assignment when interface is part
	of a bridge or bond.
	"""
	if {'is_bridge_member', 'address'} <= set(config):
	interface = config['ifname']
	bridge_name = next(iter(config['is_bridge_member']))
	raise ConfigError(f'Cannot assign address to interface "{interface}" '
	f'as it is a member of bridge "{bridge_name}"!')

	def verify_bridge_delete(config):
	"""
	Common helper function used by interface implementations to
	perform recurring validation of IP address assignmenr
	when interface also is part of a bridge.
	"""
	if 'is_bridge_member' in config:
	interface = config['ifname']
	bridge_name = next(iter(config['is_bridge_member']))
	raise ConfigError(f'Interface "{interface}" cannot be deleted as it '
	f'is a member of bridge "{bridge_name}"!')

	def verify_interface_exists(ifname):
	"""
	Common helper function used by interface implementations to perform
	recurring validation if an interface actually exists.
	"""
	import os
	if not os.path.exists(f'/sys/class/net/{ifname}'):
	raise ConfigError(f'Interface "{ifname}" does not exist!')

	def verify_source_interface(config):
	"""
	Common helper function used by interface implementations to
	perform recurring validation of the existence of a source-interface
	required by e.g. peth/MACvlan, MACsec ...
	"""
	+ import re
	from netifaces import interfaces
	- if 'source_interface' not in config:
	- raise ConfigError('Physical source-interface required for '
	- 'interface "{ifname}"'.format(**config))

	- if config['source_interface'] not in interfaces():
	- raise ConfigError('Specified source-interface {source_interface} does '
	- 'not exist'.format(**config))
	+ ifname = config['ifname']
	+ if 'source_interface' not in config:
	+ raise ConfigError(f'Physical source-interface required for "{ifname}"!')

	src_ifname = config['source_interface']
	+ # We do not allow sourcing other interfaces (e.g. tunnel) from dynamic interfaces
	+ tmp = re.compile(r'(ppp\|pppoe\|sstpc\|l2tp\|ipoe)[0-9]+')
	+ if tmp.match(src_ifname):
	+ raise ConfigError(f'Can not source "{ifname}" from dynamic interface "{src_ifname}"!')
	+
	+ if src_ifname not in interfaces():
	+ raise ConfigError(f'Specified source-interface {src_ifname} does not exist')
	+
	if 'source_interface_is_bridge_member' in config:
	bridge_name = next(iter(config['source_interface_is_bridge_member']))
	raise ConfigError(f'Invalid source-interface "{src_ifname}". Interface '
	f'is already a member of bridge "{bridge_name}"!')

	if 'source_interface_is_bond_member' in config:
	bond_name = next(iter(config['source_interface_is_bond_member']))
	raise ConfigError(f'Invalid source-interface "{src_ifname}". Interface '
	f'is already a member of bond "{bond_name}"!')

	if 'is_source_interface' in config:
	tmp = config['is_source_interface']
	- src_ifname = config['source_interface']
	raise ConfigError(f'Can not use source-interface "{src_ifname}", it already ' \
	f'belongs to interface "{tmp}"!')

	def verify_dhcpv6(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of DHCPv6 options which are mutually exclusive.
	"""
	if 'dhcpv6_options' in config:
	if {'parameters_only', 'temporary'} <= set(config['dhcpv6_options']):
	raise ConfigError('DHCPv6 temporary and parameters-only options '
	'are mutually exclusive!')

	# It is not allowed to have duplicate SLA-IDs as those identify an
	# assigned IPv6 subnet from a delegated prefix
	for pd in (dict_search('dhcpv6_options.pd', config) or []):
	sla_ids = []
	interfaces = dict_search(f'dhcpv6_options.pd.{pd}.interface', config)

	if not interfaces:
	raise ConfigError('DHCPv6-PD requires an interface where to assign '
	'the delegated prefix!')

	for count, interface in enumerate(interfaces):
	if 'sla_id' in interfaces[interface]:
	sla_ids.append(interfaces[interface]['sla_id'])
	else:
	sla_ids.append(str(count))

	# Check for duplicates
	duplicates = [x for n, x in enumerate(sla_ids) if x in sla_ids[:n]]
	if duplicates:
	raise ConfigError('Site-Level Aggregation Identifier (SLA-ID) '
	'must be unique per prefix-delegation!')

	def verify_vlan_config(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of interface VLANs
	"""

	# VLAN and Q-in-Q IDs are not allowed to overlap
	if 'vif' in config and 'vif_s' in config:
	duplicate = list(set(config['vif']) & set(config['vif_s']))
	if duplicate:
	raise ConfigError(f'Duplicate VLAN id "{duplicate[0]}" used for vif and vif-s interfaces!')

	parent_ifname = config['ifname']
	# 802.1q VLANs
	for vlan_id in config.get('vif', {}):
	vlan = config['vif'][vlan_id]
	vlan['ifname'] = f'{parent_ifname}.{vlan_id}'

	verify_dhcpv6(vlan)
	verify_address(vlan)
	verify_vrf(vlan)
	verify_mirror_redirect(vlan)
	verify_mtu_parent(vlan, config)

	# 802.1ad (Q-in-Q) VLANs
	for s_vlan_id in config.get('vif_s', {}):
	s_vlan = config['vif_s'][s_vlan_id]
	s_vlan['ifname'] = f'{parent_ifname}.{s_vlan_id}'

	verify_dhcpv6(s_vlan)
	verify_address(s_vlan)
	verify_vrf(s_vlan)
	verify_mirror_redirect(s_vlan)
	verify_mtu_parent(s_vlan, config)

	for c_vlan_id in s_vlan.get('vif_c', {}):
	c_vlan = s_vlan['vif_c'][c_vlan_id]
	c_vlan['ifname'] = f'{parent_ifname}.{s_vlan_id}.{c_vlan_id}'

	verify_dhcpv6(c_vlan)
	verify_address(c_vlan)
	verify_vrf(c_vlan)
	verify_mirror_redirect(c_vlan)
	verify_mtu_parent(c_vlan, config)
	verify_mtu_parent(c_vlan, s_vlan)


	def verify_diffie_hellman_length(file, min_keysize):
	""" Verify Diffie-Hellamn keypair length given via file. It must be greater
	then or equal to min_keysize """
	import os
	import re
	from vyos.utils.process import cmd

	try:
	keysize = str(min_keysize)
	except:
	return False

	if os.path.exists(file):
	out = cmd(f'openssl dhparam -inform PEM -in {file} -text')
	prog = re.compile('\d+\s+bit')
	if prog.search(out):
	bits = prog.search(out)[0].split()[0]
	if int(bits) >= int(min_keysize):
	return True

	return False

	def verify_common_route_maps(config):
	"""
	Common helper function used by routing protocol implementations to perform
	recurring validation if the specified route-map for either zebra to kernel
	installation exists (this is the top-level route_map key) or when a route
	is redistributed with a route-map that it exists!
	"""
	# XXX: This function is called in combination with a previous call to:
	# tmp = conf.get_config_dict(['policy']) - see protocols_ospf.py as example.
	# We should NOT call this with the key_mangling option as this would rename
	# route-map hypens '-' to underscores '_' and one could no longer distinguish
	# what should have been the "proper" route-map name, as foo-bar and foo_bar
	# are two entire different route-map instances!
	for route_map in ['route-map', 'route_map']:
	if route_map not in config:
	continue
	tmp = config[route_map]
	# Check if the specified route-map exists, if not error out
	if dict_search(f'policy.route-map.{tmp}', config) == None:
	raise ConfigError(f'Specified route-map "{tmp}" does not exist!')

	if 'redistribute' in config:
	for protocol, protocol_config in config['redistribute'].items():
	if 'route_map' in protocol_config:
	verify_route_map(protocol_config['route_map'], config)

	def verify_route_map(route_map_name, config):
	"""
	Common helper function used by routing protocol implementations to perform
	recurring validation if a specified route-map exists!
	"""
	# Check if the specified route-map exists, if not error out
	if dict_search(f'policy.route-map.{route_map_name}', config) == None:
	raise ConfigError(f'Specified route-map "{route_map_name}" does not exist!')

	def verify_prefix_list(prefix_list, config, version=''):
	"""
	Common helper function used by routing protocol implementations to perform
	recurring validation if a specified prefix-list exists!
	"""
	# Check if the specified prefix-list exists, if not error out
	if dict_search(f'policy.prefix-list{version}.{prefix_list}', config) == None:
	raise ConfigError(f'Specified prefix-list{version} "{prefix_list}" does not exist!')

	def verify_access_list(access_list, config, version=''):
	"""
	Common helper function used by routing protocol implementations to perform
	recurring validation if a specified prefix-list exists!
	"""
	# Check if the specified ACL exists, if not error out
	if dict_search(f'policy.access-list{version}.{access_list}', config) == None:
	raise ConfigError(f'Specified access-list{version} "{access_list}" does not exist!')
	diff --git a/smoketest/scripts/cli/test_interfaces_tunnel.py b/smoketest/scripts/cli/test_interfaces_tunnel.py
	index 2a7a519fd..dd9f1d2d1 100755
	--- a/smoketest/scripts/cli/test_interfaces_tunnel.py
	+++ b/smoketest/scripts/cli/test_interfaces_tunnel.py
	@@ -1,397 +1,413 @@
	#!/usr/bin/env python3
	#
	# Copyright (C) 2020-2022 VyOS maintainers and contributors
	#
	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License version 2 or later as
	# published by the Free Software Foundation.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program. If not, see <http://www.gnu.org/licenses/>.

	import unittest

	from base_interfaces_test import BasicInterfaceTest

	from vyos.configsession import ConfigSessionError
	from vyos.utils.network import get_interface_config
	from vyos.template import inc_ip

	remote_ip4 = '192.0.2.100'
	remote_ip6 = '2001:db8::ffff'
	source_if = 'dum2222'
	mtu = 1476

	class TunnelInterfaceTest(BasicInterfaceTest.TestCase):
	@classmethod
	def setUpClass(cls):
	cls._base_path = ['interfaces', 'tunnel']
	cls.local_v4 = '192.0.2.1'
	cls.local_v6 = '2001:db8::1'
	cls._options = {
	'tun10': ['encapsulation ipip', 'remote 192.0.2.10', 'source-address ' + cls.local_v4],
	'tun20': ['encapsulation gre', 'remote 192.0.2.20', 'source-address ' + cls.local_v4],
	}
	cls._interfaces = list(cls._options)
	# call base-classes classmethod
	super(TunnelInterfaceTest, cls).setUpClass()

	# create some test interfaces
	cls.cli_set(cls, ['interfaces', 'dummy', source_if, 'address', cls.local_v4 + '/32'])
	cls.cli_set(cls, ['interfaces', 'dummy', source_if, 'address', cls.local_v6 + '/128'])

	@classmethod
	def tearDownClass(cls):
	cls.cli_delete(cls, ['interfaces', 'dummy', source_if])
	super().tearDownClass()

	def test_ipv4_encapsulations(self):
	# When running tests ensure that for certain encapsulation types the
	# local and remote IP address is actually an IPv4 address

	interface = f'tun1000'
	local_if_addr = f'10.10.200.1/24'
	for encapsulation in ['ipip', 'sit', 'gre', 'gretap']:
	self.cli_set(self._base_path + [interface, 'address', local_if_addr])
	self.cli_set(self._base_path + [interface, 'encapsulation', encapsulation])
	self.cli_set(self._base_path + [interface, 'source-address', self.local_v6])
	self.cli_set(self._base_path + [interface, 'remote', remote_ip6])

	# Encapsulation mode requires IPv4 source-address
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_set(self._base_path + [interface, 'source-address', self.local_v4])

	# Encapsulation mode requires IPv4 remote
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_set(self._base_path + [interface, 'remote', remote_ip4])
	self.cli_set(self._base_path + [interface, 'source-interface', source_if])

	# Source interface can not be used with sit and gretap
	if encapsulation in ['sit', 'gretap']:
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_delete(self._base_path + [interface, 'source-interface'])

	# Check if commit is ok
	self.cli_commit()

	conf = get_interface_config(interface)
	if encapsulation not in ['sit', 'gretap']:
	self.assertEqual(source_if, conf['link'])

	self.assertEqual(interface, conf['ifname'])
	self.assertEqual(mtu, conf['mtu'])
	self.assertEqual(encapsulation, conf['linkinfo']['info_kind'])
	self.assertEqual(self.local_v4, conf['linkinfo']['info_data']['local'])
	self.assertEqual(remote_ip4, conf['linkinfo']['info_data']['remote'])
	self.assertTrue(conf['linkinfo']['info_data']['pmtudisc'])

	# cleanup this instance
	self.cli_delete(self._base_path + [interface])
	self.cli_commit()

	def test_ipv6_encapsulations(self):
	# When running tests ensure that for certain encapsulation types the
	# local and remote IP address is actually an IPv6 address

	interface = f'tun1010'
	local_if_addr = f'10.10.200.1/24'
	for encapsulation in ['ipip6', 'ip6ip6', 'ip6gre', 'ip6gretap']:
	self.cli_set(self._base_path + [interface, 'address', local_if_addr])
	self.cli_set(self._base_path + [interface, 'encapsulation', encapsulation])
	self.cli_set(self._base_path + [interface, 'source-address', self.local_v4])
	self.cli_set(self._base_path + [interface, 'remote', remote_ip4])

	# Encapsulation mode requires IPv6 source-address
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_set(self._base_path + [interface, 'source-address', self.local_v6])

	# Encapsulation mode requires IPv6 remote
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_set(self._base_path + [interface, 'remote', remote_ip6])

	# Configure Tunnel Source interface
	self.cli_set(self._base_path + [interface, 'source-interface', source_if])
	# Source interface can not be used with ip6gretap
	if encapsulation in ['ip6gretap']:
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_delete(self._base_path + [interface, 'source-interface'])

	# Check if commit is ok
	self.cli_commit()

	conf = get_interface_config(interface)
	if encapsulation not in ['ip6gretap']:
	self.assertEqual(source_if, conf['link'])

	self.assertEqual(interface, conf['ifname'])
	self.assertEqual(mtu, conf['mtu'])

	# Not applicable for ip6gre
	if 'proto' in conf['linkinfo']['info_data']:
	self.assertEqual(encapsulation, conf['linkinfo']['info_data']['proto'])

	# remap encapsulation protocol(s) only for ipip6, ip6ip6
	if encapsulation in ['ipip6', 'ip6ip6']:
	encapsulation = 'ip6tnl'

	self.assertEqual(encapsulation, conf['linkinfo']['info_kind'])
	self.assertEqual(self.local_v6, conf['linkinfo']['info_data']['local'])
	self.assertEqual(remote_ip6, conf['linkinfo']['info_data']['remote'])

	# cleanup this instance
	self.cli_delete(self._base_path + [interface])
	self.cli_commit()

	def test_tunnel_parameters_gre(self):
	interface = f'tun1030'
	gre_key = '10'
	encapsulation = 'gre'
	tos = '20'

	self.cli_set(self._base_path + [interface, 'encapsulation', encapsulation])
	self.cli_set(self._base_path + [interface, 'source-address', self.local_v4])
	self.cli_set(self._base_path + [interface, 'remote', remote_ip4])

	self.cli_set(self._base_path + [interface, 'parameters', 'ip', 'no-pmtu-discovery'])
	self.cli_set(self._base_path + [interface, 'parameters', 'ip', 'key', gre_key])
	self.cli_set(self._base_path + [interface, 'parameters', 'ip', 'tos', tos])
	self.cli_set(self._base_path + [interface, 'parameters', 'ip', 'ttl', '0'])

	# Check if commit is ok
	self.cli_commit()

	conf = get_interface_config(interface)
	self.assertEqual(mtu, conf['mtu'])
	self.assertEqual(interface, conf['ifname'])
	self.assertEqual(encapsulation, conf['linkinfo']['info_kind'])
	self.assertEqual(self.local_v4, conf['linkinfo']['info_data']['local'])
	self.assertEqual(remote_ip4, conf['linkinfo']['info_data']['remote'])
	self.assertEqual(0, conf['linkinfo']['info_data']['ttl'])
	self.assertFalse( conf['linkinfo']['info_data']['pmtudisc'])

	def test_gretap_parameters_change(self):
	interface = f'tun1040'
	gre_key = '10'
	encapsulation = 'gretap'
	tos = '20'

	self.cli_set(self._base_path + [interface, 'encapsulation', encapsulation])
	self.cli_set(self._base_path + [interface, 'source-address', self.local_v4])
	self.cli_set(self._base_path + [interface, 'remote', remote_ip4])

	# Check if commit is ok
	self.cli_commit()

	conf = get_interface_config(interface)
	self.assertEqual(mtu, conf['mtu'])
	self.assertEqual(interface, conf['ifname'])
	self.assertEqual(encapsulation, conf['linkinfo']['info_kind'])
	self.assertEqual(self.local_v4, conf['linkinfo']['info_data']['local'])
	self.assertEqual(remote_ip4, conf['linkinfo']['info_data']['remote'])
	self.assertEqual(64, conf['linkinfo']['info_data']['ttl'])

	# Change remote ip address (inc host by 2
	new_remote = inc_ip(remote_ip4, 2)
	self.cli_set(self._base_path + [interface, 'remote', new_remote])
	# Check if commit is ok
	self.cli_commit()

	conf = get_interface_config(interface)
	self.assertEqual(new_remote, conf['linkinfo']['info_data']['remote'])

	def test_erspan_v1(self):
	interface = f'tun1070'
	encapsulation = 'erspan'
	ip_key = '77'
	idx = '20'

	self.cli_set(self._base_path + [interface, 'encapsulation', encapsulation])
	self.cli_set(self._base_path + [interface, 'source-address', self.local_v4])
	self.cli_set(self._base_path + [interface, 'remote', remote_ip4])

	self.cli_set(self._base_path + [interface, 'parameters', 'erspan', 'index', idx])

	# ERSPAN requires ip key parameter
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_set(self._base_path + [interface, 'parameters', 'ip', 'key', ip_key])

	# Check if commit is ok
	self.cli_commit()

	conf = get_interface_config(interface)
	self.assertEqual(mtu, conf['mtu'])
	self.assertEqual(interface, conf['ifname'])
	self.assertEqual(encapsulation, conf['linkinfo']['info_kind'])
	self.assertEqual(self.local_v4, conf['linkinfo']['info_data']['local'])
	self.assertEqual(remote_ip4, conf['linkinfo']['info_data']['remote'])
	self.assertEqual(64, conf['linkinfo']['info_data']['ttl'])
	self.assertEqual(f'0.0.0.{ip_key}', conf['linkinfo']['info_data']['ikey'])
	self.assertEqual(f'0.0.0.{ip_key}', conf['linkinfo']['info_data']['okey'])
	self.assertEqual(int(idx), conf['linkinfo']['info_data']['erspan_index'])
	# version defaults to 1
	self.assertEqual(1, conf['linkinfo']['info_data']['erspan_ver'])
	self.assertTrue( conf['linkinfo']['info_data']['iseq'])
	self.assertTrue( conf['linkinfo']['info_data']['oseq'])

	# Change remote ip address (inc host by 2
	new_remote = inc_ip(remote_ip4, 2)
	self.cli_set(self._base_path + [interface, 'remote', new_remote])
	# Check if commit is ok
	self.cli_commit()

	conf = get_interface_config(interface)
	self.assertEqual(new_remote, conf['linkinfo']['info_data']['remote'])

	def test_ip6erspan_v2(self):
	interface = f'tun1070'
	encapsulation = 'ip6erspan'
	ip_key = '77'
	erspan_ver = 2
	direction = 'ingress'

	self.cli_set(self._base_path + [interface, 'encapsulation', encapsulation])
	self.cli_set(self._base_path + [interface, 'source-address', self.local_v6])
	self.cli_set(self._base_path + [interface, 'remote', remote_ip6])

	# ERSPAN requires ip key parameter
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_set(self._base_path + [interface, 'parameters', 'ip', 'key', ip_key])

	self.cli_set(self._base_path + [interface, 'parameters', 'erspan', 'version', str(erspan_ver)])

	# ERSPAN index is not valid on version 2
	self.cli_set(self._base_path + [interface, 'parameters', 'erspan', 'index', '10'])
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_delete(self._base_path + [interface, 'parameters', 'erspan', 'index'])

	# ERSPAN requires direction to be set
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_set(self._base_path + [interface, 'parameters', 'erspan', 'direction', direction])

	# Check if commit is ok
	self.cli_commit()

	conf = get_interface_config(interface)
	self.assertEqual(mtu, conf['mtu'])
	self.assertEqual(interface, conf['ifname'])
	self.assertEqual(encapsulation, conf['linkinfo']['info_kind'])
	self.assertEqual(self.local_v6, conf['linkinfo']['info_data']['local'])
	self.assertEqual(remote_ip6, conf['linkinfo']['info_data']['remote'])
	self.assertEqual(64, conf['linkinfo']['info_data']['ttl'])
	self.assertEqual(f'0.0.0.{ip_key}', conf['linkinfo']['info_data']['ikey'])
	self.assertEqual(f'0.0.0.{ip_key}', conf['linkinfo']['info_data']['okey'])
	self.assertEqual(erspan_ver, conf['linkinfo']['info_data']['erspan_ver'])
	self.assertEqual(direction, conf['linkinfo']['info_data']['erspan_dir'])
	self.assertTrue( conf['linkinfo']['info_data']['iseq'])
	self.assertTrue( conf['linkinfo']['info_data']['oseq'])

	# Change remote ip address (inc host by 2
	new_remote = inc_ip(remote_ip6, 2)
	self.cli_set(self._base_path + [interface, 'remote', new_remote])
	# Check if commit is ok
	self.cli_commit()

	conf = get_interface_config(interface)
	self.assertEqual(new_remote, conf['linkinfo']['info_data']['remote'])

	def test_tunnel_src_any_gre_key(self):
	interface = f'tun1280'
	encapsulation = 'gre'
	src_addr = '0.0.0.0'
	key = '127'

	self.cli_set(self._base_path + [interface, 'encapsulation', encapsulation])
	self.cli_set(self._base_path + [interface, 'source-address', src_addr])
	# GRE key must be supplied with a 0.0.0.0 source address
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_set(self._base_path + [interface, 'parameters', 'ip', 'key', key])

	self.cli_commit()

	def test_multiple_gre_tunnel_same_remote(self):
	tunnels = {
	'tun10' : {
	'encapsulation' : 'gre',
	'source_interface' : source_if,
	'remote' : '1.2.3.4',
	},
	'tun20' : {
	'encapsulation' : 'gre',
	'source_interface' : source_if,
	'remote' : '1.2.3.4',
	},
	}

	for tunnel, tunnel_config in tunnels.items():
	self.cli_set(self._base_path + [tunnel, 'encapsulation', tunnel_config['encapsulation']])
	if 'source_interface' in tunnel_config:
	self.cli_set(self._base_path + [tunnel, 'source-interface', tunnel_config['source_interface']])
	if 'remote' in tunnel_config:
	self.cli_set(self._base_path + [tunnel, 'remote', tunnel_config['remote']])

	# GRE key must be supplied when two or more tunnels are formed to the same desitnation
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	for tunnel, tunnel_config in tunnels.items():
	self.cli_set(self._base_path + [tunnel, 'parameters', 'ip', 'key', tunnel.lstrip('tun')])

	self.cli_commit()

	for tunnel, tunnel_config in tunnels.items():
	conf = get_interface_config(tunnel)
	ip_key = tunnel.lstrip('tun')

	self.assertEqual(tunnel_config['source_interface'], conf['link'])
	self.assertEqual(tunnel_config['encapsulation'], conf['linkinfo']['info_kind'])
	self.assertEqual(tunnel_config['remote'], conf['linkinfo']['info_data']['remote'])
	self.assertEqual(f'0.0.0.{ip_key}', conf['linkinfo']['info_data']['ikey'])
	self.assertEqual(f'0.0.0.{ip_key}', conf['linkinfo']['info_data']['okey'])

	def test_multiple_gre_tunnel_different_remote(self):
	tunnels = {
	'tun10' : {
	'encapsulation' : 'gre',
	'source_interface' : source_if,
	'remote' : '1.2.3.4',
	},
	'tun20' : {
	'encapsulation' : 'gre',
	'source_interface' : source_if,
	'remote' : '1.2.3.5',
	},
	}

	for tunnel, tunnel_config in tunnels.items():
	self.cli_set(self._base_path + [tunnel, 'encapsulation', tunnel_config['encapsulation']])
	if 'source_interface' in tunnel_config:
	self.cli_set(self._base_path + [tunnel, 'source-interface', tunnel_config['source_interface']])
	if 'remote' in tunnel_config:
	self.cli_set(self._base_path + [tunnel, 'remote', tunnel_config['remote']])

	self.cli_commit()

	for tunnel, tunnel_config in tunnels.items():
	conf = get_interface_config(tunnel)

	self.assertEqual(tunnel_config['source_interface'], conf['link'])
	self.assertEqual(tunnel_config['encapsulation'], conf['linkinfo']['info_kind'])
	self.assertEqual(tunnel_config['remote'], conf['linkinfo']['info_data']['remote'])

	+ def test_tunnel_invalid_source_interface(self):
	+ encapsulation = 'gre'
	+ remote = '192.0.2.1'
	+ interface = 'tun7543'
	+
	+ self.cli_set(self._base_path + [interface, 'encapsulation', encapsulation])
	+ self.cli_set(self._base_path + [interface, 'remote', remote])
	+
	+ for dynamic_interface in ['l2tp0', 'ppp4220', 'sstpc0', 'ipoe654']:
	+ self.cli_set(self._base_path + [interface, 'source-interface', dynamic_interface])
	+ # verify() - we can not source from dynamic interfaces
	+ with self.assertRaises(ConfigSessionError):
	+ self.cli_commit()
	+ self.cli_set(self._base_path + [interface, 'source-interface', 'eth0'])
	+ self.cli_commit()
	+
	if __name__ == '__main__':
	unittest.main(verbosity=2)
	diff --git a/src/conf_mode/interfaces_tunnel.py b/src/conf_mode/interfaces_tunnel.py
	index 91aed9cc3..efa5ebc64 100755
	--- a/src/conf_mode/interfaces_tunnel.py
	+++ b/src/conf_mode/interfaces_tunnel.py
	@@ -1,224 +1,224 @@
	#!/usr/bin/env python3
	#
	# Copyright (C) 2018-2022 yOS maintainers and contributors
	#
	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License version 2 or later as
	# published by the Free Software Foundation.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program. If not, see <http://www.gnu.org/licenses/>.

	import os

	from sys import exit
	from netifaces import interfaces

	from vyos.config import Config
	from vyos.configdict import get_interface_dict
	from vyos.configdict import is_node_changed
	from vyos.configverify import verify_address
	from vyos.configverify import verify_bridge_delete
	-from vyos.configverify import verify_interface_exists
	+from vyos.configverify import verify_source_interface
	from vyos.configverify import verify_mtu_ipv6
	from vyos.configverify import verify_mirror_redirect
	from vyos.configverify import verify_vrf
	from vyos.configverify import verify_tunnel
	from vyos.configverify import verify_bond_bridge_member
	from vyos.ifconfig import Interface
	from vyos.ifconfig import Section
	from vyos.ifconfig import TunnelIf
	from vyos.utils.network import get_interface_config
	from vyos.utils.dict import dict_search
	from vyos import ConfigError
	from vyos import airbag
	airbag.enable()

	def get_config(config=None):
	"""
	Retrive CLI config as dictionary. Dictionary can never be empty, as at least
	the interface name will be added or a deleted flag
	"""
	if config:
	conf = config
	else:
	conf = Config()
	base = ['interfaces', 'tunnel']
	ifname, tunnel = get_interface_dict(conf, base)

	if 'deleted' not in tunnel:
	tmp = is_node_changed(conf, base + [ifname, 'encapsulation'])
	if tmp: tunnel.update({'encapsulation_changed': {}})

	tmp = is_node_changed(conf, base + [ifname, 'parameters', 'ip', 'key'])
	if tmp: tunnel.update({'key_changed': {}})

	# We also need to inspect other configured tunnels as there are Kernel
	# restrictions where we need to comply. E.g. GRE tunnel key can't be used
	# twice, or with multiple GRE tunnels to the same location we must specify
	# a GRE key
	conf.set_level(base)
	tunnel['other_tunnels'] = conf.get_config_dict([], key_mangling=('-', '_'),
	get_first_key=True,
	no_tag_node_value_mangle=True)
	# delete our own instance from this dict
	ifname = tunnel['ifname']
	del tunnel['other_tunnels'][ifname]
	# if only one tunnel is present on the system, no need to keep this key
	if len(tunnel['other_tunnels']) == 0:
	del tunnel['other_tunnels']

	# We must check if our interface is configured to be a DMVPN member
	nhrp_base = ['protocols', 'nhrp', 'tunnel']
	conf.set_level(nhrp_base)
	nhrp = conf.get_config_dict([], key_mangling=('-', '_'), get_first_key=True)
	if nhrp: tunnel.update({'nhrp' : list(nhrp.keys())})

	if 'encapsulation' in tunnel and tunnel['encapsulation'] not in ['erspan', 'ip6erspan']:
	del tunnel['parameters']['erspan']

	return tunnel

	def verify(tunnel):
	if 'deleted' in tunnel:
	verify_bridge_delete(tunnel)

	if 'nhrp' in tunnel and tunnel['ifname'] in tunnel['nhrp']:
	raise ConfigError('Tunnel used for NHRP, it can not be deleted!')

	return None

	verify_tunnel(tunnel)

	if tunnel['encapsulation'] in ['erspan', 'ip6erspan']:
	if dict_search('parameters.ip.key', tunnel) == None:
	raise ConfigError('ERSPAN requires ip key parameter!')

	# this is a default field
	ver = int(tunnel['parameters']['erspan']['version'])
	if ver == 1:
	if 'hw_id' in tunnel['parameters']['erspan']:
	raise ConfigError('ERSPAN version 1 does not support hw-id!')
	if 'direction' in tunnel['parameters']['erspan']:
	raise ConfigError('ERSPAN version 1 does not support direction!')
	elif ver == 2:
	if 'idx' in tunnel['parameters']['erspan']:
	raise ConfigError('ERSPAN version 2 does not index parameter!')
	if 'direction' not in tunnel['parameters']['erspan']:
	raise ConfigError('ERSPAN version 2 requires direction to be set!')

	# If tunnel source is any and gre key is not set
	interface = tunnel['ifname']
	if tunnel['encapsulation'] in ['gre'] and \
	dict_search('source_address', tunnel) == '0.0.0.0' and \
	dict_search('parameters.ip.key', tunnel) == None:
	raise ConfigError(f'"parameters ip key" must be set for {interface} when '\
	'encapsulation is GRE!')

	gre_encapsulations = ['gre', 'gretap']
	if tunnel['encapsulation'] in gre_encapsulations and 'other_tunnels' in tunnel:
	# Check pairs tunnel source-address/encapsulation/key with exists tunnels.
	# Prevent the same key for 2 tunnels with same source-address/encap. T2920
	for o_tunnel, o_tunnel_conf in tunnel['other_tunnels'].items():
	# no match on encapsulation - bail out
	our_encapsulation = tunnel['encapsulation']
	their_encapsulation = o_tunnel_conf['encapsulation']
	if our_encapsulation in gre_encapsulations and their_encapsulation \
	not in gre_encapsulations:
	continue

	our_address = dict_search('source_address', tunnel)
	our_key = dict_search('parameters.ip.key', tunnel)
	their_address = dict_search('source_address', o_tunnel_conf)
	their_key = dict_search('parameters.ip.key', o_tunnel_conf)
	if our_key != None:
	if their_address == our_address and their_key == our_key:
	raise ConfigError(f'Key "{our_key}" for source-address "{our_address}" ' \
	f'is already used for tunnel "{o_tunnel}"!')
	else:
	our_source_if = dict_search('source_interface', tunnel)
	their_source_if = dict_search('source_interface', o_tunnel_conf)
	our_remote = dict_search('remote', tunnel)
	their_remote = dict_search('remote', o_tunnel_conf)
	# If no IP GRE key is defined we can not have more then one GRE tunnel
	# bound to any one interface/IP address and the same remote. This will
	# result in a OS PermissionError: add tunnel "gre0" failed: File exists
	if (their_address == our_address or our_source_if == their_source_if) and \
	our_remote == their_remote:
	raise ConfigError(f'Missing required "ip key" parameter when '\
	'running more then one GRE based tunnel on the '\
	'same source-interface/source-address')

	# Keys are not allowed with ipip and sit tunnels
	if tunnel['encapsulation'] in ['ipip', 'sit']:
	if dict_search('parameters.ip.key', tunnel) != None:
	raise ConfigError('Keys are not allowed with ipip and sit tunnels!')

	verify_mtu_ipv6(tunnel)
	verify_address(tunnel)
	verify_vrf(tunnel)
	verify_bond_bridge_member(tunnel)
	verify_mirror_redirect(tunnel)

	if 'source_interface' in tunnel:
	- verify_interface_exists(tunnel['source_interface'])
	+ verify_source_interface(tunnel)

	# TTL != 0 and nopmtudisc are incompatible, parameters and ip use default
	# values, thus the keys are always present.
	if dict_search('parameters.ip.no_pmtu_discovery', tunnel) != None:
	if dict_search('parameters.ip.ttl', tunnel) != '0':
	raise ConfigError('Disabled PMTU requires TTL set to "0"!')
	if tunnel['encapsulation'] in ['ipip6', 'ip6ip6', 'ip6gre']:
	raise ConfigError('Can not disable PMTU discovery for given encapsulation')

	if dict_search('parameters.ip.ignore_df', tunnel) != None:
	if tunnel['encapsulation'] not in ['gretap']:
	raise ConfigError('Option ignore-df can only be used on GRETAP tunnels!')

	if dict_search('parameters.ip.no_pmtu_discovery', tunnel) == None:
	raise ConfigError('Option ignore-df requires path MTU discovery to be disabled!')


	def generate(tunnel):
	return None

	def apply(tunnel):
	interface = tunnel['ifname']
	# If a gretap tunnel is already existing we can not "simply" change local or
	# remote addresses. This returns "Operation not supported" by the Kernel.
	# There is no other solution to destroy and recreate the tunnel.
	encap = ''
	remote = ''
	tmp = get_interface_config(interface)
	if tmp:
	encap = dict_search('linkinfo.info_kind', tmp)
	remote = dict_search('linkinfo.info_data.remote', tmp)

	if ('deleted' in tunnel or 'encapsulation_changed' in tunnel or encap in
	['gretap', 'ip6gretap', 'erspan', 'ip6erspan'] or remote in ['any'] or
	'key_changed' in tunnel):
	if interface in interfaces():
	tmp = Interface(interface)
	tmp.remove()
	if 'deleted' in tunnel:
	return None

	tun = TunnelIf(**tunnel)
	tun.update(tunnel)

	return None

	if __name__ == '__main__':
	try:
	c = get_config()
	generate(c)
	verify(c)
	apply(c)
	except ConfigError as e:
	print(e)
	exit(1)

File Metadata

Mime Type: text/x-diff
Expires: Fri, Nov 6, 8:46 AM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4621685
Default Alt Text: (50 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions