src/plugins/npt66/npt66_node.c

   1 // SPDX-License-Identifier: Apache-2.0
   2 // Copyright(c) 2023 Cisco Systems, Inc.
   3
   4 // This file contains the implementation of the NPT66 node.
   5 // RFC6296: IPv6-to-IPv6 Network Prefix Translation (NPTv6)
   6
   7 #include <vnet/ip/ip.h>
   8 #include <vnet/ip/ip6.h>
   9 #include <vnet/ip/ip6_packet.h>
  10
  11 #include <npt66/npt66.h>
  12
  13 typedef struct
  14 {
  15   u32 pool_index;
  16   ip6_address_t internal;
  17   ip6_address_t external;
  18 } npt66_trace_t;
  19
  20 static inline u8 *
  21 format_npt66_trace (u8 *s, va_list *args)
  22 {
  23   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  24   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  25   npt66_trace_t *t = va_arg (*args, npt66_trace_t *);
  26
  27   if (t->pool_index != ~0)
  28     s = format (s, "npt66: index %d internal: %U external: %U\n",
  29                 t->pool_index, format_ip6_address, &t->internal,
  30                 format_ip6_address, &t->external);
  31   else
  32     s = format (s, "npt66: index %d (binding not found)\n", t->pool_index);
  33   return s;
  34 }
  35
  36 /* NPT66 next-nodes */
  37 typedef enum
  38 {
  39   NPT66_NEXT_DROP,
  40   NPT66_N_NEXT
  41 } npt66_next_t;
  42
  43 static ip6_address_t
  44 ip6_prefix_copy (ip6_address_t dest, ip6_address_t src, int plen)
  45 {
  46   int bytes_to_copy = plen / 8;
  47   int residual_bits = plen % 8;
  48
  49   // Copy full bytes
  50   for (int i = 0; i < bytes_to_copy; i++)
  51     {
  52       dest.as_u8[i] = src.as_u8[i];
  53     }
  54
  55   // Handle the residual bits, if any
  56   if (residual_bits)
  57     {
  58       uint8_t mask = 0xFF << (8 - residual_bits);
  59       dest.as_u8[bytes_to_copy] = (dest.as_u8[bytes_to_copy] & ~mask) |
  60                                   (src.as_u8[bytes_to_copy] & mask);
  61     }
  62   return dest;
  63 }
  64 static int
  65 ip6_prefix_cmp (ip6_address_t a, ip6_address_t b, int plen)
  66 {
  67   int bytes_to_compare = plen / 8;
  68   int residual_bits = plen % 8;
  69
  70   // Compare full bytes
  71   for (int i = 0; i < bytes_to_compare; i++)
  72     {
  73       if (a.as_u8[i] != b.as_u8[i])
  74         {
  75           return 0; // prefixes are not identical
  76         }
  77     }
  78
  79   // Compare the residual bits, if any
  80   if (residual_bits)
  81     {
  82       uint8_t mask = 0xFF << (8 - residual_bits);
  83       if ((a.as_u8[bytes_to_compare] & mask) !=
  84           (b.as_u8[bytes_to_compare] & mask))
  85         {
  86           return 0; // prefixes are not identical
  87         }
  88     }
  89   return 1; // prefixes are identical
  90 }
  91
  92 static int
  93 npt66_adjust_checksum (int plen, bool add, ip_csum_t delta,
  94                        ip6_address_t *address)
  95 {
  96   if (plen <= 48)
  97     {
  98       // TODO: Check for 0xFFFF
  99       if (address->as_u16[3] == 0xffff)
 100         return -1;
 101       address->as_u16[3] = add ? ip_csum_add_even (address->as_u16[3], delta) :
 102                                        ip_csum_sub_even (address->as_u16[3], delta);
 103     }
 104   else
 105     {
 106       /* For prefixes longer than 48 find a 16-bit word in the interface id */
 107       for (int i = 4; i < 8; i++)
 108         {
 109           if (address->as_u16[i] == 0xffff)
 110             continue;
 111           address->as_u16[i] = add ?
 112                                        ip_csum_add_even (address->as_u16[i], delta) :
 113                                        ip_csum_sub_even (address->as_u16[i], delta);
 114           break;
 115         }
 116     }
 117   return 0;
 118 }
 119
 120 static int
 121 npt66_translate (ip6_header_t *ip, npt66_binding_t *binding, int dir)
 122 {
 123   int rv = 0;
 124   if (dir == VLIB_TX)
 125     {
 126       if (!ip6_prefix_cmp (ip->src_address, binding->internal,
 127                            binding->internal_plen))
 128         {
 129           clib_warning (
 130             "npt66_translate: src address is not internal (%U -> %U)",
 131             format_ip6_address, &ip->src_address, format_ip6_address,
 132             &ip->dst_address);
 133           goto done;
 134         }
 135       ip->src_address = ip6_prefix_copy (ip->src_address, binding->external,
 136                                          binding->external_plen);
 137       /* Checksum neutrality */
 138       rv = npt66_adjust_checksum (binding->internal_plen, false,
 139                                   binding->delta, &ip->src_address);
 140     }
 141   else
 142     {
 143       if (!ip6_prefix_cmp (ip->dst_address, binding->external,
 144                            binding->external_plen))
 145         {
 146           clib_warning (
 147             "npt66_translate: dst address is not external (%U -> %U)",
 148             format_ip6_address, &ip->src_address, format_ip6_address,
 149             &ip->dst_address);
 150           goto done;
 151         }
 152       ip->dst_address = ip6_prefix_copy (ip->dst_address, binding->internal,
 153                                          binding->internal_plen);
 154       rv = npt66_adjust_checksum (binding->internal_plen, true, binding->delta,
 155                                   &ip->dst_address);
 156     }
 157 done:
 158   return rv;
 159 }
 160
 161 /*
 162  * Lookup the packet tuple in the flow cache, given the lookup mask.
 163  * If a binding is found, rewrite the packet according to instructions,
 164  * otherwise follow configured default action (forward, punt or drop)
 165  */
 166 // TODO: Make use of SVR configurable
 167 static_always_inline uword
 168 npt66_node_inline (vlib_main_t *vm, vlib_node_runtime_t *node,
 169                    vlib_frame_t *frame, int dir)
 170 {
 171   npt66_main_t *nm = &npt66_main;
 172   u32 n_left_from, *from;
 173   u16 nexts[VLIB_FRAME_SIZE] = { 0 }, *next = nexts;
 174   u32 pool_indicies[VLIB_FRAME_SIZE], *pi = pool_indicies;
 175   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
 176   ip6_header_t *ip;
 177
 178   from = vlib_frame_vector_args (frame);
 179   n_left_from = frame->n_vectors;
 180   vlib_get_buffers (vm, from, b, n_left_from);
 181   npt66_binding_t *binding;
 182
 183   /* Stage 1: build vector of flow hash (based on lookup mask) */
 184   while (n_left_from > 0)
 185     {
 186       u32 sw_if_index = vnet_buffer (b[0])->sw_if_index[dir];
 187       u32 iph_offset =
 188         dir == VLIB_TX ? vnet_buffer (b[0])->ip.save_rewrite_length : 0;
 189       ip = (ip6_header_t *) (vlib_buffer_get_current (b[0]) + iph_offset);
 190       binding = npt66_interface_by_sw_if_index (sw_if_index);
 191       ASSERT (binding);
 192       *pi = binding - nm->bindings;
 193
 194       /* By default pass packet to next node in the feature chain */
 195       vnet_feature_next_u16 (next, b[0]);
 196
 197       int rv = npt66_translate (ip, binding, dir);
 198       if (rv < 0)
 199         {
 200           clib_warning ("npt66_translate failed");
 201           *next = NPT66_NEXT_DROP;
 202         }
 203
 204       /*next: */
 205       next += 1;
 206       n_left_from -= 1;
 207       b += 1;
 208       pi += 1;
 209     }
 210
 211   /* Packet trace */
 212   if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
 213     {
 214       u32 i;
 215       b = bufs;
 216       pi = pool_indicies;
 217
 218       for (i = 0; i < frame->n_vectors; i++)
 219         {
 220           if (b[0]->flags & VLIB_BUFFER_IS_TRACED)
 221             {
 222               npt66_trace_t *t = vlib_add_trace (vm, node, b[0], sizeof (*t));
 223               if (*pi != ~0)
 224                 {
 225                   if (!pool_is_free_index (nm->bindings, *pi))
 226                     {
 227                       npt66_binding_t *tr =
 228                         pool_elt_at_index (nm->bindings, *pi);
 229                       t->internal = tr->internal;
 230                       t->external = tr->external;
 231                     }
 232                 }
 233               t->pool_index = *pi;
 234
 235               b += 1;
 236               pi += 1;
 237             }
 238           else
 239             break;
 240         }
 241     }
 242   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
 243
 244   return frame->n_vectors;
 245 }
 246
 247 VLIB_NODE_FN (npt66_input_node)
 248 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
 249 {
 250   return npt66_node_inline (vm, node, frame, VLIB_RX);
 251 }
 252 VLIB_NODE_FN (npt66_output_node)
 253 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
 254 {
 255   return npt66_node_inline (vm, node, frame, VLIB_TX);
 256 }
 257
 258 VLIB_REGISTER_NODE(npt66_input_node) = {
 259     .name = "npt66-input",
 260     .vector_size = sizeof(u32),
 261     .format_trace = format_npt66_trace,
 262     .type = VLIB_NODE_TYPE_INTERNAL,
 263     // .n_errors = NPT66_N_ERROR,
 264     // .error_counters = npt66_error_counters,
 265     .n_next_nodes = NPT66_N_NEXT,
 266     .next_nodes =
 267         {
 268             [NPT66_NEXT_DROP] = "error-drop",
 269         },
 270 };
 271
 272 VLIB_REGISTER_NODE (npt66_output_node) = {
 273   .name = "npt66-output",
 274   .vector_size = sizeof (u32),
 275   .format_trace = format_npt66_trace,
 276   .type = VLIB_NODE_TYPE_INTERNAL,
 277   // .n_errors = npt66_N_ERROR,
 278   // .error_counters = npt66_error_counters,
 279   .sibling_of = "npt66-input",
 280 };
 281
 282 /* Hook up features */
 283 VNET_FEATURE_INIT (npt66_input, static) = {
 284   .arc_name = "ip6-unicast",
 285   .node_name = "npt66-input",
 286 };
 287 VNET_FEATURE_INIT (npt66_output, static) = {
 288   .arc_name = "ip6-output",
 289   .node_name = "npt66-output",
 290 };