emo
/
ndhc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ndhc/ifset.c

662 lines
21 KiB
C
Raw Permalink Blame History

// Copyright 2004-2018 Nicholas J. Kain <njkain at gmail dot com>
// SPDX-License-Identifier: MIT
#include <unistd.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/route.h>
#include <net/if.h>
#include <netpacket/packet.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <pwd.h>
#include <grp.h>
#include <errno.h>
#include "nk/log.h"
#include "nk/io.h"
#include "ifset.h"
#include "ifchd.h"
#include "ndhc.h"
#include "nl.h"
static uint32_t ifset_nl_seq = 1;
// Portable ctz() that gives a defined result for x == 0.
static int trailz(uint32_t x)
{
static const int ctzt[32] = {
0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10,
};
return x ? ctzt[((x & -x) * 0x077cb531u) >> 27] : 32;
}
// sn must be in network order
static inline int subnet4_to_prefixlen(uint32_t sn)
{
return 32 - trailz(ntohl(sn));
}
struct ipbcpfx {
int fd;
uint32_t ipaddr;
uint32_t bcast;
uint8_t prefixlen;
bool already_ok;
};
static ssize_t rtnl_do_send(int fd, const uint8_t *sbuf, size_t slen,
const char *fnname)
{
uint8_t response[NLMSG_ALIGN(sizeof(struct nlmsghdr)) + 64];
struct sockaddr_nl nl_addr;
memset(&nl_addr, 0, sizeof nl_addr);
nl_addr.nl_family = AF_NETLINK;
ssize_t r = safe_sendto(fd, (const char *)sbuf, slen, 0,
(struct sockaddr *)&nl_addr, sizeof nl_addr);
if (r < 0 || (size_t)r != slen) {
if (r < 0)
log_line("%s: (%s) netlink sendto failed: %s",
client_config.interface, fnname, strerror(errno));
else
log_line("%s: (%s) netlink sendto short write: %zd < %zu",
client_config.interface, fnname, r, slen);
return -1;
}
struct iovec iov = {
.iov_base = response,
.iov_len = sizeof response,
};
struct msghdr msg = {
.msg_name = &nl_addr,
.msg_namelen = sizeof nl_addr,
.msg_iov = &iov,
.msg_iovlen = 1,
};
r = safe_recvmsg(fd, &msg, 0);
if (r < 0) {
log_line("%s: (%s) netlink recvmsg failed: %s",
client_config.interface, fnname, strerror(errno));
return -1;
}
if (msg.msg_flags & MSG_TRUNC) {
log_line("%s: (%s) Buffer not long enough for message.",
client_config.interface, fnname);
return -1;
}
if ((size_t)r < sizeof(struct nlmsghdr)) {
log_line("%s: (%s) netlink recvmsg returned a headerless response",
client_config.interface, fnname);
return -1;
}
const struct nlmsghdr *nlh = (const struct nlmsghdr *)response;
if (nlh->nlmsg_type == NLMSG_ERROR) {
int nlerr = nlmsg_get_error(nlh);
if (nlerr == 0)
return 0;
else {
if (nlerr == 132) {
log_line("%s: (%s) RF-kill is set (%d). Cannot change interface.",
client_config.interface, fnname, nlerr);
return -3;
}
log_line("%s: (%s) netlink sendto returned NLMSG_ERROR: %s",
client_config.interface, fnname, strerror(nlerr));
return -1;
}
}
if (nlh->nlmsg_type == NLMSG_DONE)
return -2;
log_line("%s: (%s) netlink sendto returned an error.",
client_config.interface, __func__);
return -1;
}
static ssize_t rtnl_if_flags_send(int fd, int type, unsigned ifi_flags)
{
uint8_t request[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
NLMSG_ALIGN(sizeof(struct ifinfomsg))];
struct nlmsghdr *header;
struct ifinfomsg *ifinfomsg;
memset(&request, 0, sizeof request);
header = (struct nlmsghdr *)request;
header->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
header->nlmsg_type = type;
header->nlmsg_flags = NLM_F_ACK | NLM_F_REQUEST;
header->nlmsg_seq = ifset_nl_seq++;
ifinfomsg = NLMSG_DATA(header);
ifinfomsg->ifi_flags = ifi_flags;
ifinfomsg->ifi_index = client_config.ifindex;
ifinfomsg->ifi_change = 0xffffffff;
return rtnl_do_send(fd, request, header->nlmsg_len, __func__);
}
static ssize_t rtnl_addr_broadcast_send(int fd, int type, int ifa_flags,
int ifa_scope, uint32_t *ipaddr,
uint32_t *bcast, uint8_t prefixlen)
{
uint8_t request[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
NLMSG_ALIGN(sizeof(struct ifaddrmsg)) +
2 * RTA_LENGTH(sizeof(struct in6_addr))];
struct nlmsghdr *header;
struct ifaddrmsg *ifaddrmsg;
if (!ipaddr && !bcast) {
log_line("%s: (%s) no ipaddr or bcast!",
client_config.interface, __func__);
return -1;
}
memset(&request, 0, sizeof request);
header = (struct nlmsghdr *)request;
header->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
header->nlmsg_type = type;
header->nlmsg_flags = NLM_F_REPLACE | NLM_F_ACK | NLM_F_REQUEST;
header->nlmsg_seq = ifset_nl_seq++;
ifaddrmsg = NLMSG_DATA(header);
ifaddrmsg->ifa_family = AF_INET;
ifaddrmsg->ifa_prefixlen = prefixlen;
ifaddrmsg->ifa_flags = ifa_flags;
ifaddrmsg->ifa_scope = ifa_scope;
// Linux is inconsistent about the type of ifindex.
ifaddrmsg->ifa_index = (uint32_t)client_config.ifindex;
if (ipaddr) {
if (nl_add_rtattr(header, sizeof request, IFA_LOCAL,
ipaddr, sizeof *ipaddr) < 0) {
log_line("%s: (%s) couldn't add IFA_LOCAL to nlmsg",
client_config.interface, __func__);
return -1;
}
}
if (bcast) {
if (nl_add_rtattr(header, sizeof request, IFA_BROADCAST,
bcast, sizeof *bcast) < 0) {
log_line("%s: (%s) couldn't add IFA_BROADCAST to nlmsg",
client_config.interface, __func__);
return -1;
}
}
return rtnl_do_send(fd, request, header->nlmsg_len, __func__);
}
static ssize_t rtnl_set_default_gw_v4(int fd, uint32_t gw4, int metric)
{
uint8_t request[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
NLMSG_ALIGN(sizeof(struct rtmsg)) +
3 * RTA_LENGTH(sizeof(struct in6_addr)) +
RTA_LENGTH(sizeof(int))];
struct nlmsghdr *header;
struct rtmsg *rtmsg;
memset(&request, 0, sizeof request);
header = (struct nlmsghdr *)request;
header->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
header->nlmsg_type = RTM_NEWROUTE;
header->nlmsg_flags = NLM_F_CREATE | NLM_F_REPLACE | NLM_F_ACK
| NLM_F_REQUEST;
header->nlmsg_seq = ifset_nl_seq++;
rtmsg = NLMSG_DATA(header);
rtmsg->rtm_family = AF_INET;
rtmsg->rtm_protocol = RTPROT_DHCP;
rtmsg->rtm_scope = RT_SCOPE_UNIVERSE;
rtmsg->rtm_type = RTN_UNICAST;
uint32_t dstaddr4 = 0;
if (nl_add_rtattr(header, sizeof request, RTA_DST,
&dstaddr4, sizeof dstaddr4) < 0) {
log_line("%s: (%s) couldn't add RTA_DST to nlmsg",
client_config.interface, __func__);
return -1;
}
if (nl_add_rtattr(header, sizeof request, RTA_OIF,
&client_config.ifindex,
sizeof client_config.ifindex) < 0) {
log_line("%s: (%s) couldn't add RTA_OIF to nlmsg",
client_config.interface, __func__);
return -1;
}
if (nl_add_rtattr(header, sizeof request, RTA_GATEWAY,
&gw4, sizeof gw4) < 0) {
log_line("%s: (%s) couldn't add RTA_GATEWAY to nlmsg",
client_config.interface, __func__);
return -1;
}
if (metric > 0) {
if (nl_add_rtattr(header, sizeof request, RTA_PRIORITY,
&metric, sizeof metric) < 0) {
log_line("%s: (%s) couldn't add RTA_PRIORITY to nlmsg",
client_config.interface, __func__);
return -1;
}
}
return rtnl_do_send(fd, request, header->nlmsg_len, __func__);
}
struct link_flag_data {
int fd;
uint32_t flags;
bool got_flags;
};
static void link_flags_get_do(const struct nlmsghdr *nlh, void *data)
{
struct ifinfomsg *ifm = NLMSG_DATA(nlh);
struct link_flag_data *ifd = data;
switch(nlh->nlmsg_type) {
case RTM_NEWLINK:
if (ifm->ifi_index != client_config.ifindex)
break;
ifd->flags = ifm->ifi_flags;
ifd->got_flags = true;
break;
case RTM_DELLINK:
log_line("%s: got RTM_DELLINK", __func__);
break;
default:
log_line("%s: got %u", __func__, nlh->nlmsg_type);
break;
}
}
static int link_flags_get(int fd, uint32_t *flags)
{
char nlbuf[8192];
struct link_flag_data ipx = { .fd = fd, .flags = 0, .got_flags = false };
ssize_t ret;
uint32_t seq = ifset_nl_seq++;
if (nl_sendgetlink(fd, seq, client_config.ifindex) < 0)
return -1;
do {
ret = nl_recv_buf(fd, nlbuf, sizeof nlbuf);
if (ret < 0)
return -2;
if (nl_foreach_nlmsg(nlbuf, (size_t)ret, seq, 0, link_flags_get_do, &ipx) < 0)
return -3;
} while (ret > 0);
if (ipx.got_flags) {
*flags = ipx.flags;
return 0;
}
return -4;
}
int perform_carrier(void)
{
int ret = -1;
uint32_t flags;
int fd = socket(AF_NETLINK, SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC, NETLINK_ROUTE);
if (fd < 0) {
log_line("%s: (%s) netlink socket open failed: %s",
client_config.interface, __func__, strerror(errno));
goto fail;
}
if (link_flags_get(fd, &flags) < 0)
goto fail_fd;
if ((flags & IFF_RUNNING) && (flags & IFF_UP))
ret = 0;
fail_fd:
close(fd);
fail:
return ret;
}
// Return 0 if flags were successfully changed.
// Return 1 if flags were already set.
// Return -1 on error.
// Return -2 if NL response had no status notification.
// Return -3 if RFKILL is set and flags cannot be changed.
static int link_set_flags(int fd, uint32_t flags)
{
uint32_t oldflags;
int r = link_flags_get(fd, &oldflags);
if (r < 0) {
log_line("%s: (%s) failed to get old link flags: %u",
client_config.interface, __func__, r);
return -1;
}
if ((oldflags & flags) == flags)
return 1;
return (int)rtnl_if_flags_send(fd, RTM_SETLINK, flags | oldflags);
}
#if 0
static int link_unset_flags(int fd, uint32_t flags)
{
uint32_t oldflags;
int r = link_flags_get(fd, &oldflags);
if (r < 0) {
log_line("%s: (%s) failed to get old link flags: %u",
client_config.interface, __func__, r);
return -1;
}
if ((oldflags & flags) == 0)
return 1;
return (int)rtnl_if_flags_send(fd, RTM_SETLINK, oldflags & ~flags);
}
#endif
static void ipbcpfx_clear_others_do(const struct nlmsghdr *nlh, void *data)
{
struct rtattr *tb[IFA_MAX] = {0};
struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
struct ipbcpfx *ipx = data;
int r;
nl_rtattr_parse(nlh, sizeof *ifm, rtattr_assign, tb);
switch(nlh->nlmsg_type) {
case RTM_NEWADDR:
if (ifm->ifa_index != (unsigned)client_config.ifindex)
return;
if (ifm->ifa_family != AF_INET)
return;
if (!(ifm->ifa_flags & IFA_F_PERMANENT))
goto erase;
if (ifm->ifa_scope != RT_SCOPE_UNIVERSE)
goto erase;
if (ifm->ifa_prefixlen != ipx->prefixlen)
goto erase;
if (!tb[IFA_ADDRESS])
goto erase;
if (memcmp(RTA_DATA(tb[IFA_ADDRESS]), &ipx->ipaddr,
sizeof ipx->ipaddr))
goto erase;
if (!tb[IFA_BROADCAST])
goto erase;
if (memcmp(RTA_DATA(tb[IFA_BROADCAST]), &ipx->bcast,
sizeof ipx->bcast))
goto erase;
break;
default:
return;
}
// We already have the proper IP+broadcast+prefix.
ipx->already_ok = true;
return;
erase:
r = rtnl_addr_broadcast_send(ipx->fd, RTM_DELADDR, ifm->ifa_flags,
ifm->ifa_scope,
tb[IFA_ADDRESS] ? RTA_DATA(tb[IFA_ADDRESS]) : (uint32_t *)0,
tb[IFA_BROADCAST] ? RTA_DATA(tb[IFA_BROADCAST]) : (uint32_t *)0,
ifm->ifa_prefixlen);
if (r < 0 && r != -2) {
log_line("%s: (%s) Failed to delete IP and broadcast addresses.",
client_config.interface, __func__);
}
return;
}
static int ipbcpfx_clear_others(int fd, uint32_t ipaddr, uint32_t bcast,
uint8_t prefixlen)
{
char nlbuf[8192];
struct ipbcpfx ipx = { .fd = fd, .ipaddr = ipaddr, .bcast = bcast,
.prefixlen = prefixlen, .already_ok = false };
ssize_t ret;
uint32_t seq = ifset_nl_seq++;
if (nl_sendgetaddr4(fd, seq, (uint32_t)client_config.ifindex) < 0)
return -1;
do {
ret = nl_recv_buf(fd, nlbuf, sizeof nlbuf);
if (ret < 0)
return -2;
if (nl_foreach_nlmsg(nlbuf, (size_t)ret, seq, 0,
ipbcpfx_clear_others_do, &ipx) < 0)
return -3;
} while (ret > 0);
return ipx.already_ok ? 1 : 0;
}
static ssize_t rtnl_if_mtu_set(int fd, unsigned int mtu)
{
uint8_t request[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
NLMSG_ALIGN(sizeof(struct ifinfomsg)) +
RTA_LENGTH(sizeof(unsigned int))];
struct nlmsghdr *header;
struct ifinfomsg *ifinfomsg;
uint32_t oldflags;
int r = link_flags_get(fd, &oldflags);
if (r < 0) {
log_line("%s: (%s) failed to get old link flags: %u",
client_config.interface, __func__, r);
return -1;
}
memset(&request, 0, sizeof request);
header = (struct nlmsghdr *)request;
header->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
header->nlmsg_type = RTM_SETLINK;
header->nlmsg_flags = NLM_F_ACK | NLM_F_REQUEST;
header->nlmsg_seq = ifset_nl_seq++;
ifinfomsg = NLMSG_DATA(header);
ifinfomsg->ifi_flags = oldflags;
ifinfomsg->ifi_index = client_config.ifindex;
ifinfomsg->ifi_change = 0xffffffff;
if (nl_add_rtattr(header, sizeof request, IFLA_MTU,
&mtu, sizeof mtu) < 0) {
log_line("%s: (%s) couldn't add IFLA_MTU to nlmsg",
client_config.interface, __func__);
return -1;
}
return rtnl_do_send(fd, request, header->nlmsg_len, __func__);
}
int perform_ifup(void)
{
int fd = socket(AF_NETLINK, SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC, NETLINK_ROUTE);
if (fd < 0) {
log_line("%s: (%s) netlink socket open failed: %s",
client_config.interface, __func__, strerror(errno));
return fd;
}
int r = link_set_flags(fd, IFF_UP);
if (r < 0) {
if (r != -3)
log_line("%s: (%s) Failed to set link to be up.",
client_config.interface, __func__);
else
log_line("%s: (%s) rfkill is set; waiting until it is unset",
client_config.interface, __func__);
}
close(fd);
return r;
}
// str_bcast is optional.
int perform_ip_subnet_bcast(const char *str_ipaddr,
const char *str_subnet,
const char *str_bcast)
{
struct in_addr ipaddr, subnet, bcast;
int fd, r, ret = -99;
uint8_t prefixlen;
if (inet_pton(AF_INET, str_ipaddr, &ipaddr) <= 0) {
log_line("%s: (%s) bad interface ip address: '%s'",
client_config.interface, __func__, str_ipaddr);
goto fail;
}
if (inet_pton(AF_INET, str_subnet, &subnet) <= 0) {
log_line("%s: (%s) bad interface subnet address: '%s'",
client_config.interface, __func__, str_subnet);
goto fail;
}
prefixlen = subnet4_to_prefixlen(subnet.s_addr);
if (str_bcast) {
if (inet_pton(AF_INET, str_bcast, &bcast) <= 0) {
log_line("%s: (%s) bad interface broadcast address: '%s'",
client_config.interface, __func__, str_bcast);
goto fail;
}
} else {
// Generate the standard broadcast address if unspecified.
bcast.s_addr = ipaddr.s_addr | htonl(0xfffffffflu >> prefixlen);
}
fd = socket(AF_NETLINK, SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC, NETLINK_ROUTE);
if (fd < 0) {
log_line("%s: (%s) netlink socket open failed: %s",
client_config.interface, __func__, strerror(errno));
goto fail;
}
r = ipbcpfx_clear_others(fd, ipaddr.s_addr, bcast.s_addr, prefixlen);
if (r < 0 && r > -3) {
if (r == -1)
log_line("%s: (%s) error requesting link ip address list",
client_config.interface, __func__);
else if (r == -2)
log_line("%s: (%s) error receiving link ip address list",
client_config.interface, __func__);
goto fail_fd;
}
if (r < 1) {
r = rtnl_addr_broadcast_send(fd, RTM_NEWADDR, IFA_F_PERMANENT,
RT_SCOPE_UNIVERSE, &ipaddr.s_addr, &bcast.s_addr,
prefixlen);
if (r < 0)
goto fail_fd;
log_line("%s: Interface IP set to: '%s'", client_config.interface,
str_ipaddr);
log_line("%s: Interface subnet set to: '%s'", client_config.interface,
str_subnet);
if (str_bcast)
log_line("%s: Broadcast address set to: '%s'",
client_config.interface, str_bcast);
} else
log_line("%s: Interface IP, subnet, and broadcast were already OK.",
client_config.interface);
if (link_set_flags(fd, IFF_UP | IFF_RUNNING) < 0) {
ret = -1;
log_line("%s: (%s) Failed to set link to be up and running.",
client_config.interface, __func__);
goto fail_fd;
}
ret = 0;
fail_fd:
close(fd);
fail:
return ret;
}
int perform_router(const char *str_router, size_t len)
{
int ret = -99;
if (len < 7)
goto fail;
struct in_addr router;
if (inet_pton(AF_INET, str_router, &router) <= 0) {
log_line("%s: (%s) bad router ip address: '%s'",
client_config.interface, __func__, str_router);
goto fail;
}
int fd = socket(AF_NETLINK, SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC, NETLINK_ROUTE);
if (fd < 0) {
log_line("%s: (%s) netlink socket open failed: %s",
client_config.interface, __func__, strerror(errno));
goto fail;
}
if (rtnl_set_default_gw_v4(fd, router.s_addr, client_config.metric) < 0) {
log_line("%s: (%s) failed to set route: %s",
client_config.interface, __func__, strerror(errno));
goto fail_fd;
}
log_line("%s: Gateway router set to: '%s'", client_config.interface,
str_router);
ret = 0;
fail_fd:
close(fd);
fail:
return ret;
}
int perform_mtu(const char *str, size_t len)
{
unsigned int mtu;
int fd, ret = -99;
if (len < 2)
goto fail;
char *estr;
long tmtu = strtol(str, &estr, 10);
if (estr == str) {
log_line("%s: (%s) provided mtu arg isn't a valid number",
client_config.interface, __func__);
goto fail;
}
if ((tmtu == LONG_MAX || tmtu == LONG_MIN) && errno == ERANGE) {
log_line("%s: (%s) provided mtu arg would overflow a long",
client_config.interface, __func__);
goto fail;
}
if (tmtu > INT_MAX) {
log_line("%s: (%s) provided mtu arg would overflow int",
client_config.interface, __func__);
goto fail;
}
// 68 bytes for IPv4. 1280 bytes for IPv6.
if (tmtu < 68) {
log_line("%s: (%s) provided mtu arg (%ld) less than minimum MTU (68)",
client_config.interface, __func__, tmtu);
goto fail;
}
mtu = (unsigned int)tmtu;
fd = socket(AF_NETLINK, SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC, NETLINK_ROUTE);
if (fd < 0) {
log_line("%s: (%s) netlink socket open failed: %s",
client_config.interface, __func__, strerror(errno));
goto fail;
}
if (rtnl_if_mtu_set(fd, mtu) < 0) {
log_line("%s: (%s) failed to set MTU [%d]",
client_config.interface, __func__, mtu);
goto fail_fd;
}
log_line("%s: MTU set to: '%s'", client_config.interface, str);
ret = 0;
fail_fd:
close(fd);
fail:
return ret;
}
Reference in New Issue View Git Blame Copy Permalink