src/vnet/lisp-cp/one_cli.c

   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 *
  20 lisp_show_adjacencies_command_fn (vlib_main_t * vm,
  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
  29   /* Get a line of input. */
  30   if (!unformat_user (input, unformat_line_input, line_input))
  31     return 0;
  32
  33   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
  34     {
  35       if (unformat (line_input, "vni %d", &vni))
  36         ;
  37       else
  38         {
  39           vlib_cli_output (vm, "parse error: '%U'",
  40                            format_unformat_error, line_input);
  41           unformat_free (line_input);
  42           return 0;
  43         }
  44     }
  45   unformat_free (line_input);
  46
  47   if (~0 == vni)
  48     {
  49       vlib_cli_output (vm, "error: no vni specified!");
  50       return 0;
  51     }
  52
  53   adjs = vnet_lisp_adjacencies_get_by_vni (vni);
  54
  55   vec_foreach (adj, adjs)
  56   {
  57     vlib_cli_output (vm, "%U %40U\n", format_gid_address, &adj->leid,
  58                      format_gid_address, &adj->reid);
  59   }
  60   vec_free (adjs);
  61
  62   return 0;
  63 }
  64
  65 /* *INDENT-OFF* */
  66 VLIB_CLI_COMMAND (one_show_adjacencies_command) = {
  67     .path = "show one adjacencies",
  68     .short_help = "show one adjacencies",
  69     .function = lisp_show_adjacencies_command_fn,
  70 };
  71 /* *INDENT-ON* */
  72
  73 static clib_error_t *
  74 lisp_add_del_map_server_command_fn (vlib_main_t * vm,
  75                                     unformat_input_t * input,
  76                                     vlib_cli_command_t * cmd)
  77 {
  78   int rv = 0;
  79   u8 is_add = 1, ip_set = 0;
  80   ip_address_t ip;
  81   unformat_input_t _line_input, *line_input = &_line_input;
  82
  83   /* Get a line of input. */
  84   if (!unformat_user (input, unformat_line_input, line_input))
  85     return 0;
  86
  87   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
  88     {
  89       if (unformat (line_input, "add"))
  90         is_add = 1;
  91       else if (unformat (line_input, "del"))
  92         is_add = 0;
  93       else if (unformat (line_input, "%U", unformat_ip_address, &ip))
  94         ip_set = 1;
  95       else
  96         {
  97           vlib_cli_output (vm, "parse error: '%U'",
  98                            format_unformat_error, line_input);
  99           unformat_free (line_input);
 100           return 0;
 101         }
 102     }
 103   unformat_free (line_input);
 104
 105   if (!ip_set)
 106     {
 107       vlib_cli_output (vm, "map-server ip address not set!");
 108       return 0;
 109     }
 110
 111   rv = vnet_lisp_add_del_map_server (&ip, is_add);
 112   if (!rv)
 113     vlib_cli_output (vm, "failed to %s map-server!",
 114                      is_add ? "add" : "delete");
 115
 116   return 0;
 117 }
 118
 119 /* *INDENT-OFF* */
 120 VLIB_CLI_COMMAND (one_add_del_map_server_command) = {
 121     .path = "one map-server",
 122     .short_help = "one map-server add|del <ip>",
 123     .function = lisp_add_del_map_server_command_fn,
 124 };
 125 /* *INDENT-ON* */
 126
 127
 128 static clib_error_t *
 129 lisp_add_del_local_eid_command_fn (vlib_main_t * vm, unformat_input_t * input,
 130                                    vlib_cli_command_t * cmd)
 131 {
 132   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 133   unformat_input_t _line_input, *line_input = &_line_input;
 134   u8 is_add = 1;
 135   gid_address_t eid;
 136   gid_address_t *eids = 0;
 137   clib_error_t *error = 0;
 138   u8 *locator_set_name = 0;
 139   u32 locator_set_index = 0, map_index = 0;
 140   uword *p;
 141   vnet_lisp_add_del_mapping_args_t _a, *a = &_a;
 142   int rv = 0;
 143   u32 vni = 0;
 144   u8 *key = 0;
 145   u32 key_id = 0;
 146
 147   memset (&eid, 0, sizeof (eid));
 148   memset (a, 0, sizeof (*a));
 149
 150   /* Get a line of input. */
 151   if (!unformat_user (input, unformat_line_input, line_input))
 152     return 0;
 153
 154   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 155     {
 156       if (unformat (line_input, "add"))
 157         is_add = 1;
 158       else if (unformat (line_input, "del"))
 159         is_add = 0;
 160       else if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
 161         ;
 162       else if (unformat (line_input, "vni %d", &vni))
 163         gid_address_vni (&eid) = vni;
 164       else if (unformat (line_input, "secret-key %_%v%_", &key))
 165         ;
 166       else if (unformat (line_input, "key-id %U", unformat_hmac_key_id,
 167                          &key_id))
 168         ;
 169       else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name))
 170         {
 171           p = hash_get_mem (lcm->locator_set_index_by_name, locator_set_name);
 172           if (!p)
 173             {
 174               error = clib_error_return (0, "locator-set %s doesn't exist",
 175                                          locator_set_name);
 176               goto done;
 177             }
 178           locator_set_index = p[0];
 179         }
 180       else
 181         {
 182           error = unformat_parse_error (line_input);
 183           goto done;
 184         }
 185     }
 186   /* XXX treat batch configuration */
 187
 188   if (GID_ADDR_SRC_DST == gid_address_type (&eid))
 189     {
 190       error =
 191         clib_error_return (0, "src/dst is not supported for local EIDs!");
 192       goto done;
 193     }
 194
 195   if (key && (0 == key_id))
 196     {
 197       vlib_cli_output (vm, "invalid key_id!");
 198       goto done;
 199     }
 200
 201   gid_address_copy (&a->eid, &eid);
 202   a->is_add = is_add;
 203   a->locator_set_index = locator_set_index;
 204   a->local = 1;
 205   a->key = key;
 206   a->key_id = key_id;
 207
 208   rv = vnet_lisp_add_del_local_mapping (a, &map_index);
 209   if (0 != rv)
 210     {
 211       error = clib_error_return (0, "failed to %s local mapping!",
 212                                  is_add ? "add" : "delete");
 213     }
 214 done:
 215   vec_free (eids);
 216   if (locator_set_name)
 217     vec_free (locator_set_name);
 218   gid_address_free (&a->eid);
 219   vec_free (a->key);
 220   unformat_free (line_input);
 221   return error;
 222 }
 223
 224 /* *INDENT-OFF* */
 225 VLIB_CLI_COMMAND (one_add_del_local_eid_command) = {
 226     .path = "one eid-table",
 227     .short_help = "one eid-table add/del [vni <vni>] eid <eid> "
 228       "locator-set <locator-set> [key <secret-key> key-id sha1|sha256 ]",
 229     .function = lisp_add_del_local_eid_command_fn,
 230 };
 231 /* *INDENT-ON* */
 232
 233 static clib_error_t *
 234 lisp_eid_table_map_command_fn (vlib_main_t * vm,
 235                                unformat_input_t * input,
 236                                vlib_cli_command_t * cmd)
 237 {
 238   u8 is_add = 1, is_l2 = 0;
 239   u32 vni = 0, dp_id = 0;
 240   unformat_input_t _line_input, *line_input = &_line_input;
 241   clib_error_t *error = NULL;
 242
 243   /* Get a line of input. */
 244   if (!unformat_user (input, unformat_line_input, line_input))
 245     return 0;
 246
 247   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 248     {
 249       if (unformat (line_input, "del"))
 250         is_add = 0;
 251       else if (unformat (line_input, "vni %d", &vni))
 252         ;
 253       else if (unformat (line_input, "vrf %d", &dp_id))
 254         ;
 255       else if (unformat (line_input, "bd %d", &dp_id))
 256         is_l2 = 1;
 257       else
 258         {
 259           error = unformat_parse_error (line_input);
 260           goto done;
 261         }
 262     }
 263   vnet_lisp_eid_table_map (vni, dp_id, is_l2, is_add);
 264
 265 done:
 266   unformat_free (line_input);
 267
 268   return error;
 269 }
 270
 271 /* *INDENT-OFF* */
 272 VLIB_CLI_COMMAND (one_eid_table_map_command) = {
 273     .path = "one eid-table map",
 274     .short_help = "one eid-table map [del] vni <vni> vrf <vrf> | bd <bdi>",
 275     .function = lisp_eid_table_map_command_fn,
 276 };
 277 /* *INDENT-ON* */
 278
 279 /**
 280  * Handler for add/del remote mapping CLI.
 281  *
 282  * @param vm vlib context
 283  * @param input input from user
 284  * @param cmd cmd
 285  * @return pointer to clib error structure
 286  */
 287 static clib_error_t *
 288 lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm,
 289                                         unformat_input_t * input,
 290                                         vlib_cli_command_t * cmd)
 291 {
 292   clib_error_t *error = 0;
 293   unformat_input_t _line_input, *line_input = &_line_input;
 294   u8 is_add = 1, del_all = 0;
 295   locator_t rloc, *rlocs = 0, *curr_rloc = 0;
 296   gid_address_t eid;
 297   u8 eid_set = 0;
 298   u32 vni, action = ~0, p, w;
 299   int rv;
 300
 301   /* Get a line of input. */
 302   if (!unformat_user (input, unformat_line_input, line_input))
 303     return 0;
 304
 305   memset (&eid, 0, sizeof (eid));
 306   memset (&rloc, 0, sizeof (rloc));
 307
 308   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 309     {
 310       if (unformat (line_input, "del-all"))
 311         del_all = 1;
 312       else if (unformat (line_input, "del"))
 313         is_add = 0;
 314       else if (unformat (line_input, "add"))
 315         ;
 316       else if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
 317         eid_set = 1;
 318       else if (unformat (line_input, "vni %u", &vni))
 319         {
 320           gid_address_vni (&eid) = vni;
 321         }
 322       else if (unformat (line_input, "p %d w %d", &p, &w))
 323         {
 324           if (!curr_rloc)
 325             {
 326               clib_warning
 327                 ("No RLOC configured for setting priority/weight!");
 328               goto done;
 329             }
 330           curr_rloc->priority = p;
 331           curr_rloc->weight = w;
 332         }
 333       else if (unformat (line_input, "rloc %U", unformat_ip_address,
 334                          &gid_address_ip (&rloc.address)))
 335         {
 336           /* since rloc is stored in ip prefix we need to set prefix length */
 337           ip_prefix_t *pref = &gid_address_ippref (&rloc.address);
 338
 339           u8 version = gid_address_ip_version (&rloc.address);
 340           ip_prefix_len (pref) = ip_address_max_len (version);
 341
 342           vec_add1 (rlocs, rloc);
 343           curr_rloc = &rlocs[vec_len (rlocs) - 1];
 344         }
 345       else if (unformat (line_input, "action %U",
 346                          unformat_negative_mapping_action, &action))
 347         ;
 348       else
 349         {
 350           clib_warning ("parse error");
 351           goto done;
 352         }
 353     }
 354
 355   if (!del_all && !eid_set)
 356     {
 357       clib_warning ("missing eid!");
 358       goto done;
 359     }
 360
 361   if (!del_all)
 362     {
 363       if (is_add && (~0 == action) && 0 == vec_len (rlocs))
 364         {
 365           clib_warning ("no action set for negative map-reply!");
 366           goto done;
 367         }
 368     }
 369   else
 370     {
 371       vnet_lisp_clear_all_remote_adjacencies ();
 372       goto done;
 373     }
 374
 375   /* if it's a delete, clean forwarding */
 376   if (!is_add)
 377     {
 378       vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
 379       memset (a, 0, sizeof (a[0]));
 380       gid_address_copy (&a->reid, &eid);
 381       if (vnet_lisp_add_del_adjacency (a))
 382         {
 383           clib_warning ("failed to delete adjacency!");
 384           goto done;
 385         }
 386     }
 387
 388   /* add as static remote mapping, i.e., not authoritative and infinite
 389    * ttl */
 390   rv = vnet_lisp_add_del_mapping (&eid, rlocs, action, 0, ~0, is_add,
 391                                   1 /* is_static */ , 0);
 392
 393   if (rv)
 394     clib_warning ("failed to %s remote mapping!", is_add ? "add" : "delete");
 395
 396 done:
 397   vec_free (rlocs);
 398   unformat_free (line_input);
 399   return error;
 400 }
 401
 402 /* *INDENT-OFF* */
 403 VLIB_CLI_COMMAND (one_add_del_remote_mapping_command) = {
 404   .path = "one remote-mapping",
 405   .short_help =
 406     "one remote-mapping add|del [del-all] vni <vni> "
 407     "eid <est-eid> [action <no-action|natively-forward|"
 408     "send-map-request|drop>] rloc <dst-locator> p <prio> w <weight> "
 409     "[rloc <dst-locator> ... ]",
 410   .function = lisp_add_del_remote_mapping_command_fn,
 411 };
 412 /* *INDENT-ON* */
 413
 414 /**
 415  * Handler for add/del adjacency CLI.
 416  */
 417 static clib_error_t *
 418 lisp_add_del_adjacency_command_fn (vlib_main_t * vm, unformat_input_t * input,
 419                                    vlib_cli_command_t * cmd)
 420 {
 421   clib_error_t *error = 0;
 422   unformat_input_t _line_input, *line_input = &_line_input;
 423   vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
 424   u8 is_add = 1;
 425   ip_prefix_t *reid_ippref, *leid_ippref;
 426   gid_address_t leid, reid;
 427   u8 *dmac = gid_address_mac (&reid);
 428   u8 *smac = gid_address_mac (&leid);
 429   u8 reid_set = 0, leid_set = 0;
 430   u32 vni;
 431
 432   /* Get a line of input. */
 433   if (!unformat_user (input, unformat_line_input, line_input))
 434     return 0;
 435
 436   memset (&reid, 0, sizeof (reid));
 437   memset (&leid, 0, sizeof (leid));
 438
 439   leid_ippref = &gid_address_ippref (&leid);
 440   reid_ippref = &gid_address_ippref (&reid);
 441
 442   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 443     {
 444       if (unformat (line_input, "del"))
 445         is_add = 0;
 446       else if (unformat (line_input, "add"))
 447         ;
 448       else if (unformat (line_input, "reid %U",
 449                          unformat_ip_prefix, reid_ippref))
 450         {
 451           gid_address_type (&reid) = GID_ADDR_IP_PREFIX;
 452           reid_set = 1;
 453         }
 454       else if (unformat (line_input, "reid %U", unformat_mac_address, dmac))
 455         {
 456           gid_address_type (&reid) = GID_ADDR_MAC;
 457           reid_set = 1;
 458         }
 459       else if (unformat (line_input, "vni %u", &vni))
 460         {
 461           gid_address_vni (&leid) = vni;
 462           gid_address_vni (&reid) = vni;
 463         }
 464       else if (unformat (line_input, "leid %U",
 465                          unformat_ip_prefix, leid_ippref))
 466         {
 467           gid_address_type (&leid) = GID_ADDR_IP_PREFIX;
 468           leid_set = 1;
 469         }
 470       else if (unformat (line_input, "leid %U", unformat_mac_address, smac))
 471         {
 472           gid_address_type (&leid) = GID_ADDR_MAC;
 473           leid_set = 1;
 474         }
 475       else
 476         {
 477           clib_warning ("parse error");
 478           goto done;
 479         }
 480     }
 481
 482   if (!reid_set || !leid_set)
 483     {
 484       clib_warning ("missing remote or local eid!");
 485       goto done;
 486     }
 487
 488   if ((gid_address_type (&leid) != gid_address_type (&reid))
 489       || (gid_address_type (&reid) == GID_ADDR_IP_PREFIX
 490           && ip_prefix_version (reid_ippref)
 491           != ip_prefix_version (leid_ippref)))
 492     {
 493       clib_warning ("remote and local EIDs are of different types!");
 494       goto done;
 495     }
 496
 497   memset (a, 0, sizeof (a[0]));
 498   gid_address_copy (&a->leid, &leid);
 499   gid_address_copy (&a->reid, &reid);
 500   a->is_add = is_add;
 501
 502   if (vnet_lisp_add_del_adjacency (a))
 503     clib_warning ("failed to %s adjacency!", is_add ? "add" : "delete");
 504
 505 done:
 506   unformat_free (line_input);
 507   return error;
 508 }
 509
 510 /* *INDENT-OFF* */
 511 VLIB_CLI_COMMAND (one_add_del_adjacency_command) = {
 512     .path = "one adjacency",
 513     .short_help = "one adjacency add|del vni <vni> reid <remote-eid> "
 514       "leid <local-eid>",
 515     .function = lisp_add_del_adjacency_command_fn,
 516 };
 517 /* *INDENT-ON* */
 518
 519
 520 static clib_error_t *
 521 lisp_map_request_mode_command_fn (vlib_main_t * vm,
 522                                   unformat_input_t * input,
 523                                   vlib_cli_command_t * cmd)
 524 {
 525   unformat_input_t _i, *i = &_i;
 526   map_request_mode_t mr_mode = _MR_MODE_MAX;
 527
 528   /* Get a line of input. */
 529   if (!unformat_user (input, unformat_line_input, i))
 530     return 0;
 531
 532   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 533     {
 534       if (unformat (i, "dst-only"))
 535         mr_mode = MR_MODE_DST_ONLY;
 536       else if (unformat (i, "src-dst"))
 537         mr_mode = MR_MODE_SRC_DST;
 538       else
 539         {
 540           clib_warning ("parse error '%U'", format_unformat_error, i);
 541           goto done;
 542         }
 543     }
 544
 545   if (_MR_MODE_MAX == mr_mode)
 546     {
 547       clib_warning ("No map request mode entered!");
 548       goto done;
 549     }
 550
 551   vnet_lisp_set_map_request_mode (mr_mode);
 552
 553 done:
 554   unformat_free (i);
 555
 556   return 0;
 557 }
 558
 559 /* *INDENT-OFF* */
 560 VLIB_CLI_COMMAND (one_map_request_mode_command) = {
 561     .path = "one map-request mode",
 562     .short_help = "one map-request mode dst-only|src-dst",
 563     .function = lisp_map_request_mode_command_fn,
 564 };
 565 /* *INDENT-ON* */
 566
 567
 568 static u8 *
 569 format_lisp_map_request_mode (u8 * s, va_list * args)
 570 {
 571   u32 mode = va_arg (*args, u32);
 572
 573   switch (mode)
 574     {
 575     case 0:
 576       return format (0, "dst-only");
 577     case 1:
 578       return format (0, "src-dst");
 579     }
 580   return 0;
 581 }
 582
 583 static clib_error_t *
 584 lisp_show_map_request_mode_command_fn (vlib_main_t * vm,
 585                                        unformat_input_t * input,
 586                                        vlib_cli_command_t * cmd)
 587 {
 588   vlib_cli_output (vm, "map-request mode: %U", format_lisp_map_request_mode,
 589                    vnet_lisp_get_map_request_mode ());
 590   return 0;
 591 }
 592
 593 /* *INDENT-OFF* */
 594 VLIB_CLI_COMMAND (one_show_map_request_mode_command) = {
 595     .path = "show one map-request mode",
 596     .short_help = "show one map-request mode",
 597     .function = lisp_show_map_request_mode_command_fn,
 598 };
 599 /* *INDENT-ON* */
 600
 601 static clib_error_t *
 602 lisp_show_map_resolvers_command_fn (vlib_main_t * vm,
 603                                     unformat_input_t * input,
 604                                     vlib_cli_command_t * cmd)
 605 {
 606   lisp_msmr_t *mr;
 607   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 608
 609   vec_foreach (mr, lcm->map_resolvers)
 610   {
 611     vlib_cli_output (vm, "%U", format_ip_address, &mr->address);
 612   }
 613   return 0;
 614 }
 615
 616 /* *INDENT-OFF* */
 617 VLIB_CLI_COMMAND (one_show_map_resolvers_command) = {
 618     .path = "show one map-resolvers",
 619     .short_help = "show one map-resolvers",
 620     .function = lisp_show_map_resolvers_command_fn,
 621 };
 622 /* *INDENT-ON* */
 623
 624
 625 static clib_error_t *
 626 lisp_pitr_set_locator_set_command_fn (vlib_main_t * vm,
 627                                       unformat_input_t * input,
 628                                       vlib_cli_command_t * cmd)
 629 {
 630   u8 locator_name_set = 0;
 631   u8 *locator_set_name = 0;
 632   u8 is_add = 1;
 633   unformat_input_t _line_input, *line_input = &_line_input;
 634   clib_error_t *error = 0;
 635   int rv = 0;
 636
 637   /* Get a line of input. */
 638   if (!unformat_user (input, unformat_line_input, line_input))
 639     return 0;
 640
 641   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 642     {
 643       if (unformat (line_input, "ls %_%v%_", &locator_set_name))
 644         locator_name_set = 1;
 645       else if (unformat (line_input, "disable"))
 646         is_add = 0;
 647       else
 648         {
 649           error = clib_error_return (0, "parse error");
 650           goto done;
 651         }
 652     }
 653
 654   if (!locator_name_set)
 655     {
 656       clib_warning ("No locator set specified!");
 657       goto done;
 658     }
 659   rv = vnet_lisp_pitr_set_locator_set (locator_set_name, is_add);
 660   if (0 != rv)
 661     {
 662       error = clib_error_return (0, "failed to %s pitr!",
 663                                  is_add ? "add" : "delete");
 664     }
 665
 666 done:
 667   if (locator_set_name)
 668     vec_free (locator_set_name);
 669   unformat_free (line_input);
 670   return error;
 671 }
 672
 673 /* *INDENT-OFF* */
 674 VLIB_CLI_COMMAND (one_pitr_set_locator_set_command) = {
 675     .path = "one pitr",
 676     .short_help = "one pitr [disable] ls <locator-set-name>",
 677     .function = lisp_pitr_set_locator_set_command_fn,
 678 };
 679 /* *INDENT-ON* */
 680
 681 static clib_error_t *
 682 lisp_show_pitr_command_fn (vlib_main_t * vm,
 683                            unformat_input_t * input, vlib_cli_command_t * cmd)
 684 {
 685   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 686   mapping_t *m;
 687   locator_set_t *ls;
 688   u8 *tmp_str = 0;
 689
 690   vlib_cli_output (vm, "%=20s%=16s",
 691                    "pitr", lcm->lisp_pitr ? "locator-set" : "");
 692
 693   if (!lcm->lisp_pitr)
 694     {
 695       vlib_cli_output (vm, "%=20s", "disable");
 696       return 0;
 697     }
 698
 699   if (~0 == lcm->pitr_map_index)
 700     {
 701       tmp_str = format (0, "N/A");
 702     }
 703   else
 704     {
 705       m = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
 706       if (~0 != m->locator_set_index)
 707         {
 708           ls =
 709             pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
 710           tmp_str = format (0, "%s", ls->name);
 711         }
 712       else
 713         {
 714           tmp_str = format (0, "N/A");
 715         }
 716     }
 717   vec_add1 (tmp_str, 0);
 718
 719   vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
 720
 721   vec_free (tmp_str);
 722
 723   return 0;
 724 }
 725
 726 /* *INDENT-OFF* */
 727 VLIB_CLI_COMMAND (one_show_pitr_command) = {
 728     .path = "show one pitr",
 729     .short_help = "Show pitr",
 730     .function = lisp_show_pitr_command_fn,
 731 };
 732 /* *INDENT-ON* */
 733
 734 static u8 *
 735 format_eid_entry (u8 * s, va_list * args)
 736 {
 737   vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
 738   lisp_cp_main_t *lcm = va_arg (*args, lisp_cp_main_t *);
 739   mapping_t *mapit = va_arg (*args, mapping_t *);
 740   locator_set_t *ls = va_arg (*args, locator_set_t *);
 741   gid_address_t *gid = &mapit->eid;
 742   u32 ttl = mapit->ttl;
 743   u8 aut = mapit->authoritative;
 744   u32 *loc_index;
 745   u8 first_line = 1;
 746   u8 *loc;
 747
 748   u8 *type = ls->local ? format (0, "local(%s)", ls->name)
 749     : format (0, "remote");
 750
 751   if (vec_len (ls->locator_indices) == 0)
 752     {
 753       s = format (s, "%-35U%-30s%-20u%-u", format_gid_address, gid,
 754                   type, ttl, aut);
 755     }
 756   else
 757     {
 758       vec_foreach (loc_index, ls->locator_indices)
 759       {
 760         locator_t *l = pool_elt_at_index (lcm->locator_pool, loc_index[0]);
 761         if (l->local)
 762           loc = format (0, "%U", format_vnet_sw_if_index_name, vnm,
 763                         l->sw_if_index);
 764         else
 765           loc = format (0, "%U", format_ip_address,
 766                         &gid_address_ip (&l->address));
 767
 768         if (first_line)
 769           {
 770             s = format (s, "%-35U%-20s%-30v%-20u%-u\n", format_gid_address,
 771                         gid, type, loc, ttl, aut);
 772             first_line = 0;
 773           }
 774         else
 775           s = format (s, "%55s%v\n", "", loc);
 776       }
 777     }
 778   return s;
 779 }
 780
 781 static clib_error_t *
 782 lisp_show_eid_table_command_fn (vlib_main_t * vm,
 783                                 unformat_input_t * input,
 784                                 vlib_cli_command_t * cmd)
 785 {
 786   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 787   mapping_t *mapit;
 788   unformat_input_t _line_input, *line_input = &_line_input;
 789   u32 mi;
 790   gid_address_t eid;
 791   u8 print_all = 1;
 792   u8 filter = 0;
 793   clib_error_t *error = NULL;
 794
 795   memset (&eid, 0, sizeof (eid));
 796
 797   /* Get a line of input. */
 798   if (!unformat_user (input, unformat_line_input, line_input))
 799     return 0;
 800
 801   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 802     {
 803       if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
 804         print_all = 0;
 805       else if (unformat (line_input, "local"))
 806         filter = 1;
 807       else if (unformat (line_input, "remote"))
 808         filter = 2;
 809       else
 810         {
 811           error = clib_error_return (0, "parse error: '%U'",
 812                                      format_unformat_error, line_input);
 813           goto done;
 814         }
 815     }
 816
 817   vlib_cli_output (vm, "%-35s%-20s%-30s%-20s%-s",
 818                    "EID", "type", "locators", "ttl", "autoritative");
 819
 820   if (print_all)
 821     {
 822       /* *INDENT-OFF* */
 823       pool_foreach (mapit, lcm->mapping_pool,
 824       ({
 825         if (mapit->pitr_set)
 826           continue;
 827
 828         locator_set_t * ls = pool_elt_at_index (lcm->locator_set_pool,
 829                                                 mapit->locator_set_index);
 830         if (filter && !((1 == filter && ls->local) ||
 831           (2 == filter && !ls->local)))
 832           {
 833             continue;
 834           }
 835         vlib_cli_output (vm, "%U", format_eid_entry, lcm->vnet_main,
 836                          lcm, mapit, ls);
 837       }));
 838       /* *INDENT-ON* */
 839     }
 840   else
 841     {
 842       mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &eid);
 843       if ((u32) ~ 0 == mi)
 844         goto done;
 845
 846       mapit = pool_elt_at_index (lcm->mapping_pool, mi);
 847       locator_set_t *ls = pool_elt_at_index (lcm->locator_set_pool,
 848                                              mapit->locator_set_index);
 849
 850       if (filter && !((1 == filter && ls->local) ||
 851                       (2 == filter && !ls->local)))
 852         {
 853           goto done;
 854         }
 855
 856       vlib_cli_output (vm, "%U,", format_eid_entry, lcm->vnet_main,
 857                        lcm, mapit, ls);
 858     }
 859
 860 done:
 861   unformat_free (line_input);
 862
 863   return error;
 864 }
 865
 866 /* *INDENT-OFF* */
 867 VLIB_CLI_COMMAND (one_cp_show_eid_table_command) = {
 868     .path = "show one eid-table",
 869     .short_help = "Shows EID table",
 870     .function = lisp_show_eid_table_command_fn,
 871 };
 872 /* *INDENT-ON* */
 873
 874
 875 static clib_error_t *
 876 lisp_enable_disable_command_fn (vlib_main_t * vm, unformat_input_t * input,
 877                                 vlib_cli_command_t * cmd)
 878 {
 879   unformat_input_t _line_input, *line_input = &_line_input;
 880   u8 is_enabled = 0;
 881   u8 is_set = 0;
 882   clib_error_t *error = NULL;
 883
 884   /* Get a line of input. */
 885   if (!unformat_user (input, unformat_line_input, line_input))
 886     return 0;
 887
 888   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 889     {
 890       if (unformat (line_input, "enable"))
 891         {
 892           is_set = 1;
 893           is_enabled = 1;
 894         }
 895       else if (unformat (line_input, "disable"))
 896         is_set = 1;
 897       else
 898         {
 899           error = clib_error_return (0, "parse error: '%U'",
 900                                      format_unformat_error, line_input);
 901           goto done;
 902         }
 903     }
 904
 905   if (!is_set)
 906     {
 907       error = clib_error_return (0, "state not set");
 908       goto done;
 909     }
 910
 911   vnet_lisp_enable_disable (is_enabled);
 912
 913 done:
 914   unformat_free (line_input);
 915
 916   return error;
 917 }
 918
 919 /* *INDENT-OFF* */
 920 VLIB_CLI_COMMAND (one_cp_enable_disable_command) = {
 921     .path = "one",
 922     .short_help = "one [enable|disable]",
 923     .function = lisp_enable_disable_command_fn,
 924 };
 925 /* *INDENT-ON* */
 926
 927 static clib_error_t *
 928 lisp_map_register_enable_disable_command_fn (vlib_main_t * vm,
 929                                              unformat_input_t * input,
 930                                              vlib_cli_command_t * cmd)
 931 {
 932   unformat_input_t _line_input, *line_input = &_line_input;
 933   u8 is_enabled = 0;
 934   u8 is_set = 0;
 935   clib_error_t *error = NULL;
 936
 937   /* Get a line of input. */
 938   if (!unformat_user (input, unformat_line_input, line_input))
 939     return 0;
 940
 941   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 942     {
 943       if (unformat (line_input, "enable"))
 944         {
 945           is_set = 1;
 946           is_enabled = 1;
 947         }
 948       else if (unformat (line_input, "disable"))
 949         is_set = 1;
 950       else
 951         {
 952           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
 953                            line_input);
 954           goto done;
 955         }
 956     }
 957
 958   if (!is_set)
 959     {
 960       vlib_cli_output (vm, "state not set!");
 961       goto done;
 962     }
 963
 964   vnet_lisp_map_register_enable_disable (is_enabled);
 965
 966 done:
 967   unformat_free (line_input);
 968
 969   return error;
 970 }
 971
 972 /* *INDENT-OFF* */
 973 VLIB_CLI_COMMAND (one_map_register_enable_disable_command) = {
 974     .path = "one map-register",
 975     .short_help = "one map-register [enable|disable]",
 976     .function = lisp_map_register_enable_disable_command_fn,
 977 };
 978 /* *INDENT-ON* */
 979
 980 static clib_error_t *
 981 lisp_rloc_probe_enable_disable_command_fn (vlib_main_t * vm,
 982                                            unformat_input_t * input,
 983                                            vlib_cli_command_t * cmd)
 984 {
 985   unformat_input_t _line_input, *line_input = &_line_input;
 986   u8 is_enabled = 0;
 987   u8 is_set = 0;
 988   clib_error_t *error = NULL;
 989
 990   /* Get a line of input. */
 991   if (!unformat_user (input, unformat_line_input, line_input))
 992     return 0;
 993
 994   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 995     {
 996       if (unformat (line_input, "enable"))
 997         {
 998           is_set = 1;
 999           is_enabled = 1;
1000         }
1001       else if (unformat (line_input, "disable"))
1002         is_set = 1;
1003       else
1004         {
1005           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1006                            line_input);
1007           goto done;
1008         }
1009     }
1010
1011   if (!is_set)
1012     {
1013       vlib_cli_output (vm, "state not set!");
1014       goto done;
1015     }
1016
1017   vnet_lisp_rloc_probe_enable_disable (is_enabled);
1018
1019 done:
1020   unformat_free (line_input);
1021
1022   return error;
1023 }
1024
1025 /* *INDENT-OFF* */
1026 VLIB_CLI_COMMAND (one_rloc_probe_enable_disable_command) = {
1027     .path = "one rloc-probe",
1028     .short_help = "one rloc-probe [enable|disable]",
1029     .function = lisp_rloc_probe_enable_disable_command_fn,
1030 };
1031 /* *INDENT-ON* */
1032
1033 static u8 *
1034 format_lisp_status (u8 * s, va_list * args)
1035 {
1036   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1037   return format (s, "%s", lcm->is_enabled ? "enabled" : "disabled");
1038 }
1039
1040 static clib_error_t *
1041 lisp_show_status_command_fn (vlib_main_t * vm, unformat_input_t * input,
1042                              vlib_cli_command_t * cmd)
1043 {
1044   u8 *msg = 0;
1045   msg = format (msg, "feature: %U\ngpe: %U\n",
1046                 format_lisp_status, format_vnet_lisp_gpe_status);
1047   vlib_cli_output (vm, "%v", msg);
1048   vec_free (msg);
1049   return 0;
1050 }
1051
1052 /* *INDENT-OFF* */
1053 VLIB_CLI_COMMAND (one_show_status_command) = {
1054     .path = "show one status",
1055     .short_help = "show one status",
1056     .function = lisp_show_status_command_fn,
1057 };
1058 /* *INDENT-ON* */
1059
1060 static clib_error_t *
1061 lisp_show_eid_table_map_command_fn (vlib_main_t * vm,
1062                                     unformat_input_t * input,
1063                                     vlib_cli_command_t * cmd)
1064 {
1065   hash_pair_t *p;
1066   unformat_input_t _line_input, *line_input = &_line_input;
1067   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1068   uword *vni_table = 0;
1069   u8 is_l2 = 0;
1070   clib_error_t *error = NULL;
1071
1072   /* Get a line of input. */
1073   if (!unformat_user (input, unformat_line_input, line_input))
1074     return 0;
1075
1076   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1077     {
1078       if (unformat (line_input, "l2"))
1079         {
1080           vni_table = lcm->bd_id_by_vni;
1081           is_l2 = 1;
1082         }
1083       else if (unformat (line_input, "l3"))
1084         {
1085           vni_table = lcm->table_id_by_vni;
1086           is_l2 = 0;
1087         }
1088       else
1089         {
1090           error = clib_error_return (0, "parse error: '%U'",
1091                                      format_unformat_error, line_input);
1092           goto done;
1093         }
1094     }
1095
1096   if (!vni_table)
1097     {
1098       vlib_cli_output (vm, "Error: expected l2|l3 param!\n");
1099       goto done;
1100     }
1101
1102   vlib_cli_output (vm, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
1103
1104   /* *INDENT-OFF* */
1105   hash_foreach_pair (p, vni_table,
1106   ({
1107     vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]);
1108   }));
1109   /* *INDENT-ON* */
1110
1111 done:
1112   unformat_free (line_input);
1113
1114   return error;
1115 }
1116
1117 /* *INDENT-OFF* */
1118 VLIB_CLI_COMMAND (one_show_eid_table_map_command) = {
1119     .path = "show one eid-table map",
1120     .short_help = "show one eid-table l2|l3",
1121     .function = lisp_show_eid_table_map_command_fn,
1122 };
1123 /* *INDENT-ON* */
1124
1125
1126 static clib_error_t *
1127 lisp_add_del_locator_set_command_fn (vlib_main_t * vm,
1128                                      unformat_input_t * input,
1129                                      vlib_cli_command_t * cmd)
1130 {
1131   lisp_gpe_main_t *lgm = &lisp_gpe_main;
1132   vnet_main_t *vnm = lgm->vnet_main;
1133   unformat_input_t _line_input, *line_input = &_line_input;
1134   u8 is_add = 1;
1135   clib_error_t *error = 0;
1136   u8 *locator_set_name = 0;
1137   locator_t locator, *locators = 0;
1138   vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
1139   u32 ls_index = 0;
1140   int rv = 0;
1141
1142   memset (&locator, 0, sizeof (locator));
1143   memset (a, 0, sizeof (a[0]));
1144
1145   /* Get a line of input. */
1146   if (!unformat_user (input, unformat_line_input, line_input))
1147     return 0;
1148
1149   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1150     {
1151       if (unformat (line_input, "add %_%v%_", &locator_set_name))
1152         is_add = 1;
1153       else if (unformat (line_input, "del %_%v%_", &locator_set_name))
1154         is_add = 0;
1155       else if (unformat (line_input, "iface %U p %d w %d",
1156                          unformat_vnet_sw_interface, vnm,
1157                          &locator.sw_if_index, &locator.priority,
1158                          &locator.weight))
1159         {
1160           locator.local = 1;
1161           vec_add1 (locators, locator);
1162         }
1163       else
1164         {
1165           error = unformat_parse_error (line_input);
1166           goto done;
1167         }
1168     }
1169
1170   a->name = locator_set_name;
1171   a->locators = locators;
1172   a->is_add = is_add;
1173   a->local = 1;
1174
1175   rv = vnet_lisp_add_del_locator_set (a, &ls_index);
1176   if (0 != rv)
1177     {
1178       error = clib_error_return (0, "failed to %s locator-set!",
1179                                  is_add ? "add" : "delete");
1180     }
1181
1182 done:
1183   vec_free (locators);
1184   if (locator_set_name)
1185     vec_free (locator_set_name);
1186   unformat_free (line_input);
1187   return error;
1188 }
1189
1190 /* *INDENT-OFF* */
1191 VLIB_CLI_COMMAND (one_cp_add_del_locator_set_command) = {
1192     .path = "one locator-set",
1193     .short_help = "one locator-set add/del <name> [iface <iface-name> "
1194         "p <priority> w <weight>]",
1195     .function = lisp_add_del_locator_set_command_fn,
1196 };
1197 /* *INDENT-ON* */
1198
1199 static clib_error_t *
1200 lisp_add_del_locator_in_set_command_fn (vlib_main_t * vm,
1201                                         unformat_input_t * input,
1202                                         vlib_cli_command_t * cmd)
1203 {
1204   lisp_gpe_main_t *lgm = &lisp_gpe_main;
1205   vnet_main_t *vnm = lgm->vnet_main;
1206   unformat_input_t _line_input, *line_input = &_line_input;
1207   u8 is_add = 1;
1208   clib_error_t *error = 0;
1209   u8 *locator_set_name = 0;
1210   u8 locator_set_name_set = 0;
1211   locator_t locator, *locators = 0;
1212   vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
1213   u32 ls_index = 0;
1214
1215   memset (&locator, 0, sizeof (locator));
1216   memset (a, 0, sizeof (a[0]));
1217
1218   /* Get a line of input. */
1219   if (!unformat_user (input, unformat_line_input, line_input))
1220     return 0;
1221
1222   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1223     {
1224       if (unformat (line_input, "add"))
1225         is_add = 1;
1226       else if (unformat (line_input, "del"))
1227         is_add = 0;
1228       else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name))
1229         locator_set_name_set = 1;
1230       else if (unformat (line_input, "iface %U p %d w %d",
1231                          unformat_vnet_sw_interface, vnm,
1232                          &locator.sw_if_index, &locator.priority,
1233                          &locator.weight))
1234         {
1235           locator.local = 1;
1236           vec_add1 (locators, locator);
1237         }
1238       else
1239         {
1240           error = unformat_parse_error (line_input);
1241           goto done;
1242         }
1243     }
1244
1245   if (!locator_set_name_set)
1246     {
1247       error = clib_error_return (0, "locator_set name not set!");
1248       goto done;
1249     }
1250
1251   a->name = locator_set_name;
1252   a->locators = locators;
1253   a->is_add = is_add;
1254   a->local = 1;
1255
1256   vnet_lisp_add_del_locator (a, 0, &ls_index);
1257
1258 done:
1259   vec_free (locators);
1260   vec_free (locator_set_name);
1261   unformat_free (line_input);
1262   return error;
1263 }
1264
1265 /* *INDENT-OFF* */
1266 VLIB_CLI_COMMAND (one_cp_add_del_locator_in_set_command) = {
1267     .path = "one locator",
1268     .short_help = "one locator add/del locator-set <name> iface <iface-name> "
1269                   "p <priority> w <weight>",
1270     .function = lisp_add_del_locator_in_set_command_fn,
1271 };
1272 /* *INDENT-ON* */
1273
1274 static clib_error_t *
1275 lisp_cp_show_locator_sets_command_fn (vlib_main_t * vm,
1276                                       unformat_input_t * input,
1277                                       vlib_cli_command_t * cmd)
1278 {
1279   locator_set_t *lsit;
1280   locator_t *loc;
1281   u32 *locit;
1282   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1283
1284   vlib_cli_output (vm, "%s%=16s%=16s%=16s", "Locator-set", "Locator",
1285                    "Priority", "Weight");
1286
1287   /* *INDENT-OFF* */
1288   pool_foreach (lsit, lcm->locator_set_pool,
1289   ({
1290     u8 * msg = 0;
1291     int next_line = 0;
1292     if (lsit->local)
1293       {
1294         msg = format (msg, "%v", lsit->name);
1295       }
1296     else
1297       {
1298         msg = format (msg, "<%s-%d>", "remote", lsit - lcm->locator_set_pool);
1299       }
1300     vec_foreach (locit, lsit->locator_indices)
1301       {
1302         if (next_line)
1303           {
1304             msg = format (msg, "%16s", " ");
1305           }
1306         loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
1307         if (loc->local)
1308           msg = format (msg, "%16d%16d%16d\n", loc->sw_if_index, loc->priority,
1309                         loc->weight);
1310         else
1311           msg = format (msg, "%16U%16d%16d\n", format_ip_address,
1312                         &gid_address_ip(&loc->address), loc->priority,
1313                         loc->weight);
1314         next_line = 1;
1315       }
1316     vlib_cli_output (vm, "%v", msg);
1317     vec_free (msg);
1318   }));
1319   /* *INDENT-ON* */
1320   return 0;
1321 }
1322
1323 /* *INDENT-OFF* */
1324 VLIB_CLI_COMMAND (one_cp_show_locator_sets_command) = {
1325     .path = "show one locator-set",
1326     .short_help = "Shows locator-sets",
1327     .function = lisp_cp_show_locator_sets_command_fn,
1328 };
1329 /* *INDENT-ON* */
1330
1331
1332 static clib_error_t *
1333 lisp_add_del_map_resolver_command_fn (vlib_main_t * vm,
1334                                       unformat_input_t * input,
1335                                       vlib_cli_command_t * cmd)
1336 {
1337   unformat_input_t _line_input, *line_input = &_line_input;
1338   u8 is_add = 1, addr_set = 0;
1339   ip_address_t ip_addr;
1340   clib_error_t *error = 0;
1341   int rv = 0;
1342   vnet_lisp_add_del_map_resolver_args_t _a, *a = &_a;
1343
1344   /* Get a line of input. */
1345   if (!unformat_user (input, unformat_line_input, line_input))
1346     return 0;
1347
1348   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1349     {
1350       if (unformat (line_input, "add"))
1351         is_add = 1;
1352       else if (unformat (line_input, "del"))
1353         is_add = 0;
1354       else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr))
1355         addr_set = 1;
1356       else
1357         {
1358           error = unformat_parse_error (line_input);
1359           goto done;
1360         }
1361     }
1362
1363   if (!addr_set)
1364     {
1365       error = clib_error_return (0, "Map-resolver address must be set!");
1366       goto done;
1367     }
1368
1369   a->is_add = is_add;
1370   a->address = ip_addr;
1371   rv = vnet_lisp_add_del_map_resolver (a);
1372   if (0 != rv)
1373     {
1374       error = clib_error_return (0, "failed to %s map-resolver!",
1375                                  is_add ? "add" : "delete");
1376     }
1377
1378 done:
1379   unformat_free (line_input);
1380   return error;
1381 }
1382
1383 /* *INDENT-OFF* */
1384 VLIB_CLI_COMMAND (one_add_del_map_resolver_command) = {
1385     .path = "one map-resolver",
1386     .short_help = "one map-resolver add/del <ip_address>",
1387     .function = lisp_add_del_map_resolver_command_fn,
1388 };
1389 /* *INDENT-ON* */
1390
1391
1392 static clib_error_t *
1393 lisp_add_del_mreq_itr_rlocs_command_fn (vlib_main_t * vm,
1394                                         unformat_input_t * input,
1395                                         vlib_cli_command_t * cmd)
1396 {
1397   unformat_input_t _line_input, *line_input = &_line_input;
1398   u8 is_add = 1;
1399   u8 *locator_set_name = 0;
1400   clib_error_t *error = 0;
1401   int rv = 0;
1402   vnet_lisp_add_del_mreq_itr_rloc_args_t _a, *a = &_a;
1403
1404   /* Get a line of input. */
1405   if (!unformat_user (input, unformat_line_input, line_input))
1406     return 0;
1407
1408   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1409     {
1410       if (unformat (line_input, "del"))
1411         is_add = 0;
1412       else if (unformat (line_input, "add %_%v%_", &locator_set_name))
1413         is_add = 1;
1414       else
1415         {
1416           error = unformat_parse_error (line_input);
1417           goto done;
1418         }
1419     }
1420
1421   a->is_add = is_add;
1422   a->locator_set_name = locator_set_name;
1423   rv = vnet_lisp_add_del_mreq_itr_rlocs (a);
1424   if (0 != rv)
1425     {
1426       error = clib_error_return (0, "failed to %s map-request itr-rlocs!",
1427                                  is_add ? "add" : "delete");
1428     }
1429
1430 done:
1431   vec_free (locator_set_name);
1432   unformat_free (line_input);
1433   return error;
1434
1435 }
1436
1437 /* *INDENT-OFF* */
1438 VLIB_CLI_COMMAND (one_add_del_map_request_command) = {
1439     .path = "one map-request itr-rlocs",
1440     .short_help = "one map-request itr-rlocs add/del <locator_set_name>",
1441     .function = lisp_add_del_mreq_itr_rlocs_command_fn,
1442 };
1443 /* *INDENT-ON* */
1444
1445 static clib_error_t *
1446 lisp_show_mreq_itr_rlocs_command_fn (vlib_main_t * vm,
1447                                      unformat_input_t * input,
1448                                      vlib_cli_command_t * cmd)
1449 {
1450   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1451   locator_set_t *loc_set;
1452
1453   vlib_cli_output (vm, "%=20s", "itr-rlocs");
1454
1455   if (~0 == lcm->mreq_itr_rlocs)
1456     {
1457       return 0;
1458     }
1459
1460   loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1461
1462   vlib_cli_output (vm, "%=20s", loc_set->name);
1463
1464   return 0;
1465 }
1466
1467 /* *INDENT-OFF* */
1468 VLIB_CLI_COMMAND (one_show_map_request_command) = {
1469     .path = "show one map-request itr-rlocs",
1470     .short_help = "Shows map-request itr-rlocs",
1471     .function = lisp_show_mreq_itr_rlocs_command_fn,
1472 };
1473 /* *INDENT-ON* */
1474
1475 static clib_error_t *
1476 lisp_use_petr_set_locator_set_command_fn (vlib_main_t * vm,
1477                                           unformat_input_t * input,
1478                                           vlib_cli_command_t * cmd)
1479 {
1480   u8 is_add = 1, ip_set = 0;
1481   unformat_input_t _line_input, *line_input = &_line_input;
1482   clib_error_t *error = 0;
1483   ip_address_t ip;
1484
1485   /* Get a line of input. */
1486   if (!unformat_user (input, unformat_line_input, line_input))
1487     return 0;
1488
1489   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1490     {
1491       if (unformat (line_input, "%U", unformat_ip_address, &ip))
1492         ip_set = 1;
1493       else if (unformat (line_input, "disable"))
1494         is_add = 0;
1495       else
1496         {
1497           error = clib_error_return (0, "parse error");
1498           goto done;
1499         }
1500     }
1501
1502   if (!ip_set)
1503     {
1504       clib_warning ("No petr IP specified!");
1505       goto done;
1506     }
1507
1508   if (vnet_lisp_use_petr (&ip, is_add))
1509     {
1510       error = clib_error_return (0, "failed to %s petr!",
1511                                  is_add ? "add" : "delete");
1512     }
1513
1514 done:
1515   unformat_free (line_input);
1516   return error;
1517 }
1518
1519 /* *INDENT-OFF* */
1520 VLIB_CLI_COMMAND (one_use_petr_set_locator_set_command) = {
1521     .path = "one use-petr",
1522     .short_help = "one use-petr [disable] <petr-ip>",
1523     .function = lisp_use_petr_set_locator_set_command_fn,
1524 };
1525
1526 static clib_error_t *
1527 lisp_show_petr_command_fn (vlib_main_t * vm,
1528                            unformat_input_t * input, vlib_cli_command_t * cmd)
1529 {
1530   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1531   mapping_t *m;
1532   locator_set_t *ls;
1533   locator_t *loc;
1534   u8 *tmp_str = 0;
1535   u8 use_petr = lcm->flags & LISP_FLAG_USE_PETR;
1536   vlib_cli_output (vm, "%=20s%=16s", "petr", use_petr ? "ip" : "");
1537
1538   if (!use_petr)
1539     {
1540       vlib_cli_output (vm, "%=20s", "disable");
1541       return 0;
1542     }
1543
1544   if (~0 == lcm->petr_map_index)
1545     {
1546       tmp_str = format (0, "N/A");
1547     }
1548   else
1549     {
1550       m = pool_elt_at_index (lcm->mapping_pool, lcm->petr_map_index);
1551       if (~0 != m->locator_set_index)
1552         {
1553           ls = pool_elt_at_index(lcm->locator_set_pool, m->locator_set_index);
1554           loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
1555           tmp_str = format (0, "%U", format_ip_address, &loc->address);
1556         }
1557       else
1558         {
1559           tmp_str = format (0, "N/A");
1560         }
1561     }
1562   vec_add1 (tmp_str, 0);
1563
1564   vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
1565
1566   vec_free (tmp_str);
1567
1568   return 0;
1569 }
1570
1571 /* *INDENT-OFF* */
1572 VLIB_CLI_COMMAND (one_show_petr_command) = {
1573     .path = "show one petr",
1574     .short_help = "Show petr",
1575     .function = lisp_show_petr_command_fn,
1576 };
1577 /* *INDENT-ON* */
1578
1579 static clib_error_t *
1580 lisp_show_map_servers_command_fn (vlib_main_t * vm,
1581                                   unformat_input_t * input,
1582                                   vlib_cli_command_t * cmd)
1583 {
1584   lisp_msmr_t *ms;
1585   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1586
1587   vec_foreach (ms, lcm->map_servers)
1588   {
1589     vlib_cli_output (vm, "%U", format_ip_address, &ms->address);
1590   }
1591   return 0;
1592 }
1593
1594 /* *INDENT-OFF* */
1595 VLIB_CLI_COMMAND (one_show_map_servers_command) = {
1596     .path = "show one map-servers",
1597     .short_help = "show one map servers",
1598     .function = lisp_show_map_servers_command_fn,
1599 };
1600 /* *INDENT-ON* */
1601
1602 static clib_error_t *
1603 lisp_show_map_register_state_command_fn (vlib_main_t * vm,
1604                                          unformat_input_t * input,
1605                                          vlib_cli_command_t * cmd)
1606 {
1607   u8 *msg = 0;
1608   u8 is_enabled = vnet_lisp_map_register_state_get ();
1609
1610   msg = format (msg, "%s\n", is_enabled ? "enabled" : "disabled");
1611   vlib_cli_output (vm, "%v", msg);
1612   vec_free (msg);
1613   return 0;
1614 }
1615
1616 /* *INDENT-OFF* */
1617 VLIB_CLI_COMMAND (one_show_map_register_state_command) = {
1618     .path = "show one map-register state",
1619     .short_help = "show one map-register state",
1620     .function = lisp_show_map_register_state_command_fn,
1621 };
1622 /* *INDENT-ON* */
1623
1624 static clib_error_t *
1625 lisp_show_rloc_probe_state_command_fn (vlib_main_t * vm,
1626                                        unformat_input_t * input,
1627                                        vlib_cli_command_t * cmd)
1628 {
1629   u8 *msg = 0;
1630   u8 is_enabled = vnet_lisp_rloc_probe_state_get ();
1631
1632   msg = format (msg, "%s\n", is_enabled ? "enabled" : "disabled");
1633   vlib_cli_output (vm, "%v", msg);
1634   vec_free (msg);
1635   return 0;
1636 }
1637
1638 /* *INDENT-OFF* */
1639 VLIB_CLI_COMMAND (one_show_rloc_probe_state_command) = {
1640     .path = "show one rloc state",
1641     .short_help = "show one RLOC state",
1642     .function = lisp_show_rloc_probe_state_command_fn,
1643 };
1644 /* *INDENT-ON* */
1645
1646 static clib_error_t *
1647 lisp_show_stats_command_fn (vlib_main_t * vm,
1648                             unformat_input_t * input,
1649                             vlib_cli_command_t * cmd)
1650 {
1651   u8 is_enabled = vnet_lisp_stats_enable_disable_state ();
1652   vlib_cli_output (vm, "%s\n", is_enabled ? "enabled" : "disabled");
1653   return 0;
1654 }
1655
1656 /* *INDENT-OFF* */
1657 VLIB_CLI_COMMAND (one_show_stats_command) = {
1658     .path = "show one statistics status",
1659     .short_help = "show ONE statistics enable/disable status",
1660     .function = lisp_show_stats_command_fn,
1661 };
1662 /* *INDENT-ON* */
1663
1664 static clib_error_t *
1665 lisp_show_stats_details_command_fn (vlib_main_t * vm,
1666                                     unformat_input_t * input,
1667                                     vlib_cli_command_t * cmd)
1668 {
1669   lisp_api_stats_t *stat, *stats = vnet_lisp_get_stats ();
1670
1671   if (vec_len (stats) > 0)
1672     vlib_cli_output (vm,
1673                      "[src-EID, dst-EID] [loc-rloc, rmt-rloc] count bytes\n");
1674   else
1675     vlib_cli_output (vm, "No statistics found.\n");
1676
1677   vec_foreach (stat, stats)
1678   {
1679     vlib_cli_output (vm, "[%U, %U] [%U, %U] %7u %7u\n",
1680                      format_fid_address, &stat->seid,
1681                      format_fid_address, &stat->deid,
1682                      format_ip_address, &stat->loc_rloc,
1683                      format_ip_address, &stat->rmt_rloc,
1684                      stat->stats.pkt_count, stat->stats.bytes);
1685   }
1686   vec_free (stats);
1687   return 0;
1688 }
1689
1690 /* *INDENT-OFF* */
1691 VLIB_CLI_COMMAND (one_show_stats_details_command) = {
1692     .path = "show one statistics details",
1693     .short_help = "show ONE statistics",
1694     .function = lisp_show_stats_details_command_fn,
1695 };
1696 /* *INDENT-ON* */
1697
1698 static clib_error_t *
1699 lisp_stats_enable_disable_command_fn (vlib_main_t * vm,
1700                                       unformat_input_t * input,
1701                                       vlib_cli_command_t * cmd)
1702 {
1703   unformat_input_t _line_input, *line_input = &_line_input;
1704   u8 enable = 0;
1705
1706   /* Get a line of input. */
1707   if (!unformat_user (input, unformat_line_input, line_input))
1708     return 0;
1709
1710   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1711     {
1712       if (unformat (line_input, "enable"))
1713         enable = 1;
1714       else if (unformat (line_input, "disable"))
1715         enable = 0;
1716       else
1717         {
1718           clib_warning ("Error: expected enable/disable!");
1719           goto done;
1720         }
1721     }
1722   vnet_lisp_stats_enable_disable (enable);
1723 done:
1724   unformat_free (line_input);
1725   return 0;
1726 }
1727
1728 /* *INDENT-OFF* */
1729 VLIB_CLI_COMMAND (one_stats_enable_disable_command) = {
1730     .path = "one statistics",
1731     .short_help = "enable/disable ONE statistics collecting",
1732     .function = lisp_stats_enable_disable_command_fn,
1733 };
1734 /* *INDENT-ON* */
1735
1736 static clib_error_t *
1737 lisp_stats_flush_command_fn (vlib_main_t * vm,
1738                              unformat_input_t * input,
1739                              vlib_cli_command_t * cmd)
1740 {
1741   vnet_lisp_flush_stats ();
1742   return 0;
1743 }
1744
1745 /* *INDENT-OFF* */
1746 VLIB_CLI_COMMAND (one_stats_flush_command) = {
1747     .path = "one statistics flush",
1748     .short_help = "Flush ONE statistics",
1749     .function = lisp_stats_flush_command_fn,
1750 };
1751 /* *INDENT-ON* */
1752
1753 /*
1754  * fd.io coding-style-patch-verification: ON
1755  *
1756  * Local Variables:
1757  * eval: (c-set-style "gnu")
1758  * End:
1759  */