sd-dhcp: add very basic debug logging

[elogind.git] / src / libsystemd-dhcp / sd-dhcp-client.c

diff --git a/src/libsystemd-dhcp/sd-dhcp-client.c b/src/libsystemd-dhcp/sd-dhcp-client.c
index 39c2eebffcdb320104f3026a514fb48f641b51c1..350675530466f2f472bcd2a5ab7b5a986de79e33 100644 (file)
--- a/src/libsystemd-dhcp/sd-dhcp-client.c
+++ b/src/libsystemd-dhcp/sd-dhcp-client.c
@@ -32,8 +32,6 @@
 #include "dhcp-internal.h"
 #include "sd-dhcp-client.h"
 
-#define DHCP_CLIENT_MIN_OPTIONS_SIZE            312
-
 struct sd_dhcp_client {
         DHCPState state;
         sd_event *event;
@@ -197,6 +195,8 @@ static int client_stop(sd_dhcp_client *client, int error) {
         if (client->lease)
                 client->lease = sd_dhcp_lease_unref(client->lease);
 
+        log_dhcp_client(client, "STOPPED");
+
         return 0;
 }
 
@@ -216,7 +216,7 @@ static int client_message_init(sd_dhcp_client *client, DHCPMessage *message,
             client->state == DHCP_STATE_REBINDING)
                 message->ciaddr = client->lease->address;
 
-        /* Some DHCP servers will refuse to issue an DHCP lease if the Cliient
+        /* 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);
@@ -237,7 +237,7 @@ static int client_message_init(sd_dhcp_client *client, DHCPMessage *message,
                    defined default size unless the Maximum Messge Size option
                    is explicitely set */
                 max_size = htobe16(DHCP_IP_UDP_SIZE + DHCP_MESSAGE_SIZE +
-                                   DHCP_CLIENT_MIN_OPTIONS_SIZE);
+                                   DHCP_MIN_OPTIONS_SIZE);
                 r = dhcp_option_append(opt, optlen,
                                        DHCP_OPTION_MAXIMUM_MESSAGE_SIZE,
                                        2, &max_size);
@@ -254,7 +254,7 @@ static int client_send_discover(sd_dhcp_client *client, uint16_t secs) {
         size_t optlen, len;
         uint8_t *opt;
 
-        optlen = DHCP_CLIENT_MIN_OPTIONS_SIZE;
+        optlen = DHCP_MIN_OPTIONS_SIZE;
         len = sizeof(DHCPPacket) + optlen;
 
         discover = malloc0(len);
@@ -284,6 +284,8 @@ static int client_send_discover(sd_dhcp_client *client, uint16_t secs) {
         err = dhcp_network_send_raw_socket(client->fd, &client->link,
                                            discover, len);
 
+        log_dhcp_client(client, "DISCOVER");
+
         return err;
 }
 
@@ -293,7 +295,7 @@ static int client_send_request(sd_dhcp_client *client, uint16_t secs) {
         int err;
         uint8_t *opt;
 
-        optlen = DHCP_CLIENT_MIN_OPTIONS_SIZE;
+        optlen = DHCP_MIN_OPTIONS_SIZE;
         len = DHCP_MESSAGE_SIZE + optlen;
 
         request = malloc0(len);
@@ -326,6 +328,7 @@ static int client_send_request(sd_dhcp_client *client, uint16_t secs) {
         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);
         } else {
@@ -335,6 +338,8 @@ static int client_send_request(sd_dhcp_client *client, uint16_t secs) {
                                                    request, len);
         }
 
+        log_dhcp_client(client, "REQUEST");
+
         return err;
 }
 
@@ -393,10 +398,13 @@ static int client_timeout_resend(sd_event_source *s, uint64_t usec,
 
         next_timeout += (random_u32() & 0x1fffff);
 
-        r = sd_event_add_monotonic(client->event, next_timeout,
+        client->timeout_resend = sd_event_source_unref(client->timeout_resend);
+
+        r = sd_event_add_monotonic(client->event,
+                                     &client->timeout_resend,
+                                     next_timeout,
                                      10 * USEC_PER_MSEC,
-                                     client_timeout_resend, client,
-                                     &client->timeout_resend);
+                                     client_timeout_resend, client);
         if (r < 0)
                 goto error;
 
@@ -466,8 +474,9 @@ static int client_initialize_events(sd_dhcp_client *client,
         assert(client);
         assert(client->event);
 
-        r = sd_event_add_io(client->event, client->fd, EPOLLIN, io_callback,
-                            client, &client->receive_message);
+        r = sd_event_add_io(client->event, &client->receive_message,
+                            client->fd, EPOLLIN, io_callback,
+                            client);
         if (r < 0)
                 goto error;
 
@@ -476,9 +485,12 @@ static int client_initialize_events(sd_dhcp_client *client,
         if (r < 0)
                 goto error;
 
-        r = sd_event_add_monotonic(client->event, usec, 0,
-                                   client_timeout_resend, client,
-                                   &client->timeout_resend);
+        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, client);
         if (r < 0)
                 goto error;
 
@@ -497,6 +509,8 @@ 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);
 
         return 0;
@@ -524,6 +538,8 @@ static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata)
 
         client->fd = r;
 
+        log_dhcp_client(client, "TIMEOUT T2");
+
         return client_initialize_events(client, client_receive_message_raw,
                                         usec);
 }
@@ -537,7 +553,8 @@ static int client_timeout_t1(sd_event_source *s, uint64_t usec,
         client->attempt = 1;
 
         r = dhcp_network_bind_udp_socket(client->index,
-                                         client->lease->address);
+                                         client->lease->address,
+                                         DHCP_PORT_CLIENT);
         if (r < 0) {
                 client_stop(client, r);
                 return 0;
@@ -545,6 +562,8 @@ static int client_timeout_t1(sd_event_source *s, uint64_t usec,
 
         client->fd = r;
 
+        log_dhcp_client(client, "TIMEOUT T1");
+
         return client_initialize_events(client, client_receive_message_udp, usec);
 }
 
@@ -572,6 +591,8 @@ static int client_handle_offer(sd_dhcp_client *client, DHCPMessage *offer,
         client->lease = lease;
         lease = NULL;
 
+        log_dhcp_client(client, "OFFER");
+
         return 0;
 }
 
@@ -585,8 +606,10 @@ static int client_handle_ack(sd_dhcp_client *client, DHCPMessage *ack,
                 return r;
 
         r = dhcp_option_parse(ack, len, dhcp_lease_parse_options, lease);
-        if (r == DHCP_NAK)
+        if (r == DHCP_NAK) {
+                log_dhcp_client(client, "NAK");
                 return DHCP_EVENT_NO_LEASE;
+        }
 
         if (r != DHCP_ACK)
                 return -ENOMSG;
@@ -612,6 +635,8 @@ static int client_handle_ack(sd_dhcp_client *client, DHCPMessage *ack,
         client->lease = lease;
         lease = NULL;
 
+        log_dhcp_client(client, "ACK");
+
         return r;
 }
 
@@ -643,10 +668,11 @@ static int client_set_lease_timeouts(sd_dhcp_client *client, uint64_t usec) {
         if (next_timeout < usec)
                 return -EINVAL;
 
-        r = sd_event_add_monotonic(client->event, next_timeout,
+        r = sd_event_add_monotonic(client->event,
+                                     &client->timeout_t1,
+                                     next_timeout,
                                      10 * USEC_PER_MSEC,
-                                     client_timeout_t1, client,
-                                     &client->timeout_t1);
+                                     client_timeout_t1, client);
         if (r < 0)
                 return r;
 
@@ -669,10 +695,11 @@ static int client_set_lease_timeouts(sd_dhcp_client *client, uint64_t usec) {
         if (next_timeout < usec)
                 return -EINVAL;
 
-        r = sd_event_add_monotonic(client->event, next_timeout,
+        r = sd_event_add_monotonic(client->event,
+                                     &client->timeout_t2,
+                                     next_timeout,
                                      10 * USEC_PER_MSEC,
-                                     client_timeout_t2, client,
-                                     &client->timeout_t2);
+                                     client_timeout_t2, client);
         if (r < 0)
                 return r;
 
@@ -686,10 +713,10 @@ static int client_set_lease_timeouts(sd_dhcp_client *client, uint64_t usec) {
         if (next_timeout < usec)
                 return -EINVAL;
 
-        r = sd_event_add_monotonic(client->event, next_timeout,
+        r = sd_event_add_monotonic(client->event,
+                                     &client->timeout_expire, next_timeout,
                                      10 * USEC_PER_MSEC,
-                                     client_timeout_expire, client,
-                                     &client->timeout_expire);
+                                     client_timeout_expire, client);
         if (r < 0)
                 return r;
 
@@ -710,11 +737,11 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message,
         assert(message);
 
         if (be32toh(message->xid) != client->xid)
-                return -EINVAL;
+                return 0;
 
         if (memcmp(&message->chaddr[0], &client->mac_addr.ether_addr_octet,
                    ETHER_ADDR_LEN))
-                return -EINVAL;
+                return 0;
 
         switch (client->state) {
         case DHCP_STATE_SELECTING:
@@ -728,10 +755,11 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message,
                         client->state = DHCP_STATE_REQUESTING;
                         client->attempt = 1;
 
-                        r = sd_event_add_monotonic(client->event, time_now, 0,
+                        r = sd_event_add_monotonic(client->event,
+                                                   &client->timeout_resend,
+                                                   time_now, 0,
                                                    client_timeout_resend,
-                                                   client,
-                                                   &client->timeout_resend);
+                                                   client);
                         if (r < 0)
                                 goto error;
 
@@ -798,10 +826,10 @@ error:
         return 0;
 }
 
-static int client_receive_message_raw(sd_event_source *s, int fd,
+static int client_receive_message_udp(sd_event_source *s, int fd,
                                       uint32_t revents, void *userdata) {
         sd_dhcp_client *client = userdata;
-        uint8_t buf[sizeof(DHCPMessage) + DHCP_CLIENT_MIN_OPTIONS_SIZE];
+        uint8_t buf[sizeof(DHCPMessage) + DHCP_MIN_OPTIONS_SIZE];
         int buflen = sizeof(buf);
         int len, r = 0;
         usec_t time_now;
@@ -822,10 +850,10 @@ static int client_receive_message_raw(sd_event_source *s, int fd,
                                      time_now);
 }
 
-static int client_receive_message_udp(sd_event_source *s, int fd,
+static int client_receive_message_raw(sd_event_source *s, int fd,
                                       uint32_t revents, void *userdata) {
         sd_dhcp_client *client = userdata;
-        uint8_t buf[sizeof(DHCPPacket) + DHCP_CLIENT_MIN_OPTIONS_SIZE];
+        uint8_t buf[sizeof(DHCPPacket) + DHCP_MIN_OPTIONS_SIZE];
         int buflen = sizeof(buf);
         int len, r = 0;
         DHCPPacket *packet;
@@ -842,8 +870,10 @@ static int client_receive_message_udp(sd_event_source *s, int fd,
         packet = (DHCPPacket *) buf;
 
         r = dhcp_packet_verify_headers(packet, BOOTREPLY, len);
-        if (r < 0)
-                return r;
+        if (r < 0) {
+                log_dhcp_client(client, "ignoring DHCP packet with invalid headers");
+                return 0;
+        }
 
         len -= DHCP_IP_UDP_SIZE;
 
@@ -876,7 +906,9 @@ int sd_dhcp_client_start(sd_dhcp_client *client) {
         client->start_time = now(CLOCK_MONOTONIC);
         client->secs = 0;
 
-        return client_initialize_events(client, client_receive_message_udp,
+        log_dhcp_client(client, "STARTED");
+
+        return client_initialize_events(client, client_receive_message_raw,
                                         client->start_time);
 }