1 /* 2 * NETLINK Generic Netlink Family 3 * 4 * Authors: Jamal Hadi Salim 5 * Thomas Graf <tgraf@suug.ch> 6 * Johannes Berg <johannes@sipsolutions.net> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/kernel.h> 11 #include <linux/slab.h> 12 #include <linux/errno.h> 13 #include <linux/types.h> 14 #include <linux/socket.h> 15 #include <linux/string.h> 16 #include <linux/skbuff.h> 17 #include <linux/mutex.h> 18 #include <linux/bitmap.h> 19 #include <net/sock.h> 20 #include <net/genetlink.h> 21 22 static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */ 23 24 void genl_lock(void) 25 { 26 mutex_lock(&genl_mutex); 27 } 28 EXPORT_SYMBOL(genl_lock); 29 30 void genl_unlock(void) 31 { 32 mutex_unlock(&genl_mutex); 33 } 34 EXPORT_SYMBOL(genl_unlock); 35 36 #ifdef CONFIG_PROVE_LOCKING 37 int lockdep_genl_is_held(void) 38 { 39 return lockdep_is_held(&genl_mutex); 40 } 41 EXPORT_SYMBOL(lockdep_genl_is_held); 42 #endif 43 44 #define GENL_FAM_TAB_SIZE 16 45 #define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1) 46 47 static struct list_head family_ht[GENL_FAM_TAB_SIZE]; 48 /* 49 * Bitmap of multicast groups that are currently in use. 50 * 51 * To avoid an allocation at boot of just one unsigned long, 52 * declare it global instead. 53 * Bit 0 is marked as already used since group 0 is invalid. 54 */ 55 static unsigned long mc_group_start = 0x1; 56 static unsigned long *mc_groups = &mc_group_start; 57 static unsigned long mc_groups_longs = 1; 58 59 static int genl_ctrl_event(int event, void *data); 60 61 static inline unsigned int genl_family_hash(unsigned int id) 62 { 63 return id & GENL_FAM_TAB_MASK; 64 } 65 66 static inline struct list_head *genl_family_chain(unsigned int id) 67 { 68 return &family_ht[genl_family_hash(id)]; 69 } 70 71 static struct genl_family *genl_family_find_byid(unsigned int id) 72 { 73 struct genl_family *f; 74 75 list_for_each_entry(f, genl_family_chain(id), family_list) 76 if (f->id == id) 77 return f; 78 79 return NULL; 80 } 81 82 static struct genl_family *genl_family_find_byname(char *name) 83 { 84 struct genl_family *f; 85 int i; 86 87 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) 88 list_for_each_entry(f, genl_family_chain(i), family_list) 89 if (strcmp(f->name, name) == 0) 90 return f; 91 92 return NULL; 93 } 94 95 static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family) 96 { 97 struct genl_ops *ops; 98 99 list_for_each_entry(ops, &family->ops_list, ops_list) 100 if (ops->cmd == cmd) 101 return ops; 102 103 return NULL; 104 } 105 106 /* Of course we are going to have problems once we hit 107 * 2^16 alive types, but that can only happen by year 2K 108 */ 109 static u16 genl_generate_id(void) 110 { 111 static u16 id_gen_idx = GENL_MIN_ID; 112 int i; 113 114 for (i = 0; i <= GENL_MAX_ID - GENL_MIN_ID; i++) { 115 if (!genl_family_find_byid(id_gen_idx)) 116 return id_gen_idx; 117 if (++id_gen_idx > GENL_MAX_ID) 118 id_gen_idx = GENL_MIN_ID; 119 } 120 121 return 0; 122 } 123 124 static struct genl_multicast_group notify_grp; 125 126 /** 127 * genl_register_mc_group - register a multicast group 128 * 129 * Registers the specified multicast group and notifies userspace 130 * about the new group. 131 * 132 * Returns 0 on success or a negative error code. 133 * 134 * @family: The generic netlink family the group shall be registered for. 135 * @grp: The group to register, must have a name. 136 */ 137 int genl_register_mc_group(struct genl_family *family, 138 struct genl_multicast_group *grp) 139 { 140 int id; 141 unsigned long *new_groups; 142 int err = 0; 143 144 BUG_ON(grp->name[0] == '\0'); 145 146 genl_lock(); 147 148 /* special-case our own group */ 149 if (grp == ¬ify_grp) 150 id = GENL_ID_CTRL; 151 else 152 id = find_first_zero_bit(mc_groups, 153 mc_groups_longs * BITS_PER_LONG); 154 155 156 if (id >= mc_groups_longs * BITS_PER_LONG) { 157 size_t nlen = (mc_groups_longs + 1) * sizeof(unsigned long); 158 159 if (mc_groups == &mc_group_start) { 160 new_groups = kzalloc(nlen, GFP_KERNEL); 161 if (!new_groups) { 162 err = -ENOMEM; 163 goto out; 164 } 165 mc_groups = new_groups; 166 *mc_groups = mc_group_start; 167 } else { 168 new_groups = krealloc(mc_groups, nlen, GFP_KERNEL); 169 if (!new_groups) { 170 err = -ENOMEM; 171 goto out; 172 } 173 mc_groups = new_groups; 174 mc_groups[mc_groups_longs] = 0; 175 } 176 mc_groups_longs++; 177 } 178 179 if (family->netnsok) { 180 struct net *net; 181 182 netlink_table_grab(); 183 rcu_read_lock(); 184 for_each_net_rcu(net) { 185 err = __netlink_change_ngroups(net->genl_sock, 186 mc_groups_longs * BITS_PER_LONG); 187 if (err) { 188 /* 189 * No need to roll back, can only fail if 190 * memory allocation fails and then the 191 * number of _possible_ groups has been 192 * increased on some sockets which is ok. 193 */ 194 rcu_read_unlock(); 195 netlink_table_ungrab(); 196 goto out; 197 } 198 } 199 rcu_read_unlock(); 200 netlink_table_ungrab(); 201 } else { 202 err = netlink_change_ngroups(init_net.genl_sock, 203 mc_groups_longs * BITS_PER_LONG); 204 if (err) 205 goto out; 206 } 207 208 grp->id = id; 209 set_bit(id, mc_groups); 210 list_add_tail(&grp->list, &family->mcast_groups); 211 grp->family = family; 212 213 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, grp); 214 out: 215 genl_unlock(); 216 return err; 217 } 218 EXPORT_SYMBOL(genl_register_mc_group); 219 220 static void __genl_unregister_mc_group(struct genl_family *family, 221 struct genl_multicast_group *grp) 222 { 223 struct net *net; 224 BUG_ON(grp->family != family); 225 226 netlink_table_grab(); 227 rcu_read_lock(); 228 for_each_net_rcu(net) 229 __netlink_clear_multicast_users(net->genl_sock, grp->id); 230 rcu_read_unlock(); 231 netlink_table_ungrab(); 232 233 clear_bit(grp->id, mc_groups); 234 list_del(&grp->list); 235 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, grp); 236 grp->id = 0; 237 grp->family = NULL; 238 } 239 240 /** 241 * genl_unregister_mc_group - unregister a multicast group 242 * 243 * Unregisters the specified multicast group and notifies userspace 244 * about it. All current listeners on the group are removed. 245 * 246 * Note: It is not necessary to unregister all multicast groups before 247 * unregistering the family, unregistering the family will cause 248 * all assigned multicast groups to be unregistered automatically. 249 * 250 * @family: Generic netlink family the group belongs to. 251 * @grp: The group to unregister, must have been registered successfully 252 * previously. 253 */ 254 void genl_unregister_mc_group(struct genl_family *family, 255 struct genl_multicast_group *grp) 256 { 257 genl_lock(); 258 __genl_unregister_mc_group(family, grp); 259 genl_unlock(); 260 } 261 EXPORT_SYMBOL(genl_unregister_mc_group); 262 263 static void genl_unregister_mc_groups(struct genl_family *family) 264 { 265 struct genl_multicast_group *grp, *tmp; 266 267 list_for_each_entry_safe(grp, tmp, &family->mcast_groups, list) 268 __genl_unregister_mc_group(family, grp); 269 } 270 271 /** 272 * genl_register_ops - register generic netlink operations 273 * @family: generic netlink family 274 * @ops: operations to be registered 275 * 276 * Registers the specified operations and assigns them to the specified 277 * family. Either a doit or dumpit callback must be specified or the 278 * operation will fail. Only one operation structure per command 279 * identifier may be registered. 280 * 281 * See include/net/genetlink.h for more documenation on the operations 282 * structure. 283 * 284 * Returns 0 on success or a negative error code. 285 */ 286 int genl_register_ops(struct genl_family *family, struct genl_ops *ops) 287 { 288 int err = -EINVAL; 289 290 if (ops->dumpit == NULL && ops->doit == NULL) 291 goto errout; 292 293 if (genl_get_cmd(ops->cmd, family)) { 294 err = -EEXIST; 295 goto errout; 296 } 297 298 if (ops->dumpit) 299 ops->flags |= GENL_CMD_CAP_DUMP; 300 if (ops->doit) 301 ops->flags |= GENL_CMD_CAP_DO; 302 if (ops->policy) 303 ops->flags |= GENL_CMD_CAP_HASPOL; 304 305 genl_lock(); 306 list_add_tail(&ops->ops_list, &family->ops_list); 307 genl_unlock(); 308 309 genl_ctrl_event(CTRL_CMD_NEWOPS, ops); 310 err = 0; 311 errout: 312 return err; 313 } 314 EXPORT_SYMBOL(genl_register_ops); 315 316 /** 317 * genl_unregister_ops - unregister generic netlink operations 318 * @family: generic netlink family 319 * @ops: operations to be unregistered 320 * 321 * Unregisters the specified operations and unassigns them from the 322 * specified family. The operation blocks until the current message 323 * processing has finished and doesn't start again until the 324 * unregister process has finished. 325 * 326 * Note: It is not necessary to unregister all operations before 327 * unregistering the family, unregistering the family will cause 328 * all assigned operations to be unregistered automatically. 329 * 330 * Returns 0 on success or a negative error code. 331 */ 332 int genl_unregister_ops(struct genl_family *family, struct genl_ops *ops) 333 { 334 struct genl_ops *rc; 335 336 genl_lock(); 337 list_for_each_entry(rc, &family->ops_list, ops_list) { 338 if (rc == ops) { 339 list_del(&ops->ops_list); 340 genl_unlock(); 341 genl_ctrl_event(CTRL_CMD_DELOPS, ops); 342 return 0; 343 } 344 } 345 genl_unlock(); 346 347 return -ENOENT; 348 } 349 EXPORT_SYMBOL(genl_unregister_ops); 350 351 /** 352 * genl_register_family - register a generic netlink family 353 * @family: generic netlink family 354 * 355 * Registers the specified family after validating it first. Only one 356 * family may be registered with the same family name or identifier. 357 * The family id may equal GENL_ID_GENERATE causing an unique id to 358 * be automatically generated and assigned. 359 * 360 * Return 0 on success or a negative error code. 361 */ 362 int genl_register_family(struct genl_family *family) 363 { 364 int err = -EINVAL; 365 366 if (family->id && family->id < GENL_MIN_ID) 367 goto errout; 368 369 if (family->id > GENL_MAX_ID) 370 goto errout; 371 372 INIT_LIST_HEAD(&family->ops_list); 373 INIT_LIST_HEAD(&family->mcast_groups); 374 375 genl_lock(); 376 377 if (genl_family_find_byname(family->name)) { 378 err = -EEXIST; 379 goto errout_locked; 380 } 381 382 if (family->id == GENL_ID_GENERATE) { 383 u16 newid = genl_generate_id(); 384 385 if (!newid) { 386 err = -ENOMEM; 387 goto errout_locked; 388 } 389 390 family->id = newid; 391 } else if (genl_family_find_byid(family->id)) { 392 err = -EEXIST; 393 goto errout_locked; 394 } 395 396 if (family->maxattr) { 397 family->attrbuf = kmalloc((family->maxattr+1) * 398 sizeof(struct nlattr *), GFP_KERNEL); 399 if (family->attrbuf == NULL) { 400 err = -ENOMEM; 401 goto errout_locked; 402 } 403 } else 404 family->attrbuf = NULL; 405 406 list_add_tail(&family->family_list, genl_family_chain(family->id)); 407 genl_unlock(); 408 409 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family); 410 411 return 0; 412 413 errout_locked: 414 genl_unlock(); 415 errout: 416 return err; 417 } 418 EXPORT_SYMBOL(genl_register_family); 419 420 /** 421 * genl_register_family_with_ops - register a generic netlink family 422 * @family: generic netlink family 423 * @ops: operations to be registered 424 * @n_ops: number of elements to register 425 * 426 * Registers the specified family and operations from the specified table. 427 * Only one family may be registered with the same family name or identifier. 428 * 429 * The family id may equal GENL_ID_GENERATE causing an unique id to 430 * be automatically generated and assigned. 431 * 432 * Either a doit or dumpit callback must be specified for every registered 433 * operation or the function will fail. Only one operation structure per 434 * command identifier may be registered. 435 * 436 * See include/net/genetlink.h for more documenation on the operations 437 * structure. 438 * 439 * This is equivalent to calling genl_register_family() followed by 440 * genl_register_ops() for every operation entry in the table taking 441 * care to unregister the family on error path. 442 * 443 * Return 0 on success or a negative error code. 444 */ 445 int genl_register_family_with_ops(struct genl_family *family, 446 struct genl_ops *ops, size_t n_ops) 447 { 448 int err, i; 449 450 err = genl_register_family(family); 451 if (err) 452 return err; 453 454 for (i = 0; i < n_ops; ++i, ++ops) { 455 err = genl_register_ops(family, ops); 456 if (err) 457 goto err_out; 458 } 459 return 0; 460 err_out: 461 genl_unregister_family(family); 462 return err; 463 } 464 EXPORT_SYMBOL(genl_register_family_with_ops); 465 466 /** 467 * genl_unregister_family - unregister generic netlink family 468 * @family: generic netlink family 469 * 470 * Unregisters the specified family. 471 * 472 * Returns 0 on success or a negative error code. 473 */ 474 int genl_unregister_family(struct genl_family *family) 475 { 476 struct genl_family *rc; 477 478 genl_lock(); 479 480 genl_unregister_mc_groups(family); 481 482 list_for_each_entry(rc, genl_family_chain(family->id), family_list) { 483 if (family->id != rc->id || strcmp(rc->name, family->name)) 484 continue; 485 486 list_del(&rc->family_list); 487 INIT_LIST_HEAD(&family->ops_list); 488 genl_unlock(); 489 490 kfree(family->attrbuf); 491 genl_ctrl_event(CTRL_CMD_DELFAMILY, family); 492 return 0; 493 } 494 495 genl_unlock(); 496 497 return -ENOENT; 498 } 499 EXPORT_SYMBOL(genl_unregister_family); 500 501 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) 502 { 503 struct genl_ops *ops; 504 struct genl_family *family; 505 struct net *net = sock_net(skb->sk); 506 struct genl_info info; 507 struct genlmsghdr *hdr = nlmsg_data(nlh); 508 int hdrlen, err; 509 510 family = genl_family_find_byid(nlh->nlmsg_type); 511 if (family == NULL) 512 return -ENOENT; 513 514 /* this family doesn't exist in this netns */ 515 if (!family->netnsok && !net_eq(net, &init_net)) 516 return -ENOENT; 517 518 hdrlen = GENL_HDRLEN + family->hdrsize; 519 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen)) 520 return -EINVAL; 521 522 ops = genl_get_cmd(hdr->cmd, family); 523 if (ops == NULL) 524 return -EOPNOTSUPP; 525 526 if ((ops->flags & GENL_ADMIN_PERM) && 527 !capable(CAP_NET_ADMIN)) 528 return -EPERM; 529 530 if (nlh->nlmsg_flags & NLM_F_DUMP) { 531 if (ops->dumpit == NULL) 532 return -EOPNOTSUPP; 533 534 genl_unlock(); 535 err = netlink_dump_start(net->genl_sock, skb, nlh, 536 ops->dumpit, ops->done, 0); 537 genl_lock(); 538 return err; 539 } 540 541 if (ops->doit == NULL) 542 return -EOPNOTSUPP; 543 544 if (family->attrbuf) { 545 err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr, 546 ops->policy); 547 if (err < 0) 548 return err; 549 } 550 551 info.snd_seq = nlh->nlmsg_seq; 552 info.snd_pid = NETLINK_CB(skb).pid; 553 info.nlhdr = nlh; 554 info.genlhdr = nlmsg_data(nlh); 555 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN; 556 info.attrs = family->attrbuf; 557 genl_info_net_set(&info, net); 558 memset(&info.user_ptr, 0, sizeof(info.user_ptr)); 559 560 if (family->pre_doit) { 561 err = family->pre_doit(ops, skb, &info); 562 if (err) 563 return err; 564 } 565 566 err = ops->doit(skb, &info); 567 568 if (family->post_doit) 569 family->post_doit(ops, skb, &info); 570 571 return err; 572 } 573 574 static void genl_rcv(struct sk_buff *skb) 575 { 576 genl_lock(); 577 netlink_rcv_skb(skb, &genl_rcv_msg); 578 genl_unlock(); 579 } 580 581 /************************************************************************** 582 * Controller 583 **************************************************************************/ 584 585 static struct genl_family genl_ctrl = { 586 .id = GENL_ID_CTRL, 587 .name = "nlctrl", 588 .version = 0x2, 589 .maxattr = CTRL_ATTR_MAX, 590 .netnsok = true, 591 }; 592 593 static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq, 594 u32 flags, struct sk_buff *skb, u8 cmd) 595 { 596 void *hdr; 597 598 hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd); 599 if (hdr == NULL) 600 return -1; 601 602 NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name); 603 NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id); 604 NLA_PUT_U32(skb, CTRL_ATTR_VERSION, family->version); 605 NLA_PUT_U32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize); 606 NLA_PUT_U32(skb, CTRL_ATTR_MAXATTR, family->maxattr); 607 608 if (!list_empty(&family->ops_list)) { 609 struct nlattr *nla_ops; 610 struct genl_ops *ops; 611 int idx = 1; 612 613 nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS); 614 if (nla_ops == NULL) 615 goto nla_put_failure; 616 617 list_for_each_entry(ops, &family->ops_list, ops_list) { 618 struct nlattr *nest; 619 620 nest = nla_nest_start(skb, idx++); 621 if (nest == NULL) 622 goto nla_put_failure; 623 624 NLA_PUT_U32(skb, CTRL_ATTR_OP_ID, ops->cmd); 625 NLA_PUT_U32(skb, CTRL_ATTR_OP_FLAGS, ops->flags); 626 627 nla_nest_end(skb, nest); 628 } 629 630 nla_nest_end(skb, nla_ops); 631 } 632 633 if (!list_empty(&family->mcast_groups)) { 634 struct genl_multicast_group *grp; 635 struct nlattr *nla_grps; 636 int idx = 1; 637 638 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS); 639 if (nla_grps == NULL) 640 goto nla_put_failure; 641 642 list_for_each_entry(grp, &family->mcast_groups, list) { 643 struct nlattr *nest; 644 645 nest = nla_nest_start(skb, idx++); 646 if (nest == NULL) 647 goto nla_put_failure; 648 649 NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id); 650 NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME, 651 grp->name); 652 653 nla_nest_end(skb, nest); 654 } 655 nla_nest_end(skb, nla_grps); 656 } 657 658 return genlmsg_end(skb, hdr); 659 660 nla_put_failure: 661 genlmsg_cancel(skb, hdr); 662 return -EMSGSIZE; 663 } 664 665 static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 pid, 666 u32 seq, u32 flags, struct sk_buff *skb, 667 u8 cmd) 668 { 669 void *hdr; 670 struct nlattr *nla_grps; 671 struct nlattr *nest; 672 673 hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd); 674 if (hdr == NULL) 675 return -1; 676 677 NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, grp->family->name); 678 NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, grp->family->id); 679 680 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS); 681 if (nla_grps == NULL) 682 goto nla_put_failure; 683 684 nest = nla_nest_start(skb, 1); 685 if (nest == NULL) 686 goto nla_put_failure; 687 688 NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id); 689 NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME, 690 grp->name); 691 692 nla_nest_end(skb, nest); 693 nla_nest_end(skb, nla_grps); 694 695 return genlmsg_end(skb, hdr); 696 697 nla_put_failure: 698 genlmsg_cancel(skb, hdr); 699 return -EMSGSIZE; 700 } 701 702 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb) 703 { 704 705 int i, n = 0; 706 struct genl_family *rt; 707 struct net *net = sock_net(skb->sk); 708 int chains_to_skip = cb->args[0]; 709 int fams_to_skip = cb->args[1]; 710 711 for (i = chains_to_skip; i < GENL_FAM_TAB_SIZE; i++) { 712 n = 0; 713 list_for_each_entry(rt, genl_family_chain(i), family_list) { 714 if (!rt->netnsok && !net_eq(net, &init_net)) 715 continue; 716 if (++n < fams_to_skip) 717 continue; 718 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid, 719 cb->nlh->nlmsg_seq, NLM_F_MULTI, 720 skb, CTRL_CMD_NEWFAMILY) < 0) 721 goto errout; 722 } 723 724 fams_to_skip = 0; 725 } 726 727 errout: 728 cb->args[0] = i; 729 cb->args[1] = n; 730 731 return skb->len; 732 } 733 734 static struct sk_buff *ctrl_build_family_msg(struct genl_family *family, 735 u32 pid, int seq, u8 cmd) 736 { 737 struct sk_buff *skb; 738 int err; 739 740 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 741 if (skb == NULL) 742 return ERR_PTR(-ENOBUFS); 743 744 err = ctrl_fill_info(family, pid, seq, 0, skb, cmd); 745 if (err < 0) { 746 nlmsg_free(skb); 747 return ERR_PTR(err); 748 } 749 750 return skb; 751 } 752 753 static struct sk_buff *ctrl_build_mcgrp_msg(struct genl_multicast_group *grp, 754 u32 pid, int seq, u8 cmd) 755 { 756 struct sk_buff *skb; 757 int err; 758 759 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 760 if (skb == NULL) 761 return ERR_PTR(-ENOBUFS); 762 763 err = ctrl_fill_mcgrp_info(grp, pid, seq, 0, skb, cmd); 764 if (err < 0) { 765 nlmsg_free(skb); 766 return ERR_PTR(err); 767 } 768 769 return skb; 770 } 771 772 static const struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = { 773 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 }, 774 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING, 775 .len = GENL_NAMSIZ - 1 }, 776 }; 777 778 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info) 779 { 780 struct sk_buff *msg; 781 struct genl_family *res = NULL; 782 int err = -EINVAL; 783 784 if (info->attrs[CTRL_ATTR_FAMILY_ID]) { 785 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]); 786 res = genl_family_find_byid(id); 787 err = -ENOENT; 788 } 789 790 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) { 791 char *name; 792 793 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]); 794 res = genl_family_find_byname(name); 795 #ifdef CONFIG_MODULES 796 if (res == NULL) { 797 genl_unlock(); 798 request_module("net-pf-%d-proto-%d-type-%s", 799 PF_NETLINK, NETLINK_GENERIC, name); 800 genl_lock(); 801 res = genl_family_find_byname(name); 802 } 803 #endif 804 err = -ENOENT; 805 } 806 807 if (res == NULL) 808 return err; 809 810 if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) { 811 /* family doesn't exist here */ 812 return -ENOENT; 813 } 814 815 msg = ctrl_build_family_msg(res, info->snd_pid, info->snd_seq, 816 CTRL_CMD_NEWFAMILY); 817 if (IS_ERR(msg)) 818 return PTR_ERR(msg); 819 820 return genlmsg_reply(msg, info); 821 } 822 823 static int genl_ctrl_event(int event, void *data) 824 { 825 struct sk_buff *msg; 826 struct genl_family *family; 827 struct genl_multicast_group *grp; 828 829 /* genl is still initialising */ 830 if (!init_net.genl_sock) 831 return 0; 832 833 switch (event) { 834 case CTRL_CMD_NEWFAMILY: 835 case CTRL_CMD_DELFAMILY: 836 family = data; 837 msg = ctrl_build_family_msg(family, 0, 0, event); 838 break; 839 case CTRL_CMD_NEWMCAST_GRP: 840 case CTRL_CMD_DELMCAST_GRP: 841 grp = data; 842 family = grp->family; 843 msg = ctrl_build_mcgrp_msg(data, 0, 0, event); 844 break; 845 default: 846 return -EINVAL; 847 } 848 849 if (IS_ERR(msg)) 850 return PTR_ERR(msg); 851 852 if (!family->netnsok) { 853 genlmsg_multicast_netns(&init_net, msg, 0, 854 GENL_ID_CTRL, GFP_KERNEL); 855 } else { 856 rcu_read_lock(); 857 genlmsg_multicast_allns(msg, 0, GENL_ID_CTRL, GFP_ATOMIC); 858 rcu_read_unlock(); 859 } 860 861 return 0; 862 } 863 864 static struct genl_ops genl_ctrl_ops = { 865 .cmd = CTRL_CMD_GETFAMILY, 866 .doit = ctrl_getfamily, 867 .dumpit = ctrl_dumpfamily, 868 .policy = ctrl_policy, 869 }; 870 871 static struct genl_multicast_group notify_grp = { 872 .name = "notify", 873 }; 874 875 static int __net_init genl_pernet_init(struct net *net) 876 { 877 /* we'll bump the group number right afterwards */ 878 net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, 0, 879 genl_rcv, &genl_mutex, 880 THIS_MODULE); 881 882 if (!net->genl_sock && net_eq(net, &init_net)) 883 panic("GENL: Cannot initialize generic netlink\n"); 884 885 if (!net->genl_sock) 886 return -ENOMEM; 887 888 return 0; 889 } 890 891 static void __net_exit genl_pernet_exit(struct net *net) 892 { 893 netlink_kernel_release(net->genl_sock); 894 net->genl_sock = NULL; 895 } 896 897 static struct pernet_operations genl_pernet_ops = { 898 .init = genl_pernet_init, 899 .exit = genl_pernet_exit, 900 }; 901 902 static int __init genl_init(void) 903 { 904 int i, err; 905 906 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) 907 INIT_LIST_HEAD(&family_ht[i]); 908 909 err = genl_register_family_with_ops(&genl_ctrl, &genl_ctrl_ops, 1); 910 if (err < 0) 911 goto problem; 912 913 netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV); 914 915 err = register_pernet_subsys(&genl_pernet_ops); 916 if (err) 917 goto problem; 918 919 err = genl_register_mc_group(&genl_ctrl, ¬ify_grp); 920 if (err < 0) 921 goto problem; 922 923 return 0; 924 925 problem: 926 panic("GENL: Cannot register controller: %d\n", err); 927 } 928 929 subsys_initcall(genl_init); 930 931 static int genlmsg_mcast(struct sk_buff *skb, u32 pid, unsigned long group, 932 gfp_t flags) 933 { 934 struct sk_buff *tmp; 935 struct net *net, *prev = NULL; 936 int err; 937 938 for_each_net_rcu(net) { 939 if (prev) { 940 tmp = skb_clone(skb, flags); 941 if (!tmp) { 942 err = -ENOMEM; 943 goto error; 944 } 945 err = nlmsg_multicast(prev->genl_sock, tmp, 946 pid, group, flags); 947 if (err) 948 goto error; 949 } 950 951 prev = net; 952 } 953 954 return nlmsg_multicast(prev->genl_sock, skb, pid, group, flags); 955 error: 956 kfree_skb(skb); 957 return err; 958 } 959 960 int genlmsg_multicast_allns(struct sk_buff *skb, u32 pid, unsigned int group, 961 gfp_t flags) 962 { 963 return genlmsg_mcast(skb, pid, group, flags); 964 } 965 EXPORT_SYMBOL(genlmsg_multicast_allns); 966 967 void genl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group, 968 struct nlmsghdr *nlh, gfp_t flags) 969 { 970 struct sock *sk = net->genl_sock; 971 int report = 0; 972 973 if (nlh) 974 report = nlmsg_report(nlh); 975 976 nlmsg_notify(sk, skb, pid, group, report, flags); 977 } 978 EXPORT_SYMBOL(genl_notify); 979