FD.io VPP  v21.06-3-gbb25fbf28
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 */
136  address, a->address_length);
137 
138  pfx.fp_len = 128;
140  {
143  if (classify_table_index != (u32) ~ 0)
144  {
145  dpo_id_t dpo = DPO_INVALID;
146 
147  dpo_set (&dpo,
148  DPO_CLASSIFY,
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 */
212  fib_table_entry_delete (fib_index, &key.prefix, FIB_SOURCE_INTERFACE);
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 */
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 ();
244 
245  vec_validate_init_empty (im->ip_enabled_by_sw_if_index, sw_if_index, 0);
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* */
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 
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 
331 
332  if (rv)
333  {
334  vnm->api_errno = rv;
335  return clib_error_create ("address not assignable");
336  }
337  }
338  else
339  {
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  {
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;
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;
708 
710  /* *INDENT-OFF* */
712  ({
715  }));
716  /* *INDENT-ON* */
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;
758  ip6_main_t *im = &ip6_main;
761 
763  n_left = frame->n_vectors;
764  next = nexts;
765 
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 
920 
921  if (node->flags & VLIB_NODE_FLAG_TRACE)
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, "%Ufib:%d adj:%d flow:%d",
959  format_white_space, indent,
960  t->fib_index, t->adj_index, t->flow_hash);
961  s = format (s, "\n%U%U",
962  format_white_space, indent,
963  format_ip6_header, t->packet_data, sizeof (t->packet_data));
964  return s;
965 }
966 #endif
967 
968 static u8 *
969 format_ip6_lookup_trace (u8 * s, va_list * args)
970 {
971  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
972  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
973  ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
974  u32 indent = format_get_indent (s);
975 
976  s = format (s, "fib %d dpo-idx %d flow hash: 0x%08x",
977  t->fib_index, t->adj_index, t->flow_hash);
978  s = format (s, "\n%U%U",
979  format_white_space, indent,
980  format_ip6_header, t->packet_data, sizeof (t->packet_data));
981  return s;
982 }
983 
984 
985 static u8 *
986 format_ip6_rewrite_trace (u8 * s, va_list * args)
987 {
988  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
989  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
990  ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *);
991  u32 indent = format_get_indent (s);
992 
993  s = format (s, "tx_sw_if_index %d adj-idx %d : %U flow hash: 0x%08x",
996  s = format (s, "\n%U%U",
997  format_white_space, indent,
999  t->packet_data, sizeof (t->packet_data));
1000  return s;
1001 }
1002 
1003 /* Common trace function for all ip6-forward next nodes. */
1004 #ifndef CLIB_MARCH_VARIANT
1005 void
1008  vlib_frame_t * frame, vlib_rx_or_tx_t which_adj_index)
1009 {
1010  u32 *from, n_left;
1011  ip6_main_t *im = &ip6_main;
1012 
1013  n_left = frame->n_vectors;
1015 
1016  while (n_left >= 4)
1017  {
1018  u32 bi0, bi1;
1019  vlib_buffer_t *b0, *b1;
1020  ip6_forward_next_trace_t *t0, *t1;
1021 
1022  /* Prefetch next iteration. */
1025 
1026  bi0 = from[0];
1027  bi1 = from[1];
1028 
1029  b0 = vlib_get_buffer (vm, bi0);
1030  b1 = vlib_get_buffer (vm, bi1);
1031 
1032  if (b0->flags & VLIB_BUFFER_IS_TRACED)
1033  {
1034  t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
1035  t0->adj_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
1036  t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
1037  t0->fib_index =
1038  (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1039  (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1040  vec_elt (im->fib_index_by_sw_if_index,
1042 
1045  sizeof (t0->packet_data));
1046  }
1047  if (b1->flags & VLIB_BUFFER_IS_TRACED)
1048  {
1049  t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
1050  t1->adj_index = vnet_buffer (b1)->ip.adj_index[which_adj_index];
1051  t1->flow_hash = vnet_buffer (b1)->ip.flow_hash;
1052  t1->fib_index =
1053  (vnet_buffer (b1)->sw_if_index[VLIB_TX] !=
1054  (u32) ~ 0) ? vnet_buffer (b1)->sw_if_index[VLIB_TX] :
1055  vec_elt (im->fib_index_by_sw_if_index,
1057 
1060  sizeof (t1->packet_data));
1061  }
1062  from += 2;
1063  n_left -= 2;
1064  }
1065 
1066  while (n_left >= 1)
1067  {
1068  u32 bi0;
1069  vlib_buffer_t *b0;
1071 
1072  bi0 = from[0];
1073 
1074  b0 = vlib_get_buffer (vm, bi0);
1075 
1076  if (b0->flags & VLIB_BUFFER_IS_TRACED)
1077  {
1078  t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
1079  t0->adj_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
1080  t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
1081  t0->fib_index =
1082  (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1083  (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1084  vec_elt (im->fib_index_by_sw_if_index,
1086 
1089  sizeof (t0->packet_data));
1090  }
1091  from += 1;
1092  n_left -= 1;
1093  }
1094 }
1095 
1096 /* Compute TCP/UDP/ICMP6 checksum in software. */
1097 u16
1099  ip6_header_t * ip0, int *bogus_lengthp)
1100 {
1101  ip_csum_t sum0 = 0;
1102  u16 payload_length, payload_length_host_byte_order;
1103  u32 i;
1104  u32 headers_size = sizeof (ip0[0]);
1105  u8 *data_this_buffer;
1106  u8 next_hdr = ip0->protocol;
1107 
1108  ASSERT (bogus_lengthp);
1109  *bogus_lengthp = 0;
1110 
1111  payload_length_host_byte_order = clib_net_to_host_u16 (ip0->payload_length);
1112  data_this_buffer = (u8 *) (ip0 + 1);
1113  payload_length = ip0->payload_length;
1114 
1115  /* some icmp packets may come with a "router alert" hop-by-hop extension header (e.g., mldv2 packets)
1116  * or UDP-Ping packets */
1117  if (PREDICT_FALSE (next_hdr == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
1118  {
1119  u32 skip_bytes;
1120  ip6_hop_by_hop_ext_t *ext_hdr =
1121  (ip6_hop_by_hop_ext_t *) data_this_buffer;
1122 
1123  /* validate really icmp6 next */
1124  ASSERT ((ext_hdr->next_hdr == IP_PROTOCOL_ICMP6)
1125  || (ext_hdr->next_hdr == IP_PROTOCOL_UDP));
1126 
1127  skip_bytes = 8 * (1 + ext_hdr->n_data_u64s);
1128  data_this_buffer = (void *) ((u8 *) data_this_buffer + skip_bytes);
1129 
1130  payload_length_host_byte_order -= skip_bytes;
1131  headers_size += skip_bytes;
1132 
1133  /* pseudo-header adjustments:
1134  * exclude ext header bytes from payload length
1135  * use payload IP proto rather than ext header IP proto
1136  */
1137  payload_length = clib_host_to_net_u16 (payload_length_host_byte_order);
1138  next_hdr = ext_hdr->next_hdr;
1139  }
1140 
1141  /* Initialize checksum with ip pseudo-header. */
1142  sum0 = payload_length + clib_host_to_net_u16 (next_hdr);
1143 
1144  for (i = 0; i < ARRAY_LEN (ip0->src_address.as_uword); i++)
1145  {
1146  sum0 = ip_csum_with_carry
1147  (sum0, clib_mem_unaligned (&ip0->src_address.as_uword[i], uword));
1148  sum0 = ip_csum_with_carry
1149  (sum0, clib_mem_unaligned (&ip0->dst_address.as_uword[i], uword));
1150  }
1151 
1152  if (p0)
1153  return ip_calculate_l4_checksum (vm, p0, sum0,
1154  payload_length_host_byte_order,
1155  (u8 *) ip0, headers_size, NULL);
1156  else
1157  return ip_calculate_l4_checksum (vm, 0, sum0,
1158  payload_length_host_byte_order, NULL, 0,
1159  data_this_buffer);
1160 }
1161 
1162 u32
1164 {
1166  udp_header_t *udp0;
1167  u16 sum16;
1168  int bogus_length;
1169 
1170  /* some icmp packets may come with a "router alert" hop-by-hop extension header (e.g., mldv2 packets) */
1171  ASSERT (ip0->protocol == IP_PROTOCOL_TCP
1172  || ip0->protocol == IP_PROTOCOL_ICMP6
1173  || ip0->protocol == IP_PROTOCOL_UDP
1174  || ip0->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS);
1175 
1176  udp0 = (void *) (ip0 + 1);
1177  if (ip0->protocol == IP_PROTOCOL_UDP && udp0->checksum == 0)
1178  {
1179  p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1180  | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
1181  return p0->flags;
1182  }
1183 
1184  sum16 = ip6_tcp_udp_icmp_compute_checksum (vm, p0, ip0, &bogus_length);
1185 
1186  p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1187  | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
1188 
1189  return p0->flags;
1190 }
1191 #endif
1192 
1193 /**
1194  * @brief returns number of links on which src is reachable.
1195  */
1196 always_inline int
1198 {
1199  const load_balance_t *lb0;
1200  index_t lbi;
1201  u32 fib_index;
1202 
1203  fib_index = vec_elt (im->fib_index_by_sw_if_index,
1205  fib_index =
1206  (vnet_buffer (b)->sw_if_index[VLIB_TX] == (u32) ~ 0) ?
1207  fib_index : vnet_buffer (b)->sw_if_index[VLIB_TX];
1208 
1209  lbi = ip6_fib_table_fwding_lookup (fib_index, &i->src_address);
1210  lb0 = load_balance_get (lbi);
1211 
1212  return (fib_urpf_check_size (lb0->lb_urpf));
1213 }
1214 
1217  u32 * udp_offset0)
1218 {
1219  u32 proto0;
1220  proto0 = ip6_locate_header (p0, ip0, IP_PROTOCOL_UDP, udp_offset0);
1221  if (proto0 != IP_PROTOCOL_UDP)
1222  {
1223  proto0 = ip6_locate_header (p0, ip0, IP_PROTOCOL_TCP, udp_offset0);
1224  proto0 = (proto0 == IP_PROTOCOL_TCP) ? proto0 : 0;
1225  }
1226  return proto0;
1227 }
1228 
1229 /* *INDENT-OFF* */
1230 VNET_FEATURE_ARC_INIT (ip6_local) =
1231 {
1232  .arc_name = "ip6-local",
1233  .start_nodes = VNET_FEATURES ("ip6-local"),
1234 };
1235 /* *INDENT-ON* */
1236 
1239 {
1240 
1241  u16 payload_length_host_byte_order;
1242  u32 n_this_buffer, n_bytes_left;
1244  u32 headers_size = sizeof (ip0[0]);
1245  u8 *data_this_buffer;
1246 
1247 
1248  data_this_buffer = (u8 *) (ip0 + 1);
1249 
1250  ip6_hop_by_hop_ext_t *ext_hdr = (ip6_hop_by_hop_ext_t *) data_this_buffer;
1251 
1252  /* validate really icmp6 next */
1253 
1254  if (!(ext_hdr->next_hdr == IP_PROTOCOL_ICMP6)
1255  || (ext_hdr->next_hdr == IP_PROTOCOL_UDP))
1256  return 0;
1257 
1258 
1259  payload_length_host_byte_order = clib_net_to_host_u16 (ip0->payload_length);
1260  n_bytes_left = n_this_buffer = payload_length_host_byte_order;
1261 
1262 
1263  u32 n_ip_bytes_this_buffer =
1264  p0->current_length - (((u8 *) ip0 - p0->data) - p0->current_data);
1265  if (n_this_buffer + headers_size > n_ip_bytes_this_buffer)
1266  {
1267  n_this_buffer = p0->current_length > headers_size ?
1268  n_ip_bytes_this_buffer - headers_size : 0;
1269  }
1270 
1271  n_bytes_left -= n_this_buffer;
1272  n_bytes_left -= p0->total_length_not_including_first_buffer;
1273 
1274  if (n_bytes_left == 0)
1275  return 0;
1276  else
1277  return 1;
1278 }
1279 
1280 
1283  vlib_frame_t * frame, int head_of_feature_arc)
1284 {
1285  ip6_main_t *im = &ip6_main;
1286  ip_lookup_main_t *lm = &im->lookup_main;
1287  u32 *from, n_left_from;
1288  vlib_node_runtime_t *error_node =
1290  u8 arc_index = vnet_feat_arc_ip6_local.feature_arc_index;
1293 
1295  n_left_from = frame->n_vectors;
1296 
1297  if (node->flags & VLIB_NODE_FLAG_TRACE)
1299 
1301  b = bufs;
1302  next = nexts;
1303 
1304  while (n_left_from > 2)
1305  {
1306  /* Prefetch next iteration. */
1307  if (n_left_from >= 6)
1308  {
1309  vlib_prefetch_buffer_header (b[4], STORE);
1310  vlib_prefetch_buffer_header (b[5], STORE);
1311  vlib_prefetch_buffer_data (b[2], LOAD);
1312  vlib_prefetch_buffer_data (b[3], LOAD);
1313  }
1314 
1315  ip6_error_t error[2];
1316  error[0] = IP6_ERROR_UNKNOWN_PROTOCOL;
1317  error[1] = IP6_ERROR_UNKNOWN_PROTOCOL;
1318 
1319  ip6_header_t *ip[2];
1320  ip[0] = vlib_buffer_get_current (b[0]);
1321  ip[1] = vlib_buffer_get_current (b[1]);
1322 
1323  if (head_of_feature_arc)
1324  {
1325  vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data;
1326  vnet_buffer (b[1])->l3_hdr_offset = b[1]->current_data;
1327 
1328  u8 type[2];
1329  type[0] = lm->builtin_protocol_by_ip_protocol[ip[0]->protocol];
1330  type[1] = lm->builtin_protocol_by_ip_protocol[ip[1]->protocol];
1331 
1332  u32 flags[2];
1333  flags[0] = b[0]->flags;
1334  flags[1] = b[1]->flags;
1335 
1336  vnet_buffer_oflags_t oflags[2];
1337  oflags[0] = vnet_buffer (b[0])->oflags;
1338  oflags[1] = vnet_buffer (b[1])->oflags;
1339 
1340  u32 l4_offload[2];
1341  l4_offload[0] = (flags[0] & VNET_BUFFER_F_OFFLOAD) &&
1342  (oflags[0] & (VNET_BUFFER_OFFLOAD_F_TCP_CKSUM |
1343  VNET_BUFFER_OFFLOAD_F_UDP_CKSUM));
1344  l4_offload[1] = (flags[1] & VNET_BUFFER_F_OFFLOAD) &&
1345  (oflags[1] & (VNET_BUFFER_OFFLOAD_F_TCP_CKSUM |
1346  VNET_BUFFER_OFFLOAD_F_UDP_CKSUM));
1347 
1348  u32 good_l4_csum[2];
1349  good_l4_csum[0] =
1350  (flags[0] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) | l4_offload[0];
1351  good_l4_csum[1] =
1352  (flags[1] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) | l4_offload[1];
1353 
1354  u32 udp_offset[2] = { };
1355  u8 is_tcp_udp[2];
1356  is_tcp_udp[0] =
1357  ip6_next_proto_is_tcp_udp (b[0], ip[0], &udp_offset[0]);
1358  is_tcp_udp[1] =
1359  ip6_next_proto_is_tcp_udp (b[1], ip[1], &udp_offset[1]);
1360  i16 len_diff[2] = { 0 };
1361  if (PREDICT_TRUE (is_tcp_udp[0]))
1362  {
1363  udp_header_t *udp =
1364  (udp_header_t *) ((u8 *) ip[0] + udp_offset[0]);
1365  good_l4_csum[0] |= type[0] == IP_BUILTIN_PROTOCOL_UDP
1366  && udp->checksum == 0;
1367  /* optimistically verify UDP length. */
1368  u16 ip_len, udp_len;
1369  ip_len = clib_net_to_host_u16 (ip[0]->payload_length);
1370  udp_len = clib_net_to_host_u16 (udp->length);
1371  len_diff[0] = ip_len - udp_len;
1372  }
1373  if (PREDICT_TRUE (is_tcp_udp[1]))
1374  {
1375  udp_header_t *udp =
1376  (udp_header_t *) ((u8 *) ip[1] + udp_offset[1]);
1377  good_l4_csum[1] |= type[1] == IP_BUILTIN_PROTOCOL_UDP
1378  && udp->checksum == 0;
1379  /* optimistically verify UDP length. */
1380  u16 ip_len, udp_len;
1381  ip_len = clib_net_to_host_u16 (ip[1]->payload_length);
1382  udp_len = clib_net_to_host_u16 (udp->length);
1383  len_diff[1] = ip_len - udp_len;
1384  }
1385 
1386  good_l4_csum[0] |= type[0] == IP_BUILTIN_PROTOCOL_UNKNOWN;
1387  good_l4_csum[1] |= type[1] == IP_BUILTIN_PROTOCOL_UNKNOWN;
1388 
1389  len_diff[0] = type[0] == IP_BUILTIN_PROTOCOL_UDP ? len_diff[0] : 0;
1390  len_diff[1] = type[1] == IP_BUILTIN_PROTOCOL_UDP ? len_diff[1] : 0;
1391 
1392  u8 need_csum[2];
1393  need_csum[0] = type[0] != IP_BUILTIN_PROTOCOL_UNKNOWN
1394  && !good_l4_csum[0]
1395  && !(flags[0] & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
1396  need_csum[1] = type[1] != IP_BUILTIN_PROTOCOL_UNKNOWN
1397  && !good_l4_csum[1]
1398  && !(flags[1] & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
1399  if (PREDICT_FALSE (need_csum[0]))
1400  {
1402  good_l4_csum[0] = flags[0] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT;
1403  error[0] = IP6_ERROR_UNKNOWN_PROTOCOL;
1404  }
1405  else
1406  {
1407  if (ip6_tcp_udp_icmp_bad_length (vm, b[0]))
1408  error[0] = IP6_ERROR_BAD_LENGTH;
1409  }
1410  if (PREDICT_FALSE (need_csum[1]))
1411  {
1413  good_l4_csum[1] = flags[1] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT;
1414  error[1] = IP6_ERROR_UNKNOWN_PROTOCOL;
1415  }
1416  else
1417  {
1418  if (ip6_tcp_udp_icmp_bad_length (vm, b[1]))
1419  error[1] = IP6_ERROR_BAD_LENGTH;
1420  }
1421 
1422 
1423  error[0] = len_diff[0] < 0 ? IP6_ERROR_UDP_LENGTH : error[0];
1424 
1425  error[1] = len_diff[1] < 0 ? IP6_ERROR_UDP_LENGTH : error[1];
1426 
1427  STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_UDP ==
1428  IP6_ERROR_UDP_CHECKSUM,
1429  "Wrong IP6 errors constants");
1430  STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_ICMP ==
1431  IP6_ERROR_ICMP_CHECKSUM,
1432  "Wrong IP6 errors constants");
1433 
1434  error[0] =
1435  !good_l4_csum[0] ? IP6_ERROR_UDP_CHECKSUM + type[0] : error[0];
1436  error[1] =
1437  !good_l4_csum[1] ? IP6_ERROR_UDP_CHECKSUM + type[1] : error[1];
1438 
1439  /* Drop packets from unroutable hosts. */
1440  /* If this is a neighbor solicitation (ICMP), skip source RPF check */
1441  u8 unroutable[2];
1442  unroutable[0] = error[0] == IP6_ERROR_UNKNOWN_PROTOCOL
1445  unroutable[1] = error[1] == IP6_ERROR_UNKNOWN_PROTOCOL
1448  if (PREDICT_FALSE (unroutable[0]))
1449  {
1450  error[0] =
1451  !ip6_urpf_loose_check (im, b[0],
1452  ip[0]) ? IP6_ERROR_SRC_LOOKUP_MISS
1453  : error[0];
1454  }
1455  if (PREDICT_FALSE (unroutable[1]))
1456  {
1457  error[1] =
1458  !ip6_urpf_loose_check (im, b[1],
1459  ip[1]) ? IP6_ERROR_SRC_LOOKUP_MISS
1460  : error[1];
1461  }
1462 
1463  vnet_buffer (b[0])->ip.fib_index =
1464  vnet_buffer (b[0])->sw_if_index[VLIB_TX] != ~0 ?
1465  vnet_buffer (b[0])->sw_if_index[VLIB_TX] :
1466  vnet_buffer (b[0])->ip.fib_index;
1467  vnet_buffer (b[1])->ip.fib_index =
1468  vnet_buffer (b[1])->sw_if_index[VLIB_TX] != ~0 ?
1469  vnet_buffer (b[1])->sw_if_index[VLIB_TX] :
1470  vnet_buffer (b[1])->ip.fib_index;
1471  } /* head_of_feature_arc */
1472 
1473  next[0] = lm->local_next_by_ip_protocol[ip[0]->protocol];
1474  next[0] =
1475  error[0] != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next[0];
1476  next[1] = lm->local_next_by_ip_protocol[ip[1]->protocol];
1477  next[1] =
1478  error[1] != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next[1];
1479 
1480  b[0]->error = error_node->errors[error[0]];
1481  b[1]->error = error_node->errors[error[1]];
1482 
1483  if (head_of_feature_arc)
1484  {
1485  u8 ip6_unknown[2];
1486  ip6_unknown[0] = error[0] == (u8) IP6_ERROR_UNKNOWN_PROTOCOL;
1487  ip6_unknown[1] = error[1] == (u8) IP6_ERROR_UNKNOWN_PROTOCOL;
1488  if (PREDICT_TRUE (ip6_unknown[0]))
1489  {
1490  u32 next32 = next[0];
1492  vnet_buffer (b[0])->sw_if_index
1493  [VLIB_RX], &next32, b[0]);
1494  next[0] = next32;
1495  }
1496  if (PREDICT_TRUE (ip6_unknown[1]))
1497  {
1498  u32 next32 = next[1];
1500  vnet_buffer (b[1])->sw_if_index
1501  [VLIB_RX], &next32, b[1]);
1502  next[1] = next32;
1503  }
1504  }
1505 
1506  /* next */
1507  b += 2;
1508  next += 2;
1509  n_left_from -= 2;
1510  }
1511 
1512  while (n_left_from)
1513  {
1514  u8 error;
1515  error = IP6_ERROR_UNKNOWN_PROTOCOL;
1516 
1517  ip6_header_t *ip;
1518  ip = vlib_buffer_get_current (b[0]);
1519 
1520  if (head_of_feature_arc)
1521  {
1522  vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data;
1523  u8 type = lm->builtin_protocol_by_ip_protocol[ip->protocol];
1524 
1525  u32 flags = b[0]->flags;
1526 
1527  vnet_buffer_oflags_t oflags = vnet_buffer (b[0])->oflags;
1528 
1529  u32 l4_offload = (flags & VNET_BUFFER_F_OFFLOAD) &&
1530  (oflags & (VNET_BUFFER_OFFLOAD_F_TCP_CKSUM |
1531  VNET_BUFFER_OFFLOAD_F_UDP_CKSUM));
1532 
1533  u32 good_l4_csum =
1534  (flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) | l4_offload;
1535  u32 udp_offset;
1536  i16 len_diff = 0;
1537  u8 is_tcp_udp = ip6_next_proto_is_tcp_udp (b[0], ip, &udp_offset);
1538  if (PREDICT_TRUE (is_tcp_udp))
1539  {
1540  udp_header_t *udp = (udp_header_t *) ((u8 *) ip + udp_offset);
1541  /* Don't verify UDP checksum for packets with explicit zero checksum. */
1542  good_l4_csum |= type == IP_BUILTIN_PROTOCOL_UDP
1543  && udp->checksum == 0;
1544  /* optimistically verify UDP length. */
1545  u16 ip_len, udp_len;
1546  ip_len = clib_net_to_host_u16 (ip->payload_length);
1547  udp_len = clib_net_to_host_u16 (udp->length);
1548  len_diff = ip_len - udp_len;
1549  }
1550 
1551  good_l4_csum |= type == IP_BUILTIN_PROTOCOL_UNKNOWN;
1552  len_diff = type == IP_BUILTIN_PROTOCOL_UDP ? len_diff : 0;
1553 
1554  u8 need_csum = type != IP_BUILTIN_PROTOCOL_UNKNOWN &&
1555  !good_l4_csum &&
1556  !(flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED);
1557  if (PREDICT_FALSE (need_csum))
1558  {
1560  good_l4_csum = flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT;
1561  error = IP6_ERROR_UNKNOWN_PROTOCOL;
1562  }
1563  else
1564  {
1565  if (ip6_tcp_udp_icmp_bad_length (vm, b[0]))
1566  error = IP6_ERROR_BAD_LENGTH;
1567  }
1568 
1569 
1570 
1571  error = len_diff < 0 ? IP6_ERROR_UDP_LENGTH : error;
1572  STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_UDP ==
1573  IP6_ERROR_UDP_CHECKSUM,
1574  "Wrong IP6 errors constants");
1575  STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_ICMP ==
1576  IP6_ERROR_ICMP_CHECKSUM,
1577  "Wrong IP6 errors constants");
1578 
1579  error = !good_l4_csum ? IP6_ERROR_UDP_CHECKSUM + type : error;
1580 
1581  /* Drop packets from unroutable hosts. */
1582  /* If this is a neighbor solicitation (ICMP), skip source RPF check */
1583  u8 unroutable = error == IP6_ERROR_UNKNOWN_PROTOCOL
1585  && !ip6_address_is_link_local_unicast (&ip->src_address);
1586  if (PREDICT_FALSE (unroutable))
1587  {
1588  error =
1589  !ip6_urpf_loose_check (im, b[0],
1590  ip) ? IP6_ERROR_SRC_LOOKUP_MISS :
1591  error;
1592  }
1593 
1594  vnet_buffer (b[0])->ip.fib_index =
1595  vnet_buffer (b[0])->sw_if_index[VLIB_TX] != ~0 ?
1596  vnet_buffer (b[0])->sw_if_index[VLIB_TX] :
1597  vnet_buffer (b[0])->ip.fib_index;
1598  } /* head_of_feature_arc */
1599 
1600  next[0] = lm->local_next_by_ip_protocol[ip->protocol];
1601  next[0] =
1602  error != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next[0];
1603 
1604  b[0]->error = error_node->errors[error];
1605 
1606  if (head_of_feature_arc)
1607  {
1608  if (PREDICT_TRUE (error == (u8) IP6_ERROR_UNKNOWN_PROTOCOL))
1609  {
1610  u32 next32 = next[0];
1612  vnet_buffer (b[0])->sw_if_index
1613  [VLIB_RX], &next32, b[0]);
1614  next[0] = next32;
1615  }
1616  }
1617 
1618  /* next */
1619  b += 1;
1620  next += 1;
1621  n_left_from -= 1;
1622  }
1623 
1625  return frame->n_vectors;
1626 }
1627 
1629  vlib_frame_t * frame)
1630 {
1631  return ip6_local_inline (vm, node, frame, 1 /* head of feature arc */ );
1632 }
1633 
1634 /* *INDENT-OFF* */
1636 {
1637  .name = "ip6-local",
1638  .vector_size = sizeof (u32),
1639  .format_trace = format_ip6_forward_next_trace,
1640  .n_next_nodes = IP_LOCAL_N_NEXT,
1641  .next_nodes =
1642  {
1643  [IP_LOCAL_NEXT_DROP] = "ip6-drop",
1644  [IP_LOCAL_NEXT_PUNT] = "ip6-punt",
1645  [IP_LOCAL_NEXT_UDP_LOOKUP] = "ip6-udp-lookup",
1646  [IP_LOCAL_NEXT_ICMP] = "ip6-icmp-input",
1647  [IP_LOCAL_NEXT_REASSEMBLY] = "ip6-full-reassembly",
1648  },
1649 };
1650 /* *INDENT-ON* */
1651 
1654  vlib_frame_t * frame)
1655 {
1656  return ip6_local_inline (vm, node, frame, 0 /* head of feature arc */ );
1657 }
1658 
1659 /* *INDENT-OFF* */
1661  .name = "ip6-local-end-of-arc",
1662  .vector_size = sizeof (u32),
1663 
1664  .format_trace = format_ip6_forward_next_trace,
1665  .sibling_of = "ip6-local",
1666 };
1667 
1668 VNET_FEATURE_INIT (ip6_local_end_of_arc, static) = {
1669  .arc_name = "ip6-local",
1670  .node_name = "ip6-local-end-of-arc",
1671  .runs_before = 0, /* not before any other features */
1672 };
1673 /* *INDENT-ON* */
1674 
1675 #ifdef CLIB_MARCH_VARIANT
1677 #else
1678 void
1680 {
1682  ip6_main_t *im = &ip6_main;
1683  ip_lookup_main_t *lm = &im->lookup_main;
1684 
1688 }
1689 
1690 void
1692 {
1693  ip6_main_t *im = &ip6_main;
1694  ip_lookup_main_t *lm = &im->lookup_main;
1695 
1698 }
1699 #endif
1700 
1701 typedef enum
1702 {
1708 
1709 /**
1710  * This bits of an IPv6 address to mask to construct a multicast
1711  * MAC address
1712  */
1713 #define IP6_MCAST_ADDR_MASK 0xffffffff
1714 
1715 always_inline void
1717  u16 adj_packet_bytes, bool is_locally_generated,
1718  u32 * next, u8 is_midchain, u32 * error)
1719 {
1720  if (adj_packet_bytes >= 1280 && packet_bytes > adj_packet_bytes)
1721  {
1722  if (is_locally_generated)
1723  {
1724  /* IP fragmentation */
1725  ip_frag_set_vnet_buffer (b, adj_packet_bytes,
1726  (is_midchain ?
1730  *error = IP6_ERROR_MTU_EXCEEDED;
1731  }
1732  else
1733  {
1734  *error = IP6_ERROR_MTU_EXCEEDED;
1735  icmp6_error_set_vnet_buffer (b, ICMP6_packet_too_big, 0,
1736  adj_packet_bytes);
1738  }
1739  }
1740 }
1741 
1745  vlib_frame_t * frame,
1746  int do_counters, int is_midchain, int is_mcast)
1747 {
1750  u32 n_left_from, n_left_to_next, *to_next, next_index;
1751  vlib_node_runtime_t *error_node =
1753 
1754  n_left_from = frame->n_vectors;
1755  next_index = node->cached_next_index;
1757 
1758  while (n_left_from > 0)
1759  {
1760  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1761 
1762  while (n_left_from >= 4 && n_left_to_next >= 2)
1763  {
1764  const ip_adjacency_t *adj0, *adj1;
1765  vlib_buffer_t *p0, *p1;
1766  ip6_header_t *ip0, *ip1;
1767  u32 pi0, rw_len0, next0, error0, adj_index0;
1768  u32 pi1, rw_len1, next1, error1, adj_index1;
1769  u32 tx_sw_if_index0, tx_sw_if_index1;
1770  bool is_locally_originated0, is_locally_originated1;
1771 
1772  /* Prefetch next iteration. */
1773  {
1774  vlib_buffer_t *p2, *p3;
1775 
1776  p2 = vlib_get_buffer (vm, from[2]);
1777  p3 = vlib_get_buffer (vm, from[3]);
1778 
1779  vlib_prefetch_buffer_header (p2, LOAD);
1780  vlib_prefetch_buffer_header (p3, LOAD);
1781 
1782  CLIB_PREFETCH (p2->pre_data, 32, STORE);
1783  CLIB_PREFETCH (p3->pre_data, 32, STORE);
1784 
1785  CLIB_PREFETCH (p2->data, sizeof (ip0[0]), STORE);
1786  CLIB_PREFETCH (p3->data, sizeof (ip0[0]), STORE);
1787  }
1788 
1789  pi0 = to_next[0] = from[0];
1790  pi1 = to_next[1] = from[1];
1791 
1792  from += 2;
1793  n_left_from -= 2;
1794  to_next += 2;
1795  n_left_to_next -= 2;
1796 
1797  p0 = vlib_get_buffer (vm, pi0);
1798  p1 = vlib_get_buffer (vm, pi1);
1799 
1800  adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
1801  adj_index1 = vnet_buffer (p1)->ip.adj_index[VLIB_TX];
1802 
1803  ip0 = vlib_buffer_get_current (p0);
1804  ip1 = vlib_buffer_get_current (p1);
1805 
1806  error0 = error1 = IP6_ERROR_NONE;
1807  next0 = next1 = IP6_REWRITE_NEXT_DROP;
1808 
1809  is_locally_originated0 =
1810  p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED;
1811  if (PREDICT_TRUE (!is_locally_originated0))
1812  {
1813  i32 hop_limit0 = ip0->hop_limit;
1814 
1815  /* Input node should have reject packets with hop limit 0. */
1816  ASSERT (ip0->hop_limit > 0);
1817 
1818  hop_limit0 -= 1;
1819 
1820  ip0->hop_limit = hop_limit0;
1821 
1822  /*
1823  * If the hop count drops below 1 when forwarding, generate
1824  * an ICMP response.
1825  */
1826  if (PREDICT_FALSE (hop_limit0 <= 0))
1827  {
1828  error0 = IP6_ERROR_TIME_EXPIRED;
1830  vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
1831  icmp6_error_set_vnet_buffer (p0, ICMP6_time_exceeded,
1832  ICMP6_time_exceeded_ttl_exceeded_in_transit,
1833  0);
1834  }
1835  }
1836 
1837  is_locally_originated1 =
1838  p1->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED;
1839  if (PREDICT_TRUE (!is_locally_originated1))
1840  {
1841  i32 hop_limit1 = ip1->hop_limit;
1842 
1843  /* Input node should have reject packets with hop limit 0. */
1844  ASSERT (ip1->hop_limit > 0);
1845 
1846  hop_limit1 -= 1;
1847 
1848  ip1->hop_limit = hop_limit1;
1849 
1850  /*
1851  * If the hop count drops below 1 when forwarding, generate
1852  * an ICMP response.
1853  */
1854  if (PREDICT_FALSE (hop_limit1 <= 0))
1855  {
1856  error1 = IP6_ERROR_TIME_EXPIRED;
1858  vnet_buffer (p1)->sw_if_index[VLIB_TX] = (u32) ~ 0;
1859  icmp6_error_set_vnet_buffer (p1, ICMP6_time_exceeded,
1860  ICMP6_time_exceeded_ttl_exceeded_in_transit,
1861  0);
1862  }
1863  }
1864 
1865  adj0 = adj_get (adj_index0);
1866  adj1 = adj_get (adj_index1);
1867 
1868  rw_len0 = adj0[0].rewrite_header.data_bytes;
1869  rw_len1 = adj1[0].rewrite_header.data_bytes;
1870  vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
1871  vnet_buffer (p1)->ip.save_rewrite_length = rw_len1;
1872 
1873  if (do_counters)
1874  {
1877  thread_index, adj_index0, 1,
1878  vlib_buffer_length_in_chain (vm, p0) + rw_len0);
1881  thread_index, adj_index1, 1,
1882  vlib_buffer_length_in_chain (vm, p1) + rw_len1);
1883  }
1884 
1885  /* Check MTU of outgoing interface. */
1886  u16 ip0_len =
1887  clib_net_to_host_u16 (ip0->payload_length) +
1888  sizeof (ip6_header_t);
1889  u16 ip1_len =
1890  clib_net_to_host_u16 (ip1->payload_length) +
1891  sizeof (ip6_header_t);
1892  if (p0->flags & VNET_BUFFER_F_GSO)
1893  ip0_len = gso_mtu_sz (p0);
1894  if (p1->flags & VNET_BUFFER_F_GSO)
1895  ip1_len = gso_mtu_sz (p1);
1896 
1897  ip6_mtu_check (p0, ip0_len,
1898  adj0[0].rewrite_header.max_l3_packet_bytes,
1899  is_locally_originated0, &next0, is_midchain,
1900  &error0);
1901  ip6_mtu_check (p1, ip1_len,
1902  adj1[0].rewrite_header.max_l3_packet_bytes,
1903  is_locally_originated1, &next1, is_midchain,
1904  &error1);
1905  /* Don't adjust the buffer for hop count issue; icmp-error node
1906  * wants to see the IP header */
1907  if (PREDICT_TRUE (error0 == IP6_ERROR_NONE))
1908  {
1909  p0->current_data -= rw_len0;
1910  p0->current_length += rw_len0;
1911  tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
1912  vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0;
1913  next0 = adj0[0].rewrite_header.next_index;
1914  if (PREDICT_FALSE
1915  (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
1917  (lm->output_feature_arc_index, tx_sw_if_index0, &next0, p0,
1918  adj0->ia_cfg_index);
1919  }
1920  else
1921  {
1922  p0->error = error_node->errors[error0];
1923  }
1924  if (PREDICT_TRUE (error1 == IP6_ERROR_NONE))
1925  {
1926  p1->current_data -= rw_len1;
1927  p1->current_length += rw_len1;
1928 
1929  tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index;
1930  vnet_buffer (p1)->sw_if_index[VLIB_TX] = tx_sw_if_index1;
1931  next1 = adj1[0].rewrite_header.next_index;
1932 
1933  if (PREDICT_FALSE
1934  (adj1[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
1936  (lm->output_feature_arc_index, tx_sw_if_index1, &next1, p1,
1937  adj1->ia_cfg_index);
1938  }
1939  else
1940  {
1941  p1->error = error_node->errors[error1];
1942  }
1943 
1944  if (is_midchain)
1945  {
1946  /* before we paint on the next header, update the L4
1947  * checksums if required, since there's no offload on a tunnel */
1948  vnet_calc_checksums_inline (vm, p0, 0 /* is_ip4 */ ,
1949  1 /* is_ip6 */ );
1950  vnet_calc_checksums_inline (vm, p1, 0 /* is_ip4 */ ,
1951  1 /* is_ip6 */ );
1952 
1953  /* Guess we are only writing on ipv6 header. */
1954  vnet_rewrite_two_headers (adj0[0], adj1[0],
1955  ip0, ip1, sizeof (ip6_header_t));
1956  }
1957  else
1958  /* Guess we are only writing on simple Ethernet header. */
1959  vnet_rewrite_two_headers (adj0[0], adj1[0],
1960  ip0, ip1, sizeof (ethernet_header_t));
1961 
1962  if (is_midchain)
1963  {
1964  if (adj0->sub_type.midchain.fixup_func)
1965  adj0->sub_type.midchain.fixup_func
1966  (vm, adj0, p0, adj0->sub_type.midchain.fixup_data);
1967  if (adj1->sub_type.midchain.fixup_func)
1968  adj1->sub_type.midchain.fixup_func
1969  (vm, adj1, p1, adj1->sub_type.midchain.fixup_data);
1970  }
1971  if (is_mcast)
1972  {
1973  /*
1974  * copy bytes from the IP address into the MAC rewrite
1975  */
1977  adj0->
1978  rewrite_header.dst_mcast_offset,
1979  &ip0->dst_address.as_u32[3],
1980  (u8 *) ip0);
1982  adj1->
1983  rewrite_header.dst_mcast_offset,
1984  &ip1->dst_address.as_u32[3],
1985  (u8 *) ip1);
1986  }
1987 
1989  to_next, n_left_to_next,
1990  pi0, pi1, next0, next1);
1991  }
1992 
1993  while (n_left_from > 0 && n_left_to_next > 0)
1994  {
1995  ip_adjacency_t *adj0;
1996  vlib_buffer_t *p0;
1997  ip6_header_t *ip0;
1998  u32 pi0, rw_len0;
1999  u32 adj_index0, next0, error0;
2000  u32 tx_sw_if_index0;
2001  bool is_locally_originated0;
2002 
2003  pi0 = to_next[0] = from[0];
2004 
2005  p0 = vlib_get_buffer (vm, pi0);
2006 
2007  adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
2008 
2009  adj0 = adj_get (adj_index0);
2010 
2011  ip0 = vlib_buffer_get_current (p0);
2012 
2013  error0 = IP6_ERROR_NONE;
2014  next0 = IP6_REWRITE_NEXT_DROP;
2015 
2016  /* Check hop limit */
2017  is_locally_originated0 =
2018  p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED;
2019  if (PREDICT_TRUE (!is_locally_originated0))
2020  {
2021  i32 hop_limit0 = ip0->hop_limit;
2022 
2023  ASSERT (ip0->hop_limit > 0);
2024 
2025  hop_limit0 -= 1;
2026 
2027  ip0->hop_limit = hop_limit0;
2028 
2029  if (PREDICT_FALSE (hop_limit0 <= 0))
2030  {
2031  /*
2032  * If the hop count drops below 1 when forwarding, generate
2033  * an ICMP response.
2034  */
2035  error0 = IP6_ERROR_TIME_EXPIRED;
2037  vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
2038  icmp6_error_set_vnet_buffer (p0, ICMP6_time_exceeded,
2039  ICMP6_time_exceeded_ttl_exceeded_in_transit,
2040  0);
2041  }
2042  }
2043 
2044  if (is_midchain)
2045  {
2046  vnet_calc_checksums_inline (vm, p0, 0 /* is_ip4 */ ,
2047  1 /* is_ip6 */ );
2048 
2049  /* Guess we are only writing on ip6 header. */
2050  vnet_rewrite_one_header (adj0[0], ip0, sizeof (ip6_header_t));
2051  }
2052  else
2053  /* Guess we are only writing on simple Ethernet header. */
2054  vnet_rewrite_one_header (adj0[0], ip0,
2055  sizeof (ethernet_header_t));
2056 
2057  /* Update packet buffer attributes/set output interface. */
2058  rw_len0 = adj0[0].rewrite_header.data_bytes;
2059  vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2060 
2061  if (do_counters)
2062  {
2065  thread_index, adj_index0, 1,
2066  vlib_buffer_length_in_chain (vm, p0) + rw_len0);
2067  }
2068 
2069  /* Check MTU of outgoing interface. */
2070  u16 ip0_len =
2071  clib_net_to_host_u16 (ip0->payload_length) +
2072  sizeof (ip6_header_t);
2073  if (p0->flags & VNET_BUFFER_F_GSO)
2074  ip0_len = gso_mtu_sz (p0);
2075 
2076  ip6_mtu_check (p0, ip0_len,
2077  adj0[0].rewrite_header.max_l3_packet_bytes,
2078  is_locally_originated0, &next0, is_midchain,
2079  &error0);
2080  /* Don't adjust the buffer for hop count issue; icmp-error node
2081  * wants to see the IP header */
2082  if (PREDICT_TRUE (error0 == IP6_ERROR_NONE))
2083  {
2084  p0->current_data -= rw_len0;
2085  p0->current_length += rw_len0;
2086 
2087  tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2088 
2089  vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0;
2090  next0 = adj0[0].rewrite_header.next_index;
2091 
2092  if (PREDICT_FALSE
2093  (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2095  (lm->output_feature_arc_index, tx_sw_if_index0, &next0, p0,
2096  adj0->ia_cfg_index);
2097  }
2098  else
2099  {
2100  p0->error = error_node->errors[error0];
2101  }
2102 
2103  if (is_midchain)
2104  {
2105  if (adj0->sub_type.midchain.fixup_func)
2106  adj0->sub_type.midchain.fixup_func
2107  (vm, adj0, p0, adj0->sub_type.midchain.fixup_data);
2108  }
2109  if (is_mcast)
2110  {
2112  adj0->
2113  rewrite_header.dst_mcast_offset,
2114  &ip0->dst_address.as_u32[3],
2115  (u8 *) ip0);
2116  }
2117 
2118  from += 1;
2119  n_left_from -= 1;
2120  to_next += 1;
2121  n_left_to_next -= 1;
2122 
2124  to_next, n_left_to_next,
2125  pi0, next0);
2126  }
2127 
2128  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2129  }
2130 
2131  /* Need to do trace after rewrites to pick up new packet data. */
2132  if (node->flags & VLIB_NODE_FLAG_TRACE)
2134 
2135  return frame->n_vectors;
2136 }
2137 
2141  vlib_frame_t * frame,
2142  int do_counters, int is_midchain, int is_mcast)
2143 {
2144  return ip6_rewrite_inline_with_gso (vm, node, frame, do_counters,
2145  is_midchain, is_mcast);
2146 }
2147 
2150  vlib_frame_t * frame)
2151 {
2152  if (adj_are_counters_enabled ())
2153  return ip6_rewrite_inline (vm, node, frame, 1, 0, 0);
2154  else
2155  return ip6_rewrite_inline (vm, node, frame, 0, 0, 0);
2156 }
2157 
2160  vlib_frame_t * frame)
2161 {
2162  if (adj_are_counters_enabled ())
2163  return ip6_rewrite_inline (vm, node, frame, 1, 0, 0);
2164  else
2165  return ip6_rewrite_inline (vm, node, frame, 0, 0, 0);
2166 }
2167 
2170  vlib_frame_t * frame)
2171 {
2172  if (adj_are_counters_enabled ())
2173  return ip6_rewrite_inline (vm, node, frame, 1, 0, 1);
2174  else
2175  return ip6_rewrite_inline (vm, node, frame, 0, 0, 1);
2176 }
2177 
2180  vlib_frame_t * frame)
2181 {
2182  if (adj_are_counters_enabled ())
2183  return ip6_rewrite_inline (vm, node, frame, 1, 1, 0);
2184  else
2185  return ip6_rewrite_inline (vm, node, frame, 0, 1, 0);
2186 }
2187 
2190  vlib_frame_t * frame)
2191 {
2192  if (adj_are_counters_enabled ())
2193  return ip6_rewrite_inline (vm, node, frame, 1, 1, 1);
2194  else
2195  return ip6_rewrite_inline (vm, node, frame, 0, 1, 1);
2196 }
2197 
2198 /* *INDENT-OFF* */
2200 {
2201  .name = "ip6-midchain",
2202  .vector_size = sizeof (u32),
2203  .format_trace = format_ip6_forward_next_trace,
2204  .sibling_of = "ip6-rewrite",
2205  };
2206 
2208 {
2209  .name = "ip6-rewrite",
2210  .vector_size = sizeof (u32),
2211  .format_trace = format_ip6_rewrite_trace,
2212  .n_next_nodes = IP6_REWRITE_N_NEXT,
2213  .next_nodes =
2214  {
2215  [IP6_REWRITE_NEXT_DROP] = "ip6-drop",
2216  [IP6_REWRITE_NEXT_ICMP_ERROR] = "ip6-icmp-error",
2217  [IP6_REWRITE_NEXT_FRAGMENT] = "ip6-frag",
2218  },
2219 };
2220 
2222  .name = "ip6-rewrite-bcast",
2223  .vector_size = sizeof (u32),
2224 
2225  .format_trace = format_ip6_rewrite_trace,
2226  .sibling_of = "ip6-rewrite",
2227 };
2228 
2230 {
2231  .name = "ip6-rewrite-mcast",
2232  .vector_size = sizeof (u32),
2233  .format_trace = format_ip6_rewrite_trace,
2234  .sibling_of = "ip6-rewrite",
2235 };
2236 
2237 
2239 {
2240  .name = "ip6-mcast-midchain",
2241  .vector_size = sizeof (u32),
2242  .format_trace = format_ip6_rewrite_trace,
2243  .sibling_of = "ip6-rewrite",
2244 };
2245 
2246 /* *INDENT-ON* */
2247 
2248 /*
2249  * Hop-by-Hop handling
2250  */
2251 #ifndef CLIB_MARCH_VARIANT
2253 #endif /* CLIB_MARCH_VARIANT */
2254 
2255 #define foreach_ip6_hop_by_hop_error \
2256 _(PROCESSED, "pkts with ip6 hop-by-hop options") \
2257 _(FORMAT, "incorrectly formatted hop-by-hop options") \
2258 _(UNKNOWN_OPTION, "unknown ip6 hop-by-hop options")
2259 
2260 /* *INDENT-OFF* */
2261 typedef enum
2262 {
2263 #define _(sym,str) IP6_HOP_BY_HOP_ERROR_##sym,
2265 #undef _
2268 /* *INDENT-ON* */
2269 
2270 /*
2271  * Primary h-b-h handler trace support
2272  * We work pretty hard on the problem for obvious reasons
2273  */
2274 typedef struct
2275 {
2278  u8 option_data[256];
2280 
2282 
2284 #define _(sym,string) string,
2286 #undef _
2287 };
2288 
2289 #ifndef CLIB_MARCH_VARIANT
2290 u8 *
2291 format_ip6_hop_by_hop_ext_hdr (u8 * s, va_list * args)
2292 {
2293  ip6_hop_by_hop_header_t *hbh0 = va_arg (*args, ip6_hop_by_hop_header_t *);
2294  int total_len = va_arg (*args, int);
2295  ip6_hop_by_hop_option_t *opt0, *limit0;
2297  u8 type0;
2298  s = format (s, "IP6_HOP_BY_HOP: next protocol %d len %d total %d",
2299  hbh0->protocol, (hbh0->length + 1) << 3, total_len);
2300 
2301  opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1);
2302  limit0 = (ip6_hop_by_hop_option_t *) ((u8 *) hbh0 + total_len);
2303 
2304  while (opt0 < limit0)
2305  {
2306  type0 = opt0->type;
2307  switch (type0)
2308  {
2309  case 0: /* Pad, just stop */
2310  opt0 = (ip6_hop_by_hop_option_t *) ((u8 *) opt0 + 1);
2311  break;
2312 
2313  default:
2314  if (hm->trace[type0])
2315  {
2316  s = (*hm->trace[type0]) (s, opt0);
2317  }
2318  else
2319  {
2320  s = format (s, "\n unrecognized option %d length %d", type0,
2321  opt0->length);
2322  }
2323  opt0 =
2324  (ip6_hop_by_hop_option_t *) (((u8 *) opt0) + opt0->length +
2325  sizeof (ip6_hop_by_hop_option_t));
2326  break;
2327  }
2328  }
2329  return s;
2330 }
2331 #endif
2332 
2333 static u8 *
2334 format_ip6_hop_by_hop_trace (u8 * s, va_list * args)
2335 {
2336  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
2337  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
2338  ip6_hop_by_hop_trace_t *t = va_arg (*args, ip6_hop_by_hop_trace_t *);
2340  ip6_hop_by_hop_option_t *opt0, *limit0;
2342 
2343  u8 type0;
2344 
2345  hbh0 = (ip6_hop_by_hop_header_t *) t->option_data;
2346 
2347  s = format (s, "IP6_HOP_BY_HOP: next index %d len %d traced %d",
2348  t->next_index, (hbh0->length + 1) << 3, t->trace_len);
2349 
2350  opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1);
2351  limit0 = (ip6_hop_by_hop_option_t *) ((u8 *) hbh0) + t->trace_len;
2352 
2353  while (opt0 < limit0)
2354  {
2355  type0 = opt0->type;
2356  switch (type0)
2357  {
2358  case 0: /* Pad, just stop */
2359  opt0 = (ip6_hop_by_hop_option_t *) ((u8 *) opt0) + 1;
2360  break;
2361 
2362  default:
2363  if (hm->trace[type0])
2364  {
2365  s = (*hm->trace[type0]) (s, opt0);
2366  }
2367  else
2368  {
2369  s = format (s, "\n unrecognized option %d length %d", type0,
2370  opt0->length);
2371  }
2372  opt0 =
2373  (ip6_hop_by_hop_option_t *) (((u8 *) opt0) + opt0->length +
2374  sizeof (ip6_hop_by_hop_option_t));
2375  break;
2376  }
2377  }
2378  return s;
2379 }
2380 
2383  ip6_header_t * ip0,
2384  ip6_hop_by_hop_header_t * hbh0,
2385  ip6_hop_by_hop_option_t * opt0,
2386  ip6_hop_by_hop_option_t * limit0, u32 * next0)
2387 {
2389  u8 type0;
2390  u8 error0 = 0;
2391 
2392  while (opt0 < limit0)
2393  {
2394  type0 = opt0->type;
2395  switch (type0)
2396  {
2397  case 0: /* Pad1 */
2398  opt0 = (ip6_hop_by_hop_option_t *) ((u8 *) opt0) + 1;
2399  continue;
2400  case 1: /* PadN */
2401  break;
2402  default:
2403  if (hm->options[type0])
2404  {
2405  if ((*hm->options[type0]) (b0, ip0, opt0) < 0)
2406  {
2407  error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2408  return (error0);
2409  }
2410  }
2411  else
2412  {
2413  /* Unrecognized mandatory option, check the two high order bits */
2414  switch (opt0->type & HBH_OPTION_TYPE_HIGH_ORDER_BITS)
2415  {
2417  break;
2419  error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2420  *next0 = IP_LOOKUP_NEXT_DROP;
2421  break;
2423  error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2424  *next0 = IP_LOOKUP_NEXT_ICMP_ERROR;
2425  icmp6_error_set_vnet_buffer (b0, ICMP6_parameter_problem,
2426  ICMP6_parameter_problem_unrecognized_option,
2427  (u8 *) opt0 - (u8 *) ip0);
2428  break;
2430  error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION;
2431  if (!ip6_address_is_multicast (&ip0->dst_address))
2432  {
2433  *next0 = IP_LOOKUP_NEXT_ICMP_ERROR;
2435  ICMP6_parameter_problem,
2436  ICMP6_parameter_problem_unrecognized_option,
2437  (u8 *) opt0 - (u8 *) ip0);
2438  }
2439  else
2440  {
2441  *next0 = IP_LOOKUP_NEXT_DROP;
2442  }
2443  break;
2444  }
2445  return (error0);
2446  }
2447  }
2448  opt0 =
2449  (ip6_hop_by_hop_option_t *) (((u8 *) opt0) + opt0->length +
2450  sizeof (ip6_hop_by_hop_option_t));
2451  }
2452  return (error0);
2453 }
2454 
2455 /*
2456  * Process the Hop-by-Hop Options header
2457  */
2460  vlib_frame_t * frame)
2461 {
2462  vlib_node_runtime_t *error_node =
2465  u32 n_left_from, *from, *to_next;
2467 
2469  n_left_from = frame->n_vectors;
2470  next_index = node->cached_next_index;
2471 
2472  while (n_left_from > 0)
2473  {
2474  u32 n_left_to_next;
2475 
2476  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2477 
2478  while (n_left_from >= 4 && n_left_to_next >= 2)
2479  {
2480  u32 bi0, bi1;
2481  vlib_buffer_t *b0, *b1;
2482  u32 next0, next1;
2483  ip6_header_t *ip0, *ip1;
2484  ip6_hop_by_hop_header_t *hbh0, *hbh1;
2485  ip6_hop_by_hop_option_t *opt0, *limit0, *opt1, *limit1;
2486  u8 error0 = 0, error1 = 0;
2487 
2488  /* Prefetch next iteration. */
2489  {
2490  vlib_buffer_t *p2, *p3;
2491 
2492  p2 = vlib_get_buffer (vm, from[2]);
2493  p3 = vlib_get_buffer (vm, from[3]);
2494 
2495  vlib_prefetch_buffer_header (p2, LOAD);
2496  vlib_prefetch_buffer_header (p3, LOAD);
2497 
2498  CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
2499  CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
2500  }
2501 
2502  /* Speculatively enqueue b0, b1 to the current next frame */
2503  to_next[0] = bi0 = from[0];
2504  to_next[1] = bi1 = from[1];
2505  from += 2;
2506  to_next += 2;
2507  n_left_from -= 2;
2508  n_left_to_next -= 2;
2509 
2510  b0 = vlib_get_buffer (vm, bi0);
2511  b1 = vlib_get_buffer (vm, bi1);
2512 
2513  /* Default use the next_index from the adjacency. A HBH option rarely redirects to a different node */
2514  u32 adj_index0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
2515  ip_adjacency_t *adj0 = adj_get (adj_index0);
2516  u32 adj_index1 = vnet_buffer (b1)->ip.adj_index[VLIB_TX];
2517  ip_adjacency_t *adj1 = adj_get (adj_index1);
2518 
2519  /* Default use the next_index from the adjacency. A HBH option rarely redirects to a different node */
2520  next0 = adj0->lookup_next_index;
2521  next1 = adj1->lookup_next_index;
2522 
2523  ip0 = vlib_buffer_get_current (b0);
2524  ip1 = vlib_buffer_get_current (b1);
2525  hbh0 = (ip6_hop_by_hop_header_t *) (ip0 + 1);
2526  hbh1 = (ip6_hop_by_hop_header_t *) (ip1 + 1);
2527  opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1);
2528  opt1 = (ip6_hop_by_hop_option_t *) (hbh1 + 1);
2529  limit0 =
2530  (ip6_hop_by_hop_option_t *) ((u8 *) hbh0 +
2531  ((hbh0->length + 1) << 3));
2532  limit1 =
2533  (ip6_hop_by_hop_option_t *) ((u8 *) hbh1 +
2534  ((hbh1->length + 1) << 3));
2535 
2536  /*
2537  * Basic validity checks
2538  */
2539  if ((hbh0->length + 1) << 3 >
2540  clib_net_to_host_u16 (ip0->payload_length))
2541  {
2542  error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2543  next0 = IP_LOOKUP_NEXT_DROP;
2544  goto outdual;
2545  }
2546  /* Scan the set of h-b-h options, process ones that we understand */
2547  error0 = ip6_scan_hbh_options (b0, ip0, hbh0, opt0, limit0, &next0);
2548 
2549  if ((hbh1->length + 1) << 3 >
2550  clib_net_to_host_u16 (ip1->payload_length))
2551  {
2552  error1 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2553  next1 = IP_LOOKUP_NEXT_DROP;
2554  goto outdual;
2555  }
2556  /* Scan the set of h-b-h options, process ones that we understand */
2557  error1 = ip6_scan_hbh_options (b1, ip1, hbh1, opt1, limit1, &next1);
2558 
2559  outdual:
2560  /* Has the classifier flagged this buffer for special treatment? */
2561  if (PREDICT_FALSE
2562  ((error0 == 0)
2563  && (vnet_buffer (b0)->l2_classify.opaque_index & OI_DECAP)))
2564  next0 = hm->next_override;
2565 
2566  /* Has the classifier flagged this buffer for special treatment? */
2567  if (PREDICT_FALSE
2568  ((error1 == 0)
2569  && (vnet_buffer (b1)->l2_classify.opaque_index & OI_DECAP)))
2570  next1 = hm->next_override;
2571 
2572  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
2573  {
2574  if (b0->flags & VLIB_BUFFER_IS_TRACED)
2575  {
2577  vlib_add_trace (vm, node, b0, sizeof (*t));
2578  u32 trace_len = (hbh0->length + 1) << 3;
2579  t->next_index = next0;
2580  /* Capture the h-b-h option verbatim */
2581  trace_len =
2582  trace_len <
2583  ARRAY_LEN (t->option_data) ? trace_len :
2584  ARRAY_LEN (t->option_data);
2585  t->trace_len = trace_len;
2586  clib_memcpy_fast (t->option_data, hbh0, trace_len);
2587  }
2588  if (b1->flags & VLIB_BUFFER_IS_TRACED)
2589  {
2591  vlib_add_trace (vm, node, b1, sizeof (*t));
2592  u32 trace_len = (hbh1->length + 1) << 3;
2593  t->next_index = next1;
2594  /* Capture the h-b-h option verbatim */
2595  trace_len =
2596  trace_len <
2597  ARRAY_LEN (t->option_data) ? trace_len :
2598  ARRAY_LEN (t->option_data);
2599  t->trace_len = trace_len;
2600  clib_memcpy_fast (t->option_data, hbh1, trace_len);
2601  }
2602 
2603  }
2604 
2605  b0->error = error_node->errors[error0];
2606  b1->error = error_node->errors[error1];
2607 
2608  /* verify speculative enqueue, maybe switch current next frame */
2610  n_left_to_next, bi0, bi1, next0,
2611  next1);
2612  }
2613 
2614  while (n_left_from > 0 && n_left_to_next > 0)
2615  {
2616  u32 bi0;
2617  vlib_buffer_t *b0;
2618  u32 next0;
2619  ip6_header_t *ip0;
2621  ip6_hop_by_hop_option_t *opt0, *limit0;
2622  u8 error0 = 0;
2623 
2624  /* Speculatively enqueue b0 to the current next frame */
2625  bi0 = from[0];
2626  to_next[0] = bi0;
2627  from += 1;
2628  to_next += 1;
2629  n_left_from -= 1;
2630  n_left_to_next -= 1;
2631 
2632  b0 = vlib_get_buffer (vm, bi0);
2633  /*
2634  * Default use the next_index from the adjacency.
2635  * A HBH option rarely redirects to a different node
2636  */
2637  u32 adj_index0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
2638  ip_adjacency_t *adj0 = adj_get (adj_index0);
2639  next0 = adj0->lookup_next_index;
2640 
2641  ip0 = vlib_buffer_get_current (b0);
2642  hbh0 = (ip6_hop_by_hop_header_t *) (ip0 + 1);
2643  opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1);
2644  limit0 =
2645  (ip6_hop_by_hop_option_t *) ((u8 *) hbh0 +
2646  ((hbh0->length + 1) << 3));
2647 
2648  /*
2649  * Basic validity checks
2650  */
2651  if ((hbh0->length + 1) << 3 >
2652  clib_net_to_host_u16 (ip0->payload_length))
2653  {
2654  error0 = IP6_HOP_BY_HOP_ERROR_FORMAT;
2655  next0 = IP_LOOKUP_NEXT_DROP;
2656  goto out0;
2657  }
2658 
2659  /* Scan the set of h-b-h options, process ones that we understand */
2660  error0 = ip6_scan_hbh_options (b0, ip0, hbh0, opt0, limit0, &next0);
2661 
2662  out0:
2663  /* Has the classifier flagged this buffer for special treatment? */
2664  if (PREDICT_FALSE
2665  ((error0 == 0)
2666  && (vnet_buffer (b0)->l2_classify.opaque_index & OI_DECAP)))
2667  next0 = hm->next_override;
2668 
2669  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2670  {
2672  vlib_add_trace (vm, node, b0, sizeof (*t));
2673  u32 trace_len = (hbh0->length + 1) << 3;
2674  t->next_index = next0;
2675  /* Capture the h-b-h option verbatim */
2676  trace_len =
2677  trace_len <
2678  ARRAY_LEN (t->option_data) ? trace_len :
2679  ARRAY_LEN (t->option_data);
2680  t->trace_len = trace_len;
2681  clib_memcpy_fast (t->option_data, hbh0, trace_len);
2682  }
2683 
2684  b0->error = error_node->errors[error0];
2685 
2686  /* verify speculative enqueue, maybe switch current next frame */
2688  n_left_to_next, bi0, next0);
2689  }
2690  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2691  }
2692  return frame->n_vectors;
2693 }
2694 
2695 /* *INDENT-OFF* */
2697 {
2698  .name = "ip6-hop-by-hop",
2699  .sibling_of = "ip6-lookup",
2700  .vector_size = sizeof (u32),
2701  .format_trace = format_ip6_hop_by_hop_trace,
2704  .error_strings = ip6_hop_by_hop_error_strings,
2705  .n_next_nodes = 0,
2706 };
2707 /* *INDENT-ON* */
2708 
2709 static clib_error_t *
2711 {
2713  clib_memset (hm->options, 0, sizeof (hm->options));
2714  clib_memset (hm->trace, 0, sizeof (hm->trace));
2716  return (0);
2717 }
2718 
2720 
2721 #ifndef CLIB_MARCH_VARIANT
2722 void
2724 {
2726 
2727  hm->next_override = next;
2728 }
2729 
2730 int
2733  ip6_hop_by_hop_option_t * opt),
2734  u8 * trace (u8 * s, ip6_hop_by_hop_option_t * opt))
2735 {
2736  ip6_main_t *im = &ip6_main;
2738 
2739  ASSERT ((u32) option < ARRAY_LEN (hm->options));
2740 
2741  /* Already registered */
2742  if (hm->options[option])
2743  return (-1);
2744 
2745  hm->options[option] = options;
2746  hm->trace[option] = trace;
2747 
2748  /* Set global variable */
2749  im->hbh_enabled = 1;
2750 
2751  return (0);
2752 }
2753 
2754 int
2756 {
2757  ip6_main_t *im = &ip6_main;
2759 
2760  ASSERT ((u32) option < ARRAY_LEN (hm->options));
2761 
2762  /* Not registered */
2763  if (!hm->options[option])
2764  return (-1);
2765 
2766  hm->options[option] = NULL;
2767  hm->trace[option] = NULL;
2768 
2769  /* Disable global knob if this was the last option configured */
2770  int i;
2771  bool found = false;
2772  for (i = 0; i < 256; i++)
2773  {
2774  if (hm->options[option])
2775  {
2776  found = true;
2777  break;
2778  }
2779  }
2780  if (!found)
2781  im->hbh_enabled = 0;
2782 
2783  return (0);
2784 }
2785 
2786 /* Global IP6 main. */
2788 #endif
2789 
2790 static clib_error_t *
2792 {
2793  ip6_main_t *im = &ip6_main;
2795  uword i;
2796 
2798  return error;
2799 
2800  for (i = 0; i < ARRAY_LEN (im->fib_masks); i++)
2801  {
2802  u32 j, i0, i1;
2803 
2804  i0 = i / 32;
2805  i1 = i % 32;
2806 
2807  for (j = 0; j < i0; j++)
2808  im->fib_masks[i].as_u32[j] = ~0;
2809 
2810  if (i1)
2811  im->fib_masks[i].as_u32[i0] =
2812  clib_host_to_net_u32 (pow2_mask (i1) << (32 - i1));
2813  }
2814 
2815  ip_lookup_init (&im->lookup_main, /* is_ip6 */ 1);
2816 
2817  /* Create FIB with index 0 and table id of 0. */
2822 
2823  {
2824  pg_node_t *pn;
2825  pn = pg_get_node (ip6_lookup_node.index);
2827  }
2828 
2829  /* Unless explicitly configured, don't process HBH options */
2830  im->hbh_enabled = 0;
2831 
2832  return error;
2833 }
2834 
2836 
2837 static clib_error_t *
2839  unformat_input_t * input,
2840  vlib_cli_command_t * cmd)
2841 {
2842  int matched = 0;
2843  u32 table_id = 0;
2844  u32 flow_hash_config = 0;
2845  int rv;
2846 
2847  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2848  {
2849  if (unformat (input, "table %d", &table_id))
2850  matched = 1;
2851 #define _(a, b, v) \
2852  else if (unformat (input, #a)) \
2853  { \
2854  flow_hash_config |= v; \
2855  matched = 1; \
2856  }
2858 #undef _
2859  else
2860  break;
2861  }
2862 
2863  if (matched == 0)
2864  return clib_error_return (0, "unknown input `%U'",
2865  format_unformat_error, input);
2866 
2867  rv = ip_flow_hash_set (AF_IP6, table_id, flow_hash_config);
2868  switch (rv)
2869  {
2870  case 0:
2871  break;
2872 
2873  case -1:
2874  return clib_error_return (0, "no such FIB table %d", table_id);
2875 
2876  default:
2877  clib_warning ("BUG: illegal flow hash config 0x%x", flow_hash_config);
2878  break;
2879  }
2880 
2881  return 0;
2882 }
2883 
2884 /*?
2885  * Configure the set of IPv6 fields used by the flow hash.
2886  *
2887  * @cliexpar
2888  * @parblock
2889  * Example of how to set the flow hash on a given table:
2890  * @cliexcmd{set ip6 flow-hash table 8 dst sport dport proto}
2891  *
2892  * Example of display the configured flow hash:
2893  * @cliexstart{show ip6 fib}
2894  * ipv6-VRF:0, fib_index 0, flow hash: src dst sport dport proto
2895  * @::/0
2896  * unicast-ip6-chain
2897  * [@0]: dpo-load-balance: [index:5 buckets:1 uRPF:5 to:[0:0]]
2898  * [0] [@0]: dpo-drop ip6
2899  * fe80::/10
2900  * unicast-ip6-chain
2901  * [@0]: dpo-load-balance: [index:10 buckets:1 uRPF:10 to:[0:0]]
2902  * [0] [@2]: dpo-receive
2903  * ff02::1/128
2904  * unicast-ip6-chain
2905  * [@0]: dpo-load-balance: [index:8 buckets:1 uRPF:8 to:[0:0]]
2906  * [0] [@2]: dpo-receive
2907  * ff02::2/128
2908  * unicast-ip6-chain
2909  * [@0]: dpo-load-balance: [index:7 buckets:1 uRPF:7 to:[0:0]]
2910  * [0] [@2]: dpo-receive
2911  * ff02::16/128
2912  * unicast-ip6-chain
2913  * [@0]: dpo-load-balance: [index:9 buckets:1 uRPF:9 to:[0:0]]
2914  * [0] [@2]: dpo-receive
2915  * ff02::1:ff00:0/104
2916  * unicast-ip6-chain
2917  * [@0]: dpo-load-balance: [index:6 buckets:1 uRPF:6 to:[0:0]]
2918  * [0] [@2]: dpo-receive
2919  * ipv6-VRF:8, fib_index 1, flow hash: dst sport dport proto
2920  * @::/0
2921  * unicast-ip6-chain
2922  * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
2923  * [0] [@0]: dpo-drop ip6
2924  * @::a:1:1:0:4/126
2925  * unicast-ip6-chain
2926  * [@0]: dpo-load-balance: [index:27 buckets:1 uRPF:26 to:[0:0]]
2927  * [0] [@4]: ipv6-glean: af_packet0
2928  * @::a:1:1:0:7/128
2929  * unicast-ip6-chain
2930  * [@0]: dpo-load-balance: [index:28 buckets:1 uRPF:27 to:[0:0]]
2931  * [0] [@2]: dpo-receive: @::a:1:1:0:7 on af_packet0
2932  * fe80::/10
2933  * unicast-ip6-chain
2934  * [@0]: dpo-load-balance: [index:26 buckets:1 uRPF:25 to:[0:0]]
2935  * [0] [@2]: dpo-receive
2936  * fe80::fe:3eff:fe3e:9222/128
2937  * unicast-ip6-chain
2938  * [@0]: dpo-load-balance: [index:29 buckets:1 uRPF:28 to:[0:0]]
2939  * [0] [@2]: dpo-receive: fe80::fe:3eff:fe3e:9222 on af_packet0
2940  * ff02::1/128
2941  * unicast-ip6-chain
2942  * [@0]: dpo-load-balance: [index:24 buckets:1 uRPF:23 to:[0:0]]
2943  * [0] [@2]: dpo-receive
2944  * ff02::2/128
2945  * unicast-ip6-chain
2946  * [@0]: dpo-load-balance: [index:23 buckets:1 uRPF:22 to:[0:0]]
2947  * [0] [@2]: dpo-receive
2948  * ff02::16/128
2949  * unicast-ip6-chain
2950  * [@0]: dpo-load-balance: [index:25 buckets:1 uRPF:24 to:[0:0]]
2951  * [0] [@2]: dpo-receive
2952  * ff02::1:ff00:0/104
2953  * unicast-ip6-chain
2954  * [@0]: dpo-load-balance: [index:22 buckets:1 uRPF:21 to:[0:0]]
2955  * [0] [@2]: dpo-receive
2956  * @cliexend
2957  * @endparblock
2958 ?*/
2959 /* *INDENT-OFF* */
2961  .path = "set ip6 flow-hash",
2962  .short_help = "set ip6 flow-hash table <table-id> [src] [dst] [sport] "
2963  "[dport] [proto] [reverse] [flowlabel]",
2964  .function = set_ip6_flow_hash_command_fn,
2965 };
2966 /* *INDENT-ON* */
2967 
2968 static clib_error_t *
2970  unformat_input_t * input, vlib_cli_command_t * cmd)
2971 {
2972  ip6_main_t *im = &ip6_main;
2973  ip_lookup_main_t *lm = &im->lookup_main;
2974  int i;
2975 
2976  vlib_cli_output (vm, "Protocols handled by ip6_local");
2977  for (i = 0; i < ARRAY_LEN (lm->local_next_by_ip_protocol); i++)
2978  {
2980  {
2981 
2983  ip6_local_node.index)->
2984  next_nodes[lm->local_next_by_ip_protocol[i]];
2986  node_index);
2987  }
2988  }
2989  return 0;
2990 }
2991 
2992 
2993 
2994 /*?
2995  * Display the set of protocols handled by the local IPv6 stack.
2996  *
2997  * @cliexpar
2998  * Example of how to display local protocol table:
2999  * @cliexstart{show ip6 local}
3000  * Protocols handled by ip6_local
3001  * 17
3002  * 43
3003  * 58
3004  * 115
3005  * @cliexend
3006 ?*/
3007 /* *INDENT-OFF* */
3009 {
3010  .path = "show ip6 local",
3011  .function = show_ip6_local_command_fn,
3012  .short_help = "show ip6 local",
3013 };
3014 /* *INDENT-ON* */
3015 
3016 #ifndef CLIB_MARCH_VARIANT
3017 int
3019 {
3020  vnet_main_t *vnm = vnet_get_main ();
3022  ip6_main_t *ipm = &ip6_main;
3023  ip_lookup_main_t *lm = &ipm->lookup_main;
3025  ip6_address_t *if_addr;
3026 
3028  return VNET_API_ERROR_NO_MATCHING_INTERFACE;
3029 
3030  if (table_index != ~0 && pool_is_free_index (cm->tables, table_index))
3031  return VNET_API_ERROR_NO_SUCH_ENTRY;
3032 
3035 
3036  if_addr = ip6_interface_first_address (ipm, sw_if_index);
3037 
3038  if (NULL != if_addr)
3039  {
3040  fib_prefix_t pfx = {
3041  .fp_len = 128,
3042  .fp_proto = FIB_PROTOCOL_IP6,
3043  .fp_addr.ip6 = *if_addr,
3044  };
3045  u32 fib_index;
3046 
3048  sw_if_index);
3049  if (table_index != (u32) ~ 0)
3050  {
3051  dpo_id_t dpo = DPO_INVALID;
3052  dpo_set (&dpo,
3053  DPO_CLASSIFY,
3054  DPO_PROTO_IP6,
3055  classify_dpo_create (DPO_PROTO_IP6, table_index));
3057  &pfx,
3059  FIB_ENTRY_FLAG_NONE, &dpo);
3060  dpo_reset (&dpo);
3061  }
3062  else
3063  {
3064  fib_table_entry_special_remove (fib_index,
3065  &pfx, FIB_SOURCE_CLASSIFY);
3066  }
3067  }
3068 
3069  return 0;
3070 }
3071 #endif
3072 
3073 static clib_error_t *
3075  unformat_input_t * input,
3076  vlib_cli_command_t * cmd)
3077 {
3078  u32 table_index = ~0;
3079  int table_index_set = 0;
3080  u32 sw_if_index = ~0;
3081  int rv;
3082 
3083  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3084  {
3085  if (unformat (input, "table-index %d", &table_index))
3086  table_index_set = 1;
3087  else if (unformat (input, "intfc %U", unformat_vnet_sw_interface,
3088  vnet_get_main (), &sw_if_index))
3089  ;
3090  else
3091  break;
3092  }
3093 
3094  if (table_index_set == 0)
3095  return clib_error_return (0, "classify table-index must be specified");
3096 
3097  if (sw_if_index == ~0)
3098  return clib_error_return (0, "interface / subif must be specified");
3099 
3100  rv = vnet_set_ip6_classify_intfc (vm, sw_if_index, table_index);
3101 
3102  switch (rv)
3103  {
3104  case 0:
3105  break;
3106 
3107  case VNET_API_ERROR_NO_MATCHING_INTERFACE:
3108  return clib_error_return (0, "No such interface");
3109 
3110  case VNET_API_ERROR_NO_SUCH_ENTRY:
3111  return clib_error_return (0, "No such classifier table");
3112  }
3113  return 0;
3114 }
3115 
3116 /*?
3117  * Assign a classification table to an interface. The classification
3118  * table is created using the '<em>classify table</em>' and '<em>classify session</em>'
3119  * commands. Once the table is create, use this command to filter packets
3120  * on an interface.
3121  *
3122  * @cliexpar
3123  * Example of how to assign a classification table to an interface:
3124  * @cliexcmd{set ip6 classify intfc GigabitEthernet2/0/0 table-index 1}
3125 ?*/
3126 /* *INDENT-OFF* */
3128 {
3129  .path = "set ip6 classify",
3130  .short_help =
3131  "set ip6 classify intfc <interface> table-index <classify-idx>",
3132  .function = set_ip6_classify_command_fn,
3133 };
3134 /* *INDENT-ON* */
3135 
3136 /*
3137  * fd.io coding-style-patch-verification: ON
3138  *
3139  * Local Variables:
3140  * eval: (c-set-style "gnu")
3141  * End:
3142  */
ip_interface_address_t::sw_if_index
u32 sw_if_index
Definition: lookup.h:95
IP_INTERFACE_ADDRESS_FLAG_STALE
@ IP_INTERFACE_ADDRESS_FLAG_STALE
Definition: lookup.h:67
ip6_hop_by_hop_option_t::length
u8 length
Definition: ip6_hop_by_hop_packet.h:40
ip6_del_interface_routes
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
HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP_NOT_MCAST
#define HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP_NOT_MCAST
Definition: ip6_hop_by_hop_packet.h:35
ip6_address_is_link_local_unicast
static uword ip6_address_is_link_local_unicast(const ip6_address_t *a)
Definition: ip6_packet.h:253
ip6_main
ip6_main_t ip6_main
Definition: ip6_forward.c:2787
ip6_address_is_equal
static uword ip6_address_is_equal(const ip6_address_t *a, const ip6_address_t *b)
Definition: ip6_packet.h:167
adj_are_counters_enabled
static int adj_are_counters_enabled(void)
Get the global configuration option for enabling per-adj counters.
Definition: adj.h:485
ip6_hop_by_hop_option_t::type
u8 type
Definition: ip6_hop_by_hop_packet.h:38
dpo_id_t_::dpoi_next_node
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:186
im
vnet_interface_main_t * im
Definition: interface_output.c:395
ip_lookup_main_t::if_prefix_pool
ip_interface_prefix_t * if_prefix_pool
Pool of prefixes containing addresses assigned to interfaces.
Definition: lookup.h:134
ip_lookup_main_t::prefix_to_if_prefix_index
mhash_t prefix_to_if_prefix_index
Hash table mapping prefix to index in interface prefix pool.
Definition: lookup.h:137
udp_header_t::length
u16 length
Definition: udp_packet.h:51
ip6_lookup
static u32 ip6_lookup(gid_ip6_table_t *db, u32 vni, ip_prefix_t *key)
Definition: gid_dictionary.c:260
trace
static vlib_cli_command_t trace
(constructor) VLIB_CLI_COMMAND (trace)
Definition: vlib_api_cli.c:899
load_balance_t_::lb_n_buckets
u16 lb_n_buckets
number of buckets in the load-balance.
Definition: load_balance.h:116
ip_interface_prefix_t::key
ip_interface_prefix_key_t key
Definition: lookup.h:80
ip6_hop_by_hop_main
ip6_hop_by_hop_main_t ip6_hop_by_hop_main
Definition: ip6_forward.c:2252
while
while(n_left_from > 0)
Definition: nat44_ei_hairpinning.c:419
ip_interface_address_get_address
static void * ip_interface_address_get_address(ip_lookup_main_t *lm, ip_interface_address_t *a)
Definition: ip_interface.h:43
ip6_local_end_of_arc_node
vlib_node_registration_t ip6_local_end_of_arc_node
(constructor) VLIB_REGISTER_NODE (ip6_local_end_of_arc_node)
Definition: ip6_forward.c:1660
dpo_id_t_::dpoi_index
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:190
DPO_INVALID
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:204
bihash_template.c
thread_index
u32 thread_index
Definition: nat44_ei_hairpinning.c:492
fib_table_entry_special_dpo_add
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 'special' entry to the FIB that links to the DPO passed A special entry is an entry that the FI...
Definition: fib_table.c:324
bufs
vlib_buffer_t * bufs[VLIB_FRAME_SIZE]
Definition: nat44_ei_out2in.c:717
foreach_ip_interface_address
#define foreach_ip_interface_address(lm, a, sw_if_index, loop, body)
Definition: ip_interface.h:57
vnet_sw_interface_t
Definition: interface.h:868
ip6_mcast_midchain_node
vlib_node_registration_t ip6_mcast_midchain_node
(constructor) VLIB_REGISTER_NODE (ip6_mcast_midchain_node)
Definition: ip6_forward.c:2238
vlib_prefetch_buffer_header
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:231
frame
vlib_main_t vlib_node_runtime_t vlib_frame_t * frame
Definition: nat44_ei.c:3048
vnet_set_ip6_classify_intfc
int vnet_set_ip6_classify_intfc(vlib_main_t *vm, u32 sw_if_index, u32 table_index)
Definition: ip6_forward.c:3018
icmp6_error_set_vnet_buffer
void icmp6_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
Definition: icmp6.c:446
gso_mtu_sz
#define gso_mtu_sz(b)
Definition: buffer.h:509
ip6_tcp_udp_icmp_bad_length
static_always_inline u8 ip6_tcp_udp_icmp_bad_length(vlib_main_t *vm, vlib_buffer_t *p0)
Definition: ip6_forward.c:1238
vlib_node_add_next
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1177
ip_lookup_main_t::ucast_feature_arc_index
u8 ucast_feature_arc_index
Definition: lookup.h:144
clib_memcpy
#define clib_memcpy(d, s, n)
Definition: string.h:197
fib_table_entry_delete
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:895
next_index
nat44_ei_hairpin_src_next_t next_index
Definition: nat44_ei_hairpinning.c:412
IP6_HOP_BY_HOP_N_ERROR
@ IP6_HOP_BY_HOP_N_ERROR
Definition: ip6_forward.c:2266
fib_table_entry_update_one_path
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:814
load_balance_map.h
vlib_get_buffer
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:111
format_ip6_header
format_function_t format_ip6_header
Definition: format.h:95
srp.h
IP6_LOOKUP_NEXT_NODES
#define IP6_LOOKUP_NEXT_NODES
Definition: adj.h:122
pow2_mask
static uword pow2_mask(uword x)
Definition: clib.h:252
ip6_sw_interface_add_del
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
pool_elt_at_index
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:553
fib_urpf_check_size
static int fib_urpf_check_size(index_t ui)
Data-Plane function to check the size of an uRPF list, (i.e.
Definition: fib_urpf_list.h:137
ip_interface_prefix_t::ref_count
u16 ref_count
Definition: lookup.h:83
format_ip_adjacency
format_function_t format_ip_adjacency
Definition: format.h:58
ip6_hop_by_hop_init
static clib_error_t * ip6_hop_by_hop_init(vlib_main_t *vm)
Definition: ip6_forward.c:2710
IP6_LOOKUP_NEXT_POP_HOP_BY_HOP
@ IP6_LOOKUP_NEXT_POP_HOP_BY_HOP
Definition: adj.h:104
ip6_sw_interface_enable_disable
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip6_forward.c:239
ip6_header_t::protocol
u8 protocol
Definition: ip6_packet.h:304
vlib_get_buffers
vlib_get_buffers(vm, from, b, n_left_from)
next
u16 * next
Definition: nat44_ei_out2in.c:718
show_ip6_local
static vlib_cli_command_t show_ip6_local
(constructor) VLIB_CLI_COMMAND (show_ip6_local)
Definition: ip6_forward.c:3008
VLIB_NODE_TYPE_INTERNAL
@ VLIB_NODE_TYPE_INTERNAL
Definition: node.h:72
IP_LOCAL_N_NEXT
@ IP_LOCAL_N_NEXT
Definition: lookup.h:116
IP6_REWRITE_NEXT_ICMP_ERROR
@ IP6_REWRITE_NEXT_ICMP_ERROR
Definition: ip6_forward.c:1704
ip_interface_address_t::address_length
u16 address_length
Definition: lookup.h:98
VLIB_FRAME_SIZE
#define VLIB_FRAME_SIZE
Definition: node.h:368
ip6_forward_next_trace
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:1006
node
vlib_main_t vlib_node_runtime_t * node
Definition: nat44_ei.c:3047
ip6_header_t::hop_limit
u8 hop_limit
Definition: ip6_packet.h:307
VNET_FEATURE_INIT
VNET_FEATURE_INIT(ip6_flow_classify, static)
load_balance_t_::lb_hash_config
flow_hash_config_t lb_hash_config
the hash config to use when selecting a bucket.
Definition: load_balance.h:161
unformat_pg_ip6_header
unformat_function_t unformat_pg_ip6_header
Definition: format.h:97
vnet_classify_main
vnet_classify_main_t vnet_classify_main
Definition: vnet_classify.c:32
ip6_add_interface_prefix_routes
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
vnet_buffer_oflags_t
vnet_buffer_oflags_t
Definition: buffer.h:118
FIB_ENTRY_FLAG_ATTACHED
@ FIB_ENTRY_FLAG_ATTACHED
Definition: fib_entry.h:114
mfib_table_find_or_create_and_lock
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
clib_error_return
#define clib_error_return(e, args...)
Definition: error.h:99
HBH_OPTION_TYPE_SKIP_UNKNOWN
#define HBH_OPTION_TYPE_SKIP_UNKNOWN
Definition: ip6_hop_by_hop_packet.h:32
u8
#define u8
Padding.
Definition: clib.h:121
vlib_cli_command_t::path
char * path
Definition: cli.h:96
FORMAT_IP_ADJACENCY_NONE
@ FORMAT_IP_ADJACENCY_NONE
Definition: format.h:53
IP_BUILTIN_PROTOCOL_UNKNOWN
@ IP_BUILTIN_PROTOCOL_UNKNOWN
Definition: ip_packet.h:67
vnet_interface_main_t
Definition: interface.h:989
ip6_forward_next_trace_t
Definition: ip6_forward.c:937
HBH_OPTION_TYPE_DISCARD_UNKNOWN
#define HBH_OPTION_TYPE_DISCARD_UNKNOWN
Definition: ip6_hop_by_hop_packet.h:33
ip6_add_interface_routes
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
OI_DECAP
#define OI_DECAP
Definition: ip6_forward.c:61
u16
unsigned short u16
Definition: types.h:57
load_balance_main_t_::lbm_via_counters
vlib_combined_counter_main_t lbm_via_counters
Definition: load_balance.h:47
fib_prefix_t_::fp_len
u16 fp_len
The mask length.
Definition: fib_types.h:206
VNET_REWRITE_HAS_FEATURES
@ VNET_REWRITE_HAS_FEATURES
This adjacency/interface has output features configured.
Definition: rewrite.h:57
vlib_call_init_function
#define vlib_call_init_function(vm, x)
Definition: init.h:259
VNET_SW_INTERFACE_FLAG_ADMIN_UP
@ VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:843
pool_put
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:305
ip_lookup_main_t::classify_table_index_by_sw_if_index
u32 * classify_table_index_by_sw_if_index
First table index to use for this interface, ~0 => none.
Definition: lookup.h:140
vm
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
VLIB_RX
@ VLIB_RX
Definition: defs.h:46
node_index
node node_index
Definition: interface_output.c:420
IP6_LOOKUP_NEXT_HOP_BY_HOP
@ IP6_LOOKUP_NEXT_HOP_BY_HOP
Definition: adj.h:102
ip_interface_prefix_t
Definition: lookup.h:77
ip6_mtu_check
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:1716
ip6_hop_by_hop_option_t
Definition: ip6_hop_by_hop_packet.h:29
vlib_buffer_enqueue_to_next
vlib_buffer_enqueue_to_next(vm, node, from,(u16 *) nexts, frame->n_vectors)
hi
vl_api_ip4_address_t hi
Definition: arp.api:37
set_ip6_flow_hash_command
static vlib_cli_command_t set_ip6_flow_hash_command
(constructor) VLIB_CLI_COMMAND (set_ip6_flow_hash_command)
Definition: ip6_forward.c:2960
unformat_input_t
struct _unformat_input_t unformat_input_t
vnet_calc_checksums_inline
static_always_inline void vnet_calc_checksums_inline(vlib_main_t *vm, vlib_buffer_t *b, int is_ip4, int is_ip6)
Definition: interface_output.h:83
classify_dpo_create
index_t classify_dpo_create(dpo_proto_t proto, u32 classify_table_index)
Definition: classify_dpo.c:48
vlib_frame_t
Definition: node.h:372
ip_interface_address_add
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
ip_calculate_l4_checksum
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
ip6_hop_by_hop_header_t
Definition: ip6_hop_by_hop_packet.h:18
vlib_buffer_length_in_chain
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:433
clib_memcpy_fast
static_always_inline void * clib_memcpy_fast(void *restrict dst, const void *restrict src, size_t n)
Definition: string.h:92
udp_header_t
Definition: udp_packet.h:45
ethernet.h
error
Definition: cJSON.c:88
ip6_local_inline
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:1282
ip6_sw_interface_admin_up_down
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
key
typedef key
Definition: ipsec_types.api:88
i32
signed int i32
Definition: types.h:77
pg_node_t
Definition: pg.h:324
vnet_feature_arc_start_w_cfg_index
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
ip_frag_set_vnet_buffer
void ip_frag_set_vnet_buffer(vlib_buffer_t *b, u16 mtu, u8 next_index, u8 flags)
Definition: ip_frag.c:238
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(ip6_sw_interface_admin_up_down)
ip6_mfib.h
unformat
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
pool_is_free_index
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:302
IP6_REWRITE_N_NEXT
@ IP6_REWRITE_N_NEXT
Definition: ip6_forward.c:1706
vec_elt
#define vec_elt(v, i)
Get vector value at index i.
Definition: vec_bootstrap.h:210
ip6_midchain_node
vlib_node_registration_t ip6_midchain_node
(constructor) VLIB_REGISTER_NODE (ip6_midchain_node)
Definition: ip6_forward.c:2199
ip6_hbh_set_next_override
void ip6_hbh_set_next_override(uword next)
Definition: ip6_forward.c:2723
CLIB_PREFETCH
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
vnet_sw_interface_t::sw_if_index
u32 sw_if_index
Definition: interface.h:875
i16
signed short i16
Definition: types.h:46
vlib_buffer_t::current_data
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:119
fib_table_entry_special_remove
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a 'special' entry from the FIB.
Definition: fib_table.c:424
vlib_node_runtime_t::errors
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:460
pool_foreach
#define pool_foreach(VAR, POOL)
Iterate through pool.
Definition: pool.h:534
format_ip_adjacency_packet_data
format_function_t format_ip_adjacency_packet_data
Definition: format.h:59
load_balance_main
load_balance_main_t load_balance_main
The one instance of load-balance main.
Definition: load_balance.c:59
set_ip6_classify_command_fn
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:3074
load_balance_get_fwd_bucket
static const dpo_id_t * load_balance_get_fwd_bucket(const load_balance_t *lb, u16 bucket)
Definition: load_balance_map.h:94
IP_LOCAL_NEXT_ICMP
@ IP_LOCAL_NEXT_ICMP
Definition: lookup.h:114
clib_error_create
#define clib_error_create(args...)
Definition: error.h:96
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
ip6_address_is_multicast
static uword ip6_address_is_multicast(const ip6_address_t *a)
Definition: ip6_packet.h:121
vlib_buffer_t::error
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:145
IP_LOOKUP_NEXT_DROP
@ IP_LOOKUP_NEXT_DROP
Adjacency to drop this packet.
Definition: adj.h:53
ip6_rewrite_inline
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:2139
VLIB_NODE_FN
#define VLIB_NODE_FN(node)
Definition: node.h:202
ip6_mfib_interface_enable_disable
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:234
vec_add1
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:606
ip_lookup_init
void ip_lookup_init(ip_lookup_main_t *lm, u32 is_ip6)
Definition: lookup.c:75
FIB_SOURCE_INTERFACE
@ FIB_SOURCE_INTERFACE
Route added as a result of interface configuration.
Definition: fib_source.h:59
ip_adjacency_t_::lookup_next_index
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
Definition: adj.h:337
ip6_compute_flow_hash
static u32 ip6_compute_flow_hash(const ip6_header_t *ip, flow_hash_config_t flow_hash_config)
Definition: ip6_inlines.h:49
pg_node_t::unformat_edit
unformat_function_t * unformat_edit
Definition: pg.h:327
CLIB_UNUSED
#define CLIB_UNUSED(x)
Definition: clib.h:90
ip6_rewrite_node
vlib_node_registration_t ip6_rewrite_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_node)
Definition: ip6_forward.c:2207
vnet_buffer
#define vnet_buffer(b)
Definition: buffer.h:437
vnet_get_main
vnet_main_t * vnet_get_main(void)
Definition: pnat_test_stubs.h:56
ip_lookup_main_t::mcast_feature_arc_index
u8 mcast_feature_arc_index
Feature arc indices.
Definition: lookup.h:143
VLIB_NODE_FLAG_TRACE
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:291
ip6_add_del_interface_address_callback_t
Definition: ip6.h:94
IP_LOCAL_NEXT_REASSEMBLY
@ IP_LOCAL_NEXT_REASSEMBLY
Definition: lookup.h:115
fib_table_find_or_create_and_lock
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:1165
PREDICT_FALSE
#define PREDICT_FALSE(x)
Definition: clib.h:124
ARRAY_LEN
#define ARRAY_LEN(x)
Definition: clib.h:70
foreach_flow_hash_bit
@ foreach_flow_hash_bit
Definition: ip_flow_hash.h:49
vlib_frame_vector_args
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:301
unformat_check_input
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:163
ip6_hbh_unregister_option
int ip6_hbh_unregister_option(u8 option)
Definition: ip6_forward.c:2755
interface_output.h
FIB_ENTRY_FLAG_NONE
@ FIB_ENTRY_FLAG_NONE
Definition: fib_entry.h:112
index_t
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:43
ip_flow_hash_set
int ip_flow_hash_set(ip_address_family_t af, u32 table_id, u32 flow_hash_config)
Definition: ip.c:192
static_always_inline
#define static_always_inline
Definition: clib.h:112
ip6_hop_by_hop_node
vlib_node_registration_t ip6_hop_by_hop_node
(constructor) VLIB_REGISTER_NODE (ip6_hop_by_hop_node)
Definition: ip6_forward.c:2696
ip6_hop_by_hop_trace_t::trace_len
u32 trace_len
Definition: ip6_forward.c:2277
vlib_prefetch_buffer_with_index
#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:507
HBH_OPTION_TYPE_HIGH_ORDER_BITS
#define HBH_OPTION_TYPE_HIGH_ORDER_BITS
Definition: ip6_hop_by_hop_packet.h:36
uword
u64 uword
Definition: types.h:112
pg_get_node
static pg_node_t * pg_get_node(uword node_index)
Definition: pg.h:381
if
if(node->flags &VLIB_NODE_FLAG_TRACE) vnet_interface_output_trace(vm
MFIB_SOURCE_DEFAULT_ROUTE
@ MFIB_SOURCE_DEFAULT_ROUTE
Definition: mfib_types.h:177
ethernet_header_t
Definition: packet.h:52
vlib_rx_or_tx_t
vlib_rx_or_tx_t
Definition: defs.h:44
arc_index
u8 arc_index
Definition: nat44_ei_hairpinning.c:590
clib_mem_unaligned
#define clib_mem_unaligned(pointer, type)
Definition: types.h:155
vlib_main_t::thread_index
u32 thread_index
Definition: main.h:213
ip6_tcp_udp_icmp_compute_checksum
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:1098
vlib_get_node
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:86
load_balance_get_bucket_i
static const dpo_id_t * load_balance_get_bucket_i(const load_balance_t *lb, u32 bucket)
Definition: load_balance.h:229
ip_get_interface_prefix
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
i
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
ip6_header_t::dst_address
ip6_address_t dst_address
Definition: ip6_packet.h:310
IP_BUILTIN_PROTOCOL_UDP
@ IP_BUILTIN_PROTOCOL_UDP
Definition: ip_packet.h:65
cm
vnet_feature_config_main_t * cm
Definition: nat44_ei_hairpinning.c:591
format_unformat_error
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
pool_get
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:255
FIB_SOURCE_CLASSIFY
@ FIB_SOURCE_CLASSIFY
Classify.
Definition: fib_source.h:49
IP_FRAG_NEXT_IP_REWRITE
@ IP_FRAG_NEXT_IP_REWRITE
Definition: ip_frag.h:51
ip6_locate_header
static int ip6_locate_header(vlib_buffer_t *p0, ip6_header_t *ip0, int find_hdr_type, u32 *offset)
Definition: ip6_inlines.h:137
vec_validate
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment)
Definition: vec.h:523
address
manual_print typedef address
Definition: ip_types.api:96
VLIB_CLI_COMMAND
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:163
vnet_feature_init
static clib_error_t * vnet_feature_init(vlib_main_t *vm)
Definition: feature.c:50
IP6_MCAST_ADDR_MASK
#define IP6_MCAST_ADDR_MASK
This bits of an IPv6 address to mask to construct a multicast MAC address.
Definition: ip6_forward.c:1713
ip_adjacency_t_
IP unicast adjacency.
Definition: adj.h:235
FIB_PROTOCOL_IP4
@ FIB_PROTOCOL_IP4
Definition: fib_types.h:36
ip_interface_prefix_key_t
Definition: lookup.h:70
STATIC_ASSERT
#define STATIC_ASSERT(truth,...)
Definition: error_bootstrap.h:111
ip6_lookup_init
static clib_error_t * ip6_lookup_init(vlib_main_t *vm)
Definition: ip6_forward.c:2791
CLIB_CACHE_LINE_BYTES
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
FIB_ENTRY_FLAG_LOCAL
@ FIB_ENTRY_FLAG_LOCAL
Definition: fib_entry.h:117
vlib_node_registration_t
struct _vlib_node_registration vlib_node_registration_t
vlib_cli_output
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:716
ip6_rewrite_mcast_node
vlib_node_registration_t ip6_rewrite_mcast_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_mcast_node)
Definition: ip6_forward.c:2229
ip6_forward_next_trace_t::flow_hash
u32 flow_hash
Definition: ip6_forward.c:941
vnet_interface_main_t::sw_interfaces
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:1014
function
u8 function
Definition: pci_types.api:23
ip6_fib_table_fwding_lookup
static u32 ip6_fib_table_fwding_lookup(u32 fib_index, const ip6_address_t *dst)
Definition: ip6_fib.h:115
vlib_buffer_t::current_length
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:122
fib_prefix_t_::fp_addr
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:225
vnet_sw_interface_is_admin_up
static uword vnet_sw_interface_is_admin_up(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface_funcs.h:265
ip6_hop_by_hop_main_t::options
int(* options[256])(vlib_buffer_t *b, ip6_header_t *ip, ip6_hop_by_hop_option_t *opt)
Definition: ip6.h:307
ip6_hop_by_hop_error_strings
static char * ip6_hop_by_hop_error_strings[]
Definition: ip6_forward.c:2283
ip6_forward_next_trace_t::adj_index
u32 adj_index
Definition: ip6_forward.c:940
ip_frag.h
udp_header_t::checksum
u16 checksum
Definition: udp_packet.h:55
VNET_SW_INTERFACE_ADD_DEL_FUNCTION
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(ip6_sw_interface_add_del)
vnet_main_t::api_errno
vnet_api_error_t api_errno
Definition: vnet.h:109
set_ip6_classify_command
static vlib_cli_command_t set_ip6_classify_command
(constructor) VLIB_CLI_COMMAND (set_ip6_classify_command)
Definition: ip6_forward.c:3127
ip6_forward_next_trace_t::packet_data
u8 packet_data[128 - 1 *sizeof(u32)]
Definition: ip6_forward.c:945
IP_LOOKUP_NEXT_ICMP_ERROR
@ IP_LOOKUP_NEXT_ICMP_ERROR
This packets needs to go to ICMP error.
Definition: adj.h:79
data
u8 data[128]
Definition: ipsec_types.api:92
ip6_hop_by_hop_trace_t::next_index
u32 next_index
Definition: ip6_forward.c:2276
IP6_REWRITE_NEXT_DROP
@ IP6_REWRITE_NEXT_DROP
Definition: ip6_forward.c:1703
ip_lookup_next_t
ip_lookup_next_t
An adjacency is a representation of an attached L3 peer.
Definition: adj.h:50
ip6_rewrite_next_t
ip6_rewrite_next_t
Definition: ip6_forward.c:1701
vnet_hw_interface_t
Definition: interface.h:638
vnet_main_t
Definition: vnet.h:76
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
ip_adjacency_t_::sub_type
union ip_adjacency_t_::@144 sub_type
ip6_forward.h
IPv6 Forwarding.
ip6_urpf_loose_check
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:1197
vlib_validate_buffer_enqueue_x1
#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
ip6_input_node
vlib_node_registration_t ip6_input_node
(constructor) VLIB_REGISTER_NODE (ip6_input_node)
Definition: ip6_input.c:230
always_inline
#define always_inline
Definition: rdma_mlx5dv.h:23
format_ip6_hop_by_hop_ext_hdr
u8 * format_ip6_hop_by_hop_ext_hdr(u8 *s, va_list *args)
Definition: ip6_forward.c:2291
format_ip6_hop_by_hop_trace
static u8 * format_ip6_hop_by_hop_trace(u8 *s, va_list *args)
Definition: ip6_forward.c:2334
HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP
#define HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP
Definition: ip6_hop_by_hop_packet.h:34
format_vlib_node_name
format_function_t format_vlib_node_name
Definition: node_funcs.h:1235
format_ip6_forward_next_trace
u8 * format_ip6_forward_next_trace(u8 *s, va_list *args)
Definition: ip6_forward.c:951
FIB_ENTRY_FLAG_CONNECTED
@ FIB_ENTRY_FLAG_CONNECTED
Definition: fib_entry.h:113
set_ip6_flow_hash_command_fn
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:2838
ip6_add_del_interface_address
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
format_vnet_sw_if_index_name
format_function_t format_vnet_sw_if_index_name
Definition: interface_funcs.h:455
ip6_load_balance_node
vlib_node_registration_t ip6_load_balance_node
(constructor) VLIB_REGISTER_NODE (ip6_load_balance_node)
Definition: ip6_forward.c:928
ip6_hop_by_hop_main_t::trace
u8 *(* trace[256])(u8 *s, ip6_hop_by_hop_option_t *opt)
Definition: ip6.h:309
unformat_vnet_sw_interface
unformat_function_t unformat_vnet_sw_interface
Definition: interface_funcs.h:459
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
cache.h
adjacency_counters
vlib_combined_counter_main_t adjacency_counters
Adjacency packet counters.
Definition: adj.c:26
ip6_rewrite_bcast_node
vlib_node_registration_t ip6_rewrite_bcast_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_bcast_node)
Definition: ip6_forward.c:2221
vlib_combined_counter_main_t
A collection of combined counters.
Definition: counter.h:203
format_get_indent
static u32 format_get_indent(u8 *s)
Definition: format.h:72
FIB_SOURCE_DEFAULT_ROUTE
@ FIB_SOURCE_DEFAULT_ROUTE
The default route source.
Definition: fib_source.h:134
vec_validate_init_empty
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header,...
Definition: vec.h:570
vlib_put_next_frame
vlib_put_next_frame(vm, node, next_index, 0)
ip_csum_with_carry
static ip_csum_t ip_csum_with_carry(ip_csum_t sum, ip_csum_t x)
Definition: ip_packet.h:248
fib_table_get_index_for_sw_if_index
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:998
DPO_PROTO_IP6
@ DPO_PROTO_IP6
Definition: dpo.h:65
FIB_ROUTE_PATH_FLAG_NONE
@ FIB_ROUTE_PATH_FLAG_NONE
Definition: fib_types.h:332
ip.h
u32
unsigned int u32
Definition: types.h:88
VLIB_INIT_FUNCTION
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:172
vnet_get_sup_hw_interface
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface_funcs.h:92
fib_urpf_list.h
options
static struct option options[]
Definition: main.c:52
protocol
vl_api_ip_proto_t protocol
Definition: lb_types.api:72
ip6_hop_by_hop_trace_t::option_data
u8 option_data[256]
Definition: ip6_forward.c:2278
table_id
u32 table_id
Definition: wireguard.api:102
IP_BUILTIN_PROTOCOL_ICMP
@ IP_BUILTIN_PROTOCOL_ICMP
Definition: ip_packet.h:66
FIB_PROTOCOL_IP6
@ FIB_PROTOCOL_IP6
Definition: fib_types.h:37
ip6_hop_by_hop_header_t::length
u8 length
Definition: ip6_hop_by_hop_packet.h:26
ip_adjacency_t_::ia_cfg_index
u32 ia_cfg_index
feature [arc] config index
Definition: adj.h:247
vec_foreach
#define vec_foreach(var, vec)
Vector iterator.
Definition: vec_bootstrap.h:213
load_balance_get
static load_balance_t * load_balance_get(index_t lbi)
Definition: load_balance.h:220
n_left
u32 n_left
Definition: interface_output.c:1078
ip6_scan_hbh_options
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:2382
ip6_hop_by_hop_error_t
ip6_hop_by_hop_error_t
Definition: ip6_forward.c:2261
ip6_unregister_protocol
void ip6_unregister_protocol(u32 protocol)
Definition: ip6_forward.c:1691
vnet_classify_main_t
struct _vnet_classify_main vnet_classify_main_t
Definition: vnet_classify.h:61
AF_IP6
@ AF_IP6
Definition: ip_types.h:24
IP_LOCAL_NEXT_UDP_LOOKUP
@ IP_LOCAL_NEXT_UDP_LOOKUP
Definition: lookup.h:113
ip6_hop_by_hop_main_t::next_override
uword next_override
Definition: ip6.h:310
ip6_main_t::lookup_main
ip_lookup_main_t lookup_main
Definition: ip6.h:112
vlib_node_get_runtime
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:116
ip6_header_t
Definition: ip6_packet.h:294
IP6_LOOKUP_N_NEXT
@ IP6_LOOKUP_N_NEXT
Definition: adj.h:105
ip6_main_t
Definition: ip6.h:110
foreach_ip6_hop_by_hop_error
#define foreach_ip6_hop_by_hop_error
Definition: ip6_forward.c:2255
vnet_classify.h
ip6_addr_fib_init
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
ip6_hop_by_hop_main_t
Definition: ip6.h:304
vnet_feature_enable_disable
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: pnat_test_stubs.h:50
IP_LOCAL_NEXT_DROP
@ IP_LOCAL_NEXT_DROP
Definition: lookup.h:111
ip6_fib.h
ip_lookup_main_t
Definition: lookup.h:121
format_ip6_rewrite_trace
static u8 * format_ip6_rewrite_trace(u8 *s, va_list *args)
Definition: ip6_forward.c:986
vnet_rewrite_two_headers
#define vnet_rewrite_two_headers(rw0, rw1, p0, p1, most_likely_size)
Definition: rewrite.h:222
ip6_header_t::src_address
ip6_address_t src_address
Definition: ip6_packet.h:310
format_ip6_lookup_trace
static u8 * format_ip6_lookup_trace(u8 *s, va_list *args)
Definition: ip6_forward.c:969
clib_memset
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vlib_main_t
Definition: main.h:102
ip_interface_address_del
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
vlib_node_t
Definition: node.h:247
ip_lookup_main_t::local_next_by_ip_protocol
u8 local_next_by_ip_protocol[256]
Table mapping ip protocol to ip[46]-local node next index.
Definition: lookup.h:158
vlib_add_trace
void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace.c:628
ip6_next_proto_is_tcp_udp
static u8 ip6_next_proto_is_tcp_udp(vlib_buffer_t *p0, ip6_header_t *ip0, u32 *udp_offset0)
Definition: ip6_forward.c:1216
vlib_get_main
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:38
b
vlib_buffer_t ** b
Definition: nat44_ei_out2in.c:717
VNET_FEATURES
#define VNET_FEATURES(...)
Definition: feature.h:470
u8
unsigned char u8
Definition: types.h:56
clib_error_t
Definition: clib_error.h:21
a
a
Definition: bitmap.h:544
vlib_buffer_get_current
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:257
ip
vl_api_address_t ip
Definition: l2.api:558
ip_interface_address_find
u32 ip_interface_address_find(ip_lookup_main_t *lm, void *addr_fib, u32 address_length)
Definition: ip_interface.c:24
vlib_init_function_t
clib_error_t *() vlib_init_function_t(struct vlib_main_t *vm)
Definition: init.h:51
ip_csum_t
uword ip_csum_t
Definition: ip_packet.h:245
vnet_ip_mcast_fixup_header
static void vnet_ip_mcast_fixup_header(u32 dst_mcast_mask, u32 dst_mcast_offset, u32 *addr, u8 *packet0)
Definition: rewrite.h:228
ip6_forward_next_trace_t::fib_index
u32 fib_index
Definition: ip6_forward.c:942
dpo_is_adj
int dpo_is_adj(const dpo_id_t *dpo)
Return TRUE is the DPO is any type of adjacency.
Definition: dpo.c:282
vlib_buffer_t::data
u8 data[]
Packet data.
Definition: buffer.h:204
ip_lookup_main_t::builtin_protocol_by_ip_protocol
u8 builtin_protocol_by_ip_protocol[256]
IP_BUILTIN_PROTOCOL_{TCP,UDP,ICMP,OTHER} by protocol in IP header.
Definition: lookup.h:161
ip6_hop_by_hop_header_t::protocol
u8 protocol
Definition: ip6_hop_by_hop_packet.h:21
vnet_rewrite_one_header
#define vnet_rewrite_one_header(rw0, p0, most_likely_size)
Definition: rewrite.h:218
ip6_del_interface_prefix_routes
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
ip6_error_t
ip6_error_t
Definition: ip6_error.h:90
vnet_feature_arc_start
static_always_inline void vnet_feature_arc_start(u8 arc, u32 sw_if_index, u32 *next0, vlib_buffer_t *b0)
Definition: feature.h:302
vnet_sw_interface_update_unnumbered
void vnet_sw_interface_update_unnumbered(u32 unnumbered_sw_if_index, u32 ip_sw_if_index, u8 enable)
Definition: interface.c:1616
clib_warning
#define clib_warning(format, args...)
Definition: error.h:59
ip6_lookup_node
vlib_node_registration_t ip6_lookup_node
(constructor) VLIB_REGISTER_NODE (ip6_lookup_node)
Definition: ip6_forward.c:741
dpo_id_t_
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:172
nexts
u16 nexts[VLIB_FRAME_SIZE]
Definition: nat44_ei_out2in.c:718
ip6_hbh_register_option
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:2731
rv
int __clib_unused rv
Definition: application.c:491
DPO_CLASSIFY
@ DPO_CLASSIFY
Definition: dpo.h:115
format_ip4_address_and_length
format_function_t format_ip4_address_and_length
Definition: format.h:74
load_balance_t_::lb_n_buckets_minus_1
u16 lb_n_buckets_minus_1
number of buckets in the load-balance - 1.
Definition: load_balance.h:121
vlib_validate_buffer_enqueue_x2
#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_t
Definition: lookup.h:89
load_balance_t_
The FIB DPO provieds;.
Definition: load_balance.h:106
vlib_buffer_t::pre_data
u8 pre_data[VLIB_BUFFER_PRE_DATA_SIZE]
Space for inserting data before buffer start.
Definition: buffer.h:201
vnet.h
dpo_set
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:188
load_balance_t_::lb_urpf
index_t lb_urpf
This is the index of the uRPF list for this LB.
Definition: load_balance.h:156
ip6_header_t::payload_length
u16 payload_length
Definition: ip6_packet.h:301
ip6_hop_by_hop_trace_t
Definition: ip6_forward.c:2274
IP6_REWRITE_NEXT_FRAGMENT
@ IP6_REWRITE_NEXT_FRAGMENT
Definition: ip6_forward.c:1705
vlib_node_runtime_t
Definition: node.h:454
src_address
vl_api_address_union_t src_address
Definition: ip_types.api:122
vlib_cli_command_t
Definition: cli.h:92
from
from
Definition: nat44_ei_hairpinning.c:415
PREDICT_TRUE
#define PREDICT_TRUE(x)
Definition: clib.h:125
ip6_interface_first_address
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
VNET_FEATURE_ARC_INIT
VNET_FEATURE_ARC_INIT(ip6_unicast, static)
vlib_buffer_t::total_length_not_including_first_buffer
u32 total_length_not_including_first_buffer
Only valid for first buffer in chain.
Definition: buffer.h:176
ip6_tcp_udp_icmp_validate_checksum
u32 ip6_tcp_udp_icmp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
Definition: ip6_forward.c:1163
sw_if_index
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
vlib_get_next_frame
#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:395
ip6_lookup_inline
static uword ip6_lookup_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: ip6_forward.h:56
VLIB_TX
@ VLIB_TX
Definition: defs.h:47
ip_interface_address_t::flags
ip_interface_address_flags_t flags
Definition: lookup.h:101
ip6_local_node
vlib_node_registration_t ip6_local_node
(constructor) VLIB_REGISTER_NODE (ip6_local_node)
Definition: ip6_forward.c:1635
ip6_register_protocol
void ip6_register_protocol(u32 protocol, u32 node_index)
Definition: ip6_forward.c:1679
dpo_reset
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:234
show_ip6_local_command_fn
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:2969
adj_get
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:470
n_left_from
n_left_from
Definition: nat44_ei_hairpinning.c:416
ip6_rewrite_inline_with_gso
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:1743
mhash_unset
__clib_export uword mhash_unset(mhash_t *h, void *key, uword *old_value)
Definition: mhash.c:346
classify_dpo.h
IP_LOCAL_NEXT_PUNT
@ IP_LOCAL_NEXT_PUNT
Definition: lookup.h:112
fib_prefix_t_
Aggregate type for a prefix.
Definition: fib_types.h:202
type
vl_api_fib_path_type_t type
Definition: fib_types.api:123
ip_lookup_main_t::output_feature_arc_index
u8 output_feature_arc_index
Definition: lookup.h:145
vnet_main_t::interface_main
vnet_interface_main_t interface_main
Definition: vnet.h:81
vlib_increment_combined_counter
vlib_increment_combined_counter(ccm, ti, sw_if_index, n_buffers, n_bytes)
format_white_space
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
vlib_prefetch_buffer_data
#define vlib_prefetch_buffer_data(b, type)
Definition: buffer.h:232
IP_FRAG_NEXT_IP_REWRITE_MIDCHAIN
@ IP_FRAG_NEXT_IP_REWRITE_MIDCHAIN
Definition: ip_frag.h:52
UNFORMAT_END_OF_INPUT
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
mhash_set
static uword mhash_set(mhash_t *h, void *key, uword new_value, uword *old_value)
Definition: mhash.h:117
vlib_buffer_t::flags
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index,...
Definition: buffer.h:133
vlib_buffer_t
VLIB buffer representation.
Definition: buffer.h:111
VLIB_REGISTER_NODE
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
ip_adjacency_t_::midchain
struct ip_adjacency_t_::@144::@146 midchain
IP_LOOKUP_NEXT_MIDCHAIN.
classify_table_index
u32 classify_table_index
Definition: fib_types.api:68
flags
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:105