X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fipsec%2Fipsec_api.c;h=11bfa41b4f14c5fa8cd8ee420c75a31af1d4781f;hb=5b8911020ee5512d76c8daccaa199878ed7cbc01;hp=6784f0b08f9aee2d8c1d866df711eb4c89bd297c;hpb=a548d134ae53c52de17fb02c8c925153cbd0fdf5;p=vpp.git diff --git a/src/vnet/ipsec/ipsec_api.c b/src/vnet/ipsec/ipsec_api.c index 6784f0b08f9..11bfa41b4f1 100644 --- a/src/vnet/ipsec/ipsec_api.c +++ b/src/vnet/ipsec/ipsec_api.c @@ -24,56 +24,25 @@ #include #include #include +#include +#include #include #include - -#include - -#if WITH_LIBSSL > 0 +#include #include #include -#endif /* IPSEC */ - -#define vl_typedefs /* define message structures */ -#include -#undef vl_typedefs - -#define vl_endianfun /* define message structures */ -#include -#undef vl_endianfun +#include -/* instantiate all the print functions we know about */ -#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) -#define vl_printfun -#include -#undef vl_printfun +#include +#include +#include +#define REPLY_MSG_ID_BASE ipsec_main.msg_id_base #include -#define foreach_vpe_api_msg \ -_(IPSEC_SPD_ADD_DEL, ipsec_spd_add_del) \ -_(IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd) \ -_(IPSEC_SPD_ENTRY_ADD_DEL, ipsec_spd_entry_add_del) \ -_(IPSEC_SAD_ENTRY_ADD_DEL, ipsec_sad_entry_add_del) \ -_(IPSEC_SA_DUMP, ipsec_sa_dump) \ -_(IPSEC_SPDS_DUMP, ipsec_spds_dump) \ -_(IPSEC_SPD_DUMP, ipsec_spd_dump) \ -_(IPSEC_SPD_INTERFACE_DUMP, ipsec_spd_interface_dump) \ -_(IPSEC_TUNNEL_IF_ADD_DEL, ipsec_tunnel_if_add_del) \ -_(IPSEC_TUNNEL_IF_SET_SA, ipsec_tunnel_if_set_sa) \ -_(IPSEC_SELECT_BACKEND, ipsec_select_backend) \ -_(IPSEC_BACKEND_DUMP, ipsec_backend_dump) \ -_(IPSEC_TUNNEL_PROTECT_UPDATE, ipsec_tunnel_protect_update) \ -_(IPSEC_TUNNEL_PROTECT_DEL, ipsec_tunnel_protect_del) \ -_(IPSEC_TUNNEL_PROTECT_DUMP, ipsec_tunnel_protect_dump) - static void vl_api_ipsec_spd_add_del_t_handler (vl_api_ipsec_spd_add_del_t * mp) { -#if WITH_LIBSSL == 0 - clib_warning ("unimplemented"); -#else - vlib_main_t *vm __attribute__ ((unused)) = vlib_get_main (); vl_api_ipsec_spd_add_del_reply_t *rmp; int rv; @@ -81,7 +50,6 @@ vl_api_ipsec_spd_add_del_t_handler (vl_api_ipsec_spd_add_del_t * mp) rv = ipsec_add_del_spd (vm, ntohl (mp->spd_id), mp->is_add); REPLY_MACRO (VL_API_IPSEC_SPD_ADD_DEL_REPLY); -#endif } static void vl_api_ipsec_interface_add_del_spd_t_handler @@ -98,11 +66,7 @@ static void vl_api_ipsec_interface_add_del_spd_t_handler VALIDATE_SW_IF_INDEX (mp); -#if WITH_LIBSSL > 0 rv = ipsec_set_interface_spd (vm, sw_if_index, spd_id, mp->is_add); -#else - rv = VNET_API_ERROR_UNIMPLEMENTED; -#endif BAD_SW_IF_INDEX_LABEL; @@ -115,22 +79,20 @@ static void vl_api_ipsec_tunnel_protect_update_t_handler vlib_main_t *vm __attribute__ ((unused)) = vlib_get_main (); vl_api_ipsec_tunnel_protect_update_reply_t *rmp; u32 sw_if_index, ii, *sa_ins = NULL; + ip_address_t nh; int rv; sw_if_index = ntohl (mp->tunnel.sw_if_index); VALIDATE_SW_IF_INDEX (&(mp->tunnel)); -#if WITH_LIBSSL > 0 - for (ii = 0; ii < mp->tunnel.n_sa_in; ii++) vec_add1 (sa_ins, ntohl (mp->tunnel.sa_in[ii])); - rv = ipsec_tun_protect_update (sw_if_index, + ip_address_decode2 (&mp->tunnel.nh, &nh); + + rv = ipsec_tun_protect_update (sw_if_index, &nh, ntohl (mp->tunnel.sa_out), sa_ins); -#else - rv = VNET_API_ERROR_UNIMPLEMENTED; -#endif BAD_SW_IF_INDEX_LABEL; @@ -142,18 +104,16 @@ static void vl_api_ipsec_tunnel_protect_del_t_handler { vlib_main_t *vm __attribute__ ((unused)) = vlib_get_main (); vl_api_ipsec_tunnel_protect_del_reply_t *rmp; - int rv; + ip_address_t nh; u32 sw_if_index; + int rv; sw_if_index = ntohl (mp->sw_if_index); VALIDATE_SW_IF_INDEX (mp); -#if WITH_LIBSSL > 0 - rv = ipsec_tun_protect_del (sw_if_index); -#else - rv = VNET_API_ERROR_UNIMPLEMENTED; -#endif + ip_address_decode2 (&mp->nh, &nh); + rv = ipsec_tun_protect_del (sw_if_index, &nh); BAD_SW_IF_INDEX_LABEL; @@ -172,24 +132,27 @@ send_ipsec_tunnel_protect_details (index_t itpi, void *arg) ipsec_dump_walk_ctx_t *ctx = arg; vl_api_ipsec_tunnel_protect_details_t *mp; ipsec_tun_protect_t *itp; - u32 sai, ii = 0; + u32 ii = 0; + ipsec_sa_t *sa; itp = ipsec_tun_protect_get (itpi); - mp = vl_msg_api_alloc (sizeof (*mp) + (sizeof (u32) * itp->itp_n_sa_in)); clib_memset (mp, 0, sizeof (*mp)); - mp->_vl_msg_id = ntohs (VL_API_IPSEC_TUNNEL_PROTECT_DETAILS); + mp->_vl_msg_id = + ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_TUNNEL_PROTECT_DETAILS); mp->context = ctx->context; mp->tun.sw_if_index = htonl (itp->itp_sw_if_index); + ip_address_encode2 (itp->itp_key, &mp->tun.nh); - mp->tun.sa_out = htonl (itp->itp_out_sa); + sa = ipsec_sa_get (itp->itp_out_sa); + mp->tun.sa_out = htonl (sa->id); mp->tun.n_sa_in = itp->itp_n_sa_in; /* *INDENT-OFF* */ - FOR_EACH_IPSEC_PROTECT_INPUT_SAI(itp, sai, + FOR_EACH_IPSEC_PROTECT_INPUT_SA(itp, sa, ({ - mp->tun.sa_in[ii++] = htonl (sai); + mp->tun.sa_in[ii++] = htonl (sa->id); })); /* *INDENT-ON* */ @@ -205,7 +168,6 @@ vl_api_ipsec_tunnel_protect_dump_t_handler (vl_api_ipsec_tunnel_protect_dump_t vl_api_registration_t *reg; u32 sw_if_index; -#if WITH_LIBSSL > 0 reg = vl_api_client_index_to_registration (mp->client_index); if (!reg) return; @@ -223,16 +185,9 @@ vl_api_ipsec_tunnel_protect_dump_t_handler (vl_api_ipsec_tunnel_protect_dump_t } else { - index_t itpi; - - itpi = ipsec_tun_protect_find (sw_if_index); - - if (INDEX_INVALID != itpi) - send_ipsec_tunnel_protect_details (itpi, &ctx); + ipsec_tun_protect_walk_itf (sw_if_index, + send_ipsec_tunnel_protect_details, &ctx); } -#else - clib_warning ("unimplemented"); -#endif } static int @@ -263,7 +218,6 @@ static void vl_api_ipsec_spd_entry_add_del_t_handler stat_index = ~0; -#if WITH_LIBSSL > 0 ipsec_policy_t p; clib_memset (&p, 0, sizeof (p)); @@ -307,11 +261,6 @@ static void vl_api_ipsec_spd_entry_add_del_t_handler if (rv) goto out; -#else - rv = VNET_API_ERROR_UNIMPLEMENTED; - goto out; -#endif - out: /* *INDENT-OFF* */ REPLY_MACRO2 (VL_API_IPSEC_SPD_ENTRY_ADD_DEL_REPLY, @@ -321,161 +270,76 @@ out: /* *INDENT-ON* */ } -static int -ipsec_proto_decode (vl_api_ipsec_proto_t in, ipsec_protocol_t * out) -{ - in = clib_net_to_host_u32 (in); - - switch (in) - { - case IPSEC_API_PROTO_ESP: - *out = IPSEC_PROTOCOL_ESP; - return (0); - case IPSEC_API_PROTO_AH: - *out = IPSEC_PROTOCOL_AH; - return (0); - } - return (VNET_API_ERROR_INVALID_PROTOCOL); -} - -static vl_api_ipsec_proto_t -ipsec_proto_encode (ipsec_protocol_t p) -{ - switch (p) - { - case IPSEC_PROTOCOL_ESP: - return clib_host_to_net_u32 (IPSEC_API_PROTO_ESP); - case IPSEC_PROTOCOL_AH: - return clib_host_to_net_u32 (IPSEC_API_PROTO_AH); - } - return (VNET_API_ERROR_UNIMPLEMENTED); -} - -static int -ipsec_crypto_algo_decode (vl_api_ipsec_crypto_alg_t in, - ipsec_crypto_alg_t * out) +static void vl_api_ipsec_sad_entry_add_del_t_handler + (vl_api_ipsec_sad_entry_add_del_t * mp) { - in = clib_net_to_host_u32 (in); + vl_api_ipsec_sad_entry_add_del_reply_t *rmp; + ipsec_key_t crypto_key, integ_key; + ipsec_crypto_alg_t crypto_alg; + ipsec_integ_alg_t integ_alg; + ipsec_protocol_t proto; + ipsec_sa_flags_t flags; + u32 id, spi, sa_index = ~0; + tunnel_t tun = { + .t_flags = TUNNEL_FLAG_NONE, + .t_encap_decap_flags = TUNNEL_ENCAP_DECAP_FLAG_NONE, + .t_dscp = 0, + .t_mode = TUNNEL_MODE_P2P, + .t_table_id = 0, + .t_hop_limit = 255, + }; + int rv; - switch (in) + id = ntohl (mp->entry.sad_id); + if (!mp->is_add) { -#define _(v,f,s) case IPSEC_API_CRYPTO_ALG_##f: \ - *out = IPSEC_CRYPTO_ALG_##f; \ - return (0); - foreach_ipsec_crypto_alg -#undef _ + rv = ipsec_sa_unlock_id (id); + goto out; } - return (VNET_API_ERROR_INVALID_ALGORITHM); -} + spi = ntohl (mp->entry.spi); -static vl_api_ipsec_crypto_alg_t -ipsec_crypto_algo_encode (ipsec_crypto_alg_t c) -{ - switch (c) - { -#define _(v,f,s) case IPSEC_CRYPTO_ALG_##f: \ - return clib_host_to_net_u32(IPSEC_API_CRYPTO_ALG_##f); - foreach_ipsec_crypto_alg -#undef _ - case IPSEC_CRYPTO_N_ALG: - break; - } - ASSERT (0); - return (VNET_API_ERROR_UNIMPLEMENTED); -} + rv = ipsec_proto_decode (mp->entry.protocol, &proto); -static int -ipsec_integ_algo_decode (vl_api_ipsec_integ_alg_t in, ipsec_integ_alg_t * out) -{ - in = clib_net_to_host_u32 (in); + if (rv) + goto out; - switch (in) - { -#define _(v,f,s) case IPSEC_API_INTEG_ALG_##f: \ - *out = IPSEC_INTEG_ALG_##f; \ - return (0); - foreach_ipsec_integ_alg -#undef _ - } - return (VNET_API_ERROR_INVALID_ALGORITHM); -} + rv = ipsec_crypto_algo_decode (mp->entry.crypto_algorithm, &crypto_alg); -static vl_api_ipsec_integ_alg_t -ipsec_integ_algo_encode (ipsec_integ_alg_t i) -{ - switch (i) - { -#define _(v,f,s) case IPSEC_INTEG_ALG_##f: \ - return (clib_host_to_net_u32(IPSEC_API_INTEG_ALG_##f)); - foreach_ipsec_integ_alg -#undef _ - case IPSEC_INTEG_N_ALG: - break; - } - ASSERT (0); - return (VNET_API_ERROR_UNIMPLEMENTED); -} + if (rv) + goto out; -static void -ipsec_key_decode (const vl_api_key_t * key, ipsec_key_t * out) -{ - ipsec_mk_key (out, key->data, key->length); -} + rv = ipsec_integ_algo_decode (mp->entry.integrity_algorithm, &integ_alg); -static void -ipsec_key_encode (const ipsec_key_t * in, vl_api_key_t * out) -{ - out->length = in->len; - clib_memcpy (out->data, in->data, out->length); -} + if (rv) + goto out; -static ipsec_sa_flags_t -ipsec_sa_flags_decode (vl_api_ipsec_sad_flags_t in) -{ - ipsec_sa_flags_t flags = IPSEC_SA_FLAG_NONE; - in = clib_net_to_host_u32 (in); + ipsec_key_decode (&mp->entry.crypto_key, &crypto_key); + ipsec_key_decode (&mp->entry.integrity_key, &integ_key); - if (in & IPSEC_API_SAD_FLAG_USE_ESN) - flags |= IPSEC_SA_FLAG_USE_ESN; - if (in & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY) - flags |= IPSEC_SA_FLAG_USE_ANTI_REPLAY; - if (in & IPSEC_API_SAD_FLAG_IS_TUNNEL) - flags |= IPSEC_SA_FLAG_IS_TUNNEL; - if (in & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6) - flags |= IPSEC_SA_FLAG_IS_TUNNEL_V6; - if (in & IPSEC_API_SAD_FLAG_UDP_ENCAP) - flags |= IPSEC_SA_FLAG_UDP_ENCAP; - - return (flags); -} + flags = ipsec_sa_flags_decode (mp->entry.flags); -static vl_api_ipsec_sad_flags_t -ipsec_sad_flags_encode (const ipsec_sa_t * sa) -{ - vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE; + ip_address_decode2 (&mp->entry.tunnel_src, &tun.t_src); + ip_address_decode2 (&mp->entry.tunnel_dst, &tun.t_dst); - if (ipsec_sa_is_set_USE_ESN (sa)) - flags |= IPSEC_API_SAD_FLAG_USE_ESN; - if (ipsec_sa_is_set_USE_ANTI_REPLAY (sa)) - flags |= IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY; - if (ipsec_sa_is_set_IS_TUNNEL (sa)) - flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL; - if (ipsec_sa_is_set_IS_TUNNEL_V6 (sa)) - flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6; - if (ipsec_sa_is_set_UDP_ENCAP (sa)) - flags |= IPSEC_API_SAD_FLAG_UDP_ENCAP; + rv = ipsec_sa_add_and_lock (id, spi, proto, crypto_alg, &crypto_key, + integ_alg, &integ_key, flags, mp->entry.salt, + htons (mp->entry.udp_src_port), + htons (mp->entry.udp_dst_port), &tun, &sa_index); - return clib_host_to_net_u32 (flags); +out: + /* *INDENT-OFF* */ + REPLY_MACRO2 (VL_API_IPSEC_SAD_ENTRY_ADD_DEL_REPLY, + { + rmp->stat_index = htonl (sa_index); + }); + /* *INDENT-ON* */ } -static void vl_api_ipsec_sad_entry_add_del_t_handler - (vl_api_ipsec_sad_entry_add_del_t * mp) +static void vl_api_ipsec_sad_entry_add_del_v2_t_handler + (vl_api_ipsec_sad_entry_add_del_v2_t * mp) { vlib_main_t *vm __attribute__ ((unused)) = vlib_get_main (); - vl_api_ipsec_sad_entry_add_del_reply_t *rmp; - ip46_address_t tun_src = { }, tun_dst = - { - }; + vl_api_ipsec_sad_entry_add_del_v2_reply_t *rmp; ipsec_key_t crypto_key, integ_key; ipsec_crypto_alg_t crypto_alg; ipsec_integ_alg_t integ_alg; @@ -483,10 +347,22 @@ static void vl_api_ipsec_sad_entry_add_del_t_handler ipsec_sa_flags_t flags; u32 id, spi, sa_index = ~0; int rv; - -#if WITH_LIBSSL > 0 + tunnel_t tun = { + .t_flags = TUNNEL_FLAG_NONE, + .t_encap_decap_flags = TUNNEL_ENCAP_DECAP_FLAG_NONE, + .t_dscp = 0, + .t_mode = TUNNEL_MODE_P2P, + .t_table_id = htonl (mp->entry.tx_table_id), + .t_hop_limit = 255, + }; id = ntohl (mp->entry.sad_id); + if (!mp->is_add) + { + rv = ipsec_sa_unlock_id (id); + goto out; + } + spi = ntohl (mp->entry.spi); rv = ipsec_proto_decode (mp->entry.protocol, &proto); @@ -501,6 +377,12 @@ static void vl_api_ipsec_sad_entry_add_del_t_handler rv = ipsec_integ_algo_decode (mp->entry.integrity_algorithm, &integ_alg); + if (rv) + goto out; + + rv = tunnel_encap_decap_flags_decode (mp->entry.tunnel_flags, + &tun.t_encap_decap_flags); + if (rv) goto out; @@ -508,32 +390,122 @@ static void vl_api_ipsec_sad_entry_add_del_t_handler ipsec_key_decode (&mp->entry.integrity_key, &integ_key); flags = ipsec_sa_flags_decode (mp->entry.flags); + tun.t_dscp = ip_dscp_decode (mp->entry.dscp); - ip_address_decode (&mp->entry.tunnel_src, &tun_src); - ip_address_decode (&mp->entry.tunnel_dst, &tun_dst); - - if (mp->is_add) - rv = ipsec_sa_add_and_lock (id, spi, proto, - crypto_alg, &crypto_key, - integ_alg, &integ_key, flags, - 0, mp->entry.salt, &tun_src, &tun_dst, - &sa_index); - else - rv = ipsec_sa_unlock_id (id); + ip_address_decode2 (&mp->entry.tunnel_src, &tun.t_src); + ip_address_decode2 (&mp->entry.tunnel_dst, &tun.t_dst); -#else - rv = VNET_API_ERROR_UNIMPLEMENTED; -#endif + rv = ipsec_sa_add_and_lock ( + id, spi, proto, crypto_alg, &crypto_key, integ_alg, &integ_key, flags, + mp->entry.salt, htons (mp->entry.udp_src_port), + htons (mp->entry.udp_dst_port), &tun, &sa_index); out: /* *INDENT-OFF* */ - REPLY_MACRO2 (VL_API_IPSEC_SAD_ENTRY_ADD_DEL_REPLY, + REPLY_MACRO2 (VL_API_IPSEC_SAD_ENTRY_ADD_DEL_V2_REPLY, { rmp->stat_index = htonl (sa_index); }); /* *INDENT-ON* */ } +static int +ipsec_sad_entry_add_v3 (const vl_api_ipsec_sad_entry_v3_t *entry, + u32 *sa_index) +{ + ipsec_key_t crypto_key, integ_key; + ipsec_crypto_alg_t crypto_alg; + ipsec_integ_alg_t integ_alg; + ipsec_protocol_t proto; + ipsec_sa_flags_t flags; + u32 id, spi; + tunnel_t tun; + int rv; + + id = ntohl (entry->sad_id); + spi = ntohl (entry->spi); + + rv = ipsec_proto_decode (entry->protocol, &proto); + + if (rv) + return (rv); + + rv = ipsec_crypto_algo_decode (entry->crypto_algorithm, &crypto_alg); + + if (rv) + return (rv); + + rv = ipsec_integ_algo_decode (entry->integrity_algorithm, &integ_alg); + + if (rv) + return (rv); + + flags = ipsec_sa_flags_decode (entry->flags); + + if (flags & IPSEC_SA_FLAG_IS_TUNNEL) + { + rv = tunnel_decode (&entry->tunnel, &tun); + + if (rv) + return (rv); + } + + ipsec_key_decode (&entry->crypto_key, &crypto_key); + ipsec_key_decode (&entry->integrity_key, &integ_key); + + return ipsec_sa_add_and_lock (id, spi, proto, crypto_alg, &crypto_key, + integ_alg, &integ_key, flags, entry->salt, + htons (entry->udp_src_port), + htons (entry->udp_dst_port), &tun, sa_index); +} + +static void +vl_api_ipsec_sad_entry_add_del_v3_t_handler ( + vl_api_ipsec_sad_entry_add_del_v3_t *mp) +{ + vl_api_ipsec_sad_entry_add_del_v3_reply_t *rmp; + u32 id, sa_index = ~0; + int rv; + + id = ntohl (mp->entry.sad_id); + + if (!mp->is_add) + { + rv = ipsec_sa_unlock_id (id); + } + else + { + rv = ipsec_sad_entry_add_v3 (&mp->entry, &sa_index); + } + + REPLY_MACRO2 (VL_API_IPSEC_SAD_ENTRY_ADD_DEL_V3_REPLY, + { rmp->stat_index = htonl (sa_index); }); +} + +static void +vl_api_ipsec_sad_entry_del_t_handler (vl_api_ipsec_sad_entry_del_t *mp) +{ + vl_api_ipsec_sad_entry_del_reply_t *rmp; + int rv; + + rv = ipsec_sa_unlock_id (ntohl (mp->id)); + + REPLY_MACRO (VL_API_IPSEC_SAD_ENTRY_DEL_REPLY); +} + +static void +vl_api_ipsec_sad_entry_add_t_handler (vl_api_ipsec_sad_entry_add_t *mp) +{ + vl_api_ipsec_sad_entry_add_reply_t *rmp; + u32 sa_index = ~0; + int rv; + + rv = ipsec_sad_entry_add_v3 (&mp->entry, &sa_index); + + REPLY_MACRO2 (VL_API_IPSEC_SAD_ENTRY_ADD_REPLY, + { rmp->stat_index = htonl (sa_index); }); +} + static void send_ipsec_spds_details (ipsec_spd_t * spd, vl_api_registration_t * reg, u32 context) @@ -543,7 +515,7 @@ send_ipsec_spds_details (ipsec_spd_t * spd, vl_api_registration_t * reg, mp = vl_msg_api_alloc (sizeof (*mp)); clib_memset (mp, 0, sizeof (*mp)); - mp->_vl_msg_id = ntohs (VL_API_IPSEC_SPDS_DETAILS); + mp->_vl_msg_id = ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_SPDS_DETAILS); mp->context = context; mp->spd_id = htonl (spd->id); @@ -561,19 +533,14 @@ vl_api_ipsec_spds_dump_t_handler (vl_api_ipsec_spds_dump_t * mp) vl_api_registration_t *reg; ipsec_main_t *im = &ipsec_main; ipsec_spd_t *spd; -#if WITH_LIBSSL > 0 + reg = vl_api_client_index_to_registration (mp->client_index); if (!reg) return; - /* *INDENT-OFF* */ - pool_foreach (spd, im->spds, ({ + pool_foreach (spd, im->spds) { send_ipsec_spds_details (spd, reg, mp->context); - })); - /* *INDENT-ON* */ -#else - clib_warning ("unimplemented"); -#endif + } } vl_api_ipsec_spd_action_t @@ -600,7 +567,7 @@ send_ipsec_spd_details (ipsec_policy_t * p, vl_api_registration_t * reg, mp = vl_msg_api_alloc (sizeof (*mp)); clib_memset (mp, 0, sizeof (*mp)); - mp->_vl_msg_id = ntohs (VL_API_IPSEC_SPD_DETAILS); + mp->_vl_msg_id = ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_SPD_DETAILS); mp->context = context; mp->entry.spd_id = htonl (p->id); @@ -637,7 +604,7 @@ vl_api_ipsec_spd_dump_t_handler (vl_api_ipsec_spd_dump_t * mp) ipsec_spd_t *spd; uword *p; u32 spd_index, *ii; -#if WITH_LIBSSL > 0 + reg = vl_api_client_index_to_registration (mp->client_index); if (!reg) return; @@ -649,7 +616,6 @@ vl_api_ipsec_spd_dump_t_handler (vl_api_ipsec_spd_dump_t * mp) spd_index = p[0]; spd = pool_elt_at_index (im->spds, spd_index); - /* *INDENT-OFF* */ FOR_EACH_IPSEC_SPD_POLICY_TYPE(ptype) { vec_foreach(ii, spd->policies[ptype]) { @@ -659,10 +625,6 @@ vl_api_ipsec_spd_dump_t_handler (vl_api_ipsec_spd_dump_t * mp) send_ipsec_spd_details (policy, reg, mp->context); } } - /* *INDENT-ON* */ -#else - clib_warning ("unimplemented"); -#endif } static void @@ -673,7 +635,8 @@ send_ipsec_spd_interface_details (vl_api_registration_t * reg, u32 spd_index, mp = vl_msg_api_alloc (sizeof (*mp)); clib_memset (mp, 0, sizeof (*mp)); - mp->_vl_msg_id = ntohs (VL_API_IPSEC_SPD_INTERFACE_DETAILS); + mp->_vl_msg_id = + ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_SPD_INTERFACE_DETAILS); mp->context = context; mp->spd_index = htonl (spd_index); @@ -690,7 +653,6 @@ vl_api_ipsec_spd_interface_dump_t_handler (vl_api_ipsec_spd_interface_dump_t * vl_api_registration_t *reg; u32 k, v, spd_index; -#if WITH_LIBSSL > 0 reg = vl_api_client_index_to_registration (mp->client_index); if (!reg) return; @@ -707,171 +669,78 @@ vl_api_ipsec_spd_interface_dump_t_handler (vl_api_ipsec_spd_interface_dump_t * } else { - /* *INDENT-OFF* */ hash_foreach(k, v, im->spd_index_by_sw_if_index, ({ send_ipsec_spd_interface_details(reg, v, k, mp->context); })); - /* *INDENT-ON* */ } - -#else - clib_warning ("unimplemented"); -#endif -} - -static u32 -ipsec_tun_mk_input_sa_id (u32 ti) -{ - return (0x80000000 | ti); -} - -static u32 -ipsec_tun_mk_output_sa_id (u32 ti) -{ - return (0xc0000000 | ti); } static void -vl_api_ipsec_tunnel_if_add_del_t_handler (vl_api_ipsec_tunnel_if_add_del_t * - mp) +vl_api_ipsec_itf_create_t_handler (vl_api_ipsec_itf_create_t * mp) { - vl_api_ipsec_tunnel_if_add_del_reply_t *rmp; + vl_api_ipsec_itf_create_reply_t *rmp; + tunnel_mode_t mode; u32 sw_if_index = ~0; int rv; -#if WITH_LIBSSL > 0 - ip46_address_t local_ip = ip46_address_initializer; - ip46_address_t remote_ip = ip46_address_initializer; - ipsec_key_t crypto_key, integ_key; - ipsec_sa_flags_t flags; - ip46_type_t local_ip_type, remote_ip_type; - ipip_transport_t transport; - u32 fib_index; - - local_ip_type = ip_address_decode (&mp->local_ip, &local_ip); - remote_ip_type = ip_address_decode (&mp->remote_ip, &remote_ip); - transport = (IP46_TYPE_IP6 == local_ip_type ? - IPIP_TRANSPORT_IP6 : IPIP_TRANSPORT_IP4); - - if (local_ip_type != remote_ip_type) - { - rv = VNET_API_ERROR_INVALID_VALUE; - goto done; - } + rv = tunnel_mode_decode (mp->itf.mode, &mode); - flags = IPSEC_SA_FLAG_NONE; + if (!rv) + rv = ipsec_itf_create (ntohl (mp->itf.user_instance), mode, &sw_if_index); - if (mp->udp_encap) - flags |= IPSEC_SA_FLAG_UDP_ENCAP; - if (mp->esn) - flags |= IPSEC_SA_FLAG_USE_ESN; - if (mp->anti_replay) - flags |= IPSEC_SA_FLAG_USE_ANTI_REPLAY; + /* *INDENT-OFF* */ + REPLY_MACRO2 (VL_API_IPSEC_ITF_CREATE_REPLY, + ({ + rmp->sw_if_index = htonl (sw_if_index); + })); + /* *INDENT-ON* */ +} - ipsec_mk_key (&crypto_key, mp->remote_crypto_key, - mp->remote_crypto_key_len); - ipsec_mk_key (&integ_key, mp->remote_integ_key, mp->remote_integ_key_len); - ipsec_mk_key (&crypto_key, mp->local_crypto_key, mp->local_crypto_key_len); - ipsec_mk_key (&integ_key, mp->local_integ_key, mp->local_integ_key_len); +static void +vl_api_ipsec_itf_delete_t_handler (vl_api_ipsec_itf_delete_t * mp) +{ + vl_api_ipsec_itf_delete_reply_t *rmp; + int rv; - fib_index = - fib_table_find (fib_proto_from_ip46 (local_ip_type), - ntohl (mp->tx_table_id)); + rv = ipsec_itf_delete (ntohl (mp->sw_if_index)); - if (~0 == fib_index) - { - rv = VNET_API_ERROR_NO_SUCH_FIB; - goto done; - } + REPLY_MACRO (VL_API_IPSEC_ITF_DELETE_REPLY); +} - if (mp->is_add) - { - // remote = input, local = output - /* create an ip-ip tunnel, then the two SA, then bind them */ - rv = ipip_add_tunnel (transport, - (mp->renumber ? ntohl (mp->show_instance) : ~0), - &local_ip, - &remote_ip, fib_index, 0, &sw_if_index); +static walk_rc_t +send_ipsec_itf_details (ipsec_itf_t *itf, void *arg) +{ + ipsec_dump_walk_ctx_t *ctx = arg; + vl_api_ipsec_itf_details_t *mp; - if (rv) - goto done; - - rv = ipsec_sa_add_and_lock (ipsec_tun_mk_input_sa_id (sw_if_index), - ntohl (mp->remote_spi), - IPSEC_PROTOCOL_ESP, - mp->crypto_alg, - &crypto_key, - mp->integ_alg, - &integ_key, - (flags | IPSEC_SA_FLAG_IS_INBOUND), - ntohl (mp->tx_table_id), - mp->salt, &remote_ip, &local_ip, NULL); + mp = vl_msg_api_alloc (sizeof (*mp)); + clib_memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_ITF_DETAILS); + mp->context = ctx->context; - if (rv) - goto done; - - rv = ipsec_sa_add_and_lock (ipsec_tun_mk_output_sa_id (sw_if_index), - ntohl (mp->local_spi), - IPSEC_PROTOCOL_ESP, - mp->crypto_alg, - &crypto_key, - mp->integ_alg, - &integ_key, - flags, - ntohl (mp->tx_table_id), - mp->salt, &local_ip, &remote_ip, NULL); + mp->itf.mode = tunnel_mode_encode (itf->ii_mode); + mp->itf.user_instance = htonl (itf->ii_user_instance); + mp->itf.sw_if_index = htonl (itf->ii_sw_if_index); + vl_api_send_msg (ctx->reg, (u8 *) mp); - if (rv) - goto done; + return (WALK_CONTINUE); +} - rv = ipsec_tun_protect_update_one (sw_if_index, - ipsec_tun_mk_output_sa_id - (sw_if_index), - ipsec_tun_mk_input_sa_id - (sw_if_index)); - if (rv) - goto done; - - /* the SAs are locked as a result of being used for proection, - * they cannot be removed from the API, since they cannot be refered - * to by the API. unlock them now, so that if the tunnel is rekeyed - * they-ll disapper - */ - ipsec_sa_unlock_id (ipsec_tun_mk_input_sa_id (sw_if_index)); - ipsec_sa_unlock_id (ipsec_tun_mk_output_sa_id (sw_if_index)); - } - else - { - /* *INDENT-OFF* */ - ipip_tunnel_key_t key = { - .transport = transport, - .fib_index = fib_index, - .src = local_ip, - .dst = remote_ip - }; - /* *INDENT-ON* */ +static void +vl_api_ipsec_itf_dump_t_handler (vl_api_ipsec_itf_dump_t * mp) +{ + vl_api_registration_t *reg; - ipip_tunnel_t *t = ipip_tunnel_db_find (&key); + reg = vl_api_client_index_to_registration (mp->client_index); + if (!reg) + return; - if (NULL != t) - { - rv = ipsec_tun_protect_del (t->sw_if_index); - ipip_del_tunnel (t->sw_if_index); - } - else - rv = VNET_API_ERROR_NO_SUCH_ENTRY; - } + ipsec_dump_walk_ctx_t ctx = { + .reg = reg, + .context = mp->context, + }; -#else - rv = VNET_API_ERROR_UNIMPLEMENTED; -#endif -done: - /* *INDENT-OFF* */ - REPLY_MACRO2 (VL_API_IPSEC_TUNNEL_IF_ADD_DEL_REPLY, - ({ - rmp->sw_if_index = htonl (sw_if_index); - })); - /* *INDENT-ON* */ + ipsec_itf_walk (send_ipsec_itf_details, &ctx); } typedef struct ipsec_sa_dump_match_ctx_t_ @@ -894,7 +763,7 @@ ipsec_sa_dump_match_sa (index_t itpi, void *arg) ctx->sw_if_index = itp->itp_sw_if_index; return (WALK_STOP); } - /* *INDENT-OFF* */ + FOR_EACH_IPSEC_PROTECT_INPUT_SAI (itp, sai, ({ if (sai == ctx->sai) @@ -903,7 +772,6 @@ ipsec_sa_dump_match_sa (index_t itpi, void *arg) return (WALK_STOP); } })); - /* *INDENT-OFF* */ return (WALK_CONTINUE); } @@ -913,18 +781,16 @@ send_ipsec_sa_details (ipsec_sa_t * sa, void *arg) { ipsec_dump_walk_ctx_t *ctx = arg; vl_api_ipsec_sa_details_t *mp; - ipsec_main_t *im = &ipsec_main; mp = vl_msg_api_alloc (sizeof (*mp)); clib_memset (mp, 0, sizeof (*mp)); - mp->_vl_msg_id = ntohs (VL_API_IPSEC_SA_DETAILS); + mp->_vl_msg_id = ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_SA_DETAILS); mp->context = ctx->context; mp->entry.sad_id = htonl (sa->id); mp->entry.spi = htonl (sa->spi); mp->entry.protocol = ipsec_proto_encode (sa->protocol); - mp->entry.tx_table_id = - htonl (fib_table_get_table_id (sa->tx_fib_index, FIB_PROTOCOL_IP4)); + mp->entry.tx_table_id = htonl (sa->tunnel.t_table_id); mp->entry.crypto_algorithm = ipsec_crypto_algo_encode (sa->crypto_alg); ipsec_key_encode (&sa->crypto_key, &mp->entry.crypto_key); @@ -938,8 +804,8 @@ send_ipsec_sa_details (ipsec_sa_t * sa, void *arg) if (ipsec_sa_is_set_IS_PROTECT (sa)) { ipsec_sa_dump_match_ctx_t ctx = { - .sai = sa - im->sad, - .sw_if_index = ~0, + .sai = sa - ipsec_sa_pool, + .sw_if_index = ~0, }; ipsec_tun_protect_walk (ipsec_sa_dump_match_sa, &ctx); @@ -950,22 +816,27 @@ send_ipsec_sa_details (ipsec_sa_t * sa, void *arg) if (ipsec_sa_is_set_IS_TUNNEL (sa)) { - ip_address_encode (&sa->tunnel_src_addr, IP46_TYPE_ANY, - &mp->entry.tunnel_src); - ip_address_encode (&sa->tunnel_dst_addr, IP46_TYPE_ANY, - &mp->entry.tunnel_dst); + ip_address_encode2 (&sa->tunnel.t_src, &mp->entry.tunnel_src); + ip_address_encode2 (&sa->tunnel.t_dst, &mp->entry.tunnel_dst); + } + if (ipsec_sa_is_set_UDP_ENCAP (sa)) + { + mp->entry.udp_src_port = sa->udp_hdr.src_port; + mp->entry.udp_dst_port = sa->udp_hdr.dst_port; } mp->seq_outbound = clib_host_to_net_u64 (((u64) sa->seq)); - mp->last_seq_inbound = clib_host_to_net_u64 (((u64) sa->last_seq)); + mp->last_seq_inbound = clib_host_to_net_u64 (((u64) sa->seq)); if (ipsec_sa_is_set_USE_ESN (sa)) { mp->seq_outbound |= (u64) (clib_host_to_net_u32 (sa->seq_hi)); - mp->last_seq_inbound |= (u64) (clib_host_to_net_u32 (sa->last_seq_hi)); + mp->last_seq_inbound |= (u64) (clib_host_to_net_u32 (sa->seq_hi)); } if (ipsec_sa_is_set_USE_ANTI_REPLAY (sa)) mp->replay_window = clib_host_to_net_u64 (sa->replay_window); + mp->stat_index = clib_host_to_net_u32 (sa->stat_index); + vl_api_send_msg (ctx->reg, (u8 *) mp); return (WALK_CONTINUE); @@ -976,7 +847,6 @@ vl_api_ipsec_sa_dump_t_handler (vl_api_ipsec_sa_dump_t * mp) { vl_api_registration_t *reg; -#if WITH_LIBSSL > 0 reg = vl_api_client_index_to_registration (mp->client_index); if (!reg) return; @@ -987,35 +857,173 @@ vl_api_ipsec_sa_dump_t_handler (vl_api_ipsec_sa_dump_t * mp) }; ipsec_sa_walk (send_ipsec_sa_details, &ctx); +} + +static walk_rc_t +send_ipsec_sa_v2_details (ipsec_sa_t * sa, void *arg) +{ + ipsec_dump_walk_ctx_t *ctx = arg; + vl_api_ipsec_sa_v2_details_t *mp; + + mp = vl_msg_api_alloc (sizeof (*mp)); + clib_memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_SA_V2_DETAILS); + mp->context = ctx->context; + + mp->entry.sad_id = htonl (sa->id); + mp->entry.spi = htonl (sa->spi); + mp->entry.protocol = ipsec_proto_encode (sa->protocol); + mp->entry.tx_table_id = htonl (sa->tunnel.t_table_id); + + mp->entry.crypto_algorithm = ipsec_crypto_algo_encode (sa->crypto_alg); + ipsec_key_encode (&sa->crypto_key, &mp->entry.crypto_key); + + mp->entry.integrity_algorithm = ipsec_integ_algo_encode (sa->integ_alg); + ipsec_key_encode (&sa->integ_key, &mp->entry.integrity_key); + + mp->entry.flags = ipsec_sad_flags_encode (sa); + mp->entry.salt = clib_host_to_net_u32 (sa->salt); + + if (ipsec_sa_is_set_IS_PROTECT (sa)) + { + ipsec_sa_dump_match_ctx_t ctx = { + .sai = sa - ipsec_sa_pool, + .sw_if_index = ~0, + }; + ipsec_tun_protect_walk (ipsec_sa_dump_match_sa, &ctx); + + mp->sw_if_index = htonl (ctx.sw_if_index); + } + else + mp->sw_if_index = ~0; + + if (ipsec_sa_is_set_IS_TUNNEL (sa)) + { + ip_address_encode2 (&sa->tunnel.t_src, &mp->entry.tunnel_src); + ip_address_encode2 (&sa->tunnel.t_dst, &mp->entry.tunnel_dst); + } + if (ipsec_sa_is_set_UDP_ENCAP (sa)) + { + mp->entry.udp_src_port = sa->udp_hdr.src_port; + mp->entry.udp_dst_port = sa->udp_hdr.dst_port; + } + + mp->entry.tunnel_flags = + tunnel_encap_decap_flags_encode (sa->tunnel.t_encap_decap_flags); + mp->entry.dscp = ip_dscp_encode (sa->tunnel.t_dscp); -#else - clib_warning ("unimplemented"); -#endif + mp->seq_outbound = clib_host_to_net_u64 (((u64) sa->seq)); + mp->last_seq_inbound = clib_host_to_net_u64 (((u64) sa->seq)); + if (ipsec_sa_is_set_USE_ESN (sa)) + { + mp->seq_outbound |= (u64) (clib_host_to_net_u32 (sa->seq_hi)); + mp->last_seq_inbound |= (u64) (clib_host_to_net_u32 (sa->seq_hi)); + } + if (ipsec_sa_is_set_USE_ANTI_REPLAY (sa)) + mp->replay_window = clib_host_to_net_u64 (sa->replay_window); + + mp->stat_index = clib_host_to_net_u32 (sa->stat_index); + + vl_api_send_msg (ctx->reg, (u8 *) mp); + + return (WALK_CONTINUE); } static void -vl_api_ipsec_tunnel_if_set_sa_t_handler (vl_api_ipsec_tunnel_if_set_sa_t * mp) +vl_api_ipsec_sa_v2_dump_t_handler (vl_api_ipsec_sa_v2_dump_t *mp) { - vl_api_ipsec_tunnel_if_set_sa_reply_t *rmp; - int rv; + vl_api_registration_t *reg; -#if WITH_LIBSSL > 0 - VALIDATE_SW_IF_INDEX(mp); + reg = vl_api_client_index_to_registration (mp->client_index); + if (!reg) + return; + + ipsec_dump_walk_ctx_t ctx = { + .reg = reg, + .context = mp->context, + }; + + ipsec_sa_walk (send_ipsec_sa_v2_details, &ctx); +} + +static walk_rc_t +send_ipsec_sa_v3_details (ipsec_sa_t *sa, void *arg) +{ + ipsec_dump_walk_ctx_t *ctx = arg; + vl_api_ipsec_sa_v3_details_t *mp; + + mp = vl_msg_api_alloc (sizeof (*mp)); + clib_memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_SA_V3_DETAILS); + mp->context = ctx->context; + + mp->entry.sad_id = htonl (sa->id); + mp->entry.spi = htonl (sa->spi); + mp->entry.protocol = ipsec_proto_encode (sa->protocol); + + mp->entry.crypto_algorithm = ipsec_crypto_algo_encode (sa->crypto_alg); + ipsec_key_encode (&sa->crypto_key, &mp->entry.crypto_key); + + mp->entry.integrity_algorithm = ipsec_integ_algo_encode (sa->integ_alg); + ipsec_key_encode (&sa->integ_key, &mp->entry.integrity_key); + + mp->entry.flags = ipsec_sad_flags_encode (sa); + mp->entry.salt = clib_host_to_net_u32 (sa->salt); + + if (ipsec_sa_is_set_IS_PROTECT (sa)) + { + ipsec_sa_dump_match_ctx_t ctx = { + .sai = sa - ipsec_sa_pool, + .sw_if_index = ~0, + }; + ipsec_tun_protect_walk (ipsec_sa_dump_match_sa, &ctx); - if (mp->is_outbound) - rv = ipsec_tun_protect_update_out (ntohl (mp->sw_if_index), - ntohl (mp->sa_id)); + mp->sw_if_index = htonl (ctx.sw_if_index); + } else - rv = ipsec_tun_protect_update_in (ntohl (mp->sw_if_index), - ntohl (mp->sa_id)); + mp->sw_if_index = ~0; -#else - clib_warning ("unimplemented"); -#endif + if (ipsec_sa_is_set_IS_TUNNEL (sa)) + tunnel_encode (&sa->tunnel, &mp->entry.tunnel); - BAD_SW_IF_INDEX_LABEL; + if (ipsec_sa_is_set_UDP_ENCAP (sa)) + { + mp->entry.udp_src_port = sa->udp_hdr.src_port; + mp->entry.udp_dst_port = sa->udp_hdr.dst_port; + } + + mp->seq_outbound = clib_host_to_net_u64 (((u64) sa->seq)); + mp->last_seq_inbound = clib_host_to_net_u64 (((u64) sa->seq)); + if (ipsec_sa_is_set_USE_ESN (sa)) + { + mp->seq_outbound |= (u64) (clib_host_to_net_u32 (sa->seq_hi)); + mp->last_seq_inbound |= (u64) (clib_host_to_net_u32 (sa->seq_hi)); + } + if (ipsec_sa_is_set_USE_ANTI_REPLAY (sa)) + mp->replay_window = clib_host_to_net_u64 (sa->replay_window); + + mp->stat_index = clib_host_to_net_u32 (sa->stat_index); - REPLY_MACRO (VL_API_IPSEC_TUNNEL_IF_SET_SA_REPLY); + vl_api_send_msg (ctx->reg, (u8 *) mp); + + return (WALK_CONTINUE); +} + +static void +vl_api_ipsec_sa_v3_dump_t_handler (vl_api_ipsec_sa_v3_dump_t *mp) +{ + vl_api_registration_t *reg; + + reg = vl_api_client_index_to_registration (mp->client_index); + if (!reg) + return; + + ipsec_dump_walk_ctx_t ctx = { + .reg = reg, + .context = mp->context, + }; + + ipsec_sa_walk (send_ipsec_sa_v3_details, &ctx); } static void @@ -1036,10 +1044,10 @@ vl_api_ipsec_backend_dump_t_handler (vl_api_ipsec_backend_dump_t * mp) ipsec_ah_backend_t *ab; ipsec_esp_backend_t *eb; /* *INDENT-OFF* */ - pool_foreach (ab, im->ah_backends, { + pool_foreach (ab, im->ah_backends) { vl_api_ipsec_backend_details_t *mp = vl_msg_api_alloc (sizeof (*mp)); clib_memset (mp, 0, sizeof (*mp)); - mp->_vl_msg_id = ntohs (VL_API_IPSEC_BACKEND_DETAILS); + mp->_vl_msg_id = ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_BACKEND_DETAILS); mp->context = context; snprintf ((char *)mp->name, sizeof (mp->name), "%.*s", vec_len (ab->name), ab->name); @@ -1047,11 +1055,11 @@ vl_api_ipsec_backend_dump_t_handler (vl_api_ipsec_backend_dump_t * mp) mp->index = ab - im->ah_backends; mp->active = mp->index == im->ah_current_backend ? 1 : 0; vl_api_send_msg (rp, (u8 *)mp); - }); - pool_foreach (eb, im->esp_backends, { + } + pool_foreach (eb, im->esp_backends) { vl_api_ipsec_backend_details_t *mp = vl_msg_api_alloc (sizeof (*mp)); clib_memset (mp, 0, sizeof (*mp)); - mp->_vl_msg_id = ntohs (VL_API_IPSEC_BACKEND_DETAILS); + mp->_vl_msg_id = ntohs (REPLY_MSG_ID_BASE + VL_API_IPSEC_BACKEND_DETAILS); mp->context = context; snprintf ((char *)mp->name, sizeof (mp->name), "%.*s", vec_len (eb->name), eb->name); @@ -1059,7 +1067,7 @@ vl_api_ipsec_backend_dump_t_handler (vl_api_ipsec_backend_dump_t * mp) mp->index = eb - im->esp_backends; mp->active = mp->index == im->esp_current_backend ? 1 : 0; vl_api_send_msg (rp, (u8 *)mp); - }); + } /* *INDENT-ON* */ } @@ -1070,7 +1078,7 @@ vl_api_ipsec_select_backend_t_handler (vl_api_ipsec_select_backend_t * mp) vl_api_ipsec_select_backend_reply_t *rmp; ipsec_protocol_t protocol; int rv = 0; - if (pool_elts (im->sad) > 0) + if (pool_elts (ipsec_sa_pool) > 0) { rv = VNET_API_ERROR_INSTANCE_IN_USE; goto done; @@ -1081,7 +1089,6 @@ vl_api_ipsec_select_backend_t_handler (vl_api_ipsec_select_backend_t * mp) if (rv) goto done; -#if WITH_LIBSSL > 0 switch (protocol) { case IPSEC_PROTOCOL_ESP: @@ -1094,58 +1101,29 @@ vl_api_ipsec_select_backend_t_handler (vl_api_ipsec_select_backend_t * mp) rv = VNET_API_ERROR_INVALID_PROTOCOL; break; } -#else - clib_warning ("unimplemented"); /* FIXME */ -#endif done: REPLY_MACRO (VL_API_IPSEC_SELECT_BACKEND_REPLY); } -/* - * ipsec_api_hookup - * Add vpe's API message handlers to the table. - * vlib has already mapped shared memory and - * added the client registration handlers. - * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process() - */ -#define vl_msg_name_crc_list -#include -#undef vl_msg_name_crc_list - static void -setup_message_id_table (api_main_t * am) +vl_api_ipsec_set_async_mode_t_handler (vl_api_ipsec_set_async_mode_t * mp) { -#define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); - foreach_vl_msg_name_crc_ipsec; -#undef _ + vl_api_ipsec_set_async_mode_reply_t *rmp; + int rv = 0; + + ipsec_set_async_mode (mp->async_enable); + + REPLY_MACRO (VL_API_IPSEC_SET_ASYNC_MODE_REPLY); } +#include static clib_error_t * ipsec_api_hookup (vlib_main_t * vm) { - api_main_t *am = &api_main; - -#define _(N,n) \ - vl_msg_api_set_handlers(VL_API_##N, #n, \ - vl_api_##n##_t_handler, \ - vl_noop_handler, \ - vl_api_##n##_t_endian, \ - vl_api_##n##_t_print, \ - sizeof(vl_api_##n##_t), 1); - foreach_vpe_api_msg; -#undef _ - - /* - * Adding and deleting SAs is MP safe since when they are added/delete - * no traffic is using them - */ - am->is_mp_safe[VL_API_IPSEC_SAD_ENTRY_ADD_DEL] = 1; - am->is_mp_safe[VL_API_IPSEC_SAD_ENTRY_ADD_DEL_REPLY] = 1; - /* * Set up the (msg_name, crc, message-id) table */ - setup_message_id_table (am); + REPLY_MSG_ID_BASE = setup_message_id_table (); return 0; }