[net-next-2.6.git] / net / netlabel / netlabel_mgmt.c

/*
 * NetLabel Management Support
 *
 * This file defines the management functions for the NetLabel system.  The
 * NetLabel system manages static and dynamic label mappings for network
 * protocols such as CIPSO and RIPSO.
 *
 * Author: Paul Moore <paul.moore@hp.com>
 *
 */

/*
 * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
 *
 * This program is free software;  you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY;  without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 * the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program;  if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 */

#include <linux/types.h>
#include <linux/socket.h>
#include <linux/string.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <net/netlink.h>
#include <net/genetlink.h>
#include <net/netlabel.h>
#include <net/cipso_ipv4.h>

#include "netlabel_domainhash.h"
#include "netlabel_user.h"
#include "netlabel_mgmt.h"

/* Argument struct for netlbl_domhsh_walk() */
struct netlbl_domhsh_walk_arg {
	struct netlink_callback *nl_cb;
	struct sk_buff *skb;
	u32 seq;
};

/* NetLabel Generic NETLINK CIPSOv4 family */
static struct genl_family netlbl_mgmt_gnl_family = {
	.id = GENL_ID_GENERATE,
	.hdrsize = 0,
	.name = NETLBL_NLTYPE_MGMT_NAME,
	.version = NETLBL_PROTO_VERSION,
	.maxattr = NLBL_MGMT_A_MAX,
};

/* NetLabel Netlink attribute policy */
static struct nla_policy netlbl_mgmt_genl_policy[NLBL_MGMT_A_MAX + 1] = {
	[NLBL_MGMT_A_DOMAIN] = { .type = NLA_NUL_STRING },
	[NLBL_MGMT_A_PROTOCOL] = { .type = NLA_U32 },
	[NLBL_MGMT_A_VERSION] = { .type = NLA_U32 },
	[NLBL_MGMT_A_CV4DOI] = { .type = NLA_U32 },
};

/*
 * NetLabel Command Handlers
 */

/**
 * netlbl_mgmt_add - Handle an ADD message
 * @skb: the NETLINK buffer
 * @info: the Generic NETLINK info block
 *
 * Description:
 * Process a user generated ADD message and add the domains from the message
 * to the hash table.  See netlabel.h for a description of the message format.
 * Returns zero on success, negative values on failure.
 *
 */
static int netlbl_mgmt_add(struct sk_buff *skb, struct genl_info *info)
{
	int ret_val = -EINVAL;
	struct netlbl_dom_map *entry = NULL;
	size_t tmp_size;
	u32 tmp_val;
	struct netlbl_audit audit_info;

	if (!info->attrs[NLBL_MGMT_A_DOMAIN] ||
	    !info->attrs[NLBL_MGMT_A_PROTOCOL])
		goto add_failure;

	netlbl_netlink_auditinfo(skb, &audit_info);

	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
	if (entry == NULL) {
		ret_val = -ENOMEM;
		goto add_failure;
	}
	tmp_size = nla_len(info->attrs[NLBL_MGMT_A_DOMAIN]);
	entry->domain = kmalloc(tmp_size, GFP_KERNEL);
	if (entry->domain == NULL) {
		ret_val = -ENOMEM;
		goto add_failure;
	}
	entry->type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]);
	nla_strlcpy(entry->domain, info->attrs[NLBL_MGMT_A_DOMAIN], tmp_size);

	switch (entry->type) {
	case NETLBL_NLTYPE_UNLABELED:
		ret_val = netlbl_domhsh_add(entry, &audit_info);
		break;
	case NETLBL_NLTYPE_CIPSOV4:
		if (!info->attrs[NLBL_MGMT_A_CV4DOI])
			goto add_failure;

		tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CV4DOI]);
		/* We should be holding a rcu_read_lock() here while we hold
		 * the result but since the entry will always be deleted when
		 * the CIPSO DOI is deleted we aren't going to keep the
		 * lock. */
		rcu_read_lock();
		entry->type_def.cipsov4 = cipso_v4_doi_getdef(tmp_val);
		if (entry->type_def.cipsov4 == NULL) {
			rcu_read_unlock();
			goto add_failure;
		}
		ret_val = netlbl_domhsh_add(entry, &audit_info);
		rcu_read_unlock();
		break;
	default:
		goto add_failure;
	}
	if (ret_val != 0)
		goto add_failure;

	return 0;

add_failure:
	if (entry)
		kfree(entry->domain);
	kfree(entry);
	return ret_val;
}

/**
 * netlbl_mgmt_remove - Handle a REMOVE message
 * @skb: the NETLINK buffer
 * @info: the Generic NETLINK info block
 *
 * Description:
 * Process a user generated REMOVE message and remove the specified domain
 * mappings.  Returns zero on success, negative values on failure.
 *
 */
static int netlbl_mgmt_remove(struct sk_buff *skb, struct genl_info *info)
{
	char *domain;
	struct netlbl_audit audit_info;

	if (!info->attrs[NLBL_MGMT_A_DOMAIN])
		return -EINVAL;

	netlbl_netlink_auditinfo(skb, &audit_info);

	domain = nla_data(info->attrs[NLBL_MGMT_A_DOMAIN]);
	return netlbl_domhsh_remove(domain, &audit_info);
}

/**
 * netlbl_mgmt_listall_cb - netlbl_domhsh_walk() callback for LISTALL
 * @entry: the domain mapping hash table entry
 * @arg: the netlbl_domhsh_walk_arg structure
 *
 * Description:
 * This function is designed to be used as a callback to the
 * netlbl_domhsh_walk() function for use in generating a response for a LISTALL
 * message.  Returns the size of the message on success, negative values on
 * failure.
 *
 */
static int netlbl_mgmt_listall_cb(struct netlbl_dom_map *entry, void *arg)
{
	int ret_val = -ENOMEM;
	struct netlbl_domhsh_walk_arg *cb_arg = arg;
	void *data;

	data = genlmsg_put(cb_arg->skb, NETLINK_CB(cb_arg->nl_cb->skb).pid,
			   cb_arg->seq, &netlbl_mgmt_gnl_family,
			   NLM_F_MULTI, NLBL_MGMT_C_LISTALL);
	if (data == NULL)
		goto listall_cb_failure;

	ret_val = nla_put_string(cb_arg->skb,
				 NLBL_MGMT_A_DOMAIN,
				 entry->domain);
	if (ret_val != 0)
		goto listall_cb_failure;
	ret_val = nla_put_u32(cb_arg->skb, NLBL_MGMT_A_PROTOCOL, entry->type);
	if (ret_val != 0)
		goto listall_cb_failure;
	switch (entry->type) {
	case NETLBL_NLTYPE_CIPSOV4:
		ret_val = nla_put_u32(cb_arg->skb,
				      NLBL_MGMT_A_CV4DOI,
				      entry->type_def.cipsov4->doi);
		if (ret_val != 0)
			goto listall_cb_failure;
		break;
	}

	cb_arg->seq++;
	return genlmsg_end(cb_arg->skb, data);

listall_cb_failure:
	genlmsg_cancel(cb_arg->skb, data);
	return ret_val;
}

/**
 * netlbl_mgmt_listall - Handle a LISTALL message
 * @skb: the NETLINK buffer
 * @cb: the NETLINK callback
 *
 * Description:
 * Process a user generated LISTALL message and dumps the domain hash table in
 * a form suitable for use in a kernel generated LISTALL message.  Returns zero
 * on success, negative values on failure.
 *
 */
static int netlbl_mgmt_listall(struct sk_buff *skb,
			       struct netlink_callback *cb)
{
	struct netlbl_domhsh_walk_arg cb_arg;
	u32 skip_bkt = cb->args[0];
	u32 skip_chain = cb->args[1];

	cb_arg.nl_cb = cb;
	cb_arg.skb = skb;
	cb_arg.seq = cb->nlh->nlmsg_seq;

	netlbl_domhsh_walk(&skip_bkt,
			   &skip_chain,
			   netlbl_mgmt_listall_cb,
			   &cb_arg);

	cb->args[0] = skip_bkt;
	cb->args[1] = skip_chain;
	return skb->len;
}

/**
 * netlbl_mgmt_adddef - Handle an ADDDEF message
 * @skb: the NETLINK buffer
 * @info: the Generic NETLINK info block
 *
 * Description:
 * Process a user generated ADDDEF message and respond accordingly.  Returns
 * zero on success, negative values on failure.
 *
 */
static int netlbl_mgmt_adddef(struct sk_buff *skb, struct genl_info *info)
{
	int ret_val = -EINVAL;
	struct netlbl_dom_map *entry = NULL;
	u32 tmp_val;
	struct netlbl_audit audit_info;

	if (!info->attrs[NLBL_MGMT_A_PROTOCOL])
		goto adddef_failure;

	netlbl_netlink_auditinfo(skb, &audit_info);

	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
	if (entry == NULL) {
		ret_val = -ENOMEM;
		goto adddef_failure;
	}
	entry->type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]);

	switch (entry->type) {
	case NETLBL_NLTYPE_UNLABELED:
		ret_val = netlbl_domhsh_add_default(entry, &audit_info);
		break;
	case NETLBL_NLTYPE_CIPSOV4:
		if (!info->attrs[NLBL_MGMT_A_CV4DOI])
			goto adddef_failure;

		tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CV4DOI]);
		/* We should be holding a rcu_read_lock() here while we hold
		 * the result but since the entry will always be deleted when
		 * the CIPSO DOI is deleted we aren't going to keep the
		 * lock. */
		rcu_read_lock();
		entry->type_def.cipsov4 = cipso_v4_doi_getdef(tmp_val);
		if (entry->type_def.cipsov4 == NULL) {
			rcu_read_unlock();
			goto adddef_failure;
		}
		ret_val = netlbl_domhsh_add_default(entry, &audit_info);
		rcu_read_unlock();
		break;
	default:
		goto adddef_failure;
	}
	if (ret_val != 0)
		goto adddef_failure;

	return 0;

adddef_failure:
	kfree(entry);
	return ret_val;
}

/**
 * netlbl_mgmt_removedef - Handle a REMOVEDEF message
 * @skb: the NETLINK buffer
 * @info: the Generic NETLINK info block
 *
 * Description:
 * Process a user generated REMOVEDEF message and remove the default domain
 * mapping.  Returns zero on success, negative values on failure.
 *
 */
static int netlbl_mgmt_removedef(struct sk_buff *skb, struct genl_info *info)
{
	struct netlbl_audit audit_info;

	netlbl_netlink_auditinfo(skb, &audit_info);

	return netlbl_domhsh_remove_default(&audit_info);
}

/**
 * netlbl_mgmt_listdef - Handle a LISTDEF message
 * @skb: the NETLINK buffer
 * @info: the Generic NETLINK info block
 *
 * Description:
 * Process a user generated LISTDEF message and dumps the default domain
 * mapping in a form suitable for use in a kernel generated LISTDEF message.
 * Returns zero on success, negative values on failure.
 *
 */
static int netlbl_mgmt_listdef(struct sk_buff *skb, struct genl_info *info)
{
	int ret_val = -ENOMEM;
	struct sk_buff *ans_skb = NULL;
	void *data;
	struct netlbl_dom_map *entry;

	ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (ans_skb == NULL)
		return -ENOMEM;
	data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
				 0, NLBL_MGMT_C_LISTDEF);
	if (data == NULL)
		goto listdef_failure;

	rcu_read_lock();
	entry = netlbl_domhsh_getentry(NULL);
	if (entry == NULL) {
		ret_val = -ENOENT;
		goto listdef_failure_lock;
	}
	ret_val = nla_put_u32(ans_skb, NLBL_MGMT_A_PROTOCOL, entry->type);
	if (ret_val != 0)
		goto listdef_failure_lock;
	switch (entry->type) {
	case NETLBL_NLTYPE_CIPSOV4:
		ret_val = nla_put_u32(ans_skb,
				      NLBL_MGMT_A_CV4DOI,
				      entry->type_def.cipsov4->doi);
		if (ret_val != 0)
			goto listdef_failure_lock;
		break;
	}
	rcu_read_unlock();

	genlmsg_end(ans_skb, data);

	ret_val = genlmsg_reply(ans_skb, info);
	if (ret_val != 0)
		goto listdef_failure;
	return 0;

listdef_failure_lock:
	rcu_read_unlock();
listdef_failure:
	kfree_skb(ans_skb);
	return ret_val;
}

/**
 * netlbl_mgmt_protocols_cb - Write an individual PROTOCOL message response
 * @skb: the skb to write to
 * @seq: the NETLINK sequence number
 * @cb: the NETLINK callback
 * @protocol: the NetLabel protocol to use in the message
 *
 * Description:
 * This function is to be used in conjunction with netlbl_mgmt_protocols() to
 * answer a application's PROTOCOLS message.  Returns the size of the message
 * on success, negative values on failure.
 *
 */
static int netlbl_mgmt_protocols_cb(struct sk_buff *skb,
				    struct netlink_callback *cb,
				    u32 protocol)
{
	int ret_val = -ENOMEM;
	void *data;

	data = genlmsg_put(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
			   &netlbl_mgmt_gnl_family, NLM_F_MULTI,
			   NLBL_MGMT_C_PROTOCOLS);
	if (data == NULL)
		goto protocols_cb_failure;

	ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL, protocol);
	if (ret_val != 0)
		goto protocols_cb_failure;

	return genlmsg_end(skb, data);

protocols_cb_failure:
	genlmsg_cancel(skb, data);
	return ret_val;
}

/**
 * netlbl_mgmt_protocols - Handle a PROTOCOLS message
 * @skb: the NETLINK buffer
 * @cb: the NETLINK callback
 *
 * Description:
 * Process a user generated PROTOCOLS message and respond accordingly.
 *
 */
static int netlbl_mgmt_protocols(struct sk_buff *skb,
				 struct netlink_callback *cb)
{
	u32 protos_sent = cb->args[0];

	if (protos_sent == 0) {
		if (netlbl_mgmt_protocols_cb(skb,
					     cb,
					     NETLBL_NLTYPE_UNLABELED) < 0)
			goto protocols_return;
		protos_sent++;
	}
	if (protos_sent == 1) {
		if (netlbl_mgmt_protocols_cb(skb,
					     cb,
					     NETLBL_NLTYPE_CIPSOV4) < 0)
			goto protocols_return;
		protos_sent++;
	}

protocols_return:
	cb->args[0] = protos_sent;
	return skb->len;
}

/**
 * netlbl_mgmt_version - Handle a VERSION message
 * @skb: the NETLINK buffer
 * @info: the Generic NETLINK info block
 *
 * Description:
 * Process a user generated VERSION message and respond accordingly.  Returns
 * zero on success, negative values on failure.
 *
 */
static int netlbl_mgmt_version(struct sk_buff *skb, struct genl_info *info)
{
	int ret_val = -ENOMEM;
	struct sk_buff *ans_skb = NULL;
	void *data;

	ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (ans_skb == NULL)
		return -ENOMEM;
	data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
				 0, NLBL_MGMT_C_VERSION);
	if (data == NULL)
		goto version_failure;

	ret_val = nla_put_u32(ans_skb,
			      NLBL_MGMT_A_VERSION,
			      NETLBL_PROTO_VERSION);
	if (ret_val != 0)
		goto version_failure;

	genlmsg_end(ans_skb, data);

	ret_val = genlmsg_reply(ans_skb, info);
	if (ret_val != 0)
		goto version_failure;
	return 0;

version_failure:
	kfree_skb(ans_skb);
	return ret_val;
}


/*
 * NetLabel Generic NETLINK Command Definitions
 */

static struct genl_ops netlbl_mgmt_genl_c_add = {
	.cmd = NLBL_MGMT_C_ADD,
	.flags = GENL_ADMIN_PERM,
	.policy = netlbl_mgmt_genl_policy,
	.doit = netlbl_mgmt_add,
	.dumpit = NULL,
};

static struct genl_ops netlbl_mgmt_genl_c_remove = {
	.cmd = NLBL_MGMT_C_REMOVE,
	.flags = GENL_ADMIN_PERM,
	.policy = netlbl_mgmt_genl_policy,
	.doit = netlbl_mgmt_remove,
	.dumpit = NULL,
};

static struct genl_ops netlbl_mgmt_genl_c_listall = {
	.cmd = NLBL_MGMT_C_LISTALL,
	.flags = 0,
	.policy = netlbl_mgmt_genl_policy,
	.doit = NULL,
	.dumpit = netlbl_mgmt_listall,
};

static struct genl_ops netlbl_mgmt_genl_c_adddef = {
	.cmd = NLBL_MGMT_C_ADDDEF,
	.flags = GENL_ADMIN_PERM,
	.policy = netlbl_mgmt_genl_policy,
	.doit = netlbl_mgmt_adddef,
	.dumpit = NULL,
};

static struct genl_ops netlbl_mgmt_genl_c_removedef = {
	.cmd = NLBL_MGMT_C_REMOVEDEF,
	.flags = GENL_ADMIN_PERM,
	.policy = netlbl_mgmt_genl_policy,
	.doit = netlbl_mgmt_removedef,
	.dumpit = NULL,
};

static struct genl_ops netlbl_mgmt_genl_c_listdef = {
	.cmd = NLBL_MGMT_C_LISTDEF,
	.flags = 0,
	.policy = netlbl_mgmt_genl_policy,
	.doit = netlbl_mgmt_listdef,
	.dumpit = NULL,
};

static struct genl_ops netlbl_mgmt_genl_c_protocols = {
	.cmd = NLBL_MGMT_C_PROTOCOLS,
	.flags = 0,
	.policy = netlbl_mgmt_genl_policy,
	.doit = NULL,
	.dumpit = netlbl_mgmt_protocols,
};

static struct genl_ops netlbl_mgmt_genl_c_version = {
	.cmd = NLBL_MGMT_C_VERSION,
	.flags = 0,
	.policy = netlbl_mgmt_genl_policy,
	.doit = netlbl_mgmt_version,
	.dumpit = NULL,
};

/*
 * NetLabel Generic NETLINK Protocol Functions
 */

/**
 * netlbl_mgmt_genl_init - Register the NetLabel management component
 *
 * Description:
 * Register the NetLabel management component with the Generic NETLINK
 * mechanism.  Returns zero on success, negative values on failure.
 *
 */
int netlbl_mgmt_genl_init(void)
{
	int ret_val;

	ret_val = genl_register_family(&netlbl_mgmt_gnl_family);
	if (ret_val != 0)
		return ret_val;

	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
				    &netlbl_mgmt_genl_c_add);
	if (ret_val != 0)
		return ret_val;
	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
				    &netlbl_mgmt_genl_c_remove);
	if (ret_val != 0)
		return ret_val;
	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
				    &netlbl_mgmt_genl_c_listall);
	if (ret_val != 0)
		return ret_val;
	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
				    &netlbl_mgmt_genl_c_adddef);
	if (ret_val != 0)
		return ret_val;
	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
				    &netlbl_mgmt_genl_c_removedef);
	if (ret_val != 0)
		return ret_val;
	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
				    &netlbl_mgmt_genl_c_listdef);
	if (ret_val != 0)
		return ret_val;
	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
				    &netlbl_mgmt_genl_c_protocols);
	if (ret_val != 0)
		return ret_val;
	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
				    &netlbl_mgmt_genl_c_version);
	if (ret_val != 0)
		return ret_val;

	return 0;
}
Commit	Line	Data
d15c345f PM	1	/*
	2	* NetLabel Management Support
	3	*
	4	* This file defines the management functions for the NetLabel system. The
	5	* NetLabel system manages static and dynamic label mappings for network
	6	* protocols such as CIPSO and RIPSO.
	7	*
	8	* Author: Paul Moore <paul.moore@hp.com>
	9	*
	10	*/
	11
	12	/*
	13	* (c) Copyright Hewlett-Packard Development Company, L.P., 2006
	14	*
	15	* This program is free software; you can redistribute it and/or modify
	16	* it under the terms of the GNU General Public License as published by
	17	* the Free Software Foundation; either version 2 of the License, or
	18	* (at your option) any later version.
	19	*
	20	* This program is distributed in the hope that it will be useful,
	21	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	23	* the GNU General Public License for more details.
	24	*
	25	* You should have received a copy of the GNU General Public License
	26	* along with this program; if not, write to the Free Software
	27	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	28	*
	29	*/
	30
	31	#include <linux/types.h>
	32	#include <linux/socket.h>
	33	#include <linux/string.h>
	34	#include <linux/skbuff.h>
	35	#include <net/sock.h>
	36	#include <net/netlink.h>
	37	#include <net/genetlink.h>
	38	#include <net/netlabel.h>
	39	#include <net/cipso_ipv4.h>
	40
	41	#include "netlabel_domainhash.h"
	42	#include "netlabel_user.h"
	43	#include "netlabel_mgmt.h"
	44
fd385855 PM	45	/* Argument struct for netlbl_domhsh_walk() */
	46	struct netlbl_domhsh_walk_arg {
	47	struct netlink_callback *nl_cb;
	48	struct sk_buff *skb;
	49	u32 seq;
	50	};
	51
d15c345f PM	52	/* NetLabel Generic NETLINK CIPSOv4 family */
	53	static struct genl_family netlbl_mgmt_gnl_family = {
	54	.id = GENL_ID_GENERATE,
	55	.hdrsize = 0,
	56	.name = NETLBL_NLTYPE_MGMT_NAME,
	57	.version = NETLBL_PROTO_VERSION,
fd385855	58	.maxattr = NLBL_MGMT_A_MAX,
d15c345f PM	59	};
d15c345f PM	60
fd385855 PM	61	/* NetLabel Netlink attribute policy */
	62	static struct nla_policy netlbl_mgmt_genl_policy[NLBL_MGMT_A_MAX + 1] = {
	63	[NLBL_MGMT_A_DOMAIN] = { .type = NLA_NUL_STRING },
	64	[NLBL_MGMT_A_PROTOCOL] = { .type = NLA_U32 },
	65	[NLBL_MGMT_A_VERSION] = { .type = NLA_U32 },
	66	[NLBL_MGMT_A_CV4DOI] = { .type = NLA_U32 },
	67	};
d15c345f PM	68
	69	/*
	70	* NetLabel Command Handlers
	71	*/
	72
	73	/**
	74	* netlbl_mgmt_add - Handle an ADD message
	75	* @skb: the NETLINK buffer
	76	* @info: the Generic NETLINK info block
	77	*
	78	* Description:
	79	* Process a user generated ADD message and add the domains from the message
	80	* to the hash table. See netlabel.h for a description of the message format.
	81	* Returns zero on success, negative values on failure.
	82	*
	83	*/
	84	static int netlbl_mgmt_add(struct sk_buff skb, struct genl_info info)
	85	{
	86	int ret_val = -EINVAL;
d15c345f	87	struct netlbl_dom_map *entry = NULL;
fd385855	88	size_t tmp_size;
d15c345f	89	u32 tmp_val;
95d4e6be	90	struct netlbl_audit audit_info;
d15c345f	91
fd385855 PM	92	if (!info->attrs[NLBL_MGMT_A_DOMAIN] \|\|
fd385855 PM	93	!info->attrs[NLBL_MGMT_A_PROTOCOL])
d15c345f PM	94	goto add_failure;
d15c345f PM	95
95d4e6be PM	96	netlbl_netlink_auditinfo(skb, &audit_info);
95d4e6be PM	97
fd385855 PM	98	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
	99	if (entry == NULL) {
	100	ret_val = -ENOMEM;
	101	goto add_failure;
	102	}
	103	tmp_size = nla_len(info->attrs[NLBL_MGMT_A_DOMAIN]);
	104	entry->domain = kmalloc(tmp_size, GFP_KERNEL);
	105	if (entry->domain == NULL) {
	106	ret_val = -ENOMEM;
d15c345f	107	goto add_failure;
fd385855 PM	108	}
	109	entry->type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]);
	110	nla_strlcpy(entry->domain, info->attrs[NLBL_MGMT_A_DOMAIN], tmp_size);
d15c345f	111
fd385855 PM	112	switch (entry->type) {
fd385855 PM	113	case NETLBL_NLTYPE_UNLABELED:
95d4e6be	114	ret_val = netlbl_domhsh_add(entry, &audit_info);
fd385855 PM	115	break;
	116	case NETLBL_NLTYPE_CIPSOV4:
	117	if (!info->attrs[NLBL_MGMT_A_CV4DOI])
d15c345f	118	goto add_failure;
d15c345f	119
fd385855 PM	120	tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CV4DOI]);
	121	/* We should be holding a rcu_read_lock() here while we hold
	122	* the result but since the entry will always be deleted when
	123	* the CIPSO DOI is deleted we aren't going to keep the
	124	* lock. */
	125	rcu_read_lock();
	126	entry->type_def.cipsov4 = cipso_v4_doi_getdef(tmp_val);
	127	if (entry->type_def.cipsov4 == NULL) {
d15c345f	128	rcu_read_unlock();
d15c345f	129	goto add_failure;
fd385855	130	}
95d4e6be	131	ret_val = netlbl_domhsh_add(entry, &audit_info);
fd385855 PM	132	rcu_read_unlock();
	133	break;
	134	default:
	135	goto add_failure;
d15c345f	136	}
fd385855 PM	137	if (ret_val != 0)
fd385855 PM	138	goto add_failure;
d15c345f	139
d15c345f PM	140	return 0;
	141
	142	add_failure:
	143	if (entry)
	144	kfree(entry->domain);
	145	kfree(entry);
d15c345f PM	146	return ret_val;
	147	}
	148
	149	/**
	150	* netlbl_mgmt_remove - Handle a REMOVE message
	151	* @skb: the NETLINK buffer
	152	* @info: the Generic NETLINK info block
	153	*
	154	* Description:
	155	* Process a user generated REMOVE message and remove the specified domain
	156	* mappings. Returns zero on success, negative values on failure.
	157	*
	158	*/
	159	static int netlbl_mgmt_remove(struct sk_buff skb, struct genl_info info)
	160	{
fd385855	161	char *domain;
95d4e6be	162	struct netlbl_audit audit_info;
d15c345f	163
fd385855 PM	164	if (!info->attrs[NLBL_MGMT_A_DOMAIN])
fd385855 PM	165	return -EINVAL;
d15c345f	166
95d4e6be PM	167	netlbl_netlink_auditinfo(skb, &audit_info);
95d4e6be PM	168
fd385855	169	domain = nla_data(info->attrs[NLBL_MGMT_A_DOMAIN]);
95d4e6be	170	return netlbl_domhsh_remove(domain, &audit_info);
fd385855 PM	171	}
	172
	173	/**
	174	* netlbl_mgmt_listall_cb - netlbl_domhsh_walk() callback for LISTALL
	175	* @entry: the domain mapping hash table entry
	176	* @arg: the netlbl_domhsh_walk_arg structure
	177	*
	178	* Description:
	179	* This function is designed to be used as a callback to the
	180	* netlbl_domhsh_walk() function for use in generating a response for a LISTALL
	181	* message. Returns the size of the message on success, negative values on
	182	* failure.
	183	*
	184	*/
	185	static int netlbl_mgmt_listall_cb(struct netlbl_dom_map entry, void arg)
	186	{
	187	int ret_val = -ENOMEM;
	188	struct netlbl_domhsh_walk_arg *cb_arg = arg;
	189	void *data;
	190
17c157c8 TG	191	data = genlmsg_put(cb_arg->skb, NETLINK_CB(cb_arg->nl_cb->skb).pid,
	192	cb_arg->seq, &netlbl_mgmt_gnl_family,
	193	NLM_F_MULTI, NLBL_MGMT_C_LISTALL);
fd385855 PM	194	if (data == NULL)
	195	goto listall_cb_failure;
	196
	197	ret_val = nla_put_string(cb_arg->skb,
	198	NLBL_MGMT_A_DOMAIN,
	199	entry->domain);
	200	if (ret_val != 0)
	201	goto listall_cb_failure;
	202	ret_val = nla_put_u32(cb_arg->skb, NLBL_MGMT_A_PROTOCOL, entry->type);
	203	if (ret_val != 0)
	204	goto listall_cb_failure;
	205	switch (entry->type) {
	206	case NETLBL_NLTYPE_CIPSOV4:
	207	ret_val = nla_put_u32(cb_arg->skb,
	208	NLBL_MGMT_A_CV4DOI,
	209	entry->type_def.cipsov4->doi);
d15c345f	210	if (ret_val != 0)
fd385855 PM	211	goto listall_cb_failure;
fd385855 PM	212	break;
d15c345f PM	213	}
d15c345f PM	214
fd385855 PM	215	cb_arg->seq++;
fd385855 PM	216	return genlmsg_end(cb_arg->skb, data);
d15c345f	217
fd385855 PM	218	listall_cb_failure:
fd385855 PM	219	genlmsg_cancel(cb_arg->skb, data);
d15c345f PM	220	return ret_val;
	221	}
	222
	223	/**
fd385855	224	* netlbl_mgmt_listall - Handle a LISTALL message
d15c345f	225	* @skb: the NETLINK buffer
fd385855	226	* @cb: the NETLINK callback
d15c345f PM	227	*
d15c345f PM	228	* Description:
fd385855 PM	229	* Process a user generated LISTALL message and dumps the domain hash table in
	230	* a form suitable for use in a kernel generated LISTALL message. Returns zero
	231	* on success, negative values on failure.
d15c345f PM	232	*
d15c345f PM	233	*/
fd385855 PM	234	static int netlbl_mgmt_listall(struct sk_buff *skb,
fd385855 PM	235	struct netlink_callback *cb)
d15c345f	236	{
fd385855 PM	237	struct netlbl_domhsh_walk_arg cb_arg;
	238	u32 skip_bkt = cb->args[0];
	239	u32 skip_chain = cb->args[1];
	240
	241	cb_arg.nl_cb = cb;
	242	cb_arg.skb = skb;
	243	cb_arg.seq = cb->nlh->nlmsg_seq;
	244
	245	netlbl_domhsh_walk(&skip_bkt,
	246	&skip_chain,
	247	netlbl_mgmt_listall_cb,
	248	&cb_arg);
	249
	250	cb->args[0] = skip_bkt;
	251	cb->args[1] = skip_chain;
	252	return skb->len;
d15c345f PM	253	}
	254
	255	/**
	256	* netlbl_mgmt_adddef - Handle an ADDDEF message
	257	* @skb: the NETLINK buffer
	258	* @info: the Generic NETLINK info block
	259	*
	260	* Description:
	261	* Process a user generated ADDDEF message and respond accordingly. Returns
	262	* zero on success, negative values on failure.
	263	*
	264	*/
	265	static int netlbl_mgmt_adddef(struct sk_buff skb, struct genl_info info)
	266	{
	267	int ret_val = -EINVAL;
d15c345f PM	268	struct netlbl_dom_map *entry = NULL;
d15c345f PM	269	u32 tmp_val;
95d4e6be	270	struct netlbl_audit audit_info;
d15c345f	271
fd385855	272	if (!info->attrs[NLBL_MGMT_A_PROTOCOL])
d15c345f	273	goto adddef_failure;
d15c345f	274
95d4e6be PM	275	netlbl_netlink_auditinfo(skb, &audit_info);
95d4e6be PM	276
d15c345f PM	277	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
	278	if (entry == NULL) {
	279	ret_val = -ENOMEM;
	280	goto adddef_failure;
	281	}
fd385855	282	entry->type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]);
d15c345f	283
d15c345f PM	284	switch (entry->type) {
d15c345f PM	285	case NETLBL_NLTYPE_UNLABELED:
95d4e6be	286	ret_val = netlbl_domhsh_add_default(entry, &audit_info);
d15c345f PM	287	break;
d15c345f PM	288	case NETLBL_NLTYPE_CIPSOV4:
fd385855	289	if (!info->attrs[NLBL_MGMT_A_CV4DOI])
d15c345f	290	goto adddef_failure;
fd385855 PM	291
	292	tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CV4DOI]);
	293	/* We should be holding a rcu_read_lock() here while we hold
	294	* the result but since the entry will always be deleted when
	295	* the CIPSO DOI is deleted we aren't going to keep the
	296	* lock. */
d15c345f PM	297	rcu_read_lock();
	298	entry->type_def.cipsov4 = cipso_v4_doi_getdef(tmp_val);
	299	if (entry->type_def.cipsov4 == NULL) {
	300	rcu_read_unlock();
d15c345f PM	301	goto adddef_failure;
d15c345f PM	302	}
95d4e6be	303	ret_val = netlbl_domhsh_add_default(entry, &audit_info);
d15c345f PM	304	rcu_read_unlock();
	305	break;
	306	default:
fd385855	307	goto adddef_failure;
d15c345f PM	308	}
	309	if (ret_val != 0)
	310	goto adddef_failure;
	311
d15c345f PM	312	return 0;
	313
	314	adddef_failure:
	315	kfree(entry);
d15c345f PM	316	return ret_val;
	317	}
	318
	319	/**
	320	* netlbl_mgmt_removedef - Handle a REMOVEDEF message
	321	* @skb: the NETLINK buffer
	322	* @info: the Generic NETLINK info block
	323	*
	324	* Description:
	325	* Process a user generated REMOVEDEF message and remove the default domain
	326	* mapping. Returns zero on success, negative values on failure.
	327	*
	328	*/
	329	static int netlbl_mgmt_removedef(struct sk_buff skb, struct genl_info info)
	330	{
95d4e6be PM	331	struct netlbl_audit audit_info;
	332
	333	netlbl_netlink_auditinfo(skb, &audit_info);
	334
	335	return netlbl_domhsh_remove_default(&audit_info);
d15c345f PM	336	}
	337
	338	/**
	339	* netlbl_mgmt_listdef - Handle a LISTDEF message
	340	* @skb: the NETLINK buffer
	341	* @info: the Generic NETLINK info block
	342	*
	343	* Description:
	344	* Process a user generated LISTDEF message and dumps the default domain
	345	* mapping in a form suitable for use in a kernel generated LISTDEF message.
	346	* Returns zero on success, negative values on failure.
	347	*
	348	*/
	349	static int netlbl_mgmt_listdef(struct sk_buff skb, struct genl_info info)
	350	{
	351	int ret_val = -ENOMEM;
fd385855 PM	352	struct sk_buff *ans_skb = NULL;
	353	void *data;
	354	struct netlbl_dom_map *entry;
d15c345f	355
339bf98f	356	ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
d15c345f	357	if (ans_skb == NULL)
fd385855	358	return -ENOMEM;
17c157c8 TG	359	data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
17c157c8 TG	360	0, NLBL_MGMT_C_LISTDEF);
fd385855	361	if (data == NULL)
d15c345f	362	goto listdef_failure;
d15c345f	363
fd385855 PM	364	rcu_read_lock();
	365	entry = netlbl_domhsh_getentry(NULL);
	366	if (entry == NULL) {
	367	ret_val = -ENOENT;
	368	goto listdef_failure_lock;
	369	}
	370	ret_val = nla_put_u32(ans_skb, NLBL_MGMT_A_PROTOCOL, entry->type);
d15c345f	371	if (ret_val != 0)
fd385855 PM	372	goto listdef_failure_lock;
	373	switch (entry->type) {
	374	case NETLBL_NLTYPE_CIPSOV4:
	375	ret_val = nla_put_u32(ans_skb,
	376	NLBL_MGMT_A_CV4DOI,
	377	entry->type_def.cipsov4->doi);
	378	if (ret_val != 0)
	379	goto listdef_failure_lock;
	380	break;
	381	}
	382	rcu_read_unlock();
d15c345f	383
fd385855 PM	384	genlmsg_end(ans_skb, data);
fd385855 PM	385
81878d27	386	ret_val = genlmsg_reply(ans_skb, info);
fd385855 PM	387	if (ret_val != 0)
fd385855 PM	388	goto listdef_failure;
d15c345f PM	389	return 0;
d15c345f PM	390
fd385855 PM	391	listdef_failure_lock:
fd385855 PM	392	rcu_read_unlock();
d15c345f	393	listdef_failure:
fd385855	394	kfree_skb(ans_skb);
d15c345f PM	395	return ret_val;
	396	}
	397
	398	/**
fd385855 PM	399	* netlbl_mgmt_protocols_cb - Write an individual PROTOCOL message response
	400	* @skb: the skb to write to
	401	* @seq: the NETLINK sequence number
	402	* @cb: the NETLINK callback
	403	* @protocol: the NetLabel protocol to use in the message
d15c345f PM	404	*
d15c345f PM	405	* Description:
fd385855 PM	406	* This function is to be used in conjunction with netlbl_mgmt_protocols() to
	407	* answer a application's PROTOCOLS message. Returns the size of the message
	408	* on success, negative values on failure.
d15c345f PM	409	*
d15c345f PM	410	*/
fd385855 PM	411	static int netlbl_mgmt_protocols_cb(struct sk_buff *skb,
	412	struct netlink_callback *cb,
	413	u32 protocol)
d15c345f PM	414	{
d15c345f PM	415	int ret_val = -ENOMEM;
fd385855 PM	416	void *data;
fd385855 PM	417
17c157c8 TG	418	data = genlmsg_put(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
	419	&netlbl_mgmt_gnl_family, NLM_F_MULTI,
	420	NLBL_MGMT_C_PROTOCOLS);
fd385855 PM	421	if (data == NULL)
	422	goto protocols_cb_failure;
	423
	424	ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL, protocol);
d15c345f	425	if (ret_val != 0)
fd385855	426	goto protocols_cb_failure;
d15c345f	427
fd385855	428	return genlmsg_end(skb, data);
d15c345f	429
fd385855 PM	430	protocols_cb_failure:
fd385855 PM	431	genlmsg_cancel(skb, data);
d15c345f PM	432	return ret_val;
	433	}
	434
fd385855 PM	435	/**
	436	* netlbl_mgmt_protocols - Handle a PROTOCOLS message
	437	* @skb: the NETLINK buffer
	438	* @cb: the NETLINK callback
	439	*
	440	* Description:
	441	* Process a user generated PROTOCOLS message and respond accordingly.
	442	*
	443	*/
	444	static int netlbl_mgmt_protocols(struct sk_buff *skb,
	445	struct netlink_callback *cb)
	446	{
	447	u32 protos_sent = cb->args[0];
	448
	449	if (protos_sent == 0) {
	450	if (netlbl_mgmt_protocols_cb(skb,
	451	cb,
	452	NETLBL_NLTYPE_UNLABELED) < 0)
	453	goto protocols_return;
	454	protos_sent++;
	455	}
	456	if (protos_sent == 1) {
	457	if (netlbl_mgmt_protocols_cb(skb,
	458	cb,
	459	NETLBL_NLTYPE_CIPSOV4) < 0)
	460	goto protocols_return;
	461	protos_sent++;
	462	}
	463
	464	protocols_return:
	465	cb->args[0] = protos_sent;
	466	return skb->len;
	467	}
	468
d15c345f PM	469	/**
	470	* netlbl_mgmt_version - Handle a VERSION message
	471	* @skb: the NETLINK buffer
	472	* @info: the Generic NETLINK info block
	473	*
	474	* Description:
	475	* Process a user generated VERSION message and respond accordingly. Returns
	476	* zero on success, negative values on failure.
	477	*
	478	*/
	479	static int netlbl_mgmt_version(struct sk_buff skb, struct genl_info info)
	480	{
	481	int ret_val = -ENOMEM;
	482	struct sk_buff *ans_skb = NULL;
fd385855	483	void *data;
d15c345f	484
339bf98f	485	ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
d15c345f	486	if (ans_skb == NULL)
fd385855	487	return -ENOMEM;
17c157c8 TG	488	data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
17c157c8 TG	489	0, NLBL_MGMT_C_VERSION);
fd385855	490	if (data == NULL)
d15c345f PM	491	goto version_failure;
d15c345f PM	492
fd385855 PM	493	ret_val = nla_put_u32(ans_skb,
	494	NLBL_MGMT_A_VERSION,
	495	NETLBL_PROTO_VERSION);
d15c345f PM	496	if (ret_val != 0)
	497	goto version_failure;
	498
fd385855 PM	499	genlmsg_end(ans_skb, data);
fd385855 PM	500
81878d27	501	ret_val = genlmsg_reply(ans_skb, info);
d15c345f PM	502	if (ret_val != 0)
d15c345f PM	503	goto version_failure;
d15c345f PM	504	return 0;
	505
	506	version_failure:
	507	kfree_skb(ans_skb);
d15c345f PM	508	return ret_val;
	509	}
	510
	511
	512	/*
	513	* NetLabel Generic NETLINK Command Definitions
	514	*/
	515
	516	static struct genl_ops netlbl_mgmt_genl_c_add = {
	517	.cmd = NLBL_MGMT_C_ADD,
fd385855 PM	518	.flags = GENL_ADMIN_PERM,
fd385855 PM	519	.policy = netlbl_mgmt_genl_policy,
d15c345f PM	520	.doit = netlbl_mgmt_add,
	521	.dumpit = NULL,
	522	};
	523
	524	static struct genl_ops netlbl_mgmt_genl_c_remove = {
	525	.cmd = NLBL_MGMT_C_REMOVE,
fd385855 PM	526	.flags = GENL_ADMIN_PERM,
fd385855 PM	527	.policy = netlbl_mgmt_genl_policy,
d15c345f PM	528	.doit = netlbl_mgmt_remove,
	529	.dumpit = NULL,
	530	};
	531
fd385855 PM	532	static struct genl_ops netlbl_mgmt_genl_c_listall = {
fd385855 PM	533	.cmd = NLBL_MGMT_C_LISTALL,
d15c345f	534	.flags = 0,
fd385855 PM	535	.policy = netlbl_mgmt_genl_policy,
	536	.doit = NULL,
	537	.dumpit = netlbl_mgmt_listall,
d15c345f PM	538	};
	539
	540	static struct genl_ops netlbl_mgmt_genl_c_adddef = {
	541	.cmd = NLBL_MGMT_C_ADDDEF,
fd385855 PM	542	.flags = GENL_ADMIN_PERM,
fd385855 PM	543	.policy = netlbl_mgmt_genl_policy,
d15c345f PM	544	.doit = netlbl_mgmt_adddef,
	545	.dumpit = NULL,
	546	};
	547
	548	static struct genl_ops netlbl_mgmt_genl_c_removedef = {
	549	.cmd = NLBL_MGMT_C_REMOVEDEF,
fd385855 PM	550	.flags = GENL_ADMIN_PERM,
fd385855 PM	551	.policy = netlbl_mgmt_genl_policy,
d15c345f PM	552	.doit = netlbl_mgmt_removedef,
	553	.dumpit = NULL,
	554	};
	555
	556	static struct genl_ops netlbl_mgmt_genl_c_listdef = {
	557	.cmd = NLBL_MGMT_C_LISTDEF,
	558	.flags = 0,
fd385855	559	.policy = netlbl_mgmt_genl_policy,
d15c345f PM	560	.doit = netlbl_mgmt_listdef,
	561	.dumpit = NULL,
	562	};
	563
fd385855 PM	564	static struct genl_ops netlbl_mgmt_genl_c_protocols = {
fd385855 PM	565	.cmd = NLBL_MGMT_C_PROTOCOLS,
d15c345f	566	.flags = 0,
fd385855 PM	567	.policy = netlbl_mgmt_genl_policy,
	568	.doit = NULL,
	569	.dumpit = netlbl_mgmt_protocols,
d15c345f PM	570	};
	571
	572	static struct genl_ops netlbl_mgmt_genl_c_version = {
	573	.cmd = NLBL_MGMT_C_VERSION,
	574	.flags = 0,
fd385855	575	.policy = netlbl_mgmt_genl_policy,
d15c345f PM	576	.doit = netlbl_mgmt_version,
	577	.dumpit = NULL,
	578	};
	579
	580	/*
	581	* NetLabel Generic NETLINK Protocol Functions
	582	*/
	583
	584	/**
	585	* netlbl_mgmt_genl_init - Register the NetLabel management component
	586	*
	587	* Description:
	588	* Register the NetLabel management component with the Generic NETLINK
	589	* mechanism. Returns zero on success, negative values on failure.
	590	*
	591	*/
	592	int netlbl_mgmt_genl_init(void)
	593	{
	594	int ret_val;
	595
	596	ret_val = genl_register_family(&netlbl_mgmt_gnl_family);
	597	if (ret_val != 0)
	598	return ret_val;
	599
	600	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
	601	&netlbl_mgmt_genl_c_add);
	602	if (ret_val != 0)
	603	return ret_val;
	604	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
	605	&netlbl_mgmt_genl_c_remove);
	606	if (ret_val != 0)
	607	return ret_val;
	608	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
fd385855	609	&netlbl_mgmt_genl_c_listall);
d15c345f PM	610	if (ret_val != 0)
	611	return ret_val;
	612	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
	613	&netlbl_mgmt_genl_c_adddef);
	614	if (ret_val != 0)
	615	return ret_val;
	616	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
	617	&netlbl_mgmt_genl_c_removedef);
	618	if (ret_val != 0)
	619	return ret_val;
	620	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
	621	&netlbl_mgmt_genl_c_listdef);
	622	if (ret_val != 0)
	623	return ret_val;
	624	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
fd385855	625	&netlbl_mgmt_genl_c_protocols);
d15c345f PM	626	if (ret_val != 0)
	627	return ret_val;
	628	ret_val = genl_register_ops(&netlbl_mgmt_gnl_family,
	629	&netlbl_mgmt_genl_c_version);
	630	if (ret_val != 0)
	631	return ret_val;
	632
	633	return 0;
	634	}