src/vnet/ip/ip6_forward.c

   1 /*
   2  * Copyright (c) 2016 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  * ip/ip6_forward.c: IP v6 forwarding
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #include <vnet/vnet.h>
  41 #include <vnet/ip/ip.h>
  42 #include <vnet/ip/ip_frag.h>
  43 #include <vnet/ip/ip6_link.h>
  44 #include <vnet/ethernet/ethernet.h>     /* for ethernet_header_t */
  45 #include <vnet/srp/srp.h>       /* for srp_hw_interface_class */
  46 #include <vppinfra/cache.h>
  47 #include <vnet/fib/fib_urpf_list.h>     /* for FIB uRPF check */
  48 #include <vnet/fib/ip6_fib.h>
  49 #include <vnet/mfib/ip6_mfib.h>
  50 #include <vnet/dpo/load_balance_map.h>
  51 #include <vnet/dpo/classify_dpo.h>
  52 #include <vnet/classify/vnet_classify.h>
  53
  54 #ifndef CLIB_MARCH_VARIANT
  55 #include <vppinfra/bihash_template.c>
  56 #endif
  57 #include <vnet/ip/ip6_forward.h>
  58 #include <vnet/ipsec/ipsec_tun.h>
  59 #include <vnet/interface_output.h>
  60
  61 /* Flag used by IOAM code. Classifier sets it pop-hop-by-hop checks it */
  62 #define OI_DECAP   0x80000000
  63
  64 static void
  65 ip6_add_interface_prefix_routes (ip6_main_t * im,
  66                                  u32 sw_if_index,
  67                                  u32 fib_index,
  68                                  ip6_address_t * address, u32 address_length)
  69 {
  70   ip_lookup_main_t *lm = &im->lookup_main;
  71   ip_interface_prefix_t *if_prefix;
  72
  73   /* *INDENT-OFF* */
  74   ip_interface_prefix_key_t key = {
  75     .prefix = {
  76       .fp_len = address_length,
  77       .fp_proto = FIB_PROTOCOL_IP6,
  78       .fp_addr.ip6 = {
  79         .as_u64 = {
  80           address->as_u64[0] & im->fib_masks[address_length].as_u64[0],
  81           address->as_u64[1] & im->fib_masks[address_length].as_u64[1],
  82         },
  83       },
  84     },
  85     .sw_if_index = sw_if_index,
  86   };
  87   /* *INDENT-ON* */
  88
  89   /* If prefix already set on interface, just increment ref count & return */
  90   if_prefix = ip_get_interface_prefix (lm, &key);
  91   if (if_prefix)
  92     {
  93       if_prefix->ref_count += 1;
  94       return;
  95     }
  96
  97   /* New prefix - allocate a pool entry, initialize it, add to the hash */
  98   pool_get (lm->if_prefix_pool, if_prefix);
  99   if_prefix->ref_count = 1;
 100   clib_memcpy (&if_prefix->key, &key, sizeof (key));
 101   mhash_set (&lm->prefix_to_if_prefix_index, &key,
 102              if_prefix - lm->if_prefix_pool, 0 /* old value */ );
 103
 104   /* length < 128 - add glean */
 105   if (address_length < 128)
 106     {
 107       /* set the glean route for the prefix */
 108       fib_table_entry_update_one_path (fib_index, &key.prefix,
 109                                        FIB_SOURCE_INTERFACE,
 110                                        (FIB_ENTRY_FLAG_CONNECTED |
 111                                         FIB_ENTRY_FLAG_ATTACHED),
 112                                        DPO_PROTO_IP6,
 113                                        /* No next-hop address */
 114                                        NULL, sw_if_index,
 115                                        /* invalid FIB index */
 116                                        ~0, 1,
 117                                        /* no out-label stack */
 118                                        NULL, FIB_ROUTE_PATH_FLAG_NONE);
 119     }
 120 }
 121
 122 static void
 123 ip6_add_interface_routes (vnet_main_t * vnm, u32 sw_if_index,
 124                           ip6_main_t * im, u32 fib_index,
 125                           ip_interface_address_t * a)
 126 {
 127   ip_lookup_main_t *lm = &im->lookup_main;
 128   ip6_address_t *address = ip_interface_address_get_address (lm, a);
 129   fib_prefix_t pfx = {
 130     .fp_len = a->address_length,
 131     .fp_proto = FIB_PROTOCOL_IP6,
 132     .fp_addr.ip6 = *address,
 133   };
 134
 135   /* set special routes for the prefix if needed */
 136   ip6_add_interface_prefix_routes (im, sw_if_index, fib_index,
 137                                    address, a->address_length);
 138
 139   pfx.fp_len = 128;
 140   if (sw_if_index < vec_len (lm->classify_table_index_by_sw_if_index))
 141     {
 142       u32 classify_table_index =
 143         lm->classify_table_index_by_sw_if_index[sw_if_index];
 144       if (classify_table_index != (u32) ~ 0)
 145         {
 146           dpo_id_t dpo = DPO_INVALID;
 147
 148           dpo_set (&dpo,
 149                    DPO_CLASSIFY,
 150                    DPO_PROTO_IP6,
 151                    classify_dpo_create (DPO_PROTO_IP6, classify_table_index));
 152
 153           fib_table_entry_special_dpo_add (fib_index,
 154                                            &pfx,
 155                                            FIB_SOURCE_CLASSIFY,
 156                                            FIB_ENTRY_FLAG_NONE, &dpo);
 157           dpo_reset (&dpo);
 158         }
 159     }
 160
 161   fib_table_entry_update_one_path (fib_index, &pfx,
 162                                    FIB_SOURCE_INTERFACE,
 163                                    (FIB_ENTRY_FLAG_CONNECTED |
 164                                     FIB_ENTRY_FLAG_LOCAL),
 165                                    DPO_PROTO_IP6,
 166                                    &pfx.fp_addr,
 167                                    sw_if_index, ~0,
 168                                    1, NULL, FIB_ROUTE_PATH_FLAG_NONE);
 169 }
 170
 171 static void
 172 ip6_del_interface_prefix_routes (ip6_main_t * im,
 173                                  u32 sw_if_index,
 174                                  u32 fib_index,
 175                                  ip6_address_t * address, u32 address_length)
 176 {
 177   ip_lookup_main_t *lm = &im->lookup_main;
 178   ip_interface_prefix_t *if_prefix;
 179
 180   /* *INDENT-OFF* */
 181   ip_interface_prefix_key_t key = {
 182     .prefix = {
 183       .fp_len = address_length,
 184       .fp_proto = FIB_PROTOCOL_IP6,
 185       .fp_addr.ip6 = {
 186         .as_u64 = {
 187           address->as_u64[0] & im->fib_masks[address_length].as_u64[0],
 188           address->as_u64[1] & im->fib_masks[address_length].as_u64[1],
 189         },
 190       },
 191     },
 192     .sw_if_index = sw_if_index,
 193   };
 194   /* *INDENT-ON* */
 195
 196   if_prefix = ip_get_interface_prefix (lm, &key);
 197   if (!if_prefix)
 198     {
 199       clib_warning ("Prefix not found while deleting %U",
 200                     format_ip4_address_and_length, address, address_length);
 201       return;
 202     }
 203
 204   /* If not deleting last intf addr in prefix, decrement ref count & return */
 205   if_prefix->ref_count -= 1;
 206   if (if_prefix->ref_count > 0)
 207     return;
 208
 209   /* length <= 128, delete glean route */
 210   if (address_length <= 128)
 211     {
 212       /* remove glean route for prefix */
 213       fib_table_entry_delete (fib_index, &key.prefix, FIB_SOURCE_INTERFACE);
 214     }
 215
 216   mhash_unset (&lm->prefix_to_if_prefix_index, &key, 0 /* old_value */ );
 217   pool_put (lm->if_prefix_pool, if_prefix);
 218 }
 219
 220 static void
 221 ip6_del_interface_routes (u32 sw_if_index, ip6_main_t * im,
 222                           u32 fib_index,
 223                           ip6_address_t * address, u32 address_length)
 224 {
 225   fib_prefix_t pfx = {
 226     .fp_len = 128,
 227     .fp_proto = FIB_PROTOCOL_IP6,
 228     .fp_addr.ip6 = *address,
 229   };
 230
 231   /* delete special routes for the prefix if needed */
 232   ip6_del_interface_prefix_routes (im, sw_if_index, fib_index,
 233                                    address, address_length);
 234
 235   fib_table_entry_delete (fib_index, &pfx, FIB_SOURCE_INTERFACE);
 236 }
 237
 238 #ifndef CLIB_MARCH_VARIANT
 239 void
 240 ip6_sw_interface_enable_disable (u32 sw_if_index, u32 is_enable)
 241 {
 242   ip6_main_t *im = &ip6_main;
 243   vnet_main_t *vnm = vnet_get_main ();
 244   vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
 245
 246   vec_validate_init_empty (im->ip_enabled_by_sw_if_index, sw_if_index, 0);
 247
 248   /*
 249    * enable/disable only on the 1<->0 transition
 250    */
 251   if (is_enable)
 252     {
 253       if (1 != ++im->ip_enabled_by_sw_if_index[sw_if_index])
 254         return;
 255     }
 256   else
 257     {
 258       /* The ref count is 0 when an address is removed from an interface that has
 259        * no address - this is not a ciritical error */
 260       if (0 == im->ip_enabled_by_sw_if_index[sw_if_index] ||
 261           0 != --im->ip_enabled_by_sw_if_index[sw_if_index])
 262         return;
 263     }
 264
 265   vnet_feature_enable_disable ("ip6-unicast", "ip6-not-enabled", sw_if_index,
 266                                !is_enable, 0, 0);
 267
 268   vnet_feature_enable_disable ("ip6-multicast", "ip6-not-enabled",
 269                                sw_if_index, !is_enable, 0, 0);
 270
 271   if (is_enable)
 272     hi->l3_if_count++;
 273   else if (hi->l3_if_count)
 274     hi->l3_if_count--;
 275 }
 276
 277 /* get first interface address */
 278 ip6_address_t *
 279 ip6_interface_first_address (ip6_main_t * im, u32 sw_if_index)
 280 {
 281   ip_lookup_main_t *lm = &im->lookup_main;
 282   ip_interface_address_t *ia = 0;
 283   ip6_address_t *result = 0;
 284
 285   /* *INDENT-OFF* */
 286   foreach_ip_interface_address (lm, ia, sw_if_index,
 287                                 1 /* honor unnumbered */,
 288   ({
 289     ip6_address_t * a = ip_interface_address_get_address (lm, ia);
 290     result = a;
 291     break;
 292   }));
 293   /* *INDENT-ON* */
 294   return result;
 295 }
 296
 297 clib_error_t *
 298 ip6_add_del_interface_address (vlib_main_t * vm,
 299                                u32 sw_if_index,
 300                                ip6_address_t * address,
 301                                u32 address_length, u32 is_del)
 302 {
 303   vnet_main_t *vnm = vnet_get_main ();
 304   ip6_main_t *im = &ip6_main;
 305   ip_lookup_main_t *lm = &im->lookup_main;
 306   clib_error_t *error = NULL;
 307   u32 if_address_index;
 308   ip6_address_fib_t ip6_af, *addr_fib = 0;
 309   const ip6_address_t *ll_addr;
 310
 311   /* local0 interface doesn't support IP addressing */
 312   if (sw_if_index == 0)
 313     {
 314       return
 315         clib_error_create ("local0 interface doesn't support IP addressing");
 316     }
 317
 318   if (ip6_address_is_link_local_unicast (address))
 319     {
 320       if (address_length != 128)
 321         {
 322           vnm->api_errno = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH;
 323           return
 324             clib_error_create
 325             ("prefix length of link-local address must be 128");
 326         }
 327       if (!is_del)
 328         {
 329           int rv;
 330
 331           rv = ip6_link_set_local_address (sw_if_index, address);
 332
 333           if (rv)
 334             {
 335               vnm->api_errno = rv;
 336               return clib_error_create ("address not assignable");
 337             }
 338         }
 339       else
 340         {
 341           ll_addr = ip6_get_link_local_address (sw_if_index);
 342           if (ip6_address_is_equal (ll_addr, address))
 343             {
 344               vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_DELETABLE;
 345               return clib_error_create ("address not deletable");
 346             }
 347           else
 348             {
 349               vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
 350               return clib_error_create ("address not found");
 351             }
 352         }
 353
 354       return (NULL);
 355     }
 356
 357   vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
 358   vec_validate (im->mfib_index_by_sw_if_index, sw_if_index);
 359
 360   ip6_addr_fib_init (&ip6_af, address,
 361                      vec_elt (im->fib_index_by_sw_if_index, sw_if_index));
 362   vec_add1 (addr_fib, ip6_af);
 363
 364   /* *INDENT-OFF* */
 365   if (!is_del)
 366     {
 367       /* When adding an address check that it does not conflict
 368          with an existing address on any interface in this table. */
 369       ip_interface_address_t *ia;
 370       vnet_sw_interface_t *sif;
 371
 372       pool_foreach (sif, vnm->interface_main.sw_interfaces)
 373        {
 374           if (im->fib_index_by_sw_if_index[sw_if_index] ==
 375               im->fib_index_by_sw_if_index[sif->sw_if_index])
 376             {
 377               foreach_ip_interface_address
 378                 (&im->lookup_main, ia, sif->sw_if_index,
 379                  0 /* honor unnumbered */ ,
 380                  ({
 381                    ip6_address_t * x =
 382                      ip_interface_address_get_address
 383                      (&im->lookup_main, ia);
 384
 385                    if (ip6_destination_matches_route
 386                        (im, address, x, ia->address_length) ||
 387                        ip6_destination_matches_route (im,
 388                                                       x,
 389                                                       address,
 390                                                       address_length))
 391                      {
 392                        /* an intf may have >1 addr from the same prefix */
 393                        if ((sw_if_index == sif->sw_if_index) &&
 394                            (ia->address_length == address_length) &&
 395                            !ip6_address_is_equal (x, address))
 396                          continue;
 397
 398                        if (ia->flags & IP_INTERFACE_ADDRESS_FLAG_STALE)
 399                          /* if the address we're comparing against is stale
 400                           * then the CP has not added this one back yet, maybe
 401                           * it never will, so we have to assume it won't and
 402                           * ignore it. if it does add it back, then it will fail
 403                           * because this one is now present */
 404                          continue;
 405
 406                        /* error if the length or intf was different */
 407                        vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
 408                        error =  clib_error_create
 409                          ("failed to add %U which conflicts with %U for interface %U",
 410                           format_ip6_address_and_length, address,
 411                           address_length,
 412                           format_ip6_address_and_length, x,
 413                           ia->address_length,
 414                           format_vnet_sw_if_index_name, vnm,
 415                           sif->sw_if_index);
 416                        goto done;
 417                      }
 418                  }));
 419             }
 420       }
 421     }
 422   /* *INDENT-ON* */
 423
 424   if_address_index = ip_interface_address_find (lm, addr_fib, address_length);
 425
 426   if (is_del)
 427     {
 428       if (~0 == if_address_index)
 429         {
 430           vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
 431           error = clib_error_create ("%U not found for interface %U",
 432                                      lm->format_address_and_length,
 433                                      addr_fib, address_length,
 434                                      format_vnet_sw_if_index_name, vnm,
 435                                      sw_if_index);
 436           goto done;
 437         }
 438
 439       error = ip_interface_address_del (lm, vnm, if_address_index, addr_fib,
 440                                         address_length, sw_if_index);
 441       if (error)
 442         goto done;
 443     }
 444   else
 445     {
 446       if (~0 != if_address_index)
 447         {
 448           ip_interface_address_t *ia;
 449
 450           ia = pool_elt_at_index (lm->if_address_pool, if_address_index);
 451
 452           if (ia->flags & IP_INTERFACE_ADDRESS_FLAG_STALE)
 453             {
 454               if (ia->sw_if_index == sw_if_index)
 455                 {
 456                   /* re-adding an address during the replace action.
 457                    * consdier this the update. clear the flag and
 458                    * we're done */
 459                   ia->flags &= ~IP_INTERFACE_ADDRESS_FLAG_STALE;
 460                   goto done;
 461                 }
 462               else
 463                 {
 464                   /* The prefix is moving from one interface to another.
 465                    * delete the stale and add the new */
 466                   ip6_add_del_interface_address (vm,
 467                                                  ia->sw_if_index,
 468                                                  address, address_length, 1);
 469                   ia = NULL;
 470                   error = ip_interface_address_add (lm, sw_if_index,
 471                                                     addr_fib, address_length,
 472                                                     &if_address_index);
 473                 }
 474             }
 475           else
 476             {
 477               vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
 478               error = clib_error_create
 479                 ("Prefix %U already found on interface %U",
 480                  lm->format_address_and_length, addr_fib, address_length,
 481                  format_vnet_sw_if_index_name, vnm, ia->sw_if_index);
 482             }
 483         }
 484       else
 485         error = ip_interface_address_add (lm, sw_if_index,
 486                                           addr_fib, address_length,
 487                                           &if_address_index);
 488     }
 489
 490   if (error)
 491     goto done;
 492
 493   ip6_sw_interface_enable_disable (sw_if_index, !is_del);
 494   if (!is_del)
 495     ip6_link_enable (sw_if_index, NULL);
 496
 497   /* intf addr routes are added/deleted on admin up/down */
 498   if (vnet_sw_interface_is_admin_up (vnm, sw_if_index))
 499     {
 500       if (is_del)
 501         ip6_del_interface_routes (sw_if_index,
 502                                   im, ip6_af.fib_index, address,
 503                                   address_length);
 504       else
 505         ip6_add_interface_routes (vnm, sw_if_index,
 506                                   im, ip6_af.fib_index,
 507                                   pool_elt_at_index (lm->if_address_pool,
 508                                                      if_address_index));
 509     }
 510
 511   ip6_add_del_interface_address_callback_t *cb;
 512   vec_foreach (cb, im->add_del_interface_address_callbacks)
 513     cb->function (im, cb->function_opaque, sw_if_index,
 514                   address, address_length, if_address_index, is_del);
 515
 516   if (is_del)
 517     ip6_link_disable (sw_if_index);
 518
 519 done:
 520   vec_free (addr_fib);
 521   return error;
 522 }
 523
 524 #endif
 525
 526 static clib_error_t *
 527 ip6_sw_interface_admin_up_down (vnet_main_t * vnm, u32 sw_if_index, u32 flags)
 528 {
 529   ip6_main_t *im = &ip6_main;
 530   ip_interface_address_t *ia;
 531   ip6_address_t *a;
 532   u32 is_admin_up, fib_index;
 533
 534   /* Fill in lookup tables with default table (0). */
 535   vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
 536
 537   vec_validate_init_empty (im->
 538                            lookup_main.if_address_pool_index_by_sw_if_index,
 539                            sw_if_index, ~0);
 540
 541   is_admin_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
 542
 543   fib_index = vec_elt (im->fib_index_by_sw_if_index, sw_if_index);
 544
 545   /* *INDENT-OFF* */
 546   foreach_ip_interface_address (&im->lookup_main, ia, sw_if_index,
 547                                 0 /* honor unnumbered */,
 548   ({
 549     a = ip_interface_address_get_address (&im->lookup_main, ia);
 550     if (is_admin_up)
 551       ip6_add_interface_routes (vnm, sw_if_index,
 552                                 im, fib_index,
 553                                 ia);
 554     else
 555       ip6_del_interface_routes (sw_if_index, im, fib_index,
 556                                 a, ia->address_length);
 557   }));
 558   /* *INDENT-ON* */
 559
 560   return 0;
 561 }
 562
 563 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (ip6_sw_interface_admin_up_down);
 564
 565 /* Built-in ip6 unicast rx feature path definition */
 566 /* *INDENT-OFF* */
 567 VNET_FEATURE_ARC_INIT (ip6_unicast, static) =
 568 {
 569   .arc_name  = "ip6-unicast",
 570   .start_nodes = VNET_FEATURES ("ip6-input"),
 571   .last_in_arc = "ip6-lookup",
 572   .arc_index_ptr = &ip6_main.lookup_main.ucast_feature_arc_index,
 573 };
 574
 575 VNET_FEATURE_INIT (ip6_flow_classify, static) =
 576 {
 577   .arc_name = "ip6-unicast",
 578   .node_name = "ip6-flow-classify",
 579   .runs_before = VNET_FEATURES ("ip6-inacl"),
 580 };
 581
 582 VNET_FEATURE_INIT (ip6_inacl, static) =
 583 {
 584   .arc_name = "ip6-unicast",
 585   .node_name = "ip6-inacl",
 586   .runs_before = VNET_FEATURES ("ip6-policer-classify"),
 587 };
 588
 589 VNET_FEATURE_INIT (ip6_policer_classify, static) =
 590 {
 591   .arc_name = "ip6-unicast",
 592   .node_name = "ip6-policer-classify",
 593   .runs_before = VNET_FEATURES ("ipsec6-input-feature"),
 594 };
 595
 596 VNET_FEATURE_INIT (ip6_ipsec, static) =
 597 {
 598   .arc_name = "ip6-unicast",
 599   .node_name = "ipsec6-input-feature",
 600   .runs_before = VNET_FEATURES ("l2tp-decap"),
 601 };
 602
 603 VNET_FEATURE_INIT (ip6_l2tp, static) =
 604 {
 605   .arc_name = "ip6-unicast",
 606   .node_name = "l2tp-decap",
 607   .runs_before = VNET_FEATURES ("vpath-input-ip6"),
 608 };
 609
 610 VNET_FEATURE_INIT (ip6_vpath, static) =
 611 {
 612   .arc_name = "ip6-unicast",
 613   .node_name = "vpath-input-ip6",
 614   .runs_before = VNET_FEATURES ("ip6-vxlan-bypass"),
 615 };
 616
 617 VNET_FEATURE_INIT (ip6_vxlan_bypass, static) =
 618 {
 619   .arc_name = "ip6-unicast",
 620   .node_name = "ip6-vxlan-bypass",
 621   .runs_before = VNET_FEATURES ("ip6-lookup"),
 622 };
 623
 624 VNET_FEATURE_INIT (ip6_not_enabled, static) =
 625 {
 626   .arc_name = "ip6-unicast",
 627   .node_name = "ip6-not-enabled",
 628   .runs_before = VNET_FEATURES ("ip6-lookup"),
 629 };
 630
 631 VNET_FEATURE_INIT (ip6_lookup, static) =
 632 {
 633   .arc_name = "ip6-unicast",
 634   .node_name = "ip6-lookup",
 635   .runs_before = 0,  /*last feature*/
 636 };
 637
 638 /* Built-in ip6 multicast rx feature path definition (none now) */
 639 VNET_FEATURE_ARC_INIT (ip6_multicast, static) =
 640 {
 641   .arc_name  = "ip6-multicast",
 642   .start_nodes = VNET_FEATURES ("ip6-input"),
 643   .last_in_arc = "ip6-mfib-forward-lookup",
 644   .arc_index_ptr = &ip6_main.lookup_main.mcast_feature_arc_index,
 645 };
 646
 647 VNET_FEATURE_INIT (ip6_vpath_mc, static) = {
 648   .arc_name = "ip6-multicast",
 649   .node_name = "vpath-input-ip6",
 650   .runs_before = VNET_FEATURES ("ip6-mfib-forward-lookup"),
 651 };
 652
 653 VNET_FEATURE_INIT (ip6_not_enabled_mc, static) = {
 654   .arc_name = "ip6-multicast",
 655   .node_name = "ip6-not-enabled",
 656   .runs_before = VNET_FEATURES ("ip6-mfib-forward-lookup"),
 657 };
 658
 659 VNET_FEATURE_INIT (ip6_mc_lookup, static) = {
 660   .arc_name = "ip6-multicast",
 661   .node_name = "ip6-mfib-forward-lookup",
 662   .runs_before = 0, /* last feature */
 663 };
 664
 665 /* Built-in ip4 tx feature path definition */
 666 VNET_FEATURE_ARC_INIT (ip6_output, static) =
 667 {
 668   .arc_name  = "ip6-output",
 669   .start_nodes = VNET_FEATURES ("ip6-rewrite", "ip6-midchain", "ip6-dvr-dpo"),
 670   .last_in_arc = "interface-output",
 671   .arc_index_ptr = &ip6_main.lookup_main.output_feature_arc_index,
 672 };
 673
 674 VNET_FEATURE_INIT (ip6_outacl, static) = {
 675   .arc_name = "ip6-output",
 676   .node_name = "ip6-outacl",
 677   .runs_before = VNET_FEATURES ("ipsec6-output-feature"),
 678 };
 679
 680 VNET_FEATURE_INIT (ip6_ipsec_output, static) = {
 681   .arc_name = "ip6-output",
 682   .node_name = "ipsec6-output-feature",
 683   .runs_before = VNET_FEATURES ("interface-output"),
 684 };
 685
 686 VNET_FEATURE_INIT (ip6_interface_output, static) = {
 687   .arc_name = "ip6-output",
 688   .node_name = "interface-output",
 689   .runs_before = 0, /* not before any other features */
 690 };
 691 /* *INDENT-ON* */
 692
 693 static clib_error_t *
 694 ip6_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
 695 {
 696   ip6_main_t *im = &ip6_main;
 697
 698   vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
 699   vec_validate (im->mfib_index_by_sw_if_index, sw_if_index);
 700
 701   if (!is_add)
 702     {
 703       /* Ensure that IPv6 is disabled */
 704       ip6_main_t *im6 = &ip6_main;
 705       ip_lookup_main_t *lm6 = &im6->lookup_main;
 706       ip_interface_address_t *ia = 0;
 707       ip6_address_t *address;
 708       vlib_main_t *vm = vlib_get_main ();
 709
 710       vnet_sw_interface_update_unnumbered (sw_if_index, ~0, 0);
 711       /* *INDENT-OFF* */
 712       foreach_ip_interface_address (lm6, ia, sw_if_index, 0,
 713       ({
 714         address = ip_interface_address_get_address (lm6, ia);
 715         ip6_add_del_interface_address(vm, sw_if_index, address, ia->address_length, 1);
 716       }));
 717       /* *INDENT-ON* */
 718       ip6_mfib_interface_enable_disable (sw_if_index, 0);
 719     }
 720
 721   vnet_feature_enable_disable ("ip6-unicast", "ip6-not-enabled", sw_if_index,
 722                                is_add, 0, 0);
 723
 724   vnet_feature_enable_disable ("ip6-multicast", "ip6-not-enabled",
 725                                sw_if_index, is_add, 0, 0);
 726
 727   return /* no error */ 0;
 728 }
 729
 730 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ip6_sw_interface_add_del);
 731
 732 VLIB_NODE_FN (ip6_lookup_node) (vlib_main_t * vm,
 733                                 vlib_node_runtime_t * node,
 734                                 vlib_frame_t * frame)
 735 {
 736   return ip6_lookup_inline (vm, node, frame);
 737 }
 738
 739 static u8 *format_ip6_lookup_trace (u8 * s, va_list * args);
 740
 741 /* *INDENT-OFF* */
 742 VLIB_REGISTER_NODE (ip6_lookup_node) =
 743 {
 744   .name = "ip6-lookup",
 745   .vector_size = sizeof (u32),
 746   .format_trace = format_ip6_lookup_trace,
 747   .n_next_nodes = IP6_LOOKUP_N_NEXT,
 748   .next_nodes = IP6_LOOKUP_NEXT_NODES,
 749 };
 750 /* *INDENT-ON* */
 751
 752 VLIB_NODE_FN (ip6_load_balance_node) (vlib_main_t * vm,
 753                                       vlib_node_runtime_t * node,
 754                                       vlib_frame_t * frame)
 755 {
 756   vlib_combined_counter_main_t *cm = &load_balance_main.lbm_via_counters;
 757   u32 n_left, *from;
 758   u32 thread_index = vm->thread_index;
 759   ip6_main_t *im = &ip6_main;
 760   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
 761   u16 nexts[VLIB_FRAME_SIZE], *next;
 762
 763   from = vlib_frame_vector_args (frame);
 764   n_left = frame->n_vectors;
 765   next = nexts;
 766
 767   vlib_get_buffers (vm, from, bufs, n_left);
 768
 769   while (n_left >= 4)
 770     {
 771       const load_balance_t *lb0, *lb1;
 772       const ip6_header_t *ip0, *ip1;
 773       u32 lbi0, hc0, lbi1, hc1;
 774       const dpo_id_t *dpo0, *dpo1;
 775
 776       /* Prefetch next iteration. */
 777       {
 778         vlib_prefetch_buffer_header (b[2], STORE);
 779         vlib_prefetch_buffer_header (b[3], STORE);
 780
 781         CLIB_PREFETCH (b[2]->data, sizeof (ip0[0]), STORE);
 782         CLIB_PREFETCH (b[3]->data, sizeof (ip0[0]), STORE);
 783       }
 784
 785       ip0 = vlib_buffer_get_current (b[0]);
 786       ip1 = vlib_buffer_get_current (b[1]);
 787       lbi0 = vnet_buffer (b[0])->ip.adj_index[VLIB_TX];
 788       lbi1 = vnet_buffer (b[1])->ip.adj_index[VLIB_TX];
 789
 790       lb0 = load_balance_get (lbi0);
 791       lb1 = load_balance_get (lbi1);
 792
 793       /*
 794        * this node is for via FIBs we can re-use the hash value from the
 795        * to node if present.
 796        * We don't want to use the same hash value at each level in the recursion
 797        * graph as that would lead to polarisation
 798        */
 799       hc0 = hc1 = 0;
 800
 801       if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
 802         {
 803           if (PREDICT_TRUE (vnet_buffer (b[0])->ip.flow_hash))
 804             {
 805               hc0 = vnet_buffer (b[0])->ip.flow_hash =
 806                 vnet_buffer (b[0])->ip.flow_hash >> 1;
 807             }
 808           else
 809             {
 810               hc0 = vnet_buffer (b[0])->ip.flow_hash =
 811                 ip6_compute_flow_hash (ip0, lb0->lb_hash_config);
 812             }
 813           dpo0 = load_balance_get_fwd_bucket
 814             (lb0, (hc0 & (lb0->lb_n_buckets_minus_1)));
 815         }
 816       else
 817         {
 818           dpo0 = load_balance_get_bucket_i (lb0, 0);
 819         }
 820       if (PREDICT_FALSE (lb1->lb_n_buckets > 1))
 821         {
 822           if (PREDICT_TRUE (vnet_buffer (b[1])->ip.flow_hash))
 823             {
 824               hc1 = vnet_buffer (b[1])->ip.flow_hash =
 825                 vnet_buffer (b[1])->ip.flow_hash >> 1;
 826             }
 827           else
 828             {
 829               hc1 = vnet_buffer (b[1])->ip.flow_hash =
 830                 ip6_compute_flow_hash (ip1, lb1->lb_hash_config);
 831             }
 832           dpo1 = load_balance_get_fwd_bucket
 833             (lb1, (hc1 & (lb1->lb_n_buckets_minus_1)));
 834         }
 835       else
 836         {
 837           dpo1 = load_balance_get_bucket_i (lb1, 0);
 838         }
 839
 840       next[0] = dpo0->dpoi_next_node;
 841       next[1] = dpo1->dpoi_next_node;
 842
 843       /* Only process the HBH Option Header if explicitly configured to do so */
 844       if (PREDICT_FALSE (ip0->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
 845         {
 846           next[0] = (dpo_is_adj (dpo0) && im->hbh_enabled) ?
 847             (ip_lookup_next_t) IP6_LOOKUP_NEXT_HOP_BY_HOP : next[0];
 848         }
 849       /* Only process the HBH Option Header if explicitly configured to do so */
 850       if (PREDICT_FALSE (ip1->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
 851         {
 852           next[1] = (dpo_is_adj (dpo1) && im->hbh_enabled) ?
 853             (ip_lookup_next_t) IP6_LOOKUP_NEXT_HOP_BY_HOP : next[1];
 854         }
 855
 856       vnet_buffer (b[0])->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
 857       vnet_buffer (b[1])->ip.adj_index[VLIB_TX] = dpo1->dpoi_index;
 858
 859       vlib_increment_combined_counter
 860         (cm, thread_index, lbi0, 1, vlib_buffer_length_in_chain (vm, b[0]));
 861       vlib_increment_combined_counter
 862         (cm, thread_index, lbi1, 1, vlib_buffer_length_in_chain (vm, b[1]));
 863
 864       b += 2;
 865       next += 2;
 866       n_left -= 2;
 867     }
 868
 869   while (n_left > 0)
 870     {
 871       const load_balance_t *lb0;
 872       const ip6_header_t *ip0;
 873       const dpo_id_t *dpo0;
 874       u32 lbi0, hc0;
 875
 876       ip0 = vlib_buffer_get_current (b[0]);
 877       lbi0 = vnet_buffer (b[0])->ip.adj_index[VLIB_TX];
 878
 879       lb0 = load_balance_get (lbi0);
 880
 881       hc0 = 0;
 882       if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
 883         {
 884           if (PREDICT_TRUE (vnet_buffer (b[0])->ip.flow_hash))
 885             {
 886               hc0 = vnet_buffer (b[0])->ip.flow_hash =
 887                 vnet_buffer (b[0])->ip.flow_hash >> 1;
 888             }
 889           else
 890             {
 891               hc0 = vnet_buffer (b[0])->ip.flow_hash =
 892                 ip6_compute_flow_hash (ip0, lb0->lb_hash_config);
 893             }
 894           dpo0 = load_balance_get_fwd_bucket
 895             (lb0, (hc0 & (lb0->lb_n_buckets_minus_1)));
 896         }
 897       else
 898         {
 899           dpo0 = load_balance_get_bucket_i (lb0, 0);
 900         }
 901
 902       next[0] = dpo0->dpoi_next_node;
 903       vnet_buffer (b[0])->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
 904
 905       /* Only process the HBH Option Header if explicitly configured to do so */
 906       if (PREDICT_FALSE (ip0->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
 907         {
 908           next[0] = (dpo_is_adj (dpo0) && im->hbh_enabled) ?
 909             (ip_lookup_next_t) IP6_LOOKUP_NEXT_HOP_BY_HOP : next[0];
 910         }
 911
 912       vlib_increment_combined_counter
 913         (cm, thread_index, lbi0, 1, vlib_buffer_length_in_chain (vm, b[0]));
 914
 915       b += 1;
 916       next += 1;
 917       n_left -= 1;
 918     }
 919
 920   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
 921
 922   if (node->flags & VLIB_NODE_FLAG_TRACE)
 923     ip6_forward_next_trace (vm, node, frame, VLIB_TX);
 924
 925   return frame->n_vectors;
 926 }
 927
 928 /* *INDENT-OFF* */
 929 VLIB_REGISTER_NODE (ip6_load_balance_node) =
 930 {
 931   .name = "ip6-load-balance",
 932   .vector_size = sizeof (u32),
 933   .sibling_of = "ip6-lookup",
 934   .format_trace = format_ip6_lookup_trace,
 935 };
 936 /* *INDENT-ON* */
 937
 938 typedef struct
 939 {
 940   /* Adjacency taken. */
 941   u32 adj_index;
 942   u32 flow_hash;
 943   u32 fib_index;
 944
 945   /* Packet data, possibly *after* rewrite. */
 946   u8 packet_data[128 - 1 * sizeof (u32)];
 947 }
 948 ip6_forward_next_trace_t;
 949
 950 #ifndef CLIB_MARCH_VARIANT
 951 u8 *
 952 format_ip6_forward_next_trace (u8 * s, va_list * args)
 953 {
 954   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 955   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 956   ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
 957   u32 indent = format_get_indent (s);
 958
 959   s = format (s, "%Ufib:%d adj:%d flow:%d",
 960               format_white_space, indent,
 961               t->fib_index, t->adj_index, t->flow_hash);
 962   s = format (s, "\n%U%U",
 963               format_white_space, indent,
 964               format_ip6_header, t->packet_data, sizeof (t->packet_data));
 965   return s;
 966 }
 967 #endif
 968
 969 static u8 *
 970 format_ip6_lookup_trace (u8 * s, va_list * args)
 971 {
 972   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 973   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 974   ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
 975   u32 indent = format_get_indent (s);
 976
 977   s = format (s, "fib %d dpo-idx %d flow hash: 0x%08x",
 978               t->fib_index, t->adj_index, t->flow_hash);
 979   s = format (s, "\n%U%U",
 980               format_white_space, indent,
 981               format_ip6_header, t->packet_data, sizeof (t->packet_data));
 982   return s;
 983 }
 984
 985
 986 static u8 *
 987 format_ip6_rewrite_trace (u8 * s, va_list * args)
 988 {
 989   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 990   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 991   ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
 992   u32 indent = format_get_indent (s);
 993
 994   s = format (s, "tx_sw_if_index %d adj-idx %d : %U flow hash: 0x%08x",
 995               t->fib_index, t->adj_index, format_ip_adjacency,
 996               t->adj_index, FORMAT_IP_ADJACENCY_NONE, t->flow_hash);
 997   s = format (s, "\n%U%U",
 998               format_white_space, indent,
 999               format_ip_adjacency_packet_data,
1000               t->packet_data, sizeof (t->packet_data));
1001   return s;
1002 }
1003
1004 /* Common trace function for all ip6-forward next nodes. */
1005 #ifndef CLIB_MARCH_VARIANT
1006 void
1007 ip6_forward_next_trace (vlib_main_t * vm,
1008                         vlib_node_runtime_t * node,
1009                         vlib_frame_t * frame, vlib_rx_or_tx_t which_adj_index)
1010 {
1011   u32 *from, n_left;
1012   ip6_main_t *im = &ip6_main;
1013
1014   n_left = frame->n_vectors;
1015   from = vlib_frame_vector_args (frame);
1016
1017   while (n_left >= 4)
1018     {
1019       u32 bi0, bi1;
1020       vlib_buffer_t *b0, *b1;
1021       ip6_forward_next_trace_t *t0, *t1;
1022
1023       /* Prefetch next iteration. */
1024       vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
1025       vlib_prefetch_buffer_with_index (vm, from[3], LOAD);
1026
1027       bi0 = from[0];
1028       bi1 = from[1];
1029
1030       b0 = vlib_get_buffer (vm, bi0);
1031       b1 = vlib_get_buffer (vm, bi1);
1032
1033       if (b0->flags & VLIB_BUFFER_IS_TRACED)
1034         {
1035           t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
1036           t0->adj_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
1037           t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
1038           t0->fib_index =
1039             (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1040              (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1041             vec_elt (im->fib_index_by_sw_if_index,
1042                      vnet_buffer (b0)->sw_if_index[VLIB_RX]);
1043
1044           clib_memcpy_fast (t0->packet_data,
1045                             vlib_buffer_get_current (b0),
1046                             sizeof (t0->packet_data));
1047         }
1048       if (b1->flags & VLIB_BUFFER_IS_TRACED)
1049         {
1050           t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
1051           t1->adj_index = vnet_buffer (b1)->ip.adj_index[which_adj_index];
1052           t1->flow_hash = vnet_buffer (b1)->ip.flow_hash;
1053           t1->fib_index =
1054             (vnet_buffer (b1)->sw_if_index[VLIB_TX] !=
1055              (u32) ~ 0) ? vnet_buffer (b1)->sw_if_index[VLIB_TX] :
1056             vec_elt (im->fib_index_by_sw_if_index,
1057                      vnet_buffer (b1)->sw_if_index[VLIB_RX]);
1058
1059           clib_memcpy_fast (t1->packet_data,
1060                             vlib_buffer_get_current (b1),
1061                             sizeof (t1->packet_data));
1062         }
1063       from += 2;
1064       n_left -= 2;
1065     }
1066
1067   while (n_left >= 1)
1068     {
1069       u32 bi0;
1070       vlib_buffer_t *b0;
1071       ip6_forward_next_trace_t *t0;
1072
1073       bi0 = from[0];
1074
1075       b0 = vlib_get_buffer (vm, bi0);
1076
1077       if (b0->flags & VLIB_BUFFER_IS_TRACED)
1078         {
1079           t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
1080           t0->adj_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
1081           t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
1082           t0->fib_index =
1083             (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1084              (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1085             vec_elt (im->fib_index_by_sw_if_index,
1086                      vnet_buffer (b0)->sw_if_index[VLIB_RX]);
1087
1088           clib_memcpy_fast (t0->packet_data,
1089                             vlib_buffer_get_current (b0),
1090                             sizeof (t0->packet_data));
1091         }
1092       from += 1;
1093       n_left -= 1;
1094     }
1095 }
1096
1097 /* Compute TCP/UDP/ICMP6 checksum in software. */
1098 u16
1099 ip6_tcp_udp_icmp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
1100                                    ip6_header_t * ip0, int *bogus_lengthp)
1101 {
1102   ip_csum_t sum0 = 0;
1103   u16 payload_length, payload_length_host_byte_order;
1104   u32 i;
1105   u32 headers_size = sizeof (ip0[0]);
1106   u8 *data_this_buffer;
1107   u8 next_hdr = ip0->protocol;
1108
1109   ASSERT (bogus_lengthp);
1110   *bogus_lengthp = 0;
1111
1112   payload_length_host_byte_order = clib_net_to_host_u16 (ip0->payload_length);
1113   data_this_buffer = (u8 *) (ip0 + 1);
1114   payload_length = ip0->payload_length;
1115
1116   /* some icmp packets may come with a "router alert" hop-by-hop extension header (e.g., mldv2 packets)
1117    * or UDP-Ping packets */
1118   if (PREDICT_FALSE (next_hdr == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
1119     {
1120       u32 skip_bytes;
1121       ip6_hop_by_hop_ext_t *ext_hdr =
1122         (ip6_hop_by_hop_ext_t *) data_this_buffer;
1123
1124       /* validate really icmp6 next */
1125       ASSERT ((ext_hdr->next_hdr == IP_PROTOCOL_ICMP6)
1126               || (ext_hdr->next_hdr == IP_PROTOCOL_UDP));
1127
1128       skip_bytes = 8 * (1 + ext_hdr->n_data_u64s);
1129       data_this_buffer = (void *) ((u8 *) data_this_buffer + skip_bytes);
1130
1131       payload_length_host_byte_order -= skip_bytes;
1132       headers_size += skip_bytes;
1133
1134       /* pseudo-header adjustments:
1135        *   exclude ext header bytes from payload length
1136        *   use payload IP proto rather than ext header IP proto
1137        */
1138       payload_length = clib_host_to_net_u16 (payload_length_host_byte_order);
1139       next_hdr = ext_hdr->next_hdr;
1140     }
1141
1142   /* Initialize checksum with ip pseudo-header. */
1143   sum0 = payload_length + clib_host_to_net_u16 (next_hdr);
1144
1145   for (i = 0; i < ARRAY_LEN (ip0->src_address.as_uword); i++)
1146     {
1147       sum0 = ip_csum_with_carry
1148         (sum0, clib_mem_unaligned (&ip0->src_address.as_uword[i], uword));
1149       sum0 = ip_csum_with_carry
1150         (sum0, clib_mem_unaligned (&ip0->dst_address.as_uword[i], uword));
1151     }
1152
1153   if (p0)
1154     return ip_calculate_l4_checksum (vm, p0, sum0,
1155                                      payload_length_host_byte_order,
1156                                      (u8 *) ip0, headers_size, NULL);
1157   else
1158     return ip_calculate_l4_checksum (vm, 0, sum0,
1159                                      payload_length_host_byte_order, NULL, 0,
1160                                      data_this_buffer);
1161 }
1162
1163 u32
1164 ip6_tcp_udp_icmp_validate_checksum (vlib_main_t * vm, vlib_buffer_t * p0)
1165 {
1166   ip6_header_t *ip0 = vlib_buffer_get_current (p0);
1167   udp_header_t *udp0;
1168   u16 sum16;
1169   int bogus_length;
1170
1171   /* some icmp packets may come with a "router alert" hop-by-hop extension header (e.g., mldv2 packets) */
1172   ASSERT (ip0->protocol == IP_PROTOCOL_TCP
1173           || ip0->protocol == IP_PROTOCOL_ICMP6
1174           || ip0->protocol == IP_PROTOCOL_UDP
1175           || ip0->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS);
1176
1177   udp0 = (void *) (ip0 + 1);
1178   if (ip0->protocol == IP_PROTOCOL_UDP && udp0->checksum == 0)
1179     {
1180       p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1181                     | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
1182       return p0->flags;
1183     }
1184
1185   sum16 = ip6_tcp_udp_icmp_compute_checksum (vm, p0, ip0, &bogus_length);
1186
1187   p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1188                 | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
1189
1190   return p0->flags;
1191 }
1192 #endif
1193
1194 /**
1195  * @brief returns number of links on which src is reachable.
1196  */
1197 always_inline int
1198 ip6_urpf_loose_check (ip6_main_t * im, vlib_buffer_t * b, ip6_header_t * i)
1199 {
1200   const load_balance_t *lb0;
1201   index_t lbi;
1202   u32 fib_index;
1203
1204   fib_index = vec_elt (im->fib_index_by_sw_if_index,
1205                        vnet_buffer (b)->sw_if_index[VLIB_RX]);
1206   fib_index =
1207     (vnet_buffer (b)->sw_if_index[VLIB_TX] == (u32) ~ 0) ?
1208     fib_index : vnet_buffer (b)->sw_if_index[VLIB_TX];
1209
1210   lbi = ip6_fib_table_fwding_lookup (fib_index, &i->src_address);
1211   lb0 = load_balance_get (lbi);
1212
1213   return (fib_urpf_check_size (lb0->lb_urpf));
1214 }
1215
1216 always_inline u8
1217 ip6_next_proto_is_tcp_udp (vlib_buffer_t * p0, ip6_header_t * ip0,
1218                            u32 * udp_offset0)
1219 {
1220   u32 proto0;
1221   proto0 = ip6_locate_header (p0, ip0, IP_PROTOCOL_UDP, udp_offset0);
1222   if (proto0 != IP_PROTOCOL_UDP)
1223     {
1224       proto0 = ip6_locate_header (p0, ip0, IP_PROTOCOL_TCP, udp_offset0);
1225       proto0 = (proto0 == IP_PROTOCOL_TCP) ? proto0 : 0;
1226     }
1227   return proto0;
1228 }
1229
1230 /* *INDENT-OFF* */
1231 VNET_FEATURE_ARC_INIT (ip6_local) =
1232 {
1233   .arc_name  = "ip6-local",
1234   .start_nodes = VNET_FEATURES ("ip6-local"),
1235 };
1236 /* *INDENT-ON* */
1237
1238 static_always_inline u8
1239 ip6_tcp_udp_icmp_bad_length (vlib_main_t * vm, vlib_buffer_t * p0)
1240 {
1241
1242   u16 payload_length_host_byte_order;
1243   u32 n_this_buffer, n_bytes_left;
1244   ip6_header_t *ip0 = vlib_buffer_get_current (p0);
1245   u32 headers_size = sizeof (ip0[0]);
1246   u8 *data_this_buffer;
1247
1248
1249   data_this_buffer = (u8 *) (ip0 + 1);
1250
1251   ip6_hop_by_hop_ext_t *ext_hdr = (ip6_hop_by_hop_ext_t *) data_this_buffer;
1252
1253   /* validate really icmp6 next */
1254
1255   if (!(ext_hdr->next_hdr == IP_PROTOCOL_ICMP6)
1256       || (ext_hdr->next_hdr == IP_PROTOCOL_UDP))
1257     return 0;
1258
1259
1260   payload_length_host_byte_order = clib_net_to_host_u16 (ip0->payload_length);
1261   n_bytes_left = n_this_buffer = payload_length_host_byte_order;
1262
1263
1264   u32 n_ip_bytes_this_buffer =
1265     p0->current_length - (((u8 *) ip0 - p0->data) - p0->current_data);
1266   if (n_this_buffer + headers_size > n_ip_bytes_this_buffer)
1267     {
1268       n_this_buffer = p0->current_length > headers_size ?
1269         n_ip_bytes_this_buffer - headers_size : 0;
1270     }
1271
1272   n_bytes_left -= n_this_buffer;
1273   n_bytes_left -= p0->total_length_not_including_first_buffer;
1274
1275   if (n_bytes_left == 0)
1276     return 0;
1277   else
1278     return 1;
1279 }
1280
1281
1282 always_inline uword
1283 ip6_local_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
1284                   vlib_frame_t * frame, int head_of_feature_arc)
1285 {
1286   ip6_main_t *im = &ip6_main;
1287   ip_lookup_main_t *lm = &im->lookup_main;
1288   u32 *from, n_left_from;
1289   vlib_node_runtime_t *error_node =
1290     vlib_node_get_runtime (vm, ip6_input_node.index);
1291   u8 arc_index = vnet_feat_arc_ip6_local.feature_arc_index;
1292   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
1293   u16 nexts[VLIB_FRAME_SIZE], *next;
1294
1295   from = vlib_frame_vector_args (frame);
1296   n_left_from = frame->n_vectors;
1297
1298   if (node->flags & VLIB_NODE_FLAG_TRACE)
1299     ip6_forward_next_trace (vm, node, frame, VLIB_TX);
1300
1301   vlib_get_buffers (vm, from, bufs, n_left_from);
1302   b = bufs;
1303   next = nexts;
1304
1305   while (n_left_from > 2)
1306     {
1307       /* Prefetch next iteration. */
1308       if (n_left_from >= 6)
1309         {
1310           vlib_prefetch_buffer_header (b[4], STORE);
1311           vlib_prefetch_buffer_header (b[5], STORE);
1312           vlib_prefetch_buffer_data (b[2], LOAD);
1313           vlib_prefetch_buffer_data (b[3], LOAD);
1314         }
1315
1316       ip6_error_t error[2];
1317       error[0] = IP6_ERROR_UNKNOWN_PROTOCOL;
1318       error[1] = IP6_ERROR_UNKNOWN_PROTOCOL;
1319
1320       ip6_header_t *ip[2];
1321       ip[0] = vlib_buffer_get_current (b[0]);
1322       ip[1] = vlib_buffer_get_current (b[1]);
1323
1324       if (head_of_feature_arc)
1325         {
1326           vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data;
1327           vnet_buffer (b[1])->l3_hdr_offset = b[1]->current_data;
1328
1329           u8 type[2];
1330           type[0] = lm->builtin_protocol_by_ip_protocol[ip[0]->protocol];
1331           type[1] = lm->builtin_protocol_by_ip_protocol[ip[1]->protocol];
1332
1333           u32 flags[2];
1334           flags[0] = b[0]->flags;
1335           flags[1] = b[1]->flags;
1336
1337           u32 good_l4_csum[2];
1338           good_l4_csum[0] =
1339             flags[0] & (VNET_BUFFER_F_L4_CHECKSUM_CORRECT |
1340                         VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
1341                         VNET_BUFFER_F_OFFLOAD_UDP_CKSUM);
1342           good_l4_csum[1] =
1343             flags[1] & (VNET_BUFFER_F_L4_CHECKSUM_CORRECT |
1344                         VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
1345                         VNET_BUFFER_F_OFFLOAD_UDP_CKSUM);
1346
1347           u32 udp_offset[2] = { };
1348           u8 is_tcp_udp[2];
1349           is_tcp_udp[0] =
1350             ip6_next_proto_is_tcp_udp (b[0], ip[0], &udp_offset[0]);
1351           is_tcp_udp[1] =
1352             ip6_next_proto_is_tcp_udp (b[1], ip[1], &udp_offset[1]);
1353           i16 len_diff[2] = { 0 };
1354           if (PREDICT_TRUE (is_tcp_udp[0]))
1355             {
1356               udp_header_t *udp =
1357                 (udp_header_t *) ((u8 *) ip[0] + udp_offset[0]);
1358               good_l4_csum[0] |= type[0] == IP_BUILTIN_PROTOCOL_UDP
1359                 && udp->checksum == 0;
1360               /* optimistically verify UDP length. */
1361               u16 ip_len, udp_len;
1362               ip_len = clib_net_to_host_u16 (ip[0]->payload_length);
1363               udp_len = clib_net_to_host_u16 (udp->length);
1364               len_diff[0] = ip_len - udp_len;
1365             }
1366           if (PREDICT_TRUE (is_tcp_udp[1]))
1367             {
1368               udp_header_t *udp =
1369                 (udp_header_t *) ((u8 *) ip[1] + udp_offset[1]);
1370               good_l4_csum[1] |= type[1] == IP_BUILTIN_PROTOCOL_UDP
1371                 && udp->checksum == 0;
1372               /* optimistically verify UDP length. */
1373               u16 ip_len, udp_len;
1374               ip_len = clib_net_to_host_u16 (ip[1]->payload_length);
1375               udp_len = clib_net_to_host_u16 (udp->length);
1376               len_diff[1] = ip_len - udp_len;
1377             }
1378
1379           good_l4_csum[0] |= type[0] == IP_BUILTIN_PROTOCOL_UNKNOWN;
1380           good_l4_csum[1] |= type[1] == IP_BUILTIN_PROTOCOL_UNKNOWN;
1381
1382           len_diff[0] = type[0] == IP_BUILTIN_PROTOCOL_UDP ? len_diff[0] : 0;
1383           len_diff[1] = type[1] == IP_BUILTIN_PROTOCOL_UDP ? len_diff[1] : 0;
1384
1385           u8 need_csum[2];
1386           need_csum[0] = type[0] != IP_BUILTIN_PROTOCOL_UNKNOWN
1387             && !good_l4_csum[0]
1388             && !(flags[0] & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
1389           need_csum[1] = type[1] != IP_BUILTIN_PROTOCOL_UNKNOWN
1390             && !good_l4_csum[1]
1391             && !(flags[1] & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
1392           if (PREDICT_FALSE (need_csum[0]))
1393             {
1394               flags[0] = ip6_tcp_udp_icmp_validate_checksum (vm, b[0]);
1395               good_l4_csum[0] = flags[0] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT;
1396               error[0] = IP6_ERROR_UNKNOWN_PROTOCOL;
1397             }
1398           else
1399             {
1400               if (ip6_tcp_udp_icmp_bad_length (vm, b[0]))
1401                 error[0] = IP6_ERROR_BAD_LENGTH;
1402             }
1403           if (PREDICT_FALSE (need_csum[1]))
1404             {
1405               flags[1] = ip6_tcp_udp_icmp_validate_checksum (vm, b[1]);
1406               good_l4_csum[1] = flags[1] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT;
1407               error[1] = IP6_ERROR_UNKNOWN_PROTOCOL;
1408             }
1409           else
1410             {
1411               if (ip6_tcp_udp_icmp_bad_length (vm, b[1]))
1412                 error[1] = IP6_ERROR_BAD_LENGTH;
1413             }
1414
1415
1416           error[0] = len_diff[0] < 0 ? IP6_ERROR_UDP_LENGTH : error[0];
1417
1418           error[1] = len_diff[1] < 0 ? IP6_ERROR_UDP_LENGTH : error[1];
1419
1420           STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_UDP ==
1421                          IP6_ERROR_UDP_CHECKSUM,
1422                          "Wrong IP6 errors constants");
1423           STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_ICMP ==
1424                          IP6_ERROR_ICMP_CHECKSUM,
1425                          "Wrong IP6 errors constants");
1426
1427           error[0] =
1428             !good_l4_csum[0] ? IP6_ERROR_UDP_CHECKSUM + type[0] : error[0];
1429           error[1] =
1430             !good_l4_csum[1] ? IP6_ERROR_UDP_CHECKSUM + type[1] : error[1];
1431
1432           /* Drop packets from unroutable hosts. */
1433           /* If this is a neighbor solicitation (ICMP), skip source RPF check */
1434           u8 unroutable[2];
1435           unroutable[0] = error[0] == IP6_ERROR_UNKNOWN_PROTOCOL
1436             && type[0] != IP_BUILTIN_PROTOCOL_ICMP
1437             && !ip6_address_is_link_local_unicast (&ip[0]->src_address);
1438           unroutable[1] = error[1] == IP6_ERROR_UNKNOWN_PROTOCOL
1439             && type[1] != IP_BUILTIN_PROTOCOL_ICMP
1440             && !ip6_address_is_link_local_unicast (&ip[1]->src_address);
1441           if (PREDICT_FALSE (unroutable[0]))
1442             {
1443               error[0] =
1444                 !ip6_urpf_loose_check (im, b[0],
1445                                        ip[0]) ? IP6_ERROR_SRC_LOOKUP_MISS
1446                 : error[0];
1447             }
1448           if (PREDICT_FALSE (unroutable[1]))
1449             {
1450               error[1] =
1451                 !ip6_urpf_loose_check (im, b[1],
1452                                        ip[1]) ? IP6_ERROR_SRC_LOOKUP_MISS
1453                 : error[1];
1454             }
1455
1456           vnet_buffer (b[0])->ip.fib_index =
1457             vnet_buffer (b[0])->sw_if_index[VLIB_TX] != ~0 ?
1458             vnet_buffer (b[0])->sw_if_index[VLIB_TX] :
1459             vnet_buffer (b[0])->ip.fib_index;
1460           vnet_buffer (b[1])->ip.fib_index =
1461             vnet_buffer (b[1])->sw_if_index[VLIB_TX] != ~0 ?
1462             vnet_buffer (b[1])->sw_if_index[VLIB_TX] :
1463             vnet_buffer (b[1])->ip.fib_index;
1464         }                       /* head_of_feature_arc */
1465
1466       next[0] = lm->local_next_by_ip_protocol[ip[0]->protocol];
1467       next[0] =
1468         error[0] != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next[0];
1469       next[1] = lm->local_next_by_ip_protocol[ip[1]->protocol];
1470       next[1] =
1471         error[1] != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next[1];
1472
1473       b[0]->error = error_node->errors[error[0]];
1474       b[1]->error = error_node->errors[error[1]];
1475
1476       if (head_of_feature_arc)
1477         {
1478           u8 ip6_unknown[2];
1479           ip6_unknown[0] = error[0] == (u8) IP6_ERROR_UNKNOWN_PROTOCOL;
1480           ip6_unknown[1] = error[1] == (u8) IP6_ERROR_UNKNOWN_PROTOCOL;
1481           if (PREDICT_TRUE (ip6_unknown[0]))
1482             {
1483               u32 next32 = next[0];
1484               vnet_feature_arc_start (arc_index,
1485                                       vnet_buffer (b[0])->sw_if_index
1486                                       [VLIB_RX], &next32, b[0]);
1487               next[0] = next32;
1488             }
1489           if (PREDICT_TRUE (ip6_unknown[1]))
1490             {
1491               u32 next32 = next[1];
1492               vnet_feature_arc_start (arc_index,
1493                                       vnet_buffer (b[1])->sw_if_index
1494                                       [VLIB_RX], &next32, b[1]);
1495               next[1] = next32;
1496             }
1497         }
1498
1499       /* next */
1500       b += 2;
1501       next += 2;
1502       n_left_from -= 2;
1503     }
1504
1505   while (n_left_from)
1506     {
1507       u8 error;
1508       error = IP6_ERROR_UNKNOWN_PROTOCOL;
1509
1510       ip6_header_t *ip;
1511       ip = vlib_buffer_get_current (b[0]);
1512
1513       if (head_of_feature_arc)
1514         {
1515           vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data;
1516           u8 type = lm->builtin_protocol_by_ip_protocol[ip->protocol];
1517
1518           u32 flags = b[0]->flags;
1519           u32 good_l4_csum =
1520             flags & (VNET_BUFFER_F_L4_CHECKSUM_CORRECT |
1521                      VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
1522                      VNET_BUFFER_F_OFFLOAD_UDP_CKSUM);
1523
1524           u32 udp_offset;
1525           i16 len_diff = 0;
1526           u8 is_tcp_udp = ip6_next_proto_is_tcp_udp (b[0], ip, &udp_offset);
1527           if (PREDICT_TRUE (is_tcp_udp))
1528             {
1529               udp_header_t *udp = (udp_header_t *) ((u8 *) ip + udp_offset);
1530               /* Don't verify UDP checksum for packets with explicit zero checksum. */
1531               good_l4_csum |= type == IP_BUILTIN_PROTOCOL_UDP
1532                 && udp->checksum == 0;
1533               /* optimistically verify UDP length. */
1534               u16 ip_len, udp_len;
1535               ip_len = clib_net_to_host_u16 (ip->payload_length);
1536               udp_len = clib_net_to_host_u16 (udp->length);
1537               len_diff = ip_len - udp_len;
1538             }
1539
1540           good_l4_csum |= type == IP_BUILTIN_PROTOCOL_UNKNOWN;
1541           len_diff = type == IP_BUILTIN_PROTOCOL_UDP ? len_diff : 0;
1542
1543           u8 need_csum = type != IP_BUILTIN_PROTOCOL_UNKNOWN && !good_l4_csum
1544             && !(flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
1545           if (PREDICT_FALSE (need_csum))
1546             {
1547               flags = ip6_tcp_udp_icmp_validate_checksum (vm, b[0]);
1548               good_l4_csum = flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT;
1549               error = IP6_ERROR_UNKNOWN_PROTOCOL;
1550             }
1551           else
1552             {
1553               if (ip6_tcp_udp_icmp_bad_length (vm, b[0]))
1554                 error = IP6_ERROR_BAD_LENGTH;
1555             }
1556
1557
1558
1559           error = len_diff < 0 ? IP6_ERROR_UDP_LENGTH : error;
1560
1561           STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_UDP ==
1562                          IP6_ERROR_UDP_CHECKSUM,
1563                          "Wrong IP6 errors constants");
1564           STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_ICMP ==
1565                          IP6_ERROR_ICMP_CHECKSUM,
1566                          "Wrong IP6 errors constants");
1567
1568           error = !good_l4_csum ? IP6_ERROR_UDP_CHECKSUM + type : error;
1569
1570           /* Drop packets from unroutable hosts. */
1571           /* If this is a neighbor solicitation (ICMP), skip source RPF check */
1572           u8 unroutable = error == IP6_ERROR_UNKNOWN_PROTOCOL
1573             && type != IP_BUILTIN_PROTOCOL_ICMP
1574             && !ip6_address_is_link_local_unicast (&ip->src_address);
1575           if (PREDICT_FALSE (unroutable))
1576             {
1577               error =
1578                 !ip6_urpf_loose_check (im, b[0],
1579                                        ip) ? IP6_ERROR_SRC_LOOKUP_MISS :
1580                 error;
1581             }
1582
1583           vnet_buffer (b[0])->ip.fib_index =
1584             vnet_buffer (b[0])->sw_if_index[VLIB_TX] != ~0 ?
1585             vnet_buffer (b[0])->sw_if_index[VLIB_TX] :
1586             vnet_buffer (b[0])->ip.fib_index;
1587         }                       /* head_of_feature_arc */
1588
1589       next[0] = lm->local_next_by_ip_protocol[ip->protocol];
1590       next[0] =
1591         error != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next[0];
1592
1593       b[0]->error = error_node->errors[error];
1594
1595       if (head_of_feature_arc)
1596         {
1597           if (PREDICT_TRUE (error == (u8) IP6_ERROR_UNKNOWN_PROTOCOL))
1598             {
1599               u32 next32 = next[0];
1600               vnet_feature_arc_start (arc_index,
1601                                       vnet_buffer (b[0])->sw_if_index
1602                                       [VLIB_RX], &next32, b[0]);
1603               next[0] = next32;
1604             }
1605         }
1606
1607       /* next */
1608       b += 1;
1609       next += 1;
1610       n_left_from -= 1;
1611     }
1612
1613   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
1614   return frame->n_vectors;
1615 }
1616
1617 VLIB_NODE_FN (ip6_local_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
1618                                vlib_frame_t * frame)
1619 {
1620   return ip6_local_inline (vm, node, frame, 1 /* head of feature arc */ );
1621 }
1622
1623 /* *INDENT-OFF* */
1624 VLIB_REGISTER_NODE (ip6_local_node) =
1625 {
1626   .name = "ip6-local",
1627   .vector_size = sizeof (u32),
1628   .format_trace = format_ip6_forward_next_trace,
1629   .n_next_nodes = IP_LOCAL_N_NEXT,
1630   .next_nodes =
1631   {
1632     [IP_LOCAL_NEXT_DROP] = "ip6-drop",
1633     [IP_LOCAL_NEXT_PUNT] = "ip6-punt",
1634     [IP_LOCAL_NEXT_UDP_LOOKUP] = "ip6-udp-lookup",
1635     [IP_LOCAL_NEXT_ICMP] = "ip6-icmp-input",
1636     [IP_LOCAL_NEXT_REASSEMBLY] = "ip6-full-reassembly",
1637   },
1638 };
1639 /* *INDENT-ON* */
1640
1641 VLIB_NODE_FN (ip6_local_end_of_arc_node) (vlib_main_t * vm,
1642                                           vlib_node_runtime_t * node,
1643                                           vlib_frame_t * frame)
1644 {
1645   return ip6_local_inline (vm, node, frame, 0 /* head of feature arc */ );
1646 }
1647
1648 /* *INDENT-OFF* */
1649 VLIB_REGISTER_NODE (ip6_local_end_of_arc_node) = {
1650   .name = "ip6-local-end-of-arc",
1651   .vector_size = sizeof (u32),
1652
1653   .format_trace = format_ip6_forward_next_trace,
1654   .sibling_of = "ip6-local",
1655 };
1656
1657 VNET_FEATURE_INIT (ip6_local_end_of_arc, static) = {
1658   .arc_name = "ip6-local",
1659   .node_name = "ip6-local-end-of-arc",
1660   .runs_before = 0, /* not before any other features */
1661 };
1662 /* *INDENT-ON* */
1663
1664 #ifdef CLIB_MARCH_VARIANT
1665 extern vlib_node_registration_t ip6_local_node;
1666 #else
1667 void
1668 ip6_register_protocol (u32 protocol, u32 node_index)
1669 {
1670   vlib_main_t *vm = vlib_get_main ();
1671   ip6_main_t *im = &ip6_main;
1672   ip_lookup_main_t *lm = &im->lookup_main;
1673
1674   ASSERT (protocol < ARRAY_LEN (lm->local_next_by_ip_protocol));
1675   lm->local_next_by_ip_protocol[protocol] =
1676     vlib_node_add_next (vm, ip6_local_node.index, node_index);
1677 }
1678
1679 void
1680 ip6_unregister_protocol (u32 protocol)
1681 {
1682   ip6_main_t *im = &ip6_main;
1683   ip_lookup_main_t *lm = &im->lookup_main;
1684
1685   ASSERT (protocol < ARRAY_LEN (lm->local_next_by_ip_protocol));
1686   lm->local_next_by_ip_protocol[protocol] = IP_LOCAL_NEXT_PUNT;
1687 }
1688 #endif
1689
1690 typedef enum
1691 {
1692   IP6_REWRITE_NEXT_DROP,
1693   IP6_REWRITE_NEXT_ICMP_ERROR,
1694   IP6_REWRITE_NEXT_FRAGMENT,
1695   IP6_REWRITE_N_NEXT            /* Last */
1696 } ip6_rewrite_next_t;
1697
1698 /**
1699  * This bits of an IPv6 address to mask to construct a multicast
1700  * MAC address
1701  */
1702 #define IP6_MCAST_ADDR_MASK 0xffffffff
1703
1704 always_inline void
1705 ip6_mtu_check (vlib_buffer_t * b, u16 packet_bytes,
1706                u16 adj_packet_bytes, bool is_locally_generated,
1707                u32 * next, u8 is_midchain, u32 * error)
1708 {
1709   if (adj_packet_bytes >= 1280 && packet_bytes > adj_packet_bytes)
1710     {
1711       if (is_locally_generated)
1712         {
1713           /* IP fragmentation */
1714           ip_frag_set_vnet_buffer (b, adj_packet_bytes,
1715                                    (is_midchain ?
1716                                     IP_FRAG_NEXT_IP_REWRITE_MIDCHAIN :
1717                                     IP_FRAG_NEXT_IP_REWRITE), 0);
1718           *next = IP6_REWRITE_NEXT_FRAGMENT;
1719           *error = IP6_ERROR_MTU_EXCEEDED;
1720         }
1721       else
1722         {
1723           *error = IP6_ERROR_MTU_EXCEEDED;
1724           icmp6_error_set_vnet_buffer (b, ICMP6_packet_too_big, 0,
1725                                        adj_packet_bytes);
1726           *next = IP6_REWRITE_NEXT_ICMP_ERROR;
1727         }
1728     }
1729 }
1730
1731 always_inline uword
1732 ip6_rewrite_inline_with_gso (vlib_main_t * vm,
1733                              vlib_node_runtime_t * node,
1734                              vlib_frame_t * frame,
1735                              int do_counters, int is_midchain, int is_mcast)
1736 {
1737   ip_lookup_main_t *lm = &ip6_main.lookup_main;
1738   u32 *from = vlib_frame_vector_args (frame);
1739   u32 n_left_from, n_left_to_next, *to_next, next_index;
1740   vlib_node_runtime_t *error_node =
1741     vlib_node_get_runtime (vm, ip6_input_node.index);
1742
1743   n_left_from = frame->n_vectors;
1744   next_index = node->cached_next_index;
1745   u32 thread_index = vm->thread_index;
1746
1747   while (n_left_from > 0)
1748     {
1749       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1750
1751       while (n_left_from >= 4 && n_left_to_next >= 2)
1752         {
1753           const ip_adjacency_t *adj0, *adj1;
1754           vlib_buffer_t *p0, *p1;
1755           ip6_header_t *ip0, *ip1;
1756           u32 pi0, rw_len0, next0, error0, adj_index0;
1757           u32 pi1, rw_len1, next1, error1, adj_index1;
1758           u32 tx_sw_if_index0, tx_sw_if_index1;
1759           bool is_locally_originated0, is_locally_originated1;
1760
1761           /* Prefetch next iteration. */
1762           {
1763             vlib_buffer_t *p2, *p3;
1764
1765             p2 = vlib_get_buffer (vm, from[2]);
1766             p3 = vlib_get_buffer (vm, from[3]);
1767
1768             vlib_prefetch_buffer_header (p2, LOAD);
1769             vlib_prefetch_buffer_header (p3, LOAD);
1770
1771             CLIB_PREFETCH (p2->pre_data, 32, STORE);
1772             CLIB_PREFETCH (p3->pre_data, 32, STORE);
1773
1774             CLIB_PREFETCH (p2->data, sizeof (ip0[0]), STORE);
1775             CLIB_PREFETCH (p3->data, sizeof (ip0[0]), STORE);
1776           }
1777
1778           pi0 = to_next[0] = from[0];
1779           pi1 = to_next[1] = from[1];
1780
1781           from += 2;
1782           n_left_from -= 2;
1783           to_next += 2;
1784           n_left_to_next -= 2;
1785
1786           p0 = vlib_get_buffer (vm, pi0);
1787           p1 = vlib_get_buffer (vm, pi1);
1788
1789           adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
1790           adj_index1 = vnet_buffer (p1)->ip.adj_index[VLIB_TX];
1791
1792           ip0 = vlib_buffer_get_current (p0);
1793           ip1 = vlib_buffer_get_current (p1);
1794
1795           error0 = error1 = IP6_ERROR_NONE;
1796           next0 = next1 = IP6_REWRITE_NEXT_DROP;
1797
1798           is_locally_originated0 =
1799             p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED;
1800           if (PREDICT_TRUE (!is_locally_originated0))
1801             {
1802               i32 hop_limit0 = ip0->hop_limit;
1803
1804               /* Input node should have reject packets with hop limit 0. */
1805               ASSERT (ip0->hop_limit > 0);
1806
1807               hop_limit0 -= 1;
1808
1809               ip0->hop_limit = hop_limit0;
1810
1811               /*
1812                * If the hop count drops below 1 when forwarding, generate
1813                * an ICMP response.
1814                */
1815               if (PREDICT_FALSE (hop_limit0 <= 0))
1816                 {
1817                   error0 = IP6_ERROR_TIME_EXPIRED;
1818                   next0 = IP6_REWRITE_NEXT_ICMP_ERROR;
1819                   vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
1820                   icmp6_error_set_vnet_buffer (p0, ICMP6_time_exceeded,
1821                                                ICMP6_time_exceeded_ttl_exceeded_in_transit,
1822                                                0);
1823                 }
1824             }
1825
1826           is_locally_originated1 =
1827             p1->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED;
1828           if (PREDICT_TRUE (!is_locally_originated1))
1829             {
1830               i32 hop_limit1 = ip1->hop_limit;
1831
1832               /* Input node should have reject packets with hop limit 0. */
1833               ASSERT (ip1->hop_limit > 0);
1834
1835               hop_limit1 -= 1;
1836
1837               ip1->hop_limit = hop_limit1;
1838
1839               /*
1840                * If the hop count drops below 1 when forwarding, generate
1841                * an ICMP response.
1842                */
1843               if (PREDICT_FALSE (hop_limit1 <= 0))
1844                 {
1845                   error1 = IP6_ERROR_TIME_EXPIRED;
1846                   next1 = IP6_REWRITE_NEXT_ICMP_ERROR;
1847                   vnet_buffer (p1)->sw_if_index[VLIB_TX] = (u32) ~ 0;
1848                   icmp6_error_set_vnet_buffer (p1, ICMP6_time_exceeded,
1849                                                ICMP6_time_exceeded_ttl_exceeded_in_transit,
1850                                                0);
1851                 }
1852             }
1853
1854           adj0 = adj_get (adj_index0);
1855           adj1 = adj_get (adj_index1);
1856
1857           rw_len0 = adj0[0].rewrite_header.data_bytes;
1858           rw_len1 = adj1[0].rewrite_header.data_bytes;
1859           vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
1860           vnet_buffer (p1)->ip.save_rewrite_length = rw_len1;
1861
1862           if (do_counters)
1863             {
1864               vlib_increment_combined_counter
1865                 (&adjacency_counters,
1866                  thread_index, adj_index0, 1,
1867                  vlib_buffer_length_in_chain (vm, p0) + rw_len0);
1868               vlib_increment_combined_counter
1869                 (&adjacency_counters,
1870                  thread_index, adj_index1, 1,
1871                  vlib_buffer_length_in_chain (vm, p1) + rw_len1);
1872             }
1873
1874           /* Check MTU of outgoing interface. */
1875           u16 ip0_len =
1876             clib_net_to_host_u16 (ip0->payload_length) +
1877             sizeof (ip6_header_t);
1878           u16 ip1_len =
1879             clib_net_to_host_u16 (ip1->payload_length) +
1880             sizeof (ip6_header_t);
1881           if (p0->flags & VNET_BUFFER_F_GSO)
1882             ip0_len = gso_mtu_sz (p0);
1883           if (p1->flags & VNET_BUFFER_F_GSO)
1884             ip1_len = gso_mtu_sz (p1);
1885
1886
1887
1888           ip6_mtu_check (p0, ip0_len,
1889                          adj0[0].rewrite_header.max_l3_packet_bytes,
1890                          is_locally_originated0, &next0, is_midchain,
1891                          &error0);
1892           ip6_mtu_check (p1, ip1_len,
1893                          adj1[0].rewrite_header.max_l3_packet_bytes,
1894                          is_locally_originated1, &next1, is_midchain,
1895                          &error1);
1896
1897           /* Don't adjust the buffer for hop count issue; icmp-error node
1898            * wants to see the IP header */
1899           if (PREDICT_TRUE (error0 == IP6_ERROR_NONE))
1900             {
1901               p0->current_data -= rw_len0;
1902               p0->current_length += rw_len0;
1903
1904               tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
1905               vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0;
1906               next0 = adj0[0].rewrite_header.next_index;
1907
1908               if (PREDICT_FALSE
1909                   (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
1910                 vnet_feature_arc_start_w_cfg_index
1911                   (lm->output_feature_arc_index, tx_sw_if_index0, &next0, p0,
1912                    adj0->ia_cfg_index);
1913             }
1914           else
1915             {
1916               p0->error = error_node->errors[error0];
1917             }
1918           if (PREDICT_TRUE (error1 == IP6_ERROR_NONE))
1919             {
1920               p1->current_data -= rw_len1;
1921               p1->current_length += rw_len1;
1922
1923               tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index;
1924               vnet_buffer (p1)->sw_if_index[VLIB_TX] = tx_sw_if_index1;
1925               next1 = adj1[0].rewrite_header.next_index;
1926
1927               if (PREDICT_FALSE
1928                   (adj1[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
1929                 vnet_feature_arc_start_w_cfg_index
1930                   (lm->output_feature_arc_index, tx_sw_if_index1, &next1, p1,
1931                    adj1->ia_cfg_index);
1932             }
1933           else
1934             {
1935               p1->error = error_node->errors[error1];
1936             }
1937
1938           if (is_midchain)
1939             {
1940               /* before we paint on the next header, update the L4
1941                * checksums if required, since there's no offload on a tunnel */
1942               vnet_calc_checksums_inline (vm, p0, 0 /* is_ip4 */ ,
1943                                           1 /* is_ip6 */ );
1944               vnet_calc_checksums_inline (vm, p1, 0 /* is_ip4 */ ,
1945                                           1 /* is_ip6 */ );
1946
1947               /* Guess we are only writing on ipv6 header. */
1948               vnet_rewrite_two_headers (adj0[0], adj1[0],
1949                                         ip0, ip1, sizeof (ip6_header_t));
1950             }
1951           else
1952             /* Guess we are only writing on simple Ethernet header. */
1953             vnet_rewrite_two_headers (adj0[0], adj1[0],
1954                                       ip0, ip1, sizeof (ethernet_header_t));
1955
1956           if (is_midchain)
1957             {
1958               if (adj0->sub_type.midchain.fixup_func)
1959                 adj0->sub_type.midchain.fixup_func
1960                   (vm, adj0, p0, adj0->sub_type.midchain.fixup_data);
1961               if (adj1->sub_type.midchain.fixup_func)
1962                 adj1->sub_type.midchain.fixup_func
1963                   (vm, adj1, p1, adj1->sub_type.midchain.fixup_data);
1964             }
1965           if (is_mcast)
1966             {
1967               /*
1968                * copy bytes from the IP address into the MAC rewrite
1969                */
1970               vnet_ip_mcast_fixup_header (IP6_MCAST_ADDR_MASK,
1971                                           adj0->
1972                                           rewrite_header.dst_mcast_offset,
1973                                           &ip0->dst_address.as_u32[3],
1974                                           (u8 *) ip0);
1975               vnet_ip_mcast_fixup_header (IP6_MCAST_ADDR_MASK,
1976                                           adj1->
1977                                           rewrite_header.dst_mcast_offset,
1978                                           &ip1->dst_address.as_u32[3],
1979                                           (u8 *) ip1);
1980             }
1981
1982           vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
1983                                            to_next, n_left_to_next,
1984                                            pi0, pi1, next0, next1);
1985         }
1986
1987       while (n_left_from > 0 && n_left_to_next > 0)
1988         {
1989           ip_adjacency_t *adj0;
1990           vlib_buffer_t *p0;
1991           ip6_header_t *ip0;
1992           u32 pi0, rw_len0;
1993           u32 adj_index0, next0, error0;
1994           u32 tx_sw_if_index0;
1995           bool is_locally_originated0;
1996
1997           pi0 = to_next[0] = from[0];
1998
1999           p0 = vlib_get_buffer (vm, pi0);
2000
2001           adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
2002
2003           adj0 = adj_get (adj_index0);
2004
2005           ip0 = vlib_buffer_get_current (p0);
2006
2007           error0 = IP6_ERROR_NONE;
2008           next0 = IP6_REWRITE_NEXT_DROP;
2009
2010           /* Check hop limit */
2011           is_locally_originated0 =
2012             p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED;
2013           if (PREDICT_TRUE (!is_locally_originated0))
2014             {
2015               i32 hop_limit0 = ip0->hop_limit;
2016
2017               ASSERT (ip0->hop_limit > 0);
2018
2019               hop_limit0 -= 1;
2020
2021               ip0->hop_limit = hop_limit0;
2022
2023               if (PREDICT_FALSE (hop_limit0 <= 0))
2024                 {
2025                   /*
2026                    * If the hop count drops below 1 when forwarding, generate
2027                    * an ICMP response.
2028                    */
2029                   error0 = IP6_ERROR_TIME_EXPIRED;
2030                   next0 = IP6_REWRITE_NEXT_ICMP_ERROR;
2031                   vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
2032                   icmp6_error_set_vnet_buffer (p0, ICMP6_time_exceeded,
2033                                                ICMP6_time_exceeded_ttl_exceeded_in_transit,
2034                                                0);
2035                 }
2036             }
2037
2038           if (is_midchain)
2039             {
2040               vnet_calc_checksums_inline (vm, p0, 0 /* is_ip4 */ ,
2041                                           1 /* is_ip6 */ );
2042
2043               /* Guess we are only writing on ip6 header. */
2044               vnet_rewrite_one_header (adj0[0], ip0, sizeof (ip6_header_t));
2045             }
2046           else
2047             /* Guess we are only writing on simple Ethernet header. */
2048             vnet_rewrite_one_header (adj0[0], ip0,
2049                                      sizeof (ethernet_header_t));
2050
2051           /* Update packet buffer attributes/set output interface. */
2052           rw_len0 = adj0[0].rewrite_header.data_bytes;
2053           vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2054
2055           if (do_counters)
2056             {
2057               vlib_increment_combined_counter
2058                 (&adjacency_counters,
2059                  thread_index, adj_index0, 1,
2060                  vlib_buffer_length_in_chain (vm, p0) + rw_len0);
2061             }
2062
2063           /* Check MTU of outgoing interface. */
2064           u16 ip0_len =
2065             clib_net_to_host_u16 (ip0->payload_length) +
2066             sizeof (ip6_header_t);
2067           if (p0->flags & VNET_BUFFER_F_GSO)
2068             ip0_len = gso_mtu_sz (p0);
2069
2070           ip6_mtu_check (p0, ip0_len,
2071                          adj0[0].rewrite_header.max_l3_packet_bytes,
2072                          is_locally_originated0, &next0, is_midchain,
2073                          &error0);
2074
2075           /* Don't adjust the buffer for hop count issue; icmp-error node
2076            * wants to see the IP header */
2077           if (PREDICT_TRUE (error0 == IP6_ERROR_NONE))
2078             {
2079               p0->current_data -= rw_len0;
2080               p0->current_length += rw_len0;
2081
2082               tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2083
2084               vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0;
2085               next0 = adj0[0].rewrite_header.next_index;
2086
2087               if (PREDICT_FALSE
2088                   (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2089                 vnet_feature_arc_start_w_cfg_index
2090                   (lm->output_feature_arc_index, tx_sw_if_index0, &next0, p0,
2091                    adj0->ia_cfg_index);
2092             }
2093           else
2094             {
2095               p0->error = error_node->errors[error0];
2096             }
2097
2098           if (is_midchain)
2099             {
2100               if (adj0->sub_type.midchain.fixup_func)
2101                 adj0->sub_type.midchain.fixup_func
2102                   (vm, adj0, p0, adj0->sub_type.midchain.fixup_data);
2103             }
2104           if (is_mcast)
2105             {
2106               vnet_ip_mcast_fixup_header (IP6_MCAST_ADDR_MASK,
2107                                           adj0->
2108                                           rewrite_header.dst_mcast_offset,
2109                                           &ip0->dst_address.as_u32[3],
2110                                           (u8 *) ip0);
2111             }
2112
2113           from += 1;
2114           n_left_from -= 1;
2115           to_next += 1;
2116           n_left_to_next -= 1;
2117
2118           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2119                                            to_next, n_left_to_next,
2120                                            pi0, next0);
2121         }
2122
2123       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2124     }
2125
2126   /* Need to do trace after rewrites to pick up new packet data. */
2127   if (node->flags & VLIB_NODE_FLAG_TRACE)
2128     ip6_forward_next_trace (vm, node, frame, VLIB_TX);
2129
2130   return frame->n_vectors;
2131 }
2132
2133 always_inline uword
2134 ip6_rewrite_inline (vlib_main_t * vm,
2135                     vlib_node_runtime_t * node,
2136                     vlib_frame_t * frame,
2137                     int do_counters, int is_midchain, int is_mcast)
2138 {
2139   return ip6_rewrite_inline_with_gso (vm, node, frame, do_counters,
2140                                       is_midchain, is_mcast);
2141 }
2142
2143 VLIB_NODE_FN (ip6_rewrite_node) (vlib_main_t * vm,
2144                                  vlib_node_runtime_t * node,
2145                                  vlib_frame_t * frame)
2146 {
2147   if (adj_are_counters_enabled ())
2148     return ip6_rewrite_inline (vm, node, frame, 1, 0, 0);
2149   else
2150     return ip6_rewrite_inline (vm, node, frame, 0, 0, 0);
2151 }
2152
2153 VLIB_NODE_FN (ip6_rewrite_bcast_node) (vlib_main_t * vm,
2154                                        vlib_node_runtime_t * node,
2155                                        vlib_frame_t * frame)
2156 {
2157   if (adj_are_counters_enabled ())
2158     return ip6_rewrite_inline (vm, node, frame, 1, 0, 0);
2159   else
2160     return ip6_rewrite_inline (vm, node, frame, 0, 0, 0);
2161 }
2162
2163 VLIB_NODE_FN (ip6_rewrite_mcast_node) (vlib_main_t * vm,
2164                                        vlib_node_runtime_t * node,
2165                                        vlib_frame_t * frame)
2166 {
2167   if (adj_are_counters_enabled ())
2168     return ip6_rewrite_inline (vm, node, frame, 1, 0, 1);
2169   else
2170     return ip6_rewrite_inline (vm, node, frame, 0, 0, 1);
2171 }
2172
2173 VLIB_NODE_FN (ip6_midchain_node) (vlib_main_t * vm,
2174                                   vlib_node_runtime_t * node,
2175                                   vlib_frame_t * frame)
2176 {
2177   if (adj_are_counters_enabled ())
2178     return ip6_rewrite_inline (vm, node, frame, 1, 1, 0);
2179   else
2180     return ip6_rewrite_inline (vm, node, frame, 0, 1, 0);
2181 }
2182
2183 VLIB_NODE_FN (ip6_mcast_midchain_node) (vlib_main_t * vm,
2184                                         vlib_node_runtime_t * node,
2185                                         vlib_frame_t * frame)
2186 {
2187   if (adj_are_counters_enabled ())
2188     return ip6_rewrite_inline (vm, node, frame, 1, 1, 1);
2189   else
2190     return ip6_rewrite_inline (vm, node, frame, 0, 1, 1);
2191 }
2192
2193 /* *INDENT-OFF* */
2194 VLIB_REGISTER_NODE (ip6_midchain_node) =
2195 {
2196   .name = "ip6-midchain",
2197   .vector_size = sizeof (u32),
2198   .format_trace = format_ip6_forward_next_trace,
2199   .sibling_of = "ip6-rewrite",
2200   };
2201
2202 VLIB_REGISTER_NODE (ip6_rewrite_node) =
2203 {
2204   .name = "ip6-rewrite",
2205   .vector_size = sizeof (u32),
2206   .format_trace = format_ip6_rewrite_trace,
2207   .n_next_nodes = IP6_REWRITE_N_NEXT,
2208   .next_nodes =
2209   {
2210     [IP6_REWRITE_NEXT_DROP] = "ip6-drop",
2211     [IP6_REWRITE_NEXT_ICMP_ERROR] = "ip6-icmp-error",
2212     [IP6_REWRITE_NEXT_FRAGMENT] = "ip6-frag",
2213   },
2214 };
2215
2216 VLIB_REGISTER_NODE (ip6_rewrite_bcast_node) = {
2217   .name = "ip6-rewrite-bcast",
2218   .vector_size = sizeof (u32),
2219
2220   .format_trace = format_ip6_rewrite_trace,
2221   .sibling_of = "ip6-rewrite",
2222 };
2223
2224 VLIB_REGISTER_NODE (ip6_rewrite_mcast_node) =
2225 {
2226   .name = "ip6-rewrite-mcast",
2227   .vector_size = sizeof (u32),
2228   .format_trace = format_ip6_rewrite_trace,
2229   .sibling_of = "ip6-rewrite",
2230 };
2231
2232
2233 VLIB_REGISTER_NODE (ip6_mcast_midchain_node) =
2234 {
2235   .name = "ip6-mcast-midchain",
2236   .vector_size = sizeof (u32),
2237   .format_trace = format_ip6_rewrite_trace,
2238   .sibling_of = "ip6-rewrite",
2239 };
2240
2241 /* *INDENT-ON* */
2242
2243 /*
2244  * Hop-by-Hop handling
2245  */
2246 #ifndef CLIB_MARCH_VARIANT
2247 ip6_hop_by_hop_main_t ip6_hop_by_hop_main;
2248 #endif /* CLIB_MARCH_VARIANT */
2249
2250 #define foreach_ip6_hop_by_hop_error \
2251 _(PROCESSED, "pkts with ip6 hop-by-hop options") \
2252 _(FORMAT, "incorrectly formatted hop-by-hop options") \
2253 _(UNKNOWN_OPTION, "unknown ip6 hop-by-hop options")
2254
2255 /* *INDENT-OFF* */
2256 typedef enum
2257 {
2258 #define _(sym,str) IP6_HOP_BY_HOP_ERROR_##sym,
2259   foreach_ip6_hop_by_hop_error
2260 #undef _
2261   IP6_HOP_BY_HOP_N_ERROR,
2262 } ip6_hop_by_hop_error_t;
2263 /* *INDENT-ON* */
2264
2265 /*
2266  * Primary h-b-h handler trace support
2267  * We work pretty hard on the problem for obvious reasons
2268  */
2269 typedef struct
2270 {
2271   u32 next_index;
2272   u32 trace_len;
2273   u8 option_data[256];
2274 } ip6_hop_by_hop_trace_t;
2275
2276 extern vlib_node_registration_t ip6_hop_by_hop_node;
2277
2278 static char *ip6_hop_by_hop_error_strings[] = {
2279 #define _(sym,string) string,
2280   foreach_ip6_hop_by_hop_error
2281 #undef _
2282 };
2283
2284 #ifndef CLIB_MARCH_VARIANT
2285 u8 *
2286 format_ip6_hop_by_hop_ext_hdr (u8 * s, va_list * args)
2287 {
2288   ip6_hop_by_hop_header_t *hbh0 = va_arg (*args, ip6_hop_by_hop_header_t *);
2289   int total_len = va_arg (*args, int);
2290   ip6_hop_by_hop_option_t *opt0, *limit0;
2291   ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main;
2292   u8 type0;
2293
2294   s = format (s, "IP6_HOP_BY_HOP: next protocol %d len %d total %d",
2295               hbh0->protocol, (hbh0->length + 1) << 3, total_len);
2296
2297   opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1);
2298   limit0 = (ip6_hop_by_hop_option_t *) ((u8 *) hbh0 + total_len);
2299
2300   while (opt0 < limit0)
2301     {
2302       type0 = opt0->type;
2303       switch (type0)
2304         {
2305         case 0:         /* Pad, just stop */
2306           opt0 = (ip6_hop_by_hop_option_t *) ((u8 *) opt0 + 1);
2307           break;
2308
2309         default:
2310           if (hm->trace[type0])
2311             {
2312               s = (*hm->trace[type0]) (s, opt0);
2313             }
2314           else
2315             {
2316               s =
2317                 format (s, "\n    unrecognized option %d length %d", type0,
2318                         opt0->length);
2319             }
2320           opt0 =
2321             (ip6_hop_by_hop_option_t *) (((u8 *) opt0) + opt0->length +
2322                                          sizeof (ip6_hop_by_hop_option_t));
2323           break;
2324         }
2325     }
2326   return s;
2327 }
2328 #endif
2329
2330 static u8 *
2331 format_ip6_hop_by_hop_trace (u8 * s, va_list * args)
2332 {
2333   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
2334   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
2335   ip6_hop_by_hop_trace_t *t = va_arg (*args, ip6_hop_by_hop_trace_t *);
2336   ip6_hop_by_hop_header_t *hbh0;
2337   ip6_hop_by_hop_option_t *opt0, *limit0;
2338   ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main;
2339
2340   u8 type0;
2341
2342   hbh0 = (ip6_hop_by_hop_header_t *) t->option_data;
2343
2344   s = format (s, "IP6_HOP_BY_HOP: next index %d len %d traced %d",
2345               t->next_index, (hbh0->length + 1) << 3, t->trace_len);
2346
2347   opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1);
2348   limit0 = (ip6_hop_by_hop_option_t *) ((u8 *) hbh0) + t->trace_len;
2349
2350   while (opt0 < limit0)
2351     {
2352       type0 = opt0->type;
2353       switch (type0)
2354         {
2355         case 0:         /* Pad, just stop */
2356           opt0 = (ip6_hop_by_hop_option_t *) ((u8 *) opt0) + 1;
2357           break;
2358
2359         default:
2360           if (hm->trace[type0])
2361             {
2362               s = (*hm->trace[type0]) (s, opt0);
2363             }
2364           else
2365             {
2366               s =
2367                 format (s, "\n    unrecognized option %d length %d", type0,
2368                         opt0->length);
2369             }
2370           opt0 =
2371             (ip6_hop_by_hop_option_t *) (((u8 *) opt0) + opt0->length +
2372                                          sizeof (ip6_hop_by_hop_option_t));
2373           break;
2374         }
2375     }
2376   return s;
2377 }
2378
2379 always_inline u8
2380 ip6_scan_hbh_options (vlib_buffer_t * b0,
2381                       ip6_header_t * ip0,
2382                       ip6_hop_by_hop_header_t * hbh0,
2383                       ip6_hop_by_hop_option_t * opt0,
2384                       ip6_hop_by_hop_option_t * limit0, u32 * next0)
2385 {
2386   ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main;
2387   u8 type0;
2388   u8 error0 = 0;
2389
2390   while (opt0 < limit0)
2391     {
2392       type0 = opt0->type;
2393       switch (type0)
2394         {
2395         case 0:         /* Pad1 */
2396           opt0 = (ip6_hop_by_hop_option_t *) ((u8 *) opt0) + 1;
2397           continue;
2398         case 1:         /* PadN */
2399           break;
2400         default:
2401           if (hm->options[type0])
2402             {
2403               if ((*hm->options[type0]) (b0, ip0, opt0) < 0)
2404                 {
2405                   error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2406                   return (error0);
2407                 }
2408             }
2409           else
2410             {
2411               /* Unrecognized mandatory option, check the two high order bits */
2412               switch (opt0->type & HBH_OPTION_TYPE_HIGH_ORDER_BITS)
2413                 {
2414                 case HBH_OPTION_TYPE_SKIP_UNKNOWN:
2415                   break;
2416                 case HBH_OPTION_TYPE_DISCARD_UNKNOWN:
2417                   error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2418                   *next0 = IP_LOOKUP_NEXT_DROP;
2419                   break;
2420                 case HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP:
2421                   error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2422                   *next0 = IP_LOOKUP_NEXT_ICMP_ERROR;
2423                   icmp6_error_set_vnet_buffer (b0, ICMP6_parameter_problem,
2424                                                ICMP6_parameter_problem_unrecognized_option,
2425                                                (u8 *) opt0 - (u8 *) ip0);
2426                   break;
2427                 case HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP_NOT_MCAST:
2428                   error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2429                   if (!ip6_address_is_multicast (&ip0->dst_address))
2430                     {
2431                       *next0 = IP_LOOKUP_NEXT_ICMP_ERROR;
2432                       icmp6_error_set_vnet_buffer (b0,
2433                                                    ICMP6_parameter_problem,
2434                                                    ICMP6_parameter_problem_unrecognized_option,
2435                                                    (u8 *) opt0 - (u8 *) ip0);
2436                     }
2437                   else
2438                     {
2439                       *next0 = IP_LOOKUP_NEXT_DROP;
2440                     }
2441                   break;
2442                 }
2443               return (error0);
2444             }
2445         }
2446       opt0 =
2447         (ip6_hop_by_hop_option_t *) (((u8 *) opt0) + opt0->length +
2448                                      sizeof (ip6_hop_by_hop_option_t));
2449     }
2450   return (error0);
2451 }
2452
2453 /*
2454  * Process the Hop-by-Hop Options header
2455  */
2456 VLIB_NODE_FN (ip6_hop_by_hop_node) (vlib_main_t * vm,
2457                                     vlib_node_runtime_t * node,
2458                                     vlib_frame_t * frame)
2459 {
2460   vlib_node_runtime_t *error_node =
2461     vlib_node_get_runtime (vm, ip6_hop_by_hop_node.index);
2462   ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main;
2463   u32 n_left_from, *from, *to_next;
2464   ip_lookup_next_t next_index;
2465
2466   from = vlib_frame_vector_args (frame);
2467   n_left_from = frame->n_vectors;
2468   next_index = node->cached_next_index;
2469
2470   while (n_left_from > 0)
2471     {
2472       u32 n_left_to_next;
2473
2474       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2475
2476       while (n_left_from >= 4 && n_left_to_next >= 2)
2477         {
2478           u32 bi0, bi1;
2479           vlib_buffer_t *b0, *b1;
2480           u32 next0, next1;
2481           ip6_header_t *ip0, *ip1;
2482           ip6_hop_by_hop_header_t *hbh0, *hbh1;
2483           ip6_hop_by_hop_option_t *opt0, *limit0, *opt1, *limit1;
2484           u8 error0 = 0, error1 = 0;
2485
2486           /* Prefetch next iteration. */
2487           {
2488             vlib_buffer_t *p2, *p3;
2489
2490             p2 = vlib_get_buffer (vm, from[2]);
2491             p3 = vlib_get_buffer (vm, from[3]);
2492
2493             vlib_prefetch_buffer_header (p2, LOAD);
2494             vlib_prefetch_buffer_header (p3, LOAD);
2495
2496             CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
2497             CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
2498           }
2499
2500           /* Speculatively enqueue b0, b1 to the current next frame */
2501           to_next[0] = bi0 = from[0];
2502           to_next[1] = bi1 = from[1];
2503           from += 2;
2504           to_next += 2;
2505           n_left_from -= 2;
2506           n_left_to_next -= 2;
2507
2508           b0 = vlib_get_buffer (vm, bi0);
2509           b1 = vlib_get_buffer (vm, bi1);
2510
2511           /* Default use the next_index from the adjacency. A HBH option rarely redirects to a different node */
2512           u32 adj_index0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
2513           ip_adjacency_t *adj0 = adj_get (adj_index0);
2514           u32 adj_index1 = vnet_buffer (b1)->ip.adj_index[VLIB_TX];
2515           ip_adjacency_t *adj1 = adj_get (adj_index1);
2516
2517           /* Default use the next_index from the adjacency. A HBH option rarely redirects to a different node */
2518           next0 = adj0->lookup_next_index;
2519           next1 = adj1->lookup_next_index;
2520
2521           ip0 = vlib_buffer_get_current (b0);
2522           ip1 = vlib_buffer_get_current (b1);
2523           hbh0 = (ip6_hop_by_hop_header_t *) (ip0 + 1);
2524           hbh1 = (ip6_hop_by_hop_header_t *) (ip1 + 1);
2525           opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1);
2526           opt1 = (ip6_hop_by_hop_option_t *) (hbh1 + 1);
2527           limit0 =
2528             (ip6_hop_by_hop_option_t *) ((u8 *) hbh0 +
2529                                          ((hbh0->length + 1) << 3));
2530           limit1 =
2531             (ip6_hop_by_hop_option_t *) ((u8 *) hbh1 +
2532                                          ((hbh1->length + 1) << 3));
2533
2534           /*
2535            * Basic validity checks
2536            */
2537           if ((hbh0->length + 1) << 3 >
2538               clib_net_to_host_u16 (ip0->payload_length))
2539             {
2540               error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2541               next0 = IP_LOOKUP_NEXT_DROP;
2542               goto outdual;
2543             }
2544           /* Scan the set of h-b-h options, process ones that we understand */
2545           error0 = ip6_scan_hbh_options (b0, ip0, hbh0, opt0, limit0, &next0);
2546
2547           if ((hbh1->length + 1) << 3 >
2548               clib_net_to_host_u16 (ip1->payload_length))
2549             {
2550               error1 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2551               next1 = IP_LOOKUP_NEXT_DROP;
2552               goto outdual;
2553             }
2554           /* Scan the set of h-b-h options, process ones that we understand */
2555           error1 = ip6_scan_hbh_options (b1, ip1, hbh1, opt1, limit1, &next1);
2556
2557         outdual:
2558           /* Has the classifier flagged this buffer for special treatment? */
2559           if (PREDICT_FALSE
2560               ((error0 == 0)
2561                && (vnet_buffer (b0)->l2_classify.opaque_index & OI_DECAP)))
2562             next0 = hm->next_override;
2563
2564           /* Has the classifier flagged this buffer for special treatment? */
2565           if (PREDICT_FALSE
2566               ((error1 == 0)
2567                && (vnet_buffer (b1)->l2_classify.opaque_index & OI_DECAP)))
2568             next1 = hm->next_override;
2569
2570           if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
2571             {
2572               if (b0->flags & VLIB_BUFFER_IS_TRACED)
2573                 {
2574                   ip6_hop_by_hop_trace_t *t =
2575                     vlib_add_trace (vm, node, b0, sizeof (*t));
2576                   u32 trace_len = (hbh0->length + 1) << 3;
2577                   t->next_index = next0;
2578                   /* Capture the h-b-h option verbatim */
2579                   trace_len =
2580                     trace_len <
2581                     ARRAY_LEN (t->option_data) ? trace_len :
2582                     ARRAY_LEN (t->option_data);
2583                   t->trace_len = trace_len;
2584                   clib_memcpy_fast (t->option_data, hbh0, trace_len);
2585                 }
2586               if (b1->flags & VLIB_BUFFER_IS_TRACED)
2587                 {
2588                   ip6_hop_by_hop_trace_t *t =
2589                     vlib_add_trace (vm, node, b1, sizeof (*t));
2590                   u32 trace_len = (hbh1->length + 1) << 3;
2591                   t->next_index = next1;
2592                   /* Capture the h-b-h option verbatim */
2593                   trace_len =
2594                     trace_len <
2595                     ARRAY_LEN (t->option_data) ? trace_len :
2596                     ARRAY_LEN (t->option_data);
2597                   t->trace_len = trace_len;
2598                   clib_memcpy_fast (t->option_data, hbh1, trace_len);
2599                 }
2600
2601             }
2602
2603           b0->error = error_node->errors[error0];
2604           b1->error = error_node->errors[error1];
2605
2606           /* verify speculative enqueue, maybe switch current next frame */
2607           vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
2608                                            n_left_to_next, bi0, bi1, next0,
2609                                            next1);
2610         }
2611
2612       while (n_left_from > 0 && n_left_to_next > 0)
2613         {
2614           u32 bi0;
2615           vlib_buffer_t *b0;
2616           u32 next0;
2617           ip6_header_t *ip0;
2618           ip6_hop_by_hop_header_t *hbh0;
2619           ip6_hop_by_hop_option_t *opt0, *limit0;
2620           u8 error0 = 0;
2621
2622           /* Speculatively enqueue b0 to the current next frame */
2623           bi0 = from[0];
2624           to_next[0] = bi0;
2625           from += 1;
2626           to_next += 1;
2627           n_left_from -= 1;
2628           n_left_to_next -= 1;
2629
2630           b0 = vlib_get_buffer (vm, bi0);
2631           /*
2632            * Default use the next_index from the adjacency.
2633            * A HBH option rarely redirects to a different node
2634            */
2635           u32 adj_index0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
2636           ip_adjacency_t *adj0 = adj_get (adj_index0);
2637           next0 = adj0->lookup_next_index;
2638
2639           ip0 = vlib_buffer_get_current (b0);
2640           hbh0 = (ip6_hop_by_hop_header_t *) (ip0 + 1);
2641           opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1);
2642           limit0 =
2643             (ip6_hop_by_hop_option_t *) ((u8 *) hbh0 +
2644                                          ((hbh0->length + 1) << 3));
2645
2646           /*
2647            * Basic validity checks
2648            */
2649           if ((hbh0->length + 1) << 3 >
2650               clib_net_to_host_u16 (ip0->payload_length))
2651             {
2652               error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2653               next0 = IP_LOOKUP_NEXT_DROP;
2654               goto out0;
2655             }
2656
2657           /* Scan the set of h-b-h options, process ones that we understand */
2658           error0 = ip6_scan_hbh_options (b0, ip0, hbh0, opt0, limit0, &next0);
2659
2660         out0:
2661           /* Has the classifier flagged this buffer for special treatment? */
2662           if (PREDICT_FALSE
2663               ((error0 == 0)
2664                && (vnet_buffer (b0)->l2_classify.opaque_index & OI_DECAP)))
2665             next0 = hm->next_override;
2666
2667           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2668             {
2669               ip6_hop_by_hop_trace_t *t =
2670                 vlib_add_trace (vm, node, b0, sizeof (*t));
2671               u32 trace_len = (hbh0->length + 1) << 3;
2672               t->next_index = next0;
2673               /* Capture the h-b-h option verbatim */
2674               trace_len =
2675                 trace_len <
2676                 ARRAY_LEN (t->option_data) ? trace_len :
2677                 ARRAY_LEN (t->option_data);
2678               t->trace_len = trace_len;
2679               clib_memcpy_fast (t->option_data, hbh0, trace_len);
2680             }
2681
2682           b0->error = error_node->errors[error0];
2683
2684           /* verify speculative enqueue, maybe switch current next frame */
2685           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2686                                            n_left_to_next, bi0, next0);
2687         }
2688       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2689     }
2690   return frame->n_vectors;
2691 }
2692
2693 /* *INDENT-OFF* */
2694 VLIB_REGISTER_NODE (ip6_hop_by_hop_node) =
2695 {
2696   .name = "ip6-hop-by-hop",
2697   .sibling_of = "ip6-lookup",
2698   .vector_size = sizeof (u32),
2699   .format_trace = format_ip6_hop_by_hop_trace,
2700   .type = VLIB_NODE_TYPE_INTERNAL,
2701   .n_errors = ARRAY_LEN (ip6_hop_by_hop_error_strings),
2702   .error_strings = ip6_hop_by_hop_error_strings,
2703   .n_next_nodes = 0,
2704 };
2705 /* *INDENT-ON* */
2706
2707 static clib_error_t *
2708 ip6_hop_by_hop_init (vlib_main_t * vm)
2709 {
2710   ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main;
2711   clib_memset (hm->options, 0, sizeof (hm->options));
2712   clib_memset (hm->trace, 0, sizeof (hm->trace));
2713   hm->next_override = IP6_LOOKUP_NEXT_POP_HOP_BY_HOP;
2714   return (0);
2715 }
2716
2717 VLIB_INIT_FUNCTION (ip6_hop_by_hop_init);
2718
2719 #ifndef CLIB_MARCH_VARIANT
2720 void
2721 ip6_hbh_set_next_override (uword next)
2722 {
2723   ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main;
2724
2725   hm->next_override = next;
2726 }
2727
2728 int
2729 ip6_hbh_register_option (u8 option,
2730                          int options (vlib_buffer_t * b, ip6_header_t * ip,
2731                                       ip6_hop_by_hop_option_t * opt),
2732                          u8 * trace (u8 * s, ip6_hop_by_hop_option_t * opt))
2733 {
2734   ip6_main_t *im = &ip6_main;
2735   ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main;
2736
2737   ASSERT ((u32) option < ARRAY_LEN (hm->options));
2738
2739   /* Already registered */
2740   if (hm->options[option])
2741     return (-1);
2742
2743   hm->options[option] = options;
2744   hm->trace[option] = trace;
2745
2746   /* Set global variable */
2747   im->hbh_enabled = 1;
2748
2749   return (0);
2750 }
2751
2752 int
2753 ip6_hbh_unregister_option (u8 option)
2754 {
2755   ip6_main_t *im = &ip6_main;
2756   ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main;
2757
2758   ASSERT ((u32) option < ARRAY_LEN (hm->options));
2759
2760   /* Not registered */
2761   if (!hm->options[option])
2762     return (-1);
2763
2764   hm->options[option] = NULL;
2765   hm->trace[option] = NULL;
2766
2767   /* Disable global knob if this was the last option configured */
2768   int i;
2769   bool found = false;
2770   for (i = 0; i < 256; i++)
2771     {
2772       if (hm->options[option])
2773         {
2774           found = true;
2775           break;
2776         }
2777     }
2778   if (!found)
2779     im->hbh_enabled = 0;
2780
2781   return (0);
2782 }
2783
2784 /* Global IP6 main. */
2785 ip6_main_t ip6_main;
2786 #endif
2787
2788 static clib_error_t *
2789 ip6_lookup_init (vlib_main_t * vm)
2790 {
2791   ip6_main_t *im = &ip6_main;
2792   clib_error_t *error;
2793   uword i;
2794
2795   if ((error = vlib_call_init_function (vm, vnet_feature_init)))
2796     return error;
2797
2798   for (i = 0; i < ARRAY_LEN (im->fib_masks); i++)
2799     {
2800       u32 j, i0, i1;
2801
2802       i0 = i / 32;
2803       i1 = i % 32;
2804
2805       for (j = 0; j < i0; j++)
2806         im->fib_masks[i].as_u32[j] = ~0;
2807
2808       if (i1)
2809         im->fib_masks[i].as_u32[i0] =
2810           clib_host_to_net_u32 (pow2_mask (i1) << (32 - i1));
2811     }
2812
2813   ip_lookup_init (&im->lookup_main, /* is_ip6 */ 1);
2814
2815   /* Create FIB with index 0 and table id of 0. */
2816   fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, 0,
2817                                      FIB_SOURCE_DEFAULT_ROUTE);
2818   mfib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, 0,
2819                                       MFIB_SOURCE_DEFAULT_ROUTE);
2820
2821   {
2822     pg_node_t *pn;
2823     pn = pg_get_node (ip6_lookup_node.index);
2824     pn->unformat_edit = unformat_pg_ip6_header;
2825   }
2826
2827   /* Unless explicitly configured, don't process HBH options */
2828   im->hbh_enabled = 0;
2829
2830   return error;
2831 }
2832
2833 VLIB_INIT_FUNCTION (ip6_lookup_init);
2834
2835 static clib_error_t *
2836 set_ip6_flow_hash_command_fn (vlib_main_t * vm,
2837                               unformat_input_t * input,
2838                               vlib_cli_command_t * cmd)
2839 {
2840   int matched = 0;
2841   u32 table_id = 0;
2842   u32 flow_hash_config = 0;
2843   int rv;
2844
2845   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2846     {
2847       if (unformat (input, "table %d", &table_id))
2848         matched = 1;
2849 #define _(a, b, v)                                                            \
2850   else if (unformat (input, #a))                                              \
2851   {                                                                           \
2852     flow_hash_config |= v;                                                    \
2853     matched = 1;                                                              \
2854   }
2855       foreach_flow_hash_bit
2856 #undef _
2857         else
2858         break;
2859     }
2860
2861   if (matched == 0)
2862     return clib_error_return (0, "unknown input `%U'",
2863                               format_unformat_error, input);
2864
2865   rv = ip_flow_hash_set (AF_IP6, table_id, flow_hash_config);
2866   switch (rv)
2867     {
2868     case 0:
2869       break;
2870
2871     case -1:
2872       return clib_error_return (0, "no such FIB table %d", table_id);
2873
2874     default:
2875       clib_warning ("BUG: illegal flow hash config 0x%x", flow_hash_config);
2876       break;
2877     }
2878
2879   return 0;
2880 }
2881
2882 /*?
2883  * Configure the set of IPv6 fields used by the flow hash.
2884  *
2885  * @cliexpar
2886  * @parblock
2887  * Example of how to set the flow hash on a given table:
2888  * @cliexcmd{set ip6 flow-hash table 8 dst sport dport proto}
2889  *
2890  * Example of display the configured flow hash:
2891  * @cliexstart{show ip6 fib}
2892  * ipv6-VRF:0, fib_index 0, flow hash: src dst sport dport proto
2893  * @::/0
2894  *   unicast-ip6-chain
2895  *   [@0]: dpo-load-balance: [index:5 buckets:1 uRPF:5 to:[0:0]]
2896  *     [0] [@0]: dpo-drop ip6
2897  * fe80::/10
2898  *   unicast-ip6-chain
2899  *   [@0]: dpo-load-balance: [index:10 buckets:1 uRPF:10 to:[0:0]]
2900  *     [0] [@2]: dpo-receive
2901  * ff02::1/128
2902  *   unicast-ip6-chain
2903  *   [@0]: dpo-load-balance: [index:8 buckets:1 uRPF:8 to:[0:0]]
2904  *     [0] [@2]: dpo-receive
2905  * ff02::2/128
2906  *   unicast-ip6-chain
2907  *   [@0]: dpo-load-balance: [index:7 buckets:1 uRPF:7 to:[0:0]]
2908  *     [0] [@2]: dpo-receive
2909  * ff02::16/128
2910  *   unicast-ip6-chain
2911  *   [@0]: dpo-load-balance: [index:9 buckets:1 uRPF:9 to:[0:0]]
2912  *     [0] [@2]: dpo-receive
2913  * ff02::1:ff00:0/104
2914  *   unicast-ip6-chain
2915  *   [@0]: dpo-load-balance: [index:6 buckets:1 uRPF:6 to:[0:0]]
2916  *     [0] [@2]: dpo-receive
2917  * ipv6-VRF:8, fib_index 1, flow hash: dst sport dport proto
2918  * @::/0
2919  *   unicast-ip6-chain
2920  *   [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
2921  *     [0] [@0]: dpo-drop ip6
2922  * @::a:1:1:0:4/126
2923  *   unicast-ip6-chain
2924  *   [@0]: dpo-load-balance: [index:27 buckets:1 uRPF:26 to:[0:0]]
2925  *     [0] [@4]: ipv6-glean: af_packet0
2926  * @::a:1:1:0:7/128
2927  *   unicast-ip6-chain
2928  *   [@0]: dpo-load-balance: [index:28 buckets:1 uRPF:27 to:[0:0]]
2929  *     [0] [@2]: dpo-receive: @::a:1:1:0:7 on af_packet0
2930  * fe80::/10
2931  *   unicast-ip6-chain
2932  *   [@0]: dpo-load-balance: [index:26 buckets:1 uRPF:25 to:[0:0]]
2933  *     [0] [@2]: dpo-receive
2934  * fe80::fe:3eff:fe3e:9222/128
2935  *   unicast-ip6-chain
2936  *   [@0]: dpo-load-balance: [index:29 buckets:1 uRPF:28 to:[0:0]]
2937  *     [0] [@2]: dpo-receive: fe80::fe:3eff:fe3e:9222 on af_packet0
2938  * ff02::1/128
2939  *   unicast-ip6-chain
2940  *   [@0]: dpo-load-balance: [index:24 buckets:1 uRPF:23 to:[0:0]]
2941  *     [0] [@2]: dpo-receive
2942  * ff02::2/128
2943  *   unicast-ip6-chain
2944  *   [@0]: dpo-load-balance: [index:23 buckets:1 uRPF:22 to:[0:0]]
2945  *     [0] [@2]: dpo-receive
2946  * ff02::16/128
2947  *   unicast-ip6-chain
2948  *   [@0]: dpo-load-balance: [index:25 buckets:1 uRPF:24 to:[0:0]]
2949  *     [0] [@2]: dpo-receive
2950  * ff02::1:ff00:0/104
2951  *   unicast-ip6-chain
2952  *   [@0]: dpo-load-balance: [index:22 buckets:1 uRPF:21 to:[0:0]]
2953  *     [0] [@2]: dpo-receive
2954  * @cliexend
2955  * @endparblock
2956 ?*/
2957 /* *INDENT-OFF* */
2958 VLIB_CLI_COMMAND (set_ip6_flow_hash_command, static) = {
2959   .path = "set ip6 flow-hash",
2960   .short_help = "set ip6 flow-hash table <table-id> [src] [dst] [sport] "
2961                 "[dport] [proto] [reverse] [flowlabel]",
2962   .function = set_ip6_flow_hash_command_fn,
2963 };
2964 /* *INDENT-ON* */
2965
2966 static clib_error_t *
2967 show_ip6_local_command_fn (vlib_main_t * vm,
2968                            unformat_input_t * input, vlib_cli_command_t * cmd)
2969 {
2970   ip6_main_t *im = &ip6_main;
2971   ip_lookup_main_t *lm = &im->lookup_main;
2972   int i;
2973
2974   vlib_cli_output (vm, "Protocols handled by ip6_local");
2975   for (i = 0; i < ARRAY_LEN (lm->local_next_by_ip_protocol); i++)
2976     {
2977       if (lm->local_next_by_ip_protocol[i] != IP_LOCAL_NEXT_PUNT)
2978         {
2979
2980           u32 node_index = vlib_get_node (vm,
2981                                           ip6_local_node.index)->
2982             next_nodes[lm->local_next_by_ip_protocol[i]];
2983           vlib_cli_output (vm, "%d: %U", i, format_vlib_node_name, vm,
2984                            node_index);
2985         }
2986     }
2987   return 0;
2988 }
2989
2990
2991
2992 /*?
2993  * Display the set of protocols handled by the local IPv6 stack.
2994  *
2995  * @cliexpar
2996  * Example of how to display local protocol table:
2997  * @cliexstart{show ip6 local}
2998  * Protocols handled by ip6_local
2999  * 17
3000  * 43
3001  * 58
3002  * 115
3003  * @cliexend
3004 ?*/
3005 /* *INDENT-OFF* */
3006 VLIB_CLI_COMMAND (show_ip6_local, static) =
3007 {
3008   .path = "show ip6 local",
3009   .function = show_ip6_local_command_fn,
3010   .short_help = "show ip6 local",
3011 };
3012 /* *INDENT-ON* */
3013
3014 #ifndef CLIB_MARCH_VARIANT
3015 int
3016 vnet_set_ip6_classify_intfc (vlib_main_t * vm, u32 sw_if_index,
3017                              u32 table_index)
3018 {
3019   vnet_main_t *vnm = vnet_get_main ();
3020   vnet_interface_main_t *im = &vnm->interface_main;
3021   ip6_main_t *ipm = &ip6_main;
3022   ip_lookup_main_t *lm = &ipm->lookup_main;
3023   vnet_classify_main_t *cm = &vnet_classify_main;
3024   ip6_address_t *if_addr;
3025
3026   if (pool_is_free_index (im->sw_interfaces, sw_if_index))
3027     return VNET_API_ERROR_NO_MATCHING_INTERFACE;
3028
3029   if (table_index != ~0 && pool_is_free_index (cm->tables, table_index))
3030     return VNET_API_ERROR_NO_SUCH_ENTRY;
3031
3032   vec_validate (lm->classify_table_index_by_sw_if_index, sw_if_index);
3033   lm->classify_table_index_by_sw_if_index[sw_if_index] = table_index;
3034
3035   if_addr = ip6_interface_first_address (ipm, sw_if_index);
3036
3037   if (NULL != if_addr)
3038     {
3039       fib_prefix_t pfx = {
3040         .fp_len = 128,
3041         .fp_proto = FIB_PROTOCOL_IP6,
3042         .fp_addr.ip6 = *if_addr,
3043       };
3044       u32 fib_index;
3045
3046       fib_index = fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4,
3047                                                        sw_if_index);
3048
3049
3050       if (table_index != (u32) ~ 0)
3051         {
3052           dpo_id_t dpo = DPO_INVALID;
3053
3054           dpo_set (&dpo,
3055                    DPO_CLASSIFY,
3056                    DPO_PROTO_IP6,
3057                    classify_dpo_create (DPO_PROTO_IP6, table_index));
3058
3059           fib_table_entry_special_dpo_add (fib_index,
3060                                            &pfx,
3061                                            FIB_SOURCE_CLASSIFY,
3062                                            FIB_ENTRY_FLAG_NONE, &dpo);
3063           dpo_reset (&dpo);
3064         }
3065       else
3066         {
3067           fib_table_entry_special_remove (fib_index,
3068                                           &pfx, FIB_SOURCE_CLASSIFY);
3069         }
3070     }
3071
3072   return 0;
3073 }
3074 #endif
3075
3076 static clib_error_t *
3077 set_ip6_classify_command_fn (vlib_main_t * vm,
3078                              unformat_input_t * input,
3079                              vlib_cli_command_t * cmd)
3080 {
3081   u32 table_index = ~0;
3082   int table_index_set = 0;
3083   u32 sw_if_index = ~0;
3084   int rv;
3085
3086   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3087     {
3088       if (unformat (input, "table-index %d", &table_index))
3089         table_index_set = 1;
3090       else if (unformat (input, "intfc %U", unformat_vnet_sw_interface,
3091                          vnet_get_main (), &sw_if_index))
3092         ;
3093       else
3094         break;
3095     }
3096
3097   if (table_index_set == 0)
3098     return clib_error_return (0, "classify table-index must be specified");
3099
3100   if (sw_if_index == ~0)
3101     return clib_error_return (0, "interface / subif must be specified");
3102
3103   rv = vnet_set_ip6_classify_intfc (vm, sw_if_index, table_index);
3104
3105   switch (rv)
3106     {
3107     case 0:
3108       break;
3109
3110     case VNET_API_ERROR_NO_MATCHING_INTERFACE:
3111       return clib_error_return (0, "No such interface");
3112
3113     case VNET_API_ERROR_NO_SUCH_ENTRY:
3114       return clib_error_return (0, "No such classifier table");
3115     }
3116   return 0;
3117 }
3118
3119 /*?
3120  * Assign a classification table to an interface. The classification
3121  * table is created using the '<em>classify table</em>' and '<em>classify session</em>'
3122  * commands. Once the table is create, use this command to filter packets
3123  * on an interface.
3124  *
3125  * @cliexpar
3126  * Example of how to assign a classification table to an interface:
3127  * @cliexcmd{set ip6 classify intfc GigabitEthernet2/0/0 table-index 1}
3128 ?*/
3129 /* *INDENT-OFF* */
3130 VLIB_CLI_COMMAND (set_ip6_classify_command, static) =
3131 {
3132   .path = "set ip6 classify",
3133   .short_help =
3134   "set ip6 classify intfc <interface> table-index <classify-idx>",
3135   .function = set_ip6_classify_command_fn,
3136 };
3137 /* *INDENT-ON* */
3138
3139 /*
3140  * fd.io coding-style-patch-verification: ON
3141  *
3142  * Local Variables:
3143  * eval: (c-set-style "gnu")
3144  * End:
3145  */