Page MenuHomeFreeBSD
Differential D36002 Diff 109566 sys/netlink/route/iface.c

Changeset View

Standalone View

View Options

sys/netlink/route/iface.c

  • This file was added.
/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* Copyright (c) 2021 Ng Peng Nam Sean
Lint: Possible Spelling Mistake
Inline Actions

Possible spelling error. You wrote 'nam', but did you mean 'name'?

Lint: Possible Spelling Mistake: Possible spelling error. You wrote 'nam', but did you mean 'name'?
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_inet.h"
#include "opt_inet6.h"
#include <sys/types.h>
#include <sys/malloc.h>
#include <sys/socket.h>
#include <sys/syslog.h>
#include <sys/socketvar.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/route.h>
#include <net/route/nhop.h>
#include <net/route/route_ctl.h>
#include <netlink/netlink.h>
#include <netlink/netlink_ctl.h>
#include <netlink/netlink_route.h>
#include <netlink/route/route_var.h>
#include <netinet6/scope6_var.h> /* scope deembedding */
#define DEBUG_MOD_NAME nl_iface
#define DEBUG_MAX_LEVEL LOG_DEBUG3
#include <netlink/netlink_debug.h>
_DECLARE_DEBUG(LOG_DEBUG3);
struct netlink_walkargs {
struct nlmsg_state ns;
struct nlmsghdr hdr;
struct nlpcb *so;
uint32_t fibnum;
int family;
int error;
int count;
int dumped;
};
#define FAIL_ATTR(a) {\
RT_LOG(LOG_DEBUG, "failed writing attribute %s (%d)", #a, a); \
goto enomem; \
}
static eventhandler_tag ifdetach_event, ifattach_event, ifaddr_event;
/* */
/*
* RTM_GETLINK request
* sendto(3, {{len=32, type=RTM_GETLINK, flags=NLM_F_REQUEST|NLM_F_DUMP, seq=1641940952, pid=0},
* {ifi_family=AF_INET, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}}, 32, 0, NULL, 0) = 32
*
* Reply:
* {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_ETHER, ifi_index=if_nametoindex("enp0s31f6"), ifi_flags=IFF_UP|IFF_BROADCAST|IFF_RUNNING|IFF_MULTICAST|IFF_LOWER_UP, ifi_change=0},
{{nla_len=10, nla_type=IFLA_ADDRESS}, "\xfe\x54\x00\x52\x3e\x90"}
[
{{nla_len=14, nla_type=IFLA_IFNAME}, "enp0s31f6"},
{{nla_len=8, nla_type=IFLA_TXQLEN}, 1000},
{{nla_len=5, nla_type=IFLA_OPERSTATE}, 6},
{{nla_len=5, nla_type=IFLA_LINKMODE}, 0},
{{nla_len=8, nla_type=IFLA_MTU}, 1500},
{{nla_len=8, nla_type=IFLA_MIN_MTU}, 68},
{{nla_len=8, nla_type=IFLA_MAX_MTU}, 9000},
{{nla_len=8, nla_type=IFLA_GROUP}, 0},
{{nla_len=8, nla_type=IFLA_PROMISCUITY}, 0},
{{nla_len=8, nla_type=IFLA_NUM_TX_QUEUES}, 1},
{{nla_len=8, nla_type=IFLA_GSO_MAX_SEGS}, 65535},
{{nla_len=8, nla_type=IFLA_GSO_MAX_SIZE}, 65536},
{{nla_len=8, nla_type=IFLA_NUM_RX_QUEUES}, 1},
{{nla_len=5, nla_type=IFLA_CARRIER}, 1},
{{nla_len=13, nla_type=IFLA_QDISC}, "fq_codel"},
{{nla_len=8, nla_type=IFLA_CARRIER_CHANGES}, 2},
{{nla_len=5, nla_type=IFLA_PROTO_DOWN}, 0},
{{nla_len=8, nla_type=IFLA_CARRIER_UP_COUNT}, 1},
{{nla_len=8, nla_type=IFLA_CARRIER_DOWN_COUNT}, 1},
*/
static unsigned
ifp_flags_to_netlink(const struct ifnet *ifp)
{
return (ifp->if_flags);
}
#define LLADDR_CONST(s) ((const void *)((s)->sdl_data + (s)->sdl_nlen))
static bool
dump_sa(struct nlmsg_state *ns, int attr, const struct sockaddr *sa)
{
uint32_t addr_len = 0;
const void *addr_data = NULL;
struct in6_addr addr6;
if (sa == NULL)
return (true);
switch (sa->sa_family) {
case AF_INET:
addr_len = sizeof(struct in_addr);
addr_data = &((const struct sockaddr_in *)sa)->sin_addr;
break;
case AF_INET6:
in6_splitscope(&((const struct sockaddr_in6 *)sa)->sin6_addr, &addr6, &addr_len);
addr_len = sizeof(struct in6_addr);
addr_data = &addr6;
break;
case AF_LINK:
addr_len = ((const struct sockaddr_dl *)sa)->sdl_alen;
addr_data = LLADDR_CONST((const struct sockaddr_dl *)sa);
break;
default:
RT_LOG(LOG_DEBUG, "unsupported family: %d, skipping", sa->sa_family);
return (true);
}
return (nlattr_add(ns, attr, addr_len, addr_data));
}
static bool
dump_iface(struct nlmsg_state *ns, struct ifnet *ifp, const struct nlmsghdr *hdr)
{
struct ifinfomsg *ifinfo;
if (!nlmsg_reply(ns, hdr, sizeof(struct ifinfomsg)))
goto enomem;
ifinfo = nlmsg_reserve_object(ns, struct ifinfomsg);
ifinfo->ifi_family = AF_UNSPEC;
ifinfo->__ifi_pad = 0;
ifinfo->ifi_type = ifp->if_type; // ARPHDR
ifinfo->ifi_index = ifp->if_index;
ifinfo->ifi_flags = ifp_flags_to_netlink(ifp);
ifinfo->ifi_change = 0;
if (!nlattr_add_string(ns, IFLA_IFNAME, if_name(ifp)))
goto enomem;
uint8_t val = 0; // XXX: operstate?
if (!nlattr_add_u8(ns, IFLA_OPERSTATE, val))
goto enomem;
/* XXX: carrier */
if (!nlattr_add_u8(ns, IFLA_CARRIER, val))
goto enomem;
if (!nlattr_add_u8(ns, IFLA_PROTO_DOWN, val))
goto enomem;
if (!nlattr_add_u8(ns, IFLA_LINKMODE, val))
goto enomem;
/* Link addr */
if ((ifp->if_addr != NULL)) {
if (!dump_sa(ns, IFLA_ADDRESS, ifp->if_addr->ifa_addr))
goto enomem;
}
if (!nlattr_add_u32(ns, IFLA_MTU, ifp->if_mtu))
goto enomem;
/*
if (!nlattr_add_u32(ns, IFLA_MIN_MTU, 60))
goto enomem;
if (!nlattr_add_u32(ns, IFLA_MAX_MTU, 9000))
goto enomem;
if (!nlattr_add_u32(ns, IFLA_GROUP, 0))
goto enomem;
*/
if (!nlattr_add_u32(ns, IFLA_PROMISCUITY, 0))
goto enomem;
nlmsg_end(ns);
return (true);
enomem:
RT_LOG(LOG_DEBUG, "unable to dump interface %s state (ENOMEM)", if_name(ifp));
nlmsg_abort(ns);
return (false);
}
struct nl_parsed_link {
char *ifla_group;
char *ifla_ifname;
unsigned short ifi_type;
int ifi_index;
};
#define _OFF_S(_field) offsetof(struct nl_parsed_link, _field)
static struct nlattr_parser ps[] = {
{ .type = IFLA_IFNAME, .off = _OFF_S(ifla_ifname), .cb = nlattr_get_string },
{ .type = IFLA_GROUP, .off = _OFF_S(ifla_group), .cb = nlattr_get_string },
{ .type = IFLA_ALT_IFNAME, .off = _OFF_S(ifla_ifname), .cb = nlattr_get_string },
};
static bool
match_iface(struct nl_parsed_link *attrs, struct ifnet *ifp)
{
if (attrs->ifi_index != 0 && attrs->ifi_index != ifp->if_index)
return (false);
if (attrs->ifi_type != 0 && attrs->ifi_index != ifp->if_type)
return (false);
if (attrs->ifla_ifname != NULL && strcmp(attrs->ifla_ifname, if_name(ifp)))
return (false);
/* TODO: add group match */
return (true);
}
static int
rtnl_handle_getlink(struct nlmsghdr *hdr, struct nlpcb *nlp, struct netlink_parse_tracker *npt)
{
struct ifnet *ifp;
int error = 0;
struct ifinfomsg *ifm = (struct ifinfomsg *)nlmsg_data(hdr);
struct nl_parsed_link attrs = {
.ifi_type = ifm->ifi_type,
.ifi_index = ifm->ifi_index,
};
error = nl_parse_attrs(hdr, sizeof(*ifm), ps, sizeof(ps)/sizeof(ps[0]), npt, &attrs);
if (error != 0)
return (error);
struct netlink_walkargs wa = {
.so = nlp,
.hdr.nlmsg_pid = hdr->nlmsg_pid,
.hdr.nlmsg_seq = hdr->nlmsg_seq,
.hdr.nlmsg_flags = hdr->nlmsg_flags | NLM_F_MULTI,
.hdr.nlmsg_type = NL_RTM_NEWLINK,
};
if (!nlmsg_get_socket_writer(NLMSG_LARGE, nlp, &wa.ns)) {
RT_LOG(LOG_DEBUG, "error allocating mbuf");
return (ENOMEM);
}
RT_LOG(LOG_DEBUG, "Start dump");
CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
wa.count++;
if (match_iface(&attrs, ifp)) {
if (!dump_iface(&wa.ns, ifp, &wa.hdr)) {
error = ENOMEM;
break;
}
}
wa.dumped++;
}
RT_LOG(LOG_DEBUG, "End dump, iterated %d dumped %d", wa.count, wa.dumped);
if (!nlmsg_end_dump(&wa.ns, error, &wa.hdr)) {
RT_LOG(LOG_DEBUG, "Unable to finalize the dump");
return (ENOMEM);
}
nlmsg_flush(&wa.ns);
return (error);
}
/*
{ifa_family=AF_INET, ifa_prefixlen=8, ifa_flags=IFA_F_PERMANENT, ifa_scope=RT_SCOPE_HOST, ifa_index=if_nametoindex("lo")},
[
{{nla_len=8, nla_type=IFA_ADDRESS}, inet_addr("127.0.0.1")},
{{nla_len=8, nla_type=IFA_LOCAL}, inet_addr("127.0.0.1")},
{{nla_len=7, nla_type=IFA_LABEL}, "lo"},
{{nla_len=8, nla_type=IFA_FLAGS}, IFA_F_PERMANENT},
{{nla_len=20, nla_type=IFA_CACHEINFO}, {ifa_prefered=4294967295, ifa_valid=4294967295, cstamp=3619, tstamp=3619}}]},
---
{{len=72, type=RTM_NEWADDR, flags=NLM_F_MULTI, seq=1642191126, pid=566735},
{ifa_family=AF_INET6, ifa_prefixlen=96, ifa_flags=IFA_F_PERMANENT, ifa_scope=RT_SCOPE_UNIVERSE, ifa_index=if_nametoindex("virbr0")},
[
{{nla_len=20, nla_type=IFA_ADDRESS}, inet_pton(AF_INET6, "2a01:4f8:13a:70c:ffff::1")},
{{nla_len=20, nla_type=IFA_CACHEINFO}, {ifa_prefered=4294967295, ifa_valid=4294967295, cstamp=4283, tstamp=4283}},
{{nla_len=8, nla_type=IFA_FLAGS}, IFA_F_PERMANENT}]},
*/
static uint8_t
ifa_get_scope(const struct ifaddr *ifa)
{
const struct sockaddr *sa;
uint8_t addr_scope = RT_SCOPE_UNIVERSE;
sa = ifa->ifa_addr;
switch (sa->sa_family) {
case AF_INET:
{
struct in_addr addr;
addr = ((const struct sockaddr_in *)sa)->sin_addr;
if (IN_LOOPBACK(addr.s_addr))
addr_scope = RT_SCOPE_HOST;
else if (IN_LINKLOCAL(addr.s_addr))
addr_scope = RT_SCOPE_LINK;
break;
}
case AF_INET6:
{
const struct in6_addr *addr;
addr = &((const struct sockaddr_in6 *)sa)->sin6_addr;
if (IN6_IS_ADDR_LOOPBACK(addr))
addr_scope = RT_SCOPE_HOST;
else if (IN6_IS_ADDR_LINKLOCAL(addr))
addr_scope = RT_SCOPE_LINK;
break;
}
}
return (addr_scope);
}
static uint8_t
inet6_get_plen(const struct in6_addr *addr)
{
return (bitcount32(addr->s6_addr32[0]) + bitcount32(addr->s6_addr32[1]) +
bitcount32(addr->s6_addr32[2]) + bitcount32(addr->s6_addr32[3]));
}
static uint8_t
get_sa_plen(const struct sockaddr *sa)
{
const struct in6_addr *paddr6;
const struct in_addr *paddr;
switch (sa->sa_family) {
case AF_INET:
if (sa == NULL)
return (32);
paddr = &(((const struct sockaddr_in *)sa)->sin_addr);
return bitcount32(paddr->s_addr);;
case AF_INET6:
if (sa == NULL)
return (128);
paddr6 = &(((const struct sockaddr_in6 *)sa)->sin6_addr);
return inet6_get_plen(paddr6);
}
return (0);
}
/*
* {'attrs': [('IFA_ADDRESS', '12.0.0.1'),
('IFA_LOCAL', '12.0.0.1'),
('IFA_LABEL', 'eth10'),
('IFA_FLAGS', 128),
('IFA_CACHEINFO', {'ifa_preferred': 4294967295, 'ifa_valid': 4294967295, 'cstamp': 63745746, 'tstamp': 63745746})],
*/
static bool
dump_iface_addr(struct nlmsg_state *ns, struct ifnet *ifp, struct ifaddr *ifa,
const struct nlmsghdr *hdr)
{
struct ifaddrmsg *ifamsg;
struct sockaddr *sa = ifa->ifa_addr;
RT_LOG(LOG_DEBUG3, "dumping ifa %p type %s(%d) for interface %s",
ifa, rib_print_family(sa->sa_family), sa->sa_family, if_name(ifp));
if (!nlmsg_reply(ns, hdr, sizeof(struct ifaddrmsg)))
goto enomem;
ifamsg = nlmsg_reserve_object(ns, struct ifaddrmsg);
if (ifamsg == NULL)
goto enomem;
ifamsg->ifa_family = sa->sa_family;
ifamsg->ifa_prefixlen = get_sa_plen(ifa->ifa_netmask);
ifamsg->ifa_flags = 0; // ifa_flags is useless
ifamsg->ifa_scope = ifa_get_scope(ifa);
ifamsg->ifa_index = ifp->if_index;
struct sockaddr *dst_sa = ifa->ifa_dstaddr;
if ((dst_sa == NULL) || (dst_sa->sa_family != sa->sa_family))
dst_sa = sa;
if (!dump_sa(ns, IFA_ADDRESS, dst_sa))
FAIL_ATTR(IFA_ADDRESS);
if (!dump_sa(ns, IFA_LOCAL, sa))
FAIL_ATTR(IFA_LOCAL);
if (!nlattr_add_string(ns, IFA_LABEL, if_name(ifp)))
FAIL_ATTR(IFA_LABEL);
uint32_t val = 0; // ifa->ifa_flags;
if (!nlattr_add_u32(ns, IFA_FLAGS, val))
FAIL_ATTR(IFA_FLAGS);
nlmsg_end(ns);
return (true);
enomem:
RT_LOG(LOG_DEBUG, "Failed to dump ifa type %s(%d) for interface %s",
rib_print_family(sa->sa_family), sa->sa_family, if_name(ifp));
nlmsg_abort(ns);
return (false);
}
static int
rtnl_handle_getaddr(struct nlmsghdr *hdr, struct nlpcb *nlp, struct netlink_parse_tracker *npt)
{
struct ifaddr *ifa;
struct ifnet *ifp;
int error = 0;
struct netlink_walkargs wa = {
.so = nlp,
.hdr.nlmsg_pid = hdr->nlmsg_pid,
.hdr.nlmsg_seq = hdr->nlmsg_seq,
.hdr.nlmsg_flags = hdr->nlmsg_flags | NLM_F_MULTI,
.hdr.nlmsg_type = NL_RTM_NEWADDR,
};
if (!nlmsg_get_socket_writer(NLMSG_LARGE, nlp, &wa.ns)) {
RT_LOG(LOG_DEBUG, "error allocating mbuf");
return (ENOMEM);
}
RT_LOG(LOG_DEBUG, "Start dump");
CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
if (wa.family != 0 && wa.family != ifa->ifa_addr->sa_family)
continue;
if (ifa->ifa_addr->sa_family == AF_LINK)
continue;
wa.count++;
if (!dump_iface_addr(&wa.ns, ifp, ifa, &wa.hdr)) {
error = ENOMEM;
break;
}
wa.dumped++;
}
if (error != 0)
break;
}
RT_LOG(LOG_DEBUG, "End dump, iterated %d dumped %d", wa.count, wa.dumped);
if (!nlmsg_end_dump(&wa.ns, error, &wa.hdr)) {
RT_LOG(LOG_DEBUG, "Unable to finalize the dump");
return (ENOMEM);
}
nlmsg_flush(&wa.ns);
return (error);
}
static void
rtnl_handle_ifaddr(void *arg __unused, struct ifaddr *ifa, int cmd)
{
struct nlmsghdr hdr = {};
struct nlmsg_state ns = {};
uint32_t group = 0;
switch (ifa->ifa_addr->sa_family) {
case AF_INET:
group = RTNLGRP_IPV4_IFADDR;
break;
case AF_INET6:
group = RTNLGRP_IPV6_IFADDR;
break;
default:
RT_LOG(LOG_DEBUG2, "ifa notification for unknown AF: %d",
ifa->ifa_addr->sa_family);
return;
}
if (!nl_has_listeners(NETLINK_ROUTE, group))
return;
if (!nlmsg_get_group_writer(NLMSG_LARGE, group, &ns)) {
RT_LOG(LOG_DEBUG, "error allocating group writer");
return;
}
hdr.nlmsg_type = (cmd == RTM_DELETE) ? NL_RTM_DELADDR : NL_RTM_NEWADDR;
dump_iface_addr(&ns, ifa->ifa_ifp, ifa, &hdr);
nlmsg_flush(&ns);
}
static void
rtnl_handle_ifattach(void *arg, struct ifnet *ifp)
{
struct nlmsghdr hdr = { .nlmsg_type = NL_RTM_NEWLINK };
struct nlmsg_state ns = {};
if (!nl_has_listeners(NETLINK_ROUTE, RTNLGRP_LINK))
return;
if (!nlmsg_get_group_writer(NLMSG_LARGE, RTNLGRP_LINK, &ns)) {
RT_LOG(LOG_DEBUG, "error allocating mbuf");
return;
}
dump_iface(&ns, ifp, &hdr);
nlmsg_flush(&ns);
}
static void
rtnl_handle_ifdetach(void *arg, struct ifnet *ifp)
{
struct nlmsghdr hdr = { .nlmsg_type = NL_RTM_DELLINK };
struct nlmsg_state ns = {};
if (!nl_has_listeners(NETLINK_ROUTE, RTNLGRP_LINK))
return;
if (!nlmsg_get_group_writer(NLMSG_LARGE, RTNLGRP_LINK, &ns)) {
RT_LOG(LOG_DEBUG, "error allocating mbuf");
return;
}
dump_iface(&ns, ifp, &hdr);
nlmsg_flush(&ns);
}
static struct rtnl_cmd_handler cmd_handlers[] = {
{ NL_RTM_GETLINK, "RTM_GETLINK", &rtnl_handle_getlink, sizeof(struct ifinfomsg)},
{ NL_RTM_GETADDR, "RTM_GETADDR", &rtnl_handle_getaddr, sizeof(struct ifaddrmsg)},
};
void
rtnl_ifaces_init(void)
{
ifattach_event = EVENTHANDLER_REGISTER(
ifnet_arrival_event, rtnl_handle_ifattach, NULL,
EVENTHANDLER_PRI_ANY);
ifdetach_event = EVENTHANDLER_REGISTER(
ifnet_departure_event, rtnl_handle_ifdetach, NULL,
EVENTHANDLER_PRI_ANY);
ifaddr_event = EVENTHANDLER_REGISTER(
rt_addrmsg, rtnl_handle_ifaddr, NULL,
EVENTHANDLER_PRI_ANY);
rtnl_register_messages(cmd_handlers, RTNL_ARRAY_LEN(cmd_handlers));
}
void
rtnl_ifaces_destroy(void)
{
EVENTHANDLER_DEREGISTER(ifnet_arrival_event, ifattach_event);
EVENTHANDLER_DEREGISTER(ifnet_departure_event, ifdetach_event);
EVENTHANDLER_DEREGISTER(rt_addrmsg, ifaddr_event);
}