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