lb: remove api boilerplate
[vpp.git] / test / test_gre.py
1 #!/usr/bin/env python
2
3 import unittest
4
5 import scapy.compat
6 from scapy.packet import Raw
7 from scapy.layers.l2 import Ether, Dot1Q, GRE
8 from scapy.layers.inet import IP, UDP
9 from scapy.layers.inet6 import IPv6
10 from scapy.volatile import RandMAC, RandIP
11
12 from framework import VppTestCase, VppTestRunner
13 from vpp_sub_interface import L2_VTR_OP, VppDot1QSubint
14 from vpp_gre_interface import VppGreInterface
15 from vpp_ip import DpoProto
16 from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable, FibPathProto
17 from util import ppp, ppc
18 from vpp_papi import VppEnum
19
20
21 class TestGREInputNodes(VppTestCase):
22     """ GRE Input Nodes Test Case """
23
24     def setUp(self):
25         super(TestGREInputNodes, self).setUp()
26
27         # create 3 pg interfaces - set one in a non-default table.
28         self.create_pg_interfaces(range(1))
29
30         for i in self.pg_interfaces:
31             i.admin_up()
32             i.config_ip4()
33
34     def tearDown(self):
35         for i in self.pg_interfaces:
36             i.unconfig_ip4()
37             i.admin_down()
38         super(TestGREInputNodes, self).tearDown()
39
40     def test_gre_input_node(self):
41         """ GRE gre input nodes not registerd unless configured """
42         pkt = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
43                IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
44                GRE())
45
46         self.pg0.add_stream(pkt)
47         self.pg_start()
48         # no tunnel created, gre-input not registered
49         err = self.statistics.get_counter(
50             '/err/ip4-input/unknown ip protocol')[0]
51         self.assertEqual(err, 1)
52         err_count = err
53
54         # create gre tunnel
55         gre_if = VppGreInterface(self, self.pg0.local_ip4, "1.1.1.2")
56         gre_if.add_vpp_config()
57
58         self.pg0.add_stream(pkt)
59         self.pg_start()
60         # tunnel created, gre-input registered
61         err = self.statistics.get_counter(
62             '/err/ip4-input/unknown ip protocol')[0]
63         # expect no new errors
64         self.assertEqual(err, err_count)
65
66
67 class TestGRE(VppTestCase):
68     """ GRE Test Case """
69
70     @classmethod
71     def setUpClass(cls):
72         super(TestGRE, cls).setUpClass()
73
74     @classmethod
75     def tearDownClass(cls):
76         super(TestGRE, cls).tearDownClass()
77
78     def setUp(self):
79         super(TestGRE, self).setUp()
80
81         # create 3 pg interfaces - set one in a non-default table.
82         self.create_pg_interfaces(range(3))
83
84         self.tbl = VppIpTable(self, 1)
85         self.tbl.add_vpp_config()
86         self.pg1.set_table_ip4(1)
87
88         for i in self.pg_interfaces:
89             i.admin_up()
90
91         self.pg0.config_ip4()
92         self.pg0.resolve_arp()
93         self.pg1.config_ip4()
94         self.pg1.resolve_arp()
95         self.pg2.config_ip6()
96         self.pg2.resolve_ndp()
97
98     def tearDown(self):
99         for i in self.pg_interfaces:
100             i.unconfig_ip4()
101             i.unconfig_ip6()
102             i.admin_down()
103         self.pg1.set_table_ip4(0)
104         super(TestGRE, self).tearDown()
105
106     def create_stream_ip4(self, src_if, src_ip, dst_ip):
107         pkts = []
108         for i in range(0, 257):
109             info = self.create_packet_info(src_if, src_if)
110             payload = self.info_to_payload(info)
111             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
112                  IP(src=src_ip, dst=dst_ip) /
113                  UDP(sport=1234, dport=1234) /
114                  Raw(payload))
115             info.data = p.copy()
116             pkts.append(p)
117         return pkts
118
119     def create_stream_ip6(self, src_if, src_ip, dst_ip):
120         pkts = []
121         for i in range(0, 257):
122             info = self.create_packet_info(src_if, src_if)
123             payload = self.info_to_payload(info)
124             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
125                  IPv6(src=src_ip, dst=dst_ip) /
126                  UDP(sport=1234, dport=1234) /
127                  Raw(payload))
128             info.data = p.copy()
129             pkts.append(p)
130         return pkts
131
132     def create_tunnel_stream_4o4(self, src_if,
133                                  tunnel_src, tunnel_dst,
134                                  src_ip, dst_ip):
135         pkts = []
136         for i in range(0, 257):
137             info = self.create_packet_info(src_if, src_if)
138             payload = self.info_to_payload(info)
139             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
140                  IP(src=tunnel_src, dst=tunnel_dst) /
141                  GRE() /
142                  IP(src=src_ip, dst=dst_ip) /
143                  UDP(sport=1234, dport=1234) /
144                  Raw(payload))
145             info.data = p.copy()
146             pkts.append(p)
147         return pkts
148
149     def create_tunnel_stream_6o4(self, src_if,
150                                  tunnel_src, tunnel_dst,
151                                  src_ip, dst_ip):
152         pkts = []
153         for i in range(0, 257):
154             info = self.create_packet_info(src_if, src_if)
155             payload = self.info_to_payload(info)
156             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
157                  IP(src=tunnel_src, dst=tunnel_dst) /
158                  GRE() /
159                  IPv6(src=src_ip, dst=dst_ip) /
160                  UDP(sport=1234, dport=1234) /
161                  Raw(payload))
162             info.data = p.copy()
163             pkts.append(p)
164         return pkts
165
166     def create_tunnel_stream_6o6(self, src_if,
167                                  tunnel_src, tunnel_dst,
168                                  src_ip, dst_ip):
169         pkts = []
170         for i in range(0, 257):
171             info = self.create_packet_info(src_if, src_if)
172             payload = self.info_to_payload(info)
173             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
174                  IPv6(src=tunnel_src, dst=tunnel_dst) /
175                  GRE() /
176                  IPv6(src=src_ip, dst=dst_ip) /
177                  UDP(sport=1234, dport=1234) /
178                  Raw(payload))
179             info.data = p.copy()
180             pkts.append(p)
181         return pkts
182
183     def create_tunnel_stream_l2o4(self, src_if,
184                                   tunnel_src, tunnel_dst):
185         pkts = []
186         for i in range(0, 257):
187             info = self.create_packet_info(src_if, src_if)
188             payload = self.info_to_payload(info)
189             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
190                  IP(src=tunnel_src, dst=tunnel_dst) /
191                  GRE() /
192                  Ether(dst=RandMAC('*:*:*:*:*:*'),
193                        src=RandMAC('*:*:*:*:*:*')) /
194                  IP(src=scapy.compat.raw(RandIP()),
195                     dst=scapy.compat.raw(RandIP())) /
196                  UDP(sport=1234, dport=1234) /
197                  Raw(payload))
198             info.data = p.copy()
199             pkts.append(p)
200         return pkts
201
202     def create_tunnel_stream_vlano4(self, src_if,
203                                     tunnel_src, tunnel_dst, vlan):
204         pkts = []
205         for i in range(0, 257):
206             info = self.create_packet_info(src_if, src_if)
207             payload = self.info_to_payload(info)
208             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
209                  IP(src=tunnel_src, dst=tunnel_dst) /
210                  GRE() /
211                  Ether(dst=RandMAC('*:*:*:*:*:*'),
212                        src=RandMAC('*:*:*:*:*:*')) /
213                  Dot1Q(vlan=vlan) /
214                  IP(src=scapy.compat.raw(RandIP()),
215                     dst=scapy.compat.raw(RandIP())) /
216                  UDP(sport=1234, dport=1234) /
217                  Raw(payload))
218             info.data = p.copy()
219             pkts.append(p)
220         return pkts
221
222     def verify_tunneled_4o4(self, src_if, capture, sent,
223                             tunnel_src, tunnel_dst):
224
225         self.assertEqual(len(capture), len(sent))
226
227         for i in range(len(capture)):
228             try:
229                 tx = sent[i]
230                 rx = capture[i]
231
232                 tx_ip = tx[IP]
233                 rx_ip = rx[IP]
234
235                 self.assertEqual(rx_ip.src, tunnel_src)
236                 self.assertEqual(rx_ip.dst, tunnel_dst)
237
238                 rx_gre = rx[GRE]
239                 rx_ip = rx_gre[IP]
240
241                 self.assertEqual(rx_ip.src, tx_ip.src)
242                 self.assertEqual(rx_ip.dst, tx_ip.dst)
243                 # IP processing post pop has decremented the TTL
244                 self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl)
245
246             except:
247                 self.logger.error(ppp("Rx:", rx))
248                 self.logger.error(ppp("Tx:", tx))
249                 raise
250
251     def verify_tunneled_6o6(self, src_if, capture, sent,
252                             tunnel_src, tunnel_dst):
253
254         self.assertEqual(len(capture), len(sent))
255
256         for i in range(len(capture)):
257             try:
258                 tx = sent[i]
259                 rx = capture[i]
260
261                 tx_ip = tx[IPv6]
262                 rx_ip = rx[IPv6]
263
264                 self.assertEqual(rx_ip.src, tunnel_src)
265                 self.assertEqual(rx_ip.dst, tunnel_dst)
266
267                 rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))
268                 rx_ip = rx_gre[IPv6]
269
270                 self.assertEqual(rx_ip.src, tx_ip.src)
271                 self.assertEqual(rx_ip.dst, tx_ip.dst)
272
273             except:
274                 self.logger.error(ppp("Rx:", rx))
275                 self.logger.error(ppp("Tx:", tx))
276                 raise
277
278     def verify_tunneled_4o6(self, src_if, capture, sent,
279                             tunnel_src, tunnel_dst):
280
281         self.assertEqual(len(capture), len(sent))
282
283         for i in range(len(capture)):
284             try:
285                 tx = sent[i]
286                 rx = capture[i]
287
288                 rx_ip = rx[IPv6]
289
290                 self.assertEqual(rx_ip.src, tunnel_src)
291                 self.assertEqual(rx_ip.dst, tunnel_dst)
292
293                 rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))
294                 tx_ip = tx[IP]
295                 rx_ip = rx_gre[IP]
296
297                 self.assertEqual(rx_ip.src, tx_ip.src)
298                 self.assertEqual(rx_ip.dst, tx_ip.dst)
299
300             except:
301                 self.logger.error(ppp("Rx:", rx))
302                 self.logger.error(ppp("Tx:", tx))
303                 raise
304
305     def verify_tunneled_6o4(self, src_if, capture, sent,
306                             tunnel_src, tunnel_dst):
307
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[IP]
316
317                 self.assertEqual(rx_ip.src, tunnel_src)
318                 self.assertEqual(rx_ip.dst, tunnel_dst)
319
320                 rx_gre = GRE(scapy.compat.raw(rx_ip[IP].payload))
321                 rx_ip = rx_gre[IPv6]
322                 tx_ip = tx[IPv6]
323
324                 self.assertEqual(rx_ip.src, tx_ip.src)
325                 self.assertEqual(rx_ip.dst, tx_ip.dst)
326
327             except:
328                 self.logger.error(ppp("Rx:", rx))
329                 self.logger.error(ppp("Tx:", tx))
330                 raise
331
332     def verify_tunneled_l2o4(self, src_if, capture, sent,
333                              tunnel_src, tunnel_dst):
334         self.assertEqual(len(capture), len(sent))
335
336         for i in range(len(capture)):
337             try:
338                 tx = sent[i]
339                 rx = capture[i]
340
341                 tx_ip = tx[IP]
342                 rx_ip = rx[IP]
343
344                 self.assertEqual(rx_ip.src, tunnel_src)
345                 self.assertEqual(rx_ip.dst, tunnel_dst)
346
347                 rx_gre = rx[GRE]
348                 rx_l2 = rx_gre[Ether]
349                 rx_ip = rx_l2[IP]
350                 tx_gre = tx[GRE]
351                 tx_l2 = tx_gre[Ether]
352                 tx_ip = tx_l2[IP]
353
354                 self.assertEqual(rx_ip.src, tx_ip.src)
355                 self.assertEqual(rx_ip.dst, tx_ip.dst)
356                 # bridged, not L3 forwarded, so no TTL decrement
357                 self.assertEqual(rx_ip.ttl, tx_ip.ttl)
358
359             except:
360                 self.logger.error(ppp("Rx:", rx))
361                 self.logger.error(ppp("Tx:", tx))
362                 raise
363
364     def verify_tunneled_vlano4(self, src_if, capture, sent,
365                                tunnel_src, tunnel_dst, vlan):
366         try:
367             self.assertEqual(len(capture), len(sent))
368         except:
369             ppc("Unexpected packets captured:", capture)
370             raise
371
372         for i in range(len(capture)):
373             try:
374                 tx = sent[i]
375                 rx = capture[i]
376
377                 tx_ip = tx[IP]
378                 rx_ip = rx[IP]
379
380                 self.assertEqual(rx_ip.src, tunnel_src)
381                 self.assertEqual(rx_ip.dst, tunnel_dst)
382
383                 rx_gre = rx[GRE]
384                 rx_l2 = rx_gre[Ether]
385                 rx_vlan = rx_l2[Dot1Q]
386                 rx_ip = rx_l2[IP]
387
388                 self.assertEqual(rx_vlan.vlan, vlan)
389
390                 tx_gre = tx[GRE]
391                 tx_l2 = tx_gre[Ether]
392                 tx_ip = tx_l2[IP]
393
394                 self.assertEqual(rx_ip.src, tx_ip.src)
395                 self.assertEqual(rx_ip.dst, tx_ip.dst)
396                 # bridged, not L3 forwarded, so no TTL decrement
397                 self.assertEqual(rx_ip.ttl, tx_ip.ttl)
398
399             except:
400                 self.logger.error(ppp("Rx:", rx))
401                 self.logger.error(ppp("Tx:", tx))
402                 raise
403
404     def verify_decapped_4o4(self, src_if, capture, sent):
405         self.assertEqual(len(capture), len(sent))
406
407         for i in range(len(capture)):
408             try:
409                 tx = sent[i]
410                 rx = capture[i]
411
412                 tx_ip = tx[IP]
413                 rx_ip = rx[IP]
414                 tx_gre = tx[GRE]
415                 tx_ip = tx_gre[IP]
416
417                 self.assertEqual(rx_ip.src, tx_ip.src)
418                 self.assertEqual(rx_ip.dst, tx_ip.dst)
419                 # IP processing post pop has decremented the TTL
420                 self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl)
421
422             except:
423                 self.logger.error(ppp("Rx:", rx))
424                 self.logger.error(ppp("Tx:", tx))
425                 raise
426
427     def verify_decapped_6o4(self, src_if, capture, sent):
428         self.assertEqual(len(capture), len(sent))
429
430         for i in range(len(capture)):
431             try:
432                 tx = sent[i]
433                 rx = capture[i]
434
435                 tx_ip = tx[IP]
436                 rx_ip = rx[IPv6]
437                 tx_gre = tx[GRE]
438                 tx_ip = tx_gre[IPv6]
439
440                 self.assertEqual(rx_ip.src, tx_ip.src)
441                 self.assertEqual(rx_ip.dst, tx_ip.dst)
442                 self.assertEqual(rx_ip.hlim + 1, tx_ip.hlim)
443
444             except:
445                 self.logger.error(ppp("Rx:", rx))
446                 self.logger.error(ppp("Tx:", tx))
447                 raise
448
449     def test_gre(self):
450         """ GRE IPv4 tunnel Tests """
451
452         #
453         # Create an L3 GRE tunnel.
454         #  - set it admin up
455         #  - assign an IP Addres
456         #  - Add a route via the tunnel
457         #
458         gre_if = VppGreInterface(self,
459                                  self.pg0.local_ip4,
460                                  "1.1.1.2")
461         gre_if.add_vpp_config()
462
463         #
464         # The double create (create the same tunnel twice) should fail,
465         # and we should still be able to use the original
466         #
467         try:
468             gre_if.add_vpp_config()
469         except Exception:
470             pass
471         else:
472             self.fail("Double GRE tunnel add does not fail")
473
474         gre_if.admin_up()
475         gre_if.config_ip4()
476
477         route_via_tun = VppIpRoute(self, "4.4.4.4", 32,
478                                    [VppRoutePath("0.0.0.0",
479                                                  gre_if.sw_if_index)])
480
481         route_via_tun.add_vpp_config()
482
483         #
484         # Send a packet stream that is routed into the tunnel
485         #  - they are all dropped since the tunnel's destintation IP
486         #    is unresolved - or resolves via the default route - which
487         #    which is a drop.
488         #
489         tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
490
491         self.send_and_assert_no_replies(self.pg0, tx)
492
493         #
494         # Add a route that resolves the tunnel's destination
495         #
496         route_tun_dst = VppIpRoute(self, "1.1.1.2", 32,
497                                    [VppRoutePath(self.pg0.remote_ip4,
498                                                  self.pg0.sw_if_index)])
499         route_tun_dst.add_vpp_config()
500
501         #
502         # Send a packet stream that is routed into the tunnel
503         #  - packets are GRE encapped
504         #
505         tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
506         rx = self.send_and_expect(self.pg0, tx, self.pg0)
507         self.verify_tunneled_4o4(self.pg0, rx, tx,
508                                  self.pg0.local_ip4, "1.1.1.2")
509
510         #
511         # Send tunneled packets that match the created tunnel and
512         # are decapped and forwarded
513         #
514         tx = self.create_tunnel_stream_4o4(self.pg0,
515                                            "1.1.1.2",
516                                            self.pg0.local_ip4,
517                                            self.pg0.local_ip4,
518                                            self.pg0.remote_ip4)
519         rx = self.send_and_expect(self.pg0, tx, self.pg0)
520         self.verify_decapped_4o4(self.pg0, rx, tx)
521
522         #
523         # Send tunneled packets that do not match the tunnel's src
524         #
525         self.vapi.cli("clear trace")
526         tx = self.create_tunnel_stream_4o4(self.pg0,
527                                            "1.1.1.3",
528                                            self.pg0.local_ip4,
529                                            self.pg0.local_ip4,
530                                            self.pg0.remote_ip4)
531         self.send_and_assert_no_replies(
532             self.pg0, tx,
533             remark="GRE packets forwarded despite no SRC address match")
534
535         #
536         # Configure IPv6 on the PG interface so we can route IPv6
537         # packets
538         #
539         self.pg0.config_ip6()
540         self.pg0.resolve_ndp()
541
542         #
543         # Send IPv6 tunnel encapslated packets
544         #  - dropped since IPv6 is not enabled on the tunnel
545         #
546         tx = self.create_tunnel_stream_6o4(self.pg0,
547                                            "1.1.1.2",
548                                            self.pg0.local_ip4,
549                                            self.pg0.local_ip6,
550                                            self.pg0.remote_ip6)
551         self.send_and_assert_no_replies(self.pg0, tx,
552                                         "IPv6 GRE packets forwarded "
553                                         "despite IPv6 not enabled on tunnel")
554
555         #
556         # Enable IPv6 on the tunnel
557         #
558         gre_if.config_ip6()
559
560         #
561         # Send IPv6 tunnel encapslated packets
562         #  - forwarded since IPv6 is enabled on the tunnel
563         #
564         tx = self.create_tunnel_stream_6o4(self.pg0,
565                                            "1.1.1.2",
566                                            self.pg0.local_ip4,
567                                            self.pg0.local_ip6,
568                                            self.pg0.remote_ip6)
569         rx = self.send_and_expect(self.pg0, tx, self.pg0)
570         self.verify_decapped_6o4(self.pg0, rx, tx)
571
572         #
573         # Send v6 packets for v4 encap
574         #
575         route6_via_tun = VppIpRoute(
576             self, "2001::1", 128,
577             [VppRoutePath("::",
578                           gre_if.sw_if_index,
579                           proto=DpoProto.DPO_PROTO_IP6)])
580         route6_via_tun.add_vpp_config()
581
582         tx = self.create_stream_ip6(self.pg0, "2001::2", "2001::1")
583         rx = self.send_and_expect(self.pg0, tx, self.pg0)
584
585         self.verify_tunneled_6o4(self.pg0, rx, tx,
586                                  self.pg0.local_ip4, "1.1.1.2")
587
588         #
589         # test case cleanup
590         #
591         route_tun_dst.remove_vpp_config()
592         route_via_tun.remove_vpp_config()
593         route6_via_tun.remove_vpp_config()
594         gre_if.remove_vpp_config()
595
596         self.pg0.unconfig_ip6()
597
598     def test_gre6(self):
599         """ GRE IPv6 tunnel Tests """
600
601         self.pg1.config_ip6()
602         self.pg1.resolve_ndp()
603
604         #
605         # Create an L3 GRE tunnel.
606         #  - set it admin up
607         #  - assign an IP Address
608         #  - Add a route via the tunnel
609         #
610         gre_if = VppGreInterface(self,
611                                  self.pg2.local_ip6,
612                                  "1002::1")
613         gre_if.add_vpp_config()
614         gre_if.admin_up()
615         gre_if.config_ip6()
616
617         route_via_tun = VppIpRoute(self, "4004::1", 128,
618                                    [VppRoutePath("0::0",
619                                                  gre_if.sw_if_index)])
620
621         route_via_tun.add_vpp_config()
622
623         #
624         # Send a packet stream that is routed into the tunnel
625         #  - they are all dropped since the tunnel's destintation IP
626         #    is unresolved - or resolves via the default route - which
627         #    which is a drop.
628         #
629         tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
630         self.send_and_assert_no_replies(
631             self.pg2, tx,
632             "GRE packets forwarded without DIP resolved")
633
634         #
635         # Add a route that resolves the tunnel's destination
636         #
637         route_tun_dst = VppIpRoute(self, "1002::1", 128,
638                                    [VppRoutePath(self.pg2.remote_ip6,
639                                                  self.pg2.sw_if_index)])
640         route_tun_dst.add_vpp_config()
641
642         #
643         # Send a packet stream that is routed into the tunnel
644         #  - packets are GRE encapped
645         #
646         tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
647         rx = self.send_and_expect(self.pg2, tx, self.pg2)
648         self.verify_tunneled_6o6(self.pg2, rx, tx,
649                                  self.pg2.local_ip6, "1002::1")
650
651         #
652         # Test decap. decapped packets go out pg1
653         #
654         tx = self.create_tunnel_stream_6o6(self.pg2,
655                                            "1002::1",
656                                            self.pg2.local_ip6,
657                                            "2001::1",
658                                            self.pg1.remote_ip6)
659         rx = self.send_and_expect(self.pg2, tx, self.pg1)
660
661         #
662         # RX'd packet is UDP over IPv6, test the GRE header is gone.
663         #
664         self.assertFalse(rx[0].haslayer(GRE))
665         self.assertEqual(rx[0][IPv6].dst, self.pg1.remote_ip6)
666
667         #
668         # Send v4 over v6
669         #
670         route4_via_tun = VppIpRoute(self, "1.1.1.1", 32,
671                                     [VppRoutePath("0.0.0.0",
672                                                   gre_if.sw_if_index)])
673         route4_via_tun.add_vpp_config()
674
675         tx = self.create_stream_ip4(self.pg0, "1.1.1.2", "1.1.1.1")
676         rx = self.send_and_expect(self.pg0, tx, self.pg2)
677
678         self.verify_tunneled_4o6(self.pg0, rx, tx,
679                                  self.pg2.local_ip6, "1002::1")
680
681         #
682         # test case cleanup
683         #
684         route_tun_dst.remove_vpp_config()
685         route_via_tun.remove_vpp_config()
686         route4_via_tun.remove_vpp_config()
687         gre_if.remove_vpp_config()
688
689         self.pg2.unconfig_ip6()
690         self.pg1.unconfig_ip6()
691
692     def test_gre_vrf(self):
693         """ GRE tunnel VRF Tests """
694
695         #
696         # Create an L3 GRE tunnel whose destination is in the non-default
697         # table. The underlay is thus non-default - the overlay is still
698         # the default.
699         #  - set it admin up
700         #  - assign an IP Addres
701         #
702         gre_if = VppGreInterface(self, self.pg1.local_ip4,
703                                  "2.2.2.2",
704                                  outer_fib_id=1)
705         gre_if.add_vpp_config()
706         gre_if.admin_up()
707         gre_if.config_ip4()
708
709         #
710         # Add a route via the tunnel - in the overlay
711         #
712         route_via_tun = VppIpRoute(self, "9.9.9.9", 32,
713                                    [VppRoutePath("0.0.0.0",
714                                                  gre_if.sw_if_index)])
715         route_via_tun.add_vpp_config()
716
717         #
718         # Add a route that resolves the tunnel's destination - in the
719         # underlay table
720         #
721         route_tun_dst = VppIpRoute(self, "2.2.2.2", 32, table_id=1,
722                                    paths=[VppRoutePath(self.pg1.remote_ip4,
723                                                        self.pg1.sw_if_index)])
724         route_tun_dst.add_vpp_config()
725
726         #
727         # Send a packet stream that is routed into the tunnel
728         # packets are sent in on pg0 which is in the default table
729         #  - packets are GRE encapped
730         #
731         self.vapi.cli("clear trace")
732         tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "9.9.9.9")
733         rx = self.send_and_expect(self.pg0, tx, self.pg1)
734         self.verify_tunneled_4o4(self.pg1, rx, tx,
735                                  self.pg1.local_ip4, "2.2.2.2")
736
737         #
738         # Send tunneled packets that match the created tunnel and
739         # are decapped and forwarded. This tests the decap lookup
740         # does not happen in the encap table
741         #
742         self.vapi.cli("clear trace")
743         tx = self.create_tunnel_stream_4o4(self.pg1,
744                                            "2.2.2.2",
745                                            self.pg1.local_ip4,
746                                            self.pg0.local_ip4,
747                                            self.pg0.remote_ip4)
748         rx = self.send_and_expect(self.pg1, tx, self.pg0)
749         self.verify_decapped_4o4(self.pg0, rx, tx)
750
751         #
752         # Send tunneled packets that match the created tunnel
753         # but arrive on an interface that is not in the tunnel's
754         # encap VRF, these are dropped.
755         # IP enable the interface so they aren't dropped due to
756         # IP not being enabled.
757         #
758         self.pg2.config_ip4()
759         self.vapi.cli("clear trace")
760         tx = self.create_tunnel_stream_4o4(self.pg2,
761                                            "2.2.2.2",
762                                            self.pg1.local_ip4,
763                                            self.pg0.local_ip4,
764                                            self.pg0.remote_ip4)
765         rx = self.send_and_assert_no_replies(
766             self.pg2, tx,
767             "GRE decap packets in wrong VRF")
768
769         self.pg2.unconfig_ip4()
770
771         #
772         # test case cleanup
773         #
774         route_tun_dst.remove_vpp_config()
775         route_via_tun.remove_vpp_config()
776         gre_if.remove_vpp_config()
777
778     def test_gre_l2(self):
779         """ GRE tunnel L2 Tests """
780
781         #
782         # Add routes to resolve the tunnel destinations
783         #
784         route_tun1_dst = VppIpRoute(self, "2.2.2.2", 32,
785                                     [VppRoutePath(self.pg0.remote_ip4,
786                                                   self.pg0.sw_if_index)])
787         route_tun2_dst = VppIpRoute(self, "2.2.2.3", 32,
788                                     [VppRoutePath(self.pg0.remote_ip4,
789                                                   self.pg0.sw_if_index)])
790
791         route_tun1_dst.add_vpp_config()
792         route_tun2_dst.add_vpp_config()
793
794         #
795         # Create 2 L2 GRE tunnels and x-connect them
796         #
797         gre_if1 = VppGreInterface(self, self.pg0.local_ip4,
798                                   "2.2.2.2",
799                                   type=(VppEnum.vl_api_gre_tunnel_type_t.
800                                         GRE_API_TUNNEL_TYPE_TEB))
801         gre_if2 = VppGreInterface(self, self.pg0.local_ip4,
802                                   "2.2.2.3",
803                                   type=(VppEnum.vl_api_gre_tunnel_type_t.
804                                         GRE_API_TUNNEL_TYPE_TEB))
805         gre_if1.add_vpp_config()
806         gre_if2.add_vpp_config()
807
808         gre_if1.admin_up()
809         gre_if2.admin_up()
810
811         self.vapi.sw_interface_set_l2_xconnect(gre_if1.sw_if_index,
812                                                gre_if2.sw_if_index,
813                                                enable=1)
814         self.vapi.sw_interface_set_l2_xconnect(gre_if2.sw_if_index,
815                                                gre_if1.sw_if_index,
816                                                enable=1)
817
818         #
819         # Send in tunnel encapped L2. expect out tunnel encapped L2
820         # in both directions
821         #
822         tx = self.create_tunnel_stream_l2o4(self.pg0,
823                                             "2.2.2.2",
824                                             self.pg0.local_ip4)
825         rx = self.send_and_expect(self.pg0, tx, self.pg0)
826         self.verify_tunneled_l2o4(self.pg0, rx, tx,
827                                   self.pg0.local_ip4,
828                                   "2.2.2.3")
829
830         tx = self.create_tunnel_stream_l2o4(self.pg0,
831                                             "2.2.2.3",
832                                             self.pg0.local_ip4)
833         rx = self.send_and_expect(self.pg0, tx, self.pg0)
834         self.verify_tunneled_l2o4(self.pg0, rx, tx,
835                                   self.pg0.local_ip4,
836                                   "2.2.2.2")
837
838         self.vapi.sw_interface_set_l2_xconnect(gre_if1.sw_if_index,
839                                                gre_if2.sw_if_index,
840                                                enable=0)
841         self.vapi.sw_interface_set_l2_xconnect(gre_if2.sw_if_index,
842                                                gre_if1.sw_if_index,
843                                                enable=0)
844
845         #
846         # Create a VLAN sub-interfaces on the GRE TEB interfaces
847         # then x-connect them
848         #
849         gre_if_11 = VppDot1QSubint(self, gre_if1, 11)
850         gre_if_12 = VppDot1QSubint(self, gre_if2, 12)
851
852         # gre_if_11.add_vpp_config()
853         # gre_if_12.add_vpp_config()
854
855         gre_if_11.admin_up()
856         gre_if_12.admin_up()
857
858         self.vapi.sw_interface_set_l2_xconnect(gre_if_11.sw_if_index,
859                                                gre_if_12.sw_if_index,
860                                                enable=1)
861         self.vapi.sw_interface_set_l2_xconnect(gre_if_12.sw_if_index,
862                                                gre_if_11.sw_if_index,
863                                                enable=1)
864
865         #
866         # Configure both to pop thier respective VLAN tags,
867         # so that during the x-coonect they will subsequently push
868         #
869         self.vapi.l2_interface_vlan_tag_rewrite(
870             sw_if_index=gre_if_12.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
871             push_dot1q=12)
872         self.vapi.l2_interface_vlan_tag_rewrite(
873             sw_if_index=gre_if_11.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
874             push_dot1q=11)
875
876         #
877         # Send traffic in both directiond - expect the VLAN tags to
878         # be swapped.
879         #
880         tx = self.create_tunnel_stream_vlano4(self.pg0,
881                                               "2.2.2.2",
882                                               self.pg0.local_ip4,
883                                               11)
884         rx = self.send_and_expect(self.pg0, tx, self.pg0)
885         self.verify_tunneled_vlano4(self.pg0, rx, tx,
886                                     self.pg0.local_ip4,
887                                     "2.2.2.3",
888                                     12)
889
890         tx = self.create_tunnel_stream_vlano4(self.pg0,
891                                               "2.2.2.3",
892                                               self.pg0.local_ip4,
893                                               12)
894         rx = self.send_and_expect(self.pg0, tx, self.pg0)
895         self.verify_tunneled_vlano4(self.pg0, rx, tx,
896                                     self.pg0.local_ip4,
897                                     "2.2.2.2",
898                                     11)
899
900         #
901         # Cleanup Test resources
902         #
903         gre_if_11.remove_vpp_config()
904         gre_if_12.remove_vpp_config()
905         gre_if1.remove_vpp_config()
906         gre_if2.remove_vpp_config()
907         route_tun1_dst.add_vpp_config()
908         route_tun2_dst.add_vpp_config()
909
910     def test_gre_loop(self):
911         """ GRE tunnel loop Tests """
912
913         #
914         # Create an L3 GRE tunnel.
915         #  - set it admin up
916         #  - assign an IP Addres
917         #
918         gre_if = VppGreInterface(self,
919                                  self.pg0.local_ip4,
920                                  "1.1.1.2")
921         gre_if.add_vpp_config()
922         gre_if.admin_up()
923         gre_if.config_ip4()
924
925         #
926         # add a route to the tunnel's destination that points
927         # through the tunnel, hence forming a loop in the forwarding
928         # graph
929         #
930         route_dst = VppIpRoute(self, "1.1.1.2", 32,
931                                [VppRoutePath("0.0.0.0",
932                                              gre_if.sw_if_index)])
933         route_dst.add_vpp_config()
934
935         #
936         # packets to the tunnels destination should be dropped
937         #
938         tx = self.create_stream_ip4(self.pg0, "1.1.1.1", "1.1.1.2")
939         self.send_and_assert_no_replies(self.pg2, tx)
940
941         self.logger.info(self.vapi.ppcli("sh adj 7"))
942
943         #
944         # break the loop
945         #
946         route_dst.modify([VppRoutePath(self.pg1.remote_ip4,
947                                        self.pg1.sw_if_index)])
948         route_dst.add_vpp_config()
949
950         rx = self.send_and_expect(self.pg0, tx, self.pg1)
951
952         #
953         # a good route throught the tunnel to check it restacked
954         #
955         route_via_tun_2 = VppIpRoute(self, "2.2.2.2", 32,
956                                      [VppRoutePath("0.0.0.0",
957                                                    gre_if.sw_if_index)])
958         route_via_tun_2.add_vpp_config()
959
960         tx = self.create_stream_ip4(self.pg0, "2.2.2.3", "2.2.2.2")
961         rx = self.send_and_expect(self.pg0, tx, self.pg1)
962         self.verify_tunneled_4o4(self.pg1, rx, tx,
963                                  self.pg0.local_ip4, "1.1.1.2")
964
965         #
966         # cleanup
967         #
968         route_via_tun_2.remove_vpp_config()
969         gre_if.remove_vpp_config()
970
971
972 if __name__ == '__main__':
973     unittest.main(testRunner=VppTestRunner)