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