FD.io VPP  v19.01.2-3-gf61a1a8
Vector Packet Processing
fib_types.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 #include <vnet/ip/ip.h>
17 
18 #include <vnet/fib/fib_types.h>
19 #include <vnet/fib/fib_internal.h>
20 #include <vnet/fib/fib_table.h>
21 #include <vnet/mpls/mpls.h>
22 
23 /*
24  * arrays of protocol and link names
25  */
26 static const char* fib_protocol_names[] = FIB_PROTOCOLS;
27 static const char* vnet_link_names[] = VNET_LINKS;
28 static const char* fib_forw_chain_names[] = FIB_FORW_CHAINS;
30 
31 u8 *
32 format_fib_protocol (u8 * s, va_list * ap)
33 {
34  fib_protocol_t proto = va_arg(*ap, int); // fib_protocol_t promotion
35 
36  return (format (s, "%s", fib_protocol_names[proto]));
37 }
38 
39 u8 *
40 format_vnet_link (u8 * s, va_list * ap)
41 {
42  vnet_link_t link = va_arg(*ap, int); // vnet_link_t promotion
43 
44  return (format (s, "%s", vnet_link_names[link]));
45 }
46 
47 u8 *
48 format_fib_forw_chain_type (u8 * s, va_list * args)
49 {
50  fib_forward_chain_type_t fct = va_arg(*args, int);
51 
52  return (format (s, "%s", fib_forw_chain_names[fct]));
53 }
54 
55 u8 *
56 format_fib_mpls_lsp_mode(u8 *s, va_list *ap)
57 {
58  fib_mpls_lsp_mode_t mode = va_arg(*ap, int);
59 
60  return (format (s, "%s", fib_mpls_lsp_mode_names[mode]));
61 }
62 
63 u8 *
64 format_fib_mpls_label (u8 *s, va_list *ap)
65 {
66  fib_mpls_label_t *label = va_arg(*ap, fib_mpls_label_t *);
67 
68  s = format(s, "%U %U ttl:%d exp:%d",
70  label->fml_value,
72  label->fml_mode,
73  label->fml_ttl,
74  label->fml_exp);
75 
76  return (s);
77 }
78 
79 void
80 fib_prefix_from_ip46_addr (const ip46_address_t *addr,
81  fib_prefix_t *pfx)
82 {
84 
85  pfx->fp_proto = ((ip46_address_is_ip4(addr) ?
88  pfx->fp_len = ((ip46_address_is_ip4(addr) ?
89  32 : 128));
90  pfx->fp_addr = *addr;
91 }
92 
93 void
95  mpls_eos_bit_t eos,
96  fib_prefix_t *pfx)
97 {
99  pfx->fp_len = 21;
100  pfx->fp_label = label;
101  pfx->fp_eos = eos;
102 }
103 
104 int
106  const fib_prefix_t *p2)
107 {
108  int res;
109 
110  res = (p1->fp_proto - p2->fp_proto);
111 
112  if (0 == res)
113  {
114  switch (p1->fp_proto)
115  {
116  case FIB_PROTOCOL_IP4:
117  case FIB_PROTOCOL_IP6:
118  res = (p1->fp_len - p2->fp_len);
119 
120  if (0 == res)
121  {
122  res = ip46_address_cmp(&p1->fp_addr, &p2->fp_addr);
123  }
124  break;
125  case FIB_PROTOCOL_MPLS:
126  res = (p1->fp_label - p2->fp_label);
127 
128  if (0 == res)
129  {
130  res = (p1->fp_eos - p2->fp_eos);
131  }
132  break;
133  }
134  }
135 
136  return (res);
137 }
138 
139 int
141  const fib_prefix_t *p2)
142 {
143  switch (p1->fp_proto)
144  {
145  case FIB_PROTOCOL_IP4:
147  &p1->fp_addr.ip4,
148  &p2->fp_addr.ip4,
149  p1->fp_len));
150  case FIB_PROTOCOL_IP6:
152  &p1->fp_addr.ip6,
153  &p2->fp_addr.ip6,
154  p1->fp_len));
155  case FIB_PROTOCOL_MPLS:
156  break;
157  }
158  return (0);
159 }
160 
161 int
163 {
164  switch (prefix->fp_proto)
165  {
166  case FIB_PROTOCOL_IP4:
167  return (prefix->fp_len == 32);
168  case FIB_PROTOCOL_IP6:
169  return (prefix->fp_len == 128);
170  case FIB_PROTOCOL_MPLS:
171  return (!0);
172  }
173  return (0);
174 }
175 
176 u8 *
177 format_fib_prefix (u8 * s, va_list * args)
178 {
179  fib_prefix_t *fp = va_arg (*args, fib_prefix_t *);
180 
181  /*
182  * protocol specific so it prints ::/0 correctly.
183  */
184  switch (fp->fp_proto)
185  {
186  case FIB_PROTOCOL_IP6:
187  {
188  ip6_address_t p6 = fp->fp_addr.ip6;
189 
191  s = format (s, "%U", format_ip6_address, &p6);
192  break;
193  }
194  case FIB_PROTOCOL_IP4:
195  {
196  ip4_address_t p4 = fp->fp_addr.ip4;
197  p4.as_u32 &= ip4_main.fib_masks[fp->fp_len];
198 
199  s = format (s, "%U", format_ip4_address, &p4);
200  break;
201  }
202  case FIB_PROTOCOL_MPLS:
203  s = format (s, "%U:%U",
206  break;
207  }
208  s = format (s, "/%d", fp->fp_len);
209 
210  return (s);
211 }
212 
213 int
215  const fib_route_path_t *rpath2)
216 {
217  int res;
218 
219  res = ip46_address_cmp(&rpath1->frp_addr,
220  &rpath2->frp_addr);
221 
222  if (0 != res) return (res);
223 
224  res = (rpath1->frp_sw_if_index - rpath2->frp_sw_if_index);
225 
226  if (0 != res) return (res);
227 
228  if (ip46_address_is_zero(&rpath1->frp_addr))
229  {
230  res = rpath1->frp_fib_index - rpath2->frp_fib_index;
231  }
232 
233  return (res);
234 }
235 
238 {
239  switch (fib_proto)
240  {
241  case FIB_PROTOCOL_IP6:
242  return (DPO_PROTO_IP6);
243  case FIB_PROTOCOL_IP4:
244  return (DPO_PROTO_IP4);
245  case FIB_PROTOCOL_MPLS:
246  return (DPO_PROTO_MPLS);
247  }
248  ASSERT(0);
249  return (0);
250 }
251 
254 {
255  switch (dpo_proto)
256  {
257  case DPO_PROTO_IP6:
258  return (FIB_PROTOCOL_IP6);
259  case DPO_PROTO_IP4:
260  return (FIB_PROTOCOL_IP4);
261  case DPO_PROTO_MPLS:
262  return (FIB_PROTOCOL_MPLS);
263  default:
264  break;
265  }
266  ASSERT(0);
267  return (0);
268 }
269 
272 {
273  switch (proto)
274  {
275  case FIB_PROTOCOL_IP4:
276  return (VNET_LINK_IP4);
277  case FIB_PROTOCOL_IP6:
278  return (VNET_LINK_IP6);
279  case FIB_PROTOCOL_MPLS:
280  return (VNET_LINK_MPLS);
281  }
282  ASSERT(0);
283  return (0);
284 }
285 
288 {
289  switch (fproto)
290  {
291  case FIB_PROTOCOL_IP4:
292  return (IP46_TYPE_IP4);
293  case FIB_PROTOCOL_IP6:
294  return (IP46_TYPE_IP6);
295  case FIB_PROTOCOL_MPLS:
296  return (IP46_TYPE_ANY);
297  }
298  ASSERT(0);
299  return (IP46_TYPE_ANY);
300 }
301 
304 {
305  switch (iproto)
306  {
307  case IP46_TYPE_IP4:
308  return FIB_PROTOCOL_IP4;
309  case IP46_TYPE_IP6:
310  return FIB_PROTOCOL_IP6;
311  case IP46_TYPE_ANY:
312  ASSERT(0);
313  return FIB_PROTOCOL_IP4;
314  }
315 
316  ASSERT(0);
317  return FIB_PROTOCOL_IP4;
318 }
319 
322 {
323  switch (proto)
324  {
325  case DPO_PROTO_IP4:
327  case DPO_PROTO_IP6:
329  case DPO_PROTO_MPLS:
331  case DPO_PROTO_ETHERNET:
333  case DPO_PROTO_NSH:
334  return (FIB_FORW_CHAIN_TYPE_NSH);
335  case DPO_PROTO_BIER:
336  return (FIB_FORW_CHAIN_TYPE_BIER);
337  }
338  ASSERT(0);
340 }
341 
344 {
345  switch (proto)
346  {
347  case FIB_PROTOCOL_IP4:
349  case FIB_PROTOCOL_IP6:
351  case FIB_PROTOCOL_MPLS:
353  }
354  ASSERT(0);
356 }
357 
360 {
361  switch (fct)
362  {
365  return (VNET_LINK_IP4);
368  return (VNET_LINK_IP6);
370  return (VNET_LINK_ETHERNET);
372  return (VNET_LINK_NSH);
375  /*
376  * insufficient information to to convert
377  */
378  ASSERT(0);
379  break;
381  return (VNET_LINK_MPLS);
382  }
383  return (VNET_LINK_IP4);
384 }
385 
388 {
389  switch (link_type)
390  {
391  case VNET_LINK_IP4:
393  case VNET_LINK_IP6:
395  case VNET_LINK_MPLS:
397  case VNET_LINK_ETHERNET:
399  case VNET_LINK_NSH:
400  return (FIB_FORW_CHAIN_TYPE_NSH);
401  case VNET_LINK_ARP:
402  break;
403  }
404 
405  ASSERT(0);
407 }
408 
411 {
412  switch (fct)
413  {
416  return (DPO_PROTO_IP4);
419  return (DPO_PROTO_IP6);
421  return (DPO_PROTO_ETHERNET);
423  return (DPO_PROTO_NSH);
425  return (DPO_PROTO_BIER);
428  return (DPO_PROTO_MPLS);
429  }
430  return (DPO_PROTO_IP4);
431 }
432 
433 uword
434 unformat_fib_route_path (unformat_input_t * input, va_list * args)
435 {
436  fib_route_path_t *rpath = va_arg (*args, fib_route_path_t *);
437  u32 *payload_proto = va_arg (*args, u32*);
438  u32 weight, preference, udp_encap_id, fi;
439  mpls_label_t out_label;
440  vnet_main_t *vnm;
441 
442  vnm = vnet_get_main ();
443  clib_memset(rpath, 0, sizeof(*rpath));
444  rpath->frp_weight = 1;
445  rpath->frp_sw_if_index = ~0;
446 
448  {
449  if (unformat (input, "%U %U",
451  &rpath->frp_addr.ip4,
453  &rpath->frp_sw_if_index))
454  {
455  rpath->frp_proto = DPO_PROTO_IP4;
456  }
457  else if (unformat (input, "%U %U",
459  &rpath->frp_addr.ip6,
461  &rpath->frp_sw_if_index))
462  {
463  rpath->frp_proto = DPO_PROTO_IP6;
464  }
465  else if (unformat (input, "weight %u", &weight))
466  {
467  rpath->frp_weight = weight;
468  }
469  else if (unformat (input, "preference %u", &preference))
470  {
471  rpath->frp_preference = preference;
472  }
473  else if (unformat (input, "%U next-hop-table %d",
475  &rpath->frp_addr.ip4,
476  &rpath->frp_fib_index))
477  {
478  rpath->frp_sw_if_index = ~0;
479  rpath->frp_proto = DPO_PROTO_IP4;
480 
481  /*
482  * the user enter table-ids, convert to index
483  */
485  if (~0 == fi)
486  return 0;
487  rpath->frp_fib_index = fi;
488  }
489  else if (unformat (input, "%U next-hop-table %d",
491  &rpath->frp_addr.ip6,
492  &rpath->frp_fib_index))
493  {
494  rpath->frp_sw_if_index = ~0;
495  rpath->frp_proto = DPO_PROTO_IP6;
497  if (~0 == fi)
498  return 0;
499  rpath->frp_fib_index = fi;
500  }
501  else if (unformat (input, "%U",
503  &rpath->frp_addr.ip4))
504  {
505  /*
506  * the recursive next-hops are by default in the default table
507  */
508  rpath->frp_fib_index = 0;
509  rpath->frp_sw_if_index = ~0;
510  rpath->frp_proto = DPO_PROTO_IP4;
511  }
512  else if (unformat (input, "%U",
514  &rpath->frp_addr.ip6))
515  {
516  rpath->frp_fib_index = 0;
517  rpath->frp_sw_if_index = ~0;
518  rpath->frp_proto = DPO_PROTO_IP6;
519  }
520  else if (unformat (input, "udp-encap %d", &udp_encap_id))
521  {
522  rpath->frp_udp_encap_id = udp_encap_id;
524  rpath->frp_proto = *payload_proto;
525  }
526  else if (unformat (input, "lookup in table %d", &rpath->frp_fib_index))
527  {
528  rpath->frp_proto = *payload_proto;
529  rpath->frp_sw_if_index = ~0;
530  rpath->frp_flags |= FIB_ROUTE_PATH_DEAG;
531  }
532  else if (unformat (input, "resolve-via-host"))
533  {
535  }
536  else if (unformat (input, "resolve-via-attached"))
537  {
539  }
540  else if (unformat (input,
541  "ip4-lookup-in-table %d",
542  &rpath->frp_fib_index))
543  {
544  rpath->frp_proto = DPO_PROTO_IP4;
545  *payload_proto = DPO_PROTO_IP4;
547  if (~0 == fi)
548  return 0;
549  rpath->frp_fib_index = fi;
550  }
551  else if (unformat (input,
552  "ip6-lookup-in-table %d",
553  &rpath->frp_fib_index))
554  {
555  rpath->frp_proto = DPO_PROTO_IP6;
556  *payload_proto = DPO_PROTO_IP6;
558  if (~0 == fi)
559  return 0;
560  rpath->frp_fib_index = fi;
561  }
562  else if (unformat (input,
563  "mpls-lookup-in-table %d",
564  &rpath->frp_fib_index))
565  {
566  rpath->frp_proto = DPO_PROTO_MPLS;
567  *payload_proto = DPO_PROTO_MPLS;
569  if (~0 == fi)
570  return 0;
571  rpath->frp_fib_index = fi;
572  }
573  else if (unformat (input, "src-lookup"))
574  {
576  }
577  else if (unformat (input,
578  "l2-input-on %U",
580  &rpath->frp_sw_if_index))
581  {
582  rpath->frp_proto = DPO_PROTO_ETHERNET;
583  *payload_proto = DPO_PROTO_ETHERNET;
585  }
586  else if (unformat (input, "via-label %U",
588  &rpath->frp_local_label))
589  {
590  rpath->frp_eos = MPLS_NON_EOS;
591  rpath->frp_proto = DPO_PROTO_MPLS;
592  rpath->frp_sw_if_index = ~0;
593  }
594  else if (unformat (input, "rx-ip4 %U",
596  &rpath->frp_sw_if_index))
597  {
598  rpath->frp_proto = DPO_PROTO_IP4;
600  }
601  else if (unformat (input, "out-labels"))
602  {
603  while (unformat (input, "%U",
604  unformat_mpls_unicast_label, &out_label))
605  {
606  fib_mpls_label_t fml = {
607  .fml_value = out_label,
608  };
609  vec_add1(rpath->frp_label_stack, fml);
610  }
611  }
612  else if (unformat (input, "%U",
614  &rpath->frp_sw_if_index))
615  {
616  rpath->frp_proto = *payload_proto;
617  }
618  else
619  {
620  return (0);
621  }
622  }
623 
624  return (1);
625 }
static const char * vnet_link_names[]
Definition: fib_types.c:27
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:212
Contribute an object that is to be used to forward BIER packets.
Definition: fib_types.h:122
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:137
ip46_address_t frp_addr
The next-hop address.
Definition: fib_types.h:486
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:113
fib_forward_chain_type_t fib_forw_chain_type_from_link_type(vnet_link_t link_type)
Convert from a adjacency&#39;s link type to chain type.
Definition: fib_types.c:387
static const char * fib_protocol_names[]
Definition: fib_types.c:26
mpls_eos_bit_t frp_eos
EOS bit for the resolving label.
Definition: fib_types.h:497
int fib_route_path_cmp(const fib_route_path_t *rpath1, const fib_route_path_t *rpath2)
Definition: fib_types.c:214
A representation of a path as described by a route producer.
Definition: fib_types.h:470
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
ip46_type_t fib_proto_to_ip46(fib_protocol_t fproto)
Convert from fib_protocol to ip46_type.
Definition: fib_types.c:287
uword unformat_fib_route_path(unformat_input_t *input, va_list *args)
Unformat a fib_route_path_t from CLI input.
Definition: fib_types.c:434
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:24
dpo_proto_t fib_forw_chain_type_to_dpo_proto(fib_forward_chain_type_t fct)
Convert from a chain type to the DPO proto it will install.
Definition: fib_types.c:410
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:525
#define VNET_LINKS
Definition: interface.h:349
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:109
clib_memset(h->entries, 0, sizeof(h->entries[0])*entries)
static uword ip4_destination_matches_route(const ip4_main_t *im, const ip4_address_t *key, const ip4_address_t *dest, uword dest_length)
Definition: ip4.h:181
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
dpo_proto_t frp_proto
The protocol of the address below.
Definition: fib_types.h:475
unformat_function_t unformat_vnet_sw_interface
A path that result in received traffic being recieved/recirculated so that it appears to have arrived...
Definition: fib_types.h:349
static void ip6_address_mask(ip6_address_t *a, const ip6_address_t *mask)
Definition: ip6_packet.h:263
vhost_vring_addr_t addr
Definition: vhost_user.h:121
#define ip46_address_cmp(ip46_1, ip46_2)
Definition: ip6_packet.h:92
unsigned char u8
Definition: types.h:56
int fib_prefix_is_host(const fib_prefix_t *prefix)
Return true is the prefix is a host prefix.
Definition: fib_types.c:162
u8 * format_fib_protocol(u8 *s, va_list *ap)
Definition: fib_types.c:32
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
unformat_function_t unformat_mpls_unicast_label
Definition: mpls.h:79
format_function_t format_ip4_address
Definition: format.h:75
unformat_function_t unformat_ip4_address
Definition: format.h:70
u32 frp_sw_if_index
The interface.
Definition: fib_types.h:505
static const char * fib_mpls_lsp_mode_names[]
Definition: fib_types.c:29
u8 * format_fib_mpls_lsp_mode(u8 *s, va_list *ap)
Format an LSP mode type.
Definition: fib_types.c:56
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:264
Recursion constraint of via a host prefix.
Definition: fib_types.h:324
u8 * format_fib_prefix(u8 *s, va_list *args)
Definition: fib_types.c:177
Aggregrate type for a prefix.
Definition: fib_types.h:203
int fib_prefix_is_cover(const fib_prefix_t *p1, const fib_prefix_t *p2)
Compare two prefixes for covering relationship.
Definition: fib_types.c:140
A path via a UDP encap object.
Definition: fib_types.h:361
unsigned int u32
Definition: types.h:88
Contribute an object that is to be used to forward Ethernet packets.
Definition: fib_types.h:141
enum dpo_proto_t_ dpo_proto_t
Data path protocol.
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
fib_protocol_t dpo_proto_to_fib(dpo_proto_t dpo_proto)
Definition: fib_types.c:253
u16 fp_len
The mask length.
Definition: fib_types.h:207
fib_protocol_t fib_proto_from_ip46(ip46_type_t iproto)
Convert from ip46_type to fib_protocol.
Definition: fib_types.c:303
Contribute an object that is to be used to forward end-of-stack MPLS packets.
Definition: fib_types.h:129
format_function_t format_mpls_eos_bit
Definition: mpls.h:67
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:226
struct _unformat_input_t unformat_input_t
enum fib_mpls_lsp_mode_t_ fib_mpls_lsp_mode_t
MPLS LSP mode - only valid at the head and tail.
static const char * fib_forw_chain_names[]
Definition: fib_types.c:28
Configuration for each label value in the output-stack.
Definition: fib_types.h:425
fib_mpls_label_t * frp_label_stack
The outgoing MPLS label Stack.
Definition: fib_types.h:525
Recursion constraint of via an attahced prefix.
Definition: fib_types.h:328
fib_mpls_lsp_mode_t fml_mode
The LSP mode.
Definition: fib_types.h:435
#define ip46_address_is_ip4(ip46)
Definition: ip6_packet.h:88
unformat_function_t unformat_ip6_address
Definition: format.h:91
ip6_address_t fib_masks[129]
Definition: ip6.h:190
vnet_link_t fib_forw_chain_type_to_link_type(fib_forward_chain_type_t fct)
Convert from a chain type to the adjacency&#39;s link type.
Definition: fib_types.c:359
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
format_function_t format_ip6_address
Definition: format.h:93
Contribute an object that is to be used to forward NSH packets.
Definition: fib_types.h:147
void fib_prefix_from_mpls_label(mpls_label_t label, mpls_eos_bit_t eos, fib_prefix_t *pfx)
Definition: fib_types.c:94
mpls_label_t fml_value
The label value.
Definition: fib_types.h:430
void fib_prefix_from_ip46_addr(const ip46_address_t *addr, fib_prefix_t *pfx)
Host prefix from ip.
Definition: fib_types.c:80
mpls_label_t fp_label
Definition: fib_types.h:229
#define ASSERT(truth)
ip6_main_t ip6_main
Definition: ip6_forward.c:2624
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
ip46_type_t
Definition: ip6_packet.h:70
u8 frp_preference
A path preference.
Definition: fib_types.h:567
A deag path using the packet&#39;s source not destination address.
Definition: fib_types.h:357
enum fib_forward_chain_type_t_ fib_forward_chain_type_t
FIB output chain type.
fib_route_path_flags_t frp_flags
flags on the path
Definition: fib_types.h:571
u8 * format_fib_forw_chain_type(u8 *s, va_list *args)
Definition: fib_types.c:48
#define FIB_FORW_CHAINS
Definition: fib_types.h:150
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:237
A path that resolves via another table.
Definition: fib_types.h:377
format_function_t format_mpls_unicast_label
Definition: mpls.h:69
mpls_label_t frp_local_label
The MPLS local Label to reursively resolve through.
Definition: fib_types.h:493
#define FIB_MPLS_LSP_MODES
Definition: fib_types.h:412
int fib_prefix_cmp(const fib_prefix_t *p1, const fib_prefix_t *p2)
Compare two prefixes for equality.
Definition: fib_types.c:105
u64 uword
Definition: types.h:112
typedef prefix
Definition: ip_types.api:35
u8 * format_fib_mpls_label(u8 *s, va_list *ap)
Format an MPLS label.
Definition: fib_types.c:64
vl_api_gbp_vxlan_tunnel_mode_t mode
Definition: gbp.api:349
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:903
vnet_link_t fib_proto_to_link(fib_protocol_t proto)
Convert from a protocol to a link type.
Definition: fib_types.c:271
u8 fml_exp
EXP bits; valid only at imposition.
Definition: fib_types.h:445
u8 * format_vnet_link(u8 *s, va_list *ap)
Definition: fib_types.c:40
Contribute an object that is to be used to forward non-end-of-stack MPLS packets. ...
Definition: fib_types.h:118
u8 frp_weight
[un]equal cost path weight
Definition: fib_types.h:561
u32 frp_udp_encap_id
UDP encap ID.
Definition: fib_types.h:551
#define ip46_address_is_zero(ip46)
Definition: ip6_packet.h:93
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:133
u32 frp_fib_index
The FIB index to lookup the nexthop Only valid for recursive paths.
Definition: fib_types.h:516
fib_forward_chain_type_t fib_forw_chain_type_from_dpo_proto(dpo_proto_t proto)
Convert from a payload-protocol to a chain type.
Definition: fib_types.c:321
#define FIB_PROTOCOLS
Definition: fib_types.h:42
fib_forward_chain_type_t fib_forw_chain_type_from_fib_proto(fib_protocol_t proto)
Convert from a fib-protocol to a chain type.
Definition: fib_types.c:343
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
mpls_eos_bit_t fp_eos
Definition: fib_types.h:230
u32 fib_masks[33]
Definition: ip4.h:109
enum mpls_eos_bit_t_ mpls_eos_bit_t