1 files changed, 183 insertions, 86 deletions

diff --git a/release/src/router/busybox/networking/udhcp/packet.c b/release/src/router/busybox/networking/udhcp/packet.c
index 0f2a3bc6..33320238 100644
--- a/release/src/router/busybox/networking/udhcp/packet.c
+++ b/release/src/router/busybox/networking/udhcp/packet.c
@@ -1,10 +1,13 @@
-#include <unistd.h>
-#include <string.h>
+/* vi: set sw=4 ts=4: */
+/*
+ * packet.c -- packet ops
+ * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
+ *
+ * Licensed under GPLv2, see file LICENSE in this tarball for details.
+ */
+
 #include <netinet/in.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <features.h>
-#if __GLIBC__ >=2 && __GLIBC_MINOR >= 1
+#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
 #include <netpacket/packet.h>
 #include <net/ethernet.h>
 #else
@@ -12,27 +15,22 @@
 #include <linux/if_packet.h>
 #include <linux/if_ether.h>
 #endif
-#include <errno.h>
 
+#include "common.h"
 #include "dhcpd.h"
 #include "options.h"
-#include "common.h"
 
+int minpkt = 0;	// zzz
 
-void init_header(struct dhcpMessage *packet, char type)
+void FAST_FUNC udhcp_init_header(struct dhcpMessage *packet, char type)
 {
 	memset(packet, 0, sizeof(struct dhcpMessage));
+	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->op = BOOTREPLY; /* if server to client */
 	}
 	packet->htype = ETH_10MB;
 	packet->hlen = ETH_10MB_LEN;
@@ -43,52 +41,64 @@ void init_header(struct dhcpMessage *packet, char type)
 
 
 /* read a packet from socket fd, return -1 on read error, -2 on packet error */
-int get_packet(struct dhcpMessage *packet, int fd)
+int FAST_FUNC udhcp_recv_kernel_packet(struct dhcpMessage *packet, int fd)
 {
 	int bytes;
-	int i;
-	const char broken_vendors[][8] = {
-		"MSFT 98",
-		""
-	};
-	char unsigned *vendor;
+	unsigned char *vendor;
 
-	memset(packet, 0, sizeof(struct dhcpMessage));
-	bytes = read(fd, packet, sizeof(struct dhcpMessage));
+	memset(packet, 0, sizeof(*packet));
+	bytes = safe_read(fd, packet, sizeof(*packet));
 	if (bytes < 0) {
-		DEBUG(LOG_INFO, "couldn't read on listening socket, ignoring");
-		return -1;
+		DEBUG("cannot read on listening socket, ignoring");
+		return bytes; /* returns -1 */
 	}
 
-	if (ntohl(packet->cookie) != DHCP_MAGIC) {
-		LOG(LOG_ERR, "received bogus message, ignoring");
+	if (packet->cookie != htonl(DHCP_MAGIC)) {
+		bb_error_msg("received bogus message, ignoring");
 		return -2;
 	}
-	DEBUG(LOG_INFO, "Received a packet");
-	
-	if (packet->op == BOOTREQUEST && (vendor = get_option(packet, DHCP_VENDOR))) {
-		for (i = 0; broken_vendors[i][0]; i++) {
-			if (vendor[OPT_LEN - 2] == (unsigned char) strlen(broken_vendors[i]) &&
-			    !strncmp(vendor, broken_vendors[i], vendor[OPT_LEN - 2])) {
-			    	DEBUG(LOG_INFO, "broken client (%s), forcing broadcast",
-			    		broken_vendors[i]);
-			    	packet->flags |= htons(BROADCAST_FLAG);
+	DEBUG("Received a packet");
+
+	if (packet->op == BOOTREQUEST) {
+		vendor = 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])
+				) {
+					DEBUG("broken client (%s), forcing broadcast replies",
+						broken_vendors[i]);
+					packet->flags |= htons(BROADCAST_FLAG);
+				}
 			}
+#else
+			if (vendor[OPT_LEN - 2] == (uint8_t)(sizeof("MSFT 98")-1)
+			 && memcmp(vendor, "MSFT 98", sizeof("MSFT 98")-1) == 0
+			) {
+				DEBUG("broken client (%s), forcing broadcast replies", "MSFT 98");
+				packet->flags |= htons(BROADCAST_FLAG);
+			}
+#endif
 		}
 	}
-			    	
 
 	return bytes;
 }
 
 
-u_int16_t 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".
 	 */
-	register int32_t sum = 0;
-	u_int16_t *source = (u_int16_t *) addr;
+	int32_t sum = 0;
+	uint16_t *source = (uint16_t *) addr;
 
 	while (count > 1)  {
 		/*  This is the inner loop */
@@ -100,8 +110,8 @@ u_int16_t checksum(void *addr, int count)
 	if (count > 0) {
 		/* Make sure that the left-over byte is added correctly both
 		 * with little and big endian hosts */
-		u_int16_t tmp = 0;
-		*(unsigned char *) (&tmp) = * (unsigned char *) source;
+		uint16_t tmp = 0;
+		*(uint8_t*)&tmp = *(uint8_t*)source;
 		sum += tmp;
 	}
 	/*  Fold 32-bit sum to 16 bits */
@@ -112,90 +122,177 @@ u_int16_t checksum(void *addr, int count)
 }
 
 
-/* Constuct a ip/udp header for a packet, and specify the source and dest hardware address */
-int raw_packet(struct dhcpMessage *payload, u_int32_t source_ip, int source_port,
-		   u_int32_t dest_ip, int dest_port, unsigned char *dest_arp, int ifindex)
+/* Construct a ip/udp header for a packet, send packet */
+int FAST_FUNC udhcp_send_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)
 {
-	int fd;
-	int result;
 	struct sockaddr_ll dest;
 	struct udp_dhcp_packet packet;
+	int fd;
+	int result = -1;
+	const char *msg;
+
+	enum {
+		IP_UPD_DHCP_SIZE = sizeof(struct udp_dhcp_packet) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS,
+		UPD_DHCP_SIZE    = IP_UPD_DHCP_SIZE - offsetof(struct udp_dhcp_packet, udp),
+	};
 
-	if ((fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) {
-		DEBUG(LOG_ERR, "socket call failed: %m");
-		return -1;
+	fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
+	if (fd < 0) {
+		msg = "socket(%s)";
+		goto ret_msg;
 	}
-	
+
 	memset(&dest, 0, sizeof(dest));
 	memset(&packet, 0, sizeof(packet));
-	
+	packet.data = *payload; /* struct copy */
+
 	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) {
-		DEBUG(LOG_ERR, "bind call failed: %m");
-		close(fd);
-		return -1;
+	if (bind(fd, (struct sockaddr *)&dest, sizeof(dest)) < 0) {
+		msg = "bind(%s)";
+		goto ret_close;
 	}
 
+#if 1	// zzz
+	int n;
+
+	// n = size of dhcp only
+	if (minpkt) n = (end_option(payload->options) + 1 + sizeof(*payload) - sizeof(payload->options));
+		else n = sizeof(struct dhcpMessage) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS;
+		
 	packet.ip.protocol = IPPROTO_UDP;
 	packet.ip.saddr = source_ip;
 	packet.ip.daddr = dest_ip;
 	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(sizeof(packet.udp) + n);	// udp + dhcp
+
+	n += sizeof(packet) - sizeof(packet.data);		// n = ip + udp + dhcp
+
+	/* 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 = checksum(&packet, sizeof(struct udp_dhcp_packet));
-	
-	packet.ip.tot_len = htons(sizeof(struct udp_dhcp_packet));
+	packet.udp.check = udhcp_checksum(&packet, n);
+	/* but for sending, it is set to IP packet len */
+	packet.ip.tot_len = htons(n);	
 	packet.ip.ihl = sizeof(packet.ip) >> 2;
 	packet.ip.version = IPVERSION;
 	packet.ip.ttl = IPDEFTTL;
-	packet.ip.check = checksum(&(packet.ip), sizeof(packet.ip));
+	packet.ip.check = udhcp_checksum(&packet.ip, sizeof(packet.ip));
+/*
+	bb_info_msg("%s", __FUNCTION__);
+	bb_info_msg("packet.udp.len=%d", ntohs(packet.udp.len));
+	bb_info_msg("packet.ip.tot_len=%d", ntohs(packet.ip.tot_len));
+	bb_info_msg("UPD_DHCP_SIZE=%d", UPD_DHCP_SIZE);
+	bb_info_msg("IP_UPD_DHCP_SIZE=%d", IP_UPD_DHCP_SIZE);
+*/
+	result = sendto(fd, &packet, n, 0, (struct sockaddr *) &dest, sizeof(dest));
+#else
+	packet.ip.protocol = IPPROTO_UDP;
+	packet.ip.saddr = source_ip;
+	packet.ip.daddr = dest_ip;
+	packet.udp.source = htons(source_port);
+	packet.udp.dest = htons(dest_port);
+	/* size, excluding IP header: */
+	packet.udp.len = htons(UPD_DHCP_SIZE);
+	/* for UDP checksumming, ip.len is set to UDP packet len */
+	packet.ip.tot_len = packet.udp.len;
+	packet.udp.check = udhcp_checksum(&packet, IP_UPD_DHCP_SIZE);
+	/* but for sending, it is set to IP packet len */
+	packet.ip.tot_len = htons(IP_UPD_DHCP_SIZE);
+	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));
 
-	result = sendto(fd, &packet, sizeof(struct udp_dhcp_packet), 0, (struct sockaddr *) &dest, sizeof(dest));
-	if (result <= 0) {
-		DEBUG(LOG_ERR, "write on socket failed: %m");
-	}
+	/* Currently we send full-sized DHCP packets (zero padded).
+	 * If you need to change this: last byte of the packet is
+	 * packet.data.options[end_option(packet.data.options)]
+	 */
+	result = sendto(fd, &packet, IP_UPD_DHCP_SIZE, 0,
+				(struct sockaddr *) &dest, sizeof(dest));
+#endif
+
+	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 kernel_packet(struct dhcpMessage *payload, u_int32_t source_ip, int source_port,
-		   u_int32_t dest_ip, int dest_port)
+int FAST_FUNC udhcp_send_kernel_packet(struct dhcpMessage *payload,
+		uint32_t source_ip, int source_port,
+		uint32_t dest_ip, int dest_port)
 {
-	int n = 1;
-	int fd, result;
 	struct sockaddr_in client;
-	
-	if ((fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
-		return -1;
-	
-	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &n, sizeof(n)) == -1)
-		return -1;
+	int fd;
+	int result = -1;
+	const char *msg;
+
+	enum {
+		DHCP_SIZE = sizeof(struct dhcpMessage) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS,
+	};
+
+	fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (fd < 0) {
+		msg = "socket(%s)";
+		goto ret_msg;
+	}
+	setsockopt_reuseaddr(fd);
 
 	memset(&client, 0, sizeof(client));
 	client.sin_family = AF_INET;
 	client.sin_port = htons(source_port);
 	client.sin_addr.s_addr = source_ip;
-
-	if (bind(fd, (struct sockaddr *)&client, sizeof(struct sockaddr)) == -1)
-		return -1;
+	if (bind(fd, (struct sockaddr *)&client, sizeof(client)) == -1) {
+		msg = "bind(%s)";
+		goto ret_close;
+	}
 
 	memset(&client, 0, sizeof(client));
 	client.sin_family = AF_INET;
 	client.sin_port = htons(dest_port);
-	client.sin_addr.s_addr = dest_ip; 
+	client.sin_addr.s_addr = dest_ip;
+	if (connect(fd, (struct sockaddr *)&client, sizeof(client)) == -1) {
+		msg = "connect";
+		goto ret_close;
+	}
 
-	if (connect(fd, (struct sockaddr *)&client, sizeof(struct sockaddr)) == -1)
-		return -1;
+#if 1		// zzz
+	int n;
 
-	result = write(fd, payload, sizeof(struct dhcpMessage));
+	if (minpkt) n = (end_option(payload->options) + 1 + sizeof(*payload) - sizeof(payload->options));
+		else n = DHCP_SIZE;
+/*		
+	bb_info_msg("%s n=%d", __FUNCTION__, n);
+	bb_info_msg("%s", __FUNCTION__);
+	bb_info_msg("n=%d", n);
+	bb_info_msg("DHCP_SIZE=%d", DHCP_SIZE);
+*/
+	result = write(fd, payload, n);
+	
+#else
+	/* Currently we send full-sized DHCP packets (see above) */
+	result = safe_write(fd, payload, DHCP_SIZE);
+#endif
+
+	msg = "write";
+ ret_close:
 	close(fd);
+	if (result < 0) {
+ ret_msg:
+		bb_perror_msg(msg, "UDP");
+	}
 	return result;
-}	
+}