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