FD.io VPP  v20.05.1-6-gf53edbc3b
Vector Packet Processing
ip6.h
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.h: ip6 main include file
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 #ifndef included_ip_ip6_h
41 #define included_ip_ip6_h
42 
43 #include <vlib/buffer.h>
44 #include <vnet/ethernet/packet.h>
46 #include <vnet/ip/ip6_packet.h>
47 #include <vnet/ip/ip46_address.h>
49 #include <vnet/ip/lookup.h>
50 #include <vnet/ip/ip_interface.h>
51 #include <stdbool.h>
52 #include <vppinfra/bihash_24_8.h>
53 #include <vppinfra/bihash_40_8.h>
55 #include <vnet/util/radix.h>
56 #include <vnet/util/throttle.h>
57 
58 /*
59  * Default size of the ip6 fib hash table
60  */
61 #define IP6_FIB_DEFAULT_HASH_NUM_BUCKETS (64 * 1024)
62 #define IP6_FIB_DEFAULT_HASH_MEMORY_SIZE (32<<20)
63 
64 typedef struct
65 {
66  ip6_address_t addr;
70 
71 typedef struct
72 {
73  /* required for pool_get_aligned. */
74  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
75 
76  /* Table ID (hash key) for this FIB. */
78 
79  /* Index into FIB vector. */
81 } ip6_fib_t;
82 
83 typedef struct ip6_mfib_t
84 {
85  /* required for pool_get_aligned. */
86  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
87 
88  /* Table ID (hash key) for this FIB. */
90 
91  /* Index into FIB vector. */
93 } ip6_mfib_t;
94 
95 struct ip6_main_t;
96 
98  (struct ip6_main_t * im,
99  uword opaque,
101  ip6_address_t * address,
102  u32 address_length, u32 if_address_index, u32 is_del);
103 
104 typedef struct
105 {
109 
110 typedef void (ip6_table_bind_function_t)
111  (struct ip6_main_t * im,
112  uword opaque, u32 sw_if_index, u32 new_fib_index, u32 old_fib_index);
113 
114 typedef struct
115 {
119 
120 /**
121  * Enumeration of the FIB table instance types
122  */
124 {
125  /**
126  * This table stores the routes that are used to forward traffic.
127  * The key is the prefix, the result the adjacency to forward on.
128  */
130  /**
131  * The table that stores ALL routes learned by the DP.
132  * Some of these routes may not be ready to install in forwarding
133  * at a given time.
134  * The key in this table is the prefix, the result is the fib_entry_t
135  */
138 
139 #define IP6_FIB_NUM_TABLES (IP6_FIB_TABLE_NON_FWDING+1)
140 
141 /**
142  * A representation of a single IP6 table
143  */
145 {
146  /* The hash table */
147  clib_bihash_24_8_t ip6_hash;
148 
149  /* bitmap / refcounts / vector of mask widths to search */
152  i32 dst_address_length_refcounts[129];
154 
155 /**
156  * A representation of a single IP6 mfib table
157  */
159 {
160  /* The hash table */
161  clib_bihash_40_8_t ip6_mhash;
162 
163  /* bitmap / refcounts / vector of mask widths to search */
166  i32 dst_address_length_refcounts[257];
168 
169 typedef struct ip6_main_t
170 {
171  /**
172  * The two FIB tables; fwding and non-fwding
173  */
175 
176  /**
177  * the single MFIB table
178  */
180 
182 
183  /* Pool of FIBs. */
185 
186  /* Pool of V6 FIBs. */
188 
189  /** Vector of MFIBs. */
191 
192  /* Network byte orders subnet mask for each prefix length */
193  ip6_address_t fib_masks[129];
194 
195  /* Table index indexed by software interface. */
197 
198  /** Table index indexed by software interface. */
200 
201  /* IP6 enabled count by software interface */
203 
204  /* Hash table mapping table id to fib index.
205  ID space is not necessarily dense; index space is dense. */
207 
208  /** Hash table mapping table id to multicast fib index.
209  ID space is not necessarily dense; index space is dense. */
211 
212  /* Hash table mapping interface rewrite adjacency index by sw if index. */
214 
215  /* Functions to call when interface address changes. */
218 
219  /** Functions to call when interface to table biding changes. */
221 
222  /* ip6 lookup table config parameters */
225 
226  /* Seed for Jenkins hash used to compute ip6 flow hash. */
228 
229  struct
230  {
231  /* TTL to use for host generated packets. */
233 
234  u8 pad[3];
235  } host_config;
236 
237  /* HBH processing enabled? */
239 
240  /** ND throttling */
242 } ip6_main_t;
243 
244 #define ND_THROTTLE_BITS 512
245 
246 /* Global ip6 main structure. */
247 extern ip6_main_t ip6_main;
248 
249 /* Global ip6 input node. Errors get attached to ip6 input node. */
258 
259 extern void ip6_forward_next_trace (vlib_main_t * vm,
262  vlib_rx_or_tx_t which_adj_index);
263 
266  const ip6_address_t * key,
267  const ip6_address_t * dest, uword dest_length)
268 {
269  int i;
270  for (i = 0; i < ARRAY_LEN (key->as_uword); i++)
271  {
272  if ((key->as_uword[i] ^ dest->as_uword[i]) & im->
273  fib_masks[dest_length].as_uword[i])
274  return 0;
275  }
276  return 1;
277 }
278 
281  ip6_address_t * key,
283 {
284  ip6_address_t *a = ip_interface_address_get_address (&im->lookup_main, ia);
285  return ip6_destination_matches_route (im, key, a, ia->address_length);
286 }
287 
288 /* As above but allows for unaligned destinations (e.g. works right from IP header of packet). */
291  ip6_address_t * key,
292  ip6_address_t * dest,
293  uword dest_length)
294 {
295  int i;
296  for (i = 0; i < ARRAY_LEN (key->as_uword); i++)
297  {
298  if ((clib_mem_unaligned (&key->as_uword[i], uword) ^ dest->as_uword[i])
299  & im->fib_masks[dest_length].as_uword[i])
300  return 0;
301  }
302  return 1;
303 }
304 
305 /* Find interface address which matches destination. */
306 always_inline ip6_address_t *
308  const ip6_address_t * dst,
309  u32 sw_if_index,
311  result_ia)
312 {
313  ip_lookup_main_t *lm = &im->lookup_main;
315  ip6_address_t *result = 0;
316 
317  /* *INDENT-OFF* */
318  foreach_ip_interface_address (lm, ia, sw_if_index,
319  1 /* honor unnumbered */,
320  ({
321  ip6_address_t * a = ip_interface_address_get_address (lm, ia);
322  if (ip6_destination_matches_route (im, dst, a, ia->address_length))
323  {
324  result = a;
325  break;
326  }
327  }));
328  /* *INDENT-ON* */
329  if (result_ia)
330  *result_ia = result ? ia : 0;
331  return result;
332 }
333 
335  u32 sw_if_index,
336  ip6_address_t * address,
337  u32 address_length, u32 is_del);
338 void ip6_sw_interface_enable_disable (u32 sw_if_index, u32 is_enable);
339 
340 /**
341  * @brief get first IPv6 interface address
342  */
343 ip6_address_t *ip6_interface_first_address (ip6_main_t * im, u32 sw_if_index);
344 
345 int ip6_address_compare (ip6_address_t * a1, ip6_address_t * a2);
346 
347 uword
349  u16 dst_port, u32 next_node_index);
350 
352  ip6_header_t * ip0,
353  int *bogus_lengthp);
354 
355 void ip6_register_protocol (u32 protocol, u32 node_index);
356 void ip6_unregister_protocol (u32 protocol);
357 void ip6_local_hop_by_hop_register_protocol (u32 protocol, u32 node_index);
358 
360 
362  flow_hash_config_t flow_hash_config);
363 
364 u8 *format_ip6_forward_next_trace (u8 * s, va_list * args);
365 
367 
368 void ip6_punt_policer_add_del (u8 is_add, u32 policer_index);
369 void ip6_punt_redirect_add (u32 rx_sw_if_index,
370  u32 tx_sw_if_index, ip46_address_t * nh);
371 void ip6_punt_redirect_add_paths (u32 rx_sw_if_index,
373 void ip6_punt_redirect_del (u32 rx_sw_if_index);
374 
375 int vnet_set_ip6_classify_intfc (vlib_main_t * vm, u32 sw_if_index,
376  u32 table_index);
378 
379 /* Compute flow hash. We'll use it to select which Sponge to use for this
380  flow. And other things. */
383  flow_hash_config_t flow_hash_config)
384 {
385  tcp_header_t *tcp;
386  u64 a, b, c;
387  u64 t1, t2;
388  uword is_tcp_udp = 0;
389  u8 protocol = ip->protocol;
390 
391  if (PREDICT_TRUE
392  ((ip->protocol == IP_PROTOCOL_TCP)
393  || (ip->protocol == IP_PROTOCOL_UDP)))
394  {
395  is_tcp_udp = 1;
396  tcp = (void *) (ip + 1);
397  }
398  else if (ip->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS)
399  {
401  if ((hbh->protocol == IP_PROTOCOL_TCP) ||
402  (hbh->protocol == IP_PROTOCOL_UDP))
403  {
404  is_tcp_udp = 1;
405  tcp = (tcp_header_t *) ((u8 *) hbh + ((hbh->length + 1) << 3));
406  }
407  protocol = hbh->protocol;
408  }
409 
410  t1 = (ip->src_address.as_u64[0] ^ ip->src_address.as_u64[1]);
411  t1 = (flow_hash_config & IP_FLOW_HASH_SRC_ADDR) ? t1 : 0;
412 
413  t2 = (ip->dst_address.as_u64[0] ^ ip->dst_address.as_u64[1]);
414  t2 = (flow_hash_config & IP_FLOW_HASH_DST_ADDR) ? t2 : 0;
415 
416  a = (flow_hash_config & IP_FLOW_HASH_REVERSE_SRC_DST) ? t2 : t1;
417  b = (flow_hash_config & IP_FLOW_HASH_REVERSE_SRC_DST) ? t1 : t2;
418 
419  t1 = is_tcp_udp ? tcp->src : 0;
420  t2 = is_tcp_udp ? tcp->dst : 0;
421 
422  t1 = (flow_hash_config & IP_FLOW_HASH_SRC_PORT) ? t1 : 0;
423  t2 = (flow_hash_config & IP_FLOW_HASH_DST_PORT) ? t2 : 0;
424 
425  if (flow_hash_config & IP_FLOW_HASH_SYMMETRIC)
426  {
427  if (b < a)
428  {
429  c = a;
430  a = b;
431  b = c;
432  }
433  if (t2 < t1)
434  {
435  t2 += t1;
436  t1 = t2 - t1;
437  t2 = t2 - t1;
438  }
439  }
440 
441  b ^= (flow_hash_config & IP_FLOW_HASH_PROTO) ? protocol : 0;
442  c = (flow_hash_config & IP_FLOW_HASH_REVERSE_SRC_DST) ?
443  ((t1 << 16) | t2) : ((t2 << 16) | t1);
444 
445  hash_mix64 (a, b, c);
446  return (u32) c;
447 }
448 
449 /* ip6_locate_header
450  *
451  * This function is to search for the header specified by the protocol number
452  * in find_hdr_type.
453  * This is used to locate a specific IPv6 extension header
454  * or to find transport layer header.
455  * 1. If the find_hdr_type < 0 then it finds and returns the protocol number and
456  * offset stored in *offset of the transport or ESP header in the chain if
457  * found.
458  * 2. If a header with find_hdr_type > 0 protocol number is found then the
459  * offset is stored in *offset and protocol number of the header is
460  * returned.
461  * 3. If find_hdr_type is not found or packet is malformed or
462  * it is a non-first fragment -1 is returned.
463  */
464 always_inline int
466  ip6_header_t * ip0, int find_hdr_type, u32 * offset)
467 {
468  u8 next_proto = ip0->protocol;
469  u8 *next_header;
470  u8 done = 0;
471  u32 cur_offset;
472  u8 *temp_nxthdr = 0;
473  u32 exthdr_len = 0;
474 
475  next_header = ip6_next_header (ip0);
476  cur_offset = sizeof (ip6_header_t);
477  while (1)
478  {
479  done = (next_proto == find_hdr_type);
480  if (PREDICT_FALSE
481  (next_header >=
482  (u8 *) vlib_buffer_get_current (p0) + p0->current_length))
483  {
484  //A malicious packet could set an extension header with a too big size
485  return (-1);
486  }
487  if (done)
488  break;
489  if ((!ip6_ext_hdr (next_proto)) || next_proto == IP_PROTOCOL_IP6_NONXT)
490  {
491  if (find_hdr_type < 0)
492  break;
493  return -1;
494  }
495  if (next_proto == IP_PROTOCOL_IPV6_FRAGMENTATION)
496  {
497  ip6_frag_hdr_t *frag_hdr = (ip6_frag_hdr_t *) next_header;
498  u16 frag_off = ip6_frag_hdr_offset (frag_hdr);
499  /* Non first fragment return -1 */
500  if (frag_off)
501  return (-1);
502  exthdr_len = sizeof (ip6_frag_hdr_t);
503  temp_nxthdr = next_header + exthdr_len;
504  }
505  else if (next_proto == IP_PROTOCOL_IPSEC_AH)
506  {
507  exthdr_len =
508  ip6_ext_authhdr_len (((ip6_ext_header_t *) next_header));
509  temp_nxthdr = next_header + exthdr_len;
510  }
511  else
512  {
513  exthdr_len =
514  ip6_ext_header_len (((ip6_ext_header_t *) next_header));
515  temp_nxthdr = next_header + exthdr_len;
516  }
517  next_proto = ((ip6_ext_header_t *) next_header)->next_hdr;
518  next_header = temp_nxthdr;
519  cur_offset += exthdr_len;
520  }
521 
522  *offset = cur_offset;
523  return (next_proto);
524 }
525 
526 u8 *format_ip6_hop_by_hop_ext_hdr (u8 * s, va_list * args);
527 /*
528  * Hop-by-Hop handling
529  */
530 typedef struct
531 {
532  /* Array of function pointers to HBH option handling routines */
533  int (*options[256]) (vlib_buffer_t * b, ip6_header_t * ip,
535  u8 *(*trace[256]) (u8 * s, ip6_hop_by_hop_option_t * opt);
538 
540 
541 int ip6_hbh_register_option (u8 option,
542  int options (vlib_buffer_t * b,
543  ip6_header_t * ip,
545  u8 * trace (u8 * s,
546  ip6_hop_by_hop_option_t * opt));
547 int ip6_hbh_unregister_option (u8 option);
548 void ip6_hbh_set_next_override (uword next);
549 
550 /**
551  * Push IPv6 header to buffer
552  *
553  * @param vm - vlib_main
554  * @param b - buffer to write the header to
555  * @param src - source IP
556  * @param dst - destination IP
557  * @param prot - payload proto
558  * @param flow_label - flow label
559  *
560  * @return - pointer to start of IP header
561  */
562 always_inline void *
564  ip6_address_t * src, ip6_address_t * dst,
565  int proto, u32 flow_label)
566 {
567  ip6_header_t *ip6h;
568  u16 payload_length;
569 
570  /* make some room */
571  ip6h = vlib_buffer_push_uninit (b, sizeof (ip6_header_t));
572  ASSERT (flow_label < 1 << 20);
574  clib_host_to_net_u32 ((0x6 << 28) | flow_label);
575 
576  /* calculate ip6 payload length */
577  payload_length = vlib_buffer_length_in_chain (vm, b);
578  payload_length -= sizeof (*ip6h);
579 
580  ip6h->payload_length = clib_host_to_net_u16 (payload_length);
581 
582  ip6h->hop_limit = 0xff;
583  ip6h->protocol = proto;
584  clib_memcpy_fast (ip6h->src_address.as_u8, src->as_u8,
585  sizeof (ip6h->src_address));
586  clib_memcpy_fast (ip6h->dst_address.as_u8, dst->as_u8,
587  sizeof (ip6h->src_address));
588  vnet_buffer (b)->l3_hdr_offset = (u8 *) ip6h - b->data;
589  b->flags |= VNET_BUFFER_F_IS_IP6 | VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
590 
591  return ip6h;
592 }
593 
594 /**
595  * Push IPv6 header to buffer
596  *
597  * @param vm - vlib_main
598  * @param b - buffer to write the header to
599  * @param src - source IP
600  * @param dst - destination IP
601  * @param prot - payload proto
602  *
603  * @return - pointer to start of IP header
604  */
605 always_inline void *
607  ip6_address_t * src, ip6_address_t * dst, int proto)
608 {
609  return vlib_buffer_push_ip6_custom (vm, b, src, dst, proto,
610  0 /* flow label */ );
611 
612 }
613 
616 {
617  u32 fib_index, sw_if_index;
618  sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
619  fib_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
620  return (fib_index == (u32) ~ 0) ?
621  vec_elt (ip6_main.fib_index_by_sw_if_index, sw_if_index) : fib_index;
622 }
623 #endif /* included_ip_ip6_h */
624 
625 /*
626  * fd.io coding-style-patch-verification: ON
627  *
628  * Local Variables:
629  * eval: (c-set-style "gnu")
630  * End:
631  */
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
int ip6_address_compare(ip6_address_t *a1, ip6_address_t *a2)
Definition: ip46_cli.c:60
static vlib_cli_command_t trace
(constructor) VLIB_CLI_COMMAND (trace)
Definition: vlib_api_cli.c:899
u8 pad[3]
log2 (size of the packing page block)
Definition: bihash_doc.h:61
vlib_node_registration_t ip6_midchain_node
(constructor) VLIB_REGISTER_NODE (ip6_midchain_node)
Definition: ip6_forward.c:2193
#define CLIB_CACHE_LINE_ALIGN_MARK(mark)
Definition: cache.h:60
ip6_fib_t * v6_fibs
Definition: ip6.h:187
a
Definition: bitmap.h:538
void ip6_register_protocol(u32 protocol, u32 node_index)
Definition: ip6_forward.c:1664
#define IP_FLOW_HASH_SRC_PORT
Definition: lookup.h:64
u32 * mfib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip6.h:199
A representation of a path as described by a route producer.
Definition: fib_types.h:490
uword lookup_table_size
Definition: ip6.h:224
void ip6_hbh_set_next_override(uword next)
Definition: ip6_forward.c:2720
int vnet_set_ip6_classify_intfc(vlib_main_t *vm, u32 sw_if_index, u32 table_index)
Definition: ip6_forward.c:3048
vl_api_fib_path_nh_t nh
Definition: fib_types.api:126
void ip6_unregister_protocol(u32 protocol)
Definition: ip6_forward.c:1676
The table that stores ALL routes learned by the DP.
Definition: ip6.h:136
#define PREDICT_TRUE(x)
Definition: clib.h:119
u32 flow_hash_seed
Definition: ip6.h:227
unsigned long u64
Definition: types.h:89
static void * ip_interface_address_get_address(ip_lookup_main_t *lm, ip_interface_address_t *a)
Definition: ip_interface.h:43
Definitions for all things IP (v4|v6) unicast and multicast lookup related.
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
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:2728
#define IP_FLOW_HASH_REVERSE_SRC_DST
Definition: lookup.h:66
u8 ttl
Definition: ip6.h:232
u8 * ip_enabled_by_sw_if_index
Definition: ip6.h:202
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:113
ip6_address_t * ip6_interface_first_address(ip6_main_t *im, u32 sw_if_index)
get first IPv6 interface address
Definition: ip6_forward.c:278
vlib_node_registration_t ip6_rewrite_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_node)
Definition: ip6_forward.c:2201
vl_api_address_t src
Definition: gre.api:54
#define IP_FLOW_HASH_DST_PORT
Definition: lookup.h:65
void() serialize_function_t(serialize_main_t *m, va_list *va)
Definition: serialize.h:168
struct ip6_mfib_t ip6_mfib_t
void ip6_local_hop_by_hop_register_protocol(u32 protocol, u32 node_index)
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:402
struct _tcp_header tcp_header_t
ip6_address_t src_address
Definition: ip6_packet.h:310
u8 * prefix_lengths_in_search_order
Definition: ip6.h:151
unsigned char u8
Definition: types.h:56
static u32 vlib_buffer_get_ip6_fib_index(vlib_buffer_t *b)
Definition: ip6.h:615
u32 vrf_index
Definition: ip6.h:68
vlib_node_registration_t ip6_rewrite_mcast_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_mcast_node)
Definition: ip6_forward.c:2223
vl_api_ip_proto_t protocol
Definition: lb_types.api:71
vlib_rx_or_tx_t
Definition: defs.h:44
vlib_node_registration_t ip6_discover_neighbor_node
(constructor) VLIB_REGISTER_NODE (ip6_discover_neighbor_node)
Definition: ip6_neighbor.c:278
u8 * format_ip6_hop_by_hop_ext_hdr(u8 *s, va_list *args)
Definition: ip6_forward.c:2285
clib_bihash_24_8_t ip6_hash
Definition: ip6.h:147
vl_api_interface_index_t sw_if_index
Definition: gre.api:53
#define IP_FLOW_HASH_DST_ADDR
Definition: lookup.h:62
ip6_hop_by_hop_main_t ip6_hop_by_hop_main
Definition: ip6_forward.c:2246
static uword ip6_destination_matches_route(const ip6_main_t *im, const ip6_address_t *key, const ip6_address_t *dest, uword dest_length)
Definition: ip6.h:265
uword ip6_udp_register_listener(vlib_main_t *vm, u16 dst_port, u32 next_node_index)
A representation of a single IP6 table.
Definition: ip6.h:144
unsigned int u32
Definition: types.h:88
void() ip6_add_del_interface_address_function_t(struct ip6_main_t *im, uword opaque, u32 sw_if_index, ip6_address_t *address, u32 address_length, u32 if_address_index, u32 is_del)
Definition: ip6.h:98
A representation of a single IP6 mfib table.
Definition: ip6.h:158
u32 lookup_table_nbuckets
Definition: ip6.h:223
int ip6_hbh_unregister_option(u8 option)
Definition: ip6_forward.c:2752
throttle_t nd_throttle
ND throttling.
Definition: ip6.h:241
void() ip6_table_bind_function_t(struct ip6_main_t *im, uword opaque, u32 sw_if_index, u32 new_fib_index, u32 old_fib_index)
Definition: ip6.h:111
uword * mfib_index_by_table_id
Hash table mapping table id to multicast fib index.
Definition: ip6.h:210
vl_api_ip_proto_t proto
Definition: acl_types.api:50
vlib_node_registration_t ip6_input_node
(constructor) VLIB_REGISTER_NODE (ip6_input_node)
Definition: ip6_input.c:230
unsigned short u16
Definition: types.h:57
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
vlib_node_registration_t ip6_glean_node
(constructor) VLIB_REGISTER_NODE (ip6_glean_node)
Definition: ip6_neighbor.c:263
static u32 ip6_compute_flow_hash(const ip6_header_t *ip, flow_hash_config_t flow_hash_config)
Definition: ip6.h:382
vlib_node_registration_t ip6_punt_node
(constructor) VLIB_REGISTER_NODE (ip6_punt_node)
ip6_table_bind_callback_t * table_bind_callbacks
Functions to call when interface to table biding changes.
Definition: ip6.h:220
#define PREDICT_FALSE(x)
Definition: clib.h:118
#define always_inline
Definition: ipsec.h:28
u32 index
Definition: ip6.h:80
vl_api_address_t dst
Definition: gre.api:55
A throttle Used in the data plane to decide if a given hash should be throttled, i.e.
Definition: throttle.h:28
ip6_add_del_interface_address_callback_t * add_del_interface_address_callbacks
Definition: ip6.h:217
Definition: ip6.h:83
#define ip6_ext_authhdr_len(p)
Definition: ip6_packet.h:510
uword * fib_index_by_table_id
Definition: ip6.h:206
#define ip6_ext_header_len(p)
Definition: ip6_packet.h:509
ip6_address_t fib_masks[129]
Definition: ip6.h:193
#define hash_mix64(a0, b0, c0)
Definition: hash.h:531
svmdb_client_t * c
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
Definition: ip6.h:71
u8 data[]
Packet data.
Definition: buffer.h:181
This table stores the routes that are used to forward traffic.
Definition: ip6.h:129
u32 dst_address_length
Definition: ip6.h:67
u32 index
Definition: ip6.h:92
#define ARRAY_LEN(x)
Definition: clib.h:66
u8 hbh_enabled
Definition: ip6.h:238
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1599
static void * ip6_next_header(ip6_header_t *i)
Definition: ip6_packet.h:371
void ip6_punt_redirect_add(u32 rx_sw_if_index, u32 tx_sw_if_index, ip46_address_t *nh)
static u8 ip6_ext_hdr(u8 nexthdr)
Definition: ip6_packet.h:488
void ip6_punt_redirect_del(u32 rx_sw_if_index)
ip6_address_t addr
Definition: ip6.h:66
vl_api_fib_path_t paths[n_paths]
Definition: ip.api:146
#define IP_FLOW_HASH_SYMMETRIC
Definition: lookup.h:67
u16 ip6_tcp_udp_icmp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip6_header_t *ip0, int *bogus_lengthp)
Definition: ip6_forward.c:1095
signed int i32
Definition: types.h:77
vlib_node_registration_t ip6_lookup_node
(constructor) VLIB_REGISTER_NODE (ip6_lookup_node)
Definition: ip6_forward.c:741
void ip6_punt_policer_add_del(u8 is_add, u32 policer_index)
#define ip6_frag_hdr_offset(hdr)
Definition: ip6_packet.h:664
#define IP6_FIB_NUM_TABLES
Definition: ip6.h:139
vl_api_interface_index_t tx_sw_if_index
Definition: ip.api:441
vlib buffer structure definition and a few select access methods.
#define ASSERT(truth)
#define IP_FLOW_HASH_SRC_ADDR
Flow hash configuration.
Definition: lookup.h:61
ip6_fib_table_instance_type_t_
Enumeration of the FIB table instance types.
Definition: ip6.h:123
serialize_function_t serialize_vnet_ip6_main
Definition: ip6.h:359
manual_print typedef address
Definition: ip_types.api:85
void ip6_punt_redirect_add_paths(u32 rx_sw_if_index, fib_route_path_t *paths)
ip6_main_t ip6_main
Definition: ip6_forward.c:2784
ip_lookup_main_t lookup_main
Definition: ip6.h:181
uword * non_empty_dst_address_length_bitmap
Definition: ip6.h:164
u16 * prefix_lengths_in_search_order
Definition: ip6.h:165
u32 table_id
Definition: ip6.h:89
struct ip6_main_t ip6_main_t
struct mfib_table_t_ * mfibs
Vector of MFIBs.
Definition: ip6.h:190
#define clib_mem_unaligned(pointer, type)
Definition: types.h:155
u32 flow_hash_config_t
A flow hash configuration is a mask of the flow hash options.
Definition: lookup.h:84
int vnet_set_ip6_flow_hash(u32 table_id, flow_hash_config_t flow_hash_config)
Definition: ip6_forward.c:2854
static int ip6_locate_header(vlib_buffer_t *p0, ip6_header_t *ip0, int find_hdr_type, u32 *offset)
Definition: ip6.h:465
#define vec_elt(v, i)
Get vector value at index i.
typedef key
Definition: ipsec_types.api:85
static uword ip6_destination_matches_interface(ip6_main_t *im, ip6_address_t *key, ip_interface_address_t *ia)
Definition: ip6.h:280
struct _vlib_node_registration vlib_node_registration_t
template key/value backing page structure
Definition: bihash_doc.h:44
u32 ip_version_traffic_class_and_flow_label
Definition: ip6_packet.h:297
Definition: defs.h:47
static void * vlib_buffer_push_uninit(vlib_buffer_t *b, u8 size)
Prepend uninitialized data to buffer.
Definition: buffer.h:335
struct ip6_mfib_table_instance_t_ ip6_mfib_table_instance_t
A representation of a single IP6 mfib table.
u16 payload_length
Definition: ip6_packet.h:301
struct ip6_fib_table_instance_t_ ip6_fib_table_instance_t
A representation of a single IP6 table.
vl_api_address_t ip
Definition: l2.api:501
static void * vlib_buffer_push_ip6(vlib_main_t *vm, vlib_buffer_t *b, ip6_address_t *src, ip6_address_t *dst, int proto)
Push IPv6 header to buffer.
Definition: ip6.h:606
serialize_function_t unserialize_vnet_ip6_main
Definition: ip6.h:359
u32 ip6_tcp_udp_icmp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
Definition: ip6_forward.c:1160
#define foreach_ip_interface_address(lm, a, sw_if_index, loop, body)
Definition: ip_interface.h:57
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
uword * non_empty_dst_address_length_bitmap
Definition: ip6.h:150
uword * interface_route_adj_index_by_sw_if_index
Definition: ip6.h:213
ip6_mfib_table_instance_t ip6_mtable
the single MFIB table
Definition: ip6.h:179
vlib_node_registration_t ip6_rewrite_local_node
#define vnet_buffer(b)
Definition: buffer.h:417
static struct option options[]
Definition: main.c:52
A protocol Independent IP multicast FIB table.
Definition: mfib_table.h:71
#define IP_FLOW_HASH_PROTO
Definition: lookup.h:63
void ip6_forward_next_trace(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, vlib_rx_or_tx_t which_adj_index)
Definition: ip6_forward.c:1003
vlib_main_t vlib_node_runtime_t vlib_frame_t * frame
Definition: in2out_ed.c:1600
u32 table_id
Definition: ip6.h:77
clib_error_t * ip6_add_del_interface_address(vlib_main_t *vm, u32 sw_if_index, ip6_address_t *address, u32 address_length, u32 is_del)
Definition: ip6_forward.c:297
CLIB_CACHE_LINE_ALIGN_MARK(cacheline0)
static void * vlib_buffer_push_ip6_custom(vlib_main_t *vm, vlib_buffer_t *b, ip6_address_t *src, ip6_address_t *dst, int proto, u32 flow_label)
Push IPv6 header to buffer.
Definition: ip6.h:563
u16 dst_port
Definition: udp.api:42
static uword ip6_unaligned_destination_matches_route(ip6_main_t *im, ip6_address_t *key, ip6_address_t *dest, uword dest_length)
Definition: ip6.h:290
static ip6_address_t * ip6_interface_address_matching_destination(ip6_main_t *im, const ip6_address_t *dst, u32 sw_if_index, ip_interface_address_t **result_ia)
Definition: ip6.h:307
struct fib_table_t_ * fibs
Definition: ip6.h:184
u32 * fib_index_by_sw_if_index
Definition: ip6.h:196
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip6_forward.c:239
enum ip6_fib_table_instance_type_t_ ip6_fib_table_instance_type_t
Enumeration of the FIB table instance types.
Definition: defs.h:46
IP prefix management on interfaces.
clib_bihash_40_8_t ip6_mhash
Definition: ip6.h:161
ip6_address_t dst_address
Definition: ip6_packet.h:310
A protocol Independent FIB table.
Definition: fib_table.h:71
uword next_override
Definition: ip6.h:536
u8 * format_ip6_forward_next_trace(u8 *s, va_list *args)
Definition: ip6_forward.c:951