src/vnet/vxlan/vxlan_api.c

   1 /*
   2  *------------------------------------------------------------------
   3  * vxlan_api.c - vxlan api
   4  *
   5  * Copyright (c) 2016 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <vnet/vnet.h>
  21 #include <vlibmemory/api.h>
  22
  23 #include <vnet/interface.h>
  24 #include <vnet/api_errno.h>
  25 #include <vnet/feature/feature.h>
  26 #include <vnet/vxlan/vxlan.h>
  27 #include <vnet/fib/fib_table.h>
  28
  29 #include <vnet/ip/ip_types_api.h>
  30
  31 #include <vnet/vnet_msg_enum.h>
  32
  33 #define vl_typedefs             /* define message structures */
  34 #include <vnet/vnet_all_api_h.h>
  35 #undef vl_typedefs
  36
  37 #define vl_endianfun            /* define message structures */
  38 #include <vnet/vnet_all_api_h.h>
  39 #undef vl_endianfun
  40
  41 /* instantiate all the print functions we know about */
  42 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  43 #define vl_printfun
  44 #include <vnet/vnet_all_api_h.h>
  45 #undef vl_printfun
  46
  47 #include <vlibapi/api_helper_macros.h>
  48
  49 #define foreach_vpe_api_msg                             \
  50 _(SW_INTERFACE_SET_VXLAN_BYPASS, sw_interface_set_vxlan_bypass)         \
  51 _(VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel)                           \
  52 _(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump)                                 \
  53 _(VXLAN_OFFLOAD_RX, vxlan_offload_rx)
  54
  55 static void
  56 vl_api_vxlan_offload_rx_t_handler (vl_api_vxlan_offload_rx_t * mp)
  57 {
  58   vl_api_vxlan_offload_rx_reply_t *rmp;
  59   int rv = 0;
  60   u32 hw_if_index = ntohl (mp->hw_if_index);
  61   u32 sw_if_index = ntohl (mp->sw_if_index);
  62
  63   if (!vnet_hw_interface_is_valid (vnet_get_main (), hw_if_index))
  64     {
  65       rv = VNET_API_ERROR_NO_SUCH_ENTRY;
  66       goto err;
  67     }
  68   VALIDATE_SW_IF_INDEX (mp);
  69
  70   u32 t_index = vnet_vxlan_get_tunnel_index (sw_if_index);
  71   if (t_index == ~0)
  72     {
  73       rv = VNET_API_ERROR_INVALID_SW_IF_INDEX_2;
  74       goto err;
  75     }
  76
  77   vxlan_main_t *vxm = &vxlan_main;
  78   vxlan_tunnel_t *t = pool_elt_at_index (vxm->tunnels, t_index);
  79   if (!ip46_address_is_ip4 (&t->dst))
  80     {
  81       rv = VNET_API_ERROR_INVALID_ADDRESS_FAMILY;
  82       goto err;
  83     }
  84
  85   vnet_main_t *vnm = vnet_get_main ();
  86   vnet_hw_interface_t *hw_if = vnet_get_hw_interface (vnm, hw_if_index);
  87   ip4_main_t *im = &ip4_main;
  88   u32 rx_fib_index =
  89     vec_elt (im->fib_index_by_sw_if_index, hw_if->sw_if_index);
  90
  91   if (t->encap_fib_index != rx_fib_index)
  92     {
  93       rv = VNET_API_ERROR_NO_SUCH_FIB;
  94       goto err;
  95     }
  96
  97   if (vnet_vxlan_add_del_rx_flow (hw_if_index, t_index, mp->enable))
  98     {
  99       rv = VNET_API_ERROR_UNSPECIFIED;
 100       goto err;
 101     }
 102   BAD_SW_IF_INDEX_LABEL;
 103 err:
 104
 105   REPLY_MACRO (VL_API_VXLAN_OFFLOAD_RX_REPLY);
 106 }
 107
 108 static void
 109   vl_api_sw_interface_set_vxlan_bypass_t_handler
 110   (vl_api_sw_interface_set_vxlan_bypass_t * mp)
 111 {
 112   vl_api_sw_interface_set_vxlan_bypass_reply_t *rmp;
 113   int rv = 0;
 114   u32 sw_if_index = ntohl (mp->sw_if_index);
 115
 116   VALIDATE_SW_IF_INDEX (mp);
 117
 118   vnet_int_vxlan_bypass_mode (sw_if_index, mp->is_ipv6, mp->enable);
 119   BAD_SW_IF_INDEX_LABEL;
 120
 121   REPLY_MACRO (VL_API_SW_INTERFACE_SET_VXLAN_BYPASS_REPLY);
 122 }
 123
 124 static void vl_api_vxlan_add_del_tunnel_t_handler
 125   (vl_api_vxlan_add_del_tunnel_t * mp)
 126 {
 127   vl_api_vxlan_add_del_tunnel_reply_t *rmp;
 128   int rv = 0;
 129   bool is_ipv6;
 130   u32 fib_index;
 131   ip46_address_t src, dst;
 132
 133   ip_address_decode (&mp->src_address, &src);
 134   ip_address_decode (&mp->dst_address, &dst);
 135
 136   if (ip46_address_is_ip4 (&src) != ip46_address_is_ip4 (&dst))
 137     {
 138       rv = VNET_API_ERROR_INVALID_VALUE;
 139       goto out;
 140     }
 141
 142   is_ipv6 = !ip46_address_is_ip4 (&src);
 143
 144   fib_index = fib_table_find (fib_ip_proto (is_ipv6),
 145                               ntohl (mp->encap_vrf_id));
 146   if (fib_index == ~0)
 147     {
 148       rv = VNET_API_ERROR_NO_SUCH_FIB;
 149       goto out;
 150     }
 151
 152   vnet_vxlan_add_del_tunnel_args_t a = {
 153     .is_add = mp->is_add,
 154     .is_ip6 = is_ipv6,
 155     .instance = ntohl (mp->instance),
 156     .mcast_sw_if_index = ntohl (mp->mcast_sw_if_index),
 157     .encap_fib_index = fib_index,
 158     .decap_next_index = ntohl (mp->decap_next_index),
 159     .vni = ntohl (mp->vni),
 160     .dst = dst,
 161     .src = src,
 162   };
 163
 164   /* Check src & dst are different */
 165   if (ip46_address_cmp (&a.dst, &a.src) == 0)
 166     {
 167       rv = VNET_API_ERROR_SAME_SRC_DST;
 168       goto out;
 169     }
 170   if (ip46_address_is_multicast (&a.dst) &&
 171       !vnet_sw_if_index_is_api_valid (a.mcast_sw_if_index))
 172     {
 173       rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
 174       goto out;
 175     }
 176
 177   u32 sw_if_index = ~0;
 178   rv = vnet_vxlan_add_del_tunnel (&a, &sw_if_index);
 179
 180 out:
 181   /* *INDENT-OFF* */
 182   REPLY_MACRO2(VL_API_VXLAN_ADD_DEL_TUNNEL_REPLY,
 183   ({
 184     rmp->sw_if_index = ntohl (sw_if_index);
 185   }));
 186   /* *INDENT-ON* */
 187 }
 188
 189 static void send_vxlan_tunnel_details
 190   (vxlan_tunnel_t * t, vl_api_registration_t * reg, u32 context)
 191 {
 192   vl_api_vxlan_tunnel_details_t *rmp;
 193   ip4_main_t *im4 = &ip4_main;
 194   ip6_main_t *im6 = &ip6_main;
 195
 196   rmp = vl_msg_api_alloc (sizeof (*rmp));
 197   clib_memset (rmp, 0, sizeof (*rmp));
 198   rmp->_vl_msg_id = ntohs (VL_API_VXLAN_TUNNEL_DETAILS);
 199
 200   ip_address_encode (&t->src, IP46_TYPE_ANY, &rmp->src_address);
 201   ip_address_encode (&t->dst, IP46_TYPE_ANY, &rmp->dst_address);
 202
 203   if (ip46_address_is_ip4 (&t->dst))
 204     rmp->encap_vrf_id = htonl (im4->fibs[t->encap_fib_index].ft_table_id);
 205   else
 206     rmp->encap_vrf_id = htonl (im6->fibs[t->encap_fib_index].ft_table_id);
 207
 208   rmp->instance = htonl (t->user_instance);
 209   rmp->mcast_sw_if_index = htonl (t->mcast_sw_if_index);
 210   rmp->vni = htonl (t->vni);
 211   rmp->decap_next_index = htonl (t->decap_next_index);
 212   rmp->sw_if_index = htonl (t->sw_if_index);
 213   rmp->context = context;
 214
 215   vl_api_send_msg (reg, (u8 *) rmp);
 216 }
 217
 218 static void vl_api_vxlan_tunnel_dump_t_handler
 219   (vl_api_vxlan_tunnel_dump_t * mp)
 220 {
 221   vl_api_registration_t *reg;
 222   vxlan_main_t *vxm = &vxlan_main;
 223   vxlan_tunnel_t *t;
 224   u32 sw_if_index;
 225
 226   reg = vl_api_client_index_to_registration (mp->client_index);
 227   if (!reg)
 228     return;
 229
 230   sw_if_index = ntohl (mp->sw_if_index);
 231
 232   if (~0 == sw_if_index)
 233     {
 234       /* *INDENT-OFF* */
 235       pool_foreach (t, vxm->tunnels,
 236       ({
 237         send_vxlan_tunnel_details(t, reg, mp->context);
 238       }));
 239       /* *INDENT-ON* */
 240     }
 241   else
 242     {
 243       if ((sw_if_index >= vec_len (vxm->tunnel_index_by_sw_if_index)) ||
 244           (~0 == vxm->tunnel_index_by_sw_if_index[sw_if_index]))
 245         {
 246           return;
 247         }
 248       t = &vxm->tunnels[vxm->tunnel_index_by_sw_if_index[sw_if_index]];
 249       send_vxlan_tunnel_details (t, reg, mp->context);
 250     }
 251 }
 252
 253 /*
 254  * vpe_api_hookup
 255  * Add vpe's API message handlers to the table.
 256  * vlib has already mapped shared memory and
 257  * added the client registration handlers.
 258  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
 259  */
 260 #define vl_msg_name_crc_list
 261 #include <vnet/vnet_all_api_h.h>
 262 #undef vl_msg_name_crc_list
 263
 264 static void
 265 setup_message_id_table (api_main_t * am)
 266 {
 267 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
 268   foreach_vl_msg_name_crc_vxlan;
 269 #undef _
 270 }
 271
 272 static clib_error_t *
 273 vxlan_api_hookup (vlib_main_t * vm)
 274 {
 275   api_main_t *am = vlibapi_get_main ();
 276
 277 #define _(N,n)                                                  \
 278     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
 279                            vl_api_##n##_t_handler,              \
 280                            vl_noop_handler,                     \
 281                            vl_api_##n##_t_endian,               \
 282                            vl_api_##n##_t_print,                \
 283                            sizeof(vl_api_##n##_t), 1);
 284   foreach_vpe_api_msg;
 285 #undef _
 286
 287   am->api_trace_cfg[VL_API_VXLAN_ADD_DEL_TUNNEL].size += 16 * sizeof (u32);
 288
 289   /*
 290    * Set up the (msg_name, crc, message-id) table
 291    */
 292   setup_message_id_table (am);
 293
 294   return 0;
 295 }
 296
 297 VLIB_API_INIT_FUNCTION (vxlan_api_hookup);
 298
 299 /*
 300  * fd.io coding-style-patch-verification: ON
 301  *
 302  * Local Variables:
 303  * eval: (c-set-style "gnu")
 304  * End:
 305  */