blob: a79819ed73c2bb828b26a24548ae41e999a9ccfe [file] [log] [blame]
Renato Botelho do Coutoead1e532019-10-31 13:31:07 -05001#!/usr/bin/env python3
Neale Ranns177bbdc2016-11-15 09:46:51 +00002
3import unittest
Neale Ranns177bbdc2016-11-15 09:46:51 +00004
Paul Vinciguerraa7427ec2019-03-10 10:04:23 -07005import scapy.compat
Neale Ranns177bbdc2016-11-15 09:46:51 +00006from scapy.packet import Raw
Klement Sekera9225dee2016-12-12 08:36:58 +01007from scapy.layers.l2 import Ether, Dot1Q, GRE
Neale Ranns177bbdc2016-11-15 09:46:51 +00008from scapy.layers.inet import IP, UDP
Klement Sekera65cc8c02016-12-18 15:49:54 +01009from scapy.layers.inet6 import IPv6
Neale Ranns177bbdc2016-11-15 09:46:51 +000010from scapy.volatile import RandMAC, RandIP
11
Andrew Yourtchenko8dc0d482021-01-29 13:17:19 +000012from framework import tag_fixme_vpp_workers
Paul Vinciguerraa279d9c2019-02-28 09:00:09 -080013from framework import VppTestCase, VppTestRunner
Paul Vinciguerra95c0ca42019-03-28 13:07:00 -070014from vpp_sub_interface import L2_VTR_OP, VppDot1QSubint
Neale Ranns5a8844b2019-04-16 07:15:35 +000015from vpp_gre_interface import VppGreInterface
Neale Ranns28287212019-12-16 00:53:11 +000016from vpp_teib import VppTeib
Paul Vinciguerraa279d9c2019-02-28 09:00:09 -080017from vpp_ip import DpoProto
Klement Sekerad9b0c6f2022-04-26 19:02:15 +020018from vpp_ip_route import (
19 VppIpRoute,
20 VppRoutePath,
21 VppIpTable,
22 FibPathProto,
23 VppMplsLabel,
24)
Neale Ranns533bf082020-10-08 08:10:34 +000025from vpp_mpls_tunnel_interface import VppMPLSTunnelInterface
Klement Sekera9225dee2016-12-12 08:36:58 +010026from util import ppp, ppc
Neale Ranns5a8844b2019-04-16 07:15:35 +000027from vpp_papi import VppEnum
John Loa43ccae2018-02-13 17:15:23 -050028
29
Andrew Yourtchenko8dc0d482021-01-29 13:17:19 +000030@tag_fixme_vpp_workers
Jakub Grajciarf03beca2019-05-24 08:25:03 +020031class TestGREInputNodes(VppTestCase):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +020032 """GRE Input Nodes Test Case"""
Jakub Grajciarf03beca2019-05-24 08:25:03 +020033
34 def setUp(self):
35 super(TestGREInputNodes, self).setUp()
36
37 # create 3 pg interfaces - set one in a non-default table.
38 self.create_pg_interfaces(range(1))
39
40 for i in self.pg_interfaces:
41 i.admin_up()
42 i.config_ip4()
43
44 def tearDown(self):
45 for i in self.pg_interfaces:
46 i.unconfig_ip4()
47 i.admin_down()
48 super(TestGREInputNodes, self).tearDown()
49
50 def test_gre_input_node(self):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +020051 """GRE gre input nodes not registerd unless configured"""
52 pkt = (
53 Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
54 / IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4)
55 / GRE()
56 )
Jakub Grajciarf03beca2019-05-24 08:25:03 +020057
58 self.pg0.add_stream(pkt)
59 self.pg_start()
60 # no tunnel created, gre-input not registered
Klement Sekerad9b0c6f2022-04-26 19:02:15 +020061 err = self.statistics.get_counter("/err/ip4-local/unknown ip protocol")[0]
Jakub Grajciarf03beca2019-05-24 08:25:03 +020062 self.assertEqual(err, 1)
63 err_count = err
64
65 # create gre tunnel
66 gre_if = VppGreInterface(self, self.pg0.local_ip4, "1.1.1.2")
67 gre_if.add_vpp_config()
68
69 self.pg0.add_stream(pkt)
70 self.pg_start()
71 # tunnel created, gre-input registered
Klement Sekerad9b0c6f2022-04-26 19:02:15 +020072 err = self.statistics.get_counter("/err/ip4-local/unknown ip protocol")[0]
Jakub Grajciarf03beca2019-05-24 08:25:03 +020073 # expect no new errors
74 self.assertEqual(err, err_count)
75
76
Neale Ranns177bbdc2016-11-15 09:46:51 +000077class TestGRE(VppTestCase):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +020078 """GRE Test Case"""
Neale Ranns177bbdc2016-11-15 09:46:51 +000079
80 @classmethod
81 def setUpClass(cls):
82 super(TestGRE, cls).setUpClass()
83
Paul Vinciguerra7f9b7f92019-03-12 19:23:27 -070084 @classmethod
85 def tearDownClass(cls):
86 super(TestGRE, cls).tearDownClass()
87
Neale Ranns177bbdc2016-11-15 09:46:51 +000088 def setUp(self):
89 super(TestGRE, self).setUp()
90
Ciara Loftus7eac9162016-09-30 15:47:03 +010091 # create 3 pg interfaces - set one in a non-default table.
Neale Ranns5f8f6172019-04-18 10:23:56 +000092 self.create_pg_interfaces(range(5))
Neale Ranns15002542017-09-10 04:39:11 -070093
94 self.tbl = VppIpTable(self, 1)
95 self.tbl.add_vpp_config()
Neale Ranns177bbdc2016-11-15 09:46:51 +000096 self.pg1.set_table_ip4(1)
Ciara Loftus7eac9162016-09-30 15:47:03 +010097
Neale Ranns177bbdc2016-11-15 09:46:51 +000098 for i in self.pg_interfaces:
99 i.admin_up()
Ciara Loftus7eac9162016-09-30 15:47:03 +0100100
101 self.pg0.config_ip4()
102 self.pg0.resolve_arp()
103 self.pg1.config_ip4()
104 self.pg1.resolve_arp()
105 self.pg2.config_ip6()
106 self.pg2.resolve_ndp()
Neale Ranns5f8f6172019-04-18 10:23:56 +0000107 self.pg3.config_ip4()
108 self.pg3.resolve_arp()
109 self.pg4.config_ip4()
110 self.pg4.resolve_arp()
Neale Ranns177bbdc2016-11-15 09:46:51 +0000111
112 def tearDown(self):
Neale Ranns4008ac92017-02-13 23:20:04 -0800113 for i in self.pg_interfaces:
114 i.unconfig_ip4()
115 i.unconfig_ip6()
116 i.admin_down()
Neale Ranns15002542017-09-10 04:39:11 -0700117 self.pg1.set_table_ip4(0)
118 super(TestGRE, self).tearDown()
Neale Ranns177bbdc2016-11-15 09:46:51 +0000119
Neale Rannse5b94dd2019-12-31 05:13:14 +0000120 def create_stream_ip4(self, src_if, src_ip, dst_ip, dscp=0, ecn=0):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000121 pkts = []
Neale Rannse5b94dd2019-12-31 05:13:14 +0000122 tos = (dscp << 2) | ecn
Neale Ranns177bbdc2016-11-15 09:46:51 +0000123 for i in range(0, 257):
Klement Sekeradab231a2016-12-21 08:50:14 +0100124 info = self.create_packet_info(src_if, src_if)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000125 payload = self.info_to_payload(info)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200126 p = (
127 Ether(dst=src_if.local_mac, src=src_if.remote_mac)
128 / IP(src=src_ip, dst=dst_ip, tos=tos)
129 / UDP(sport=1234, dport=1234)
130 / Raw(payload)
131 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000132 info.data = p.copy()
133 pkts.append(p)
134 return pkts
135
Neale Rannse5b94dd2019-12-31 05:13:14 +0000136 def create_stream_ip6(self, src_if, src_ip, dst_ip, dscp=0, ecn=0):
Ciara Loftus7eac9162016-09-30 15:47:03 +0100137 pkts = []
Neale Rannse5b94dd2019-12-31 05:13:14 +0000138 tc = (dscp << 2) | ecn
Ciara Loftus7eac9162016-09-30 15:47:03 +0100139 for i in range(0, 257):
140 info = self.create_packet_info(src_if, src_if)
141 payload = self.info_to_payload(info)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200142 p = (
143 Ether(dst=src_if.local_mac, src=src_if.remote_mac)
144 / IPv6(src=src_ip, dst=dst_ip, tc=tc)
145 / UDP(sport=1234, dport=1234)
146 / Raw(payload)
147 )
Ciara Loftus7eac9162016-09-30 15:47:03 +0100148 info.data = p.copy()
149 pkts.append(p)
150 return pkts
151
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200152 def create_tunnel_stream_4o4(self, src_if, tunnel_src, tunnel_dst, src_ip, dst_ip):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000153 pkts = []
154 for i in range(0, 257):
Klement Sekeradab231a2016-12-21 08:50:14 +0100155 info = self.create_packet_info(src_if, src_if)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000156 payload = self.info_to_payload(info)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200157 p = (
158 Ether(dst=src_if.local_mac, src=src_if.remote_mac)
159 / IP(src=tunnel_src, dst=tunnel_dst)
160 / GRE()
161 / IP(src=src_ip, dst=dst_ip)
162 / UDP(sport=1234, dport=1234)
163 / Raw(payload)
164 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000165 info.data = p.copy()
166 pkts.append(p)
167 return pkts
168
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200169 def create_tunnel_stream_6o4(self, src_if, tunnel_src, tunnel_dst, src_ip, dst_ip):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000170 pkts = []
171 for i in range(0, 257):
Klement Sekeradab231a2016-12-21 08:50:14 +0100172 info = self.create_packet_info(src_if, src_if)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000173 payload = self.info_to_payload(info)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200174 p = (
175 Ether(dst=src_if.local_mac, src=src_if.remote_mac)
176 / IP(src=tunnel_src, dst=tunnel_dst)
177 / GRE()
178 / IPv6(src=src_ip, dst=dst_ip)
179 / UDP(sport=1234, dport=1234)
180 / Raw(payload)
181 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000182 info.data = p.copy()
183 pkts.append(p)
184 return pkts
185
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200186 def create_tunnel_stream_6o6(self, src_if, tunnel_src, tunnel_dst, src_ip, dst_ip):
Ciara Loftus7eac9162016-09-30 15:47:03 +0100187 pkts = []
188 for i in range(0, 257):
189 info = self.create_packet_info(src_if, src_if)
190 payload = self.info_to_payload(info)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200191 p = (
192 Ether(dst=src_if.local_mac, src=src_if.remote_mac)
193 / IPv6(src=tunnel_src, dst=tunnel_dst)
194 / GRE()
195 / IPv6(src=src_ip, dst=dst_ip)
196 / UDP(sport=1234, dport=1234)
197 / Raw(payload)
198 )
Ciara Loftus7eac9162016-09-30 15:47:03 +0100199 info.data = p.copy()
200 pkts.append(p)
201 return pkts
202
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200203 def create_tunnel_stream_l2o4(self, src_if, tunnel_src, tunnel_dst):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000204 pkts = []
205 for i in range(0, 257):
Klement Sekeradab231a2016-12-21 08:50:14 +0100206 info = self.create_packet_info(src_if, src_if)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000207 payload = self.info_to_payload(info)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200208 p = (
209 Ether(dst=src_if.local_mac, src=src_if.remote_mac)
210 / IP(src=tunnel_src, dst=tunnel_dst)
211 / GRE()
212 / Ether(dst=RandMAC("*:*:*:*:*:*"), src=RandMAC("*:*:*:*:*:*"))
213 / IP(src=scapy.compat.raw(RandIP()), dst=scapy.compat.raw(RandIP()))
214 / UDP(sport=1234, dport=1234)
215 / Raw(payload)
216 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000217 info.data = p.copy()
218 pkts.append(p)
219 return pkts
220
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200221 def create_tunnel_stream_vlano4(self, src_if, tunnel_src, tunnel_dst, vlan):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000222 pkts = []
223 for i in range(0, 257):
Klement Sekeradab231a2016-12-21 08:50:14 +0100224 info = self.create_packet_info(src_if, src_if)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000225 payload = self.info_to_payload(info)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200226 p = (
227 Ether(dst=src_if.local_mac, src=src_if.remote_mac)
228 / IP(src=tunnel_src, dst=tunnel_dst)
229 / GRE()
230 / Ether(dst=RandMAC("*:*:*:*:*:*"), src=RandMAC("*:*:*:*:*:*"))
231 / Dot1Q(vlan=vlan)
232 / IP(src=scapy.compat.raw(RandIP()), dst=scapy.compat.raw(RandIP()))
233 / UDP(sport=1234, dport=1234)
234 / Raw(payload)
235 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000236 info.data = p.copy()
237 pkts.append(p)
238 return pkts
239
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200240 def verify_tunneled_4o4(
241 self, src_if, capture, sent, tunnel_src, tunnel_dst, dscp=0, ecn=0
242 ):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000243
Neale Ranns177bbdc2016-11-15 09:46:51 +0000244 self.assertEqual(len(capture), len(sent))
Neale Rannse5b94dd2019-12-31 05:13:14 +0000245 tos = (dscp << 2) | ecn
Neale Ranns177bbdc2016-11-15 09:46:51 +0000246
247 for i in range(len(capture)):
248 try:
249 tx = sent[i]
250 rx = capture[i]
251
252 tx_ip = tx[IP]
253 rx_ip = rx[IP]
254
255 self.assertEqual(rx_ip.src, tunnel_src)
256 self.assertEqual(rx_ip.dst, tunnel_dst)
Neale Rannse5b94dd2019-12-31 05:13:14 +0000257 self.assertEqual(rx_ip.tos, tos)
Aloys Augustincf86740a2020-07-16 11:01:01 +0200258 self.assertEqual(rx_ip.len, len(rx_ip))
Neale Ranns177bbdc2016-11-15 09:46:51 +0000259
260 rx_gre = rx[GRE]
261 rx_ip = rx_gre[IP]
262
263 self.assertEqual(rx_ip.src, tx_ip.src)
264 self.assertEqual(rx_ip.dst, tx_ip.dst)
265 # IP processing post pop has decremented the TTL
266 self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl)
267
268 except:
Klement Sekera9225dee2016-12-12 08:36:58 +0100269 self.logger.error(ppp("Rx:", rx))
270 self.logger.error(ppp("Tx:", tx))
Neale Ranns177bbdc2016-11-15 09:46:51 +0000271 raise
272
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200273 def verify_tunneled_6o6(
274 self, src_if, capture, sent, tunnel_src, tunnel_dst, dscp=0, ecn=0
275 ):
Ciara Loftus7eac9162016-09-30 15:47:03 +0100276
277 self.assertEqual(len(capture), len(sent))
Neale Rannse5b94dd2019-12-31 05:13:14 +0000278 tc = (dscp << 2) | ecn
Ciara Loftus7eac9162016-09-30 15:47:03 +0100279
280 for i in range(len(capture)):
281 try:
282 tx = sent[i]
283 rx = capture[i]
284
285 tx_ip = tx[IPv6]
286 rx_ip = rx[IPv6]
287
288 self.assertEqual(rx_ip.src, tunnel_src)
289 self.assertEqual(rx_ip.dst, tunnel_dst)
Neale Rannse5b94dd2019-12-31 05:13:14 +0000290 self.assertEqual(rx_ip.tc, tc)
Ciara Loftus7eac9162016-09-30 15:47:03 +0100291
Paul Vinciguerraa7427ec2019-03-10 10:04:23 -0700292 rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))
Aloys Augustincf86740a2020-07-16 11:01:01 +0200293
294 self.assertEqual(rx_ip.plen, len(rx_gre))
295
Ciara Loftus7eac9162016-09-30 15:47:03 +0100296 rx_ip = rx_gre[IPv6]
297
298 self.assertEqual(rx_ip.src, tx_ip.src)
299 self.assertEqual(rx_ip.dst, tx_ip.dst)
300
301 except:
302 self.logger.error(ppp("Rx:", rx))
303 self.logger.error(ppp("Tx:", tx))
304 raise
305
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200306 def verify_tunneled_4o6(self, src_if, capture, sent, tunnel_src, tunnel_dst):
Neale Ranns2646c802018-09-19 04:55:32 -0700307
308 self.assertEqual(len(capture), len(sent))
309
310 for i in range(len(capture)):
311 try:
312 tx = sent[i]
313 rx = capture[i]
314
315 rx_ip = rx[IPv6]
316
317 self.assertEqual(rx_ip.src, tunnel_src)
318 self.assertEqual(rx_ip.dst, tunnel_dst)
319
Paul Vinciguerraa7427ec2019-03-10 10:04:23 -0700320 rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))
Aloys Augustincf86740a2020-07-16 11:01:01 +0200321
322 self.assertEqual(rx_ip.plen, len(rx_gre))
323
Neale Ranns2646c802018-09-19 04:55:32 -0700324 tx_ip = tx[IP]
325 rx_ip = rx_gre[IP]
326
327 self.assertEqual(rx_ip.src, tx_ip.src)
328 self.assertEqual(rx_ip.dst, tx_ip.dst)
329
330 except:
331 self.logger.error(ppp("Rx:", rx))
332 self.logger.error(ppp("Tx:", tx))
333 raise
334
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200335 def verify_tunneled_6o4(self, src_if, capture, sent, tunnel_src, tunnel_dst):
Neale Ranns2646c802018-09-19 04:55:32 -0700336
337 self.assertEqual(len(capture), len(sent))
338
339 for i in range(len(capture)):
340 try:
341 tx = sent[i]
342 rx = capture[i]
343
344 rx_ip = rx[IP]
345
346 self.assertEqual(rx_ip.src, tunnel_src)
347 self.assertEqual(rx_ip.dst, tunnel_dst)
Aloys Augustincf86740a2020-07-16 11:01:01 +0200348 self.assertEqual(rx_ip.len, len(rx_ip))
Neale Ranns2646c802018-09-19 04:55:32 -0700349
Paul Vinciguerraa7427ec2019-03-10 10:04:23 -0700350 rx_gre = GRE(scapy.compat.raw(rx_ip[IP].payload))
Neale Ranns2646c802018-09-19 04:55:32 -0700351 rx_ip = rx_gre[IPv6]
352 tx_ip = tx[IPv6]
353
354 self.assertEqual(rx_ip.src, tx_ip.src)
355 self.assertEqual(rx_ip.dst, tx_ip.dst)
356
357 except:
358 self.logger.error(ppp("Rx:", rx))
359 self.logger.error(ppp("Tx:", tx))
360 raise
361
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200362 def verify_tunneled_l2o4(self, src_if, capture, sent, tunnel_src, tunnel_dst):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000363 self.assertEqual(len(capture), len(sent))
364
365 for i in range(len(capture)):
366 try:
367 tx = sent[i]
368 rx = capture[i]
369
370 tx_ip = tx[IP]
371 rx_ip = rx[IP]
372
373 self.assertEqual(rx_ip.src, tunnel_src)
374 self.assertEqual(rx_ip.dst, tunnel_dst)
Aloys Augustincf86740a2020-07-16 11:01:01 +0200375 self.assertEqual(rx_ip.len, len(rx_ip))
Neale Ranns177bbdc2016-11-15 09:46:51 +0000376
377 rx_gre = rx[GRE]
378 rx_l2 = rx_gre[Ether]
379 rx_ip = rx_l2[IP]
380 tx_gre = tx[GRE]
381 tx_l2 = tx_gre[Ether]
382 tx_ip = tx_l2[IP]
383
384 self.assertEqual(rx_ip.src, tx_ip.src)
385 self.assertEqual(rx_ip.dst, tx_ip.dst)
386 # bridged, not L3 forwarded, so no TTL decrement
387 self.assertEqual(rx_ip.ttl, tx_ip.ttl)
388
389 except:
Klement Sekera9225dee2016-12-12 08:36:58 +0100390 self.logger.error(ppp("Rx:", rx))
391 self.logger.error(ppp("Tx:", tx))
Neale Ranns177bbdc2016-11-15 09:46:51 +0000392 raise
393
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200394 def verify_tunneled_vlano4(
395 self, src_if, capture, sent, tunnel_src, tunnel_dst, vlan
396 ):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000397 try:
Neale Ranns177bbdc2016-11-15 09:46:51 +0000398 self.assertEqual(len(capture), len(sent))
399 except:
Klement Sekera9225dee2016-12-12 08:36:58 +0100400 ppc("Unexpected packets captured:", capture)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000401 raise
402
403 for i in range(len(capture)):
404 try:
405 tx = sent[i]
406 rx = capture[i]
407
408 tx_ip = tx[IP]
409 rx_ip = rx[IP]
410
411 self.assertEqual(rx_ip.src, tunnel_src)
412 self.assertEqual(rx_ip.dst, tunnel_dst)
413
414 rx_gre = rx[GRE]
415 rx_l2 = rx_gre[Ether]
416 rx_vlan = rx_l2[Dot1Q]
417 rx_ip = rx_l2[IP]
418
419 self.assertEqual(rx_vlan.vlan, vlan)
420
421 tx_gre = tx[GRE]
422 tx_l2 = tx_gre[Ether]
423 tx_ip = tx_l2[IP]
424
425 self.assertEqual(rx_ip.src, tx_ip.src)
426 self.assertEqual(rx_ip.dst, tx_ip.dst)
427 # bridged, not L3 forwarded, so no TTL decrement
428 self.assertEqual(rx_ip.ttl, tx_ip.ttl)
429
430 except:
Klement Sekera9225dee2016-12-12 08:36:58 +0100431 self.logger.error(ppp("Rx:", rx))
432 self.logger.error(ppp("Tx:", tx))
Neale Ranns177bbdc2016-11-15 09:46:51 +0000433 raise
434
435 def verify_decapped_4o4(self, src_if, capture, sent):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000436 self.assertEqual(len(capture), len(sent))
437
438 for i in range(len(capture)):
439 try:
440 tx = sent[i]
441 rx = capture[i]
442
443 tx_ip = tx[IP]
444 rx_ip = rx[IP]
445 tx_gre = tx[GRE]
446 tx_ip = tx_gre[IP]
447
448 self.assertEqual(rx_ip.src, tx_ip.src)
449 self.assertEqual(rx_ip.dst, tx_ip.dst)
450 # IP processing post pop has decremented the TTL
451 self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl)
452
453 except:
Klement Sekera9225dee2016-12-12 08:36:58 +0100454 self.logger.error(ppp("Rx:", rx))
455 self.logger.error(ppp("Tx:", tx))
Neale Ranns177bbdc2016-11-15 09:46:51 +0000456 raise
457
458 def verify_decapped_6o4(self, src_if, capture, sent):
Neale Ranns177bbdc2016-11-15 09:46:51 +0000459 self.assertEqual(len(capture), len(sent))
460
461 for i in range(len(capture)):
462 try:
463 tx = sent[i]
464 rx = capture[i]
465
466 tx_ip = tx[IP]
467 rx_ip = rx[IPv6]
468 tx_gre = tx[GRE]
469 tx_ip = tx_gre[IPv6]
470
471 self.assertEqual(rx_ip.src, tx_ip.src)
472 self.assertEqual(rx_ip.dst, tx_ip.dst)
473 self.assertEqual(rx_ip.hlim + 1, tx_ip.hlim)
474
475 except:
Klement Sekera9225dee2016-12-12 08:36:58 +0100476 self.logger.error(ppp("Rx:", rx))
477 self.logger.error(ppp("Tx:", tx))
Neale Ranns177bbdc2016-11-15 09:46:51 +0000478 raise
479
Neale Ranns4c16d802019-12-17 20:15:03 +0000480 def verify_decapped_6o6(self, src_if, capture, sent):
481 self.assertEqual(len(capture), len(sent))
482
483 for i in range(len(capture)):
484 try:
485 tx = sent[i]
486 rx = capture[i]
487
488 tx_ip = tx[IPv6]
489 rx_ip = rx[IPv6]
490 tx_gre = tx[GRE]
491 tx_ip = tx_gre[IPv6]
492
493 self.assertEqual(rx_ip.src, tx_ip.src)
494 self.assertEqual(rx_ip.dst, tx_ip.dst)
495 self.assertEqual(rx_ip.hlim + 1, tx_ip.hlim)
496
497 except:
498 self.logger.error(ppp("Rx:", rx))
499 self.logger.error(ppp("Tx:", tx))
500 raise
501
Neale Ranns177bbdc2016-11-15 09:46:51 +0000502 def test_gre(self):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200503 """GRE IPv4 tunnel Tests"""
Neale Ranns177bbdc2016-11-15 09:46:51 +0000504
505 #
506 # Create an L3 GRE tunnel.
507 # - set it admin up
508 # - assign an IP Addres
509 # - Add a route via the tunnel
510 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200511 gre_if = VppGreInterface(self, self.pg0.local_ip4, "1.1.1.2")
Neale Ranns177bbdc2016-11-15 09:46:51 +0000512 gre_if.add_vpp_config()
513
514 #
515 # The double create (create the same tunnel twice) should fail,
516 # and we should still be able to use the original
517 #
518 try:
519 gre_if.add_vpp_config()
520 except Exception:
521 pass
522 else:
523 self.fail("Double GRE tunnel add does not fail")
524
525 gre_if.admin_up()
526 gre_if.config_ip4()
527
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200528 route_via_tun = VppIpRoute(
529 self, "4.4.4.4", 32, [VppRoutePath("0.0.0.0", gre_if.sw_if_index)]
530 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000531
532 route_via_tun.add_vpp_config()
533
534 #
535 # Send a packet stream that is routed into the tunnel
Jim Thompsonf324dec2019-04-08 03:22:21 -0500536 # - they are all dropped since the tunnel's destintation IP
Neale Ranns177bbdc2016-11-15 09:46:51 +0000537 # is unresolved - or resolves via the default route - which
538 # which is a drop.
539 #
540 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
Neale Ranns177bbdc2016-11-15 09:46:51 +0000541
Neale Ranns55882252018-11-29 08:48:37 +0000542 self.send_and_assert_no_replies(self.pg0, tx)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000543
544 #
545 # Add a route that resolves the tunnel's destination
546 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200547 route_tun_dst = VppIpRoute(
548 self,
549 "1.1.1.2",
550 32,
551 [VppRoutePath(self.pg0.remote_ip4, self.pg0.sw_if_index)],
552 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000553 route_tun_dst.add_vpp_config()
554
555 #
556 # Send a packet stream that is routed into the tunnel
557 # - packets are GRE encapped
558 #
Neale Ranns177bbdc2016-11-15 09:46:51 +0000559 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
Neale Ranns55882252018-11-29 08:48:37 +0000560 rx = self.send_and_expect(self.pg0, tx, self.pg0)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200561 self.verify_tunneled_4o4(self.pg0, rx, tx, self.pg0.local_ip4, "1.1.1.2")
Neale Ranns177bbdc2016-11-15 09:46:51 +0000562
563 #
564 # Send tunneled packets that match the created tunnel and
565 # are decapped and forwarded
566 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200567 tx = self.create_tunnel_stream_4o4(
568 self.pg0,
569 "1.1.1.2",
570 self.pg0.local_ip4,
571 self.pg0.local_ip4,
572 self.pg0.remote_ip4,
573 )
Neale Ranns55882252018-11-29 08:48:37 +0000574 rx = self.send_and_expect(self.pg0, tx, self.pg0)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000575 self.verify_decapped_4o4(self.pg0, rx, tx)
576
577 #
578 # Send tunneled packets that do not match the tunnel's src
579 #
580 self.vapi.cli("clear trace")
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200581 tx = self.create_tunnel_stream_4o4(
582 self.pg0,
583 "1.1.1.3",
584 self.pg0.local_ip4,
585 self.pg0.local_ip4,
586 self.pg0.remote_ip4,
587 )
Neale Ranns55882252018-11-29 08:48:37 +0000588 self.send_and_assert_no_replies(
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200589 self.pg0, tx, remark="GRE packets forwarded despite no SRC address match"
590 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000591
592 #
593 # Configure IPv6 on the PG interface so we can route IPv6
594 # packets
595 #
596 self.pg0.config_ip6()
597 self.pg0.resolve_ndp()
598
599 #
600 # Send IPv6 tunnel encapslated packets
601 # - dropped since IPv6 is not enabled on the tunnel
602 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200603 tx = self.create_tunnel_stream_6o4(
604 self.pg0,
605 "1.1.1.2",
606 self.pg0.local_ip4,
607 self.pg0.local_ip6,
608 self.pg0.remote_ip6,
609 )
610 self.send_and_assert_no_replies(
611 self.pg0,
612 tx,
613 "IPv6 GRE packets forwarded despite IPv6 not enabled on tunnel",
614 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000615
616 #
617 # Enable IPv6 on the tunnel
618 #
619 gre_if.config_ip6()
620
621 #
622 # Send IPv6 tunnel encapslated packets
623 # - forwarded since IPv6 is enabled on the tunnel
624 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200625 tx = self.create_tunnel_stream_6o4(
626 self.pg0,
627 "1.1.1.2",
628 self.pg0.local_ip4,
629 self.pg0.local_ip6,
630 self.pg0.remote_ip6,
631 )
Neale Ranns55882252018-11-29 08:48:37 +0000632 rx = self.send_and_expect(self.pg0, tx, self.pg0)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000633 self.verify_decapped_6o4(self.pg0, rx, tx)
634
635 #
Neale Ranns2646c802018-09-19 04:55:32 -0700636 # Send v6 packets for v4 encap
637 #
638 route6_via_tun = VppIpRoute(
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200639 self,
640 "2001::1",
641 128,
642 [VppRoutePath("::", gre_if.sw_if_index, proto=DpoProto.DPO_PROTO_IP6)],
643 )
Neale Ranns2646c802018-09-19 04:55:32 -0700644 route6_via_tun.add_vpp_config()
645
646 tx = self.create_stream_ip6(self.pg0, "2001::2", "2001::1")
647 rx = self.send_and_expect(self.pg0, tx, self.pg0)
648
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200649 self.verify_tunneled_6o4(self.pg0, rx, tx, self.pg0.local_ip4, "1.1.1.2")
Neale Ranns2646c802018-09-19 04:55:32 -0700650
651 #
Neale Ranns533bf082020-10-08 08:10:34 +0000652 # add a labelled route through the tunnel
653 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200654 label_via_tun = VppIpRoute(
655 self,
656 "5.4.3.2",
657 32,
658 [VppRoutePath("0.0.0.0", gre_if.sw_if_index, labels=[VppMplsLabel(33)])],
659 )
Neale Ranns533bf082020-10-08 08:10:34 +0000660 label_via_tun.add_vpp_config()
661
662 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "5.4.3.2")
663 rx = self.send_and_expect(self.pg0, tx, self.pg0)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200664 self.verify_tunneled_4o4(self.pg0, rx, tx, self.pg0.local_ip4, "1.1.1.2")
Neale Ranns533bf082020-10-08 08:10:34 +0000665
666 #
667 # an MPLS tunnel over the GRE tunnel add a route through
668 # the mpls tunnel
669 #
670 mpls_tun = VppMPLSTunnelInterface(
671 self,
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200672 [
673 VppRoutePath(
674 "0.0.0.0",
675 gre_if.sw_if_index,
676 labels=[VppMplsLabel(44), VppMplsLabel(46)],
677 )
678 ],
679 )
Neale Ranns533bf082020-10-08 08:10:34 +0000680 mpls_tun.add_vpp_config()
681 mpls_tun.admin_up()
682
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200683 label_via_mpls = VppIpRoute(
684 self,
685 "5.4.3.1",
686 32,
687 [VppRoutePath("0.0.0.0", mpls_tun.sw_if_index, labels=[VppMplsLabel(33)])],
688 )
Neale Ranns533bf082020-10-08 08:10:34 +0000689 label_via_mpls.add_vpp_config()
690
691 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "5.4.3.1")
692 rx = self.send_and_expect(self.pg0, tx, self.pg0)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200693 self.verify_tunneled_4o4(self.pg0, rx, tx, self.pg0.local_ip4, "1.1.1.2")
Neale Ranns533bf082020-10-08 08:10:34 +0000694
695 mpls_tun_l2 = VppMPLSTunnelInterface(
696 self,
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200697 [
698 VppRoutePath(
699 "0.0.0.0",
700 gre_if.sw_if_index,
701 labels=[VppMplsLabel(44), VppMplsLabel(46)],
702 )
703 ],
704 is_l2=1,
705 )
Neale Ranns533bf082020-10-08 08:10:34 +0000706 mpls_tun_l2.add_vpp_config()
707 mpls_tun_l2.admin_up()
708
709 #
Neale Ranns177bbdc2016-11-15 09:46:51 +0000710 # test case cleanup
711 #
712 route_tun_dst.remove_vpp_config()
713 route_via_tun.remove_vpp_config()
Neale Ranns2646c802018-09-19 04:55:32 -0700714 route6_via_tun.remove_vpp_config()
Neale Ranns533bf082020-10-08 08:10:34 +0000715 label_via_mpls.remove_vpp_config()
716 label_via_tun.remove_vpp_config()
717 mpls_tun.remove_vpp_config()
718 mpls_tun_l2.remove_vpp_config()
Neale Ranns177bbdc2016-11-15 09:46:51 +0000719 gre_if.remove_vpp_config()
720
721 self.pg0.unconfig_ip6()
722
Ciara Loftus7eac9162016-09-30 15:47:03 +0100723 def test_gre6(self):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200724 """GRE IPv6 tunnel Tests"""
Ciara Loftus7eac9162016-09-30 15:47:03 +0100725
Neale Ranns8716e6b2017-12-13 02:47:27 -0800726 self.pg1.config_ip6()
727 self.pg1.resolve_ndp()
728
Ciara Loftus7eac9162016-09-30 15:47:03 +0100729 #
730 # Create an L3 GRE tunnel.
731 # - set it admin up
732 # - assign an IP Address
733 # - Add a route via the tunnel
734 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200735 gre_if = VppGreInterface(self, self.pg2.local_ip6, "1002::1")
Ciara Loftus7eac9162016-09-30 15:47:03 +0100736 gre_if.add_vpp_config()
737 gre_if.admin_up()
738 gre_if.config_ip6()
739
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200740 route_via_tun = VppIpRoute(
741 self, "4004::1", 128, [VppRoutePath("0::0", gre_if.sw_if_index)]
742 )
Ciara Loftus7eac9162016-09-30 15:47:03 +0100743
744 route_via_tun.add_vpp_config()
745
746 #
747 # Send a packet stream that is routed into the tunnel
Jim Thompsonf324dec2019-04-08 03:22:21 -0500748 # - they are all dropped since the tunnel's destintation IP
Ciara Loftus7eac9162016-09-30 15:47:03 +0100749 # is unresolved - or resolves via the default route - which
750 # which is a drop.
751 #
752 tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
Neale Ranns55882252018-11-29 08:48:37 +0000753 self.send_and_assert_no_replies(
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200754 self.pg2, tx, "GRE packets forwarded without DIP resolved"
755 )
Ciara Loftus7eac9162016-09-30 15:47:03 +0100756
757 #
758 # Add a route that resolves the tunnel's destination
759 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200760 route_tun_dst = VppIpRoute(
761 self,
762 "1002::1",
763 128,
764 [VppRoutePath(self.pg2.remote_ip6, self.pg2.sw_if_index)],
765 )
Ciara Loftus7eac9162016-09-30 15:47:03 +0100766 route_tun_dst.add_vpp_config()
767
768 #
769 # Send a packet stream that is routed into the tunnel
770 # - packets are GRE encapped
771 #
Ciara Loftus7eac9162016-09-30 15:47:03 +0100772 tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
Neale Ranns55882252018-11-29 08:48:37 +0000773 rx = self.send_and_expect(self.pg2, tx, self.pg2)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200774 self.verify_tunneled_6o6(self.pg2, rx, tx, self.pg2.local_ip6, "1002::1")
Ciara Loftus7eac9162016-09-30 15:47:03 +0100775
776 #
Neale Ranns8716e6b2017-12-13 02:47:27 -0800777 # Test decap. decapped packets go out pg1
778 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200779 tx = self.create_tunnel_stream_6o6(
780 self.pg2, "1002::1", self.pg2.local_ip6, "2001::1", self.pg1.remote_ip6
781 )
Neale Ranns55882252018-11-29 08:48:37 +0000782 rx = self.send_and_expect(self.pg2, tx, self.pg1)
Neale Ranns8716e6b2017-12-13 02:47:27 -0800783
784 #
785 # RX'd packet is UDP over IPv6, test the GRE header is gone.
786 #
787 self.assertFalse(rx[0].haslayer(GRE))
788 self.assertEqual(rx[0][IPv6].dst, self.pg1.remote_ip6)
789
790 #
Neale Ranns2646c802018-09-19 04:55:32 -0700791 # Send v4 over v6
792 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200793 route4_via_tun = VppIpRoute(
794 self, "1.1.1.1", 32, [VppRoutePath("0.0.0.0", gre_if.sw_if_index)]
795 )
Neale Ranns2646c802018-09-19 04:55:32 -0700796 route4_via_tun.add_vpp_config()
797
798 tx = self.create_stream_ip4(self.pg0, "1.1.1.2", "1.1.1.1")
799 rx = self.send_and_expect(self.pg0, tx, self.pg2)
800
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200801 self.verify_tunneled_4o6(self.pg0, rx, tx, self.pg2.local_ip6, "1002::1")
Neale Ranns2646c802018-09-19 04:55:32 -0700802
803 #
Ciara Loftus7eac9162016-09-30 15:47:03 +0100804 # test case cleanup
805 #
806 route_tun_dst.remove_vpp_config()
807 route_via_tun.remove_vpp_config()
Neale Ranns2646c802018-09-19 04:55:32 -0700808 route4_via_tun.remove_vpp_config()
Ciara Loftus7eac9162016-09-30 15:47:03 +0100809 gre_if.remove_vpp_config()
810
811 self.pg2.unconfig_ip6()
Neale Ranns8716e6b2017-12-13 02:47:27 -0800812 self.pg1.unconfig_ip6()
Ciara Loftus7eac9162016-09-30 15:47:03 +0100813
Neale Ranns177bbdc2016-11-15 09:46:51 +0000814 def test_gre_vrf(self):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200815 """GRE tunnel VRF Tests"""
Neale Ranns177bbdc2016-11-15 09:46:51 +0000816
Neale Rannse5b94dd2019-12-31 05:13:14 +0000817 e = VppEnum.vl_api_tunnel_encap_decap_flags_t
818
Neale Ranns177bbdc2016-11-15 09:46:51 +0000819 #
820 # Create an L3 GRE tunnel whose destination is in the non-default
821 # table. The underlay is thus non-default - the overlay is still
822 # the default.
823 # - set it admin up
824 # - assign an IP Addres
825 #
Neale Rannse5b94dd2019-12-31 05:13:14 +0000826 gre_if = VppGreInterface(
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200827 self,
828 self.pg1.local_ip4,
Neale Rannse5b94dd2019-12-31 05:13:14 +0000829 "2.2.2.2",
830 outer_table_id=1,
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200831 flags=(
832 e.TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_DSCP
833 | e.TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_ECN
834 ),
835 )
Neale Rannse5b94dd2019-12-31 05:13:14 +0000836
Neale Ranns177bbdc2016-11-15 09:46:51 +0000837 gre_if.add_vpp_config()
838 gre_if.admin_up()
839 gre_if.config_ip4()
840
841 #
842 # Add a route via the tunnel - in the overlay
843 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200844 route_via_tun = VppIpRoute(
845 self, "9.9.9.9", 32, [VppRoutePath("0.0.0.0", gre_if.sw_if_index)]
846 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000847 route_via_tun.add_vpp_config()
848
849 #
850 # Add a route that resolves the tunnel's destination - in the
851 # underlay table
852 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200853 route_tun_dst = VppIpRoute(
854 self,
855 "2.2.2.2",
856 32,
857 table_id=1,
858 paths=[VppRoutePath(self.pg1.remote_ip4, self.pg1.sw_if_index)],
859 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000860 route_tun_dst.add_vpp_config()
861
862 #
863 # Send a packet stream that is routed into the tunnel
864 # packets are sent in on pg0 which is in the default table
865 # - packets are GRE encapped
866 #
867 self.vapi.cli("clear trace")
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200868 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "9.9.9.9", dscp=5, ecn=3)
Neale Ranns55882252018-11-29 08:48:37 +0000869 rx = self.send_and_expect(self.pg0, tx, self.pg1)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200870 self.verify_tunneled_4o4(
871 self.pg1, rx, tx, self.pg1.local_ip4, "2.2.2.2", dscp=5, ecn=3
872 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000873
874 #
875 # Send tunneled packets that match the created tunnel and
876 # are decapped and forwarded. This tests the decap lookup
877 # does not happen in the encap table
878 #
879 self.vapi.cli("clear trace")
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200880 tx = self.create_tunnel_stream_4o4(
881 self.pg1,
882 "2.2.2.2",
883 self.pg1.local_ip4,
884 self.pg0.local_ip4,
885 self.pg0.remote_ip4,
886 )
Neale Ranns55882252018-11-29 08:48:37 +0000887 rx = self.send_and_expect(self.pg1, tx, self.pg0)
Neale Ranns177bbdc2016-11-15 09:46:51 +0000888 self.verify_decapped_4o4(self.pg0, rx, tx)
889
890 #
Neale Ranns743ee3e2018-11-29 08:24:38 +0000891 # Send tunneled packets that match the created tunnel
Neale Ranns33ce60d2017-12-14 08:51:32 -0800892 # but arrive on an interface that is not in the tunnel's
Neale Ranns743ee3e2018-11-29 08:24:38 +0000893 # encap VRF, these are dropped.
894 # IP enable the interface so they aren't dropped due to
895 # IP not being enabled.
Neale Ranns33ce60d2017-12-14 08:51:32 -0800896 #
Neale Ranns743ee3e2018-11-29 08:24:38 +0000897 self.pg2.config_ip4()
Neale Ranns33ce60d2017-12-14 08:51:32 -0800898 self.vapi.cli("clear trace")
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200899 tx = self.create_tunnel_stream_4o4(
900 self.pg2,
901 "2.2.2.2",
902 self.pg1.local_ip4,
903 self.pg0.local_ip4,
904 self.pg0.remote_ip4,
905 )
Neale Ranns55882252018-11-29 08:48:37 +0000906 rx = self.send_and_assert_no_replies(
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200907 self.pg2, tx, "GRE decap packets in wrong VRF"
908 )
Neale Ranns33ce60d2017-12-14 08:51:32 -0800909
Neale Ranns743ee3e2018-11-29 08:24:38 +0000910 self.pg2.unconfig_ip4()
911
Neale Ranns33ce60d2017-12-14 08:51:32 -0800912 #
Neale Ranns177bbdc2016-11-15 09:46:51 +0000913 # test case cleanup
914 #
915 route_tun_dst.remove_vpp_config()
916 route_via_tun.remove_vpp_config()
917 gre_if.remove_vpp_config()
918
919 def test_gre_l2(self):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200920 """GRE tunnel L2 Tests"""
Neale Ranns177bbdc2016-11-15 09:46:51 +0000921
922 #
923 # Add routes to resolve the tunnel destinations
924 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200925 route_tun1_dst = VppIpRoute(
926 self,
927 "2.2.2.2",
928 32,
929 [VppRoutePath(self.pg0.remote_ip4, self.pg0.sw_if_index)],
930 )
931 route_tun2_dst = VppIpRoute(
932 self,
933 "2.2.2.3",
934 32,
935 [VppRoutePath(self.pg0.remote_ip4, self.pg0.sw_if_index)],
936 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000937
938 route_tun1_dst.add_vpp_config()
939 route_tun2_dst.add_vpp_config()
940
941 #
942 # Create 2 L2 GRE tunnels and x-connect them
943 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200944 gre_if1 = VppGreInterface(
945 self,
946 self.pg0.local_ip4,
947 "2.2.2.2",
948 type=(VppEnum.vl_api_gre_tunnel_type_t.GRE_API_TUNNEL_TYPE_TEB),
949 )
950 gre_if2 = VppGreInterface(
951 self,
952 self.pg0.local_ip4,
953 "2.2.2.3",
954 type=(VppEnum.vl_api_gre_tunnel_type_t.GRE_API_TUNNEL_TYPE_TEB),
955 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000956 gre_if1.add_vpp_config()
957 gre_if2.add_vpp_config()
958
959 gre_if1.admin_up()
960 gre_if2.admin_up()
961
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200962 self.vapi.sw_interface_set_l2_xconnect(
963 gre_if1.sw_if_index, gre_if2.sw_if_index, enable=1
964 )
965 self.vapi.sw_interface_set_l2_xconnect(
966 gre_if2.sw_if_index, gre_if1.sw_if_index, enable=1
967 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000968
969 #
970 # Send in tunnel encapped L2. expect out tunnel encapped L2
971 # in both directions
972 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200973 tx = self.create_tunnel_stream_l2o4(self.pg0, "2.2.2.2", self.pg0.local_ip4)
Neale Ranns55882252018-11-29 08:48:37 +0000974 rx = self.send_and_expect(self.pg0, tx, self.pg0)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200975 self.verify_tunneled_l2o4(self.pg0, rx, tx, self.pg0.local_ip4, "2.2.2.3")
Neale Ranns177bbdc2016-11-15 09:46:51 +0000976
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200977 tx = self.create_tunnel_stream_l2o4(self.pg0, "2.2.2.3", self.pg0.local_ip4)
Neale Ranns55882252018-11-29 08:48:37 +0000978 rx = self.send_and_expect(self.pg0, tx, self.pg0)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200979 self.verify_tunneled_l2o4(self.pg0, rx, tx, self.pg0.local_ip4, "2.2.2.2")
Neale Ranns177bbdc2016-11-15 09:46:51 +0000980
Klement Sekerad9b0c6f2022-04-26 19:02:15 +0200981 self.vapi.sw_interface_set_l2_xconnect(
982 gre_if1.sw_if_index, gre_if2.sw_if_index, enable=0
983 )
984 self.vapi.sw_interface_set_l2_xconnect(
985 gre_if2.sw_if_index, gre_if1.sw_if_index, enable=0
986 )
Neale Ranns177bbdc2016-11-15 09:46:51 +0000987
988 #
989 # Create a VLAN sub-interfaces on the GRE TEB interfaces
990 # then x-connect them
991 #
992 gre_if_11 = VppDot1QSubint(self, gre_if1, 11)
993 gre_if_12 = VppDot1QSubint(self, gre_if2, 12)
994
995 # gre_if_11.add_vpp_config()
996 # gre_if_12.add_vpp_config()
997
998 gre_if_11.admin_up()
999 gre_if_12.admin_up()
1000
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001001 self.vapi.sw_interface_set_l2_xconnect(
1002 gre_if_11.sw_if_index, gre_if_12.sw_if_index, enable=1
1003 )
1004 self.vapi.sw_interface_set_l2_xconnect(
1005 gre_if_12.sw_if_index, gre_if_11.sw_if_index, enable=1
1006 )
Neale Ranns177bbdc2016-11-15 09:46:51 +00001007
1008 #
1009 # Configure both to pop thier respective VLAN tags,
1010 # so that during the x-coonect they will subsequently push
1011 #
Ole Troana5b2eec2019-03-11 19:23:25 +01001012 self.vapi.l2_interface_vlan_tag_rewrite(
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001013 sw_if_index=gre_if_12.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1, push_dot1q=12
1014 )
Ole Troana5b2eec2019-03-11 19:23:25 +01001015 self.vapi.l2_interface_vlan_tag_rewrite(
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001016 sw_if_index=gre_if_11.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1, push_dot1q=11
1017 )
Neale Ranns177bbdc2016-11-15 09:46:51 +00001018
1019 #
1020 # Send traffic in both directiond - expect the VLAN tags to
1021 # be swapped.
1022 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001023 tx = self.create_tunnel_stream_vlano4(
1024 self.pg0, "2.2.2.2", self.pg0.local_ip4, 11
1025 )
Neale Ranns55882252018-11-29 08:48:37 +00001026 rx = self.send_and_expect(self.pg0, tx, self.pg0)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001027 self.verify_tunneled_vlano4(self.pg0, rx, tx, self.pg0.local_ip4, "2.2.2.3", 12)
Neale Ranns177bbdc2016-11-15 09:46:51 +00001028
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001029 tx = self.create_tunnel_stream_vlano4(
1030 self.pg0, "2.2.2.3", self.pg0.local_ip4, 12
1031 )
Neale Ranns55882252018-11-29 08:48:37 +00001032 rx = self.send_and_expect(self.pg0, tx, self.pg0)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001033 self.verify_tunneled_vlano4(self.pg0, rx, tx, self.pg0.local_ip4, "2.2.2.2", 11)
Neale Ranns177bbdc2016-11-15 09:46:51 +00001034
1035 #
1036 # Cleanup Test resources
1037 #
1038 gre_if_11.remove_vpp_config()
1039 gre_if_12.remove_vpp_config()
1040 gre_if1.remove_vpp_config()
1041 gre_if2.remove_vpp_config()
1042 route_tun1_dst.add_vpp_config()
1043 route_tun2_dst.add_vpp_config()
1044
Neale Ranns521a8d72018-12-06 13:46:49 +00001045 def test_gre_loop(self):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001046 """GRE tunnel loop Tests"""
Neale Ranns521a8d72018-12-06 13:46:49 +00001047
1048 #
1049 # Create an L3 GRE tunnel.
1050 # - set it admin up
1051 # - assign an IP Addres
1052 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001053 gre_if = VppGreInterface(self, self.pg0.local_ip4, "1.1.1.2")
Neale Ranns521a8d72018-12-06 13:46:49 +00001054 gre_if.add_vpp_config()
1055 gre_if.admin_up()
1056 gre_if.config_ip4()
1057
1058 #
1059 # add a route to the tunnel's destination that points
1060 # through the tunnel, hence forming a loop in the forwarding
1061 # graph
1062 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001063 route_dst = VppIpRoute(
1064 self, "1.1.1.2", 32, [VppRoutePath("0.0.0.0", gre_if.sw_if_index)]
1065 )
Neale Ranns521a8d72018-12-06 13:46:49 +00001066 route_dst.add_vpp_config()
1067
1068 #
1069 # packets to the tunnels destination should be dropped
1070 #
1071 tx = self.create_stream_ip4(self.pg0, "1.1.1.1", "1.1.1.2")
1072 self.send_and_assert_no_replies(self.pg2, tx)
1073
1074 self.logger.info(self.vapi.ppcli("sh adj 7"))
1075
1076 #
1077 # break the loop
1078 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001079 route_dst.modify([VppRoutePath(self.pg1.remote_ip4, self.pg1.sw_if_index)])
Neale Ranns521a8d72018-12-06 13:46:49 +00001080 route_dst.add_vpp_config()
1081
1082 rx = self.send_and_expect(self.pg0, tx, self.pg1)
1083
1084 #
1085 # a good route throught the tunnel to check it restacked
1086 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001087 route_via_tun_2 = VppIpRoute(
1088 self, "2.2.2.2", 32, [VppRoutePath("0.0.0.0", gre_if.sw_if_index)]
1089 )
Neale Ranns521a8d72018-12-06 13:46:49 +00001090 route_via_tun_2.add_vpp_config()
1091
1092 tx = self.create_stream_ip4(self.pg0, "2.2.2.3", "2.2.2.2")
1093 rx = self.send_and_expect(self.pg0, tx, self.pg1)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001094 self.verify_tunneled_4o4(self.pg1, rx, tx, self.pg0.local_ip4, "1.1.1.2")
Neale Ranns521a8d72018-12-06 13:46:49 +00001095
1096 #
1097 # cleanup
1098 #
1099 route_via_tun_2.remove_vpp_config()
1100 gre_if.remove_vpp_config()
1101
Neale Ranns5f8f6172019-04-18 10:23:56 +00001102 def test_mgre(self):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001103 """mGRE IPv4 tunnel Tests"""
Neale Ranns5f8f6172019-04-18 10:23:56 +00001104
1105 for itf in self.pg_interfaces[3:]:
1106 #
1107 # one underlay nh for each overlay/tunnel peer
1108 #
1109 itf.generate_remote_hosts(4)
1110 itf.configure_ipv4_neighbors()
1111
1112 #
1113 # Create an L3 GRE tunnel.
1114 # - set it admin up
1115 # - assign an IP Addres
1116 # - Add a route via the tunnel
1117 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001118 gre_if = VppGreInterface(
1119 self,
1120 itf.local_ip4,
1121 "0.0.0.0",
1122 mode=(VppEnum.vl_api_tunnel_mode_t.TUNNEL_API_MODE_MP),
1123 )
Neale Ranns5f8f6172019-04-18 10:23:56 +00001124 gre_if.add_vpp_config()
1125 gre_if.admin_up()
1126 gre_if.config_ip4()
1127 gre_if.generate_remote_hosts(4)
1128
Neale Ranns3fd99042019-12-16 00:53:11 +00001129 self.logger.info(self.vapi.cli("sh adj"))
1130 self.logger.info(self.vapi.cli("sh ip fib"))
1131
Neale Ranns5f8f6172019-04-18 10:23:56 +00001132 #
Neale Ranns4c16d802019-12-17 20:15:03 +00001133 # ensure we don't match to the tunnel if the source address
1134 # is all zeros
1135 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001136 tx = self.create_tunnel_stream_4o4(
1137 self.pg0,
1138 "0.0.0.0",
1139 itf.local_ip4,
1140 self.pg0.local_ip4,
1141 self.pg0.remote_ip4,
1142 )
Neale Ranns4c16d802019-12-17 20:15:03 +00001143 self.send_and_assert_no_replies(self.pg0, tx)
1144
1145 #
Neale Ranns5f8f6172019-04-18 10:23:56 +00001146 # for-each peer
1147 #
1148 for ii in range(1, 4):
1149 route_addr = "4.4.4.%d" % ii
Neale Rannsbd8e43d2021-03-15 14:42:30 +00001150 tx_e = self.create_stream_ip4(self.pg0, "5.5.5.5", route_addr)
Neale Ranns5f8f6172019-04-18 10:23:56 +00001151
1152 #
1153 # route traffic via the peer
1154 #
1155 route_via_tun = VppIpRoute(
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001156 self,
1157 route_addr,
1158 32,
1159 [VppRoutePath(gre_if._remote_hosts[ii].ip4, gre_if.sw_if_index)],
1160 )
Neale Ranns5f8f6172019-04-18 10:23:56 +00001161 route_via_tun.add_vpp_config()
1162
Neale Rannsbd8e43d2021-03-15 14:42:30 +00001163 # all packets dropped at this point
Neale Rannsbd8e43d2021-03-15 14:42:30 +00001164 rx = self.send_and_assert_no_replies(self.pg0, tx_e)
1165
1166 gre_if.admin_down()
1167 gre_if.admin_up()
Neale Rannsbd8e43d2021-03-15 14:42:30 +00001168 rx = self.send_and_assert_no_replies(self.pg0, tx_e)
1169
Neale Ranns5f8f6172019-04-18 10:23:56 +00001170 #
Neale Ranns28287212019-12-16 00:53:11 +00001171 # Add a TEIB entry resolves the peer
Neale Ranns5f8f6172019-04-18 10:23:56 +00001172 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001173 teib = VppTeib(
1174 self,
1175 gre_if,
1176 gre_if._remote_hosts[ii].ip4,
1177 itf._remote_hosts[ii].ip4,
1178 )
Neale Ranns03ce4622020-02-03 10:55:09 +00001179 teib.add_vpp_config()
Neale Ranns5f8f6172019-04-18 10:23:56 +00001180
1181 #
1182 # Send a packet stream that is routed into the tunnel
1183 # - packets are GRE encapped
1184 #
Neale Rannsf2b6b9e2021-04-27 13:54:46 +00001185 rx = self.send_and_expect(self.pg0, tx_e, itf)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001186 self.verify_tunneled_4o4(
1187 self.pg0, rx, tx_e, itf.local_ip4, itf._remote_hosts[ii].ip4
1188 )
Neale Ranns5f8f6172019-04-18 10:23:56 +00001189
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001190 tx_i = self.create_tunnel_stream_4o4(
1191 self.pg0,
1192 itf._remote_hosts[ii].ip4,
1193 itf.local_ip4,
1194 self.pg0.local_ip4,
1195 self.pg0.remote_ip4,
1196 )
Neale Ranns4c16d802019-12-17 20:15:03 +00001197 rx = self.send_and_expect(self.pg0, tx_i, self.pg0)
1198 self.verify_decapped_4o4(self.pg0, rx, tx_i)
1199
Neale Ranns5f8f6172019-04-18 10:23:56 +00001200 #
Neale Ranns28287212019-12-16 00:53:11 +00001201 # delete and re-add the TEIB
Neale Ranns5f8f6172019-04-18 10:23:56 +00001202 #
Neale Ranns03ce4622020-02-03 10:55:09 +00001203 teib.remove_vpp_config()
Neale Ranns4c16d802019-12-17 20:15:03 +00001204 self.send_and_assert_no_replies(self.pg0, tx_e)
1205 self.send_and_assert_no_replies(self.pg0, tx_i)
Neale Ranns5f8f6172019-04-18 10:23:56 +00001206
Neale Ranns03ce4622020-02-03 10:55:09 +00001207 teib.add_vpp_config()
Neale Ranns4c16d802019-12-17 20:15:03 +00001208 rx = self.send_and_expect(self.pg0, tx_e, itf)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001209 self.verify_tunneled_4o4(
1210 self.pg0, rx, tx_e, itf.local_ip4, itf._remote_hosts[ii].ip4
1211 )
Neale Ranns4c16d802019-12-17 20:15:03 +00001212 rx = self.send_and_expect(self.pg0, tx_i, self.pg0)
1213 self.verify_decapped_4o4(self.pg0, rx, tx_i)
Neale Ranns5f8f6172019-04-18 10:23:56 +00001214
Neale Rannsbd8e43d2021-03-15 14:42:30 +00001215 #
1216 # bounce the interface state and try packets again
1217 #
1218 gre_if.admin_down()
1219 gre_if.admin_up()
1220 rx = self.send_and_expect(self.pg0, tx_e, itf)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001221 self.verify_tunneled_4o4(
1222 self.pg0, rx, tx_e, itf.local_ip4, itf._remote_hosts[ii].ip4
1223 )
Neale Rannsbd8e43d2021-03-15 14:42:30 +00001224 rx = self.send_and_expect(self.pg0, tx_i, self.pg0)
1225 self.verify_decapped_4o4(self.pg0, rx, tx_i)
1226
Neale Ranns3fd99042019-12-16 00:53:11 +00001227 gre_if.admin_down()
1228 gre_if.unconfig_ip4()
1229
Neale Rannse11dce22019-12-17 00:14:26 +00001230 def test_mgre6(self):
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001231 """mGRE IPv6 tunnel Tests"""
Neale Rannse11dce22019-12-17 00:14:26 +00001232
Neale Ranns4c16d802019-12-17 20:15:03 +00001233 self.pg0.config_ip6()
1234 self.pg0.resolve_ndp()
Neale Rannse11dce22019-12-17 00:14:26 +00001235
Neale Rannse5b94dd2019-12-31 05:13:14 +00001236 e = VppEnum.vl_api_tunnel_encap_decap_flags_t
1237
Neale Rannse11dce22019-12-17 00:14:26 +00001238 for itf in self.pg_interfaces[3:]:
1239 #
1240 # one underlay nh for each overlay/tunnel peer
1241 #
1242 itf.config_ip6()
1243 itf.generate_remote_hosts(4)
1244 itf.configure_ipv6_neighbors()
1245
1246 #
1247 # Create an L3 GRE tunnel.
1248 # - set it admin up
1249 # - assign an IP Addres
1250 # - Add a route via the tunnel
1251 #
Neale Rannse5b94dd2019-12-31 05:13:14 +00001252 gre_if = VppGreInterface(
1253 self,
1254 itf.local_ip6,
1255 "::",
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001256 mode=(VppEnum.vl_api_tunnel_mode_t.TUNNEL_API_MODE_MP),
1257 flags=e.TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_DSCP,
1258 )
Neale Rannse5b94dd2019-12-31 05:13:14 +00001259
Neale Rannse11dce22019-12-17 00:14:26 +00001260 gre_if.add_vpp_config()
1261 gre_if.admin_up()
1262 gre_if.config_ip6()
1263 gre_if.generate_remote_hosts(4)
1264
1265 #
1266 # for-each peer
1267 #
1268 for ii in range(1, 4):
1269 route_addr = "4::%d" % ii
1270
1271 #
Neale Ranns28287212019-12-16 00:53:11 +00001272 # Add a TEIB entry resolves the peer
Neale Ranns14053c92019-12-29 23:55:18 +00001273 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001274 teib = VppTeib(
1275 self,
1276 gre_if,
1277 gre_if._remote_hosts[ii].ip6,
1278 itf._remote_hosts[ii].ip6,
1279 )
Neale Ranns03ce4622020-02-03 10:55:09 +00001280 teib.add_vpp_config()
Neale Ranns14053c92019-12-29 23:55:18 +00001281
1282 #
Neale Rannse11dce22019-12-17 00:14:26 +00001283 # route traffic via the peer
1284 #
1285 route_via_tun = VppIpRoute(
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001286 self,
1287 route_addr,
1288 128,
1289 [VppRoutePath(gre_if._remote_hosts[ii].ip6, gre_if.sw_if_index)],
1290 )
Neale Rannse11dce22019-12-17 00:14:26 +00001291 route_via_tun.add_vpp_config()
1292
1293 #
Neale Rannse11dce22019-12-17 00:14:26 +00001294 # Send a packet stream that is routed into the tunnel
1295 # - packets are GRE encapped
1296 #
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001297 tx_e = self.create_stream_ip6(
1298 self.pg0, "5::5", route_addr, dscp=2, ecn=1
1299 )
Neale Ranns4c16d802019-12-17 20:15:03 +00001300 rx = self.send_and_expect(self.pg0, tx_e, itf)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001301 self.verify_tunneled_6o6(
1302 self.pg0, rx, tx_e, itf.local_ip6, itf._remote_hosts[ii].ip6, dscp=2
1303 )
1304 tx_i = self.create_tunnel_stream_6o6(
1305 self.pg0,
1306 itf._remote_hosts[ii].ip6,
1307 itf.local_ip6,
1308 self.pg0.local_ip6,
1309 self.pg0.remote_ip6,
1310 )
Neale Ranns4c16d802019-12-17 20:15:03 +00001311 rx = self.send_and_expect(self.pg0, tx_i, self.pg0)
1312 self.verify_decapped_6o6(self.pg0, rx, tx_i)
Neale Rannse11dce22019-12-17 00:14:26 +00001313
1314 #
Neale Ranns28287212019-12-16 00:53:11 +00001315 # delete and re-add the TEIB
Neale Rannse11dce22019-12-17 00:14:26 +00001316 #
Neale Ranns03ce4622020-02-03 10:55:09 +00001317 teib.remove_vpp_config()
Neale Ranns4c16d802019-12-17 20:15:03 +00001318 self.send_and_assert_no_replies(self.pg0, tx_e)
Neale Rannse11dce22019-12-17 00:14:26 +00001319
Neale Ranns03ce4622020-02-03 10:55:09 +00001320 teib.add_vpp_config()
Neale Ranns4c16d802019-12-17 20:15:03 +00001321 rx = self.send_and_expect(self.pg0, tx_e, itf)
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001322 self.verify_tunneled_6o6(
1323 self.pg0, rx, tx_e, itf.local_ip6, itf._remote_hosts[ii].ip6, dscp=2
1324 )
Neale Ranns4c16d802019-12-17 20:15:03 +00001325 rx = self.send_and_expect(self.pg0, tx_i, self.pg0)
1326 self.verify_decapped_6o6(self.pg0, rx, tx_i)
1327
Neale Rannse11dce22019-12-17 00:14:26 +00001328 gre_if.admin_down()
1329 gre_if.unconfig_ip4()
1330 itf.unconfig_ip6()
Neale Ranns4c16d802019-12-17 20:15:03 +00001331 self.pg0.unconfig_ip6()
Neale Rannse11dce22019-12-17 00:14:26 +00001332
Neale Ranns177bbdc2016-11-15 09:46:51 +00001333
Klement Sekerad9b0c6f2022-04-26 19:02:15 +02001334if __name__ == "__main__":
Neale Ranns177bbdc2016-11-15 09:46:51 +00001335 unittest.main(testRunner=VppTestRunner)