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