Skip to contentSkip to conversation

dhcp: release lease when client stops

PATCH In review James Prestwood 2 participants 10 messages Nov 23, 2020

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/9 dhcp: release lease when client stops

RFC 2131 does not explicitly require this but clients MAY release their IP address when they are done using it, e.g. when shutting down. This is also described as a "graceful shutdown" so its probably best the DHCP client does this.

---
 ell/dhcp.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 65 insertions(+), 9 deletions(-)

v2:
* Send release in BOUND, RENEW, and REBINDING states

ell/dhcp.c +65 -9
index e6fbda7..dc4e73b 100644
@@ -367,6 +367,19 @@ static int dhcp_client_send_discover(struct l_dhcp_client *client)
 					discover, len);
 }
 
+static int dhcp_client_send_unicast(struct l_dhcp_client *client,
+					struct dhcp_message *request,
+					unsigned int len)
+{
+	struct sockaddr_in si;
+
+	memset(&si, 0, sizeof(si));
+	si.sin_family = AF_INET;
+	si.sin_port = L_CPU_TO_BE16(DHCP_PORT_SERVER);
+	si.sin_addr.s_addr = client->lease->server_address;
+	return client->transport->send(client->transport, &si, request, len);
+}
+
 static int dhcp_client_send_request(struct l_dhcp_client *client)
 {
 	struct dhcp_message_builder builder;
@@ -450,15 +463,8 @@ static int dhcp_client_send_request(struct l_dhcp_client *client)
 	 * 'server identifier' option for any unicast requests to the DHCP
 	 * server.
 	 */
-	if (client->state == DHCP_STATE_RENEWING) {
-		struct sockaddr_in si;
-		memset(&si, 0, sizeof(si));
-		si.sin_family = AF_INET;
-		si.sin_port = L_CPU_TO_BE16(DHCP_PORT_SERVER);
-		si.sin_addr.s_addr = client->lease->server_address;
-		return client->transport->send(client->transport,
-							&si, request, len);
-	}
+	if (client->state == DHCP_STATE_RENEWING)
+		return dhcp_client_send_unicast(client, request, len);
 
 	return client->transport->l2_send(client->transport,
 					INADDR_ANY, DHCP_PORT_CLIENT,
@@ -466,6 +472,45 @@ static int dhcp_client_send_request(struct l_dhcp_client *client)
 					NULL, request, len);
 }
 
+static void dhcp_client_send_release(struct l_dhcp_client *client)
+{
+	struct dhcp_message_builder builder;
+	size_t optlen = DHCP_MIN_OPTIONS_SIZE;
+	size_t len = sizeof(struct dhcp_message) + optlen;
+	L_AUTO_FREE_VAR(struct dhcp_message *, request);
+	int err;
+	struct sockaddr_in si;
+
+	CLIENT_DEBUG("");
+
+	memset(&si, 0, sizeof(si));
+	si.sin_family = AF_INET;
+	si.sin_port = L_CPU_TO_BE16(DHCP_PORT_SERVER);
+	si.sin_addr.s_addr = client->lease->server_address;
+
+	request = (struct dhcp_message *) l_new(uint8_t, len);
+
+	_dhcp_message_builder_init(&builder, request, len,
+					DHCP_MESSAGE_TYPE_RELEASE);
+
+	err = client_message_init(client, request, &builder);
+	if (err < 0)
+		return;
+
+	request->ciaddr = client->lease->address;
+
+	if (!_dhcp_message_builder_append(&builder,
+					L_DHCP_OPTION_SERVER_IDENTIFIER,
+					4, &client->lease->server_address)) {
+		CLIENT_DEBUG("Failed to append server ID");
+		return;
+	}
+
+	_dhcp_message_builder_finalize(&builder, &len);
+
+	dhcp_client_send_unicast(client, request, len);
+}
+
 static void dhcp_client_timeout_resend(struct l_timeout *timeout,
 								void *user_data)
 {
@@ -1063,6 +1108,17 @@ LIB_EXPORT bool l_dhcp_client_stop(struct l_dhcp_client *client)
 	if (unlikely(!client))
 		return false;
 
+	/*
+	 * RFC 2131 Section 4.4.6
+	 * "If the client no longer requires use of its assigned network address
+	 * (e.g., the client is gracefully shut down), the client sends a
+	 * DHCPRELEASE message to the server.""
+	 */
+	if (client->state == DHCP_STATE_BOUND ||
+			client->state == DHCP_STATE_RENEWING ||
+			client->state == DHCP_STATE_REBINDING)
+		dhcp_client_send_release(client);
+
 	if (client->rtnl_add_cmdid) {
 		l_netlink_cancel(client->rtnl, client->rtnl_add_cmdid);
 		client->rtnl_add_cmdid = 0;
Signature · 1 line
2.26.2
#1 lore raw

PATCH v2 2/9 dhcp-private: add flag in lease to distinguish offered/active

The DHCP server did not distinguish between a lease which has been offered, and one that is active.

---
 ell/dhcp-private.h | 3 +++
 1 file changed, 3 insertions(+)
ell/dhcp-private.h +3 -0
index 62abfca..17d0574 100644
@@ -158,6 +158,9 @@ struct l_dhcp_lease {
 	char *domain_name;
 	/* for server */
 	uint8_t mac[6];
+
+	/* set for an offered lease, but not ACK'ed */
+	bool offering : 1;
 };
 
 struct l_dhcp_lease *_dhcp_lease_new(void);
Signature · 1 line
2.26.2
#2 lore raw

PATCH v2 3/9 dhcp-server: add timer for tracking expired leases

In reply to James Prestwood

Currently dhcp-server has a limitation where it only calls the lease expired callback if a client actually releases the lease itself.

This patchs adds a single timer to the server object which tracks the soonest expiring lease. When this lease expires the event is triggered and the timeout is reset to the (new) soonest expiring lease.

---
 ell/dhcp-server.c | 163 +++++++++++++++++++++++++++++++++++++---------
 1 file changed, 132 insertions(+), 31 deletions(-)

v2:
* Added an expired list queue which all expired leases get moved into after expiration. This queue can be pulled from if there are no more IPs available.

ell/dhcp-server.c +132 -31
index 2be14b4..c01aba2 100644
@@ -37,6 +37,7 @@
 #include "queue.h"
 #include "util.h"
 #include "strv.h"
+#include "timeout.h"
 
 /* 8 hours */
 #define DEFAULT_DHCP_LEASE_SEC (8*60*60)
@@ -44,6 +45,8 @@
 /* 5 minutes  */
 #define OFFER_TIME (5*60)
 
+#define MAX_EXPIRED_LEASES 50
+
 static const uint8_t MAC_BCAST_ADDR[ETH_ALEN] = {
 	0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
@@ -59,8 +62,13 @@ struct l_dhcp_server {
 	uint32_t gateway;
 	uint32_t *dns_list;
 	uint32_t lease_seconds;
+	unsigned int max_expired;
 
 	struct l_queue *lease_list;
+	struct l_queue *expired_list;
+
+	/* Next lease expiring */
+	struct l_timeout *next_expire;
 
 	l_dhcp_debug_cb_t debug_handler;
 	void *debug_data;
@@ -156,16 +164,77 @@ static int get_lease(struct l_dhcp_server *server, uint32_t yiaddr,
 	return 0;
 }
 
-static int compare_lifetime(const void *a, const void *b, void *user_data)
+static int compare_lifetime_or_offering(const void *a, const void *b,
+					void *user_data)
 {
 	const struct l_dhcp_lease *lease1 = a;
 	const struct l_dhcp_lease *lease2 = b;
 
+	/*
+	 * Ensures offered but not active leases stay at the head of the queue.
+	 * This lets us peek at the tail to find the next expiring (active)
+	 */
+	if (lease1->offering)
+		return 1;
+
 	return lease2->lifetime - lease1->lifetime;
 }
 
+struct lease_expire_data {
+	struct l_dhcp_lease *lease;
+	struct l_dhcp_server *server;
+};
+
+static void lease_expired_cb(struct l_timeout *timeout, void *user_data);
+
+static void set_next_expire_timer(struct l_dhcp_server *server,
+					struct l_dhcp_lease *expired)
+{
+	struct lease_expire_data *data;
+	struct l_dhcp_lease *next;
+	unsigned int next_timeout;
+
+	l_queue_remove(server->lease_list, expired);
+
+	if (l_queue_length(server->expired_list) > server->max_expired)
+		_dhcp_lease_free(l_queue_pop_head(server->expired_list));
+
+	l_queue_push_tail(server->expired_list, expired);
+
+	next = l_queue_peek_tail(server->lease_list);
+	if (!next || next->offering) {
+		server->next_expire = NULL;
+		return;
+	}
+
+	next_timeout = l_time_to_secs(l_time_diff(l_time_now(), next->lifetime));
+
+	data = l_new(struct lease_expire_data, 1);
+
+	data->server = server;
+	data->lease = next;
+
+	l_timeout_remove(server->next_expire);
+
+	server->next_expire = l_timeout_create(next_timeout, lease_expired_cb,
+						data, l_free);
+}
+
+static void lease_expired_cb(struct l_timeout *timeout, void *user_data)
+{
+	struct lease_expire_data *data = user_data;
+	struct l_dhcp_server *server = data->server;
+	struct l_dhcp_lease *lease = data->lease;
+
+	if (server->event_handler)
+		server->event_handler(server, L_DHCP_SERVER_EVENT_LEASE_EXPIRED,
+					server->user_data, lease);
+
+	set_next_expire_timer(server, lease);
+}
+
 static struct l_dhcp_lease *add_lease(struct l_dhcp_server *server,
-					uint32_t expire, const uint8_t *chaddr,
+					bool offering, const uint8_t *chaddr,
 					uint32_t yiaddr)
 {
 	struct l_dhcp_lease *lease = NULL;
@@ -180,13 +249,36 @@ static struct l_dhcp_lease *add_lease(struct l_dhcp_server *server,
 	memcpy(lease->mac, chaddr, ETH_ALEN);
 	lease->address = yiaddr;
 
-	if (expire == 0)
-		lease->lifetime = l_time_to_secs(l_time_now()) +
-						server->lease_seconds;
-	else
-		lease->lifetime = expire;
+	lease->offering = offering;
+	lease->lifetime = l_time_to_secs(l_time_now());
+
+	if (!offering) {
+		lease->lifetime += server->lease_seconds;
+
+		if (!server->next_expire) {
+			struct lease_expire_data *data = l_new(
+						struct lease_expire_data, 1);
 
-	l_queue_insert(server->lease_list, lease, compare_lifetime, NULL);
+			data->lease = lease;
+			data->server = server;
+
+			server->next_expire = l_timeout_create(
+							server->lease_seconds,
+							lease_expired_cb,
+							data, l_free);
+		}
+
+		/*
+		 * Insert into queue by lifetime (skipping any offered leases
+		 * at the head)
+		 */
+		l_queue_insert(server->lease_list, lease,
+					compare_lifetime_or_offering, NULL);
+	} else {
+		lease->lifetime += OFFER_TIME;
+		/* Push offered leases to head, active leases after those */
+		l_queue_push_head(server->lease_list, lease);
+	}
 
 	SERVER_DEBUG("added lease IP %s for "MAC " lifetime=%u",
 			IP_STR(yiaddr), MAC_STR(chaddr),
@@ -196,17 +288,21 @@ static struct l_dhcp_lease *add_lease(struct l_dhcp_server *server,
 }
 
 static void lease_release(struct l_dhcp_server *server,
-			struct l_dhcp_lease *lease, uint32_t expire)
+			struct l_dhcp_lease *lease)
 {
-	l_queue_remove(server->lease_list, lease);
-
-	lease->lifetime = expire;
-
-	l_queue_insert(server->lease_list, lease, compare_lifetime, NULL);
+	/*
+	 * If the client released the lease after the server timeout expired
+	 * there is nothing to do. Otherwise the client is releasing the
+	 * lease early which may require re-setting the lease expire timer
+	 */
+	if (is_expired_lease(lease))
+		return;
 
 	if (server->event_handler)
 		server->event_handler(server, L_DHCP_SERVER_EVENT_LEASE_EXPIRED,
 					server->user_data, lease);
+
+	set_next_expire_timer(server, lease);
 }
 
 static bool match_lease_ip(const void *data, const void *user_data)
@@ -216,11 +312,10 @@ static bool match_lease_ip(const void *data, const void *user_data)
 	return lease->address == L_PTR_TO_UINT(user_data);
 }
 
-static struct l_dhcp_lease *find_lease_by_ip(struct l_dhcp_server *server,
+static struct l_dhcp_lease *find_lease_by_ip(struct l_queue *lease_list,
 						uint32_t nip)
 {
-	return l_queue_find(server->lease_list, match_lease_ip,
-				L_UINT_TO_PTR(nip));
+	return l_queue_find(lease_list, match_lease_ip, L_UINT_TO_PTR(nip));
 }
 
 static bool check_requested_ip(struct l_dhcp_server *server,
@@ -237,7 +332,7 @@ static bool check_requested_ip(struct l_dhcp_server *server,
 	if (htonl(requested_nip) > server->end_ip)
 		return false;
 
-	lease = find_lease_by_ip(server, requested_nip);
+	lease = find_lease_by_ip(server->lease_list, requested_nip);
 	if (!lease)
 		return true;
 
@@ -272,7 +367,17 @@ static uint32_t find_free_or_expired_ip(struct l_dhcp_server *server,
 		if ((ip_addr & 0xff) == 0xff)
 			continue;
 
-		lease = find_lease_by_ip(server, ip_nl);
+		/*
+		 * Search both active and expired leases. If this exausts all
+		 * IP's in the range pop the expired list (oldest expired lease)
+		 * and use that IP. If the expired list is empty we have reached
+		 * our maximum number of clients.
+		 */
+		lease = find_lease_by_ip(server->lease_list, ip_nl);
+		if (lease)
+			continue;
+
+		lease = find_lease_by_ip(server->expired_list, ip_nl);
 		if (lease)
 			continue;
 
@@ -280,16 +385,10 @@ static uint32_t find_free_or_expired_ip(struct l_dhcp_server *server,
 			return ip_nl;
 	}
 
-	lease = l_queue_peek_tail(server->lease_list);
+	lease = l_queue_pop_head(server->expired_list);
 	if (!lease)
 		return 0;
 
-	if (!is_expired_lease(lease))
-		return 0;
-
-	if (!arp_check(lease->address, safe_mac))
-		return 0;
-
 	return lease->address;
 }
 
@@ -350,8 +449,7 @@ static void send_offer(struct l_dhcp_server *server,
 		return;
 	}
 
-	lease = add_lease(server, l_time_to_secs(l_time_now()) + OFFER_TIME,
-				client_msg->chaddr, reply->yiaddr);
+	lease = add_lease(server, true, client_msg->chaddr, reply->yiaddr);
 	if (!lease) {
 		SERVER_DEBUG("No free IP addresses, OFFER abandoned");
 		return;
@@ -467,7 +565,7 @@ static void send_ack(struct l_dhcp_server *server,
 		return;
 	}
 
-	lease = add_lease(server, 0, reply->chaddr, reply->yiaddr);
+	lease = add_lease(server, false, reply->chaddr, reply->yiaddr);
 
 	if (server->event_handler)
 		server->event_handler(server, L_DHCP_SERVER_EVENT_NEW_LEASE,
@@ -567,8 +665,7 @@ static void listener_event(const void *data, size_t len, void *user_data)
 			break;
 
 		if (message->ciaddr == lease->address)
-			lease_release(server, lease,
-						l_time_to_secs(l_time_now()));
+			lease_release(server, lease);
 
 		break;
 	case DHCP_MESSAGE_TYPE_INFORM:
@@ -599,10 +696,12 @@ LIB_EXPORT struct l_dhcp_server *l_dhcp_server_new(int ifindex)
 		return NULL;
 
 	server->lease_list = l_queue_new();
+	server->expired_list = l_queue_new();
 
 	server->started = false;
 
 	server->lease_seconds = DEFAULT_DHCP_LEASE_SEC;
+	server->max_expired = MAX_EXPIRED_LEASES;
 
 	server->ifindex = ifindex;
 	server->debug_handler = NULL;
@@ -626,6 +725,8 @@ LIB_EXPORT void l_dhcp_server_destroy(struct l_dhcp_server *server)
 
 	l_queue_destroy(server->lease_list,
 				(l_queue_destroy_func_t) _dhcp_lease_free);
+	l_queue_destroy(server->expired_list,
+				(l_queue_destroy_func_t) _dhcp_lease_free);
 
 	if (server->dns_list)
 		l_free(server->dns_list);
Signature · 1 line
2.26.2
#3 lore raw

PATCH v2 4/9 dhcp-server: add private _dhcp_server_get_transport

In reply to James Prestwood

A convenience for unit tests so the server transport doesn't need to be tracked.

---
 ell/dhcp-private.h | 1 +
 ell/dhcp-server.c  | 8 ++++++++
 2 files changed, 9 insertions(+)
ell/dhcp-private.h +1 -0
index 17d0574..11f8220 100644
@@ -144,6 +144,7 @@ void _dhcp_client_override_xid(struct l_dhcp_client *client, uint32_t xid);
 
 bool _dhcp_server_set_transport(struct l_dhcp_server *server,
 					struct dhcp_transport *transport);
+struct dhcp_transport *_dhcp_server_get_transport(struct l_dhcp_server *server);
 
 struct l_dhcp_lease {
 	uint32_t address;
ell/dhcp-server.c +8 -0
index c01aba2..e4d65b8 100644
@@ -689,6 +689,14 @@ bool _dhcp_server_set_transport(struct l_dhcp_server *server,
 	return true;
 }
 
+struct dhcp_transport *_dhcp_server_get_transport(struct l_dhcp_server *server)
+{
+	if (unlikely(!server))
+		return NULL;
+
+	return server->transport;
+}
+
 LIB_EXPORT struct l_dhcp_server *l_dhcp_server_new(int ifindex)
 {
 	struct l_dhcp_server *server = l_new(struct l_dhcp_server, 1);
Signature · 1 line
2.26.2
#4 lore raw

PATCH v2 5/9 dhcp: add private _dhcp_client_get_transport

In reply to James Prestwood

A convenience for unit tests so the client transport doesn't need to be tracked.

---
 ell/dhcp-private.h | 1 +
 ell/dhcp.c         | 9 +++++++++
 2 files changed, 10 insertions(+)
ell/dhcp-private.h +1 -0
index 11f8220..379792c 100644
@@ -140,6 +140,7 @@ int _dhcp_option_append(uint8_t **buf, size_t *buflen, uint8_t code,
 
 bool _dhcp_client_set_transport(struct l_dhcp_client *client,
 					struct dhcp_transport *transport);
+struct dhcp_transport *_dhcp_client_get_transport(struct l_dhcp_client *client);
 void _dhcp_client_override_xid(struct l_dhcp_client *client, uint32_t xid);
 
 bool _dhcp_server_set_transport(struct l_dhcp_server *server,
ell/dhcp.c +9 -0
index dc4e73b..e104845 100644
@@ -1025,6 +1025,15 @@ bool _dhcp_client_set_transport(struct l_dhcp_client *client,
 	return true;
 }
 
+struct dhcp_transport *_dhcp_client_get_transport(struct l_dhcp_client *client)
+{
+	if (unlikely(!client))
+		return NULL;
+
+	return client->transport;
+}
+
+
 void _dhcp_client_override_xid(struct l_dhcp_client *client, uint32_t xid)
 {
 	client->override_xid = true;
Signature · 1 line
2.26.2
#5 lore raw

PATCH v2 6/9 dhcp-server: add private setter for max expired clients

In reply to James Prestwood

Convenience for unit tests so the max expired clients can be set artificially low.

---
 ell/dhcp-private.h |  3 +++
 ell/dhcp-server.c  | 11 +++++++++++
 2 files changed, 14 insertions(+)
ell/dhcp-private.h +3 -0
index 379792c..204e54e 100644
@@ -147,6 +147,9 @@ bool _dhcp_server_set_transport(struct l_dhcp_server *server,
 					struct dhcp_transport *transport);
 struct dhcp_transport *_dhcp_server_get_transport(struct l_dhcp_server *server);
 
+bool _dhcp_server_set_max_expired_clients(struct l_dhcp_server *server,
+						unsigned int max_expired);
+
 struct l_dhcp_lease {
 	uint32_t address;
 	uint32_t server_address;
ell/dhcp-server.c +11 -0
index e4d65b8..78b6b47 100644
@@ -676,6 +676,17 @@ static void listener_event(const void *data, size_t len, void *user_data)
 	}
 }
 
+bool _dhcp_server_set_max_expired_clients(struct l_dhcp_server *server,
+						unsigned int max_expired)
+{
+	if (unlikely(!server))
+		return false;
+
+	server->max_expired = max_expired;
+
+	return true;
+}
+
 bool _dhcp_server_set_transport(struct l_dhcp_server *server,
 					struct dhcp_transport *transport)
 {
Signature · 1 line
2.26.2
#6 lore raw

PATCH v2 7/9 unit: add client expire checks to test-dhcp

In reply to James Prestwood

Verifies the proper events fire when clients release their lease.

---
 unit/test-dhcp.c | 43 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)
unit/test-dhcp.c +42 -1
index 877d649..2f41609 100644
@@ -764,6 +764,24 @@ static void do_debug(const char *str, void *user_data)
 	l_info("%s%s", prefix, str);
 }
 
+static char *new_client;
+static char *expired_client;
+
+static void server_event(struct l_dhcp_server *server,
+					enum l_dhcp_server_event event,
+					void *user_data,
+					const struct l_dhcp_lease *lease)
+{
+	switch (event) {
+	case L_DHCP_SERVER_EVENT_NEW_LEASE:
+		new_client = l_dhcp_lease_get_address(lease);
+		break;
+	case L_DHCP_SERVER_EVENT_LEASE_EXPIRED:
+		expired_client = l_dhcp_lease_get_address(lease);
+		break;
+	}
+}
+
 static void test_complete_run(const void *data)
 {
 	static const uint8_t addr1[6] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
@@ -794,6 +812,8 @@ static void test_complete_run(const void *data)
 	assert(l_dhcp_server_set_netmask(server, "255.255.255.0"));
 	assert(l_dhcp_server_set_gateway(server, "192.168.1.1"));
 	assert(l_dhcp_server_set_dns(server, dns));
+	assert(l_dhcp_server_set_event_handler(server, server_event,
+						NULL, NULL));
 
 	if (verbose)
 		l_dhcp_server_set_debug(server, do_debug, "[DHCP SERV] ", NULL);
@@ -865,6 +885,11 @@ static void test_complete_run(const void *data)
 	cli_addr = l_dhcp_lease_get_address(cli_lease);
 	assert(cli_addr);
 	assert(!strcmp(cli_addr, "192.168.1.2"));
+	assert(new_client);
+	assert(!strcmp(new_client, cli_addr));
+	l_free(new_client);
+	new_client = NULL;
+
 	srv_addr = l_dhcp_lease_get_server_id(cli_lease);
 	assert(!strcmp(srv_addr, "192.168.1.1"));
 	l_free(srv_addr);
@@ -910,14 +935,30 @@ static void test_complete_run(const void *data)
 	cli_addr = l_dhcp_lease_get_address(cli_lease);
 	assert(cli_addr);
 	assert(!strcmp(cli_addr, "192.168.1.3"));
+	assert(new_client);
+	assert(!strcmp(new_client, cli_addr));
+	l_free(new_client);
+	new_client = NULL;
 	srv_addr = l_dhcp_lease_get_server_id(cli_lease);
 	assert(!strcmp(srv_addr, "192.168.1.1"));
 	l_free(srv_addr);
 	l_free(cli_addr);
 
-
 	l_dhcp_client_stop(client1);
+
+	srv_transport->rx_cb(client_packet, client_packet_len, server);
+	assert(expired_client);
+	assert(!strcmp(expired_client, "192.168.1.2"));
+	l_free(expired_client);
+	expired_client = NULL;
+
 	l_dhcp_client_stop(client2);
+	srv_transport->rx_cb(client_packet, client_packet_len, server);
+	assert(expired_client);
+	assert(!strcmp(expired_client, "192.168.1.3"));
+	l_free(expired_client);
+	expired_client = NULL;
+
 	l_dhcp_client_destroy(client1);
 	l_dhcp_client_destroy(client2);
 
Signature · 1 line
2.26.2
#7 lore raw

PATCH v2 8/9 unit: refactor test-dhcp to reuse code for other tests

In reply to James Prestwood

Add client_init, client_connect, and server_init functions to make future tests easier to write.

---
 unit/test-dhcp.c | 166 +++++++++++++++++++++++------------------------
 1 file changed, 81 insertions(+), 85 deletions(-)
unit/test-dhcp.c +81 -85
index 2f41609..1f4bd8b 100644
@@ -782,33 +782,69 @@ static void server_event(struct l_dhcp_server *server,
 	}
 }
 
-static void test_complete_run(const void *data)
+static struct l_dhcp_client *client_init(const uint8_t *mac)
 {
-	static const uint8_t addr1[6] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
-	static const uint8_t addr2[6] = { 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c };
+	struct l_dhcp_client *client = l_dhcp_client_new(42);
+	struct dhcp_transport *transport = l_new(struct dhcp_transport, 1);
 
-	char *dns[] = { "192.168.1.1", "192.168.1.254", NULL };
-	struct l_dhcp_client *client1;
-	struct l_dhcp_client *client2;
-	struct l_dhcp_server *server;
-	struct dhcp_transport *cli_transport1 = l_new(struct dhcp_transport, 1);
-	struct dhcp_transport *cli_transport2 = l_new(struct dhcp_transport, 1);
+	assert(l_dhcp_client_set_address(client, ARPHRD_ETHER, mac, 6));
+	assert(l_dhcp_client_set_interface_name(client, "fake"));
+	assert(l_dhcp_client_set_hostname(client, "<hostname>"));
+	_dhcp_client_override_xid(client, 0x4d7c67c6);
+	assert(l_dhcp_client_set_event_handler(client,
+				event_handler_lease_obtained, NULL, NULL));
 
-	struct dhcp_transport *srv_transport = l_new(struct dhcp_transport, 1);
-	const struct l_dhcp_lease *cli_lease;
-	/* client IP address */
-	char *cli_addr;
-	/* servers IP address */
-	char *srv_addr;
-	char *tmp_addr;
-	char **dns_list;
+	if (verbose)
+		l_dhcp_client_set_debug(client, do_debug, "[DHCP1] ", NULL);
 
-	server = l_dhcp_server_new(41);
+	transport->send = fake_transport_send;
+	transport->l2_send = fake_transport_l2_send;
+	transport->ifindex = 42;
+
+	assert(_dhcp_client_set_transport(client, transport));
+
+	return client;
+}
+
+static bool client_connect(struct l_dhcp_client *client,
+				struct l_dhcp_server *server)
+{
+	struct dhcp_transport *srv_transport =
+					_dhcp_server_get_transport(server);
+	struct dhcp_transport *cli_transport =
+					_dhcp_client_get_transport(client);
+	if (!l_dhcp_client_start(client))
+		return false;
+
+	/* RX DISCOVER */
+	srv_transport->rx_cb(client_packet, client_packet_len, server);
+	assert(l2_send_called);
+	l2_send_called = false;
+
+	/* RX OFFER */
+	cli_transport->rx_cb(server_packet, server_packet_len, client);
+
+	/* RX REQUEST */
+	srv_transport->rx_cb(client_packet, client_packet_len, server);
+	assert(l2_send_called);
+	l2_send_called = false;
+
+	/* RX ACK */
+	cli_transport->rx_cb(server_packet, server_packet_len, client);
+
+	assert(event_handler_called);
+
+	return true;
+}
+
+static struct l_dhcp_server *server_init()
+{
+	char *dns[] = { "192.168.1.1", "192.168.1.254", NULL };
+	struct l_dhcp_server *server = l_dhcp_server_new(41);
+	struct dhcp_transport *srv_transport = l_new(struct dhcp_transport, 1);
 
 	assert(l_dhcp_server_set_interface_name(server, "fake"));
 	assert(l_dhcp_server_set_ip_address(server, "192.168.1.1"));
-	assert(l_dhcp_server_set_ip_range(server, "192.168.1.2",
-						"192.168.1.100"));
 	assert(l_dhcp_server_set_netmask(server, "255.255.255.0"));
 	assert(l_dhcp_server_set_gateway(server, "192.168.1.1"));
 	assert(l_dhcp_server_set_dns(server, dns));
@@ -825,60 +861,37 @@ static void test_complete_run(const void *data)
 
 	assert(l_dhcp_server_start(server));
 
-	client1 = l_dhcp_client_new(42);
-
-	assert(l_dhcp_client_set_address(client1, ARPHRD_ETHER, addr1, 6));
-	assert(l_dhcp_client_set_interface_name(client1, "fake"));
-	assert(l_dhcp_client_set_hostname(client1, "<hostname>"));
-	_dhcp_client_override_xid(client1, 0x4d7c67c6);
-	assert(l_dhcp_client_set_event_handler(client1,
-				event_handler_lease_obtained, NULL, NULL));
-
-	if (verbose)
-		l_dhcp_client_set_debug(client1, do_debug, "[DHCP1] ", NULL);
-
-	cli_transport1->send = fake_transport_send;
-	cli_transport1->l2_send = fake_transport_l2_send;
-	cli_transport1->ifindex = 42;
-
-	assert(_dhcp_client_set_transport(client1, cli_transport1));
-
-	assert(l_dhcp_client_start(client1));
-
-	client2 = l_dhcp_client_new(43);
-	assert(l_dhcp_client_set_address(client2, ARPHRD_ETHER, addr2, 6));
-	assert(l_dhcp_client_set_interface_name(client2, "fake"));
-	assert(l_dhcp_client_set_hostname(client2, "<hostname>"));
-	_dhcp_client_override_xid(client2, 0x5d7c67c6);
-	assert(l_dhcp_client_set_event_handler(client2,
-				event_handler_lease_obtained, NULL, NULL));
+	return server;
+}
 
-	if (verbose)
-		l_dhcp_client_set_debug(client2, do_debug, "[DHCP2] ", NULL);
+static void test_complete_run(const void *data)
+{
+	static const uint8_t addr1[6] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
+	static const uint8_t addr2[6] = { 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c };
+	struct dhcp_transport *srv_transport;
 
-	cli_transport2->send = fake_transport_send;
-	cli_transport2->l2_send = fake_transport_l2_send;
-	cli_transport2->ifindex = 42;
+	struct l_dhcp_client *client1;
+	struct l_dhcp_client *client2;
+	struct l_dhcp_server *server;
 
-	assert(_dhcp_client_set_transport(client2, cli_transport2));
+	const struct l_dhcp_lease *cli_lease;
+	/* client IP address */
+	char *cli_addr;
+	/* servers IP address */
+	char *srv_addr;
+	char *tmp_addr;
+	char **dns_list;
 
-	/* RX DISCOVER */
-	srv_transport->rx_cb(client_packet, client_packet_len, server);
-	assert(l2_send_called);
-	l2_send_called = false;
+	server = server_init();
 
-	/* RX OFFER */
-	cli_transport1->rx_cb(server_packet, server_packet_len, client1);
+	assert(l_dhcp_server_set_ip_range(server, "192.168.1.2",
+						"192.168.1.100"));
 
-	/* RX REQUEST */
-	srv_transport->rx_cb(client_packet, client_packet_len, server);
-	assert(l2_send_called);
-	l2_send_called = false;
+	srv_transport = _dhcp_server_get_transport(server);
 
-	/* RX ACK */
-	cli_transport1->rx_cb(server_packet, server_packet_len, client1);
+	client1 = client_init(addr1);
 
-	assert(event_handler_called);
+	client_connect(client1, server);
 
 	cli_lease = l_dhcp_client_get_lease(client1);
 	assert(cli_lease);
@@ -909,26 +922,9 @@ static void test_complete_run(const void *data)
 	assert(!strcmp(dns_list[1], "192.168.1.254"));
 	l_strv_free(dns_list);
 
-	/* Second client connect */
-	assert(l_dhcp_client_start(client2));
+	client2 = client_init(addr2);
 
-	/* RX DISCOVER */
-	srv_transport->rx_cb(client_packet, client_packet_len, server);
-	assert(l2_send_called);
-	l2_send_called = false;
-
-	/* RX OFFER */
-	cli_transport2->rx_cb(server_packet, server_packet_len, client2);
-
-	/* RX REQUEST */
-	srv_transport->rx_cb(client_packet, client_packet_len, server);
-	assert(l2_send_called);
-	l2_send_called = false;
-
-	/* RX ACK */
-	cli_transport2->rx_cb(server_packet, server_packet_len, client2);
-
-	assert(event_handler_called);
+	client_connect(client2, server);
 
 	cli_lease = l_dhcp_client_get_lease(client2);
 	assert(cli_lease);
Signature · 1 line
2.26.2
#8 lore raw

PATCH v2 9/9 unit: add DHCP expiration reuse test

In reply to James Prestwood

Test that the DHCP server reuses expired IPs once the limit is reached.

---
 unit/test-dhcp.c | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
unit/test-dhcp.c +42 -0
index 1f4bd8b..ad06c14 100644
@@ -962,6 +962,47 @@ static void test_complete_run(const void *data)
 	l_dhcp_server_destroy(server);
 }
 
+static void test_expired_ip_reuse(const void *data)
+{
+	uint8_t addr[6] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x00};
+	struct l_dhcp_server *server = server_init();
+	struct dhcp_transport *srv_transport =
+					_dhcp_server_get_transport(server);
+	struct l_dhcp_client *client_new;
+	const struct l_dhcp_lease *lease;
+	const char *cli_addr;
+	int i;
+
+	l_dhcp_server_set_ip_range(server, "192.168.1.2", "192.168.1.11");
+	_dhcp_server_set_max_expired_clients(server, 10);
+
+	/*
+	 * Connect and release 10 clients, this should max out the expired
+	 * queue (since we are setting it to 10) and force the first client that
+	 * expired to be removed allowing 192.168.1.2 to be reused for a new
+	 * client
+	 */
+	for (i = 0; i < 10; i++) {
+		struct l_dhcp_client *client;
+
+		addr[5] = i;
+		client = client_init(addr);
+		client_connect(client, server);
+
+		l_dhcp_client_stop(client);
+		srv_transport->rx_cb(client_packet, client_packet_len, server);
+	}
+
+	addr[5] = i + 1;
+	client_new = client_init(addr);
+	client_connect(client_new, server);
+
+	lease = l_dhcp_client_get_lease(client_new);
+	assert(lease);
+	cli_addr = l_dhcp_lease_get_address(lease);
+	assert(!strcmp(cli_addr, "192.168.1.2"));
+}
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
@@ -986,6 +1027,7 @@ int main(int argc, char *argv[])
 	l_test_add("discover", test_discover, NULL);
 
 	l_test_add("complete run", test_complete_run, NULL);
+	l_test_add("expired IP reuse", test_expired_ip_reuse, NULL);
 
 	return l_test_run();
 }
Signature · 1 line
2.26.2
#9 lore raw
In reply to James Prestwood

Hi James,

Quoted 11 lines · James Prestwood

RFC 2131 does not explicitly require this but clients MAY release their IP address when they are done using it, e.g. when shutting down. This is also described as a "graceful shutdown" so its probably best the DHCP client does this.

---
  ell/dhcp.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++-------
  1 file changed, 65 insertions(+), 9 deletions(-)

v2:
* Send release in BOUND, RENEW, and REBINDING states

Patch 1-2, 4-5 applied, thanks.

Regards,
-Denis