sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
1b64c80d72
nuttx/net/netlink/netlink_route.c
Alin Jerpelea 67d02a45eb net: migrate to SPDX identifier 
Most tools used for compliance and SBOM generation use SPDX identifiers
This change brings us a step closer to an easy SBOM generation.

Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2024-09-12 01:08:11 +08:00

1692 lines
45 KiB
C
Raw Blame History

/****************************************************************************
* net/netlink/netlink_route.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <arpa/inet.h>
#include <net/route.h>
#include <netpacket/netlink.h>
#include <netinet/if_ether.h>
#include <nuttx/kmalloc.h>
#include <nuttx/net/net.h>
#include <nuttx/net/ip.h>
#include <nuttx/net/neighbor.h>
#include <nuttx/net/netlink.h>
#include "netdev/netdev.h"
#include "arp/arp.h"
#include "net/if_arp.h"
#include "neighbor/neighbor.h"
#include "route/route.h"
#include "netlink/netlink.h"
#include "utils/utils.h"
#ifdef CONFIG_NETLINK_ROUTE
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Configuration ************************************************************/
#if !defined(CONFIG_NET_ARP) && !defined(CONFIG_NET_IPv6)
# undef CONFIG_NETLINK_DISABLE_GETNEIGH
# define CONFIG_NETLINK_DISABLE_GETNEIGH 1
#endif
#if !defined(CONFIG_NET_ROUTE) || (!defined(CONFIG_NET_IPv4) && \
!defined(CONFIG_NET_IPv6))
# undef CONFIG_NETLINK_DISABLE_GETROUTE
# define CONFIG_NETLINK_DISABLE_GETROUTE 1
#endif
/****************************************************************************
* Private Types
****************************************************************************/
/* RTM_GETLINK: Enumerate network devices */
struct getlink_recvfrom_response_s
{
struct nlmsghdr hdr;
struct ifinfomsg iface;
struct rtattr attrmtu;
uint32_t mtu; /* IFLA_MTU attribute */
#if defined(CONFIG_NET_ETHERNET) || defined(CONFIG_NET_TUN)
struct rtattr attraddr;
uint8_t mac[NLMSG_ALIGN(ETH_ALEN)]; /* IFLA_ADDRESS attribute */
#endif
struct rtattr attrname;
uint8_t data[IFNAMSIZ]; /* IFLA_IFNAME attribute */
};
struct getlink_recvfrom_rsplist_s
{
sq_entry_t flink;
struct getlink_recvfrom_response_s payload;
};
/* RTM_GETNEIGH: Get neighbor table entry */
struct getneigh_recvfrom_response_s
{
struct nlmsghdr hdr;
struct ndmsg msg;
struct rtattr attr;
uint8_t data[1];
};
#define SIZEOF_NLROUTE_RECVFROM_RESPONSE_S(n) \
(sizeof(struct getneigh_recvfrom_response_s) + (n) - 1)
struct getneigh_recvfrom_rsplist_s
{
sq_entry_t flink;
struct getneigh_recvfrom_response_s payload;
};
#define SIZEOF_NLROUTE_RECVFROM_RSPLIST_S(n) \
(sizeof(struct getneigh_recvfrom_rsplist_s) + (n) - 1)
/* RTM_GETROUTE. Get routing tables */
struct getroute_recvfrom_ipv4addr_s
{
struct rtattr attr;
in_addr_t addr;
};
struct getroute_recvfrom_ipv4response_s
{
struct nlmsghdr hdr;
struct rtmsg rte;
struct getroute_recvfrom_ipv4addr_s dst;
struct getroute_recvfrom_ipv4addr_s genmask;
struct getroute_recvfrom_ipv4addr_s gateway;
};
struct getroute_recvfrom_ipv4resplist_s
{
sq_entry_t flink;
struct getroute_recvfrom_ipv4response_s payload;
};
struct getroute_recvfrom_ipv6addr_s
{
struct rtattr attr;
net_ipv6addr_t addr;
};
struct getroute_recvfrom_ipv6response_s
{
struct nlmsghdr hdr;
struct rtmsg rte;
struct getroute_recvfrom_ipv6addr_s dst;
struct getroute_recvfrom_ipv6addr_s genmask;
struct getroute_recvfrom_ipv6addr_s gateway;
};
struct getroute_recvfrom_ipv6resplist_s
{
sq_entry_t flink;
struct getroute_recvfrom_ipv6response_s payload;
};
/* RTM_GETADDR: Get the specified network device address info */
struct getaddr_recvfrom_response_s
{
struct nlmsghdr hdr;
struct ifaddrmsg ifaddr;
struct rtattr attr;
#ifndef CONFIG_NET_IPv6
struct in_addr local_addr; /* IFA_LOCAL is the only attribute supported */
#else
struct in6_addr local_addr; /* IFA_LOCAL is the only attribute supported */
#endif
};
struct getaddr_recvfrom_rsplist_s
{
sq_entry_t flink;
struct getaddr_recvfrom_response_s payload;
};
struct getprefix_recvfrom_addr_s
{
struct rtattr attr;
net_ipv6addr_t addr;
};
struct getprefix_recvfrom_cache_s
{
struct rtattr attr;
struct prefix_cacheinfo pci;
};
struct getprefix_recvfrom_response_s
{
struct nlmsghdr hdr;
struct prefixmsg pmsg;
struct getprefix_recvfrom_addr_s prefix;
struct getprefix_recvfrom_cache_s pci;
};
struct getprefix_recvfrom_rsplist_s
{
sq_entry_t flink;
struct getprefix_recvfrom_response_s payload;
};
/* netdev_foreach() callback */
struct nlroute_sendto_request_s
{
struct nlmsghdr hdr;
struct rtgenmsg gen;
};
struct nlroute_info_s
{
NETLINK_HANDLE handle;
FAR const struct nlroute_sendto_request_s *req;
};
/****************************************************************************
* Private Data
****************************************************************************/
#ifdef CONFIG_NETLINK_VALIDATE_POLICY
# ifdef CONFIG_NET_IPv4
static const struct nla_policy g_ifa_ipv4_policy[] =
{
{0}, /* IFA_UNSPEC */
{NLA_U32, 0, NULL}, /* IFA_ADDRESS */
{NLA_U32, 0, NULL}, /* IFA_LOCAL */
{NLA_STRING, IFNAMSIZ - 1, NULL}, /* IFA_LABEL */
{NLA_U32, 0, NULL}, /* IFA_BROADCAST */
{0}, /* IFA_ANYCAST */
{NLA_UNSPEC, sizeof(struct ifa_cacheinfo), NULL}, /* IFA_CACHEINFO */
{0}, /* IFA_MULTICAST */
{NLA_U32, 0, NULL}, /* IFA_FLAGS */
{NLA_U32, 0, NULL}, /* IFA_RT_PRIORITY */
};
static_assert(sizeof(g_ifa_ipv4_policy) / sizeof(g_ifa_ipv4_policy[0]) ==
IFA_MAX + 1, "The policy definition has changed,"
" please check it");
# endif
# ifdef CONFIG_NET_IPv6
static const struct nla_policy g_ifa_ipv6_policy[] =
{
{0}, /* IFA_UNSPEC */
{0, sizeof(struct in6_addr), NULL}, /* IFA_ADDRESS */
{0, sizeof(struct in6_addr), NULL}, /* IFA_LOCAL */
{0}, /* IFA_LABEL */
{0}, /* IFA_BROADCAST */
{0}, /* IFA_ANYCAST */
{NLA_UNSPEC, sizeof(struct ifa_cacheinfo), NULL}, /* IFA_CACHEINFO */
{0}, /* IFA_MULTICAST */
{0, sizeof(uint32_t), NULL}, /* IFA_FLAGS */
{0, sizeof(uint32_t), NULL}, /* IFA_RT_PRIORITY */
};
static_assert(sizeof(g_ifa_ipv6_policy) / sizeof(g_ifa_ipv6_policy[0]) ==
IFA_MAX + 1, "The policy definition has changed,"
" please check it");
# endif
#else
# define g_ifa_ipv4_policy NULL
# define g_ifa_ipv6_policy NULL
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: netlink_get_device
*
* Description:
* Generate one device response.
*
****************************************************************************/
#ifndef CONFIG_NETLINK_DISABLE_GETLINK
static uint16_t netlink_convert_device_type(uint8_t lltype)
{
switch (lltype)
{
case NET_LL_ETHERNET:
return ARPHRD_ETHER;
case NET_LL_IEEE80211:
return ARPHRD_IEEE80211;
case NET_LL_LOOPBACK:
return ARPHRD_LOOPBACK;
case NET_LL_SLIP:
return ARPHRD_SLIP;
case NET_LL_TUN:
case NET_LL_BLUETOOTH:
case NET_LL_PKTRADIO:
case NET_LL_MBIM:
return ARPHRD_NONE;
case NET_LL_IEEE802154:
return ARPHRD_IEEE802154;
case NET_LL_CAN:
return ARPHRD_CAN;
case NET_LL_CELL:
return ARPHRD_PHONET_PIPE;
default:
nerr("ERROR: invalid lltype %d\n", lltype);
return ARPHRD_VOID;
}
}
static FAR struct netlink_response_s *
netlink_get_device(FAR struct net_driver_s *dev,
FAR const struct nlroute_sendto_request_s *req)
{
FAR struct getlink_recvfrom_rsplist_s *alloc;
FAR struct getlink_recvfrom_response_s *resp;
int up = IFF_IS_UP(dev->d_flags);
/* Allocate the response buffer */
alloc = (FAR struct getlink_recvfrom_rsplist_s *)
kmm_zalloc(sizeof(struct getlink_recvfrom_rsplist_s));
if (alloc == NULL)
{
nerr("ERROR: Failed to allocate response buffer.\n");
return NULL;
}
/* Initialize the response buffer */
resp = &alloc->payload;
resp->hdr.nlmsg_len = sizeof(struct getlink_recvfrom_response_s);
resp->hdr.nlmsg_type = up ? RTM_NEWLINK : RTM_DELLINK;
resp->hdr.nlmsg_flags = req ? req->hdr.nlmsg_flags : 0;
resp->hdr.nlmsg_seq = req ? req->hdr.nlmsg_seq : 0;
resp->hdr.nlmsg_pid = req ? req->hdr.nlmsg_pid : 0;
resp->iface.ifi_family = req ? req->gen.rtgen_family : AF_PACKET;
resp->iface.ifi_type = netlink_convert_device_type(dev->d_lltype);
#ifdef CONFIG_NETDEV_IFINDEX
resp->iface.ifi_index = dev->d_ifindex;
#endif
resp->iface.ifi_flags = dev->d_flags;
resp->iface.ifi_change = 0xffffffff;
resp->attrmtu.rta_len = RTA_LENGTH(sizeof(uint32_t));
resp->attrmtu.rta_type = IFLA_MTU;
resp->mtu = NETDEV_PKTSIZE(dev) - NET_LL_HDRLEN(dev);
#if defined(CONFIG_NET_ETHERNET) || defined(CONFIG_NET_TUN)
resp->attraddr.rta_len = RTA_LENGTH(ETH_ALEN);
resp->attraddr.rta_type = IFLA_ADDRESS;
if (dev->d_lltype == NET_LL_ETHERNET ||
dev->d_lltype == NET_LL_IEEE80211 ||
dev->d_lltype == NET_LL_LOOPBACK ||
dev->d_lltype == NET_LL_TUN)
{
memcpy(&resp->mac, &dev->d_mac.ether, ETH_ALEN);
}
else
{
memset(&resp->mac, 0, ETH_ALEN);
}
#endif
resp->attrname.rta_len = RTA_LENGTH(strnlen(dev->d_ifname, IFNAMSIZ));
resp->attrname.rta_type = IFLA_IFNAME;
strlcpy((FAR char *)resp->data, dev->d_ifname, IFNAMSIZ);
/* Finally, return the response */
return (FAR struct netlink_response_s *)alloc;
}
#endif
#ifdef CONFIG_NET_IPv4
static uint32_t make_mask(int prefixlen)
{
if (prefixlen)
{
return HTONL(UINT32_MAX << (32 - prefixlen));
}
return 0;
}
#endif
/****************************************************************************
* Name: netlink_get_ifaddr
*
* Description:
* Generate one interface address response.
*
****************************************************************************/
#ifndef CONFIG_NETLINK_DISABLE_GETLINK
static FAR struct netlink_response_s *
netlink_get_ifaddr(FAR struct net_driver_s *dev, int domain, int type,
FAR const void *local_addr, uint8_t prefixlen,
FAR const struct nlroute_sendto_request_s *req)
{
FAR struct getaddr_recvfrom_rsplist_s *alloc;
FAR struct getaddr_recvfrom_response_s *resp;
/* Allocate the response buffer */
alloc = (FAR struct getaddr_recvfrom_rsplist_s *)
kmm_zalloc(sizeof(struct getaddr_recvfrom_rsplist_s));
if (alloc == NULL)
{
nerr("ERROR: Failed to allocate response buffer.\n");
return NULL;
}
/* Initialize the response buffer */
resp = &alloc->payload;
resp->hdr.nlmsg_len = sizeof(struct getaddr_recvfrom_response_s);
resp->hdr.nlmsg_type = type;
resp->hdr.nlmsg_flags = req ? req->hdr.nlmsg_flags : 0;
resp->hdr.nlmsg_seq = req ? req->hdr.nlmsg_seq : 0;
resp->hdr.nlmsg_pid = req ? req->hdr.nlmsg_pid : 0;
resp->ifaddr.ifa_family = domain;
#ifdef CONFIG_NETDEV_IFINDEX
resp->ifaddr.ifa_index = dev->d_ifindex;
#endif
resp->ifaddr.ifa_flags = IFA_F_PERMANENT;
resp->ifaddr.ifa_scope = RT_SCOPE_UNIVERSE;
resp->attr.rta_type = IFA_LOCAL;
#ifdef CONFIG_NET_IPv4
if (domain == AF_INET)
{
resp->attr.rta_len = RTA_LENGTH(sizeof(struct in_addr));
memcpy(&resp->local_addr, local_addr, sizeof(struct in_addr));
resp->ifaddr.ifa_prefixlen = prefixlen;
}
#endif
#ifdef CONFIG_NET_IPv6
if (domain == AF_INET6)
{
resp->attr.rta_len = RTA_LENGTH(sizeof(struct in6_addr));
memcpy(&resp->local_addr, local_addr, sizeof(struct in6_addr));
resp->ifaddr.ifa_prefixlen = prefixlen;
}
#endif
/* Finally, return the response */
return (FAR struct netlink_response_s *)alloc;
}
#endif
/****************************************************************************
* Name: netlink_get_devlist
*
* Description:
* Dump a list of all network devices of the specified type.
*
****************************************************************************/
#ifndef CONFIG_NETLINK_DISABLE_GETLINK
static int netlink_device_callback(FAR struct net_driver_s *dev,
FAR void *arg)
{
FAR struct nlroute_info_s *info = arg;
FAR struct netlink_response_s * resp;
resp = netlink_get_device(dev, info->req);
if (resp == NULL)
{
return -ENOMEM;
}
netlink_add_response(info->handle, resp);
return OK;
}
static int netlink_get_devlist(NETLINK_HANDLE handle,
FAR const struct nlroute_sendto_request_s *req)
{
struct nlroute_info_s info;
int ret;
/* Visit each device */
info.handle = handle;
info.req = req;
net_lock();
ret = netdev_foreach(netlink_device_callback, &info);
net_unlock();
if (ret < 0)
{
return ret;
}
return netlink_add_terminator(handle, &req->hdr, 0);
}
#endif
/****************************************************************************
* Name: netlink_fill_arptable()
*
* Description:
* Return the entire ARP table.
*
****************************************************************************/
#if defined(CONFIG_NET_ARP) && !defined(CONFIG_NETLINK_DISABLE_GETNEIGH)
static size_t netlink_fill_arptable(
FAR struct getneigh_recvfrom_rsplist_s **entry)
{
unsigned int ncopied;
size_t allocsize;
size_t tabsize;
size_t rspsize;
/* Lock the network so that the ARP table will be stable, then copy
* the ARP table into the allocated memory.
*/
net_lock();
ncopied = arp_snapshot((FAR struct arpreq *)(*entry)->payload.data,
CONFIG_NET_ARPTAB_SIZE);
net_unlock();
/* Now we have the real number of valid entries in the ARP table and
* we can trim the allocation.
*/
if (ncopied > 0)
{
FAR struct getneigh_recvfrom_rsplist_s *newentry;
tabsize = ncopied * sizeof(struct arpreq);
rspsize = SIZEOF_NLROUTE_RECVFROM_RESPONSE_S(tabsize);
allocsize = SIZEOF_NLROUTE_RECVFROM_RSPLIST_S(tabsize);
newentry = kmm_realloc(*entry, allocsize);
if (newentry != NULL)
{
*entry = newentry;
}
(*entry)->payload.hdr.nlmsg_len = rspsize;
(*entry)->payload.attr.rta_len = RTA_LENGTH(tabsize);
}
return ncopied;
}
#endif
/****************************************************************************
* Name: netlink_fill_nbtable()
*
* Description:
* Return the entire IPv6 neighbor table.
*
****************************************************************************/
#if defined(CONFIG_NET_IPv6) && !defined(CONFIG_NETLINK_DISABLE_GETNEIGH)
static size_t netlink_fill_nbtable(
FAR struct getneigh_recvfrom_rsplist_s **entry)
{
unsigned int ncopied;
size_t allocsize;
size_t tabsize;
size_t rspsize;
/* Lock the network so that the Neighbor table will be stable, then
* copy the Neighbor table into the allocated memory.
*/
net_lock();
ncopied = neighbor_snapshot(
(FAR struct neighbor_entry_s *)(*entry)->payload.data,
CONFIG_NET_IPv6_NCONF_ENTRIES);
net_unlock();
/* Now we have the real number of valid entries in the Neighbor table
* and we can trim the allocation.
*/
if (ncopied > 0)
{
FAR struct getneigh_recvfrom_rsplist_s *newentry;
tabsize = ncopied * sizeof(struct neighbor_entry_s);
rspsize = SIZEOF_NLROUTE_RECVFROM_RESPONSE_S(tabsize);
allocsize = SIZEOF_NLROUTE_RECVFROM_RSPLIST_S(tabsize);
newentry = kmm_realloc(*entry, allocsize);
if (newentry != NULL)
{
*entry = newentry;
}
(*entry)->payload.hdr.nlmsg_len = rspsize;
(*entry)->payload.attr.rta_len = RTA_LENGTH(tabsize);
}
return ncopied;
}
#endif
/****************************************************************************
* Name: netlink_fill_nbtable()
*
* Description:
* Return the entire IPv6 neighbor table.
*
****************************************************************************/
#if !defined(CONFIG_NETLINK_DISABLE_GETNEIGH)
static FAR struct netlink_response_s *
netlink_get_neighbor(FAR const void *neigh, int domain, int type,
FAR const struct nlroute_sendto_request_s *req)
{
FAR struct getneigh_recvfrom_rsplist_s *alloc;
FAR struct getneigh_recvfrom_response_s *resp;
size_t allocsize;
size_t tabsize;
size_t tabnum;
size_t rspsize;
/* Preallocate memory to hold the maximum sized ARP table
* REVISIT: This is probably excessively large and could cause false
* memory out conditions. A better approach would be to actually count
* the number of valid entries in the ARP table.
*/
#if defined(CONFIG_NET_ARP)
if (domain == AF_INET)
{
tabnum = req ? CONFIG_NET_ARPTAB_SIZE : 1;
tabsize = tabnum * sizeof(struct arpreq);
}
else
#endif
#if defined(CONFIG_NET_IPv6)
if (domain == AF_INET6)
{
tabnum = req ? CONFIG_NET_IPv6_NCONF_ENTRIES : 1;
tabsize = tabnum * sizeof(struct neighbor_entry_s);
}
else
#endif
{
return NULL;
}
rspsize = SIZEOF_NLROUTE_RECVFROM_RESPONSE_S(tabsize);
allocsize = SIZEOF_NLROUTE_RECVFROM_RSPLIST_S(tabsize);
/* Allocate the response buffer */
alloc = kmm_zalloc(allocsize);
if (alloc == NULL)
{
nerr("ERROR: Failed to allocate response buffer.\n");
return NULL;
}
/* Initialize the response buffer */
resp = &alloc->payload;
resp->hdr.nlmsg_len = rspsize;
resp->hdr.nlmsg_type = type;
resp->hdr.nlmsg_flags = req ? req->hdr.nlmsg_flags : 0;
resp->hdr.nlmsg_seq = req ? req->hdr.nlmsg_seq : 0;
resp->hdr.nlmsg_pid = req ? req->hdr.nlmsg_pid : 0;
resp->msg.ndm_family = domain;
resp->attr.rta_len = RTA_LENGTH(tabsize);
/* Copy neigh or arp entries into resp data */
if (req == NULL)
{
if (neigh == NULL)
{
return NULL;
}
/* Only one entry need to notify */
memcpy(resp->data, neigh, tabsize);
}
#if defined(CONFIG_NET_ARP)
else if (domain == AF_INET)
{
tabnum = netlink_fill_arptable(&alloc);
}
#endif
#if defined(CONFIG_NET_IPv6)
else if (domain == AF_INET6)
{
tabnum = netlink_fill_nbtable(&alloc);
}
#endif
/* If no entry in table, just free alloc */
if (tabnum <= 0)
{
kmm_free(alloc);
nwarn("WARNING: Failed to get entry in %s table.\n",
domain == AF_INET ? "ARP" : "neighbor");
return NULL;
}
return (FAR struct netlink_response_s *)alloc;
}
static int netlink_get_neighborlist(NETLINK_HANDLE handle, int domain,
FAR const struct nlroute_sendto_request_s *req)
{
FAR struct netlink_response_s *resp;
resp = netlink_get_neighbor(NULL, domain, RTM_GETNEIGH, req);
if (resp == NULL)
{
return -ENOENT;
}
netlink_add_response(handle, resp);
return netlink_add_terminator(handle, &req->hdr, 0);
}
#endif /* CONFIG_NETLINK_DISABLE_GETNEIGH */
/****************************************************************************
* Name: netlink_ipv4_route
*
* Description:
* Dump a list of all network devices of the specified type.
*
****************************************************************************/
#if defined(CONFIG_NET_IPv4) && !defined(CONFIG_NETLINK_DISABLE_GETROUTE)
static FAR struct netlink_response_s *
netlink_get_ipv4_route(FAR const struct net_route_ipv4_s *route, int type,
FAR const struct nlroute_sendto_request_s *req)
{
FAR struct getroute_recvfrom_ipv4resplist_s *alloc;
FAR struct getroute_recvfrom_ipv4response_s *resp;
DEBUGASSERT(route != NULL);
/* Allocate the response */
alloc = (FAR struct getroute_recvfrom_ipv4resplist_s *)
kmm_zalloc(sizeof(struct getroute_recvfrom_ipv4resplist_s));
if (alloc == NULL)
{
return NULL;
}
/* Format the response */
resp = &alloc->payload;
resp->hdr.nlmsg_len = sizeof(struct getroute_recvfrom_ipv4response_s);
resp->hdr.nlmsg_type = type;
resp->hdr.nlmsg_flags = req ? req->hdr.nlmsg_flags : 0;
resp->hdr.nlmsg_seq = req ? req->hdr.nlmsg_seq : 0;
resp->hdr.nlmsg_pid = req ? req->hdr.nlmsg_pid : 0;
resp->rte.rtm_family = AF_INET;
resp->rte.rtm_table = RT_TABLE_MAIN;
resp->rte.rtm_protocol = RTPROT_STATIC;
resp->rte.rtm_scope = RT_SCOPE_SITE;
resp->dst.attr.rta_len = RTA_LENGTH(sizeof(in_addr_t));
resp->dst.attr.rta_type = RTA_DST;
resp->dst.addr = route->target;
resp->genmask.attr.rta_len = RTA_LENGTH(sizeof(in_addr_t));
resp->genmask.attr.rta_type = RTA_GENMASK;
resp->genmask.addr = route->netmask;
resp->gateway.attr.rta_len = RTA_LENGTH(sizeof(in_addr_t));
resp->gateway.attr.rta_type = RTA_GATEWAY;
resp->gateway.addr = route->router;
return (FAR struct netlink_response_s *)alloc;
}
/****************************************************************************
* Name: netlink_ipv4route_callback
*
* Input Parameters:
* route - The entry of IPV4 routing table.
* arg - The netlink info of request.
*
****************************************************************************/
static int netlink_ipv4route_callback(FAR struct net_route_ipv4_s *route,
FAR void *arg)
{
FAR struct nlroute_info_s *info = arg;
FAR struct netlink_response_s *resp;
resp = netlink_get_ipv4_route(route, RTM_NEWROUTE, info->req);
if (resp == NULL)
{
return -ENOENT;
}
/* Finally, add the response to the list of pending responses */
netlink_add_response(info->handle, resp);
return OK;
}
#endif
/****************************************************************************
* Name: netlink_list_ipv4_route
*
* Description:
* Dump a list of all network devices of the specified type.
*
****************************************************************************/
#if defined(CONFIG_NET_IPv4) && !defined(CONFIG_NETLINK_DISABLE_GETROUTE)
static int netlink_list_ipv4_route(NETLINK_HANDLE handle,
FAR const struct nlroute_sendto_request_s *req)
{
struct nlroute_info_s info;
int ret;
/* Visit each routing table entry */
info.handle = handle;
info.req = req;
ret = net_foreachroute_ipv4(netlink_ipv4route_callback, &info);
if (ret < 0)
{
return ret;
}
/* Terminate the routing table */
return netlink_add_terminator(handle, &req->hdr, 0);
}
#endif
/****************************************************************************
* Name: netlink_get_ipv6_route
*
* Description:
* Dump a list of all network devices of the specified type.
*
****************************************************************************/
#if defined(CONFIG_NET_IPv6) && !defined(CONFIG_NETLINK_DISABLE_GETROUTE)
static FAR struct netlink_response_s *
netlink_get_ipv6_route(FAR const struct net_route_ipv6_s *route, int type,
FAR const struct nlroute_sendto_request_s *req)
{
FAR struct getroute_recvfrom_ipv6resplist_s *alloc;
FAR struct getroute_recvfrom_ipv6response_s *resp;
DEBUGASSERT(route != NULL);
/* Allocate the response */
alloc = (FAR struct getroute_recvfrom_ipv6resplist_s *)
kmm_zalloc(sizeof(struct getroute_recvfrom_ipv6resplist_s));
if (alloc == NULL)
{
return NULL;
}
/* Format the response */
resp = &alloc->payload;
resp->hdr.nlmsg_len = sizeof(struct getroute_recvfrom_ipv6response_s);
resp->hdr.nlmsg_type = type;
resp->hdr.nlmsg_flags = req ? req->hdr.nlmsg_flags : 0;
resp->hdr.nlmsg_seq = req ? req->hdr.nlmsg_seq : 0;
resp->hdr.nlmsg_pid = req ? req->hdr.nlmsg_pid : 0;
resp->rte.rtm_family = AF_INET6;
resp->rte.rtm_table = RT_TABLE_MAIN;
resp->rte.rtm_protocol = RTPROT_STATIC;
resp->rte.rtm_scope = RT_SCOPE_SITE;
resp->dst.attr.rta_len = RTA_LENGTH(sizeof(net_ipv6addr_t));
resp->dst.attr.rta_type = RTA_DST;
net_ipv6addr_copy(resp->dst.addr, route->target);
resp->genmask.attr.rta_len = RTA_LENGTH(sizeof(net_ipv6addr_t));
resp->genmask.attr.rta_type = RTA_GENMASK;
net_ipv6addr_copy(resp->genmask.addr, route->netmask);
resp->gateway.attr.rta_len = RTA_LENGTH(sizeof(net_ipv6addr_t));
resp->gateway.attr.rta_type = RTA_GATEWAY;
net_ipv6addr_copy(resp->gateway.addr, route->router);
return (FAR struct netlink_response_s *)alloc;
}
/****************************************************************************
* Name: netlink_ipv6route_callback
*
* Description:
* Response netlink message from ipv6 route list.
*
* Input Parameters:
* route - The entry of IPV6 routing table.
* arg - The netlink info of request.
*
****************************************************************************/
static int netlink_ipv6route_callback(FAR struct net_route_ipv6_s *route,
FAR void *arg)
{
FAR struct nlroute_info_s *info = arg;
FAR struct netlink_response_s *resp;
resp = netlink_get_ipv6_route(route, RTM_NEWROUTE, info->req);
if (resp == NULL)
{
return -ENOENT;
}
/* Finally, add the response to the list of pending responses */
netlink_add_response(info->handle, resp);
return OK;
}
#endif
/****************************************************************************
* Name: netlink_get_ipv6route
*
* Description:
* Dump a list of all network devices of the specified type.
*
****************************************************************************/
#if defined(CONFIG_NET_IPv6) && !defined(CONFIG_NETLINK_DISABLE_GETROUTE)
static int netlink_list_ipv6_route(NETLINK_HANDLE handle,
FAR const struct nlroute_sendto_request_s *req)
{
struct nlroute_info_s info;
int ret;
/* Visit each routing table entry */
info.handle = handle;
info.req = req;
ret = net_foreachroute_ipv6(netlink_ipv6route_callback, &info);
if (ret < 0)
{
return ret;
}
/* Terminate the routing table */
return netlink_add_terminator(handle, &req->hdr, 0);
}
#endif
/****************************************************************************
* Name: netlink_new_ipv4addr
*
* Description:
* Set the ipv4 address.
*
****************************************************************************/
#if defined(CONFIG_NET_IPv4) && !defined(CONFIG_NETLINK_DISABLE_NEWADDR)
static int netlink_new_ipv4addr(NETLINK_HANDLE handle,
FAR const struct nlmsghdr *nlmsg)
{
FAR struct net_driver_s *dev;
FAR struct ifaddrmsg *ifm = NLMSG_DATA(nlmsg);
FAR struct nlattr *tb[IFA_MAX + 1];
struct netlink_ext_ack extack;
int ret;
ret = nlmsg_parse(nlmsg, sizeof(*ifm), tb, IFA_MAX, g_ifa_ipv4_policy,
&extack);
if (ret < 0)
{
return ret;
}
if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
{
return -EINVAL;
}
net_lock();
dev = netdev_findbyindex(ifm->ifa_index);
if (dev == NULL)
{
net_unlock();
return -ENODEV;
}
dev->d_ipaddr = nla_get_in_addr(tb[IFA_LOCAL]);
dev->d_netmask = make_mask(ifm->ifa_prefixlen);
netlink_device_notify_ipaddr(dev, RTM_NEWADDR, AF_INET, &dev->d_ipaddr,
ifm->ifa_prefixlen);
net_unlock();
return OK;
}
#endif
/****************************************************************************
* Name: netlink_new_ipv6addr
*
* Description:
* Set the ipv6 address.
*
****************************************************************************/
#if defined(CONFIG_NET_IPv6) && !defined(CONFIG_NETLINK_DISABLE_NEWADDR)
static int netlink_new_ipv6addr(NETLINK_HANDLE handle,
FAR const struct nlmsghdr *nlmsg)
{
FAR struct net_driver_s *dev;
FAR struct ifaddrmsg *ifm = NLMSG_DATA(nlmsg);
FAR struct nlattr *tb[IFA_MAX + 1];
struct netlink_ext_ack extack;
int ret;
ret = nlmsg_parse(nlmsg, sizeof(*ifm), tb, IFA_MAX, g_ifa_ipv6_policy,
&extack);
if (ret < 0)
{
return ret;
}
if (ifm->ifa_prefixlen > 128 || !tb[IFA_LOCAL])
{
return -EINVAL;
}
net_lock();
dev = netdev_findbyindex(ifm->ifa_index);
if (dev == NULL)
{
net_unlock();
return -ENODEV;
}
ret = netdev_ipv6_add(dev, nla_data(tb[IFA_LOCAL]), ifm->ifa_prefixlen);
if (ret == OK)
{
netlink_device_notify_ipaddr(dev, RTM_NEWADDR, AF_INET6,
nla_data(tb[IFA_LOCAL]), ifm->ifa_prefixlen);
}
net_unlock();
return ret;
}
#endif
/****************************************************************************
* Name: netlink_del_ipv4addr
*
* Description:
* Clear the ipv4 address.
*
****************************************************************************/
#if defined(CONFIG_NET_IPv4) && !defined(CONFIG_NETLINK_DISABLE_DELADDR)
static int netlink_del_ipv4addr(NETLINK_HANDLE handle,
FAR const struct nlmsghdr *nlmsg)
{
FAR struct net_driver_s *dev;
FAR struct ifaddrmsg *ifm = NLMSG_DATA(nlmsg);
FAR struct nlattr *tb[IFA_MAX + 1];
struct netlink_ext_ack extack;
int ret;
ret = nlmsg_parse(nlmsg, sizeof(*ifm), tb, IFA_MAX, g_ifa_ipv4_policy,
&extack);
if (ret < 0)
{
return ret;
}
net_lock();
dev = netdev_findbyindex(ifm->ifa_index);
if (dev == NULL)
{
net_unlock();
return -ENODEV;
}
if (tb[IFA_LOCAL] && dev->d_ipaddr != nla_get_in_addr(tb[IFA_LOCAL]))
{
net_unlock();
return -EADDRNOTAVAIL;
}
netlink_device_notify_ipaddr(dev, RTM_DELADDR, AF_INET, &dev->d_ipaddr,
net_ipv4_mask2pref(dev->d_netmask));
dev->d_ipaddr = 0;
net_unlock();
return OK;
}
#endif
/****************************************************************************
* Name: netlink_del_ipv6addr
*
* Description:
* Clear the ipv6 address.
*
****************************************************************************/
#if defined(CONFIG_NET_IPv6) && !defined(CONFIG_NETLINK_DISABLE_DELADDR)
static int netlink_del_ipv6addr(NETLINK_HANDLE handle,
FAR const struct nlmsghdr *nlmsg)
{
FAR struct net_driver_s *dev;
FAR struct ifaddrmsg *ifm = NLMSG_DATA(nlmsg);
FAR struct nlattr *tb[IFA_MAX + 1];
struct netlink_ext_ack extack;
int ret;
ret = nlmsg_parse(nlmsg, sizeof(*ifm), tb, IFA_MAX, g_ifa_ipv6_policy,
&extack);
if (ret < 0)
{
return ret;
}
if (!tb[IFA_LOCAL] || ifm->ifa_prefixlen > 128)
{
return -EINVAL;
}
net_lock();
dev = netdev_findbyindex(ifm->ifa_index);
if (dev == NULL)
{
net_unlock();
return -ENODEV;
}
if (!NETDEV_IS_MY_V6ADDR(dev, nla_data(tb[IFA_LOCAL])))
{
net_unlock();
return -EADDRNOTAVAIL;
}
ret = netdev_ipv6_del(dev, nla_data(tb[IFA_LOCAL]), ifm->ifa_prefixlen);
if (ret == OK)
{
netlink_device_notify_ipaddr(dev, RTM_DELADDR, AF_INET6,
nla_data(tb[IFA_LOCAL]), ifm->ifa_prefixlen);
}
net_unlock();
return ret;
}
#endif
/****************************************************************************
* Name: netlink_get_addr
*
* Description:
* Clear the ipv4/ipv6 address.
*
****************************************************************************/
#ifndef CONFIG_NETLINK_DISABLE_GETADDR
#ifdef CONFIG_NET_IPv6
static int netlink_ipv6_addr_callback(FAR struct net_driver_s *dev,
FAR struct netdev_ifaddr6_s *addr,
FAR void *arg)
{
FAR struct nlroute_info_s *info = arg;
FAR struct netlink_response_s *resp;
resp = netlink_get_ifaddr(dev, AF_INET6, RTM_NEWADDR, addr->addr,
net_ipv6_mask2pref(addr->mask), info->req);
if (resp == NULL)
{
return -ENOMEM;
}
netlink_add_response(info->handle, resp);
return OK;
}
#endif
static int netlink_addr_callback(FAR struct net_driver_s *dev, FAR void *arg)
{
FAR struct nlroute_info_s *info = arg;
FAR struct netlink_response_s *resp;
#ifdef CONFIG_NET_IPv4
if (info->req->gen.rtgen_family == AF_INET)
{
resp = netlink_get_ifaddr(dev, AF_INET, RTM_NEWADDR, &dev->d_ipaddr,
net_ipv4_mask2pref(dev->d_netmask),
info->req);
if (resp == NULL)
{
return -ENOMEM;
}
netlink_add_response(info->handle, resp);
}
#endif
#ifdef CONFIG_NET_IPv6
if (info->req->gen.rtgen_family == AF_INET6)
{
return netdev_ipv6_foreach(dev, netlink_ipv6_addr_callback, arg);
}
#endif
return OK;
}
static int netlink_get_addr(NETLINK_HANDLE handle,
FAR const struct nlroute_sendto_request_s *req)
{
struct nlroute_info_s info;
int ret;
/* Visit each device */
info.handle = handle;
info.req = req;
net_lock();
ret = netdev_foreach(netlink_addr_callback, &info);
net_unlock();
if (ret < 0)
{
return ret;
}
return netlink_add_terminator(handle, &req->hdr, 0);
}
#endif
#if !defined(CONFIG_NETLINK_DISABLE_NEWADDR) && defined(CONFIG_NET_IPv6)
static FAR struct netlink_response_s *
netlink_fill_ipv6prefix(FAR struct net_driver_s *dev, int type,
FAR const struct icmpv6_prefixinfo_s *pinfo)
{
FAR struct getprefix_recvfrom_rsplist_s *alloc;
FAR struct getprefix_recvfrom_response_s *resp;
DEBUGASSERT(dev != NULL && pinfo != NULL);
alloc = kmm_zalloc(sizeof(struct getprefix_recvfrom_rsplist_s));
if (alloc == NULL)
{
nerr("ERROR: Failed to allocate response buffer.\n");
return NULL;
}
/* Initialize the response buffer */
resp = &alloc->payload;
resp->hdr.nlmsg_len = sizeof(struct getprefix_recvfrom_response_s);
resp->hdr.nlmsg_type = type;
resp->hdr.nlmsg_flags = 0;
resp->hdr.nlmsg_seq = 0;
resp->hdr.nlmsg_pid = 0;
resp->pmsg.prefix_family = AF_INET6;
#ifdef CONFIG_NETDEV_IFINDEX
resp->pmsg.prefix_ifindex = dev->d_ifindex;
#endif
resp->pmsg.prefix_len = pinfo->optlen;
resp->pmsg.prefix_type = pinfo->opttype;
resp->prefix.attr.rta_len = RTA_LENGTH(sizeof(net_ipv6addr_t));
resp->prefix.attr.rta_type = PREFIX_ADDRESS;
net_ipv6addr_copy(resp->prefix.addr, pinfo->prefix);
resp->pci.attr.rta_len = RTA_LENGTH(sizeof(struct prefix_cacheinfo));
resp->pci.attr.rta_type = PREFIX_CACHEINFO;
resp->pci.pci.preferred_time = NTOHS(pinfo->plifetime[0]) << 16;
resp->pci.pci.preferred_time |= NTOHS(pinfo->plifetime[1]);
resp->pci.pci.valid_time = NTOHS(pinfo->vlifetime[0]) << 16;
resp->pci.pci.valid_time |= NTOHS(pinfo->vlifetime[1]);
/* Finally, return the response */
return (FAR struct netlink_response_s *)alloc;
}
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: netlink_route_sendto()
*
* Description:
* Perform the sendto() operation for the NETLINK_ROUTE protocol.
*
****************************************************************************/
ssize_t netlink_route_sendto(NETLINK_HANDLE handle,
FAR const struct nlmsghdr *nlmsg,
size_t len, int flags,
FAR const struct sockaddr_nl *to,
socklen_t tolen)
{
FAR const struct nlroute_sendto_request_s *req =
(FAR const struct nlroute_sendto_request_s *)nlmsg;
int ret;
DEBUGASSERT(handle != NULL && nlmsg != NULL &&
nlmsg->nlmsg_len >= sizeof(struct nlmsghdr) &&
len >= sizeof(struct nlmsghdr) &&
len >= nlmsg->nlmsg_len && to != NULL &&
tolen >= sizeof(struct sockaddr_nl));
/* Handle according to the message type */
switch (nlmsg->nlmsg_type)
{
#ifndef CONFIG_NETLINK_DISABLE_GETLINK
/* Dump a list of all devices */
case RTM_GETLINK:
/* Generate the response */
ret = netlink_get_devlist(handle, req);
break;
#endif
#ifndef CONFIG_NETLINK_DISABLE_GETNEIGH
/* Retrieve ARP/Neighbor Tables */
case RTM_GETNEIGH:
#ifdef CONFIG_NET_ARP
/* Retrieve the ARP table in its entirety. */
if (req->gen.rtgen_family == AF_INET)
{
ret = netlink_get_neighborlist(handle, AF_INET, req);
}
else
#endif
#ifdef CONFIG_NET_IPv6
/* Retrieve the IPv6 neighbor table in its entirety. */
if (req->gen.rtgen_family == AF_INET6)
{
ret = netlink_get_neighborlist(handle, AF_INET6, req);
}
else
#endif
{
ret = -EAFNOSUPPORT;
}
break;
#endif /* !CONFIG_NETLINK_DISABLE_GETNEIGH */
#ifndef CONFIG_NETLINK_DISABLE_GETROUTE
/* Retrieve the IPv4 or IPv6 routing table */
case RTM_GETROUTE:
#ifdef CONFIG_NET_IPv4
if (req->gen.rtgen_family == AF_INET)
{
ret = netlink_list_ipv4_route(handle, req);
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (req->gen.rtgen_family == AF_INET6)
{
ret = netlink_list_ipv6_route(handle, req);
}
else
#endif
{
ret = -EAFNOSUPPORT;
}
break;
#endif
#ifndef CONFIG_NETLINK_DISABLE_NEWADDR
/* Set the IPv4 or IPv6 address */
case RTM_NEWADDR:
#ifdef CONFIG_NET_IPv4
if (req->gen.rtgen_family == AF_INET)
{
ret = netlink_new_ipv4addr(handle, nlmsg);
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (req->gen.rtgen_family == AF_INET6)
{
ret = netlink_new_ipv6addr(handle, nlmsg);
}
else
#endif
{
ret = -EAFNOSUPPORT;
}
break;
#endif
#ifndef CONFIG_NETLINK_DISABLE_DELADDR
/* Clear the IPv4 or IPv6 address */
case RTM_DELADDR:
#ifdef CONFIG_NET_IPv4
if (req->gen.rtgen_family == AF_INET)
{
ret = netlink_del_ipv4addr(handle, nlmsg);
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (req->gen.rtgen_family == AF_INET6)
{
ret = netlink_del_ipv6addr(handle, nlmsg);
}
else
#endif
{
ret = -EAFNOSUPPORT;
}
break;
#endif
#ifndef CONFIG_NETLINK_DISABLE_GETADDR
/* Get the IPv4 or IPv6 address */
case RTM_GETADDR:
#ifdef CONFIG_NET_IPv4
if (req->gen.rtgen_family == AF_INET)
{
ret = netlink_get_addr(handle, req);
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (req->gen.rtgen_family == AF_INET6)
{
ret = netlink_get_addr(handle, req);
}
else
#endif
{
ret = -EAFNOSUPPORT;
}
break;
#endif
default:
ret = -ENOSYS;
break;
}
/* On success, return the size of the request that was processed */
if (ret >= 0)
{
ret = len;
}
return ret;
}
/****************************************************************************
* Name: netlink_device_notify()
*
* Description:
* Perform the route broadcast for the NETLINK_ROUTE protocol.
*
****************************************************************************/
#ifndef CONFIG_NETLINK_DISABLE_GETLINK
void netlink_device_notify(FAR struct net_driver_s *dev)
{
FAR struct netlink_response_s *resp;
DEBUGASSERT(dev != NULL);
resp = netlink_get_device(dev, NULL);
if (resp != NULL)
{
netlink_add_broadcast(RTNLGRP_LINK, resp);
netlink_add_terminator(NULL, NULL, RTNLGRP_LINK);
}
}
#endif
/****************************************************************************
* Name: netlink_device_notify_ipaddr()
*
* Description:
* Perform the route broadcast for the NETLINK_ROUTE protocol.
*
****************************************************************************/
#if !defined(CONFIG_NETLINK_DISABLE_NEWADDR) || \
!defined(CONFIG_NETLINK_DISABLE_DELADDR) || \
!defined(CONFIG_NETLINK_DISABLE_GETADDR)
void netlink_device_notify_ipaddr(FAR struct net_driver_s *dev,
int type, int domain,
FAR const void *addr, uint8_t preflen)
{
FAR struct netlink_response_s *resp;
int group;
DEBUGASSERT(dev != NULL);
resp = netlink_get_ifaddr(dev, domain, type, addr, preflen, NULL);
if (resp != NULL)
{
#ifdef CONFIG_NET_IPv4
if (domain == AF_INET)
{
group = RTNLGRP_IPV4_IFADDR;
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (domain == AF_INET6)
{
group = RTNLGRP_IPV6_IFADDR;
}
else
#endif
{
nwarn("netlink_device_notify_ipaddr unknown type %d domain %d\n",
type, domain);
return;
}
netlink_add_broadcast(group, resp);
netlink_add_terminator(NULL, NULL, group);
}
}
#endif
/****************************************************************************
* Name: netlink_route_notify
*
* Description:
* Perform the route broadcast for the NETLINK_NETFILTER protocol.
*
* Input Parameters:
* route - The route entry
* type - The type of the message, RTM_*ROUTE
* domain - The domain of the message
*
****************************************************************************/
#ifndef CONFIG_NETLINK_DISABLE_GETROUTE
void netlink_route_notify(FAR const void *route, int type, int domain)
{
FAR struct netlink_response_s *resp;
int group;
DEBUGASSERT(route != NULL);
#ifdef CONFIG_NET_IPv4
if (domain == AF_INET)
{
resp = netlink_get_ipv4_route((FAR struct net_route_ipv4_s *)route,
type, NULL);
group = RTNLGRP_IPV4_ROUTE;
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (domain == AF_INET6)
{
resp = netlink_get_ipv6_route((FAR struct net_route_ipv6_s *)route,
type, NULL);
group = RTNLGRP_IPV6_ROUTE;
}
else
#endif
{
nwarn("netlink_route_notify unknown type %d domain %d\n",
type, domain);
return;
}
if (resp != NULL)
{
netlink_add_broadcast(group, resp);
netlink_add_terminator(NULL, NULL, group);
}
}
#endif
/****************************************************************************
* Name: netlink_neigh_notify()
*
* Description:
* Perform the neigh broadcast for the NETLINK_ROUTE protocol.
*
****************************************************************************/
#ifndef CONFIG_NETLINK_DISABLE_GETNEIGH
void netlink_neigh_notify(FAR const void *neigh, int type, int domain)
{
FAR struct netlink_response_s *resp;
resp = netlink_get_neighbor(neigh, domain, type, NULL);
if (resp == NULL)
{
return;
}
netlink_add_broadcast(RTNLGRP_NEIGH, resp);
netlink_add_terminator(NULL, NULL, RTNLGRP_NEIGH);
}
#endif
/****************************************************************************
* Name: netlink_ipv6_prefix_notify()
*
* Description:
* Perform the RA prefix for the NETLINK_ROUTE protocol.
*
****************************************************************************/
#if !defined(CONFIG_NETLINK_DISABLE_NEWADDR) && defined(CONFIG_NET_IPv6)
void netlink_ipv6_prefix_notify(FAR struct net_driver_s *dev, int type,
FAR const struct icmpv6_prefixinfo_s *pinfo)
{
FAR struct netlink_response_s *resp;
resp = netlink_fill_ipv6prefix(dev, type, pinfo);
if (resp == NULL)
{
return;
}
netlink_add_broadcast(RTNLGRP_IPV6_PREFIX, resp);
netlink_add_terminator(NULL, NULL, RTNLGRP_IPV6_PREFIX);
}
#endif
#endif /* CONFIG_NETLINK_ROUTE */
Reference in New Issue View Git Blame Copy Permalink