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         locator_set_t * ls = pool_elt_at_index (lcm->locator_set_pool,
 826                                                 mapit->locator_set_index);
 827         if (filter && !((1 == filter && ls->local) ||
 828           (2 == filter && !ls->local)))
 829           {
 830             continue;
 831           }
 832         vlib_cli_output (vm, "%U", format_eid_entry, lcm->vnet_main,
 833                          lcm, mapit, ls);
 834       }));
 835       /* *INDENT-ON* */
 836     }
 837   else
 838     {
 839       mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &eid);
 840       if ((u32) ~ 0 == mi)
 841         goto done;
 842
 843       mapit = pool_elt_at_index (lcm->mapping_pool, mi);
 844       locator_set_t *ls = pool_elt_at_index (lcm->locator_set_pool,
 845                                              mapit->locator_set_index);
 846
 847       if (filter && !((1 == filter && ls->local) ||
 848                       (2 == filter && !ls->local)))
 849         {
 850           goto done;
 851         }
 852
 853       vlib_cli_output (vm, "%U,", format_eid_entry, lcm->vnet_main,
 854                        lcm, mapit, ls);
 855     }
 856
 857 done:
 858   unformat_free (line_input);
 859
 860   return error;
 861 }
 862
 863 /* *INDENT-OFF* */
 864 VLIB_CLI_COMMAND (one_cp_show_eid_table_command) = {
 865     .path = "show one eid-table",
 866     .short_help = "Shows EID table",
 867     .function = lisp_show_eid_table_command_fn,
 868 };
 869 /* *INDENT-ON* */
 870
 871
 872 static clib_error_t *
 873 lisp_enable_disable_command_fn (vlib_main_t * vm, unformat_input_t * input,
 874                                 vlib_cli_command_t * cmd)
 875 {
 876   unformat_input_t _line_input, *line_input = &_line_input;
 877   u8 is_enabled = 0;
 878   u8 is_set = 0;
 879   clib_error_t *error = NULL;
 880
 881   /* Get a line of input. */
 882   if (!unformat_user (input, unformat_line_input, line_input))
 883     return 0;
 884
 885   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 886     {
 887       if (unformat (line_input, "enable"))
 888         {
 889           is_set = 1;
 890           is_enabled = 1;
 891         }
 892       else if (unformat (line_input, "disable"))
 893         is_set = 1;
 894       else
 895         {
 896           error = clib_error_return (0, "parse error: '%U'",
 897                                      format_unformat_error, line_input);
 898           goto done;
 899         }
 900     }
 901
 902   if (!is_set)
 903     {
 904       error = clib_error_return (0, "state not set");
 905       goto done;
 906     }
 907
 908   vnet_lisp_enable_disable (is_enabled);
 909
 910 done:
 911   unformat_free (line_input);
 912
 913   return error;
 914 }
 915
 916 /* *INDENT-OFF* */
 917 VLIB_CLI_COMMAND (one_cp_enable_disable_command) = {
 918     .path = "one",
 919     .short_help = "one [enable|disable]",
 920     .function = lisp_enable_disable_command_fn,
 921 };
 922 /* *INDENT-ON* */
 923
 924 static clib_error_t *
 925 lisp_map_register_enable_disable_command_fn (vlib_main_t * vm,
 926                                              unformat_input_t * input,
 927                                              vlib_cli_command_t * cmd)
 928 {
 929   unformat_input_t _line_input, *line_input = &_line_input;
 930   u8 is_enabled = 0;
 931   u8 is_set = 0;
 932   clib_error_t *error = NULL;
 933
 934   /* Get a line of input. */
 935   if (!unformat_user (input, unformat_line_input, line_input))
 936     return 0;
 937
 938   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 939     {
 940       if (unformat (line_input, "enable"))
 941         {
 942           is_set = 1;
 943           is_enabled = 1;
 944         }
 945       else if (unformat (line_input, "disable"))
 946         is_set = 1;
 947       else
 948         {
 949           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
 950                            line_input);
 951           goto done;
 952         }
 953     }
 954
 955   if (!is_set)
 956     {
 957       vlib_cli_output (vm, "state not set!");
 958       goto done;
 959     }
 960
 961   vnet_lisp_map_register_enable_disable (is_enabled);
 962
 963 done:
 964   unformat_free (line_input);
 965
 966   return error;
 967 }
 968
 969 /* *INDENT-OFF* */
 970 VLIB_CLI_COMMAND (one_map_register_enable_disable_command) = {
 971     .path = "one map-register",
 972     .short_help = "one map-register [enable|disable]",
 973     .function = lisp_map_register_enable_disable_command_fn,
 974 };
 975 /* *INDENT-ON* */
 976
 977 static clib_error_t *
 978 lisp_rloc_probe_enable_disable_command_fn (vlib_main_t * vm,
 979                                            unformat_input_t * input,
 980                                            vlib_cli_command_t * cmd)
 981 {
 982   unformat_input_t _line_input, *line_input = &_line_input;
 983   u8 is_enabled = 0;
 984   u8 is_set = 0;
 985   clib_error_t *error = NULL;
 986
 987   /* Get a line of input. */
 988   if (!unformat_user (input, unformat_line_input, line_input))
 989     return 0;
 990
 991   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 992     {
 993       if (unformat (line_input, "enable"))
 994         {
 995           is_set = 1;
 996           is_enabled = 1;
 997         }
 998       else if (unformat (line_input, "disable"))
 999         is_set = 1;
1000       else
1001         {
1002           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1003                            line_input);
1004           goto done;
1005         }
1006     }
1007
1008   if (!is_set)
1009     {
1010       vlib_cli_output (vm, "state not set!");
1011       goto done;
1012     }
1013
1014   vnet_lisp_rloc_probe_enable_disable (is_enabled);
1015
1016 done:
1017   unformat_free (line_input);
1018
1019   return error;
1020 }
1021
1022 /* *INDENT-OFF* */
1023 VLIB_CLI_COMMAND (one_rloc_probe_enable_disable_command) = {
1024     .path = "one rloc-probe",
1025     .short_help = "one rloc-probe [enable|disable]",
1026     .function = lisp_rloc_probe_enable_disable_command_fn,
1027 };
1028 /* *INDENT-ON* */
1029
1030 static u8 *
1031 format_lisp_status (u8 * s, va_list * args)
1032 {
1033   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1034   return format (s, "%s", lcm->is_enabled ? "enabled" : "disabled");
1035 }
1036
1037 static clib_error_t *
1038 lisp_show_status_command_fn (vlib_main_t * vm, unformat_input_t * input,
1039                              vlib_cli_command_t * cmd)
1040 {
1041   u8 *msg = 0;
1042   msg = format (msg, "feature: %U\ngpe: %U\n",
1043                 format_lisp_status, format_vnet_lisp_gpe_status);
1044   vlib_cli_output (vm, "%v", msg);
1045   vec_free (msg);
1046   return 0;
1047 }
1048
1049 /* *INDENT-OFF* */
1050 VLIB_CLI_COMMAND (one_show_status_command) = {
1051     .path = "show one status",
1052     .short_help = "show one status",
1053     .function = lisp_show_status_command_fn,
1054 };
1055 /* *INDENT-ON* */
1056
1057 static clib_error_t *
1058 lisp_show_eid_table_map_command_fn (vlib_main_t * vm,
1059                                     unformat_input_t * input,
1060                                     vlib_cli_command_t * cmd)
1061 {
1062   hash_pair_t *p;
1063   unformat_input_t _line_input, *line_input = &_line_input;
1064   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1065   uword *vni_table = 0;
1066   u8 is_l2 = 0;
1067   clib_error_t *error = NULL;
1068
1069   /* Get a line of input. */
1070   if (!unformat_user (input, unformat_line_input, line_input))
1071     return 0;
1072
1073   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1074     {
1075       if (unformat (line_input, "l2"))
1076         {
1077           vni_table = lcm->bd_id_by_vni;
1078           is_l2 = 1;
1079         }
1080       else if (unformat (line_input, "l3"))
1081         {
1082           vni_table = lcm->table_id_by_vni;
1083           is_l2 = 0;
1084         }
1085       else
1086         {
1087           error = clib_error_return (0, "parse error: '%U'",
1088                                      format_unformat_error, line_input);
1089           goto done;
1090         }
1091     }
1092
1093   if (!vni_table)
1094     {
1095       vlib_cli_output (vm, "Error: expected l2|l3 param!\n");
1096       goto done;
1097     }
1098
1099   vlib_cli_output (vm, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
1100
1101   /* *INDENT-OFF* */
1102   hash_foreach_pair (p, vni_table,
1103   ({
1104     vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]);
1105   }));
1106   /* *INDENT-ON* */
1107
1108 done:
1109   unformat_free (line_input);
1110
1111   return error;
1112 }
1113
1114 /* *INDENT-OFF* */
1115 VLIB_CLI_COMMAND (one_show_eid_table_map_command) = {
1116     .path = "show one eid-table map",
1117     .short_help = "show one eid-table l2|l3",
1118     .function = lisp_show_eid_table_map_command_fn,
1119 };
1120 /* *INDENT-ON* */
1121
1122
1123 static clib_error_t *
1124 lisp_add_del_locator_set_command_fn (vlib_main_t * vm,
1125                                      unformat_input_t * input,
1126                                      vlib_cli_command_t * cmd)
1127 {
1128   lisp_gpe_main_t *lgm = &lisp_gpe_main;
1129   vnet_main_t *vnm = lgm->vnet_main;
1130   unformat_input_t _line_input, *line_input = &_line_input;
1131   u8 is_add = 1;
1132   clib_error_t *error = 0;
1133   u8 *locator_set_name = 0;
1134   locator_t locator, *locators = 0;
1135   vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
1136   u32 ls_index = 0;
1137   int rv = 0;
1138
1139   memset (&locator, 0, sizeof (locator));
1140   memset (a, 0, sizeof (a[0]));
1141
1142   /* Get a line of input. */
1143   if (!unformat_user (input, unformat_line_input, line_input))
1144     return 0;
1145
1146   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1147     {
1148       if (unformat (line_input, "add %_%v%_", &locator_set_name))
1149         is_add = 1;
1150       else if (unformat (line_input, "del %_%v%_", &locator_set_name))
1151         is_add = 0;
1152       else if (unformat (line_input, "iface %U p %d w %d",
1153                          unformat_vnet_sw_interface, vnm,
1154                          &locator.sw_if_index, &locator.priority,
1155                          &locator.weight))
1156         {
1157           locator.local = 1;
1158           vec_add1 (locators, locator);
1159         }
1160       else
1161         {
1162           error = unformat_parse_error (line_input);
1163           goto done;
1164         }
1165     }
1166
1167   a->name = locator_set_name;
1168   a->locators = locators;
1169   a->is_add = is_add;
1170   a->local = 1;
1171
1172   rv = vnet_lisp_add_del_locator_set (a, &ls_index);
1173   if (0 != rv)
1174     {
1175       error = clib_error_return (0, "failed to %s locator-set!",
1176                                  is_add ? "add" : "delete");
1177     }
1178
1179 done:
1180   vec_free (locators);
1181   if (locator_set_name)
1182     vec_free (locator_set_name);
1183   unformat_free (line_input);
1184   return error;
1185 }
1186
1187 /* *INDENT-OFF* */
1188 VLIB_CLI_COMMAND (one_cp_add_del_locator_set_command) = {
1189     .path = "one locator-set",
1190     .short_help = "one locator-set add/del <name> [iface <iface-name> "
1191         "p <priority> w <weight>]",
1192     .function = lisp_add_del_locator_set_command_fn,
1193 };
1194 /* *INDENT-ON* */
1195
1196 static clib_error_t *
1197 lisp_add_del_locator_in_set_command_fn (vlib_main_t * vm,
1198                                         unformat_input_t * input,
1199                                         vlib_cli_command_t * cmd)
1200 {
1201   lisp_gpe_main_t *lgm = &lisp_gpe_main;
1202   vnet_main_t *vnm = lgm->vnet_main;
1203   unformat_input_t _line_input, *line_input = &_line_input;
1204   u8 is_add = 1;
1205   clib_error_t *error = 0;
1206   u8 *locator_set_name = 0;
1207   u8 locator_set_name_set = 0;
1208   locator_t locator, *locators = 0;
1209   vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
1210   u32 ls_index = 0;
1211
1212   memset (&locator, 0, sizeof (locator));
1213   memset (a, 0, sizeof (a[0]));
1214
1215   /* Get a line of input. */
1216   if (!unformat_user (input, unformat_line_input, line_input))
1217     return 0;
1218
1219   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1220     {
1221       if (unformat (line_input, "add"))
1222         is_add = 1;
1223       else if (unformat (line_input, "del"))
1224         is_add = 0;
1225       else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name))
1226         locator_set_name_set = 1;
1227       else if (unformat (line_input, "iface %U p %d w %d",
1228                          unformat_vnet_sw_interface, vnm,
1229                          &locator.sw_if_index, &locator.priority,
1230                          &locator.weight))
1231         {
1232           locator.local = 1;
1233           vec_add1 (locators, locator);
1234         }
1235       else
1236         {
1237           error = unformat_parse_error (line_input);
1238           goto done;
1239         }
1240     }
1241
1242   if (!locator_set_name_set)
1243     {
1244       error = clib_error_return (0, "locator_set name not set!");
1245       goto done;
1246     }
1247
1248   a->name = locator_set_name;
1249   a->locators = locators;
1250   a->is_add = is_add;
1251   a->local = 1;
1252
1253   vnet_lisp_add_del_locator (a, 0, &ls_index);
1254
1255 done:
1256   vec_free (locators);
1257   vec_free (locator_set_name);
1258   unformat_free (line_input);
1259   return error;
1260 }
1261
1262 /* *INDENT-OFF* */
1263 VLIB_CLI_COMMAND (one_cp_add_del_locator_in_set_command) = {
1264     .path = "one locator",
1265     .short_help = "one locator add/del locator-set <name> iface <iface-name> "
1266                   "p <priority> w <weight>",
1267     .function = lisp_add_del_locator_in_set_command_fn,
1268 };
1269 /* *INDENT-ON* */
1270
1271 static clib_error_t *
1272 lisp_cp_show_locator_sets_command_fn (vlib_main_t * vm,
1273                                       unformat_input_t * input,
1274                                       vlib_cli_command_t * cmd)
1275 {
1276   locator_set_t *lsit;
1277   locator_t *loc;
1278   u32 *locit;
1279   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1280
1281   vlib_cli_output (vm, "%s%=16s%=16s%=16s", "Locator-set", "Locator",
1282                    "Priority", "Weight");
1283
1284   /* *INDENT-OFF* */
1285   pool_foreach (lsit, lcm->locator_set_pool,
1286   ({
1287     u8 * msg = 0;
1288     int next_line = 0;
1289     if (lsit->local)
1290       {
1291         msg = format (msg, "%v", lsit->name);
1292       }
1293     else
1294       {
1295         msg = format (msg, "<%s-%d>", "remote", lsit - lcm->locator_set_pool);
1296       }
1297     vec_foreach (locit, lsit->locator_indices)
1298       {
1299         if (next_line)
1300           {
1301             msg = format (msg, "%16s", " ");
1302           }
1303         loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
1304         if (loc->local)
1305           msg = format (msg, "%16d%16d%16d\n", loc->sw_if_index, loc->priority,
1306                         loc->weight);
1307         else
1308           msg = format (msg, "%16U%16d%16d\n", format_ip_address,
1309                         &gid_address_ip(&loc->address), loc->priority,
1310                         loc->weight);
1311         next_line = 1;
1312       }
1313     vlib_cli_output (vm, "%v", msg);
1314     vec_free (msg);
1315   }));
1316   /* *INDENT-ON* */
1317   return 0;
1318 }
1319
1320 /* *INDENT-OFF* */
1321 VLIB_CLI_COMMAND (one_cp_show_locator_sets_command) = {
1322     .path = "show one locator-set",
1323     .short_help = "Shows locator-sets",
1324     .function = lisp_cp_show_locator_sets_command_fn,
1325 };
1326 /* *INDENT-ON* */
1327
1328
1329 static clib_error_t *
1330 lisp_add_del_map_resolver_command_fn (vlib_main_t * vm,
1331                                       unformat_input_t * input,
1332                                       vlib_cli_command_t * cmd)
1333 {
1334   unformat_input_t _line_input, *line_input = &_line_input;
1335   u8 is_add = 1, addr_set = 0;
1336   ip_address_t ip_addr;
1337   clib_error_t *error = 0;
1338   int rv = 0;
1339   vnet_lisp_add_del_map_resolver_args_t _a, *a = &_a;
1340
1341   /* Get a line of input. */
1342   if (!unformat_user (input, unformat_line_input, line_input))
1343     return 0;
1344
1345   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1346     {
1347       if (unformat (line_input, "add"))
1348         is_add = 1;
1349       else if (unformat (line_input, "del"))
1350         is_add = 0;
1351       else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr))
1352         addr_set = 1;
1353       else
1354         {
1355           error = unformat_parse_error (line_input);
1356           goto done;
1357         }
1358     }
1359
1360   if (!addr_set)
1361     {
1362       error = clib_error_return (0, "Map-resolver address must be set!");
1363       goto done;
1364     }
1365
1366   a->is_add = is_add;
1367   a->address = ip_addr;
1368   rv = vnet_lisp_add_del_map_resolver (a);
1369   if (0 != rv)
1370     {
1371       error = clib_error_return (0, "failed to %s map-resolver!",
1372                                  is_add ? "add" : "delete");
1373     }
1374
1375 done:
1376   unformat_free (line_input);
1377   return error;
1378 }
1379
1380 /* *INDENT-OFF* */
1381 VLIB_CLI_COMMAND (one_add_del_map_resolver_command) = {
1382     .path = "one map-resolver",
1383     .short_help = "one map-resolver add/del <ip_address>",
1384     .function = lisp_add_del_map_resolver_command_fn,
1385 };
1386 /* *INDENT-ON* */
1387
1388
1389 static clib_error_t *
1390 lisp_add_del_mreq_itr_rlocs_command_fn (vlib_main_t * vm,
1391                                         unformat_input_t * input,
1392                                         vlib_cli_command_t * cmd)
1393 {
1394   unformat_input_t _line_input, *line_input = &_line_input;
1395   u8 is_add = 1;
1396   u8 *locator_set_name = 0;
1397   clib_error_t *error = 0;
1398   int rv = 0;
1399   vnet_lisp_add_del_mreq_itr_rloc_args_t _a, *a = &_a;
1400
1401   /* Get a line of input. */
1402   if (!unformat_user (input, unformat_line_input, line_input))
1403     return 0;
1404
1405   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1406     {
1407       if (unformat (line_input, "del"))
1408         is_add = 0;
1409       else if (unformat (line_input, "add %_%v%_", &locator_set_name))
1410         is_add = 1;
1411       else
1412         {
1413           error = unformat_parse_error (line_input);
1414           goto done;
1415         }
1416     }
1417
1418   a->is_add = is_add;
1419   a->locator_set_name = locator_set_name;
1420   rv = vnet_lisp_add_del_mreq_itr_rlocs (a);
1421   if (0 != rv)
1422     {
1423       error = clib_error_return (0, "failed to %s map-request itr-rlocs!",
1424                                  is_add ? "add" : "delete");
1425     }
1426
1427 done:
1428   vec_free (locator_set_name);
1429   unformat_free (line_input);
1430   return error;
1431
1432 }
1433
1434 /* *INDENT-OFF* */
1435 VLIB_CLI_COMMAND (one_add_del_map_request_command) = {
1436     .path = "one map-request itr-rlocs",
1437     .short_help = "one map-request itr-rlocs add/del <locator_set_name>",
1438     .function = lisp_add_del_mreq_itr_rlocs_command_fn,
1439 };
1440 /* *INDENT-ON* */
1441
1442 static clib_error_t *
1443 lisp_show_mreq_itr_rlocs_command_fn (vlib_main_t * vm,
1444                                      unformat_input_t * input,
1445                                      vlib_cli_command_t * cmd)
1446 {
1447   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1448   locator_set_t *loc_set;
1449
1450   vlib_cli_output (vm, "%=20s", "itr-rlocs");
1451
1452   if (~0 == lcm->mreq_itr_rlocs)
1453     {
1454       return 0;
1455     }
1456
1457   loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1458
1459   vlib_cli_output (vm, "%=20s", loc_set->name);
1460
1461   return 0;
1462 }
1463
1464 /* *INDENT-OFF* */
1465 VLIB_CLI_COMMAND (one_show_map_request_command) = {
1466     .path = "show one map-request itr-rlocs",
1467     .short_help = "Shows map-request itr-rlocs",
1468     .function = lisp_show_mreq_itr_rlocs_command_fn,
1469 };
1470 /* *INDENT-ON* */
1471
1472 static clib_error_t *
1473 lisp_use_petr_set_locator_set_command_fn (vlib_main_t * vm,
1474                                           unformat_input_t * input,
1475                                           vlib_cli_command_t * cmd)
1476 {
1477   u8 is_add = 1, ip_set = 0;
1478   unformat_input_t _line_input, *line_input = &_line_input;
1479   clib_error_t *error = 0;
1480   ip_address_t ip;
1481
1482   /* Get a line of input. */
1483   if (!unformat_user (input, unformat_line_input, line_input))
1484     return 0;
1485
1486   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1487     {
1488       if (unformat (line_input, "%U", unformat_ip_address, &ip))
1489         ip_set = 1;
1490       else if (unformat (line_input, "disable"))
1491         is_add = 0;
1492       else
1493         {
1494           error = clib_error_return (0, "parse error");
1495           goto done;
1496         }
1497     }
1498
1499   if (!ip_set)
1500     {
1501       clib_warning ("No petr IP specified!");
1502       goto done;
1503     }
1504
1505   if (vnet_lisp_use_petr (&ip, is_add))
1506     {
1507       error = clib_error_return (0, "failed to %s petr!",
1508                                  is_add ? "add" : "delete");
1509     }
1510
1511 done:
1512   unformat_free (line_input);
1513   return error;
1514 }
1515
1516 /* *INDENT-OFF* */
1517 VLIB_CLI_COMMAND (one_use_petr_set_locator_set_command) = {
1518     .path = "one use-petr",
1519     .short_help = "one use-petr [disable] <petr-ip>",
1520     .function = lisp_use_petr_set_locator_set_command_fn,
1521 };
1522
1523 static clib_error_t *
1524 lisp_show_petr_command_fn (vlib_main_t * vm,
1525                            unformat_input_t * input, vlib_cli_command_t * cmd)
1526 {
1527   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1528   mapping_t *m;
1529   locator_set_t *ls;
1530   locator_t *loc;
1531   u8 *tmp_str = 0;
1532   u8 use_petr = lcm->flags & LISP_FLAG_USE_PETR;
1533   vlib_cli_output (vm, "%=20s%=16s", "petr", use_petr ? "ip" : "");
1534
1535   if (!use_petr)
1536     {
1537       vlib_cli_output (vm, "%=20s", "disable");
1538       return 0;
1539     }
1540
1541   if (~0 == lcm->petr_map_index)
1542     {
1543       tmp_str = format (0, "N/A");
1544     }
1545   else
1546     {
1547       m = pool_elt_at_index (lcm->mapping_pool, lcm->petr_map_index);
1548       if (~0 != m->locator_set_index)
1549         {
1550           ls = pool_elt_at_index(lcm->locator_set_pool, m->locator_set_index);
1551           loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
1552           tmp_str = format (0, "%U", format_ip_address, &loc->address);
1553         }
1554       else
1555         {
1556           tmp_str = format (0, "N/A");
1557         }
1558     }
1559   vec_add1 (tmp_str, 0);
1560
1561   vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
1562
1563   vec_free (tmp_str);
1564
1565   return 0;
1566 }
1567
1568 /* *INDENT-OFF* */
1569 VLIB_CLI_COMMAND (one_show_petr_command) = {
1570     .path = "show one petr",
1571     .short_help = "Show petr",
1572     .function = lisp_show_petr_command_fn,
1573 };
1574 /* *INDENT-ON* */
1575
1576 static clib_error_t *
1577 lisp_show_map_servers_command_fn (vlib_main_t * vm,
1578                                   unformat_input_t * input,
1579                                   vlib_cli_command_t * cmd)
1580 {
1581   lisp_msmr_t *ms;
1582   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1583
1584   vec_foreach (ms, lcm->map_servers)
1585   {
1586     vlib_cli_output (vm, "%U", format_ip_address, &ms->address);
1587   }
1588   return 0;
1589 }
1590
1591 /* *INDENT-OFF* */
1592 VLIB_CLI_COMMAND (one_show_map_servers_command) = {
1593     .path = "show one map-servers",
1594     .short_help = "show one map servers",
1595     .function = lisp_show_map_servers_command_fn,
1596 };
1597 /* *INDENT-ON* */
1598
1599 static clib_error_t *
1600 lisp_show_map_register_state_command_fn (vlib_main_t * vm,
1601                                          unformat_input_t * input,
1602                                          vlib_cli_command_t * cmd)
1603 {
1604   u8 *msg = 0;
1605   u8 is_enabled = vnet_lisp_map_register_state_get ();
1606
1607   msg = format (msg, "%s\n", is_enabled ? "enabled" : "disabled");
1608   vlib_cli_output (vm, "%v", msg);
1609   vec_free (msg);
1610   return 0;
1611 }
1612
1613 /* *INDENT-OFF* */
1614 VLIB_CLI_COMMAND (one_show_map_register_state_command) = {
1615     .path = "show one map-register state",
1616     .short_help = "show one map-register state",
1617     .function = lisp_show_map_register_state_command_fn,
1618 };
1619 /* *INDENT-ON* */
1620
1621 static clib_error_t *
1622 lisp_show_rloc_probe_state_command_fn (vlib_main_t * vm,
1623                                        unformat_input_t * input,
1624                                        vlib_cli_command_t * cmd)
1625 {
1626   u8 *msg = 0;
1627   u8 is_enabled = vnet_lisp_rloc_probe_state_get ();
1628
1629   msg = format (msg, "%s\n", is_enabled ? "enabled" : "disabled");
1630   vlib_cli_output (vm, "%v", msg);
1631   vec_free (msg);
1632   return 0;
1633 }
1634
1635 /* *INDENT-OFF* */
1636 VLIB_CLI_COMMAND (one_show_rloc_probe_state_command) = {
1637     .path = "show one rloc state",
1638     .short_help = "show one RLOC state",
1639     .function = lisp_show_rloc_probe_state_command_fn,
1640 };
1641 /* *INDENT-ON* */
1642
1643 static clib_error_t *
1644 lisp_show_stats_command_fn (vlib_main_t * vm,
1645                             unformat_input_t * input,
1646                             vlib_cli_command_t * cmd)
1647 {
1648   u8 is_enabled = vnet_lisp_stats_enable_disable_state ();
1649   vlib_cli_output (vm, "%s\n", is_enabled ? "enabled" : "disabled");
1650   return 0;
1651 }
1652
1653 /* *INDENT-OFF* */
1654 VLIB_CLI_COMMAND (one_show_stats_command) = {
1655     .path = "show one statistics status",
1656     .short_help = "show ONE statistics enable/disable status",
1657     .function = lisp_show_stats_command_fn,
1658 };
1659 /* *INDENT-ON* */
1660
1661 static clib_error_t *
1662 lisp_show_stats_details_command_fn (vlib_main_t * vm,
1663                                     unformat_input_t * input,
1664                                     vlib_cli_command_t * cmd)
1665 {
1666   lisp_api_stats_t *stat, *stats = vnet_lisp_get_stats ();
1667
1668   if (vec_len (stats) > 0)
1669     vlib_cli_output (vm,
1670                      "[src-EID, dst-EID] [loc-rloc, rmt-rloc] count bytes\n");
1671   else
1672     vlib_cli_output (vm, "No statistics found.\n");
1673
1674   vec_foreach (stat, stats)
1675   {
1676     vlib_cli_output (vm, "[%U, %U] [%U, %U] %7u %7u\n",
1677                      format_fid_address, &stat->seid,
1678                      format_fid_address, &stat->deid,
1679                      format_ip_address, &stat->loc_rloc,
1680                      format_ip_address, &stat->rmt_rloc,
1681                      stat->stats.pkt_count, stat->stats.bytes);
1682   }
1683   vec_free (stats);
1684   return 0;
1685 }
1686
1687 /* *INDENT-OFF* */
1688 VLIB_CLI_COMMAND (one_show_stats_details_command) = {
1689     .path = "show one statistics details",
1690     .short_help = "show ONE statistics",
1691     .function = lisp_show_stats_details_command_fn,
1692 };
1693 /* *INDENT-ON* */
1694
1695 static clib_error_t *
1696 lisp_stats_enable_disable_command_fn (vlib_main_t * vm,
1697                                       unformat_input_t * input,
1698                                       vlib_cli_command_t * cmd)
1699 {
1700   unformat_input_t _line_input, *line_input = &_line_input;
1701   u8 enable = 0;
1702
1703   /* Get a line of input. */
1704   if (!unformat_user (input, unformat_line_input, line_input))
1705     return 0;
1706
1707   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1708     {
1709       if (unformat (line_input, "enable"))
1710         enable = 1;
1711       else if (unformat (line_input, "disable"))
1712         enable = 0;
1713       else
1714         {
1715           clib_warning ("Error: expected enable/disable!");
1716           goto done;
1717         }
1718     }
1719   vnet_lisp_stats_enable_disable (enable);
1720 done:
1721   unformat_free (line_input);
1722   return 0;
1723 }
1724
1725 /* *INDENT-OFF* */
1726 VLIB_CLI_COMMAND (one_stats_enable_disable_command) = {
1727     .path = "one statistics",
1728     .short_help = "enable/disable ONE statistics collecting",
1729     .function = lisp_stats_enable_disable_command_fn,
1730 };
1731 /* *INDENT-ON* */
1732
1733 static clib_error_t *
1734 lisp_stats_flush_command_fn (vlib_main_t * vm,
1735                              unformat_input_t * input,
1736                              vlib_cli_command_t * cmd)
1737 {
1738   vnet_lisp_flush_stats ();
1739   return 0;
1740 }
1741
1742 /* *INDENT-OFF* */
1743 VLIB_CLI_COMMAND (one_stats_flush_command) = {
1744     .path = "one statistics flush",
1745     .short_help = "Flush ONE statistics",
1746     .function = lisp_stats_flush_command_fn,
1747 };
1748 /* *INDENT-ON* */
1749
1750 /*
1751  * fd.io coding-style-patch-verification: ON
1752  *
1753  * Local Variables:
1754  * eval: (c-set-style "gnu")
1755  * End:
1756  */