[deliverable/linux.git] / security / selinux / netlink.c

/*
 * Netlink event notifications for SELinux.
 *
 * Author: James Morris <jmorris@redhat.com>
 *
 * Copyright (C) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2,
 * as published by the Free Software Foundation.
 */
#include <linux/init.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/stddef.h>
#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/skbuff.h>
#include <linux/netlink.h>
#include <linux/selinux_netlink.h>
#include <net/net_namespace.h>

#include "security.h"

static struct sock *selnl;

static int selnl_msglen(int msgtype)
{
	int ret = 0;

	switch (msgtype) {
	case SELNL_MSG_SETENFORCE:
		ret = sizeof(struct selnl_msg_setenforce);
		break;

	case SELNL_MSG_POLICYLOAD:
		ret = sizeof(struct selnl_msg_policyload);
		break;

	default:
		BUG();
	}
	return ret;
}

static void selnl_add_payload(struct nlmsghdr *nlh, int len, int msgtype, void *data)
{
	switch (msgtype) {
	case SELNL_MSG_SETENFORCE: {
		struct selnl_msg_setenforce *msg = NLMSG_DATA(nlh);

		memset(msg, 0, len);
		msg->val = *((int *)data);
		break;
	}

	case SELNL_MSG_POLICYLOAD: {
		struct selnl_msg_policyload *msg = NLMSG_DATA(nlh);

		memset(msg, 0, len);
		msg->seqno = *((u32 *)data);
		break;
	}

	default:
		BUG();
	}
}

static void selnl_notify(int msgtype, void *data)
{
	int len;
	sk_buff_data_t tmp;
	struct sk_buff *skb;
	struct nlmsghdr *nlh;

	len = selnl_msglen(msgtype);

	skb = alloc_skb(NLMSG_SPACE(len), GFP_USER);
	if (!skb)
		goto oom;

	tmp = skb->tail;
	nlh = NLMSG_PUT(skb, 0, 0, msgtype, len);
	selnl_add_payload(nlh, len, msgtype, data);
	nlh->nlmsg_len = skb->tail - tmp;
	NETLINK_CB(skb).dst_group = SELNLGRP_AVC;
	netlink_broadcast(selnl, skb, 0, SELNLGRP_AVC, GFP_USER);
out:
	return;

nlmsg_failure:
	kfree_skb(skb);
oom:
	printk(KERN_ERR "SELinux:  OOM in %s\n", __func__);
	goto out;
}

void selnl_notify_setenforce(int val)
{
	selnl_notify(SELNL_MSG_SETENFORCE, &val);
}

void selnl_notify_policyload(u32 seqno)
{
	selnl_notify(SELNL_MSG_POLICYLOAD, &seqno);
}

static int __init selnl_init(void)
{
	selnl = netlink_kernel_create(&init_net, NETLINK_SELINUX,
				      SELNLGRP_MAX, NULL, NULL, THIS_MODULE);
	if (selnl == NULL)
		panic("SELinux:  Cannot create netlink socket.");
	netlink_set_nonroot(NETLINK_SELINUX, NL_NONROOT_RECV);
	return 0;
}

__initcall(selnl_init);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Netlink event notifications for SELinux.
	3	*
	4	* Author: James Morris <jmorris@redhat.com>
	5	*
	6	* Copyright (C) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2,
	10	* as published by the Free Software Foundation.
	11	*/
	12	#include <linux/init.h>
	13	#include <linux/types.h>
5a0e3ad6	14	#include <linux/slab.h>
1da177e4 LT	15	#include <linux/stddef.h>
1da177e4 LT	16	#include <linux/kernel.h>
44fc7ea0	17	#include <linux/export.h>
1da177e4 LT	18	#include <linux/skbuff.h>
	19	#include <linux/netlink.h>
	20	#include <linux/selinux_netlink.h>
b4b51029	21	#include <net/net_namespace.h>
1da177e4	22
6a3fbe81 JM	23	#include "security.h"
6a3fbe81 JM	24
1da177e4 LT	25	static struct sock *selnl;
	26
	27	static int selnl_msglen(int msgtype)
	28	{
	29	int ret = 0;
c544c028	30
1da177e4 LT	31	switch (msgtype) {
	32	case SELNL_MSG_SETENFORCE:
	33	ret = sizeof(struct selnl_msg_setenforce);
	34	break;
c544c028	35
1da177e4 LT	36	case SELNL_MSG_POLICYLOAD:
	37	ret = sizeof(struct selnl_msg_policyload);
	38	break;
c544c028	39
1da177e4 LT	40	default:
	41	BUG();
	42	}
	43	return ret;
	44	}
	45
	46	static void selnl_add_payload(struct nlmsghdr nlh, int len, int msgtype, void data)
	47	{
	48	switch (msgtype) {
	49	case SELNL_MSG_SETENFORCE: {
	50	struct selnl_msg_setenforce *msg = NLMSG_DATA(nlh);
c544c028	51
1da177e4 LT	52	memset(msg, 0, len);
	53	msg->val = ((int )data);
	54	break;
	55	}
c544c028	56
1da177e4 LT	57	case SELNL_MSG_POLICYLOAD: {
1da177e4 LT	58	struct selnl_msg_policyload *msg = NLMSG_DATA(nlh);
c544c028	59
1da177e4 LT	60	memset(msg, 0, len);
	61	msg->seqno = ((u32 )data);
	62	break;
	63	}
	64
	65	default:
	66	BUG();
	67	}
	68	}
	69
	70	static void selnl_notify(int msgtype, void *data)
	71	{
	72	int len;
27a884dc	73	sk_buff_data_t tmp;
1da177e4 LT	74	struct sk_buff *skb;
1da177e4 LT	75	struct nlmsghdr *nlh;
c544c028	76
1da177e4	77	len = selnl_msglen(msgtype);
c544c028	78
1da177e4 LT	79	skb = alloc_skb(NLMSG_SPACE(len), GFP_USER);
	80	if (!skb)
	81	goto oom;
	82
	83	tmp = skb->tail;
	84	nlh = NLMSG_PUT(skb, 0, 0, msgtype, len);
	85	selnl_add_payload(nlh, len, msgtype, data);
	86	nlh->nlmsg_len = skb->tail - tmp;
ac6d439d PM	87	NETLINK_CB(skb).dst_group = SELNLGRP_AVC;
ac6d439d PM	88	netlink_broadcast(selnl, skb, 0, SELNLGRP_AVC, GFP_USER);
1da177e4 LT	89	out:
1da177e4 LT	90	return;
c544c028	91
1da177e4 LT	92	nlmsg_failure:
	93	kfree_skb(skb);
	94	oom:
dd6f953a	95	printk(KERN_ERR "SELinux: OOM in %s\n", __func__);
1da177e4 LT	96	goto out;
	97	}
	98
	99	void selnl_notify_setenforce(int val)
	100	{
	101	selnl_notify(SELNL_MSG_SETENFORCE, &val);
	102	}
	103
	104	void selnl_notify_policyload(u32 seqno)
	105	{
	106	selnl_notify(SELNL_MSG_POLICYLOAD, &seqno);
	107	}
	108
	109	static int __init selnl_init(void)
	110	{
b4b51029 EB	111	selnl = netlink_kernel_create(&init_net, NETLINK_SELINUX,
b4b51029 EB	112	SELNLGRP_MAX, NULL, NULL, THIS_MODULE);
1da177e4 LT	113	if (selnl == NULL)
1da177e4 LT	114	panic("SELinux: Cannot create netlink socket.");
c544c028	115	netlink_set_nonroot(NETLINK_SELINUX, NL_NONROOT_RECV);
1da177e4 LT	116	return 0;
	117	}
	118
	119	__initcall(selnl_init);