1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2022 Alexander V. Chernikov <melifaro@FreeBSD.org>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28#ifndef _NETLINK_NETLINK_MESSAGE_PARSER_H_
29#define _NETLINK_NETLINK_MESSAGE_PARSER_H_
30
31#ifdef _KERNEL
32
33#include <sys/bitset.h>
34
35/*
36 * It is not meant to be included directly
37 */
38
39/* Parsing state */
40struct linear_buffer {
41 char *base; /* Base allocated memory pointer */
42 uint32_t offset; /* Currently used offset */
43 uint32_t size; /* Total buffer size */
44} __aligned(_Alignof(__max_align_t));
45
46static inline void *
47lb_alloc(struct linear_buffer *lb, int len)
48{
49 len = roundup2(len, _Alignof(__max_align_t));
50 if (lb->offset + len > lb->size)
51 return (NULL);
52 void *data = (void *)(lb->base + lb->offset);
53 lb->offset += len;
54 return (data);
55}
56
57static inline void
58lb_clear(struct linear_buffer *lb)
59{
60 memset(lb->base, 0, lb->size);
61 lb->offset = 0;
62}
63
64#define NL_MAX_ERROR_BUF 128
65#define SCRATCH_BUFFER_SIZE (1024 + NL_MAX_ERROR_BUF)
66struct nl_pstate {
67 struct linear_buffer lb; /* Per-message scratch buffer */
68 struct nlpcb *nlp; /* Originator socket */
69 struct nl_writer *nw; /* Message writer to use */
70 struct nlmsghdr *hdr; /* Current parsed message header */
71 uint32_t err_off; /* error offset from hdr start */
72 int error; /* last operation error */
73 char *err_msg; /* Description of last error */
74 struct nlattr *cookie; /* NLA to return to the userspace */
75 bool strict; /* Strict parsing required */
76};
77
78static inline void *
79npt_alloc(struct nl_pstate *npt, int len)
80{
81 return (lb_alloc(&npt->lb, len));
82}
83#define npt_alloc_sockaddr(_npt, _len) \
84 ((struct sockaddr *)(npt_alloc((_npt), (_len))))
85
86typedef int parse_field_f(void *hdr, struct nl_pstate *npt, void *target);
87struct nlfield_parser {
88 uint16_t off_in;
89 uint16_t off_out;
90 parse_field_f *cb;
91};
92static const struct nlfield_parser nlf_p_empty[] = {};
93
94int nlf_get_ifp(void *src, struct nl_pstate *npt, void *target);
95int nlf_get_ifpz(void *src, struct nl_pstate *npt, void *target);
96int nlf_get_u8(void *src, struct nl_pstate *npt, void *target);
97int nlf_get_u16(void *src, struct nl_pstate *npt, void *target);
98int nlf_get_u32(void *src, struct nl_pstate *npt, void *target);
99int nlf_get_u8_u32(void *src, struct nl_pstate *npt, void *target);
100
101struct nlattr_parser;
102typedef int parse_attr_f(struct nlattr *attr, struct nl_pstate *npt,
103 const void *arg, void *target);
104struct nlattr_parser {
105 uint16_t type; /* Attribute type */
106 uint16_t off; /* field offset in the target structure */
107 parse_attr_f *cb; /* parser function to call */
108 const void *arg;
109};
110
111typedef bool strict_parser_f(void *hdr, struct nl_pstate *npt);
112typedef bool post_parser_f(void *parsed_attrs, struct nl_pstate *npt);
113
114struct nlhdr_parser {
115 u_int nl_hdr_off; /* aligned netlink header size */
116 u_int out_hdr_off; /* target header size */
117 u_int fp_size;
118 u_int np_size;
119 const struct nlfield_parser *fp; /* array of header field parsers */
120 const struct nlattr_parser *np; /* array of attribute parsers */
121 strict_parser_f *sp; /* Pre-parse strict validation function */
122 post_parser_f *post_parse;
123};
124
125#define NL_DECLARE_PARSER_EXT(_name, _t, _sp, _fp, _np, _pp) \
126static const struct nlhdr_parser _name = { \
127 .nl_hdr_off = sizeof(_t), \
128 .fp = &((_fp)[0]), \
129 .np = &((_np)[0]), \
130 .fp_size = nitems(_fp), \
131 .np_size = nitems(_np), \
132 .sp = _sp, \
133 .post_parse = _pp, \
134}
135
136#define NL_DECLARE_PARSER(_name, _t, _fp, _np) \
137 NL_DECLARE_PARSER_EXT(_name, _t, NULL, _fp, _np, NULL)
138
139#define NL_DECLARE_STRICT_PARSER(_name, _t, _sp, _fp, _np) \
140 NL_DECLARE_PARSER_EXT(_name, _t, _sp, _fp, _np, NULL)
141
142#define NL_DECLARE_ARR_PARSER(_name, _t, _o, _fp, _np) \
143static const struct nlhdr_parser _name = { \
144 .nl_hdr_off = sizeof(_t), \
145 .out_hdr_off = sizeof(_o), \
146 .fp = &((_fp)[0]), \
147 .np = &((_np)[0]), \
148 .fp_size = nitems(_fp), \
149 .np_size = nitems(_np), \
150}
151
152#define NL_DECLARE_ATTR_PARSER_EXT(_name, _np, _pp) \
153static const struct nlhdr_parser _name = { \
154 .np = &((_np)[0]), \
155 .np_size = nitems(_np), \
156 .post_parse = (_pp) \
157}
158
159#define NL_DECLARE_ATTR_PARSER(_name, _np) \
160 NL_DECLARE_ATTR_PARSER_EXT(_name, _np, NULL)
161
162#define NL_ATTR_BMASK_SIZE 128
163BITSET_DEFINE(nlattr_bmask, NL_ATTR_BMASK_SIZE);
164
165void nl_get_attrs_bmask_raw(struct nlattr *nla_head, uint32_t len,
166 struct nlattr_bmask *bm);
167bool nl_has_attr(const struct nlattr_bmask *bm, uint16_t nla_type);
168
169int nl_parse_attrs_raw(struct nlattr *nla_head, uint16_t len,
170 const struct nlattr_parser *ps, u_int pslen, struct nl_pstate *npt,
171 void *target);
172
173int nlattr_get_flag(struct nlattr *nla, struct nl_pstate *npt,
174 const void *arg, void *target);
175int nlattr_get_ip(struct nlattr *nla, struct nl_pstate *npt,
176 const void *arg, void *target);
177int nlattr_get_bool(struct nlattr *nla, struct nl_pstate *npt,
178 const void *arg, void *target);
179int nlattr_get_uint8(struct nlattr *nla, struct nl_pstate *npt,
180 const void *arg, void *target);
181int nlattr_get_uint16(struct nlattr *nla, struct nl_pstate *npt,
182 const void *arg, void *target);
183int nlattr_get_uint32(struct nlattr *nla, struct nl_pstate *npt,
184 const void *arg, void *target);
185int nlattr_get_uint64(struct nlattr *nla, struct nl_pstate *npt,
186 const void *arg, void *target);
187int nlattr_get_in_addr(struct nlattr *nla, struct nl_pstate *npt,
188 const void *arg, void *target);
189int nlattr_get_in6_addr(struct nlattr *nla, struct nl_pstate *npt,
190 const void *arg, void *target);
191int nlattr_get_ifp(struct nlattr *nla, struct nl_pstate *npt,
192 const void *arg, void *target);
193int nlattr_get_ifpz(struct nlattr *nla, struct nl_pstate *npt,
194 const void *arg, void *target);
195int nlattr_get_ipvia(struct nlattr *nla, struct nl_pstate *npt,
196 const void *arg, void *target);
197int nlattr_get_chara(struct nlattr *nla, struct nl_pstate *npt,
198 const void *arg, void *target);
199int nlattr_get_string(struct nlattr *nla, struct nl_pstate *npt,
200 const void *arg, void *target);
201int nlattr_get_stringn(struct nlattr *nla, struct nl_pstate *npt,
202 const void *arg, void *target);
203int nlattr_get_bytes(struct nlattr *nla, struct nl_pstate *npt,
204 const void *arg, void *target);
205int nlattr_get_nla(struct nlattr *nla, struct nl_pstate *npt,
206 const void *arg, void *target);
207int nlattr_get_nested(struct nlattr *nla, struct nl_pstate *npt,
208 const void *arg, void *target);
209int nlattr_get_nested_ptr(struct nlattr *nla, struct nl_pstate *npt,
210 const void *arg, void *target);
211
212bool nlmsg_report_err_msg(struct nl_pstate *npt, const char *fmt, ...)
213 __printflike(2, 3);
214
215#define NLMSG_REPORT_ERR_MSG(_npt, _fmt, ...) { \
216 nlmsg_report_err_msg(_npt, _fmt, ## __VA_ARGS__); \
217 NLP_LOG(LOG_DEBUG, (_npt)->nlp, _fmt, ## __VA_ARGS__); \
218}
219
220bool nlmsg_report_err_offset(struct nl_pstate *npt, uint32_t off);
221
222void nlmsg_report_cookie(struct nl_pstate *npt, struct nlattr *nla);
223void nlmsg_report_cookie_u32(struct nl_pstate *npt, uint32_t val);
224
225/*
226 * Have it inline so compiler can optimize field accesses into
227 * the list of direct function calls without iteration.
228 */
229static inline int
230nl_parse_header(void *hdr, uint32_t len, const struct nlhdr_parser *parser,
231 struct nl_pstate *npt, void *target)
232{
233 int error;
234
235 if (__predict_false(len < parser->nl_hdr_off)) {
236 void *tmp_hdr;
237
238 if (npt->strict) {
239 nlmsg_report_err_msg(npt,
240 "header too short: expected %d, got %d",
241 parser->nl_hdr_off, len);
242 return (EINVAL);
243 }
244
245 /*
246 * Compatibility with older applications:
247 * pretend there's a full header.
248 */
249 tmp_hdr = npt_alloc(npt, parser->nl_hdr_off);
250 if (tmp_hdr == NULL)
251 return (EINVAL);
252 memcpy(tmp_hdr, hdr, len);
253 hdr = tmp_hdr;
254 len = parser->nl_hdr_off;
255 }
256
257 if (npt->strict && parser->sp != NULL && !parser->sp(hdr, npt))
258 return (EINVAL);
259
260 /* Extract fields first */
261 for (u_int i = 0; i < parser->fp_size; i++) {
262 const struct nlfield_parser *fp = &parser->fp[i];
263 void *src = (char *)hdr + fp->off_in;
264 void *dst = (char *)target + fp->off_out;
265
266 error = fp->cb(src, npt, dst);
267 if (error != 0)
268 return (error);
269 }
270
271 error = nl_parse_attrs_raw(
272 (struct nlattr *)((char *)hdr + parser->nl_hdr_off),
273 len - parser->nl_hdr_off, parser->np, parser->np_size, npt, target);
274
275 if (parser->post_parse != NULL && error == 0) {
276 if (!parser->post_parse(target, npt))
277 return (EINVAL);
278 }
279
280 return (error);
281}
282
283static inline int
284nl_parse_nested(struct nlattr *nla, const struct nlhdr_parser *parser,
285 struct nl_pstate *npt, void *target)
286{
287 return (nl_parse_attrs_raw((struct nlattr *)NLA_DATA(nla),
288 NLA_DATA_LEN(nla), parser->np, parser->np_size, npt, target));
289}
290
291/*
292 * Checks that attributes are sorted by attribute type.
293 */
294static inline void
295nl_verify_parsers(const struct nlhdr_parser **parser, int count)
296{
297#ifdef INVARIANTS
298 for (int i = 0; i < count; i++) {
299 const struct nlhdr_parser *p = parser[i];
300 int attr_type = 0;
301 for (int j = 0; j < p->np_size; j++) {
302 MPASS(p->np[j].type > attr_type);
303 attr_type = p->np[j].type;
304
305 /* Recurse into nested objects. */
306 if (p->np[j].cb == nlattr_get_nested ||
307 p->np[j].cb == nlattr_get_nested_ptr) {
308 const struct nlhdr_parser *np =
309 (const struct nlhdr_parser *)p->np[j].arg;
310 nl_verify_parsers(&np, 1);
311 }
312 }
313 }
314#endif
315}
316void nl_verify_parsers(const struct nlhdr_parser **parser, int count);
317#define NL_VERIFY_PARSERS(_p) nl_verify_parsers((_p), nitems(_p))
318
319static inline int
320nl_parse_nlmsg(struct nlmsghdr *hdr, const struct nlhdr_parser *parser,
321 struct nl_pstate *npt, void *target)
322{
323 return (nl_parse_header(hdr + 1, hdr->nlmsg_len - sizeof(*hdr), parser,
324 npt, target));
325}
326
327static inline void
328nl_get_attrs_bmask_nlmsg(struct nlmsghdr *hdr,
329 const struct nlhdr_parser *parser, struct nlattr_bmask *bm)
330{
331 nl_get_attrs_bmask_raw(
332 (struct nlattr *)((char *)(hdr + 1) + parser->nl_hdr_off),
333 hdr->nlmsg_len - sizeof(*hdr) - parser->nl_hdr_off, bm);
334}
335
336#endif
337#endif