1#include <linux/mutex.h>
2#include <linux/socket.h>
3#include <linux/skbuff.h>
4#include <net/netlink.h>
5#include <net/net_namespace.h>
6#include <linux/module.h>
7#include <net/sock.h>
8
9#include <linux/inet_diag.h>
10#include <linux/sock_diag.h>
11
12static const struct sock_diag_handler *sock_diag_handlers[AF_MAX];
13static int (*inet_rcv_compat)(struct sk_buff *skb, struct nlmsghdr *nlh);
14static DEFINE_MUTEX(sock_diag_table_mutex);
15
16static u64 sock_gen_cookie(struct sock *sk)
17{
18	while (1) {
19		u64 res = atomic64_read(&sk->sk_cookie);
20
21		if (res)
22			return res;
23		res = atomic64_inc_return(&sock_net(sk)->cookie_gen);
24		atomic64_cmpxchg(&sk->sk_cookie, 0, res);
25	}
26}
27
28int sock_diag_check_cookie(struct sock *sk, const __u32 *cookie)
29{
30	u64 res;
31
32	if (cookie[0] == INET_DIAG_NOCOOKIE && cookie[1] == INET_DIAG_NOCOOKIE)
33		return 0;
34
35	res = sock_gen_cookie(sk);
36	if ((u32)res != cookie[0] || (u32)(res >> 32) != cookie[1])
37		return -ESTALE;
38
39	return 0;
40}
41EXPORT_SYMBOL_GPL(sock_diag_check_cookie);
42
43void sock_diag_save_cookie(struct sock *sk, __u32 *cookie)
44{
45	u64 res = sock_gen_cookie(sk);
46
47	cookie[0] = (u32)res;
48	cookie[1] = (u32)(res >> 32);
49}
50EXPORT_SYMBOL_GPL(sock_diag_save_cookie);
51
52int sock_diag_put_meminfo(struct sock *sk, struct sk_buff *skb, int attrtype)
53{
54	u32 mem[SK_MEMINFO_VARS];
55
56	mem[SK_MEMINFO_RMEM_ALLOC] = sk_rmem_alloc_get(sk);
57	mem[SK_MEMINFO_RCVBUF] = sk->sk_rcvbuf;
58	mem[SK_MEMINFO_WMEM_ALLOC] = sk_wmem_alloc_get(sk);
59	mem[SK_MEMINFO_SNDBUF] = sk->sk_sndbuf;
60	mem[SK_MEMINFO_FWD_ALLOC] = sk->sk_forward_alloc;
61	mem[SK_MEMINFO_WMEM_QUEUED] = sk->sk_wmem_queued;
62	mem[SK_MEMINFO_OPTMEM] = atomic_read(&sk->sk_omem_alloc);
63	mem[SK_MEMINFO_BACKLOG] = sk->sk_backlog.len;
64
65	return nla_put(skb, attrtype, sizeof(mem), &mem);
66}
67EXPORT_SYMBOL_GPL(sock_diag_put_meminfo);
68
69int sock_diag_put_filterinfo(bool may_report_filterinfo, struct sock *sk,
70			     struct sk_buff *skb, int attrtype)
71{
72	struct sock_fprog_kern *fprog;
73	struct sk_filter *filter;
74	struct nlattr *attr;
75	unsigned int flen;
76	int err = 0;
77
78	if (!may_report_filterinfo) {
79		nla_reserve(skb, attrtype, 0);
80		return 0;
81	}
82
83	rcu_read_lock();
84	filter = rcu_dereference(sk->sk_filter);
85	if (!filter)
86		goto out;
87
88	fprog = filter->prog->orig_prog;
89	if (!fprog)
90		goto out;
91
92	flen = bpf_classic_proglen(fprog);
93
94	attr = nla_reserve(skb, attrtype, flen);
95	if (attr == NULL) {
96		err = -EMSGSIZE;
97		goto out;
98	}
99
100	memcpy(nla_data(attr), fprog->filter, flen);
101out:
102	rcu_read_unlock();
103	return err;
104}
105EXPORT_SYMBOL(sock_diag_put_filterinfo);
106
107void sock_diag_register_inet_compat(int (*fn)(struct sk_buff *skb, struct nlmsghdr *nlh))
108{
109	mutex_lock(&sock_diag_table_mutex);
110	inet_rcv_compat = fn;
111	mutex_unlock(&sock_diag_table_mutex);
112}
113EXPORT_SYMBOL_GPL(sock_diag_register_inet_compat);
114
115void sock_diag_unregister_inet_compat(int (*fn)(struct sk_buff *skb, struct nlmsghdr *nlh))
116{
117	mutex_lock(&sock_diag_table_mutex);
118	inet_rcv_compat = NULL;
119	mutex_unlock(&sock_diag_table_mutex);
120}
121EXPORT_SYMBOL_GPL(sock_diag_unregister_inet_compat);
122
123int sock_diag_register(const struct sock_diag_handler *hndl)
124{
125	int err = 0;
126
127	if (hndl->family >= AF_MAX)
128		return -EINVAL;
129
130	mutex_lock(&sock_diag_table_mutex);
131	if (sock_diag_handlers[hndl->family])
132		err = -EBUSY;
133	else
134		sock_diag_handlers[hndl->family] = hndl;
135	mutex_unlock(&sock_diag_table_mutex);
136
137	return err;
138}
139EXPORT_SYMBOL_GPL(sock_diag_register);
140
141void sock_diag_unregister(const struct sock_diag_handler *hnld)
142{
143	int family = hnld->family;
144
145	if (family >= AF_MAX)
146		return;
147
148	mutex_lock(&sock_diag_table_mutex);
149	BUG_ON(sock_diag_handlers[family] != hnld);
150	sock_diag_handlers[family] = NULL;
151	mutex_unlock(&sock_diag_table_mutex);
152}
153EXPORT_SYMBOL_GPL(sock_diag_unregister);
154
155static int __sock_diag_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
156{
157	int err;
158	struct sock_diag_req *req = nlmsg_data(nlh);
159	const struct sock_diag_handler *hndl;
160
161	if (nlmsg_len(nlh) < sizeof(*req))
162		return -EINVAL;
163
164	if (req->sdiag_family >= AF_MAX)
165		return -EINVAL;
166
167	if (sock_diag_handlers[req->sdiag_family] == NULL)
168		request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
169				NETLINK_SOCK_DIAG, req->sdiag_family);
170
171	mutex_lock(&sock_diag_table_mutex);
172	hndl = sock_diag_handlers[req->sdiag_family];
173	if (hndl == NULL)
174		err = -ENOENT;
175	else
176		err = hndl->dump(skb, nlh);
177	mutex_unlock(&sock_diag_table_mutex);
178
179	return err;
180}
181
182static int sock_diag_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
183{
184	int ret;
185
186	switch (nlh->nlmsg_type) {
187	case TCPDIAG_GETSOCK:
188	case DCCPDIAG_GETSOCK:
189		if (inet_rcv_compat == NULL)
190			request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
191					NETLINK_SOCK_DIAG, AF_INET);
192
193		mutex_lock(&sock_diag_table_mutex);
194		if (inet_rcv_compat != NULL)
195			ret = inet_rcv_compat(skb, nlh);
196		else
197			ret = -EOPNOTSUPP;
198		mutex_unlock(&sock_diag_table_mutex);
199
200		return ret;
201	case SOCK_DIAG_BY_FAMILY:
202		return __sock_diag_rcv_msg(skb, nlh);
203	default:
204		return -EINVAL;
205	}
206}
207
208static DEFINE_MUTEX(sock_diag_mutex);
209
210static void sock_diag_rcv(struct sk_buff *skb)
211{
212	mutex_lock(&sock_diag_mutex);
213	netlink_rcv_skb(skb, &sock_diag_rcv_msg);
214	mutex_unlock(&sock_diag_mutex);
215}
216
217static int __net_init diag_net_init(struct net *net)
218{
219	struct netlink_kernel_cfg cfg = {
220		.input	= sock_diag_rcv,
221	};
222
223	net->diag_nlsk = netlink_kernel_create(net, NETLINK_SOCK_DIAG, &cfg);
224	return net->diag_nlsk == NULL ? -ENOMEM : 0;
225}
226
227static void __net_exit diag_net_exit(struct net *net)
228{
229	netlink_kernel_release(net->diag_nlsk);
230	net->diag_nlsk = NULL;
231}
232
233static struct pernet_operations diag_net_ops = {
234	.init = diag_net_init,
235	.exit = diag_net_exit,
236};
237
238static int __init sock_diag_init(void)
239{
240	return register_pernet_subsys(&diag_net_ops);
241}
242
243static void __exit sock_diag_exit(void)
244{
245	unregister_pernet_subsys(&diag_net_ops);
246}
247
248module_init(sock_diag_init);
249module_exit(sock_diag_exit);
250MODULE_LICENSE("GPL");
251MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_SOCK_DIAG);
252