src/plugins/l3xc/l3xc_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 <l3xc/l3xc.h>
  21 #include <vnet/mpls/mpls_types.h>
  22 #include <vnet/fib/fib_path_list.h>
  23 #include <vnet/fib/fib_api.h>
  24
  25 #include <vpp/app/version.h>
  26
  27 #include <vlibapi/api.h>
  28 #include <vlibmemory/api.h>
  29
  30 /* define message IDs */
  31 #include <l3xc/l3xc_msg_enum.h>
  32
  33 /* define message structures */
  34 #define vl_typedefs
  35 #include <l3xc/l3xc_all_api_h.h>
  36 #undef vl_typedefs
  37
  38 /* define generated endian-swappers */
  39 #define vl_endianfun
  40 #include <l3xc/l3xc_all_api_h.h>
  41 #undef vl_endianfun
  42
  43 /* instantiate all the print functions we know about */
  44 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  45 #define vl_printfun
  46 #include <l3xc/l3xc_all_api_h.h>
  47 #undef vl_printfun
  48
  49 /* Get the API version number */
  50 #define vl_api_version(n,v) static u32 api_version=(v);
  51 #include <l3xc/l3xc_all_api_h.h>
  52 #undef vl_api_version
  53
  54 /**
  55  * Base message ID fot the plugin
  56  */
  57 static u32 l3xc_base_msg_id;
  58
  59 #include <vlibapi/api_helper_macros.h>
  60
  61 /* List of message types that this plugin understands */
  62
  63 #define foreach_l3xc_plugin_api_msg                     \
  64   _(L3XC_PLUGIN_GET_VERSION, l3xc_plugin_get_version)   \
  65   _(L3XC_UPDATE, l3xc_update)                           \
  66   _(L3XC_DEL, l3xc_del)                                 \
  67   _(L3XC_DUMP, l3xc_dump)
  68
  69 static void
  70 vl_api_l3xc_plugin_get_version_t_handler (vl_api_l3xc_plugin_get_version_t *
  71                                           mp)
  72 {
  73   vl_api_l3xc_plugin_get_version_reply_t *rmp;
  74   vl_api_registration_t *rp;
  75
  76   rp = vl_api_client_index_to_registration (mp->client_index);
  77   if (rp == 0)
  78     return;
  79
  80   rmp = vl_msg_api_alloc (sizeof (*rmp));
  81   rmp->_vl_msg_id =
  82     ntohs (VL_API_L3XC_PLUGIN_GET_VERSION_REPLY + l3xc_base_msg_id);
  83   rmp->context = mp->context;
  84   rmp->major = htonl (L3XC_PLUGIN_VERSION_MAJOR);
  85   rmp->minor = htonl (L3XC_PLUGIN_VERSION_MINOR);
  86
  87   vl_api_send_msg (rp, (u8 *) rmp);
  88 }
  89
  90 static void
  91 vl_api_l3xc_update_t_handler (vl_api_l3xc_update_t * mp)
  92 {
  93   vl_api_l3xc_update_reply_t *rmp;
  94   fib_route_path_t *paths = NULL, *path;
  95   int rv = 0;
  96   u8 pi;
  97
  98   VALIDATE_SW_IF_INDEX (&mp->l3xc);
  99
 100   if (0 == mp->l3xc.n_paths)
 101     {
 102       rv = VNET_API_ERROR_INVALID_VALUE;
 103       goto done;
 104     }
 105
 106   vec_validate (paths, mp->l3xc.n_paths - 1);
 107
 108   for (pi = 0; pi < mp->l3xc.n_paths; pi++)
 109     {
 110       path = &paths[pi];
 111       rv = fib_path_api_parse (&mp->l3xc.paths[pi], path);
 112
 113       if (0 != rv)
 114         {
 115           goto done;
 116         }
 117     }
 118
 119   rv = l3xc_update (ntohl (mp->l3xc.sw_if_index), mp->l3xc.is_ip6, paths);
 120
 121 done:
 122   vec_free (paths);
 123
 124   BAD_SW_IF_INDEX_LABEL;
 125
 126   /* *INDENT-OFF* */
 127   REPLY_MACRO2 (VL_API_L3XC_UPDATE_REPLY + l3xc_base_msg_id,
 128   ({
 129     rmp->stats_index = 0;
 130   }))
 131   /* *INDENT-ON* */
 132 }
 133
 134 static void
 135 vl_api_l3xc_del_t_handler (vl_api_l3xc_del_t * mp)
 136 {
 137   vl_api_l3xc_del_reply_t *rmp;
 138   int rv = 0;
 139
 140   VALIDATE_SW_IF_INDEX (mp);
 141
 142   rv = l3xc_delete (ntohl (mp->sw_if_index), mp->is_ip6);
 143
 144   BAD_SW_IF_INDEX_LABEL;
 145
 146   REPLY_MACRO (VL_API_L3XC_DEL_REPLY + l3xc_base_msg_id);
 147 }
 148
 149 typedef struct l3xc_dump_walk_ctx_t_
 150 {
 151   vl_api_registration_t *rp;
 152   u32 context;
 153 } l3xc_dump_walk_ctx_t;
 154
 155 static int
 156 l3xc_send_details (u32 l3xci, void *args)
 157 {
 158   fib_route_path_encode_t *api_rpaths = NULL, *api_rpath;
 159   vl_api_l3xc_details_t *mp;
 160   l3xc_dump_walk_ctx_t *ctx;
 161   vl_api_fib_path_t *fp;
 162   size_t msg_size;
 163   l3xc_t *l3xc;
 164   u8 n_paths;
 165
 166   ctx = args;
 167   l3xc = l3xc_get (l3xci);
 168   n_paths = fib_path_list_get_n_paths (l3xc->l3xc_pl);
 169   msg_size = sizeof (*mp) + sizeof (mp->l3xc.paths[0]) * n_paths;
 170
 171   mp = vl_msg_api_alloc (msg_size);
 172   clib_memset (mp, 0, msg_size);
 173   mp->_vl_msg_id = ntohs (VL_API_L3XC_DETAILS + l3xc_base_msg_id);
 174
 175   /* fill in the message */
 176   mp->context = ctx->context;
 177   mp->l3xc.n_paths = n_paths;
 178   mp->l3xc.sw_if_index = htonl (l3xc->l3xc_sw_if_index);
 179
 180   fib_path_list_walk_w_ext (l3xc->l3xc_pl, NULL, fib_path_encode,
 181                             &api_rpaths);
 182
 183   fp = mp->l3xc.paths;
 184   vec_foreach (api_rpath, api_rpaths)
 185   {
 186     fib_api_path_encode (api_rpath, fp);
 187     fp++;
 188   }
 189
 190   vl_api_send_msg (ctx->rp, (u8 *) mp);
 191
 192   return (1);
 193 }
 194
 195 static void
 196 vl_api_l3xc_dump_t_handler (vl_api_l3xc_dump_t * mp)
 197 {
 198   vl_api_registration_t *rp;
 199   u32 sw_if_index;
 200
 201   rp = vl_api_client_index_to_registration (mp->client_index);
 202   if (rp == 0)
 203     return;
 204
 205   l3xc_dump_walk_ctx_t ctx = {
 206     .rp = rp,
 207     .context = mp->context,
 208   };
 209
 210   sw_if_index = ntohl (mp->sw_if_index);
 211
 212   if (~0 == sw_if_index)
 213     l3xc_walk (l3xc_send_details, &ctx);
 214   else
 215     {
 216       fib_protocol_t fproto;
 217       index_t l3xci;
 218
 219       FOR_EACH_FIB_IP_PROTOCOL (fproto)
 220       {
 221         l3xci = l3xc_find (sw_if_index, fproto);
 222
 223         if (INDEX_INVALID != l3xci)
 224           l3xc_send_details (l3xci, &ctx);
 225       }
 226     }
 227 }
 228
 229 #define vl_msg_name_crc_list
 230 #include <l3xc/l3xc_all_api_h.h>
 231 #undef vl_msg_name_crc_list
 232
 233 /* Set up the API message handling tables */
 234 static clib_error_t *
 235 l3xc_plugin_api_hookup (vlib_main_t * vm)
 236 {
 237 #define _(N,n)                                                  \
 238     vl_msg_api_set_handlers((VL_API_##N + l3xc_base_msg_id),     \
 239                             #n,                                 \
 240                             vl_api_##n##_t_handler,             \
 241                             vl_noop_handler,                    \
 242                             vl_api_##n##_t_endian,              \
 243                             vl_api_##n##_t_print,               \
 244                             sizeof(vl_api_##n##_t), 1);
 245   foreach_l3xc_plugin_api_msg;
 246 #undef _
 247
 248   return 0;
 249 }
 250
 251 static void
 252 setup_message_id_table (api_main_t * apim)
 253 {
 254 #define _(id,n,crc) \
 255   vl_msg_api_add_msg_name_crc (apim, #n "_" #crc, id + l3xc_base_msg_id);
 256   foreach_vl_msg_name_crc_l3xc;
 257 #undef _
 258 }
 259
 260 static clib_error_t *
 261 l3xc_api_init (vlib_main_t * vm)
 262 {
 263   clib_error_t *error = 0;
 264
 265   u8 *name = format (0, "l3xc_%08x%c", api_version, 0);
 266
 267   /* Ask for a correctly-sized block of API message decode slots */
 268   l3xc_base_msg_id = vl_msg_api_get_msg_ids ((char *) name,
 269                                              VL_MSG_FIRST_AVAILABLE);
 270
 271   error = l3xc_plugin_api_hookup (vm);
 272
 273   /* Add our API messages to the global name_crc hash table */
 274   setup_message_id_table (&api_main);
 275
 276   vec_free (name);
 277
 278   return error;
 279 }
 280
 281 VLIB_INIT_FUNCTION (l3xc_api_init);
 282
 283 /* *INDENT-OFF* */
 284 VLIB_PLUGIN_REGISTER () = {
 285     .version = VPP_BUILD_VER,
 286     .description = "L3 Cross-Connect (L3XC)",
 287 };
 288 /* *INDENT-ON* */
 289
 290 /*
 291  * fd.io coding-style-patch-verification: ON
 292  *
 293  * Local Variables:
 294  * eval: (c-set-style "gnu")
 295  * End:
 296  */