net/netlink/genetlink.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * NETLINK      Generic Netlink Family
   4  *
   5  *              Authors:        Jamal Hadi Salim
   6  *                              Thomas Graf <tgraf@suug.ch>
   7  *                              Johannes Berg <johannes@sipsolutions.net>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/slab.h>
  13 #include <linux/errno.h>
  14 #include <linux/types.h>
  15 #include <linux/socket.h>
  16 #include <linux/string.h>
  17 #include <linux/skbuff.h>
  18 #include <linux/mutex.h>
  19 #include <linux/bitmap.h>
  20 #include <linux/rwsem.h>
  21 #include <linux/idr.h>
  22 #include <net/sock.h>
  23 #include <net/genetlink.h>
  24
  25 static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */
  26 static DECLARE_RWSEM(cb_lock);
  27
  28 atomic_t genl_sk_destructing_cnt = ATOMIC_INIT(0);
  29 DECLARE_WAIT_QUEUE_HEAD(genl_sk_destructing_waitq);
  30
  31 void genl_lock(void)
  32 {
  33         mutex_lock(&genl_mutex);
  34 }
  35 EXPORT_SYMBOL(genl_lock);
  36
  37 void genl_unlock(void)
  38 {
  39         mutex_unlock(&genl_mutex);
  40 }
  41 EXPORT_SYMBOL(genl_unlock);
  42
  43 static void genl_lock_all(void)
  44 {
  45         down_write(&cb_lock);
  46         genl_lock();
  47 }
  48
  49 static void genl_unlock_all(void)
  50 {
  51         genl_unlock();
  52         up_write(&cb_lock);
  53 }
  54
  55 static DEFINE_IDR(genl_fam_idr);
  56
  57 /*
  58  * Bitmap of multicast groups that are currently in use.
  59  *
  60  * To avoid an allocation at boot of just one unsigned long,
  61  * declare it global instead.
  62  * Bit 0 is marked as already used since group 0 is invalid.
  63  * Bit 1 is marked as already used since the drop-monitor code
  64  * abuses the API and thinks it can statically use group 1.
  65  * That group will typically conflict with other groups that
  66  * any proper users use.
  67  * Bit 16 is marked as used since it's used for generic netlink
  68  * and the code no longer marks pre-reserved IDs as used.
  69  * Bit 17 is marked as already used since the VFS quota code
  70  * also abused this API and relied on family == group ID, we
  71  * cater to that by giving it a static family and group ID.
  72  * Bit 18 is marked as already used since the PMCRAID driver
  73  * did the same thing as the VFS quota code (maybe copied?)
  74  */
  75 static unsigned long mc_group_start = 0x3 | BIT(GENL_ID_CTRL) |
  76                                       BIT(GENL_ID_VFS_DQUOT) |
  77                                       BIT(GENL_ID_PMCRAID);
  78 static unsigned long *mc_groups = &mc_group_start;
  79 static unsigned long mc_groups_longs = 1;
  80
  81 /* We need the last attribute with non-zero ID therefore a 2-entry array */
  82 static struct nla_policy genl_policy_reject_all[] = {
  83         { .type = NLA_REJECT },
  84         { .type = NLA_REJECT },
  85 };
  86
  87 static int genl_ctrl_event(int event, const struct genl_family *family,
  88                            const struct genl_multicast_group *grp,
  89                            int grp_id);
  90
  91 static void
  92 genl_op_fill_in_reject_policy(const struct genl_family *family,
  93                               struct genl_ops *op)
  94 {
  95         BUILD_BUG_ON(ARRAY_SIZE(genl_policy_reject_all) - 1 != 1);
  96
  97         if (op->policy || op->cmd < family->resv_start_op)
  98                 return;
  99
 100         op->policy = genl_policy_reject_all;
 101         op->maxattr = 1;
 102 }
 103
 104 static const struct genl_family *genl_family_find_byid(unsigned int id)
 105 {
 106         return idr_find(&genl_fam_idr, id);
 107 }
 108
 109 static const struct genl_family *genl_family_find_byname(char *name)
 110 {
 111         const struct genl_family *family;
 112         unsigned int id;
 113
 114         idr_for_each_entry(&genl_fam_idr, family, id)
 115                 if (strcmp(family->name, name) == 0)
 116                         return family;
 117
 118         return NULL;
 119 }
 120
 121 static int genl_get_cmd_cnt(const struct genl_family *family)
 122 {
 123         return family->n_ops + family->n_small_ops;
 124 }
 125
 126 static void genl_op_from_full(const struct genl_family *family,
 127                               unsigned int i, struct genl_ops *op)
 128 {
 129         *op = family->ops[i];
 130
 131         if (!op->maxattr)
 132                 op->maxattr = family->maxattr;
 133         if (!op->policy)
 134                 op->policy = family->policy;
 135
 136         genl_op_fill_in_reject_policy(family, op);
 137 }
 138
 139 static int genl_get_cmd_full(u32 cmd, const struct genl_family *family,
 140                              struct genl_ops *op)
 141 {
 142         int i;
 143
 144         for (i = 0; i < family->n_ops; i++)
 145                 if (family->ops[i].cmd == cmd) {
 146                         genl_op_from_full(family, i, op);
 147                         return 0;
 148                 }
 149
 150         return -ENOENT;
 151 }
 152
 153 static void genl_op_from_small(const struct genl_family *family,
 154                                unsigned int i, struct genl_ops *op)
 155 {
 156         memset(op, 0, sizeof(*op));
 157         op->doit        = family->small_ops[i].doit;
 158         op->dumpit      = family->small_ops[i].dumpit;
 159         op->cmd         = family->small_ops[i].cmd;
 160         op->internal_flags = family->small_ops[i].internal_flags;
 161         op->flags       = family->small_ops[i].flags;
 162         op->validate    = family->small_ops[i].validate;
 163
 164         op->maxattr = family->maxattr;
 165         op->policy = family->policy;
 166
 167         genl_op_fill_in_reject_policy(family, op);
 168 }
 169
 170 static int genl_get_cmd_small(u32 cmd, const struct genl_family *family,
 171                               struct genl_ops *op)
 172 {
 173         int i;
 174
 175         for (i = 0; i < family->n_small_ops; i++)
 176                 if (family->small_ops[i].cmd == cmd) {
 177                         genl_op_from_small(family, i, op);
 178                         return 0;
 179                 }
 180
 181         return -ENOENT;
 182 }
 183
 184 static int genl_get_cmd(u32 cmd, const struct genl_family *family,
 185                         struct genl_ops *op)
 186 {
 187         if (!genl_get_cmd_full(cmd, family, op))
 188                 return 0;
 189         return genl_get_cmd_small(cmd, family, op);
 190 }
 191
 192 static void genl_get_cmd_by_index(unsigned int i,
 193                                   const struct genl_family *family,
 194                                   struct genl_ops *op)
 195 {
 196         if (i < family->n_ops)
 197                 genl_op_from_full(family, i, op);
 198         else if (i < family->n_ops + family->n_small_ops)
 199                 genl_op_from_small(family, i - family->n_ops, op);
 200         else
 201                 WARN_ON_ONCE(1);
 202 }
 203
 204 static int genl_allocate_reserve_groups(int n_groups, int *first_id)
 205 {
 206         unsigned long *new_groups;
 207         int start = 0;
 208         int i;
 209         int id;
 210         bool fits;
 211
 212         do {
 213                 if (start == 0)
 214                         id = find_first_zero_bit(mc_groups,
 215                                                  mc_groups_longs *
 216                                                  BITS_PER_LONG);
 217                 else
 218                         id = find_next_zero_bit(mc_groups,
 219                                                 mc_groups_longs * BITS_PER_LONG,
 220                                                 start);
 221
 222                 fits = true;
 223                 for (i = id;
 224                      i < min_t(int, id + n_groups,
 225                                mc_groups_longs * BITS_PER_LONG);
 226                      i++) {
 227                         if (test_bit(i, mc_groups)) {
 228                                 start = i;
 229                                 fits = false;
 230                                 break;
 231                         }
 232                 }
 233
 234                 if (id + n_groups > mc_groups_longs * BITS_PER_LONG) {
 235                         unsigned long new_longs = mc_groups_longs +
 236                                                   BITS_TO_LONGS(n_groups);
 237                         size_t nlen = new_longs * sizeof(unsigned long);
 238
 239                         if (mc_groups == &mc_group_start) {
 240                                 new_groups = kzalloc(nlen, GFP_KERNEL);
 241                                 if (!new_groups)
 242                                         return -ENOMEM;
 243                                 mc_groups = new_groups;
 244                                 *mc_groups = mc_group_start;
 245                         } else {
 246                                 new_groups = krealloc(mc_groups, nlen,
 247                                                       GFP_KERNEL);
 248                                 if (!new_groups)
 249                                         return -ENOMEM;
 250                                 mc_groups = new_groups;
 251                                 for (i = 0; i < BITS_TO_LONGS(n_groups); i++)
 252                                         mc_groups[mc_groups_longs + i] = 0;
 253                         }
 254                         mc_groups_longs = new_longs;
 255                 }
 256         } while (!fits);
 257
 258         for (i = id; i < id + n_groups; i++)
 259                 set_bit(i, mc_groups);
 260         *first_id = id;
 261         return 0;
 262 }
 263
 264 static struct genl_family genl_ctrl;
 265
 266 static int genl_validate_assign_mc_groups(struct genl_family *family)
 267 {
 268         int first_id;
 269         int n_groups = family->n_mcgrps;
 270         int err = 0, i;
 271         bool groups_allocated = false;
 272
 273         if (!n_groups)
 274                 return 0;
 275
 276         for (i = 0; i < n_groups; i++) {
 277                 const struct genl_multicast_group *grp = &family->mcgrps[i];
 278
 279                 if (WARN_ON(grp->name[0] == '\0'))
 280                         return -EINVAL;
 281                 if (WARN_ON(memchr(grp->name, '\0', GENL_NAMSIZ) == NULL))
 282                         return -EINVAL;
 283         }
 284
 285         /* special-case our own group and hacks */
 286         if (family == &genl_ctrl) {
 287                 first_id = GENL_ID_CTRL;
 288                 BUG_ON(n_groups != 1);
 289         } else if (strcmp(family->name, "NET_DM") == 0) {
 290                 first_id = 1;
 291                 BUG_ON(n_groups != 1);
 292         } else if (family->id == GENL_ID_VFS_DQUOT) {
 293                 first_id = GENL_ID_VFS_DQUOT;
 294                 BUG_ON(n_groups != 1);
 295         } else if (family->id == GENL_ID_PMCRAID) {
 296                 first_id = GENL_ID_PMCRAID;
 297                 BUG_ON(n_groups != 1);
 298         } else {
 299                 groups_allocated = true;
 300                 err = genl_allocate_reserve_groups(n_groups, &first_id);
 301                 if (err)
 302                         return err;
 303         }
 304
 305         family->mcgrp_offset = first_id;
 306
 307         /* if still initializing, can't and don't need to realloc bitmaps */
 308         if (!init_net.genl_sock)
 309                 return 0;
 310
 311         if (family->netnsok) {
 312                 struct net *net;
 313
 314                 netlink_table_grab();
 315                 rcu_read_lock();
 316                 for_each_net_rcu(net) {
 317                         err = __netlink_change_ngroups(net->genl_sock,
 318                                         mc_groups_longs * BITS_PER_LONG);
 319                         if (err) {
 320                                 /*
 321                                  * No need to roll back, can only fail if
 322                                  * memory allocation fails and then the
 323                                  * number of _possible_ groups has been
 324                                  * increased on some sockets which is ok.
 325                                  */
 326                                 break;
 327                         }
 328                 }
 329                 rcu_read_unlock();
 330                 netlink_table_ungrab();
 331         } else {
 332                 err = netlink_change_ngroups(init_net.genl_sock,
 333                                              mc_groups_longs * BITS_PER_LONG);
 334         }
 335
 336         if (groups_allocated && err) {
 337                 for (i = 0; i < family->n_mcgrps; i++)
 338                         clear_bit(family->mcgrp_offset + i, mc_groups);
 339         }
 340
 341         return err;
 342 }
 343
 344 static void genl_unregister_mc_groups(const struct genl_family *family)
 345 {
 346         struct net *net;
 347         int i;
 348
 349         netlink_table_grab();
 350         rcu_read_lock();
 351         for_each_net_rcu(net) {
 352                 for (i = 0; i < family->n_mcgrps; i++)
 353                         __netlink_clear_multicast_users(
 354                                 net->genl_sock, family->mcgrp_offset + i);
 355         }
 356         rcu_read_unlock();
 357         netlink_table_ungrab();
 358
 359         for (i = 0; i < family->n_mcgrps; i++) {
 360                 int grp_id = family->mcgrp_offset + i;
 361
 362                 if (grp_id != 1)
 363                         clear_bit(grp_id, mc_groups);
 364                 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, family,
 365                                 &family->mcgrps[i], grp_id);
 366         }
 367 }
 368
 369 static int genl_validate_ops(const struct genl_family *family)
 370 {
 371         int i, j;
 372
 373         if (WARN_ON(family->n_ops && !family->ops) ||
 374             WARN_ON(family->n_small_ops && !family->small_ops))
 375                 return -EINVAL;
 376
 377         for (i = 0; i < genl_get_cmd_cnt(family); i++) {
 378                 struct genl_ops op;
 379
 380                 genl_get_cmd_by_index(i, family, &op);
 381                 if (op.dumpit == NULL && op.doit == NULL)
 382                         return -EINVAL;
 383                 if (WARN_ON(op.cmd >= family->resv_start_op && op.validate))
 384                         return -EINVAL;
 385                 for (j = i + 1; j < genl_get_cmd_cnt(family); j++) {
 386                         struct genl_ops op2;
 387
 388                         genl_get_cmd_by_index(j, family, &op2);
 389                         if (op.cmd == op2.cmd)
 390                                 return -EINVAL;
 391                 }
 392         }
 393
 394         return 0;
 395 }
 396
 397 /**
 398  * genl_register_family - register a generic netlink family
 399  * @family: generic netlink family
 400  *
 401  * Registers the specified family after validating it first. Only one
 402  * family may be registered with the same family name or identifier.
 403  *
 404  * The family's ops, multicast groups and module pointer must already
 405  * be assigned.
 406  *
 407  * Return 0 on success or a negative error code.
 408  */
 409 int genl_register_family(struct genl_family *family)
 410 {
 411         int err, i;
 412         int start = GENL_START_ALLOC, end = GENL_MAX_ID;
 413
 414         err = genl_validate_ops(family);
 415         if (err)
 416                 return err;
 417
 418         genl_lock_all();
 419
 420         if (genl_family_find_byname(family->name)) {
 421                 err = -EEXIST;
 422                 goto errout_locked;
 423         }
 424
 425         /*
 426          * Sadly, a few cases need to be special-cased
 427          * due to them having previously abused the API
 428          * and having used their family ID also as their
 429          * multicast group ID, so we use reserved IDs
 430          * for both to be sure we can do that mapping.
 431          */
 432         if (family == &genl_ctrl) {
 433                 /* and this needs to be special for initial family lookups */
 434                 start = end = GENL_ID_CTRL;
 435         } else if (strcmp(family->name, "pmcraid") == 0) {
 436                 start = end = GENL_ID_PMCRAID;
 437         } else if (strcmp(family->name, "VFS_DQUOT") == 0) {
 438                 start = end = GENL_ID_VFS_DQUOT;
 439         }
 440
 441         family->id = idr_alloc_cyclic(&genl_fam_idr, family,
 442                                       start, end + 1, GFP_KERNEL);
 443         if (family->id < 0) {
 444                 err = family->id;
 445                 goto errout_locked;
 446         }
 447
 448         err = genl_validate_assign_mc_groups(family);
 449         if (err)
 450                 goto errout_remove;
 451
 452         genl_unlock_all();
 453
 454         /* send all events */
 455         genl_ctrl_event(CTRL_CMD_NEWFAMILY, family, NULL, 0);
 456         for (i = 0; i < family->n_mcgrps; i++)
 457                 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, family,
 458                                 &family->mcgrps[i], family->mcgrp_offset + i);
 459
 460         return 0;
 461
 462 errout_remove:
 463         idr_remove(&genl_fam_idr, family->id);
 464 errout_locked:
 465         genl_unlock_all();
 466         return err;
 467 }
 468 EXPORT_SYMBOL(genl_register_family);
 469
 470 /**
 471  * genl_unregister_family - unregister generic netlink family
 472  * @family: generic netlink family
 473  *
 474  * Unregisters the specified family.
 475  *
 476  * Returns 0 on success or a negative error code.
 477  */
 478 int genl_unregister_family(const struct genl_family *family)
 479 {
 480         genl_lock_all();
 481
 482         if (!genl_family_find_byid(family->id)) {
 483                 genl_unlock_all();
 484                 return -ENOENT;
 485         }
 486
 487         genl_unregister_mc_groups(family);
 488
 489         idr_remove(&genl_fam_idr, family->id);
 490
 491         up_write(&cb_lock);
 492         wait_event(genl_sk_destructing_waitq,
 493                    atomic_read(&genl_sk_destructing_cnt) == 0);
 494         genl_unlock();
 495
 496         genl_ctrl_event(CTRL_CMD_DELFAMILY, family, NULL, 0);
 497
 498         return 0;
 499 }
 500 EXPORT_SYMBOL(genl_unregister_family);
 501
 502 /**
 503  * genlmsg_put - Add generic netlink header to netlink message
 504  * @skb: socket buffer holding the message
 505  * @portid: netlink portid the message is addressed to
 506  * @seq: sequence number (usually the one of the sender)
 507  * @family: generic netlink family
 508  * @flags: netlink message flags
 509  * @cmd: generic netlink command
 510  *
 511  * Returns pointer to user specific header
 512  */
 513 void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
 514                   const struct genl_family *family, int flags, u8 cmd)
 515 {
 516         struct nlmsghdr *nlh;
 517         struct genlmsghdr *hdr;
 518
 519         nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN +
 520                         family->hdrsize, flags);
 521         if (nlh == NULL)
 522                 return NULL;
 523
 524         hdr = nlmsg_data(nlh);
 525         hdr->cmd = cmd;
 526         hdr->version = family->version;
 527         hdr->reserved = 0;
 528
 529         return (char *) hdr + GENL_HDRLEN;
 530 }
 531 EXPORT_SYMBOL(genlmsg_put);
 532
 533 static struct genl_dumpit_info *genl_dumpit_info_alloc(void)
 534 {
 535         return kmalloc(sizeof(struct genl_dumpit_info), GFP_KERNEL);
 536 }
 537
 538 static void genl_dumpit_info_free(const struct genl_dumpit_info *info)
 539 {
 540         kfree(info);
 541 }
 542
 543 static struct nlattr **
 544 genl_family_rcv_msg_attrs_parse(const struct genl_family *family,
 545                                 struct nlmsghdr *nlh,
 546                                 struct netlink_ext_ack *extack,
 547                                 const struct genl_ops *ops,
 548                                 int hdrlen,
 549                                 enum genl_validate_flags no_strict_flag)
 550 {
 551         enum netlink_validation validate = ops->validate & no_strict_flag ?
 552                                            NL_VALIDATE_LIBERAL :
 553                                            NL_VALIDATE_STRICT;
 554         struct nlattr **attrbuf;
 555         int err;
 556
 557         if (!ops->maxattr)
 558                 return NULL;
 559
 560         attrbuf = kmalloc_array(ops->maxattr + 1,
 561                                 sizeof(struct nlattr *), GFP_KERNEL);
 562         if (!attrbuf)
 563                 return ERR_PTR(-ENOMEM);
 564
 565         err = __nlmsg_parse(nlh, hdrlen, attrbuf, ops->maxattr, ops->policy,
 566                             validate, extack);
 567         if (err) {
 568                 kfree(attrbuf);
 569                 return ERR_PTR(err);
 570         }
 571         return attrbuf;
 572 }
 573
 574 static void genl_family_rcv_msg_attrs_free(struct nlattr **attrbuf)
 575 {
 576         kfree(attrbuf);
 577 }
 578
 579 struct genl_start_context {
 580         const struct genl_family *family;
 581         struct nlmsghdr *nlh;
 582         struct netlink_ext_ack *extack;
 583         const struct genl_ops *ops;
 584         int hdrlen;
 585 };
 586
 587 static int genl_start(struct netlink_callback *cb)
 588 {
 589         struct genl_start_context *ctx = cb->data;
 590         const struct genl_ops *ops = ctx->ops;
 591         struct genl_dumpit_info *info;
 592         struct nlattr **attrs = NULL;
 593         int rc = 0;
 594
 595         if (ops->validate & GENL_DONT_VALIDATE_DUMP)
 596                 goto no_attrs;
 597
 598         if (ctx->nlh->nlmsg_len < nlmsg_msg_size(ctx->hdrlen))
 599                 return -EINVAL;
 600
 601         attrs = genl_family_rcv_msg_attrs_parse(ctx->family, ctx->nlh, ctx->extack,
 602                                                 ops, ctx->hdrlen,
 603                                                 GENL_DONT_VALIDATE_DUMP_STRICT);
 604         if (IS_ERR(attrs))
 605                 return PTR_ERR(attrs);
 606
 607 no_attrs:
 608         info = genl_dumpit_info_alloc();
 609         if (!info) {
 610                 genl_family_rcv_msg_attrs_free(attrs);
 611                 return -ENOMEM;
 612         }
 613         info->family = ctx->family;
 614         info->op = *ops;
 615         info->attrs = attrs;
 616
 617         cb->data = info;
 618         if (ops->start) {
 619                 if (!ctx->family->parallel_ops)
 620                         genl_lock();
 621                 rc = ops->start(cb);
 622                 if (!ctx->family->parallel_ops)
 623                         genl_unlock();
 624         }
 625
 626         if (rc) {
 627                 genl_family_rcv_msg_attrs_free(info->attrs);
 628                 genl_dumpit_info_free(info);
 629                 cb->data = NULL;
 630         }
 631         return rc;
 632 }
 633
 634 static int genl_lock_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
 635 {
 636         const struct genl_ops *ops = &genl_dumpit_info(cb)->op;
 637         int rc;
 638
 639         genl_lock();
 640         rc = ops->dumpit(skb, cb);
 641         genl_unlock();
 642         return rc;
 643 }
 644
 645 static int genl_lock_done(struct netlink_callback *cb)
 646 {
 647         const struct genl_dumpit_info *info = genl_dumpit_info(cb);
 648         const struct genl_ops *ops = &info->op;
 649         int rc = 0;
 650
 651         if (ops->done) {
 652                 genl_lock();
 653                 rc = ops->done(cb);
 654                 genl_unlock();
 655         }
 656         genl_family_rcv_msg_attrs_free(info->attrs);
 657         genl_dumpit_info_free(info);
 658         return rc;
 659 }
 660
 661 static int genl_parallel_done(struct netlink_callback *cb)
 662 {
 663         const struct genl_dumpit_info *info = genl_dumpit_info(cb);
 664         const struct genl_ops *ops = &info->op;
 665         int rc = 0;
 666
 667         if (ops->done)
 668                 rc = ops->done(cb);
 669         genl_family_rcv_msg_attrs_free(info->attrs);
 670         genl_dumpit_info_free(info);
 671         return rc;
 672 }
 673
 674 static int genl_family_rcv_msg_dumpit(const struct genl_family *family,
 675                                       struct sk_buff *skb,
 676                                       struct nlmsghdr *nlh,
 677                                       struct netlink_ext_ack *extack,
 678                                       const struct genl_ops *ops,
 679                                       int hdrlen, struct net *net)
 680 {
 681         struct genl_start_context ctx;
 682         int err;
 683
 684         if (!ops->dumpit)
 685                 return -EOPNOTSUPP;
 686
 687         ctx.family = family;
 688         ctx.nlh = nlh;
 689         ctx.extack = extack;
 690         ctx.ops = ops;
 691         ctx.hdrlen = hdrlen;
 692
 693         if (!family->parallel_ops) {
 694                 struct netlink_dump_control c = {
 695                         .module = family->module,
 696                         .data = &ctx,
 697                         .start = genl_start,
 698                         .dump = genl_lock_dumpit,
 699                         .done = genl_lock_done,
 700                 };
 701
 702                 genl_unlock();
 703                 err = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
 704                 genl_lock();
 705         } else {
 706                 struct netlink_dump_control c = {
 707                         .module = family->module,
 708                         .data = &ctx,
 709                         .start = genl_start,
 710                         .dump = ops->dumpit,
 711                         .done = genl_parallel_done,
 712                 };
 713
 714                 err = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
 715         }
 716
 717         return err;
 718 }
 719
 720 static int genl_family_rcv_msg_doit(const struct genl_family *family,
 721                                     struct sk_buff *skb,
 722                                     struct nlmsghdr *nlh,
 723                                     struct netlink_ext_ack *extack,
 724                                     const struct genl_ops *ops,
 725                                     int hdrlen, struct net *net)
 726 {
 727         struct nlattr **attrbuf;
 728         struct genl_info info;
 729         int err;
 730
 731         if (!ops->doit)
 732                 return -EOPNOTSUPP;
 733
 734         attrbuf = genl_family_rcv_msg_attrs_parse(family, nlh, extack,
 735                                                   ops, hdrlen,
 736                                                   GENL_DONT_VALIDATE_STRICT);
 737         if (IS_ERR(attrbuf))
 738                 return PTR_ERR(attrbuf);
 739
 740         info.snd_seq = nlh->nlmsg_seq;
 741         info.snd_portid = NETLINK_CB(skb).portid;
 742         info.nlhdr = nlh;
 743         info.genlhdr = nlmsg_data(nlh);
 744         info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
 745         info.attrs = attrbuf;
 746         info.extack = extack;
 747         genl_info_net_set(&info, net);
 748         memset(&info.user_ptr, 0, sizeof(info.user_ptr));
 749
 750         if (family->pre_doit) {
 751                 err = family->pre_doit(ops, skb, &info);
 752                 if (err)
 753                         goto out;
 754         }
 755
 756         err = ops->doit(skb, &info);
 757
 758         if (family->post_doit)
 759                 family->post_doit(ops, skb, &info);
 760
 761 out:
 762         genl_family_rcv_msg_attrs_free(attrbuf);
 763
 764         return err;
 765 }
 766
 767 static int genl_header_check(const struct genl_family *family,
 768                              struct nlmsghdr *nlh, struct genlmsghdr *hdr,
 769                              struct netlink_ext_ack *extack)
 770 {
 771         u16 flags;
 772
 773         /* Only for commands added after we started validating */
 774         if (hdr->cmd < family->resv_start_op)
 775                 return 0;
 776
 777         if (hdr->reserved) {
 778                 NL_SET_ERR_MSG(extack, "genlmsghdr.reserved field is not 0");
 779                 return -EINVAL;
 780         }
 781
 782         /* Old netlink flags have pretty loose semantics, allow only the flags
 783          * consumed by the core where we can enforce the meaning.
 784          */
 785         flags = nlh->nlmsg_flags;
 786         if ((flags & NLM_F_DUMP) == NLM_F_DUMP) /* DUMP is 2 bits */
 787                 flags &= ~NLM_F_DUMP;
 788         if (flags & ~(NLM_F_REQUEST | NLM_F_ACK | NLM_F_ECHO)) {
 789                 NL_SET_ERR_MSG(extack,
 790                                "ambiguous or reserved bits set in nlmsg_flags");
 791                 return -EINVAL;
 792         }
 793
 794         return 0;
 795 }
 796
 797 static int genl_family_rcv_msg(const struct genl_family *family,
 798                                struct sk_buff *skb,
 799                                struct nlmsghdr *nlh,
 800                                struct netlink_ext_ack *extack)
 801 {
 802         struct net *net = sock_net(skb->sk);
 803         struct genlmsghdr *hdr = nlmsg_data(nlh);
 804         struct genl_ops op;
 805         int hdrlen;
 806
 807         /* this family doesn't exist in this netns */
 808         if (!family->netnsok && !net_eq(net, &init_net))
 809                 return -ENOENT;
 810
 811         hdrlen = GENL_HDRLEN + family->hdrsize;
 812         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
 813                 return -EINVAL;
 814
 815         if (genl_header_check(family, nlh, hdr, extack))
 816                 return -EINVAL;
 817
 818         if (genl_get_cmd(hdr->cmd, family, &op))
 819                 return -EOPNOTSUPP;
 820
 821         if ((op.flags & GENL_ADMIN_PERM) &&
 822             !netlink_capable(skb, CAP_NET_ADMIN))
 823                 return -EPERM;
 824
 825         if ((op.flags & GENL_UNS_ADMIN_PERM) &&
 826             !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
 827                 return -EPERM;
 828
 829         if ((nlh->nlmsg_flags & NLM_F_DUMP) == NLM_F_DUMP)
 830                 return genl_family_rcv_msg_dumpit(family, skb, nlh, extack,
 831                                                   &op, hdrlen, net);
 832         else
 833                 return genl_family_rcv_msg_doit(family, skb, nlh, extack,
 834                                                 &op, hdrlen, net);
 835 }
 836
 837 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
 838                         struct netlink_ext_ack *extack)
 839 {
 840         const struct genl_family *family;
 841         int err;
 842
 843         family = genl_family_find_byid(nlh->nlmsg_type);
 844         if (family == NULL)
 845                 return -ENOENT;
 846
 847         if (!family->parallel_ops)
 848                 genl_lock();
 849
 850         err = genl_family_rcv_msg(family, skb, nlh, extack);
 851
 852         if (!family->parallel_ops)
 853                 genl_unlock();
 854
 855         return err;
 856 }
 857
 858 static void genl_rcv(struct sk_buff *skb)
 859 {
 860         down_read(&cb_lock);
 861         netlink_rcv_skb(skb, &genl_rcv_msg);
 862         up_read(&cb_lock);
 863 }
 864
 865 /**************************************************************************
 866  * Controller
 867  **************************************************************************/
 868
 869 static struct genl_family genl_ctrl;
 870
 871 static int ctrl_fill_info(const struct genl_family *family, u32 portid, u32 seq,
 872                           u32 flags, struct sk_buff *skb, u8 cmd)
 873 {
 874         void *hdr;
 875
 876         hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
 877         if (hdr == NULL)
 878                 return -1;
 879
 880         if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
 881             nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) ||
 882             nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) ||
 883             nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) ||
 884             nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr))
 885                 goto nla_put_failure;
 886
 887         if (genl_get_cmd_cnt(family)) {
 888                 struct nlattr *nla_ops;
 889                 int i;
 890
 891                 nla_ops = nla_nest_start_noflag(skb, CTRL_ATTR_OPS);
 892                 if (nla_ops == NULL)
 893                         goto nla_put_failure;
 894
 895                 for (i = 0; i < genl_get_cmd_cnt(family); i++) {
 896                         struct nlattr *nest;
 897                         struct genl_ops op;
 898                         u32 op_flags;
 899
 900                         genl_get_cmd_by_index(i, family, &op);
 901                         op_flags = op.flags;
 902                         if (op.dumpit)
 903                                 op_flags |= GENL_CMD_CAP_DUMP;
 904                         if (op.doit)
 905                                 op_flags |= GENL_CMD_CAP_DO;
 906                         if (op.policy)
 907                                 op_flags |= GENL_CMD_CAP_HASPOL;
 908
 909                         nest = nla_nest_start_noflag(skb, i + 1);
 910                         if (nest == NULL)
 911                                 goto nla_put_failure;
 912
 913                         if (nla_put_u32(skb, CTRL_ATTR_OP_ID, op.cmd) ||
 914                             nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, op_flags))
 915                                 goto nla_put_failure;
 916
 917                         nla_nest_end(skb, nest);
 918                 }
 919
 920                 nla_nest_end(skb, nla_ops);
 921         }
 922
 923         if (family->n_mcgrps) {
 924                 struct nlattr *nla_grps;
 925                 int i;
 926
 927                 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);
 928                 if (nla_grps == NULL)
 929                         goto nla_put_failure;
 930
 931                 for (i = 0; i < family->n_mcgrps; i++) {
 932                         struct nlattr *nest;
 933                         const struct genl_multicast_group *grp;
 934
 935                         grp = &family->mcgrps[i];
 936
 937                         nest = nla_nest_start_noflag(skb, i + 1);
 938                         if (nest == NULL)
 939                                 goto nla_put_failure;
 940
 941                         if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID,
 942                                         family->mcgrp_offset + i) ||
 943                             nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
 944                                            grp->name))
 945                                 goto nla_put_failure;
 946
 947                         nla_nest_end(skb, nest);
 948                 }
 949                 nla_nest_end(skb, nla_grps);
 950         }
 951
 952         genlmsg_end(skb, hdr);
 953         return 0;
 954
 955 nla_put_failure:
 956         genlmsg_cancel(skb, hdr);
 957         return -EMSGSIZE;
 958 }
 959
 960 static int ctrl_fill_mcgrp_info(const struct genl_family *family,
 961                                 const struct genl_multicast_group *grp,
 962                                 int grp_id, u32 portid, u32 seq, u32 flags,
 963                                 struct sk_buff *skb, u8 cmd)
 964 {
 965         void *hdr;
 966         struct nlattr *nla_grps;
 967         struct nlattr *nest;
 968
 969         hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
 970         if (hdr == NULL)
 971                 return -1;
 972
 973         if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
 974             nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id))
 975                 goto nla_put_failure;
 976
 977         nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);
 978         if (nla_grps == NULL)
 979                 goto nla_put_failure;
 980
 981         nest = nla_nest_start_noflag(skb, 1);
 982         if (nest == NULL)
 983                 goto nla_put_failure;
 984
 985         if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp_id) ||
 986             nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
 987                            grp->name))
 988                 goto nla_put_failure;
 989
 990         nla_nest_end(skb, nest);
 991         nla_nest_end(skb, nla_grps);
 992
 993         genlmsg_end(skb, hdr);
 994         return 0;
 995
 996 nla_put_failure:
 997         genlmsg_cancel(skb, hdr);
 998         return -EMSGSIZE;
 999 }
1000
1001 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
1002 {
1003         int n = 0;
1004         struct genl_family *rt;
1005         struct net *net = sock_net(skb->sk);
1006         int fams_to_skip = cb->args[0];
1007         unsigned int id;
1008
1009         idr_for_each_entry(&genl_fam_idr, rt, id) {
1010                 if (!rt->netnsok && !net_eq(net, &init_net))
1011                         continue;
1012
1013                 if (n++ < fams_to_skip)
1014                         continue;
1015
1016                 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid,
1017                                    cb->nlh->nlmsg_seq, NLM_F_MULTI,
1018                                    skb, CTRL_CMD_NEWFAMILY) < 0) {
1019                         n--;
1020                         break;
1021                 }
1022         }
1023
1024         cb->args[0] = n;
1025         return skb->len;
1026 }
1027
1028 static struct sk_buff *ctrl_build_family_msg(const struct genl_family *family,
1029                                              u32 portid, int seq, u8 cmd)
1030 {
1031         struct sk_buff *skb;
1032         int err;
1033
1034         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1035         if (skb == NULL)
1036                 return ERR_PTR(-ENOBUFS);
1037
1038         err = ctrl_fill_info(family, portid, seq, 0, skb, cmd);
1039         if (err < 0) {
1040                 nlmsg_free(skb);
1041                 return ERR_PTR(err);
1042         }
1043
1044         return skb;
1045 }
1046
1047 static struct sk_buff *
1048 ctrl_build_mcgrp_msg(const struct genl_family *family,
1049                      const struct genl_multicast_group *grp,
1050                      int grp_id, u32 portid, int seq, u8 cmd)
1051 {
1052         struct sk_buff *skb;
1053         int err;
1054
1055         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1056         if (skb == NULL)
1057                 return ERR_PTR(-ENOBUFS);
1058
1059         err = ctrl_fill_mcgrp_info(family, grp, grp_id, portid,
1060                                    seq, 0, skb, cmd);
1061         if (err < 0) {
1062                 nlmsg_free(skb);
1063                 return ERR_PTR(err);
1064         }
1065
1066         return skb;
1067 }
1068
1069 static const struct nla_policy ctrl_policy_family[] = {
1070         [CTRL_ATTR_FAMILY_ID]   = { .type = NLA_U16 },
1071         [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
1072                                     .len = GENL_NAMSIZ - 1 },
1073 };
1074
1075 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
1076 {
1077         struct sk_buff *msg;
1078         const struct genl_family *res = NULL;
1079         int err = -EINVAL;
1080
1081         if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
1082                 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
1083                 res = genl_family_find_byid(id);
1084                 err = -ENOENT;
1085         }
1086
1087         if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
1088                 char *name;
1089
1090                 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
1091                 res = genl_family_find_byname(name);
1092 #ifdef CONFIG_MODULES
1093                 if (res == NULL) {
1094                         genl_unlock();
1095                         up_read(&cb_lock);
1096                         request_module("net-pf-%d-proto-%d-family-%s",
1097                                        PF_NETLINK, NETLINK_GENERIC, name);
1098                         down_read(&cb_lock);
1099                         genl_lock();
1100                         res = genl_family_find_byname(name);
1101                 }
1102 #endif
1103                 err = -ENOENT;
1104         }
1105
1106         if (res == NULL)
1107                 return err;
1108
1109         if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) {
1110                 /* family doesn't exist here */
1111                 return -ENOENT;
1112         }
1113
1114         msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq,
1115                                     CTRL_CMD_NEWFAMILY);
1116         if (IS_ERR(msg))
1117                 return PTR_ERR(msg);
1118
1119         return genlmsg_reply(msg, info);
1120 }
1121
1122 static int genl_ctrl_event(int event, const struct genl_family *family,
1123                            const struct genl_multicast_group *grp,
1124                            int grp_id)
1125 {
1126         struct sk_buff *msg;
1127
1128         /* genl is still initialising */
1129         if (!init_net.genl_sock)
1130                 return 0;
1131
1132         switch (event) {
1133         case CTRL_CMD_NEWFAMILY:
1134         case CTRL_CMD_DELFAMILY:
1135                 WARN_ON(grp);
1136                 msg = ctrl_build_family_msg(family, 0, 0, event);
1137                 break;
1138         case CTRL_CMD_NEWMCAST_GRP:
1139         case CTRL_CMD_DELMCAST_GRP:
1140                 BUG_ON(!grp);
1141                 msg = ctrl_build_mcgrp_msg(family, grp, grp_id, 0, 0, event);
1142                 break;
1143         default:
1144                 return -EINVAL;
1145         }
1146
1147         if (IS_ERR(msg))
1148                 return PTR_ERR(msg);
1149
1150         if (!family->netnsok) {
1151                 genlmsg_multicast_netns(&genl_ctrl, &init_net, msg, 0,
1152                                         0, GFP_KERNEL);
1153         } else {
1154                 rcu_read_lock();
1155                 genlmsg_multicast_allns(&genl_ctrl, msg, 0,
1156                                         0, GFP_ATOMIC);
1157                 rcu_read_unlock();
1158         }
1159
1160         return 0;
1161 }
1162
1163 struct ctrl_dump_policy_ctx {
1164         struct netlink_policy_dump_state *state;
1165         const struct genl_family *rt;
1166         unsigned int opidx;
1167         u32 op;
1168         u16 fam_id;
1169         u8 policies:1,
1170            single_op:1;
1171 };
1172
1173 static const struct nla_policy ctrl_policy_policy[] = {
1174         [CTRL_ATTR_FAMILY_ID]   = { .type = NLA_U16 },
1175         [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
1176                                     .len = GENL_NAMSIZ - 1 },
1177         [CTRL_ATTR_OP]          = { .type = NLA_U32 },
1178 };
1179
1180 static int ctrl_dumppolicy_start(struct netlink_callback *cb)
1181 {
1182         const struct genl_dumpit_info *info = genl_dumpit_info(cb);
1183         struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1184         struct nlattr **tb = info->attrs;
1185         const struct genl_family *rt;
1186         struct genl_ops op;
1187         int err, i;
1188
1189         BUILD_BUG_ON(sizeof(*ctx) > sizeof(cb->ctx));
1190
1191         if (!tb[CTRL_ATTR_FAMILY_ID] && !tb[CTRL_ATTR_FAMILY_NAME])
1192                 return -EINVAL;
1193
1194         if (tb[CTRL_ATTR_FAMILY_ID]) {
1195                 ctx->fam_id = nla_get_u16(tb[CTRL_ATTR_FAMILY_ID]);
1196         } else {
1197                 rt = genl_family_find_byname(
1198                         nla_data(tb[CTRL_ATTR_FAMILY_NAME]));
1199                 if (!rt)
1200                         return -ENOENT;
1201                 ctx->fam_id = rt->id;
1202         }
1203
1204         rt = genl_family_find_byid(ctx->fam_id);
1205         if (!rt)
1206                 return -ENOENT;
1207
1208         ctx->rt = rt;
1209
1210         if (tb[CTRL_ATTR_OP]) {
1211                 ctx->single_op = true;
1212                 ctx->op = nla_get_u32(tb[CTRL_ATTR_OP]);
1213
1214                 err = genl_get_cmd(ctx->op, rt, &op);
1215                 if (err) {
1216                         NL_SET_BAD_ATTR(cb->extack, tb[CTRL_ATTR_OP]);
1217                         return err;
1218                 }
1219
1220                 if (!op.policy)
1221                         return -ENODATA;
1222
1223                 return netlink_policy_dump_add_policy(&ctx->state, op.policy,
1224                                                       op.maxattr);
1225         }
1226
1227         for (i = 0; i < genl_get_cmd_cnt(rt); i++) {
1228                 genl_get_cmd_by_index(i, rt, &op);
1229
1230                 if (op.policy) {
1231                         err = netlink_policy_dump_add_policy(&ctx->state,
1232                                                              op.policy,
1233                                                              op.maxattr);
1234                         if (err)
1235                                 goto err_free_state;
1236                 }
1237         }
1238
1239         if (!ctx->state)
1240                 return -ENODATA;
1241         return 0;
1242
1243 err_free_state:
1244         netlink_policy_dump_free(ctx->state);
1245         return err;
1246 }
1247
1248 static void *ctrl_dumppolicy_prep(struct sk_buff *skb,
1249                                   struct netlink_callback *cb)
1250 {
1251         struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1252         void *hdr;
1253
1254         hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
1255                           cb->nlh->nlmsg_seq, &genl_ctrl,
1256                           NLM_F_MULTI, CTRL_CMD_GETPOLICY);
1257         if (!hdr)
1258                 return NULL;
1259
1260         if (nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, ctx->fam_id))
1261                 return NULL;
1262
1263         return hdr;
1264 }
1265
1266 static int ctrl_dumppolicy_put_op(struct sk_buff *skb,
1267                                   struct netlink_callback *cb,
1268                                   struct genl_ops *op)
1269 {
1270         struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1271         struct nlattr *nest_pol, *nest_op;
1272         void *hdr;
1273         int idx;
1274
1275         /* skip if we have nothing to show */
1276         if (!op->policy)
1277                 return 0;
1278         if (!op->doit &&
1279             (!op->dumpit || op->validate & GENL_DONT_VALIDATE_DUMP))
1280                 return 0;
1281
1282         hdr = ctrl_dumppolicy_prep(skb, cb);
1283         if (!hdr)
1284                 return -ENOBUFS;
1285
1286         nest_pol = nla_nest_start(skb, CTRL_ATTR_OP_POLICY);
1287         if (!nest_pol)
1288                 goto err;
1289
1290         nest_op = nla_nest_start(skb, op->cmd);
1291         if (!nest_op)
1292                 goto err;
1293
1294         /* for now both do/dump are always the same */
1295         idx = netlink_policy_dump_get_policy_idx(ctx->state,
1296                                                  op->policy,
1297                                                  op->maxattr);
1298
1299         if (op->doit && nla_put_u32(skb, CTRL_ATTR_POLICY_DO, idx))
1300                 goto err;
1301
1302         if (op->dumpit && !(op->validate & GENL_DONT_VALIDATE_DUMP) &&
1303             nla_put_u32(skb, CTRL_ATTR_POLICY_DUMP, idx))
1304                 goto err;
1305
1306         nla_nest_end(skb, nest_op);
1307         nla_nest_end(skb, nest_pol);
1308         genlmsg_end(skb, hdr);
1309
1310         return 0;
1311 err:
1312         genlmsg_cancel(skb, hdr);
1313         return -ENOBUFS;
1314 }
1315
1316 static int ctrl_dumppolicy(struct sk_buff *skb, struct netlink_callback *cb)
1317 {
1318         struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1319         void *hdr;
1320
1321         if (!ctx->policies) {
1322                 while (ctx->opidx < genl_get_cmd_cnt(ctx->rt)) {
1323                         struct genl_ops op;
1324
1325                         if (ctx->single_op) {
1326                                 int err;
1327
1328                                 err = genl_get_cmd(ctx->op, ctx->rt, &op);
1329                                 if (WARN_ON(err))
1330                                         return skb->len;
1331
1332                                 /* break out of the loop after this one */
1333                                 ctx->opidx = genl_get_cmd_cnt(ctx->rt);
1334                         } else {
1335                                 genl_get_cmd_by_index(ctx->opidx, ctx->rt, &op);
1336                         }
1337
1338                         if (ctrl_dumppolicy_put_op(skb, cb, &op))
1339                                 return skb->len;
1340
1341                         ctx->opidx++;
1342                 }
1343
1344                 /* completed with the per-op policy index list */
1345                 ctx->policies = true;
1346         }
1347
1348         while (netlink_policy_dump_loop(ctx->state)) {
1349                 struct nlattr *nest;
1350
1351                 hdr = ctrl_dumppolicy_prep(skb, cb);
1352                 if (!hdr)
1353                         goto nla_put_failure;
1354
1355                 nest = nla_nest_start(skb, CTRL_ATTR_POLICY);
1356                 if (!nest)
1357                         goto nla_put_failure;
1358
1359                 if (netlink_policy_dump_write(skb, ctx->state))
1360                         goto nla_put_failure;
1361
1362                 nla_nest_end(skb, nest);
1363
1364                 genlmsg_end(skb, hdr);
1365         }
1366
1367         return skb->len;
1368
1369 nla_put_failure:
1370         genlmsg_cancel(skb, hdr);
1371         return skb->len;
1372 }
1373
1374 static int ctrl_dumppolicy_done(struct netlink_callback *cb)
1375 {
1376         struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1377
1378         netlink_policy_dump_free(ctx->state);
1379         return 0;
1380 }
1381
1382 static const struct genl_ops genl_ctrl_ops[] = {
1383         {
1384                 .cmd            = CTRL_CMD_GETFAMILY,
1385                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1386                 .policy         = ctrl_policy_family,
1387                 .maxattr        = ARRAY_SIZE(ctrl_policy_family) - 1,
1388                 .doit           = ctrl_getfamily,
1389                 .dumpit         = ctrl_dumpfamily,
1390         },
1391         {
1392                 .cmd            = CTRL_CMD_GETPOLICY,
1393                 .policy         = ctrl_policy_policy,
1394                 .maxattr        = ARRAY_SIZE(ctrl_policy_policy) - 1,
1395                 .start          = ctrl_dumppolicy_start,
1396                 .dumpit         = ctrl_dumppolicy,
1397                 .done           = ctrl_dumppolicy_done,
1398         },
1399 };
1400
1401 static const struct genl_multicast_group genl_ctrl_groups[] = {
1402         { .name = "notify", },
1403 };
1404
1405 static struct genl_family genl_ctrl __ro_after_init = {
1406         .module = THIS_MODULE,
1407         .ops = genl_ctrl_ops,
1408         .n_ops = ARRAY_SIZE(genl_ctrl_ops),
1409         .resv_start_op = CTRL_CMD_GETPOLICY + 1,
1410         .mcgrps = genl_ctrl_groups,
1411         .n_mcgrps = ARRAY_SIZE(genl_ctrl_groups),
1412         .id = GENL_ID_CTRL,
1413         .name = "nlctrl",
1414         .version = 0x2,
1415         .netnsok = true,
1416 };
1417
1418 static int genl_bind(struct net *net, int group)
1419 {
1420         const struct genl_family *family;
1421         unsigned int id;
1422         int ret = 0;
1423
1424         down_read(&cb_lock);
1425
1426         idr_for_each_entry(&genl_fam_idr, family, id) {
1427                 const struct genl_multicast_group *grp;
1428                 int i;
1429
1430                 if (family->n_mcgrps == 0)
1431                         continue;
1432
1433                 i = group - family->mcgrp_offset;
1434                 if (i < 0 || i >= family->n_mcgrps)
1435                         continue;
1436
1437                 grp = &family->mcgrps[i];
1438                 if ((grp->flags & GENL_UNS_ADMIN_PERM) &&
1439                     !ns_capable(net->user_ns, CAP_NET_ADMIN))
1440                         ret = -EPERM;
1441
1442                 break;
1443         }
1444
1445         up_read(&cb_lock);
1446         return ret;
1447 }
1448
1449 static int __net_init genl_pernet_init(struct net *net)
1450 {
1451         struct netlink_kernel_cfg cfg = {
1452                 .input          = genl_rcv,
1453                 .flags          = NL_CFG_F_NONROOT_RECV,
1454                 .bind           = genl_bind,
1455         };
1456
1457         /* we'll bump the group number right afterwards */
1458         net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg);
1459
1460         if (!net->genl_sock && net_eq(net, &init_net))
1461                 panic("GENL: Cannot initialize generic netlink\n");
1462
1463         if (!net->genl_sock)
1464                 return -ENOMEM;
1465
1466         return 0;
1467 }
1468
1469 static void __net_exit genl_pernet_exit(struct net *net)
1470 {
1471         netlink_kernel_release(net->genl_sock);
1472         net->genl_sock = NULL;
1473 }
1474
1475 static struct pernet_operations genl_pernet_ops = {
1476         .init = genl_pernet_init,
1477         .exit = genl_pernet_exit,
1478 };
1479
1480 static int __init genl_init(void)
1481 {
1482         int err;
1483
1484         err = genl_register_family(&genl_ctrl);
1485         if (err < 0)
1486                 goto problem;
1487
1488         err = register_pernet_subsys(&genl_pernet_ops);
1489         if (err)
1490                 goto problem;
1491
1492         return 0;
1493
1494 problem:
1495         panic("GENL: Cannot register controller: %d\n", err);
1496 }
1497
1498 core_initcall(genl_init);
1499
1500 static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,
1501                          gfp_t flags)
1502 {
1503         struct sk_buff *tmp;
1504         struct net *net, *prev = NULL;
1505         bool delivered = false;
1506         int err;
1507
1508         for_each_net_rcu(net) {
1509                 if (prev) {
1510                         tmp = skb_clone(skb, flags);
1511                         if (!tmp) {
1512                                 err = -ENOMEM;
1513                                 goto error;
1514                         }
1515                         err = nlmsg_multicast(prev->genl_sock, tmp,
1516                                               portid, group, flags);
1517                         if (!err)
1518                                 delivered = true;
1519                         else if (err != -ESRCH)
1520                                 goto error;
1521                 }
1522
1523                 prev = net;
1524         }
1525
1526         err = nlmsg_multicast(prev->genl_sock, skb, portid, group, flags);
1527         if (!err)
1528                 delivered = true;
1529         else if (err != -ESRCH)
1530                 return err;
1531         return delivered ? 0 : -ESRCH;
1532  error:
1533         kfree_skb(skb);
1534         return err;
1535 }
1536
1537 int genlmsg_multicast_allns(const struct genl_family *family,
1538                             struct sk_buff *skb, u32 portid,
1539                             unsigned int group, gfp_t flags)
1540 {
1541         if (WARN_ON_ONCE(group >= family->n_mcgrps))
1542                 return -EINVAL;
1543
1544         group = family->mcgrp_offset + group;
1545         return genlmsg_mcast(skb, portid, group, flags);
1546 }
1547 EXPORT_SYMBOL(genlmsg_multicast_allns);
1548
1549 void genl_notify(const struct genl_family *family, struct sk_buff *skb,
1550                  struct genl_info *info, u32 group, gfp_t flags)
1551 {
1552         struct net *net = genl_info_net(info);
1553         struct sock *sk = net->genl_sock;
1554
1555         if (WARN_ON_ONCE(group >= family->n_mcgrps))
1556                 return;
1557
1558         group = family->mcgrp_offset + group;
1559         nlmsg_notify(sk, skb, info->snd_portid, group,
1560                      nlmsg_report(info->nlhdr), flags);
1561 }
1562 EXPORT_SYMBOL(genl_notify);