FD.io VPP  v21.01.1
Vector Packet Processing
lisp_cli.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <lisp/lisp-cp/control.h>
17 #include <lisp/lisp-gpe/lisp_gpe.h>
18 
19 static clib_error_t *
21  unformat_input_t * input,
22  vlib_cli_command_t * cmd)
23 {
24  lisp_adjacency_t *adjs, *adj;
25  vlib_cli_output (vm, "%s %40s\n", "leid", "reid");
26  unformat_input_t _line_input, *line_input = &_line_input;
27  u32 vni = ~0;
28  clib_error_t *error = NULL;
29 
30  /* Get a line of input. */
31  if (!unformat_user (input, unformat_line_input, line_input))
32  return 0;
33 
34  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
35  {
36  if (unformat (line_input, "vni %d", &vni))
37  ;
38  else
39  {
40  vlib_cli_output (vm, "parse error: '%U'",
41  format_unformat_error, line_input);
42  goto done;
43  }
44  }
45 
46  if (~0 == vni)
47  {
48  vlib_cli_output (vm, "error: no vni specified!");
49  goto done;
50  }
51 
53 
54  vec_foreach (adj, adjs)
55  {
56  vlib_cli_output (vm, "%U %40U\n", format_gid_address, &adj->leid,
57  format_gid_address, &adj->reid);
58  }
59  vec_free (adjs);
60 
61 done:
62  unformat_free (line_input);
63 
64  return error;
65 }
66 
67 /* *INDENT-OFF* */
68 VLIB_CLI_COMMAND (lisp_show_adjacencies_command) = {
69  .path = "show lisp adjacencies",
70  .short_help = "show lisp adjacencies",
72 };
73 /* *INDENT-ON* */
74 
75 static clib_error_t *
77  unformat_input_t * input,
78  vlib_cli_command_t * cmd)
79 {
80  int rv = 0;
81  u8 is_add = 1, ip_set = 0;
83  unformat_input_t _line_input, *line_input = &_line_input;
84  clib_error_t *error = NULL;
85 
86  /* Get a line of input. */
87  if (!unformat_user (input, unformat_line_input, line_input))
88  return 0;
89 
90  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
91  {
92  if (unformat (line_input, "add"))
93  is_add = 1;
94  else if (unformat (line_input, "del"))
95  is_add = 0;
96  else if (unformat (line_input, "%U", unformat_ip_address, &ip))
97  ip_set = 1;
98  else
99  {
100  vlib_cli_output (vm, "parse error: '%U'",
101  format_unformat_error, line_input);
102  goto done;
103  }
104  }
105 
106  if (!ip_set)
107  {
108  vlib_cli_output (vm, "map-server ip address not set!");
109  goto done;
110  }
111 
112  rv = vnet_lisp_add_del_map_server (&ip, is_add);
113  if (!rv)
114  vlib_cli_output (vm, "failed to %s map-server!",
115  is_add ? "add" : "delete");
116 
117 done:
118  unformat_free (line_input);
119 
120  return error;
121 }
122 
123 /* *INDENT-OFF* */
124 VLIB_CLI_COMMAND (lisp_add_del_map_server_command) = {
125  .path = "lisp map-server",
126  .short_help = "lisp map-server add|del <ip>",
128 };
129 /* *INDENT-ON* */
130 
131 
132 static clib_error_t *
134  vlib_cli_command_t * cmd)
135 {
137  unformat_input_t _line_input, *line_input = &_line_input;
138  u8 is_add = 1;
140  gid_address_t *eids = 0;
141  clib_error_t *error = 0;
142  u8 *locator_set_name = 0;
143  u32 locator_set_index = 0, map_index = 0;
144  uword *p;
146  int rv = 0;
147  u32 vni = 0;
148  u8 *key = 0;
149  u32 key_id = 0;
150 
151  clib_memset (&eid, 0, sizeof (eid));
152  clib_memset (a, 0, sizeof (*a));
153 
154  /* Get a line of input. */
155  if (!unformat_user (input, unformat_line_input, line_input))
156  return 0;
157 
158  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
159  {
160  if (unformat (line_input, "add"))
161  is_add = 1;
162  else if (unformat (line_input, "del"))
163  is_add = 0;
164  else if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
165  ;
166  else if (unformat (line_input, "vni %d", &vni))
167  gid_address_vni (&eid) = vni;
168  else if (unformat (line_input, "secret-key %_%v%_", &key))
169  ;
170  else if (unformat (line_input, "key-id %U", unformat_hmac_key_id,
171  &key_id))
172  ;
173  else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name))
174  {
175  vec_terminate_c_string (locator_set_name);
176  p = hash_get_mem (lcm->locator_set_index_by_name, locator_set_name);
177  if (!p)
178  {
179  error = clib_error_return (0, "locator-set %s doesn't exist",
180  locator_set_name);
181  goto done;
182  }
183  locator_set_index = p[0];
184  }
185  else
186  {
187  error = unformat_parse_error (line_input);
188  goto done;
189  }
190  }
191  /* XXX treat batch configuration */
192 
193  if (GID_ADDR_SRC_DST == gid_address_type (&eid))
194  {
195  error =
196  clib_error_return (0, "src/dst is not supported for local EIDs!");
197  goto done;
198  }
199 
200  if (key && (0 == key_id))
201  {
202  vlib_cli_output (vm, "invalid key_id!");
203  goto done;;
204  }
205 
206  gid_address_copy (&a->eid, &eid);
207  a->is_add = is_add;
208  a->locator_set_index = locator_set_index;
209  a->local = 1;
210  a->key = key;
211  a->key_id = key_id;
212 
213  rv = vnet_lisp_add_del_local_mapping (a, &map_index);
214  if (0 != rv)
215  {
216  error = clib_error_return (0, "failed to %s local mapping!",
217  is_add ? "add" : "delete");
218  }
219 done:
220  vec_free (eids);
221  if (locator_set_name)
222  vec_free (locator_set_name);
223  gid_address_free (&a->eid);
224  vec_free (a->key);
225  unformat_free (line_input);
226 
227  return error;
228 }
229 
230 /* *INDENT-OFF* */
231 VLIB_CLI_COMMAND (lisp_add_del_local_eid_command) = {
232  .path = "lisp eid-table",
233  .short_help = "lisp eid-table add/del [vni <vni>] eid <eid> "
234  "locator-set <locator-set> [key <secret-key> key-id sha1|sha256 ]",
236 };
237 /* *INDENT-ON* */
238 
239 static clib_error_t *
241  unformat_input_t * input,
242  vlib_cli_command_t * cmd)
243 {
244  u8 is_add = 1, is_l2 = 0;
245  u32 vni = 0, dp_id = 0;
246  unformat_input_t _line_input, *line_input = &_line_input;
247  clib_error_t *error = NULL;
248 
249  /* Get a line of input. */
250  if (!unformat_user (input, unformat_line_input, line_input))
251  return 0;
252 
253  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
254  {
255  if (unformat (line_input, "del"))
256  is_add = 0;
257  else if (unformat (line_input, "vni %d", &vni))
258  ;
259  else if (unformat (line_input, "vrf %d", &dp_id))
260  ;
261  else if (unformat (line_input, "bd %d", &dp_id))
262  is_l2 = 1;
263  else
264  {
265  error = unformat_parse_error (line_input);
266  goto done;
267  }
268  }
269  vnet_lisp_eid_table_map (vni, dp_id, is_l2, is_add);
270 
271 done:
272  unformat_free (line_input);
273 
274  return error;
275 }
276 
277 /* *INDENT-OFF* */
278 VLIB_CLI_COMMAND (lisp_eid_table_map_command) = {
279  .path = "lisp eid-table map",
280  .short_help = "lisp eid-table map [del] vni <vni> vrf <vrf> | bd <bdi>",
281  .function = lisp_eid_table_map_command_fn,
282 };
283 /* *INDENT-ON* */
284 
285 /**
286  * Handler for add/del remote mapping CLI.
287  *
288  * @param vm vlib context
289  * @param input input from user
290  * @param cmd cmd
291  * @return pointer to clib error structure
292  */
293 static clib_error_t *
295  unformat_input_t * input,
296  vlib_cli_command_t * cmd)
297 {
298  clib_error_t *error = 0;
299  unformat_input_t _line_input, *line_input = &_line_input;
300  u8 is_add = 1, del_all = 0;
301  locator_t rloc, *rlocs = 0, *curr_rloc = 0;
303  u8 eid_set = 0;
304  u32 vni, action = ~0, p, w;
305  int rv;
306 
307  /* Get a line of input. */
308  if (!unformat_user (input, unformat_line_input, line_input))
309  return 0;
310 
311  clib_memset (&eid, 0, sizeof (eid));
312  clib_memset (&rloc, 0, sizeof (rloc));
313 
314  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
315  {
316  if (unformat (line_input, "del-all"))
317  del_all = 1;
318  else if (unformat (line_input, "del"))
319  is_add = 0;
320  else if (unformat (line_input, "add"))
321  ;
322  else if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
323  eid_set = 1;
324  else if (unformat (line_input, "vni %u", &vni))
325  {
326  gid_address_vni (&eid) = vni;
327  }
328  else if (unformat (line_input, "p %d w %d", &p, &w))
329  {
330  if (!curr_rloc)
331  {
333  ("No RLOC configured for setting priority/weight!");
334  goto done;
335  }
336  curr_rloc->priority = p;
337  curr_rloc->weight = w;
338  }
339  else if (unformat (line_input, "rloc %U", unformat_ip_address,
340  &gid_address_ip (&rloc.address)))
341  {
342  /* since rloc is stored in ip prefix we need to set prefix length */
343  ip_prefix_t *pref = &gid_address_ippref (&rloc.address);
344 
346  ip_prefix_len (pref) = ip_address_max_len (version);
347 
348  vec_add1 (rlocs, rloc);
349  curr_rloc = &rlocs[vec_len (rlocs) - 1];
350  }
351  else if (unformat (line_input, "action %U",
353  ;
354  else
355  {
356  clib_warning ("parse error");
357  goto done;
358  }
359  }
360 
361  if (!eid_set)
362  {
363  clib_warning ("missing eid!");
364  goto done;
365  }
366 
367  if (!del_all)
368  {
369  if (is_add && (~0 == action) && 0 == vec_len (rlocs))
370  {
371  clib_warning ("no action set for negative map-reply!");
372  goto done;
373  }
374  }
375  else
376  {
378  goto done;
379  }
380 
381  /* TODO build src/dst with seid */
382 
383  /* if it's a delete, clean forwarding */
384  if (!is_add)
385  {
387  clib_memset (a, 0, sizeof (a[0]));
388  gid_address_copy (&a->reid, &eid);
390  {
391  clib_warning ("failed to delete adjacency!");
392  goto done;
393  }
394  }
395 
396  /* add as static remote mapping, i.e., not authoritative and infinite
397  * ttl */
398  if (is_add)
399  {
400  vnet_lisp_add_del_mapping_args_t _map_args, *map_args = &_map_args;
401  clib_memset (map_args, 0, sizeof (map_args[0]));
402  gid_address_copy (&map_args->eid, &eid);
403  map_args->action = action;
404  map_args->is_static = 1;
405  map_args->authoritative = 0;
406  map_args->ttl = ~0;
407  rv = vnet_lisp_add_mapping (map_args, rlocs, NULL, NULL);
408  }
409  else
410  rv = vnet_lisp_del_mapping (&eid, NULL);
411 
412  if (rv)
413  clib_warning ("failed to %s remote mapping!", is_add ? "add" : "delete");
414 
415 done:
416  vec_free (rlocs);
417  unformat_free (line_input);
418  return error;
419 }
420 
421 /* *INDENT-OFF* */
422 VLIB_CLI_COMMAND (lisp_add_del_remote_mapping_command) = {
423  .path = "lisp remote-mapping",
424  .short_help = "lisp remote-mapping add|del [del-all] vni <vni> "
425  "eid <est-eid> [action <no-action|natively-forward|"
426  "send-map-request|drop>] rloc <dst-locator> p <prio> "
427  "w <weight> [rloc <dst-locator> ... ]",
429 };
430 /* *INDENT-ON* */
431 
432 /**
433  * Handler for add/del adjacency CLI.
434  */
435 static clib_error_t *
437  vlib_cli_command_t * cmd)
438 {
439  clib_error_t *error = 0;
440  unformat_input_t _line_input, *line_input = &_line_input;
442  u8 is_add = 1;
443  ip_prefix_t *reid_ippref, *leid_ippref;
445  u8 *dmac = gid_address_mac (&reid);
446  u8 *smac = gid_address_mac (&leid);
447  u8 reid_set = 0, leid_set = 0;
448  u32 vni;
449 
450  /* Get a line of input. */
451  if (!unformat_user (input, unformat_line_input, line_input))
452  return 0;
453 
454  clib_memset (&reid, 0, sizeof (reid));
455  clib_memset (&leid, 0, sizeof (leid));
456 
457  leid_ippref = &gid_address_ippref (&leid);
458  reid_ippref = &gid_address_ippref (&reid);
459 
460  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
461  {
462  if (unformat (line_input, "del"))
463  is_add = 0;
464  else if (unformat (line_input, "add"))
465  ;
466  else if (unformat (line_input, "reid %U",
467  unformat_ip_prefix, reid_ippref))
468  {
470  reid_set = 1;
471  }
472  else if (unformat (line_input, "reid %U", unformat_mac_address, dmac))
473  {
474  gid_address_type (&reid) = GID_ADDR_MAC;
475  reid_set = 1;
476  }
477  else if (unformat (line_input, "vni %u", &vni))
478  {
479  gid_address_vni (&leid) = vni;
480  gid_address_vni (&reid) = vni;
481  }
482  else if (unformat (line_input, "leid %U",
483  unformat_ip_prefix, leid_ippref))
484  {
486  leid_set = 1;
487  }
488  else if (unformat (line_input, "leid %U", unformat_mac_address, smac))
489  {
490  gid_address_type (&leid) = GID_ADDR_MAC;
491  leid_set = 1;
492  }
493  else
494  {
495  clib_warning ("parse error");
496  goto done;
497  }
498  }
499 
500  if (!reid_set || !leid_set)
501  {
502  clib_warning ("missing remote or local eid!");
503  goto done;
504  }
505 
506  if ((gid_address_type (&leid) != gid_address_type (&reid))
507  || (gid_address_type (&reid) == GID_ADDR_IP_PREFIX
508  && ip_prefix_version (reid_ippref)
509  != ip_prefix_version (leid_ippref)))
510  {
511  clib_warning ("remote and local EIDs are of different types!");
512  goto done;
513  }
514 
515  clib_memset (a, 0, sizeof (a[0]));
516  gid_address_copy (&a->leid, &leid);
517  gid_address_copy (&a->reid, &reid);
518  a->is_add = is_add;
519 
521  clib_warning ("failed to %s adjacency!", is_add ? "add" : "delete");
522 
523 done:
524  unformat_free (line_input);
525  return error;
526 }
527 
528 /* *INDENT-OFF* */
529 VLIB_CLI_COMMAND (lisp_add_del_adjacency_command) = {
530  .path = "lisp adjacency",
531  .short_help = "lisp adjacency add|del vni <vni> reid <remote-eid> "
532  "leid <local-eid>",
534 };
535 /* *INDENT-ON* */
536 
537 
538 static clib_error_t *
540  unformat_input_t * input,
541  vlib_cli_command_t * cmd)
542 {
543  unformat_input_t _i, *i = &_i;
544  map_request_mode_t mr_mode = _MR_MODE_MAX;
545  clib_error_t *error = NULL;
546 
547  /* Get a line of input. */
548  if (!unformat_user (input, unformat_line_input, i))
549  return 0;
550 
552  {
553  if (unformat (i, "dst-only"))
554  mr_mode = MR_MODE_DST_ONLY;
555  else if (unformat (i, "src-dst"))
556  mr_mode = MR_MODE_SRC_DST;
557  else
558  {
559  clib_warning ("parse error '%U'", format_unformat_error, i);
560  goto done;
561  }
562  }
563 
564  if (_MR_MODE_MAX == mr_mode)
565  {
566  clib_warning ("No LISP map request mode entered!");
567  goto done;
568  }
569 
571 
572 done:
573  unformat_free (i);
574 
575  return error;
576 }
577 
578 /* *INDENT-OFF* */
579 VLIB_CLI_COMMAND (lisp_map_request_mode_command) = {
580  .path = "lisp map-request mode",
581  .short_help = "lisp map-request mode dst-only|src-dst",
583 };
584 /* *INDENT-ON* */
585 
586 
587 static u8 *
588 format_lisp_map_request_mode (u8 * s, va_list * args)
589 {
590  u32 mode = va_arg (*args, u32);
591 
592  switch (mode)
593  {
594  case 0:
595  return format (0, "dst-only");
596  case 1:
597  return format (0, "src-dst");
598  }
599  return 0;
600 }
601 
602 static clib_error_t *
604  unformat_input_t * input,
605  vlib_cli_command_t * cmd)
606 {
607  vlib_cli_output (vm, "map-request mode: %U", format_lisp_map_request_mode,
609  return 0;
610 }
611 
612 /* *INDENT-OFF* */
613 VLIB_CLI_COMMAND (lisp_show_map_request_mode_command) = {
614  .path = "show lisp map-request mode",
615  .short_help = "show lisp map-request mode",
617 };
618 /* *INDENT-ON* */
619 
620 static clib_error_t *
622  unformat_input_t * input,
623  vlib_cli_command_t * cmd)
624 {
625  lisp_msmr_t *mr;
627 
628  vec_foreach (mr, lcm->map_resolvers)
629  {
630  vlib_cli_output (vm, "%U", format_ip_address, &mr->address);
631  }
632  return 0;
633 }
634 
635 /* *INDENT-OFF* */
636 VLIB_CLI_COMMAND (lisp_show_map_resolvers_command) = {
637  .path = "show lisp map-resolvers",
638  .short_help = "show lisp map-resolvers",
640 };
641 /* *INDENT-ON* */
642 
643 
644 static clib_error_t *
646  unformat_input_t * input,
647  vlib_cli_command_t * cmd)
648 {
649  u8 locator_name_set = 0;
650  u8 *locator_set_name = 0;
651  u8 is_add = 1;
652  unformat_input_t _line_input, *line_input = &_line_input;
653  clib_error_t *error = 0;
654  int rv = 0;
655 
656  /* Get a line of input. */
657  if (!unformat_user (input, unformat_line_input, line_input))
658  return 0;
659 
660  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
661  {
662  if (unformat (line_input, "ls %_%v%_", &locator_set_name))
663  locator_name_set = 1;
664  else if (unformat (line_input, "disable"))
665  is_add = 0;
666  else
667  {
668  error = clib_error_return (0, "parse error");
669  goto done;
670  }
671  }
672 
673  if (!locator_name_set)
674  {
675  clib_warning ("No locator set specified!");
676  goto done;
677  }
678  vec_terminate_c_string (locator_set_name);
679  rv = vnet_lisp_pitr_set_locator_set (locator_set_name, is_add);
680  if (0 != rv)
681  {
682  error = clib_error_return (0, "failed to %s pitr!",
683  is_add ? "add" : "delete");
684  }
685 
686 done:
687  if (locator_set_name)
688  vec_free (locator_set_name);
689  unformat_free (line_input);
690 
691  return error;
692 }
693 
694 /* *INDENT-OFF* */
695 VLIB_CLI_COMMAND (lisp_pitr_set_locator_set_command) = {
696  .path = "lisp pitr",
697  .short_help = "lisp pitr [disable] ls <locator-set-name>",
699 };
700 /* *INDENT-ON* */
701 
702 static clib_error_t *
704  unformat_input_t * input, vlib_cli_command_t * cmd)
705 {
707  mapping_t *m;
708  locator_set_t *ls;
709  u8 *tmp_str = 0;
710  u8 status = lcm->flags & LISP_FLAG_PITR_MODE;
711 
712  vlib_cli_output (vm, "%=20s%=16s", "pitr", status ? "locator-set" : "");
713 
714  if (!status)
715  {
716  vlib_cli_output (vm, "%=20s", "disable");
717  return 0;
718  }
719 
720  if (~0 == lcm->pitr_map_index)
721  {
722  tmp_str = format (0, "N/A");
723  }
724  else
725  {
727  if (~0 != m->locator_set_index)
728  {
729  ls =
731  tmp_str = format (0, "%s", ls->name);
732  }
733  else
734  {
735  tmp_str = format (0, "N/A");
736  }
737  }
738  vec_add1 (tmp_str, 0);
739 
740  vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
741 
742  vec_free (tmp_str);
743 
744  return 0;
745 }
746 
747 /* *INDENT-OFF* */
748 VLIB_CLI_COMMAND (lisp_show_pitr_command) = {
749  .path = "show lisp pitr",
750  .short_help = "Show pitr",
751  .function = lisp_show_pitr_command_fn,
752 };
753 /* *INDENT-ON* */
754 
755 static u8 *
756 format_eid_entry (u8 * s, va_list * args)
757 {
758  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
759  lisp_cp_main_t *lcm = va_arg (*args, lisp_cp_main_t *);
760  mapping_t *mapit = va_arg (*args, mapping_t *);
761  locator_set_t *ls = va_arg (*args, locator_set_t *);
762  gid_address_t *gid = &mapit->eid;
763  u32 ttl = mapit->ttl;
764  u8 aut = mapit->authoritative;
765  u32 *loc_index;
766  u8 first_line = 1;
767  u8 *loc;
768 
769  u8 *type = ls->local ? format (0, "local(%s)", ls->name)
770  : format (0, "remote");
771 
772  if (vec_len (ls->locator_indices) == 0)
773  {
774  s = format (s, "%-35U%-30s%-20u%-u", format_gid_address, gid,
775  type, ttl, aut);
776  }
777  else
778  {
779  vec_foreach (loc_index, ls->locator_indices)
780  {
781  locator_t *l = pool_elt_at_index (lcm->locator_pool, loc_index[0]);
782  if (l->local)
783  loc = format (0, "%U", format_vnet_sw_if_index_name, vnm,
784  l->sw_if_index);
785  else
786  loc = format (0, "%U", format_ip_address,
787  &gid_address_ip (&l->address));
788 
789  if (first_line)
790  {
791  s = format (s, "%-35U%-20s%-30v%-20u%-u\n", format_gid_address,
792  gid, type, loc, ttl, aut);
793  first_line = 0;
794  }
795  else
796  s = format (s, "%55s%v\n", "", loc);
797  }
798  }
799  return s;
800 }
801 
802 static clib_error_t *
804  unformat_input_t * input,
805  vlib_cli_command_t * cmd)
806 {
808  mapping_t *mapit;
809  unformat_input_t _line_input, *line_input = &_line_input;
810  u32 mi;
812  u8 print_all = 1;
813  u8 filter = 0;
814  clib_error_t *error = NULL;
815 
816  clib_memset (&eid, 0, sizeof (eid));
817 
818  /* Get a line of input. */
819  if (!unformat_user (input, unformat_line_input, line_input))
820  return 0;
821 
822  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
823  {
824  if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
825  print_all = 0;
826  else if (unformat (line_input, "local"))
827  filter = 1;
828  else if (unformat (line_input, "remote"))
829  filter = 2;
830  else
831  {
832  error = clib_error_return (0, "parse error: '%U'",
833  format_unformat_error, line_input);
834  goto done;
835  }
836  }
837 
838  vlib_cli_output (vm, "%-35s%-20s%-30s%-20s%-s",
839  "EID", "type", "locators", "ttl", "authoritative");
840 
841  if (print_all)
842  {
843  /* *INDENT-OFF* */
844  pool_foreach (mapit, lcm->mapping_pool)
845  {
846  if (mapit->pitr_set)
847  continue;
848 
850  mapit->locator_set_index);
851  if (filter && !((1 == filter && ls->local) ||
852  (2 == filter && !ls->local)))
853  {
854  continue;
855  }
856  vlib_cli_output (vm, "%U", format_eid_entry, lcm->vnet_main,
857  lcm, mapit, ls);
858  }
859  /* *INDENT-ON* */
860  }
861  else
862  {
863  mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &eid);
864  if ((u32) ~ 0 == mi)
865  goto done;
866 
867  mapit = pool_elt_at_index (lcm->mapping_pool, mi);
869  mapit->locator_set_index);
870 
871  if (filter && !((1 == filter && ls->local) ||
872  (2 == filter && !ls->local)))
873  {
874  goto done;
875  }
876 
877  vlib_cli_output (vm, "%U,", format_eid_entry, lcm->vnet_main,
878  lcm, mapit, ls);
879  }
880 
881 done:
882  unformat_free (line_input);
883 
884  return error;
885 }
886 
887 /* *INDENT-OFF* */
888 VLIB_CLI_COMMAND (lisp_cp_show_eid_table_command) = {
889  .path = "show lisp eid-table",
890  .short_help = "show lisp eid-table [local|remote|eid <eid>]",
891  .function = lisp_show_eid_table_command_fn,
892 };
893 /* *INDENT-ON* */
894 
895 
896 static clib_error_t *
898  vlib_cli_command_t * cmd)
899 {
901  return clib_error_return (0, "parse error: '%U'", format_unformat_error,
902  input);
903 
905 
906  return 0;
907 }
908 
909 /* *INDENT-OFF* */
910 VLIB_CLI_COMMAND (lisp_cp_enable_command) = {
911  .path = "lisp enable",
912  .short_help = "lisp enable",
913  .function = lisp_enable_command_fn,
914 };
915 /* *INDENT-ON* */
916 
917 static clib_error_t *
919  vlib_cli_command_t * cmd)
920 {
922  return clib_error_return (0, "parse error: '%U'", format_unformat_error,
923  input);
924 
926 
927  return 0;
928 }
929 
930 /* *INDENT-OFF* */
931 VLIB_CLI_COMMAND (lisp_cp_disable_command) = {
932  .path = "lisp disable",
933  .short_help = "lisp disable",
934  .function = lisp_disable_command_fn,
935 };
936 /* *INDENT-ON* */
937 
938 static clib_error_t *
940  unformat_input_t * input,
941  vlib_cli_command_t * cmd)
942 {
943  unformat_input_t _line_input, *line_input = &_line_input;
944  u8 is_enabled = 0;
945  u8 is_set = 0;
946  clib_error_t *error = NULL;
947 
948  /* Get a line of input. */
949  if (!unformat_user (input, unformat_line_input, line_input))
950  return clib_error_return (0, "expected enable | disable");
951 
952  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
953  {
954  if (unformat (line_input, "enable"))
955  {
956  is_set = 1;
957  is_enabled = 1;
958  }
959  else if (unformat (line_input, "disable"))
960  is_set = 1;
961  else
962  {
963  vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
964  line_input);
965  goto done;
966  }
967  }
968 
969  if (!is_set)
970  {
971  vlib_cli_output (vm, "state not set!");
972  goto done;
973  }
974 
976 
977 done:
978  unformat_free (line_input);
979 
980  return error;
981 }
982 
983 /* *INDENT-OFF* */
984 VLIB_CLI_COMMAND (lisp_map_register_enable_disable_command) = {
985  .path = "lisp map-register",
986  .short_help = "lisp map-register [enable|disable]",
988 };
989 /* *INDENT-ON* */
990 
991 static clib_error_t *
993  unformat_input_t * input,
994  vlib_cli_command_t * cmd)
995 {
996  unformat_input_t _line_input, *line_input = &_line_input;
997  u8 is_enabled = 0;
998  u8 is_set = 0;
999  clib_error_t *error = NULL;
1000 
1001  /* Get a line of input. */
1002  if (!unformat_user (input, unformat_line_input, line_input))
1003  return clib_error_return (0, "expected enable | disable");
1004 
1005  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1006  {
1007  if (unformat (line_input, "enable"))
1008  {
1009  is_set = 1;
1010  is_enabled = 1;
1011  }
1012  else if (unformat (line_input, "disable"))
1013  is_set = 1;
1014  else
1015  {
1016  vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1017  line_input);
1018  goto done;
1019  }
1020  }
1021 
1022  if (!is_set)
1023  {
1024  vlib_cli_output (vm, "state not set!");
1025  goto done;
1026  }
1027 
1029 
1030 done:
1031  unformat_free (line_input);
1032 
1033  return error;
1034 }
1035 
1036 /* *INDENT-OFF* */
1037 VLIB_CLI_COMMAND (lisp_rloc_probe_enable_disable_command) = {
1038  .path = "lisp rloc-probe",
1039  .short_help = "lisp rloc-probe [enable|disable]",
1041 };
1042 /* *INDENT-ON* */
1043 
1044 static u8 *
1045 format_lisp_status (u8 * s, va_list * args)
1046 {
1048  return format (s, "%s", lcm->is_enabled ? "enabled" : "disabled");
1049 }
1050 
1051 static clib_error_t *
1053  vlib_cli_command_t * cmd)
1054 {
1055  u8 *msg = 0;
1056  msg = format (msg, "feature: %U\ngpe: %U\n",
1058  vlib_cli_output (vm, "%v", msg);
1059  vec_free (msg);
1060  return 0;
1061 }
1062 
1063 /* *INDENT-OFF* */
1064 VLIB_CLI_COMMAND (lisp_show_status_command) = {
1065  .path = "show lisp status",
1066  .short_help = "show lisp status",
1067  .function = lisp_show_status_command_fn,
1068 };
1069 /* *INDENT-ON* */
1070 
1071 static clib_error_t *
1073  unformat_input_t * input,
1074  vlib_cli_command_t * cmd)
1075 {
1076  hash_pair_t *p;
1077  unformat_input_t _line_input, *line_input = &_line_input;
1079  uword *vni_table = 0;
1080  u8 is_l2 = 0;
1081  clib_error_t *error = NULL;
1082 
1083  /* Get a line of input. */
1084  if (!unformat_user (input, unformat_line_input, line_input))
1085  return 0;
1086 
1087  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1088  {
1089  if (unformat (line_input, "l2"))
1090  {
1091  vni_table = lcm->bd_id_by_vni;
1092  is_l2 = 1;
1093  }
1094  else if (unformat (line_input, "l3"))
1095  {
1096  vni_table = lcm->table_id_by_vni;
1097  is_l2 = 0;
1098  }
1099  else
1100  {
1101  error = clib_error_return (0, "parse error: '%U'",
1102  format_unformat_error, line_input);
1103  goto done;
1104  }
1105  }
1106 
1107  if (!vni_table)
1108  {
1109  vlib_cli_output (vm, "Error: expected l2|l3 param!\n");
1110  goto done;
1111  }
1112 
1113  vlib_cli_output (vm, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
1114 
1115  /* *INDENT-OFF* */
1116  hash_foreach_pair (p, vni_table,
1117  ({
1118  vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]);
1119  }));
1120  /* *INDENT-ON* */
1121 
1122 done:
1123  unformat_free (line_input);
1124 
1125  return error;
1126 }
1127 
1128 /* *INDENT-OFF* */
1129 VLIB_CLI_COMMAND (lisp_show_eid_table_map_command) = {
1130  .path = "show lisp eid-table map",
1131  .short_help = "show lisp eid-table map l2|l3",
1133 };
1134 /* *INDENT-ON* */
1135 
1136 
1137 static clib_error_t *
1139  unformat_input_t * input,
1140  vlib_cli_command_t * cmd)
1141 {
1143  vnet_main_t *vnm = lgm->vnet_main;
1144  unformat_input_t _line_input, *line_input = &_line_input;
1145  u8 is_add = 1;
1146  clib_error_t *error = 0;
1147  u8 *locator_set_name = 0;
1148  locator_t locator, *locators = 0;
1150  u32 ls_index = 0;
1151  int rv = 0;
1152 
1153  clib_memset (&locator, 0, sizeof (locator));
1154  clib_memset (a, 0, sizeof (a[0]));
1155 
1156  /* Get a line of input. */
1157  if (!unformat_user (input, unformat_line_input, line_input))
1158  return clib_error_return (0, "missing parameters");
1159 
1160  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1161  {
1162  if (unformat (line_input, "add %_%v%_", &locator_set_name))
1163  is_add = 1;
1164  else if (unformat (line_input, "del %_%v%_", &locator_set_name))
1165  is_add = 0;
1166  else if (unformat (line_input, "iface %U p %d w %d",
1168  &locator.sw_if_index, &locator.priority,
1169  &locator.weight))
1170  {
1171  locator.local = 1;
1172  locator.state = 1;
1173  vec_add1 (locators, locator);
1174  }
1175  else
1176  {
1177  error = unformat_parse_error (line_input);
1178  goto done;
1179  }
1180  }
1181 
1182  vec_terminate_c_string (locator_set_name);
1183  a->name = locator_set_name;
1184  a->locators = locators;
1185  a->is_add = is_add;
1186  a->local = 1;
1187 
1188  rv = vnet_lisp_add_del_locator_set (a, &ls_index);
1189  if (0 != rv)
1190  {
1191  error = clib_error_return (0, "failed to %s locator-set!",
1192  is_add ? "add" : "delete");
1193  }
1194 
1195 done:
1196  vec_free (locators);
1197  if (locator_set_name)
1198  vec_free (locator_set_name);
1199  unformat_free (line_input);
1200 
1201  return error;
1202 }
1203 
1204 /* *INDENT-OFF* */
1205 VLIB_CLI_COMMAND (lisp_cp_add_del_locator_set_command) = {
1206  .path = "lisp locator-set",
1207  .short_help = "lisp locator-set add/del <name> [iface <iface-name> "
1208  "p <priority> w <weight>]",
1210 };
1211 /* *INDENT-ON* */
1212 
1213 static clib_error_t *
1215  unformat_input_t * input,
1216  vlib_cli_command_t * cmd)
1217 {
1219  vnet_main_t *vnm = lgm->vnet_main;
1220  unformat_input_t _line_input, *line_input = &_line_input;
1221  u8 is_add = 1;
1222  clib_error_t *error = 0;
1223  u8 *locator_set_name = 0;
1224  u8 locator_set_name_set = 0;
1225  locator_t locator, *locators = 0;
1227  u32 ls_index = 0;
1228 
1229  clib_memset (&locator, 0, sizeof (locator));
1230  clib_memset (a, 0, sizeof (a[0]));
1231 
1232  /* Get a line of input. */
1233  if (!unformat_user (input, unformat_line_input, line_input))
1234  return 0;
1235 
1236  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1237  {
1238  if (unformat (line_input, "add"))
1239  is_add = 1;
1240  else if (unformat (line_input, "del"))
1241  is_add = 0;
1242  else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name))
1243  locator_set_name_set = 1;
1244  else if (unformat (line_input, "iface %U p %d w %d",
1246  &locator.sw_if_index, &locator.priority,
1247  &locator.weight))
1248  {
1249  locator.local = 1;
1250  vec_add1 (locators, locator);
1251  }
1252  else
1253  {
1254  error = unformat_parse_error (line_input);
1255  goto done;
1256  }
1257  }
1258 
1259  if (!locator_set_name_set)
1260  {
1261  error = clib_error_return (0, "locator_set name not set!");
1262  goto done;
1263  }
1264 
1265  a->name = locator_set_name;
1266  a->locators = locators;
1267  a->is_add = is_add;
1268  a->local = 1;
1269 
1270  vnet_lisp_add_del_locator (a, 0, &ls_index);
1271 
1272 done:
1273  vec_free (locators);
1274  vec_free (locator_set_name);
1275  unformat_free (line_input);
1276 
1277  return error;
1278 }
1279 
1280 /* *INDENT-OFF* */
1281 VLIB_CLI_COMMAND (lisp_cp_add_del_locator_in_set_command) = {
1282  .path = "lisp locator",
1283  .short_help = "lisp locator add/del locator-set <name> iface <iface-name> "
1284  "p <priority> w <weight>",
1286 };
1287 /* *INDENT-ON* */
1288 
1289 static clib_error_t *
1291  unformat_input_t * input,
1292  vlib_cli_command_t * cmd)
1293 {
1294  locator_set_t *lsit;
1295  locator_t *loc;
1296  u32 *locit;
1298 
1299  vlib_cli_output (vm, "%s%=16s%=16s%=16s", "Locator-set", "Locator",
1300  "Priority", "Weight");
1301 
1302  /* *INDENT-OFF* */
1303  pool_foreach (lsit, lcm->locator_set_pool)
1304  {
1305  u8 * msg = 0;
1306  int next_line = 0;
1307  if (lsit->local)
1308  {
1309  msg = format (msg, "%v", lsit->name);
1310  }
1311  else
1312  {
1313  msg = format (msg, "<%s-%d>", "remote", lsit - lcm->locator_set_pool);
1314  }
1315  vec_foreach (locit, lsit->locator_indices)
1316  {
1317  if (next_line)
1318  {
1319  msg = format (msg, "%16s", " ");
1320  }
1321  loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
1322  if (loc->local)
1323  msg = format (msg, "%16d%16d%16d\n", loc->sw_if_index, loc->priority,
1324  loc->weight);
1325  else
1326  msg = format (msg, "%16U%16d%16d\n", format_ip_address,
1327  &gid_address_ip(&loc->address), loc->priority,
1328  loc->weight);
1329  next_line = 1;
1330  }
1331  vlib_cli_output (vm, "%v", msg);
1332  vec_free (msg);
1333  }
1334  /* *INDENT-ON* */
1335  return 0;
1336 }
1337 
1338 /* *INDENT-OFF* */
1339 VLIB_CLI_COMMAND (lisp_cp_show_locator_sets_command) = {
1340  .path = "show lisp locator-set",
1341  .short_help = "Shows locator-sets",
1343 };
1344 /* *INDENT-ON* */
1345 
1346 
1347 static clib_error_t *
1349  unformat_input_t * input,
1350  vlib_cli_command_t * cmd)
1351 {
1352  unformat_input_t _line_input, *line_input = &_line_input;
1353  u8 is_add = 1, addr_set = 0;
1354  ip_address_t ip_addr;
1355  clib_error_t *error = 0;
1356  int rv = 0;
1358 
1359  /* Get a line of input. */
1360  if (!unformat_user (input, unformat_line_input, line_input))
1361  return 0;
1362 
1363  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1364  {
1365  if (unformat (line_input, "add"))
1366  is_add = 1;
1367  else if (unformat (line_input, "del"))
1368  is_add = 0;
1369  else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr))
1370  addr_set = 1;
1371  else
1372  {
1373  error = unformat_parse_error (line_input);
1374  goto done;
1375  }
1376  }
1377 
1378  if (!addr_set)
1379  {
1380  error = clib_error_return (0, "Map-resolver address must be set!");
1381  goto done;
1382  }
1383 
1384  a->is_add = is_add;
1385  a->address = ip_addr;
1387  if (0 != rv)
1388  {
1389  error = clib_error_return (0, "failed to %s map-resolver!",
1390  is_add ? "add" : "delete");
1391  }
1392 
1393 done:
1394  unformat_free (line_input);
1395 
1396  return error;
1397 }
1398 
1399 /* *INDENT-OFF* */
1400 VLIB_CLI_COMMAND (lisp_add_del_map_resolver_command) = {
1401  .path = "lisp map-resolver",
1402  .short_help = "lisp map-resolver add/del <ip_address>",
1404 };
1405 /* *INDENT-ON* */
1406 
1407 
1408 static clib_error_t *
1410  unformat_input_t * input,
1411  vlib_cli_command_t * cmd)
1412 {
1413  unformat_input_t _line_input, *line_input = &_line_input;
1414  u8 is_add = 1;
1415  u8 *locator_set_name = 0;
1416  clib_error_t *error = 0;
1417  int rv = 0;
1419 
1420  /* Get a line of input. */
1421  if (!unformat_user (input, unformat_line_input, line_input))
1422  return 0;
1423 
1424  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1425  {
1426  if (unformat (line_input, "del"))
1427  is_add = 0;
1428  else if (unformat (line_input, "add %_%v%_", &locator_set_name))
1429  is_add = 1;
1430  else
1431  {
1432  error = unformat_parse_error (line_input);
1433  goto done;
1434  }
1435  }
1436 
1437  vec_terminate_c_string (locator_set_name);
1438  a->is_add = is_add;
1439  a->locator_set_name = locator_set_name;
1441  if (0 != rv)
1442  {
1443  error = clib_error_return (0, "failed to %s map-request itr-rlocs!",
1444  is_add ? "add" : "delete");
1445  }
1446 
1447 done:
1448  vec_free (locator_set_name);
1449  unformat_free (line_input);
1450 
1451  return error;
1452 }
1453 
1454 /* *INDENT-OFF* */
1455 VLIB_CLI_COMMAND (lisp_add_del_map_request_command) = {
1456  .path = "lisp map-request itr-rlocs",
1457  .short_help = "lisp map-request itr-rlocs add/del <locator_set_name>",
1459 };
1460 /* *INDENT-ON* */
1461 
1462 static clib_error_t *
1464  unformat_input_t * input,
1465  vlib_cli_command_t * cmd)
1466 {
1468  locator_set_t *loc_set;
1469 
1470  vlib_cli_output (vm, "%=20s", "itr-rlocs");
1471 
1472  if (~0 == lcm->mreq_itr_rlocs)
1473  {
1474  return 0;
1475  }
1476 
1477  loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1478 
1479  vlib_cli_output (vm, "%=20s", loc_set->name);
1480 
1481  return 0;
1482 }
1483 
1484 /* *INDENT-OFF* */
1485 VLIB_CLI_COMMAND (lisp_show_map_request_command) = {
1486  .path = "show lisp map-request itr-rlocs",
1487  .short_help = "Shows map-request itr-rlocs",
1489 };
1490 /* *INDENT-ON* */
1491 
1492 static clib_error_t *
1494  unformat_input_t * input,
1495  vlib_cli_command_t * cmd)
1496 {
1497  u8 is_add = 1, ip_set = 0;
1498  unformat_input_t _line_input, *line_input = &_line_input;
1499  clib_error_t *error = 0;
1500  ip_address_t ip;
1501 
1502  /* Get a line of input. */
1503  if (!unformat_user (input, unformat_line_input, line_input))
1504  return 0;
1505 
1506  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1507  {
1508  if (unformat (line_input, "%U", unformat_ip_address, &ip))
1509  ip_set = 1;
1510  else if (unformat (line_input, "disable"))
1511  is_add = 0;
1512  else
1513  {
1514  error = clib_error_return (0, "parse error");
1515  goto done;
1516  }
1517  }
1518 
1519  if (!ip_set)
1520  {
1521  clib_warning ("No petr IP specified!");
1522  goto done;
1523  }
1524 
1525  if (vnet_lisp_use_petr (&ip, is_add))
1526  {
1527  error = clib_error_return (0, "failed to %s petr!",
1528  is_add ? "add" : "delete");
1529  }
1530 
1531 done:
1532  unformat_free (line_input);
1533 
1534  return error;
1535 }
1536 
1537 /* *INDENT-OFF* */
1538 VLIB_CLI_COMMAND (lisp_use_petr_set_locator_set_command) = {
1539  .path = "lisp use-petr",
1540  .short_help = "lisp use-petr [disable] <petr-ip>",
1542 };
1543 
1544 static clib_error_t *
1546  unformat_input_t * input, vlib_cli_command_t * cmd)
1547 {
1549  mapping_t *m;
1550  locator_set_t *ls;
1551  locator_t *loc;
1552  u8 *tmp_str = 0;
1553  u8 use_petr = lcm->flags & LISP_FLAG_USE_PETR;
1554  vlib_cli_output (vm, "%=20s%=16s", "petr", use_petr ? "ip" : "");
1555 
1556  if (!use_petr)
1557  {
1558  vlib_cli_output (vm, "%=20s", "disable");
1559  return 0;
1560  }
1561 
1562  if (~0 == lcm->petr_map_index)
1563  {
1564  tmp_str = format (0, "N/A");
1565  }
1566  else
1567  {
1569  if (~0 != m->locator_set_index)
1570  {
1572  loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
1573  tmp_str = format (0, "%U", format_ip_address, &loc->address);
1574  }
1575  else
1576  {
1577  tmp_str = format (0, "N/A");
1578  }
1579  }
1580  vec_add1 (tmp_str, 0);
1581 
1582  vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
1583 
1584  vec_free (tmp_str);
1585 
1586  return 0;
1587 }
1588 
1589 /* *INDENT-OFF* */
1590 VLIB_CLI_COMMAND (lisp_show_petr_command) = {
1591  .path = "show lisp petr",
1592  .short_help = "Show petr",
1593  .function = lisp_show_petr_command_fn,
1594 };
1595 /* *INDENT-ON* */
1596 
1597 /*
1598  * fd.io coding-style-patch-verification: ON
1599  *
1600  * Local Variables:
1601  * eval: (c-set-style "gnu")
1602  * End:
1603  */
#define gid_address_ip_version(_a)
Definition: lisp_types.h:207
static clib_error_t * lisp_show_pitr_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:703
u16 vni
Definition: flow_types.api:160
u32 pitr_map_index
Definition: control.h:251
gid_address_t leid
Definition: control.h:74
#define gid_address_type(_a)
Definition: lisp_types.h:203
static clib_error_t * lisp_disable_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:918
a
Definition: bitmap.h:544
static clib_error_t * lisp_use_petr_set_locator_set_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1493
static clib_error_t * lisp_show_mreq_itr_rlocs_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1463
lisp_msmr_t * map_resolvers
Definition: control.h:221
#define pool_foreach(VAR, POOL)
Iterate through pool.
Definition: pool.h:527
static u8 * format_lisp_status(u8 *s, va_list *args)
Definition: lisp_cli.c:1045
uword * table_id_by_vni
Definition: control.h:240
void ip_set(ip46_address_t *dst, void *src, u8 is_ip4)
Definition: ip.c:93
static clib_error_t * lisp_rloc_probe_enable_disable_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:992
static u8 * format_lisp_map_request_mode(u8 *s, va_list *args)
Definition: lisp_cli.c:588
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
locator_t * locator_pool
Definition: control.h:178
LISP-GPE global state.
Definition: lisp_gpe.h:119
u8 vnet_lisp_get_map_request_mode(void)
Definition: control.c:55
#define vec_terminate_c_string(V)
(If necessary) NULL terminate a vector containing a c-string.
Definition: vec.h:1090
static clib_error_t * lisp_show_eid_table_map_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1072
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:592
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
vlib_main_t * vm
Definition: in2out_ed.c:1580
unformat_function_t unformat_vnet_sw_interface
ip_address_t address
Definition: control.h:89
int vnet_lisp_add_mapping(vnet_lisp_add_del_mapping_args_t *a, locator_t *rlocs, u32 *res_map_index, u8 *is_updated)
Adds/updates mapping.
Definition: control.c:1228
uword unformat_hmac_key_id(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:247
format_function_t format_vnet_sw_if_index_name
unsigned char u8
Definition: types.h:56
int vnet_lisp_set_map_request_mode(u8 mode)
Definition: control.c:1508
int vnet_lisp_add_del_adjacency(vnet_lisp_add_del_adjacency_args_t *a)
Adds adjacency or removes forwarding entry associated to remote mapping.
Definition: control.c:1437
uword value[0]
Definition: hash.h:165
uword unformat_negative_mapping_action(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:313
static clib_error_t * lisp_add_del_adjacency_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Handler for add/del adjacency CLI.
Definition: lisp_cli.c:436
description fragment has unexpected format
Definition: map.api:433
#define clib_error_return(e, args...)
Definition: error.h:99
typedef eid
Definition: lisp_types.api:59
static clib_error_t * lisp_cp_show_locator_sets_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1290
int vnet_lisp_eid_table_map(u32 vni, u32 dp_id, u8 is_l2, u8 is_add)
Definition: control.c:1034
unsigned int u32
Definition: types.h:88
uword * bd_id_by_vni
Definition: control.h:244
static clib_error_t * lisp_add_del_local_eid_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:133
static lisp_cp_main_t * vnet_lisp_cp_get_main()
Definition: control.h:305
static clib_error_t * lisp_show_map_request_mode_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:603
static clib_error_t * lisp_add_del_mreq_itr_rlocs_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1409
u32 petr_map_index
Proxy ETR map index used for &#39;use-petr&#39;.
Definition: control.h:255
unformat_function_t unformat_line_input
Definition: format.h:282
vl_api_fib_path_type_t type
Definition: fib_types.api:123
clib_error_t * vnet_lisp_enable_disable(u8 is_enable)
Definition: control.c:2204
Definition: cJSON.c:84
int vnet_lisp_pitr_set_locator_set(u8 *locator_set_name, u8 is_add)
Definition: control.c:1580
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:546
#define gid_address_mac(_a)
Definition: lisp_types.h:209
struct _unformat_input_t unformat_input_t
int vnet_lisp_add_del_local_mapping(vnet_lisp_add_del_mapping_args_t *a, u32 *map_index_result)
Add/update/delete mapping to/in/from map-cache.
Definition: control.c:835
void gid_address_free(gid_address_t *a)
Definition: lisp_types.c:733
u8 authoritative
Definition: lisp_types.h:305
uword unformat_gid_address(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:272
static clib_error_t * lisp_show_petr_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1545
static clib_error_t * lisp_map_register_enable_disable_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:939
u8 * format_gid_address(u8 *s, va_list *args)
Definition: lisp_types.c:187
static clib_error_t * lisp_map_request_mode_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:539
uword unformat_ip_address(unformat_input_t *input, va_list *args)
Definition: ip_types.c:41
static clib_error_t * lisp_pitr_set_locator_set_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:645
vl_api_tunnel_mode_t mode
Definition: gre.api:48
#define gid_address_ippref(_a)
Definition: lisp_types.h:204
lisp_adjacency_t * vnet_lisp_adjacencies_get_by_vni(u32 vni)
Returns vector of adjacencies.
Definition: control.c:577
u32 sw_if_index
Definition: lisp_types.h:266
static u8 * format_eid_entry(u8 *s, va_list *args)
Definition: lisp_cli.c:756
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
int vnet_lisp_add_del_mreq_itr_rlocs(vnet_lisp_add_del_mreq_itr_rloc_args_t *a)
Definition: control.c:2339
static clib_error_t * lisp_show_adjacencies_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:20
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
static clib_error_t * lisp_add_del_map_resolver_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1348
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
vnet_main_t * vnet_main
Definition: lisp_gpe.h:173
u8 ttl
Definition: fib_types.api:26
#define clib_warning(format, args...)
Definition: error.h:59
u32 locator_set_index
Definition: lisp_types.h:298
u8 * format_ip_address(u8 *s, va_list *args)
Definition: ip_types.c:21
int vnet_lisp_map_register_enable_disable(u8 is_enable)
Definition: control.c:2138
uword unformat_mac_address(unformat_input_t *input, va_list *args)
Definition: format.c:241
lisp_gpe_main_t lisp_gpe_main
LISP-GPE global state.
Definition: lisp_gpe.c:30
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:158
static clib_error_t * lisp_show_status_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1052
struct _gid_address_t gid_address_t
u8 * format_vnet_lisp_gpe_status(u8 *s, va_list *args)
Format LISP-GPE status.
Definition: lisp_gpe.c:592
int vnet_lisp_add_del_map_server(ip_address_t *addr, u8 is_add)
Definition: control.c:631
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:696
int vnet_lisp_clear_all_remote_adjacencies(void)
Definition: control.c:1386
static clib_error_t * lisp_add_del_map_server_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:76
gid_dictionary_t mapping_index_by_gid
Definition: control.h:169
locator_set_t * locator_set_pool
Definition: control.h:181
int vnet_lisp_rloc_probe_enable_disable(u8 is_enable)
Definition: control.c:2129
u64 gid_dictionary_lookup(gid_dictionary_t *db, gid_address_t *key)
vl_api_eid_t reid
Definition: lisp_gpe.api:118
#define unformat_parse_error(input)
Definition: format.h:268
typedef key
Definition: ipsec_types.api:86
int vnet_lisp_add_del_locator_set(vnet_lisp_add_del_locator_set_args_t *a, u32 *ls_result)
Definition: control.c:1994
#define gid_address_ip(_a)
Definition: lisp_types.h:206
static clib_error_t * lisp_add_del_locator_in_set_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1214
#define gid_address_vni(_a)
Definition: lisp_types.h:213
vl_api_address_t ip
Definition: l2.api:501
map_request_mode_t
Definition: control.h:113
vl_api_mac_event_action_t action
Definition: l2.api:181
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:373
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:162
int vnet_lisp_del_mapping(gid_address_t *eid, u32 *res_map_index)
Removes a mapping.
Definition: control.c:1337
int vnet_lisp_add_del_locator(vnet_lisp_add_del_locator_set_args_t *a, locator_set_t *ls, u32 *ls_result)
Definition: control.c:1890
mapping_t * mapping_pool
Definition: control.h:172
#define ip_prefix_len(_a)
Definition: ip_types.h:124
u8 ip_address_max_len(u8 version)
Definition: lisp_types.c:432
uword * locator_set_index_by_name
Definition: control.h:187
void gid_address_copy(gid_address_t *dst, gid_address_t *src)
Definition: lisp_types.c:1203
#define ip_prefix_version(_a)
Definition: ip_types.h:123
gid_address_t eid
Definition: lisp_types.h:293
gid_address_t reid
Definition: control.h:75
gid_address_t address
Definition: lisp_types.h:267
option version
Definition: sample.api:19
#define hash_get_mem(h, key)
Definition: hash.h:269
static clib_error_t * lisp_add_del_locator_set_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:1138
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
static clib_error_t * lisp_eid_table_map_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:240
int vnet_lisp_add_del_map_resolver(vnet_lisp_add_del_map_resolver_args_t *a)
Definition: control.c:2276
#define vec_foreach(var, vec)
Vector iterator.
uword unformat_ip_prefix(unformat_input_t *input, va_list *args)
Definition: ip_types.c:64
vl_api_eid_t leid
Definition: lisp.api:497
static clib_error_t * lisp_enable_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:897
int vnet_lisp_use_petr(ip_address_t *ip, u8 is_add)
Configure Proxy-ETR.
Definition: control.c:1647
static clib_error_t * lisp_show_eid_table_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:803
u32 mreq_itr_rlocs
Definition: control.h:237
u32 * locator_indices
Definition: lisp_types.h:287
vnet_main_t * vnet_main
Definition: control.h:292
uword key
Definition: hash.h:162
LISP-GPE definitions.
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
static clib_error_t * lisp_show_map_resolvers_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:621
static clib_error_t * lisp_add_del_remote_mapping_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Handler for add/del remote mapping CLI.
Definition: lisp_cli.c:294
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170