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 <vnet/ipsec/ipsec.h>
  17 #include <vnet/ipsec/esp.h>
  18 #include <vnet/udp/udp_local.h>
  19 #include <vnet/fib/fib_table.h>
  20 #include <vnet/fib/fib_entry_track.h>
  21 #include <vnet/ipsec/ipsec_tun.h>
  22
  23 /**
  24  * @brief
  25  * SA packet & bytes counters
  26  */
  27 vlib_combined_counter_main_t ipsec_sa_counters = {
  28   .name = "SA",
  29   .stat_segment_name = "/net/ipsec/sa",
  30 };
  31 vlib_simple_counter_main_t ipsec_sa_lost_counters = {
  32   .name = "SA-lost",
  33   .stat_segment_name = "/net/ipsec/sa/lost",
  34 };
  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_crypto_alg (ipsec_sa_t * sa, ipsec_crypto_alg_t crypto_alg)
  97 {
  98   ipsec_main_t *im = &ipsec_main;
  99   sa->crypto_alg = crypto_alg;
 100   sa->crypto_iv_size = im->crypto_algs[crypto_alg].iv_size;
 101   sa->esp_block_align = clib_max (4, im->crypto_algs[crypto_alg].block_align);
 102   sa->sync_op_data.crypto_enc_op_id = im->crypto_algs[crypto_alg].enc_op_id;
 103   sa->sync_op_data.crypto_dec_op_id = im->crypto_algs[crypto_alg].dec_op_id;
 104   sa->crypto_calg = im->crypto_algs[crypto_alg].alg;
 105   ASSERT (sa->crypto_iv_size <= ESP_MAX_IV_SIZE);
 106   ASSERT (sa->esp_block_align <= ESP_MAX_BLOCK_SIZE);
 107   if (IPSEC_CRYPTO_ALG_IS_GCM (crypto_alg) ||
 108       IPSEC_CRYPTO_ALG_CTR_AEAD_OTHERS (crypto_alg))
 109     {
 110       sa->integ_icv_size = im->crypto_algs[crypto_alg].icv_size;
 111       ipsec_sa_set_IS_CTR (sa);
 112       ipsec_sa_set_IS_AEAD (sa);
 113     }
 114   else if (IPSEC_CRYPTO_ALG_IS_CTR (crypto_alg))
 115     {
 116       ipsec_sa_set_IS_CTR (sa);
 117     }
 118 }
 119
 120 void
 121 ipsec_sa_set_integ_alg (ipsec_sa_t * sa, ipsec_integ_alg_t integ_alg)
 122 {
 123   ipsec_main_t *im = &ipsec_main;
 124   sa->integ_alg = integ_alg;
 125   sa->integ_icv_size = im->integ_algs[integ_alg].icv_size;
 126   sa->sync_op_data.integ_op_id = im->integ_algs[integ_alg].op_id;
 127   sa->integ_calg = im->integ_algs[integ_alg].alg;
 128   ASSERT (sa->integ_icv_size <= ESP_MAX_ICV_SIZE);
 129 }
 130
 131 void
 132 ipsec_sa_set_async_op_ids (ipsec_sa_t * sa)
 133 {
 134   /* *INDENT-OFF* */
 135   if (ipsec_sa_is_set_USE_ESN (sa))
 136     {
 137 #define _(n, s, k) \
 138   if( sa->sync_op_data.crypto_enc_op_id == VNET_CRYPTO_OP_##n##_ENC ) \
 139     sa->async_op_data.crypto_async_enc_op_id = \
 140       VNET_CRYPTO_OP_##n##_TAG16_AAD12_ENC; \
 141   if( sa->sync_op_data.crypto_dec_op_id == VNET_CRYPTO_OP_##n##_DEC ) \
 142     sa->async_op_data.crypto_async_dec_op_id = \
 143       VNET_CRYPTO_OP_##n##_TAG16_AAD12_DEC;
 144     foreach_crypto_aead_alg
 145 #undef _
 146     }
 147   else
 148     {
 149 #define _(n, s, k) \
 150   if( sa->sync_op_data.crypto_enc_op_id == VNET_CRYPTO_OP_##n##_ENC ) \
 151     sa->async_op_data.crypto_async_enc_op_id = \
 152       VNET_CRYPTO_OP_##n##_TAG16_AAD8_ENC; \
 153   if( sa->sync_op_data.crypto_dec_op_id == VNET_CRYPTO_OP_##n##_DEC ) \
 154     sa->async_op_data.crypto_async_dec_op_id = \
 155       VNET_CRYPTO_OP_##n##_TAG16_AAD8_DEC;
 156     foreach_crypto_aead_alg
 157 #undef _
 158     }
 159
 160 #define _(c, h, s, k ,d) \
 161   if( sa->sync_op_data.crypto_enc_op_id == VNET_CRYPTO_OP_##c##_ENC && \
 162       sa->sync_op_data.integ_op_id == VNET_CRYPTO_OP_##h##_HMAC) \
 163     sa->async_op_data.crypto_async_enc_op_id = \
 164       VNET_CRYPTO_OP_##c##_##h##_TAG##d##_ENC; \
 165   if( sa->sync_op_data.crypto_dec_op_id == VNET_CRYPTO_OP_##c##_DEC && \
 166       sa->sync_op_data.integ_op_id == VNET_CRYPTO_OP_##h##_HMAC) \
 167     sa->async_op_data.crypto_async_dec_op_id = \
 168       VNET_CRYPTO_OP_##c##_##h##_TAG##d##_DEC;
 169   foreach_crypto_link_async_alg
 170 #undef _
 171   /* *INDENT-ON* */
 172 }
 173
 174 int
 175 ipsec_sa_update (u32 id, u16 src_port, u16 dst_port, const tunnel_t *tun,
 176                  bool is_tun)
 177 {
 178   ipsec_main_t *im = &ipsec_main;
 179   ipsec_sa_t *sa;
 180   u32 sa_index;
 181   uword *p;
 182   int rv;
 183
 184   p = hash_get (im->sa_index_by_sa_id, id);
 185   if (!p)
 186     return VNET_API_ERROR_NO_SUCH_ENTRY;
 187
 188   sa = ipsec_sa_get (p[0]);
 189   sa_index = sa - ipsec_sa_pool;
 190
 191   if (is_tun && ipsec_sa_is_set_IS_TUNNEL (sa) &&
 192       (ip_address_cmp (&tun->t_src, &sa->tunnel.t_src) != 0 ||
 193        ip_address_cmp (&tun->t_dst, &sa->tunnel.t_dst) != 0))
 194     {
 195       /* if the source IP is updated for an inbound SA under a tunnel protect,
 196        we need to update the tun_protect DB with the new src IP */
 197       if (ipsec_sa_is_set_IS_INBOUND (sa) &&
 198           ip_address_cmp (&tun->t_src, &sa->tunnel.t_src) != 0 &&
 199           !ip46_address_is_zero (&tun->t_src.ip))
 200         {
 201           if (ip46_address_is_ip4 (&sa->tunnel.t_src.ip))
 202             {
 203               ipsec4_tunnel_kv_t old_key, new_key;
 204               clib_bihash_kv_8_16_t res,
 205                 *bkey = (clib_bihash_kv_8_16_t *) &old_key;
 206
 207               ipsec4_tunnel_mk_key (&old_key, &sa->tunnel.t_src.ip.ip4,
 208                                     clib_host_to_net_u32 (sa->spi));
 209               ipsec4_tunnel_mk_key (&new_key, &tun->t_src.ip.ip4,
 210                                     clib_host_to_net_u32 (sa->spi));
 211
 212               if (!clib_bihash_search_8_16 (&im->tun4_protect_by_key, bkey,
 213                                             &res))
 214                 {
 215                   clib_bihash_add_del_8_16 (&im->tun4_protect_by_key, &res, 0);
 216                   res.key = new_key.key;
 217                   clib_bihash_add_del_8_16 (&im->tun4_protect_by_key, &res, 1);
 218                 }
 219             }
 220           else
 221             {
 222               ipsec6_tunnel_kv_t old_key = {
 223           .key = {
 224             .remote_ip =  sa->tunnel.t_src.ip.ip6,
 225             .spi = clib_host_to_net_u32 (sa->spi),
 226           },
 227         }, new_key = {
 228           .key = {
 229             .remote_ip = tun->t_src.ip.ip6,
 230             .spi = clib_host_to_net_u32 (sa->spi),
 231           }};
 232               clib_bihash_kv_24_16_t res,
 233                 *bkey = (clib_bihash_kv_24_16_t *) &old_key;
 234
 235               if (!clib_bihash_search_24_16 (&im->tun6_protect_by_key, bkey,
 236                                              &res))
 237                 {
 238                   clib_bihash_add_del_24_16 (&im->tun6_protect_by_key, &res,
 239                                              0);
 240                   clib_memcpy (&res.key, &new_key.key, 3);
 241                   clib_bihash_add_del_24_16 (&im->tun6_protect_by_key, &res,
 242                                              1);
 243                 }
 244             }
 245         }
 246       tunnel_unresolve (&sa->tunnel);
 247       tunnel_copy (tun, &sa->tunnel);
 248       if (!ipsec_sa_is_set_IS_INBOUND (sa))
 249         {
 250           dpo_reset (&sa->dpo);
 251
 252           sa->tunnel_flags = sa->tunnel.t_encap_decap_flags;
 253
 254           rv = tunnel_resolve (&sa->tunnel, FIB_NODE_TYPE_IPSEC_SA, sa_index);
 255
 256           if (rv)
 257             {
 258               hash_unset (im->sa_index_by_sa_id, sa->id);
 259               pool_put (ipsec_sa_pool, sa);
 260               return rv;
 261             }
 262           ipsec_sa_stack (sa);
 263           /* generate header templates */
 264           if (ipsec_sa_is_set_IS_TUNNEL_V6 (sa))
 265             {
 266               tunnel_build_v6_hdr (&sa->tunnel,
 267                                    (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 268                                             IP_PROTOCOL_UDP :
 269                                             IP_PROTOCOL_IPSEC_ESP),
 270                                    &sa->ip6_hdr);
 271             }
 272           else
 273             {
 274               tunnel_build_v4_hdr (&sa->tunnel,
 275                                    (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 276                                             IP_PROTOCOL_UDP :
 277                                             IP_PROTOCOL_IPSEC_ESP),
 278                                    &sa->ip4_hdr);
 279             }
 280         }
 281     }
 282
 283   if (ipsec_sa_is_set_UDP_ENCAP (sa))
 284     {
 285       if (dst_port != IPSEC_UDP_PORT_NONE &&
 286           dst_port != clib_net_to_host_u16 (sa->udp_hdr.dst_port))
 287         {
 288           if (ipsec_sa_is_set_IS_INBOUND (sa))
 289             {
 290               ipsec_unregister_udp_port (
 291                 clib_net_to_host_u16 (sa->udp_hdr.dst_port),
 292                 !ipsec_sa_is_set_IS_TUNNEL_V6 (sa));
 293               ipsec_register_udp_port (dst_port,
 294                                        !ipsec_sa_is_set_IS_TUNNEL_V6 (sa));
 295             }
 296           sa->udp_hdr.dst_port = clib_host_to_net_u16 (dst_port);
 297         }
 298       if (src_port != IPSEC_UDP_PORT_NONE &&
 299           src_port != clib_net_to_host_u16 (sa->udp_hdr.src_port))
 300         sa->udp_hdr.src_port = clib_host_to_net_u16 (src_port);
 301     }
 302   return (0);
 303 }
 304
 305 int
 306 ipsec_sa_add_and_lock (u32 id, u32 spi, ipsec_protocol_t proto,
 307                        ipsec_crypto_alg_t crypto_alg, const ipsec_key_t *ck,
 308                        ipsec_integ_alg_t integ_alg, const ipsec_key_t *ik,
 309                        ipsec_sa_flags_t flags, u32 salt, u16 src_port,
 310                        u16 dst_port, const tunnel_t *tun, u32 *sa_out_index)
 311 {
 312   vlib_main_t *vm = vlib_get_main ();
 313   ipsec_main_t *im = &ipsec_main;
 314   clib_error_t *err;
 315   ipsec_sa_t *sa;
 316   u32 sa_index;
 317   uword *p;
 318   int rv;
 319
 320   p = hash_get (im->sa_index_by_sa_id, id);
 321   if (p)
 322     return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
 323
 324   pool_get_aligned_zero (ipsec_sa_pool, sa, CLIB_CACHE_LINE_BYTES);
 325
 326   fib_node_init (&sa->node, FIB_NODE_TYPE_IPSEC_SA);
 327   fib_node_lock (&sa->node);
 328   sa_index = sa - ipsec_sa_pool;
 329
 330   vlib_validate_combined_counter (&ipsec_sa_counters, sa_index);
 331   vlib_zero_combined_counter (&ipsec_sa_counters, sa_index);
 332   vlib_validate_simple_counter (&ipsec_sa_lost_counters, sa_index);
 333   vlib_zero_simple_counter (&ipsec_sa_lost_counters, sa_index);
 334
 335   tunnel_copy (tun, &sa->tunnel);
 336   sa->id = id;
 337   sa->spi = spi;
 338   sa->stat_index = sa_index;
 339   sa->protocol = proto;
 340   sa->flags = flags;
 341   sa->salt = salt;
 342   sa->thread_index = (vlib_num_workers ()) ? ~0 : 0;
 343   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 344     {
 345       ipsec_sa_set_integ_alg (sa, integ_alg);
 346       clib_memcpy (&sa->integ_key, ik, sizeof (sa->integ_key));
 347     }
 348   ipsec_sa_set_crypto_alg (sa, crypto_alg);
 349   ipsec_sa_set_async_op_ids (sa);
 350
 351   clib_memcpy (&sa->crypto_key, ck, sizeof (sa->crypto_key));
 352
 353   sa->crypto_key_index = vnet_crypto_key_add (vm,
 354                                               im->crypto_algs[crypto_alg].alg,
 355                                               (u8 *) ck->data, ck->len);
 356   if (~0 == sa->crypto_key_index)
 357     {
 358       pool_put (ipsec_sa_pool, sa);
 359       return VNET_API_ERROR_KEY_LENGTH;
 360     }
 361
 362   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 363     {
 364       sa->integ_key_index = vnet_crypto_key_add (vm,
 365                                                  im->
 366                                                  integ_algs[integ_alg].alg,
 367                                                  (u8 *) ik->data, ik->len);
 368       if (~0 == sa->integ_key_index)
 369         {
 370           pool_put (ipsec_sa_pool, sa);
 371           return VNET_API_ERROR_KEY_LENGTH;
 372         }
 373     }
 374
 375   if (sa->async_op_data.crypto_async_enc_op_id &&
 376       !ipsec_sa_is_set_IS_AEAD (sa))
 377     {                           //AES-CBC & HMAC
 378       sa->async_op_data.linked_key_index =
 379         vnet_crypto_key_add_linked (vm, sa->crypto_key_index,
 380                                     sa->integ_key_index);
 381     }
 382
 383   if (im->async_mode)
 384     sa->crypto_op_data = sa->async_op_data.data;
 385   else
 386     {
 387       if (ipsec_sa_is_set_IS_ASYNC (sa))
 388         {
 389           vnet_crypto_request_async_mode (1);
 390           sa->crypto_op_data = sa->async_op_data.data;
 391         }
 392       else
 393         sa->crypto_op_data = sa->sync_op_data.data;
 394     }
 395
 396   err = ipsec_check_support_cb (im, sa);
 397   if (err)
 398     {
 399       clib_warning ("%s", err->what);
 400       pool_put (ipsec_sa_pool, sa);
 401       return VNET_API_ERROR_UNIMPLEMENTED;
 402     }
 403
 404   err = ipsec_call_add_del_callbacks (im, sa, sa_index, 1);
 405   if (err)
 406     {
 407       pool_put (ipsec_sa_pool, sa);
 408       return VNET_API_ERROR_SYSCALL_ERROR_1;
 409     }
 410
 411   if (ipsec_sa_is_set_IS_TUNNEL (sa) &&
 412       AF_IP6 == ip_addr_version (&tun->t_src))
 413     ipsec_sa_set_IS_TUNNEL_V6 (sa);
 414
 415   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 416     {
 417       sa->tunnel_flags = sa->tunnel.t_encap_decap_flags;
 418
 419       rv = tunnel_resolve (&sa->tunnel, FIB_NODE_TYPE_IPSEC_SA, sa_index);
 420
 421       if (rv)
 422         {
 423           pool_put (ipsec_sa_pool, sa);
 424           return rv;
 425         }
 426       ipsec_sa_stack (sa);
 427
 428       /* generate header templates */
 429       if (ipsec_sa_is_set_IS_TUNNEL_V6 (sa))
 430         {
 431           tunnel_build_v6_hdr (&sa->tunnel,
 432                                (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 433                                   IP_PROTOCOL_UDP :
 434                                   IP_PROTOCOL_IPSEC_ESP),
 435                                &sa->ip6_hdr);
 436         }
 437       else
 438         {
 439           tunnel_build_v4_hdr (&sa->tunnel,
 440                                (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 441                                   IP_PROTOCOL_UDP :
 442                                   IP_PROTOCOL_IPSEC_ESP),
 443                                &sa->ip4_hdr);
 444         }
 445     }
 446
 447   if (ipsec_sa_is_set_UDP_ENCAP (sa))
 448     {
 449       if (dst_port == IPSEC_UDP_PORT_NONE)
 450         sa->udp_hdr.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 451       else
 452         sa->udp_hdr.dst_port = clib_host_to_net_u16 (dst_port);
 453
 454       if (src_port == IPSEC_UDP_PORT_NONE)
 455         sa->udp_hdr.src_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 456       else
 457         sa->udp_hdr.src_port = clib_host_to_net_u16 (src_port);
 458
 459       if (ipsec_sa_is_set_IS_INBOUND (sa))
 460         ipsec_register_udp_port (clib_host_to_net_u16 (sa->udp_hdr.dst_port),
 461                                  !ipsec_sa_is_set_IS_TUNNEL_V6 (sa));
 462     }
 463
 464   hash_set (im->sa_index_by_sa_id, sa->id, sa_index);
 465
 466   if (sa_out_index)
 467     *sa_out_index = sa_index;
 468
 469   return (0);
 470 }
 471
 472 static void
 473 ipsec_sa_del (ipsec_sa_t * sa)
 474 {
 475   vlib_main_t *vm = vlib_get_main ();
 476   ipsec_main_t *im = &ipsec_main;
 477   u32 sa_index;
 478
 479   sa_index = sa - ipsec_sa_pool;
 480   hash_unset (im->sa_index_by_sa_id, sa->id);
 481   tunnel_unresolve (&sa->tunnel);
 482
 483   /* no recovery possible when deleting an SA */
 484   (void) ipsec_call_add_del_callbacks (im, sa, sa_index, 0);
 485
 486   if (ipsec_sa_is_set_IS_ASYNC (sa))
 487     {
 488       vnet_crypto_request_async_mode (0);
 489       if (!ipsec_sa_is_set_IS_AEAD (sa))
 490         vnet_crypto_key_del (vm, sa->async_op_data.linked_key_index);
 491     }
 492
 493   if (ipsec_sa_is_set_UDP_ENCAP (sa) && ipsec_sa_is_set_IS_INBOUND (sa))
 494     ipsec_unregister_udp_port (clib_net_to_host_u16 (sa->udp_hdr.dst_port),
 495                                !ipsec_sa_is_set_IS_TUNNEL_V6 (sa));
 496
 497   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 498     dpo_reset (&sa->dpo);
 499   vnet_crypto_key_del (vm, sa->crypto_key_index);
 500   if (sa->integ_alg != IPSEC_INTEG_ALG_NONE)
 501     vnet_crypto_key_del (vm, sa->integ_key_index);
 502   pool_put (ipsec_sa_pool, sa);
 503 }
 504
 505 void
 506 ipsec_sa_unlock (index_t sai)
 507 {
 508   ipsec_sa_t *sa;
 509
 510   if (INDEX_INVALID == sai)
 511     return;
 512
 513   sa = ipsec_sa_get (sai);
 514
 515   fib_node_unlock (&sa->node);
 516 }
 517
 518 void
 519 ipsec_sa_lock (index_t sai)
 520 {
 521   ipsec_sa_t *sa;
 522
 523   if (INDEX_INVALID == sai)
 524     return;
 525
 526   sa = ipsec_sa_get (sai);
 527
 528   fib_node_lock (&sa->node);
 529 }
 530
 531 index_t
 532 ipsec_sa_find_and_lock (u32 id)
 533 {
 534   ipsec_main_t *im = &ipsec_main;
 535   ipsec_sa_t *sa;
 536   uword *p;
 537
 538   p = hash_get (im->sa_index_by_sa_id, id);
 539
 540   if (!p)
 541     return INDEX_INVALID;
 542
 543   sa = ipsec_sa_get (p[0]);
 544
 545   fib_node_lock (&sa->node);
 546
 547   return (p[0]);
 548 }
 549
 550 int
 551 ipsec_sa_unlock_id (u32 id)
 552 {
 553   ipsec_main_t *im = &ipsec_main;
 554   uword *p;
 555
 556   p = hash_get (im->sa_index_by_sa_id, id);
 557
 558   if (!p)
 559     return VNET_API_ERROR_NO_SUCH_ENTRY;
 560
 561   ipsec_sa_unlock (p[0]);
 562
 563   return (0);
 564 }
 565
 566 void
 567 ipsec_sa_clear (index_t sai)
 568 {
 569   vlib_zero_combined_counter (&ipsec_sa_counters, sai);
 570   vlib_zero_simple_counter (&ipsec_sa_lost_counters, sai);
 571 }
 572
 573 void
 574 ipsec_sa_walk (ipsec_sa_walk_cb_t cb, void *ctx)
 575 {
 576   ipsec_sa_t *sa;
 577
 578   /* *INDENT-OFF* */
 579   pool_foreach (sa, ipsec_sa_pool)
 580     {
 581       if (WALK_CONTINUE != cb (sa, ctx))
 582         break;
 583     }
 584   /* *INDENT-ON* */
 585 }
 586
 587 /**
 588  * Function definition to get a FIB node from its index
 589  */
 590 static fib_node_t *
 591 ipsec_sa_fib_node_get (fib_node_index_t index)
 592 {
 593   ipsec_sa_t *sa;
 594
 595   sa = ipsec_sa_get (index);
 596
 597   return (&sa->node);
 598 }
 599
 600 static ipsec_sa_t *
 601 ipsec_sa_from_fib_node (fib_node_t * node)
 602 {
 603   ASSERT (FIB_NODE_TYPE_IPSEC_SA == node->fn_type);
 604   return ((ipsec_sa_t *) (((char *) node) -
 605                           STRUCT_OFFSET_OF (ipsec_sa_t, node)));
 606
 607 }
 608
 609 /**
 610  * Function definition to inform the FIB node that its last lock has gone.
 611  */
 612 static void
 613 ipsec_sa_last_lock_gone (fib_node_t * node)
 614 {
 615   /*
 616    * The ipsec SA is a root of the graph. As such
 617    * it never has children and thus is never locked.
 618    */
 619   ipsec_sa_del (ipsec_sa_from_fib_node (node));
 620 }
 621
 622 /**
 623  * Function definition to backwalk a FIB node
 624  */
 625 static fib_node_back_walk_rc_t
 626 ipsec_sa_back_walk (fib_node_t * node, fib_node_back_walk_ctx_t * ctx)
 627 {
 628   ipsec_sa_stack (ipsec_sa_from_fib_node (node));
 629
 630   return (FIB_NODE_BACK_WALK_CONTINUE);
 631 }
 632
 633 /*
 634  * Virtual function table registered by SAs
 635  * for participation in the FIB object graph.
 636  */
 637 const static fib_node_vft_t ipsec_sa_vft = {
 638   .fnv_get = ipsec_sa_fib_node_get,
 639   .fnv_last_lock = ipsec_sa_last_lock_gone,
 640   .fnv_back_walk = ipsec_sa_back_walk,
 641 };
 642
 643 /* force inclusion from application's main.c */
 644 clib_error_t *
 645 ipsec_sa_interface_init (vlib_main_t * vm)
 646 {
 647   fib_node_register_type (FIB_NODE_TYPE_IPSEC_SA, &ipsec_sa_vft);
 648
 649   return 0;
 650 }
 651
 652 VLIB_INIT_FUNCTION (ipsec_sa_interface_init);
 653
 654 /*
 655  * fd.io coding-style-patch-verification: ON
 656  *
 657  * Local Variables:
 658  * eval: (c-set-style "gnu")
 659  * End:
 660  */