xref: /freebsd/sbin/dhclient/dhclient.c (revision 83f745b8b9fb9a050c22a1ae98a43c060595490f)
147c08596SBrooks Davis /*	$OpenBSD: dhclient.c,v 1.63 2005/02/06 17:10:13 krw Exp $	*/
247c08596SBrooks Davis 
347c08596SBrooks Davis /*
447c08596SBrooks Davis  * Copyright 2004 Henning Brauer <henning@openbsd.org>
547c08596SBrooks Davis  * Copyright (c) 1995, 1996, 1997, 1998, 1999
647c08596SBrooks Davis  * The Internet Software Consortium.    All rights reserved.
747c08596SBrooks Davis  *
847c08596SBrooks Davis  * Redistribution and use in source and binary forms, with or without
947c08596SBrooks Davis  * modification, are permitted provided that the following conditions
1047c08596SBrooks Davis  * are met:
1147c08596SBrooks Davis  *
1247c08596SBrooks Davis  * 1. Redistributions of source code must retain the above copyright
1347c08596SBrooks Davis  *    notice, this list of conditions and the following disclaimer.
1447c08596SBrooks Davis  * 2. Redistributions in binary form must reproduce the above copyright
1547c08596SBrooks Davis  *    notice, this list of conditions and the following disclaimer in the
1647c08596SBrooks Davis  *    documentation and/or other materials provided with the distribution.
1747c08596SBrooks Davis  * 3. Neither the name of The Internet Software Consortium nor the names
1847c08596SBrooks Davis  *    of its contributors may be used to endorse or promote products derived
1947c08596SBrooks Davis  *    from this software without specific prior written permission.
2047c08596SBrooks Davis  *
2147c08596SBrooks Davis  * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
2247c08596SBrooks Davis  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
2347c08596SBrooks Davis  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
2447c08596SBrooks Davis  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
2547c08596SBrooks Davis  * DISCLAIMED.  IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
2647c08596SBrooks Davis  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2747c08596SBrooks Davis  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2847c08596SBrooks Davis  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
2947c08596SBrooks Davis  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
3047c08596SBrooks Davis  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
3147c08596SBrooks Davis  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
3247c08596SBrooks Davis  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
3347c08596SBrooks Davis  * SUCH DAMAGE.
3447c08596SBrooks Davis  *
3547c08596SBrooks Davis  * This software has been written for the Internet Software Consortium
3647c08596SBrooks Davis  * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
3747c08596SBrooks Davis  * Enterprises.  To learn more about the Internet Software Consortium,
3847c08596SBrooks Davis  * see ``http://www.vix.com/isc''.  To learn more about Vixie
3947c08596SBrooks Davis  * Enterprises, see ``http://www.vix.com''.
4047c08596SBrooks Davis  *
4147c08596SBrooks Davis  * This client was substantially modified and enhanced by Elliot Poger
4247c08596SBrooks Davis  * for use on Linux while he was working on the MosquitoNet project at
4347c08596SBrooks Davis  * Stanford.
4447c08596SBrooks Davis  *
4547c08596SBrooks Davis  * The current version owes much to Elliot's Linux enhancements, but
4647c08596SBrooks Davis  * was substantially reorganized and partially rewritten by Ted Lemon
4747c08596SBrooks Davis  * so as to use the same networking framework that the Internet Software
4847c08596SBrooks Davis  * Consortium DHCP server uses.   Much system-specific configuration code
4947c08596SBrooks Davis  * was moved into a shell script so that as support for more operating
5047c08596SBrooks Davis  * systems is added, it will not be necessary to port and maintain
5147c08596SBrooks Davis  * system-specific configuration code to these operating systems - instead,
5247c08596SBrooks Davis  * the shell script can invoke the native tools to accomplish the same
5347c08596SBrooks Davis  * purpose.
5447c08596SBrooks Davis  */
5547c08596SBrooks Davis 
568794fdbbSBrooks Davis #include <sys/cdefs.h>
578794fdbbSBrooks Davis __FBSDID("$FreeBSD$");
588794fdbbSBrooks Davis 
5947c08596SBrooks Davis #include "dhcpd.h"
6047c08596SBrooks Davis #include "privsep.h"
6147c08596SBrooks Davis 
622b19b6fcSBrooks Davis #include <net80211/ieee80211_freebsd.h>
632b19b6fcSBrooks Davis 
642b19b6fcSBrooks Davis #ifndef _PATH_VAREMPTY
652b19b6fcSBrooks Davis #define	_PATH_VAREMPTY	"/var/empty"
662b19b6fcSBrooks Davis #endif
672b19b6fcSBrooks Davis 
6847c08596SBrooks Davis #define	PERIOD 0x2e
6947c08596SBrooks Davis #define	hyphenchar(c) ((c) == 0x2d)
7047c08596SBrooks Davis #define	bslashchar(c) ((c) == 0x5c)
7147c08596SBrooks Davis #define	periodchar(c) ((c) == PERIOD)
7247c08596SBrooks Davis #define	asterchar(c) ((c) == 0x2a)
7347c08596SBrooks Davis #define	alphachar(c) (((c) >= 0x41 && (c) <= 0x5a) || \
7447c08596SBrooks Davis 	    ((c) >= 0x61 && (c) <= 0x7a))
7547c08596SBrooks Davis #define	digitchar(c) ((c) >= 0x30 && (c) <= 0x39)
76f954ec0bSBrooks Davis #define	whitechar(c) ((c) == ' ' || (c) == '\t')
7747c08596SBrooks Davis 
7847c08596SBrooks Davis #define	borderchar(c) (alphachar(c) || digitchar(c))
7947c08596SBrooks Davis #define	middlechar(c) (borderchar(c) || hyphenchar(c))
8047c08596SBrooks Davis #define	domainchar(c) ((c) > 0x20 && (c) < 0x7f)
8147c08596SBrooks Davis 
8247c08596SBrooks Davis #define	CLIENT_PATH "PATH=/usr/bin:/usr/sbin:/bin:/sbin"
8347c08596SBrooks Davis 
8447c08596SBrooks Davis time_t cur_time;
8547c08596SBrooks Davis time_t default_lease_time = 43200; /* 12 hours... */
8647c08596SBrooks Davis 
8747c08596SBrooks Davis char *path_dhclient_conf = _PATH_DHCLIENT_CONF;
8847c08596SBrooks Davis char *path_dhclient_db = NULL;
8947c08596SBrooks Davis 
9047c08596SBrooks Davis int log_perror = 1;
9147c08596SBrooks Davis int privfd;
9247c08596SBrooks Davis int nullfd = -1;
9347c08596SBrooks Davis 
9447c08596SBrooks Davis struct iaddr iaddr_broadcast = { 4, { 255, 255, 255, 255 } };
9547c08596SBrooks Davis struct in_addr inaddr_any;
9647c08596SBrooks Davis struct sockaddr_in sockaddr_broadcast;
9747c08596SBrooks Davis 
9823f39c90SDag-Erling Smørgrav char *path_dhclient_pidfile;
9923f39c90SDag-Erling Smørgrav struct pidfh *pidfile;
10023f39c90SDag-Erling Smørgrav 
10147c08596SBrooks Davis /*
10247c08596SBrooks Davis  * ASSERT_STATE() does nothing now; it used to be
10347c08596SBrooks Davis  * assert (state_is == state_shouldbe).
10447c08596SBrooks Davis  */
10547c08596SBrooks Davis #define ASSERT_STATE(state_is, state_shouldbe) {}
10647c08596SBrooks Davis 
10747c08596SBrooks Davis #define TIME_MAX 2147483647
10847c08596SBrooks Davis 
10947c08596SBrooks Davis int		log_priority;
11047c08596SBrooks Davis int		no_daemon;
11147c08596SBrooks Davis int		unknown_ok = 1;
11247c08596SBrooks Davis int		routefd;
11347c08596SBrooks Davis 
11447c08596SBrooks Davis struct interface_info	*ifi;
11547c08596SBrooks Davis 
11647c08596SBrooks Davis int		 findproto(char *, int);
11747c08596SBrooks Davis struct sockaddr	*get_ifa(char *, int);
11847c08596SBrooks Davis void		 routehandler(struct protocol *);
11947c08596SBrooks Davis void		 usage(void);
12047c08596SBrooks Davis int		 check_option(struct client_lease *l, int option);
1212fcc7370SEd Maste int		 check_classless_option(unsigned char *data, int len);
12247c08596SBrooks Davis int		 ipv4addrs(char * buf);
12347c08596SBrooks Davis int		 res_hnok(const char *dn);
124f954ec0bSBrooks Davis int		 check_search(const char *srch);
12547c08596SBrooks Davis char		*option_as_string(unsigned int code, unsigned char *data, int len);
12647c08596SBrooks Davis int		 fork_privchld(int, int);
12747c08596SBrooks Davis 
12847c08596SBrooks Davis #define	ROUNDUP(a) \
12947c08596SBrooks Davis 	    ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
13047c08596SBrooks Davis #define	ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
13147c08596SBrooks Davis 
1326964abefSBrian Somers static time_t	scripttime;
13347c08596SBrooks Davis 
13447c08596SBrooks Davis int
13547c08596SBrooks Davis findproto(char *cp, int n)
13647c08596SBrooks Davis {
13747c08596SBrooks Davis 	struct sockaddr *sa;
13847c08596SBrooks Davis 	int i;
13947c08596SBrooks Davis 
14047c08596SBrooks Davis 	if (n == 0)
14147c08596SBrooks Davis 		return -1;
14247c08596SBrooks Davis 	for (i = 1; i; i <<= 1) {
14347c08596SBrooks Davis 		if (i & n) {
14447c08596SBrooks Davis 			sa = (struct sockaddr *)cp;
14547c08596SBrooks Davis 			switch (i) {
14647c08596SBrooks Davis 			case RTA_IFA:
14747c08596SBrooks Davis 			case RTA_DST:
14847c08596SBrooks Davis 			case RTA_GATEWAY:
14947c08596SBrooks Davis 			case RTA_NETMASK:
15047c08596SBrooks Davis 				if (sa->sa_family == AF_INET)
15147c08596SBrooks Davis 					return AF_INET;
15247c08596SBrooks Davis 				if (sa->sa_family == AF_INET6)
15347c08596SBrooks Davis 					return AF_INET6;
15447c08596SBrooks Davis 				break;
15547c08596SBrooks Davis 			case RTA_IFP:
15647c08596SBrooks Davis 				break;
15747c08596SBrooks Davis 			}
15847c08596SBrooks Davis 			ADVANCE(cp, sa);
15947c08596SBrooks Davis 		}
16047c08596SBrooks Davis 	}
16147c08596SBrooks Davis 	return (-1);
16247c08596SBrooks Davis }
16347c08596SBrooks Davis 
16447c08596SBrooks Davis struct sockaddr *
16547c08596SBrooks Davis get_ifa(char *cp, int n)
16647c08596SBrooks Davis {
16747c08596SBrooks Davis 	struct sockaddr *sa;
16847c08596SBrooks Davis 	int i;
16947c08596SBrooks Davis 
17047c08596SBrooks Davis 	if (n == 0)
17147c08596SBrooks Davis 		return (NULL);
17247c08596SBrooks Davis 	for (i = 1; i; i <<= 1)
17347c08596SBrooks Davis 		if (i & n) {
17447c08596SBrooks Davis 			sa = (struct sockaddr *)cp;
17547c08596SBrooks Davis 			if (i == RTA_IFA)
17647c08596SBrooks Davis 				return (sa);
17747c08596SBrooks Davis 			ADVANCE(cp, sa);
17847c08596SBrooks Davis 		}
17947c08596SBrooks Davis 
18047c08596SBrooks Davis 	return (NULL);
18147c08596SBrooks Davis }
18261063e47SSam Leffler 
18347c08596SBrooks Davis struct iaddr defaddr = { 4 };
18461063e47SSam Leffler uint8_t curbssid[6];
18561063e47SSam Leffler 
18661063e47SSam Leffler static void
18761063e47SSam Leffler disassoc(void *arg)
18861063e47SSam Leffler {
18961063e47SSam Leffler 	struct interface_info *ifi = arg;
19061063e47SSam Leffler 
19161063e47SSam Leffler 	/*
19261063e47SSam Leffler 	 * Clear existing state.
19361063e47SSam Leffler 	 */
19461063e47SSam Leffler 	if (ifi->client->active != NULL) {
19561063e47SSam Leffler 		script_init("EXPIRE", NULL);
19661063e47SSam Leffler 		script_write_params("old_",
19761063e47SSam Leffler 		    ifi->client->active);
19861063e47SSam Leffler 		if (ifi->client->alias)
19961063e47SSam Leffler 			script_write_params("alias_",
20061063e47SSam Leffler 				ifi->client->alias);
20161063e47SSam Leffler 		script_go();
20261063e47SSam Leffler 	}
20361063e47SSam Leffler 	ifi->client->state = S_INIT;
20461063e47SSam Leffler }
20547c08596SBrooks Davis 
20647c08596SBrooks Davis /* ARGSUSED */
20747c08596SBrooks Davis void
20847c08596SBrooks Davis routehandler(struct protocol *p)
20947c08596SBrooks Davis {
2106964abefSBrian Somers 	char msg[2048], *addr;
21147c08596SBrooks Davis 	struct rt_msghdr *rtm;
21247c08596SBrooks Davis 	struct if_msghdr *ifm;
21347c08596SBrooks Davis 	struct ifa_msghdr *ifam;
21447c08596SBrooks Davis 	struct if_announcemsghdr *ifan;
21561063e47SSam Leffler 	struct ieee80211_join_event *jev;
21647c08596SBrooks Davis 	struct client_lease *l;
21747c08596SBrooks Davis 	time_t t = time(NULL);
21847c08596SBrooks Davis 	struct sockaddr *sa;
21947c08596SBrooks Davis 	struct iaddr a;
22047c08596SBrooks Davis 	ssize_t n;
22147c08596SBrooks Davis 
22247c08596SBrooks Davis 	n = read(routefd, &msg, sizeof(msg));
22347c08596SBrooks Davis 	rtm = (struct rt_msghdr *)msg;
22447c08596SBrooks Davis 	if (n < sizeof(rtm->rtm_msglen) || n < rtm->rtm_msglen ||
22547c08596SBrooks Davis 	    rtm->rtm_version != RTM_VERSION)
22647c08596SBrooks Davis 		return;
22747c08596SBrooks Davis 
22847c08596SBrooks Davis 	switch (rtm->rtm_type) {
22947c08596SBrooks Davis 	case RTM_NEWADDR:
230dfad96eaSBrooks Davis 	case RTM_DELADDR:
23147c08596SBrooks Davis 		ifam = (struct ifa_msghdr *)rtm;
232dfad96eaSBrooks Davis 
23347c08596SBrooks Davis 		if (ifam->ifam_index != ifi->index)
23447c08596SBrooks Davis 			break;
23547c08596SBrooks Davis 		if (findproto((char *)(ifam + 1), ifam->ifam_addrs) != AF_INET)
23647c08596SBrooks Davis 			break;
237dfad96eaSBrooks Davis 		if (scripttime == 0 || t < scripttime + 10)
238dfad96eaSBrooks Davis 			break;
239dfad96eaSBrooks Davis 
24047c08596SBrooks Davis 		sa = get_ifa((char *)(ifam + 1), ifam->ifam_addrs);
24147c08596SBrooks Davis 		if (sa == NULL)
2426964abefSBrian Somers 			break;
24347c08596SBrooks Davis 
24447c08596SBrooks Davis 		if ((a.len = sizeof(struct in_addr)) > sizeof(a.iabuf))
24547c08596SBrooks Davis 			error("king bula sez: len mismatch");
24647c08596SBrooks Davis 		memcpy(a.iabuf, &((struct sockaddr_in *)sa)->sin_addr, a.len);
24747c08596SBrooks Davis 		if (addr_eq(a, defaddr))
24847c08596SBrooks Davis 			break;
24947c08596SBrooks Davis 
25047c08596SBrooks Davis 		for (l = ifi->client->active; l != NULL; l = l->next)
25147c08596SBrooks Davis 			if (addr_eq(a, l->address))
25247c08596SBrooks Davis 				break;
25347c08596SBrooks Davis 
2546964abefSBrian Somers 		if (l == NULL)	/* added/deleted addr is not the one we set */
25547c08596SBrooks Davis 			break;
2566964abefSBrian Somers 
2576964abefSBrian Somers 		addr = inet_ntoa(((struct sockaddr_in *)sa)->sin_addr);
2586964abefSBrian Somers 		if (rtm->rtm_type == RTM_NEWADDR)  {
2596964abefSBrian Somers 			/*
2606964abefSBrian Somers 			 * XXX: If someone other than us adds our address,
2616964abefSBrian Somers 			 * should we assume they are taking over from us,
2626964abefSBrian Somers 			 * delete the lease record, and exit without modifying
2636964abefSBrian Somers 			 * the interface?
2646964abefSBrian Somers 			 */
2656964abefSBrian Somers 			warning("My address (%s) was re-added", addr);
2666964abefSBrian Somers 		} else {
2676964abefSBrian Somers 			warning("My address (%s) was deleted, dhclient exiting",
2686964abefSBrian Somers 			    addr);
26947c08596SBrooks Davis 			goto die;
2706964abefSBrian Somers 		}
2716964abefSBrian Somers 		break;
27247c08596SBrooks Davis 	case RTM_IFINFO:
27347c08596SBrooks Davis 		ifm = (struct if_msghdr *)rtm;
27447c08596SBrooks Davis 		if (ifm->ifm_index != ifi->index)
27547c08596SBrooks Davis 			break;
2766964abefSBrian Somers 		if ((rtm->rtm_flags & RTF_UP) == 0) {
2776964abefSBrian Somers 			warning("Interface %s is down, dhclient exiting",
2786964abefSBrian Somers 			    ifi->name);
27947c08596SBrooks Davis 			goto die;
2806964abefSBrian Somers 		}
281*83f745b8SJohn Baldwin 		if (!interface_link_status(ifi->name)) {
282*83f745b8SJohn Baldwin 			warning("Interface %s is down, dhclient exiting",
283*83f745b8SJohn Baldwin 			    ifi->name);
284*83f745b8SJohn Baldwin 			goto die;
285*83f745b8SJohn Baldwin 		}
28647c08596SBrooks Davis 		break;
28747c08596SBrooks Davis 	case RTM_IFANNOUNCE:
28847c08596SBrooks Davis 		ifan = (struct if_announcemsghdr *)rtm;
28947c08596SBrooks Davis 		if (ifan->ifan_what == IFAN_DEPARTURE &&
2906964abefSBrian Somers 		    ifan->ifan_index == ifi->index) {
2916964abefSBrian Somers 			warning("Interface %s is gone, dhclient exiting",
2926964abefSBrian Somers 			    ifi->name);
29347c08596SBrooks Davis 			goto die;
2946964abefSBrian Somers 		}
29547c08596SBrooks Davis 		break;
2962b19b6fcSBrooks Davis 	case RTM_IEEE80211:
2972b19b6fcSBrooks Davis 		ifan = (struct if_announcemsghdr *)rtm;
2982b19b6fcSBrooks Davis 		if (ifan->ifan_index != ifi->index)
2992b19b6fcSBrooks Davis 			break;
3002b19b6fcSBrooks Davis 		switch (ifan->ifan_what) {
3012b19b6fcSBrooks Davis 		case RTM_IEEE80211_ASSOC:
302b35f2511SSam Leffler 		case RTM_IEEE80211_REASSOC:
3032b19b6fcSBrooks Davis 			/*
30461063e47SSam Leffler 			 * Use assoc/reassoc event to kick state machine
30561063e47SSam Leffler 			 * in case we roam.  Otherwise fall back to the
30661063e47SSam Leffler 			 * normal state machine just like a wired network.
3072b19b6fcSBrooks Davis 			 */
30861063e47SSam Leffler 			jev = (struct ieee80211_join_event *) &ifan[1];
30961063e47SSam Leffler 			if (memcmp(curbssid, jev->iev_addr, 6)) {
31061063e47SSam Leffler 				disassoc(ifi);
31161063e47SSam Leffler 				state_reboot(ifi);
31259eac186SBrooks Davis 			}
31361063e47SSam Leffler 			memcpy(curbssid, jev->iev_addr, 6);
3142b19b6fcSBrooks Davis 			break;
3152b19b6fcSBrooks Davis 		}
3162b19b6fcSBrooks Davis 		break;
31747c08596SBrooks Davis 	default:
31847c08596SBrooks Davis 		break;
31947c08596SBrooks Davis 	}
32047c08596SBrooks Davis 	return;
32147c08596SBrooks Davis 
32247c08596SBrooks Davis die:
32347c08596SBrooks Davis 	script_init("FAIL", NULL);
324*83f745b8SJohn Baldwin 	if (ifi->client->active)
325*83f745b8SJohn Baldwin 		script_write_params("old_", ifi->client->active);
32647c08596SBrooks Davis 	if (ifi->client->alias)
32747c08596SBrooks Davis 		script_write_params("alias_", ifi->client->alias);
32847c08596SBrooks Davis 	script_go();
32923f39c90SDag-Erling Smørgrav 	if (pidfile != NULL)
33023f39c90SDag-Erling Smørgrav 		pidfile_remove(pidfile);
33147c08596SBrooks Davis 	exit(1);
33247c08596SBrooks Davis }
33347c08596SBrooks Davis 
33447c08596SBrooks Davis int
33547c08596SBrooks Davis main(int argc, char *argv[])
33647c08596SBrooks Davis {
33747c08596SBrooks Davis 	extern char		*__progname;
33847c08596SBrooks Davis 	int			 ch, fd, quiet = 0, i = 0;
33947c08596SBrooks Davis 	int			 pipe_fd[2];
3402b19b6fcSBrooks Davis 	int			 immediate_daemon = 0;
34147c08596SBrooks Davis 	struct passwd		*pw;
34223f39c90SDag-Erling Smørgrav 	pid_t			 otherpid;
34347c08596SBrooks Davis 
34447c08596SBrooks Davis 	/* Initially, log errors to stderr as well as to syslogd. */
34547c08596SBrooks Davis 	openlog(__progname, LOG_PID | LOG_NDELAY, DHCPD_LOG_FACILITY);
346043f1935SSam Leffler 	setlogmask(LOG_UPTO(LOG_DEBUG));
34747c08596SBrooks Davis 
34823f39c90SDag-Erling Smørgrav 	while ((ch = getopt(argc, argv, "bc:dl:p:qu")) != -1)
34947c08596SBrooks Davis 		switch (ch) {
3502b19b6fcSBrooks Davis 		case 'b':
3512b19b6fcSBrooks Davis 			immediate_daemon = 1;
3522b19b6fcSBrooks Davis 			break;
35347c08596SBrooks Davis 		case 'c':
35447c08596SBrooks Davis 			path_dhclient_conf = optarg;
35547c08596SBrooks Davis 			break;
35647c08596SBrooks Davis 		case 'd':
35747c08596SBrooks Davis 			no_daemon = 1;
35847c08596SBrooks Davis 			break;
35947c08596SBrooks Davis 		case 'l':
36047c08596SBrooks Davis 			path_dhclient_db = optarg;
36147c08596SBrooks Davis 			break;
36223f39c90SDag-Erling Smørgrav 		case 'p':
36323f39c90SDag-Erling Smørgrav 			path_dhclient_pidfile = optarg;
36423f39c90SDag-Erling Smørgrav 			break;
36547c08596SBrooks Davis 		case 'q':
36647c08596SBrooks Davis 			quiet = 1;
36747c08596SBrooks Davis 			break;
36847c08596SBrooks Davis 		case 'u':
36947c08596SBrooks Davis 			unknown_ok = 0;
37047c08596SBrooks Davis 			break;
37147c08596SBrooks Davis 		default:
37247c08596SBrooks Davis 			usage();
37347c08596SBrooks Davis 		}
37447c08596SBrooks Davis 
37547c08596SBrooks Davis 	argc -= optind;
37647c08596SBrooks Davis 	argv += optind;
37747c08596SBrooks Davis 
37847c08596SBrooks Davis 	if (argc != 1)
37947c08596SBrooks Davis 		usage();
38047c08596SBrooks Davis 
38123f39c90SDag-Erling Smørgrav 	if (path_dhclient_pidfile == NULL) {
38223f39c90SDag-Erling Smørgrav 		asprintf(&path_dhclient_pidfile,
38323f39c90SDag-Erling Smørgrav 		    "%sdhclient.%s.pid", _PATH_VARRUN, *argv);
38423f39c90SDag-Erling Smørgrav 		if (path_dhclient_pidfile == NULL)
38523f39c90SDag-Erling Smørgrav 			error("asprintf");
38623f39c90SDag-Erling Smørgrav 	}
38723f39c90SDag-Erling Smørgrav 	pidfile = pidfile_open(path_dhclient_pidfile, 0600, &otherpid);
38823f39c90SDag-Erling Smørgrav 	if (pidfile == NULL) {
38923f39c90SDag-Erling Smørgrav 		if (errno == EEXIST)
39023f39c90SDag-Erling Smørgrav 			error("dhclient already running, pid: %d.", otherpid);
39123f39c90SDag-Erling Smørgrav 		if (errno == EAGAIN)
39223f39c90SDag-Erling Smørgrav 			error("dhclient already running.");
39323f39c90SDag-Erling Smørgrav 		warning("Cannot open or create pidfile: %m");
39423f39c90SDag-Erling Smørgrav 	}
39523f39c90SDag-Erling Smørgrav 
39647c08596SBrooks Davis 	if ((ifi = calloc(1, sizeof(struct interface_info))) == NULL)
39747c08596SBrooks Davis 		error("calloc");
39847c08596SBrooks Davis 	if (strlcpy(ifi->name, argv[0], IFNAMSIZ) >= IFNAMSIZ)
39947c08596SBrooks Davis 		error("Interface name too long");
40047c08596SBrooks Davis 	if (path_dhclient_db == NULL && asprintf(&path_dhclient_db, "%s.%s",
40147c08596SBrooks Davis 	    _PATH_DHCLIENT_DB, ifi->name) == -1)
40247c08596SBrooks Davis 		error("asprintf");
40347c08596SBrooks Davis 
40447c08596SBrooks Davis 	if (quiet)
40547c08596SBrooks Davis 		log_perror = 0;
40647c08596SBrooks Davis 
40747c08596SBrooks Davis 	tzset();
40847c08596SBrooks Davis 	time(&cur_time);
40947c08596SBrooks Davis 
41047c08596SBrooks Davis 	memset(&sockaddr_broadcast, 0, sizeof(sockaddr_broadcast));
41147c08596SBrooks Davis 	sockaddr_broadcast.sin_family = AF_INET;
41247c08596SBrooks Davis 	sockaddr_broadcast.sin_port = htons(REMOTE_PORT);
41347c08596SBrooks Davis 	sockaddr_broadcast.sin_addr.s_addr = INADDR_BROADCAST;
41447c08596SBrooks Davis 	sockaddr_broadcast.sin_len = sizeof(sockaddr_broadcast);
41547c08596SBrooks Davis 	inaddr_any.s_addr = INADDR_ANY;
41647c08596SBrooks Davis 
41747c08596SBrooks Davis 	read_client_conf();
41847c08596SBrooks Davis 
41923f39c90SDag-Erling Smørgrav 	/* The next bit is potentially very time-consuming, so write out
42023f39c90SDag-Erling Smørgrav 	   the pidfile right away.  We will write it out again with the
42123f39c90SDag-Erling Smørgrav 	   correct pid after daemonizing. */
42223f39c90SDag-Erling Smørgrav 	if (pidfile != NULL)
42323f39c90SDag-Erling Smørgrav 		pidfile_write(pidfile);
42423f39c90SDag-Erling Smørgrav 
42547c08596SBrooks Davis 	if (!interface_link_status(ifi->name)) {
42647c08596SBrooks Davis 		fprintf(stderr, "%s: no link ...", ifi->name);
42747c08596SBrooks Davis 		fflush(stderr);
42847c08596SBrooks Davis 		sleep(1);
42947c08596SBrooks Davis 		while (!interface_link_status(ifi->name)) {
43047c08596SBrooks Davis 			fprintf(stderr, ".");
43147c08596SBrooks Davis 			fflush(stderr);
43247c08596SBrooks Davis 			if (++i > 10) {
43347c08596SBrooks Davis 				fprintf(stderr, " giving up\n");
43447c08596SBrooks Davis 				exit(1);
43547c08596SBrooks Davis 			}
43647c08596SBrooks Davis 			sleep(1);
43747c08596SBrooks Davis 		}
43847c08596SBrooks Davis 		fprintf(stderr, " got link\n");
43947c08596SBrooks Davis 	}
44047c08596SBrooks Davis 
44147c08596SBrooks Davis 	if ((nullfd = open(_PATH_DEVNULL, O_RDWR, 0)) == -1)
44247c08596SBrooks Davis 		error("cannot open %s: %m", _PATH_DEVNULL);
44347c08596SBrooks Davis 
44447c08596SBrooks Davis 	if ((pw = getpwnam("_dhcp")) == NULL) {
44547c08596SBrooks Davis 		warning("no such user: _dhcp, falling back to \"nobody\"");
44647c08596SBrooks Davis 		if ((pw = getpwnam("nobody")) == NULL)
44747c08596SBrooks Davis 			error("no such user: nobody");
44847c08596SBrooks Davis 	}
44947c08596SBrooks Davis 
45047c08596SBrooks Davis 	if (pipe(pipe_fd) == -1)
45147c08596SBrooks Davis 		error("pipe");
45247c08596SBrooks Davis 
45347c08596SBrooks Davis 	fork_privchld(pipe_fd[0], pipe_fd[1]);
45447c08596SBrooks Davis 
45547c08596SBrooks Davis 	close(pipe_fd[0]);
45647c08596SBrooks Davis 	privfd = pipe_fd[1];
45747c08596SBrooks Davis 
45847c08596SBrooks Davis 	if ((fd = open(path_dhclient_db, O_RDONLY|O_EXLOCK|O_CREAT, 0)) == -1)
45947c08596SBrooks Davis 		error("can't open and lock %s: %m", path_dhclient_db);
46047c08596SBrooks Davis 	read_client_leases();
46147c08596SBrooks Davis 	rewrite_client_leases();
46247c08596SBrooks Davis 	close(fd);
46347c08596SBrooks Davis 
46447c08596SBrooks Davis 	priv_script_init("PREINIT", NULL);
46547c08596SBrooks Davis 	if (ifi->client->alias)
46647c08596SBrooks Davis 		priv_script_write_params("alias_", ifi->client->alias);
46747c08596SBrooks Davis 	priv_script_go();
46847c08596SBrooks Davis 
46947c08596SBrooks Davis 	if ((routefd = socket(PF_ROUTE, SOCK_RAW, 0)) != -1)
47047c08596SBrooks Davis 		add_protocol("AF_ROUTE", routefd, routehandler, ifi);
47147c08596SBrooks Davis 
47247c08596SBrooks Davis 	/* set up the interface */
47347c08596SBrooks Davis 	discover_interfaces(ifi);
47447c08596SBrooks Davis 
47547c08596SBrooks Davis 	if (chroot(_PATH_VAREMPTY) == -1)
47647c08596SBrooks Davis 		error("chroot");
47747c08596SBrooks Davis 	if (chdir("/") == -1)
47847c08596SBrooks Davis 		error("chdir(\"/\")");
47947c08596SBrooks Davis 
48047c08596SBrooks Davis 	if (setgroups(1, &pw->pw_gid) ||
48147c08596SBrooks Davis 	    setegid(pw->pw_gid) || setgid(pw->pw_gid) ||
48247c08596SBrooks Davis 	    seteuid(pw->pw_uid) || setuid(pw->pw_uid))
48347c08596SBrooks Davis 		error("can't drop privileges: %m");
48447c08596SBrooks Davis 
48547c08596SBrooks Davis 	endpwent();
48647c08596SBrooks Davis 
48747c08596SBrooks Davis 	setproctitle("%s", ifi->name);
48847c08596SBrooks Davis 
4892b19b6fcSBrooks Davis 	if (immediate_daemon)
4902b19b6fcSBrooks Davis 		go_daemon();
4912b19b6fcSBrooks Davis 
49247c08596SBrooks Davis 	ifi->client->state = S_INIT;
49347c08596SBrooks Davis 	state_reboot(ifi);
49447c08596SBrooks Davis 
49547c08596SBrooks Davis 	bootp_packet_handler = do_packet;
49647c08596SBrooks Davis 
49747c08596SBrooks Davis 	dispatch();
49847c08596SBrooks Davis 
49947c08596SBrooks Davis 	/* not reached */
50047c08596SBrooks Davis 	return (0);
50147c08596SBrooks Davis }
50247c08596SBrooks Davis 
50347c08596SBrooks Davis void
50447c08596SBrooks Davis usage(void)
50547c08596SBrooks Davis {
50647c08596SBrooks Davis 	extern char	*__progname;
50747c08596SBrooks Davis 
5083dd3357aSBrian Somers 	fprintf(stderr, "usage: %s [-bdqu] ", __progname);
50947c08596SBrooks Davis 	fprintf(stderr, "[-c conffile] [-l leasefile] interface\n");
51047c08596SBrooks Davis 	exit(1);
51147c08596SBrooks Davis }
51247c08596SBrooks Davis 
51347c08596SBrooks Davis /*
51447c08596SBrooks Davis  * Individual States:
51547c08596SBrooks Davis  *
51647c08596SBrooks Davis  * Each routine is called from the dhclient_state_machine() in one of
51747c08596SBrooks Davis  * these conditions:
51847c08596SBrooks Davis  * -> entering INIT state
51947c08596SBrooks Davis  * -> recvpacket_flag == 0: timeout in this state
52047c08596SBrooks Davis  * -> otherwise: received a packet in this state
52147c08596SBrooks Davis  *
52247c08596SBrooks Davis  * Return conditions as handled by dhclient_state_machine():
52347c08596SBrooks Davis  * Returns 1, sendpacket_flag = 1: send packet, reset timer.
52447c08596SBrooks Davis  * Returns 1, sendpacket_flag = 0: just reset the timer (wait for a milestone).
52547c08596SBrooks Davis  * Returns 0: finish the nap which was interrupted for no good reason.
52647c08596SBrooks Davis  *
52747c08596SBrooks Davis  * Several per-interface variables are used to keep track of the process:
52847c08596SBrooks Davis  *   active_lease: the lease that is being used on the interface
52947c08596SBrooks Davis  *                 (null pointer if not configured yet).
53047c08596SBrooks Davis  *   offered_leases: leases corresponding to DHCPOFFER messages that have
53147c08596SBrooks Davis  *                   been sent to us by DHCP servers.
53247c08596SBrooks Davis  *   acked_leases: leases corresponding to DHCPACK messages that have been
53347c08596SBrooks Davis  *                 sent to us by DHCP servers.
53447c08596SBrooks Davis  *   sendpacket: DHCP packet we're trying to send.
53547c08596SBrooks Davis  *   destination: IP address to send sendpacket to
53647c08596SBrooks Davis  * In addition, there are several relevant per-lease variables.
53747c08596SBrooks Davis  *   T1_expiry, T2_expiry, lease_expiry: lease milestones
53847c08596SBrooks Davis  * In the active lease, these control the process of renewing the lease;
53947c08596SBrooks Davis  * In leases on the acked_leases list, this simply determines when we
54047c08596SBrooks Davis  * can no longer legitimately use the lease.
54147c08596SBrooks Davis  */
54247c08596SBrooks Davis 
54347c08596SBrooks Davis void
54447c08596SBrooks Davis state_reboot(void *ipp)
54547c08596SBrooks Davis {
54647c08596SBrooks Davis 	struct interface_info *ip = ipp;
54747c08596SBrooks Davis 
54847c08596SBrooks Davis 	/* If we don't remember an active lease, go straight to INIT. */
54947c08596SBrooks Davis 	if (!ip->client->active || ip->client->active->is_bootp) {
55047c08596SBrooks Davis 		state_init(ip);
55147c08596SBrooks Davis 		return;
55247c08596SBrooks Davis 	}
55347c08596SBrooks Davis 
55447c08596SBrooks Davis 	/* We are in the rebooting state. */
55547c08596SBrooks Davis 	ip->client->state = S_REBOOTING;
55647c08596SBrooks Davis 
55747c08596SBrooks Davis 	/* make_request doesn't initialize xid because it normally comes
55847c08596SBrooks Davis 	   from the DHCPDISCOVER, but we haven't sent a DHCPDISCOVER,
55947c08596SBrooks Davis 	   so pick an xid now. */
56047c08596SBrooks Davis 	ip->client->xid = arc4random();
56147c08596SBrooks Davis 
56247c08596SBrooks Davis 	/* Make a DHCPREQUEST packet, and set appropriate per-interface
56347c08596SBrooks Davis 	   flags. */
56447c08596SBrooks Davis 	make_request(ip, ip->client->active);
56547c08596SBrooks Davis 	ip->client->destination = iaddr_broadcast;
56647c08596SBrooks Davis 	ip->client->first_sending = cur_time;
56747c08596SBrooks Davis 	ip->client->interval = ip->client->config->initial_interval;
56847c08596SBrooks Davis 
56947c08596SBrooks Davis 	/* Zap the medium list... */
57047c08596SBrooks Davis 	ip->client->medium = NULL;
57147c08596SBrooks Davis 
57247c08596SBrooks Davis 	/* Send out the first DHCPREQUEST packet. */
57347c08596SBrooks Davis 	send_request(ip);
57447c08596SBrooks Davis }
57547c08596SBrooks Davis 
57647c08596SBrooks Davis /*
57747c08596SBrooks Davis  * Called when a lease has completely expired and we've
57847c08596SBrooks Davis  * been unable to renew it.
57947c08596SBrooks Davis  */
58047c08596SBrooks Davis void
58147c08596SBrooks Davis state_init(void *ipp)
58247c08596SBrooks Davis {
58347c08596SBrooks Davis 	struct interface_info *ip = ipp;
58447c08596SBrooks Davis 
58547c08596SBrooks Davis 	ASSERT_STATE(state, S_INIT);
58647c08596SBrooks Davis 
58747c08596SBrooks Davis 	/* Make a DHCPDISCOVER packet, and set appropriate per-interface
58847c08596SBrooks Davis 	   flags. */
58947c08596SBrooks Davis 	make_discover(ip, ip->client->active);
59047c08596SBrooks Davis 	ip->client->xid = ip->client->packet.xid;
59147c08596SBrooks Davis 	ip->client->destination = iaddr_broadcast;
59247c08596SBrooks Davis 	ip->client->state = S_SELECTING;
59347c08596SBrooks Davis 	ip->client->first_sending = cur_time;
59447c08596SBrooks Davis 	ip->client->interval = ip->client->config->initial_interval;
59547c08596SBrooks Davis 
59647c08596SBrooks Davis 	/* Add an immediate timeout to cause the first DHCPDISCOVER packet
59747c08596SBrooks Davis 	   to go out. */
59847c08596SBrooks Davis 	send_discover(ip);
59947c08596SBrooks Davis }
60047c08596SBrooks Davis 
60147c08596SBrooks Davis /*
60247c08596SBrooks Davis  * state_selecting is called when one or more DHCPOFFER packets
60347c08596SBrooks Davis  * have been received and a configurable period of time has passed.
60447c08596SBrooks Davis  */
60547c08596SBrooks Davis void
60647c08596SBrooks Davis state_selecting(void *ipp)
60747c08596SBrooks Davis {
60847c08596SBrooks Davis 	struct interface_info *ip = ipp;
60947c08596SBrooks Davis 	struct client_lease *lp, *next, *picked;
61047c08596SBrooks Davis 
61147c08596SBrooks Davis 	ASSERT_STATE(state, S_SELECTING);
61247c08596SBrooks Davis 
61347c08596SBrooks Davis 	/* Cancel state_selecting and send_discover timeouts, since either
61447c08596SBrooks Davis 	   one could have got us here. */
61547c08596SBrooks Davis 	cancel_timeout(state_selecting, ip);
61647c08596SBrooks Davis 	cancel_timeout(send_discover, ip);
61747c08596SBrooks Davis 
61847c08596SBrooks Davis 	/* We have received one or more DHCPOFFER packets.   Currently,
61947c08596SBrooks Davis 	   the only criterion by which we judge leases is whether or
62047c08596SBrooks Davis 	   not we get a response when we arp for them. */
62147c08596SBrooks Davis 	picked = NULL;
62247c08596SBrooks Davis 	for (lp = ip->client->offered_leases; lp; lp = next) {
62347c08596SBrooks Davis 		next = lp->next;
62447c08596SBrooks Davis 
62547c08596SBrooks Davis 		/* Check to see if we got an ARPREPLY for the address
62647c08596SBrooks Davis 		   in this particular lease. */
62747c08596SBrooks Davis 		if (!picked) {
62847c08596SBrooks Davis 			script_init("ARPCHECK", lp->medium);
62947c08596SBrooks Davis 			script_write_params("check_", lp);
63047c08596SBrooks Davis 
63147c08596SBrooks Davis 			/* If the ARPCHECK code detects another
63247c08596SBrooks Davis 			   machine using the offered address, it exits
63347c08596SBrooks Davis 			   nonzero.  We need to send a DHCPDECLINE and
63447c08596SBrooks Davis 			   toss the lease. */
63547c08596SBrooks Davis 			if (script_go()) {
63647c08596SBrooks Davis 				make_decline(ip, lp);
63747c08596SBrooks Davis 				send_decline(ip);
63847c08596SBrooks Davis 				goto freeit;
63947c08596SBrooks Davis 			}
64047c08596SBrooks Davis 			picked = lp;
64147c08596SBrooks Davis 			picked->next = NULL;
64247c08596SBrooks Davis 		} else {
64347c08596SBrooks Davis freeit:
64447c08596SBrooks Davis 			free_client_lease(lp);
64547c08596SBrooks Davis 		}
64647c08596SBrooks Davis 	}
64747c08596SBrooks Davis 	ip->client->offered_leases = NULL;
64847c08596SBrooks Davis 
64947c08596SBrooks Davis 	/* If we just tossed all the leases we were offered, go back
65047c08596SBrooks Davis 	   to square one. */
65147c08596SBrooks Davis 	if (!picked) {
65247c08596SBrooks Davis 		ip->client->state = S_INIT;
65347c08596SBrooks Davis 		state_init(ip);
65447c08596SBrooks Davis 		return;
65547c08596SBrooks Davis 	}
65647c08596SBrooks Davis 
65747c08596SBrooks Davis 	/* If it was a BOOTREPLY, we can just take the address right now. */
65847c08596SBrooks Davis 	if (!picked->options[DHO_DHCP_MESSAGE_TYPE].len) {
65947c08596SBrooks Davis 		ip->client->new = picked;
66047c08596SBrooks Davis 
66147c08596SBrooks Davis 		/* Make up some lease expiry times
66247c08596SBrooks Davis 		   XXX these should be configurable. */
66347c08596SBrooks Davis 		ip->client->new->expiry = cur_time + 12000;
66447c08596SBrooks Davis 		ip->client->new->renewal += cur_time + 8000;
66547c08596SBrooks Davis 		ip->client->new->rebind += cur_time + 10000;
66647c08596SBrooks Davis 
66747c08596SBrooks Davis 		ip->client->state = S_REQUESTING;
66847c08596SBrooks Davis 
66947c08596SBrooks Davis 		/* Bind to the address we received. */
67047c08596SBrooks Davis 		bind_lease(ip);
67147c08596SBrooks Davis 		return;
67247c08596SBrooks Davis 	}
67347c08596SBrooks Davis 
67447c08596SBrooks Davis 	/* Go to the REQUESTING state. */
67547c08596SBrooks Davis 	ip->client->destination = iaddr_broadcast;
67647c08596SBrooks Davis 	ip->client->state = S_REQUESTING;
67747c08596SBrooks Davis 	ip->client->first_sending = cur_time;
67847c08596SBrooks Davis 	ip->client->interval = ip->client->config->initial_interval;
67947c08596SBrooks Davis 
68047c08596SBrooks Davis 	/* Make a DHCPREQUEST packet from the lease we picked. */
68147c08596SBrooks Davis 	make_request(ip, picked);
68247c08596SBrooks Davis 	ip->client->xid = ip->client->packet.xid;
68347c08596SBrooks Davis 
68447c08596SBrooks Davis 	/* Toss the lease we picked - we'll get it back in a DHCPACK. */
68547c08596SBrooks Davis 	free_client_lease(picked);
68647c08596SBrooks Davis 
68747c08596SBrooks Davis 	/* Add an immediate timeout to send the first DHCPREQUEST packet. */
68847c08596SBrooks Davis 	send_request(ip);
68947c08596SBrooks Davis }
69047c08596SBrooks Davis 
69147c08596SBrooks Davis /* state_requesting is called when we receive a DHCPACK message after
69247c08596SBrooks Davis    having sent out one or more DHCPREQUEST packets. */
69347c08596SBrooks Davis 
69447c08596SBrooks Davis void
69547c08596SBrooks Davis dhcpack(struct packet *packet)
69647c08596SBrooks Davis {
69747c08596SBrooks Davis 	struct interface_info *ip = packet->interface;
69847c08596SBrooks Davis 	struct client_lease *lease;
69947c08596SBrooks Davis 
70047c08596SBrooks Davis 	/* If we're not receptive to an offer right now, or if the offer
70147c08596SBrooks Davis 	   has an unrecognizable transaction id, then just drop it. */
70247c08596SBrooks Davis 	if (packet->interface->client->xid != packet->raw->xid ||
70347c08596SBrooks Davis 	    (packet->interface->hw_address.hlen != packet->raw->hlen) ||
70447c08596SBrooks Davis 	    (memcmp(packet->interface->hw_address.haddr,
70547c08596SBrooks Davis 	    packet->raw->chaddr, packet->raw->hlen)))
70647c08596SBrooks Davis 		return;
70747c08596SBrooks Davis 
70847c08596SBrooks Davis 	if (ip->client->state != S_REBOOTING &&
70947c08596SBrooks Davis 	    ip->client->state != S_REQUESTING &&
71047c08596SBrooks Davis 	    ip->client->state != S_RENEWING &&
71147c08596SBrooks Davis 	    ip->client->state != S_REBINDING)
71247c08596SBrooks Davis 		return;
71347c08596SBrooks Davis 
71447c08596SBrooks Davis 	note("DHCPACK from %s", piaddr(packet->client_addr));
71547c08596SBrooks Davis 
71647c08596SBrooks Davis 	lease = packet_to_lease(packet);
71747c08596SBrooks Davis 	if (!lease) {
71847c08596SBrooks Davis 		note("packet_to_lease failed.");
71947c08596SBrooks Davis 		return;
72047c08596SBrooks Davis 	}
72147c08596SBrooks Davis 
72247c08596SBrooks Davis 	ip->client->new = lease;
72347c08596SBrooks Davis 
72447c08596SBrooks Davis 	/* Stop resending DHCPREQUEST. */
72547c08596SBrooks Davis 	cancel_timeout(send_request, ip);
72647c08596SBrooks Davis 
72747c08596SBrooks Davis 	/* Figure out the lease time. */
72847c08596SBrooks Davis 	if (ip->client->new->options[DHO_DHCP_LEASE_TIME].data)
72947c08596SBrooks Davis 		ip->client->new->expiry = getULong(
73047c08596SBrooks Davis 		    ip->client->new->options[DHO_DHCP_LEASE_TIME].data);
73147c08596SBrooks Davis 	else
73247c08596SBrooks Davis 		ip->client->new->expiry = default_lease_time;
73347c08596SBrooks Davis 	/* A number that looks negative here is really just very large,
73447c08596SBrooks Davis 	   because the lease expiry offset is unsigned. */
73547c08596SBrooks Davis 	if (ip->client->new->expiry < 0)
73647c08596SBrooks Davis 		ip->client->new->expiry = TIME_MAX;
73747c08596SBrooks Davis 	/* XXX should be fixed by resetting the client state */
73847c08596SBrooks Davis 	if (ip->client->new->expiry < 60)
73947c08596SBrooks Davis 		ip->client->new->expiry = 60;
74047c08596SBrooks Davis 
74147c08596SBrooks Davis 	/* Take the server-provided renewal time if there is one;
74247c08596SBrooks Davis 	   otherwise figure it out according to the spec. */
74347c08596SBrooks Davis 	if (ip->client->new->options[DHO_DHCP_RENEWAL_TIME].len)
74447c08596SBrooks Davis 		ip->client->new->renewal = getULong(
74547c08596SBrooks Davis 		    ip->client->new->options[DHO_DHCP_RENEWAL_TIME].data);
74647c08596SBrooks Davis 	else
74747c08596SBrooks Davis 		ip->client->new->renewal = ip->client->new->expiry / 2;
74847c08596SBrooks Davis 
74947c08596SBrooks Davis 	/* Same deal with the rebind time. */
75047c08596SBrooks Davis 	if (ip->client->new->options[DHO_DHCP_REBINDING_TIME].len)
75147c08596SBrooks Davis 		ip->client->new->rebind = getULong(
75247c08596SBrooks Davis 		    ip->client->new->options[DHO_DHCP_REBINDING_TIME].data);
75347c08596SBrooks Davis 	else
75447c08596SBrooks Davis 		ip->client->new->rebind = ip->client->new->renewal +
75547c08596SBrooks Davis 		    ip->client->new->renewal / 2 + ip->client->new->renewal / 4;
75647c08596SBrooks Davis 
75747c08596SBrooks Davis 	ip->client->new->expiry += cur_time;
75847c08596SBrooks Davis 	/* Lease lengths can never be negative. */
75947c08596SBrooks Davis 	if (ip->client->new->expiry < cur_time)
76047c08596SBrooks Davis 		ip->client->new->expiry = TIME_MAX;
76147c08596SBrooks Davis 	ip->client->new->renewal += cur_time;
76247c08596SBrooks Davis 	if (ip->client->new->renewal < cur_time)
76347c08596SBrooks Davis 		ip->client->new->renewal = TIME_MAX;
76447c08596SBrooks Davis 	ip->client->new->rebind += cur_time;
76547c08596SBrooks Davis 	if (ip->client->new->rebind < cur_time)
76647c08596SBrooks Davis 		ip->client->new->rebind = TIME_MAX;
76747c08596SBrooks Davis 
76847c08596SBrooks Davis 	bind_lease(ip);
76947c08596SBrooks Davis }
77047c08596SBrooks Davis 
77147c08596SBrooks Davis void
77247c08596SBrooks Davis bind_lease(struct interface_info *ip)
77347c08596SBrooks Davis {
77447c08596SBrooks Davis 	/* Remember the medium. */
77547c08596SBrooks Davis 	ip->client->new->medium = ip->client->medium;
77647c08596SBrooks Davis 
77747c08596SBrooks Davis 	/* Write out the new lease. */
77847c08596SBrooks Davis 	write_client_lease(ip, ip->client->new, 0);
77947c08596SBrooks Davis 
78047c08596SBrooks Davis 	/* Run the client script with the new parameters. */
78147c08596SBrooks Davis 	script_init((ip->client->state == S_REQUESTING ? "BOUND" :
78247c08596SBrooks Davis 	    (ip->client->state == S_RENEWING ? "RENEW" :
78347c08596SBrooks Davis 	    (ip->client->state == S_REBOOTING ? "REBOOT" : "REBIND"))),
78447c08596SBrooks Davis 	    ip->client->new->medium);
78547c08596SBrooks Davis 	if (ip->client->active && ip->client->state != S_REBOOTING)
78647c08596SBrooks Davis 		script_write_params("old_", ip->client->active);
78747c08596SBrooks Davis 	script_write_params("new_", ip->client->new);
78847c08596SBrooks Davis 	if (ip->client->alias)
78947c08596SBrooks Davis 		script_write_params("alias_", ip->client->alias);
79047c08596SBrooks Davis 	script_go();
79147c08596SBrooks Davis 
79247c08596SBrooks Davis 	/* Replace the old active lease with the new one. */
79347c08596SBrooks Davis 	if (ip->client->active)
79447c08596SBrooks Davis 		free_client_lease(ip->client->active);
79547c08596SBrooks Davis 	ip->client->active = ip->client->new;
79647c08596SBrooks Davis 	ip->client->new = NULL;
79747c08596SBrooks Davis 
79847c08596SBrooks Davis 	/* Set up a timeout to start the renewal process. */
79947c08596SBrooks Davis 	add_timeout(ip->client->active->renewal, state_bound, ip);
80047c08596SBrooks Davis 
80147c08596SBrooks Davis 	note("bound to %s -- renewal in %d seconds.",
80247c08596SBrooks Davis 	    piaddr(ip->client->active->address),
8039c13d9cdSBrooks Davis 	    (int)(ip->client->active->renewal - cur_time));
80447c08596SBrooks Davis 	ip->client->state = S_BOUND;
80547c08596SBrooks Davis 	reinitialize_interfaces();
80647c08596SBrooks Davis 	go_daemon();
80747c08596SBrooks Davis }
80847c08596SBrooks Davis 
80947c08596SBrooks Davis /*
81047c08596SBrooks Davis  * state_bound is called when we've successfully bound to a particular
81147c08596SBrooks Davis  * lease, but the renewal time on that lease has expired.   We are
81247c08596SBrooks Davis  * expected to unicast a DHCPREQUEST to the server that gave us our
81347c08596SBrooks Davis  * original lease.
81447c08596SBrooks Davis  */
81547c08596SBrooks Davis void
81647c08596SBrooks Davis state_bound(void *ipp)
81747c08596SBrooks Davis {
81847c08596SBrooks Davis 	struct interface_info *ip = ipp;
81947c08596SBrooks Davis 
82047c08596SBrooks Davis 	ASSERT_STATE(state, S_BOUND);
82147c08596SBrooks Davis 
82247c08596SBrooks Davis 	/* T1 has expired. */
82347c08596SBrooks Davis 	make_request(ip, ip->client->active);
82447c08596SBrooks Davis 	ip->client->xid = ip->client->packet.xid;
82547c08596SBrooks Davis 
82647c08596SBrooks Davis 	if (ip->client->active->options[DHO_DHCP_SERVER_IDENTIFIER].len == 4) {
82747c08596SBrooks Davis 		memcpy(ip->client->destination.iabuf, ip->client->active->
82847c08596SBrooks Davis 		    options[DHO_DHCP_SERVER_IDENTIFIER].data, 4);
82947c08596SBrooks Davis 		ip->client->destination.len = 4;
83047c08596SBrooks Davis 	} else
83147c08596SBrooks Davis 		ip->client->destination = iaddr_broadcast;
83247c08596SBrooks Davis 
83347c08596SBrooks Davis 	ip->client->first_sending = cur_time;
83447c08596SBrooks Davis 	ip->client->interval = ip->client->config->initial_interval;
83547c08596SBrooks Davis 	ip->client->state = S_RENEWING;
83647c08596SBrooks Davis 
83747c08596SBrooks Davis 	/* Send the first packet immediately. */
83847c08596SBrooks Davis 	send_request(ip);
83947c08596SBrooks Davis }
84047c08596SBrooks Davis 
84147c08596SBrooks Davis void
84247c08596SBrooks Davis bootp(struct packet *packet)
84347c08596SBrooks Davis {
84447c08596SBrooks Davis 	struct iaddrlist *ap;
84547c08596SBrooks Davis 
84647c08596SBrooks Davis 	if (packet->raw->op != BOOTREPLY)
84747c08596SBrooks Davis 		return;
84847c08596SBrooks Davis 
84947c08596SBrooks Davis 	/* If there's a reject list, make sure this packet's sender isn't
85047c08596SBrooks Davis 	   on it. */
85147c08596SBrooks Davis 	for (ap = packet->interface->client->config->reject_list;
85247c08596SBrooks Davis 	    ap; ap = ap->next) {
85347c08596SBrooks Davis 		if (addr_eq(packet->client_addr, ap->addr)) {
85447c08596SBrooks Davis 			note("BOOTREPLY from %s rejected.", piaddr(ap->addr));
85547c08596SBrooks Davis 			return;
85647c08596SBrooks Davis 		}
85747c08596SBrooks Davis 	}
85847c08596SBrooks Davis 	dhcpoffer(packet);
85947c08596SBrooks Davis }
86047c08596SBrooks Davis 
86147c08596SBrooks Davis void
86247c08596SBrooks Davis dhcp(struct packet *packet)
86347c08596SBrooks Davis {
86447c08596SBrooks Davis 	struct iaddrlist *ap;
86547c08596SBrooks Davis 	void (*handler)(struct packet *);
86647c08596SBrooks Davis 	char *type;
86747c08596SBrooks Davis 
86847c08596SBrooks Davis 	switch (packet->packet_type) {
86947c08596SBrooks Davis 	case DHCPOFFER:
87047c08596SBrooks Davis 		handler = dhcpoffer;
87147c08596SBrooks Davis 		type = "DHCPOFFER";
87247c08596SBrooks Davis 		break;
87347c08596SBrooks Davis 	case DHCPNAK:
87447c08596SBrooks Davis 		handler = dhcpnak;
87547c08596SBrooks Davis 		type = "DHCPNACK";
87647c08596SBrooks Davis 		break;
87747c08596SBrooks Davis 	case DHCPACK:
87847c08596SBrooks Davis 		handler = dhcpack;
87947c08596SBrooks Davis 		type = "DHCPACK";
88047c08596SBrooks Davis 		break;
88147c08596SBrooks Davis 	default:
88247c08596SBrooks Davis 		return;
88347c08596SBrooks Davis 	}
88447c08596SBrooks Davis 
88547c08596SBrooks Davis 	/* If there's a reject list, make sure this packet's sender isn't
88647c08596SBrooks Davis 	   on it. */
88747c08596SBrooks Davis 	for (ap = packet->interface->client->config->reject_list;
88847c08596SBrooks Davis 	    ap; ap = ap->next) {
88947c08596SBrooks Davis 		if (addr_eq(packet->client_addr, ap->addr)) {
89047c08596SBrooks Davis 			note("%s from %s rejected.", type, piaddr(ap->addr));
89147c08596SBrooks Davis 			return;
89247c08596SBrooks Davis 		}
89347c08596SBrooks Davis 	}
89447c08596SBrooks Davis 	(*handler)(packet);
89547c08596SBrooks Davis }
89647c08596SBrooks Davis 
89747c08596SBrooks Davis void
89847c08596SBrooks Davis dhcpoffer(struct packet *packet)
89947c08596SBrooks Davis {
90047c08596SBrooks Davis 	struct interface_info *ip = packet->interface;
90147c08596SBrooks Davis 	struct client_lease *lease, *lp;
90247c08596SBrooks Davis 	int i;
90347c08596SBrooks Davis 	int arp_timeout_needed, stop_selecting;
90447c08596SBrooks Davis 	char *name = packet->options[DHO_DHCP_MESSAGE_TYPE].len ?
90547c08596SBrooks Davis 	    "DHCPOFFER" : "BOOTREPLY";
90647c08596SBrooks Davis 
90747c08596SBrooks Davis 	/* If we're not receptive to an offer right now, or if the offer
90847c08596SBrooks Davis 	   has an unrecognizable transaction id, then just drop it. */
90947c08596SBrooks Davis 	if (ip->client->state != S_SELECTING ||
91047c08596SBrooks Davis 	    packet->interface->client->xid != packet->raw->xid ||
91147c08596SBrooks Davis 	    (packet->interface->hw_address.hlen != packet->raw->hlen) ||
91247c08596SBrooks Davis 	    (memcmp(packet->interface->hw_address.haddr,
91347c08596SBrooks Davis 	    packet->raw->chaddr, packet->raw->hlen)))
91447c08596SBrooks Davis 		return;
91547c08596SBrooks Davis 
91647c08596SBrooks Davis 	note("%s from %s", name, piaddr(packet->client_addr));
91747c08596SBrooks Davis 
91847c08596SBrooks Davis 
91947c08596SBrooks Davis 	/* If this lease doesn't supply the minimum required parameters,
92047c08596SBrooks Davis 	   blow it off. */
92147c08596SBrooks Davis 	for (i = 0; ip->client->config->required_options[i]; i++) {
92247c08596SBrooks Davis 		if (!packet->options[ip->client->config->
92347c08596SBrooks Davis 		    required_options[i]].len) {
92447c08596SBrooks Davis 			note("%s isn't satisfactory.", name);
92547c08596SBrooks Davis 			return;
92647c08596SBrooks Davis 		}
92747c08596SBrooks Davis 	}
92847c08596SBrooks Davis 
92947c08596SBrooks Davis 	/* If we've already seen this lease, don't record it again. */
93047c08596SBrooks Davis 	for (lease = ip->client->offered_leases;
93147c08596SBrooks Davis 	    lease; lease = lease->next) {
93247c08596SBrooks Davis 		if (lease->address.len == sizeof(packet->raw->yiaddr) &&
93347c08596SBrooks Davis 		    !memcmp(lease->address.iabuf,
93447c08596SBrooks Davis 		    &packet->raw->yiaddr, lease->address.len)) {
93547c08596SBrooks Davis 			debug("%s already seen.", name);
93647c08596SBrooks Davis 			return;
93747c08596SBrooks Davis 		}
93847c08596SBrooks Davis 	}
93947c08596SBrooks Davis 
94047c08596SBrooks Davis 	lease = packet_to_lease(packet);
94147c08596SBrooks Davis 	if (!lease) {
94247c08596SBrooks Davis 		note("packet_to_lease failed.");
94347c08596SBrooks Davis 		return;
94447c08596SBrooks Davis 	}
94547c08596SBrooks Davis 
94647c08596SBrooks Davis 	/* If this lease was acquired through a BOOTREPLY, record that
94747c08596SBrooks Davis 	   fact. */
94847c08596SBrooks Davis 	if (!packet->options[DHO_DHCP_MESSAGE_TYPE].len)
94947c08596SBrooks Davis 		lease->is_bootp = 1;
95047c08596SBrooks Davis 
95147c08596SBrooks Davis 	/* Record the medium under which this lease was offered. */
95247c08596SBrooks Davis 	lease->medium = ip->client->medium;
95347c08596SBrooks Davis 
95447c08596SBrooks Davis 	/* Send out an ARP Request for the offered IP address. */
95547c08596SBrooks Davis 	script_init("ARPSEND", lease->medium);
95647c08596SBrooks Davis 	script_write_params("check_", lease);
95747c08596SBrooks Davis 	/* If the script can't send an ARP request without waiting,
95847c08596SBrooks Davis 	   we'll be waiting when we do the ARPCHECK, so don't wait now. */
95947c08596SBrooks Davis 	if (script_go())
96047c08596SBrooks Davis 		arp_timeout_needed = 0;
96147c08596SBrooks Davis 	else
96247c08596SBrooks Davis 		arp_timeout_needed = 2;
96347c08596SBrooks Davis 
96447c08596SBrooks Davis 	/* Figure out when we're supposed to stop selecting. */
96547c08596SBrooks Davis 	stop_selecting =
96647c08596SBrooks Davis 	    ip->client->first_sending + ip->client->config->select_interval;
96747c08596SBrooks Davis 
96847c08596SBrooks Davis 	/* If this is the lease we asked for, put it at the head of the
96947c08596SBrooks Davis 	   list, and don't mess with the arp request timeout. */
97047c08596SBrooks Davis 	if (lease->address.len == ip->client->requested_address.len &&
97147c08596SBrooks Davis 	    !memcmp(lease->address.iabuf,
97247c08596SBrooks Davis 	    ip->client->requested_address.iabuf,
97347c08596SBrooks Davis 	    ip->client->requested_address.len)) {
97447c08596SBrooks Davis 		lease->next = ip->client->offered_leases;
97547c08596SBrooks Davis 		ip->client->offered_leases = lease;
97647c08596SBrooks Davis 	} else {
97747c08596SBrooks Davis 		/* If we already have an offer, and arping for this
97847c08596SBrooks Davis 		   offer would take us past the selection timeout,
97947c08596SBrooks Davis 		   then don't extend the timeout - just hope for the
98047c08596SBrooks Davis 		   best. */
98147c08596SBrooks Davis 		if (ip->client->offered_leases &&
98247c08596SBrooks Davis 		    (cur_time + arp_timeout_needed) > stop_selecting)
98347c08596SBrooks Davis 			arp_timeout_needed = 0;
98447c08596SBrooks Davis 
98547c08596SBrooks Davis 		/* Put the lease at the end of the list. */
98647c08596SBrooks Davis 		lease->next = NULL;
98747c08596SBrooks Davis 		if (!ip->client->offered_leases)
98847c08596SBrooks Davis 			ip->client->offered_leases = lease;
98947c08596SBrooks Davis 		else {
99047c08596SBrooks Davis 			for (lp = ip->client->offered_leases; lp->next;
99147c08596SBrooks Davis 			    lp = lp->next)
99247c08596SBrooks Davis 				;	/* nothing */
99347c08596SBrooks Davis 			lp->next = lease;
99447c08596SBrooks Davis 		}
99547c08596SBrooks Davis 	}
99647c08596SBrooks Davis 
99747c08596SBrooks Davis 	/* If we're supposed to stop selecting before we've had time
99847c08596SBrooks Davis 	   to wait for the ARPREPLY, add some delay to wait for
99947c08596SBrooks Davis 	   the ARPREPLY. */
100047c08596SBrooks Davis 	if (stop_selecting - cur_time < arp_timeout_needed)
100147c08596SBrooks Davis 		stop_selecting = cur_time + arp_timeout_needed;
100247c08596SBrooks Davis 
100347c08596SBrooks Davis 	/* If the selecting interval has expired, go immediately to
100447c08596SBrooks Davis 	   state_selecting().  Otherwise, time out into
100547c08596SBrooks Davis 	   state_selecting at the select interval. */
100647c08596SBrooks Davis 	if (stop_selecting <= 0)
100747c08596SBrooks Davis 		state_selecting(ip);
100847c08596SBrooks Davis 	else {
100947c08596SBrooks Davis 		add_timeout(stop_selecting, state_selecting, ip);
101047c08596SBrooks Davis 		cancel_timeout(send_discover, ip);
101147c08596SBrooks Davis 	}
101247c08596SBrooks Davis }
101347c08596SBrooks Davis 
101447c08596SBrooks Davis /* Allocate a client_lease structure and initialize it from the parameters
101547c08596SBrooks Davis    in the specified packet. */
101647c08596SBrooks Davis 
101747c08596SBrooks Davis struct client_lease *
101847c08596SBrooks Davis packet_to_lease(struct packet *packet)
101947c08596SBrooks Davis {
102047c08596SBrooks Davis 	struct client_lease *lease;
102147c08596SBrooks Davis 	int i;
102247c08596SBrooks Davis 
102347c08596SBrooks Davis 	lease = malloc(sizeof(struct client_lease));
102447c08596SBrooks Davis 
102547c08596SBrooks Davis 	if (!lease) {
102647c08596SBrooks Davis 		warning("dhcpoffer: no memory to record lease.");
102747c08596SBrooks Davis 		return (NULL);
102847c08596SBrooks Davis 	}
102947c08596SBrooks Davis 
103047c08596SBrooks Davis 	memset(lease, 0, sizeof(*lease));
103147c08596SBrooks Davis 
103247c08596SBrooks Davis 	/* Copy the lease options. */
103347c08596SBrooks Davis 	for (i = 0; i < 256; i++) {
103447c08596SBrooks Davis 		if (packet->options[i].len) {
103547c08596SBrooks Davis 			lease->options[i].data =
103647c08596SBrooks Davis 			    malloc(packet->options[i].len + 1);
103747c08596SBrooks Davis 			if (!lease->options[i].data) {
103847c08596SBrooks Davis 				warning("dhcpoffer: no memory for option %d", i);
103947c08596SBrooks Davis 				free_client_lease(lease);
104047c08596SBrooks Davis 				return (NULL);
104147c08596SBrooks Davis 			} else {
104247c08596SBrooks Davis 				memcpy(lease->options[i].data,
104347c08596SBrooks Davis 				    packet->options[i].data,
104447c08596SBrooks Davis 				    packet->options[i].len);
104547c08596SBrooks Davis 				lease->options[i].len =
104647c08596SBrooks Davis 				    packet->options[i].len;
104747c08596SBrooks Davis 				lease->options[i].data[lease->options[i].len] =
104847c08596SBrooks Davis 				    0;
104947c08596SBrooks Davis 			}
105047c08596SBrooks Davis 			if (!check_option(lease,i)) {
105147c08596SBrooks Davis 				/* ignore a bogus lease offer */
105247c08596SBrooks Davis 				warning("Invalid lease option - ignoring offer");
105347c08596SBrooks Davis 				free_client_lease(lease);
105447c08596SBrooks Davis 				return (NULL);
105547c08596SBrooks Davis 			}
105647c08596SBrooks Davis 		}
105747c08596SBrooks Davis 	}
105847c08596SBrooks Davis 
105947c08596SBrooks Davis 	lease->address.len = sizeof(packet->raw->yiaddr);
106047c08596SBrooks Davis 	memcpy(lease->address.iabuf, &packet->raw->yiaddr, lease->address.len);
106147c08596SBrooks Davis 
1062acccb9aaSBrooks Davis 	/* If the server name was filled out, copy it.
1063acccb9aaSBrooks Davis 	   Do not attempt to validate the server name as a host name.
1064acccb9aaSBrooks Davis 	   RFC 2131 merely states that sname is NUL-terminated (which do
1065acccb9aaSBrooks Davis 	   do not assume) and that it is the server's host name.  Since
1066acccb9aaSBrooks Davis 	   the ISC client and server allow arbitrary characters, we do
1067acccb9aaSBrooks Davis 	   as well. */
106847c08596SBrooks Davis 	if ((!packet->options[DHO_DHCP_OPTION_OVERLOAD].len ||
106947c08596SBrooks Davis 	    !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 2)) &&
107047c08596SBrooks Davis 	    packet->raw->sname[0]) {
107147c08596SBrooks Davis 		lease->server_name = malloc(DHCP_SNAME_LEN + 1);
107247c08596SBrooks Davis 		if (!lease->server_name) {
107347c08596SBrooks Davis 			warning("dhcpoffer: no memory for server name.");
107447c08596SBrooks Davis 			free_client_lease(lease);
107547c08596SBrooks Davis 			return (NULL);
107647c08596SBrooks Davis 		}
107747c08596SBrooks Davis 		memcpy(lease->server_name, packet->raw->sname, DHCP_SNAME_LEN);
107847c08596SBrooks Davis 		lease->server_name[DHCP_SNAME_LEN]='\0';
107947c08596SBrooks Davis 	}
108047c08596SBrooks Davis 
108147c08596SBrooks Davis 	/* Ditto for the filename. */
108247c08596SBrooks Davis 	if ((!packet->options[DHO_DHCP_OPTION_OVERLOAD].len ||
108347c08596SBrooks Davis 	    !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 1)) &&
108447c08596SBrooks Davis 	    packet->raw->file[0]) {
108547c08596SBrooks Davis 		/* Don't count on the NUL terminator. */
108647c08596SBrooks Davis 		lease->filename = malloc(DHCP_FILE_LEN + 1);
108747c08596SBrooks Davis 		if (!lease->filename) {
108847c08596SBrooks Davis 			warning("dhcpoffer: no memory for filename.");
108947c08596SBrooks Davis 			free_client_lease(lease);
109047c08596SBrooks Davis 			return (NULL);
109147c08596SBrooks Davis 		}
109247c08596SBrooks Davis 		memcpy(lease->filename, packet->raw->file, DHCP_FILE_LEN);
109347c08596SBrooks Davis 		lease->filename[DHCP_FILE_LEN]='\0';
109447c08596SBrooks Davis 	}
109547c08596SBrooks Davis 	return lease;
109647c08596SBrooks Davis }
109747c08596SBrooks Davis 
109847c08596SBrooks Davis void
109947c08596SBrooks Davis dhcpnak(struct packet *packet)
110047c08596SBrooks Davis {
110147c08596SBrooks Davis 	struct interface_info *ip = packet->interface;
110247c08596SBrooks Davis 
110347c08596SBrooks Davis 	/* If we're not receptive to an offer right now, or if the offer
110447c08596SBrooks Davis 	   has an unrecognizable transaction id, then just drop it. */
110547c08596SBrooks Davis 	if (packet->interface->client->xid != packet->raw->xid ||
110647c08596SBrooks Davis 	    (packet->interface->hw_address.hlen != packet->raw->hlen) ||
110747c08596SBrooks Davis 	    (memcmp(packet->interface->hw_address.haddr,
110847c08596SBrooks Davis 	    packet->raw->chaddr, packet->raw->hlen)))
110947c08596SBrooks Davis 		return;
111047c08596SBrooks Davis 
111147c08596SBrooks Davis 	if (ip->client->state != S_REBOOTING &&
111247c08596SBrooks Davis 	    ip->client->state != S_REQUESTING &&
111347c08596SBrooks Davis 	    ip->client->state != S_RENEWING &&
111447c08596SBrooks Davis 	    ip->client->state != S_REBINDING)
111547c08596SBrooks Davis 		return;
111647c08596SBrooks Davis 
111747c08596SBrooks Davis 	note("DHCPNAK from %s", piaddr(packet->client_addr));
111847c08596SBrooks Davis 
111947c08596SBrooks Davis 	if (!ip->client->active) {
112047c08596SBrooks Davis 		note("DHCPNAK with no active lease.\n");
112147c08596SBrooks Davis 		return;
112247c08596SBrooks Davis 	}
112347c08596SBrooks Davis 
112447c08596SBrooks Davis 	free_client_lease(ip->client->active);
112547c08596SBrooks Davis 	ip->client->active = NULL;
112647c08596SBrooks Davis 
112747c08596SBrooks Davis 	/* Stop sending DHCPREQUEST packets... */
112847c08596SBrooks Davis 	cancel_timeout(send_request, ip);
112947c08596SBrooks Davis 
113047c08596SBrooks Davis 	ip->client->state = S_INIT;
113147c08596SBrooks Davis 	state_init(ip);
113247c08596SBrooks Davis }
113347c08596SBrooks Davis 
113447c08596SBrooks Davis /* Send out a DHCPDISCOVER packet, and set a timeout to send out another
113547c08596SBrooks Davis    one after the right interval has expired.  If we don't get an offer by
113647c08596SBrooks Davis    the time we reach the panic interval, call the panic function. */
113747c08596SBrooks Davis 
113847c08596SBrooks Davis void
113947c08596SBrooks Davis send_discover(void *ipp)
114047c08596SBrooks Davis {
114147c08596SBrooks Davis 	struct interface_info *ip = ipp;
114247c08596SBrooks Davis 	int interval, increase = 1;
114347c08596SBrooks Davis 
114447c08596SBrooks Davis 	/* Figure out how long it's been since we started transmitting. */
114547c08596SBrooks Davis 	interval = cur_time - ip->client->first_sending;
114647c08596SBrooks Davis 
114747c08596SBrooks Davis 	/* If we're past the panic timeout, call the script and tell it
114847c08596SBrooks Davis 	   we haven't found anything for this interface yet. */
114947c08596SBrooks Davis 	if (interval > ip->client->config->timeout) {
115047c08596SBrooks Davis 		state_panic(ip);
115147c08596SBrooks Davis 		return;
115247c08596SBrooks Davis 	}
115347c08596SBrooks Davis 
115447c08596SBrooks Davis 	/* If we're selecting media, try the whole list before doing
115547c08596SBrooks Davis 	   the exponential backoff, but if we've already received an
115647c08596SBrooks Davis 	   offer, stop looping, because we obviously have it right. */
115747c08596SBrooks Davis 	if (!ip->client->offered_leases &&
115847c08596SBrooks Davis 	    ip->client->config->media) {
115947c08596SBrooks Davis 		int fail = 0;
116047c08596SBrooks Davis again:
116147c08596SBrooks Davis 		if (ip->client->medium) {
116247c08596SBrooks Davis 			ip->client->medium = ip->client->medium->next;
116347c08596SBrooks Davis 			increase = 0;
116447c08596SBrooks Davis 		}
116547c08596SBrooks Davis 		if (!ip->client->medium) {
116647c08596SBrooks Davis 			if (fail)
116747c08596SBrooks Davis 				error("No valid media types for %s!", ip->name);
116847c08596SBrooks Davis 			ip->client->medium = ip->client->config->media;
116947c08596SBrooks Davis 			increase = 1;
117047c08596SBrooks Davis 		}
117147c08596SBrooks Davis 
117247c08596SBrooks Davis 		note("Trying medium \"%s\" %d", ip->client->medium->string,
117347c08596SBrooks Davis 		    increase);
117447c08596SBrooks Davis 		script_init("MEDIUM", ip->client->medium);
117547c08596SBrooks Davis 		if (script_go())
117647c08596SBrooks Davis 			goto again;
117747c08596SBrooks Davis 	}
117847c08596SBrooks Davis 
117947c08596SBrooks Davis 	/*
118047c08596SBrooks Davis 	 * If we're supposed to increase the interval, do so.  If it's
118147c08596SBrooks Davis 	 * currently zero (i.e., we haven't sent any packets yet), set
118247c08596SBrooks Davis 	 * it to one; otherwise, add to it a random number between zero
118347c08596SBrooks Davis 	 * and two times itself.  On average, this means that it will
118447c08596SBrooks Davis 	 * double with every transmission.
118547c08596SBrooks Davis 	 */
118647c08596SBrooks Davis 	if (increase) {
118747c08596SBrooks Davis 		if (!ip->client->interval)
118847c08596SBrooks Davis 			ip->client->interval =
118947c08596SBrooks Davis 			    ip->client->config->initial_interval;
119047c08596SBrooks Davis 		else {
119147c08596SBrooks Davis 			ip->client->interval += (arc4random() >> 2) %
119247c08596SBrooks Davis 			    (2 * ip->client->interval);
119347c08596SBrooks Davis 		}
119447c08596SBrooks Davis 
119547c08596SBrooks Davis 		/* Don't backoff past cutoff. */
119647c08596SBrooks Davis 		if (ip->client->interval >
119747c08596SBrooks Davis 		    ip->client->config->backoff_cutoff)
119847c08596SBrooks Davis 			ip->client->interval =
119947c08596SBrooks Davis 				((ip->client->config->backoff_cutoff / 2)
120047c08596SBrooks Davis 				 + ((arc4random() >> 2) %
120147c08596SBrooks Davis 				    ip->client->config->backoff_cutoff));
120247c08596SBrooks Davis 	} else if (!ip->client->interval)
120347c08596SBrooks Davis 		ip->client->interval =
120447c08596SBrooks Davis 			ip->client->config->initial_interval;
120547c08596SBrooks Davis 
120647c08596SBrooks Davis 	/* If the backoff would take us to the panic timeout, just use that
120747c08596SBrooks Davis 	   as the interval. */
120847c08596SBrooks Davis 	if (cur_time + ip->client->interval >
120947c08596SBrooks Davis 	    ip->client->first_sending + ip->client->config->timeout)
121047c08596SBrooks Davis 		ip->client->interval =
121147c08596SBrooks Davis 			(ip->client->first_sending +
121247c08596SBrooks Davis 			 ip->client->config->timeout) - cur_time + 1;
121347c08596SBrooks Davis 
121447c08596SBrooks Davis 	/* Record the number of seconds since we started sending. */
121547c08596SBrooks Davis 	if (interval < 65536)
121647c08596SBrooks Davis 		ip->client->packet.secs = htons(interval);
121747c08596SBrooks Davis 	else
121847c08596SBrooks Davis 		ip->client->packet.secs = htons(65535);
121947c08596SBrooks Davis 	ip->client->secs = ip->client->packet.secs;
122047c08596SBrooks Davis 
122147c08596SBrooks Davis 	note("DHCPDISCOVER on %s to %s port %d interval %d",
122247c08596SBrooks Davis 	    ip->name, inet_ntoa(sockaddr_broadcast.sin_addr),
12239c13d9cdSBrooks Davis 	    ntohs(sockaddr_broadcast.sin_port),
12249c13d9cdSBrooks Davis 	    (int)ip->client->interval);
122547c08596SBrooks Davis 
122647c08596SBrooks Davis 	/* Send out a packet. */
122747c08596SBrooks Davis 	(void)send_packet(ip, &ip->client->packet, ip->client->packet_length,
122847c08596SBrooks Davis 	    inaddr_any, &sockaddr_broadcast, NULL);
122947c08596SBrooks Davis 
123047c08596SBrooks Davis 	add_timeout(cur_time + ip->client->interval, send_discover, ip);
123147c08596SBrooks Davis }
123247c08596SBrooks Davis 
123347c08596SBrooks Davis /*
123447c08596SBrooks Davis  * state_panic gets called if we haven't received any offers in a preset
123547c08596SBrooks Davis  * amount of time.   When this happens, we try to use existing leases
123647c08596SBrooks Davis  * that haven't yet expired, and failing that, we call the client script
123747c08596SBrooks Davis  * and hope it can do something.
123847c08596SBrooks Davis  */
123947c08596SBrooks Davis void
124047c08596SBrooks Davis state_panic(void *ipp)
124147c08596SBrooks Davis {
124247c08596SBrooks Davis 	struct interface_info *ip = ipp;
124347c08596SBrooks Davis 	struct client_lease *loop = ip->client->active;
124447c08596SBrooks Davis 	struct client_lease *lp;
124547c08596SBrooks Davis 
124647c08596SBrooks Davis 	note("No DHCPOFFERS received.");
124747c08596SBrooks Davis 
124847c08596SBrooks Davis 	/* We may not have an active lease, but we may have some
124947c08596SBrooks Davis 	   predefined leases that we can try. */
125047c08596SBrooks Davis 	if (!ip->client->active && ip->client->leases)
125147c08596SBrooks Davis 		goto activate_next;
125247c08596SBrooks Davis 
125347c08596SBrooks Davis 	/* Run through the list of leases and see if one can be used. */
125447c08596SBrooks Davis 	while (ip->client->active) {
125547c08596SBrooks Davis 		if (ip->client->active->expiry > cur_time) {
125647c08596SBrooks Davis 			note("Trying recorded lease %s",
125747c08596SBrooks Davis 			    piaddr(ip->client->active->address));
125847c08596SBrooks Davis 			/* Run the client script with the existing
125947c08596SBrooks Davis 			   parameters. */
126047c08596SBrooks Davis 			script_init("TIMEOUT",
126147c08596SBrooks Davis 			    ip->client->active->medium);
126247c08596SBrooks Davis 			script_write_params("new_", ip->client->active);
126347c08596SBrooks Davis 			if (ip->client->alias)
126447c08596SBrooks Davis 				script_write_params("alias_",
126547c08596SBrooks Davis 				    ip->client->alias);
126647c08596SBrooks Davis 
126747c08596SBrooks Davis 			/* If the old lease is still good and doesn't
126847c08596SBrooks Davis 			   yet need renewal, go into BOUND state and
126947c08596SBrooks Davis 			   timeout at the renewal time. */
127047c08596SBrooks Davis 			if (!script_go()) {
127147c08596SBrooks Davis 				if (cur_time <
127247c08596SBrooks Davis 				    ip->client->active->renewal) {
127347c08596SBrooks Davis 					ip->client->state = S_BOUND;
127447c08596SBrooks Davis 					note("bound: renewal in %d seconds.",
12759c13d9cdSBrooks Davis 					    (int)(ip->client->active->renewal -
12769c13d9cdSBrooks Davis 					    cur_time));
127747c08596SBrooks Davis 					add_timeout(
127847c08596SBrooks Davis 					    ip->client->active->renewal,
127947c08596SBrooks Davis 					    state_bound, ip);
128047c08596SBrooks Davis 				} else {
128147c08596SBrooks Davis 					ip->client->state = S_BOUND;
128247c08596SBrooks Davis 					note("bound: immediate renewal.");
128347c08596SBrooks Davis 					state_bound(ip);
128447c08596SBrooks Davis 				}
128547c08596SBrooks Davis 				reinitialize_interfaces();
128647c08596SBrooks Davis 				go_daemon();
128747c08596SBrooks Davis 				return;
128847c08596SBrooks Davis 			}
128947c08596SBrooks Davis 		}
129047c08596SBrooks Davis 
129147c08596SBrooks Davis 		/* If there are no other leases, give up. */
129247c08596SBrooks Davis 		if (!ip->client->leases) {
129347c08596SBrooks Davis 			ip->client->leases = ip->client->active;
129447c08596SBrooks Davis 			ip->client->active = NULL;
129547c08596SBrooks Davis 			break;
129647c08596SBrooks Davis 		}
129747c08596SBrooks Davis 
129847c08596SBrooks Davis activate_next:
129947c08596SBrooks Davis 		/* Otherwise, put the active lease at the end of the
130047c08596SBrooks Davis 		   lease list, and try another lease.. */
130147c08596SBrooks Davis 		for (lp = ip->client->leases; lp->next; lp = lp->next)
130247c08596SBrooks Davis 			;
130347c08596SBrooks Davis 		lp->next = ip->client->active;
130447c08596SBrooks Davis 		if (lp->next)
130547c08596SBrooks Davis 			lp->next->next = NULL;
130647c08596SBrooks Davis 		ip->client->active = ip->client->leases;
130747c08596SBrooks Davis 		ip->client->leases = ip->client->leases->next;
130847c08596SBrooks Davis 
130947c08596SBrooks Davis 		/* If we already tried this lease, we've exhausted the
131047c08596SBrooks Davis 		   set of leases, so we might as well give up for
131147c08596SBrooks Davis 		   now. */
131247c08596SBrooks Davis 		if (ip->client->active == loop)
131347c08596SBrooks Davis 			break;
131447c08596SBrooks Davis 		else if (!loop)
131547c08596SBrooks Davis 			loop = ip->client->active;
131647c08596SBrooks Davis 	}
131747c08596SBrooks Davis 
131847c08596SBrooks Davis 	/* No leases were available, or what was available didn't work, so
131947c08596SBrooks Davis 	   tell the shell script that we failed to allocate an address,
132047c08596SBrooks Davis 	   and try again later. */
132147c08596SBrooks Davis 	note("No working leases in persistent database - sleeping.\n");
132247c08596SBrooks Davis 	script_init("FAIL", NULL);
132347c08596SBrooks Davis 	if (ip->client->alias)
132447c08596SBrooks Davis 		script_write_params("alias_", ip->client->alias);
132547c08596SBrooks Davis 	script_go();
132647c08596SBrooks Davis 	ip->client->state = S_INIT;
132747c08596SBrooks Davis 	add_timeout(cur_time + ip->client->config->retry_interval, state_init,
132847c08596SBrooks Davis 	    ip);
132947c08596SBrooks Davis 	go_daemon();
133047c08596SBrooks Davis }
133147c08596SBrooks Davis 
133247c08596SBrooks Davis void
133347c08596SBrooks Davis send_request(void *ipp)
133447c08596SBrooks Davis {
133547c08596SBrooks Davis 	struct interface_info *ip = ipp;
133647c08596SBrooks Davis 	struct sockaddr_in destination;
133747c08596SBrooks Davis 	struct in_addr from;
133847c08596SBrooks Davis 	int interval;
133947c08596SBrooks Davis 
134047c08596SBrooks Davis 	/* Figure out how long it's been since we started transmitting. */
134147c08596SBrooks Davis 	interval = cur_time - ip->client->first_sending;
134247c08596SBrooks Davis 
134347c08596SBrooks Davis 	/* If we're in the INIT-REBOOT or REQUESTING state and we're
134447c08596SBrooks Davis 	   past the reboot timeout, go to INIT and see if we can
134547c08596SBrooks Davis 	   DISCOVER an address... */
134647c08596SBrooks Davis 	/* XXX In the INIT-REBOOT state, if we don't get an ACK, it
134747c08596SBrooks Davis 	   means either that we're on a network with no DHCP server,
134847c08596SBrooks Davis 	   or that our server is down.  In the latter case, assuming
134947c08596SBrooks Davis 	   that there is a backup DHCP server, DHCPDISCOVER will get
135047c08596SBrooks Davis 	   us a new address, but we could also have successfully
135147c08596SBrooks Davis 	   reused our old address.  In the former case, we're hosed
135247c08596SBrooks Davis 	   anyway.  This is not a win-prone situation. */
135347c08596SBrooks Davis 	if ((ip->client->state == S_REBOOTING ||
135447c08596SBrooks Davis 	    ip->client->state == S_REQUESTING) &&
135547c08596SBrooks Davis 	    interval > ip->client->config->reboot_timeout) {
135647c08596SBrooks Davis cancel:
135747c08596SBrooks Davis 		ip->client->state = S_INIT;
135847c08596SBrooks Davis 		cancel_timeout(send_request, ip);
135947c08596SBrooks Davis 		state_init(ip);
136047c08596SBrooks Davis 		return;
136147c08596SBrooks Davis 	}
136247c08596SBrooks Davis 
136347c08596SBrooks Davis 	/* If we're in the reboot state, make sure the media is set up
136447c08596SBrooks Davis 	   correctly. */
136547c08596SBrooks Davis 	if (ip->client->state == S_REBOOTING &&
136647c08596SBrooks Davis 	    !ip->client->medium &&
136747c08596SBrooks Davis 	    ip->client->active->medium ) {
136847c08596SBrooks Davis 		script_init("MEDIUM", ip->client->active->medium);
136947c08596SBrooks Davis 
137047c08596SBrooks Davis 		/* If the medium we chose won't fly, go to INIT state. */
137147c08596SBrooks Davis 		if (script_go())
137247c08596SBrooks Davis 			goto cancel;
137347c08596SBrooks Davis 
137447c08596SBrooks Davis 		/* Record the medium. */
137547c08596SBrooks Davis 		ip->client->medium = ip->client->active->medium;
137647c08596SBrooks Davis 	}
137747c08596SBrooks Davis 
137847c08596SBrooks Davis 	/* If the lease has expired, relinquish the address and go back
137947c08596SBrooks Davis 	   to the INIT state. */
138047c08596SBrooks Davis 	if (ip->client->state != S_REQUESTING &&
138147c08596SBrooks Davis 	    cur_time > ip->client->active->expiry) {
138247c08596SBrooks Davis 		/* Run the client script with the new parameters. */
138347c08596SBrooks Davis 		script_init("EXPIRE", NULL);
138447c08596SBrooks Davis 		script_write_params("old_", ip->client->active);
138547c08596SBrooks Davis 		if (ip->client->alias)
138647c08596SBrooks Davis 			script_write_params("alias_", ip->client->alias);
138747c08596SBrooks Davis 		script_go();
138847c08596SBrooks Davis 
138947c08596SBrooks Davis 		/* Now do a preinit on the interface so that we can
139047c08596SBrooks Davis 		   discover a new address. */
139147c08596SBrooks Davis 		script_init("PREINIT", NULL);
139247c08596SBrooks Davis 		if (ip->client->alias)
139347c08596SBrooks Davis 			script_write_params("alias_", ip->client->alias);
139447c08596SBrooks Davis 		script_go();
139547c08596SBrooks Davis 
139647c08596SBrooks Davis 		ip->client->state = S_INIT;
139747c08596SBrooks Davis 		state_init(ip);
139847c08596SBrooks Davis 		return;
139947c08596SBrooks Davis 	}
140047c08596SBrooks Davis 
140147c08596SBrooks Davis 	/* Do the exponential backoff... */
140247c08596SBrooks Davis 	if (!ip->client->interval)
140347c08596SBrooks Davis 		ip->client->interval = ip->client->config->initial_interval;
140447c08596SBrooks Davis 	else
140547c08596SBrooks Davis 		ip->client->interval += ((arc4random() >> 2) %
140647c08596SBrooks Davis 		    (2 * ip->client->interval));
140747c08596SBrooks Davis 
140847c08596SBrooks Davis 	/* Don't backoff past cutoff. */
140947c08596SBrooks Davis 	if (ip->client->interval >
141047c08596SBrooks Davis 	    ip->client->config->backoff_cutoff)
141147c08596SBrooks Davis 		ip->client->interval =
141247c08596SBrooks Davis 		    ((ip->client->config->backoff_cutoff / 2) +
141347c08596SBrooks Davis 		    ((arc4random() >> 2) % ip->client->interval));
141447c08596SBrooks Davis 
141547c08596SBrooks Davis 	/* If the backoff would take us to the expiry time, just set the
141647c08596SBrooks Davis 	   timeout to the expiry time. */
141747c08596SBrooks Davis 	if (ip->client->state != S_REQUESTING &&
141847c08596SBrooks Davis 	    cur_time + ip->client->interval >
141947c08596SBrooks Davis 	    ip->client->active->expiry)
142047c08596SBrooks Davis 		ip->client->interval =
142147c08596SBrooks Davis 		    ip->client->active->expiry - cur_time + 1;
142247c08596SBrooks Davis 
142347c08596SBrooks Davis 	/* If the lease T2 time has elapsed, or if we're not yet bound,
142447c08596SBrooks Davis 	   broadcast the DHCPREQUEST rather than unicasting. */
142547c08596SBrooks Davis 	memset(&destination, 0, sizeof(destination));
142647c08596SBrooks Davis 	if (ip->client->state == S_REQUESTING ||
142747c08596SBrooks Davis 	    ip->client->state == S_REBOOTING ||
142847c08596SBrooks Davis 	    cur_time > ip->client->active->rebind)
142947c08596SBrooks Davis 		destination.sin_addr.s_addr = INADDR_BROADCAST;
143047c08596SBrooks Davis 	else
143147c08596SBrooks Davis 		memcpy(&destination.sin_addr.s_addr,
143247c08596SBrooks Davis 		    ip->client->destination.iabuf,
143347c08596SBrooks Davis 		    sizeof(destination.sin_addr.s_addr));
143447c08596SBrooks Davis 	destination.sin_port = htons(REMOTE_PORT);
143547c08596SBrooks Davis 	destination.sin_family = AF_INET;
143647c08596SBrooks Davis 	destination.sin_len = sizeof(destination);
143747c08596SBrooks Davis 
143847c08596SBrooks Davis 	if (ip->client->state != S_REQUESTING)
143947c08596SBrooks Davis 		memcpy(&from, ip->client->active->address.iabuf,
144047c08596SBrooks Davis 		    sizeof(from));
144147c08596SBrooks Davis 	else
144247c08596SBrooks Davis 		from.s_addr = INADDR_ANY;
144347c08596SBrooks Davis 
144447c08596SBrooks Davis 	/* Record the number of seconds since we started sending. */
144547c08596SBrooks Davis 	if (ip->client->state == S_REQUESTING)
144647c08596SBrooks Davis 		ip->client->packet.secs = ip->client->secs;
144747c08596SBrooks Davis 	else {
144847c08596SBrooks Davis 		if (interval < 65536)
144947c08596SBrooks Davis 			ip->client->packet.secs = htons(interval);
145047c08596SBrooks Davis 		else
145147c08596SBrooks Davis 			ip->client->packet.secs = htons(65535);
145247c08596SBrooks Davis 	}
145347c08596SBrooks Davis 
145447c08596SBrooks Davis 	note("DHCPREQUEST on %s to %s port %d", ip->name,
145547c08596SBrooks Davis 	    inet_ntoa(destination.sin_addr), ntohs(destination.sin_port));
145647c08596SBrooks Davis 
145747c08596SBrooks Davis 	/* Send out a packet. */
145847c08596SBrooks Davis 	(void) send_packet(ip, &ip->client->packet, ip->client->packet_length,
145947c08596SBrooks Davis 	    from, &destination, NULL);
146047c08596SBrooks Davis 
146147c08596SBrooks Davis 	add_timeout(cur_time + ip->client->interval, send_request, ip);
146247c08596SBrooks Davis }
146347c08596SBrooks Davis 
146447c08596SBrooks Davis void
146547c08596SBrooks Davis send_decline(void *ipp)
146647c08596SBrooks Davis {
146747c08596SBrooks Davis 	struct interface_info *ip = ipp;
146847c08596SBrooks Davis 
146947c08596SBrooks Davis 	note("DHCPDECLINE on %s to %s port %d", ip->name,
147047c08596SBrooks Davis 	    inet_ntoa(sockaddr_broadcast.sin_addr),
147147c08596SBrooks Davis 	    ntohs(sockaddr_broadcast.sin_port));
147247c08596SBrooks Davis 
147347c08596SBrooks Davis 	/* Send out a packet. */
147447c08596SBrooks Davis 	(void) send_packet(ip, &ip->client->packet, ip->client->packet_length,
147547c08596SBrooks Davis 	    inaddr_any, &sockaddr_broadcast, NULL);
147647c08596SBrooks Davis }
147747c08596SBrooks Davis 
147847c08596SBrooks Davis void
147947c08596SBrooks Davis make_discover(struct interface_info *ip, struct client_lease *lease)
148047c08596SBrooks Davis {
148147c08596SBrooks Davis 	unsigned char discover = DHCPDISCOVER;
148247c08596SBrooks Davis 	struct tree_cache *options[256];
148347c08596SBrooks Davis 	struct tree_cache option_elements[256];
148447c08596SBrooks Davis 	int i;
148547c08596SBrooks Davis 
148647c08596SBrooks Davis 	memset(option_elements, 0, sizeof(option_elements));
148747c08596SBrooks Davis 	memset(options, 0, sizeof(options));
148847c08596SBrooks Davis 	memset(&ip->client->packet, 0, sizeof(ip->client->packet));
148947c08596SBrooks Davis 
149047c08596SBrooks Davis 	/* Set DHCP_MESSAGE_TYPE to DHCPDISCOVER */
149147c08596SBrooks Davis 	i = DHO_DHCP_MESSAGE_TYPE;
149247c08596SBrooks Davis 	options[i] = &option_elements[i];
149347c08596SBrooks Davis 	options[i]->value = &discover;
149447c08596SBrooks Davis 	options[i]->len = sizeof(discover);
149547c08596SBrooks Davis 	options[i]->buf_size = sizeof(discover);
149647c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
149747c08596SBrooks Davis 
149847c08596SBrooks Davis 	/* Request the options we want */
149947c08596SBrooks Davis 	i  = DHO_DHCP_PARAMETER_REQUEST_LIST;
150047c08596SBrooks Davis 	options[i] = &option_elements[i];
150147c08596SBrooks Davis 	options[i]->value = ip->client->config->requested_options;
150247c08596SBrooks Davis 	options[i]->len = ip->client->config->requested_option_count;
150347c08596SBrooks Davis 	options[i]->buf_size =
150447c08596SBrooks Davis 		ip->client->config->requested_option_count;
150547c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
150647c08596SBrooks Davis 
150747c08596SBrooks Davis 	/* If we had an address, try to get it again. */
150847c08596SBrooks Davis 	if (lease) {
150947c08596SBrooks Davis 		ip->client->requested_address = lease->address;
151047c08596SBrooks Davis 		i = DHO_DHCP_REQUESTED_ADDRESS;
151147c08596SBrooks Davis 		options[i] = &option_elements[i];
151247c08596SBrooks Davis 		options[i]->value = lease->address.iabuf;
151347c08596SBrooks Davis 		options[i]->len = lease->address.len;
151447c08596SBrooks Davis 		options[i]->buf_size = lease->address.len;
151547c08596SBrooks Davis 		options[i]->timeout = 0xFFFFFFFF;
151647c08596SBrooks Davis 	} else
151747c08596SBrooks Davis 		ip->client->requested_address.len = 0;
151847c08596SBrooks Davis 
151947c08596SBrooks Davis 	/* Send any options requested in the config file. */
152047c08596SBrooks Davis 	for (i = 0; i < 256; i++)
152147c08596SBrooks Davis 		if (!options[i] &&
152247c08596SBrooks Davis 		    ip->client->config->send_options[i].data) {
152347c08596SBrooks Davis 			options[i] = &option_elements[i];
152447c08596SBrooks Davis 			options[i]->value =
152547c08596SBrooks Davis 			    ip->client->config->send_options[i].data;
152647c08596SBrooks Davis 			options[i]->len =
152747c08596SBrooks Davis 			    ip->client->config->send_options[i].len;
152847c08596SBrooks Davis 			options[i]->buf_size =
152947c08596SBrooks Davis 			    ip->client->config->send_options[i].len;
153047c08596SBrooks Davis 			options[i]->timeout = 0xFFFFFFFF;
153147c08596SBrooks Davis 		}
153247c08596SBrooks Davis 
1533fcab8addSBrooks Davis 	/* send host name if not set via config file. */
1534fcab8addSBrooks Davis 	char hostname[_POSIX_HOST_NAME_MAX+1];
1535fcab8addSBrooks Davis 	if (!options[DHO_HOST_NAME]) {
1536fcab8addSBrooks Davis 		if (gethostname(hostname, sizeof(hostname)) == 0) {
1537fcab8addSBrooks Davis 			size_t len;
1538fcab8addSBrooks Davis 			char* posDot = strchr(hostname, '.');
1539fcab8addSBrooks Davis 			if (posDot != NULL)
1540fcab8addSBrooks Davis 				len = posDot - hostname;
1541fcab8addSBrooks Davis 			else
1542fcab8addSBrooks Davis 				len = strlen(hostname);
1543fcab8addSBrooks Davis 			options[DHO_HOST_NAME] = &option_elements[DHO_HOST_NAME];
1544fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->value = hostname;
1545fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->len = len;
1546fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->buf_size = len;
1547fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->timeout = 0xFFFFFFFF;
1548fcab8addSBrooks Davis 		}
1549fcab8addSBrooks Davis 	}
1550fcab8addSBrooks Davis 
1551fcab8addSBrooks Davis 	/* set unique client identifier */
1552fcab8addSBrooks Davis 	char client_ident[sizeof(struct hardware)];
1553fcab8addSBrooks Davis 	if (!options[DHO_DHCP_CLIENT_IDENTIFIER]) {
1554fcab8addSBrooks Davis 		int hwlen = (ip->hw_address.hlen < sizeof(client_ident)-1) ?
1555fcab8addSBrooks Davis 				ip->hw_address.hlen : sizeof(client_ident)-1;
1556fcab8addSBrooks Davis 		client_ident[0] = ip->hw_address.htype;
1557fcab8addSBrooks Davis 		memcpy(&client_ident[1], ip->hw_address.haddr, hwlen);
1558fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER] = &option_elements[DHO_DHCP_CLIENT_IDENTIFIER];
1559fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->value = client_ident;
1560fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->len = hwlen+1;
1561fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->buf_size = hwlen+1;
1562fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->timeout = 0xFFFFFFFF;
1563fcab8addSBrooks Davis 	}
1564fcab8addSBrooks Davis 
156547c08596SBrooks Davis 	/* Set up the option buffer... */
156647c08596SBrooks Davis 	ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
156747c08596SBrooks Davis 	    options, 0, 0, 0, NULL, 0);
156847c08596SBrooks Davis 	if (ip->client->packet_length < BOOTP_MIN_LEN)
156947c08596SBrooks Davis 		ip->client->packet_length = BOOTP_MIN_LEN;
157047c08596SBrooks Davis 
157147c08596SBrooks Davis 	ip->client->packet.op = BOOTREQUEST;
157247c08596SBrooks Davis 	ip->client->packet.htype = ip->hw_address.htype;
157347c08596SBrooks Davis 	ip->client->packet.hlen = ip->hw_address.hlen;
157447c08596SBrooks Davis 	ip->client->packet.hops = 0;
157547c08596SBrooks Davis 	ip->client->packet.xid = arc4random();
157647c08596SBrooks Davis 	ip->client->packet.secs = 0; /* filled in by send_discover. */
157747c08596SBrooks Davis 	ip->client->packet.flags = 0;
157847c08596SBrooks Davis 
157947c08596SBrooks Davis 	memset(&(ip->client->packet.ciaddr),
158047c08596SBrooks Davis 	    0, sizeof(ip->client->packet.ciaddr));
158147c08596SBrooks Davis 	memset(&(ip->client->packet.yiaddr),
158247c08596SBrooks Davis 	    0, sizeof(ip->client->packet.yiaddr));
158347c08596SBrooks Davis 	memset(&(ip->client->packet.siaddr),
158447c08596SBrooks Davis 	    0, sizeof(ip->client->packet.siaddr));
158547c08596SBrooks Davis 	memset(&(ip->client->packet.giaddr),
158647c08596SBrooks Davis 	    0, sizeof(ip->client->packet.giaddr));
158747c08596SBrooks Davis 	memcpy(ip->client->packet.chaddr,
158847c08596SBrooks Davis 	    ip->hw_address.haddr, ip->hw_address.hlen);
158947c08596SBrooks Davis }
159047c08596SBrooks Davis 
159147c08596SBrooks Davis 
159247c08596SBrooks Davis void
159347c08596SBrooks Davis make_request(struct interface_info *ip, struct client_lease * lease)
159447c08596SBrooks Davis {
159547c08596SBrooks Davis 	unsigned char request = DHCPREQUEST;
159647c08596SBrooks Davis 	struct tree_cache *options[256];
159747c08596SBrooks Davis 	struct tree_cache option_elements[256];
159847c08596SBrooks Davis 	int i;
159947c08596SBrooks Davis 
160047c08596SBrooks Davis 	memset(options, 0, sizeof(options));
160147c08596SBrooks Davis 	memset(&ip->client->packet, 0, sizeof(ip->client->packet));
160247c08596SBrooks Davis 
160347c08596SBrooks Davis 	/* Set DHCP_MESSAGE_TYPE to DHCPREQUEST */
160447c08596SBrooks Davis 	i = DHO_DHCP_MESSAGE_TYPE;
160547c08596SBrooks Davis 	options[i] = &option_elements[i];
160647c08596SBrooks Davis 	options[i]->value = &request;
160747c08596SBrooks Davis 	options[i]->len = sizeof(request);
160847c08596SBrooks Davis 	options[i]->buf_size = sizeof(request);
160947c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
161047c08596SBrooks Davis 
161147c08596SBrooks Davis 	/* Request the options we want */
161247c08596SBrooks Davis 	i = DHO_DHCP_PARAMETER_REQUEST_LIST;
161347c08596SBrooks Davis 	options[i] = &option_elements[i];
161447c08596SBrooks Davis 	options[i]->value = ip->client->config->requested_options;
161547c08596SBrooks Davis 	options[i]->len = ip->client->config->requested_option_count;
161647c08596SBrooks Davis 	options[i]->buf_size =
161747c08596SBrooks Davis 		ip->client->config->requested_option_count;
161847c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
161947c08596SBrooks Davis 
162047c08596SBrooks Davis 	/* If we are requesting an address that hasn't yet been assigned
162147c08596SBrooks Davis 	   to us, use the DHCP Requested Address option. */
162247c08596SBrooks Davis 	if (ip->client->state == S_REQUESTING) {
162347c08596SBrooks Davis 		/* Send back the server identifier... */
162447c08596SBrooks Davis 		i = DHO_DHCP_SERVER_IDENTIFIER;
162547c08596SBrooks Davis 		options[i] = &option_elements[i];
162647c08596SBrooks Davis 		options[i]->value = lease->options[i].data;
162747c08596SBrooks Davis 		options[i]->len = lease->options[i].len;
162847c08596SBrooks Davis 		options[i]->buf_size = lease->options[i].len;
162947c08596SBrooks Davis 		options[i]->timeout = 0xFFFFFFFF;
163047c08596SBrooks Davis 	}
163147c08596SBrooks Davis 	if (ip->client->state == S_REQUESTING ||
163247c08596SBrooks Davis 	    ip->client->state == S_REBOOTING) {
163347c08596SBrooks Davis 		ip->client->requested_address = lease->address;
163447c08596SBrooks Davis 		i = DHO_DHCP_REQUESTED_ADDRESS;
163547c08596SBrooks Davis 		options[i] = &option_elements[i];
163647c08596SBrooks Davis 		options[i]->value = lease->address.iabuf;
163747c08596SBrooks Davis 		options[i]->len = lease->address.len;
163847c08596SBrooks Davis 		options[i]->buf_size = lease->address.len;
163947c08596SBrooks Davis 		options[i]->timeout = 0xFFFFFFFF;
164047c08596SBrooks Davis 	} else
164147c08596SBrooks Davis 		ip->client->requested_address.len = 0;
164247c08596SBrooks Davis 
164347c08596SBrooks Davis 	/* Send any options requested in the config file. */
164447c08596SBrooks Davis 	for (i = 0; i < 256; i++)
164547c08596SBrooks Davis 		if (!options[i] &&
164647c08596SBrooks Davis 		    ip->client->config->send_options[i].data) {
164747c08596SBrooks Davis 			options[i] = &option_elements[i];
164847c08596SBrooks Davis 			options[i]->value =
164947c08596SBrooks Davis 			    ip->client->config->send_options[i].data;
165047c08596SBrooks Davis 			options[i]->len =
165147c08596SBrooks Davis 			    ip->client->config->send_options[i].len;
165247c08596SBrooks Davis 			options[i]->buf_size =
165347c08596SBrooks Davis 			    ip->client->config->send_options[i].len;
165447c08596SBrooks Davis 			options[i]->timeout = 0xFFFFFFFF;
165547c08596SBrooks Davis 		}
165647c08596SBrooks Davis 
1657fcab8addSBrooks Davis 	/* send host name if not set via config file. */
1658fcab8addSBrooks Davis 	char hostname[_POSIX_HOST_NAME_MAX+1];
1659fcab8addSBrooks Davis 	if (!options[DHO_HOST_NAME]) {
1660fcab8addSBrooks Davis 		if (gethostname(hostname, sizeof(hostname)) == 0) {
1661fcab8addSBrooks Davis 			size_t len;
1662fcab8addSBrooks Davis 			char* posDot = strchr(hostname, '.');
1663fcab8addSBrooks Davis 			if (posDot != NULL)
1664fcab8addSBrooks Davis 				len = posDot - hostname;
1665fcab8addSBrooks Davis 			else
1666fcab8addSBrooks Davis 				len = strlen(hostname);
1667fcab8addSBrooks Davis 			options[DHO_HOST_NAME] = &option_elements[DHO_HOST_NAME];
1668fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->value = hostname;
1669fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->len = len;
1670fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->buf_size = len;
1671fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->timeout = 0xFFFFFFFF;
1672fcab8addSBrooks Davis 		}
1673fcab8addSBrooks Davis 	}
1674fcab8addSBrooks Davis 
1675fcab8addSBrooks Davis 	/* set unique client identifier */
1676fcab8addSBrooks Davis 	char client_ident[sizeof(struct hardware)];
1677fcab8addSBrooks Davis 	if (!options[DHO_DHCP_CLIENT_IDENTIFIER]) {
1678fcab8addSBrooks Davis 		int hwlen = (ip->hw_address.hlen < sizeof(client_ident)-1) ?
1679fcab8addSBrooks Davis 				ip->hw_address.hlen : sizeof(client_ident)-1;
1680fcab8addSBrooks Davis 		client_ident[0] = ip->hw_address.htype;
1681fcab8addSBrooks Davis 		memcpy(&client_ident[1], ip->hw_address.haddr, hwlen);
1682fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER] = &option_elements[DHO_DHCP_CLIENT_IDENTIFIER];
1683fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->value = client_ident;
1684fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->len = hwlen+1;
1685fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->buf_size = hwlen+1;
1686fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->timeout = 0xFFFFFFFF;
1687fcab8addSBrooks Davis 	}
1688fcab8addSBrooks Davis 
168947c08596SBrooks Davis 	/* Set up the option buffer... */
169047c08596SBrooks Davis 	ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
169147c08596SBrooks Davis 	    options, 0, 0, 0, NULL, 0);
169247c08596SBrooks Davis 	if (ip->client->packet_length < BOOTP_MIN_LEN)
169347c08596SBrooks Davis 		ip->client->packet_length = BOOTP_MIN_LEN;
169447c08596SBrooks Davis 
169547c08596SBrooks Davis 	ip->client->packet.op = BOOTREQUEST;
169647c08596SBrooks Davis 	ip->client->packet.htype = ip->hw_address.htype;
169747c08596SBrooks Davis 	ip->client->packet.hlen = ip->hw_address.hlen;
169847c08596SBrooks Davis 	ip->client->packet.hops = 0;
169947c08596SBrooks Davis 	ip->client->packet.xid = ip->client->xid;
170047c08596SBrooks Davis 	ip->client->packet.secs = 0; /* Filled in by send_request. */
170147c08596SBrooks Davis 
170247c08596SBrooks Davis 	/* If we own the address we're requesting, put it in ciaddr;
170347c08596SBrooks Davis 	   otherwise set ciaddr to zero. */
170447c08596SBrooks Davis 	if (ip->client->state == S_BOUND ||
170547c08596SBrooks Davis 	    ip->client->state == S_RENEWING ||
170647c08596SBrooks Davis 	    ip->client->state == S_REBINDING) {
170747c08596SBrooks Davis 		memcpy(&ip->client->packet.ciaddr,
170847c08596SBrooks Davis 		    lease->address.iabuf, lease->address.len);
170947c08596SBrooks Davis 		ip->client->packet.flags = 0;
171047c08596SBrooks Davis 	} else {
171147c08596SBrooks Davis 		memset(&ip->client->packet.ciaddr, 0,
171247c08596SBrooks Davis 		    sizeof(ip->client->packet.ciaddr));
171347c08596SBrooks Davis 		ip->client->packet.flags = 0;
171447c08596SBrooks Davis 	}
171547c08596SBrooks Davis 
171647c08596SBrooks Davis 	memset(&ip->client->packet.yiaddr, 0,
171747c08596SBrooks Davis 	    sizeof(ip->client->packet.yiaddr));
171847c08596SBrooks Davis 	memset(&ip->client->packet.siaddr, 0,
171947c08596SBrooks Davis 	    sizeof(ip->client->packet.siaddr));
172047c08596SBrooks Davis 	memset(&ip->client->packet.giaddr, 0,
172147c08596SBrooks Davis 	    sizeof(ip->client->packet.giaddr));
172247c08596SBrooks Davis 	memcpy(ip->client->packet.chaddr,
172347c08596SBrooks Davis 	    ip->hw_address.haddr, ip->hw_address.hlen);
172447c08596SBrooks Davis }
172547c08596SBrooks Davis 
172647c08596SBrooks Davis void
172747c08596SBrooks Davis make_decline(struct interface_info *ip, struct client_lease *lease)
172847c08596SBrooks Davis {
172947c08596SBrooks Davis 	struct tree_cache *options[256], message_type_tree;
173047c08596SBrooks Davis 	struct tree_cache requested_address_tree;
173147c08596SBrooks Davis 	struct tree_cache server_id_tree, client_id_tree;
173247c08596SBrooks Davis 	unsigned char decline = DHCPDECLINE;
173347c08596SBrooks Davis 	int i;
173447c08596SBrooks Davis 
173547c08596SBrooks Davis 	memset(options, 0, sizeof(options));
173647c08596SBrooks Davis 	memset(&ip->client->packet, 0, sizeof(ip->client->packet));
173747c08596SBrooks Davis 
173847c08596SBrooks Davis 	/* Set DHCP_MESSAGE_TYPE to DHCPDECLINE */
173947c08596SBrooks Davis 	i = DHO_DHCP_MESSAGE_TYPE;
174047c08596SBrooks Davis 	options[i] = &message_type_tree;
174147c08596SBrooks Davis 	options[i]->value = &decline;
174247c08596SBrooks Davis 	options[i]->len = sizeof(decline);
174347c08596SBrooks Davis 	options[i]->buf_size = sizeof(decline);
174447c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
174547c08596SBrooks Davis 
174647c08596SBrooks Davis 	/* Send back the server identifier... */
174747c08596SBrooks Davis 	i = DHO_DHCP_SERVER_IDENTIFIER;
174847c08596SBrooks Davis 	options[i] = &server_id_tree;
174947c08596SBrooks Davis 	options[i]->value = lease->options[i].data;
175047c08596SBrooks Davis 	options[i]->len = lease->options[i].len;
175147c08596SBrooks Davis 	options[i]->buf_size = lease->options[i].len;
175247c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
175347c08596SBrooks Davis 
175447c08596SBrooks Davis 	/* Send back the address we're declining. */
175547c08596SBrooks Davis 	i = DHO_DHCP_REQUESTED_ADDRESS;
175647c08596SBrooks Davis 	options[i] = &requested_address_tree;
175747c08596SBrooks Davis 	options[i]->value = lease->address.iabuf;
175847c08596SBrooks Davis 	options[i]->len = lease->address.len;
175947c08596SBrooks Davis 	options[i]->buf_size = lease->address.len;
176047c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
176147c08596SBrooks Davis 
176247c08596SBrooks Davis 	/* Send the uid if the user supplied one. */
176347c08596SBrooks Davis 	i = DHO_DHCP_CLIENT_IDENTIFIER;
176447c08596SBrooks Davis 	if (ip->client->config->send_options[i].len) {
176547c08596SBrooks Davis 		options[i] = &client_id_tree;
176647c08596SBrooks Davis 		options[i]->value = ip->client->config->send_options[i].data;
176747c08596SBrooks Davis 		options[i]->len = ip->client->config->send_options[i].len;
176847c08596SBrooks Davis 		options[i]->buf_size = ip->client->config->send_options[i].len;
176947c08596SBrooks Davis 		options[i]->timeout = 0xFFFFFFFF;
177047c08596SBrooks Davis 	}
177147c08596SBrooks Davis 
177247c08596SBrooks Davis 
177347c08596SBrooks Davis 	/* Set up the option buffer... */
177447c08596SBrooks Davis 	ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
177547c08596SBrooks Davis 	    options, 0, 0, 0, NULL, 0);
177647c08596SBrooks Davis 	if (ip->client->packet_length < BOOTP_MIN_LEN)
177747c08596SBrooks Davis 		ip->client->packet_length = BOOTP_MIN_LEN;
177847c08596SBrooks Davis 
177947c08596SBrooks Davis 	ip->client->packet.op = BOOTREQUEST;
178047c08596SBrooks Davis 	ip->client->packet.htype = ip->hw_address.htype;
178147c08596SBrooks Davis 	ip->client->packet.hlen = ip->hw_address.hlen;
178247c08596SBrooks Davis 	ip->client->packet.hops = 0;
178347c08596SBrooks Davis 	ip->client->packet.xid = ip->client->xid;
178447c08596SBrooks Davis 	ip->client->packet.secs = 0; /* Filled in by send_request. */
178547c08596SBrooks Davis 	ip->client->packet.flags = 0;
178647c08596SBrooks Davis 
178747c08596SBrooks Davis 	/* ciaddr must always be zero. */
178847c08596SBrooks Davis 	memset(&ip->client->packet.ciaddr, 0,
178947c08596SBrooks Davis 	    sizeof(ip->client->packet.ciaddr));
179047c08596SBrooks Davis 	memset(&ip->client->packet.yiaddr, 0,
179147c08596SBrooks Davis 	    sizeof(ip->client->packet.yiaddr));
179247c08596SBrooks Davis 	memset(&ip->client->packet.siaddr, 0,
179347c08596SBrooks Davis 	    sizeof(ip->client->packet.siaddr));
179447c08596SBrooks Davis 	memset(&ip->client->packet.giaddr, 0,
179547c08596SBrooks Davis 	    sizeof(ip->client->packet.giaddr));
179647c08596SBrooks Davis 	memcpy(ip->client->packet.chaddr,
179747c08596SBrooks Davis 	    ip->hw_address.haddr, ip->hw_address.hlen);
179847c08596SBrooks Davis }
179947c08596SBrooks Davis 
180047c08596SBrooks Davis void
180147c08596SBrooks Davis free_client_lease(struct client_lease *lease)
180247c08596SBrooks Davis {
180347c08596SBrooks Davis 	int i;
180447c08596SBrooks Davis 
180547c08596SBrooks Davis 	if (lease->server_name)
180647c08596SBrooks Davis 		free(lease->server_name);
180747c08596SBrooks Davis 	if (lease->filename)
180847c08596SBrooks Davis 		free(lease->filename);
180947c08596SBrooks Davis 	for (i = 0; i < 256; i++) {
181047c08596SBrooks Davis 		if (lease->options[i].len)
181147c08596SBrooks Davis 			free(lease->options[i].data);
181247c08596SBrooks Davis 	}
181347c08596SBrooks Davis 	free(lease);
181447c08596SBrooks Davis }
181547c08596SBrooks Davis 
181647c08596SBrooks Davis FILE *leaseFile;
181747c08596SBrooks Davis 
181847c08596SBrooks Davis void
181947c08596SBrooks Davis rewrite_client_leases(void)
182047c08596SBrooks Davis {
182147c08596SBrooks Davis 	struct client_lease *lp;
182247c08596SBrooks Davis 
182347c08596SBrooks Davis 	if (!leaseFile) {
182447c08596SBrooks Davis 		leaseFile = fopen(path_dhclient_db, "w");
182547c08596SBrooks Davis 		if (!leaseFile)
182647c08596SBrooks Davis 			error("can't create %s: %m", path_dhclient_db);
182747c08596SBrooks Davis 	} else {
182847c08596SBrooks Davis 		fflush(leaseFile);
182947c08596SBrooks Davis 		rewind(leaseFile);
183047c08596SBrooks Davis 	}
183147c08596SBrooks Davis 
183247c08596SBrooks Davis 	for (lp = ifi->client->leases; lp; lp = lp->next)
183347c08596SBrooks Davis 		write_client_lease(ifi, lp, 1);
183447c08596SBrooks Davis 	if (ifi->client->active)
183547c08596SBrooks Davis 		write_client_lease(ifi, ifi->client->active, 1);
183647c08596SBrooks Davis 
183747c08596SBrooks Davis 	fflush(leaseFile);
183847c08596SBrooks Davis 	ftruncate(fileno(leaseFile), ftello(leaseFile));
183947c08596SBrooks Davis 	fsync(fileno(leaseFile));
184047c08596SBrooks Davis }
184147c08596SBrooks Davis 
184247c08596SBrooks Davis void
184347c08596SBrooks Davis write_client_lease(struct interface_info *ip, struct client_lease *lease,
184447c08596SBrooks Davis     int rewrite)
184547c08596SBrooks Davis {
184647c08596SBrooks Davis 	static int leases_written;
184747c08596SBrooks Davis 	struct tm *t;
184847c08596SBrooks Davis 	int i;
184947c08596SBrooks Davis 
185047c08596SBrooks Davis 	if (!rewrite) {
185147c08596SBrooks Davis 		if (leases_written++ > 20) {
185247c08596SBrooks Davis 			rewrite_client_leases();
185347c08596SBrooks Davis 			leases_written = 0;
185447c08596SBrooks Davis 		}
185547c08596SBrooks Davis 	}
185647c08596SBrooks Davis 
185747c08596SBrooks Davis 	/* If the lease came from the config file, we don't need to stash
185847c08596SBrooks Davis 	   a copy in the lease database. */
185947c08596SBrooks Davis 	if (lease->is_static)
186047c08596SBrooks Davis 		return;
186147c08596SBrooks Davis 
186247c08596SBrooks Davis 	if (!leaseFile) {	/* XXX */
186347c08596SBrooks Davis 		leaseFile = fopen(path_dhclient_db, "w");
186447c08596SBrooks Davis 		if (!leaseFile)
186547c08596SBrooks Davis 			error("can't create %s: %m", path_dhclient_db);
186647c08596SBrooks Davis 	}
186747c08596SBrooks Davis 
186847c08596SBrooks Davis 	fprintf(leaseFile, "lease {\n");
186947c08596SBrooks Davis 	if (lease->is_bootp)
187047c08596SBrooks Davis 		fprintf(leaseFile, "  bootp;\n");
187147c08596SBrooks Davis 	fprintf(leaseFile, "  interface \"%s\";\n", ip->name);
187247c08596SBrooks Davis 	fprintf(leaseFile, "  fixed-address %s;\n", piaddr(lease->address));
187347c08596SBrooks Davis 	if (lease->filename)
187447c08596SBrooks Davis 		fprintf(leaseFile, "  filename \"%s\";\n", lease->filename);
187547c08596SBrooks Davis 	if (lease->server_name)
187647c08596SBrooks Davis 		fprintf(leaseFile, "  server-name \"%s\";\n",
187747c08596SBrooks Davis 		    lease->server_name);
187847c08596SBrooks Davis 	if (lease->medium)
187947c08596SBrooks Davis 		fprintf(leaseFile, "  medium \"%s\";\n", lease->medium->string);
188047c08596SBrooks Davis 	for (i = 0; i < 256; i++)
188147c08596SBrooks Davis 		if (lease->options[i].len)
188247c08596SBrooks Davis 			fprintf(leaseFile, "  option %s %s;\n",
188347c08596SBrooks Davis 			    dhcp_options[i].name,
188447c08596SBrooks Davis 			    pretty_print_option(i, lease->options[i].data,
188547c08596SBrooks Davis 			    lease->options[i].len, 1, 1));
188647c08596SBrooks Davis 
188747c08596SBrooks Davis 	t = gmtime(&lease->renewal);
188847c08596SBrooks Davis 	fprintf(leaseFile, "  renew %d %d/%d/%d %02d:%02d:%02d;\n",
188947c08596SBrooks Davis 	    t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
189047c08596SBrooks Davis 	    t->tm_hour, t->tm_min, t->tm_sec);
189147c08596SBrooks Davis 	t = gmtime(&lease->rebind);
189247c08596SBrooks Davis 	fprintf(leaseFile, "  rebind %d %d/%d/%d %02d:%02d:%02d;\n",
189347c08596SBrooks Davis 	    t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
189447c08596SBrooks Davis 	    t->tm_hour, t->tm_min, t->tm_sec);
189547c08596SBrooks Davis 	t = gmtime(&lease->expiry);
189647c08596SBrooks Davis 	fprintf(leaseFile, "  expire %d %d/%d/%d %02d:%02d:%02d;\n",
189747c08596SBrooks Davis 	    t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
189847c08596SBrooks Davis 	    t->tm_hour, t->tm_min, t->tm_sec);
189947c08596SBrooks Davis 	fprintf(leaseFile, "}\n");
190047c08596SBrooks Davis 	fflush(leaseFile);
190147c08596SBrooks Davis }
190247c08596SBrooks Davis 
190347c08596SBrooks Davis void
190447c08596SBrooks Davis script_init(char *reason, struct string_list *medium)
190547c08596SBrooks Davis {
190647c08596SBrooks Davis 	size_t		 len, mediumlen = 0;
190747c08596SBrooks Davis 	struct imsg_hdr	 hdr;
190847c08596SBrooks Davis 	struct buf	*buf;
190947c08596SBrooks Davis 	int		 errs;
191047c08596SBrooks Davis 
191147c08596SBrooks Davis 	if (medium != NULL && medium->string != NULL)
191247c08596SBrooks Davis 		mediumlen = strlen(medium->string);
191347c08596SBrooks Davis 
191447c08596SBrooks Davis 	hdr.code = IMSG_SCRIPT_INIT;
191547c08596SBrooks Davis 	hdr.len = sizeof(struct imsg_hdr) +
191647c08596SBrooks Davis 	    sizeof(size_t) + mediumlen +
191747c08596SBrooks Davis 	    sizeof(size_t) + strlen(reason);
191847c08596SBrooks Davis 
191947c08596SBrooks Davis 	if ((buf = buf_open(hdr.len)) == NULL)
192047c08596SBrooks Davis 		error("buf_open: %m");
192147c08596SBrooks Davis 
192247c08596SBrooks Davis 	errs = 0;
192347c08596SBrooks Davis 	errs += buf_add(buf, &hdr, sizeof(hdr));
192447c08596SBrooks Davis 	errs += buf_add(buf, &mediumlen, sizeof(mediumlen));
192547c08596SBrooks Davis 	if (mediumlen > 0)
192647c08596SBrooks Davis 		errs += buf_add(buf, medium->string, mediumlen);
192747c08596SBrooks Davis 	len = strlen(reason);
192847c08596SBrooks Davis 	errs += buf_add(buf, &len, sizeof(len));
192947c08596SBrooks Davis 	errs += buf_add(buf, reason, len);
193047c08596SBrooks Davis 
193147c08596SBrooks Davis 	if (errs)
193247c08596SBrooks Davis 		error("buf_add: %m");
193347c08596SBrooks Davis 
193447c08596SBrooks Davis 	if (buf_close(privfd, buf) == -1)
193547c08596SBrooks Davis 		error("buf_close: %m");
193647c08596SBrooks Davis }
193747c08596SBrooks Davis 
193847c08596SBrooks Davis void
193947c08596SBrooks Davis priv_script_init(char *reason, char *medium)
194047c08596SBrooks Davis {
194147c08596SBrooks Davis 	struct interface_info *ip = ifi;
194247c08596SBrooks Davis 
194347c08596SBrooks Davis 	if (ip) {
194447c08596SBrooks Davis 		ip->client->scriptEnvsize = 100;
194547c08596SBrooks Davis 		if (ip->client->scriptEnv == NULL)
194647c08596SBrooks Davis 			ip->client->scriptEnv =
194747c08596SBrooks Davis 			    malloc(ip->client->scriptEnvsize * sizeof(char *));
194847c08596SBrooks Davis 		if (ip->client->scriptEnv == NULL)
194947c08596SBrooks Davis 			error("script_init: no memory for environment");
195047c08596SBrooks Davis 
195147c08596SBrooks Davis 		ip->client->scriptEnv[0] = strdup(CLIENT_PATH);
195247c08596SBrooks Davis 		if (ip->client->scriptEnv[0] == NULL)
195347c08596SBrooks Davis 			error("script_init: no memory for environment");
195447c08596SBrooks Davis 
195547c08596SBrooks Davis 		ip->client->scriptEnv[1] = NULL;
195647c08596SBrooks Davis 
195747c08596SBrooks Davis 		script_set_env(ip->client, "", "interface", ip->name);
195847c08596SBrooks Davis 
195947c08596SBrooks Davis 		if (medium)
196047c08596SBrooks Davis 			script_set_env(ip->client, "", "medium", medium);
196147c08596SBrooks Davis 
196247c08596SBrooks Davis 		script_set_env(ip->client, "", "reason", reason);
196347c08596SBrooks Davis 	}
196447c08596SBrooks Davis }
196547c08596SBrooks Davis 
196647c08596SBrooks Davis void
196747c08596SBrooks Davis priv_script_write_params(char *prefix, struct client_lease *lease)
196847c08596SBrooks Davis {
196947c08596SBrooks Davis 	struct interface_info *ip = ifi;
197040767e22SBrooks Davis 	u_int8_t dbuf[1500], *dp = NULL;
197140767e22SBrooks Davis 	int i, len;
197247c08596SBrooks Davis 	char tbuf[128];
197347c08596SBrooks Davis 
197447c08596SBrooks Davis 	script_set_env(ip->client, prefix, "ip_address",
197547c08596SBrooks Davis 	    piaddr(lease->address));
197647c08596SBrooks Davis 
197740767e22SBrooks Davis 	if (ip->client->config->default_actions[DHO_SUBNET_MASK] ==
197840767e22SBrooks Davis 	    ACTION_SUPERSEDE) {
197940767e22SBrooks Davis 		dp = ip->client->config->defaults[DHO_SUBNET_MASK].data;
198040767e22SBrooks Davis 		len = ip->client->config->defaults[DHO_SUBNET_MASK].len;
198140767e22SBrooks Davis 	} else {
198240767e22SBrooks Davis 		dp = lease->options[DHO_SUBNET_MASK].data;
198340767e22SBrooks Davis 		len = lease->options[DHO_SUBNET_MASK].len;
198440767e22SBrooks Davis 	}
198540767e22SBrooks Davis 	if (len && (len < sizeof(lease->address.iabuf))) {
198647c08596SBrooks Davis 		struct iaddr netmask, subnet, broadcast;
198747c08596SBrooks Davis 
198840767e22SBrooks Davis 		memcpy(netmask.iabuf, dp, len);
198940767e22SBrooks Davis 		netmask.len = len;
199047c08596SBrooks Davis 		subnet = subnet_number(lease->address, netmask);
199147c08596SBrooks Davis 		if (subnet.len) {
199247c08596SBrooks Davis 			script_set_env(ip->client, prefix, "network_number",
199347c08596SBrooks Davis 			    piaddr(subnet));
199447c08596SBrooks Davis 			if (!lease->options[DHO_BROADCAST_ADDRESS].len) {
199547c08596SBrooks Davis 				broadcast = broadcast_addr(subnet, netmask);
199647c08596SBrooks Davis 				if (broadcast.len)
199747c08596SBrooks Davis 					script_set_env(ip->client, prefix,
199847c08596SBrooks Davis 					    "broadcast_address",
199947c08596SBrooks Davis 					    piaddr(broadcast));
200047c08596SBrooks Davis 			}
200147c08596SBrooks Davis 		}
200247c08596SBrooks Davis 	}
200347c08596SBrooks Davis 
200447c08596SBrooks Davis 	if (lease->filename)
200547c08596SBrooks Davis 		script_set_env(ip->client, prefix, "filename", lease->filename);
200647c08596SBrooks Davis 	if (lease->server_name)
200747c08596SBrooks Davis 		script_set_env(ip->client, prefix, "server_name",
200847c08596SBrooks Davis 		    lease->server_name);
200947c08596SBrooks Davis 	for (i = 0; i < 256; i++) {
201040767e22SBrooks Davis 		len = 0;
201147c08596SBrooks Davis 
201247c08596SBrooks Davis 		if (ip->client->config->defaults[i].len) {
201347c08596SBrooks Davis 			if (lease->options[i].len) {
201447c08596SBrooks Davis 				switch (
201547c08596SBrooks Davis 				    ip->client->config->default_actions[i]) {
201647c08596SBrooks Davis 				case ACTION_DEFAULT:
201747c08596SBrooks Davis 					dp = lease->options[i].data;
201847c08596SBrooks Davis 					len = lease->options[i].len;
201947c08596SBrooks Davis 					break;
202047c08596SBrooks Davis 				case ACTION_SUPERSEDE:
202147c08596SBrooks Davis supersede:
202247c08596SBrooks Davis 					dp = ip->client->
202347c08596SBrooks Davis 						config->defaults[i].data;
202447c08596SBrooks Davis 					len = ip->client->
202547c08596SBrooks Davis 						config->defaults[i].len;
202647c08596SBrooks Davis 					break;
202747c08596SBrooks Davis 				case ACTION_PREPEND:
202847c08596SBrooks Davis 					len = ip->client->
202947c08596SBrooks Davis 					    config->defaults[i].len +
203047c08596SBrooks Davis 					    lease->options[i].len;
2031043bcc8dSBrian Somers 					if (len >= sizeof(dbuf)) {
203247c08596SBrooks Davis 						warning("no space to %s %s",
203347c08596SBrooks Davis 						    "prepend option",
203447c08596SBrooks Davis 						    dhcp_options[i].name);
203547c08596SBrooks Davis 						goto supersede;
203647c08596SBrooks Davis 					}
203747c08596SBrooks Davis 					dp = dbuf;
203847c08596SBrooks Davis 					memcpy(dp,
203947c08596SBrooks Davis 						ip->client->
204047c08596SBrooks Davis 						config->defaults[i].data,
204147c08596SBrooks Davis 						ip->client->
204247c08596SBrooks Davis 						config->defaults[i].len);
204347c08596SBrooks Davis 					memcpy(dp + ip->client->
204447c08596SBrooks Davis 						config->defaults[i].len,
204547c08596SBrooks Davis 						lease->options[i].data,
204647c08596SBrooks Davis 						lease->options[i].len);
204747c08596SBrooks Davis 					dp[len] = '\0';
204847c08596SBrooks Davis 					break;
204947c08596SBrooks Davis 				case ACTION_APPEND:
2050043bcc8dSBrian Somers 					/*
2051043bcc8dSBrian Somers 					 * When we append, we assume that we're
2052043bcc8dSBrian Somers 					 * appending to text.  Some MS servers
2053043bcc8dSBrian Somers 					 * include a NUL byte at the end of
2054043bcc8dSBrian Somers 					 * the search string provided.
2055043bcc8dSBrian Somers 					 */
205647c08596SBrooks Davis 					len = ip->client->
205747c08596SBrooks Davis 					    config->defaults[i].len +
205847c08596SBrooks Davis 					    lease->options[i].len;
2059043bcc8dSBrian Somers 					if (len >= sizeof(dbuf)) {
206047c08596SBrooks Davis 						warning("no space to %s %s",
206147c08596SBrooks Davis 						    "append option",
206247c08596SBrooks Davis 						    dhcp_options[i].name);
206347c08596SBrooks Davis 						goto supersede;
206447c08596SBrooks Davis 					}
2065043bcc8dSBrian Somers 					memcpy(dbuf,
206647c08596SBrooks Davis 						lease->options[i].data,
206747c08596SBrooks Davis 						lease->options[i].len);
2068043bcc8dSBrian Somers 					for (dp = dbuf + lease->options[i].len;
2069043bcc8dSBrian Somers 					    dp > dbuf; dp--, len--)
2070043bcc8dSBrian Somers 						if (dp[-1] != '\0')
2071043bcc8dSBrian Somers 							break;
2072043bcc8dSBrian Somers 					memcpy(dp,
207347c08596SBrooks Davis 						ip->client->
207447c08596SBrooks Davis 						config->defaults[i].data,
207547c08596SBrooks Davis 						ip->client->
207647c08596SBrooks Davis 						config->defaults[i].len);
2077043bcc8dSBrian Somers 					dp = dbuf;
207847c08596SBrooks Davis 					dp[len] = '\0';
207947c08596SBrooks Davis 				}
208047c08596SBrooks Davis 			} else {
208147c08596SBrooks Davis 				dp = ip->client->
208247c08596SBrooks Davis 					config->defaults[i].data;
208347c08596SBrooks Davis 				len = ip->client->
208447c08596SBrooks Davis 					config->defaults[i].len;
208547c08596SBrooks Davis 			}
208647c08596SBrooks Davis 		} else if (lease->options[i].len) {
208747c08596SBrooks Davis 			len = lease->options[i].len;
208847c08596SBrooks Davis 			dp = lease->options[i].data;
208947c08596SBrooks Davis 		} else {
209047c08596SBrooks Davis 			len = 0;
209147c08596SBrooks Davis 		}
209247c08596SBrooks Davis 		if (len) {
209347c08596SBrooks Davis 			char name[256];
209447c08596SBrooks Davis 
209547c08596SBrooks Davis 			if (dhcp_option_ev_name(name, sizeof(name),
209647c08596SBrooks Davis 			    &dhcp_options[i]))
209747c08596SBrooks Davis 				script_set_env(ip->client, prefix, name,
209847c08596SBrooks Davis 				    pretty_print_option(i, dp, len, 0, 0));
209947c08596SBrooks Davis 		}
210047c08596SBrooks Davis 	}
210147c08596SBrooks Davis 	snprintf(tbuf, sizeof(tbuf), "%d", (int)lease->expiry);
210247c08596SBrooks Davis 	script_set_env(ip->client, prefix, "expiry", tbuf);
210347c08596SBrooks Davis }
210447c08596SBrooks Davis 
210547c08596SBrooks Davis void
210647c08596SBrooks Davis script_write_params(char *prefix, struct client_lease *lease)
210747c08596SBrooks Davis {
210847c08596SBrooks Davis 	size_t		 fn_len = 0, sn_len = 0, pr_len = 0;
210947c08596SBrooks Davis 	struct imsg_hdr	 hdr;
211047c08596SBrooks Davis 	struct buf	*buf;
211147c08596SBrooks Davis 	int		 errs, i;
211247c08596SBrooks Davis 
211347c08596SBrooks Davis 	if (lease->filename != NULL)
211447c08596SBrooks Davis 		fn_len = strlen(lease->filename);
211547c08596SBrooks Davis 	if (lease->server_name != NULL)
211647c08596SBrooks Davis 		sn_len = strlen(lease->server_name);
211747c08596SBrooks Davis 	if (prefix != NULL)
211847c08596SBrooks Davis 		pr_len = strlen(prefix);
211947c08596SBrooks Davis 
212047c08596SBrooks Davis 	hdr.code = IMSG_SCRIPT_WRITE_PARAMS;
212147c08596SBrooks Davis 	hdr.len = sizeof(hdr) + sizeof(struct client_lease) +
212247c08596SBrooks Davis 	    sizeof(size_t) + fn_len + sizeof(size_t) + sn_len +
212347c08596SBrooks Davis 	    sizeof(size_t) + pr_len;
212447c08596SBrooks Davis 
212547c08596SBrooks Davis 	for (i = 0; i < 256; i++)
212647c08596SBrooks Davis 		hdr.len += sizeof(int) + lease->options[i].len;
212747c08596SBrooks Davis 
212847c08596SBrooks Davis 	scripttime = time(NULL);
212947c08596SBrooks Davis 
213047c08596SBrooks Davis 	if ((buf = buf_open(hdr.len)) == NULL)
213147c08596SBrooks Davis 		error("buf_open: %m");
213247c08596SBrooks Davis 
213347c08596SBrooks Davis 	errs = 0;
213447c08596SBrooks Davis 	errs += buf_add(buf, &hdr, sizeof(hdr));
213547c08596SBrooks Davis 	errs += buf_add(buf, lease, sizeof(struct client_lease));
213647c08596SBrooks Davis 	errs += buf_add(buf, &fn_len, sizeof(fn_len));
213747c08596SBrooks Davis 	errs += buf_add(buf, lease->filename, fn_len);
213847c08596SBrooks Davis 	errs += buf_add(buf, &sn_len, sizeof(sn_len));
213947c08596SBrooks Davis 	errs += buf_add(buf, lease->server_name, sn_len);
214047c08596SBrooks Davis 	errs += buf_add(buf, &pr_len, sizeof(pr_len));
214147c08596SBrooks Davis 	errs += buf_add(buf, prefix, pr_len);
214247c08596SBrooks Davis 
214347c08596SBrooks Davis 	for (i = 0; i < 256; i++) {
214447c08596SBrooks Davis 		errs += buf_add(buf, &lease->options[i].len,
214547c08596SBrooks Davis 		    sizeof(lease->options[i].len));
214647c08596SBrooks Davis 		errs += buf_add(buf, lease->options[i].data,
214747c08596SBrooks Davis 		    lease->options[i].len);
214847c08596SBrooks Davis 	}
214947c08596SBrooks Davis 
215047c08596SBrooks Davis 	if (errs)
215147c08596SBrooks Davis 		error("buf_add: %m");
215247c08596SBrooks Davis 
215347c08596SBrooks Davis 	if (buf_close(privfd, buf) == -1)
215447c08596SBrooks Davis 		error("buf_close: %m");
215547c08596SBrooks Davis }
215647c08596SBrooks Davis 
215747c08596SBrooks Davis int
215847c08596SBrooks Davis script_go(void)
215947c08596SBrooks Davis {
216047c08596SBrooks Davis 	struct imsg_hdr	 hdr;
216147c08596SBrooks Davis 	struct buf	*buf;
216247c08596SBrooks Davis 	int		 ret;
216347c08596SBrooks Davis 
216447c08596SBrooks Davis 	hdr.code = IMSG_SCRIPT_GO;
216547c08596SBrooks Davis 	hdr.len = sizeof(struct imsg_hdr);
216647c08596SBrooks Davis 
216747c08596SBrooks Davis 	if ((buf = buf_open(hdr.len)) == NULL)
216847c08596SBrooks Davis 		error("buf_open: %m");
216947c08596SBrooks Davis 
217047c08596SBrooks Davis 	if (buf_add(buf, &hdr, sizeof(hdr)))
217147c08596SBrooks Davis 		error("buf_add: %m");
217247c08596SBrooks Davis 
217347c08596SBrooks Davis 	if (buf_close(privfd, buf) == -1)
217447c08596SBrooks Davis 		error("buf_close: %m");
217547c08596SBrooks Davis 
217647c08596SBrooks Davis 	bzero(&hdr, sizeof(hdr));
217747c08596SBrooks Davis 	buf_read(privfd, &hdr, sizeof(hdr));
217847c08596SBrooks Davis 	if (hdr.code != IMSG_SCRIPT_GO_RET)
217947c08596SBrooks Davis 		error("unexpected msg type %u", hdr.code);
218047c08596SBrooks Davis 	if (hdr.len != sizeof(hdr) + sizeof(int))
218147c08596SBrooks Davis 		error("received corrupted message");
218247c08596SBrooks Davis 	buf_read(privfd, &ret, sizeof(ret));
218347c08596SBrooks Davis 
21846964abefSBrian Somers 	scripttime = time(NULL);
21856964abefSBrian Somers 
218647c08596SBrooks Davis 	return (ret);
218747c08596SBrooks Davis }
218847c08596SBrooks Davis 
218947c08596SBrooks Davis int
219047c08596SBrooks Davis priv_script_go(void)
219147c08596SBrooks Davis {
219247c08596SBrooks Davis 	char *scriptName, *argv[2], **envp, *epp[3], reason[] = "REASON=NBI";
219347c08596SBrooks Davis 	static char client_path[] = CLIENT_PATH;
219447c08596SBrooks Davis 	struct interface_info *ip = ifi;
219547c08596SBrooks Davis 	int pid, wpid, wstatus;
219647c08596SBrooks Davis 
219747c08596SBrooks Davis 	scripttime = time(NULL);
219847c08596SBrooks Davis 
219947c08596SBrooks Davis 	if (ip) {
220047c08596SBrooks Davis 		scriptName = ip->client->config->script_name;
220147c08596SBrooks Davis 		envp = ip->client->scriptEnv;
220247c08596SBrooks Davis 	} else {
220347c08596SBrooks Davis 		scriptName = top_level_config.script_name;
220447c08596SBrooks Davis 		epp[0] = reason;
220547c08596SBrooks Davis 		epp[1] = client_path;
220647c08596SBrooks Davis 		epp[2] = NULL;
220747c08596SBrooks Davis 		envp = epp;
220847c08596SBrooks Davis 	}
220947c08596SBrooks Davis 
221047c08596SBrooks Davis 	argv[0] = scriptName;
221147c08596SBrooks Davis 	argv[1] = NULL;
221247c08596SBrooks Davis 
221347c08596SBrooks Davis 	pid = fork();
221447c08596SBrooks Davis 	if (pid < 0) {
221547c08596SBrooks Davis 		error("fork: %m");
221647c08596SBrooks Davis 		wstatus = 0;
221747c08596SBrooks Davis 	} else if (pid) {
221847c08596SBrooks Davis 		do {
221947c08596SBrooks Davis 			wpid = wait(&wstatus);
222047c08596SBrooks Davis 		} while (wpid != pid && wpid > 0);
222147c08596SBrooks Davis 		if (wpid < 0) {
222247c08596SBrooks Davis 			error("wait: %m");
222347c08596SBrooks Davis 			wstatus = 0;
222447c08596SBrooks Davis 		}
222547c08596SBrooks Davis 	} else {
222647c08596SBrooks Davis 		execve(scriptName, argv, envp);
222747c08596SBrooks Davis 		error("execve (%s, ...): %m", scriptName);
222847c08596SBrooks Davis 	}
222947c08596SBrooks Davis 
223047c08596SBrooks Davis 	if (ip)
223147c08596SBrooks Davis 		script_flush_env(ip->client);
223247c08596SBrooks Davis 
223347c08596SBrooks Davis 	return (wstatus & 0xff);
223447c08596SBrooks Davis }
223547c08596SBrooks Davis 
223647c08596SBrooks Davis void
223747c08596SBrooks Davis script_set_env(struct client_state *client, const char *prefix,
223847c08596SBrooks Davis     const char *name, const char *value)
223947c08596SBrooks Davis {
224047c08596SBrooks Davis 	int i, j, namelen;
224147c08596SBrooks Davis 
224247c08596SBrooks Davis 	namelen = strlen(name);
224347c08596SBrooks Davis 
224447c08596SBrooks Davis 	for (i = 0; client->scriptEnv[i]; i++)
224547c08596SBrooks Davis 		if (strncmp(client->scriptEnv[i], name, namelen) == 0 &&
224647c08596SBrooks Davis 		    client->scriptEnv[i][namelen] == '=')
224747c08596SBrooks Davis 			break;
224847c08596SBrooks Davis 
224947c08596SBrooks Davis 	if (client->scriptEnv[i])
225047c08596SBrooks Davis 		/* Reuse the slot. */
225147c08596SBrooks Davis 		free(client->scriptEnv[i]);
225247c08596SBrooks Davis 	else {
225347c08596SBrooks Davis 		/* New variable.  Expand if necessary. */
225447c08596SBrooks Davis 		if (i >= client->scriptEnvsize - 1) {
225547c08596SBrooks Davis 			char **newscriptEnv;
225647c08596SBrooks Davis 			int newscriptEnvsize = client->scriptEnvsize + 50;
225747c08596SBrooks Davis 
225847c08596SBrooks Davis 			newscriptEnv = realloc(client->scriptEnv,
225947c08596SBrooks Davis 			    newscriptEnvsize);
226047c08596SBrooks Davis 			if (newscriptEnv == NULL) {
226147c08596SBrooks Davis 				free(client->scriptEnv);
226247c08596SBrooks Davis 				client->scriptEnv = NULL;
226347c08596SBrooks Davis 				client->scriptEnvsize = 0;
226447c08596SBrooks Davis 				error("script_set_env: no memory for variable");
226547c08596SBrooks Davis 			}
226647c08596SBrooks Davis 			client->scriptEnv = newscriptEnv;
226747c08596SBrooks Davis 			client->scriptEnvsize = newscriptEnvsize;
226847c08596SBrooks Davis 		}
226947c08596SBrooks Davis 		/* need to set the NULL pointer at end of array beyond
227047c08596SBrooks Davis 		   the new slot. */
227147c08596SBrooks Davis 		client->scriptEnv[i + 1] = NULL;
227247c08596SBrooks Davis 	}
227347c08596SBrooks Davis 	/* Allocate space and format the variable in the appropriate slot. */
227447c08596SBrooks Davis 	client->scriptEnv[i] = malloc(strlen(prefix) + strlen(name) + 1 +
227547c08596SBrooks Davis 	    strlen(value) + 1);
227647c08596SBrooks Davis 	if (client->scriptEnv[i] == NULL)
227747c08596SBrooks Davis 		error("script_set_env: no memory for variable assignment");
227847c08596SBrooks Davis 
227947c08596SBrooks Davis 	/* No `` or $() command substitution allowed in environment values! */
228047c08596SBrooks Davis 	for (j=0; j < strlen(value); j++)
228147c08596SBrooks Davis 		switch (value[j]) {
228247c08596SBrooks Davis 		case '`':
228347c08596SBrooks Davis 		case '$':
228447c08596SBrooks Davis 			error("illegal character (%c) in value '%s'", value[j],
228547c08596SBrooks Davis 			    value);
228647c08596SBrooks Davis 			/* not reached */
228747c08596SBrooks Davis 		}
228847c08596SBrooks Davis 	snprintf(client->scriptEnv[i], strlen(prefix) + strlen(name) +
228947c08596SBrooks Davis 	    1 + strlen(value) + 1, "%s%s=%s", prefix, name, value);
229047c08596SBrooks Davis }
229147c08596SBrooks Davis 
229247c08596SBrooks Davis void
229347c08596SBrooks Davis script_flush_env(struct client_state *client)
229447c08596SBrooks Davis {
229547c08596SBrooks Davis 	int i;
229647c08596SBrooks Davis 
229747c08596SBrooks Davis 	for (i = 0; client->scriptEnv[i]; i++) {
229847c08596SBrooks Davis 		free(client->scriptEnv[i]);
229947c08596SBrooks Davis 		client->scriptEnv[i] = NULL;
230047c08596SBrooks Davis 	}
230147c08596SBrooks Davis 	client->scriptEnvsize = 0;
230247c08596SBrooks Davis }
230347c08596SBrooks Davis 
230447c08596SBrooks Davis int
230547c08596SBrooks Davis dhcp_option_ev_name(char *buf, size_t buflen, struct option *option)
230647c08596SBrooks Davis {
230747c08596SBrooks Davis 	int i;
230847c08596SBrooks Davis 
230947c08596SBrooks Davis 	for (i = 0; option->name[i]; i++) {
231047c08596SBrooks Davis 		if (i + 1 == buflen)
231147c08596SBrooks Davis 			return 0;
231247c08596SBrooks Davis 		if (option->name[i] == '-')
231347c08596SBrooks Davis 			buf[i] = '_';
231447c08596SBrooks Davis 		else
231547c08596SBrooks Davis 			buf[i] = option->name[i];
231647c08596SBrooks Davis 	}
231747c08596SBrooks Davis 
231847c08596SBrooks Davis 	buf[i] = 0;
231947c08596SBrooks Davis 	return 1;
232047c08596SBrooks Davis }
232147c08596SBrooks Davis 
232247c08596SBrooks Davis void
232347c08596SBrooks Davis go_daemon(void)
232447c08596SBrooks Davis {
232547c08596SBrooks Davis 	static int state = 0;
232647c08596SBrooks Davis 
232747c08596SBrooks Davis 	if (no_daemon || state)
232847c08596SBrooks Davis 		return;
232947c08596SBrooks Davis 
233047c08596SBrooks Davis 	state = 1;
233147c08596SBrooks Davis 
233247c08596SBrooks Davis 	/* Stop logging to stderr... */
233347c08596SBrooks Davis 	log_perror = 0;
233447c08596SBrooks Davis 
233547c08596SBrooks Davis 	if (daemon(1, 0) == -1)
233647c08596SBrooks Davis 		error("daemon");
233747c08596SBrooks Davis 
233823f39c90SDag-Erling Smørgrav 	if (pidfile != NULL)
233923f39c90SDag-Erling Smørgrav 		pidfile_write(pidfile);
234023f39c90SDag-Erling Smørgrav 
234147c08596SBrooks Davis 	/* we are chrooted, daemon(3) fails to open /dev/null */
234247c08596SBrooks Davis 	if (nullfd != -1) {
234347c08596SBrooks Davis 		dup2(nullfd, STDIN_FILENO);
234447c08596SBrooks Davis 		dup2(nullfd, STDOUT_FILENO);
234547c08596SBrooks Davis 		dup2(nullfd, STDERR_FILENO);
234647c08596SBrooks Davis 		close(nullfd);
234747c08596SBrooks Davis 		nullfd = -1;
234847c08596SBrooks Davis 	}
234947c08596SBrooks Davis }
235047c08596SBrooks Davis 
235147c08596SBrooks Davis int
235247c08596SBrooks Davis check_option(struct client_lease *l, int option)
235347c08596SBrooks Davis {
235447c08596SBrooks Davis 	char *opbuf;
235547c08596SBrooks Davis 	char *sbuf;
235647c08596SBrooks Davis 
235747c08596SBrooks Davis 	/* we use this, since this is what gets passed to dhclient-script */
235847c08596SBrooks Davis 
235947c08596SBrooks Davis 	opbuf = pretty_print_option(option, l->options[option].data,
236047c08596SBrooks Davis 	    l->options[option].len, 0, 0);
236147c08596SBrooks Davis 
236247c08596SBrooks Davis 	sbuf = option_as_string(option, l->options[option].data,
236347c08596SBrooks Davis 	    l->options[option].len);
236447c08596SBrooks Davis 
236547c08596SBrooks Davis 	switch (option) {
236647c08596SBrooks Davis 	case DHO_SUBNET_MASK:
236747c08596SBrooks Davis 	case DHO_TIME_SERVERS:
236847c08596SBrooks Davis 	case DHO_NAME_SERVERS:
236947c08596SBrooks Davis 	case DHO_ROUTERS:
237047c08596SBrooks Davis 	case DHO_DOMAIN_NAME_SERVERS:
237147c08596SBrooks Davis 	case DHO_LOG_SERVERS:
237247c08596SBrooks Davis 	case DHO_COOKIE_SERVERS:
237347c08596SBrooks Davis 	case DHO_LPR_SERVERS:
237447c08596SBrooks Davis 	case DHO_IMPRESS_SERVERS:
237547c08596SBrooks Davis 	case DHO_RESOURCE_LOCATION_SERVERS:
237647c08596SBrooks Davis 	case DHO_SWAP_SERVER:
237747c08596SBrooks Davis 	case DHO_BROADCAST_ADDRESS:
237847c08596SBrooks Davis 	case DHO_NIS_SERVERS:
237947c08596SBrooks Davis 	case DHO_NTP_SERVERS:
238047c08596SBrooks Davis 	case DHO_NETBIOS_NAME_SERVERS:
238147c08596SBrooks Davis 	case DHO_NETBIOS_DD_SERVER:
238247c08596SBrooks Davis 	case DHO_FONT_SERVERS:
238347c08596SBrooks Davis 	case DHO_DHCP_SERVER_IDENTIFIER:
238438e755fdSBrooks Davis 	case DHO_NISPLUS_SERVERS:
238538e755fdSBrooks Davis 	case DHO_MOBILE_IP_HOME_AGENT:
2386a36c0b6bSBrooks Davis 	case DHO_SMTP_SERVER:
2387a36c0b6bSBrooks Davis 	case DHO_POP_SERVER:
2388a36c0b6bSBrooks Davis 	case DHO_NNTP_SERVER:
2389a36c0b6bSBrooks Davis 	case DHO_WWW_SERVER:
2390a36c0b6bSBrooks Davis 	case DHO_FINGER_SERVER:
2391a36c0b6bSBrooks Davis 	case DHO_IRC_SERVER:
239238e755fdSBrooks Davis 	case DHO_STREETTALK_SERVER:
239338e755fdSBrooks Davis 	case DHO_STREETTALK_DA_SERVER:
239447c08596SBrooks Davis 		if (!ipv4addrs(opbuf)) {
239547c08596SBrooks Davis 			warning("Invalid IP address in option: %s", opbuf);
239647c08596SBrooks Davis 			return (0);
239747c08596SBrooks Davis 		}
239847c08596SBrooks Davis 		return (1)  ;
239947c08596SBrooks Davis 	case DHO_HOST_NAME:
240047c08596SBrooks Davis 	case DHO_NIS_DOMAIN:
240138e755fdSBrooks Davis 	case DHO_NISPLUS_DOMAIN:
240238e755fdSBrooks Davis 	case DHO_TFTP_SERVER_NAME:
240347c08596SBrooks Davis 		if (!res_hnok(sbuf)) {
240447c08596SBrooks Davis 			warning("Bogus Host Name option %d: %s (%s)", option,
240547c08596SBrooks Davis 			    sbuf, opbuf);
240682dbbc41SBrooks Davis 			l->options[option].len = 0;
240782dbbc41SBrooks Davis 			free(l->options[option].data);
240847c08596SBrooks Davis 		}
240947c08596SBrooks Davis 		return (1);
2410b388f1cbSBrooks Davis 	case DHO_DOMAIN_NAME:
2411409139f0SJean-Sébastien Pédron 	case DHO_DOMAIN_SEARCH:
2412f954ec0bSBrooks Davis 		if (!res_hnok(sbuf)) {
2413f954ec0bSBrooks Davis 			if (!check_search(sbuf)) {
2414f954ec0bSBrooks Davis 				warning("Bogus domain search list %d: %s (%s)",
2415f954ec0bSBrooks Davis 				    option, sbuf, opbuf);
241682dbbc41SBrooks Davis 				l->options[option].len = 0;
241782dbbc41SBrooks Davis 				free(l->options[option].data);
2418f954ec0bSBrooks Davis 			}
2419f954ec0bSBrooks Davis 		}
2420f954ec0bSBrooks Davis 		return (1);
242147c08596SBrooks Davis 	case DHO_PAD:
242247c08596SBrooks Davis 	case DHO_TIME_OFFSET:
242347c08596SBrooks Davis 	case DHO_BOOT_SIZE:
242447c08596SBrooks Davis 	case DHO_MERIT_DUMP:
242547c08596SBrooks Davis 	case DHO_ROOT_PATH:
242647c08596SBrooks Davis 	case DHO_EXTENSIONS_PATH:
242747c08596SBrooks Davis 	case DHO_IP_FORWARDING:
242847c08596SBrooks Davis 	case DHO_NON_LOCAL_SOURCE_ROUTING:
242947c08596SBrooks Davis 	case DHO_POLICY_FILTER:
243047c08596SBrooks Davis 	case DHO_MAX_DGRAM_REASSEMBLY:
243147c08596SBrooks Davis 	case DHO_DEFAULT_IP_TTL:
243247c08596SBrooks Davis 	case DHO_PATH_MTU_AGING_TIMEOUT:
243347c08596SBrooks Davis 	case DHO_PATH_MTU_PLATEAU_TABLE:
243447c08596SBrooks Davis 	case DHO_INTERFACE_MTU:
243547c08596SBrooks Davis 	case DHO_ALL_SUBNETS_LOCAL:
243647c08596SBrooks Davis 	case DHO_PERFORM_MASK_DISCOVERY:
243747c08596SBrooks Davis 	case DHO_MASK_SUPPLIER:
243847c08596SBrooks Davis 	case DHO_ROUTER_DISCOVERY:
243947c08596SBrooks Davis 	case DHO_ROUTER_SOLICITATION_ADDRESS:
244047c08596SBrooks Davis 	case DHO_STATIC_ROUTES:
244147c08596SBrooks Davis 	case DHO_TRAILER_ENCAPSULATION:
244247c08596SBrooks Davis 	case DHO_ARP_CACHE_TIMEOUT:
244347c08596SBrooks Davis 	case DHO_IEEE802_3_ENCAPSULATION:
244447c08596SBrooks Davis 	case DHO_DEFAULT_TCP_TTL:
244547c08596SBrooks Davis 	case DHO_TCP_KEEPALIVE_INTERVAL:
244647c08596SBrooks Davis 	case DHO_TCP_KEEPALIVE_GARBAGE:
244747c08596SBrooks Davis 	case DHO_VENDOR_ENCAPSULATED_OPTIONS:
244847c08596SBrooks Davis 	case DHO_NETBIOS_NODE_TYPE:
244947c08596SBrooks Davis 	case DHO_NETBIOS_SCOPE:
245047c08596SBrooks Davis 	case DHO_X_DISPLAY_MANAGER:
245147c08596SBrooks Davis 	case DHO_DHCP_REQUESTED_ADDRESS:
245247c08596SBrooks Davis 	case DHO_DHCP_LEASE_TIME:
245347c08596SBrooks Davis 	case DHO_DHCP_OPTION_OVERLOAD:
245447c08596SBrooks Davis 	case DHO_DHCP_MESSAGE_TYPE:
245547c08596SBrooks Davis 	case DHO_DHCP_PARAMETER_REQUEST_LIST:
245647c08596SBrooks Davis 	case DHO_DHCP_MESSAGE:
245747c08596SBrooks Davis 	case DHO_DHCP_MAX_MESSAGE_SIZE:
245847c08596SBrooks Davis 	case DHO_DHCP_RENEWAL_TIME:
245947c08596SBrooks Davis 	case DHO_DHCP_REBINDING_TIME:
246047c08596SBrooks Davis 	case DHO_DHCP_CLASS_IDENTIFIER:
246147c08596SBrooks Davis 	case DHO_DHCP_CLIENT_IDENTIFIER:
246238e755fdSBrooks Davis 	case DHO_BOOTFILE_NAME:
246347c08596SBrooks Davis 	case DHO_DHCP_USER_CLASS_ID:
246447c08596SBrooks Davis 	case DHO_END:
246547c08596SBrooks Davis 		return (1);
24662fcc7370SEd Maste 	case DHO_CLASSLESS_ROUTES:
24672fcc7370SEd Maste 		return (check_classless_option(l->options[option].data,
24682fcc7370SEd Maste 		    l->options[option].len));
246947c08596SBrooks Davis 	default:
247047c08596SBrooks Davis 		warning("unknown dhcp option value 0x%x", option);
247147c08596SBrooks Davis 		return (unknown_ok);
247247c08596SBrooks Davis 	}
247347c08596SBrooks Davis }
247447c08596SBrooks Davis 
24752fcc7370SEd Maste /* RFC 3442 The Classless Static Routes option checks */
24762fcc7370SEd Maste int
24772fcc7370SEd Maste check_classless_option(unsigned char *data, int len)
24782fcc7370SEd Maste {
24792fcc7370SEd Maste 	int i = 0;
24802fcc7370SEd Maste 	unsigned char width;
24812fcc7370SEd Maste 	in_addr_t addr, mask;
24822fcc7370SEd Maste 
24832fcc7370SEd Maste 	if (len < 5) {
24842fcc7370SEd Maste 		warning("Too small length: %d", len);
24852fcc7370SEd Maste 		return (0);
24862fcc7370SEd Maste 	}
24872fcc7370SEd Maste 	while(i < len) {
24882fcc7370SEd Maste 		width = data[i++];
24892fcc7370SEd Maste 		if (width == 0) {
24902fcc7370SEd Maste 			i += 4;
24912fcc7370SEd Maste 			continue;
24922fcc7370SEd Maste 		} else if (width < 9) {
24932fcc7370SEd Maste 			addr =  (in_addr_t)(data[i] 	<< 24);
24942fcc7370SEd Maste 			i += 1;
24952fcc7370SEd Maste 		} else if (width < 17) {
24962fcc7370SEd Maste 			addr =  (in_addr_t)(data[i] 	<< 24) +
24972fcc7370SEd Maste 				(in_addr_t)(data[i + 1]	<< 16);
24982fcc7370SEd Maste 			i += 2;
24992fcc7370SEd Maste 		} else if (width < 25) {
25002fcc7370SEd Maste 			addr =  (in_addr_t)(data[i] 	<< 24) +
25012fcc7370SEd Maste 				(in_addr_t)(data[i + 1]	<< 16) +
25022fcc7370SEd Maste 				(in_addr_t)(data[i + 2]	<< 8);
25032fcc7370SEd Maste 			i += 3;
25042fcc7370SEd Maste 		} else if (width < 33) {
25052fcc7370SEd Maste 			addr =  (in_addr_t)(data[i] 	<< 24) +
25062fcc7370SEd Maste 				(in_addr_t)(data[i + 1]	<< 16) +
25072fcc7370SEd Maste 				(in_addr_t)(data[i + 2]	<< 8)  +
25082fcc7370SEd Maste 				data[i + 3];
25092fcc7370SEd Maste 			i += 4;
25102fcc7370SEd Maste 		} else {
25112fcc7370SEd Maste 			warning("Incorrect subnet width: %d", width);
25122fcc7370SEd Maste 			return (0);
25132fcc7370SEd Maste 		}
25142fcc7370SEd Maste 		mask = (in_addr_t)(~0) << (32 - width);
25152fcc7370SEd Maste 		addr = ntohl(addr);
25162fcc7370SEd Maste 		mask = ntohl(mask);
25172fcc7370SEd Maste 
25182fcc7370SEd Maste 		/*
25192fcc7370SEd Maste 		 * From RFC 3442:
25202fcc7370SEd Maste 		 * ... After deriving a subnet number and subnet mask
25212fcc7370SEd Maste 		 * from each destination descriptor, the DHCP client
25222fcc7370SEd Maste 		 * MUST zero any bits in the subnet number where the
25232fcc7370SEd Maste 		 * corresponding bit in the mask is zero...
25242fcc7370SEd Maste 		 */
25252fcc7370SEd Maste 		if ((addr & mask) != addr) {
25262fcc7370SEd Maste 			addr &= mask;
25272fcc7370SEd Maste 			data[i - 1] = (unsigned char)(
25282fcc7370SEd Maste 				(addr >> (((32 - width)/8)*8)) & 0xFF);
25292fcc7370SEd Maste 		}
25302fcc7370SEd Maste 		i += 4;
25312fcc7370SEd Maste 	}
25322fcc7370SEd Maste 	if (i > len) {
25332fcc7370SEd Maste 		warning("Incorrect data length: %d (must be %d)", len, i);
25342fcc7370SEd Maste 		return (0);
25352fcc7370SEd Maste 	}
25362fcc7370SEd Maste 	return (1);
25372fcc7370SEd Maste }
25382fcc7370SEd Maste 
253947c08596SBrooks Davis int
254047c08596SBrooks Davis res_hnok(const char *dn)
254147c08596SBrooks Davis {
254247c08596SBrooks Davis 	int pch = PERIOD, ch = *dn++;
254347c08596SBrooks Davis 
254447c08596SBrooks Davis 	while (ch != '\0') {
254547c08596SBrooks Davis 		int nch = *dn++;
254647c08596SBrooks Davis 
254747c08596SBrooks Davis 		if (periodchar(ch)) {
254847c08596SBrooks Davis 			;
254947c08596SBrooks Davis 		} else if (periodchar(pch)) {
255047c08596SBrooks Davis 			if (!borderchar(ch))
255147c08596SBrooks Davis 				return (0);
255247c08596SBrooks Davis 		} else if (periodchar(nch) || nch == '\0') {
255347c08596SBrooks Davis 			if (!borderchar(ch))
255447c08596SBrooks Davis 				return (0);
255547c08596SBrooks Davis 		} else {
255647c08596SBrooks Davis 			if (!middlechar(ch))
255747c08596SBrooks Davis 				return (0);
255847c08596SBrooks Davis 		}
255947c08596SBrooks Davis 		pch = ch, ch = nch;
256047c08596SBrooks Davis 	}
256147c08596SBrooks Davis 	return (1);
256247c08596SBrooks Davis }
256347c08596SBrooks Davis 
2564f954ec0bSBrooks Davis int
2565f954ec0bSBrooks Davis check_search(const char *srch)
2566f954ec0bSBrooks Davis {
2567f954ec0bSBrooks Davis         int pch = PERIOD, ch = *srch++;
2568f954ec0bSBrooks Davis 	int domains = 1;
2569f954ec0bSBrooks Davis 
2570f954ec0bSBrooks Davis 	/* 256 char limit re resolv.conf(5) */
2571f954ec0bSBrooks Davis 	if (strlen(srch) > 256)
2572f954ec0bSBrooks Davis 		return (0);
2573f954ec0bSBrooks Davis 
2574f954ec0bSBrooks Davis 	while (whitechar(ch))
2575f954ec0bSBrooks Davis 		ch = *srch++;
2576f954ec0bSBrooks Davis 
2577f954ec0bSBrooks Davis         while (ch != '\0') {
2578f954ec0bSBrooks Davis                 int nch = *srch++;
2579f954ec0bSBrooks Davis 
2580f954ec0bSBrooks Davis                 if (periodchar(ch) || whitechar(ch)) {
2581f954ec0bSBrooks Davis                         ;
2582f954ec0bSBrooks Davis                 } else if (periodchar(pch)) {
2583f954ec0bSBrooks Davis                         if (!borderchar(ch))
2584f954ec0bSBrooks Davis                                 return (0);
2585f954ec0bSBrooks Davis                 } else if (periodchar(nch) || nch == '\0') {
2586f954ec0bSBrooks Davis                         if (!borderchar(ch))
2587f954ec0bSBrooks Davis                                 return (0);
2588f954ec0bSBrooks Davis                 } else {
2589f954ec0bSBrooks Davis                         if (!middlechar(ch))
2590f954ec0bSBrooks Davis                                 return (0);
2591f954ec0bSBrooks Davis                 }
2592f954ec0bSBrooks Davis 		if (!whitechar(ch)) {
2593f954ec0bSBrooks Davis 			pch = ch;
2594f954ec0bSBrooks Davis 		} else {
2595f954ec0bSBrooks Davis 			while (whitechar(nch)) {
2596f954ec0bSBrooks Davis 				nch = *srch++;
2597f954ec0bSBrooks Davis 			}
2598f954ec0bSBrooks Davis 			if (nch != '\0')
2599f954ec0bSBrooks Davis 				domains++;
2600f954ec0bSBrooks Davis 			pch = PERIOD;
2601f954ec0bSBrooks Davis 		}
2602f954ec0bSBrooks Davis 		ch = nch;
2603f954ec0bSBrooks Davis         }
2604f954ec0bSBrooks Davis 	/* 6 domain limit re resolv.conf(5) */
2605f954ec0bSBrooks Davis 	if (domains > 6)
2606f954ec0bSBrooks Davis 		return (0);
2607f954ec0bSBrooks Davis         return (1);
2608f954ec0bSBrooks Davis }
2609f954ec0bSBrooks Davis 
261047c08596SBrooks Davis /* Does buf consist only of dotted decimal ipv4 addrs?
261147c08596SBrooks Davis  * return how many if so,
261247c08596SBrooks Davis  * otherwise, return 0
261347c08596SBrooks Davis  */
261447c08596SBrooks Davis int
261547c08596SBrooks Davis ipv4addrs(char * buf)
261647c08596SBrooks Davis {
261747c08596SBrooks Davis 	struct in_addr jnk;
261847c08596SBrooks Davis 	int count = 0;
261947c08596SBrooks Davis 
262047c08596SBrooks Davis 	while (inet_aton(buf, &jnk) == 1){
262147c08596SBrooks Davis 		count++;
262247c08596SBrooks Davis 		while (periodchar(*buf) || digitchar(*buf))
262347c08596SBrooks Davis 			buf++;
262447c08596SBrooks Davis 		if (*buf == '\0')
262547c08596SBrooks Davis 			return (count);
262647c08596SBrooks Davis 		while (*buf ==  ' ')
262747c08596SBrooks Davis 			buf++;
262847c08596SBrooks Davis 	}
262947c08596SBrooks Davis 	return (0);
263047c08596SBrooks Davis }
263147c08596SBrooks Davis 
263247c08596SBrooks Davis 
263347c08596SBrooks Davis char *
263447c08596SBrooks Davis option_as_string(unsigned int code, unsigned char *data, int len)
263547c08596SBrooks Davis {
263647c08596SBrooks Davis 	static char optbuf[32768]; /* XXX */
263747c08596SBrooks Davis 	char *op = optbuf;
263847c08596SBrooks Davis 	int opleft = sizeof(optbuf);
263947c08596SBrooks Davis 	unsigned char *dp = data;
264047c08596SBrooks Davis 
264147c08596SBrooks Davis 	if (code > 255)
264247c08596SBrooks Davis 		error("option_as_string: bad code %d", code);
264347c08596SBrooks Davis 
264447c08596SBrooks Davis 	for (; dp < data + len; dp++) {
264547c08596SBrooks Davis 		if (!isascii(*dp) || !isprint(*dp)) {
264647c08596SBrooks Davis 			if (dp + 1 != data + len || *dp != 0) {
264747c08596SBrooks Davis 				snprintf(op, opleft, "\\%03o", *dp);
264847c08596SBrooks Davis 				op += 4;
264947c08596SBrooks Davis 				opleft -= 4;
265047c08596SBrooks Davis 			}
265147c08596SBrooks Davis 		} else if (*dp == '"' || *dp == '\'' || *dp == '$' ||
265247c08596SBrooks Davis 		    *dp == '`' || *dp == '\\') {
265347c08596SBrooks Davis 			*op++ = '\\';
265447c08596SBrooks Davis 			*op++ = *dp;
265547c08596SBrooks Davis 			opleft -= 2;
265647c08596SBrooks Davis 		} else {
265747c08596SBrooks Davis 			*op++ = *dp;
265847c08596SBrooks Davis 			opleft--;
265947c08596SBrooks Davis 		}
266047c08596SBrooks Davis 	}
266147c08596SBrooks Davis 	if (opleft < 1)
266247c08596SBrooks Davis 		goto toobig;
266347c08596SBrooks Davis 	*op = 0;
266447c08596SBrooks Davis 	return optbuf;
266547c08596SBrooks Davis toobig:
266647c08596SBrooks Davis 	warning("dhcp option too large");
266747c08596SBrooks Davis 	return "<error>";
266847c08596SBrooks Davis }
266947c08596SBrooks Davis 
267047c08596SBrooks Davis int
267147c08596SBrooks Davis fork_privchld(int fd, int fd2)
267247c08596SBrooks Davis {
267347c08596SBrooks Davis 	struct pollfd pfd[1];
267447c08596SBrooks Davis 	int nfds;
267547c08596SBrooks Davis 
267647c08596SBrooks Davis 	switch (fork()) {
267747c08596SBrooks Davis 	case -1:
267847c08596SBrooks Davis 		error("cannot fork");
267947c08596SBrooks Davis 	case 0:
268047c08596SBrooks Davis 		break;
268147c08596SBrooks Davis 	default:
268247c08596SBrooks Davis 		return (0);
268347c08596SBrooks Davis 	}
268447c08596SBrooks Davis 
268547c08596SBrooks Davis 	setproctitle("%s [priv]", ifi->name);
268647c08596SBrooks Davis 
268770892546SEd Schouten 	setsid();
268847c08596SBrooks Davis 	dup2(nullfd, STDIN_FILENO);
268947c08596SBrooks Davis 	dup2(nullfd, STDOUT_FILENO);
269047c08596SBrooks Davis 	dup2(nullfd, STDERR_FILENO);
269147c08596SBrooks Davis 	close(nullfd);
269247c08596SBrooks Davis 	close(fd2);
269347c08596SBrooks Davis 
269447c08596SBrooks Davis 	for (;;) {
269547c08596SBrooks Davis 		pfd[0].fd = fd;
269647c08596SBrooks Davis 		pfd[0].events = POLLIN;
269747c08596SBrooks Davis 		if ((nfds = poll(pfd, 1, INFTIM)) == -1)
269847c08596SBrooks Davis 			if (errno != EINTR)
269947c08596SBrooks Davis 				error("poll error");
270047c08596SBrooks Davis 
270147c08596SBrooks Davis 		if (nfds == 0 || !(pfd[0].revents & POLLIN))
270247c08596SBrooks Davis 			continue;
270347c08596SBrooks Davis 
270447c08596SBrooks Davis 		dispatch_imsg(fd);
270547c08596SBrooks Davis 	}
270647c08596SBrooks Davis }
2707