[linux-block.git] / security / selinux / netlink.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Netlink event notifications for SELinux.
 *
 * Author: James Morris <jmorris@redhat.com>
 *
 * Copyright (C) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
 */
#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/selinux_netlink.h>
#include <net/net_namespace.h>
#include <net/netlink.h>

#include "security.h"

static struct sock *selnl __ro_after_init;

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 = nlmsg_new(len, GFP_USER);
	if (!skb)
		goto oom;

	tmp = skb->tail;
	nlh = nlmsg_put(skb, 0, 0, msgtype, len, 0);
	if (!nlh)
		goto out_kfree_skb;
	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;

out_kfree_skb:
	kfree_skb(skb);
oom:
	pr_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)
{
	struct netlink_kernel_cfg cfg = {
		.groups	= SELNLGRP_MAX,
		.flags	= NL_CFG_F_NONROOT_RECV,
	};

	selnl = netlink_kernel_create(&init_net, NETLINK_SELINUX, &cfg);
	if (selnl == NULL)
		panic("SELinux:  Cannot create netlink socket.");
	return 0;
}

__initcall(selnl_init);
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
1da177e4 LT	2	/*
	3	* Netlink event notifications for SELinux.
	4	*
	5	* Author: James Morris <jmorris@redhat.com>
	6	*
	7	* Copyright (C) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
1da177e4 LT	8	*/
	9	#include <linux/init.h>
	10	#include <linux/types.h>
5a0e3ad6	11	#include <linux/slab.h>
1da177e4 LT	12	#include <linux/stddef.h>
1da177e4 LT	13	#include <linux/kernel.h>
44fc7ea0	14	#include <linux/export.h>
1da177e4	15	#include <linux/skbuff.h>
1da177e4	16	#include <linux/selinux_netlink.h>
b4b51029	17	#include <net/net_namespace.h>
01f534d0	18	#include <net/netlink.h>
1da177e4	19
6a3fbe81 JM	20	#include "security.h"
6a3fbe81 JM	21
cd2bb4cb	22	static struct sock *selnl __ro_after_init;
1da177e4 LT	23
	24	static int selnl_msglen(int msgtype)
	25	{
	26	int ret = 0;
c544c028	27
1da177e4 LT	28	switch (msgtype) {
	29	case SELNL_MSG_SETENFORCE:
	30	ret = sizeof(struct selnl_msg_setenforce);
	31	break;
c544c028	32
1da177e4 LT	33	case SELNL_MSG_POLICYLOAD:
	34	ret = sizeof(struct selnl_msg_policyload);
	35	break;
c544c028	36
1da177e4 LT	37	default:
	38	BUG();
	39	}
	40	return ret;
	41	}
	42
	43	static void selnl_add_payload(struct nlmsghdr nlh, int len, int msgtype, void data)
	44	{
	45	switch (msgtype) {
	46	case SELNL_MSG_SETENFORCE: {
01f534d0	47	struct selnl_msg_setenforce *msg = nlmsg_data(nlh);
c544c028	48
1da177e4 LT	49	memset(msg, 0, len);
	50	msg->val = ((int )data);
	51	break;
	52	}
c544c028	53
1da177e4	54	case SELNL_MSG_POLICYLOAD: {
01f534d0	55	struct selnl_msg_policyload *msg = nlmsg_data(nlh);
c544c028	56
1da177e4 LT	57	memset(msg, 0, len);
	58	msg->seqno = ((u32 )data);
	59	break;
	60	}
	61
	62	default:
	63	BUG();
	64	}
	65	}
	66
	67	static void selnl_notify(int msgtype, void *data)
	68	{
	69	int len;
27a884dc	70	sk_buff_data_t tmp;
1da177e4 LT	71	struct sk_buff *skb;
1da177e4 LT	72	struct nlmsghdr *nlh;
c544c028	73
1da177e4	74	len = selnl_msglen(msgtype);
c544c028	75
77954983	76	skb = nlmsg_new(len, GFP_USER);
1da177e4 LT	77	if (!skb)
	78	goto oom;
	79
	80	tmp = skb->tail;
01f534d0 DM	81	nlh = nlmsg_put(skb, 0, 0, msgtype, len, 0);
	82	if (!nlh)
	83	goto out_kfree_skb;
1da177e4 LT	84	selnl_add_payload(nlh, len, msgtype, data);
1da177e4 LT	85	nlh->nlmsg_len = skb->tail - tmp;
ac6d439d PM	86	NETLINK_CB(skb).dst_group = SELNLGRP_AVC;
ac6d439d PM	87	netlink_broadcast(selnl, skb, 0, SELNLGRP_AVC, GFP_USER);
1da177e4 LT	88	out:
1da177e4 LT	89	return;
c544c028	90
01f534d0	91	out_kfree_skb:
1da177e4 LT	92	kfree_skb(skb);
1da177e4 LT	93	oom:
d85a7833	94	pr_err("SELinux: OOM in %s\n", __func__);
1da177e4 LT	95	goto out;
	96	}
	97
	98	void selnl_notify_setenforce(int val)
	99	{
	100	selnl_notify(SELNL_MSG_SETENFORCE, &val);
	101	}
	102
	103	void selnl_notify_policyload(u32 seqno)
	104	{
	105	selnl_notify(SELNL_MSG_POLICYLOAD, &seqno);
	106	}
	107
	108	static int __init selnl_init(void)
	109	{
a31f2d17 PNA	110	struct netlink_kernel_cfg cfg = {
a31f2d17 PNA	111	.groups = SELNLGRP_MAX,
9785e10a	112	.flags = NL_CFG_F_NONROOT_RECV,
a31f2d17 PNA	113	};
a31f2d17 PNA	114
9f00d977	115	selnl = netlink_kernel_create(&init_net, NETLINK_SELINUX, &cfg);
1da177e4 LT	116	if (selnl == NULL)
1da177e4 LT	117	panic("SELinux: Cannot create netlink socket.");
1da177e4 LT	118	return 0;
	119	}
	120
	121	__initcall(selnl_init);