2 * dhcp6_proxy_node.c: dhcpv6 proxy node processing
4 * Copyright (c) 2013 Cisco and/or its affiliates.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
18 #include <vlib/vlib.h>
19 #include <dhcp/dhcp_proxy.h>
20 #include <dhcp/dhcp6_packet.h>
21 #include <vnet/mfib/mfib_table.h>
22 #include <vnet/mfib/ip6_mfib.h>
23 #include <vnet/fib/fib.h>
25 static char *dhcpv6_proxy_error_strings[] = {
26 #define dhcpv6_proxy_error(n,s) s,
27 #include <dhcp/dhcp6_proxy_error.def>
28 #undef dhcpv6_proxy_error
31 #define foreach_dhcpv6_proxy_to_server_input_next \
32 _ (DROP, "error-drop") \
33 _ (LOOKUP, "ip6-lookup") \
34 _ (SEND_TO_CLIENT, "dhcpv6-proxy-to-client")
39 #define _(s,n) DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_##s,
40 foreach_dhcpv6_proxy_to_server_input_next
42 DHCPV6_PROXY_TO_SERVER_INPUT_N_NEXT,
43 } dhcpv6_proxy_to_server_input_next_t;
47 /* 0 => to server, 1 => to client */
52 u32 original_sw_if_index;
53 } dhcpv6_proxy_trace_t;
55 static vlib_node_registration_t dhcpv6_proxy_to_server_node;
56 static vlib_node_registration_t dhcpv6_proxy_to_client_node;
58 /* all DHCP servers address */
59 static ip6_address_t all_dhcpv6_server_address;
60 static ip6_address_t all_dhcpv6_server_relay_agent_address;
63 format_dhcpv6_proxy_trace (u8 * s, va_list * args)
65 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
66 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
67 dhcpv6_proxy_trace_t *t = va_arg (*args, dhcpv6_proxy_trace_t *);
70 s = format (s, "DHCPV6 proxy: sent to server %U",
71 format_ip6_address, &t->packet_data, sizeof (ip6_address_t));
73 s = format (s, "DHCPV6 proxy: sent to client from %U",
74 format_ip6_address, &t->packet_data, sizeof (ip6_address_t));
75 if (t->error != (u32) ~ 0)
76 s = format (s, " error: %s\n", dhcpv6_proxy_error_strings[t->error]);
78 s = format (s, " original_sw_if_index: %d, sw_if_index: %d\n",
79 t->original_sw_if_index, t->sw_if_index);
85 format_dhcpv6_proxy_header_with_length (u8 * s, va_list * args)
87 dhcpv6_header_t *h = va_arg (*args, dhcpv6_header_t *);
88 u32 max_header_bytes = va_arg (*args, u32);
91 header_bytes = sizeof (h[0]);
92 if (max_header_bytes != 0 && header_bytes > max_header_bytes)
93 return format (s, "dhcpv6 header truncated");
95 s = format (s, "DHCPV6 Proxy");
100 /* get first interface address */
101 static ip6_address_t *
102 ip6_interface_first_global_or_site_address (ip6_main_t * im, u32 sw_if_index)
104 ip_lookup_main_t *lm = &im->lookup_main;
105 ip_interface_address_t *ia = 0;
106 ip6_address_t *result = 0;
108 foreach_ip_interface_address (lm, ia, sw_if_index,
109 1 /* honor unnumbered */,
111 ip6_address_t * a = ip_interface_address_get_address (lm, ia);
112 if ((a->as_u8[0] & 0xe0) == 0x20 ||
113 (a->as_u8[0] & 0xfe) == 0xfc) {
122 copy_ip6_address (ip6_address_t * dst, ip6_address_t * src)
124 dst->as_u64[0] = src->as_u64[0];
125 dst->as_u64[1] = src->as_u64[1];
129 dhcpv6_proxy_to_server_input (vlib_main_t * vm,
130 vlib_node_runtime_t * node,
131 vlib_frame_t * from_frame)
133 u32 n_left_from, next_index, *from, *to_next;
134 dhcp_proxy_main_t *dpm = &dhcp_proxy_main;
135 from = vlib_frame_vector_args (from_frame);
136 n_left_from = from_frame->n_vectors;
137 u32 pkts_to_server = 0, pkts_to_client = 0;
138 u32 pkts_no_interface_address = 0;
139 u32 pkts_no_src_address = 0;
140 u32 pkts_wrong_msg_type = 0;
141 u32 pkts_too_big = 0;
142 ip6_main_t *im = &ip6_main;
146 dhcp_server_t *server;
147 u32 rx_fib_idx = 0, server_fib_idx = 0;
149 next_index = node->cached_next_index;
151 while (n_left_from > 0)
155 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
157 while (n_left_from > 0 && n_left_to_next > 0)
159 vnet_main_t *vnm = vnet_get_main ();
161 u32 rx_sw_if_index = 0;
162 vnet_sw_interface_t *swif;
165 udp_header_t *u0, *u1;
166 dhcpv6_header_t *h0; // client msg hdr
167 ip6_header_t *ip0, *ip1;
168 ip6_address_t _ia0, *ia0 = &_ia0;
170 u32 error0 = (u32) ~ 0;
171 dhcpv6_option_t *fwd_opt;
172 dhcpv6_relay_hdr_t *r1;
174 dhcpv6_int_id_t *id1;
176 dhcpv6_client_mac_t *cmac; // client mac
177 ethernet_header_t *e_h0;
178 u8 client_src_mac[6];
186 b0 = vlib_get_buffer (vm, bi0);
188 h0 = vlib_buffer_get_current (b0);
191 * udp_local hands us the DHCPV6 header.
193 u0 = (void *) h0 - (sizeof (*u0));
194 ip0 = (void *) u0 - (sizeof (*ip0));
195 e_h0 = (void *) ip0 - ethernet_buffer_header_size (b0);
197 clib_memcpy (client_src_mac, e_h0->src_address, 6);
199 switch (h0->msg_type)
201 case DHCPV6_MSG_SOLICIT:
202 case DHCPV6_MSG_REQUEST:
203 case DHCPV6_MSG_CONFIRM:
204 case DHCPV6_MSG_RENEW:
205 case DHCPV6_MSG_REBIND:
206 case DHCPV6_MSG_RELEASE:
207 case DHCPV6_MSG_DECLINE:
208 case DHCPV6_MSG_INFORMATION_REQUEST:
209 case DHCPV6_MSG_RELAY_FORW:
212 case DHCPV6_MSG_RELAY_REPL:
214 next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_SEND_TO_CLIENT;
219 /* drop the packet */
220 pkts_wrong_msg_type++;
221 error0 = DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE;
222 next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
227 /* Send to DHCPV6 server via the configured FIB */
228 rx_sw_if_index = sw_if_index =
229 vnet_buffer (b0)->sw_if_index[VLIB_RX];
230 rx_fib_idx = im->mfib_index_by_sw_if_index[rx_sw_if_index];
231 proxy = dhcp_get_proxy (dpm, rx_fib_idx, FIB_PROTOCOL_IP6);
233 if (PREDICT_FALSE (NULL == proxy))
235 error0 = DHCPV6_PROXY_ERROR_NO_SERVER;
236 next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
240 server = &proxy->dhcp_servers[0];
241 server_fib_idx = server->server_fib_index;
242 vnet_buffer (b0)->sw_if_index[VLIB_TX] = server_fib_idx;
245 /* relay-option header pointer */
246 vlib_buffer_advance (b0, -(sizeof (*fwd_opt)));
247 fwd_opt = vlib_buffer_get_current (b0);
248 /* relay message header pointer */
249 vlib_buffer_advance (b0, -(sizeof (*r1)));
250 r1 = vlib_buffer_get_current (b0);
252 vlib_buffer_advance (b0, -(sizeof (*u1)));
253 u1 = vlib_buffer_get_current (b0);
255 vlib_buffer_advance (b0, -(sizeof (*ip1)));
256 ip1 = vlib_buffer_get_current (b0);
258 /* fill in all that rubbish... */
259 len = clib_net_to_host_u16 (u0->length) - sizeof (udp_header_t);
260 copy_ip6_address (&r1->peer_addr, &ip0->src_address);
262 r1->msg_type = DHCPV6_MSG_RELAY_FORW;
263 fwd_opt->length = clib_host_to_net_u16 (len);
264 fwd_opt->option = clib_host_to_net_u16 (DHCPV6_OPTION_RELAY_MSG);
268 (h0->msg_type != DHCPV6_MSG_RELAY_FORW) ? 0 : r1->hop_count;
270 if (PREDICT_FALSE (r1->hop_count >= HOP_COUNT_LIMIT))
272 error0 = DHCPV6_RELAY_PKT_DROP_MAX_HOPS;
273 next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
278 /* If relay-fwd and src address is site or global unicast address */
279 if (h0->msg_type == DHCPV6_MSG_RELAY_FORW &&
280 ((ip0->src_address.as_u8[0] & 0xe0) == 0x20 ||
281 (ip0->src_address.as_u8[0] & 0xfe) == 0xfc))
283 /* Set link address to zero */
284 r1->link_addr.as_u64[0] = 0;
285 r1->link_addr.as_u64[1] = 0;
286 goto link_address_set;
289 /* if receiving interface is unnumbered, use receiving interface
290 * IP address as link address, otherwise use the loopback interface
291 * IP address as link address.
294 swif = vnet_get_sw_interface (vnm, rx_sw_if_index);
295 if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
296 sw_if_index = swif->unnumbered_sw_if_index;
299 ip6_interface_first_global_or_site_address (&ip6_main,
303 error0 = DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS;
304 next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
305 pkts_no_interface_address++;
309 copy_ip6_address (&r1->link_addr, ia0);
313 if ((b0->current_data + b0->current_length + sizeof (*id1) +
314 sizeof (*vss1) + sizeof (*cmac)) >
315 vlib_buffer_get_default_data_size (vm))
317 error0 = DHCPV6_PROXY_ERROR_PKT_TOO_BIG;
318 next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
323 id1 = (dhcpv6_int_id_t *) (((uword) ip1) + b0->current_length);
324 b0->current_length += (sizeof (*id1));
326 id1->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_INTERFACE_ID);
327 id1->opt.length = clib_host_to_net_u16 (sizeof (rx_sw_if_index));
328 id1->int_idx = clib_host_to_net_u32 (rx_sw_if_index);
331 if (h0->msg_type != DHCPV6_MSG_RELAY_FORW)
334 (dhcpv6_client_mac_t *) (((uword) ip1) + b0->current_length);
335 b0->current_length += (sizeof (*cmac));
336 cmac->opt.length = clib_host_to_net_u16 (sizeof (*cmac) -
340 (DHCPV6_OPTION_CLIENT_LINK_LAYER_ADDRESS);
341 cmac->link_type = clib_host_to_net_u16 (1); /* ethernet */
342 clib_memcpy (cmac->data, client_src_mac, 6);
343 u1->length += sizeof (*cmac);
346 vss = dhcp_get_vss_info (dpm, rx_fib_idx, FIB_PROTOCOL_IP6);
350 u16 id_len; /* length of VPN ID */
351 u16 type_len = sizeof (vss1->vss_type);
353 vss1 = (dhcpv6_vss_t *) (((uword) ip1) + b0->current_length);
354 vss1->vss_type = vss->vss_type;
355 if (vss->vss_type == VSS_TYPE_VPN_ID)
357 id_len = sizeof (vss->vpn_id); /* vpn_id is 7 bytes */
358 memcpy (vss1->data, vss->vpn_id, id_len);
360 else if (vss->vss_type == VSS_TYPE_ASCII)
362 id_len = vec_len (vss->vpn_ascii_id);
363 memcpy (vss1->data, vss->vpn_ascii_id, id_len);
365 else /* must be VSS_TYPE_DEFAULT, no VPN ID */
368 vss1->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_VSS);
369 vss1->opt.length = clib_host_to_net_u16 (type_len + id_len);
370 u1->length += type_len + id_len + sizeof (vss1->opt);
371 b0->current_length += type_len + id_len + sizeof (vss1->opt);
376 u1->src_port = clib_host_to_net_u16 (UDP_DST_PORT_dhcpv6_to_client);
377 u1->dst_port = clib_host_to_net_u16 (UDP_DST_PORT_dhcpv6_to_server);
380 clib_host_to_net_u16 (clib_net_to_host_u16 (fwd_opt->length) +
381 sizeof (*r1) + sizeof (*fwd_opt) +
382 sizeof (*u1) + sizeof (*id1) + u1->length);
384 clib_memset (ip1, 0, sizeof (*ip1));
385 ip1->ip_version_traffic_class_and_flow_label = 0x60;
386 ip1->payload_length = u1->length;
387 ip1->protocol = PROTO_UDP;
388 ip1->hop_limit = HOP_COUNT_LIMIT;
389 src = ((server->dhcp_server.ip6.as_u64[0] ||
390 server->dhcp_server.ip6.as_u64[1]) ?
391 &server->dhcp_server.ip6 : &all_dhcpv6_server_address);
392 copy_ip6_address (&ip1->dst_address, src);
395 ia0 = ip6_interface_first_global_or_site_address
396 (&ip6_main, vnet_buffer (b0)->sw_if_index[VLIB_RX]);
398 src = (proxy->dhcp_src_address.ip6.as_u64[0] ||
399 proxy->dhcp_src_address.ip6.as_u64[1]) ?
400 &proxy->dhcp_src_address.ip6 : ia0;
403 error0 = DHCPV6_PROXY_ERROR_NO_SRC_ADDRESS;
404 next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
405 pkts_no_src_address++;
409 copy_ip6_address (&ip1->src_address, src);
412 u1->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip1,
414 ASSERT (bogus_length == 0);
416 next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP;
418 is_solicit = (DHCPV6_MSG_SOLICIT == h0->msg_type);
421 * If we have multiple servers configured and this is the
422 * client's discover message, then send copies to each of
425 if (is_solicit && vec_len (proxy->dhcp_servers) > 1)
429 for (ii = 1; ii < vec_len (proxy->dhcp_servers); ii++)
434 c0 = vlib_buffer_copy (vm, b0);
437 vlib_node_increment_counter
438 (vm, dhcpv6_proxy_to_server_node.index,
439 DHCPV6_PROXY_ERROR_ALLOC_FAIL, 1);
442 ci0 = vlib_get_buffer_index (vm, c0);
443 server = &proxy->dhcp_servers[ii];
445 ip0 = vlib_buffer_get_current (c0);
447 src = ((server->dhcp_server.ip6.as_u64[0] ||
448 server->dhcp_server.ip6.as_u64[1]) ?
449 &server->dhcp_server.ip6 :
450 &all_dhcpv6_server_address);
451 copy_ip6_address (&ip1->dst_address, src);
457 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
458 to_next, n_left_to_next,
461 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
463 dhcpv6_proxy_trace_t *tr;
465 tr = vlib_add_trace (vm, node, c0, sizeof (*tr));
466 tr->which = 0; /* to server */
468 tr->original_sw_if_index = rx_sw_if_index;
469 tr->sw_if_index = sw_if_index;
470 if (next0 == DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP)
471 copy_ip6_address ((ip6_address_t *) &
473 &server->dhcp_server.ip6);
476 if (PREDICT_FALSE (0 == n_left_to_next))
478 vlib_put_next_frame (vm, node, next_index,
480 vlib_get_next_frame (vm, node, next_index,
481 to_next, n_left_to_next);
487 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
489 dhcpv6_proxy_trace_t *tr = vlib_add_trace (vm, node,
491 tr->which = 0; /* to server */
493 tr->original_sw_if_index = rx_sw_if_index;
494 tr->sw_if_index = sw_if_index;
495 if (DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP == next0)
496 copy_ip6_address ((ip6_address_t *) & tr->packet_data[0],
497 &server->dhcp_server.ip6);
505 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
506 to_next, n_left_to_next,
510 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
513 vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
514 DHCPV6_PROXY_ERROR_RELAY_TO_CLIENT,
516 vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
517 DHCPV6_PROXY_ERROR_RELAY_TO_SERVER,
519 vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
520 DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS,
521 pkts_no_interface_address);
522 vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
523 DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE,
524 pkts_wrong_msg_type);
525 vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
526 DHCPV6_PROXY_ERROR_NO_SRC_ADDRESS,
527 pkts_no_src_address);
528 vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
529 DHCPV6_PROXY_ERROR_PKT_TOO_BIG, pkts_too_big);
530 return from_frame->n_vectors;
533 VLIB_REGISTER_NODE (dhcpv6_proxy_to_server_node, static) = {
534 .function = dhcpv6_proxy_to_server_input,
535 .name = "dhcpv6-proxy-to-server",
536 /* Takes a vector of packets. */
537 .vector_size = sizeof (u32),
539 .n_errors = DHCPV6_PROXY_N_ERROR,
540 .error_strings = dhcpv6_proxy_error_strings,
542 .n_next_nodes = DHCPV6_PROXY_TO_SERVER_INPUT_N_NEXT,
544 #define _(s,n) [DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_##s] = n,
545 foreach_dhcpv6_proxy_to_server_input_next
549 .format_buffer = format_dhcpv6_proxy_header_with_length,
550 .format_trace = format_dhcpv6_proxy_trace,
552 .unformat_buffer = unformat_dhcpv6_proxy_header,
557 dhcpv6_proxy_to_client_input (vlib_main_t * vm,
558 vlib_node_runtime_t * node,
559 vlib_frame_t * from_frame)
562 u32 n_left_from, *from;
563 ethernet_main_t *em = vnet_get_ethernet_main ();
564 dhcp_proxy_main_t *dm = &dhcp_proxy_main;
566 dhcp_server_t *server;
567 vnet_main_t *vnm = vnet_get_main ();
570 from = vlib_frame_vector_args (from_frame);
571 n_left_from = from_frame->n_vectors;
573 while (n_left_from > 0)
577 udp_header_t *u0, *u1 = 0;
578 dhcpv6_relay_hdr_t *h0;
579 ip6_header_t *ip1 = 0, *ip0;
580 ip6_address_t *ia0 = 0;
581 ip6_address_t client_address;
582 ethernet_interface_t *ei0;
583 ethernet_header_t *mac0;
584 vnet_hw_interface_t *hi0;
587 u32 sw_if_index = ~0;
588 u32 original_sw_if_index = ~0;
589 vnet_sw_interface_t *si0;
590 u32 inner_vlan = (u32) ~ 0;
591 u32 outer_vlan = (u32) ~ 0;
592 u32 error0 = (u32) ~ 0;
593 vnet_sw_interface_t *swif;
594 dhcpv6_option_t *r0 = 0, *o;
596 u8 interface_opt_flag = 0;
597 u8 relay_msg_opt_flag = 0;
598 ip6_main_t *im = &ip6_main;
599 u32 server_fib_idx, client_fib_idx;
605 b0 = vlib_get_buffer (vm, bi0);
606 h0 = vlib_buffer_get_current (b0);
608 if (DHCPV6_MSG_RELAY_REPL != h0->msg_type)
610 error0 = DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE;
613 vlib_node_increment_counter (vm, dhcpv6_proxy_to_client_node.index,
616 f0 = vlib_get_frame_to_node (vm, dm->error_drop_node_index);
617 to_next0 = vlib_frame_vector_args (f0);
620 vlib_put_frame_to_node (vm, dm->error_drop_node_index, f0);
623 /* hop count seems not need to be checked */
624 if (HOP_COUNT_LIMIT < h0->hop_count)
626 error0 = DHCPV6_RELAY_PKT_DROP_MAX_HOPS;
629 u0 = (void *) h0 - (sizeof (*u0));
630 ip0 = (void *) u0 - (sizeof (*ip0));
632 vlib_buffer_advance (b0, sizeof (*h0));
633 o = vlib_buffer_get_current (b0);
635 /* Parse through TLVs looking for option 18 (DHCPV6_OPTION_INTERFACE_ID)
636 _and_ option 9 (DHCPV6_OPTION_RELAY_MSG) option which must be there.
637 Currently assuming no other options need to be processed
638 The interface-ID is the FIB number we need
639 to track down the client-facing interface */
641 while ((u8 *) o < (b0->data + b0->current_data + b0->current_length))
643 if (DHCPV6_OPTION_INTERFACE_ID == clib_net_to_host_u16 (o->option))
645 interface_opt_flag = 1;
646 if (clib_net_to_host_u16 (o->length) == sizeof (sw_if_index))
648 clib_net_to_host_u32 (((dhcpv6_int_id_t *) o)->int_idx);
649 if (sw_if_index >= vec_len (im->fib_index_by_sw_if_index))
651 error0 = DHCPV6_PROXY_ERROR_WRONG_INTERFACE_ID_OPTION;
655 if (DHCPV6_OPTION_RELAY_MSG == clib_net_to_host_u16 (o->option))
657 relay_msg_opt_flag = 1;
658 r0 = vlib_buffer_get_current (b0);
660 if ((relay_msg_opt_flag == 1) && (interface_opt_flag == 1))
662 vlib_buffer_advance (b0,
664 clib_net_to_host_u16 (o->length));
666 (dhcpv6_option_t *) (((uword) o) +
667 clib_net_to_host_u16 (o->length) +
671 if ((relay_msg_opt_flag == 0) || (r0 == 0))
673 error0 = DHCPV6_PROXY_ERROR_NO_RELAY_MESSAGE_OPTION;
677 if ((u32) ~ 0 == sw_if_index)
679 error0 = DHCPV6_PROXY_ERROR_NO_CIRCUIT_ID_OPTION;
683 //Advance buffer to start of encapsulated DHCPv6 message
684 vlib_buffer_advance (b0, sizeof (*r0));
686 client_fib_idx = im->mfib_index_by_sw_if_index[sw_if_index];
687 proxy = dhcp_get_proxy (dm, client_fib_idx, FIB_PROTOCOL_IP6);
691 error0 = DHCPV6_PROXY_ERROR_NO_SERVER;
695 server_fib_idx = im->fib_index_by_sw_if_index
696 [vnet_buffer (b0)->sw_if_index[VLIB_RX]];
698 vec_foreach (server, proxy->dhcp_servers)
700 if (server_fib_idx == server->server_fib_index &&
701 ip0->src_address.as_u64[0] == server->dhcp_server.ip6.as_u64[0] &&
702 ip0->src_address.as_u64[1] == server->dhcp_server.ip6.as_u64[1])
708 //drop packet if not from server with configured address or FIB
709 error0 = DHCPV6_PROXY_ERROR_BAD_SVR_FIB_OR_ADDRESS;
713 vnet_buffer (b0)->sw_if_index[VLIB_TX] = original_sw_if_index
716 swif = vnet_get_sw_interface (vnm, original_sw_if_index);
717 if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
718 sw_if_index = swif->unnumbered_sw_if_index;
722 * udp_local hands us the DHCPV6 header, need udp hdr,
723 * ip hdr to relay to client
725 vlib_buffer_advance (b0, -(sizeof (*u1)));
726 u1 = vlib_buffer_get_current (b0);
728 vlib_buffer_advance (b0, -(sizeof (*ip1)));
729 ip1 = vlib_buffer_get_current (b0);
731 copy_ip6_address (&client_address, &h0->peer_addr);
733 ia0 = ip6_interface_first_address (&ip6_main, sw_if_index);
736 error0 = DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS;
740 len = clib_net_to_host_u16 (r0->length);
741 clib_memset (ip1, 0, sizeof (*ip1));
742 copy_ip6_address (&ip1->dst_address, &client_address);
744 u1->src_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcpv6_to_server);
745 u1->dst_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcpv6_to_client);
746 u1->length = clib_host_to_net_u16 (len + sizeof (udp_header_t));
748 ip1->ip_version_traffic_class_and_flow_label =
749 ip0->ip_version_traffic_class_and_flow_label & 0x00000fff;
750 ip1->payload_length = u1->length;
751 ip1->protocol = PROTO_UDP;
752 ip1->hop_limit = HOP_COUNT_LIMIT;
753 copy_ip6_address (&ip1->src_address, ia0);
755 u1->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip1,
757 ASSERT (bogus_length == 0);
759 vlib_buffer_advance (b0, -(sizeof (ethernet_header_t)));
760 si0 = vnet_get_sw_interface (vnm, original_sw_if_index);
761 if (si0->type == VNET_SW_INTERFACE_TYPE_SUB)
763 if (si0->sub.eth.flags.one_tag == 1)
765 vlib_buffer_advance (b0, -4 /* space for 1 VLAN tag */ );
766 outer_vlan = (si0->sub.eth.outer_vlan_id << 16) | 0x86dd;
768 else if (si0->sub.eth.flags.two_tags == 1)
770 vlib_buffer_advance (b0, -8 /* space for 2 VLAN tag */ );
771 outer_vlan = (si0->sub.eth.outer_vlan_id << 16) | 0x8100;
772 inner_vlan = (si0->sub.eth.inner_vlan_id << 16) | 0x86dd;
776 mac0 = vlib_buffer_get_current (b0);
778 hi0 = vnet_get_sup_hw_interface (vnm, original_sw_if_index);
779 ei0 = pool_elt_at_index (em->interfaces, hi0->hw_instance);
780 clib_memcpy (mac0->src_address, &ei0->address,
781 sizeof (mac0->src_address));
782 clib_memset (&mac0->dst_address, 0xff, sizeof (mac0->dst_address));
784 if (si0->type == VNET_SW_INTERFACE_TYPE_SUB && outer_vlan != (u32) ~ 0)
786 mac0->type = (si0->sub.eth.flags.dot1ad == 1) ?
787 clib_net_to_host_u16 (0x88a8) : clib_net_to_host_u16 (0x8100);
788 u32 *vlan_tag = (u32 *) (mac0 + 1);
789 *vlan_tag = clib_host_to_net_u32 (outer_vlan);
790 if (inner_vlan != (u32) ~ 0)
792 u32 *inner_vlan_tag = (u32 *) (vlan_tag + 1);
793 *inner_vlan_tag = clib_host_to_net_u32 (inner_vlan);
798 mac0->type = clib_net_to_host_u16 (0x86dd);
801 /* $$$ consider adding a dynamic next to the graph node, for performance */
802 f0 = vlib_get_frame_to_node (vm, hi0->output_node_index);
803 to_next0 = vlib_frame_vector_args (f0);
806 vlib_put_frame_to_node (vm, hi0->output_node_index, f0);
809 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
811 dhcpv6_proxy_trace_t *tr = vlib_add_trace (vm, node,
813 tr->which = 1; /* to client */
815 copy_ip6_address ((ip6_address_t *) tr->packet_data, ia0);
817 tr->original_sw_if_index = original_sw_if_index;
818 tr->sw_if_index = sw_if_index;
821 return from_frame->n_vectors;
825 VLIB_REGISTER_NODE (dhcpv6_proxy_to_client_node, static) = {
826 .function = dhcpv6_proxy_to_client_input,
827 .name = "dhcpv6-proxy-to-client",
828 /* Takes a vector of packets. */
829 .vector_size = sizeof (u32),
831 .n_errors = DHCPV6_PROXY_N_ERROR,
832 .error_strings = dhcpv6_proxy_error_strings,
833 .format_buffer = format_dhcpv6_proxy_header_with_length,
834 .format_trace = format_dhcpv6_proxy_trace,
836 .unformat_buffer = unformat_dhcpv6_proxy_header,
840 static clib_error_t *
841 dhcp6_proxy_init (vlib_main_t * vm)
843 dhcp_proxy_main_t *dm = &dhcp_proxy_main;
844 vlib_node_t *error_drop_node;
846 error_drop_node = vlib_get_node_by_name (vm, (u8 *) "error-drop");
847 dm->error_drop_node_index = error_drop_node->index;
849 /* RFC says this is the dhcpv6 server address */
850 all_dhcpv6_server_address.as_u64[0] =
851 clib_host_to_net_u64 (0xFF05000000000000);
852 all_dhcpv6_server_address.as_u64[1] = clib_host_to_net_u64 (0x00010003);
854 /* RFC says this is the server and agent address */
855 all_dhcpv6_server_relay_agent_address.as_u64[0] =
856 clib_host_to_net_u64 (0xFF02000000000000);
857 all_dhcpv6_server_relay_agent_address.as_u64[1] =
858 clib_host_to_net_u64 (0x00010002);
863 VLIB_INIT_FUNCTION (dhcp6_proxy_init);
866 dhcp6_proxy_set_server (ip46_address_t * addr,
867 ip46_address_t * src_addr,
868 u32 rx_table_id, u32 server_table_id, int is_del)
870 vlib_main_t *vm = vlib_get_main ();
871 u32 rx_fib_index = 0;
874 const mfib_prefix_t all_dhcp_servers = {
876 .fp_proto = FIB_PROTOCOL_IP6,
878 .ip6 = all_dhcpv6_server_relay_agent_address,
882 if (ip46_address_is_zero (addr))
883 return VNET_API_ERROR_INVALID_DST_ADDRESS;
885 if (ip46_address_is_zero (src_addr))
886 return VNET_API_ERROR_INVALID_SRC_ADDRESS;
888 rx_fib_index = mfib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6,
894 if (dhcp_proxy_server_del (FIB_PROTOCOL_IP6, rx_fib_index,
895 addr, server_table_id))
897 mfib_table_entry_delete (rx_fib_index,
898 &all_dhcp_servers, MFIB_SOURCE_DHCP);
899 mfib_table_unlock (rx_fib_index, FIB_PROTOCOL_IP6,
902 udp_unregister_dst_port (vm, UDP_DST_PORT_dhcpv6_to_client,
904 udp_unregister_dst_port (vm, UDP_DST_PORT_dhcpv6_to_server,
910 const fib_route_path_t path_for_us = {
911 .frp_proto = DPO_PROTO_IP6,
912 .frp_addr = zero_addr,
913 .frp_sw_if_index = 0xffffffff,
916 .frp_flags = FIB_ROUTE_PATH_LOCAL,
917 .frp_mitf_flags = MFIB_ITF_FLAG_FORWARD,
919 if (dhcp_proxy_server_add (FIB_PROTOCOL_IP6, addr, src_addr,
920 rx_fib_index, server_table_id))
922 mfib_table_entry_path_update (rx_fib_index, &all_dhcp_servers,
923 MFIB_SOURCE_DHCP, MFIB_ENTRY_FLAG_NONE,
926 * Each interface that is enabled in this table, needs to be added
927 * as an accepting interface, but this is not easily doable in VPP.
928 * So we cheat. Add a flag to the entry that indicates accept form
930 * We will still only accept on v6 enabled interfaces, since the
931 * input feature ensures this.
933 mfib_table_entry_update (rx_fib_index,
937 MFIB_ENTRY_FLAG_ACCEPT_ALL_ITF);
938 mfib_table_lock (rx_fib_index, FIB_PROTOCOL_IP6, MFIB_SOURCE_DHCP);
940 udp_register_dst_port (vm, UDP_DST_PORT_dhcpv6_to_client,
941 dhcpv6_proxy_to_client_node.index,
943 udp_register_dst_port (vm, UDP_DST_PORT_dhcpv6_to_server,
944 dhcpv6_proxy_to_server_node.index,
949 mfib_table_unlock (rx_fib_index, FIB_PROTOCOL_IP6, MFIB_SOURCE_DHCP);
954 static clib_error_t *
955 dhcpv6_proxy_set_command_fn (vlib_main_t * vm,
956 unformat_input_t * input,
957 vlib_cli_command_t * cmd)
959 ip46_address_t addr, src_addr;
960 int set_server = 0, set_src_address = 0;
961 u32 rx_table_id = 0, server_table_id = 0;
964 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
966 if (unformat (input, "server %U", unformat_ip6_address, &addr.ip6))
968 else if (unformat (input, "src-address %U",
969 unformat_ip6_address, &src_addr.ip6))
971 else if (unformat (input, "server-fib-id %d", &server_table_id))
973 else if (unformat (input, "rx-fib-id %d", &rx_table_id))
975 else if (unformat (input, "delete") || unformat (input, "del"))
981 if (is_del || (set_server && set_src_address))
985 rv = dhcp6_proxy_set_server (&addr, &src_addr, rx_table_id,
986 server_table_id, is_del);
988 //TODO: Complete the errors
994 case VNET_API_ERROR_INVALID_DST_ADDRESS:
995 return clib_error_return (0, "Invalid server address");
997 case VNET_API_ERROR_INVALID_SRC_ADDRESS:
998 return clib_error_return (0, "Invalid src address");
1000 case VNET_API_ERROR_NO_SUCH_ENTRY:
1001 return clib_error_return
1002 (0, "Fib id %d: no per-fib DHCP server configured", rx_table_id);
1005 return clib_error_return (0, "BUG: rv %d", rv);
1009 return clib_error_return (0, "parse error`%U'",
1010 format_unformat_error, input);
1013 VLIB_CLI_COMMAND (dhcpv6_proxy_set_command, static) = {
1014 .path = "set dhcpv6 proxy",
1015 .short_help = "set dhcpv6 proxy [del] server <ipv6-addr> src-address <ipv6-addr> "
1016 "[server-fib-id <fib-id>] [rx-fib-id <fib-id>] ",
1017 .function = dhcpv6_proxy_set_command_fn,
1021 format_dhcp6_proxy_server (u8 * s, va_list * args)
1023 dhcp_proxy_t *proxy = va_arg (*args, dhcp_proxy_t *);
1024 fib_table_t *server_fib;
1025 dhcp_server_t *server;
1030 s = format (s, "%=14s%=16s%s", "RX FIB", "Src Address",
1031 "Servers FIB,Address");
1035 rx_fib = ip6_mfib_get (proxy->rx_fib_index);
1037 s = format (s, "%=14u%=16U",
1039 format_ip46_address, &proxy->dhcp_src_address, IP46_TYPE_ANY);
1041 vec_foreach (server, proxy->dhcp_servers)
1043 server_fib = fib_table_get (server->server_fib_index, FIB_PROTOCOL_IP6);
1044 s = format (s, "%u,%U ",
1045 server_fib->ft_table_id,
1046 format_ip46_address, &server->dhcp_server, IP46_TYPE_ANY);
1053 dhcp6_proxy_show_walk (dhcp_proxy_t * proxy, void *ctx)
1055 vlib_main_t *vm = ctx;
1057 vlib_cli_output (vm, "%U", format_dhcp6_proxy_server, proxy);
1062 static clib_error_t *
1063 dhcpv6_proxy_show_command_fn (vlib_main_t * vm,
1064 unformat_input_t * input,
1065 vlib_cli_command_t * cmd)
1067 vlib_cli_output (vm, "%U", format_dhcp6_proxy_server,
1068 NULL /* header line */ );
1070 dhcp_proxy_walk (FIB_PROTOCOL_IP6, dhcp6_proxy_show_walk, vm);
1075 VLIB_CLI_COMMAND (dhcpv6_proxy_show_command, static) = {
1076 .path = "show dhcpv6 proxy",
1077 .short_help = "Display dhcpv6 proxy info",
1078 .function = dhcpv6_proxy_show_command_fn,
1081 static clib_error_t *
1082 dhcpv6_vss_command_fn (vlib_main_t * vm,
1083 unformat_input_t * input, vlib_cli_command_t * cmd)
1085 u8 is_del = 0, vss_type = VSS_TYPE_DEFAULT;
1086 u8 *vpn_ascii_id = 0;
1087 u32 oui = 0, fib_id = 0, tbl_id = ~0;
1089 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1091 if (unformat (input, "table %d", &tbl_id))
1093 else if (unformat (input, "oui %d", &oui))
1094 vss_type = VSS_TYPE_VPN_ID;
1095 else if (unformat (input, "vpn-id %d", &fib_id))
1096 vss_type = VSS_TYPE_VPN_ID;
1097 else if (unformat (input, "vpn-ascii-id %s", &vpn_ascii_id))
1098 vss_type = VSS_TYPE_ASCII;
1099 else if (unformat (input, "delete") || unformat (input, "del"))
1106 return clib_error_return (0, "no table ID specified.");
1108 int rv = dhcp_proxy_set_vss (FIB_PROTOCOL_IP6, tbl_id, vss_type,
1109 vpn_ascii_id, oui, fib_id, is_del);
1114 case VNET_API_ERROR_NO_SUCH_ENTRY:
1115 return clib_error_return (0, "vss for table %d not found in pool.",
1118 return clib_error_return (0, "BUG: rv %d", rv);
1122 VLIB_CLI_COMMAND (dhcpv6_proxy_vss_command, static) = {
1123 .path = "set dhcpv6 vss",
1124 .short_help = "set dhcpv6 vss table <table-id> [oui <n> vpn-id <n> | vpn-ascii-id <text>]",
1125 .function = dhcpv6_vss_command_fn,
1128 static clib_error_t *
1129 dhcpv6_vss_show_command_fn (vlib_main_t * vm,
1130 unformat_input_t * input,
1131 vlib_cli_command_t * cmd)
1133 dhcp_vss_walk (FIB_PROTOCOL_IP6, dhcp_vss_show_walk, vm);
1138 VLIB_CLI_COMMAND (dhcpv6_proxy_vss_show_command, static) = {
1139 .path = "show dhcpv6 vss",
1140 .short_help = "show dhcpv6 VSS",
1141 .function = dhcpv6_vss_show_command_fn,
1144 static clib_error_t *
1145 dhcpv6_link_address_show_command_fn (vlib_main_t * vm,
1146 unformat_input_t * input,
1147 vlib_cli_command_t * cmd)
1149 vnet_main_t *vnm = vnet_get_main ();
1150 u32 sw_if_index0 = 0, sw_if_index;
1151 vnet_sw_interface_t *swif;
1154 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1157 if (unformat (input, "%U",
1158 unformat_vnet_sw_interface, vnm, &sw_if_index0))
1160 swif = vnet_get_sw_interface (vnm, sw_if_index0);
1161 sw_if_index = (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) ?
1162 swif->unnumbered_sw_if_index : sw_if_index0;
1163 ia0 = ip6_interface_first_address (&ip6_main, sw_if_index);
1166 vlib_cli_output (vm, "%=20s%=48s", "interface", "link-address");
1168 vlib_cli_output (vm, "%=20U%=48U",
1169 format_vnet_sw_if_index_name, vnm,
1170 sw_if_index0, format_ip6_address, ia0);
1173 vlib_cli_output (vm, "%=34s%=20U",
1174 "No IPv6 address configured on",
1175 format_vnet_sw_if_index_name, vnm, sw_if_index);
1184 VLIB_CLI_COMMAND (dhcpv6_proxy_address_show_command, static) = {
1185 .path = "show dhcpv6 link-address interface",
1186 .short_help = "show dhcpv6 link-address interface <interface>",
1187 .function = dhcpv6_link_address_show_command_fn,
1191 * fd.io coding-style-patch-verification: ON
1194 * eval: (c-set-style "gnu")