master
1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2021 Ng Peng Nam Sean
5 * Copyright (c) 2022 Alexander V. Chernikov <melifaro@FreeBSD.org>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#ifndef _NETLINK_NETLINK_MESSAGE_WRITER_H_
30#define _NETLINK_NETLINK_MESSAGE_WRITER_H_
31
32#ifdef _KERNEL
33
34#include <netinet/in.h>
35
36/*
37 * It is not meant to be included directly
38 */
39
40struct mbuf;
41struct nl_writer;
42typedef bool nl_writer_cb(struct nl_writer *nw, void *buf, int buflen, int cnt);
43
44struct nl_writer {
45 int alloc_len; /* allocated buffer length */
46 int offset; /* offset from the start of the buffer */
47 struct nlmsghdr *hdr; /* Pointer to the currently-filled msg */
48 char *data; /* pointer to the contiguous storage */
49 void *_storage; /* Underlying storage pointer */
50 nl_writer_cb *cb; /* Callback to flush data */
51 union {
52 void *ptr;
53 struct {
54 uint16_t proto;
55 uint16_t id;
56 } group;
57 } arg;
58 int num_messages; /* Number of messages in the buffer */
59 int malloc_flag; /* M_WAITOK or M_NOWAIT */
60 uint8_t writer_type; /* NS_WRITER_TYPE_* */
61 uint8_t writer_target; /* NS_WRITER_TARGET_* */
62 bool ignore_limit; /* If true, ignores RCVBUF limit */
63 bool enomem; /* True if ENOMEM occured */
64 bool suppress_ack; /* If true, don't send NLMSG_ERR */
65};
66#define NS_WRITER_TARGET_SOCKET 0
67#define NS_WRITER_TARGET_GROUP 1
68#define NS_WRITER_TARGET_CHAIN 2
69
70#define NS_WRITER_TYPE_MBUF 0
71#define NS_WRITER_TYPE_BUF 1
72#define NS_WRITER_TYPE_LBUF 2
73#define NS_WRITER_TYPE_MBUFC 3
74#define NS_WRITER_TYPE_STUB 4
75
76
77#define NLMSG_SMALL 128
78#define NLMSG_LARGE 2048
79
80/* Message and attribute writing */
81
82struct nlpcb;
83
84#if defined(NETLINK) || defined(NETLINK_MODULE)
85/* Provide optimized calls to the functions inside the same linking unit */
86
87bool _nlmsg_get_unicast_writer(struct nl_writer *nw, int expected_size, struct nlpcb *nlp);
88bool _nlmsg_get_group_writer(struct nl_writer *nw, int expected_size, int proto, int group_id);
89bool _nlmsg_get_chain_writer(struct nl_writer *nw, int expected_size, struct mbuf **pm);
90bool _nlmsg_flush(struct nl_writer *nw);
91void _nlmsg_ignore_limit(struct nl_writer *nw);
92
93bool _nlmsg_refill_buffer(struct nl_writer *nw, int required_size);
94bool _nlmsg_add(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
95 uint16_t flags, uint32_t len);
96bool _nlmsg_end(struct nl_writer *nw);
97void _nlmsg_abort(struct nl_writer *nw);
98
99bool _nlmsg_end_dump(struct nl_writer *nw, int error, struct nlmsghdr *hdr);
100
101
102static inline bool
103nlmsg_get_unicast_writer(struct nl_writer *nw, int expected_size, struct nlpcb *nlp)
104{
105 return (_nlmsg_get_unicast_writer(nw, expected_size, nlp));
106}
107
108static inline bool
109nlmsg_get_group_writer(struct nl_writer *nw, int expected_size, int proto, int group_id)
110{
111 return (_nlmsg_get_group_writer(nw, expected_size, proto, group_id));
112}
113
114static inline bool
115nlmsg_get_chain_writer(struct nl_writer *nw, int expected_size, struct mbuf **pm)
116{
117 return (_nlmsg_get_chain_writer(nw, expected_size, pm));
118}
119
120static inline bool
121nlmsg_flush(struct nl_writer *nw)
122{
123 return (_nlmsg_flush(nw));
124}
125
126static inline void
127nlmsg_ignore_limit(struct nl_writer *nw)
128{
129 _nlmsg_ignore_limit(nw);
130}
131
132static inline bool
133nlmsg_refill_buffer(struct nl_writer *nw, int required_size)
134{
135 return (_nlmsg_refill_buffer(nw, required_size));
136}
137
138static inline bool
139nlmsg_add(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
140 uint16_t flags, uint32_t len)
141{
142 return (_nlmsg_add(nw, portid, seq, type, flags, len));
143}
144
145static inline bool
146nlmsg_end(struct nl_writer *nw)
147{
148 return (_nlmsg_end(nw));
149}
150
151static inline void
152nlmsg_abort(struct nl_writer *nw)
153{
154 return (_nlmsg_abort(nw));
155}
156
157static inline bool
158nlmsg_end_dump(struct nl_writer *nw, int error, struct nlmsghdr *hdr)
159{
160 return (_nlmsg_end_dump(nw, error, hdr));
161}
162
163#else
164/* Provide access to the functions via netlink_glue.c */
165
166bool nlmsg_get_unicast_writer(struct nl_writer *nw, int expected_size, struct nlpcb *nlp);
167bool nlmsg_get_group_writer(struct nl_writer *nw, int expected_size, int proto, int group_id);
168bool nlmsg_get_chain_writer(struct nl_writer *nw, int expected_size, struct mbuf **pm);
169bool nlmsg_flush(struct nl_writer *nw);
170void nlmsg_ignore_limit(struct nl_writer *nw);
171
172bool nlmsg_refill_buffer(struct nl_writer *nw, int required_size);
173bool nlmsg_add(struct nl_writer *nw, uint32_t portid, uint32_t seq, uint16_t type,
174 uint16_t flags, uint32_t len);
175bool nlmsg_end(struct nl_writer *nw);
176void nlmsg_abort(struct nl_writer *nw);
177
178bool nlmsg_end_dump(struct nl_writer *nw, int error, struct nlmsghdr *hdr);
179
180#endif /* defined(NETLINK) || defined(NETLINK_MODULE) */
181
182static inline bool
183nlmsg_reply(struct nl_writer *nw, const struct nlmsghdr *hdr, int payload_len)
184{
185 return (nlmsg_add(nw, hdr->nlmsg_pid, hdr->nlmsg_seq, hdr->nlmsg_type,
186 hdr->nlmsg_flags, payload_len));
187}
188
189#define nlmsg_data(_hdr) ((void *)((_hdr) + 1))
190
191/*
192 * KPI similar to mtodo():
193 * current (uncompleted) header is guaranteed to be contiguous,
194 * but can be reallocated, thus pointers may need to be readjusted.
195 */
196static inline int
197nlattr_save_offset(const struct nl_writer *nw)
198{
199 return (nw->offset - ((char *)nw->hdr - nw->data));
200}
201
202static inline void *
203_nlattr_restore_offset(const struct nl_writer *nw, int off)
204{
205 return ((void *)((char *)nw->hdr + off));
206}
207#define nlattr_restore_offset(_ns, _off, _t) ((_t *)_nlattr_restore_offset(_ns, _off))
208
209static inline void
210nlattr_set_len(const struct nl_writer *nw, int off)
211{
212 struct nlattr *nla = nlattr_restore_offset(nw, off, struct nlattr);
213 nla->nla_len = nlattr_save_offset(nw) - off;
214}
215
216static inline void *
217nlmsg_reserve_data_raw(struct nl_writer *nw, size_t sz)
218{
219 sz = NETLINK_ALIGN(sz);
220
221 if (__predict_false(nw->offset + sz > nw->alloc_len)) {
222 if (!nlmsg_refill_buffer(nw, sz))
223 return (NULL);
224 }
225
226 void *data_ptr = &nw->data[nw->offset];
227 nw->offset += sz;
228 bzero(data_ptr, sz);
229
230 return (data_ptr);
231}
232#define nlmsg_reserve_object(_ns, _t) ((_t *)nlmsg_reserve_data_raw(_ns, sizeof(_t)))
233#define nlmsg_reserve_data(_ns, _sz, _t) ((_t *)nlmsg_reserve_data_raw(_ns, _sz))
234
235static inline int
236nlattr_add_nested(struct nl_writer *nw, uint16_t nla_type)
237{
238 int off = nlattr_save_offset(nw);
239 struct nlattr *nla = nlmsg_reserve_data(nw, sizeof(struct nlattr), struct nlattr);
240 if (__predict_false(nla == NULL))
241 return (0);
242 nla->nla_type = nla_type;
243 return (off);
244}
245
246static inline void *
247_nlmsg_reserve_attr(struct nl_writer *nw, uint16_t nla_type, uint16_t sz)
248{
249 sz += sizeof(struct nlattr);
250
251 struct nlattr *nla = nlmsg_reserve_data(nw, sz, struct nlattr);
252 if (__predict_false(nla == NULL))
253 return (NULL);
254 nla->nla_type = nla_type;
255 nla->nla_len = sz;
256
257 return ((void *)(nla + 1));
258}
259#define nlmsg_reserve_attr(_ns, _at, _t) ((_t *)_nlmsg_reserve_attr(_ns, _at, NLA_ALIGN(sizeof(_t))))
260
261static inline bool
262nlattr_add(struct nl_writer *nw, int attr_type, int attr_len, const void *data)
263{
264 int required_len = NLA_ALIGN(attr_len + sizeof(struct nlattr));
265
266 if (__predict_false(nw->offset + required_len > nw->alloc_len)) {
267 if (!nlmsg_refill_buffer(nw, required_len))
268 return (false);
269 }
270
271 struct nlattr *nla = (struct nlattr *)(&nw->data[nw->offset]);
272
273 nla->nla_len = attr_len + sizeof(struct nlattr);
274 nla->nla_type = attr_type;
275 if (attr_len > 0) {
276 if ((attr_len % 4) != 0) {
277 /* clear padding bytes */
278 bzero((char *)nla + required_len - 4, 4);
279 }
280 memcpy((nla + 1), data, attr_len);
281 }
282 nw->offset += required_len;
283 return (true);
284}
285
286static inline bool
287nlattr_add_raw(struct nl_writer *nw, const struct nlattr *nla_src)
288{
289 int attr_len = nla_src->nla_len - sizeof(struct nlattr);
290
291 MPASS(attr_len >= 0);
292
293 return (nlattr_add(nw, nla_src->nla_type, attr_len, (const void *)(nla_src + 1)));
294}
295
296static inline bool
297nlattr_add_u8(struct nl_writer *nw, int attrtype, uint8_t value)
298{
299 return (nlattr_add(nw, attrtype, sizeof(uint8_t), &value));
300}
301
302static inline bool
303nlattr_add_u16(struct nl_writer *nw, int attrtype, uint16_t value)
304{
305 return (nlattr_add(nw, attrtype, sizeof(uint16_t), &value));
306}
307
308static inline bool
309nlattr_add_u32(struct nl_writer *nw, int attrtype, uint32_t value)
310{
311 return (nlattr_add(nw, attrtype, sizeof(uint32_t), &value));
312}
313
314static inline bool
315nlattr_add_u64(struct nl_writer *nw, int attrtype, uint64_t value)
316{
317 return (nlattr_add(nw, attrtype, sizeof(uint64_t), &value));
318}
319
320static inline bool
321nlattr_add_s8(struct nl_writer *nw, int attrtype, int8_t value)
322{
323 return (nlattr_add(nw, attrtype, sizeof(int8_t), &value));
324}
325
326static inline bool
327nlattr_add_s16(struct nl_writer *nw, int attrtype, int16_t value)
328{
329 return (nlattr_add(nw, attrtype, sizeof(int16_t), &value));
330}
331
332static inline bool
333nlattr_add_s32(struct nl_writer *nw, int attrtype, int32_t value)
334{
335 return (nlattr_add(nw, attrtype, sizeof(int32_t), &value));
336}
337
338static inline bool
339nlattr_add_s64(struct nl_writer *nw, int attrtype, int64_t value)
340{
341 return (nlattr_add(nw, attrtype, sizeof(int64_t), &value));
342}
343
344static inline bool
345nlattr_add_flag(struct nl_writer *nw, int attrtype)
346{
347 return (nlattr_add(nw, attrtype, 0, NULL));
348}
349
350static inline bool
351nlattr_add_string(struct nl_writer *nw, int attrtype, const char *str)
352{
353 return (nlattr_add(nw, attrtype, strlen(str) + 1, str));
354}
355
356static inline bool
357nlattr_add_in_addr(struct nl_writer *nw, int attrtype, const struct in_addr *in)
358{
359 return (nlattr_add(nw, attrtype, sizeof(*in), in));
360}
361
362static inline bool
363nlattr_add_in6_addr(struct nl_writer *nw, int attrtype, const struct in6_addr *in6)
364{
365 return (nlattr_add(nw, attrtype, sizeof(*in6), in6));
366}
367#endif
368#endif