From 87322b3aee0dc649ff1ae7a403dcc9d7305baba2 Mon Sep 17 00:00:00 2001 From: Tom Gundersen Date: Sun, 25 May 2014 22:07:53 +0200 Subject: sd-dhcp-server: track bound leases Make sure we don't hand out the same IP twice. We still don't handle lease expiry. --- src/libsystemd-network/sd-dhcp-server.c | 136 +++++++++++++++++++++++++++++--- 1 file changed, 127 insertions(+), 9 deletions(-) (limited to 'src/libsystemd-network/sd-dhcp-server.c') diff --git a/src/libsystemd-network/sd-dhcp-server.c b/src/libsystemd-network/sd-dhcp-server.c index 4c43eeb3fb..4a06833875 100644 --- a/src/libsystemd-network/sd-dhcp-server.c +++ b/src/libsystemd-network/sd-dhcp-server.c @@ -23,6 +23,8 @@ #include #include +#include "siphash24.h" + #include "sd-dhcp-server.h" #include "dhcp-server-internal.h" #include "dhcp-internal.h" @@ -37,6 +39,11 @@ int sd_dhcp_server_set_lease_pool(sd_dhcp_server *server, struct in_addr *addres assert_return(size, -EINVAL); assert_return(server->pool_start == htobe32(INADDR_ANY), -EBUSY); assert_return(!server->pool_size, -EBUSY); + assert_return(!server->bound_leases, -EBUSY); + + server->bound_leases = new0(DHCPLease*, size); + if (!server->bound_leases) + return -ENOMEM; server->pool_start = address->s_addr; server->pool_size = size; @@ -62,13 +69,63 @@ sd_dhcp_server *sd_dhcp_server_ref(sd_dhcp_server *server) { return server; } +unsigned long client_id_hash_func(const void *p, const uint8_t hash_key[HASH_KEY_SIZE]) { + uint64_t u; + const DHCPClientId *id = p; + + assert(id); + assert(id->length); + assert(id->data); + + siphash24((uint8_t*) &u, id->data, id->length, hash_key); + + return (unsigned long) u; +} + +int client_id_compare_func(const void *_a, const void *_b) { + const DHCPClientId *a, *b; + + a = _a; + b = _b; + + assert(!a->length || a->data); + assert(!b->length || b->data); + + if (a->length != b->length) + return a->length < b->length ? -1 : 1; + + return memcmp(a->data, b->data, a->length); +} + +static void dhcp_lease_free(DHCPLease *lease) { + if (!lease) + return; + + free(lease->client_id.data); + free(lease); +} + +DEFINE_TRIVIAL_CLEANUP_FUNC(DHCPLease*, dhcp_lease_free); +#define _cleanup_dhcp_lease_free_ _cleanup_(dhcp_lease_freep) + sd_dhcp_server *sd_dhcp_server_unref(sd_dhcp_server *server) { if (server && REFCNT_DEC(server->n_ref) <= 0) { + DHCPLease *lease; + Iterator i; + log_dhcp_server(server, "UNREF"); sd_dhcp_server_stop(server); sd_event_unref(server->event); + + HASHMAP_FOREACH(lease, server->leases_by_client_id, i) { + hashmap_remove(server->leases_by_client_id, lease); + dhcp_lease_free(lease); + } + + hashmap_free(server->leases_by_client_id); + free(server->bound_leases); free(server); } @@ -90,6 +147,7 @@ int sd_dhcp_server_new(sd_dhcp_server **ret, int ifindex) { server->fd = -1; server->address = htobe32(INADDR_ANY); server->index = ifindex; + server->leases_by_client_id = hashmap_new(client_id_hash_func, client_id_compare_func); *ret = server; server = NULL; @@ -478,9 +536,24 @@ static int ensure_sane_request(DHCPRequest *req, DHCPMessage *message) { return 0; } +static int get_pool_offset(sd_dhcp_server *server, be32_t requested_ip) { + assert(server); + + if (!server->pool_size) + return -EINVAL; + + if (be32toh(requested_ip) < be32toh(server->pool_start) || + be32toh(requested_ip) >= be32toh(server->pool_start) + + + server->pool_size) + return -EINVAL; + + return be32toh(requested_ip) - be32toh(server->pool_start); +} + int dhcp_server_handle_message(sd_dhcp_server *server, DHCPMessage *message, size_t length) { _cleanup_dhcp_request_free_ DHCPRequest *req = NULL; + DHCPLease *existing_lease; int type, r; assert(server); @@ -504,10 +577,13 @@ int dhcp_server_handle_message(sd_dhcp_server *server, DHCPMessage *message, /* this only fails on critical errors */ return r; + existing_lease = hashmap_get(server->leases_by_client_id, &req->client_id); + switch(type) { case DHCP_DISCOVER: { - be32_t address; + be32_t address = INADDR_ANY; + unsigned i; log_dhcp_server(server, "DISCOVER (0x%x)", be32toh(req->message->xid)); @@ -516,9 +592,22 @@ int dhcp_server_handle_message(sd_dhcp_server *server, DHCPMessage *message, /* no pool allocated */ return 0; - /* for now pick a random address from the pool */ - address = htobe32(be32toh(server->pool_start) + - (random_u32() % server->pool_size)); + /* for now pick a random free address from the pool */ + if (existing_lease) + address = existing_lease->address; + else { + for (i = 0; i < server->pool_size; i++) { + if (!server->bound_leases[server->next_offer]) { + address = htobe32(be32toh(server->pool_start) + server->next_offer); + break; + } else + server->next_offer = (server->next_offer + 1) % server->pool_size; + } + } + + if (address == INADDR_ANY) + /* no free addresses left */ + return 0; r = server_send_offer(server, req, address); if (r < 0) { @@ -538,6 +627,7 @@ int dhcp_server_handle_message(sd_dhcp_server *server, DHCPMessage *message, { be32_t address; bool init_reboot = false; + int pool_offset; /* see RFC 2131, section 4.3.2 */ @@ -584,20 +674,48 @@ int dhcp_server_handle_message(sd_dhcp_server *server, DHCPMessage *message, address = req->message->ciaddr; } - /* for now we just verify that the address is from the pool, not - whether or not it is taken */ - if (htobe32(req->requested_ip) >= htobe32(server->pool_start) && - htobe32(req->requested_ip) < htobe32(server->pool_start) + - + server->pool_size) { + pool_offset = get_pool_offset(server, address); + + /* verify that the requested address is from the pool, and either + owned by the current client or free */ + if (pool_offset >= 0 && + server->bound_leases[pool_offset] == existing_lease) { + DHCPLease *lease; + usec_t time_now; + + if (!existing_lease) { + lease = new0(DHCPLease, 1); + lease->address = req->requested_ip; + lease->client_id.data = memdup(req->client_id.data, + req->client_id.length); + if (!lease->client_id.data) + return -ENOMEM; + lease->client_id.length = req->client_id.length; + } else + lease = existing_lease; + + r = sd_event_now(server->event, CLOCK_MONOTONIC, &time_now); + if (r < 0) + time_now = now(CLOCK_MONOTONIC); + lease->expiration = req->lifetime * USEC_PER_SEC + time_now; + r = server_send_ack(server, req, address); if (r < 0) { /* this only fails on critical errors */ log_dhcp_server(server, "could not send ack: %s", strerror(-r)); + + if (!existing_lease) + dhcp_lease_free(lease); + return r; } else { log_dhcp_server(server, "ACK (0x%x)", be32toh(req->message->xid)); + + server->bound_leases[pool_offset] = lease; + hashmap_put(server->leases_by_client_id, &lease->client_id, lease); + return DHCP_ACK; } } else if (init_reboot) { -- cgit v1.2.3-54-g00ecf