src/plugins/stn/stn_api.c

   1 /*
   2  * Copyright (c) 2017 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 <vlibapi/api.h>
  17 #include <vlibmemory/api.h>
  18
  19 #include <plugins/stn/stn.h>
  20 #include <vnet/ip/format.h>
  21
  22 #include <vppinfra/byte_order.h>
  23
  24 /* define message IDs */
  25 #define vl_msg_id(n,h) n,
  26 typedef enum
  27 {
  28 #include <stn/stn.api.h>
  29   /* We'll want to know how many messages IDs we need... */
  30   VL_MSG_FIRST_AVAILABLE,
  31 } vl_msg_id_t;
  32 #undef vl_msg_id
  33
  34 /* define message structures */
  35 #define vl_typedefs
  36 #include <stn/stn.api.h>
  37 #undef vl_typedefs
  38
  39 /* define generated endian-swappers */
  40 #define vl_endianfun
  41 #include <stn/stn.api.h>
  42 #undef vl_endianfun
  43
  44 /* instantiate all the print functions we know about */
  45 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  46 #define vl_printfun
  47 #include <stn/stn.api.h>
  48 #undef vl_printfun
  49
  50 /* Get the API version number */
  51 #define vl_api_version(n,v) static u32 api_version=(v);
  52 #include <nat/nat_all_api_h.h>
  53 #undef vl_api_version
  54
  55 #define REPLY_MSG_ID_BASE stn_main.msg_id_base
  56 #include <vlibapi/api_helper_macros.h>
  57
  58 /* Macro to finish up custom dump fns */
  59 #define FINISH                                  \
  60     vec_add1 (s, 0);                            \
  61     vl_print (handle, (char *)s);               \
  62     vec_free (s);                               \
  63     return handle;
  64
  65 /**
  66  * @brief API message custom-dump function
  67  * @param mp vl_api_stn_add_del_rule_t * mp the api message
  68  * @param handle void * print function handle
  69  * @returns u8 * output string
  70  */
  71 static void *vl_api_stn_add_del_rule_t_print
  72   (vl_api_stn_add_del_rule_t * mp, void *handle)
  73 {
  74   u8 *s;
  75
  76   s = format (0, "SCRIPT: stn_add_del_rule ");
  77   if (mp->is_ip4)
  78     s = format (s, "address %U ", format_ip4_address, mp->ip_address);
  79   else
  80     s = format (s, "address %U ", format_ip6_address, mp->ip_address);
  81   s = format (s, "sw_if_index %d is_add %d", mp->sw_if_index, mp->is_add);
  82
  83   FINISH;
  84 }
  85
  86 static void
  87 vl_api_stn_add_del_rule_t_handler (vl_api_stn_add_del_rule_t * mp)
  88 {
  89   stn_rule_add_del_args_t args;
  90   vl_api_stn_add_del_rule_reply_t *rmp;
  91   int rv = 0;
  92
  93   if (mp->is_ip4)
  94     {
  95       ip4_address_t a;
  96       memcpy (&a, mp->ip_address, sizeof (a));
  97       ip46_address_set_ip4 (&args.address, &a);
  98     }
  99   else
 100     memcpy (&args.address.ip6, mp->ip_address, sizeof (ip6_address_t));
 101
 102   args.sw_if_index = clib_net_to_host_u32 (mp->sw_if_index);
 103   args.del = !mp->is_add;
 104
 105   rv = stn_rule_add_del (&args);
 106
 107   REPLY_MACRO (VL_API_STN_ADD_DEL_RULE_REPLY);
 108 }
 109
 110 static void
 111 send_stn_rule_details (stn_rule_t * r, svm_queue_t * q, u32 context)
 112 {
 113   vl_api_stn_rule_details_t *rmp;
 114
 115   rmp = vl_msg_api_alloc (sizeof (*rmp));
 116   memset (rmp, 0, sizeof (*rmp));
 117   rmp->_vl_msg_id =
 118     clib_host_to_net_u32 (VL_API_STN_RULE_DETAILS + stn_main.msg_id_base);
 119
 120   if (ip46_address_is_ip4 (&r->address))
 121     {
 122       clib_memcpy (rmp->ip_address, &r->address.ip4, sizeof (ip4_address_t));
 123       rmp->is_ip4 = 1;
 124     }
 125   else
 126     {
 127       clib_memcpy (rmp->ip_address, &r->address.ip6, sizeof (ip6_address_t));
 128     }
 129
 130   rmp->context = context;
 131   rmp->sw_if_index = clib_host_to_net_u32 (r->sw_if_index);
 132
 133   vl_msg_api_send_shmem (q, (u8 *) & rmp);
 134 }
 135
 136 static void
 137 vl_api_stn_rules_dump_t_handler (vl_api_stn_rules_dump_t * mp)
 138 {
 139   svm_queue_t *q;
 140   stn_main_t *stn = &stn_main;
 141   stn_rule_t *r;
 142
 143   q = vl_api_client_index_to_input_queue (mp->client_index);
 144   if (q == 0)
 145     return;
 146
 147   /* *INDENT-OFF* */
 148   pool_foreach (r, stn->rules,({
 149     send_stn_rule_details (r, q, mp->context);
 150   }));
 151   /* *INDENT-ON* */
 152 }
 153
 154
 155 /* List of message types that this plugin understands */
 156 #define foreach_stn_plugin_api_msg                      \
 157 _(STN_ADD_DEL_RULE, stn_add_del_rule)   \
 158 _(STN_RULES_DUMP, stn_rules_dump)
 159
 160 /**
 161  * @brief Set up the API message handling tables
 162  * @param vm vlib_main_t * vlib main data structure pointer
 163  * @returns 0 to indicate all is well
 164  */
 165 static clib_error_t *
 166 stn_plugin_api_hookup (vlib_main_t * vm)
 167 {
 168   stn_main_t *stn = &stn_main;
 169 #define _(N,n)                                                  \
 170     vl_msg_api_set_handlers((VL_API_##N + stn->msg_id_base),     \
 171                            #n,                                  \
 172                            vl_api_##n##_t_handler,              \
 173                            vl_noop_handler,                     \
 174                            vl_api_##n##_t_endian,               \
 175                            vl_api_##n##_t_print,                \
 176                            sizeof(vl_api_##n##_t), 1);
 177   foreach_stn_plugin_api_msg;
 178 #undef _
 179
 180   return 0;
 181 }
 182
 183 #define vl_msg_name_crc_list
 184 #include <stn/stn.api.h>
 185 #undef vl_msg_name_crc_list
 186
 187 static void
 188 setup_message_id_table (stn_main_t * stn, api_main_t * am)
 189 {
 190 #define _(id,n,crc) \
 191   vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + stn->msg_id_base);
 192   foreach_vl_msg_name_crc_stn;
 193 #undef _
 194 }
 195
 196 static void
 197 plugin_custom_dump_configure (stn_main_t * stn)
 198 {
 199 #define _(n,f) api_main.msg_print_handlers \
 200   [VL_API_##n + stn->msg_id_base]                \
 201     = (void *) vl_api_##f##_t_print;
 202   foreach_stn_plugin_api_msg;
 203 #undef _
 204 }
 205
 206 clib_error_t *
 207 stn_api_init (vlib_main_t * vm, stn_main_t * sm)
 208 {
 209   u8 *name;
 210   clib_error_t *error = 0;
 211
 212   name = format (0, "stn_%08x%c", api_version, 0);
 213
 214   /* Ask for a correctly-sized block of API message decode slots */
 215   sm->msg_id_base = vl_msg_api_get_msg_ids ((char *) name,
 216                                             VL_MSG_FIRST_AVAILABLE);
 217
 218   error = stn_plugin_api_hookup (vm);
 219
 220   /* Add our API messages to the global name_crc hash table */
 221   setup_message_id_table (sm, &api_main);
 222
 223   plugin_custom_dump_configure (sm);
 224
 225   vec_free (name);
 226
 227   return error;
 228 }
 229
 230 /*
 231  * fd.io coding-style-patch-verification: ON
 232  *
 233  * Local Variables:
 234  * eval: (c-set-style "gnu")
 235  * End:
 236  */