/* * dhcpcd - DHCP client daemon * Copyright 2006-2008 Roy Marples * All rights reserved * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "config.h" #include "common.h" #include "dhcp.h" #include "net.h" /* Darwin doesn't define this for some very odd reason */ #ifndef SA_SIZE # define SA_SIZE(sa) \ ( (!(sa) || ((struct sockaddr *)(sa))->sa_len == 0) ? \ sizeof(long) : \ 1 + ( (((struct sockaddr *)(sa))->sa_len - 1) | (sizeof(long) - 1) ) ) #endif int if_address(const char *ifname, const struct in_addr *address, const struct in_addr *netmask, const struct in_addr *broadcast, int action) { int s; int retval; struct ifaliasreq ifa; union { struct sockaddr *sa; struct sockaddr_in *sin; } _s; if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1) return -1; memset(&ifa, 0, sizeof(ifa)); strlcpy(ifa.ifra_name, ifname, sizeof(ifa.ifra_name)); #define ADDADDR(_var, _addr) \ _s.sa = &_var; \ _s.sin->sin_family = AF_INET; \ _s.sin->sin_len = sizeof(*_s.sin); \ memcpy(&_s.sin->sin_addr, _addr, sizeof(_s.sin->sin_addr)); ADDADDR(ifa.ifra_addr, address); ADDADDR(ifa.ifra_mask, netmask); if (action >= 0) { ADDADDR(ifa.ifra_broadaddr, broadcast); } #undef ADDADDR if (action < 0) retval = ioctl(s, SIOCDIFADDR, &ifa); else retval = ioctl(s, SIOCAIFADDR, &ifa); close(s); return retval; } int if_route(const struct interface *iface, const struct in_addr *dest, const struct in_addr *net, const struct in_addr *gate, _unused int metric, int action) { int s; union sockunion { struct sockaddr sa; struct sockaddr_in sin; #ifdef INET6 struct sockaddr_in6 sin6; #endif struct sockaddr_dl sdl; struct sockaddr_storage ss; } su; struct rtm { struct rt_msghdr hdr; char buffer[sizeof(su) * 4]; } rtm; char *bp = rtm.buffer, *p; size_t l; int retval = 0; #define ADDSU(_su) { \ l = SA_SIZE(&(_su.sa)); \ memcpy(bp, &(_su), l); \ bp += l; \ } #define ADDADDR(_addr) { \ memset (&su, 0, sizeof(su)); \ su.sin.sin_family = AF_INET; \ su.sin.sin_len = sizeof(su.sin); \ memcpy (&su.sin.sin_addr, _addr, sizeof(su.sin.sin_addr)); \ ADDSU(su); \ } if ((s = socket(PF_ROUTE, SOCK_RAW, 0)) == -1) return -1; memset(&rtm, 0, sizeof(rtm)); rtm.hdr.rtm_version = RTM_VERSION; rtm.hdr.rtm_seq = 1; if (action == 0) rtm.hdr.rtm_type = RTM_CHANGE; else if (action > 0) rtm.hdr.rtm_type = RTM_ADD; else rtm.hdr.rtm_type = RTM_DELETE; rtm.hdr.rtm_flags = RTF_UP; /* None interface subnet routes are static. */ if (gate->s_addr != INADDR_ANY || net->s_addr != iface->net.s_addr || dest->s_addr != (iface->addr.s_addr & iface->net.s_addr)) rtm.hdr.rtm_flags |= RTF_STATIC; rtm.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY; if (dest->s_addr == gate->s_addr && net->s_addr == INADDR_BROADCAST) rtm.hdr.rtm_flags |= RTF_HOST; else { rtm.hdr.rtm_addrs |= RTA_NETMASK; if (rtm.hdr.rtm_flags & RTF_STATIC) rtm.hdr.rtm_flags |= RTF_GATEWAY; if (action >= 0) rtm.hdr.rtm_addrs |= RTA_IFA; } ADDADDR(dest); if (rtm.hdr.rtm_flags & RTF_HOST || !(rtm.hdr.rtm_flags & RTF_STATIC)) { /* Make us a link layer socket for the host gateway */ memset(&su, 0, sizeof(su)); su.sdl.sdl_len = sizeof(struct sockaddr_dl); link_addr(iface->name, &su.sdl); ADDSU(su); } else ADDADDR(gate); if (rtm.hdr.rtm_addrs & RTA_NETMASK) { /* Ensure that netmask is set correctly */ memset(&su, 0, sizeof(su)); su.sin.sin_family = AF_INET; su.sin.sin_len = sizeof(su.sin); memcpy(&su.sin.sin_addr, &net->s_addr, sizeof(su.sin.sin_addr)); p = su.sa.sa_len + (char *)&su; for (su.sa.sa_len = 0; p > (char *)&su;) if (*--p != 0) { su.sa.sa_len = 1 + p - (char *)&su; break; } ADDSU(su); } if (rtm.hdr.rtm_addrs & RTA_IFA) ADDADDR(&iface->addr); rtm.hdr.rtm_msglen = l = bp - (char *)&rtm; if (write(s, &rtm, l) == -1) retval = -1; close(s); return retval; } int open_link_socket(struct interface *iface) { int fd; fd = socket(PF_ROUTE, SOCK_RAW, 0); if (fd == -1) return -1; set_cloexec(fd); if (iface->link_fd != -1) close(iface->link_fd); iface->link_fd = fd; return 0; } #define BUFFER_LEN 2048 int link_changed(struct interface *iface) { char buffer[2048], *p; ssize_t bytes; struct rt_msghdr *rtm; struct if_msghdr *ifm; int i; if ((i = if_nametoindex(iface->name)) == -1) return -1; for (;;) { bytes = recv(iface->link_fd, buffer, BUFFER_LEN, MSG_DONTWAIT); if (bytes == -1) { if (errno == EAGAIN) return 0; if (errno == EINTR) continue; return -1; } for (p = buffer; bytes > 0; bytes -= ((struct rt_msghdr *)p)->rtm_msglen, p += ((struct rt_msghdr *)p)->rtm_msglen) { rtm = (struct rt_msghdr *)p; if (rtm->rtm_type != RTM_IFINFO) continue; ifm = (struct if_msghdr *)p; if (ifm->ifm_index != i) continue; /* Link changed */ return 1; } } return 0; }