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 static clib_error_t *
 280 lisp_add_del_l2_arp_entry_command_fn (vlib_main_t * vm,
 281                                       unformat_input_t * input,
 282                                       vlib_cli_command_t * cmd)
 283 {
 284   unformat_input_t _line_input, *line_input = &_line_input;
 285   clib_error_t *error = NULL;
 286   int rc = 0;
 287   u8 hw_addr[6], bd = 0;
 288   ip4_address_t ip4;
 289   u32 hw_addr_set = 0, ip_set = 0, is_add = 1;
 290   gid_address_t _arp, *arp = &_arp;
 291
 292   memset (&ip4, 0, sizeof (ip4));
 293   memset (hw_addr, 0, sizeof (hw_addr));
 294   memset (arp, 0, sizeof (*arp));
 295
 296   if (!unformat_user (input, unformat_line_input, line_input))
 297     return 0;
 298
 299   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 300     {
 301       if (unformat (line_input, "mac %U", unformat_mac_address, hw_addr))
 302         hw_addr_set = 1;
 303       else if (unformat (line_input, "ip %U", unformat_ip4_address, &ip4))
 304         ip_set = 1;
 305       else if (unformat (line_input, "del"))
 306         is_add = 0;
 307       else if (unformat (line_input, "bd %d", &bd))
 308         ;
 309       else
 310         {
 311           error = clib_error_return (0, "parse error");
 312           goto done;
 313         }
 314     }
 315
 316   if (!ip_set || (!hw_addr_set && is_add))
 317     {
 318       vlib_cli_output (vm, "expected IP and MAC addresses!");
 319       return 0;
 320     }
 321
 322   /* build GID address */
 323   gid_address_arp_ip4 (arp) = ip4;
 324   gid_address_arp_bd (arp) = bd;
 325   gid_address_type (arp) = GID_ADDR_ARP;
 326   rc = vnet_lisp_add_del_l2_arp_entry (arp, hw_addr, is_add);
 327   if (rc)
 328     clib_warning ("Failed to %s l2 arp entry!", is_add ? "add" : "delete");
 329
 330 done:
 331   unformat_free (line_input);
 332   return error;
 333 }
 334
 335 /* *INDENT-OFF* */
 336 VLIB_CLI_COMMAND (one_add_del_l2_arp_entry_command) = {
 337     .path = "one l2 arp",
 338     .short_help = "one l2 arp [del] bd <bd> mac <mac> ip <ipv4>",
 339     .function = lisp_add_del_l2_arp_entry_command_fn,
 340 };
 341 /* *INDENT-ON* */
 342
 343 static clib_error_t *
 344 lisp_show_l2_arp_entries_command_fn (vlib_main_t * vm,
 345                                      unformat_input_t * input,
 346                                      vlib_cli_command_t * cmd)
 347 {
 348   u32 *ht = vnet_lisp_l2_arp_bds_get ();
 349   lisp_api_l2_arp_entry_t *entries, *e;
 350   hash_pair_t *p;
 351
 352   /* *INDENT-OFF* */
 353   hash_foreach_pair (p, ht,
 354   ({
 355     entries = vnet_lisp_l2_arp_entries_get_by_bd (p->key);
 356     vlib_cli_output (vm, "Table: %d", p->key);
 357
 358     vec_foreach (e, entries)
 359       {
 360         vlib_cli_output (vm, "\t%U -> %U", format_ip4_address, &e->ip4,
 361                          format_mac_address, e->mac);
 362       }
 363     vec_free (entries);
 364   }));
 365   /* *INDENT-ON* */
 366
 367   hash_free (ht);
 368   return 0;
 369 }
 370
 371 /* *INDENT-OFF* */
 372 VLIB_CLI_COMMAND (one_show_l2_arp_entries_command) = {
 373     .path = "show one l2 arp entries",
 374     .short_help = "Show ONE L2 ARP entries",
 375     .function = lisp_show_l2_arp_entries_command_fn,
 376 };
 377 /* *INDENT-ON* */
 378
 379 /**
 380  * Handler for add/del remote mapping CLI.
 381  *
 382  * @param vm vlib context
 383  * @param input input from user
 384  * @param cmd cmd
 385  * @return pointer to clib error structure
 386  */
 387 static clib_error_t *
 388 lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm,
 389                                         unformat_input_t * input,
 390                                         vlib_cli_command_t * cmd)
 391 {
 392   clib_error_t *error = 0;
 393   unformat_input_t _line_input, *line_input = &_line_input;
 394   u8 is_add = 1, del_all = 0;
 395   locator_t rloc, *rlocs = 0, *curr_rloc = 0;
 396   gid_address_t eid;
 397   u8 eid_set = 0;
 398   u32 vni, action = ~0, p, w;
 399   int rv;
 400
 401   /* Get a line of input. */
 402   if (!unformat_user (input, unformat_line_input, line_input))
 403     return 0;
 404
 405   memset (&eid, 0, sizeof (eid));
 406   memset (&rloc, 0, sizeof (rloc));
 407
 408   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 409     {
 410       if (unformat (line_input, "del-all"))
 411         del_all = 1;
 412       else if (unformat (line_input, "del"))
 413         is_add = 0;
 414       else if (unformat (line_input, "add"))
 415         ;
 416       else if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
 417         eid_set = 1;
 418       else if (unformat (line_input, "vni %u", &vni))
 419         {
 420           gid_address_vni (&eid) = vni;
 421         }
 422       else if (unformat (line_input, "p %d w %d", &p, &w))
 423         {
 424           if (!curr_rloc)
 425             {
 426               clib_warning
 427                 ("No RLOC configured for setting priority/weight!");
 428               goto done;
 429             }
 430           curr_rloc->priority = p;
 431           curr_rloc->weight = w;
 432         }
 433       else if (unformat (line_input, "rloc %U", unformat_ip_address,
 434                          &gid_address_ip (&rloc.address)))
 435         {
 436           /* since rloc is stored in ip prefix we need to set prefix length */
 437           ip_prefix_t *pref = &gid_address_ippref (&rloc.address);
 438
 439           u8 version = gid_address_ip_version (&rloc.address);
 440           ip_prefix_len (pref) = ip_address_max_len (version);
 441
 442           vec_add1 (rlocs, rloc);
 443           curr_rloc = &rlocs[vec_len (rlocs) - 1];
 444         }
 445       else if (unformat (line_input, "action %U",
 446                          unformat_negative_mapping_action, &action))
 447         ;
 448       else
 449         {
 450           clib_warning ("parse error");
 451           goto done;
 452         }
 453     }
 454
 455   if (!del_all && !eid_set)
 456     {
 457       clib_warning ("missing eid!");
 458       goto done;
 459     }
 460
 461   if (!del_all)
 462     {
 463       if (is_add && (~0 == action) && 0 == vec_len (rlocs))
 464         {
 465           clib_warning ("no action set for negative map-reply!");
 466           goto done;
 467         }
 468     }
 469   else
 470     {
 471       vnet_lisp_clear_all_remote_adjacencies ();
 472       goto done;
 473     }
 474
 475   /* if it's a delete, clean forwarding */
 476   if (!is_add)
 477     {
 478       vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
 479       memset (a, 0, sizeof (a[0]));
 480       gid_address_copy (&a->reid, &eid);
 481       if (vnet_lisp_add_del_adjacency (a))
 482         {
 483           clib_warning ("failed to delete adjacency!");
 484           goto done;
 485         }
 486     }
 487
 488   /* add as static remote mapping, i.e., not authoritative and infinite
 489    * ttl */
 490   rv = vnet_lisp_add_del_mapping (&eid, rlocs, action, 0, ~0, is_add,
 491                                   1 /* is_static */ , 0);
 492
 493   if (rv)
 494     clib_warning ("failed to %s remote mapping!", is_add ? "add" : "delete");
 495
 496 done:
 497   vec_free (rlocs);
 498   unformat_free (line_input);
 499   return error;
 500 }
 501
 502 /* *INDENT-OFF* */
 503 VLIB_CLI_COMMAND (one_add_del_remote_mapping_command) = {
 504   .path = "one remote-mapping",
 505   .short_help =
 506     "one remote-mapping add|del [del-all] vni <vni> "
 507     "eid <est-eid> [action <no-action|natively-forward|"
 508     "send-map-request|drop>] rloc <dst-locator> p <prio> w <weight> "
 509     "[rloc <dst-locator> ... ]",
 510   .function = lisp_add_del_remote_mapping_command_fn,
 511 };
 512 /* *INDENT-ON* */
 513
 514 /**
 515  * Handler for add/del adjacency CLI.
 516  */
 517 static clib_error_t *
 518 lisp_add_del_adjacency_command_fn (vlib_main_t * vm, unformat_input_t * input,
 519                                    vlib_cli_command_t * cmd)
 520 {
 521   clib_error_t *error = 0;
 522   unformat_input_t _line_input, *line_input = &_line_input;
 523   vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
 524   u8 is_add = 1;
 525   ip_prefix_t *reid_ippref, *leid_ippref;
 526   gid_address_t leid, reid;
 527   u8 *dmac = gid_address_mac (&reid);
 528   u8 *smac = gid_address_mac (&leid);
 529   u8 reid_set = 0, leid_set = 0;
 530   u32 vni;
 531
 532   /* Get a line of input. */
 533   if (!unformat_user (input, unformat_line_input, line_input))
 534     return 0;
 535
 536   memset (&reid, 0, sizeof (reid));
 537   memset (&leid, 0, sizeof (leid));
 538
 539   leid_ippref = &gid_address_ippref (&leid);
 540   reid_ippref = &gid_address_ippref (&reid);
 541
 542   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 543     {
 544       if (unformat (line_input, "del"))
 545         is_add = 0;
 546       else if (unformat (line_input, "add"))
 547         ;
 548       else if (unformat (line_input, "reid %U",
 549                          unformat_ip_prefix, reid_ippref))
 550         {
 551           gid_address_type (&reid) = GID_ADDR_IP_PREFIX;
 552           reid_set = 1;
 553         }
 554       else if (unformat (line_input, "reid %U", unformat_mac_address, dmac))
 555         {
 556           gid_address_type (&reid) = GID_ADDR_MAC;
 557           reid_set = 1;
 558         }
 559       else if (unformat (line_input, "vni %u", &vni))
 560         {
 561           gid_address_vni (&leid) = vni;
 562           gid_address_vni (&reid) = vni;
 563         }
 564       else if (unformat (line_input, "leid %U",
 565                          unformat_ip_prefix, leid_ippref))
 566         {
 567           gid_address_type (&leid) = GID_ADDR_IP_PREFIX;
 568           leid_set = 1;
 569         }
 570       else if (unformat (line_input, "leid %U", unformat_mac_address, smac))
 571         {
 572           gid_address_type (&leid) = GID_ADDR_MAC;
 573           leid_set = 1;
 574         }
 575       else
 576         {
 577           clib_warning ("parse error");
 578           goto done;
 579         }
 580     }
 581
 582   if (!reid_set || !leid_set)
 583     {
 584       clib_warning ("missing remote or local eid!");
 585       goto done;
 586     }
 587
 588   if ((gid_address_type (&leid) != gid_address_type (&reid))
 589       || (gid_address_type (&reid) == GID_ADDR_IP_PREFIX
 590           && ip_prefix_version (reid_ippref)
 591           != ip_prefix_version (leid_ippref)))
 592     {
 593       clib_warning ("remote and local EIDs are of different types!");
 594       goto done;
 595     }
 596
 597   memset (a, 0, sizeof (a[0]));
 598   gid_address_copy (&a->leid, &leid);
 599   gid_address_copy (&a->reid, &reid);
 600   a->is_add = is_add;
 601
 602   if (vnet_lisp_add_del_adjacency (a))
 603     clib_warning ("failed to %s adjacency!", is_add ? "add" : "delete");
 604
 605 done:
 606   unformat_free (line_input);
 607   return error;
 608 }
 609
 610 /* *INDENT-OFF* */
 611 VLIB_CLI_COMMAND (one_add_del_adjacency_command) = {
 612     .path = "one adjacency",
 613     .short_help = "one adjacency add|del vni <vni> reid <remote-eid> "
 614       "leid <local-eid>",
 615     .function = lisp_add_del_adjacency_command_fn,
 616 };
 617 /* *INDENT-ON* */
 618
 619
 620 static clib_error_t *
 621 lisp_map_request_mode_command_fn (vlib_main_t * vm,
 622                                   unformat_input_t * input,
 623                                   vlib_cli_command_t * cmd)
 624 {
 625   unformat_input_t _i, *i = &_i;
 626   map_request_mode_t mr_mode = _MR_MODE_MAX;
 627
 628   /* Get a line of input. */
 629   if (!unformat_user (input, unformat_line_input, i))
 630     return 0;
 631
 632   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 633     {
 634       if (unformat (i, "dst-only"))
 635         mr_mode = MR_MODE_DST_ONLY;
 636       else if (unformat (i, "src-dst"))
 637         mr_mode = MR_MODE_SRC_DST;
 638       else
 639         {
 640           clib_warning ("parse error '%U'", format_unformat_error, i);
 641           goto done;
 642         }
 643     }
 644
 645   if (_MR_MODE_MAX == mr_mode)
 646     {
 647       clib_warning ("No map request mode entered!");
 648       goto done;
 649     }
 650
 651   vnet_lisp_set_map_request_mode (mr_mode);
 652
 653 done:
 654   unformat_free (i);
 655
 656   return 0;
 657 }
 658
 659 /* *INDENT-OFF* */
 660 VLIB_CLI_COMMAND (one_map_request_mode_command) = {
 661     .path = "one map-request mode",
 662     .short_help = "one map-request mode dst-only|src-dst",
 663     .function = lisp_map_request_mode_command_fn,
 664 };
 665 /* *INDENT-ON* */
 666
 667
 668 static u8 *
 669 format_lisp_map_request_mode (u8 * s, va_list * args)
 670 {
 671   u32 mode = va_arg (*args, u32);
 672
 673   switch (mode)
 674     {
 675     case 0:
 676       return format (0, "dst-only");
 677     case 1:
 678       return format (0, "src-dst");
 679     }
 680   return 0;
 681 }
 682
 683 static clib_error_t *
 684 lisp_show_map_request_mode_command_fn (vlib_main_t * vm,
 685                                        unformat_input_t * input,
 686                                        vlib_cli_command_t * cmd)
 687 {
 688   vlib_cli_output (vm, "map-request mode: %U", format_lisp_map_request_mode,
 689                    vnet_lisp_get_map_request_mode ());
 690   return 0;
 691 }
 692
 693 /* *INDENT-OFF* */
 694 VLIB_CLI_COMMAND (one_show_map_request_mode_command) = {
 695     .path = "show one map-request mode",
 696     .short_help = "show one map-request mode",
 697     .function = lisp_show_map_request_mode_command_fn,
 698 };
 699 /* *INDENT-ON* */
 700
 701 static clib_error_t *
 702 lisp_show_map_resolvers_command_fn (vlib_main_t * vm,
 703                                     unformat_input_t * input,
 704                                     vlib_cli_command_t * cmd)
 705 {
 706   lisp_msmr_t *mr;
 707   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 708
 709   vec_foreach (mr, lcm->map_resolvers)
 710   {
 711     vlib_cli_output (vm, "%U", format_ip_address, &mr->address);
 712   }
 713   return 0;
 714 }
 715
 716 /* *INDENT-OFF* */
 717 VLIB_CLI_COMMAND (one_show_map_resolvers_command) = {
 718     .path = "show one map-resolvers",
 719     .short_help = "show one map-resolvers",
 720     .function = lisp_show_map_resolvers_command_fn,
 721 };
 722 /* *INDENT-ON* */
 723
 724 static clib_error_t *
 725 lisp_nsh_set_locator_set_command_fn (vlib_main_t * vm,
 726                                      unformat_input_t * input,
 727                                      vlib_cli_command_t * cmd)
 728 {
 729   u8 locator_name_set = 0;
 730   u8 *locator_set_name = 0;
 731   u8 is_add = 1;
 732   unformat_input_t _line_input, *line_input = &_line_input;
 733   clib_error_t *error = 0;
 734   int rv = 0;
 735
 736   /* Get a line of input. */
 737   if (!unformat_user (input, unformat_line_input, line_input))
 738     return 0;
 739
 740   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 741     {
 742       if (unformat (line_input, "ls %_%v%_", &locator_set_name))
 743         locator_name_set = 1;
 744       else if (unformat (line_input, "disable"))
 745         is_add = 0;
 746       else
 747         {
 748           error = clib_error_return (0, "parse error");
 749           goto done;
 750         }
 751     }
 752
 753   if (!locator_name_set)
 754     {
 755       clib_warning ("No locator set specified!");
 756       goto done;
 757     }
 758
 759   rv = vnet_lisp_nsh_set_locator_set (locator_set_name, is_add);
 760   if (0 != rv)
 761     {
 762       error = clib_error_return (0, "failed to %s NSH mapping!",
 763                                  is_add ? "add" : "delete");
 764     }
 765
 766 done:
 767   vec_free (locator_set_name);
 768   unformat_free (line_input);
 769   return error;
 770 }
 771
 772 /* *INDENT-OFF* */
 773 VLIB_CLI_COMMAND (one_nsh_set_locator_set_command) = {
 774     .path = "one nsh-mapping",
 775     .short_help = "one nsh-mapping [del] ls <locator-set-name>",
 776     .function = lisp_nsh_set_locator_set_command_fn,
 777 };
 778 /* *INDENT-ON* */
 779
 780
 781 static clib_error_t *
 782 lisp_pitr_set_locator_set_command_fn (vlib_main_t * vm,
 783                                       unformat_input_t * input,
 784                                       vlib_cli_command_t * cmd)
 785 {
 786   u8 locator_name_set = 0;
 787   u8 *locator_set_name = 0;
 788   u8 is_add = 1;
 789   unformat_input_t _line_input, *line_input = &_line_input;
 790   clib_error_t *error = 0;
 791   int rv = 0;
 792
 793   /* Get a line of input. */
 794   if (!unformat_user (input, unformat_line_input, line_input))
 795     return 0;
 796
 797   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 798     {
 799       if (unformat (line_input, "ls %_%v%_", &locator_set_name))
 800         locator_name_set = 1;
 801       else if (unformat (line_input, "disable"))
 802         is_add = 0;
 803       else
 804         {
 805           error = clib_error_return (0, "parse error");
 806           goto done;
 807         }
 808     }
 809
 810   if (!locator_name_set)
 811     {
 812       clib_warning ("No locator set specified!");
 813       goto done;
 814     }
 815   rv = vnet_lisp_pitr_set_locator_set (locator_set_name, is_add);
 816   if (0 != rv)
 817     {
 818       error = clib_error_return (0, "failed to %s pitr!",
 819                                  is_add ? "add" : "delete");
 820     }
 821
 822 done:
 823   if (locator_set_name)
 824     vec_free (locator_set_name);
 825   unformat_free (line_input);
 826   return error;
 827 }
 828
 829 /* *INDENT-OFF* */
 830 VLIB_CLI_COMMAND (one_pitr_set_locator_set_command) = {
 831     .path = "one pitr",
 832     .short_help = "one pitr [disable] ls <locator-set-name>",
 833     .function = lisp_pitr_set_locator_set_command_fn,
 834 };
 835 /* *INDENT-ON* */
 836
 837 static clib_error_t *
 838 lisp_show_pitr_command_fn (vlib_main_t * vm,
 839                            unformat_input_t * input, vlib_cli_command_t * cmd)
 840 {
 841   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 842   mapping_t *m;
 843   locator_set_t *ls;
 844   u8 *tmp_str = 0;
 845
 846   vlib_cli_output (vm, "%=20s%=16s",
 847                    "pitr", lcm->lisp_pitr ? "locator-set" : "");
 848
 849   if (!lcm->lisp_pitr)
 850     {
 851       vlib_cli_output (vm, "%=20s", "disable");
 852       return 0;
 853     }
 854
 855   if (~0 == lcm->pitr_map_index)
 856     {
 857       tmp_str = format (0, "N/A");
 858     }
 859   else
 860     {
 861       m = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
 862       if (~0 != m->locator_set_index)
 863         {
 864           ls =
 865             pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
 866           tmp_str = format (0, "%s", ls->name);
 867         }
 868       else
 869         {
 870           tmp_str = format (0, "N/A");
 871         }
 872     }
 873   vec_add1 (tmp_str, 0);
 874
 875   vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
 876
 877   vec_free (tmp_str);
 878
 879   return 0;
 880 }
 881
 882 /* *INDENT-OFF* */
 883 VLIB_CLI_COMMAND (one_show_pitr_command) = {
 884     .path = "show one pitr",
 885     .short_help = "Show pitr",
 886     .function = lisp_show_pitr_command_fn,
 887 };
 888 /* *INDENT-ON* */
 889
 890 static u8 *
 891 format_eid_entry (u8 * s, va_list * args)
 892 {
 893   vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
 894   lisp_cp_main_t *lcm = va_arg (*args, lisp_cp_main_t *);
 895   mapping_t *mapit = va_arg (*args, mapping_t *);
 896   locator_set_t *ls = va_arg (*args, locator_set_t *);
 897   gid_address_t *gid = &mapit->eid;
 898   u32 ttl = mapit->ttl;
 899   u8 aut = mapit->authoritative;
 900   u32 *loc_index;
 901   u8 first_line = 1;
 902   u8 *loc;
 903
 904   u8 *type = ls->local ? format (0, "local(%s)", ls->name)
 905     : format (0, "remote");
 906
 907   if (vec_len (ls->locator_indices) == 0)
 908     {
 909       s = format (s, "%-35U%-20saction:%-30U%-20u%-u", format_gid_address,
 910                   gid, type, format_negative_mapping_action, mapit->action,
 911                   ttl, aut);
 912     }
 913   else
 914     {
 915       vec_foreach (loc_index, ls->locator_indices)
 916       {
 917         locator_t *l = pool_elt_at_index (lcm->locator_pool, loc_index[0]);
 918         if (l->local)
 919           loc = format (0, "%U", format_vnet_sw_if_index_name, vnm,
 920                         l->sw_if_index);
 921         else
 922           loc = format (0, "%U", format_ip_address,
 923                         &gid_address_ip (&l->address));
 924
 925         if (first_line)
 926           {
 927             s = format (s, "%-35U%-20s%-30v%-20u%-u\n", format_gid_address,
 928                         gid, type, loc, ttl, aut);
 929             first_line = 0;
 930           }
 931         else
 932           s = format (s, "%55s%v\n", "", loc);
 933       }
 934     }
 935   return s;
 936 }
 937
 938 static clib_error_t *
 939 lisp_show_eid_table_command_fn (vlib_main_t * vm,
 940                                 unformat_input_t * input,
 941                                 vlib_cli_command_t * cmd)
 942 {
 943   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 944   mapping_t *mapit;
 945   unformat_input_t _line_input, *line_input = &_line_input;
 946   u32 mi;
 947   gid_address_t eid;
 948   u8 print_all = 1;
 949   u8 filter = 0;
 950   clib_error_t *error = NULL;
 951
 952   memset (&eid, 0, sizeof (eid));
 953
 954   /* Get a line of input. */
 955   if (!unformat_user (input, unformat_line_input, line_input))
 956     return 0;
 957
 958   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 959     {
 960       if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
 961         print_all = 0;
 962       else if (unformat (line_input, "local"))
 963         filter = 1;
 964       else if (unformat (line_input, "remote"))
 965         filter = 2;
 966       else
 967         {
 968           error = clib_error_return (0, "parse error: '%U'",
 969                                      format_unformat_error, line_input);
 970           goto done;
 971         }
 972     }
 973
 974   vlib_cli_output (vm, "%-35s%-20s%-30s%-20s%-s",
 975                    "EID", "type", "locators", "ttl", "autoritative");
 976
 977   if (print_all)
 978     {
 979       /* *INDENT-OFF* */
 980       pool_foreach (mapit, lcm->mapping_pool,
 981       ({
 982         if (mapit->pitr_set || mapit->nsh_set)
 983           continue;
 984
 985         locator_set_t * ls = pool_elt_at_index (lcm->locator_set_pool,
 986                                                 mapit->locator_set_index);
 987         if (filter && !((1 == filter && ls->local) ||
 988           (2 == filter && !ls->local)))
 989           {
 990             continue;
 991           }
 992         vlib_cli_output (vm, "%U", format_eid_entry, lcm->vnet_main,
 993                          lcm, mapit, ls);
 994       }));
 995       /* *INDENT-ON* */
 996     }
 997   else
 998     {
 999       mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &eid);
1000       if ((u32) ~ 0 == mi)
1001         goto done;
1002
1003       mapit = pool_elt_at_index (lcm->mapping_pool, mi);
1004       locator_set_t *ls = pool_elt_at_index (lcm->locator_set_pool,
1005                                              mapit->locator_set_index);
1006
1007       if (filter && !((1 == filter && ls->local) ||
1008                       (2 == filter && !ls->local)))
1009         {
1010           goto done;
1011         }
1012
1013       vlib_cli_output (vm, "%U,", format_eid_entry, lcm->vnet_main,
1014                        lcm, mapit, ls);
1015     }
1016
1017 done:
1018   unformat_free (line_input);
1019
1020   return error;
1021 }
1022
1023 /* *INDENT-OFF* */
1024 VLIB_CLI_COMMAND (one_cp_show_eid_table_command) = {
1025     .path = "show one eid-table",
1026     .short_help = "Shows EID table",
1027     .function = lisp_show_eid_table_command_fn,
1028 };
1029 /* *INDENT-ON* */
1030
1031
1032 static clib_error_t *
1033 lisp_enable_disable_command_fn (vlib_main_t * vm, unformat_input_t * input,
1034                                 vlib_cli_command_t * cmd)
1035 {
1036   unformat_input_t _line_input, *line_input = &_line_input;
1037   u8 is_enabled = 0;
1038   u8 is_set = 0;
1039   clib_error_t *error = NULL;
1040
1041   /* Get a line of input. */
1042   if (!unformat_user (input, unformat_line_input, line_input))
1043     return 0;
1044
1045   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1046     {
1047       if (unformat (line_input, "enable"))
1048         {
1049           is_set = 1;
1050           is_enabled = 1;
1051         }
1052       else if (unformat (line_input, "disable"))
1053         is_set = 1;
1054       else
1055         {
1056           error = clib_error_return (0, "parse error: '%U'",
1057                                      format_unformat_error, line_input);
1058           goto done;
1059         }
1060     }
1061
1062   if (!is_set)
1063     {
1064       error = clib_error_return (0, "state not set");
1065       goto done;
1066     }
1067
1068   vnet_lisp_enable_disable (is_enabled);
1069
1070 done:
1071   unformat_free (line_input);
1072
1073   return error;
1074 }
1075
1076 /* *INDENT-OFF* */
1077 VLIB_CLI_COMMAND (one_cp_enable_disable_command) = {
1078     .path = "one",
1079     .short_help = "one [enable|disable]",
1080     .function = lisp_enable_disable_command_fn,
1081 };
1082 /* *INDENT-ON* */
1083
1084 static clib_error_t *
1085 lisp_map_register_set_ttl_command_fn (vlib_main_t * vm,
1086                                       unformat_input_t * input,
1087                                       vlib_cli_command_t * cmd)
1088 {
1089   unformat_input_t _line_input, *line_input = &_line_input;
1090   u32 ttl = 0;
1091   u8 is_set = 0;
1092   clib_error_t *error = NULL;
1093
1094   /* Get a line of input. */
1095   if (!unformat_user (input, unformat_line_input, line_input))
1096     return 0;
1097
1098   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1099     {
1100       if (unformat (line_input, "%u", &ttl))
1101         is_set = 1;
1102       else
1103         {
1104           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1105                            line_input);
1106           goto done;
1107         }
1108     }
1109
1110   if (!is_set)
1111     {
1112       vlib_cli_output (vm, "expected integer value for TTL!");
1113       goto done;
1114     }
1115
1116   vnet_lisp_map_register_set_ttl (ttl);
1117
1118 done:
1119   unformat_free (line_input);
1120   return error;
1121 }
1122
1123 /* *INDENT-OFF* */
1124 VLIB_CLI_COMMAND (one_map_register_set_ttl_command) = {
1125     .path = "one map-register ttl",
1126     .short_help = "one map-register ttl",
1127     .function = lisp_map_register_set_ttl_command_fn,
1128 };
1129 /* *INDENT-ON* */
1130
1131 static clib_error_t *
1132 lisp_map_register_show_ttl_command_fn (vlib_main_t * vm,
1133                                        unformat_input_t * input,
1134                                        vlib_cli_command_t * cmd)
1135 {
1136   u32 ttl = vnet_lisp_map_register_get_ttl ();
1137
1138   vlib_cli_output (vm, "map-register TTL: %u", ttl);
1139   return 0;
1140 }
1141
1142 /* *INDENT-OFF* */
1143 VLIB_CLI_COMMAND (one_map_register_show_ttl_command) = {
1144     .path = "show one map-register ttl",
1145     .short_help = "show one map-register ttl",
1146     .function = lisp_map_register_show_ttl_command_fn,
1147 };
1148
1149 /* *INDENT-ON* */
1150
1151 static clib_error_t *
1152 lisp_map_register_enable_disable_command_fn (vlib_main_t * vm,
1153                                              unformat_input_t * input,
1154                                              vlib_cli_command_t * cmd)
1155 {
1156   unformat_input_t _line_input, *line_input = &_line_input;
1157   u8 is_enabled = 0;
1158   u8 is_set = 0;
1159   clib_error_t *error = NULL;
1160
1161   /* Get a line of input. */
1162   if (!unformat_user (input, unformat_line_input, line_input))
1163     return 0;
1164
1165   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1166     {
1167       if (unformat (line_input, "enable"))
1168         {
1169           is_set = 1;
1170           is_enabled = 1;
1171         }
1172       else if (unformat (line_input, "disable"))
1173         is_set = 1;
1174       else
1175         {
1176           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1177                            line_input);
1178           goto done;
1179         }
1180     }
1181
1182   if (!is_set)
1183     {
1184       vlib_cli_output (vm, "state not set!");
1185       goto done;
1186     }
1187
1188   vnet_lisp_map_register_enable_disable (is_enabled);
1189
1190 done:
1191   unformat_free (line_input);
1192
1193   return error;
1194 }
1195
1196 /* *INDENT-OFF* */
1197 VLIB_CLI_COMMAND (one_map_register_enable_disable_command) = {
1198     .path = "one map-register",
1199     .short_help = "one map-register [enable|disable]",
1200     .function = lisp_map_register_enable_disable_command_fn,
1201 };
1202 /* *INDENT-ON* */
1203
1204 static clib_error_t *
1205 lisp_rloc_probe_enable_disable_command_fn (vlib_main_t * vm,
1206                                            unformat_input_t * input,
1207                                            vlib_cli_command_t * cmd)
1208 {
1209   unformat_input_t _line_input, *line_input = &_line_input;
1210   u8 is_enabled = 0;
1211   u8 is_set = 0;
1212   clib_error_t *error = NULL;
1213
1214   /* Get a line of input. */
1215   if (!unformat_user (input, unformat_line_input, line_input))
1216     return 0;
1217
1218   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1219     {
1220       if (unformat (line_input, "enable"))
1221         {
1222           is_set = 1;
1223           is_enabled = 1;
1224         }
1225       else if (unformat (line_input, "disable"))
1226         is_set = 1;
1227       else
1228         {
1229           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1230                            line_input);
1231           goto done;
1232         }
1233     }
1234
1235   if (!is_set)
1236     {
1237       vlib_cli_output (vm, "state not set!");
1238       goto done;
1239     }
1240
1241   vnet_lisp_rloc_probe_enable_disable (is_enabled);
1242
1243 done:
1244   unformat_free (line_input);
1245
1246   return error;
1247 }
1248
1249 /* *INDENT-OFF* */
1250 VLIB_CLI_COMMAND (one_rloc_probe_enable_disable_command) = {
1251     .path = "one rloc-probe",
1252     .short_help = "one rloc-probe [enable|disable]",
1253     .function = lisp_rloc_probe_enable_disable_command_fn,
1254 };
1255 /* *INDENT-ON* */
1256
1257 static u8 *
1258 format_lisp_status (u8 * s, va_list * args)
1259 {
1260   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1261   return format (s, "%s", lcm->is_enabled ? "enabled" : "disabled");
1262 }
1263
1264 static clib_error_t *
1265 lisp_show_status_command_fn (vlib_main_t * vm, unformat_input_t * input,
1266                              vlib_cli_command_t * cmd)
1267 {
1268   u8 *msg = 0;
1269   msg = format (msg, "feature: %U\ngpe: %U\n",
1270                 format_lisp_status, format_vnet_lisp_gpe_status);
1271   vlib_cli_output (vm, "%v", msg);
1272   vec_free (msg);
1273   return 0;
1274 }
1275
1276 /* *INDENT-OFF* */
1277 VLIB_CLI_COMMAND (one_show_status_command) = {
1278     .path = "show one status",
1279     .short_help = "show one status",
1280     .function = lisp_show_status_command_fn,
1281 };
1282 /* *INDENT-ON* */
1283
1284 static clib_error_t *
1285 lisp_show_eid_table_map_command_fn (vlib_main_t * vm,
1286                                     unformat_input_t * input,
1287                                     vlib_cli_command_t * cmd)
1288 {
1289   hash_pair_t *p;
1290   unformat_input_t _line_input, *line_input = &_line_input;
1291   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1292   uword *vni_table = 0;
1293   u8 is_l2 = 0;
1294   clib_error_t *error = NULL;
1295
1296   /* Get a line of input. */
1297   if (!unformat_user (input, unformat_line_input, line_input))
1298     return 0;
1299
1300   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1301     {
1302       if (unformat (line_input, "l2"))
1303         {
1304           vni_table = lcm->bd_id_by_vni;
1305           is_l2 = 1;
1306         }
1307       else if (unformat (line_input, "l3"))
1308         {
1309           vni_table = lcm->table_id_by_vni;
1310           is_l2 = 0;
1311         }
1312       else
1313         {
1314           error = clib_error_return (0, "parse error: '%U'",
1315                                      format_unformat_error, line_input);
1316           goto done;
1317         }
1318     }
1319
1320   if (!vni_table)
1321     {
1322       vlib_cli_output (vm, "Error: expected l2|l3 param!\n");
1323       goto done;
1324     }
1325
1326   vlib_cli_output (vm, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
1327
1328   /* *INDENT-OFF* */
1329   hash_foreach_pair (p, vni_table,
1330   ({
1331     vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]);
1332   }));
1333   /* *INDENT-ON* */
1334
1335 done:
1336   unformat_free (line_input);
1337
1338   return error;
1339 }
1340
1341 /* *INDENT-OFF* */
1342 VLIB_CLI_COMMAND (one_show_eid_table_map_command) = {
1343     .path = "show one eid-table map",
1344     .short_help = "show one eid-table l2|l3",
1345     .function = lisp_show_eid_table_map_command_fn,
1346 };
1347 /* *INDENT-ON* */
1348
1349
1350 static clib_error_t *
1351 lisp_add_del_locator_set_command_fn (vlib_main_t * vm,
1352                                      unformat_input_t * input,
1353                                      vlib_cli_command_t * cmd)
1354 {
1355   lisp_gpe_main_t *lgm = &lisp_gpe_main;
1356   vnet_main_t *vnm = lgm->vnet_main;
1357   unformat_input_t _line_input, *line_input = &_line_input;
1358   u8 is_add = 1;
1359   clib_error_t *error = 0;
1360   u8 *locator_set_name = 0;
1361   locator_t locator, *locators = 0;
1362   vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
1363   u32 ls_index = 0;
1364   int rv = 0;
1365
1366   memset (&locator, 0, sizeof (locator));
1367   memset (a, 0, sizeof (a[0]));
1368
1369   /* Get a line of input. */
1370   if (!unformat_user (input, unformat_line_input, line_input))
1371     return 0;
1372
1373   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1374     {
1375       if (unformat (line_input, "add %_%v%_", &locator_set_name))
1376         is_add = 1;
1377       else if (unformat (line_input, "del %_%v%_", &locator_set_name))
1378         is_add = 0;
1379       else if (unformat (line_input, "iface %U p %d w %d",
1380                          unformat_vnet_sw_interface, vnm,
1381                          &locator.sw_if_index, &locator.priority,
1382                          &locator.weight))
1383         {
1384           locator.local = 1;
1385           vec_add1 (locators, locator);
1386         }
1387       else
1388         {
1389           error = unformat_parse_error (line_input);
1390           goto done;
1391         }
1392     }
1393
1394   a->name = locator_set_name;
1395   a->locators = locators;
1396   a->is_add = is_add;
1397   a->local = 1;
1398
1399   rv = vnet_lisp_add_del_locator_set (a, &ls_index);
1400   if (0 != rv)
1401     {
1402       error = clib_error_return (0, "failed to %s locator-set!",
1403                                  is_add ? "add" : "delete");
1404     }
1405
1406 done:
1407   vec_free (locators);
1408   if (locator_set_name)
1409     vec_free (locator_set_name);
1410   unformat_free (line_input);
1411   return error;
1412 }
1413
1414 /* *INDENT-OFF* */
1415 VLIB_CLI_COMMAND (one_cp_add_del_locator_set_command) = {
1416     .path = "one locator-set",
1417     .short_help = "one locator-set add/del <name> [iface <iface-name> "
1418         "p <priority> w <weight>]",
1419     .function = lisp_add_del_locator_set_command_fn,
1420 };
1421 /* *INDENT-ON* */
1422
1423 static clib_error_t *
1424 lisp_add_del_locator_in_set_command_fn (vlib_main_t * vm,
1425                                         unformat_input_t * input,
1426                                         vlib_cli_command_t * cmd)
1427 {
1428   lisp_gpe_main_t *lgm = &lisp_gpe_main;
1429   vnet_main_t *vnm = lgm->vnet_main;
1430   unformat_input_t _line_input, *line_input = &_line_input;
1431   u8 is_add = 1;
1432   clib_error_t *error = 0;
1433   u8 *locator_set_name = 0;
1434   u8 locator_set_name_set = 0;
1435   locator_t locator, *locators = 0;
1436   vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
1437   u32 ls_index = 0;
1438
1439   memset (&locator, 0, sizeof (locator));
1440   memset (a, 0, sizeof (a[0]));
1441
1442   /* Get a line of input. */
1443   if (!unformat_user (input, unformat_line_input, line_input))
1444     return 0;
1445
1446   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1447     {
1448       if (unformat (line_input, "add"))
1449         is_add = 1;
1450       else if (unformat (line_input, "del"))
1451         is_add = 0;
1452       else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name))
1453         locator_set_name_set = 1;
1454       else if (unformat (line_input, "iface %U p %d w %d",
1455                          unformat_vnet_sw_interface, vnm,
1456                          &locator.sw_if_index, &locator.priority,
1457                          &locator.weight))
1458         {
1459           locator.local = 1;
1460           vec_add1 (locators, locator);
1461         }
1462       else
1463         {
1464           error = unformat_parse_error (line_input);
1465           goto done;
1466         }
1467     }
1468
1469   if (!locator_set_name_set)
1470     {
1471       error = clib_error_return (0, "locator_set name not set!");
1472       goto done;
1473     }
1474
1475   a->name = locator_set_name;
1476   a->locators = locators;
1477   a->is_add = is_add;
1478   a->local = 1;
1479
1480   vnet_lisp_add_del_locator (a, 0, &ls_index);
1481
1482 done:
1483   vec_free (locators);
1484   vec_free (locator_set_name);
1485   unformat_free (line_input);
1486   return error;
1487 }
1488
1489 /* *INDENT-OFF* */
1490 VLIB_CLI_COMMAND (one_cp_add_del_locator_in_set_command) = {
1491     .path = "one locator",
1492     .short_help = "one locator add/del locator-set <name> iface <iface-name> "
1493                   "p <priority> w <weight>",
1494     .function = lisp_add_del_locator_in_set_command_fn,
1495 };
1496 /* *INDENT-ON* */
1497
1498 static clib_error_t *
1499 lisp_cp_show_locator_sets_command_fn (vlib_main_t * vm,
1500                                       unformat_input_t * input,
1501                                       vlib_cli_command_t * cmd)
1502 {
1503   locator_set_t *lsit;
1504   locator_t *loc;
1505   u32 *locit;
1506   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1507
1508   vlib_cli_output (vm, "%s%=16s%=16s%=16s", "Locator-set", "Locator",
1509                    "Priority", "Weight");
1510
1511   /* *INDENT-OFF* */
1512   pool_foreach (lsit, lcm->locator_set_pool,
1513   ({
1514     u8 * msg = 0;
1515     int next_line = 0;
1516     if (lsit->local)
1517       {
1518         msg = format (msg, "%v", lsit->name);
1519       }
1520     else
1521       {
1522         msg = format (msg, "<%s-%d>", "remote", lsit - lcm->locator_set_pool);
1523       }
1524     vec_foreach (locit, lsit->locator_indices)
1525       {
1526         if (next_line)
1527           {
1528             msg = format (msg, "%16s", " ");
1529           }
1530         loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
1531         if (loc->local)
1532           msg = format (msg, "%16d%16d%16d\n", loc->sw_if_index, loc->priority,
1533                         loc->weight);
1534         else
1535           msg = format (msg, "%16U%16d%16d\n", format_ip_address,
1536                         &gid_address_ip(&loc->address), loc->priority,
1537                         loc->weight);
1538         next_line = 1;
1539       }
1540     vlib_cli_output (vm, "%v", msg);
1541     vec_free (msg);
1542   }));
1543   /* *INDENT-ON* */
1544   return 0;
1545 }
1546
1547 /* *INDENT-OFF* */
1548 VLIB_CLI_COMMAND (one_cp_show_locator_sets_command) = {
1549     .path = "show one locator-set",
1550     .short_help = "Shows locator-sets",
1551     .function = lisp_cp_show_locator_sets_command_fn,
1552 };
1553 /* *INDENT-ON* */
1554
1555
1556 static clib_error_t *
1557 lisp_add_del_map_resolver_command_fn (vlib_main_t * vm,
1558                                       unformat_input_t * input,
1559                                       vlib_cli_command_t * cmd)
1560 {
1561   unformat_input_t _line_input, *line_input = &_line_input;
1562   u8 is_add = 1, addr_set = 0;
1563   ip_address_t ip_addr;
1564   clib_error_t *error = 0;
1565   int rv = 0;
1566   vnet_lisp_add_del_map_resolver_args_t _a, *a = &_a;
1567
1568   /* Get a line of input. */
1569   if (!unformat_user (input, unformat_line_input, line_input))
1570     return 0;
1571
1572   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1573     {
1574       if (unformat (line_input, "add"))
1575         is_add = 1;
1576       else if (unformat (line_input, "del"))
1577         is_add = 0;
1578       else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr))
1579         addr_set = 1;
1580       else
1581         {
1582           error = unformat_parse_error (line_input);
1583           goto done;
1584         }
1585     }
1586
1587   if (!addr_set)
1588     {
1589       error = clib_error_return (0, "Map-resolver address must be set!");
1590       goto done;
1591     }
1592
1593   a->is_add = is_add;
1594   a->address = ip_addr;
1595   rv = vnet_lisp_add_del_map_resolver (a);
1596   if (0 != rv)
1597     {
1598       error = clib_error_return (0, "failed to %s map-resolver!",
1599                                  is_add ? "add" : "delete");
1600     }
1601
1602 done:
1603   unformat_free (line_input);
1604   return error;
1605 }
1606
1607 /* *INDENT-OFF* */
1608 VLIB_CLI_COMMAND (one_add_del_map_resolver_command) = {
1609     .path = "one map-resolver",
1610     .short_help = "one map-resolver add/del <ip_address>",
1611     .function = lisp_add_del_map_resolver_command_fn,
1612 };
1613 /* *INDENT-ON* */
1614
1615
1616 static clib_error_t *
1617 lisp_add_del_mreq_itr_rlocs_command_fn (vlib_main_t * vm,
1618                                         unformat_input_t * input,
1619                                         vlib_cli_command_t * cmd)
1620 {
1621   unformat_input_t _line_input, *line_input = &_line_input;
1622   u8 is_add = 1;
1623   u8 *locator_set_name = 0;
1624   clib_error_t *error = 0;
1625   int rv = 0;
1626   vnet_lisp_add_del_mreq_itr_rloc_args_t _a, *a = &_a;
1627
1628   /* Get a line of input. */
1629   if (!unformat_user (input, unformat_line_input, line_input))
1630     return 0;
1631
1632   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1633     {
1634       if (unformat (line_input, "del"))
1635         is_add = 0;
1636       else if (unformat (line_input, "add %_%v%_", &locator_set_name))
1637         is_add = 1;
1638       else
1639         {
1640           error = unformat_parse_error (line_input);
1641           goto done;
1642         }
1643     }
1644
1645   a->is_add = is_add;
1646   a->locator_set_name = locator_set_name;
1647   rv = vnet_lisp_add_del_mreq_itr_rlocs (a);
1648   if (0 != rv)
1649     {
1650       error = clib_error_return (0, "failed to %s map-request itr-rlocs!",
1651                                  is_add ? "add" : "delete");
1652     }
1653
1654 done:
1655   vec_free (locator_set_name);
1656   unformat_free (line_input);
1657   return error;
1658
1659 }
1660
1661 /* *INDENT-OFF* */
1662 VLIB_CLI_COMMAND (one_add_del_map_request_command) = {
1663     .path = "one map-request itr-rlocs",
1664     .short_help = "one map-request itr-rlocs add/del <locator_set_name>",
1665     .function = lisp_add_del_mreq_itr_rlocs_command_fn,
1666 };
1667 /* *INDENT-ON* */
1668
1669 static clib_error_t *
1670 lisp_show_mreq_itr_rlocs_command_fn (vlib_main_t * vm,
1671                                      unformat_input_t * input,
1672                                      vlib_cli_command_t * cmd)
1673 {
1674   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1675   locator_set_t *loc_set;
1676
1677   vlib_cli_output (vm, "%=20s", "itr-rlocs");
1678
1679   if (~0 == lcm->mreq_itr_rlocs)
1680     {
1681       return 0;
1682     }
1683
1684   loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1685
1686   vlib_cli_output (vm, "%=20s", loc_set->name);
1687
1688   return 0;
1689 }
1690
1691 /* *INDENT-OFF* */
1692 VLIB_CLI_COMMAND (one_show_map_request_command) = {
1693     .path = "show one map-request itr-rlocs",
1694     .short_help = "Shows map-request itr-rlocs",
1695     .function = lisp_show_mreq_itr_rlocs_command_fn,
1696 };
1697 /* *INDENT-ON* */
1698
1699 static clib_error_t *
1700 lisp_use_petr_set_locator_set_command_fn (vlib_main_t * vm,
1701                                           unformat_input_t * input,
1702                                           vlib_cli_command_t * cmd)
1703 {
1704   u8 is_add = 1, ip_set = 0;
1705   unformat_input_t _line_input, *line_input = &_line_input;
1706   clib_error_t *error = 0;
1707   ip_address_t ip;
1708
1709   /* Get a line of input. */
1710   if (!unformat_user (input, unformat_line_input, line_input))
1711     return 0;
1712
1713   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1714     {
1715       if (unformat (line_input, "%U", unformat_ip_address, &ip))
1716         ip_set = 1;
1717       else if (unformat (line_input, "disable"))
1718         is_add = 0;
1719       else
1720         {
1721           error = clib_error_return (0, "parse error");
1722           goto done;
1723         }
1724     }
1725
1726   if (!ip_set)
1727     {
1728       clib_warning ("No petr IP specified!");
1729       goto done;
1730     }
1731
1732   if (vnet_lisp_use_petr (&ip, is_add))
1733     {
1734       error = clib_error_return (0, "failed to %s petr!",
1735                                  is_add ? "add" : "delete");
1736     }
1737
1738 done:
1739   unformat_free (line_input);
1740   return error;
1741 }
1742
1743 /* *INDENT-OFF* */
1744 VLIB_CLI_COMMAND (one_use_petr_set_locator_set_command) = {
1745     .path = "one use-petr",
1746     .short_help = "one use-petr [disable] <petr-ip>",
1747     .function = lisp_use_petr_set_locator_set_command_fn,
1748 };
1749
1750 static clib_error_t *
1751 lisp_show_petr_command_fn (vlib_main_t * vm,
1752                            unformat_input_t * input, vlib_cli_command_t * cmd)
1753 {
1754   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1755   mapping_t *m;
1756   locator_set_t *ls;
1757   locator_t *loc;
1758   u8 *tmp_str = 0;
1759   u8 use_petr = lcm->flags & LISP_FLAG_USE_PETR;
1760   vlib_cli_output (vm, "%=20s%=16s", "petr", use_petr ? "ip" : "");
1761
1762   if (!use_petr)
1763     {
1764       vlib_cli_output (vm, "%=20s", "disable");
1765       return 0;
1766     }
1767
1768   if (~0 == lcm->petr_map_index)
1769     {
1770       tmp_str = format (0, "N/A");
1771     }
1772   else
1773     {
1774       m = pool_elt_at_index (lcm->mapping_pool, lcm->petr_map_index);
1775       if (~0 != m->locator_set_index)
1776         {
1777           ls = pool_elt_at_index(lcm->locator_set_pool, m->locator_set_index);
1778           loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
1779           tmp_str = format (0, "%U", format_ip_address, &loc->address);
1780         }
1781       else
1782         {
1783           tmp_str = format (0, "N/A");
1784         }
1785     }
1786   vec_add1 (tmp_str, 0);
1787
1788   vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str);
1789
1790   vec_free (tmp_str);
1791
1792   return 0;
1793 }
1794
1795 /* *INDENT-OFF* */
1796 VLIB_CLI_COMMAND (one_show_petr_command) = {
1797     .path = "show one petr",
1798     .short_help = "Show petr",
1799     .function = lisp_show_petr_command_fn,
1800 };
1801 /* *INDENT-ON* */
1802
1803 static clib_error_t *
1804 lisp_show_map_servers_command_fn (vlib_main_t * vm,
1805                                   unformat_input_t * input,
1806                                   vlib_cli_command_t * cmd)
1807 {
1808   lisp_msmr_t *ms;
1809   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1810
1811   vec_foreach (ms, lcm->map_servers)
1812   {
1813     vlib_cli_output (vm, "%U", format_ip_address, &ms->address);
1814   }
1815   return 0;
1816 }
1817
1818 /* *INDENT-OFF* */
1819 VLIB_CLI_COMMAND (one_show_map_servers_command) = {
1820     .path = "show one map-servers",
1821     .short_help = "show one map servers",
1822     .function = lisp_show_map_servers_command_fn,
1823 };
1824 /* *INDENT-ON* */
1825
1826 static clib_error_t *
1827 lisp_show_map_register_state_command_fn (vlib_main_t * vm,
1828                                          unformat_input_t * input,
1829                                          vlib_cli_command_t * cmd)
1830 {
1831   u8 *msg = 0;
1832   u8 is_enabled = vnet_lisp_map_register_state_get ();
1833
1834   msg = format (msg, "%s\n", is_enabled ? "enabled" : "disabled");
1835   vlib_cli_output (vm, "%v", msg);
1836   vec_free (msg);
1837   return 0;
1838 }
1839
1840 /* *INDENT-OFF* */
1841 VLIB_CLI_COMMAND (one_show_map_register_state_command) = {
1842     .path = "show one map-register state",
1843     .short_help = "show one map-register state",
1844     .function = lisp_show_map_register_state_command_fn,
1845 };
1846 /* *INDENT-ON* */
1847
1848 static clib_error_t *
1849 lisp_show_rloc_probe_state_command_fn (vlib_main_t * vm,
1850                                        unformat_input_t * input,
1851                                        vlib_cli_command_t * cmd)
1852 {
1853   u8 *msg = 0;
1854   u8 is_enabled = vnet_lisp_rloc_probe_state_get ();
1855
1856   msg = format (msg, "%s\n", is_enabled ? "enabled" : "disabled");
1857   vlib_cli_output (vm, "%v", msg);
1858   vec_free (msg);
1859   return 0;
1860 }
1861
1862 /* *INDENT-OFF* */
1863 VLIB_CLI_COMMAND (one_show_rloc_probe_state_command) = {
1864     .path = "show one rloc state",
1865     .short_help = "show one RLOC state",
1866     .function = lisp_show_rloc_probe_state_command_fn,
1867 };
1868 /* *INDENT-ON* */
1869
1870 static clib_error_t *
1871 lisp_show_stats_command_fn (vlib_main_t * vm,
1872                             unformat_input_t * input,
1873                             vlib_cli_command_t * cmd)
1874 {
1875   u8 is_enabled = vnet_lisp_stats_enable_disable_state ();
1876   vlib_cli_output (vm, "%s\n", is_enabled ? "enabled" : "disabled");
1877   return 0;
1878 }
1879
1880 /* *INDENT-OFF* */
1881 VLIB_CLI_COMMAND (one_show_stats_command) = {
1882     .path = "show one statistics status",
1883     .short_help = "show ONE statistics enable/disable status",
1884     .function = lisp_show_stats_command_fn,
1885 };
1886 /* *INDENT-ON* */
1887
1888 static clib_error_t *
1889 lisp_show_stats_details_command_fn (vlib_main_t * vm,
1890                                     unformat_input_t * input,
1891                                     vlib_cli_command_t * cmd)
1892 {
1893   lisp_api_stats_t *stat, *stats = vnet_lisp_get_stats ();
1894
1895   if (vec_len (stats) > 0)
1896     vlib_cli_output (vm,
1897                      "[src-EID, dst-EID] [loc-rloc, rmt-rloc] count bytes\n");
1898   else
1899     vlib_cli_output (vm, "No statistics found.\n");
1900
1901   vec_foreach (stat, stats)
1902   {
1903     vlib_cli_output (vm, "[%U, %U] [%U, %U] %7u %7u\n",
1904                      format_fid_address, &stat->seid,
1905                      format_fid_address, &stat->deid,
1906                      format_ip_address, &stat->loc_rloc,
1907                      format_ip_address, &stat->rmt_rloc,
1908                      stat->counters.packets, stat->counters.bytes);
1909   }
1910   vec_free (stats);
1911   return 0;
1912 }
1913
1914 /* *INDENT-OFF* */
1915 VLIB_CLI_COMMAND (one_show_stats_details_command) = {
1916     .path = "show one statistics details",
1917     .short_help = "show ONE statistics",
1918     .function = lisp_show_stats_details_command_fn,
1919 };
1920 /* *INDENT-ON* */
1921
1922 static clib_error_t *
1923 lisp_stats_enable_disable_command_fn (vlib_main_t * vm,
1924                                       unformat_input_t * input,
1925                                       vlib_cli_command_t * cmd)
1926 {
1927   unformat_input_t _line_input, *line_input = &_line_input;
1928   u8 enable = 0;
1929
1930   /* Get a line of input. */
1931   if (!unformat_user (input, unformat_line_input, line_input))
1932     return 0;
1933
1934   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1935     {
1936       if (unformat (line_input, "enable"))
1937         enable = 1;
1938       else if (unformat (line_input, "disable"))
1939         enable = 0;
1940       else
1941         {
1942           clib_warning ("Error: expected enable/disable!");
1943           goto done;
1944         }
1945     }
1946   vnet_lisp_stats_enable_disable (enable);
1947 done:
1948   unformat_free (line_input);
1949   return 0;
1950 }
1951
1952 /* *INDENT-OFF* */
1953 VLIB_CLI_COMMAND (one_stats_enable_disable_command) = {
1954     .path = "one statistics",
1955     .short_help = "enable/disable ONE statistics collecting",
1956     .function = lisp_stats_enable_disable_command_fn,
1957 };
1958 /* *INDENT-ON* */
1959
1960 static clib_error_t *
1961 lisp_stats_flush_command_fn (vlib_main_t * vm,
1962                              unformat_input_t * input,
1963                              vlib_cli_command_t * cmd)
1964 {
1965   vnet_lisp_flush_stats ();
1966   return 0;
1967 }
1968
1969 /* *INDENT-OFF* */
1970 VLIB_CLI_COMMAND (one_stats_flush_command) = {
1971     .path = "one statistics flush",
1972     .short_help = "Flush ONE statistics",
1973     .function = lisp_stats_flush_command_fn,
1974 };
1975 /* *INDENT-ON* */
1976
1977 /*
1978  * fd.io coding-style-patch-verification: ON
1979  *
1980  * Local Variables:
1981  * eval: (c-set-style "gnu")
1982  * End:
1983  */