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 self.logger.info(self.vapi.ppcli("show interface span"))
67 def xconnect(self, a, b, is_add=1):
68 self.vapi.sw_interface_set_l2_xconnect(a, b, enable=is_add)
69 self.vapi.sw_interface_set_l2_xconnect(b, a, enable=is_add)
71 def bridge(self, sw_if_index, is_add=1):
72 self.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=sw_if_index,
73 bd_id=self.bd_id, enable=is_add)
75 def _remove_tag(self, packet, vlan, tag_type):
76 self.assertEqual(packet.type, tag_type)
77 payload = packet.payload
78 self.assertEqual(payload.vlan, vlan)
79 inner_type = payload.type
80 payload = payload.payload
81 packet.remove_payload()
82 packet.add_payload(payload)
83 packet.type = inner_type
85 def remove_tags(self, packet, tags):
87 self._remove_tag(packet, t.vlan, t.dot1)
90 def decap_gre(self, pkt):
92 Decapsulate the original payload frame by removing GRE header
94 self.assertEqual(pkt[Ether].src, self.pg2.local_mac)
95 self.assertEqual(pkt[Ether].dst, self.pg2.remote_mac)
97 self.assertEqual(pkt[IP].src, self.pg2.local_ip4)
98 self.assertEqual(pkt[IP].dst, self.pg2.remote_ip4)
100 return pkt[GRE].payload
102 def decap_erspan(self, pkt, session):
104 Decapsulate the original payload frame by removing ERSPAN header
106 self.assertEqual(pkt[Ether].src, self.pg2.local_mac)
107 self.assertEqual(pkt[Ether].dst, self.pg2.remote_mac)
109 self.assertEqual(pkt[IP].src, self.pg2.local_ip4)
110 self.assertEqual(pkt[IP].dst, self.pg2.remote_ip4)
112 self.assertEqual(pkt[ERSPAN].ver, 1)
113 self.assertEqual(pkt[ERSPAN].vlan, 0)
114 self.assertEqual(pkt[ERSPAN].cos, 0)
115 self.assertEqual(pkt[ERSPAN].en, 3)
116 self.assertEqual(pkt[ERSPAN].t, 0)
117 self.assertEqual(pkt[ERSPAN].session_id, session)
118 self.assertEqual(pkt[ERSPAN].reserved, 0)
119 self.assertEqual(pkt[ERSPAN].index, 0)
121 return pkt[ERSPAN].payload
123 def decap_vxlan(self, pkt):
125 Decapsulate the original payload frame by removing VXLAN header
127 self.assertEqual(pkt[Ether].src, self.pg2.local_mac)
128 self.assertEqual(pkt[Ether].dst, self.pg2.remote_mac)
130 self.assertEqual(pkt[IP].src, self.pg2.local_ip4)
131 self.assertEqual(pkt[IP].dst, self.pg2.remote_ip4)
133 return pkt[VXLAN].payload
135 def create_stream(self, src_if, packet_sizes, do_dot1=False, bcast=False):
137 dst_if = self.flows[src_if][0]
138 dst_mac = src_if.remote_mac
140 dst_mac = "ff:ff:ff:ff:ff:ff"
142 for i in range(0, self.pkts_per_burst):
143 payload = "span test"
144 size = packet_sizes[(i / 2) % len(packet_sizes)]
145 p = (Ether(src=src_if.local_mac, dst=dst_mac) /
146 IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4) /
147 UDP(sport=10000 + src_if.sw_if_index * 1000 + i, dport=1234) /
150 p = self.sub_if.add_dot1_layer(p)
151 self.extend_packet(p, size)
155 def verify_capture(self, cap1, cap2):
156 self.assertEqual(len(cap1), len(cap2),
157 "Different number of sent and mirrored packets :"
158 "%u != %u" % (len(cap1), len(cap2)))
160 pkts1 = [(pkt[Ether] / pkt[IP] / pkt[UDP]) for pkt in cap1]
161 pkts2 = [(pkt[Ether] / pkt[IP] / pkt[UDP]) for pkt in cap2]
163 self.assertEqual(pkts1.sort(), pkts2.sort())
165 def test_device_span(self):
166 """ SPAN device rx mirror """
168 # Create bi-directional cross-connects between pg0 and pg1
169 self.xconnect(self.pg0.sw_if_index, self.pg1.sw_if_index)
170 # Create incoming packet streams for packet-generator interfaces
171 pkts = self.create_stream(self.pg0, self.pg_if_packet_sizes)
172 self.pg0.add_stream(pkts)
174 # Enable SPAN on pg0 (mirrored to pg2)
175 self.vapi.sw_interface_span_enable_disable(
176 self.pg0.sw_if_index, self.pg2.sw_if_index)
178 self.logger.info(self.vapi.ppcli("show interface span"))
179 # Enable packet capturing and start packet sending
180 self.pg_enable_capture(self.pg_interfaces)
183 # Verify packets outgoing packet streams on mirrored interface (pg2)
185 pg1_pkts = self.pg1.get_capture(n_pkts)
186 pg2_pkts = self.pg2.get_capture(n_pkts)
188 # Disable SPAN on pg0 (mirrored to pg2)
189 self.vapi.sw_interface_span_enable_disable(
190 self.pg0.sw_if_index, self.pg2.sw_if_index, state=0)
191 self.xconnect(self.pg0.sw_if_index, self.pg1.sw_if_index, is_add=0)
193 self.verify_capture(pg1_pkts, pg2_pkts)
195 def test_span_l2_rx(self):
196 """ SPAN l2 rx mirror """
198 self.sub_if.admin_up()
200 self.bridge(self.pg2.sw_if_index)
201 # Create bi-directional cross-connects between pg0 subif and pg1
202 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
203 # Create incoming packet streams for packet-generator interfaces
204 pkts = self.create_stream(
205 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
206 self.pg0.add_stream(pkts)
208 # Enable SPAN on pg0 (mirrored to pg2)
209 self.vapi.sw_interface_span_enable_disable(
210 self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1)
212 self.logger.info(self.vapi.ppcli("show interface span"))
213 # Enable packet capturing and start packet sending
214 self.pg_enable_capture(self.pg_interfaces)
217 # Verify packets outgoing packet streams on mirrored interface (pg2)
218 pg2_expected = len(pkts)
219 pg1_pkts = self.pg1.get_capture(pg2_expected)
220 pg2_pkts = self.pg2.get_capture(pg2_expected)
221 self.bridge(self.pg2.sw_if_index, is_add=0)
223 # Disable SPAN on pg0 (mirrored to pg2)
224 self.vapi.sw_interface_span_enable_disable(
225 self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
226 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
228 self.verify_capture(pg1_pkts, pg2_pkts)
230 def test_span_l2_rx_dst_vxlan(self):
231 """ SPAN l2 rx mirror into vxlan """
233 self.sub_if.admin_up()
234 self.vapi.sw_interface_set_flags(self.vxlan.sw_if_index,
237 self.bridge(self.vxlan.sw_if_index, is_add=1)
238 # Create bi-directional cross-connects between pg0 subif and pg1
239 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
240 # Create incoming packet streams for packet-generator interfaces
241 pkts = self.create_stream(
242 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
243 self.pg0.add_stream(pkts)
245 # Enable SPAN on pg0 sub if (mirrored to vxlan)
246 self.vapi.sw_interface_span_enable_disable(
247 self.sub_if.sw_if_index, self.vxlan.sw_if_index, is_l2=1)
249 self.logger.info(self.vapi.ppcli("show interface span"))
250 # Enable packet capturing and start packet sending
251 self.pg_enable_capture(self.pg_interfaces)
254 # Verify packets outgoing packet streams on mirrored interface (pg2)
256 pg1_pkts = self.pg1.get_capture(n_pkts)
257 pg2_pkts = [self.decap_vxlan(p) for p in self.pg2.get_capture(n_pkts)]
259 self.bridge(self.vxlan.sw_if_index, is_add=0)
260 # Disable SPAN on pg0 sub if (mirrored to vxlan)
261 self.vapi.sw_interface_span_enable_disable(
262 self.sub_if.sw_if_index, self.vxlan.sw_if_index, state=0, is_l2=1)
263 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
264 self.verify_capture(pg1_pkts, pg2_pkts)
266 def test_span_l2_rx_dst_gre_erspan(self):
267 """ SPAN l2 rx mirror into gre-erspan """
269 self.sub_if.admin_up()
271 gre_if = VppGreInterface(self, self.pg2.local_ip4,
276 gre_if.add_vpp_config()
279 self.bridge(gre_if.sw_if_index)
280 # Create bi-directional cross-connects between pg0 and pg1
281 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
283 # Create incoming packet streams for packet-generator interfaces
284 pkts = self.create_stream(
285 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
286 self.pg0.add_stream(pkts)
288 # Enable SPAN on pg0 sub if (mirrored to gre-erspan)
289 self.vapi.sw_interface_span_enable_disable(
290 self.sub_if.sw_if_index, gre_if.sw_if_index, is_l2=1)
292 # Enable packet capturing and start packet sending
293 self.pg_enable_capture(self.pg_interfaces)
296 # Verify packets outgoing packet streams on mirrored interface (pg2)
298 pg1_pkts = self.pg1.get_capture(n_pkts)
299 pg2_pkts = self.pg2.get_capture(n_pkts)
301 def decap(p): return self.decap_erspan(p, session=543)
302 pg2_decaped = [decap(p) for p in pg2_pkts]
304 self.bridge(gre_if.sw_if_index, is_add=0)
306 # Disable SPAN on pg0 sub if
307 self.vapi.sw_interface_span_enable_disable(
308 self.sub_if.sw_if_index, gre_if.sw_if_index, state=0, is_l2=1)
309 gre_if.remove_vpp_config()
310 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
312 self.verify_capture(pg1_pkts, pg2_decaped)
314 def test_span_l2_rx_dst_gre_subif_vtr(self):
315 """ SPAN l2 rx mirror into gre-subif+vtr """
317 self.sub_if.admin_up()
319 gre_if = VppGreInterface(self, self.pg2.local_ip4,
323 gre_if.add_vpp_config()
326 gre_sub_if = VppDot1QSubint(self, gre_if, 500)
327 gre_sub_if.set_vtr(L2_VTR_OP.L2_POP_1, tag=500)
328 gre_sub_if.admin_up()
330 self.bridge(gre_sub_if.sw_if_index)
331 # Create bi-directional cross-connects between pg0 and pg1
332 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
334 # Create incoming packet streams for packet-generator interfaces
335 pkts = self.create_stream(
336 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
337 self.pg0.add_stream(pkts)
339 # Enable SPAN on pg0 sub if (mirrored to gre sub if)
340 self.vapi.sw_interface_span_enable_disable(
341 self.sub_if.sw_if_index, gre_sub_if.sw_if_index, is_l2=1)
343 # Enable packet capturing and start packet sending
344 self.pg_enable_capture(self.pg_interfaces)
347 # Verify packets outgoing packet streams on mirrored interface (pg2)
349 pg1_pkts = self.pg1.get_capture(n_pkts)
350 pg2_pkts = self.pg2.get_capture(n_pkts)
352 def decap(p): return self.remove_tags(
353 self.decap_gre(p), [Tag(dot1=DOT1Q, vlan=500)])
354 pg2_decaped = [decap(p) for p in pg2_pkts]
356 self.bridge(gre_sub_if.sw_if_index, is_add=0)
358 # Disable SPAN on pg0 sub if
359 self.vapi.sw_interface_span_enable_disable(
360 self.sub_if.sw_if_index, gre_sub_if.sw_if_index, state=0, is_l2=1)
361 gre_if.remove_vpp_config()
362 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
364 self.verify_capture(pg1_pkts, pg2_decaped)
366 def test_span_l2_rx_dst_1q_vtr(self):
367 """ SPAN l2 rx mirror into 1q subif+vtr """
369 self.sub_if.admin_up()
370 self.vlan_sub_if.admin_up()
372 self.bridge(self.vlan_sub_if.sw_if_index)
373 # Create bi-directional cross-connects between pg0 and pg1
374 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
376 # Create incoming packet streams for packet-generator interfaces
377 pkts = self.create_stream(
378 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
379 self.pg0.add_stream(pkts)
381 self.vapi.sw_interface_span_enable_disable(
382 self.sub_if.sw_if_index, self.vlan_sub_if.sw_if_index, is_l2=1)
384 # Enable packet capturing and start packet sending
385 self.pg_enable_capture(self.pg_interfaces)
388 # Verify packets outgoing packet streams on mirrored interface (pg2)
390 pg1_pkts = self.pg1.get_capture(n_pkts)
391 pg2_pkts = self.pg2.get_capture(n_pkts)
392 pg2_untagged = [self.remove_tags(p, [Tag(dot1=DOT1Q, vlan=300)])
395 self.bridge(self.vlan_sub_if.sw_if_index, is_add=0)
396 # Disable SPAN on pg0 sub if (mirrored to vxlan)
397 self.vapi.sw_interface_span_enable_disable(
398 self.sub_if.sw_if_index, self.vlan_sub_if.sw_if_index, state=0,
400 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
402 self.verify_capture(pg1_pkts, pg2_untagged)
404 def test_span_l2_rx_dst_1ad_vtr(self):
405 """ SPAN l2 rx mirror into 1ad subif+vtr """
407 self.sub_if.admin_up()
408 self.qinq_sub_if.admin_up()
410 self.bridge(self.qinq_sub_if.sw_if_index)
411 # Create bi-directional cross-connects between pg0 and pg1
412 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=1)
414 # Create incoming packet streams for packet-generator interfaces
415 pkts = self.create_stream(
416 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
417 self.pg0.add_stream(pkts)
419 self.vapi.sw_interface_span_enable_disable(
420 self.sub_if.sw_if_index, self.qinq_sub_if.sw_if_index, is_l2=1)
422 # Enable packet capturing and start packet sending
423 self.pg_enable_capture(self.pg_interfaces)
426 # Verify packets outgoing packet streams on mirrored interface (pg2)
428 pg1_pkts = self.pg1.get_capture(n_pkts)
429 pg2_pkts = self.pg2.get_capture(n_pkts)
430 pg2_untagged = [self.remove_tags(p, [Tag(dot1=DOT1AD, vlan=400),
431 Tag(dot1=DOT1Q, vlan=500)])
434 self.bridge(self.qinq_sub_if.sw_if_index, is_add=0)
435 # Disable SPAN on pg0 sub if (mirrored to vxlan)
436 self.vapi.sw_interface_span_enable_disable(
437 self.sub_if.sw_if_index, self.qinq_sub_if.sw_if_index, state=0,
439 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
441 self.verify_capture(pg1_pkts, pg2_untagged)
443 def test_l2_tx_span(self):
444 """ SPAN l2 tx mirror """
446 self.sub_if.admin_up()
447 self.bridge(self.pg2.sw_if_index)
448 # Create bi-directional cross-connects between pg0 and pg1
449 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
450 # Create incoming packet streams for packet-generator interfaces
451 pkts = self.create_stream(
452 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
453 self.pg0.add_stream(pkts)
455 # Enable SPAN on pg1 (mirrored to pg2)
456 self.vapi.sw_interface_span_enable_disable(
457 self.pg1.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=2)
459 self.logger.info(self.vapi.ppcli("show interface span"))
460 # Enable packet capturing and start packet sending
461 self.pg_enable_capture(self.pg_interfaces)
464 # Verify packets outgoing packet streams on mirrored interface (pg2)
466 pg1_pkts = self.pg1.get_capture(n_pkts)
467 pg2_pkts = self.pg2.get_capture(n_pkts)
468 self.bridge(self.pg2.sw_if_index, is_add=0)
469 # Disable SPAN on pg0 (mirrored to pg2)
470 self.vapi.sw_interface_span_enable_disable(
471 self.pg1.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
472 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
474 self.verify_capture(pg1_pkts, pg2_pkts)
476 def test_l2_rx_tx_span(self):
477 """ SPAN l2 rx tx mirror """
479 self.sub_if.admin_up()
480 self.bridge(self.pg2.sw_if_index)
481 # Create bi-directional cross-connects between pg0 and pg1
482 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index)
484 # Create incoming packet streams for packet-generator interfaces
485 pg0_pkts = self.create_stream(
486 self.pg0, self.pg_if_packet_sizes, do_dot1=True)
487 self.pg0.add_stream(pg0_pkts)
488 pg1_pkts = self.create_stream(
489 self.pg1, self.pg_if_packet_sizes, do_dot1=False)
490 self.pg1.add_stream(pg1_pkts)
492 # Enable SPAN on pg0 (mirrored to pg2)
493 self.vapi.sw_interface_span_enable_disable(
494 self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=3)
495 self.logger.info(self.vapi.ppcli("show interface span"))
497 # Enable packet capturing and start packet sending
498 self.pg_enable_capture(self.pg_interfaces)
501 # Verify packets outgoing packet streams on mirrored interface (pg2)
502 pg0_expected = len(pg1_pkts)
503 pg1_expected = len(pg0_pkts)
504 pg2_expected = pg0_expected + pg1_expected
506 pg0_pkts = self.pg0.get_capture(pg0_expected)
507 pg1_pkts = self.pg1.get_capture(pg1_expected)
508 pg2_pkts = self.pg2.get_capture(pg2_expected)
510 self.bridge(self.pg2.sw_if_index, is_add=0)
511 # Disable SPAN on pg0 (mirrored to pg2)
512 self.vapi.sw_interface_span_enable_disable(
513 self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
514 self.xconnect(self.sub_if.sw_if_index, self.pg1.sw_if_index, is_add=0)
516 self.verify_capture(pg0_pkts + pg1_pkts, pg2_pkts)
518 def test_l2_bcast_mirror(self):
519 """ SPAN l2 broadcast mirror """
521 self.sub_if.admin_up()
522 self.bridge(self.pg2.sw_if_index)
524 # Create bi-directional cross-connects between pg0 and pg1
525 self.vapi.sw_interface_set_l2_bridge(
526 rx_sw_if_index=self.sub_if.sw_if_index, bd_id=99, enable=1)
527 self.vapi.sw_interface_set_l2_bridge(
528 rx_sw_if_index=self.pg1.sw_if_index, bd_id=99, enable=1)
530 # Create incoming packet streams for packet-generator interfaces
531 pg0_pkts = self.create_stream(
532 self.pg0, self.pg_if_packet_sizes, do_dot1=True, bcast=True)
533 self.pg0.add_stream(pg0_pkts)
534 pg1_pkts = self.create_stream(
535 self.pg1, self.pg_if_packet_sizes, do_dot1=False, bcast=True)
536 self.pg1.add_stream(pg1_pkts)
538 # Enable SPAN on pg0 (mirrored to pg2)
539 self.vapi.sw_interface_span_enable_disable(
540 self.sub_if.sw_if_index, self.pg2.sw_if_index, is_l2=1, state=3)
541 self.logger.info(self.vapi.ppcli("show interface span"))
543 # Enable packet capturing and start packet sending
544 self.pg_enable_capture(self.pg_interfaces)
547 # Verify packets outgoing packet streams on mirrored interface (pg2)
548 pg0_expected = len(pg1_pkts)
549 pg1_expected = len(pg0_pkts)
550 pg2_expected = pg0_expected + pg1_expected
552 pg0_pkts = self.pg0.get_capture(pg0_expected)
553 pg1_pkts = self.pg1.get_capture(pg1_expected)
554 pg2_pkts = self.pg2.get_capture(pg2_expected)
556 self.bridge(self.pg2.sw_if_index, is_add=0)
557 self.vapi.sw_interface_set_l2_bridge(
558 rx_sw_if_index=self.sub_if.sw_if_index, bd_id=99, enable=0)
559 self.vapi.sw_interface_set_l2_bridge(
560 rx_sw_if_index=self.pg1.sw_if_index, bd_id=99, enable=0)
561 # Disable SPAN on pg0 (mirrored to pg2)
562 self.vapi.sw_interface_span_enable_disable(
563 self.sub_if.sw_if_index, self.pg2.sw_if_index, state=0, is_l2=1)
565 self.verify_capture(pg0_pkts + pg1_pkts, pg2_pkts)
568 if __name__ == '__main__':
569 unittest.main(testRunner=VppTestRunner)