blob: cd26d058a81daa374d3e79354c9bd034937da458 [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
2 * Copyright 2008, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <stdlib.h>
Elliott Hughesa744b052015-01-28 11:37:57 -080018#include <string.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080019#include <unistd.h>
20#include <sys/uio.h>
21#include <sys/socket.h>
22#include <netinet/in.h>
23#include <netinet/ip.h>
24#include <netinet/udp.h>
25#include <linux/if_packet.h>
26#include <linux/if_ether.h>
27#include <errno.h>
28
29#ifdef ANDROID
30#define LOG_TAG "DHCP"
31#include <cutils/log.h>
32#else
33#include <stdio.h>
34#include <string.h>
Steve Block8d66c492011-12-20 16:07:45 +000035#define ALOGD printf
Steve Blockae8b56c2012-01-05 22:25:38 +000036#define ALOGW printf
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080037#endif
38
39#include "dhcpmsg.h"
40
41int fatal();
42
Edwin Vanea5db95d2012-07-26 15:04:10 -040043int open_raw_socket(const char *ifname __attribute__((unused)), uint8_t *hwaddr, int if_index)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080044{
Andreas Gampea5d5d842014-11-24 10:43:53 -080045 int s;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080046 struct sockaddr_ll bindaddr;
47
48 if((s = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) {
49 return fatal("socket(PF_PACKET)");
50 }
51
52 memset(&bindaddr, 0, sizeof(bindaddr));
53 bindaddr.sll_family = AF_PACKET;
54 bindaddr.sll_protocol = htons(ETH_P_IP);
55 bindaddr.sll_halen = ETH_ALEN;
56 memcpy(bindaddr.sll_addr, hwaddr, ETH_ALEN);
57 bindaddr.sll_ifindex = if_index;
58
59 if (bind(s, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < 0) {
60 return fatal("Cannot bind raw socket to interface");
61 }
62
63 return s;
64}
65
66static uint32_t checksum(void *buffer, unsigned int count, uint32_t startsum)
67{
68 uint16_t *up = (uint16_t *)buffer;
69 uint32_t sum = startsum;
70 uint32_t upper16;
71
72 while (count > 1) {
73 sum += *up++;
74 count -= 2;
75 }
76 if (count > 0) {
77 sum += (uint16_t) *(uint8_t *)up;
78 }
79 while ((upper16 = (sum >> 16)) != 0) {
80 sum = (sum & 0xffff) + upper16;
81 }
82 return sum;
83}
84
85static uint32_t finish_sum(uint32_t sum)
86{
87 return ~sum & 0xffff;
88}
89
90int send_packet(int s, int if_index, struct dhcp_msg *msg, int size,
91 uint32_t saddr, uint32_t daddr, uint32_t sport, uint32_t dport)
92{
93 struct iphdr ip;
94 struct udphdr udp;
95 struct iovec iov[3];
96 uint32_t udpsum;
97 uint16_t temp;
98 struct msghdr msghdr;
99 struct sockaddr_ll destaddr;
100
101 ip.version = IPVERSION;
102 ip.ihl = sizeof(ip) >> 2;
103 ip.tos = 0;
104 ip.tot_len = htons(sizeof(ip) + sizeof(udp) + size);
105 ip.id = 0;
106 ip.frag_off = 0;
107 ip.ttl = IPDEFTTL;
108 ip.protocol = IPPROTO_UDP;
109 ip.check = 0;
110 ip.saddr = saddr;
111 ip.daddr = daddr;
112 ip.check = finish_sum(checksum(&ip, sizeof(ip), 0));
113
114 udp.source = htons(sport);
115 udp.dest = htons(dport);
116 udp.len = htons(sizeof(udp) + size);
117 udp.check = 0;
118
119 /* Calculate checksum for pseudo header */
120 udpsum = checksum(&ip.saddr, sizeof(ip.saddr), 0);
121 udpsum = checksum(&ip.daddr, sizeof(ip.daddr), udpsum);
122 temp = htons(IPPROTO_UDP);
123 udpsum = checksum(&temp, sizeof(temp), udpsum);
124 temp = udp.len;
125 udpsum = checksum(&temp, sizeof(temp), udpsum);
126
127 /* Add in the checksum for the udp header */
128 udpsum = checksum(&udp, sizeof(udp), udpsum);
129
130 /* Add in the checksum for the data */
131 udpsum = checksum(msg, size, udpsum);
132 udp.check = finish_sum(udpsum);
133
134 iov[0].iov_base = (char *)&ip;
135 iov[0].iov_len = sizeof(ip);
136 iov[1].iov_base = (char *)&udp;
137 iov[1].iov_len = sizeof(udp);
138 iov[2].iov_base = (char *)msg;
139 iov[2].iov_len = size;
140 memset(&destaddr, 0, sizeof(destaddr));
141 destaddr.sll_family = AF_PACKET;
142 destaddr.sll_protocol = htons(ETH_P_IP);
143 destaddr.sll_ifindex = if_index;
144 destaddr.sll_halen = ETH_ALEN;
145 memcpy(destaddr.sll_addr, "\xff\xff\xff\xff\xff\xff", ETH_ALEN);
146
147 msghdr.msg_name = &destaddr;
148 msghdr.msg_namelen = sizeof(destaddr);
149 msghdr.msg_iov = iov;
150 msghdr.msg_iovlen = sizeof(iov) / sizeof(struct iovec);
151 msghdr.msg_flags = 0;
152 msghdr.msg_control = 0;
153 msghdr.msg_controllen = 0;
154 return sendmsg(s, &msghdr, 0);
155}
156
157int receive_packet(int s, struct dhcp_msg *msg)
158{
159 int nread;
160 int is_valid;
161 struct dhcp_packet {
162 struct iphdr ip;
163 struct udphdr udp;
164 struct dhcp_msg dhcp;
165 } packet;
166 int dhcp_size;
167 uint32_t sum;
168 uint16_t temp;
169 uint32_t saddr, daddr;
170
171 nread = read(s, &packet, sizeof(packet));
172 if (nread < 0) {
173 return -1;
174 }
175 /*
176 * The raw packet interface gives us all packets received by the
177 * network interface. We need to filter out all packets that are
178 * not meant for us.
179 */
180 is_valid = 0;
181 if (nread < (int)(sizeof(struct iphdr) + sizeof(struct udphdr))) {
182#if VERBOSE
Steve Block8d66c492011-12-20 16:07:45 +0000183 ALOGD("Packet is too small (%d) to be a UDP datagram", nread);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800184#endif
185 } else if (packet.ip.version != IPVERSION || packet.ip.ihl != (sizeof(packet.ip) >> 2)) {
186#if VERBOSE
Steve Block8d66c492011-12-20 16:07:45 +0000187 ALOGD("Not a valid IP packet");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800188#endif
189 } else if (nread < ntohs(packet.ip.tot_len)) {
190#if VERBOSE
Steve Block8d66c492011-12-20 16:07:45 +0000191 ALOGD("Packet was truncated (read %d, needed %d)", nread, ntohs(packet.ip.tot_len));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800192#endif
193 } else if (packet.ip.protocol != IPPROTO_UDP) {
194#if VERBOSE
Steve Block8d66c492011-12-20 16:07:45 +0000195 ALOGD("IP protocol (%d) is not UDP", packet.ip.protocol);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800196#endif
197 } else if (packet.udp.dest != htons(PORT_BOOTP_CLIENT)) {
198#if VERBOSE
Steve Block8d66c492011-12-20 16:07:45 +0000199 ALOGD("UDP dest port (%d) is not DHCP client", ntohs(packet.udp.dest));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800200#endif
201 } else {
202 is_valid = 1;
203 }
204
205 if (!is_valid) {
206 return -1;
207 }
208
209 /* Seems like it's probably a valid DHCP packet */
210 /* validate IP header checksum */
211 sum = finish_sum(checksum(&packet.ip, sizeof(packet.ip), 0));
212 if (sum != 0) {
Steve Blockae8b56c2012-01-05 22:25:38 +0000213 ALOGW("IP header checksum failure (0x%x)", packet.ip.check);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800214 return -1;
215 }
216 /*
217 * Validate the UDP checksum.
218 * Since we don't need the IP header anymore, we "borrow" it
219 * to construct the pseudo header used in the checksum calculation.
220 */
221 dhcp_size = ntohs(packet.udp.len) - sizeof(packet.udp);
222 saddr = packet.ip.saddr;
223 daddr = packet.ip.daddr;
224 nread = ntohs(packet.ip.tot_len);
225 memset(&packet.ip, 0, sizeof(packet.ip));
226 packet.ip.saddr = saddr;
227 packet.ip.daddr = daddr;
228 packet.ip.protocol = IPPROTO_UDP;
229 packet.ip.tot_len = packet.udp.len;
230 temp = packet.udp.check;
231 packet.udp.check = 0;
232 sum = finish_sum(checksum(&packet, nread, 0));
233 packet.udp.check = temp;
Ajay Dudani1c87ae02013-05-22 21:16:59 -0700234 if (!sum)
235 sum = finish_sum(sum);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800236 if (temp != sum) {
Steve Blockae8b56c2012-01-05 22:25:38 +0000237 ALOGW("UDP header checksum failure (0x%x should be 0x%x)", sum, temp);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800238 return -1;
239 }
240 memcpy(msg, &packet.dhcp, dhcp_size);
241 return dhcp_size;
242}