Page MenuHomeFreeBSD
Differential D36002 Diff 109100 sys/netlink/netlink_linux.c

Changeset View

Standalone View

View Options

sys/netlink/netlink_linux.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/rmlock.h>
#include <sys/socket.h>
#include <sys/ck.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 <net/route/route_var.h>
#include <netlink/netlink.h>
#include <netlink/netlink_ctl.h>
#include <netlink/netlink_var.h>
#include <netlink/netlink_route.h>
#include <compat/linux/linux.h>
#include <compat/linux/linux_common.h>
#define DEBUG_MOD_NAME nl_linux
#define DEBUG_MAX_LEVEL LOG_DEBUG3
#include <net/route/route_debug.h>
_DECLARE_DEBUG(LOG_DEBUG3);
static int
_linux_to_bsd_domain(int domain)
{
switch (domain) {
case LINUX_AF_UNSPEC:
return (AF_UNSPEC);
case LINUX_AF_UNIX:
return (AF_LOCAL);
case LINUX_AF_INET:
return (AF_INET);
case LINUX_AF_INET6:
return (AF_INET6);
}
return (-1);
}
static int
_bsd_to_linux_domain(int domain)
{
switch (domain) {
case AF_UNSPEC:
return (LINUX_AF_UNSPEC);
case AF_LOCAL:
return (LINUX_AF_UNIX);
case AF_INET:
return (LINUX_AF_INET);
case AF_INET6:
return (LINUX_AF_INET6);
}
return (-1);
}
static bool
valid_rta_size(const struct rtattr *rta, int sz)
{
return (NL_RTA_DATA_LEN(rta) == sz);
}
static bool
valid_rta_u32(const struct rtattr *rta)
{
return (valid_rta_size(rta, sizeof(uint32_t)));
}
static uint32_t
nl_rta_get_uint32(const struct rtattr *rta)
{
return (*((const uint32_t *)NL_RTA_DATA_CONST(rta)));
}
#if 0
static struct nlmsghdr *
rtnl_ifaddr_from_linux(struct nlmsghdr *hdr, struct netlink_parse_tracker *npt)
{
/* Tweak address families and default fib only */
struct ifaddrmsg *ifamsg = (struct ifaddrmsg *)(hdr + 1);
ifamsg->ifa_family = _linux_to_bsd_domain(ifamsg->ifa_family);
return (hdr);
}
#endif
static struct nlmsghdr *
rtnl_route_from_linux(struct nlmsghdr *hdr, struct netlink_parse_tracker *npt)
{
/* Tweak address families and default fib only */
struct rtmsg *rtm = (struct rtmsg *)(hdr + 1);
struct nlattr *nla, *nla_head;
int attrs_len;
rtm->rtm_family = _linux_to_bsd_domain(rtm->rtm_family);
if (rtm->rtm_table == 254)
rtm->rtm_table = 0;
attrs_len = hdr->nlmsg_len - sizeof(struct nlmsghdr);
attrs_len -= NETLINK_ALIGN(sizeof(struct rtmsg));
nla_head = (struct nlattr *)((char *)rtm + NETLINK_ALIGN(sizeof(struct rtmsg)));
NLA_FOREACH(nla, nla_head, attrs_len) {
RT_LOG(LOG_DEBUG3, "GOT type %d len %d total %d",
nla->nla_type, nla->nla_len, attrs_len);
struct rtattr *rta = (struct rtattr *)nla;
if (rta->rta_len < sizeof(struct rtattr)) {
break;
}
switch (rta->rta_type) {
case NL_RTA_TABLE:
if (!valid_rta_u32(rta))
goto done;
rtm->rtm_table = 0;
uint32_t fibnum = nl_rta_get_uint32(rta);
RT_LOG(LOG_DEBUG, "GET RTABLE: %u", fibnum);
if (fibnum == 254) {
*((uint32_t *)NL_RTA_DATA(rta)) = 0;
}
break;
}
}
done:
return (hdr);
}
static struct nlmsghdr *
rtnl_from_linux(struct nlmsghdr *hdr, struct netlink_parse_tracker *npt)
{
switch (hdr->nlmsg_type) {
case NL_RTM_GETROUTE:
case NL_RTM_NEWROUTE:
case NL_RTM_DELROUTE:
return (rtnl_route_from_linux(hdr, npt));
}
return (hdr);
}
struct nlmsghdr *
nlmsg_from_linux(struct nlmsghdr *hdr, struct netlink_parse_tracker *npt)
{
struct nlpcb *nlp = npt->nlp;
switch (nlp->nl_proto) {
case NETLINK_ROUTE:
return (rtnl_from_linux(hdr, npt));
}
return (hdr);
}
/************************************************************
* Kernel -> Linux
************************************************************/
static bool
handle_default_out(struct nlmsghdr *hdr, struct nlmsg_state *ns)
{
char *out_hdr;
out_hdr = nlmsg_reserve_data(ns, NLMSG_ALIGN(hdr->nlmsg_len), char);
if (out_hdr != NULL) {
memcpy(out_hdr, hdr, hdr->nlmsg_len);
return (true);
}
return (false);
}
static bool
nlmsg_copy_header(struct nlmsghdr *hdr, struct nlmsg_state *ns)
{
return (nlmsg_add(ns, hdr->nlmsg_pid, hdr->nlmsg_seq, hdr->nlmsg_type,
hdr->nlmsg_flags, 0));
}
static void *
_nlmsg_copy_next_header(struct nlmsghdr *hdr, struct nlmsg_state *ns, int sz)
{
void *next_hdr = nlmsg_reserve_data(ns, sz, void);
memcpy(next_hdr, hdr + 1, NLMSG_ALIGN(sz));
return (next_hdr);
}
#define nlmsg_copy_next_header(_hdr, _ns, _t) \
((_t *)(_nlmsg_copy_next_header(_hdr, _ns, sizeof(_t))))
static bool
nlmsg_copy_nla(const struct nlattr *nla_orig, struct nlmsg_state *ns)
{
struct nlattr *nla = nlmsg_reserve_data(ns, nla_orig->nla_len, struct nlattr);
if (nla != NULL) {
memcpy(nla, nla_orig, nla_orig->nla_len);
return (true);
}
return (false);
}
static bool
nlmsg_copy_all_nla(struct nlmsghdr *hdr, int raw_hdrlen, struct nlmsg_state *ns)
{
struct nlattr *nla;
int hdrlen = NETLINK_ALIGN(raw_hdrlen);
int attrs_len = hdr->nlmsg_len - sizeof(struct nlmsghdr) - hdrlen;
struct nlattr *nla_head = (struct nlattr *)((char *)(hdr + 1) + hdrlen);
NLA_FOREACH(nla, nla_head, attrs_len) {
if (!nlmsg_copy_nla(nla, ns))
return (false);
}
return (true);
}
static unsigned int
rtnl_if_flags_to_linux(unsigned int if_flags)
{
unsigned int result = 0;
for (int i = 0; i < 31; i++) {
unsigned int flag = 1 << i;
if (!(flag & if_flags))
continue;
switch (flag) {
case IFF_UP:
case IFF_BROADCAST:
case IFF_DEBUG:
case IFF_LOOPBACK:
case IFF_POINTOPOINT:
case IFF_NOARP:
case IFF_PROMISC:
case IFF_ALLMULTI:
result |= flag;
break;
case IFF_KNOWSEPOCH:
case IFF_DRV_RUNNING:
case IFF_DRV_OACTIVE:
case IFF_SIMPLEX:
case IFF_LINK0:
case IFF_LINK1:
case IFF_LINK2:
case IFF_CANTCONFIG:
case IFF_PPROMISC:
case IFF_MONITOR:
case IFF_STATICARP:
case IFF_STICKYARP:
case IFF_DYING:
case IFF_RENAMING:
case IFF_NOGROUP:
/* No Linux analogue */
break;
case IFF_MULTICAST:
result |= 1 << 12;
}
}
return (result);
}
static bool
rtnl_newlink_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp,
struct nlmsg_state *ns)
{
if (!nlmsg_copy_header(hdr, ns))
return (false);
struct ifinfomsg *ifinfo;
ifinfo = nlmsg_copy_next_header(hdr, ns, struct ifinfomsg);
ifinfo->ifi_family = _bsd_to_linux_domain(ifinfo->ifi_family);
/* Convert interface type */
switch (ifinfo->ifi_type) {
case IFT_ETHER:
ifinfo->ifi_type = 1; // ARPHRD_ETHER
break;
}
ifinfo->ifi_flags = rtnl_if_flags_to_linux(ifinfo->ifi_flags);
/* Copy attributes unchanged */
if (!nlmsg_copy_all_nla(hdr, sizeof(struct ifinfomsg), ns))
return (false);
/* make ip(8) happy */
if (!nlattr_add_string(ns, IFLA_QDISC, "noqueue"))
return (false);
if (!nlattr_add_u32(ns, IFLA_TXQLEN, 1000))
return (false);
nlmsg_end(ns);
RT_LOG(LOG_DEBUG2, "done processing ns %p", ns);
return (true);
}
static bool
rtnl_newaddr_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp,
struct nlmsg_state *ns)
{
if (!nlmsg_copy_header(hdr, ns))
return (false);
struct ifaddrmsg *ifamsg;
ifamsg = nlmsg_copy_next_header(hdr, ns, struct ifaddrmsg);
int old_family = ifamsg->ifa_family;
ifamsg->ifa_family = _bsd_to_linux_domain(ifamsg->ifa_family);
RT_LOG(LOG_DEBUG2, "CONVERT FAMILY %d -> %d", old_family, ifamsg->ifa_family);
/* XXX: fake ifa_flags? */
/* Copy attributes unchanged */
if (!nlmsg_copy_all_nla(hdr, sizeof(struct ifaddrmsg), ns))
return (false);
nlmsg_end(ns);
RT_LOG(LOG_DEBUG2, "done processing ns %p", ns);
return (true);
}
static bool
rtnl_newroute_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp,
struct nlmsg_state *ns)
{
if (!nlmsg_copy_header(hdr, ns))
return (false);
struct rtmsg *rtm;
rtm = nlmsg_copy_next_header(hdr, ns, struct rtmsg);
rtm->rtm_family = _bsd_to_linux_domain(rtm->rtm_family);
struct nlattr *nla;
int hdrlen = NETLINK_ALIGN(sizeof(struct rtmsg));
int attrs_len = hdr->nlmsg_len - sizeof(struct nlmsghdr) - hdrlen;
struct nlattr *nla_head = (struct nlattr *)((char *)(hdr + 1) + hdrlen);
NLA_FOREACH(nla, nla_head, attrs_len) {
struct rtattr *rta = (struct rtattr *)nla;
switch (rta->rta_type) {
case NL_RTA_TABLE:
{
uint32_t fibnum;
fibnum = nl_rta_get_uint32(rta);
if (fibnum == 0)
fibnum = 254;
RT_LOG(LOG_DEBUG3, "FIBNUM %u", fibnum);
if (!nlattr_add_u32(ns, NL_RTA_TABLE, fibnum))
return (false);
}
break;
default:
if (!nlmsg_copy_nla(nla, ns))
return (false);
break;
}
}
nlmsg_end(ns);
RT_LOG(LOG_DEBUG2, "done processing ns %p", ns);
return (true);
}
static bool
rtnl_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nlmsg_state *ns)
{
RT_LOG(LOG_DEBUG2, "Got message type %d", hdr->nlmsg_type);
switch (hdr->nlmsg_type) {
case NL_RTM_NEWLINK:
return (rtnl_newlink_to_linux(hdr, nlp, ns));
case NL_RTM_NEWADDR:
return (rtnl_newaddr_to_linux(hdr, nlp, ns));
case NL_RTM_DELADDR:
return (rtnl_newaddr_to_linux(hdr, nlp, ns));
case NL_RTM_NEWROUTE:
return (rtnl_newroute_to_linux(hdr, nlp, ns));
default:
return (handle_default_out(hdr, ns));
}
}
static bool
nlmsg_to_linux(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nlmsg_state *ns)
{
switch (nlp->nl_proto) {
case NETLINK_ROUTE:
return (rtnl_to_linux(hdr, nlp, ns));
default:
return (handle_default_out(hdr, ns));
}
}
struct mbuf *
nlmsgs_to_linux(char *buf, int data_length, struct nlpcb *nlp)
{
RT_LOG(LOG_DEBUG, "LINUX: get %p size %d", buf, data_length);
struct nlmsg_state ns = {};
struct mbuf *m = NULL;
if (!nlmsg_get_chain_writer(data_length, &m, &ns)) {
RT_LOG(LOG_DEBUG, "unable to setup chain writer for size %d",
data_length);
return (NULL);
}
/* Assume correct headers. Buffer IS mutable */
int count = 0;
for (int offset = 0; offset + sizeof(struct nlmsghdr) <= data_length;) {
struct nlmsghdr *hdr = (struct nlmsghdr *)&buf[offset];
int msglen = NLMSG_ALIGN(hdr->nlmsg_len);
count++;
if (!nlmsg_to_linux(hdr, nlp, &ns)) {
RT_LOG(LOG_DEBUG, "failed to process msg type %d",
hdr->nlmsg_type);
m_freem(m);
return (NULL);
}
offset += msglen;
}
nlmsg_flush(&ns);
nlmsg_free(&ns);
RT_LOG(LOG_DEBUG2, "Processed %d messages, chain size %d", count, m ? m_length(m, NULL) : 0);
return (m);
}
struct mbuf *
mbufs_to_linux(struct mbuf *m, struct nlpcb *nlp)
{
/* XXX: easiest solution, not optimized for performance */
int data_length = m_length(m, NULL);
char *buf = malloc(data_length, M_NETLINK, M_NOWAIT);
if (buf == NULL) {
RT_LOG(LOG_INFO, "unable to allocate %d bytes, dropping message",
data_length);
m_freem(m);
return (NULL);
}
m_copydata(m, 0, data_length, buf);
m_freem(m);
return (nlmsgs_to_linux(buf, data_length, nlp));
}