-#!/usr/bin/env python
+#!/usr/bin/env python3
import unittest
from scapy.packet import Raw
-from scapy.layers.l2 import Ether, Dot1Q, GRE
+from scapy.layers.l2 import Ether, Dot1Q, GRE, ERSPAN
from scapy.layers.inet import IP, UDP
from scapy.layers.vxlan import VXLAN
from framework import VppTestCase, VppTestRunner
from util import Host, ppp
-from vpp_sub_interface import VppDot1QSubint, VppDot1ADSubint
-from vpp_gre_interface import VppGreInterface, VppGre6Interface
-from vpp_papi_provider import L2_VTR_OP
+from vpp_sub_interface import L2_VTR_OP, VppDot1QSubint, VppDot1ADSubint
+from vpp_gre_interface import VppGreInterface
+from vpp_vxlan_tunnel import VppVxlanTunnel
from collections import namedtuple
+from vpp_papi import VppEnum
+
Tag = namedtuple('Tag', ['dot1', 'vlan'])
DOT1AD = 0x88A8
cls.bd_id = 55
cls.sub_if = VppDot1QSubint(cls, cls.pg0, 100)
- cls.dst_sub_if = VppDot1QSubint(cls, cls.pg2, 300)
- cls.dst_sub_if.set_vtr(L2_VTR_OP.L2_POP_1, tag=300)
+ cls.vlan_sub_if = VppDot1QSubint(cls, cls.pg2, 300)
+ cls.vlan_sub_if.set_vtr(L2_VTR_OP.L2_POP_1, tag=300)
+
+ cls.qinq_sub_if = VppDot1ADSubint(cls, cls.pg2, 33, 400, 500)
+ cls.qinq_sub_if.set_vtr(L2_VTR_OP.L2_POP_2, outer=500, inner=400)
+
# packet flows mapping pg0 -> pg1, pg2 -> pg3, etc.
cls.flows = dict()
cls.flows[cls.pg0] = [cls.pg1]
cls.flows[cls.pg1] = [cls.pg0]
# packet sizes
- cls.pg_if_packet_sizes = [64, 512] # , 1518, 9018]
-
- cls.interfaces = list(cls.pg_interfaces)
+ cls.pg_if_packet_sizes = [64, 512, 1518] # , 9018]
# setup all interfaces
- for i in cls.interfaces:
+ for i in cls.pg_interfaces:
i.admin_up()
i.config_ip4()
i.resolve_arp()
- cls.vxlan = cls.vapi.vxlan_add_del_tunnel(
- src_addr=cls.pg2.local_ip4n,
- dst_addr=cls.pg2.remote_ip4n,
- vni=1111,
- is_add=1)
-
def setUp(self):
super(TestSpan, self).setUp()
+ self.vxlan = VppVxlanTunnel(self, src=self.pg2.local_ip4,
+ dst=self.pg2.remote_ip4, vni=1111)
+ self.vxlan.add_vpp_config()
self.reset_packet_infos()
def tearDown(self):
super(TestSpan, self).tearDown()
- if not self.vpp_dead:
- self.logger.info(self.vapi.ppcli("show interface span"))
+
+ def show_commands_at_teardown(self):
+ self.logger.info(self.vapi.ppcli("show interface span"))
def xconnect(self, a, b, is_add=1):
self.vapi.sw_interface_set_l2_xconnect(a, b, enable=is_add)
self.vapi.sw_interface_set_l2_xconnect(b, a, enable=is_add)
def bridge(self, sw_if_index, is_add=1):
- self.vapi.sw_interface_set_l2_bridge(
- sw_if_index, bd_id=self.bd_id, enable=is_add)
+ self.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=sw_if_index,
+ bd_id=self.bd_id, enable=is_add)
def _remove_tag(self, packet, vlan, tag_type):
self.assertEqual(packet.type, tag_type)
return pkt[GRE].payload
+ def decap_erspan(self, pkt, session):
+ """
+ Decapsulate the original payload frame by removing ERSPAN header
+ """
+ self.assertEqual(pkt[Ether].src, self.pg2.local_mac)
+ self.assertEqual(pkt[Ether].dst, self.pg2.remote_mac)
+
+ self.assertEqual(pkt[IP].src, self.pg2.local_ip4)
+ self.assertEqual(pkt[IP].dst, self.pg2.remote_ip4)
+
+ self.assertEqual(pkt[ERSPAN].ver, 1)
+ self.assertEqual(pkt[ERSPAN].vlan, 0)
+ self.assertEqual(pkt[ERSPAN].cos, 0)
+ self.assertEqual(pkt[ERSPAN].en, 3)
+ self.assertEqual(pkt[ERSPAN].t, 0)
+ self.assertEqual(pkt[ERSPAN].session_id, session)
+ self.assertEqual(pkt[ERSPAN].reserved, 0)
+ self.assertEqual(pkt[ERSPAN].index, 0)
+
+ return pkt[ERSPAN].payload
+
def decap_vxlan(self, pkt):
"""
Decapsulate the original payload frame by removing VXLAN header
return pkt[VXLAN].payload
- def create_stream(self, src_if, packet_sizes, do_dot1=False):
+ def create_stream(self, src_if, packet_sizes, do_dot1=False, bcast=False):
pkts = []
dst_if = self.flows[src_if][0]
+ dst_mac = src_if.remote_mac
+ if bcast:
+ dst_mac = "ff:ff:ff:ff:ff:ff"
+
for i in range(0, self.pkts_per_burst):
- pkt_info = self.create_packet_info(src_if, dst_if)
- payload = self.info_to_payload(pkt_info)
- size = packet_sizes[(i / 2) % len(packet_sizes)]
- p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
+ payload = "span test"
+ size = packet_sizes[int((i / 2) % len(packet_sizes))]
+ p = (Ether(src=src_if.local_mac, dst=dst_mac) /
IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4) /
UDP(sport=10000 + src_if.sw_if_index * 1000 + i, dport=1234) /
Raw(payload))
if do_dot1:
p = self.sub_if.add_dot1_layer(p)
- pkt_info.data = p.copy()
self.extend_packet(p, size)
pkts.append(p)
return pkts
self.assertEqual(pkts1.sort(), pkts2.sort())
def test_device_span(self):
- """ SPAN device rx mirror test
-
- Test scenario:
- 1. config
- 3 interfaces, pg0 l2xconnected with pg1
- 2. sending l2 eth packets between 2 interfaces (pg0, pg1) and
- mirrored to pg2
- 64B, 512B, 1518B, 9018B (ether_size)
- burst of packets per interface
- """
+ """ SPAN device rx mirror """
# Create bi-directional cross-connects between pg0 and pg1
self.xconnect(self.pg0.sw_if_index, self.pg1.sw_if_index)
self.pg_start()
# Verify packets outgoing packet streams on mirrored interface (pg2)
- self.logger.info("Verifying capture on interfaces %s and %s" %
- (self.pg1.name, self.pg2.name))
-
- n_pkts = self.get_packet_count_for_if_idx(self.pg1.sw_if_index)
+ n_pkts = len(pkts)
pg1_pkts = self.pg1.get_capture(n_pkts)
pg2_pkts = self.pg2.get_capture(n_pkts)
self.verify_capture(pg1_pkts, pg2_pkts)
def test_span_l2_rx(self):
- """ SPAN l2 rx mirror test """
+ """ SPAN l2 rx mirror """
self.sub_if.admin_up()
self.bridge(self.pg2.sw_if_index)
- # Create bi-directional cross-connects between pg0 and pg1
+ # Create bi-directional cross-connects between pg0 subif and pg1
self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
# Create incoming packet streams for packet-generator interfaces
pkts = self.create_stream(
self.pg_start()
# Verify packets outgoing packet streams on mirrored interface (pg2)
- self.logger.info("Verifying capture on interfaces %s and %s" %
- (self.pg1.name, self.pg2.name))
pg2_expected = len(pkts)
pg1_pkts = self.pg1.get_capture(pg2_expected)
pg2_pkts = self.pg2.get_capture(pg2_expected)
self.verify_capture(pg1_pkts, pg2_pkts)
def test_span_l2_rx_dst_vxlan(self):
- """ SPAN l2 rx mirror into vxlan test """
+ """ SPAN l2 rx mirror into vxlan """
self.sub_if.admin_up()
self.vapi.sw_interface_set_flags(self.vxlan.sw_if_index,
- admin_up_down=1)
+ flags=1)
self.bridge(self.vxlan.sw_if_index, is_add=1)
- # Create bi-directional cross-connects between pg0 and pg1
+ # Create bi-directional cross-connects between pg0 subif and pg1
self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
# Create incoming packet streams for packet-generator interfaces
pkts = self.create_stream(
self.pg_start()
# Verify packets outgoing packet streams on mirrored interface (pg2)
- self.logger.info("Verifying capture on interfaces %s and %s" %
- (self.pg1.name, self.pg2.name))
- pg2_expected = self.get_packet_count_for_if_idx(self.pg1.sw_if_index)
- pg1_pkts = self.pg1.get_capture()
- pg2_pkts = [self.decap_vxlan(p)
- for p in self.pg2.get_capture(pg2_expected)]
+ n_pkts = len(pkts)
+ pg1_pkts = self.pg1.get_capture(n_pkts)
+ pg2_pkts = [self.decap_vxlan(p) for p in self.pg2.get_capture(n_pkts)]
self.bridge(self.vxlan.sw_if_index, is_add=0)
# Disable SPAN on pg0 sub if (mirrored to vxlan)
self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
self.verify_capture(pg1_pkts, pg2_pkts)
+ def test_span_l2_rx_dst_gre_erspan(self):
+ """ SPAN l2 rx mirror into gre-erspan """
+
+ self.sub_if.admin_up()
+
+ gre_if = VppGreInterface(self, self.pg2.local_ip4,
+ self.pg2.remote_ip4,
+ session=543,
+ type=(VppEnum.vl_api_gre_tunnel_type_t.
+ GRE_API_TUNNEL_TYPE_ERSPAN))
+
+ gre_if.add_vpp_config()
+ gre_if.admin_up()
+
+ self.bridge(gre_if.sw_if_index)
+ # Create bi-directional cross-connects between pg0 and pg1
+ self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
+
+ # Create incoming packet streams for packet-generator interfaces
+ pkts = self.create_stream(
+ self.pg0, self.pg_if_packet_sizes, do_dot1=True)
+ self.pg0.add_stream(pkts)
+
+ # Enable SPAN on pg0 sub if (mirrored to gre-erspan)
+ self.vapi.sw_interface_span_enable_disable(
+ self.sub_if.sw_if_index, gre_if.sw_if_index, is_l2=1)
+
+ # Enable packet capturing and start packet sending
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ # Verify packets outgoing packet streams on mirrored interface (pg2)
+ n_pkts = len(pkts)
+ pg1_pkts = self.pg1.get_capture(n_pkts)
+ pg2_pkts = self.pg2.get_capture(n_pkts)
+
+ def decap(p): return self.decap_erspan(p, session=543)
+ pg2_decaped = [decap(p) for p in pg2_pkts]
+
+ self.bridge(gre_if.sw_if_index, is_add=0)
+
+ # Disable SPAN on pg0 sub if
+ self.vapi.sw_interface_span_enable_disable(
+ self.sub_if.sw_if_index, gre_if.sw_if_index, state=0, is_l2=1)
+ gre_if.remove_vpp_config()
+ self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
+
+ self.verify_capture(pg1_pkts, pg2_decaped)
+
def test_span_l2_rx_dst_gre_subif_vtr(self):
""" SPAN l2 rx mirror into gre-subif+vtr """
gre_if = VppGreInterface(self, self.pg2.local_ip4,
self.pg2.remote_ip4,
- is_teb=1)
+ type=(VppEnum.vl_api_gre_tunnel_type_t.
+ GRE_API_TUNNEL_TYPE_TEB))
gre_if.add_vpp_config()
gre_if.admin_up()
self.pg0, self.pg_if_packet_sizes, do_dot1=True)
self.pg0.add_stream(pkts)
+ # Enable SPAN on pg0 sub if (mirrored to gre sub if)
self.vapi.sw_interface_span_enable_disable(
self.sub_if.sw_if_index, gre_sub_if.sw_if_index, is_l2=1)
self.pg_start()
# Verify packets outgoing packet streams on mirrored interface (pg2)
- self.logger.info("Verifying capture on interfaces %s and %s" %
- (self.pg1.name, self.pg2.name))
- pg2_expected = self.get_packet_count_for_if_idx(self.pg1.sw_if_index)
- pg1_pkts = self.pg1.get_capture()
- pg2_pkts = self.pg2.get_capture(pg2_expected)
- pg2_decaped = [self.remove_tags(self.decap_gre(
- p), [Tag(dot1=DOT1Q, vlan=500)]) for p in pg2_pkts]
+ n_pkts = len(pkts)
+ pg1_pkts = self.pg1.get_capture(n_pkts)
+ pg2_pkts = self.pg2.get_capture(n_pkts)
+
+ def decap(p): return self.remove_tags(
+ self.decap_gre(p), [Tag(dot1=DOT1Q, vlan=500)])
+ pg2_decaped = [decap(p) for p in pg2_pkts]
+
self.bridge(gre_sub_if.sw_if_index, is_add=0)
# Disable SPAN on pg0 sub if
self.verify_capture(pg1_pkts, pg2_decaped)
- def test_span_l2_rx_dst_vtr(self):
- """ SPAN l2 rx mirror into subif+vtr """
+ def test_span_l2_rx_dst_1q_vtr(self):
+ """ SPAN l2 rx mirror into 1q subif+vtr """
self.sub_if.admin_up()
- self.dst_sub_if.admin_up()
+ self.vlan_sub_if.admin_up()
- self.bridge(self.dst_sub_if.sw_if_index)
+ self.bridge(self.vlan_sub_if.sw_if_index)
# Create bi-directional cross-connects between pg0 and pg1
self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
self.pg0.add_stream(pkts)
self.vapi.sw_interface_span_enable_disable(
- self.sub_if.sw_if_index, self.dst_sub_if.sw_if_index, is_l2=1)
+ self.sub_if.sw_if_index, self.vlan_sub_if.sw_if_index, is_l2=1)
# Enable packet capturing and start packet sending
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# Verify packets outgoing packet streams on mirrored interface (pg2)
- self.logger.info("Verifying capture on interfaces %s and %s" %
- (self.pg1.name, self.pg2.name))
- pg2_expected = self.get_packet_count_for_if_idx(self.pg1.sw_if_index)
- pg1_pkts = self.pg1.get_capture()
- pg2_pkts = self.pg2.get_capture(pg2_expected)
+ n_pkts = len(pkts)
+ pg1_pkts = self.pg1.get_capture(n_pkts)
+ pg2_pkts = self.pg2.get_capture(n_pkts)
pg2_untagged = [self.remove_tags(p, [Tag(dot1=DOT1Q, vlan=300)])
for p in pg2_pkts]
- self.bridge(self.dst_sub_if.sw_if_index, is_add=0)
+ self.bridge(self.vlan_sub_if.sw_if_index, is_add=0)
# Disable SPAN on pg0 sub if (mirrored to vxlan)
self.vapi.sw_interface_span_enable_disable(
- self.sub_if.sw_if_index, self.dst_sub_if.sw_if_index, state=0,
+ self.sub_if.sw_if_index, self.vlan_sub_if.sw_if_index, state=0,
+ is_l2=1)
+ self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
+
+ self.verify_capture(pg1_pkts, pg2_untagged)
+
+ def test_span_l2_rx_dst_1ad_vtr(self):
+ """ SPAN l2 rx mirror into 1ad subif+vtr """
+
+ self.sub_if.admin_up()
+ self.qinq_sub_if.admin_up()
+
+ self.bridge(self.qinq_sub_if.sw_if_index)
+ # Create bi-directional cross-connects between pg0 and pg1
+ self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
+
+ # Create incoming packet streams for packet-generator interfaces
+ pkts = self.create_stream(
+ self.pg0, self.pg_if_packet_sizes, do_dot1=True)
+ self.pg0.add_stream(pkts)
+
+ self.vapi.sw_interface_span_enable_disable(
+ self.sub_if.sw_if_index, self.qinq_sub_if.sw_if_index, is_l2=1)
+
+ # Enable packet capturing and start packet sending
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ # Verify packets outgoing packet streams on mirrored interface (pg2)
+ n_pkts = len(pkts)
+ pg1_pkts = self.pg1.get_capture(n_pkts)
+ pg2_pkts = self.pg2.get_capture(n_pkts)
+ pg2_untagged = [self.remove_tags(p, [Tag(dot1=DOT1AD, vlan=400),
+ Tag(dot1=DOT1Q, vlan=500)])
+ for p in pg2_pkts]
+
+ self.bridge(self.qinq_sub_if.sw_if_index, is_add=0)
+ # Disable SPAN on pg0 sub if (mirrored to vxlan)
+ self.vapi.sw_interface_span_enable_disable(
+ self.sub_if.sw_if_index, self.qinq_sub_if.sw_if_index, state=0,
is_l2=1)
self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
self.verify_capture(pg1_pkts, pg2_untagged)
def test_l2_tx_span(self):
- """ SPAN l2 tx mirror test """
+ """ SPAN l2 tx mirror """
self.sub_if.admin_up()
self.bridge(self.pg2.sw_if_index)
self.pg_start()
# Verify packets outgoing packet streams on mirrored interface (pg2)
- self.logger.info("Verifying capture on interfaces %s and %s" %
- (self.pg1.name, self.pg2.name))
- pg2_expected = self.get_packet_count_for_if_idx(self.pg1.sw_if_index)
- pg1_pkts = self.pg1.get_capture()
- pg2_pkts = self.pg2.get_capture(pg2_expected)
+ n_pkts = len(pkts)
+ pg1_pkts = self.pg1.get_capture(n_pkts)
+ pg2_pkts = self.pg2.get_capture(n_pkts)
self.bridge(self.pg2.sw_if_index, is_add=0)
# Disable SPAN on pg0 (mirrored to pg2)
self.vapi.sw_interface_span_enable_disable(
self.verify_capture(pg1_pkts, pg2_pkts)
def test_l2_rx_tx_span(self):
- """ SPAN l2 rx tx mirror test """
+ """ SPAN l2 rx tx mirror """
self.sub_if.admin_up()
self.bridge(self.pg2.sw_if_index)
self.pg_start()
# Verify packets outgoing packet streams on mirrored interface (pg2)
- self.logger.info("Verifying capture on interfaces %s and %s" %
- (self.pg1.name, self.pg2.name))
- pg0_expected = self.get_packet_count_for_if_idx(self.pg0.sw_if_index)
- pg1_expected = self.get_packet_count_for_if_idx(self.pg1.sw_if_index)
+ pg0_expected = len(pg1_pkts)
+ pg1_expected = len(pg0_pkts)
pg2_expected = pg0_expected + pg1_expected
pg0_pkts = self.pg0.get_capture(pg0_expected)
self.verify_capture(pg0_pkts + pg1_pkts, pg2_pkts)
+ def test_l2_bcast_mirror(self):
+ """ SPAN l2 broadcast mirror """
+
+ self.sub_if.admin_up()
+ self.bridge(self.pg2.sw_if_index)
+
+ # Create bi-directional cross-connects between pg0 and pg1
+ self.vapi.sw_interface_set_l2_bridge(
+ rx_sw_if_index=self.sub_if.sw_if_index, bd_id=99, enable=1)
+ self.vapi.sw_interface_set_l2_bridge(
+ rx_sw_if_index=self.pg1.sw_if_index, bd_id=99, enable=1)
+
+ # Create incoming packet streams for packet-generator interfaces
+ pg0_pkts = self.create_stream(
+ self.pg0, self.pg_if_packet_sizes, do_dot1=True, bcast=True)
+ self.pg0.add_stream(pg0_pkts)
+ pg1_pkts = self.create_stream(
+ self.pg1, self.pg_if_packet_sizes, do_dot1=False, bcast=True)
+ self.pg1.add_stream(pg1_pkts)
+
+ # Enable SPAN on pg0 (mirrored to pg2)
+ self.vapi.sw_interface_span_enable_disable(
+ self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=3)
+ self.logger.info(self.vapi.ppcli("show interface span"))
+
+ # Enable packet capturing and start packet sending
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ # Verify packets outgoing packet streams on mirrored interface (pg2)
+ pg0_expected = len(pg1_pkts)
+ pg1_expected = len(pg0_pkts)
+ pg2_expected = pg0_expected + pg1_expected
+
+ pg0_pkts = self.pg0.get_capture(pg0_expected)
+ pg1_pkts = self.pg1.get_capture(pg1_expected)
+ pg2_pkts = self.pg2.get_capture(pg2_expected)
+
+ self.bridge(self.pg2.sw_if_index, is_add=0)
+ self.vapi.sw_interface_set_l2_bridge(
+ rx_sw_if_index=self.sub_if.sw_if_index, bd_id=99, enable=0)
+ self.vapi.sw_interface_set_l2_bridge(
+ rx_sw_if_index=self.pg1.sw_if_index, bd_id=99, enable=0)
+ # Disable SPAN on pg0 (mirrored to pg2)
+ self.vapi.sw_interface_span_enable_disable(
+ self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
+
+ self.verify_capture(pg0_pkts + pg1_pkts, pg2_pkts)
+
if __name__ == '__main__':
unittest.main(testRunner=VppTestRunner)