/* 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 "exception/Except.h"
#include "util/platform/netdev/NetPlatform.h"
#include "util/AddrTools.h"
#include "util/platform/Sockaddr.h"
#include "util/Assert.h"
#include "util/Bits.h"
#include "util/CString.h"
#include "wire/Message.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define ArrayList_TYPE struct Sockaddr
#define ArrayList_NAME OfSockaddr
#include "util/ArrayList.h"
Assert_compileTime(sizeof(struct in_addr) == 4);
struct RouteMessage4 {
struct rt_msghdr header;
struct sockaddr_in dest;
struct sockaddr_dl link;
struct sockaddr_in netmask;
};
Assert_compileTime(sizeof(struct rt_msghdr) == 92);
Assert_compileTime(sizeof(struct sockaddr_in) == 16);
Assert_compileTime(sizeof(struct sockaddr_dl) == 20);
Assert_compileTime(sizeof(struct RouteMessage4) == 144);
static Er_DEFUN(void mkRouteMsg(struct Message* msg,
struct Sockaddr* addRoute,
int ifIndex,
const char* ifName,
int seq,
bool delete))
{
if (CString_strlen(ifName) >= 12) {
Er_raise(Message_getAlloc(msg), "ifName [%s] too long, limit 11 chars", ifName);
}
int lengthBegin = Message_getLength(msg);
bool ipv6 = Sockaddr_getFamily(addRoute) == Sockaddr_AF_INET6;
if (ipv6) {
struct sockaddr_in6 mask = {
.sin6_family = AF_INET6,
.sin6_len = sizeof(struct sockaddr_in6)
};
Bits_memset((void *)&mask.sin6_addr, 0xff, addRoute->prefix >> 3);
((uint8_t*)&mask.sin6_addr)[addRoute->prefix >> 3] = 0xff << (8 - (addRoute->prefix % 8));
Er(Message_epush(msg, &mask, sizeof(struct sockaddr_in6)));
} else {
struct sockaddr_in mask = {
.sin_family = AF_INET,
.sin_len = sizeof(struct sockaddr_in)
};
mask.sin_addr.s_addr = Endian_hostToBigEndian32(~0u << (32 - addRoute->prefix));
Er(Message_epush(msg, &mask, sizeof(struct sockaddr_in)));
}
if (!delete) {
struct sockaddr_dl link = {
.sdl_family = AF_LINK,
.sdl_len = sizeof(struct sockaddr_dl),
.sdl_type = IFT_OTHER,
.sdl_index = ifIndex,
.sdl_nlen = CString_strlen(ifName)
};
CString_safeStrncpy(link.sdl_data, ifName, 12);
Er(Message_epush(msg, &link, sizeof(struct sockaddr_dl)));
}
void* dest = Sockaddr_asNative(addRoute);
int len = (ipv6) ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
((struct sockaddr*)dest)->sa_len = len;
Er(Message_epush(msg, dest, len));
struct rt_msghdr hdr = {
.rtm_type = (delete) ? RTM_DELETE : RTM_ADD,
.rtm_flags = RTF_UP | RTF_STATIC,
.rtm_version = RTM_VERSION,
.rtm_seq = seq,
.rtm_pid = getpid(),
.rtm_addrs = RTA_DST | RTA_NETMASK | ((delete) ? 0 : RTA_GATEWAY),
.rtm_msglen = sizeof(struct rt_msghdr) + (Message_getLength(msg) - lengthBegin)
};
Er(Message_epush(msg, &hdr, sizeof(struct rt_msghdr)));
Er_ret();
}
static Er_DEFUN(void setRoutes(uint32_t ifIndex,
const char* ifName,
struct ArrayList_OfSockaddr* toRemove,
struct ArrayList_OfSockaddr* toAdd,
struct Log* logger,
struct Allocator* alloc))
{
int seq = 0;
int sock = socket(PF_ROUTE, SOCK_RAW, 0);
if (sock == -1) {
int err = errno;
close(sock);
Er_raise(alloc, "open route socket [%s]", strerror(err));
}
bool err = false;
ssize_t returnLen = 0;
for (int i = 0; !err && i < toRemove->length; i++) {
struct Sockaddr* pfx = ArrayList_OfSockaddr_get(toRemove, i);
Log_debug(logger, "DELETE ROUTE %s", Sockaddr_print(pfx, alloc));
struct Message* msg = Message_new(0, 1024, alloc);
Er(mkRouteMsg(msg, pfx, ifIndex, ifName, seq++, true));
//printf("DELETE ROUTE %s\n", Hex_print(msg->bytes, Message_getLength(msg), alloc));
returnLen = write(sock, msg->msgbytes, Message_getLength(msg));
if (returnLen < Message_getLength(msg)) { err = true; break; }
}
for (int i = 0; !err && i < toAdd->length; i++) {
struct Sockaddr* pfx = ArrayList_OfSockaddr_get(toAdd, i);
Log_debug(logger, "ADD ROUTE %s", Sockaddr_print(pfx, alloc));
struct Message* msg = Message_new(0, 1024, alloc);
Er(mkRouteMsg(msg, pfx, ifIndex, ifName, seq++, false));
//printf("ADD ROUTE %s\n", Hex_print(msg->bytes, Message_getLength(msg), alloc));
returnLen = write(sock, msg->msgbytes, Message_getLength(msg));
if (returnLen < Message_getLength(msg)) { err = true; break; }
}
if (returnLen < 0) {
int error = errno;
close(sock);
Er_raise(alloc, "setRoutes() [%s]", strerror(error));
} else if (err) {
close(sock);
Er_raise(alloc, "setRoutes() returned short");
}
close(sock);
Er_ret();
}
static int prefixFromWeirdBSDMask(uint8_t* weirdBsdMask, bool ipv6)
{
uint8_t len = weirdBsdMask[0];
int out;
if (ipv6) {
Assert_true(len >= 8);
out = (len - 9) * 8;
} else {
Assert_true(len >= 4);
out = (len - 5) * 8;
}
for (int i = 1; i < len - 1; i++) {
Assert_true(weirdBsdMask[i] == 0xff);
}
return out + Bits_popCountx32(weirdBsdMask[len - 1]);
}
static Er_DEFUN(struct ArrayList_OfSockaddr* getRoutes(uint32_t ifIndex,
struct Log* logger,
struct Allocator* allocator))
{
size_t needed;
int mib[] = { CTL_NET, PF_ROUTE, 0, 0, NET_RT_DUMP, 0 };
if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
Er_raise(allocator, "sysctl(net.route.0.0.dump) estimate");
}
struct Allocator* tempAlloc = Allocator_child(allocator);
uint8_t* buf = Allocator_malloc(tempAlloc, needed);
if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
Er_raise(allocator, "sysctl(net.route.0.0.dump)");
}
struct ArrayList_OfSockaddr* addrList = ArrayList_OfSockaddr_new(allocator);
for (int i = 0; i < (int)needed;) {
struct rt_msghdr* rtm = (struct rt_msghdr*) (&buf[i]);
i += rtm->rtm_msglen;
struct sockaddr* sa1 = (struct sockaddr*)(rtm + 1);
struct sockaddr* sa2 = (struct sockaddr*)(sa1->sa_len + (char *)sa1);
uint8_t* mask = (uint8_t*) (sa2->sa_len + (char*)sa2);
Assert_true(&buf[i] >= mask);
if (sa2->sa_family != AF_LINK) { continue; }
if (rtm->rtm_flags & RTF_LOCAL) { continue; }
if (!(rtm->rtm_flags & RTF_STATIC)) { continue; }
if (((struct sockaddr_dl*) sa2)->sdl_index != ifIndex) { continue; }
bool ipv6 = (sa1->sa_family == AF_INET6);
if (!ipv6 && (sa1->sa_family != AF_INET)) { continue; }
// printf("GOT ROUTE %s\n", Hex_print(rtm, rtm->rtm_msglen, tempAlloc));
int prefix;
if (&buf[i] < &mask[mask[0]] || mask[0] == 0) {
//Assert_true(rtm->rtm_flags & RTF_HOST);
prefix = (ipv6) ? 128 : 32;
} else {
prefix = prefixFromWeirdBSDMask(mask, ipv6);
}
struct Sockaddr* addr = Sockaddr_fromNative(sa1, sa1->sa_len, allocator);
addr->flags |= Sockaddr_flags_PREFIX;
addr->prefix = prefix;
ArrayList_OfSockaddr_add(addrList, addr);
}
Allocator_free(tempAlloc);
Er_ret(addrList);
}
static Er_DEFUN(void addIp4Address(const char* interfaceName,
const uint8_t address[4],
int prefixLen,
struct Log* logger,
struct Allocator* tempAlloc))
{
struct ifaliasreq ifarted;
Bits_memset(&ifarted, 0, sizeof(struct ifaliasreq));
CString_safeStrncpy(ifarted.ifra_name, interfaceName, IFNAMSIZ);
struct sockaddr_in sin = { .sin_family = AF_INET, .sin_len = sizeof(struct sockaddr_in) };
Bits_memcpy(&sin.sin_addr.s_addr, address, 4);
Bits_memcpy(&ifarted.ifra_addr, &sin, sizeof(struct sockaddr_in));
sin.sin_addr.s_addr = Endian_hostToBigEndian32(~0u << (32 - prefixLen));
Bits_memcpy(&ifarted.ifra_mask, &sin, sizeof(struct sockaddr_in));
int s = socket(AF_INET, SOCK_DGRAM, 0);
if (s < 0) {
Er_raise(tempAlloc, "socket() [%s]", strerror(errno));
}
// will probably fail, ignore result.
struct ifreq ifr = { .ifr_flags = 0 };
CString_safeStrncpy(ifr.ifr_name, interfaceName, IFNAMSIZ);
ioctl(s, SIOCDIFADDR, &ifr);
if (ioctl(s, SIOCSIFADDR, &ifarted) < 0) {
int err = errno;
close(s);
Er_raise(tempAlloc, "ioctl(SIOCSIFADDR) [%s]", strerror(err));
}
//setupRoute4(address, prefixLen, interfaceName, logger, tempAlloc, eh);
Log_info(logger, "Configured IPv4 [%u.%u.%u.%u/%i] for [%s]",
address[0], address[1], address[2], address[3], prefixLen, interfaceName);
close(s);
Er_ret();
}
static Er_DEFUN(void addIp6Address(const char* interfaceName,
const uint8_t address[16],
int prefixLen,
struct Log* logger,
struct Allocator* errAlloc))
{
/* stringify our IP address */
char myIp[40];
AddrTools_printIp((uint8_t*)myIp, address);
/* set up the interface ip assignment request */
struct in6_aliasreq in6_addreq;
memset(&in6_addreq, 0, sizeof(in6_addreq));
in6_addreq.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
in6_addreq.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
/* parse the IPv6 address and add it to the request */
struct addrinfo hints, *result;
bzero(&hints, sizeof(struct addrinfo));
hints.ai_family = AF_INET6;
int err = getaddrinfo((const char *)myIp, NULL, &hints, &result);
if (err) {
// Should never happen since the address is specified as binary.
Er_raise(errAlloc, "bad IPv6 address [%s]", gai_strerror(err));
}
bcopy(result->ai_addr, &in6_addreq.ifra_addr, result->ai_addrlen);
/* turn the prefixlen into a mask, and add it to the request */
struct sockaddr_in6* mask = &in6_addreq.ifra_prefixmask;
mask->sin6_len = sizeof(*mask);
if (prefixLen >= 128 || prefixLen <= 0) {
memset(&mask->sin6_addr, 0xff, sizeof(struct in6_addr));
} else {
memset((void *)&mask->sin6_addr, 0x00, sizeof(mask->sin6_addr));
memset((void *)&mask->sin6_addr, 0xff, prefixLen>>3);
((uint8_t*)&mask->sin6_addr)[prefixLen>>3] = 0xff << (8 - (prefixLen%8));
}
CString_safeStrncpy(in6_addreq.ifra_name, interfaceName, sizeof(in6_addreq.ifra_name));
/* do the actual assignment ioctl */
int s = socket(AF_INET6, SOCK_DGRAM, 0);
if (s < 0) {
Er_raise(errAlloc, "socket() [%s]", strerror(errno));
}
if (ioctl(s, SIOCAIFADDR_IN6, &in6_addreq) < 0) {
int err = errno;
close(s);
Er_raise(errAlloc, "ioctl(SIOCAIFADDR) [%s] for [%s]", strerror(err), interfaceName);
}
Log_info(logger, "Configured IPv6 [%s/%i] for [%s]", myIp, prefixLen, interfaceName);
close(s);
Er_ret();
}
Er_DEFUN(void NetPlatform_addAddress(const char* interfaceName,
const uint8_t* address,
int prefixLen,
int addrFam,
struct Log* logger,
struct Allocator* tempAlloc))
{
if (addrFam == Sockaddr_AF_INET6) {
Er(addIp6Address(interfaceName, address, prefixLen, logger, tempAlloc));
} else if (addrFam == Sockaddr_AF_INET) {
Er(addIp4Address(interfaceName, address, prefixLen, logger, tempAlloc));
} else {
Assert_true(0);
}
Er_ret();
}
Er_DEFUN(void NetPlatform_setMTU(const char* interfaceName,
uint32_t mtu,
struct Log* logger,
struct Allocator* errAlloc))
{
int s = socket(AF_INET6, SOCK_DGRAM, 0);
if (s < 0) {
Er_raise(errAlloc, "socket() [%s]", strerror(errno));
}
struct ifreq ifRequest;
CString_safeStrncpy(ifRequest.ifr_name, interfaceName, IFNAMSIZ);
ifRequest.ifr_mtu = mtu;
Log_info(logger, "Setting MTU for device [%s] to [%u] bytes.", interfaceName, mtu);
if (ioctl(s, SIOCSIFMTU, &ifRequest) < 0) {
int err = errno;
close(s);
Er_raise(errAlloc, "ioctl(SIOCSIFMTU) [%s]", strerror(err));
}
close(s);
Er_ret();
}
Er_DEFUN(void NetPlatform_setRoutes(const char* ifName,
struct Sockaddr** prefixSet,
int prefixCount,
struct Log* logger,
struct Allocator* tempAlloc))
{
struct ArrayList_OfSockaddr* newRoutes = ArrayList_OfSockaddr_new(tempAlloc);
for (int i = 0; i < prefixCount; i++) {
int addrFam = Sockaddr_getFamily(prefixSet[i]);
if (addrFam == Sockaddr_AF_INET) {
// OK
} else if (addrFam == Sockaddr_AF_INET6) {
// OK
} else {
Er_raise(tempAlloc, "Unrecognized address type %d", addrFam);
}
ArrayList_OfSockaddr_add(newRoutes, prefixSet[i]);
}
uint32_t ifIndex = if_nametoindex(ifName);
if (!ifIndex) {
Er_raise(tempAlloc, "tunName not recognized");
}
struct ArrayList_OfSockaddr* oldRoutes = Er(getRoutes(ifIndex, logger, tempAlloc));
Er(setRoutes(ifIndex, ifName, oldRoutes, newRoutes, logger, tempAlloc));
Er_ret();
}