int sd_dhcp_client_set_mac(sd_dhcp_client *client,
const struct ether_addr *addr) {
+ bool need_restart = false;
+
assert_return(client, -EINVAL);
- assert_return(client->state == DHCP_STATE_INIT, -EBUSY);
+ assert_return(addr, -EINVAL);
+
+ if (memcmp(&client->client_id.mac_addr, addr, ETH_ALEN) == 0)
+ return 0;
- log_dhcp_client(client, "set MAC address to "
- "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
- addr->ether_addr_octet[0],
- addr->ether_addr_octet[1],
- addr->ether_addr_octet[2],
- addr->ether_addr_octet[3],
- addr->ether_addr_octet[4],
- addr->ether_addr_octet[5]);
+ if (client->state != DHCP_STATE_INIT) {
+ log_dhcp_client(client, "Changing MAC address on running DHCP "
+ "client, restarting");
+ sd_dhcp_client_stop(client);
+ need_restart = true;
+ }
memcpy(&client->client_id.mac_addr, addr, ETH_ALEN);
client->client_id.type = 0x01;
+ if (need_restart)
+ sd_dhcp_client_start(client);
+
return 0;
}
client->attempt = 1;
- client->start_time = 0;
- client->secs = 0;
client->state = DHCP_STATE_INIT;
client->xid = 0;
client_stop(client, r);
return r;
}
-
client->fd = r;
- client->start_time = now(CLOCK_MONOTONIC);
- client->secs = 0;
+
+ if (client->state == DHCP_STATE_INIT) {
+ client->start_time = now(CLOCK_MONOTONIC);
+ client->secs = 0;
+ }
log_dhcp_client(client, "STARTED");
return r;
r = dhcp_option_parse(offer, len, dhcp_lease_parse_options, lease);
- if (r != DHCP_OFFER)
+ if (r != DHCP_OFFER) {
+ log_dhcp_client(client, "receieved message was not an OFFER, ignoring");
return -ENOMSG;
+ }
lease->next_server = offer->siaddr;
if (lease->address == INADDR_ANY ||
lease->server_address == INADDR_ANY ||
- lease->subnet_mask == INADDR_ANY ||
- lease->lifetime == 0)
+ lease->lifetime == 0) {
+ log_dhcp_client(client, "receieved lease lacks address, server "
+ "address or lease lifetime, ignoring");
return -ENOMSG;
+ }
+
+ if (lease->subnet_mask == INADDR_ANY) {
+ r = dhcp_lease_set_default_subnet_mask(lease);
+ if (r < 0) {
+ log_dhcp_client(client, "receieved lease lacks subnet "
+ "mask, and a fallback one can not be "
+ "generated, ignoring");
+ return -ENOMSG;
+ }
+ }
client->lease = lease;
lease = NULL;
return DHCP_EVENT_NO_LEASE;
}
- if (r != DHCP_ACK)
+ if (r != DHCP_ACK) {
+ log_dhcp_client(client, "receieved message was not an ACK, ignoring");
return -ENOMSG;
+ }
lease->next_server = ack->siaddr;
if (lease->address == INADDR_ANY ||
lease->server_address == INADDR_ANY ||
- lease->subnet_mask == INADDR_ANY || lease->lifetime == 0)
+ lease->lifetime == 0) {
+ log_dhcp_client(client, "receieved lease lacks address, server "
+ "address or lease lifetime, ignoring");
return -ENOMSG;
+ }
+
+ if (lease->subnet_mask == INADDR_ANY) {
+ r = dhcp_lease_set_default_subnet_mask(lease);
+ if (r < 0) {
+ log_dhcp_client(client, "receieved lease lacks subnet "
+ "mask, and a fallback one can not be "
+ "generated, ignoring");
+ return -ENOMSG;
+ }
+ }
r = DHCP_EVENT_IP_ACQUIRE;
if (client->lease) {
return r;
}
-static uint64_t client_compute_timeout(uint64_t request_sent,
- uint32_t lifetime) {
- return request_sent + (lifetime - 3) * USEC_PER_SEC +
+static uint64_t client_compute_timeout(sd_dhcp_client *client,
+ uint32_t lifetime, double factor) {
+ assert(client);
+ assert(client->request_sent);
+ assert(lifetime);
+
+ return client->request_sent + ((lifetime - 3) * USEC_PER_SEC * factor) +
+ (random_u32() & 0x1fffff);
}
-static int client_set_lease_timeouts(sd_dhcp_client *client, uint64_t usec) {
- uint64_t next_timeout;
+static int client_set_lease_timeouts(sd_dhcp_client *client) {
+ usec_t time_now;
+ uint64_t lifetime_timeout;
+ uint64_t t2_timeout;
+ uint64_t t1_timeout;
+ char time_string[FORMAT_TIMESPAN_MAX];
int r;
assert(client);
assert(client->event);
-
- /* don't set timers for infinite leases */
- if (client->lease->lifetime == 0xffffffff)
- return 0;
-
- if (client->lease->lifetime < 10)
- return -EINVAL;
+ assert(client->lease);
+ assert(client->lease->lifetime);
client->timeout_t1 = sd_event_source_unref(client->timeout_t1);
client->timeout_t2 = sd_event_source_unref(client->timeout_t2);
client->timeout_expire = sd_event_source_unref(client->timeout_expire);
- if (!client->lease->t1)
- client->lease->t1 = client->lease->lifetime / 2;
+ /* don't set timers for infinite leases */
+ if (client->lease->lifetime == 0xffffffff)
+ return 0;
- next_timeout = client_compute_timeout(client->request_sent,
- client->lease->t1);
- if (next_timeout < usec)
- return -EINVAL;
+ r = sd_event_get_now_monotonic(client->event, &time_now);
+ if (r < 0)
+ return r;
+ assert(client->request_sent <= time_now);
+
+ /* convert the various timeouts from relative (secs) to absolute (usecs) */
+ lifetime_timeout = client_compute_timeout(client, client->lease->lifetime, 1);
+ if (client->lease->t1 && client->lease->t2) {
+ /* both T1 and T2 are given */
+ if (client->lease->t1 < client->lease->t2 &&
+ client->lease->t2 < client->lease->lifetime) {
+ /* they are both valid */
+ t2_timeout = client_compute_timeout(client, client->lease->t2, 1);
+ t1_timeout = client_compute_timeout(client, client->lease->t1, 1);
+ } else {
+ /* discard both */
+ t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
+ client->lease->t2 = (client->lease->lifetime * 7) / 8;
+ t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
+ client->lease->t1 = client->lease->lifetime / 2;
+ }
+ } else if (client->lease->t2 && client->lease->t2 < client->lease->lifetime) {
+ /* only T2 is given, and it is valid */
+ t2_timeout = client_compute_timeout(client, client->lease->t2, 1);
+ t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
+ client->lease->t1 = client->lease->lifetime / 2;
+ if (t2_timeout <= t1_timeout) {
+ /* the computed T1 would be invalid, so discard T2 */
+ t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
+ client->lease->t2 = (client->lease->lifetime * 7) / 8;
+ }
+ } else if (client->lease->t1 && client->lease->t1 < client->lease->lifetime) {
+ /* only T1 is given, and it is valid */
+ t1_timeout = client_compute_timeout(client, client->lease->t1, 1);
+ t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
+ client->lease->t2 = (client->lease->lifetime * 7) / 8;
+ if (t2_timeout <= t1_timeout) {
+ /* the computed T2 would be invalid, so discard T1 */
+ t2_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
+ client->lease->t2 = client->lease->lifetime / 2;
+ }
+ } else {
+ /* fall back to the default timeouts */
+ t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
+ client->lease->t1 = client->lease->lifetime / 2;
+ t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
+ client->lease->t2 = (client->lease->lifetime * 7) / 8;
+ }
+ /* arm lifetime timeout */
r = sd_event_add_monotonic(client->event,
- &client->timeout_t1,
- next_timeout,
+ &client->timeout_expire, lifetime_timeout,
10 * USEC_PER_MSEC,
- client_timeout_t1, client);
+ client_timeout_expire, client);
if (r < 0)
return r;
- r = sd_event_source_set_priority(client->timeout_t1,
+ r = sd_event_source_set_priority(client->timeout_expire,
client->event_priority);
if (r < 0)
return r;
- if (!client->lease->t2)
- client->lease->t2 = client->lease->lifetime * 7 / 8;
+ log_dhcp_client(client, "lease expires in %s",
+ format_timespan(time_string, FORMAT_TIMESPAN_MAX,
+ lifetime_timeout - time_now, 0));
- if (client->lease->t2 < client->lease->t1)
- return -EINVAL;
-
- if (client->lease->lifetime < client->lease->t2)
- return -EINVAL;
-
- next_timeout = client_compute_timeout(client->request_sent,
- client->lease->t2);
- if (next_timeout < usec)
- return -EINVAL;
+ /* don't arm earlier timeouts if this has already expired */
+ if (lifetime_timeout <= time_now)
+ return 0;
+ /* arm T2 timeout */
r = sd_event_add_monotonic(client->event,
&client->timeout_t2,
- next_timeout,
+ t2_timeout,
10 * USEC_PER_MSEC,
client_timeout_t2, client);
if (r < 0)
if (r < 0)
return r;
- next_timeout = client_compute_timeout(client->request_sent,
- client->lease->lifetime);
- if (next_timeout < usec)
- return -EINVAL;
+ log_dhcp_client(client, "T2 expires in %s",
+ format_timespan(time_string, FORMAT_TIMESPAN_MAX,
+ t2_timeout - time_now, 0));
+ /* don't arm earlier timeout if this has already expired */
+ if (t2_timeout <= time_now)
+ return 0;
+
+ /* arm T1 timeout */
r = sd_event_add_monotonic(client->event,
- &client->timeout_expire, next_timeout,
+ &client->timeout_t1,
+ t1_timeout,
10 * USEC_PER_MSEC,
- client_timeout_expire, client);
+ client_timeout_t1, client);
if (r < 0)
return r;
- r = sd_event_source_set_priority(client->timeout_expire,
+ r = sd_event_source_set_priority(client->timeout_t1,
client->event_priority);
if (r < 0)
return r;
+ log_dhcp_client(client, "T1 expires in %s",
+ format_timespan(time_string, FORMAT_TIMESPAN_MAX,
+ t1_timeout - time_now, 0));
+
return 0;
}
static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message,
- int len, usec_t time_now) {
+ int len) {
int r = 0, notify_event = 0;
assert(client);
client->event_priority);
if (r < 0)
goto error;
- }
+ } else if (r == -ENOMSG)
+ /* invalid message, let's ignore it */
+ return 0;
break;
case DHCP_STATE_REBINDING:
r = client_handle_ack(client, message, len);
-
if (r == DHCP_EVENT_NO_LEASE) {
client->timeout_resend =
}
goto error;
- }
-
- if (r >= 0) {
+ } else if (r >= 0) {
client->timeout_resend =
sd_event_source_unref(client->timeout_resend);
client->last_addr = client->lease->address;
- r = client_set_lease_timeouts(client, time_now);
+ r = client_set_lease_timeouts(client);
if (r < 0)
goto error;
client->receive_message =
sd_event_source_unref(client->receive_message);
client->fd = safe_close(client->fd);
- }
-
- r = 0;
+ } else if (r == -ENOMSG)
+ /* invalid message, let's ignore it */
+ return 0;
break;
sd_dhcp_client *client = userdata;
_cleanup_free_ DHCPMessage *message = NULL;
int buflen = 0, len, r;
- usec_t time_now;
assert(s);
assert(client);
- assert(client->event);
r = ioctl(fd, FIONREAD, &buflen);
if (r < 0 || buflen <= 0)
if (len < 0)
return 0;
- r = sd_event_get_now_monotonic(client->event, &time_now);
- if (r < 0)
- return client_stop(client, r);
-
- return client_handle_message(client, message, len,
- time_now);
+ return client_handle_message(client, message, len);
}
static int client_receive_message_raw(sd_event_source *s, int fd,
uint32_t revents, void *userdata) {
sd_dhcp_client *client = userdata;
_cleanup_free_ DHCPPacket *packet = NULL;
- usec_t time_now;
uint8_t cmsgbuf[CMSG_LEN(sizeof(struct tpacket_auxdata))];
struct iovec iov = {};
struct msghdr msg = {
assert(s);
assert(client);
- assert(client->event);
r = ioctl(fd, FIONREAD, &buflen);
if (r < 0 || buflen <= 0)
len -= DHCP_IP_UDP_SIZE;
- r = sd_event_get_now_monotonic(client->event, &time_now);
- if (r < 0)
- return client_stop(client, r);
-
- return client_handle_message(client, &packet->dhcp, len, time_now);
+ return client_handle_message(client, &packet->dhcp, len);
}
int sd_dhcp_client_start(sd_dhcp_client *client) {
~ianmdlvl / elogind.git / blobdiff