Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/networking/udhcp/packet.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/networking/udhcp/packet.c (modified) (7 diffs)

branches/2.2.9/mindi-busybox/networking/udhcp/packet.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-
+/*
+ * Packet ops
+ *
+ * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
 #include <netinet/in.h>
 #if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
-#include <netpacket/packet.h>
-#include <net/ethernet.h>
+# include <netpacket/packet.h>
+# include <net/ethernet.h>
 #else
-#include <asm/types.h>
-#include <linux/if_packet.h>
-#include <linux/if_ether.h>
+# include <asm/types.h>
+# include <linux/if_packet.h>
+# include <linux/if_ether.h>
 #endif
 
 #include "common.h"
 #include "dhcpd.h"
-#include "options.h"
-
-
-void udhcp_init_header(struct dhcpMessage *packet, char type)
-{
-    memset(packet, 0, sizeof(struct dhcpMessage));
+
+void FAST_FUNC udhcp_init_header(struct dhcp_packet *packet, char type)
+{
+    memset(packet, 0, sizeof(*packet));
+    packet->op = BOOTREQUEST; /* if client to a server */
     switch (type) {
-    case DHCPDISCOVER:
-    case DHCPREQUEST:
-    case DHCPRELEASE:
-    case DHCPINFORM:
-        packet->op = BOOTREQUEST;
-        break;
     case DHCPOFFER:
     case DHCPACK:
     case DHCPNAK:
-        packet->op = BOOTREPLY;
-    }
-    packet->htype = ETH_10MB;
-    packet->hlen = ETH_10MB_LEN;
+        packet->op = BOOTREPLY; /* if server to client */
+    }
+    packet->htype = 1; /* ethernet */
+    packet->hlen = 6;
     packet->cookie = htonl(DHCP_MAGIC);
-    packet->options[0] = DHCP_END;
-    add_simple_option(packet->options, DHCP_MESSAGE_TYPE, type);
-}
-
-
-/* read a packet from socket fd, return -1 on read error, -2 on packet error */
-int udhcp_get_packet(struct dhcpMessage *packet, int fd)
-{
-#if 0
-    static const char broken_vendors[][8] = {
-        "MSFT 98",
-        ""
-    };
+    if (DHCP_END != 0)
+        packet->options[0] = DHCP_END;
+    udhcp_add_simple_option(packet, DHCP_MESSAGE_TYPE, type);
+}
+
+#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 2
+void FAST_FUNC udhcp_dump_packet(struct dhcp_packet *packet)
+{
+    char buf[sizeof(packet->chaddr)*2 + 1];
+
+    if (dhcp_verbose < 2)
+        return;
+
+    bb_info_msg(
+        //" op %x"
+        //" htype %x"
+        " hlen %x"
+        //" hops %x"
+        " xid %x"
+        //" secs %x"
+        //" flags %x"
+        " ciaddr %x"
+        " yiaddr %x"
+        " siaddr %x"
+        " giaddr %x"
+        //" chaddr %s"
+        //" sname %s"
+        //" file %s"
+        //" cookie %x"
+        //" options %s"
+        //, packet->op
+        //, packet->htype
+        , packet->hlen
+        //, packet->hops
+        , packet->xid
+        //, packet->secs
+        //, packet->flags
+        , packet->ciaddr
+        , packet->yiaddr
+        , packet->siaddr_nip
+        , packet->gateway_nip
+        //, packet->chaddr[16]
+        //, packet->sname[64]
+        //, packet->file[128]
+        //, packet->cookie
+        //, packet->options[]
+    );
+    *bin2hex(buf, (void *) packet->chaddr, sizeof(packet->chaddr)) = '\0';
+    bb_info_msg(" chaddr %s", buf);
+}
 #endif
+
+/* Read a packet from socket fd, return -1 on read error, -2 on packet error */
+int FAST_FUNC udhcp_recv_kernel_packet(struct dhcp_packet *packet, int fd)
+{
     int bytes;
     unsigned char *vendor;
 
     memset(packet, 0, sizeof(*packet));
-    bytes = read(fd, packet, sizeof(*packet));
+    bytes = safe_read(fd, packet, sizeof(*packet));
     if (bytes < 0) {
-        DEBUG("cannot read on listening socket, ignoring");
-        return -1;
-    }
-
-    if (ntohl(packet->cookie) != DHCP_MAGIC) {
-        bb_error_msg("received bogus message, ignoring");
+        log1("Packet read error, ignoring");
+        return bytes; /* returns -1 */
+    }
+
+    if (packet->cookie != htonl(DHCP_MAGIC)) {
+        bb_info_msg("Packet with bad magic, ignoring");
         return -2;
     }
-    DEBUG("Received a packet");
+    log1("Received a packet");
+    udhcp_dump_packet(packet);
 
     if (packet->op == BOOTREQUEST) {
-        vendor = get_option(packet, DHCP_VENDOR);
+        vendor = udhcp_get_option(packet, DHCP_VENDOR);
         if (vendor) {
 #if 0
+            static const char broken_vendors[][8] = {
+                "MSFT 98",
+                ""
+            };
             int i;
             for (i = 0; broken_vendors[i][0]; i++) {
-                if (vendor[OPT_LEN - 2] == (uint8_t)strlen(broken_vendors[i])
-                 && !strncmp((char*)vendor, broken_vendors[i], vendor[OPT_LEN - 2])
+                if (vendor[OPT_LEN - OPT_DATA] == (uint8_t)strlen(broken_vendors[i])
+                 && strncmp((char*)vendor, broken_vendors[i], vendor[OPT_LEN - OPT_DATA]) == 0
                 ) {
-                    DEBUG("broken client (%s), forcing broadcast",
+                    log1("Broken client (%s), forcing broadcast replies",
                         broken_vendors[i]);
                     packet->flags |= htons(BROADCAST_FLAG);
@@ -79 +124 @@
             }
 #else
-            if (vendor[OPT_LEN - 2] == (uint8_t)(sizeof("MSFT 98")-1)
+            if (vendor[OPT_LEN - OPT_DATA] == (uint8_t)(sizeof("MSFT 98")-1)
              && memcmp(vendor, "MSFT 98", sizeof("MSFT 98")-1) == 0
             ) {
-                DEBUG("broken client (%s), forcing broadcast", "MSFT 98");
+                log1("Broken client (%s), forcing broadcast replies", "MSFT 98");
                 packet->flags |= htons(BROADCAST_FLAG);
             }
@@ -92 +137 @@
 }
 
-
-uint16_t udhcp_checksum(void *addr, int count)
+uint16_t FAST_FUNC udhcp_checksum(void *addr, int count)
 {
     /* Compute Internet Checksum for "count" bytes
-     *         beginning at location "addr".
+     * beginning at location "addr".
      */
     int32_t sum = 0;
@@ -112 +156 @@
          * with little and big endian hosts */
         uint16_t tmp = 0;
-        *(uint8_t *) (&tmp) = * (uint8_t *) source;
+        *(uint8_t*)&tmp = *(uint8_t*)source;
         sum += tmp;
     }
@@ -122 +166 @@
 }
 
-
-/* Construct a ip/udp header for a packet, and specify the source and dest hardware address */
-void BUG_sizeof_struct_udp_dhcp_packet_must_be_576(void);
-int udhcp_raw_packet(struct dhcpMessage *payload,
-        uint32_t source_ip, int source_port,
-        uint32_t dest_ip, int dest_port, const uint8_t *dest_arp, int ifindex)
-{
+/* Construct a ip/udp header for a packet, send packet */
+int FAST_FUNC udhcp_send_raw_packet(struct dhcp_packet *dhcp_pkt,
+        uint32_t source_nip, int source_port,
+        uint32_t dest_nip, int dest_port, const uint8_t *dest_arp,
+        int ifindex)
+{
+    struct sockaddr_ll dest_sll;
+    struct ip_udp_dhcp_packet packet;
+    unsigned padding;
     int fd;
-    int result;
-    struct sockaddr_ll dest;
-    struct udp_dhcp_packet packet;
+    int result = -1;
+    const char *msg;
 
     fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
     if (fd < 0) {
-        bb_perror_msg("socket");
-        return -1;
-    }
-
-    memset(&dest, 0, sizeof(dest));
-    memset(&packet, 0, sizeof(packet));
-
-    dest.sll_family = AF_PACKET;
-    dest.sll_protocol = htons(ETH_P_IP);
-    dest.sll_ifindex = ifindex;
-    dest.sll_halen = 6;
-    memcpy(dest.sll_addr, dest_arp, 6);
-    if (bind(fd, (struct sockaddr *)&dest, sizeof(struct sockaddr_ll)) < 0) {
-        bb_perror_msg("bind");
-        close(fd);
-        return -1;
-    }
+        msg = "socket(%s)";
+        goto ret_msg;
+    }
+
+    memset(&dest_sll, 0, sizeof(dest_sll));
+    memset(&packet, 0, offsetof(struct ip_udp_dhcp_packet, data));
+    packet.data = *dhcp_pkt; /* struct copy */
+
+    dest_sll.sll_family = AF_PACKET;
+    dest_sll.sll_protocol = htons(ETH_P_IP);
+    dest_sll.sll_ifindex = ifindex;
+    dest_sll.sll_halen = 6;
+    memcpy(dest_sll.sll_addr, dest_arp, 6);
+
+    if (bind(fd, (struct sockaddr *)&dest_sll, sizeof(dest_sll)) < 0) {
+        msg = "bind(%s)";
+        goto ret_close;
+    }
+
+    /* We were sending full-sized DHCP packets (zero padded),
+     * but some badly configured servers were seen dropping them.
+     * Apparently they drop all DHCP packets >576 *ethernet* octets big,
+     * whereas they may only drop packets >576 *IP* octets big
+     * (which for typical Ethernet II means 590 octets: 6+6+2 + 576).
+     *
+     * In order to work with those buggy servers,
+     * we truncate packets after end option byte.
+     */
+    padding = DHCP_OPTIONS_BUFSIZE - 1 - udhcp_end_option(packet.data.options);
 
     packet.ip.protocol = IPPROTO_UDP;
-    packet.ip.saddr = source_ip;
-    packet.ip.daddr = dest_ip;
+    packet.ip.saddr = source_nip;
+    packet.ip.daddr = dest_nip;
     packet.udp.source = htons(source_port);
     packet.udp.dest = htons(dest_port);
-    packet.udp.len = htons(sizeof(packet.udp) + sizeof(struct dhcpMessage)); /* cheat on the psuedo-header */
+    /* size, excluding IP header: */
+    packet.udp.len = htons(UDP_DHCP_SIZE - padding);
+    /* for UDP checksumming, ip.len is set to UDP packet len */
     packet.ip.tot_len = packet.udp.len;
-    memcpy(&(packet.data), payload, sizeof(struct dhcpMessage));
-    packet.udp.check = udhcp_checksum(&packet, sizeof(struct udp_dhcp_packet));
-
-    packet.ip.tot_len = htons(sizeof(struct udp_dhcp_packet));
+    packet.udp.check = udhcp_checksum(&packet, IP_UDP_DHCP_SIZE - padding);
+    /* but for sending, it is set to IP packet len */
+    packet.ip.tot_len = htons(IP_UDP_DHCP_SIZE - padding);
     packet.ip.ihl = sizeof(packet.ip) >> 2;
     packet.ip.version = IPVERSION;
     packet.ip.ttl = IPDEFTTL;
-    packet.ip.check = udhcp_checksum(&(packet.ip), sizeof(packet.ip));
-
-    if (sizeof(struct udp_dhcp_packet) != 576)
-        BUG_sizeof_struct_udp_dhcp_packet_must_be_576();
-
-    result = sendto(fd, &packet, sizeof(struct udp_dhcp_packet), 0,
-            (struct sockaddr *) &dest, sizeof(dest));
-    if (result <= 0) {
-        bb_perror_msg("sendto");
-    }
+    packet.ip.check = udhcp_checksum(&packet.ip, sizeof(packet.ip));
+
+    udhcp_dump_packet(dhcp_pkt);
+    result = sendto(fd, &packet, IP_UDP_DHCP_SIZE - padding, /*flags:*/ 0,
+            (struct sockaddr *) &dest_sll, sizeof(dest_sll));
+    msg = "sendto";
+ ret_close:
     close(fd);
+    if (result < 0) {
+ ret_msg:
+        bb_perror_msg(msg, "PACKET");
+    }
     return result;
 }
 
-
 /* Let the kernel do all the work for packet generation */
-int udhcp_kernel_packet(struct dhcpMessage *payload,
-        uint32_t source_ip, int source_port,
-        uint32_t dest_ip, int dest_port)
-{
-    int fd, result;
+int FAST_FUNC udhcp_send_kernel_packet(struct dhcp_packet *dhcp_pkt,
+        uint32_t source_nip, int source_port,
+        uint32_t dest_nip, int dest_port)
+{
     struct sockaddr_in client;
+    unsigned padding;
+    int fd;
+    int result = -1;
+    const char *msg;
 
     fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    if (fd < 0)
-        return -1;
-
+    if (fd < 0) {
+        msg = "socket(%s)";
+        goto ret_msg;
+    }
     setsockopt_reuseaddr(fd);
 
@@ -200 +262 @@
     client.sin_family = AF_INET;
     client.sin_port = htons(source_port);
-    client.sin_addr.s_addr = source_ip;
-
+    client.sin_addr.s_addr = source_nip;
     if (bind(fd, (struct sockaddr *)&client, sizeof(client)) == -1) {
-        close(fd);
-        return -1;
+        msg = "bind(%s)";
+        goto ret_close;
     }
 
@@ -210 +271 @@
     client.sin_family = AF_INET;
     client.sin_port = htons(dest_port);
-    client.sin_addr.s_addr = dest_ip;
-
-    if (connect(fd, (struct sockaddr *)&client, sizeof(struct sockaddr)) == -1) {
-        close(fd);
-        return -1;
-    }
-
-    result = write(fd, payload, sizeof(struct dhcpMessage));
+    client.sin_addr.s_addr = dest_nip;
+    if (connect(fd, (struct sockaddr *)&client, sizeof(client)) == -1) {
+        msg = "connect";
+        goto ret_close;
+    }
+
+    udhcp_dump_packet(dhcp_pkt);
+
+    padding = DHCP_OPTIONS_BUFSIZE - 1 - udhcp_end_option(dhcp_pkt->options);
+    result = safe_write(fd, dhcp_pkt, DHCP_SIZE - padding);
+    msg = "write";
+ ret_close:
     close(fd);
+    if (result < 0) {
+ ret_msg:
+        bb_perror_msg(msg, "UDP");
+    }
     return result;
 }