FD.io VPP  v18.01.2-1-g9b554f3
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 <vnet/lisp-cp/control.h>
17 #include <vnet/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;
82  ip_address_t ip;
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;
139  gid_address_t eid;
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  memset (&eid, 0, sizeof (eid));
152  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;
302  gid_address_t eid;
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  memset (&eid, 0, sizeof (eid));
312  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 
345  u8 version = gid_address_ip_version (&rloc.address);
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  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  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 VLIB_CLI_COMMAND (lisp_add_del_remote_mapping_command) =
422 {
423 .path = "lisp remote-mapping",.short_help =
424  "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> w <weight> "
427  "[rloc <dst-locator> ... ]",.function =
429 
430 /**
431  * Handler for add/del adjacency CLI.
432  */
433 static clib_error_t *
435  vlib_cli_command_t * cmd)
436 {
437  clib_error_t *error = 0;
438  unformat_input_t _line_input, *line_input = &_line_input;
440  u8 is_add = 1;
441  ip_prefix_t *reid_ippref, *leid_ippref;
442  gid_address_t leid, reid;
443  u8 *dmac = gid_address_mac (&reid);
444  u8 *smac = gid_address_mac (&leid);
445  u8 reid_set = 0, leid_set = 0;
446  u32 vni;
447 
448  /* Get a line of input. */
449  if (!unformat_user (input, unformat_line_input, line_input))
450  return 0;
451 
452  memset (&reid, 0, sizeof (reid));
453  memset (&leid, 0, sizeof (leid));
454 
455  leid_ippref = &gid_address_ippref (&leid);
456  reid_ippref = &gid_address_ippref (&reid);
457 
458  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
459  {
460  if (unformat (line_input, "del"))
461  is_add = 0;
462  else if (unformat (line_input, "add"))
463  ;
464  else if (unformat (line_input, "reid %U",
465  unformat_ip_prefix, reid_ippref))
466  {
468  reid_set = 1;
469  }
470  else if (unformat (line_input, "reid %U", unformat_mac_address, dmac))
471  {
472  gid_address_type (&reid) = GID_ADDR_MAC;
473  reid_set = 1;
474  }
475  else if (unformat (line_input, "vni %u", &vni))
476  {
477  gid_address_vni (&leid) = vni;
478  gid_address_vni (&reid) = vni;
479  }
480  else if (unformat (line_input, "leid %U",
481  unformat_ip_prefix, leid_ippref))
482  {
484  leid_set = 1;
485  }
486  else if (unformat (line_input, "leid %U", unformat_mac_address, smac))
487  {
488  gid_address_type (&leid) = GID_ADDR_MAC;
489  leid_set = 1;
490  }
491  else
492  {
493  clib_warning ("parse error");
494  goto done;
495  }
496  }
497 
498  if (!reid_set || !leid_set)
499  {
500  clib_warning ("missing remote or local eid!");
501  goto done;
502  }
503 
504  if ((gid_address_type (&leid) != gid_address_type (&reid))
505  || (gid_address_type (&reid) == GID_ADDR_IP_PREFIX
506  && ip_prefix_version (reid_ippref)
507  != ip_prefix_version (leid_ippref)))
508  {
509  clib_warning ("remote and local EIDs are of different types!");
510  goto done;
511  }
512 
513  memset (a, 0, sizeof (a[0]));
514  gid_address_copy (&a->leid, &leid);
515  gid_address_copy (&a->reid, &reid);
516  a->is_add = is_add;
517 
519  clib_warning ("failed to %s adjacency!", is_add ? "add" : "delete");
520 
521 done:
522  unformat_free (line_input);
523  return error;
524 }
525 
526 /* *INDENT-OFF* */
527 VLIB_CLI_COMMAND (lisp_add_del_adjacency_command) = {
528  .path = "lisp adjacency",
529  .short_help = "lisp adjacency add|del vni <vni> reid <remote-eid> "
530  "leid <local-eid>",
532 };
533 /* *INDENT-ON* */
534 
535 
536 static clib_error_t *
538  unformat_input_t * input,
539  vlib_cli_command_t * cmd)
540 {
541  unformat_input_t _i, *i = &_i;
542  map_request_mode_t mr_mode = _MR_MODE_MAX;
543  clib_error_t *error = NULL;
544 
545  /* Get a line of input. */
546  if (!unformat_user (input, unformat_line_input, i))
547  return 0;
548 
550  {
551  if (unformat (i, "dst-only"))
552  mr_mode = MR_MODE_DST_ONLY;
553  else if (unformat (i, "src-dst"))
554  mr_mode = MR_MODE_SRC_DST;
555  else
556  {
557  clib_warning ("parse error '%U'", format_unformat_error, i);
558  goto done;
559  }
560  }
561 
562  if (_MR_MODE_MAX == mr_mode)
563  {
564  clib_warning ("No LISP map request mode entered!");
565  goto done;
566  }
567 
569 
570 done:
571  unformat_free (i);
572 
573  return error;
574 }
575 
576 /* *INDENT-OFF* */
577 VLIB_CLI_COMMAND (lisp_map_request_mode_command) = {
578  .path = "lisp map-request mode",
579  .short_help = "lisp map-request mode dst-only|src-dst",
581 };
582 /* *INDENT-ON* */
583 
584 
585 static u8 *
586 format_lisp_map_request_mode (u8 * s, va_list * args)
587 {
588  u32 mode = va_arg (*args, u32);
589 
590  switch (mode)
591  {
592  case 0:
593  return format (0, "dst-only");
594  case 1:
595  return format (0, "src-dst");
596  }
597  return 0;
598 }
599 
600 static clib_error_t *
602  unformat_input_t * input,
603  vlib_cli_command_t * cmd)
604 {
605  vlib_cli_output (vm, "map-request mode: %U", format_lisp_map_request_mode,
607  return 0;
608 }
609 
610 /* *INDENT-OFF* */
611 VLIB_CLI_COMMAND (lisp_show_map_request_mode_command) = {
612  .path = "show lisp map-request mode",
613  .short_help = "show lisp map-request mode",
615 };
616 /* *INDENT-ON* */
617 
618 static clib_error_t *
620  unformat_input_t * input,
621  vlib_cli_command_t * cmd)
622 {
623  lisp_msmr_t *mr;
625 
626  vec_foreach (mr, lcm->map_resolvers)
627  {
628  vlib_cli_output (vm, "%U", format_ip_address, &mr->address);
629  }
630  return 0;
631 }
632 
633 /* *INDENT-OFF* */
634 VLIB_CLI_COMMAND (lisp_show_map_resolvers_command) = {
635  .path = "show lisp map-resolvers",
636  .short_help = "show lisp map-resolvers",
638 };
639 /* *INDENT-ON* */
640 
641 
642 static clib_error_t *
644  unformat_input_t * input,
645  vlib_cli_command_t * cmd)
646 {
647  u8 locator_name_set = 0;
648  u8 *locator_set_name = 0;
649  u8 is_add = 1;
650  unformat_input_t _line_input, *line_input = &_line_input;
651  clib_error_t *error = 0;
652  int rv = 0;
653 
654  /* Get a line of input. */
655  if (!unformat_user (input, unformat_line_input, line_input))
656  return 0;
657 
658  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
659  {
660  if (unformat (line_input, "ls %_%v%_", &locator_set_name))
661  locator_name_set = 1;
662  else if (unformat (line_input, "disable"))
663  is_add = 0;
664  else
665  {
666  error = clib_error_return (0, "parse error");
667  goto done;
668  }
669  }
670 
671  if (!locator_name_set)
672  {
673  clib_warning ("No locator set specified!");
674  goto done;
675  }
676  vec_terminate_c_string (locator_set_name);
677  rv = vnet_lisp_pitr_set_locator_set (locator_set_name, is_add);
678  if (0 != rv)
679  {
680  error = clib_error_return (0, "failed to %s pitr!",
681  is_add ? "add" : "delete");
682  }
683 
684 done:
685  if (locator_set_name)
686  vec_free (locator_set_name);
687  unformat_free (line_input);
688 
689  return error;
690 }
691 
692 /* *INDENT-OFF* */
693 VLIB_CLI_COMMAND (lisp_pitr_set_locator_set_command) = {
694  .path = "lisp pitr",
695  .short_help = "lisp pitr [disable] ls <locator-set-name>",
697 };
698 /* *INDENT-ON* */
699 
700 static clib_error_t *
702  unformat_input_t * input, vlib_cli_command_t * cmd)
703 {
705  mapping_t *m;
706  locator_set_t *ls;
707  u8 *tmp_str = 0;
708  u8 status = lcm->flags & LISP_FLAG_PITR_MODE;
709 
710  vlib_cli_output (vm, "%=20s%=16s", "pitr", status ? "locator-set" : "");
711 
712  if (!status)
713  {
714  vlib_cli_output (vm, "%=20s", "disable");
715  return 0;
716  }
717 
718  if (~0 == lcm->pitr_map_index)
719  {
720  tmp_str = format (0, "N/A");
721  }
722  else
723  {
725  if (~0 != m->locator_set_index)
726  {
727  ls =
729  tmp_str = format (0, "%s", ls->name);
730  }
731  else
732  {
733  tmp_str = format (0, "N/A");
734  }
735  }
736  vec_add1 (tmp_str, 0);
737 
738  vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
739 
740  vec_free (tmp_str);
741 
742  return 0;
743 }
744 
745 /* *INDENT-OFF* */
746 VLIB_CLI_COMMAND (lisp_show_pitr_command) = {
747  .path = "show lisp pitr",
748  .short_help = "Show pitr",
749  .function = lisp_show_pitr_command_fn,
750 };
751 /* *INDENT-ON* */
752 
753 static u8 *
754 format_eid_entry (u8 * s, va_list * args)
755 {
756  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
757  lisp_cp_main_t *lcm = va_arg (*args, lisp_cp_main_t *);
758  mapping_t *mapit = va_arg (*args, mapping_t *);
759  locator_set_t *ls = va_arg (*args, locator_set_t *);
760  gid_address_t *gid = &mapit->eid;
761  u32 ttl = mapit->ttl;
762  u8 aut = mapit->authoritative;
763  u32 *loc_index;
764  u8 first_line = 1;
765  u8 *loc;
766 
767  u8 *type = ls->local ? format (0, "local(%s)", ls->name)
768  : format (0, "remote");
769 
770  if (vec_len (ls->locator_indices) == 0)
771  {
772  s = format (s, "%-35U%-30s%-20u%-u", format_gid_address, gid,
773  type, ttl, aut);
774  }
775  else
776  {
777  vec_foreach (loc_index, ls->locator_indices)
778  {
779  locator_t *l = pool_elt_at_index (lcm->locator_pool, loc_index[0]);
780  if (l->local)
781  loc = format (0, "%U", format_vnet_sw_if_index_name, vnm,
782  l->sw_if_index);
783  else
784  loc = format (0, "%U", format_ip_address,
785  &gid_address_ip (&l->address));
786 
787  if (first_line)
788  {
789  s = format (s, "%-35U%-20s%-30v%-20u%-u\n", format_gid_address,
790  gid, type, loc, ttl, aut);
791  first_line = 0;
792  }
793  else
794  s = format (s, "%55s%v\n", "", loc);
795  }
796  }
797  return s;
798 }
799 
800 static clib_error_t *
802  unformat_input_t * input,
803  vlib_cli_command_t * cmd)
804 {
806  mapping_t *mapit;
807  unformat_input_t _line_input, *line_input = &_line_input;
808  u32 mi;
809  gid_address_t eid;
810  u8 print_all = 1;
811  u8 filter = 0;
812  clib_error_t *error = NULL;
813 
814  memset (&eid, 0, sizeof (eid));
815 
816  /* Get a line of input. */
817  if (!unformat_user (input, unformat_line_input, line_input))
818  return 0;
819 
820  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
821  {
822  if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
823  print_all = 0;
824  else if (unformat (line_input, "local"))
825  filter = 1;
826  else if (unformat (line_input, "remote"))
827  filter = 2;
828  else
829  {
830  error = clib_error_return (0, "parse error: '%U'",
831  format_unformat_error, line_input);
832  goto done;
833  }
834  }
835 
836  vlib_cli_output (vm, "%-35s%-20s%-30s%-20s%-s",
837  "EID", "type", "locators", "ttl", "autoritative");
838 
839  if (print_all)
840  {
841  /* *INDENT-OFF* */
842  pool_foreach (mapit, lcm->mapping_pool,
843  ({
844  if (mapit->pitr_set)
845  continue;
846 
847  locator_set_t * ls = pool_elt_at_index (lcm->locator_set_pool,
848  mapit->locator_set_index);
849  if (filter && !((1 == filter && ls->local) ||
850  (2 == filter && !ls->local)))
851  {
852  continue;
853  }
854  vlib_cli_output (vm, "%U", format_eid_entry, lcm->vnet_main,
855  lcm, mapit, ls);
856  }));
857  /* *INDENT-ON* */
858  }
859  else
860  {
861  mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &eid);
862  if ((u32) ~ 0 == mi)
863  goto done;
864 
865  mapit = pool_elt_at_index (lcm->mapping_pool, mi);
866  locator_set_t *ls = pool_elt_at_index (lcm->locator_set_pool,
867  mapit->locator_set_index);
868 
869  if (filter && !((1 == filter && ls->local) ||
870  (2 == filter && !ls->local)))
871  {
872  goto done;
873  }
874 
875  vlib_cli_output (vm, "%U,", format_eid_entry, lcm->vnet_main,
876  lcm, mapit, ls);
877  }
878 
879 done:
880  unformat_free (line_input);
881 
882  return error;
883 }
884 
885 /* *INDENT-OFF* */
886 VLIB_CLI_COMMAND (lisp_cp_show_eid_table_command) = {
887  .path = "show lisp eid-table",
888  .short_help = "Shows EID table",
889  .function = lisp_show_eid_table_command_fn,
890 };
891 /* *INDENT-ON* */
892 
893 
894 static clib_error_t *
896  vlib_cli_command_t * cmd)
897 {
898  unformat_input_t _line_input, *line_input = &_line_input;
899  u8 is_enabled = 0;
900  u8 is_set = 0;
901  clib_error_t *error = NULL;
902 
903  /* Get a line of input. */
904  if (!unformat_user (input, unformat_line_input, line_input))
905  return clib_error_return (0, "expected enable | disable");
906 
907  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
908  {
909  if (unformat (line_input, "enable"))
910  {
911  is_set = 1;
912  is_enabled = 1;
913  }
914  else if (unformat (line_input, "disable"))
915  is_set = 1;
916  else
917  {
918  error = clib_error_return (0, "parse error: '%U'",
919  format_unformat_error, line_input);
920  goto done;
921  }
922  }
923 
924  if (!is_set)
925  {
926  error = clib_error_return (0, "state not set");
927  goto done;
928  }
929 
930  vnet_lisp_enable_disable (is_enabled);
931 
932 done:
933  unformat_free (line_input);
934 
935  return error;
936 }
937 
938 /* *INDENT-OFF* */
939 VLIB_CLI_COMMAND (lisp_cp_enable_disable_command) = {
940  .path = "lisp",
941  .short_help = "lisp [enable|disable]",
942  .function = lisp_enable_disable_command_fn,
943 };
944 /* *INDENT-ON* */
945 
946 static clib_error_t *
948  unformat_input_t * input,
949  vlib_cli_command_t * cmd)
950 {
951  unformat_input_t _line_input, *line_input = &_line_input;
952  u8 is_enabled = 0;
953  u8 is_set = 0;
954  clib_error_t *error = NULL;
955 
956  /* Get a line of input. */
957  if (!unformat_user (input, unformat_line_input, line_input))
958  return clib_error_return (0, "expected enable | disable");
959 
960  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
961  {
962  if (unformat (line_input, "enable"))
963  {
964  is_set = 1;
965  is_enabled = 1;
966  }
967  else if (unformat (line_input, "disable"))
968  is_set = 1;
969  else
970  {
971  vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
972  line_input);
973  goto done;
974  }
975  }
976 
977  if (!is_set)
978  {
979  vlib_cli_output (vm, "state not set!");
980  goto done;
981  }
982 
984 
985 done:
986  unformat_free (line_input);
987 
988  return error;
989 }
990 
991 /* *INDENT-OFF* */
992 VLIB_CLI_COMMAND (lisp_map_register_enable_disable_command) = {
993  .path = "lisp map-register",
994  .short_help = "lisp map-register [enable|disable]",
996 };
997 /* *INDENT-ON* */
998 
999 static clib_error_t *
1001  unformat_input_t * input,
1002  vlib_cli_command_t * cmd)
1003 {
1004  unformat_input_t _line_input, *line_input = &_line_input;
1005  u8 is_enabled = 0;
1006  u8 is_set = 0;
1007  clib_error_t *error = NULL;
1008 
1009  /* Get a line of input. */
1010  if (!unformat_user (input, unformat_line_input, line_input))
1011  return clib_error_return (0, "expected enable | disable");
1012 
1013  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1014  {
1015  if (unformat (line_input, "enable"))
1016  {
1017  is_set = 1;
1018  is_enabled = 1;
1019  }
1020  else if (unformat (line_input, "disable"))
1021  is_set = 1;
1022  else
1023  {
1024  vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1025  line_input);
1026  goto done;
1027  }
1028  }
1029 
1030  if (!is_set)
1031  {
1032  vlib_cli_output (vm, "state not set!");
1033  goto done;
1034  }
1035 
1037 
1038 done:
1039  unformat_free (line_input);
1040 
1041  return error;
1042 }
1043 
1044 /* *INDENT-OFF* */
1045 VLIB_CLI_COMMAND (lisp_rloc_probe_enable_disable_command) = {
1046  .path = "lisp rloc-probe",
1047  .short_help = "lisp rloc-probe [enable|disable]",
1049 };
1050 /* *INDENT-ON* */
1051 
1052 static u8 *
1053 format_lisp_status (u8 * s, va_list * args)
1054 {
1056  return format (s, "%s", lcm->is_enabled ? "enabled" : "disabled");
1057 }
1058 
1059 static clib_error_t *
1061  vlib_cli_command_t * cmd)
1062 {
1063  u8 *msg = 0;
1064  msg = format (msg, "feature: %U\ngpe: %U\n",
1066  vlib_cli_output (vm, "%v", msg);
1067  vec_free (msg);
1068  return 0;
1069 }
1070 
1071 /* *INDENT-OFF* */
1072 VLIB_CLI_COMMAND (lisp_show_status_command) = {
1073  .path = "show lisp status",
1074  .short_help = "show lisp status",
1075  .function = lisp_show_status_command_fn,
1076 };
1077 /* *INDENT-ON* */
1078 
1079 static clib_error_t *
1081  unformat_input_t * input,
1082  vlib_cli_command_t * cmd)
1083 {
1084  hash_pair_t *p;
1085  unformat_input_t _line_input, *line_input = &_line_input;
1087  uword *vni_table = 0;
1088  u8 is_l2 = 0;
1089  clib_error_t *error = NULL;
1090 
1091  /* Get a line of input. */
1092  if (!unformat_user (input, unformat_line_input, line_input))
1093  return 0;
1094 
1095  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1096  {
1097  if (unformat (line_input, "l2"))
1098  {
1099  vni_table = lcm->bd_id_by_vni;
1100  is_l2 = 1;
1101  }
1102  else if (unformat (line_input, "l3"))
1103  {
1104  vni_table = lcm->table_id_by_vni;
1105  is_l2 = 0;
1106  }
1107  else
1108  {
1109  error = clib_error_return (0, "parse error: '%U'",
1110  format_unformat_error, line_input);
1111  goto done;
1112  }
1113  }
1114 
1115  if (!vni_table)
1116  {
1117  vlib_cli_output (vm, "Error: expected l2|l3 param!\n");
1118  goto done;
1119  }
1120 
1121  vlib_cli_output (vm, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
1122 
1123  /* *INDENT-OFF* */
1124  hash_foreach_pair (p, vni_table,
1125  ({
1126  vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]);
1127  }));
1128  /* *INDENT-ON* */
1129 
1130 done:
1131  unformat_free (line_input);
1132 
1133  return error;
1134 }
1135 
1136 /* *INDENT-OFF* */
1137 VLIB_CLI_COMMAND (lisp_show_eid_table_map_command) = {
1138  .path = "show lisp eid-table map",
1139  .short_help = "show lisp eid-table l2|l3",
1141 };
1142 /* *INDENT-ON* */
1143 
1144 
1145 static clib_error_t *
1147  unformat_input_t * input,
1148  vlib_cli_command_t * cmd)
1149 {
1151  vnet_main_t *vnm = lgm->vnet_main;
1152  unformat_input_t _line_input, *line_input = &_line_input;
1153  u8 is_add = 1;
1154  clib_error_t *error = 0;
1155  u8 *locator_set_name = 0;
1156  locator_t locator, *locators = 0;
1158  u32 ls_index = 0;
1159  int rv = 0;
1160 
1161  memset (&locator, 0, sizeof (locator));
1162  memset (a, 0, sizeof (a[0]));
1163 
1164  /* Get a line of input. */
1165  if (!unformat_user (input, unformat_line_input, line_input))
1166  return 0;
1167 
1168  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1169  {
1170  if (unformat (line_input, "add %_%v%_", &locator_set_name))
1171  is_add = 1;
1172  else if (unformat (line_input, "del %_%v%_", &locator_set_name))
1173  is_add = 0;
1174  else if (unformat (line_input, "iface %U p %d w %d",
1176  &locator.sw_if_index, &locator.priority,
1177  &locator.weight))
1178  {
1179  locator.local = 1;
1180  vec_add1 (locators, locator);
1181  }
1182  else
1183  {
1184  error = unformat_parse_error (line_input);
1185  goto done;
1186  }
1187  }
1188 
1189  a->name = locator_set_name;
1190  a->locators = locators;
1191  a->is_add = is_add;
1192  a->local = 1;
1193 
1194  rv = vnet_lisp_add_del_locator_set (a, &ls_index);
1195  if (0 != rv)
1196  {
1197  error = clib_error_return (0, "failed to %s locator-set!",
1198  is_add ? "add" : "delete");
1199  }
1200 
1201 done:
1202  vec_free (locators);
1203  if (locator_set_name)
1204  vec_free (locator_set_name);
1205  unformat_free (line_input);
1206 
1207  return error;
1208 }
1209 
1210 /* *INDENT-OFF* */
1211 VLIB_CLI_COMMAND (lisp_cp_add_del_locator_set_command) = {
1212  .path = "lisp locator-set",
1213  .short_help = "lisp locator-set add/del <name> [iface <iface-name> "
1214  "p <priority> w <weight>]",
1216 };
1217 /* *INDENT-ON* */
1218 
1219 static clib_error_t *
1221  unformat_input_t * input,
1222  vlib_cli_command_t * cmd)
1223 {
1225  vnet_main_t *vnm = lgm->vnet_main;
1226  unformat_input_t _line_input, *line_input = &_line_input;
1227  u8 is_add = 1;
1228  clib_error_t *error = 0;
1229  u8 *locator_set_name = 0;
1230  u8 locator_set_name_set = 0;
1231  locator_t locator, *locators = 0;
1233  u32 ls_index = 0;
1234 
1235  memset (&locator, 0, sizeof (locator));
1236  memset (a, 0, sizeof (a[0]));
1237 
1238  /* Get a line of input. */
1239  if (!unformat_user (input, unformat_line_input, line_input))
1240  return 0;
1241 
1242  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1243  {
1244  if (unformat (line_input, "add"))
1245  is_add = 1;
1246  else if (unformat (line_input, "del"))
1247  is_add = 0;
1248  else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name))
1249  locator_set_name_set = 1;
1250  else if (unformat (line_input, "iface %U p %d w %d",
1252  &locator.sw_if_index, &locator.priority,
1253  &locator.weight))
1254  {
1255  locator.local = 1;
1256  vec_add1 (locators, locator);
1257  }
1258  else
1259  {
1260  error = unformat_parse_error (line_input);
1261  goto done;
1262  }
1263  }
1264 
1265  if (!locator_set_name_set)
1266  {
1267  error = clib_error_return (0, "locator_set name not set!");
1268  goto done;
1269  }
1270 
1271  a->name = locator_set_name;
1272  a->locators = locators;
1273  a->is_add = is_add;
1274  a->local = 1;
1275 
1276  vnet_lisp_add_del_locator (a, 0, &ls_index);
1277 
1278 done:
1279  vec_free (locators);
1280  vec_free (locator_set_name);
1281  unformat_free (line_input);
1282 
1283  return error;
1284 }
1285 
1286 /* *INDENT-OFF* */
1287 VLIB_CLI_COMMAND (lisp_cp_add_del_locator_in_set_command) = {
1288  .path = "lisp locator",
1289  .short_help = "lisp locator add/del locator-set <name> iface <iface-name> "
1290  "p <priority> w <weight>",
1292 };
1293 /* *INDENT-ON* */
1294 
1295 static clib_error_t *
1297  unformat_input_t * input,
1298  vlib_cli_command_t * cmd)
1299 {
1300  locator_set_t *lsit;
1301  locator_t *loc;
1302  u32 *locit;
1304 
1305  vlib_cli_output (vm, "%s%=16s%=16s%=16s", "Locator-set", "Locator",
1306  "Priority", "Weight");
1307 
1308  /* *INDENT-OFF* */
1309  pool_foreach (lsit, lcm->locator_set_pool,
1310  ({
1311  u8 * msg = 0;
1312  int next_line = 0;
1313  if (lsit->local)
1314  {
1315  msg = format (msg, "%v", lsit->name);
1316  }
1317  else
1318  {
1319  msg = format (msg, "<%s-%d>", "remote", lsit - lcm->locator_set_pool);
1320  }
1321  vec_foreach (locit, lsit->locator_indices)
1322  {
1323  if (next_line)
1324  {
1325  msg = format (msg, "%16s", " ");
1326  }
1327  loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
1328  if (loc->local)
1329  msg = format (msg, "%16d%16d%16d\n", loc->sw_if_index, loc->priority,
1330  loc->weight);
1331  else
1332  msg = format (msg, "%16U%16d%16d\n", format_ip_address,
1333  &gid_address_ip(&loc->address), loc->priority,
1334  loc->weight);
1335  next_line = 1;
1336  }
1337  vlib_cli_output (vm, "%v", msg);
1338  vec_free (msg);
1339  }));
1340  /* *INDENT-ON* */
1341  return 0;
1342 }
1343 
1344 /* *INDENT-OFF* */
1345 VLIB_CLI_COMMAND (lisp_cp_show_locator_sets_command) = {
1346  .path = "show lisp locator-set",
1347  .short_help = "Shows locator-sets",
1349 };
1350 /* *INDENT-ON* */
1351 
1352 
1353 static clib_error_t *
1355  unformat_input_t * input,
1356  vlib_cli_command_t * cmd)
1357 {
1358  unformat_input_t _line_input, *line_input = &_line_input;
1359  u8 is_add = 1, addr_set = 0;
1360  ip_address_t ip_addr;
1361  clib_error_t *error = 0;
1362  int rv = 0;
1364 
1365  /* Get a line of input. */
1366  if (!unformat_user (input, unformat_line_input, line_input))
1367  return 0;
1368 
1369  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1370  {
1371  if (unformat (line_input, "add"))
1372  is_add = 1;
1373  else if (unformat (line_input, "del"))
1374  is_add = 0;
1375  else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr))
1376  addr_set = 1;
1377  else
1378  {
1379  error = unformat_parse_error (line_input);
1380  goto done;
1381  }
1382  }
1383 
1384  if (!addr_set)
1385  {
1386  error = clib_error_return (0, "Map-resolver address must be set!");
1387  goto done;
1388  }
1389 
1390  a->is_add = is_add;
1391  a->address = ip_addr;
1393  if (0 != rv)
1394  {
1395  error = clib_error_return (0, "failed to %s map-resolver!",
1396  is_add ? "add" : "delete");
1397  }
1398 
1399 done:
1400  unformat_free (line_input);
1401 
1402  return error;
1403 }
1404 
1405 /* *INDENT-OFF* */
1406 VLIB_CLI_COMMAND (lisp_add_del_map_resolver_command) = {
1407  .path = "lisp map-resolver",
1408  .short_help = "lisp map-resolver add/del <ip_address>",
1410 };
1411 /* *INDENT-ON* */
1412 
1413 
1414 static clib_error_t *
1416  unformat_input_t * input,
1417  vlib_cli_command_t * cmd)
1418 {
1419  unformat_input_t _line_input, *line_input = &_line_input;
1420  u8 is_add = 1;
1421  u8 *locator_set_name = 0;
1422  clib_error_t *error = 0;
1423  int rv = 0;
1425 
1426  /* Get a line of input. */
1427  if (!unformat_user (input, unformat_line_input, line_input))
1428  return 0;
1429 
1430  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1431  {
1432  if (unformat (line_input, "del"))
1433  is_add = 0;
1434  else if (unformat (line_input, "add %_%v%_", &locator_set_name))
1435  is_add = 1;
1436  else
1437  {
1438  error = unformat_parse_error (line_input);
1439  goto done;
1440  }
1441  }
1442 
1443  vec_terminate_c_string (locator_set_name);
1444  a->is_add = is_add;
1445  a->locator_set_name = locator_set_name;
1447  if (0 != rv)
1448  {
1449  error = clib_error_return (0, "failed to %s map-request itr-rlocs!",
1450  is_add ? "add" : "delete");
1451  }
1452 
1453 done:
1454  vec_free (locator_set_name);
1455  unformat_free (line_input);
1456 
1457  return error;
1458 }
1459 
1460 /* *INDENT-OFF* */
1461 VLIB_CLI_COMMAND (lisp_add_del_map_request_command) = {
1462  .path = "lisp map-request itr-rlocs",
1463  .short_help = "lisp map-request itr-rlocs add/del <locator_set_name>",
1465 };
1466 /* *INDENT-ON* */
1467 
1468 static clib_error_t *
1470  unformat_input_t * input,
1471  vlib_cli_command_t * cmd)
1472 {
1474  locator_set_t *loc_set;
1475 
1476  vlib_cli_output (vm, "%=20s", "itr-rlocs");
1477 
1478  if (~0 == lcm->mreq_itr_rlocs)
1479  {
1480  return 0;
1481  }
1482 
1483  loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1484 
1485  vlib_cli_output (vm, "%=20s", loc_set->name);
1486 
1487  return 0;
1488 }
1489 
1490 /* *INDENT-OFF* */
1491 VLIB_CLI_COMMAND (lisp_show_map_request_command) = {
1492  .path = "show lisp map-request itr-rlocs",
1493  .short_help = "Shows map-request itr-rlocs",
1495 };
1496 /* *INDENT-ON* */
1497 
1498 static clib_error_t *
1500  unformat_input_t * input,
1501  vlib_cli_command_t * cmd)
1502 {
1503  u8 is_add = 1, ip_set = 0;
1504  unformat_input_t _line_input, *line_input = &_line_input;
1505  clib_error_t *error = 0;
1506  ip_address_t ip;
1507 
1508  /* Get a line of input. */
1509  if (!unformat_user (input, unformat_line_input, line_input))
1510  return 0;
1511 
1512  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1513  {
1514  if (unformat (line_input, "%U", unformat_ip_address, &ip))
1515  ip_set = 1;
1516  else if (unformat (line_input, "disable"))
1517  is_add = 0;
1518  else
1519  {
1520  error = clib_error_return (0, "parse error");
1521  goto done;
1522  }
1523  }
1524 
1525  if (!ip_set)
1526  {
1527  clib_warning ("No petr IP specified!");
1528  goto done;
1529  }
1530 
1531  if (vnet_lisp_use_petr (&ip, is_add))
1532  {
1533  error = clib_error_return (0, "failed to %s petr!",
1534  is_add ? "add" : "delete");
1535  }
1536 
1537 done:
1538  unformat_free (line_input);
1539 
1540  return error;
1541 }
1542 
1543 /* *INDENT-OFF* */
1544 VLIB_CLI_COMMAND (lisp_use_petr_set_locator_set_command) = {
1545  .path = "lisp use-petr",
1546  .short_help = "lisp use-petr [disable] <petr-ip>",
1548 };
1549 
1550 static clib_error_t *
1552  unformat_input_t * input, vlib_cli_command_t * cmd)
1553 {
1555  mapping_t *m;
1556  locator_set_t *ls;
1557  locator_t *loc;
1558  u8 *tmp_str = 0;
1559  u8 use_petr = lcm->flags & LISP_FLAG_USE_PETR;
1560  vlib_cli_output (vm, "%=20s%=16s", "petr", use_petr ? "ip" : "");
1561 
1562  if (!use_petr)
1563  {
1564  vlib_cli_output (vm, "%=20s", "disable");
1565  return 0;
1566  }
1567 
1568  if (~0 == lcm->petr_map_index)
1569  {
1570  tmp_str = format (0, "N/A");
1571  }
1572  else
1573  {
1575  if (~0 != m->locator_set_index)
1576  {
1578  loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
1579  tmp_str = format (0, "%U", format_ip_address, &loc->address);
1580  }
1581  else
1582  {
1583  tmp_str = format (0, "N/A");
1584  }
1585  }
1586  vec_add1 (tmp_str, 0);
1587 
1588  vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
1589 
1590  vec_free (tmp_str);
1591 
1592  return 0;
1593 }
1594 
1595 /* *INDENT-OFF* */
1596 VLIB_CLI_COMMAND (lisp_show_petr_command) = {
1597  .path = "show lisp petr",
1598  .short_help = "Show petr",
1599  .function = lisp_show_petr_command_fn,
1600 };
1601 /* *INDENT-ON* */
1602 
1603 /*
1604  * fd.io coding-style-patch-verification: ON
1605  *
1606  * Local Variables:
1607  * eval: (c-set-style "gnu")
1608  * End:
1609  */
#define gid_address_ip_version(_a)
Definition: lisp_types.h:265
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:701
u32 pitr_map_index
Definition: control.h:250
gid_address_t leid
Definition: control.h:73
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
#define gid_address_type(_a)
Definition: lisp_types.h:261
a
Definition: bitmap.h:516
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:1499
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:1469
lisp_msmr_t * map_resolvers
Definition: control.h:220
static u8 * format_lisp_status(u8 *s, va_list *args)
Definition: lisp_cli.c:1053
uword * table_id_by_vni
Definition: control.h:239
void ip_set(ip46_address_t *dst, void *src, u8 is_ip4)
Definition: ip.c:76
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:1000
static u8 * format_lisp_map_request_mode(u8 *s, va_list *args)
Definition: lisp_cli.c:586
#define NULL
Definition: clib.h:55
locator_t * locator_pool
Definition: control.h:177
LISP-GPE global state.
Definition: lisp_gpe.h:118
u8 vnet_lisp_get_map_request_mode(void)
Definition: control.c:57
#define ip_prefix_len(_a)
Definition: lisp_types.h:73
#define vec_terminate_c_string(V)
(If necessary) NULL terminate a vector containing a c-string.
Definition: vec.h:990
uword unformat_ip_address(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:164
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:1080
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:518
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
unformat_function_t unformat_vnet_sw_interface
ip_address_t address
Definition: control.h:88
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:1279
static clib_error_t * lisp_enable_disable_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: lisp_cli.c:895
uword unformat_hmac_key_id(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:325
#define ip_prefix_version(_a)
Definition: lisp_types.h:72
format_function_t format_vnet_sw_if_index_name
int vnet_lisp_set_map_request_mode(u8 mode)
Definition: control.c:1559
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:1488
uword value[0]
Definition: hash.h:164
uword unformat_negative_mapping_action(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:391
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:438
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:434
#define clib_error_return(e, args...)
Definition: error.h:99
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:1296
int vnet_lisp_eid_table_map(u32 vni, u32 dp_id, u8 is_l2, u8 is_add)
Definition: control.c:1079
uword * bd_id_by_vni
Definition: control.h:243
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:301
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:601
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:1415
u32 petr_map_index
Proxy ETR map index used for &#39;use-petr&#39;.
Definition: control.h:254
unformat_function_t unformat_line_input
Definition: format.h:281
clib_error_t * vnet_lisp_enable_disable(u8 is_enable)
Definition: control.c:2260
int vnet_lisp_pitr_set_locator_set(u8 *locator_set_name, u8 is_add)
Definition: control.c:1631
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:459
#define gid_address_mac(_a)
Definition: lisp_types.h:267
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:884
void gid_address_free(gid_address_t *a)
Definition: lisp_types.c:850
u8 authoritative
Definition: lisp_types.h:363
uword unformat_gid_address(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:350
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:1551
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:947
u8 * format_gid_address(u8 *s, va_list *args)
Definition: lisp_types.c:265
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:537
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:643
#define gid_address_ippref(_a)
Definition: lisp_types.h:262
lisp_adjacency_t * vnet_lisp_adjacencies_get_by_vni(u32 vni)
Returns vector of adjacencies.
Definition: control.c:627
u32 sw_if_index
Definition: lisp_types.h:324
static u8 * format_eid_entry(u8 *s, va_list *args)
Definition: lisp_cli.c:754
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
int vnet_lisp_add_del_mreq_itr_rlocs(vnet_lisp_add_del_mreq_itr_rloc_args_t *a)
Definition: control.c:2392
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
vlib_main_t * vm
Definition: buffer.c:283
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:1354
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
vnet_main_t * vnet_main
Definition: lisp_gpe.h:172
#define clib_warning(format, args...)
Definition: error.h:59
u32 locator_set_index
Definition: lisp_types.h:356
int vnet_lisp_map_register_enable_disable(u8 is_enable)
Definition: control.c:2194
lisp_gpe_main_t lisp_gpe_main
LISP-GPE global state.
Definition: lisp_gpe.c:30
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
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:1060
struct _gid_address_t gid_address_t
uword unformat_mac_address(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:207
u8 * format_vnet_lisp_gpe_status(u8 *s, va_list *args)
Format LISP-GPE status.
Definition: lisp_gpe.c:585
int vnet_lisp_add_del_map_server(ip_address_t *addr, u8 is_add)
Definition: control.c:681
unsigned int u32
Definition: types.h:88
u8 * format_ip_address(u8 *s, va_list *args)
Definition: lisp_types.c:144
int vnet_lisp_clear_all_remote_adjacencies(void)
Definition: control.c:1437
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
locator_set_t * locator_set_pool
Definition: control.h:180
int vnet_lisp_rloc_probe_enable_disable(u8 is_enable)
Definition: control.c:2185
u64 gid_dictionary_lookup(gid_dictionary_t *db, gid_address_t *key)
uword unformat_ip_prefix(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:187
u64 uword
Definition: types.h:112
#define unformat_parse_error(input)
Definition: format.h:267
int vnet_lisp_add_del_locator_set(vnet_lisp_add_del_locator_set_args_t *a, u32 *ls_result)
Definition: control.c:2045
#define gid_address_ip(_a)
Definition: lisp_types.h:264
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:1220
#define gid_address_vni(_a)
Definition: lisp_types.h:271
map_request_mode_t
Definition: control.h:112
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:372
static void unformat_free(unformat_input_t *i)
Definition: format.h:161
int vnet_lisp_del_mapping(gid_address_t *eid, u32 *res_map_index)
Removes a mapping.
Definition: control.c:1388
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:1941
mapping_t * mapping_pool
Definition: control.h:171
u8 ip_address_max_len(u8 version)
Definition: lisp_types.c:549
uword * locator_set_index_by_name
Definition: control.h:186
void gid_address_copy(gid_address_t *dst, gid_address_t *src)
Definition: lisp_types.c:1495
gid_address_t eid
Definition: lisp_types.h:351
gid_address_t reid
Definition: control.h:74
gid_address_t address
Definition: lisp_types.h:325
#define hash_get_mem(h, key)
Definition: hash.h:268
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:1146
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:2329
#define vec_foreach(var, vec)
Vector iterator.
int vnet_lisp_use_petr(ip_address_t *ip, u8 is_add)
Configure Proxy-ETR.
Definition: control.c:1698
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:801
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:680
u32 mreq_itr_rlocs
Definition: control.h:236
u32 * locator_indices
Definition: lisp_types.h:345
vnet_main_t * vnet_main
Definition: control.h:288
uword key
Definition: hash.h:161
LISP-GPE definitions.
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
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:619
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:169