Contents of /trunk/mkinitrd-magellan/busybox/networking/udhcp/packet.c
Parent Directory | Revision Log
Revision 816 -
(show annotations)
(download)
Fri Apr 24 18:33:46 2009 UTC (15 years ago) by niro
File MIME type: text/plain
File size: 6142 byte(s)
Fri Apr 24 18:33:46 2009 UTC (15 years ago) by niro
File MIME type: text/plain
File size: 6142 byte(s)
-updated to busybox-1.13.4
1 | /* vi: set sw=4 ts=4: */ |
2 | |
3 | #include <netinet/in.h> |
4 | #if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION |
5 | #include <netpacket/packet.h> |
6 | #include <net/ethernet.h> |
7 | #else |
8 | #include <asm/types.h> |
9 | #include <linux/if_packet.h> |
10 | #include <linux/if_ether.h> |
11 | #endif |
12 | |
13 | #include "common.h" |
14 | #include "dhcpd.h" |
15 | #include "options.h" |
16 | |
17 | |
18 | void FAST_FUNC udhcp_init_header(struct dhcpMessage *packet, char type) |
19 | { |
20 | memset(packet, 0, sizeof(struct dhcpMessage)); |
21 | packet->op = BOOTREQUEST; /* if client to a server */ |
22 | switch (type) { |
23 | case DHCPOFFER: |
24 | case DHCPACK: |
25 | case DHCPNAK: |
26 | packet->op = BOOTREPLY; /* if server to client */ |
27 | } |
28 | packet->htype = ETH_10MB; |
29 | packet->hlen = ETH_10MB_LEN; |
30 | packet->cookie = htonl(DHCP_MAGIC); |
31 | packet->options[0] = DHCP_END; |
32 | add_simple_option(packet->options, DHCP_MESSAGE_TYPE, type); |
33 | } |
34 | |
35 | |
36 | /* read a packet from socket fd, return -1 on read error, -2 on packet error */ |
37 | int FAST_FUNC udhcp_recv_kernel_packet(struct dhcpMessage *packet, int fd) |
38 | { |
39 | int bytes; |
40 | unsigned char *vendor; |
41 | |
42 | memset(packet, 0, sizeof(*packet)); |
43 | bytes = safe_read(fd, packet, sizeof(*packet)); |
44 | if (bytes < 0) { |
45 | DEBUG("cannot read on listening socket, ignoring"); |
46 | return bytes; /* returns -1 */ |
47 | } |
48 | |
49 | if (packet->cookie != htonl(DHCP_MAGIC)) { |
50 | bb_error_msg("received bogus message, ignoring"); |
51 | return -2; |
52 | } |
53 | DEBUG("Received a packet"); |
54 | |
55 | if (packet->op == BOOTREQUEST) { |
56 | vendor = get_option(packet, DHCP_VENDOR); |
57 | if (vendor) { |
58 | #if 0 |
59 | static const char broken_vendors[][8] = { |
60 | "MSFT 98", |
61 | "" |
62 | }; |
63 | int i; |
64 | for (i = 0; broken_vendors[i][0]; i++) { |
65 | if (vendor[OPT_LEN - 2] == (uint8_t)strlen(broken_vendors[i]) |
66 | && !strncmp((char*)vendor, broken_vendors[i], vendor[OPT_LEN - 2]) |
67 | ) { |
68 | DEBUG("broken client (%s), forcing broadcast replies", |
69 | broken_vendors[i]); |
70 | packet->flags |= htons(BROADCAST_FLAG); |
71 | } |
72 | } |
73 | #else |
74 | if (vendor[OPT_LEN - 2] == (uint8_t)(sizeof("MSFT 98")-1) |
75 | && memcmp(vendor, "MSFT 98", sizeof("MSFT 98")-1) == 0 |
76 | ) { |
77 | DEBUG("broken client (%s), forcing broadcast replies", "MSFT 98"); |
78 | packet->flags |= htons(BROADCAST_FLAG); |
79 | } |
80 | #endif |
81 | } |
82 | } |
83 | |
84 | return bytes; |
85 | } |
86 | |
87 | |
88 | uint16_t FAST_FUNC udhcp_checksum(void *addr, int count) |
89 | { |
90 | /* Compute Internet Checksum for "count" bytes |
91 | * beginning at location "addr". |
92 | */ |
93 | int32_t sum = 0; |
94 | uint16_t *source = (uint16_t *) addr; |
95 | |
96 | while (count > 1) { |
97 | /* This is the inner loop */ |
98 | sum += *source++; |
99 | count -= 2; |
100 | } |
101 | |
102 | /* Add left-over byte, if any */ |
103 | if (count > 0) { |
104 | /* Make sure that the left-over byte is added correctly both |
105 | * with little and big endian hosts */ |
106 | uint16_t tmp = 0; |
107 | *(uint8_t*)&tmp = *(uint8_t*)source; |
108 | sum += tmp; |
109 | } |
110 | /* Fold 32-bit sum to 16 bits */ |
111 | while (sum >> 16) |
112 | sum = (sum & 0xffff) + (sum >> 16); |
113 | |
114 | return ~sum; |
115 | } |
116 | |
117 | |
118 | /* Construct a ip/udp header for a packet, send packet */ |
119 | int FAST_FUNC udhcp_send_raw_packet(struct dhcpMessage *payload, |
120 | uint32_t source_ip, int source_port, |
121 | uint32_t dest_ip, int dest_port, const uint8_t *dest_arp, |
122 | int ifindex) |
123 | { |
124 | struct sockaddr_ll dest; |
125 | struct udp_dhcp_packet packet; |
126 | int fd; |
127 | int result = -1; |
128 | const char *msg; |
129 | |
130 | enum { |
131 | IP_UPD_DHCP_SIZE = sizeof(struct udp_dhcp_packet) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS, |
132 | UPD_DHCP_SIZE = IP_UPD_DHCP_SIZE - offsetof(struct udp_dhcp_packet, udp), |
133 | }; |
134 | |
135 | fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP)); |
136 | if (fd < 0) { |
137 | msg = "socket(%s)"; |
138 | goto ret_msg; |
139 | } |
140 | |
141 | memset(&dest, 0, sizeof(dest)); |
142 | memset(&packet, 0, sizeof(packet)); |
143 | packet.data = *payload; /* struct copy */ |
144 | |
145 | dest.sll_family = AF_PACKET; |
146 | dest.sll_protocol = htons(ETH_P_IP); |
147 | dest.sll_ifindex = ifindex; |
148 | dest.sll_halen = 6; |
149 | memcpy(dest.sll_addr, dest_arp, 6); |
150 | if (bind(fd, (struct sockaddr *)&dest, sizeof(dest)) < 0) { |
151 | msg = "bind(%s)"; |
152 | goto ret_close; |
153 | } |
154 | |
155 | packet.ip.protocol = IPPROTO_UDP; |
156 | packet.ip.saddr = source_ip; |
157 | packet.ip.daddr = dest_ip; |
158 | packet.udp.source = htons(source_port); |
159 | packet.udp.dest = htons(dest_port); |
160 | /* size, excluding IP header: */ |
161 | packet.udp.len = htons(UPD_DHCP_SIZE); |
162 | /* for UDP checksumming, ip.len is set to UDP packet len */ |
163 | packet.ip.tot_len = packet.udp.len; |
164 | packet.udp.check = udhcp_checksum(&packet, IP_UPD_DHCP_SIZE); |
165 | /* but for sending, it is set to IP packet len */ |
166 | packet.ip.tot_len = htons(IP_UPD_DHCP_SIZE); |
167 | packet.ip.ihl = sizeof(packet.ip) >> 2; |
168 | packet.ip.version = IPVERSION; |
169 | packet.ip.ttl = IPDEFTTL; |
170 | packet.ip.check = udhcp_checksum(&packet.ip, sizeof(packet.ip)); |
171 | |
172 | /* Currently we send full-sized DHCP packets (zero padded). |
173 | * If you need to change this: last byte of the packet is |
174 | * packet.data.options[end_option(packet.data.options)] |
175 | */ |
176 | result = sendto(fd, &packet, IP_UPD_DHCP_SIZE, 0, |
177 | (struct sockaddr *) &dest, sizeof(dest)); |
178 | msg = "sendto"; |
179 | ret_close: |
180 | close(fd); |
181 | if (result < 0) { |
182 | ret_msg: |
183 | bb_perror_msg(msg, "PACKET"); |
184 | } |
185 | return result; |
186 | } |
187 | |
188 | |
189 | /* Let the kernel do all the work for packet generation */ |
190 | int FAST_FUNC udhcp_send_kernel_packet(struct dhcpMessage *payload, |
191 | uint32_t source_ip, int source_port, |
192 | uint32_t dest_ip, int dest_port) |
193 | { |
194 | struct sockaddr_in client; |
195 | int fd; |
196 | int result = -1; |
197 | const char *msg; |
198 | |
199 | enum { |
200 | DHCP_SIZE = sizeof(struct dhcpMessage) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS, |
201 | }; |
202 | |
203 | fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); |
204 | if (fd < 0) { |
205 | msg = "socket(%s)"; |
206 | goto ret_msg; |
207 | } |
208 | setsockopt_reuseaddr(fd); |
209 | |
210 | memset(&client, 0, sizeof(client)); |
211 | client.sin_family = AF_INET; |
212 | client.sin_port = htons(source_port); |
213 | client.sin_addr.s_addr = source_ip; |
214 | if (bind(fd, (struct sockaddr *)&client, sizeof(client)) == -1) { |
215 | msg = "bind(%s)"; |
216 | goto ret_close; |
217 | } |
218 | |
219 | memset(&client, 0, sizeof(client)); |
220 | client.sin_family = AF_INET; |
221 | client.sin_port = htons(dest_port); |
222 | client.sin_addr.s_addr = dest_ip; |
223 | if (connect(fd, (struct sockaddr *)&client, sizeof(client)) == -1) { |
224 | msg = "connect"; |
225 | goto ret_close; |
226 | } |
227 | |
228 | /* Currently we send full-sized DHCP packets (see above) */ |
229 | result = safe_write(fd, payload, DHCP_SIZE); |
230 | msg = "write"; |
231 | ret_close: |
232 | close(fd); |
233 | if (result < 0) { |
234 | ret_msg: |
235 | bb_perror_msg(msg, "UDP"); |
236 | } |
237 | return result; |
238 | } |