src/vnet/ipip/ipip_api.c

   1 /*
   2  * ipip_api.c - ipip api
   3  *
   4  * Copyright (c) 2018 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <vlibmemory/api.h>
  19 #include <vnet/api_errno.h>
  20 #include <vnet/fib/fib_table.h>
  21 #include <vnet/interface.h>
  22 #include <vnet/ipip/ipip.h>
  23 #include <vnet/vnet.h>
  24 #include <vnet/vnet_msg_enum.h>
  25 #include <vnet/ip/ip_types_api.h>
  26
  27 #define vl_typedefs             /* define message structures */
  28 #include <vnet/vnet_all_api_h.h>
  29 #undef vl_typedefs
  30
  31 #define vl_endianfun            /* define message structures */
  32 #include <vnet/vnet_all_api_h.h>
  33 #undef vl_endianfun
  34
  35 /* instantiate all the print functions we know about */
  36 #define vl_print(handle, ...) vlib_cli_output(handle, __VA_ARGS__)
  37 #define vl_printfun
  38 #include <vnet/vnet_all_api_h.h>
  39 #undef vl_printfun
  40
  41 #include <vlibapi/api_helper_macros.h>
  42
  43 #define foreach_vpe_api_msg                     \
  44   _(IPIP_ADD_TUNNEL, ipip_add_tunnel)           \
  45   _(IPIP_DEL_TUNNEL, ipip_del_tunnel)           \
  46   _(IPIP_6RD_ADD_TUNNEL, ipip_6rd_add_tunnel)   \
  47   _(IPIP_6RD_DEL_TUNNEL, ipip_6rd_del_tunnel)   \
  48   _(IPIP_TUNNEL_DUMP, ipip_tunnel_dump)
  49
  50 static void
  51 vl_api_ipip_add_tunnel_t_handler (vl_api_ipip_add_tunnel_t * mp)
  52 {
  53   vl_api_ipip_add_tunnel_reply_t *rmp;
  54   int rv = 0;
  55   u32 fib_index, sw_if_index = ~0;
  56   ip46_address_t src, dst;
  57   ip46_type_t itype[2];
  58
  59   itype[0] = ip_address_decode (&mp->tunnel.src, &src);
  60   itype[1] = ip_address_decode (&mp->tunnel.dst, &dst);
  61
  62   if (itype[0] != itype[1])
  63     {
  64       rv = VNET_API_ERROR_INVALID_PROTOCOL;
  65       goto out;
  66     }
  67
  68   if (ip46_address_is_equal (&src, &dst))
  69     {
  70       rv = VNET_API_ERROR_SAME_SRC_DST;
  71       goto out;
  72     }
  73
  74   fib_index = fib_table_find (fib_proto_from_ip46 (itype[0]),
  75                               ntohl (mp->tunnel.table_id));
  76
  77   if (~0 == fib_index)
  78     {
  79       rv = VNET_API_ERROR_NO_SUCH_FIB;
  80     }
  81   else
  82     {
  83       rv = ipip_add_tunnel ((itype[0] == IP46_TYPE_IP6 ?
  84                              IPIP_TRANSPORT_IP6 :
  85                              IPIP_TRANSPORT_IP4),
  86                             ntohl (mp->tunnel.instance), &src, &dst,
  87                             fib_index, mp->tunnel.tc_tos, &sw_if_index);
  88     }
  89
  90 out:
  91   /* *INDENT-OFF* */
  92   REPLY_MACRO2(VL_API_IPIP_ADD_TUNNEL_REPLY,
  93   ({
  94     rmp->sw_if_index = ntohl(sw_if_index);
  95   }));
  96   /* *INDENT-ON* */
  97 }
  98
  99 static void
 100 vl_api_ipip_del_tunnel_t_handler (vl_api_ipip_del_tunnel_t * mp)
 101 {
 102   vl_api_ipip_del_tunnel_reply_t *rmp;
 103
 104   int rv = ipip_del_tunnel (ntohl (mp->sw_if_index));
 105
 106   REPLY_MACRO (VL_API_IPIP_DEL_TUNNEL_REPLY);
 107 }
 108
 109 static void
 110 send_ipip_tunnel_details (ipip_tunnel_t * t,
 111                           vl_api_registration_t * reg, u32 context)
 112 {
 113   vl_api_ipip_tunnel_details_t *rmp;
 114   bool is_ipv6 = t->transport == IPIP_TRANSPORT_IP6 ? true : false;
 115   fib_table_t *ft;
 116
 117   rmp = vl_msg_api_alloc (sizeof (*rmp));
 118   clib_memset (rmp, 0, sizeof (*rmp));
 119   rmp->_vl_msg_id = htons (VL_API_IPIP_TUNNEL_DETAILS);
 120
 121   ip_address_encode (&t->tunnel_src, IP46_TYPE_ANY, &rmp->tunnel.src);
 122   ip_address_encode (&t->tunnel_dst, IP46_TYPE_ANY, &rmp->tunnel.dst);
 123
 124   ft = fib_table_get (t->fib_index, (is_ipv6 ? FIB_PROTOCOL_IP6 :
 125                                      FIB_PROTOCOL_IP4));
 126
 127   rmp->tunnel.table_id = htonl (ft->ft_table_id);
 128   rmp->tunnel.instance = htonl (t->user_instance);
 129   rmp->tunnel.sw_if_index = htonl (t->sw_if_index);
 130   rmp->context = context;
 131
 132   vl_api_send_msg (reg, (u8 *) rmp);
 133 }
 134
 135 static void
 136 vl_api_ipip_tunnel_dump_t_handler (vl_api_ipip_tunnel_dump_t * mp)
 137 {
 138   vl_api_registration_t *reg;
 139   ipip_main_t *gm = &ipip_main;
 140   ipip_tunnel_t *t;
 141   u32 sw_if_index;
 142
 143   reg = vl_api_client_index_to_registration (mp->client_index);
 144   if (!reg)
 145     return;
 146
 147   sw_if_index = ntohl (mp->sw_if_index);
 148
 149   if (sw_if_index == ~0)
 150     {
 151     /* *INDENT-OFF* */
 152     pool_foreach(t, gm->tunnels,
 153                  ({ send_ipip_tunnel_details(t, reg, mp->context); }));
 154     /* *INDENT-ON* */
 155     }
 156   else
 157     {
 158       t = ipip_tunnel_db_find_by_sw_if_index (sw_if_index);
 159       if (t)
 160         send_ipip_tunnel_details (t, reg, mp->context);
 161     }
 162 }
 163
 164 static void
 165 vl_api_ipip_6rd_add_tunnel_t_handler (vl_api_ipip_6rd_add_tunnel_t * mp)
 166 {
 167   vl_api_ipip_6rd_add_tunnel_reply_t *rmp;
 168   u32 sixrd_tunnel_index, ip4_fib_index, ip6_fib_index;
 169   int rv;
 170
 171   ip4_fib_index = fib_table_find (FIB_PROTOCOL_IP4, ntohl (mp->ip4_table_id));
 172   ip6_fib_index = fib_table_find (FIB_PROTOCOL_IP6, ntohl (mp->ip6_table_id));
 173
 174   if (~0 == ip4_fib_index || ~0 == ip6_fib_index)
 175
 176     {
 177       rv = VNET_API_ERROR_NO_SUCH_FIB;
 178     }
 179   else
 180     {
 181       rv = sixrd_add_tunnel ((ip6_address_t *) & mp->ip6_prefix.prefix,
 182                              mp->ip6_prefix.len,
 183                              (ip4_address_t *) & mp->ip4_prefix.prefix,
 184                              mp->ip4_prefix.len,
 185                              (ip4_address_t *) & mp->ip4_src,
 186                              mp->security_check,
 187                              ip4_fib_index, ip6_fib_index,
 188                              &sixrd_tunnel_index);
 189     }
 190
 191   /* *INDENT-OFF* */
 192   REPLY_MACRO2 (VL_API_IPIP_6RD_ADD_TUNNEL_REPLY,
 193   ({
 194     rmp->sw_if_index = htonl (sixrd_tunnel_index);
 195   }));
 196   /* *INDENT-ON* */
 197 }
 198
 199 static void
 200 vl_api_ipip_6rd_del_tunnel_t_handler (vl_api_ipip_6rd_del_tunnel_t * mp)
 201 {
 202   vl_api_ipip_6rd_del_tunnel_reply_t *rmp;
 203
 204   int rv = sixrd_del_tunnel (ntohl (mp->sw_if_index));
 205
 206   REPLY_MACRO (VL_API_IPIP_6RD_DEL_TUNNEL_REPLY);
 207 }
 208
 209 /*
 210  * ipip_api_hookup
 211  * Add vpe's API message handlers to the table.
 212  * vlib has already mapped shared memory and
 213  * added the client registration handlers.
 214  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
 215  */
 216 #define vl_msg_name_crc_list
 217 #include <vnet/vnet_all_api_h.h>
 218 #undef vl_msg_name_crc_list
 219
 220 static void
 221 setup_message_id_table (api_main_t * am)
 222 {
 223 #define _(id, n, crc) vl_msg_api_add_msg_name_crc(am, #n "_" #crc, id);
 224   foreach_vl_msg_name_crc_ipip;
 225 #undef _
 226 }
 227
 228 static clib_error_t *
 229 ipip_api_hookup (vlib_main_t * vm)
 230 {
 231   api_main_t *am = &api_main;
 232
 233 #define _(N, n)                                                                \
 234   vl_msg_api_set_handlers(VL_API_##N, #n, vl_api_##n##_t_handler,              \
 235                           vl_noop_handler, vl_api_##n##_t_endian,              \
 236                           vl_api_##n##_t_print, sizeof(vl_api_##n##_t), 1);
 237   foreach_vpe_api_msg;
 238 #undef _
 239
 240   /*
 241    * Set up the (msg_name, crc, message-id) table
 242    */
 243   setup_message_id_table (am);
 244
 245   return 0;
 246 }
 247
 248 VLIB_API_INIT_FUNCTION (ipip_api_hookup);
 249
 250 /*
 251  * fd.io coding-style-patch-verification: ON
 252  *
 253  * Local Variables:
 254  * eval: (c-set-style "gnu")
 255  * End:
 256  */