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 <stdio.h>
18 #include <stdarg.h>
19 #include <stdlib.h>
20 #include <unistd.h>
21 #include <errno.h>
22 #include <string.h>
23
24 #include <time.h>
25 #include <sys/time.h>
26 #include <poll.h>
27
28 #include <sys/socket.h>
29 #include <sys/select.h>
30 #include <sys/types.h>
31 #include <netinet/in.h>
32
33 #include <cutils/properties.h>
34 #define LOG_TAG "DHCP"
35 #include <cutils/log.h>
36
37 #include <dirent.h>
38
39 #include <netutils/ifc.h>
40 #include "dhcpmsg.h"
41 #include "packet.h"
42
43 #define VERBOSE 2
44
45 static int verbose = 1;
46 static char errmsg[2048];
47
48 typedef unsigned long long msecs_t;
49 #if VERBOSE
50 void dump_dhcp_msg();
51 #endif
52
get_msecs(void)53 msecs_t get_msecs(void)
54 {
55 struct timespec ts;
56
57 if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
58 return 0;
59 } else {
60 return (((msecs_t) ts.tv_sec) * ((msecs_t) 1000)) +
61 (((msecs_t) ts.tv_nsec) / ((msecs_t) 1000000));
62 }
63 }
64
printerr(char * fmt,...)65 void printerr(char *fmt, ...)
66 {
67 va_list ap;
68
69 va_start(ap, fmt);
70 vsnprintf(errmsg, sizeof(errmsg), fmt, ap);
71 va_end(ap);
72
73 ALOGD("%s", errmsg);
74 }
75
dhcp_lasterror()76 const char *dhcp_lasterror()
77 {
78 return errmsg;
79 }
80
fatal(const char * reason)81 int fatal(const char *reason)
82 {
83 printerr("%s: %s\n", reason, strerror(errno));
84 return -1;
85 // exit(1);
86 }
87
ipaddr(in_addr_t addr)88 const char *ipaddr(in_addr_t addr)
89 {
90 struct in_addr in_addr;
91
92 in_addr.s_addr = addr;
93 return inet_ntoa(in_addr);
94 }
95
96 extern int ipv4NetmaskToPrefixLength(in_addr_t mask);
97
98 typedef struct dhcp_info dhcp_info;
99
100 struct dhcp_info {
101 uint32_t type;
102
103 uint32_t ipaddr;
104 uint32_t gateway;
105 uint32_t prefixLength;
106
107 uint32_t dns1;
108 uint32_t dns2;
109
110 uint32_t serveraddr;
111 uint32_t lease;
112 };
113
114 dhcp_info last_good_info;
115
get_dhcp_info(uint32_t * ipaddr,uint32_t * gateway,uint32_t * prefixLength,uint32_t * dns1,uint32_t * dns2,uint32_t * server,uint32_t * lease)116 void get_dhcp_info(uint32_t *ipaddr, uint32_t *gateway, uint32_t *prefixLength,
117 uint32_t *dns1, uint32_t *dns2, uint32_t *server,
118 uint32_t *lease)
119 {
120 *ipaddr = last_good_info.ipaddr;
121 *gateway = last_good_info.gateway;
122 *prefixLength = last_good_info.prefixLength;
123 *dns1 = last_good_info.dns1;
124 *dns2 = last_good_info.dns2;
125 *server = last_good_info.serveraddr;
126 *lease = last_good_info.lease;
127 }
128
dhcp_configure(const char * ifname,dhcp_info * info)129 static int dhcp_configure(const char *ifname, dhcp_info *info)
130 {
131 last_good_info = *info;
132 return ifc_configure(ifname, info->ipaddr, info->prefixLength, info->gateway,
133 info->dns1, info->dns2);
134 }
135
dhcp_type_to_name(uint32_t type)136 static const char *dhcp_type_to_name(uint32_t type)
137 {
138 switch(type) {
139 case DHCPDISCOVER: return "discover";
140 case DHCPOFFER: return "offer";
141 case DHCPREQUEST: return "request";
142 case DHCPDECLINE: return "decline";
143 case DHCPACK: return "ack";
144 case DHCPNAK: return "nak";
145 case DHCPRELEASE: return "release";
146 case DHCPINFORM: return "inform";
147 default: return "???";
148 }
149 }
150
dump_dhcp_info(dhcp_info * info)151 void dump_dhcp_info(dhcp_info *info)
152 {
153 char addr[20], gway[20], mask[20];
154 ALOGD("--- dhcp %s (%d) ---",
155 dhcp_type_to_name(info->type), info->type);
156 strcpy(addr, ipaddr(info->ipaddr));
157 strcpy(gway, ipaddr(info->gateway));
158 ALOGD("ip %s gw %s prefixLength %d", addr, gway, info->prefixLength);
159 if (info->dns1) ALOGD("dns1: %s", ipaddr(info->dns1));
160 if (info->dns2) ALOGD("dns2: %s", ipaddr(info->dns2));
161 ALOGD("server %s, lease %d seconds",
162 ipaddr(info->serveraddr), info->lease);
163 }
164
165
decode_dhcp_msg(dhcp_msg * msg,int len,dhcp_info * info)166 int decode_dhcp_msg(dhcp_msg *msg, int len, dhcp_info *info)
167 {
168 uint8_t *x;
169 unsigned int opt;
170 int optlen;
171
172 memset(info, 0, sizeof(dhcp_info));
173 if (len < (DHCP_MSG_FIXED_SIZE + 4)) return -1;
174
175 len -= (DHCP_MSG_FIXED_SIZE + 4);
176
177 if (msg->options[0] != OPT_COOKIE1) return -1;
178 if (msg->options[1] != OPT_COOKIE2) return -1;
179 if (msg->options[2] != OPT_COOKIE3) return -1;
180 if (msg->options[3] != OPT_COOKIE4) return -1;
181
182 x = msg->options + 4;
183
184 while (len > 2) {
185 opt = *x++;
186 if (opt == OPT_PAD) {
187 len--;
188 continue;
189 }
190 if (opt == OPT_END) {
191 break;
192 }
193 optlen = *x++;
194 len -= 2;
195 if (optlen > len) {
196 break;
197 }
198 switch(opt) {
199 case OPT_SUBNET_MASK:
200 if (optlen >= 4) info->prefixLength = ipv4NetmaskToPrefixLength(*((uint32_t*)x));
201 break;
202 case OPT_GATEWAY:
203 if (optlen >= 4) memcpy(&info->gateway, x, 4);
204 break;
205 case OPT_DNS:
206 if (optlen >= 4) memcpy(&info->dns1, x + 0, 4);
207 if (optlen >= 8) memcpy(&info->dns2, x + 4, 4);
208 break;
209 case OPT_LEASE_TIME:
210 if (optlen >= 4) {
211 memcpy(&info->lease, x, 4);
212 info->lease = ntohl(info->lease);
213 }
214 break;
215 case OPT_SERVER_ID:
216 if (optlen >= 4) memcpy(&info->serveraddr, x, 4);
217 break;
218 case OPT_MESSAGE_TYPE:
219 info->type = *x;
220 break;
221 default:
222 break;
223 }
224 x += optlen;
225 len -= optlen;
226 }
227
228 info->ipaddr = msg->yiaddr;
229
230 return 0;
231 }
232
233 #if VERBOSE
234
hex2str(char * buf,const unsigned char * array,int len)235 static void hex2str(char *buf, const unsigned char *array, int len)
236 {
237 int i;
238 char *cp = buf;
239
240 for (i = 0; i < len; i++) {
241 cp += sprintf(cp, " %02x ", array[i]);
242 }
243 }
244
dump_dhcp_msg(dhcp_msg * msg,int len)245 void dump_dhcp_msg(dhcp_msg *msg, int len)
246 {
247 unsigned char *x;
248 unsigned int n,c;
249 int optsz;
250 const char *name;
251 char buf[2048];
252
253 ALOGD("===== DHCP message:");
254 if (len < DHCP_MSG_FIXED_SIZE) {
255 ALOGD("Invalid length %d, should be %d", len, DHCP_MSG_FIXED_SIZE);
256 return;
257 }
258
259 len -= DHCP_MSG_FIXED_SIZE;
260
261 if (msg->op == OP_BOOTREQUEST)
262 name = "BOOTREQUEST";
263 else if (msg->op == OP_BOOTREPLY)
264 name = "BOOTREPLY";
265 else
266 name = "????";
267 ALOGD("op = %s (%d), htype = %d, hlen = %d, hops = %d",
268 name, msg->op, msg->htype, msg->hlen, msg->hops);
269 ALOGD("xid = 0x%08x secs = %d, flags = 0x%04x optlen = %d",
270 ntohl(msg->xid), ntohs(msg->secs), ntohs(msg->flags), len);
271 ALOGD("ciaddr = %s", ipaddr(msg->ciaddr));
272 ALOGD("yiaddr = %s", ipaddr(msg->yiaddr));
273 ALOGD("siaddr = %s", ipaddr(msg->siaddr));
274 ALOGD("giaddr = %s", ipaddr(msg->giaddr));
275
276 c = msg->hlen > 16 ? 16 : msg->hlen;
277 hex2str(buf, msg->chaddr, c);
278 ALOGD("chaddr = {%s}", buf);
279
280 for (n = 0; n < 64; n++) {
281 if ((msg->sname[n] < ' ') || (msg->sname[n] > 127)) {
282 if (msg->sname[n] == 0) break;
283 msg->sname[n] = '.';
284 }
285 }
286 msg->sname[63] = 0;
287
288 for (n = 0; n < 128; n++) {
289 if ((msg->file[n] < ' ') || (msg->file[n] > 127)) {
290 if (msg->file[n] == 0) break;
291 msg->file[n] = '.';
292 }
293 }
294 msg->file[127] = 0;
295
296 ALOGD("sname = '%s'", msg->sname);
297 ALOGD("file = '%s'", msg->file);
298
299 if (len < 4) return;
300 len -= 4;
301 x = msg->options + 4;
302
303 while (len > 2) {
304 if (*x == 0) {
305 x++;
306 len--;
307 continue;
308 }
309 if (*x == OPT_END) {
310 break;
311 }
312 len -= 2;
313 optsz = x[1];
314 if (optsz > len) break;
315 if (x[0] == OPT_DOMAIN_NAME || x[0] == OPT_MESSAGE) {
316 if ((unsigned int)optsz < sizeof(buf) - 1) {
317 n = optsz;
318 } else {
319 n = sizeof(buf) - 1;
320 }
321 memcpy(buf, &x[2], n);
322 buf[n] = '\0';
323 } else {
324 hex2str(buf, &x[2], optsz);
325 }
326 if (x[0] == OPT_MESSAGE_TYPE)
327 name = dhcp_type_to_name(x[2]);
328 else
329 name = NULL;
330 ALOGD("op %d len %d {%s} %s", x[0], optsz, buf, name == NULL ? "" : name);
331 len -= optsz;
332 x = x + optsz + 2;
333 }
334 }
335
336 #endif
337
send_message(int sock,int if_index,dhcp_msg * msg,int size)338 static int send_message(int sock, int if_index, dhcp_msg *msg, int size)
339 {
340 #if VERBOSE > 1
341 dump_dhcp_msg(msg, size);
342 #endif
343 return send_packet(sock, if_index, msg, size, INADDR_ANY, INADDR_BROADCAST,
344 PORT_BOOTP_CLIENT, PORT_BOOTP_SERVER);
345 }
346
is_valid_reply(dhcp_msg * msg,dhcp_msg * reply,int sz)347 static int is_valid_reply(dhcp_msg *msg, dhcp_msg *reply, int sz)
348 {
349 if (sz < DHCP_MSG_FIXED_SIZE) {
350 if (verbose) ALOGD("netcfg: Wrong size %d != %d\n", sz, DHCP_MSG_FIXED_SIZE);
351 return 0;
352 }
353 if (reply->op != OP_BOOTREPLY) {
354 if (verbose) ALOGD("netcfg: Wrong Op %d != %d\n", reply->op, OP_BOOTREPLY);
355 return 0;
356 }
357 if (reply->xid != msg->xid) {
358 if (verbose) ALOGD("netcfg: Wrong Xid 0x%x != 0x%x\n", ntohl(reply->xid),
359 ntohl(msg->xid));
360 return 0;
361 }
362 if (reply->htype != msg->htype) {
363 if (verbose) ALOGD("netcfg: Wrong Htype %d != %d\n", reply->htype, msg->htype);
364 return 0;
365 }
366 if (reply->hlen != msg->hlen) {
367 if (verbose) ALOGD("netcfg: Wrong Hlen %d != %d\n", reply->hlen, msg->hlen);
368 return 0;
369 }
370 if (memcmp(msg->chaddr, reply->chaddr, msg->hlen)) {
371 if (verbose) ALOGD("netcfg: Wrong chaddr %x != %x\n", *(reply->chaddr),*(msg->chaddr));
372 return 0;
373 }
374 return 1;
375 }
376
377 #define STATE_SELECTING 1
378 #define STATE_REQUESTING 2
379
380 #define TIMEOUT_INITIAL 4000
381 #define TIMEOUT_MAX 32000
382
dhcp_init_ifc(const char * ifname)383 int dhcp_init_ifc(const char *ifname)
384 {
385 dhcp_msg discover_msg;
386 dhcp_msg request_msg;
387 dhcp_msg reply;
388 dhcp_msg *msg;
389 dhcp_info info;
390 int s, r, size;
391 int valid_reply;
392 uint32_t xid;
393 unsigned char hwaddr[6];
394 struct pollfd pfd;
395 unsigned int state;
396 unsigned int timeout;
397 int if_index;
398
399 xid = (uint32_t) get_msecs();
400
401 if (ifc_get_hwaddr(ifname, hwaddr)) {
402 return fatal("cannot obtain interface address");
403 }
404 if (ifc_get_ifindex(ifname, &if_index)) {
405 return fatal("cannot obtain interface index");
406 }
407
408 s = open_raw_socket(ifname, hwaddr, if_index);
409
410 timeout = TIMEOUT_INITIAL;
411 state = STATE_SELECTING;
412 info.type = 0;
413 goto transmit;
414
415 for (;;) {
416 pfd.fd = s;
417 pfd.events = POLLIN;
418 pfd.revents = 0;
419 r = poll(&pfd, 1, timeout);
420
421 if (r == 0) {
422 #if VERBOSE
423 printerr("TIMEOUT\n");
424 #endif
425 if (timeout >= TIMEOUT_MAX) {
426 printerr("timed out\n");
427 if ( info.type == DHCPOFFER ) {
428 printerr("no acknowledgement from DHCP server\nconfiguring %s with offered parameters\n", ifname);
429 return dhcp_configure(ifname, &info);
430 }
431 errno = ETIME;
432 close(s);
433 return -1;
434 }
435 timeout = timeout * 2;
436
437 transmit:
438 size = 0;
439 msg = NULL;
440 switch(state) {
441 case STATE_SELECTING:
442 msg = &discover_msg;
443 size = init_dhcp_discover_msg(msg, hwaddr, xid);
444 break;
445 case STATE_REQUESTING:
446 msg = &request_msg;
447 size = init_dhcp_request_msg(msg, hwaddr, xid, info.ipaddr, info.serveraddr);
448 break;
449 default:
450 r = 0;
451 }
452 if (size != 0) {
453 r = send_message(s, if_index, msg, size);
454 if (r < 0) {
455 printerr("error sending dhcp msg: %s\n", strerror(errno));
456 }
457 }
458 continue;
459 }
460
461 if (r < 0) {
462 if ((errno == EAGAIN) || (errno == EINTR)) {
463 continue;
464 }
465 return fatal("poll failed");
466 }
467
468 errno = 0;
469 r = receive_packet(s, &reply);
470 if (r < 0) {
471 if (errno != 0) {
472 ALOGD("receive_packet failed (%d): %s", r, strerror(errno));
473 if (errno == ENETDOWN || errno == ENXIO) {
474 return -1;
475 }
476 }
477 continue;
478 }
479
480 #if VERBOSE > 1
481 dump_dhcp_msg(&reply, r);
482 #endif
483 decode_dhcp_msg(&reply, r, &info);
484
485 if (state == STATE_SELECTING) {
486 valid_reply = is_valid_reply(&discover_msg, &reply, r);
487 } else {
488 valid_reply = is_valid_reply(&request_msg, &reply, r);
489 }
490 if (!valid_reply) {
491 printerr("invalid reply\n");
492 continue;
493 }
494
495 if (verbose) dump_dhcp_info(&info);
496
497 switch(state) {
498 case STATE_SELECTING:
499 if (info.type == DHCPOFFER) {
500 state = STATE_REQUESTING;
501 timeout = TIMEOUT_INITIAL;
502 xid++;
503 goto transmit;
504 }
505 break;
506 case STATE_REQUESTING:
507 if (info.type == DHCPACK) {
508 printerr("configuring %s\n", ifname);
509 close(s);
510 return dhcp_configure(ifname, &info);
511 } else if (info.type == DHCPNAK) {
512 printerr("configuration request denied\n");
513 close(s);
514 return -1;
515 } else {
516 printerr("ignoring %s message in state %d\n",
517 dhcp_type_to_name(info.type), state);
518 }
519 break;
520 }
521 }
522 close(s);
523 return 0;
524 }
525
do_dhcp(char * iname)526 int do_dhcp(char *iname)
527 {
528 if (ifc_set_addr(iname, 0)) {
529 printerr("failed to set ip addr for %s to 0.0.0.0: %s\n", iname, strerror(errno));
530 return -1;
531 }
532
533 if (ifc_up(iname)) {
534 printerr("failed to bring up interface %s: %s\n", iname, strerror(errno));
535 return -1;
536 }
537
538 return dhcp_init_ifc(iname);
539 }
540