The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 1 | /* |
| 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 Hughes | a744b05 | 2015-01-28 11:37:57 -0800 | [diff] [blame] | 18 | #include <string.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 19 | #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 Block | 8d66c49 | 2011-12-20 16:07:45 +0000 | [diff] [blame] | 35 | #define ALOGD printf |
Steve Block | ae8b56c | 2012-01-05 22:25:38 +0000 | [diff] [blame] | 36 | #define ALOGW printf |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 37 | #endif |
| 38 | |
| 39 | #include "dhcpmsg.h" |
| 40 | |
| 41 | int fatal(); |
| 42 | |
Edwin Vane | a5db95d | 2012-07-26 15:04:10 -0400 | [diff] [blame] | 43 | int open_raw_socket(const char *ifname __attribute__((unused)), uint8_t *hwaddr, int if_index) |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 44 | { |
Andreas Gampe | a5d5d84 | 2014-11-24 10:43:53 -0800 | [diff] [blame] | 45 | int s; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 46 | 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 | |
| 66 | static 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 | |
| 85 | static uint32_t finish_sum(uint32_t sum) |
| 86 | { |
| 87 | return ~sum & 0xffff; |
| 88 | } |
| 89 | |
| 90 | int 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 | |
| 157 | int 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 Block | 8d66c49 | 2011-12-20 16:07:45 +0000 | [diff] [blame] | 183 | ALOGD("Packet is too small (%d) to be a UDP datagram", nread); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 184 | #endif |
| 185 | } else if (packet.ip.version != IPVERSION || packet.ip.ihl != (sizeof(packet.ip) >> 2)) { |
| 186 | #if VERBOSE |
Steve Block | 8d66c49 | 2011-12-20 16:07:45 +0000 | [diff] [blame] | 187 | ALOGD("Not a valid IP packet"); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 188 | #endif |
| 189 | } else if (nread < ntohs(packet.ip.tot_len)) { |
| 190 | #if VERBOSE |
Steve Block | 8d66c49 | 2011-12-20 16:07:45 +0000 | [diff] [blame] | 191 | ALOGD("Packet was truncated (read %d, needed %d)", nread, ntohs(packet.ip.tot_len)); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 192 | #endif |
| 193 | } else if (packet.ip.protocol != IPPROTO_UDP) { |
| 194 | #if VERBOSE |
Steve Block | 8d66c49 | 2011-12-20 16:07:45 +0000 | [diff] [blame] | 195 | ALOGD("IP protocol (%d) is not UDP", packet.ip.protocol); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 196 | #endif |
| 197 | } else if (packet.udp.dest != htons(PORT_BOOTP_CLIENT)) { |
| 198 | #if VERBOSE |
Steve Block | 8d66c49 | 2011-12-20 16:07:45 +0000 | [diff] [blame] | 199 | ALOGD("UDP dest port (%d) is not DHCP client", ntohs(packet.udp.dest)); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 200 | #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 Block | ae8b56c | 2012-01-05 22:25:38 +0000 | [diff] [blame] | 213 | ALOGW("IP header checksum failure (0x%x)", packet.ip.check); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 214 | 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 Dudani | 1c87ae0 | 2013-05-22 21:16:59 -0700 | [diff] [blame] | 234 | if (!sum) |
| 235 | sum = finish_sum(sum); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 236 | if (temp != sum) { |
Steve Block | ae8b56c | 2012-01-05 22:25:38 +0000 | [diff] [blame] | 237 | ALOGW("UDP header checksum failure (0x%x should be 0x%x)", sum, temp); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 238 | return -1; |
| 239 | } |
| 240 | memcpy(msg, &packet.dhcp, dhcp_size); |
| 241 | return dhcp_size; |
| 242 | } |