/* vim: set expandtab ts=4 sw=4: */ /* * You may redistribute this program and/or modify it under the terms of * the GNU General Public License as published by the Free Software Foundation, * either version 3 of the License, or (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "util/platform/netdev/NetPlatform.h" #include "util/platform/Sockaddr.h" #include "memory/Allocator.h" #include "exception/Except.h" #include "wire/Message.h" #include "util/AddrTools.h" #include "util/Assert.h" #include "util/CString.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if ! defined(Cjdns_android) #include #endif #include #include #include // Way to identify our routes as opposed to statically created or otherwise... #define RTPROT_CJDNS 52 /** * This hack exists because linux/in.h and linux/in6.h define * the same structures, leading to redefinition errors. * For the second operand, we're grateful to android/bionic, platform level 21. */ struct Cjdns_in6_ifreq { struct in6_addr ifr6_addr; uint32_t ifr6_prefixlen; int ifr6_ifindex; }; /** * Get a socket and ifRequest for a given interface by name. * * @param interfaceName the name of the interface, eg: tun0 * @param af either AF_INET or AF_INET6 * @param eg an exception handler in case something goes wrong. * this will send a -1 for all errors. * @param ifRequestOut an ifreq which will be populated with the interface index of the interface. * @return a socket for interacting with this interface. */ static Er_DEFUN(int socketForIfName(const char* interfaceName, int af, struct Allocator* alloc, struct ifreq* ifRequestOut)) { int s; if ((s = socket(af, SOCK_DGRAM, 0)) < 0) { Er_raise(alloc, "socket() [%s]", strerror(errno)); } memset(ifRequestOut, 0, sizeof(struct ifreq)); CString_safeStrncpy(ifRequestOut->ifr_name, interfaceName, IFNAMSIZ); if (ioctl(s, SIOCGIFINDEX, ifRequestOut) < 0) { int err = errno; close(s); Er_raise(alloc, "ioctl(SIOCGIFINDEX) [%s]", strerror(err)); } Er_ret(s); } /** don't use if_nametoindex() because it accesses the filesystem. */ static Er_DEFUN(int ifIndexForName(const char* interfaceName, struct Allocator* alloc)) { struct ifreq ifRequest; int s = Er(socketForIfName(interfaceName, AF_INET, alloc, &ifRequest)); close(s); Er_ret(ifRequest.ifr_ifindex); } static Er_DEFUN(void checkInterfaceUp(int socket, struct ifreq* ifRequest, struct Log* logger, struct Allocator* alloc)) { if (ioctl(socket, SIOCGIFFLAGS, ifRequest) < 0) { int err = errno; close(socket); Er_raise(alloc, "ioctl(SIOCGIFFLAGS) [%s]", strerror(err)); } if (ifRequest->ifr_flags & IFF_UP & IFF_RUNNING) { // already up. Er_ret(); } Log_info(logger, "Bringing up interface [%s]", ifRequest->ifr_name); ifRequest->ifr_flags |= IFF_UP | IFF_RUNNING; if (ioctl(socket, SIOCSIFFLAGS, ifRequest) < 0) { int err = errno; close(socket); Er_raise(alloc, "ioctl(SIOCSIFFLAGS) [%s]", strerror(err)); } Er_ret(); } Er_DEFUN(void NetPlatform_addAddress(const char* interfaceName, const uint8_t* address, int prefixLen, int addrFam, struct Log* logger, struct Allocator* tempAlloc)) { struct ifreq ifRequest; int s = Er(socketForIfName(interfaceName, addrFam, tempAlloc, &ifRequest)); int ifIndex = ifRequest.ifr_ifindex; // checkInterfaceUp() clobbers the ifindex. Er(checkInterfaceUp(s, &ifRequest, logger, tempAlloc)); if (addrFam == Sockaddr_AF_INET6) { struct Cjdns_in6_ifreq ifr6 = { .ifr6_ifindex = ifIndex, .ifr6_prefixlen = prefixLen }; memcpy(&ifr6.ifr6_addr, address, 16); if (ioctl(s, SIOCSIFADDR, &ifr6) < 0) { int err = errno; close(s); if (err == EPERM) { Er_raise(tempAlloc, "ioctl permission denied, Are you root and is ipv6 enabled?"); } else { Er_raise(tempAlloc, "ioctl(SIOCSIFADDR) failed: [%s]", strerror(err)); } } } else if (addrFam == Sockaddr_AF_INET) { struct sockaddr_in sin = { .sin_family = AF_INET, .sin_port = 0 }; memcpy(&sin.sin_addr.s_addr, address, 4); memcpy(&ifRequest.ifr_addr, &sin, sizeof(struct sockaddr)); if (ioctl(s, SIOCSIFADDR, &ifRequest) < 0) { int err = errno; close(s); Er_raise(tempAlloc, "ioctl(SIOCSIFADDR) failed: [%s]", strerror(err)); } uint32_t x = (uint32_t)~0 << (32 - prefixLen); x = Endian_hostToBigEndian32(x); memcpy(&sin.sin_addr, &x, 4); memcpy(&ifRequest.ifr_addr, &sin, sizeof(struct sockaddr_in)); if (ioctl(s, SIOCSIFNETMASK, &ifRequest) < 0) { int err = errno; close(s); Er_raise(tempAlloc, "ioctl(SIOCSIFNETMASK) failed: [%s]", strerror(err)); } } else { Assert_true(0); } close(s); Er_ret(); } Er_DEFUN(void NetPlatform_setMTU(const char* interfaceName, uint32_t mtu, struct Log* logger, struct Allocator* alloc)) { struct ifreq ifRequest; int s = Er(socketForIfName(interfaceName, AF_INET6, alloc, &ifRequest)); Log_info(logger, "Setting MTU for device [%s] to [%u] bytes.", interfaceName, mtu); ifRequest.ifr_mtu = mtu; if (ioctl(s, SIOCSIFMTU, &ifRequest) < 0) { int err = errno; close(s); Er_raise(alloc, "ioctl(SIOCSIFMTU) [%s]", strerror(err)); } close(s); Er_ret(); } struct IfIndexAttr { struct rtattr rta; int ifIndex; }; Assert_compileTime(sizeof(struct IfIndexAttr) == 8); struct RouteRequest { struct nlmsghdr hdr; struct rtmsg route; }; Assert_compileTime(sizeof(struct nlmsghdr) == 16); Assert_compileTime(sizeof(struct rtmsg) == 12); Assert_compileTime(sizeof(struct RouteRequest) == 28); struct RouteInfo; struct RouteInfo { struct RouteInfo* next; int protocol; int prefix; uint8_t dstAddr[16]; int ifIndex; int af; }; #define BUFF_SZ 16384 static Er_DEFUN(bool getMoreMessages(struct RouteInfo** rio, int sock, int ifIndex, struct Allocator* alloc)) { bool retVal = false; struct Allocator* tempAlloc = Allocator_child(alloc); struct Message* msg = Message_new(BUFF_SZ, 0, tempAlloc); ssize_t sz = recv(sock, msg->msgbytes, BUFF_SZ, MSG_TRUNC); if (sz < (ssize_t)sizeof(struct nlmsghdr)) { Er_raise(tempAlloc, "recv() -> %s", strerror(errno)); } else if (sz > BUFF_SZ) { Er_raise(tempAlloc, "recv() -> buffer too small"); } Er_assert(Message_truncate(msg, sz)); //printf("%s\n", Hex_print(msg->bytes, Message_getLength(msg), tempAlloc)); while (Message_getLength(msg)) { struct RouteInfo ri = { .protocol = 0 }; int initMsgLen = Message_getLength(msg); struct nlmsghdr hdr; Er(Message_epop(msg, &hdr, sizeof(struct nlmsghdr))); //printf("\nHEADER %04x %04x\n", hdr.nlmsg_type, hdr.nlmsg_flags); if (hdr.nlmsg_flags & NLM_F_MULTI) { retVal = true; } if (hdr.nlmsg_type == NLMSG_DONE) { Allocator_free(tempAlloc); Er_ret(false); } struct rtmsg rtm; Er(Message_epop(msg, &rtm, sizeof(struct rtmsg))); ri.prefix = rtm.rtm_dst_len; ri.af = rtm.rtm_family; ri.protocol = rtm.rtm_protocol; for (;;) { int remainingLen = hdr.nlmsg_len - (initMsgLen - Message_getLength(msg)); if (remainingLen <= (int)sizeof(struct rtattr)) { break; } struct rtattr attrHead; //printf(">%s %d\n", Hex_print(msg->bytes, Message_getLength(msg), tempAlloc), remainingLen); Er(Message_epop(msg, &attrHead, sizeof(struct rtattr))); switch (attrHead.rta_type) { case RTA_OIF: { if (attrHead.rta_len != 8) { Er_raise(alloc, "unexpected rta_len for ifIndex"); } Er(Message_epop(msg, &ri.ifIndex, 4)); break; } case RTA_DST: { if (rtm.rtm_family == AF_INET6) { if (attrHead.rta_len != 20) { Er_raise(alloc, "unexpected rta_len for RTA_DST (ipv6)"); } Er(Message_epop(msg, ri.dstAddr, 16)); } else if (rtm.rtm_family == AF_INET) { if (attrHead.rta_len != 8) { Er_raise(alloc, "unexpected rta_len for RTA_DST (ipv4)"); } Er(Message_epop(msg, ri.dstAddr, 4)); } else { Er_raise(alloc, "unexpected af %d", rtm.rtm_family); } break; } default: { int effectiveLen = RTA_ALIGN(attrHead.rta_len); //printf("unrecognized %d (length %d)\n", attrHead.rta_type, effectiveLen); Er(Message_epop(msg, NULL, effectiveLen - sizeof(struct rtattr))); break; } } } if (rtm.rtm_table != RT_TABLE_MAIN) { continue; } if (rtm.rtm_type != RTN_UNICAST) { continue; } if (ri.ifIndex != ifIndex) { continue; } if (ri.protocol != RTPROT_CJDNS) { continue; } struct RouteInfo* outRi = Allocator_clone(alloc, &ri); outRi->next = *rio; *rio = outRi; } Allocator_free(tempAlloc); Er_ret(retVal); } static Er_DEFUN(struct RouteInfo* getRoutes(int sock, int ifIndex, struct Allocator* alloc)) { struct RouteRequest req = { .hdr = { .nlmsg_len = sizeof(struct RouteRequest), .nlmsg_type = RTM_GETROUTE, .nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT | NLM_F_MULTI }, .route = { .rtm_family = AF_UNSPEC } }; ssize_t sz = send(sock, &req, req.hdr.nlmsg_len, 0); if (sz < 0) { Er_raise(alloc, "send() -> %s", strerror(errno)); } struct RouteInfo* ri = NULL; while (Er(getMoreMessages(&ri, sock, ifIndex, alloc))) ; Er_ret(ri); } static void bitShave(uint8_t* address, int prefix, int af) { int top; if (af == AF_INET) { top = 4; } else if (af == AF_INET6) { top = 16; } else { Assert_failure("bad af"); } if (prefix < (8 * top)) { address[prefix >> 3] &= ( 0xff << (8 - (prefix % 8)) ); for (int i = (prefix >> 3) + 1; i < top; i++) { address[i] = 0; } } } static Er_DEFUN(void addDeleteRoutes(int sock, bool delete, struct RouteInfo* ri, struct Allocator* tempAlloc)) { struct Message* msg = Message_new(0, 512, tempAlloc); for (;ri;ri = ri->next) { struct IfIndexAttr ifa = { .rta = { .rta_len = sizeof(struct IfIndexAttr), .rta_type = RTA_OIF }, .ifIndex = ri->ifIndex }; Er(Message_epush(msg, &ifa, sizeof(struct IfIndexAttr))); int addrLen = (ri->af == AF_INET6) ? 16 : 4; Er(Message_epush(msg, ri->dstAddr, addrLen)); bitShave(msg->msgbytes, ri->prefix, ri->af); struct rtattr rta = { .rta_len = sizeof(struct rtattr) + addrLen, .rta_type = RTA_DST }; Er(Message_epush(msg, &rta, sizeof(struct rtattr))); struct rtmsg route = { .rtm_family = ri->af, .rtm_dst_len = ri->prefix, .rtm_table = RT_TABLE_MAIN, .rtm_scope = (delete) ? RT_SCOPE_NOWHERE : RT_SCOPE_LINK, .rtm_protocol = (delete) ? RTPROT_UNSPEC : ri->protocol, .rtm_type = (delete) ? RTN_UNSPEC : RTN_UNICAST }; Er(Message_epush(msg, &route, sizeof(struct rtmsg))); struct nlmsghdr hdr = { .nlmsg_len = Message_getLength(msg) + sizeof(struct nlmsghdr), .nlmsg_type = (delete) ? RTM_DELROUTE : RTM_NEWROUTE, .nlmsg_flags = NLM_F_REQUEST | ((delete) ? 0 : NLM_F_CREATE) // | NLM_F_ACK, }; Er(Message_epush(msg, &hdr, sizeof(struct nlmsghdr))); ssize_t sz = send(sock, msg->msgbytes, Message_getLength(msg), 0); if (sz < 0) { Er_raise(tempAlloc, "send() -> %s", strerror(errno)); } Message_reset(msg); } Er_ret(); } static int closeSocket(struct Allocator_OnFreeJob* job) { long sock = (long) job->userData; close((int)sock); return 0; } static Er_DEFUN(int mkSocket(struct Allocator* alloc)) { int sock = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (sock < 0) { Er_raise(alloc, "socket(PF_NETLINK) -> %s", strerror(errno)); } Allocator_onFree(alloc, closeSocket, (void*) ((long) sock)); Er_ret(sock); } static struct RouteInfo* riForSockaddrs(struct Sockaddr** prefixSet, int prefixCount, int ifIndex, struct Allocator* alloc) { struct RouteInfo* out = NULL; for (int i = 0; i < prefixCount; i++) { struct RouteInfo* ri = Allocator_calloc(alloc, sizeof(struct RouteInfo), 1); ri->protocol = RTPROT_CJDNS; ri->prefix = Sockaddr_getPrefix(prefixSet[i]); ri->af = Sockaddr_getFamily(prefixSet[i]); ri->ifIndex = ifIndex; uint8_t* addr; int len = Sockaddr_getAddress(prefixSet[i], &addr); Assert_true(len == 4 || len == 16); Bits_memcpy(ri->dstAddr, addr, len); ri->next = out; out = ri; } return out; } static void logRis(struct RouteInfo* ri, struct Log* logger, char* msg) { for (; ri; ri = ri->next) { uint8_t addrBuff[40] = {0}; if (ri->af == AF_INET6) { AddrTools_printIp(addrBuff, ri->dstAddr); } else if (ri->af == AF_INET) { snprintf(addrBuff, 40, "%u.%u.%u.%u", ri->dstAddr[0], ri->dstAddr[1], ri->dstAddr[2], ri->dstAddr[3]); } Log_debug(logger, "%s %s/%u", msg, addrBuff, ri->prefix); } } Er_DEFUN(void NetPlatform_setRoutes(const char* ifName, struct Sockaddr** prefixSet, int prefixCount, struct Log* logger, struct Allocator* tempAlloc)) { int ifIndex = Er(ifIndexForName(ifName, tempAlloc)); struct RouteInfo* newRi = riForSockaddrs(prefixSet, prefixCount, ifIndex, tempAlloc); int sock = Er(mkSocket(tempAlloc)); struct RouteInfo* oldRi = Er(getRoutes(sock, ifIndex, tempAlloc)); logRis(oldRi, logger, "DELETE ROUTE"); Er(addDeleteRoutes(sock, true, oldRi, tempAlloc)); logRis(newRi, logger, "ADD ROUTE"); Er(addDeleteRoutes(sock, false, newRi, tempAlloc)); Er_ret(); }