From 34719e37bf820e8398ca9159725f7f4c42764aeb Mon Sep 17 00:00:00 2001 From: khemendra kumar Date: Fri, 8 Dec 2017 18:06:52 +0530 Subject: [PATCH] VPP-249 Coding standards cleanup - vnet/vnet/dhcp Change-Id: I45a166b5780675d2bc6fe90595f413725704eaa8 Signed-off-by: khemendra kumar --- src/vnet/dhcp/client.c | 832 ++++++++++++------------- src/vnet/dhcp/client.h | 77 ++- src/vnet/dhcp/dhcp4_packet.h | 36 +- src/vnet/dhcp/dhcp4_proxy_node.c | 1169 +++++++++++++++++----------------- src/vnet/dhcp/dhcp6_packet.h | 173 ++--- src/vnet/dhcp/dhcp6_proxy_node.c | 1282 ++++++++++++++++++++------------------ src/vnet/dhcp/dhcp_proxy.c | 396 ++++++------ src/vnet/dhcp/dhcp_proxy.h | 155 +++-- 8 files changed, 2085 insertions(+), 2035 deletions(-) diff --git a/src/vnet/dhcp/client.c b/src/vnet/dhcp/client.c index 5986438b85f..8043bf22d43 100644 --- a/src/vnet/dhcp/client.c +++ b/src/vnet/dhcp/client.c @@ -18,106 +18,91 @@ #include dhcp_client_main_t dhcp_client_main; -static u8 * format_dhcp_client_state (u8 * s, va_list * va); +static u8 *format_dhcp_client_state (u8 * s, va_list * va); static vlib_node_registration_t dhcp_client_process_node; -static void +static void dhcp_client_add_rx_address (dhcp_client_main_t * dcm, dhcp_client_t * c) { /* Install a local entry for the offered address */ - fib_prefix_t rx = - { - .fp_len = 32, - .fp_addr.ip4 = c->leased_address, - .fp_proto = FIB_PROTOCOL_IP4, - }; - - fib_table_entry_special_add(fib_table_get_index_for_sw_if_index( - FIB_PROTOCOL_IP4, - c->sw_if_index), - &rx, - FIB_SOURCE_DHCP, - (FIB_ENTRY_FLAG_LOCAL)); + fib_prefix_t rx = { + .fp_len = 32, + .fp_addr.ip4 = c->leased_address, + .fp_proto = FIB_PROTOCOL_IP4, + }; + + fib_table_entry_special_add (fib_table_get_index_for_sw_if_index + (FIB_PROTOCOL_IP4, c->sw_if_index), &rx, + FIB_SOURCE_DHCP, (FIB_ENTRY_FLAG_LOCAL)); /* And add the server's address as uRPF exempt so we can accept * local packets from it */ - fib_prefix_t server = - { - .fp_len = 32, - .fp_addr.ip4 = c->dhcp_server, - .fp_proto = FIB_PROTOCOL_IP4, - }; - - fib_table_entry_special_add(fib_table_get_index_for_sw_if_index( - FIB_PROTOCOL_IP4, - c->sw_if_index), - &server, - FIB_SOURCE_URPF_EXEMPT, - (FIB_ENTRY_FLAG_DROP)); + fib_prefix_t server = { + .fp_len = 32, + .fp_addr.ip4 = c->dhcp_server, + .fp_proto = FIB_PROTOCOL_IP4, + }; + + fib_table_entry_special_add (fib_table_get_index_for_sw_if_index + (FIB_PROTOCOL_IP4, c->sw_if_index), &server, + FIB_SOURCE_URPF_EXEMPT, (FIB_ENTRY_FLAG_DROP)); } static void dhcp_client_remove_rx_address (dhcp_client_main_t * dcm, dhcp_client_t * c) { - fib_prefix_t rx = - { - .fp_len = 32, - .fp_addr.ip4 = c->leased_address, - .fp_proto = FIB_PROTOCOL_IP4, - }; - - fib_table_entry_special_remove(fib_table_get_index_for_sw_if_index( - FIB_PROTOCOL_IP4, - c->sw_if_index), - &rx, - FIB_SOURCE_DHCP); - fib_prefix_t server = - { - .fp_len = 32, - .fp_addr.ip4 = c->dhcp_server, - .fp_proto = FIB_PROTOCOL_IP4, - }; - - fib_table_entry_special_remove(fib_table_get_index_for_sw_if_index( - FIB_PROTOCOL_IP4, - c->sw_if_index), - &server, - FIB_SOURCE_URPF_EXEMPT); + fib_prefix_t rx = { + .fp_len = 32, + .fp_addr.ip4 = c->leased_address, + .fp_proto = FIB_PROTOCOL_IP4, + }; + + fib_table_entry_special_remove (fib_table_get_index_for_sw_if_index + (FIB_PROTOCOL_IP4, c->sw_if_index), &rx, + FIB_SOURCE_DHCP); + fib_prefix_t server = { + .fp_len = 32, + .fp_addr.ip4 = c->dhcp_server, + .fp_proto = FIB_PROTOCOL_IP4, + }; + + fib_table_entry_special_remove (fib_table_get_index_for_sw_if_index + (FIB_PROTOCOL_IP4, c->sw_if_index), &server, + FIB_SOURCE_URPF_EXEMPT); } static void dhcp_client_acquire_address (dhcp_client_main_t * dcm, dhcp_client_t * c) { - /* + /* * Install any/all info gleaned from dhcp, right here */ ip4_add_del_interface_address (dcm->vlib_main, c->sw_if_index, - (void *) &c->leased_address, - c->subnet_mask_width, 0 /*is_del*/); + (void *) &c->leased_address, + c->subnet_mask_width, 0 /*is_del */ ); } -static void +static void dhcp_client_release_address (dhcp_client_main_t * dcm, dhcp_client_t * c) { - /* + /* * Remove any/all info gleaned from dhcp, right here. Caller(s) * have not wiped out the info yet. */ ip4_add_del_interface_address (dcm->vlib_main, c->sw_if_index, - (void *) &c->leased_address, - c->subnet_mask_width, 1 /*is_del*/); + (void *) &c->leased_address, + c->subnet_mask_width, 1 /*is_del */ ); } static void set_l2_rewrite (dhcp_client_main_t * dcm, dhcp_client_t * c) { /* Acquire the L2 rewrite string for the indicated sw_if_index */ - c->l2_rewrite = vnet_build_rewrite_for_sw_interface( - dcm->vnet_main, - c->sw_if_index, - VNET_LINK_IP4, - 0 /* broadcast */); + c->l2_rewrite = vnet_build_rewrite_for_sw_interface (dcm->vnet_main, + c->sw_if_index, + VNET_LINK_IP4, + 0 /* broadcast */ ); } void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length); @@ -127,40 +112,40 @@ dhcp_client_proc_callback (uword * client_index) { vlib_main_t *vm = vlib_get_main (); ASSERT (vlib_get_thread_index () == 0); - vlib_process_signal_event (vm, dhcp_client_process_node.index, + vlib_process_signal_event (vm, dhcp_client_process_node.index, EVENT_DHCP_CLIENT_WAKEUP, *client_index); } -/* +/* * dhcp_client_for_us - server-to-client callback. * Called from proxy_node.c:dhcp_proxy_to_client_input(). * This function first decides that the packet in question is * actually for the dhcp client code in case we're also acting as * a dhcp proxy. Ay caramba, what a folly! */ -int dhcp_client_for_us (u32 bi, vlib_buffer_t * b, - ip4_header_t * ip, - udp_header_t * udp, - dhcp_header_t * dhcp) +int +dhcp_client_for_us (u32 bi, vlib_buffer_t * b, + ip4_header_t * ip, + udp_header_t * udp, dhcp_header_t * dhcp) { - dhcp_client_main_t * dcm = &dhcp_client_main; - vlib_main_t * vm = dcm->vlib_main; - dhcp_client_t * c; - uword * p; + dhcp_client_main_t *dcm = &dhcp_client_main; + vlib_main_t *vm = dcm->vlib_main; + dhcp_client_t *c; + uword *p; f64 now = vlib_time_now (dcm->vlib_main); u8 dhcp_message_type = 0; - dhcp_option_t * o; + dhcp_option_t *o; - /* - * Doing dhcp client on this interface? + /* + * Doing dhcp client on this interface? * Presumably we will always receive dhcp clnt for-us pkts on * the interface that's asking for an address. */ - p = hash_get (dcm->client_by_sw_if_index, - vnet_buffer(b)->sw_if_index [VLIB_RX]); + p = hash_get (dcm->client_by_sw_if_index, + vnet_buffer (b)->sw_if_index[VLIB_RX]); if (p == 0) - return 0; /* no */ - + return 0; /* no */ + c = pool_elt_at_index (dcm->clients, p[0]); /* Mixing dhcp relay and dhcp proxy? DGMS... */ @@ -174,66 +159,65 @@ int dhcp_client_for_us (u32 bi, vlib_buffer_t * b, c->dhcp_server.as_u32 = dhcp->server_ip_address.as_u32; o = (dhcp_option_t *) dhcp->options; - - while (o->option != 0xFF /* end of options */ && - (u8 *) o < (b->data + b->current_data + b->current_length)) + + while (o->option != 0xFF /* end of options */ && + (u8 *) o < (b->data + b->current_data + b->current_length)) { switch (o->option) - { - case 53: /* dhcp message type */ - dhcp_message_type = o->data[0]; - break; - - case 51: /* lease time */ - { - u32 lease_time_in_seconds = - clib_host_to_net_u32 (o->data_as_u32[0]); - c->lease_expires = now + (f64) lease_time_in_seconds; - c->lease_lifetime = lease_time_in_seconds; - /* Set a sensible default, in case we don't get opt 58 */ - c->lease_renewal_interval = lease_time_in_seconds / 2; - } - break; - - case 58: /* lease renew time in seconds */ - { - u32 lease_renew_time_in_seconds = - clib_host_to_net_u32 (o->data_as_u32[0]); - c->lease_renewal_interval = lease_renew_time_in_seconds; - } - break; - - case 54: /* dhcp server address */ - c->dhcp_server.as_u32 = o->data_as_u32[0]; - break; - - case 1: /* subnet mask */ - { - u32 subnet_mask = - clib_host_to_net_u32 (o->data_as_u32[0]); - c->subnet_mask_width = count_set_bits (subnet_mask); - } - break; - case 3: /* router address */ - { - u32 router_address = o->data_as_u32[0]; - c->router_address.as_u32 = router_address; - } - break; - - case 12: /* hostname */ - { - /* Replace the existing hostname if necessary */ - vec_free (c->hostname); - vec_validate (c->hostname, o->length - 1); - clib_memcpy (c->hostname, o->data, o->length); - } - break; - - /* $$$$ Your message in this space, parse more options */ - default: - break; - } + { + case 53: /* dhcp message type */ + dhcp_message_type = o->data[0]; + break; + + case 51: /* lease time */ + { + u32 lease_time_in_seconds = + clib_host_to_net_u32 (o->data_as_u32[0]); + c->lease_expires = now + (f64) lease_time_in_seconds; + c->lease_lifetime = lease_time_in_seconds; + /* Set a sensible default, in case we don't get opt 58 */ + c->lease_renewal_interval = lease_time_in_seconds / 2; + } + break; + + case 58: /* lease renew time in seconds */ + { + u32 lease_renew_time_in_seconds = + clib_host_to_net_u32 (o->data_as_u32[0]); + c->lease_renewal_interval = lease_renew_time_in_seconds; + } + break; + + case 54: /* dhcp server address */ + c->dhcp_server.as_u32 = o->data_as_u32[0]; + break; + + case 1: /* subnet mask */ + { + u32 subnet_mask = clib_host_to_net_u32 (o->data_as_u32[0]); + c->subnet_mask_width = count_set_bits (subnet_mask); + } + break; + case 3: /* router address */ + { + u32 router_address = o->data_as_u32[0]; + c->router_address.as_u32 = router_address; + } + break; + + case 12: /* hostname */ + { + /* Replace the existing hostname if necessary */ + vec_free (c->hostname); + vec_validate (c->hostname, o->length - 1); + clib_memcpy (c->hostname, o->data, o->length); + } + break; + + /* $$$$ Your message in this space, parse more options */ + default: + break; + } o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); } @@ -242,13 +226,13 @@ int dhcp_client_for_us (u32 bi, vlib_buffer_t * b, { case DHCP_DISCOVER: if (dhcp_message_type != DHCP_PACKET_OFFER) - { - clib_warning ("sw_if_index %d state %U message type %d", - c->sw_if_index, format_dhcp_client_state, - c->state, dhcp_message_type); - c->next_transmit = now + 5.0; - break; - } + { + clib_warning ("sw_if_index %d state %U message type %d", + c->sw_if_index, format_dhcp_client_state, + c->state, dhcp_message_type); + c->next_transmit = now + 5.0; + break; + } /* * in order to accept unicasted ACKs we need to configure the offered * address on the interface. However, at this point we may not know the @@ -260,76 +244,61 @@ int dhcp_client_for_us (u32 bi, vlib_buffer_t * b, /* Received an offer, go send a request */ c->state = DHCP_REQUEST; c->retry_count = 0; - c->next_transmit = 0; /* send right now... */ + c->next_transmit = 0; /* send right now... */ /* Poke the client process, which will send the request */ - uword client_id = c - dcm->clients; + uword client_id = c - dcm->clients; vl_api_rpc_call_main_thread (dhcp_client_proc_callback, - (u8 *) &client_id, sizeof (uword)); + (u8 *) & client_id, sizeof (uword)); break; case DHCP_BOUND: case DHCP_REQUEST: if (dhcp_message_type != DHCP_PACKET_ACK) - { - clib_warning ("sw_if_index %d state %U message type %d", - c->sw_if_index, format_dhcp_client_state, - c->state, dhcp_message_type); - c->next_transmit = now + 5.0; - break; - } + { + clib_warning ("sw_if_index %d state %U message type %d", + c->sw_if_index, format_dhcp_client_state, + c->state, dhcp_message_type); + c->next_transmit = now + 5.0; + break; + } /* OK, we own the address (etc), add to the routing table(s) */ if (c->state == DHCP_REQUEST) - { - void (*fp)(u32, u32, u8 *, u8, u8, u8 *, u8 *, u8 *) = c->event_callback; - - /* replace the temporary RX address with the correct subnet */ - dhcp_client_remove_rx_address (dcm, c); - dhcp_client_acquire_address (dcm, c); - - /* - * Configure default IP route: - */ - if (c->router_address.as_u32) + { + void (*fp) (u32, u32, u8 *, u8, u8, u8 *, u8 *, u8 *) = + c->event_callback; + + /* replace the temporary RX address with the correct subnet */ + dhcp_client_remove_rx_address (dcm, c); + dhcp_client_acquire_address (dcm, c); + + /* + * Configure default IP route: + */ + if (c->router_address.as_u32) { - fib_prefix_t all_0s = - { - .fp_len = 0, - .fp_addr.ip4.as_u32 = 0x0, - .fp_proto = FIB_PROTOCOL_IP4, + fib_prefix_t all_0s = { + .fp_len = 0, + .fp_addr.ip4.as_u32 = 0x0, + .fp_proto = FIB_PROTOCOL_IP4, }; - ip46_address_t nh = - { - .ip4 = c->router_address, + ip46_address_t nh = { + .ip4 = c->router_address, }; - fib_table_entry_path_add (fib_table_get_index_for_sw_if_index( - FIB_PROTOCOL_IP4, - c->sw_if_index), - &all_0s, - FIB_SOURCE_DHCP, - FIB_ENTRY_FLAG_NONE, - DPO_PROTO_IP4, - &nh, - c->sw_if_index, - ~0, - 1, - NULL, // no label stack + fib_table_entry_path_add (fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4, c->sw_if_index), &all_0s, FIB_SOURCE_DHCP, FIB_ENTRY_FLAG_NONE, DPO_PROTO_IP4, &nh, c->sw_if_index, ~0, 1, NULL, // no label stack FIB_ROUTE_PATH_FLAG_NONE); } - /* - * Call the user's event callback to report DHCP information - */ - if (fp) - (*fp) (c->client_index, /* clinet index */ - c->pid, - c->hostname, - c->subnet_mask_width, - 0, /* is_ipv6 */ - (u8 *)&c->leased_address, /* host IP address */ - (u8 *)&c->router_address, /* router IP address */ - (u8 *)(c->l2_rewrite + 6));/* host MAC address */ - } + /* + * Call the user's event callback to report DHCP information + */ + if (fp) + (*fp) (c->client_index, /* clinet index */ + c->pid, c->hostname, c->subnet_mask_width, 0, /* is_ipv6 */ + (u8 *) & c->leased_address, /* host IP address */ + (u8 *) & c->router_address, /* router IP address */ + (u8 *) (c->l2_rewrite + 6)); /* host MAC address */ + } c->state = DHCP_BOUND; c->retry_count = 0; @@ -338,8 +307,7 @@ int dhcp_client_for_us (u32 bi, vlib_buffer_t * b, break; default: - clib_warning ("client %d bogus state %d", - c - dcm->clients, c->state); + clib_warning ("client %d bogus state %d", c - dcm->clients, c->state); break; } @@ -348,24 +316,24 @@ int dhcp_client_for_us (u32 bi, vlib_buffer_t * b, return 1; } -static void -send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, - dhcp_packet_type_t type, int is_broadcast) +static void +send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, + dhcp_packet_type_t type, int is_broadcast) { - vlib_main_t * vm = dcm->vlib_main; - vnet_main_t * vnm = dcm->vnet_main; - vnet_hw_interface_t * hw = vnet_get_sup_hw_interface (vnm, c->sw_if_index); - vnet_sw_interface_t * sup_sw + vlib_main_t *vm = dcm->vlib_main; + vnet_main_t *vnm = dcm->vnet_main; + vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, c->sw_if_index); + vnet_sw_interface_t *sup_sw = vnet_get_sup_sw_interface (vnm, c->sw_if_index); - vnet_sw_interface_t * sw = vnet_get_sw_interface (vnm, c->sw_if_index); - vlib_buffer_t * b; + vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, c->sw_if_index); + vlib_buffer_t *b; u32 bi; - ip4_header_t * ip; - udp_header_t * udp; - dhcp_header_t * dhcp; - u32 * to_next; - vlib_frame_t * f; - dhcp_option_t * o; + ip4_header_t *ip; + udp_header_t *udp; + dhcp_header_t *dhcp; + u32 *to_next; + vlib_frame_t *f; + dhcp_option_t *o; u16 udp_length, ip_length; /* Interface(s) down? */ @@ -376,30 +344,31 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, if ((sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) == 0) return; - if (vlib_buffer_alloc (vm, &bi, 1) != 1) { - clib_warning ("buffer allocation failure"); - c->next_transmit = 0; - return; - } - + if (vlib_buffer_alloc (vm, &bi, 1) != 1) + { + clib_warning ("buffer allocation failure"); + c->next_transmit = 0; + return; + } + /* Build a dhcpv4 pkt from whole cloth */ b = vlib_get_buffer (vm, bi); ASSERT (b->current_data == 0); - vnet_buffer(b)->sw_if_index[VLIB_RX] = c->sw_if_index; - if (is_broadcast) + vnet_buffer (b)->sw_if_index[VLIB_RX] = c->sw_if_index; + if (is_broadcast) { f = vlib_get_frame_to_node (vm, hw->output_node_index); - vnet_buffer(b)->sw_if_index[VLIB_TX] = c->sw_if_index; - clib_memcpy (b->data, c->l2_rewrite, vec_len(c->l2_rewrite)); + vnet_buffer (b)->sw_if_index[VLIB_TX] = c->sw_if_index; + clib_memcpy (b->data, c->l2_rewrite, vec_len (c->l2_rewrite)); ip = (void *) - (((u8 *)vlib_buffer_get_current (b)) + vec_len (c->l2_rewrite)); + (((u8 *) vlib_buffer_get_current (b)) + vec_len (c->l2_rewrite)); } else { f = vlib_get_frame_to_node (vm, ip4_lookup_node.index); - vnet_buffer(b)->sw_if_index[VLIB_TX] = ~0; /* use interface VRF */ + vnet_buffer (b)->sw_if_index[VLIB_TX] = ~0; /* use interface VRF */ ip = vlib_buffer_get_current (b); } @@ -412,9 +381,9 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, vlib_put_frame_to_node (vm, hw->output_node_index, f); else vlib_put_frame_to_node (vm, ip4_lookup_node.index, f); - - udp = (udp_header_t *)(ip+1); - dhcp = (dhcp_header_t *)(udp+1); + + udp = (udp_header_t *) (ip + 1); + dhcp = (dhcp_header_t *) (udp + 1); /* $$$ optimize, maybe */ memset (ip, 0, sizeof (*ip) + sizeof (*udp) + sizeof (*dhcp)); @@ -422,7 +391,7 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, ip->ip_version_and_header_length = 0x45; ip->ttl = 128; ip->protocol = IP_PROTOCOL_UDP; - + if (is_broadcast) { /* src = 0.0.0.0, dst = 255.255.255.255 */ @@ -445,14 +414,14 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, if (is_broadcast == 0) dhcp->client_ip_address.as_u32 = c->leased_address.as_u32; - dhcp->opcode = 1; /* request, all we send */ - dhcp->hardware_type = 1; /* ethernet */ - dhcp->hardware_address_length = 6; - dhcp->transaction_identifier = c->transaction_id; - dhcp->flags = clib_host_to_net_u16(is_broadcast ? DHCP_FLAG_BROADCAST : 0); + dhcp->opcode = 1; /* request, all we send */ + dhcp->hardware_type = 1; /* ethernet */ + dhcp->hardware_address_length = 6; + dhcp->transaction_identifier = c->transaction_id; + dhcp->flags = clib_host_to_net_u16 (is_broadcast ? DHCP_FLAG_BROADCAST : 0); dhcp->magic_cookie.as_u32 = DHCP_MAGIC; - - o = (dhcp_option_t * )dhcp->options; + + o = (dhcp_option_t *) dhcp->options; /* Send option 53, the DHCP message type */ o->option = DHCP_PACKET_OPTION_MSG_TYPE; @@ -461,14 +430,14 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); /* Send option 57, max msg length */ - if (0 /* not needed, apparently */) + if (0 /* not needed, apparently */ ) { o->option = 57; o->length = 2; { - u16 *o2 = (u16 *) o->data; - *o2 = clib_host_to_net_u16 (1152); - o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); + u16 *o2 = (u16 *) o->data; + *o2 = clib_host_to_net_u16 (1152); + o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); } } @@ -508,13 +477,13 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, o->option = 61; o->length = vec_len (c->client_identifier); clib_memcpy (o->data, c->client_identifier, - vec_len (c->client_identifier)); + vec_len (c->client_identifier)); o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); } /* $$ maybe send the client s/w version if anyone cares */ - /* + /* * send option 55, parameter request list * The current list - see below, matches the Linux dhcp client's list * Any specific dhcp server config and/or dhcp server may or may @@ -522,36 +491,36 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, */ o->option = 55; o->length = vec_len (c->option_55_data); - clib_memcpy (o->data, c->option_55_data, vec_len(c->option_55_data)); + clib_memcpy (o->data, c->option_55_data, vec_len (c->option_55_data)); o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); /* End of list */ o->option = 0xff; o->length = 0; o++; - - b->current_length = ((u8 *)o) - b->data; + + b->current_length = ((u8 *) o) - b->data; /* fix ip length, checksum and udp length */ ip_length = vlib_buffer_length_in_chain (vm, b); if (is_broadcast) - ip_length -= vec_len (c->l2_rewrite); + ip_length -= vec_len (c->l2_rewrite); - ip->length = clib_host_to_net_u16(ip_length); - ip->checksum = ip4_header_checksum(ip); + ip->length = clib_host_to_net_u16 (ip_length); + ip->checksum = ip4_header_checksum (ip); udp_length = ip_length - (sizeof (*ip)); udp->length = clib_host_to_net_u16 (udp_length); } -static int +static int dhcp_discover_state (dhcp_client_main_t * dcm, dhcp_client_t * c, f64 now) { /* * State machine "DISCOVER" state. Send a dhcp discover packet, * eventually back off the retry rate. */ - send_dhcp_pkt (dcm, c, DHCP_PACKET_DISCOVER, 1 /* is_broadcast */); + send_dhcp_pkt (dcm, c, DHCP_PACKET_DISCOVER, 1 /* is_broadcast */ ); c->retry_count++; if (c->retry_count > 10) @@ -560,18 +529,18 @@ dhcp_discover_state (dhcp_client_main_t * dcm, dhcp_client_t * c, f64 now) c->next_transmit = now + 1.0; return 0; } - -static int + +static int dhcp_request_state (dhcp_client_main_t * dcm, dhcp_client_t * c, f64 now) -{ +{ /* * State machine "REQUEST" state. Send a dhcp request packet, * eventually drop back to the discover state. */ - send_dhcp_pkt (dcm, c, DHCP_PACKET_REQUEST, 1 /* is_broadcast */); + send_dhcp_pkt (dcm, c, DHCP_PACKET_REQUEST, 1 /* is_broadcast */ ); c->retry_count++; - if (c->retry_count > 7 /* lucky you */) + if (c->retry_count > 7 /* lucky you */ ) { c->state = DHCP_DISCOVER; c->next_transmit = now; @@ -582,7 +551,7 @@ dhcp_request_state (dhcp_client_main_t * dcm, dhcp_client_t * c, f64 now) return 0; } -static int +static int dhcp_bound_state (dhcp_client_main_t * dcm, dhcp_client_t * c, f64 now) { /* @@ -590,39 +559,32 @@ dhcp_bound_state (dhcp_client_main_t * dcm, dhcp_client_t * c, f64 now) * eventually, when the lease expires, forget the dhcp data * and go back to the stone age. */ - send_dhcp_pkt (dcm, c, DHCP_PACKET_REQUEST, 0 /* is_broadcast */); - + send_dhcp_pkt (dcm, c, DHCP_PACKET_REQUEST, 0 /* is_broadcast */ ); + c->retry_count++; if (c->retry_count > 10) c->next_transmit = now + 5.0; else c->next_transmit = now + 1.0; - + if (now > c->lease_expires) { if (c->router_address.as_u32) - { - fib_prefix_t all_0s = - { - .fp_len = 0, - .fp_addr.ip4.as_u32 = 0x0, - .fp_proto = FIB_PROTOCOL_IP4, + { + fib_prefix_t all_0s = { + .fp_len = 0, + .fp_addr.ip4.as_u32 = 0x0, + .fp_proto = FIB_PROTOCOL_IP4, }; ip46_address_t nh = { - .ip4 = c->router_address, + .ip4 = c->router_address, }; - fib_table_entry_path_remove(fib_table_get_index_for_sw_if_index( - FIB_PROTOCOL_IP4, - c->sw_if_index), - &all_0s, - FIB_SOURCE_DHCP, - DPO_PROTO_IP4, - &nh, - c->sw_if_index, - ~0, - 1, - FIB_ROUTE_PATH_FLAG_NONE); + fib_table_entry_path_remove (fib_table_get_index_for_sw_if_index + (FIB_PROTOCOL_IP4, c->sw_if_index), + &all_0s, FIB_SOURCE_DHCP, + DPO_PROTO_IP4, &nh, c->sw_if_index, ~0, + 1, FIB_ROUTE_PATH_FLAG_NONE); } dhcp_client_release_address (dcm, c); @@ -640,10 +602,11 @@ dhcp_bound_state (dhcp_client_main_t * dcm, dhcp_client_t * c, f64 now) return 0; } -static f64 dhcp_client_sm (f64 now, f64 timeout, uword pool_index) +static f64 +dhcp_client_sm (f64 now, f64 timeout, uword pool_index) { - dhcp_client_main_t * dcm = &dhcp_client_main; - dhcp_client_t * c; + dhcp_client_main_t *dcm = &dhcp_client_main; + dhcp_client_t *c; /* deleted, pooched, yadda yadda yadda */ if (pool_is_free_index (dcm->clients, pool_index)) @@ -655,30 +618,30 @@ static f64 dhcp_client_sm (f64 now, f64 timeout, uword pool_index) if (now < c->next_transmit) return timeout; - again: +again: switch (c->state) { - case DHCP_DISCOVER: /* send a discover */ + case DHCP_DISCOVER: /* send a discover */ if (dhcp_discover_state (dcm, c, now)) - goto again; + goto again; break; - case DHCP_REQUEST: /* send a request */ + case DHCP_REQUEST: /* send a request */ if (dhcp_request_state (dcm, c, now)) - goto again; + goto again; break; - - case DHCP_BOUND: /* bound, renew needed? */ + + case DHCP_BOUND: /* bound, renew needed? */ if (dhcp_bound_state (dcm, c, now)) - goto again; + goto again; break; - + default: - clib_warning ("dhcp client %d bogus state %d", - c - dcm->clients, c->state); + clib_warning ("dhcp client %d bogus state %d", + c - dcm->clients, c->state); break; } - + if (c->next_transmit < now + timeout) return c->next_transmit - now; @@ -687,15 +650,14 @@ static f64 dhcp_client_sm (f64 now, f64 timeout, uword pool_index) static uword dhcp_client_process (vlib_main_t * vm, - vlib_node_runtime_t * rt, - vlib_frame_t * f) + vlib_node_runtime_t * rt, vlib_frame_t * f) { f64 timeout = 100.0; f64 now; uword event_type; - uword * event_data = 0; - dhcp_client_main_t * dcm = &dhcp_client_main; - dhcp_client_t * c; + uword *event_data = 0; + dhcp_client_main_t *dcm = &dhcp_client_main; + dhcp_client_t *c; int i; while (1) @@ -707,22 +669,25 @@ dhcp_client_process (vlib_main_t * vm, now = vlib_time_now (vm); switch (event_type) - { - case EVENT_DHCP_CLIENT_WAKEUP: - for (i = 0; i < vec_len (event_data); i++) - timeout = dhcp_client_sm (now, timeout, event_data[i]); - break; - - case ~0: - pool_foreach (c, dcm->clients, - ({ - timeout = dhcp_client_sm (now, timeout, - (uword)(c - dcm->clients)); - })); - if (pool_elts (dcm->clients) == 0) - timeout = 100.0; - break; - } + { + case EVENT_DHCP_CLIENT_WAKEUP: + for (i = 0; i < vec_len (event_data); i++) + timeout = dhcp_client_sm (now, timeout, event_data[i]); + break; + + case ~0: + pool_foreach (c, dcm->clients, ( + { + timeout = + dhcp_client_sm (now, timeout, + (uword) (c - + dcm->clients)); + } + )); + if (pool_elts (dcm->clients) == 0) + timeout = 100.0; + break; + } vec_reset_length (event_data); } @@ -731,17 +696,20 @@ dhcp_client_process (vlib_main_t * vm, return 0; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (dhcp_client_process_node,static) = { .function = dhcp_client_process, .type = VLIB_NODE_TYPE_PROCESS, .name = "dhcp-client-process", .process_log2_n_stack_bytes = 16, }; +/* *INDENT-ON* */ -static u8 * format_dhcp_client_state (u8 * s, va_list * va) +static u8 * +format_dhcp_client_state (u8 * s, va_list * va) { dhcp_client_state_t state = va_arg (*va, dhcp_client_state_t); - char * str = "BOGUS!"; + char *str = "BOGUS!"; switch (state) { @@ -759,96 +727,100 @@ static u8 * format_dhcp_client_state (u8 * s, va_list * va) return s; } -static u8 * format_dhcp_client (u8 * s, va_list * va) +static u8 * +format_dhcp_client (u8 * s, va_list * va) { - dhcp_client_main_t * dcm = va_arg (*va, dhcp_client_main_t *); - dhcp_client_t * c = va_arg (*va, dhcp_client_t *); + dhcp_client_main_t *dcm = va_arg (*va, dhcp_client_main_t *); + dhcp_client_t *c = va_arg (*va, dhcp_client_t *); int verbose = va_arg (*va, int); - s = format (s, "[%d] %U state %U ", c - dcm->clients, - format_vnet_sw_if_index_name, dcm->vnet_main, c->sw_if_index, - format_dhcp_client_state, c->state); + s = format (s, "[%d] %U state %U ", c - dcm->clients, + format_vnet_sw_if_index_name, dcm->vnet_main, c->sw_if_index, + format_dhcp_client_state, c->state); if (c->leased_address.as_u32) s = format (s, "addr %U/%d gw %U\n", - format_ip4_address, &c->leased_address, - c->subnet_mask_width, format_ip4_address, &c->router_address); + format_ip4_address, &c->leased_address, + c->subnet_mask_width, format_ip4_address, &c->router_address); else s = format (s, "no address\n"); if (verbose) { s = format (s, "retry count %d, next xmt %.2f", - c->retry_count, c->next_transmit); + c->retry_count, c->next_transmit); } return s; } static clib_error_t * show_dhcp_client_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { - dhcp_client_main_t * dcm = &dhcp_client_main; - dhcp_client_t * c; + dhcp_client_main_t *dcm = &dhcp_client_main; + dhcp_client_t *c; int verbose = 0; u32 sw_if_index = ~0; - uword * p; + uword *p; - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (unformat (input, "intfc %U", - unformat_vnet_sw_interface, dcm->vnet_main, - &sw_if_index)) - ; + if (unformat (input, "intfc %U", + unformat_vnet_sw_interface, dcm->vnet_main, &sw_if_index)) + ; else if (unformat (input, "verbose")) - verbose = 1; + verbose = 1; else - break; + break; } if (sw_if_index != ~0) { p = hash_get (dcm->client_by_sw_if_index, sw_if_index); if (p == 0) - return clib_error_return (0, "dhcp client not configured"); + return clib_error_return (0, "dhcp client not configured"); c = pool_elt_at_index (dcm->clients, p[0]); vlib_cli_output (vm, "%U", format_dhcp_client, dcm, c, verbose); return 0; } - pool_foreach (c, dcm->clients, - ({ - vlib_cli_output (vm, "%U", format_dhcp_client, dcm, c, verbose); - })); - + pool_foreach (c, dcm->clients, ( + { + vlib_cli_output (vm, "%U", + format_dhcp_client, dcm, + c, verbose); + } + )); + return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (show_dhcp_client_command, static) = { .path = "show dhcp client", .short_help = "show dhcp client [intfc ][verbose]", .function = show_dhcp_client_command_fn, }; +/* *INDENT-ON* */ -int dhcp_client_add_del (dhcp_client_add_del_args_t * a) +int +dhcp_client_add_del (dhcp_client_add_del_args_t * a) { - dhcp_client_main_t * dcm = &dhcp_client_main; - vlib_main_t * vm = dcm->vlib_main; - dhcp_client_t * c; - uword * p; - fib_prefix_t all_1s = - { - .fp_len = 32, - .fp_addr.ip4.as_u32 = 0xffffffff, - .fp_proto = FIB_PROTOCOL_IP4, + dhcp_client_main_t *dcm = &dhcp_client_main; + vlib_main_t *vm = dcm->vlib_main; + dhcp_client_t *c; + uword *p; + fib_prefix_t all_1s = { + .fp_len = 32, + .fp_addr.ip4.as_u32 = 0xffffffff, + .fp_proto = FIB_PROTOCOL_IP4, }; - fib_prefix_t all_0s = - { - .fp_len = 0, - .fp_addr.ip4.as_u32 = 0x0, - .fp_proto = FIB_PROTOCOL_IP4, + fib_prefix_t all_0s = { + .fp_len = 0, + .fp_addr.ip4.as_u32 = 0x0, + .fp_proto = FIB_PROTOCOL_IP4, }; p = hash_get (dcm->client_by_sw_if_index, a->sw_if_index); @@ -868,57 +840,49 @@ int dhcp_client_add_del (dhcp_client_add_del_args_t * a) c->option_55_data = a->option_55_data; c->hostname = a->hostname; c->client_identifier = a->client_identifier; - do { - c->transaction_id = random_u32 (&dcm->seed); - } while (c->transaction_id == 0); + do + { + c->transaction_id = random_u32 (&dcm->seed); + } + while (c->transaction_id == 0); set_l2_rewrite (dcm, c); hash_set (dcm->client_by_sw_if_index, a->sw_if_index, c - dcm->clients); /* this add is ref counted by FIB so we can add for each itf */ - fib_table_entry_special_add(fib_table_get_index_for_sw_if_index( - FIB_PROTOCOL_IP4, - c->sw_if_index), - &all_1s, - FIB_SOURCE_DHCP, - FIB_ENTRY_FLAG_LOCAL); - - /* + fib_table_entry_special_add (fib_table_get_index_for_sw_if_index + (FIB_PROTOCOL_IP4, c->sw_if_index), + &all_1s, FIB_SOURCE_DHCP, + FIB_ENTRY_FLAG_LOCAL); + + /* * enable the interface to RX IPv4 packets * this is also ref counted */ ip4_sw_interface_enable_disable (c->sw_if_index, 1); - vlib_process_signal_event (vm, dhcp_client_process_node.index, - EVENT_DHCP_CLIENT_WAKEUP, c - dcm->clients); + vlib_process_signal_event (vm, dhcp_client_process_node.index, + EVENT_DHCP_CLIENT_WAKEUP, c - dcm->clients); } else { c = pool_elt_at_index (dcm->clients, p[0]); - fib_table_entry_special_remove(fib_table_get_index_for_sw_if_index( - FIB_PROTOCOL_IP4, - c->sw_if_index), - &all_1s, - FIB_SOURCE_DHCP); + fib_table_entry_special_remove (fib_table_get_index_for_sw_if_index + (FIB_PROTOCOL_IP4, c->sw_if_index), + &all_1s, FIB_SOURCE_DHCP); if (c->router_address.as_u32) - { + { ip46_address_t nh = { - .ip4 = c->router_address, + .ip4 = c->router_address, }; - fib_table_entry_path_remove(fib_table_get_index_for_sw_if_index( - FIB_PROTOCOL_IP4, - c->sw_if_index), - &all_0s, - FIB_SOURCE_DHCP, - DPO_PROTO_IP4, - &nh, - c->sw_if_index, - ~0, - 1, - FIB_ROUTE_PATH_FLAG_NONE); - } + fib_table_entry_path_remove (fib_table_get_index_for_sw_if_index + (FIB_PROTOCOL_IP4, c->sw_if_index), + &all_0s, FIB_SOURCE_DHCP, + DPO_PROTO_IP4, &nh, c->sw_if_index, ~0, + 1, FIB_ROUTE_PATH_FLAG_NONE); + } dhcp_client_remove_rx_address (dcm, c); dhcp_client_release_address (dcm, c); ip4_sw_interface_enable_disable (c->sw_if_index, 0); @@ -935,13 +899,11 @@ int dhcp_client_add_del (dhcp_client_add_del_args_t * a) int dhcp_client_config (vlib_main_t * vm, - u32 sw_if_index, - u8 * hostname, - u8 * client_id, - u32 is_add, - u32 client_index, - void * event_callback, - u32 pid) + u32 sw_if_index, + u8 * hostname, + u8 * client_id, + u32 is_add, + u32 client_index, void *event_callback, u32 pid) { dhcp_client_add_del_args_t _a, *a = &_a; int rv; @@ -952,12 +914,13 @@ dhcp_client_config (vlib_main_t * vm, a->client_index = client_index; a->pid = pid; a->event_callback = event_callback; - vec_validate(a->hostname, strlen((char *)hostname) - 1); - strncpy((char *)a->hostname, (char *)hostname, vec_len(a->hostname)); - vec_validate(a->client_identifier, strlen((char *)client_id) - 1); - strncpy((char *)a->client_identifier, (char *)client_id, vec_len(a->client_identifier)); + vec_validate (a->hostname, strlen ((char *) hostname) - 1); + strncpy ((char *) a->hostname, (char *) hostname, vec_len (a->hostname)); + vec_validate (a->client_identifier, strlen ((char *) client_id) - 1); + strncpy ((char *) a->client_identifier, (char *) client_id, + vec_len (a->client_identifier)); - /* + /* * Option 55 request list. These data precisely match * the Ubuntu dhcp client. YMMV. */ @@ -1003,11 +966,11 @@ dhcp_client_config (vlib_main_t * vm, vec_free (a->option_55_data); if (is_add) - clib_warning ("dhcp client already enabled on intf_idx %d", - sw_if_index); + clib_warning ("dhcp client already enabled on intf_idx %d", + sw_if_index); else - clib_warning ("dhcp client not enabled on on intf_idx %d", - sw_if_index); + clib_warning ("dhcp client not enabled on on intf_idx %d", + sw_if_index); break; default: @@ -1019,30 +982,29 @@ dhcp_client_config (vlib_main_t * vm, static clib_error_t * dhcp_client_set_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { - dhcp_client_main_t * dcm = &dhcp_client_main; + dhcp_client_main_t *dcm = &dhcp_client_main; u32 sw_if_index; - u8 * hostname = 0; + u8 *hostname = 0; u8 sw_if_index_set = 0; int is_add = 1; dhcp_client_add_del_args_t _a, *a = &_a; int rv; - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (unformat (input, "intfc %U", - unformat_vnet_sw_interface, dcm->vnet_main, - &sw_if_index)) - sw_if_index_set = 1; + if (unformat (input, "intfc %U", + unformat_vnet_sw_interface, dcm->vnet_main, &sw_if_index)) + sw_if_index_set = 1; else if (unformat (input, "hostname %v", &hostname)) - ; + ; else if (unformat (input, "del")) - is_add = 0; + is_add = 0; else - break; + break; } if (sw_if_index_set == 0) @@ -1054,7 +1016,7 @@ dhcp_client_set_command_fn (vlib_main_t * vm, a->hostname = hostname; a->client_identifier = format (0, "vpe 1.0%c", 0); - /* + /* * Option 55 request list. These data precisely match * the Ubuntu dhcp client. YMMV. */ @@ -1099,13 +1061,13 @@ dhcp_client_set_command_fn (vlib_main_t * vm, vec_free (a->client_identifier); vec_free (a->option_55_data); if (is_add) - return clib_error_return (0, "dhcp client already enabled on %U", - format_vnet_sw_if_index_name, - dcm->vnet_main, sw_if_index); + return clib_error_return (0, "dhcp client already enabled on %U", + format_vnet_sw_if_index_name, + dcm->vnet_main, sw_if_index); else - return clib_error_return (0, "dhcp client not enabled on %U", - format_vnet_sw_if_index_name, - dcm->vnet_main, sw_if_index); + return clib_error_return (0, "dhcp client not enabled on %U", + format_vnet_sw_if_index_name, + dcm->vnet_main, sw_if_index); break; default: @@ -1115,21 +1077,31 @@ dhcp_client_set_command_fn (vlib_main_t * vm, return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcp_client_set_command, static) = { .path = "set dhcp client", .short_help = "set dhcp client [del] intfc [hostname ]", .function = dhcp_client_set_command_fn, }; +/* *INDENT-ON* */ static clib_error_t * dhcp_client_init (vlib_main_t * vm) { - dhcp_client_main_t * dcm = &dhcp_client_main; + dhcp_client_main_t *dcm = &dhcp_client_main; dcm->vlib_main = vm; - dcm->vnet_main = vnet_get_main(); + dcm->vnet_main = vnet_get_main (); dcm->seed = 0xdeaddabe; return 0; } VLIB_INIT_FUNCTION (dhcp_client_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/dhcp/client.h b/src/vnet/dhcp/client.h index 68c3d7ba98e..d9c7e25d0b2 100644 --- a/src/vnet/dhcp/client.h +++ b/src/vnet/dhcp/client.h @@ -27,13 +27,15 @@ _(DHCP_DISCOVER) \ _(DHCP_REQUEST) \ _(DHCP_BOUND) -typedef enum { +typedef enum +{ #define _(a) a, foreach_dhcp_client_state #undef _ } dhcp_client_state_t; -typedef struct { +typedef struct +{ dhcp_client_state_t state; /* the interface in question */ @@ -50,73 +52,80 @@ typedef struct { u32 transaction_id; /* leased address, other learned info DHCP */ - ip4_address_t leased_address; /* from your_ip_address field */ + ip4_address_t leased_address; /* from your_ip_address field */ ip4_address_t dhcp_server; - u32 subnet_mask_width; /* option 1 */ - ip4_address_t router_address; /* option 3 */ - u32 lease_renewal_interval; /* option 51 */ - u32 lease_lifetime; /* option 59 */ + u32 subnet_mask_width; /* option 1 */ + ip4_address_t router_address; /* option 3 */ + u32 lease_renewal_interval; /* option 51 */ + u32 lease_lifetime; /* option 59 */ /* Requested data (option 55) */ - u8 * option_55_data; + u8 *option_55_data; - u8 * l2_rewrite; + u8 *l2_rewrite; /* hostname and software client identifiers */ - u8 * hostname; - u8 * client_identifier; /* software version, e.g. vpe 1.0*/ + u8 *hostname; + u8 *client_identifier; /* software version, e.g. vpe 1.0 */ /* Information used for event callback */ u32 client_index; u32 pid; - void * event_callback; + void *event_callback; } dhcp_client_t; -typedef struct { +typedef struct +{ /* DHCP client pool */ - dhcp_client_t * clients; - uword * client_by_sw_if_index; + dhcp_client_t *clients; + uword *client_by_sw_if_index; u32 seed; /* convenience */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } dhcp_client_main_t; -typedef struct { +typedef struct +{ int is_add; u32 sw_if_index; /* vectors, consumed by dhcp client code */ - u8 * hostname; - u8 * client_identifier; + u8 *hostname; + u8 *client_identifier; /* Bytes containing requested option numbers */ - u8 * option_55_data; + u8 *option_55_data; /* Information used for event callback */ u32 client_index; u32 pid; - void * event_callback; + void *event_callback; } dhcp_client_add_del_args_t; extern dhcp_client_main_t dhcp_client_main; #define EVENT_DHCP_CLIENT_WAKEUP 1 -int dhcp_client_for_us (u32 bi0, - vlib_buffer_t * b0, - ip4_header_t * ip0, - udp_header_t * u0, - dhcp_header_t * dh0); +int dhcp_client_for_us (u32 bi0, + vlib_buffer_t * b0, + ip4_header_t * ip0, + udp_header_t * u0, dhcp_header_t * dh0); int dhcp_client_config (vlib_main_t * vm, - u32 sw_if_index, - u8 * hostname, - u8 * client_id, - u32 is_add, - u32 client_index, - void *event_callback, - u32 pid); + u32 sw_if_index, + u8 * hostname, + u8 * client_id, + u32 is_add, + u32 client_index, void *event_callback, u32 pid); #endif /* included_dhcp_client_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/dhcp/dhcp4_packet.h b/src/vnet/dhcp/dhcp4_packet.h index 07829f4823c..133a1e135aa 100644 --- a/src/vnet/dhcp/dhcp4_packet.h +++ b/src/vnet/dhcp/dhcp4_packet.h @@ -19,9 +19,10 @@ */ #include -typedef struct { - u8 opcode; /* 1 = request, 2 = reply */ - u8 hardware_type; /* 1 = ethernet */ +typedef struct +{ + u8 opcode; /* 1 = request, 2 = reply */ + u8 hardware_type; /* 1 = ethernet */ u8 hardware_address_length; u8 hops; u32 transaction_identifier; @@ -29,9 +30,9 @@ typedef struct { u16 flags; #define DHCP_FLAG_BROADCAST (1<<15) ip4_address_t client_ip_address; - ip4_address_t your_ip_address; /* use this one */ + ip4_address_t your_ip_address; /* use this one */ ip4_address_t server_ip_address; - ip4_address_t gateway_ip_address; /* use option 3, not this one */ + ip4_address_t gateway_ip_address; /* use option 3, not this one */ u8 client_hardware_address[16]; u8 server_name[64]; u8 boot_filename[128]; @@ -39,28 +40,39 @@ typedef struct { u8 options[0]; } dhcp_header_t; -typedef struct { +typedef struct +{ u8 option; u8 length; - union { + union + { u8 data[0]; u32 data_as_u32[0]; }; -} __attribute__((packed)) dhcp_option_t; +} __attribute__ ((packed)) dhcp_option_t; -typedef enum { - DHCP_PACKET_DISCOVER=1, +typedef enum +{ + DHCP_PACKET_DISCOVER = 1, DHCP_PACKET_OFFER, DHCP_PACKET_REQUEST, - DHCP_PACKET_ACK=5, + DHCP_PACKET_ACK = 5, } dhcp_packet_type_t; typedef enum dhcp_packet_option_t_ { - DHCP_PACKET_OPTION_MSG_TYPE = 53, + DHCP_PACKET_OPTION_MSG_TYPE = 53, } dhcp_packet_option_t; /* charming antique: 99.130.83.99 is the dhcp magic cookie */ #define DHCP_MAGIC (clib_host_to_net_u32(0x63825363)) #endif /* included_vnet_dhcp4_packet_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/dhcp/dhcp4_proxy_node.c b/src/vnet/dhcp/dhcp4_proxy_node.c index cd52be83f71..e84d72c0afb 100644 --- a/src/vnet/dhcp/dhcp4_proxy_node.c +++ b/src/vnet/dhcp/dhcp4_proxy_node.c @@ -21,7 +21,7 @@ #include #include -static char * dhcp_proxy_error_strings[] = { +static char *dhcp_proxy_error_strings[] = { #define dhcp_proxy_error(n,s) s, #include #undef dhcp_proxy_error @@ -32,16 +32,18 @@ static char * dhcp_proxy_error_strings[] = { _ (LOOKUP, "ip4-lookup") \ _ (SEND_TO_CLIENT, "dhcp-proxy-to-client") -typedef enum { +typedef enum +{ #define _(s,n) DHCP_PROXY_TO_SERVER_INPUT_NEXT_##s, foreach_dhcp_proxy_to_server_input_next #undef _ - DHCP_PROXY_TO_SERVER_INPUT_N_NEXT, + DHCP_PROXY_TO_SERVER_INPUT_N_NEXT, } dhcp_proxy_to_server_input_next_t; -typedef struct { +typedef struct +{ /* 0 => to server, 1 => to client */ - int which; + int which; ip4_address_t trace_ip4_address; u32 error; u32 sw_if_index; @@ -63,28 +65,28 @@ format_dhcp_proxy_trace (u8 * s, va_list * args) { CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); - dhcp_proxy_trace_t * t = va_arg (*args, dhcp_proxy_trace_t *); - + dhcp_proxy_trace_t *t = va_arg (*args, dhcp_proxy_trace_t *); + if (t->which == 0) s = format (s, "DHCP proxy: sent to server %U\n", - format_ip4_address, &t->trace_ip4_address, t->error); + format_ip4_address, &t->trace_ip4_address, t->error); else s = format (s, "DHCP proxy: broadcast to client from %U\n", - format_ip4_address, &t->trace_ip4_address); - - if (t->error != (u32)~0) + format_ip4_address, &t->trace_ip4_address); + + if (t->error != (u32) ~ 0) s = format (s, " error: %s\n", dhcp_proxy_error_strings[t->error]); s = format (s, " original_sw_if_index: %d, sw_if_index: %d\n", - t->original_sw_if_index, t->sw_if_index); - + t->original_sw_if_index, t->sw_if_index); + return s; } static u8 * format_dhcp_proxy_header_with_length (u8 * s, va_list * args) { - dhcp_header_t * h = va_arg (*args, dhcp_header_t *); + dhcp_header_t *h = va_arg (*args, dhcp_header_t *); u32 max_header_bytes = va_arg (*args, u32); u32 header_bytes; @@ -99,17 +101,17 @@ format_dhcp_proxy_header_with_length (u8 * s, va_list * args) static uword dhcp_proxy_to_server_input (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * from_frame) + vlib_node_runtime_t * node, + vlib_frame_t * from_frame) { - u32 n_left_from, next_index, * from, * to_next; - dhcp_proxy_main_t * dpm = &dhcp_proxy_main; + u32 n_left_from, next_index, *from, *to_next; + dhcp_proxy_main_t *dpm = &dhcp_proxy_main; from = vlib_frame_vector_args (from_frame); n_left_from = from_frame->n_vectors; - u32 pkts_to_server=0, pkts_to_client=0, pkts_no_server=0; - u32 pkts_no_interface_address=0; - u32 pkts_too_big=0; - ip4_main_t * im = &ip4_main; + u32 pkts_to_server = 0, pkts_to_client = 0, pkts_no_server = 0; + u32 pkts_no_interface_address = 0; + u32 pkts_too_big = 0; + ip4_main_t *im = &ip4_main; next_index = node->cached_next_index; @@ -117,31 +119,30 @@ dhcp_proxy_to_server_input (vlib_main_t * vm, { u32 n_left_to_next; - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from > 0 && n_left_to_next > 0) { u32 bi0; - vlib_buffer_t * b0; - udp_header_t * u0; - dhcp_header_t * h0; - ip4_header_t * ip0; + vlib_buffer_t *b0; + udp_header_t *u0; + dhcp_header_t *h0; + ip4_header_t *ip0; u32 next0; - u32 old0, new0; - ip_csum_t sum0; - u32 error0 = (u32) ~0; - u32 sw_if_index = 0; - u32 original_sw_if_index = 0; - u8 *end = NULL; - u32 fib_index; - dhcp_proxy_t *proxy; - dhcp_server_t *server; - u32 rx_sw_if_index; - dhcp_option_t *o; - u32 len = 0; - vlib_buffer_free_list_t *fl; - u8 is_discover = 0; + u32 old0, new0; + ip_csum_t sum0; + u32 error0 = (u32) ~ 0; + u32 sw_if_index = 0; + u32 original_sw_if_index = 0; + u8 *end = NULL; + u32 fib_index; + dhcp_proxy_t *proxy; + dhcp_server_t *server; + u32 rx_sw_if_index; + dhcp_option_t *o; + u32 len = 0; + vlib_buffer_free_list_t *fl; + u8 is_discover = 0; bi0 = from[0]; from += 1; @@ -149,145 +150,148 @@ dhcp_proxy_to_server_input (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - h0 = vlib_buffer_get_current (b0); + h0 = vlib_buffer_get_current (b0); - /* - * udp_local hands us the DHCP header, need udp hdr, - * ip hdr to relay to server - */ - vlib_buffer_advance (b0, -(sizeof(*u0))); + /* + * udp_local hands us the DHCP header, need udp hdr, + * ip hdr to relay to server + */ + vlib_buffer_advance (b0, -(sizeof (*u0))); u0 = vlib_buffer_get_current (b0); - /* This blows. Return traffic has src_port = 67, dst_port = 67 */ - if (u0->src_port == clib_net_to_host_u16(UDP_DST_PORT_dhcp_to_server)) - { - vlib_buffer_advance (b0, sizeof(*u0)); - next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_SEND_TO_CLIENT; - error0 = 0; - pkts_to_client++; - goto do_enqueue; - } - - rx_sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - - fib_index = im->fib_index_by_sw_if_index [rx_sw_if_index]; - proxy = dhcp_get_proxy(dpm, fib_index, FIB_PROTOCOL_IP4); - - if (PREDICT_FALSE (NULL == proxy)) - { - error0 = DHCP_PROXY_ERROR_NO_SERVER; - next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP; - pkts_no_server++; - goto do_trace; - } - - server = &proxy->dhcp_servers[0]; - vlib_buffer_advance (b0, -(sizeof(*ip0))); - ip0 = vlib_buffer_get_current (b0); - - /* disable UDP checksum */ - u0->checksum = 0; - sum0 = ip0->checksum; - old0 = ip0->dst_address.as_u32; - new0 = server->dhcp_server.ip4.as_u32; - ip0->dst_address.as_u32 = server->dhcp_server.ip4.as_u32; - sum0 = ip_csum_update (sum0, old0, new0, - ip4_header_t /* structure */, - dst_address /* changed member */); - ip0->checksum = ip_csum_fold (sum0); - - sum0 = ip0->checksum; - old0 = ip0->src_address.as_u32; - new0 = proxy->dhcp_src_address.ip4.as_u32; - ip0->src_address.as_u32 = new0; - sum0 = ip_csum_update (sum0, old0, new0, - ip4_header_t /* structure */, - src_address /* changed member */); - ip0->checksum = ip_csum_fold (sum0); - - /* Send to DHCP server via the configured FIB */ - vnet_buffer(b0)->sw_if_index[VLIB_TX] = - server->server_fib_index; - - h0->gateway_ip_address.as_u32 = proxy->dhcp_src_address.ip4.as_u32; - pkts_to_server++; - - o = (dhcp_option_t *) h0->options; - - fib_index = im->fib_index_by_sw_if_index - [vnet_buffer(b0)->sw_if_index[VLIB_RX]]; - - end = b0->data + b0->current_data + b0->current_length; - /* TLVs are not performance-friendly... */ - while (o->option != 0xFF /* end of options */ && (u8 *)o < end) - { - if (DHCP_PACKET_OPTION_MSG_TYPE == o->option) - { - if (DHCP_PACKET_DISCOVER == o->data[0]) - { - is_discover = 1; - } - } - o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); + /* This blows. Return traffic has src_port = 67, dst_port = 67 */ + if (u0->src_port == + clib_net_to_host_u16 (UDP_DST_PORT_dhcp_to_server)) + { + vlib_buffer_advance (b0, sizeof (*u0)); + next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_SEND_TO_CLIENT; + error0 = 0; + pkts_to_client++; + goto do_enqueue; } - fl = vlib_buffer_get_free_list (vm, vlib_buffer_get_free_list_index (b0)); - // start write at (option*)o, some packets have padding - if (((u8 *)o - (u8 *)b0->data + VPP_DHCP_OPTION82_SIZE) > fl->n_data_bytes) - { - next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP; - pkts_too_big++; - goto do_trace; + rx_sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + + fib_index = im->fib_index_by_sw_if_index[rx_sw_if_index]; + proxy = dhcp_get_proxy (dpm, fib_index, FIB_PROTOCOL_IP4); + + if (PREDICT_FALSE (NULL == proxy)) + { + error0 = DHCP_PROXY_ERROR_NO_SERVER; + next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP; + pkts_no_server++; + goto do_trace; } - if ((o->option == 0xFF) && ((u8 *)o <= end)) - { - vnet_main_t *vnm = vnet_get_main(); - u16 old_l0, new_l0; - ip4_address_t _ia0, * ia0 = &_ia0; - dhcp_vss_t *vss; - vnet_sw_interface_t *swif; - sw_if_index = 0; - original_sw_if_index = 0; - - original_sw_if_index = sw_if_index = - vnet_buffer(b0)->sw_if_index[VLIB_RX]; - swif = vnet_get_sw_interface (vnm, sw_if_index); - if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) - sw_if_index = swif->unnumbered_sw_if_index; - - /* - * Get the first ip4 address on the [client-side] - * RX interface, if not unnumbered. otherwise use - * the loopback interface's ip address. - */ - ia0 = ip4_interface_first_address(&ip4_main, sw_if_index, 0); - - if (ia0 == 0) - { - error0 = DHCP_PROXY_ERROR_NO_INTERFACE_ADDRESS; - next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP; - pkts_no_interface_address++; - goto do_trace; - } - - /* Add option 82 */ - o->option = 82; /* option 82 */ - o->length = 12; /* 12 octets to follow */ - o->data[0] = 1; /* suboption 1, circuit ID (=FIB id) */ - o->data[1] = 4; /* length of suboption */ - u32 *o_ifid = (u32 *) &o->data[2]; + server = &proxy->dhcp_servers[0]; + vlib_buffer_advance (b0, -(sizeof (*ip0))); + ip0 = vlib_buffer_get_current (b0); + + /* disable UDP checksum */ + u0->checksum = 0; + sum0 = ip0->checksum; + old0 = ip0->dst_address.as_u32; + new0 = server->dhcp_server.ip4.as_u32; + ip0->dst_address.as_u32 = server->dhcp_server.ip4.as_u32; + sum0 = ip_csum_update (sum0, old0, new0, + ip4_header_t /* structure */ , + dst_address /* changed member */ ); + ip0->checksum = ip_csum_fold (sum0); + + sum0 = ip0->checksum; + old0 = ip0->src_address.as_u32; + new0 = proxy->dhcp_src_address.ip4.as_u32; + ip0->src_address.as_u32 = new0; + sum0 = ip_csum_update (sum0, old0, new0, + ip4_header_t /* structure */ , + src_address /* changed member */ ); + ip0->checksum = ip_csum_fold (sum0); + + /* Send to DHCP server via the configured FIB */ + vnet_buffer (b0)->sw_if_index[VLIB_TX] = server->server_fib_index; + + h0->gateway_ip_address.as_u32 = proxy->dhcp_src_address.ip4.as_u32; + pkts_to_server++; + + o = (dhcp_option_t *) h0->options; + + fib_index = im->fib_index_by_sw_if_index + [vnet_buffer (b0)->sw_if_index[VLIB_RX]]; + + end = b0->data + b0->current_data + b0->current_length; + /* TLVs are not performance-friendly... */ + while (o->option != 0xFF /* end of options */ && (u8 *) o < end) + { + if (DHCP_PACKET_OPTION_MSG_TYPE == o->option) + { + if (DHCP_PACKET_DISCOVER == o->data[0]) + { + is_discover = 1; + } + } + o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); + } + + fl = + vlib_buffer_get_free_list (vm, + vlib_buffer_get_free_list_index (b0)); + // start write at (option*)o, some packets have padding + if (((u8 *) o - (u8 *) b0->data + VPP_DHCP_OPTION82_SIZE) > + fl->n_data_bytes) + { + next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP; + pkts_too_big++; + goto do_trace; + } + + if ((o->option == 0xFF) && ((u8 *) o <= end)) + { + vnet_main_t *vnm = vnet_get_main (); + u16 old_l0, new_l0; + ip4_address_t _ia0, *ia0 = &_ia0; + dhcp_vss_t *vss; + vnet_sw_interface_t *swif; + sw_if_index = 0; + original_sw_if_index = 0; + + original_sw_if_index = sw_if_index = + vnet_buffer (b0)->sw_if_index[VLIB_RX]; + swif = vnet_get_sw_interface (vnm, sw_if_index); + if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) + sw_if_index = swif->unnumbered_sw_if_index; + + /* + * Get the first ip4 address on the [client-side] + * RX interface, if not unnumbered. otherwise use + * the loopback interface's ip address. + */ + ia0 = ip4_interface_first_address (&ip4_main, sw_if_index, 0); + + if (ia0 == 0) + { + error0 = DHCP_PROXY_ERROR_NO_INTERFACE_ADDRESS; + next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP; + pkts_no_interface_address++; + goto do_trace; + } + + /* Add option 82 */ + o->option = 82; /* option 82 */ + o->length = 12; /* 12 octets to follow */ + o->data[0] = 1; /* suboption 1, circuit ID (=FIB id) */ + o->data[1] = 4; /* length of suboption */ + u32 *o_ifid = (u32 *) & o->data[2]; *o_ifid = clib_host_to_net_u32 (original_sw_if_index); - o->data[6] = 5; /* suboption 5 (client RX intfc address) */ - o->data[7] = 4; /* length 4 */ - u32 *o_addr = (u32 *) &o->data[8]; + o->data[6] = 5; /* suboption 5 (client RX intfc address) */ + o->data[7] = 4; /* length 4 */ + u32 *o_addr = (u32 *) & o->data[8]; *o_addr = ia0->as_u32; - o->data[12] = 0xFF; + o->data[12] = 0xFF; - vss = dhcp_get_vss_info (dpm, fib_index, FIB_PROTOCOL_IP4); - if (vss) - { - u32 id_len; /* length of VPN ID */ + vss = dhcp_get_vss_info (dpm, fib_index, FIB_PROTOCOL_IP4); + if (vss) + { + u32 id_len; /* length of VPN ID */ if (vss->vss_type == VSS_TYPE_VPN_ID) { @@ -299,120 +303,121 @@ dhcp_proxy_to_server_input (vlib_main_t * vm, id_len = vec_len (vss->vpn_ascii_id); memcpy (&o->data[15], vss->vpn_ascii_id, id_len); } - else /* must be VSS_TYPE_DEFAULT, no VPN ID */ - id_len = 0; + else /* must be VSS_TYPE_DEFAULT, no VPN ID */ + id_len = 0; - o->data[12] = 151; /* vss suboption */ + o->data[12] = 151; /* vss suboption */ o->data[13] = id_len + 1; /* length: vss_type + id_len */ o->data[14] = vss->vss_type; /* vss option type */ o->data[15 + id_len] = 152; /* vss control suboption */ o->data[16 + id_len] = 0; /* length */ o->data[17 + id_len] = 0xFF; /* "end-of-options" (0xFF) */ /* 5 bytes for suboption headers 151+len, 152+len and 0xFF */ - o->length += id_len + 5; - } - - len = o->length + 3; - b0->current_length += len; - /* Fix IP header length and checksum */ - old_l0 = ip0->length; - new_l0 = clib_net_to_host_u16 (old_l0); - new_l0 += len; - new_l0 = clib_host_to_net_u16 (new_l0); - ip0->length = new_l0; - sum0 = ip0->checksum; - sum0 = ip_csum_update (sum0, old_l0, new_l0, ip4_header_t, - length /* changed member */); - ip0->checksum = ip_csum_fold (sum0); - - /* Fix UDP length */ - new_l0 = clib_net_to_host_u16 (u0->length); - new_l0 += len; - u0->length = clib_host_to_net_u16 (new_l0); - } - else + o->length += id_len + 5; + } + + len = o->length + 3; + b0->current_length += len; + /* Fix IP header length and checksum */ + old_l0 = ip0->length; + new_l0 = clib_net_to_host_u16 (old_l0); + new_l0 += len; + new_l0 = clib_host_to_net_u16 (new_l0); + ip0->length = new_l0; + sum0 = ip0->checksum; + sum0 = ip_csum_update (sum0, old_l0, new_l0, ip4_header_t, + length /* changed member */ ); + ip0->checksum = ip_csum_fold (sum0); + + /* Fix UDP length */ + new_l0 = clib_net_to_host_u16 (u0->length); + new_l0 += len; + u0->length = clib_host_to_net_u16 (new_l0); + } + else { - vlib_node_increment_counter - (vm, dhcp_proxy_to_server_node.index, - DHCP_PROXY_ERROR_OPTION_82_ERROR, 1); + vlib_node_increment_counter + (vm, dhcp_proxy_to_server_node.index, + DHCP_PROXY_ERROR_OPTION_82_ERROR, 1); } - - next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP; - - /* - * If we have multiple servers configured and this is the - * client's discover message, then send copies to each of - * those servers - */ - if (is_discover && vec_len(proxy->dhcp_servers) > 1) - { - u32 ii; - - for (ii = 1; ii < vec_len(proxy->dhcp_servers); ii++) - { - vlib_buffer_t *c0; - u32 ci0; - - c0 = vlib_buffer_copy(vm, b0); - ci0 = vlib_get_buffer_index(vm, c0); - server = &proxy->dhcp_servers[ii]; - - ip0 = vlib_buffer_get_current (c0); - - sum0 = ip0->checksum; - old0 = ip0->dst_address.as_u32; - new0 = server->dhcp_server.ip4.as_u32; - ip0->dst_address.as_u32 = server->dhcp_server.ip4.as_u32; - sum0 = ip_csum_update (sum0, old0, new0, - ip4_header_t /* structure */, - dst_address /* changed member */); - ip0->checksum = ip_csum_fold (sum0); - - to_next[0] = ci0; - to_next += 1; - n_left_to_next -= 1; - - vlib_validate_buffer_enqueue_x1 (vm, node, next_index, - to_next, n_left_to_next, - ci0, next0); - - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - dhcp_proxy_trace_t *tr; - - tr = vlib_add_trace (vm, node, c0, sizeof (*tr)); - tr->which = 0; /* to server */ - tr->error = error0; - tr->original_sw_if_index = original_sw_if_index; - tr->sw_if_index = sw_if_index; - if (next0 == DHCP_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP) - tr->trace_ip4_address.as_u32 = server->dhcp_server.ip4.as_u32; + + next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP; + + /* + * If we have multiple servers configured and this is the + * client's discover message, then send copies to each of + * those servers + */ + if (is_discover && vec_len (proxy->dhcp_servers) > 1) + { + u32 ii; + + for (ii = 1; ii < vec_len (proxy->dhcp_servers); ii++) + { + vlib_buffer_t *c0; + u32 ci0; + + c0 = vlib_buffer_copy (vm, b0); + ci0 = vlib_get_buffer_index (vm, c0); + server = &proxy->dhcp_servers[ii]; + + ip0 = vlib_buffer_get_current (c0); + + sum0 = ip0->checksum; + old0 = ip0->dst_address.as_u32; + new0 = server->dhcp_server.ip4.as_u32; + ip0->dst_address.as_u32 = server->dhcp_server.ip4.as_u32; + sum0 = ip_csum_update (sum0, old0, new0, + ip4_header_t /* structure */ , + dst_address /* changed member */ ); + ip0->checksum = ip_csum_fold (sum0); + + to_next[0] = ci0; + to_next += 1; + n_left_to_next -= 1; + + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, n_left_to_next, + ci0, next0); + + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + dhcp_proxy_trace_t *tr; + + tr = vlib_add_trace (vm, node, c0, sizeof (*tr)); + tr->which = 0; /* to server */ + tr->error = error0; + tr->original_sw_if_index = original_sw_if_index; + tr->sw_if_index = sw_if_index; + if (next0 == DHCP_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP) + tr->trace_ip4_address.as_u32 = + server->dhcp_server.ip4.as_u32; } - if (PREDICT_FALSE(0 == n_left_to_next)) - { - vlib_put_next_frame (vm, node, next_index, - n_left_to_next); - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); - } - } - } - do_trace: - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - dhcp_proxy_trace_t *tr = vlib_add_trace (vm, node, - b0, sizeof (*tr)); - tr->which = 0; /* to server */ - tr->error = error0; - tr->original_sw_if_index = original_sw_if_index; - tr->sw_if_index = sw_if_index; - if (next0 == DHCP_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP) - tr->trace_ip4_address.as_u32 = - proxy->dhcp_servers[0].dhcp_server.ip4.as_u32; - } - - do_enqueue: + if (PREDICT_FALSE (0 == n_left_to_next)) + { + vlib_put_next_frame (vm, node, next_index, + n_left_to_next); + vlib_get_next_frame (vm, node, next_index, + to_next, n_left_to_next); + } + } + } + do_trace: + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + dhcp_proxy_trace_t *tr = vlib_add_trace (vm, node, + b0, sizeof (*tr)); + tr->which = 0; /* to server */ + tr->error = error0; + tr->original_sw_if_index = original_sw_if_index; + tr->sw_if_index = sw_if_index; + if (next0 == DHCP_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP) + tr->trace_ip4_address.as_u32 = + proxy->dhcp_servers[0].dhcp_server.ip4.as_u32; + } + + do_enqueue: to_next[0] = bi0; to_next += 1; n_left_to_next -= 1; @@ -426,23 +431,22 @@ dhcp_proxy_to_server_input (vlib_main_t * vm, } vlib_node_increment_counter (vm, dhcp_proxy_to_server_node.index, - DHCP_PROXY_ERROR_RELAY_TO_CLIENT, - pkts_to_client); + DHCP_PROXY_ERROR_RELAY_TO_CLIENT, + pkts_to_client); + vlib_node_increment_counter (vm, dhcp_proxy_to_server_node.index, + DHCP_PROXY_ERROR_RELAY_TO_SERVER, + pkts_to_server); vlib_node_increment_counter (vm, dhcp_proxy_to_server_node.index, - DHCP_PROXY_ERROR_RELAY_TO_SERVER, - pkts_to_server); + DHCP_PROXY_ERROR_NO_SERVER, pkts_no_server); vlib_node_increment_counter (vm, dhcp_proxy_to_server_node.index, - DHCP_PROXY_ERROR_NO_SERVER, - pkts_no_server); + DHCP_PROXY_ERROR_NO_INTERFACE_ADDRESS, + pkts_no_interface_address); vlib_node_increment_counter (vm, dhcp_proxy_to_server_node.index, - DHCP_PROXY_ERROR_NO_INTERFACE_ADDRESS, - pkts_no_interface_address); - vlib_node_increment_counter (vm, dhcp_proxy_to_server_node.index, - DHCP_PROXY_ERROR_PKT_TOO_BIG, - pkts_too_big); + DHCP_PROXY_ERROR_PKT_TOO_BIG, pkts_too_big); return from_frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (dhcp_proxy_to_server_node, static) = { .function = dhcp_proxy_to_server_input, .name = "dhcp-proxy-to-server", @@ -465,17 +469,18 @@ VLIB_REGISTER_NODE (dhcp_proxy_to_server_node, static) = { .unformat_buffer = unformat_dhcp_proxy_header, #endif }; +/* *INDENT-ON* */ static uword dhcp_proxy_to_client_input (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * from_frame) + vlib_node_runtime_t * node, + vlib_frame_t * from_frame) { - u32 n_left_from, * from; + u32 n_left_from, *from; ethernet_main_t *em = ethernet_get_main (vm); - dhcp_proxy_main_t * dpm = &dhcp_proxy_main; - vnet_main_t * vnm = vnet_get_main(); - ip4_main_t * im = &ip4_main; + dhcp_proxy_main_t *dpm = &dhcp_proxy_main; + vnet_main_t *vnm = vnet_get_main (); + ip4_main_t *im = &ip4_main; from = vlib_frame_vector_args (from_frame); n_left_from = from_frame->n_vectors; @@ -483,28 +488,28 @@ dhcp_proxy_to_client_input (vlib_main_t * vm, while (n_left_from > 0) { u32 bi0; - vlib_buffer_t * b0; - udp_header_t * u0; - dhcp_header_t * h0; - ip4_header_t * ip0 = 0; - ip4_address_t * ia0 = 0; + vlib_buffer_t *b0; + udp_header_t *u0; + dhcp_header_t *h0; + ip4_header_t *ip0 = 0; + ip4_address_t *ia0 = 0; u32 old0, new0; ip_csum_t sum0; ethernet_interface_t *ei0; ethernet_header_t *mac0; vnet_hw_interface_t *hi0; vlib_frame_t *f0; - u32 * to_next0; + u32 *to_next0; u32 sw_if_index = ~0; vnet_sw_interface_t *si0; - u32 error0 = (u32)~0; + u32 error0 = (u32) ~ 0; vnet_sw_interface_t *swif; u32 fib_index; dhcp_proxy_t *proxy; dhcp_server_t *server; - u32 original_sw_if_index = (u32) ~0; + u32 original_sw_if_index = (u32) ~ 0; ip4_address_t relay_addr = { - .as_u32 = 0, + .as_u32 = 0, }; bi0 = from[0]; @@ -514,118 +519,119 @@ dhcp_proxy_to_client_input (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); h0 = vlib_buffer_get_current (b0); - /* - * udp_local hands us the DHCP header, need udp hdr, + /* + * udp_local hands us the DHCP header, need udp hdr, * ip hdr to relay to client */ - vlib_buffer_advance (b0, -(sizeof(*u0))); + vlib_buffer_advance (b0, -(sizeof (*u0))); u0 = vlib_buffer_get_current (b0); - vlib_buffer_advance (b0, -(sizeof(*ip0))); + vlib_buffer_advance (b0, -(sizeof (*ip0))); ip0 = vlib_buffer_get_current (b0); /* Consumed by dhcp client code? */ if (dhcp_client_for_us (bi0, b0, ip0, u0, h0)) - continue; - - if (1 /* dpm->insert_option_82 */) - { - dhcp_option_t *o = (dhcp_option_t *) h0->options; - dhcp_option_t *sub; - - /* Parse through TLVs looking for option 82. - The circuit-ID is the FIB number we need - to track down the client-facing interface */ - - while (o->option != 0xFF /* end of options */ && - (u8 *) o < (b0->data + b0->current_data + b0->current_length)) - { - if (o->option == 82) - { - u32 vss_exist = 0; - u32 vss_ctrl = 0; - sub = (dhcp_option_t *) &o->data[0]; - while (sub->option != 0xFF /* end of options */ && - (u8 *) sub < (u8 *)(o + o->length)) { - /* If this is one of ours, it will have - total length 12, circuit-id suboption type, - and the sw_if_index */ - if (sub->option == 1 && sub->length == 4) - { - sw_if_index = ((sub->data[0] << 24) | - (sub->data[1] << 16) | - (sub->data[2] << 8) | - (sub->data[3])); - } - else if (sub->option == 5 && sub->length == 4) - { - relay_addr.as_u8[0] = sub->data[0]; - relay_addr.as_u8[1] = sub->data[1]; - relay_addr.as_u8[2] = sub->data[2]; - relay_addr.as_u8[3] = sub->data[3]; - } - else if (sub->option == 151 && - sub->length == 7 && - sub->data[0] == 1) - vss_exist = 1; - else if (sub->option == 152 && sub->length == 0) - vss_ctrl = 1; - sub = (dhcp_option_t *) - (((uword) sub) + (sub->length + 2)); - } - if (vss_ctrl && vss_exist) - vlib_node_increment_counter - (vm, dhcp_proxy_to_client_node.index, - DHCP_PROXY_ERROR_OPTION_82_VSS_NOT_PROCESSED, 1); - - } - o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); - } - } - - if (sw_if_index == (u32)~0) - { - error0 = DHCP_PROXY_ERROR_NO_OPTION_82; - - drop_packet: - vlib_node_increment_counter (vm, dhcp_proxy_to_client_node.index, - error0, 1); - f0 = vlib_get_frame_to_node (vm, dpm->error_drop_node_index); - to_next0 = vlib_frame_vector_args (f0); - to_next0[0] = bi0; - f0->n_vectors = 1; - vlib_put_frame_to_node (vm, dpm->error_drop_node_index, f0); - goto do_trace; - } - + continue; + + if (1 /* dpm->insert_option_82 */ ) + { + dhcp_option_t *o = (dhcp_option_t *) h0->options; + dhcp_option_t *sub; + + /* Parse through TLVs looking for option 82. + The circuit-ID is the FIB number we need + to track down the client-facing interface */ + + while (o->option != 0xFF /* end of options */ && + (u8 *) o < + (b0->data + b0->current_data + b0->current_length)) + { + if (o->option == 82) + { + u32 vss_exist = 0; + u32 vss_ctrl = 0; + sub = (dhcp_option_t *) & o->data[0]; + while (sub->option != 0xFF /* end of options */ && + (u8 *) sub < (u8 *) (o + o->length)) + { + /* If this is one of ours, it will have + total length 12, circuit-id suboption type, + and the sw_if_index */ + if (sub->option == 1 && sub->length == 4) + { + sw_if_index = ((sub->data[0] << 24) | + (sub->data[1] << 16) | + (sub->data[2] << 8) | + (sub->data[3])); + } + else if (sub->option == 5 && sub->length == 4) + { + relay_addr.as_u8[0] = sub->data[0]; + relay_addr.as_u8[1] = sub->data[1]; + relay_addr.as_u8[2] = sub->data[2]; + relay_addr.as_u8[3] = sub->data[3]; + } + else if (sub->option == 151 && + sub->length == 7 && sub->data[0] == 1) + vss_exist = 1; + else if (sub->option == 152 && sub->length == 0) + vss_ctrl = 1; + sub = (dhcp_option_t *) + (((uword) sub) + (sub->length + 2)); + } + if (vss_ctrl && vss_exist) + vlib_node_increment_counter + (vm, dhcp_proxy_to_client_node.index, + DHCP_PROXY_ERROR_OPTION_82_VSS_NOT_PROCESSED, 1); + + } + o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); + } + } + + if (sw_if_index == (u32) ~ 0) + { + error0 = DHCP_PROXY_ERROR_NO_OPTION_82; + + drop_packet: + vlib_node_increment_counter (vm, dhcp_proxy_to_client_node.index, + error0, 1); + f0 = vlib_get_frame_to_node (vm, dpm->error_drop_node_index); + to_next0 = vlib_frame_vector_args (f0); + to_next0[0] = bi0; + f0->n_vectors = 1; + vlib_put_frame_to_node (vm, dpm->error_drop_node_index, f0); + goto do_trace; + } + if (relay_addr.as_u32 == 0) - { - error0 = DHCP_PROXY_ERROR_BAD_OPTION_82_ADDR; - goto drop_packet; - } + { + error0 = DHCP_PROXY_ERROR_BAD_OPTION_82_ADDR; + goto drop_packet; + } if (sw_if_index >= vec_len (im->fib_index_by_sw_if_index)) - { - error0 = DHCP_PROXY_ERROR_BAD_OPTION_82_ITF; - goto drop_packet; - } + { + error0 = DHCP_PROXY_ERROR_BAD_OPTION_82_ITF; + goto drop_packet; + } - fib_index = im->fib_index_by_sw_if_index [sw_if_index]; - proxy = dhcp_get_proxy(dpm, fib_index, FIB_PROTOCOL_IP4); + fib_index = im->fib_index_by_sw_if_index[sw_if_index]; + proxy = dhcp_get_proxy (dpm, fib_index, FIB_PROTOCOL_IP4); if (PREDICT_FALSE (NULL == proxy)) - { - error0 = DHCP_PROXY_ERROR_NO_SERVER; - goto drop_packet; - } - - vec_foreach(server, proxy->dhcp_servers) - { - if (ip0->src_address.as_u32 == server->dhcp_server.ip4.as_u32) - { - goto server_found; - } - } + { + error0 = DHCP_PROXY_ERROR_NO_SERVER; + goto drop_packet; + } + + vec_foreach (server, proxy->dhcp_servers) + { + if (ip0->src_address.as_u32 == server->dhcp_server.ip4.as_u32) + { + goto server_found; + } + } error0 = DHCP_PROXY_ERROR_BAD_SVR_FIB_OR_ADDRESS; goto drop_packet; @@ -636,20 +642,20 @@ dhcp_proxy_to_client_input (vlib_main_t * vm, swif = vnet_get_sw_interface (vnm, sw_if_index); original_sw_if_index = sw_if_index; if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) - sw_if_index = swif->unnumbered_sw_if_index; + sw_if_index = swif->unnumbered_sw_if_index; ia0 = ip4_interface_first_address (&ip4_main, sw_if_index, 0); if (ia0 == 0) - { - error0 = DHCP_PROXY_ERROR_NO_INTERFACE_ADDRESS; - goto drop_packet; - } + { + error0 = DHCP_PROXY_ERROR_NO_INTERFACE_ADDRESS; + goto drop_packet; + } if (relay_addr.as_u32 != ia0->as_u32) - { - error0 = DHCP_PROXY_ERROR_BAD_YIADDR; - goto drop_packet; - } + { + error0 = DHCP_PROXY_ERROR_BAD_YIADDR; + goto drop_packet; + } u0->checksum = 0; u0->dst_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcp_to_client); @@ -657,24 +663,22 @@ dhcp_proxy_to_client_input (vlib_main_t * vm, old0 = ip0->dst_address.as_u32; new0 = 0xFFFFFFFF; ip0->dst_address.as_u32 = new0; - sum0 = ip_csum_update (sum0, old0, new0, - ip4_header_t /* structure */, - dst_address /* offset of changed member */); + sum0 = ip_csum_update (sum0, old0, new0, ip4_header_t /* structure */ , + dst_address /* offset of changed member */ ); ip0->checksum = ip_csum_fold (sum0); sum0 = ip0->checksum; old0 = ip0->src_address.as_u32; new0 = ia0->as_u32; ip0->src_address.as_u32 = new0; - sum0 = ip_csum_update (sum0, old0, new0, - ip4_header_t /* structure */, - src_address /* offset of changed member */); + sum0 = ip_csum_update (sum0, old0, new0, ip4_header_t /* structure */ , + src_address /* offset of changed member */ ); ip0->checksum = ip_csum_fold (sum0); - vlib_buffer_advance (b0, -(sizeof(ethernet_header_t))); + vlib_buffer_advance (b0, -(sizeof (ethernet_header_t))); si0 = vnet_get_sw_interface (vnm, original_sw_if_index); if (si0->type == VNET_SW_INTERFACE_TYPE_SUB) - vlib_buffer_advance (b0, -4 /* space for VLAN tag */); + vlib_buffer_advance (b0, -4 /* space for VLAN tag */ ); mac0 = vlib_buffer_get_current (b0); @@ -683,11 +687,11 @@ dhcp_proxy_to_client_input (vlib_main_t * vm, clib_memcpy (mac0->src_address, ei0->address, sizeof (ei0->address)); memset (mac0->dst_address, 0xff, sizeof (mac0->dst_address)); mac0->type = (si0->type == VNET_SW_INTERFACE_TYPE_SUB) ? - clib_net_to_host_u16(0x8100) : clib_net_to_host_u16 (0x0800); + clib_net_to_host_u16 (0x8100) : clib_net_to_host_u16 (0x0800); if (si0->type == VNET_SW_INTERFACE_TYPE_SUB) { - u32 * vlan_tag = (u32 *)(mac0+1); + u32 *vlan_tag = (u32 *) (mac0 + 1); u32 tmp; tmp = (si0->sub.id << 16) | 0x0800; *vlan_tag = clib_host_to_net_u32 (tmp); @@ -701,20 +705,21 @@ dhcp_proxy_to_client_input (vlib_main_t * vm, vlib_put_frame_to_node (vm, hi0->output_node_index, f0); do_trace: - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - dhcp_proxy_trace_t *tr = vlib_add_trace (vm, node, - b0, sizeof (*tr)); - tr->which = 1; /* to client */ - tr->trace_ip4_address.as_u32 = ia0 ? ia0->as_u32 : 0; - tr->error = error0; - tr->original_sw_if_index = original_sw_if_index; - tr->sw_if_index = sw_if_index; - } + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + dhcp_proxy_trace_t *tr = vlib_add_trace (vm, node, + b0, sizeof (*tr)); + tr->which = 1; /* to client */ + tr->trace_ip4_address.as_u32 = ia0 ? ia0->as_u32 : 0; + tr->error = error0; + tr->original_sw_if_index = original_sw_if_index; + tr->sw_if_index = sw_if_index; + } } return from_frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (dhcp_proxy_to_client_node, static) = { .function = dhcp_proxy_to_client_input, .name = "dhcp-proxy-to-client", @@ -729,21 +734,22 @@ VLIB_REGISTER_NODE (dhcp_proxy_to_client_node, static) = { .unformat_buffer = unformat_dhcp_proxy_header, #endif }; +/* *INDENT-ON* */ static clib_error_t * dhcp4_proxy_init (vlib_main_t * vm) { - dhcp_proxy_main_t * dm = &dhcp_proxy_main; - vlib_node_t * error_drop_node; + dhcp_proxy_main_t *dm = &dhcp_proxy_main; + vlib_node_t *error_drop_node; error_drop_node = vlib_get_node_by_name (vm, (u8 *) "error-drop"); dm->error_drop_node_index = error_drop_node->index; - udp_register_dst_port (vm, UDP_DST_PORT_dhcp_to_client, - dhcp_proxy_to_client_node.index, 1 /* is_ip4 */); + udp_register_dst_port (vm, UDP_DST_PORT_dhcp_to_client, + dhcp_proxy_to_client_node.index, 1 /* is_ip4 */ ); - udp_register_dst_port (vm, UDP_DST_PORT_dhcp_to_server, - dhcp_proxy_to_server_node.index, 1 /* is_ip4 */); + udp_register_dst_port (vm, UDP_DST_PORT_dhcp_to_server, + dhcp_proxy_to_server_node.index, 1 /* is_ip4 */ ); return 0; } @@ -752,56 +758,51 @@ dhcp4_proxy_init (vlib_main_t * vm) VLIB_INIT_FUNCTION (dhcp4_proxy_init); int -dhcp4_proxy_set_server (ip46_address_t *addr, - ip46_address_t *src_addr, - u32 rx_table_id, - u32 server_table_id, - int is_del) +dhcp4_proxy_set_server (ip46_address_t * addr, + ip46_address_t * src_addr, + u32 rx_table_id, u32 server_table_id, int is_del) { u32 rx_fib_index = 0; int rc = 0; - const fib_prefix_t all_1s = - { - .fp_len = 32, - .fp_addr.ip4.as_u32 = 0xffffffff, - .fp_proto = FIB_PROTOCOL_IP4, + const fib_prefix_t all_1s = { + .fp_len = 32, + .fp_addr.ip4.as_u32 = 0xffffffff, + .fp_proto = FIB_PROTOCOL_IP4, }; - if (ip46_address_is_zero(addr)) + if (ip46_address_is_zero (addr)) return VNET_API_ERROR_INVALID_DST_ADDRESS; - - if (ip46_address_is_zero(src_addr)) + + if (ip46_address_is_zero (src_addr)) return VNET_API_ERROR_INVALID_SRC_ADDRESS; - rx_fib_index = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4, - rx_table_id, - FIB_SOURCE_DHCP); + rx_fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, + rx_table_id, + FIB_SOURCE_DHCP); if (is_del) { if (dhcp_proxy_server_del (FIB_PROTOCOL_IP4, rx_fib_index, - addr, server_table_id)) - { - fib_table_entry_special_remove(rx_fib_index, - &all_1s, - FIB_SOURCE_DHCP); - fib_table_unlock (rx_fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_DHCP); - } + addr, server_table_id)) + { + fib_table_entry_special_remove (rx_fib_index, + &all_1s, FIB_SOURCE_DHCP); + fib_table_unlock (rx_fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_DHCP); + } } else - { + { if (dhcp_proxy_server_add (FIB_PROTOCOL_IP4, - addr, src_addr, - rx_fib_index, server_table_id)) - { - fib_table_entry_special_add(rx_fib_index, - &all_1s, - FIB_SOURCE_DHCP, - FIB_ENTRY_FLAG_LOCAL); - fib_table_lock (rx_fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_DHCP); - } - } + addr, src_addr, + rx_fib_index, server_table_id)) + { + fib_table_entry_special_add (rx_fib_index, + &all_1s, + FIB_SOURCE_DHCP, FIB_ENTRY_FLAG_LOCAL); + fib_table_lock (rx_fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_DHCP); + } + } fib_table_unlock (rx_fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_DHCP); return (rc); @@ -809,243 +810,255 @@ dhcp4_proxy_set_server (ip46_address_t *addr, static clib_error_t * dhcp4_proxy_set_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { ip46_address_t server_addr, src_addr; u32 server_table_id = 0, rx_table_id = 0; int is_del = 0; int set_src = 0, set_server = 0; - memset(&server_addr, 0, sizeof(server_addr)); - memset(&src_addr, 0, sizeof(src_addr)); + memset (&server_addr, 0, sizeof (server_addr)); + memset (&src_addr, 0, sizeof (src_addr)); - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (unformat (input, "server %U", - unformat_ip4_address, &server_addr.ip4)) - set_server = 1; + if (unformat (input, "server %U", + unformat_ip4_address, &server_addr.ip4)) + set_server = 1; else if (unformat (input, "server-fib-id %d", &server_table_id)) - ; + ; else if (unformat (input, "rx-fib-id %d", &rx_table_id)) - ; - else if (unformat(input, "src-address %U", - unformat_ip4_address, &src_addr.ip4)) - set_src = 1; - else if (unformat (input, "delete") || - unformat (input, "del")) - is_del = 1; + ; + else if (unformat (input, "src-address %U", + unformat_ip4_address, &src_addr.ip4)) + set_src = 1; + else if (unformat (input, "delete") || unformat (input, "del")) + is_del = 1; else - break; + break; } if (is_del || (set_server && set_src)) { int rv; - rv = dhcp4_proxy_set_server (&server_addr, &src_addr, rx_table_id, - server_table_id, is_del); + rv = dhcp4_proxy_set_server (&server_addr, &src_addr, rx_table_id, + server_table_id, is_del); switch (rv) - { - case 0: - return 0; - - case VNET_API_ERROR_INVALID_DST_ADDRESS: - return clib_error_return (0, "Invalid server address"); - - case VNET_API_ERROR_INVALID_SRC_ADDRESS: - return clib_error_return (0, "Invalid src address"); - - case VNET_API_ERROR_NO_SUCH_ENTRY: - return clib_error_return - (0, "Fib id %d: no per-fib DHCP server configured", rx_table_id); - - default: - return clib_error_return (0, "BUG: rv %d", rv); - } + { + case 0: + return 0; + + case VNET_API_ERROR_INVALID_DST_ADDRESS: + return clib_error_return (0, "Invalid server address"); + + case VNET_API_ERROR_INVALID_SRC_ADDRESS: + return clib_error_return (0, "Invalid src address"); + + case VNET_API_ERROR_NO_SUCH_ENTRY: + return clib_error_return + (0, "Fib id %d: no per-fib DHCP server configured", rx_table_id); + + default: + return clib_error_return (0, "BUG: rv %d", rv); + } } else return clib_error_return (0, "parse error`%U'", - format_unformat_error, input); + format_unformat_error, input); } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcp_proxy_set_command, static) = { .path = "set dhcp proxy", .short_help = "set dhcp proxy [del] server src-address [server-fib-id ] [rx-fib-id ]", .function = dhcp4_proxy_set_command_fn, }; +/* *INDENT-ON* */ static u8 * format_dhcp4_proxy_server (u8 * s, va_list * args) { dhcp_proxy_t *proxy = va_arg (*args, dhcp_proxy_t *); - ip4_fib_t * rx_fib, * server_fib; + ip4_fib_t *rx_fib, *server_fib; dhcp_server_t *server; if (proxy == 0) { - s = format (s, "%=14s%=16s%s", "RX FIB", "Src Address", - "Servers FIB,Address"); + s = format (s, "%=14s%=16s%s", "RX FIB", "Src Address", + "Servers FIB,Address"); return s; } - rx_fib = ip4_fib_get(proxy->rx_fib_index); + rx_fib = ip4_fib_get (proxy->rx_fib_index); s = format (s, "%=14u%=16U", - rx_fib->table_id, - format_ip46_address, &proxy->dhcp_src_address, IP46_TYPE_ANY); + rx_fib->table_id, + format_ip46_address, &proxy->dhcp_src_address, IP46_TYPE_ANY); - vec_foreach(server, proxy->dhcp_servers) + vec_foreach (server, proxy->dhcp_servers) { - server_fib = ip4_fib_get(server->server_fib_index); - s = format (s, "%u,%U ", - server_fib->table_id, - format_ip46_address, &server->dhcp_server, IP46_TYPE_ANY); + server_fib = ip4_fib_get (server->server_fib_index); + s = format (s, "%u,%U ", + server_fib->table_id, + format_ip46_address, &server->dhcp_server, IP46_TYPE_ANY); } return s; } static int -dhcp4_proxy_show_walk (dhcp_proxy_t *server, - void *ctx) +dhcp4_proxy_show_walk (dhcp_proxy_t * server, void *ctx) { - vlib_main_t * vm = ctx; + vlib_main_t *vm = ctx; - vlib_cli_output (vm, "%U", format_dhcp4_proxy_server, server); + vlib_cli_output (vm, "%U", format_dhcp4_proxy_server, server); - return (1); + return (1); } static clib_error_t * dhcp4_proxy_show_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { - vlib_cli_output (vm, "%U", format_dhcp4_proxy_server, NULL /* header line */); + vlib_cli_output (vm, "%U", format_dhcp4_proxy_server, + NULL /* header line */ ); - dhcp_proxy_walk(FIB_PROTOCOL_IP4, dhcp4_proxy_show_walk, vm); + dhcp_proxy_walk (FIB_PROTOCOL_IP4, dhcp4_proxy_show_walk, vm); return (NULL); } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcp_proxy_show_command, static) = { .path = "show dhcp proxy", .short_help = "Display dhcp proxy server info", .function = dhcp4_proxy_show_command_fn, }; +/* *INDENT-ON* */ static clib_error_t * dhcp_option_82_vss_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { u8 is_del = 0, vss_type = VSS_TYPE_DEFAULT; u32 oui = 0, fib_id = 0, tbl_id = ~0; u8 *vpn_ascii_id = 0; - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "table %d", &tbl_id)) - ; + ; else if (unformat (input, "oui %d", &oui)) - vss_type = VSS_TYPE_VPN_ID; + vss_type = VSS_TYPE_VPN_ID; else if (unformat (input, "vpn-id %d", &fib_id)) - vss_type = VSS_TYPE_VPN_ID; + vss_type = VSS_TYPE_VPN_ID; else if (unformat (input, "vpn-ascii-id %s", &vpn_ascii_id)) - vss_type = VSS_TYPE_ASCII; - else if (unformat(input, "delete") || unformat(input, "del")) - is_del = 1; + vss_type = VSS_TYPE_ASCII; + else if (unformat (input, "delete") || unformat (input, "del")) + is_del = 1; else - break; + break; } if (tbl_id == ~0) - return clib_error_return (0, "no table ID specified."); - - int rv = dhcp_proxy_set_vss (FIB_PROTOCOL_IP4, tbl_id, vss_type, + return clib_error_return (0, "no table ID specified."); + + int rv = dhcp_proxy_set_vss (FIB_PROTOCOL_IP4, tbl_id, vss_type, vpn_ascii_id, oui, fib_id, is_del); switch (rv) { case 0: - return 0; + return 0; case VNET_API_ERROR_NO_SUCH_ENTRY: - return clib_error_return (0, "option 82 vss for table %d not found in in pool.", - tbl_id); + return clib_error_return (0, + "option 82 vss for table %d not found in in pool.", + tbl_id); default: - return clib_error_return (0, "BUG: rv %d", rv); + return clib_error_return (0, "BUG: rv %d", rv); } } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcp_proxy_vss_command,static) = { .path = "set dhcp option-82 vss", .short_help = "set dhcp option-82 vss [del] table [oui vpn-id | vpn-ascii-id ]", .function = dhcp_option_82_vss_fn, }; +/* *INDENT-ON* */ static clib_error_t * dhcp_vss_show_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) - + unformat_input_t * input, vlib_cli_command_t * cmd) { - dhcp_vss_walk(FIB_PROTOCOL_IP4, dhcp_vss_show_walk, vm); + dhcp_vss_walk (FIB_PROTOCOL_IP4, dhcp_vss_show_walk, vm); return (NULL); } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcp_proxy_vss_show_command, static) = { .path = "show dhcp vss", .short_help = "show dhcp VSS", .function = dhcp_vss_show_command_fn, }; +/* *INDENT-ON* */ static clib_error_t * dhcp_option_82_address_show_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) - + unformat_input_t * input, + vlib_cli_command_t * cmd) { - vnet_main_t *vnm = vnet_get_main(); - u32 sw_if_index0=0, sw_if_index; + vnet_main_t *vnm = vnet_get_main (); + u32 sw_if_index0 = 0, sw_if_index; vnet_sw_interface_t *swif; ip4_address_t *ia0; - - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - - if (unformat(input, "%U", - unformat_vnet_sw_interface, vnm, &sw_if_index0)) - { - swif = vnet_get_sw_interface (vnm, sw_if_index0); - sw_if_index = (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) ? - swif->unnumbered_sw_if_index : sw_if_index0; - ia0 = ip4_interface_first_address(&ip4_main, sw_if_index, 0); - if (ia0) - { - vlib_cli_output (vm, "%=20s%=20s", "interface", - "source IP address"); - - vlib_cli_output (vm, "%=20U%=20U", - format_vnet_sw_if_index_name, - vnm, sw_if_index0, - format_ip4_address, ia0); - } - else - vlib_cli_output (vm, "%=34s %=20U", - "No IPv4 address configured on", - format_vnet_sw_if_index_name, - vnm, sw_if_index); - } + + if (unformat (input, "%U", + unformat_vnet_sw_interface, vnm, &sw_if_index0)) + { + swif = vnet_get_sw_interface (vnm, sw_if_index0); + sw_if_index = (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) ? + swif->unnumbered_sw_if_index : sw_if_index0; + ia0 = ip4_interface_first_address (&ip4_main, sw_if_index, 0); + if (ia0) + { + vlib_cli_output (vm, "%=20s%=20s", "interface", + "source IP address"); + + vlib_cli_output (vm, "%=20U%=20U", + format_vnet_sw_if_index_name, + vnm, sw_if_index0, format_ip4_address, ia0); + } + else + vlib_cli_output (vm, "%=34s %=20U", + "No IPv4 address configured on", + format_vnet_sw_if_index_name, vnm, sw_if_index); + } else - break; + break; } - + return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcp_proxy_address_show_command,static) = { .path = "show dhcp option-82-address interface", .short_help = "show dhcp option-82-address interface ", .function = dhcp_option_82_address_show_command_fn, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/dhcp/dhcp6_packet.h b/src/vnet/dhcp/dhcp6_packet.h index 24a18144b16..97a89385836 100644 --- a/src/vnet/dhcp/dhcp6_packet.h +++ b/src/vnet/dhcp/dhcp6_packet.h @@ -31,83 +31,90 @@ /* * DHCPv6 message types */ -typedef enum dhcpv6_msg_type_{ - DHCPV6_MSG_SOLICIT = 1, - DHCPV6_MSG_ADVERTISE = 2, - DHCPV6_MSG_REQUEST = 3, - DHCPV6_MSG_CONFIRM = 4, - DHCPV6_MSG_RENEW = 5, - DHCPV6_MSG_REBIND = 6, - DHCPV6_MSG_REPLY = 7, - DHCPV6_MSG_RELEASE = 8, - DHCPV6_MSG_DECLINE = 9, - DHCPV6_MSG_RECONFIGURE = 10, - DHCPV6_MSG_INFORMATION_REQUEST = 11, - DHCPV6_MSG_RELAY_FORW = 12, - DHCPV6_MSG_RELAY_REPL = 13, +typedef enum dhcpv6_msg_type_ +{ + DHCPV6_MSG_SOLICIT = 1, + DHCPV6_MSG_ADVERTISE = 2, + DHCPV6_MSG_REQUEST = 3, + DHCPV6_MSG_CONFIRM = 4, + DHCPV6_MSG_RENEW = 5, + DHCPV6_MSG_REBIND = 6, + DHCPV6_MSG_REPLY = 7, + DHCPV6_MSG_RELEASE = 8, + DHCPV6_MSG_DECLINE = 9, + DHCPV6_MSG_RECONFIGURE = 10, + DHCPV6_MSG_INFORMATION_REQUEST = 11, + DHCPV6_MSG_RELAY_FORW = 12, + DHCPV6_MSG_RELAY_REPL = 13, } dhcpv6_msg_type_t; /* * DHCPv6 options types */ -enum { - DHCPV6_OPTION_CLIENTID = 1, - DHCPV6_OPTION_SERVERID = 2, - DHCPV6_OPTION_IA_NA = 3, - DHCPV6_OPTION_IA_TA = 4, - DHCPV6_OPTION_IAADDR = 5, - DHCPV6_OPTION_ORO = 6, - DHCPV6_OPTION_PREFERENCE = 7, - DHCPV6_OPTION_ELAPSED_TIME = 8, - DHCPV6_OPTION_RELAY_MSG = 9, - DHCPV6_OPTION_AUTH = 11, - DHCPV6_OPTION_UNICAST = 12, - DHCPV6_OPTION_STATUS_CODE = 13, - DHCPV6_OPTION_RAPID_COMMIT = 14, - DHCPV6_OPTION_USER_CLASS = 15, - DHCPV6_OPTION_VENDOR_CLASS = 16, - DHCPV6_OPTION_VENDOR_OPTS = 17, - DHCPV6_OPTION_INTERFACE_ID = 18, // relay agent fills this - DHCPV6_OPTION_RECONF_MSG = 19, - DHCPV6_OPTION_RECONF_ACCEPT = 20, - DHCPV6_OPTION_REMOTEID = 37, // relay agent fills this - DHCPV6_OPTION_VSS = 68, // relay agent fills this - DHCPV6_OPTION_CLIENT_LINK_LAYER_ADDRESS = 79, - DHCPV6_OPTION_MAX +enum +{ + DHCPV6_OPTION_CLIENTID = 1, + DHCPV6_OPTION_SERVERID = 2, + DHCPV6_OPTION_IA_NA = 3, + DHCPV6_OPTION_IA_TA = 4, + DHCPV6_OPTION_IAADDR = 5, + DHCPV6_OPTION_ORO = 6, + DHCPV6_OPTION_PREFERENCE = 7, + DHCPV6_OPTION_ELAPSED_TIME = 8, + DHCPV6_OPTION_RELAY_MSG = 9, + DHCPV6_OPTION_AUTH = 11, + DHCPV6_OPTION_UNICAST = 12, + DHCPV6_OPTION_STATUS_CODE = 13, + DHCPV6_OPTION_RAPID_COMMIT = 14, + DHCPV6_OPTION_USER_CLASS = 15, + DHCPV6_OPTION_VENDOR_CLASS = 16, + DHCPV6_OPTION_VENDOR_OPTS = 17, + DHCPV6_OPTION_INTERFACE_ID = 18, // relay agent fills this + DHCPV6_OPTION_RECONF_MSG = 19, + DHCPV6_OPTION_RECONF_ACCEPT = 20, + DHCPV6_OPTION_REMOTEID = 37, // relay agent fills this + DHCPV6_OPTION_VSS = 68, // relay agent fills this + DHCPV6_OPTION_CLIENT_LINK_LAYER_ADDRESS = 79, + DHCPV6_OPTION_MAX }; /* * DHCPv6 status codes */ -enum { - DHCPV6_STATUS_SUCCESS = 0, - DHCPV6_STATUS_UNSPEC_FAIL = 1, - DHCPV6_STATUS_NOADDRS_AVAIL = 2, - DHCPV6_STATUS_NO_BINDING = 3, - DHCPV6_STATUS_NOT_ONLINK = 4, - DHCPV6_STATUS_USE_MULTICAST = 5, +enum +{ + DHCPV6_STATUS_SUCCESS = 0, + DHCPV6_STATUS_UNSPEC_FAIL = 1, + DHCPV6_STATUS_NOADDRS_AVAIL = 2, + DHCPV6_STATUS_NO_BINDING = 3, + DHCPV6_STATUS_NOT_ONLINK = 4, + DHCPV6_STATUS_USE_MULTICAST = 5, }; /* * DHCPv6 DUID types */ -enum { - DHCPV6_DUID_LLT = 1, /* DUID Based on Link-layer Address Plus Time */ - DHCPV6_DUID_EN = 2, /* DUID Based on Enterprise Number */ - DHCPV6_DUID_LL = 3, /* DUID Based on Link-layer Address */ +enum +{ + DHCPV6_DUID_LLT = 1, /* DUID Based on Link-layer Address Plus Time */ + DHCPV6_DUID_EN = 2, /* DUID Based on Enterprise Number */ + DHCPV6_DUID_LL = 3, /* DUID Based on Link-layer Address */ }; //Structure for DHCPv6 payload from client -typedef struct dhcpv6_hdr_ { - union { - u8 msg_type; //DHCP msg type - u32 xid; // transaction id - }u; - u8 data[0]; +typedef struct dhcpv6_hdr_ +{ + union + { + u8 msg_type; //DHCP msg type + u32 xid; // transaction id + } u; + u8 data[0]; } dhcpv6_header_t; +/* *INDENT-OFF* */ typedef CLIB_PACKED (struct dhcpv6_relay_ctx_ { dhcpv6_header_t *pkt; u32 pkt_len; @@ -118,8 +125,10 @@ typedef CLIB_PACKED (struct dhcpv6_relay_ctx_ { char ctx_name[32+1]; u8 dhcp_msg_type; }) dhcpv6_relay_ctx_t; +/* *INDENT-ON* */ //Structure for DHCPv6 RELAY-FORWARD and DHCPv6 RELAY-REPLY pkts +/* *INDENT-OFF* */ typedef CLIB_PACKED (struct dhcpv6_relay_hdr_ { u8 msg_type; u8 hop_count; @@ -127,58 +136,80 @@ typedef CLIB_PACKED (struct dhcpv6_relay_hdr_ { ip6_address_t peer_addr; u8 data[0]; }) dhcpv6_relay_hdr_t; +/* *INDENT-ON* */ -typedef enum dhcp_stats_action_type_ { - DHCP_STATS_ACTION_FORWARDED=1, - DHCP_STATS_ACTION_RECEIVED, - DHCP_STATS_ACTION_DROPPED +typedef enum dhcp_stats_action_type_ +{ + DHCP_STATS_ACTION_FORWARDED = 1, + DHCP_STATS_ACTION_RECEIVED, + DHCP_STATS_ACTION_DROPPED } dhcp_stats_action_type_t; //Generic counters for a packet -typedef struct dhcp_stats_counters_ { - u64 rx_pkts; //counter for received pkts - u64 tx_pkts; //counter for forwarded pkts - u64 drops; //counter for dropped pkts +typedef struct dhcp_stats_counters_ +{ + u64 rx_pkts; //counter for received pkts + u64 tx_pkts; //counter for forwarded pkts + u64 drops; //counter for dropped pkts } dhcp_stats_counters_t; -typedef enum dhcpv6_stats_drop_reason_ { - DHCPV6_RELAY_PKT_DROP_RELAYDISABLE = 1, - DHCPV6_RELAY_PKT_DROP_MAX_HOPS, - DHCPV6_RELAY_PKT_DROP_VALIDATION_FAIL, - DHCPV6_RELAY_PKT_DROP_UNKNOWN_OP_INTF, - DHCPV6_RELAY_PKT_DROP_BAD_CONTEXT, - DHCPV6_RELAY_PKT_DROP_OPT_INSERT_FAIL, - DHCPV6_RELAY_PKT_DROP_REPLY_FROM_CLIENT, +typedef enum dhcpv6_stats_drop_reason_ +{ + DHCPV6_RELAY_PKT_DROP_RELAYDISABLE = 1, + DHCPV6_RELAY_PKT_DROP_MAX_HOPS, + DHCPV6_RELAY_PKT_DROP_VALIDATION_FAIL, + DHCPV6_RELAY_PKT_DROP_UNKNOWN_OP_INTF, + DHCPV6_RELAY_PKT_DROP_BAD_CONTEXT, + DHCPV6_RELAY_PKT_DROP_OPT_INSERT_FAIL, + DHCPV6_RELAY_PKT_DROP_REPLY_FROM_CLIENT, } dhcpv6_stats_drop_reason_t; +/* *INDENT-OFF* */ typedef CLIB_PACKED (struct { u16 option; u16 length; u8 data[0]; }) dhcpv6_option_t; +/* *INDENT-ON* */ +/* *INDENT-OFF* */ typedef CLIB_PACKED (struct { dhcpv6_option_t opt; u32 int_idx; }) dhcpv6_int_id_t; +/* *INDENT-ON* */ +/* *INDENT-OFF* */ typedef CLIB_PACKED (struct { dhcpv6_option_t opt; u8 vss_type; u8 data[0]; }) dhcpv6_vss_t; +/* *INDENT-ON* */ +/* *INDENT-OFF* */ typedef CLIB_PACKED (struct { dhcpv6_option_t opt; u32 ent_num; u32 rmt_id; }) dhcpv6_rmt_id_t; +/* *INDENT-ON* */ +/* *INDENT-OFF* */ typedef CLIB_PACKED (struct { dhcpv6_option_t opt; u16 link_type; u8 data[6]; // data[0]:data[5]: MAC address }) dhcpv6_client_mac_t; +/* *INDENT-ON* */ #endif /* included_vnet_dhcp6_packet_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/dhcp/dhcp6_proxy_node.c b/src/vnet/dhcp/dhcp6_proxy_node.c index 3cac278aa53..5a3a99e2e5d 100644 --- a/src/vnet/dhcp/dhcp6_proxy_node.c +++ b/src/vnet/dhcp/dhcp6_proxy_node.c @@ -23,7 +23,7 @@ #include #include -static char * dhcpv6_proxy_error_strings[] = { +static char *dhcpv6_proxy_error_strings[] = { #define dhcpv6_proxy_error(n,s) s, #include #undef dhcpv6_proxy_error @@ -35,14 +35,16 @@ static char * dhcpv6_proxy_error_strings[] = { _ (SEND_TO_CLIENT, "dhcpv6-proxy-to-client") -typedef enum { +typedef enum +{ #define _(s,n) DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_##s, foreach_dhcpv6_proxy_to_server_input_next #undef _ - DHCPV6_PROXY_TO_SERVER_INPUT_N_NEXT, + DHCPV6_PROXY_TO_SERVER_INPUT_N_NEXT, } dhcpv6_proxy_to_server_input_next_t; -typedef struct { +typedef struct +{ /* 0 => to server, 1 => to client */ int which; u8 packet_data[64]; @@ -63,19 +65,19 @@ format_dhcpv6_proxy_trace (u8 * s, va_list * args) { CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); - dhcpv6_proxy_trace_t * t = va_arg (*args, dhcpv6_proxy_trace_t *); + dhcpv6_proxy_trace_t *t = va_arg (*args, dhcpv6_proxy_trace_t *); if (t->which == 0) s = format (s, "DHCPV6 proxy: sent to server %U", - format_ip6_address, &t->packet_data, sizeof (ip6_address_t)); + format_ip6_address, &t->packet_data, sizeof (ip6_address_t)); else s = format (s, "DHCPV6 proxy: sent to client from %U", - format_ip6_address, &t->packet_data, sizeof (ip6_address_t)); - if (t->error != (u32)~0) + format_ip6_address, &t->packet_data, sizeof (ip6_address_t)); + if (t->error != (u32) ~ 0) s = format (s, " error: %s\n", dhcpv6_proxy_error_strings[t->error]); s = format (s, " original_sw_if_index: %d, sw_if_index: %d\n", - t->original_sw_if_index, t->sw_if_index); + t->original_sw_if_index, t->sw_if_index); return s; } @@ -83,7 +85,7 @@ format_dhcpv6_proxy_trace (u8 * s, va_list * args) static u8 * format_dhcpv6_proxy_header_with_length (u8 * s, va_list * args) { - dhcpv6_header_t * h = va_arg (*args, dhcpv6_header_t *); + dhcpv6_header_t *h = va_arg (*args, dhcpv6_header_t *); u32 max_header_bytes = va_arg (*args, u32); u32 header_bytes; @@ -95,14 +97,16 @@ format_dhcpv6_proxy_header_with_length (u8 * s, va_list * args) return s; } + /* get first interface address */ static ip6_address_t * ip6_interface_first_global_or_site_address (ip6_main_t * im, u32 sw_if_index) { - ip_lookup_main_t * lm = &im->lookup_main; - ip_interface_address_t * ia = 0; - ip6_address_t * result = 0; + ip_lookup_main_t *lm = &im->lookup_main; + ip_interface_address_t *ia = 0; + ip6_address_t *result = 0; + /* *INDENT-OFF* */ foreach_ip_interface_address (lm, ia, sw_if_index, 1 /* honor unnumbered */, ({ @@ -113,36 +117,37 @@ ip6_interface_first_global_or_site_address (ip6_main_t * im, u32 sw_if_index) break; } })); + /* *INDENT-ON* */ return result; } -static inline void copy_ip6_address (ip6_address_t *dst, - ip6_address_t *src) +static inline void +copy_ip6_address (ip6_address_t * dst, ip6_address_t * src) { dst->as_u64[0] = src->as_u64[0]; dst->as_u64[1] = src->as_u64[1]; -} +} static uword dhcpv6_proxy_to_server_input (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * from_frame) + vlib_node_runtime_t * node, + vlib_frame_t * from_frame) { - u32 n_left_from, next_index, * from, * to_next; - dhcp_proxy_main_t * dpm = &dhcp_proxy_main; + u32 n_left_from, next_index, *from, *to_next; + dhcp_proxy_main_t *dpm = &dhcp_proxy_main; from = vlib_frame_vector_args (from_frame); n_left_from = from_frame->n_vectors; - u32 pkts_to_server=0, pkts_to_client=0, pkts_no_server=0; - u32 pkts_no_interface_address=0, pkts_no_exceeding_max_hop=0; - u32 pkts_no_src_address=0; - u32 pkts_wrong_msg_type=0; - u32 pkts_too_big=0; - ip6_main_t * im = &ip6_main; - ip6_address_t * src; + u32 pkts_to_server = 0, pkts_to_client = 0, pkts_no_server = 0; + u32 pkts_no_interface_address = 0, pkts_no_exceeding_max_hop = 0; + u32 pkts_no_src_address = 0; + u32 pkts_wrong_msg_type = 0; + u32 pkts_too_big = 0; + ip6_main_t *im = &ip6_main; + ip6_address_t *src; int bogus_length; dhcp_proxy_t *proxy; dhcp_server_t *server; - u32 rx_fib_idx = 0, server_fib_idx = 0; + u32 rx_fib_idx = 0, server_fib_idx = 0; next_index = node->cached_next_index; @@ -150,34 +155,33 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm, { u32 n_left_to_next; - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from > 0 && n_left_to_next > 0) { - vnet_main_t *vnm = vnet_get_main(); - u32 sw_if_index = 0; - u32 rx_sw_if_index = 0; - vnet_sw_interface_t *swif; - u32 bi0; - vlib_buffer_t * b0; - udp_header_t * u0, *u1; - dhcpv6_header_t * h0; // client msg hdr - ip6_header_t * ip0, *ip1; - ip6_address_t _ia0, *ia0=&_ia0; + vnet_main_t *vnm = vnet_get_main (); + u32 sw_if_index = 0; + u32 rx_sw_if_index = 0; + vnet_sw_interface_t *swif; + u32 bi0; + vlib_buffer_t *b0; + udp_header_t *u0, *u1; + dhcpv6_header_t *h0; // client msg hdr + ip6_header_t *ip0, *ip1; + ip6_address_t _ia0, *ia0 = &_ia0; u32 next0; - u32 error0 = (u32) ~0; - dhcpv6_option_t *fwd_opt; - dhcpv6_relay_hdr_t *r1; - u16 len; - dhcpv6_int_id_t *id1; - dhcpv6_vss_t *vss1; - dhcpv6_client_mac_t *cmac; // client mac - ethernet_header_t * e_h0; - u8 client_src_mac[6]; - vlib_buffer_free_list_t *fl; - dhcp_vss_t *vss; - u8 is_solicit = 0; + u32 error0 = (u32) ~ 0; + dhcpv6_option_t *fwd_opt; + dhcpv6_relay_hdr_t *r1; + u16 len; + dhcpv6_int_id_t *id1; + dhcpv6_vss_t *vss1; + dhcpv6_client_mac_t *cmac; // client mac + ethernet_header_t *e_h0; + u8 client_src_mac[6]; + vlib_buffer_free_list_t *fl; + dhcp_vss_t *vss; + u8 is_solicit = 0; bi0 = from[0]; from += 1; @@ -185,305 +189,316 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - h0 = vlib_buffer_get_current (b0); - - /* - * udp_local hands us the DHCPV6 header. - */ - u0 = (void *)h0 -(sizeof(*u0)); - ip0 = (void *)u0 -(sizeof(*ip0)); - e_h0 = (void *)ip0 - ethernet_buffer_header_size(b0); - - clib_memcpy(client_src_mac, e_h0->src_address, 6); - - switch (h0->u.msg_type) { - case DHCPV6_MSG_SOLICIT: - case DHCPV6_MSG_REQUEST: - case DHCPV6_MSG_CONFIRM: - case DHCPV6_MSG_RENEW: - case DHCPV6_MSG_REBIND: - case DHCPV6_MSG_RELEASE: - case DHCPV6_MSG_DECLINE: - case DHCPV6_MSG_INFORMATION_REQUEST: - case DHCPV6_MSG_RELAY_FORW: - /* send to server */ - break; - case DHCPV6_MSG_RELAY_REPL: - /* send to client */ - next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_SEND_TO_CLIENT; - error0 = 0; - pkts_to_client++; - goto do_enqueue; - default: - /* drop the packet */ - pkts_wrong_msg_type++; - error0 = DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE; - next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; - goto do_trace; - - } - - /* Send to DHCPV6 server via the configured FIB */ - rx_sw_if_index = sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - rx_fib_idx = im->mfib_index_by_sw_if_index [rx_sw_if_index]; - proxy = dhcp_get_proxy(dpm, rx_fib_idx, FIB_PROTOCOL_IP6); - - if (PREDICT_FALSE (NULL == proxy)) - { - error0 = DHCPV6_PROXY_ERROR_NO_SERVER; - next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; - pkts_no_server++; - goto do_trace; - } - - server = &proxy->dhcp_servers[0]; - server_fib_idx = server->server_fib_index; - vnet_buffer(b0)->sw_if_index[VLIB_TX] = server_fib_idx; - - - /* relay-option header pointer */ - vlib_buffer_advance(b0, -(sizeof(*fwd_opt))); - fwd_opt = vlib_buffer_get_current(b0); - /* relay message header pointer */ - vlib_buffer_advance(b0, -(sizeof(*r1))); - r1 = vlib_buffer_get_current(b0); - - vlib_buffer_advance(b0, -(sizeof(*u1))); - u1 = vlib_buffer_get_current(b0); - - vlib_buffer_advance(b0, -(sizeof(*ip1))); - ip1 = vlib_buffer_get_current(b0); - - /* fill in all that rubbish... */ - len = clib_net_to_host_u16(u0->length) - sizeof(udp_header_t); - copy_ip6_address(&r1->peer_addr, &ip0->src_address); - - r1->msg_type = DHCPV6_MSG_RELAY_FORW; - fwd_opt->length = clib_host_to_net_u16(len); - fwd_opt->option = clib_host_to_net_u16(DHCPV6_OPTION_RELAY_MSG); - - r1->hop_count++; - r1->hop_count = (h0->u.msg_type != DHCPV6_MSG_RELAY_FORW) ? 0 : r1->hop_count; - - if (PREDICT_FALSE(r1->hop_count >= HOP_COUNT_LIMIT)) - { - error0 = DHCPV6_RELAY_PKT_DROP_MAX_HOPS; - next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; - pkts_no_exceeding_max_hop++; - goto do_trace; - } - - - /* If relay-fwd and src address is site or global unicast address */ - if (h0->u.msg_type == DHCPV6_MSG_RELAY_FORW && - ((ip0->src_address.as_u8[0] & 0xe0) == 0x20 || - (ip0->src_address.as_u8[0] & 0xfe) == 0xfc)) - { - /* Set link address to zero */ - r1->link_addr.as_u64[0] = 0; - r1->link_addr.as_u64[1] = 0; - goto link_address_set; - } - - /* if receiving interface is unnumbered, use receiving interface - * IP address as link address, otherwise use the loopback interface - * IP address as link address. - */ - - swif = vnet_get_sw_interface (vnm, rx_sw_if_index); - if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) - sw_if_index = swif->unnumbered_sw_if_index; - - ia0 = ip6_interface_first_global_or_site_address(&ip6_main, sw_if_index); - if (ia0 == 0) - { - error0 = DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS; - next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; - pkts_no_interface_address++; - goto do_trace; - } - - copy_ip6_address(&r1->link_addr, ia0); - - link_address_set: - fl = vlib_buffer_get_free_list (vm, vlib_buffer_get_free_list_index (b0)); - - if ((b0->current_length+sizeof(*id1)+sizeof(*vss1)+sizeof(*cmac)) - > fl->n_data_bytes) - { - error0 = DHCPV6_PROXY_ERROR_PKT_TOO_BIG; - next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; - pkts_too_big++; - goto do_trace; - } - - id1 = (dhcpv6_int_id_t *) (((uword) ip1) + b0->current_length); - b0->current_length += (sizeof (*id1)); - - id1->opt.option = clib_host_to_net_u16(DHCPV6_OPTION_INTERFACE_ID); - id1->opt.length = clib_host_to_net_u16(sizeof(rx_sw_if_index)); - id1->int_idx = clib_host_to_net_u32(rx_sw_if_index); - - u1->length =0; - if (h0->u.msg_type != DHCPV6_MSG_RELAY_FORW) - { - cmac = (dhcpv6_client_mac_t *) (((uword) ip1) + b0->current_length); - b0->current_length += (sizeof (*cmac)); - cmac->opt.length =clib_host_to_net_u16(sizeof(*cmac) - - sizeof(cmac->opt)); - cmac->opt.option = clib_host_to_net_u16(DHCPV6_OPTION_CLIENT_LINK_LAYER_ADDRESS); - cmac->link_type = clib_host_to_net_u16(1); /* ethernet */ - clib_memcpy(cmac->data, client_src_mac, 6); - u1->length += sizeof(*cmac); - } - - vss = dhcp_get_vss_info(dpm, rx_fib_idx, FIB_PROTOCOL_IP6); - - if (vss) + h0 = vlib_buffer_get_current (b0); + + /* + * udp_local hands us the DHCPV6 header. + */ + u0 = (void *) h0 - (sizeof (*u0)); + ip0 = (void *) u0 - (sizeof (*ip0)); + e_h0 = (void *) ip0 - ethernet_buffer_header_size (b0); + + clib_memcpy (client_src_mac, e_h0->src_address, 6); + + switch (h0->u.msg_type) + { + case DHCPV6_MSG_SOLICIT: + case DHCPV6_MSG_REQUEST: + case DHCPV6_MSG_CONFIRM: + case DHCPV6_MSG_RENEW: + case DHCPV6_MSG_REBIND: + case DHCPV6_MSG_RELEASE: + case DHCPV6_MSG_DECLINE: + case DHCPV6_MSG_INFORMATION_REQUEST: + case DHCPV6_MSG_RELAY_FORW: + /* send to server */ + break; + case DHCPV6_MSG_RELAY_REPL: + /* send to client */ + next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_SEND_TO_CLIENT; + error0 = 0; + pkts_to_client++; + goto do_enqueue; + default: + /* drop the packet */ + pkts_wrong_msg_type++; + error0 = DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE; + next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; + goto do_trace; + + } + + /* Send to DHCPV6 server via the configured FIB */ + rx_sw_if_index = sw_if_index = + vnet_buffer (b0)->sw_if_index[VLIB_RX]; + rx_fib_idx = im->mfib_index_by_sw_if_index[rx_sw_if_index]; + proxy = dhcp_get_proxy (dpm, rx_fib_idx, FIB_PROTOCOL_IP6); + + if (PREDICT_FALSE (NULL == proxy)) + { + error0 = DHCPV6_PROXY_ERROR_NO_SERVER; + next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; + pkts_no_server++; + goto do_trace; + } + + server = &proxy->dhcp_servers[0]; + server_fib_idx = server->server_fib_index; + vnet_buffer (b0)->sw_if_index[VLIB_TX] = server_fib_idx; + + + /* relay-option header pointer */ + vlib_buffer_advance (b0, -(sizeof (*fwd_opt))); + fwd_opt = vlib_buffer_get_current (b0); + /* relay message header pointer */ + vlib_buffer_advance (b0, -(sizeof (*r1))); + r1 = vlib_buffer_get_current (b0); + + vlib_buffer_advance (b0, -(sizeof (*u1))); + u1 = vlib_buffer_get_current (b0); + + vlib_buffer_advance (b0, -(sizeof (*ip1))); + ip1 = vlib_buffer_get_current (b0); + + /* fill in all that rubbish... */ + len = clib_net_to_host_u16 (u0->length) - sizeof (udp_header_t); + copy_ip6_address (&r1->peer_addr, &ip0->src_address); + + r1->msg_type = DHCPV6_MSG_RELAY_FORW; + fwd_opt->length = clib_host_to_net_u16 (len); + fwd_opt->option = clib_host_to_net_u16 (DHCPV6_OPTION_RELAY_MSG); + + r1->hop_count++; + r1->hop_count = + (h0->u.msg_type != DHCPV6_MSG_RELAY_FORW) ? 0 : r1->hop_count; + + if (PREDICT_FALSE (r1->hop_count >= HOP_COUNT_LIMIT)) + { + error0 = DHCPV6_RELAY_PKT_DROP_MAX_HOPS; + next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; + pkts_no_exceeding_max_hop++; + goto do_trace; + } + + + /* If relay-fwd and src address is site or global unicast address */ + if (h0->u.msg_type == DHCPV6_MSG_RELAY_FORW && + ((ip0->src_address.as_u8[0] & 0xe0) == 0x20 || + (ip0->src_address.as_u8[0] & 0xfe) == 0xfc)) + { + /* Set link address to zero */ + r1->link_addr.as_u64[0] = 0; + r1->link_addr.as_u64[1] = 0; + goto link_address_set; + } + + /* if receiving interface is unnumbered, use receiving interface + * IP address as link address, otherwise use the loopback interface + * IP address as link address. + */ + + swif = vnet_get_sw_interface (vnm, rx_sw_if_index); + if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) + sw_if_index = swif->unnumbered_sw_if_index; + + ia0 = + ip6_interface_first_global_or_site_address (&ip6_main, + sw_if_index); + if (ia0 == 0) + { + error0 = DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS; + next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; + pkts_no_interface_address++; + goto do_trace; + } + + copy_ip6_address (&r1->link_addr, ia0); + + link_address_set: + fl = + vlib_buffer_get_free_list (vm, + vlib_buffer_get_free_list_index (b0)); + + if ((b0->current_length + sizeof (*id1) + sizeof (*vss1) + + sizeof (*cmac)) > fl->n_data_bytes) + { + error0 = DHCPV6_PROXY_ERROR_PKT_TOO_BIG; + next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; + pkts_too_big++; + goto do_trace; + } + + id1 = (dhcpv6_int_id_t *) (((uword) ip1) + b0->current_length); + b0->current_length += (sizeof (*id1)); + + id1->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_INTERFACE_ID); + id1->opt.length = clib_host_to_net_u16 (sizeof (rx_sw_if_index)); + id1->int_idx = clib_host_to_net_u32 (rx_sw_if_index); + + u1->length = 0; + if (h0->u.msg_type != DHCPV6_MSG_RELAY_FORW) + { + cmac = + (dhcpv6_client_mac_t *) (((uword) ip1) + b0->current_length); + b0->current_length += (sizeof (*cmac)); + cmac->opt.length = clib_host_to_net_u16 (sizeof (*cmac) - + sizeof (cmac->opt)); + cmac->opt.option = + clib_host_to_net_u16 + (DHCPV6_OPTION_CLIENT_LINK_LAYER_ADDRESS); + cmac->link_type = clib_host_to_net_u16 (1); /* ethernet */ + clib_memcpy (cmac->data, client_src_mac, 6); + u1->length += sizeof (*cmac); + } + + vss = dhcp_get_vss_info (dpm, rx_fib_idx, FIB_PROTOCOL_IP6); + + if (vss) { u16 id_len; /* length of VPN ID */ u16 type_len = sizeof (vss1->vss_type); - vss1 = (dhcpv6_vss_t *) (((uword) ip1) + b0->current_length); + vss1 = (dhcpv6_vss_t *) (((uword) ip1) + b0->current_length); vss1->vss_type = vss->vss_type; if (vss->vss_type == VSS_TYPE_VPN_ID) - { + { id_len = sizeof (vss->vpn_id); /* vpn_id is 7 bytes */ memcpy (vss1->data, vss->vpn_id, id_len); - } + } else if (vss->vss_type == VSS_TYPE_ASCII) - { + { id_len = vec_len (vss->vpn_ascii_id); memcpy (vss1->data, vss->vpn_ascii_id, id_len); - } - else /* must be VSS_TYPE_DEFAULT, no VPN ID */ + } + else /* must be VSS_TYPE_DEFAULT, no VPN ID */ id_len = 0; - vss1->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_VSS); + vss1->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_VSS); vss1->opt.length = clib_host_to_net_u16 (type_len + id_len); u1->length += type_len + id_len + sizeof (vss1->opt); b0->current_length += type_len + id_len + sizeof (vss1->opt); - } - - pkts_to_server++; - u1->checksum = 0; - u1->src_port = clib_host_to_net_u16(UDP_DST_PORT_dhcpv6_to_client); - u1->dst_port = clib_host_to_net_u16(UDP_DST_PORT_dhcpv6_to_server); - - u1->length = - clib_host_to_net_u16( clib_net_to_host_u16(fwd_opt->length) + - sizeof(*r1) + sizeof(*fwd_opt) + - sizeof(*u1) + sizeof(*id1) + u1->length); - - memset(ip1, 0, sizeof(*ip1)); - ip1->ip_version_traffic_class_and_flow_label = 0x60; - ip1->payload_length = u1->length; - ip1->protocol = PROTO_UDP; - ip1->hop_limit = HOP_COUNT_LIMIT; - src = ((server->dhcp_server.ip6.as_u64[0] || - server->dhcp_server.ip6.as_u64[1]) ? - &server->dhcp_server.ip6 : - &all_dhcpv6_server_address); - copy_ip6_address(&ip1->dst_address, src); - - - ia0 = ip6_interface_first_global_or_site_address - (&ip6_main, vnet_buffer(b0)->sw_if_index[VLIB_RX]); - - src = (proxy->dhcp_src_address.ip6.as_u64[0] || - proxy->dhcp_src_address.ip6.as_u64[1]) ? - &proxy->dhcp_src_address.ip6 : ia0; - if (ia0 == 0) - { - error0 = DHCPV6_PROXY_ERROR_NO_SRC_ADDRESS; - next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; - pkts_no_src_address++; - goto do_trace; - } + } + + pkts_to_server++; + u1->checksum = 0; + u1->src_port = clib_host_to_net_u16 (UDP_DST_PORT_dhcpv6_to_client); + u1->dst_port = clib_host_to_net_u16 (UDP_DST_PORT_dhcpv6_to_server); + + u1->length = + clib_host_to_net_u16 (clib_net_to_host_u16 (fwd_opt->length) + + sizeof (*r1) + sizeof (*fwd_opt) + + sizeof (*u1) + sizeof (*id1) + u1->length); + + memset (ip1, 0, sizeof (*ip1)); + ip1->ip_version_traffic_class_and_flow_label = 0x60; + ip1->payload_length = u1->length; + ip1->protocol = PROTO_UDP; + ip1->hop_limit = HOP_COUNT_LIMIT; + src = ((server->dhcp_server.ip6.as_u64[0] || + server->dhcp_server.ip6.as_u64[1]) ? + &server->dhcp_server.ip6 : &all_dhcpv6_server_address); + copy_ip6_address (&ip1->dst_address, src); + + + ia0 = ip6_interface_first_global_or_site_address + (&ip6_main, vnet_buffer (b0)->sw_if_index[VLIB_RX]); + + src = (proxy->dhcp_src_address.ip6.as_u64[0] || + proxy->dhcp_src_address.ip6.as_u64[1]) ? + &proxy->dhcp_src_address.ip6 : ia0; + if (ia0 == 0) + { + error0 = DHCPV6_PROXY_ERROR_NO_SRC_ADDRESS; + next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP; + pkts_no_src_address++; + goto do_trace; + } copy_ip6_address (&ip1->src_address, src); - u1->checksum = ip6_tcp_udp_icmp_compute_checksum(vm, b0, ip1, - &bogus_length); - ASSERT(bogus_length == 0); - - next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP; - - is_solicit = (DHCPV6_MSG_SOLICIT == h0->u.msg_type); - - /* - * If we have multiple servers configured and this is the - * client's discover message, then send copies to each of - * those servers - */ - if (is_solicit && vec_len(proxy->dhcp_servers) > 1) - { - u32 ii; - - for (ii = 1; ii < vec_len(proxy->dhcp_servers); ii++) - { - vlib_buffer_t *c0; - u32 ci0; - - c0 = vlib_buffer_copy(vm, b0); - ci0 = vlib_get_buffer_index(vm, c0); - server = &proxy->dhcp_servers[ii]; - - ip0 = vlib_buffer_get_current (c0); - - src = ((server->dhcp_server.ip6.as_u64[0] || - server->dhcp_server.ip6.as_u64[1]) ? - &server->dhcp_server.ip6 : - &all_dhcpv6_server_address); - copy_ip6_address(&ip1->dst_address, src); - - to_next[0] = ci0; - to_next += 1; - n_left_to_next -= 1; - - vlib_validate_buffer_enqueue_x1 (vm, node, next_index, - to_next, n_left_to_next, - ci0, next0); - - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - dhcpv6_proxy_trace_t *tr; - - tr = vlib_add_trace (vm, node, c0, sizeof (*tr)); - tr->which = 0; /* to server */ - tr->error = error0; - tr->original_sw_if_index = rx_sw_if_index; - tr->sw_if_index = sw_if_index; - if (next0 == DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP) - copy_ip6_address((ip6_address_t *)&tr->packet_data[0], - &server->dhcp_server.ip6); - } - - if (PREDICT_FALSE(0 == n_left_to_next)) - { - vlib_put_next_frame (vm, node, next_index, - n_left_to_next); - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); - } - } - } - - do_trace: - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - dhcpv6_proxy_trace_t *tr = vlib_add_trace (vm, node, - b0, sizeof (*tr)); - tr->which = 0; /* to server */ - tr->error = error0; - tr->original_sw_if_index = rx_sw_if_index; - tr->sw_if_index = sw_if_index; - if (DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP == next0) - copy_ip6_address((ip6_address_t *)&tr->packet_data[0], &server->dhcp_server.ip6); - } - - do_enqueue: + u1->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip1, + &bogus_length); + ASSERT (bogus_length == 0); + + next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP; + + is_solicit = (DHCPV6_MSG_SOLICIT == h0->u.msg_type); + + /* + * If we have multiple servers configured and this is the + * client's discover message, then send copies to each of + * those servers + */ + if (is_solicit && vec_len (proxy->dhcp_servers) > 1) + { + u32 ii; + + for (ii = 1; ii < vec_len (proxy->dhcp_servers); ii++) + { + vlib_buffer_t *c0; + u32 ci0; + + c0 = vlib_buffer_copy (vm, b0); + ci0 = vlib_get_buffer_index (vm, c0); + server = &proxy->dhcp_servers[ii]; + + ip0 = vlib_buffer_get_current (c0); + + src = ((server->dhcp_server.ip6.as_u64[0] || + server->dhcp_server.ip6.as_u64[1]) ? + &server->dhcp_server.ip6 : + &all_dhcpv6_server_address); + copy_ip6_address (&ip1->dst_address, src); + + to_next[0] = ci0; + to_next += 1; + n_left_to_next -= 1; + + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, n_left_to_next, + ci0, next0); + + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + dhcpv6_proxy_trace_t *tr; + + tr = vlib_add_trace (vm, node, c0, sizeof (*tr)); + tr->which = 0; /* to server */ + tr->error = error0; + tr->original_sw_if_index = rx_sw_if_index; + tr->sw_if_index = sw_if_index; + if (next0 == DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP) + copy_ip6_address ((ip6_address_t *) & + tr->packet_data[0], + &server->dhcp_server.ip6); + } + + if (PREDICT_FALSE (0 == n_left_to_next)) + { + vlib_put_next_frame (vm, node, next_index, + n_left_to_next); + vlib_get_next_frame (vm, node, next_index, + to_next, n_left_to_next); + } + } + } + + do_trace: + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + dhcpv6_proxy_trace_t *tr = vlib_add_trace (vm, node, + b0, sizeof (*tr)); + tr->which = 0; /* to server */ + tr->error = error0; + tr->original_sw_if_index = rx_sw_if_index; + tr->sw_if_index = sw_if_index; + if (DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP == next0) + copy_ip6_address ((ip6_address_t *) & tr->packet_data[0], + &server->dhcp_server.ip6); + } + + do_enqueue: to_next[0] = bi0; to_next += 1; n_left_to_next -= 1; @@ -497,26 +512,26 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm, } vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index, - DHCPV6_PROXY_ERROR_RELAY_TO_CLIENT, - pkts_to_client); + DHCPV6_PROXY_ERROR_RELAY_TO_CLIENT, + pkts_to_client); vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index, - DHCPV6_PROXY_ERROR_RELAY_TO_SERVER, - pkts_to_server); + DHCPV6_PROXY_ERROR_RELAY_TO_SERVER, + pkts_to_server); vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index, - DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS, - pkts_no_interface_address); + DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS, + pkts_no_interface_address); vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index, - DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE, - pkts_wrong_msg_type); + DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE, + pkts_wrong_msg_type); vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index, - DHCPV6_PROXY_ERROR_NO_SRC_ADDRESS, - pkts_no_src_address); + DHCPV6_PROXY_ERROR_NO_SRC_ADDRESS, + pkts_no_src_address); vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index, - DHCPV6_PROXY_ERROR_PKT_TOO_BIG, - pkts_too_big); + DHCPV6_PROXY_ERROR_PKT_TOO_BIG, pkts_too_big); return from_frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (dhcpv6_proxy_to_server_node, static) = { .function = dhcpv6_proxy_to_server_input, .name = "dhcpv6-proxy-to-server", @@ -539,19 +554,20 @@ VLIB_REGISTER_NODE (dhcpv6_proxy_to_server_node, static) = { .unformat_buffer = unformat_dhcpv6_proxy_header, #endif }; +/* *INDENT-ON* */ static uword dhcpv6_proxy_to_client_input (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * from_frame) + vlib_node_runtime_t * node, + vlib_frame_t * from_frame) { - u32 n_left_from, * from; + u32 n_left_from, *from; ethernet_main_t *em = ethernet_get_main (vm); - dhcp_proxy_main_t * dm = &dhcp_proxy_main; + dhcp_proxy_main_t *dm = &dhcp_proxy_main; dhcp_proxy_t *proxy; dhcp_server_t *server; - vnet_main_t * vnm = vnet_get_main(); + vnet_main_t *vnm = vnet_get_main (); int bogus_length; from = vlib_frame_vector_args (from_frame); @@ -560,27 +576,27 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm, while (n_left_from > 0) { u32 bi0; - vlib_buffer_t * b0; - udp_header_t * u0, *u1=0; - dhcpv6_relay_hdr_t * h0; - ip6_header_t * ip1 = 0, *ip0; - ip6_address_t _ia0, * ia0 = &_ia0; + vlib_buffer_t *b0; + udp_header_t *u0, *u1 = 0; + dhcpv6_relay_hdr_t *h0; + ip6_header_t *ip1 = 0, *ip0; + ip6_address_t _ia0, *ia0 = &_ia0; ip6_address_t client_address; ethernet_interface_t *ei0; ethernet_header_t *mac0; vnet_hw_interface_t *hi0; vlib_frame_t *f0; - u32 * to_next0; + u32 *to_next0; u32 sw_if_index = ~0; u32 original_sw_if_index = ~0; vnet_sw_interface_t *si0; - u32 error0 = (u32)~0; + u32 error0 = (u32) ~ 0; vnet_sw_interface_t *swif; dhcpv6_option_t *r0 = 0, *o; u16 len = 0; u8 interface_opt_flag = 0; u8 relay_msg_opt_flag = 0; - ip6_main_t * im = &ip6_main; + ip6_main_t *im = &ip6_main; u32 server_fib_idx, client_fib_idx; bi0 = from[0]; @@ -591,30 +607,30 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm, h0 = vlib_buffer_get_current (b0); if (DHCPV6_MSG_RELAY_REPL != h0->msg_type) - { - error0 = DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE; - - drop_packet: - vlib_node_increment_counter (vm, dhcpv6_proxy_to_client_node.index, - error0, 1); - - f0 = vlib_get_frame_to_node (vm, dm->error_drop_node_index); - to_next0 = vlib_frame_vector_args (f0); - to_next0[0] = bi0; - f0->n_vectors = 1; - vlib_put_frame_to_node (vm, dm->error_drop_node_index, f0); - goto do_trace; - } + { + error0 = DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE; + + drop_packet: + vlib_node_increment_counter (vm, dhcpv6_proxy_to_client_node.index, + error0, 1); + + f0 = vlib_get_frame_to_node (vm, dm->error_drop_node_index); + to_next0 = vlib_frame_vector_args (f0); + to_next0[0] = bi0; + f0->n_vectors = 1; + vlib_put_frame_to_node (vm, dm->error_drop_node_index, f0); + goto do_trace; + } /* hop count seems not need to be checked */ if (HOP_COUNT_LIMIT < h0->hop_count) - { - error0 = DHCPV6_RELAY_PKT_DROP_MAX_HOPS; - goto drop_packet; - } - u0 = (void *)h0 -(sizeof(*u0)); - ip0 = (void *)u0 -(sizeof(*ip0)); - - vlib_buffer_advance (b0, sizeof(*h0)); + { + error0 = DHCPV6_RELAY_PKT_DROP_MAX_HOPS; + goto drop_packet; + } + u0 = (void *) h0 - (sizeof (*u0)); + ip0 = (void *) u0 - (sizeof (*ip0)); + + vlib_buffer_advance (b0, sizeof (*h0)); o = vlib_buffer_get_current (b0); /* Parse through TLVs looking for option 18 (DHCPV6_OPTION_INTERFACE_ID) @@ -624,64 +640,70 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm, to track down the client-facing interface */ while ((u8 *) o < (b0->data + b0->current_data + b0->current_length)) - { - if (DHCPV6_OPTION_INTERFACE_ID == clib_net_to_host_u16(o->option)) - { - interface_opt_flag = 1; - if (clib_net_to_host_u16(o->length) == sizeof(sw_if_index)) - sw_if_index = clib_net_to_host_u32(((dhcpv6_int_id_t*)o)->int_idx); - if (sw_if_index >= vec_len (im->fib_index_by_sw_if_index)) - { - error0 = DHCPV6_PROXY_ERROR_WRONG_INTERFACE_ID_OPTION; - goto drop_packet; - } - } - if (DHCPV6_OPTION_RELAY_MSG == clib_net_to_host_u16(o->option)) - { - relay_msg_opt_flag = 1; - r0 = vlib_buffer_get_current (b0); - } - if ((relay_msg_opt_flag == 1) && (interface_opt_flag == 1)) - break; - vlib_buffer_advance (b0, sizeof(*o) + clib_net_to_host_u16(o->length)); - o = (dhcpv6_option_t *) (((uword) o) + clib_net_to_host_u16(o->length) + sizeof(*o)); - } + { + if (DHCPV6_OPTION_INTERFACE_ID == clib_net_to_host_u16 (o->option)) + { + interface_opt_flag = 1; + if (clib_net_to_host_u16 (o->length) == sizeof (sw_if_index)) + sw_if_index = + clib_net_to_host_u32 (((dhcpv6_int_id_t *) o)->int_idx); + if (sw_if_index >= vec_len (im->fib_index_by_sw_if_index)) + { + error0 = DHCPV6_PROXY_ERROR_WRONG_INTERFACE_ID_OPTION; + goto drop_packet; + } + } + if (DHCPV6_OPTION_RELAY_MSG == clib_net_to_host_u16 (o->option)) + { + relay_msg_opt_flag = 1; + r0 = vlib_buffer_get_current (b0); + } + if ((relay_msg_opt_flag == 1) && (interface_opt_flag == 1)) + break; + vlib_buffer_advance (b0, + sizeof (*o) + + clib_net_to_host_u16 (o->length)); + o = + (dhcpv6_option_t *) (((uword) o) + + clib_net_to_host_u16 (o->length) + + sizeof (*o)); + } if ((relay_msg_opt_flag == 0) || (r0 == 0)) - { - error0 = DHCPV6_PROXY_ERROR_NO_RELAY_MESSAGE_OPTION; - goto drop_packet; - } + { + error0 = DHCPV6_PROXY_ERROR_NO_RELAY_MESSAGE_OPTION; + goto drop_packet; + } - if ((u32)~0 == sw_if_index) - { - error0 = DHCPV6_PROXY_ERROR_NO_CIRCUIT_ID_OPTION; - goto drop_packet; - } + if ((u32) ~ 0 == sw_if_index) + { + error0 = DHCPV6_PROXY_ERROR_NO_CIRCUIT_ID_OPTION; + goto drop_packet; + } //Advance buffer to start of encapsulated DHCPv6 message - vlib_buffer_advance (b0, sizeof(*r0)); + vlib_buffer_advance (b0, sizeof (*r0)); client_fib_idx = im->mfib_index_by_sw_if_index[sw_if_index]; - proxy = dhcp_get_proxy(dm, client_fib_idx, FIB_PROTOCOL_IP6); + proxy = dhcp_get_proxy (dm, client_fib_idx, FIB_PROTOCOL_IP6); if (NULL == proxy) - { - error0 = DHCPV6_PROXY_ERROR_NO_SERVER; - goto drop_packet; - } + { + error0 = DHCPV6_PROXY_ERROR_NO_SERVER; + goto drop_packet; + } server_fib_idx = im->fib_index_by_sw_if_index - [vnet_buffer(b0)->sw_if_index[VLIB_RX]]; + [vnet_buffer (b0)->sw_if_index[VLIB_RX]]; - vec_foreach(server, proxy->dhcp_servers) + vec_foreach (server, proxy->dhcp_servers) { - if (server_fib_idx == server->server_fib_index && - ip0->src_address.as_u64[0] == server->dhcp_server.ip6.as_u64[0] && - ip0->src_address.as_u64[1] == server->dhcp_server.ip6.as_u64[1]) - { - goto server_found; - } + if (server_fib_idx == server->server_fib_index && + ip0->src_address.as_u64[0] == server->dhcp_server.ip6.as_u64[0] && + ip0->src_address.as_u64[1] == server->dhcp_server.ip6.as_u64[1]) + { + goto server_found; + } } //drop packet if not from server with configured address or FIB @@ -690,56 +712,55 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm, server_found: vnet_buffer (b0)->sw_if_index[VLIB_TX] = original_sw_if_index - = sw_if_index; + = sw_if_index; swif = vnet_get_sw_interface (vnm, original_sw_if_index); if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) - sw_if_index = swif->unnumbered_sw_if_index; + sw_if_index = swif->unnumbered_sw_if_index; /* * udp_local hands us the DHCPV6 header, need udp hdr, * ip hdr to relay to client */ - vlib_buffer_advance (b0, -(sizeof(*u1))); + vlib_buffer_advance (b0, -(sizeof (*u1))); u1 = vlib_buffer_get_current (b0); - vlib_buffer_advance (b0, -(sizeof(*ip1))); + vlib_buffer_advance (b0, -(sizeof (*ip1))); ip1 = vlib_buffer_get_current (b0); - copy_ip6_address(&client_address, &h0->peer_addr); + copy_ip6_address (&client_address, &h0->peer_addr); ia0 = ip6_interface_first_address (&ip6_main, sw_if_index); if (ia0 == 0) - { - error0 = DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS; - goto drop_packet; - } - - len = clib_net_to_host_u16(r0->length); - memset(ip1, 0, sizeof(*ip1)); - copy_ip6_address(&ip1->dst_address, &client_address); + { + error0 = DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS; + goto drop_packet; + } + + len = clib_net_to_host_u16 (r0->length); + memset (ip1, 0, sizeof (*ip1)); + copy_ip6_address (&ip1->dst_address, &client_address); u1->checksum = 0; u1->src_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcpv6_to_server); u1->dst_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcpv6_to_client); - u1->length = clib_host_to_net_u16 (len + sizeof(udp_header_t)); + u1->length = clib_host_to_net_u16 (len + sizeof (udp_header_t)); ip1->ip_version_traffic_class_and_flow_label = - ip0->ip_version_traffic_class_and_flow_label & - 0x00000fff; - ip1->payload_length = u1->length; + ip0->ip_version_traffic_class_and_flow_label & 0x00000fff; + ip1->payload_length = u1->length; ip1->protocol = PROTO_UDP; ip1->hop_limit = HOP_COUNT_LIMIT; - copy_ip6_address(&ip1->src_address, ia0); + copy_ip6_address (&ip1->src_address, ia0); - u1->checksum = ip6_tcp_udp_icmp_compute_checksum(vm, b0, ip1, - &bogus_length); - ASSERT(bogus_length == 0); + u1->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip1, + &bogus_length); + ASSERT (bogus_length == 0); - vlib_buffer_advance (b0, -(sizeof(ethernet_header_t))); + vlib_buffer_advance (b0, -(sizeof (ethernet_header_t))); si0 = vnet_get_sw_interface (vnm, original_sw_if_index); if (si0->type == VNET_SW_INTERFACE_TYPE_SUB) - vlib_buffer_advance (b0, -4 /* space for VLAN tag */); + vlib_buffer_advance (b0, -4 /* space for VLAN tag */ ); mac0 = vlib_buffer_get_current (b0); @@ -748,11 +769,11 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm, clib_memcpy (mac0->src_address, ei0->address, sizeof (ei0->address)); memset (&mac0->dst_address, 0xff, sizeof (mac0->dst_address)); mac0->type = (si0->type == VNET_SW_INTERFACE_TYPE_SUB) ? - clib_net_to_host_u16(0x8100) : clib_net_to_host_u16 (0x86dd); + clib_net_to_host_u16 (0x8100) : clib_net_to_host_u16 (0x86dd); if (si0->type == VNET_SW_INTERFACE_TYPE_SUB) { - u32 * vlan_tag = (u32 *)(mac0+1); + u32 *vlan_tag = (u32 *) (mac0 + 1); u32 tmp; tmp = (si0->sub.id << 16) | 0x0800; *vlan_tag = clib_host_to_net_u32 (tmp); @@ -766,22 +787,23 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm, vlib_put_frame_to_node (vm, hi0->output_node_index, f0); do_trace: - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - dhcpv6_proxy_trace_t *tr = vlib_add_trace (vm, node, - b0, sizeof (*tr)); - tr->which = 1; /* to client */ - if (ia0) - copy_ip6_address((ip6_address_t*)tr->packet_data, ia0); - tr->error = error0; - tr->original_sw_if_index = original_sw_if_index; - tr->sw_if_index = sw_if_index; - } + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + dhcpv6_proxy_trace_t *tr = vlib_add_trace (vm, node, + b0, sizeof (*tr)); + tr->which = 1; /* to client */ + if (ia0) + copy_ip6_address ((ip6_address_t *) tr->packet_data, ia0); + tr->error = error0; + tr->original_sw_if_index = original_sw_if_index; + tr->sw_if_index = sw_if_index; + } } return from_frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (dhcpv6_proxy_to_client_node, static) = { .function = dhcpv6_proxy_to_client_input, .name = "dhcpv6-proxy-to-client", @@ -796,29 +818,33 @@ VLIB_REGISTER_NODE (dhcpv6_proxy_to_client_node, static) = { .unformat_buffer = unformat_dhcpv6_proxy_header, #endif }; +/* *INDENT-ON* */ static clib_error_t * dhcp6_proxy_init (vlib_main_t * vm) { - dhcp_proxy_main_t * dm = &dhcp_proxy_main; - vlib_node_t * error_drop_node; + dhcp_proxy_main_t *dm = &dhcp_proxy_main; + vlib_node_t *error_drop_node; error_drop_node = vlib_get_node_by_name (vm, (u8 *) "error-drop"); dm->error_drop_node_index = error_drop_node->index; /* RFC says this is the dhcpv6 server address */ - all_dhcpv6_server_address.as_u64[0] = clib_host_to_net_u64 (0xFF05000000000000); + all_dhcpv6_server_address.as_u64[0] = + clib_host_to_net_u64 (0xFF05000000000000); all_dhcpv6_server_address.as_u64[1] = clib_host_to_net_u64 (0x00010003); /* RFC says this is the server and agent address */ - all_dhcpv6_server_relay_agent_address.as_u64[0] = clib_host_to_net_u64 (0xFF02000000000000); - all_dhcpv6_server_relay_agent_address.as_u64[1] = clib_host_to_net_u64 (0x00010002); + all_dhcpv6_server_relay_agent_address.as_u64[0] = + clib_host_to_net_u64 (0xFF02000000000000); + all_dhcpv6_server_relay_agent_address.as_u64[1] = + clib_host_to_net_u64 (0x00010002); udp_register_dst_port (vm, UDP_DST_PORT_dhcpv6_to_client, - dhcpv6_proxy_to_client_node.index, 0 /* is_ip6 */); + dhcpv6_proxy_to_client_node.index, 0 /* is_ip6 */ ); udp_register_dst_port (vm, UDP_DST_PORT_dhcpv6_to_server, - dhcpv6_proxy_to_server_node.index, 0 /* is_ip6 */); + dhcpv6_proxy_to_server_node.index, 0 /* is_ip6 */ ); return 0; } @@ -826,319 +852,331 @@ dhcp6_proxy_init (vlib_main_t * vm) VLIB_INIT_FUNCTION (dhcp6_proxy_init); int -dhcp6_proxy_set_server (ip46_address_t *addr, - ip46_address_t *src_addr, - u32 rx_table_id, - u32 server_table_id, - int is_del) +dhcp6_proxy_set_server (ip46_address_t * addr, + ip46_address_t * src_addr, + u32 rx_table_id, u32 server_table_id, int is_del) { u32 rx_fib_index = 0; int rc = 0; const mfib_prefix_t all_dhcp_servers = { - .fp_len = 128, - .fp_proto = FIB_PROTOCOL_IP6, - .fp_grp_addr = { - .ip6 = all_dhcpv6_server_relay_agent_address, - } + .fp_len = 128, + .fp_proto = FIB_PROTOCOL_IP6, + .fp_grp_addr = { + .ip6 = all_dhcpv6_server_relay_agent_address, + } }; - if (ip46_address_is_zero(addr)) + if (ip46_address_is_zero (addr)) return VNET_API_ERROR_INVALID_DST_ADDRESS; - - if (ip46_address_is_zero(src_addr)) + + if (ip46_address_is_zero (src_addr)) return VNET_API_ERROR_INVALID_SRC_ADDRESS; - rx_fib_index = mfib_table_find_or_create_and_lock(FIB_PROTOCOL_IP6, - rx_table_id, - MFIB_SOURCE_DHCP); + rx_fib_index = mfib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, + rx_table_id, + MFIB_SOURCE_DHCP); if (is_del) { if (dhcp_proxy_server_del (FIB_PROTOCOL_IP6, rx_fib_index, - addr, server_table_id)) - { - mfib_table_entry_delete(rx_fib_index, - &all_dhcp_servers, - MFIB_SOURCE_DHCP); - mfib_table_unlock(rx_fib_index, FIB_PROTOCOL_IP6, MFIB_SOURCE_DHCP); - } + addr, server_table_id)) + { + mfib_table_entry_delete (rx_fib_index, + &all_dhcp_servers, MFIB_SOURCE_DHCP); + mfib_table_unlock (rx_fib_index, FIB_PROTOCOL_IP6, + MFIB_SOURCE_DHCP); + } } else { - const fib_route_path_t path_for_us = { - .frp_proto = DPO_PROTO_IP6, - .frp_addr = zero_addr, - .frp_sw_if_index = 0xffffffff, - .frp_fib_index = ~0, - .frp_weight = 0, - .frp_flags = FIB_ROUTE_PATH_LOCAL, + const fib_route_path_t path_for_us = { + .frp_proto = DPO_PROTO_IP6, + .frp_addr = zero_addr, + .frp_sw_if_index = 0xffffffff, + .frp_fib_index = ~0, + .frp_weight = 0, + .frp_flags = FIB_ROUTE_PATH_LOCAL, }; - if (dhcp_proxy_server_add (FIB_PROTOCOL_IP6, addr, src_addr, - rx_fib_index, server_table_id)) - { - mfib_table_entry_path_update(rx_fib_index, - &all_dhcp_servers, - MFIB_SOURCE_DHCP, - &path_for_us, - MFIB_ITF_FLAG_FORWARD); - /* - * Each interface that is enabled in this table, needs to be added - * as an accepting interface, but this is not easily doable in VPP. - * So we cheat. Add a flag to the entry that indicates accept form - * any interface. - * We will still only accept on v6 enabled interfaces, since the - * input feature ensures this. - */ - mfib_table_entry_update(rx_fib_index, - &all_dhcp_servers, - MFIB_SOURCE_DHCP, - MFIB_RPF_ID_NONE, - MFIB_ENTRY_FLAG_ACCEPT_ALL_ITF); - mfib_table_lock(rx_fib_index, FIB_PROTOCOL_IP6, MFIB_SOURCE_DHCP); - } + if (dhcp_proxy_server_add (FIB_PROTOCOL_IP6, addr, src_addr, + rx_fib_index, server_table_id)) + { + mfib_table_entry_path_update (rx_fib_index, + &all_dhcp_servers, + MFIB_SOURCE_DHCP, + &path_for_us, MFIB_ITF_FLAG_FORWARD); + /* + * Each interface that is enabled in this table, needs to be added + * as an accepting interface, but this is not easily doable in VPP. + * So we cheat. Add a flag to the entry that indicates accept form + * any interface. + * We will still only accept on v6 enabled interfaces, since the + * input feature ensures this. + */ + mfib_table_entry_update (rx_fib_index, + &all_dhcp_servers, + MFIB_SOURCE_DHCP, + MFIB_RPF_ID_NONE, + MFIB_ENTRY_FLAG_ACCEPT_ALL_ITF); + mfib_table_lock (rx_fib_index, FIB_PROTOCOL_IP6, MFIB_SOURCE_DHCP); + } } - mfib_table_unlock(rx_fib_index, FIB_PROTOCOL_IP6, MFIB_SOURCE_DHCP); + mfib_table_unlock (rx_fib_index, FIB_PROTOCOL_IP6, MFIB_SOURCE_DHCP); return (rc); } static clib_error_t * dhcpv6_proxy_set_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { ip46_address_t addr, src_addr; int set_server = 0, set_src_address = 0; u32 rx_table_id = 0, server_table_id = 0; int is_del = 0; - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (unformat (input, "server %U", - unformat_ip6_address, &addr.ip6)) - set_server = 1; - else if (unformat(input, "src-address %U", - unformat_ip6_address, &src_addr.ip6)) - set_src_address =1; - else if (unformat (input, "server-fib-id %d", &server_table_id)) - ; - else if (unformat (input, "rx-fib-id %d", &rx_table_id)) - ; - else if (unformat (input, "delete") || - unformat (input, "del")) - is_del = 1; + if (unformat (input, "server %U", unformat_ip6_address, &addr.ip6)) + set_server = 1; + else if (unformat (input, "src-address %U", + unformat_ip6_address, &src_addr.ip6)) + set_src_address = 1; + else if (unformat (input, "server-fib-id %d", &server_table_id)) + ; + else if (unformat (input, "rx-fib-id %d", &rx_table_id)) + ; + else if (unformat (input, "delete") || unformat (input, "del")) + is_del = 1; else - break; + break; } if (is_del || (set_server && set_src_address)) - { + { int rv; rv = dhcp6_proxy_set_server (&addr, &src_addr, rx_table_id, - server_table_id, is_del); + server_table_id, is_del); //TODO: Complete the errors switch (rv) - { - case 0: - return 0; + { + case 0: + return 0; - case VNET_API_ERROR_INVALID_DST_ADDRESS: - return clib_error_return (0, "Invalid server address"); + case VNET_API_ERROR_INVALID_DST_ADDRESS: + return clib_error_return (0, "Invalid server address"); - case VNET_API_ERROR_INVALID_SRC_ADDRESS: - return clib_error_return (0, "Invalid src address"); + case VNET_API_ERROR_INVALID_SRC_ADDRESS: + return clib_error_return (0, "Invalid src address"); - case VNET_API_ERROR_NO_SUCH_ENTRY: - return clib_error_return - (0, "Fib id %d: no per-fib DHCP server configured", rx_table_id); + case VNET_API_ERROR_NO_SUCH_ENTRY: + return clib_error_return + (0, "Fib id %d: no per-fib DHCP server configured", rx_table_id); - default: - return clib_error_return (0, "BUG: rv %d", rv); - } - } + default: + return clib_error_return (0, "BUG: rv %d", rv); + } + } else return clib_error_return (0, "parse error`%U'", - format_unformat_error, input); + format_unformat_error, input); } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcpv6_proxy_set_command, static) = { .path = "set dhcpv6 proxy", .short_help = "set dhcpv6 proxy [del] server src-address " "[server-fib-id ] [rx-fib-id ] ", .function = dhcpv6_proxy_set_command_fn, }; +/* *INDENT-ON* */ static u8 * format_dhcp6_proxy_server (u8 * s, va_list * args) { - dhcp_proxy_t * proxy = va_arg (*args, dhcp_proxy_t *); + dhcp_proxy_t *proxy = va_arg (*args, dhcp_proxy_t *); fib_table_t *server_fib; dhcp_server_t *server; ip6_mfib_t *rx_fib; if (proxy == 0) { - s = format (s, "%=14s%=16s%s", "RX FIB", "Src Address", - "Servers FIB,Address"); + s = format (s, "%=14s%=16s%s", "RX FIB", "Src Address", + "Servers FIB,Address"); return s; } - rx_fib = ip6_mfib_get(proxy->rx_fib_index); + rx_fib = ip6_mfib_get (proxy->rx_fib_index); s = format (s, "%=14u%=16U", - rx_fib->table_id, - format_ip46_address, &proxy->dhcp_src_address, IP46_TYPE_ANY); + rx_fib->table_id, + format_ip46_address, &proxy->dhcp_src_address, IP46_TYPE_ANY); - vec_foreach(server, proxy->dhcp_servers) + vec_foreach (server, proxy->dhcp_servers) { - server_fib = fib_table_get(server->server_fib_index, - FIB_PROTOCOL_IP6); - s = format (s, "%u,%U ", - server_fib->ft_table_id, - format_ip46_address, &server->dhcp_server, IP46_TYPE_ANY); + server_fib = fib_table_get (server->server_fib_index, FIB_PROTOCOL_IP6); + s = format (s, "%u,%U ", + server_fib->ft_table_id, + format_ip46_address, &server->dhcp_server, IP46_TYPE_ANY); } return s; } static int -dhcp6_proxy_show_walk (dhcp_proxy_t *proxy, - void *ctx) +dhcp6_proxy_show_walk (dhcp_proxy_t * proxy, void *ctx) { - vlib_main_t * vm = ctx; + vlib_main_t *vm = ctx; - vlib_cli_output (vm, "%U", format_dhcp6_proxy_server, proxy); + vlib_cli_output (vm, "%U", format_dhcp6_proxy_server, proxy); - return (1); + return (1); } static clib_error_t * dhcpv6_proxy_show_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { - vlib_cli_output (vm, "%U", format_dhcp6_proxy_server, NULL /* header line */); + vlib_cli_output (vm, "%U", format_dhcp6_proxy_server, + NULL /* header line */ ); - dhcp_proxy_walk(FIB_PROTOCOL_IP6, dhcp6_proxy_show_walk, vm); + dhcp_proxy_walk (FIB_PROTOCOL_IP6, dhcp6_proxy_show_walk, vm); return (NULL); } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcpv6_proxy_show_command, static) = { .path = "show dhcpv6 proxy", .short_help = "Display dhcpv6 proxy info", .function = dhcpv6_proxy_show_command_fn, }; +/* *INDENT-ON* */ static clib_error_t * dhcpv6_vss_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { u8 is_del = 0, vss_type = VSS_TYPE_DEFAULT; u8 *vpn_ascii_id = 0; u32 oui = 0, fib_id = 0, tbl_id = ~0; - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "table %d", &tbl_id)) - ; + ; else if (unformat (input, "oui %d", &oui)) - vss_type = VSS_TYPE_VPN_ID; + vss_type = VSS_TYPE_VPN_ID; else if (unformat (input, "vpn-id %d", &fib_id)) - vss_type = VSS_TYPE_VPN_ID; + vss_type = VSS_TYPE_VPN_ID; else if (unformat (input, "vpn-ascii-id %s", &vpn_ascii_id)) - vss_type = VSS_TYPE_ASCII; - else if (unformat(input, "delete") || unformat(input, "del")) - is_del = 1; + vss_type = VSS_TYPE_ASCII; + else if (unformat (input, "delete") || unformat (input, "del")) + is_del = 1; else - break; + break; } - if (tbl_id ==~0) - return clib_error_return (0, "no table ID specified."); + if (tbl_id == ~0) + return clib_error_return (0, "no table ID specified."); - int rv = dhcp_proxy_set_vss(FIB_PROTOCOL_IP6, tbl_id, vss_type, - vpn_ascii_id, oui, fib_id, is_del); + int rv = dhcp_proxy_set_vss (FIB_PROTOCOL_IP6, tbl_id, vss_type, + vpn_ascii_id, oui, fib_id, is_del); switch (rv) { case 0: - return 0; + return 0; case VNET_API_ERROR_NO_SUCH_ENTRY: - return clib_error_return (0, "vss for table %d not found in pool.", - tbl_id); + return clib_error_return (0, "vss for table %d not found in pool.", + tbl_id); default: - return clib_error_return (0, "BUG: rv %d", rv); + return clib_error_return (0, "BUG: rv %d", rv); } } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcpv6_proxy_vss_command, static) = { .path = "set dhcpv6 vss", .short_help = "set dhcpv6 vss table [oui vpn-id | vpn-ascii-id ]", .function = dhcpv6_vss_command_fn, }; +/* *INDENT-ON* */ static clib_error_t * dhcpv6_vss_show_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) - + unformat_input_t * input, + vlib_cli_command_t * cmd) { - dhcp_vss_walk(FIB_PROTOCOL_IP6, dhcp_vss_show_walk, vm); + dhcp_vss_walk (FIB_PROTOCOL_IP6, dhcp_vss_show_walk, vm); return (NULL); } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcpv6_proxy_vss_show_command, static) = { .path = "show dhcpv6 vss", .short_help = "show dhcpv6 VSS", .function = dhcpv6_vss_show_command_fn, }; +/* *INDENT-ON* */ static clib_error_t * dhcpv6_link_address_show_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) - + unformat_input_t * input, + vlib_cli_command_t * cmd) { - vnet_main_t *vnm = vnet_get_main(); - u32 sw_if_index0=0, sw_if_index; + vnet_main_t *vnm = vnet_get_main (); + u32 sw_if_index0 = 0, sw_if_index; vnet_sw_interface_t *swif; ip6_address_t *ia0; - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (unformat(input, "%U", - unformat_vnet_sw_interface, vnm, &sw_if_index0)) - { - swif = vnet_get_sw_interface (vnm, sw_if_index0); - sw_if_index = (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) ? - swif->unnumbered_sw_if_index : sw_if_index0; - ia0 = ip6_interface_first_address(&ip6_main, sw_if_index); - if (ia0) - { - vlib_cli_output (vm, "%=20s%=48s", "interface", "link-address"); - - vlib_cli_output (vm, "%=20U%=48U", - format_vnet_sw_if_index_name, vnm, sw_if_index0, - format_ip6_address, ia0); - } else - vlib_cli_output (vm, "%=34s%=20U", "No IPv6 address configured on", - format_vnet_sw_if_index_name, vnm, sw_if_index); - } else - break; + if (unformat (input, "%U", + unformat_vnet_sw_interface, vnm, &sw_if_index0)) + { + swif = vnet_get_sw_interface (vnm, sw_if_index0); + sw_if_index = (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) ? + swif->unnumbered_sw_if_index : sw_if_index0; + ia0 = ip6_interface_first_address (&ip6_main, sw_if_index); + if (ia0) + { + vlib_cli_output (vm, "%=20s%=48s", "interface", "link-address"); + + vlib_cli_output (vm, "%=20U%=48U", + format_vnet_sw_if_index_name, vnm, + sw_if_index0, format_ip6_address, ia0); + } + else + vlib_cli_output (vm, "%=34s%=20U", + "No IPv6 address configured on", + format_vnet_sw_if_index_name, vnm, sw_if_index); + } + else + break; } return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (dhcpv6_proxy_address_show_command, static) = { .path = "show dhcpv6 link-address interface", .short_help = "show dhcpv6 link-address interface ", .function = dhcpv6_link_address_show_command_fn, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/dhcp/dhcp_proxy.c b/src/vnet/dhcp/dhcp_proxy.c index dae631236de..88cdcacd62b 100644 --- a/src/vnet/dhcp/dhcp_proxy.c +++ b/src/vnet/dhcp/dhcp_proxy.c @@ -25,164 +25,156 @@ dhcp_proxy_main_t dhcp_proxy_main; static void -dhcp_proxy_rx_table_lock (fib_protocol_t proto, - u32 fib_index) +dhcp_proxy_rx_table_lock (fib_protocol_t proto, u32 fib_index) { - if (FIB_PROTOCOL_IP4 == proto) - fib_table_lock(fib_index, proto, FIB_SOURCE_DHCP); - else - mfib_table_lock(fib_index, proto, MFIB_SOURCE_DHCP); + if (FIB_PROTOCOL_IP4 == proto) + fib_table_lock (fib_index, proto, FIB_SOURCE_DHCP); + else + mfib_table_lock (fib_index, proto, MFIB_SOURCE_DHCP); } static void -dhcp_proxy_rx_table_unlock (fib_protocol_t proto, - u32 fib_index) +dhcp_proxy_rx_table_unlock (fib_protocol_t proto, u32 fib_index) { - if (FIB_PROTOCOL_IP4 == proto) - fib_table_unlock(fib_index, proto, FIB_SOURCE_DHCP); - else - mfib_table_unlock(fib_index, proto, MFIB_SOURCE_DHCP); + if (FIB_PROTOCOL_IP4 == proto) + fib_table_unlock (fib_index, proto, FIB_SOURCE_DHCP); + else + mfib_table_unlock (fib_index, proto, MFIB_SOURCE_DHCP); } - u32 -dhcp_proxy_rx_table_get_table_id (fib_protocol_t proto, - u32 fib_index) +u32 +dhcp_proxy_rx_table_get_table_id (fib_protocol_t proto, u32 fib_index) { - if (FIB_PROTOCOL_IP4 == proto) - { - fib_table_t *fib; + if (FIB_PROTOCOL_IP4 == proto) + { + fib_table_t *fib; - fib = fib_table_get(fib_index, proto); + fib = fib_table_get (fib_index, proto); - return (fib->ft_table_id); - } - else - { - mfib_table_t *mfib; + return (fib->ft_table_id); + } + else + { + mfib_table_t *mfib; - mfib = mfib_table_get(fib_index, proto); + mfib = mfib_table_get (fib_index, proto); - return (mfib->mft_table_id); - } + return (mfib->mft_table_id); + } } void -dhcp_proxy_walk (fib_protocol_t proto, - dhcp_proxy_walk_fn_t fn, - void *ctx) +dhcp_proxy_walk (fib_protocol_t proto, dhcp_proxy_walk_fn_t fn, void *ctx) { - dhcp_proxy_main_t * dpm = &dhcp_proxy_main; - dhcp_proxy_t * server; + dhcp_proxy_main_t *dpm = &dhcp_proxy_main; + dhcp_proxy_t *server; u32 server_index, i; vec_foreach_index (i, dpm->dhcp_server_index_by_rx_fib_index[proto]) { - server_index = dpm->dhcp_server_index_by_rx_fib_index[proto][i]; - if (~0 == server_index) - continue; + server_index = dpm->dhcp_server_index_by_rx_fib_index[proto][i]; + if (~0 == server_index) + continue; - server = pool_elt_at_index (dpm->dhcp_servers[proto], server_index); + server = pool_elt_at_index (dpm->dhcp_servers[proto], server_index); - if (!fn(server, ctx)) - break; - } + if (!fn (server, ctx)) + break; + } } void -dhcp_vss_walk (fib_protocol_t proto, - dhcp_vss_walk_fn_t fn, - void *ctx) +dhcp_vss_walk (fib_protocol_t proto, dhcp_vss_walk_fn_t fn, void *ctx) { - dhcp_proxy_main_t * dpm = &dhcp_proxy_main; + dhcp_proxy_main_t *dpm = &dhcp_proxy_main; mfib_table_t *mfib; - dhcp_vss_t * vss; + dhcp_vss_t *vss; u32 vss_index, i; fib_table_t *fib; vec_foreach_index (i, dpm->vss_index_by_rx_fib_index[proto]) { - vss_index = dpm->vss_index_by_rx_fib_index[proto][i]; - if (~0 == vss_index) - continue; + vss_index = dpm->vss_index_by_rx_fib_index[proto][i]; + if (~0 == vss_index) + continue; - vss = pool_elt_at_index (dpm->vss[proto], vss_index); + vss = pool_elt_at_index (dpm->vss[proto], vss_index); - if (FIB_PROTOCOL_IP4 == proto) - { - fib = fib_table_get(i, proto); + if (FIB_PROTOCOL_IP4 == proto) + { + fib = fib_table_get (i, proto); - if (!fn(vss, fib->ft_table_id, ctx)) - break; - } - else - { - mfib = mfib_table_get(i, proto); + if (!fn (vss, fib->ft_table_id, ctx)) + break; + } + else + { + mfib = mfib_table_get (i, proto); - if (!fn(vss, mfib->mft_table_id, ctx)) - break; - } - } + if (!fn (vss, mfib->mft_table_id, ctx)) + break; + } + } } static u32 -dhcp_proxy_server_find (dhcp_proxy_t *proxy, - fib_protocol_t proto, - ip46_address_t *addr, - u32 server_table_id) +dhcp_proxy_server_find (dhcp_proxy_t * proxy, + fib_protocol_t proto, + ip46_address_t * addr, u32 server_table_id) { - dhcp_server_t *server; - u32 ii, fib_index; + dhcp_server_t *server; + u32 ii, fib_index; - vec_foreach_index(ii, proxy->dhcp_servers) - { - server = &proxy->dhcp_servers[ii]; - fib_index = fib_table_find(proto, server_table_id); - - if (ip46_address_is_equal(&server->dhcp_server, - addr) && - (server->server_fib_index == fib_index)) - { - return (ii); - } - } - return (~0); + vec_foreach_index (ii, proxy->dhcp_servers) + { + server = &proxy->dhcp_servers[ii]; + fib_index = fib_table_find (proto, server_table_id); + + if (ip46_address_is_equal (&server->dhcp_server, + addr) && + (server->server_fib_index == fib_index)) + { + return (ii); + } + } + return (~0); } int dhcp_proxy_server_del (fib_protocol_t proto, - u32 rx_fib_index, - ip46_address_t *addr, - u32 server_table_id) + u32 rx_fib_index, + ip46_address_t * addr, u32 server_table_id) { - dhcp_proxy_main_t * dpm = &dhcp_proxy_main; + dhcp_proxy_main_t *dpm = &dhcp_proxy_main; dhcp_proxy_t *proxy = 0; - proxy = dhcp_get_proxy(dpm, rx_fib_index, proto); + proxy = dhcp_get_proxy (dpm, rx_fib_index, proto); if (NULL != proxy) - { + { dhcp_server_t *server; u32 index; - index = dhcp_proxy_server_find(proxy, proto, addr, server_table_id); + index = dhcp_proxy_server_find (proxy, proto, addr, server_table_id); if (~0 != index) - { - server = &proxy->dhcp_servers[index]; - fib_table_unlock (server->server_fib_index, proto, FIB_SOURCE_DHCP); - - vec_del1(proxy->dhcp_servers, index); - - if (0 == vec_len(proxy->dhcp_servers)) - { - /* no servers left, delete the proxy config */ - dpm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] = ~0; - vec_free(proxy->dhcp_servers); - pool_put (dpm->dhcp_servers[proto], proxy); - return (1); - } - } - } + { + server = &proxy->dhcp_servers[index]; + fib_table_unlock (server->server_fib_index, proto, FIB_SOURCE_DHCP); + + vec_del1 (proxy->dhcp_servers, index); + + if (0 == vec_len (proxy->dhcp_servers)) + { + /* no servers left, delete the proxy config */ + dpm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] = + ~0; + vec_free (proxy->dhcp_servers); + pool_put (dpm->dhcp_servers[proto], proxy); + return (1); + } + } + } /* the proxy still exists */ return (0); @@ -190,129 +182,117 @@ dhcp_proxy_server_del (fib_protocol_t proto, int dhcp_proxy_server_add (fib_protocol_t proto, - ip46_address_t *addr, - ip46_address_t *src_address, - u32 rx_fib_index, - u32 server_table_id) + ip46_address_t * addr, + ip46_address_t * src_address, + u32 rx_fib_index, u32 server_table_id) { - dhcp_proxy_main_t * dpm = &dhcp_proxy_main; - dhcp_proxy_t * proxy = 0; + dhcp_proxy_main_t *dpm = &dhcp_proxy_main; + dhcp_proxy_t *proxy = 0; int new = 0; - proxy = dhcp_get_proxy(dpm, rx_fib_index, proto); + proxy = dhcp_get_proxy (dpm, rx_fib_index, proto); if (NULL == proxy) - { - vec_validate_init_empty(dpm->dhcp_server_index_by_rx_fib_index[proto], - rx_fib_index, - ~0); + { + vec_validate_init_empty (dpm->dhcp_server_index_by_rx_fib_index[proto], + rx_fib_index, ~0); pool_get (dpm->dhcp_servers[proto], proxy); memset (proxy, 0, sizeof (*proxy)); new = 1; dpm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] = - proxy - dpm->dhcp_servers[proto]; + proxy - dpm->dhcp_servers[proto]; proxy->dhcp_src_address = *src_address; proxy->rx_fib_index = rx_fib_index; - } + } else - { - if (~0 != dhcp_proxy_server_find(proxy, proto, addr, server_table_id)) - { - return (new); - } - } + { + if (~0 != dhcp_proxy_server_find (proxy, proto, addr, server_table_id)) + { + return (new); + } + } dhcp_server_t server = { - .dhcp_server = *addr, - .server_fib_index = fib_table_find_or_create_and_lock(proto, - server_table_id, - FIB_SOURCE_DHCP), + .dhcp_server = *addr, + .server_fib_index = fib_table_find_or_create_and_lock (proto, + server_table_id, + FIB_SOURCE_DHCP), }; - vec_add1(proxy->dhcp_servers, server); + vec_add1 (proxy->dhcp_servers, server); return (new); } typedef struct dhcp4_proxy_dump_walk_ctx_t_ { - fib_protocol_t proto; - void *opaque; - u32 context; + fib_protocol_t proto; + void *opaque; + u32 context; } dhcp_proxy_dump_walk_cxt_t; static int -dhcp_proxy_dump_walk (dhcp_proxy_t *proxy, - void *arg) +dhcp_proxy_dump_walk (dhcp_proxy_t * proxy, void *arg) { dhcp_proxy_dump_walk_cxt_t *ctx = arg; - dhcp_send_details(ctx->proto, - ctx->opaque, - ctx->context, - proxy); + dhcp_send_details (ctx->proto, ctx->opaque, ctx->context, proxy); return (1); } void -dhcp_proxy_dump (fib_protocol_t proto, - void *opaque, - u32 context) +dhcp_proxy_dump (fib_protocol_t proto, void *opaque, u32 context) { - dhcp_proxy_dump_walk_cxt_t ctx = { - .proto = proto, - .opaque = opaque, - .context = context, - }; - dhcp_proxy_walk(proto, dhcp_proxy_dump_walk, &ctx); + dhcp_proxy_dump_walk_cxt_t ctx = { + .proto = proto, + .opaque = opaque, + .context = context, + }; + dhcp_proxy_walk (proto, dhcp_proxy_dump_walk, &ctx); } int -dhcp_vss_show_walk (dhcp_vss_t *vss, - u32 rx_table_id, - void *ctx) +dhcp_vss_show_walk (dhcp_vss_t * vss, u32 rx_table_id, void *ctx) { - vlib_main_t * vm = ctx; + vlib_main_t *vm = ctx; - if (vss->vss_type == VSS_TYPE_VPN_ID) - { - u32 oui = ((u32) vss->vpn_id[0] << 16) + ((u32) vss->vpn_id[1] << 8) - + ((u32) vss->vpn_id[2]); - u32 fib_id = ((u32) vss->vpn_id[3] << 24) + ((u32) vss->vpn_id[4] << 16) - + ((u32) vss->vpn_id[5] << 8) + ((u32) vss->vpn_id[6]); - vlib_cli_output (vm, " fib_table: %d oui: %d vpn_index: %d", - rx_table_id, oui, fib_id); - } - else if (vss->vss_type == VSS_TYPE_ASCII) - vlib_cli_output (vm, " fib_table: %d vpn_id: %s", - rx_table_id, vss->vpn_ascii_id); - else - vlib_cli_output (vm, " fib_table: %d default global vpn", rx_table_id); + if (vss->vss_type == VSS_TYPE_VPN_ID) + { + u32 oui = ((u32) vss->vpn_id[0] << 16) + ((u32) vss->vpn_id[1] << 8) + + ((u32) vss->vpn_id[2]); + u32 fib_id = ((u32) vss->vpn_id[3] << 24) + ((u32) vss->vpn_id[4] << 16) + + ((u32) vss->vpn_id[5] << 8) + ((u32) vss->vpn_id[6]); + vlib_cli_output (vm, " fib_table: %d oui: %d vpn_index: %d", + rx_table_id, oui, fib_id); + } + else if (vss->vss_type == VSS_TYPE_ASCII) + vlib_cli_output (vm, " fib_table: %d vpn_id: %s", + rx_table_id, vss->vpn_ascii_id); + else + vlib_cli_output (vm, " fib_table: %d default global vpn", rx_table_id); - return (1); + return (1); } -void update_vss (dhcp_vss_t *v, - u8 vss_type, - u8 *vpn_ascii_id, - u32 oui, - u32 vpn_index) +void +update_vss (dhcp_vss_t * v, + u8 vss_type, u8 * vpn_ascii_id, u32 oui, u32 vpn_index) { v->vss_type = vss_type; if (v->vpn_ascii_id) { - if (v->vpn_ascii_id == (u8 *) ~0) + if (v->vpn_ascii_id == (u8 *) ~ 0) v->vpn_ascii_id = 0; else vec_free (v->vpn_ascii_id); } if (vss_type == VSS_TYPE_ASCII) - v->vpn_ascii_id = vpn_ascii_id; + v->vpn_ascii_id = vpn_ascii_id; else if (vss_type == VSS_TYPE_VPN_ID) { v->vpn_id[0] = (oui >> 16) & 0xff; @@ -325,61 +305,59 @@ void update_vss (dhcp_vss_t *v, } } -int dhcp_proxy_set_vss (fib_protocol_t proto, - u32 tbl_id, - u8 vss_type, - u8 *vpn_ascii_id, - u32 oui, - u32 vpn_index, - u8 is_del) +int +dhcp_proxy_set_vss (fib_protocol_t proto, + u32 tbl_id, + u8 vss_type, + u8 * vpn_ascii_id, u32 oui, u32 vpn_index, u8 is_del) { dhcp_proxy_main_t *dm = &dhcp_proxy_main; dhcp_vss_t *v = NULL; - u32 rx_fib_index; + u32 rx_fib_index; int rc = 0; - + if (proto == FIB_PROTOCOL_IP4) - rx_fib_index = fib_table_find_or_create_and_lock(proto, tbl_id, - FIB_SOURCE_DHCP); + rx_fib_index = fib_table_find_or_create_and_lock (proto, tbl_id, + FIB_SOURCE_DHCP); else - rx_fib_index = mfib_table_find_or_create_and_lock(proto, tbl_id, - MFIB_SOURCE_DHCP); - v = dhcp_get_vss_info(dm, rx_fib_index, proto); + rx_fib_index = mfib_table_find_or_create_and_lock (proto, tbl_id, + MFIB_SOURCE_DHCP); + v = dhcp_get_vss_info (dm, rx_fib_index, proto); if (NULL != v) { if (is_del) - { - /* release the lock held on the table when the VSS - * info was created */ - dhcp_proxy_rx_table_unlock (proto, rx_fib_index); + { + /* release the lock held on the table when the VSS + * info was created */ + dhcp_proxy_rx_table_unlock (proto, rx_fib_index); vec_free (v->vpn_ascii_id); - pool_put (dm->vss[proto], v); - dm->vss_index_by_rx_fib_index[proto][rx_fib_index] = ~0; - } + pool_put (dm->vss[proto], v); + dm->vss_index_by_rx_fib_index[proto][rx_fib_index] = ~0; + } else - { + { update_vss (v, vss_type, vpn_ascii_id, oui, vpn_index); - } + } } else { if (is_del) - rc = VNET_API_ERROR_NO_SUCH_ENTRY; + rc = VNET_API_ERROR_NO_SUCH_ENTRY; else - { - /* create a new entry */ - vec_validate_init_empty(dm->vss_index_by_rx_fib_index[proto], - rx_fib_index, ~0); + { + /* create a new entry */ + vec_validate_init_empty (dm->vss_index_by_rx_fib_index[proto], + rx_fib_index, ~0); - /* hold a lock on the table whilst the VSS info exist */ - pool_get (dm->vss[proto], v); + /* hold a lock on the table whilst the VSS info exist */ + pool_get (dm->vss[proto], v); update_vss (v, vss_type, vpn_ascii_id, oui, vpn_index); - dm->vss_index_by_rx_fib_index[proto][rx_fib_index] = - v - dm->vss[proto]; - dhcp_proxy_rx_table_lock (proto, rx_fib_index); - } + dm->vss_index_by_rx_fib_index[proto][rx_fib_index] = + v - dm->vss[proto]; + dhcp_proxy_rx_table_lock (proto, rx_fib_index); + } } /* Release the lock taken during the create_or_lock at the start */ @@ -387,3 +365,11 @@ int dhcp_proxy_set_vss (fib_protocol_t proto, return (rc); } + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/dhcp/dhcp_proxy.h b/src/vnet/dhcp/dhcp_proxy.h index 9b15ac82d1e..ec43769d643 100644 --- a/src/vnet/dhcp/dhcp_proxy.h +++ b/src/vnet/dhcp/dhcp_proxy.h @@ -28,14 +28,16 @@ #include #include -typedef enum { +typedef enum +{ #define dhcp_proxy_error(n,s) DHCP_PROXY_ERROR_##n, #include #undef dhcp_proxy_error DHCP_PROXY_N_ERROR, } dhcp_proxy_error_t; -typedef enum { +typedef enum +{ #define dhcpv6_proxy_error(n,s) DHCPV6_PROXY_ERROR_##n, #include #undef dhcpv6_proxy_error @@ -46,14 +48,15 @@ typedef enum { /** * @brief The Virtual Sub-net Selection information for a given RX FIB */ -typedef struct dhcp_vss_t_ { +typedef struct dhcp_vss_t_ +{ /** * @brief VSS type as defined in RFC 6607: * 0 for NVT ASCII VPN Identifier * 1 for RFC 2685 VPN-ID of 7 octects - 3 bytes OUI & 4 bytes VPN index * 255 for global default VPN */ - u8 vss_type; + u8 vss_type; #define VSS_TYPE_ASCII 0 #define VSS_TYPE_VPN_ID 1 #define VSS_TYPE_INVALID 123 @@ -61,11 +64,11 @@ typedef struct dhcp_vss_t_ { /** * @brief Type 1 VPN-ID */ - u8 vpn_id[7]; + u8 vpn_id[7]; /** * @brief Type 0 ASCII VPN Identifier */ - u8 *vpn_ascii_id; + u8 *vpn_ascii_id; } dhcp_vss_t; /** @@ -77,19 +80,20 @@ typedef struct dhcp_server_t_ * @brief The address of the DHCP server to which to relay the client's * messages */ - ip46_address_t dhcp_server; + ip46_address_t dhcp_server; /** * @brief The FIB index (not the external Table-ID) in which the server * is reachable. */ - u32 server_fib_index; + u32 server_fib_index; } dhcp_server_t; /** * @brief A DHCP proxy represenation fpr per-client VRF config */ -typedef struct dhcp_proxy_t_ { +typedef struct dhcp_proxy_t_ +{ /** * @brief The set of DHCP servers to which messages are relayed. * If multiple servers are configured then discover/solict messages @@ -98,28 +102,28 @@ typedef struct dhcp_proxy_t_ { * cookie. * The expectation is there are only 1 or 2 servers, hence no fancy DB. */ - dhcp_server_t *dhcp_servers; + dhcp_server_t *dhcp_servers; /** * @brief Hash table of pending requets key'd on the clients MAC address */ - uword *dhcp_pending; + uword *dhcp_pending; /** * @brief A lock for the pending request DB. */ - int lock; + int lock; /** * @brief The source address to use in relayed messaes */ - ip46_address_t dhcp_src_address; + ip46_address_t dhcp_src_address; /** * @brief The FIB index (not the external Table-ID) in which the client * is resides. */ - u32 rx_fib_index; + u32 rx_fib_index; } dhcp_proxy_t; #define DHCP_N_PROTOS (FIB_PROTOCOL_IP6 + 1) @@ -127,12 +131,13 @@ typedef struct dhcp_proxy_t_ { /** * @brief Collection of global DHCP proxy data */ -typedef struct { +typedef struct +{ /* Pool of DHCP servers */ dhcp_proxy_t *dhcp_servers[DHCP_N_PROTOS]; /* Pool of selected DHCP server. Zero is the default server */ - u32 * dhcp_server_index_by_rx_fib_index[DHCP_N_PROTOS]; + u32 *dhcp_server_index_by_rx_fib_index[DHCP_N_PROTOS]; /* to drop pkts in server-to-client direction */ u32 error_drop_node_index; @@ -149,117 +154,98 @@ extern dhcp_proxy_main_t dhcp_proxy_main; * @brief Send the details of a proxy session to the API client during a dump */ void dhcp_send_details (fib_protocol_t proto, - void *opaque, - u32 context, - dhcp_proxy_t *proxy); + void *opaque, u32 context, dhcp_proxy_t * proxy); /** * @brief Show (on CLI) a VSS config during a show walk */ -int dhcp_vss_show_walk (dhcp_vss_t *vss, - u32 rx_table_id, - void *ctx); +int dhcp_vss_show_walk (dhcp_vss_t * vss, u32 rx_table_id, void *ctx); /** * @brief Configure/set a new VSS info */ int dhcp_proxy_set_vss (fib_protocol_t proto, - u32 tbl_id, + u32 tbl_id, u8 vss_type, - u8 *vpn_ascii_id, - u32 oui, - u32 vpn_index, - u8 is_del); + u8 * vpn_ascii_id, u32 oui, u32 vpn_index, u8 is_del); /** * @brief Dump the proxy configs to the API */ -void dhcp_proxy_dump(fib_protocol_t proto, - void *opaque, - u32 context); +void dhcp_proxy_dump (fib_protocol_t proto, void *opaque, u32 context); /** * @brief Add a new DHCP proxy server configuration. * @return 1 is the config is new, * 0 otherwise (implying a modify of an existing) */ -int dhcp_proxy_server_add(fib_protocol_t proto, - ip46_address_t *addr, - ip46_address_t *src_address, - u32 rx_fib_iindex, - u32 server_table_id); +int dhcp_proxy_server_add (fib_protocol_t proto, + ip46_address_t * addr, + ip46_address_t * src_address, + u32 rx_fib_iindex, u32 server_table_id); /** * @brief Delete a DHCP proxy config * @return 1 if the proxy is deleted, 0 otherwise */ -int dhcp_proxy_server_del(fib_protocol_t proto, - u32 rx_fib_index, - ip46_address_t *addr, - u32 server_table_id); +int dhcp_proxy_server_del (fib_protocol_t proto, + u32 rx_fib_index, + ip46_address_t * addr, u32 server_table_id); -u32 -dhcp_proxy_rx_table_get_table_id (fib_protocol_t proto, - u32 fib_index); +u32 dhcp_proxy_rx_table_get_table_id (fib_protocol_t proto, u32 fib_index); /** * @brief Callback function invoked for each DHCP proxy entry * return 0 to break the walk, non-zero otherwise. */ -typedef int (*dhcp_proxy_walk_fn_t)(dhcp_proxy_t *server, - void *ctx); +typedef int (*dhcp_proxy_walk_fn_t) (dhcp_proxy_t * server, void *ctx); /** * @brief Walk/Visit each DHCP proxy server */ -void dhcp_proxy_walk(fib_protocol_t proto, - dhcp_proxy_walk_fn_t fn, - void *ctx); +void dhcp_proxy_walk (fib_protocol_t proto, + dhcp_proxy_walk_fn_t fn, void *ctx); /** * @brief Callback function invoked for each DHCP VSS entry * return 0 to break the walk, non-zero otherwise. */ -typedef int (*dhcp_vss_walk_fn_t)(dhcp_vss_t *server, - u32 rx_table_id, - void *ctx); +typedef int (*dhcp_vss_walk_fn_t) (dhcp_vss_t * server, + u32 rx_table_id, void *ctx); /** * @brief Walk/Visit each DHCP proxy VSS */ -void dhcp_vss_walk(fib_protocol_t proto, - dhcp_vss_walk_fn_t fn, - void *ctx); +void dhcp_vss_walk (fib_protocol_t proto, dhcp_vss_walk_fn_t fn, void *ctx); /** * @brief Lock a proxy object to prevent simultaneous access of its * pending store */ -void dhcp_proxy_lock (dhcp_proxy_t *server); +void dhcp_proxy_lock (dhcp_proxy_t * server); /** * @brief Lock a proxy object to prevent simultaneous access of its * pending store */ -void dhcp_proxy_unlock (dhcp_proxy_t *server); +void dhcp_proxy_unlock (dhcp_proxy_t * server); /** * @brief Get the VSS data for the FIB index */ static inline dhcp_vss_t * -dhcp_get_vss_info (dhcp_proxy_main_t *dm, - u32 rx_fib_index, - fib_protocol_t proto) +dhcp_get_vss_info (dhcp_proxy_main_t * dm, + u32 rx_fib_index, fib_protocol_t proto) { dhcp_vss_t *v = NULL; - if (vec_len(dm->vss_index_by_rx_fib_index[proto]) > rx_fib_index && + if (vec_len (dm->vss_index_by_rx_fib_index[proto]) > rx_fib_index && dm->vss_index_by_rx_fib_index[proto][rx_fib_index] != ~0) - { - v = pool_elt_at_index ( - dm->vss[proto], - dm->vss_index_by_rx_fib_index[proto][rx_fib_index]); - } + { + v = pool_elt_at_index (dm->vss[proto], + dm->vss_index_by_rx_fib_index[proto] + [rx_fib_index]); + } return (v); } @@ -268,32 +254,35 @@ dhcp_get_vss_info (dhcp_proxy_main_t *dm, * @brief Get the DHCP proxy server data for the FIB index */ static inline dhcp_proxy_t * -dhcp_get_proxy (dhcp_proxy_main_t *dm, - u32 rx_fib_index, - fib_protocol_t proto) +dhcp_get_proxy (dhcp_proxy_main_t * dm, + u32 rx_fib_index, fib_protocol_t proto) { dhcp_proxy_t *s = NULL; - if (vec_len(dm->dhcp_server_index_by_rx_fib_index[proto]) > rx_fib_index && + if (vec_len (dm->dhcp_server_index_by_rx_fib_index[proto]) > rx_fib_index && dm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] != ~0) - { - s = pool_elt_at_index ( - dm->dhcp_servers[proto], - dm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index]); - } + { + s = pool_elt_at_index (dm->dhcp_servers[proto], + dm->dhcp_server_index_by_rx_fib_index[proto] + [rx_fib_index]); + } return (s); } -int dhcp6_proxy_set_server (ip46_address_t *addr, - ip46_address_t *src_addr, - u32 rx_table_id, - u32 server_table_id, - int is_del); -int dhcp4_proxy_set_server (ip46_address_t *addr, - ip46_address_t *src_addr, - u32 rx_table_id, - u32 server_table_id, - int is_del); +int dhcp6_proxy_set_server (ip46_address_t * addr, + ip46_address_t * src_addr, + u32 rx_table_id, u32 server_table_id, int is_del); +int dhcp4_proxy_set_server (ip46_address_t * addr, + ip46_address_t * src_addr, + u32 rx_table_id, u32 server_table_id, int is_del); #endif /* included_dhcp_proxy_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ -- 2.16.6