FD.io VPP  v19.08.3-2-gbabecb413
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 management
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 #include <vnet/ethernet/arp.h>
55 
56 /**
57  * @file
58  * @brief IPv4 and IPv6 adjacency and lookup table management.
59  *
60  */
61 
65  void *addr_fib,
66  u32 address_length,
67  u32 is_del, u32 * result_if_address_index)
68 {
69  vnet_main_t *vnm = vnet_get_main ();
70  ip_interface_address_t *a, *prev, *next;
71  uword *p = mhash_get (&lm->address_to_if_address_index, addr_fib);
72 
74  sw_if_index, ~0);
75  a = p ? pool_elt_at_index (lm->if_address_pool, p[0]) : 0;
76 
77  /* Verify given length. */
78  if ((a && (address_length != a->address_length)) ||
79  (address_length == 0) ||
80  (lm->is_ip6 && address_length > 128) ||
81  (!lm->is_ip6 && address_length > 32))
82  {
83  vnm->api_errno = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH;
84  return clib_error_create
85  ("%U wrong length (expected %d) for interface %U",
86  lm->format_address_and_length, addr_fib,
87  address_length, a ? a->address_length : -1,
88  format_vnet_sw_if_index_name, vnm, sw_if_index);
89  }
90 
91  if (is_del)
92  {
93  if (!a)
94  {
95  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
96  vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
97  return clib_error_create ("%U not found for interface %U",
99  addr_fib, address_length,
101  }
102 
103  if (a->prev_this_sw_interface != ~0)
104  {
105  prev =
109  }
110  if (a->next_this_sw_interface != ~0)
111  {
112  next =
116 
117  if (a->prev_this_sw_interface == ~0)
120  }
121 
122  if ((a->next_this_sw_interface == ~0)
123  && (a->prev_this_sw_interface == ~0))
125 
127  /* old_value */ 0);
128  pool_put (lm->if_address_pool, a);
129 
130  if (result_if_address_index)
131  *result_if_address_index = ~0;
132  }
133 
134  else if (!a)
135  {
136  u32 pi; /* previous index */
137  u32 ai;
138  u32 hi; /* head index */
139 
140  pool_get (lm->if_address_pool, a);
141  clib_memset (a, ~0, sizeof (a[0]));
142  ai = a - lm->if_address_pool;
143 
145  prev = 0;
146  while (pi != (u32) ~ 0)
147  {
148  prev = pool_elt_at_index (lm->if_address_pool, pi);
149  pi = prev->next_this_sw_interface;
150  }
151  pi = prev ? prev - lm->if_address_pool : (u32) ~ 0;
152 
154  addr_fib, ai, /* old_value */ 0);
155  a->address_length = address_length;
157  a->flags = 0;
158  a->prev_this_sw_interface = pi;
159  a->next_this_sw_interface = ~0;
160  if (prev)
161  prev->next_this_sw_interface = ai;
162 
164  (hi != ~0) ? hi : ai;
165  if (result_if_address_index)
166  *result_if_address_index = ai;
167  }
168  else
169  {
170  if (sw_if_index != a->sw_if_index)
171  {
172  if (result_if_address_index)
173  *result_if_address_index = ~0;
174  vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
175  return clib_error_create
176  ("Prefix %U already found on interface %U",
177  lm->format_address_and_length, addr_fib, address_length,
179  }
180 
181  if (result_if_address_index)
182  *result_if_address_index = a - lm->if_address_pool;
183  }
184 
185  return /* no error */ 0;
186 }
187 
188 static clib_error_t *
190 {
192  lookup_main.if_address_pool_index_by_sw_if_index,
193  sw_if_index, ~0);
195  lookup_main.if_address_pool_index_by_sw_if_index,
196  sw_if_index, ~0);
197 
198  return (NULL);
199 }
200 
202 
203 void
205 {
206  if (!lm->fib_result_n_bytes)
207  lm->fib_result_n_bytes = sizeof (uword);
208 
209  lm->is_ip6 = is_ip6;
211  sizeof (ip_interface_prefix_key_t));
212  if (is_ip6)
213  {
216  sizeof (ip6_address_fib_t));
217  }
218  else
219  {
222  sizeof (ip4_address_fib_t));
223  }
224 
225  {
226  int i;
227 
228  /* Setup all IP protocols to be punted and builtin-unknown. */
229  for (i = 0; i < 256; i++)
230  {
233  }
234 
236  lm->local_next_by_ip_protocol[is_ip6 ? IP_PROTOCOL_ICMP6 :
237  IP_PROTOCOL_ICMP] = IP_LOCAL_NEXT_ICMP;
238  lm->builtin_protocol_by_ip_protocol[IP_PROTOCOL_UDP] =
240  lm->builtin_protocol_by_ip_protocol[is_ip6 ? IP_PROTOCOL_ICMP6 :
241  IP_PROTOCOL_ICMP] =
243  }
244 }
245 
246 u8 *
247 format_ip_flow_hash_config (u8 * s, va_list * args)
248 {
249  flow_hash_config_t flow_hash_config = va_arg (*args, u32);
250 
251 #define _(n,v) if (flow_hash_config & v) s = format (s, "%s ", #n);
253 #undef _
254 
255  return s;
256 }
257 
258 u8 *
259 format_ip_adjacency_packet_data (u8 * s, va_list * args)
260 {
261  u32 adj_index = va_arg (*args, u32);
262  u8 *packet_data = va_arg (*args, u8 *);
263  u32 n_packet_data_bytes = va_arg (*args, u32);
264  ip_adjacency_t *adj;
265 
266  if (!adj_is_valid (adj_index))
267  return format (s, "<invalid adjacency>");
268 
269  adj = adj_get (adj_index);
270 
271  switch (adj->lookup_next_index)
272  {
275  s =
276  format (s, "%U", format_hex_bytes, packet_data, n_packet_data_bytes);
277  break;
278 
279  default:
280  break;
281  }
282 
283  return s;
284 }
285 
286 static uword
287 unformat_dpo (unformat_input_t * input, va_list * args)
288 {
289  dpo_id_t *dpo = va_arg (*args, dpo_id_t *);
290  fib_protocol_t fp = va_arg (*args, int);
292 
293  proto = fib_proto_to_dpo (fp);
294 
295  if (unformat (input, "drop"))
296  dpo_copy (dpo, drop_dpo_get (proto));
297  else if (unformat (input, "punt"))
298  dpo_copy (dpo, punt_dpo_get (proto));
299  else if (unformat (input, "local"))
300  receive_dpo_add_or_lock (proto, ~0, NULL, dpo);
301  else if (unformat (input, "null-send-unreach"))
303  else if (unformat (input, "null-send-prohibit"))
305  else if (unformat (input, "null"))
307  else if (unformat (input, "classify"))
308  {
310 
311  if (!unformat (input, "%d", &classify_table_index))
312  {
313  clib_warning ("classify adj must specify table index");
314  return 0;
315  }
316 
317  dpo_set (dpo, DPO_CLASSIFY, proto,
318  classify_dpo_create (proto, classify_table_index));
319  }
320  else
321  return 0;
322 
323  return 1;
324 }
325 
326 const ip46_address_t zero_addr = {
327  .as_u64 = {
328  0, 0},
329 };
330 
331 static clib_error_t *
333  unformat_input_t * main_input, vlib_cli_command_t * cmd)
334 {
335  unformat_input_t _line_input, *line_input = &_line_input;
336  u32 table_id, is_del, fib_index, payload_proto;
337  dpo_id_t dpo = DPO_INVALID, *dpos = NULL;
338  fib_route_path_t *rpaths = NULL, rpath;
339  fib_prefix_t *prefixs = NULL, pfx;
340  clib_error_t *error = NULL;
341  f64 count;
342  int i;
343 
344  is_del = 0;
345  table_id = 0;
346  count = 1;
347  clib_memset (&pfx, 0, sizeof (pfx));
348 
349  /* Get a line of input. */
350  if (!unformat_user (main_input, unformat_line_input, line_input))
351  return 0;
352 
353  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
354  {
355  clib_memset (&rpath, 0, sizeof (rpath));
356 
357  if (unformat (line_input, "table %d", &table_id))
358  ;
359  else if (unformat (line_input, "count %f", &count))
360  ;
361 
362  else if (unformat (line_input, "%U/%d",
363  unformat_ip4_address, &pfx.fp_addr.ip4, &pfx.fp_len))
364  {
365  payload_proto = pfx.fp_proto = FIB_PROTOCOL_IP4;
366  vec_add1 (prefixs, pfx);
367  }
368  else if (unformat (line_input, "%U/%d",
369  unformat_ip6_address, &pfx.fp_addr.ip6, &pfx.fp_len))
370  {
371  payload_proto = pfx.fp_proto = FIB_PROTOCOL_IP6;
372  vec_add1 (prefixs, pfx);
373  }
374  else if (unformat (line_input, "via %U",
375  unformat_fib_route_path, &rpath, &payload_proto))
376  {
377  vec_add1 (rpaths, rpath);
378  }
379  else if (vec_len (prefixs) > 0 &&
380  unformat (line_input, "via %U",
381  unformat_dpo, &dpo, prefixs[0].fp_proto))
382  {
383  vec_add1 (dpos, dpo);
384  }
385  else if (unformat (line_input, "del"))
386  is_del = 1;
387  else if (unformat (line_input, "add"))
388  is_del = 0;
389  else
390  {
391  error = unformat_parse_error (line_input);
392  goto done;
393  }
394  }
395 
396  if (vec_len (prefixs) == 0)
397  {
398  error =
399  clib_error_return (0, "expected ip4/ip6 destination address/length.");
400  goto done;
401  }
402 
403  if (!is_del && vec_len (rpaths) + vec_len (dpos) == 0)
404  {
405  error = clib_error_return (0, "expected paths.");
406  goto done;
407  }
408 
409  if (~0 == table_id)
410  {
411  /*
412  * if no table_id is passed we will manipulate the default
413  */
414  fib_index = 0;
415  }
416  else
417  {
418  fib_index = fib_table_find (prefixs[0].fp_proto, table_id);
419 
420  if (~0 == fib_index)
421  {
422  error = clib_error_return (0, "Nonexistent table id %d", table_id);
423  goto done;
424  }
425  }
426 
427  for (i = 0; i < vec_len (prefixs); i++)
428  {
429  if (is_del && 0 == vec_len (rpaths))
430  {
431  fib_table_entry_delete (fib_index, &prefixs[i], FIB_SOURCE_CLI);
432  }
433  else if (!is_del && 1 == vec_len (dpos))
434  {
436  &prefixs[i],
439  &dpos[0]);
440  dpo_reset (&dpos[0]);
441  }
442  else if (vec_len (dpos) > 0)
443  {
444  error =
446  "Load-balancing over multiple special adjacencies is unsupported");
447  goto done;
448  }
449  else if (0 < vec_len (rpaths))
450  {
451  u32 k, n, incr;
452  ip46_address_t dst = prefixs[i].fp_addr;
453  f64 t[2];
454  n = count;
455  t[0] = vlib_time_now (vm);
456  incr = 1 << ((FIB_PROTOCOL_IP4 == prefixs[0].fp_proto ? 32 : 128) -
457  prefixs[i].fp_len);
458 
459  for (k = 0; k < n; k++)
460  {
461  fib_prefix_t rpfx = {
462  .fp_len = prefixs[i].fp_len,
463  .fp_proto = prefixs[i].fp_proto,
464  .fp_addr = dst,
465  };
466 
467  if (is_del)
468  fib_table_entry_path_remove2 (fib_index,
469  &rpfx, FIB_SOURCE_CLI, rpaths);
470  else
471  fib_table_entry_path_add2 (fib_index,
472  &rpfx,
474  FIB_ENTRY_FLAG_NONE, rpaths);
475 
476  if (FIB_PROTOCOL_IP4 == prefixs[0].fp_proto)
477  {
478  dst.ip4.as_u32 =
479  clib_host_to_net_u32 (incr +
480  clib_net_to_host_u32 (dst.
481  ip4.as_u32));
482  }
483  else
484  {
485  int bucket = (incr < 64 ? 0 : 1);
486  dst.ip6.as_u64[bucket] =
487  clib_host_to_net_u64 (incr +
488  clib_net_to_host_u64 (dst.ip6.as_u64
489  [bucket]));
490  }
491  }
492 
493  t[1] = vlib_time_now (vm);
494  if (count > 1)
495  vlib_cli_output (vm, "%.6e routes/sec", count / (t[1] - t[0]));
496  }
497  else
498  {
499  error = clib_error_return (0, "Don't understand what you want...");
500  goto done;
501  }
502  }
503 
504 done:
505  vec_free (dpos);
506  vec_free (prefixs);
507  vec_free (rpaths);
508  unformat_free (line_input);
509  return error;
510 }
511 
512 clib_error_t *
514  unformat_input_t * main_input,
515  vlib_cli_command_t * cmd, fib_protocol_t fproto)
516 {
517  unformat_input_t _line_input, *line_input = &_line_input;
518  clib_error_t *error = NULL;
519  u32 table_id, is_add;
520  u8 *name = NULL;
521 
522  is_add = 1;
523  table_id = ~0;
524 
525  /* Get a line of input. */
526  if (!unformat_user (main_input, unformat_line_input, line_input))
527  return 0;
528 
529  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
530  {
531  if (unformat (line_input, "%d", &table_id))
532  ;
533  else if (unformat (line_input, "del"))
534  is_add = 0;
535  else if (unformat (line_input, "add"))
536  is_add = 1;
537  else if (unformat (line_input, "name %s", &name))
538  ;
539  else
540  {
541  error = unformat_parse_error (line_input);
542  goto done;
543  }
544  }
545 
546  if (~0 == table_id)
547  {
548  error = clib_error_return (0, "No table id");
549  goto done;
550  }
551  else if (0 == table_id)
552  {
553  error = clib_error_return (0, "Can't change the default table");
554  goto done;
555  }
556  else
557  {
558  if (is_add)
559  {
560  ip_table_create (fproto, table_id, 0, name);
561  }
562  else
563  {
564  ip_table_delete (fproto, table_id, 0);
565  }
566  }
567 
568 done:
569  unformat_free (line_input);
570  return error;
571 }
572 
573 clib_error_t *
575  unformat_input_t * main_input, vlib_cli_command_t * cmd)
576 {
577  return (vnet_ip_table_cmd (vm, main_input, cmd, FIB_PROTOCOL_IP4));
578 }
579 
580 clib_error_t *
582  unformat_input_t * main_input, vlib_cli_command_t * cmd)
583 {
584  return (vnet_ip_table_cmd (vm, main_input, cmd, FIB_PROTOCOL_IP6));
585 }
586 
587 /* *INDENT-OFF* */
588 VLIB_CLI_COMMAND (vlib_cli_ip_command, static) = {
589  .path = "ip",
590  .short_help = "Internet protocol (IP) commands",
591 };
592 /* *INDENT-ON* */
593 
594 /* *INDENT-OFF* */
595 VLIB_CLI_COMMAND (vlib_cli_ip6_command, static) = {
596  .path = "ip6",
597  .short_help = "Internet protocol version 6 (IPv6) commands",
598 };
599 /* *INDENT-ON* */
600 
601 /* *INDENT-OFF* */
602 VLIB_CLI_COMMAND (vlib_cli_show_ip_command, static) = {
603  .path = "show ip",
604  .short_help = "Internet protocol (IP) show commands",
605 };
606 /* *INDENT-ON* */
607 
608 /* *INDENT-OFF* */
609 VLIB_CLI_COMMAND (vlib_cli_show_ip6_command, static) = {
610  .path = "show ip6",
611  .short_help = "Internet protocol version 6 (IPv6) show commands",
612 };
613 /* *INDENT-ON* */
614 
615 /*?
616  * This command is used to add or delete IPv4 or IPv6 routes. All
617  * IP Addresses ('<em><dst-ip-addr>/<width></em>',
618  * '<em><next-hop-ip-addr></em>' and '<em><adj-hop-ip-addr></em>')
619  * can be IPv4 or IPv6, but all must be of the same form in a single
620  * command. To display the current set of routes, use the commands
621  * '<em>show ip fib</em>' and '<em>show ip6 fib</em>'.
622  *
623  * @cliexpar
624  * Example of how to add a straight forward static route:
625  * @cliexcmd{ip route add 6.0.1.2/32 via 6.0.0.1 GigabitEthernet2/0/0}
626  * Example of how to delete a straight forward static route:
627  * @cliexcmd{ip route del 6.0.1.2/32 via 6.0.0.1 GigabitEthernet2/0/0}
628  * Mainly for route add/del performance testing, one can add or delete
629  * multiple routes by adding 'count N' to the previous item:
630  * @cliexcmd{ip route add count 10 7.0.0.0/24 via 6.0.0.1 GigabitEthernet2/0/0}
631  * Add multiple routes for the same destination to create equal-cost multipath:
632  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.1 GigabitEthernet2/0/0}
633  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.2 GigabitEthernet2/0/0}
634  * For unequal-cost multipath, specify the desired weights. This
635  * combination of weights results in 3/4 of the traffic following the
636  * second path, 1/4 following the first path:
637  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.1 GigabitEthernet2/0/0 weight 1}
638  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.2 GigabitEthernet2/0/0 weight 3}
639  * To add a route to a particular FIB table (VRF), use:
640  * @cliexcmd{ip route add 172.16.24.0/24 table 7 via GigabitEthernet2/0/0}
641  ?*/
642 /* *INDENT-OFF* */
643 VLIB_CLI_COMMAND (ip_route_command, static) = {
644  .path = "ip route",
645  .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>]",
646  .function = vnet_ip_route_cmd,
647  .is_mp_safe = 1,
648 };
649 
650 /* *INDENT-ON* */
651 /*?
652  * This command is used to add or delete IPv4 Tables. All
653  * Tables must be explicitly added before that can be used. Creating a
654  * table will add both unicast and multicast FIBs
655  *
656  ?*/
657 /* *INDENT-OFF* */
658 VLIB_CLI_COMMAND (ip4_table_command, static) = {
659  .path = "ip table",
660  .short_help = "ip table [add|del] <table-id>",
661  .function = vnet_ip4_table_cmd,
662 };
663 /* *INDENT-ON* */
664 
665 /* *INDENT-ON* */
666 /*?
667  * This command is used to add or delete IPv4 Tables. All
668  * Tables must be explicitly added before that can be used. Creating a
669  * table will add both unicast and multicast FIBs
670  *
671  ?*/
672 /* *INDENT-OFF* */
673 VLIB_CLI_COMMAND (ip6_table_command, static) = {
674  .path = "ip6 table",
675  .short_help = "ip6 table [add|del] <table-id>",
676  .function = vnet_ip6_table_cmd,
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;
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). The FIB table must be created using "ip table add" already. 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). The FIB table must be created using "ip6 table add" already. 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  fib_route_path_t rpath, *rpaths = NULL;
808  clib_error_t *error = NULL;
809  u32 table_id, is_del, payload_proto;
810  mfib_prefix_t pfx;
811  u32 fib_index;
812  mfib_entry_flags_t eflags = 0;
813  u32 gcount, scount, ss, gg, incr;
814  f64 timet[2];
816 
817  gcount = scount = 1;
818  is_del = 0;
819  table_id = 0;
820  clib_memset (&pfx, 0, sizeof (pfx));
821  clib_memset (&rpath, 0, sizeof (rpath));
822  rpath.frp_sw_if_index = ~0;
823 
824  /* Get a line of input. */
825  if (!unformat_user (main_input, unformat_line_input, line_input))
826  return 0;
827 
828  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
829  {
830  if (unformat (line_input, "table %d", &table_id))
831  ;
832  else if (unformat (line_input, "del"))
833  is_del = 1;
834  else if (unformat (line_input, "add"))
835  is_del = 0;
836  else if (unformat (line_input, "rpf-id %d", &rpf_id))
837  ;
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  clib_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  clib_memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
871  }
872  else if (unformat (line_input, "%U",
874  {
875  clib_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  clib_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 local Forward"))
887  {
888  clib_memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
889  rpath.frp_sw_if_index = ~0;
890  rpath.frp_weight = 1;
892  /*
893  * set the path proto appropriately for the prefix
894  */
895  rpath.frp_proto = fib_proto_to_dpo (pfx.fp_proto);
897 
898  vec_add1 (rpaths, rpath);
899  }
900  else if (unformat (line_input, "via %U",
901  unformat_fib_route_path, &rpath, &payload_proto))
902  {
903  vec_add1 (rpaths, rpath);
904  }
905  else if (unformat (line_input, "%U",
906  unformat_mfib_entry_flags, &eflags))
907  ;
908  else
909  {
910  error = unformat_parse_error (line_input);
911  goto done;
912  }
913  }
914 
915  if (~0 == table_id)
916  {
917  /*
918  * if no table_id is passed we will manipulate the default
919  */
920  fib_index = 0;
921  }
922  else
923  {
924  fib_index = mfib_table_find (pfx.fp_proto, table_id);
925 
926  if (~0 == fib_index)
927  {
928  error = clib_error_return (0, "Nonexistent table id %d", table_id);
929  goto done;
930  }
931  }
932 
933  timet[0] = vlib_time_now (vm);
934 
935  if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
936  {
937  incr = 1 << (32 - (pfx.fp_len % 32));
938  }
939  else
940  {
941  incr = 1 << (128 - (pfx.fp_len % 128));
942  }
943 
944  for (ss = 0; ss < scount; ss++)
945  {
946  for (gg = 0; gg < gcount; gg++)
947  {
948  if (is_del && 0 == vec_len (rpaths))
949  {
950  /* no path provided => route delete */
951  mfib_table_entry_delete (fib_index, &pfx, MFIB_SOURCE_CLI);
952  }
953  else if (eflags || (MFIB_RPF_ID_NONE != rpf_id))
954  {
955  mfib_table_entry_update (fib_index, &pfx, MFIB_SOURCE_CLI,
956  rpf_id, eflags);
957  }
958  else
959  {
960  if (is_del)
961  mfib_table_entry_path_remove (fib_index,
962  &pfx, MFIB_SOURCE_CLI, rpaths);
963  else
964  mfib_table_entry_path_update (fib_index,
965  &pfx, MFIB_SOURCE_CLI, rpaths);
966  }
967 
968  if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
969  {
970  pfx.fp_grp_addr.ip4.as_u32 =
971  clib_host_to_net_u32 (incr +
972  clib_net_to_host_u32 (pfx.
973  fp_grp_addr.ip4.
974  as_u32));
975  }
976  else
977  {
978  int bucket = (incr < 64 ? 0 : 1);
979  pfx.fp_grp_addr.ip6.as_u64[bucket] =
980  clib_host_to_net_u64 (incr +
981  clib_net_to_host_u64 (pfx.
982  fp_grp_addr.ip6.as_u64
983  [bucket]));
984 
985  }
986  }
987  if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
988  {
989  pfx.fp_src_addr.ip4.as_u32 =
990  clib_host_to_net_u32 (1 +
991  clib_net_to_host_u32 (pfx.fp_src_addr.
992  ip4.as_u32));
993  }
994  else
995  {
996  pfx.fp_src_addr.ip6.as_u64[1] =
997  clib_host_to_net_u64 (1 +
998  clib_net_to_host_u64 (pfx.fp_src_addr.
999  ip6.as_u64[1]));
1000  }
1001  }
1002 
1003  timet[1] = vlib_time_now (vm);
1004 
1005  if (scount > 1 || gcount > 1)
1006  vlib_cli_output (vm, "%.6e routes/sec",
1007  (scount * gcount) / (timet[1] - timet[0]));
1008 
1009 done:
1010  vec_free (rpaths);
1011  unformat_free (line_input);
1012 
1013  return error;
1014 }
1015 
1016 /*?
1017  * This command is used to add or delete IPv4 or IPv6 multicast routes. All
1018  * IP Addresses ('<em><dst-ip-addr>/<width></em>',
1019  * '<em><next-hop-ip-addr></em>' and '<em><adj-hop-ip-addr></em>')
1020  * can be IPv4 or IPv6, but all must be of the same form in a single
1021  * command. To display the current set of routes, use the commands
1022  * '<em>show ip mfib</em>' and '<em>show ip6 mfib</em>'.
1023  * The full set of support flags for interfaces and route is shown via;
1024  * '<em>show mfib route flags</em>' and '<em>show mfib itf flags</em>'
1025  * respectively.
1026  * @cliexpar
1027  * Example of how to add a forwarding interface to a route (and create the
1028  * route if it does not exist)
1029  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/0 Forward}
1030  * Example of how to add an accepting interface to a route (and create the
1031  * route if it does not exist)
1032  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/1 Accept}
1033  * Example of changing the route's flags to send signals via the API
1034  * @cliexcmd{ip mroute add 232.1.1.1 Signal}
1035 
1036  ?*/
1037 /* *INDENT-OFF* */
1038 VLIB_CLI_COMMAND (ip_mroute_command, static) =
1039 {
1040  .path = "ip mroute",
1041  .short_help = "ip mroute [add|del] <dst-ip-addr>/<width> [table <table-id>] [rpf-id <ID>] [via <next-hop-ip-addr> [<interface>],",
1042  .function = vnet_ip_mroute_cmd,
1043  .is_mp_safe = 1,
1044 };
1045 /* *INDENT-ON* */
1046 
1047 /*
1048  * The next two routines address a longstanding script hemorrhoid.
1049  * Probing a v4 or v6 neighbor needs to appear to be synchronous,
1050  * or dependent route-adds will simply fail.
1051  */
1052 static clib_error_t *
1054  int retry_count)
1055 {
1056  vnet_main_t *vnm = vnet_get_main ();
1057  clib_error_t *e;
1058  int i;
1059  int resolved = 0;
1060  uword event_type;
1061  uword *event_data = 0;
1062 
1064 
1065  if (retry_count > 0)
1067  (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1068  1 /* event */ , 0 /* data */ );
1069 
1070  for (i = 0; i < retry_count; i++)
1071  {
1072  /* The interface may be down, etc. */
1073  e = ip6_probe_neighbor (vm, a, sw_if_index, 0);
1074 
1075  if (e)
1076  return e;
1077 
1079  event_type = vlib_process_get_events (vm, &event_data);
1080  switch (event_type)
1081  {
1082  case 1: /* resolved... */
1083  vlib_cli_output (vm, "Resolved %U", format_ip6_address, a);
1084  resolved = 1;
1085  goto done;
1086 
1087  case ~0: /* timeout */
1088  break;
1089 
1090  default:
1091  clib_warning ("unknown event_type %d", event_type);
1092  }
1093  vec_reset_length (event_data);
1094  }
1095 
1096 done:
1097 
1098  if (!resolved)
1099  return clib_error_return (0, "Resolution failed for %U",
1100  format_ip6_address, a);
1101  return 0;
1102 }
1103 
1104 static clib_error_t *
1106  int retry_count)
1107 {
1108  vnet_main_t *vnm = vnet_get_main ();
1109  clib_error_t *e;
1110  int i;
1111  int resolved = 0;
1112  uword event_type;
1113  uword *event_data = 0;
1114 
1116 
1117  if (retry_count > 0)
1119  (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1120  1 /* event */ , 0 /* data */ );
1121 
1122  for (i = 0; i < retry_count; i++)
1123  {
1124  /* The interface may be down, etc. */
1125  e = ip4_probe_neighbor (vm, a, sw_if_index, 0);
1126 
1127  if (e)
1128  return e;
1129 
1131  event_type = vlib_process_get_events (vm, &event_data);
1132  switch (event_type)
1133  {
1134  case 1: /* resolved... */
1135  vlib_cli_output (vm, "Resolved %U", format_ip4_address, a);
1136  resolved = 1;
1137  goto done;
1138 
1139  case ~0: /* timeout */
1140  break;
1141 
1142  default:
1143  clib_warning ("unknown event_type %d", event_type);
1144  }
1145  vec_reset_length (event_data);
1146  }
1147 
1148 done:
1149 
1150  vec_reset_length (event_data);
1151 
1152  if (!resolved)
1153  return clib_error_return (0, "Resolution failed for %U",
1154  format_ip4_address, a);
1155  return 0;
1156 }
1157 
1158 static clib_error_t *
1160  unformat_input_t * input, vlib_cli_command_t * cmd)
1161 {
1162  vnet_main_t *vnm = vnet_get_main ();
1163  unformat_input_t _line_input, *line_input = &_line_input;
1164  ip4_address_t a4;
1165  ip6_address_t a6;
1166  clib_error_t *error = 0;
1167  u32 sw_if_index = ~0;
1168  int retry_count = 3;
1169  int is_ip4 = 1;
1170  int address_set = 0;
1171 
1172  /* Get a line of input. */
1173  if (!unformat_user (input, unformat_line_input, line_input))
1174  return 0;
1175 
1176  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1177  {
1178  if (unformat_user (line_input, unformat_vnet_sw_interface, vnm,
1179  &sw_if_index))
1180  ;
1181  else if (unformat (line_input, "retry %d", &retry_count))
1182  ;
1183 
1184  else if (unformat (line_input, "%U", unformat_ip4_address, &a4))
1185  address_set++;
1186  else if (unformat (line_input, "%U", unformat_ip6_address, &a6))
1187  {
1188  address_set++;
1189  is_ip4 = 0;
1190  }
1191  else
1192  {
1193  error = clib_error_return (0, "unknown input '%U'",
1194  format_unformat_error, line_input);
1195  goto done;
1196  }
1197  }
1198 
1199  if (sw_if_index == ~0)
1200  {
1201  error = clib_error_return (0, "Interface required, not set.");
1202  goto done;
1203  }
1204  if (address_set == 0)
1205  {
1206  error = clib_error_return (0, "ip address required, not set.");
1207  goto done;
1208  }
1209  if (address_set > 1)
1210  {
1211  error = clib_error_return (0, "Multiple ip addresses not supported.");
1212  goto done;
1213  }
1214 
1215  if (is_ip4)
1216  error = ip4_probe_neighbor_wait (vm, &a4, sw_if_index, retry_count);
1217  else
1218  error = ip6_probe_neighbor_wait (vm, &a6, sw_if_index, retry_count);
1219 
1220 done:
1221  unformat_free (line_input);
1222 
1223  return error;
1224 }
1225 
1226 /*?
1227  * The '<em>ip probe-neighbor</em>' command ARPs for IPv4 addresses or
1228  * attempts IPv6 neighbor discovery depending on the supplied IP address
1229  * format.
1230  *
1231  * @note This command will not immediately affect the indicated FIB; it
1232  * is not suitable for use in establishing a FIB entry prior to adding
1233  * recursive FIB entries. As in: don't use it in a script to probe a
1234  * gateway prior to adding a default route. It won't work. Instead,
1235  * configure a static ARP cache entry [see '<em>set ip arp</em>'], or
1236  * a static IPv6 neighbor [see '<em>set ip6 neighbor</em>'].
1237  *
1238  * @cliexpar
1239  * Example of probe for an IPv4 address:
1240  * @cliexcmd{ip probe-neighbor GigabitEthernet2/0/0 172.16.1.2}
1241 ?*/
1242 /* *INDENT-OFF* */
1243 VLIB_CLI_COMMAND (ip_probe_neighbor_command, static) = {
1244  .path = "ip probe-neighbor",
1245  .function = probe_neighbor_address,
1246  .short_help = "ip probe-neighbor <interface> <ip4-addr> | <ip6-addr> [retry nn]",
1247  .is_mp_safe = 1,
1248 };
1249 /* *INDENT-ON* */
1250 
1251 clib_error_t *
1253 {
1254  u32 fib_index;
1255 
1256  if (!vnet_sw_interface_is_api_valid (vnet_get_main (), args->sw_if_index))
1257  return clib_error_return_code (0, VNET_API_ERROR_INVALID_INTERFACE, 0,
1258  "invalid sw_if_index");
1259 
1260  fib_index = fib_table_get_table_id_for_sw_if_index (args->prefix.fp_proto,
1261  args->sw_if_index);
1262  if (args->is_add)
1263  {
1264  dpo_id_t proxy_dpo = DPO_INVALID;
1265  l3_proxy_dpo_add_or_lock (fib_proto_to_dpo (args->prefix.fp_proto),
1266  args->sw_if_index, &proxy_dpo);
1268  &args->prefix,
1270  FIB_ENTRY_FLAG_EXCLUSIVE, &proxy_dpo);
1271  dpo_reset (&proxy_dpo);
1272  }
1273  else
1274  {
1275  fib_table_entry_special_remove (fib_index, &args->prefix,
1277  }
1278  return 0;
1279 }
1280 
1281 u8
1283 {
1284  u32 fib_index;
1285  fib_node_index_t fei;
1286  const dpo_id_t *dpo;
1287  l3_proxy_dpo_t *l3p;
1288  load_balance_t *lb0;
1289 
1291  sw_if_index);
1292  if (fib_index == ~0)
1293  return 0;
1294 
1295  fei = fib_table_lookup_exact_match (fib_index, pfx);
1296  if (fei == FIB_NODE_INDEX_INVALID)
1297  return 0;
1298 
1300  lb0 = load_balance_get (dpo->dpoi_index);
1301  dpo = load_balance_get_bucket_i (lb0, 0);
1302  if (dpo->dpoi_type != DPO_L3_PROXY)
1303  return 0;
1304 
1305  l3p = l3_proxy_dpo_get (dpo->dpoi_index);
1306  return (l3p->l3p_sw_if_index == sw_if_index);
1307 }
1308 
1309 typedef struct ip_container_proxy_walk_ctx_t_
1310 {
1312  void *ctx;
1314 
1315 static fib_table_walk_rc_t
1317 {
1319  const fib_prefix_t *pfx;
1320  const dpo_id_t *dpo;
1321  load_balance_t *lb;
1322  l3_proxy_dpo_t *l3p;
1323 
1324  pfx = fib_entry_get_prefix (fei);
1326  {
1328  lb = load_balance_get (dpo->dpoi_index);
1329  dpo = load_balance_get_bucket_i (lb, 0);
1330  l3p = l3_proxy_dpo_get (dpo->dpoi_index);
1331  ctx->cb (pfx, l3p->l3p_sw_if_index, ctx->ctx);
1332  }
1333 
1334  return FIB_TABLE_WALK_CONTINUE;
1335 }
1336 
1337 void
1339 {
1340  fib_table_t *fib_table;
1342  .cb = cb,
1343  .ctx = ctx,
1344  };
1345 
1346  /* *INDENT-OFF* */
1347  pool_foreach (fib_table, ip4_main.fibs,
1348  ({
1349  fib_table_walk(fib_table->ft_index,
1350  FIB_PROTOCOL_IP4,
1351  ip_container_proxy_fib_table_walk,
1352  &wctx);
1353  }));
1354  pool_foreach (fib_table, ip6_main.fibs,
1355  ({
1356  fib_table_walk(fib_table->ft_index,
1357  FIB_PROTOCOL_IP6,
1358  ip_container_proxy_fib_table_walk,
1359  &wctx);
1360  }));
1361  /* *INDENT-ON* */
1362 }
1363 
1364 clib_error_t *
1366  unformat_input_t * main_input, vlib_cli_command_t * cmd)
1367 {
1368  unformat_input_t _line_input, *line_input = &_line_input;
1369  fib_prefix_t pfx;
1370  u32 is_del, addr_set = 0;
1371  vnet_main_t *vnm;
1372  u32 sw_if_index;
1373 
1374  vnm = vnet_get_main ();
1375  is_del = 0;
1376  sw_if_index = ~0;
1377  clib_memset (&pfx, 0, sizeof (pfx));
1378 
1379  /* Get a line of input. */
1380  if (!unformat_user (main_input, unformat_line_input, line_input))
1381  return 0;
1382 
1383  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1384  {
1385  if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1386  {
1387  pfx.fp_proto = FIB_PROTOCOL_IP4;
1388  pfx.fp_len = 32;
1389  addr_set = 1;
1390  }
1391  else if (unformat (line_input, "%U",
1392  unformat_ip6_address, &pfx.fp_addr.ip6))
1393  {
1394  pfx.fp_proto = FIB_PROTOCOL_IP6;
1395  pfx.fp_len = 128;
1396  addr_set = 1;
1397  }
1398  else if (unformat (line_input, "%U",
1399  unformat_vnet_sw_interface, vnm, &sw_if_index))
1400  ;
1401  else if (unformat (line_input, "del"))
1402  is_del = 1;
1403  else
1404  {
1405  unformat_free (line_input);
1406  return (clib_error_return (0, "unknown input '%U'",
1407  format_unformat_error, line_input));
1408  }
1409  }
1410 
1411  if (~0 == sw_if_index || !addr_set)
1412  {
1413  unformat_free (line_input);
1414  vlib_cli_output (vm, "interface and address must be set");
1415  return 0;
1416  }
1417 
1419  .prefix = pfx,
1420  .sw_if_index = sw_if_index,
1421  .is_add = !is_del,
1422  };
1424  unformat_free (line_input);
1425  return (NULL);
1426 }
1427 
1428 /* *INDENT-OFF* */
1429 VLIB_CLI_COMMAND (ip_container_command_node, static) = {
1430  .path = "ip container",
1431  .function = ip_container_cmd,
1432  .short_help = "ip container <address> <interface>",
1433  .is_mp_safe = 1,
1434 };
1435 /* *INDENT-ON* */
1436 
1437 clib_error_t *
1439  vlib_cli_command_t * cmd)
1440 {
1441  unformat_input_t _line_input, *line_input = &_line_input;
1442  vnet_main_t *vnm = vnet_get_main ();
1443  fib_prefix_t pfx;
1444  u32 sw_if_index = ~0;
1445  u8 has_proxy;
1446 
1447  if (!unformat_user (main_input, unformat_line_input, line_input))
1448  return 0;
1449  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1450  {
1451  if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1452  {
1453  pfx.fp_proto = FIB_PROTOCOL_IP4;
1454  pfx.fp_len = 32;
1455  }
1456  else if (unformat (line_input, "%U",
1457  unformat_ip6_address, &pfx.fp_addr.ip6))
1458  {
1459  pfx.fp_proto = FIB_PROTOCOL_IP6;
1460  pfx.fp_len = 128;
1461  }
1462  else if (unformat (line_input, "%U",
1463  unformat_vnet_sw_interface, vnm, &sw_if_index))
1464  ;
1465  else
1466  {
1467  unformat_free (line_input);
1468  return (clib_error_return (0, "unknown input '%U'",
1469  format_unformat_error, line_input));
1470  }
1471  }
1472 
1473  if (~0 == sw_if_index)
1474  {
1475  unformat_free (line_input);
1476  vlib_cli_output (vm, "no interface");
1477  return (clib_error_return (0, "no interface"));
1478  }
1479 
1480  has_proxy = ip_container_proxy_is_set (&pfx, sw_if_index);
1481  vlib_cli_output (vm, "ip container proxy is: %s", has_proxy ? "on" : "off");
1482 
1483  unformat_free (line_input);
1484  return 0;
1485 }
1486 
1487 /* *INDENT-OFF* */
1488 VLIB_CLI_COMMAND (show_ip_container_command, static) = {
1489  .path = "show ip container",
1490  .function = show_ip_container_cmd_fn,
1491  .short_help = "show ip container <address> <interface>",
1492  .is_mp_safe = 1,
1493 };
1494 /* *INDENT-ON* */
1495 
1496 /*
1497  * fd.io coding-style-patch-verification: ON
1498  *
1499  * Local Variables:
1500  * eval: (c-set-style "gnu")
1501  * End:
1502  */
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:1053
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:212
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:491
clib_error_t * vnet_ip4_table_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
Definition: lookup.c:574
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:501
Continue on to the next entry.
Definition: fib_table.h:868
void ip_table_create(fib_protocol_t fproto, u32 table_id, u8 is_api, const u8 *name)
Definition: ip_api.c:719
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:67
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:673
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:287
A representation of a path as described by a route producer.
Definition: fib_types.h:485
ip_interface_address_t * if_address_pool
Pool of addresses that are assigned to interfaces.
Definition: lookup.h:143
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
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:1105
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)
Add n paths to an entry (aka route) in the FIB.
Definition: mfib_table.c:323
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:444
u32 frp_mitf_flags
MFIB interface flags.
Definition: fib_types.h:554
Multicast Adjacency.
Definition: adj.h:82
uword mhash_unset(mhash_t *h, void *key, uword *old_value)
Definition: mhash.c:346
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:279
ip_container_proxy_cb_t cb
Definition: lookup.c:1311
IP unicast adjacency.
Definition: adj.h:221
const dpo_id_t * fib_entry_contribute_ip_forwarding(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:517
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 *rpaths)
Add n paths to an entry (aka route) in the FIB.
Definition: fib_table.c:574
This packet is to be rewritten and forwarded to the next processing node.
Definition: adj.h:73
From the CLI.
Definition: fib_entry.h:83
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:262
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
int i
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
const fib_prefix_t * fib_entry_get_prefix(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1699
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:235
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:490
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:236
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:332
mhash_t address_to_if_address_index
Hash table mapping address to index in interface address pool.
Definition: lookup.h:146
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:75
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:433
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
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:493
unformat_function_t unformat_ip4_address
Definition: format.h:70
u32 frp_sw_if_index
The interface.
Definition: fib_types.h:525
vl_api_interface_index_t sw_if_index
Definition: gre.api:50
#define MFIB_RPF_ID_NONE
Definition: fib_types.h:408
format_function_t format_ip6_address_and_length
Definition: format.h:94
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:516
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:1252
struct _vnet_ip_container_proxy_args vnet_ip_container_proxy_args_t
Aggregate type for a prefix.
Definition: fib_types.h:203
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
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:1080
u16 fp_len
The mask length.
Definition: fib_types.h:207
clib_error_t * ip6_probe_neighbor(vlib_main_t *vm, ip6_address_t *dst, u32 sw_if_index, u8 refresh)
Definition: ip6_forward.c:1603
Definition: fib_entry.h:281
unformat_function_t unformat_line_input
Definition: format.h:283
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
u32 rpf_id
Definition: fib_types.api:119
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:170
int(* ip_container_proxy_cb_t)(const fib_prefix_t *pfx, u32 sw_if_index, void *ctx)
Definition: lookup.h:272
format_function_t format_vnet_sw_interface_name
Definition: fib_entry.h:285
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
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:226
index_t classify_dpo_create(dpo_proto_t proto, u32 classify_table_index)
Definition: classify_dpo.c:48
dpo_type_t dpoi_type
the type
Definition: dpo.h:174
static const dpo_id_t * load_balance_get_bucket_i(const load_balance_t *lb, u32 bucket)
Definition: load_balance.h:229
struct _unformat_input_t unformat_input_t
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
The FIB DPO provieds;.
Definition: load_balance.h:106
u8 local_next_by_ip_protocol[256]
Table mapping ip protocol to ip[46]-local node next index.
Definition: lookup.h:177
clib_error_t * ip_container_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
Definition: lookup.c:1365
static uword mhash_set(mhash_t *h, void *key, uword new_value, uword *old_value)
Definition: mhash.h:117
vl_api_address_t dst
Definition: gre.api:52
u8 name[64]
Definition: memclnt.api:152
clib_error_t * ip4_probe_neighbor(vlib_main_t *vm, ip4_address_t *dst, u32 sw_if_index, u8 refresh)
Definition: ip4_forward.c:2169
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:513
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:91
u32 classify_table_index
Definition: fib_types.api:68
int fib_entry_is_sourced(fib_node_index_t fib_entry_index, fib_source_t source)
uword unformat_mfib_entry_flags(unformat_input_t *input, va_list *args)
Definition: mfib_types.c:218
void fib_table_entry_path_remove2(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_route_path_t *rpaths)
Remove n paths to an entry (aka route) in the FIB.
Definition: fib_table.c:623
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
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:93
static vlib_process_t * vlib_get_current_process(vlib_main_t *vm)
Definition: node_funcs.h:391
vlib_main_t * vm
Definition: buffer.c:323
enum fib_table_walk_rc_t_ fib_table_walk_rc_t
return code controlling how a table walk proceeds
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
struct ip_container_proxy_walk_ctx_t_ ip_container_proxy_walk_ctx_t
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:869
void ip_table_delete(fib_protocol_t fproto, u32 table_id, u8 is_api)
Definition: ip_api.c:597
#define clib_warning(format, args...)
Definition: error.h:59
static fib_table_walk_rc_t ip_container_proxy_fib_table_walk(fib_node_index_t fei, void *arg)
Definition: lookup.c:1316
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:204
void ip_container_proxy_walk(ip_container_proxy_cb_t cb, void *ctx)
Definition: lookup.c:1338
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:857
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:186
Aggregate 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:180
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:161
#define foreach_flow_hash_bit
Definition: lookup.h:72
u32 * if_address_pool_index_by_sw_if_index
Head of doubly linked list of interface addresses for each software interface.
Definition: lookup.h:150
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:1056
#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:2805
static load_balance_t * load_balance_get(index_t lbi)
Definition: load_balance.h:220
fib_route_path_flags_t frp_flags
flags on the path
Definition: fib_types.h:595
size_t count
Definition: vapi.c:47
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:247
u32 flow_hash_config_t
A flow hash configuration is a mask of the flow hash options.
Definition: lookup.h:84
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:269
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:581
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:186
static clib_error_t * ip_sw_interface_add_del(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
Definition: lookup.c:189
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
A for-us/local path.
Definition: fib_types.h:338
#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:236
mhash_t prefix_to_if_prefix_index
Hash table mapping prefix to index in interface prefix pool.
Definition: lookup.h:156
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:553
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:163
A route the is being &#39;proxied&#39; on behalf of another device.
Definition: fib_entry.h:53
u32 is_ip6
1 for ip6; 0 for ip4.
Definition: lookup.h:171
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:197
clib_error_t * ip_interface_address_add_del(ip_lookup_main_t *lm, u32 sw_if_index, void *addr_fib, u32 address_length, u32 is_del, u32 *result_if_address_index)
Definition: lookup.c:63
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:1438
static int adj_is_valid(adj_index_t adj_index)
Definition: adj.h:439
static uword vlib_in_process_context(vlib_main_t *vm)
Definition: node_funcs.h:385
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:1076
#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:1282
struct fib_table_t_ * fibs
Vector of FIBs.
Definition: ip4.h:110
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:232
u8 * format_ip_flow_hash_config(u8 *s, va_list *args)
Definition: lookup.c:247
static clib_error_t * probe_neighbor_address(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lookup.c:1159
u8 * format_ip_adjacency_packet_data(u8 *s, va_list *args)
Definition: lookup.c:259
u16 fp_len
The mask length.
Definition: mfib_types.h:28
u32 table_id
Definition: fib_types.api:118
#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:405
u8 frp_weight
[un]equal cost path weight
Definition: fib_types.h:585
struct fib_table_t_ * fibs
Definition: ip6.h:182
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:772
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:326
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
u32 fib_result_n_bytes
Number of bytes in a fib result.
Definition: lookup.h:168
vl_api_fib_path_nh_proto_t proto
Definition: fib_types.api:125
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:171
A protocol Independent FIB table.
Definition: fib_table.h:69
format_function_t * format_address_and_length
Either format_ip4_address_and_length or format_ip6_address_and_length.
Definition: lookup.h:174
format_function_t format_ip4_address_and_length
Definition: format.h:76