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