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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
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>
28 dhcp6_pd_client_main_t dhcp6_pd_client_main;
29 dhcp6_pd_client_public_main_t dhcp6_pd_client_public_main;
32 signal_report (prefix_report_t * r)
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;
39 if (ni == (uword) ~ 0)
42 vlib_process_signal_event_data (vm, ni, et, 1, sizeof *q);
48 dhcp6_pd_publish_report (prefix_report_t * r)
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);
56 dhcp6_pd_set_publisher_node (uword node_index, uword event_type)
58 dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main;
59 cm->publisher_node = node_index;
60 cm->publisher_et = event_type;
64 stop_sending_client_message (vlib_main_t * vm,
65 dhcp6_pd_client_state_t * client_state)
69 client_state->keep_sending_client_message = 0;
70 vec_free (client_state->params.prefixes);
71 if (client_state->buffer)
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;
81 static vlib_buffer_t *
82 create_buffer_for_client_message (vlib_main_t * vm,
84 dhcp6_pd_client_state_t
85 * client_state, u32 type)
87 dhcp6_client_common_main_t *ccm = &dhcp6_client_common_main;
92 dhcpv6_header_t *dhcp;
93 const ip6_address_t *src_addr;
95 client_state->transaction_start = vlib_time_now (vm);
100 * Note: do NOT psychoanalyze link-state here.
101 * If the interface is down, let the driver turf the packet.
104 /* Get a link-local address */
105 src_addr = ip6_get_link_local_address (sw_if_index);
107 if (src_addr->as_u8[0] != 0xfe)
109 clib_warning ("Could not find source address to send DHCPv6 packet");
113 if (vlib_buffer_alloc (vm, &bi, 1) != 1)
115 clib_warning ("Buffer allocation failed");
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,
125 vnet_buffer (b)->ip.adj_index[VLIB_TX] = client_state->adj_index;
126 b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
128 ip = (ip6_header_t *) vlib_buffer_get_current (b);
129 udp = (udp_header_t *) (ip + 1);
130 dhcp = (dhcpv6_header_t *) (udp + 1);
132 ip->src_address = *src_addr;
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;
139 udp->src_port = clib_host_to_net_u16 (DHCPV6_CLIENT_PORT);
140 udp->dst_port = clib_host_to_net_u16 (DHCPV6_SERVER_PORT);
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;
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)
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;
164 if (client_state->params.server_index != ~0)
167 &ccm->server_ids[client_state->params.server_index];
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;
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);
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);
193 n_prefixes = vec_len (client_state->params.prefixes);
196 clib_host_to_net_u16 (sizeof (*ia_hdr) +
197 n_prefixes * sizeof (*opt_pd) -
198 sizeof (ia_hdr->opt));
200 for (i = 0; i < n_prefixes; i++)
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);
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);
217 clib_warning ("State not implemented");
220 dhcp_opt_len = ((u8 *) d) - dhcp->data;
222 clib_host_to_net_u16 (sizeof (*udp) + sizeof (*dhcp) + dhcp_opt_len);
223 ip->payload_length = udp->length;
225 sizeof (*ip) + sizeof (*udp) + sizeof (*dhcp) + dhcp_opt_len;
227 ip->dst_address = all_dhcp6_relay_agents_and_servers;
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)
245 int bogus_length = 0;
247 dhcp6_pd_send_client_message_params_t *params;
249 f64 now = vlib_time_now (vm);
251 if (!client_state->keep_sending_client_message)
254 params = &client_state->params;
256 if (client_state->due_time > current_time)
258 *due_time = client_state->due_time;
262 p0 = client_state->buffer;
264 next_index = ip6_rewrite_mcast_node.index;
266 c0 = vlib_buffer_copy (vm, p0);
268 return client_state->keep_sending_client_message;
270 ci0 = vlib_get_buffer_index (vm, c0);
272 ip = (ip6_header_t *) vlib_buffer_get_current (c0);
273 udp = (udp_header_t *) (ip + 1);
275 u16 *elapsed_field = (u16 *) ((void *) ip + client_state->elapsed_pos);
277 clib_host_to_net_u16 ((u16)
278 ((now - client_state->transaction_start) * 100));
282 ip6_tcp_udp_icmp_compute_checksum (vm, 0, ip, &bogus_length);
284 f = vlib_get_frame_to_node (vm, next_index);
285 to_next = vlib_frame_vector_args (f);
288 vlib_put_frame_to_node (vm, next_index, f);
290 if (params->mrc != 0 && --client_state->n_left == 0)
291 stop_sending_client_message (vm, client_state);
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;
300 client_state->due_time = current_time + client_state->sleep_interval;
303 && current_time > client_state->start_time + params->mrd)
304 stop_sending_client_message (vm, client_state);
306 *due_time = client_state->due_time;
309 return client_state->keep_sending_client_message;
313 send_dhcp6_pd_client_message_process (vlib_main_t * vm,
314 vlib_node_runtime_t * rt,
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;
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);
332 current_time = vlib_time_now (vm);
335 due_time = current_time + 1e9;
336 for (i = 0; i < vec_len (cm->client_state_by_sw_if_index); i++)
338 client_state = &cm->client_state_by_sw_if_index[i];
339 if (!client_state->entry_valid)
341 if (check_pd_send_client_message
342 (vm, client_state, current_time, &dt) && (dt < due_time))
345 current_time = vlib_time_now (vm);
347 while (due_time < current_time);
349 sleep_time = due_time - current_time;
356 VLIB_REGISTER_NODE (send_dhcp6_pd_client_message_process_node, static) = {
357 .function = send_dhcp6_pd_client_message_process,
358 .type = VLIB_NODE_TYPE_PROCESS,
359 .name = "send-dhcp6-pd-client-message-process",
364 dhcp6_pd_send_client_message (vlib_main_t * vm, u32 sw_if_index, u8 stop,
365 dhcp6_pd_send_client_message_params_t * params)
367 dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main;
368 dhcp6_pd_client_state_t *client_state = 0;
369 dhcp6_pd_client_state_t empty_state = {
373 ASSERT (~0 != sw_if_index);
375 vec_validate_init_empty (cm->client_state_by_sw_if_index, sw_if_index,
377 client_state = &cm->client_state_by_sw_if_index[sw_if_index];
378 if (!client_state->entry_valid)
380 client_state->entry_valid = 1;
381 client_state->adj_index = ~0;
384 stop_sending_client_message (vm, client_state);
388 client_state->keep_sending_client_message = 1;
389 vec_free (client_state->params.prefixes);
390 client_state->params = *params;
391 client_state->params.prefixes = vec_dup (params->prefixes);
392 client_state->n_left = params->mrc;
393 client_state->start_time = vlib_time_now (vm);
394 client_state->sleep_interval =
395 (1 + random_f64_from_to (-0.1, 0.1)) * params->irt;
396 client_state->due_time = 0; /* send first packet ASAP */
397 client_state->transaction_id = random_u32 (&cm->seed) & 0x00ffffff;
398 client_state->buffer =
399 create_buffer_for_client_message (vm, sw_if_index, client_state,
401 if (client_state->buffer)
402 vlib_process_signal_event
403 (vm, send_dhcp6_pd_client_message_process_node.index, 1, 0);
407 static clib_error_t *
408 dhcp6_pd_client_init (vlib_main_t * vm)
410 dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main;
413 cm->vnet_main = vnet_get_main ();
414 cm->publisher_node = ~0;
415 cm->seed = (u32) clib_cpu_time_now ();
420 VLIB_INIT_FUNCTION (dhcp6_pd_client_init);
423 * fd.io coding-style-patch-verification: ON
426 * eval: (c-set-style "gnu")