1/*
2 * dhcpcd - DHCP client daemon
3 * Copyright 2006-2008 Roy Marples <roy@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#include <sys/stat.h>
29#include <sys/time.h>
30#include <sys/types.h>
31#include <arpa/inet.h>
32
33#ifdef __linux__
34# include <netinet/ether.h>
35#endif
36
37#include <errno.h>
38#include <poll.h>
39#include <signal.h>
40#include <stdlib.h>
41#include <stdio.h>
42#include <string.h>
43#include <time.h>
44#include <unistd.h>
45
46#include "config.h"
47#include "common.h"
48#include "client.h"
49#include "configure.h"
50#include "dhcp.h"
51#include "dhcpcd.h"
52#include "net.h"
53#include "logger.h"
54#include "signals.h"
55
56#define IPV4LL_LEASETIME 	2
57
58/* Some platforms don't define INFTIM */
59#ifndef INFTIM
60# define INFTIM                 -1
61#endif
62
63#define STATE_INIT              0
64#define STATE_DISCOVERING	1
65#define STATE_REQUESTING        2
66#define STATE_BOUND             3
67#define STATE_RENEWING          4
68#define STATE_REBINDING         5
69#define STATE_REBOOT            6
70#define STATE_RENEW_REQUESTED   7
71#define STATE_INIT_IPV4LL	8
72#define STATE_PROBING		9
73#define STATE_ANNOUNCING	10
74
75/* Constants taken from RFC 2131. */
76#define T1			0.5
77#define T2			0.875
78#define DHCP_BASE		4
79#define DHCP_MAX		64
80#define DHCP_RAND_MIN		-1
81#define DHCP_RAND_MAX		1
82#define DHCP_ARP_FAIL		10
83
84/* We should define a maximum for the NAK exponential backoff */
85#define NAKOFF_MAX              60
86
87#define SOCKET_CLOSED           0
88#define SOCKET_OPEN             1
89
90/* These are for IPV4LL, RFC 3927. */
91#define PROBE_WAIT		 1
92#define PROBE_NUM		 3
93#define PROBE_MIN		 1
94#define PROBE_MAX		 2
95#define ANNOUNCE_WAIT		 2
96/* BSD systems always do a grauitous ARP when assigning an address,
97 * so we can do one less announce. */
98#ifdef BSD
99# define ANNOUNCE_NUM		 1
100#else
101# define ANNOUNCE_NUM		 2
102#endif
103#define ANNOUNCE_INTERVAL	 2
104#define MAX_CONFLICTS		10
105#define RATE_LIMIT_INTERVAL	60
106#define DEFEND_INTERVAL		10
107
108
109/* number of usecs in a second. */
110#define USECS_SECOND		1000000
111/* As we use timevals, we should use the usec part for
112 * greater randomisation. */
113#define DHCP_RAND_MIN_U		DHCP_RAND_MIN * USECS_SECOND
114#define DHCP_RAND_MAX_U		DHCP_RAND_MAX * USECS_SECOND
115#define PROBE_MIN_U		PROBE_MIN * USECS_SECOND
116#define PROBE_MAX_U		PROBE_MAX * USECS_SECOND
117
118#define timernorm(tvp)						\
119	do {							\
120		while ((tvp)->tv_usec >= 1000000) {		\
121			(tvp)->tv_sec++;			\
122			(tvp)->tv_usec -= 1000000;		\
123		}						\
124	} while (0 /* CONSTCOND */);
125
126#define timerneg(tvp)	((tvp)->tv_sec < 0 || (tvp)->tv_usec < 0)
127
128struct if_state {
129	int options;
130	struct interface *interface;
131	struct dhcp_message *offer;
132	struct dhcp_message *new;
133	struct dhcp_message *old;
134	struct dhcp_lease lease;
135	struct timeval timeout;
136	struct timeval stop;
137	struct timeval exit;
138	int state;
139	int messages;
140	time_t nakoff;
141	uint32_t xid;
142	int socket;
143	int *pid_fd;
144	int signal_fd;
145	int carrier;
146	int probes;
147	int claims;
148	int conflicts;
149	time_t defend;
150	struct in_addr fail;
151};
152
153#define LINK_UP 	1
154#define LINK_UNKNOWN	0
155#define LINK_DOWN 	-1
156
157struct dhcp_op {
158        uint8_t value;
159        const char *name;
160};
161
162static const struct dhcp_op const dhcp_ops[] = {
163	{ DHCP_DISCOVER, "DHCP_DISCOVER" },
164	{ DHCP_OFFER,    "DHCP_OFFER" },
165	{ DHCP_REQUEST,  "DHCP_REQUEST" },
166	{ DHCP_DECLINE,  "DHCP_DECLINE" },
167	{ DHCP_ACK,      "DHCP_ACK" },
168	{ DHCP_NAK,      "DHCP_NAK" },
169	{ DHCP_RELEASE,  "DHCP_RELEASE" },
170	{ DHCP_INFORM,   "DHCP_INFORM" },
171	{ 0, NULL }
172};
173
174static const char *
175get_dhcp_op(uint8_t type)
176{
177	const struct dhcp_op *d;
178
179	for (d = dhcp_ops; d->name; d++)
180		if (d->value == type)
181			return d->name;
182	return NULL;
183}
184
185#ifdef THERE_IS_NO_FORK
186#define daemonise(a,b) 0
187#else
188static int
189daemonise(struct if_state *state, const struct options *options)
190{
191	pid_t pid;
192	sigset_t full;
193	sigset_t old;
194	char buf = '\0';
195	int sidpipe[2];
196
197	if (state->options & DHCPCD_DAEMONISED ||
198	    !(options->options & DHCPCD_DAEMONISE))
199		return 0;
200
201	sigfillset(&full);
202	sigprocmask(SIG_SETMASK, &full, &old);
203
204	/* Setup a signal pipe so parent knows when to exit. */
205	if (pipe(sidpipe) == -1) {
206		logger(LOG_ERR,"pipe: %s", strerror(errno));
207		return -1;
208	}
209
210	logger(LOG_DEBUG, "forking to background");
211	switch (pid = fork()) {
212		case -1:
213			logger(LOG_ERR, "fork: %s", strerror(errno));
214			exit(EXIT_FAILURE);
215			/* NOTREACHED */
216		case 0:
217			setsid();
218			/* Notify parent it's safe to exit as we've detached. */
219			close(sidpipe[0]);
220			if (write(sidpipe[1], &buf, 1) != 1)
221				logger(LOG_ERR, "write: %s", strerror(errno));
222			close(sidpipe[1]);
223			close_fds();
224			break;
225		default:
226			/* Reset signals as we're the parent about to exit. */
227			signal_reset();
228			/* Wait for child to detach */
229			close(sidpipe[1]);
230			if (read(sidpipe[0], &buf, 1) != 1)
231				logger(LOG_ERR, "read: %s", strerror(errno));
232			close(sidpipe[0]);
233			break;
234	}
235
236	/* Done with the fd now */
237	if (pid != 0) {
238		writepid(*state->pid_fd, pid);
239		close(*state->pid_fd);
240		*state->pid_fd = -1;
241	}
242
243	sigprocmask(SIG_SETMASK, &old, NULL);
244	if (pid == 0) {
245		state->options |= DHCPCD_DAEMONISED;
246		timerclear(&state->exit);
247		return 0;
248	}
249	state->options |= DHCPCD_PERSISTENT | DHCPCD_FORKED;
250	return -1;
251}
252#endif
253
254#define THIRTY_YEARS_IN_SECONDS    946707779
255static size_t
256get_duid(unsigned char *duid, const struct interface *iface)
257{
258	FILE *f;
259	uint16_t type = 0;
260	uint16_t hw = 0;
261	uint32_t ul;
262	time_t t;
263	int x = 0;
264	unsigned char *p = duid;
265	size_t len = 0, l = 0;
266	char *buffer = NULL, *line, *option;
267
268	/* If we already have a DUID then use it as it's never supposed
269	 * to change once we have one even if the interfaces do */
270	if ((f = fopen(DUID, "r"))) {
271		while ((get_line(&buffer, &len, f))) {
272			line = buffer;
273			while ((option = strsep(&line, " \t")))
274				if (*option != '\0')
275					break;
276			if (!option || *option == '\0' || *option == '#')
277				continue;
278			l = hwaddr_aton(NULL, option);
279			if (l && l <= DUID_LEN) {
280				hwaddr_aton(duid, option);
281				break;
282			}
283			l = 0;
284		}
285		fclose(f);
286		free(buffer);
287		if (l)
288			return l;
289	} else {
290		if (errno != ENOENT)
291			return 0;
292	}
293
294	/* No file? OK, lets make one based on our interface */
295	if (!(f = fopen(DUID, "w")))
296		return 0;
297	type = htons(1); /* DUI-D-LLT */
298	memcpy(p, &type, 2);
299	p += 2;
300	hw = htons(iface->family);
301	memcpy(p, &hw, 2);
302	p += 2;
303	/* time returns seconds from jan 1 1970, but DUID-LLT is
304	 * seconds from jan 1 2000 modulo 2^32 */
305	t = time(NULL) - THIRTY_YEARS_IN_SECONDS;
306	ul = htonl(t & 0xffffffff);
307	memcpy(p, &ul, 4);
308	p += 4;
309	/* Finally, add the MAC address of the interface */
310	memcpy(p, iface->hwaddr, iface->hwlen);
311	p += iface->hwlen;
312	len = p - duid;
313	x = fprintf(f, "%s\n", hwaddr_ntoa(duid, len));
314	fclose(f);
315	/* Failed to write the duid? scrub it, we cannot use it */
316	if (x < 1) {
317		len = 0;
318		unlink(DUID);
319	}
320	return len;
321}
322
323static struct dhcp_message*
324ipv4ll_get_dhcp(uint32_t old_addr)
325{
326	uint32_t u32;
327	struct dhcp_message *dhcp;
328	uint8_t *p;
329
330	dhcp = xzalloc(sizeof(*dhcp));
331	/* Put some LL options in */
332	p = dhcp->options;
333	*p++ = DHO_SUBNETMASK;
334	*p++ = sizeof(u32);
335	u32 = htonl(LINKLOCAL_MASK);
336	memcpy(p, &u32, sizeof(u32));
337	p += sizeof(u32);
338	*p++ = DHO_BROADCAST;
339	*p++ = sizeof(u32);
340	u32 = htonl(LINKLOCAL_BRDC);
341	memcpy(p, &u32, sizeof(u32));
342	p += sizeof(u32);
343	*p++ = DHO_END;
344
345	for (;;) {
346		dhcp->yiaddr = htonl(LINKLOCAL_ADDR |
347				     (((uint32_t)abs((int)arc4random())
348				       % 0xFD00) + 0x0100));
349		if (dhcp->yiaddr != old_addr &&
350		    IN_LINKLOCAL(ntohl(dhcp->yiaddr)))
351			break;
352	}
353	return dhcp;
354}
355
356static double
357timeval_to_double(struct timeval *tv)
358{
359	return tv->tv_sec * 1.0 + tv->tv_usec * 1.0e-6;
360}
361
362static void
363get_lease(struct dhcp_lease *lease, const struct dhcp_message *dhcp)
364{
365	time_t t;
366
367	if (lease->frominfo)
368		return;
369	lease->addr.s_addr = dhcp->yiaddr;
370
371	if (get_option_addr(&lease->net, dhcp, DHO_SUBNETMASK) == -1)
372		lease->net.s_addr = get_netmask(dhcp->yiaddr);
373	if (get_option_uint32(&lease->leasetime, dhcp, DHO_LEASETIME) == 0) {
374		/* Ensure that we can use the lease */
375		t = 0;
376		if (t + (time_t)lease->leasetime < t) {
377			logger(LOG_WARNING, "lease of %u would overflow, "
378			       "treating as infinite", lease->leasetime);
379			lease->leasetime = ~0U; /* Infinite lease */
380		}
381	} else
382		lease->leasetime = DEFAULT_LEASETIME;
383	if (get_option_uint32(&lease->renewaltime, dhcp, DHO_RENEWALTIME) != 0)
384		lease->renewaltime = 0;
385	if (get_option_uint32(&lease->rebindtime, dhcp, DHO_REBINDTIME) != 0)
386		lease->rebindtime = 0;
387}
388
389static int
390get_old_lease(struct if_state *state)
391{
392	struct interface *iface = state->interface;
393	struct dhcp_lease *lease = &state->lease;
394	struct dhcp_message *dhcp = NULL;
395	struct timeval tv;
396	unsigned int offset = 0;
397	struct stat sb;
398
399	if (stat(iface->leasefile, &sb) == -1) {
400		if (errno != ENOENT)
401			logger(LOG_ERR, "stat: %s", strerror(errno));
402		goto eexit;
403	}
404	if (!IN_LINKLOCAL(ntohl(iface->addr.s_addr)))
405		logger(LOG_INFO, "trying to use old lease in `%s'",
406		       iface->leasefile);
407	if ((dhcp = read_lease(iface)) == NULL) {
408		logger(LOG_INFO, "read_lease: %s", strerror(errno));
409		goto eexit;
410	}
411	lease->frominfo = 0;
412	get_lease(&state->lease, dhcp);
413	lease->frominfo = 1;
414	lease->leasedfrom = sb.st_mtime;
415
416	/* Vitaly important we remove the server information here */
417	state->lease.server.s_addr = 0;
418	dhcp->servername[0] = '\0';
419
420	if (!IN_LINKLOCAL(ntohl(dhcp->yiaddr))) {
421		if (!(state->options & DHCPCD_LASTLEASE))
422			goto eexit;
423
424		/* Ensure that we can still use the lease */
425		if (gettimeofday(&tv, NULL) == -1) {
426			logger(LOG_ERR, "gettimeofday: %s", strerror(errno));
427			goto eexit;
428		}
429
430		offset = tv.tv_sec - lease->leasedfrom;
431		if (lease->leasedfrom &&
432		    tv.tv_sec - lease->leasedfrom > (time_t)lease->leasetime)
433		{
434			logger(LOG_ERR, "lease expired %u seconds ago",
435			       offset + lease->leasetime);
436			/* Persistent interfaces should still try and use the
437			 * lease if we can't contact a DHCP server.
438			 * We just set the timeout to 1 second. */
439			if (state->options & DHCPCD_PERSISTENT)
440				offset = lease->renewaltime - 1;
441			else
442				goto eexit;
443		}
444		lease->leasetime -= offset;
445		lease->rebindtime -= offset;
446		lease->renewaltime -= offset;
447	}
448
449	free(state->old);
450	state->old = state->new;
451	state->new = NULL;
452	state->offer = dhcp;
453	return 0;
454
455eexit:
456	lease->addr.s_addr = 0;
457	free(dhcp);
458	return -1;
459}
460
461static int
462client_setup(struct if_state *state, const struct options *options)
463{
464	struct interface *iface = state->interface;
465	struct dhcp_lease *lease = &state->lease;
466	struct in_addr addr;
467	struct timeval tv;
468	size_t len = 0;
469	unsigned char *duid = NULL;
470	uint32_t ul;
471
472	state->state = STATE_INIT;
473	state->nakoff = 1;
474	state->options = options->options;
475	timerclear(&tv);
476
477	if (options->request_address.s_addr == 0 &&
478	    (options->options & DHCPCD_INFORM ||
479	     options->options & DHCPCD_REQUEST ||
480	     (options->options & DHCPCD_DAEMONISED &&
481	      !(options->options & DHCPCD_BACKGROUND))))
482	{
483		if (get_old_lease(state) != 0)
484			return -1;
485		timerclear(&state->timeout);
486
487		if (!(options->options & DHCPCD_DAEMONISED) &&
488		    IN_LINKLOCAL(ntohl(lease->addr.s_addr)))
489		{
490			logger(LOG_ERR, "cannot request a link local address");
491			return -1;
492		}
493	} else {
494		lease->addr.s_addr = options->request_address.s_addr;
495		lease->net.s_addr = options->request_netmask.s_addr;
496	}
497
498	/* If INFORMing, ensure the interface has the address */
499	if (state->options & DHCPCD_INFORM &&
500	    has_address(iface->name, &lease->addr, &lease->net) < 1)
501	{
502		addr.s_addr = lease->addr.s_addr | ~lease->net.s_addr;
503		logger(LOG_DEBUG, "adding IP address %s/%d",
504		       inet_ntoa(lease->addr), inet_ntocidr(lease->net));
505		if (add_address(iface->name, &lease->addr,
506				&lease->net, &addr) == -1)
507		{
508			logger(LOG_ERR, "add_address: %s", strerror(errno));
509			return -1;
510		}
511		iface->addr.s_addr = lease->addr.s_addr;
512		iface->net.s_addr = lease->net.s_addr;
513	}
514
515       /* If we haven't specified a ClientID and our hardware address
516	* length is greater than DHCP_CHADDR_LEN then we enforce a ClientID
517	* of the hardware address family and the hardware address. */
518	if (!(state->options & DHCPCD_CLIENTID) && iface->hwlen > DHCP_CHADDR_LEN)
519		state->options |= DHCPCD_CLIENTID;
520
521	if (*options->clientid) {
522		iface->clientid = xmalloc(options->clientid[0] + 1);
523		memcpy(iface->clientid,
524		       options->clientid, options->clientid[0] + 1);
525	} else if (state->options & DHCPCD_CLIENTID) {
526		if (state->options & DHCPCD_DUID) {
527			duid = xmalloc(DUID_LEN);
528			if ((len = get_duid(duid, iface)) == 0)
529				logger(LOG_ERR, "get_duid: %s",
530				       strerror(errno));
531		}
532
533		if (len > 0) {
534			logger(LOG_DEBUG, "DUID = %s",
535			       hwaddr_ntoa(duid, len));
536
537			iface->clientid = xmalloc(len + 6);
538			iface->clientid[0] = len + 5;
539			iface->clientid[1] = 255; /* RFC 4361 */
540
541			/* IAID is 4 bytes, so if the iface name is 4 bytes
542			 * or less, use it */
543			ul = strlen(iface->name);
544			if (ul < 5) {
545				memcpy(iface->clientid + 2, iface->name, ul);
546				if (ul < 4)
547					memset(iface->clientid + 2 + ul,
548					       0, 4 - ul);
549			} else {
550				/* Name isn't 4 bytes, so use the index */
551				ul = htonl(if_nametoindex(iface->name));
552				memcpy(iface->clientid + 2, &ul, 4);
553			}
554
555			memcpy(iface->clientid + 6, duid, len);
556			free(duid);
557		}
558		if (len == 0) {
559			len = iface->hwlen + 1;
560			iface->clientid = xmalloc(len + 1);
561			iface->clientid[0] = len;
562			iface->clientid[1] = iface->family;
563			memcpy(iface->clientid + 2, iface->hwaddr, iface->hwlen);
564		}
565	}
566
567	if (state->options & DHCPCD_LINK) {
568		open_link_socket(iface);
569		switch (carrier_status(iface->name)) {
570		case 0:
571			state->carrier = LINK_DOWN;
572			break;
573		case 1:
574			state->carrier = LINK_UP;
575			break;
576		default:
577			state->carrier = LINK_UNKNOWN;
578		}
579	}
580
581	if (options->timeout > 0 &&
582	    !(state->options & DHCPCD_DAEMONISED))
583	{
584		if (state->options & DHCPCD_IPV4LL) {
585			state->stop.tv_sec = options->timeout;
586			if (!(state->options & DHCPCD_BACKGROUND))
587				state->exit.tv_sec = state->stop.tv_sec + 10;
588		} else if (!(state->options & DHCPCD_BACKGROUND))
589			state->exit.tv_sec = options->timeout;
590	}
591	return 0;
592}
593
594static int
595do_socket(struct if_state *state, int mode)
596{
597	if (state->interface->raw_fd != -1) {
598		close(state->interface->raw_fd);
599		state->interface->raw_fd = -1;
600	}
601	if (mode == SOCKET_CLOSED) {
602		if (state->interface->udp_fd != -1) {
603			close(state->interface->udp_fd);
604			state->interface->udp_fd = -1;
605		}
606		if (state->interface->arp_fd != -1) {
607			close(state->interface->arp_fd);
608			state->interface->arp_fd = -1;
609		}
610	}
611
612	/* Always have the UDP socket open to avoid the kernel sending
613	 * ICMP unreachable messages. */
614	/* For systems without SO_BINDTODEVICE, (ie BSD ones) we may get an
615	 * error or EADDRINUSE when binding to INADDR_ANY as another dhcpcd
616	 * instance could be running.
617	 * Oddly enough, we don't care about this as the socket is there
618	 * just to please the kernel - we don't care for reading from it. */
619	if (mode == SOCKET_OPEN &&
620	    state->interface->udp_fd == -1 &&
621	    open_udp_socket(state->interface) == -1 &&
622	    (errno != EADDRINUSE || state->interface->addr.s_addr != 0))
623		logger(LOG_ERR, "open_udp_socket: %s", strerror(errno));
624
625	if (mode == SOCKET_OPEN)
626		if (open_socket(state->interface, ETHERTYPE_IP) == -1) {
627			logger(LOG_ERR, "open_socket: %s", strerror(errno));
628			return -1;
629		}
630	state->socket = mode;
631	return 0;
632}
633
634static ssize_t
635send_message(struct if_state *state, int type, const struct options *options)
636{
637	struct dhcp_message *dhcp;
638	uint8_t *udp;
639	ssize_t len, r;
640	struct in_addr from, to;
641	in_addr_t a = 0;
642
643	if (state->carrier == LINK_DOWN)
644		return 0;
645	if (type == DHCP_RELEASE)
646		logger(LOG_DEBUG, "sending %s with xid 0x%x",
647		       get_dhcp_op(type), state->xid);
648	else
649		logger(LOG_DEBUG,
650		       "sending %s with xid 0x%x, next in %0.2f seconds",
651		       get_dhcp_op(type), state->xid,
652		       timeval_to_double(&state->timeout));
653	state->messages++;
654	if (state->messages < 0)
655		state->messages = INT_MAX;
656	/* If we couldn't open a UDP port for our IP address
657	 * then we cannot renew.
658	 * This could happen if our IP was pulled out from underneath us. */
659	if (state->interface->udp_fd == -1) {
660		a = state->interface->addr.s_addr;
661		state->interface->addr.s_addr = 0;
662	}
663	len = make_message(&dhcp, state->interface, &state->lease, state->xid,
664			   type, options);
665	if (state->interface->udp_fd == -1)
666		state->interface->addr.s_addr = a;
667	from.s_addr = dhcp->ciaddr;
668	if (from.s_addr)
669		to.s_addr = state->lease.server.s_addr;
670	else
671		to.s_addr = 0;
672	if (to.s_addr && to.s_addr != INADDR_BROADCAST) {
673		r = send_packet(state->interface, to, (uint8_t *)dhcp, len);
674		if (r == -1)
675			logger(LOG_ERR, "send_packet: %s", strerror(errno));
676	} else {
677		len = make_udp_packet(&udp, (uint8_t *)dhcp, len, from, to);
678		r = send_raw_packet(state->interface, ETHERTYPE_IP, udp, len);
679		free(udp);
680		if (r == -1)
681			logger(LOG_ERR, "send_raw_packet: %s", strerror(errno));
682	}
683	free(dhcp);
684	/* Failed to send the packet? Return to the init state */
685	if (r == -1) {
686		state->state = STATE_INIT;
687		timerclear(&state->timeout);
688		/* We need to set a timeout so we fall through gracefully */
689		state->stop.tv_sec = 1;
690		state->stop.tv_usec = 0;
691		do_socket(state, SOCKET_CLOSED);
692	}
693	return r;
694}
695
696static void
697drop_config(struct if_state *state, const char *reason,
698	    const struct options *options)
699{
700	if (state->new || strcmp(reason, "FAIL") == 0) {
701		configure(state->interface, reason, NULL, state->new,
702			  &state->lease, options, 0);
703		free(state->old);
704		state->old = NULL;
705		free(state->new);
706		state->new = NULL;
707	}
708	state->lease.addr.s_addr = 0;
709}
710
711static void
712reduce_timers(struct if_state *state, const struct timeval *tv)
713{
714	if (timerisset(&state->exit)) {
715		timersub(&state->exit, tv, &state->exit);
716		if (!timerisset(&state->exit))
717			state->exit.tv_sec = -1;
718	}
719	if (timerisset(&state->stop)) {
720		timersub(&state->stop, tv, &state->stop);
721		if (!timerisset(&state->stop))
722			state->stop.tv_sec = -1;
723	}
724	if (timerisset(&state->timeout)) {
725		timersub(&state->timeout, tv, &state->timeout);
726		if (!timerisset(&state->timeout))
727			state->timeout.tv_sec = -1;
728	}
729}
730
731static struct timeval *
732get_lowest_timer(struct if_state *state)
733{
734	struct timeval *ref = NULL;
735
736	if (timerisset(&state->exit))
737		ref = &state->exit;
738	if (timerisset(&state->stop)) {
739		if (!ref || timercmp(&state->stop, ref, <))
740			ref = &state->stop;
741	}
742	if (timerisset(&state->timeout)) {
743		if (!ref || timercmp(&state->timeout, ref, <))
744			ref = &state->timeout;
745	}
746	return ref;
747}
748
749static int
750wait_for_fd(struct if_state *state, int *fd)
751{
752	struct pollfd fds[4]; /* signal, link, raw, arp */
753	struct interface *iface = state->interface;
754	int i, r, nfds = 0, msecs = -1;
755	struct timeval start, stop, diff, *ref;
756	static int lastinf = 0;
757
758	/* Ensure that we haven't already timed out */
759	ref = get_lowest_timer(state);
760	if (ref && timerneg(ref))
761		return 0;
762
763	/* We always listen to signals */
764	fds[nfds].fd = state->signal_fd;
765	fds[nfds].events = POLLIN;
766	nfds++;
767	/* And links */
768	if (iface->link_fd != -1) {
769		fds[nfds].fd = iface->link_fd;
770		fds[nfds].events = POLLIN;
771		nfds++;
772	}
773
774	if (state->lease.leasetime == ~0U &&
775	    state->state == STATE_BOUND)
776	{
777		if (!lastinf) {
778			logger(LOG_DEBUG, "waiting for infinity");
779			lastinf = 1;
780		}
781		ref = NULL;
782	} else if (state->carrier == LINK_DOWN && !ref) {
783		if (!lastinf) {
784			logger(LOG_DEBUG, "waiting for carrier");
785			lastinf = 1;
786		}
787		if (timerisset(&state->exit))
788			ref = &state->exit;
789		else
790			ref = NULL;
791	} else {
792		if (iface->raw_fd != -1) {
793			fds[nfds].fd = iface->raw_fd;
794			fds[nfds].events = POLLIN;
795			nfds++;
796		}
797		if (iface->arp_fd != -1) {
798			fds[nfds].fd = iface->arp_fd;
799			fds[nfds].events = POLLIN;
800			nfds++;
801		}
802	}
803
804	/* Wait and then reduce the timers.
805	 * If we reduce a timer to zero, set it negative to indicate timeout.
806	 * We cannot reliably use select as there is no guarantee we will
807	 * actually wait the whole time if greater than 31 days according
808	 * to POSIX. So we loop on poll if needed as it's limitation of
809	 * INT_MAX milliseconds is known. */
810	for (;;) {
811		get_monotonic(&start);
812		if (ref) {
813			lastinf = 0;
814			if (ref->tv_sec > INT_MAX / 1000 ||
815			    (ref->tv_sec == INT_MAX / 1000 &&
816			     (ref->tv_usec + 999) / 1000 > INT_MAX % 1000))
817				msecs = INT_MAX;
818			else
819				msecs = ref->tv_sec * 1000 +
820					(ref->tv_usec + 999) / 1000;
821		} else
822			msecs = -1;
823		r = poll(fds, nfds, msecs);
824		get_monotonic(&stop);
825		timersub(&stop, &start, &diff);
826		reduce_timers(state, &diff);
827		if (r == -1) {
828			if (errno != EINTR)
829				logger(LOG_ERR, "poll: %s", strerror(errno));
830			return -1;
831		}
832		if (r)
833			break;
834		/* We should not have an infinite timeout if we get here */
835		if (timerneg(ref))
836			return 0;
837	}
838
839	/* We configured our array in the order we should deal with them */
840	for (i = 0; i < nfds; i++) {
841		if (fds[i].revents & POLLERR) {
842			syslog(LOG_ERR, "poll: POLLERR on fd %d", fds[i].fd);
843			errno = EBADF;
844			return -1;
845		}
846		if (fds[i].revents & POLLNVAL) {
847			syslog(LOG_ERR, "poll: POLLNVAL on fd %d", fds[i].fd);
848			errno = EINVAL;
849			return -1;
850		}
851		if (fds[i].revents & (POLLIN | POLLHUP)) {
852			*fd = fds[i].fd;
853			return r;
854		}
855	}
856	/* We should never get here. */
857	return 0;
858}
859
860static int
861handle_signal(int sig, struct if_state *state,  const struct options *options)
862{
863	struct dhcp_lease *lease = &state->lease;
864
865	switch (sig) {
866	case SIGINT:
867		logger(LOG_INFO, "received SIGINT, stopping");
868		if (!(state->options & DHCPCD_PERSISTENT))
869			drop_config(state, "STOP", options);
870		return -1;
871	case SIGTERM:
872		logger(LOG_INFO, "received SIGTERM, stopping");
873		if (!(state->options & DHCPCD_PERSISTENT))
874			drop_config(state, "STOP", options);
875		return -1;
876	case SIGALRM:
877		logger(LOG_INFO, "received SIGALRM, renewing lease");
878		do_socket(state, SOCKET_CLOSED);
879		state->state = STATE_RENEW_REQUESTED;
880		timerclear(&state->timeout);
881		timerclear(&state->stop);
882		return 1;
883	case SIGHUP:
884		logger(LOG_INFO, "received SIGHUP, releasing lease");
885		if (lease->addr.s_addr &&
886		    !IN_LINKLOCAL(ntohl(lease->addr.s_addr)))
887		{
888			do_socket(state, SOCKET_OPEN);
889			state->xid = arc4random();
890			send_message(state, DHCP_RELEASE, options);
891			do_socket(state, SOCKET_CLOSED);
892		}
893		drop_config(state, "RELEASE", options);
894		return -1;
895	default:
896		logger (LOG_ERR,
897			"received signal %d, but don't know what to do with it",
898			sig);
899	}
900
901	return 0;
902}
903
904static int bind_dhcp(struct if_state *state, const struct options *options)
905{
906	struct interface *iface = state->interface;
907	struct dhcp_lease *lease = &state->lease;
908	const char *reason = NULL;
909	struct timeval start, stop, diff;
910	int retval;
911
912	free(state->old);
913	state->old = state->new;
914	state->new = state->offer;
915	state->offer = NULL;
916	state->messages = 0;
917	state->conflicts = 0;
918	state->defend = 0;
919	timerclear(&state->exit);
920	if (clock_monotonic)
921		get_monotonic(&lease->boundtime);
922
923	if (options->options & DHCPCD_INFORM) {
924		if (options->request_address.s_addr != 0)
925			lease->addr.s_addr = options->request_address.s_addr;
926		else
927			lease->addr.s_addr = iface->addr.s_addr;
928		logger(LOG_INFO, "received approval for %s",
929		       inet_ntoa(lease->addr));
930		state->state = STATE_BOUND;
931		state->lease.leasetime = ~0U;
932		timerclear(&state->stop);
933		reason = "INFORM";
934	} else if (IN_LINKLOCAL(htonl(state->new->yiaddr))) {
935		get_lease(lease, state->new);
936		logger(LOG_INFO, "using IPv4LL address %s",
937		       inet_ntoa(lease->addr));
938		state->state = STATE_INIT;
939		timerclear(&state->timeout);
940		reason = "IPV4LL";
941	} else {
942		if (gettimeofday(&start, NULL) == 0)
943			lease->leasedfrom = start.tv_sec;
944
945		get_lease(lease, state->new);
946		if (lease->frominfo)
947			reason = "TIMEOUT";
948
949		if (lease->leasetime == ~0U) {
950			lease->renewaltime = lease->rebindtime = lease->leasetime;
951			logger(LOG_INFO, "leased %s for infinity",
952			       inet_ntoa(lease->addr));
953			state->state = STATE_BOUND;
954			timerclear(&state->stop);
955		} else {
956			if (lease->rebindtime == 0)
957				lease->rebindtime = lease->leasetime * T2;
958			else if (lease->rebindtime >= lease->leasetime) {
959				lease->rebindtime = lease->leasetime * T2;
960				logger(LOG_ERR,
961				       "rebind time greater than lease "
962				       "time, forcing to %u seconds",
963				       lease->rebindtime);
964			}
965			if (lease->renewaltime == 0)
966				lease->renewaltime = lease->leasetime * T1;
967			else if (lease->renewaltime > lease->rebindtime) {
968				lease->renewaltime = lease->leasetime * T1;
969				logger(LOG_ERR,
970				       "renewal time greater than rebind time, "
971				       "forcing to %u seconds",
972				       lease->renewaltime);
973			}
974			logger(LOG_INFO,
975			       "leased %s for %u seconds",
976			       inet_ntoa(lease->addr), lease->leasetime);
977			state->stop.tv_sec = lease->renewaltime;
978			state->stop.tv_usec = 0;
979		}
980		state->state = STATE_BOUND;
981	}
982
983	state->xid = 0;
984	timerclear(&state->timeout);
985	if (!reason) {
986		if (state->old) {
987			if (state->old->yiaddr == state->new->yiaddr &&
988			    lease->server.s_addr)
989				reason = "RENEW";
990			else
991				reason = "REBIND";
992		} else
993			reason = "BOUND";
994	}
995	/* If we have a monotonic clock we can safely substract the
996	 * script execution time from our timers.
997	 * Otherwise we can't as the script may update the real time. */
998	if (clock_monotonic)
999		get_monotonic(&start);
1000	retval = configure(iface, reason, state->new, state->old,
1001			   &state->lease, options, 1);
1002	if (clock_monotonic) {
1003		get_monotonic(&stop);
1004		timersub(&stop, &start, &diff);
1005		reduce_timers(state, &diff);
1006	}
1007	if (retval != 0)
1008		return -1;
1009	return daemonise(state, options);
1010}
1011
1012static int
1013handle_timeout_fail(struct if_state *state, const struct options *options)
1014{
1015	struct dhcp_lease *lease = &state->lease;
1016	struct interface *iface = state->interface;
1017	int gotlease = -1, r;
1018	const char *reason = NULL;
1019
1020	timerclear(&state->stop);
1021	timerclear(&state->exit);
1022	if (state->state != STATE_DISCOVERING)
1023		state->messages = 0;
1024
1025	switch (state->state) {
1026	case STATE_INIT:	/* FALLTHROUGH */
1027	case STATE_DISCOVERING: /* FALLTHROUGH */
1028	case STATE_REQUESTING:
1029		if (IN_LINKLOCAL(ntohl(iface->addr.s_addr))) {
1030			if (!(state->options & DHCPCD_DAEMONISED))
1031				logger(LOG_ERR, "timed out");
1032		} else {
1033			if (iface->addr.s_addr != 0 &&
1034			    !(state->options & DHCPCD_INFORM))
1035				logger(LOG_ERR, "lost lease");
1036			else if (state->carrier != LINK_DOWN ||
1037				!(state->options & DHCPCD_DAEMONISED))
1038				logger(LOG_ERR, "timed out");
1039		}
1040		do_socket(state, SOCKET_CLOSED);
1041		if (state->options & DHCPCD_INFORM ||
1042		    state->options & DHCPCD_TEST)
1043			return -1;
1044
1045		if (state->carrier != LINK_DOWN &&
1046		    (state->options & DHCPCD_IPV4LL ||
1047		     state->options & DHCPCD_LASTLEASE))
1048			gotlease = get_old_lease(state);
1049
1050		if (state->carrier != LINK_DOWN &&
1051		    state->options & DHCPCD_IPV4LL &&
1052		    gotlease != 0)
1053		{
1054			logger(LOG_INFO, "probing for an IPV4LL address");
1055			free(state->offer);
1056			lease->frominfo = 0;
1057			state->offer = ipv4ll_get_dhcp(0);
1058			gotlease = 0;
1059		}
1060
1061		if (gotlease == 0 &&
1062		    state->offer->yiaddr != iface->addr.s_addr &&
1063		    state->options & DHCPCD_ARP)
1064		{
1065			state->state = STATE_PROBING;
1066			state->claims = 0;
1067			state->probes = 0;
1068			if (iface->addr.s_addr)
1069				state->conflicts = 0;
1070			return 1;
1071		}
1072
1073		if (gotlease == 0) {
1074			r = bind_dhcp(state, options);
1075			logger(LOG_DEBUG, "renew in %ld seconds",
1076				(long int)state->stop.tv_sec);
1077			return r;
1078		}
1079		if (iface->addr.s_addr)
1080			reason = "EXPIRE";
1081		else
1082			reason = "FAIL";
1083		drop_config(state, reason, options);
1084		if (!(state->options & DHCPCD_DAEMONISED) &&
1085		    (state->options & DHCPCD_DAEMONISE))
1086			return -1;
1087		state->state = STATE_RENEW_REQUESTED;
1088		return 1;
1089	case STATE_BOUND:
1090		logger(LOG_INFO, "renewing lease of %s",inet_ntoa(lease->addr));
1091		if (state->carrier != LINK_DOWN)
1092			do_socket(state, SOCKET_OPEN);
1093		state->xid = arc4random();
1094		state->state = STATE_RENEWING;
1095		state->stop.tv_sec = lease->rebindtime - lease->renewaltime;
1096		break;
1097	case STATE_RENEWING:
1098		logger(LOG_ERR, "failed to renew, attempting to rebind");
1099		state->state = STATE_REBINDING;
1100		if (lease->server.s_addr == 0)
1101			state->stop.tv_sec = options->timeout;
1102		else
1103			state->stop.tv_sec = lease->rebindtime - \
1104					     lease->renewaltime;
1105		lease->server.s_addr = 0;
1106		break;
1107	case STATE_REBINDING:
1108		logger(LOG_ERR, "failed to rebind");
1109		reason = "EXPIRE";
1110		drop_config(state, reason, options);
1111		state->state = STATE_INIT;
1112		break;
1113	case STATE_PROBING:    /* FALLTHROUGH */
1114	case STATE_ANNOUNCING:
1115		/* We should have lost carrier here and exit timer went */
1116		logger(LOG_ERR, "timed out");
1117		return -1;
1118	default:
1119		logger(LOG_DEBUG, "handle_timeout_failed: invalid state %d",
1120		       state->state);
1121	}
1122
1123	/* This effectively falls through into the handle_timeout funtion */
1124	return 1;
1125}
1126
1127static int
1128handle_timeout(struct if_state *state, const struct options *options)
1129{
1130	struct dhcp_lease *lease = &state->lease;
1131	struct interface *iface = state->interface;
1132	int i = 0;
1133	struct in_addr addr;
1134	struct timeval tv;
1135
1136	timerclear(&state->timeout);
1137	if (timerneg(&state->exit))
1138		return handle_timeout_fail(state, options);
1139
1140	if (state->state == STATE_RENEW_REQUESTED &&
1141	    IN_LINKLOCAL(ntohl(lease->addr.s_addr)))
1142	{
1143		state->state = STATE_PROBING;
1144		free(state->offer);
1145		state->offer = read_lease(state->interface);
1146		state->probes = 0;
1147		state->claims = 0;
1148	}
1149	switch (state->state) {
1150	case STATE_INIT_IPV4LL:
1151		state->state = STATE_PROBING;
1152		free(state->offer);
1153		state->offer = ipv4ll_get_dhcp(0);
1154		state->probes = 0;
1155		state->claims = 0;
1156		/* FALLTHROUGH */
1157	case STATE_PROBING:
1158		if (iface->arp_fd == -1)
1159			open_socket(iface, ETHERTYPE_ARP);
1160		if (state->probes < PROBE_NUM) {
1161			if (state->probes == 0) {
1162				addr.s_addr = state->offer->yiaddr;
1163				logger(LOG_INFO, "checking %s is available"
1164				       " on attached networks",
1165				       inet_ntoa(addr));
1166			}
1167			state->probes++;
1168			if (state->probes < PROBE_NUM) {
1169				state->timeout.tv_sec = PROBE_MIN;
1170				state->timeout.tv_usec = arc4random() %
1171					(PROBE_MAX_U - PROBE_MIN_U);
1172				timernorm(&state->timeout);
1173			} else {
1174				state->timeout.tv_sec = ANNOUNCE_WAIT;
1175				state->timeout.tv_usec = 0;
1176			}
1177			logger(LOG_DEBUG,
1178			       "sending ARP probe (%d of %d), next in %0.2f seconds",
1179			       state->probes, PROBE_NUM,
1180			       timeval_to_double(&state->timeout));
1181			if (send_arp(iface, ARPOP_REQUEST, 0,
1182				     state->offer->yiaddr) == -1)
1183			{
1184				logger(LOG_ERR, "send_arp: %s", strerror(errno));
1185				return -1;
1186			}
1187			return 0;
1188		} else {
1189			/* We've waited for ANNOUNCE_WAIT after the final probe
1190			 * so the address is now ours */
1191			i = bind_dhcp(state, options);
1192			state->state = STATE_ANNOUNCING;
1193			state->timeout.tv_sec = ANNOUNCE_INTERVAL;
1194			state->timeout.tv_usec = 0;
1195			return i;
1196		}
1197		break;
1198	case STATE_ANNOUNCING:
1199		if (iface->arp_fd == -1)
1200			open_socket(iface, ETHERTYPE_ARP);
1201		if (state->claims < ANNOUNCE_NUM) {
1202			state->claims++;
1203			if (state->claims < ANNOUNCE_NUM) {
1204				state->timeout.tv_sec = ANNOUNCE_INTERVAL;
1205				state->timeout.tv_usec = 0;
1206				logger(LOG_DEBUG,
1207				       "sending ARP announce (%d of %d),"
1208				       " next in %0.2f seconds",
1209				       state->claims, ANNOUNCE_NUM,
1210				       timeval_to_double(&state->timeout));
1211			} else
1212				logger(LOG_DEBUG,
1213				       "sending ARP announce (%d of %d)",
1214				       state->claims, ANNOUNCE_NUM);
1215			i = send_arp(iface, ARPOP_REQUEST,
1216				     state->new->yiaddr, state->new->yiaddr);
1217			if (i == -1) {
1218				logger(LOG_ERR, "send_arp: %s", strerror(errno));
1219				return -1;
1220			}
1221		}
1222		if (state->claims < ANNOUNCE_NUM)
1223			return 0;
1224		if (IN_LINKLOCAL(htonl(state->new->yiaddr))) {
1225			/* We should pretend to be at the end
1226			 * of the DHCP negotation cycle */
1227			state->state = STATE_INIT;
1228			state->messages = DHCP_MAX / DHCP_BASE;
1229			state->probes = 0;
1230			state->claims = 0;
1231			timerclear(&state->stop);
1232			goto dhcp_timeout;
1233		} else {
1234			state->state = STATE_BOUND;
1235			close(iface->arp_fd);
1236			iface->arp_fd = -1;
1237			if (lease->leasetime != ~0U) {
1238				state->stop.tv_sec = lease->renewaltime;
1239				state->stop.tv_usec = 0;
1240				if (clock_monotonic) {
1241					get_monotonic(&tv);
1242					timersub(&tv, &lease->boundtime, &tv);
1243					timersub(&state->stop, &tv, &state->stop);
1244				} else {
1245					state->stop.tv_sec -=
1246						(ANNOUNCE_INTERVAL * ANNOUNCE_NUM);
1247				}
1248				logger(LOG_DEBUG, "renew in %ld seconds",
1249				       (long int)state->stop.tv_sec);
1250			}
1251		}
1252		return 0;
1253	}
1254
1255	if (timerneg(&state->stop))
1256		return handle_timeout_fail(state, options);
1257
1258	switch (state->state) {
1259	case STATE_BOUND: /* FALLTHROUGH */
1260	case STATE_RENEW_REQUESTED:
1261		timerclear(&state->stop);
1262		/* FALLTHROUGH */
1263	case STATE_INIT:
1264		if (state->carrier == LINK_DOWN)
1265			return 0;
1266		do_socket(state, SOCKET_OPEN);
1267		state->xid = arc4random();
1268		iface->start_uptime = uptime();
1269		break;
1270	}
1271
1272	switch(state->state) {
1273	case STATE_RENEW_REQUESTED:
1274		/* If a renew was requested (ie, didn't timeout) we actually
1275		 * enter the REBIND state so that we broadcast to all servers.
1276		 * We need to do this for when we change networks. */
1277		lease->server.s_addr = 0;
1278		state->messages = 0;
1279		if (lease->addr.s_addr && !(state->options & DHCPCD_INFORM)) {
1280			logger(LOG_INFO, "rebinding lease of %s",
1281			       inet_ntoa(lease->addr));
1282			state->state = STATE_REBINDING;
1283			state->stop.tv_sec = options->timeout;
1284			state->stop.tv_usec = 0;
1285			break;
1286		}
1287		/* FALLTHROUGH */
1288	case STATE_INIT:
1289		if (lease->addr.s_addr == 0 ||
1290		    IN_LINKLOCAL(ntohl(iface->addr.s_addr)))
1291		{
1292			logger(LOG_INFO, "broadcasting for a lease");
1293			state->state = STATE_DISCOVERING;
1294		} else if (state->options & DHCPCD_INFORM) {
1295			logger(LOG_INFO, "broadcasting inform for %s",
1296			       inet_ntoa(lease->addr));
1297			state->state = STATE_REQUESTING;
1298		} else {
1299			logger(LOG_INFO, "broadcasting for a lease of %s",
1300			       inet_ntoa(lease->addr));
1301			state->state = STATE_REQUESTING;
1302		}
1303		if (!lease->addr.s_addr && !timerisset(&state->stop)) {
1304			state->stop.tv_sec = DHCP_MAX + DHCP_RAND_MIN;
1305			state->stop.tv_usec = arc4random() % (DHCP_RAND_MAX_U - DHCP_RAND_MIN_U);
1306			timernorm(&state->stop);
1307		}
1308		break;
1309	}
1310
1311dhcp_timeout:
1312	if (state->carrier == LINK_DOWN) {
1313		timerclear(&state->timeout);
1314		return 0;
1315	}
1316	state->timeout.tv_sec = DHCP_BASE;
1317	for (i = 0; i < state->messages; i++) {
1318		state->timeout.tv_sec *= 2;
1319		if (state->timeout.tv_sec > DHCP_MAX) {
1320			state->timeout.tv_sec = DHCP_MAX;
1321			break;
1322		}
1323	}
1324	state->timeout.tv_sec += DHCP_RAND_MIN;
1325	state->timeout.tv_usec = arc4random() %
1326		(DHCP_RAND_MAX_U - DHCP_RAND_MIN_U);
1327	timernorm(&state->timeout);
1328
1329	/* We send the message here so that the timeout is reported */
1330	switch (state->state) {
1331	case STATE_DISCOVERING:
1332		send_message(state, DHCP_DISCOVER, options);
1333		break;
1334	case STATE_REQUESTING:
1335		if (state->options & DHCPCD_INFORM) {
1336			send_message(state, DHCP_INFORM, options);
1337			break;
1338		}
1339		/* FALLTHROUGH */
1340	case STATE_RENEWING:   /* FALLTHROUGH */
1341	case STATE_REBINDING:
1342		if (iface->raw_fd == -1)
1343			do_socket(state, SOCKET_OPEN);
1344		send_message(state, DHCP_REQUEST, options);
1345		break;
1346	}
1347
1348	return 0;
1349}
1350
1351static void
1352log_dhcp(int lvl, const char *msg, const struct dhcp_message *dhcp)
1353{
1354	char *a;
1355	struct in_addr addr;
1356	int r;
1357
1358	if (strcmp(msg, "NAK:") == 0)
1359		a = get_option_string(dhcp, DHO_MESSAGE);
1360	else {
1361		addr.s_addr = dhcp->yiaddr;
1362		a = xstrdup(inet_ntoa(addr));
1363	}
1364	r = get_option_addr(&addr, dhcp, DHO_SERVERID);
1365	if (dhcp->servername[0] && r == 0)
1366		logger(lvl, "%s %s from %s `%s'", msg, a,
1367		       inet_ntoa(addr), dhcp->servername);
1368	else if (r == 0)
1369		logger(lvl, "%s %s from %s", msg, a, inet_ntoa(addr));
1370	else
1371		logger(lvl, "%s %s", msg, a);
1372	free(a);
1373}
1374
1375static int
1376handle_dhcp(struct if_state *state, struct dhcp_message **dhcpp,
1377	    const struct options *options)
1378{
1379	struct dhcp_message *dhcp = *dhcpp;
1380	struct interface *iface = state->interface;
1381	struct dhcp_lease *lease = &state->lease;
1382	uint8_t type, tmp;
1383	struct in_addr addr;
1384	size_t i;
1385	int r;
1386
1387	/* reset the message counter */
1388	state->messages = 0;
1389
1390	/* We have to have DHCP type to work */
1391	if (get_option_uint8(&type, dhcp, DHO_MESSAGETYPE) == -1) {
1392		logger(LOG_ERR, "ignoring message; no DHCP type");
1393		return 0;
1394	}
1395	/* Every DHCP message should include ServerID */
1396	if (get_option_addr(&addr, dhcp, DHO_SERVERID) == -1) {
1397		logger(LOG_ERR, "ignoring message; no Server ID");
1398		return 0;
1399	}
1400
1401	/* Ensure that it's not from a blacklisted server.
1402	 * We should expand this to check IP and/or hardware address
1403	 * at the packet level. */
1404	if (options->blacklist_len != 0 &&
1405	    get_option_addr(&addr, dhcp, DHO_SERVERID) == 0)
1406	{
1407		for (i = 0; i < options->blacklist_len; i++) {
1408			if (options->blacklist[i] != addr.s_addr)
1409				continue;
1410			if (dhcp->servername[0])
1411				logger(LOG_WARNING,
1412				       "ignoring blacklisted server %s `%s'",
1413					inet_ntoa(addr), dhcp->servername);
1414			else
1415				logger(LOG_WARNING,
1416				       "ignoring blacklisted server %s",
1417				       inet_ntoa(addr));
1418			return 0;
1419		}
1420	}
1421
1422	/* We should restart on a NAK */
1423	if (type == DHCP_NAK) {
1424		log_dhcp(LOG_WARNING, "NAK:", dhcp);
1425		drop_config(state, "EXPIRE", options);
1426		do_socket(state, SOCKET_CLOSED);
1427		state->state = STATE_INIT;
1428		/* If we constantly get NAKS then we should slowly back off */
1429		if (state->nakoff == 0) {
1430			state->nakoff = 1;
1431			timerclear(&state->timeout);
1432		} else {
1433			state->timeout.tv_sec = state->nakoff;
1434			state->timeout.tv_usec = 0;
1435			state->nakoff *= 2;
1436			if (state->nakoff > NAKOFF_MAX)
1437				state->nakoff = NAKOFF_MAX;
1438		}
1439		return 0;
1440	}
1441
1442	/* No NAK, so reset the backoff */
1443	state->nakoff = 1;
1444
1445	/* Ensure that all required options are present */
1446	for (i = 1; i < 255; i++) {
1447		if (has_option_mask(options->requiremask, i) &&
1448		    get_option_uint8(&tmp, dhcp, i) != 0)
1449		{
1450			log_dhcp(LOG_WARNING, "reject", dhcp);
1451			return 0;
1452		}
1453	}
1454
1455	if (type == DHCP_OFFER && state->state == STATE_DISCOVERING) {
1456		lease->addr.s_addr = dhcp->yiaddr;
1457		get_option_addr(&lease->server, dhcp, DHO_SERVERID);
1458		log_dhcp(LOG_INFO, "offered", dhcp);
1459		if (state->options & DHCPCD_TEST) {
1460			run_script(options, iface->name, "TEST", dhcp, NULL);
1461			/* Fake the fact we forked so we return 0 to userland */
1462			state->options |= DHCPCD_FORKED;
1463			return -1;
1464		}
1465		free(state->offer);
1466		state->offer = dhcp;
1467		*dhcpp = NULL;
1468		timerclear(&state->timeout);
1469		state->state = STATE_REQUESTING;
1470		return 1;
1471	}
1472
1473	if (type == DHCP_OFFER) {
1474		log_dhcp(LOG_INFO, "ignoring offer of", dhcp);
1475		return 0;
1476	}
1477
1478	/* We should only be dealing with acks */
1479	if (type != DHCP_ACK) {
1480		log_dhcp(LOG_ERR, "not ACK or OFFER", dhcp);
1481		return 0;
1482	}
1483
1484	switch (state->state) {
1485	case STATE_RENEW_REQUESTED:
1486	case STATE_REQUESTING:
1487	case STATE_RENEWING:
1488	case STATE_REBINDING:
1489		if (!(state->options & DHCPCD_INFORM)) {
1490			get_option_addr(&lease->server,
1491					dhcp, DHO_SERVERID);
1492			log_dhcp(LOG_INFO, "acknowledged", dhcp);
1493		}
1494		free(state->offer);
1495		state->offer = dhcp;
1496		*dhcpp = NULL;
1497		break;
1498	default:
1499		logger(LOG_ERR, "wrong state %d", state->state);
1500	}
1501
1502	lease->frominfo = 0;
1503	do_socket(state, SOCKET_CLOSED);
1504	if (state->options & DHCPCD_ARP &&
1505	    iface->addr.s_addr != state->offer->yiaddr)
1506	{
1507		/* If the interface already has the address configured
1508		 * then we can't ARP for duplicate detection. */
1509		addr.s_addr = state->offer->yiaddr;
1510		if (!has_address(iface->name, &addr, NULL)) {
1511			state->state = STATE_PROBING;
1512			state->claims = 0;
1513			state->probes = 0;
1514			state->conflicts = 0;
1515			timerclear(&state->stop);
1516			return 1;
1517		}
1518	}
1519
1520	r = bind_dhcp(state, options);
1521	if (!(state->options & DHCPCD_ARP)) {
1522		if (!(state->options & DHCPCD_INFORM))
1523			logger(LOG_DEBUG, "renew in %ld seconds",
1524			       (long int)state->stop.tv_sec);
1525		return r;
1526	}
1527	state->state = STATE_ANNOUNCING;
1528	if (state->options & DHCPCD_FORKED)
1529		return r;
1530	return 1;
1531}
1532
1533static int
1534handle_dhcp_packet(struct if_state *state, const struct options *options)
1535{
1536	uint8_t *packet;
1537	struct interface *iface = state->interface;
1538	struct dhcp_message *dhcp = NULL;
1539	const uint8_t *pp;
1540	ssize_t bytes;
1541	int retval = -1;
1542
1543	/* We loop through until our buffer is empty.
1544	 * The benefit is that if we get >1 DHCP packet in our buffer and
1545	 * the first one fails for any reason, we can use the next. */
1546	packet = xmalloc(udp_dhcp_len);
1547	for(;;) {
1548		bytes = get_raw_packet(iface, ETHERTYPE_IP,
1549				       packet, udp_dhcp_len);
1550		if (bytes == 0) {
1551			retval = 0;
1552			break;
1553		}
1554		if (bytes == -1)
1555			break;
1556		if (valid_udp_packet(packet, bytes) == -1)
1557			continue;
1558		bytes = get_udp_data(&pp, packet);
1559		if ((size_t)bytes > sizeof(*dhcp)) {
1560			logger(LOG_ERR, "packet greater than DHCP size");
1561			continue;
1562		}
1563		if (!dhcp)
1564			dhcp = xzalloc(sizeof(*dhcp));
1565		memcpy(dhcp, pp, bytes);
1566		if (dhcp->cookie != htonl(MAGIC_COOKIE)) {
1567			logger(LOG_DEBUG, "bogus cookie, ignoring");
1568			continue;
1569		}
1570		/* Ensure it's the right transaction */
1571		if (state->xid != dhcp->xid) {
1572			logger(LOG_DEBUG,
1573			       "ignoring packet with xid 0x%x as"
1574			       " it's not ours (0x%x)",
1575			       dhcp->xid, state->xid);
1576			continue;
1577		}
1578		/* Ensure packet is for us */
1579		if (iface->hwlen <= sizeof(dhcp->chaddr) &&
1580		    memcmp(dhcp->chaddr, iface->hwaddr, iface->hwlen))
1581		{
1582			logger(LOG_DEBUG, "xid 0x%x is not for our hwaddr %s",
1583			       dhcp->xid,
1584			       hwaddr_ntoa(dhcp->chaddr, sizeof(dhcp->chaddr)));
1585			continue;
1586		}
1587		retval = handle_dhcp(state, &dhcp, options);
1588		if (retval == 0 && state->options & DHCPCD_TEST)
1589			state->options |= DHCPCD_FORKED;
1590		break;
1591	}
1592
1593	free(packet);
1594	free(dhcp);
1595	return retval;
1596}
1597
1598static int
1599handle_arp_packet(struct if_state *state)
1600{
1601	struct arphdr reply;
1602	uint32_t reply_s;
1603	uint32_t reply_t;
1604	uint8_t arp_reply[sizeof(reply) + 2 * sizeof(reply_s) + 2 * HWADDR_LEN];
1605	uint8_t *hw_s, *hw_t;
1606	ssize_t bytes;
1607	struct interface *iface = state->interface;
1608
1609	state->fail.s_addr = 0;
1610	for(;;) {
1611		bytes = get_raw_packet(iface, ETHERTYPE_ARP,
1612				       arp_reply, sizeof(arp_reply));
1613		if (bytes == 0 || bytes == -1)
1614			return (int)bytes;
1615		/* We must have a full ARP header */
1616		if ((size_t)bytes < sizeof(reply))
1617			continue;
1618		memcpy(&reply, arp_reply, sizeof(reply));
1619		/* Protocol must be IP. */
1620		if (reply.ar_pro != htons(ETHERTYPE_IP))
1621			continue;
1622		if (reply.ar_pln != sizeof(reply_s))
1623			continue;
1624		/* Only these types are recognised */
1625		if (reply.ar_op != htons(ARPOP_REPLY) &&
1626		    reply.ar_op != htons(ARPOP_REQUEST))
1627			continue;
1628
1629		/* Get pointers to the hardware addreses */
1630		hw_s = arp_reply + sizeof(reply);
1631		hw_t = hw_s + reply.ar_hln + reply.ar_pln;
1632		/* Ensure we got all the data */
1633		if ((hw_t + reply.ar_hln + reply.ar_pln) - arp_reply > bytes)
1634			continue;
1635		/* Ignore messages from ourself */
1636		if (reply.ar_hln == iface->hwlen &&
1637		    memcmp(hw_s, iface->hwaddr, iface->hwlen) == 0)
1638			continue;
1639		/* Copy out the IP addresses */
1640		memcpy(&reply_s, hw_s + reply.ar_hln, reply.ar_pln);
1641		memcpy(&reply_t, hw_t + reply.ar_hln, reply.ar_pln);
1642
1643		/* Check for conflict */
1644		if (state->offer &&
1645		    (reply_s == state->offer->yiaddr ||
1646		     (reply_s == 0 && reply_t == state->offer->yiaddr)))
1647			state->fail.s_addr = state->offer->yiaddr;
1648
1649		/* Handle IPv4LL conflicts */
1650		if (IN_LINKLOCAL(htonl(iface->addr.s_addr)) &&
1651		    (reply_s == iface->addr.s_addr ||
1652		     (reply_s == 0 && reply_t == iface->addr.s_addr)))
1653			state->fail.s_addr = iface->addr.s_addr;
1654
1655		if (state->fail.s_addr) {
1656			logger(LOG_ERR, "hardware address %s claims %s",
1657			       hwaddr_ntoa((unsigned char *)hw_s,
1658					   (size_t)reply.ar_hln),
1659			       inet_ntoa(state->fail));
1660			errno = EEXIST;
1661			return -1;
1662		}
1663	}
1664}
1665
1666static int
1667handle_arp_fail(struct if_state *state, const struct options *options)
1668{
1669	time_t up;
1670	int cookie = state->offer->cookie;
1671
1672	if (!IN_LINKLOCAL(htonl(state->fail.s_addr))) {
1673		if (cookie) {
1674			state->timeout.tv_sec = DHCP_ARP_FAIL;
1675			state->timeout.tv_usec = 0;
1676			do_socket(state, SOCKET_OPEN);
1677			send_message(state, DHCP_DECLINE, options);
1678			do_socket(state, SOCKET_CLOSED);
1679		}
1680		state->state = STATE_INIT;
1681		free(state->offer);
1682		state->offer = NULL;
1683		state->lease.addr.s_addr = 0;
1684		if (!cookie)
1685			return 1;
1686		return 0;
1687	}
1688
1689	if (state->fail.s_addr == state->interface->addr.s_addr) {
1690		if (state->state == STATE_PROBING)
1691			/* This should only happen when SIGALRM or
1692			 * link when down/up and we have a conflict. */
1693			drop_config(state, "EXPIRE", options);
1694		else {
1695			up = uptime();
1696			if (state->defend + DEFEND_INTERVAL > up) {
1697				drop_config(state, "EXPIRE", options);
1698				state->conflicts = -1;
1699				/* drop through to set conflicts to 0 */
1700			} else {
1701				state->defend = up;
1702				return 0;
1703			}
1704		}
1705	}
1706	do_socket(state, SOCKET_CLOSED);
1707	state->conflicts++;
1708	timerclear(&state->stop);
1709	if (state->conflicts > MAX_CONFLICTS) {
1710		logger(LOG_ERR, "failed to obtain an IPv4LL address");
1711		state->state = STATE_INIT;
1712		timerclear(&state->timeout);
1713		if (!(state->options & DHCPCD_DAEMONISED) &&
1714		    (state->options & DHCPCD_DAEMONISE))
1715			return -1;
1716		return 1;
1717	}
1718	state->state = STATE_INIT_IPV4LL;
1719	state->timeout.tv_sec = PROBE_WAIT;
1720	state->timeout.tv_usec = 0;
1721	return 0;
1722}
1723
1724static int
1725handle_link(struct if_state *state)
1726{
1727	int retval;
1728
1729	retval = link_changed(state->interface);
1730	if (retval == -1) {
1731		logger(LOG_ERR, "link_changed: %s", strerror(errno));
1732		return -1;
1733	}
1734	if (retval == 0)
1735		return 0;
1736
1737	switch (carrier_status(state->interface->name)) {
1738	case -1:
1739		logger(LOG_ERR, "carrier_status: %s", strerror(errno));
1740		return -1;
1741	case 0:
1742		if (state->carrier != LINK_DOWN) {
1743			logger(LOG_INFO, "carrier lost");
1744			state->carrier = LINK_DOWN;
1745			do_socket(state, SOCKET_CLOSED);
1746			timerclear(&state->timeout);
1747			if (state->state != STATE_BOUND)
1748				timerclear(&state->stop);
1749		}
1750		break;
1751	default:
1752		if (state->carrier != LINK_UP) {
1753			logger(LOG_INFO, "carrier acquired");
1754			state->state = STATE_RENEW_REQUESTED;
1755			state->carrier = LINK_UP;
1756			timerclear(&state->timeout);
1757			timerclear(&state->stop);
1758			return 1;
1759		}
1760		break;
1761	}
1762	return 0;
1763}
1764
1765int
1766dhcp_run(const struct options *options, int *pid_fd)
1767{
1768	struct interface *iface;
1769	struct if_state *state = NULL;
1770	int fd = -1, r = 0, sig;
1771
1772	iface = read_interface(options->interface, options->metric);
1773	if (!iface) {
1774		logger(LOG_ERR, "read_interface: %s", strerror(errno));
1775		goto eexit;
1776	}
1777	logger(LOG_DEBUG, "hardware address = %s",
1778	       hwaddr_ntoa(iface->hwaddr, iface->hwlen));
1779	state = xzalloc(sizeof(*state));
1780	state->pid_fd = pid_fd;
1781	state->interface = iface;
1782	if (!(options->options & DHCPCD_TEST))
1783		run_script(options, iface->name, "PREINIT", NULL, NULL);
1784
1785	if (client_setup(state, options) == -1)
1786		goto eexit;
1787	if (signal_init() == -1)
1788		goto eexit;
1789	if (signal_setup() == -1)
1790		goto eexit;
1791	state->signal_fd = signal_fd();
1792
1793	if (state->options & DHCPCD_BACKGROUND &&
1794	    !(state->options & DHCPCD_DAEMONISED))
1795		if (daemonise(state, options) == -1)
1796			goto eexit;
1797
1798	if (state->carrier == LINK_DOWN)
1799		logger(LOG_INFO, "waiting for carrier");
1800
1801	for (;;) {
1802		if (r == 0)
1803			r = handle_timeout(state, options);
1804		else if (r > 0) {
1805			if (fd == state->signal_fd) {
1806			    	if ((sig = signal_read()) != -1)
1807					r = handle_signal(sig, state, options);
1808			} else if (fd == iface->link_fd)
1809				r = handle_link(state);
1810			else if (fd == iface->raw_fd)
1811				r = handle_dhcp_packet(state, options);
1812			else if (fd == iface->arp_fd) {
1813				if ((r = handle_arp_packet(state)) == -1)
1814					r = handle_arp_fail(state, options);
1815			} else
1816				r = 0;
1817		}
1818		if (r == -1)
1819			break;
1820		if (r == 0) {
1821			fd = -1;
1822			r = wait_for_fd(state, &fd);
1823			if (r == -1 && errno == EINTR) {
1824				r = 1;
1825				fd = state->signal_fd;
1826			}
1827		} else
1828			r = 0;
1829	}
1830
1831eexit:
1832	if (iface) {
1833		do_socket(state, SOCKET_CLOSED);
1834		if (iface->link_fd != -1)
1835		    close(iface->link_fd);
1836		free_routes(iface->routes);
1837		free(iface->clientid);
1838		free(iface->buffer);
1839		free(iface);
1840	}
1841
1842	if (state) {
1843		if (state->options & DHCPCD_FORKED)
1844			r = 0;
1845		if (state->options & DHCPCD_DAEMONISED)
1846			unlink(options->pidfile);
1847		free(state->offer);
1848		free(state->new);
1849		free(state->old);
1850		free(state);
1851	}
1852
1853	return r;
1854}
1855