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