Home | History | Annotate | Download | only in dhcpcd
      1 /*
      2  * dhcpcd - DHCP client daemon
      3  * Copyright (c) 2006-2010 Roy Marples <roy (at) marples.name>
      4  * All rights reserved
      5 
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     25  * SUCH DAMAGE.
     26  */
     27 
     28 const char copyright[] = "Copyright (c) 2006-2010 Roy Marples";
     29 
     30 #include <sys/file.h>
     31 #include <sys/socket.h>
     32 #include <sys/stat.h>
     33 #include <sys/time.h>
     34 #include <sys/types.h>
     35 #include <sys/uio.h>
     36 
     37 #include <arpa/inet.h>
     38 #include <net/route.h>
     39 
     40 #ifdef __linux__
     41 #  include <asm/types.h> /* for systems with broken headers */
     42 #  include <linux/rtnetlink.h>
     43 #endif
     44 
     45 #include <ctype.h>
     46 #include <errno.h>
     47 #include <getopt.h>
     48 #include <limits.h>
     49 #include <paths.h>
     50 #include <signal.h>
     51 #include <stdio.h>
     52 #include <stdlib.h>
     53 #include <string.h>
     54 #include <syslog.h>
     55 #include <unistd.h>
     56 #include <time.h>
     57 
     58 #include "arp.h"
     59 #include "bind.h"
     60 #include "config.h"
     61 #include "common.h"
     62 #include "configure.h"
     63 #include "control.h"
     64 #include "dhcpcd.h"
     65 #include "duid.h"
     66 #include "eloop.h"
     67 #include "if-options.h"
     68 #include "if-pref.h"
     69 #include "ipv4ll.h"
     70 #include "net.h"
     71 #include "signals.h"
     72 
     73 #ifdef ANDROID
     74 #include <linux/capability.h>
     75 #include <linux/prctl.h>
     76 #include <cutils/properties.h>
     77 #include <private/android_filesystem_config.h>
     78 #endif
     79 
     80 /* We should define a maximum for the NAK exponential backoff */
     81 #define NAKOFF_MAX              60
     82 
     83 /* Wait N nanoseconds between sending a RELEASE and dropping the address.
     84  * This gives the kernel enough time to actually send it. */
     85 #define RELEASE_DELAY_S		0
     86 #define RELEASE_DELAY_NS	10000000
     87 
     88 int options = 0;
     89 int pidfd = -1;
     90 struct interface *ifaces = NULL;
     91 int ifac = 0;
     92 char **ifav = NULL;
     93 int ifdc = 0;
     94 char **ifdv = NULL;
     95 /* If set, avoid routes after a DHCP success */
     96 int avoid_routes = 0;
     97 
     98 static char **margv;
     99 static int margc;
    100 static struct if_options *if_options;
    101 static char **ifv;
    102 static int ifc;
    103 static char *cffile;
    104 static char *pidfile;
    105 static int linkfd = -1;
    106 
    107 struct dhcp_op {
    108 	uint8_t value;
    109 	const char *name;
    110 };
    111 
    112 static const struct dhcp_op dhcp_ops[] = {
    113 	{ DHCP_DISCOVER, "DISCOVER" },
    114 	{ DHCP_OFFER,    "OFFER" },
    115 	{ DHCP_REQUEST,  "REQUEST" },
    116 	{ DHCP_DECLINE,  "DECLINE" },
    117 	{ DHCP_ACK,      "ACK" },
    118 	{ DHCP_NAK,      "NAK" },
    119 	{ DHCP_RELEASE,  "RELEASE" },
    120 	{ DHCP_INFORM,   "INFORM" },
    121 	{ 0, NULL }
    122 };
    123 
    124 static void send_release(struct interface *);
    125 
    126 static const char *
    127 get_dhcp_op(uint8_t type)
    128 {
    129 	const struct dhcp_op *d;
    130 
    131 	for (d = dhcp_ops; d->name; d++)
    132 		if (d->value == type)
    133 			return d->name;
    134 	return NULL;
    135 }
    136 
    137 static pid_t
    138 read_pid(void)
    139 {
    140 	FILE *fp;
    141 	pid_t pid;
    142 
    143 	if ((fp = fopen(pidfile, "r")) == NULL) {
    144 		errno = ENOENT;
    145 		return 0;
    146 	}
    147 	if (fscanf(fp, "%d", &pid) != 1)
    148 		pid = 0;
    149 	fclose(fp);
    150 	return pid;
    151 }
    152 
    153 static void
    154 usage(void)
    155 {
    156 	printf("usage: "PACKAGE" [-adgknpqwxyADEGHJKLOTV] [-c script] [-f file]"
    157 	    " [-e var=val]\n"
    158 	    "              [-h hostname] [-i classID ] [-l leasetime]"
    159 	    " [-m metric] [-o option]\n"
    160 	    "              [-r ipaddr] [-s ipaddr] [-t timeout]"
    161 	    " [-u userclass]\n"
    162 	    "              [-F none|ptr|both] [-I clientID] [-C hookscript]"
    163 	    " [-Q option]\n"
    164 	    "              [-X ipaddr] <interface>\n");
    165 }
    166 
    167 static void
    168 cleanup(void)
    169 {
    170 #ifdef DEBUG_MEMORY
    171 	struct interface *iface;
    172 	int i;
    173 
    174 	free_options(if_options);
    175 
    176 	while (ifaces) {
    177 		iface = ifaces;
    178 		ifaces = iface->next;
    179 		free_interface(iface);
    180 	}
    181 
    182 	for (i = 0; i < ifac; i++)
    183 		free(ifav[i]);
    184 	free(ifav);
    185 	for (i = 0; i < ifdc; i++)
    186 		free(ifdv[i]);
    187 	free(ifdv);
    188 #endif
    189 
    190 	if (linkfd != -1)
    191 		close(linkfd);
    192 	if (pidfd > -1) {
    193 		if (options & DHCPCD_MASTER) {
    194 			if (stop_control() == -1)
    195 				syslog(LOG_ERR, "stop_control: %m");
    196 		}
    197 		close(pidfd);
    198 		unlink(pidfile);
    199 	}
    200 #ifdef DEBUG_MEMORY
    201 	free(pidfile);
    202 #endif
    203 }
    204 
    205 /* ARGSUSED */
    206 void
    207 handle_exit_timeout(_unused void *arg)
    208 {
    209 	int timeout;
    210 
    211 	syslog(LOG_ERR, "timed out");
    212 	if (!(options & DHCPCD_TIMEOUT_IPV4LL)) {
    213 		if (options & DHCPCD_MASTER) {
    214 			daemonise();
    215 			return;
    216 		} else
    217 			exit(EXIT_FAILURE);
    218 	}
    219 	options &= ~DHCPCD_TIMEOUT_IPV4LL;
    220 	timeout = (PROBE_NUM * PROBE_MAX) + PROBE_WAIT + 1;
    221 	syslog(LOG_WARNING, "allowing %d seconds for IPv4LL timeout", timeout);
    222 	add_timeout_sec(timeout, handle_exit_timeout, NULL);
    223 }
    224 
    225 void
    226 drop_config(struct interface *iface, const char *reason)
    227 {
    228 	free(iface->state->old);
    229 	iface->state->old = iface->state->new;
    230 	iface->state->new = NULL;
    231 	iface->state->reason = reason;
    232 	configure(iface);
    233 	free(iface->state->old);
    234 	iface->state->old = NULL;
    235 	iface->state->lease.addr.s_addr = 0;
    236 }
    237 
    238 struct interface *
    239 find_interface(const char *ifname)
    240 {
    241 	struct interface *ifp;
    242 
    243 	for (ifp = ifaces; ifp; ifp = ifp->next)
    244 		if (strcmp(ifp->name, ifname) == 0)
    245 			return ifp;
    246 	return NULL;
    247 }
    248 
    249 static void
    250 stop_interface(struct interface *iface)
    251 {
    252 	struct interface *ifp, *ifl = NULL;
    253 
    254 	syslog(LOG_INFO, "%s: removing interface", iface->name);
    255 	if (strcmp(iface->state->reason, "RELEASE") != 0)
    256 		drop_config(iface, "STOP");
    257 	close_sockets(iface);
    258 	delete_timeout(NULL, iface);
    259 	for (ifp = ifaces; ifp; ifp = ifp->next) {
    260 		if (ifp == iface)
    261 			break;
    262 		ifl = ifp;
    263 	}
    264 	if (ifl)
    265 		ifl->next = ifp->next;
    266 	else
    267 		ifaces = ifp->next;
    268 	free_interface(ifp);
    269 	if (!(options & (DHCPCD_MASTER | DHCPCD_TEST)))
    270 		exit(EXIT_FAILURE);
    271 }
    272 
    273 static uint32_t
    274 dhcp_xid(struct interface *iface)
    275 {
    276 	uint32_t xid;
    277 
    278 	if (iface->state->options->options & DHCPCD_XID_HWADDR &&
    279 	    iface->hwlen >= sizeof(xid))
    280 		/* The lower bits are probably more unique on the network */
    281 		memcpy(&xid, (iface->hwaddr + iface->hwlen) - sizeof(xid),
    282 		    sizeof(xid));
    283 	else
    284 		xid = arc4random();
    285 
    286 	return xid;
    287 }
    288 
    289 static void
    290 send_message(struct interface *iface, int type,
    291     void (*callback)(void *))
    292 {
    293 	struct if_state *state = iface->state;
    294 	struct if_options *ifo = state->options;
    295 	struct dhcp_message *dhcp;
    296 	uint8_t *udp;
    297 	ssize_t len, r;
    298 	struct in_addr from, to;
    299 	in_addr_t a = 0;
    300 	struct timeval tv;
    301 
    302 	if (!callback)
    303 		syslog(LOG_DEBUG, "%s: sending %s with xid 0x%x",
    304 		    iface->name, get_dhcp_op(type), state->xid);
    305 	else {
    306 		if (state->interval == 0)
    307 			state->interval = 4;
    308 		else {
    309 			state->interval *= 2;
    310 			if (state->interval > 64)
    311 				state->interval = 64;
    312 		}
    313 		tv.tv_sec = state->interval + DHCP_RAND_MIN;
    314 		tv.tv_usec = arc4random() % (DHCP_RAND_MAX_U - DHCP_RAND_MIN_U);
    315 		syslog(LOG_DEBUG,
    316 		    "%s: sending %s (xid 0x%x), next in %0.2f seconds",
    317 		    iface->name, get_dhcp_op(type), state->xid,
    318 		    timeval_to_double(&tv));
    319 	}
    320 
    321 	/* Ensure sockets are open. */
    322 	open_sockets(iface);
    323 
    324 	/* If we couldn't open a UDP port for our IP address
    325 	 * then we cannot renew.
    326 	 * This could happen if our IP was pulled out from underneath us.
    327 	 * Also, we should not unicast from a BOOTP lease. */
    328 	if (iface->udp_fd == -1 ||
    329 	    (!(ifo->options & DHCPCD_INFORM) && is_bootp(iface->state->new)))
    330 	{
    331 		a = iface->addr.s_addr;
    332 		iface->addr.s_addr = 0;
    333 	}
    334 	len = make_message(&dhcp, iface, type);
    335 	if (a)
    336 		iface->addr.s_addr = a;
    337 	from.s_addr = dhcp->ciaddr;
    338 	if (from.s_addr)
    339 		to.s_addr = state->lease.server.s_addr;
    340 	else
    341 		to.s_addr = 0;
    342 	if (to.s_addr && to.s_addr != INADDR_BROADCAST) {
    343 		r = send_packet(iface, to, (uint8_t *)dhcp, len);
    344 		if (r == -1) {
    345 			syslog(LOG_ERR, "%s: send_packet: %m", iface->name);
    346 			close_sockets(iface);
    347 		}
    348 	} else {
    349 		len = make_udp_packet(&udp, (uint8_t *)dhcp, len, from, to);
    350 		r = send_raw_packet(iface, ETHERTYPE_IP, udp, len);
    351 		free(udp);
    352 		/* If we failed to send a raw packet this normally means
    353 		 * we don't have the ability to work beneath the IP layer
    354 		 * for this interface.
    355 		 * As such we remove it from consideration without actually
    356 		 * stopping the interface. */
    357 		if (r == -1) {
    358 			syslog(LOG_ERR, "%s: send_raw_packet: %m", iface->name);
    359 			if (!(options & DHCPCD_TEST))
    360 				drop_config(iface, "FAIL");
    361 			close_sockets(iface);
    362 			delete_timeout(NULL, iface);
    363 			callback = NULL;
    364 		}
    365 	}
    366 	free(dhcp);
    367 
    368 	/* Even if we fail to send a packet we should continue as we are
    369 	 * as our failure timeouts will change out codepath when needed. */
    370 	if (callback)
    371 		add_timeout_tv(&tv, callback, iface);
    372 }
    373 
    374 static void
    375 send_inform(void *arg)
    376 {
    377 	send_message((struct interface *)arg, DHCP_INFORM, send_inform);
    378 }
    379 
    380 static void
    381 send_discover(void *arg)
    382 {
    383 	send_message((struct interface *)arg, DHCP_DISCOVER, send_discover);
    384 }
    385 
    386 static void
    387 send_request(void *arg)
    388 {
    389 	send_message((struct interface *)arg, DHCP_REQUEST, send_request);
    390 }
    391 
    392 static void
    393 send_renew(void *arg)
    394 {
    395 	send_message((struct interface *)arg, DHCP_REQUEST, send_renew);
    396 }
    397 
    398 static void
    399 send_rebind(void *arg)
    400 {
    401 	send_message((struct interface *)arg, DHCP_REQUEST, send_rebind);
    402 }
    403 
    404 void
    405 start_expire(void *arg)
    406 {
    407 	struct interface *iface = arg;
    408 
    409 	iface->state->interval = 0;
    410 	if (iface->addr.s_addr == 0) {
    411 		/* We failed to reboot, so enter discovery. */
    412 		iface->state->lease.addr.s_addr = 0;
    413 		start_discover(iface);
    414 		return;
    415 	}
    416 
    417 	syslog(LOG_ERR, "%s: lease expired", iface->name);
    418 	delete_timeout(NULL, iface);
    419 	drop_config(iface, "EXPIRE");
    420 	unlink(iface->leasefile);
    421 	if (iface->carrier != LINK_DOWN)
    422 		start_interface(iface);
    423 }
    424 
    425 static void
    426 log_dhcp(int lvl, const char *msg,
    427     const struct interface *iface, const struct dhcp_message *dhcp,
    428     const struct in_addr *from)
    429 {
    430 	const char *tfrom;
    431 	char *a;
    432 	struct in_addr addr;
    433 	int r;
    434 
    435 	if (strcmp(msg, "NAK:") == 0)
    436 		a = get_option_string(dhcp, DHO_MESSAGE);
    437 	else if (dhcp->yiaddr != 0) {
    438 		addr.s_addr = dhcp->yiaddr;
    439 		a = xstrdup(inet_ntoa(addr));
    440 	} else
    441 		a = NULL;
    442 
    443 	tfrom = "from";
    444 	r = get_option_addr(&addr, dhcp, DHO_SERVERID);
    445 	if (dhcp->servername[0] && r == 0)
    446 		syslog(lvl, "%s: %s %s %s %s `%s'", iface->name, msg, a,
    447 		    tfrom, inet_ntoa(addr), dhcp->servername);
    448 	else {
    449 		if (r != 0) {
    450 			tfrom = "via";
    451 			addr = *from;
    452 		}
    453 		if (a == NULL)
    454 			syslog(lvl, "%s: %s %s %s",
    455 			    iface->name, msg, tfrom, inet_ntoa(addr));
    456 		else
    457 			syslog(lvl, "%s: %s %s %s %s",
    458 			    iface->name, msg, a, tfrom, inet_ntoa(addr));
    459 	}
    460 	free(a);
    461 }
    462 
    463 static int
    464 blacklisted_ip(const struct if_options *ifo, in_addr_t addr)
    465 {
    466 	size_t i;
    467 
    468 	for (i = 0; i < ifo->blacklist_len; i += 2)
    469 		if (ifo->blacklist[i] == (addr & ifo->blacklist[i + 1]))
    470 			return 1;
    471 	return 0;
    472 }
    473 
    474 static int
    475 whitelisted_ip(const struct if_options *ifo, in_addr_t addr)
    476 {
    477 	size_t i;
    478 
    479 	if (ifo->whitelist_len == 0)
    480 		return -1;
    481 	for (i = 0; i < ifo->whitelist_len; i += 2)
    482 		if (ifo->whitelist[i] == (addr & ifo->whitelist[i + 1]))
    483 			return 1;
    484 	return 0;
    485 }
    486 
    487 static void
    488 handle_dhcp(struct interface *iface, struct dhcp_message **dhcpp, const struct in_addr *from)
    489 {
    490 	struct if_state *state = iface->state;
    491 	struct if_options *ifo = state->options;
    492 	struct dhcp_message *dhcp = *dhcpp;
    493 	struct dhcp_lease *lease = &state->lease;
    494 	uint8_t type, tmp;
    495 	struct in_addr addr;
    496 	size_t i;
    497 
    498 	/* reset the message counter */
    499 	state->interval = 0;
    500 
    501 	/* We may have found a BOOTP server */
    502 	if (get_option_uint8(&type, dhcp, DHO_MESSAGETYPE) == -1)
    503 		type = 0;
    504 
    505 	if (type == DHCP_NAK) {
    506 		/* For NAK, only check if we require the ServerID */
    507 		if (has_option_mask(ifo->requiremask, DHO_SERVERID) &&
    508 		    get_option_addr(&addr, dhcp, DHO_SERVERID) == -1)
    509 		{
    510 			log_dhcp(LOG_WARNING, "reject NAK", iface, dhcp, from);
    511 			return;
    512 		}
    513 		/* We should restart on a NAK */
    514 		log_dhcp(LOG_WARNING, "NAK:", iface, dhcp, from);
    515 		if (!(options & DHCPCD_TEST)) {
    516 			drop_config(iface, "NAK");
    517 			unlink(iface->leasefile);
    518 		}
    519 		close_sockets(iface);
    520 		/* If we constantly get NAKS then we should slowly back off */
    521 		add_timeout_sec(state->nakoff, start_interface, iface);
    522 		state->nakoff *= 2;
    523 		if (state->nakoff > NAKOFF_MAX)
    524 			state->nakoff = NAKOFF_MAX;
    525 		return;
    526 	}
    527 
    528 	/* Ensure that all required options are present */
    529 	for (i = 1; i < 255; i++) {
    530 		if (has_option_mask(ifo->requiremask, i) &&
    531 		    get_option_uint8(&tmp, dhcp, i) != 0)
    532 		{
    533 			/* If we are bootp, then ignore the need for serverid.
    534 			 * To ignore bootp, require dhcp_message_type instead. */
    535 			if (type == 0 && i == DHO_SERVERID)
    536 				continue;
    537 			log_dhcp(LOG_WARNING, "reject DHCP", iface, dhcp, from);
    538 			return;
    539 		}
    540 	}
    541 
    542 	/* No NAK, so reset the backoff */
    543 	state->nakoff = 1;
    544 
    545 	if ((type == 0 || type == DHCP_OFFER) &&
    546 	    state->state == DHS_DISCOVER)
    547 	{
    548 		lease->frominfo = 0;
    549 		lease->addr.s_addr = dhcp->yiaddr;
    550 		lease->cookie = dhcp->cookie;
    551 		if (type == 0 ||
    552 		    get_option_addr(&lease->server, dhcp, DHO_SERVERID) != 0)
    553 			lease->server.s_addr = INADDR_ANY;
    554 		log_dhcp(LOG_INFO, "offered", iface, dhcp, from);
    555 		free(state->offer);
    556 		state->offer = dhcp;
    557 		*dhcpp = NULL;
    558 		if (options & DHCPCD_TEST) {
    559 			free(state->old);
    560 			state->old = state->new;
    561 			state->new = state->offer;
    562 			state->offer = NULL;
    563 			state->reason = "TEST";
    564 			run_script(iface);
    565 			exit(EXIT_SUCCESS);
    566 		}
    567 		delete_timeout(send_discover, iface);
    568 		/* We don't request BOOTP addresses */
    569 		if (type) {
    570 			/* We used to ARP check here, but that seems to be in
    571 			 * violation of RFC2131 where it only describes
    572 			 * DECLINE after REQUEST.
    573 			 * It also seems that some MS DHCP servers actually
    574 			 * ignore DECLINE if no REQUEST, ie we decline a
    575 			 * DISCOVER. */
    576 			start_request(iface);
    577 			return;
    578 		}
    579 	}
    580 
    581 	if (type) {
    582 		if (type == DHCP_OFFER) {
    583 			log_dhcp(LOG_INFO, "ignoring offer of",
    584 			    iface, dhcp, from);
    585 			return;
    586 		}
    587 
    588 		/* We should only be dealing with acks */
    589 		if (type != DHCP_ACK) {
    590 			log_dhcp(LOG_ERR, "not ACK or OFFER",
    591 			    iface, dhcp, from);
    592 			return;
    593 		}
    594 
    595 		if (!(ifo->options & DHCPCD_INFORM))
    596 			log_dhcp(LOG_INFO, "acknowledged", iface, dhcp, from);
    597 	}
    598 
    599 	/* BOOTP could have already assigned this above, so check we still
    600 	 * have a pointer. */
    601 	if (*dhcpp) {
    602 		free(state->offer);
    603 		state->offer = dhcp;
    604 		*dhcpp = NULL;
    605 	}
    606 
    607 	lease->frominfo = 0;
    608 	delete_timeout(NULL, iface);
    609 
    610 	/* We now have an offer, so close the DHCP sockets.
    611 	 * This allows us to safely ARP when broken DHCP servers send an ACK
    612 	 * follows by an invalid NAK. */
    613 	close_sockets(iface);
    614 
    615 	if (ifo->options & DHCPCD_ARP &&
    616 	    iface->addr.s_addr != state->offer->yiaddr)
    617 	{
    618 		/* If the interface already has the address configured
    619 		 * then we can't ARP for duplicate detection. */
    620 		addr.s_addr = state->offer->yiaddr;
    621 		if (has_address(iface->name, &addr, NULL) != 1) {
    622 			state->claims = 0;
    623 			state->probes = 0;
    624 			state->conflicts = 0;
    625 			state->state = DHS_PROBE;
    626 			send_arp_probe(iface);
    627 			return;
    628 		}
    629 	}
    630 
    631 	bind_interface(iface);
    632 }
    633 
    634 static void
    635 handle_dhcp_packet(void *arg)
    636 {
    637 	struct interface *iface = arg;
    638 	uint8_t *packet;
    639 	struct dhcp_message *dhcp = NULL;
    640 	const uint8_t *pp;
    641 	ssize_t bytes;
    642 	struct in_addr from;
    643 	int i;
    644 
    645 	/* We loop through until our buffer is empty.
    646 	 * The benefit is that if we get >1 DHCP packet in our buffer and
    647 	 * the first one fails for any reason, we can use the next. */
    648 	packet = xmalloc(udp_dhcp_len);
    649 	for(;;) {
    650 		bytes = get_raw_packet(iface, ETHERTYPE_IP,
    651 		    packet, udp_dhcp_len);
    652 		if (bytes == 0 || bytes == -1)
    653 			break;
    654 		if (valid_udp_packet(packet, bytes, &from) == -1) {
    655 			syslog(LOG_ERR, "%s: invalid UDP packet from %s",
    656 			    iface->name, inet_ntoa(from));
    657 			continue;
    658 		}
    659 		i = whitelisted_ip(iface->state->options, from.s_addr);
    660 		if (i == 0) {
    661 			syslog(LOG_WARNING,
    662 			    "%s: non whitelisted DHCP packet from %s",
    663 			    iface->name, inet_ntoa(from));
    664 			continue;
    665 		} else if (i != 1 &&
    666 		    blacklisted_ip(iface->state->options, from.s_addr) == 1)
    667 		{
    668 			syslog(LOG_WARNING,
    669 			    "%s: blacklisted DHCP packet from %s",
    670 			    iface->name, inet_ntoa(from));
    671 			continue;
    672 		}
    673 		if (iface->flags & IFF_POINTOPOINT &&
    674 		    iface->dst.s_addr != from.s_addr)
    675 		{
    676 			syslog(LOG_WARNING,
    677 			    "%s: server %s is not destination",
    678 			    iface->name, inet_ntoa(from));
    679 		}
    680 		bytes = get_udp_data(&pp, packet);
    681 		if ((size_t)bytes > sizeof(*dhcp)) {
    682 			syslog(LOG_ERR,
    683 			    "%s: packet greater than DHCP size from %s",
    684 			    iface->name, inet_ntoa(from));
    685 			continue;
    686 		}
    687 		if (!dhcp)
    688 			dhcp = xzalloc(sizeof(*dhcp));
    689 		memcpy(dhcp, pp, bytes);
    690 		if (dhcp->cookie != htonl(MAGIC_COOKIE)) {
    691 			syslog(LOG_DEBUG, "%s: bogus cookie from %s",
    692 			    iface->name, inet_ntoa(from));
    693 			continue;
    694 		}
    695 		/* Ensure it's the right transaction */
    696 		if (iface->state->xid != dhcp->xid) {
    697 			syslog(LOG_DEBUG,
    698 			    "%s: wrong xid 0x%x (expecting 0x%x) from %s",
    699 			    iface->name, dhcp->xid, iface->state->xid,
    700 			    inet_ntoa(from));
    701 			continue;
    702 		}
    703 		/* Ensure packet is for us */
    704 		if (iface->hwlen <= sizeof(dhcp->chaddr) &&
    705 		    memcmp(dhcp->chaddr, iface->hwaddr, iface->hwlen))
    706 		{
    707 			syslog(LOG_DEBUG, "%s: xid 0x%x is not for hwaddr %s",
    708 			    iface->name, dhcp->xid,
    709 			    hwaddr_ntoa(dhcp->chaddr, sizeof(dhcp->chaddr)));
    710 			continue;
    711 		}
    712 		handle_dhcp(iface, &dhcp, &from);
    713 		if (iface->raw_fd == -1)
    714 			break;
    715 	}
    716 	free(packet);
    717 	free(dhcp);
    718 }
    719 
    720 static void
    721 send_release(struct interface *iface)
    722 {
    723 	struct timespec ts;
    724 
    725 	if (iface->state->new != NULL &&
    726 	    iface->state->new->cookie == htonl(MAGIC_COOKIE))
    727 	{
    728 		syslog(LOG_INFO, "%s: releasing lease of %s",
    729 		    iface->name, inet_ntoa(iface->state->lease.addr));
    730 		iface->state->xid = dhcp_xid(iface);
    731 		send_message(iface, DHCP_RELEASE, NULL);
    732 		/* Give the packet a chance to go before dropping the ip */
    733 		ts.tv_sec = RELEASE_DELAY_S;
    734 		ts.tv_nsec = RELEASE_DELAY_NS;
    735 		nanosleep(&ts, NULL);
    736 		drop_config(iface, "RELEASE");
    737 	}
    738 	unlink(iface->leasefile);
    739 }
    740 
    741 void
    742 send_decline(struct interface *iface)
    743 {
    744 	send_message(iface, DHCP_DECLINE, NULL);
    745 }
    746 
    747 static void
    748 configure_interface1(struct interface *iface)
    749 {
    750 	struct if_state *ifs = iface->state;
    751 	struct if_options *ifo = ifs->options;
    752 	uint8_t *duid;
    753 	size_t len = 0, ifl;
    754 
    755 	/* Do any platform specific configuration */
    756 	if_conf(iface);
    757 
    758 	if (iface->flags & IFF_POINTOPOINT && !(ifo->options & DHCPCD_INFORM))
    759 		ifo->options |= DHCPCD_STATIC;
    760 	if (iface->flags & IFF_NOARP ||
    761 	    ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))
    762 		ifo->options &= ~(DHCPCD_ARP | DHCPCD_IPV4LL);
    763 	if (ifo->options & DHCPCD_LINK && carrier_status(iface) == -1)
    764 		ifo->options &= ~DHCPCD_LINK;
    765 
    766 	if (ifo->metric != -1)
    767 		iface->metric = ifo->metric;
    768 
    769 	/* If we haven't specified a ClientID and our hardware address
    770 	 * length is greater than DHCP_CHADDR_LEN then we enforce a ClientID
    771 	 * of the hardware address family and the hardware address. */
    772 	if (iface->hwlen > DHCP_CHADDR_LEN)
    773 		ifo->options |= DHCPCD_CLIENTID;
    774 
    775 	/* Firewire and InfiniBand interfaces require ClientID and
    776 	 * the broadcast option being set. */
    777 	switch (iface->family) {
    778 	case ARPHRD_IEEE1394:	/* FALLTHROUGH */
    779 	case ARPHRD_INFINIBAND:
    780 		ifo->options |= DHCPCD_CLIENTID | DHCPCD_BROADCAST;
    781 		break;
    782 	}
    783 
    784 	free(iface->clientid);
    785 	iface->clientid = NULL;
    786 	if (*ifo->clientid) {
    787 		iface->clientid = xmalloc(ifo->clientid[0] + 1);
    788 		memcpy(iface->clientid, ifo->clientid, ifo->clientid[0] + 1);
    789 	} else if (ifo->options & DHCPCD_CLIENTID) {
    790 		if (ifo->options & DHCPCD_DUID) {
    791 			duid = xmalloc(DUID_LEN);
    792 			if ((len = get_duid(duid, iface)) == 0)
    793 				syslog(LOG_ERR, "get_duid: %m");
    794 		}
    795 		if (len > 0) {
    796 			iface->clientid = xmalloc(len + 6);
    797 			iface->clientid[0] = len + 5;
    798 			iface->clientid[1] = 255; /* RFC 4361 */
    799 			ifl = strlen(iface->name);
    800 			if (ifl < 5) {
    801 				memcpy(iface->clientid + 2, iface->name, ifl);
    802 				if (ifl < 4)
    803 					memset(iface->clientid + 2 + ifl,
    804 					    0, 4 - ifl);
    805 			} else {
    806 				ifl = htonl(if_nametoindex(iface->name));
    807 				memcpy(iface->clientid + 2, &ifl, 4);
    808 			}
    809 		} else if (len == 0) {
    810 			len = iface->hwlen + 1;
    811 			iface->clientid = xmalloc(len + 1);
    812 			iface->clientid[0] = len;
    813 			iface->clientid[1] = iface->family;
    814 			memcpy(iface->clientid + 2, iface->hwaddr,
    815 			    iface->hwlen);
    816 		}
    817 	}
    818 	if (ifo->options & DHCPCD_CLIENTID)
    819 		syslog(LOG_DEBUG, "%s: using ClientID %s", iface->name,
    820 		    hwaddr_ntoa(iface->clientid + 1, *iface->clientid));
    821 	else
    822 		syslog(LOG_DEBUG, "%s: using hwaddr %s", iface->name,
    823 		    hwaddr_ntoa(iface->hwaddr, iface->hwlen));
    824 }
    825 
    826 int
    827 select_profile(struct interface *iface, const char *profile)
    828 {
    829 	struct if_options *ifo;
    830 	int ret;
    831 
    832 	ret = 0;
    833 	ifo = read_config(cffile, iface->name, iface->ssid, profile);
    834 	if (ifo == NULL) {
    835 		syslog(LOG_DEBUG, "%s: no profile %s", iface->name, profile);
    836 		ret = -1;
    837 		goto exit;
    838 	}
    839 	if (profile != NULL) {
    840 		strlcpy(iface->state->profile, profile,
    841 		    sizeof(iface->state->profile));
    842 		syslog(LOG_INFO, "%s: selected profile %s",
    843 		    iface->name, profile);
    844 	} else
    845 		*iface->state->profile = '\0';
    846 	free_options(iface->state->options);
    847 	iface->state->options = ifo;
    848 
    849 exit:
    850 	if (profile)
    851 		configure_interface1(iface);
    852 	return ret;
    853 }
    854 
    855 static void
    856 start_fallback(void *arg)
    857 {
    858 	struct interface *iface;
    859 
    860 	iface = (struct interface *)arg;
    861 	select_profile(iface, iface->state->options->fallback);
    862 	start_interface(iface);
    863 }
    864 
    865 static void
    866 configure_interface(struct interface *iface, int argc, char **argv)
    867 {
    868 	select_profile(iface, NULL);
    869 	add_options(iface->state->options, argc, argv);
    870 	configure_interface1(iface);
    871 }
    872 
    873 static void
    874 handle_carrier(const char *ifname)
    875 {
    876 	struct interface *iface;
    877 	int carrier;
    878 
    879 	if (!(options & DHCPCD_LINK))
    880 		return;
    881 	for (iface = ifaces; iface; iface = iface->next)
    882 		if (strcmp(iface->name, ifname) == 0)
    883 			break;
    884 	if (!iface || !(iface->state->options->options & DHCPCD_LINK))
    885 		return;
    886 	carrier = carrier_status(iface);
    887 	if (carrier == -1)
    888 		syslog(LOG_ERR, "%s: carrier_status: %m", ifname);
    889 	else if (carrier == 0 || !(iface->flags & IFF_RUNNING)) {
    890 		if (iface->carrier != LINK_DOWN) {
    891 			iface->carrier = LINK_DOWN;
    892 			syslog(LOG_INFO, "%s: carrier lost", iface->name);
    893 			close_sockets(iface);
    894 			delete_timeouts(iface, start_expire, NULL);
    895 			drop_config(iface, "NOCARRIER");
    896 		}
    897 	} else if (carrier == 1 && (iface->flags & IFF_RUNNING)) {
    898 		if (iface->carrier != LINK_UP) {
    899 			iface->carrier = LINK_UP;
    900 			syslog(LOG_INFO, "%s: carrier acquired", iface->name);
    901 			if (iface->wireless)
    902 				getifssid(iface->name, iface->ssid);
    903 			configure_interface(iface, margc, margv);
    904 			iface->state->interval = 0;
    905 			iface->state->reason = "CARRIER";
    906 			run_script(iface);
    907 			start_interface(iface);
    908 		}
    909 	}
    910 }
    911 
    912 void
    913 start_discover(void *arg)
    914 {
    915 	struct interface *iface = arg;
    916 	struct if_options *ifo = iface->state->options;
    917 
    918 	iface->state->state = DHS_DISCOVER;
    919 	iface->state->xid = dhcp_xid(iface);
    920 	delete_timeout(NULL, iface);
    921 	if (ifo->fallback)
    922 		add_timeout_sec(ifo->timeout, start_fallback, iface);
    923 	else if (ifo->options & DHCPCD_IPV4LL &&
    924 	    !IN_LINKLOCAL(htonl(iface->addr.s_addr)))
    925 	{
    926 		if (IN_LINKLOCAL(htonl(iface->state->fail.s_addr)))
    927 			add_timeout_sec(RATE_LIMIT_INTERVAL, start_ipv4ll, iface);
    928 		else
    929 			add_timeout_sec(ifo->timeout, start_ipv4ll, iface);
    930 	}
    931 	syslog(LOG_INFO, "%s: broadcasting for a lease", iface->name);
    932 	send_discover(iface);
    933 }
    934 
    935 void
    936 start_request(void *arg)
    937 {
    938 	struct interface *iface = arg;
    939 
    940 	iface->state->state = DHS_REQUEST;
    941 	send_request(iface);
    942 }
    943 
    944 void
    945 start_renew(void *arg)
    946 {
    947 	struct interface *iface = arg;
    948 
    949 	syslog(LOG_INFO, "%s: renewing lease of %s",
    950 	    iface->name, inet_ntoa(iface->state->lease.addr));
    951 	iface->state->state = DHS_RENEW;
    952 	iface->state->xid = dhcp_xid(iface);
    953 	send_renew(iface);
    954 }
    955 
    956 void
    957 start_rebind(void *arg)
    958 {
    959 	struct interface *iface = arg;
    960 
    961 	syslog(LOG_ERR, "%s: failed to renew, attempting to rebind",
    962 	    iface->name);
    963 	iface->state->state = DHS_REBIND;
    964 	delete_timeout(send_renew, iface);
    965 	iface->state->lease.server.s_addr = 0;
    966 	send_rebind(iface);
    967 }
    968 
    969 static void
    970 start_timeout(void *arg)
    971 {
    972 	struct interface *iface = arg;
    973 
    974 	bind_interface(iface);
    975 	iface->state->interval = 0;
    976 	start_discover(iface);
    977 }
    978 
    979 static struct dhcp_message *
    980 dhcp_message_new(struct in_addr *addr, struct in_addr *mask)
    981 {
    982 	struct dhcp_message *dhcp;
    983 	uint8_t *p;
    984 
    985 	dhcp = xzalloc(sizeof(*dhcp));
    986 	dhcp->yiaddr = addr->s_addr;
    987 	p = dhcp->options;
    988 	if (mask && mask->s_addr != INADDR_ANY) {
    989 		*p++ = DHO_SUBNETMASK;
    990 		*p++ = sizeof(mask->s_addr);
    991 		memcpy(p, &mask->s_addr, sizeof(mask->s_addr));
    992 		p+= sizeof(mask->s_addr);
    993 	}
    994 	*p++ = DHO_END;
    995 	return dhcp;
    996 }
    997 
    998 static int
    999 handle_3rdparty(struct interface *iface)
   1000 {
   1001 	struct if_options *ifo;
   1002 	struct in_addr addr, net, dst;
   1003 
   1004 	ifo = iface->state->options;
   1005 	if (ifo->req_addr.s_addr != INADDR_ANY)
   1006 		return 0;
   1007 
   1008 	if (get_address(iface->name, &addr, &net, &dst) == 1)
   1009 		handle_ifa(RTM_NEWADDR, iface->name, &addr, &net, &dst);
   1010 	else {
   1011 		syslog(LOG_INFO,
   1012 		    "%s: waiting for 3rd party to configure IP address",
   1013 		    iface->name);
   1014 		iface->state->reason = "3RDPARTY";
   1015 		run_script(iface);
   1016 	}
   1017 	return 1;
   1018 }
   1019 
   1020 static void
   1021 start_static(struct interface *iface)
   1022 {
   1023 	struct if_options *ifo;
   1024 
   1025 	if (handle_3rdparty(iface))
   1026 		return;
   1027 	ifo = iface->state->options;
   1028 	iface->state->offer =
   1029 	    dhcp_message_new(&ifo->req_addr, &ifo->req_mask);
   1030 	delete_timeout(NULL, iface);
   1031 	bind_interface(iface);
   1032 }
   1033 
   1034 static void
   1035 start_inform(struct interface *iface)
   1036 {
   1037 	if (handle_3rdparty(iface))
   1038 		return;
   1039 
   1040 	if (options & DHCPCD_TEST) {
   1041 		iface->addr.s_addr = iface->state->options->req_addr.s_addr;
   1042 		iface->net.s_addr = iface->state->options->req_mask.s_addr;
   1043 	} else {
   1044 		iface->state->options->options |= DHCPCD_STATIC;
   1045 		start_static(iface);
   1046 	}
   1047 
   1048 	iface->state->state = DHS_INFORM;
   1049 	iface->state->xid = dhcp_xid(iface);
   1050 	send_inform(iface);
   1051 }
   1052 
   1053 void
   1054 start_reboot(struct interface *iface)
   1055 {
   1056 	struct if_options *ifo = iface->state->options;
   1057 
   1058 	if (ifo->options & DHCPCD_LINK && iface->carrier == LINK_DOWN) {
   1059 		syslog(LOG_INFO, "%s: waiting for carrier", iface->name);
   1060 		return;
   1061 	}
   1062 	if (ifo->options & DHCPCD_STATIC) {
   1063 		start_static(iface);
   1064 		return;
   1065 	}
   1066 	if (ifo->reboot == 0 || iface->state->offer == NULL) {
   1067 		start_discover(iface);
   1068 		return;
   1069 	}
   1070 	if (ifo->options & DHCPCD_INFORM) {
   1071 		syslog(LOG_INFO, "%s: informing address of %s",
   1072 		    iface->name, inet_ntoa(iface->state->lease.addr));
   1073 	} else if (iface->state->offer->cookie == 0) {
   1074 		if (ifo->options & DHCPCD_IPV4LL) {
   1075 			iface->state->claims = 0;
   1076 			send_arp_announce(iface);
   1077 		} else
   1078 			start_discover(iface);
   1079 		return;
   1080 	} else {
   1081 		syslog(LOG_INFO, "%s: rebinding lease of %s",
   1082 		    iface->name, inet_ntoa(iface->state->lease.addr));
   1083 	}
   1084 	iface->state->state = DHS_REBOOT;
   1085 	iface->state->xid = dhcp_xid(iface);
   1086 	iface->state->lease.server.s_addr = 0;
   1087 	delete_timeout(NULL, iface);
   1088 	if (ifo->fallback)
   1089 		add_timeout_sec(ifo->reboot, start_fallback, iface);
   1090 	else if (ifo->options & DHCPCD_LASTLEASE &&
   1091 	    iface->state->lease.frominfo)
   1092 		add_timeout_sec(ifo->reboot, start_timeout, iface);
   1093 	else if (!(ifo->options & DHCPCD_INFORM &&
   1094 		options & (DHCPCD_MASTER | DHCPCD_DAEMONISED)))
   1095 		add_timeout_sec(ifo->reboot, start_expire, iface);
   1096 	/* Don't bother ARP checking as the server could NAK us first. */
   1097 	if (ifo->options & DHCPCD_INFORM)
   1098 		send_inform(iface);
   1099 	else
   1100 		send_request(iface);
   1101 }
   1102 
   1103 void
   1104 start_interface(void *arg)
   1105 {
   1106 	struct interface *iface = arg;
   1107 	struct if_options *ifo = iface->state->options;
   1108 	struct stat st;
   1109 	struct timeval now;
   1110 	uint32_t l;
   1111 	int nolease;
   1112 
   1113 	handle_carrier(iface->name);
   1114 	if (iface->carrier == LINK_DOWN) {
   1115 		syslog(LOG_INFO, "%s: waiting for carrier", iface->name);
   1116 		return;
   1117 	}
   1118 
   1119 	iface->start_uptime = uptime();
   1120 	free(iface->state->offer);
   1121 	iface->state->offer = NULL;
   1122 
   1123 	if (iface->state->arping_index < ifo->arping_len) {
   1124 		start_arping(iface);
   1125 		return;
   1126 	}
   1127 	if (ifo->options & DHCPCD_STATIC) {
   1128 		start_static(iface);
   1129 		return;
   1130 	}
   1131 	if (ifo->options & DHCPCD_INFORM) {
   1132 		start_inform(iface);
   1133 		return;
   1134 	}
   1135 	if (iface->hwlen == 0 && ifo->clientid[0] == '\0') {
   1136 		syslog(LOG_WARNING, "%s: needs a clientid to configure",
   1137 		    iface->name);
   1138 		drop_config(iface, "FAIL");
   1139 		close_sockets(iface);
   1140 		delete_timeout(NULL, iface);
   1141 		return;
   1142 	}
   1143 	/* We don't want to read the old lease if we NAK an old test */
   1144 	nolease = iface->state->offer && options & DHCPCD_TEST;
   1145 	if (!nolease)
   1146 		iface->state->offer = read_lease(iface);
   1147 	if (iface->state->offer) {
   1148 		get_lease(&iface->state->lease, iface->state->offer);
   1149 		iface->state->lease.frominfo = 1;
   1150 		if (iface->state->offer->cookie == 0) {
   1151 			if (iface->state->offer->yiaddr ==
   1152 			    iface->addr.s_addr)
   1153 			{
   1154 				free(iface->state->offer);
   1155 				iface->state->offer = NULL;
   1156 			}
   1157 		} else if (iface->state->lease.leasetime != ~0U &&
   1158 		    stat(iface->leasefile, &st) == 0)
   1159 		{
   1160 			/* Offset lease times and check expiry */
   1161 			gettimeofday(&now, NULL);
   1162 			if ((time_t)iface->state->lease.leasetime <
   1163 			    (time_t)(now.tv_sec - st.st_mtime))
   1164 			{
   1165 				syslog(LOG_DEBUG,
   1166 				    "%s: discarding expired lease",
   1167 				    iface->name);
   1168 				free(iface->state->offer);
   1169 				iface->state->offer = NULL;
   1170 				iface->state->lease.addr.s_addr = 0;
   1171 			} else {
   1172 				l = now.tv_sec - st.st_mtime;
   1173 				iface->state->lease.leasetime -= l;
   1174 				iface->state->lease.renewaltime -= l;
   1175 				iface->state->lease.rebindtime -= l;
   1176 			}
   1177 		}
   1178 	}
   1179 	if (iface->state->offer == NULL)
   1180 		start_discover(iface);
   1181 	else if (iface->state->offer->cookie == 0 &&
   1182 	    iface->state->options->options & DHCPCD_IPV4LL)
   1183 		start_ipv4ll(iface);
   1184 	else
   1185 		start_reboot(iface);
   1186 }
   1187 
   1188 static void
   1189 init_state(struct interface *iface, int argc, char **argv)
   1190 {
   1191 	struct if_state *ifs;
   1192 
   1193 	if (iface->state)
   1194 		ifs = iface->state;
   1195 	else
   1196 		ifs = iface->state = xzalloc(sizeof(*ifs));
   1197 
   1198 	ifs->state = DHS_INIT;
   1199 	ifs->reason = "PREINIT";
   1200 	ifs->nakoff = 1;
   1201 	configure_interface(iface, argc, argv);
   1202 	if (!(options & DHCPCD_TEST))
   1203 		run_script(iface);
   1204 	/* We need to drop the leasefile so that start_interface
   1205 	 * doesn't load it. */
   1206 	if (ifs->options->options & DHCPCD_REQUEST)
   1207 		unlink(iface->leasefile);
   1208 
   1209 	if (ifs->options->options & DHCPCD_LINK) {
   1210 		switch (carrier_status(iface)) {
   1211 		case 0:
   1212 			iface->carrier = LINK_DOWN;
   1213 			ifs->reason = "NOCARRIER";
   1214 			break;
   1215 		case 1:
   1216 			iface->carrier = LINK_UP;
   1217 			ifs->reason = "CARRIER";
   1218 			break;
   1219 		default:
   1220 			iface->carrier = LINK_UNKNOWN;
   1221 			return;
   1222 		}
   1223 		if (!(options & DHCPCD_TEST))
   1224 			run_script(iface);
   1225 	} else
   1226 		iface->carrier = LINK_UNKNOWN;
   1227 }
   1228 
   1229 void
   1230 handle_interface(int action, const char *ifname)
   1231 {
   1232 	struct interface *ifs, *ifp, *ifn, *ifl = NULL;
   1233 	const char * const argv[] = { ifname };
   1234 	int i;
   1235 
   1236 	if (action == -1) {
   1237 		ifp = find_interface(ifname);
   1238 		if (ifp != NULL)
   1239 			stop_interface(ifp);
   1240 		return;
   1241 	} else if (action == 0) {
   1242 		handle_carrier(ifname);
   1243 		return;
   1244 	}
   1245 
   1246 	/* If running off an interface list, check it's in it. */
   1247 	if (ifc) {
   1248 		for (i = 0; i < ifc; i++)
   1249 			if (strcmp(ifv[i], ifname) == 0)
   1250 				break;
   1251 		if (i >= ifc)
   1252 			return;
   1253 	}
   1254 
   1255 	ifs = discover_interfaces(-1, UNCONST(argv));
   1256 	for (ifp = ifs; ifp; ifp = ifp->next) {
   1257 		if (strcmp(ifp->name, ifname) != 0)
   1258 			continue;
   1259 		/* Check if we already have the interface */
   1260 		for (ifn = ifaces; ifn; ifn = ifn->next) {
   1261 			if (strcmp(ifn->name, ifp->name) == 0)
   1262 				break;
   1263 			ifl = ifn;
   1264 		}
   1265 		if (ifn) {
   1266 			/* The flags and hwaddr could have changed */
   1267 			ifn->flags = ifp->flags;
   1268 			ifn->hwlen = ifp->hwlen;
   1269 			if (ifp->hwlen != 0)
   1270 				memcpy(ifn->hwaddr, ifp->hwaddr, ifn->hwlen);
   1271 		} else {
   1272 			if (ifl)
   1273 				ifl->next = ifp;
   1274 			else
   1275 				ifaces = ifp;
   1276 		}
   1277 		init_state(ifp, 0, NULL);
   1278 		start_interface(ifp);
   1279 	}
   1280 }
   1281 
   1282 #ifdef RTM_CHGADDR
   1283 void
   1284 handle_hwaddr(const char *ifname, unsigned char *hwaddr, size_t hwlen)
   1285 {
   1286 	struct interface *ifp;
   1287 	struct if_options *ifo;
   1288 
   1289 	for (ifp = ifaces; ifp; ifp = ifp->next)
   1290 		if (strcmp(ifp->name, ifname) == 0 && ifp->hwlen <= hwlen) {
   1291 			ifo = ifp->state->options;
   1292 			if (!(ifo->options &
   1293 			    (DHCPCD_INFORM | DHCPCD_STATIC | DHCPCD_CLIENTID))
   1294 	    		    && ifp->state->new != NULL &&
   1295 			    ifp->state->new->cookie == htonl(MAGIC_COOKIE))
   1296 			{
   1297 				syslog(LOG_INFO,
   1298 				    "%s: expiring for new hardware address",
   1299 				    ifp->name);
   1300 				drop_config(ifp, "EXPIRE");
   1301 			}
   1302 			memcpy(ifp->hwaddr, hwaddr, hwlen);
   1303 			ifp->hwlen = hwlen;
   1304 			if (!(ifo->options &
   1305 			    (DHCPCD_INFORM | DHCPCD_STATIC | DHCPCD_CLIENTID)))
   1306 			{
   1307 				syslog(LOG_DEBUG, "%s: using hwaddr %s",
   1308 				    ifp->name,
   1309 		    		    hwaddr_ntoa(ifp->hwaddr, ifp->hwlen));
   1310 				ifp->state->interval = 0;
   1311 				ifp->state->nakoff = 1;
   1312 				start_interface(ifp);
   1313 			}
   1314 		}
   1315 	free(hwaddr);
   1316 }
   1317 #endif
   1318 
   1319 void
   1320 handle_ifa(int type, const char *ifname,
   1321     struct in_addr *addr, struct in_addr *net, struct in_addr *dst)
   1322 {
   1323 	struct interface *ifp;
   1324 	struct if_options *ifo;
   1325 	int i;
   1326 
   1327 	if (addr->s_addr == INADDR_ANY)
   1328 		return;
   1329 	for (ifp = ifaces; ifp; ifp = ifp->next)
   1330 		if (strcmp(ifp->name, ifname) == 0)
   1331 			break;
   1332 	if (ifp == NULL)
   1333 		return;
   1334 	ifo = ifp->state->options;
   1335 	if ((ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC)) == 0 ||
   1336 	    ifo->req_addr.s_addr != INADDR_ANY)
   1337 		return;
   1338 
   1339 	switch (type) {
   1340 	case RTM_DELADDR:
   1341 		if (ifp->state->new &&
   1342 		    ifp->state->new->yiaddr == addr->s_addr)
   1343 			drop_config(ifp, "EXPIRE");
   1344 		break;
   1345 	case RTM_NEWADDR:
   1346 		free(ifp->state->old);
   1347 		ifp->state->old = ifp->state->new;
   1348 		ifp->state->new = dhcp_message_new(addr, net);
   1349 		ifp->dst.s_addr = dst ? dst->s_addr : INADDR_ANY;
   1350 		if (dst) {
   1351 			for (i = 1; i < 255; i++)
   1352 				if (i != DHO_ROUTER &&
   1353 				    has_option_mask(ifo->dstmask, i))
   1354 					dhcp_message_add_addr(
   1355 						ifp->state->new,
   1356 						i, *dst);
   1357 		}
   1358 		ifp->state->reason = "STATIC";
   1359 		build_routes();
   1360 		run_script(ifp);
   1361 		if (ifo->options & DHCPCD_INFORM) {
   1362 			ifp->state->state = DHS_INFORM;
   1363 			ifp->state->xid = dhcp_xid(ifp);
   1364 			ifp->state->lease.server.s_addr =
   1365 			    dst ? dst->s_addr : INADDR_ANY;
   1366 			ifp->addr = *addr;
   1367 			ifp->net = *net;
   1368 			send_inform(ifp);
   1369 		}
   1370 		break;
   1371 	}
   1372 }
   1373 
   1374 /* ARGSUSED */
   1375 static void
   1376 handle_link(_unused void *arg)
   1377 {
   1378 	if (manage_link(linkfd) == -1)
   1379 		syslog(LOG_ERR, "manage_link: %m");
   1380 }
   1381 
   1382 static void
   1383 if_reboot(struct interface *iface, int argc, char **argv)
   1384 {
   1385 	const struct if_options *ifo;
   1386 	int opt;
   1387 
   1388 	ifo = iface->state->options;
   1389 	opt = ifo->options;
   1390 	configure_interface(iface, argc, argv);
   1391 	ifo = iface->state->options;
   1392 	iface->state->interval = 0;
   1393 	if ((ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC) &&
   1394 		iface->addr.s_addr != ifo->req_addr.s_addr) ||
   1395 	    (opt & (DHCPCD_INFORM | DHCPCD_STATIC) &&
   1396 		!(ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))))
   1397 	{
   1398 		drop_config(iface, "EXPIRE");
   1399 	} else {
   1400 		free(iface->state->offer);
   1401 		iface->state->offer = NULL;
   1402 	}
   1403 	start_interface(iface);
   1404 }
   1405 
   1406 static void
   1407 reconf_reboot(int action, int argc, char **argv, int oi)
   1408 {
   1409 	struct interface *ifl, *ifn, *ifp, *ifs, *ift;
   1410 
   1411 	ifs = discover_interfaces(argc - oi, argv + oi);
   1412 	if (ifs == NULL)
   1413 		return;
   1414 
   1415 	/* Remove any old interfaces */
   1416 	if (ifaces) {
   1417 		for (ifl = NULL; ifl != ifaces;) {
   1418 			/* Work our way backwards */
   1419 			for (ifp = ifaces; ifp; ifp = ifp->next)
   1420 				if (ifp->next == ifl) {
   1421 					ifl = ifp;
   1422 					break;
   1423 				}
   1424 			for (ifn = ifs; ifn; ifn = ifn->next)
   1425 				if (strcmp(ifn->name, ifp->name) == 0)
   1426 					break;
   1427 			if (ifn == NULL) {
   1428 				ifl = ifp->next;
   1429 				stop_interface(ifp);
   1430 			}
   1431 		}
   1432 	}
   1433 
   1434 	for (ifp = ifs; ifp && (ift = ifp->next, 1); ifp = ift) {
   1435 		ifl = NULL;
   1436 		for (ifn = ifaces; ifn; ifn = ifn->next) {
   1437 			if (strcmp(ifn->name, ifp->name) == 0)
   1438 				break;
   1439 			ifl = ifn;
   1440 		}
   1441 		if (ifn) {
   1442 			if (action)
   1443 				if_reboot(ifn, argc, argv);
   1444 			else if (ifn->state->new)
   1445 				configure(ifn);
   1446 			free_interface(ifp);
   1447 		} else {
   1448 			ifp->next = NULL;
   1449 			init_state(ifp, argc, argv);
   1450 			start_interface(ifp);
   1451 			if (ifl)
   1452 				ifl->next = ifp;
   1453 			else
   1454 				ifaces = ifp;
   1455 		}
   1456 	}
   1457 
   1458 	sort_interfaces();
   1459 }
   1460 
   1461 /* ARGSUSED */
   1462 static void
   1463 handle_signal(_unused void *arg)
   1464 {
   1465 	struct interface *ifp, *ifl;
   1466 	struct if_options *ifo;
   1467 	int sig = signal_read();
   1468 	int do_release, do_rebind, i;
   1469 
   1470 	do_rebind = do_release = 0;
   1471 	switch (sig) {
   1472 	case SIGINT:
   1473 		syslog(LOG_INFO, "received SIGINT, stopping");
   1474 		break;
   1475 	case SIGTERM:
   1476 		syslog(LOG_INFO, "received SIGTERM, stopping");
   1477 		break;
   1478 	case SIGALRM:
   1479 #ifdef ANDROID
   1480 		syslog(LOG_INFO, "received SIGALRM, renewing");
   1481 		for (ifp = ifaces; ifp; ifp = ifp->next) {
   1482 			start_renew(ifp);
   1483 		}
   1484 #else
   1485 		syslog(LOG_INFO, "received SIGALRM, rebinding");
   1486 		for (i = 0; i < ifac; i++)
   1487 			free(ifav[i]);
   1488 		free(ifav);
   1489 		ifav = NULL;
   1490 		ifac = 0;
   1491 		for (i = 0; i < ifdc; i++)
   1492 			free(ifdv[i]);
   1493 		free(ifdv);
   1494 		ifdc = 0;
   1495 		ifdv = NULL;
   1496 		ifo = read_config(cffile, NULL, NULL, NULL);
   1497 		add_options(ifo, margc, margv);
   1498 		/* We need to preserve these two options. */
   1499 		if (options & DHCPCD_MASTER)
   1500 			ifo->options |= DHCPCD_MASTER;
   1501 		if (options & DHCPCD_DAEMONISED)
   1502 			ifo->options |= DHCPCD_DAEMONISED;
   1503 		options = ifo->options;
   1504 		free_options(ifo);
   1505 		reconf_reboot(1, 0, NULL, 0);
   1506 #endif
   1507 		return;
   1508 	case SIGHUP:
   1509 		syslog(LOG_INFO, "received SIGHUP, releasing");
   1510 		do_release = 1;
   1511 		break;
   1512 	case SIGUSR1:
   1513 		syslog(LOG_INFO, "received SIGUSR, reconfiguring");
   1514 		for (ifp = ifaces; ifp; ifp = ifp->next)
   1515 			if (ifp->state->new)
   1516 				configure(ifp);
   1517 		return;
   1518 	case SIGPIPE:
   1519 		syslog(LOG_WARNING, "received SIGPIPE");
   1520 		return;
   1521 	default:
   1522 		syslog(LOG_ERR,
   1523 		    "received signal %d, but don't know what to do with it",
   1524 		    sig);
   1525 		return;
   1526 	}
   1527 
   1528 	if (options & DHCPCD_TEST)
   1529 		exit(EXIT_FAILURE);
   1530 
   1531 	/* As drop_config could re-arrange the order, we do it like this. */
   1532 	for (;;) {
   1533 		/* Be sane and drop the last config first */
   1534 		ifl = NULL;
   1535 		for (ifp = ifaces; ifp; ifp = ifp->next) {
   1536 			if (ifp->next == NULL)
   1537 				break;
   1538 			ifl = ifp;
   1539 		}
   1540 		if (ifp == NULL)
   1541 			break;
   1542 		if (ifp->carrier != LINK_DOWN &&
   1543 		    (do_release ||
   1544 			ifp->state->options->options & DHCPCD_RELEASE))
   1545 			send_release(ifp);
   1546 		stop_interface(ifp);
   1547 	}
   1548 	exit(EXIT_FAILURE);
   1549 }
   1550 
   1551 int
   1552 handle_args(struct fd_list *fd, int argc, char **argv)
   1553 {
   1554 	struct interface *ifp;
   1555 	int do_exit = 0, do_release = 0, do_reboot = 0, do_reconf = 0;
   1556 	int opt, oi = 0;
   1557 	ssize_t len;
   1558 	size_t l;
   1559 	struct iovec iov[2];
   1560 	char *tmp, *p;
   1561 
   1562 	if (fd != NULL) {
   1563 		/* Special commands for our control socket */
   1564 		if (strcmp(*argv, "--version") == 0) {
   1565 			len = strlen(VERSION) + 1;
   1566 			iov[0].iov_base = &len;
   1567 			iov[0].iov_len = sizeof(ssize_t);
   1568 			iov[1].iov_base = UNCONST(VERSION);
   1569 			iov[1].iov_len = len;
   1570 			if (writev(fd->fd, iov, 2) == -1) {
   1571 				syslog(LOG_ERR, "writev: %m");
   1572 				return -1;
   1573 			}
   1574 			return 0;
   1575 		} else if (strcmp(*argv, "--getconfigfile") == 0) {
   1576 			len = strlen(cffile ? cffile : CONFIG) + 1;
   1577 			iov[0].iov_base = &len;
   1578 			iov[0].iov_len = sizeof(ssize_t);
   1579 			iov[1].iov_base = cffile ? cffile : UNCONST(CONFIG);
   1580 			iov[1].iov_len = len;
   1581 			if (writev(fd->fd, iov, 2) == -1) {
   1582 				syslog(LOG_ERR, "writev: %m");
   1583 				return -1;
   1584 			}
   1585 			return 0;
   1586 		} else if (strcmp(*argv, "--getinterfaces") == 0) {
   1587 			len = 0;
   1588 			if (argc == 1) {
   1589 				for (ifp = ifaces; ifp; ifp = ifp->next)
   1590 					len++;
   1591 				len = write(fd->fd, &len, sizeof(len));
   1592 				if (len != sizeof(len))
   1593 					return -1;
   1594 				for (ifp = ifaces; ifp; ifp = ifp->next)
   1595 					send_interface(fd->fd, ifp);
   1596 				return 0;
   1597 			}
   1598 			opt = 0;
   1599 			while (argv[++opt] != NULL) {
   1600 				for (ifp = ifaces; ifp; ifp = ifp->next)
   1601 					if (strcmp(argv[opt], ifp->name) == 0)
   1602 						len++;
   1603 			}
   1604 			len = write(fd->fd, &len, sizeof(len));
   1605 			if (len != sizeof(len))
   1606 				return -1;
   1607 			opt = 0;
   1608 			while (argv[++opt] != NULL) {
   1609 				for (ifp = ifaces; ifp; ifp = ifp->next)
   1610 					if (strcmp(argv[opt], ifp->name) == 0)
   1611 						send_interface(fd->fd, ifp);
   1612 			}
   1613 			return 0;
   1614 		} else if (strcmp(*argv, "--listen") == 0) {
   1615 			fd->listener = 1;
   1616 			return 0;
   1617 		}
   1618 	}
   1619 
   1620 	/* Log the command */
   1621 	len = 0;
   1622 	for (opt = 0; opt < argc; opt++)
   1623 		len += strlen(argv[opt]) + 1;
   1624 	tmp = p = xmalloc(len + 1);
   1625 	for (opt = 0; opt < argc; opt++) {
   1626 		l = strlen(argv[opt]);
   1627 		strlcpy(p, argv[opt], l + 1);
   1628 		p += l;
   1629 		*p++ = ' ';
   1630 	}
   1631 	*--p = '\0';
   1632 	syslog(LOG_INFO, "control command: %s", tmp);
   1633 	free(tmp);
   1634 
   1635 	optind = 0;
   1636 	while ((opt = getopt_long(argc, argv, IF_OPTS, cf_options, &oi)) != -1)
   1637 	{
   1638 		switch (opt) {
   1639 		case 'g':
   1640 			do_reconf = 1;
   1641 			break;
   1642 		case 'k':
   1643 			do_release = 1;
   1644 			break;
   1645 		case 'n':
   1646 			do_reboot = 1;
   1647 			break;
   1648 		case 'x':
   1649 			do_exit = 1;
   1650 			break;
   1651 		}
   1652 	}
   1653 
   1654 	/* We need at least one interface */
   1655 	if (optind == argc) {
   1656 		syslog(LOG_ERR, "handle_args: no interface");
   1657 		return -1;
   1658 	}
   1659 
   1660 	if (do_release || do_exit) {
   1661 		for (oi = optind; oi < argc; oi++) {
   1662 			for (ifp = ifaces; ifp; ifp = ifp->next)
   1663 				if (strcmp(ifp->name, argv[oi]) == 0)
   1664 					break;
   1665 			if (!ifp)
   1666 				continue;
   1667 			if (do_release)
   1668 				ifp->state->options->options |= DHCPCD_RELEASE;
   1669 			if (ifp->state->options->options & DHCPCD_RELEASE &&
   1670 			    ifp->carrier != LINK_DOWN)
   1671 				send_release(ifp);
   1672 			stop_interface(ifp);
   1673 		}
   1674 		return 0;
   1675 	}
   1676 
   1677 	reconf_reboot(do_reboot, argc, argv, optind);
   1678 	return 0;
   1679 }
   1680 
   1681 void
   1682 open_sockets(struct interface *iface)
   1683 {
   1684 	if (iface->raw_fd == -1) {
   1685 		if (open_socket(iface, ETHERTYPE_IP) == -1)
   1686 			syslog(LOG_ERR, "%s: open_socket: %m", iface->name);
   1687 		else
   1688 			add_event(iface->raw_fd, handle_dhcp_packet, iface);
   1689 	}
   1690 	if (iface->udp_fd == -1 &&
   1691 	    iface->addr.s_addr != 0 &&
   1692 	    iface->state->new != NULL &&
   1693 	    (iface->state->new->cookie == htonl(MAGIC_COOKIE) ||
   1694 	    iface->state->options->options & DHCPCD_INFORM))
   1695 	{
   1696 		if (open_udp_socket(iface) == -1 && errno != EADDRINUSE)
   1697 			syslog(LOG_ERR, "%s: open_udp_socket: %m", iface->name);
   1698 	}
   1699 }
   1700 
   1701 void
   1702 close_sockets(struct interface *iface)
   1703 {
   1704 	if (iface->arp_fd != -1) {
   1705 		delete_event(iface->arp_fd);
   1706 		close(iface->arp_fd);
   1707 		iface->arp_fd = -1;
   1708 	}
   1709 	if (iface->raw_fd != -1) {
   1710 		delete_event(iface->raw_fd);
   1711 		close(iface->raw_fd);
   1712 		iface->raw_fd = -1;
   1713 	}
   1714 	if (iface->udp_fd != -1) {
   1715 		/* we don't listen to events on the udp */
   1716 		close(iface->udp_fd);
   1717 		iface->udp_fd = -1;
   1718 	}
   1719 }
   1720 
   1721 #ifdef ANDROID
   1722 void switchUser(void)
   1723 {
   1724 	gid_t groups[] = { AID_INET, AID_SHELL };
   1725 	struct __user_cap_header_struct header;
   1726 	struct __user_cap_data_struct cap;
   1727 
   1728 	setgroups(sizeof(groups)/sizeof(groups[0]), groups);
   1729 
   1730 	prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
   1731 
   1732 	setgid(AID_DHCP);
   1733 	setuid(AID_DHCP);
   1734 	header.version = _LINUX_CAPABILITY_VERSION;
   1735 	header.pid = 0;
   1736 	cap.effective = cap.permitted =
   1737 		(1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW) |
   1738 		(1 << CAP_NET_BROADCAST) | (1 << CAP_NET_BIND_SERVICE);
   1739 	cap.inheritable = 0;
   1740 	capset(&header, &cap);
   1741 }
   1742 #endif /* ANDROID */
   1743 
   1744 int
   1745 main(int argc, char **argv)
   1746 {
   1747 	struct interface *iface;
   1748 	int opt, oi = 0, signal_fd, sig = 0, i, control_fd;
   1749 	size_t len;
   1750 	pid_t pid;
   1751 	struct timespec ts;
   1752 
   1753 #ifdef ANDROID
   1754 	/* Reuse system properties for a p2p interface */
   1755 	char p2p_interface[PROPERTY_KEY_MAX];
   1756 	switchUser();
   1757 #endif
   1758 	closefrom(3);
   1759 	openlog(PACKAGE, LOG_PERROR | LOG_PID, LOG_DAEMON);
   1760 	setlogmask(LOG_UPTO(LOG_INFO));
   1761 
   1762 	/* Test for --help and --version */
   1763 	if (argc > 1) {
   1764 		if (strcmp(argv[1], "--help") == 0) {
   1765 			usage();
   1766 			exit(EXIT_SUCCESS);
   1767 		} else if (strcmp(argv[1], "--version") == 0) {
   1768 			printf(""PACKAGE" "VERSION"\n%s\n", copyright);
   1769 			exit(EXIT_SUCCESS);
   1770 		}
   1771 	}
   1772 
   1773 	i = 0;
   1774 	while ((opt = getopt_long(argc, argv, IF_OPTS, cf_options, &oi)) != -1)
   1775 	{
   1776 		switch (opt) {
   1777 		case 'f':
   1778 			cffile = optarg;
   1779 			break;
   1780 		case 'g':
   1781 			sig = SIGUSR1;
   1782 			break;
   1783 		case 'k':
   1784 			sig = SIGHUP;
   1785 			break;
   1786 		case 'n':
   1787 			sig = SIGALRM;
   1788 			break;
   1789 		case 'x':
   1790 			sig = SIGTERM;
   1791 			break;
   1792 		case 'T':
   1793 			i = 1;
   1794 			break;
   1795 		case 'U':
   1796 			i = 2;
   1797 			break;
   1798 		case 'a':
   1799 			avoid_routes = 1;
   1800 			break;
   1801 		case 'V':
   1802 			print_options();
   1803 			exit(EXIT_SUCCESS);
   1804 		case '?':
   1805 			usage();
   1806 			exit(EXIT_FAILURE);
   1807 		}
   1808 	}
   1809 
   1810 	margv = argv;
   1811 	margc = argc;
   1812 	if_options = read_config(cffile, NULL, NULL, NULL);
   1813 	opt = add_options(if_options, argc, argv);
   1814 	if (opt != 1) {
   1815 		if (opt == 0)
   1816 			usage();
   1817 		exit(EXIT_FAILURE);
   1818 	}
   1819 	options = if_options->options;
   1820 	if (i != 0) {
   1821 		if (i == 1)
   1822 			options |= DHCPCD_TEST;
   1823 		else
   1824 			options |= DHCPCD_DUMPLEASE;
   1825 		options |= DHCPCD_PERSISTENT;
   1826 		options &= ~DHCPCD_DAEMONISE;
   1827 	}
   1828 
   1829 #ifdef THERE_IS_NO_FORK
   1830 	options &= ~DHCPCD_DAEMONISE;
   1831 #endif
   1832 
   1833 	if (options & DHCPCD_DEBUG)
   1834 		setlogmask(LOG_UPTO(LOG_DEBUG));
   1835 	if (options & DHCPCD_QUIET)
   1836 		close(STDERR_FILENO);
   1837 
   1838 	if (!(options & (DHCPCD_TEST | DHCPCD_DUMPLEASE))) {
   1839 		/* If we have any other args, we should run as a single dhcpcd
   1840 		 *  instance for that interface. */
   1841 		len = strlen(PIDFILE) + IF_NAMESIZE + 2;
   1842 		pidfile = xmalloc(len);
   1843 		if (optind == argc - 1)
   1844 			snprintf(pidfile, len, PIDFILE, "-", argv[optind]);
   1845 		else {
   1846 			snprintf(pidfile, len, PIDFILE, "", "");
   1847 			options |= DHCPCD_MASTER;
   1848 		}
   1849 	}
   1850 
   1851 	if (chdir("/") == -1)
   1852 		syslog(LOG_ERR, "chdir `/': %m");
   1853 	atexit(cleanup);
   1854 
   1855 	if (options & DHCPCD_DUMPLEASE) {
   1856 		if (optind != argc - 1) {
   1857 			syslog(LOG_ERR, "dumplease requires an interface");
   1858 			exit(EXIT_FAILURE);
   1859 		}
   1860 		ifaces = iface = xzalloc(sizeof(*iface));
   1861 		strlcpy(iface->name, argv[optind], sizeof(iface->name));
   1862 		snprintf(iface->leasefile, sizeof(iface->leasefile),
   1863 		    LEASEFILE, iface->name);
   1864 		iface->state = xzalloc(sizeof(*iface->state));
   1865 		iface->state->options = xzalloc(sizeof(*iface->state->options));
   1866 		strlcpy(iface->state->options->script, if_options->script,
   1867 		    sizeof(iface->state->options->script));
   1868 		iface->state->new = read_lease(iface);
   1869 		if (iface->state->new == NULL && errno == ENOENT) {
   1870 			strlcpy(iface->leasefile, argv[optind],
   1871 			    sizeof(iface->leasefile));
   1872 			iface->state->new = read_lease(iface);
   1873 		}
   1874 		if (iface->state->new == NULL) {
   1875 			if (errno == ENOENT)
   1876 				syslog(LOG_ERR, "%s: no lease to dump",
   1877 				    iface->name);
   1878 			exit(EXIT_FAILURE);
   1879 		}
   1880 		iface->state->reason = "DUMP";
   1881 		run_script(iface);
   1882 		exit(EXIT_SUCCESS);
   1883 	}
   1884 
   1885 	if (!(options & (DHCPCD_MASTER | DHCPCD_TEST))) {
   1886 		control_fd = open_control();
   1887 		if (control_fd != -1) {
   1888 			syslog(LOG_INFO,
   1889 			    "sending commands to master dhcpcd process");
   1890 			i = send_control(argc, argv);
   1891 			if (i > 0) {
   1892 				syslog(LOG_DEBUG, "send OK");
   1893 				exit(EXIT_SUCCESS);
   1894 			} else {
   1895 				syslog(LOG_ERR, "failed to send commands");
   1896 				exit(EXIT_FAILURE);
   1897 			}
   1898 		} else {
   1899 			if (errno != ENOENT)
   1900 				syslog(LOG_ERR, "open_control: %m");
   1901 		}
   1902 	}
   1903 
   1904 #ifndef ANDROID
   1905 	/* android runs us as user "dhcp" */
   1906 	if (geteuid())
   1907 		syslog(LOG_WARNING,
   1908 		    PACKAGE " will not work correctly unless run as root");
   1909 #endif
   1910 	if (sig != 0) {
   1911 #ifdef ANDROID
   1912 		char pidpropname[PROPERTY_KEY_MAX];
   1913 		char pidpropval[PROPERTY_VALUE_MAX];
   1914 
   1915 		if (optind != argc - 1) {
   1916 			syslog(LOG_ERR, "Android requires an interface");
   1917 			exit(EXIT_FAILURE);
   1918 		}
   1919 
   1920 		if (strncmp(argv[optind], "p2p", 3) == 0) {
   1921 			strncpy(p2p_interface, "p2p", sizeof(p2p_interface));
   1922 		} else {
   1923 			strncpy(p2p_interface, argv[optind], sizeof(p2p_interface));
   1924 		}
   1925 
   1926 		if (snprintf(pidpropname,
   1927 			     sizeof(pidpropname),
   1928 			     "dhcp.%s.pid", p2p_interface) >= PROPERTY_KEY_MAX)
   1929 			exit(EXIT_FAILURE);
   1930 		property_get(pidpropname, pidpropval, NULL);
   1931 		if (strlen(pidpropval) == 0)
   1932 			exit(EXIT_FAILURE);
   1933 		pid = atoi(pidpropval);
   1934 #else
   1935 		pid = read_pid();
   1936 #endif
   1937 		if (pid != 0)
   1938 			syslog(LOG_INFO, "sending signal %d to pid %d",
   1939 			    sig, pid);
   1940 		if (pid == 0 || kill(pid, sig) != 0) {
   1941 			if (sig != SIGALRM)
   1942 				syslog(LOG_ERR, ""PACKAGE" not running");
   1943 			if (pid != 0 && errno != ESRCH) {
   1944 				syslog(LOG_ERR, "kill: %m");
   1945 				exit(EXIT_FAILURE);
   1946 			}
   1947 			unlink(pidfile);
   1948 			if (sig != SIGALRM)
   1949 				exit(EXIT_FAILURE);
   1950 		} else {
   1951 			if (sig == SIGALRM)
   1952 				exit(EXIT_SUCCESS);
   1953 			/* Spin until it exits */
   1954 			syslog(LOG_INFO, "waiting for pid %d to exit", pid);
   1955 			ts.tv_sec = 0;
   1956 			ts.tv_nsec = 100000000; /* 10th of a second */
   1957 			for(i = 0; i < 100; i++) {
   1958 				nanosleep(&ts, NULL);
   1959 				if (read_pid() == 0)
   1960 					exit(EXIT_SUCCESS);
   1961 			}
   1962 			syslog(LOG_ERR, "pid %d failed to exit", pid);
   1963 			exit(EXIT_FAILURE);
   1964 		}
   1965 	}
   1966 
   1967 	if (!(options & DHCPCD_TEST)) {
   1968 #ifdef ANDROID
   1969 		char pidpropname[PROPERTY_KEY_MAX];
   1970 		char pidpropval[PROPERTY_VALUE_MAX];
   1971 #endif
   1972 #ifndef ANDROID
   1973 		if ((pid = read_pid()) > 0 &&
   1974 		    kill(pid, 0) == 0)
   1975 		{
   1976 			syslog(LOG_ERR, ""PACKAGE
   1977 			    " already running on pid %d (%s)",
   1978 			    pid, pidfile);
   1979 			exit(EXIT_FAILURE);
   1980 		}
   1981 
   1982 		/* Ensure we have the needed directories */
   1983 		if (mkdir(RUNDIR, 0755) == -1 && errno != EEXIST) {
   1984 			syslog(LOG_ERR, "mkdir `%s': %m", RUNDIR);
   1985 			exit(EXIT_FAILURE);
   1986 		}
   1987 		if (mkdir(DBDIR, 0755) == -1 && errno != EEXIST) {
   1988 			syslog(LOG_ERR, "mkdir `%s': %m", DBDIR);
   1989 			exit(EXIT_FAILURE);
   1990 		}
   1991 #endif
   1992 		pidfd = open(pidfile, O_WRONLY | O_CREAT | O_NONBLOCK, 0664);
   1993 		if (pidfd == -1) {
   1994 			syslog(LOG_ERR, "open `%s': %m", pidfile);
   1995 			exit(EXIT_FAILURE);
   1996 		}
   1997 		/* Lock the file so that only one instance of dhcpcd runs
   1998 		 * on an interface */
   1999 		if (flock(pidfd, LOCK_EX | LOCK_NB) == -1) {
   2000 			syslog(LOG_ERR, "flock `%s': %m", pidfile);
   2001 			exit(EXIT_FAILURE);
   2002 		}
   2003 		if (set_cloexec(pidfd) == -1)
   2004 			exit(EXIT_FAILURE);
   2005 #ifdef ANDROID
   2006 		if (optind != argc - 1) {
   2007 			syslog(LOG_ERR, "Android requires an interface");
   2008 			exit(EXIT_FAILURE);
   2009 		}
   2010 
   2011 		if (strncmp(argv[optind], "p2p", 3) == 0) {
   2012 			strncpy(p2p_interface, "p2p", sizeof(p2p_interface));
   2013 		} else {
   2014 			strncpy(p2p_interface, argv[optind], sizeof(p2p_interface));
   2015 		}
   2016 
   2017 		if (snprintf(pidpropname,
   2018 			     sizeof(pidpropname),
   2019 			     "dhcp.%s.pid", p2p_interface) >= PROPERTY_KEY_MAX)
   2020 			exit(EXIT_FAILURE);
   2021 		if (snprintf(pidpropval, sizeof(pidpropval), "%d", getpid()) >= PROPERTY_VALUE_MAX)
   2022 			exit(EXIT_FAILURE);
   2023 		property_set(pidpropname, pidpropval);
   2024 #else
   2025 		writepid(pidfd, getpid());
   2026 #endif
   2027 	}
   2028 
   2029 	syslog(LOG_INFO, "version " VERSION " starting");
   2030 
   2031 	if ((signal_fd = signal_init()) == -1)
   2032 		exit(EXIT_FAILURE);
   2033 	if (signal_setup() == -1)
   2034 		exit(EXIT_FAILURE);
   2035 	add_event(signal_fd, handle_signal, NULL);
   2036 
   2037 	if (options & DHCPCD_MASTER) {
   2038 		if (start_control() == -1) {
   2039 			syslog(LOG_ERR, "start_control: %m");
   2040 			exit(EXIT_FAILURE);
   2041 		}
   2042 	}
   2043 
   2044 	if (init_sockets() == -1) {
   2045 		syslog(LOG_ERR, "init_socket: %m");
   2046 		exit(EXIT_FAILURE);
   2047 	}
   2048 	if (if_options->options & DHCPCD_LINK) {
   2049 		linkfd = open_link_socket();
   2050 		if (linkfd == -1)
   2051 			syslog(LOG_ERR, "open_link_socket: %m");
   2052 		else
   2053 			add_event(linkfd, handle_link, NULL);
   2054 	}
   2055 
   2056 	ifc = argc - optind;
   2057 	ifv = argv + optind;
   2058 
   2059 	/* When running dhcpcd against a single interface, we need to retain
   2060 	 * the old behaviour of waiting for an IP address */
   2061 	if (ifc == 1)
   2062 		options |= DHCPCD_WAITIP;
   2063 
   2064 	ifaces = discover_interfaces(ifc, ifv);
   2065 	for (i = 0; i < ifc; i++) {
   2066 		for (iface = ifaces; iface; iface = iface->next)
   2067 			if (strcmp(iface->name, ifv[i]) == 0)
   2068 				break;
   2069 		if (!iface)
   2070 			syslog(LOG_ERR, "%s: interface not found or invalid",
   2071 			    ifv[i]);
   2072 	}
   2073 	if (!ifaces) {
   2074 		if (ifc == 0)
   2075 			syslog(LOG_ERR, "no valid interfaces found");
   2076 		else
   2077 			exit(EXIT_FAILURE);
   2078 		if (!(options & DHCPCD_LINK)) {
   2079 			syslog(LOG_ERR,
   2080 			    "aborting as link detection is disabled");
   2081 			exit(EXIT_FAILURE);
   2082 		}
   2083 	}
   2084 
   2085 	if (options & DHCPCD_BACKGROUND)
   2086 		daemonise();
   2087 
   2088 	opt = 0;
   2089 	for (iface = ifaces; iface; iface = iface->next) {
   2090 		init_state(iface, argc, argv);
   2091 		if (iface->carrier != LINK_DOWN)
   2092 			opt = 1;
   2093 	}
   2094 
   2095 	if (!(options & DHCPCD_BACKGROUND)) {
   2096 		/* If we don't have a carrier, we may have to wait for a second
   2097 		 * before one becomes available if we brought an interface up. */
   2098 		if (opt == 0 &&
   2099 		    options & DHCPCD_LINK &&
   2100 		    options & DHCPCD_WAITUP &&
   2101 		    !(options & DHCPCD_WAITIP))
   2102 		{
   2103 			ts.tv_sec = 1;
   2104 			ts.tv_nsec = 0;
   2105 			nanosleep(&ts, NULL);
   2106 			for (iface = ifaces; iface; iface = iface->next) {
   2107 				handle_carrier(iface->name);
   2108 				if (iface->carrier != LINK_DOWN) {
   2109 					opt = 1;
   2110 					break;
   2111 				}
   2112 			}
   2113 		}
   2114 		if (opt == 0 &&
   2115 		    options & DHCPCD_LINK &&
   2116 		    !(options & DHCPCD_WAITIP))
   2117 		{
   2118 			syslog(LOG_WARNING, "no interfaces have a carrier");
   2119 			daemonise();
   2120 		} else if (if_options->timeout > 0) {
   2121 			if (options & DHCPCD_IPV4LL)
   2122 				options |= DHCPCD_TIMEOUT_IPV4LL;
   2123 			add_timeout_sec(if_options->timeout,
   2124 			    handle_exit_timeout, NULL);
   2125 		}
   2126 	}
   2127 	free_options(if_options);
   2128 	if_options = NULL;
   2129 
   2130 	sort_interfaces();
   2131 	for (iface = ifaces; iface; iface = iface->next)
   2132 		add_timeout_sec(0, start_interface, iface);
   2133 
   2134 	start_eloop();
   2135 	exit(EXIT_SUCCESS);
   2136 }
   2137