chiark / gitweb /
sd-dhcp-client: recevie_message - verify cmsg_len before reading
[elogind.git] / src / libsystemd-network / sd-dhcp-client.c
index 59cd30c..392e294 100644 (file)
@@ -22,6 +22,7 @@
 #include <string.h>
 #include <stdio.h>
 #include <net/ethernet.h>
+#include <net/if_arp.h>
 #include <sys/param.h>
 #include <sys/ioctl.h>
 
@@ -143,21 +144,27 @@ int sd_dhcp_client_set_index(sd_dhcp_client *client, int interface_index) {
 
 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);
 
-        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 (memcmp(&client->client_id.mac_addr, addr, ETH_ALEN) == 0)
+                return 0;
+
+        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;
 }
 
@@ -286,7 +293,7 @@ static int dhcp_client_send_raw(sd_dhcp_client *client, DHCPPacket *packet,
 }
 
 static int client_send_discover(sd_dhcp_client *client) {
-        _cleanup_free_ DHCPPacket *discover;
+        _cleanup_free_ DHCPPacket *discover = NULL;
         size_t optlen, len;
         uint8_t *opt;
         usec_t time_now;
@@ -294,7 +301,7 @@ static int client_send_discover(sd_dhcp_client *client) {
 
         assert(client);
 
-        r = sd_event_get_now_monotonic(client->event, &time_now);
+        r = sd_event_now(client->event, CLOCK_MONOTONIC, &time_now);
         if (r < 0)
                 return r;
         assert(time_now >= client->start_time);
@@ -421,7 +428,7 @@ static int client_timeout_resend(sd_event_source *s, uint64_t usec,
         assert(client);
         assert(client->event);
 
-        r = sd_event_get_now_monotonic(client->event, &time_now);
+        r = sd_event_now(client->event, CLOCK_MONOTONIC, &time_now);
         if (r < 0)
                 goto error;
 
@@ -470,11 +477,11 @@ static int client_timeout_resend(sd_event_source *s, uint64_t usec,
 
         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);
+        r = sd_event_add_time(client->event,
+                              &client->timeout_resend,
+                              CLOCK_MONOTONIC,
+                              next_timeout, 10 * USEC_PER_MSEC,
+                              client_timeout_resend, client);
         if (r < 0)
                 goto error;
 
@@ -554,9 +561,11 @@ static int client_initialize_events(sd_dhcp_client *client,
 
         client->timeout_resend = sd_event_source_unref(client->timeout_resend);
 
-        r = sd_event_add_monotonic(client->event,
-                                   &client->timeout_resend, 0, 0,
-                                   client_timeout_resend, client);
+        r = sd_event_add_time(client->event,
+                              &client->timeout_resend,
+                              CLOCK_MONOTONIC,
+                              0, 0,
+                              client_timeout_resend, client);
         if (r < 0)
                 goto error;
 
@@ -584,7 +593,7 @@ static int client_start(sd_dhcp_client *client) {
 
         client->xid = random_u32();
 
-        r = dhcp_network_bind_raw_socket(client->index, &client->link);
+        r = dhcp_network_bind_raw_socket(client->index, &client->link, client->xid);
 
         if (r < 0) {
                 client_stop(client, r);
@@ -627,7 +636,7 @@ static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata)
         client->state = DHCP_STATE_REBINDING;
         client->attempt = 1;
 
-        r = dhcp_network_bind_raw_socket(client->index, &client->link);
+        r = dhcp_network_bind_raw_socket(client->index, &client->link, client->xid);
         if (r < 0) {
                 client_stop(client, r);
                 return 0;
@@ -800,7 +809,7 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
         if (client->lease->lifetime == 0xffffffff)
                 return 0;
 
-        r = sd_event_get_now_monotonic(client->event, &time_now);
+        r = sd_event_now(client->event, CLOCK_MONOTONIC, &time_now);
         if (r < 0)
                 return r;
         assert(client->request_sent <= time_now);
@@ -850,10 +859,10 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
         }
 
         /* arm lifetime timeout */
-        r = sd_event_add_monotonic(client->event,
-                                   &client->timeout_expire, lifetime_timeout,
-                                   10 * USEC_PER_MSEC,
-                                   client_timeout_expire, client);
+        r = sd_event_add_time(client->event, &client->timeout_expire,
+                              CLOCK_MONOTONIC,
+                              lifetime_timeout, 10 * USEC_PER_MSEC,
+                              client_timeout_expire, client);
         if (r < 0)
                 return r;
 
@@ -871,11 +880,12 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
                 return 0;
 
         /* arm T2 timeout */
-        r = sd_event_add_monotonic(client->event,
-                                   &client->timeout_t2,
-                                   t2_timeout,
-                                   10 * USEC_PER_MSEC,
-                                   client_timeout_t2, client);
+        r = sd_event_add_time(client->event,
+                              &client->timeout_t2,
+                              CLOCK_MONOTONIC,
+                              t2_timeout,
+                              10 * USEC_PER_MSEC,
+                              client_timeout_t2, client);
         if (r < 0)
                 return r;
 
@@ -893,11 +903,11 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
                 return 0;
 
         /* arm T1 timeout */
-        r = sd_event_add_monotonic(client->event,
-                                   &client->timeout_t1,
-                                   t1_timeout,
-                                   10 * USEC_PER_MSEC,
-                                   client_timeout_t1, client);
+        r = sd_event_add_time(client->event,
+                              &client->timeout_t1,
+                              CLOCK_MONOTONIC,
+                              t1_timeout, 10 * USEC_PER_MSEC,
+                              client_timeout_t1, client);
         if (r < 0)
                 return r;
 
@@ -921,9 +931,8 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message,
         assert(client->event);
         assert(message);
 
-        if (len < DHCP_MESSAGE_SIZE) {
-                log_dhcp_client(client, "message too small (%d bytes): "
-                                "ignoring", len);
+        if (be32toh(message->magic) != DHCP_MAGIC_COOKIE) {
+                log_dhcp_client(client, "not a DHCP message: ignoring");
                 return 0;
         }
 
@@ -939,6 +948,11 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message,
                 return 0;
         }
 
+        if (message->htype != ARPHRD_ETHER || message->hlen != ETHER_ADDR_LEN) {
+                log_dhcp_client(client, "not an ethernet packet");
+                return 0;
+        }
+
         if (memcmp(&message->chaddr[0], &client->client_id.mac_addr,
                    ETH_ALEN)) {
                 log_dhcp_client(client, "received chaddr does not match "
@@ -958,10 +972,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,
-                                                   &client->timeout_resend, 0,
-                                                   0, client_timeout_resend,
-                                                   client);
+                        r = sd_event_add_time(client->event,
+                                              &client->timeout_resend,
+                                              CLOCK_MONOTONIC,
+                                              0, 0,
+                                              client_timeout_resend, client);
                         if (r < 0)
                                 goto error;
 
@@ -1060,7 +1075,11 @@ static int client_receive_message_udp(sd_event_source *s, int fd,
                 return -ENOMEM;
 
         len = read(fd, message, buflen);
-        if (len < 0)
+        if (len < 0) {
+                log_dhcp_client(client, "could not receive message from UDP "
+                                "socket: %s", strerror(errno));
+                return 0;
+        } else if ((size_t)len < sizeof(DHCPMessage))
                 return 0;
 
         return client_handle_message(client, message, len);
@@ -1101,11 +1120,14 @@ static int client_receive_message_raw(sd_event_source *s, int fd,
                 log_dhcp_client(client, "could not receive message from raw "
                                 "socket: %s", strerror(errno));
                 return 0;
-        }
+        } else if ((size_t)len < sizeof(DHCPPacket))
+                return 0;
 
         for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
-                if (cmsg->cmsg_level == SOL_PACKET && cmsg->cmsg_type == PACKET_AUXDATA) {
-                        struct tpacket_auxdata *aux = (void *)CMSG_DATA(cmsg);
+                if (cmsg->cmsg_level == SOL_PACKET &&
+                    cmsg->cmsg_type == PACKET_AUXDATA &&
+                    cmsg->cmsg_len == CMSG_LEN(sizeof(struct tpacket_auxdata))) {
+                        struct tpacket_auxdata *aux = (struct tpacket_auxdata*)CMSG_DATA(cmsg);
 
                         checksum = !(aux->tp_status & TP_STATUS_CSUMNOTREADY);
                         break;