size_t req_opts_allocated;
size_t req_opts_size;
be32_t last_addr;
- struct ether_addr mac_addr;
+ struct {
+ uint8_t type;
+ struct ether_addr mac_addr;
+ } _packed_ client_id;
uint32_t xid;
usec_t start_time;
uint16_t secs;
addr->ether_addr_octet[4],
addr->ether_addr_octet[5]);
- memcpy(&client->mac_addr, addr, ETH_ALEN);
+ memcpy(&client->client_id.mac_addr, addr, ETH_ALEN);
+ client->client_id.type = 0x01;
return 0;
}
return 0;
}
-static int client_stop(sd_dhcp_client *client, int error) {
+static int client_initialize(sd_dhcp_client *client) {
assert_return(client, -EINVAL);
client->receive_message =
sd_event_source_unref(client->receive_message);
- if (client->fd >= 0)
- close(client->fd);
- client->fd = -1;
+ client->fd = safe_close(client->fd);
client->timeout_resend = sd_event_source_unref(client->timeout_resend);
client->attempt = 1;
- client_notify(client, error);
-
client->start_time = 0;
client->secs = 0;
client->state = DHCP_STATE_INIT;
+ client->xid = 0;
if (client->lease)
client->lease = sd_dhcp_lease_unref(client->lease);
+ return 0;
+}
+
+static int client_stop(sd_dhcp_client *client, int error) {
+ assert_return(client, -EINVAL);
+
+ client_notify(client, error);
+
+ client_initialize(client);
+
log_dhcp_client(client, "STOPPED");
return 0;
}
static int client_message_init(sd_dhcp_client *client, DHCPMessage *message,
- uint8_t type, uint16_t secs, uint8_t **opt,
- size_t *optlen) {
+ uint8_t type, uint8_t **opt, size_t *optlen) {
int r;
- assert(secs);
+ assert(client);
+ assert(client->secs);
+ assert(message);
+ assert(opt);
+ assert(optlen);
r = dhcp_message_init(message, BOOTREQUEST, client->xid, type, opt,
optlen);
/* Although 'secs' field is a SHOULD in RFC 2131, certain DHCP servers
refuse to issue an DHCP lease if 'secs' is set to zero */
- message->secs = htobe16(secs);
+ message->secs = htobe16(client->secs);
- memcpy(&message->chaddr, &client->mac_addr, ETH_ALEN);
+ memcpy(&message->chaddr, &client->client_id.mac_addr, ETH_ALEN);
if (client->state == DHCP_STATE_RENEWING ||
client->state == DHCP_STATE_REBINDING)
/* Some DHCP servers will refuse to issue an DHCP lease if the Client
Identifier option is not set */
r = dhcp_option_append(opt, optlen, DHCP_OPTION_CLIENT_IDENTIFIER,
- ETH_ALEN, &client->mac_addr);
+ sizeof(client->client_id), &client->client_id);
if (r < 0)
return r;
return 0;
}
-static int client_send_discover(sd_dhcp_client *client, uint16_t secs) {
- int err = 0;
+static int dhcp_client_send_raw(sd_dhcp_client *client, DHCPPacket *packet,
+ size_t len) {
+ dhcp_packet_append_ip_headers(packet, INADDR_ANY, DHCP_PORT_CLIENT,
+ INADDR_BROADCAST, DHCP_PORT_SERVER, len);
+
+ return dhcp_network_send_raw_socket(client->fd, &client->link,
+ packet, len);
+}
+
+static int client_send_discover(sd_dhcp_client *client) {
_cleanup_free_ DHCPPacket *discover;
size_t optlen, len;
uint8_t *opt;
+ usec_t time_now;
+ int r;
+
+ assert(client);
+
+ r = sd_event_get_now_monotonic(client->event, &time_now);
+ if (r < 0)
+ return r;
+ assert(time_now >= client->start_time);
+
+ /* seconds between sending first and last DISCOVER
+ * must always be strictly positive to deal with broken servers */
+ client->secs = ((time_now - client->start_time) / USEC_PER_SEC) ? : 1;
optlen = DHCP_MIN_OPTIONS_SIZE;
len = sizeof(DHCPPacket) + optlen;
discover = malloc0(len);
-
if (!discover)
return -ENOMEM;
- err = client_message_init(client, &discover->dhcp, DHCP_DISCOVER,
- secs, &opt, &optlen);
- if (err < 0)
- return err;
+ r = client_message_init(client, &discover->dhcp, DHCP_DISCOVER,
+ &opt, &optlen);
+ if (r < 0)
+ return r;
if (client->last_addr != INADDR_ANY) {
- err = dhcp_option_append(&opt, &optlen,
+ r = dhcp_option_append(&opt, &optlen,
DHCP_OPTION_REQUESTED_IP_ADDRESS,
4, &client->last_addr);
- if (err < 0)
- return err;
+ if (r < 0)
+ return r;
}
- err = dhcp_option_append(&opt, &optlen, DHCP_OPTION_END, 0, NULL);
- if (err < 0)
- return err;
-
- dhcp_packet_append_ip_headers(discover, len);
+ r = dhcp_option_append(&opt, &optlen, DHCP_OPTION_END, 0, NULL);
+ if (r < 0)
+ return r;
- err = dhcp_network_send_raw_socket(client->fd, &client->link,
- discover, len);
+ r = dhcp_client_send_raw(client, discover, len - optlen);
+ if (r < 0)
+ return r;
log_dhcp_client(client, "DISCOVER");
- return err;
+ return 0;
}
-static int client_send_request(sd_dhcp_client *client, uint16_t secs) {
+static int client_send_request(sd_dhcp_client *client) {
_cleanup_free_ DHCPPacket *request;
size_t optlen, len;
- int err;
uint8_t *opt;
+ int r;
optlen = DHCP_MIN_OPTIONS_SIZE;
len = sizeof(DHCPPacket) + optlen;
if (!request)
return -ENOMEM;
- err = client_message_init(client, &request->dhcp, DHCP_REQUEST, secs,
- &opt, &optlen);
- if (err < 0)
- return err;
+ r = client_message_init(client, &request->dhcp, DHCP_REQUEST, &opt,
+ &optlen);
+ if (r < 0)
+ return r;
+
+ switch (client->state) {
- if (client->state == DHCP_STATE_REQUESTING) {
- err = dhcp_option_append(&opt, &optlen,
+ case DHCP_STATE_INIT_REBOOT:
+ r = dhcp_option_append(&opt, &optlen,
DHCP_OPTION_REQUESTED_IP_ADDRESS,
- 4, &client->lease->address);
- if (err < 0)
- return err;
-
- err = dhcp_option_append(&opt, &optlen,
- DHCP_OPTION_SERVER_IDENTIFIER,
- 4, &client->lease->server_address);
- if (err < 0)
- return err;
+ 4, &client->last_addr);
+ if (r < 0)
+ return r;
+ break;
+
+ case DHCP_STATE_REQUESTING:
+ r = dhcp_option_append(&opt, &optlen,
+ DHCP_OPTION_REQUESTED_IP_ADDRESS,
+ 4, &client->lease->address);
+ if (r < 0)
+ return r;
+
+ r = dhcp_option_append(&opt, &optlen,
+ DHCP_OPTION_SERVER_IDENTIFIER,
+ 4, &client->lease->server_address);
+ if (r < 0)
+ return r;
+ break;
+
+ case DHCP_STATE_INIT:
+ case DHCP_STATE_SELECTING:
+ case DHCP_STATE_REBOOTING:
+ case DHCP_STATE_BOUND:
+ case DHCP_STATE_RENEWING:
+ case DHCP_STATE_REBINDING:
+
+ break;
}
- err = dhcp_option_append(&opt, &optlen, DHCP_OPTION_END, 0, NULL);
- if (err < 0)
- return err;
+ r = dhcp_option_append(&opt, &optlen, DHCP_OPTION_END, 0, NULL);
+ if (r < 0)
+ return r;
if (client->state == DHCP_STATE_RENEWING) {
- err = dhcp_network_send_udp_socket(client->fd,
- client->lease->server_address,
- DHCP_PORT_SERVER,
- &request->dhcp,
- len - DHCP_IP_UDP_SIZE);
+ r = dhcp_network_send_udp_socket(client->fd,
+ client->lease->server_address,
+ DHCP_PORT_SERVER,
+ &request->dhcp,
+ len - optlen - DHCP_IP_UDP_SIZE);
} else {
- dhcp_packet_append_ip_headers(request, len);
-
- err = dhcp_network_send_raw_socket(client->fd, &client->link,
- request, len);
+ r = dhcp_client_send_raw(client, request, len - optlen);
}
+ if (r < 0)
+ return r;
log_dhcp_client(client, "REQUEST");
- return err;
-}
-
-static uint16_t client_update_secs(sd_dhcp_client *client, usec_t time_now)
-{
- client->secs = ((time_now - client->start_time) / USEC_PER_SEC) ? : 1;
-
- return client->secs;
+ return 0;
}
static int client_timeout_resend(sd_event_source *s, uint64_t usec,
void *userdata) {
sd_dhcp_client *client = userdata;
usec_t next_timeout = 0;
+ uint64_t time_now;
uint32_t time_left;
- int r = 0;
+ int r;
assert(s);
assert(client);
assert(client->event);
+ r = sd_event_get_now_monotonic(client->event, &time_now);
+ if (r < 0)
+ goto error;
+
switch (client->state) {
case DHCP_STATE_RENEWING:
if (time_left < 60)
time_left = 60;
- next_timeout = usec + time_left * USEC_PER_SEC;
+ next_timeout = time_now + time_left * USEC_PER_SEC;
break;
if (time_left < 60)
time_left = 60;
- next_timeout = usec + time_left * USEC_PER_SEC;
+ next_timeout = time_now + time_left * USEC_PER_SEC;
break;
+ case DHCP_STATE_REBOOTING:
+ /* start over as we did not receive a timely ack or nak */
+ client->state = DHCP_STATE_INIT;
+ client->attempt = 1;
+ client->xid = random_u32();
+
+ /* fall through */
case DHCP_STATE_INIT:
case DHCP_STATE_INIT_REBOOT:
- case DHCP_STATE_REBOOTING:
case DHCP_STATE_SELECTING:
case DHCP_STATE_REQUESTING:
case DHCP_STATE_BOUND:
if (client->attempt < 64)
client->attempt *= 2;
- next_timeout = usec + (client->attempt - 1) * USEC_PER_SEC;
+ next_timeout = time_now + (client->attempt - 1) * USEC_PER_SEC;
break;
}
switch (client->state) {
case DHCP_STATE_INIT:
-
- client_update_secs(client, usec);
-
- r = client_send_discover(client, client->secs);
+ r = client_send_discover(client);
if (r >= 0) {
client->state = DHCP_STATE_SELECTING;
client->attempt = 1;
break;
case DHCP_STATE_SELECTING:
- client_update_secs(client, usec);
-
- r = client_send_discover(client, client->secs);
+ r = client_send_discover(client);
if (r < 0 && client->attempt >= 64)
goto error;
break;
+ case DHCP_STATE_INIT_REBOOT:
case DHCP_STATE_REQUESTING:
case DHCP_STATE_RENEWING:
case DHCP_STATE_REBINDING:
- r = client_send_request(client, client->secs);
+ r = client_send_request(client);
if (r < 0 && client->attempt >= 64)
goto error;
- client->request_sent = usec;
+ if (client->state == DHCP_STATE_INIT_REBOOT)
+ client->state = DHCP_STATE_REBOOTING;
+
+ client->request_sent = time_now;
break;
- case DHCP_STATE_INIT_REBOOT:
case DHCP_STATE_REBOOTING:
case DHCP_STATE_BOUND:
}
static int client_initialize_events(sd_dhcp_client *client,
- sd_event_io_handler_t io_callback,
- usec_t usec) {
+ sd_event_io_handler_t io_callback) {
int r;
assert(client);
client->timeout_resend = sd_event_source_unref(client->timeout_resend);
r = sd_event_add_monotonic(client->event,
- &client->timeout_resend,
- usec, 0,
+ &client->timeout_resend, 0, 0,
client_timeout_resend, client);
if (r < 0)
goto error;
}
+static int client_start(sd_dhcp_client *client) {
+ int r;
+
+ assert_return(client, -EINVAL);
+ assert_return(client->event, -EINVAL);
+ assert_return(client->index > 0, -EINVAL);
+ assert_return(client->fd < 0, -EBUSY);
+ assert_return(client->xid == 0, -EINVAL);
+ assert_return(client->state == DHCP_STATE_INIT ||
+ client->state == DHCP_STATE_INIT_REBOOT, -EBUSY);
+
+ client->xid = random_u32();
+
+ r = dhcp_network_bind_raw_socket(client->index, &client->link);
+
+ if (r < 0) {
+ client_stop(client, r);
+ return r;
+ }
+
+ client->fd = r;
+ client->start_time = now(CLOCK_MONOTONIC);
+ client->secs = 0;
+
+ log_dhcp_client(client, "STARTED");
+
+ return client_initialize_events(client, client_receive_message_raw);
+}
+
static int client_timeout_expire(sd_event_source *s, uint64_t usec,
void *userdata) {
sd_dhcp_client *client = userdata;
log_dhcp_client(client, "EXPIRED");
- client_stop(client, DHCP_EVENT_EXPIRED);
+ client_notify(client, DHCP_EVENT_EXPIRED);
+
+ /* start over as the lease was lost */
+ client_initialize(client);
+ client_start(client);
return 0;
}
sd_dhcp_client *client = userdata;
int r;
- if (client->fd >= 0) {
- client->receive_message =
- sd_event_source_unref(client->receive_message);
- close(client->fd);
- client->fd = -1;
- }
+ client->receive_message = sd_event_source_unref(client->receive_message);
+ client->fd = safe_close(client->fd);
client->state = DHCP_STATE_REBINDING;
client->attempt = 1;
log_dhcp_client(client, "TIMEOUT T2");
- return client_initialize_events(client, client_receive_message_raw,
- usec);
+ return client_initialize_events(client, client_receive_message_raw);
}
static int client_timeout_t1(sd_event_source *s, uint64_t usec,
log_dhcp_client(client, "TIMEOUT T1");
- return client_initialize_events(client, client_receive_message_udp, usec);
+ return client_initialize_events(client, client_receive_message_udp);
}
static int client_handle_offer(sd_dhcp_client *client, DHCPMessage *offer,
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;
return -EINVAL;
r = sd_event_add_monotonic(client->event,
- &client->timeout_t1,
- next_timeout,
- 10 * USEC_PER_MSEC,
- client_timeout_t1, client);
+ &client->timeout_t1,
+ next_timeout,
+ 10 * USEC_PER_MSEC,
+ client_timeout_t1, client);
if (r < 0)
return r;
return -EINVAL;
r = sd_event_add_monotonic(client->event,
- &client->timeout_t2,
- next_timeout,
- 10 * USEC_PER_MSEC,
- client_timeout_t2, client);
+ &client->timeout_t2,
+ next_timeout,
+ 10 * USEC_PER_MSEC,
+ client_timeout_t2, client);
if (r < 0)
return r;
return -EINVAL;
r = sd_event_add_monotonic(client->event,
- &client->timeout_expire, next_timeout,
- 10 * USEC_PER_MSEC,
- client_timeout_expire, client);
+ &client->timeout_expire, next_timeout,
+ 10 * USEC_PER_MSEC,
+ client_timeout_expire, client);
if (r < 0)
return r;
return 0;
}
- if (memcmp(&message->chaddr[0], &client->mac_addr.ether_addr_octet,
- ETHER_ADDR_LEN)) {
+ if (memcmp(&message->chaddr[0], &client->client_id.mac_addr,
+ ETH_ALEN)) {
log_dhcp_client(client, "received chaddr does not match "
"expected: ignoring");
return 0;
client->attempt = 1;
r = sd_event_add_monotonic(client->event,
- &client->timeout_resend,
- time_now, 0,
- client_timeout_resend,
+ &client->timeout_resend, 0,
+ 0, client_timeout_resend,
client);
if (r < 0)
goto error;
break;
+ case DHCP_STATE_REBOOTING:
case DHCP_STATE_REQUESTING:
case DHCP_STATE_RENEWING:
case DHCP_STATE_REBINDING:
r = client_handle_ack(client, message, len);
- if (r == DHCP_EVENT_NO_LEASE)
+ if (r == DHCP_EVENT_NO_LEASE) {
+
+ client->timeout_resend =
+ sd_event_source_unref(client->timeout_resend);
+
+ if (client->state == DHCP_STATE_REBOOTING) {
+ r = client_initialize(client);
+ if (r < 0)
+ goto error;
+
+ r = client_start(client);
+ if (r < 0)
+ goto error;
+ }
+
goto error;
+ }
if (r >= 0) {
client->timeout_resend =
sd_event_source_unref(client->timeout_resend);
- if (client->state == DHCP_STATE_REQUESTING)
+ if (IN_SET(client->state, DHCP_STATE_REQUESTING,
+ DHCP_STATE_REBOOTING))
notify_event = DHCP_EVENT_IP_ACQUIRE;
else if (r != DHCP_EVENT_IP_ACQUIRE)
notify_event = r;
client->receive_message =
sd_event_source_unref(client->receive_message);
- close(client->fd);
- client->fd = -1;
+ client->fd = safe_close(client->fd);
}
r = 0;
case DHCP_STATE_INIT:
case DHCP_STATE_INIT_REBOOT:
- case DHCP_STATE_REBOOTING:
case DHCP_STATE_BOUND:
break;
int r;
assert_return(client, -EINVAL);
- assert_return(client->event, -EINVAL);
- assert_return(client->index > 0, -EINVAL);
- assert_return(client->state == DHCP_STATE_INIT ||
- client->state == DHCP_STATE_INIT_REBOOT, -EBUSY);
-
- client->xid = random_u32();
-
- r = dhcp_network_bind_raw_socket(client->index, &client->link);
- if (r < 0) {
- client_stop(client, r);
+ r = client_initialize(client);
+ if (r < 0)
return r;
- }
- client->fd = r;
- client->start_time = now(CLOCK_MONOTONIC);
- client->secs = 0;
-
- log_dhcp_client(client, "STARTED");
+ if (client->last_addr)
+ client->state = DHCP_STATE_INIT_REBOOT;
- return client_initialize_events(client, client_receive_message_raw,
- client->start_time);
+ return client_start(client);
}
int sd_dhcp_client_stop(sd_dhcp_client *client) {