test/test_ipip.py

   1 #!/usr/bin/env python
   2 """IP{4,6} over IP{v,6} tunnel functional tests"""
   3
   4 import unittest
   5 from scapy.layers.inet6 import IPv6, Ether, IP, UDP
   6 from scapy.all import fragment, RandShort
   7 from framework import VppTestCase, VppTestRunner
   8 from vpp_ip import DpoProto
   9 from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable
  10 from socket import AF_INET, AF_INET6, inet_pton
  11 import StringIO
  12
  13 """ Testipip is a subclass of  VPPTestCase classes.
  14
  15 IPIP tests.
  16
  17 """
  18
  19
  20 def reassemble(listoffragments):
  21     buffer = StringIO.StringIO()
  22     first = listoffragments[0]
  23     buffer.seek(20)
  24     for pkt in listoffragments:
  25         buffer.seek(pkt[IP].frag*8)
  26         buffer.write(pkt[IP].payload)
  27     first.len = len(buffer.getvalue()) + 20
  28     first.flags = 0
  29     del(first.chksum)
  30     header = str(first[IP])[:20]
  31     return first[IP].__class__(header + buffer.getvalue())
  32
  33
  34 class TestIPIP(VppTestCase):
  35     """ IPIP Test Case """
  36
  37     @classmethod
  38     def setUpClass(cls):
  39         super(TestIPIP, cls).setUpClass()
  40         cls.create_pg_interfaces(range(2))
  41         cls.interfaces = list(cls.pg_interfaces)
  42
  43     def setUp(cls):
  44         super(TestIPIP, cls).setUp()
  45         for i in cls.interfaces:
  46             i.admin_up()
  47             i.config_ip4()
  48             i.config_ip6()
  49             i.disable_ipv6_ra()
  50             i.resolve_arp()
  51             i.resolve_ndp()
  52
  53     def tearDown(self):
  54         super(TestIPIP, self).tearDown()
  55         if not self.vpp_dead:
  56             for i in self.pg_interfaces:
  57                 i.unconfig_ip4()
  58                 i.unconfig_ip6()
  59                 i.admin_down()
  60
  61     def validate(self, rx, expected):
  62         self.assertEqual(rx, expected.__class__(str(expected)))
  63
  64     def generate_frags(self, payload_length, fragment_size):
  65         p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
  66         p_payload = UDP(sport=1234, dport=1234) / self.payload(payload_length)
  67         p_ip4 = IP(src="1.2.3.4", dst=self.pg0.remote_ip4)
  68         outer_ip4 = (p_ether / IP(src=self.pg1.remote_ip4,
  69                                   id=RandShort(),
  70                                   dst=self.pg0.local_ip4) / p_ip4 / p_payload)
  71         frags = fragment(outer_ip4, fragment_size)
  72         p4_reply = (p_ip4 / p_payload)
  73         p4_reply.ttl -= 1
  74         return frags, p4_reply
  75
  76     def test_ipip4(self):
  77         """ ip{v4,v6} over ip4 test """
  78         p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
  79         p_ip6 = IPv6(src="1::1", dst="DEAD::1", nh='UDP', tc=42)
  80         p_ip4 = IP(src="1.2.3.4", dst="130.67.0.1", tos=42)
  81         p_payload = UDP(sport=1234, dport=1234)
  82
  83         # IPv4 transport
  84         rv = self.vapi.ipip_add_tunnel(
  85             src_address=self.pg0.local_ip4n,
  86             dst_address=self.pg1.remote_ip4n,
  87             is_ipv6=0, tc_tos=0xFF)
  88         sw_if_index = rv.sw_if_index
  89
  90         # Set interface up and enable IP on it
  91         self.vapi.sw_interface_set_flags(sw_if_index, 1)
  92         self.vapi.sw_interface_set_unnumbered(
  93             ip_sw_if_index=self.pg0.sw_if_index,
  94             sw_if_index=sw_if_index)
  95
  96         # Add IPv4 and IPv6 routes via tunnel interface
  97         ip4_via_tunnel = VppIpRoute(
  98             self, "130.67.0.0", 16,
  99             [VppRoutePath("0.0.0.0",
 100                           sw_if_index,
 101                           proto=DpoProto.DPO_PROTO_IP4)], is_ip6=0)
 102         ip4_via_tunnel.add_vpp_config()
 103
 104         ip6_via_tunnel = VppIpRoute(
 105             self, "dead::", 16,
 106             [VppRoutePath("::",
 107                           sw_if_index,
 108                           proto=DpoProto.DPO_PROTO_IP6)], is_ip6=1)
 109         ip6_via_tunnel.add_vpp_config()
 110
 111         # IPv6 in to IPv4 tunnel
 112         p6 = (p_ether / p_ip6 / p_payload)
 113         p_inner_ip6 = p_ip6
 114         p_inner_ip6.hlim -= 1
 115         p6_reply = (IP(src=self.pg0.local_ip4, dst=self.pg1.remote_ip4,
 116                        proto='ipv6', id=0, tos=42) / p_inner_ip6 / p_payload)
 117         p6_reply.ttl -= 1
 118         rx = self.send_and_expect(self.pg0, p6*10, self.pg1)
 119         for p in rx:
 120             self.validate(p[1], p6_reply)
 121
 122         # IPv4 in to IPv4 tunnel
 123         p4 = (p_ether / p_ip4 / p_payload)
 124         p_ip4_inner = p_ip4
 125         p_ip4_inner.ttl -= 1
 126         p4_reply = (IP(src=self.pg0.local_ip4, dst=self.pg1.remote_ip4,
 127                        tos=42) /
 128                     p_ip4_inner / p_payload)
 129         p4_reply.ttl -= 1
 130         p4_reply.id = 0
 131         rx = self.send_and_expect(self.pg0, p4*10, self.pg1)
 132         for p in rx:
 133             self.validate(p[1], p4_reply)
 134
 135         # Decapsulation
 136         p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
 137
 138         # IPv4 tunnel to IPv4
 139         p_ip4 = IP(src="1.2.3.4", dst=self.pg0.remote_ip4)
 140         p4 = (p_ether / IP(src=self.pg1.remote_ip4,
 141                            dst=self.pg0.local_ip4) / p_ip4 / p_payload)
 142         p4_reply = (p_ip4 / p_payload)
 143         p4_reply.ttl -= 1
 144         rx = self.send_and_expect(self.pg1, p4*10, self.pg0)
 145         for p in rx:
 146             self.validate(p[1], p4_reply)
 147
 148         err = '/err/ipip4-input/packets decapsulated'
 149         cnt = self.statistics.dump_str(err)
 150         self.assertEqual(cnt[err], 10)
 151
 152         # IPv4 tunnel to IPv6
 153         p_ip6 = IPv6(src="1:2:3::4", dst=self.pg0.remote_ip6)
 154         p6 = (p_ether / IP(src=self.pg1.remote_ip4,
 155                            dst=self.pg0.local_ip4) / p_ip6 / p_payload)
 156         p6_reply = (p_ip6 / p_payload)
 157         p6_reply.hlim = 63
 158         rx = self.send_and_expect(self.pg1, p6*10, self.pg0)
 159         for p in rx:
 160             self.validate(p[1], p6_reply)
 161
 162         cnt = self.statistics.dump_str(err)
 163         self.assertEqual(cnt[err], 20)
 164
 165         #
 166         # Fragmentation / Reassembly and Re-fragmentation
 167         #
 168         rv = self.vapi.ip_reassembly_enable_disable(
 169             sw_if_index=self.pg1.sw_if_index,
 170             enable_ip4=1)
 171
 172         # Send lots of fragments, verify reassembled packet
 173         frags, p4_reply = self.generate_frags(3131, 1400)
 174         f = []
 175         for i in range(0, 1000):
 176             f.extend(frags)
 177         self.pg1.add_stream(f)
 178         self.pg_enable_capture()
 179         self.pg_start()
 180         rx = self.pg0.get_capture(1000)
 181
 182         for p in rx:
 183             self.validate(p[1], p4_reply)
 184
 185         cnt = self.statistics.dump_str(err)
 186         self.assertEqual(cnt[err], 1020)
 187
 188         f = []
 189         r = []
 190         for i in range(1, 90):
 191             frags, p4_reply = self.generate_frags(i * 100, 1000)
 192             f.extend(frags)
 193             r.extend(p4_reply)
 194         self.pg_enable_capture()
 195         self.pg1.add_stream(f)
 196         self.pg_start()
 197         rx = self.pg0.get_capture(89)
 198         i = 0
 199         for p in rx:
 200             self.validate(p[1], r[i])
 201             i += 1
 202
 203         # Now try with re-fragmentation
 204         #
 205         # Send fragments to tunnel head-end, for the tunnel head end
 206         # to reassemble and then refragment
 207         #
 208         self.vapi.sw_interface_set_mtu(self.pg0.sw_if_index, [576, 0, 0, 0])
 209         frags, p4_reply = self.generate_frags(3123, 1200)
 210         self.pg_enable_capture()
 211         self.pg1.add_stream(frags)
 212         self.pg_start()
 213         rx = self.pg0.get_capture(6)
 214         reass_pkt = reassemble(rx)
 215         p4_reply.ttl -= 1
 216         p4_reply.id = 256
 217         self.validate(reass_pkt, p4_reply)
 218
 219         self.vapi.sw_interface_set_mtu(self.pg0.sw_if_index, [1600, 0, 0, 0])
 220         frags, p4_reply = self.generate_frags(3123, 1200)
 221         self.pg_enable_capture()
 222         self.pg1.add_stream(frags)
 223         self.pg_start()
 224         rx = self.pg0.get_capture(2)
 225         reass_pkt = reassemble(rx)
 226         p4_reply.ttl -= 1
 227         p4_reply.id = 512
 228         self.validate(reass_pkt, p4_reply)
 229
 230     def test_ipip6(self):
 231         """ ip{v4,v6} over ip6 test """
 232         p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
 233         p_ip6 = IPv6(src="1::1", dst="DEAD::1", tc=42, nh='UDP')
 234         p_ip4 = IP(src="1.2.3.4", dst="130.67.0.1", tos=42)
 235         p_payload = UDP(sport=1234, dport=1234)
 236
 237         # IPv6 transport
 238         rv = self.vapi.ipip_add_tunnel(
 239             src_address=self.pg0.local_ip6n,
 240             dst_address=self.pg1.remote_ip6n, tc_tos=255)
 241
 242         sw_if_index = rv.sw_if_index
 243
 244         self.vapi.sw_interface_set_flags(sw_if_index, 1)
 245         self.vapi.sw_interface_set_unnumbered(
 246             ip_sw_if_index=self.pg0.sw_if_index, sw_if_index=sw_if_index)
 247
 248         # Add IPv4 and IPv6 routes via tunnel interface
 249         ip4_via_tunnel = VppIpRoute(
 250             self, "130.67.0.0", 16,
 251             [VppRoutePath("0.0.0.0",
 252                           sw_if_index,
 253                           proto=DpoProto.DPO_PROTO_IP4)], is_ip6=0)
 254         ip4_via_tunnel.add_vpp_config()
 255
 256         ip6_via_tunnel = VppIpRoute(
 257             self, "dead::", 16,
 258             [VppRoutePath("::",
 259                           sw_if_index,
 260                           proto=DpoProto.DPO_PROTO_IP6)], is_ip6=1)
 261         ip6_via_tunnel.add_vpp_config()
 262
 263         # Encapsulation
 264
 265         # IPv6 in to IPv6 tunnel
 266         p6 = (p_ether / p_ip6 / p_payload)
 267         p6_reply = (IPv6(src=self.pg0.local_ip6, dst=self.pg1.remote_ip6,
 268                          hlim=63, tc=42) /
 269                     p_ip6 / p_payload)
 270         p6_reply[1].hlim -= 1
 271         rx = self.send_and_expect(self.pg0, p6*11, self.pg1)
 272         for p in rx:
 273             self.validate(p[1], p6_reply)
 274
 275         # IPv4 in to IPv6 tunnel
 276         p4 = (p_ether / p_ip4 / p_payload)
 277         p4_reply = (IPv6(src=self.pg0.local_ip6,
 278                          dst=self.pg1.remote_ip6, hlim=63, tc=42) /
 279                     p_ip4 / p_payload)
 280         p4_reply[1].ttl -= 1
 281         rx = self.send_and_expect(self.pg0, p4*11, self.pg1)
 282         for p in rx:
 283             self.validate(p[1], p4_reply)
 284
 285         # Decapsulation
 286
 287         p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
 288
 289         # IPv6 tunnel to IPv4
 290         p_ip4 = IP(src="1.2.3.4", dst=self.pg0.remote_ip4)
 291         p4 = (p_ether / IPv6(src=self.pg1.remote_ip6,
 292                              dst=self.pg0.local_ip6) / p_ip4 / p_payload)
 293         p4_reply = (p_ip4 / p_payload)
 294         p4_reply.ttl -= 1
 295         rx = self.send_and_expect(self.pg1, p4*11, self.pg0)
 296         for p in rx:
 297             self.validate(p[1], p4_reply)
 298
 299         # IPv6 tunnel to IPv6
 300         p_ip6 = IPv6(src="1:2:3::4", dst=self.pg0.remote_ip6)
 301         p6 = (p_ether / IPv6(src=self.pg1.remote_ip6,
 302                              dst=self.pg0.local_ip6) / p_ip6 / p_payload)
 303         p6_reply = (p_ip6 / p_payload)
 304         p6_reply.hlim = 63
 305         rx = self.send_and_expect(self.pg1, p6*11, self.pg0)
 306         for p in rx:
 307             self.validate(p[1], p6_reply)
 308
 309     def test_ipip_create(self):
 310         """ ipip create / delete interface test """
 311         rv = self.vapi.ipip_add_tunnel(
 312             src_address=inet_pton(AF_INET, '1.2.3.4'),
 313             dst_address=inet_pton(AF_INET, '2.3.4.5'), is_ipv6=0)
 314         sw_if_index = rv.sw_if_index
 315         self.vapi.ipip_del_tunnel(sw_if_index)
 316
 317     def test_ipip_vrf_create(self):
 318         """ ipip create / delete interface VRF test """
 319
 320         t = VppIpTable(self, 20)
 321         t.add_vpp_config()
 322         rv = self.vapi.ipip_add_tunnel(
 323             src_address=inet_pton(AF_INET, '1.2.3.4'),
 324             dst_address=inet_pton(AF_INET, '2.3.4.5'), is_ipv6=0,
 325             table_id=20)
 326         sw_if_index = rv.sw_if_index
 327         self.vapi.ipip_del_tunnel(sw_if_index)
 328
 329     def payload(self, len):
 330         return 'x' * len
 331
 332
 333 if __name__ == '__main__':
 334     unittest.main(testRunner=VppTestRunner)