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