static u8 *format_dhcp_client_state (u8 * s, va_list * va);
static vlib_node_registration_t dhcp_client_process_node;
-static void
-dhcp_client_add_rx_address (dhcp_client_main_t * dcm, dhcp_client_t * c)
+#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
{
- /* 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));
-
- /* 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));
-}
-
-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,
- };
+#define _(sym,str) DHCP_STAT_##sym,
+ foreach_dhcp_sent_packet_stat foreach_dhcp_error_counter
+#undef _
+ DHCP_STAT_UNKNOWN,
+ DHCP_STAT_N_STAT,
+} sample_error_t;
- 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,
- };
+static char *dhcp_client_process_stat_strings[] = {
+#define _(sym,string) string,
+ foreach_dhcp_sent_packet_stat foreach_dhcp_error_counter
+#undef _
+ "DHCP unknown packets sent",
+};
- 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)
EVENT_DHCP_CLIENT_WAKEUP, *client_index);
}
+static void
+dhcp_client_addr_callback (dhcp_client_t * c)
+{
+ dhcp_client_main_t *dcm = &dhcp_client_main;
+
+ /* disable the feature */
+ vnet_feature_enable_disable ("ip4-unicast",
+ "ip4-dhcp-client-detect",
+ 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:
+ */
+ 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,
+ };
+ ip46_address_t nh = {
+ .ip4 = c->router_address,
+ };
+
+ /* *INDENT-OFF* */
+ 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);
+ /* *INDENT-ON* */
+ }
+
+ /*
+ * Call the user's event callback to report DHCP information
+ */
+ if (c->event_callback)
+ c->event_callback (c->client_index, c);
+}
+
/*
* dhcp_client_for_us - server-to-client callback.
* Called from proxy_node.c:dhcp_proxy_to_client_input().
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;
{
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 */
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 */
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;
}
- /*
- * 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
- * subnet-mask (an OFFER may not contain it). So add a temporary receice
- * and uRPF excempt entry
- */
- dhcp_client_add_rx_address (dcm, c);
/* Received an offer, go send a request */
c->state = DHCP_REQUEST;
case DHCP_BOUND:
case DHCP_REQUEST:
- if (dhcp_message_type != DHCP_PACKET_ACK)
+ 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)
+ {
+ ip4_add_del_interface_address (dcm->vlib_main, c->sw_if_index,
+ (void *) &c->leased_address,
+ c->subnet_mask_width,
+ 1 /*is_del */ );
+ vnet_feature_enable_disable ("ip4-unicast",
+ "ip4-dhcp-client-detect",
+ 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;
+ c->next_transmit = now;
+ c->retry_count = 0;
+ c->leased_address.as_u32 = 0;
+ c->subnet_mask_width = 0;
+ 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);
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)
- {
- 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,
- };
-
- 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 */
- }
+ 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:
vlib_frame_t *f;
dhcp_option_t *o;
u16 udp_length, ip_length;
+ u32 counter_index;
/* Interface(s) down? */
if ((hw->flags & VNET_HW_INTERFACE_FLAG_LINK_UP) == 0)
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;
/* Send the interface MAC address */
clib_memcpy (dhcp->client_hardware_address, c->l2_rewrite + 6, 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)
dhcp->client_ip_address.as_u32 = c->leased_address.as_u32;
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->flags =
+ clib_host_to_net_u16 (is_broadcast && c->set_broadcast_flag ?
+ DHCP_FLAG_BROADCAST : 0);
dhcp->magic_cookie.as_u32 = DHCP_MAGIC;
o = (dhcp_option_t *) dhcp->options;
udp_length = ip_length - (sizeof (*ip));
udp->length = clib_host_to_net_u16 (udp_length);
+
+ switch (type)
+ {
+#define _(a,b) case DHCP_PACKET_##a: {counter_index = DHCP_STAT_##a; break;}
+ foreach_dhcp_sent_packet_stat
+#undef _
+ default:
+ counter_index = DHCP_STAT_UNKNOWN;
+ break;
+ }
+
+ vlib_node_increment_counter (vm, dhcp_client_process_node.index,
+ counter_index, 1);
}
static int
* 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++;
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++;
if (now > c->lease_expires)
{
+ /* Remove the default route */
if (c->router_address.as_u32)
{
fib_prefix_t all_0s = {
DPO_PROTO_IP4, &nh, c->sw_if_index, ~0,
1, FIB_ROUTE_PATH_FLAG_NONE);
}
-
+ /* Remove the interface address */
dhcp_client_release_address (dcm, c);
c->state = DHCP_DISCOVER;
c->next_transmit = now;
break;
case ~0:
- pool_foreach (c, dcm->clients, (
- {
- timeout =
- dhcp_client_sm (now, timeout,
- (uword) (c -
- dcm->clients));
- }
- ));
+ /* *INDENT-OFF* */
+ pool_foreach (c, dcm->clients,
+ ({
+ timeout = dhcp_client_sm (now, timeout,
+ (uword) (c - dcm->clients));
+ }));
+ /* *INDENT-ON* */
if (pool_elts (dcm->clients) == 0)
timeout = 100.0;
break;
.type = VLIB_NODE_TYPE_PROCESS,
.name = "dhcp-client-process",
.process_log2_n_stack_bytes = 16,
+ .n_errors = ARRAY_LEN(dhcp_client_process_stat_strings),
+ .error_strings = dhcp_client_process_stat_strings,
};
/* *INDENT-ON* */
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 (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);
+ vec_add1 (s, '\n');
+ }
else
- s = format (s, "no address\n");
+ {
+ s = format (s, "no address\n");
+ }
if (verbose)
{
return 0;
}
- pool_foreach (c, dcm->clients, (
- {
- vlib_cli_output (vm, "%U",
- format_dhcp_client, dcm,
- c, verbose);
- }
- ));
+ /* *INDENT-OFF* */
+ pool_foreach (c, dcm->clients,
+ ({
+ vlib_cli_output (vm, "%U",
+ format_dhcp_client, dcm,
+ c, verbose);
+ }));
+ /* *INDENT-ON* */
return 0;
}
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,
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;
c->option_55_data = a->option_55_data;
c->hostname = a->hostname;
c->client_identifier = a->client_identifier;
+ c->set_broadcast_flag = a->set_broadcast_flag;
do
{
c->transaction_id = random_u32 (&dcm->seed);
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);
-
/*
- * enable the interface to RX IPv4 packets
- * this is also ref counted
+ * In order to accept any OFFER, whether broadcasted or unicasted, we
+ * need to configure the dhcp-client-detect feature as an input feature
+ * so the DHCP OFFER is sent to the ip4-local node. Without this a
+ * broadcasted OFFER hits the 255.255.255.255/32 address and a unicast
+ * hits 0.0.0.0/0 both of which default to drop and the latter may forward
+ * of box - not what we want. Nor to we want to change these route for
+ * all interfaces in this table
*/
- ip4_sw_interface_enable_disable (c->sw_if_index, 1);
+ vnet_feature_enable_disable ("ip4-unicast",
+ "ip4-dhcp-client-detect",
+ 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);
{
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);
-
if (c->router_address.as_u32)
{
ip46_address_t nh = {
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);
+ vec_free (c->domain_server_address);
vec_free (c->option_55_data);
vec_free (c->hostname);
vec_free (c->client_identifier);
}
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, u32 pid)
+ dhcp_event_cb_t event_callback,
+ u8 set_broadcast_flag, 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;
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);
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,
u32 sw_if_index;
u8 *hostname = 0;
u8 sw_if_index_set = 0;
+ u8 set_broadcast_flag = 1;
int is_add = 1;
dhcp_client_add_del_args_t _a, *a = &_a;
int rv;
;
else if (unformat (input, "del"))
is_add = 0;
+ else if (unformat (input, "broadcast", &set_broadcast_flag))
+ is_add = 0;
else
break;
}
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;
a->client_identifier = format (0, "vpe 1.0%c", 0);
+ a->set_broadcast_flag = set_broadcast_flag;
/*
* Option 55 request list. These data precisely match
dcm->vlib_main = vm;
dcm->vnet_main = vnet_get_main ();
- dcm->seed = 0xdeaddabe;
+ dcm->seed = (u32) clib_cpu_time_now ();
return 0;
}