147c08596SBrooks Davis /* $OpenBSD: dispatch.c,v 1.31 2004/09/21 04:07:03 david Exp $ */
247c08596SBrooks Davis
38a16b7a1SPedro F. Giffuni /*-
48a16b7a1SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause
58a16b7a1SPedro F. Giffuni *
647c08596SBrooks Davis * Copyright 2004 Henning Brauer <henning@openbsd.org>
747c08596SBrooks Davis * Copyright (c) 1995, 1996, 1997, 1998, 1999
847c08596SBrooks Davis * The Internet Software Consortium. All rights reserved.
947c08596SBrooks Davis *
1047c08596SBrooks Davis * Redistribution and use in source and binary forms, with or without
1147c08596SBrooks Davis * modification, are permitted provided that the following conditions
1247c08596SBrooks Davis * are met:
1347c08596SBrooks Davis *
1447c08596SBrooks Davis * 1. Redistributions of source code must retain the above copyright
1547c08596SBrooks Davis * notice, this list of conditions and the following disclaimer.
1647c08596SBrooks Davis * 2. Redistributions in binary form must reproduce the above copyright
1747c08596SBrooks Davis * notice, this list of conditions and the following disclaimer in the
1847c08596SBrooks Davis * documentation and/or other materials provided with the distribution.
1947c08596SBrooks Davis * 3. Neither the name of The Internet Software Consortium nor the names
2047c08596SBrooks Davis * of its contributors may be used to endorse or promote products derived
2147c08596SBrooks Davis * from this software without specific prior written permission.
2247c08596SBrooks Davis *
2347c08596SBrooks Davis * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
2447c08596SBrooks Davis * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
2547c08596SBrooks Davis * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
2647c08596SBrooks Davis * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
2747c08596SBrooks Davis * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
2847c08596SBrooks Davis * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2947c08596SBrooks Davis * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3047c08596SBrooks Davis * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
3147c08596SBrooks Davis * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
3247c08596SBrooks Davis * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
3347c08596SBrooks Davis * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
3447c08596SBrooks Davis * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
3547c08596SBrooks Davis * SUCH DAMAGE.
3647c08596SBrooks Davis *
3747c08596SBrooks Davis * This software has been written for the Internet Software Consortium
3847c08596SBrooks Davis * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
3947c08596SBrooks Davis * Enterprises. To learn more about the Internet Software Consortium,
4047c08596SBrooks Davis * see ``http://www.vix.com/isc''. To learn more about Vixie
4147c08596SBrooks Davis * Enterprises, see ``http://www.vix.com''.
4247c08596SBrooks Davis */
4347c08596SBrooks Davis
448794fdbbSBrooks Davis #include <sys/cdefs.h>
4547c08596SBrooks Davis #include "dhcpd.h"
46387016a5SConrad Meyer #include "privsep.h"
4747c08596SBrooks Davis
4847c08596SBrooks Davis #include <sys/ioctl.h>
4947c08596SBrooks Davis
5079a1d195SAlan Somers #include <assert.h>
5147c08596SBrooks Davis #include <net/if_media.h>
5247c08596SBrooks Davis #include <ifaddrs.h>
5347c08596SBrooks Davis #include <poll.h>
5447c08596SBrooks Davis
5579a1d195SAlan Somers /* Assert that pointer p is aligned to at least align bytes */
5679a1d195SAlan Somers #define assert_aligned(p, align) assert((((uintptr_t)p) & ((align) - 1)) == 0)
5779a1d195SAlan Somers
5871c6c44dSEitan Adler static struct protocol *protocols;
5971c6c44dSEitan Adler static struct timeout *timeouts;
6047c08596SBrooks Davis static struct timeout *free_timeouts;
6147c08596SBrooks Davis static int interfaces_invalidated;
6247c08596SBrooks Davis void (*bootp_packet_handler)(struct interface_info *,
6347c08596SBrooks Davis struct dhcp_packet *, int, unsigned int,
6447c08596SBrooks Davis struct iaddr, struct hardware *);
6547c08596SBrooks Davis
6647c08596SBrooks Davis static int interface_status(struct interface_info *ifinfo);
6747c08596SBrooks Davis
6847c08596SBrooks Davis /*
6947c08596SBrooks Davis * Use getifaddrs() to get a list of all the attached interfaces. For
7047c08596SBrooks Davis * each interface that's of type INET and not the loopback interface,
7147c08596SBrooks Davis * register that interface with the network I/O software, figure out
7247c08596SBrooks Davis * what subnet it's on, and add it to the list of interfaces.
7347c08596SBrooks Davis */
7447c08596SBrooks Davis void
discover_interfaces(struct interface_info * iface)7547c08596SBrooks Davis discover_interfaces(struct interface_info *iface)
7647c08596SBrooks Davis {
7747c08596SBrooks Davis struct ifaddrs *ifap, *ifa;
7847c08596SBrooks Davis struct ifreq *tif;
79e2dc8d78SAlexander V. Chernikov int len = IFNAMSIZ + sizeof(struct sockaddr_storage);
8047c08596SBrooks Davis
8147c08596SBrooks Davis if (getifaddrs(&ifap) != 0)
8247c08596SBrooks Davis error("getifaddrs failed");
8347c08596SBrooks Davis
8447c08596SBrooks Davis for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
8547c08596SBrooks Davis if ((ifa->ifa_flags & IFF_LOOPBACK) ||
8647c08596SBrooks Davis (ifa->ifa_flags & IFF_POINTOPOINT) ||
8747c08596SBrooks Davis (!(ifa->ifa_flags & IFF_UP)))
8847c08596SBrooks Davis continue;
8947c08596SBrooks Davis
9047c08596SBrooks Davis if (strcmp(iface->name, ifa->ifa_name))
9147c08596SBrooks Davis continue;
9247c08596SBrooks Davis
9347c08596SBrooks Davis /*
9447c08596SBrooks Davis * If we have the capability, extract link information
9547c08596SBrooks Davis * and record it in a linked list.
9647c08596SBrooks Davis */
9747c08596SBrooks Davis if (ifa->ifa_addr->sa_family == AF_LINK) {
9879a1d195SAlan Somers struct sockaddr_dl *foo;
9979a1d195SAlan Somers
10079a1d195SAlan Somers /*
10179a1d195SAlan Somers * The implementation of getifaddrs should guarantee
10279a1d195SAlan Somers * this alignment
10379a1d195SAlan Somers */
10479a1d195SAlan Somers assert_aligned(ifa->ifa_addr,
10579a1d195SAlan Somers _Alignof(struct sockaddr_dl));
10679a1d195SAlan Somers #ifdef __clang__
10779a1d195SAlan Somers #pragma clang diagnostic push
10879a1d195SAlan Somers #pragma clang diagnostic ignored "-Wcast-align"
10979a1d195SAlan Somers #endif
11079a1d195SAlan Somers foo = (struct sockaddr_dl *)ifa->ifa_addr;
11179a1d195SAlan Somers #ifdef __clang__
11279a1d195SAlan Somers #pragma clang diagnostic pop
11379a1d195SAlan Somers #endif
11447c08596SBrooks Davis
11547c08596SBrooks Davis iface->index = foo->sdl_index;
11647c08596SBrooks Davis iface->hw_address.hlen = foo->sdl_alen;
11747c08596SBrooks Davis iface->hw_address.htype = HTYPE_ETHER; /* XXX */
11847c08596SBrooks Davis memcpy(iface->hw_address.haddr,
11947c08596SBrooks Davis LLADDR(foo), foo->sdl_alen);
120e2dc8d78SAlexander V. Chernikov }
12147c08596SBrooks Davis if (!iface->ifp) {
122e2dc8d78SAlexander V. Chernikov if ((tif = calloc(1, len)) == NULL)
12347c08596SBrooks Davis error("no space to remember ifp");
12447c08596SBrooks Davis strlcpy(tif->ifr_name, ifa->ifa_name, IFNAMSIZ);
12547c08596SBrooks Davis iface->ifp = tif;
12647c08596SBrooks Davis }
127e2dc8d78SAlexander V. Chernikov
12847c08596SBrooks Davis }
12947c08596SBrooks Davis
13047c08596SBrooks Davis if (!iface->ifp)
13147c08596SBrooks Davis error("%s: not found", iface->name);
13247c08596SBrooks Davis
13347c08596SBrooks Davis /* Register the interface... */
13447c08596SBrooks Davis if_register_receive(iface);
13547c08596SBrooks Davis if_register_send(iface);
13647c08596SBrooks Davis add_protocol(iface->name, iface->rfdesc, got_one, iface);
13747c08596SBrooks Davis freeifaddrs(ifap);
13847c08596SBrooks Davis }
13947c08596SBrooks Davis
14047c08596SBrooks Davis void
reinitialize_interfaces(void)14147c08596SBrooks Davis reinitialize_interfaces(void)
14247c08596SBrooks Davis {
14347c08596SBrooks Davis interfaces_invalidated = 1;
14447c08596SBrooks Davis }
14547c08596SBrooks Davis
14647c08596SBrooks Davis /*
14747c08596SBrooks Davis * Wait for packets to come in using poll(). When a packet comes in,
14847c08596SBrooks Davis * call receive_packet to receive the packet and possibly strip hardware
14947c08596SBrooks Davis * addressing information from it, and then call through the
15047c08596SBrooks Davis * bootp_packet_handler hook to try to do something with it.
15147c08596SBrooks Davis */
15247c08596SBrooks Davis void
dispatch(void)15347c08596SBrooks Davis dispatch(void)
15447c08596SBrooks Davis {
155f8c44adaSSam Leffler int count, live_interfaces, i, to_msec, nfds = 0;
15647c08596SBrooks Davis struct protocol *l;
15747c08596SBrooks Davis struct pollfd *fds;
15847c08596SBrooks Davis time_t howlong;
15947c08596SBrooks Davis
16047c08596SBrooks Davis for (l = protocols; l; l = l->next)
16147c08596SBrooks Davis nfds++;
16247c08596SBrooks Davis
16347c08596SBrooks Davis fds = malloc(nfds * sizeof(struct pollfd));
16447c08596SBrooks Davis if (fds == NULL)
16547c08596SBrooks Davis error("Can't allocate poll structures.");
16647c08596SBrooks Davis
16747c08596SBrooks Davis do {
16847c08596SBrooks Davis /*
16947c08596SBrooks Davis * Call any expired timeouts, and then if there's still
17047c08596SBrooks Davis * a timeout registered, time out the select call then.
17147c08596SBrooks Davis */
17247c08596SBrooks Davis another:
17347c08596SBrooks Davis if (timeouts) {
17447c08596SBrooks Davis struct timeout *t;
17547c08596SBrooks Davis
17647c08596SBrooks Davis if (timeouts->when <= cur_time) {
17747c08596SBrooks Davis t = timeouts;
17847c08596SBrooks Davis timeouts = timeouts->next;
17947c08596SBrooks Davis (*(t->func))(t->what);
18047c08596SBrooks Davis t->next = free_timeouts;
18147c08596SBrooks Davis free_timeouts = t;
18247c08596SBrooks Davis goto another;
18347c08596SBrooks Davis }
18447c08596SBrooks Davis
18547c08596SBrooks Davis /*
18647c08596SBrooks Davis * Figure timeout in milliseconds, and check for
18747c08596SBrooks Davis * potential overflow, so we can cram into an
18847c08596SBrooks Davis * int for poll, while not polling with a
18947c08596SBrooks Davis * negative timeout and blocking indefinitely.
19047c08596SBrooks Davis */
19147c08596SBrooks Davis howlong = timeouts->when - cur_time;
19247c08596SBrooks Davis if (howlong > INT_MAX / 1000)
19347c08596SBrooks Davis howlong = INT_MAX / 1000;
19447c08596SBrooks Davis to_msec = howlong * 1000;
19547c08596SBrooks Davis } else
19647c08596SBrooks Davis to_msec = -1;
19747c08596SBrooks Davis
19847c08596SBrooks Davis /* Set up the descriptors to be polled. */
199f8c44adaSSam Leffler live_interfaces = 0;
20047c08596SBrooks Davis for (i = 0, l = protocols; l; l = l->next) {
20147c08596SBrooks Davis struct interface_info *ip = l->local;
20247c08596SBrooks Davis
203f8c44adaSSam Leffler if (ip == NULL || ip->dead)
204f8c44adaSSam Leffler continue;
20547c08596SBrooks Davis fds[i].fd = l->fd;
20647c08596SBrooks Davis fds[i].events = POLLIN;
20747c08596SBrooks Davis fds[i].revents = 0;
20847c08596SBrooks Davis i++;
209f8c44adaSSam Leffler if (l->handler == got_one)
210f8c44adaSSam Leffler live_interfaces++;
21147c08596SBrooks Davis }
212f8c44adaSSam Leffler if (live_interfaces == 0)
21347c08596SBrooks Davis error("No live interfaces to poll on - exiting.");
21447c08596SBrooks Davis
21547c08596SBrooks Davis /* Wait for a packet or a timeout... XXX */
21647c08596SBrooks Davis count = poll(fds, nfds, to_msec);
21747c08596SBrooks Davis
21847c08596SBrooks Davis /* Not likely to be transitory... */
21947c08596SBrooks Davis if (count == -1) {
22047c08596SBrooks Davis if (errno == EAGAIN || errno == EINTR) {
22147c08596SBrooks Davis time(&cur_time);
22247c08596SBrooks Davis continue;
22347c08596SBrooks Davis } else
22447c08596SBrooks Davis error("poll: %m");
22547c08596SBrooks Davis }
22647c08596SBrooks Davis
22747c08596SBrooks Davis /* Get the current time... */
22847c08596SBrooks Davis time(&cur_time);
22947c08596SBrooks Davis
23047c08596SBrooks Davis i = 0;
23147c08596SBrooks Davis for (l = protocols; l; l = l->next) {
23247c08596SBrooks Davis struct interface_info *ip;
23347c08596SBrooks Davis ip = l->local;
23447c08596SBrooks Davis if ((fds[i].revents & (POLLIN | POLLHUP))) {
23547c08596SBrooks Davis fds[i].revents = 0;
23647c08596SBrooks Davis if (ip && (l->handler != got_one ||
23747c08596SBrooks Davis !ip->dead))
23847c08596SBrooks Davis (*(l->handler))(l);
23947c08596SBrooks Davis if (interfaces_invalidated)
24047c08596SBrooks Davis break;
24147c08596SBrooks Davis }
24247c08596SBrooks Davis i++;
24347c08596SBrooks Davis }
24447c08596SBrooks Davis interfaces_invalidated = 0;
24547c08596SBrooks Davis } while (1);
24647c08596SBrooks Davis }
24747c08596SBrooks Davis
24847c08596SBrooks Davis
24947c08596SBrooks Davis void
got_one(struct protocol * l)25047c08596SBrooks Davis got_one(struct protocol *l)
25147c08596SBrooks Davis {
25247c08596SBrooks Davis struct sockaddr_in from;
25347c08596SBrooks Davis struct hardware hfrom;
25447c08596SBrooks Davis struct iaddr ifrom;
25547c08596SBrooks Davis ssize_t result;
25647c08596SBrooks Davis union {
25747c08596SBrooks Davis /*
25847c08596SBrooks Davis * Packet input buffer. Must be as large as largest
25947c08596SBrooks Davis * possible MTU.
26047c08596SBrooks Davis */
26147c08596SBrooks Davis unsigned char packbuf[4095];
26247c08596SBrooks Davis struct dhcp_packet packet;
26347c08596SBrooks Davis } u;
26447c08596SBrooks Davis struct interface_info *ip = l->local;
26547c08596SBrooks Davis
26647c08596SBrooks Davis if ((result = receive_packet(ip, u.packbuf, sizeof(u), &from,
26747c08596SBrooks Davis &hfrom)) == -1) {
26847c08596SBrooks Davis warning("receive_packet failed on %s: %s", ip->name,
26947c08596SBrooks Davis strerror(errno));
27047c08596SBrooks Davis ip->errors++;
27147c08596SBrooks Davis if ((!interface_status(ip)) ||
27247c08596SBrooks Davis (ip->noifmedia && ip->errors > 20)) {
27347c08596SBrooks Davis /* our interface has gone away. */
27447c08596SBrooks Davis warning("Interface %s no longer appears valid.",
27547c08596SBrooks Davis ip->name);
27647c08596SBrooks Davis ip->dead = 1;
27747c08596SBrooks Davis interfaces_invalidated = 1;
27847c08596SBrooks Davis close(l->fd);
27947c08596SBrooks Davis remove_protocol(l);
28047c08596SBrooks Davis free(ip);
28147c08596SBrooks Davis }
28247c08596SBrooks Davis return;
28347c08596SBrooks Davis }
28447c08596SBrooks Davis if (result == 0)
28547c08596SBrooks Davis return;
28647c08596SBrooks Davis
28747c08596SBrooks Davis if (bootp_packet_handler) {
28847c08596SBrooks Davis ifrom.len = 4;
28947c08596SBrooks Davis memcpy(ifrom.iabuf, &from.sin_addr, ifrom.len);
29047c08596SBrooks Davis
29147c08596SBrooks Davis (*bootp_packet_handler)(ip, &u.packet, result,
29247c08596SBrooks Davis from.sin_port, ifrom, &hfrom);
29347c08596SBrooks Davis }
29447c08596SBrooks Davis }
29547c08596SBrooks Davis
29647c08596SBrooks Davis int
interface_status(struct interface_info * ifinfo)29747c08596SBrooks Davis interface_status(struct interface_info *ifinfo)
29847c08596SBrooks Davis {
29947c08596SBrooks Davis char *ifname = ifinfo->name;
30047c08596SBrooks Davis int ifsock = ifinfo->rfdesc;
30147c08596SBrooks Davis struct ifreq ifr;
30247c08596SBrooks Davis struct ifmediareq ifmr;
30347c08596SBrooks Davis
30447c08596SBrooks Davis /* get interface flags */
30547c08596SBrooks Davis memset(&ifr, 0, sizeof(ifr));
30647c08596SBrooks Davis strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
30747c08596SBrooks Davis if (ioctl(ifsock, SIOCGIFFLAGS, &ifr) < 0) {
308cb003dd9SMariusz Zaborski cap_syslog(capsyslog, LOG_ERR, "ioctl(SIOCGIFFLAGS) on %s: %m",
309cb003dd9SMariusz Zaborski ifname);
31047c08596SBrooks Davis goto inactive;
31147c08596SBrooks Davis }
31247c08596SBrooks Davis
31347c08596SBrooks Davis /*
31447c08596SBrooks Davis * if one of UP and RUNNING flags is dropped,
31547c08596SBrooks Davis * the interface is not active.
31647c08596SBrooks Davis */
31747c08596SBrooks Davis if ((ifr.ifr_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
31847c08596SBrooks Davis goto inactive;
31947c08596SBrooks Davis
32047c08596SBrooks Davis /* Next, check carrier on the interface, if possible */
32147c08596SBrooks Davis if (ifinfo->noifmedia)
32247c08596SBrooks Davis goto active;
32347c08596SBrooks Davis memset(&ifmr, 0, sizeof(ifmr));
32447c08596SBrooks Davis strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));
32547c08596SBrooks Davis if (ioctl(ifsock, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) {
32647c08596SBrooks Davis if (errno != EINVAL) {
327cb003dd9SMariusz Zaborski cap_syslog(capsyslog, LOG_DEBUG,
328cb003dd9SMariusz Zaborski "ioctl(SIOCGIFMEDIA) on %s: %m", ifname);
32947c08596SBrooks Davis ifinfo->noifmedia = 1;
33047c08596SBrooks Davis goto active;
33147c08596SBrooks Davis }
33247c08596SBrooks Davis /*
33347c08596SBrooks Davis * EINVAL (or ENOTTY) simply means that the interface
33447c08596SBrooks Davis * does not support the SIOCGIFMEDIA ioctl. We regard it alive.
33547c08596SBrooks Davis */
33647c08596SBrooks Davis ifinfo->noifmedia = 1;
33747c08596SBrooks Davis goto active;
33847c08596SBrooks Davis }
33947c08596SBrooks Davis if (ifmr.ifm_status & IFM_AVALID) {
34047c08596SBrooks Davis switch (ifmr.ifm_active & IFM_NMASK) {
34147c08596SBrooks Davis case IFM_ETHER:
342cd765a65SJung-uk Kim case IFM_IEEE80211:
34347c08596SBrooks Davis if (ifmr.ifm_status & IFM_ACTIVE)
34447c08596SBrooks Davis goto active;
34547c08596SBrooks Davis else
34647c08596SBrooks Davis goto inactive;
34747c08596SBrooks Davis break;
34847c08596SBrooks Davis default:
34947c08596SBrooks Davis goto inactive;
35047c08596SBrooks Davis }
35147c08596SBrooks Davis }
35247c08596SBrooks Davis inactive:
35347c08596SBrooks Davis return (0);
35447c08596SBrooks Davis active:
35547c08596SBrooks Davis return (1);
35647c08596SBrooks Davis }
35747c08596SBrooks Davis
35847c08596SBrooks Davis void
add_timeout(time_t when,void (* where)(void *),void * what)35947c08596SBrooks Davis add_timeout(time_t when, void (*where)(void *), void *what)
36047c08596SBrooks Davis {
36147c08596SBrooks Davis struct timeout *t, *q;
36247c08596SBrooks Davis
36347c08596SBrooks Davis /* See if this timeout supersedes an existing timeout. */
36447c08596SBrooks Davis t = NULL;
36547c08596SBrooks Davis for (q = timeouts; q; q = q->next) {
36647c08596SBrooks Davis if (q->func == where && q->what == what) {
36747c08596SBrooks Davis if (t)
36847c08596SBrooks Davis t->next = q->next;
36947c08596SBrooks Davis else
37047c08596SBrooks Davis timeouts = q->next;
37147c08596SBrooks Davis break;
37247c08596SBrooks Davis }
37347c08596SBrooks Davis t = q;
37447c08596SBrooks Davis }
37547c08596SBrooks Davis
37647c08596SBrooks Davis /* If we didn't supersede a timeout, allocate a timeout
37747c08596SBrooks Davis structure now. */
37847c08596SBrooks Davis if (!q) {
37947c08596SBrooks Davis if (free_timeouts) {
38047c08596SBrooks Davis q = free_timeouts;
38147c08596SBrooks Davis free_timeouts = q->next;
38247c08596SBrooks Davis q->func = where;
38347c08596SBrooks Davis q->what = what;
38447c08596SBrooks Davis } else {
38547c08596SBrooks Davis q = malloc(sizeof(struct timeout));
38647c08596SBrooks Davis if (!q)
38747c08596SBrooks Davis error("Can't allocate timeout structure!");
38847c08596SBrooks Davis q->func = where;
38947c08596SBrooks Davis q->what = what;
39047c08596SBrooks Davis }
39147c08596SBrooks Davis }
39247c08596SBrooks Davis
39347c08596SBrooks Davis q->when = when;
39447c08596SBrooks Davis
39547c08596SBrooks Davis /* Now sort this timeout into the timeout list. */
39647c08596SBrooks Davis
39747c08596SBrooks Davis /* Beginning of list? */
39847c08596SBrooks Davis if (!timeouts || timeouts->when > q->when) {
39947c08596SBrooks Davis q->next = timeouts;
40047c08596SBrooks Davis timeouts = q;
40147c08596SBrooks Davis return;
40247c08596SBrooks Davis }
40347c08596SBrooks Davis
40447c08596SBrooks Davis /* Middle of list? */
40547c08596SBrooks Davis for (t = timeouts; t->next; t = t->next) {
40647c08596SBrooks Davis if (t->next->when > q->when) {
40747c08596SBrooks Davis q->next = t->next;
40847c08596SBrooks Davis t->next = q;
40947c08596SBrooks Davis return;
41047c08596SBrooks Davis }
41147c08596SBrooks Davis }
41247c08596SBrooks Davis
41347c08596SBrooks Davis /* End of list. */
41447c08596SBrooks Davis t->next = q;
41547c08596SBrooks Davis q->next = NULL;
41647c08596SBrooks Davis }
41747c08596SBrooks Davis
41847c08596SBrooks Davis void
cancel_timeout(void (* where)(void *),void * what)41947c08596SBrooks Davis cancel_timeout(void (*where)(void *), void *what)
42047c08596SBrooks Davis {
42147c08596SBrooks Davis struct timeout *t, *q;
42247c08596SBrooks Davis
42347c08596SBrooks Davis /* Look for this timeout on the list, and unlink it if we find it. */
42447c08596SBrooks Davis t = NULL;
42547c08596SBrooks Davis for (q = timeouts; q; q = q->next) {
42647c08596SBrooks Davis if (q->func == where && q->what == what) {
42747c08596SBrooks Davis if (t)
42847c08596SBrooks Davis t->next = q->next;
42947c08596SBrooks Davis else
43047c08596SBrooks Davis timeouts = q->next;
43147c08596SBrooks Davis break;
43247c08596SBrooks Davis }
43347c08596SBrooks Davis t = q;
43447c08596SBrooks Davis }
43547c08596SBrooks Davis
43647c08596SBrooks Davis /* If we found the timeout, put it on the free list. */
43747c08596SBrooks Davis if (q) {
43847c08596SBrooks Davis q->next = free_timeouts;
43947c08596SBrooks Davis free_timeouts = q;
44047c08596SBrooks Davis }
44147c08596SBrooks Davis }
44247c08596SBrooks Davis
44347c08596SBrooks Davis /* Add a protocol to the list of protocols... */
44447c08596SBrooks Davis void
add_protocol(const char * name,int fd,void (* handler)(struct protocol *),void * local)44579a1d195SAlan Somers add_protocol(const char *name, int fd, void (*handler)(struct protocol *),
44647c08596SBrooks Davis void *local)
44747c08596SBrooks Davis {
44847c08596SBrooks Davis struct protocol *p;
44947c08596SBrooks Davis
45047c08596SBrooks Davis p = malloc(sizeof(*p));
45147c08596SBrooks Davis if (!p)
45247c08596SBrooks Davis error("can't allocate protocol struct for %s", name);
45347c08596SBrooks Davis
45447c08596SBrooks Davis p->fd = fd;
45547c08596SBrooks Davis p->handler = handler;
45647c08596SBrooks Davis p->local = local;
45747c08596SBrooks Davis p->next = protocols;
45847c08596SBrooks Davis protocols = p;
45947c08596SBrooks Davis }
46047c08596SBrooks Davis
46147c08596SBrooks Davis void
remove_protocol(struct protocol * proto)46247c08596SBrooks Davis remove_protocol(struct protocol *proto)
46347c08596SBrooks Davis {
46400060820SMark Johnston struct protocol *p, *prev;
46547c08596SBrooks Davis
46600060820SMark Johnston for (p = protocols, prev = NULL; p != NULL; prev = p, p = p->next) {
46747c08596SBrooks Davis if (p == proto) {
46800060820SMark Johnston if (prev == NULL)
46947c08596SBrooks Davis protocols = p->next;
47000060820SMark Johnston else
47100060820SMark Johnston prev->next = p->next;
47247c08596SBrooks Davis free(p);
47300060820SMark Johnston break;
47447c08596SBrooks Davis }
47547c08596SBrooks Davis }
47647c08596SBrooks Davis }
47747c08596SBrooks Davis
47847c08596SBrooks Davis int
interface_link_status(char * ifname)47947c08596SBrooks Davis interface_link_status(char *ifname)
48047c08596SBrooks Davis {
48147c08596SBrooks Davis struct ifmediareq ifmr;
48247c08596SBrooks Davis int sock;
48347c08596SBrooks Davis
48447c08596SBrooks Davis if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
48547c08596SBrooks Davis error("Can't create socket");
48647c08596SBrooks Davis
48747c08596SBrooks Davis memset(&ifmr, 0, sizeof(ifmr));
48847c08596SBrooks Davis strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));
48947c08596SBrooks Davis if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifmr) == -1) {
49047c08596SBrooks Davis /* EINVAL -> link state unknown. treat as active */
49147c08596SBrooks Davis if (errno != EINVAL)
492cb003dd9SMariusz Zaborski cap_syslog(capsyslog, LOG_DEBUG,
493cb003dd9SMariusz Zaborski "ioctl(SIOCGIFMEDIA) on %s: %m", ifname);
49447c08596SBrooks Davis close(sock);
49547c08596SBrooks Davis return (1);
49647c08596SBrooks Davis }
49747c08596SBrooks Davis close(sock);
49847c08596SBrooks Davis
49947c08596SBrooks Davis if (ifmr.ifm_status & IFM_AVALID) {
500cd765a65SJung-uk Kim switch (ifmr.ifm_active & IFM_NMASK) {
501cd765a65SJung-uk Kim case IFM_ETHER:
502cd765a65SJung-uk Kim case IFM_IEEE80211:
50347c08596SBrooks Davis if (ifmr.ifm_status & IFM_ACTIVE)
50447c08596SBrooks Davis return (1);
50547c08596SBrooks Davis else
50647c08596SBrooks Davis return (0);
50747c08596SBrooks Davis }
50847c08596SBrooks Davis }
50947c08596SBrooks Davis return (1);
51047c08596SBrooks Davis }
511387016a5SConrad Meyer
512387016a5SConrad Meyer void
interface_set_mtu_unpriv(int privfd,u_int16_t mtu)513387016a5SConrad Meyer interface_set_mtu_unpriv(int privfd, u_int16_t mtu)
514387016a5SConrad Meyer {
515387016a5SConrad Meyer struct imsg_hdr hdr;
516387016a5SConrad Meyer struct buf *buf;
517387016a5SConrad Meyer int errs = 0;
518387016a5SConrad Meyer
519387016a5SConrad Meyer hdr.code = IMSG_SET_INTERFACE_MTU;
520387016a5SConrad Meyer hdr.len = sizeof(hdr) +
521387016a5SConrad Meyer sizeof(u_int16_t);
522387016a5SConrad Meyer
523387016a5SConrad Meyer if ((buf = buf_open(hdr.len)) == NULL)
524387016a5SConrad Meyer error("buf_open: %m");
525387016a5SConrad Meyer
526387016a5SConrad Meyer errs += buf_add(buf, &hdr, sizeof(hdr));
527387016a5SConrad Meyer errs += buf_add(buf, &mtu, sizeof(mtu));
528387016a5SConrad Meyer if (errs)
529387016a5SConrad Meyer error("buf_add: %m");
530387016a5SConrad Meyer
531387016a5SConrad Meyer if (buf_close(privfd, buf) == -1)
532387016a5SConrad Meyer error("buf_close: %m");
533387016a5SConrad Meyer }
534387016a5SConrad Meyer
535387016a5SConrad Meyer void
interface_set_mtu_priv(char * ifname,u_int16_t mtu)536387016a5SConrad Meyer interface_set_mtu_priv(char *ifname, u_int16_t mtu)
537387016a5SConrad Meyer {
538387016a5SConrad Meyer struct ifreq ifr;
539387016a5SConrad Meyer int sock;
54035b930ccSEugene Grosbein u_int16_t old_mtu;
541387016a5SConrad Meyer
542387016a5SConrad Meyer if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
543387016a5SConrad Meyer error("Can't create socket");
544387016a5SConrad Meyer
545387016a5SConrad Meyer memset(&ifr, 0, sizeof(ifr));
54635b930ccSEugene Grosbein old_mtu = 0;
547387016a5SConrad Meyer
548387016a5SConrad Meyer strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
54935b930ccSEugene Grosbein
55035b930ccSEugene Grosbein if (ioctl(sock, SIOCGIFMTU, (caddr_t)&ifr) == -1)
55135b930ccSEugene Grosbein warning("SIOCGIFMTU failed (%s): %s", ifname,
55235b930ccSEugene Grosbein strerror(errno));
55335b930ccSEugene Grosbein else
55435b930ccSEugene Grosbein old_mtu = ifr.ifr_mtu;
55535b930ccSEugene Grosbein
55635b930ccSEugene Grosbein if (mtu != old_mtu) {
557387016a5SConrad Meyer ifr.ifr_mtu = mtu;
558387016a5SConrad Meyer
559387016a5SConrad Meyer if (ioctl(sock, SIOCSIFMTU, &ifr) == -1)
560387016a5SConrad Meyer warning("SIOCSIFMTU failed (%d): %s", mtu,
561387016a5SConrad Meyer strerror(errno));
56235b930ccSEugene Grosbein }
56335b930ccSEugene Grosbein
564387016a5SConrad Meyer close(sock);
565387016a5SConrad Meyer }
566