FD.io VPP  v20.05.1-6-gf53edbc3b
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/mfib/mfib_types.h>
22 #include <vnet/mpls/mpls.h>
23 
24 /*
25  * arrays of protocol and link names
26  */
27 static const char* fib_protocol_names[] = FIB_PROTOCOLS;
28 static const char* vnet_link_names[] = VNET_LINKS;
29 static const char* fib_forw_chain_names[] = FIB_FORW_CHAINS;
31 
32 u8 *
33 format_fib_protocol (u8 * s, va_list * ap)
34 {
35  fib_protocol_t proto = va_arg(*ap, int); // fib_protocol_t promotion
36 
37  return (format (s, "%s", fib_protocol_names[proto]));
38 }
39 
40 u8 *
41 format_vnet_link (u8 * s, va_list * ap)
42 {
43  vnet_link_t link = va_arg(*ap, int); // vnet_link_t promotion
44 
45  return (format (s, "%s", vnet_link_names[link]));
46 }
47 
48 u8 *
49 format_fib_forw_chain_type (u8 * s, va_list * args)
50 {
51  fib_forward_chain_type_t fct = va_arg(*args, int);
52 
53  return (format (s, "%s", fib_forw_chain_names[fct]));
54 }
55 
56 u8 *
57 format_fib_mpls_lsp_mode(u8 *s, va_list *ap)
58 {
59  fib_mpls_lsp_mode_t mode = va_arg(*ap, int);
60 
61  return (format (s, "%s", fib_mpls_lsp_mode_names[mode]));
62 }
63 
64 u8 *
65 format_fib_mpls_label (u8 *s, va_list *ap)
66 {
67  fib_mpls_label_t *label = va_arg(*ap, fib_mpls_label_t *);
68 
69  s = format(s, "%U %U ttl:%d exp:%d",
71  label->fml_value,
73  label->fml_mode,
74  label->fml_ttl,
75  label->fml_exp);
76 
77  return (s);
78 }
79 
80 void
81 fib_prefix_from_ip46_addr (const ip46_address_t *addr,
82  fib_prefix_t *pfx)
83 {
85 
86  pfx->fp_proto = ((ip46_address_is_ip4(addr) ?
89  pfx->fp_len = ((ip46_address_is_ip4(addr) ?
90  32 : 128));
91  pfx->fp_addr = *addr;
92  pfx->___fp___pad = 0;
93 }
94 
95 u8 *
97 {
99 
101  s = format (s, "via-host");
103  s = format (s, "via-attached,");
104  if (flags & FIB_ROUTE_PATH_LOCAL)
105  s = format (s, "local,");
106  if (flags & FIB_ROUTE_PATH_ATTACHED)
107  s = format (s, "attached,");
108  if (flags & FIB_ROUTE_PATH_DROP)
109  s = format (s, "drop,");
110  if (flags & FIB_ROUTE_PATH_EXCLUSIVE)
111  s = format (s, "exclusive,");
112  if (flags & FIB_ROUTE_PATH_INTF_RX)
113  s = format (s, "intf-rx,");
114  if (flags & FIB_ROUTE_PATH_RPF_ID)
115  s = format (s, "rpf-id,");
116  if (flags & FIB_ROUTE_PATH_SOURCE_LOOKUP)
117  s = format (s, "src-lkup,");
118  if (flags & FIB_ROUTE_PATH_UDP_ENCAP)
119  s = format (s, "udp-encap,");
120  if (flags & FIB_ROUTE_PATH_BIER_FMASK)
121  s = format (s, "bier-fmask,");
122  if (flags & FIB_ROUTE_PATH_BIER_TABLE)
123  s = format (s, "bier-table,");
124  if (flags & FIB_ROUTE_PATH_BIER_IMP)
125  s = format (s, "bier-imp,");
126  if (flags & FIB_ROUTE_PATH_DEAG)
127  s = format (s, "deag,");
128  if (flags & FIB_ROUTE_PATH_DVR)
129  s = format (s, "dvr,");
130  if (flags & FIB_ROUTE_PATH_ICMP_UNREACH)
131  s = format (s, "imcp-unreach,");
132  if (flags & FIB_ROUTE_PATH_ICMP_PROHIBIT)
133  s = format (s, "icmp-prohibit,");
134  if (flags & FIB_ROUTE_PATH_CLASSIFY)
135  s = format (s, "classify,");
136  if (flags & FIB_ROUTE_PATH_POP_PW_CW)
137  s = format (s, "pop-pw-cw,");
138 
139  return (s);
140 }
141 
142 u8 *
143 format_fib_route_path (u8 *s, va_list *ap)
144 {
145  fib_route_path_t *rpath = va_arg (*ap, fib_route_path_t*);
146 
147  s = format (s, "%U %U, %U, [%U]",
148  format_dpo_proto, rpath->frp_proto,
151  rpath->frp_sw_if_index,
153 
154  return (s);
155 }
156 
157 void
159  mpls_eos_bit_t eos,
160  fib_prefix_t *pfx)
161 {
163  pfx->fp_len = 21;
164  pfx->fp_label = label;
165  pfx->fp_eos = eos;
166  pfx->___fp___pad = 0;
167 }
168 
169 void
171  const fib_prefix_t *src)
172 {
173  clib_memcpy(dst, src, sizeof(*dst));
174 }
175 
176 int
178  const fib_prefix_t *p2)
179 {
180  int res;
181 
182  res = (p1->fp_proto - p2->fp_proto);
183 
184  if (0 == res)
185  {
186  switch (p1->fp_proto)
187  {
188  case FIB_PROTOCOL_IP4:
189  case FIB_PROTOCOL_IP6:
190  res = (p1->fp_len - p2->fp_len);
191 
192  if (0 == res)
193  {
194  res = ip46_address_cmp(&p1->fp_addr, &p2->fp_addr);
195  }
196  break;
197  case FIB_PROTOCOL_MPLS:
198  res = (p1->fp_label - p2->fp_label);
199 
200  if (0 == res)
201  {
202  res = (p1->fp_eos - p2->fp_eos);
203  }
204  break;
205  }
206  }
207 
208  return (res);
209 }
210 
211 int
213  const fib_prefix_t *p2)
214 {
215  switch (p1->fp_proto)
216  {
217  case FIB_PROTOCOL_IP4:
219  &p1->fp_addr.ip4,
220  &p2->fp_addr.ip4,
221  p1->fp_len));
222  case FIB_PROTOCOL_IP6:
224  &p1->fp_addr.ip6,
225  &p2->fp_addr.ip6,
226  p1->fp_len));
227  case FIB_PROTOCOL_MPLS:
228  break;
229  }
230  return (0);
231 }
232 
233 u8
235 {
236  switch (proto)
237  {
238  case FIB_PROTOCOL_IP4:
239  return (32);
240  case FIB_PROTOCOL_IP6:
241  return (128);
242  case FIB_PROTOCOL_MPLS:
243  return (21);
244  }
245  return (0);
246 }
247 
248 int
250 {
251  switch (prefix->fp_proto)
252  {
253  case FIB_PROTOCOL_IP4:
254  return (prefix->fp_len == 32);
255  case FIB_PROTOCOL_IP6:
256  return (prefix->fp_len == 128);
257  case FIB_PROTOCOL_MPLS:
258  return (!0);
259  }
260  return (0);
261 }
262 
263 u8 *
264 format_fib_prefix (u8 * s, va_list * args)
265 {
266  fib_prefix_t *fp = va_arg (*args, fib_prefix_t *);
267 
268  /*
269  * protocol specific so it prints ::/0 correctly.
270  */
271  switch (fp->fp_proto)
272  {
273  case FIB_PROTOCOL_IP6:
274  {
275  ip6_address_t p6 = fp->fp_addr.ip6;
276 
278  s = format (s, "%U", format_ip6_address, &p6);
279  break;
280  }
281  case FIB_PROTOCOL_IP4:
282  {
283  ip4_address_t p4 = fp->fp_addr.ip4;
284  p4.as_u32 &= ip4_main.fib_masks[fp->fp_len];
285 
286  s = format (s, "%U", format_ip4_address, &p4);
287  break;
288  }
289  case FIB_PROTOCOL_MPLS:
290  s = format (s, "%U:%U",
293  break;
294  }
295  s = format (s, "/%d", fp->fp_len);
296 
297  return (s);
298 }
299 
300 int
302  const fib_route_path_t *rpath2)
303 {
304  int res;
305 
306  res = ip46_address_cmp(&rpath1->frp_addr,
307  &rpath2->frp_addr);
308 
309  if (0 != res) return (res);
310 
311  res = (rpath1->frp_sw_if_index - rpath2->frp_sw_if_index);
312 
313  if (0 != res) return (res);
314 
315  if (ip46_address_is_zero(&rpath1->frp_addr))
316  {
317  res = rpath1->frp_fib_index - rpath2->frp_fib_index;
318  }
319 
320  return (res);
321 }
322 
325 {
326  switch (fib_proto)
327  {
328  case FIB_PROTOCOL_IP6:
329  return (DPO_PROTO_IP6);
330  case FIB_PROTOCOL_IP4:
331  return (DPO_PROTO_IP4);
332  case FIB_PROTOCOL_MPLS:
333  return (DPO_PROTO_MPLS);
334  }
335  ASSERT(0);
336  return (0);
337 }
338 
341 {
342  switch (dpo_proto)
343  {
344  case DPO_PROTO_IP6:
345  return (FIB_PROTOCOL_IP6);
346  case DPO_PROTO_IP4:
347  return (FIB_PROTOCOL_IP4);
348  case DPO_PROTO_MPLS:
349  return (FIB_PROTOCOL_MPLS);
350  default:
351  break;
352  }
353  ASSERT(0);
354  return (0);
355 }
356 
359 {
360  switch (proto)
361  {
362  case FIB_PROTOCOL_IP4:
363  return (VNET_LINK_IP4);
364  case FIB_PROTOCOL_IP6:
365  return (VNET_LINK_IP6);
366  case FIB_PROTOCOL_MPLS:
367  return (VNET_LINK_MPLS);
368  }
369  ASSERT(0);
370  return (0);
371 }
372 
375 {
376  switch (fproto)
377  {
378  case FIB_PROTOCOL_IP4:
379  return (IP46_TYPE_IP4);
380  case FIB_PROTOCOL_IP6:
381  return (IP46_TYPE_IP6);
382  case FIB_PROTOCOL_MPLS:
383  return (IP46_TYPE_ANY);
384  }
385  ASSERT(0);
386  return (IP46_TYPE_ANY);
387 }
388 
391 {
392  switch (iproto)
393  {
394  case IP46_TYPE_IP4:
395  return FIB_PROTOCOL_IP4;
396  case IP46_TYPE_IP6:
397  return FIB_PROTOCOL_IP6;
398  case IP46_TYPE_ANY:
399  ASSERT(0);
400  return FIB_PROTOCOL_IP4;
401  }
402 
403  ASSERT(0);
404  return FIB_PROTOCOL_IP4;
405 }
406 
409 {
410  switch (proto)
411  {
412  case DPO_PROTO_IP4:
414  case DPO_PROTO_IP6:
416  case DPO_PROTO_MPLS:
418  case DPO_PROTO_ETHERNET:
420  case DPO_PROTO_NSH:
421  return (FIB_FORW_CHAIN_TYPE_NSH);
422  case DPO_PROTO_BIER:
423  return (FIB_FORW_CHAIN_TYPE_BIER);
424  }
425  ASSERT(0);
427 }
428 
431 {
432  switch (proto)
433  {
434  case FIB_PROTOCOL_IP4:
436  case FIB_PROTOCOL_IP6:
438  case FIB_PROTOCOL_MPLS:
440  }
441  ASSERT(0);
443 }
444 
447 {
448  switch (fct)
449  {
452  return (VNET_LINK_IP4);
455  return (VNET_LINK_IP6);
457  return (VNET_LINK_ETHERNET);
459  return (VNET_LINK_NSH);
462  /*
463  * insufficient information to to convert
464  */
465  ASSERT(0);
466  break;
468  return (VNET_LINK_MPLS);
469  }
470  return (VNET_LINK_IP4);
471 }
472 
475 {
476  switch (link_type)
477  {
478  case VNET_LINK_IP4:
480  case VNET_LINK_IP6:
482  case VNET_LINK_MPLS:
484  case VNET_LINK_ETHERNET:
486  case VNET_LINK_NSH:
487  return (FIB_FORW_CHAIN_TYPE_NSH);
488  case VNET_LINK_ARP:
489  break;
490  }
491 
492  ASSERT(0);
494 }
495 
498 {
499  switch (fct)
500  {
503  return (DPO_PROTO_IP4);
506  return (DPO_PROTO_IP6);
508  return (DPO_PROTO_ETHERNET);
510  return (DPO_PROTO_NSH);
512  return (DPO_PROTO_BIER);
515  return (DPO_PROTO_MPLS);
516  }
517  return (DPO_PROTO_IP4);
518 }
519 
520 uword
521 unformat_fib_route_path (unformat_input_t * input, va_list * args)
522 {
523  fib_route_path_t *rpath = va_arg (*args, fib_route_path_t *);
524  dpo_proto_t *payload_proto = va_arg (*args, void*);
525  u32 weight, preference, udp_encap_id, fi;
526  mpls_label_t out_label;
527  vnet_main_t *vnm;
528 
529  vnm = vnet_get_main ();
530  clib_memset(rpath, 0, sizeof(*rpath));
531  rpath->frp_weight = 1;
532  rpath->frp_sw_if_index = ~0;
533 
535  {
536  if (unformat (input, "%U %U",
538  &rpath->frp_addr.ip4,
540  &rpath->frp_sw_if_index))
541  {
542  rpath->frp_proto = DPO_PROTO_IP4;
543  }
544  else if (unformat (input, "%U %U",
546  &rpath->frp_addr.ip6,
548  &rpath->frp_sw_if_index))
549  {
550  rpath->frp_proto = DPO_PROTO_IP6;
551  }
552  else if (unformat (input, "weight %u", &weight))
553  {
554  rpath->frp_weight = weight;
555  }
556  else if (unformat (input, "preference %u", &preference))
557  {
558  rpath->frp_preference = preference;
559  }
560  else if (unformat (input, "%U next-hop-table %d",
562  &rpath->frp_addr.ip4,
563  &rpath->frp_fib_index))
564  {
565  rpath->frp_sw_if_index = ~0;
566  rpath->frp_proto = DPO_PROTO_IP4;
567 
568  /*
569  * the user enter table-ids, convert to index
570  */
572  if (~0 == fi)
573  return 0;
574  rpath->frp_fib_index = fi;
575  }
576  else if (unformat (input, "%U next-hop-table %d",
578  &rpath->frp_addr.ip6,
579  &rpath->frp_fib_index))
580  {
581  rpath->frp_sw_if_index = ~0;
582  rpath->frp_proto = DPO_PROTO_IP6;
584  if (~0 == fi)
585  return 0;
586  rpath->frp_fib_index = fi;
587  }
588  else if (unformat (input, "%U",
590  &rpath->frp_addr.ip4))
591  {
592  /*
593  * the recursive next-hops are by default in the default table
594  */
595  rpath->frp_fib_index = 0;
596  rpath->frp_sw_if_index = ~0;
597  rpath->frp_proto = DPO_PROTO_IP4;
598  }
599  else if (unformat (input, "%U",
601  &rpath->frp_addr.ip6))
602  {
603  rpath->frp_fib_index = 0;
604  rpath->frp_sw_if_index = ~0;
605  rpath->frp_proto = DPO_PROTO_IP6;
606  }
607  else if (unformat (input, "udp-encap %d", &udp_encap_id))
608  {
609  rpath->frp_udp_encap_id = udp_encap_id;
611  rpath->frp_proto = *payload_proto;
612  }
613  else if (unformat (input, "lookup in table %d", &rpath->frp_fib_index))
614  {
615  rpath->frp_proto = *payload_proto;
616  rpath->frp_sw_if_index = ~0;
617  rpath->frp_flags |= FIB_ROUTE_PATH_DEAG;
618  }
619  else if (unformat (input, "resolve-via-host"))
620  {
622  }
623  else if (unformat (input, "resolve-via-attached"))
624  {
626  }
627  else if (unformat (input, "pop-pw-cw"))
628  {
630  }
631  else if (unformat (input,
632  "ip4-lookup-in-table %d",
633  &rpath->frp_fib_index))
634  {
635  rpath->frp_proto = DPO_PROTO_IP4;
636  *payload_proto = DPO_PROTO_IP4;
638  if (~0 == fi)
639  return 0;
640  rpath->frp_fib_index = fi;
641  }
642  else if (unformat (input,
643  "ip6-lookup-in-table %d",
644  &rpath->frp_fib_index))
645  {
646  rpath->frp_proto = DPO_PROTO_IP6;
647  *payload_proto = DPO_PROTO_IP6;
649  if (~0 == fi)
650  return 0;
651  rpath->frp_fib_index = fi;
652  }
653  else if (unformat (input,
654  "mpls-lookup-in-table %d",
655  &rpath->frp_fib_index))
656  {
657  rpath->frp_proto = DPO_PROTO_MPLS;
658  *payload_proto = DPO_PROTO_MPLS;
660  if (~0 == fi)
661  return 0;
662  rpath->frp_fib_index = fi;
663  }
664  else if (unformat (input, "src-lookup"))
665  {
667  }
668  else if (unformat (input,
669  "l2-input-on %U",
671  &rpath->frp_sw_if_index))
672  {
673  rpath->frp_proto = DPO_PROTO_ETHERNET;
674  *payload_proto = DPO_PROTO_ETHERNET;
676  }
677  else if (unformat (input, "via-label %U",
679  &rpath->frp_local_label))
680  {
681  rpath->frp_eos = MPLS_NON_EOS;
682  rpath->frp_proto = DPO_PROTO_MPLS;
683  rpath->frp_sw_if_index = ~0;
684  }
685  else if (unformat (input, "rx-ip4 %U",
687  &rpath->frp_sw_if_index))
688  {
689  rpath->frp_proto = DPO_PROTO_IP4;
691  }
692  else if (unformat (input, "local"))
693  {
694  clib_memset (&rpath->frp_addr, 0, sizeof (rpath->frp_addr));
695  rpath->frp_sw_if_index = ~0;
696  rpath->frp_weight = 1;
698  }
699  else if (unformat (input, "%U",
701  ;
702  else if (unformat (input, "out-labels"))
703  {
704  while (unformat (input, "%U",
705  unformat_mpls_unicast_label, &out_label))
706  {
707  fib_mpls_label_t fml = {
708  .fml_value = out_label,
709  };
710  vec_add1(rpath->frp_label_stack, fml);
711  }
712  }
713  else if (unformat (input, "%U",
715  &rpath->frp_sw_if_index))
716  {
717  rpath->frp_proto = *payload_proto;
718  }
719  else if (unformat (input, "via"))
720  {
721  /* new path, back up and return */
722  unformat_put_input (input);
723  unformat_put_input (input);
724  unformat_put_input (input);
725  unformat_put_input (input);
726  break;
727  }
728  else
729  {
730  return (0);
731  }
732  }
733 
734  return (1);
735 }
static const char * vnet_link_names[]
Definition: fib_types.c:28
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:506
A path that resolves via a DVR DPO.
Definition: fib_types.h:387
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:474
static const char * fib_protocol_names[]
Definition: fib_types.c:27
mpls_eos_bit_t frp_eos
EOS bit for the resolving label.
Definition: fib_types.h:517
int fib_route_path_cmp(const fib_route_path_t *rpath1, const fib_route_path_t *rpath2)
Definition: fib_types.c:301
A representation of a path as described by a route producer.
Definition: fib_types.h:490
uword unformat_mfib_itf_flags(unformat_input_t *input, va_list *args)
Definition: mfib_types.c:198
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
A Drop path - resolve the path on the drop DPO.
Definition: fib_types.h:346
ip46_type_t fib_proto_to_ip46(fib_protocol_t fproto)
Convert from fib_protocol to ip46_type.
Definition: fib_types.c:374
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:521
u32 frp_mitf_flags
MFIB interface flags.
Definition: fib_types.h:559
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
A path that resolves via a BIER impostion object.
Definition: fib_types.h:379
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:26
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:497
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:590
vl_api_address_t src
Definition: gre.api:54
A path that resolves via a BIER [ECMP] Table.
Definition: fib_types.h:375
#define VNET_LINKS
Definition: interface.h:342
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:109
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:197
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
dpo_proto_t frp_proto
The protocol of the address below.
Definition: fib_types.h:495
unformat_function_t unformat_vnet_sw_interface
vl_api_prefix_t prefix
Definition: ip.api:144
A path that result in received traffic being recieved/recirculated so that it appears to have arrived...
Definition: fib_types.h:355
static u8 ip46_address_is_ip4(const ip46_address_t *ip46)
Definition: ip46_address.h:55
static void ip6_address_mask(ip6_address_t *a, const ip6_address_t *mask)
Definition: ip6_packet.h:195
vhost_vring_addr_t addr
Definition: vhost_user.h:254
format_function_t format_vnet_sw_if_index_name
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:249
u8 * format_fib_protocol(u8 *s, va_list *ap)
Definition: fib_types.c:33
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
unformat_function_t unformat_mpls_unicast_label
Definition: mpls.h:81
#define clib_memcpy(d, s, n)
Definition: string.h:180
A local path with a RPF-ID => multicast traffic.
Definition: fib_types.h:359
u8 preference
Definition: fib_types.api:121
format_function_t format_ip4_address
Definition: format.h:73
unformat_function_t unformat_ip4_address
Definition: format.h:68
u32 frp_sw_if_index
The interface.
Definition: fib_types.h:530
static const char * fib_mpls_lsp_mode_names[]
Definition: fib_types.c:30
u8 * format_fib_mpls_lsp_mode(u8 *s, va_list *ap)
Format an LSP mode type.
Definition: fib_types.c:57
static int ip46_address_cmp(const ip46_address_t *ip46_1, const ip46_address_t *ip46_2)
Definition: ip46_address.h:80
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
Recursion constraint of via a host prefix.
Definition: fib_types.h:330
u8 * format_fib_prefix(u8 *s, va_list *args)
Definition: fib_types.c:264
Aggregate 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:212
A path via a UDP encap object.
Definition: fib_types.h:367
enum fib_route_path_flags_t_ fib_route_path_flags_t
Path flags from the control plane.
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:1097
fib_protocol_t dpo_proto_to_fib(dpo_proto_t dpo_proto)
Definition: fib_types.c:340
u16 fp_len
The mask length.
Definition: fib_types.h:207
u8 * format_fib_route_path(u8 *s, va_list *ap)
Format route path flags.
Definition: fib_types.c:143
fib_protocol_t fib_proto_from_ip46(ip46_type_t iproto)
Convert from ip46_type to fib_protocol.
Definition: fib_types.c:390
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:69
u8 * format_fib_route_path_flags(u8 *s, va_list *ap)
Format route path flags.
Definition: fib_types.c:96
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:226
vl_api_ip_proto_t proto
Definition: acl_types.api:50
static u8 ip46_address_is_zero(const ip46_address_t *ip46)
Definition: ip46_address.h:87
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.
u8 weight
Definition: fib_types.api:120
static const char * fib_forw_chain_names[]
Definition: fib_types.c:29
Configuration for each label value in the output-stack.
Definition: fib_types.h:445
fib_mpls_label_t * frp_label_stack
The outgoing MPLS label Stack.
Definition: fib_types.h:551
Recursion constraint of via an attahced prefix.
Definition: fib_types.h:334
ip6_main_t ip6_main
Definition: ip6_forward.c:2784
static void unformat_put_input(unformat_input_t *input)
Definition: format.h:205
u32 label
Definition: fib_types.api:25
vl_api_address_t dst
Definition: gre.api:55
fib_mpls_lsp_mode_t fml_mode
The LSP mode.
Definition: fib_types.h:455
Pop a Psuedo Wire Control Word.
Definition: fib_types.h:396
vl_api_tunnel_mode_t mode
Definition: gre.api:48
format_function_t format_ip46_address
Definition: ip46_address.h:50
unformat_function_t unformat_ip6_address
Definition: format.h:89
ip6_address_t fib_masks[129]
Definition: ip6.h:193
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:446
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
u32 flags
Definition: vhost_user.h:248
format_function_t format_ip6_address
Definition: format.h:91
u8 fib_prefix_get_host_length(fib_protocol_t proto)
Definition: fib_types.c:234
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:158
Don&#39;t resolve the path, use the DPO the client provides.
Definition: fib_types.h:350
mpls_label_t fml_value
The label value.
Definition: fib_types.h:450
void fib_prefix_from_ip46_addr(const ip46_address_t *addr, fib_prefix_t *pfx)
Host prefix from ip.
Definition: fib_types.c:81
mpls_label_t fp_label
Definition: fib_types.h:229
#define ASSERT(truth)
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
u8 frp_preference
A path preference.
Definition: fib_types.h:596
A deag path using the packet&#39;s source not destination address.
Definition: fib_types.h:363
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:600
u8 * format_fib_forw_chain_type(u8 *s, va_list *args)
Definition: fib_types.c:49
#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:324
void fib_prefix_copy(fib_prefix_t *dst, const fib_prefix_t *src)
Copy a prefix.
Definition: fib_types.c:170
A path that resolves via a BIER F-Mask.
Definition: fib_types.h:371
A path that resolves via another table.
Definition: fib_types.h:383
format_function_t format_mpls_unicast_label
Definition: mpls.h:71
mpls_label_t frp_local_label
The MPLS local Label to reursively resolve through.
Definition: fib_types.h:513
#define FIB_MPLS_LSP_MODES
Definition: fib_types.h:432
int fib_prefix_cmp(const fib_prefix_t *p1, const fib_prefix_t *p2)
Compare two prefixes for equality.
Definition: fib_types.c:177
A for-us/local path.
Definition: fib_types.h:338
u64 uword
Definition: types.h:112
u8 * format_dpo_proto(u8 *s, va_list *args)
format a DPO protocol
Definition: dpo.c:178
u8 * format_fib_mpls_label(u8 *s, va_list *ap)
Format an MPLS label.
Definition: fib_types.c:65
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1144
vnet_link_t fib_proto_to_link(fib_protocol_t proto)
Convert from a protocol to a link type.
Definition: fib_types.c:358
u8 fml_exp
EXP bits; valid only at imposition.
Definition: fib_types.h:465
u8 * format_vnet_link(u8 *s, va_list *ap)
Definition: fib_types.c:41
Contribute an object that is to be used to forward non-end-of-stack MPLS packets. ...
Definition: fib_types.h:118
Attached path.
Definition: fib_types.h:342
u8 frp_weight
[un]equal cost path weight
Definition: fib_types.h:590
u32 frp_udp_encap_id
UDP encap ID.
Definition: fib_types.h:570
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:542
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:408
#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:430
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
ip46_type_t
Definition: ip46_address.h:22
mpls_eos_bit_t fp_eos
Definition: fib_types.h:230
u32 fib_masks[33]
Definition: ip4.h:119
enum mpls_eos_bit_t_ mpls_eos_bit_t