libnetutils/dhcpclient.c

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