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