// SPDX-License-Identifier: GPL-2.0

  /*
   * NETLINK      Generic Netlink Family
   *
   * 		Authors:	Jamal Hadi Salim
   * 				Thomas Graf <tgraf@suug.ch>

   *				Johannes Berg <johannes@sipsolutions.net>

   */

  #include <linux/module.h>
  #include <linux/kernel.h>

  #include <linux/slab.h>

  #include <linux/errno.h>
  #include <linux/types.h>
  #include <linux/socket.h>
  #include <linux/string.h>
  #include <linux/skbuff.h>

  #include <linux/mutex.h>

  #include <linux/bitmap.h>

  #include <linux/rwsem.h>

  #include <linux/idr.h>

  #include <net/sock.h>
  #include <net/genetlink.h>

  static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */

  static DECLARE_RWSEM(cb_lock);

  atomic_t genl_sk_destructing_cnt = ATOMIC_INIT(0);
  DECLARE_WAIT_QUEUE_HEAD(genl_sk_destructing_waitq);

  void genl_lock(void)

  {

  	mutex_lock(&genl_mutex);

  }

  EXPORT_SYMBOL(genl_lock);

  void genl_unlock(void)

  {

  	mutex_unlock(&genl_mutex);

  }

  EXPORT_SYMBOL(genl_unlock);

  static void genl_lock_all(void)
  {
  	down_write(&cb_lock);
  	genl_lock();
  }
  
  static void genl_unlock_all(void)
  {
  	genl_unlock();
  	up_write(&cb_lock);
  }

  static DEFINE_IDR(genl_fam_idr);

  /*
   * Bitmap of multicast groups that are currently in use.
   *
   * To avoid an allocation at boot of just one unsigned long,
   * declare it global instead.
   * Bit 0 is marked as already used since group 0 is invalid.

   * Bit 1 is marked as already used since the drop-monitor code
   * abuses the API and thinks it can statically use group 1.
   * That group will typically conflict with other groups that
   * any proper users use.

   * Bit 16 is marked as used since it's used for generic netlink
   * and the code no longer marks pre-reserved IDs as used.

   * Bit 17 is marked as already used since the VFS quota code
   * also abused this API and relied on family == group ID, we
   * cater to that by giving it a static family and group ID.

   * Bit 18 is marked as already used since the PMCRAID driver
   * did the same thing as the VFS quota code (maybe copied?)

   */

  static unsigned long mc_group_start = 0x3 | BIT(GENL_ID_CTRL) |

  				      BIT(GENL_ID_VFS_DQUOT) |
  				      BIT(GENL_ID_PMCRAID);

  static unsigned long *mc_groups = &mc_group_start;
  static unsigned long mc_groups_longs = 1;

  static int genl_ctrl_event(int event, const struct genl_family *family,

  			   const struct genl_multicast_group *grp,
  			   int grp_id);

  static const struct genl_family *genl_family_find_byid(unsigned int id)

  {

  	return idr_find(&genl_fam_idr, id);

  }

  static const struct genl_family *genl_family_find_byname(char *name)

  {

  	const struct genl_family *family;
  	unsigned int id;

  	idr_for_each_entry(&genl_fam_idr, family, id)
  		if (strcmp(family->name, name) == 0)
  			return family;

  
  	return NULL;
  }

  static int genl_get_cmd_cnt(const struct genl_family *family)
  {
  	return family->n_ops + family->n_small_ops;
  }
  
  static void genl_op_from_full(const struct genl_family *family,
  			      unsigned int i, struct genl_ops *op)
  {
  	*op = family->ops[i];

  
  	if (!op->maxattr)
  		op->maxattr = family->maxattr;
  	if (!op->policy)
  		op->policy = family->policy;

  }

  static int genl_get_cmd_full(u32 cmd, const struct genl_family *family,

  			     struct genl_ops *op)

  {

  	int i;

  	for (i = 0; i < family->n_ops; i++)

  		if (family->ops[i].cmd == cmd) {
  			genl_op_from_full(family, i, op);
  			return 0;
  		}

  	return -ENOENT;
  }
  
  static void genl_op_from_small(const struct genl_family *family,
  			       unsigned int i, struct genl_ops *op)
  {
  	memset(op, 0, sizeof(*op));
  	op->doit	= family->small_ops[i].doit;
  	op->dumpit	= family->small_ops[i].dumpit;
  	op->cmd		= family->small_ops[i].cmd;
  	op->internal_flags = family->small_ops[i].internal_flags;
  	op->flags	= family->small_ops[i].flags;
  	op->validate	= family->small_ops[i].validate;

  
  	op->maxattr = family->maxattr;
  	op->policy = family->policy;

  }

  static int genl_get_cmd_small(u32 cmd, const struct genl_family *family,

  			      struct genl_ops *op)
  {
  	int i;
  
  	for (i = 0; i < family->n_small_ops; i++)
  		if (family->small_ops[i].cmd == cmd) {
  			genl_op_from_small(family, i, op);
  			return 0;
  		}
  
  	return -ENOENT;
  }

  static int genl_get_cmd(u32 cmd, const struct genl_family *family,

  			struct genl_ops *op)
  {
  	if (!genl_get_cmd_full(cmd, family, op))
  		return 0;
  	return genl_get_cmd_small(cmd, family, op);
  }
  
  static void genl_get_cmd_by_index(unsigned int i,
  				  const struct genl_family *family,
  				  struct genl_ops *op)
  {
  	if (i < family->n_ops)
  		genl_op_from_full(family, i, op);
  	else if (i < family->n_ops + family->n_small_ops)
  		genl_op_from_small(family, i - family->n_ops, op);
  	else
  		WARN_ON_ONCE(1);

  }

  static int genl_allocate_reserve_groups(int n_groups, int *first_id)

  {

  	unsigned long *new_groups;

  	int start = 0;
  	int i;
  	int id;
  	bool fits;
  
  	do {
  		if (start == 0)
  			id = find_first_zero_bit(mc_groups,
  						 mc_groups_longs *
  						 BITS_PER_LONG);
  		else
  			id = find_next_zero_bit(mc_groups,
  						mc_groups_longs * BITS_PER_LONG,
  						start);
  
  		fits = true;
  		for (i = id;
  		     i < min_t(int, id + n_groups,
  			       mc_groups_longs * BITS_PER_LONG);
  		     i++) {
  			if (test_bit(i, mc_groups)) {
  				start = i;
  				fits = false;
  				break;
  			}
  		}

  		if (id + n_groups > mc_groups_longs * BITS_PER_LONG) {

  			unsigned long new_longs = mc_groups_longs +
  						  BITS_TO_LONGS(n_groups);
  			size_t nlen = new_longs * sizeof(unsigned long);
  
  			if (mc_groups == &mc_group_start) {
  				new_groups = kzalloc(nlen, GFP_KERNEL);
  				if (!new_groups)
  					return -ENOMEM;
  				mc_groups = new_groups;
  				*mc_groups = mc_group_start;
  			} else {
  				new_groups = krealloc(mc_groups, nlen,
  						      GFP_KERNEL);
  				if (!new_groups)
  					return -ENOMEM;
  				mc_groups = new_groups;
  				for (i = 0; i < BITS_TO_LONGS(n_groups); i++)
  					mc_groups[mc_groups_longs + i] = 0;
  			}
  			mc_groups_longs = new_longs;
  		}
  	} while (!fits);

  	for (i = id; i < id + n_groups; i++)
  		set_bit(i, mc_groups);
  	*first_id = id;
  	return 0;
  }
  
  static struct genl_family genl_ctrl;
  
  static int genl_validate_assign_mc_groups(struct genl_family *family)
  {
  	int first_id;
  	int n_groups = family->n_mcgrps;

  	int err = 0, i;

  	bool groups_allocated = false;
  
  	if (!n_groups)
  		return 0;
  
  	for (i = 0; i < n_groups; i++) {
  		const struct genl_multicast_group *grp = &family->mcgrps[i];
  
  		if (WARN_ON(grp->name[0] == '\0'))
  			return -EINVAL;
  		if (WARN_ON(memchr(grp->name, '\0', GENL_NAMSIZ) == NULL))
  			return -EINVAL;
  	}

  	/* special-case our own group and hacks */

  	if (family == &genl_ctrl) {
  		first_id = GENL_ID_CTRL;
  		BUG_ON(n_groups != 1);
  	} else if (strcmp(family->name, "NET_DM") == 0) {
  		first_id = 1;
  		BUG_ON(n_groups != 1);

  	} else if (family->id == GENL_ID_VFS_DQUOT) {

  		first_id = GENL_ID_VFS_DQUOT;
  		BUG_ON(n_groups != 1);

  	} else if (family->id == GENL_ID_PMCRAID) {
  		first_id = GENL_ID_PMCRAID;
  		BUG_ON(n_groups != 1);

  	} else {
  		groups_allocated = true;
  		err = genl_allocate_reserve_groups(n_groups, &first_id);
  		if (err)
  			return err;

  	}

  	family->mcgrp_offset = first_id;

  	/* if still initializing, can't and don't need to realloc bitmaps */

  	if (!init_net.genl_sock)
  		return 0;

  	if (family->netnsok) {
  		struct net *net;

  		netlink_table_grab();

  		rcu_read_lock();
  		for_each_net_rcu(net) {

  			err = __netlink_change_ngroups(net->genl_sock,

  					mc_groups_longs * BITS_PER_LONG);
  			if (err) {
  				/*
  				 * No need to roll back, can only fail if
  				 * memory allocation fails and then the
  				 * number of _possible_ groups has been
  				 * increased on some sockets which is ok.
  				 */

  				break;

  			}
  		}
  		rcu_read_unlock();

  		netlink_table_ungrab();

  	} else {
  		err = netlink_change_ngroups(init_net.genl_sock,
  					     mc_groups_longs * BITS_PER_LONG);

  	}

  	if (groups_allocated && err) {
  		for (i = 0; i < family->n_mcgrps; i++)
  			clear_bit(family->mcgrp_offset + i, mc_groups);
  	}

  	return err;

  }

  static void genl_unregister_mc_groups(const struct genl_family *family)

  {

  	struct net *net;

  	int i;

  	netlink_table_grab();

  	rcu_read_lock();

  	for_each_net_rcu(net) {
  		for (i = 0; i < family->n_mcgrps; i++)
  			__netlink_clear_multicast_users(
  				net->genl_sock, family->mcgrp_offset + i);
  	}

  	rcu_read_unlock();

  	netlink_table_ungrab();

  	for (i = 0; i < family->n_mcgrps; i++) {
  		int grp_id = family->mcgrp_offset + i;

  		if (grp_id != 1)
  			clear_bit(grp_id, mc_groups);
  		genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, family,
  				&family->mcgrps[i], grp_id);
  	}

  }

  static int genl_validate_ops(const struct genl_family *family)

  {

  	int i, j;

  	if (WARN_ON(family->n_ops && !family->ops) ||
  	    WARN_ON(family->n_small_ops && !family->small_ops))

  		return -EINVAL;

  	for (i = 0; i < genl_get_cmd_cnt(family); i++) {
  		struct genl_ops op;

  		genl_get_cmd_by_index(i, family, &op);
  		if (op.dumpit == NULL && op.doit == NULL)

  			return -EINVAL;

  		for (j = i + 1; j < genl_get_cmd_cnt(family); j++) {
  			struct genl_ops op2;
  
  			genl_get_cmd_by_index(j, family, &op2);
  			if (op.cmd == op2.cmd)

  				return -EINVAL;

  		}

  	}

  	return 0;

  }

  
  /**

   * genl_register_family - register a generic netlink family

   * @family: generic netlink family
   *
   * Registers the specified family after validating it first. Only one
   * family may be registered with the same family name or identifier.

   *

   * The family's ops, multicast groups and module pointer must already
   * be assigned.

   *

   * Return 0 on success or a negative error code.
   */

  int genl_register_family(struct genl_family *family)

  {

  	int err, i;

  	int start = GENL_START_ALLOC, end = GENL_MAX_ID;

  	err = genl_validate_ops(family);
  	if (err)
  		return err;

  	genl_lock_all();

  
  	if (genl_family_find_byname(family->name)) {
  		err = -EEXIST;
  		goto errout_locked;
  	}

  	/*
  	 * Sadly, a few cases need to be special-cased
  	 * due to them having previously abused the API
  	 * and having used their family ID also as their
  	 * multicast group ID, so we use reserved IDs
  	 * for both to be sure we can do that mapping.
  	 */

  	if (family == &genl_ctrl) {

  		/* and this needs to be special for initial family lookups */
  		start = end = GENL_ID_CTRL;
  	} else if (strcmp(family->name, "pmcraid") == 0) {
  		start = end = GENL_ID_PMCRAID;
  	} else if (strcmp(family->name, "VFS_DQUOT") == 0) {
  		start = end = GENL_ID_VFS_DQUOT;

  	}

  	family->id = idr_alloc_cyclic(&genl_fam_idr, family,
  				      start, end + 1, GFP_KERNEL);

  	if (family->id < 0) {
  		err = family->id;

  		goto errout_locked;

  	}

  	err = genl_validate_assign_mc_groups(family);
  	if (err)

  		goto errout_remove;

  	genl_unlock_all();

  	/* send all events */
  	genl_ctrl_event(CTRL_CMD_NEWFAMILY, family, NULL, 0);
  	for (i = 0; i < family->n_mcgrps; i++)
  		genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, family,
  				&family->mcgrps[i], family->mcgrp_offset + i);

  
  	return 0;

  errout_remove:
  	idr_remove(&genl_fam_idr, family->id);

  errout_locked:

  	genl_unlock_all();

  	return err;
  }

  EXPORT_SYMBOL(genl_register_family);

  
  /**
   * genl_unregister_family - unregister generic netlink family
   * @family: generic netlink family
   *
   * Unregisters the specified family.
   *
   * Returns 0 on success or a negative error code.
   */

  int genl_unregister_family(const struct genl_family *family)

  {

  	genl_lock_all();

  	if (!genl_family_find_byid(family->id)) {

  		genl_unlock_all();
  		return -ENOENT;
  	}

  	genl_unregister_mc_groups(family);

  	idr_remove(&genl_fam_idr, family->id);

  	up_write(&cb_lock);
  	wait_event(genl_sk_destructing_waitq,
  		   atomic_read(&genl_sk_destructing_cnt) == 0);
  	genl_unlock();

  	genl_ctrl_event(CTRL_CMD_DELFAMILY, family, NULL, 0);
  
  	return 0;

  }

  EXPORT_SYMBOL(genl_unregister_family);

  /**
   * genlmsg_put - Add generic netlink header to netlink message
   * @skb: socket buffer holding the message

   * @portid: netlink portid the message is addressed to

   * @seq: sequence number (usually the one of the sender)
   * @family: generic netlink family

   * @flags: netlink message flags

   * @cmd: generic netlink command
   *
   * Returns pointer to user specific header
   */

  void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,

  		  const struct genl_family *family, int flags, u8 cmd)

  {
  	struct nlmsghdr *nlh;
  	struct genlmsghdr *hdr;

  	nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN +

  			family->hdrsize, flags);
  	if (nlh == NULL)
  		return NULL;
  
  	hdr = nlmsg_data(nlh);
  	hdr->cmd = cmd;
  	hdr->version = family->version;
  	hdr->reserved = 0;
  
  	return (char *) hdr + GENL_HDRLEN;
  }
  EXPORT_SYMBOL(genlmsg_put);

  static struct genl_dumpit_info *genl_dumpit_info_alloc(void)
  {
  	return kmalloc(sizeof(struct genl_dumpit_info), GFP_KERNEL);
  }
  
  static void genl_dumpit_info_free(const struct genl_dumpit_info *info)
  {
  	kfree(info);
  }

  static struct nlattr **
  genl_family_rcv_msg_attrs_parse(const struct genl_family *family,
  				struct nlmsghdr *nlh,
  				struct netlink_ext_ack *extack,
  				const struct genl_ops *ops,
  				int hdrlen,

  				enum genl_validate_flags no_strict_flag)

  {
  	enum netlink_validation validate = ops->validate & no_strict_flag ?
  					   NL_VALIDATE_LIBERAL :
  					   NL_VALIDATE_STRICT;
  	struct nlattr **attrbuf;
  	int err;

  	if (!ops->maxattr)

  		return NULL;

  	attrbuf = kmalloc_array(ops->maxattr + 1,

  				sizeof(struct nlattr *), GFP_KERNEL);
  	if (!attrbuf)
  		return ERR_PTR(-ENOMEM);

  	err = __nlmsg_parse(nlh, hdrlen, attrbuf, ops->maxattr, ops->policy,
  			    validate, extack);

  	if (err) {

  		kfree(attrbuf);

  		return ERR_PTR(err);
  	}
  	return attrbuf;
  }

  static void genl_family_rcv_msg_attrs_free(struct nlattr **attrbuf)

  {

  	kfree(attrbuf);

  }

  struct genl_start_context {
  	const struct genl_family *family;
  	struct nlmsghdr *nlh;
  	struct netlink_ext_ack *extack;
  	const struct genl_ops *ops;
  	int hdrlen;
  };
  
  static int genl_start(struct netlink_callback *cb)

  {

  	struct genl_start_context *ctx = cb->data;
  	const struct genl_ops *ops = ctx->ops;
  	struct genl_dumpit_info *info;
  	struct nlattr **attrs = NULL;

  	int rc = 0;

  	if (ops->validate & GENL_DONT_VALIDATE_DUMP)
  		goto no_attrs;
  
  	if (ctx->nlh->nlmsg_len < nlmsg_msg_size(ctx->hdrlen))
  		return -EINVAL;
  
  	attrs = genl_family_rcv_msg_attrs_parse(ctx->family, ctx->nlh, ctx->extack,
  						ops, ctx->hdrlen,

  						GENL_DONT_VALIDATE_DUMP_STRICT);

  	if (IS_ERR(attrs))
  		return PTR_ERR(attrs);
  
  no_attrs:
  	info = genl_dumpit_info_alloc();
  	if (!info) {

  		genl_family_rcv_msg_attrs_free(attrs);

  		return -ENOMEM;
  	}
  	info->family = ctx->family;

  	info->op = *ops;

  	info->attrs = attrs;
  
  	cb->data = info;

  	if (ops->start) {

  		if (!ctx->family->parallel_ops)
  			genl_lock();

  		rc = ops->start(cb);

  		if (!ctx->family->parallel_ops)
  			genl_unlock();
  	}
  
  	if (rc) {

  		genl_family_rcv_msg_attrs_free(info->attrs);

  		genl_dumpit_info_free(info);
  		cb->data = NULL;

  	}
  	return rc;
  }

  static int genl_lock_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
  {

  	const struct genl_ops *ops = &genl_dumpit_info(cb)->op;

  	int rc;
  
  	genl_lock();
  	rc = ops->dumpit(skb, cb);
  	genl_unlock();
  	return rc;
  }
  
  static int genl_lock_done(struct netlink_callback *cb)
  {

  	const struct genl_dumpit_info *info = genl_dumpit_info(cb);

  	const struct genl_ops *ops = &info->op;

  	int rc = 0;
  
  	if (ops->done) {
  		genl_lock();
  		rc = ops->done(cb);
  		genl_unlock();
  	}

  	genl_family_rcv_msg_attrs_free(info->attrs);

  	genl_dumpit_info_free(info);
  	return rc;
  }
  
  static int genl_parallel_done(struct netlink_callback *cb)
  {
  	const struct genl_dumpit_info *info = genl_dumpit_info(cb);

  	const struct genl_ops *ops = &info->op;

  	int rc = 0;
  
  	if (ops->done)
  		rc = ops->done(cb);

  	genl_family_rcv_msg_attrs_free(info->attrs);

  	genl_dumpit_info_free(info);

  	return rc;
  }

  static int genl_family_rcv_msg_dumpit(const struct genl_family *family,
  				      struct sk_buff *skb,
  				      struct nlmsghdr *nlh,
  				      struct netlink_ext_ack *extack,
  				      const struct genl_ops *ops,
  				      int hdrlen, struct net *net)

  {

  	struct genl_start_context ctx;

  	int err;

  	if (!ops->dumpit)

  		return -EOPNOTSUPP;

  	ctx.family = family;
  	ctx.nlh = nlh;
  	ctx.extack = extack;
  	ctx.ops = ops;
  	ctx.hdrlen = hdrlen;

  	if (!family->parallel_ops) {
  		struct netlink_dump_control c = {
  			.module = family->module,

  			.data = &ctx,
  			.start = genl_start,

  			.dump = genl_lock_dumpit,
  			.done = genl_lock_done,
  		};

  		genl_unlock();
  		err = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
  		genl_lock();

  	} else {
  		struct netlink_dump_control c = {
  			.module = family->module,

  			.data = &ctx,
  			.start = genl_start,

  			.dump = ops->dumpit,

  			.done = genl_parallel_done,

  		};
  
  		err = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
  	}

  	return err;
  }

  static int genl_family_rcv_msg_doit(const struct genl_family *family,
  				    struct sk_buff *skb,
  				    struct nlmsghdr *nlh,
  				    struct netlink_ext_ack *extack,
  				    const struct genl_ops *ops,
  				    int hdrlen, struct net *net)
  {
  	struct nlattr **attrbuf;
  	struct genl_info info;
  	int err;

  	if (!ops->doit)

  		return -EOPNOTSUPP;

  	attrbuf = genl_family_rcv_msg_attrs_parse(family, nlh, extack,
  						  ops, hdrlen,

  						  GENL_DONT_VALIDATE_STRICT);

  	if (IS_ERR(attrbuf))
  		return PTR_ERR(attrbuf);

  
  	info.snd_seq = nlh->nlmsg_seq;

  	info.snd_portid = NETLINK_CB(skb).portid;

  	info.nlhdr = nlh;
  	info.genlhdr = nlmsg_data(nlh);
  	info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;

  	info.attrs = attrbuf;

  	info.extack = extack;

  	genl_info_net_set(&info, net);

  	memset(&info.user_ptr, 0, sizeof(info.user_ptr));

  	if (family->pre_doit) {
  		err = family->pre_doit(ops, skb, &info);
  		if (err)

  			goto out;

  	}
  
  	err = ops->doit(skb, &info);
  
  	if (family->post_doit)
  		family->post_doit(ops, skb, &info);

  out:

  	genl_family_rcv_msg_attrs_free(attrbuf);

  
  	return err;
  }

  static int genl_family_rcv_msg(const struct genl_family *family,
  			       struct sk_buff *skb,
  			       struct nlmsghdr *nlh,
  			       struct netlink_ext_ack *extack)
  {

  	struct net *net = sock_net(skb->sk);
  	struct genlmsghdr *hdr = nlmsg_data(nlh);

  	struct genl_ops op;

  	int hdrlen;
  
  	/* this family doesn't exist in this netns */
  	if (!family->netnsok && !net_eq(net, &init_net))
  		return -ENOENT;
  
  	hdrlen = GENL_HDRLEN + family->hdrsize;
  	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
  		return -EINVAL;

  	if (genl_get_cmd(hdr->cmd, family, &op))

  		return -EOPNOTSUPP;

  	if ((op.flags & GENL_ADMIN_PERM) &&

  	    !netlink_capable(skb, CAP_NET_ADMIN))
  		return -EPERM;

  	if ((op.flags & GENL_UNS_ADMIN_PERM) &&

  	    !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
  		return -EPERM;
  
  	if ((nlh->nlmsg_flags & NLM_F_DUMP) == NLM_F_DUMP)
  		return genl_family_rcv_msg_dumpit(family, skb, nlh, extack,

  						  &op, hdrlen, net);

  	else
  		return genl_family_rcv_msg_doit(family, skb, nlh, extack,

  						&op, hdrlen, net);

  }

  static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
  			struct netlink_ext_ack *extack)

  {

  	const struct genl_family *family;

  	int err;
  
  	family = genl_family_find_byid(nlh->nlmsg_type);
  	if (family == NULL)
  		return -ENOENT;
  
  	if (!family->parallel_ops)
  		genl_lock();

  	err = genl_family_rcv_msg(family, skb, nlh, extack);

  
  	if (!family->parallel_ops)
  		genl_unlock();

  	return err;

  }

  static void genl_rcv(struct sk_buff *skb)

  {

  	down_read(&cb_lock);

  	netlink_rcv_skb(skb, &genl_rcv_msg);

  	up_read(&cb_lock);

  }
  
  /**************************************************************************
   * Controller
   **************************************************************************/

  static struct genl_family genl_ctrl;

  static int ctrl_fill_info(const struct genl_family *family, u32 portid, u32 seq,

  			  u32 flags, struct sk_buff *skb, u8 cmd)
  {
  	void *hdr;

  	hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);

  	if (hdr == NULL)
  		return -1;

  	if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
  	    nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) ||
  	    nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) ||
  	    nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) ||
  	    nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr))
  		goto nla_put_failure;

  	if (genl_get_cmd_cnt(family)) {

  		struct nlattr *nla_ops;

  		int i;

  		nla_ops = nla_nest_start_noflag(skb, CTRL_ATTR_OPS);

  		if (nla_ops == NULL)

  			goto nla_put_failure;

  		for (i = 0; i < genl_get_cmd_cnt(family); i++) {

  			struct nlattr *nest;

  			struct genl_ops op;
  			u32 op_flags;

  			genl_get_cmd_by_index(i, family, &op);
  			op_flags = op.flags;
  			if (op.dumpit)

  				op_flags |= GENL_CMD_CAP_DUMP;

  			if (op.doit)

  				op_flags |= GENL_CMD_CAP_DO;

  			if (op.policy)

  				op_flags |= GENL_CMD_CAP_HASPOL;

  			nest = nla_nest_start_noflag(skb, i + 1);

  			if (nest == NULL)
  				goto nla_put_failure;

  			if (nla_put_u32(skb, CTRL_ATTR_OP_ID, op.cmd) ||

  			    nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, op_flags))

  				goto nla_put_failure;

  			nla_nest_end(skb, nest);
  		}
  
  		nla_nest_end(skb, nla_ops);
  	}

  	if (family->n_mcgrps) {

  		struct nlattr *nla_grps;

  		int i;

  		nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);

  		if (nla_grps == NULL)
  			goto nla_put_failure;

  		for (i = 0; i < family->n_mcgrps; i++) {

  			struct nlattr *nest;

  			const struct genl_multicast_group *grp;

  			grp = &family->mcgrps[i];

  			nest = nla_nest_start_noflag(skb, i + 1);

  			if (nest == NULL)
  				goto nla_put_failure;

  			if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID,
  					family->mcgrp_offset + i) ||

  			    nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
  					   grp->name))
  				goto nla_put_failure;

  
  			nla_nest_end(skb, nest);
  		}
  		nla_nest_end(skb, nla_grps);
  	}

  	genlmsg_end(skb, hdr);
  	return 0;

  
  nla_put_failure:

  	genlmsg_cancel(skb, hdr);
  	return -EMSGSIZE;

  }

  static int ctrl_fill_mcgrp_info(const struct genl_family *family,

  				const struct genl_multicast_group *grp,
  				int grp_id, u32 portid, u32 seq, u32 flags,
  				struct sk_buff *skb, u8 cmd)

  {
  	void *hdr;
  	struct nlattr *nla_grps;
  	struct nlattr *nest;

  	hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);

  	if (hdr == NULL)
  		return -1;

  	if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
  	    nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id))

  		goto nla_put_failure;

  	nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);

  	if (nla_grps == NULL)
  		goto nla_put_failure;

  	nest = nla_nest_start_noflag(skb, 1);

  	if (nest == NULL)
  		goto nla_put_failure;

  	if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp_id) ||

  	    nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
  			   grp->name))
  		goto nla_put_failure;

  
  	nla_nest_end(skb, nest);
  	nla_nest_end(skb, nla_grps);

  	genlmsg_end(skb, hdr);
  	return 0;

  
  nla_put_failure:

  	genlmsg_cancel(skb, hdr);
  	return -EMSGSIZE;

  }
  
  static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
  {

  	int n = 0;

  	struct genl_family *rt;

  	struct net *net = sock_net(skb->sk);

  	int fams_to_skip = cb->args[0];
  	unsigned int id;

  	idr_for_each_entry(&genl_fam_idr, rt, id) {
  		if (!rt->netnsok && !net_eq(net, &init_net))
  			continue;
  
  		if (n++ < fams_to_skip)
  			continue;

  		if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid,
  				   cb->nlh->nlmsg_seq, NLM_F_MULTI,

  				   skb, CTRL_CMD_NEWFAMILY) < 0) {
  			n--;

  			break;

  		}

  	}

  	cb->args[0] = n;

  	return skb->len;
  }

  static struct sk_buff *ctrl_build_family_msg(const struct genl_family *family,

  					     u32 portid, int seq, u8 cmd)

  {
  	struct sk_buff *skb;
  	int err;

  	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);

  	if (skb == NULL)
  		return ERR_PTR(-ENOBUFS);

  	err = ctrl_fill_info(family, portid, seq, 0, skb, cmd);

  	if (err < 0) {
  		nlmsg_free(skb);
  		return ERR_PTR(err);
  	}
  
  	return skb;
  }

  static struct sk_buff *

  ctrl_build_mcgrp_msg(const struct genl_family *family,

  		     const struct genl_multicast_group *grp,
  		     int grp_id, u32 portid, int seq, u8 cmd)

  {
  	struct sk_buff *skb;
  	int err;
  
  	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  	if (skb == NULL)
  		return ERR_PTR(-ENOBUFS);

  	err = ctrl_fill_mcgrp_info(family, grp, grp_id, portid,
  				   seq, 0, skb, cmd);

  	if (err < 0) {
  		nlmsg_free(skb);
  		return ERR_PTR(err);
  	}
  
  	return skb;
  }

  static const struct nla_policy ctrl_policy_family[] = {

  	[CTRL_ATTR_FAMILY_ID]	= { .type = NLA_U16 },

  	[CTRL_ATTR_FAMILY_NAME]	= { .type = NLA_NUL_STRING,
  				    .len = GENL_NAMSIZ - 1 },

  };
  
  static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
  {
  	struct sk_buff *msg;

  	const struct genl_family *res = NULL;

  	int err = -EINVAL;
  
  	if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
  		u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
  		res = genl_family_find_byid(id);

  		err = -ENOENT;

  	}
  
  	if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {

  		char *name;

  		name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);

  		res = genl_family_find_byname(name);

  #ifdef CONFIG_MODULES
  		if (res == NULL) {
  			genl_unlock();

  			up_read(&cb_lock);

  			request_module("net-pf-%d-proto-%d-family-%s",

  				       PF_NETLINK, NETLINK_GENERIC, name);

  			down_read(&cb_lock);

  			genl_lock();
  			res = genl_family_find_byname(name);
  		}
  #endif

  		err = -ENOENT;

  	}

  	if (res == NULL)
  		return err;
  
  	if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) {
  		/* family doesn't exist here */
  		return -ENOENT;

  	}

  	msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq,

  				    CTRL_CMD_NEWFAMILY);

  	if (IS_ERR(msg))
  		return PTR_ERR(msg);

  	return genlmsg_reply(msg, info);

  }

  static int genl_ctrl_event(int event, const struct genl_family *family,

  			   const struct genl_multicast_group *grp,
  			   int grp_id)

  {
  	struct sk_buff *msg;

  	/* genl is still initialising */
  	if (!init_net.genl_sock)

  		return 0;
  
  	switch (event) {
  	case CTRL_CMD_NEWFAMILY:
  	case CTRL_CMD_DELFAMILY:

  		WARN_ON(grp);

  		msg = ctrl_build_family_msg(family, 0, 0, event);

  		break;
  	case CTRL_CMD_NEWMCAST_GRP:
  	case CTRL_CMD_DELMCAST_GRP:

  		BUG_ON(!grp);

  		msg = ctrl_build_mcgrp_msg(family, grp, grp_id, 0, 0, event);

  		break;

  	default:
  		return -EINVAL;
  	}
  
  	if (IS_ERR(msg))
  		return PTR_ERR(msg);
  
  	if (!family->netnsok) {

  		genlmsg_multicast_netns(&genl_ctrl, &init_net, msg, 0,

  					0, GFP_KERNEL);

  	} else {
  		rcu_read_lock();

  		genlmsg_multicast_allns(&genl_ctrl, msg, 0,

  					0, GFP_ATOMIC);

  		rcu_read_unlock();

  	}
  
  	return 0;
  }

  struct ctrl_dump_policy_ctx {
  	struct netlink_policy_dump_state *state;

  	const struct genl_family *rt;
  	unsigned int opidx;

  	u32 op;

  	u16 fam_id;

  	u8 policies:1,
  	   single_op:1;

  };

  static const struct nla_policy ctrl_policy_policy[] = {
  	[CTRL_ATTR_FAMILY_ID]	= { .type = NLA_U16 },
  	[CTRL_ATTR_FAMILY_NAME]	= { .type = NLA_NUL_STRING,
  				    .len = GENL_NAMSIZ - 1 },

  	[CTRL_ATTR_OP]		= { .type = NLA_U32 },

  };

  static int ctrl_dumppolicy_start(struct netlink_callback *cb)

  {

  	const struct genl_dumpit_info *info = genl_dumpit_info(cb);

  	struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;

  	struct nlattr **tb = info->attrs;

  	const struct genl_family *rt;

  	struct genl_ops op;
  	int err, i;

  	BUILD_BUG_ON(sizeof(*ctx) > sizeof(cb->ctx));

  	if (!tb[CTRL_ATTR_FAMILY_ID] && !tb[CTRL_ATTR_FAMILY_NAME])
  		return -EINVAL;

  	if (tb[CTRL_ATTR_FAMILY_ID]) {
  		ctx->fam_id = nla_get_u16(tb[CTRL_ATTR_FAMILY_ID]);
  	} else {
  		rt = genl_family_find_byname(
  			nla_data(tb[CTRL_ATTR_FAMILY_NAME]));
  		if (!rt)
  			return -ENOENT;
  		ctx->fam_id = rt->id;

  	}

  	rt = genl_family_find_byid(ctx->fam_id);

  	if (!rt)
  		return -ENOENT;

  	ctx->rt = rt;

  	if (tb[CTRL_ATTR_OP]) {
  		ctx->single_op = true;
  		ctx->op = nla_get_u32(tb[CTRL_ATTR_OP]);
  
  		err = genl_get_cmd(ctx->op, rt, &op);
  		if (err) {
  			NL_SET_BAD_ATTR(cb->extack, tb[CTRL_ATTR_OP]);
  			return err;
  		}
  
  		if (!op.policy)
  			return -ENODATA;
  
  		return netlink_policy_dump_add_policy(&ctx->state, op.policy,
  						      op.maxattr);
  	}

  	for (i = 0; i < genl_get_cmd_cnt(rt); i++) {
  		genl_get_cmd_by_index(i, rt, &op);
  
  		if (op.policy) {
  			err = netlink_policy_dump_add_policy(&ctx->state,
  							     op.policy,
  							     op.maxattr);
  			if (err)

  				goto err_free_state;

  		}
  	}

  	if (!ctx->state)
  		return -ENODATA;
  	return 0;

  
  err_free_state:
  	netlink_policy_dump_free(ctx->state);
  	return err;

  }

  static void *ctrl_dumppolicy_prep(struct sk_buff *skb,
  				  struct netlink_callback *cb)
  {
  	struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
  	void *hdr;
  
  	hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
  			  cb->nlh->nlmsg_seq, &genl_ctrl,
  			  NLM_F_MULTI, CTRL_CMD_GETPOLICY);
  	if (!hdr)
  		return NULL;
  
  	if (nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, ctx->fam_id))
  		return NULL;
  
  	return hdr;
  }

  static int ctrl_dumppolicy_put_op(struct sk_buff *skb,
  				  struct netlink_callback *cb,
  			          struct genl_ops *op)
  {
  	struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
  	struct nlattr *nest_pol, *nest_op;
  	void *hdr;
  	int idx;
  
  	/* skip if we have nothing to show */
  	if (!op->policy)
  		return 0;
  	if (!op->doit &&
  	    (!op->dumpit || op->validate & GENL_DONT_VALIDATE_DUMP))
  		return 0;
  
  	hdr = ctrl_dumppolicy_prep(skb, cb);
  	if (!hdr)
  		return -ENOBUFS;
  
  	nest_pol = nla_nest_start(skb, CTRL_ATTR_OP_POLICY);
  	if (!nest_pol)
  		goto err;
  
  	nest_op = nla_nest_start(skb, op->cmd);
  	if (!nest_op)
  		goto err;
  
  	/* for now both do/dump are always the same */
  	idx = netlink_policy_dump_get_policy_idx(ctx->state,
  						 op->policy,
  						 op->maxattr);
  
  	if (op->doit && nla_put_u32(skb, CTRL_ATTR_POLICY_DO, idx))
  		goto err;
  
  	if (op->dumpit && !(op->validate & GENL_DONT_VALIDATE_DUMP) &&
  	    nla_put_u32(skb, CTRL_ATTR_POLICY_DUMP, idx))
  		goto err;
  
  	nla_nest_end(skb, nest_op);
  	nla_nest_end(skb, nest_pol);
  	genlmsg_end(skb, hdr);
  
  	return 0;
  err:
  	genlmsg_cancel(skb, hdr);
  	return -ENOBUFS;
  }

  static int ctrl_dumppolicy(struct sk_buff *skb, struct netlink_callback *cb)
  {
  	struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;

  	void *hdr;
  
  	if (!ctx->policies) {
  		while (ctx->opidx < genl_get_cmd_cnt(ctx->rt)) {
  			struct genl_ops op;

  			if (ctx->single_op) {
  				int err;
  
  				err = genl_get_cmd(ctx->op, ctx->rt, &op);
  				if (WARN_ON(err))
  					return skb->len;
  
  				/* break out of the loop after this one */
  				ctx->opidx = genl_get_cmd_cnt(ctx->rt);
  			} else {
  				genl_get_cmd_by_index(ctx->opidx, ctx->rt, &op);
  			}

  
  			if (ctrl_dumppolicy_put_op(skb, cb, &op))
  				return skb->len;
  
  			ctx->opidx++;
  		}
  
  		/* completed with the per-op policy index list */
  		ctx->policies = true;
  	}

  	while (netlink_policy_dump_loop(ctx->state)) {

  		struct nlattr *nest;

  		hdr = ctrl_dumppolicy_prep(skb, cb);

  		if (!hdr)
  			goto nla_put_failure;

  		nest = nla_nest_start(skb, CTRL_ATTR_POLICY);
  		if (!nest)
  			goto nla_put_failure;

  		if (netlink_policy_dump_write(skb, ctx->state))

  			goto nla_put_failure;
  
  		nla_nest_end(skb, nest);
  
  		genlmsg_end(skb, hdr);

  	}

  	return skb->len;

  
  nla_put_failure:
  	genlmsg_cancel(skb, hdr);
  	return skb->len;

  }

  static int ctrl_dumppolicy_done(struct netlink_callback *cb)
  {

  	struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
  
  	netlink_policy_dump_free(ctx->state);

  	return 0;
  }

  static const struct genl_ops genl_ctrl_ops[] = {

  	{
  		.cmd		= CTRL_CMD_GETFAMILY,

  		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,

  		.policy		= ctrl_policy_family,
  		.maxattr	= ARRAY_SIZE(ctrl_policy_family) - 1,

  		.doit		= ctrl_getfamily,
  		.dumpit		= ctrl_dumpfamily,

  	},

  	{
  		.cmd		= CTRL_CMD_GETPOLICY,

  		.policy		= ctrl_policy_policy,
  		.maxattr	= ARRAY_SIZE(ctrl_policy_policy) - 1,

  		.start		= ctrl_dumppolicy_start,

  		.dumpit		= ctrl_dumppolicy,

  		.done		= ctrl_dumppolicy_done,

  	},

  };

  static const struct genl_multicast_group genl_ctrl_groups[] = {

  	{ .name = "notify", },

  };

  static struct genl_family genl_ctrl __ro_after_init = {

  	.module = THIS_MODULE,
  	.ops = genl_ctrl_ops,
  	.n_ops = ARRAY_SIZE(genl_ctrl_ops),
  	.mcgrps = genl_ctrl_groups,
  	.n_mcgrps = ARRAY_SIZE(genl_ctrl_groups),
  	.id = GENL_ID_CTRL,
  	.name = "nlctrl",
  	.version = 0x2,

  	.netnsok = true,
  };

  static int genl_bind(struct net *net, int group)
  {
  	const struct genl_family *family;
  	unsigned int id;
  	int ret = 0;
  
  	genl_lock_all();
  
  	idr_for_each_entry(&genl_fam_idr, family, id) {
  		const struct genl_multicast_group *grp;
  		int i;
  
  		if (family->n_mcgrps == 0)
  			continue;
  
  		i = group - family->mcgrp_offset;
  		if (i < 0 || i >= family->n_mcgrps)
  			continue;
  
  		grp = &family->mcgrps[i];
  		if ((grp->flags & GENL_UNS_ADMIN_PERM) &&
  		    !ns_capable(net->user_ns, CAP_NET_ADMIN))
  			ret = -EPERM;
  
  		break;
  	}
  
  	genl_unlock_all();
  	return ret;
  }

  static int __net_init genl_pernet_init(struct net *net)
  {

  	struct netlink_kernel_cfg cfg = {
  		.input		= genl_rcv,

  		.flags		= NL_CFG_F_NONROOT_RECV,

  		.bind		= genl_bind,

  	};

  	/* we'll bump the group number right afterwards */

  	net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg);

  
  	if (!net->genl_sock && net_eq(net, &init_net))
  		panic("GENL: Cannot initialize generic netlink
  ");
  
  	if (!net->genl_sock)
  		return -ENOMEM;
  
  	return 0;
  }
  
  static void __net_exit genl_pernet_exit(struct net *net)
  {
  	netlink_kernel_release(net->genl_sock);
  	net->genl_sock = NULL;
  }
  
  static struct pernet_operations genl_pernet_ops = {
  	.init = genl_pernet_init,
  	.exit = genl_pernet_exit,
  };

  static int __init genl_init(void)
  {

  	int err;

  	err = genl_register_family(&genl_ctrl);

  	if (err < 0)

  		goto problem;

  	err = register_pernet_subsys(&genl_pernet_ops);
  	if (err)
  		goto problem;

  
  	return 0;

  problem:

  	panic("GENL: Cannot register controller: %d
  ", err);

  }

  core_initcall(genl_init);

  static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,

  			 gfp_t flags)
  {
  	struct sk_buff *tmp;
  	struct net *net, *prev = NULL;

  	bool delivered = false;

  	int err;
  
  	for_each_net_rcu(net) {
  		if (prev) {
  			tmp = skb_clone(skb, flags);
  			if (!tmp) {
  				err = -ENOMEM;
  				goto error;
  			}
  			err = nlmsg_multicast(prev->genl_sock, tmp,

  					      portid, group, flags);

  			if (!err)
  				delivered = true;
  			else if (err != -ESRCH)

  				goto error;
  		}
  
  		prev = net;
  	}

  	err = nlmsg_multicast(prev->genl_sock, skb, portid, group, flags);
  	if (!err)
  		delivered = true;
  	else if (err != -ESRCH)

  		return err;

  	return delivered ? 0 : -ESRCH;

   error:
  	kfree_skb(skb);
  	return err;
  }

  int genlmsg_multicast_allns(const struct genl_family *family,
  			    struct sk_buff *skb, u32 portid,
  			    unsigned int group, gfp_t flags)

  {

  	if (WARN_ON_ONCE(group >= family->n_mcgrps))

  		return -EINVAL;

  	group = family->mcgrp_offset + group;

  	return genlmsg_mcast(skb, portid, group, flags);

  }
  EXPORT_SYMBOL(genlmsg_multicast_allns);

  void genl_notify(const struct genl_family *family, struct sk_buff *skb,

  		 struct genl_info *info, u32 group, gfp_t flags)

  {

  	struct net *net = genl_info_net(info);

  	struct sock *sk = net->genl_sock;

  	if (WARN_ON_ONCE(group >= family->n_mcgrps))

  		return;

  	group = family->mcgrp_offset + group;

  	nlmsg_notify(sk, skb, info->snd_portid, group,
  		     nlmsg_report(info->nlhdr), flags);

  }
  EXPORT_SYMBOL(genl_notify);