src/vnet/dhcp/dhcp_api.c

   1 /*
   2  *------------------------------------------------------------------
   3  * dhcp_api.c - dhcp 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/dhcp/dhcp_proxy.h>
  26 #include <vnet/dhcp/client.h>
  27 #include <vnet/fib/fib_table.h>
  28
  29 #include <vnet/vnet_msg_enum.h>
  30
  31 #define vl_typedefs             /* define message structures */
  32 #include <vnet/vnet_all_api_h.h>
  33 #undef vl_typedefs
  34
  35 #define vl_endianfun            /* define message structures */
  36 #include <vnet/vnet_all_api_h.h>
  37 #undef vl_endianfun
  38
  39 /* instantiate all the print functions we know about */
  40 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  41 #define vl_printfun
  42 #include <vnet/vnet_all_api_h.h>
  43 #undef vl_printfun
  44
  45 #include <vlibapi/api_helper_macros.h>
  46
  47 #define foreach_vpe_api_msg                       \
  48 _(DHCP_PROXY_CONFIG,dhcp_proxy_config)            \
  49 _(DHCP_PROXY_DUMP,dhcp_proxy_dump)                \
  50 _(DHCP_PROXY_SET_VSS,dhcp_proxy_set_vss)          \
  51 _(DHCP_CLIENT_CONFIG, dhcp_client_config)
  52
  53
  54 static void
  55 vl_api_dhcp_proxy_set_vss_t_handler (vl_api_dhcp_proxy_set_vss_t * mp)
  56 {
  57   vl_api_dhcp_proxy_set_vss_reply_t *rmp;
  58   int rv;
  59
  60   rv = dhcp_proxy_set_vss ((mp->is_ipv6 ?
  61                             FIB_PROTOCOL_IP6 :
  62                             FIB_PROTOCOL_IP4),
  63                            ntohl (mp->tbl_id),
  64                            ntohl (mp->oui),
  65                            ntohl (mp->fib_id), (int) mp->is_add == 0);
  66
  67   REPLY_MACRO (VL_API_DHCP_PROXY_SET_VSS_REPLY);
  68 }
  69
  70
  71 static void vl_api_dhcp_proxy_config_t_handler
  72   (vl_api_dhcp_proxy_config_t * mp)
  73 {
  74   vl_api_dhcp_proxy_set_vss_reply_t *rmp;
  75   ip46_address_t src, server;
  76   int rv = -1;
  77
  78   if (mp->is_ipv6)
  79     {
  80       clib_memcpy (&src.ip6, mp->dhcp_src_address, sizeof (src.ip6));
  81       clib_memcpy (&server.ip6, mp->dhcp_server, sizeof (server.ip6));
  82
  83       rv = dhcp6_proxy_set_server (&server,
  84                                    &src,
  85                                    (u32) ntohl (mp->rx_vrf_id),
  86                                    (u32) ntohl (mp->server_vrf_id),
  87                                    (int) (mp->is_add == 0));
  88     }
  89   else
  90     {
  91       ip46_address_reset (&src);
  92       ip46_address_reset (&server);
  93
  94       clib_memcpy (&src.ip4, mp->dhcp_src_address, sizeof (src.ip4));
  95       clib_memcpy (&server.ip4, mp->dhcp_server, sizeof (server.ip4));
  96
  97       rv = dhcp4_proxy_set_server (&server,
  98                                    &src,
  99                                    (u32) ntohl (mp->rx_vrf_id),
 100                                    (u32) ntohl (mp->server_vrf_id),
 101                                    (int) (mp->is_add == 0));
 102     }
 103
 104
 105   REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_REPLY);
 106 }
 107
 108 static void
 109 vl_api_dhcp_proxy_dump_t_handler (vl_api_dhcp_proxy_dump_t * mp)
 110 {
 111   unix_shared_memory_queue_t *q;
 112
 113   q = vl_api_client_index_to_input_queue (mp->client_index);
 114   if (q == 0)
 115     return;
 116
 117   dhcp_proxy_dump ((mp->is_ip6 == 1 ?
 118                     FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4), q, mp->context);
 119 }
 120
 121 void
 122 dhcp_send_details (fib_protocol_t proto,
 123                    void *opaque, u32 context, dhcp_proxy_t * proxy)
 124 {
 125   vl_api_dhcp_proxy_details_t *mp;
 126   unix_shared_memory_queue_t *q = opaque;
 127   vl_api_dhcp_server_t *v_server;
 128   dhcp_server_t *server;
 129   fib_table_t *s_fib;
 130   dhcp_vss_t *vss;
 131   u32 count;
 132   size_t n;
 133
 134   count = vec_len (proxy->dhcp_servers);
 135   n = sizeof (*mp) + (count * sizeof (vl_api_dhcp_server_t));
 136   mp = vl_msg_api_alloc (n);
 137   if (!mp)
 138     return;
 139   memset (mp, 0, n);
 140   mp->_vl_msg_id = ntohs (VL_API_DHCP_PROXY_DETAILS);
 141   mp->context = context;
 142   mp->count = count;
 143
 144   mp->is_ipv6 = (proto == FIB_PROTOCOL_IP6);
 145   mp->rx_vrf_id =
 146     htonl (dhcp_proxy_rx_table_get_table_id (proto, proxy->rx_fib_index));
 147
 148   vss = dhcp_get_vss_info (&dhcp_proxy_main, proxy->rx_fib_index, proto);
 149
 150   if (NULL != vss)
 151     {
 152       mp->vss_oui = htonl (vss->oui);
 153       mp->vss_fib_id = htonl (vss->fib_id);
 154     }
 155
 156   vec_foreach_index (count, proxy->dhcp_servers)
 157   {
 158     server = &proxy->dhcp_servers[count];
 159     v_server = &mp->servers[count];
 160
 161     s_fib = fib_table_get (server->server_fib_index, proto);
 162
 163     v_server->server_vrf_id = htonl (s_fib->ft_table_id);
 164
 165     if (mp->is_ipv6)
 166       {
 167         memcpy (v_server->dhcp_server, &server->dhcp_server.ip6, 16);
 168       }
 169     else
 170       {
 171         /* put the address in the first bytes */
 172         memcpy (v_server->dhcp_server, &server->dhcp_server.ip4, 4);
 173       }
 174   }
 175
 176   if (mp->is_ipv6)
 177     {
 178       memcpy (mp->dhcp_src_address, &proxy->dhcp_src_address.ip6, 16);
 179     }
 180   else
 181     {
 182       /* put the address in the first bytes */
 183       memcpy (mp->dhcp_src_address, &proxy->dhcp_src_address.ip4, 4);
 184     }
 185   vl_msg_api_send_shmem (q, (u8 *) & mp);
 186 }
 187
 188 void
 189 dhcp_compl_event_callback (u32 client_index, u32 pid, u8 * hostname,
 190                            u8 mask_width, u8 is_ipv6, u8 * host_address,
 191                            u8 * router_address, u8 * host_mac)
 192 {
 193   unix_shared_memory_queue_t *q;
 194   vl_api_dhcp_compl_event_t *mp;
 195   u32 len;
 196
 197   q = vl_api_client_index_to_input_queue (client_index);
 198   if (!q)
 199     return;
 200
 201   mp = vl_msg_api_alloc (sizeof (*mp));
 202   mp->client_index = client_index;
 203   mp->pid = pid;
 204   mp->is_ipv6 = is_ipv6;
 205   len = (vec_len (hostname) < 63) ? vec_len (hostname) : 63;
 206   clib_memcpy (&mp->hostname, hostname, len);
 207   mp->hostname[len] = 0;
 208   mp->mask_width = mask_width;
 209   clib_memcpy (&mp->host_address[0], host_address, 16);
 210   clib_memcpy (&mp->router_address[0], router_address, 16);
 211
 212   if (NULL != host_mac)
 213     clib_memcpy (&mp->host_mac[0], host_mac, 6);
 214
 215   mp->_vl_msg_id = ntohs (VL_API_DHCP_COMPL_EVENT);
 216
 217   vl_msg_api_send_shmem (q, (u8 *) & mp);
 218 }
 219
 220 static void vl_api_dhcp_client_config_t_handler
 221   (vl_api_dhcp_client_config_t * mp)
 222 {
 223   vlib_main_t *vm = vlib_get_main ();
 224   vl_api_dhcp_client_config_reply_t *rmp;
 225   int rv = 0;
 226
 227   VALIDATE_SW_IF_INDEX (mp);
 228
 229   rv = dhcp_client_config (vm, ntohl (mp->sw_if_index),
 230                            mp->hostname, mp->client_id,
 231                            mp->is_add, mp->client_index,
 232                            mp->want_dhcp_event ? dhcp_compl_event_callback :
 233                            NULL, mp->pid);
 234
 235   BAD_SW_IF_INDEX_LABEL;
 236
 237   REPLY_MACRO (VL_API_DHCP_CLIENT_CONFIG_REPLY);
 238 }
 239
 240 /*
 241  * dhcp_api_hookup
 242  * Add vpe's API message handlers to the table.
 243  * vlib has alread mapped shared memory and
 244  * added the client registration handlers.
 245  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
 246  */
 247 #define vl_msg_name_crc_list
 248 #include <vnet/vnet_all_api_h.h>
 249 #undef vl_msg_name_crc_list
 250
 251 static void
 252 setup_message_id_table (api_main_t * am)
 253 {
 254 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
 255   foreach_vl_msg_name_crc_dhcp;
 256 #undef _
 257 }
 258
 259 static clib_error_t *
 260 dhcp_api_hookup (vlib_main_t * vm)
 261 {
 262   api_main_t *am = &api_main;
 263
 264 #define _(N,n)                                                  \
 265     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
 266                            vl_api_##n##_t_handler,              \
 267                            vl_noop_handler,                     \
 268                            vl_api_##n##_t_endian,               \
 269                            vl_api_##n##_t_print,                \
 270                            sizeof(vl_api_##n##_t), 1);
 271   foreach_vpe_api_msg;
 272 #undef _
 273
 274   /*
 275    * Set up the (msg_name, crc, message-id) table
 276    */
 277   setup_message_id_table (am);
 278
 279   return 0;
 280 }
 281
 282 VLIB_API_INIT_FUNCTION (dhcp_api_hookup);
 283
 284 /*
 285  * fd.io coding-style-patch-verification: ON
 286  *
 287  * Local Variables:
 288  * eval: (c-set-style "gnu")
 289  * End:
 290  */