Differential D36002 Diff 109873 sys/netlink/netlink_ctl.h

Changeset View

Standalone View

sys/netlink/netlink_ctl.h

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'?
				* Copyright (c) 2022 Alexander V. Chernikov
				*
				* 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_CTL_H_
				#define _NETLINK_NETLINK_CTL_H_

				/*
				* This file provides headers for the public KPI of the netlink
				* subsystem
				*/

				MALLOC_DECLARE(M_NETLINK);

				/*
				* Macro for handling attribute TLVs
				*/
				#define _roundup2(x, y) (((x)+((y)-1))&(~((y)-1)))

				#define NETLINK_ALIGN_SIZE sizeof(uint32_t)
				#define NETLINK_ALIGN(_len) _roundup2(_len, NETLINK_ALIGN_SIZE)

				#define NLA_ALIGN_SIZE sizeof(uint32_t)
				#define NLA_ALIGN(_len) _roundup2(_len, NLA_ALIGN_SIZE)
				#define NLA_HDRLEN ((int)sizeof(struct nlattr))
				#define NLA_DATA_LEN(_nla) ((int)((_nla)->nla_len - NLA_HDRLEN))
				#define NLA_DATA(_nla) NL_ITEM_DATA(_nla, NLA_HDRLEN)
				#define NLA_DATA_CONST(_nla) NL_ITEM_DATA_CONST(_nla, NLA_HDRLEN)

				#define NLA_TYPE(_nla) ((_nla)->nla_type & 0x3FFF)

				#define NLA_NEXT(_attr) (struct nlattr )((char )_attr + NLA_ALIGN(_attr->nla_len))

				#define _NLA_END(_start, _len) ((char *)(_start) + (_len))
				#define NLA_FOREACH(_attr, _start, _len) \
				for (_attr = (_start); \
				((char *)_attr < _NLA_END(_start, _len)) && \
				((char *)NLA_NEXT(_attr) <= _NLA_END(_start, _len)); \
				_attr = NLA_NEXT(_attr))

				/*
				(NLA_ALIGN(_attr->nla_len) >= NLA_HDRLEN) && \
				*/

				struct mbuf;
				struct nlmsg_state;
				typedef bool nlmsg_state_cb(struct nlmsg_state ns, void buf, int buflen, int cnt);

				struct nlmsg_state {
				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 */
				nlmsg_state_cb cb; / Callback to flush data */
				void arg; / Callback argument */
				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 */
				};
				#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_socket_writer(int size, struct nlpcb nlp, struct nlmsg_state ns);
				bool nlmsg_get_group_writer(int size, uint32_t group_mask, struct nlmsg_state *ns);
				bool nlmsg_get_chain_writer(int size, struct mbuf *pm, struct nlmsg_state ns);
				bool nlmsg_flush(struct nlmsg_state *ns);
				void nlmsg_ignore_limit(struct nlmsg_state *ns);

				bool nlmsg_refill_buffer(struct nlmsg_state *ns, int required_size);
				bool nlmsg_add(struct nlmsg_state *ns, uint32_t portid, uint32_t seq, uint16_t type,
				uint16_t flags, uint32_t len);
				void nlmsg_end(struct nlmsg_state *ns);
				void nlmsg_abort(struct nlmsg_state *ns);

				bool nlmsg_end_dump(struct nlmsg_state ns, int error, struct nlmsghdr hdr);

				static inline bool
				nlmsg_reply(struct nlmsg_state ns, const struct nlmsghdr hdr, int payload_len)
				{
				return (nlmsg_add(ns, 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 nlmsg_state *ns)
				{
				return (ns->offset - ((char *)ns->hdr - ns->data));
				}

				static inline void *
				_nlattr_restore_offset(const struct nlmsg_state *ns, int off)
				{
				return ((void )((char )ns->hdr + off));
				}
				#define nlattr_restore_offset(_ns, _off, _t) ((_t *)_nlattr_restore_offset(_ns, _off))

				static inline void *
				nlmsg_reserve_data_raw(struct nlmsg_state *ns, size_t sz)
				{
				if (__predict_false(ns->offset + NETLINK_ALIGN(sz) > ns->alloc_len)) {
				if (!nlmsg_refill_buffer(ns, NETLINK_ALIGN(sz)))
				return (NULL);
				}

				void *data_ptr = &ns->data[ns->offset];
				ns->offset += NLMSG_ALIGN(sz);

				return (data_ptr);
				}
				#define nlmsg_reserve_object(_ns, _t) ((_t *)nlmsg_reserve_data_raw(_ns, NLA_ALIGN(sizeof(_t))))
				#define nlmsg_reserve_data(_ns, _sz, _t) ((_t *)nlmsg_reserve_data_raw(_ns, _sz))

				static inline void *
				_nlmsg_reserve_attr(struct nlmsg_state *ns, uint16_t nla_type, uint16_t sz)
				{
				sz += sizeof(struct nlattr);

				struct nlattr *nla = nlmsg_reserve_data(ns, 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 nlmsg_state ns, int attr_type, int attr_len, const void data)
				{
				int required_len = NLA_ALIGN(attr_len + sizeof(struct nlattr));

				if (__predict_false(ns->offset + required_len > ns->alloc_len)) {
				if (!nlmsg_refill_buffer(ns, required_len))
				return (false);
				}

				struct nlattr nla = (struct nlattr )(&ns->data[ns->offset]);

				nla->nla_len = attr_len + sizeof(struct nlattr);
				nla->nla_type = attr_type;
				if (attr_len > 0)
				memcpy((nla + 1), data, attr_len);
				ns->offset += required_len;
				return (true);
				}

				static inline bool
				nlattr_add_u8(struct nlmsg_state *ns, int attrtype, uint8_t value)
				{
				return (nlattr_add(ns, attrtype, sizeof(uint8_t), &value));
				}

				static inline bool
				nlattr_add_u16(struct nlmsg_state *ns, int attrtype, uint16_t value)
				{
				return (nlattr_add(ns, attrtype, sizeof(uint16_t), &value));
				}

				static inline bool
				nlattr_add_u32(struct nlmsg_state *ns, int attrtype, uint32_t value)
				{
				return (nlattr_add(ns, attrtype, sizeof(uint32_t), &value));
				}

				static inline bool
				nlattr_add_u64(struct nlmsg_state *ns, int attrtype, uint64_t value)
				{
				return (nlattr_add(ns, attrtype, sizeof(uint64_t), &value));
				}

				static inline bool
				nlattr_add_s8(struct nlmsg_state *ns, int attrtype, int8_t value)
				{
				return (nlattr_add(ns, attrtype, sizeof(int8_t), &value));
				}

				static inline bool
				nlattr_add_s16(struct nlmsg_state *ns, int attrtype, int16_t value)
				{
				return (nlattr_add(ns, attrtype, sizeof(int16_t), &value));
				}

				static inline bool
				nlattr_add_s32(struct nlmsg_state *ns, int attrtype, int32_t value)
				{
				return (nlattr_add(ns, attrtype, sizeof(int32_t), &value));
				}

				static inline bool
				nlattr_add_s64(struct nlmsg_state *ns, int attrtype, int64_t value)
				{
				return (nlattr_add(ns, attrtype, sizeof(int64_t), &value));
				}

				static inline bool
				nlattr_add_flag(struct nlmsg_state *ns, int attrtype)
				{
				return (nlattr_add(ns, attrtype, 0, NULL));
				}

				static inline bool
				nlattr_add_string(struct nlmsg_state ns, int attrtype, const char str)
				{
				return (nlattr_add(ns, attrtype, strlen(str) + 1, str));
				}

				/* Attribute reading */

				/* netlink_attr_helpers.c */
				struct netlink_parse_tracker;

				typedef int parse_attr_f(struct nlattr attr, struct netlink_parse_tracker npt,
				void *target);
				struct nlattr_parser {
				uint16_t type; /* Attribute type */
				uint16_t off; /* field offset in the target structure */
				parse_attr_f cb; / parser function to call */
				};

				int nl_parse_attrs_raw(struct nlattr nla_head, int len, struct nlattr_parser ps,
				int pslen, struct netlink_parse_tracker npt, void target);
				int nl_parse_attrs(struct nlmsghdr hdr, int hdrlen, struct nlattr_parser ps,
				int pslen, struct netlink_parse_tracker npt, void target);

				int nlattr_get_flag(struct nlattr nla, struct netlink_parse_tracker npt,
				void *target);
				int nlattr_get_ip(struct nlattr nla, struct netlink_parse_tracker npt,
				void *target);
				int nlattr_get_uint32(struct nlattr nla, struct netlink_parse_tracker npt,
				void *target);
				int nlattr_get_ifindex(struct nlattr nla, struct netlink_parse_tracker npt,
				void *target);
				int nlattr_get_ipvia(struct nlattr nla, struct netlink_parse_tracker npt,
				void *target);
				int nlattr_get_string(struct nlattr nla, struct netlink_parse_tracker npt,
				void *target);
				int nlattr_get_nla(struct nlattr nla, struct netlink_parse_tracker npt,
				void *target);

				/* Parsing state */
				struct linear_buffer {
				char base; / Base allocated memory pointer */
				uint32_t offset; /* Currently used offset */
				uint32_t size; /* Total buffer size */
				};

				static inline void *
				lb_alloc(struct linear_buffer *lb, int len)
				{
				len = roundup2(len, sizeof(uint64_t));
				if (lb->offset + len > lb->size)
				return (NULL);
				void data = (void )(lb->base + lb->offset);
				lb->offset += len;
				return (data);
				}

				static inline void
				lb_clear(struct linear_buffer *lb)
				{
				memset(lb->base, 0, lb->size);
				lb->offset = 0;
				}

				#define SCRATCH_BUFFER_SIZE 1024
				struct netlink_parse_tracker {
				struct linear_buffer lb; /* Per-message scratch buffer */
				struct nlpcb nlp; / Originator */
				struct nlmsg_state ns; / Message writer to use */
				int error; /* last operation error */
				};

				static inline void *
				npt_alloc(struct netlink_parse_tracker *npt, int len)
				{
				return (lb_alloc(&npt->lb, len));
				}
				#define npt_alloc_sockaddr(_npt, _len) ((struct sockaddr *)(npt_alloc(_npt, _len)))



				/* Protocol handlers */
				typedef int (nl_handler_f)(struct nlmsghdr hdr, struct netlink_parse_tracker *npt);

				bool netlink_register_proto(int proto, const char *proto_name, nl_handler_f handler);
				bool netlink_unregister_proto(int proto);

				/* Generic */
				bool nl_has_listeners(int netlink_family, uint32_t groups_mask);
				bool nlp_has_priv(struct nlpcb *nlp, int priv);
				bool nlp_has_priv_route(struct nlpcb *nlp);

				/* Debug */
				uint32_t nlp_get_pid(const struct nlpcb *nlp);

				#endif