+ events = self.vapi.collect_events()
+ for e in events:
+ self.logger.error("Received unexpected event: %s", e)
+ self.assert_equal(count, 0, "number of packets received")
+ self.assert_equal(len(events), 0, "number of events received")
+
+ def test_intf_deleted(self):
+ """interface with bfd session deleted"""
+ intf = VppLoInterface(self)
+ intf.config_ip4()
+ intf.admin_up()
+ sw_if_index = intf.sw_if_index
+ vpp_session = VppBFDUDPSession(self, intf, intf.remote_ip4)
+ vpp_session.add_vpp_config()
+ vpp_session.admin_up()
+ intf.remove_vpp_config()
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
+ self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index")
+ self.assertFalse(vpp_session.query_vpp_config())
+
+
+@tag_run_solo
+@tag_fixme_vpp_workers
+class BFD6TestCase(VppTestCase):
+ """Bidirectional Forwarding Detection (BFD) (IPv6)"""
+
+ pg0 = None
+ vpp_clock_offset = None
+ vpp_session = None
+ test_session = None
+
+ @classmethod
+ def setUpClass(cls):
+ super(BFD6TestCase, cls).setUpClass()
+ cls.vapi.cli("set log class bfd level debug")
+ try:
+ cls.create_pg_interfaces([0])
+ cls.pg0.config_ip6()
+ cls.pg0.configure_ipv6_neighbors()
+ cls.pg0.admin_up()
+ cls.pg0.resolve_ndp()
+ cls.create_loopback_interfaces(1)
+ cls.loopback0 = cls.lo_interfaces[0]
+ cls.loopback0.config_ip6()
+ cls.loopback0.admin_up()
+
+ except Exception:
+ super(BFD6TestCase, cls).tearDownClass()
+ raise
+
+ @classmethod
+ def tearDownClass(cls):
+ super(BFD6TestCase, cls).tearDownClass()
+
+ def setUp(self):
+ super(BFD6TestCase, self).setUp()
+ self.factory = AuthKeyFactory()
+ self.vapi.want_bfd_events()
+ self.pg0.enable_capture()
+ try:
+ self.bfd_udp4_sessions = self.statistics["/bfd/udp4/sessions"]
+ self.bfd_udp6_sessions = self.statistics["/bfd/udp6/sessions"]
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip6, af=AF_INET6
+ )
+ self.vpp_session.add_vpp_config()
+ self.vpp_session.admin_up()
+ self.test_session = BFDTestSession(self, self.pg0, AF_INET6)
+ self.logger.debug(self.vapi.cli("show adj nbr"))
+ except BaseException:
+ self.vapi.want_bfd_events(enable_disable=0)
+ raise
+
+ def tearDown(self):
+ if not self.vpp_dead:
+ self.vapi.want_bfd_events(enable_disable=0)
+ self.vapi.collect_events() # clear the event queue
+ super(BFD6TestCase, self).tearDown()
+
+ def test_session_up(self):
+ """bring BFD session up"""
+ bfd_session_up(self)
+ bfd_udp4_sessions = self.statistics["/bfd/udp4/sessions"]
+ bfd_udp6_sessions = self.statistics["/bfd/udp6/sessions"]
+ self.assert_equal(bfd_udp4_sessions, self.bfd_udp4_sessions)
+ self.assert_equal(bfd_udp6_sessions - self.bfd_udp6_sessions, 1)
+
+ def test_session_up_by_ip(self):
+ """bring BFD session up - first frame looked up by address pair"""
+ self.logger.info("BFD: Sending Slow control frame")
+ self.test_session.update(my_discriminator=randint(0, 40000000))
+ self.test_session.send_packet()
+ self.pg0.enable_capture()
+ p = self.pg0.wait_for_packet(1)
+ self.assert_equal(
+ p[BFD].your_discriminator,
+ self.test_session.my_discriminator,
+ "BFD - your discriminator",
+ )
+ self.assert_equal(p[BFD].state, BFDState.init, BFDState)
+ self.test_session.update(
+ your_discriminator=p[BFD].my_discriminator, state=BFDState.up
+ )
+ self.logger.info("BFD: Waiting for event")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
+ verify_event(self, e, expected_state=BFDState.init)
+ self.logger.info("BFD: Sending Up")
+ self.test_session.send_packet()
+ self.logger.info("BFD: Waiting for event")
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
+ verify_event(self, e, expected_state=BFDState.up)
+ self.logger.info("BFD: Session is Up")
+ self.test_session.update(state=BFDState.up)
+ self.test_session.send_packet()
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+
+ def test_hold_up(self):
+ """hold BFD session up"""
+ bfd_session_up(self)
+ for dummy in range(self.test_session.detect_mult * 2):
+ wait_for_bfd_packet(self)
+ self.test_session.send_packet()
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+
+ def test_echo_looped_back(self):
+ """echo packets looped back"""
+ bfd_session_up(self)
+ stats_before = bfd_grab_stats_snapshot(self)
+ self.pg0.enable_capture()
+ echo_packet_count = 10
+ # random source port low enough to increment a few times..
+ udp_sport_tx = randint(1, 50000)
+ udp_sport_rx = udp_sport_tx
+ echo_packet = (
+ Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
+ / IPv6(src=self.pg0.remote_ip6, dst=self.pg0.remote_ip6)
+ / UDP(dport=BFD.udp_dport_echo)
+ / Raw("this should be looped back")
+ )
+ for dummy in range(echo_packet_count):
+ self.sleep(0.01, "delay between echo packets")
+ echo_packet[UDP].sport = udp_sport_tx
+ udp_sport_tx += 1
+ self.logger.debug(ppp("Sending packet:", echo_packet))
+ self.pg0.add_stream(echo_packet)
+ self.pg_start()
+ counter = 0
+ bfd_control_packets_rx = 0
+ while counter < echo_packet_count:
+ p = self.pg0.wait_for_packet(1)
+ self.logger.debug(ppp("Got packet:", p))
+ ether = p[Ether]
+ self.assert_equal(self.pg0.remote_mac, ether.dst, "Destination MAC")
+ self.assert_equal(self.pg0.local_mac, ether.src, "Source MAC")
+ ip = p[IPv6]
+ self.assert_equal(self.pg0.remote_ip6, ip.dst, "Destination IP")
+ udp = p[UDP]
+ if udp.dport == BFD.udp_dport:
+ bfd_control_packets_rx += 1
+ continue
+ self.assert_equal(self.pg0.remote_ip6, ip.src, "Source IP")
+ self.assert_equal(udp.dport, BFD.udp_dport_echo, "UDP destination port")
+ self.assert_equal(udp.sport, udp_sport_rx, "UDP source port")
+ udp_sport_rx += 1
+ # need to compare the hex payload here, otherwise BFD_vpp_echo
+ # gets in way
+ self.assertEqual(
+ scapy.compat.raw(p[UDP].payload),
+ scapy.compat.raw(echo_packet[UDP].payload),
+ "Received packet is not the echo packet sent",
+ )
+ counter += 1
+ self.assert_equal(
+ udp_sport_tx,
+ udp_sport_rx,
+ "UDP source port (== ECHO packet identifier for test purposes)",
+ )
+ stats_after = bfd_grab_stats_snapshot(self)
+ diff = bfd_stats_diff(stats_before, stats_after)
+ self.assertEqual(0, diff.rx, "RX counter bumped but no BFD packets sent")
+ self.assertEqual(
+ 0, diff.rx_echo, "RX echo counter bumped but no BFD session exists"
+ )
+ self.assertEqual(
+ 0, diff.tx_echo, "TX echo counter bumped but no BFD session exists"
+ )
+
+ def test_echo(self):
+ """echo function"""
+ stats_before = bfd_grab_stats_snapshot(self)
+ bfd_session_up(self)
+ self.test_session.update(required_min_echo_rx=150000)
+ self.test_session.send_packet()
+ detection_time = (
+ self.test_session.detect_mult
+ * self.vpp_session.required_min_rx
+ / USEC_IN_SEC
+ )
+ # echo shouldn't work without echo source set
+ for dummy in range(10):
+ sleep = self.vpp_session.required_min_rx / USEC_IN_SEC
+ self.sleep(sleep, "delay before sending bfd packet")
+ self.test_session.send_packet()
+ p = wait_for_bfd_packet(self, pcap_time_min=time.time() - self.vpp_clock_offset)
+ self.assert_equal(
+ p[BFD].required_min_rx_interval,
+ self.vpp_session.required_min_rx,
+ "BFD required min rx interval",
+ )
+ self.test_session.send_packet()
+ self.vapi.bfd_udp_set_echo_source(sw_if_index=self.loopback0.sw_if_index)
+ echo_seen = False
+ # should be turned on - loopback echo packets
+ for dummy in range(3):
+ loop_until = time.time() + 0.75 * detection_time
+ while time.time() < loop_until:
+ p = self.pg0.wait_for_packet(1)
+ self.logger.debug(ppp("Got packet:", p))
+ if p[UDP].dport == BFD.udp_dport_echo:
+ self.assert_equal(
+ p[IPv6].dst, self.pg0.local_ip6, "BFD ECHO dst IP"
+ )
+ self.assertNotEqual(
+ p[IPv6].src,
+ self.loopback0.local_ip6,
+ "BFD ECHO src IP equal to loopback IP",
+ )
+ self.logger.debug(ppp("Looping back packet:", p))
+ self.assert_equal(
+ p[Ether].dst,
+ self.pg0.remote_mac,
+ "ECHO packet destination MAC address",
+ )
+ self.test_session.rx_packets_echo += 1
+ self.test_session.tx_packets_echo += 1
+ p[Ether].dst = self.pg0.local_mac
+ self.pg0.add_stream(p)
+ self.pg_start()
+ echo_seen = True
+ elif p.haslayer(BFD):
+ self.test_session.rx_packets += 1
+ if echo_seen:
+ self.assertGreaterEqual(
+ p[BFD].required_min_rx_interval, 1000000
+ )
+ if "P" in p.sprintf("%BFD.flags%"):
+ final = self.test_session.create_packet()
+ final[BFD].flags = "F"
+ self.test_session.send_packet(final)
+ else:
+ raise Exception(ppp("Received unknown packet:", p))
+
+ self.assert_equal(
+ len(self.vapi.collect_events()), 0, "number of bfd events"
+ )
+ self.test_session.send_packet()
+ self.assertTrue(echo_seen, "No echo packets received")
+
+ stats_after = bfd_grab_stats_snapshot(self)
+ diff = bfd_stats_diff(stats_before, stats_after)
+ # our rx is vpp tx and vice versa, also tolerate one packet off
+ self.assert_in_range(
+ self.test_session.tx_packets, diff.rx - 1, diff.rx + 1, "RX counter"
+ )
+ self.assert_in_range(
+ self.test_session.rx_packets, diff.tx - 1, diff.tx + 1, "TX counter"
+ )
+ self.assert_in_range(
+ self.test_session.tx_packets_echo,
+ diff.rx_echo - 1,
+ diff.rx_echo + 1,
+ "RX echo counter",
+ )
+ self.assert_in_range(
+ self.test_session.rx_packets_echo,
+ diff.tx_echo - 1,
+ diff.tx_echo + 1,
+ "TX echo counter",
+ )
+
+ def test_intf_deleted(self):
+ """interface with bfd session deleted"""
+ intf = VppLoInterface(self)
+ intf.config_ip6()
+ intf.admin_up()
+ sw_if_index = intf.sw_if_index
+ vpp_session = VppBFDUDPSession(self, intf, intf.remote_ip6, af=AF_INET6)
+ vpp_session.add_vpp_config()
+ vpp_session.admin_up()
+ intf.remove_vpp_config()
+ e = self.vapi.wait_for_event(1, "bfd_udp_session_event")
+ self.assert_equal(e.sw_if_index, sw_if_index, "sw_if_index")
+ self.assertFalse(vpp_session.query_vpp_config())
+
+
+@tag_run_solo
+class BFDFIBTestCase(VppTestCase):
+ """BFD-FIB interactions (IPv6)"""
+
+ vpp_session = None
+ test_session = None
+
+ @classmethod
+ def setUpClass(cls):
+ super(BFDFIBTestCase, cls).setUpClass()
+
+ @classmethod
+ def tearDownClass(cls):
+ super(BFDFIBTestCase, cls).tearDownClass()
+
+ def setUp(self):
+ super(BFDFIBTestCase, self).setUp()
+ self.create_pg_interfaces(range(1))
+
+ self.vapi.want_bfd_events()
+ self.pg0.enable_capture()
+
+ for i in self.pg_interfaces:
+ i.admin_up()
+ i.config_ip6()
+ i.configure_ipv6_neighbors()
+
+ def tearDown(self):
+ if not self.vpp_dead:
+ self.vapi.want_bfd_events(enable_disable=False)
+
+ super(BFDFIBTestCase, self).tearDown()
+
+ @staticmethod
+ def pkt_is_not_data_traffic(p):
+ """not data traffic implies BFD or the usual IPv6 ND/RA"""
+ if p.haslayer(BFD) or is_ipv6_misc(p):
+ return True
+ return False
+
+ def test_session_with_fib(self):
+ """BFD-FIB interactions"""
+
+ # packets to match against both of the routes
+ p = [
+ (
+ Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
+ / IPv6(src="3001::1", dst="2001::1")
+ / UDP(sport=1234, dport=1234)
+ / Raw(b"\xa5" * 100)
+ ),
+ (
+ Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
+ / IPv6(src="3001::1", dst="2002::1")
+ / UDP(sport=1234, dport=1234)
+ / Raw(b"\xa5" * 100)
+ ),
+ ]
+
+ # A recursive and a non-recursive route via a next-hop that
+ # will have a BFD session
+ ip_2001_s_64 = VppIpRoute(
+ self,
+ "2001::",
+ 64,
+ [VppRoutePath(self.pg0.remote_ip6, self.pg0.sw_if_index)],
+ )
+ ip_2002_s_64 = VppIpRoute(
+ self, "2002::", 64, [VppRoutePath(self.pg0.remote_ip6, 0xFFFFFFFF)]
+ )
+ ip_2001_s_64.add_vpp_config()
+ ip_2002_s_64.add_vpp_config()
+
+ # bring the session up now the routes are present
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip6, af=AF_INET6
+ )
+ self.vpp_session.add_vpp_config()
+ self.vpp_session.admin_up()
+ self.test_session = BFDTestSession(self, self.pg0, AF_INET6)
+
+ # session is up - traffic passes
+ bfd_session_up(self)
+
+ self.pg0.add_stream(p)
+ self.pg_start()
+ for packet in p:
+ captured = self.pg0.wait_for_packet(
+ 1, filter_out_fn=self.pkt_is_not_data_traffic
+ )
+ self.assertEqual(captured[IPv6].dst, packet[IPv6].dst)
+
+ # session is up - traffic is dropped
+ bfd_session_down(self)
+
+ self.pg0.add_stream(p)
+ self.pg_start()
+ with self.assertRaises(CaptureTimeoutError):
+ self.pg0.wait_for_packet(1, self.pkt_is_not_data_traffic)
+
+ # session is up - traffic passes
+ bfd_session_up(self)
+
+ self.pg0.add_stream(p)
+ self.pg_start()
+ for packet in p:
+ captured = self.pg0.wait_for_packet(
+ 1, filter_out_fn=self.pkt_is_not_data_traffic
+ )
+ self.assertEqual(captured[IPv6].dst, packet[IPv6].dst)
+
+
+@unittest.skipUnless(config.extended, "part of extended tests")
+class BFDTunTestCase(VppTestCase):
+ """BFD over GRE tunnel"""
+
+ vpp_session = None
+ test_session = None
+
+ @classmethod
+ def setUpClass(cls):
+ super(BFDTunTestCase, cls).setUpClass()
+
+ @classmethod
+ def tearDownClass(cls):
+ super(BFDTunTestCase, cls).tearDownClass()
+
+ def setUp(self):
+ super(BFDTunTestCase, self).setUp()
+ self.create_pg_interfaces(range(1))
+
+ self.vapi.want_bfd_events()
+ self.pg0.enable_capture()
+
+ for i in self.pg_interfaces:
+ i.admin_up()
+ i.config_ip4()
+ i.resolve_arp()
+
+ def tearDown(self):
+ if not self.vpp_dead:
+ self.vapi.want_bfd_events(enable_disable=0)
+
+ super(BFDTunTestCase, self).tearDown()
+
+ @staticmethod
+ def pkt_is_not_data_traffic(p):
+ """not data traffic implies BFD or the usual IPv6 ND/RA"""
+ if p.haslayer(BFD) or is_ipv6_misc(p):
+ return True
+ return False
+
+ def test_bfd_o_gre(self):
+ """BFD-o-GRE"""
+
+ # A GRE interface over which to run a BFD session
+ gre_if = VppGreInterface(self, self.pg0.local_ip4, self.pg0.remote_ip4)
+ gre_if.add_vpp_config()
+ gre_if.admin_up()
+ gre_if.config_ip4()
+
+ # bring the session up now the routes are present
+ self.vpp_session = VppBFDUDPSession(
+ self, gre_if, gre_if.remote_ip4, is_tunnel=True
+ )
+ self.vpp_session.add_vpp_config()
+ self.vpp_session.admin_up()
+
+ self.test_session = BFDTestSession(
+ self,
+ gre_if,
+ AF_INET,
+ tunnel_header=(IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) / GRE()),
+ phy_interface=self.pg0,
+ )
+
+ # packets to match against both of the routes
+ p = [
+ (
+ Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
+ / IP(src=self.pg0.remote_ip4, dst=gre_if.remote_ip4)
+ / UDP(sport=1234, dport=1234)
+ / Raw(b"\xa5" * 100)
+ )
+ ]
+
+ # session is up - traffic passes
+ bfd_session_up(self)
+
+ self.send_and_expect(self.pg0, p, self.pg0)
+
+ # bring session down
+ bfd_session_down(self)
+
+
+@tag_run_solo
+class BFDSHA1TestCase(VppTestCase):
+ """Bidirectional Forwarding Detection (BFD) (SHA1 auth)"""
+
+ pg0 = None
+ vpp_clock_offset = None
+ vpp_session = None
+ test_session = None
+
+ @classmethod
+ def setUpClass(cls):
+ super(BFDSHA1TestCase, cls).setUpClass()
+ cls.vapi.cli("set log class bfd level debug")
+ try:
+ cls.create_pg_interfaces([0])
+ cls.pg0.config_ip4()
+ cls.pg0.admin_up()
+ cls.pg0.resolve_arp()
+
+ except Exception:
+ super(BFDSHA1TestCase, cls).tearDownClass()
+ raise
+
+ @classmethod
+ def tearDownClass(cls):
+ super(BFDSHA1TestCase, cls).tearDownClass()
+
+ def setUp(self):
+ super(BFDSHA1TestCase, self).setUp()
+ self.factory = AuthKeyFactory()
+ self.vapi.want_bfd_events()
+ self.pg0.enable_capture()
+
+ def tearDown(self):
+ if not self.vpp_dead:
+ self.vapi.want_bfd_events(enable_disable=False)
+ self.vapi.collect_events() # clear the event queue
+ super(BFDSHA1TestCase, self).tearDown()
+
+ def test_session_up(self):
+ """bring BFD session up"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ self.vpp_session.add_vpp_config()
+ self.vpp_session.admin_up()
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
+ bfd_session_up(self)
+
+ def test_hold_up(self):
+ """hold BFD session up"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ self.vpp_session.add_vpp_config()
+ self.vpp_session.admin_up()
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
+ bfd_session_up(self)
+ for dummy in range(self.test_session.detect_mult * 2):
+ wait_for_bfd_packet(self)
+ self.test_session.send_packet()
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+
+ def test_hold_up_meticulous(self):
+ """hold BFD session up - meticulous auth"""
+ key = self.factory.create_random_key(self, BFDAuthType.meticulous_keyed_sha1)
+ key.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ self.vpp_session.add_vpp_config()
+ self.vpp_session.admin_up()
+ # specify sequence number so that it wraps
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ our_seq_number=0xFFFFFFFF - 4,
+ )
+ bfd_session_up(self)
+ for dummy in range(30):
+ wait_for_bfd_packet(self)
+ self.test_session.inc_seq_num()
+ self.test_session.send_packet()
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+
+ def test_send_bad_seq_number(self):
+ """session is not kept alive by msgs with bad sequence numbers"""
+ key = self.factory.create_random_key(self, BFDAuthType.meticulous_keyed_sha1)
+ key.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ self.vpp_session.add_vpp_config()
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
+ bfd_session_up(self)
+ detection_time = (
+ self.test_session.detect_mult
+ * self.vpp_session.required_min_rx
+ / USEC_IN_SEC
+ )
+ send_until = time.time() + 2 * detection_time
+ while time.time() < send_until:
+ self.test_session.send_packet()
+ self.sleep(
+ 0.7 * self.vpp_session.required_min_rx / USEC_IN_SEC,
+ "time between bfd packets",
+ )
+ e = self.vapi.collect_events()
+ # session should be down now, because the sequence numbers weren't
+ # updated
+ self.assert_equal(len(e), 1, "number of bfd events")
+ verify_event(self, e[0], expected_state=BFDState.down)
+
+ def execute_rogue_session_scenario(
+ self,
+ vpp_bfd_udp_session,
+ legitimate_test_session,
+ rogue_test_session,
+ rogue_bfd_values=None,
+ ):
+ """execute a rogue session interaction scenario
+
+ 1. create vpp session, add config
+ 2. bring the legitimate session up
+ 3. copy the bfd values from legitimate session to rogue session
+ 4. apply rogue_bfd_values to rogue session
+ 5. set rogue session state to down
+ 6. send message to take the session down from the rogue session
+ 7. assert that the legitimate session is unaffected
+ """
+
+ self.vpp_session = vpp_bfd_udp_session
+ self.vpp_session.add_vpp_config()
+ self.test_session = legitimate_test_session
+ # bring vpp session up
+ bfd_session_up(self)
+ # send packet from rogue session
+ rogue_test_session.update(
+ my_discriminator=self.test_session.my_discriminator,
+ your_discriminator=self.test_session.your_discriminator,
+ desired_min_tx=self.test_session.desired_min_tx,
+ required_min_rx=self.test_session.required_min_rx,
+ detect_mult=self.test_session.detect_mult,
+ diag=self.test_session.diag,
+ state=self.test_session.state,
+ auth_type=self.test_session.auth_type,
+ )
+ if rogue_bfd_values:
+ rogue_test_session.update(**rogue_bfd_values)
+ rogue_test_session.update(state=BFDState.down)
+ rogue_test_session.send_packet()
+ wait_for_bfd_packet(self)
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+
+ def test_mismatch_auth(self):
+ """session is not brought down by unauthenticated msg"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ legitimate_test_session = BFDTestSession(
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ )
+ rogue_test_session = BFDTestSession(self, self.pg0, AF_INET)
+ self.execute_rogue_session_scenario(
+ vpp_session, legitimate_test_session, rogue_test_session
+ )
+
+ def test_mismatch_bfd_key_id(self):
+ """session is not brought down by msg with non-existent key-id"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ # pick a different random bfd key id
+ x = randint(0, 255)
+ while x == vpp_session.bfd_key_id:
+ x = randint(0, 255)
+ legitimate_test_session = BFDTestSession(
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ )
+ rogue_test_session = BFDTestSession(
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=x
+ )
+ self.execute_rogue_session_scenario(
+ vpp_session, legitimate_test_session, rogue_test_session
+ )
+
+ def test_mismatched_auth_type(self):
+ """session is not brought down by msg with wrong auth type"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ legitimate_test_session = BFDTestSession(
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ )
+ rogue_test_session = BFDTestSession(
+ self, self.pg0, AF_INET, sha1_key=key, bfd_key_id=vpp_session.bfd_key_id
+ )
+ self.execute_rogue_session_scenario(
+ vpp_session,
+ legitimate_test_session,
+ rogue_test_session,
+ {"auth_type": BFDAuthType.keyed_md5},
+ )
+
+ def test_restart(self):
+ """simulate remote peer restart and resynchronization"""
+ key = self.factory.create_random_key(self, BFDAuthType.meticulous_keyed_sha1)
+ key.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ self.vpp_session.add_vpp_config()
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ our_seq_number=0,
+ )
+ bfd_session_up(self)
+ # don't send any packets for 2*detection_time
+ detection_time = (
+ self.test_session.detect_mult
+ * self.vpp_session.required_min_rx
+ / USEC_IN_SEC
+ )
+ self.sleep(2 * detection_time, "simulating peer restart")
+ events = self.vapi.collect_events()
+ self.assert_equal(len(events), 1, "number of bfd events")
+ verify_event(self, events[0], expected_state=BFDState.down)
+ self.test_session.update(state=BFDState.down)
+ # reset sequence number
+ self.test_session.our_seq_number = 0
+ self.test_session.vpp_seq_number = None
+ # now throw away any pending packets
+ self.pg0.enable_capture()
+ self.test_session.my_discriminator = 0
+ bfd_session_up(self)
+
+
+@tag_run_solo
+class BFDAuthOnOffTestCase(VppTestCase):
+ """Bidirectional Forwarding Detection (BFD) (changing auth)"""
+
+ pg0 = None
+ vpp_session = None
+ test_session = None
+
+ @classmethod
+ def setUpClass(cls):
+ super(BFDAuthOnOffTestCase, cls).setUpClass()
+ cls.vapi.cli("set log class bfd level debug")
+ try:
+ cls.create_pg_interfaces([0])
+ cls.pg0.config_ip4()
+ cls.pg0.admin_up()
+ cls.pg0.resolve_arp()
+
+ except Exception:
+ super(BFDAuthOnOffTestCase, cls).tearDownClass()
+ raise
+
+ @classmethod
+ def tearDownClass(cls):
+ super(BFDAuthOnOffTestCase, cls).tearDownClass()
+
+ def setUp(self):
+ super(BFDAuthOnOffTestCase, self).setUp()
+ self.factory = AuthKeyFactory()
+ self.vapi.want_bfd_events()
+ self.pg0.enable_capture()
+
+ def tearDown(self):
+ if not self.vpp_dead:
+ self.vapi.want_bfd_events(enable_disable=False)
+ self.vapi.collect_events() # clear the event queue
+ super(BFDAuthOnOffTestCase, self).tearDown()
+
+ def test_auth_on_immediate(self):
+ """turn auth on without disturbing session state (immediate)"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ self.vpp_session.add_vpp_config()
+ self.test_session = BFDTestSession(self, self.pg0, AF_INET)
+ bfd_session_up(self)
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.vpp_session.activate_auth(key)
+ self.test_session.bfd_key_id = self.vpp_session.bfd_key_id
+ self.test_session.sha1_key = key
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
+
+ def test_auth_off_immediate(self):
+ """turn auth off without disturbing session state (immediate)"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ self.vpp_session.add_vpp_config()
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
+ bfd_session_up(self)
+ # self.vapi.want_bfd_events(enable_disable=0)
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.inc_seq_num()
+ self.test_session.send_packet()
+ self.vpp_session.deactivate_auth()
+ self.test_session.bfd_key_id = None
+ self.test_session.sha1_key = None
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.inc_seq_num()
+ self.test_session.send_packet()
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
+
+ def test_auth_change_key_immediate(self):
+ """change auth key without disturbing session state (immediate)"""
+ key1 = self.factory.create_random_key(self)
+ key1.add_vpp_config()
+ key2 = self.factory.create_random_key(self)
+ key2.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key1
+ )
+ self.vpp_session.add_vpp_config()
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key1,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
+ bfd_session_up(self)
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.vpp_session.activate_auth(key2)
+ self.test_session.bfd_key_id = self.vpp_session.bfd_key_id
+ self.test_session.sha1_key = key2
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
+
+ def test_auth_on_delayed(self):
+ """turn auth on without disturbing session state (delayed)"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ self.vpp_session.add_vpp_config()
+ self.test_session = BFDTestSession(self, self.pg0, AF_INET)
+ bfd_session_up(self)
+ for dummy in range(self.test_session.detect_mult * 2):
+ wait_for_bfd_packet(self)
+ self.test_session.send_packet()
+ self.vpp_session.activate_auth(key, delayed=True)
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.test_session.bfd_key_id = self.vpp_session.bfd_key_id
+ self.test_session.sha1_key = key
+ self.test_session.send_packet()
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
+
+ def test_auth_off_delayed(self):
+ """turn auth off without disturbing session state (delayed)"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ self.vpp_session.add_vpp_config()
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
+ bfd_session_up(self)
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.vpp_session.deactivate_auth(delayed=True)
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.test_session.bfd_key_id = None
+ self.test_session.sha1_key = None
+ self.test_session.send_packet()
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
+
+ def test_auth_change_key_delayed(self):
+ """change auth key without disturbing session state (delayed)"""
+ key1 = self.factory.create_random_key(self)
+ key1.add_vpp_config()
+ key2 = self.factory.create_random_key(self)
+ key2.add_vpp_config()
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key1
+ )
+ self.vpp_session.add_vpp_config()
+ self.vpp_session.admin_up()
+ self.test_session = BFDTestSession(
+ self,
+ self.pg0,
+ AF_INET,
+ sha1_key=key1,
+ bfd_key_id=self.vpp_session.bfd_key_id,
+ )
+ bfd_session_up(self)
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.vpp_session.activate_auth(key2, delayed=True)
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.test_session.bfd_key_id = self.vpp_session.bfd_key_id
+ self.test_session.sha1_key = key2
+ self.test_session.send_packet()
+ for dummy in range(self.test_session.detect_mult * 2):
+ p = wait_for_bfd_packet(self)
+ self.assert_equal(p[BFD].state, BFDState.up, BFDState)
+ self.test_session.send_packet()
+ self.assert_equal(self.vpp_session.state, BFDState.up, BFDState)
+ self.assert_equal(len(self.vapi.collect_events()), 0, "number of bfd events")
+
+
+@tag_run_solo
+class BFDCLITestCase(VppTestCase):
+ """Bidirectional Forwarding Detection (BFD) (CLI)"""
+
+ pg0 = None
+
+ @classmethod
+ def setUpClass(cls):
+ super(BFDCLITestCase, cls).setUpClass()
+ cls.vapi.cli("set log class bfd level debug")
+ try:
+ cls.create_pg_interfaces((0,))
+ cls.pg0.config_ip4()
+ cls.pg0.config_ip6()
+ cls.pg0.resolve_arp()
+ cls.pg0.resolve_ndp()
+
+ except Exception:
+ super(BFDCLITestCase, cls).tearDownClass()
+ raise
+
+ @classmethod
+ def tearDownClass(cls):
+ super(BFDCLITestCase, cls).tearDownClass()
+
+ def setUp(self):
+ super(BFDCLITestCase, self).setUp()
+ self.factory = AuthKeyFactory()
+ self.pg0.enable_capture()
+
+ def tearDown(self):
+ try:
+ self.vapi.want_bfd_events(enable_disable=False)
+ except UnexpectedApiReturnValueError:
+ # some tests aren't subscribed, so this is not an issue
+ pass
+ self.vapi.collect_events() # clear the event queue
+ super(BFDCLITestCase, self).tearDown()
+
+ def cli_verify_no_response(self, cli):
+ """execute a CLI, asserting that the response is empty"""
+ self.assert_equal(self.vapi.cli(cli), "", "CLI command response")
+
+ def cli_verify_response(self, cli, expected):
+ """execute a CLI, asserting that the response matches expectation"""
+ try:
+ reply = self.vapi.cli(cli)
+ except CliFailedCommandError as cli_error:
+ reply = str(cli_error)
+ self.assert_equal(reply.strip(), expected, "CLI command response")
+
+ def test_show(self):
+ """show commands"""
+ k1 = self.factory.create_random_key(self)
+ k1.add_vpp_config()
+ k2 = self.factory.create_random_key(
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
+ k2.add_vpp_config()
+ s1 = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ s1.add_vpp_config()
+ s2 = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=k2
+ )
+ s2.add_vpp_config()
+ self.logger.info(self.vapi.ppcli("show bfd keys"))
+ self.logger.info(self.vapi.ppcli("show bfd sessions"))
+ self.logger.info(self.vapi.ppcli("show bfd"))
+
+ def test_set_del_sha1_key(self):
+ """set/delete SHA1 auth key"""
+ k = self.factory.create_random_key(self)
+ self.registry.register(k, self.logger)
+ self.cli_verify_no_response(
+ "bfd key set conf-key-id %s type keyed-sha1 secret %s"
+ % (
+ k.conf_key_id,
+ "".join("{:02x}".format(scapy.compat.orb(c)) for c in k.key),
+ )
+ )
+ self.assertTrue(k.query_vpp_config())
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=k
+ )
+ self.vpp_session.add_vpp_config()
+ self.test_session = BFDTestSession(
+ self, self.pg0, AF_INET, sha1_key=k, bfd_key_id=self.vpp_session.bfd_key_id
+ )
+ self.vapi.want_bfd_events()
+ bfd_session_up(self)
+ bfd_session_down(self)
+ # try to replace the secret for the key - should fail because the key
+ # is in-use
+ k2 = self.factory.create_random_key(self)
+ self.cli_verify_response(
+ "bfd key set conf-key-id %s type keyed-sha1 secret %s"
+ % (
+ k.conf_key_id,
+ "".join("{:02x}".format(scapy.compat.orb(c)) for c in k2.key),
+ ),
+ "bfd key set: `bfd_auth_set_key' API call failed, "
+ "rv=-103:BFD object in use",
+ )
+ # manipulating the session using old secret should still work
+ bfd_session_up(self)
+ bfd_session_down(self)
+ self.vpp_session.remove_vpp_config()
+ self.cli_verify_no_response("bfd key del conf-key-id %s" % k.conf_key_id)
+ self.assertFalse(k.query_vpp_config())
+
+ def test_set_del_meticulous_sha1_key(self):
+ """set/delete meticulous SHA1 auth key"""
+ k = self.factory.create_random_key(
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
+ self.registry.register(k, self.logger)
+ self.cli_verify_no_response(
+ "bfd key set conf-key-id %s type meticulous-keyed-sha1 secret %s"
+ % (
+ k.conf_key_id,
+ "".join("{:02x}".format(scapy.compat.orb(c)) for c in k.key),
+ )
+ )
+ self.assertTrue(k.query_vpp_config())
+ self.vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=k
+ )
+ self.vpp_session.add_vpp_config()
+ self.vpp_session.admin_up()
+ self.test_session = BFDTestSession(
+ self, self.pg0, AF_INET6, sha1_key=k, bfd_key_id=self.vpp_session.bfd_key_id
+ )
+ self.vapi.want_bfd_events()
+ bfd_session_up(self)
+ bfd_session_down(self)
+ # try to replace the secret for the key - should fail because the key
+ # is in-use
+ k2 = self.factory.create_random_key(self)
+ self.cli_verify_response(
+ "bfd key set conf-key-id %s type keyed-sha1 secret %s"
+ % (
+ k.conf_key_id,
+ "".join("{:02x}".format(scapy.compat.orb(c)) for c in k2.key),
+ ),
+ "bfd key set: `bfd_auth_set_key' API call failed, "
+ "rv=-103:BFD object in use",
+ )
+ # manipulating the session using old secret should still work
+ bfd_session_up(self)
+ bfd_session_down(self)
+ self.vpp_session.remove_vpp_config()
+ self.cli_verify_no_response("bfd key del conf-key-id %s" % k.conf_key_id)
+ self.assertFalse(k.query_vpp_config())
+
+ def test_add_mod_del_bfd_udp(self):
+ """create/modify/delete IPv4 BFD UDP session"""
+ vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ self.registry.register(vpp_session, self.logger)
+ cli_add_cmd = (
+ "bfd udp session add interface %s local-addr %s "
+ "peer-addr %s desired-min-tx %s required-min-rx %s "
+ "detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ vpp_session.desired_min_tx,
+ vpp_session.required_min_rx,
+ vpp_session.detect_mult,
+ )
+ )
+ self.cli_verify_no_response(cli_add_cmd)
+ # 2nd add should fail
+ self.cli_verify_response(
+ cli_add_cmd,
+ "bfd udp session add: `bfd_add_add_session' API call"
+ " failed, rv=-101:Duplicate BFD object",
+ )
+ verify_bfd_session_config(self, vpp_session)
+ mod_session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.pg0.remote_ip4,
+ required_min_rx=2 * vpp_session.required_min_rx,
+ desired_min_tx=3 * vpp_session.desired_min_tx,
+ detect_mult=4 * vpp_session.detect_mult,
+ )
+ self.cli_verify_no_response(
+ "bfd udp session mod interface %s local-addr %s peer-addr %s "
+ "desired-min-tx %s required-min-rx %s detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ mod_session.desired_min_tx,
+ mod_session.required_min_rx,
+ mod_session.detect_mult,
+ )
+ )
+ verify_bfd_session_config(self, mod_session)
+ cli_del_cmd = (
+ "bfd udp session del interface %s local-addr %s "
+ "peer-addr %s" % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
+ self.cli_verify_no_response(cli_del_cmd)
+ # 2nd del is expected to fail
+ self.cli_verify_response(
+ cli_del_cmd,
+ "bfd udp session del: `bfd_udp_del_session' API call"
+ " failed, rv=-102:No such BFD object",
+ )
+ self.assertFalse(vpp_session.query_vpp_config())
+
+ def test_add_mod_del_bfd_udp6(self):
+ """create/modify/delete IPv6 BFD UDP session"""
+ vpp_session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip6, af=AF_INET6)
+ self.registry.register(vpp_session, self.logger)
+ cli_add_cmd = (
+ "bfd udp session add interface %s local-addr %s "
+ "peer-addr %s desired-min-tx %s required-min-rx %s "
+ "detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip6,
+ self.pg0.remote_ip6,
+ vpp_session.desired_min_tx,
+ vpp_session.required_min_rx,
+ vpp_session.detect_mult,
+ )
+ )
+ self.cli_verify_no_response(cli_add_cmd)
+ # 2nd add should fail
+ self.cli_verify_response(
+ cli_add_cmd,
+ "bfd udp session add: `bfd_add_add_session' API call"
+ " failed, rv=-101:Duplicate BFD object",
+ )
+ verify_bfd_session_config(self, vpp_session)
+ mod_session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.pg0.remote_ip6,
+ af=AF_INET6,
+ required_min_rx=2 * vpp_session.required_min_rx,
+ desired_min_tx=3 * vpp_session.desired_min_tx,
+ detect_mult=4 * vpp_session.detect_mult,
+ )
+ self.cli_verify_no_response(
+ "bfd udp session mod interface %s local-addr %s peer-addr %s "
+ "desired-min-tx %s required-min-rx %s detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip6,
+ self.pg0.remote_ip6,
+ mod_session.desired_min_tx,
+ mod_session.required_min_rx,
+ mod_session.detect_mult,
+ )
+ )
+ verify_bfd_session_config(self, mod_session)
+ cli_del_cmd = (
+ "bfd udp session del interface %s local-addr %s "
+ "peer-addr %s" % (self.pg0.name, self.pg0.local_ip6, self.pg0.remote_ip6)
+ )
+ self.cli_verify_no_response(cli_del_cmd)
+ # 2nd del is expected to fail
+ self.cli_verify_response(
+ cli_del_cmd,
+ "bfd udp session del: `bfd_udp_del_session' API call"
+ " failed, rv=-102:No such BFD object",
+ )
+ self.assertFalse(vpp_session.query_vpp_config())
+
+ def test_add_mod_del_bfd_udp_auth(self):
+ """create/modify/delete IPv4 BFD UDP session (authenticated)"""
+ key = self.factory.create_random_key(self)
+ key.add_vpp_config()
+ vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ self.registry.register(vpp_session, self.logger)
+ cli_add_cmd = (
+ "bfd udp session add interface %s local-addr %s "
+ "peer-addr %s desired-min-tx %s required-min-rx %s "
+ "detect-mult %s conf-key-id %s bfd-key-id %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ vpp_session.desired_min_tx,
+ vpp_session.required_min_rx,
+ vpp_session.detect_mult,
+ key.conf_key_id,
+ vpp_session.bfd_key_id,
+ )
+ )
+ self.cli_verify_no_response(cli_add_cmd)
+ # 2nd add should fail
+ self.cli_verify_response(
+ cli_add_cmd,
+ "bfd udp session add: `bfd_add_add_session' API call"
+ " failed, rv=-101:Duplicate BFD object",
+ )
+ verify_bfd_session_config(self, vpp_session)
+ mod_session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.pg0.remote_ip4,
+ sha1_key=key,
+ bfd_key_id=vpp_session.bfd_key_id,
+ required_min_rx=2 * vpp_session.required_min_rx,
+ desired_min_tx=3 * vpp_session.desired_min_tx,
+ detect_mult=4 * vpp_session.detect_mult,
+ )
+ self.cli_verify_no_response(
+ "bfd udp session mod interface %s local-addr %s peer-addr %s "
+ "desired-min-tx %s required-min-rx %s detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ mod_session.desired_min_tx,
+ mod_session.required_min_rx,
+ mod_session.detect_mult,
+ )
+ )
+ verify_bfd_session_config(self, mod_session)
+ cli_del_cmd = (
+ "bfd udp session del interface %s local-addr %s "
+ "peer-addr %s" % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
+ self.cli_verify_no_response(cli_del_cmd)
+ # 2nd del is expected to fail
+ self.cli_verify_response(
+ cli_del_cmd,
+ "bfd udp session del: `bfd_udp_del_session' API call"
+ " failed, rv=-102:No such BFD object",
+ )
+ self.assertFalse(vpp_session.query_vpp_config())
+
+ def test_add_mod_del_bfd_udp6_auth(self):
+ """create/modify/delete IPv6 BFD UDP session (authenticated)"""
+ key = self.factory.create_random_key(
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
+ key.add_vpp_config()
+ vpp_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip6, af=AF_INET6, sha1_key=key
+ )
+ self.registry.register(vpp_session, self.logger)
+ cli_add_cmd = (
+ "bfd udp session add interface %s local-addr %s "
+ "peer-addr %s desired-min-tx %s required-min-rx %s "
+ "detect-mult %s conf-key-id %s bfd-key-id %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip6,
+ self.pg0.remote_ip6,
+ vpp_session.desired_min_tx,
+ vpp_session.required_min_rx,
+ vpp_session.detect_mult,
+ key.conf_key_id,
+ vpp_session.bfd_key_id,
+ )
+ )
+ self.cli_verify_no_response(cli_add_cmd)
+ # 2nd add should fail
+ self.cli_verify_response(
+ cli_add_cmd,
+ "bfd udp session add: `bfd_add_add_session' API call"
+ " failed, rv=-101:Duplicate BFD object",
+ )
+ verify_bfd_session_config(self, vpp_session)
+ mod_session = VppBFDUDPSession(
+ self,
+ self.pg0,
+ self.pg0.remote_ip6,
+ af=AF_INET6,
+ sha1_key=key,
+ bfd_key_id=vpp_session.bfd_key_id,
+ required_min_rx=2 * vpp_session.required_min_rx,
+ desired_min_tx=3 * vpp_session.desired_min_tx,
+ detect_mult=4 * vpp_session.detect_mult,
+ )
+ self.cli_verify_no_response(
+ "bfd udp session mod interface %s local-addr %s peer-addr %s "
+ "desired-min-tx %s required-min-rx %s detect-mult %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip6,
+ self.pg0.remote_ip6,
+ mod_session.desired_min_tx,
+ mod_session.required_min_rx,
+ mod_session.detect_mult,
+ )
+ )
+ verify_bfd_session_config(self, mod_session)
+ cli_del_cmd = (
+ "bfd udp session del interface %s local-addr %s "
+ "peer-addr %s" % (self.pg0.name, self.pg0.local_ip6, self.pg0.remote_ip6)
+ )
+ self.cli_verify_no_response(cli_del_cmd)
+ # 2nd del is expected to fail
+ self.cli_verify_response(
+ cli_del_cmd,
+ "bfd udp session del: `bfd_udp_del_session' API call"
+ " failed, rv=-102:No such BFD object",
+ )
+ self.assertFalse(vpp_session.query_vpp_config())
+
+ def test_auth_on_off(self):
+ """turn authentication on and off"""
+ key = self.factory.create_random_key(
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
+ key.add_vpp_config()
+ session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ auth_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ session.add_vpp_config()
+ cli_activate = (
+ "bfd udp session auth activate interface %s local-addr %s "
+ "peer-addr %s conf-key-id %s bfd-key-id %s"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ key.conf_key_id,
+ auth_session.bfd_key_id,
+ )
+ )
+ self.cli_verify_no_response(cli_activate)
+ verify_bfd_session_config(self, auth_session)
+ self.cli_verify_no_response(cli_activate)
+ verify_bfd_session_config(self, auth_session)
+ cli_deactivate = (
+ "bfd udp session auth deactivate interface %s local-addr %s "
+ "peer-addr %s " % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
+ self.cli_verify_no_response(cli_deactivate)
+ verify_bfd_session_config(self, session)
+ self.cli_verify_no_response(cli_deactivate)
+ verify_bfd_session_config(self, session)
+
+ def test_auth_on_off_delayed(self):
+ """turn authentication on and off (delayed)"""
+ key = self.factory.create_random_key(
+ self, auth_type=BFDAuthType.meticulous_keyed_sha1
+ )
+ key.add_vpp_config()
+ session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ auth_session = VppBFDUDPSession(
+ self, self.pg0, self.pg0.remote_ip4, sha1_key=key
+ )
+ session.add_vpp_config()
+ cli_activate = (
+ "bfd udp session auth activate interface %s local-addr %s "
+ "peer-addr %s conf-key-id %s bfd-key-id %s delayed yes"
+ % (
+ self.pg0.name,
+ self.pg0.local_ip4,
+ self.pg0.remote_ip4,
+ key.conf_key_id,
+ auth_session.bfd_key_id,
+ )
+ )
+ self.cli_verify_no_response(cli_activate)
+ verify_bfd_session_config(self, auth_session)
+ self.cli_verify_no_response(cli_activate)
+ verify_bfd_session_config(self, auth_session)
+ cli_deactivate = (
+ "bfd udp session auth deactivate interface %s local-addr %s "
+ "peer-addr %s delayed yes"
+ % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
+ self.cli_verify_no_response(cli_deactivate)
+ verify_bfd_session_config(self, session)
+ self.cli_verify_no_response(cli_deactivate)
+ verify_bfd_session_config(self, session)
+
+ def test_admin_up_down(self):
+ """put session admin-up and admin-down"""
+ session = VppBFDUDPSession(self, self.pg0, self.pg0.remote_ip4)
+ session.add_vpp_config()
+ cli_down = (
+ "bfd udp session set-flags admin down interface %s local-addr %s "
+ "peer-addr %s " % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
+ cli_up = (
+ "bfd udp session set-flags admin up interface %s local-addr %s "
+ "peer-addr %s " % (self.pg0.name, self.pg0.local_ip4, self.pg0.remote_ip4)
+ )
+ self.cli_verify_no_response(cli_down)
+ verify_bfd_session_config(self, session, state=BFDState.admin_down)
+ self.cli_verify_no_response(cli_up)
+ verify_bfd_session_config(self, session, state=BFDState.down)
+
+ def test_set_del_udp_echo_source(self):
+ """set/del udp echo source"""
+ self.create_loopback_interfaces(1)
+ self.loopback0 = self.lo_interfaces[0]
+ self.loopback0.admin_up()
+ self.cli_verify_response("show bfd echo-source", "UDP echo source is not set.")
+ cli_set = "bfd udp echo-source set interface %s" % self.loopback0.name
+ self.cli_verify_no_response(cli_set)
+ self.cli_verify_response(
+ "show bfd echo-source",
+ "UDP echo source is: %s\n"
+ "IPv4 address usable as echo source: none\n"
+ "IPv6 address usable as echo source: none" % self.loopback0.name,
+ )
+ self.loopback0.config_ip4()
+ echo_ip4 = str(
+ ipaddress.IPv4Address(
+ int(ipaddress.IPv4Address(self.loopback0.local_ip4)) ^ 1
+ )
+ )
+ self.cli_verify_response(
+ "show bfd echo-source",
+ "UDP echo source is: %s\n"
+ "IPv4 address usable as echo source: %s\n"
+ "IPv6 address usable as echo source: none"
+ % (self.loopback0.name, echo_ip4),
+ )
+ echo_ip6 = str(
+ ipaddress.IPv6Address(
+ int(ipaddress.IPv6Address(self.loopback0.local_ip6)) ^ 1
+ )
+ )
+ self.loopback0.config_ip6()
+ self.cli_verify_response(
+ "show bfd echo-source",
+ "UDP echo source is: %s\n"
+ "IPv4 address usable as echo source: %s\n"
+ "IPv6 address usable as echo source: %s"
+ % (self.loopback0.name, echo_ip4, echo_ip6),
+ )
+ cli_del = "bfd udp echo-source del"
+ self.cli_verify_no_response(cli_del)
+ self.cli_verify_response("show bfd echo-source", "UDP echo source is not set.")