147c08596SBrooks Davis /* $OpenBSD: dispatch.c,v 1.31 2004/09/21 04:07:03 david 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 428794fdbbSBrooks Davis #include <sys/cdefs.h> 438794fdbbSBrooks Davis __FBSDID("$FreeBSD$"); 448794fdbbSBrooks Davis 4547c08596SBrooks Davis #include "dhcpd.h" 4647c08596SBrooks Davis 4747c08596SBrooks Davis #include <sys/ioctl.h> 4847c08596SBrooks Davis 4947c08596SBrooks Davis #include <net/if_media.h> 5047c08596SBrooks Davis #include <ifaddrs.h> 5147c08596SBrooks Davis #include <poll.h> 5247c08596SBrooks Davis 5347c08596SBrooks Davis struct protocol *protocols; 5447c08596SBrooks Davis struct timeout *timeouts; 5547c08596SBrooks Davis static struct timeout *free_timeouts; 5647c08596SBrooks Davis static int interfaces_invalidated; 5747c08596SBrooks Davis void (*bootp_packet_handler)(struct interface_info *, 5847c08596SBrooks Davis struct dhcp_packet *, int, unsigned int, 5947c08596SBrooks Davis struct iaddr, struct hardware *); 6047c08596SBrooks Davis 6147c08596SBrooks Davis static int interface_status(struct interface_info *ifinfo); 6247c08596SBrooks Davis 6347c08596SBrooks Davis /* 6447c08596SBrooks Davis * Use getifaddrs() to get a list of all the attached interfaces. For 6547c08596SBrooks Davis * each interface that's of type INET and not the loopback interface, 6647c08596SBrooks Davis * register that interface with the network I/O software, figure out 6747c08596SBrooks Davis * what subnet it's on, and add it to the list of interfaces. 6847c08596SBrooks Davis */ 6947c08596SBrooks Davis void 7047c08596SBrooks Davis discover_interfaces(struct interface_info *iface) 7147c08596SBrooks Davis { 7247c08596SBrooks Davis struct ifaddrs *ifap, *ifa; 7347c08596SBrooks Davis struct sockaddr_in foo; 7447c08596SBrooks Davis struct ifreq *tif; 7547c08596SBrooks Davis 7647c08596SBrooks Davis if (getifaddrs(&ifap) != 0) 7747c08596SBrooks Davis error("getifaddrs failed"); 7847c08596SBrooks Davis 7947c08596SBrooks Davis for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) { 8047c08596SBrooks Davis if ((ifa->ifa_flags & IFF_LOOPBACK) || 8147c08596SBrooks Davis (ifa->ifa_flags & IFF_POINTOPOINT) || 8247c08596SBrooks Davis (!(ifa->ifa_flags & IFF_UP))) 8347c08596SBrooks Davis continue; 8447c08596SBrooks Davis 8547c08596SBrooks Davis if (strcmp(iface->name, ifa->ifa_name)) 8647c08596SBrooks Davis continue; 8747c08596SBrooks Davis 8847c08596SBrooks Davis /* 8947c08596SBrooks Davis * If we have the capability, extract link information 9047c08596SBrooks Davis * and record it in a linked list. 9147c08596SBrooks Davis */ 9247c08596SBrooks Davis if (ifa->ifa_addr->sa_family == AF_LINK) { 9347c08596SBrooks Davis struct sockaddr_dl *foo = 9447c08596SBrooks Davis (struct sockaddr_dl *)ifa->ifa_addr; 9547c08596SBrooks Davis 9647c08596SBrooks Davis iface->index = foo->sdl_index; 9747c08596SBrooks Davis iface->hw_address.hlen = foo->sdl_alen; 9847c08596SBrooks Davis iface->hw_address.htype = HTYPE_ETHER; /* XXX */ 9947c08596SBrooks Davis memcpy(iface->hw_address.haddr, 10047c08596SBrooks Davis LLADDR(foo), foo->sdl_alen); 10147c08596SBrooks Davis } else if (ifa->ifa_addr->sa_family == AF_INET) { 10247c08596SBrooks Davis struct iaddr addr; 10347c08596SBrooks Davis 10447c08596SBrooks Davis memcpy(&foo, ifa->ifa_addr, sizeof(foo)); 10547c08596SBrooks Davis if (foo.sin_addr.s_addr == htonl(INADDR_LOOPBACK)) 10647c08596SBrooks Davis continue; 10747c08596SBrooks Davis if (!iface->ifp) { 10847c08596SBrooks Davis int len = IFNAMSIZ + ifa->ifa_addr->sa_len; 10947c08596SBrooks Davis if ((tif = malloc(len)) == NULL) 11047c08596SBrooks Davis error("no space to remember ifp"); 11147c08596SBrooks Davis strlcpy(tif->ifr_name, ifa->ifa_name, IFNAMSIZ); 11247c08596SBrooks Davis memcpy(&tif->ifr_addr, ifa->ifa_addr, 11347c08596SBrooks Davis ifa->ifa_addr->sa_len); 11447c08596SBrooks Davis iface->ifp = tif; 11547c08596SBrooks Davis iface->primary_address = foo.sin_addr; 11647c08596SBrooks Davis } 11747c08596SBrooks Davis addr.len = 4; 11847c08596SBrooks Davis memcpy(addr.iabuf, &foo.sin_addr.s_addr, addr.len); 11947c08596SBrooks Davis } 12047c08596SBrooks Davis } 12147c08596SBrooks Davis 12247c08596SBrooks Davis if (!iface->ifp) 12347c08596SBrooks Davis error("%s: not found", iface->name); 12447c08596SBrooks Davis 12547c08596SBrooks Davis /* Register the interface... */ 12647c08596SBrooks Davis if_register_receive(iface); 12747c08596SBrooks Davis if_register_send(iface); 12847c08596SBrooks Davis add_protocol(iface->name, iface->rfdesc, got_one, iface); 12947c08596SBrooks Davis freeifaddrs(ifap); 13047c08596SBrooks Davis } 13147c08596SBrooks Davis 13247c08596SBrooks Davis void 13347c08596SBrooks Davis reinitialize_interfaces(void) 13447c08596SBrooks Davis { 13547c08596SBrooks Davis interfaces_invalidated = 1; 13647c08596SBrooks Davis } 13747c08596SBrooks Davis 13847c08596SBrooks Davis /* 13947c08596SBrooks Davis * Wait for packets to come in using poll(). When a packet comes in, 14047c08596SBrooks Davis * call receive_packet to receive the packet and possibly strip hardware 14147c08596SBrooks Davis * addressing information from it, and then call through the 14247c08596SBrooks Davis * bootp_packet_handler hook to try to do something with it. 14347c08596SBrooks Davis */ 14447c08596SBrooks Davis void 14547c08596SBrooks Davis dispatch(void) 14647c08596SBrooks Davis { 14747c08596SBrooks Davis int count, i, to_msec, nfds = 0; 14847c08596SBrooks Davis struct protocol *l; 14947c08596SBrooks Davis struct pollfd *fds; 15047c08596SBrooks Davis time_t howlong; 15147c08596SBrooks Davis 15247c08596SBrooks Davis for (l = protocols; l; l = l->next) 15347c08596SBrooks Davis nfds++; 15447c08596SBrooks Davis 15547c08596SBrooks Davis fds = malloc(nfds * sizeof(struct pollfd)); 15647c08596SBrooks Davis if (fds == NULL) 15747c08596SBrooks Davis error("Can't allocate poll structures."); 15847c08596SBrooks Davis 15947c08596SBrooks Davis do { 16047c08596SBrooks Davis /* 16147c08596SBrooks Davis * Call any expired timeouts, and then if there's still 16247c08596SBrooks Davis * a timeout registered, time out the select call then. 16347c08596SBrooks Davis */ 16447c08596SBrooks Davis another: 16547c08596SBrooks Davis if (timeouts) { 16647c08596SBrooks Davis struct timeout *t; 16747c08596SBrooks Davis 16847c08596SBrooks Davis if (timeouts->when <= cur_time) { 16947c08596SBrooks Davis t = timeouts; 17047c08596SBrooks Davis timeouts = timeouts->next; 17147c08596SBrooks Davis (*(t->func))(t->what); 17247c08596SBrooks Davis t->next = free_timeouts; 17347c08596SBrooks Davis free_timeouts = t; 17447c08596SBrooks Davis goto another; 17547c08596SBrooks Davis } 17647c08596SBrooks Davis 17747c08596SBrooks Davis /* 17847c08596SBrooks Davis * Figure timeout in milliseconds, and check for 17947c08596SBrooks Davis * potential overflow, so we can cram into an 18047c08596SBrooks Davis * int for poll, while not polling with a 18147c08596SBrooks Davis * negative timeout and blocking indefinitely. 18247c08596SBrooks Davis */ 18347c08596SBrooks Davis howlong = timeouts->when - cur_time; 18447c08596SBrooks Davis if (howlong > INT_MAX / 1000) 18547c08596SBrooks Davis howlong = INT_MAX / 1000; 18647c08596SBrooks Davis to_msec = howlong * 1000; 18747c08596SBrooks Davis } else 18847c08596SBrooks Davis to_msec = -1; 18947c08596SBrooks Davis 19047c08596SBrooks Davis /* Set up the descriptors to be polled. */ 19147c08596SBrooks Davis for (i = 0, l = protocols; l; l = l->next) { 19247c08596SBrooks Davis struct interface_info *ip = l->local; 19347c08596SBrooks Davis 19447c08596SBrooks Davis if (ip && (l->handler != got_one || !ip->dead)) { 19547c08596SBrooks Davis fds[i].fd = l->fd; 19647c08596SBrooks Davis fds[i].events = POLLIN; 19747c08596SBrooks Davis fds[i].revents = 0; 19847c08596SBrooks Davis i++; 19947c08596SBrooks Davis } 20047c08596SBrooks Davis } 20147c08596SBrooks Davis 20247c08596SBrooks Davis if (i == 0) 20347c08596SBrooks Davis error("No live interfaces to poll on - exiting."); 20447c08596SBrooks Davis 20547c08596SBrooks Davis /* Wait for a packet or a timeout... XXX */ 20647c08596SBrooks Davis count = poll(fds, nfds, to_msec); 20747c08596SBrooks Davis 20847c08596SBrooks Davis /* Not likely to be transitory... */ 20947c08596SBrooks Davis if (count == -1) { 21047c08596SBrooks Davis if (errno == EAGAIN || errno == EINTR) { 21147c08596SBrooks Davis time(&cur_time); 21247c08596SBrooks Davis continue; 21347c08596SBrooks Davis } else 21447c08596SBrooks Davis error("poll: %m"); 21547c08596SBrooks Davis } 21647c08596SBrooks Davis 21747c08596SBrooks Davis /* Get the current time... */ 21847c08596SBrooks Davis time(&cur_time); 21947c08596SBrooks Davis 22047c08596SBrooks Davis i = 0; 22147c08596SBrooks Davis for (l = protocols; l; l = l->next) { 22247c08596SBrooks Davis struct interface_info *ip; 22347c08596SBrooks Davis ip = l->local; 22447c08596SBrooks Davis if ((fds[i].revents & (POLLIN | POLLHUP))) { 22547c08596SBrooks Davis fds[i].revents = 0; 22647c08596SBrooks Davis if (ip && (l->handler != got_one || 22747c08596SBrooks Davis !ip->dead)) 22847c08596SBrooks Davis (*(l->handler))(l); 22947c08596SBrooks Davis if (interfaces_invalidated) 23047c08596SBrooks Davis break; 23147c08596SBrooks Davis } 23247c08596SBrooks Davis i++; 23347c08596SBrooks Davis } 23447c08596SBrooks Davis interfaces_invalidated = 0; 23547c08596SBrooks Davis } while (1); 23647c08596SBrooks Davis } 23747c08596SBrooks Davis 23847c08596SBrooks Davis 23947c08596SBrooks Davis void 24047c08596SBrooks Davis got_one(struct protocol *l) 24147c08596SBrooks Davis { 24247c08596SBrooks Davis struct sockaddr_in from; 24347c08596SBrooks Davis struct hardware hfrom; 24447c08596SBrooks Davis struct iaddr ifrom; 24547c08596SBrooks Davis ssize_t result; 24647c08596SBrooks Davis union { 24747c08596SBrooks Davis /* 24847c08596SBrooks Davis * Packet input buffer. Must be as large as largest 24947c08596SBrooks Davis * possible MTU. 25047c08596SBrooks Davis */ 25147c08596SBrooks Davis unsigned char packbuf[4095]; 25247c08596SBrooks Davis struct dhcp_packet packet; 25347c08596SBrooks Davis } u; 25447c08596SBrooks Davis struct interface_info *ip = l->local; 25547c08596SBrooks Davis 25647c08596SBrooks Davis if ((result = receive_packet(ip, u.packbuf, sizeof(u), &from, 25747c08596SBrooks Davis &hfrom)) == -1) { 25847c08596SBrooks Davis warning("receive_packet failed on %s: %s", ip->name, 25947c08596SBrooks Davis strerror(errno)); 26047c08596SBrooks Davis ip->errors++; 26147c08596SBrooks Davis if ((!interface_status(ip)) || 26247c08596SBrooks Davis (ip->noifmedia && ip->errors > 20)) { 26347c08596SBrooks Davis /* our interface has gone away. */ 26447c08596SBrooks Davis warning("Interface %s no longer appears valid.", 26547c08596SBrooks Davis ip->name); 26647c08596SBrooks Davis ip->dead = 1; 26747c08596SBrooks Davis interfaces_invalidated = 1; 26847c08596SBrooks Davis close(l->fd); 26947c08596SBrooks Davis remove_protocol(l); 27047c08596SBrooks Davis free(ip); 27147c08596SBrooks Davis } 27247c08596SBrooks Davis return; 27347c08596SBrooks Davis } 27447c08596SBrooks Davis if (result == 0) 27547c08596SBrooks Davis return; 27647c08596SBrooks Davis 27747c08596SBrooks Davis if (bootp_packet_handler) { 27847c08596SBrooks Davis ifrom.len = 4; 27947c08596SBrooks Davis memcpy(ifrom.iabuf, &from.sin_addr, ifrom.len); 28047c08596SBrooks Davis 28147c08596SBrooks Davis (*bootp_packet_handler)(ip, &u.packet, result, 28247c08596SBrooks Davis from.sin_port, ifrom, &hfrom); 28347c08596SBrooks Davis } 28447c08596SBrooks Davis } 28547c08596SBrooks Davis 28647c08596SBrooks Davis int 28747c08596SBrooks Davis interface_status(struct interface_info *ifinfo) 28847c08596SBrooks Davis { 28947c08596SBrooks Davis char *ifname = ifinfo->name; 29047c08596SBrooks Davis int ifsock = ifinfo->rfdesc; 29147c08596SBrooks Davis struct ifreq ifr; 29247c08596SBrooks Davis struct ifmediareq ifmr; 29347c08596SBrooks Davis 29447c08596SBrooks Davis /* get interface flags */ 29547c08596SBrooks Davis memset(&ifr, 0, sizeof(ifr)); 29647c08596SBrooks Davis strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 29747c08596SBrooks Davis if (ioctl(ifsock, SIOCGIFFLAGS, &ifr) < 0) { 29847c08596SBrooks Davis syslog(LOG_ERR, "ioctl(SIOCGIFFLAGS) on %s: %m", ifname); 29947c08596SBrooks Davis goto inactive; 30047c08596SBrooks Davis } 30147c08596SBrooks Davis 30247c08596SBrooks Davis /* 30347c08596SBrooks Davis * if one of UP and RUNNING flags is dropped, 30447c08596SBrooks Davis * the interface is not active. 30547c08596SBrooks Davis */ 30647c08596SBrooks Davis if ((ifr.ifr_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) 30747c08596SBrooks Davis goto inactive; 30847c08596SBrooks Davis 30947c08596SBrooks Davis /* Next, check carrier on the interface, if possible */ 31047c08596SBrooks Davis if (ifinfo->noifmedia) 31147c08596SBrooks Davis goto active; 31247c08596SBrooks Davis memset(&ifmr, 0, sizeof(ifmr)); 31347c08596SBrooks Davis strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name)); 31447c08596SBrooks Davis if (ioctl(ifsock, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) { 31547c08596SBrooks Davis if (errno != EINVAL) { 31647c08596SBrooks Davis syslog(LOG_DEBUG, "ioctl(SIOCGIFMEDIA) on %s: %m", 31747c08596SBrooks Davis ifname); 31847c08596SBrooks Davis 31947c08596SBrooks Davis ifinfo->noifmedia = 1; 32047c08596SBrooks Davis goto active; 32147c08596SBrooks Davis } 32247c08596SBrooks Davis /* 32347c08596SBrooks Davis * EINVAL (or ENOTTY) simply means that the interface 32447c08596SBrooks Davis * does not support the SIOCGIFMEDIA ioctl. We regard it alive. 32547c08596SBrooks Davis */ 32647c08596SBrooks Davis ifinfo->noifmedia = 1; 32747c08596SBrooks Davis goto active; 32847c08596SBrooks Davis } 32947c08596SBrooks Davis if (ifmr.ifm_status & IFM_AVALID) { 33047c08596SBrooks Davis switch (ifmr.ifm_active & IFM_NMASK) { 33147c08596SBrooks Davis case IFM_ETHER: 33247c08596SBrooks Davis if (ifmr.ifm_status & IFM_ACTIVE) 33347c08596SBrooks Davis goto active; 33447c08596SBrooks Davis else 33547c08596SBrooks Davis goto inactive; 33647c08596SBrooks Davis break; 33747c08596SBrooks Davis default: 33847c08596SBrooks Davis goto inactive; 33947c08596SBrooks Davis } 34047c08596SBrooks Davis } 34147c08596SBrooks Davis inactive: 34247c08596SBrooks Davis return (0); 34347c08596SBrooks Davis active: 34447c08596SBrooks Davis return (1); 34547c08596SBrooks Davis } 34647c08596SBrooks Davis 34747c08596SBrooks Davis void 34847c08596SBrooks Davis add_timeout(time_t when, void (*where)(void *), void *what) 34947c08596SBrooks Davis { 35047c08596SBrooks Davis struct timeout *t, *q; 35147c08596SBrooks Davis 35247c08596SBrooks Davis /* See if this timeout supersedes an existing timeout. */ 35347c08596SBrooks Davis t = NULL; 35447c08596SBrooks Davis for (q = timeouts; q; q = q->next) { 35547c08596SBrooks Davis if (q->func == where && q->what == what) { 35647c08596SBrooks Davis if (t) 35747c08596SBrooks Davis t->next = q->next; 35847c08596SBrooks Davis else 35947c08596SBrooks Davis timeouts = q->next; 36047c08596SBrooks Davis break; 36147c08596SBrooks Davis } 36247c08596SBrooks Davis t = q; 36347c08596SBrooks Davis } 36447c08596SBrooks Davis 36547c08596SBrooks Davis /* If we didn't supersede a timeout, allocate a timeout 36647c08596SBrooks Davis structure now. */ 36747c08596SBrooks Davis if (!q) { 36847c08596SBrooks Davis if (free_timeouts) { 36947c08596SBrooks Davis q = free_timeouts; 37047c08596SBrooks Davis free_timeouts = q->next; 37147c08596SBrooks Davis q->func = where; 37247c08596SBrooks Davis q->what = what; 37347c08596SBrooks Davis } else { 37447c08596SBrooks Davis q = malloc(sizeof(struct timeout)); 37547c08596SBrooks Davis if (!q) 37647c08596SBrooks Davis error("Can't allocate timeout structure!"); 37747c08596SBrooks Davis q->func = where; 37847c08596SBrooks Davis q->what = what; 37947c08596SBrooks Davis } 38047c08596SBrooks Davis } 38147c08596SBrooks Davis 38247c08596SBrooks Davis q->when = when; 38347c08596SBrooks Davis 38447c08596SBrooks Davis /* Now sort this timeout into the timeout list. */ 38547c08596SBrooks Davis 38647c08596SBrooks Davis /* Beginning of list? */ 38747c08596SBrooks Davis if (!timeouts || timeouts->when > q->when) { 38847c08596SBrooks Davis q->next = timeouts; 38947c08596SBrooks Davis timeouts = q; 39047c08596SBrooks Davis return; 39147c08596SBrooks Davis } 39247c08596SBrooks Davis 39347c08596SBrooks Davis /* Middle of list? */ 39447c08596SBrooks Davis for (t = timeouts; t->next; t = t->next) { 39547c08596SBrooks Davis if (t->next->when > q->when) { 39647c08596SBrooks Davis q->next = t->next; 39747c08596SBrooks Davis t->next = q; 39847c08596SBrooks Davis return; 39947c08596SBrooks Davis } 40047c08596SBrooks Davis } 40147c08596SBrooks Davis 40247c08596SBrooks Davis /* End of list. */ 40347c08596SBrooks Davis t->next = q; 40447c08596SBrooks Davis q->next = NULL; 40547c08596SBrooks Davis } 40647c08596SBrooks Davis 40747c08596SBrooks Davis void 40847c08596SBrooks Davis cancel_timeout(void (*where)(void *), void *what) 40947c08596SBrooks Davis { 41047c08596SBrooks Davis struct timeout *t, *q; 41147c08596SBrooks Davis 41247c08596SBrooks Davis /* Look for this timeout on the list, and unlink it if we find it. */ 41347c08596SBrooks Davis t = NULL; 41447c08596SBrooks Davis for (q = timeouts; q; q = q->next) { 41547c08596SBrooks Davis if (q->func == where && q->what == what) { 41647c08596SBrooks Davis if (t) 41747c08596SBrooks Davis t->next = q->next; 41847c08596SBrooks Davis else 41947c08596SBrooks Davis timeouts = q->next; 42047c08596SBrooks Davis break; 42147c08596SBrooks Davis } 42247c08596SBrooks Davis t = q; 42347c08596SBrooks Davis } 42447c08596SBrooks Davis 42547c08596SBrooks Davis /* If we found the timeout, put it on the free list. */ 42647c08596SBrooks Davis if (q) { 42747c08596SBrooks Davis q->next = free_timeouts; 42847c08596SBrooks Davis free_timeouts = q; 42947c08596SBrooks Davis } 43047c08596SBrooks Davis } 43147c08596SBrooks Davis 43247c08596SBrooks Davis /* Add a protocol to the list of protocols... */ 43347c08596SBrooks Davis void 43447c08596SBrooks Davis add_protocol(char *name, int fd, void (*handler)(struct protocol *), 43547c08596SBrooks Davis void *local) 43647c08596SBrooks Davis { 43747c08596SBrooks Davis struct protocol *p; 43847c08596SBrooks Davis 43947c08596SBrooks Davis p = malloc(sizeof(*p)); 44047c08596SBrooks Davis if (!p) 44147c08596SBrooks Davis error("can't allocate protocol struct for %s", name); 44247c08596SBrooks Davis 44347c08596SBrooks Davis p->fd = fd; 44447c08596SBrooks Davis p->handler = handler; 44547c08596SBrooks Davis p->local = local; 44647c08596SBrooks Davis p->next = protocols; 44747c08596SBrooks Davis protocols = p; 44847c08596SBrooks Davis } 44947c08596SBrooks Davis 45047c08596SBrooks Davis void 45147c08596SBrooks Davis remove_protocol(struct protocol *proto) 45247c08596SBrooks Davis { 45347c08596SBrooks Davis struct protocol *p, *next, *prev; 45447c08596SBrooks Davis 45547c08596SBrooks Davis prev = NULL; 45647c08596SBrooks Davis for (p = protocols; p; p = next) { 45747c08596SBrooks Davis next = p->next; 45847c08596SBrooks Davis if (p == proto) { 45947c08596SBrooks Davis if (prev) 46047c08596SBrooks Davis prev->next = p->next; 46147c08596SBrooks Davis else 46247c08596SBrooks Davis protocols = p->next; 46347c08596SBrooks Davis free(p); 46447c08596SBrooks Davis } 46547c08596SBrooks Davis } 46647c08596SBrooks Davis } 46747c08596SBrooks Davis 46847c08596SBrooks Davis int 46947c08596SBrooks Davis interface_link_status(char *ifname) 47047c08596SBrooks Davis { 47147c08596SBrooks Davis struct ifmediareq ifmr; 47247c08596SBrooks Davis int sock; 47347c08596SBrooks Davis 47447c08596SBrooks Davis if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1) 47547c08596SBrooks Davis error("Can't create socket"); 47647c08596SBrooks Davis 47747c08596SBrooks Davis memset(&ifmr, 0, sizeof(ifmr)); 47847c08596SBrooks Davis strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name)); 47947c08596SBrooks Davis if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifmr) == -1) { 48047c08596SBrooks Davis /* EINVAL -> link state unknown. treat as active */ 48147c08596SBrooks Davis if (errno != EINVAL) 48247c08596SBrooks Davis syslog(LOG_DEBUG, "ioctl(SIOCGIFMEDIA) on %s: %m", 48347c08596SBrooks Davis ifname); 48447c08596SBrooks Davis close(sock); 48547c08596SBrooks Davis return (1); 48647c08596SBrooks Davis } 48747c08596SBrooks Davis close(sock); 48847c08596SBrooks Davis 48947c08596SBrooks Davis if (ifmr.ifm_status & IFM_AVALID) { 49047c08596SBrooks Davis if ((ifmr.ifm_active & IFM_NMASK) == IFM_ETHER) { 49147c08596SBrooks Davis if (ifmr.ifm_status & IFM_ACTIVE) 49247c08596SBrooks Davis return (1); 49347c08596SBrooks Davis else 49447c08596SBrooks Davis return (0); 49547c08596SBrooks Davis } 49647c08596SBrooks Davis } 49747c08596SBrooks Davis return (1); 49847c08596SBrooks Davis } 499