Add SPDX license identifiers to source files under the LGPL

[thirdparty/systemd.git] / src / libsystemd-network / dhcp-packet.c

diff --git a/src/libsystemd-network/dhcp-packet.c b/src/libsystemd-network/dhcp-packet.c
index 3e2fb96c27f3054633dc7430381a40f3deb22303..1c4ab5d52fcf0796d535db092f19d6ef70039877 100644 (file)
--- a/src/libsystemd-network/dhcp-packet.c
+++ b/src/libsystemd-network/dhcp-packet.c
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
 /***
   This file is part of systemd.
 
@@ -18,40 +19,33 @@
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 
-#include <stdlib.h>
 #include <errno.h>
-#include <string.h>
-#include <stdio.h>
 #include <net/ethernet.h>
 #include <net/if_arp.h>
-#include <sys/param.h>
-
-#include "util.h"
-#include "list.h"
+#include <string.h>
 
-#include "dhcp-protocol.h"
-#include "dhcp-lease-internal.h"
 #include "dhcp-internal.h"
-#include "sd-dhcp-lease.h"
-#include "sd-dhcp-client.h"
+#include "dhcp-protocol.h"
 
 #define DHCP_CLIENT_MIN_OPTIONS_SIZE            312
 
 int dhcp_message_init(DHCPMessage *message, uint8_t op, uint32_t xid,
-                      uint8_t type, size_t optlen, size_t *optoffset) {
+                      uint8_t type, uint16_t arp_type, size_t optlen,
+                      size_t *optoffset) {
         size_t offset = 0;
         int r;
 
-        assert(op == BOOTREQUEST || op == BOOTREPLY);
+        assert(IN_SET(op, BOOTREQUEST, BOOTREPLY));
+        assert(IN_SET(arp_type, ARPHRD_ETHER, ARPHRD_INFINIBAND));
 
         message->op = op;
-        message->htype = ARPHRD_ETHER;
-        message->hlen = ETHER_ADDR_LEN;
+        message->htype = arp_type;
+        message->hlen = (arp_type == ARPHRD_ETHER) ? ETHER_ADDR_LEN : 0;
         message->xid = htobe32(xid);
         message->magic = htobe32(DHCP_MAGIC_COOKIE);
 
         r = dhcp_option_append(message, optlen, &offset, 0,
-                               DHCP_OPTION_MESSAGE_TYPE, 1, &type);
+                               SD_DHCP_OPTION_MESSAGE_TYPE, 1, &type);
         if (r < 0)
                 return r;
 
@@ -60,47 +54,32 @@ int dhcp_message_init(DHCPMessage *message, uint8_t op, uint32_t xid,
         return 0;
 }
 
-uint16_t dhcp_packet_checksum(void *buf, size_t len) {
-        uint64_t *buf_64 = buf;
-        uint64_t *end_64 = (uint64_t*)buf + (len / sizeof(uint64_t));
-        uint32_t *buf_32;
-        uint16_t *buf_16;
-        uint8_t *buf_8;
+uint16_t dhcp_packet_checksum(uint8_t *buf, size_t len) {
+        uint64_t *buf_64 = (uint64_t*)buf;
+        uint64_t *end_64 = buf_64 + (len / sizeof(uint64_t));
         uint64_t sum = 0;
 
+        /* See RFC1071 */
+
         while (buf_64 < end_64) {
                 sum += *buf_64;
                 if (sum < *buf_64)
+                        /* wrap around in one's complement */
                         sum++;
 
-                buf_64 ++;
-        }
-
-        buf_32 = (uint32_t*)buf_64;
-
-        if (len & sizeof(uint32_t)) {
-                sum += *buf_32;
-                if (sum < *buf_32)
-                        sum++;
-
-                buf_32 ++;
+                buf_64++;
         }
 
-        buf_16 = (uint16_t*)buf_32;
-
-        if (len & sizeof(uint16_t)) {
-                sum += *buf_16;
-                if (sum < *buf_16)
-                        sum ++;
-
-                buf_16 ++;
-        }
+        if (len % sizeof(uint64_t)) {
+                /* If the buffer is not aligned to 64-bit, we need
+                   to zero-pad the last few bytes and add them in */
+                uint64_t buf_tail = 0;
 
-        buf_8 = (uint8_t*)buf_16;
+                memcpy(&buf_tail, buf_64, len % sizeof(uint64_t));
 
-        if (len & sizeof(uint8_t)) {
-                sum += *buf_8;
-                if (sum < *buf_8)
+                sum += buf_tail;
+                if (sum < buf_tail)
+                        /* wrap around */
                         sum++;
         }
 
@@ -129,14 +108,14 @@ void dhcp_packet_append_ip_headers(DHCPPacket *packet, be32_t source_addr,
         packet->udp.len = htobe16(len - DHCP_IP_SIZE);
 
         packet->ip.check = packet->udp.len;
-        packet->udp.check = dhcp_packet_checksum(&packet->ip.ttl, len - 8);
+        packet->udp.check = dhcp_packet_checksum((uint8_t*)&packet->ip.ttl, len - 8);
 
         packet->ip.ttl = IPDEFTTL;
         packet->ip.check = 0;
-        packet->ip.check = dhcp_packet_checksum(&packet->ip, DHCP_IP_SIZE);
+        packet->ip.check = dhcp_packet_checksum((uint8_t*)&packet->ip, DHCP_IP_SIZE);
 }
 
-int dhcp_packet_verify_headers(DHCPPacket *packet, size_t len, bool checksum) {
+int dhcp_packet_verify_headers(DHCPPacket *packet, size_t len, bool checksum, uint16_t port) {
         size_t hdrlen;
 
         assert(packet);
@@ -182,10 +161,10 @@ int dhcp_packet_verify_headers(DHCPPacket *packet, size_t len, bool checksum) {
                 return -EINVAL;
         }
 
-        if (be16toh(packet->udp.dest) != DHCP_PORT_CLIENT) {
+        if (be16toh(packet->udp.dest) != port) {
                 log_debug("ignoring packet: to port %u, which "
                           "is not the DHCP client port (%u)",
-                          be16toh(packet->udp.dest), DHCP_PORT_CLIENT);
+                          be16toh(packet->udp.dest), port);
                 return -EINVAL;
         }
 
@@ -193,7 +172,7 @@ int dhcp_packet_verify_headers(DHCPPacket *packet, size_t len, bool checksum) {
            if all the other checks have passed
          */
 
-        if (dhcp_packet_checksum(&packet->ip, hdrlen)) {
+        if (dhcp_packet_checksum((uint8_t*)&packet->ip, hdrlen)) {
                 log_debug("ignoring packet: invalid IP checksum");
                 return -EINVAL;
         }
@@ -202,7 +181,7 @@ int dhcp_packet_verify_headers(DHCPPacket *packet, size_t len, bool checksum) {
                 packet->ip.check = packet->udp.len;
                 packet->ip.ttl = 0;
 
-                if (dhcp_packet_checksum(&packet->ip.ttl,
+                if (dhcp_packet_checksum((uint8_t*)&packet->ip.ttl,
                                   be16toh(packet->udp.len) + 12)) {
                         log_debug("ignoring packet: invalid UDP checksum");
                         return -EINVAL;