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