xref: /freebsd/sbin/dhclient/dhclient.c (revision 31698405990209a0e092de7265b1672651eed287)
147c08596SBrooks Davis /*	$OpenBSD: dhclient.c,v 1.63 2005/02/06 17:10:13 krw Exp $	*/
247c08596SBrooks Davis 
38a16b7a1SPedro F. Giffuni /*-
48a16b7a1SPedro F. Giffuni  * SPDX-License-Identifier: BSD-3-Clause
58a16b7a1SPedro F. Giffuni  *
647c08596SBrooks Davis  * Copyright 2004 Henning Brauer <henning@openbsd.org>
747c08596SBrooks Davis  * Copyright (c) 1995, 1996, 1997, 1998, 1999
847c08596SBrooks Davis  * The Internet Software Consortium.    All rights reserved.
947c08596SBrooks Davis  *
1047c08596SBrooks Davis  * Redistribution and use in source and binary forms, with or without
1147c08596SBrooks Davis  * modification, are permitted provided that the following conditions
1247c08596SBrooks Davis  * are met:
1347c08596SBrooks Davis  *
1447c08596SBrooks Davis  * 1. Redistributions of source code must retain the above copyright
1547c08596SBrooks Davis  *    notice, this list of conditions and the following disclaimer.
1647c08596SBrooks Davis  * 2. Redistributions in binary form must reproduce the above copyright
1747c08596SBrooks Davis  *    notice, this list of conditions and the following disclaimer in the
1847c08596SBrooks Davis  *    documentation and/or other materials provided with the distribution.
1947c08596SBrooks Davis  * 3. Neither the name of The Internet Software Consortium nor the names
2047c08596SBrooks Davis  *    of its contributors may be used to endorse or promote products derived
2147c08596SBrooks Davis  *    from this software without specific prior written permission.
2247c08596SBrooks Davis  *
2347c08596SBrooks Davis  * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
2447c08596SBrooks Davis  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
2547c08596SBrooks Davis  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
2647c08596SBrooks Davis  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
2747c08596SBrooks Davis  * DISCLAIMED.  IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
2847c08596SBrooks Davis  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2947c08596SBrooks Davis  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3047c08596SBrooks Davis  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
3147c08596SBrooks Davis  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
3247c08596SBrooks Davis  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
3347c08596SBrooks Davis  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
3447c08596SBrooks Davis  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
3547c08596SBrooks Davis  * SUCH DAMAGE.
3647c08596SBrooks Davis  *
3747c08596SBrooks Davis  * This software has been written for the Internet Software Consortium
3847c08596SBrooks Davis  * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
3947c08596SBrooks Davis  * Enterprises.  To learn more about the Internet Software Consortium,
4047c08596SBrooks Davis  * see ``http://www.vix.com/isc''.  To learn more about Vixie
4147c08596SBrooks Davis  * Enterprises, see ``http://www.vix.com''.
4247c08596SBrooks Davis  *
4347c08596SBrooks Davis  * This client was substantially modified and enhanced by Elliot Poger
4447c08596SBrooks Davis  * for use on Linux while he was working on the MosquitoNet project at
4547c08596SBrooks Davis  * Stanford.
4647c08596SBrooks Davis  *
4747c08596SBrooks Davis  * The current version owes much to Elliot's Linux enhancements, but
4847c08596SBrooks Davis  * was substantially reorganized and partially rewritten by Ted Lemon
4947c08596SBrooks Davis  * so as to use the same networking framework that the Internet Software
5047c08596SBrooks Davis  * Consortium DHCP server uses.   Much system-specific configuration code
5147c08596SBrooks Davis  * was moved into a shell script so that as support for more operating
5247c08596SBrooks Davis  * systems is added, it will not be necessary to port and maintain
5347c08596SBrooks Davis  * system-specific configuration code to these operating systems - instead,
5447c08596SBrooks Davis  * the shell script can invoke the native tools to accomplish the same
5547c08596SBrooks Davis  * purpose.
5647c08596SBrooks Davis  */
5747c08596SBrooks Davis 
588794fdbbSBrooks Davis #include <sys/cdefs.h>
598794fdbbSBrooks Davis __FBSDID("$FreeBSD$");
608794fdbbSBrooks Davis 
6147c08596SBrooks Davis #include "dhcpd.h"
6247c08596SBrooks Davis #include "privsep.h"
6347c08596SBrooks Davis 
64b881b8beSRobert Watson #include <sys/capsicum.h>
65387016a5SConrad Meyer #include <sys/endian.h>
66de2c882fSPawel Jakub Dawidek 
672b19b6fcSBrooks Davis #include <net80211/ieee80211_freebsd.h>
682b19b6fcSBrooks Davis 
692b19b6fcSBrooks Davis #ifndef _PATH_VAREMPTY
702b19b6fcSBrooks Davis #define	_PATH_VAREMPTY	"/var/empty"
712b19b6fcSBrooks Davis #endif
722b19b6fcSBrooks Davis 
7347c08596SBrooks Davis #define	PERIOD 0x2e
7447c08596SBrooks Davis #define	hyphenchar(c) ((c) == 0x2d)
7547c08596SBrooks Davis #define	bslashchar(c) ((c) == 0x5c)
7647c08596SBrooks Davis #define	periodchar(c) ((c) == PERIOD)
7747c08596SBrooks Davis #define	asterchar(c) ((c) == 0x2a)
7847c08596SBrooks Davis #define	alphachar(c) (((c) >= 0x41 && (c) <= 0x5a) || \
7947c08596SBrooks Davis 	    ((c) >= 0x61 && (c) <= 0x7a))
8047c08596SBrooks Davis #define	digitchar(c) ((c) >= 0x30 && (c) <= 0x39)
81f954ec0bSBrooks Davis #define	whitechar(c) ((c) == ' ' || (c) == '\t')
8247c08596SBrooks Davis 
8347c08596SBrooks Davis #define	borderchar(c) (alphachar(c) || digitchar(c))
8447c08596SBrooks Davis #define	middlechar(c) (borderchar(c) || hyphenchar(c))
8547c08596SBrooks Davis #define	domainchar(c) ((c) > 0x20 && (c) < 0x7f)
8647c08596SBrooks Davis 
8747c08596SBrooks Davis #define	CLIENT_PATH "PATH=/usr/bin:/usr/sbin:/bin:/sbin"
8847c08596SBrooks Davis 
89cb003dd9SMariusz Zaborski cap_channel_t *capsyslog;
90cb003dd9SMariusz Zaborski 
9147c08596SBrooks Davis time_t cur_time;
9247c08596SBrooks Davis time_t default_lease_time = 43200; /* 12 hours... */
9347c08596SBrooks Davis 
9447c08596SBrooks Davis char *path_dhclient_conf = _PATH_DHCLIENT_CONF;
9547c08596SBrooks Davis char *path_dhclient_db = NULL;
9647c08596SBrooks Davis 
9747c08596SBrooks Davis int log_perror = 1;
9847c08596SBrooks Davis int privfd;
9947c08596SBrooks Davis int nullfd = -1;
10047c08596SBrooks Davis 
1010bbe8306SPawel Jakub Dawidek char hostname[_POSIX_HOST_NAME_MAX + 1];
1020bbe8306SPawel Jakub Dawidek 
10347c08596SBrooks Davis struct iaddr iaddr_broadcast = { 4, { 255, 255, 255, 255 } };
104ba019ae5SPawel Jakub Dawidek struct in_addr inaddr_any, inaddr_broadcast;
10547c08596SBrooks Davis 
10623f39c90SDag-Erling Smørgrav char *path_dhclient_pidfile;
10723f39c90SDag-Erling Smørgrav struct pidfh *pidfile;
10823f39c90SDag-Erling Smørgrav 
10947c08596SBrooks Davis /*
11047c08596SBrooks Davis  * ASSERT_STATE() does nothing now; it used to be
11147c08596SBrooks Davis  * assert (state_is == state_shouldbe).
11247c08596SBrooks Davis  */
11347c08596SBrooks Davis #define ASSERT_STATE(state_is, state_shouldbe) {}
11447c08596SBrooks Davis 
115223c44aeSNick Hibma /*
116223c44aeSNick Hibma  * We need to check that the expiry, renewal and rebind times are not beyond
117223c44aeSNick Hibma  * the end of time (~2038 when a 32-bit time_t is being used).
118223c44aeSNick Hibma  */
119223c44aeSNick Hibma #define TIME_MAX        ((((time_t) 1 << (sizeof(time_t) * CHAR_BIT - 2)) - 1) * 2 + 1)
12047c08596SBrooks Davis 
12147c08596SBrooks Davis int		log_priority;
12247c08596SBrooks Davis int		no_daemon;
12347c08596SBrooks Davis int		unknown_ok = 1;
12447c08596SBrooks Davis int		routefd;
12547c08596SBrooks Davis 
12647c08596SBrooks Davis struct interface_info	*ifi;
12747c08596SBrooks Davis 
12847c08596SBrooks Davis int		 findproto(char *, int);
12947c08596SBrooks Davis struct sockaddr	*get_ifa(char *, int);
13047c08596SBrooks Davis void		 routehandler(struct protocol *);
13147c08596SBrooks Davis void		 usage(void);
13247c08596SBrooks Davis int		 check_option(struct client_lease *l, int option);
1332fcc7370SEd Maste int		 check_classless_option(unsigned char *data, int len);
13447c08596SBrooks Davis int		 ipv4addrs(char * buf);
13547c08596SBrooks Davis int		 res_hnok(const char *dn);
136f954ec0bSBrooks Davis int		 check_search(const char *srch);
13747c08596SBrooks Davis char		*option_as_string(unsigned int code, unsigned char *data, int len);
13847c08596SBrooks Davis int		 fork_privchld(int, int);
13947c08596SBrooks Davis 
14047c08596SBrooks Davis #define	ROUNDUP(a) \
14147c08596SBrooks Davis 	    ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
14247c08596SBrooks Davis #define	ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
14347c08596SBrooks Davis 
144387016a5SConrad Meyer /* Minimum MTU is 68 as per RFC791, p. 24 */
145387016a5SConrad Meyer #define MIN_MTU 68
146387016a5SConrad Meyer 
1476964abefSBrian Somers static time_t	scripttime;
14847c08596SBrooks Davis 
14947c08596SBrooks Davis int
15047c08596SBrooks Davis findproto(char *cp, int n)
15147c08596SBrooks Davis {
15247c08596SBrooks Davis 	struct sockaddr *sa;
1535f28c51dSAlan Somers 	unsigned i;
15447c08596SBrooks Davis 
15547c08596SBrooks Davis 	if (n == 0)
15647c08596SBrooks Davis 		return -1;
15747c08596SBrooks Davis 	for (i = 1; i; i <<= 1) {
15847c08596SBrooks Davis 		if (i & n) {
15947c08596SBrooks Davis 			sa = (struct sockaddr *)cp;
16047c08596SBrooks Davis 			switch (i) {
16147c08596SBrooks Davis 			case RTA_IFA:
16247c08596SBrooks Davis 			case RTA_DST:
16347c08596SBrooks Davis 			case RTA_GATEWAY:
16447c08596SBrooks Davis 			case RTA_NETMASK:
16547c08596SBrooks Davis 				if (sa->sa_family == AF_INET)
16647c08596SBrooks Davis 					return AF_INET;
16747c08596SBrooks Davis 				if (sa->sa_family == AF_INET6)
16847c08596SBrooks Davis 					return AF_INET6;
16947c08596SBrooks Davis 				break;
17047c08596SBrooks Davis 			case RTA_IFP:
17147c08596SBrooks Davis 				break;
17247c08596SBrooks Davis 			}
17347c08596SBrooks Davis 			ADVANCE(cp, sa);
17447c08596SBrooks Davis 		}
17547c08596SBrooks Davis 	}
17647c08596SBrooks Davis 	return (-1);
17747c08596SBrooks Davis }
17847c08596SBrooks Davis 
17947c08596SBrooks Davis struct sockaddr *
18047c08596SBrooks Davis get_ifa(char *cp, int n)
18147c08596SBrooks Davis {
18247c08596SBrooks Davis 	struct sockaddr *sa;
1835f28c51dSAlan Somers 	unsigned i;
18447c08596SBrooks Davis 
18547c08596SBrooks Davis 	if (n == 0)
18647c08596SBrooks Davis 		return (NULL);
18747c08596SBrooks Davis 	for (i = 1; i; i <<= 1)
18847c08596SBrooks Davis 		if (i & n) {
18947c08596SBrooks Davis 			sa = (struct sockaddr *)cp;
19047c08596SBrooks Davis 			if (i == RTA_IFA)
19147c08596SBrooks Davis 				return (sa);
19247c08596SBrooks Davis 			ADVANCE(cp, sa);
19347c08596SBrooks Davis 		}
19447c08596SBrooks Davis 
19547c08596SBrooks Davis 	return (NULL);
19647c08596SBrooks Davis }
19761063e47SSam Leffler 
198afe6f835SAlan Somers struct iaddr defaddr = { .len = 4 };
19961063e47SSam Leffler uint8_t curbssid[6];
20061063e47SSam Leffler 
20161063e47SSam Leffler static void
20261063e47SSam Leffler disassoc(void *arg)
20361063e47SSam Leffler {
20461063e47SSam Leffler 	struct interface_info *ifi = arg;
20561063e47SSam Leffler 
20661063e47SSam Leffler 	/*
20761063e47SSam Leffler 	 * Clear existing state.
20861063e47SSam Leffler 	 */
20961063e47SSam Leffler 	if (ifi->client->active != NULL) {
21061063e47SSam Leffler 		script_init("EXPIRE", NULL);
21161063e47SSam Leffler 		script_write_params("old_",
21261063e47SSam Leffler 		    ifi->client->active);
21361063e47SSam Leffler 		if (ifi->client->alias)
21461063e47SSam Leffler 			script_write_params("alias_",
21561063e47SSam Leffler 				ifi->client->alias);
21661063e47SSam Leffler 		script_go();
21761063e47SSam Leffler 	}
21861063e47SSam Leffler 	ifi->client->state = S_INIT;
21961063e47SSam Leffler }
22047c08596SBrooks Davis 
22147c08596SBrooks Davis /* ARGSUSED */
22247c08596SBrooks Davis void
22347c08596SBrooks Davis routehandler(struct protocol *p)
22447c08596SBrooks Davis {
2256964abefSBrian Somers 	char msg[2048], *addr;
22647c08596SBrooks Davis 	struct rt_msghdr *rtm;
22747c08596SBrooks Davis 	struct if_msghdr *ifm;
22847c08596SBrooks Davis 	struct ifa_msghdr *ifam;
22947c08596SBrooks Davis 	struct if_announcemsghdr *ifan;
23061063e47SSam Leffler 	struct ieee80211_join_event *jev;
23147c08596SBrooks Davis 	struct client_lease *l;
23247c08596SBrooks Davis 	time_t t = time(NULL);
23347c08596SBrooks Davis 	struct sockaddr *sa;
23447c08596SBrooks Davis 	struct iaddr a;
23547c08596SBrooks Davis 	ssize_t n;
2360a26f858SJohn Baldwin 	int linkstat;
23747c08596SBrooks Davis 
23847c08596SBrooks Davis 	n = read(routefd, &msg, sizeof(msg));
23947c08596SBrooks Davis 	rtm = (struct rt_msghdr *)msg;
240afe6f835SAlan Somers 	if (n < (ssize_t)sizeof(rtm->rtm_msglen) ||
241afe6f835SAlan Somers 	    n < (ssize_t)rtm->rtm_msglen ||
24247c08596SBrooks Davis 	    rtm->rtm_version != RTM_VERSION)
24347c08596SBrooks Davis 		return;
24447c08596SBrooks Davis 
24547c08596SBrooks Davis 	switch (rtm->rtm_type) {
24647c08596SBrooks Davis 	case RTM_NEWADDR:
247dfad96eaSBrooks Davis 	case RTM_DELADDR:
24847c08596SBrooks Davis 		ifam = (struct ifa_msghdr *)rtm;
249dfad96eaSBrooks Davis 
25047c08596SBrooks Davis 		if (ifam->ifam_index != ifi->index)
25147c08596SBrooks Davis 			break;
25247c08596SBrooks Davis 		if (findproto((char *)(ifam + 1), ifam->ifam_addrs) != AF_INET)
25347c08596SBrooks Davis 			break;
254dfad96eaSBrooks Davis 		if (scripttime == 0 || t < scripttime + 10)
255dfad96eaSBrooks Davis 			break;
256dfad96eaSBrooks Davis 
25747c08596SBrooks Davis 		sa = get_ifa((char *)(ifam + 1), ifam->ifam_addrs);
25847c08596SBrooks Davis 		if (sa == NULL)
2596964abefSBrian Somers 			break;
26047c08596SBrooks Davis 
26147c08596SBrooks Davis 		if ((a.len = sizeof(struct in_addr)) > sizeof(a.iabuf))
26247c08596SBrooks Davis 			error("king bula sez: len mismatch");
26347c08596SBrooks Davis 		memcpy(a.iabuf, &((struct sockaddr_in *)sa)->sin_addr, a.len);
26447c08596SBrooks Davis 		if (addr_eq(a, defaddr))
26547c08596SBrooks Davis 			break;
26647c08596SBrooks Davis 
26747c08596SBrooks Davis 		for (l = ifi->client->active; l != NULL; l = l->next)
26847c08596SBrooks Davis 			if (addr_eq(a, l->address))
26947c08596SBrooks Davis 				break;
27047c08596SBrooks Davis 
2716964abefSBrian Somers 		if (l == NULL)	/* added/deleted addr is not the one we set */
27247c08596SBrooks Davis 			break;
2736964abefSBrian Somers 
2746964abefSBrian Somers 		addr = inet_ntoa(((struct sockaddr_in *)sa)->sin_addr);
2756964abefSBrian Somers 		if (rtm->rtm_type == RTM_NEWADDR)  {
2766964abefSBrian Somers 			/*
2776964abefSBrian Somers 			 * XXX: If someone other than us adds our address,
2786964abefSBrian Somers 			 * should we assume they are taking over from us,
2796964abefSBrian Somers 			 * delete the lease record, and exit without modifying
2806964abefSBrian Somers 			 * the interface?
2816964abefSBrian Somers 			 */
2826964abefSBrian Somers 			warning("My address (%s) was re-added", addr);
2836964abefSBrian Somers 		} else {
2846964abefSBrian Somers 			warning("My address (%s) was deleted, dhclient exiting",
2856964abefSBrian Somers 			    addr);
28647c08596SBrooks Davis 			goto die;
2876964abefSBrian Somers 		}
2886964abefSBrian Somers 		break;
28947c08596SBrooks Davis 	case RTM_IFINFO:
29047c08596SBrooks Davis 		ifm = (struct if_msghdr *)rtm;
29147c08596SBrooks Davis 		if (ifm->ifm_index != ifi->index)
29247c08596SBrooks Davis 			break;
2936964abefSBrian Somers 		if ((rtm->rtm_flags & RTF_UP) == 0) {
2946964abefSBrian Somers 			warning("Interface %s is down, dhclient exiting",
2956964abefSBrian Somers 			    ifi->name);
29647c08596SBrooks Davis 			goto die;
2976964abefSBrian Somers 		}
2980a26f858SJohn Baldwin 		linkstat = interface_link_status(ifi->name);
2990a26f858SJohn Baldwin 		if (linkstat != ifi->linkstat) {
3000a26f858SJohn Baldwin 			debug("%s link state %s -> %s", ifi->name,
3010a26f858SJohn Baldwin 			    ifi->linkstat ? "up" : "down",
3020a26f858SJohn Baldwin 			    linkstat ? "up" : "down");
3030a26f858SJohn Baldwin 			ifi->linkstat = linkstat;
3040a26f858SJohn Baldwin 			if (linkstat)
3050a26f858SJohn Baldwin 				state_reboot(ifi);
30683f745b8SJohn Baldwin 		}
30747c08596SBrooks Davis 		break;
30847c08596SBrooks Davis 	case RTM_IFANNOUNCE:
30947c08596SBrooks Davis 		ifan = (struct if_announcemsghdr *)rtm;
31047c08596SBrooks Davis 		if (ifan->ifan_what == IFAN_DEPARTURE &&
3116964abefSBrian Somers 		    ifan->ifan_index == ifi->index) {
3126964abefSBrian Somers 			warning("Interface %s is gone, dhclient exiting",
3136964abefSBrian Somers 			    ifi->name);
31447c08596SBrooks Davis 			goto die;
3156964abefSBrian Somers 		}
31647c08596SBrooks Davis 		break;
3172b19b6fcSBrooks Davis 	case RTM_IEEE80211:
3182b19b6fcSBrooks Davis 		ifan = (struct if_announcemsghdr *)rtm;
3192b19b6fcSBrooks Davis 		if (ifan->ifan_index != ifi->index)
3202b19b6fcSBrooks Davis 			break;
3212b19b6fcSBrooks Davis 		switch (ifan->ifan_what) {
3222b19b6fcSBrooks Davis 		case RTM_IEEE80211_ASSOC:
323b35f2511SSam Leffler 		case RTM_IEEE80211_REASSOC:
3242b19b6fcSBrooks Davis 			/*
32561063e47SSam Leffler 			 * Use assoc/reassoc event to kick state machine
32661063e47SSam Leffler 			 * in case we roam.  Otherwise fall back to the
32761063e47SSam Leffler 			 * normal state machine just like a wired network.
3282b19b6fcSBrooks Davis 			 */
32961063e47SSam Leffler 			jev = (struct ieee80211_join_event *) &ifan[1];
33061063e47SSam Leffler 			if (memcmp(curbssid, jev->iev_addr, 6)) {
33161063e47SSam Leffler 				disassoc(ifi);
33261063e47SSam Leffler 				state_reboot(ifi);
33359eac186SBrooks Davis 			}
33461063e47SSam Leffler 			memcpy(curbssid, jev->iev_addr, 6);
3352b19b6fcSBrooks Davis 			break;
3362b19b6fcSBrooks Davis 		}
3372b19b6fcSBrooks Davis 		break;
33847c08596SBrooks Davis 	default:
33947c08596SBrooks Davis 		break;
34047c08596SBrooks Davis 	}
34147c08596SBrooks Davis 	return;
34247c08596SBrooks Davis 
34347c08596SBrooks Davis die:
34447c08596SBrooks Davis 	script_init("FAIL", NULL);
34547c08596SBrooks Davis 	if (ifi->client->alias)
34647c08596SBrooks Davis 		script_write_params("alias_", ifi->client->alias);
34747c08596SBrooks Davis 	script_go();
34823f39c90SDag-Erling Smørgrav 	if (pidfile != NULL)
34923f39c90SDag-Erling Smørgrav 		pidfile_remove(pidfile);
35047c08596SBrooks Davis 	exit(1);
35147c08596SBrooks Davis }
35247c08596SBrooks Davis 
353cb003dd9SMariusz Zaborski static void
354cb003dd9SMariusz Zaborski init_casper(void)
355cb003dd9SMariusz Zaborski {
356cb003dd9SMariusz Zaborski 	cap_channel_t		*casper;
357cb003dd9SMariusz Zaborski 
358cb003dd9SMariusz Zaborski 	casper = cap_init();
359cb003dd9SMariusz Zaborski 	if (casper == NULL)
360cb003dd9SMariusz Zaborski 		error("unable to start casper");
361cb003dd9SMariusz Zaborski 
362cb003dd9SMariusz Zaborski 	capsyslog = cap_service_open(casper, "system.syslog");
363cb003dd9SMariusz Zaborski 	cap_close(casper);
364cb003dd9SMariusz Zaborski 	if (capsyslog == NULL)
365cb003dd9SMariusz Zaborski 		error("unable to open system.syslog service");
366cb003dd9SMariusz Zaborski }
367cb003dd9SMariusz Zaborski 
36847c08596SBrooks Davis int
36947c08596SBrooks Davis main(int argc, char *argv[])
37047c08596SBrooks Davis {
37147c08596SBrooks Davis 	extern char		*__progname;
37247c08596SBrooks Davis 	int			 ch, fd, quiet = 0, i = 0;
37347c08596SBrooks Davis 	int			 pipe_fd[2];
3742b19b6fcSBrooks Davis 	int			 immediate_daemon = 0;
37547c08596SBrooks Davis 	struct passwd		*pw;
37623f39c90SDag-Erling Smørgrav 	pid_t			 otherpid;
3777008be5bSPawel Jakub Dawidek 	cap_rights_t		 rights;
37847c08596SBrooks Davis 
379cb003dd9SMariusz Zaborski 	init_casper();
380cb003dd9SMariusz Zaborski 
38147c08596SBrooks Davis 	/* Initially, log errors to stderr as well as to syslogd. */
382cb003dd9SMariusz Zaborski 	cap_openlog(capsyslog, __progname, LOG_PID | LOG_NDELAY, DHCPD_LOG_FACILITY);
383cb003dd9SMariusz Zaborski 	cap_setlogmask(capsyslog, LOG_UPTO(LOG_DEBUG));
38447c08596SBrooks Davis 
38523f39c90SDag-Erling Smørgrav 	while ((ch = getopt(argc, argv, "bc:dl:p:qu")) != -1)
38647c08596SBrooks Davis 		switch (ch) {
3872b19b6fcSBrooks Davis 		case 'b':
3882b19b6fcSBrooks Davis 			immediate_daemon = 1;
3892b19b6fcSBrooks Davis 			break;
39047c08596SBrooks Davis 		case 'c':
39147c08596SBrooks Davis 			path_dhclient_conf = optarg;
39247c08596SBrooks Davis 			break;
39347c08596SBrooks Davis 		case 'd':
39447c08596SBrooks Davis 			no_daemon = 1;
39547c08596SBrooks Davis 			break;
39647c08596SBrooks Davis 		case 'l':
39747c08596SBrooks Davis 			path_dhclient_db = optarg;
39847c08596SBrooks Davis 			break;
39923f39c90SDag-Erling Smørgrav 		case 'p':
40023f39c90SDag-Erling Smørgrav 			path_dhclient_pidfile = optarg;
40123f39c90SDag-Erling Smørgrav 			break;
40247c08596SBrooks Davis 		case 'q':
40347c08596SBrooks Davis 			quiet = 1;
40447c08596SBrooks Davis 			break;
40547c08596SBrooks Davis 		case 'u':
40647c08596SBrooks Davis 			unknown_ok = 0;
40747c08596SBrooks Davis 			break;
40847c08596SBrooks Davis 		default:
40947c08596SBrooks Davis 			usage();
41047c08596SBrooks Davis 		}
41147c08596SBrooks Davis 
41247c08596SBrooks Davis 	argc -= optind;
41347c08596SBrooks Davis 	argv += optind;
41447c08596SBrooks Davis 
41547c08596SBrooks Davis 	if (argc != 1)
41647c08596SBrooks Davis 		usage();
41747c08596SBrooks Davis 
41823f39c90SDag-Erling Smørgrav 	if (path_dhclient_pidfile == NULL) {
41923f39c90SDag-Erling Smørgrav 		asprintf(&path_dhclient_pidfile,
42023f39c90SDag-Erling Smørgrav 		    "%sdhclient.%s.pid", _PATH_VARRUN, *argv);
42123f39c90SDag-Erling Smørgrav 		if (path_dhclient_pidfile == NULL)
42223f39c90SDag-Erling Smørgrav 			error("asprintf");
42323f39c90SDag-Erling Smørgrav 	}
42407561ab4SEitan Adler 	pidfile = pidfile_open(path_dhclient_pidfile, 0644, &otherpid);
42523f39c90SDag-Erling Smørgrav 	if (pidfile == NULL) {
42623f39c90SDag-Erling Smørgrav 		if (errno == EEXIST)
42723f39c90SDag-Erling Smørgrav 			error("dhclient already running, pid: %d.", otherpid);
42823f39c90SDag-Erling Smørgrav 		if (errno == EAGAIN)
42923f39c90SDag-Erling Smørgrav 			error("dhclient already running.");
43023f39c90SDag-Erling Smørgrav 		warning("Cannot open or create pidfile: %m");
43123f39c90SDag-Erling Smørgrav 	}
43223f39c90SDag-Erling Smørgrav 
43347c08596SBrooks Davis 	if ((ifi = calloc(1, sizeof(struct interface_info))) == NULL)
43447c08596SBrooks Davis 		error("calloc");
43547c08596SBrooks Davis 	if (strlcpy(ifi->name, argv[0], IFNAMSIZ) >= IFNAMSIZ)
43647c08596SBrooks Davis 		error("Interface name too long");
43747c08596SBrooks Davis 	if (path_dhclient_db == NULL && asprintf(&path_dhclient_db, "%s.%s",
43847c08596SBrooks Davis 	    _PATH_DHCLIENT_DB, ifi->name) == -1)
43947c08596SBrooks Davis 		error("asprintf");
44047c08596SBrooks Davis 
44147c08596SBrooks Davis 	if (quiet)
44247c08596SBrooks Davis 		log_perror = 0;
44347c08596SBrooks Davis 
44447c08596SBrooks Davis 	tzset();
44547c08596SBrooks Davis 	time(&cur_time);
44647c08596SBrooks Davis 
447ba019ae5SPawel Jakub Dawidek 	inaddr_broadcast.s_addr = INADDR_BROADCAST;
44847c08596SBrooks Davis 	inaddr_any.s_addr = INADDR_ANY;
44947c08596SBrooks Davis 
45047c08596SBrooks Davis 	read_client_conf();
45147c08596SBrooks Davis 
45223f39c90SDag-Erling Smørgrav 	/* The next bit is potentially very time-consuming, so write out
45323f39c90SDag-Erling Smørgrav 	   the pidfile right away.  We will write it out again with the
45423f39c90SDag-Erling Smørgrav 	   correct pid after daemonizing. */
45523f39c90SDag-Erling Smørgrav 	if (pidfile != NULL)
45623f39c90SDag-Erling Smørgrav 		pidfile_write(pidfile);
45723f39c90SDag-Erling Smørgrav 
45847c08596SBrooks Davis 	if (!interface_link_status(ifi->name)) {
45947c08596SBrooks Davis 		fprintf(stderr, "%s: no link ...", ifi->name);
46047c08596SBrooks Davis 		fflush(stderr);
46147c08596SBrooks Davis 		sleep(1);
46247c08596SBrooks Davis 		while (!interface_link_status(ifi->name)) {
46347c08596SBrooks Davis 			fprintf(stderr, ".");
46447c08596SBrooks Davis 			fflush(stderr);
46547c08596SBrooks Davis 			if (++i > 10) {
46647c08596SBrooks Davis 				fprintf(stderr, " giving up\n");
46747c08596SBrooks Davis 				exit(1);
46847c08596SBrooks Davis 			}
46947c08596SBrooks Davis 			sleep(1);
47047c08596SBrooks Davis 		}
47147c08596SBrooks Davis 		fprintf(stderr, " got link\n");
47247c08596SBrooks Davis 	}
4730a26f858SJohn Baldwin 	ifi->linkstat = 1;
47447c08596SBrooks Davis 
47547c08596SBrooks Davis 	if ((nullfd = open(_PATH_DEVNULL, O_RDWR, 0)) == -1)
47647c08596SBrooks Davis 		error("cannot open %s: %m", _PATH_DEVNULL);
47747c08596SBrooks Davis 
47847c08596SBrooks Davis 	if ((pw = getpwnam("_dhcp")) == NULL) {
47947c08596SBrooks Davis 		warning("no such user: _dhcp, falling back to \"nobody\"");
48047c08596SBrooks Davis 		if ((pw = getpwnam("nobody")) == NULL)
48147c08596SBrooks Davis 			error("no such user: nobody");
48247c08596SBrooks Davis 	}
48347c08596SBrooks Davis 
4840bbe8306SPawel Jakub Dawidek 	/*
4850bbe8306SPawel Jakub Dawidek 	 * Obtain hostname before entering capability mode - it won't be
4860bbe8306SPawel Jakub Dawidek 	 * possible then, as reading kern.hostname is not permitted.
4870bbe8306SPawel Jakub Dawidek 	 */
4880bbe8306SPawel Jakub Dawidek 	if (gethostname(hostname, sizeof(hostname)) < 0)
4890bbe8306SPawel Jakub Dawidek 		hostname[0] = '\0';
4900bbe8306SPawel Jakub Dawidek 
491374a8a32SPawel Jakub Dawidek 	priv_script_init("PREINIT", NULL);
492374a8a32SPawel Jakub Dawidek 	if (ifi->client->alias)
493374a8a32SPawel Jakub Dawidek 		priv_script_write_params("alias_", ifi->client->alias);
494374a8a32SPawel Jakub Dawidek 	priv_script_go();
495374a8a32SPawel Jakub Dawidek 
496235eb530SPawel Jakub Dawidek 	/* set up the interface */
497235eb530SPawel Jakub Dawidek 	discover_interfaces(ifi);
498235eb530SPawel Jakub Dawidek 
49947c08596SBrooks Davis 	if (pipe(pipe_fd) == -1)
50047c08596SBrooks Davis 		error("pipe");
50147c08596SBrooks Davis 
50247c08596SBrooks Davis 	fork_privchld(pipe_fd[0], pipe_fd[1]);
50347c08596SBrooks Davis 
504235eb530SPawel Jakub Dawidek 	close(ifi->ufdesc);
505235eb530SPawel Jakub Dawidek 	ifi->ufdesc = -1;
506235eb530SPawel Jakub Dawidek 	close(ifi->wfdesc);
507235eb530SPawel Jakub Dawidek 	ifi->wfdesc = -1;
508235eb530SPawel Jakub Dawidek 
50947c08596SBrooks Davis 	close(pipe_fd[0]);
51047c08596SBrooks Davis 	privfd = pipe_fd[1];
5117008be5bSPawel Jakub Dawidek 	cap_rights_init(&rights, CAP_READ, CAP_WRITE);
5127008be5bSPawel Jakub Dawidek 	if (cap_rights_limit(privfd, &rights) < 0 && errno != ENOSYS)
513de2c882fSPawel Jakub Dawidek 		error("can't limit private descriptor: %m");
51447c08596SBrooks Davis 
51547c08596SBrooks Davis 	if ((fd = open(path_dhclient_db, O_RDONLY|O_EXLOCK|O_CREAT, 0)) == -1)
51647c08596SBrooks Davis 		error("can't open and lock %s: %m", path_dhclient_db);
51747c08596SBrooks Davis 	read_client_leases();
51847c08596SBrooks Davis 	rewrite_client_leases();
51947c08596SBrooks Davis 	close(fd);
52047c08596SBrooks Davis 
52147c08596SBrooks Davis 	if ((routefd = socket(PF_ROUTE, SOCK_RAW, 0)) != -1)
52247c08596SBrooks Davis 		add_protocol("AF_ROUTE", routefd, routehandler, ifi);
523e374cef5SPawel Jakub Dawidek 	if (shutdown(routefd, SHUT_WR) < 0)
524e374cef5SPawel Jakub Dawidek 		error("can't shutdown route socket: %m");
525bb7a82acSChristian Brueffer 	cap_rights_init(&rights, CAP_EVENT, CAP_READ);
5267008be5bSPawel Jakub Dawidek 	if (cap_rights_limit(routefd, &rights) < 0 && errno != ENOSYS)
527f73ac8b9SPawel Jakub Dawidek 		error("can't limit route socket: %m");
52847c08596SBrooks Davis 
52947c08596SBrooks Davis 	if (chroot(_PATH_VAREMPTY) == -1)
53047c08596SBrooks Davis 		error("chroot");
53147c08596SBrooks Davis 	if (chdir("/") == -1)
53247c08596SBrooks Davis 		error("chdir(\"/\")");
53347c08596SBrooks Davis 
53447c08596SBrooks Davis 	if (setgroups(1, &pw->pw_gid) ||
53547c08596SBrooks Davis 	    setegid(pw->pw_gid) || setgid(pw->pw_gid) ||
53647c08596SBrooks Davis 	    seteuid(pw->pw_uid) || setuid(pw->pw_uid))
53747c08596SBrooks Davis 		error("can't drop privileges: %m");
53847c08596SBrooks Davis 
53947c08596SBrooks Davis 	endpwent();
54047c08596SBrooks Davis 
54147c08596SBrooks Davis 	setproctitle("%s", ifi->name);
54247c08596SBrooks Davis 
543cb003dd9SMariusz Zaborski 	if (CASPER_SUPPORT && cap_enter() < 0 && errno != ENOSYS)
5448da93e68SPawel Jakub Dawidek 		error("can't enter capability mode: %m");
5458da93e68SPawel Jakub Dawidek 
5462b19b6fcSBrooks Davis 	if (immediate_daemon)
5472b19b6fcSBrooks Davis 		go_daemon();
5482b19b6fcSBrooks Davis 
54947c08596SBrooks Davis 	ifi->client->state = S_INIT;
55047c08596SBrooks Davis 	state_reboot(ifi);
55147c08596SBrooks Davis 
55247c08596SBrooks Davis 	bootp_packet_handler = do_packet;
55347c08596SBrooks Davis 
55447c08596SBrooks Davis 	dispatch();
55547c08596SBrooks Davis 
55647c08596SBrooks Davis 	/* not reached */
55747c08596SBrooks Davis 	return (0);
55847c08596SBrooks Davis }
55947c08596SBrooks Davis 
56047c08596SBrooks Davis void
56147c08596SBrooks Davis usage(void)
56247c08596SBrooks Davis {
56347c08596SBrooks Davis 	extern char	*__progname;
56447c08596SBrooks Davis 
5653dd3357aSBrian Somers 	fprintf(stderr, "usage: %s [-bdqu] ", __progname);
56647c08596SBrooks Davis 	fprintf(stderr, "[-c conffile] [-l leasefile] interface\n");
56747c08596SBrooks Davis 	exit(1);
56847c08596SBrooks Davis }
56947c08596SBrooks Davis 
57047c08596SBrooks Davis /*
57147c08596SBrooks Davis  * Individual States:
57247c08596SBrooks Davis  *
57347c08596SBrooks Davis  * Each routine is called from the dhclient_state_machine() in one of
57447c08596SBrooks Davis  * these conditions:
57547c08596SBrooks Davis  * -> entering INIT state
57647c08596SBrooks Davis  * -> recvpacket_flag == 0: timeout in this state
57747c08596SBrooks Davis  * -> otherwise: received a packet in this state
57847c08596SBrooks Davis  *
57947c08596SBrooks Davis  * Return conditions as handled by dhclient_state_machine():
58047c08596SBrooks Davis  * Returns 1, sendpacket_flag = 1: send packet, reset timer.
58147c08596SBrooks Davis  * Returns 1, sendpacket_flag = 0: just reset the timer (wait for a milestone).
58247c08596SBrooks Davis  * Returns 0: finish the nap which was interrupted for no good reason.
58347c08596SBrooks Davis  *
58447c08596SBrooks Davis  * Several per-interface variables are used to keep track of the process:
58547c08596SBrooks Davis  *   active_lease: the lease that is being used on the interface
58647c08596SBrooks Davis  *                 (null pointer if not configured yet).
58747c08596SBrooks Davis  *   offered_leases: leases corresponding to DHCPOFFER messages that have
58847c08596SBrooks Davis  *                   been sent to us by DHCP servers.
58947c08596SBrooks Davis  *   acked_leases: leases corresponding to DHCPACK messages that have been
59047c08596SBrooks Davis  *                 sent to us by DHCP servers.
59147c08596SBrooks Davis  *   sendpacket: DHCP packet we're trying to send.
59247c08596SBrooks Davis  *   destination: IP address to send sendpacket to
59347c08596SBrooks Davis  * In addition, there are several relevant per-lease variables.
59447c08596SBrooks Davis  *   T1_expiry, T2_expiry, lease_expiry: lease milestones
59547c08596SBrooks Davis  * In the active lease, these control the process of renewing the lease;
59647c08596SBrooks Davis  * In leases on the acked_leases list, this simply determines when we
59747c08596SBrooks Davis  * can no longer legitimately use the lease.
59847c08596SBrooks Davis  */
59947c08596SBrooks Davis 
60047c08596SBrooks Davis void
60147c08596SBrooks Davis state_reboot(void *ipp)
60247c08596SBrooks Davis {
60347c08596SBrooks Davis 	struct interface_info *ip = ipp;
60447c08596SBrooks Davis 
60547c08596SBrooks Davis 	/* If we don't remember an active lease, go straight to INIT. */
60647c08596SBrooks Davis 	if (!ip->client->active || ip->client->active->is_bootp) {
60747c08596SBrooks Davis 		state_init(ip);
60847c08596SBrooks Davis 		return;
60947c08596SBrooks Davis 	}
61047c08596SBrooks Davis 
61147c08596SBrooks Davis 	/* We are in the rebooting state. */
61247c08596SBrooks Davis 	ip->client->state = S_REBOOTING;
61347c08596SBrooks Davis 
61447c08596SBrooks Davis 	/* make_request doesn't initialize xid because it normally comes
61547c08596SBrooks Davis 	   from the DHCPDISCOVER, but we haven't sent a DHCPDISCOVER,
61647c08596SBrooks Davis 	   so pick an xid now. */
61747c08596SBrooks Davis 	ip->client->xid = arc4random();
61847c08596SBrooks Davis 
61947c08596SBrooks Davis 	/* Make a DHCPREQUEST packet, and set appropriate per-interface
62047c08596SBrooks Davis 	   flags. */
62147c08596SBrooks Davis 	make_request(ip, ip->client->active);
62247c08596SBrooks Davis 	ip->client->destination = iaddr_broadcast;
62347c08596SBrooks Davis 	ip->client->first_sending = cur_time;
62447c08596SBrooks Davis 	ip->client->interval = ip->client->config->initial_interval;
62547c08596SBrooks Davis 
62647c08596SBrooks Davis 	/* Zap the medium list... */
62747c08596SBrooks Davis 	ip->client->medium = NULL;
62847c08596SBrooks Davis 
62947c08596SBrooks Davis 	/* Send out the first DHCPREQUEST packet. */
63047c08596SBrooks Davis 	send_request(ip);
63147c08596SBrooks Davis }
63247c08596SBrooks Davis 
63347c08596SBrooks Davis /*
63447c08596SBrooks Davis  * Called when a lease has completely expired and we've
63547c08596SBrooks Davis  * been unable to renew it.
63647c08596SBrooks Davis  */
63747c08596SBrooks Davis void
63847c08596SBrooks Davis state_init(void *ipp)
63947c08596SBrooks Davis {
64047c08596SBrooks Davis 	struct interface_info *ip = ipp;
64147c08596SBrooks Davis 
64247c08596SBrooks Davis 	ASSERT_STATE(state, S_INIT);
64347c08596SBrooks Davis 
64447c08596SBrooks Davis 	/* Make a DHCPDISCOVER packet, and set appropriate per-interface
64547c08596SBrooks Davis 	   flags. */
64647c08596SBrooks Davis 	make_discover(ip, ip->client->active);
64747c08596SBrooks Davis 	ip->client->xid = ip->client->packet.xid;
64847c08596SBrooks Davis 	ip->client->destination = iaddr_broadcast;
64947c08596SBrooks Davis 	ip->client->state = S_SELECTING;
65047c08596SBrooks Davis 	ip->client->first_sending = cur_time;
65147c08596SBrooks Davis 	ip->client->interval = ip->client->config->initial_interval;
65247c08596SBrooks Davis 
65347c08596SBrooks Davis 	/* Add an immediate timeout to cause the first DHCPDISCOVER packet
65447c08596SBrooks Davis 	   to go out. */
65547c08596SBrooks Davis 	send_discover(ip);
65647c08596SBrooks Davis }
65747c08596SBrooks Davis 
65847c08596SBrooks Davis /*
65947c08596SBrooks Davis  * state_selecting is called when one or more DHCPOFFER packets
66047c08596SBrooks Davis  * have been received and a configurable period of time has passed.
66147c08596SBrooks Davis  */
66247c08596SBrooks Davis void
66347c08596SBrooks Davis state_selecting(void *ipp)
66447c08596SBrooks Davis {
66547c08596SBrooks Davis 	struct interface_info *ip = ipp;
66647c08596SBrooks Davis 	struct client_lease *lp, *next, *picked;
66747c08596SBrooks Davis 
66847c08596SBrooks Davis 	ASSERT_STATE(state, S_SELECTING);
66947c08596SBrooks Davis 
67047c08596SBrooks Davis 	/* Cancel state_selecting and send_discover timeouts, since either
67147c08596SBrooks Davis 	   one could have got us here. */
67247c08596SBrooks Davis 	cancel_timeout(state_selecting, ip);
67347c08596SBrooks Davis 	cancel_timeout(send_discover, ip);
67447c08596SBrooks Davis 
67547c08596SBrooks Davis 	/* We have received one or more DHCPOFFER packets.   Currently,
67647c08596SBrooks Davis 	   the only criterion by which we judge leases is whether or
67747c08596SBrooks Davis 	   not we get a response when we arp for them. */
67847c08596SBrooks Davis 	picked = NULL;
67947c08596SBrooks Davis 	for (lp = ip->client->offered_leases; lp; lp = next) {
68047c08596SBrooks Davis 		next = lp->next;
68147c08596SBrooks Davis 
68247c08596SBrooks Davis 		/* Check to see if we got an ARPREPLY for the address
68347c08596SBrooks Davis 		   in this particular lease. */
68447c08596SBrooks Davis 		if (!picked) {
68547c08596SBrooks Davis 			script_init("ARPCHECK", lp->medium);
68647c08596SBrooks Davis 			script_write_params("check_", lp);
68747c08596SBrooks Davis 
68847c08596SBrooks Davis 			/* If the ARPCHECK code detects another
68947c08596SBrooks Davis 			   machine using the offered address, it exits
69047c08596SBrooks Davis 			   nonzero.  We need to send a DHCPDECLINE and
69147c08596SBrooks Davis 			   toss the lease. */
69247c08596SBrooks Davis 			if (script_go()) {
69347c08596SBrooks Davis 				make_decline(ip, lp);
69447c08596SBrooks Davis 				send_decline(ip);
69547c08596SBrooks Davis 				goto freeit;
69647c08596SBrooks Davis 			}
69747c08596SBrooks Davis 			picked = lp;
69847c08596SBrooks Davis 			picked->next = NULL;
69947c08596SBrooks Davis 		} else {
70047c08596SBrooks Davis freeit:
70147c08596SBrooks Davis 			free_client_lease(lp);
70247c08596SBrooks Davis 		}
70347c08596SBrooks Davis 	}
70447c08596SBrooks Davis 	ip->client->offered_leases = NULL;
70547c08596SBrooks Davis 
70647c08596SBrooks Davis 	/* If we just tossed all the leases we were offered, go back
70747c08596SBrooks Davis 	   to square one. */
70847c08596SBrooks Davis 	if (!picked) {
70947c08596SBrooks Davis 		ip->client->state = S_INIT;
71047c08596SBrooks Davis 		state_init(ip);
71147c08596SBrooks Davis 		return;
71247c08596SBrooks Davis 	}
71347c08596SBrooks Davis 
71447c08596SBrooks Davis 	/* If it was a BOOTREPLY, we can just take the address right now. */
71547c08596SBrooks Davis 	if (!picked->options[DHO_DHCP_MESSAGE_TYPE].len) {
71647c08596SBrooks Davis 		ip->client->new = picked;
71747c08596SBrooks Davis 
71847c08596SBrooks Davis 		/* Make up some lease expiry times
71947c08596SBrooks Davis 		   XXX these should be configurable. */
72047c08596SBrooks Davis 		ip->client->new->expiry = cur_time + 12000;
72147c08596SBrooks Davis 		ip->client->new->renewal += cur_time + 8000;
72247c08596SBrooks Davis 		ip->client->new->rebind += cur_time + 10000;
72347c08596SBrooks Davis 
72447c08596SBrooks Davis 		ip->client->state = S_REQUESTING;
72547c08596SBrooks Davis 
72647c08596SBrooks Davis 		/* Bind to the address we received. */
72747c08596SBrooks Davis 		bind_lease(ip);
72847c08596SBrooks Davis 		return;
72947c08596SBrooks Davis 	}
73047c08596SBrooks Davis 
73147c08596SBrooks Davis 	/* Go to the REQUESTING state. */
73247c08596SBrooks Davis 	ip->client->destination = iaddr_broadcast;
73347c08596SBrooks Davis 	ip->client->state = S_REQUESTING;
73447c08596SBrooks Davis 	ip->client->first_sending = cur_time;
73547c08596SBrooks Davis 	ip->client->interval = ip->client->config->initial_interval;
73647c08596SBrooks Davis 
73747c08596SBrooks Davis 	/* Make a DHCPREQUEST packet from the lease we picked. */
73847c08596SBrooks Davis 	make_request(ip, picked);
73947c08596SBrooks Davis 	ip->client->xid = ip->client->packet.xid;
74047c08596SBrooks Davis 
74147c08596SBrooks Davis 	/* Toss the lease we picked - we'll get it back in a DHCPACK. */
74247c08596SBrooks Davis 	free_client_lease(picked);
74347c08596SBrooks Davis 
74447c08596SBrooks Davis 	/* Add an immediate timeout to send the first DHCPREQUEST packet. */
74547c08596SBrooks Davis 	send_request(ip);
74647c08596SBrooks Davis }
74747c08596SBrooks Davis 
74847c08596SBrooks Davis /* state_requesting is called when we receive a DHCPACK message after
74947c08596SBrooks Davis    having sent out one or more DHCPREQUEST packets. */
75047c08596SBrooks Davis 
75147c08596SBrooks Davis void
75247c08596SBrooks Davis dhcpack(struct packet *packet)
75347c08596SBrooks Davis {
75447c08596SBrooks Davis 	struct interface_info *ip = packet->interface;
75547c08596SBrooks Davis 	struct client_lease *lease;
75647c08596SBrooks Davis 
75747c08596SBrooks Davis 	/* If we're not receptive to an offer right now, or if the offer
75847c08596SBrooks Davis 	   has an unrecognizable transaction id, then just drop it. */
75947c08596SBrooks Davis 	if (packet->interface->client->xid != packet->raw->xid ||
76047c08596SBrooks Davis 	    (packet->interface->hw_address.hlen != packet->raw->hlen) ||
76147c08596SBrooks Davis 	    (memcmp(packet->interface->hw_address.haddr,
76247c08596SBrooks Davis 	    packet->raw->chaddr, packet->raw->hlen)))
76347c08596SBrooks Davis 		return;
76447c08596SBrooks Davis 
76547c08596SBrooks Davis 	if (ip->client->state != S_REBOOTING &&
76647c08596SBrooks Davis 	    ip->client->state != S_REQUESTING &&
76747c08596SBrooks Davis 	    ip->client->state != S_RENEWING &&
76847c08596SBrooks Davis 	    ip->client->state != S_REBINDING)
76947c08596SBrooks Davis 		return;
77047c08596SBrooks Davis 
77147c08596SBrooks Davis 	note("DHCPACK from %s", piaddr(packet->client_addr));
77247c08596SBrooks Davis 
77347c08596SBrooks Davis 	lease = packet_to_lease(packet);
77447c08596SBrooks Davis 	if (!lease) {
77547c08596SBrooks Davis 		note("packet_to_lease failed.");
77647c08596SBrooks Davis 		return;
77747c08596SBrooks Davis 	}
77847c08596SBrooks Davis 
77947c08596SBrooks Davis 	ip->client->new = lease;
78047c08596SBrooks Davis 
78147c08596SBrooks Davis 	/* Stop resending DHCPREQUEST. */
78247c08596SBrooks Davis 	cancel_timeout(send_request, ip);
78347c08596SBrooks Davis 
78447c08596SBrooks Davis 	/* Figure out the lease time. */
7851fb4382cSNick Hibma         if (ip->client->config->default_actions[DHO_DHCP_LEASE_TIME] ==
7861fb4382cSNick Hibma             ACTION_SUPERSEDE)
7871fb4382cSNick Hibma 		ip->client->new->expiry = getULong(
7881fb4382cSNick Hibma 		    ip->client->config->defaults[DHO_DHCP_LEASE_TIME].data);
7891fb4382cSNick Hibma         else if (ip->client->new->options[DHO_DHCP_LEASE_TIME].data)
79047c08596SBrooks Davis 		ip->client->new->expiry = getULong(
79147c08596SBrooks Davis 		    ip->client->new->options[DHO_DHCP_LEASE_TIME].data);
79247c08596SBrooks Davis 	else
79347c08596SBrooks Davis 		ip->client->new->expiry = default_lease_time;
79447c08596SBrooks Davis 	/* A number that looks negative here is really just very large,
795223c44aeSNick Hibma 	   because the lease expiry offset is unsigned. Also make sure that
796223c44aeSNick Hibma            the addition of cur_time below does not overflow (a 32 bit) time_t. */
797223c44aeSNick Hibma 	if (ip->client->new->expiry < 0 ||
798223c44aeSNick Hibma             ip->client->new->expiry > TIME_MAX - cur_time)
799223c44aeSNick Hibma 		ip->client->new->expiry = TIME_MAX - cur_time;
80047c08596SBrooks Davis 	/* XXX should be fixed by resetting the client state */
80147c08596SBrooks Davis 	if (ip->client->new->expiry < 60)
80247c08596SBrooks Davis 		ip->client->new->expiry = 60;
80347c08596SBrooks Davis 
804c13fa60cSNick Hibma         /* Unless overridden in the config, take the server-provided renewal
805223c44aeSNick Hibma          * time if there is one. Otherwise figure it out according to the spec.
806c13fa60cSNick Hibma          * Also make sure the renewal time does not exceed the expiry time.
807c13fa60cSNick Hibma          */
808c13fa60cSNick Hibma         if (ip->client->config->default_actions[DHO_DHCP_RENEWAL_TIME] ==
809c13fa60cSNick Hibma             ACTION_SUPERSEDE)
810c13fa60cSNick Hibma 		ip->client->new->renewal = getULong(
811c13fa60cSNick Hibma 		    ip->client->config->defaults[DHO_DHCP_RENEWAL_TIME].data);
812c13fa60cSNick Hibma         else if (ip->client->new->options[DHO_DHCP_RENEWAL_TIME].len)
81347c08596SBrooks Davis 		ip->client->new->renewal = getULong(
81447c08596SBrooks Davis 		    ip->client->new->options[DHO_DHCP_RENEWAL_TIME].data);
81547c08596SBrooks Davis 	else
81647c08596SBrooks Davis 		ip->client->new->renewal = ip->client->new->expiry / 2;
817223c44aeSNick Hibma         if (ip->client->new->renewal < 0 ||
818223c44aeSNick Hibma             ip->client->new->renewal > ip->client->new->expiry / 2)
819c13fa60cSNick Hibma                 ip->client->new->renewal = ip->client->new->expiry / 2;
82047c08596SBrooks Davis 
82147c08596SBrooks Davis 	/* Same deal with the rebind time. */
822c13fa60cSNick Hibma         if (ip->client->config->default_actions[DHO_DHCP_REBINDING_TIME] ==
823c13fa60cSNick Hibma             ACTION_SUPERSEDE)
824c13fa60cSNick Hibma 		ip->client->new->rebind = getULong(
825c13fa60cSNick Hibma 		    ip->client->config->defaults[DHO_DHCP_REBINDING_TIME].data);
826c13fa60cSNick Hibma         else if (ip->client->new->options[DHO_DHCP_REBINDING_TIME].len)
82747c08596SBrooks Davis 		ip->client->new->rebind = getULong(
82847c08596SBrooks Davis 		    ip->client->new->options[DHO_DHCP_REBINDING_TIME].data);
82947c08596SBrooks Davis 	else
830223c44aeSNick Hibma 		ip->client->new->rebind = ip->client->new->renewal / 4 * 7;
831223c44aeSNick Hibma 	if (ip->client->new->rebind < 0 ||
832223c44aeSNick Hibma             ip->client->new->rebind > ip->client->new->renewal / 4 * 7)
833223c44aeSNick Hibma                 ip->client->new->rebind = ip->client->new->renewal / 4 * 7;
83447c08596SBrooks Davis 
835223c44aeSNick Hibma         /* Convert the time offsets into seconds-since-the-epoch */
83647c08596SBrooks Davis         ip->client->new->expiry += cur_time;
83747c08596SBrooks Davis         ip->client->new->renewal += cur_time;
83847c08596SBrooks Davis         ip->client->new->rebind += cur_time;
83947c08596SBrooks Davis 
84047c08596SBrooks Davis 	bind_lease(ip);
84147c08596SBrooks Davis }
84247c08596SBrooks Davis 
84347c08596SBrooks Davis void
84447c08596SBrooks Davis bind_lease(struct interface_info *ip)
84547c08596SBrooks Davis {
846387016a5SConrad Meyer 	struct option_data *opt;
847387016a5SConrad Meyer 
84847c08596SBrooks Davis 	/* Remember the medium. */
84947c08596SBrooks Davis 	ip->client->new->medium = ip->client->medium;
85047c08596SBrooks Davis 
851387016a5SConrad Meyer 	opt = &ip->client->new->options[DHO_INTERFACE_MTU];
852387016a5SConrad Meyer 	if (opt->len == sizeof(u_int16_t)) {
853387016a5SConrad Meyer 		u_int16_t mtu = be16dec(opt->data);
854387016a5SConrad Meyer 		if (mtu < MIN_MTU)
855387016a5SConrad Meyer 			warning("mtu size %u < %d: ignored", (unsigned)mtu, MIN_MTU);
856387016a5SConrad Meyer 		else
857387016a5SConrad Meyer 			interface_set_mtu_unpriv(privfd, mtu);
858387016a5SConrad Meyer 	}
859387016a5SConrad Meyer 
86047c08596SBrooks Davis 	/* Write out the new lease. */
86147c08596SBrooks Davis 	write_client_lease(ip, ip->client->new, 0);
86247c08596SBrooks Davis 
86347c08596SBrooks Davis 	/* Run the client script with the new parameters. */
86447c08596SBrooks Davis 	script_init((ip->client->state == S_REQUESTING ? "BOUND" :
86547c08596SBrooks Davis 	    (ip->client->state == S_RENEWING ? "RENEW" :
86647c08596SBrooks Davis 	    (ip->client->state == S_REBOOTING ? "REBOOT" : "REBIND"))),
86747c08596SBrooks Davis 	    ip->client->new->medium);
86847c08596SBrooks Davis 	if (ip->client->active && ip->client->state != S_REBOOTING)
86947c08596SBrooks Davis 		script_write_params("old_", ip->client->active);
87047c08596SBrooks Davis 	script_write_params("new_", ip->client->new);
87147c08596SBrooks Davis 	if (ip->client->alias)
87247c08596SBrooks Davis 		script_write_params("alias_", ip->client->alias);
87347c08596SBrooks Davis 	script_go();
87447c08596SBrooks Davis 
87547c08596SBrooks Davis 	/* Replace the old active lease with the new one. */
87647c08596SBrooks Davis 	if (ip->client->active)
87747c08596SBrooks Davis 		free_client_lease(ip->client->active);
87847c08596SBrooks Davis 	ip->client->active = ip->client->new;
87947c08596SBrooks Davis 	ip->client->new = NULL;
88047c08596SBrooks Davis 
88147c08596SBrooks Davis 	/* Set up a timeout to start the renewal process. */
88247c08596SBrooks Davis 	add_timeout(ip->client->active->renewal, state_bound, ip);
88347c08596SBrooks Davis 
88447c08596SBrooks Davis 	note("bound to %s -- renewal in %d seconds.",
88547c08596SBrooks Davis 	    piaddr(ip->client->active->address),
8869c13d9cdSBrooks Davis 	    (int)(ip->client->active->renewal - cur_time));
88747c08596SBrooks Davis 	ip->client->state = S_BOUND;
88847c08596SBrooks Davis 	reinitialize_interfaces();
88947c08596SBrooks Davis 	go_daemon();
89047c08596SBrooks Davis }
89147c08596SBrooks Davis 
89247c08596SBrooks Davis /*
89347c08596SBrooks Davis  * state_bound is called when we've successfully bound to a particular
89447c08596SBrooks Davis  * lease, but the renewal time on that lease has expired.   We are
89547c08596SBrooks Davis  * expected to unicast a DHCPREQUEST to the server that gave us our
89647c08596SBrooks Davis  * original lease.
89747c08596SBrooks Davis  */
89847c08596SBrooks Davis void
89947c08596SBrooks Davis state_bound(void *ipp)
90047c08596SBrooks Davis {
90147c08596SBrooks Davis 	struct interface_info *ip = ipp;
90247c08596SBrooks Davis 
90347c08596SBrooks Davis 	ASSERT_STATE(state, S_BOUND);
90447c08596SBrooks Davis 
90547c08596SBrooks Davis 	/* T1 has expired. */
90647c08596SBrooks Davis 	make_request(ip, ip->client->active);
90747c08596SBrooks Davis 	ip->client->xid = ip->client->packet.xid;
90847c08596SBrooks Davis 
90947c08596SBrooks Davis 	if (ip->client->active->options[DHO_DHCP_SERVER_IDENTIFIER].len == 4) {
91047c08596SBrooks Davis 		memcpy(ip->client->destination.iabuf, ip->client->active->
91147c08596SBrooks Davis 		    options[DHO_DHCP_SERVER_IDENTIFIER].data, 4);
91247c08596SBrooks Davis 		ip->client->destination.len = 4;
91347c08596SBrooks Davis 	} else
91447c08596SBrooks Davis 		ip->client->destination = iaddr_broadcast;
91547c08596SBrooks Davis 
91647c08596SBrooks Davis 	ip->client->first_sending = cur_time;
91747c08596SBrooks Davis 	ip->client->interval = ip->client->config->initial_interval;
91847c08596SBrooks Davis 	ip->client->state = S_RENEWING;
91947c08596SBrooks Davis 
92047c08596SBrooks Davis 	/* Send the first packet immediately. */
92147c08596SBrooks Davis 	send_request(ip);
92247c08596SBrooks Davis }
92347c08596SBrooks Davis 
92447c08596SBrooks Davis void
92547c08596SBrooks Davis bootp(struct packet *packet)
92647c08596SBrooks Davis {
92747c08596SBrooks Davis 	struct iaddrlist *ap;
92847c08596SBrooks Davis 
92947c08596SBrooks Davis 	if (packet->raw->op != BOOTREPLY)
93047c08596SBrooks Davis 		return;
93147c08596SBrooks Davis 
93247c08596SBrooks Davis 	/* If there's a reject list, make sure this packet's sender isn't
93347c08596SBrooks Davis 	   on it. */
93447c08596SBrooks Davis 	for (ap = packet->interface->client->config->reject_list;
93547c08596SBrooks Davis 	    ap; ap = ap->next) {
93647c08596SBrooks Davis 		if (addr_eq(packet->client_addr, ap->addr)) {
93747c08596SBrooks Davis 			note("BOOTREPLY from %s rejected.", piaddr(ap->addr));
93847c08596SBrooks Davis 			return;
93947c08596SBrooks Davis 		}
94047c08596SBrooks Davis 	}
94147c08596SBrooks Davis 	dhcpoffer(packet);
94247c08596SBrooks Davis }
94347c08596SBrooks Davis 
94447c08596SBrooks Davis void
94547c08596SBrooks Davis dhcp(struct packet *packet)
94647c08596SBrooks Davis {
94747c08596SBrooks Davis 	struct iaddrlist *ap;
94847c08596SBrooks Davis 	void (*handler)(struct packet *);
94947c08596SBrooks Davis 	char *type;
95047c08596SBrooks Davis 
95147c08596SBrooks Davis 	switch (packet->packet_type) {
95247c08596SBrooks Davis 	case DHCPOFFER:
95347c08596SBrooks Davis 		handler = dhcpoffer;
95447c08596SBrooks Davis 		type = "DHCPOFFER";
95547c08596SBrooks Davis 		break;
95647c08596SBrooks Davis 	case DHCPNAK:
95747c08596SBrooks Davis 		handler = dhcpnak;
95847c08596SBrooks Davis 		type = "DHCPNACK";
95947c08596SBrooks Davis 		break;
96047c08596SBrooks Davis 	case DHCPACK:
96147c08596SBrooks Davis 		handler = dhcpack;
96247c08596SBrooks Davis 		type = "DHCPACK";
96347c08596SBrooks Davis 		break;
96447c08596SBrooks Davis 	default:
96547c08596SBrooks Davis 		return;
96647c08596SBrooks Davis 	}
96747c08596SBrooks Davis 
96847c08596SBrooks Davis 	/* If there's a reject list, make sure this packet's sender isn't
96947c08596SBrooks Davis 	   on it. */
97047c08596SBrooks Davis 	for (ap = packet->interface->client->config->reject_list;
97147c08596SBrooks Davis 	    ap; ap = ap->next) {
97247c08596SBrooks Davis 		if (addr_eq(packet->client_addr, ap->addr)) {
97347c08596SBrooks Davis 			note("%s from %s rejected.", type, piaddr(ap->addr));
97447c08596SBrooks Davis 			return;
97547c08596SBrooks Davis 		}
97647c08596SBrooks Davis 	}
97747c08596SBrooks Davis 	(*handler)(packet);
97847c08596SBrooks Davis }
97947c08596SBrooks Davis 
98047c08596SBrooks Davis void
98147c08596SBrooks Davis dhcpoffer(struct packet *packet)
98247c08596SBrooks Davis {
98347c08596SBrooks Davis 	struct interface_info *ip = packet->interface;
98447c08596SBrooks Davis 	struct client_lease *lease, *lp;
98547c08596SBrooks Davis 	int i;
98647c08596SBrooks Davis 	int arp_timeout_needed, stop_selecting;
98747c08596SBrooks Davis 	char *name = packet->options[DHO_DHCP_MESSAGE_TYPE].len ?
98847c08596SBrooks Davis 	    "DHCPOFFER" : "BOOTREPLY";
98947c08596SBrooks Davis 
99047c08596SBrooks Davis 	/* If we're not receptive to an offer right now, or if the offer
99147c08596SBrooks Davis 	   has an unrecognizable transaction id, then just drop it. */
99247c08596SBrooks Davis 	if (ip->client->state != S_SELECTING ||
99347c08596SBrooks Davis 	    packet->interface->client->xid != packet->raw->xid ||
99447c08596SBrooks Davis 	    (packet->interface->hw_address.hlen != packet->raw->hlen) ||
99547c08596SBrooks Davis 	    (memcmp(packet->interface->hw_address.haddr,
99647c08596SBrooks Davis 	    packet->raw->chaddr, packet->raw->hlen)))
99747c08596SBrooks Davis 		return;
99847c08596SBrooks Davis 
99947c08596SBrooks Davis 	note("%s from %s", name, piaddr(packet->client_addr));
100047c08596SBrooks Davis 
100147c08596SBrooks Davis 
100247c08596SBrooks Davis 	/* If this lease doesn't supply the minimum required parameters,
100347c08596SBrooks Davis 	   blow it off. */
100447c08596SBrooks Davis 	for (i = 0; ip->client->config->required_options[i]; i++) {
100547c08596SBrooks Davis 		if (!packet->options[ip->client->config->
100647c08596SBrooks Davis 		    required_options[i]].len) {
100747c08596SBrooks Davis 			note("%s isn't satisfactory.", name);
100847c08596SBrooks Davis 			return;
100947c08596SBrooks Davis 		}
101047c08596SBrooks Davis 	}
101147c08596SBrooks Davis 
101247c08596SBrooks Davis 	/* If we've already seen this lease, don't record it again. */
101347c08596SBrooks Davis 	for (lease = ip->client->offered_leases;
101447c08596SBrooks Davis 	    lease; lease = lease->next) {
101547c08596SBrooks Davis 		if (lease->address.len == sizeof(packet->raw->yiaddr) &&
101647c08596SBrooks Davis 		    !memcmp(lease->address.iabuf,
101747c08596SBrooks Davis 		    &packet->raw->yiaddr, lease->address.len)) {
101847c08596SBrooks Davis 			debug("%s already seen.", name);
101947c08596SBrooks Davis 			return;
102047c08596SBrooks Davis 		}
102147c08596SBrooks Davis 	}
102247c08596SBrooks Davis 
102347c08596SBrooks Davis 	lease = packet_to_lease(packet);
102447c08596SBrooks Davis 	if (!lease) {
102547c08596SBrooks Davis 		note("packet_to_lease failed.");
102647c08596SBrooks Davis 		return;
102747c08596SBrooks Davis 	}
102847c08596SBrooks Davis 
102947c08596SBrooks Davis 	/* If this lease was acquired through a BOOTREPLY, record that
103047c08596SBrooks Davis 	   fact. */
103147c08596SBrooks Davis 	if (!packet->options[DHO_DHCP_MESSAGE_TYPE].len)
103247c08596SBrooks Davis 		lease->is_bootp = 1;
103347c08596SBrooks Davis 
103447c08596SBrooks Davis 	/* Record the medium under which this lease was offered. */
103547c08596SBrooks Davis 	lease->medium = ip->client->medium;
103647c08596SBrooks Davis 
103747c08596SBrooks Davis 	/* Send out an ARP Request for the offered IP address. */
103847c08596SBrooks Davis 	script_init("ARPSEND", lease->medium);
103947c08596SBrooks Davis 	script_write_params("check_", lease);
104047c08596SBrooks Davis 	/* If the script can't send an ARP request without waiting,
104147c08596SBrooks Davis 	   we'll be waiting when we do the ARPCHECK, so don't wait now. */
104247c08596SBrooks Davis 	if (script_go())
104347c08596SBrooks Davis 		arp_timeout_needed = 0;
104447c08596SBrooks Davis 	else
104547c08596SBrooks Davis 		arp_timeout_needed = 2;
104647c08596SBrooks Davis 
104747c08596SBrooks Davis 	/* Figure out when we're supposed to stop selecting. */
104847c08596SBrooks Davis 	stop_selecting =
104947c08596SBrooks Davis 	    ip->client->first_sending + ip->client->config->select_interval;
105047c08596SBrooks Davis 
105147c08596SBrooks Davis 	/* If this is the lease we asked for, put it at the head of the
105247c08596SBrooks Davis 	   list, and don't mess with the arp request timeout. */
105347c08596SBrooks Davis 	if (lease->address.len == ip->client->requested_address.len &&
105447c08596SBrooks Davis 	    !memcmp(lease->address.iabuf,
105547c08596SBrooks Davis 	    ip->client->requested_address.iabuf,
105647c08596SBrooks Davis 	    ip->client->requested_address.len)) {
105747c08596SBrooks Davis 		lease->next = ip->client->offered_leases;
105847c08596SBrooks Davis 		ip->client->offered_leases = lease;
105947c08596SBrooks Davis 	} else {
106047c08596SBrooks Davis 		/* If we already have an offer, and arping for this
106147c08596SBrooks Davis 		   offer would take us past the selection timeout,
106247c08596SBrooks Davis 		   then don't extend the timeout - just hope for the
106347c08596SBrooks Davis 		   best. */
106447c08596SBrooks Davis 		if (ip->client->offered_leases &&
106547c08596SBrooks Davis 		    (cur_time + arp_timeout_needed) > stop_selecting)
106647c08596SBrooks Davis 			arp_timeout_needed = 0;
106747c08596SBrooks Davis 
106847c08596SBrooks Davis 		/* Put the lease at the end of the list. */
106947c08596SBrooks Davis 		lease->next = NULL;
107047c08596SBrooks Davis 		if (!ip->client->offered_leases)
107147c08596SBrooks Davis 			ip->client->offered_leases = lease;
107247c08596SBrooks Davis 		else {
107347c08596SBrooks Davis 			for (lp = ip->client->offered_leases; lp->next;
107447c08596SBrooks Davis 			    lp = lp->next)
107547c08596SBrooks Davis 				;	/* nothing */
107647c08596SBrooks Davis 			lp->next = lease;
107747c08596SBrooks Davis 		}
107847c08596SBrooks Davis 	}
107947c08596SBrooks Davis 
108047c08596SBrooks Davis 	/* If we're supposed to stop selecting before we've had time
108147c08596SBrooks Davis 	   to wait for the ARPREPLY, add some delay to wait for
108247c08596SBrooks Davis 	   the ARPREPLY. */
108347c08596SBrooks Davis 	if (stop_selecting - cur_time < arp_timeout_needed)
108447c08596SBrooks Davis 		stop_selecting = cur_time + arp_timeout_needed;
108547c08596SBrooks Davis 
108647c08596SBrooks Davis 	/* If the selecting interval has expired, go immediately to
108747c08596SBrooks Davis 	   state_selecting().  Otherwise, time out into
108847c08596SBrooks Davis 	   state_selecting at the select interval. */
108947c08596SBrooks Davis 	if (stop_selecting <= 0)
109047c08596SBrooks Davis 		state_selecting(ip);
109147c08596SBrooks Davis 	else {
109247c08596SBrooks Davis 		add_timeout(stop_selecting, state_selecting, ip);
109347c08596SBrooks Davis 		cancel_timeout(send_discover, ip);
109447c08596SBrooks Davis 	}
109547c08596SBrooks Davis }
109647c08596SBrooks Davis 
109747c08596SBrooks Davis /* Allocate a client_lease structure and initialize it from the parameters
109847c08596SBrooks Davis    in the specified packet. */
109947c08596SBrooks Davis 
110047c08596SBrooks Davis struct client_lease *
110147c08596SBrooks Davis packet_to_lease(struct packet *packet)
110247c08596SBrooks Davis {
110347c08596SBrooks Davis 	struct client_lease *lease;
110447c08596SBrooks Davis 	int i;
110547c08596SBrooks Davis 
110647c08596SBrooks Davis 	lease = malloc(sizeof(struct client_lease));
110747c08596SBrooks Davis 
110847c08596SBrooks Davis 	if (!lease) {
110947c08596SBrooks Davis 		warning("dhcpoffer: no memory to record lease.");
111047c08596SBrooks Davis 		return (NULL);
111147c08596SBrooks Davis 	}
111247c08596SBrooks Davis 
111347c08596SBrooks Davis 	memset(lease, 0, sizeof(*lease));
111447c08596SBrooks Davis 
111547c08596SBrooks Davis 	/* Copy the lease options. */
111647c08596SBrooks Davis 	for (i = 0; i < 256; i++) {
111747c08596SBrooks Davis 		if (packet->options[i].len) {
111847c08596SBrooks Davis 			lease->options[i].data =
111947c08596SBrooks Davis 			    malloc(packet->options[i].len + 1);
112047c08596SBrooks Davis 			if (!lease->options[i].data) {
112147c08596SBrooks Davis 				warning("dhcpoffer: no memory for option %d", i);
112247c08596SBrooks Davis 				free_client_lease(lease);
112347c08596SBrooks Davis 				return (NULL);
112447c08596SBrooks Davis 			} else {
112547c08596SBrooks Davis 				memcpy(lease->options[i].data,
112647c08596SBrooks Davis 				    packet->options[i].data,
112747c08596SBrooks Davis 				    packet->options[i].len);
112847c08596SBrooks Davis 				lease->options[i].len =
112947c08596SBrooks Davis 				    packet->options[i].len;
113047c08596SBrooks Davis 				lease->options[i].data[lease->options[i].len] =
113147c08596SBrooks Davis 				    0;
113247c08596SBrooks Davis 			}
113347c08596SBrooks Davis 			if (!check_option(lease,i)) {
113447c08596SBrooks Davis 				/* ignore a bogus lease offer */
113547c08596SBrooks Davis 				warning("Invalid lease option - ignoring offer");
113647c08596SBrooks Davis 				free_client_lease(lease);
113747c08596SBrooks Davis 				return (NULL);
113847c08596SBrooks Davis 			}
113947c08596SBrooks Davis 		}
114047c08596SBrooks Davis 	}
114147c08596SBrooks Davis 
114247c08596SBrooks Davis 	lease->address.len = sizeof(packet->raw->yiaddr);
114347c08596SBrooks Davis 	memcpy(lease->address.iabuf, &packet->raw->yiaddr, lease->address.len);
114447c08596SBrooks Davis 
1145d32438c3SBruce M Simpson 	lease->nextserver.len = sizeof(packet->raw->siaddr);
1146d32438c3SBruce M Simpson 	memcpy(lease->nextserver.iabuf, &packet->raw->siaddr, lease->nextserver.len);
1147d32438c3SBruce M Simpson 
1148acccb9aaSBrooks Davis 	/* If the server name was filled out, copy it.
1149acccb9aaSBrooks Davis 	   Do not attempt to validate the server name as a host name.
1150acccb9aaSBrooks Davis 	   RFC 2131 merely states that sname is NUL-terminated (which do
1151acccb9aaSBrooks Davis 	   do not assume) and that it is the server's host name.  Since
1152acccb9aaSBrooks Davis 	   the ISC client and server allow arbitrary characters, we do
1153acccb9aaSBrooks Davis 	   as well. */
115447c08596SBrooks Davis 	if ((!packet->options[DHO_DHCP_OPTION_OVERLOAD].len ||
115547c08596SBrooks Davis 	    !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 2)) &&
115647c08596SBrooks Davis 	    packet->raw->sname[0]) {
115747c08596SBrooks Davis 		lease->server_name = malloc(DHCP_SNAME_LEN + 1);
115847c08596SBrooks Davis 		if (!lease->server_name) {
115947c08596SBrooks Davis 			warning("dhcpoffer: no memory for server name.");
116047c08596SBrooks Davis 			free_client_lease(lease);
116147c08596SBrooks Davis 			return (NULL);
116247c08596SBrooks Davis 		}
116347c08596SBrooks Davis 		memcpy(lease->server_name, packet->raw->sname, DHCP_SNAME_LEN);
116447c08596SBrooks Davis 		lease->server_name[DHCP_SNAME_LEN]='\0';
116547c08596SBrooks Davis 	}
116647c08596SBrooks Davis 
116747c08596SBrooks Davis 	/* Ditto for the filename. */
116847c08596SBrooks Davis 	if ((!packet->options[DHO_DHCP_OPTION_OVERLOAD].len ||
116947c08596SBrooks Davis 	    !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 1)) &&
117047c08596SBrooks Davis 	    packet->raw->file[0]) {
117147c08596SBrooks Davis 		/* Don't count on the NUL terminator. */
117247c08596SBrooks Davis 		lease->filename = malloc(DHCP_FILE_LEN + 1);
117347c08596SBrooks Davis 		if (!lease->filename) {
117447c08596SBrooks Davis 			warning("dhcpoffer: no memory for filename.");
117547c08596SBrooks Davis 			free_client_lease(lease);
117647c08596SBrooks Davis 			return (NULL);
117747c08596SBrooks Davis 		}
117847c08596SBrooks Davis 		memcpy(lease->filename, packet->raw->file, DHCP_FILE_LEN);
117947c08596SBrooks Davis 		lease->filename[DHCP_FILE_LEN]='\0';
118047c08596SBrooks Davis 	}
118147c08596SBrooks Davis 	return lease;
118247c08596SBrooks Davis }
118347c08596SBrooks Davis 
118447c08596SBrooks Davis void
118547c08596SBrooks Davis dhcpnak(struct packet *packet)
118647c08596SBrooks Davis {
118747c08596SBrooks Davis 	struct interface_info *ip = packet->interface;
118847c08596SBrooks Davis 
118947c08596SBrooks Davis 	/* If we're not receptive to an offer right now, or if the offer
119047c08596SBrooks Davis 	   has an unrecognizable transaction id, then just drop it. */
119147c08596SBrooks Davis 	if (packet->interface->client->xid != packet->raw->xid ||
119247c08596SBrooks Davis 	    (packet->interface->hw_address.hlen != packet->raw->hlen) ||
119347c08596SBrooks Davis 	    (memcmp(packet->interface->hw_address.haddr,
119447c08596SBrooks Davis 	    packet->raw->chaddr, packet->raw->hlen)))
119547c08596SBrooks Davis 		return;
119647c08596SBrooks Davis 
119747c08596SBrooks Davis 	if (ip->client->state != S_REBOOTING &&
119847c08596SBrooks Davis 	    ip->client->state != S_REQUESTING &&
119947c08596SBrooks Davis 	    ip->client->state != S_RENEWING &&
120047c08596SBrooks Davis 	    ip->client->state != S_REBINDING)
120147c08596SBrooks Davis 		return;
120247c08596SBrooks Davis 
120347c08596SBrooks Davis 	note("DHCPNAK from %s", piaddr(packet->client_addr));
120447c08596SBrooks Davis 
120547c08596SBrooks Davis 	if (!ip->client->active) {
120647c08596SBrooks Davis 		note("DHCPNAK with no active lease.\n");
120747c08596SBrooks Davis 		return;
120847c08596SBrooks Davis 	}
120947c08596SBrooks Davis 
121047c08596SBrooks Davis 	free_client_lease(ip->client->active);
121147c08596SBrooks Davis 	ip->client->active = NULL;
121247c08596SBrooks Davis 
121347c08596SBrooks Davis 	/* Stop sending DHCPREQUEST packets... */
121447c08596SBrooks Davis 	cancel_timeout(send_request, ip);
121547c08596SBrooks Davis 
121647c08596SBrooks Davis 	ip->client->state = S_INIT;
121747c08596SBrooks Davis 	state_init(ip);
121847c08596SBrooks Davis }
121947c08596SBrooks Davis 
122047c08596SBrooks Davis /* Send out a DHCPDISCOVER packet, and set a timeout to send out another
122147c08596SBrooks Davis    one after the right interval has expired.  If we don't get an offer by
122247c08596SBrooks Davis    the time we reach the panic interval, call the panic function. */
122347c08596SBrooks Davis 
122447c08596SBrooks Davis void
122547c08596SBrooks Davis send_discover(void *ipp)
122647c08596SBrooks Davis {
122747c08596SBrooks Davis 	struct interface_info *ip = ipp;
122847c08596SBrooks Davis 	int interval, increase = 1;
122947c08596SBrooks Davis 
123047c08596SBrooks Davis 	/* Figure out how long it's been since we started transmitting. */
123147c08596SBrooks Davis 	interval = cur_time - ip->client->first_sending;
123247c08596SBrooks Davis 
123347c08596SBrooks Davis 	/* If we're past the panic timeout, call the script and tell it
123447c08596SBrooks Davis 	   we haven't found anything for this interface yet. */
123547c08596SBrooks Davis 	if (interval > ip->client->config->timeout) {
123647c08596SBrooks Davis 		state_panic(ip);
123747c08596SBrooks Davis 		return;
123847c08596SBrooks Davis 	}
123947c08596SBrooks Davis 
124047c08596SBrooks Davis 	/* If we're selecting media, try the whole list before doing
124147c08596SBrooks Davis 	   the exponential backoff, but if we've already received an
124247c08596SBrooks Davis 	   offer, stop looping, because we obviously have it right. */
124347c08596SBrooks Davis 	if (!ip->client->offered_leases &&
124447c08596SBrooks Davis 	    ip->client->config->media) {
124547c08596SBrooks Davis 		int fail = 0;
124647c08596SBrooks Davis again:
124747c08596SBrooks Davis 		if (ip->client->medium) {
124847c08596SBrooks Davis 			ip->client->medium = ip->client->medium->next;
124947c08596SBrooks Davis 			increase = 0;
125047c08596SBrooks Davis 		}
125147c08596SBrooks Davis 		if (!ip->client->medium) {
125247c08596SBrooks Davis 			if (fail)
125347c08596SBrooks Davis 				error("No valid media types for %s!", ip->name);
125447c08596SBrooks Davis 			ip->client->medium = ip->client->config->media;
125547c08596SBrooks Davis 			increase = 1;
125647c08596SBrooks Davis 		}
125747c08596SBrooks Davis 
125847c08596SBrooks Davis 		note("Trying medium \"%s\" %d", ip->client->medium->string,
125947c08596SBrooks Davis 		    increase);
126047c08596SBrooks Davis 		script_init("MEDIUM", ip->client->medium);
126147c08596SBrooks Davis 		if (script_go())
126247c08596SBrooks Davis 			goto again;
126347c08596SBrooks Davis 	}
126447c08596SBrooks Davis 
126547c08596SBrooks Davis 	/*
126647c08596SBrooks Davis 	 * If we're supposed to increase the interval, do so.  If it's
126747c08596SBrooks Davis 	 * currently zero (i.e., we haven't sent any packets yet), set
126847c08596SBrooks Davis 	 * it to one; otherwise, add to it a random number between zero
126947c08596SBrooks Davis 	 * and two times itself.  On average, this means that it will
127047c08596SBrooks Davis 	 * double with every transmission.
127147c08596SBrooks Davis 	 */
127247c08596SBrooks Davis 	if (increase) {
127347c08596SBrooks Davis 		if (!ip->client->interval)
127447c08596SBrooks Davis 			ip->client->interval =
127547c08596SBrooks Davis 			    ip->client->config->initial_interval;
127647c08596SBrooks Davis 		else {
127747c08596SBrooks Davis 			ip->client->interval += (arc4random() >> 2) %
127847c08596SBrooks Davis 			    (2 * ip->client->interval);
127947c08596SBrooks Davis 		}
128047c08596SBrooks Davis 
128147c08596SBrooks Davis 		/* Don't backoff past cutoff. */
128247c08596SBrooks Davis 		if (ip->client->interval >
128347c08596SBrooks Davis 		    ip->client->config->backoff_cutoff)
128447c08596SBrooks Davis 			ip->client->interval =
128547c08596SBrooks Davis 				((ip->client->config->backoff_cutoff / 2)
128647c08596SBrooks Davis 				 + ((arc4random() >> 2) %
128747c08596SBrooks Davis 				    ip->client->config->backoff_cutoff));
128847c08596SBrooks Davis 	} else if (!ip->client->interval)
128947c08596SBrooks Davis 		ip->client->interval =
129047c08596SBrooks Davis 			ip->client->config->initial_interval;
129147c08596SBrooks Davis 
129247c08596SBrooks Davis 	/* If the backoff would take us to the panic timeout, just use that
129347c08596SBrooks Davis 	   as the interval. */
129447c08596SBrooks Davis 	if (cur_time + ip->client->interval >
129547c08596SBrooks Davis 	    ip->client->first_sending + ip->client->config->timeout)
129647c08596SBrooks Davis 		ip->client->interval =
129747c08596SBrooks Davis 			(ip->client->first_sending +
129847c08596SBrooks Davis 			 ip->client->config->timeout) - cur_time + 1;
129947c08596SBrooks Davis 
130047c08596SBrooks Davis 	/* Record the number of seconds since we started sending. */
130147c08596SBrooks Davis 	if (interval < 65536)
130247c08596SBrooks Davis 		ip->client->packet.secs = htons(interval);
130347c08596SBrooks Davis 	else
130447c08596SBrooks Davis 		ip->client->packet.secs = htons(65535);
130547c08596SBrooks Davis 	ip->client->secs = ip->client->packet.secs;
130647c08596SBrooks Davis 
130747c08596SBrooks Davis 	note("DHCPDISCOVER on %s to %s port %d interval %d",
1308ba019ae5SPawel Jakub Dawidek 	    ip->name, inet_ntoa(inaddr_broadcast), REMOTE_PORT,
13099c13d9cdSBrooks Davis 	    (int)ip->client->interval);
131047c08596SBrooks Davis 
131147c08596SBrooks Davis 	/* Send out a packet. */
1312235eb530SPawel Jakub Dawidek 	send_packet_unpriv(privfd, &ip->client->packet,
1313235eb530SPawel Jakub Dawidek 	    ip->client->packet_length, inaddr_any, inaddr_broadcast);
131447c08596SBrooks Davis 
131547c08596SBrooks Davis 	add_timeout(cur_time + ip->client->interval, send_discover, ip);
131647c08596SBrooks Davis }
131747c08596SBrooks Davis 
131847c08596SBrooks Davis /*
131947c08596SBrooks Davis  * state_panic gets called if we haven't received any offers in a preset
132047c08596SBrooks Davis  * amount of time.   When this happens, we try to use existing leases
132147c08596SBrooks Davis  * that haven't yet expired, and failing that, we call the client script
132247c08596SBrooks Davis  * and hope it can do something.
132347c08596SBrooks Davis  */
132447c08596SBrooks Davis void
132547c08596SBrooks Davis state_panic(void *ipp)
132647c08596SBrooks Davis {
132747c08596SBrooks Davis 	struct interface_info *ip = ipp;
132847c08596SBrooks Davis 	struct client_lease *loop = ip->client->active;
132947c08596SBrooks Davis 	struct client_lease *lp;
133047c08596SBrooks Davis 
133147c08596SBrooks Davis 	note("No DHCPOFFERS received.");
133247c08596SBrooks Davis 
133347c08596SBrooks Davis 	/* We may not have an active lease, but we may have some
133447c08596SBrooks Davis 	   predefined leases that we can try. */
133547c08596SBrooks Davis 	if (!ip->client->active && ip->client->leases)
133647c08596SBrooks Davis 		goto activate_next;
133747c08596SBrooks Davis 
133847c08596SBrooks Davis 	/* Run through the list of leases and see if one can be used. */
133947c08596SBrooks Davis 	while (ip->client->active) {
134047c08596SBrooks Davis 		if (ip->client->active->expiry > cur_time) {
134147c08596SBrooks Davis 			note("Trying recorded lease %s",
134247c08596SBrooks Davis 			    piaddr(ip->client->active->address));
134347c08596SBrooks Davis 			/* Run the client script with the existing
134447c08596SBrooks Davis 			   parameters. */
134547c08596SBrooks Davis 			script_init("TIMEOUT",
134647c08596SBrooks Davis 			    ip->client->active->medium);
134747c08596SBrooks Davis 			script_write_params("new_", ip->client->active);
134847c08596SBrooks Davis 			if (ip->client->alias)
134947c08596SBrooks Davis 				script_write_params("alias_",
135047c08596SBrooks Davis 				    ip->client->alias);
135147c08596SBrooks Davis 
135247c08596SBrooks Davis 			/* If the old lease is still good and doesn't
135347c08596SBrooks Davis 			   yet need renewal, go into BOUND state and
135447c08596SBrooks Davis 			   timeout at the renewal time. */
135547c08596SBrooks Davis 			if (!script_go()) {
135647c08596SBrooks Davis 				if (cur_time <
135747c08596SBrooks Davis 				    ip->client->active->renewal) {
135847c08596SBrooks Davis 					ip->client->state = S_BOUND;
135947c08596SBrooks Davis 					note("bound: renewal in %d seconds.",
13609c13d9cdSBrooks Davis 					    (int)(ip->client->active->renewal -
13619c13d9cdSBrooks Davis 					    cur_time));
136247c08596SBrooks Davis 					add_timeout(
136347c08596SBrooks Davis 					    ip->client->active->renewal,
136447c08596SBrooks Davis 					    state_bound, ip);
136547c08596SBrooks Davis 				} else {
136647c08596SBrooks Davis 					ip->client->state = S_BOUND;
136747c08596SBrooks Davis 					note("bound: immediate renewal.");
136847c08596SBrooks Davis 					state_bound(ip);
136947c08596SBrooks Davis 				}
137047c08596SBrooks Davis 				reinitialize_interfaces();
137147c08596SBrooks Davis 				go_daemon();
137247c08596SBrooks Davis 				return;
137347c08596SBrooks Davis 			}
137447c08596SBrooks Davis 		}
137547c08596SBrooks Davis 
137647c08596SBrooks Davis 		/* If there are no other leases, give up. */
137747c08596SBrooks Davis 		if (!ip->client->leases) {
137847c08596SBrooks Davis 			ip->client->leases = ip->client->active;
137947c08596SBrooks Davis 			ip->client->active = NULL;
138047c08596SBrooks Davis 			break;
138147c08596SBrooks Davis 		}
138247c08596SBrooks Davis 
138347c08596SBrooks Davis activate_next:
138447c08596SBrooks Davis 		/* Otherwise, put the active lease at the end of the
138547c08596SBrooks Davis 		   lease list, and try another lease.. */
138647c08596SBrooks Davis 		for (lp = ip->client->leases; lp->next; lp = lp->next)
138747c08596SBrooks Davis 			;
138847c08596SBrooks Davis 		lp->next = ip->client->active;
138947c08596SBrooks Davis 		if (lp->next)
139047c08596SBrooks Davis 			lp->next->next = NULL;
139147c08596SBrooks Davis 		ip->client->active = ip->client->leases;
139247c08596SBrooks Davis 		ip->client->leases = ip->client->leases->next;
139347c08596SBrooks Davis 
139447c08596SBrooks Davis 		/* If we already tried this lease, we've exhausted the
139547c08596SBrooks Davis 		   set of leases, so we might as well give up for
139647c08596SBrooks Davis 		   now. */
139747c08596SBrooks Davis 		if (ip->client->active == loop)
139847c08596SBrooks Davis 			break;
139947c08596SBrooks Davis 		else if (!loop)
140047c08596SBrooks Davis 			loop = ip->client->active;
140147c08596SBrooks Davis 	}
140247c08596SBrooks Davis 
140347c08596SBrooks Davis 	/* No leases were available, or what was available didn't work, so
140447c08596SBrooks Davis 	   tell the shell script that we failed to allocate an address,
140547c08596SBrooks Davis 	   and try again later. */
140647c08596SBrooks Davis 	note("No working leases in persistent database - sleeping.\n");
140747c08596SBrooks Davis 	script_init("FAIL", NULL);
140847c08596SBrooks Davis 	if (ip->client->alias)
140947c08596SBrooks Davis 		script_write_params("alias_", ip->client->alias);
141047c08596SBrooks Davis 	script_go();
141147c08596SBrooks Davis 	ip->client->state = S_INIT;
141247c08596SBrooks Davis 	add_timeout(cur_time + ip->client->config->retry_interval, state_init,
141347c08596SBrooks Davis 	    ip);
141447c08596SBrooks Davis 	go_daemon();
141547c08596SBrooks Davis }
141647c08596SBrooks Davis 
141747c08596SBrooks Davis void
141847c08596SBrooks Davis send_request(void *ipp)
141947c08596SBrooks Davis {
142047c08596SBrooks Davis 	struct interface_info *ip = ipp;
1421ba019ae5SPawel Jakub Dawidek 	struct in_addr from, to;
142247c08596SBrooks Davis 	int interval;
142347c08596SBrooks Davis 
142447c08596SBrooks Davis 	/* Figure out how long it's been since we started transmitting. */
142547c08596SBrooks Davis 	interval = cur_time - ip->client->first_sending;
142647c08596SBrooks Davis 
142747c08596SBrooks Davis 	/* If we're in the INIT-REBOOT or REQUESTING state and we're
142847c08596SBrooks Davis 	   past the reboot timeout, go to INIT and see if we can
142947c08596SBrooks Davis 	   DISCOVER an address... */
143047c08596SBrooks Davis 	/* XXX In the INIT-REBOOT state, if we don't get an ACK, it
143147c08596SBrooks Davis 	   means either that we're on a network with no DHCP server,
143247c08596SBrooks Davis 	   or that our server is down.  In the latter case, assuming
143347c08596SBrooks Davis 	   that there is a backup DHCP server, DHCPDISCOVER will get
143447c08596SBrooks Davis 	   us a new address, but we could also have successfully
143547c08596SBrooks Davis 	   reused our old address.  In the former case, we're hosed
143647c08596SBrooks Davis 	   anyway.  This is not a win-prone situation. */
143747c08596SBrooks Davis 	if ((ip->client->state == S_REBOOTING ||
143847c08596SBrooks Davis 	    ip->client->state == S_REQUESTING) &&
143947c08596SBrooks Davis 	    interval > ip->client->config->reboot_timeout) {
144047c08596SBrooks Davis cancel:
144147c08596SBrooks Davis 		ip->client->state = S_INIT;
144247c08596SBrooks Davis 		cancel_timeout(send_request, ip);
144347c08596SBrooks Davis 		state_init(ip);
144447c08596SBrooks Davis 		return;
144547c08596SBrooks Davis 	}
144647c08596SBrooks Davis 
144747c08596SBrooks Davis 	/* If we're in the reboot state, make sure the media is set up
144847c08596SBrooks Davis 	   correctly. */
144947c08596SBrooks Davis 	if (ip->client->state == S_REBOOTING &&
145047c08596SBrooks Davis 	    !ip->client->medium &&
145147c08596SBrooks Davis 	    ip->client->active->medium ) {
145247c08596SBrooks Davis 		script_init("MEDIUM", ip->client->active->medium);
145347c08596SBrooks Davis 
145447c08596SBrooks Davis 		/* If the medium we chose won't fly, go to INIT state. */
145547c08596SBrooks Davis 		if (script_go())
145647c08596SBrooks Davis 			goto cancel;
145747c08596SBrooks Davis 
145847c08596SBrooks Davis 		/* Record the medium. */
145947c08596SBrooks Davis 		ip->client->medium = ip->client->active->medium;
146047c08596SBrooks Davis 	}
146147c08596SBrooks Davis 
146247c08596SBrooks Davis 	/* If the lease has expired, relinquish the address and go back
146347c08596SBrooks Davis 	   to the INIT state. */
146447c08596SBrooks Davis 	if (ip->client->state != S_REQUESTING &&
146547c08596SBrooks Davis 	    cur_time > ip->client->active->expiry) {
146647c08596SBrooks Davis 		/* Run the client script with the new parameters. */
146747c08596SBrooks Davis 		script_init("EXPIRE", NULL);
146847c08596SBrooks Davis 		script_write_params("old_", ip->client->active);
146947c08596SBrooks Davis 		if (ip->client->alias)
147047c08596SBrooks Davis 			script_write_params("alias_", ip->client->alias);
147147c08596SBrooks Davis 		script_go();
147247c08596SBrooks Davis 
147347c08596SBrooks Davis 		/* Now do a preinit on the interface so that we can
147447c08596SBrooks Davis 		   discover a new address. */
147547c08596SBrooks Davis 		script_init("PREINIT", NULL);
147647c08596SBrooks Davis 		if (ip->client->alias)
147747c08596SBrooks Davis 			script_write_params("alias_", ip->client->alias);
147847c08596SBrooks Davis 		script_go();
147947c08596SBrooks Davis 
148047c08596SBrooks Davis 		ip->client->state = S_INIT;
148147c08596SBrooks Davis 		state_init(ip);
148247c08596SBrooks Davis 		return;
148347c08596SBrooks Davis 	}
148447c08596SBrooks Davis 
148547c08596SBrooks Davis 	/* Do the exponential backoff... */
148647c08596SBrooks Davis 	if (!ip->client->interval)
148747c08596SBrooks Davis 		ip->client->interval = ip->client->config->initial_interval;
148847c08596SBrooks Davis 	else
148947c08596SBrooks Davis 		ip->client->interval += ((arc4random() >> 2) %
149047c08596SBrooks Davis 		    (2 * ip->client->interval));
149147c08596SBrooks Davis 
149247c08596SBrooks Davis 	/* Don't backoff past cutoff. */
149347c08596SBrooks Davis 	if (ip->client->interval >
149447c08596SBrooks Davis 	    ip->client->config->backoff_cutoff)
149547c08596SBrooks Davis 		ip->client->interval =
149647c08596SBrooks Davis 		    ((ip->client->config->backoff_cutoff / 2) +
149747c08596SBrooks Davis 		    ((arc4random() >> 2) % ip->client->interval));
149847c08596SBrooks Davis 
149947c08596SBrooks Davis 	/* If the backoff would take us to the expiry time, just set the
150047c08596SBrooks Davis 	   timeout to the expiry time. */
150147c08596SBrooks Davis 	if (ip->client->state != S_REQUESTING &&
150247c08596SBrooks Davis 	    cur_time + ip->client->interval >
150347c08596SBrooks Davis 	    ip->client->active->expiry)
150447c08596SBrooks Davis 		ip->client->interval =
150547c08596SBrooks Davis 		    ip->client->active->expiry - cur_time + 1;
150647c08596SBrooks Davis 
150747c08596SBrooks Davis 	/* If the lease T2 time has elapsed, or if we're not yet bound,
150847c08596SBrooks Davis 	   broadcast the DHCPREQUEST rather than unicasting. */
150947c08596SBrooks Davis 	if (ip->client->state == S_REQUESTING ||
151047c08596SBrooks Davis 	    ip->client->state == S_REBOOTING ||
151147c08596SBrooks Davis 	    cur_time > ip->client->active->rebind)
1512ba019ae5SPawel Jakub Dawidek 		to.s_addr = INADDR_BROADCAST;
151347c08596SBrooks Davis 	else
1514ba019ae5SPawel Jakub Dawidek 		memcpy(&to.s_addr, ip->client->destination.iabuf,
1515ba019ae5SPawel Jakub Dawidek 		    sizeof(to.s_addr));
151647c08596SBrooks Davis 
151747c08596SBrooks Davis 	if (ip->client->state != S_REQUESTING)
151847c08596SBrooks Davis 		memcpy(&from, ip->client->active->address.iabuf,
151947c08596SBrooks Davis 		    sizeof(from));
152047c08596SBrooks Davis 	else
152147c08596SBrooks Davis 		from.s_addr = INADDR_ANY;
152247c08596SBrooks Davis 
152347c08596SBrooks Davis 	/* Record the number of seconds since we started sending. */
152447c08596SBrooks Davis 	if (ip->client->state == S_REQUESTING)
152547c08596SBrooks Davis 		ip->client->packet.secs = ip->client->secs;
152647c08596SBrooks Davis 	else {
152747c08596SBrooks Davis 		if (interval < 65536)
152847c08596SBrooks Davis 			ip->client->packet.secs = htons(interval);
152947c08596SBrooks Davis 		else
153047c08596SBrooks Davis 			ip->client->packet.secs = htons(65535);
153147c08596SBrooks Davis 	}
153247c08596SBrooks Davis 
1533ba019ae5SPawel Jakub Dawidek 	note("DHCPREQUEST on %s to %s port %d", ip->name, inet_ntoa(to),
1534ba019ae5SPawel Jakub Dawidek 	    REMOTE_PORT);
153547c08596SBrooks Davis 
153647c08596SBrooks Davis 	/* Send out a packet. */
1537235eb530SPawel Jakub Dawidek 	send_packet_unpriv(privfd, &ip->client->packet,
1538235eb530SPawel Jakub Dawidek 	    ip->client->packet_length, from, to);
153947c08596SBrooks Davis 
154047c08596SBrooks Davis 	add_timeout(cur_time + ip->client->interval, send_request, ip);
154147c08596SBrooks Davis }
154247c08596SBrooks Davis 
154347c08596SBrooks Davis void
154447c08596SBrooks Davis send_decline(void *ipp)
154547c08596SBrooks Davis {
154647c08596SBrooks Davis 	struct interface_info *ip = ipp;
154747c08596SBrooks Davis 
154847c08596SBrooks Davis 	note("DHCPDECLINE on %s to %s port %d", ip->name,
1549ba019ae5SPawel Jakub Dawidek 	    inet_ntoa(inaddr_broadcast), REMOTE_PORT);
155047c08596SBrooks Davis 
155147c08596SBrooks Davis 	/* Send out a packet. */
1552235eb530SPawel Jakub Dawidek 	send_packet_unpriv(privfd, &ip->client->packet,
1553235eb530SPawel Jakub Dawidek 	    ip->client->packet_length, inaddr_any, inaddr_broadcast);
155447c08596SBrooks Davis }
155547c08596SBrooks Davis 
155647c08596SBrooks Davis void
155747c08596SBrooks Davis make_discover(struct interface_info *ip, struct client_lease *lease)
155847c08596SBrooks Davis {
155947c08596SBrooks Davis 	unsigned char discover = DHCPDISCOVER;
156047c08596SBrooks Davis 	struct tree_cache *options[256];
156147c08596SBrooks Davis 	struct tree_cache option_elements[256];
156247c08596SBrooks Davis 	int i;
156347c08596SBrooks Davis 
156447c08596SBrooks Davis 	memset(option_elements, 0, sizeof(option_elements));
156547c08596SBrooks Davis 	memset(options, 0, sizeof(options));
156647c08596SBrooks Davis 	memset(&ip->client->packet, 0, sizeof(ip->client->packet));
156747c08596SBrooks Davis 
156847c08596SBrooks Davis 	/* Set DHCP_MESSAGE_TYPE to DHCPDISCOVER */
156947c08596SBrooks Davis 	i = DHO_DHCP_MESSAGE_TYPE;
157047c08596SBrooks Davis 	options[i] = &option_elements[i];
157147c08596SBrooks Davis 	options[i]->value = &discover;
157247c08596SBrooks Davis 	options[i]->len = sizeof(discover);
157347c08596SBrooks Davis 	options[i]->buf_size = sizeof(discover);
157447c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
157547c08596SBrooks Davis 
157647c08596SBrooks Davis 	/* Request the options we want */
157747c08596SBrooks Davis 	i  = DHO_DHCP_PARAMETER_REQUEST_LIST;
157847c08596SBrooks Davis 	options[i] = &option_elements[i];
157947c08596SBrooks Davis 	options[i]->value = ip->client->config->requested_options;
158047c08596SBrooks Davis 	options[i]->len = ip->client->config->requested_option_count;
158147c08596SBrooks Davis 	options[i]->buf_size =
158247c08596SBrooks Davis 		ip->client->config->requested_option_count;
158347c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
158447c08596SBrooks Davis 
158547c08596SBrooks Davis 	/* If we had an address, try to get it again. */
158647c08596SBrooks Davis 	if (lease) {
158747c08596SBrooks Davis 		ip->client->requested_address = lease->address;
158847c08596SBrooks Davis 		i = DHO_DHCP_REQUESTED_ADDRESS;
158947c08596SBrooks Davis 		options[i] = &option_elements[i];
159047c08596SBrooks Davis 		options[i]->value = lease->address.iabuf;
159147c08596SBrooks Davis 		options[i]->len = lease->address.len;
159247c08596SBrooks Davis 		options[i]->buf_size = lease->address.len;
159347c08596SBrooks Davis 		options[i]->timeout = 0xFFFFFFFF;
159447c08596SBrooks Davis 	} else
159547c08596SBrooks Davis 		ip->client->requested_address.len = 0;
159647c08596SBrooks Davis 
159747c08596SBrooks Davis 	/* Send any options requested in the config file. */
159847c08596SBrooks Davis 	for (i = 0; i < 256; i++)
159947c08596SBrooks Davis 		if (!options[i] &&
160047c08596SBrooks Davis 		    ip->client->config->send_options[i].data) {
160147c08596SBrooks Davis 			options[i] = &option_elements[i];
160247c08596SBrooks Davis 			options[i]->value =
160347c08596SBrooks Davis 			    ip->client->config->send_options[i].data;
160447c08596SBrooks Davis 			options[i]->len =
160547c08596SBrooks Davis 			    ip->client->config->send_options[i].len;
160647c08596SBrooks Davis 			options[i]->buf_size =
160747c08596SBrooks Davis 			    ip->client->config->send_options[i].len;
160847c08596SBrooks Davis 			options[i]->timeout = 0xFFFFFFFF;
160947c08596SBrooks Davis 		}
161047c08596SBrooks Davis 
1611fcab8addSBrooks Davis 	/* send host name if not set via config file. */
1612fcab8addSBrooks Davis 	if (!options[DHO_HOST_NAME]) {
16130bbe8306SPawel Jakub Dawidek 		if (hostname[0] != '\0') {
1614fcab8addSBrooks Davis 			size_t len;
1615fcab8addSBrooks Davis 			char* posDot = strchr(hostname, '.');
1616fcab8addSBrooks Davis 			if (posDot != NULL)
1617fcab8addSBrooks Davis 				len = posDot - hostname;
1618fcab8addSBrooks Davis 			else
1619fcab8addSBrooks Davis 				len = strlen(hostname);
1620fcab8addSBrooks Davis 			options[DHO_HOST_NAME] = &option_elements[DHO_HOST_NAME];
1621fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->value = hostname;
1622fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->len = len;
1623fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->buf_size = len;
1624fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->timeout = 0xFFFFFFFF;
1625fcab8addSBrooks Davis 		}
1626fcab8addSBrooks Davis 	}
1627fcab8addSBrooks Davis 
1628fcab8addSBrooks Davis 	/* set unique client identifier */
1629fb0eab09SConrad Meyer 	char client_ident[sizeof(ip->hw_address.haddr) + 1];
1630fcab8addSBrooks Davis 	if (!options[DHO_DHCP_CLIENT_IDENTIFIER]) {
16314441bd73SConrad Meyer 		int hwlen = (ip->hw_address.hlen < sizeof(client_ident)-1) ?
16324441bd73SConrad Meyer 				ip->hw_address.hlen : sizeof(client_ident)-1;
16334441bd73SConrad Meyer 		client_ident[0] = ip->hw_address.htype;
16344441bd73SConrad Meyer 		memcpy(&client_ident[1], ip->hw_address.haddr, hwlen);
1635fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER] = &option_elements[DHO_DHCP_CLIENT_IDENTIFIER];
16364441bd73SConrad Meyer 		options[DHO_DHCP_CLIENT_IDENTIFIER]->value = client_ident;
16374441bd73SConrad Meyer 		options[DHO_DHCP_CLIENT_IDENTIFIER]->len = hwlen+1;
16384441bd73SConrad Meyer 		options[DHO_DHCP_CLIENT_IDENTIFIER]->buf_size = hwlen+1;
1639fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->timeout = 0xFFFFFFFF;
1640fcab8addSBrooks Davis 	}
1641fcab8addSBrooks Davis 
164247c08596SBrooks Davis 	/* Set up the option buffer... */
164347c08596SBrooks Davis 	ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
164447c08596SBrooks Davis 	    options, 0, 0, 0, NULL, 0);
164547c08596SBrooks Davis 	if (ip->client->packet_length < BOOTP_MIN_LEN)
164647c08596SBrooks Davis 		ip->client->packet_length = BOOTP_MIN_LEN;
164747c08596SBrooks Davis 
164847c08596SBrooks Davis 	ip->client->packet.op = BOOTREQUEST;
164947c08596SBrooks Davis 	ip->client->packet.htype = ip->hw_address.htype;
165047c08596SBrooks Davis 	ip->client->packet.hlen = ip->hw_address.hlen;
165147c08596SBrooks Davis 	ip->client->packet.hops = 0;
165247c08596SBrooks Davis 	ip->client->packet.xid = arc4random();
165347c08596SBrooks Davis 	ip->client->packet.secs = 0; /* filled in by send_discover. */
165447c08596SBrooks Davis 	ip->client->packet.flags = 0;
165547c08596SBrooks Davis 
165647c08596SBrooks Davis 	memset(&(ip->client->packet.ciaddr),
165747c08596SBrooks Davis 	    0, sizeof(ip->client->packet.ciaddr));
165847c08596SBrooks Davis 	memset(&(ip->client->packet.yiaddr),
165947c08596SBrooks Davis 	    0, sizeof(ip->client->packet.yiaddr));
166047c08596SBrooks Davis 	memset(&(ip->client->packet.siaddr),
166147c08596SBrooks Davis 	    0, sizeof(ip->client->packet.siaddr));
166247c08596SBrooks Davis 	memset(&(ip->client->packet.giaddr),
166347c08596SBrooks Davis 	    0, sizeof(ip->client->packet.giaddr));
16644441bd73SConrad Meyer 	memcpy(ip->client->packet.chaddr,
16654441bd73SConrad Meyer 	    ip->hw_address.haddr, ip->hw_address.hlen);
166647c08596SBrooks Davis }
166747c08596SBrooks Davis 
166847c08596SBrooks Davis 
166947c08596SBrooks Davis void
167047c08596SBrooks Davis make_request(struct interface_info *ip, struct client_lease * lease)
167147c08596SBrooks Davis {
167247c08596SBrooks Davis 	unsigned char request = DHCPREQUEST;
167347c08596SBrooks Davis 	struct tree_cache *options[256];
167447c08596SBrooks Davis 	struct tree_cache option_elements[256];
167547c08596SBrooks Davis 	int i;
167647c08596SBrooks Davis 
167747c08596SBrooks Davis 	memset(options, 0, sizeof(options));
167847c08596SBrooks Davis 	memset(&ip->client->packet, 0, sizeof(ip->client->packet));
167947c08596SBrooks Davis 
168047c08596SBrooks Davis 	/* Set DHCP_MESSAGE_TYPE to DHCPREQUEST */
168147c08596SBrooks Davis 	i = DHO_DHCP_MESSAGE_TYPE;
168247c08596SBrooks Davis 	options[i] = &option_elements[i];
168347c08596SBrooks Davis 	options[i]->value = &request;
168447c08596SBrooks Davis 	options[i]->len = sizeof(request);
168547c08596SBrooks Davis 	options[i]->buf_size = sizeof(request);
168647c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
168747c08596SBrooks Davis 
168847c08596SBrooks Davis 	/* Request the options we want */
168947c08596SBrooks Davis 	i = DHO_DHCP_PARAMETER_REQUEST_LIST;
169047c08596SBrooks Davis 	options[i] = &option_elements[i];
169147c08596SBrooks Davis 	options[i]->value = ip->client->config->requested_options;
169247c08596SBrooks Davis 	options[i]->len = ip->client->config->requested_option_count;
169347c08596SBrooks Davis 	options[i]->buf_size =
169447c08596SBrooks Davis 		ip->client->config->requested_option_count;
169547c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
169647c08596SBrooks Davis 
169747c08596SBrooks Davis 	/* If we are requesting an address that hasn't yet been assigned
169847c08596SBrooks Davis 	   to us, use the DHCP Requested Address option. */
169947c08596SBrooks Davis 	if (ip->client->state == S_REQUESTING) {
170047c08596SBrooks Davis 		/* Send back the server identifier... */
170147c08596SBrooks Davis 		i = DHO_DHCP_SERVER_IDENTIFIER;
170247c08596SBrooks Davis 		options[i] = &option_elements[i];
170347c08596SBrooks Davis 		options[i]->value = lease->options[i].data;
170447c08596SBrooks Davis 		options[i]->len = lease->options[i].len;
170547c08596SBrooks Davis 		options[i]->buf_size = lease->options[i].len;
170647c08596SBrooks Davis 		options[i]->timeout = 0xFFFFFFFF;
170747c08596SBrooks Davis 	}
170847c08596SBrooks Davis 	if (ip->client->state == S_REQUESTING ||
170947c08596SBrooks Davis 	    ip->client->state == S_REBOOTING) {
171047c08596SBrooks Davis 		ip->client->requested_address = lease->address;
171147c08596SBrooks Davis 		i = DHO_DHCP_REQUESTED_ADDRESS;
171247c08596SBrooks Davis 		options[i] = &option_elements[i];
171347c08596SBrooks Davis 		options[i]->value = lease->address.iabuf;
171447c08596SBrooks Davis 		options[i]->len = lease->address.len;
171547c08596SBrooks Davis 		options[i]->buf_size = lease->address.len;
171647c08596SBrooks Davis 		options[i]->timeout = 0xFFFFFFFF;
171747c08596SBrooks Davis 	} else
171847c08596SBrooks Davis 		ip->client->requested_address.len = 0;
171947c08596SBrooks Davis 
172047c08596SBrooks Davis 	/* Send any options requested in the config file. */
172147c08596SBrooks Davis 	for (i = 0; i < 256; i++)
172247c08596SBrooks Davis 		if (!options[i] &&
172347c08596SBrooks Davis 		    ip->client->config->send_options[i].data) {
172447c08596SBrooks Davis 			options[i] = &option_elements[i];
172547c08596SBrooks Davis 			options[i]->value =
172647c08596SBrooks Davis 			    ip->client->config->send_options[i].data;
172747c08596SBrooks Davis 			options[i]->len =
172847c08596SBrooks Davis 			    ip->client->config->send_options[i].len;
172947c08596SBrooks Davis 			options[i]->buf_size =
173047c08596SBrooks Davis 			    ip->client->config->send_options[i].len;
173147c08596SBrooks Davis 			options[i]->timeout = 0xFFFFFFFF;
173247c08596SBrooks Davis 		}
173347c08596SBrooks Davis 
1734fcab8addSBrooks Davis 	/* send host name if not set via config file. */
1735fcab8addSBrooks Davis 	if (!options[DHO_HOST_NAME]) {
17360bbe8306SPawel Jakub Dawidek 		if (hostname[0] != '\0') {
1737fcab8addSBrooks Davis 			size_t len;
1738fcab8addSBrooks Davis 			char* posDot = strchr(hostname, '.');
1739fcab8addSBrooks Davis 			if (posDot != NULL)
1740fcab8addSBrooks Davis 				len = posDot - hostname;
1741fcab8addSBrooks Davis 			else
1742fcab8addSBrooks Davis 				len = strlen(hostname);
1743fcab8addSBrooks Davis 			options[DHO_HOST_NAME] = &option_elements[DHO_HOST_NAME];
1744fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->value = hostname;
1745fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->len = len;
1746fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->buf_size = len;
1747fcab8addSBrooks Davis 			options[DHO_HOST_NAME]->timeout = 0xFFFFFFFF;
1748fcab8addSBrooks Davis 		}
1749fcab8addSBrooks Davis 	}
1750fcab8addSBrooks Davis 
1751fcab8addSBrooks Davis 	/* set unique client identifier */
1752fcab8addSBrooks Davis 	char client_ident[sizeof(struct hardware)];
1753fcab8addSBrooks Davis 	if (!options[DHO_DHCP_CLIENT_IDENTIFIER]) {
1754fcab8addSBrooks Davis 		int hwlen = (ip->hw_address.hlen < sizeof(client_ident)-1) ?
1755fcab8addSBrooks Davis 				ip->hw_address.hlen : sizeof(client_ident)-1;
1756fcab8addSBrooks Davis 		client_ident[0] = ip->hw_address.htype;
1757fcab8addSBrooks Davis 		memcpy(&client_ident[1], ip->hw_address.haddr, hwlen);
1758fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER] = &option_elements[DHO_DHCP_CLIENT_IDENTIFIER];
1759fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->value = client_ident;
1760fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->len = hwlen+1;
1761fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->buf_size = hwlen+1;
1762fcab8addSBrooks Davis 		options[DHO_DHCP_CLIENT_IDENTIFIER]->timeout = 0xFFFFFFFF;
1763fcab8addSBrooks Davis 	}
1764fcab8addSBrooks Davis 
176547c08596SBrooks Davis 	/* Set up the option buffer... */
176647c08596SBrooks Davis 	ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
176747c08596SBrooks Davis 	    options, 0, 0, 0, NULL, 0);
176847c08596SBrooks Davis 	if (ip->client->packet_length < BOOTP_MIN_LEN)
176947c08596SBrooks Davis 		ip->client->packet_length = BOOTP_MIN_LEN;
177047c08596SBrooks Davis 
177147c08596SBrooks Davis 	ip->client->packet.op = BOOTREQUEST;
177247c08596SBrooks Davis 	ip->client->packet.htype = ip->hw_address.htype;
177347c08596SBrooks Davis 	ip->client->packet.hlen = ip->hw_address.hlen;
177447c08596SBrooks Davis 	ip->client->packet.hops = 0;
177547c08596SBrooks Davis 	ip->client->packet.xid = ip->client->xid;
177647c08596SBrooks Davis 	ip->client->packet.secs = 0; /* Filled in by send_request. */
177747c08596SBrooks Davis 
177847c08596SBrooks Davis 	/* If we own the address we're requesting, put it in ciaddr;
177947c08596SBrooks Davis 	   otherwise set ciaddr to zero. */
178047c08596SBrooks Davis 	if (ip->client->state == S_BOUND ||
178147c08596SBrooks Davis 	    ip->client->state == S_RENEWING ||
178247c08596SBrooks Davis 	    ip->client->state == S_REBINDING) {
178347c08596SBrooks Davis 		memcpy(&ip->client->packet.ciaddr,
178447c08596SBrooks Davis 		    lease->address.iabuf, lease->address.len);
178547c08596SBrooks Davis 		ip->client->packet.flags = 0;
178647c08596SBrooks Davis 	} else {
178747c08596SBrooks Davis 		memset(&ip->client->packet.ciaddr, 0,
178847c08596SBrooks Davis 		    sizeof(ip->client->packet.ciaddr));
178947c08596SBrooks Davis 		ip->client->packet.flags = 0;
179047c08596SBrooks Davis 	}
179147c08596SBrooks Davis 
179247c08596SBrooks Davis 	memset(&ip->client->packet.yiaddr, 0,
179347c08596SBrooks Davis 	    sizeof(ip->client->packet.yiaddr));
179447c08596SBrooks Davis 	memset(&ip->client->packet.siaddr, 0,
179547c08596SBrooks Davis 	    sizeof(ip->client->packet.siaddr));
179647c08596SBrooks Davis 	memset(&ip->client->packet.giaddr, 0,
179747c08596SBrooks Davis 	    sizeof(ip->client->packet.giaddr));
179847c08596SBrooks Davis 	memcpy(ip->client->packet.chaddr,
179947c08596SBrooks Davis 	    ip->hw_address.haddr, ip->hw_address.hlen);
180047c08596SBrooks Davis }
180147c08596SBrooks Davis 
180247c08596SBrooks Davis void
180347c08596SBrooks Davis make_decline(struct interface_info *ip, struct client_lease *lease)
180447c08596SBrooks Davis {
180547c08596SBrooks Davis 	struct tree_cache *options[256], message_type_tree;
180647c08596SBrooks Davis 	struct tree_cache requested_address_tree;
180747c08596SBrooks Davis 	struct tree_cache server_id_tree, client_id_tree;
180847c08596SBrooks Davis 	unsigned char decline = DHCPDECLINE;
180947c08596SBrooks Davis 	int i;
181047c08596SBrooks Davis 
181147c08596SBrooks Davis 	memset(options, 0, sizeof(options));
181247c08596SBrooks Davis 	memset(&ip->client->packet, 0, sizeof(ip->client->packet));
181347c08596SBrooks Davis 
181447c08596SBrooks Davis 	/* Set DHCP_MESSAGE_TYPE to DHCPDECLINE */
181547c08596SBrooks Davis 	i = DHO_DHCP_MESSAGE_TYPE;
181647c08596SBrooks Davis 	options[i] = &message_type_tree;
181747c08596SBrooks Davis 	options[i]->value = &decline;
181847c08596SBrooks Davis 	options[i]->len = sizeof(decline);
181947c08596SBrooks Davis 	options[i]->buf_size = sizeof(decline);
182047c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
182147c08596SBrooks Davis 
182247c08596SBrooks Davis 	/* Send back the server identifier... */
182347c08596SBrooks Davis 	i = DHO_DHCP_SERVER_IDENTIFIER;
182447c08596SBrooks Davis 	options[i] = &server_id_tree;
182547c08596SBrooks Davis 	options[i]->value = lease->options[i].data;
182647c08596SBrooks Davis 	options[i]->len = lease->options[i].len;
182747c08596SBrooks Davis 	options[i]->buf_size = lease->options[i].len;
182847c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
182947c08596SBrooks Davis 
183047c08596SBrooks Davis 	/* Send back the address we're declining. */
183147c08596SBrooks Davis 	i = DHO_DHCP_REQUESTED_ADDRESS;
183247c08596SBrooks Davis 	options[i] = &requested_address_tree;
183347c08596SBrooks Davis 	options[i]->value = lease->address.iabuf;
183447c08596SBrooks Davis 	options[i]->len = lease->address.len;
183547c08596SBrooks Davis 	options[i]->buf_size = lease->address.len;
183647c08596SBrooks Davis 	options[i]->timeout = 0xFFFFFFFF;
183747c08596SBrooks Davis 
183847c08596SBrooks Davis 	/* Send the uid if the user supplied one. */
183947c08596SBrooks Davis 	i = DHO_DHCP_CLIENT_IDENTIFIER;
184047c08596SBrooks Davis 	if (ip->client->config->send_options[i].len) {
184147c08596SBrooks Davis 		options[i] = &client_id_tree;
184247c08596SBrooks Davis 		options[i]->value = ip->client->config->send_options[i].data;
184347c08596SBrooks Davis 		options[i]->len = ip->client->config->send_options[i].len;
184447c08596SBrooks Davis 		options[i]->buf_size = ip->client->config->send_options[i].len;
184547c08596SBrooks Davis 		options[i]->timeout = 0xFFFFFFFF;
184647c08596SBrooks Davis 	}
184747c08596SBrooks Davis 
184847c08596SBrooks Davis 
184947c08596SBrooks Davis 	/* Set up the option buffer... */
185047c08596SBrooks Davis 	ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
185147c08596SBrooks Davis 	    options, 0, 0, 0, NULL, 0);
185247c08596SBrooks Davis 	if (ip->client->packet_length < BOOTP_MIN_LEN)
185347c08596SBrooks Davis 		ip->client->packet_length = BOOTP_MIN_LEN;
185447c08596SBrooks Davis 
185547c08596SBrooks Davis 	ip->client->packet.op = BOOTREQUEST;
185647c08596SBrooks Davis 	ip->client->packet.htype = ip->hw_address.htype;
185747c08596SBrooks Davis 	ip->client->packet.hlen = ip->hw_address.hlen;
185847c08596SBrooks Davis 	ip->client->packet.hops = 0;
185947c08596SBrooks Davis 	ip->client->packet.xid = ip->client->xid;
186047c08596SBrooks Davis 	ip->client->packet.secs = 0; /* Filled in by send_request. */
186147c08596SBrooks Davis 	ip->client->packet.flags = 0;
186247c08596SBrooks Davis 
186347c08596SBrooks Davis 	/* ciaddr must always be zero. */
186447c08596SBrooks Davis 	memset(&ip->client->packet.ciaddr, 0,
186547c08596SBrooks Davis 	    sizeof(ip->client->packet.ciaddr));
186647c08596SBrooks Davis 	memset(&ip->client->packet.yiaddr, 0,
186747c08596SBrooks Davis 	    sizeof(ip->client->packet.yiaddr));
186847c08596SBrooks Davis 	memset(&ip->client->packet.siaddr, 0,
186947c08596SBrooks Davis 	    sizeof(ip->client->packet.siaddr));
187047c08596SBrooks Davis 	memset(&ip->client->packet.giaddr, 0,
187147c08596SBrooks Davis 	    sizeof(ip->client->packet.giaddr));
187247c08596SBrooks Davis 	memcpy(ip->client->packet.chaddr,
187347c08596SBrooks Davis 	    ip->hw_address.haddr, ip->hw_address.hlen);
187447c08596SBrooks Davis }
187547c08596SBrooks Davis 
187647c08596SBrooks Davis void
187747c08596SBrooks Davis free_client_lease(struct client_lease *lease)
187847c08596SBrooks Davis {
187947c08596SBrooks Davis 	int i;
188047c08596SBrooks Davis 
188147c08596SBrooks Davis 	if (lease->server_name)
188247c08596SBrooks Davis 		free(lease->server_name);
188347c08596SBrooks Davis 	if (lease->filename)
188447c08596SBrooks Davis 		free(lease->filename);
188547c08596SBrooks Davis 	for (i = 0; i < 256; i++) {
188647c08596SBrooks Davis 		if (lease->options[i].len)
188747c08596SBrooks Davis 			free(lease->options[i].data);
188847c08596SBrooks Davis 	}
188947c08596SBrooks Davis 	free(lease);
189047c08596SBrooks Davis }
189147c08596SBrooks Davis 
189247c08596SBrooks Davis FILE *leaseFile;
189347c08596SBrooks Davis 
189447c08596SBrooks Davis void
189547c08596SBrooks Davis rewrite_client_leases(void)
189647c08596SBrooks Davis {
189747c08596SBrooks Davis 	struct client_lease *lp;
18987008be5bSPawel Jakub Dawidek 	cap_rights_t rights;
189947c08596SBrooks Davis 
190047c08596SBrooks Davis 	if (!leaseFile) {
190147c08596SBrooks Davis 		leaseFile = fopen(path_dhclient_db, "w");
190247c08596SBrooks Davis 		if (!leaseFile)
190347c08596SBrooks Davis 			error("can't create %s: %m", path_dhclient_db);
190419342eeeSPatrick Kelsey 		cap_rights_init(&rights, CAP_FCNTL, CAP_FSTAT, CAP_FSYNC,
190519342eeeSPatrick Kelsey 		    CAP_FTRUNCATE, CAP_SEEK, CAP_WRITE);
19067008be5bSPawel Jakub Dawidek 		if (cap_rights_limit(fileno(leaseFile), &rights) < 0 &&
1907fe5c7163SPawel Jakub Dawidek 		    errno != ENOSYS) {
1908fe5c7163SPawel Jakub Dawidek 			error("can't limit lease descriptor: %m");
1909fe5c7163SPawel Jakub Dawidek 		}
191019342eeeSPatrick Kelsey 		if (cap_fcntls_limit(fileno(leaseFile), CAP_FCNTL_GETFL) < 0 &&
191119342eeeSPatrick Kelsey 		    errno != ENOSYS) {
191219342eeeSPatrick Kelsey 			error("can't limit lease descriptor fcntls: %m");
191319342eeeSPatrick Kelsey 		}
191447c08596SBrooks Davis 	} else {
191547c08596SBrooks Davis 		fflush(leaseFile);
191647c08596SBrooks Davis 		rewind(leaseFile);
191747c08596SBrooks Davis 	}
191847c08596SBrooks Davis 
191947c08596SBrooks Davis 	for (lp = ifi->client->leases; lp; lp = lp->next)
192047c08596SBrooks Davis 		write_client_lease(ifi, lp, 1);
192147c08596SBrooks Davis 	if (ifi->client->active)
192247c08596SBrooks Davis 		write_client_lease(ifi, ifi->client->active, 1);
192347c08596SBrooks Davis 
192447c08596SBrooks Davis 	fflush(leaseFile);
192547c08596SBrooks Davis 	ftruncate(fileno(leaseFile), ftello(leaseFile));
192647c08596SBrooks Davis 	fsync(fileno(leaseFile));
192747c08596SBrooks Davis }
192847c08596SBrooks Davis 
192947c08596SBrooks Davis void
193047c08596SBrooks Davis write_client_lease(struct interface_info *ip, struct client_lease *lease,
193147c08596SBrooks Davis     int rewrite)
193247c08596SBrooks Davis {
193347c08596SBrooks Davis 	static int leases_written;
193447c08596SBrooks Davis 	struct tm *t;
193547c08596SBrooks Davis 	int i;
193647c08596SBrooks Davis 
193747c08596SBrooks Davis 	if (!rewrite) {
193847c08596SBrooks Davis 		if (leases_written++ > 20) {
193947c08596SBrooks Davis 			rewrite_client_leases();
194047c08596SBrooks Davis 			leases_written = 0;
194147c08596SBrooks Davis 		}
194247c08596SBrooks Davis 	}
194347c08596SBrooks Davis 
194447c08596SBrooks Davis 	/* If the lease came from the config file, we don't need to stash
194547c08596SBrooks Davis 	   a copy in the lease database. */
194647c08596SBrooks Davis 	if (lease->is_static)
194747c08596SBrooks Davis 		return;
194847c08596SBrooks Davis 
194947c08596SBrooks Davis 	if (!leaseFile) {	/* XXX */
195047c08596SBrooks Davis 		leaseFile = fopen(path_dhclient_db, "w");
195147c08596SBrooks Davis 		if (!leaseFile)
195247c08596SBrooks Davis 			error("can't create %s: %m", path_dhclient_db);
195347c08596SBrooks Davis 	}
195447c08596SBrooks Davis 
195547c08596SBrooks Davis 	fprintf(leaseFile, "lease {\n");
195647c08596SBrooks Davis 	if (lease->is_bootp)
195747c08596SBrooks Davis 		fprintf(leaseFile, "  bootp;\n");
195847c08596SBrooks Davis 	fprintf(leaseFile, "  interface \"%s\";\n", ip->name);
195947c08596SBrooks Davis 	fprintf(leaseFile, "  fixed-address %s;\n", piaddr(lease->address));
1960d32438c3SBruce M Simpson 	if (lease->nextserver.len == sizeof(inaddr_any) &&
1961d32438c3SBruce M Simpson 	    0 != memcmp(lease->nextserver.iabuf, &inaddr_any,
1962d32438c3SBruce M Simpson 	    sizeof(inaddr_any)))
1963d32438c3SBruce M Simpson 		fprintf(leaseFile, "  next-server %s;\n",
1964d32438c3SBruce M Simpson 		    piaddr(lease->nextserver));
196547c08596SBrooks Davis 	if (lease->filename)
196647c08596SBrooks Davis 		fprintf(leaseFile, "  filename \"%s\";\n", lease->filename);
196747c08596SBrooks Davis 	if (lease->server_name)
196847c08596SBrooks Davis 		fprintf(leaseFile, "  server-name \"%s\";\n",
196947c08596SBrooks Davis 		    lease->server_name);
197047c08596SBrooks Davis 	if (lease->medium)
197147c08596SBrooks Davis 		fprintf(leaseFile, "  medium \"%s\";\n", lease->medium->string);
197247c08596SBrooks Davis 	for (i = 0; i < 256; i++)
197347c08596SBrooks Davis 		if (lease->options[i].len)
197447c08596SBrooks Davis 			fprintf(leaseFile, "  option %s %s;\n",
197547c08596SBrooks Davis 			    dhcp_options[i].name,
197647c08596SBrooks Davis 			    pretty_print_option(i, lease->options[i].data,
197747c08596SBrooks Davis 			    lease->options[i].len, 1, 1));
197847c08596SBrooks Davis 
197947c08596SBrooks Davis 	t = gmtime(&lease->renewal);
198047c08596SBrooks Davis 	fprintf(leaseFile, "  renew %d %d/%d/%d %02d:%02d:%02d;\n",
198147c08596SBrooks Davis 	    t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
198247c08596SBrooks Davis 	    t->tm_hour, t->tm_min, t->tm_sec);
198347c08596SBrooks Davis 	t = gmtime(&lease->rebind);
198447c08596SBrooks Davis 	fprintf(leaseFile, "  rebind %d %d/%d/%d %02d:%02d:%02d;\n",
198547c08596SBrooks Davis 	    t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
198647c08596SBrooks Davis 	    t->tm_hour, t->tm_min, t->tm_sec);
198747c08596SBrooks Davis 	t = gmtime(&lease->expiry);
198847c08596SBrooks Davis 	fprintf(leaseFile, "  expire %d %d/%d/%d %02d:%02d:%02d;\n",
198947c08596SBrooks Davis 	    t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
199047c08596SBrooks Davis 	    t->tm_hour, t->tm_min, t->tm_sec);
199147c08596SBrooks Davis 	fprintf(leaseFile, "}\n");
199247c08596SBrooks Davis 	fflush(leaseFile);
199347c08596SBrooks Davis }
199447c08596SBrooks Davis 
199547c08596SBrooks Davis void
199647c08596SBrooks Davis script_init(char *reason, struct string_list *medium)
199747c08596SBrooks Davis {
199847c08596SBrooks Davis 	size_t		 len, mediumlen = 0;
199947c08596SBrooks Davis 	struct imsg_hdr	 hdr;
200047c08596SBrooks Davis 	struct buf	*buf;
200147c08596SBrooks Davis 	int		 errs;
200247c08596SBrooks Davis 
200347c08596SBrooks Davis 	if (medium != NULL && medium->string != NULL)
200447c08596SBrooks Davis 		mediumlen = strlen(medium->string);
200547c08596SBrooks Davis 
200647c08596SBrooks Davis 	hdr.code = IMSG_SCRIPT_INIT;
200747c08596SBrooks Davis 	hdr.len = sizeof(struct imsg_hdr) +
200847c08596SBrooks Davis 	    sizeof(size_t) + mediumlen +
200947c08596SBrooks Davis 	    sizeof(size_t) + strlen(reason);
201047c08596SBrooks Davis 
201147c08596SBrooks Davis 	if ((buf = buf_open(hdr.len)) == NULL)
201247c08596SBrooks Davis 		error("buf_open: %m");
201347c08596SBrooks Davis 
201447c08596SBrooks Davis 	errs = 0;
201547c08596SBrooks Davis 	errs += buf_add(buf, &hdr, sizeof(hdr));
201647c08596SBrooks Davis 	errs += buf_add(buf, &mediumlen, sizeof(mediumlen));
201747c08596SBrooks Davis 	if (mediumlen > 0)
201847c08596SBrooks Davis 		errs += buf_add(buf, medium->string, mediumlen);
201947c08596SBrooks Davis 	len = strlen(reason);
202047c08596SBrooks Davis 	errs += buf_add(buf, &len, sizeof(len));
202147c08596SBrooks Davis 	errs += buf_add(buf, reason, len);
202247c08596SBrooks Davis 
202347c08596SBrooks Davis 	if (errs)
202447c08596SBrooks Davis 		error("buf_add: %m");
202547c08596SBrooks Davis 
202647c08596SBrooks Davis 	if (buf_close(privfd, buf) == -1)
202747c08596SBrooks Davis 		error("buf_close: %m");
202847c08596SBrooks Davis }
202947c08596SBrooks Davis 
203047c08596SBrooks Davis void
203147c08596SBrooks Davis priv_script_init(char *reason, char *medium)
203247c08596SBrooks Davis {
203347c08596SBrooks Davis 	struct interface_info *ip = ifi;
203447c08596SBrooks Davis 
203547c08596SBrooks Davis 	if (ip) {
203647c08596SBrooks Davis 		ip->client->scriptEnvsize = 100;
203747c08596SBrooks Davis 		if (ip->client->scriptEnv == NULL)
203847c08596SBrooks Davis 			ip->client->scriptEnv =
203947c08596SBrooks Davis 			    malloc(ip->client->scriptEnvsize * sizeof(char *));
204047c08596SBrooks Davis 		if (ip->client->scriptEnv == NULL)
204147c08596SBrooks Davis 			error("script_init: no memory for environment");
204247c08596SBrooks Davis 
204347c08596SBrooks Davis 		ip->client->scriptEnv[0] = strdup(CLIENT_PATH);
204447c08596SBrooks Davis 		if (ip->client->scriptEnv[0] == NULL)
204547c08596SBrooks Davis 			error("script_init: no memory for environment");
204647c08596SBrooks Davis 
204747c08596SBrooks Davis 		ip->client->scriptEnv[1] = NULL;
204847c08596SBrooks Davis 
204947c08596SBrooks Davis 		script_set_env(ip->client, "", "interface", ip->name);
205047c08596SBrooks Davis 
205147c08596SBrooks Davis 		if (medium)
205247c08596SBrooks Davis 			script_set_env(ip->client, "", "medium", medium);
205347c08596SBrooks Davis 
205447c08596SBrooks Davis 		script_set_env(ip->client, "", "reason", reason);
205547c08596SBrooks Davis 	}
205647c08596SBrooks Davis }
205747c08596SBrooks Davis 
205847c08596SBrooks Davis void
205947c08596SBrooks Davis priv_script_write_params(char *prefix, struct client_lease *lease)
206047c08596SBrooks Davis {
206147c08596SBrooks Davis 	struct interface_info *ip = ifi;
206240767e22SBrooks Davis 	u_int8_t dbuf[1500], *dp = NULL;
2063afe6f835SAlan Somers 	int i;
2064afe6f835SAlan Somers 	size_t len;
206547c08596SBrooks Davis 	char tbuf[128];
206647c08596SBrooks Davis 
206747c08596SBrooks Davis 	script_set_env(ip->client, prefix, "ip_address",
206847c08596SBrooks Davis 	    piaddr(lease->address));
206947c08596SBrooks Davis 
207040767e22SBrooks Davis 	if (ip->client->config->default_actions[DHO_SUBNET_MASK] ==
207140767e22SBrooks Davis 	    ACTION_SUPERSEDE) {
207240767e22SBrooks Davis 		dp = ip->client->config->defaults[DHO_SUBNET_MASK].data;
207340767e22SBrooks Davis 		len = ip->client->config->defaults[DHO_SUBNET_MASK].len;
207440767e22SBrooks Davis 	} else {
207540767e22SBrooks Davis 		dp = lease->options[DHO_SUBNET_MASK].data;
207640767e22SBrooks Davis 		len = lease->options[DHO_SUBNET_MASK].len;
207740767e22SBrooks Davis 	}
207840767e22SBrooks Davis 	if (len && (len < sizeof(lease->address.iabuf))) {
207947c08596SBrooks Davis 		struct iaddr netmask, subnet, broadcast;
208047c08596SBrooks Davis 
208140767e22SBrooks Davis 		memcpy(netmask.iabuf, dp, len);
208240767e22SBrooks Davis 		netmask.len = len;
208347c08596SBrooks Davis 		subnet = subnet_number(lease->address, netmask);
208447c08596SBrooks Davis 		if (subnet.len) {
208547c08596SBrooks Davis 			script_set_env(ip->client, prefix, "network_number",
208647c08596SBrooks Davis 			    piaddr(subnet));
208747c08596SBrooks Davis 			if (!lease->options[DHO_BROADCAST_ADDRESS].len) {
208847c08596SBrooks Davis 				broadcast = broadcast_addr(subnet, netmask);
208947c08596SBrooks Davis 				if (broadcast.len)
209047c08596SBrooks Davis 					script_set_env(ip->client, prefix,
209147c08596SBrooks Davis 					    "broadcast_address",
209247c08596SBrooks Davis 					    piaddr(broadcast));
209347c08596SBrooks Davis 			}
209447c08596SBrooks Davis 		}
209547c08596SBrooks Davis 	}
209647c08596SBrooks Davis 
209747c08596SBrooks Davis 	if (lease->filename)
209847c08596SBrooks Davis 		script_set_env(ip->client, prefix, "filename", lease->filename);
209947c08596SBrooks Davis 	if (lease->server_name)
210047c08596SBrooks Davis 		script_set_env(ip->client, prefix, "server_name",
210147c08596SBrooks Davis 		    lease->server_name);
210247c08596SBrooks Davis 	for (i = 0; i < 256; i++) {
210340767e22SBrooks Davis 		len = 0;
210447c08596SBrooks Davis 
210547c08596SBrooks Davis 		if (ip->client->config->defaults[i].len) {
210647c08596SBrooks Davis 			if (lease->options[i].len) {
210747c08596SBrooks Davis 				switch (
210847c08596SBrooks Davis 				    ip->client->config->default_actions[i]) {
210947c08596SBrooks Davis 				case ACTION_DEFAULT:
211047c08596SBrooks Davis 					dp = lease->options[i].data;
211147c08596SBrooks Davis 					len = lease->options[i].len;
211247c08596SBrooks Davis 					break;
211347c08596SBrooks Davis 				case ACTION_SUPERSEDE:
211447c08596SBrooks Davis supersede:
211547c08596SBrooks Davis 					dp = ip->client->
211647c08596SBrooks Davis 						config->defaults[i].data;
211747c08596SBrooks Davis 					len = ip->client->
211847c08596SBrooks Davis 						config->defaults[i].len;
211947c08596SBrooks Davis 					break;
212047c08596SBrooks Davis 				case ACTION_PREPEND:
212147c08596SBrooks Davis 					len = ip->client->
212247c08596SBrooks Davis 					    config->defaults[i].len +
212347c08596SBrooks Davis 					    lease->options[i].len;
2124043bcc8dSBrian Somers 					if (len >= sizeof(dbuf)) {
212547c08596SBrooks Davis 						warning("no space to %s %s",
212647c08596SBrooks Davis 						    "prepend option",
212747c08596SBrooks Davis 						    dhcp_options[i].name);
212847c08596SBrooks Davis 						goto supersede;
212947c08596SBrooks Davis 					}
213047c08596SBrooks Davis 					dp = dbuf;
213147c08596SBrooks Davis 					memcpy(dp,
213247c08596SBrooks Davis 						ip->client->
213347c08596SBrooks Davis 						config->defaults[i].data,
213447c08596SBrooks Davis 						ip->client->
213547c08596SBrooks Davis 						config->defaults[i].len);
213647c08596SBrooks Davis 					memcpy(dp + ip->client->
213747c08596SBrooks Davis 						config->defaults[i].len,
213847c08596SBrooks Davis 						lease->options[i].data,
213947c08596SBrooks Davis 						lease->options[i].len);
214047c08596SBrooks Davis 					dp[len] = '\0';
214147c08596SBrooks Davis 					break;
214247c08596SBrooks Davis 				case ACTION_APPEND:
2143043bcc8dSBrian Somers 					/*
2144043bcc8dSBrian Somers 					 * When we append, we assume that we're
2145043bcc8dSBrian Somers 					 * appending to text.  Some MS servers
2146043bcc8dSBrian Somers 					 * include a NUL byte at the end of
2147043bcc8dSBrian Somers 					 * the search string provided.
2148043bcc8dSBrian Somers 					 */
214947c08596SBrooks Davis 					len = ip->client->
215047c08596SBrooks Davis 					    config->defaults[i].len +
215147c08596SBrooks Davis 					    lease->options[i].len;
2152043bcc8dSBrian Somers 					if (len >= sizeof(dbuf)) {
215347c08596SBrooks Davis 						warning("no space to %s %s",
215447c08596SBrooks Davis 						    "append option",
215547c08596SBrooks Davis 						    dhcp_options[i].name);
215647c08596SBrooks Davis 						goto supersede;
215747c08596SBrooks Davis 					}
2158043bcc8dSBrian Somers 					memcpy(dbuf,
215947c08596SBrooks Davis 						lease->options[i].data,
216047c08596SBrooks Davis 						lease->options[i].len);
2161043bcc8dSBrian Somers 					for (dp = dbuf + lease->options[i].len;
2162043bcc8dSBrian Somers 					    dp > dbuf; dp--, len--)
2163043bcc8dSBrian Somers 						if (dp[-1] != '\0')
2164043bcc8dSBrian Somers 							break;
2165043bcc8dSBrian Somers 					memcpy(dp,
216647c08596SBrooks Davis 						ip->client->
216747c08596SBrooks Davis 						config->defaults[i].data,
216847c08596SBrooks Davis 						ip->client->
216947c08596SBrooks Davis 						config->defaults[i].len);
2170043bcc8dSBrian Somers 					dp = dbuf;
217147c08596SBrooks Davis 					dp[len] = '\0';
217247c08596SBrooks Davis 				}
217347c08596SBrooks Davis 			} else {
217447c08596SBrooks Davis 				dp = ip->client->
217547c08596SBrooks Davis 					config->defaults[i].data;
217647c08596SBrooks Davis 				len = ip->client->
217747c08596SBrooks Davis 					config->defaults[i].len;
217847c08596SBrooks Davis 			}
217947c08596SBrooks Davis 		} else if (lease->options[i].len) {
218047c08596SBrooks Davis 			len = lease->options[i].len;
218147c08596SBrooks Davis 			dp = lease->options[i].data;
218247c08596SBrooks Davis 		} else {
218347c08596SBrooks Davis 			len = 0;
218447c08596SBrooks Davis 		}
218547c08596SBrooks Davis 		if (len) {
218647c08596SBrooks Davis 			char name[256];
218747c08596SBrooks Davis 
218847c08596SBrooks Davis 			if (dhcp_option_ev_name(name, sizeof(name),
218947c08596SBrooks Davis 			    &dhcp_options[i]))
219047c08596SBrooks Davis 				script_set_env(ip->client, prefix, name,
219147c08596SBrooks Davis 				    pretty_print_option(i, dp, len, 0, 0));
219247c08596SBrooks Davis 		}
219347c08596SBrooks Davis 	}
219447c08596SBrooks Davis 	snprintf(tbuf, sizeof(tbuf), "%d", (int)lease->expiry);
219547c08596SBrooks Davis 	script_set_env(ip->client, prefix, "expiry", tbuf);
219647c08596SBrooks Davis }
219747c08596SBrooks Davis 
219847c08596SBrooks Davis void
219947c08596SBrooks Davis script_write_params(char *prefix, struct client_lease *lease)
220047c08596SBrooks Davis {
220147c08596SBrooks Davis 	size_t		 fn_len = 0, sn_len = 0, pr_len = 0;
220247c08596SBrooks Davis 	struct imsg_hdr	 hdr;
220347c08596SBrooks Davis 	struct buf	*buf;
220447c08596SBrooks Davis 	int		 errs, i;
220547c08596SBrooks Davis 
220647c08596SBrooks Davis 	if (lease->filename != NULL)
220747c08596SBrooks Davis 		fn_len = strlen(lease->filename);
220847c08596SBrooks Davis 	if (lease->server_name != NULL)
220947c08596SBrooks Davis 		sn_len = strlen(lease->server_name);
221047c08596SBrooks Davis 	if (prefix != NULL)
221147c08596SBrooks Davis 		pr_len = strlen(prefix);
221247c08596SBrooks Davis 
221347c08596SBrooks Davis 	hdr.code = IMSG_SCRIPT_WRITE_PARAMS;
2214afe6f835SAlan Somers 	hdr.len = sizeof(hdr) + sizeof(*lease) +
2215afe6f835SAlan Somers 	    sizeof(fn_len) + fn_len + sizeof(sn_len) + sn_len +
2216afe6f835SAlan Somers 	    sizeof(pr_len) + pr_len;
221747c08596SBrooks Davis 
2218afe6f835SAlan Somers 	for (i = 0; i < 256; i++) {
2219afe6f835SAlan Somers 		hdr.len += sizeof(lease->options[i].len);
2220afe6f835SAlan Somers 		hdr.len += lease->options[i].len;
2221afe6f835SAlan Somers 	}
222247c08596SBrooks Davis 
222347c08596SBrooks Davis 	scripttime = time(NULL);
222447c08596SBrooks Davis 
222547c08596SBrooks Davis 	if ((buf = buf_open(hdr.len)) == NULL)
222647c08596SBrooks Davis 		error("buf_open: %m");
222747c08596SBrooks Davis 
222847c08596SBrooks Davis 	errs = 0;
222947c08596SBrooks Davis 	errs += buf_add(buf, &hdr, sizeof(hdr));
2230afe6f835SAlan Somers 	errs += buf_add(buf, lease, sizeof(*lease));
223147c08596SBrooks Davis 	errs += buf_add(buf, &fn_len, sizeof(fn_len));
223247c08596SBrooks Davis 	errs += buf_add(buf, lease->filename, fn_len);
223347c08596SBrooks Davis 	errs += buf_add(buf, &sn_len, sizeof(sn_len));
223447c08596SBrooks Davis 	errs += buf_add(buf, lease->server_name, sn_len);
223547c08596SBrooks Davis 	errs += buf_add(buf, &pr_len, sizeof(pr_len));
223647c08596SBrooks Davis 	errs += buf_add(buf, prefix, pr_len);
223747c08596SBrooks Davis 
223847c08596SBrooks Davis 	for (i = 0; i < 256; i++) {
223947c08596SBrooks Davis 		errs += buf_add(buf, &lease->options[i].len,
224047c08596SBrooks Davis 		    sizeof(lease->options[i].len));
224147c08596SBrooks Davis 		errs += buf_add(buf, lease->options[i].data,
224247c08596SBrooks Davis 		    lease->options[i].len);
224347c08596SBrooks Davis 	}
224447c08596SBrooks Davis 
224547c08596SBrooks Davis 	if (errs)
224647c08596SBrooks Davis 		error("buf_add: %m");
224747c08596SBrooks Davis 
224847c08596SBrooks Davis 	if (buf_close(privfd, buf) == -1)
224947c08596SBrooks Davis 		error("buf_close: %m");
225047c08596SBrooks Davis }
225147c08596SBrooks Davis 
225247c08596SBrooks Davis int
225347c08596SBrooks Davis script_go(void)
225447c08596SBrooks Davis {
225547c08596SBrooks Davis 	struct imsg_hdr	 hdr;
225647c08596SBrooks Davis 	struct buf	*buf;
225747c08596SBrooks Davis 	int		 ret;
225847c08596SBrooks Davis 
225947c08596SBrooks Davis 	hdr.code = IMSG_SCRIPT_GO;
226047c08596SBrooks Davis 	hdr.len = sizeof(struct imsg_hdr);
226147c08596SBrooks Davis 
226247c08596SBrooks Davis 	if ((buf = buf_open(hdr.len)) == NULL)
226347c08596SBrooks Davis 		error("buf_open: %m");
226447c08596SBrooks Davis 
226547c08596SBrooks Davis 	if (buf_add(buf, &hdr, sizeof(hdr)))
226647c08596SBrooks Davis 		error("buf_add: %m");
226747c08596SBrooks Davis 
226847c08596SBrooks Davis 	if (buf_close(privfd, buf) == -1)
226947c08596SBrooks Davis 		error("buf_close: %m");
227047c08596SBrooks Davis 
227147c08596SBrooks Davis 	bzero(&hdr, sizeof(hdr));
227247c08596SBrooks Davis 	buf_read(privfd, &hdr, sizeof(hdr));
227347c08596SBrooks Davis 	if (hdr.code != IMSG_SCRIPT_GO_RET)
227447c08596SBrooks Davis 		error("unexpected msg type %u", hdr.code);
227547c08596SBrooks Davis 	if (hdr.len != sizeof(hdr) + sizeof(int))
227647c08596SBrooks Davis 		error("received corrupted message");
227747c08596SBrooks Davis 	buf_read(privfd, &ret, sizeof(ret));
227847c08596SBrooks Davis 
22796964abefSBrian Somers 	scripttime = time(NULL);
22806964abefSBrian Somers 
228147c08596SBrooks Davis 	return (ret);
228247c08596SBrooks Davis }
228347c08596SBrooks Davis 
228447c08596SBrooks Davis int
228547c08596SBrooks Davis priv_script_go(void)
228647c08596SBrooks Davis {
228747c08596SBrooks Davis 	char *scriptName, *argv[2], **envp, *epp[3], reason[] = "REASON=NBI";
228847c08596SBrooks Davis 	static char client_path[] = CLIENT_PATH;
228947c08596SBrooks Davis 	struct interface_info *ip = ifi;
229047c08596SBrooks Davis 	int pid, wpid, wstatus;
229147c08596SBrooks Davis 
229247c08596SBrooks Davis 	scripttime = time(NULL);
229347c08596SBrooks Davis 
229447c08596SBrooks Davis 	if (ip) {
229547c08596SBrooks Davis 		scriptName = ip->client->config->script_name;
229647c08596SBrooks Davis 		envp = ip->client->scriptEnv;
229747c08596SBrooks Davis 	} else {
229847c08596SBrooks Davis 		scriptName = top_level_config.script_name;
229947c08596SBrooks Davis 		epp[0] = reason;
230047c08596SBrooks Davis 		epp[1] = client_path;
230147c08596SBrooks Davis 		epp[2] = NULL;
230247c08596SBrooks Davis 		envp = epp;
230347c08596SBrooks Davis 	}
230447c08596SBrooks Davis 
230547c08596SBrooks Davis 	argv[0] = scriptName;
230647c08596SBrooks Davis 	argv[1] = NULL;
230747c08596SBrooks Davis 
230847c08596SBrooks Davis 	pid = fork();
230947c08596SBrooks Davis 	if (pid < 0) {
231047c08596SBrooks Davis 		error("fork: %m");
231147c08596SBrooks Davis 		wstatus = 0;
231247c08596SBrooks Davis 	} else if (pid) {
231347c08596SBrooks Davis 		do {
231447c08596SBrooks Davis 			wpid = wait(&wstatus);
231547c08596SBrooks Davis 		} while (wpid != pid && wpid > 0);
231647c08596SBrooks Davis 		if (wpid < 0) {
231747c08596SBrooks Davis 			error("wait: %m");
231847c08596SBrooks Davis 			wstatus = 0;
231947c08596SBrooks Davis 		}
232047c08596SBrooks Davis 	} else {
232147c08596SBrooks Davis 		execve(scriptName, argv, envp);
232247c08596SBrooks Davis 		error("execve (%s, ...): %m", scriptName);
232347c08596SBrooks Davis 	}
232447c08596SBrooks Davis 
232547c08596SBrooks Davis 	if (ip)
232647c08596SBrooks Davis 		script_flush_env(ip->client);
232747c08596SBrooks Davis 
232847c08596SBrooks Davis 	return (wstatus & 0xff);
232947c08596SBrooks Davis }
233047c08596SBrooks Davis 
233147c08596SBrooks Davis void
233247c08596SBrooks Davis script_set_env(struct client_state *client, const char *prefix,
233347c08596SBrooks Davis     const char *name, const char *value)
233447c08596SBrooks Davis {
2335afe6f835SAlan Somers 	int i, namelen;
2336afe6f835SAlan Somers 	size_t j;
233747c08596SBrooks Davis 
2338dd09ce39SSepherosa Ziehau 	/* No `` or $() command substitution allowed in environment values! */
2339dd09ce39SSepherosa Ziehau 	for (j=0; j < strlen(value); j++)
2340dd09ce39SSepherosa Ziehau 		switch (value[j]) {
2341dd09ce39SSepherosa Ziehau 		case '`':
2342dd09ce39SSepherosa Ziehau 		case '$':
2343dd09ce39SSepherosa Ziehau 			warning("illegal character (%c) in value '%s'",
2344dd09ce39SSepherosa Ziehau 			    value[j], value);
2345dd09ce39SSepherosa Ziehau 			/* Ignore this option */
2346dd09ce39SSepherosa Ziehau 			return;
2347dd09ce39SSepherosa Ziehau 		}
2348dd09ce39SSepherosa Ziehau 
234947c08596SBrooks Davis 	namelen = strlen(name);
235047c08596SBrooks Davis 
235147c08596SBrooks Davis 	for (i = 0; client->scriptEnv[i]; i++)
235247c08596SBrooks Davis 		if (strncmp(client->scriptEnv[i], name, namelen) == 0 &&
235347c08596SBrooks Davis 		    client->scriptEnv[i][namelen] == '=')
235447c08596SBrooks Davis 			break;
235547c08596SBrooks Davis 
235647c08596SBrooks Davis 	if (client->scriptEnv[i])
235747c08596SBrooks Davis 		/* Reuse the slot. */
235847c08596SBrooks Davis 		free(client->scriptEnv[i]);
235947c08596SBrooks Davis 	else {
236047c08596SBrooks Davis 		/* New variable.  Expand if necessary. */
236147c08596SBrooks Davis 		if (i >= client->scriptEnvsize - 1) {
236247c08596SBrooks Davis 			char **newscriptEnv;
236347c08596SBrooks Davis 			int newscriptEnvsize = client->scriptEnvsize + 50;
236447c08596SBrooks Davis 
236547c08596SBrooks Davis 			newscriptEnv = realloc(client->scriptEnv,
236647c08596SBrooks Davis 			    newscriptEnvsize);
236747c08596SBrooks Davis 			if (newscriptEnv == NULL) {
236847c08596SBrooks Davis 				free(client->scriptEnv);
236947c08596SBrooks Davis 				client->scriptEnv = NULL;
237047c08596SBrooks Davis 				client->scriptEnvsize = 0;
237147c08596SBrooks Davis 				error("script_set_env: no memory for variable");
237247c08596SBrooks Davis 			}
237347c08596SBrooks Davis 			client->scriptEnv = newscriptEnv;
237447c08596SBrooks Davis 			client->scriptEnvsize = newscriptEnvsize;
237547c08596SBrooks Davis 		}
237647c08596SBrooks Davis 		/* need to set the NULL pointer at end of array beyond
237747c08596SBrooks Davis 		   the new slot. */
237847c08596SBrooks Davis 		client->scriptEnv[i + 1] = NULL;
237947c08596SBrooks Davis 	}
238047c08596SBrooks Davis 	/* Allocate space and format the variable in the appropriate slot. */
238147c08596SBrooks Davis 	client->scriptEnv[i] = malloc(strlen(prefix) + strlen(name) + 1 +
238247c08596SBrooks Davis 	    strlen(value) + 1);
238347c08596SBrooks Davis 	if (client->scriptEnv[i] == NULL)
238447c08596SBrooks Davis 		error("script_set_env: no memory for variable assignment");
238547c08596SBrooks Davis 	snprintf(client->scriptEnv[i], strlen(prefix) + strlen(name) +
238647c08596SBrooks Davis 	    1 + strlen(value) + 1, "%s%s=%s", prefix, name, value);
238747c08596SBrooks Davis }
238847c08596SBrooks Davis 
238947c08596SBrooks Davis void
239047c08596SBrooks Davis script_flush_env(struct client_state *client)
239147c08596SBrooks Davis {
239247c08596SBrooks Davis 	int i;
239347c08596SBrooks Davis 
239447c08596SBrooks Davis 	for (i = 0; client->scriptEnv[i]; i++) {
239547c08596SBrooks Davis 		free(client->scriptEnv[i]);
239647c08596SBrooks Davis 		client->scriptEnv[i] = NULL;
239747c08596SBrooks Davis 	}
239847c08596SBrooks Davis 	client->scriptEnvsize = 0;
239947c08596SBrooks Davis }
240047c08596SBrooks Davis 
240147c08596SBrooks Davis int
240247c08596SBrooks Davis dhcp_option_ev_name(char *buf, size_t buflen, struct option *option)
240347c08596SBrooks Davis {
2404afe6f835SAlan Somers 	size_t i;
240547c08596SBrooks Davis 
240647c08596SBrooks Davis 	for (i = 0; option->name[i]; i++) {
240747c08596SBrooks Davis 		if (i + 1 == buflen)
240847c08596SBrooks Davis 			return 0;
240947c08596SBrooks Davis 		if (option->name[i] == '-')
241047c08596SBrooks Davis 			buf[i] = '_';
241147c08596SBrooks Davis 		else
241247c08596SBrooks Davis 			buf[i] = option->name[i];
241347c08596SBrooks Davis 	}
241447c08596SBrooks Davis 
241547c08596SBrooks Davis 	buf[i] = 0;
241647c08596SBrooks Davis 	return 1;
241747c08596SBrooks Davis }
241847c08596SBrooks Davis 
241947c08596SBrooks Davis void
242047c08596SBrooks Davis go_daemon(void)
242147c08596SBrooks Davis {
242247c08596SBrooks Davis 	static int state = 0;
24237008be5bSPawel Jakub Dawidek 	cap_rights_t rights;
242447c08596SBrooks Davis 
242547c08596SBrooks Davis 	if (no_daemon || state)
242647c08596SBrooks Davis 		return;
242747c08596SBrooks Davis 
242847c08596SBrooks Davis 	state = 1;
242947c08596SBrooks Davis 
243047c08596SBrooks Davis 	/* Stop logging to stderr... */
243147c08596SBrooks Davis 	log_perror = 0;
243247c08596SBrooks Davis 
2433*31698405SMariusz Zaborski 	if (daemonfd(-1, nullfd) == -1)
243447c08596SBrooks Davis 		error("daemon");
243547c08596SBrooks Davis 
24367008be5bSPawel Jakub Dawidek 	cap_rights_init(&rights);
24377008be5bSPawel Jakub Dawidek 
24384c7a48b7SPawel Jakub Dawidek 	if (pidfile != NULL) {
243923f39c90SDag-Erling Smørgrav 		pidfile_write(pidfile);
24407008be5bSPawel Jakub Dawidek 		if (cap_rights_limit(pidfile_fileno(pidfile), &rights) < 0 &&
24414c7a48b7SPawel Jakub Dawidek 		    errno != ENOSYS) {
24424c7a48b7SPawel Jakub Dawidek 			error("can't limit pidfile descriptor: %m");
24434c7a48b7SPawel Jakub Dawidek 		}
24444c7a48b7SPawel Jakub Dawidek 	}
244523f39c90SDag-Erling Smørgrav 
244647c08596SBrooks Davis 	if (nullfd != -1) {
244747c08596SBrooks Davis 		close(nullfd);
244847c08596SBrooks Davis 		nullfd = -1;
244947c08596SBrooks Davis 	}
2450a6f38228SPawel Jakub Dawidek 
24517008be5bSPawel Jakub Dawidek 	if (cap_rights_limit(STDIN_FILENO, &rights) < 0 && errno != ENOSYS)
2452a6f38228SPawel Jakub Dawidek 		error("can't limit stdin: %m");
24537008be5bSPawel Jakub Dawidek 	cap_rights_init(&rights, CAP_WRITE);
24547008be5bSPawel Jakub Dawidek 	if (cap_rights_limit(STDOUT_FILENO, &rights) < 0 && errno != ENOSYS)
2455a6f38228SPawel Jakub Dawidek 		error("can't limit stdout: %m");
24567008be5bSPawel Jakub Dawidek 	if (cap_rights_limit(STDERR_FILENO, &rights) < 0 && errno != ENOSYS)
2457a6f38228SPawel Jakub Dawidek 		error("can't limit stderr: %m");
245847c08596SBrooks Davis }
245947c08596SBrooks Davis 
246047c08596SBrooks Davis int
246147c08596SBrooks Davis check_option(struct client_lease *l, int option)
246247c08596SBrooks Davis {
246347c08596SBrooks Davis 	char *opbuf;
246447c08596SBrooks Davis 	char *sbuf;
246547c08596SBrooks Davis 
246647c08596SBrooks Davis 	/* we use this, since this is what gets passed to dhclient-script */
246747c08596SBrooks Davis 
246847c08596SBrooks Davis 	opbuf = pretty_print_option(option, l->options[option].data,
246947c08596SBrooks Davis 	    l->options[option].len, 0, 0);
247047c08596SBrooks Davis 
247147c08596SBrooks Davis 	sbuf = option_as_string(option, l->options[option].data,
247247c08596SBrooks Davis 	    l->options[option].len);
247347c08596SBrooks Davis 
247447c08596SBrooks Davis 	switch (option) {
247547c08596SBrooks Davis 	case DHO_SUBNET_MASK:
247647c08596SBrooks Davis 	case DHO_TIME_SERVERS:
247747c08596SBrooks Davis 	case DHO_NAME_SERVERS:
247847c08596SBrooks Davis 	case DHO_ROUTERS:
247947c08596SBrooks Davis 	case DHO_DOMAIN_NAME_SERVERS:
248047c08596SBrooks Davis 	case DHO_LOG_SERVERS:
248147c08596SBrooks Davis 	case DHO_COOKIE_SERVERS:
248247c08596SBrooks Davis 	case DHO_LPR_SERVERS:
248347c08596SBrooks Davis 	case DHO_IMPRESS_SERVERS:
248447c08596SBrooks Davis 	case DHO_RESOURCE_LOCATION_SERVERS:
248547c08596SBrooks Davis 	case DHO_SWAP_SERVER:
248647c08596SBrooks Davis 	case DHO_BROADCAST_ADDRESS:
248747c08596SBrooks Davis 	case DHO_NIS_SERVERS:
248847c08596SBrooks Davis 	case DHO_NTP_SERVERS:
248947c08596SBrooks Davis 	case DHO_NETBIOS_NAME_SERVERS:
249047c08596SBrooks Davis 	case DHO_NETBIOS_DD_SERVER:
249147c08596SBrooks Davis 	case DHO_FONT_SERVERS:
249247c08596SBrooks Davis 	case DHO_DHCP_SERVER_IDENTIFIER:
249338e755fdSBrooks Davis 	case DHO_NISPLUS_SERVERS:
249438e755fdSBrooks Davis 	case DHO_MOBILE_IP_HOME_AGENT:
2495a36c0b6bSBrooks Davis 	case DHO_SMTP_SERVER:
2496a36c0b6bSBrooks Davis 	case DHO_POP_SERVER:
2497a36c0b6bSBrooks Davis 	case DHO_NNTP_SERVER:
2498a36c0b6bSBrooks Davis 	case DHO_WWW_SERVER:
2499a36c0b6bSBrooks Davis 	case DHO_FINGER_SERVER:
2500a36c0b6bSBrooks Davis 	case DHO_IRC_SERVER:
250138e755fdSBrooks Davis 	case DHO_STREETTALK_SERVER:
250238e755fdSBrooks Davis 	case DHO_STREETTALK_DA_SERVER:
250347c08596SBrooks Davis 		if (!ipv4addrs(opbuf)) {
250447c08596SBrooks Davis 			warning("Invalid IP address in option: %s", opbuf);
250547c08596SBrooks Davis 			return (0);
250647c08596SBrooks Davis 		}
250747c08596SBrooks Davis 		return (1)  ;
250847c08596SBrooks Davis 	case DHO_HOST_NAME:
250947c08596SBrooks Davis 	case DHO_NIS_DOMAIN:
251038e755fdSBrooks Davis 	case DHO_NISPLUS_DOMAIN:
251138e755fdSBrooks Davis 	case DHO_TFTP_SERVER_NAME:
251247c08596SBrooks Davis 		if (!res_hnok(sbuf)) {
251347c08596SBrooks Davis 			warning("Bogus Host Name option %d: %s (%s)", option,
251447c08596SBrooks Davis 			    sbuf, opbuf);
251582dbbc41SBrooks Davis 			l->options[option].len = 0;
251682dbbc41SBrooks Davis 			free(l->options[option].data);
251747c08596SBrooks Davis 		}
251847c08596SBrooks Davis 		return (1);
2519b388f1cbSBrooks Davis 	case DHO_DOMAIN_NAME:
2520409139f0SJean-Sébastien Pédron 	case DHO_DOMAIN_SEARCH:
2521f954ec0bSBrooks Davis 		if (!res_hnok(sbuf)) {
2522f954ec0bSBrooks Davis 			if (!check_search(sbuf)) {
2523f954ec0bSBrooks Davis 				warning("Bogus domain search list %d: %s (%s)",
2524f954ec0bSBrooks Davis 				    option, sbuf, opbuf);
252582dbbc41SBrooks Davis 				l->options[option].len = 0;
252682dbbc41SBrooks Davis 				free(l->options[option].data);
2527f954ec0bSBrooks Davis 			}
2528f954ec0bSBrooks Davis 		}
2529f954ec0bSBrooks Davis 		return (1);
253047c08596SBrooks Davis 	case DHO_PAD:
253147c08596SBrooks Davis 	case DHO_TIME_OFFSET:
253247c08596SBrooks Davis 	case DHO_BOOT_SIZE:
253347c08596SBrooks Davis 	case DHO_MERIT_DUMP:
253447c08596SBrooks Davis 	case DHO_ROOT_PATH:
253547c08596SBrooks Davis 	case DHO_EXTENSIONS_PATH:
253647c08596SBrooks Davis 	case DHO_IP_FORWARDING:
253747c08596SBrooks Davis 	case DHO_NON_LOCAL_SOURCE_ROUTING:
253847c08596SBrooks Davis 	case DHO_POLICY_FILTER:
253947c08596SBrooks Davis 	case DHO_MAX_DGRAM_REASSEMBLY:
254047c08596SBrooks Davis 	case DHO_DEFAULT_IP_TTL:
254147c08596SBrooks Davis 	case DHO_PATH_MTU_AGING_TIMEOUT:
254247c08596SBrooks Davis 	case DHO_PATH_MTU_PLATEAU_TABLE:
254347c08596SBrooks Davis 	case DHO_INTERFACE_MTU:
254447c08596SBrooks Davis 	case DHO_ALL_SUBNETS_LOCAL:
254547c08596SBrooks Davis 	case DHO_PERFORM_MASK_DISCOVERY:
254647c08596SBrooks Davis 	case DHO_MASK_SUPPLIER:
254747c08596SBrooks Davis 	case DHO_ROUTER_DISCOVERY:
254847c08596SBrooks Davis 	case DHO_ROUTER_SOLICITATION_ADDRESS:
254947c08596SBrooks Davis 	case DHO_STATIC_ROUTES:
255047c08596SBrooks Davis 	case DHO_TRAILER_ENCAPSULATION:
255147c08596SBrooks Davis 	case DHO_ARP_CACHE_TIMEOUT:
255247c08596SBrooks Davis 	case DHO_IEEE802_3_ENCAPSULATION:
255347c08596SBrooks Davis 	case DHO_DEFAULT_TCP_TTL:
255447c08596SBrooks Davis 	case DHO_TCP_KEEPALIVE_INTERVAL:
255547c08596SBrooks Davis 	case DHO_TCP_KEEPALIVE_GARBAGE:
255647c08596SBrooks Davis 	case DHO_VENDOR_ENCAPSULATED_OPTIONS:
255747c08596SBrooks Davis 	case DHO_NETBIOS_NODE_TYPE:
255847c08596SBrooks Davis 	case DHO_NETBIOS_SCOPE:
255947c08596SBrooks Davis 	case DHO_X_DISPLAY_MANAGER:
256047c08596SBrooks Davis 	case DHO_DHCP_REQUESTED_ADDRESS:
256147c08596SBrooks Davis 	case DHO_DHCP_LEASE_TIME:
256247c08596SBrooks Davis 	case DHO_DHCP_OPTION_OVERLOAD:
256347c08596SBrooks Davis 	case DHO_DHCP_MESSAGE_TYPE:
256447c08596SBrooks Davis 	case DHO_DHCP_PARAMETER_REQUEST_LIST:
256547c08596SBrooks Davis 	case DHO_DHCP_MESSAGE:
256647c08596SBrooks Davis 	case DHO_DHCP_MAX_MESSAGE_SIZE:
256747c08596SBrooks Davis 	case DHO_DHCP_RENEWAL_TIME:
256847c08596SBrooks Davis 	case DHO_DHCP_REBINDING_TIME:
256947c08596SBrooks Davis 	case DHO_DHCP_CLASS_IDENTIFIER:
257047c08596SBrooks Davis 	case DHO_DHCP_CLIENT_IDENTIFIER:
257138e755fdSBrooks Davis 	case DHO_BOOTFILE_NAME:
257247c08596SBrooks Davis 	case DHO_DHCP_USER_CLASS_ID:
257347c08596SBrooks Davis 	case DHO_END:
257447c08596SBrooks Davis 		return (1);
25752fcc7370SEd Maste 	case DHO_CLASSLESS_ROUTES:
25762fcc7370SEd Maste 		return (check_classless_option(l->options[option].data,
25772fcc7370SEd Maste 		    l->options[option].len));
257847c08596SBrooks Davis 	default:
257947c08596SBrooks Davis 		warning("unknown dhcp option value 0x%x", option);
258047c08596SBrooks Davis 		return (unknown_ok);
258147c08596SBrooks Davis 	}
258247c08596SBrooks Davis }
258347c08596SBrooks Davis 
25842fcc7370SEd Maste /* RFC 3442 The Classless Static Routes option checks */
25852fcc7370SEd Maste int
25862fcc7370SEd Maste check_classless_option(unsigned char *data, int len)
25872fcc7370SEd Maste {
25882fcc7370SEd Maste 	int i = 0;
25892fcc7370SEd Maste 	unsigned char width;
25902fcc7370SEd Maste 	in_addr_t addr, mask;
25912fcc7370SEd Maste 
25922fcc7370SEd Maste 	if (len < 5) {
25932fcc7370SEd Maste 		warning("Too small length: %d", len);
25942fcc7370SEd Maste 		return (0);
25952fcc7370SEd Maste 	}
25962fcc7370SEd Maste 	while(i < len) {
25972fcc7370SEd Maste 		width = data[i++];
25982fcc7370SEd Maste 		if (width == 0) {
25992fcc7370SEd Maste 			i += 4;
26002fcc7370SEd Maste 			continue;
26012fcc7370SEd Maste 		} else if (width < 9) {
26022fcc7370SEd Maste 			addr =  (in_addr_t)(data[i]	<< 24);
26032fcc7370SEd Maste 			i += 1;
26042fcc7370SEd Maste 		} else if (width < 17) {
26052fcc7370SEd Maste 			addr =  (in_addr_t)(data[i]	<< 24) +
26062fcc7370SEd Maste 				(in_addr_t)(data[i + 1]	<< 16);
26072fcc7370SEd Maste 			i += 2;
26082fcc7370SEd Maste 		} else if (width < 25) {
26092fcc7370SEd Maste 			addr =  (in_addr_t)(data[i]	<< 24) +
26102fcc7370SEd Maste 				(in_addr_t)(data[i + 1]	<< 16) +
26112fcc7370SEd Maste 				(in_addr_t)(data[i + 2]	<< 8);
26122fcc7370SEd Maste 			i += 3;
26132fcc7370SEd Maste 		} else if (width < 33) {
26142fcc7370SEd Maste 			addr =  (in_addr_t)(data[i]	<< 24) +
26152fcc7370SEd Maste 				(in_addr_t)(data[i + 1]	<< 16) +
26162fcc7370SEd Maste 				(in_addr_t)(data[i + 2]	<< 8)  +
26172fcc7370SEd Maste 				data[i + 3];
26182fcc7370SEd Maste 			i += 4;
26192fcc7370SEd Maste 		} else {
26202fcc7370SEd Maste 			warning("Incorrect subnet width: %d", width);
26212fcc7370SEd Maste 			return (0);
26222fcc7370SEd Maste 		}
26232fcc7370SEd Maste 		mask = (in_addr_t)(~0) << (32 - width);
26242fcc7370SEd Maste 		addr = ntohl(addr);
26252fcc7370SEd Maste 		mask = ntohl(mask);
26262fcc7370SEd Maste 
26272fcc7370SEd Maste 		/*
26282fcc7370SEd Maste 		 * From RFC 3442:
26292fcc7370SEd Maste 		 * ... After deriving a subnet number and subnet mask
26302fcc7370SEd Maste 		 * from each destination descriptor, the DHCP client
26312fcc7370SEd Maste 		 * MUST zero any bits in the subnet number where the
26322fcc7370SEd Maste 		 * corresponding bit in the mask is zero...
26332fcc7370SEd Maste 		 */
26342fcc7370SEd Maste 		if ((addr & mask) != addr) {
26352fcc7370SEd Maste 			addr &= mask;
26362fcc7370SEd Maste 			data[i - 1] = (unsigned char)(
26372fcc7370SEd Maste 				(addr >> (((32 - width)/8)*8)) & 0xFF);
26382fcc7370SEd Maste 		}
26392fcc7370SEd Maste 		i += 4;
26402fcc7370SEd Maste 	}
26412fcc7370SEd Maste 	if (i > len) {
26422fcc7370SEd Maste 		warning("Incorrect data length: %d (must be %d)", len, i);
26432fcc7370SEd Maste 		return (0);
26442fcc7370SEd Maste 	}
26452fcc7370SEd Maste 	return (1);
26462fcc7370SEd Maste }
26472fcc7370SEd Maste 
264847c08596SBrooks Davis int
264947c08596SBrooks Davis res_hnok(const char *dn)
265047c08596SBrooks Davis {
265147c08596SBrooks Davis 	int pch = PERIOD, ch = *dn++;
265247c08596SBrooks Davis 
265347c08596SBrooks Davis 	while (ch != '\0') {
265447c08596SBrooks Davis 		int nch = *dn++;
265547c08596SBrooks Davis 
265647c08596SBrooks Davis 		if (periodchar(ch)) {
265747c08596SBrooks Davis 			;
265847c08596SBrooks Davis 		} else if (periodchar(pch)) {
265947c08596SBrooks Davis 			if (!borderchar(ch))
266047c08596SBrooks Davis 				return (0);
266147c08596SBrooks Davis 		} else if (periodchar(nch) || nch == '\0') {
266247c08596SBrooks Davis 			if (!borderchar(ch))
266347c08596SBrooks Davis 				return (0);
266447c08596SBrooks Davis 		} else {
266547c08596SBrooks Davis 			if (!middlechar(ch))
266647c08596SBrooks Davis 				return (0);
266747c08596SBrooks Davis 		}
266847c08596SBrooks Davis 		pch = ch, ch = nch;
266947c08596SBrooks Davis 	}
267047c08596SBrooks Davis 	return (1);
267147c08596SBrooks Davis }
267247c08596SBrooks Davis 
2673f954ec0bSBrooks Davis int
2674f954ec0bSBrooks Davis check_search(const char *srch)
2675f954ec0bSBrooks Davis {
2676f954ec0bSBrooks Davis         int pch = PERIOD, ch = *srch++;
2677f954ec0bSBrooks Davis 	int domains = 1;
2678f954ec0bSBrooks Davis 
2679f954ec0bSBrooks Davis 	/* 256 char limit re resolv.conf(5) */
2680f954ec0bSBrooks Davis 	if (strlen(srch) > 256)
2681f954ec0bSBrooks Davis 		return (0);
2682f954ec0bSBrooks Davis 
2683f954ec0bSBrooks Davis 	while (whitechar(ch))
2684f954ec0bSBrooks Davis 		ch = *srch++;
2685f954ec0bSBrooks Davis 
2686f954ec0bSBrooks Davis         while (ch != '\0') {
2687f954ec0bSBrooks Davis                 int nch = *srch++;
2688f954ec0bSBrooks Davis 
2689f954ec0bSBrooks Davis                 if (periodchar(ch) || whitechar(ch)) {
2690f954ec0bSBrooks Davis                         ;
2691f954ec0bSBrooks Davis                 } else if (periodchar(pch)) {
2692f954ec0bSBrooks Davis                         if (!borderchar(ch))
2693f954ec0bSBrooks Davis                                 return (0);
2694f954ec0bSBrooks Davis                 } else if (periodchar(nch) || nch == '\0') {
2695f954ec0bSBrooks Davis                         if (!borderchar(ch))
2696f954ec0bSBrooks Davis                                 return (0);
2697f954ec0bSBrooks Davis                 } else {
2698f954ec0bSBrooks Davis                         if (!middlechar(ch))
2699f954ec0bSBrooks Davis                                 return (0);
2700f954ec0bSBrooks Davis                 }
2701f954ec0bSBrooks Davis 		if (!whitechar(ch)) {
2702f954ec0bSBrooks Davis 			pch = ch;
2703f954ec0bSBrooks Davis 		} else {
2704f954ec0bSBrooks Davis 			while (whitechar(nch)) {
2705f954ec0bSBrooks Davis 				nch = *srch++;
2706f954ec0bSBrooks Davis 			}
2707f954ec0bSBrooks Davis 			if (nch != '\0')
2708f954ec0bSBrooks Davis 				domains++;
2709f954ec0bSBrooks Davis 			pch = PERIOD;
2710f954ec0bSBrooks Davis 		}
2711f954ec0bSBrooks Davis 		ch = nch;
2712f954ec0bSBrooks Davis         }
2713f954ec0bSBrooks Davis 	/* 6 domain limit re resolv.conf(5) */
2714f954ec0bSBrooks Davis 	if (domains > 6)
2715f954ec0bSBrooks Davis 		return (0);
2716f954ec0bSBrooks Davis         return (1);
2717f954ec0bSBrooks Davis }
2718f954ec0bSBrooks Davis 
271947c08596SBrooks Davis /* Does buf consist only of dotted decimal ipv4 addrs?
272047c08596SBrooks Davis  * return how many if so,
272147c08596SBrooks Davis  * otherwise, return 0
272247c08596SBrooks Davis  */
272347c08596SBrooks Davis int
272447c08596SBrooks Davis ipv4addrs(char * buf)
272547c08596SBrooks Davis {
272647c08596SBrooks Davis 	struct in_addr jnk;
272747c08596SBrooks Davis 	int count = 0;
272847c08596SBrooks Davis 
272947c08596SBrooks Davis 	while (inet_aton(buf, &jnk) == 1){
273047c08596SBrooks Davis 		count++;
273147c08596SBrooks Davis 		while (periodchar(*buf) || digitchar(*buf))
273247c08596SBrooks Davis 			buf++;
273347c08596SBrooks Davis 		if (*buf == '\0')
273447c08596SBrooks Davis 			return (count);
273547c08596SBrooks Davis 		while (*buf ==  ' ')
273647c08596SBrooks Davis 			buf++;
273747c08596SBrooks Davis 	}
273847c08596SBrooks Davis 	return (0);
273947c08596SBrooks Davis }
274047c08596SBrooks Davis 
274147c08596SBrooks Davis 
274247c08596SBrooks Davis char *
274347c08596SBrooks Davis option_as_string(unsigned int code, unsigned char *data, int len)
274447c08596SBrooks Davis {
274547c08596SBrooks Davis 	static char optbuf[32768]; /* XXX */
274647c08596SBrooks Davis 	char *op = optbuf;
274747c08596SBrooks Davis 	int opleft = sizeof(optbuf);
274847c08596SBrooks Davis 	unsigned char *dp = data;
274947c08596SBrooks Davis 
275047c08596SBrooks Davis 	if (code > 255)
275147c08596SBrooks Davis 		error("option_as_string: bad code %d", code);
275247c08596SBrooks Davis 
275347c08596SBrooks Davis 	for (; dp < data + len; dp++) {
275447c08596SBrooks Davis 		if (!isascii(*dp) || !isprint(*dp)) {
275547c08596SBrooks Davis 			if (dp + 1 != data + len || *dp != 0) {
275647c08596SBrooks Davis 				snprintf(op, opleft, "\\%03o", *dp);
275747c08596SBrooks Davis 				op += 4;
275847c08596SBrooks Davis 				opleft -= 4;
275947c08596SBrooks Davis 			}
276047c08596SBrooks Davis 		} else if (*dp == '"' || *dp == '\'' || *dp == '$' ||
276147c08596SBrooks Davis 		    *dp == '`' || *dp == '\\') {
276247c08596SBrooks Davis 			*op++ = '\\';
276347c08596SBrooks Davis 			*op++ = *dp;
276447c08596SBrooks Davis 			opleft -= 2;
276547c08596SBrooks Davis 		} else {
276647c08596SBrooks Davis 			*op++ = *dp;
276747c08596SBrooks Davis 			opleft--;
276847c08596SBrooks Davis 		}
276947c08596SBrooks Davis 	}
277047c08596SBrooks Davis 	if (opleft < 1)
277147c08596SBrooks Davis 		goto toobig;
277247c08596SBrooks Davis 	*op = 0;
277347c08596SBrooks Davis 	return optbuf;
277447c08596SBrooks Davis toobig:
277547c08596SBrooks Davis 	warning("dhcp option too large");
277647c08596SBrooks Davis 	return "<error>";
277747c08596SBrooks Davis }
277847c08596SBrooks Davis 
277947c08596SBrooks Davis int
278047c08596SBrooks Davis fork_privchld(int fd, int fd2)
278147c08596SBrooks Davis {
278247c08596SBrooks Davis 	struct pollfd pfd[1];
278347c08596SBrooks Davis 	int nfds;
278447c08596SBrooks Davis 
278547c08596SBrooks Davis 	switch (fork()) {
278647c08596SBrooks Davis 	case -1:
278747c08596SBrooks Davis 		error("cannot fork");
278847c08596SBrooks Davis 	case 0:
278947c08596SBrooks Davis 		break;
279047c08596SBrooks Davis 	default:
279147c08596SBrooks Davis 		return (0);
279247c08596SBrooks Davis 	}
279347c08596SBrooks Davis 
279447c08596SBrooks Davis 	setproctitle("%s [priv]", ifi->name);
279547c08596SBrooks Davis 
279670892546SEd Schouten 	setsid();
279747c08596SBrooks Davis 	dup2(nullfd, STDIN_FILENO);
279847c08596SBrooks Davis 	dup2(nullfd, STDOUT_FILENO);
279947c08596SBrooks Davis 	dup2(nullfd, STDERR_FILENO);
280047c08596SBrooks Davis 	close(nullfd);
280147c08596SBrooks Davis 	close(fd2);
2802235eb530SPawel Jakub Dawidek 	close(ifi->rfdesc);
2803235eb530SPawel Jakub Dawidek 	ifi->rfdesc = -1;
280447c08596SBrooks Davis 
280547c08596SBrooks Davis 	for (;;) {
280647c08596SBrooks Davis 		pfd[0].fd = fd;
280747c08596SBrooks Davis 		pfd[0].events = POLLIN;
280847c08596SBrooks Davis 		if ((nfds = poll(pfd, 1, INFTIM)) == -1)
280947c08596SBrooks Davis 			if (errno != EINTR)
281047c08596SBrooks Davis 				error("poll error");
281147c08596SBrooks Davis 
281247c08596SBrooks Davis 		if (nfds == 0 || !(pfd[0].revents & POLLIN))
281347c08596SBrooks Davis 			continue;
281447c08596SBrooks Davis 
2815235eb530SPawel Jakub Dawidek 		dispatch_imsg(ifi, fd);
281647c08596SBrooks Davis 	}
281747c08596SBrooks Davis }
2818