src/plugins/linux-cp/lcp_api.c

   1 /*
   2  * Copyright 2020 Rubicon Communications, LLC.
   3  *
   4  * SPDX-License-Identifier: Apache-2.0
   5  */
   6
   7 #include <sys/socket.h>
   8 #include <linux/if.h>
   9
  10 #include <vnet/vnet.h>
  11 #include <vnet/plugin/plugin.h>
  12
  13 #include <vlibapi/api.h>
  14 #include <vlibmemory/api.h>
  15 #include <vpp/app/version.h>
  16 #include <vnet/format_fns.h>
  17
  18 #include <linux-cp/lcp_interface.h>
  19 #include <linux-cp/lcp.api_enum.h>
  20 #include <linux-cp/lcp.api_types.h>
  21
  22 static u16 lcp_msg_id_base;
  23 #define REPLY_MSG_ID_BASE lcp_msg_id_base
  24 #include <vlibapi/api_helper_macros.h>
  25
  26 static lip_host_type_t
  27 api_decode_host_type (vl_api_lcp_itf_host_type_t type)
  28 {
  29   if (type == LCP_API_ITF_HOST_TUN)
  30     return LCP_ITF_HOST_TUN;
  31
  32   return LCP_ITF_HOST_TAP;
  33 }
  34
  35 static vl_api_lcp_itf_host_type_t
  36 api_encode_host_type (lip_host_type_t type)
  37 {
  38   if (type == LCP_ITF_HOST_TUN)
  39     return LCP_API_ITF_HOST_TUN;
  40
  41   return LCP_API_ITF_HOST_TAP;
  42 }
  43
  44 static int
  45 vl_api_lcp_itf_pair_add (u32 phy_sw_if_index, lip_host_type_t lip_host_type,
  46                          u8 *mp_host_if_name, size_t sizeof_host_if_name,
  47                          u8 *mp_namespace, size_t sizeof_mp_namespace,
  48                          u32 *host_sw_if_index_p)
  49 {
  50   u8 *host_if_name, *netns;
  51   int host_len, netns_len, rv;
  52
  53   host_if_name = netns = 0;
  54
  55   /* lcp_itf_pair_create expects vec of u8 */
  56   host_len = clib_strnlen ((char *) mp_host_if_name, sizeof_host_if_name - 1);
  57   vec_add (host_if_name, mp_host_if_name, host_len);
  58   vec_add1 (host_if_name, 0);
  59
  60   netns_len = clib_strnlen ((char *) mp_namespace, sizeof_mp_namespace - 1);
  61   vec_add (netns, mp_namespace, netns_len);
  62   vec_add1 (netns, 0);
  63
  64   rv = lcp_itf_pair_create (phy_sw_if_index, host_if_name, lip_host_type,
  65                             netns, host_sw_if_index_p);
  66
  67   vec_free (host_if_name);
  68   vec_free (netns);
  69
  70   return rv;
  71 }
  72
  73 static void
  74 vl_api_lcp_itf_pair_add_del_t_handler (vl_api_lcp_itf_pair_add_del_t *mp)
  75 {
  76   u32 phy_sw_if_index;
  77   vl_api_lcp_itf_pair_add_del_reply_t *rmp;
  78   lip_host_type_t lip_host_type;
  79   int rv;
  80
  81   if (!vnet_sw_if_index_is_api_valid (mp->sw_if_index))
  82     {
  83       rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
  84       goto bad_sw_if_index;
  85     }
  86
  87   phy_sw_if_index = mp->sw_if_index;
  88   lip_host_type = api_decode_host_type (mp->host_if_type);
  89   if (mp->is_add)
  90     {
  91       rv =
  92         vl_api_lcp_itf_pair_add (phy_sw_if_index, lip_host_type,
  93                                  mp->host_if_name, sizeof (mp->host_if_name),
  94                                  mp->namespace, sizeof (mp->namespace), NULL);
  95     }
  96   else
  97     {
  98       rv = lcp_itf_pair_delete (phy_sw_if_index);
  99     }
 100
 101   BAD_SW_IF_INDEX_LABEL;
 102   REPLY_MACRO (VL_API_LCP_ITF_PAIR_ADD_DEL_REPLY);
 103 }
 104
 105 static void
 106 vl_api_lcp_itf_pair_add_del_v2_t_handler (vl_api_lcp_itf_pair_add_del_v2_t *mp)
 107 {
 108   u32 phy_sw_if_index, host_sw_if_index = ~0;
 109   vl_api_lcp_itf_pair_add_del_v2_reply_t *rmp;
 110   lip_host_type_t lip_host_type;
 111   int rv;
 112
 113   if (!vnet_sw_if_index_is_api_valid (mp->sw_if_index))
 114     {
 115       rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
 116       goto bad_sw_if_index;
 117     }
 118
 119   phy_sw_if_index = mp->sw_if_index;
 120   lip_host_type = api_decode_host_type (mp->host_if_type);
 121   if (mp->is_add)
 122     {
 123       rv = vl_api_lcp_itf_pair_add (phy_sw_if_index, lip_host_type,
 124                                     mp->host_if_name,
 125                                     sizeof (mp->host_if_name), mp->namespace,
 126                                     sizeof (mp->namespace), &host_sw_if_index);
 127     }
 128   else
 129     {
 130       rv = lcp_itf_pair_delete (phy_sw_if_index);
 131     }
 132
 133   BAD_SW_IF_INDEX_LABEL;
 134   REPLY_MACRO2 (VL_API_LCP_ITF_PAIR_ADD_DEL_V2_REPLY,
 135                 { rmp->host_sw_if_index = ntohl (host_sw_if_index); });
 136 }
 137
 138 static void
 139 send_lcp_itf_pair_details (index_t lipi, vl_api_registration_t *rp,
 140                            u32 context)
 141 {
 142   vl_api_lcp_itf_pair_details_t *rmp;
 143   lcp_itf_pair_t *lcp_pair = lcp_itf_pair_get (lipi);
 144
 145   REPLY_MACRO_DETAILS4 (
 146     VL_API_LCP_ITF_PAIR_DETAILS, rp, context, ({
 147       rmp->phy_sw_if_index = lcp_pair->lip_phy_sw_if_index;
 148       rmp->host_sw_if_index = lcp_pair->lip_host_sw_if_index;
 149       rmp->vif_index = lcp_pair->lip_vif_index;
 150       rmp->host_if_type = api_encode_host_type (lcp_pair->lip_host_type);
 151
 152       memcpy_s (rmp->host_if_name, sizeof (rmp->host_if_name),
 153                 lcp_pair->lip_host_name, vec_len (lcp_pair->lip_host_name));
 154
 155       clib_strncpy ((char *) rmp->namespace, (char *) lcp_pair->lip_namespace,
 156                     vec_len (lcp_pair->lip_namespace));
 157     }));
 158 }
 159
 160 static void
 161 vl_api_lcp_itf_pair_get_t_handler (vl_api_lcp_itf_pair_get_t *mp)
 162 {
 163   vl_api_lcp_itf_pair_get_reply_t *rmp;
 164   i32 rv = 0;
 165
 166   REPLY_AND_DETAILS_MACRO (
 167     VL_API_LCP_ITF_PAIR_GET_REPLY, lcp_itf_pair_pool,
 168     ({ send_lcp_itf_pair_details (cursor, rp, mp->context); }));
 169 }
 170
 171 static void
 172 vl_api_lcp_default_ns_set_t_handler (vl_api_lcp_default_ns_set_t *mp)
 173 {
 174   vl_api_lcp_default_ns_set_reply_t *rmp;
 175   int rv;
 176
 177   mp->namespace[LCP_NS_LEN - 1] = 0;
 178   rv = lcp_set_default_ns (mp->namespace);
 179
 180   REPLY_MACRO (VL_API_LCP_DEFAULT_NS_SET_REPLY);
 181 }
 182
 183 static void
 184 vl_api_lcp_default_ns_get_t_handler (vl_api_lcp_default_ns_get_t *mp)
 185 {
 186   lcp_main_t *lcpm = &lcp_main;
 187   vl_api_lcp_default_ns_get_reply_t *rmp;
 188   vl_api_registration_t *reg;
 189   char *ns;
 190
 191   reg = vl_api_client_index_to_registration (mp->client_index);
 192   if (!reg)
 193     return;
 194
 195   rmp = vl_msg_api_alloc (sizeof (*rmp));
 196   clib_memset (rmp, 0, sizeof (*rmp));
 197   rmp->_vl_msg_id = (VL_API_LCP_DEFAULT_NS_GET_REPLY + lcpm->msg_id_base);
 198   rmp->context = mp->context;
 199
 200   ns = (char *) lcp_get_default_ns ();
 201   if (ns)
 202     clib_strncpy ((char *) rmp->namespace, ns, LCP_NS_LEN - 1);
 203
 204   vl_api_send_msg (reg, (u8 *) rmp);
 205 }
 206
 207 static void
 208 vl_api_lcp_itf_pair_replace_begin_t_handler (
 209   vl_api_lcp_itf_pair_replace_begin_t *mp)
 210 {
 211   vl_api_lcp_itf_pair_replace_begin_reply_t *rmp;
 212   int rv;
 213
 214   rv = lcp_itf_pair_replace_begin ();
 215
 216   REPLY_MACRO (VL_API_LCP_ITF_PAIR_REPLACE_BEGIN_REPLY);
 217 }
 218
 219 static void
 220 vl_api_lcp_itf_pair_replace_end_t_handler (
 221   vl_api_lcp_itf_pair_replace_end_t *mp)
 222 {
 223   vl_api_lcp_itf_pair_replace_end_reply_t *rmp;
 224   int rv = 0;
 225
 226   rv = lcp_itf_pair_replace_end ();
 227
 228   REPLY_MACRO (VL_API_LCP_ITF_PAIR_REPLACE_END_REPLY);
 229 }
 230
 231 /*
 232  * Set up the API message handling tables
 233  */
 234 #include <linux-cp/lcp.api.c>
 235
 236 static clib_error_t *
 237 lcp_plugin_api_hookup (vlib_main_t *vm)
 238 {
 239   /* Ask for a correctly-sized block of API message decode slots */
 240   lcp_msg_id_base = setup_message_id_table ();
 241
 242   return (NULL);
 243 }
 244
 245 VLIB_INIT_FUNCTION (lcp_plugin_api_hookup);
 246
 247 #include <vpp/app/version.h>
 248 VLIB_PLUGIN_REGISTER () = {
 249   .version = VPP_BUILD_VER,
 250   .description = "Linux Control Plane - Interface Mirror",
 251   .default_disabled = 1,
 252 };
 253
 254 /*
 255  * fd.io coding-style-patch-verification: ON
 256  *
 257  * Local Variables:
 258  * eval: (c-set-style "gnu")
 259  * End:
 260  */