/* 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 tarball for details.
+ */
#include <netinet/in.h>
-#if (__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
-#include <netpacket/packet.h>
-#include <net/ethernet.h>
+#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
+# include <netpacket/packet.h>
+# include <net/ethernet.h>
#else
-#include <asm/types.h>
-#include <linux/if_packet.h>
-#include <linux/if_ether.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)
+void FAST_FUNC udhcp_init_header(struct dhcp_packet *packet, char type)
{
- memset(packet, 0, sizeof(struct dhcpMessage));
+ 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->op = BOOTREPLY; /* if server to client */
}
- packet->htype = ETH_10MB;
- packet->hlen = ETH_10MB_LEN;
+ 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);
+ 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 udhcp_get_packet(struct dhcpMessage *packet, int fd)
+/* 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)
{
- static const char broken_vendors[][8] = {
- "MSFT 98",
- ""
- };
int bytes;
- int i;
- 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("cannot read on listening socket, ignoring");
- return -1;
+ log1("Packet read error, ignoring");
+ return bytes; /* returns -1 */
}
- if (ntohl(packet->cookie) != DHCP_MAGIC) {
- bb_error_msg("received bogus message, ignoring");
+ if (packet->cookie != htonl(DHCP_MAGIC)) {
+ bb_info_msg("Packet with bad magic, ignoring");
return -2;
}
- DEBUG("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] == (uint8_t)strlen(broken_vendors[i])
- && !strncmp((char*)vendor, broken_vendors[i], vendor[OPT_LEN - 2])
+ log1("Received a packet");
+ udhcp_dump_packet(packet);
+
+ if (packet->op == BOOTREQUEST) {
+ 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 - OPT_DATA] == (uint8_t)strlen(broken_vendors[i])
+ && strncmp((char*)vendor, broken_vendors[i], vendor[OPT_LEN - OPT_DATA]) == 0
+ ) {
+ log1("Broken client (%s), forcing broadcast replies",
+ broken_vendors[i]);
+ packet->flags |= htons(BROADCAST_FLAG);
+ }
+ }
+#else
+ 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",
- broken_vendors[i]);
+ log1("Broken client (%s), forcing broadcast replies", "MSFT 98");
packet->flags |= htons(BROADCAST_FLAG);
}
+#endif
}
}
return bytes;
}
-
-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;
uint16_t *source = (uint16_t *) addr;
/* Make sure that the left-over byte is added correctly both
* with little and big endian hosts */
uint16_t tmp = 0;
- *(uint8_t *) (&tmp) = * (uint8_t *) source;
+ *(uint8_t*)&tmp = *(uint8_t*)source;
sum += tmp;
}
/* Fold 32-bit sum to 16 bits */
return ~sum;
}
-
-/* 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,
+/* 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_ip, int source_port,
- uint32_t dest_ip, int dest_port, uint8_t *dest_arp, int ifindex)
+ 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;
+ struct ip_udp_dhcp_packet packet;
+ int fd;
+ int result = -1;
+ const char *msg;
+
+ enum {
+ IP_UPD_DHCP_SIZE = sizeof(struct ip_udp_dhcp_packet) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS,
+ UPD_DHCP_SIZE = IP_UPD_DHCP_SIZE - offsetof(struct ip_udp_dhcp_packet, udp),
+ };
fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
if (fd < 0) {
- bb_perror_msg("socket");
- return -1;
+ msg = "socket(%s)";
+ goto ret_msg;
}
memset(&dest, 0, sizeof(dest));
memset(&packet, 0, sizeof(packet));
+ packet.data = *dhcp_pkt; /* 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) {
- bb_perror_msg("bind");
- close(fd);
- return -1;
+ if (bind(fd, (struct sockaddr *)&dest, sizeof(dest)) < 0) {
+ msg = "bind(%s)";
+ goto ret_close;
}
packet.ip.protocol = IPPROTO_UDP;
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(UPD_DHCP_SIZE);
+ /* 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_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));
+ 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");
- }
+ /* Currently we send full-sized DHCP packets (zero padded).
+ * If you need to change this: last byte of the packet is
+ * packet.data.options[udhcp_end_option(packet.data.options)]
+ */
+ udhcp_dump_packet(dhcp_pkt);
+ result = sendto(fd, &packet, IP_UPD_DHCP_SIZE, 0,
+ (struct sockaddr *) &dest, sizeof(dest));
+ msg = "sendto";
+ ret_close:
close(fd);
+ /* FIXME: and if result >= 0 but != IP_UPD_DHCP_SIZE? */
+ 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,
+int FAST_FUNC udhcp_send_kernel_packet(struct dhcp_packet *dhcp_pkt,
uint32_t source_ip, int source_port,
uint32_t dest_ip, int dest_port)
{
- int fd, result;
struct sockaddr_in client;
+ int fd;
+ int result = -1;
+ const char *msg;
- fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
- if (fd < 0)
- return -1;
+ enum {
+ DHCP_SIZE = sizeof(struct dhcp_packet) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS,
+ };
- if (setsockopt_reuseaddr(fd) == -1) {
- close(fd);
- return -1;
+ 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) {
- close(fd);
- 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;
-
- if (connect(fd, (struct sockaddr *)&client, sizeof(struct sockaddr)) == -1) {
- close(fd);
- return -1;
+ if (connect(fd, (struct sockaddr *)&client, sizeof(client)) == -1) {
+ msg = "connect";
+ goto ret_close;
}
- result = write(fd, payload, sizeof(struct dhcpMessage));
+ /* Currently we send full-sized DHCP packets (see above) */
+ udhcp_dump_packet(dhcp_pkt);
+ result = safe_write(fd, dhcp_pkt, DHCP_SIZE);
+ msg = "write";
+ ret_close:
close(fd);
+ /* FIXME: and if result >= 0 but != DHCP_SIZE? */
+ if (result < 0) {
+ ret_msg:
+ bb_perror_msg(msg, "UDP");
+ }
return result;
}
projects / oweals / busybox.git / blobdiff