FD.io VPP  v18.07.1-19-g511ce25
Vector Packet Processing
lookup.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 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/ip_lookup.c: ip4/6 adjacency and lookup table managment
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/ip/ip.h>
41 #include <vnet/adj/adj.h>
42 #include <vnet/fib/fib_table.h>
43 #include <vnet/fib/ip4_fib.h>
44 #include <vnet/fib/ip6_fib.h>
45 #include <vnet/mpls/mpls.h>
46 #include <vnet/mfib/mfib_table.h>
47 #include <vnet/dpo/drop_dpo.h>
48 #include <vnet/dpo/classify_dpo.h>
49 #include <vnet/dpo/punt_dpo.h>
50 #include <vnet/dpo/receive_dpo.h>
51 #include <vnet/dpo/ip_null_dpo.h>
52 #include <vnet/dpo/l3_proxy_dpo.h>
53 #include <vnet/ip/ip6_neighbor.h>
54 
55 /**
56  * @file
57  * @brief IPv4 and IPv6 adjacency and lookup table managment.
58  *
59  */
60 
63  u32 sw_if_index,
64  void *addr_fib,
66  u32 is_del, u32 * result_if_address_index)
67 {
68  vnet_main_t *vnm = vnet_get_main ();
69  ip_interface_address_t *a, *prev, *next;
70  uword *p = mhash_get (&lm->address_to_if_address_index, addr_fib);
71 
73  sw_if_index, ~0);
74  a = p ? pool_elt_at_index (lm->if_address_pool, p[0]) : 0;
75 
76  /* Verify given length. */
77  if ((a && (address_length != a->address_length)) ||
78  (address_length == 0) ||
79  (lm->is_ip6 && address_length > 128) ||
80  (!lm->is_ip6 && address_length > 32))
81  {
82  vnm->api_errno = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH;
83  return clib_error_create
84  ("%U wrong length (expected %d) for interface %U",
85  lm->format_address_and_length, addr_fib,
86  address_length, a ? a->address_length : -1,
87  format_vnet_sw_if_index_name, vnm, sw_if_index);
88  }
89 
90  if (is_del)
91  {
92  if (!a)
93  {
94  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
95  vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
96  return clib_error_create ("%U not found for interface %U",
98  addr_fib, address_length,
100  }
101 
102  if (a->prev_this_sw_interface != ~0)
103  {
104  prev =
108  }
109  if (a->next_this_sw_interface != ~0)
110  {
111  next =
115 
116  if (a->prev_this_sw_interface == ~0)
117  lm->if_address_pool_index_by_sw_if_index[sw_if_index] =
119  }
120 
121  if ((a->next_this_sw_interface == ~0)
122  && (a->prev_this_sw_interface == ~0))
123  lm->if_address_pool_index_by_sw_if_index[sw_if_index] = ~0;
124 
126  /* old_value */ 0);
127  pool_put (lm->if_address_pool, a);
128 
129  if (result_if_address_index)
130  *result_if_address_index = ~0;
131  }
132 
133  else if (!a)
134  {
135  u32 pi; /* previous index */
136  u32 ai;
137  u32 hi; /* head index */
138 
139  pool_get (lm->if_address_pool, a);
140  memset (a, ~0, sizeof (a[0]));
141  ai = a - lm->if_address_pool;
142 
143  hi = pi = lm->if_address_pool_index_by_sw_if_index[sw_if_index];
144  prev = 0;
145  while (pi != (u32) ~ 0)
146  {
147  prev = pool_elt_at_index (lm->if_address_pool, pi);
148  pi = prev->next_this_sw_interface;
149  }
150  pi = prev ? prev - lm->if_address_pool : (u32) ~ 0;
151 
153  addr_fib, ai, /* old_value */ 0);
155  a->sw_if_index = sw_if_index;
156  a->flags = 0;
157  a->prev_this_sw_interface = pi;
158  a->next_this_sw_interface = ~0;
159  if (prev)
160  prev->next_this_sw_interface = ai;
161 
162  lm->if_address_pool_index_by_sw_if_index[sw_if_index] =
163  (hi != ~0) ? hi : ai;
164  if (result_if_address_index)
165  *result_if_address_index = ai;
166  }
167  else
168  {
169  if (sw_if_index != a->sw_if_index)
170  {
171  if (result_if_address_index)
172  *result_if_address_index = ~0;
173  vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
174  return clib_error_create
175  ("Prefix %U already found on interface %U",
176  lm->format_address_and_length, addr_fib, address_length,
178  }
179 
180  if (result_if_address_index)
181  *result_if_address_index = a - lm->if_address_pool;
182  }
183 
184  return /* no error */ 0;
185 }
186 
187 static clib_error_t *
188 ip_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
189 {
191  lookup_main.if_address_pool_index_by_sw_if_index,
192  sw_if_index, ~0);
194  lookup_main.if_address_pool_index_by_sw_if_index,
195  sw_if_index, ~0);
196 
197  return (NULL);
198 }
199 
201 
202 void
204 {
205  if (!lm->fib_result_n_bytes)
206  lm->fib_result_n_bytes = sizeof (uword);
207 
208  lm->is_ip6 = is_ip6;
209  if (is_ip6)
210  {
213  sizeof (ip6_address_fib_t));
214  }
215  else
216  {
219  sizeof (ip4_address_fib_t));
220  }
221 
222  {
223  int i;
224 
225  /* Setup all IP protocols to be punted and builtin-unknown. */
226  for (i = 0; i < 256; i++)
227  {
230  }
231 
233  lm->local_next_by_ip_protocol[is_ip6 ? IP_PROTOCOL_ICMP6 :
234  IP_PROTOCOL_ICMP] = IP_LOCAL_NEXT_ICMP;
235  lm->builtin_protocol_by_ip_protocol[IP_PROTOCOL_UDP] =
237  lm->builtin_protocol_by_ip_protocol[is_ip6 ? IP_PROTOCOL_ICMP6 :
238  IP_PROTOCOL_ICMP] =
240  }
241 }
242 
243 u8 *
244 format_ip_flow_hash_config (u8 * s, va_list * args)
245 {
246  flow_hash_config_t flow_hash_config = va_arg (*args, u32);
247 
248 #define _(n,v) if (flow_hash_config & v) s = format (s, "%s ", #n);
250 #undef _
251 
252  return s;
253 }
254 
255 u8 *
256 format_ip_adjacency_packet_data (u8 * s, va_list * args)
257 {
258  u32 adj_index = va_arg (*args, u32);
259  u8 *packet_data = va_arg (*args, u8 *);
260  u32 n_packet_data_bytes = va_arg (*args, u32);
261  ip_adjacency_t *adj = adj_get (adj_index);
262 
263  switch (adj->lookup_next_index)
264  {
267  s =
268  format (s, "%U", format_hex_bytes, packet_data, n_packet_data_bytes);
269  break;
270 
271  default:
272  break;
273  }
274 
275  return s;
276 }
277 
278 static uword
279 unformat_dpo (unformat_input_t * input, va_list * args)
280 {
281  dpo_id_t *dpo = va_arg (*args, dpo_id_t *);
282  fib_protocol_t fp = va_arg (*args, int);
283  dpo_proto_t proto;
284 
285  proto = fib_proto_to_dpo (fp);
286 
287  if (unformat (input, "drop"))
288  dpo_copy (dpo, drop_dpo_get (proto));
289  else if (unformat (input, "punt"))
290  dpo_copy (dpo, punt_dpo_get (proto));
291  else if (unformat (input, "local"))
292  receive_dpo_add_or_lock (proto, ~0, NULL, dpo);
293  else if (unformat (input, "null-send-unreach"))
295  else if (unformat (input, "null-send-prohibit"))
297  else if (unformat (input, "null"))
299  else if (unformat (input, "classify"))
300  {
301  u32 classify_table_index;
302 
303  if (!unformat (input, "%d", &classify_table_index))
304  {
305  clib_warning ("classify adj must specify table index");
306  return 0;
307  }
308 
309  dpo_set (dpo, DPO_CLASSIFY, proto,
310  classify_dpo_create (proto, classify_table_index));
311  }
312  else
313  return 0;
314 
315  return 1;
316 }
317 
318 const ip46_address_t zero_addr = {
319  .as_u64 = {
320  0, 0},
321 };
322 
323 static clib_error_t *
325  unformat_input_t * main_input, vlib_cli_command_t * cmd)
326 {
327  unformat_input_t _line_input, *line_input = &_line_input;
328  u32 table_id, is_del, fib_index, payload_proto;
329  dpo_id_t dpo = DPO_INVALID, *dpos = NULL;
330  fib_route_path_t *rpaths = NULL, rpath;
331  fib_prefix_t *prefixs = NULL, pfx;
332  clib_error_t *error = NULL;
333  f64 count;
334  int i;
335 
336  is_del = 0;
337  table_id = 0;
338  count = 1;
339  memset (&pfx, 0, sizeof (pfx));
340 
341  /* Get a line of input. */
342  if (!unformat_user (main_input, unformat_line_input, line_input))
343  return 0;
344 
345  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
346  {
347  memset (&rpath, 0, sizeof (rpath));
348 
349  if (unformat (line_input, "table %d", &table_id))
350  ;
351  else if (unformat (line_input, "count %f", &count))
352  ;
353 
354  else if (unformat (line_input, "%U/%d",
355  unformat_ip4_address, &pfx.fp_addr.ip4, &pfx.fp_len))
356  {
357  payload_proto = pfx.fp_proto = FIB_PROTOCOL_IP4;
358  vec_add1 (prefixs, pfx);
359  }
360  else if (unformat (line_input, "%U/%d",
361  unformat_ip6_address, &pfx.fp_addr.ip6, &pfx.fp_len))
362  {
363  payload_proto = pfx.fp_proto = FIB_PROTOCOL_IP6;
364  vec_add1 (prefixs, pfx);
365  }
366  else if (unformat (line_input, "via %U",
367  unformat_fib_route_path, &rpath, &payload_proto))
368  {
369  vec_add1 (rpaths, rpath);
370  }
371  else if (vec_len (prefixs) > 0 &&
372  unformat (line_input, "via %U",
373  unformat_dpo, &dpo, prefixs[0].fp_proto))
374  {
375  vec_add1 (dpos, dpo);
376  }
377  else if (unformat (line_input, "del"))
378  is_del = 1;
379  else if (unformat (line_input, "add"))
380  is_del = 0;
381  else
382  {
383  error = unformat_parse_error (line_input);
384  goto done;
385  }
386  }
387 
388  if (vec_len (prefixs) == 0)
389  {
390  error =
391  clib_error_return (0, "expected ip4/ip6 destination address/length.");
392  goto done;
393  }
394 
395  if (!is_del && vec_len (rpaths) + vec_len (dpos) == 0)
396  {
397  error = clib_error_return (0, "expected paths.");
398  goto done;
399  }
400 
401  if (~0 == table_id)
402  {
403  /*
404  * if no table_id is passed we will manipulate the default
405  */
406  fib_index = 0;
407  }
408  else
409  {
410  fib_index = fib_table_find (prefixs[0].fp_proto, table_id);
411 
412  if (~0 == fib_index)
413  {
414  error = clib_error_return (0, "Nonexistent table id %d", table_id);
415  goto done;
416  }
417  }
418 
419  for (i = 0; i < vec_len (prefixs); i++)
420  {
421  if (is_del && 0 == vec_len (rpaths))
422  {
423  fib_table_entry_delete (fib_index, &prefixs[i], FIB_SOURCE_CLI);
424  }
425  else if (!is_del && 1 == vec_len (dpos))
426  {
428  &prefixs[i],
431  &dpos[0]);
432  dpo_reset (&dpos[0]);
433  }
434  else if (vec_len (dpos) > 0)
435  {
436  error =
438  "Load-balancing over multiple special adjacencies is unsupported");
439  goto done;
440  }
441  else if (0 < vec_len (rpaths))
442  {
443  u32 k, j, n, incr;
444  ip46_address_t dst = prefixs[i].fp_addr;
445  f64 t[2];
446  n = count;
447  t[0] = vlib_time_now (vm);
448  incr = 1 << ((FIB_PROTOCOL_IP4 == prefixs[0].fp_proto ? 32 : 128) -
449  prefixs[i].fp_len);
450 
451  for (k = 0; k < n; k++)
452  {
453  for (j = 0; j < vec_len (rpaths); j++)
454  {
455  fib_prefix_t rpfx = {
456  .fp_len = prefixs[i].fp_len,
457  .fp_proto = prefixs[i].fp_proto,
458  .fp_addr = dst,
459  };
460 
461  if (is_del)
462  fib_table_entry_path_remove2 (fib_index,
463  &rpfx,
464  FIB_SOURCE_CLI, &rpaths[j]);
465  else
466  fib_table_entry_path_add2 (fib_index,
467  &rpfx,
470  &rpaths[j]);
471  }
472 
473  if (FIB_PROTOCOL_IP4 == prefixs[0].fp_proto)
474  {
475  dst.ip4.as_u32 =
476  clib_host_to_net_u32 (incr +
477  clib_net_to_host_u32 (dst.
478  ip4.as_u32));
479  }
480  else
481  {
482  int bucket = (incr < 64 ? 0 : 1);
483  dst.ip6.as_u64[bucket] =
484  clib_host_to_net_u64 (incr +
485  clib_net_to_host_u64 (dst.ip6.as_u64
486  [bucket]));
487 
488  }
489  }
490  t[1] = vlib_time_now (vm);
491  if (count > 1)
492  vlib_cli_output (vm, "%.6e routes/sec", count / (t[1] - t[0]));
493  }
494  else
495  {
496  error = clib_error_return (0, "Don't understand what you want...");
497  goto done;
498  }
499  }
500 
501 
502 done:
503  vec_free (dpos);
504  vec_free (prefixs);
505  vec_free (rpaths);
506  unformat_free (line_input);
507  return error;
508 }
509 
510 clib_error_t *
512  unformat_input_t * main_input,
513  vlib_cli_command_t * cmd, fib_protocol_t fproto)
514 {
515  unformat_input_t _line_input, *line_input = &_line_input;
516  clib_error_t *error = NULL;
517  u32 table_id, is_add;
518  u8 *name = NULL;
519 
520  is_add = 1;
521  table_id = ~0;
522 
523  /* Get a line of input. */
524  if (!unformat_user (main_input, unformat_line_input, line_input))
525  return 0;
526 
527  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
528  {
529  if (unformat (line_input, "%d", &table_id))
530  ;
531  else if (unformat (line_input, "del"))
532  is_add = 0;
533  else if (unformat (line_input, "add"))
534  is_add = 1;
535  else if (unformat (line_input, "name %s", &name))
536  ;
537  else
538  {
539  error = unformat_parse_error (line_input);
540  goto done;
541  }
542  }
543 
544  if (~0 == table_id)
545  {
546  error = clib_error_return (0, "No table id");
547  goto done;
548  }
549  else if (0 == table_id)
550  {
551  error = clib_error_return (0, "Can't change the default table");
552  goto done;
553  }
554  else
555  {
556  if (is_add)
557  {
558  ip_table_create (fproto, table_id, 0, name);
559  }
560  else
561  {
562  ip_table_delete (fproto, table_id, 0);
563  }
564  }
565 
566 done:
567  unformat_free (line_input);
568  return error;
569 }
570 
571 clib_error_t *
573  unformat_input_t * main_input, vlib_cli_command_t * cmd)
574 {
575  return (vnet_ip_table_cmd (vm, main_input, cmd, FIB_PROTOCOL_IP4));
576 }
577 
578 clib_error_t *
580  unformat_input_t * main_input, vlib_cli_command_t * cmd)
581 {
582  return (vnet_ip_table_cmd (vm, main_input, cmd, FIB_PROTOCOL_IP6));
583 }
584 
585 /* *INDENT-OFF* */
586 VLIB_CLI_COMMAND (vlib_cli_ip_command, static) = {
587  .path = "ip",
588  .short_help = "Internet protocol (IP) commands",
589 };
590 /* *INDENT-ON* */
591 
592 /* *INDENT-OFF* */
593 VLIB_CLI_COMMAND (vlib_cli_ip6_command, static) = {
594  .path = "ip6",
595  .short_help = "Internet protocol version 6 (IPv6) commands",
596 };
597 /* *INDENT-ON* */
598 
599 /* *INDENT-OFF* */
600 VLIB_CLI_COMMAND (vlib_cli_show_ip_command, static) = {
601  .path = "show ip",
602  .short_help = "Internet protocol (IP) show commands",
603 };
604 /* *INDENT-ON* */
605 
606 /* *INDENT-OFF* */
607 VLIB_CLI_COMMAND (vlib_cli_show_ip6_command, static) = {
608  .path = "show ip6",
609  .short_help = "Internet protocol version 6 (IPv6) show commands",
610 };
611 /* *INDENT-ON* */
612 
613 /*?
614  * This command is used to add or delete IPv4 or IPv6 routes. All
615  * IP Addresses ('<em><dst-ip-addr>/<width></em>',
616  * '<em><next-hop-ip-addr></em>' and '<em><adj-hop-ip-addr></em>')
617  * can be IPv4 or IPv6, but all must be of the same form in a single
618  * command. To display the current set of routes, use the commands
619  * '<em>show ip fib</em>' and '<em>show ip6 fib</em>'.
620  *
621  * @cliexpar
622  * Example of how to add a straight forward static route:
623  * @cliexcmd{ip route add 6.0.1.2/32 via 6.0.0.1 GigabitEthernet2/0/0}
624  * Example of how to delete a straight forward static route:
625  * @cliexcmd{ip route del 6.0.1.2/32 via 6.0.0.1 GigabitEthernet2/0/0}
626  * Mainly for route add/del performance testing, one can add or delete
627  * multiple routes by adding 'count N' to the previous item:
628  * @cliexcmd{ip route add count 10 7.0.0.0/24 via 6.0.0.1 GigabitEthernet2/0/0}
629  * Add multiple routes for the same destination to create equal-cost multipath:
630  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.1 GigabitEthernet2/0/0}
631  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.2 GigabitEthernet2/0/0}
632  * For unequal-cost multipath, specify the desired weights. This
633  * combination of weights results in 3/4 of the traffic following the
634  * second path, 1/4 following the first path:
635  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.1 GigabitEthernet2/0/0 weight 1}
636  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.2 GigabitEthernet2/0/0 weight 3}
637  * To add a route to a particular FIB table (VRF), use:
638  * @cliexcmd{ip route add 172.16.24.0/24 table 7 via GigabitEthernet2/0/0}
639  ?*/
640 /* *INDENT-OFF* */
641 VLIB_CLI_COMMAND (ip_route_command, static) = {
642  .path = "ip route",
643  .short_help = "ip route [add|del] [count <n>] <dst-ip-addr>/<width> [table <table-id>] via [next-hop-address] [next-hop-interface] [next-hop-table <value>] [weight <value>] [preference <value>] [udp-encap-id <value>] [ip4-lookup-in-table <value>] [ip6-lookup-in-table <value>] [mpls-lookup-in-table <value>] [resolve-via-host] [resolve-via-connected] [rx-ip4 <interface>] [out-labels <value value value>]",
644  .function = vnet_ip_route_cmd,
645  .is_mp_safe = 1,
646 };
647 
648 /* *INDENT-ON* */
649 /*?
650  * This command is used to add or delete IPv4 Tables. All
651  * Tables must be explicitly added before that can be used. Creating a
652  * table will add both unicast and multicast FIBs
653  *
654  ?*/
655 /* *INDENT-OFF* */
656 VLIB_CLI_COMMAND (ip4_table_command, static) = {
657  .path = "ip table",
658  .short_help = "ip table [add|del] <table-id>",
659  .function = vnet_ip4_table_cmd,
660  .is_mp_safe = 1,
661 };
662 /* *INDENT-ON* */
663 
664 /* *INDENT-ON* */
665 /*?
666  * This command is used to add or delete IPv4 Tables. All
667  * Tables must be explicitly added before that can be used. Creating a
668  * table will add both unicast and multicast FIBs
669  *
670  ?*/
671 /* *INDENT-OFF* */
672 VLIB_CLI_COMMAND (ip6_table_command, static) = {
673  .path = "ip6 table",
674  .short_help = "ip6 table [add|del] <table-id>",
675  .function = vnet_ip6_table_cmd,
676  .is_mp_safe = 1,
677 };
678 
679 static clib_error_t *
681  unformat_input_t * input,
682  vlib_cli_command_t * cmd,
683  fib_protocol_t fproto)
684 {
685  vnet_main_t *vnm = vnet_get_main ();
686  clib_error_t *error = 0;
687  u32 sw_if_index, table_id;
688  int rv;
689 
690  sw_if_index = ~0;
691 
692  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
693  {
694  error = clib_error_return (0, "unknown interface `%U'",
695  format_unformat_error, input);
696  goto done;
697  }
698 
699  if (unformat (input, "%d", &table_id))
700  ;
701  else
702  {
703  error = clib_error_return (0, "expected table id `%U'",
704  format_unformat_error, input);
705  goto done;
706  }
707 
708  rv = ip_table_bind (fproto, sw_if_index, table_id, 0);
709 
710  if (VNET_API_ERROR_ADDRESS_FOUND_FOR_INTERFACE == rv)
711  {
712  error = clib_error_return (0, "IP addresses are still present on %U",
714  vnet_get_main(),
715  sw_if_index);
716  }
717  else if (VNET_API_ERROR_NO_SUCH_FIB == rv)
718  {
719  error = clib_error_return (0, "no such table %d", table_id);
720  }
721  else if (0 != rv)
722  {
723  error = clib_error_return (0, "unknown error");
724  }
725 
726  done:
727  return error;
728 }
729 
730 static clib_error_t *
732  unformat_input_t * input,
733  vlib_cli_command_t * cmd)
734 {
735  return (ip_table_bind_cmd (vm , input, cmd, FIB_PROTOCOL_IP4));
736 }
737 
738 static clib_error_t *
740  unformat_input_t * input,
741  vlib_cli_command_t * cmd)
742 {
743  return (ip_table_bind_cmd (vm , input, cmd, FIB_PROTOCOL_IP6));
744 }
745 
746 /*?
747  * Place the indicated interface into the supplied IPv4 FIB table (also known
748  * as a VRF). If the FIB table does not exist, this command creates it. To
749  * display the current IPv4 FIB table, use the command '<em>show ip fib</em>'.
750  * FIB table will only be displayed if a route has been added to the table, or
751  * an IP Address is assigned to an interface in the table (which adds a route
752  * automatically).
753  *
754  * @note IP addresses added after setting the interface IP table are added to
755  * the indicated FIB table. If an IP address is added prior to changing the
756  * table then this is an error. The control plane must remove these addresses
757  * first and then change the table. VPP will not automatically move the
758  * addresses from the old to the new table as it does not know the validity
759  * of such a change.
760  *
761  * @cliexpar
762  * Example of how to add an interface to an IPv4 FIB table (where 2 is the table-id):
763  * @cliexcmd{set interface ip table GigabitEthernet2/0/0 2}
764  ?*/
765 /* *INDENT-OFF* */
766 VLIB_CLI_COMMAND (set_interface_ip_table_command, static) =
767 {
768  .path = "set interface ip table",
769  .function = ip4_table_bind_cmd,
770  .short_help = "set interface ip table <interface> <table-id>",
771 };
772 /* *INDENT-ON* */
773 
774 /*?
775  * Place the indicated interface into the supplied IPv6 FIB table (also known
776  * as a VRF). If the FIB table does not exist, this command creates it. To
777  * display the current IPv6 FIB table, use the command '<em>show ip6 fib</em>'.
778  * FIB table will only be displayed if a route has been added to the table, or
779  * an IP Address is assigned to an interface in the table (which adds a route
780  * automatically).
781  *
782  * @note IP addresses added after setting the interface IP table are added to
783  * the indicated FIB table. If an IP address is added prior to changing the
784  * table then this is an error. The control plane must remove these addresses
785  * first and then change the table. VPP will not automatically move the
786  * addresses from the old to the new table as it does not know the validity
787  * of such a change.
788  *
789  * @cliexpar
790  * Example of how to add an interface to an IPv6 FIB table (where 2 is the table-id):
791  * @cliexcmd{set interface ip6 table GigabitEthernet2/0/0 2}
792  ?*/
793 /* *INDENT-OFF* */
794 VLIB_CLI_COMMAND (set_interface_ip6_table_command, static) =
795 {
796  .path = "set interface ip6 table",
797  .function = ip6_table_bind_cmd,
798  .short_help = "set interface ip6 table <interface> <table-id>"
799 };
800 /* *INDENT-ON* */
801 
802 clib_error_t *
804  unformat_input_t * main_input, vlib_cli_command_t * cmd)
805 {
806  unformat_input_t _line_input, *line_input = &_line_input;
807  clib_error_t *error = NULL;
808  fib_route_path_t rpath;
809  u32 table_id, is_del;
810  vnet_main_t *vnm;
811  mfib_prefix_t pfx;
812  u32 fib_index;
813  mfib_itf_flags_t iflags = 0;
814  mfib_entry_flags_t eflags = 0;
815  u32 gcount, scount, ss, gg, incr;
816  f64 timet[2];
817 
818  gcount = scount = 1;
819  vnm = vnet_get_main ();
820  is_del = 0;
821  table_id = 0;
822  memset (&pfx, 0, sizeof (pfx));
823  memset (&rpath, 0, sizeof (rpath));
824  rpath.frp_sw_if_index = ~0;
825 
826  /* Get a line of input. */
827  if (!unformat_user (main_input, unformat_line_input, line_input))
828  return 0;
829 
830  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
831  {
832  if (unformat (line_input, "table %d", &table_id))
833  ;
834  else if (unformat (line_input, "del"))
835  is_del = 1;
836  else if (unformat (line_input, "add"))
837  is_del = 0;
838  else if (unformat (line_input, "scount %d", &scount))
839  ;
840  else if (unformat (line_input, "gcount %d", &gcount))
841  ;
842  else if (unformat (line_input, "%U %U",
844  &pfx.fp_src_addr.ip4,
846  {
848  pfx.fp_len = 64;
849  }
850  else if (unformat (line_input, "%U %U",
852  &pfx.fp_src_addr.ip6,
854  {
856  pfx.fp_len = 256;
857  }
858  else if (unformat (line_input, "%U/%d",
860  &pfx.fp_grp_addr.ip4, &pfx.fp_len))
861  {
862  memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
864  }
865  else if (unformat (line_input, "%U/%d",
867  &pfx.fp_grp_addr.ip6, &pfx.fp_len))
868  {
869  memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
871  }
872  else if (unformat (line_input, "%U",
874  {
875  memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
877  pfx.fp_len = 32;
878  }
879  else if (unformat (line_input, "%U",
881  {
882  memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
884  pfx.fp_len = 128;
885  }
886  else if (unformat (line_input, "via %U %U",
887  unformat_ip4_address, &rpath.frp_addr.ip4,
889  &rpath.frp_sw_if_index))
890  {
891  rpath.frp_weight = 1;
892  }
893  else if (unformat (line_input, "via %U %U",
894  unformat_ip6_address, &rpath.frp_addr.ip6,
896  &rpath.frp_sw_if_index))
897  {
898  rpath.frp_weight = 1;
899  }
900  else if (unformat (line_input, "via %U",
902  &rpath.frp_sw_if_index))
903  {
904  memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
905  rpath.frp_weight = 1;
906  }
907  else if (unformat (line_input, "via local"))
908  {
909  memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
910  rpath.frp_sw_if_index = ~0;
911  rpath.frp_weight = 1;
913  /*
914  * set the path proto appropriately for the prefix
915  */
916  rpath.frp_proto = fib_proto_to_dpo (pfx.fp_proto);
917  }
918  else if (unformat (line_input, "%U", unformat_mfib_itf_flags, &iflags))
919  ;
920  else if (unformat (line_input, "%U",
921  unformat_mfib_entry_flags, &eflags))
922  ;
923  else
924  {
925  error = unformat_parse_error (line_input);
926  goto done;
927  }
928  }
929 
930  if (~0 == table_id)
931  {
932  /*
933  * if no table_id is passed we will manipulate the default
934  */
935  fib_index = 0;
936  }
937  else
938  {
939  fib_index = mfib_table_find (pfx.fp_proto, table_id);
940 
941  if (~0 == fib_index)
942  {
943  error = clib_error_return (0, "Nonexistent table id %d", table_id);
944  goto done;
945  }
946  }
947 
948  timet[0] = vlib_time_now (vm);
949 
950  if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
951  {
952  incr = 1 << (32 - (pfx.fp_len % 32));
953  }
954  else
955  {
956  incr = 1 << (128 - (pfx.fp_len % 128));
957  }
958 
959  for (ss = 0; ss < scount; ss++)
960  {
961  for (gg = 0; gg < gcount; gg++)
962  {
963  if (is_del && 0 == rpath.frp_weight)
964  {
965  /* no path provided => route delete */
966  mfib_table_entry_delete (fib_index, &pfx, MFIB_SOURCE_CLI);
967  }
968  else if (eflags)
969  {
970  mfib_table_entry_update (fib_index, &pfx, MFIB_SOURCE_CLI,
971  MFIB_RPF_ID_NONE, eflags);
972  }
973  else
974  {
975  if (is_del)
976  mfib_table_entry_path_remove (fib_index,
977  &pfx, MFIB_SOURCE_CLI, &rpath);
978  else
979  mfib_table_entry_path_update (fib_index,
980  &pfx, MFIB_SOURCE_CLI, &rpath,
981  iflags);
982  }
983 
984  if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
985  {
986  pfx.fp_grp_addr.ip4.as_u32 =
987  clib_host_to_net_u32 (incr +
988  clib_net_to_host_u32 (pfx.
989  fp_grp_addr.ip4.
990  as_u32));
991  }
992  else
993  {
994  int bucket = (incr < 64 ? 0 : 1);
995  pfx.fp_grp_addr.ip6.as_u64[bucket] =
996  clib_host_to_net_u64 (incr +
997  clib_net_to_host_u64 (pfx.
998  fp_grp_addr.ip6.as_u64
999  [bucket]));
1000 
1001  }
1002  }
1003  if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
1004  {
1005  pfx.fp_src_addr.ip4.as_u32 =
1006  clib_host_to_net_u32 (1 +
1007  clib_net_to_host_u32 (pfx.fp_src_addr.
1008  ip4.as_u32));
1009  }
1010  else
1011  {
1012  pfx.fp_src_addr.ip6.as_u64[1] =
1013  clib_host_to_net_u64 (1 +
1014  clib_net_to_host_u64 (pfx.fp_src_addr.
1015  ip6.as_u64[1]));
1016  }
1017  }
1018 
1019  timet[1] = vlib_time_now (vm);
1020 
1021  if (scount > 1 || gcount > 1)
1022  vlib_cli_output (vm, "%.6e routes/sec",
1023  (scount * gcount) / (timet[1] - timet[0]));
1024 
1025 done:
1026  unformat_free (line_input);
1027 
1028  return error;
1029 }
1030 
1031 /*?
1032  * This command is used to add or delete IPv4 or IPv6 multicastroutes. All
1033  * IP Addresses ('<em><dst-ip-addr>/<width></em>',
1034  * '<em><next-hop-ip-addr></em>' and '<em><adj-hop-ip-addr></em>')
1035  * can be IPv4 or IPv6, but all must be of the same form in a single
1036  * command. To display the current set of routes, use the commands
1037  * '<em>show ip mfib</em>' and '<em>show ip6 mfib</em>'.
1038  * The full set of support flags for interfaces and route is shown via;
1039  * '<em>show mfib route flags</em>' and '<em>show mfib itf flags</em>'
1040  * respectively.
1041  * @cliexpar
1042  * Example of how to add a forwarding interface to a route (and create the
1043  * route if it does not exist)
1044  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/0 Forward}
1045  * Example of how to add an accepting interface to a route (and create the
1046  * route if it does not exist)
1047  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/1 Accept}
1048  * Example of changing the route's flags to send signals via the API
1049  * @cliexcmd{ip mroute add 232.1.1.1 Signal}
1050 
1051  ?*/
1052 /* *INDENT-OFF* */
1053 VLIB_CLI_COMMAND (ip_mroute_command, static) =
1054 {
1055  .path = "ip mroute",
1056  .short_help = "ip mroute [add|del] <dst-ip-addr>/<width> [table <table-id>] [via <next-hop-ip-addr> [<interface>],",
1057  .function = vnet_ip_mroute_cmd,
1058  .is_mp_safe = 1,
1059 };
1060 /* *INDENT-ON* */
1061 
1062 /*
1063  * The next two routines address a longstanding script hemorrhoid.
1064  * Probing a v4 or v6 neighbor needs to appear to be synchronous,
1065  * or dependent route-adds will simply fail.
1066  */
1067 static clib_error_t *
1069  int retry_count)
1070 {
1071  vnet_main_t *vnm = vnet_get_main ();
1072  clib_error_t *e;
1073  int i;
1074  int resolved = 0;
1075  uword event_type;
1076  uword *event_data = 0;
1077 
1079 
1080  if (retry_count > 0)
1082  (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1083  1 /* event */ , 0 /* data */ );
1084 
1085  for (i = 0; i < retry_count; i++)
1086  {
1087  /* The interface may be down, etc. */
1088  e = ip6_probe_neighbor (vm, a, sw_if_index, 0);
1089 
1090  if (e)
1091  return e;
1092 
1094  event_type = vlib_process_get_events (vm, &event_data);
1095  switch (event_type)
1096  {
1097  case 1: /* resolved... */
1098  vlib_cli_output (vm, "Resolved %U", format_ip6_address, a);
1099  resolved = 1;
1100  goto done;
1101 
1102  case ~0: /* timeout */
1103  break;
1104 
1105  default:
1106  clib_warning ("unknown event_type %d", event_type);
1107  }
1108  vec_reset_length (event_data);
1109  }
1110 
1111 done:
1112 
1113  if (!resolved)
1114  return clib_error_return (0, "Resolution failed for %U",
1115  format_ip6_address, a);
1116  return 0;
1117 }
1118 
1119 static clib_error_t *
1121  int retry_count)
1122 {
1123  vnet_main_t *vnm = vnet_get_main ();
1124  clib_error_t *e;
1125  int i;
1126  int resolved = 0;
1127  uword event_type;
1128  uword *event_data = 0;
1129 
1131 
1132  if (retry_count > 0)
1134  (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1135  1 /* event */ , 0 /* data */ );
1136 
1137  for (i = 0; i < retry_count; i++)
1138  {
1139  /* The interface may be down, etc. */
1140  e = ip4_probe_neighbor (vm, a, sw_if_index, 0);
1141 
1142  if (e)
1143  return e;
1144 
1146  event_type = vlib_process_get_events (vm, &event_data);
1147  switch (event_type)
1148  {
1149  case 1: /* resolved... */
1150  vlib_cli_output (vm, "Resolved %U", format_ip4_address, a);
1151  resolved = 1;
1152  goto done;
1153 
1154  case ~0: /* timeout */
1155  break;
1156 
1157  default:
1158  clib_warning ("unknown event_type %d", event_type);
1159  }
1160  vec_reset_length (event_data);
1161  }
1162 
1163 done:
1164 
1165  vec_reset_length (event_data);
1166 
1167  if (!resolved)
1168  return clib_error_return (0, "Resolution failed for %U",
1169  format_ip4_address, a);
1170  return 0;
1171 }
1172 
1173 static clib_error_t *
1175  unformat_input_t * input, vlib_cli_command_t * cmd)
1176 {
1177  vnet_main_t *vnm = vnet_get_main ();
1178  unformat_input_t _line_input, *line_input = &_line_input;
1179  ip4_address_t a4;
1180  ip6_address_t a6;
1181  clib_error_t *error = 0;
1182  u32 sw_if_index = ~0;
1183  int retry_count = 3;
1184  int is_ip4 = 1;
1185  int address_set = 0;
1186 
1187  /* Get a line of input. */
1188  if (!unformat_user (input, unformat_line_input, line_input))
1189  return 0;
1190 
1191  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1192  {
1193  if (unformat_user (line_input, unformat_vnet_sw_interface, vnm,
1194  &sw_if_index))
1195  ;
1196  else if (unformat (line_input, "retry %d", &retry_count))
1197  ;
1198 
1199  else if (unformat (line_input, "%U", unformat_ip4_address, &a4))
1200  address_set++;
1201  else if (unformat (line_input, "%U", unformat_ip6_address, &a6))
1202  {
1203  address_set++;
1204  is_ip4 = 0;
1205  }
1206  else
1207  {
1208  error = clib_error_return (0, "unknown input '%U'",
1209  format_unformat_error, line_input);
1210  goto done;
1211  }
1212  }
1213 
1214  if (sw_if_index == ~0)
1215  {
1216  error = clib_error_return (0, "Interface required, not set.");
1217  goto done;
1218  }
1219  if (address_set == 0)
1220  {
1221  error = clib_error_return (0, "ip address required, not set.");
1222  goto done;
1223  }
1224  if (address_set > 1)
1225  {
1226  error = clib_error_return (0, "Multiple ip addresses not supported.");
1227  goto done;
1228  }
1229 
1230  if (is_ip4)
1231  error = ip4_probe_neighbor_wait (vm, &a4, sw_if_index, retry_count);
1232  else
1233  error = ip6_probe_neighbor_wait (vm, &a6, sw_if_index, retry_count);
1234 
1235 done:
1236  unformat_free (line_input);
1237 
1238  return error;
1239 }
1240 
1241 /*?
1242  * The '<em>ip probe-neighbor</em>' command ARPs for IPv4 addresses or
1243  * attempts IPv6 neighbor discovery depending on the supplied IP address
1244  * format.
1245  *
1246  * @note This command will not immediately affect the indicated FIB; it
1247  * is not suitable for use in establishing a FIB entry prior to adding
1248  * recursive FIB entries. As in: don't use it in a script to probe a
1249  * gateway prior to adding a default route. It won't work. Instead,
1250  * configure a static ARP cache entry [see '<em>set ip arp</em>'], or
1251  * a static IPv6 neighbor [see '<em>set ip6 neighbor</em>'].
1252  *
1253  * @cliexpar
1254  * Example of probe for an IPv4 address:
1255  * @cliexcmd{ip probe-neighbor GigabitEthernet2/0/0 172.16.1.2}
1256 ?*/
1257 /* *INDENT-OFF* */
1258 VLIB_CLI_COMMAND (ip_probe_neighbor_command, static) = {
1259  .path = "ip probe-neighbor",
1260  .function = probe_neighbor_address,
1261  .short_help = "ip probe-neighbor <interface> <ip4-addr> | <ip6-addr> [retry nn]",
1262  .is_mp_safe = 1,
1263 };
1264 /* *INDENT-ON* */
1265 
1266 clib_error_t *
1268 {
1269  u32 fib_index;
1270 
1271  if (!vnet_sw_interface_is_api_valid (vnet_get_main (), args->sw_if_index))
1272  return clib_error_return_code (0, VNET_API_ERROR_INVALID_INTERFACE, 0,
1273  "invalid sw_if_index");
1274 
1275  fib_index = fib_table_get_table_id_for_sw_if_index (args->prefix.fp_proto,
1276  args->sw_if_index);
1277  if (args->is_add)
1278  {
1279  dpo_id_t proxy_dpo = DPO_INVALID;
1280  l3_proxy_dpo_add_or_lock (fib_proto_to_dpo (args->prefix.fp_proto),
1281  args->sw_if_index, &proxy_dpo);
1283  &args->prefix,
1285  FIB_ENTRY_FLAG_EXCLUSIVE, &proxy_dpo);
1286  dpo_reset (&proxy_dpo);
1287  }
1288  else
1289  {
1290  fib_table_entry_special_remove (fib_index, &args->prefix,
1292  }
1293  return 0;
1294 }
1295 
1296 u8
1298 {
1299  u32 fib_index;
1300  fib_node_index_t fei;
1301  const dpo_id_t *dpo;
1302  l3_proxy_dpo_t *l3p;
1303  load_balance_t *lb0;
1304 
1306  sw_if_index);
1307  if (fib_index == ~0)
1308  return 0;
1309 
1310  fei = fib_table_lookup_exact_match (fib_index, pfx);
1311  if (fei == FIB_NODE_INDEX_INVALID)
1312  return 0;
1313 
1315  lb0 = load_balance_get (dpo->dpoi_index);
1316  dpo = load_balance_get_bucket_i (lb0, 0);
1317  if (dpo->dpoi_type != DPO_L3_PROXY)
1318  return 0;
1319 
1320  l3p = l3_proxy_dpo_get (dpo->dpoi_index);
1321  return (l3p->l3p_sw_if_index == sw_if_index);
1322 }
1323 
1324 clib_error_t *
1326  unformat_input_t * main_input, vlib_cli_command_t * cmd)
1327 {
1328  unformat_input_t _line_input, *line_input = &_line_input;
1329  fib_prefix_t pfx;
1330  u32 is_del, addr_set = 0;
1331  vnet_main_t *vnm;
1332  u32 sw_if_index;
1333 
1334  vnm = vnet_get_main ();
1335  is_del = 0;
1336  sw_if_index = ~0;
1337  memset (&pfx, 0, sizeof (pfx));
1338 
1339  /* Get a line of input. */
1340  if (!unformat_user (main_input, unformat_line_input, line_input))
1341  return 0;
1342 
1343  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1344  {
1345  if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1346  {
1347  pfx.fp_proto = FIB_PROTOCOL_IP4;
1348  pfx.fp_len = 32;
1349  addr_set = 1;
1350  }
1351  else if (unformat (line_input, "%U",
1352  unformat_ip6_address, &pfx.fp_addr.ip6))
1353  {
1354  pfx.fp_proto = FIB_PROTOCOL_IP6;
1355  pfx.fp_len = 128;
1356  addr_set = 1;
1357  }
1358  else if (unformat (line_input, "%U",
1359  unformat_vnet_sw_interface, vnm, &sw_if_index))
1360  ;
1361  else if (unformat (line_input, "del"))
1362  is_del = 1;
1363  else
1364  {
1365  unformat_free (line_input);
1366  return (clib_error_return (0, "unknown input '%U'",
1367  format_unformat_error, line_input));
1368  }
1369  }
1370 
1371  if (~0 == sw_if_index || !addr_set)
1372  {
1373  unformat_free (line_input);
1374  vlib_cli_output (vm, "interface and address must be set");
1375  return 0;
1376  }
1377 
1379  .prefix = pfx,
1380  .sw_if_index = sw_if_index,
1381  .is_add = !is_del,
1382  };
1384  unformat_free (line_input);
1385  return (NULL);
1386 }
1387 
1388 /* *INDENT-OFF* */
1389 VLIB_CLI_COMMAND (ip_container_command_node, static) = {
1390  .path = "ip container",
1391  .function = ip_container_cmd,
1392  .short_help = "ip container <address> <interface>",
1393  .is_mp_safe = 1,
1394 };
1395 /* *INDENT-ON* */
1396 
1397 clib_error_t *
1399  vlib_cli_command_t * cmd)
1400 {
1401  unformat_input_t _line_input, *line_input = &_line_input;
1402  vnet_main_t *vnm = vnet_get_main ();
1403  fib_prefix_t pfx;
1404  u32 sw_if_index = ~0;
1405  u8 has_proxy;
1406 
1407  if (!unformat_user (main_input, unformat_line_input, line_input))
1408  return 0;
1409  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1410  {
1411  if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1412  {
1413  pfx.fp_proto = FIB_PROTOCOL_IP4;
1414  pfx.fp_len = 32;
1415  }
1416  else if (unformat (line_input, "%U",
1417  unformat_ip6_address, &pfx.fp_addr.ip6))
1418  {
1419  pfx.fp_proto = FIB_PROTOCOL_IP6;
1420  pfx.fp_len = 128;
1421  }
1422  else if (unformat (line_input, "%U",
1423  unformat_vnet_sw_interface, vnm, &sw_if_index))
1424  ;
1425  else
1426  {
1427  unformat_free (line_input);
1428  return (clib_error_return (0, "unknown input '%U'",
1429  format_unformat_error, line_input));
1430  }
1431  }
1432 
1433  if (~0 == sw_if_index)
1434  {
1435  unformat_free (line_input);
1436  vlib_cli_output (vm, "no interface");
1437  return (clib_error_return (0, "no interface"));
1438  }
1439 
1440  has_proxy = ip_container_proxy_is_set (&pfx, sw_if_index);
1441  vlib_cli_output (vm, "ip container proxy is: %s", has_proxy ? "on" : "off");
1442 
1443  unformat_free (line_input);
1444  return 0;
1445 }
1446 
1447 /* *INDENT-OFF* */
1448 VLIB_CLI_COMMAND (show_ip_container_command, static) = {
1449  .path = "show ip container",
1450  .function = show_ip_container_cmd_fn,
1451  .short_help = "show ip container <address> <interface>",
1452  .is_mp_safe = 1,
1453 };
1454 /* *INDENT-ON* */
1455 
1456 /*
1457  * fd.io coding-style-patch-verification: ON
1458  *
1459  * Local Variables:
1460  * eval: (c-set-style "gnu")
1461  * End:
1462  */
static clib_error_t * ip6_probe_neighbor_wait(vlib_main_t *vm, ip6_address_t *a, u32 sw_if_index, int retry_count)
Definition: lookup.c:1068
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:202
void mfib_table_entry_delete(u32 fib_index, const mfib_prefix_t *prefix, mfib_source_t source)
Delete a FIB entry.
Definition: mfib_table.c:356
clib_error_t * vnet_ip4_table_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
Definition: lookup.c:572
vmrglw vmrglh hi
void ip_null_dpo_add_and_lock(dpo_proto_t proto, ip_null_dpo_action_t action, dpo_id_t *dpo)
Definition: ip_null_dpo.c:78
ip46_address_t frp_addr
The next-hop address.
Definition: fib_types.h:476
void ip_table_create(fib_protocol_t fproto, u32 table_id, u8 is_api, const u8 *name)
Definition: ip_api.c:1144
ip46_address_t fp_src_addr
Definition: mfib_types.h:47
void receive_dpo_add_or_lock(dpo_proto_t proto, u32 sw_if_index, const ip46_address_t *nh_addr, dpo_id_t *dpo)
Definition: receive_dpo.c:56
fib_node_index_t fib_table_lookup_exact_match(u32 fib_index, const fib_prefix_t *prefix)
Perfom an exact match in the non-forwarding table.
Definition: fib_table.c:95
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
Definition: node_funcs.h:699
enum mfib_entry_flags_t_ mfib_entry_flags_t
a
Definition: bitmap.h:538
static uword unformat_dpo(unformat_input_t *input, va_list *args)
Definition: lookup.c:279
A representation of a path as described by a route producer.
Definition: fib_types.h:460
uword unformat_mfib_itf_flags(unformat_input_t *input, va_list *args)
Definition: mfib_types.c:122
ip_interface_address_t * if_address_pool
Pool of addresses that are assigned to interfaces.
Definition: lookup.h:122
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
static clib_error_t * ip4_probe_neighbor_wait(vlib_main_t *vm, ip4_address_t *a, u32 sw_if_index, int retry_count)
Definition: lookup.c:1120
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:400
Multicast Adjacency.
Definition: adj.h:82
#define NULL
Definition: clib.h:55
uword mhash_unset(mhash_t *h, void *key, uword *old_value)
Definition: mhash.c:353
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:228
fib_node_index_t fib_table_entry_path_add2(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, fib_route_path_t *rpath)
Add n paths to an entry (aka route) in the FIB.
Definition: fib_table.c:556
IP unicast adjacency.
Definition: adj.h:175
const dpo_id_t * fib_entry_contribute_ip_forwarding(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:478
This packet is to be rewritten and forwarded to the next processing node.
Definition: adj.h:73
From the CLI.
Definition: fib_entry.h:78
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:261
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:523
int i
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
fib_node_index_t mfib_table_entry_update(u32 fib_index, const mfib_prefix_t *prefix, mfib_source_t source, fib_rpf_id_t rpf_id, mfib_entry_flags_t entry_flags)
Add a new (with no replication) or lock an existing entry.
Definition: mfib_table.c:165
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:465
unformat_function_t unformat_vnet_sw_interface
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:228
The data-path object representing L3 proxy.
Definition: l3_proxy_dpo.h:27
static clib_error_t * vnet_ip_route_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
Definition: lookup.c:324
mhash_t address_to_if_address_index
Hash table mapping address to index in interface address pool.
Definition: lookup.h:125
format_function_t format_vnet_sw_if_index_name
unsigned char u8
Definition: types.h:56
static clib_error_t * ip_table_bind_cmd(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd, fib_protocol_t fproto)
Definition: lookup.c:680
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
double f64
Definition: types.h:142
int ip_table_bind(fib_protocol_t fproto, u32 sw_if_index, u32 table_id, u8 is_api)
const dpo_id_t * drop_dpo_get(dpo_proto_t proto)
Definition: drop_dpo.c:25
format_function_t format_ip4_address
Definition: format.h:81
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:370
static clib_error_t * ip6_table_bind_cmd(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lookup.c:739
unformat_function_t unformat_ip4_address
Definition: format.h:76
u32 frp_sw_if_index
The interface.
Definition: fib_types.h:495
#define MFIB_RPF_ID_NONE
Definition: fib_types.h:383
format_function_t format_ip6_address_and_length
Definition: format.h:100
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Definition: node_funcs.h:542
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
clib_error_t * vnet_ip_container_proxy_add_del(vnet_ip_container_proxy_args_t *args)
Definition: lookup.c:1267
struct _vnet_ip_container_proxy_args vnet_ip_container_proxy_args_t
Aggregrate type for a prefix.
Definition: fib_types.h:193
u8 * format_hex_bytes(u8 *s, va_list *va)
Definition: std-formats.c:84
const dpo_id_t * punt_dpo_get(dpo_proto_t proto)
Definition: punt_dpo.c:25
#define clib_error_return(e, args...)
Definition: error.h:99
fib_node_index_t mfib_table_entry_path_update(u32 fib_index, const mfib_prefix_t *prefix, mfib_source_t source, const fib_route_path_t *rpath, mfib_itf_flags_t itf_flags)
Add n paths to an entry (aka route) in the FIB.
Definition: mfib_table.c:219
unsigned int u32
Definition: types.h:88
#define clib_error_create(args...)
Definition: error.h:96
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:1056
u16 fp_len
The mask length.
Definition: fib_types.h:197
clib_error_t * ip6_probe_neighbor(vlib_main_t *vm, ip6_address_t *dst, u32 sw_if_index, u8 refresh)
Definition: ip6_forward.c:1438
Definition: fib_entry.h:275
unformat_function_t unformat_line_input
Definition: format.h:282
u32 l3p_sw_if_index
The Software interface index on which traffic is l3_proxyd.
Definition: l3_proxy_dpo.h:38
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
format_function_t format_vnet_sw_interface_name
Definition: fib_entry.h:279
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
void vnet_register_ip6_neighbor_resolution_event(vnet_main_t *vnm, void *address_arg, uword node_index, uword type_opaque, uword data)
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:216
index_t classify_dpo_create(dpo_proto_t proto, u32 classify_table_index)
Definition: classify_dpo.c:43
u8 address_length
Definition: ip_types.api:42
dpo_type_t dpoi_type
the type
Definition: dpo.h:172
static const dpo_id_t * load_balance_get_bucket_i(const load_balance_t *lb, u32 bucket)
Definition: load_balance.h:209
struct _unformat_input_t unformat_input_t
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:274
The FIB DPO provieds;.
Definition: load_balance.h:84
void fib_table_entry_path_remove2(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_route_path_t *rpath)
Remove n paths to an entry (aka route) in the FIB.
Definition: fib_table.c:600
u8 local_next_by_ip_protocol[256]
Table mapping ip protocol to ip[46]-local node next index.
Definition: lookup.h:150
clib_error_t * ip_container_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
Definition: lookup.c:1325
static uword mhash_set(mhash_t *h, void *key, uword new_value, uword *old_value)
Definition: mhash.h:117
clib_error_t * ip4_probe_neighbor(vlib_main_t *vm, ip4_address_t *dst, u32 sw_if_index, u8 refresh)
Definition: ip4_forward.c:1921
clib_error_t * vnet_ip_table_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd, fib_protocol_t fproto)
Definition: lookup.c:511
clib_error_t * vnet_ip_mroute_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
Definition: lookup.c:803
unformat_function_t unformat_ip6_address
Definition: format.h:97
uword unformat_mfib_entry_flags(unformat_input_t *input, va_list *args)
Definition: mfib_types.c:142
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
void mhash_init(mhash_t *h, uword n_value_bytes, uword n_key_bytes)
Definition: mhash.c:168
format_function_t format_ip6_address
Definition: format.h:99
static vlib_process_t * vlib_get_current_process(vlib_main_t *vm)
Definition: node_funcs.h:417
vlib_main_t * vm
Definition: buffer.c:294
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:339
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 ip_table_delete(fib_protocol_t fproto, u32 table_id, u8 is_api)
Definition: ip_api.c:706
#define clib_warning(format, args...)
Definition: error.h:59
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
void ip_lookup_init(ip_lookup_main_t *lm, u32 is_ip6)
Definition: lookup.c:203
void vnet_register_ip4_arp_resolution_event(vnet_main_t *vnm, void *address_arg, uword node_index, uword type_opaque, uword data)
Definition: arp.c:767
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
Aggregrate type for a prefix.
Definition: mfib_types.h:24
u8 builtin_protocol_by_ip_protocol[256]
IP_BUILTIN_PROTOCOL_{TCP,UDP,ICMP,OTHER} by protocol in IP header.
Definition: lookup.h:153
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
#define foreach_flow_hash_bit
Definition: lookup.h:71
u32 * if_address_pool_index_by_sw_if_index
Head of doubly linked list of interface addresses for each software interface.
Definition: lookup.h:129
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
u32 fib_table_get_table_id_for_sw_if_index(fib_protocol_t proto, u32 sw_if_index)
Get the Table-ID of the FIB bound to the interface.
Definition: fib_table.c:1032
#define ASSERT(truth)
static uword * mhash_get(mhash_t *h, const void *key)
Definition: mhash.h:110
ip6_main_t ip6_main
Definition: ip6_forward.c:2574
static load_balance_t * load_balance_get(index_t lbi)
Definition: load_balance.h:200
fib_route_path_flags_t frp_flags
flags on the path
Definition: fib_types.h:552
size_t count
Definition: vapi.c:46
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:237
u32 flow_hash_config_t
A flow hash configuration is a mask of the flow hash options.
Definition: lookup.h:82
static l3_proxy_dpo_t * l3_proxy_dpo_get(index_t index)
Definition: l3_proxy_dpo.h:58
#define unformat_parse_error(input)
Definition: format.h:268
static clib_error_t * ip4_table_bind_cmd(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lookup.c:731
fib_protocol_t fp_proto
protocol type
Definition: mfib_types.h:33
static uword vnet_sw_interface_is_api_valid(vnet_main_t *vnm, u32 sw_if_index)
clib_error_t * vnet_ip6_table_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
Definition: lookup.c:579
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:184
static clib_error_t * ip_sw_interface_add_del(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
Definition: lookup.c:188
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
A for-us/local path.
Definition: fib_types.h:322
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
Definition: adj.h:190
u32 mfib_table_find(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
Definition: mfib_table.c:409
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:162
A route the is being &#39;proxied&#39; on behalf of another device.
Definition: fib_entry.h:48
u32 is_ip6
1 for ip6; 0 for ip4.
Definition: lookup.h:144
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:195
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:62
enum mfib_itf_flags_t_ mfib_itf_flags_t
clib_error_t * show_ip_container_cmd_fn(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
Definition: lookup.c:1398
static uword vlib_in_process_context(vlib_main_t *vm)
Definition: node_funcs.h:411
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:832
#define clib_error_return_code(e, code, flags, args...)
Definition: error.h:93
u8 ip_container_proxy_is_set(fib_prefix_t *pfx, u32 sw_if_index)
Definition: lookup.c:1297
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:231
u8 * format_ip_flow_hash_config(u8 *s, va_list *args)
Definition: lookup.c:244
static clib_error_t * probe_neighbor_address(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lookup.c:1174
u8 * format_ip_adjacency_packet_data(u8 *s, va_list *args)
Definition: lookup.c:256
u16 fp_len
The mask length.
Definition: mfib_types.h:28
#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
void mfib_table_entry_path_remove(u32 fib_index, const mfib_prefix_t *prefix, mfib_source_t source, const fib_route_path_t *rpath)
Remove n paths to an entry (aka route) in the FIB.
Definition: mfib_table.c:251
u8 frp_weight
[un]equal cost path weight
Definition: fib_types.h:542
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:681
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(ip_sw_interface_add_del)
void l3_proxy_dpo_add_or_lock(dpo_proto_t proto, u32 sw_if_index, dpo_id_t *dpo)
Definition: l3_proxy_dpo.c:56
const ip46_address_t zero_addr
Definition: lookup.c:318
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
u32 fib_result_n_bytes
Number of bytes in a fib result.
Definition: lookup.h:141
ip46_address_t fp_grp_addr
The address type is not deriveable from the fp_addr member.
Definition: mfib_types.h:46
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
format_function_t * format_address_and_length
Either format_ip4_address_and_length or format_ip6_address_and_length.
Definition: lookup.h:147
format_function_t format_ip4_address_and_length
Definition: format.h:82