src/vnet/ipsec/ipsec_cli.c

   1 /*
   2  * decap.c : IPSec tunnel support
   3  *
   4  * Copyright (c) 2015 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <vnet/vnet.h>
  19 #include <vnet/api_errno.h>
  20 #include <vnet/ip/ip.h>
  21 #include <vnet/interface.h>
  22 #include <vnet/fib/fib.h>
  23 #include <vnet/ipip/ipip.h>
  24
  25 #include <vnet/ipsec/ipsec.h>
  26 #include <vnet/ipsec/ipsec_tun.h>
  27
  28 static clib_error_t *
  29 set_interface_spd_command_fn (vlib_main_t * vm,
  30                               unformat_input_t * input,
  31                               vlib_cli_command_t * cmd)
  32 {
  33   unformat_input_t _line_input, *line_input = &_line_input;
  34   ipsec_main_t *im = &ipsec_main;
  35   u32 sw_if_index = (u32) ~ 0;
  36   u32 spd_id;
  37   int is_add = 1;
  38   clib_error_t *error = NULL;
  39   int err;
  40
  41   if (!unformat_user (input, unformat_line_input, line_input))
  42     return 0;
  43
  44   if (unformat
  45       (line_input, "%U %u", unformat_vnet_sw_interface, im->vnet_main,
  46        &sw_if_index, &spd_id))
  47     ;
  48   else if (unformat (line_input, "del"))
  49     is_add = 0;
  50   else
  51     {
  52       error = clib_error_return (0, "parse error: '%U'",
  53                                  format_unformat_error, line_input);
  54       goto done;
  55     }
  56
  57   err = ipsec_set_interface_spd (vm, sw_if_index, spd_id, is_add);
  58   switch (err)
  59     {
  60     case VNET_API_ERROR_SYSCALL_ERROR_1:
  61       error = clib_error_return (0, "no such spd-id");
  62       break;
  63     case VNET_API_ERROR_SYSCALL_ERROR_2:
  64       error = clib_error_return (0, "spd already assigned");
  65       break;
  66     }
  67
  68 done:
  69   unformat_free (line_input);
  70
  71   return error;
  72 }
  73
  74 /* *INDENT-OFF* */
  75 VLIB_CLI_COMMAND (set_interface_spd_command, static) = {
  76     .path = "set interface ipsec spd",
  77     .short_help =
  78     "set interface ipsec spd <int> <id>",
  79     .function = set_interface_spd_command_fn,
  80 };
  81 /* *INDENT-ON* */
  82
  83 static clib_error_t *
  84 ipsec_sa_add_del_command_fn (vlib_main_t * vm,
  85                              unformat_input_t * input,
  86                              vlib_cli_command_t * cmd)
  87 {
  88   unformat_input_t _line_input, *line_input = &_line_input;
  89   ipsec_crypto_alg_t crypto_alg;
  90   ipsec_integ_alg_t integ_alg;
  91   ipsec_protocol_t proto;
  92   ipsec_sa_flags_t flags;
  93   clib_error_t *error;
  94   ipsec_key_t ck = { 0 };
  95   ipsec_key_t ik = { 0 };
  96   u32 id, spi, salt, sai;
  97   int i = 0;
  98   u16 udp_src, udp_dst;
  99   int is_add, rv;
 100   u32 m_args = 0;
 101   tunnel_t tun = {};
 102
 103   salt = 0;
 104   error = NULL;
 105   is_add = 0;
 106   flags = IPSEC_SA_FLAG_NONE;
 107   proto = IPSEC_PROTOCOL_ESP;
 108   integ_alg = IPSEC_INTEG_ALG_NONE;
 109   crypto_alg = IPSEC_CRYPTO_ALG_NONE;
 110   udp_src = udp_dst = IPSEC_UDP_PORT_NONE;
 111
 112   if (!unformat_user (input, unformat_line_input, line_input))
 113     return 0;
 114
 115   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 116     {
 117       if (unformat (line_input, "add %u", &id))
 118         {
 119           is_add = 1;
 120           m_args |= 1 << 0;
 121         }
 122       else if (unformat (line_input, "del %u", &id))
 123         {
 124           is_add = 0;
 125           m_args |= 1 << 0;
 126         }
 127       else if (unformat (line_input, "spi %u", &spi))
 128         m_args |= 1 << 1;
 129       else if (unformat (line_input, "salt 0x%x", &salt))
 130         ;
 131       else if (unformat (line_input, "esp"))
 132         proto = IPSEC_PROTOCOL_ESP;
 133       else if (unformat (line_input, "ah"))
 134         proto = IPSEC_PROTOCOL_AH;
 135       else if (unformat (line_input, "crypto-key %U",
 136                          unformat_ipsec_key, &ck))
 137         ;
 138       else if (unformat (line_input, "crypto-alg %U",
 139                          unformat_ipsec_crypto_alg, &crypto_alg))
 140         ;
 141       else if (unformat (line_input, "integ-key %U", unformat_ipsec_key, &ik))
 142         ;
 143       else if (unformat (line_input, "integ-alg %U",
 144                          unformat_ipsec_integ_alg, &integ_alg))
 145         ;
 146       else if (unformat (line_input, "%U", unformat_tunnel, &tun))
 147         {
 148           flags |= IPSEC_SA_FLAG_IS_TUNNEL;
 149           if (AF_IP6 == tunnel_get_af (&tun))
 150             flags |= IPSEC_SA_FLAG_IS_TUNNEL_V6;
 151         }
 152       else if (unformat (line_input, "udp-src-port %d", &i))
 153         udp_src = i;
 154       else if (unformat (line_input, "udp-dst-port %d", &i))
 155         udp_dst = i;
 156       else if (unformat (line_input, "inbound"))
 157         flags |= IPSEC_SA_FLAG_IS_INBOUND;
 158       else if (unformat (line_input, "use-anti-replay"))
 159         flags |= IPSEC_SA_FLAG_USE_ANTI_REPLAY;
 160       else if (unformat (line_input, "use-esn"))
 161         flags |= IPSEC_SA_FLAG_USE_ESN;
 162       else if (unformat (line_input, "udp-encap"))
 163         flags |= IPSEC_SA_FLAG_UDP_ENCAP;
 164       else if (unformat (line_input, "async"))
 165         flags |= IPSEC_SA_FLAG_IS_ASYNC;
 166       else
 167         {
 168           error = clib_error_return (0, "parse error: '%U'",
 169                                      format_unformat_error, line_input);
 170           goto done;
 171         }
 172     }
 173
 174   if (!(m_args & 1))
 175     {
 176       error = clib_error_return (0, "missing id");
 177       goto done;
 178     }
 179
 180   if (is_add)
 181     {
 182       if (!(m_args & 2))
 183         {
 184           error = clib_error_return (0, "missing spi");
 185           goto done;
 186         }
 187       rv = ipsec_sa_add_and_lock (id, spi, proto, crypto_alg, &ck, integ_alg,
 188                                   &ik, flags, clib_host_to_net_u32 (salt),
 189                                   udp_src, udp_dst, &tun, &sai);
 190     }
 191   else
 192     {
 193       rv = ipsec_sa_unlock_id (id);
 194     }
 195
 196   if (rv)
 197     error = clib_error_return (0, "failed: %d", rv);
 198
 199 done:
 200   unformat_free (line_input);
 201
 202   return error;
 203 }
 204
 205 /* *INDENT-OFF* */
 206 VLIB_CLI_COMMAND (ipsec_sa_add_del_command, static) = {
 207     .path = "ipsec sa",
 208     .short_help =
 209     "ipsec sa [add|del]",
 210     .function = ipsec_sa_add_del_command_fn,
 211 };
 212 /* *INDENT-ON* */
 213
 214 static clib_error_t *
 215 ipsec_sa_bind_cli (vlib_main_t *vm, unformat_input_t *input,
 216                    vlib_cli_command_t *cmd)
 217 {
 218   unformat_input_t _line_input, *line_input = &_line_input;
 219   u32 id = ~0;
 220   u32 worker = ~0;
 221   bool bind = 1;
 222   int rv;
 223   clib_error_t *error = NULL;
 224
 225   if (!unformat_user (input, unformat_line_input, line_input))
 226     return 0;
 227
 228   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 229     {
 230       if (unformat (line_input, "unbind"))
 231         bind = 0;
 232       else if (id != ~0 && unformat (line_input, "%u", &id))
 233         ;
 234       else if (unformat (line_input, "%u", &worker))
 235         ;
 236       else
 237         {
 238           error = clib_error_return (0, "parse error: '%U'",
 239                                      format_unformat_error, line_input);
 240           goto done;
 241         }
 242     }
 243
 244   if (id == ~0)
 245     {
 246       error = clib_error_return (0, "please specify SA ID");
 247       goto done;
 248     }
 249
 250   if (bind && ~0 == worker)
 251     {
 252       error = clib_error_return (0, "please specify worker to bind to");
 253       goto done;
 254     }
 255
 256   rv = ipsec_sa_bind (id, worker, bind);
 257   switch (rv)
 258     {
 259     case VNET_API_ERROR_INVALID_VALUE:
 260       error = clib_error_return (0, "please specify a valid SA ID");
 261       break;
 262     case VNET_API_ERROR_INVALID_WORKER:
 263       error = clib_error_return (0, "please specify a valid worker index");
 264       break;
 265     }
 266
 267 done:
 268   unformat_free (line_input);
 269
 270   return error;
 271 }
 272
 273 VLIB_CLI_COMMAND (ipsec_sa_bind_cmd, static) = {
 274   .path = "ipsec sa bind",
 275   .short_help = "ipsec sa [unbind] <sa-id> <worker>",
 276   .function = ipsec_sa_bind_cli,
 277 };
 278
 279 static clib_error_t *
 280 ipsec_spd_add_del_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   u32 spd_id = ~0;
 286   int is_add = ~0;
 287   clib_error_t *error = NULL;
 288
 289   if (!unformat_user (input, unformat_line_input, line_input))
 290     return 0;
 291
 292   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 293     {
 294       if (unformat (line_input, "add"))
 295         is_add = 1;
 296       else if (unformat (line_input, "del"))
 297         is_add = 0;
 298       else if (unformat (line_input, "%u", &spd_id))
 299         ;
 300       else
 301         {
 302           error = clib_error_return (0, "parse error: '%U'",
 303                                      format_unformat_error, line_input);
 304           goto done;
 305         }
 306     }
 307
 308   if (spd_id == ~0)
 309     {
 310       error = clib_error_return (0, "please specify SPD ID");
 311       goto done;
 312     }
 313
 314   ipsec_add_del_spd (vm, spd_id, is_add);
 315
 316 done:
 317   unformat_free (line_input);
 318
 319   return error;
 320 }
 321
 322 /* *INDENT-OFF* */
 323 VLIB_CLI_COMMAND (ipsec_spd_add_del_command, static) = {
 324     .path = "ipsec spd",
 325     .short_help =
 326     "ipsec spd [add|del] <id>",
 327     .function = ipsec_spd_add_del_command_fn,
 328 };
 329 /* *INDENT-ON* */
 330
 331
 332 static clib_error_t *
 333 ipsec_policy_add_del_command_fn (vlib_main_t * vm,
 334                                  unformat_input_t * input,
 335                                  vlib_cli_command_t * cmd)
 336 {
 337   unformat_input_t _line_input, *line_input = &_line_input;
 338   ipsec_policy_t p;
 339   int rv, is_add = 0;
 340   u32 tmp, tmp2, stat_index, local_range_set, remote_range_set;
 341   clib_error_t *error = NULL;
 342   u32 is_outbound;
 343
 344   clib_memset (&p, 0, sizeof (p));
 345   p.lport.stop = p.rport.stop = ~0;
 346   remote_range_set = local_range_set = is_outbound = 0;
 347   p.protocol = IPSEC_POLICY_PROTOCOL_ANY;
 348
 349   if (!unformat_user (input, unformat_line_input, line_input))
 350     return 0;
 351
 352   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 353     {
 354       if (unformat (line_input, "add"))
 355         is_add = 1;
 356       else if (unformat (line_input, "del"))
 357         is_add = 0;
 358       else if (unformat (line_input, "ip6"))
 359         p.is_ipv6 = 1;
 360       else if (unformat (line_input, "spd %u", &p.id))
 361         ;
 362       else if (unformat (line_input, "inbound"))
 363         is_outbound = 0;
 364       else if (unformat (line_input, "outbound"))
 365         is_outbound = 1;
 366       else if (unformat (line_input, "priority %d", &p.priority))
 367         ;
 368       else if (unformat (line_input, "protocol %u", &tmp))
 369         p.protocol = (u8) tmp;
 370       else
 371         if (unformat
 372             (line_input, "action %U", unformat_ipsec_policy_action,
 373              &p.policy))
 374         {
 375           if (p.policy == IPSEC_POLICY_ACTION_RESOLVE)
 376             {
 377               error = clib_error_return (0, "unsupported action: 'resolve'");
 378               goto done;
 379             }
 380         }
 381       else if (unformat (line_input, "sa %u", &p.sa_id))
 382         ;
 383       else if (unformat (line_input, "local-ip-range %U - %U",
 384                          unformat_ip4_address, &p.laddr.start.ip4,
 385                          unformat_ip4_address, &p.laddr.stop.ip4))
 386         local_range_set = 1;
 387       else if (unformat (line_input, "remote-ip-range %U - %U",
 388                          unformat_ip4_address, &p.raddr.start.ip4,
 389                          unformat_ip4_address, &p.raddr.stop.ip4))
 390         remote_range_set = 1;
 391       else if (unformat (line_input, "local-ip-range %U - %U",
 392                          unformat_ip6_address, &p.laddr.start.ip6,
 393                          unformat_ip6_address, &p.laddr.stop.ip6))
 394         {
 395           p.is_ipv6 = 1;
 396           local_range_set = 1;
 397         }
 398       else if (unformat (line_input, "remote-ip-range %U - %U",
 399                          unformat_ip6_address, &p.raddr.start.ip6,
 400                          unformat_ip6_address, &p.raddr.stop.ip6))
 401         {
 402           p.is_ipv6 = 1;
 403           remote_range_set = 1;
 404         }
 405       else if (unformat (line_input, "local-port-range %u - %u", &tmp, &tmp2))
 406         {
 407           p.lport.start = tmp;
 408           p.lport.stop = tmp2;
 409         }
 410       else
 411         if (unformat (line_input, "remote-port-range %u - %u", &tmp, &tmp2))
 412         {
 413           p.rport.start = tmp;
 414           p.rport.stop = tmp2;
 415         }
 416       else
 417         {
 418           error = clib_error_return (0, "parse error: '%U'",
 419                                      format_unformat_error, line_input);
 420           goto done;
 421         }
 422     }
 423
 424   if (!remote_range_set)
 425     {
 426       if (p.is_ipv6)
 427         clib_memset (&p.raddr.stop.ip6, 0xff, 16);
 428       else
 429         clib_memset (&p.raddr.stop.ip4, 0xff, 4);
 430     }
 431   if (!local_range_set)
 432     {
 433       if (p.is_ipv6)
 434         clib_memset (&p.laddr.stop.ip6, 0xff, 16);
 435       else
 436         clib_memset (&p.laddr.stop.ip4, 0xff, 4);
 437     }
 438
 439   rv = ipsec_policy_mk_type (is_outbound, p.is_ipv6, p.policy, &p.type);
 440
 441   if (rv)
 442     {
 443       error = clib_error_return (0, "unsupported policy type for:",
 444                                  " outboud:%s %s action:%U",
 445                                  (is_outbound ? "yes" : "no"),
 446                                  (p.is_ipv6 ? "IPv4" : "IPv6"),
 447                                  format_ipsec_policy_action, p.policy);
 448       goto done;
 449     }
 450
 451   rv = ipsec_add_del_policy (vm, &p, is_add, &stat_index);
 452
 453   if (!rv)
 454     vlib_cli_output (vm, "policy-index:%d", stat_index);
 455   else
 456     vlib_cli_output (vm, "error:%d", rv);
 457
 458 done:
 459   unformat_free (line_input);
 460
 461   return error;
 462 }
 463
 464 /* *INDENT-OFF* */
 465 VLIB_CLI_COMMAND (ipsec_policy_add_del_command, static) = {
 466     .path = "ipsec policy",
 467     .short_help =
 468     "ipsec policy [add|del] spd <id> priority <n> ",
 469     .function = ipsec_policy_add_del_command_fn,
 470 };
 471 /* *INDENT-ON* */
 472
 473 static void
 474 ipsec_sa_show_all (vlib_main_t * vm, ipsec_main_t * im, u8 detail)
 475 {
 476   u32 sai;
 477
 478   /* *INDENT-OFF* */
 479   pool_foreach_index (sai, ipsec_sa_pool)
 480     {
 481       vlib_cli_output (vm, "%U", format_ipsec_sa, sai,
 482                        (detail ? IPSEC_FORMAT_DETAIL : IPSEC_FORMAT_BRIEF));
 483     }
 484   /* *INDENT-ON* */
 485 }
 486
 487 static void
 488 ipsec_spd_show_all (vlib_main_t * vm, ipsec_main_t * im)
 489 {
 490   u32 spdi;
 491
 492   /* *INDENT-OFF* */
 493   pool_foreach_index (spdi, im->spds)  {
 494     vlib_cli_output(vm, "%U", format_ipsec_spd, spdi);
 495   }
 496
 497   if (im->output_flow_cache_flag)
 498     {
 499       vlib_cli_output (vm, "%U", format_ipsec_out_spd_flow_cache);
 500     }
 501   if (im->input_flow_cache_flag)
 502     {
 503       vlib_cli_output (vm, "%U", format_ipsec_in_spd_flow_cache);
 504     }
 505   /* *INDENT-ON* */
 506 }
 507
 508 static void
 509 ipsec_spd_bindings_show_all (vlib_main_t * vm, ipsec_main_t * im)
 510 {
 511   u32 spd_id, sw_if_index;
 512   ipsec_spd_t *spd;
 513
 514   vlib_cli_output (vm, "SPD Bindings:");
 515
 516   /* *INDENT-OFF* */
 517   hash_foreach(sw_if_index, spd_id, im->spd_index_by_sw_if_index, ({
 518     spd = pool_elt_at_index (im->spds, spd_id);
 519     vlib_cli_output (vm, "  %d -> %U", spd->id,
 520                      format_vnet_sw_if_index_name, im->vnet_main,
 521                      sw_if_index);
 522   }));
 523   /* *INDENT-ON* */
 524 }
 525
 526 static walk_rc_t
 527 ipsec_tun_protect_show_one (index_t itpi, void *ctx)
 528 {
 529   vlib_cli_output (ctx, "%U", format_ipsec_tun_protect_index, itpi);
 530
 531   return (WALK_CONTINUE);
 532 }
 533
 534 static void
 535 ipsec_tunnel_show_all (vlib_main_t * vm)
 536 {
 537   ipsec_tun_protect_walk (ipsec_tun_protect_show_one, vm);
 538 }
 539
 540 static clib_error_t *
 541 show_ipsec_command_fn (vlib_main_t * vm,
 542                        unformat_input_t * input, vlib_cli_command_t * cmd)
 543 {
 544   ipsec_main_t *im = &ipsec_main;
 545
 546   ipsec_sa_show_all (vm, im, 0);
 547   ipsec_spd_show_all (vm, im);
 548   ipsec_spd_bindings_show_all (vm, im);
 549   ipsec_tun_protect_walk (ipsec_tun_protect_show_one, vm);
 550
 551   vlib_cli_output (vm, "IPSec async mode: %s",
 552                    (im->async_mode ? "on" : "off"));
 553
 554   return 0;
 555 }
 556
 557 /* *INDENT-OFF* */
 558 VLIB_CLI_COMMAND (show_ipsec_command, static) = {
 559     .path = "show ipsec all",
 560     .short_help = "show ipsec all",
 561     .function = show_ipsec_command_fn,
 562 };
 563 /* *INDENT-ON* */
 564
 565 static clib_error_t *
 566 show_ipsec_sa_command_fn (vlib_main_t * vm,
 567                           unformat_input_t * input, vlib_cli_command_t * cmd)
 568 {
 569   ipsec_main_t *im = &ipsec_main;
 570   u32 sai = ~0;
 571   u8 detail = 0;
 572
 573   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 574     {
 575       if (unformat (input, "%u", &sai))
 576         ;
 577       if (unformat (input, "detail"))
 578         detail = 1;
 579       else
 580         break;
 581     }
 582
 583   if (~0 == sai)
 584     ipsec_sa_show_all (vm, im, detail);
 585   else
 586     vlib_cli_output (vm, "%U", format_ipsec_sa, sai,
 587                      IPSEC_FORMAT_DETAIL | IPSEC_FORMAT_INSECURE);
 588
 589   return 0;
 590 }
 591
 592 static clib_error_t *
 593 clear_ipsec_sa_command_fn (vlib_main_t * vm,
 594                            unformat_input_t * input, vlib_cli_command_t * cmd)
 595 {
 596   u32 sai = ~0;
 597
 598   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 599     {
 600       if (unformat (input, "%u", &sai))
 601         ;
 602       else
 603         break;
 604     }
 605
 606   if (~0 == sai)
 607     {
 608       /* *INDENT-OFF* */
 609       pool_foreach_index (sai, ipsec_sa_pool)
 610         {
 611           ipsec_sa_clear (sai);
 612         }
 613       /* *INDENT-ON* */
 614     }
 615   else
 616     {
 617       if (pool_is_free_index (ipsec_sa_pool, sai))
 618         return clib_error_return (0, "unknown SA index: %d", sai);
 619       else
 620         ipsec_sa_clear (sai);
 621     }
 622
 623   return 0;
 624 }
 625
 626 /* *INDENT-OFF* */
 627 VLIB_CLI_COMMAND (show_ipsec_sa_command, static) = {
 628     .path = "show ipsec sa",
 629     .short_help = "show ipsec sa [index]",
 630     .function = show_ipsec_sa_command_fn,
 631 };
 632
 633 VLIB_CLI_COMMAND (clear_ipsec_sa_command, static) = {
 634     .path = "clear ipsec sa",
 635     .short_help = "clear ipsec sa [index]",
 636     .function = clear_ipsec_sa_command_fn,
 637 };
 638 /* *INDENT-ON* */
 639
 640 static clib_error_t *
 641 show_ipsec_spd_command_fn (vlib_main_t * vm,
 642                            unformat_input_t * input, vlib_cli_command_t * cmd)
 643 {
 644   ipsec_main_t *im = &ipsec_main;
 645   u8 show_bindings = 0;
 646   u32 spdi = ~0;
 647
 648   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 649     {
 650       if (unformat (input, "%u", &spdi))
 651         ;
 652       else if (unformat (input, "bindings"))
 653         show_bindings = 1;
 654       else
 655         break;
 656     }
 657
 658   if (show_bindings)
 659     ipsec_spd_bindings_show_all (vm, im);
 660   else if (~0 != spdi)
 661     vlib_cli_output (vm, "%U", format_ipsec_spd, spdi);
 662   else
 663     ipsec_spd_show_all (vm, im);
 664
 665   return 0;
 666 }
 667
 668 /* *INDENT-OFF* */
 669 VLIB_CLI_COMMAND (show_ipsec_spd_command, static) = {
 670     .path = "show ipsec spd",
 671     .short_help = "show ipsec spd [index]",
 672     .function = show_ipsec_spd_command_fn,
 673 };
 674 /* *INDENT-ON* */
 675
 676 static clib_error_t *
 677 show_ipsec_tunnel_command_fn (vlib_main_t * vm,
 678                               unformat_input_t * input,
 679                               vlib_cli_command_t * cmd)
 680 {
 681   ipsec_tunnel_show_all (vm);
 682
 683   return 0;
 684 }
 685
 686 /* *INDENT-OFF* */
 687 VLIB_CLI_COMMAND (show_ipsec_tunnel_command, static) = {
 688     .path = "show ipsec tunnel",
 689     .short_help = "show ipsec tunnel",
 690     .function = show_ipsec_tunnel_command_fn,
 691 };
 692 /* *INDENT-ON* */
 693
 694 static clib_error_t *
 695 ipsec_show_backends_command_fn (vlib_main_t * vm,
 696                                 unformat_input_t * input,
 697                                 vlib_cli_command_t * cmd)
 698 {
 699   ipsec_main_t *im = &ipsec_main;
 700   u32 verbose = 0;
 701
 702   (void) unformat (input, "verbose %u", &verbose);
 703
 704   vlib_cli_output (vm, "IPsec AH backends available:");
 705   u8 *s = format (NULL, "%=25s %=25s %=10s\n", "Name", "Index", "Active");
 706   ipsec_ah_backend_t *ab;
 707   /* *INDENT-OFF* */
 708   pool_foreach (ab, im->ah_backends) {
 709     s = format (s, "%=25s %=25u %=10s\n", ab->name, ab - im->ah_backends,
 710                 ab - im->ah_backends == im->ah_current_backend ? "yes" : "no");
 711     if (verbose) {
 712         vlib_node_t *n;
 713         n = vlib_get_node (vm, ab->ah4_encrypt_node_index);
 714         s = format (s, "     enc4 %s (next %d)\n", n->name, ab->ah4_encrypt_next_index);
 715         n = vlib_get_node (vm, ab->ah4_decrypt_node_index);
 716         s = format (s, "     dec4 %s (next %d)\n", n->name, ab->ah4_decrypt_next_index);
 717         n = vlib_get_node (vm, ab->ah6_encrypt_node_index);
 718         s = format (s, "     enc6 %s (next %d)\n", n->name, ab->ah6_encrypt_next_index);
 719         n = vlib_get_node (vm, ab->ah6_decrypt_node_index);
 720         s = format (s, "     dec6 %s (next %d)\n", n->name, ab->ah6_decrypt_next_index);
 721     }
 722   }
 723   /* *INDENT-ON* */
 724   vlib_cli_output (vm, "%v", s);
 725   vec_set_len (s, 0);
 726   vlib_cli_output (vm, "IPsec ESP backends available:");
 727   s = format (s, "%=25s %=25s %=10s\n", "Name", "Index", "Active");
 728   ipsec_esp_backend_t *eb;
 729   /* *INDENT-OFF* */
 730   pool_foreach (eb, im->esp_backends) {
 731     s = format (s, "%=25s %=25u %=10s\n", eb->name, eb - im->esp_backends,
 732                 eb - im->esp_backends == im->esp_current_backend ? "yes"
 733                                                                  : "no");
 734     if (verbose) {
 735         vlib_node_t *n;
 736         n = vlib_get_node (vm, eb->esp4_encrypt_node_index);
 737         s = format (s, "     enc4 %s (next %d)\n", n->name, eb->esp4_encrypt_next_index);
 738         n = vlib_get_node (vm, eb->esp4_decrypt_node_index);
 739         s = format (s, "     dec4 %s (next %d)\n", n->name, eb->esp4_decrypt_next_index);
 740         n = vlib_get_node (vm, eb->esp6_encrypt_node_index);
 741         s = format (s, "     enc6 %s (next %d)\n", n->name, eb->esp6_encrypt_next_index);
 742         n = vlib_get_node (vm, eb->esp6_decrypt_node_index);
 743         s = format (s, "     dec6 %s (next %d)\n", n->name, eb->esp6_decrypt_next_index);
 744     }
 745   }
 746   /* *INDENT-ON* */
 747   vlib_cli_output (vm, "%v", s);
 748
 749   vec_free (s);
 750   return 0;
 751 }
 752
 753 /* *INDENT-OFF* */
 754 VLIB_CLI_COMMAND (ipsec_show_backends_command, static) = {
 755     .path = "show ipsec backends",
 756     .short_help = "show ipsec backends",
 757     .function = ipsec_show_backends_command_fn,
 758 };
 759 /* *INDENT-ON* */
 760
 761 static clib_error_t *
 762 ipsec_select_backend_command_fn (vlib_main_t * vm,
 763                                  unformat_input_t * input,
 764                                  vlib_cli_command_t * cmd)
 765 {
 766   unformat_input_t _line_input, *line_input = &_line_input;
 767   ipsec_main_t *im = &ipsec_main;
 768   clib_error_t *error;
 769   u32 backend_index;
 770
 771   error = ipsec_rsc_in_use (im);
 772
 773   if (error)
 774     return error;
 775
 776   /* Get a line of input. */
 777   if (!unformat_user (input, unformat_line_input, line_input))
 778     return 0;
 779
 780   if (unformat (line_input, "ah"))
 781     {
 782       if (unformat (line_input, "%u", &backend_index))
 783         {
 784           if (ipsec_select_ah_backend (im, backend_index) < 0)
 785             {
 786               return clib_error_return (0, "Invalid AH backend index `%u'",
 787                                         backend_index);
 788             }
 789         }
 790       else
 791         {
 792           return clib_error_return (0, "Invalid backend index `%U'",
 793                                     format_unformat_error, line_input);
 794         }
 795     }
 796   else if (unformat (line_input, "esp"))
 797     {
 798       if (unformat (line_input, "%u", &backend_index))
 799         {
 800           if (ipsec_select_esp_backend (im, backend_index) < 0)
 801             {
 802               return clib_error_return (0, "Invalid ESP backend index `%u'",
 803                                         backend_index);
 804             }
 805         }
 806       else
 807         {
 808           return clib_error_return (0, "Invalid backend index `%U'",
 809                                     format_unformat_error, line_input);
 810         }
 811     }
 812   else
 813     {
 814       return clib_error_return (0, "Unknown input `%U'",
 815                                 format_unformat_error, line_input);
 816     }
 817
 818   return 0;
 819 }
 820
 821 /* *INDENT-OFF* */
 822 VLIB_CLI_COMMAND (ipsec_select_backend_command, static) = {
 823     .path = "ipsec select backend",
 824     .short_help = "ipsec select backend <ah|esp> <backend index>",
 825     .function = ipsec_select_backend_command_fn,
 826 };
 827
 828 /* *INDENT-ON* */
 829
 830 static clib_error_t *
 831 clear_ipsec_counters_command_fn (vlib_main_t * vm,
 832                                  unformat_input_t * input,
 833                                  vlib_cli_command_t * cmd)
 834 {
 835   vlib_clear_combined_counters (&ipsec_spd_policy_counters);
 836   vlib_clear_combined_counters (&ipsec_sa_counters);
 837   for (int i = 0; i < IPSEC_SA_N_ERRORS; i++)
 838     vlib_clear_simple_counters (&ipsec_sa_err_counters[i]);
 839
 840   return (NULL);
 841 }
 842
 843 /* *INDENT-OFF* */
 844 VLIB_CLI_COMMAND (clear_ipsec_counters_command, static) = {
 845     .path = "clear ipsec counters",
 846     .short_help = "clear ipsec counters",
 847     .function = clear_ipsec_counters_command_fn,
 848 };
 849 /* *INDENT-ON* */
 850
 851 static clib_error_t *
 852 ipsec_tun_protect_cmd (vlib_main_t * vm,
 853                        unformat_input_t * input, vlib_cli_command_t * cmd)
 854 {
 855   unformat_input_t _line_input, *line_input = &_line_input;
 856   u32 sw_if_index, is_del, sa_in, sa_out, *sa_ins = NULL;
 857   ip_address_t peer = { };
 858   vnet_main_t *vnm;
 859
 860   is_del = 0;
 861   sw_if_index = ~0;
 862   vnm = vnet_get_main ();
 863
 864   if (!unformat_user (input, unformat_line_input, line_input))
 865     return 0;
 866
 867   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 868     {
 869       if (unformat (line_input, "del"))
 870         is_del = 1;
 871       else if (unformat (line_input, "add"))
 872         is_del = 0;
 873       else if (unformat (line_input, "sa-in %d", &sa_in))
 874         vec_add1 (sa_ins, sa_in);
 875       else if (unformat (line_input, "sa-out %d", &sa_out))
 876         ;
 877       else if (unformat (line_input, "%U",
 878                          unformat_vnet_sw_interface, vnm, &sw_if_index))
 879         ;
 880       else if (unformat (line_input, "%U", unformat_ip_address, &peer))
 881         ;
 882       else
 883         return (clib_error_return (0, "unknown input '%U'",
 884                                    format_unformat_error, line_input));
 885     }
 886
 887   if (!is_del)
 888     ipsec_tun_protect_update (sw_if_index, &peer, sa_out, sa_ins);
 889   else
 890     ipsec_tun_protect_del (sw_if_index, &peer);
 891
 892   unformat_free (line_input);
 893   return NULL;
 894 }
 895
 896 /**
 897  * Protect tunnel with IPSEC
 898  */
 899 /* *INDENT-OFF* */
 900 VLIB_CLI_COMMAND (ipsec_tun_protect_cmd_node, static) =
 901 {
 902   .path = "ipsec tunnel protect",
 903   .function = ipsec_tun_protect_cmd,
 904   .short_help = "ipsec tunnel protect <interface> input-sa <SA> output-sa <SA> [add|del]",
 905     // this is not MP safe
 906 };
 907 /* *INDENT-ON* */
 908
 909
 910 static clib_error_t *
 911 ipsec_tun_protect_show (vlib_main_t * vm,
 912                         unformat_input_t * input, vlib_cli_command_t * cmd)
 913 {
 914   ipsec_tun_protect_walk (ipsec_tun_protect_show_one, vm);
 915
 916   return NULL;
 917 }
 918
 919 /**
 920  * show IPSEC tunnel protection
 921  */
 922 /* *INDENT-OFF* */
 923 VLIB_CLI_COMMAND (ipsec_tun_protect_show_node, static) =
 924 {
 925   .path = "show ipsec protect",
 926   .function = ipsec_tun_protect_show,
 927   .short_help =  "show ipsec protect",
 928 };
 929 /* *INDENT-ON* */
 930
 931 static int
 932 ipsec_tun_protect4_hash_show_one (clib_bihash_kv_8_16_t * kv, void *arg)
 933 {
 934   ipsec4_tunnel_kv_t *ikv = (ipsec4_tunnel_kv_t *) kv;
 935   vlib_main_t *vm = arg;
 936
 937   vlib_cli_output (vm, " %U", format_ipsec4_tunnel_kv, ikv);
 938
 939   return (BIHASH_WALK_CONTINUE);
 940 }
 941
 942 static int
 943 ipsec_tun_protect6_hash_show_one (clib_bihash_kv_24_16_t * kv, void *arg)
 944 {
 945   ipsec6_tunnel_kv_t *ikv = (ipsec6_tunnel_kv_t *) kv;
 946   vlib_main_t *vm = arg;
 947
 948   vlib_cli_output (vm, " %U", format_ipsec6_tunnel_kv, ikv);
 949
 950   return (BIHASH_WALK_CONTINUE);
 951 }
 952
 953 static clib_error_t *
 954 ipsec_tun_protect_hash_show (vlib_main_t * vm,
 955                              unformat_input_t * input,
 956                              vlib_cli_command_t * cmd)
 957 {
 958   ipsec_main_t *im = &ipsec_main;
 959
 960   {
 961     vlib_cli_output (vm, "IPv4:");
 962
 963     clib_bihash_foreach_key_value_pair_8_16
 964       (&im->tun4_protect_by_key, ipsec_tun_protect4_hash_show_one, vm);
 965
 966     vlib_cli_output (vm, "IPv6:");
 967
 968     clib_bihash_foreach_key_value_pair_24_16
 969       (&im->tun6_protect_by_key, ipsec_tun_protect6_hash_show_one, vm);
 970   }
 971
 972   return NULL;
 973 }
 974
 975 /**
 976  * show IPSEC tunnel protection hash tables
 977  */
 978 /* *INDENT-OFF* */
 979 VLIB_CLI_COMMAND (ipsec_tun_protect_hash_show_node, static) =
 980 {
 981   .path = "show ipsec protect-hash",
 982   .function = ipsec_tun_protect_hash_show,
 983   .short_help =  "show ipsec protect-hash",
 984 };
 985 /* *INDENT-ON* */
 986
 987 clib_error_t *
 988 ipsec_cli_init (vlib_main_t * vm)
 989 {
 990   return 0;
 991 }
 992
 993 VLIB_INIT_FUNCTION (ipsec_cli_init);
 994
 995 static clib_error_t *
 996 set_async_mode_command_fn (vlib_main_t * vm, unformat_input_t * input,
 997                            vlib_cli_command_t * cmd)
 998 {
 999   unformat_input_t _line_input, *line_input = &_line_input;
1000   int async_enable = 0;
1001
1002   if (!unformat_user (input, unformat_line_input, line_input))
1003     return 0;
1004
1005   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1006     {
1007       if (unformat (line_input, "on"))
1008         async_enable = 1;
1009       else if (unformat (line_input, "off"))
1010         async_enable = 0;
1011       else
1012         return (clib_error_return (0, "unknown input '%U'",
1013                                    format_unformat_error, line_input));
1014     }
1015
1016   ipsec_set_async_mode (async_enable);
1017
1018   unformat_free (line_input);
1019   return (NULL);
1020 }
1021
1022 /* *INDENT-OFF* */
1023 VLIB_CLI_COMMAND (set_async_mode_command, static) = {
1024     .path = "set ipsec async mode",
1025     .short_help = "set ipsec async mode on|off",
1026     .function = set_async_mode_command_fn,
1027 };
1028 /* *INDENT-ON* */
1029
1030 /*
1031  * fd.io coding-style-patch-verification: ON
1032  *
1033  * Local Variables:
1034  * eval: (c-set-style "gnu")
1035  * End:
1036  */