blob: f28e937320a3b453371143a035e6967482d17cd4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * NETLINK Kernel-user communication protocol.
3 *
Alan Cox113aa832008-10-13 19:01:08 -07004 * Authors: Alan Cox <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
Patrick McHardycd1df522013-04-17 06:47:05 +00006 * Patrick McHardy <kaber@trash.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +090012 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * Tue Jun 26 14:36:48 MEST 2001 Herbert "herp" Rosmanith
14 * added netlink_proto_exit
15 * Tue Jan 22 18:32:44 BRST 2002 Arnaldo C. de Melo <acme@conectiva.com.br>
16 * use nlk_sk, as sk->protinfo is on a diet 8)
Harald Welte4fdb3bb2005-08-09 19:40:55 -070017 * Fri Jul 22 19:51:12 MEST 2005 Harald Welte <laforge@gnumonks.org>
18 * - inc module use count of module that owns
19 * the kernel socket in case userspace opens
20 * socket of same protocol
21 * - remove all module support, since netlink is
22 * mandatory if CONFIG_NET=y these days
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 */
24
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/module.h>
26
Randy Dunlap4fc268d2006-01-11 12:17:47 -080027#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/kernel.h>
29#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/signal.h>
31#include <linux/sched.h>
32#include <linux/errno.h>
33#include <linux/string.h>
34#include <linux/stat.h>
35#include <linux/socket.h>
36#include <linux/un.h>
37#include <linux/fcntl.h>
38#include <linux/termios.h>
39#include <linux/sockios.h>
40#include <linux/net.h>
41#include <linux/fs.h>
42#include <linux/slab.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080043#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/skbuff.h>
45#include <linux/netdevice.h>
46#include <linux/rtnetlink.h>
47#include <linux/proc_fs.h>
48#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <linux/notifier.h>
50#include <linux/security.h>
51#include <linux/jhash.h>
52#include <linux/jiffies.h>
53#include <linux/random.h>
54#include <linux/bitops.h>
55#include <linux/mm.h>
56#include <linux/types.h>
Andrew Morton54e0f522005-04-30 07:07:04 +010057#include <linux/audit.h>
Patrick McHardyaf65bdf2007-04-20 14:14:21 -070058#include <linux/mutex.h>
Patrick McHardyccdfcc32013-04-17 06:47:01 +000059#include <linux/vmalloc.h>
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +020060#include <linux/if_arp.h>
Thomas Grafe3416942014-08-02 11:47:45 +020061#include <linux/rhashtable.h>
Patrick McHardy9652e932013-04-17 06:47:02 +000062#include <asm/cacheflush.h>
Thomas Grafe3416942014-08-02 11:47:45 +020063#include <linux/hash.h>
Johannes Bergee1c24422015-01-16 11:37:14 +010064#include <linux/genetlink.h>
Nicolas Dichtel72124622017-06-01 10:00:07 +020065#include <linux/net_namespace.h>
Jeremy Clinebc5b6c02018-07-31 21:13:16 +000066#include <linux/nospec.h>
Andrew Morton54e0f522005-04-30 07:07:04 +010067
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020068#include <net/net_namespace.h>
Cong Wang25e3f702017-12-06 15:03:19 -080069#include <net/netns/generic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#include <net/sock.h>
71#include <net/scm.h>
Thomas Graf82ace472005-11-10 02:25:53 +010072#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Andrey Vagin0f29c762013-03-21 20:33:47 +040074#include "af_netlink.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Eric Dumazet5c398dc2010-10-24 04:27:10 +000076struct listeners {
77 struct rcu_head rcu;
78 unsigned long masks[0];
Johannes Berg6c04bb12009-07-10 09:51:32 +000079};
80
Patrick McHardycd967e02013-04-17 06:46:56 +000081/* state bits */
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +020082#define NETLINK_S_CONGESTED 0x0
Patrick McHardycd967e02013-04-17 06:46:56 +000083
David S. Miller035c4c12011-12-23 17:33:03 -050084static inline int netlink_is_kernel(struct sock *sk)
Denis V. Lunevaed815602007-10-10 21:14:32 -070085{
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +020086 return nlk_sk(sk)->flags & NETLINK_F_KERNEL_SOCKET;
Denis V. Lunevaed815602007-10-10 21:14:32 -070087}
88
Eric Dumazet91dd93f2015-05-12 17:24:50 -070089struct netlink_table *nl_table __read_mostly;
Andrey Vagin0f29c762013-03-21 20:33:47 +040090EXPORT_SYMBOL_GPL(nl_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);
93
Herbert Xu8a0f5cc2017-03-14 18:25:57 +080094static struct lock_class_key nlk_cb_mutex_keys[MAX_LINKS];
95
96static const char *const nlk_cb_mutex_key_strings[MAX_LINKS + 1] = {
97 "nlk_cb_mutex-ROUTE",
98 "nlk_cb_mutex-1",
99 "nlk_cb_mutex-USERSOCK",
100 "nlk_cb_mutex-FIREWALL",
101 "nlk_cb_mutex-SOCK_DIAG",
102 "nlk_cb_mutex-NFLOG",
103 "nlk_cb_mutex-XFRM",
104 "nlk_cb_mutex-SELINUX",
105 "nlk_cb_mutex-ISCSI",
106 "nlk_cb_mutex-AUDIT",
107 "nlk_cb_mutex-FIB_LOOKUP",
108 "nlk_cb_mutex-CONNECTOR",
109 "nlk_cb_mutex-NETFILTER",
110 "nlk_cb_mutex-IP6_FW",
111 "nlk_cb_mutex-DNRTMSG",
112 "nlk_cb_mutex-KOBJECT_UEVENT",
113 "nlk_cb_mutex-GENERIC",
114 "nlk_cb_mutex-17",
115 "nlk_cb_mutex-SCSITRANSPORT",
116 "nlk_cb_mutex-ECRYPTFS",
117 "nlk_cb_mutex-RDMA",
118 "nlk_cb_mutex-CRYPTO",
119 "nlk_cb_mutex-SMC",
120 "nlk_cb_mutex-23",
121 "nlk_cb_mutex-24",
122 "nlk_cb_mutex-25",
123 "nlk_cb_mutex-26",
124 "nlk_cb_mutex-27",
125 "nlk_cb_mutex-28",
126 "nlk_cb_mutex-29",
127 "nlk_cb_mutex-30",
128 "nlk_cb_mutex-31",
129 "nlk_cb_mutex-MAX_LINKS"
130};
131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132static int netlink_dump(struct sock *sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Thomas Graf78fd1d02014-10-21 22:05:38 +0200134/* nl_table locking explained:
Thomas Graf21e49022015-01-02 23:00:22 +0100135 * Lookup and traversal are protected with an RCU read-side lock. Insertion
Ying Xuec5adde92015-01-12 14:52:23 +0800136 * and removal are protected with per bucket lock while using RCU list
Thomas Graf21e49022015-01-02 23:00:22 +0100137 * modification primitives and may run in parallel to RCU protected lookups.
138 * Destruction of the Netlink socket may only occur *after* nl_table_lock has
139 * been acquired * either during or after the socket has been removed from
140 * the list and after an RCU grace period.
Thomas Graf78fd1d02014-10-21 22:05:38 +0200141 */
Andrey Vagin0f29c762013-03-21 20:33:47 +0400142DEFINE_RWLOCK(nl_table_lock);
143EXPORT_SYMBOL_GPL(nl_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144static atomic_t nl_table_users = ATOMIC_INIT(0);
145
Eric Dumazet6d772ac2012-10-18 03:21:55 +0000146#define nl_deref_protected(X) rcu_dereference_protected(X, lockdep_is_held(&nl_table_lock));
147
WANG Congefa172f2016-12-09 21:10:59 -0800148static BLOCKING_NOTIFIER_HEAD(netlink_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200150
Herbert Xuc428ecd2015-03-20 21:57:01 +1100151static const struct rhashtable_params netlink_rhashtable_params;
152
stephen hemmingerb57ef81f2011-12-22 08:52:02 +0000153static inline u32 netlink_group_mask(u32 group)
Patrick McHardyd629b832005-08-14 19:27:50 -0700154{
155 return group ? 1 << (group - 1) : 0;
156}
157
Daniel Borkmann1853c942015-09-10 20:05:46 +0200158static struct sk_buff *netlink_to_full_skb(const struct sk_buff *skb,
159 gfp_t gfp_mask)
160{
161 unsigned int len = skb_end_offset(skb);
162 struct sk_buff *new;
163
164 new = alloc_skb(len, gfp_mask);
165 if (new == NULL)
166 return NULL;
167
168 NETLINK_CB(new).portid = NETLINK_CB(skb).portid;
169 NETLINK_CB(new).dst_group = NETLINK_CB(skb).dst_group;
170 NETLINK_CB(new).creds = NETLINK_CB(skb).creds;
171
Johannes Berg59ae1d12017-06-16 14:29:20 +0200172 skb_put_data(new, skb->data, len);
Daniel Borkmann1853c942015-09-10 20:05:46 +0200173 return new;
174}
175
Cong Wang25e3f702017-12-06 15:03:19 -0800176static unsigned int netlink_tap_net_id;
177
178struct netlink_tap_net {
179 struct list_head netlink_tap_all;
Cong Wangb1042d32017-12-06 15:03:20 -0800180 struct mutex netlink_tap_lock;
Cong Wang25e3f702017-12-06 15:03:19 -0800181};
182
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200183int netlink_add_tap(struct netlink_tap *nt)
184{
Cong Wang25e3f702017-12-06 15:03:19 -0800185 struct net *net = dev_net(nt->dev);
186 struct netlink_tap_net *nn = net_generic(net, netlink_tap_net_id);
187
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200188 if (unlikely(nt->dev->type != ARPHRD_NETLINK))
189 return -EINVAL;
190
Cong Wangb1042d32017-12-06 15:03:20 -0800191 mutex_lock(&nn->netlink_tap_lock);
Cong Wang25e3f702017-12-06 15:03:19 -0800192 list_add_rcu(&nt->list, &nn->netlink_tap_all);
Cong Wangb1042d32017-12-06 15:03:20 -0800193 mutex_unlock(&nn->netlink_tap_lock);
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200194
Markus Elfringfcd4d352014-11-18 21:03:13 +0100195 __module_get(nt->module);
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200196
197 return 0;
198}
199EXPORT_SYMBOL_GPL(netlink_add_tap);
200
stephen hemminger2173f8d2013-12-30 10:49:22 -0800201static int __netlink_remove_tap(struct netlink_tap *nt)
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200202{
Cong Wang25e3f702017-12-06 15:03:19 -0800203 struct net *net = dev_net(nt->dev);
204 struct netlink_tap_net *nn = net_generic(net, netlink_tap_net_id);
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200205 bool found = false;
206 struct netlink_tap *tmp;
207
Cong Wangb1042d32017-12-06 15:03:20 -0800208 mutex_lock(&nn->netlink_tap_lock);
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200209
Cong Wang25e3f702017-12-06 15:03:19 -0800210 list_for_each_entry(tmp, &nn->netlink_tap_all, list) {
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200211 if (nt == tmp) {
212 list_del_rcu(&nt->list);
213 found = true;
214 goto out;
215 }
216 }
217
218 pr_warn("__netlink_remove_tap: %p not found\n", nt);
219out:
Cong Wangb1042d32017-12-06 15:03:20 -0800220 mutex_unlock(&nn->netlink_tap_lock);
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200221
Markus Elfring92b80eb2015-07-02 18:38:12 +0200222 if (found)
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200223 module_put(nt->module);
224
225 return found ? 0 : -ENODEV;
226}
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200227
228int netlink_remove_tap(struct netlink_tap *nt)
229{
230 int ret;
231
232 ret = __netlink_remove_tap(nt);
233 synchronize_net();
234
235 return ret;
236}
237EXPORT_SYMBOL_GPL(netlink_remove_tap);
238
Cong Wang25e3f702017-12-06 15:03:19 -0800239static __net_init int netlink_tap_init_net(struct net *net)
240{
241 struct netlink_tap_net *nn = net_generic(net, netlink_tap_net_id);
242
243 INIT_LIST_HEAD(&nn->netlink_tap_all);
Cong Wangb1042d32017-12-06 15:03:20 -0800244 mutex_init(&nn->netlink_tap_lock);
Cong Wang25e3f702017-12-06 15:03:19 -0800245 return 0;
246}
247
248static void __net_exit netlink_tap_exit_net(struct net *net)
249{
250}
251
252static struct pernet_operations netlink_tap_net_ops = {
253 .init = netlink_tap_init_net,
254 .exit = netlink_tap_exit_net,
255 .id = &netlink_tap_net_id,
256 .size = sizeof(struct netlink_tap_net),
257};
258
Daniel Borkmann5ffd5cd2013-09-05 17:48:47 +0200259static bool netlink_filter_tap(const struct sk_buff *skb)
260{
261 struct sock *sk = skb->sk;
Daniel Borkmann5ffd5cd2013-09-05 17:48:47 +0200262
263 /* We take the more conservative approach and
264 * whitelist socket protocols that may pass.
265 */
266 switch (sk->sk_protocol) {
267 case NETLINK_ROUTE:
268 case NETLINK_USERSOCK:
269 case NETLINK_SOCK_DIAG:
270 case NETLINK_NFLOG:
271 case NETLINK_XFRM:
272 case NETLINK_FIB_LOOKUP:
273 case NETLINK_NETFILTER:
274 case NETLINK_GENERIC:
Varka Bhadram498044b2014-07-16 10:59:47 +0530275 return true;
Daniel Borkmann5ffd5cd2013-09-05 17:48:47 +0200276 }
277
Varka Bhadram498044b2014-07-16 10:59:47 +0530278 return false;
Daniel Borkmann5ffd5cd2013-09-05 17:48:47 +0200279}
280
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200281static int __netlink_deliver_tap_skb(struct sk_buff *skb,
282 struct net_device *dev)
283{
284 struct sk_buff *nskb;
Daniel Borkmann5ffd5cd2013-09-05 17:48:47 +0200285 struct sock *sk = skb->sk;
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200286 int ret = -ENOMEM;
287
Kevin Cernekee93c64762017-12-06 12:12:27 -0800288 if (!net_eq(dev_net(dev), sock_net(sk)))
289 return 0;
290
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200291 dev_hold(dev);
Daniel Borkmann1853c942015-09-10 20:05:46 +0200292
Florian Westphald1b4c682016-02-18 15:03:24 +0100293 if (is_vmalloc_addr(skb->head))
Daniel Borkmann1853c942015-09-10 20:05:46 +0200294 nskb = netlink_to_full_skb(skb, GFP_ATOMIC);
295 else
296 nskb = skb_clone(skb, GFP_ATOMIC);
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200297 if (nskb) {
298 nskb->dev = dev;
Daniel Borkmann5ffd5cd2013-09-05 17:48:47 +0200299 nskb->protocol = htons((u16) sk->sk_protocol);
Daniel Borkmann604d13c2013-12-23 14:35:56 +0100300 nskb->pkt_type = netlink_is_kernel(sk) ?
301 PACKET_KERNEL : PACKET_USER;
Daniel Borkmann4e48ed82014-08-07 22:22:47 +0200302 skb_reset_network_header(nskb);
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200303 ret = dev_queue_xmit(nskb);
304 if (unlikely(ret > 0))
305 ret = net_xmit_errno(ret);
306 }
307
308 dev_put(dev);
309 return ret;
310}
311
Cong Wang25e3f702017-12-06 15:03:19 -0800312static void __netlink_deliver_tap(struct sk_buff *skb, struct netlink_tap_net *nn)
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200313{
314 int ret;
315 struct netlink_tap *tmp;
316
Daniel Borkmann5ffd5cd2013-09-05 17:48:47 +0200317 if (!netlink_filter_tap(skb))
318 return;
319
Cong Wang25e3f702017-12-06 15:03:19 -0800320 list_for_each_entry_rcu(tmp, &nn->netlink_tap_all, list) {
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200321 ret = __netlink_deliver_tap_skb(skb, tmp->dev);
322 if (unlikely(ret))
323 break;
324 }
325}
326
Cong Wang25e3f702017-12-06 15:03:19 -0800327static void netlink_deliver_tap(struct net *net, struct sk_buff *skb)
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200328{
Cong Wang25e3f702017-12-06 15:03:19 -0800329 struct netlink_tap_net *nn = net_generic(net, netlink_tap_net_id);
330
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200331 rcu_read_lock();
332
Cong Wang25e3f702017-12-06 15:03:19 -0800333 if (unlikely(!list_empty(&nn->netlink_tap_all)))
334 __netlink_deliver_tap(skb, nn);
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +0200335
336 rcu_read_unlock();
337}
338
Daniel Borkmann73bfd372013-12-23 14:35:55 +0100339static void netlink_deliver_tap_kernel(struct sock *dst, struct sock *src,
340 struct sk_buff *skb)
341{
342 if (!(netlink_is_kernel(dst) && netlink_is_kernel(src)))
Cong Wang25e3f702017-12-06 15:03:19 -0800343 netlink_deliver_tap(sock_net(dst), skb);
Daniel Borkmann73bfd372013-12-23 14:35:55 +0100344}
345
Patrick McHardycd1df522013-04-17 06:47:05 +0000346static void netlink_overrun(struct sock *sk)
347{
348 struct netlink_sock *nlk = nlk_sk(sk);
349
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +0200350 if (!(nlk->flags & NETLINK_F_RECV_NO_ENOBUFS)) {
351 if (!test_and_set_bit(NETLINK_S_CONGESTED,
352 &nlk_sk(sk)->state)) {
Patrick McHardycd1df522013-04-17 06:47:05 +0000353 sk->sk_err = ENOBUFS;
354 sk->sk_error_report(sk);
355 }
356 }
357 atomic_inc(&sk->sk_drops);
358}
359
360static void netlink_rcv_wake(struct sock *sk)
361{
362 struct netlink_sock *nlk = nlk_sk(sk);
363
364 if (skb_queue_empty(&sk->sk_receive_queue))
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +0200365 clear_bit(NETLINK_S_CONGESTED, &nlk->state);
366 if (!test_bit(NETLINK_S_CONGESTED, &nlk->state))
Patrick McHardycd1df522013-04-17 06:47:05 +0000367 wake_up_interruptible(&nlk->wait);
368}
369
Patrick McHardycf0a0182013-04-17 06:47:00 +0000370static void netlink_skb_destructor(struct sk_buff *skb)
371{
Pablo Neira Ayusoc05cdb12013-06-03 09:46:28 +0000372 if (is_vmalloc_addr(skb->head)) {
Pablo Neira3a365152013-06-28 03:04:23 +0200373 if (!skb->cloned ||
374 !atomic_dec_return(&(skb_shinfo(skb)->dataref)))
375 vfree(skb->head);
376
Pablo Neira Ayusoc05cdb12013-06-03 09:46:28 +0000377 skb->head = NULL;
378 }
Patrick McHardy9652e932013-04-17 06:47:02 +0000379 if (skb->sk != NULL)
380 sock_rfree(skb);
Patrick McHardycf0a0182013-04-17 06:47:00 +0000381}
382
383static void netlink_skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
384{
385 WARN_ON(skb->sk != NULL);
386 skb->sk = sk;
387 skb->destructor = netlink_skb_destructor;
388 atomic_add(skb->truesize, &sk->sk_rmem_alloc);
389 sk_mem_charge(sk, skb->truesize);
390}
391
Herbert Xued5d7782016-12-05 15:28:21 +0800392static void netlink_sock_destruct(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393{
Herbert Xu3f660d62007-05-03 03:17:14 -0700394 struct netlink_sock *nlk = nlk_sk(sk);
395
Pravin B Shelar16b304f2013-08-15 15:31:06 -0700396 if (nlk->cb_running) {
Herbert Xued5d7782016-12-05 15:28:21 +0800397 if (nlk->cb.done)
398 nlk->cb.done(&nlk->cb);
Pravin B Shelar16b304f2013-08-15 15:31:06 -0700399 module_put(nlk->cb.module);
400 kfree_skb(nlk->cb.skb);
Herbert Xu3f660d62007-05-03 03:17:14 -0700401 }
402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 skb_queue_purge(&sk->sk_receive_queue);
404
405 if (!sock_flag(sk, SOCK_DEAD)) {
Patrick McHardy6ac552f2007-12-04 00:19:38 -0800406 printk(KERN_ERR "Freeing alive netlink socket %p\n", sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 return;
408 }
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700409
410 WARN_ON(atomic_read(&sk->sk_rmem_alloc));
Reshetova, Elena14afee42017-06-30 13:08:00 +0300411 WARN_ON(refcount_read(&sk->sk_wmem_alloc));
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700412 WARN_ON(nlk_sk(sk)->groups);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413}
414
Herbert Xu707693c2016-11-28 19:22:12 +0800415static void netlink_sock_destruct_work(struct work_struct *work)
416{
417 struct netlink_sock *nlk = container_of(work, struct netlink_sock,
418 work);
419
Herbert Xued5d7782016-12-05 15:28:21 +0800420 sk_free(&nlk->sk);
Herbert Xu707693c2016-11-28 19:22:12 +0800421}
422
Patrick McHardy6ac552f2007-12-04 00:19:38 -0800423/* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on
424 * SMP. Look, when several writers sleep and reader wakes them up, all but one
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 * immediately hit write lock and grab all the cpus. Exclusive sleep solves
426 * this, _but_ remember, it adds useless work on UP machines.
427 */
428
Johannes Bergd136f1b2009-09-12 03:03:15 +0000429void netlink_table_grab(void)
Eric Dumazet9a429c42008-01-01 21:58:02 -0800430 __acquires(nl_table_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431{
Johannes Bergd136f1b2009-09-12 03:03:15 +0000432 might_sleep();
433
Arjan van de Ven6abd2192006-07-03 00:24:07 -0700434 write_lock_irq(&nl_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436 if (atomic_read(&nl_table_users)) {
437 DECLARE_WAITQUEUE(wait, current);
438
439 add_wait_queue_exclusive(&nl_table_wait, &wait);
Patrick McHardy6ac552f2007-12-04 00:19:38 -0800440 for (;;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 set_current_state(TASK_UNINTERRUPTIBLE);
442 if (atomic_read(&nl_table_users) == 0)
443 break;
Arjan van de Ven6abd2192006-07-03 00:24:07 -0700444 write_unlock_irq(&nl_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 schedule();
Arjan van de Ven6abd2192006-07-03 00:24:07 -0700446 write_lock_irq(&nl_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 }
448
449 __set_current_state(TASK_RUNNING);
450 remove_wait_queue(&nl_table_wait, &wait);
451 }
452}
453
Johannes Bergd136f1b2009-09-12 03:03:15 +0000454void netlink_table_ungrab(void)
Eric Dumazet9a429c42008-01-01 21:58:02 -0800455 __releases(nl_table_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456{
Arjan van de Ven6abd2192006-07-03 00:24:07 -0700457 write_unlock_irq(&nl_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 wake_up(&nl_table_wait);
459}
460
Patrick McHardy6ac552f2007-12-04 00:19:38 -0800461static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462netlink_lock_table(void)
463{
464 /* read_lock() synchronizes us to netlink_table_grab */
465
466 read_lock(&nl_table_lock);
467 atomic_inc(&nl_table_users);
468 read_unlock(&nl_table_lock);
469}
470
Patrick McHardy6ac552f2007-12-04 00:19:38 -0800471static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472netlink_unlock_table(void)
473{
474 if (atomic_dec_and_test(&nl_table_users))
475 wake_up(&nl_table_wait);
476}
477
Thomas Grafe3416942014-08-02 11:47:45 +0200478struct netlink_compare_arg
Gao fengda12c902013-06-06 14:49:11 +0800479{
Herbert Xuc428ecd2015-03-20 21:57:01 +1100480 possible_net_t pnet;
Thomas Grafe3416942014-08-02 11:47:45 +0200481 u32 portid;
482};
483
Herbert Xu8f2ddaa2015-03-21 14:14:03 +1100484/* Doing sizeof directly may yield 4 extra bytes on 64-bit. */
485#define netlink_compare_arg_len \
486 (offsetof(struct netlink_compare_arg, portid) + sizeof(u32))
Thomas Grafe3416942014-08-02 11:47:45 +0200487
Herbert Xuc428ecd2015-03-20 21:57:01 +1100488static inline int netlink_compare(struct rhashtable_compare_arg *arg,
489 const void *ptr)
490{
491 const struct netlink_compare_arg *x = arg->key;
492 const struct netlink_sock *nlk = ptr;
493
Herbert Xuda314c92015-09-22 11:38:56 +0800494 return nlk->portid != x->portid ||
Herbert Xuc428ecd2015-03-20 21:57:01 +1100495 !net_eq(sock_net(&nlk->sk), read_pnet(&x->pnet));
496}
497
498static void netlink_compare_arg_init(struct netlink_compare_arg *arg,
499 struct net *net, u32 portid)
500{
501 memset(arg, 0, sizeof(*arg));
502 write_pnet(&arg->pnet, net);
503 arg->portid = portid;
Thomas Grafe3416942014-08-02 11:47:45 +0200504}
505
506static struct sock *__netlink_lookup(struct netlink_table *table, u32 portid,
507 struct net *net)
508{
Herbert Xuc428ecd2015-03-20 21:57:01 +1100509 struct netlink_compare_arg arg;
Thomas Grafe3416942014-08-02 11:47:45 +0200510
Herbert Xuc428ecd2015-03-20 21:57:01 +1100511 netlink_compare_arg_init(&arg, net, portid);
512 return rhashtable_lookup_fast(&table->hash, &arg,
513 netlink_rhashtable_params);
Gao fengda12c902013-06-06 14:49:11 +0800514}
515
Herbert Xuc428ecd2015-03-20 21:57:01 +1100516static int __netlink_insert(struct netlink_table *table, struct sock *sk)
Ying Xuec5adde92015-01-12 14:52:23 +0800517{
Herbert Xuc428ecd2015-03-20 21:57:01 +1100518 struct netlink_compare_arg arg;
Ying Xuec5adde92015-01-12 14:52:23 +0800519
Herbert Xuda314c92015-09-22 11:38:56 +0800520 netlink_compare_arg_init(&arg, sock_net(sk), nlk_sk(sk)->portid);
Herbert Xuc428ecd2015-03-20 21:57:01 +1100521 return rhashtable_lookup_insert_key(&table->hash, &arg,
522 &nlk_sk(sk)->node,
523 netlink_rhashtable_params);
Ying Xuec5adde92015-01-12 14:52:23 +0800524}
525
Eric W. Biederman15e47302012-09-07 20:12:54 +0000526static struct sock *netlink_lookup(struct net *net, int protocol, u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527{
Gao fengda12c902013-06-06 14:49:11 +0800528 struct netlink_table *table = &nl_table[protocol];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
Thomas Grafe3416942014-08-02 11:47:45 +0200531 rcu_read_lock();
532 sk = __netlink_lookup(table, portid, net);
533 if (sk)
534 sock_hold(sk);
535 rcu_read_unlock();
536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 return sk;
538}
539
Eric Dumazet90ddc4f2005-12-22 12:49:22 -0800540static const struct proto_ops netlink_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
Patrick McHardy4277a082006-03-20 18:52:01 -0800542static void
543netlink_update_listeners(struct sock *sk)
544{
545 struct netlink_table *tbl = &nl_table[sk->sk_protocol];
Patrick McHardy4277a082006-03-20 18:52:01 -0800546 unsigned long mask;
547 unsigned int i;
Eric Dumazet6d772ac2012-10-18 03:21:55 +0000548 struct listeners *listeners;
549
550 listeners = nl_deref_protected(tbl->listeners);
551 if (!listeners)
552 return;
Patrick McHardy4277a082006-03-20 18:52:01 -0800553
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700554 for (i = 0; i < NLGRPLONGS(tbl->groups); i++) {
Patrick McHardy4277a082006-03-20 18:52:01 -0800555 mask = 0;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800556 sk_for_each_bound(sk, &tbl->mc_list) {
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700557 if (i < NLGRPLONGS(nlk_sk(sk)->ngroups))
558 mask |= nlk_sk(sk)->groups[i];
559 }
Eric Dumazet6d772ac2012-10-18 03:21:55 +0000560 listeners->masks[i] = mask;
Patrick McHardy4277a082006-03-20 18:52:01 -0800561 }
562 /* this function is only called with the netlink table "grabbed", which
563 * makes sure updates are visible before bind or setsockopt return. */
564}
565
Herbert Xu8ea65f42015-01-26 14:02:56 +1100566static int netlink_insert(struct sock *sk, u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
Gao fengda12c902013-06-06 14:49:11 +0800568 struct netlink_table *table = &nl_table[sk->sk_protocol];
Herbert Xu919d9db2015-01-16 17:23:48 +1100569 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Ying Xuec5adde92015-01-12 14:52:23 +0800571 lock_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Herbert Xuda314c92015-09-22 11:38:56 +0800573 err = nlk_sk(sk)->portid == portid ? 0 : -EBUSY;
574 if (nlk_sk(sk)->bound)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 goto err;
576
Herbert Xuda314c92015-09-22 11:38:56 +0800577 nlk_sk(sk)->portid = portid;
Thomas Grafe3416942014-08-02 11:47:45 +0200578 sock_hold(sk);
Herbert Xu919d9db2015-01-16 17:23:48 +1100579
Herbert Xuc428ecd2015-03-20 21:57:01 +1100580 err = __netlink_insert(table, sk);
581 if (err) {
Daniel Borkmann4e7c1332015-08-07 00:26:41 +0200582 /* In case the hashtable backend returns with -EBUSY
583 * from here, it must not escape to the caller.
584 */
585 if (unlikely(err == -EBUSY))
586 err = -EOVERFLOW;
Herbert Xuc428ecd2015-03-20 21:57:01 +1100587 if (err == -EEXIST)
588 err = -EADDRINUSE;
Ying Xuec5adde92015-01-12 14:52:23 +0800589 sock_put(sk);
Herbert Xu1f770c02015-09-18 19:16:50 +0800590 goto err;
Herbert Xu919d9db2015-01-16 17:23:48 +1100591 }
592
Herbert Xuda314c92015-09-22 11:38:56 +0800593 /* We need to ensure that the socket is hashed and visible. */
594 smp_wmb();
595 nlk_sk(sk)->bound = portid;
Herbert Xu1f770c02015-09-18 19:16:50 +0800596
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597err:
Ying Xuec5adde92015-01-12 14:52:23 +0800598 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 return err;
600}
601
602static void netlink_remove(struct sock *sk)
603{
Thomas Grafe3416942014-08-02 11:47:45 +0200604 struct netlink_table *table;
605
Thomas Grafe3416942014-08-02 11:47:45 +0200606 table = &nl_table[sk->sk_protocol];
Herbert Xuc428ecd2015-03-20 21:57:01 +1100607 if (!rhashtable_remove_fast(&table->hash, &nlk_sk(sk)->node,
608 netlink_rhashtable_params)) {
Reshetova, Elena41c6d652017-06-30 13:08:01 +0300609 WARN_ON(refcount_read(&sk->sk_refcnt) == 1);
Thomas Grafe3416942014-08-02 11:47:45 +0200610 __sock_put(sk);
611 }
Thomas Grafe3416942014-08-02 11:47:45 +0200612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 netlink_table_grab();
Johannes Bergb10dcb32014-12-22 18:56:37 +0100614 if (nlk_sk(sk)->subscriptions) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 __sk_del_bind_node(sk);
Johannes Bergb10dcb32014-12-22 18:56:37 +0100616 netlink_update_listeners(sk);
617 }
Johannes Bergee1c24422015-01-16 11:37:14 +0100618 if (sk->sk_protocol == NETLINK_GENERIC)
619 atomic_inc(&genl_sk_destructing_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 netlink_table_ungrab();
621}
622
623static struct proto netlink_proto = {
624 .name = "NETLINK",
625 .owner = THIS_MODULE,
626 .obj_size = sizeof(struct netlink_sock),
627};
628
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700629static int __netlink_create(struct net *net, struct socket *sock,
Eric W. Biederman11aa9c22015-05-08 21:09:13 -0500630 struct mutex *cb_mutex, int protocol,
631 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632{
633 struct sock *sk;
634 struct netlink_sock *nlk;
Patrick McHardyab33a172005-08-14 19:31:36 -0700635
636 sock->ops = &netlink_ops;
637
Eric W. Biederman11aa9c22015-05-08 21:09:13 -0500638 sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto, kern);
Patrick McHardyab33a172005-08-14 19:31:36 -0700639 if (!sk)
640 return -ENOMEM;
641
642 sock_init_data(sock, sk);
643
644 nlk = nlk_sk(sk);
Eric Dumazet658cb352012-04-22 21:30:21 +0000645 if (cb_mutex) {
Patrick McHardyffa4d722007-04-25 14:01:17 -0700646 nlk->cb_mutex = cb_mutex;
Eric Dumazet658cb352012-04-22 21:30:21 +0000647 } else {
Patrick McHardyffa4d722007-04-25 14:01:17 -0700648 nlk->cb_mutex = &nlk->cb_def_mutex;
649 mutex_init(nlk->cb_mutex);
Herbert Xu8a0f5cc2017-03-14 18:25:57 +0800650 lockdep_set_class_and_name(nlk->cb_mutex,
651 nlk_cb_mutex_keys + protocol,
652 nlk_cb_mutex_key_strings[protocol]);
Patrick McHardyffa4d722007-04-25 14:01:17 -0700653 }
Patrick McHardyab33a172005-08-14 19:31:36 -0700654 init_waitqueue_head(&nlk->wait);
655
656 sk->sk_destruct = netlink_sock_destruct;
657 sk->sk_protocol = protocol;
658 return 0;
659}
660
Eric Paris3f378b682009-11-05 22:18:14 -0800661static int netlink_create(struct net *net, struct socket *sock, int protocol,
662 int kern)
Patrick McHardyab33a172005-08-14 19:31:36 -0700663{
664 struct module *module = NULL;
Patrick McHardyaf65bdf2007-04-20 14:14:21 -0700665 struct mutex *cb_mutex;
Patrick McHardyf7fa9b12005-08-15 12:29:13 -0700666 struct netlink_sock *nlk;
Johannes Berg023e2cf2014-12-23 21:00:06 +0100667 int (*bind)(struct net *net, int group);
668 void (*unbind)(struct net *net, int group);
Patrick McHardyab33a172005-08-14 19:31:36 -0700669 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
671 sock->state = SS_UNCONNECTED;
672
673 if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
674 return -ESOCKTNOSUPPORT;
675
Patrick McHardy6ac552f2007-12-04 00:19:38 -0800676 if (protocol < 0 || protocol >= MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 return -EPROTONOSUPPORT;
Jeremy Clinebc5b6c02018-07-31 21:13:16 +0000678 protocol = array_index_nospec(protocol, MAX_LINKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Patrick McHardy77247bb2005-08-14 19:27:13 -0700680 netlink_lock_table();
Johannes Berg95a5afc2008-10-16 15:24:51 -0700681#ifdef CONFIG_MODULES
Patrick McHardyab33a172005-08-14 19:31:36 -0700682 if (!nl_table[protocol].registered) {
Patrick McHardy77247bb2005-08-14 19:27:13 -0700683 netlink_unlock_table();
Harald Welte4fdb3bb2005-08-09 19:40:55 -0700684 request_module("net-pf-%d-proto-%d", PF_NETLINK, protocol);
Patrick McHardy77247bb2005-08-14 19:27:13 -0700685 netlink_lock_table();
Harald Welte4fdb3bb2005-08-09 19:40:55 -0700686 }
Patrick McHardyab33a172005-08-14 19:31:36 -0700687#endif
688 if (nl_table[protocol].registered &&
689 try_module_get(nl_table[protocol].module))
690 module = nl_table[protocol].module;
Alexey Dobriyan974c37e2010-01-30 10:05:05 +0000691 else
692 err = -EPROTONOSUPPORT;
Patrick McHardyaf65bdf2007-04-20 14:14:21 -0700693 cb_mutex = nl_table[protocol].cb_mutex;
Pablo Neira Ayuso03292742012-06-29 06:15:22 +0000694 bind = nl_table[protocol].bind;
Richard Guy Briggs4f520902014-04-22 21:31:54 -0400695 unbind = nl_table[protocol].unbind;
Patrick McHardy77247bb2005-08-14 19:27:13 -0700696 netlink_unlock_table();
Harald Welte4fdb3bb2005-08-09 19:40:55 -0700697
Alexey Dobriyan974c37e2010-01-30 10:05:05 +0000698 if (err < 0)
699 goto out;
700
Eric W. Biederman11aa9c22015-05-08 21:09:13 -0500701 err = __netlink_create(net, sock, cb_mutex, protocol, kern);
Patrick McHardy6ac552f2007-12-04 00:19:38 -0800702 if (err < 0)
Patrick McHardyab33a172005-08-14 19:31:36 -0700703 goto out_module;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
David S. Miller6f756a82008-11-23 17:34:03 -0800705 local_bh_disable();
Eric Dumazetc1fd3b92008-11-23 15:48:22 -0800706 sock_prot_inuse_add(net, &netlink_proto, 1);
David S. Miller6f756a82008-11-23 17:34:03 -0800707 local_bh_enable();
708
Patrick McHardyf7fa9b12005-08-15 12:29:13 -0700709 nlk = nlk_sk(sock->sk);
Patrick McHardyf7fa9b12005-08-15 12:29:13 -0700710 nlk->module = module;
Pablo Neira Ayuso03292742012-06-29 06:15:22 +0000711 nlk->netlink_bind = bind;
Richard Guy Briggs4f520902014-04-22 21:31:54 -0400712 nlk->netlink_unbind = unbind;
Patrick McHardyab33a172005-08-14 19:31:36 -0700713out:
714 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Patrick McHardyab33a172005-08-14 19:31:36 -0700716out_module:
717 module_put(module);
718 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719}
720
Thomas Graf21e49022015-01-02 23:00:22 +0100721static void deferred_put_nlk_sk(struct rcu_head *head)
722{
723 struct netlink_sock *nlk = container_of(head, struct netlink_sock, rcu);
Herbert Xued5d7782016-12-05 15:28:21 +0800724 struct sock *sk = &nlk->sk;
Thomas Graf21e49022015-01-02 23:00:22 +0100725
Xin Longbe824852017-09-06 11:47:12 +0800726 kfree(nlk->groups);
727 nlk->groups = NULL;
728
Reshetova, Elena41c6d652017-06-30 13:08:01 +0300729 if (!refcount_dec_and_test(&sk->sk_refcnt))
Herbert Xued5d7782016-12-05 15:28:21 +0800730 return;
731
732 if (nlk->cb_running && nlk->cb.done) {
733 INIT_WORK(&nlk->work, netlink_sock_destruct_work);
734 schedule_work(&nlk->work);
735 return;
736 }
737
738 sk_free(sk);
Thomas Graf21e49022015-01-02 23:00:22 +0100739}
740
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741static int netlink_release(struct socket *sock)
742{
743 struct sock *sk = sock->sk;
744 struct netlink_sock *nlk;
745
746 if (!sk)
747 return 0;
748
749 netlink_remove(sk);
Denis Lunevac57b3a2007-04-18 17:05:58 -0700750 sock_orphan(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 nlk = nlk_sk(sk);
752
Herbert Xu3f660d62007-05-03 03:17:14 -0700753 /*
754 * OK. Socket is unlinked, any packets that arrive now
755 * will be purged.
756 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
Johannes Bergee1c24422015-01-16 11:37:14 +0100758 /* must not acquire netlink_table_lock in any way again before unbind
759 * and notifying genetlink is done as otherwise it might deadlock
760 */
761 if (nlk->netlink_unbind) {
762 int i;
763
764 for (i = 0; i < nlk->ngroups; i++)
765 if (test_bit(i, nlk->groups))
766 nlk->netlink_unbind(sock_net(sk), i + 1);
767 }
768 if (sk->sk_protocol == NETLINK_GENERIC &&
769 atomic_dec_return(&genl_sk_destructing_cnt) == 0)
770 wake_up(&genl_sk_destructing_waitq);
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 sock->sk = NULL;
773 wake_up_interruptible_all(&nlk->wait);
774
775 skb_queue_purge(&sk->sk_write_queue);
776
Dmitry Ivanove2726022016-04-07 09:31:38 +0200777 if (nlk->portid && nlk->bound) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 struct netlink_notify n = {
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900779 .net = sock_net(sk),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 .protocol = sk->sk_protocol,
Eric W. Biederman15e47302012-09-07 20:12:54 +0000781 .portid = nlk->portid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 };
WANG Congefa172f2016-12-09 21:10:59 -0800783 blocking_notifier_call_chain(&netlink_chain,
Alan Sterne041c682006-03-27 01:16:30 -0800784 NETLINK_URELEASE, &n);
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +0900785 }
Harald Welte4fdb3bb2005-08-09 19:40:55 -0700786
Mariusz Kozlowski5e7c0012007-01-02 15:24:30 -0800787 module_put(nlk->module);
Harald Welte4fdb3bb2005-08-09 19:40:55 -0700788
Denis V. Lunevaed815602007-10-10 21:14:32 -0700789 if (netlink_is_kernel(sk)) {
Johannes Bergb10dcb32014-12-22 18:56:37 +0100790 netlink_table_grab();
Denis V. Lunev869e58f2008-01-18 23:53:31 -0800791 BUG_ON(nl_table[sk->sk_protocol].registered == 0);
792 if (--nl_table[sk->sk_protocol].registered == 0) {
Eric Dumazet6d772ac2012-10-18 03:21:55 +0000793 struct listeners *old;
794
795 old = nl_deref_protected(nl_table[sk->sk_protocol].listeners);
796 RCU_INIT_POINTER(nl_table[sk->sk_protocol].listeners, NULL);
797 kfree_rcu(old, rcu);
Denis V. Lunev869e58f2008-01-18 23:53:31 -0800798 nl_table[sk->sk_protocol].module = NULL;
Pablo Neira Ayuso9785e102012-09-08 02:53:53 +0000799 nl_table[sk->sk_protocol].bind = NULL;
Richard Guy Briggs4f520902014-04-22 21:31:54 -0400800 nl_table[sk->sk_protocol].unbind = NULL;
Pablo Neira Ayuso9785e102012-09-08 02:53:53 +0000801 nl_table[sk->sk_protocol].flags = 0;
Denis V. Lunev869e58f2008-01-18 23:53:31 -0800802 nl_table[sk->sk_protocol].registered = 0;
803 }
Johannes Bergb10dcb32014-12-22 18:56:37 +0100804 netlink_table_ungrab();
Eric Dumazet658cb352012-04-22 21:30:21 +0000805 }
Patrick McHardy77247bb2005-08-14 19:27:13 -0700806
Eric Dumazet37558102008-11-24 14:05:22 -0800807 local_bh_disable();
Eric Dumazetc1fd3b92008-11-23 15:48:22 -0800808 sock_prot_inuse_add(sock_net(sk), &netlink_proto, -1);
Eric Dumazet37558102008-11-24 14:05:22 -0800809 local_bh_enable();
Thomas Graf21e49022015-01-02 23:00:22 +0100810 call_rcu(&nlk->rcu, deferred_put_nlk_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 return 0;
812}
813
814static int netlink_autobind(struct socket *sock)
815{
816 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900817 struct net *net = sock_net(sk);
Gao fengda12c902013-06-06 14:49:11 +0800818 struct netlink_table *table = &nl_table[sk->sk_protocol];
Eric W. Biederman15e47302012-09-07 20:12:54 +0000819 s32 portid = task_tgid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 int err;
Herbert Xub9fbe702015-05-17 10:45:34 +0800821 s32 rover = -4096;
822 bool ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
824retry:
825 cond_resched();
Thomas Grafe3416942014-08-02 11:47:45 +0200826 rcu_read_lock();
Herbert Xub9fbe702015-05-17 10:45:34 +0800827 ok = !__netlink_lookup(table, portid, net);
828 rcu_read_unlock();
829 if (!ok) {
Thomas Grafe3416942014-08-02 11:47:45 +0200830 /* Bind collision, search negative portid values. */
Herbert Xub9fbe702015-05-17 10:45:34 +0800831 if (rover == -4096)
832 /* rover will be in range [S32_MIN, -4097] */
833 rover = S32_MIN + prandom_u32_max(-4096 - S32_MIN);
834 else if (rover >= -4096)
Thomas Grafe3416942014-08-02 11:47:45 +0200835 rover = -4097;
Herbert Xub9fbe702015-05-17 10:45:34 +0800836 portid = rover--;
Thomas Grafe3416942014-08-02 11:47:45 +0200837 goto retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Herbert Xu8ea65f42015-01-26 14:02:56 +1100840 err = netlink_insert(sk, portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 if (err == -EADDRINUSE)
842 goto retry;
David S. Millerd470e3b2005-06-26 15:31:51 -0700843
844 /* If 2 threads race to autobind, that is fine. */
845 if (err == -EBUSY)
846 err = 0;
847
848 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849}
850
Eric W. Biedermanaa4cf942014-04-23 14:28:03 -0700851/**
852 * __netlink_ns_capable - General netlink message capability test
853 * @nsp: NETLINK_CB of the socket buffer holding a netlink command from userspace.
854 * @user_ns: The user namespace of the capability to use
855 * @cap: The capability to use
856 *
857 * Test to see if the opener of the socket we received the message
858 * from had when the netlink socket was created and the sender of the
859 * message has has the capability @cap in the user namespace @user_ns.
860 */
861bool __netlink_ns_capable(const struct netlink_skb_parms *nsp,
862 struct user_namespace *user_ns, int cap)
863{
Eric W. Biederman2d7a85f2014-05-30 11:04:00 -0700864 return ((nsp->flags & NETLINK_SKB_DST) ||
865 file_ns_capable(nsp->sk->sk_socket->file, user_ns, cap)) &&
866 ns_capable(user_ns, cap);
Eric W. Biedermanaa4cf942014-04-23 14:28:03 -0700867}
868EXPORT_SYMBOL(__netlink_ns_capable);
869
870/**
871 * netlink_ns_capable - General netlink message capability test
872 * @skb: socket buffer holding a netlink command from userspace
873 * @user_ns: The user namespace of the capability to use
874 * @cap: The capability to use
875 *
876 * Test to see if the opener of the socket we received the message
877 * from had when the netlink socket was created and the sender of the
878 * message has has the capability @cap in the user namespace @user_ns.
879 */
880bool netlink_ns_capable(const struct sk_buff *skb,
881 struct user_namespace *user_ns, int cap)
882{
883 return __netlink_ns_capable(&NETLINK_CB(skb), user_ns, cap);
884}
885EXPORT_SYMBOL(netlink_ns_capable);
886
887/**
888 * netlink_capable - Netlink global message capability test
889 * @skb: socket buffer holding a netlink command from userspace
890 * @cap: The capability to use
891 *
892 * Test to see if the opener of the socket we received the message
893 * from had when the netlink socket was created and the sender of the
894 * message has has the capability @cap in all user namespaces.
895 */
896bool netlink_capable(const struct sk_buff *skb, int cap)
897{
898 return netlink_ns_capable(skb, &init_user_ns, cap);
899}
900EXPORT_SYMBOL(netlink_capable);
901
902/**
903 * netlink_net_capable - Netlink network namespace message capability test
904 * @skb: socket buffer holding a netlink command from userspace
905 * @cap: The capability to use
906 *
907 * Test to see if the opener of the socket we received the message
908 * from had when the netlink socket was created and the sender of the
909 * message has has the capability @cap over the network namespace of
910 * the socket we received the message from.
911 */
912bool netlink_net_capable(const struct sk_buff *skb, int cap)
913{
914 return netlink_ns_capable(skb, sock_net(skb->sk)->user_ns, cap);
915}
916EXPORT_SYMBOL(netlink_net_capable);
917
Eric W. Biederman5187cd02014-04-23 14:25:48 -0700918static inline int netlink_allowed(const struct socket *sock, unsigned int flag)
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +0900919{
Pablo Neira Ayuso9785e102012-09-08 02:53:53 +0000920 return (nl_table[sock->sk->sk_protocol].flags & flag) ||
Eric W. Biedermandf008c92012-11-16 03:03:07 +0000921 ns_capable(sock_net(sock->sk)->user_ns, CAP_NET_ADMIN);
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +0900922}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
Patrick McHardyf7fa9b12005-08-15 12:29:13 -0700924static void
925netlink_update_subscriptions(struct sock *sk, unsigned int subscriptions)
926{
927 struct netlink_sock *nlk = nlk_sk(sk);
928
929 if (nlk->subscriptions && !subscriptions)
930 __sk_del_bind_node(sk);
931 else if (!nlk->subscriptions && subscriptions)
932 sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list);
933 nlk->subscriptions = subscriptions;
934}
935
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700936static int netlink_realloc_groups(struct sock *sk)
Patrick McHardy513c2502005-09-06 15:43:59 -0700937{
938 struct netlink_sock *nlk = nlk_sk(sk);
939 unsigned int groups;
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700940 unsigned long *new_groups;
Patrick McHardy513c2502005-09-06 15:43:59 -0700941 int err = 0;
942
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700943 netlink_table_grab();
944
Patrick McHardy513c2502005-09-06 15:43:59 -0700945 groups = nl_table[sk->sk_protocol].groups;
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700946 if (!nl_table[sk->sk_protocol].registered) {
Patrick McHardy513c2502005-09-06 15:43:59 -0700947 err = -ENOENT;
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700948 goto out_unlock;
949 }
Patrick McHardy513c2502005-09-06 15:43:59 -0700950
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700951 if (nlk->ngroups >= groups)
952 goto out_unlock;
Patrick McHardy513c2502005-09-06 15:43:59 -0700953
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700954 new_groups = krealloc(nlk->groups, NLGRPSZ(groups), GFP_ATOMIC);
955 if (new_groups == NULL) {
956 err = -ENOMEM;
957 goto out_unlock;
958 }
Patrick McHardy6ac552f2007-12-04 00:19:38 -0800959 memset((char *)new_groups + NLGRPSZ(nlk->ngroups), 0,
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700960 NLGRPSZ(groups) - NLGRPSZ(nlk->ngroups));
961
962 nlk->groups = new_groups;
Patrick McHardy513c2502005-09-06 15:43:59 -0700963 nlk->ngroups = groups;
Johannes Bergb4ff4f02007-07-18 15:46:06 -0700964 out_unlock:
965 netlink_table_ungrab();
966 return err;
Patrick McHardy513c2502005-09-06 15:43:59 -0700967}
968
Johannes Berg02c81ab2014-12-22 18:56:35 +0100969static void netlink_undo_bind(int group, long unsigned int groups,
Johannes Berg023e2cf2014-12-23 21:00:06 +0100970 struct sock *sk)
Richard Guy Briggs4f520902014-04-22 21:31:54 -0400971{
Johannes Berg023e2cf2014-12-23 21:00:06 +0100972 struct netlink_sock *nlk = nlk_sk(sk);
Richard Guy Briggs4f520902014-04-22 21:31:54 -0400973 int undo;
974
975 if (!nlk->netlink_unbind)
976 return;
977
978 for (undo = 0; undo < group; undo++)
Hiroaki SHIMODA6251edd2014-11-13 04:24:10 +0900979 if (test_bit(undo, &groups))
Pablo Neira8b7c36d2015-01-29 10:51:53 +0100980 nlk->netlink_unbind(sock_net(sk), undo + 1);
Richard Guy Briggs4f520902014-04-22 21:31:54 -0400981}
982
Patrick McHardy6ac552f2007-12-04 00:19:38 -0800983static int netlink_bind(struct socket *sock, struct sockaddr *addr,
984 int addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985{
986 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900987 struct net *net = sock_net(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 struct netlink_sock *nlk = nlk_sk(sk);
989 struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
Xin Longf7736082017-09-06 11:53:29 +0800990 int err = 0;
Dmitry Safonov428f9442018-09-03 22:40:51 +0100991 unsigned long groups = nladdr->nl_groups;
Herbert Xuda314c92015-09-22 11:38:56 +0800992 bool bound;
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +0900993
Hannes Frederic Sowa4e4b5372012-12-15 15:42:19 +0000994 if (addr_len < sizeof(struct sockaddr_nl))
995 return -EINVAL;
996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 if (nladdr->nl_family != AF_NETLINK)
998 return -EINVAL;
999
1000 /* Only superuser is allowed to listen multicasts */
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001001 if (groups) {
Eric W. Biederman5187cd02014-04-23 14:25:48 -07001002 if (!netlink_allowed(sock, NL_CFG_F_NONROOT_RECV))
Patrick McHardy513c2502005-09-06 15:43:59 -07001003 return -EPERM;
Johannes Bergb4ff4f02007-07-18 15:46:06 -07001004 err = netlink_realloc_groups(sk);
1005 if (err)
1006 return err;
Patrick McHardy513c2502005-09-06 15:43:59 -07001007 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
Dmitry Safonov428f9442018-09-03 22:40:51 +01001009 if (nlk->ngroups < BITS_PER_LONG)
Dmitry Safonov91874ec2018-08-05 01:35:53 +01001010 groups &= (1UL << nlk->ngroups) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011
Herbert Xuda314c92015-09-22 11:38:56 +08001012 bound = nlk->bound;
1013 if (bound) {
1014 /* Ensure nlk->portid is up-to-date. */
1015 smp_rmb();
1016
Eric W. Biederman15e47302012-09-07 20:12:54 +00001017 if (nladdr->nl_pid != nlk->portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 return -EINVAL;
Herbert Xuda314c92015-09-22 11:38:56 +08001019 }
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001020
Xin Longf7736082017-09-06 11:53:29 +08001021 netlink_lock_table();
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001022 if (nlk->netlink_bind && groups) {
1023 int group;
1024
1025 for (group = 0; group < nlk->ngroups; group++) {
1026 if (!test_bit(group, &groups))
1027 continue;
Pablo Neira8b7c36d2015-01-29 10:51:53 +01001028 err = nlk->netlink_bind(net, group + 1);
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001029 if (!err)
1030 continue;
Johannes Berg023e2cf2014-12-23 21:00:06 +01001031 netlink_undo_bind(group, groups, sk);
Xin Longf7736082017-09-06 11:53:29 +08001032 goto unlock;
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001033 }
1034 }
1035
Herbert Xuda314c92015-09-22 11:38:56 +08001036 /* No need for barriers here as we return to user-space without
1037 * using any of the bound attributes.
1038 */
1039 if (!bound) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 err = nladdr->nl_pid ?
Herbert Xu8ea65f42015-01-26 14:02:56 +11001041 netlink_insert(sk, nladdr->nl_pid) :
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 netlink_autobind(sock);
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001043 if (err) {
Johannes Berg023e2cf2014-12-23 21:00:06 +01001044 netlink_undo_bind(nlk->ngroups, groups, sk);
Xin Longf7736082017-09-06 11:53:29 +08001045 goto unlock;
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001046 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 }
1048
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001049 if (!groups && (nlk->groups == NULL || !(u32)nlk->groups[0]))
Xin Longf7736082017-09-06 11:53:29 +08001050 goto unlock;
1051 netlink_unlock_table();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052
1053 netlink_table_grab();
Patrick McHardyf7fa9b12005-08-15 12:29:13 -07001054 netlink_update_subscriptions(sk, nlk->subscriptions +
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001055 hweight32(groups) -
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +09001056 hweight32(nlk->groups[0]));
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001057 nlk->groups[0] = (nlk->groups[0] & ~0xffffffffUL) | groups;
Patrick McHardy4277a082006-03-20 18:52:01 -08001058 netlink_update_listeners(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 netlink_table_ungrab();
1060
1061 return 0;
Xin Longf7736082017-09-06 11:53:29 +08001062
1063unlock:
1064 netlink_unlock_table();
1065 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066}
1067
1068static int netlink_connect(struct socket *sock, struct sockaddr *addr,
1069 int alen, int flags)
1070{
1071 int err = 0;
1072 struct sock *sk = sock->sk;
1073 struct netlink_sock *nlk = nlk_sk(sk);
Patrick McHardy6ac552f2007-12-04 00:19:38 -08001074 struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075
Changli Gao6503d962010-03-31 22:58:26 +00001076 if (alen < sizeof(addr->sa_family))
1077 return -EINVAL;
1078
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 if (addr->sa_family == AF_UNSPEC) {
1080 sk->sk_state = NETLINK_UNCONNECTED;
Eric W. Biederman15e47302012-09-07 20:12:54 +00001081 nlk->dst_portid = 0;
Patrick McHardyd629b832005-08-14 19:27:50 -07001082 nlk->dst_group = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 return 0;
1084 }
1085 if (addr->sa_family != AF_NETLINK)
1086 return -EINVAL;
1087
Alexander Potapenko78802872018-03-23 13:49:02 +01001088 if (alen < sizeof(struct sockaddr_nl))
1089 return -EINVAL;
1090
Mike Pecovnik46833a82014-02-24 21:11:16 +01001091 if ((nladdr->nl_groups || nladdr->nl_pid) &&
Eric W. Biederman5187cd02014-04-23 14:25:48 -07001092 !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 return -EPERM;
1094
Herbert Xuda314c92015-09-22 11:38:56 +08001095 /* No need for barriers here as we return to user-space without
1096 * using any of the bound attributes.
1097 */
1098 if (!nlk->bound)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 err = netlink_autobind(sock);
1100
1101 if (err == 0) {
1102 sk->sk_state = NETLINK_CONNECTED;
Eric W. Biederman15e47302012-09-07 20:12:54 +00001103 nlk->dst_portid = nladdr->nl_pid;
Patrick McHardyd629b832005-08-14 19:27:50 -07001104 nlk->dst_group = ffs(nladdr->nl_groups);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 }
1106
1107 return err;
1108}
1109
Patrick McHardy6ac552f2007-12-04 00:19:38 -08001110static int netlink_getname(struct socket *sock, struct sockaddr *addr,
Denys Vlasenko9b2c45d2018-02-12 20:00:20 +01001111 int peer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112{
1113 struct sock *sk = sock->sk;
1114 struct netlink_sock *nlk = nlk_sk(sk);
Cyrill Gorcunov13cfa972009-11-08 05:51:19 +00001115 DECLARE_SOCKADDR(struct sockaddr_nl *, nladdr, addr);
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +09001116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 nladdr->nl_family = AF_NETLINK;
1118 nladdr->nl_pad = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119
1120 if (peer) {
Eric W. Biederman15e47302012-09-07 20:12:54 +00001121 nladdr->nl_pid = nlk->dst_portid;
Patrick McHardyd629b832005-08-14 19:27:50 -07001122 nladdr->nl_groups = netlink_group_mask(nlk->dst_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 } else {
Eric W. Biederman15e47302012-09-07 20:12:54 +00001124 nladdr->nl_pid = nlk->portid;
Xin Longf7736082017-09-06 11:53:29 +08001125 netlink_lock_table();
Patrick McHardy513c2502005-09-06 15:43:59 -07001126 nladdr->nl_groups = nlk->groups ? nlk->groups[0] : 0;
Xin Longf7736082017-09-06 11:53:29 +08001127 netlink_unlock_table();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 }
Denys Vlasenko9b2c45d2018-02-12 20:00:20 +01001129 return sizeof(*nladdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130}
1131
David Decotigny025c6812016-03-21 10:15:35 -07001132static int netlink_ioctl(struct socket *sock, unsigned int cmd,
1133 unsigned long arg)
1134{
1135 /* try to hand this ioctl down to the NIC drivers.
1136 */
1137 return -ENOIOCTLCMD;
1138}
1139
Eric W. Biederman15e47302012-09-07 20:12:54 +00001140static struct sock *netlink_getsockbyportid(struct sock *ssk, u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 struct sock *sock;
1143 struct netlink_sock *nlk;
1144
Eric W. Biederman15e47302012-09-07 20:12:54 +00001145 sock = netlink_lookup(sock_net(ssk), ssk->sk_protocol, portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 if (!sock)
1147 return ERR_PTR(-ECONNREFUSED);
1148
1149 /* Don't bother queuing skb if kernel socket has no input function */
1150 nlk = nlk_sk(sock);
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07001151 if (sock->sk_state == NETLINK_CONNECTED &&
Eric W. Biederman15e47302012-09-07 20:12:54 +00001152 nlk->dst_portid != nlk_sk(ssk)->portid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 sock_put(sock);
1154 return ERR_PTR(-ECONNREFUSED);
1155 }
1156 return sock;
1157}
1158
1159struct sock *netlink_getsockbyfilp(struct file *filp)
1160{
Al Viro496ad9a2013-01-23 17:07:38 -05001161 struct inode *inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 struct sock *sock;
1163
1164 if (!S_ISSOCK(inode->i_mode))
1165 return ERR_PTR(-ENOTSOCK);
1166
1167 sock = SOCKET_I(inode)->sk;
1168 if (sock->sk_family != AF_NETLINK)
1169 return ERR_PTR(-EINVAL);
1170
1171 sock_hold(sock);
1172 return sock;
1173}
1174
Pablo Neira3a365152013-06-28 03:04:23 +02001175static struct sk_buff *netlink_alloc_large_skb(unsigned int size,
1176 int broadcast)
Pablo Neira Ayusoc05cdb12013-06-03 09:46:28 +00001177{
1178 struct sk_buff *skb;
1179 void *data;
1180
Pablo Neira3a365152013-06-28 03:04:23 +02001181 if (size <= NLMSG_GOODSIZE || broadcast)
Pablo Neira Ayusoc05cdb12013-06-03 09:46:28 +00001182 return alloc_skb(size, GFP_KERNEL);
1183
Pablo Neira3a365152013-06-28 03:04:23 +02001184 size = SKB_DATA_ALIGN(size) +
1185 SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
Pablo Neira Ayusoc05cdb12013-06-03 09:46:28 +00001186
1187 data = vmalloc(size);
1188 if (data == NULL)
Pablo Neira3a365152013-06-28 03:04:23 +02001189 return NULL;
Pablo Neira Ayusoc05cdb12013-06-03 09:46:28 +00001190
Eric Dumazet2ea2f622015-04-24 16:05:01 -07001191 skb = __build_skb(data, size);
Pablo Neira3a365152013-06-28 03:04:23 +02001192 if (skb == NULL)
1193 vfree(data);
Eric Dumazet2ea2f622015-04-24 16:05:01 -07001194 else
Pablo Neira3a365152013-06-28 03:04:23 +02001195 skb->destructor = netlink_skb_destructor;
Pablo Neira Ayusoc05cdb12013-06-03 09:46:28 +00001196
1197 return skb;
Pablo Neira Ayusoc05cdb12013-06-03 09:46:28 +00001198}
1199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200/*
1201 * Attach a skb to a netlink socket.
1202 * The caller must hold a reference to the destination socket. On error, the
1203 * reference is dropped. The skb is not send to the destination, just all
1204 * all error checks are performed and memory in the queue is reserved.
1205 * Return values:
1206 * < 0: error. skb freed, reference to sock dropped.
1207 * 0: continue
1208 * 1: repeat lookup - reference dropped while waiting for socket memory.
1209 */
Denis V. Lunev9457afe2008-06-05 11:23:39 -07001210int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
Patrick McHardyc3d8d1e2007-11-07 02:42:09 -08001211 long *timeo, struct sock *ssk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212{
1213 struct netlink_sock *nlk;
1214
1215 nlk = nlk_sk(sk);
1216
Patrick McHardy5fd96122013-04-17 06:47:03 +00001217 if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
Florian Westphald1b4c682016-02-18 15:03:24 +01001218 test_bit(NETLINK_S_CONGESTED, &nlk->state))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 DECLARE_WAITQUEUE(wait, current);
Patrick McHardyc3d8d1e2007-11-07 02:42:09 -08001220 if (!*timeo) {
Denis V. Lunevaed815602007-10-10 21:14:32 -07001221 if (!ssk || netlink_is_kernel(ssk))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 netlink_overrun(sk);
1223 sock_put(sk);
1224 kfree_skb(skb);
1225 return -EAGAIN;
1226 }
1227
1228 __set_current_state(TASK_INTERRUPTIBLE);
1229 add_wait_queue(&nlk->wait, &wait);
1230
1231 if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001232 test_bit(NETLINK_S_CONGESTED, &nlk->state)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 !sock_flag(sk, SOCK_DEAD))
Patrick McHardyc3d8d1e2007-11-07 02:42:09 -08001234 *timeo = schedule_timeout(*timeo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235
1236 __set_current_state(TASK_RUNNING);
1237 remove_wait_queue(&nlk->wait, &wait);
1238 sock_put(sk);
1239
1240 if (signal_pending(current)) {
1241 kfree_skb(skb);
Patrick McHardyc3d8d1e2007-11-07 02:42:09 -08001242 return sock_intr_errno(*timeo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 }
1244 return 1;
1245 }
Patrick McHardycf0a0182013-04-17 06:47:00 +00001246 netlink_skb_set_owner_r(skb, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 return 0;
1248}
1249
Eric Dumazet4a7e7c22012-04-05 22:17:46 +00001250static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 int len = skb->len;
1253
Cong Wang25e3f702017-12-06 15:03:19 -08001254 netlink_deliver_tap(sock_net(sk), skb);
Daniel Borkmannbcbde0d2013-06-21 19:38:07 +02001255
Florian Westphald1b4c682016-02-18 15:03:24 +01001256 skb_queue_tail(&sk->sk_receive_queue, skb);
David S. Miller676d2362014-04-11 16:15:36 -04001257 sk->sk_data_ready(sk);
Eric Dumazet4a7e7c22012-04-05 22:17:46 +00001258 return len;
1259}
1260
1261int netlink_sendskb(struct sock *sk, struct sk_buff *skb)
1262{
1263 int len = __netlink_sendskb(sk, skb);
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 sock_put(sk);
1266 return len;
1267}
1268
1269void netlink_detachskb(struct sock *sk, struct sk_buff *skb)
1270{
1271 kfree_skb(skb);
1272 sock_put(sk);
1273}
1274
stephen hemmingerb57ef81f2011-12-22 08:52:02 +00001275static struct sk_buff *netlink_trim(struct sk_buff *skb, gfp_t allocation)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276{
1277 int delta;
1278
Patrick McHardy1298ca42013-04-17 06:46:59 +00001279 WARN_ON(skb->sk != NULL);
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -07001280 delta = skb->end - skb->tail;
Pablo Neira Ayusoc05cdb12013-06-03 09:46:28 +00001281 if (is_vmalloc_addr(skb->head) || delta * 2 < skb->truesize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 return skb;
1283
1284 if (skb_shared(skb)) {
1285 struct sk_buff *nskb = skb_clone(skb, allocation);
1286 if (!nskb)
1287 return skb;
Eric Dumazet8460c002012-04-19 02:24:28 +00001288 consume_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 skb = nskb;
1290 }
1291
Eric Dumazet158f3232017-01-27 07:11:27 -08001292 pskb_expand_head(skb, 0, -delta,
1293 (allocation & ~__GFP_DIRECT_RECLAIM) |
1294 __GFP_NOWARN | __GFP_NORETRY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 return skb;
1296}
1297
Eric W. Biederman3fbc2902012-05-24 17:21:27 -06001298static int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb,
1299 struct sock *ssk)
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07001300{
1301 int ret;
1302 struct netlink_sock *nlk = nlk_sk(sk);
1303
1304 ret = -ECONNREFUSED;
1305 if (nlk->netlink_rcv != NULL) {
1306 ret = skb->len;
Patrick McHardycf0a0182013-04-17 06:47:00 +00001307 netlink_skb_set_owner_r(skb, sk);
Patrick McHardye32123e2013-04-17 06:46:57 +00001308 NETLINK_CB(skb).sk = ssk;
Daniel Borkmann73bfd372013-12-23 14:35:55 +01001309 netlink_deliver_tap_kernel(sk, ssk, skb);
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07001310 nlk->netlink_rcv(skb);
Eric Dumazetbfb253c2012-04-22 21:30:29 +00001311 consume_skb(skb);
1312 } else {
1313 kfree_skb(skb);
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07001314 }
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07001315 sock_put(sk);
1316 return ret;
1317}
1318
1319int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
Eric W. Biederman15e47302012-09-07 20:12:54 +00001320 u32 portid, int nonblock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321{
1322 struct sock *sk;
1323 int err;
1324 long timeo;
1325
1326 skb = netlink_trim(skb, gfp_any());
1327
1328 timeo = sock_sndtimeo(ssk, nonblock);
1329retry:
Eric W. Biederman15e47302012-09-07 20:12:54 +00001330 sk = netlink_getsockbyportid(ssk, portid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 if (IS_ERR(sk)) {
1332 kfree_skb(skb);
1333 return PTR_ERR(sk);
1334 }
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07001335 if (netlink_is_kernel(sk))
Eric W. Biederman3fbc2902012-05-24 17:21:27 -06001336 return netlink_unicast_kernel(sk, skb, ssk);
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07001337
Stephen Hemmingerb1153f22008-03-21 15:46:12 -07001338 if (sk_filter(sk, skb)) {
Wang Chen84874602008-07-01 19:55:09 -07001339 err = skb->len;
Stephen Hemmingerb1153f22008-03-21 15:46:12 -07001340 kfree_skb(skb);
1341 sock_put(sk);
1342 return err;
1343 }
1344
Denis V. Lunev9457afe2008-06-05 11:23:39 -07001345 err = netlink_attachskb(sk, skb, &timeo, ssk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 if (err == 1)
1347 goto retry;
1348 if (err)
1349 return err;
1350
Denis V. Lunev7ee015e2007-10-10 21:14:03 -07001351 return netlink_sendskb(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352}
Patrick McHardy6ac552f2007-12-04 00:19:38 -08001353EXPORT_SYMBOL(netlink_unicast);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354
Patrick McHardy4277a082006-03-20 18:52:01 -08001355int netlink_has_listeners(struct sock *sk, unsigned int group)
1356{
1357 int res = 0;
Eric Dumazet5c398dc2010-10-24 04:27:10 +00001358 struct listeners *listeners;
Patrick McHardy4277a082006-03-20 18:52:01 -08001359
Denis V. Lunevaed815602007-10-10 21:14:32 -07001360 BUG_ON(!netlink_is_kernel(sk));
Johannes Bergb4ff4f02007-07-18 15:46:06 -07001361
1362 rcu_read_lock();
1363 listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners);
1364
Eric Dumazet6d772ac2012-10-18 03:21:55 +00001365 if (listeners && group - 1 < nl_table[sk->sk_protocol].groups)
Eric Dumazet5c398dc2010-10-24 04:27:10 +00001366 res = test_bit(group - 1, listeners->masks);
Johannes Bergb4ff4f02007-07-18 15:46:06 -07001367
1368 rcu_read_unlock();
1369
Patrick McHardy4277a082006-03-20 18:52:01 -08001370 return res;
1371}
1372EXPORT_SYMBOL_GPL(netlink_has_listeners);
1373
Jakub Kicinski59c28052019-01-18 10:46:13 -08001374bool netlink_strict_get_check(struct sk_buff *skb)
1375{
1376 const struct netlink_sock *nlk = nlk_sk(NETLINK_CB(skb).sk);
1377
1378 return nlk->flags & NETLINK_F_STRICT_CHK;
1379}
1380EXPORT_SYMBOL_GPL(netlink_strict_get_check);
1381
stephen hemmingerb57ef81f2011-12-22 08:52:02 +00001382static int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383{
1384 struct netlink_sock *nlk = nlk_sk(sk);
1385
1386 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001387 !test_bit(NETLINK_S_CONGESTED, &nlk->state)) {
Patrick McHardycf0a0182013-04-17 06:47:00 +00001388 netlink_skb_set_owner_r(skb, sk);
Eric Dumazet4a7e7c22012-04-05 22:17:46 +00001389 __netlink_sendskb(sk, skb);
stephen hemminger2c6458002011-12-22 08:52:03 +00001390 return atomic_read(&sk->sk_rmem_alloc) > (sk->sk_rcvbuf >> 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 }
1392 return -1;
1393}
1394
1395struct netlink_broadcast_data {
1396 struct sock *exclude_sk;
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02001397 struct net *net;
Eric W. Biederman15e47302012-09-07 20:12:54 +00001398 u32 portid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 u32 group;
1400 int failure;
Pablo Neira Ayusoff491a72009-02-05 23:56:36 -08001401 int delivery_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 int congested;
1403 int delivered;
Al Viro7d877f32005-10-21 03:20:43 -04001404 gfp_t allocation;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 struct sk_buff *skb, *skb2;
Eric W. Biederman910a7e92010-05-04 17:36:46 -07001406 int (*tx_filter)(struct sock *dsk, struct sk_buff *skb, void *data);
1407 void *tx_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408};
1409
Rami Rosen46c95212014-07-01 21:17:35 +03001410static void do_one_broadcast(struct sock *sk,
1411 struct netlink_broadcast_data *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412{
1413 struct netlink_sock *nlk = nlk_sk(sk);
1414 int val;
1415
1416 if (p->exclude_sk == sk)
Rami Rosen46c95212014-07-01 21:17:35 +03001417 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418
Eric W. Biederman15e47302012-09-07 20:12:54 +00001419 if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
Patrick McHardyf7fa9b12005-08-15 12:29:13 -07001420 !test_bit(p->group - 1, nlk->groups))
Rami Rosen46c95212014-07-01 21:17:35 +03001421 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
Nicolas Dichtel59324cf2015-05-07 11:02:53 +02001423 if (!net_eq(sock_net(sk), p->net)) {
1424 if (!(nlk->flags & NETLINK_F_LISTEN_ALL_NSID))
1425 return;
1426
1427 if (!peernet_has_id(sock_net(sk), p->net))
1428 return;
1429
1430 if (!file_ns_capable(sk->sk_socket->file, p->net->user_ns,
1431 CAP_NET_BROADCAST))
1432 return;
1433 }
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02001434
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 if (p->failure) {
1436 netlink_overrun(sk);
Rami Rosen46c95212014-07-01 21:17:35 +03001437 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 }
1439
1440 sock_hold(sk);
1441 if (p->skb2 == NULL) {
Tommy S. Christensen68acc022005-05-19 13:06:35 -07001442 if (skb_shared(p->skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 p->skb2 = skb_clone(p->skb, p->allocation);
1444 } else {
Tommy S. Christensen68acc022005-05-19 13:06:35 -07001445 p->skb2 = skb_get(p->skb);
1446 /*
1447 * skb ownership may have been set when
1448 * delivered to a previous socket.
1449 */
1450 skb_orphan(p->skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 }
1452 }
1453 if (p->skb2 == NULL) {
1454 netlink_overrun(sk);
1455 /* Clone failed. Notify ALL listeners. */
1456 p->failure = 1;
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001457 if (nlk->flags & NETLINK_F_BROADCAST_SEND_ERROR)
Pablo Neira Ayusobe0c22a2009-02-18 01:40:43 +00001458 p->delivery_failure = 1;
Nicolas Dichtel59324cf2015-05-07 11:02:53 +02001459 goto out;
1460 }
1461 if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)) {
Eric W. Biederman910a7e92010-05-04 17:36:46 -07001462 kfree_skb(p->skb2);
1463 p->skb2 = NULL;
Nicolas Dichtel59324cf2015-05-07 11:02:53 +02001464 goto out;
1465 }
1466 if (sk_filter(sk, p->skb2)) {
Stephen Hemmingerb1153f22008-03-21 15:46:12 -07001467 kfree_skb(p->skb2);
1468 p->skb2 = NULL;
Nicolas Dichtel59324cf2015-05-07 11:02:53 +02001469 goto out;
1470 }
1471 NETLINK_CB(p->skb2).nsid = peernet2id(sock_net(sk), p->net);
Nicolas Dichtel72124622017-06-01 10:00:07 +02001472 if (NETLINK_CB(p->skb2).nsid != NETNSA_NSID_NOT_ASSIGNED)
1473 NETLINK_CB(p->skb2).nsid_is_set = true;
Nicolas Dichtel59324cf2015-05-07 11:02:53 +02001474 val = netlink_broadcast_deliver(sk, p->skb2);
1475 if (val < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 netlink_overrun(sk);
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001477 if (nlk->flags & NETLINK_F_BROADCAST_SEND_ERROR)
Pablo Neira Ayusobe0c22a2009-02-18 01:40:43 +00001478 p->delivery_failure = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 } else {
1480 p->congested |= val;
1481 p->delivered = 1;
1482 p->skb2 = NULL;
1483 }
Nicolas Dichtel59324cf2015-05-07 11:02:53 +02001484out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 sock_put(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486}
1487
Eric W. Biederman15e47302012-09-07 20:12:54 +00001488int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid,
Eric W. Biederman910a7e92010-05-04 17:36:46 -07001489 u32 group, gfp_t allocation,
1490 int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),
1491 void *filter_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001493 struct net *net = sock_net(ssk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 struct netlink_broadcast_data info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 struct sock *sk;
1496
1497 skb = netlink_trim(skb, allocation);
1498
1499 info.exclude_sk = ssk;
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02001500 info.net = net;
Eric W. Biederman15e47302012-09-07 20:12:54 +00001501 info.portid = portid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 info.group = group;
1503 info.failure = 0;
Pablo Neira Ayusoff491a72009-02-05 23:56:36 -08001504 info.delivery_failure = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 info.congested = 0;
1506 info.delivered = 0;
1507 info.allocation = allocation;
1508 info.skb = skb;
1509 info.skb2 = NULL;
Eric W. Biederman910a7e92010-05-04 17:36:46 -07001510 info.tx_filter = filter;
1511 info.tx_data = filter_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512
1513 /* While we sleep in clone, do not allow to change socket list */
1514
1515 netlink_lock_table();
1516
Sasha Levinb67bfe02013-02-27 17:06:00 -08001517 sk_for_each_bound(sk, &nl_table[ssk->sk_protocol].mc_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 do_one_broadcast(sk, &info);
1519
Neil Horman70d4bf62010-07-20 06:45:56 +00001520 consume_skb(skb);
Tommy S. Christensenaa1c6a6f2005-05-19 13:07:32 -07001521
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 netlink_unlock_table();
1523
Neil Horman70d4bf62010-07-20 06:45:56 +00001524 if (info.delivery_failure) {
1525 kfree_skb(info.skb2);
Pablo Neira Ayusoff491a72009-02-05 23:56:36 -08001526 return -ENOBUFS;
Eric Dumazet658cb352012-04-22 21:30:21 +00001527 }
1528 consume_skb(info.skb2);
Pablo Neira Ayusoff491a72009-02-05 23:56:36 -08001529
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 if (info.delivered) {
Mel Gormand0164ad2015-11-06 16:28:21 -08001531 if (info.congested && gfpflags_allow_blocking(allocation))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 yield();
1533 return 0;
1534 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 return -ESRCH;
1536}
Eric W. Biederman910a7e92010-05-04 17:36:46 -07001537EXPORT_SYMBOL(netlink_broadcast_filtered);
1538
Eric W. Biederman15e47302012-09-07 20:12:54 +00001539int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 portid,
Eric W. Biederman910a7e92010-05-04 17:36:46 -07001540 u32 group, gfp_t allocation)
1541{
Eric W. Biederman15e47302012-09-07 20:12:54 +00001542 return netlink_broadcast_filtered(ssk, skb, portid, group, allocation,
Eric W. Biederman910a7e92010-05-04 17:36:46 -07001543 NULL, NULL);
1544}
Patrick McHardy6ac552f2007-12-04 00:19:38 -08001545EXPORT_SYMBOL(netlink_broadcast);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
1547struct netlink_set_err_data {
1548 struct sock *exclude_sk;
Eric W. Biederman15e47302012-09-07 20:12:54 +00001549 u32 portid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 u32 group;
1551 int code;
1552};
1553
stephen hemmingerb57ef81f2011-12-22 08:52:02 +00001554static int do_one_set_err(struct sock *sk, struct netlink_set_err_data *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555{
1556 struct netlink_sock *nlk = nlk_sk(sk);
Pablo Neira Ayuso1a503072010-03-18 14:24:42 +00001557 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558
1559 if (sk == p->exclude_sk)
1560 goto out;
1561
Octavian Purdila09ad9bc2009-11-25 15:14:13 -08001562 if (!net_eq(sock_net(sk), sock_net(p->exclude_sk)))
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02001563 goto out;
1564
Eric W. Biederman15e47302012-09-07 20:12:54 +00001565 if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
Patrick McHardyf7fa9b12005-08-15 12:29:13 -07001566 !test_bit(p->group - 1, nlk->groups))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 goto out;
1568
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001569 if (p->code == ENOBUFS && nlk->flags & NETLINK_F_RECV_NO_ENOBUFS) {
Pablo Neira Ayuso1a503072010-03-18 14:24:42 +00001570 ret = 1;
1571 goto out;
1572 }
1573
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 sk->sk_err = p->code;
1575 sk->sk_error_report(sk);
1576out:
Pablo Neira Ayuso1a503072010-03-18 14:24:42 +00001577 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578}
1579
Pablo Neira Ayuso4843b932009-03-03 23:37:30 -08001580/**
1581 * netlink_set_err - report error to broadcast listeners
1582 * @ssk: the kernel netlink socket, as returned by netlink_kernel_create()
Eric W. Biederman15e47302012-09-07 20:12:54 +00001583 * @portid: the PORTID of a process that we want to skip (if any)
Johannes Berg840e93f22013-11-19 10:35:40 +01001584 * @group: the broadcast group that will notice the error
Pablo Neira Ayuso4843b932009-03-03 23:37:30 -08001585 * @code: error code, must be negative (as usual in kernelspace)
Pablo Neira Ayuso1a503072010-03-18 14:24:42 +00001586 *
1587 * This function returns the number of broadcast listeners that have set the
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001588 * NETLINK_NO_ENOBUFS socket option.
Pablo Neira Ayuso4843b932009-03-03 23:37:30 -08001589 */
Eric W. Biederman15e47302012-09-07 20:12:54 +00001590int netlink_set_err(struct sock *ssk, u32 portid, u32 group, int code)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591{
1592 struct netlink_set_err_data info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 struct sock *sk;
Pablo Neira Ayuso1a503072010-03-18 14:24:42 +00001594 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
1596 info.exclude_sk = ssk;
Eric W. Biederman15e47302012-09-07 20:12:54 +00001597 info.portid = portid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 info.group = group;
Pablo Neira Ayuso4843b932009-03-03 23:37:30 -08001599 /* sk->sk_err wants a positive error value */
1600 info.code = -code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601
1602 read_lock(&nl_table_lock);
1603
Sasha Levinb67bfe02013-02-27 17:06:00 -08001604 sk_for_each_bound(sk, &nl_table[ssk->sk_protocol].mc_list)
Pablo Neira Ayuso1a503072010-03-18 14:24:42 +00001605 ret += do_one_set_err(sk, &info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606
1607 read_unlock(&nl_table_lock);
Pablo Neira Ayuso1a503072010-03-18 14:24:42 +00001608 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609}
Pablo Neira Ayusodd5b6ce2009-03-23 13:21:06 +01001610EXPORT_SYMBOL(netlink_set_err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
Johannes Berg84659eb2007-07-18 15:47:05 -07001612/* must be called with netlink table grabbed */
1613static void netlink_update_socket_mc(struct netlink_sock *nlk,
1614 unsigned int group,
1615 int is_new)
1616{
1617 int old, new = !!is_new, subscriptions;
1618
1619 old = test_bit(group - 1, nlk->groups);
1620 subscriptions = nlk->subscriptions - old + new;
1621 if (new)
1622 __set_bit(group - 1, nlk->groups);
1623 else
1624 __clear_bit(group - 1, nlk->groups);
1625 netlink_update_subscriptions(&nlk->sk, subscriptions);
1626 netlink_update_listeners(&nlk->sk);
1627}
1628
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001629static int netlink_setsockopt(struct socket *sock, int level, int optname,
David S. Millerb7058842009-09-30 16:12:20 -07001630 char __user *optval, unsigned int optlen)
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001631{
1632 struct sock *sk = sock->sk;
1633 struct netlink_sock *nlk = nlk_sk(sk);
Johannes Bergeb496532007-07-18 02:07:51 -07001634 unsigned int val = 0;
1635 int err;
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001636
1637 if (level != SOL_NETLINK)
1638 return -ENOPROTOOPT;
1639
Florian Westphald1b4c682016-02-18 15:03:24 +01001640 if (optlen >= sizeof(int) &&
Johannes Bergeb496532007-07-18 02:07:51 -07001641 get_user(val, (unsigned int __user *)optval))
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001642 return -EFAULT;
1643
1644 switch (optname) {
1645 case NETLINK_PKTINFO:
1646 if (val)
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001647 nlk->flags |= NETLINK_F_RECV_PKTINFO;
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001648 else
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001649 nlk->flags &= ~NETLINK_F_RECV_PKTINFO;
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001650 err = 0;
1651 break;
1652 case NETLINK_ADD_MEMBERSHIP:
1653 case NETLINK_DROP_MEMBERSHIP: {
Eric W. Biederman5187cd02014-04-23 14:25:48 -07001654 if (!netlink_allowed(sock, NL_CFG_F_NONROOT_RECV))
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001655 return -EPERM;
Johannes Bergb4ff4f02007-07-18 15:46:06 -07001656 err = netlink_realloc_groups(sk);
1657 if (err)
1658 return err;
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001659 if (!val || val - 1 >= nlk->ngroups)
1660 return -EINVAL;
Richard Guy Briggs7774d5e2014-04-22 21:31:55 -04001661 if (optname == NETLINK_ADD_MEMBERSHIP && nlk->netlink_bind) {
Johannes Berg023e2cf2014-12-23 21:00:06 +01001662 err = nlk->netlink_bind(sock_net(sk), val);
Richard Guy Briggs4f520902014-04-22 21:31:54 -04001663 if (err)
1664 return err;
1665 }
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001666 netlink_table_grab();
Johannes Berg84659eb2007-07-18 15:47:05 -07001667 netlink_update_socket_mc(nlk, val,
1668 optname == NETLINK_ADD_MEMBERSHIP);
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001669 netlink_table_ungrab();
Richard Guy Briggs7774d5e2014-04-22 21:31:55 -04001670 if (optname == NETLINK_DROP_MEMBERSHIP && nlk->netlink_unbind)
Johannes Berg023e2cf2014-12-23 21:00:06 +01001671 nlk->netlink_unbind(sock_net(sk), val);
Pablo Neira Ayuso03292742012-06-29 06:15:22 +00001672
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001673 err = 0;
1674 break;
1675 }
Pablo Neira Ayusobe0c22a2009-02-18 01:40:43 +00001676 case NETLINK_BROADCAST_ERROR:
1677 if (val)
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001678 nlk->flags |= NETLINK_F_BROADCAST_SEND_ERROR;
Pablo Neira Ayusobe0c22a2009-02-18 01:40:43 +00001679 else
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001680 nlk->flags &= ~NETLINK_F_BROADCAST_SEND_ERROR;
Pablo Neira Ayusobe0c22a2009-02-18 01:40:43 +00001681 err = 0;
1682 break;
Pablo Neira Ayuso38938bf2009-03-24 16:37:55 -07001683 case NETLINK_NO_ENOBUFS:
1684 if (val) {
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001685 nlk->flags |= NETLINK_F_RECV_NO_ENOBUFS;
1686 clear_bit(NETLINK_S_CONGESTED, &nlk->state);
Pablo Neira Ayuso38938bf2009-03-24 16:37:55 -07001687 wake_up_interruptible(&nlk->wait);
Eric Dumazet658cb352012-04-22 21:30:21 +00001688 } else {
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001689 nlk->flags &= ~NETLINK_F_RECV_NO_ENOBUFS;
Eric Dumazet658cb352012-04-22 21:30:21 +00001690 }
Pablo Neira Ayuso38938bf2009-03-24 16:37:55 -07001691 err = 0;
1692 break;
Nicolas Dichtel59324cf2015-05-07 11:02:53 +02001693 case NETLINK_LISTEN_ALL_NSID:
1694 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_BROADCAST))
1695 return -EPERM;
1696
1697 if (val)
1698 nlk->flags |= NETLINK_F_LISTEN_ALL_NSID;
1699 else
1700 nlk->flags &= ~NETLINK_F_LISTEN_ALL_NSID;
1701 err = 0;
1702 break;
Christophe Ricard0a6a3a22015-08-28 07:07:48 +02001703 case NETLINK_CAP_ACK:
1704 if (val)
1705 nlk->flags |= NETLINK_F_CAP_ACK;
1706 else
1707 nlk->flags &= ~NETLINK_F_CAP_ACK;
1708 err = 0;
1709 break;
Johannes Berg2d4bc932017-04-12 14:34:04 +02001710 case NETLINK_EXT_ACK:
1711 if (val)
1712 nlk->flags |= NETLINK_F_EXT_ACK;
1713 else
1714 nlk->flags &= ~NETLINK_F_EXT_ACK;
1715 err = 0;
1716 break;
Jakub Kicinskid3e88692018-12-14 11:38:48 -08001717 case NETLINK_GET_STRICT_CHK:
David Ahern89d35522018-10-07 20:16:27 -07001718 if (val)
1719 nlk->flags |= NETLINK_F_STRICT_CHK;
1720 else
1721 nlk->flags &= ~NETLINK_F_STRICT_CHK;
1722 err = 0;
1723 break;
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001724 default:
1725 err = -ENOPROTOOPT;
1726 }
1727 return err;
1728}
1729
1730static int netlink_getsockopt(struct socket *sock, int level, int optname,
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +09001731 char __user *optval, int __user *optlen)
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001732{
1733 struct sock *sk = sock->sk;
1734 struct netlink_sock *nlk = nlk_sk(sk);
1735 int len, val, err;
1736
1737 if (level != SOL_NETLINK)
1738 return -ENOPROTOOPT;
1739
1740 if (get_user(len, optlen))
1741 return -EFAULT;
1742 if (len < 0)
1743 return -EINVAL;
1744
1745 switch (optname) {
1746 case NETLINK_PKTINFO:
1747 if (len < sizeof(int))
1748 return -EINVAL;
1749 len = sizeof(int);
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001750 val = nlk->flags & NETLINK_F_RECV_PKTINFO ? 1 : 0;
Heiko Carstensa27b58f2006-10-30 15:06:12 -08001751 if (put_user(len, optlen) ||
1752 put_user(val, optval))
1753 return -EFAULT;
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001754 err = 0;
1755 break;
Pablo Neira Ayusobe0c22a2009-02-18 01:40:43 +00001756 case NETLINK_BROADCAST_ERROR:
1757 if (len < sizeof(int))
1758 return -EINVAL;
1759 len = sizeof(int);
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001760 val = nlk->flags & NETLINK_F_BROADCAST_SEND_ERROR ? 1 : 0;
Pablo Neira Ayusobe0c22a2009-02-18 01:40:43 +00001761 if (put_user(len, optlen) ||
1762 put_user(val, optval))
1763 return -EFAULT;
1764 err = 0;
1765 break;
Pablo Neira Ayuso38938bf2009-03-24 16:37:55 -07001766 case NETLINK_NO_ENOBUFS:
1767 if (len < sizeof(int))
1768 return -EINVAL;
1769 len = sizeof(int);
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001770 val = nlk->flags & NETLINK_F_RECV_NO_ENOBUFS ? 1 : 0;
Pablo Neira Ayuso38938bf2009-03-24 16:37:55 -07001771 if (put_user(len, optlen) ||
1772 put_user(val, optval))
1773 return -EFAULT;
1774 err = 0;
1775 break;
David Herrmannb42be382015-06-17 17:14:33 +02001776 case NETLINK_LIST_MEMBERSHIPS: {
1777 int pos, idx, shift;
1778
1779 err = 0;
David Herrmann47191d62015-10-21 11:47:43 +02001780 netlink_lock_table();
David Herrmannb42be382015-06-17 17:14:33 +02001781 for (pos = 0; pos * 8 < nlk->ngroups; pos += sizeof(u32)) {
1782 if (len - pos < sizeof(u32))
1783 break;
1784
1785 idx = pos / sizeof(unsigned long);
1786 shift = (pos % sizeof(unsigned long)) * 8;
1787 if (put_user((u32)(nlk->groups[idx] >> shift),
1788 (u32 __user *)(optval + pos))) {
1789 err = -EFAULT;
1790 break;
1791 }
1792 }
1793 if (put_user(ALIGN(nlk->ngroups / 8, sizeof(u32)), optlen))
1794 err = -EFAULT;
David Herrmann47191d62015-10-21 11:47:43 +02001795 netlink_unlock_table();
David Herrmannb42be382015-06-17 17:14:33 +02001796 break;
1797 }
Christophe Ricard0a6a3a22015-08-28 07:07:48 +02001798 case NETLINK_CAP_ACK:
1799 if (len < sizeof(int))
1800 return -EINVAL;
1801 len = sizeof(int);
1802 val = nlk->flags & NETLINK_F_CAP_ACK ? 1 : 0;
1803 if (put_user(len, optlen) ||
1804 put_user(val, optval))
1805 return -EFAULT;
1806 err = 0;
1807 break;
Johannes Berg2d4bc932017-04-12 14:34:04 +02001808 case NETLINK_EXT_ACK:
1809 if (len < sizeof(int))
1810 return -EINVAL;
1811 len = sizeof(int);
1812 val = nlk->flags & NETLINK_F_EXT_ACK ? 1 : 0;
1813 if (put_user(len, optlen) || put_user(val, optval))
1814 return -EFAULT;
1815 err = 0;
1816 break;
Jakub Kicinskid3e88692018-12-14 11:38:48 -08001817 case NETLINK_GET_STRICT_CHK:
David Ahern89d35522018-10-07 20:16:27 -07001818 if (len < sizeof(int))
1819 return -EINVAL;
1820 len = sizeof(int);
1821 val = nlk->flags & NETLINK_F_STRICT_CHK ? 1 : 0;
1822 if (put_user(len, optlen) || put_user(val, optval))
1823 return -EFAULT;
1824 err = 0;
1825 break;
Patrick McHardy9a4595b2005-08-15 12:32:15 -07001826 default:
1827 err = -ENOPROTOOPT;
1828 }
1829 return err;
1830}
1831
1832static void netlink_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
1833{
1834 struct nl_pktinfo info;
1835
1836 info.group = NETLINK_CB(skb).dst_group;
1837 put_cmsg(msg, SOL_NETLINK, NETLINK_PKTINFO, sizeof(info), &info);
1838}
1839
Nicolas Dichtel59324cf2015-05-07 11:02:53 +02001840static void netlink_cmsg_listen_all_nsid(struct sock *sk, struct msghdr *msg,
1841 struct sk_buff *skb)
1842{
1843 if (!NETLINK_CB(skb).nsid_is_set)
1844 return;
1845
1846 put_cmsg(msg, SOL_NETLINK, NETLINK_LISTEN_ALL_NSID, sizeof(int),
1847 &NETLINK_CB(skb).nsid);
1848}
1849
Ying Xue1b784142015-03-02 15:37:48 +08001850static int netlink_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 struct sock *sk = sock->sk;
1853 struct netlink_sock *nlk = nlk_sk(sk);
Steffen Hurrle342dfc32014-01-17 22:53:15 +01001854 DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
Eric W. Biederman15e47302012-09-07 20:12:54 +00001855 u32 dst_portid;
Patrick McHardyd629b832005-08-14 19:27:50 -07001856 u32 dst_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 struct sk_buff *skb;
1858 int err;
1859 struct scm_cookie scm;
Eric W. Biederman2d7a85f2014-05-30 11:04:00 -07001860 u32 netlink_skb_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
1862 if (msg->msg_flags&MSG_OOB)
1863 return -EOPNOTSUPP;
1864
Christoph Hellwig7cc05662015-01-28 18:04:53 +01001865 err = scm_send(sock, msg, &scm, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 if (err < 0)
1867 return err;
1868
1869 if (msg->msg_namelen) {
Eric W. Biedermanb47030c2010-06-13 03:31:06 +00001870 err = -EINVAL;
Eric Dumazet6091f092018-04-07 13:42:37 -07001871 if (msg->msg_namelen < sizeof(struct sockaddr_nl))
1872 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 if (addr->nl_family != AF_NETLINK)
Eric W. Biedermanb47030c2010-06-13 03:31:06 +00001874 goto out;
Eric W. Biederman15e47302012-09-07 20:12:54 +00001875 dst_portid = addr->nl_pid;
Patrick McHardyd629b832005-08-14 19:27:50 -07001876 dst_group = ffs(addr->nl_groups);
Eric W. Biedermanb47030c2010-06-13 03:31:06 +00001877 err = -EPERM;
Eric W. Biederman15e47302012-09-07 20:12:54 +00001878 if ((dst_group || dst_portid) &&
Eric W. Biederman5187cd02014-04-23 14:25:48 -07001879 !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
Eric W. Biedermanb47030c2010-06-13 03:31:06 +00001880 goto out;
Eric W. Biederman2d7a85f2014-05-30 11:04:00 -07001881 netlink_skb_flags |= NETLINK_SKB_DST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 } else {
Eric W. Biederman15e47302012-09-07 20:12:54 +00001883 dst_portid = nlk->dst_portid;
Patrick McHardyd629b832005-08-14 19:27:50 -07001884 dst_group = nlk->dst_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 }
1886
Herbert Xuda314c92015-09-22 11:38:56 +08001887 if (!nlk->bound) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 err = netlink_autobind(sock);
1889 if (err)
1890 goto out;
Herbert Xuda314c92015-09-22 11:38:56 +08001891 } else {
1892 /* Ensure nlk is hashed and visible. */
1893 smp_rmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 }
1895
1896 err = -EMSGSIZE;
1897 if (len > sk->sk_sndbuf - 32)
1898 goto out;
1899 err = -ENOBUFS;
Pablo Neira3a365152013-06-28 03:04:23 +02001900 skb = netlink_alloc_large_skb(len, dst_group);
Patrick McHardy6ac552f2007-12-04 00:19:38 -08001901 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 goto out;
1903
Eric W. Biederman15e47302012-09-07 20:12:54 +00001904 NETLINK_CB(skb).portid = nlk->portid;
Patrick McHardyd629b832005-08-14 19:27:50 -07001905 NETLINK_CB(skb).dst_group = dst_group;
Christoph Hellwig7cc05662015-01-28 18:04:53 +01001906 NETLINK_CB(skb).creds = scm.creds;
Eric W. Biederman2d7a85f2014-05-30 11:04:00 -07001907 NETLINK_CB(skb).flags = netlink_skb_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 err = -EFAULT;
Al Viro6ce8e9c2014-04-06 21:25:44 -04001910 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 kfree_skb(skb);
1912 goto out;
1913 }
1914
1915 err = security_netlink_send(sk, skb);
1916 if (err) {
1917 kfree_skb(skb);
1918 goto out;
1919 }
1920
Patrick McHardyd629b832005-08-14 19:27:50 -07001921 if (dst_group) {
Reshetova, Elena63354792017-06-30 13:07:58 +03001922 refcount_inc(&skb->users);
Eric W. Biederman15e47302012-09-07 20:12:54 +00001923 netlink_broadcast(sk, skb, dst_portid, dst_group, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 }
Eric W. Biederman15e47302012-09-07 20:12:54 +00001925 err = netlink_unicast(sk, skb, dst_portid, msg->msg_flags&MSG_DONTWAIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926
1927out:
Christoph Hellwig7cc05662015-01-28 18:04:53 +01001928 scm_destroy(&scm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 return err;
1930}
1931
Ying Xue1b784142015-03-02 15:37:48 +08001932static int netlink_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 int flags)
1934{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 struct scm_cookie scm;
1936 struct sock *sk = sock->sk;
1937 struct netlink_sock *nlk = nlk_sk(sk);
1938 int noblock = flags&MSG_DONTWAIT;
1939 size_t copied;
Johannes Berg68d6ac62010-08-15 21:20:44 +00001940 struct sk_buff *skb, *data_skb;
Andrey Vaginb44d2112011-02-21 02:40:47 +00001941 int err, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942
1943 if (flags&MSG_OOB)
1944 return -EOPNOTSUPP;
1945
1946 copied = 0;
1947
Patrick McHardy6ac552f2007-12-04 00:19:38 -08001948 skb = skb_recv_datagram(sk, flags, noblock, &err);
1949 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 goto out;
1951
Johannes Berg68d6ac62010-08-15 21:20:44 +00001952 data_skb = skb;
1953
Johannes Berg1dacc762009-07-01 11:26:02 +00001954#ifdef CONFIG_COMPAT_NETLINK_MESSAGES
1955 if (unlikely(skb_shinfo(skb)->frag_list)) {
Johannes Berg1dacc762009-07-01 11:26:02 +00001956 /*
Johannes Berg68d6ac62010-08-15 21:20:44 +00001957 * If this skb has a frag_list, then here that means that we
1958 * will have to use the frag_list skb's data for compat tasks
1959 * and the regular skb's data for normal (non-compat) tasks.
Johannes Berg1dacc762009-07-01 11:26:02 +00001960 *
Johannes Berg68d6ac62010-08-15 21:20:44 +00001961 * If we need to send the compat skb, assign it to the
1962 * 'data_skb' variable so that it will be used below for data
1963 * copying. We keep 'skb' for everything else, including
1964 * freeing both later.
Johannes Berg1dacc762009-07-01 11:26:02 +00001965 */
Johannes Berg68d6ac62010-08-15 21:20:44 +00001966 if (flags & MSG_CMSG_COMPAT)
1967 data_skb = skb_shinfo(skb)->frag_list;
Johannes Berg1dacc762009-07-01 11:26:02 +00001968 }
1969#endif
1970
Eric Dumazet9063e212014-03-07 12:02:33 -08001971 /* Record the max length of recvmsg() calls for future allocations */
1972 nlk->max_recvmsg_len = max(nlk->max_recvmsg_len, len);
1973 nlk->max_recvmsg_len = min_t(size_t, nlk->max_recvmsg_len,
Eric Dumazetd35c99f2016-10-06 04:13:18 +09001974 SKB_WITH_OVERHEAD(32768));
Eric Dumazet9063e212014-03-07 12:02:33 -08001975
Johannes Berg68d6ac62010-08-15 21:20:44 +00001976 copied = data_skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 if (len < copied) {
1978 msg->msg_flags |= MSG_TRUNC;
1979 copied = len;
1980 }
1981
Johannes Berg68d6ac62010-08-15 21:20:44 +00001982 skb_reset_transport_header(data_skb);
David S. Miller51f3d022014-11-05 16:46:40 -05001983 err = skb_copy_datagram_msg(data_skb, 0, msg, copied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984
1985 if (msg->msg_name) {
Steffen Hurrle342dfc32014-01-17 22:53:15 +01001986 DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 addr->nl_family = AF_NETLINK;
1988 addr->nl_pad = 0;
Eric W. Biederman15e47302012-09-07 20:12:54 +00001989 addr->nl_pid = NETLINK_CB(skb).portid;
Patrick McHardyd629b832005-08-14 19:27:50 -07001990 addr->nl_groups = netlink_group_mask(NETLINK_CB(skb).dst_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 msg->msg_namelen = sizeof(*addr);
1992 }
1993
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02001994 if (nlk->flags & NETLINK_F_RECV_PKTINFO)
Patrick McHardycc9a06c2006-03-12 20:34:27 -08001995 netlink_cmsg_recv_pktinfo(msg, skb);
Nicolas Dichtel59324cf2015-05-07 11:02:53 +02001996 if (nlk->flags & NETLINK_F_LISTEN_ALL_NSID)
1997 netlink_cmsg_listen_all_nsid(sk, msg, skb);
Patrick McHardycc9a06c2006-03-12 20:34:27 -08001998
Christoph Hellwig7cc05662015-01-28 18:04:53 +01001999 memset(&scm, 0, sizeof(scm));
2000 scm.creds = *NETLINK_CREDS(skb);
Patrick McHardy188ccb52007-05-03 03:27:01 -07002001 if (flags & MSG_TRUNC)
Johannes Berg68d6ac62010-08-15 21:20:44 +00002002 copied = data_skb->len;
David S. Millerdaa37662010-08-15 23:21:50 -07002003
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 skb_free_datagram(sk, skb);
2005
Pravin B Shelar16b304f2013-08-15 15:31:06 -07002006 if (nlk->cb_running &&
2007 atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2) {
Andrey Vaginb44d2112011-02-21 02:40:47 +00002008 ret = netlink_dump(sk);
2009 if (ret) {
Ben Pfaffac30ef82014-07-09 10:31:22 -07002010 sk->sk_err = -ret;
Andrey Vaginb44d2112011-02-21 02:40:47 +00002011 sk->sk_error_report(sk);
2012 }
2013 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014
Christoph Hellwig7cc05662015-01-28 18:04:53 +01002015 scm_recv(sock, msg, &scm, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016out:
2017 netlink_rcv_wake(sk);
2018 return err ? : copied;
2019}
2020
David S. Miller676d2362014-04-11 16:15:36 -04002021static void netlink_data_ready(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022{
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07002023 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024}
2025
2026/*
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +09002027 * We export these functions to other modules. They provide a
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 * complete set of kernel non-blocking support for message
2029 * queueing.
2030 */
2031
2032struct sock *
Pablo Neira Ayuso9f00d972012-09-08 02:53:54 +00002033__netlink_kernel_create(struct net *net, int unit, struct module *module,
2034 struct netlink_kernel_cfg *cfg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035{
2036 struct socket *sock;
2037 struct sock *sk;
Patrick McHardy77247bb2005-08-14 19:27:13 -07002038 struct netlink_sock *nlk;
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002039 struct listeners *listeners = NULL;
Pablo Neira Ayusoa31f2d12012-06-29 06:15:21 +00002040 struct mutex *cb_mutex = cfg ? cfg->cb_mutex : NULL;
2041 unsigned int groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042
Akinobu Mitafab2caf2006-08-29 02:15:24 -07002043 BUG_ON(!nl_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044
Patrick McHardy6ac552f2007-12-04 00:19:38 -08002045 if (unit < 0 || unit >= MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 return NULL;
2047
2048 if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
2049 return NULL;
Eric W. Biederman13d30782015-05-08 21:11:33 -05002050
2051 if (__netlink_create(net, sock, cb_mutex, unit, 1) < 0)
Pavel Emelyanov23fe1862008-01-30 19:31:06 -08002052 goto out_sock_release_nosk;
2053
2054 sk = sock->sk;
Harald Welte4fdb3bb2005-08-09 19:40:55 -07002055
Pablo Neira Ayusoa31f2d12012-06-29 06:15:21 +00002056 if (!cfg || cfg->groups < 32)
Patrick McHardy4277a082006-03-20 18:52:01 -08002057 groups = 32;
Pablo Neira Ayusoa31f2d12012-06-29 06:15:21 +00002058 else
2059 groups = cfg->groups;
Patrick McHardy4277a082006-03-20 18:52:01 -08002060
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002061 listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL);
Patrick McHardy4277a082006-03-20 18:52:01 -08002062 if (!listeners)
2063 goto out_sock_release;
2064
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 sk->sk_data_ready = netlink_data_ready;
Pablo Neira Ayusoa31f2d12012-06-29 06:15:21 +00002066 if (cfg && cfg->input)
2067 nlk_sk(sk)->netlink_rcv = cfg->input;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068
Herbert Xu8ea65f42015-01-26 14:02:56 +11002069 if (netlink_insert(sk, 0))
Patrick McHardy77247bb2005-08-14 19:27:13 -07002070 goto out_sock_release;
2071
2072 nlk = nlk_sk(sk);
Nicolas Dichtelcc3a5722015-05-07 11:02:52 +02002073 nlk->flags |= NETLINK_F_KERNEL_SOCKET;
Patrick McHardy77247bb2005-08-14 19:27:13 -07002074
2075 netlink_table_grab();
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002076 if (!nl_table[unit].registered) {
2077 nl_table[unit].groups = groups;
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002078 rcu_assign_pointer(nl_table[unit].listeners, listeners);
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002079 nl_table[unit].cb_mutex = cb_mutex;
2080 nl_table[unit].module = module;
Pablo Neira Ayuso9785e102012-09-08 02:53:53 +00002081 if (cfg) {
2082 nl_table[unit].bind = cfg->bind;
Hiroaki SHIMODA6251edd2014-11-13 04:24:10 +09002083 nl_table[unit].unbind = cfg->unbind;
Pablo Neira Ayuso9785e102012-09-08 02:53:53 +00002084 nl_table[unit].flags = cfg->flags;
Gao fengda12c902013-06-06 14:49:11 +08002085 if (cfg->compare)
2086 nl_table[unit].compare = cfg->compare;
Pablo Neira Ayuso9785e102012-09-08 02:53:53 +00002087 }
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002088 nl_table[unit].registered = 1;
Jesper Juhlf937f1f462007-10-15 01:39:12 -07002089 } else {
2090 kfree(listeners);
Denis V. Lunev869e58f2008-01-18 23:53:31 -08002091 nl_table[unit].registered++;
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002092 }
Patrick McHardy77247bb2005-08-14 19:27:13 -07002093 netlink_table_ungrab();
Harald Welte4fdb3bb2005-08-09 19:40:55 -07002094 return sk;
2095
Harald Welte4fdb3bb2005-08-09 19:40:55 -07002096out_sock_release:
Patrick McHardy4277a082006-03-20 18:52:01 -08002097 kfree(listeners);
Denis V. Lunev9dfbec12008-02-29 11:17:56 -08002098 netlink_kernel_release(sk);
Pavel Emelyanov23fe1862008-01-30 19:31:06 -08002099 return NULL;
2100
2101out_sock_release_nosk:
Harald Welte4fdb3bb2005-08-09 19:40:55 -07002102 sock_release(sock);
Patrick McHardy77247bb2005-08-14 19:27:13 -07002103 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104}
Pablo Neira Ayuso9f00d972012-09-08 02:53:54 +00002105EXPORT_SYMBOL(__netlink_kernel_create);
Denis V. Lunevb7c6ba62008-01-28 14:41:19 -08002106
2107void
2108netlink_kernel_release(struct sock *sk)
2109{
Eric W. Biederman13d30782015-05-08 21:11:33 -05002110 if (sk == NULL || sk->sk_socket == NULL)
2111 return;
2112
2113 sock_release(sk->sk_socket);
Denis V. Lunevb7c6ba62008-01-28 14:41:19 -08002114}
2115EXPORT_SYMBOL(netlink_kernel_release);
2116
Johannes Bergd136f1b2009-09-12 03:03:15 +00002117int __netlink_change_ngroups(struct sock *sk, unsigned int groups)
Johannes Bergb4ff4f02007-07-18 15:46:06 -07002118{
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002119 struct listeners *new, *old;
Johannes Bergb4ff4f02007-07-18 15:46:06 -07002120 struct netlink_table *tbl = &nl_table[sk->sk_protocol];
Johannes Bergb4ff4f02007-07-18 15:46:06 -07002121
2122 if (groups < 32)
2123 groups = 32;
2124
Johannes Bergb4ff4f02007-07-18 15:46:06 -07002125 if (NLGRPSZ(tbl->groups) < NLGRPSZ(groups)) {
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002126 new = kzalloc(sizeof(*new) + NLGRPSZ(groups), GFP_ATOMIC);
2127 if (!new)
Johannes Bergd136f1b2009-09-12 03:03:15 +00002128 return -ENOMEM;
Eric Dumazet6d772ac2012-10-18 03:21:55 +00002129 old = nl_deref_protected(tbl->listeners);
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002130 memcpy(new->masks, old->masks, NLGRPSZ(tbl->groups));
2131 rcu_assign_pointer(tbl->listeners, new);
2132
Lai Jiangshan37b6b932011-03-15 18:01:42 +08002133 kfree_rcu(old, rcu);
Johannes Bergb4ff4f02007-07-18 15:46:06 -07002134 }
2135 tbl->groups = groups;
2136
Johannes Bergd136f1b2009-09-12 03:03:15 +00002137 return 0;
2138}
2139
2140/**
2141 * netlink_change_ngroups - change number of multicast groups
2142 *
2143 * This changes the number of multicast groups that are available
2144 * on a certain netlink family. Note that it is not possible to
2145 * change the number of groups to below 32. Also note that it does
2146 * not implicitly call netlink_clear_multicast_users() when the
2147 * number of groups is reduced.
2148 *
2149 * @sk: The kernel netlink socket, as returned by netlink_kernel_create().
2150 * @groups: The new number of groups.
2151 */
2152int netlink_change_ngroups(struct sock *sk, unsigned int groups)
2153{
2154 int err;
2155
2156 netlink_table_grab();
2157 err = __netlink_change_ngroups(sk, groups);
Johannes Bergb4ff4f02007-07-18 15:46:06 -07002158 netlink_table_ungrab();
Johannes Bergd136f1b2009-09-12 03:03:15 +00002159
Johannes Bergb4ff4f02007-07-18 15:46:06 -07002160 return err;
2161}
Johannes Bergb4ff4f02007-07-18 15:46:06 -07002162
Johannes Bergb8273572009-09-24 15:44:05 -07002163void __netlink_clear_multicast_users(struct sock *ksk, unsigned int group)
2164{
2165 struct sock *sk;
Johannes Bergb8273572009-09-24 15:44:05 -07002166 struct netlink_table *tbl = &nl_table[ksk->sk_protocol];
2167
Sasha Levinb67bfe02013-02-27 17:06:00 -08002168 sk_for_each_bound(sk, &tbl->mc_list)
Johannes Bergb8273572009-09-24 15:44:05 -07002169 netlink_update_socket_mc(nlk_sk(sk), group, 0);
2170}
2171
Denys Vlasenkoa46621a2012-01-30 15:22:06 -05002172struct nlmsghdr *
Eric W. Biederman15e47302012-09-07 20:12:54 +00002173__nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, int type, int len, int flags)
Denys Vlasenkoa46621a2012-01-30 15:22:06 -05002174{
2175 struct nlmsghdr *nlh;
Hong zhi guo573ce262013-03-27 06:47:04 +00002176 int size = nlmsg_msg_size(len);
Denys Vlasenkoa46621a2012-01-30 15:22:06 -05002177
Johannes Berg4df864c2017-06-16 14:29:21 +02002178 nlh = skb_put(skb, NLMSG_ALIGN(size));
Denys Vlasenkoa46621a2012-01-30 15:22:06 -05002179 nlh->nlmsg_type = type;
2180 nlh->nlmsg_len = size;
2181 nlh->nlmsg_flags = flags;
Eric W. Biederman15e47302012-09-07 20:12:54 +00002182 nlh->nlmsg_pid = portid;
Denys Vlasenkoa46621a2012-01-30 15:22:06 -05002183 nlh->nlmsg_seq = seq;
2184 if (!__builtin_constant_p(size) || NLMSG_ALIGN(size) - size != 0)
Hong zhi guo573ce262013-03-27 06:47:04 +00002185 memset(nlmsg_data(nlh) + len, 0, NLMSG_ALIGN(size) - size);
Denys Vlasenkoa46621a2012-01-30 15:22:06 -05002186 return nlh;
2187}
2188EXPORT_SYMBOL(__nlmsg_put);
2189
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190/*
2191 * It looks a bit ugly.
2192 * It would be better to create kernel thread.
2193 */
2194
2195static int netlink_dump(struct sock *sk)
2196{
2197 struct netlink_sock *nlk = nlk_sk(sk);
David Ahern4a19edb2018-10-07 20:16:22 -07002198 struct netlink_ext_ack extack = {};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 struct netlink_callback *cb;
Greg Rosec7ac8672011-06-10 01:27:09 +00002200 struct sk_buff *skb = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 struct nlmsghdr *nlh;
Herbert Xu92964c72016-05-16 17:28:16 +08002202 struct module *module;
Jason A. Donenfeld06428402017-11-09 13:04:44 +09002203 int err = -ENOBUFS;
Arad, Ronendb65a3a2015-10-15 01:55:17 -07002204 int alloc_min_size;
Greg Rosec7ac8672011-06-10 01:27:09 +00002205 int alloc_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206
Patrick McHardyaf65bdf2007-04-20 14:14:21 -07002207 mutex_lock(nlk->cb_mutex);
Pravin B Shelar16b304f2013-08-15 15:31:06 -07002208 if (!nlk->cb_running) {
Thomas Grafbf8b79e2006-08-04 23:03:29 -07002209 err = -EINVAL;
2210 goto errout_skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 }
2212
Florian Westphald1b4c682016-02-18 15:03:24 +01002213 if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
Patrick McHardyf9c22882013-04-17 06:47:04 +00002214 goto errout_skb;
Eric Dumazet9063e212014-03-07 12:02:33 -08002215
2216 /* NLMSG_GOODSIZE is small to avoid high order allocations being
2217 * required, but it makes sense to _attempt_ a 16K bytes allocation
2218 * to reduce number of system calls on dump operations, if user
2219 * ever provided a big enough buffer.
2220 */
Arad, Ronendb65a3a2015-10-15 01:55:17 -07002221 cb = &nlk->cb;
2222 alloc_min_size = max_t(int, cb->min_dump_alloc, NLMSG_GOODSIZE);
2223
2224 if (alloc_min_size < nlk->max_recvmsg_len) {
2225 alloc_size = nlk->max_recvmsg_len;
Eric Dumazetd35c99f2016-10-06 04:13:18 +09002226 skb = alloc_skb(alloc_size,
2227 (GFP_KERNEL & ~__GFP_DIRECT_RECLAIM) |
2228 __GFP_NOWARN | __GFP_NORETRY);
Eric Dumazet9063e212014-03-07 12:02:33 -08002229 }
Arad, Ronendb65a3a2015-10-15 01:55:17 -07002230 if (!skb) {
2231 alloc_size = alloc_min_size;
Florian Westphalc5b0db32016-02-18 15:03:28 +01002232 skb = alloc_skb(alloc_size, GFP_KERNEL);
Arad, Ronendb65a3a2015-10-15 01:55:17 -07002233 }
Greg Rosec7ac8672011-06-10 01:27:09 +00002234 if (!skb)
Dan Carpenterc63d6ea2011-06-15 03:11:42 +00002235 goto errout_skb;
Arad, Ronendb65a3a2015-10-15 01:55:17 -07002236
2237 /* Trim skb to allocated size. User is expected to provide buffer as
2238 * large as max(min_dump_alloc, 16KiB (mac_recvmsg_len capped at
2239 * netlink_recvmsg())). dump will pack as many smaller messages as
2240 * could fit within the allocated skb. skb is typically allocated
2241 * with larger space than required (could be as much as near 2x the
2242 * requested size with align to next power of 2 approach). Allowing
2243 * dump to use the excess space makes it difficult for a user to have a
2244 * reasonable static buffer based on the expected largest dump of a
2245 * single netdev. The outcome is MSG_TRUNC error.
2246 */
Florian Westphald1b4c682016-02-18 15:03:24 +01002247 skb_reserve(skb, skb_tailroom(skb) - alloc_size);
Patrick McHardyf9c22882013-04-17 06:47:04 +00002248 netlink_skb_set_owner_r(skb, sk);
Greg Rosec7ac8672011-06-10 01:27:09 +00002249
David Ahern4a19edb2018-10-07 20:16:22 -07002250 if (nlk->dump_done_errno > 0) {
2251 cb->extack = &extack;
Jason A. Donenfeld06428402017-11-09 13:04:44 +09002252 nlk->dump_done_errno = cb->dump(skb, cb);
David Ahern4a19edb2018-10-07 20:16:22 -07002253 cb->extack = NULL;
2254 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255
Jason A. Donenfeld06428402017-11-09 13:04:44 +09002256 if (nlk->dump_done_errno > 0 ||
2257 skb_tailroom(skb) < nlmsg_total_size(sizeof(nlk->dump_done_errno))) {
Patrick McHardyaf65bdf2007-04-20 14:14:21 -07002258 mutex_unlock(nlk->cb_mutex);
Stephen Hemmingerb1153f22008-03-21 15:46:12 -07002259
2260 if (sk_filter(sk, skb))
2261 kfree_skb(skb);
Eric Dumazet4a7e7c22012-04-05 22:17:46 +00002262 else
2263 __netlink_sendskb(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 return 0;
2265 }
2266
Jason A. Donenfeld06428402017-11-09 13:04:44 +09002267 nlh = nlmsg_put_answer(skb, cb, NLMSG_DONE,
David Ahern22e6c582018-10-15 18:56:41 -07002268 sizeof(nlk->dump_done_errno),
2269 NLM_F_MULTI | cb->answer_flags);
Jason A. Donenfeld06428402017-11-09 13:04:44 +09002270 if (WARN_ON(!nlh))
Thomas Grafbf8b79e2006-08-04 23:03:29 -07002271 goto errout_skb;
2272
Johannes Berg670dc282011-06-20 13:40:46 +02002273 nl_dump_check_consistent(cb, nlh);
2274
Jason A. Donenfeld06428402017-11-09 13:04:44 +09002275 memcpy(nlmsg_data(nlh), &nlk->dump_done_errno,
2276 sizeof(nlk->dump_done_errno));
Thomas Grafbf8b79e2006-08-04 23:03:29 -07002277
David Ahern4a19edb2018-10-07 20:16:22 -07002278 if (extack._msg && nlk->flags & NETLINK_F_EXT_ACK) {
2279 nlh->nlmsg_flags |= NLM_F_ACK_TLVS;
2280 if (!nla_put_string(skb, NLMSGERR_ATTR_MSG, extack._msg))
2281 nlmsg_end(skb, nlh);
2282 }
2283
Stephen Hemmingerb1153f22008-03-21 15:46:12 -07002284 if (sk_filter(sk, skb))
2285 kfree_skb(skb);
Eric Dumazet4a7e7c22012-04-05 22:17:46 +00002286 else
2287 __netlink_sendskb(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288
Thomas Grafa8f74b22005-11-10 02:25:52 +01002289 if (cb->done)
2290 cb->done(cb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291
Pravin B Shelar16b304f2013-08-15 15:31:06 -07002292 nlk->cb_running = false;
Herbert Xu92964c72016-05-16 17:28:16 +08002293 module = cb->module;
2294 skb = cb->skb;
Pravin B Shelar16b304f2013-08-15 15:31:06 -07002295 mutex_unlock(nlk->cb_mutex);
Herbert Xu92964c72016-05-16 17:28:16 +08002296 module_put(module);
2297 consume_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 return 0;
Thomas Graf17977542005-06-18 22:53:48 -07002299
Thomas Grafbf8b79e2006-08-04 23:03:29 -07002300errout_skb:
Patrick McHardyaf65bdf2007-04-20 14:14:21 -07002301 mutex_unlock(nlk->cb_mutex);
Thomas Grafbf8b79e2006-08-04 23:03:29 -07002302 kfree_skb(skb);
Thomas Grafbf8b79e2006-08-04 23:03:29 -07002303 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304}
2305
Gao feng6dc878a2012-10-04 20:15:48 +00002306int __netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
2307 const struct nlmsghdr *nlh,
2308 struct netlink_dump_control *control)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309{
David Ahern89d35522018-10-07 20:16:27 -07002310 struct netlink_sock *nlk, *nlk2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 struct netlink_callback *cb;
2312 struct sock *sk;
Andrey Vaginb44d2112011-02-21 02:40:47 +00002313 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314
Reshetova, Elena63354792017-06-30 13:07:58 +03002315 refcount_inc(&skb->users);
Patrick McHardyf9c22882013-04-17 06:47:04 +00002316
Pravin B Shelar16b304f2013-08-15 15:31:06 -07002317 sk = netlink_lookup(sock_net(ssk), ssk->sk_protocol, NETLINK_CB(skb).portid);
2318 if (sk == NULL) {
2319 ret = -ECONNREFUSED;
2320 goto error_free;
2321 }
2322
2323 nlk = nlk_sk(sk);
2324 mutex_lock(nlk->cb_mutex);
2325 /* A dump is in progress... */
2326 if (nlk->cb_running) {
2327 ret = -EBUSY;
2328 goto error_unlock;
2329 }
2330 /* add reference of module which cb->dump belongs to */
2331 if (!try_module_get(control->module)) {
2332 ret = -EPROTONOSUPPORT;
2333 goto error_unlock;
2334 }
2335
2336 cb = &nlk->cb;
2337 memset(cb, 0, sizeof(*cb));
Pablo Neira Ayuso80d326f2012-02-24 14:30:15 +00002338 cb->dump = control->dump;
2339 cb->done = control->done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 cb->nlh = nlh;
Pablo Neira Ayuso7175c882012-02-24 14:30:16 +00002341 cb->data = control->data;
Gao feng6dc878a2012-10-04 20:15:48 +00002342 cb->module = control->module;
Pablo Neira Ayuso80d326f2012-02-24 14:30:15 +00002343 cb->min_dump_alloc = control->min_dump_alloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 cb->skb = skb;
2345
David Ahern89d35522018-10-07 20:16:27 -07002346 nlk2 = nlk_sk(NETLINK_CB(skb).sk);
2347 cb->strict_check = !!(nlk2->flags & NETLINK_F_STRICT_CHK);
2348
Florian Westphal3730cf42018-07-24 12:47:56 +02002349 if (control->start) {
2350 ret = control->start(cb);
Jason A. Donenfeld41c87422017-10-09 14:14:51 +02002351 if (ret)
Jason A. Donenfeldb87b6192018-02-21 04:41:59 +01002352 goto error_put;
Jason A. Donenfeld41c87422017-10-09 14:14:51 +02002353 }
2354
Pravin B Shelar16b304f2013-08-15 15:31:06 -07002355 nlk->cb_running = true;
Jason A. Donenfeld06428402017-11-09 13:04:44 +09002356 nlk->dump_done_errno = INT_MAX;
Gao feng6dc878a2012-10-04 20:15:48 +00002357
Patrick McHardyaf65bdf2007-04-20 14:14:21 -07002358 mutex_unlock(nlk->cb_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359
Jason A. Donenfeld41c87422017-10-09 14:14:51 +02002360 ret = netlink_dump(sk);
Jason A. Donenfeldfef00352017-09-28 00:41:44 +02002361
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 sock_put(sk);
Denis V. Lunev5c582982007-10-23 20:29:25 -07002363
Andrey Vaginb44d2112011-02-21 02:40:47 +00002364 if (ret)
2365 return ret;
2366
Denis V. Lunev5c582982007-10-23 20:29:25 -07002367 /* We successfully started a dump, by returning -EINTR we
2368 * signal not to send ACK even if it was requested.
2369 */
2370 return -EINTR;
Pravin B Shelar16b304f2013-08-15 15:31:06 -07002371
Jason A. Donenfeldb87b6192018-02-21 04:41:59 +01002372error_put:
2373 module_put(control->module);
Pravin B Shelar16b304f2013-08-15 15:31:06 -07002374error_unlock:
2375 sock_put(sk);
2376 mutex_unlock(nlk->cb_mutex);
2377error_free:
2378 kfree_skb(skb);
2379 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380}
Gao feng6dc878a2012-10-04 20:15:48 +00002381EXPORT_SYMBOL(__netlink_dump_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382
Johannes Berg2d4bc932017-04-12 14:34:04 +02002383void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err,
2384 const struct netlink_ext_ack *extack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385{
2386 struct sk_buff *skb;
2387 struct nlmsghdr *rep;
2388 struct nlmsgerr *errmsg;
Thomas Graf339bf982006-11-10 14:10:15 -08002389 size_t payload = sizeof(*errmsg);
Johannes Berg2d4bc932017-04-12 14:34:04 +02002390 size_t tlvlen = 0;
Christophe Ricard0a6a3a22015-08-28 07:07:48 +02002391 struct netlink_sock *nlk = nlk_sk(NETLINK_CB(in_skb).sk);
Johannes Berg2d4bc932017-04-12 14:34:04 +02002392 unsigned int flags = 0;
Johannes Berg48044eb2017-10-16 17:09:53 +02002393 bool nlk_has_extack = nlk->flags & NETLINK_F_EXT_ACK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394
Christophe Ricard0a6a3a22015-08-28 07:07:48 +02002395 /* Error messages get the original request appened, unless the user
Johannes Berg2d4bc932017-04-12 14:34:04 +02002396 * requests to cap the error message, and get extra error data if
2397 * requested.
Christophe Ricard0a6a3a22015-08-28 07:07:48 +02002398 */
David Ahern4f6265d2017-10-27 17:37:12 -07002399 if (nlk_has_extack && extack && extack->_msg)
2400 tlvlen += nla_total_size(strlen(extack->_msg) + 1);
2401
Johannes Berg2d4bc932017-04-12 14:34:04 +02002402 if (err) {
2403 if (!(nlk->flags & NETLINK_F_CAP_ACK))
2404 payload += nlmsg_len(nlh);
2405 else
2406 flags |= NLM_F_CAPPED;
David Ahern4f6265d2017-10-27 17:37:12 -07002407 if (nlk_has_extack && extack && extack->bad_attr)
2408 tlvlen += nla_total_size(sizeof(u32));
Johannes Berg2d4bc932017-04-12 14:34:04 +02002409 } else {
2410 flags |= NLM_F_CAPPED;
Johannes Bergba0dc5f2017-04-12 14:34:06 +02002411
Johannes Berg48044eb2017-10-16 17:09:53 +02002412 if (nlk_has_extack && extack && extack->cookie_len)
Johannes Bergba0dc5f2017-04-12 14:34:06 +02002413 tlvlen += nla_total_size(extack->cookie_len);
Johannes Berg2d4bc932017-04-12 14:34:04 +02002414 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415
Johannes Berg2d4bc932017-04-12 14:34:04 +02002416 if (tlvlen)
2417 flags |= NLM_F_ACK_TLVS;
2418
2419 skb = nlmsg_new(payload + tlvlen, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 if (!skb) {
Johannes Berga2084f52017-10-16 16:57:49 +02002421 NETLINK_CB(in_skb).sk->sk_err = ENOBUFS;
2422 NETLINK_CB(in_skb).sk->sk_error_report(NETLINK_CB(in_skb).sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 return;
2424 }
2425
Eric W. Biederman15e47302012-09-07 20:12:54 +00002426 rep = __nlmsg_put(skb, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
Johannes Berg2d4bc932017-04-12 14:34:04 +02002427 NLMSG_ERROR, payload, flags);
Thomas Grafbf8b79e2006-08-04 23:03:29 -07002428 errmsg = nlmsg_data(rep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 errmsg->error = err;
Christophe Ricard0a6a3a22015-08-28 07:07:48 +02002430 memcpy(&errmsg->msg, nlh, payload > sizeof(*errmsg) ? nlh->nlmsg_len : sizeof(*nlh));
Johannes Berg2d4bc932017-04-12 14:34:04 +02002431
Johannes Berg48044eb2017-10-16 17:09:53 +02002432 if (nlk_has_extack && extack) {
David Ahern4f6265d2017-10-27 17:37:12 -07002433 if (extack->_msg) {
2434 WARN_ON(nla_put_string(skb, NLMSGERR_ATTR_MSG,
2435 extack->_msg));
2436 }
Johannes Bergba0dc5f2017-04-12 14:34:06 +02002437 if (err) {
Johannes Bergba0dc5f2017-04-12 14:34:06 +02002438 if (extack->bad_attr &&
2439 !WARN_ON((u8 *)extack->bad_attr < in_skb->data ||
2440 (u8 *)extack->bad_attr >= in_skb->data +
2441 in_skb->len))
2442 WARN_ON(nla_put_u32(skb, NLMSGERR_ATTR_OFFS,
2443 (u8 *)extack->bad_attr -
2444 in_skb->data));
2445 } else {
2446 if (extack->cookie_len)
2447 WARN_ON(nla_put(skb, NLMSGERR_ATTR_COOKIE,
2448 extack->cookie_len,
2449 extack->cookie));
2450 }
Johannes Berg2d4bc932017-04-12 14:34:04 +02002451 }
2452
2453 nlmsg_end(skb, rep);
2454
Eric W. Biederman15e47302012-09-07 20:12:54 +00002455 netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).portid, MSG_DONTWAIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456}
Patrick McHardy6ac552f2007-12-04 00:19:38 -08002457EXPORT_SYMBOL(netlink_ack);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07002459int netlink_rcv_skb(struct sk_buff *skb, int (*cb)(struct sk_buff *,
Johannes Berg2d4bc932017-04-12 14:34:04 +02002460 struct nlmsghdr *,
2461 struct netlink_ext_ack *))
Thomas Graf82ace472005-11-10 02:25:53 +01002462{
David Aherncbbdf842018-01-10 13:00:39 -08002463 struct netlink_ext_ack extack;
Thomas Graf82ace472005-11-10 02:25:53 +01002464 struct nlmsghdr *nlh;
2465 int err;
2466
2467 while (skb->len >= nlmsg_total_size(0)) {
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07002468 int msglen;
2469
Xin Longcd443f12018-01-18 14:48:03 +08002470 memset(&extack, 0, sizeof(extack));
Arnaldo Carvalho de Melob529ccf2007-04-25 19:08:35 -07002471 nlh = nlmsg_hdr(skb);
Thomas Grafd35b6852007-03-22 23:28:46 -07002472 err = 0;
Thomas Graf82ace472005-11-10 02:25:53 +01002473
Martin Murrayad8e4b72006-01-10 13:02:29 -08002474 if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len)
Thomas Graf82ace472005-11-10 02:25:53 +01002475 return 0;
2476
Thomas Grafd35b6852007-03-22 23:28:46 -07002477 /* Only requests are handled by the kernel */
2478 if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
Denis V. Lunev5c582982007-10-23 20:29:25 -07002479 goto ack;
Thomas Grafd35b6852007-03-22 23:28:46 -07002480
Thomas Graf45e7ae72007-03-22 23:29:10 -07002481 /* Skip control messages */
2482 if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
Denis V. Lunev5c582982007-10-23 20:29:25 -07002483 goto ack;
Thomas Graf45e7ae72007-03-22 23:29:10 -07002484
Johannes Berg2d4bc932017-04-12 14:34:04 +02002485 err = cb(skb, nlh, &extack);
Denis V. Lunev5c582982007-10-23 20:29:25 -07002486 if (err == -EINTR)
2487 goto skip;
2488
2489ack:
Thomas Grafd35b6852007-03-22 23:28:46 -07002490 if (nlh->nlmsg_flags & NLM_F_ACK || err)
Johannes Berg2d4bc932017-04-12 14:34:04 +02002491 netlink_ack(skb, nlh, err, &extack);
Thomas Graf82ace472005-11-10 02:25:53 +01002492
Denis V. Lunev5c582982007-10-23 20:29:25 -07002493skip:
Patrick McHardy6ac552f2007-12-04 00:19:38 -08002494 msglen = NLMSG_ALIGN(nlh->nlmsg_len);
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -07002495 if (msglen > skb->len)
2496 msglen = skb->len;
2497 skb_pull(skb, msglen);
Thomas Graf82ace472005-11-10 02:25:53 +01002498 }
2499
2500 return 0;
2501}
Patrick McHardy6ac552f2007-12-04 00:19:38 -08002502EXPORT_SYMBOL(netlink_rcv_skb);
Thomas Graf82ace472005-11-10 02:25:53 +01002503
2504/**
Thomas Grafd387f6a2006-08-15 00:31:06 -07002505 * nlmsg_notify - send a notification netlink message
2506 * @sk: netlink socket to use
2507 * @skb: notification message
Eric W. Biederman15e47302012-09-07 20:12:54 +00002508 * @portid: destination netlink portid for reports or 0
Thomas Grafd387f6a2006-08-15 00:31:06 -07002509 * @group: destination multicast group or 0
2510 * @report: 1 to report back, 0 to disable
2511 * @flags: allocation flags
2512 */
Eric W. Biederman15e47302012-09-07 20:12:54 +00002513int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
Thomas Grafd387f6a2006-08-15 00:31:06 -07002514 unsigned int group, int report, gfp_t flags)
2515{
2516 int err = 0;
2517
2518 if (group) {
Eric W. Biederman15e47302012-09-07 20:12:54 +00002519 int exclude_portid = 0;
Thomas Grafd387f6a2006-08-15 00:31:06 -07002520
2521 if (report) {
Reshetova, Elena63354792017-06-30 13:07:58 +03002522 refcount_inc(&skb->users);
Eric W. Biederman15e47302012-09-07 20:12:54 +00002523 exclude_portid = portid;
Thomas Grafd387f6a2006-08-15 00:31:06 -07002524 }
2525
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08002526 /* errors reported via destination sk->sk_err, but propagate
2527 * delivery errors if NETLINK_BROADCAST_ERROR flag is set */
Eric W. Biederman15e47302012-09-07 20:12:54 +00002528 err = nlmsg_multicast(sk, skb, exclude_portid, group, flags);
Thomas Grafd387f6a2006-08-15 00:31:06 -07002529 }
2530
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08002531 if (report) {
2532 int err2;
2533
Eric W. Biederman15e47302012-09-07 20:12:54 +00002534 err2 = nlmsg_unicast(sk, skb, portid);
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08002535 if (!err || err == -ESRCH)
2536 err = err2;
2537 }
Thomas Grafd387f6a2006-08-15 00:31:06 -07002538
2539 return err;
2540}
Patrick McHardy6ac552f2007-12-04 00:19:38 -08002541EXPORT_SYMBOL(nlmsg_notify);
Thomas Grafd387f6a2006-08-15 00:31:06 -07002542
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543#ifdef CONFIG_PROC_FS
2544struct nl_seq_iter {
Denis V. Luneve372c412007-11-19 22:31:54 -08002545 struct seq_net_private p;
Herbert Xu56d28b12015-02-04 07:33:24 +11002546 struct rhashtable_iter hti;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 int link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548};
2549
Herbert Xu56d28b12015-02-04 07:33:24 +11002550static int netlink_walk_start(struct nl_seq_iter *iter)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551{
Herbert Xu6c4128f2019-02-14 22:03:27 +08002552 rhashtable_walk_enter(&nl_table[iter->link].hash, &iter->hti);
Tom Herbert97a6ec42017-12-04 10:31:41 -08002553 rhashtable_walk_start(&iter->hti);
2554
2555 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556}
2557
Herbert Xu56d28b12015-02-04 07:33:24 +11002558static void netlink_walk_stop(struct nl_seq_iter *iter)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559{
Herbert Xu56d28b12015-02-04 07:33:24 +11002560 rhashtable_walk_stop(&iter->hti);
2561 rhashtable_walk_exit(&iter->hti);
2562}
2563
2564static void *__netlink_seq_next(struct seq_file *seq)
2565{
2566 struct nl_seq_iter *iter = seq->private;
2567 struct netlink_sock *nlk;
2568
2569 do {
2570 for (;;) {
2571 int err;
2572
2573 nlk = rhashtable_walk_next(&iter->hti);
2574
2575 if (IS_ERR(nlk)) {
2576 if (PTR_ERR(nlk) == -EAGAIN)
2577 continue;
2578
2579 return nlk;
2580 }
2581
2582 if (nlk)
2583 break;
2584
2585 netlink_walk_stop(iter);
2586 if (++iter->link >= MAX_LINKS)
2587 return NULL;
2588
2589 err = netlink_walk_start(iter);
2590 if (err)
2591 return ERR_PTR(err);
2592 }
2593 } while (sock_net(&nlk->sk) != seq_file_net(seq));
2594
2595 return nlk;
2596}
2597
2598static void *netlink_seq_start(struct seq_file *seq, loff_t *posp)
2599{
2600 struct nl_seq_iter *iter = seq->private;
2601 void *obj = SEQ_START_TOKEN;
2602 loff_t pos;
2603 int err;
2604
2605 iter->link = 0;
2606
2607 err = netlink_walk_start(iter);
2608 if (err)
2609 return ERR_PTR(err);
2610
2611 for (pos = *posp; pos && obj && !IS_ERR(obj); pos--)
2612 obj = __netlink_seq_next(seq);
2613
2614 return obj;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615}
2616
2617static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2618{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619 ++*pos;
Herbert Xu56d28b12015-02-04 07:33:24 +11002620 return __netlink_seq_next(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002621}
2622
2623static void netlink_seq_stop(struct seq_file *seq, void *v)
2624{
Herbert Xu56d28b12015-02-04 07:33:24 +11002625 struct nl_seq_iter *iter = seq->private;
2626
2627 if (iter->link >= MAX_LINKS)
2628 return;
2629
2630 netlink_walk_stop(iter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631}
2632
2633
2634static int netlink_seq_show(struct seq_file *seq, void *v)
2635{
Eric Dumazet658cb352012-04-22 21:30:21 +00002636 if (v == SEQ_START_TOKEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637 seq_puts(seq,
YU Boae552ac2018-05-03 23:09:23 -04002638 "sk Eth Pid Groups "
2639 "Rmem Wmem Dump Locks Drops Inode\n");
Eric Dumazet658cb352012-04-22 21:30:21 +00002640 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641 struct sock *s = v;
2642 struct netlink_sock *nlk = nlk_sk(s);
2643
YU Boae552ac2018-05-03 23:09:23 -04002644 seq_printf(seq, "%pK %-3d %-10u %08x %-8d %-8d %-5d %-8d %-8d %-8lu\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 s,
2646 s->sk_protocol,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002647 nlk->portid,
Patrick McHardy513c2502005-09-06 15:43:59 -07002648 nlk->groups ? (u32)nlk->groups[0] : 0,
Eric Dumazet31e6d362009-06-17 19:05:41 -07002649 sk_rmem_alloc_get(s),
2650 sk_wmem_alloc_get(s),
Pravin B Shelar16b304f2013-08-15 15:31:06 -07002651 nlk->cb_running,
Reshetova, Elena41c6d652017-06-30 13:08:01 +03002652 refcount_read(&s->sk_refcnt),
Masatake YAMATOcf0aa4e2010-02-27 19:45:37 +00002653 atomic_read(&s->sk_drops),
2654 sock_i_ino(s)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 );
2656
2657 }
2658 return 0;
2659}
2660
Philippe De Muyter56b3d972007-07-10 23:07:31 -07002661static const struct seq_operations netlink_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662 .start = netlink_seq_start,
2663 .next = netlink_seq_next,
2664 .stop = netlink_seq_stop,
2665 .show = netlink_seq_show,
2666};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667#endif
2668
2669int netlink_register_notifier(struct notifier_block *nb)
2670{
WANG Congefa172f2016-12-09 21:10:59 -08002671 return blocking_notifier_chain_register(&netlink_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672}
Patrick McHardy6ac552f2007-12-04 00:19:38 -08002673EXPORT_SYMBOL(netlink_register_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674
2675int netlink_unregister_notifier(struct notifier_block *nb)
2676{
WANG Congefa172f2016-12-09 21:10:59 -08002677 return blocking_notifier_chain_unregister(&netlink_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678}
Patrick McHardy6ac552f2007-12-04 00:19:38 -08002679EXPORT_SYMBOL(netlink_unregister_notifier);
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +09002680
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08002681static const struct proto_ops netlink_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 .family = PF_NETLINK,
2683 .owner = THIS_MODULE,
2684 .release = netlink_release,
2685 .bind = netlink_bind,
2686 .connect = netlink_connect,
2687 .socketpair = sock_no_socketpair,
2688 .accept = sock_no_accept,
2689 .getname = netlink_getname,
Linus Torvaldsa11e1d42018-06-28 09:43:44 -07002690 .poll = datagram_poll,
David Decotigny025c6812016-03-21 10:15:35 -07002691 .ioctl = netlink_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692 .listen = sock_no_listen,
2693 .shutdown = sock_no_shutdown,
Patrick McHardy9a4595b2005-08-15 12:32:15 -07002694 .setsockopt = netlink_setsockopt,
2695 .getsockopt = netlink_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 .sendmsg = netlink_sendmsg,
2697 .recvmsg = netlink_recvmsg,
Florian Westphald1b4c682016-02-18 15:03:24 +01002698 .mmap = sock_no_mmap,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699 .sendpage = sock_no_sendpage,
2700};
2701
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +00002702static const struct net_proto_family netlink_family_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 .family = PF_NETLINK,
2704 .create = netlink_create,
2705 .owner = THIS_MODULE, /* for consistency 8) */
2706};
2707
Pavel Emelyanov46650792007-10-08 20:38:39 -07002708static int __net_init netlink_net_init(struct net *net)
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002709{
2710#ifdef CONFIG_PROC_FS
Christoph Hellwigc3506372018-04-10 19:42:55 +02002711 if (!proc_create_net("netlink", 0, net->proc_net, &netlink_seq_ops,
2712 sizeof(struct nl_seq_iter)))
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002713 return -ENOMEM;
2714#endif
2715 return 0;
2716}
2717
Pavel Emelyanov46650792007-10-08 20:38:39 -07002718static void __net_exit netlink_net_exit(struct net *net)
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002719{
2720#ifdef CONFIG_PROC_FS
Gao fengece31ff2013-02-18 01:34:56 +00002721 remove_proc_entry("netlink", net->proc_net);
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002722#endif
2723}
2724
David S. Millerb963ea82010-08-30 19:08:01 -07002725static void __init netlink_add_usersock_entry(void)
2726{
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002727 struct listeners *listeners;
David S. Millerb963ea82010-08-30 19:08:01 -07002728 int groups = 32;
2729
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002730 listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL);
David S. Millerb963ea82010-08-30 19:08:01 -07002731 if (!listeners)
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002732 panic("netlink_add_usersock_entry: Cannot allocate listeners\n");
David S. Millerb963ea82010-08-30 19:08:01 -07002733
2734 netlink_table_grab();
2735
2736 nl_table[NETLINK_USERSOCK].groups = groups;
Eric Dumazet5c398dc2010-10-24 04:27:10 +00002737 rcu_assign_pointer(nl_table[NETLINK_USERSOCK].listeners, listeners);
David S. Millerb963ea82010-08-30 19:08:01 -07002738 nl_table[NETLINK_USERSOCK].module = THIS_MODULE;
2739 nl_table[NETLINK_USERSOCK].registered = 1;
Pablo Neira Ayuso9785e102012-09-08 02:53:53 +00002740 nl_table[NETLINK_USERSOCK].flags = NL_CFG_F_NONROOT_SEND;
David S. Millerb963ea82010-08-30 19:08:01 -07002741
2742 netlink_table_ungrab();
2743}
2744
Denis V. Lunev022cbae2007-11-13 03:23:50 -08002745static struct pernet_operations __net_initdata netlink_net_ops = {
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002746 .init = netlink_net_init,
2747 .exit = netlink_net_exit,
2748};
2749
Patrick McHardy49f7b332015-03-25 13:07:45 +00002750static inline u32 netlink_hash(const void *data, u32 len, u32 seed)
Herbert Xuc428ecd2015-03-20 21:57:01 +11002751{
2752 const struct netlink_sock *nlk = data;
2753 struct netlink_compare_arg arg;
2754
Herbert Xuda314c92015-09-22 11:38:56 +08002755 netlink_compare_arg_init(&arg, sock_net(&nlk->sk), nlk->portid);
Herbert Xu11b58ba2015-03-24 00:50:22 +11002756 return jhash2((u32 *)&arg, netlink_compare_arg_len / sizeof(u32), seed);
Herbert Xuc428ecd2015-03-20 21:57:01 +11002757}
2758
2759static const struct rhashtable_params netlink_rhashtable_params = {
2760 .head_offset = offsetof(struct netlink_sock, node),
2761 .key_len = netlink_compare_arg_len,
Herbert Xuc428ecd2015-03-20 21:57:01 +11002762 .obj_hashfn = netlink_hash,
2763 .obj_cmpfn = netlink_compare,
Thomas Grafb5e2c152015-03-24 20:42:19 +00002764 .automatic_shrinking = true,
Herbert Xuc428ecd2015-03-20 21:57:01 +11002765};
2766
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767static int __init netlink_proto_init(void)
2768{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 int err = proto_register(&netlink_proto, 0);
2771
2772 if (err != 0)
2773 goto out;
2774
YOSHIFUJI Hideaki / 吉藤英明fab25742013-01-09 07:19:48 +00002775 BUILD_BUG_ON(sizeof(struct netlink_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776
Panagiotis Issaris0da974f2006-07-21 14:51:30 -07002777 nl_table = kcalloc(MAX_LINKS, sizeof(*nl_table), GFP_KERNEL);
Akinobu Mitafab2caf2006-08-29 02:15:24 -07002778 if (!nl_table)
2779 goto panic;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781 for (i = 0; i < MAX_LINKS; i++) {
Herbert Xuc428ecd2015-03-20 21:57:01 +11002782 if (rhashtable_init(&nl_table[i].hash,
2783 &netlink_rhashtable_params) < 0) {
Thomas Grafe3416942014-08-02 11:47:45 +02002784 while (--i > 0)
2785 rhashtable_destroy(&nl_table[i].hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 kfree(nl_table);
Akinobu Mitafab2caf2006-08-29 02:15:24 -07002787 goto panic;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789 }
2790
David S. Millerb963ea82010-08-30 19:08:01 -07002791 netlink_add_usersock_entry();
2792
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793 sock_register(&netlink_family_ops);
Eric W. Biedermanb4b51022007-09-12 13:05:38 +02002794 register_pernet_subsys(&netlink_net_ops);
Cong Wang25e3f702017-12-06 15:03:19 -08002795 register_pernet_subsys(&netlink_tap_net_ops);
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +09002796 /* The netlink device handler may be needed early. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 rtnetlink_init();
2798out:
2799 return err;
Akinobu Mitafab2caf2006-08-29 02:15:24 -07002800panic:
2801 panic("netlink_init: Cannot allocate nl_table\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802}
2803
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804core_initcall(netlink_proto_init);