FD.io VPP  v19.08.1-401-g8e4ed521a
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;
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  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;
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  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 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  clib_memset (&reid, 0, sizeof (reid));
453  clib_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  clib_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  clib_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", "authoritative");
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  clib_memset (&locator, 0, sizeof (locator));
1162  clib_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  locator.state = 1;
1181  vec_add1 (locators, locator);
1182  }
1183  else
1184  {
1185  error = unformat_parse_error (line_input);
1186  goto done;
1187  }
1188  }
1189 
1190  a->name = locator_set_name;
1191  a->locators = locators;
1192  a->is_add = is_add;
1193  a->local = 1;
1194 
1195  rv = vnet_lisp_add_del_locator_set (a, &ls_index);
1196  if (0 != rv)
1197  {
1198  error = clib_error_return (0, "failed to %s locator-set!",
1199  is_add ? "add" : "delete");
1200  }
1201 
1202 done:
1203  vec_free (locators);
1204  if (locator_set_name)
1205  vec_free (locator_set_name);
1206  unformat_free (line_input);
1207 
1208  return error;
1209 }
1210 
1211 /* *INDENT-OFF* */
1212 VLIB_CLI_COMMAND (lisp_cp_add_del_locator_set_command) = {
1213  .path = "lisp locator-set",
1214  .short_help = "lisp locator-set add/del <name> [iface <iface-name> "
1215  "p <priority> w <weight>]",
1217 };
1218 /* *INDENT-ON* */
1219 
1220 static clib_error_t *
1222  unformat_input_t * input,
1223  vlib_cli_command_t * cmd)
1224 {
1226  vnet_main_t *vnm = lgm->vnet_main;
1227  unformat_input_t _line_input, *line_input = &_line_input;
1228  u8 is_add = 1;
1229  clib_error_t *error = 0;
1230  u8 *locator_set_name = 0;
1231  u8 locator_set_name_set = 0;
1232  locator_t locator, *locators = 0;
1234  u32 ls_index = 0;
1235 
1236  clib_memset (&locator, 0, sizeof (locator));
1237  clib_memset (a, 0, sizeof (a[0]));
1238 
1239  /* Get a line of input. */
1240  if (!unformat_user (input, unformat_line_input, line_input))
1241  return 0;
1242 
1243  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1244  {
1245  if (unformat (line_input, "add"))
1246  is_add = 1;
1247  else if (unformat (line_input, "del"))
1248  is_add = 0;
1249  else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name))
1250  locator_set_name_set = 1;
1251  else if (unformat (line_input, "iface %U p %d w %d",
1253  &locator.sw_if_index, &locator.priority,
1254  &locator.weight))
1255  {
1256  locator.local = 1;
1257  vec_add1 (locators, locator);
1258  }
1259  else
1260  {
1261  error = unformat_parse_error (line_input);
1262  goto done;
1263  }
1264  }
1265 
1266  if (!locator_set_name_set)
1267  {
1268  error = clib_error_return (0, "locator_set name not set!");
1269  goto done;
1270  }
1271 
1272  a->name = locator_set_name;
1273  a->locators = locators;
1274  a->is_add = is_add;
1275  a->local = 1;
1276 
1277  vnet_lisp_add_del_locator (a, 0, &ls_index);
1278 
1279 done:
1280  vec_free (locators);
1281  vec_free (locator_set_name);
1282  unformat_free (line_input);
1283 
1284  return error;
1285 }
1286 
1287 /* *INDENT-OFF* */
1288 VLIB_CLI_COMMAND (lisp_cp_add_del_locator_in_set_command) = {
1289  .path = "lisp locator",
1290  .short_help = "lisp locator add/del locator-set <name> iface <iface-name> "
1291  "p <priority> w <weight>",
1293 };
1294 /* *INDENT-ON* */
1295 
1296 static clib_error_t *
1298  unformat_input_t * input,
1299  vlib_cli_command_t * cmd)
1300 {
1301  locator_set_t *lsit;
1302  locator_t *loc;
1303  u32 *locit;
1305 
1306  vlib_cli_output (vm, "%s%=16s%=16s%=16s", "Locator-set", "Locator",
1307  "Priority", "Weight");
1308 
1309  /* *INDENT-OFF* */
1310  pool_foreach (lsit, lcm->locator_set_pool,
1311  ({
1312  u8 * msg = 0;
1313  int next_line = 0;
1314  if (lsit->local)
1315  {
1316  msg = format (msg, "%v", lsit->name);
1317  }
1318  else
1319  {
1320  msg = format (msg, "<%s-%d>", "remote", lsit - lcm->locator_set_pool);
1321  }
1322  vec_foreach (locit, lsit->locator_indices)
1323  {
1324  if (next_line)
1325  {
1326  msg = format (msg, "%16s", " ");
1327  }
1328  loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
1329  if (loc->local)
1330  msg = format (msg, "%16d%16d%16d\n", loc->sw_if_index, loc->priority,
1331  loc->weight);
1332  else
1333  msg = format (msg, "%16U%16d%16d\n", format_ip_address,
1334  &gid_address_ip(&loc->address), loc->priority,
1335  loc->weight);
1336  next_line = 1;
1337  }
1338  vlib_cli_output (vm, "%v", msg);
1339  vec_free (msg);
1340  }));
1341  /* *INDENT-ON* */
1342  return 0;
1343 }
1344 
1345 /* *INDENT-OFF* */
1346 VLIB_CLI_COMMAND (lisp_cp_show_locator_sets_command) = {
1347  .path = "show lisp locator-set",
1348  .short_help = "Shows locator-sets",
1350 };
1351 /* *INDENT-ON* */
1352 
1353 
1354 static clib_error_t *
1356  unformat_input_t * input,
1357  vlib_cli_command_t * cmd)
1358 {
1359  unformat_input_t _line_input, *line_input = &_line_input;
1360  u8 is_add = 1, addr_set = 0;
1361  ip_address_t ip_addr;
1362  clib_error_t *error = 0;
1363  int rv = 0;
1365 
1366  /* Get a line of input. */
1367  if (!unformat_user (input, unformat_line_input, line_input))
1368  return 0;
1369 
1370  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1371  {
1372  if (unformat (line_input, "add"))
1373  is_add = 1;
1374  else if (unformat (line_input, "del"))
1375  is_add = 0;
1376  else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr))
1377  addr_set = 1;
1378  else
1379  {
1380  error = unformat_parse_error (line_input);
1381  goto done;
1382  }
1383  }
1384 
1385  if (!addr_set)
1386  {
1387  error = clib_error_return (0, "Map-resolver address must be set!");
1388  goto done;
1389  }
1390 
1391  a->is_add = is_add;
1392  a->address = ip_addr;
1394  if (0 != rv)
1395  {
1396  error = clib_error_return (0, "failed to %s map-resolver!",
1397  is_add ? "add" : "delete");
1398  }
1399 
1400 done:
1401  unformat_free (line_input);
1402 
1403  return error;
1404 }
1405 
1406 /* *INDENT-OFF* */
1407 VLIB_CLI_COMMAND (lisp_add_del_map_resolver_command) = {
1408  .path = "lisp map-resolver",
1409  .short_help = "lisp map-resolver add/del <ip_address>",
1411 };
1412 /* *INDENT-ON* */
1413 
1414 
1415 static clib_error_t *
1417  unformat_input_t * input,
1418  vlib_cli_command_t * cmd)
1419 {
1420  unformat_input_t _line_input, *line_input = &_line_input;
1421  u8 is_add = 1;
1422  u8 *locator_set_name = 0;
1423  clib_error_t *error = 0;
1424  int rv = 0;
1426 
1427  /* Get a line of input. */
1428  if (!unformat_user (input, unformat_line_input, line_input))
1429  return 0;
1430 
1431  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1432  {
1433  if (unformat (line_input, "del"))
1434  is_add = 0;
1435  else if (unformat (line_input, "add %_%v%_", &locator_set_name))
1436  is_add = 1;
1437  else
1438  {
1439  error = unformat_parse_error (line_input);
1440  goto done;
1441  }
1442  }
1443 
1444  vec_terminate_c_string (locator_set_name);
1445  a->is_add = is_add;
1446  a->locator_set_name = locator_set_name;
1448  if (0 != rv)
1449  {
1450  error = clib_error_return (0, "failed to %s map-request itr-rlocs!",
1451  is_add ? "add" : "delete");
1452  }
1453 
1454 done:
1455  vec_free (locator_set_name);
1456  unformat_free (line_input);
1457 
1458  return error;
1459 }
1460 
1461 /* *INDENT-OFF* */
1462 VLIB_CLI_COMMAND (lisp_add_del_map_request_command) = {
1463  .path = "lisp map-request itr-rlocs",
1464  .short_help = "lisp map-request itr-rlocs add/del <locator_set_name>",
1466 };
1467 /* *INDENT-ON* */
1468 
1469 static clib_error_t *
1471  unformat_input_t * input,
1472  vlib_cli_command_t * cmd)
1473 {
1475  locator_set_t *loc_set;
1476 
1477  vlib_cli_output (vm, "%=20s", "itr-rlocs");
1478 
1479  if (~0 == lcm->mreq_itr_rlocs)
1480  {
1481  return 0;
1482  }
1483 
1484  loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1485 
1486  vlib_cli_output (vm, "%=20s", loc_set->name);
1487 
1488  return 0;
1489 }
1490 
1491 /* *INDENT-OFF* */
1492 VLIB_CLI_COMMAND (lisp_show_map_request_command) = {
1493  .path = "show lisp map-request itr-rlocs",
1494  .short_help = "Shows map-request itr-rlocs",
1496 };
1497 /* *INDENT-ON* */
1498 
1499 static clib_error_t *
1501  unformat_input_t * input,
1502  vlib_cli_command_t * cmd)
1503 {
1504  u8 is_add = 1, ip_set = 0;
1505  unformat_input_t _line_input, *line_input = &_line_input;
1506  clib_error_t *error = 0;
1507  ip_address_t ip;
1508 
1509  /* Get a line of input. */
1510  if (!unformat_user (input, unformat_line_input, line_input))
1511  return 0;
1512 
1513  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1514  {
1515  if (unformat (line_input, "%U", unformat_ip_address, &ip))
1516  ip_set = 1;
1517  else if (unformat (line_input, "disable"))
1518  is_add = 0;
1519  else
1520  {
1521  error = clib_error_return (0, "parse error");
1522  goto done;
1523  }
1524  }
1525 
1526  if (!ip_set)
1527  {
1528  clib_warning ("No petr IP specified!");
1529  goto done;
1530  }
1531 
1532  if (vnet_lisp_use_petr (&ip, is_add))
1533  {
1534  error = clib_error_return (0, "failed to %s petr!",
1535  is_add ? "add" : "delete");
1536  }
1537 
1538 done:
1539  unformat_free (line_input);
1540 
1541  return error;
1542 }
1543 
1544 /* *INDENT-OFF* */
1545 VLIB_CLI_COMMAND (lisp_use_petr_set_locator_set_command) = {
1546  .path = "lisp use-petr",
1547  .short_help = "lisp use-petr [disable] <petr-ip>",
1549 };
1550 
1551 static clib_error_t *
1553  unformat_input_t * input, vlib_cli_command_t * cmd)
1554 {
1556  mapping_t *m;
1557  locator_set_t *ls;
1558  locator_t *loc;
1559  u8 *tmp_str = 0;
1560  u8 use_petr = lcm->flags & LISP_FLAG_USE_PETR;
1561  vlib_cli_output (vm, "%=20s%=16s", "petr", use_petr ? "ip" : "");
1562 
1563  if (!use_petr)
1564  {
1565  vlib_cli_output (vm, "%=20s", "disable");
1566  return 0;
1567  }
1568 
1569  if (~0 == lcm->petr_map_index)
1570  {
1571  tmp_str = format (0, "N/A");
1572  }
1573  else
1574  {
1576  if (~0 != m->locator_set_index)
1577  {
1579  loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
1580  tmp_str = format (0, "%U", format_ip_address, &loc->address);
1581  }
1582  else
1583  {
1584  tmp_str = format (0, "N/A");
1585  }
1586  }
1587  vec_add1 (tmp_str, 0);
1588 
1589  vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
1590 
1591  vec_free (tmp_str);
1592 
1593  return 0;
1594 }
1595 
1596 /* *INDENT-OFF* */
1597 VLIB_CLI_COMMAND (lisp_show_petr_command) = {
1598  .path = "show lisp petr",
1599  .short_help = "Show petr",
1600  .function = lisp_show_petr_command_fn,
1601 };
1602 /* *INDENT-ON* */
1603 
1604 /*
1605  * fd.io coding-style-patch-verification: ON
1606  *
1607  * Local Variables:
1608  * eval: (c-set-style "gnu")
1609  * End:
1610  */
#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:701
u32 pitr_map_index
Definition: control.h:250
gid_address_t leid
Definition: control.h:73
#define gid_address_type(_a)
Definition: lisp_types.h:203
a
Definition: bitmap.h:538
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:1500
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:1470
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:90
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:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
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 vec_terminate_c_string(V)
(If necessary) NULL terminate a vector containing a c-string.
Definition: vec.h:1014
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:522
int i
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
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:1264
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: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:1544
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:1473
uword value[0]
Definition: hash.h:165
uword unformat_negative_mapping_action(unformat_input_t *input, va_list *args)
Definition: lisp_types.c:313
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:493
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:1297
int vnet_lisp_eid_table_map(u32 vni, u32 dp_id, u8 is_l2, u8 is_add)
Definition: control.c:1064
unsigned int u32
Definition: types.h:88
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:304
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:1416
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:283
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:2245
int vnet_lisp_pitr_set_locator_set(u8 *locator_set_name, u8 is_add)
Definition: control.c:1616
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
#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:869
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:1552
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: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:537
uword unformat_ip_address(unformat_input_t *input, va_list *args)
Definition: ip_types.c:40
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:204
lisp_adjacency_t * vnet_lisp_adjacencies_get_by_vni(u32 vni)
Returns vector of adjacencies.
Definition: control.c:611
u32 sw_if_index
Definition: lisp_types.h:266
static u8 * format_eid_entry(u8 *s, va_list *args)
Definition: lisp_cli.c:754
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
int vnet_lisp_add_del_mreq_itr_rlocs(vnet_lisp_add_del_mreq_itr_rloc_args_t *a)
Definition: control.c:2380
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:323
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:1355
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
vnet_main_t * vnet_main
Definition: lisp_gpe.h:172
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:20
int vnet_lisp_map_register_enable_disable(u8 is_enable)
Definition: control.c:2179
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
vl_api_vxlan_gbp_api_tunnel_mode_t mode
Definition: vxlan_gbp.api:44
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:161
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
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:665
int vnet_lisp_clear_all_remote_adjacencies(void)
Definition: control.c:1422
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
option version
Definition: memclnt.api:17
int vnet_lisp_rloc_probe_enable_disable(u8 is_enable)
Definition: control.c:2170
u64 gid_dictionary_lookup(gid_dictionary_t *db, gid_address_t *key)
#define unformat_parse_error(input)
Definition: format.h:269
int vnet_lisp_add_del_locator_set(vnet_lisp_add_del_locator_set_args_t *a, u32 *ls_result)
Definition: control.c:2030
#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:1221
#define gid_address_vni(_a)
Definition: lisp_types.h:213
vl_api_address_t ip
Definition: l2.api:489
map_request_mode_t
Definition: control.h:112
#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:163
int vnet_lisp_del_mapping(gid_address_t *eid, u32 *res_map_index)
Removes a mapping.
Definition: control.c:1373
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:1926
typedef key
Definition: ipsec.api:247
mapping_t * mapping_pool
Definition: control.h:171
#define ip_prefix_len(_a)
Definition: ip_types.h:76
u32 vni
Definition: vxlan_gbp.api:42
u8 ip_address_max_len(u8 version)
Definition: lisp_types.c:432
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:1203
#define ip_prefix_version(_a)
Definition: ip_types.h:75
gid_address_t eid
Definition: lisp_types.h:293
gid_address_t reid
Definition: control.h:74
gid_address_t address
Definition: lisp_types.h:267
#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: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:2317
#define vec_foreach(var, vec)
Vector iterator.
uword unformat_ip_prefix(unformat_input_t *input, va_list *args)
Definition: ip_types.c:63
int vnet_lisp_use_petr(ip_address_t *ip, u8 is_add)
Configure Proxy-ETR.
Definition: control.c:1683
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:772
u32 mreq_itr_rlocs
Definition: control.h:236
u32 * locator_indices
Definition: lisp_types.h:287
vnet_main_t * vnet_main
Definition: control.h:291
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: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:171