* limitations under the License.
*/
#include <vlib/vlib.h>
+#include <vlibmemory/api.h>
#include <vnet/dhcp/client.h>
#include <vnet/dhcp/dhcp_proxy.h>
#include <vnet/fib/fib_table.h>
+#include <vnet/qos/qos_types.h>
dhcp_client_main_t dhcp_client_main;
static u8 *format_dhcp_client_state (u8 * s, va_list * va);
"DHCP unknown packets sent",
};
-
static void
dhcp_client_acquire_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)
{
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 /* 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:
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);
}
/*
{
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 */
"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->router_address.as_u32 = 0;
c->lease_renewal_interval = 0;
c->dhcp_server.as_u32 = 0;
+ vec_free (c->domain_server_address);
break;
}
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;
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)
/* 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 */
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,
/* 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);
* 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++;
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 /* enable */ , 0, 0);
return 1;
}
return 0;
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;
}
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->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);
/*
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);
}
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);
}
}
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);
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,
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;
dcm->vlib_main = vm;
dcm->vnet_main = vnet_get_main ();
- dcm->seed = 0xdeaddabe;
+ dcm->seed = (u32) clib_cpu_time_now ();
return 0;
}