src/vnet/ipsec/ipsec_sa.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <sys/random.h>
  17 #include <vnet/ipsec/ipsec.h>
  18 #include <vnet/ipsec/esp.h>
  19 #include <vnet/udp/udp_local.h>
  20 #include <vnet/fib/fib_table.h>
  21 #include <vnet/fib/fib_entry_track.h>
  22 #include <vnet/ipsec/ipsec_tun.h>
  23 #include <vnet/ipsec/ipsec.api_enum.h>
  24
  25 /**
  26  * @brief
  27  * SA packet & bytes counters
  28  */
  29 vlib_combined_counter_main_t ipsec_sa_counters = {
  30   .name = "SA",
  31   .stat_segment_name = "/net/ipsec/sa",
  32 };
  33 /* Per-SA error counters */
  34 vlib_simple_counter_main_t ipsec_sa_err_counters[IPSEC_SA_N_ERRORS];
  35
  36 ipsec_sa_t *ipsec_sa_pool;
  37
  38 static clib_error_t *
  39 ipsec_call_add_del_callbacks (ipsec_main_t * im, ipsec_sa_t * sa,
  40                               u32 sa_index, int is_add)
  41 {
  42   ipsec_ah_backend_t *ab;
  43   ipsec_esp_backend_t *eb;
  44   switch (sa->protocol)
  45     {
  46     case IPSEC_PROTOCOL_AH:
  47       ab = pool_elt_at_index (im->ah_backends, im->ah_current_backend);
  48       if (ab->add_del_sa_sess_cb)
  49         return ab->add_del_sa_sess_cb (sa_index, is_add);
  50       break;
  51     case IPSEC_PROTOCOL_ESP:
  52       eb = pool_elt_at_index (im->esp_backends, im->esp_current_backend);
  53       if (eb->add_del_sa_sess_cb)
  54         return eb->add_del_sa_sess_cb (sa_index, is_add);
  55       break;
  56     }
  57   return 0;
  58 }
  59
  60 void
  61 ipsec_mk_key (ipsec_key_t * key, const u8 * data, u8 len)
  62 {
  63   memset (key, 0, sizeof (*key));
  64
  65   if (len > sizeof (key->data))
  66     key->len = sizeof (key->data);
  67   else
  68     key->len = len;
  69
  70   memcpy (key->data, data, key->len);
  71 }
  72
  73 /**
  74  * 'stack' (resolve the recursion for) the SA tunnel destination
  75  */
  76 static void
  77 ipsec_sa_stack (ipsec_sa_t * sa)
  78 {
  79   ipsec_main_t *im = &ipsec_main;
  80   dpo_id_t tmp = DPO_INVALID;
  81
  82   tunnel_contribute_forwarding (&sa->tunnel, &tmp);
  83
  84   if (IPSEC_PROTOCOL_AH == sa->protocol)
  85     dpo_stack_from_node ((ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ?
  86                           im->ah6_encrypt_node_index :
  87                           im->ah4_encrypt_node_index), &sa->dpo, &tmp);
  88   else
  89     dpo_stack_from_node ((ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ?
  90                           im->esp6_encrypt_node_index :
  91                           im->esp4_encrypt_node_index), &sa->dpo, &tmp);
  92   dpo_reset (&tmp);
  93 }
  94
  95 void
  96 ipsec_sa_set_async_mode (ipsec_sa_t *sa, int is_enabled)
  97 {
  98   if (is_enabled)
  99     {
 100       sa->crypto_key_index = sa->crypto_async_key_index;
 101       sa->crypto_enc_op_id = sa->crypto_async_enc_op_id;
 102       sa->crypto_dec_op_id = sa->crypto_async_dec_op_id;
 103       sa->integ_key_index = ~0;
 104       sa->integ_op_id = ~0;
 105     }
 106   else
 107     {
 108       sa->crypto_key_index = sa->crypto_sync_key_index;
 109       sa->crypto_enc_op_id = sa->crypto_sync_enc_op_id;
 110       sa->crypto_dec_op_id = sa->crypto_sync_dec_op_id;
 111       sa->integ_key_index = sa->integ_sync_key_index;
 112       sa->integ_op_id = sa->integ_sync_op_id;
 113     }
 114 }
 115
 116 void
 117 ipsec_sa_set_crypto_alg (ipsec_sa_t * sa, ipsec_crypto_alg_t crypto_alg)
 118 {
 119   ipsec_main_t *im = &ipsec_main;
 120   sa->crypto_alg = crypto_alg;
 121   sa->crypto_iv_size = im->crypto_algs[crypto_alg].iv_size;
 122   sa->esp_block_align = clib_max (4, im->crypto_algs[crypto_alg].block_align);
 123   sa->crypto_sync_enc_op_id = im->crypto_algs[crypto_alg].enc_op_id;
 124   sa->crypto_sync_dec_op_id = im->crypto_algs[crypto_alg].dec_op_id;
 125   sa->crypto_calg = im->crypto_algs[crypto_alg].alg;
 126   ASSERT (sa->crypto_iv_size <= ESP_MAX_IV_SIZE);
 127   ASSERT (sa->esp_block_align <= ESP_MAX_BLOCK_SIZE);
 128   if (IPSEC_CRYPTO_ALG_IS_GCM (crypto_alg) ||
 129       IPSEC_CRYPTO_ALG_CTR_AEAD_OTHERS (crypto_alg))
 130     {
 131       sa->integ_icv_size = im->crypto_algs[crypto_alg].icv_size;
 132       ipsec_sa_set_IS_CTR (sa);
 133       ipsec_sa_set_IS_AEAD (sa);
 134     }
 135   else if (IPSEC_CRYPTO_ALG_IS_CTR (crypto_alg))
 136     {
 137       ipsec_sa_set_IS_CTR (sa);
 138     }
 139   else if (IPSEC_CRYPTO_ALG_IS_NULL_GMAC (crypto_alg))
 140     {
 141       sa->integ_icv_size = im->crypto_algs[crypto_alg].icv_size;
 142       ipsec_sa_set_IS_CTR (sa);
 143       ipsec_sa_set_IS_AEAD (sa);
 144       ipsec_sa_set_IS_NULL_GMAC (sa);
 145     }
 146 }
 147
 148 void
 149 ipsec_sa_set_integ_alg (ipsec_sa_t * sa, ipsec_integ_alg_t integ_alg)
 150 {
 151   ipsec_main_t *im = &ipsec_main;
 152   sa->integ_alg = integ_alg;
 153   sa->integ_icv_size = im->integ_algs[integ_alg].icv_size;
 154   sa->integ_sync_op_id = im->integ_algs[integ_alg].op_id;
 155   sa->integ_calg = im->integ_algs[integ_alg].alg;
 156   ASSERT (sa->integ_icv_size <= ESP_MAX_ICV_SIZE);
 157 }
 158
 159 void
 160 ipsec_sa_set_async_op_ids (ipsec_sa_t * sa)
 161 {
 162   /* *INDENT-OFF* */
 163   if (ipsec_sa_is_set_USE_ESN (sa))
 164     {
 165 #define _(n, s, k)                                                            \
 166   if (sa->crypto_sync_enc_op_id == VNET_CRYPTO_OP_##n##_ENC)                  \
 167     sa->crypto_async_enc_op_id = VNET_CRYPTO_OP_##n##_TAG16_AAD12_ENC;        \
 168   if (sa->crypto_sync_dec_op_id == VNET_CRYPTO_OP_##n##_DEC)                  \
 169     sa->crypto_async_dec_op_id = VNET_CRYPTO_OP_##n##_TAG16_AAD12_DEC;
 170       foreach_crypto_aead_alg
 171 #undef _
 172     }
 173   else
 174     {
 175 #define _(n, s, k)                                                            \
 176   if (sa->crypto_sync_enc_op_id == VNET_CRYPTO_OP_##n##_ENC)                  \
 177     sa->crypto_async_enc_op_id = VNET_CRYPTO_OP_##n##_TAG16_AAD8_ENC;         \
 178   if (sa->crypto_sync_dec_op_id == VNET_CRYPTO_OP_##n##_DEC)                  \
 179     sa->crypto_async_dec_op_id = VNET_CRYPTO_OP_##n##_TAG16_AAD8_DEC;
 180       foreach_crypto_aead_alg
 181 #undef _
 182     }
 183
 184 #define _(c, h, s, k, d)                                                      \
 185   if (sa->crypto_sync_enc_op_id == VNET_CRYPTO_OP_##c##_ENC &&                \
 186       sa->integ_sync_op_id == VNET_CRYPTO_OP_##h##_HMAC)                      \
 187     sa->crypto_async_enc_op_id = VNET_CRYPTO_OP_##c##_##h##_TAG##d##_ENC;     \
 188   if (sa->crypto_sync_dec_op_id == VNET_CRYPTO_OP_##c##_DEC &&                \
 189       sa->integ_sync_op_id == VNET_CRYPTO_OP_##h##_HMAC)                      \
 190     sa->crypto_async_dec_op_id = VNET_CRYPTO_OP_##c##_##h##_TAG##d##_DEC;
 191   foreach_crypto_link_async_alg
 192 #undef _
 193   /* *INDENT-ON* */
 194 }
 195
 196 int
 197 ipsec_sa_update (u32 id, u16 src_port, u16 dst_port, const tunnel_t *tun,
 198                  bool is_tun)
 199 {
 200   ipsec_main_t *im = &ipsec_main;
 201   ipsec_sa_t *sa;
 202   u32 sa_index;
 203   uword *p;
 204   int rv;
 205
 206   p = hash_get (im->sa_index_by_sa_id, id);
 207   if (!p)
 208     return VNET_API_ERROR_NO_SUCH_ENTRY;
 209
 210   sa = ipsec_sa_get (p[0]);
 211   sa_index = sa - ipsec_sa_pool;
 212
 213   if (is_tun && ipsec_sa_is_set_IS_TUNNEL (sa) &&
 214       (ip_address_cmp (&tun->t_src, &sa->tunnel.t_src) != 0 ||
 215        ip_address_cmp (&tun->t_dst, &sa->tunnel.t_dst) != 0))
 216     {
 217       /* if the source IP is updated for an inbound SA under a tunnel protect,
 218        we need to update the tun_protect DB with the new src IP */
 219       if (ipsec_sa_is_set_IS_INBOUND (sa) &&
 220           ip_address_cmp (&tun->t_src, &sa->tunnel.t_src) != 0 &&
 221           !ip46_address_is_zero (&tun->t_src.ip))
 222         {
 223           if (ip46_address_is_ip4 (&sa->tunnel.t_src.ip))
 224             {
 225               ipsec4_tunnel_kv_t old_key, new_key;
 226               clib_bihash_kv_8_16_t res,
 227                 *bkey = (clib_bihash_kv_8_16_t *) &old_key;
 228
 229               ipsec4_tunnel_mk_key (&old_key, &sa->tunnel.t_src.ip.ip4,
 230                                     clib_host_to_net_u32 (sa->spi));
 231               ipsec4_tunnel_mk_key (&new_key, &tun->t_src.ip.ip4,
 232                                     clib_host_to_net_u32 (sa->spi));
 233
 234               if (!clib_bihash_search_8_16 (&im->tun4_protect_by_key, bkey,
 235                                             &res))
 236                 {
 237                   clib_bihash_add_del_8_16 (&im->tun4_protect_by_key, &res, 0);
 238                   res.key = new_key.key;
 239                   clib_bihash_add_del_8_16 (&im->tun4_protect_by_key, &res, 1);
 240                 }
 241             }
 242           else
 243             {
 244               ipsec6_tunnel_kv_t old_key = {
 245           .key = {
 246             .remote_ip =  sa->tunnel.t_src.ip.ip6,
 247             .spi = clib_host_to_net_u32 (sa->spi),
 248           },
 249         }, new_key = {
 250           .key = {
 251             .remote_ip = tun->t_src.ip.ip6,
 252             .spi = clib_host_to_net_u32 (sa->spi),
 253           }};
 254               clib_bihash_kv_24_16_t res,
 255                 *bkey = (clib_bihash_kv_24_16_t *) &old_key;
 256
 257               if (!clib_bihash_search_24_16 (&im->tun6_protect_by_key, bkey,
 258                                              &res))
 259                 {
 260                   clib_bihash_add_del_24_16 (&im->tun6_protect_by_key, &res,
 261                                              0);
 262                   clib_memcpy (&res.key, &new_key.key, 3);
 263                   clib_bihash_add_del_24_16 (&im->tun6_protect_by_key, &res,
 264                                              1);
 265                 }
 266             }
 267         }
 268       tunnel_unresolve (&sa->tunnel);
 269       tunnel_copy (tun, &sa->tunnel);
 270       if (!ipsec_sa_is_set_IS_INBOUND (sa))
 271         {
 272           dpo_reset (&sa->dpo);
 273
 274           sa->tunnel_flags = sa->tunnel.t_encap_decap_flags;
 275
 276           rv = tunnel_resolve (&sa->tunnel, FIB_NODE_TYPE_IPSEC_SA, sa_index);
 277
 278           if (rv)
 279             {
 280               hash_unset (im->sa_index_by_sa_id, sa->id);
 281               pool_put (ipsec_sa_pool, sa);
 282               return rv;
 283             }
 284           ipsec_sa_stack (sa);
 285           /* generate header templates */
 286           if (ipsec_sa_is_set_IS_TUNNEL_V6 (sa))
 287             {
 288               tunnel_build_v6_hdr (&sa->tunnel,
 289                                    (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 290                                             IP_PROTOCOL_UDP :
 291                                             IP_PROTOCOL_IPSEC_ESP),
 292                                    &sa->ip6_hdr);
 293             }
 294           else
 295             {
 296               tunnel_build_v4_hdr (&sa->tunnel,
 297                                    (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 298                                             IP_PROTOCOL_UDP :
 299                                             IP_PROTOCOL_IPSEC_ESP),
 300                                    &sa->ip4_hdr);
 301             }
 302         }
 303     }
 304
 305   if (ipsec_sa_is_set_UDP_ENCAP (sa))
 306     {
 307       if (dst_port != IPSEC_UDP_PORT_NONE &&
 308           dst_port != clib_net_to_host_u16 (sa->udp_hdr.dst_port))
 309         {
 310           if (ipsec_sa_is_set_IS_INBOUND (sa))
 311             {
 312               ipsec_unregister_udp_port (
 313                 clib_net_to_host_u16 (sa->udp_hdr.dst_port),
 314                 !ipsec_sa_is_set_IS_TUNNEL_V6 (sa));
 315               ipsec_register_udp_port (dst_port,
 316                                        !ipsec_sa_is_set_IS_TUNNEL_V6 (sa));
 317             }
 318           sa->udp_hdr.dst_port = clib_host_to_net_u16 (dst_port);
 319         }
 320       if (src_port != IPSEC_UDP_PORT_NONE &&
 321           src_port != clib_net_to_host_u16 (sa->udp_hdr.src_port))
 322         sa->udp_hdr.src_port = clib_host_to_net_u16 (src_port);
 323     }
 324   return (0);
 325 }
 326
 327 int
 328 ipsec_sa_add_and_lock (u32 id, u32 spi, ipsec_protocol_t proto,
 329                        ipsec_crypto_alg_t crypto_alg, const ipsec_key_t *ck,
 330                        ipsec_integ_alg_t integ_alg, const ipsec_key_t *ik,
 331                        ipsec_sa_flags_t flags, u32 salt, u16 src_port,
 332                        u16 dst_port, u32 anti_replay_window_size,
 333                        const tunnel_t *tun, u32 *sa_out_index)
 334 {
 335   vlib_main_t *vm = vlib_get_main ();
 336   ipsec_main_t *im = &ipsec_main;
 337   clib_error_t *err;
 338   ipsec_sa_t *sa;
 339   u32 sa_index;
 340   u64 rand[2];
 341   uword *p;
 342   int rv;
 343
 344   p = hash_get (im->sa_index_by_sa_id, id);
 345   if (p)
 346     return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
 347
 348   if (getrandom (rand, sizeof (rand), 0) != sizeof (rand))
 349     return VNET_API_ERROR_INIT_FAILED;
 350
 351   pool_get_aligned_zero (ipsec_sa_pool, sa, CLIB_CACHE_LINE_BYTES);
 352
 353   clib_pcg64i_srandom_r (&sa->iv_prng, rand[0], rand[1]);
 354
 355   fib_node_init (&sa->node, FIB_NODE_TYPE_IPSEC_SA);
 356   fib_node_lock (&sa->node);
 357   sa_index = sa - ipsec_sa_pool;
 358
 359   vlib_validate_combined_counter (&ipsec_sa_counters, sa_index);
 360   vlib_zero_combined_counter (&ipsec_sa_counters, sa_index);
 361   for (int i = 0; i < IPSEC_SA_N_ERRORS; i++)
 362     {
 363       vlib_validate_simple_counter (&ipsec_sa_err_counters[i], sa_index);
 364       vlib_zero_simple_counter (&ipsec_sa_err_counters[i], sa_index);
 365     }
 366
 367   tunnel_copy (tun, &sa->tunnel);
 368   sa->id = id;
 369   sa->spi = spi;
 370   sa->stat_index = sa_index;
 371   sa->protocol = proto;
 372   sa->flags = flags;
 373   sa->salt = salt;
 374   sa->thread_index = (vlib_num_workers ()) ? ~0 : 0;
 375   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 376     {
 377       ipsec_sa_set_integ_alg (sa, integ_alg);
 378       clib_memcpy (&sa->integ_key, ik, sizeof (sa->integ_key));
 379     }
 380   ipsec_sa_set_crypto_alg (sa, crypto_alg);
 381   ipsec_sa_set_async_op_ids (sa);
 382
 383   if (ipsec_sa_is_set_USE_ANTI_REPLAY (sa) && anti_replay_window_size > 64)
 384     ipsec_sa_set_ANTI_REPLAY_HUGE (sa);
 385
 386   clib_memcpy (&sa->crypto_key, ck, sizeof (sa->crypto_key));
 387
 388   sa->crypto_sync_key_index = vnet_crypto_key_add (
 389     vm, im->crypto_algs[crypto_alg].alg, (u8 *) ck->data, ck->len);
 390   if (~0 == sa->crypto_sync_key_index)
 391     {
 392       pool_put (ipsec_sa_pool, sa);
 393       return VNET_API_ERROR_KEY_LENGTH;
 394     }
 395
 396   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 397     {
 398       sa->integ_sync_key_index = vnet_crypto_key_add (
 399         vm, im->integ_algs[integ_alg].alg, (u8 *) ik->data, ik->len);
 400       if (~0 == sa->integ_sync_key_index)
 401         {
 402           pool_put (ipsec_sa_pool, sa);
 403           return VNET_API_ERROR_KEY_LENGTH;
 404         }
 405     }
 406
 407   if (sa->crypto_async_enc_op_id && !ipsec_sa_is_set_IS_AEAD (sa))
 408     sa->crypto_async_key_index =
 409       vnet_crypto_key_add_linked (vm, sa->crypto_sync_key_index,
 410                                   sa->integ_sync_key_index); // AES-CBC & HMAC
 411   else
 412     sa->crypto_async_key_index = sa->crypto_sync_key_index;
 413
 414   if (im->async_mode)
 415     {
 416       ipsec_sa_set_async_mode (sa, 1);
 417     }
 418   else if (ipsec_sa_is_set_IS_ASYNC (sa))
 419     {
 420       ipsec_sa_set_async_mode (sa, 1 /* is_enabled */);
 421     }
 422   else
 423     {
 424       ipsec_sa_set_async_mode (sa, 0 /* is_enabled */);
 425     }
 426
 427   err = ipsec_check_support_cb (im, sa);
 428   if (err)
 429     {
 430       clib_warning ("%v", err->what);
 431       pool_put (ipsec_sa_pool, sa);
 432       return VNET_API_ERROR_UNIMPLEMENTED;
 433     }
 434
 435   err = ipsec_call_add_del_callbacks (im, sa, sa_index, 1);
 436   if (err)
 437     {
 438       pool_put (ipsec_sa_pool, sa);
 439       return VNET_API_ERROR_SYSCALL_ERROR_1;
 440     }
 441
 442   if (ipsec_sa_is_set_IS_TUNNEL (sa) &&
 443       AF_IP6 == ip_addr_version (&tun->t_src))
 444     ipsec_sa_set_IS_TUNNEL_V6 (sa);
 445
 446   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 447     {
 448       sa->tunnel_flags = sa->tunnel.t_encap_decap_flags;
 449
 450       rv = tunnel_resolve (&sa->tunnel, FIB_NODE_TYPE_IPSEC_SA, sa_index);
 451
 452       if (rv)
 453         {
 454           pool_put (ipsec_sa_pool, sa);
 455           return rv;
 456         }
 457       ipsec_sa_stack (sa);
 458
 459       /* generate header templates */
 460       if (ipsec_sa_is_set_IS_TUNNEL_V6 (sa))
 461         {
 462           tunnel_build_v6_hdr (&sa->tunnel,
 463                                (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 464                                   IP_PROTOCOL_UDP :
 465                                   IP_PROTOCOL_IPSEC_ESP),
 466                                &sa->ip6_hdr);
 467         }
 468       else
 469         {
 470           tunnel_build_v4_hdr (&sa->tunnel,
 471                                (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 472                                   IP_PROTOCOL_UDP :
 473                                   IP_PROTOCOL_IPSEC_ESP),
 474                                &sa->ip4_hdr);
 475         }
 476     }
 477
 478   if (ipsec_sa_is_set_UDP_ENCAP (sa))
 479     {
 480       if (dst_port == IPSEC_UDP_PORT_NONE)
 481         sa->udp_hdr.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 482       else
 483         sa->udp_hdr.dst_port = clib_host_to_net_u16 (dst_port);
 484
 485       if (src_port == IPSEC_UDP_PORT_NONE)
 486         sa->udp_hdr.src_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 487       else
 488         sa->udp_hdr.src_port = clib_host_to_net_u16 (src_port);
 489
 490       if (ipsec_sa_is_set_IS_INBOUND (sa))
 491         ipsec_register_udp_port (clib_host_to_net_u16 (sa->udp_hdr.dst_port),
 492                                  !ipsec_sa_is_set_IS_TUNNEL_V6 (sa));
 493     }
 494
 495   /* window size rounded up to next power of 2 */
 496   if (ipsec_sa_is_set_ANTI_REPLAY_HUGE (sa))
 497     {
 498       anti_replay_window_size = 1 << max_log2 (anti_replay_window_size);
 499       sa->replay_window_huge =
 500         clib_bitmap_set_region (0, 0, 1, anti_replay_window_size);
 501     }
 502   else
 503     {
 504       sa->replay_window = ~0;
 505     }
 506
 507   hash_set (im->sa_index_by_sa_id, sa->id, sa_index);
 508
 509   if (sa_out_index)
 510     *sa_out_index = sa_index;
 511
 512   return (0);
 513 }
 514
 515 static void
 516 ipsec_sa_del (ipsec_sa_t * sa)
 517 {
 518   vlib_main_t *vm = vlib_get_main ();
 519   ipsec_main_t *im = &ipsec_main;
 520   u32 sa_index;
 521
 522   sa_index = sa - ipsec_sa_pool;
 523   hash_unset (im->sa_index_by_sa_id, sa->id);
 524   tunnel_unresolve (&sa->tunnel);
 525
 526   /* no recovery possible when deleting an SA */
 527   (void) ipsec_call_add_del_callbacks (im, sa, sa_index, 0);
 528
 529   if (ipsec_sa_is_set_IS_ASYNC (sa))
 530     {
 531       if (!ipsec_sa_is_set_IS_AEAD (sa))
 532         vnet_crypto_key_del (vm, sa->crypto_async_key_index);
 533     }
 534
 535   if (ipsec_sa_is_set_UDP_ENCAP (sa) && ipsec_sa_is_set_IS_INBOUND (sa))
 536     ipsec_unregister_udp_port (clib_net_to_host_u16 (sa->udp_hdr.dst_port),
 537                                !ipsec_sa_is_set_IS_TUNNEL_V6 (sa));
 538
 539   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 540     dpo_reset (&sa->dpo);
 541   vnet_crypto_key_del (vm, sa->crypto_sync_key_index);
 542   if (sa->integ_alg != IPSEC_INTEG_ALG_NONE)
 543     vnet_crypto_key_del (vm, sa->integ_sync_key_index);
 544   if (ipsec_sa_is_set_ANTI_REPLAY_HUGE (sa))
 545     clib_bitmap_free (sa->replay_window_huge);
 546   pool_put (ipsec_sa_pool, sa);
 547 }
 548
 549 int
 550 ipsec_sa_bind (u32 id, u32 worker, bool bind)
 551 {
 552   ipsec_main_t *im = &ipsec_main;
 553   uword *p;
 554   ipsec_sa_t *sa;
 555
 556   p = hash_get (im->sa_index_by_sa_id, id);
 557   if (!p)
 558     return VNET_API_ERROR_INVALID_VALUE;
 559
 560   sa = ipsec_sa_get (p[0]);
 561
 562   if (!bind)
 563     {
 564       sa->thread_index = ~0;
 565       return 0;
 566     }
 567
 568   if (worker >= vlib_num_workers ())
 569     return VNET_API_ERROR_INVALID_WORKER;
 570
 571   sa->thread_index = vlib_get_worker_thread_index (worker);
 572   return 0;
 573 }
 574
 575 void
 576 ipsec_sa_unlock (index_t sai)
 577 {
 578   ipsec_sa_t *sa;
 579
 580   if (INDEX_INVALID == sai)
 581     return;
 582
 583   sa = ipsec_sa_get (sai);
 584
 585   fib_node_unlock (&sa->node);
 586 }
 587
 588 void
 589 ipsec_sa_lock (index_t sai)
 590 {
 591   ipsec_sa_t *sa;
 592
 593   if (INDEX_INVALID == sai)
 594     return;
 595
 596   sa = ipsec_sa_get (sai);
 597
 598   fib_node_lock (&sa->node);
 599 }
 600
 601 index_t
 602 ipsec_sa_find_and_lock (u32 id)
 603 {
 604   ipsec_main_t *im = &ipsec_main;
 605   ipsec_sa_t *sa;
 606   uword *p;
 607
 608   p = hash_get (im->sa_index_by_sa_id, id);
 609
 610   if (!p)
 611     return INDEX_INVALID;
 612
 613   sa = ipsec_sa_get (p[0]);
 614
 615   fib_node_lock (&sa->node);
 616
 617   return (p[0]);
 618 }
 619
 620 int
 621 ipsec_sa_unlock_id (u32 id)
 622 {
 623   ipsec_main_t *im = &ipsec_main;
 624   uword *p;
 625
 626   p = hash_get (im->sa_index_by_sa_id, id);
 627
 628   if (!p)
 629     return VNET_API_ERROR_NO_SUCH_ENTRY;
 630
 631   ipsec_sa_unlock (p[0]);
 632
 633   return (0);
 634 }
 635
 636 void
 637 ipsec_sa_clear (index_t sai)
 638 {
 639   vlib_zero_combined_counter (&ipsec_sa_counters, sai);
 640   for (int i = 0; i < IPSEC_SA_N_ERRORS; i++)
 641     vlib_zero_simple_counter (&ipsec_sa_err_counters[i], sai);
 642 }
 643
 644 void
 645 ipsec_sa_walk (ipsec_sa_walk_cb_t cb, void *ctx)
 646 {
 647   ipsec_sa_t *sa;
 648
 649   /* *INDENT-OFF* */
 650   pool_foreach (sa, ipsec_sa_pool)
 651     {
 652       if (WALK_CONTINUE != cb (sa, ctx))
 653         break;
 654     }
 655   /* *INDENT-ON* */
 656 }
 657
 658 /**
 659  * Function definition to get a FIB node from its index
 660  */
 661 static fib_node_t *
 662 ipsec_sa_fib_node_get (fib_node_index_t index)
 663 {
 664   ipsec_sa_t *sa;
 665
 666   sa = ipsec_sa_get (index);
 667
 668   return (&sa->node);
 669 }
 670
 671 static ipsec_sa_t *
 672 ipsec_sa_from_fib_node (fib_node_t *node)
 673 {
 674   ASSERT (FIB_NODE_TYPE_IPSEC_SA == node->fn_type);
 675   return (
 676     (ipsec_sa_t *) (((char *) node) - STRUCT_OFFSET_OF (ipsec_sa_t, node)));
 677 }
 678
 679 /**
 680  * Function definition to inform the FIB node that its last lock has gone.
 681  */
 682 static void
 683 ipsec_sa_last_lock_gone (fib_node_t *node)
 684 {
 685   /*
 686    * The ipsec SA is a root of the graph. As such
 687    * it never has children and thus is never locked.
 688    */
 689   ipsec_sa_del (ipsec_sa_from_fib_node (node));
 690 }
 691
 692 /**
 693  * Function definition to backwalk a FIB node
 694  */
 695 static fib_node_back_walk_rc_t
 696 ipsec_sa_back_walk (fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
 697 {
 698   ipsec_sa_stack (ipsec_sa_from_fib_node (node));
 699
 700   return (FIB_NODE_BACK_WALK_CONTINUE);
 701 }
 702
 703 /*
 704  * Virtual function table registered by SAs
 705  * for participation in the FIB object graph.
 706  */
 707 const static fib_node_vft_t ipsec_sa_vft = {
 708   .fnv_get = ipsec_sa_fib_node_get,
 709   .fnv_last_lock = ipsec_sa_last_lock_gone,
 710   .fnv_back_walk = ipsec_sa_back_walk,
 711 };
 712
 713 /* Init per-SA error counters and node type */
 714 clib_error_t *
 715 ipsec_sa_init (vlib_main_t *vm)
 716 {
 717   fib_node_register_type (FIB_NODE_TYPE_IPSEC_SA, &ipsec_sa_vft);
 718
 719 #define _(index, val, err, desc)                                              \
 720   ipsec_sa_err_counters[index].name =                                         \
 721     (char *) format (0, "SA-" #err "%c", 0);                                  \
 722   ipsec_sa_err_counters[index].stat_segment_name =                            \
 723     (char *) format (0, "/net/ipsec/sa/err/" #err "%c", 0);                   \
 724   ipsec_sa_err_counters[index].counters = 0;
 725   foreach_ipsec_sa_err
 726 #undef _
 727     return 0;
 728 }
 729
 730 VLIB_INIT_FUNCTION (ipsec_sa_init);
 731
 732 /*
 733  * fd.io coding-style-patch-verification: ON
 734  *
 735  * Local Variables:
 736  * eval: (c-set-style "gnu")
 737  * End:
 738  */