src/plugins/cnat/cnat_api.c

   1 /*
   2  * Copyright (c) 2016 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 <stddef.h>
  17
  18 #include <vnet/vnet.h>
  19 #include <vnet/plugin/plugin.h>
  20 #include <cnat/cnat_translation.h>
  21 #include <cnat/cnat_session.h>
  22 #include <cnat/cnat_client.h>
  23 #include <cnat/cnat_snat.h>
  24
  25 #include <vnet/ip/ip_types_api.h>
  26
  27 #include <vpp/app/version.h>
  28
  29 #include <vlibapi/api.h>
  30 #include <vlibmemory/api.h>
  31
  32 /* define message IDs */
  33 #include <vnet/format_fns.h>
  34 #include <cnat/cnat.api_enum.h>
  35 #include <cnat/cnat.api_types.h>
  36
  37 /**
  38  * Base message ID fot the plugin
  39  */
  40 static u32 cnat_base_msg_id;
  41
  42 #define REPLY_MSG_ID_BASE cnat_base_msg_id
  43
  44 #include <vlibapi/api_helper_macros.h>
  45
  46 static void
  47 cnat_endpoint_decode (const vl_api_cnat_endpoint_t * in,
  48                       cnat_endpoint_t * out)
  49 {
  50   out->ce_port = clib_net_to_host_u16 (in->port);
  51   out->ce_sw_if_index = clib_net_to_host_u32 (in->sw_if_index);
  52   out->ce_flags = 0;
  53   if (out->ce_sw_if_index == INDEX_INVALID)
  54     ip_address_decode2 (&in->addr, &out->ce_ip);
  55   else
  56     ip_address_family_decode (in->if_af, &out->ce_ip.version);
  57 }
  58
  59 static void
  60 cnat_endpoint_tuple_decode (const vl_api_cnat_endpoint_tuple_t * in,
  61                             cnat_endpoint_tuple_t * out)
  62 {
  63   cnat_endpoint_decode (&in->src_ep, &out->src_ep);
  64   cnat_endpoint_decode (&in->dst_ep, &out->dst_ep);
  65 }
  66
  67 static void
  68 cnat_endpoint_encode (const cnat_endpoint_t * in,
  69                       vl_api_cnat_endpoint_t * out)
  70 {
  71   out->port = clib_net_to_host_u16 (in->ce_port);
  72   out->sw_if_index = clib_net_to_host_u32 (in->ce_sw_if_index);
  73   out->if_af = ip_address_family_encode (in->ce_ip.version);
  74   if (in->ce_flags & CNAT_EP_FLAG_RESOLVED)
  75     ip_address_encode2 (&in->ce_ip, &out->addr);
  76   else
  77     clib_memset ((void *) &in->ce_ip, 0, sizeof (in->ce_ip));
  78 }
  79
  80 static void
  81 vl_api_cnat_translation_update_t_handler (vl_api_cnat_translation_update_t
  82                                           * mp)
  83 {
  84   vl_api_cnat_translation_update_reply_t *rmp;
  85   cnat_endpoint_t vip;
  86   cnat_endpoint_tuple_t *paths = NULL, *path;
  87   ip_protocol_t ip_proto;
  88   u32 id = ~0;
  89   u8 flags;
  90   int rv = 0;
  91   u8 pi;
  92
  93   rv = ip_proto_decode (mp->translation.ip_proto, &ip_proto);
  94
  95   if (rv)
  96     goto done;
  97
  98   vec_validate (paths, mp->translation.n_paths - 1);
  99
 100   for (pi = 0; pi < mp->translation.n_paths; pi++)
 101     {
 102       path = &paths[pi];
 103       cnat_endpoint_tuple_decode (&mp->translation.paths[pi], path);
 104     }
 105   cnat_endpoint_decode (&mp->translation.vip, &vip);
 106
 107   flags = mp->translation.flags;
 108   if (!mp->translation.is_real_ip)
 109     flags |= CNAT_FLAG_EXCLUSIVE;
 110   id = cnat_translation_update (&vip, ip_proto, paths, flags);
 111
 112   vec_free (paths);
 113
 114 done:
 115   /* *INDENT-OFF* */
 116   REPLY_MACRO2 (VL_API_CNAT_TRANSLATION_UPDATE_REPLY,
 117   ({
 118     rmp->id = htonl (id);
 119   }));
 120   /* *INDENT-ON* */
 121 }
 122
 123 static void
 124 vl_api_cnat_translation_del_t_handler (vl_api_cnat_translation_del_t * mp)
 125 {
 126   vl_api_cnat_translation_del_reply_t *rmp;
 127   int rv;
 128
 129   rv = cnat_translation_delete (ntohl (mp->id));
 130
 131   REPLY_MACRO (VL_API_CNAT_TRANSLATION_DEL_REPLY);
 132 }
 133
 134 typedef struct cnat_dump_walk_ctx_t_
 135 {
 136   vl_api_registration_t *rp;
 137   u32 context;
 138 } cnat_dump_walk_ctx_t;
 139
 140 static walk_rc_t
 141 cnat_translation_send_details (u32 cti, void *args)
 142 {
 143   vl_api_cnat_translation_details_t *mp;
 144   cnat_dump_walk_ctx_t *ctx;
 145   cnat_ep_trk_t *trk;
 146   vl_api_cnat_endpoint_tuple_t *path;
 147   size_t msg_size;
 148   cnat_translation_t *ct;
 149   u8 n_paths;
 150
 151   ctx = args;
 152   ct = cnat_translation_get (cti);
 153   n_paths = vec_len (ct->ct_paths);
 154   msg_size = sizeof (*mp) + sizeof (mp->translation.paths[0]) * n_paths;
 155
 156   mp = vl_msg_api_alloc_zero (msg_size);
 157   mp->_vl_msg_id = ntohs (VL_API_CNAT_TRANSLATION_DETAILS + cnat_base_msg_id);
 158
 159   /* fill in the message */
 160   mp->context = ctx->context;
 161   mp->translation.n_paths = n_paths;
 162   mp->translation.id = htonl (cti);
 163   cnat_endpoint_encode (&ct->ct_vip, &mp->translation.vip);
 164   mp->translation.ip_proto = ip_proto_encode (ct->ct_proto);
 165
 166   path = mp->translation.paths;
 167   vec_foreach (trk, ct->ct_paths)
 168   {
 169     cnat_endpoint_encode (&trk->ct_ep[VLIB_TX], &path->dst_ep);
 170     cnat_endpoint_encode (&trk->ct_ep[VLIB_RX], &path->src_ep);
 171     path++;
 172   }
 173
 174   vl_api_send_msg (ctx->rp, (u8 *) mp);
 175
 176   return (WALK_CONTINUE);
 177 }
 178
 179 static void
 180 vl_api_cnat_translation_dump_t_handler (vl_api_cnat_translation_dump_t * mp)
 181 {
 182   vl_api_registration_t *rp;
 183
 184   rp = vl_api_client_index_to_registration (mp->client_index);
 185   if (rp == 0)
 186     return;
 187
 188   cnat_dump_walk_ctx_t ctx = {
 189     .rp = rp,
 190     .context = mp->context,
 191   };
 192
 193   cnat_translation_walk (cnat_translation_send_details, &ctx);
 194 }
 195
 196 static void
 197 ip_address2_from_46 (const ip46_address_t * nh,
 198                      ip_address_family_t af, ip_address_t * ip)
 199 {
 200   ip_addr_46 (ip) = *nh;
 201   ip_addr_version (ip) = af;
 202 }
 203
 204 static walk_rc_t
 205 cnat_session_send_details (const cnat_session_t * session, void *args)
 206 {
 207   vl_api_cnat_session_details_t *mp;
 208   cnat_dump_walk_ctx_t *ctx;
 209   cnat_endpoint_t ep;
 210
 211   ctx = args;
 212
 213   mp = vl_msg_api_alloc_zero (sizeof (*mp));
 214   mp->_vl_msg_id = ntohs (VL_API_CNAT_SESSION_DETAILS + cnat_base_msg_id);
 215
 216   /* fill in the message */
 217   mp->context = ctx->context;
 218
 219   ip_address2_from_46 (&session->value.cs_ip[VLIB_TX], session->key.cs_af,
 220                        &ep.ce_ip);
 221   ep.ce_port = clib_host_to_net_u16 (session->value.cs_port[VLIB_TX]);
 222   cnat_endpoint_encode (&ep, &mp->session.new);
 223
 224   ip_address2_from_46 (&session->key.cs_ip[VLIB_RX], session->key.cs_af,
 225                        &ep.ce_ip);
 226   ep.ce_port = clib_host_to_net_u16 (session->key.cs_port[VLIB_RX]);
 227   cnat_endpoint_encode (&ep, &mp->session.src);
 228
 229   ip_address2_from_46 (&session->key.cs_ip[VLIB_TX], session->key.cs_af,
 230                        &ep.ce_ip);
 231   ep.ce_port = clib_host_to_net_u16 (session->key.cs_port[VLIB_TX]);
 232   cnat_endpoint_encode (&ep, &mp->session.dst);
 233
 234   mp->session.ip_proto = ip_proto_encode (session->key.cs_proto);
 235
 236   vl_api_send_msg (ctx->rp, (u8 *) mp);
 237
 238   return (WALK_CONTINUE);
 239 }
 240
 241 static void
 242 vl_api_cnat_session_dump_t_handler (vl_api_cnat_session_dump_t * mp)
 243 {
 244   vl_api_registration_t *rp;
 245
 246   rp = vl_api_client_index_to_registration (mp->client_index);
 247   if (rp == 0)
 248     return;
 249
 250   cnat_dump_walk_ctx_t ctx = {
 251     .rp = rp,
 252     .context = mp->context,
 253   };
 254
 255   cnat_session_walk (cnat_session_send_details, &ctx);
 256 }
 257
 258 static void
 259 vl_api_cnat_session_purge_t_handler (vl_api_cnat_session_purge_t * mp)
 260 {
 261   vl_api_cnat_session_purge_reply_t *rmp;
 262   int rv;
 263
 264   cnat_client_throttle_pool_process ();
 265   rv = cnat_session_purge ();
 266   rv |= cnat_translation_purge ();
 267
 268   REPLY_MACRO (VL_API_CNAT_SESSION_PURGE_REPLY);
 269 }
 270
 271 static void
 272 vl_api_cnat_get_snat_addresses_t_handler (vl_api_cnat_get_snat_addresses_t
 273                                           * mp)
 274 {
 275   vl_api_cnat_get_snat_addresses_reply_t *rmp;
 276   int rv = 0;
 277
 278   /* *INDENT-OFF* */
 279   REPLY_MACRO2 (VL_API_CNAT_GET_SNAT_ADDRESSES_REPLY,
 280   ({
 281     ip6_address_encode (&ip_addr_v6(&cnat_main.snat_ip6.ce_ip), rmp->snat_ip6);
 282     ip4_address_encode (&ip_addr_v4(&cnat_main.snat_ip4.ce_ip), rmp->snat_ip4);
 283     rmp->sw_if_index = clib_host_to_net_u32 (cnat_main.snat_ip6.ce_sw_if_index);
 284   }));
 285   /* *INDENT-ON* */
 286 }
 287
 288 static void
 289 vl_api_cnat_set_snat_addresses_t_handler (vl_api_cnat_set_snat_addresses_t
 290                                           * mp)
 291 {
 292   vl_api_cnat_set_snat_addresses_reply_t *rmp;
 293   u32 sw_if_index = clib_net_to_host_u32 (mp->sw_if_index);
 294   ip4_address_t ip4;
 295   ip6_address_t ip6;
 296   int rv = 0;
 297
 298   ip4_address_decode (mp->snat_ip4, &ip4);
 299   ip6_address_decode (mp->snat_ip6, &ip6);
 300
 301   cnat_set_snat (&ip4, &ip6, sw_if_index);
 302
 303   REPLY_MACRO (VL_API_CNAT_SET_SNAT_ADDRESSES_REPLY);
 304 }
 305
 306 static void
 307   vl_api_cnat_add_del_snat_prefix_t_handler
 308   (vl_api_cnat_add_del_snat_prefix_t * mp)
 309 {
 310   vl_api_cnat_add_del_snat_prefix_reply_t *rmp;
 311   ip_prefix_t pfx;
 312   int rv;
 313
 314   ip_prefix_decode2 (&mp->prefix, &pfx);
 315   if (mp->is_add)
 316     rv = cnat_add_snat_prefix (&pfx);
 317   else
 318     rv = cnat_del_snat_prefix (&pfx);
 319
 320   REPLY_MACRO (VL_API_CNAT_ADD_DEL_SNAT_PREFIX_REPLY);
 321 }
 322
 323 #include <cnat/cnat.api.c>
 324
 325 static clib_error_t *
 326 cnat_api_init (vlib_main_t * vm)
 327 {
 328   /* Ask for a correctly-sized block of API message decode slots */
 329   cnat_base_msg_id = setup_message_id_table ();
 330
 331   return 0;
 332 }
 333
 334 VLIB_INIT_FUNCTION (cnat_api_init);
 335
 336 /* *INDENT-OFF* */
 337 VLIB_PLUGIN_REGISTER () = {
 338     .version = VPP_BUILD_VER,
 339     .description = "CNat Translate",
 340 };
 341 /* *INDENT-ON* */
 342
 343 /*
 344  * fd.io coding-style-patch-verification: ON
 345  *
 346  * Local Variables:
 347  * eval: (c-set-style "gnu")
 348  * End:
 349  */