L2 over MPLS

[vpp.git] / src / vnet / ip / ip4_forward.c

diff --git a/src/vnet/ip/ip4_forward.c b/src/vnet/ip/ip4_forward.c
index f4ecc39..7a8d7a0 100755 (executable)
--- a/src/vnet/ip/ip4_forward.c
+++ b/src/vnet/ip/ip4_forward.c
@@ -724,7 +724,7 @@ ip4_add_interface_routes (u32 sw_if_index,
                                        FIB_SOURCE_INTERFACE,
                                        (FIB_ENTRY_FLAG_CONNECTED |
                                         FIB_ENTRY_FLAG_ATTACHED),
-                                       FIB_PROTOCOL_IP4,
+                                       DPO_PROTO_IP4,
                                        /* No next-hop address */
                                        NULL,
                                        sw_if_index,
@@ -767,7 +767,7 @@ ip4_add_interface_routes (u32 sw_if_index,
       fib_table_entry_update_one_path (fib_index, &net_pfx,
                                        FIB_SOURCE_INTERFACE,
                                        (FIB_ENTRY_FLAG_ATTACHED),
-                                       FIB_PROTOCOL_IP4,
+                                       DPO_PROTO_IP4,
                                        &net_pfx.fp_addr,
                                        sw_if_index,
                                        // invalid FIB index
@@ -803,7 +803,7 @@ ip4_add_interface_routes (u32 sw_if_index,
                                    FIB_SOURCE_INTERFACE,
                                    (FIB_ENTRY_FLAG_CONNECTED |
                                     FIB_ENTRY_FLAG_LOCAL),
-                                   FIB_PROTOCOL_IP4,
+                                   DPO_PROTO_IP4,
                                    &pfx.fp_addr,
                                    sw_if_index,
                                    // invalid FIB index
@@ -898,6 +898,13 @@ ip4_add_del_interface_address_internal (vlib_main_t * vm,
   u32 if_address_index, elts_before;
   ip4_address_fib_t ip4_af, *addr_fib = 0;
 
+  /* local0 interface doesn't support IP addressing  */
+  if (sw_if_index == 0)
+    {
+      return
+       clib_error_create ("local0 interface doesn't support IP addressing");
+    }
+
   vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
   ip4_addr_fib_init (&ip4_af, address,
                     vec_elt (im->fib_index_by_sw_if_index, sw_if_index));
@@ -1136,6 +1143,23 @@ ip4_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
   vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
   vec_validate (im->mfib_index_by_sw_if_index, sw_if_index);
 
+  if (!is_add)
+    {
+      ip4_main_t *im4 = &ip4_main;
+      ip_lookup_main_t *lm4 = &im4->lookup_main;
+      ip_interface_address_t *ia = 0;
+      ip4_address_t *address;
+      vlib_main_t *vm = vlib_get_main ();
+
+      /* *INDENT-OFF* */
+      foreach_ip_interface_address (lm4, ia, sw_if_index, 1 /* honor unnumbered */,
+      ({
+        address = ip_interface_address_get_address (lm4, ia);
+        ip4_add_del_interface_address(vm, sw_if_index, address, ia->address_length, 1);
+      }));
+      /* *INDENT-ON* */
+    }
+
   vnet_feature_enable_disable ("ip4-unicast", "ip4-drop", sw_if_index,
                               is_add, 0, 0);
 
@@ -1492,15 +1516,15 @@ ip4_tcp_udp_validate_checksum (vlib_main_t * vm, vlib_buffer_t * p0)
   udp0 = (void *) (ip0 + 1);
   if (ip0->protocol == IP_PROTOCOL_UDP && udp0->checksum == 0)
     {
-      p0->flags |= (IP_BUFFER_L4_CHECKSUM_COMPUTED
-                   | IP_BUFFER_L4_CHECKSUM_CORRECT);
+      p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
+                   | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
       return p0->flags;
     }
 
   sum16 = ip4_tcp_udp_compute_checksum (vm, p0, ip0);
 
-  p0->flags |= (IP_BUFFER_L4_CHECKSUM_COMPUTED
-               | ((sum16 == 0) << LOG2_IP_BUFFER_L4_CHECKSUM_CORRECT));
+  p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
+               | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
 
   return p0->flags;
 }
@@ -1568,8 +1592,8 @@ ip4_local_inline (vlib_main_t * vm,
          ip0 = vlib_buffer_get_current (p0);
          ip1 = vlib_buffer_get_current (p1);
 
-         vnet_buffer (p0)->ip.start_of_ip_header = p0->current_data;
-         vnet_buffer (p1)->ip.start_of_ip_header = p1->current_data;
+         vnet_buffer (p0)->l3_hdr_offset = p0->current_data;
+         vnet_buffer (p1)->l3_hdr_offset = p1->current_data;
 
          sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
          sw_if_index1 = vnet_buffer (p1)->sw_if_index[VLIB_RX];
@@ -1612,8 +1636,8 @@ ip4_local_inline (vlib_main_t * vm,
          flags0 = p0->flags;
          flags1 = p1->flags;
 
-         good_tcp_udp0 = (flags0 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
-         good_tcp_udp1 = (flags1 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
+         good_tcp_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
+         good_tcp_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 
          udp0 = ip4_next_header (ip0);
          udp1 = ip4_next_header (ip1);
@@ -1640,19 +1664,19 @@ ip4_local_inline (vlib_main_t * vm,
              if (is_tcp_udp0)
                {
                  if (is_tcp_udp0
-                     && !(flags0 & IP_BUFFER_L4_CHECKSUM_COMPUTED))
+                     && !(flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED))
                    flags0 = ip4_tcp_udp_validate_checksum (vm, p0);
                  good_tcp_udp0 =
-                   (flags0 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
+                   (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
                  good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
                }
              if (is_tcp_udp1)
                {
                  if (is_tcp_udp1
-                     && !(flags1 & IP_BUFFER_L4_CHECKSUM_COMPUTED))
+                     && !(flags1 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED))
                    flags1 = ip4_tcp_udp_validate_checksum (vm, p1);
                  good_tcp_udp1 =
-                   (flags1 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
+                   (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
                  good_tcp_udp1 |= is_udp1 && udp1->checksum == 0;
                }
            }
@@ -1771,7 +1795,7 @@ ip4_local_inline (vlib_main_t * vm,
 
          ip0 = vlib_buffer_get_current (p0);
 
-         vnet_buffer (p0)->ip.start_of_ip_header = p0->current_data;
+         vnet_buffer (p0)->l3_hdr_offset = p0->current_data;
 
          sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
 
@@ -1800,7 +1824,7 @@ ip4_local_inline (vlib_main_t * vm,
 
          flags0 = p0->flags;
 
-         good_tcp_udp0 = (flags0 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
+         good_tcp_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 
          udp0 = ip4_next_header (ip0);
 
@@ -1820,10 +1844,10 @@ ip4_local_inline (vlib_main_t * vm,
              if (is_tcp_udp0)
                {
                  if (is_tcp_udp0
-                     && !(flags0 & IP_BUFFER_L4_CHECKSUM_COMPUTED))
+                     && !(flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED))
                    flags0 = ip4_tcp_udp_validate_checksum (vm, p0);
                  good_tcp_udp0 =
-                   (flags0 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
+                   (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
                  good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
                }
            }
@@ -2302,6 +2326,13 @@ ip4_probe_neighbor (vlib_main_t * vm, ip4_address_t * dst, u32 sw_if_index)
                                       &bi);
 
   hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
+  if (PREDICT_FALSE (!hi->hw_address))
+    {
+      return clib_error_return (0, "%U: interface %U do not support ip probe",
+                               format_ip4_address, dst,
+                               format_vnet_sw_if_index_name, vnm,
+                               sw_if_index);
+    }
 
   clib_memcpy (h->ip4_over_ethernet[0].ethernet, hi->hw_address,
               sizeof (h->ip4_over_ethernet[0].ethernet));
@@ -2411,7 +2442,7 @@ ip4_rewrite_inline (vlib_main_t * vm,
 
          /* Decrement TTL & update checksum.
             Works either endian, so no need for byte swap. */
-         if (PREDICT_TRUE (!(p0->flags & VNET_BUFFER_LOCALLY_ORIGINATED)))
+         if (PREDICT_TRUE (!(p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED)))
            {
              i32 ttl0 = ip0->ttl;
 
@@ -2440,13 +2471,14 @@ ip4_rewrite_inline (vlib_main_t * vm,
                }
 
              /* Verify checksum. */
-             ASSERT (ip0->checksum == ip4_header_checksum (ip0));
+             ASSERT ((ip0->checksum == ip4_header_checksum (ip0)) ||
+                     (p0->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
            }
          else
            {
-             p0->flags &= ~VNET_BUFFER_LOCALLY_ORIGINATED;
+             p0->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
            }
-         if (PREDICT_TRUE (!(p1->flags & VNET_BUFFER_LOCALLY_ORIGINATED)))
+         if (PREDICT_TRUE (!(p1->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED)))
            {
              i32 ttl1 = ip1->ttl;
 
@@ -2475,11 +2507,12 @@ ip4_rewrite_inline (vlib_main_t * vm,
                }
 
              /* Verify checksum. */
-             ASSERT (ip1->checksum == ip4_header_checksum (ip1));
+             ASSERT ((ip1->checksum == ip4_header_checksum (ip1)) ||
+                     (p1->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
            }
          else
            {
-             p1->flags &= ~VNET_BUFFER_LOCALLY_ORIGINATED;
+             p1->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
            }
 
          /* Rewrite packet header and updates lengths. */
@@ -2597,7 +2630,7 @@ ip4_rewrite_inline (vlib_main_t * vm,
          next0 = IP4_REWRITE_NEXT_DROP;        /* drop on error */
 
          /* Decrement TTL & update checksum. */
-         if (PREDICT_TRUE (!(p0->flags & VNET_BUFFER_LOCALLY_ORIGINATED)))
+         if (PREDICT_TRUE (!(p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED)))
            {
              i32 ttl0 = ip0->ttl;
 
@@ -2613,7 +2646,8 @@ ip4_rewrite_inline (vlib_main_t * vm,
 
              ip0->ttl = ttl0;
 
-             ASSERT (ip0->checksum == ip4_header_checksum (ip0));
+             ASSERT ((ip0->checksum == ip4_header_checksum (ip0)) ||
+                     (p0->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
 
              if (PREDICT_FALSE (ttl0 <= 0))
                {
@@ -2631,7 +2665,7 @@ ip4_rewrite_inline (vlib_main_t * vm,
            }
          else
            {
-             p0->flags &= ~VNET_BUFFER_LOCALLY_ORIGINATED;
+             p0->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
            }
 
          if (do_counters)