[linux.git] / net / ipv4 / raw_diag.c

#include <linux/module.h>

#include <linux/inet_diag.h>
#include <linux/sock_diag.h>

#include <net/inet_sock.h>
#include <net/raw.h>
#include <net/rawv6.h>

#ifdef pr_fmt
# undef pr_fmt
#endif

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

static struct raw_hashinfo *
raw_get_hashinfo(const struct inet_diag_req_v2 *r)
{
	if (r->sdiag_family == AF_INET) {
		return &raw_v4_hashinfo;
#if IS_ENABLED(CONFIG_IPV6)
	} else if (r->sdiag_family == AF_INET6) {
		return &raw_v6_hashinfo;
#endif
	} else {
		pr_warn_once("Unexpected inet family %d\n",
			     r->sdiag_family);
		WARN_ON_ONCE(1);
		return ERR_PTR(-EINVAL);
	}
}

/*
 * Due to requirement of not breaking user API we can't simply
 * rename @pad field in inet_diag_req_v2 structure, instead
 * use helper to figure it out.
 */

static struct sock *raw_lookup(struct net *net, struct sock *from,
			       const struct inet_diag_req_v2 *req)
{
	struct inet_diag_req_raw *r = (void *)req;
	struct sock *sk = NULL;

	if (r->sdiag_family == AF_INET)
		sk = __raw_v4_lookup(net, from, r->sdiag_raw_protocol,
				     r->id.idiag_dst[0],
				     r->id.idiag_src[0],
				     r->id.idiag_if, 0);
#if IS_ENABLED(CONFIG_IPV6)
	else
		sk = __raw_v6_lookup(net, from, r->sdiag_raw_protocol,
				     (const struct in6_addr *)r->id.idiag_src,
				     (const struct in6_addr *)r->id.idiag_dst,
				     r->id.idiag_if, 0);
#endif
	return sk;
}

static struct sock *raw_sock_get(struct net *net, const struct inet_diag_req_v2 *r)
{
	struct raw_hashinfo *hashinfo = raw_get_hashinfo(r);
	struct sock *sk = NULL, *s;
	int slot;

	if (IS_ERR(hashinfo))
		return ERR_CAST(hashinfo);

	read_lock(&hashinfo->lock);
	for (slot = 0; slot < RAW_HTABLE_SIZE; slot++) {
		sk_for_each(s, &hashinfo->ht[slot]) {
			sk = raw_lookup(net, s, r);
			if (sk) {
				/*
				 * Grab it and keep until we fill
				 * diag meaage to be reported, so
				 * caller should call sock_put then.
				 * We can do that because we're keeping
				 * hashinfo->lock here.
				 */
				sock_hold(sk);
				goto out_unlock;
			}
		}
	}
out_unlock:
	read_unlock(&hashinfo->lock);

	return sk ? sk : ERR_PTR(-ENOENT);
}

static int raw_diag_dump_one(struct sk_buff *in_skb,
			     const struct nlmsghdr *nlh,
			     const struct inet_diag_req_v2 *r)
{
	struct net *net = sock_net(in_skb->sk);
	struct sk_buff *rep;
	struct sock *sk;
	int err;

	sk = raw_sock_get(net, r);
	if (IS_ERR(sk))
		return PTR_ERR(sk);

	rep = nlmsg_new(sizeof(struct inet_diag_msg) +
			sizeof(struct inet_diag_meminfo) + 64,
			GFP_KERNEL);
	if (!rep) {
		sock_put(sk);
		return -ENOMEM;
	}

	err = inet_sk_diag_fill(sk, NULL, rep, r,
				sk_user_ns(NETLINK_CB(in_skb).sk),
				NETLINK_CB(in_skb).portid,
				nlh->nlmsg_seq, 0, nlh,
				netlink_net_capable(in_skb, CAP_NET_ADMIN));
	sock_put(sk);

	if (err < 0) {
		kfree_skb(rep);
		return err;
	}

	err = netlink_unicast(net->diag_nlsk, rep,
			      NETLINK_CB(in_skb).portid,
			      MSG_DONTWAIT);
	if (err > 0)
		err = 0;
	return err;
}

static int sk_diag_dump(struct sock *sk, struct sk_buff *skb,
			struct netlink_callback *cb,
			const struct inet_diag_req_v2 *r,
			struct nlattr *bc, bool net_admin)
{
	if (!inet_diag_bc_sk(bc, sk))
		return 0;

	return inet_sk_diag_fill(sk, NULL, skb, r,
				 sk_user_ns(NETLINK_CB(cb->skb).sk),
				 NETLINK_CB(cb->skb).portid,
				 cb->nlh->nlmsg_seq, NLM_F_MULTI,
				 cb->nlh, net_admin);
}

static void raw_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
			  const struct inet_diag_req_v2 *r, struct nlattr *bc)
{
	bool net_admin = netlink_net_capable(cb->skb, CAP_NET_ADMIN);
	struct raw_hashinfo *hashinfo = raw_get_hashinfo(r);
	struct net *net = sock_net(skb->sk);
	int num, s_num, slot, s_slot;
	struct sock *sk = NULL;

	if (IS_ERR(hashinfo))
		return;

	s_slot = cb->args[0];
	num = s_num = cb->args[1];

	read_lock(&hashinfo->lock);
	for (slot = s_slot; slot < RAW_HTABLE_SIZE; s_num = 0, slot++) {
		num = 0;

		sk_for_each(sk, &hashinfo->ht[slot]) {
			struct inet_sock *inet = inet_sk(sk);

			if (!net_eq(sock_net(sk), net))
				continue;
			if (num < s_num)
				goto next;
			if (sk->sk_family != r->sdiag_family)
				goto next;
			if (r->id.idiag_sport != inet->inet_sport &&
			    r->id.idiag_sport)
				goto next;
			if (r->id.idiag_dport != inet->inet_dport &&
			    r->id.idiag_dport)
				goto next;
			if (sk_diag_dump(sk, skb, cb, r, bc, net_admin) < 0)
				goto out_unlock;
next:
			num++;
		}
	}

out_unlock:
	read_unlock(&hashinfo->lock);

	cb->args[0] = slot;
	cb->args[1] = num;
}

static void raw_diag_get_info(struct sock *sk, struct inet_diag_msg *r,
			      void *info)
{
	r->idiag_rqueue = sk_rmem_alloc_get(sk);
	r->idiag_wqueue = sk_wmem_alloc_get(sk);
}

#ifdef CONFIG_INET_DIAG_DESTROY
static int raw_diag_destroy(struct sk_buff *in_skb,
			    const struct inet_diag_req_v2 *r)
{
	struct net *net = sock_net(in_skb->sk);
	struct sock *sk;
	int err;

	sk = raw_sock_get(net, r);
	if (IS_ERR(sk))
		return PTR_ERR(sk);
	err = sock_diag_destroy(sk, ECONNABORTED);
	sock_put(sk);
	return err;
}
#endif

static const struct inet_diag_handler raw_diag_handler = {
	.dump			= raw_diag_dump,
	.dump_one		= raw_diag_dump_one,
	.idiag_get_info		= raw_diag_get_info,
	.idiag_type		= IPPROTO_RAW,
	.idiag_info_size	= 0,
#ifdef CONFIG_INET_DIAG_DESTROY
	.destroy		= raw_diag_destroy,
#endif
};

static void __always_unused __check_inet_diag_req_raw(void)
{
	/*
	 * Make sure the two structures are identical,
	 * except the @pad field.
	 */
#define __offset_mismatch(m1, m2)			\
	(offsetof(struct inet_diag_req_v2, m1) !=	\
	 offsetof(struct inet_diag_req_raw, m2))

	BUILD_BUG_ON(sizeof(struct inet_diag_req_v2) !=
		     sizeof(struct inet_diag_req_raw));
	BUILD_BUG_ON(__offset_mismatch(sdiag_family, sdiag_family));
	BUILD_BUG_ON(__offset_mismatch(sdiag_protocol, sdiag_protocol));
	BUILD_BUG_ON(__offset_mismatch(idiag_ext, idiag_ext));
	BUILD_BUG_ON(__offset_mismatch(pad, sdiag_raw_protocol));
	BUILD_BUG_ON(__offset_mismatch(idiag_states, idiag_states));
	BUILD_BUG_ON(__offset_mismatch(id, id));
#undef __offset_mismatch
}

static int __init raw_diag_init(void)
{
	return inet_diag_register(&raw_diag_handler);
}

static void __exit raw_diag_exit(void)
{
	inet_diag_unregister(&raw_diag_handler);
}

module_init(raw_diag_init);
module_exit(raw_diag_exit);
MODULE_LICENSE("GPL");
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-255 /* AF_INET - IPPROTO_RAW */);
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 10-255 /* AF_INET6 - IPPROTO_RAW */);
Commit	Line	Data
432490f9 CG	1	#include <linux/module.h>
	2
	3	#include <linux/inet_diag.h>
	4	#include <linux/sock_diag.h>
	5
f8da9779	6	#include <net/inet_sock.h>
432490f9 CG	7	#include <net/raw.h>
	8	#include <net/rawv6.h>
	9
	10	#ifdef pr_fmt
	11	# undef pr_fmt
	12	#endif
	13
	14	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	15
	16	static struct raw_hashinfo *
	17	raw_get_hashinfo(const struct inet_diag_req_v2 *r)
	18	{
	19	if (r->sdiag_family == AF_INET) {
	20	return &raw_v4_hashinfo;
	21	#if IS_ENABLED(CONFIG_IPV6)
	22	} else if (r->sdiag_family == AF_INET6) {
	23	return &raw_v6_hashinfo;
	24	#endif
	25	} else {
	26	pr_warn_once("Unexpected inet family %d\n",
	27	r->sdiag_family);
	28	WARN_ON_ONCE(1);
	29	return ERR_PTR(-EINVAL);
	30	}
	31	}
	32
	33	/*
	34	* Due to requirement of not breaking user API we can't simply
	35	* rename @pad field in inet_diag_req_v2 structure, instead
	36	* use helper to figure it out.
	37	*/
	38
	39	static struct sock raw_lookup(struct net net, struct sock *from,
	40	const struct inet_diag_req_v2 *req)
	41	{
	42	struct inet_diag_req_raw r = (void )req;
	43	struct sock *sk = NULL;
	44
	45	if (r->sdiag_family == AF_INET)
	46	sk = __raw_v4_lookup(net, from, r->sdiag_raw_protocol,
	47	r->id.idiag_dst[0],
	48	r->id.idiag_src[0],
67359930	49	r->id.idiag_if, 0);
432490f9 CG	50	#if IS_ENABLED(CONFIG_IPV6)
	51	else
	52	sk = __raw_v6_lookup(net, from, r->sdiag_raw_protocol,
	53	(const struct in6_addr *)r->id.idiag_src,
	54	(const struct in6_addr *)r->id.idiag_dst,
5108ab4b	55	r->id.idiag_if, 0);
432490f9 CG	56	#endif
	57	return sk;
	58	}
	59
	60	static struct sock raw_sock_get(struct net net, const struct inet_diag_req_v2 *r)
	61	{
	62	struct raw_hashinfo *hashinfo = raw_get_hashinfo(r);
	63	struct sock sk = NULL, s;
	64	int slot;
	65
	66	if (IS_ERR(hashinfo))
	67	return ERR_CAST(hashinfo);
	68
	69	read_lock(&hashinfo->lock);
	70	for (slot = 0; slot < RAW_HTABLE_SIZE; slot++) {
	71	sk_for_each(s, &hashinfo->ht[slot]) {
	72	sk = raw_lookup(net, s, r);
	73	if (sk) {
	74	/*
	75	* Grab it and keep until we fill
	76	* diag meaage to be reported, so
	77	* caller should call sock_put then.
	78	* We can do that because we're keeping
	79	* hashinfo->lock here.
	80	*/
	81	sock_hold(sk);
9999370f	82	goto out_unlock;
432490f9 CG	83	}
	84	}
	85	}
9999370f	86	out_unlock:
432490f9 CG	87	read_unlock(&hashinfo->lock);
	88
	89	return sk ? sk : ERR_PTR(-ENOENT);
	90	}
	91
	92	static int raw_diag_dump_one(struct sk_buff *in_skb,
	93	const struct nlmsghdr *nlh,
	94	const struct inet_diag_req_v2 *r)
	95	{
	96	struct net *net = sock_net(in_skb->sk);
	97	struct sk_buff *rep;
	98	struct sock *sk;
	99	int err;
	100
	101	sk = raw_sock_get(net, r);
	102	if (IS_ERR(sk))
	103	return PTR_ERR(sk);
	104
	105	rep = nlmsg_new(sizeof(struct inet_diag_msg) +
	106	sizeof(struct inet_diag_meminfo) + 64,
	107	GFP_KERNEL);
	108	if (!rep) {
	109	sock_put(sk);
	110	return -ENOMEM;
	111	}
	112
	113	err = inet_sk_diag_fill(sk, NULL, rep, r,
	114	sk_user_ns(NETLINK_CB(in_skb).sk),
	115	NETLINK_CB(in_skb).portid,
	116	nlh->nlmsg_seq, 0, nlh,
	117	netlink_net_capable(in_skb, CAP_NET_ADMIN));
	118	sock_put(sk);
	119
	120	if (err < 0) {
	121	kfree_skb(rep);
	122	return err;
	123	}
	124
	125	err = netlink_unicast(net->diag_nlsk, rep,
	126	NETLINK_CB(in_skb).portid,
	127	MSG_DONTWAIT);
	128	if (err > 0)
	129	err = 0;
	130	return err;
	131	}
	132
	133	static int sk_diag_dump(struct sock sk, struct sk_buff skb,
	134	struct netlink_callback *cb,
	135	const struct inet_diag_req_v2 *r,
	136	struct nlattr *bc, bool net_admin)
	137	{
	138	if (!inet_diag_bc_sk(bc, sk))
	139	return 0;
	140
	141	return inet_sk_diag_fill(sk, NULL, skb, r,
	142	sk_user_ns(NETLINK_CB(cb->skb).sk),
	143	NETLINK_CB(cb->skb).portid,
	144	cb->nlh->nlmsg_seq, NLM_F_MULTI,
	145	cb->nlh, net_admin);
	146	}
	147
	148	static void raw_diag_dump(struct sk_buff skb, struct netlink_callback cb,
	149	const struct inet_diag_req_v2 r, struct nlattr bc)
	150	{
151	bool net_admin = netlink_net_capable(cb->skb, CAP_NET_ADMIN);
152	struct raw_hashinfo *hashinfo = raw_get_hashinfo(r);
153	struct net *net = sock_net(skb->sk);
154	int num, s_num, slot, s_slot;
155	struct sock *sk = NULL;
156
157	if (IS_ERR(hashinfo))
158	return;
159
160	s_slot = cb->args[0];
161	num = s_num = cb->args[1];
162
163	read_lock(&hashinfo->lock);
164	for (slot = s_slot; slot < RAW_HTABLE_SIZE; s_num = 0, slot++) {
165	num = 0;
166
167	sk_for_each(sk, &hashinfo->ht[slot]) {
168	struct inet_sock *inet = inet_sk(sk);
169
170	if (!net_eq(sock_net(sk), net))
171	continue;
172	if (num < s_num)
173	goto next;
174	if (sk->sk_family != r->sdiag_family)
175	goto next;
176	if (r->id.idiag_sport != inet->inet_sport &&
177	r->id.idiag_sport)
178	goto next;
179	if (r->id.idiag_dport != inet->inet_dport &&
180	r->id.idiag_dport)
181	goto next;
182	if (sk_diag_dump(sk, skb, cb, r, bc, net_admin) < 0)
183	goto out_unlock;
184	next:
185	num++;
186	}
187	}
188
189	out_unlock:
190	read_unlock(&hashinfo->lock);
191
192	cb->args[0] = slot;
193	cb->args[1] = num;
194	}
195
196	static void raw_diag_get_info(struct sock sk, struct inet_diag_msg r,
197	void *info)
198	{
199	r->idiag_rqueue = sk_rmem_alloc_get(sk);
200	r->idiag_wqueue = sk_wmem_alloc_get(sk);
201	}
202
203	#ifdef CONFIG_INET_DIAG_DESTROY
204	static int raw_diag_destroy(struct sk_buff *in_skb,
205	const struct inet_diag_req_v2 *r)
206	{
207	struct net *net = sock_net(in_skb->sk);
208	struct sock *sk;
cd05a0ec	209	int err;
432490f9 CG	210
	211	sk = raw_sock_get(net, r);
	212	if (IS_ERR(sk))
	213	return PTR_ERR(sk);
cd05a0ec CG	214	err = sock_diag_destroy(sk, ECONNABORTED);
	215	sock_put(sk);
	216	return err;
432490f9 CG	217	}
	218	#endif
	219
	220	static const struct inet_diag_handler raw_diag_handler = {
	221	.dump = raw_diag_dump,
	222	.dump_one = raw_diag_dump_one,
	223	.idiag_get_info = raw_diag_get_info,
	224	.idiag_type = IPPROTO_RAW,
	225	.idiag_info_size = 0,
	226	#ifdef CONFIG_INET_DIAG_DESTROY
	227	.destroy = raw_diag_destroy,
	228	#endif
	229	};
	230
	231	static void __always_unused __check_inet_diag_req_raw(void)
	232	{
	233	/*
	234	* Make sure the two structures are identical,
	235	* except the @pad field.
	236	*/
	237	#define __offset_mismatch(m1, m2) \
	238	(offsetof(struct inet_diag_req_v2, m1) != \
	239	offsetof(struct inet_diag_req_raw, m2))
	240
	241	BUILD_BUG_ON(sizeof(struct inet_diag_req_v2) !=
	242	sizeof(struct inet_diag_req_raw));
	243	BUILD_BUG_ON(__offset_mismatch(sdiag_family, sdiag_family));
	244	BUILD_BUG_ON(__offset_mismatch(sdiag_protocol, sdiag_protocol));
	245	BUILD_BUG_ON(__offset_mismatch(idiag_ext, idiag_ext));
	246	BUILD_BUG_ON(__offset_mismatch(pad, sdiag_raw_protocol));
	247	BUILD_BUG_ON(__offset_mismatch(idiag_states, idiag_states));
	248	BUILD_BUG_ON(__offset_mismatch(id, id));
	249	#undef __offset_mismatch
	250	}
	251
	252	static int __init raw_diag_init(void)
	253	{
	254	return inet_diag_register(&raw_diag_handler);
	255	}
	256
	257	static void __exit raw_diag_exit(void)
	258	{
	259	inet_diag_unregister(&raw_diag_handler);
	260	}
	261
	262	module_init(raw_diag_init);
	263	module_exit(raw_diag_exit);
	264	MODULE_LICENSE("GPL");
	265	MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-255 /* AF_INET - IPPROTO_RAW */);
	266	MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 10-255 /* AF_INET6 - IPPROTO_RAW */);