5 from scapy.packet import Raw
6 from scapy.layers.l2 import Ether, Dot1Q, GRE, ERSPAN
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 L2_VTR_OP, VppDot1QSubint, VppDot1ADSubint
13 from vpp_gre_interface import VppGreInterface, VppGre6Interface
14 from collections import namedtuple
16 Tag = namedtuple('Tag', ['dot1', 'vlan'])
21 class TestSpan(VppTestCase):
22 """ SPAN Test Case """
26 super(TestSpan, cls).setUpClass()
28 cls.pkts_per_burst = 257 # Number of packets per burst
29 # create 3 pg interfaces
30 cls.create_pg_interfaces(range(3))
33 cls.sub_if = VppDot1QSubint(cls, cls.pg0, 100)
34 cls.vlan_sub_if = VppDot1QSubint(cls, cls.pg2, 300)
35 cls.vlan_sub_if.set_vtr(L2_VTR_OP.L2_POP_1, tag=300)
37 cls.qinq_sub_if = VppDot1ADSubint(cls, cls.pg2, 33, 400, 500)
38 cls.qinq_sub_if.set_vtr(L2_VTR_OP.L2_POP_2, outer=500, inner=400)
40 # packet flows mapping pg0 -> pg1, pg2 -> pg3, etc.
42 cls.flows[cls.pg0] = [cls.pg1]
43 cls.flows[cls.pg1] = [cls.pg0]
46 cls.pg_if_packet_sizes = [64, 512, 1518] # , 9018]
48 # setup all interfaces
49 for i in cls.pg_interfaces:
54 cls.vxlan = cls.vapi.vxlan_add_del_tunnel(
55 src_address=cls.pg2.local_ip4n, dst_address=cls.pg2.remote_ip4n,
59 super(TestSpan, self).setUp()
60 self.reset_packet_infos()
63 super(TestSpan, self).tearDown()
65 def show_commands_at_teardown(self):
66 self.logger.info(self.vapi.ppcli("show interface span"))
68 def xconnect(self, a, b, is_add=1):
69 self.vapi.sw_interface_set_l2_xconnect(a, b, enable=is_add)
70 self.vapi.sw_interface_set_l2_xconnect(b, a, enable=is_add)
72 def bridge(self, sw_if_index, is_add=1):
73 self.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=sw_if_index,
74 bd_id=self.bd_id, enable=is_add)
76 def _remove_tag(self, packet, vlan, tag_type):
77 self.assertEqual(packet.type, tag_type)
78 payload = packet.payload
79 self.assertEqual(payload.vlan, vlan)
80 inner_type = payload.type
81 payload = payload.payload
82 packet.remove_payload()
83 packet.add_payload(payload)
84 packet.type = inner_type
86 def remove_tags(self, packet, tags):
88 self._remove_tag(packet, t.vlan, t.dot1)
91 def decap_gre(self, pkt):
93 Decapsulate the original payload frame by removing GRE header
95 self.assertEqual(pkt[Ether].src, self.pg2.local_mac)
96 self.assertEqual(pkt[Ether].dst, self.pg2.remote_mac)
98 self.assertEqual(pkt[IP].src, self.pg2.local_ip4)
99 self.assertEqual(pkt[IP].dst, self.pg2.remote_ip4)
101 return pkt[GRE].payload
103 def decap_erspan(self, pkt, session):
105 Decapsulate the original payload frame by removing ERSPAN header
107 self.assertEqual(pkt[Ether].src, self.pg2.local_mac)
108 self.assertEqual(pkt[Ether].dst, self.pg2.remote_mac)
110 self.assertEqual(pkt[IP].src, self.pg2.local_ip4)
111 self.assertEqual(pkt[IP].dst, self.pg2.remote_ip4)
113 self.assertEqual(pkt[ERSPAN].ver, 1)
114 self.assertEqual(pkt[ERSPAN].vlan, 0)
115 self.assertEqual(pkt[ERSPAN].cos, 0)
116 self.assertEqual(pkt[ERSPAN].en, 3)
117 self.assertEqual(pkt[ERSPAN].t, 0)
118 self.assertEqual(pkt[ERSPAN].session_id, session)
119 self.assertEqual(pkt[ERSPAN].reserved, 0)
120 self.assertEqual(pkt[ERSPAN].index, 0)
122 return pkt[ERSPAN].payload
124 def decap_vxlan(self, pkt):
126 Decapsulate the original payload frame by removing VXLAN header
128 self.assertEqual(pkt[Ether].src, self.pg2.local_mac)
129 self.assertEqual(pkt[Ether].dst, self.pg2.remote_mac)
131 self.assertEqual(pkt[IP].src, self.pg2.local_ip4)
132 self.assertEqual(pkt[IP].dst, self.pg2.remote_ip4)
134 return pkt[VXLAN].payload
136 def create_stream(self, src_if, packet_sizes, do_dot1=False, bcast=False):
138 dst_if = self.flows[src_if][0]
139 dst_mac = src_if.remote_mac
141 dst_mac = "ff:ff:ff:ff:ff:ff"
143 for i in range(0, self.pkts_per_burst):
144 payload = "span test"
145 size = packet_sizes[(i / 2) % len(packet_sizes)]
146 p = (Ether(src=src_if.local_mac, dst=dst_mac) /
147 IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4) /
148 UDP(sport=10000 + src_if.sw_if_index * 1000 + i, dport=1234) /
151 p = self.sub_if.add_dot1_layer(p)
152 self.extend_packet(p, size)
156 def verify_capture(self, cap1, cap2):
157 self.assertEqual(len(cap1), len(cap2),
158 "Different number of sent and mirrored packets :"
159 "%u != %u" % (len(cap1), len(cap2)))
161 pkts1 = [(pkt[Ether] / pkt[IP] / pkt[UDP]) for pkt in cap1]
162 pkts2 = [(pkt[Ether] / pkt[IP] / pkt[UDP]) for pkt in cap2]
164 self.assertEqual(pkts1.sort(), pkts2.sort())
166 def test_device_span(self):
167 """ SPAN device rx mirror """
169 # Create bi-directional cross-connects between pg0 and pg1
170 self.xconnect(self.pg0.sw_if_index, self.pg1.sw_if_index)
171 # Create incoming packet streams for packet-generator interfaces
172 pkts = self.create_stream(self.pg0, self.pg_if_packet_sizes)
173 self.pg0.add_stream(pkts)
175 # Enable SPAN on pg0 (mirrored to pg2)
176 self.vapi.sw_interface_span_enable_disable(
177 self.pg0.sw_if_index, self.pg2.sw_if_index)
179 self.logger.info(self.vapi.ppcli("show interface span"))
180 # Enable packet capturing and start packet sending
181 self.pg_enable_capture(self.pg_interfaces)
184 # Verify packets outgoing packet streams on mirrored interface (pg2)
186 pg1_pkts = self.pg1.get_capture(n_pkts)
187 pg2_pkts = self.pg2.get_capture(n_pkts)
189 # Disable SPAN on pg0 (mirrored to pg2)
190 self.vapi.sw_interface_span_enable_disable(
191 self.pg0.sw_if_index, self.pg2.sw_if_index, state=0)
192 self.xconnect(self.pg0.sw_if_index, self.pg1.sw_if_index, is_add=0)
194 self.verify_capture(pg1_pkts, pg2_pkts)
196 def test_span_l2_rx(self):
197 """ SPAN l2 rx mirror """
199 self.sub_if.admin_up()
201 self.bridge(self.pg2.sw_if_index)
202 # Create bi-directional cross-connects between pg0 subif and pg1
203 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
204 # Create incoming packet streams for packet-generator interfaces
205 pkts = self.create_stream(
206 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
207 self.pg0.add_stream(pkts)
209 # Enable SPAN on pg0 (mirrored to pg2)
210 self.vapi.sw_interface_span_enable_disable(
211 self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1)
213 self.logger.info(self.vapi.ppcli("show interface span"))
214 # Enable packet capturing and start packet sending
215 self.pg_enable_capture(self.pg_interfaces)
218 # Verify packets outgoing packet streams on mirrored interface (pg2)
219 pg2_expected = len(pkts)
220 pg1_pkts = self.pg1.get_capture(pg2_expected)
221 pg2_pkts = self.pg2.get_capture(pg2_expected)
222 self.bridge(self.pg2.sw_if_index, is_add=0)
224 # Disable SPAN on pg0 (mirrored to pg2)
225 self.vapi.sw_interface_span_enable_disable(
226 self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
227 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
229 self.verify_capture(pg1_pkts, pg2_pkts)
231 def test_span_l2_rx_dst_vxlan(self):
232 """ SPAN l2 rx mirror into vxlan """
234 self.sub_if.admin_up()
235 self.vapi.sw_interface_set_flags(self.vxlan.sw_if_index,
238 self.bridge(self.vxlan.sw_if_index, is_add=1)
239 # Create bi-directional cross-connects between pg0 subif and pg1
240 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
241 # Create incoming packet streams for packet-generator interfaces
242 pkts = self.create_stream(
243 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
244 self.pg0.add_stream(pkts)
246 # Enable SPAN on pg0 sub if (mirrored to vxlan)
247 self.vapi.sw_interface_span_enable_disable(
248 self.sub_if.sw_if_index, self.vxlan.sw_if_index, is_l2=1)
250 self.logger.info(self.vapi.ppcli("show interface span"))
251 # Enable packet capturing and start packet sending
252 self.pg_enable_capture(self.pg_interfaces)
255 # Verify packets outgoing packet streams on mirrored interface (pg2)
257 pg1_pkts = self.pg1.get_capture(n_pkts)
258 pg2_pkts = [self.decap_vxlan(p) for p in self.pg2.get_capture(n_pkts)]
260 self.bridge(self.vxlan.sw_if_index, is_add=0)
261 # Disable SPAN on pg0 sub if (mirrored to vxlan)
262 self.vapi.sw_interface_span_enable_disable(
263 self.sub_if.sw_if_index, self.vxlan.sw_if_index, state=0, is_l2=1)
264 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
265 self.verify_capture(pg1_pkts, pg2_pkts)
267 def test_span_l2_rx_dst_gre_erspan(self):
268 """ SPAN l2 rx mirror into gre-erspan """
270 self.sub_if.admin_up()
272 gre_if = VppGreInterface(self, self.pg2.local_ip4,
277 gre_if.add_vpp_config()
280 self.bridge(gre_if.sw_if_index)
281 # Create bi-directional cross-connects between pg0 and pg1
282 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
284 # Create incoming packet streams for packet-generator interfaces
285 pkts = self.create_stream(
286 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
287 self.pg0.add_stream(pkts)
289 # Enable SPAN on pg0 sub if (mirrored to gre-erspan)
290 self.vapi.sw_interface_span_enable_disable(
291 self.sub_if.sw_if_index, gre_if.sw_if_index, is_l2=1)
293 # Enable packet capturing and start packet sending
294 self.pg_enable_capture(self.pg_interfaces)
297 # Verify packets outgoing packet streams on mirrored interface (pg2)
299 pg1_pkts = self.pg1.get_capture(n_pkts)
300 pg2_pkts = self.pg2.get_capture(n_pkts)
302 def decap(p): return self.decap_erspan(p, session=543)
303 pg2_decaped = [decap(p) for p in pg2_pkts]
305 self.bridge(gre_if.sw_if_index, is_add=0)
307 # Disable SPAN on pg0 sub if
308 self.vapi.sw_interface_span_enable_disable(
309 self.sub_if.sw_if_index, gre_if.sw_if_index, state=0, is_l2=1)
310 gre_if.remove_vpp_config()
311 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
313 self.verify_capture(pg1_pkts, pg2_decaped)
315 def test_span_l2_rx_dst_gre_subif_vtr(self):
316 """ SPAN l2 rx mirror into gre-subif+vtr """
318 self.sub_if.admin_up()
320 gre_if = VppGreInterface(self, self.pg2.local_ip4,
324 gre_if.add_vpp_config()
327 gre_sub_if = VppDot1QSubint(self, gre_if, 500)
328 gre_sub_if.set_vtr(L2_VTR_OP.L2_POP_1, tag=500)
329 gre_sub_if.admin_up()
331 self.bridge(gre_sub_if.sw_if_index)
332 # Create bi-directional cross-connects between pg0 and pg1
333 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
335 # Create incoming packet streams for packet-generator interfaces
336 pkts = self.create_stream(
337 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
338 self.pg0.add_stream(pkts)
340 # Enable SPAN on pg0 sub if (mirrored to gre sub if)
341 self.vapi.sw_interface_span_enable_disable(
342 self.sub_if.sw_if_index, gre_sub_if.sw_if_index, is_l2=1)
344 # Enable packet capturing and start packet sending
345 self.pg_enable_capture(self.pg_interfaces)
348 # Verify packets outgoing packet streams on mirrored interface (pg2)
350 pg1_pkts = self.pg1.get_capture(n_pkts)
351 pg2_pkts = self.pg2.get_capture(n_pkts)
353 def decap(p): return self.remove_tags(
354 self.decap_gre(p), [Tag(dot1=DOT1Q, vlan=500)])
355 pg2_decaped = [decap(p) for p in pg2_pkts]
357 self.bridge(gre_sub_if.sw_if_index, is_add=0)
359 # Disable SPAN on pg0 sub if
360 self.vapi.sw_interface_span_enable_disable(
361 self.sub_if.sw_if_index, gre_sub_if.sw_if_index, state=0, is_l2=1)
362 gre_if.remove_vpp_config()
363 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
365 self.verify_capture(pg1_pkts, pg2_decaped)
367 def test_span_l2_rx_dst_1q_vtr(self):
368 """ SPAN l2 rx mirror into 1q subif+vtr """
370 self.sub_if.admin_up()
371 self.vlan_sub_if.admin_up()
373 self.bridge(self.vlan_sub_if.sw_if_index)
374 # Create bi-directional cross-connects between pg0 and pg1
375 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
377 # Create incoming packet streams for packet-generator interfaces
378 pkts = self.create_stream(
379 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
380 self.pg0.add_stream(pkts)
382 self.vapi.sw_interface_span_enable_disable(
383 self.sub_if.sw_if_index, self.vlan_sub_if.sw_if_index, is_l2=1)
385 # Enable packet capturing and start packet sending
386 self.pg_enable_capture(self.pg_interfaces)
389 # Verify packets outgoing packet streams on mirrored interface (pg2)
391 pg1_pkts = self.pg1.get_capture(n_pkts)
392 pg2_pkts = self.pg2.get_capture(n_pkts)
393 pg2_untagged = [self.remove_tags(p, [Tag(dot1=DOT1Q, vlan=300)])
396 self.bridge(self.vlan_sub_if.sw_if_index, is_add=0)
397 # Disable SPAN on pg0 sub if (mirrored to vxlan)
398 self.vapi.sw_interface_span_enable_disable(
399 self.sub_if.sw_if_index, self.vlan_sub_if.sw_if_index, state=0,
401 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
403 self.verify_capture(pg1_pkts, pg2_untagged)
405 def test_span_l2_rx_dst_1ad_vtr(self):
406 """ SPAN l2 rx mirror into 1ad subif+vtr """
408 self.sub_if.admin_up()
409 self.qinq_sub_if.admin_up()
411 self.bridge(self.qinq_sub_if.sw_if_index)
412 # Create bi-directional cross-connects between pg0 and pg1
413 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
415 # Create incoming packet streams for packet-generator interfaces
416 pkts = self.create_stream(
417 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
418 self.pg0.add_stream(pkts)
420 self.vapi.sw_interface_span_enable_disable(
421 self.sub_if.sw_if_index, self.qinq_sub_if.sw_if_index, is_l2=1)
423 # Enable packet capturing and start packet sending
424 self.pg_enable_capture(self.pg_interfaces)
427 # Verify packets outgoing packet streams on mirrored interface (pg2)
429 pg1_pkts = self.pg1.get_capture(n_pkts)
430 pg2_pkts = self.pg2.get_capture(n_pkts)
431 pg2_untagged = [self.remove_tags(p, [Tag(dot1=DOT1AD, vlan=400),
432 Tag(dot1=DOT1Q, vlan=500)])
435 self.bridge(self.qinq_sub_if.sw_if_index, is_add=0)
436 # Disable SPAN on pg0 sub if (mirrored to vxlan)
437 self.vapi.sw_interface_span_enable_disable(
438 self.sub_if.sw_if_index, self.qinq_sub_if.sw_if_index, state=0,
440 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
442 self.verify_capture(pg1_pkts, pg2_untagged)
444 def test_l2_tx_span(self):
445 """ SPAN l2 tx mirror """
447 self.sub_if.admin_up()
448 self.bridge(self.pg2.sw_if_index)
449 # Create bi-directional cross-connects between pg0 and pg1
450 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
451 # Create incoming packet streams for packet-generator interfaces
452 pkts = self.create_stream(
453 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
454 self.pg0.add_stream(pkts)
456 # Enable SPAN on pg1 (mirrored to pg2)
457 self.vapi.sw_interface_span_enable_disable(
458 self.pg1.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=2)
460 self.logger.info(self.vapi.ppcli("show interface span"))
461 # Enable packet capturing and start packet sending
462 self.pg_enable_capture(self.pg_interfaces)
465 # Verify packets outgoing packet streams on mirrored interface (pg2)
467 pg1_pkts = self.pg1.get_capture(n_pkts)
468 pg2_pkts = self.pg2.get_capture(n_pkts)
469 self.bridge(self.pg2.sw_if_index, is_add=0)
470 # Disable SPAN on pg0 (mirrored to pg2)
471 self.vapi.sw_interface_span_enable_disable(
472 self.pg1.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
473 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
475 self.verify_capture(pg1_pkts, pg2_pkts)
477 def test_l2_rx_tx_span(self):
478 """ SPAN l2 rx tx mirror """
480 self.sub_if.admin_up()
481 self.bridge(self.pg2.sw_if_index)
482 # Create bi-directional cross-connects between pg0 and pg1
483 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
485 # Create incoming packet streams for packet-generator interfaces
486 pg0_pkts = self.create_stream(
487 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
488 self.pg0.add_stream(pg0_pkts)
489 pg1_pkts = self.create_stream(
490 self.pg1, self.pg_if_packet_sizes, do_dot1=False)
491 self.pg1.add_stream(pg1_pkts)
493 # Enable SPAN on pg0 (mirrored to pg2)
494 self.vapi.sw_interface_span_enable_disable(
495 self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=3)
496 self.logger.info(self.vapi.ppcli("show interface span"))
498 # Enable packet capturing and start packet sending
499 self.pg_enable_capture(self.pg_interfaces)
502 # Verify packets outgoing packet streams on mirrored interface (pg2)
503 pg0_expected = len(pg1_pkts)
504 pg1_expected = len(pg0_pkts)
505 pg2_expected = pg0_expected + pg1_expected
507 pg0_pkts = self.pg0.get_capture(pg0_expected)
508 pg1_pkts = self.pg1.get_capture(pg1_expected)
509 pg2_pkts = self.pg2.get_capture(pg2_expected)
511 self.bridge(self.pg2.sw_if_index, is_add=0)
512 # Disable SPAN on pg0 (mirrored to pg2)
513 self.vapi.sw_interface_span_enable_disable(
514 self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
515 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
517 self.verify_capture(pg0_pkts + pg1_pkts, pg2_pkts)
519 def test_l2_bcast_mirror(self):
520 """ SPAN l2 broadcast mirror """
522 self.sub_if.admin_up()
523 self.bridge(self.pg2.sw_if_index)
525 # Create bi-directional cross-connects between pg0 and pg1
526 self.vapi.sw_interface_set_l2_bridge(
527 rx_sw_if_index=self.sub_if.sw_if_index, bd_id=99, enable=1)
528 self.vapi.sw_interface_set_l2_bridge(
529 rx_sw_if_index=self.pg1.sw_if_index, bd_id=99, enable=1)
531 # Create incoming packet streams for packet-generator interfaces
532 pg0_pkts = self.create_stream(
533 self.pg0, self.pg_if_packet_sizes, do_dot1=True, bcast=True)
534 self.pg0.add_stream(pg0_pkts)
535 pg1_pkts = self.create_stream(
536 self.pg1, self.pg_if_packet_sizes, do_dot1=False, bcast=True)
537 self.pg1.add_stream(pg1_pkts)
539 # Enable SPAN on pg0 (mirrored to pg2)
540 self.vapi.sw_interface_span_enable_disable(
541 self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=3)
542 self.logger.info(self.vapi.ppcli("show interface span"))
544 # Enable packet capturing and start packet sending
545 self.pg_enable_capture(self.pg_interfaces)
548 # Verify packets outgoing packet streams on mirrored interface (pg2)
549 pg0_expected = len(pg1_pkts)
550 pg1_expected = len(pg0_pkts)
551 pg2_expected = pg0_expected + pg1_expected
553 pg0_pkts = self.pg0.get_capture(pg0_expected)
554 pg1_pkts = self.pg1.get_capture(pg1_expected)
555 pg2_pkts = self.pg2.get_capture(pg2_expected)
557 self.bridge(self.pg2.sw_if_index, is_add=0)
558 self.vapi.sw_interface_set_l2_bridge(
559 rx_sw_if_index=self.sub_if.sw_if_index, bd_id=99, enable=0)
560 self.vapi.sw_interface_set_l2_bridge(
561 rx_sw_if_index=self.pg1.sw_if_index, bd_id=99, enable=0)
562 # Disable SPAN on pg0 (mirrored to pg2)
563 self.vapi.sw_interface_span_enable_disable(
564 self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
566 self.verify_capture(pg0_pkts + pg1_pkts, pg2_pkts)
569 if __name__ == '__main__':
570 unittest.main(testRunner=VppTestRunner)