540 lines
14 KiB
C
540 lines
14 KiB
C
/*
|
|
* Copyright 2008, The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
|
#include <sys/time.h>
|
|
#include <poll.h>
|
|
|
|
#include <sys/socket.h>
|
|
#include <sys/select.h>
|
|
#include <sys/types.h>
|
|
#include <netinet/in.h>
|
|
|
|
#include <cutils/properties.h>
|
|
#define LOG_TAG "DHCP"
|
|
#include <cutils/log.h>
|
|
|
|
#include <dirent.h>
|
|
|
|
#include <netutils/ifc.h>
|
|
#include "dhcpmsg.h"
|
|
#include "packet.h"
|
|
|
|
#define VERBOSE 2
|
|
|
|
static int verbose = 1;
|
|
static char errmsg[2048];
|
|
|
|
typedef unsigned long long msecs_t;
|
|
#if VERBOSE
|
|
void dump_dhcp_msg();
|
|
#endif
|
|
|
|
msecs_t get_msecs(void)
|
|
{
|
|
struct timespec ts;
|
|
|
|
if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
|
|
return 0;
|
|
} else {
|
|
return (((msecs_t) ts.tv_sec) * ((msecs_t) 1000)) +
|
|
(((msecs_t) ts.tv_nsec) / ((msecs_t) 1000000));
|
|
}
|
|
}
|
|
|
|
void printerr(char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
vsnprintf(errmsg, sizeof(errmsg), fmt, ap);
|
|
va_end(ap);
|
|
|
|
ALOGD("%s", errmsg);
|
|
}
|
|
|
|
const char *dhcp_lasterror()
|
|
{
|
|
return errmsg;
|
|
}
|
|
|
|
int fatal(const char *reason)
|
|
{
|
|
printerr("%s: %s\n", reason, strerror(errno));
|
|
return -1;
|
|
// exit(1);
|
|
}
|
|
|
|
const char *ipaddr(in_addr_t addr)
|
|
{
|
|
struct in_addr in_addr;
|
|
|
|
in_addr.s_addr = addr;
|
|
return inet_ntoa(in_addr);
|
|
}
|
|
|
|
extern int ipv4NetmaskToPrefixLength(in_addr_t mask);
|
|
|
|
typedef struct dhcp_info dhcp_info;
|
|
|
|
struct dhcp_info {
|
|
uint32_t type;
|
|
|
|
uint32_t ipaddr;
|
|
uint32_t gateway;
|
|
uint32_t prefixLength;
|
|
|
|
uint32_t dns1;
|
|
uint32_t dns2;
|
|
|
|
uint32_t serveraddr;
|
|
uint32_t lease;
|
|
};
|
|
|
|
dhcp_info last_good_info;
|
|
|
|
void get_dhcp_info(uint32_t *ipaddr, uint32_t *gateway, uint32_t *prefixLength,
|
|
uint32_t *dns1, uint32_t *dns2, uint32_t *server,
|
|
uint32_t *lease)
|
|
{
|
|
*ipaddr = last_good_info.ipaddr;
|
|
*gateway = last_good_info.gateway;
|
|
*prefixLength = last_good_info.prefixLength;
|
|
*dns1 = last_good_info.dns1;
|
|
*dns2 = last_good_info.dns2;
|
|
*server = last_good_info.serveraddr;
|
|
*lease = last_good_info.lease;
|
|
}
|
|
|
|
static int dhcp_configure(const char *ifname, dhcp_info *info)
|
|
{
|
|
last_good_info = *info;
|
|
return ifc_configure(ifname, info->ipaddr, info->prefixLength, info->gateway,
|
|
info->dns1, info->dns2);
|
|
}
|
|
|
|
static const char *dhcp_type_to_name(uint32_t type)
|
|
{
|
|
switch(type) {
|
|
case DHCPDISCOVER: return "discover";
|
|
case DHCPOFFER: return "offer";
|
|
case DHCPREQUEST: return "request";
|
|
case DHCPDECLINE: return "decline";
|
|
case DHCPACK: return "ack";
|
|
case DHCPNAK: return "nak";
|
|
case DHCPRELEASE: return "release";
|
|
case DHCPINFORM: return "inform";
|
|
default: return "???";
|
|
}
|
|
}
|
|
|
|
void dump_dhcp_info(dhcp_info *info)
|
|
{
|
|
char addr[20], gway[20], mask[20];
|
|
ALOGD("--- dhcp %s (%d) ---",
|
|
dhcp_type_to_name(info->type), info->type);
|
|
strcpy(addr, ipaddr(info->ipaddr));
|
|
strcpy(gway, ipaddr(info->gateway));
|
|
ALOGD("ip %s gw %s prefixLength %d", addr, gway, info->prefixLength);
|
|
if (info->dns1) ALOGD("dns1: %s", ipaddr(info->dns1));
|
|
if (info->dns2) ALOGD("dns2: %s", ipaddr(info->dns2));
|
|
ALOGD("server %s, lease %d seconds",
|
|
ipaddr(info->serveraddr), info->lease);
|
|
}
|
|
|
|
|
|
int decode_dhcp_msg(dhcp_msg *msg, int len, dhcp_info *info)
|
|
{
|
|
uint8_t *x;
|
|
unsigned int opt;
|
|
int optlen;
|
|
|
|
memset(info, 0, sizeof(dhcp_info));
|
|
if (len < (DHCP_MSG_FIXED_SIZE + 4)) return -1;
|
|
|
|
len -= (DHCP_MSG_FIXED_SIZE + 4);
|
|
|
|
if (msg->options[0] != OPT_COOKIE1) return -1;
|
|
if (msg->options[1] != OPT_COOKIE2) return -1;
|
|
if (msg->options[2] != OPT_COOKIE3) return -1;
|
|
if (msg->options[3] != OPT_COOKIE4) return -1;
|
|
|
|
x = msg->options + 4;
|
|
|
|
while (len > 2) {
|
|
opt = *x++;
|
|
if (opt == OPT_PAD) {
|
|
len--;
|
|
continue;
|
|
}
|
|
if (opt == OPT_END) {
|
|
break;
|
|
}
|
|
optlen = *x++;
|
|
len -= 2;
|
|
if (optlen > len) {
|
|
break;
|
|
}
|
|
switch(opt) {
|
|
case OPT_SUBNET_MASK:
|
|
if (optlen >= 4) info->prefixLength = ipv4NetmaskToPrefixLength(*((uint32_t*)x));
|
|
break;
|
|
case OPT_GATEWAY:
|
|
if (optlen >= 4) memcpy(&info->gateway, x, 4);
|
|
break;
|
|
case OPT_DNS:
|
|
if (optlen >= 4) memcpy(&info->dns1, x + 0, 4);
|
|
if (optlen >= 8) memcpy(&info->dns2, x + 4, 4);
|
|
break;
|
|
case OPT_LEASE_TIME:
|
|
if (optlen >= 4) {
|
|
memcpy(&info->lease, x, 4);
|
|
info->lease = ntohl(info->lease);
|
|
}
|
|
break;
|
|
case OPT_SERVER_ID:
|
|
if (optlen >= 4) memcpy(&info->serveraddr, x, 4);
|
|
break;
|
|
case OPT_MESSAGE_TYPE:
|
|
info->type = *x;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
x += optlen;
|
|
len -= optlen;
|
|
}
|
|
|
|
info->ipaddr = msg->yiaddr;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if VERBOSE
|
|
|
|
static void hex2str(char *buf, const unsigned char *array, int len)
|
|
{
|
|
int i;
|
|
char *cp = buf;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
cp += sprintf(cp, " %02x ", array[i]);
|
|
}
|
|
}
|
|
|
|
void dump_dhcp_msg(dhcp_msg *msg, int len)
|
|
{
|
|
unsigned char *x;
|
|
unsigned int n,c;
|
|
int optsz;
|
|
const char *name;
|
|
char buf[2048];
|
|
|
|
ALOGD("===== DHCP message:");
|
|
if (len < DHCP_MSG_FIXED_SIZE) {
|
|
ALOGD("Invalid length %d, should be %d", len, DHCP_MSG_FIXED_SIZE);
|
|
return;
|
|
}
|
|
|
|
len -= DHCP_MSG_FIXED_SIZE;
|
|
|
|
if (msg->op == OP_BOOTREQUEST)
|
|
name = "BOOTREQUEST";
|
|
else if (msg->op == OP_BOOTREPLY)
|
|
name = "BOOTREPLY";
|
|
else
|
|
name = "????";
|
|
ALOGD("op = %s (%d), htype = %d, hlen = %d, hops = %d",
|
|
name, msg->op, msg->htype, msg->hlen, msg->hops);
|
|
ALOGD("xid = 0x%08x secs = %d, flags = 0x%04x optlen = %d",
|
|
ntohl(msg->xid), ntohs(msg->secs), ntohs(msg->flags), len);
|
|
ALOGD("ciaddr = %s", ipaddr(msg->ciaddr));
|
|
ALOGD("yiaddr = %s", ipaddr(msg->yiaddr));
|
|
ALOGD("siaddr = %s", ipaddr(msg->siaddr));
|
|
ALOGD("giaddr = %s", ipaddr(msg->giaddr));
|
|
|
|
c = msg->hlen > 16 ? 16 : msg->hlen;
|
|
hex2str(buf, msg->chaddr, c);
|
|
ALOGD("chaddr = {%s}", buf);
|
|
|
|
for (n = 0; n < 64; n++) {
|
|
if ((msg->sname[n] < ' ') || (msg->sname[n] > 127)) {
|
|
if (msg->sname[n] == 0) break;
|
|
msg->sname[n] = '.';
|
|
}
|
|
}
|
|
msg->sname[63] = 0;
|
|
|
|
for (n = 0; n < 128; n++) {
|
|
if ((msg->file[n] < ' ') || (msg->file[n] > 127)) {
|
|
if (msg->file[n] == 0) break;
|
|
msg->file[n] = '.';
|
|
}
|
|
}
|
|
msg->file[127] = 0;
|
|
|
|
ALOGD("sname = '%s'", msg->sname);
|
|
ALOGD("file = '%s'", msg->file);
|
|
|
|
if (len < 4) return;
|
|
len -= 4;
|
|
x = msg->options + 4;
|
|
|
|
while (len > 2) {
|
|
if (*x == 0) {
|
|
x++;
|
|
len--;
|
|
continue;
|
|
}
|
|
if (*x == OPT_END) {
|
|
break;
|
|
}
|
|
len -= 2;
|
|
optsz = x[1];
|
|
if (optsz > len) break;
|
|
if (x[0] == OPT_DOMAIN_NAME || x[0] == OPT_MESSAGE) {
|
|
if ((unsigned int)optsz < sizeof(buf) - 1) {
|
|
n = optsz;
|
|
} else {
|
|
n = sizeof(buf) - 1;
|
|
}
|
|
memcpy(buf, &x[2], n);
|
|
buf[n] = '\0';
|
|
} else {
|
|
hex2str(buf, &x[2], optsz);
|
|
}
|
|
if (x[0] == OPT_MESSAGE_TYPE)
|
|
name = dhcp_type_to_name(x[2]);
|
|
else
|
|
name = NULL;
|
|
ALOGD("op %d len %d {%s} %s", x[0], optsz, buf, name == NULL ? "" : name);
|
|
len -= optsz;
|
|
x = x + optsz + 2;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
static int send_message(int sock, int if_index, dhcp_msg *msg, int size)
|
|
{
|
|
#if VERBOSE > 1
|
|
dump_dhcp_msg(msg, size);
|
|
#endif
|
|
return send_packet(sock, if_index, msg, size, INADDR_ANY, INADDR_BROADCAST,
|
|
PORT_BOOTP_CLIENT, PORT_BOOTP_SERVER);
|
|
}
|
|
|
|
static int is_valid_reply(dhcp_msg *msg, dhcp_msg *reply, int sz)
|
|
{
|
|
if (sz < DHCP_MSG_FIXED_SIZE) {
|
|
if (verbose) ALOGD("netcfg: Wrong size %d != %d\n", sz, DHCP_MSG_FIXED_SIZE);
|
|
return 0;
|
|
}
|
|
if (reply->op != OP_BOOTREPLY) {
|
|
if (verbose) ALOGD("netcfg: Wrong Op %d != %d\n", reply->op, OP_BOOTREPLY);
|
|
return 0;
|
|
}
|
|
if (reply->xid != msg->xid) {
|
|
if (verbose) ALOGD("netcfg: Wrong Xid 0x%x != 0x%x\n", ntohl(reply->xid),
|
|
ntohl(msg->xid));
|
|
return 0;
|
|
}
|
|
if (reply->htype != msg->htype) {
|
|
if (verbose) ALOGD("netcfg: Wrong Htype %d != %d\n", reply->htype, msg->htype);
|
|
return 0;
|
|
}
|
|
if (reply->hlen != msg->hlen) {
|
|
if (verbose) ALOGD("netcfg: Wrong Hlen %d != %d\n", reply->hlen, msg->hlen);
|
|
return 0;
|
|
}
|
|
if (memcmp(msg->chaddr, reply->chaddr, msg->hlen)) {
|
|
if (verbose) ALOGD("netcfg: Wrong chaddr %x != %x\n", *(reply->chaddr),*(msg->chaddr));
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
#define STATE_SELECTING 1
|
|
#define STATE_REQUESTING 2
|
|
|
|
#define TIMEOUT_INITIAL 4000
|
|
#define TIMEOUT_MAX 32000
|
|
|
|
int dhcp_init_ifc(const char *ifname)
|
|
{
|
|
dhcp_msg discover_msg;
|
|
dhcp_msg request_msg;
|
|
dhcp_msg reply;
|
|
dhcp_msg *msg;
|
|
dhcp_info info;
|
|
int s, r, size;
|
|
int valid_reply;
|
|
uint32_t xid;
|
|
unsigned char hwaddr[6];
|
|
struct pollfd pfd;
|
|
unsigned int state;
|
|
unsigned int timeout;
|
|
int if_index;
|
|
|
|
xid = (uint32_t) get_msecs();
|
|
|
|
if (ifc_get_hwaddr(ifname, hwaddr)) {
|
|
return fatal("cannot obtain interface address");
|
|
}
|
|
if (ifc_get_ifindex(ifname, &if_index)) {
|
|
return fatal("cannot obtain interface index");
|
|
}
|
|
|
|
s = open_raw_socket(ifname, hwaddr, if_index);
|
|
|
|
timeout = TIMEOUT_INITIAL;
|
|
state = STATE_SELECTING;
|
|
info.type = 0;
|
|
goto transmit;
|
|
|
|
for (;;) {
|
|
pfd.fd = s;
|
|
pfd.events = POLLIN;
|
|
pfd.revents = 0;
|
|
r = poll(&pfd, 1, timeout);
|
|
|
|
if (r == 0) {
|
|
#if VERBOSE
|
|
printerr("TIMEOUT\n");
|
|
#endif
|
|
if (timeout >= TIMEOUT_MAX) {
|
|
printerr("timed out\n");
|
|
if ( info.type == DHCPOFFER ) {
|
|
printerr("no acknowledgement from DHCP server\nconfiguring %s with offered parameters\n", ifname);
|
|
return dhcp_configure(ifname, &info);
|
|
}
|
|
errno = ETIME;
|
|
close(s);
|
|
return -1;
|
|
}
|
|
timeout = timeout * 2;
|
|
|
|
transmit:
|
|
size = 0;
|
|
msg = NULL;
|
|
switch(state) {
|
|
case STATE_SELECTING:
|
|
msg = &discover_msg;
|
|
size = init_dhcp_discover_msg(msg, hwaddr, xid);
|
|
break;
|
|
case STATE_REQUESTING:
|
|
msg = &request_msg;
|
|
size = init_dhcp_request_msg(msg, hwaddr, xid, info.ipaddr, info.serveraddr);
|
|
break;
|
|
default:
|
|
r = 0;
|
|
}
|
|
if (size != 0) {
|
|
r = send_message(s, if_index, msg, size);
|
|
if (r < 0) {
|
|
printerr("error sending dhcp msg: %s\n", strerror(errno));
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (r < 0) {
|
|
if ((errno == EAGAIN) || (errno == EINTR)) {
|
|
continue;
|
|
}
|
|
return fatal("poll failed");
|
|
}
|
|
|
|
errno = 0;
|
|
r = receive_packet(s, &reply);
|
|
if (r < 0) {
|
|
if (errno != 0) {
|
|
ALOGD("receive_packet failed (%d): %s", r, strerror(errno));
|
|
if (errno == ENETDOWN || errno == ENXIO) {
|
|
return -1;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
#if VERBOSE > 1
|
|
dump_dhcp_msg(&reply, r);
|
|
#endif
|
|
decode_dhcp_msg(&reply, r, &info);
|
|
|
|
if (state == STATE_SELECTING) {
|
|
valid_reply = is_valid_reply(&discover_msg, &reply, r);
|
|
} else {
|
|
valid_reply = is_valid_reply(&request_msg, &reply, r);
|
|
}
|
|
if (!valid_reply) {
|
|
printerr("invalid reply\n");
|
|
continue;
|
|
}
|
|
|
|
if (verbose) dump_dhcp_info(&info);
|
|
|
|
switch(state) {
|
|
case STATE_SELECTING:
|
|
if (info.type == DHCPOFFER) {
|
|
state = STATE_REQUESTING;
|
|
timeout = TIMEOUT_INITIAL;
|
|
xid++;
|
|
goto transmit;
|
|
}
|
|
break;
|
|
case STATE_REQUESTING:
|
|
if (info.type == DHCPACK) {
|
|
printerr("configuring %s\n", ifname);
|
|
close(s);
|
|
return dhcp_configure(ifname, &info);
|
|
} else if (info.type == DHCPNAK) {
|
|
printerr("configuration request denied\n");
|
|
close(s);
|
|
return -1;
|
|
} else {
|
|
printerr("ignoring %s message in state %d\n",
|
|
dhcp_type_to_name(info.type), state);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
close(s);
|
|
return 0;
|
|
}
|
|
|
|
int do_dhcp(char *iname)
|
|
{
|
|
if (ifc_set_addr(iname, 0)) {
|
|
printerr("failed to set ip addr for %s to 0.0.0.0: %s\n", iname, strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
if (ifc_up(iname)) {
|
|
printerr("failed to bring up interface %s: %s\n", iname, strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
return dhcp_init_ifc(iname);
|
|
}
|