src/vnet/map/ip4_map.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 /*
  16  * Defines used for testing various optimisation schemes
  17  */
  18 #define MAP_ENCAP_DUAL 0
  19
  20 #include "map.h"
  21 #include "../ip/ip_frag.h"
  22
  23 vlib_node_registration_t ip4_map_reass_node;
  24
  25 enum ip4_map_next_e
  26 {
  27   IP4_MAP_NEXT_IP6_LOOKUP,
  28 #ifdef MAP_SKIP_IP6_LOOKUP
  29   IP4_MAP_NEXT_IP6_REWRITE,
  30 #endif
  31   IP4_MAP_NEXT_IP4_FRAGMENT,
  32   IP4_MAP_NEXT_IP6_FRAGMENT,
  33   IP4_MAP_NEXT_REASS,
  34   IP4_MAP_NEXT_ICMP_ERROR,
  35   IP4_MAP_NEXT_DROP,
  36   IP4_MAP_N_NEXT,
  37 };
  38
  39 enum ip4_map_reass_next_t
  40 {
  41   IP4_MAP_REASS_NEXT_IP6_LOOKUP,
  42   IP4_MAP_REASS_NEXT_IP4_FRAGMENT,
  43   IP4_MAP_REASS_NEXT_DROP,
  44   IP4_MAP_REASS_N_NEXT,
  45 };
  46
  47 typedef struct
  48 {
  49   u32 map_domain_index;
  50   u16 port;
  51   u8 cached;
  52 } map_ip4_map_reass_trace_t;
  53
  54 u8 *
  55 format_ip4_map_reass_trace (u8 * s, va_list * args)
  56 {
  57   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  58   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  59   map_ip4_map_reass_trace_t *t = va_arg (*args, map_ip4_map_reass_trace_t *);
  60   return format (s, "MAP domain index: %d L4 port: %u Status: %s",
  61                  t->map_domain_index, t->port,
  62                  t->cached ? "cached" : "forwarded");
  63 }
  64
  65 /*
  66  * ip4_map_get_port
  67  */
  68 u16
  69 ip4_map_get_port (ip4_header_t * ip, map_dir_e dir)
  70 {
  71   /* Find port information */
  72   if (PREDICT_TRUE ((ip->protocol == IP_PROTOCOL_TCP) ||
  73                     (ip->protocol == IP_PROTOCOL_UDP)))
  74     {
  75       udp_header_t *udp = (void *) (ip + 1);
  76       return (dir == MAP_SENDER ? udp->src_port : udp->dst_port);
  77     }
  78   else if (ip->protocol == IP_PROTOCOL_ICMP)
  79     {
  80       /*
  81        * 1) ICMP Echo request or Echo reply
  82        * 2) ICMP Error with inner packet being UDP or TCP
  83        * 3) ICMP Error with inner packet being ICMP Echo request or Echo reply
  84        */
  85       icmp46_header_t *icmp = (void *) (ip + 1);
  86       if (icmp->type == ICMP4_echo_request || icmp->type == ICMP4_echo_reply)
  87         {
  88           return *((u16 *) (icmp + 1));
  89         }
  90       else if (clib_net_to_host_u16 (ip->length) >= 56)
  91         {                       // IP + ICMP + IP + L4 header
  92           ip4_header_t *icmp_ip = (ip4_header_t *) (icmp + 2);
  93           if (PREDICT_TRUE ((icmp_ip->protocol == IP_PROTOCOL_TCP) ||
  94                             (icmp_ip->protocol == IP_PROTOCOL_UDP)))
  95             {
  96               udp_header_t *udp = (void *) (icmp_ip + 1);
  97               return (dir == MAP_SENDER ? udp->dst_port : udp->src_port);
  98             }
  99           else if (icmp_ip->protocol == IP_PROTOCOL_ICMP)
 100             {
 101               icmp46_header_t *inner_icmp = (void *) (icmp_ip + 1);
 102               if (inner_icmp->type == ICMP4_echo_request
 103                   || inner_icmp->type == ICMP4_echo_reply)
 104                 return (*((u16 *) (inner_icmp + 1)));
 105             }
 106         }
 107     }
 108   return (0);
 109 }
 110
 111 static_always_inline u16
 112 ip4_map_port_and_security_check (map_domain_t * d, ip4_header_t * ip,
 113                                  u32 * next, u8 * error)
 114 {
 115   u16 port = 0;
 116
 117   if (d->psid_length > 0)
 118     {
 119       if (ip4_get_fragment_offset (ip) == 0)
 120         {
 121           if (PREDICT_FALSE
 122               ((ip->ip_version_and_header_length != 0x45)
 123                || clib_host_to_net_u16 (ip->length) < 28))
 124             {
 125               return 0;
 126             }
 127           port = ip4_map_get_port (ip, MAP_RECEIVER);
 128           if (port)
 129             {
 130               /* Verify that port is not among the well-known ports */
 131               if ((d->psid_offset > 0)
 132                   && (clib_net_to_host_u16 (port) <
 133                       (0x1 << (16 - d->psid_offset))))
 134                 {
 135                   *error = MAP_ERROR_ENCAP_SEC_CHECK;
 136                 }
 137               else
 138                 {
 139                   if (ip4_get_fragment_more (ip))
 140                     *next = IP4_MAP_NEXT_REASS;
 141                   return (port);
 142                 }
 143             }
 144           else
 145             {
 146               *error = MAP_ERROR_BAD_PROTOCOL;
 147             }
 148         }
 149       else
 150         {
 151           *next = IP4_MAP_NEXT_REASS;
 152         }
 153     }
 154   return (0);
 155 }
 156
 157 /*
 158  * ip4_map_vtcfl
 159  */
 160 static_always_inline u32
 161 ip4_map_vtcfl (ip4_header_t * ip4, vlib_buffer_t * p)
 162 {
 163   map_main_t *mm = &map_main;
 164   u8 tc = mm->tc_copy ? ip4->tos : mm->tc;
 165   u32 vtcfl = 0x6 << 28;
 166   vtcfl |= tc << 20;
 167   vtcfl |= vnet_buffer (p)->ip.flow_hash & 0x000fffff;
 168
 169   return (clib_host_to_net_u32 (vtcfl));
 170 }
 171
 172 static_always_inline bool
 173 ip4_map_ip6_lookup_bypass (vlib_buffer_t * p0, ip4_header_t * ip)
 174 {
 175 #ifdef MAP_SKIP_IP6_LOOKUP
 176   if (FIB_NODE_INDEX_INVALID != pre_resolved[FIB_PROTOCOL_IP6].fei)
 177     {
 178       vnet_buffer (p0)->ip.adj_index[VLIB_TX] =
 179         pre_resolved[FIB_PROTOCOL_IP6].dpo.dpoi_index;
 180       return (true);
 181     }
 182 #endif
 183   return (false);
 184 }
 185
 186 /*
 187  * ip4_map_ttl
 188  */
 189 static inline void
 190 ip4_map_decrement_ttl (ip4_header_t * ip, u8 * error)
 191 {
 192   i32 ttl = ip->ttl;
 193
 194   /* Input node should have reject packets with ttl 0. */
 195   ASSERT (ip->ttl > 0);
 196
 197   u32 checksum = ip->checksum + clib_host_to_net_u16 (0x0100);
 198   checksum += checksum >= 0xffff;
 199   ip->checksum = checksum;
 200   ttl -= 1;
 201   ip->ttl = ttl;
 202   *error = ttl <= 0 ? IP4_ERROR_TIME_EXPIRED : *error;
 203
 204   /* Verify checksum. */
 205   ASSERT (ip->checksum == ip4_header_checksum (ip));
 206 }
 207
 208 static u32
 209 ip4_map_fragment (vlib_buffer_t * b, u16 mtu, bool df, u8 * error)
 210 {
 211   map_main_t *mm = &map_main;
 212
 213   if (mm->frag_inner)
 214     {
 215       ip_frag_set_vnet_buffer (b, sizeof (ip6_header_t), mtu,
 216                                IP4_FRAG_NEXT_IP6_LOOKUP,
 217                                IP_FRAG_FLAG_IP6_HEADER);
 218       return (IP4_MAP_NEXT_IP4_FRAGMENT);
 219     }
 220   else
 221     {
 222       if (df && !mm->frag_ignore_df)
 223         {
 224           icmp4_error_set_vnet_buffer (b, ICMP4_destination_unreachable,
 225                                        ICMP4_destination_unreachable_fragmentation_needed_and_dont_fragment_set,
 226                                        mtu);
 227           vlib_buffer_advance (b, sizeof (ip6_header_t));
 228           *error = MAP_ERROR_DF_SET;
 229           return (IP4_MAP_NEXT_ICMP_ERROR);
 230         }
 231       ip_frag_set_vnet_buffer (b, 0, mtu, IP6_FRAG_NEXT_IP6_LOOKUP,
 232                                IP_FRAG_FLAG_IP6_HEADER);
 233       return (IP4_MAP_NEXT_IP6_FRAGMENT);
 234     }
 235 }
 236
 237 /*
 238  * ip4_map
 239  */
 240 static uword
 241 ip4_map (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 242 {
 243   u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
 244   vlib_node_runtime_t *error_node =
 245     vlib_node_get_runtime (vm, ip4_map_node.index);
 246   from = vlib_frame_vector_args (frame);
 247   n_left_from = frame->n_vectors;
 248   next_index = node->cached_next_index;
 249   map_main_t *mm = &map_main;
 250   vlib_combined_counter_main_t *cm = mm->domain_counters;
 251   u32 cpu_index = os_get_cpu_number ();
 252
 253   while (n_left_from > 0)
 254     {
 255       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 256
 257       /* Dual loop */
 258       while (n_left_from >= 4 && n_left_to_next >= 2)
 259         {
 260           u32 pi0, pi1;
 261           vlib_buffer_t *p0, *p1;
 262           map_domain_t *d0, *d1;
 263           u8 error0 = MAP_ERROR_NONE, error1 = MAP_ERROR_NONE;
 264           ip4_header_t *ip40, *ip41;
 265           u16 port0 = 0, port1 = 0;
 266           ip6_header_t *ip6h0, *ip6h1;
 267           u32 map_domain_index0 = ~0, map_domain_index1 = ~0;
 268           u32 next0 = IP4_MAP_NEXT_IP6_LOOKUP, next1 =
 269             IP4_MAP_NEXT_IP6_LOOKUP;
 270
 271           /* Prefetch next iteration. */
 272           {
 273             vlib_buffer_t *p2, *p3;
 274
 275             p2 = vlib_get_buffer (vm, from[2]);
 276             p3 = vlib_get_buffer (vm, from[3]);
 277
 278             vlib_prefetch_buffer_header (p2, STORE);
 279             vlib_prefetch_buffer_header (p3, STORE);
 280             /* IPv4 + 8 = 28. possibly plus -40 */
 281             CLIB_PREFETCH (p2->data - 40, 68, STORE);
 282             CLIB_PREFETCH (p3->data - 40, 68, STORE);
 283           }
 284
 285           pi0 = to_next[0] = from[0];
 286           pi1 = to_next[1] = from[1];
 287           from += 2;
 288           n_left_from -= 2;
 289           to_next += 2;
 290           n_left_to_next -= 2;
 291
 292           p0 = vlib_get_buffer (vm, pi0);
 293           p1 = vlib_get_buffer (vm, pi1);
 294           ip40 = vlib_buffer_get_current (p0);
 295           ip41 = vlib_buffer_get_current (p1);
 296           d0 =
 297             ip4_map_get_domain (vnet_buffer (p0)->ip.adj_index[VLIB_TX],
 298                                 &map_domain_index0);
 299           d1 =
 300             ip4_map_get_domain (vnet_buffer (p1)->ip.adj_index[VLIB_TX],
 301                                 &map_domain_index1);
 302           ASSERT (d0);
 303           ASSERT (d1);
 304
 305           /*
 306            * Shared IPv4 address
 307            */
 308           port0 = ip4_map_port_and_security_check (d0, ip40, &next0, &error0);
 309           port1 = ip4_map_port_and_security_check (d1, ip41, &next1, &error1);
 310
 311           /* Decrement IPv4 TTL */
 312           ip4_map_decrement_ttl (ip40, &error0);
 313           ip4_map_decrement_ttl (ip41, &error1);
 314           bool df0 =
 315             ip40->flags_and_fragment_offset &
 316             clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT);
 317           bool df1 =
 318             ip41->flags_and_fragment_offset &
 319             clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT);
 320
 321           /* MAP calc */
 322           u32 da40 = clib_net_to_host_u32 (ip40->dst_address.as_u32);
 323           u32 da41 = clib_net_to_host_u32 (ip41->dst_address.as_u32);
 324           u16 dp40 = clib_net_to_host_u16 (port0);
 325           u16 dp41 = clib_net_to_host_u16 (port1);
 326           u64 dal60 = map_get_pfx (d0, da40, dp40);
 327           u64 dal61 = map_get_pfx (d1, da41, dp41);
 328           u64 dar60 = map_get_sfx (d0, da40, dp40);
 329           u64 dar61 = map_get_sfx (d1, da41, dp41);
 330           if (dal60 == 0 && dar60 == 0 && error0 == MAP_ERROR_NONE
 331               && next0 != IP4_MAP_NEXT_REASS)
 332             error0 = MAP_ERROR_NO_BINDING;
 333           if (dal61 == 0 && dar61 == 0 && error1 == MAP_ERROR_NONE
 334               && next1 != IP4_MAP_NEXT_REASS)
 335             error1 = MAP_ERROR_NO_BINDING;
 336
 337           /* construct ipv6 header */
 338           vlib_buffer_advance (p0, -sizeof (ip6_header_t));
 339           vlib_buffer_advance (p1, -sizeof (ip6_header_t));
 340           ip6h0 = vlib_buffer_get_current (p0);
 341           ip6h1 = vlib_buffer_get_current (p1);
 342           vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
 343           vnet_buffer (p1)->sw_if_index[VLIB_TX] = (u32) ~ 0;
 344
 345           ip6h0->ip_version_traffic_class_and_flow_label =
 346             ip4_map_vtcfl (ip40, p0);
 347           ip6h1->ip_version_traffic_class_and_flow_label =
 348             ip4_map_vtcfl (ip41, p1);
 349           ip6h0->payload_length = ip40->length;
 350           ip6h1->payload_length = ip41->length;
 351           ip6h0->protocol = IP_PROTOCOL_IP_IN_IP;
 352           ip6h1->protocol = IP_PROTOCOL_IP_IN_IP;
 353           ip6h0->hop_limit = 0x40;
 354           ip6h1->hop_limit = 0x40;
 355           ip6h0->src_address = d0->ip6_src;
 356           ip6h1->src_address = d1->ip6_src;
 357           ip6h0->dst_address.as_u64[0] = clib_host_to_net_u64 (dal60);
 358           ip6h0->dst_address.as_u64[1] = clib_host_to_net_u64 (dar60);
 359           ip6h1->dst_address.as_u64[0] = clib_host_to_net_u64 (dal61);
 360           ip6h1->dst_address.as_u64[1] = clib_host_to_net_u64 (dar61);
 361
 362           /*
 363            * Determine next node. Can be one of:
 364            * ip6-lookup, ip6-rewrite, ip4-fragment, ip4-virtreass, error-drop
 365            */
 366           if (PREDICT_TRUE (error0 == MAP_ERROR_NONE))
 367             {
 368               if (PREDICT_FALSE
 369                   (d0->mtu
 370                    && (clib_net_to_host_u16 (ip6h0->payload_length) +
 371                        sizeof (*ip6h0) > d0->mtu)))
 372                 {
 373                   next0 = ip4_map_fragment (p0, d0->mtu, df0, &error0);
 374                 }
 375               else
 376                 {
 377                   next0 =
 378                     ip4_map_ip6_lookup_bypass (p0,
 379                                                ip40) ?
 380                     IP4_MAP_NEXT_IP6_REWRITE : next0;
 381                   vlib_increment_combined_counter (cm + MAP_DOMAIN_COUNTER_TX,
 382                                                    cpu_index,
 383                                                    map_domain_index0, 1,
 384                                                    clib_net_to_host_u16
 385                                                    (ip6h0->payload_length) +
 386                                                    40);
 387                 }
 388             }
 389           else
 390             {
 391               next0 = IP4_MAP_NEXT_DROP;
 392             }
 393
 394           /*
 395            * Determine next node. Can be one of:
 396            * ip6-lookup, ip6-rewrite, ip4-fragment, ip4-virtreass, error-drop
 397            */
 398           if (PREDICT_TRUE (error1 == MAP_ERROR_NONE))
 399             {
 400               if (PREDICT_FALSE
 401                   (d1->mtu
 402                    && (clib_net_to_host_u16 (ip6h1->payload_length) +
 403                        sizeof (*ip6h1) > d1->mtu)))
 404                 {
 405                   next1 = ip4_map_fragment (p1, d1->mtu, df1, &error1);
 406                 }
 407               else
 408                 {
 409                   next1 =
 410                     ip4_map_ip6_lookup_bypass (p1,
 411                                                ip41) ?
 412                     IP4_MAP_NEXT_IP6_REWRITE : next1;
 413                   vlib_increment_combined_counter (cm + MAP_DOMAIN_COUNTER_TX,
 414                                                    cpu_index,
 415                                                    map_domain_index1, 1,
 416                                                    clib_net_to_host_u16
 417                                                    (ip6h1->payload_length) +
 418                                                    40);
 419                 }
 420             }
 421           else
 422             {
 423               next1 = IP4_MAP_NEXT_DROP;
 424             }
 425
 426           if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
 427             {
 428               map_trace_t *tr = vlib_add_trace (vm, node, p0, sizeof (*tr));
 429               tr->map_domain_index = map_domain_index0;
 430               tr->port = port0;
 431             }
 432           if (PREDICT_FALSE (p1->flags & VLIB_BUFFER_IS_TRACED))
 433             {
 434               map_trace_t *tr = vlib_add_trace (vm, node, p1, sizeof (*tr));
 435               tr->map_domain_index = map_domain_index1;
 436               tr->port = port1;
 437             }
 438
 439           p0->error = error_node->errors[error0];
 440           p1->error = error_node->errors[error1];
 441
 442           vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
 443                                            n_left_to_next, pi0, pi1, next0,
 444                                            next1);
 445         }
 446
 447       while (n_left_from > 0 && n_left_to_next > 0)
 448         {
 449           u32 pi0;
 450           vlib_buffer_t *p0;
 451           map_domain_t *d0;
 452           u8 error0 = MAP_ERROR_NONE;
 453           ip4_header_t *ip40;
 454           u16 port0 = 0;
 455           ip6_header_t *ip6h0;
 456           u32 next0 = IP4_MAP_NEXT_IP6_LOOKUP;
 457           u32 map_domain_index0 = ~0;
 458
 459           pi0 = to_next[0] = from[0];
 460           from += 1;
 461           n_left_from -= 1;
 462           to_next += 1;
 463           n_left_to_next -= 1;
 464
 465           p0 = vlib_get_buffer (vm, pi0);
 466           ip40 = vlib_buffer_get_current (p0);
 467           d0 =
 468             ip4_map_get_domain (vnet_buffer (p0)->ip.adj_index[VLIB_TX],
 469                                 &map_domain_index0);
 470           ASSERT (d0);
 471
 472           /*
 473            * Shared IPv4 address
 474            */
 475           port0 = ip4_map_port_and_security_check (d0, ip40, &next0, &error0);
 476
 477           /* Decrement IPv4 TTL */
 478           ip4_map_decrement_ttl (ip40, &error0);
 479           bool df0 =
 480             ip40->flags_and_fragment_offset &
 481             clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT);
 482
 483           /* MAP calc */
 484           u32 da40 = clib_net_to_host_u32 (ip40->dst_address.as_u32);
 485           u16 dp40 = clib_net_to_host_u16 (port0);
 486           u64 dal60 = map_get_pfx (d0, da40, dp40);
 487           u64 dar60 = map_get_sfx (d0, da40, dp40);
 488           if (dal60 == 0 && dar60 == 0 && error0 == MAP_ERROR_NONE
 489               && next0 != IP4_MAP_NEXT_REASS)
 490             error0 = MAP_ERROR_NO_BINDING;
 491
 492           /* construct ipv6 header */
 493           vlib_buffer_advance (p0, -(sizeof (ip6_header_t)));
 494           ip6h0 = vlib_buffer_get_current (p0);
 495           vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
 496
 497           ip6h0->ip_version_traffic_class_and_flow_label =
 498             ip4_map_vtcfl (ip40, p0);
 499           ip6h0->payload_length = ip40->length;
 500           ip6h0->protocol = IP_PROTOCOL_IP_IN_IP;
 501           ip6h0->hop_limit = 0x40;
 502           ip6h0->src_address = d0->ip6_src;
 503           ip6h0->dst_address.as_u64[0] = clib_host_to_net_u64 (dal60);
 504           ip6h0->dst_address.as_u64[1] = clib_host_to_net_u64 (dar60);
 505
 506           /*
 507            * Determine next node. Can be one of:
 508            * ip6-lookup, ip6-rewrite, ip4-fragment, ip4-virtreass, error-drop
 509            */
 510           if (PREDICT_TRUE (error0 == MAP_ERROR_NONE))
 511             {
 512               if (PREDICT_FALSE
 513                   (d0->mtu
 514                    && (clib_net_to_host_u16 (ip6h0->payload_length) +
 515                        sizeof (*ip6h0) > d0->mtu)))
 516                 {
 517                   next0 = ip4_map_fragment (p0, d0->mtu, df0, &error0);
 518                 }
 519               else
 520                 {
 521                   next0 =
 522                     ip4_map_ip6_lookup_bypass (p0,
 523                                                ip40) ?
 524                     IP4_MAP_NEXT_IP6_REWRITE : next0;
 525                   vlib_increment_combined_counter (cm + MAP_DOMAIN_COUNTER_TX,
 526                                                    cpu_index,
 527                                                    map_domain_index0, 1,
 528                                                    clib_net_to_host_u16
 529                                                    (ip6h0->payload_length) +
 530                                                    40);
 531                 }
 532             }
 533           else
 534             {
 535               next0 = IP4_MAP_NEXT_DROP;
 536             }
 537
 538           if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
 539             {
 540               map_trace_t *tr = vlib_add_trace (vm, node, p0, sizeof (*tr));
 541               tr->map_domain_index = map_domain_index0;
 542               tr->port = port0;
 543             }
 544
 545           p0->error = error_node->errors[error0];
 546           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 547                                            n_left_to_next, pi0, next0);
 548         }
 549       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 550     }
 551
 552   return frame->n_vectors;
 553 }
 554
 555 /*
 556  * ip4_map_reass
 557  */
 558 static uword
 559 ip4_map_reass (vlib_main_t * vm,
 560                vlib_node_runtime_t * node, vlib_frame_t * frame)
 561 {
 562   u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
 563   vlib_node_runtime_t *error_node =
 564     vlib_node_get_runtime (vm, ip4_map_reass_node.index);
 565   from = vlib_frame_vector_args (frame);
 566   n_left_from = frame->n_vectors;
 567   next_index = node->cached_next_index;
 568   map_main_t *mm = &map_main;
 569   vlib_combined_counter_main_t *cm = mm->domain_counters;
 570   u32 cpu_index = os_get_cpu_number ();
 571   u32 *fragments_to_drop = NULL;
 572   u32 *fragments_to_loopback = NULL;
 573
 574   while (n_left_from > 0)
 575     {
 576       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 577
 578       while (n_left_from > 0 && n_left_to_next > 0)
 579         {
 580           u32 pi0;
 581           vlib_buffer_t *p0;
 582           map_domain_t *d0;
 583           u8 error0 = MAP_ERROR_NONE;
 584           ip4_header_t *ip40;
 585           i32 port0 = 0;
 586           ip6_header_t *ip60;
 587           u32 next0 = IP4_MAP_REASS_NEXT_IP6_LOOKUP;
 588           u32 map_domain_index0;
 589           u8 cached = 0;
 590
 591           pi0 = to_next[0] = from[0];
 592           from += 1;
 593           n_left_from -= 1;
 594           to_next += 1;
 595           n_left_to_next -= 1;
 596
 597           p0 = vlib_get_buffer (vm, pi0);
 598           ip60 = vlib_buffer_get_current (p0);
 599           ip40 = (ip4_header_t *) (ip60 + 1);
 600           d0 =
 601             ip4_map_get_domain (vnet_buffer (p0)->ip.adj_index[VLIB_TX],
 602                                 &map_domain_index0);
 603
 604           map_ip4_reass_lock ();
 605           map_ip4_reass_t *r = map_ip4_reass_get (ip40->src_address.as_u32,
 606                                                   ip40->dst_address.as_u32,
 607                                                   ip40->fragment_id,
 608                                                   ip40->protocol,
 609                                                   &fragments_to_drop);
 610           if (PREDICT_FALSE (!r))
 611             {
 612               // Could not create a caching entry
 613               error0 = MAP_ERROR_FRAGMENT_MEMORY;
 614             }
 615           else if (PREDICT_TRUE (ip4_get_fragment_offset (ip40)))
 616             {
 617               if (r->port >= 0)
 618                 {
 619                   // We know the port already
 620                   port0 = r->port;
 621                 }
 622               else if (map_ip4_reass_add_fragment (r, pi0))
 623                 {
 624                   // Not enough space for caching
 625                   error0 = MAP_ERROR_FRAGMENT_MEMORY;
 626                   map_ip4_reass_free (r, &fragments_to_drop);
 627                 }
 628               else
 629                 {
 630                   cached = 1;
 631                 }
 632             }
 633           else
 634             if ((port0 =
 635                  ip4_get_port (ip40, MAP_RECEIVER, p0->current_length)) < 0)
 636             {
 637               // Could not find port. We'll free the reassembly.
 638               error0 = MAP_ERROR_BAD_PROTOCOL;
 639               port0 = 0;
 640               map_ip4_reass_free (r, &fragments_to_drop);
 641             }
 642           else
 643             {
 644               r->port = port0;
 645               map_ip4_reass_get_fragments (r, &fragments_to_loopback);
 646             }
 647
 648 #ifdef MAP_IP4_REASS_COUNT_BYTES
 649           if (!cached && r)
 650             {
 651               r->forwarded += clib_host_to_net_u16 (ip40->length) - 20;
 652               if (!ip4_get_fragment_more (ip40))
 653                 r->expected_total =
 654                   ip4_get_fragment_offset (ip40) * 8 +
 655                   clib_host_to_net_u16 (ip40->length) - 20;
 656               if (r->forwarded >= r->expected_total)
 657                 map_ip4_reass_free (r, &fragments_to_drop);
 658             }
 659 #endif
 660
 661           map_ip4_reass_unlock ();
 662
 663           // NOTE: Most operations have already been performed by ip4_map
 664           // All we need is the right destination address
 665           ip60->dst_address.as_u64[0] =
 666             map_get_pfx_net (d0, ip40->dst_address.as_u32, port0);
 667           ip60->dst_address.as_u64[1] =
 668             map_get_sfx_net (d0, ip40->dst_address.as_u32, port0);
 669
 670           if (PREDICT_FALSE
 671               (d0->mtu
 672                && (clib_net_to_host_u16 (ip60->payload_length) +
 673                    sizeof (*ip60) > d0->mtu)))
 674             {
 675               vnet_buffer (p0)->ip_frag.header_offset = sizeof (*ip60);
 676               vnet_buffer (p0)->ip_frag.next_index = IP4_FRAG_NEXT_IP6_LOOKUP;
 677               vnet_buffer (p0)->ip_frag.mtu = d0->mtu;
 678               vnet_buffer (p0)->ip_frag.flags = IP_FRAG_FLAG_IP6_HEADER;
 679               next0 = IP4_MAP_REASS_NEXT_IP4_FRAGMENT;
 680             }
 681
 682           if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
 683             {
 684               map_ip4_map_reass_trace_t *tr =
 685                 vlib_add_trace (vm, node, p0, sizeof (*tr));
 686               tr->map_domain_index = map_domain_index0;
 687               tr->port = port0;
 688               tr->cached = cached;
 689             }
 690
 691           if (cached)
 692             {
 693               //Dequeue the packet
 694               n_left_to_next++;
 695               to_next--;
 696             }
 697           else
 698             {
 699               if (error0 == MAP_ERROR_NONE)
 700                 vlib_increment_combined_counter (cm + MAP_DOMAIN_COUNTER_TX,
 701                                                  cpu_index, map_domain_index0,
 702                                                  1,
 703                                                  clib_net_to_host_u16
 704                                                  (ip60->payload_length) + 40);
 705               next0 =
 706                 (error0 == MAP_ERROR_NONE) ? next0 : IP4_MAP_REASS_NEXT_DROP;
 707               p0->error = error_node->errors[error0];
 708               vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 709                                                n_left_to_next, pi0, next0);
 710             }
 711
 712           //Loopback when we reach the end of the inpu vector
 713           if (n_left_from == 0 && vec_len (fragments_to_loopback))
 714             {
 715               from = vlib_frame_vector_args (frame);
 716               u32 len = vec_len (fragments_to_loopback);
 717               if (len <= VLIB_FRAME_SIZE)
 718                 {
 719                   clib_memcpy (from, fragments_to_loopback,
 720                                sizeof (u32) * len);
 721                   n_left_from = len;
 722                   vec_reset_length (fragments_to_loopback);
 723                 }
 724               else
 725                 {
 726                   clib_memcpy (from,
 727                                fragments_to_loopback + (len -
 728                                                         VLIB_FRAME_SIZE),
 729                                sizeof (u32) * VLIB_FRAME_SIZE);
 730                   n_left_from = VLIB_FRAME_SIZE;
 731                   _vec_len (fragments_to_loopback) = len - VLIB_FRAME_SIZE;
 732                 }
 733             }
 734         }
 735       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 736     }
 737
 738   map_send_all_to_node (vm, fragments_to_drop, node,
 739                         &error_node->errors[MAP_ERROR_FRAGMENT_DROPPED],
 740                         IP4_MAP_REASS_NEXT_DROP);
 741
 742   vec_free (fragments_to_drop);
 743   vec_free (fragments_to_loopback);
 744   return frame->n_vectors;
 745 }
 746
 747 static char *map_error_strings[] = {
 748 #define _(sym,string) string,
 749   foreach_map_error
 750 #undef _
 751 };
 752
 753 /* *INDENT-OFF* */
 754 VLIB_REGISTER_NODE(ip4_map_node) = {
 755   .function = ip4_map,
 756   .name = "ip4-map",
 757   .vector_size = sizeof(u32),
 758   .format_trace = format_map_trace,
 759   .type = VLIB_NODE_TYPE_INTERNAL,
 760
 761   .n_errors = MAP_N_ERROR,
 762   .error_strings = map_error_strings,
 763
 764   .n_next_nodes = IP4_MAP_N_NEXT,
 765   .next_nodes = {
 766     [IP4_MAP_NEXT_IP6_LOOKUP] = "ip6-lookup",
 767 #ifdef MAP_SKIP_IP6_LOOKUP
 768     [IP4_MAP_NEXT_IP6_REWRITE] = "ip6-load-balance",
 769 #endif
 770     [IP4_MAP_NEXT_IP4_FRAGMENT] = "ip4-frag",
 771     [IP4_MAP_NEXT_IP6_FRAGMENT] = "ip6-frag",
 772     [IP4_MAP_NEXT_REASS] = "ip4-map-reass",
 773     [IP4_MAP_NEXT_ICMP_ERROR] = "ip4-icmp-error",
 774     [IP4_MAP_NEXT_DROP] = "error-drop",
 775   },
 776 };
 777 /* *INDENT-ON* */
 778
 779 /* *INDENT-OFF* */
 780 VLIB_REGISTER_NODE(ip4_map_reass_node) = {
 781   .function = ip4_map_reass,
 782   .name = "ip4-map-reass",
 783   .vector_size = sizeof(u32),
 784   .format_trace = format_ip4_map_reass_trace,
 785   .type = VLIB_NODE_TYPE_INTERNAL,
 786
 787   .n_errors = MAP_N_ERROR,
 788   .error_strings = map_error_strings,
 789
 790   .n_next_nodes = IP4_MAP_REASS_N_NEXT,
 791   .next_nodes = {
 792     [IP4_MAP_REASS_NEXT_IP6_LOOKUP] = "ip6-lookup",
 793     [IP4_MAP_REASS_NEXT_IP4_FRAGMENT] = "ip4-frag",
 794     [IP4_MAP_REASS_NEXT_DROP] = "error-drop",
 795   },
 796 };
 797 /* *INDENT-ON* */
 798
 799 /*
 800  * fd.io coding-style-patch-verification: ON
 801  *
 802  * Local Variables:
 803  * eval: (c-set-style "gnu")
 804  * End:
 805  */