netlink: add netlink support
Netlinks is a communication protocol currently used in Linux kernel to modify,
read and subscribe for nearly all networking state. Interfaces, addresses, routes,
firewall, fibs, vnets, etc are controlled via netlink.
It is async, TLV-based protocol, providing 1-1 and 1-many communications.
The current implementation supports the subset of NETLINK_ROUTE
family. To be more specific, the following is supported:
* Dumps:
- routes
- nexthops / nexthop groups
- interfaces
- interface addresses
- neighbors (arp/ndp)
* Notifications:
- interface arrival/departure
- interface address arrival/departure
- route addition/deletion
* Modifications:
- adding/deleting routes
- adding/deleting nexthops/nexthops groups
- adding/deleting neghbors
- adding/deleting interfaces (basic support only)
* Rtsock interaction
- route events are bridged both ways
The implementation also supports the NETLINK_GENERIC family framework.
Implementation notes:
Netlink is implemented via loadable/unloadable kernel module,
not touching many kernel parts.
Each netlink socket uses dedicated taskqueue to support async operations
that can sleep, such as interface creation. All message processing is
performed within these taskqueues.
Compatibility:
Most of the Netlink data models specified above maps to FreeBSD concepts
nicely. Unmodified ip(8) binary correctly works with
interfaces, addresses, routes, nexthops and nexthop groups. Some
software such as net/bird require header-only modifications to compile
and work with FreeBSD netlink.
Reviewed by: imp
Differential Revision: https://reviews.freebsd.org/D36002
MFC after: 2 months
2022-01-20 21:39:21 +00:00
|
|
|
/*-
|
|
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
|
|
*
|
|
|
|
* Copyright (c) 2021 Ng Peng Nam Sean
|
|
|
|
* Copyright (c) 2022 Alexander V. Chernikov <melifaro@FreeBSD.org>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _NETLINK_NETLINK_MESSAGE_WRITER_H_
|
|
|
|
#define _NETLINK_NETLINK_MESSAGE_WRITER_H_
|
|
|
|
|
2022-10-01 17:01:53 +00:00
|
|
|
#ifdef _KERNEL
|
2023-03-15 12:31:45 +00:00
|
|
|
|
2023-03-27 11:53:34 +00:00
|
|
|
#include <netinet/in.h>
|
|
|
|
|
netlink: add netlink support
Netlinks is a communication protocol currently used in Linux kernel to modify,
read and subscribe for nearly all networking state. Interfaces, addresses, routes,
firewall, fibs, vnets, etc are controlled via netlink.
It is async, TLV-based protocol, providing 1-1 and 1-many communications.
The current implementation supports the subset of NETLINK_ROUTE
family. To be more specific, the following is supported:
* Dumps:
- routes
- nexthops / nexthop groups
- interfaces
- interface addresses
- neighbors (arp/ndp)
* Notifications:
- interface arrival/departure
- interface address arrival/departure
- route addition/deletion
* Modifications:
- adding/deleting routes
- adding/deleting nexthops/nexthops groups
- adding/deleting neghbors
- adding/deleting interfaces (basic support only)
* Rtsock interaction
- route events are bridged both ways
The implementation also supports the NETLINK_GENERIC family framework.
Implementation notes:
Netlink is implemented via loadable/unloadable kernel module,
not touching many kernel parts.
Each netlink socket uses dedicated taskqueue to support async operations
that can sleep, such as interface creation. All message processing is
performed within these taskqueues.
Compatibility:
Most of the Netlink data models specified above maps to FreeBSD concepts
nicely. Unmodified ip(8) binary correctly works with
interfaces, addresses, routes, nexthops and nexthop groups. Some
software such as net/bird require header-only modifications to compile
and work with FreeBSD netlink.
Reviewed by: imp
Differential Revision: https://reviews.freebsd.org/D36002
MFC after: 2 months
2022-01-20 21:39:21 +00:00
|
|
|
/*
|
|
|
|
* It is not meant to be included directly
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct mbuf;
|
|
|
|
struct nl_writer;
|
|
|
|
typedef bool nl_writer_cb(struct nl_writer *nw, void *buf, int buflen, int cnt);
|
|
|
|
|
|
|
|
struct nl_writer {
|
|
|
|
int alloc_len; /* allocated buffer length */
|
|
|
|
int offset; /* offset from the start of the buffer */
|
|
|
|
struct nlmsghdr *hdr; /* Pointer to the currently-filled msg */
|
|
|
|
char *data; /* pointer to the contiguous storage */
|
|
|
|
void *_storage; /* Underlying storage pointer */
|
|
|
|
nl_writer_cb *cb; /* Callback to flush data */
|
|
|
|
union {
|
|
|
|
void *arg_ptr; /* Callback argument as pointer */
|
|
|
|
uint64_t arg_uint; /* Callback argument as int */
|
|
|
|
};
|
|
|
|
int num_messages; /* Number of messages in the buffer */
|
|
|
|
int malloc_flag; /* M_WAITOK or M_NOWAIT */
|
|
|
|
uint8_t writer_type; /* NS_WRITER_TYPE_* */
|
|
|
|
uint8_t writer_target; /* NS_WRITER_TARGET_* */
|
|
|
|
bool ignore_limit; /* If true, ignores RCVBUF limit */
|
|
|
|
bool enomem; /* True if ENOMEM occured */
|
netlink: suppress sending NLMSG_ERROR if NLMSG_DONE is already sent
Netlink has a confirmation/error reporting mechanism for the sent
messages. Kernel explicitly acks each messages if requested (NLM_F_ACK)
or if message processing results in an error.
Similarly, for multipart messages - typically dumps, where each message
represents a single object like an interface or a route - another
message, NLMSG_DONE is used to indicate the end of dump and the
resulting status.
As a result, successfull dump ends with both NLMSG_DONE and NLMSG_ERROR
messages.
RFC 3549 does not say anything specific about such case.
Linux adopted an optimisation which suppresses NLMSG_ERROR message
when NLMSG_DONE is already sent. Certain libraries/applications like
libnl depends on such behavior.
Suppress sending NLMSG_ERROR if NLMSG_DONE is already sent, by
setting newly-added 'suppress_ack' flag in the writer and checking
this flag when generating ack.
This change restores libnl compatibility.
Before:
```
~ nl-link-list
Error: Unable to allocate link cache: Message sequence number mismatch
````
After:
```
~ nl-link-list
vtnet0 ether 52:54:00:14:e3:19 <broadcast,multicast,up,running>
lo0 ieee1394 <loopback,multicast,up,running>
```
Reviewed by: bapt,pauamma
Tested by: bapt
Differential Revision: https://reviews.freebsd.org/D37565
2022-11-30 12:15:23 +00:00
|
|
|
bool suppress_ack; /* If true, don't send NLMSG_ERR */
|
netlink: add netlink support
Netlinks is a communication protocol currently used in Linux kernel to modify,
read and subscribe for nearly all networking state. Interfaces, addresses, routes,
firewall, fibs, vnets, etc are controlled via netlink.
It is async, TLV-based protocol, providing 1-1 and 1-many communications.
The current implementation supports the subset of NETLINK_ROUTE
family. To be more specific, the following is supported:
* Dumps:
- routes
- nexthops / nexthop groups
- interfaces
- interface addresses
- neighbors (arp/ndp)
* Notifications:
- interface arrival/departure
- interface address arrival/departure
- route addition/deletion
* Modifications:
- adding/deleting routes
- adding/deleting nexthops/nexthops groups
- adding/deleting neghbors
- adding/deleting interfaces (basic support only)
* Rtsock interaction
- route events are bridged both ways
The implementation also supports the NETLINK_GENERIC family framework.
Implementation notes:
Netlink is implemented via loadable/unloadable kernel module,
not touching many kernel parts.
Each netlink socket uses dedicated taskqueue to support async operations
that can sleep, such as interface creation. All message processing is
performed within these taskqueues.
Compatibility:
Most of the Netlink data models specified above maps to FreeBSD concepts
nicely. Unmodified ip(8) binary correctly works with
interfaces, addresses, routes, nexthops and nexthop groups. Some
software such as net/bird require header-only modifications to compile
and work with FreeBSD netlink.
Reviewed by: imp
Differential Revision: https://reviews.freebsd.org/D36002
MFC after: 2 months
2022-01-20 21:39:21 +00:00
|
|
|
};
|
|
|
|
#define NS_WRITER_TARGET_SOCKET 0
|
|
|
|
#define NS_WRITER_TARGET_GROUP 1
|
|
|
|
#define NS_WRITER_TARGET_CHAIN 2
|
|
|
|
|
|
|
|
#define NS_WRITER_TYPE_MBUF 0
|
|
|
|
#define NS_WRITER_TYPE_BUF 1
|
|
|
|
#define NS_WRITER_TYPE_LBUF 2
|
|
|
|
#define NS_WRITER_TYPE_MBUFC 3
|
|
|
|
|
|
|
|
|
|
|
|
#define NLMSG_SMALL 128
|
|
|
|
#define NLMSG_LARGE 2048
|
|
|
|
|
|
|
|
/* Message and attribute writing */
|
|
|
|
|
|
|
|
struct nlpcb;
|
|
|
|
bool nlmsg_get_unicast_writer(struct nl_writer *nw, int expected_size, struct nlpcb *nlp);
|
|
|
|
bool nlmsg_get_group_writer(struct nl_writer *nw, int expected_size, int proto, int group_id);
|
|
|
|
bool nlmsg_get_chain_writer(struct nl_writer *nw, int expected_size, struct mbuf **pm);
|
|
|
|
bool nlmsg_flush(struct nl_writer *nw);
|
|
|
|
void nlmsg_ignore_limit(struct nl_writer *nw);
|
|
|
|
|
|
|
|
bool nlmsg_refill_buffer(struct nl_writer *nw, int required_size);
|
|
|
|
bool nlmsg_add(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
|
|
|
|
uint16_t flags, uint32_t len);
|
|
|
|
bool nlmsg_end(struct nl_writer *nw);
|
|
|
|
void nlmsg_abort(struct nl_writer *nw);
|
|
|
|
|
|
|
|
bool nlmsg_end_dump(struct nl_writer *nw, int error, struct nlmsghdr *hdr);
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlmsg_reply(struct nl_writer *nw, const struct nlmsghdr *hdr, int payload_len)
|
|
|
|
{
|
|
|
|
return (nlmsg_add(nw, hdr->nlmsg_pid, hdr->nlmsg_seq, hdr->nlmsg_type,
|
|
|
|
hdr->nlmsg_flags, payload_len));
|
|
|
|
}
|
|
|
|
|
|
|
|
#define nlmsg_data(_hdr) ((void *)((_hdr) + 1))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* KPI similar to mtodo():
|
|
|
|
* current (uncompleted) header is guaranteed to be contiguous,
|
|
|
|
* but can be reallocated, thus pointers may need to be readjusted.
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
nlattr_save_offset(const struct nl_writer *nw)
|
|
|
|
{
|
|
|
|
return (nw->offset - ((char *)nw->hdr - nw->data));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *
|
|
|
|
_nlattr_restore_offset(const struct nl_writer *nw, int off)
|
|
|
|
{
|
|
|
|
return ((void *)((char *)nw->hdr + off));
|
|
|
|
}
|
|
|
|
#define nlattr_restore_offset(_ns, _off, _t) ((_t *)_nlattr_restore_offset(_ns, _off))
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
nlattr_set_len(const struct nl_writer *nw, int off)
|
|
|
|
{
|
|
|
|
struct nlattr *nla = nlattr_restore_offset(nw, off, struct nlattr);
|
|
|
|
nla->nla_len = nlattr_save_offset(nw) - off;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *
|
|
|
|
nlmsg_reserve_data_raw(struct nl_writer *nw, size_t sz)
|
|
|
|
{
|
2023-03-07 17:42:27 +00:00
|
|
|
sz = NETLINK_ALIGN(sz);
|
|
|
|
|
|
|
|
if (__predict_false(nw->offset + sz > nw->alloc_len)) {
|
|
|
|
if (!nlmsg_refill_buffer(nw, sz))
|
netlink: add netlink support
Netlinks is a communication protocol currently used in Linux kernel to modify,
read and subscribe for nearly all networking state. Interfaces, addresses, routes,
firewall, fibs, vnets, etc are controlled via netlink.
It is async, TLV-based protocol, providing 1-1 and 1-many communications.
The current implementation supports the subset of NETLINK_ROUTE
family. To be more specific, the following is supported:
* Dumps:
- routes
- nexthops / nexthop groups
- interfaces
- interface addresses
- neighbors (arp/ndp)
* Notifications:
- interface arrival/departure
- interface address arrival/departure
- route addition/deletion
* Modifications:
- adding/deleting routes
- adding/deleting nexthops/nexthops groups
- adding/deleting neghbors
- adding/deleting interfaces (basic support only)
* Rtsock interaction
- route events are bridged both ways
The implementation also supports the NETLINK_GENERIC family framework.
Implementation notes:
Netlink is implemented via loadable/unloadable kernel module,
not touching many kernel parts.
Each netlink socket uses dedicated taskqueue to support async operations
that can sleep, such as interface creation. All message processing is
performed within these taskqueues.
Compatibility:
Most of the Netlink data models specified above maps to FreeBSD concepts
nicely. Unmodified ip(8) binary correctly works with
interfaces, addresses, routes, nexthops and nexthop groups. Some
software such as net/bird require header-only modifications to compile
and work with FreeBSD netlink.
Reviewed by: imp
Differential Revision: https://reviews.freebsd.org/D36002
MFC after: 2 months
2022-01-20 21:39:21 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *data_ptr = &nw->data[nw->offset];
|
2023-03-07 17:42:27 +00:00
|
|
|
nw->offset += sz;
|
netlink: add netlink support
Netlinks is a communication protocol currently used in Linux kernel to modify,
read and subscribe for nearly all networking state. Interfaces, addresses, routes,
firewall, fibs, vnets, etc are controlled via netlink.
It is async, TLV-based protocol, providing 1-1 and 1-many communications.
The current implementation supports the subset of NETLINK_ROUTE
family. To be more specific, the following is supported:
* Dumps:
- routes
- nexthops / nexthop groups
- interfaces
- interface addresses
- neighbors (arp/ndp)
* Notifications:
- interface arrival/departure
- interface address arrival/departure
- route addition/deletion
* Modifications:
- adding/deleting routes
- adding/deleting nexthops/nexthops groups
- adding/deleting neghbors
- adding/deleting interfaces (basic support only)
* Rtsock interaction
- route events are bridged both ways
The implementation also supports the NETLINK_GENERIC family framework.
Implementation notes:
Netlink is implemented via loadable/unloadable kernel module,
not touching many kernel parts.
Each netlink socket uses dedicated taskqueue to support async operations
that can sleep, such as interface creation. All message processing is
performed within these taskqueues.
Compatibility:
Most of the Netlink data models specified above maps to FreeBSD concepts
nicely. Unmodified ip(8) binary correctly works with
interfaces, addresses, routes, nexthops and nexthop groups. Some
software such as net/bird require header-only modifications to compile
and work with FreeBSD netlink.
Reviewed by: imp
Differential Revision: https://reviews.freebsd.org/D36002
MFC after: 2 months
2022-01-20 21:39:21 +00:00
|
|
|
|
|
|
|
return (data_ptr);
|
|
|
|
}
|
2023-03-07 17:42:27 +00:00
|
|
|
#define nlmsg_reserve_object(_ns, _t) ((_t *)nlmsg_reserve_data_raw(_ns, sizeof(_t)))
|
netlink: add netlink support
Netlinks is a communication protocol currently used in Linux kernel to modify,
read and subscribe for nearly all networking state. Interfaces, addresses, routes,
firewall, fibs, vnets, etc are controlled via netlink.
It is async, TLV-based protocol, providing 1-1 and 1-many communications.
The current implementation supports the subset of NETLINK_ROUTE
family. To be more specific, the following is supported:
* Dumps:
- routes
- nexthops / nexthop groups
- interfaces
- interface addresses
- neighbors (arp/ndp)
* Notifications:
- interface arrival/departure
- interface address arrival/departure
- route addition/deletion
* Modifications:
- adding/deleting routes
- adding/deleting nexthops/nexthops groups
- adding/deleting neghbors
- adding/deleting interfaces (basic support only)
* Rtsock interaction
- route events are bridged both ways
The implementation also supports the NETLINK_GENERIC family framework.
Implementation notes:
Netlink is implemented via loadable/unloadable kernel module,
not touching many kernel parts.
Each netlink socket uses dedicated taskqueue to support async operations
that can sleep, such as interface creation. All message processing is
performed within these taskqueues.
Compatibility:
Most of the Netlink data models specified above maps to FreeBSD concepts
nicely. Unmodified ip(8) binary correctly works with
interfaces, addresses, routes, nexthops and nexthop groups. Some
software such as net/bird require header-only modifications to compile
and work with FreeBSD netlink.
Reviewed by: imp
Differential Revision: https://reviews.freebsd.org/D36002
MFC after: 2 months
2022-01-20 21:39:21 +00:00
|
|
|
#define nlmsg_reserve_data(_ns, _sz, _t) ((_t *)nlmsg_reserve_data_raw(_ns, _sz))
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
nlattr_add_nested(struct nl_writer *nw, uint16_t nla_type)
|
|
|
|
{
|
|
|
|
int off = nlattr_save_offset(nw);
|
|
|
|
struct nlattr *nla = nlmsg_reserve_data(nw, sizeof(struct nlattr), struct nlattr);
|
|
|
|
if (__predict_false(nla == NULL))
|
|
|
|
return (0);
|
|
|
|
nla->nla_type = nla_type;
|
|
|
|
return (off);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *
|
|
|
|
_nlmsg_reserve_attr(struct nl_writer *nw, uint16_t nla_type, uint16_t sz)
|
|
|
|
{
|
|
|
|
sz += sizeof(struct nlattr);
|
|
|
|
|
|
|
|
struct nlattr *nla = nlmsg_reserve_data(nw, sz, struct nlattr);
|
|
|
|
if (__predict_false(nla == NULL))
|
|
|
|
return (NULL);
|
|
|
|
nla->nla_type = nla_type;
|
|
|
|
nla->nla_len = sz;
|
|
|
|
|
|
|
|
return ((void *)(nla + 1));
|
|
|
|
}
|
|
|
|
#define nlmsg_reserve_attr(_ns, _at, _t) ((_t *)_nlmsg_reserve_attr(_ns, _at, NLA_ALIGN(sizeof(_t))))
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add(struct nl_writer *nw, int attr_type, int attr_len, const void *data)
|
|
|
|
{
|
|
|
|
int required_len = NLA_ALIGN(attr_len + sizeof(struct nlattr));
|
|
|
|
|
|
|
|
if (__predict_false(nw->offset + required_len > nw->alloc_len)) {
|
|
|
|
if (!nlmsg_refill_buffer(nw, required_len))
|
|
|
|
return (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct nlattr *nla = (struct nlattr *)(&nw->data[nw->offset]);
|
|
|
|
|
|
|
|
nla->nla_len = attr_len + sizeof(struct nlattr);
|
|
|
|
nla->nla_type = attr_type;
|
|
|
|
if (attr_len > 0) {
|
|
|
|
if ((attr_len % 4) != 0) {
|
|
|
|
/* clear padding bytes */
|
|
|
|
bzero((char *)nla + required_len - 4, 4);
|
|
|
|
}
|
|
|
|
memcpy((nla + 1), data, attr_len);
|
|
|
|
}
|
|
|
|
nw->offset += required_len;
|
|
|
|
return (true);
|
|
|
|
}
|
|
|
|
|
2023-02-09 14:53:44 +00:00
|
|
|
static inline bool
|
|
|
|
nlattr_add_raw(struct nl_writer *nw, const struct nlattr *nla_src)
|
|
|
|
{
|
|
|
|
int attr_len = nla_src->nla_len - sizeof(struct nlattr);
|
|
|
|
|
|
|
|
MPASS(attr_len >= 0);
|
|
|
|
|
|
|
|
return (nlattr_add(nw, nla_src->nla_type, attr_len, (const void *)(nla_src + 1)));
|
|
|
|
}
|
|
|
|
|
netlink: add netlink support
Netlinks is a communication protocol currently used in Linux kernel to modify,
read and subscribe for nearly all networking state. Interfaces, addresses, routes,
firewall, fibs, vnets, etc are controlled via netlink.
It is async, TLV-based protocol, providing 1-1 and 1-many communications.
The current implementation supports the subset of NETLINK_ROUTE
family. To be more specific, the following is supported:
* Dumps:
- routes
- nexthops / nexthop groups
- interfaces
- interface addresses
- neighbors (arp/ndp)
* Notifications:
- interface arrival/departure
- interface address arrival/departure
- route addition/deletion
* Modifications:
- adding/deleting routes
- adding/deleting nexthops/nexthops groups
- adding/deleting neghbors
- adding/deleting interfaces (basic support only)
* Rtsock interaction
- route events are bridged both ways
The implementation also supports the NETLINK_GENERIC family framework.
Implementation notes:
Netlink is implemented via loadable/unloadable kernel module,
not touching many kernel parts.
Each netlink socket uses dedicated taskqueue to support async operations
that can sleep, such as interface creation. All message processing is
performed within these taskqueues.
Compatibility:
Most of the Netlink data models specified above maps to FreeBSD concepts
nicely. Unmodified ip(8) binary correctly works with
interfaces, addresses, routes, nexthops and nexthop groups. Some
software such as net/bird require header-only modifications to compile
and work with FreeBSD netlink.
Reviewed by: imp
Differential Revision: https://reviews.freebsd.org/D36002
MFC after: 2 months
2022-01-20 21:39:21 +00:00
|
|
|
static inline bool
|
|
|
|
nlattr_add_u8(struct nl_writer *nw, int attrtype, uint8_t value)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(uint8_t), &value));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add_u16(struct nl_writer *nw, int attrtype, uint16_t value)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(uint16_t), &value));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add_u32(struct nl_writer *nw, int attrtype, uint32_t value)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(uint32_t), &value));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add_u64(struct nl_writer *nw, int attrtype, uint64_t value)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(uint64_t), &value));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add_s8(struct nl_writer *nw, int attrtype, int8_t value)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(int8_t), &value));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add_s16(struct nl_writer *nw, int attrtype, int16_t value)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(int16_t), &value));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add_s32(struct nl_writer *nw, int attrtype, int32_t value)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(int32_t), &value));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add_s64(struct nl_writer *nw, int attrtype, int64_t value)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(int64_t), &value));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add_flag(struct nl_writer *nw, int attrtype)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, 0, NULL));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
nlattr_add_string(struct nl_writer *nw, int attrtype, const char *str)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, strlen(str) + 1, str));
|
|
|
|
}
|
|
|
|
|
2023-03-27 11:53:34 +00:00
|
|
|
static inline bool
|
|
|
|
nlattr_add_in_addr(struct nl_writer *nw, int attrtype, const struct in_addr *in)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(*in), in));
|
|
|
|
}
|
netlink: add netlink support
Netlinks is a communication protocol currently used in Linux kernel to modify,
read and subscribe for nearly all networking state. Interfaces, addresses, routes,
firewall, fibs, vnets, etc are controlled via netlink.
It is async, TLV-based protocol, providing 1-1 and 1-many communications.
The current implementation supports the subset of NETLINK_ROUTE
family. To be more specific, the following is supported:
* Dumps:
- routes
- nexthops / nexthop groups
- interfaces
- interface addresses
- neighbors (arp/ndp)
* Notifications:
- interface arrival/departure
- interface address arrival/departure
- route addition/deletion
* Modifications:
- adding/deleting routes
- adding/deleting nexthops/nexthops groups
- adding/deleting neghbors
- adding/deleting interfaces (basic support only)
* Rtsock interaction
- route events are bridged both ways
The implementation also supports the NETLINK_GENERIC family framework.
Implementation notes:
Netlink is implemented via loadable/unloadable kernel module,
not touching many kernel parts.
Each netlink socket uses dedicated taskqueue to support async operations
that can sleep, such as interface creation. All message processing is
performed within these taskqueues.
Compatibility:
Most of the Netlink data models specified above maps to FreeBSD concepts
nicely. Unmodified ip(8) binary correctly works with
interfaces, addresses, routes, nexthops and nexthop groups. Some
software such as net/bird require header-only modifications to compile
and work with FreeBSD netlink.
Reviewed by: imp
Differential Revision: https://reviews.freebsd.org/D36002
MFC after: 2 months
2022-01-20 21:39:21 +00:00
|
|
|
|
2023-03-27 11:53:34 +00:00
|
|
|
static inline bool
|
|
|
|
nlattr_add_in6_addr(struct nl_writer *nw, int attrtype, const struct in6_addr *in6)
|
|
|
|
{
|
|
|
|
return (nlattr_add(nw, attrtype, sizeof(*in6), in6));
|
|
|
|
}
|
netlink: add netlink support
Netlinks is a communication protocol currently used in Linux kernel to modify,
read and subscribe for nearly all networking state. Interfaces, addresses, routes,
firewall, fibs, vnets, etc are controlled via netlink.
It is async, TLV-based protocol, providing 1-1 and 1-many communications.
The current implementation supports the subset of NETLINK_ROUTE
family. To be more specific, the following is supported:
* Dumps:
- routes
- nexthops / nexthop groups
- interfaces
- interface addresses
- neighbors (arp/ndp)
* Notifications:
- interface arrival/departure
- interface address arrival/departure
- route addition/deletion
* Modifications:
- adding/deleting routes
- adding/deleting nexthops/nexthops groups
- adding/deleting neghbors
- adding/deleting interfaces (basic support only)
* Rtsock interaction
- route events are bridged both ways
The implementation also supports the NETLINK_GENERIC family framework.
Implementation notes:
Netlink is implemented via loadable/unloadable kernel module,
not touching many kernel parts.
Each netlink socket uses dedicated taskqueue to support async operations
that can sleep, such as interface creation. All message processing is
performed within these taskqueues.
Compatibility:
Most of the Netlink data models specified above maps to FreeBSD concepts
nicely. Unmodified ip(8) binary correctly works with
interfaces, addresses, routes, nexthops and nexthop groups. Some
software such as net/bird require header-only modifications to compile
and work with FreeBSD netlink.
Reviewed by: imp
Differential Revision: https://reviews.freebsd.org/D36002
MFC after: 2 months
2022-01-20 21:39:21 +00:00
|
|
|
#endif
|
2022-10-01 17:01:53 +00:00
|
|
|
#endif
|