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 * 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 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 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 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 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 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 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 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 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 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 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 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 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 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