src/plugins/dhcp/dhcp6_pd_client_dp.c

   1 /*
   2  * Copyright (c) 2018 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 <vlib/vlib.h>
  17 #include <dhcp/dhcp6_packet.h>
  18 #include <dhcp/dhcp_proxy.h>
  19 #include <vnet/mfib/mfib_table.h>
  20 #include <vnet/mfib/ip6_mfib.h>
  21 #include <vnet/fib/fib.h>
  22 #include <vnet/adj/adj_mcast.h>
  23 #include <vnet/ip/ip6_neighbor.h>
  24 #include <dhcp/dhcp6_pd_client_dp.h>
  25 #include <dhcp/dhcp6_client_common_dp.h>
  26 #include <vnet/ip/ip_types_api.h>
  27
  28 dhcp6_pd_client_main_t dhcp6_pd_client_main;
  29 dhcp6_pd_client_public_main_t dhcp6_pd_client_public_main;
  30
  31 static void
  32 signal_report (prefix_report_t * r)
  33 {
  34   vlib_main_t *vm = vlib_get_main ();
  35   dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main;
  36   uword ni = cm->publisher_node;
  37   uword et = cm->publisher_et;
  38
  39   if (ni == (uword) ~ 0)
  40     return;
  41   prefix_report_t *q =
  42     vlib_process_signal_event_data (vm, ni, et, 1, sizeof *q);
  43
  44   *q = *r;
  45 }
  46
  47 int
  48 dhcp6_pd_publish_report (prefix_report_t * r)
  49 {
  50   void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
  51   vl_api_rpc_call_main_thread (signal_report, (u8 *) r, sizeof *r);
  52   return 0;
  53 }
  54
  55 void
  56 dhcp6_pd_set_publisher_node (uword node_index, uword event_type)
  57 {
  58   dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main;
  59   cm->publisher_node = node_index;
  60   cm->publisher_et = event_type;
  61 }
  62
  63 static void
  64 stop_sending_client_message (vlib_main_t * vm,
  65                              dhcp6_pd_client_state_t * client_state)
  66 {
  67   u32 bi0;
  68
  69   client_state->keep_sending_client_message = 0;
  70   vec_free (client_state->params.prefixes);
  71   if (client_state->buffer)
  72     {
  73       bi0 = vlib_get_buffer_index (vm, client_state->buffer);
  74       vlib_buffer_free (vm, &bi0, 1);
  75       client_state->buffer = 0;
  76       adj_unlock (client_state->adj_index);
  77       client_state->adj_index = ~0;
  78     }
  79 }
  80
  81 static vlib_buffer_t *
  82 create_buffer_for_client_message (vlib_main_t * vm,
  83                                   u32 sw_if_index,
  84                                   dhcp6_pd_client_state_t
  85                                   * client_state, u32 type)
  86 {
  87   dhcp6_client_common_main_t *ccm = &dhcp6_client_common_main;
  88   vnet_main_t *vnm = vnet_get_main ();
  89
  90   vlib_buffer_t *b;
  91   u32 bi;
  92   ip6_header_t *ip;
  93   udp_header_t *udp;
  94   dhcpv6_header_t *dhcp;
  95   ip6_address_t src_addr;
  96   u32 dhcp_opt_len = 0;
  97   client_state->transaction_start = vlib_time_now (vm);
  98   u32 n_prefixes;
  99   u32 i;
 100
 101   vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
 102   vnet_sw_interface_t *sup_sw = vnet_get_sup_sw_interface (vnm, sw_if_index);
 103   vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, sw_if_index);
 104
 105   /* Interface(s) down? */
 106   if ((hw->flags & VNET_HW_INTERFACE_FLAG_LINK_UP) == 0)
 107     return NULL;
 108   if ((sup_sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) == 0)
 109     return NULL;
 110   if ((sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) == 0)
 111     return NULL;
 112
 113   /* Get a link-local address */
 114   src_addr = ip6_neighbor_get_link_local_address (sw_if_index);
 115
 116   if (src_addr.as_u8[0] != 0xfe)
 117     {
 118       clib_warning ("Could not find source address to send DHCPv6 packet");
 119       return NULL;
 120     }
 121
 122   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
 123     {
 124       clib_warning ("Buffer allocation failed");
 125       return NULL;
 126     }
 127
 128   b = vlib_get_buffer (vm, bi);
 129   vnet_buffer (b)->sw_if_index[VLIB_RX] = sw_if_index;
 130   vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index;
 131   client_state->adj_index = adj_mcast_add_or_lock (FIB_PROTOCOL_IP6,
 132                                                    VNET_LINK_IP6,
 133                                                    sw_if_index);
 134   vnet_buffer (b)->ip.adj_index[VLIB_TX] = client_state->adj_index;
 135   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 136
 137   ip = (ip6_header_t *) vlib_buffer_get_current (b);
 138   udp = (udp_header_t *) (ip + 1);
 139   dhcp = (dhcpv6_header_t *) (udp + 1);
 140
 141   ip->src_address = src_addr;
 142   ip->hop_limit = 255;
 143   ip->ip_version_traffic_class_and_flow_label =
 144     clib_host_to_net_u32 (0x6 << 28);
 145   ip->payload_length = 0;
 146   ip->protocol = IP_PROTOCOL_UDP;
 147
 148   udp->src_port = clib_host_to_net_u16 (DHCPV6_CLIENT_PORT);
 149   udp->dst_port = clib_host_to_net_u16 (DHCPV6_SERVER_PORT);
 150   udp->checksum = 0;
 151   udp->length = 0;
 152
 153   dhcp->msg_type = type;
 154   dhcp->xid[0] = (client_state->transaction_id & 0x00ff0000) >> 16;
 155   dhcp->xid[1] = (client_state->transaction_id & 0x0000ff00) >> 8;
 156   dhcp->xid[2] = (client_state->transaction_id & 0x000000ff) >> 0;
 157
 158   void *d = (void *) dhcp->data;
 159   dhcpv6_option_t *duid;
 160   dhcpv6_elapsed_t *elapsed;
 161   dhcpv6_ia_header_t *ia_hdr;
 162   dhcpv6_ia_opt_pd_t *opt_pd;
 163   if (type == DHCPV6_MSG_SOLICIT || type == DHCPV6_MSG_REQUEST ||
 164       type == DHCPV6_MSG_RENEW || type == DHCPV6_MSG_REBIND ||
 165       type == DHCPV6_MSG_RELEASE)
 166     {
 167       duid = (dhcpv6_option_t *) d;
 168       duid->option = clib_host_to_net_u16 (DHCPV6_OPTION_CLIENTID);
 169       duid->length = clib_host_to_net_u16 (CLIENT_DUID_LENGTH);
 170       clib_memcpy (duid + 1, client_duid.bin_string, CLIENT_DUID_LENGTH);
 171       d += sizeof (*duid) + CLIENT_DUID_LENGTH;
 172
 173       if (client_state->params.server_index != ~0)
 174         {
 175           server_id_t *se =
 176             &ccm->server_ids[client_state->params.server_index];
 177
 178           duid = (dhcpv6_option_t *) d;
 179           duid->option = clib_host_to_net_u16 (DHCPV6_OPTION_SERVERID);
 180           duid->length = clib_host_to_net_u16 (se->len);
 181           clib_memcpy (duid + 1, se->data, se->len);
 182           d += sizeof (*duid) + se->len;
 183         }
 184
 185       elapsed = (dhcpv6_elapsed_t *) d;
 186       elapsed->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_ELAPSED_TIME);
 187       elapsed->opt.length =
 188         clib_host_to_net_u16 (sizeof (*elapsed) - sizeof (elapsed->opt));
 189       elapsed->elapsed_10ms = 0;
 190       client_state->elapsed_pos =
 191         (char *) &elapsed->elapsed_10ms -
 192         (char *) vlib_buffer_get_current (b);
 193       d += sizeof (*elapsed);
 194
 195       ia_hdr = (dhcpv6_ia_header_t *) d;
 196       ia_hdr->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_IA_PD);
 197       ia_hdr->iaid = clib_host_to_net_u32 (DHCPV6_CLIENT_IAID);
 198       ia_hdr->t1 = clib_host_to_net_u32 (client_state->params.T1);
 199       ia_hdr->t2 = clib_host_to_net_u32 (client_state->params.T2);
 200       d += sizeof (*ia_hdr);
 201
 202       n_prefixes = vec_len (client_state->params.prefixes);
 203
 204       ia_hdr->opt.length =
 205         clib_host_to_net_u16 (sizeof (*ia_hdr) +
 206                               n_prefixes * sizeof (*opt_pd) -
 207                               sizeof (ia_hdr->opt));
 208
 209       for (i = 0; i < n_prefixes; i++)
 210         {
 211           dhcp6_pd_send_client_message_params_prefix_t *pref =
 212             &client_state->params.prefixes[i];
 213           opt_pd = (dhcpv6_ia_opt_pd_t *) d;
 214           opt_pd->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_IAPREFIX);
 215           opt_pd->opt.length =
 216             clib_host_to_net_u16 (sizeof (*opt_pd) - sizeof (opt_pd->opt));
 217           opt_pd->addr = pref->prefix;
 218           opt_pd->prefix = pref->prefix_length;
 219           opt_pd->valid = clib_host_to_net_u32 (pref->valid_lt);
 220           opt_pd->preferred = clib_host_to_net_u32 (pref->preferred_lt);
 221           d += sizeof (*opt_pd);
 222         }
 223     }
 224   else
 225     {
 226       clib_warning ("State not implemented");
 227     }
 228
 229   dhcp_opt_len = ((u8 *) d) - dhcp->data;
 230   udp->length =
 231     clib_host_to_net_u16 (sizeof (*udp) + sizeof (*dhcp) + dhcp_opt_len);
 232   ip->payload_length = udp->length;
 233   b->current_length =
 234     sizeof (*ip) + sizeof (*udp) + sizeof (*dhcp) + dhcp_opt_len;
 235
 236   ip->dst_address = all_dhcp6_relay_agents_and_servers;
 237
 238   return b;
 239 }
 240
 241 static inline u8
 242 check_pd_send_client_message (vlib_main_t * vm,
 243                               dhcp6_pd_client_state_t * client_state,
 244                               f64 current_time, f64 * due_time)
 245 {
 246   vlib_buffer_t *p0;
 247   vlib_frame_t *f;
 248   u32 *to_next;
 249   u32 next_index;
 250   vlib_buffer_t *c0;
 251   ip6_header_t *ip;
 252   udp_header_t *udp;
 253   u32 ci0;
 254   int bogus_length = 0;
 255
 256   dhcp6_pd_send_client_message_params_t *params;
 257
 258   f64 now = vlib_time_now (vm);
 259
 260   if (!client_state->keep_sending_client_message)
 261     return false;
 262
 263   params = &client_state->params;
 264
 265   if (client_state->due_time > current_time)
 266     {
 267       *due_time = client_state->due_time;
 268       return true;
 269     }
 270
 271   p0 = client_state->buffer;
 272
 273   next_index = ip6_rewrite_mcast_node.index;
 274
 275   c0 = vlib_buffer_copy (vm, p0);
 276   ci0 = vlib_get_buffer_index (vm, c0);
 277
 278   ip = (ip6_header_t *) vlib_buffer_get_current (c0);
 279   udp = (udp_header_t *) (ip + 1);
 280
 281   u16 *elapsed_field = (u16 *) ((void *) ip + client_state->elapsed_pos);
 282   *elapsed_field =
 283     clib_host_to_net_u16 ((u16)
 284                           ((now - client_state->transaction_start) * 100));
 285
 286   udp->checksum = 0;
 287   udp->checksum =
 288     ip6_tcp_udp_icmp_compute_checksum (vm, 0, ip, &bogus_length);
 289
 290   f = vlib_get_frame_to_node (vm, next_index);
 291   to_next = vlib_frame_vector_args (f);
 292   to_next[0] = ci0;
 293   f->n_vectors = 1;
 294   vlib_put_frame_to_node (vm, next_index, f);
 295
 296   if (params->mrc != 0 && --client_state->n_left == 0)
 297     stop_sending_client_message (vm, client_state);
 298   else
 299     {
 300       client_state->sleep_interval =
 301         (2 + random_f64_from_to (-0.1, 0.1)) * client_state->sleep_interval;
 302       if (client_state->sleep_interval > params->mrt)
 303         client_state->sleep_interval =
 304           (1 + random_f64_from_to (-0.1, 0.1)) * params->mrt;
 305
 306       client_state->due_time = current_time + client_state->sleep_interval;
 307
 308       if (params->mrd != 0
 309           && current_time > client_state->start_time + params->mrd)
 310         stop_sending_client_message (vm, client_state);
 311       else
 312         *due_time = client_state->due_time;
 313     }
 314
 315   return client_state->keep_sending_client_message;
 316 }
 317
 318 static uword
 319 send_dhcp6_pd_client_message_process (vlib_main_t * vm,
 320                                       vlib_node_runtime_t * rt,
 321                                       vlib_frame_t * f0)
 322 {
 323   dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main;
 324   dhcp6_pd_client_state_t *client_state;
 325   uword *event_data = 0;
 326   f64 sleep_time = 1e9;
 327   f64 current_time;
 328   f64 due_time;
 329   f64 dt = 0;
 330   int i;
 331
 332   while (true)
 333     {
 334       vlib_process_wait_for_event_or_clock (vm, sleep_time);
 335       vlib_process_get_events (vm, &event_data);
 336       vec_reset_length (event_data);
 337
 338       current_time = vlib_time_now (vm);
 339       do
 340         {
 341           due_time = current_time + 1e9;
 342           for (i = 0; i < vec_len (cm->client_state_by_sw_if_index); i++)
 343             {
 344               client_state = &cm->client_state_by_sw_if_index[i];
 345               if (!client_state->entry_valid)
 346                 continue;
 347               if (check_pd_send_client_message
 348                   (vm, client_state, current_time, &dt) && (dt < due_time))
 349                 due_time = dt;
 350             }
 351           current_time = vlib_time_now (vm);
 352         }
 353       while (due_time < current_time);
 354
 355       sleep_time = due_time - current_time;
 356     }
 357
 358   return 0;
 359 }
 360
 361 /* *INDENT-OFF* */
 362 VLIB_REGISTER_NODE (send_dhcp6_pd_client_message_process_node, static) = {
 363     .function = send_dhcp6_pd_client_message_process,
 364     .type = VLIB_NODE_TYPE_PROCESS,
 365     .name = "send-dhcp6-pd-client-message-process",
 366 };
 367 /* *INDENT-ON* */
 368
 369 void
 370 dhcp6_pd_send_client_message (vlib_main_t * vm, u32 sw_if_index, u8 stop,
 371                               dhcp6_pd_send_client_message_params_t * params)
 372 {
 373   dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main;
 374   dhcp6_pd_client_state_t *client_state = 0;
 375   dhcp6_pd_client_state_t empty_state = {
 376     0,
 377   };
 378
 379   ASSERT (~0 != sw_if_index);
 380
 381   vec_validate_init_empty (cm->client_state_by_sw_if_index, sw_if_index,
 382                            empty_state);
 383   client_state = &cm->client_state_by_sw_if_index[sw_if_index];
 384   if (!client_state->entry_valid)
 385     {
 386       client_state->entry_valid = 1;
 387       client_state->adj_index = ~0;
 388     }
 389
 390   stop_sending_client_message (vm, client_state);
 391
 392   if (!stop)
 393     {
 394       client_state->keep_sending_client_message = 1;
 395       vec_free (client_state->params.prefixes);
 396       client_state->params = *params;
 397       client_state->params.prefixes = vec_dup (params->prefixes);
 398       client_state->n_left = params->mrc;
 399       client_state->start_time = vlib_time_now (vm);
 400       client_state->sleep_interval =
 401         (1 + random_f64_from_to (-0.1, 0.1)) * params->irt;
 402       client_state->due_time = 0;       /* send first packet ASAP */
 403       client_state->transaction_id = random_u32 (&cm->seed) & 0x00ffffff;
 404       client_state->buffer =
 405         create_buffer_for_client_message (vm, sw_if_index, client_state,
 406                                           params->msg_type);
 407       if (!client_state->buffer)
 408         client_state->keep_sending_client_message = 0;
 409       else
 410         vlib_process_signal_event (vm,
 411                                    send_dhcp6_pd_client_message_process_node.index,
 412                                    1, 0);
 413     }
 414 }
 415
 416 static clib_error_t *
 417 dhcp6_pd_client_init (vlib_main_t * vm)
 418 {
 419   dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main;
 420
 421   cm->vlib_main = vm;
 422   cm->vnet_main = vnet_get_main ();
 423   cm->publisher_node = ~0;
 424   cm->seed = (u32) clib_cpu_time_now ();
 425
 426   return 0;
 427 }
 428
 429 VLIB_INIT_FUNCTION (dhcp6_pd_client_init);
 430
 431 /*
 432  * fd.io coding-style-patch-verification: ON
 433  *
 434  * Local Variables:
 435  * eval: (c-set-style "gnu")
 436  * End:
 437  */