X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fdhcp%2Fclient.c;h=aaeda96327d49098128dbd0e8fbf97c8bdf8cecc;hb=038e1dfbd;hp=2e47d6e6dca7a806d8570d9f5f630e144d986ff0;hpb=43ebe29b6ea1107c30311cfb3dbd8190282903d0;p=vpp.git diff --git a/src/vnet/dhcp/client.c b/src/vnet/dhcp/client.c index 2e47d6e6dca..aaeda96327d 100644 --- a/src/vnet/dhcp/client.c +++ b/src/vnet/dhcp/client.c @@ -13,24 +13,33 @@ * limitations under the License. */ #include +#include #include #include #include +#include dhcp_client_main_t dhcp_client_main; static u8 *format_dhcp_client_state (u8 * s, va_list * va); static vlib_node_registration_t dhcp_client_process_node; -#define foreach_dhcp_client_process_stat \ +#define foreach_dhcp_sent_packet_stat \ _(DISCOVER, "DHCP discover packets sent") \ _(OFFER, "DHCP offer packets sent") \ _(REQUEST, "DHCP request packets sent") \ _(ACK, "DHCP ack packets sent") +#define foreach_dhcp_error_counter \ +_(NOT_FOR_US, "DHCP packets for other hosts, dropped") \ +_(NAK, "DHCP nak packets received") \ +_(NON_OFFER_DISCOVER, "DHCP non-offer packets in discover state") \ +_(ODDBALL, "DHCP non-ack, non-offer packets received") \ +_(BOUND, "DHCP bind success") + typedef enum { #define _(sym,str) DHCP_STAT_##sym, - foreach_dhcp_client_process_stat + foreach_dhcp_sent_packet_stat foreach_dhcp_error_counter #undef _ DHCP_STAT_UNKNOWN, DHCP_STAT_N_STAT, @@ -38,12 +47,11 @@ typedef enum static char *dhcp_client_process_stat_strings[] = { #define _(sym,string) string, - foreach_dhcp_client_process_stat + foreach_dhcp_sent_packet_stat foreach_dhcp_error_counter #undef _ "DHCP unknown packets sent", }; - static void dhcp_client_acquire_address (dhcp_client_main_t * dcm, dhcp_client_t * c) { @@ -68,18 +76,6 @@ dhcp_client_release_address (dhcp_client_main_t * dcm, dhcp_client_t * c) 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 */ ); -} - -void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length); - static void dhcp_client_proc_callback (uword * client_index) { @@ -93,13 +89,19 @@ static void dhcp_client_addr_callback (dhcp_client_t * c) { dhcp_client_main_t *dcm = &dhcp_client_main; - void (*fp) (u32, u32, u8 *, u8, u8, u8 *, u8 *, u8 *) = c->event_callback; - /* add the advertised subnet and disable the feature */ - dhcp_client_acquire_address (dcm, c); + /* disable the feature */ vnet_feature_enable_disable ("ip4-unicast", "ip4-dhcp-client-detect", - c->sw_if_index, 0, 0, 0); + c->sw_if_index, 0 /* disable */ , 0, 0); + c->client_detect_feature_enabled = 0; + + /* if renewing the lease, the address and route have already been added */ + if (c->state == DHCP_BOUND) + return; + + /* add the address to the interface */ + dhcp_client_acquire_address (dcm, c); /* * Configure default IP route: @@ -129,16 +131,20 @@ dhcp_client_addr_callback (dhcp_client_t * c) FIB_ROUTE_PATH_FLAG_NONE); /* *INDENT-ON* */ } + if (c->dhcp_server.as_u32) + { + ip46_address_t dst = { + .ip4 = c->dhcp_server, + }; + c->ai_ucast = adj_nbr_add_or_lock (FIB_PROTOCOL_IP4, + VNET_LINK_IP4, &dst, c->sw_if_index); + } /* * 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 */ + if (c->event_callback) + c->event_callback (c->client_index, c); } /* @@ -177,6 +183,15 @@ dhcp_client_for_us (u32 bi, vlib_buffer_t * b, if (c->state == DHCP_BOUND && c->retry_count == 0) return 0; + /* Packet not for us? Turf it... */ + if (memcmp (dhcp->client_hardware_address, c->client_hardware_address, + sizeof (c->client_hardware_address))) + { + vlib_node_increment_counter (vm, dhcp_client_process_node.index, + DHCP_STAT_NOT_FOR_US, 1); + return 0; + } + /* parse through the packet, learn what we can */ if (dhcp->your_ip_address.as_u32) c->leased_address.as_u32 = dhcp->your_ip_address.as_u32; @@ -198,6 +213,7 @@ dhcp_client_for_us (u32 bi, vlib_buffer_t * b, { u32 lease_time_in_seconds = clib_host_to_net_u32 (o->data_as_u32[0]); + // for debug: lease_time_in_seconds = 20; /*$$$$*/ 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 */ @@ -229,7 +245,14 @@ dhcp_client_for_us (u32 bi, vlib_buffer_t * b, c->router_address.as_u32 = router_address; } break; - + case 6: /* domain server address */ + { + vec_free (c->domain_server_address); + vec_validate (c->domain_server_address, + o->length / sizeof (ip4_address_t) - 1); + clib_memcpy (c->domain_server_address, o->data, o->length); + } + break; case 12: /* hostname */ { /* Replace the existing hostname if necessary */ @@ -252,9 +275,8 @@ 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); + vlib_node_increment_counter (vm, dhcp_client_process_node.index, + DHCP_STAT_NON_OFFER_DISCOVER, 1); c->next_transmit = now + 5.0; break; } @@ -273,6 +295,8 @@ dhcp_client_for_us (u32 bi, vlib_buffer_t * b, case DHCP_REQUEST: if (dhcp_message_type == DHCP_PACKET_NAK) { + vlib_node_increment_counter (vm, dhcp_client_process_node.index, + DHCP_STAT_NAK, 1); /* Probably never happens in bound state, but anyhow... */ if (c->state == DHCP_BOUND) { @@ -282,7 +306,9 @@ dhcp_client_for_us (u32 bi, vlib_buffer_t * b, 1 /*is_del */ ); vnet_feature_enable_disable ("ip4-unicast", "ip4-dhcp-client-detect", - c->sw_if_index, 1, 0, 0); + c->sw_if_index, 1 /* enable */ , + 0, 0); + c->client_detect_feature_enabled = 1; } /* Wipe out any memory of the address we had... */ c->state = DHCP_DISCOVER; @@ -293,12 +319,15 @@ dhcp_client_for_us (u32 bi, vlib_buffer_t * b, c->router_address.as_u32 = 0; c->lease_renewal_interval = 0; c->dhcp_server.as_u32 = 0; + vec_free (c->domain_server_address); break; } if (dhcp_message_type != DHCP_PACKET_ACK && dhcp_message_type != DHCP_PACKET_OFFER) { + vlib_node_increment_counter (vm, dhcp_client_process_node.index, + DHCP_STAT_NON_OFFER_DISCOVER, 1); clib_warning ("sw_if_index %d state %U message type %d", c->sw_if_index, format_dhcp_client_state, c->state, dhcp_message_type); @@ -306,14 +335,15 @@ dhcp_client_for_us (u32 bi, vlib_buffer_t * b, break; } /* OK, we own the address (etc), add to the routing table(s) */ - if (c->state == DHCP_REQUEST) - vl_api_rpc_call_main_thread (dhcp_client_addr_callback, - (u8 *) c, sizeof (*c)); + vl_api_rpc_call_main_thread (dhcp_client_addr_callback, + (u8 *) c, sizeof (*c)); c->state = DHCP_BOUND; c->retry_count = 0; c->next_transmit = now + (f64) c->lease_renewal_interval; c->lease_expires = now + (f64) c->lease_lifetime; + vlib_node_increment_counter (vm, dhcp_client_process_node.index, + DHCP_STAT_BOUND, 1); break; default: @@ -345,7 +375,7 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, vlib_frame_t *f; dhcp_option_t *o; u16 udp_length, ip_length; - u32 counter_index; + u32 counter_index, node_index; /* Interface(s) down? */ if ((hw->flags & VNET_HW_INTERFACE_FLAG_LINK_UP) == 0) @@ -364,45 +394,60 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, /* Build a dhcpv4 pkt from whole cloth */ b = vlib_get_buffer (vm, bi); + VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b); ASSERT (b->current_data == 0); 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)); - ip = (void *) - (((u8 *) vlib_buffer_get_current (b)) + vec_len (c->l2_rewrite)); + node_index = ip4_rewrite_node.index; + vnet_buffer (b)->ip.adj_index[VLIB_TX] = c->ai_bcast; } else { - f = vlib_get_frame_to_node (vm, ip4_lookup_node.index); - vnet_buffer (b)->sw_if_index[VLIB_TX] = ~0; /* use interface VRF */ - ip = vlib_buffer_get_current (b); + ip_adjacency_t *adj = adj_get (c->ai_ucast); + + if (IP_LOOKUP_NEXT_ARP == adj->lookup_next_index) + node_index = ip4_arp_node.index; + else + node_index = ip4_rewrite_node.index; + vnet_buffer (b)->ip.adj_index[VLIB_TX] = c->ai_ucast; } /* Enqueue the packet right now */ + f = vlib_get_frame_to_node (vm, node_index); to_next = vlib_frame_vector_args (f); to_next[0] = bi; f->n_vectors = 1; + vlib_put_frame_to_node (vm, node_index, f); - if (is_broadcast) - vlib_put_frame_to_node (vm, hw->output_node_index, f); - else - vlib_put_frame_to_node (vm, ip4_lookup_node.index, f); - + /* build the headers */ + ip = vlib_buffer_get_current (b); udp = (udp_header_t *) (ip + 1); dhcp = (dhcp_header_t *) (udp + 1); /* $$$ optimize, maybe */ - memset (ip, 0, sizeof (*ip) + sizeof (*udp) + sizeof (*dhcp)); + clib_memset (ip, 0, sizeof (*ip) + sizeof (*udp) + sizeof (*dhcp)); ip->ip_version_and_header_length = 0x45; ip->ttl = 128; ip->protocol = IP_PROTOCOL_UDP; + ip->tos = c->dscp; + + if (ip->tos) + { + /* + * Setup the buffer's QoS settings so any QoS marker on the egress + * interface, that might set VLAN CoS bits, based on this DSCP setting + */ + vnet_buffer2 (b)->qos.source = QOS_SOURCE_IP; + vnet_buffer2 (b)->qos.bits = ip->tos; + b->flags |= VNET_BUFFER_F_QOS_DATA_VALID; + } + if (is_broadcast) { /* src = 0.0.0.0, dst = 255.255.255.255 */ @@ -419,7 +464,12 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, udp->dst_port = clib_host_to_net_u16 (UDP_DST_PORT_dhcp_to_server); /* Send the interface MAC address */ - clib_memcpy (dhcp->client_hardware_address, c->l2_rewrite + 6, 6); + clib_memcpy (dhcp->client_hardware_address, + vnet_sw_interface_get_hw_address (vnm, c->sw_if_index), 6); + + /* And remember it for rx-packet-for-us checking */ + clib_memcpy (c->client_hardware_address, dhcp->client_hardware_address, + sizeof (c->client_hardware_address)); /* Lease renewal, set up client_ip_address */ if (is_broadcast == 0) @@ -516,8 +566,6 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, /* 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 = clib_host_to_net_u16 (ip_length); ip->checksum = ip4_header_checksum (ip); @@ -528,7 +576,7 @@ send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, switch (type) { #define _(a,b) case DHCP_PACKET_##a: {counter_index = DHCP_STAT_##a; break;} - foreach_dhcp_client_process_stat + foreach_dhcp_sent_packet_stat #undef _ default: counter_index = DHCP_STAT_UNKNOWN; @@ -546,6 +594,15 @@ 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. */ + + if (c->client_detect_feature_enabled == 0) + { + vnet_feature_enable_disable ("ip4-unicast", + "ip4-dhcp-client-detect", + c->sw_if_index, 1 /* enable */ , 0, 0); + c->client_detect_feature_enabled = 1; + } + send_dhcp_pkt (dcm, c, DHCP_PACKET_DISCOVER, 1 /* is_broadcast */ ); c->retry_count++; @@ -581,10 +638,25 @@ static int dhcp_bound_state (dhcp_client_main_t * dcm, dhcp_client_t * c, f64 now) { /* - * State machine "BOUND" state. Send a dhcp request packet, - * eventually, when the lease expires, forget the dhcp data + * State machine "BOUND" state. Send a dhcp request packet to renew + * the lease. + * Eventually, when the lease expires, forget the dhcp data * and go back to the stone age. */ + + /* + * We disable the client detect feature when we bind a + * DHCP address. Turn it back on again on first renew attempt. + * Otherwise, if the DHCP server replies we'll never see it. + */ + if (c->client_detect_feature_enabled == 0) + { + vnet_feature_enable_disable ("ip4-unicast", + "ip4-dhcp-client-detect", + c->sw_if_index, 1 /* enable */ , 0, 0); + c->client_detect_feature_enabled = 1; + } + send_dhcp_pkt (dcm, c, DHCP_PACKET_REQUEST, 0 /* is_broadcast */ ); c->retry_count++; @@ -624,15 +696,6 @@ dhcp_bound_state (dhcp_client_main_t * dcm, dhcp_client_t * c, f64 now) c->router_address.as_u32 = 0; c->lease_renewal_interval = 0; c->dhcp_server.as_u32 = 0; - /* - * We disable the client detect feature when we bind a - * DHCP address. Turn it back on again here. - * Otherwise, if the DHCP server replies after an outage, - * we'll never see it. - */ - vnet_feature_enable_disable ("ip4-unicast", - "ip4-dhcp-client-detect", - c->sw_if_index, 1, 0, 0); return 1; } return 0; @@ -770,22 +833,43 @@ 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 *); int verbose = va_arg (*va, int); + ip4_address_t *addr; 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 (0 != c->dscp) + s = format (s, "dscp %d ", c->dscp); + 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); + { + s = format (s, "addr %U/%d gw %U", + format_ip4_address, &c->leased_address, + c->subnet_mask_width, format_ip4_address, + &c->router_address); + + vec_foreach (addr, c->domain_server_address) + s = format (s, " dns %U", format_ip4_address, addr); + } else - s = format (s, "no address\n"); + { + s = format (s, "no address\n"); + } if (verbose) { - s = format (s, "retry count %d, next xmt %.2f", - c->retry_count, c->next_transmit); + s = + format (s, + "\n lease: lifetime:%d renewal-interval:%d expires:%.2f (now:%.2f)", + c->lease_lifetime, c->lease_renewal_interval, + c->lease_expires, vlib_time_now (dcm->vlib_main)); + s = + format (s, "\n retry-count:%d, next-xmt:%.2f", c->retry_count, + c->next_transmit); + s = + format (s, "\n adjacencies:[unicast:%d broadcast:%d]", c->ai_ucast, + c->ai_bcast); } return s; } @@ -863,8 +947,9 @@ dhcp_client_add_del (dhcp_client_add_del_args_t * a) if (a->is_add) { + dhcp_maybe_register_udp_ports (DHCP_PORT_REG_CLIENT); pool_get (dcm->clients, c); - memset (c, 0, sizeof (*c)); + clib_memset (c, 0, sizeof (*c)); c->state = DHCP_DISCOVER; c->sw_if_index = a->sw_if_index; c->client_index = a->client_index; @@ -874,12 +959,18 @@ dhcp_client_add_del (dhcp_client_add_del_args_t * a) c->hostname = a->hostname; c->client_identifier = a->client_identifier; c->set_broadcast_flag = a->set_broadcast_flag; + c->dscp = a->dscp; + c->ai_ucast = ADJ_INDEX_INVALID; + c->ai_bcast = adj_nbr_add_or_lock (FIB_PROTOCOL_IP4, + VNET_LINK_IP4, + &ADJ_BCAST_ADDR, c->sw_if_index); + 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); /* @@ -893,7 +984,8 @@ dhcp_client_add_del (dhcp_client_add_del_args_t * a) */ vnet_feature_enable_disable ("ip4-unicast", "ip4-dhcp-client-detect", - c->sw_if_index, 1, 0, 0); + c->sw_if_index, 1 /* enable */ , 0, 0); + c->client_detect_feature_enabled = 1; vlib_process_signal_event (vm, dhcp_client_process_node.index, EVENT_DHCP_CLIENT_WAKEUP, c - dcm->clients); @@ -916,10 +1008,13 @@ dhcp_client_add_del (dhcp_client_add_del_args_t * a) } dhcp_client_release_address (dcm, c); + adj_unlock (c->ai_ucast); + adj_unlock (c->ai_bcast); + + vec_free (c->domain_server_address); vec_free (c->option_55_data); vec_free (c->hostname); vec_free (c->client_identifier); - vec_free (c->l2_rewrite); hash_unset (dcm->client_by_sw_if_index, c->sw_if_index); pool_put (dcm->clients, c); } @@ -927,24 +1022,26 @@ dhcp_client_add_del (dhcp_client_add_del_args_t * a) } int -dhcp_client_config (vlib_main_t * vm, +dhcp_client_config (u32 is_add, + u32 client_index, + vlib_main_t * vm, u32 sw_if_index, u8 * hostname, u8 * client_id, - u32 is_add, - u32 client_index, - void *event_callback, u8 set_broadcast_flag, u32 pid) + dhcp_event_cb_t event_callback, + u8 set_broadcast_flag, ip_dscp_t dscp, u32 pid) { dhcp_client_add_del_args_t _a, *a = &_a; int rv; - memset (a, 0, sizeof (*a)); + clib_memset (a, 0, sizeof (*a)); a->is_add = is_add; a->sw_if_index = sw_if_index; a->client_index = client_index; a->pid = pid; a->event_callback = event_callback; a->set_broadcast_flag = set_broadcast_flag; + a->dscp = dscp; 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); @@ -1011,6 +1108,22 @@ dhcp_client_config (vlib_main_t * vm, return rv; } +void +dhcp_client_walk (dhcp_client_walk_cb_t cb, void *ctx) +{ + dhcp_client_main_t *dcm = &dhcp_client_main; + dhcp_client_t *c; + + /* *INDENT-OFF* */ + pool_foreach (c, dcm->clients, + ({ + if (!cb(c, ctx)) + break; + })); + /* *INDENT-ON* */ + +} + static clib_error_t * dhcp_client_set_command_fn (vlib_main_t * vm, unformat_input_t * input, @@ -1044,7 +1157,7 @@ dhcp_client_set_command_fn (vlib_main_t * vm, if (sw_if_index_set == 0) return clib_error_return (0, "interface not specified"); - memset (a, 0, sizeof (*a)); + clib_memset (a, 0, sizeof (*a)); a->is_add = is_add; a->sw_if_index = sw_if_index; a->hostname = hostname; @@ -1127,7 +1240,7 @@ dhcp_client_init (vlib_main_t * vm) dcm->vlib_main = vm; dcm->vnet_main = vnet_get_main (); - dcm->seed = 0xdeaddabe; + dcm->seed = (u32) clib_cpu_time_now (); return 0; }