VXLAN over IPv6.

Refactors the VXLAN node to work with both IPv4 and IPv6 transports.

There is a discussion thread for this change at
https://lists.fd.io/pipermail/vpp-dev/2016-March/000279.html

Note that this changes the binary configuration API to support both
address families; each address uses the same memory for either address
type and a flag to indicate which is in use. This also includes changes
to the Java API to support both address families.

The CLI and VAT syntax remains unchanged; the code detects whether an
IPv4 or an IPv6 address was given.

Configuration examples:

IPv4 CLI: create vxlan tunnel src 192.168.1.1 dst 192.168.1.2
                vni 10 encap-vrf-id 0 decap-next l2
IPv6 CLI: create vxlan tunnel src 2620:124:9000::1 dst 2620:124:9000::2
                vni 16 encap-vrf-id 0 decap-next l2

IPv4 VAT: vxlan_add_del_tunnel src 192.168.1.1 dst 192.168.1.2
                vni 10 encap-vrf-id 0 decap-next l2
IPv6 VAT: vxlan_add_del_tunnel src 2620:124:9000::1 dst 2620:124:9000::2
                vni 16 encap-vrf-id 0 decap-next l2

TODO: The encap path is not as optimal as it could be.

Change-Id: I87be8bf0501e0c9cd7e401be4542bb599f1b6e47
Signed-off-by: Chris Luke <chrisy@flirble.org>

1 files changed, 177 insertions, 32 deletions

diff --git a/vnet/vnet/vxlan/vxlan.c b/vnet/vnet/vxlan/vxlan.c
index 6e3842887a7..89e56e7844f 100644
--- a/vnet/vnet/vxlan/vxlan.c
+++ b/vnet/vnet/vxlan/vxlan.c
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 #include <vnet/vxlan/vxlan.h>
+#include <vnet/ip/format.h>
 
 vxlan_main_t vxlan_main;
 
@@ -44,8 +45,8 @@ u8 * format_vxlan_tunnel (u8 * s, va_list * args)
   s = format (s, 
               "[%d] %U (src) %U (dst) vni %d encap_fib_index %d",
               t - ngm->tunnels,
-              format_ip4_address, &t->src,
-              format_ip4_address, &t->dst,
+              format_ip46_address, &t->src,
+              format_ip46_address, &t->dst,
               t->vni,
               t->encap_fib_index);
   s = format (s, " decap_next %U\n", format_decap_next, t->decap_next_index);
@@ -109,13 +110,23 @@ VNET_HW_INTERFACE_CLASS (vxlan_hw_class) = {
 };
 
 #define foreach_copy_field                      \
-_(src.as_u32)                                   \
-_(dst.as_u32)                                   \
 _(vni)                                          \
 _(encap_fib_index)                              \
 _(decap_next_index)
 
-static int vxlan_rewrite (vxlan_tunnel_t * t)
+#define foreach_copy_ipv4 {                     \
+  _(src.ip4.as_u32)                             \
+  _(dst.ip4.as_u32)                             \
+}
+
+#define foreach_copy_ipv6 {                     \
+  _(src.ip6.as_u64[0])                          \
+  _(src.ip6.as_u64[1])                          \
+  _(dst.ip6.as_u64[0])                          \
+  _(dst.ip6.as_u64[1])                          \
+}
+
+static int vxlan4_rewrite (vxlan_tunnel_t * t)
 {
   u8 *rw = 0;
   ip4_header_t * ip0;
@@ -133,8 +144,8 @@ static int vxlan_rewrite (vxlan_tunnel_t * t)
   ip0->protocol = IP_PROTOCOL_UDP;
 
   /* we fix up the ip4 header length and checksum after-the-fact */
-  ip0->src_address.as_u32 = t->src.as_u32;
-  ip0->dst_address.as_u32 = t->dst.as_u32;
+  ip0->src_address.as_u32 = t->src.ip4.as_u32;
+  ip0->dst_address.as_u32 = t->dst.ip4.as_u32;
   ip0->checksum = ip4_header_checksum (ip0);
 
   /* UDP header, randomize src port on something, maybe? */
@@ -148,6 +159,39 @@ static int vxlan_rewrite (vxlan_tunnel_t * t)
   return (0);
 }
 
+static int vxlan6_rewrite (vxlan_tunnel_t * t)
+{
+  u8 *rw = 0;
+  ip6_header_t * ip0;
+  ip6_vxlan_header_t * h0;
+  int len = sizeof (*h0);
+
+  vec_validate_aligned (rw, len-1, CLIB_CACHE_LINE_BYTES);
+
+  h0 = (ip6_vxlan_header_t *) rw;
+
+  /* Fixed portion of the (outer) ip6 header */
+  ip0 = &h0->ip6;
+  ip0->ip_version_traffic_class_and_flow_label = clib_host_to_net_u32(6 << 28);
+  ip0->hop_limit = 255;
+  ip0->protocol = IP_PROTOCOL_UDP;
+
+  ip0->src_address.as_u64[0] = t->src.ip6.as_u64[0];
+  ip0->src_address.as_u64[1] = t->src.ip6.as_u64[1];
+  ip0->dst_address.as_u64[0] = t->dst.ip6.as_u64[0];
+  ip0->dst_address.as_u64[1] = t->dst.ip6.as_u64[1];
+
+  /* UDP header, randomize src port on something, maybe? */
+  h0->udp.src_port = clib_host_to_net_u16 (4789);
+  h0->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_vxlan);
+
+  /* VXLAN header */
+  vnet_set_vni_and_flags(&h0->vxlan, t->vni);
+
+  t->rewrite = rw;
+  return (0);
+}
+
 int vnet_vxlan_add_del_tunnel 
 (vnet_vxlan_add_del_tunnel_args_t *a, u32 * sw_if_indexp)
 {
@@ -155,17 +199,27 @@ int vnet_vxlan_add_del_tunnel
   vxlan_tunnel_t *t = 0;
   vnet_main_t * vnm = vxm->vnet_main;
   ip4_main_t * im4 = &ip4_main;
+  ip6_main_t * im6 = &ip6_main;
   vnet_hw_interface_t * hi;
   uword * p;
   u32 hw_if_index = ~0;
   u32 sw_if_index = ~0;
   int rv;
-  vxlan_tunnel_key_t key;
+  vxlan4_tunnel_key_t key4;
+  vxlan6_tunnel_key_t key6;
+
+  if (!a->is_ip6) {
+    key4.src = a->dst.ip4.as_u32; /* decap src in key is encap dst in config */
+    key4.vni = clib_host_to_net_u32 (a->vni << 8);
   
-  key.src = a->dst.as_u32; /* decap src in key is encap dst in config */
-  key.vni = clib_host_to_net_u32 (a->vni << 8);
+    p = hash_get (vxm->vxlan4_tunnel_by_key, key4.as_u64);
+  } else {
+    key6.src.as_u64[0] = a->dst.ip6.as_u64[0];
+    key6.src.as_u64[1] = a->dst.ip6.as_u64[1];
+    key6.vni = clib_host_to_net_u32 (a->vni << 8);
 
-  p = hash_get (vxm->vxlan_tunnel_by_key, key.as_u64);
+    p = hash_get (vxm->vxlan6_tunnel_by_key, pointer_to_uword(&key6));
+  }
   
   if (a->is_add)
     {
@@ -185,9 +239,22 @@ int vnet_vxlan_add_del_tunnel
       /* copy from arg structure */
 #define _(x) t->x = a->x;
       foreach_copy_field;
+      if (!a->is_ip6) foreach_copy_ipv4
+      else            foreach_copy_ipv6
 #undef _
       
-      rv = vxlan_rewrite (t);
+      if (a->is_ip6) {
+        /* copy the key */
+        t->key6 = key6;
+      }
+
+      if (!a->is_ip6) t->flags |= VXLAN_TUNNEL_IS_IPV4;
+
+      if (!a->is_ip6) {
+        rv = vxlan4_rewrite (t);
+      } else {
+        rv = vxlan6_rewrite (t);
+      }
 
       if (rv)
         {
@@ -195,7 +262,10 @@ int vnet_vxlan_add_del_tunnel
           return rv;
         }
 
-      hash_set (vxm->vxlan_tunnel_by_key, key.as_u64, t - vxm->tunnels);
+      if (!a->is_ip6)
+        hash_set (vxm->vxlan4_tunnel_by_key, key4.as_u64, t - vxm->tunnels);
+      else
+        hash_set (vxm->vxlan6_tunnel_by_key, pointer_to_uword(&t->key6), t - vxm->tunnels);
       
       if (vec_len (vxm->free_vxlan_tunnel_hw_if_indices) > 0)
         {
@@ -244,8 +314,13 @@ int vnet_vxlan_add_del_tunnel
 	}
       vnet_sw_interface_set_flags (vnm, sw_if_index, 
                                    VNET_SW_INTERFACE_FLAG_ADMIN_UP);
+      if (!a->is_ip6) {
       vec_validate (im4->fib_index_by_sw_if_index, sw_if_index);
       im4->fib_index_by_sw_if_index[sw_if_index] = t->encap_fib_index;
+      } else {
+        vec_validate (im6->fib_index_by_sw_if_index, sw_if_index);
+        im6->fib_index_by_sw_if_index[sw_if_index] = t->encap_fib_index;
+      }
     }
   else
     {
@@ -262,10 +337,17 @@ int vnet_vxlan_add_del_tunnel
 
       vxm->tunnel_index_by_sw_if_index[t->sw_if_index] = ~0;
 
-      hash_unset (vxm->vxlan_tunnel_by_key, key.as_u64);
+      if (!a->is_ip6)
+        hash_unset (vxm->vxlan4_tunnel_by_key, key4.as_u64);
+      else
+        hash_unset (vxm->vxlan6_tunnel_by_key, pointer_to_uword(&key6));
 
       vec_free (t->rewrite);
-      t->rewrite = vxlan_dummy_rewrite;
+      if (!a->is_ip6) {
+        t->rewrite = vxlan4_dummy_rewrite;
+      } else {
+        t->rewrite = vxlan6_dummy_rewrite;
+      }
       pool_put (vxm->tunnels, t);
     }
 
@@ -275,7 +357,7 @@ int vnet_vxlan_add_del_tunnel
   return 0;
 }
 
-static u32 fib_index_from_fib_id (u32 fib_id)
+static u32 fib4_index_from_fib_id (u32 fib_id)
 {
   ip4_main_t * im = &ip4_main;
   uword * p;
@@ -287,6 +369,18 @@ static u32 fib_index_from_fib_id (u32 fib_id)
   return p[0];
 }
 
+static u32 fib6_index_from_fib_id (u32 fib_id)
+{
+  ip6_main_t * im = &ip6_main;
+  uword * p;
+
+  p = hash_get (im->fib_index_by_table_id, fib_id);
+  if (!p)
+    return ~0;
+
+  return p[0];
+}
+
 static uword unformat_decap_next (unformat_input_t * input, va_list * args)
 {
   u32 * result = va_arg (*args, u32 *);
@@ -313,10 +407,12 @@ vxlan_add_del_tunnel_command_fn (vlib_main_t * vm,
                                    vlib_cli_command_t * cmd)
 {
   unformat_input_t _line_input, * line_input = &_line_input;
-  ip4_address_t src, dst;
+  ip46_address_t src, dst;
   u8 is_add = 1;
   u8 src_set = 0;
   u8 dst_set = 0;
+  u8 ipv4_set = 0;
+  u8 ipv6_set = 0;
   u32 encap_fib_index = 0;
   u32 decap_next_index = ~0;
   u32 vni = 0;
@@ -330,16 +426,39 @@ vxlan_add_del_tunnel_command_fn (vlib_main_t * vm,
 
   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
     if (unformat (line_input, "del"))
-      is_add = 0;
+      {
+        is_add = 0;
+      }
+    else if (unformat (line_input, "src %U",
+                       unformat_ip4_address, &src.ip4))
+      {
+        src_set = 1;
+        ipv4_set = 1;
+      }
+    else if (unformat (line_input, "dst %U",
+                       unformat_ip4_address, &dst.ip4))
+      {
+        dst_set = 1;
+        ipv4_set = 1;
+      }
     else if (unformat (line_input, "src %U", 
-                       unformat_ip4_address, &src))
-      src_set = 1;
+                       unformat_ip6_address, &src.ip6))
+      {
+        src_set = 1;
+        ipv6_set = 1;
+      }
     else if (unformat (line_input, "dst %U",
-                       unformat_ip4_address, &dst))
-      dst_set = 1;
+                       unformat_ip6_address, &dst.ip6))
+      {
+        dst_set = 1;
+        ipv6_set = 1;
+      }
     else if (unformat (line_input, "encap-vrf-id %d", &tmp))
       {
-        encap_fib_index = fib_index_from_fib_id (tmp);
+        if (ipv6_set)
+          encap_fib_index = fib6_index_from_fib_id (tmp);
+        else
+          encap_fib_index = fib4_index_from_fib_id (tmp);
         if (encap_fib_index == ~0)
           return clib_error_return (0, "nonexistent encap-vrf-id %d", tmp);
       }
@@ -364,15 +483,25 @@ vxlan_add_del_tunnel_command_fn (vlib_main_t * vm,
   if (dst_set == 0)
     return clib_error_return (0, "tunnel dst address not specified");
 
+  if (ipv4_set && ipv6_set)
+    return clib_error_return (0, "both IPv4 and IPv6 addresses specified");
+
+  if ((ipv4_set && memcmp(&src.ip4, &dst.ip4, sizeof(src.ip4)) == 0) ||
+      (ipv6_set && memcmp(&src.ip6, &dst.ip6, sizeof(src.ip6)) == 0))
+    return clib_error_return (0, "src and dst addresses are identical");
+
   if (vni == 0)
     return clib_error_return (0, "vni not specified");
 
   memset (a, 0, sizeof (*a));
 
   a->is_add = is_add;
+  a->is_ip6 = ipv6_set;
 
 #define _(x) a->x = x;
   foreach_copy_field;
+  if (ipv4_set) foreach_copy_ipv4
+  else          foreach_copy_ipv6
 #undef _
   
   rv = vnet_vxlan_add_del_tunnel (a, 0 /* hw_if_indexp */);
@@ -430,27 +559,43 @@ VLIB_CLI_COMMAND (show_vxlan_tunnel_command, static) = {
     .function = show_vxlan_tunnel_command_fn,
 };
 
+
 clib_error_t *vxlan_init (vlib_main_t *vm)
 {
   vxlan_main_t * vxm = &vxlan_main;
-  ip4_vxlan_header_t * hdr;
-  ip4_header_t * ip;
+  ip4_vxlan_header_t * hdr4;
+  ip4_header_t * ip4;
+  ip6_vxlan_header_t * hdr6;
+  ip6_header_t * ip6;
   
   vxm->vnet_main = vnet_get_main();
   vxm->vlib_main = vm;
 
+  /* initialize the ip6 hash */
+  vxm->vxlan6_tunnel_by_key = hash_create_mem(0,
+        sizeof(vxlan6_tunnel_key_t),
+        sizeof(uword));
+
   /* init dummy rewrite string for deleted vxlan tunnels */
-  _vec_len(vxlan_dummy_rewrite) = sizeof(ip4_vxlan_header_t);
-  hdr = (ip4_vxlan_header_t *) vxlan_dummy_rewrite;
-  ip = &hdr->ip4;
+  _vec_len(vxlan4_dummy_rewrite) = sizeof(ip4_vxlan_header_t);
+  hdr4 = (ip4_vxlan_header_t *) vxlan4_dummy_rewrite;
+  ip4 = &hdr4->ip4;
   /* minimal rewrite setup, see vxlan_rewite() above as reference */
-  ip->ip_version_and_header_length = 0x45;
-  ip->checksum = ip4_header_checksum (ip);
+  ip4->ip_version_and_header_length = 0x45;
+  ip4->checksum = ip4_header_checksum (ip4);
+
+  /* Same again for IPv6 */
+  _vec_len(vxlan6_dummy_rewrite) = sizeof(ip6_vxlan_header_t);
+  hdr6 = (ip6_vxlan_header_t *) vxlan6_dummy_rewrite;
+  ip6 = &hdr6->ip6;
+  /* minimal rewrite setup, see vxlan_rewite() above as reference */
+  ip6->ip_version_traffic_class_and_flow_label = clib_host_to_net_u32(6 << 28);
  
   udp_register_dst_port (vm, UDP_DST_PORT_vxlan, 
-                         vxlan_input_node.index, 1 /* is_ip4 */);
+                         vxlan4_input_node.index, /* is_ip4 */ 1);
+  udp_register_dst_port (vm, UDP_DST_PORT_vxlan6,
+                         vxlan6_input_node.index, /* is_ip4 */ 0);
   return 0;
 }
 
 VLIB_INIT_FUNCTION(vxlan_init);
-