41#include <sys/socket.h>
42#include <linux/netlink.h>
43#include <linux/rtnetlink.h>
45#define SNDBUF_SIZE (1024 * 2)
46#define RCVBUF_SIZE (1024 * 4)
48#define SITNL_ADDATTR(_msg, _max_size, _attr, _data, _size) \
50 if (sitnl_addattr(_msg, _max_size, _attr, _data, _size) < 0) \
56#define SITNL_NEST(_msg, _max_size, _attr) \
58 struct rtattr *_nest = sitnl_nlmsg_tail(_msg); \
59 SITNL_ADDATTR(_msg, _max_size, _attr, NULL, 0); \
63#define SITNL_NEST_END(_msg, _nest) \
65 _nest->rta_len = (unsigned short)((void *)sitnl_nlmsg_tail(_msg) - (void *)_nest); \
79sitnl_nlmsg_tail(
const struct nlmsghdr *nlh)
81 return (
unsigned char *)nlh + NLMSG_ALIGN(nlh->nlmsg_len);
117struct sitnl_route_req
124typedef int (*sitnl_parse_reply_cb)(
struct nlmsghdr *
msg,
void *arg);
130sitnl_addattr(
struct nlmsghdr *n,
size_t maxlen,
unsigned short type,
const void *data,
size_t alen)
132 size_t len = RTA_LENGTH(alen);
134 if ((NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len)) > maxlen)
136 msg(
M_WARN,
"%s: rtnl: message exceeded bound of %zu", __func__, maxlen);
140 struct rtattr *rta = sitnl_nlmsg_tail(n);
141 rta->rta_type = type;
143 rta->rta_len = (
unsigned short)len;
147 memset(RTA_DATA(rta), 0, alen);
151 memcpy(RTA_DATA(rta), data, alen);
154 n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len);
165 int sndbuf = SNDBUF_SIZE;
166 int rcvbuf = RCVBUF_SIZE;
169 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
172 msg(
M_WARN,
"%s: cannot open netlink socket", __func__);
179 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sndbuf,
sizeof(sndbuf)) < 0)
186 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
sizeof(rcvbuf)) < 0)
200sitnl_bind(
int fd, uint32_t groups, uint32_t *local_pid)
203 struct sockaddr_nl local;
207 local.nl_family = AF_NETLINK;
208 local.nl_groups = groups;
210 if (bind(fd, (
struct sockaddr *)&local,
sizeof(local)) < 0)
216 addr_len =
sizeof(local);
217 if (getsockname(fd, (
struct sockaddr *)&local, &addr_len) < 0)
223 if (addr_len !=
sizeof(local))
225 msg(
M_WARN,
"%s: wrong address length %u", __func__, (
unsigned int)addr_len);
229 if (local.nl_family != AF_NETLINK)
231 msg(
M_WARN,
"%s: wrong address family %d", __func__, local.nl_family);
241 *local_pid = local.nl_pid;
246#if defined(__GNUC__) || defined(__clang__)
247#pragma GCC diagnostic push
248#pragma GCC diagnostic ignored "-Wsign-conversion"
255sitnl_send(
struct nlmsghdr *payload, pid_t peer,
unsigned int groups, sitnl_parse_reply_cb cb,
259 uint32_t local_pid = 0;
260 struct sockaddr_nl nladdr;
261 struct nlmsgerr *err;
266 .iov_len = payload->nlmsg_len,
268 struct msghdr nlmsg = {
270 .msg_namelen =
sizeof(nladdr),
277 nladdr.nl_family = AF_NETLINK;
278 nladdr.nl_pid = peer;
279 nladdr.nl_groups = groups;
286 static uint32_t sitnl_seq;
289 sitnl_seq = (uint32_t)time(NULL);
291 payload->nlmsg_seq = ++sitnl_seq;
296 payload->nlmsg_flags |= NLM_F_ACK;
306 if (sitnl_bind(fd, 0, &local_pid) < 0)
313 if (sendmsg(fd, &nlmsg, 0) < 0)
321 memset(buf, 0,
sizeof(buf));
330 msg(
D_RTNL,
"%s: checking for received messages", __func__);
331 iov.iov_len =
sizeof(buf);
332 ssize_t rcv_len = recvmsg(fd, &nlmsg, 0);
333 msg(
D_RTNL,
"%s: rtnl: received %zd bytes", __func__, rcv_len);
336 if ((errno == EINTR) || (errno == EAGAIN))
338 msg(
D_RTNL,
"%s: interrupted call", __func__);
348 msg(
M_WARN,
"%s: rtnl: socket reached unexpected EOF", __func__);
353 if (nlmsg.msg_namelen !=
sizeof(nladdr))
355 msg(
M_WARN,
"%s: sender address length: %u (expected %zu)", __func__, nlmsg.msg_namelen,
361 h = (
struct nlmsghdr *)buf;
362 while (rcv_len >= (
int)
sizeof(*h))
364 uint32_t len = h->nlmsg_len;
365 ssize_t rem_len = len -
sizeof(*h);
367 if ((rem_len < 0) || (len > rcv_len))
369 if (nlmsg.msg_flags & MSG_TRUNC)
371 msg(
M_WARN,
"%s: truncated message", __func__);
375 msg(
M_WARN,
"%s: malformed message: len=%u", __func__, len);
386 if ((nladdr.nl_pid != 0) || (h->nlmsg_pid != local_pid)
387 || (h->nlmsg_seq != payload->nlmsg_seq))
390 "%s: skipping unrelated message. nl_pid:%u nlmsg_pid:%u (local:%u) nlmsg_seq:%u (seq:%u)",
391 __func__, nladdr.nl_pid, h->nlmsg_pid, local_pid, h->nlmsg_seq,
393 rcv_len -= NLMSG_ALIGN(len);
394 h = (
struct nlmsghdr *)((
char *)h + NLMSG_ALIGN(len));
398 if (h->nlmsg_type == NLMSG_DONE)
404 if (h->nlmsg_type == NLMSG_ERROR)
406 err = (
struct nlmsgerr *)NLMSG_DATA(h);
407 if (rem_len < (
int)
sizeof(
struct nlmsgerr))
409 msg(
M_WARN,
"%s: ERROR truncated", __func__);
419 int r = cb(h, arg_cb);
428 msg(
M_WARN,
"%s: rtnl: generic error (%d): %s", __func__, err->error,
429 strerror(-err->error));
438 int r = cb(h, arg_cb);
447 msg(
M_WARN,
"%s: RTNL: unexpected reply", __func__);
450 rcv_len -= NLMSG_ALIGN(len);
451 h = (
struct nlmsghdr *)((
char *)h + NLMSG_ALIGN(len));
454 if (nlmsg.msg_flags & MSG_TRUNC)
456 msg(
M_WARN,
"%s: message truncated", __func__);
462 msg(
M_WARN,
"%s: rtnl: %zd not parsed bytes", __func__, rcv_len);
477 char iface[IFNAMSIZ];
483sitnl_route_save(
struct nlmsghdr *n,
void *arg)
485 route_res_t *res = arg;
486 struct rtmsg *r = NLMSG_DATA(n);
487 struct rtattr *rta = RTM_RTA(r);
488 size_t len = n->nlmsg_len - NLMSG_LENGTH(
sizeof(*r));
489 unsigned int table, ifindex = 0;
490 const void *gw = NULL;
493 if (res->default_only && r->rtm_dst_len != 0)
499 table = r->rtm_table;
501 while (RTA_OK(rta, len))
503 switch (rta->rta_type)
507 ifindex = *(
unsigned int *)RTA_DATA(rta);
521 table = *(
unsigned int *)RTA_DATA(rta);
525 rta = RTA_NEXT(rta, len);
529 if (res->table && res->table != table)
534 if (!if_indextoname(ifindex, res->iface))
536 msg(
M_WARN |
M_ERRNO,
"%s: rtnl: can't get ifname for index %u", __func__, ifindex);
542 memcpy(&res->gw, gw, res->addr_size);
552 struct sitnl_route_req req;
562 req.n.nlmsg_len = NLMSG_LENGTH(
sizeof(req.r));
563 req.n.nlmsg_type = RTM_GETROUTE;
564 req.n.nlmsg_flags = NLM_F_REQUEST;
566 ASSERT(af_family <= UCHAR_MAX);
567 req.r.rtm_family = (
unsigned char)af_family;
577 if (!dst || !dst->
ipv4)
579 req.n.nlmsg_flags |= NLM_F_DUMP;
580 res.default_only =
true;
581 res.table = RT_TABLE_MAIN;
585 req.r.rtm_dst_len = 32;
590 res.addr_size =
sizeof(
struct in6_addr);
592 req.r.rtm_dst_len = 128;
600 SITNL_ADDATTR(&req.n,
sizeof(req), RTA_DST, dst, res.addr_size);
602 ret = sitnl_send(&req.n, 0, 0, sitnl_route_save, &res);
609 memcpy(best_gw, &res.gw, res.addr_size);
610 strlcpy(best_iface, res.iface, IFNAMSIZ);
617net_route_v6_best_gw(
openvpn_net_ctx_t *ctx,
const struct in6_addr *dst,
struct in6_addr *best_gw,
621 char buf[INET6_ADDRSTRLEN];
631 msg(
D_ROUTE,
"%s query: dst %s", __func__, inet_ntop(AF_INET6, &dst_v6.
ipv6, buf,
sizeof(buf)));
633 ret = sitnl_route_best_gw(AF_INET6, &dst_v6, best_gw, best_iface);
639 msg(
D_ROUTE,
"%s result: via %s dev %s", __func__,
640 inet_ntop(AF_INET6, best_gw, buf,
sizeof(buf)), best_iface);
651 char buf[INET_ADDRSTRLEN];
658 dst_v4.
ipv4 = htonl(*dst);
661 msg(
D_ROUTE,
"%s query: dst %s", __func__, inet_ntop(AF_INET, &dst_v4.
ipv4, buf,
sizeof(buf)));
663 ret = sitnl_route_best_gw(AF_INET, &dst_v4, best_gw, best_iface);
669 msg(
D_ROUTE,
"%s result: via %s dev %s", __func__,
670 inet_ntop(AF_INET, best_gw, buf,
sizeof(buf)), best_iface);
673 *best_gw = ntohl(*best_gw);
681get_ifindex(
const char *func,
const char *
iface, uint32_t *ifindex)
685 msg(
M_WARN,
"%s: passed NULL interface", func);
689 *ifindex = if_nametoindex(
iface);
702 struct sitnl_link_req req;
707 const int ret = get_ifindex(__func__,
iface, &ifindex);
713 req.n.nlmsg_len = NLMSG_LENGTH(
sizeof(req.i));
714 req.n.nlmsg_flags = NLM_F_REQUEST;
715 req.n.nlmsg_type = RTM_SETLINK;
717 req.i.ifi_family = AF_PACKET;
718 req.i.ifi_index = (int)ifindex;
719 req.i.ifi_change |= IFF_UP;
722 req.i.ifi_flags |= IFF_UP;
726 req.i.ifi_flags &= ~(
unsigned int)IFF_UP;
729 msg(
M_INFO,
"%s: set %s %s", __func__,
iface, up ?
"up" :
"down");
731 return sitnl_send(&req.n, 0, 0, NULL, NULL);
737 struct sitnl_link_req req;
743 if (get_ifindex(__func__,
iface, &ifindex) < 0)
748 req.n.nlmsg_len = NLMSG_LENGTH(
sizeof(req.i));
749 req.n.nlmsg_flags = NLM_F_REQUEST;
750 req.n.nlmsg_type = RTM_SETLINK;
752 req.i.ifi_family = AF_PACKET;
753 req.i.ifi_index = (int)ifindex;
755 SITNL_ADDATTR(&req.n,
sizeof(req), IFLA_MTU, &mtu, 4);
759 ret = sitnl_send(&req.n, 0, 0, NULL, NULL);
767 struct sitnl_link_req req;
773 if (get_ifindex(__func__,
iface, &ifindex) < 0)
778 req.n.nlmsg_len = NLMSG_LENGTH(
sizeof(req.i));
779 req.n.nlmsg_flags = NLM_F_REQUEST;
780 req.n.nlmsg_type = RTM_SETLINK;
782 req.i.ifi_family = AF_PACKET;
783 req.i.ifi_index = (int)ifindex;
789 ret = sitnl_send(&req.n, 0, 0, NULL, NULL);
795sitnl_addr_set(uint16_t cmd, uint16_t flags,
const char *
iface,
sa_family_t af_family,
798 struct sitnl_addr_req req;
802 int ret = get_ifindex(__func__,
iface, &ifindex);
812 size =
sizeof(
struct in_addr);
816 size =
sizeof(
struct in6_addr);
820 msg(
M_WARN,
"%s: rtnl: unknown address family %d", __func__, af_family);
826 req.n.nlmsg_len = NLMSG_LENGTH(
sizeof(req.i));
827 req.n.nlmsg_type = cmd;
828 req.n.nlmsg_flags = NLM_F_REQUEST | flags;
830 req.i.ifa_index = ifindex;
831 ASSERT(af_family <= UINT8_MAX);
832 req.i.ifa_family = (uint8_t)af_family;
837 prefixlen = (int)size * 8;
839 ASSERT(prefixlen <= UINT8_MAX);
840 req.i.ifa_prefixlen = (uint8_t)prefixlen;
844 SITNL_ADDATTR(&req.n,
sizeof(req), IFA_ADDRESS, remote, size);
849 SITNL_ADDATTR(&req.n,
sizeof(req), IFA_LOCAL, local, size);
852 if (af_family == AF_INET && local && !remote && prefixlen <= 30)
856 SITNL_ADDATTR(&req.n,
sizeof(req), IFA_BROADCAST, &broadcast, size);
859 ret = sitnl_send(&req.n, 0, 0, NULL, NULL);
872 return sitnl_addr_set(RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE,
iface, af_family, local,
879 return sitnl_addr_set(RTM_DELADDR, 0,
iface, af_family, local, NULL, 0);
883sitnl_route_set(uint16_t cmd, uint16_t flags,
const char *
iface,
sa_family_t af_family,
const void *dst,
884 int prefixlen,
const void *gw,
enum rt_class_t table,
int metric,
885 enum rt_scope_t scope,
unsigned char protocol,
unsigned char type)
887 struct sitnl_route_req req;
890 uint32_t ifindex = 0;
896 const int ifi_ret = get_ifindex(__func__,
iface, &ifindex);
910 size =
sizeof(
struct in6_addr);
917 req.n.nlmsg_len = NLMSG_LENGTH(
sizeof(req.r));
918 req.n.nlmsg_type = cmd;
919 req.n.nlmsg_flags = NLM_F_REQUEST | flags;
921 ASSERT(af_family <= UCHAR_MAX);
922 req.r.rtm_family = (
unsigned char)af_family;
923 req.r.rtm_scope = (
unsigned char)scope;
924 req.r.rtm_protocol = protocol;
925 req.r.rtm_type = type;
926 ASSERT(prefixlen >= 0 && prefixlen <= UCHAR_MAX);
927 req.r.rtm_dst_len = (
unsigned char)prefixlen;
929 if (table <= UCHAR_MAX)
931 req.r.rtm_table = (
unsigned char)table;
935 req.r.rtm_table = RT_TABLE_UNSPEC;
936 SITNL_ADDATTR(&req.n,
sizeof(req), RTA_TABLE, &table, 4);
941 SITNL_ADDATTR(&req.n,
sizeof(req), RTA_DST, dst, size);
946 SITNL_ADDATTR(&req.n,
sizeof(req), RTA_GATEWAY, gw, size);
951 SITNL_ADDATTR(&req.n,
sizeof(req), RTA_OIF, &ifindex, 4);
956 SITNL_ADDATTR(&req.n,
sizeof(req), RTA_PRIORITY, &metric, 4);
959 ret = sitnl_send(&req.n, 0, 0, NULL, NULL);
967 return sitnl_addr_set(RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE,
iface, af_family, addr, NULL,
974 return sitnl_addr_set(RTM_DELADDR, 0,
iface, af_family, addr, NULL, prefixlen);
981 char buf[INET_ADDRSTRLEN];
990 addr_v4.
ipv4 = htonl(*addr);
992 msg(
M_INFO,
"%s: %s/%d dev %s", __func__, inet_ntop(AF_INET, &addr_v4.
ipv4, buf,
sizeof(buf)),
995 return sitnl_addr_add(AF_INET,
iface, &addr_v4, prefixlen);
1003 char buf[INET6_ADDRSTRLEN];
1012 addr_v6.
ipv6 = *addr;
1014 msg(
M_INFO,
"%s: %s/%d dev %s", __func__, inet_ntop(AF_INET6, &addr_v6.
ipv6, buf,
sizeof(buf)),
1017 return sitnl_addr_add(AF_INET6,
iface, &addr_v6, prefixlen);
1024 char buf[INET_ADDRSTRLEN];
1033 addr_v4.
ipv4 = htonl(*addr);
1035 msg(
M_INFO,
"%s: %s dev %s", __func__, inet_ntop(AF_INET, &addr_v4.
ipv4, buf,
sizeof(buf)),
1038 return sitnl_addr_del(AF_INET,
iface, &addr_v4, prefixlen);
1046 char buf[INET6_ADDRSTRLEN];
1055 addr_v6.
ipv6 = *addr;
1057 msg(
M_INFO,
"%s: %s/%d dev %s", __func__, inet_ntop(AF_INET6, &addr_v6.
ipv6, buf,
sizeof(buf)),
1060 return sitnl_addr_del(AF_INET6,
iface, &addr_v6, prefixlen);
1069 char buf1[INET_ADDRSTRLEN];
1070 char buf2[INET_ADDRSTRLEN];
1080 local_v4.
ipv4 = htonl(*local);
1084 remote_v4.
ipv4 = htonl(*remote);
1087 msg(
M_INFO,
"%s: %s peer %s dev %s", __func__,
1088 inet_ntop(AF_INET, &local_v4.
ipv4, buf1,
sizeof(buf1)),
1089 inet_ntop(AF_INET, &remote_v4.
ipv4, buf2,
sizeof(buf2)),
iface);
1091 return sitnl_addr_ptp_add(AF_INET,
iface, &local_v4, &remote_v4);
1099 char buf[INET6_ADDRSTRLEN];
1108 local_v4.
ipv4 = htonl(*local);
1110 msg(
M_INFO,
"%s: %s dev %s", __func__, inet_ntop(AF_INET, &local_v4.
ipv4, buf,
sizeof(buf)),
1113 return sitnl_addr_ptp_del(AF_INET,
iface, &local_v4);
1117sitnl_route_add(
const char *
iface,
sa_family_t af_family,
const void *dst,
int prefixlen,
1118 const void *gw, uint32_t table,
int metric)
1120 enum rt_scope_t scope = RT_SCOPE_UNIVERSE;
1124 table = RT_TABLE_MAIN;
1129 scope = RT_SCOPE_LINK;
1132 return sitnl_route_set(RTM_NEWROUTE, NLM_F_CREATE,
iface, af_family, dst, prefixlen, gw,
1133 table, metric, scope, RTPROT_BOOT, RTN_UNICAST);
1138 const char *
iface, uint32_t table,
int metric)
1140 const in_addr_t *dst_ptr = NULL, *gw_ptr = NULL;
1142 char dst_str[INET_ADDRSTRLEN];
1143 char gw_str[INET_ADDRSTRLEN];
1147 dst_be = htonl(*dst);
1157 msg(
D_ROUTE,
"%s: %s/%d via %s dev %s table %u metric %d", __func__,
1158 inet_ntop(AF_INET, &dst_be, dst_str,
sizeof(dst_str)), prefixlen,
1159 inet_ntop(AF_INET, &gw_be, gw_str,
sizeof(gw_str)),
np(
iface), table, metric);
1161 return sitnl_route_add(
iface, AF_INET, dst_ptr, prefixlen, gw_ptr, table, metric);
1165net_route_v6_add(
const openvpn_net_ctx_t *ctx,
const struct in6_addr *dst,
int prefixlen,
1166 const struct in6_addr *gw,
const char *
iface, uint32_t table,
int metric)
1170 char dst_str[INET6_ADDRSTRLEN];
1171 char gw_str[INET6_ADDRSTRLEN];
1186 msg(
D_ROUTE,
"%s: %s/%d via %s dev %s table %u metric %d", __func__,
1187 inet_ntop(AF_INET6, &dst_v6.
ipv6, dst_str,
sizeof(dst_str)), prefixlen,
1188 inet_ntop(AF_INET6, &gw_v6.
ipv6, gw_str,
sizeof(gw_str)),
np(
iface), table, metric);
1190 return sitnl_route_add(
iface, AF_INET6, dst, prefixlen, gw, table, metric);
1199 table = RT_TABLE_MAIN;
1202 return sitnl_route_set(RTM_DELROUTE, 0,
iface, af_family, dst, prefixlen, gw, table, metric,
1203 RT_SCOPE_NOWHERE, 0, 0);
1208 const char *
iface, uint32_t table,
int metric)
1212 char dst_str[INET_ADDRSTRLEN];
1213 char gw_str[INET_ADDRSTRLEN];
1220 dst_v4.
ipv4 = htonl(*dst);
1225 gw_v4.
ipv4 = htonl(*gw);
1228 msg(
D_ROUTE,
"%s: %s/%d via %s dev %s table %u metric %d", __func__,
1229 inet_ntop(AF_INET, &dst_v4.
ipv4, dst_str,
sizeof(dst_str)), prefixlen,
1230 inet_ntop(AF_INET, &gw_v4.
ipv4, gw_str,
sizeof(gw_str)),
np(
iface), table, metric);
1232 return sitnl_route_del(
iface, AF_INET, &dst_v4, prefixlen, &gw_v4, table, metric);
1236net_route_v6_del(
const openvpn_net_ctx_t *ctx,
const struct in6_addr *dst,
int prefixlen,
1237 const struct in6_addr *gw,
const char *
iface, uint32_t table,
int metric)
1241 char dst_str[INET6_ADDRSTRLEN];
1242 char gw_str[INET6_ADDRSTRLEN];
1257 msg(
D_ROUTE,
"%s: %s/%d via %s dev %s table %u metric %d", __func__,
1258 inet_ntop(AF_INET6, &dst_v6.
ipv6, dst_str,
sizeof(dst_str)), prefixlen,
1259 inet_ntop(AF_INET6, &gw_v6.
ipv6, gw_str,
sizeof(gw_str)),
np(
iface), table, metric);
1261 return sitnl_route_del(
iface, AF_INET6, &dst_v6, prefixlen, &gw_v6, table, metric);
1268 struct sitnl_link_req req = {};
1273 req.n.nlmsg_len = NLMSG_LENGTH(
sizeof(req.i));
1274 req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;
1275 req.n.nlmsg_type = RTM_NEWLINK;
1277 SITNL_ADDATTR(&req.n,
sizeof(req), IFLA_IFNAME,
iface, strlen(
iface) + 1);
1279 struct rtattr *linkinfo = SITNL_NEST(&req.n,
sizeof(req), IFLA_LINKINFO);
1280 SITNL_ADDATTR(&req.n,
sizeof(req), IFLA_INFO_KIND, type, strlen(type) + 1);
1281#if defined(ENABLE_DCO)
1285 struct rtattr *data = SITNL_NEST(&req.n,
sizeof(req), IFLA_INFO_DATA);
1293 uint8_t ifmode = (uint8_t)dco->ifmode;
1294 SITNL_ADDATTR(&req.n,
sizeof(req), IFLA_OVPN_MODE, &ifmode,
sizeof(uint8_t));
1295 SITNL_NEST_END(&req.n, data);
1298 SITNL_NEST_END(&req.n, linkinfo);
1300 req.i.ifi_family = AF_PACKET;
1304 ret = sitnl_send(&req.n, 0, 0, NULL, NULL);
1310sitnl_parse_rtattr_flags(
struct rtattr *tb[],
size_t max,
struct rtattr *rta,
size_t len,
1311 unsigned short flags)
1313 memset(tb, 0,
sizeof(
struct rtattr *) * (max + 1));
1315 while (RTA_OK(rta, len))
1317 const unsigned short type = rta->rta_type & ~flags;
1319 if ((type <= max) && (!tb[type]))
1324 rta = RTA_NEXT(rta, len);
1329 msg(
D_ROUTE,
"%s: %zu bytes not parsed! (rta_len=%u)", __func__, len, rta->rta_len);
1334sitnl_parse_rtattr(
struct rtattr *tb[],
size_t max,
struct rtattr *rta,
size_t len)
1336 sitnl_parse_rtattr_flags(tb, max, rta, len, 0);
1339#define sitnl_parse_rtattr_nested(tb, max, rta) \
1340 (sitnl_parse_rtattr_flags(tb, max, RTA_DATA(rta), RTA_PAYLOAD(rta), NLA_F_NESTED))
1343sitnl_type_save(
struct nlmsghdr *n,
void *arg)
1345 struct ifinfomsg *ifi = NLMSG_DATA(n);
1346 struct rtattr *tb[IFLA_MAX + 1];
1348 sitnl_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(n));
1350 if (tb[IFLA_LINKINFO])
1352 struct rtattr *tb_link[IFLA_INFO_MAX + 1];
1355 sitnl_parse_rtattr_nested(tb_link, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
1357 if (!tb_link[IFLA_INFO_KIND])
1371 struct sitnl_link_req req = {};
1372 int ifindex = (int)if_nametoindex(
iface);
1379 req.n.nlmsg_len = NLMSG_LENGTH(
sizeof(req.i));
1380 req.n.nlmsg_flags = NLM_F_REQUEST;
1381 req.n.nlmsg_type = RTM_GETLINK;
1383 req.i.ifi_family = AF_PACKET;
1384 req.i.ifi_index = ifindex;
1388 int ret = sitnl_send(&req.n, 0, 0, sitnl_type_save, type);
1391 msg(
D_ROUTE,
"%s: cannot retrieve iface %s: %s (%d)", __func__,
iface, strerror(-ret), ret);
1403 struct sitnl_link_req req = {};
1404 int ifindex = (int)if_nametoindex(
iface);
1411 req.n.nlmsg_len = NLMSG_LENGTH(
sizeof(req.i));
1412 req.n.nlmsg_flags = NLM_F_REQUEST;
1413 req.n.nlmsg_type = RTM_DELLINK;
1415 req.i.ifi_family = AF_PACKET;
1416 req.i.ifi_index = ifindex;
1420 return sitnl_send(&req.n, 0, 0, NULL, NULL);
1423#if defined(__GNUC__) || defined(__clang__)
1424#pragma GCC diagnostic pop
Buffer management functions and garbage collection.
size_t strlcpy(char *dest, const char *src, size_t maxlen)
void set_cloexec(socket_descriptor_t fd)
#define MAC_PRINT_ARG(_mac)
static const char * np(const char *str)
void * openvpn_net_iface_t
#define IFACE_TYPE_LEN_MAX
static in_addr_t netbits_to_netmask(const int netbits)
unsigned short sa_family_t