| /* rcs tags go here */ |
| /* Original author: Bruce M. Simpson <bms@FreeBSD.org> */ |
| |
| /*** |
| This file is part of avahi. |
| |
| avahi is free software; you can redistribute it and/or modify it |
| under the terms of the GNU Lesser General Public License as |
| published by the Free Software Foundation; either version 2.1 of the |
| License, or (at your option) any later version. |
| |
| avahi is distributed in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
| or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General |
| Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with avahi; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 |
| USA. |
| ***/ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <sys/param.h> |
| #include <sys/types.h> |
| #include <sys/socket.h> |
| #include <sys/sysctl.h> |
| |
| #include <net/if.h> |
| #include <net/route.h> |
| #include <netinet/in.h> |
| #include <arpa/inet.h> |
| |
| #include <stdarg.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <string.h> |
| |
| #include <unistd.h> |
| |
| #include <libdaemon/dlog.h> |
| |
| #include <avahi-common/llist.h> |
| #include <avahi-common/malloc.h> |
| |
| #include "iface.h" |
| |
| #ifndef IN_LINKLOCAL |
| #define IN_LINKLOCAL(i) (((u_int32_t)(i) & (0xffff0000)) == (0xa9fe0000)) |
| #endif |
| |
| #ifndef elementsof |
| #define elementsof(array) (sizeof(array)/sizeof(array[0])) |
| #endif |
| |
| #ifndef so_set_nonblock |
| #define so_set_nonblock(s, val) \ |
| do { \ |
| int __flags; \ |
| __flags = fcntl((s), F_GETFL); \ |
| if (__flags == -1) \ |
| break; \ |
| if (val != 0) \ |
| __flags |= O_NONBLOCK; \ |
| else \ |
| __flags &= ~O_NONBLOCK; \ |
| (void)fcntl((s), F_SETFL, __flags); \ |
| } while (0) |
| #endif |
| |
| #define MAX_RTMSG_SIZE 2048 |
| |
| struct rtm_dispinfo { |
| u_char *di_buf; |
| ssize_t di_buflen; |
| ssize_t di_len; |
| }; |
| |
| union rtmunion { |
| struct rt_msghdr rtm; |
| struct if_msghdr ifm; |
| struct ifa_msghdr ifam; |
| struct ifma_msghdr ifmam; |
| struct if_announcemsghdr ifan; |
| }; |
| typedef union rtmunion rtmunion_t; |
| |
| struct Address; |
| typedef struct Address Address; |
| |
| struct Address { |
| in_addr_t address; |
| AVAHI_LLIST_FIELDS(Address, addresses); |
| }; |
| |
| static int rtm_dispatch(void); |
| static int rtm_dispatch_newdeladdr(struct rtm_dispinfo *di); |
| static int rtm_dispatch_ifannounce(struct rtm_dispinfo *di); |
| static struct sockaddr *next_sa(struct sockaddr *sa); |
| |
| static int fd = -1; |
| static int ifindex = -1; |
| static AVAHI_LLIST_HEAD(Address, addresses) = NULL; |
| |
| int |
| iface_init(int idx) |
| { |
| |
| fd = socket(PF_ROUTE, SOCK_RAW, AF_INET); |
| if (fd == -1) { |
| daemon_log(LOG_ERR, "socket(PF_ROUTE): %s", strerror(errno)); |
| return (-1); |
| } |
| |
| so_set_nonblock(fd, 1); |
| |
| ifindex = idx; |
| |
| return (fd); |
| } |
| |
| int |
| iface_get_initial_state(State *state) |
| { |
| int mib[6]; |
| char *buf; |
| struct if_msghdr *ifm; |
| struct ifa_msghdr *ifam; |
| char *lim; |
| char *next; |
| struct sockaddr *sa; |
| size_t len; |
| int naddrs; |
| |
| assert(state != NULL); |
| assert(fd != -1); |
| |
| naddrs = 0; |
| |
| mib[0] = CTL_NET; |
| mib[1] = PF_ROUTE; |
| mib[2] = 0; |
| mib[3] = 0; |
| mib[4] = NET_RT_IFLIST; |
| mib[5] = ifindex; |
| |
| if (sysctl(mib, elementsof(mib), NULL, &len, NULL, 0) != 0) { |
| daemon_log(LOG_ERR, "sysctl(NET_RT_IFLIST): %s", |
| strerror(errno)); |
| return (-1); |
| } |
| |
| buf = malloc(len); |
| if (buf == NULL) { |
| daemon_log(LOG_ERR, "malloc(%d): %s", len, strerror(errno)); |
| return (-1); |
| } |
| |
| if (sysctl(mib, elementsof(mib), buf, &len, NULL, 0) != 0) { |
| daemon_log(LOG_ERR, "sysctl(NET_RT_IFLIST): %s", |
| strerror(errno)); |
| free(buf); |
| return (-1); |
| } |
| |
| lim = buf + len; |
| for (next = buf; next < lim; next += ifm->ifm_msglen) { |
| ifm = (struct if_msghdr *)next; |
| if (ifm->ifm_type == RTM_NEWADDR) { |
| ifam = (struct ifa_msghdr *)next; |
| sa = (struct sockaddr *)(ifam + 1); |
| if (sa->sa_family != AF_INET) |
| continue; |
| ++naddrs; |
| } |
| } |
| free(buf); |
| |
| *state = (naddrs > 0) ? STATE_SLEEPING : STATE_START; |
| |
| return (0); |
| } |
| |
| int |
| iface_process(Event *event) |
| { |
| int routable; |
| |
| assert(fd != -1); |
| |
| routable = !!addresses; |
| |
| if (rtm_dispatch() == -1) |
| return (-1); |
| |
| if (routable && !addresses) |
| *event = EVENT_ROUTABLE_ADDR_UNCONFIGURED; |
| else if (!routable && addresses) |
| *event = EVENT_ROUTABLE_ADDR_CONFIGURED; |
| |
| return (0); |
| } |
| |
| void |
| iface_done(void) |
| { |
| Address *a; |
| |
| if (fd != -1) { |
| close(fd); |
| fd = -1; |
| } |
| |
| while ((a = addresses) != NULL) { |
| AVAHI_LLIST_REMOVE(Address, addresses, addresses, a); |
| avahi_free(a); |
| } |
| } |
| |
| /* |
| * Dispatch kernel routing socket messages. |
| */ |
| static int |
| rtm_dispatch(void) |
| { |
| struct msghdr mh; |
| struct iovec iov[1]; |
| struct rt_msghdr *rtm; |
| struct rtm_dispinfo *di; |
| ssize_t len; |
| int retval; |
| |
| di = malloc(sizeof(*di)); |
| if (di == NULL) { |
| daemon_log(LOG_ERR, "malloc(%d): %s", sizeof(*di), |
| strerror(errno)); |
| return (-1); |
| } |
| di->di_buflen = MAX_RTMSG_SIZE; |
| di->di_buf = calloc(MAX_RTMSG_SIZE, 1); |
| if (di->di_buf == NULL) { |
| free(di); |
| daemon_log(LOG_ERR, "calloc(%d): %s", MAX_RTMSG_SIZE, |
| strerror(errno)); |
| return (-1); |
| } |
| |
| memset(&mh, 0, sizeof(mh)); |
| iov[0].iov_base = di->di_buf; |
| iov[0].iov_len = di->di_buflen; |
| mh.msg_iov = iov; |
| mh.msg_iovlen = 1; |
| |
| retval = 0; |
| for (;;) { |
| len = recvmsg(fd, &mh, MSG_DONTWAIT); |
| if (len == -1) { |
| if (errno == EWOULDBLOCK) |
| break; |
| else { |
| daemon_log(LOG_ERR, "recvmsg(): %s", |
| strerror(errno)); |
| retval = -1; |
| break; |
| } |
| } |
| |
| rtm = (void *)di->di_buf; |
| if (rtm->rtm_version != RTM_VERSION) { |
| daemon_log(LOG_ERR, |
| "unknown routing socket message (version %d)\n", |
| rtm->rtm_version); |
| /* this is non-fatal; just ignore it for now. */ |
| continue; |
| } |
| |
| switch (rtm->rtm_type) { |
| case RTM_NEWADDR: |
| case RTM_DELADDR: |
| retval = rtm_dispatch_newdeladdr(di); |
| break; |
| case RTM_IFANNOUNCE: |
| retval = rtm_dispatch_ifannounce(di); |
| break; |
| default: |
| daemon_log(LOG_DEBUG, "%s: rtm_type %d ignored", __func__, rtm->rtm_type); |
| break; |
| } |
| |
| /* |
| * If we got an error; assume our position on the call |
| * stack is enclosed by a level-triggered event loop, |
| * and signal the error condition. |
| */ |
| if (retval != 0) |
| break; |
| } |
| free(di->di_buf); |
| free(di); |
| |
| return (retval); |
| } |
| |
| /* handle link coming or going away */ |
| static int |
| rtm_dispatch_ifannounce(struct rtm_dispinfo *di) |
| { |
| rtmunion_t *rtm = (void *)di->di_buf; |
| |
| assert(rtm->rtm.rtm_type == RTM_IFANNOUNCE); |
| |
| daemon_log(LOG_DEBUG, "%s: IFANNOUNCE for ifindex %d", |
| __func__, rtm->ifan.ifan_index); |
| |
| switch (rtm->ifan.ifan_what) { |
| case IFAN_ARRIVAL: |
| if (rtm->ifan.ifan_index == ifindex) { |
| daemon_log(LOG_ERR, |
| "RTM_IFANNOUNCE IFAN_ARRIVAL, for ifindex %d, which we already manage.", |
| ifindex); |
| return (-1); |
| } |
| break; |
| case IFAN_DEPARTURE: |
| if (rtm->ifan.ifan_index == ifindex) { |
| daemon_log(LOG_ERR, "Interface vanished."); |
| return (-1); |
| } |
| break; |
| default: |
| /* ignore */ |
| break; |
| } |
| |
| return (0); |
| } |
| |
| static struct sockaddr * |
| next_sa(struct sockaddr *sa) |
| { |
| void *p; |
| size_t sa_size; |
| |
| #ifdef SA_SIZE |
| sa_size = SA_SIZE(sa); |
| #else |
| /* This is not foolproof, kernel may round. */ |
| sa_size = sa->sa_len; |
| if (sa_size < sizeof(u_long)) |
| sa_size = sizeof(u_long); |
| #endif |
| |
| p = ((char *)sa) + sa_size; |
| |
| return (struct sockaddr *)p; |
| } |
| |
| /* handle address coming or going away */ |
| static int |
| rtm_dispatch_newdeladdr(struct rtm_dispinfo *di) |
| { |
| Address *ap; |
| struct ifa_msghdr *ifam; |
| struct sockaddr *sa; |
| struct sockaddr_in *sin; |
| int link_local; |
| |
| /* macro to skip to next RTA; has side-effects */ |
| #define SKIPRTA(ifamsgp, rta, sa) \ |
| do { \ |
| if ((ifamsgp)->ifam_addrs & (rta)) \ |
| (sa) = next_sa((sa)); \ |
| } while (0) |
| |
| ifam = &((rtmunion_t *)di->di_buf)->ifam; |
| |
| assert(ifam->ifam_type == RTM_NEWADDR || |
| ifam->ifam_type == RTM_DELADDR); |
| |
| daemon_log(LOG_DEBUG, "%s: %s for iface %d (%s)", __func__, |
| ifam->ifam_type == RTM_NEWADDR ? "NEWADDR" : "DELADDR", |
| ifam->ifam_index, (ifam->ifam_index == ifindex) ? "ours" : "not ours"); |
| |
| if (ifam->ifam_index != ifindex) |
| return (0); |
| |
| if (!(ifam->ifam_addrs & RTA_IFA)) { |
| daemon_log(LOG_ERR, "ifa msg has no RTA_IFA."); |
| return (0); |
| } |
| |
| /* skip over rtmsg padding correctly */ |
| sa = (struct sockaddr *)(ifam + 1); |
| SKIPRTA(ifam, RTA_DST, sa); |
| SKIPRTA(ifam, RTA_GATEWAY, sa); |
| SKIPRTA(ifam, RTA_NETMASK, sa); |
| SKIPRTA(ifam, RTA_GENMASK, sa); |
| SKIPRTA(ifam, RTA_IFP, sa); |
| |
| /* |
| * sa now points to RTA_IFA sockaddr; we are only interested |
| * in updates for routable addresses. |
| */ |
| if (sa->sa_family != AF_INET) { |
| daemon_log(LOG_DEBUG, "%s: RTA_IFA family not AF_INET (=%d)", __func__, sa->sa_family); |
| return (0); |
| } |
| |
| sin = (struct sockaddr_in *)sa; |
| link_local = IN_LINKLOCAL(ntohl(sin->sin_addr.s_addr)); |
| |
| daemon_log(LOG_DEBUG, "%s: %s for %s (%s)", __func__, |
| ifam->ifam_type == RTM_NEWADDR ? "NEWADDR" : "DELADDR", |
| inet_ntoa(sin->sin_addr), link_local ? "link local" : "routable"); |
| |
| if (link_local) |
| return (0); |
| |
| for (ap = addresses; ap; ap = ap->addresses_next) { |
| if (ap->address == sin->sin_addr.s_addr) |
| break; |
| } |
| if (ifam->ifam_type == RTM_DELADDR && ap != NULL) { |
| AVAHI_LLIST_REMOVE(Address, addresses, addresses, ap); |
| avahi_free(ap); |
| } |
| if (ifam->ifam_type == RTM_NEWADDR && ap == NULL) { |
| ap = avahi_new(Address, 1); |
| ap->address = sin->sin_addr.s_addr; |
| AVAHI_LLIST_PREPEND(Address, addresses, addresses, ap); |
| } |
| |
| return (0); |
| #undef SKIPRTA |
| } |
