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 #include <sys/types.h>
29 #include <sys/ck.h>
30 #include <sys/epoch.h>
31 #include <sys/eventhandler.h>
32 #include <sys/kernel.h>
33 #include <sys/jail.h>
34 #include <sys/lock.h>
35 #include <sys/malloc.h>
36 #include <sys/priv.h>
37 #include <sys/proc.h>
38 #include <sys/socket.h>
39 #include <sys/sx.h>
40
41 #include <netlink/netlink.h>
42 #include <netlink/netlink_ctl.h>
43 #include <netlink/netlink_generic.h>
44 #include <netlink/netlink_var.h>
45
46 #define DEBUG_MOD_NAME nl_generic
47 #define DEBUG_MAX_LEVEL LOG_DEBUG3
48 #include <netlink/netlink_debug.h>
49 _DECLARE_DEBUG(LOG_INFO);
50
51 static int nlctrl_handle_getfamily(struct nlmsghdr *, struct nl_pstate *);
52
53 static struct genl_cmd nlctrl_cmds[] = {
54 [CTRL_CMD_GETFAMILY] = {
55 .cmd_num = CTRL_CMD_GETFAMILY,
56 .cmd_name = "GETFAMILY",
57 .cmd_cb = nlctrl_handle_getfamily,
58 .cmd_flags = GENL_CMD_CAP_DO | GENL_CMD_CAP_DUMP |
59 GENL_CMD_CAP_HASPOL,
60 },
61 };
62
63 static struct genl_family {
64 const char *family_name;
65 uint16_t family_hdrsize;
66 uint16_t family_version;
67 uint16_t family_attr_max;
68 uint16_t family_cmd_size;
69 uint16_t family_num_groups;
70 struct genl_cmd *family_cmds;
71 } families[MAX_FAMILIES] = {
72 [CTRL_FAMILY_ID] = {
73 .family_name = CTRL_FAMILY_NAME,
74 .family_hdrsize = 0,
75 .family_version = 2,
76 .family_attr_max = CTRL_ATTR_MAX,
77 .family_cmd_size = CTRL_CMD_GETFAMILY + 1,
78 .family_cmds = nlctrl_cmds,
79 .family_num_groups = 1,
80 },
81 };
82
83 static struct genl_group {
84 struct genl_family *group_family;
85 const char *group_name;
86 } groups[MAX_GROUPS] = {
87 [CTRL_GROUP_ID] = {
88 .group_family = &families[CTRL_FAMILY_ID],
89 .group_name = CTRL_GROUP_NAME,
90 },
91 };
92
93 static inline struct genl_family *
genl_family(uint16_t family_id)94 genl_family(uint16_t family_id)
95 {
96 KASSERT(family_id - GENL_MIN_ID < MAX_FAMILIES &&
97 families[family_id - GENL_MIN_ID].family_name != NULL,
98 ("family %u does not exist", family_id));
99 return (&families[family_id - GENL_MIN_ID]);
100 }
101
102 static inline uint16_t
genl_family_id(const struct genl_family * gf)103 genl_family_id(const struct genl_family *gf)
104 {
105 MPASS(gf >= &families[0] && gf < &families[MAX_FAMILIES]);
106 return ((uint16_t)(gf - &families[0]) + GENL_MIN_ID);
107 }
108
109 /*
110 * Handler called by netlink subsystem when matching netlink message is received
111 */
112 static int
genl_handle_message(struct nlmsghdr * hdr,struct nl_pstate * npt)113 genl_handle_message(struct nlmsghdr *hdr, struct nl_pstate *npt)
114 {
115 struct nlpcb *nlp = npt->nlp;
116 struct genl_family *gf;
117 uint16_t family_id;
118 int error = 0;
119
120 if (__predict_false(hdr->nlmsg_len < sizeof(struct nlmsghdr) +
121 GENL_HDRLEN)) {
122 NLP_LOG(LOG_DEBUG, nlp, "invalid message size: %d",
123 hdr->nlmsg_len);
124 return (EINVAL);
125 }
126
127 family_id = hdr->nlmsg_type - GENL_MIN_ID;
128 if (__predict_false(family_id >= MAX_FAMILIES ||
129 families[family_id].family_name == NULL)) {
130 NLP_LOG(LOG_DEBUG, nlp, "invalid message type: %d",
131 hdr->nlmsg_type);
132 return (ENOTSUP);
133 }
134 gf = &families[family_id];
135
136 struct genlmsghdr *ghdr = (struct genlmsghdr *)(hdr + 1);
137
138 if (ghdr->cmd >= gf->family_cmd_size || gf->family_cmds[ghdr->cmd].cmd_cb == NULL) {
139 NLP_LOG(LOG_DEBUG, nlp, "family %s: invalid cmd %d",
140 gf->family_name, ghdr->cmd);
141 return (ENOTSUP);
142 }
143
144 struct genl_cmd *cmd = &gf->family_cmds[ghdr->cmd];
145
146 if (cmd->cmd_priv != 0 && !nlp_has_priv(nlp, cmd->cmd_priv)) {
147 NLP_LOG(LOG_DEBUG, nlp, "family %s: cmd %d priv_check() failed",
148 gf->family_name, ghdr->cmd);
149 return (EPERM);
150 }
151
152 if (cmd->cmd_securelevel > 0 &&
153 securelevel_ge(nlp_get_cred(nlp), cmd->cmd_securelevel)) {
154 NLP_LOG(LOG_DEBUG, nlp, "family %s: cmd %d securelevel_gt() failed",
155 gf->family_name, ghdr->cmd);
156 return (EPERM);
157 }
158
159 NLP_LOG(LOG_DEBUG2, nlp, "received family %s cmd %s(%d) len %d",
160 gf->family_name, cmd->cmd_name, ghdr->cmd, hdr->nlmsg_len);
161
162 error = cmd->cmd_cb(hdr, npt);
163
164 return (error);
165 }
166
167 static uint32_t
get_cmd_flags(const struct genl_cmd * cmd)168 get_cmd_flags(const struct genl_cmd *cmd)
169 {
170 uint32_t flags = cmd->cmd_flags;
171 if (cmd->cmd_priv != 0)
172 flags |= GENL_ADMIN_PERM;
173 return (flags);
174 }
175
176 static int
dump_family(struct nlmsghdr * hdr,struct genlmsghdr * ghdr,const struct genl_family * gf,struct nl_writer * nw)177 dump_family(struct nlmsghdr *hdr, struct genlmsghdr *ghdr,
178 const struct genl_family *gf, struct nl_writer *nw)
179 {
180 if (!nlmsg_reply(nw, hdr, sizeof(struct genlmsghdr)))
181 goto enomem;
182
183 struct genlmsghdr *ghdr_new = nlmsg_reserve_object(nw, struct genlmsghdr);
184 ghdr_new->cmd = ghdr->cmd;
185 ghdr_new->version = gf->family_version;
186 ghdr_new->reserved = 0;
187
188 nlattr_add_string(nw, CTRL_ATTR_FAMILY_NAME, gf->family_name);
189 nlattr_add_u16(nw, CTRL_ATTR_FAMILY_ID, genl_family_id(gf));
190 nlattr_add_u32(nw, CTRL_ATTR_VERSION, gf->family_version);
191 nlattr_add_u32(nw, CTRL_ATTR_HDRSIZE, gf->family_hdrsize);
192 nlattr_add_u32(nw, CTRL_ATTR_MAXATTR, gf->family_attr_max);
193
194 if (gf->family_cmd_size > 0) {
195 int off = nlattr_add_nested(nw, CTRL_ATTR_OPS);
196 if (off == 0)
197 goto enomem;
198 for (int i = 0, cnt=0; i < gf->family_cmd_size; i++) {
199 struct genl_cmd *cmd = &gf->family_cmds[i];
200 if (cmd->cmd_cb == NULL)
201 continue;
202 int cmd_off = nlattr_add_nested(nw, ++cnt);
203 if (cmd_off == 0)
204 goto enomem;
205
206 nlattr_add_u32(nw, CTRL_ATTR_OP_ID, cmd->cmd_num);
207 nlattr_add_u32(nw, CTRL_ATTR_OP_FLAGS, get_cmd_flags(cmd));
208 nlattr_set_len(nw, cmd_off);
209 }
210 nlattr_set_len(nw, off);
211 }
212 if (gf->family_num_groups > 0) {
213 int off = nlattr_add_nested(nw, CTRL_ATTR_MCAST_GROUPS);
214 if (off == 0)
215 goto enomem;
216 for (u_int i = 0, cnt = 0; i < MAX_GROUPS; i++) {
217 struct genl_group *gg = &groups[i];
218
219 if (gg->group_family != gf)
220 continue;
221
222 int cmd_off = nlattr_add_nested(nw, ++cnt);
223 if (cmd_off == 0)
224 goto enomem;
225 nlattr_add_u32(nw, CTRL_ATTR_MCAST_GRP_ID, i + MIN_GROUP_NUM);
226 nlattr_add_string(nw, CTRL_ATTR_MCAST_GRP_NAME, gg->group_name);
227 nlattr_set_len(nw, cmd_off);
228 }
229 nlattr_set_len(nw, off);
230 }
231 if (nlmsg_end(nw))
232 return (0);
233 enomem:
234 NL_LOG(LOG_DEBUG, "unable to dump family %s state (ENOMEM)", gf->family_name);
235 nlmsg_abort(nw);
236 return (ENOMEM);
237 }
238
239 struct nl_parsed_family {
240 char *family_name;
241 uint16_t family_id;
242 uint8_t version;
243 };
244
245 #define _IN(_field) offsetof(struct genlmsghdr, _field)
246 #define _OUT(_field) offsetof(struct nl_parsed_family, _field)
247 static const struct nlfield_parser nlf_p_generic[] = {
248 { .off_in = _IN(version), .off_out = _OUT(version), .cb = nlf_get_u8 },
249 };
250
251 static struct nlattr_parser nla_p_generic[] = {
252 { .type = CTRL_ATTR_FAMILY_ID , .off = _OUT(family_id), .cb = nlattr_get_uint16 },
253 { .type = CTRL_ATTR_FAMILY_NAME , .off = _OUT(family_name), .cb = nlattr_get_string },
254 };
255 #undef _IN
256 #undef _OUT
257 NL_DECLARE_PARSER(genl_parser, struct genlmsghdr, nlf_p_generic, nla_p_generic);
258
259 static int
nlctrl_handle_getfamily(struct nlmsghdr * hdr,struct nl_pstate * npt)260 nlctrl_handle_getfamily(struct nlmsghdr *hdr, struct nl_pstate *npt)
261 {
262 int error = 0;
263
264 struct nl_parsed_family attrs = {};
265 error = nl_parse_nlmsg(hdr, &genl_parser, npt, &attrs);
266 if (error != 0)
267 return (error);
268
269 struct genlmsghdr ghdr = {
270 .cmd = CTRL_CMD_NEWFAMILY,
271 };
272
273 if (attrs.family_id != 0 || attrs.family_name != NULL) {
274 for (u_int i = 0; i < MAX_FAMILIES; i++) {
275 struct genl_family *gf = &families[i];
276
277 if (gf->family_name == NULL)
278 continue;
279 if (attrs.family_id != 0 &&
280 attrs.family_id != genl_family_id(gf))
281 continue;
282 if (attrs.family_name != NULL &&
283 strcmp(attrs.family_name, gf->family_name) != 0)
284 continue;
285 return (dump_family(hdr, &ghdr, gf, npt->nw));
286 }
287 return (ENOENT);
288 }
289
290 hdr->nlmsg_flags = hdr->nlmsg_flags | NLM_F_MULTI;
291 for (u_int i = 0; i < MAX_FAMILIES; i++) {
292 struct genl_family *gf = &families[i];
293
294 if (gf->family_name != NULL) {
295 error = dump_family(hdr, &ghdr, gf, npt->nw);
296 if (error != 0)
297 break;
298 }
299 }
300
301 if (!nlmsg_end_dump(npt->nw, error, hdr)) {
302 NL_LOG(LOG_DEBUG, "Unable to finalize the dump");
303 return (ENOMEM);
304 }
305
306 return (error);
307 }
308
309 static void
nlctrl_notify(void * arg __unused,const char * family_name __unused,uint16_t family_id,u_int cmd)310 nlctrl_notify(void *arg __unused, const char *family_name __unused,
311 uint16_t family_id, u_int cmd)
312 {
313 struct nlmsghdr hdr = {.nlmsg_type = NETLINK_GENERIC };
314 struct genlmsghdr ghdr = { .cmd = cmd };
315 struct genl_family *gf;
316 struct nl_writer nw;
317
318 gf = genl_family(family_id);
319 if (!nl_writer_group(&nw, NLMSG_SMALL, NETLINK_GENERIC, CTRL_GROUP_ID,
320 0, false)) {
321 NL_LOG(LOG_DEBUG, "error allocating group writer");
322 return;
323 }
324
325 dump_family(&hdr, &ghdr, gf, &nw);
326 nlmsg_flush(&nw);
327 }
328
329 static const struct nlhdr_parser *all_parsers[] = { &genl_parser };
330 static eventhandler_tag family_event_tag;
331
332 static void
genl_load_all(void * u __unused)333 genl_load_all(void *u __unused)
334 {
335 NL_VERIFY_PARSERS(all_parsers);
336 family_event_tag = EVENTHANDLER_REGISTER(genl_family_event,
337 nlctrl_notify, NULL, EVENTHANDLER_PRI_ANY);
338 netlink_register_proto(NETLINK_GENERIC, "NETLINK_GENERIC",
339 genl_handle_message);
340 }
341 SYSINIT(genl_load_all, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, genl_load_all, NULL);
342
343 static void
genl_unload(void * u __unused)344 genl_unload(void *u __unused)
345 {
346 netlink_unregister_proto(NETLINK_GENERIC);
347 EVENTHANDLER_DEREGISTER(genl_family_event, family_event_tag);
348 NET_EPOCH_WAIT();
349 }
350 SYSUNINIT(genl_unload, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, genl_unload, NULL);
351
352 /*
353 * Public KPI for NETLINK_GENERIC families/groups registration logic below.
354 */
355
356 static struct sx sx_lock;
357 SX_SYSINIT(genl_lock, &sx_lock, "genetlink lock");
358 #define GENL_LOCK() sx_xlock(&sx_lock)
359 #define GENL_UNLOCK() sx_xunlock(&sx_lock)
360 #define GENL_ASSERT_LOCKED() sx_assert(&sx_lock, SA_LOCKED)
361 #define GENL_ASSERT_XLOCKED() sx_assert(&sx_lock, SA_XLOCKED)
362
363 uint16_t
genl_register_family(const char * family_name,size_t hdrsize,uint16_t family_version,uint16_t max_attr_idx)364 genl_register_family(const char *family_name, size_t hdrsize,
365 uint16_t family_version, uint16_t max_attr_idx)
366 {
367 struct genl_family *gf;
368 uint16_t family_id;
369
370 MPASS(family_name != NULL);
371
372 GENL_LOCK();
373 for (u_int i = 0; i < MAX_FAMILIES; i++)
374 if (families[i].family_name != NULL &&
375 strcmp(families[i].family_name, family_name) == 0) {
376 GENL_UNLOCK();
377 return (0);
378 }
379
380 /* Microoptimization: index 0 is reserved for the control family. */
381 gf = NULL;
382 for (u_int i = 1; i < MAX_FAMILIES; i++)
383 if (families[i].family_name == NULL) {
384 gf = &families[i];
385 break;
386 }
387 KASSERT(gf, ("%s: maximum of %u generic netlink families allocated",
388 __func__, MAX_FAMILIES));
389
390 *gf = (struct genl_family) {
391 .family_name = family_name,
392 .family_version = family_version,
393 .family_hdrsize = hdrsize,
394 .family_attr_max = max_attr_idx,
395 };
396 family_id = genl_family_id(gf);
397 GENL_UNLOCK();
398
399 NL_LOG(LOG_DEBUG2, "Registered family %s id %d", gf->family_name,
400 family_id);
401 EVENTHANDLER_INVOKE(genl_family_event, gf->family_name, family_id,
402 CTRL_CMD_NEWFAMILY);
403
404 return (family_id);
405 }
406
407 void
genl_unregister_family(uint16_t family_id)408 genl_unregister_family(uint16_t family_id)
409 {
410 struct genl_family *gf;
411
412 GENL_LOCK();
413 gf = genl_family(family_id);
414
415 EVENTHANDLER_INVOKE(genl_family_event, gf->family_name,
416 family_id, CTRL_CMD_DELFAMILY);
417 for (u_int i = 0; i < MAX_GROUPS; i++) {
418 struct genl_group *gg = &groups[i];
419 if (gg->group_family == gf && gg->group_name != NULL) {
420 gg->group_family = NULL;
421 gg->group_name = NULL;
422 }
423 }
424 if (gf->family_cmds != NULL)
425 free(gf->family_cmds, M_NETLINK);
426 bzero(gf, sizeof(*gf));
427 GENL_UNLOCK();
428 }
429
430 bool
genl_register_cmds(uint16_t family_id,const struct genl_cmd * cmds,u_int count)431 genl_register_cmds(uint16_t family_id, const struct genl_cmd *cmds,
432 u_int count)
433 {
434 struct genl_family *gf;
435 uint16_t cmd_size;
436
437 GENL_LOCK();
438 gf = genl_family(family_id);
439
440 cmd_size = gf->family_cmd_size;
441
442 for (u_int i = 0; i < count; i++) {
443 MPASS(cmds[i].cmd_cb != NULL);
444 if (cmds[i].cmd_num >= cmd_size)
445 cmd_size = cmds[i].cmd_num + 1;
446 }
447
448 if (cmd_size > gf->family_cmd_size) {
449 void *old_data;
450
451 /* need to realloc */
452 size_t sz = cmd_size * sizeof(struct genl_cmd);
453 void *data = malloc(sz, M_NETLINK, M_WAITOK | M_ZERO);
454
455 memcpy(data, gf->family_cmds,
456 gf->family_cmd_size * sizeof(struct genl_cmd));
457 old_data = gf->family_cmds;
458 gf->family_cmds = data;
459 gf->family_cmd_size = cmd_size;
460 free(old_data, M_NETLINK);
461 }
462
463 for (u_int i = 0; i < count; i++) {
464 const struct genl_cmd *cmd = &cmds[i];
465
466 MPASS(gf->family_cmds[cmd->cmd_num].cmd_cb == NULL);
467 gf->family_cmds[cmd->cmd_num] = cmds[i];
468 NL_LOG(LOG_DEBUG2, "Adding cmd %s(%d) to family %s",
469 cmd->cmd_name, cmd->cmd_num, gf->family_name);
470 }
471 GENL_UNLOCK();
472 return (true);
473 }
474
475 uint32_t
genl_register_group(uint16_t family_id,const char * group_name)476 genl_register_group(uint16_t family_id, const char *group_name)
477 {
478 struct genl_family *gf;
479 uint32_t group_id = 0;
480
481 MPASS(group_name != NULL);
482
483 GENL_LOCK();
484 gf = genl_family(family_id);
485
486 for (u_int i = 0; i < MAX_GROUPS; i++)
487 if (groups[i].group_family == gf &&
488 strcmp(groups[i].group_name, group_name) == 0) {
489 GENL_UNLOCK();
490 return (0);
491 }
492
493 /* Microoptimization: index 0 is reserved for the control family */
494 for (u_int i = 1; i < MAX_GROUPS; i++) {
495 struct genl_group *gg = &groups[i];
496 if (gg->group_family == NULL) {
497 gf->family_num_groups++;
498 gg->group_family = gf;
499 gg->group_name = group_name;
500 group_id = i + MIN_GROUP_NUM;
501 break;
502 }
503 }
504 GENL_UNLOCK();
505
506 return (group_id);
507 }
508
509 void
genl_unregister_group(uint16_t family_id,uint32_t group_id)510 genl_unregister_group(uint16_t family_id, uint32_t group_id)
511 {
512 struct genl_family *gf;
513 struct genl_group *gg;
514
515 MPASS(group_id > MIN_GROUP_NUM &&
516 group_id < MIN_GROUP_NUM + MAX_GROUPS);
517
518 nl_clear_group(group_id);
519
520 group_id -= MIN_GROUP_NUM;
521
522 GENL_LOCK();
523 gf = genl_family(family_id);
524 gg = &groups[group_id];
525
526 MPASS(gg->group_family == gf);
527 MPASS(gf->family_num_groups > 0);
528
529 gf->family_num_groups--;
530 gg->group_family = NULL;
531 gg->group_name = NULL;
532 GENL_UNLOCK();
533 }
534