5 from scapy.packet import Raw
6 from scapy.layers.l2 import Ether, Dot1Q, GRE
7 from scapy.layers.inet import IP, UDP
8 from scapy.layers.vxlan import VXLAN
10 from framework import VppTestCase, VppTestRunner
11 from util import Host, ppp
12 from vpp_sub_interface import VppDot1QSubint, VppDot1ADSubint
13 from vpp_gre_interface import VppGreInterface, VppGre6Interface
14 from vpp_papi_provider import L2_VTR_OP
15 from collections import namedtuple
17 Tag = namedtuple('Tag', ['dot1', 'vlan'])
22 class TestSpan(VppTestCase):
23 """ SPAN Test Case """
27 super(TestSpan, cls).setUpClass()
29 cls.pkts_per_burst = 257 # Number of packets per burst
30 # create 3 pg interfaces
31 cls.create_pg_interfaces(range(3))
34 cls.sub_if = VppDot1QSubint(cls, cls.pg0, 100)
35 cls.vlan_sub_if = VppDot1QSubint(cls, cls.pg2, 300)
36 cls.vlan_sub_if.set_vtr(L2_VTR_OP.L2_POP_1, tag=300)
38 cls.qinq_sub_if = VppDot1ADSubint(cls, cls.pg2, 33, 400, 500)
39 cls.qinq_sub_if.set_vtr(L2_VTR_OP.L2_POP_2, outer=500, inner=400)
41 # packet flows mapping pg0 -> pg1, pg2 -> pg3, etc.
43 cls.flows[cls.pg0] = [cls.pg1]
44 cls.flows[cls.pg1] = [cls.pg0]
47 cls.pg_if_packet_sizes = [64, 512, 1518] # , 9018]
49 # setup all interfaces
50 for i in cls.pg_interfaces:
55 cls.vxlan = cls.vapi.vxlan_add_del_tunnel(
56 src_addr=cls.pg2.local_ip4n,
57 dst_addr=cls.pg2.remote_ip4n,
62 super(TestSpan, self).setUp()
63 self.reset_packet_infos()
66 super(TestSpan, self).tearDown()
68 self.logger.info(self.vapi.ppcli("show interface span"))
70 def xconnect(self, a, b, is_add=1):
71 self.vapi.sw_interface_set_l2_xconnect(a, b, enable=is_add)
72 self.vapi.sw_interface_set_l2_xconnect(b, a, enable=is_add)
74 def bridge(self, sw_if_index, is_add=1):
75 self.vapi.sw_interface_set_l2_bridge(
76 sw_if_index, bd_id=self.bd_id, enable=is_add)
78 def _remove_tag(self, packet, vlan, tag_type):
79 self.assertEqual(packet.type, tag_type)
80 payload = packet.payload
81 self.assertEqual(payload.vlan, vlan)
82 inner_type = payload.type
83 payload = payload.payload
84 packet.remove_payload()
85 packet.add_payload(payload)
86 packet.type = inner_type
88 def remove_tags(self, packet, tags):
90 self._remove_tag(packet, t.vlan, t.dot1)
93 def decap_gre(self, pkt):
95 Decapsulate the original payload frame by removing GRE header
97 self.assertEqual(pkt[Ether].src, self.pg2.local_mac)
98 self.assertEqual(pkt[Ether].dst, self.pg2.remote_mac)
100 self.assertEqual(pkt[IP].src, self.pg2.local_ip4)
101 self.assertEqual(pkt[IP].dst, self.pg2.remote_ip4)
103 return pkt[GRE].payload
105 def decap_vxlan(self, pkt):
107 Decapsulate the original payload frame by removing VXLAN header
109 self.assertEqual(pkt[Ether].src, self.pg2.local_mac)
110 self.assertEqual(pkt[Ether].dst, self.pg2.remote_mac)
112 self.assertEqual(pkt[IP].src, self.pg2.local_ip4)
113 self.assertEqual(pkt[IP].dst, self.pg2.remote_ip4)
115 return pkt[VXLAN].payload
117 def create_stream(self, src_if, packet_sizes, do_dot1=False, bcast=False):
119 dst_if = self.flows[src_if][0]
120 dst_mac = src_if.remote_mac
122 dst_mac = "ff:ff:ff:ff:ff:ff"
124 for i in range(0, self.pkts_per_burst):
125 payload = "span test"
126 size = packet_sizes[(i / 2) % len(packet_sizes)]
127 p = (Ether(src=src_if.local_mac, dst=dst_mac) /
128 IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4) /
129 UDP(sport=10000 + src_if.sw_if_index * 1000 + i, dport=1234) /
132 p = self.sub_if.add_dot1_layer(p)
133 self.extend_packet(p, size)
137 def verify_capture(self, cap1, cap2):
138 self.assertEqual(len(cap1), len(cap2),
139 "Different number of sent and mirrored packets :"
140 "%u != %u" % (len(cap1), len(cap2)))
142 pkts1 = [(pkt[Ether] / pkt[IP] / pkt[UDP]) for pkt in cap1]
143 pkts2 = [(pkt[Ether] / pkt[IP] / pkt[UDP]) for pkt in cap2]
145 self.assertEqual(pkts1.sort(), pkts2.sort())
147 def test_device_span(self):
148 """ SPAN device rx mirror """
150 # Create bi-directional cross-connects between pg0 and pg1
151 self.xconnect(self.pg0.sw_if_index, self.pg1.sw_if_index)
152 # Create incoming packet streams for packet-generator interfaces
153 pkts = self.create_stream(self.pg0, self.pg_if_packet_sizes)
154 self.pg0.add_stream(pkts)
156 # Enable SPAN on pg0 (mirrored to pg2)
157 self.vapi.sw_interface_span_enable_disable(
158 self.pg0.sw_if_index, self.pg2.sw_if_index)
160 self.logger.info(self.vapi.ppcli("show interface span"))
161 # Enable packet capturing and start packet sending
162 self.pg_enable_capture(self.pg_interfaces)
165 # Verify packets outgoing packet streams on mirrored interface (pg2)
167 pg1_pkts = self.pg1.get_capture(n_pkts)
168 pg2_pkts = self.pg2.get_capture(n_pkts)
170 # Disable SPAN on pg0 (mirrored to pg2)
171 self.vapi.sw_interface_span_enable_disable(
172 self.pg0.sw_if_index, self.pg2.sw_if_index, state=0)
173 self.xconnect(self.pg0.sw_if_index, self.pg1.sw_if_index, is_add=0)
175 self.verify_capture(pg1_pkts, pg2_pkts)
177 def test_span_l2_rx(self):
178 """ SPAN l2 rx mirror """
180 self.sub_if.admin_up()
182 self.bridge(self.pg2.sw_if_index)
183 # Create bi-directional cross-connects between pg0 subif and pg1
184 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
185 # Create incoming packet streams for packet-generator interfaces
186 pkts = self.create_stream(
187 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
188 self.pg0.add_stream(pkts)
190 # Enable SPAN on pg0 (mirrored to pg2)
191 self.vapi.sw_interface_span_enable_disable(
192 self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1)
194 self.logger.info(self.vapi.ppcli("show interface span"))
195 # Enable packet capturing and start packet sending
196 self.pg_enable_capture(self.pg_interfaces)
199 # Verify packets outgoing packet streams on mirrored interface (pg2)
200 pg2_expected = len(pkts)
201 pg1_pkts = self.pg1.get_capture(pg2_expected)
202 pg2_pkts = self.pg2.get_capture(pg2_expected)
203 self.bridge(self.pg2.sw_if_index, is_add=0)
205 # Disable SPAN on pg0 (mirrored to pg2)
206 self.vapi.sw_interface_span_enable_disable(
207 self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
208 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
210 self.verify_capture(pg1_pkts, pg2_pkts)
212 def test_span_l2_rx_dst_vxlan(self):
213 """ SPAN l2 rx mirror into vxlan """
215 self.sub_if.admin_up()
216 self.vapi.sw_interface_set_flags(self.vxlan.sw_if_index,
219 self.bridge(self.vxlan.sw_if_index, is_add=1)
220 # Create bi-directional cross-connects between pg0 subif and pg1
221 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
222 # Create incoming packet streams for packet-generator interfaces
223 pkts = self.create_stream(
224 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
225 self.pg0.add_stream(pkts)
227 # Enable SPAN on pg0 sub if (mirrored to vxlan)
228 self.vapi.sw_interface_span_enable_disable(
229 self.sub_if.sw_if_index, self.vxlan.sw_if_index, is_l2=1)
231 self.logger.info(self.vapi.ppcli("show interface span"))
232 # Enable packet capturing and start packet sending
233 self.pg_enable_capture(self.pg_interfaces)
236 # Verify packets outgoing packet streams on mirrored interface (pg2)
238 pg1_pkts = self.pg1.get_capture(n_pkts)
239 pg2_pkts = [self.decap_vxlan(p) for p in self.pg2.get_capture(n_pkts)]
241 self.bridge(self.vxlan.sw_if_index, is_add=0)
242 # Disable SPAN on pg0 sub if (mirrored to vxlan)
243 self.vapi.sw_interface_span_enable_disable(
244 self.sub_if.sw_if_index, self.vxlan.sw_if_index, state=0, is_l2=1)
245 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
246 self.verify_capture(pg1_pkts, pg2_pkts)
248 def test_span_l2_rx_dst_gre_subif_vtr(self):
249 """ SPAN l2 rx mirror into gre-subif+vtr """
251 self.sub_if.admin_up()
253 gre_if = VppGreInterface(self, self.pg2.local_ip4,
257 gre_if.add_vpp_config()
260 gre_sub_if = VppDot1QSubint(self, gre_if, 500)
261 gre_sub_if.set_vtr(L2_VTR_OP.L2_POP_1, tag=500)
262 gre_sub_if.admin_up()
264 self.bridge(gre_sub_if.sw_if_index)
265 # Create bi-directional cross-connects between pg0 and pg1
266 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
268 # Create incoming packet streams for packet-generator interfaces
269 pkts = self.create_stream(
270 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
271 self.pg0.add_stream(pkts)
273 self.vapi.sw_interface_span_enable_disable(
274 self.sub_if.sw_if_index, gre_sub_if.sw_if_index, is_l2=1)
276 # Enable packet capturing and start packet sending
277 self.pg_enable_capture(self.pg_interfaces)
280 # Verify packets outgoing packet streams on mirrored interface (pg2)
282 pg1_pkts = self.pg1.get_capture(n_pkts)
283 pg2_pkts = self.pg2.get_capture(n_pkts)
285 def decap(p): return self.remove_tags(
286 self.decap_gre(p), [Tag(dot1=DOT1Q, vlan=500)])
287 pg2_decaped = [decap(p) for p in pg2_pkts]
289 self.bridge(gre_sub_if.sw_if_index, is_add=0)
291 # Disable SPAN on pg0 sub if
292 self.vapi.sw_interface_span_enable_disable(
293 self.sub_if.sw_if_index, gre_sub_if.sw_if_index, state=0, is_l2=1)
294 gre_if.remove_vpp_config()
295 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
297 self.verify_capture(pg1_pkts, pg2_decaped)
299 def test_span_l2_rx_dst_1q_vtr(self):
300 """ SPAN l2 rx mirror into 1q subif+vtr """
302 self.sub_if.admin_up()
303 self.vlan_sub_if.admin_up()
305 self.bridge(self.vlan_sub_if.sw_if_index)
306 # Create bi-directional cross-connects between pg0 and pg1
307 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
309 # Create incoming packet streams for packet-generator interfaces
310 pkts = self.create_stream(
311 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
312 self.pg0.add_stream(pkts)
314 self.vapi.sw_interface_span_enable_disable(
315 self.sub_if.sw_if_index, self.vlan_sub_if.sw_if_index, is_l2=1)
317 # Enable packet capturing and start packet sending
318 self.pg_enable_capture(self.pg_interfaces)
321 # Verify packets outgoing packet streams on mirrored interface (pg2)
323 pg1_pkts = self.pg1.get_capture(n_pkts)
324 pg2_pkts = self.pg2.get_capture(n_pkts)
325 pg2_untagged = [self.remove_tags(p, [Tag(dot1=DOT1Q, vlan=300)])
328 self.bridge(self.vlan_sub_if.sw_if_index, is_add=0)
329 # Disable SPAN on pg0 sub if (mirrored to vxlan)
330 self.vapi.sw_interface_span_enable_disable(
331 self.sub_if.sw_if_index, self.vlan_sub_if.sw_if_index, state=0,
333 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
335 self.verify_capture(pg1_pkts, pg2_untagged)
337 def test_span_l2_rx_dst_1ad_vtr(self):
338 """ SPAN l2 rx mirror into 1ad subif+vtr """
340 self.sub_if.admin_up()
341 self.qinq_sub_if.admin_up()
343 self.bridge(self.qinq_sub_if.sw_if_index)
344 # Create bi-directional cross-connects between pg0 and pg1
345 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
347 # Create incoming packet streams for packet-generator interfaces
348 pkts = self.create_stream(
349 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
350 self.pg0.add_stream(pkts)
352 self.vapi.sw_interface_span_enable_disable(
353 self.sub_if.sw_if_index, self.qinq_sub_if.sw_if_index, is_l2=1)
355 # Enable packet capturing and start packet sending
356 self.pg_enable_capture(self.pg_interfaces)
359 # Verify packets outgoing packet streams on mirrored interface (pg2)
361 pg1_pkts = self.pg1.get_capture(n_pkts)
362 pg2_pkts = self.pg2.get_capture(n_pkts)
363 pg2_untagged = [self.remove_tags(p, [Tag(dot1=DOT1AD, vlan=400),
364 Tag(dot1=DOT1Q, vlan=500)])
367 self.bridge(self.qinq_sub_if.sw_if_index, is_add=0)
368 # Disable SPAN on pg0 sub if (mirrored to vxlan)
369 self.vapi.sw_interface_span_enable_disable(
370 self.sub_if.sw_if_index, self.qinq_sub_if.sw_if_index, state=0,
372 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
374 self.verify_capture(pg1_pkts, pg2_untagged)
376 def test_l2_tx_span(self):
377 """ SPAN l2 tx mirror """
379 self.sub_if.admin_up()
380 self.bridge(self.pg2.sw_if_index)
381 # Create bi-directional cross-connects between pg0 and pg1
382 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
383 # Create incoming packet streams for packet-generator interfaces
384 pkts = self.create_stream(
385 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
386 self.pg0.add_stream(pkts)
388 # Enable SPAN on pg1 (mirrored to pg2)
389 self.vapi.sw_interface_span_enable_disable(
390 self.pg1.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=2)
392 self.logger.info(self.vapi.ppcli("show interface span"))
393 # Enable packet capturing and start packet sending
394 self.pg_enable_capture(self.pg_interfaces)
397 # Verify packets outgoing packet streams on mirrored interface (pg2)
399 pg1_pkts = self.pg1.get_capture(n_pkts)
400 pg2_pkts = self.pg2.get_capture(n_pkts)
401 self.bridge(self.pg2.sw_if_index, is_add=0)
402 # Disable SPAN on pg0 (mirrored to pg2)
403 self.vapi.sw_interface_span_enable_disable(
404 self.pg1.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
405 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
407 self.verify_capture(pg1_pkts, pg2_pkts)
409 def test_l2_rx_tx_span(self):
410 """ SPAN l2 rx tx mirror """
412 self.sub_if.admin_up()
413 self.bridge(self.pg2.sw_if_index)
414 # Create bi-directional cross-connects between pg0 and pg1
415 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
417 # Create incoming packet streams for packet-generator interfaces
418 pg0_pkts = self.create_stream(
419 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
420 self.pg0.add_stream(pg0_pkts)
421 pg1_pkts = self.create_stream(
422 self.pg1, self.pg_if_packet_sizes, do_dot1=False)
423 self.pg1.add_stream(pg1_pkts)
425 # Enable SPAN on pg0 (mirrored to pg2)
426 self.vapi.sw_interface_span_enable_disable(
427 self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=3)
428 self.logger.info(self.vapi.ppcli("show interface span"))
430 # Enable packet capturing and start packet sending
431 self.pg_enable_capture(self.pg_interfaces)
434 # Verify packets outgoing packet streams on mirrored interface (pg2)
435 pg0_expected = len(pg1_pkts)
436 pg1_expected = len(pg0_pkts)
437 pg2_expected = pg0_expected + pg1_expected
439 pg0_pkts = self.pg0.get_capture(pg0_expected)
440 pg1_pkts = self.pg1.get_capture(pg1_expected)
441 pg2_pkts = self.pg2.get_capture(pg2_expected)
443 self.bridge(self.pg2.sw_if_index, is_add=0)
444 # Disable SPAN on pg0 (mirrored to pg2)
445 self.vapi.sw_interface_span_enable_disable(
446 self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
447 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
449 self.verify_capture(pg0_pkts + pg1_pkts, pg2_pkts)
451 def test_l2_bcast_mirror(self):
452 """ SPAN l2 broadcast mirror """
454 self.sub_if.admin_up()
455 self.bridge(self.pg2.sw_if_index)
457 # Create bi-directional cross-connects between pg0 and pg1
458 self.vapi.sw_interface_set_l2_bridge(
459 self.sub_if.sw_if_index, bd_id=99, enable=1)
460 self.vapi.sw_interface_set_l2_bridge(
461 self.pg1.sw_if_index, bd_id=99, enable=1)
463 # Create incoming packet streams for packet-generator interfaces
464 pg0_pkts = self.create_stream(
465 self.pg0, self.pg_if_packet_sizes, do_dot1=True, bcast=True)
466 self.pg0.add_stream(pg0_pkts)
467 pg1_pkts = self.create_stream(
468 self.pg1, self.pg_if_packet_sizes, do_dot1=False, bcast=True)
469 self.pg1.add_stream(pg1_pkts)
471 # Enable SPAN on pg0 (mirrored to pg2)
472 self.vapi.sw_interface_span_enable_disable(
473 self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=3)
474 self.logger.info(self.vapi.ppcli("show interface span"))
476 # Enable packet capturing and start packet sending
477 self.pg_enable_capture(self.pg_interfaces)
480 # Verify packets outgoing packet streams on mirrored interface (pg2)
481 pg0_expected = len(pg1_pkts)
482 pg1_expected = len(pg0_pkts)
483 pg2_expected = pg0_expected + pg1_expected
485 pg0_pkts = self.pg0.get_capture(pg0_expected)
486 pg1_pkts = self.pg1.get_capture(pg1_expected)
487 pg2_pkts = self.pg2.get_capture(pg2_expected)
489 self.bridge(self.pg2.sw_if_index, is_add=0)
490 self.vapi.sw_interface_set_l2_bridge(
491 self.sub_if.sw_if_index, bd_id=99, enable=0)
492 self.vapi.sw_interface_set_l2_bridge(
493 self.pg1.sw_if_index, bd_id=99, enable=0)
494 # Disable SPAN on pg0 (mirrored to pg2)
495 self.vapi.sw_interface_span_enable_disable(
496 self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
498 self.verify_capture(pg0_pkts + pg1_pkts, pg2_pkts)
501 if __name__ == '__main__':
502 unittest.main(testRunner=VppTestRunner)