source: src/linux/universal/linux-3.18/net/netlink/af_netlink.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

File size: 56.3 KB
Line 
1/*
2 * NETLINK      Kernel-user communication protocol.
3 *
4 *              Authors:        Alan Cox <alan@lxorguk.ukuu.org.uk>
5 *                              Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
6 *                              Patrick McHardy <kaber@trash.net>
7 *
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.
12 *
13 * 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)
17 * 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
23 */
24
25#include <linux/module.h>
26
27#include <linux/capability.h>
28#include <linux/kernel.h>
29#include <linux/init.h>
30#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>
43#include <asm/uaccess.h>
44#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>
49#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>
57#include <linux/audit.h>
58#include <linux/mutex.h>
59#include <linux/vmalloc.h>
60#include <linux/if_arp.h>
61#include <linux/rhashtable.h>
62#include <asm/cacheflush.h>
63#include <linux/hash.h>
64
65#include <net/net_namespace.h>
66#include <net/sock.h>
67#include <net/scm.h>
68#include <net/netlink.h>
69
70#include "af_netlink.h"
71
72struct listeners {
73        struct rcu_head         rcu;
74        unsigned long           masks[0];
75};
76
77/* state bits */
78#define NETLINK_CONGESTED       0x0
79
80/* flags */
81#define NETLINK_KERNEL_SOCKET   0x1
82#define NETLINK_RECV_PKTINFO    0x2
83#define NETLINK_BROADCAST_SEND_ERROR    0x4
84#define NETLINK_RECV_NO_ENOBUFS 0x8
85
86static inline int netlink_is_kernel(struct sock *sk)
87{
88        return nlk_sk(sk)->flags & NETLINK_KERNEL_SOCKET;
89}
90
91struct netlink_table *nl_table;
92EXPORT_SYMBOL_GPL(nl_table);
93
94static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);
95
96static int netlink_dump(struct sock *sk);
97static void netlink_skb_destructor(struct sk_buff *skb);
98
99/* nl_table locking explained:
100 * Lookup and traversal are protected with nl_sk_hash_lock or nl_table_lock
101 * combined with an RCU read-side lock. Insertion and removal are protected
102 * with nl_sk_hash_lock while using RCU list modification primitives and may
103 * run in parallel to nl_table_lock protected lookups. Destruction of the
104 * Netlink socket may only occur *after* nl_table_lock has been acquired
105 * either during or after the socket has been removed from the list.
106 */
107DEFINE_RWLOCK(nl_table_lock);
108EXPORT_SYMBOL_GPL(nl_table_lock);
109static atomic_t nl_table_users = ATOMIC_INIT(0);
110
111#define nl_deref_protected(X) rcu_dereference_protected(X, lockdep_is_held(&nl_table_lock));
112
113/* Protects netlink socket hash table mutations */
114DEFINE_MUTEX(nl_sk_hash_lock);
115EXPORT_SYMBOL_GPL(nl_sk_hash_lock);
116
117static int lockdep_nl_sk_hash_is_held(void)
118{
119#ifdef CONFIG_LOCKDEP
120        if (debug_locks)
121                return lockdep_is_held(&nl_sk_hash_lock) || lockdep_is_held(&nl_table_lock);
122#endif
123        return 1;
124}
125
126static ATOMIC_NOTIFIER_HEAD(netlink_chain);
127
128static DEFINE_SPINLOCK(netlink_tap_lock);
129static struct list_head netlink_tap_all __read_mostly;
130
131static inline u32 netlink_group_mask(u32 group)
132{
133        return group ? 1 << (group - 1) : 0;
134}
135
136static struct sk_buff *netlink_to_full_skb(const struct sk_buff *skb,
137                                           gfp_t gfp_mask)
138{
139        unsigned int len = skb_end_offset(skb);
140        struct sk_buff *new;
141
142        new = alloc_skb(len, gfp_mask);
143        if (new == NULL)
144                return NULL;
145
146        NETLINK_CB(new).portid = NETLINK_CB(skb).portid;
147        NETLINK_CB(new).dst_group = NETLINK_CB(skb).dst_group;
148        NETLINK_CB(new).creds = NETLINK_CB(skb).creds;
149
150        memcpy(skb_put(new, len), skb->data, len);
151        return new;
152}
153
154int netlink_add_tap(struct netlink_tap *nt)
155{
156        if (unlikely(nt->dev->type != ARPHRD_NETLINK))
157                return -EINVAL;
158
159        spin_lock(&netlink_tap_lock);
160        list_add_rcu(&nt->list, &netlink_tap_all);
161        spin_unlock(&netlink_tap_lock);
162
163        if (nt->module)
164                __module_get(nt->module);
165
166        return 0;
167}
168EXPORT_SYMBOL_GPL(netlink_add_tap);
169
170static int __netlink_remove_tap(struct netlink_tap *nt)
171{
172        bool found = false;
173        struct netlink_tap *tmp;
174
175        spin_lock(&netlink_tap_lock);
176
177        list_for_each_entry(tmp, &netlink_tap_all, list) {
178                if (nt == tmp) {
179                        list_del_rcu(&nt->list);
180                        found = true;
181                        goto out;
182                }
183        }
184
185        pr_warn("__netlink_remove_tap: %p not found\n", nt);
186out:
187        spin_unlock(&netlink_tap_lock);
188
189        if (found && nt->module)
190                module_put(nt->module);
191
192        return found ? 0 : -ENODEV;
193}
194
195int netlink_remove_tap(struct netlink_tap *nt)
196{
197        int ret;
198
199        ret = __netlink_remove_tap(nt);
200        synchronize_net();
201
202        return ret;
203}
204EXPORT_SYMBOL_GPL(netlink_remove_tap);
205
206static bool netlink_filter_tap(const struct sk_buff *skb)
207{
208        struct sock *sk = skb->sk;
209
210        /* We take the more conservative approach and
211         * whitelist socket protocols that may pass.
212         */
213        switch (sk->sk_protocol) {
214        case NETLINK_ROUTE:
215        case NETLINK_USERSOCK:
216        case NETLINK_SOCK_DIAG:
217        case NETLINK_NFLOG:
218        case NETLINK_XFRM:
219        case NETLINK_FIB_LOOKUP:
220        case NETLINK_NETFILTER:
221        case NETLINK_GENERIC:
222                return true;
223        }
224
225        return false;
226}
227
228static int __netlink_deliver_tap_skb(struct sk_buff *skb,
229                                     struct net_device *dev)
230{
231        struct sk_buff *nskb;
232        struct sock *sk = skb->sk;
233        int ret = -ENOMEM;
234
235        dev_hold(dev);
236
237        if (is_vmalloc_addr(skb->head))
238                nskb = netlink_to_full_skb(skb, GFP_ATOMIC);
239        else
240                nskb = skb_clone(skb, GFP_ATOMIC);
241        if (nskb) {
242                nskb->dev = dev;
243                nskb->protocol = htons((u16) sk->sk_protocol);
244                nskb->pkt_type = netlink_is_kernel(sk) ?
245                                 PACKET_KERNEL : PACKET_USER;
246                skb_reset_network_header(nskb);
247                ret = dev_queue_xmit(nskb);
248                if (unlikely(ret > 0))
249                        ret = net_xmit_errno(ret);
250        }
251
252        dev_put(dev);
253        return ret;
254}
255
256static void __netlink_deliver_tap(struct sk_buff *skb)
257{
258        int ret;
259        struct netlink_tap *tmp;
260
261        if (!netlink_filter_tap(skb))
262                return;
263
264        list_for_each_entry_rcu(tmp, &netlink_tap_all, list) {
265                ret = __netlink_deliver_tap_skb(skb, tmp->dev);
266                if (unlikely(ret))
267                        break;
268        }
269}
270
271static void netlink_deliver_tap(struct sk_buff *skb)
272{
273        rcu_read_lock();
274
275        if (unlikely(!list_empty(&netlink_tap_all)))
276                __netlink_deliver_tap(skb);
277
278        rcu_read_unlock();
279}
280
281static void netlink_deliver_tap_kernel(struct sock *dst, struct sock *src,
282                                       struct sk_buff *skb)
283{
284        if (!(netlink_is_kernel(dst) && netlink_is_kernel(src)))
285                netlink_deliver_tap(skb);
286}
287
288static void netlink_overrun(struct sock *sk)
289{
290        struct netlink_sock *nlk = nlk_sk(sk);
291
292        if (!(nlk->flags & NETLINK_RECV_NO_ENOBUFS)) {
293                if (!test_and_set_bit(NETLINK_CONGESTED, &nlk_sk(sk)->state)) {
294                        sk->sk_err = ENOBUFS;
295                        sk->sk_error_report(sk);
296                }
297        }
298        atomic_inc(&sk->sk_drops);
299}
300
301static void netlink_rcv_wake(struct sock *sk)
302{
303        struct netlink_sock *nlk = nlk_sk(sk);
304
305        if (skb_queue_empty(&sk->sk_receive_queue))
306                clear_bit(NETLINK_CONGESTED, &nlk->state);
307        if (!test_bit(NETLINK_CONGESTED, &nlk->state))
308                wake_up_interruptible(&nlk->wait);
309}
310
311static void netlink_skb_destructor(struct sk_buff *skb)
312{
313        if (is_vmalloc_addr(skb->head)) {
314                if (!skb->cloned ||
315                    !atomic_dec_return(&(skb_shinfo(skb)->dataref)))
316                        vfree(skb->head);
317
318                skb->head = NULL;
319        }
320        if (skb->sk != NULL)
321                sock_rfree(skb);
322}
323
324static void netlink_skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
325{
326        WARN_ON(skb->sk != NULL);
327        skb->sk = sk;
328        skb->destructor = netlink_skb_destructor;
329        atomic_add(skb->truesize, &sk->sk_rmem_alloc);
330        sk_mem_charge(sk, skb->truesize);
331}
332
333static void netlink_sock_destruct(struct sock *sk)
334{
335        struct netlink_sock *nlk = nlk_sk(sk);
336
337        if (nlk->cb_running) {
338                if (nlk->cb.done)
339                        nlk->cb.done(&nlk->cb);
340
341                module_put(nlk->cb.module);
342                kfree_skb(nlk->cb.skb);
343        }
344
345        skb_queue_purge(&sk->sk_receive_queue);
346
347        if (!sock_flag(sk, SOCK_DEAD)) {
348                printk(KERN_ERR "Freeing alive netlink socket %p\n", sk);
349                return;
350        }
351
352        WARN_ON(atomic_read(&sk->sk_rmem_alloc));
353        WARN_ON(atomic_read(&sk->sk_wmem_alloc));
354        WARN_ON(nlk_sk(sk)->groups);
355}
356
357/* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on
358 * SMP. Look, when several writers sleep and reader wakes them up, all but one
359 * immediately hit write lock and grab all the cpus. Exclusive sleep solves
360 * this, _but_ remember, it adds useless work on UP machines.
361 */
362
363void netlink_table_grab(void)
364        __acquires(nl_table_lock)
365{
366        might_sleep();
367
368        write_lock_irq(&nl_table_lock);
369
370        if (atomic_read(&nl_table_users)) {
371                DECLARE_WAITQUEUE(wait, current);
372
373                add_wait_queue_exclusive(&nl_table_wait, &wait);
374                for (;;) {
375                        set_current_state(TASK_UNINTERRUPTIBLE);
376                        if (atomic_read(&nl_table_users) == 0)
377                                break;
378                        write_unlock_irq(&nl_table_lock);
379                        schedule();
380                        write_lock_irq(&nl_table_lock);
381                }
382
383                __set_current_state(TASK_RUNNING);
384                remove_wait_queue(&nl_table_wait, &wait);
385        }
386}
387
388void netlink_table_ungrab(void)
389        __releases(nl_table_lock)
390{
391        write_unlock_irq(&nl_table_lock);
392        wake_up(&nl_table_wait);
393}
394
395static inline void
396netlink_lock_table(void)
397{
398        /* read_lock() synchronizes us to netlink_table_grab */
399
400        read_lock(&nl_table_lock);
401        atomic_inc(&nl_table_users);
402        read_unlock(&nl_table_lock);
403}
404
405static inline void
406netlink_unlock_table(void)
407{
408        if (atomic_dec_and_test(&nl_table_users))
409                wake_up(&nl_table_wait);
410}
411
412struct netlink_compare_arg
413{
414        struct net *net;
415        u32 portid;
416};
417
418static bool netlink_compare(void *ptr, void *arg)
419{
420        struct netlink_compare_arg *x = arg;
421        struct sock *sk = ptr;
422
423        return nlk_sk(sk)->portid == x->portid &&
424               net_eq(sock_net(sk), x->net);
425}
426
427static struct sock *__netlink_lookup(struct netlink_table *table, u32 portid,
428                                     struct net *net)
429{
430        struct netlink_compare_arg arg = {
431                .net = net,
432                .portid = portid,
433        };
434
435        return rhashtable_lookup_compare(&table->hash, &portid,
436                                         &netlink_compare, &arg);
437}
438
439static struct sock *netlink_lookup(struct net *net, int protocol, u32 portid)
440{
441        struct netlink_table *table = &nl_table[protocol];
442        struct sock *sk;
443
444        read_lock(&nl_table_lock);
445        rcu_read_lock();
446        sk = __netlink_lookup(table, portid, net);
447        if (sk)
448                sock_hold(sk);
449        rcu_read_unlock();
450        read_unlock(&nl_table_lock);
451
452        return sk;
453}
454
455static const struct proto_ops netlink_ops;
456
457static void
458netlink_update_listeners(struct sock *sk)
459{
460        struct netlink_table *tbl = &nl_table[sk->sk_protocol];
461        unsigned long mask;
462        unsigned int i;
463        struct listeners *listeners;
464
465        listeners = nl_deref_protected(tbl->listeners);
466        if (!listeners)
467                return;
468
469        for (i = 0; i < NLGRPLONGS(tbl->groups); i++) {
470                mask = 0;
471                sk_for_each_bound(sk, &tbl->mc_list) {
472                        if (i < NLGRPLONGS(nlk_sk(sk)->ngroups))
473                                mask |= nlk_sk(sk)->groups[i];
474                }
475                listeners->masks[i] = mask;
476        }
477        /* this function is only called with the netlink table "grabbed", which
478         * makes sure updates are visible before bind or setsockopt return. */
479}
480
481static int netlink_insert(struct sock *sk, struct net *net, u32 portid)
482{
483        struct netlink_table *table = &nl_table[sk->sk_protocol];
484        int err = -EADDRINUSE;
485
486        mutex_lock(&nl_sk_hash_lock);
487        if (__netlink_lookup(table, portid, net))
488                goto err;
489
490        err = -EBUSY;
491        if (nlk_sk(sk)->portid)
492                goto err;
493
494        err = -ENOMEM;
495        if (BITS_PER_LONG > 32 && unlikely(table->hash.nelems >= UINT_MAX))
496                goto err;
497
498        nlk_sk(sk)->portid = portid;
499        sock_hold(sk);
500        rhashtable_insert(&table->hash, &nlk_sk(sk)->node, GFP_KERNEL);
501        err = 0;
502err:
503        mutex_unlock(&nl_sk_hash_lock);
504        return err;
505}
506
507static void netlink_remove(struct sock *sk)
508{
509        struct netlink_table *table;
510
511        mutex_lock(&nl_sk_hash_lock);
512        table = &nl_table[sk->sk_protocol];
513        if (rhashtable_remove(&table->hash, &nlk_sk(sk)->node, GFP_KERNEL)) {
514                WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
515                __sock_put(sk);
516        }
517        mutex_unlock(&nl_sk_hash_lock);
518
519        netlink_table_grab();
520        if (nlk_sk(sk)->subscriptions)
521                __sk_del_bind_node(sk);
522        netlink_table_ungrab();
523}
524
525static struct proto netlink_proto = {
526        .name     = "NETLINK",
527        .owner    = THIS_MODULE,
528        .obj_size = sizeof(struct netlink_sock),
529};
530
531static int __netlink_create(struct net *net, struct socket *sock,
532                            struct mutex *cb_mutex, int protocol)
533{
534        struct sock *sk;
535        struct netlink_sock *nlk;
536
537        sock->ops = &netlink_ops;
538
539        sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto);
540        if (!sk)
541                return -ENOMEM;
542
543        sock_init_data(sock, sk);
544
545        nlk = nlk_sk(sk);
546        if (cb_mutex) {
547                nlk->cb_mutex = cb_mutex;
548        } else {
549                nlk->cb_mutex = &nlk->cb_def_mutex;
550                mutex_init(nlk->cb_mutex);
551        }
552        init_waitqueue_head(&nlk->wait);
553
554        sk->sk_destruct = netlink_sock_destruct;
555        sk->sk_protocol = protocol;
556        return 0;
557}
558
559static int netlink_create(struct net *net, struct socket *sock, int protocol,
560                          int kern)
561{
562        struct module *module = NULL;
563        struct mutex *cb_mutex;
564        struct netlink_sock *nlk;
565        int (*bind)(int group);
566        void (*unbind)(int group);
567        int err = 0;
568
569        sock->state = SS_UNCONNECTED;
570
571        if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
572                return -ESOCKTNOSUPPORT;
573
574        if (protocol < 0 || protocol >= MAX_LINKS)
575                return -EPROTONOSUPPORT;
576
577        netlink_lock_table();
578#ifdef CONFIG_MODULES
579        if (!nl_table[protocol].registered) {
580                netlink_unlock_table();
581                request_module("net-pf-%d-proto-%d", PF_NETLINK, protocol);
582                netlink_lock_table();
583        }
584#endif
585        if (nl_table[protocol].registered &&
586            try_module_get(nl_table[protocol].module))
587                module = nl_table[protocol].module;
588        else
589                err = -EPROTONOSUPPORT;
590        cb_mutex = nl_table[protocol].cb_mutex;
591        bind = nl_table[protocol].bind;
592        unbind = nl_table[protocol].unbind;
593        netlink_unlock_table();
594
595        if (err < 0)
596                goto out;
597
598        err = __netlink_create(net, sock, cb_mutex, protocol);
599        if (err < 0)
600                goto out_module;
601
602        local_bh_disable();
603        sock_prot_inuse_add(net, &netlink_proto, 1);
604        local_bh_enable();
605
606        nlk = nlk_sk(sock->sk);
607        nlk->module = module;
608        nlk->netlink_bind = bind;
609        nlk->netlink_unbind = unbind;
610out:
611        return err;
612
613out_module:
614        module_put(module);
615        goto out;
616}
617
618static int netlink_release(struct socket *sock)
619{
620        struct sock *sk = sock->sk;
621        struct netlink_sock *nlk;
622
623        if (!sk)
624                return 0;
625
626        netlink_remove(sk);
627        sock_orphan(sk);
628        nlk = nlk_sk(sk);
629
630        /*
631         * OK. Socket is unlinked, any packets that arrive now
632         * will be purged.
633         */
634
635        sock->sk = NULL;
636        wake_up_interruptible_all(&nlk->wait);
637
638        skb_queue_purge(&sk->sk_write_queue);
639
640        if (nlk->portid) {
641                struct netlink_notify n = {
642                                                .net = sock_net(sk),
643                                                .protocol = sk->sk_protocol,
644                                                .portid = nlk->portid,
645                                          };
646                atomic_notifier_call_chain(&netlink_chain,
647                                NETLINK_URELEASE, &n);
648        }
649
650        module_put(nlk->module);
651
652        netlink_table_grab();
653        if (netlink_is_kernel(sk)) {
654                BUG_ON(nl_table[sk->sk_protocol].registered == 0);
655                if (--nl_table[sk->sk_protocol].registered == 0) {
656                        struct listeners *old;
657
658                        old = nl_deref_protected(nl_table[sk->sk_protocol].listeners);
659                        RCU_INIT_POINTER(nl_table[sk->sk_protocol].listeners, NULL);
660                        kfree_rcu(old, rcu);
661                        nl_table[sk->sk_protocol].module = NULL;
662                        nl_table[sk->sk_protocol].bind = NULL;
663                        nl_table[sk->sk_protocol].unbind = NULL;
664                        nl_table[sk->sk_protocol].flags = 0;
665                        nl_table[sk->sk_protocol].registered = 0;
666                }
667        } else if (nlk->subscriptions) {
668                netlink_update_listeners(sk);
669        }
670        netlink_table_ungrab();
671
672        kfree(nlk->groups);
673        nlk->groups = NULL;
674
675        local_bh_disable();
676        sock_prot_inuse_add(sock_net(sk), &netlink_proto, -1);
677        local_bh_enable();
678        sock_put(sk);
679        return 0;
680}
681
682static int netlink_autobind(struct socket *sock)
683{
684        struct sock *sk = sock->sk;
685        struct net *net = sock_net(sk);
686        struct netlink_table *table = &nl_table[sk->sk_protocol];
687        s32 portid = task_tgid_vnr(current);
688        int err;
689        static s32 rover = -4097;
690
691retry:
692        cond_resched();
693        netlink_table_grab();
694        rcu_read_lock();
695        if (__netlink_lookup(table, portid, net)) {
696                /* Bind collision, search negative portid values. */
697                portid = rover--;
698                if (rover > -4097)
699                        rover = -4097;
700                rcu_read_unlock();
701                netlink_table_ungrab();
702                goto retry;
703        }
704        rcu_read_unlock();
705        netlink_table_ungrab();
706
707        err = netlink_insert(sk, net, portid);
708        if (err == -EADDRINUSE)
709                goto retry;
710
711        /* If 2 threads race to autobind, that is fine.  */
712        if (err == -EBUSY)
713                err = 0;
714
715        return err;
716}
717
718/**
719 * __netlink_ns_capable - General netlink message capability test
720 * @nsp: NETLINK_CB of the socket buffer holding a netlink command from userspace.
721 * @user_ns: The user namespace of the capability to use
722 * @cap: The capability to use
723 *
724 * Test to see if the opener of the socket we received the message
725 * from had when the netlink socket was created and the sender of the
726 * message has has the capability @cap in the user namespace @user_ns.
727 */
728bool __netlink_ns_capable(const struct netlink_skb_parms *nsp,
729                        struct user_namespace *user_ns, int cap)
730{
731        return ((nsp->flags & NETLINK_SKB_DST) ||
732                file_ns_capable(nsp->sk->sk_socket->file, user_ns, cap)) &&
733                ns_capable(user_ns, cap);
734}
735EXPORT_SYMBOL(__netlink_ns_capable);
736
737/**
738 * netlink_ns_capable - General netlink message capability test
739 * @skb: socket buffer holding a netlink command from userspace
740 * @user_ns: The user namespace of the capability to use
741 * @cap: The capability to use
742 *
743 * Test to see if the opener of the socket we received the message
744 * from had when the netlink socket was created and the sender of the
745 * message has has the capability @cap in the user namespace @user_ns.
746 */
747bool netlink_ns_capable(const struct sk_buff *skb,
748                        struct user_namespace *user_ns, int cap)
749{
750        return __netlink_ns_capable(&NETLINK_CB(skb), user_ns, cap);
751}
752EXPORT_SYMBOL(netlink_ns_capable);
753
754/**
755 * netlink_capable - Netlink global message capability test
756 * @skb: socket buffer holding a netlink command from userspace
757 * @cap: The capability to use
758 *
759 * Test to see if the opener of the socket we received the message
760 * from had when the netlink socket was created and the sender of the
761 * message has has the capability @cap in all user namespaces.
762 */
763bool netlink_capable(const struct sk_buff *skb, int cap)
764{
765        return netlink_ns_capable(skb, &init_user_ns, cap);
766}
767EXPORT_SYMBOL(netlink_capable);
768
769/**
770 * netlink_net_capable - Netlink network namespace message capability test
771 * @skb: socket buffer holding a netlink command from userspace
772 * @cap: The capability to use
773 *
774 * Test to see if the opener of the socket we received the message
775 * from had when the netlink socket was created and the sender of the
776 * message has has the capability @cap over the network namespace of
777 * the socket we received the message from.
778 */
779bool netlink_net_capable(const struct sk_buff *skb, int cap)
780{
781        return netlink_ns_capable(skb, sock_net(skb->sk)->user_ns, cap);
782}
783EXPORT_SYMBOL(netlink_net_capable);
784
785static inline int netlink_allowed(const struct socket *sock, unsigned int flag)
786{
787        return (nl_table[sock->sk->sk_protocol].flags & flag) ||
788                ns_capable(sock_net(sock->sk)->user_ns, CAP_NET_ADMIN);
789}
790
791static void
792netlink_update_subscriptions(struct sock *sk, unsigned int subscriptions)
793{
794        struct netlink_sock *nlk = nlk_sk(sk);
795
796        if (nlk->subscriptions && !subscriptions)
797                __sk_del_bind_node(sk);
798        else if (!nlk->subscriptions && subscriptions)
799                sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list);
800        nlk->subscriptions = subscriptions;
801}
802
803static int netlink_realloc_groups(struct sock *sk)
804{
805        struct netlink_sock *nlk = nlk_sk(sk);
806        unsigned int groups;
807        unsigned long *new_groups;
808        int err = 0;
809
810        netlink_table_grab();
811
812        groups = nl_table[sk->sk_protocol].groups;
813        if (!nl_table[sk->sk_protocol].registered) {
814                err = -ENOENT;
815                goto out_unlock;
816        }
817
818        if (nlk->ngroups >= groups)
819                goto out_unlock;
820
821        new_groups = krealloc(nlk->groups, NLGRPSZ(groups), GFP_ATOMIC);
822        if (new_groups == NULL) {
823                err = -ENOMEM;
824                goto out_unlock;
825        }
826        memset((char *)new_groups + NLGRPSZ(nlk->ngroups), 0,
827               NLGRPSZ(groups) - NLGRPSZ(nlk->ngroups));
828
829        nlk->groups = new_groups;
830        nlk->ngroups = groups;
831 out_unlock:
832        netlink_table_ungrab();
833        return err;
834}
835
836static void netlink_unbind(int group, long unsigned int groups,
837                           struct netlink_sock *nlk)
838{
839        int undo;
840
841        if (!nlk->netlink_unbind)
842                return;
843
844        for (undo = 0; undo < group; undo++)
845                if (test_bit(undo, &groups))
846                        nlk->netlink_unbind(undo);
847}
848
849static int netlink_bind(struct socket *sock, struct sockaddr *addr,
850                        int addr_len)
851{
852        struct sock *sk = sock->sk;
853        struct net *net = sock_net(sk);
854        struct netlink_sock *nlk = nlk_sk(sk);
855        struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
856        int err;
857        long unsigned int groups = nladdr->nl_groups;
858
859        if (addr_len < sizeof(struct sockaddr_nl))
860                return -EINVAL;
861
862        if (nladdr->nl_family != AF_NETLINK)
863                return -EINVAL;
864
865        /* Only superuser is allowed to listen multicasts */
866        if (groups) {
867                if (!netlink_allowed(sock, NL_CFG_F_NONROOT_RECV))
868                        return -EPERM;
869                err = netlink_realloc_groups(sk);
870                if (err)
871                        return err;
872        }
873
874        if (nlk->portid)
875                if (nladdr->nl_pid != nlk->portid)
876                        return -EINVAL;
877
878        if (nlk->netlink_bind && groups) {
879                int group;
880
881                for (group = 0; group < nlk->ngroups; group++) {
882                        if (!test_bit(group, &groups))
883                                continue;
884                        err = nlk->netlink_bind(group);
885                        if (!err)
886                                continue;
887                        netlink_unbind(group, groups, nlk);
888                        return err;
889                }
890        }
891
892        if (!nlk->portid) {
893                err = nladdr->nl_pid ?
894                        netlink_insert(sk, net, nladdr->nl_pid) :
895                        netlink_autobind(sock);
896                if (err) {
897                        netlink_unbind(nlk->ngroups, groups, nlk);
898                        return err;
899                }
900        }
901
902        if (!groups && (nlk->groups == NULL || !(u32)nlk->groups[0]))
903                return 0;
904
905        netlink_table_grab();
906        netlink_update_subscriptions(sk, nlk->subscriptions +
907                                         hweight32(groups) -
908                                         hweight32(nlk->groups[0]));
909        nlk->groups[0] = (nlk->groups[0] & ~0xffffffffUL) | groups;
910        netlink_update_listeners(sk);
911        netlink_table_ungrab();
912
913        return 0;
914}
915
916static int netlink_connect(struct socket *sock, struct sockaddr *addr,
917                           int alen, int flags)
918{
919        int err = 0;
920        struct sock *sk = sock->sk;
921        struct netlink_sock *nlk = nlk_sk(sk);
922        struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
923
924        if (alen < sizeof(addr->sa_family))
925                return -EINVAL;
926
927        if (addr->sa_family == AF_UNSPEC) {
928                sk->sk_state    = NETLINK_UNCONNECTED;
929                nlk->dst_portid = 0;
930                nlk->dst_group  = 0;
931                return 0;
932        }
933        if (addr->sa_family != AF_NETLINK)
934                return -EINVAL;
935
936        if ((nladdr->nl_groups || nladdr->nl_pid) &&
937            !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
938                return -EPERM;
939
940        if (!nlk->portid)
941                err = netlink_autobind(sock);
942
943        if (err == 0) {
944                sk->sk_state    = NETLINK_CONNECTED;
945                nlk->dst_portid = nladdr->nl_pid;
946                nlk->dst_group  = ffs(nladdr->nl_groups);
947        }
948
949        return err;
950}
951
952static int netlink_getname(struct socket *sock, struct sockaddr *addr,
953                           int *addr_len, int peer)
954{
955        struct sock *sk = sock->sk;
956        struct netlink_sock *nlk = nlk_sk(sk);
957        DECLARE_SOCKADDR(struct sockaddr_nl *, nladdr, addr);
958
959        nladdr->nl_family = AF_NETLINK;
960        nladdr->nl_pad = 0;
961        *addr_len = sizeof(*nladdr);
962
963        if (peer) {
964                nladdr->nl_pid = nlk->dst_portid;
965                nladdr->nl_groups = netlink_group_mask(nlk->dst_group);
966        } else {
967                nladdr->nl_pid = nlk->portid;
968                nladdr->nl_groups = nlk->groups ? nlk->groups[0] : 0;
969        }
970        return 0;
971}
972
973static struct sock *netlink_getsockbyportid(struct sock *ssk, u32 portid)
974{
975        struct sock *sock;
976        struct netlink_sock *nlk;
977
978        sock = netlink_lookup(sock_net(ssk), ssk->sk_protocol, portid);
979        if (!sock)
980                return ERR_PTR(-ECONNREFUSED);
981
982        /* Don't bother queuing skb if kernel socket has no input function */
983        nlk = nlk_sk(sock);
984        if (sock->sk_state == NETLINK_CONNECTED &&
985            nlk->dst_portid != nlk_sk(ssk)->portid) {
986                sock_put(sock);
987                return ERR_PTR(-ECONNREFUSED);
988        }
989        return sock;
990}
991
992struct sock *netlink_getsockbyfilp(struct file *filp)
993{
994        struct inode *inode = file_inode(filp);
995        struct sock *sock;
996
997        if (!S_ISSOCK(inode->i_mode))
998                return ERR_PTR(-ENOTSOCK);
999
1000        sock = SOCKET_I(inode)->sk;
1001        if (sock->sk_family != AF_NETLINK)
1002                return ERR_PTR(-EINVAL);
1003
1004        sock_hold(sock);
1005        return sock;
1006}
1007
1008static struct sk_buff *netlink_alloc_large_skb(unsigned int size,
1009                                               int broadcast)
1010{
1011        struct sk_buff *skb;
1012        void *data;
1013
1014        if (size <= NLMSG_GOODSIZE || broadcast)
1015                return alloc_skb(size, GFP_KERNEL);
1016
1017        size = SKB_DATA_ALIGN(size) +
1018               SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
1019
1020        data = vmalloc(size);
1021        if (data == NULL)
1022                return NULL;
1023
1024        skb = __build_skb(data, size);
1025        if (skb == NULL)
1026                vfree(data);
1027        else
1028                skb->destructor = netlink_skb_destructor;
1029
1030        return skb;
1031}
1032
1033/*
1034 * Attach a skb to a netlink socket.
1035 * The caller must hold a reference to the destination socket. On error, the
1036 * reference is dropped. The skb is not send to the destination, just all
1037 * all error checks are performed and memory in the queue is reserved.
1038 * Return values:
1039 * < 0: error. skb freed, reference to sock dropped.
1040 * 0: continue
1041 * 1: repeat lookup - reference dropped while waiting for socket memory.
1042 */
1043int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
1044                      long *timeo, struct sock *ssk)
1045{
1046        struct netlink_sock *nlk;
1047
1048        nlk = nlk_sk(sk);
1049
1050        if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
1051            test_bit(NETLINK_CONGESTED, &nlk->state)) {
1052                DECLARE_WAITQUEUE(wait, current);
1053                if (!*timeo) {
1054                        if (!ssk || netlink_is_kernel(ssk))
1055                                netlink_overrun(sk);
1056                        sock_put(sk);
1057                        kfree_skb(skb);
1058                        return -EAGAIN;
1059                }
1060
1061                __set_current_state(TASK_INTERRUPTIBLE);
1062                add_wait_queue(&nlk->wait, &wait);
1063
1064                if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
1065                     test_bit(NETLINK_CONGESTED, &nlk->state)) &&
1066                    !sock_flag(sk, SOCK_DEAD))
1067                        *timeo = schedule_timeout(*timeo);
1068
1069                __set_current_state(TASK_RUNNING);
1070                remove_wait_queue(&nlk->wait, &wait);
1071                sock_put(sk);
1072
1073                if (signal_pending(current)) {
1074                        kfree_skb(skb);
1075                        return sock_intr_errno(*timeo);
1076                }
1077                return 1;
1078        }
1079        netlink_skb_set_owner_r(skb, sk);
1080        return 0;
1081}
1082
1083static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb)
1084{
1085        int len = skb->len;
1086
1087        netlink_deliver_tap(skb);
1088
1089        skb_queue_tail(&sk->sk_receive_queue, skb);
1090        sk->sk_data_ready(sk);
1091        return len;
1092}
1093
1094int netlink_sendskb(struct sock *sk, struct sk_buff *skb)
1095{
1096        int len = __netlink_sendskb(sk, skb);
1097
1098        sock_put(sk);
1099        return len;
1100}
1101
1102void netlink_detachskb(struct sock *sk, struct sk_buff *skb)
1103{
1104        kfree_skb(skb);
1105        sock_put(sk);
1106}
1107
1108static struct sk_buff *netlink_trim(struct sk_buff *skb, gfp_t allocation)
1109{
1110        skb_orphan(skb);
1111        return skb;
1112}
1113
1114static int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb,
1115                                  struct sock *ssk)
1116{
1117        int ret;
1118        struct netlink_sock *nlk = nlk_sk(sk);
1119
1120        ret = -ECONNREFUSED;
1121        if (nlk->netlink_rcv != NULL) {
1122                ret = skb->len;
1123                netlink_skb_set_owner_r(skb, sk);
1124                NETLINK_CB(skb).sk = ssk;
1125                netlink_deliver_tap_kernel(sk, ssk, skb);
1126                nlk->netlink_rcv(skb);
1127                consume_skb(skb);
1128        } else {
1129                kfree_skb(skb);
1130        }
1131        sock_put(sk);
1132        return ret;
1133}
1134
1135int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
1136                    u32 portid, int nonblock)
1137{
1138        struct sock *sk;
1139        int err;
1140        long timeo;
1141
1142        skb = netlink_trim(skb, gfp_any());
1143
1144        timeo = sock_sndtimeo(ssk, nonblock);
1145retry:
1146        sk = netlink_getsockbyportid(ssk, portid);
1147        if (IS_ERR(sk)) {
1148                kfree_skb(skb);
1149                return PTR_ERR(sk);
1150        }
1151        if (netlink_is_kernel(sk))
1152                return netlink_unicast_kernel(sk, skb, ssk);
1153
1154        if (sk_filter(sk, skb)) {
1155                err = skb->len;
1156                kfree_skb(skb);
1157                sock_put(sk);
1158                return err;
1159        }
1160
1161        err = netlink_attachskb(sk, skb, &timeo, ssk);
1162        if (err == 1)
1163                goto retry;
1164        if (err)
1165                return err;
1166
1167        return netlink_sendskb(sk, skb);
1168}
1169EXPORT_SYMBOL(netlink_unicast);
1170
1171struct sk_buff *netlink_alloc_skb(struct sock *ssk, unsigned int size,
1172                                  u32 dst_portid, gfp_t gfp_mask)
1173{
1174        return alloc_skb(size, gfp_mask);
1175}
1176EXPORT_SYMBOL_GPL(netlink_alloc_skb);
1177
1178int netlink_has_listeners(struct sock *sk, unsigned int group)
1179{
1180        int res = 0;
1181        struct listeners *listeners;
1182
1183        BUG_ON(!netlink_is_kernel(sk));
1184
1185        rcu_read_lock();
1186        listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners);
1187
1188        if (listeners && group - 1 < nl_table[sk->sk_protocol].groups)
1189                res = test_bit(group - 1, listeners->masks);
1190
1191        rcu_read_unlock();
1192
1193        return res;
1194}
1195EXPORT_SYMBOL_GPL(netlink_has_listeners);
1196
1197static int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb)
1198{
1199        struct netlink_sock *nlk = nlk_sk(sk);
1200
1201        if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
1202            !test_bit(NETLINK_CONGESTED, &nlk->state)) {
1203                netlink_skb_set_owner_r(skb, sk);
1204                __netlink_sendskb(sk, skb);
1205                return atomic_read(&sk->sk_rmem_alloc) > (sk->sk_rcvbuf >> 1);
1206        }
1207        return -1;
1208}
1209
1210struct netlink_broadcast_data {
1211        struct sock *exclude_sk;
1212        struct net *net;
1213        u32 portid;
1214        u32 group;
1215        int failure;
1216        int delivery_failure;
1217        int congested;
1218        int delivered;
1219        gfp_t allocation;
1220        struct sk_buff *skb, *skb2;
1221        int (*tx_filter)(struct sock *dsk, struct sk_buff *skb, void *data);
1222        void *tx_data;
1223};
1224
1225static void do_one_broadcast(struct sock *sk,
1226                                    struct netlink_broadcast_data *p)
1227{
1228        struct netlink_sock *nlk = nlk_sk(sk);
1229        int val;
1230
1231        if (p->exclude_sk == sk)
1232                return;
1233
1234        if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
1235            !test_bit(p->group - 1, nlk->groups))
1236                return;
1237
1238        if (!net_eq(sock_net(sk), p->net))
1239                return;
1240
1241        if (p->failure) {
1242                netlink_overrun(sk);
1243                return;
1244        }
1245
1246        sock_hold(sk);
1247        if (p->skb2 == NULL) {
1248                if (skb_shared(p->skb)) {
1249                        p->skb2 = skb_clone(p->skb, p->allocation);
1250                } else {
1251                        p->skb2 = skb_get(p->skb);
1252                        /*
1253                         * skb ownership may have been set when
1254                         * delivered to a previous socket.
1255                         */
1256                        skb_orphan(p->skb2);
1257                }
1258        }
1259        if (p->skb2 == NULL) {
1260                netlink_overrun(sk);
1261                /* Clone failed. Notify ALL listeners. */
1262                p->failure = 1;
1263                if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)
1264                        p->delivery_failure = 1;
1265        } else if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)) {
1266                kfree_skb(p->skb2);
1267                p->skb2 = NULL;
1268        } else if (sk_filter(sk, p->skb2)) {
1269                kfree_skb(p->skb2);
1270                p->skb2 = NULL;
1271        } else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0) {
1272                netlink_overrun(sk);
1273                if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)
1274                        p->delivery_failure = 1;
1275        } else {
1276                p->congested |= val;
1277                p->delivered = 1;
1278                p->skb2 = NULL;
1279        }
1280        sock_put(sk);
1281}
1282
1283int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid,
1284        u32 group, gfp_t allocation,
1285        int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),
1286        void *filter_data)
1287{
1288        struct net *net = sock_net(ssk);
1289        struct netlink_broadcast_data info;
1290        struct sock *sk;
1291
1292        skb = netlink_trim(skb, allocation);
1293
1294        info.exclude_sk = ssk;
1295        info.net = net;
1296        info.portid = portid;
1297        info.group = group;
1298        info.failure = 0;
1299        info.delivery_failure = 0;
1300        info.congested = 0;
1301        info.delivered = 0;
1302        info.allocation = allocation;
1303        info.skb = skb;
1304        info.skb2 = NULL;
1305        info.tx_filter = filter;
1306        info.tx_data = filter_data;
1307
1308        /* While we sleep in clone, do not allow to change socket list */
1309
1310        netlink_lock_table();
1311
1312        sk_for_each_bound(sk, &nl_table[ssk->sk_protocol].mc_list)
1313                do_one_broadcast(sk, &info);
1314
1315        consume_skb(skb);
1316
1317        netlink_unlock_table();
1318
1319        if (info.delivery_failure) {
1320                kfree_skb(info.skb2);
1321                return -ENOBUFS;
1322        }
1323        consume_skb(info.skb2);
1324
1325        if (info.delivered) {
1326                if (info.congested && (allocation & __GFP_WAIT))
1327                        yield();
1328                return 0;
1329        }
1330        return -ESRCH;
1331}
1332EXPORT_SYMBOL(netlink_broadcast_filtered);
1333
1334int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 portid,
1335                      u32 group, gfp_t allocation)
1336{
1337        return netlink_broadcast_filtered(ssk, skb, portid, group, allocation,
1338                NULL, NULL);
1339}
1340EXPORT_SYMBOL(netlink_broadcast);
1341
1342struct netlink_set_err_data {
1343        struct sock *exclude_sk;
1344        u32 portid;
1345        u32 group;
1346        int code;
1347};
1348
1349static int do_one_set_err(struct sock *sk, struct netlink_set_err_data *p)
1350{
1351        struct netlink_sock *nlk = nlk_sk(sk);
1352        int ret = 0;
1353
1354        if (sk == p->exclude_sk)
1355                goto out;
1356
1357        if (!net_eq(sock_net(sk), sock_net(p->exclude_sk)))
1358                goto out;
1359
1360        if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
1361            !test_bit(p->group - 1, nlk->groups))
1362                goto out;
1363
1364        if (p->code == ENOBUFS && nlk->flags & NETLINK_RECV_NO_ENOBUFS) {
1365                ret = 1;
1366                goto out;
1367        }
1368
1369        sk->sk_err = p->code;
1370        sk->sk_error_report(sk);
1371out:
1372        return ret;
1373}
1374
1375/**
1376 * netlink_set_err - report error to broadcast listeners
1377 * @ssk: the kernel netlink socket, as returned by netlink_kernel_create()
1378 * @portid: the PORTID of a process that we want to skip (if any)
1379 * @group: the broadcast group that will notice the error
1380 * @code: error code, must be negative (as usual in kernelspace)
1381 *
1382 * This function returns the number of broadcast listeners that have set the
1383 * NETLINK_RECV_NO_ENOBUFS socket option.
1384 */
1385int netlink_set_err(struct sock *ssk, u32 portid, u32 group, int code)
1386{
1387        struct netlink_set_err_data info;
1388        struct sock *sk;
1389        int ret = 0;
1390
1391        info.exclude_sk = ssk;
1392        info.portid = portid;
1393        info.group = group;
1394        /* sk->sk_err wants a positive error value */
1395        info.code = -code;
1396
1397        read_lock(&nl_table_lock);
1398
1399        sk_for_each_bound(sk, &nl_table[ssk->sk_protocol].mc_list)
1400                ret += do_one_set_err(sk, &info);
1401
1402        read_unlock(&nl_table_lock);
1403        return ret;
1404}
1405EXPORT_SYMBOL(netlink_set_err);
1406
1407/* must be called with netlink table grabbed */
1408static void netlink_update_socket_mc(struct netlink_sock *nlk,
1409                                     unsigned int group,
1410                                     int is_new)
1411{
1412        int old, new = !!is_new, subscriptions;
1413
1414        old = test_bit(group - 1, nlk->groups);
1415        subscriptions = nlk->subscriptions - old + new;
1416        if (new)
1417                __set_bit(group - 1, nlk->groups);
1418        else
1419                __clear_bit(group - 1, nlk->groups);
1420        netlink_update_subscriptions(&nlk->sk, subscriptions);
1421        netlink_update_listeners(&nlk->sk);
1422}
1423
1424static int netlink_setsockopt(struct socket *sock, int level, int optname,
1425                              char __user *optval, unsigned int optlen)
1426{
1427        struct sock *sk = sock->sk;
1428        struct netlink_sock *nlk = nlk_sk(sk);
1429        unsigned int val = 0;
1430        int err;
1431
1432        if (level != SOL_NETLINK)
1433                return -ENOPROTOOPT;
1434
1435        if (optlen >= sizeof(int) &&
1436            get_user(val, (unsigned int __user *)optval))
1437                return -EFAULT;
1438
1439        switch (optname) {
1440        case NETLINK_PKTINFO:
1441                if (val)
1442                        nlk->flags |= NETLINK_RECV_PKTINFO;
1443                else
1444                        nlk->flags &= ~NETLINK_RECV_PKTINFO;
1445                err = 0;
1446                break;
1447        case NETLINK_ADD_MEMBERSHIP:
1448        case NETLINK_DROP_MEMBERSHIP: {
1449                if (!netlink_allowed(sock, NL_CFG_F_NONROOT_RECV))
1450                        return -EPERM;
1451                err = netlink_realloc_groups(sk);
1452                if (err)
1453                        return err;
1454                if (!val || val - 1 >= nlk->ngroups)
1455                        return -EINVAL;
1456                if (optname == NETLINK_ADD_MEMBERSHIP && nlk->netlink_bind) {
1457                        err = nlk->netlink_bind(val);
1458                        if (err)
1459                                return err;
1460                }
1461                netlink_table_grab();
1462                netlink_update_socket_mc(nlk, val,
1463                                         optname == NETLINK_ADD_MEMBERSHIP);
1464                netlink_table_ungrab();
1465                if (optname == NETLINK_DROP_MEMBERSHIP && nlk->netlink_unbind)
1466                        nlk->netlink_unbind(val);
1467
1468                err = 0;
1469                break;
1470        }
1471        case NETLINK_BROADCAST_ERROR:
1472                if (val)
1473                        nlk->flags |= NETLINK_BROADCAST_SEND_ERROR;
1474                else
1475                        nlk->flags &= ~NETLINK_BROADCAST_SEND_ERROR;
1476                err = 0;
1477                break;
1478        case NETLINK_NO_ENOBUFS:
1479                if (val) {
1480                        nlk->flags |= NETLINK_RECV_NO_ENOBUFS;
1481                        clear_bit(NETLINK_CONGESTED, &nlk->state);
1482                        wake_up_interruptible(&nlk->wait);
1483                } else {
1484                        nlk->flags &= ~NETLINK_RECV_NO_ENOBUFS;
1485                }
1486                err = 0;
1487                break;
1488        default:
1489                err = -ENOPROTOOPT;
1490        }
1491        return err;
1492}
1493
1494static int netlink_getsockopt(struct socket *sock, int level, int optname,
1495                              char __user *optval, int __user *optlen)
1496{
1497        struct sock *sk = sock->sk;
1498        struct netlink_sock *nlk = nlk_sk(sk);
1499        int len, val, err;
1500
1501        if (level != SOL_NETLINK)
1502                return -ENOPROTOOPT;
1503
1504        if (get_user(len, optlen))
1505                return -EFAULT;
1506        if (len < 0)
1507                return -EINVAL;
1508
1509        switch (optname) {
1510        case NETLINK_PKTINFO:
1511                if (len < sizeof(int))
1512                        return -EINVAL;
1513                len = sizeof(int);
1514                val = nlk->flags & NETLINK_RECV_PKTINFO ? 1 : 0;
1515                if (put_user(len, optlen) ||
1516                    put_user(val, optval))
1517                        return -EFAULT;
1518                err = 0;
1519                break;
1520        case NETLINK_BROADCAST_ERROR:
1521                if (len < sizeof(int))
1522                        return -EINVAL;
1523                len = sizeof(int);
1524                val = nlk->flags & NETLINK_BROADCAST_SEND_ERROR ? 1 : 0;
1525                if (put_user(len, optlen) ||
1526                    put_user(val, optval))
1527                        return -EFAULT;
1528                err = 0;
1529                break;
1530        case NETLINK_NO_ENOBUFS:
1531                if (len < sizeof(int))
1532                        return -EINVAL;
1533                len = sizeof(int);
1534                val = nlk->flags & NETLINK_RECV_NO_ENOBUFS ? 1 : 0;
1535                if (put_user(len, optlen) ||
1536                    put_user(val, optval))
1537                        return -EFAULT;
1538                err = 0;
1539                break;
1540        default:
1541                err = -ENOPROTOOPT;
1542        }
1543        return err;
1544}
1545
1546static void netlink_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
1547{
1548        struct nl_pktinfo info;
1549
1550        info.group = NETLINK_CB(skb).dst_group;
1551        put_cmsg(msg, SOL_NETLINK, NETLINK_PKTINFO, sizeof(info), &info);
1552}
1553
1554static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
1555                           struct msghdr *msg, size_t len)
1556{
1557        struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1558        struct sock *sk = sock->sk;
1559        struct netlink_sock *nlk = nlk_sk(sk);
1560        DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
1561        u32 dst_portid;
1562        u32 dst_group;
1563        struct sk_buff *skb;
1564        int err;
1565        struct scm_cookie scm;
1566        u32 netlink_skb_flags = 0;
1567
1568        if (msg->msg_flags&MSG_OOB)
1569                return -EOPNOTSUPP;
1570
1571        if (NULL == siocb->scm)
1572                siocb->scm = &scm;
1573
1574        err = scm_send(sock, msg, siocb->scm, true);
1575        if (err < 0)
1576                return err;
1577
1578        if (msg->msg_namelen) {
1579                err = -EINVAL;
1580                if (addr->nl_family != AF_NETLINK)
1581                        goto out;
1582                dst_portid = addr->nl_pid;
1583                dst_group = ffs(addr->nl_groups);
1584                err =  -EPERM;
1585                if ((dst_group || dst_portid) &&
1586                    !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
1587                        goto out;
1588                netlink_skb_flags |= NETLINK_SKB_DST;
1589        } else {
1590                dst_portid = nlk->dst_portid;
1591                dst_group = nlk->dst_group;
1592        }
1593
1594        if (!nlk->portid) {
1595                err = netlink_autobind(sock);
1596                if (err)
1597                        goto out;
1598        }
1599
1600        err = -EMSGSIZE;
1601        if (len > sk->sk_sndbuf - 32)
1602                goto out;
1603        err = -ENOBUFS;
1604        skb = netlink_alloc_large_skb(len, dst_group);
1605        if (skb == NULL)
1606                goto out;
1607
1608        NETLINK_CB(skb).portid  = nlk->portid;
1609        NETLINK_CB(skb).dst_group = dst_group;
1610        NETLINK_CB(skb).creds   = siocb->scm->creds;
1611        NETLINK_CB(skb).flags   = netlink_skb_flags;
1612
1613        err = -EFAULT;
1614        if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1615                kfree_skb(skb);
1616                goto out;
1617        }
1618
1619        err = security_netlink_send(sk, skb);
1620        if (err) {
1621                kfree_skb(skb);
1622                goto out;
1623        }
1624
1625        if (dst_group) {
1626                atomic_inc(&skb->users);
1627                netlink_broadcast(sk, skb, dst_portid, dst_group, GFP_KERNEL);
1628        }
1629        err = netlink_unicast(sk, skb, dst_portid, msg->msg_flags&MSG_DONTWAIT);
1630
1631out:
1632        scm_destroy(siocb->scm);
1633        return err;
1634}
1635
1636static int netlink_recvmsg(struct kiocb *kiocb, struct socket *sock,
1637                           struct msghdr *msg, size_t len,
1638                           int flags)
1639{
1640        struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1641        struct scm_cookie scm;
1642        struct sock *sk = sock->sk;
1643        struct netlink_sock *nlk = nlk_sk(sk);
1644        int noblock = flags&MSG_DONTWAIT;
1645        size_t copied;
1646        struct sk_buff *skb, *data_skb;
1647        int err, ret;
1648
1649        if (flags&MSG_OOB)
1650                return -EOPNOTSUPP;
1651
1652        copied = 0;
1653
1654        skb = skb_recv_datagram(sk, flags, noblock, &err);
1655        if (skb == NULL)
1656                goto out;
1657
1658        data_skb = skb;
1659
1660#ifdef CONFIG_COMPAT_NETLINK_MESSAGES
1661        if (unlikely(skb_shinfo(skb)->frag_list)) {
1662                /*
1663                 * If this skb has a frag_list, then here that means that we
1664                 * will have to use the frag_list skb's data for compat tasks
1665                 * and the regular skb's data for normal (non-compat) tasks.
1666                 *
1667                 * If we need to send the compat skb, assign it to the
1668                 * 'data_skb' variable so that it will be used below for data
1669                 * copying. We keep 'skb' for everything else, including
1670                 * freeing both later.
1671                 */
1672                if (flags & MSG_CMSG_COMPAT)
1673                        data_skb = skb_shinfo(skb)->frag_list;
1674        }
1675#endif
1676
1677        /* Record the max length of recvmsg() calls for future allocations */
1678        nlk->max_recvmsg_len = max(nlk->max_recvmsg_len, len);
1679        nlk->max_recvmsg_len = min_t(size_t, nlk->max_recvmsg_len,
1680                                     SKB_WITH_OVERHEAD(32768));
1681
1682        copied = data_skb->len;
1683        if (len < copied) {
1684                msg->msg_flags |= MSG_TRUNC;
1685                copied = len;
1686        }
1687
1688        skb_reset_transport_header(data_skb);
1689        err = skb_copy_datagram_iovec(data_skb, 0, msg->msg_iov, copied);
1690
1691        if (msg->msg_name) {
1692                DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
1693                addr->nl_family = AF_NETLINK;
1694                addr->nl_pad    = 0;
1695                addr->nl_pid    = NETLINK_CB(skb).portid;
1696                addr->nl_groups = netlink_group_mask(NETLINK_CB(skb).dst_group);
1697                msg->msg_namelen = sizeof(*addr);
1698        }
1699
1700        if (nlk->flags & NETLINK_RECV_PKTINFO)
1701                netlink_cmsg_recv_pktinfo(msg, skb);
1702
1703        if (NULL == siocb->scm) {
1704                memset(&scm, 0, sizeof(scm));
1705                siocb->scm = &scm;
1706        }
1707        siocb->scm->creds = *NETLINK_CREDS(skb);
1708        if (flags & MSG_TRUNC)
1709                copied = data_skb->len;
1710
1711        skb_free_datagram(sk, skb);
1712
1713        if (nlk->cb_running &&
1714            atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2) {
1715                ret = netlink_dump(sk);
1716                if (ret) {
1717                        sk->sk_err = -ret;
1718                        sk->sk_error_report(sk);
1719                }
1720        }
1721
1722        scm_recv(sock, msg, siocb->scm, flags);
1723out:
1724        netlink_rcv_wake(sk);
1725        return err ? : copied;
1726}
1727
1728static void netlink_data_ready(struct sock *sk)
1729{
1730        BUG();
1731}
1732
1733/*
1734 *      We export these functions to other modules. They provide a
1735 *      complete set of kernel non-blocking support for message
1736 *      queueing.
1737 */
1738
1739struct sock *
1740__netlink_kernel_create(struct net *net, int unit, struct module *module,
1741                        struct netlink_kernel_cfg *cfg)
1742{
1743        struct socket *sock;
1744        struct sock *sk;
1745        struct netlink_sock *nlk;
1746        struct listeners *listeners = NULL;
1747        struct mutex *cb_mutex = cfg ? cfg->cb_mutex : NULL;
1748        unsigned int groups;
1749
1750        BUG_ON(!nl_table);
1751
1752        if (unit < 0 || unit >= MAX_LINKS)
1753                return NULL;
1754
1755        if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
1756                return NULL;
1757
1758        /*
1759         * We have to just have a reference on the net from sk, but don't
1760         * get_net it. Besides, we cannot get and then put the net here.
1761         * So we create one inside init_net and the move it to net.
1762         */
1763
1764        if (__netlink_create(&init_net, sock, cb_mutex, unit) < 0)
1765                goto out_sock_release_nosk;
1766
1767        sk = sock->sk;
1768        sk_change_net(sk, net);
1769
1770        if (!cfg || cfg->groups < 32)
1771                groups = 32;
1772        else
1773                groups = cfg->groups;
1774
1775        listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL);
1776        if (!listeners)
1777                goto out_sock_release;
1778
1779        sk->sk_data_ready = netlink_data_ready;
1780        if (cfg && cfg->input)
1781                nlk_sk(sk)->netlink_rcv = cfg->input;
1782
1783        if (netlink_insert(sk, net, 0))
1784                goto out_sock_release;
1785
1786        nlk = nlk_sk(sk);
1787        nlk->flags |= NETLINK_KERNEL_SOCKET;
1788
1789        netlink_table_grab();
1790        if (!nl_table[unit].registered) {
1791                nl_table[unit].groups = groups;
1792                rcu_assign_pointer(nl_table[unit].listeners, listeners);
1793                nl_table[unit].cb_mutex = cb_mutex;
1794                nl_table[unit].module = module;
1795                if (cfg) {
1796                        nl_table[unit].bind = cfg->bind;
1797                        nl_table[unit].unbind = cfg->unbind;
1798                        nl_table[unit].flags = cfg->flags;
1799                        if (cfg->compare)
1800                                nl_table[unit].compare = cfg->compare;
1801                }
1802                nl_table[unit].registered = 1;
1803        } else {
1804                kfree(listeners);
1805                nl_table[unit].registered++;
1806        }
1807        netlink_table_ungrab();
1808        return sk;
1809
1810out_sock_release:
1811        kfree(listeners);
1812        netlink_kernel_release(sk);
1813        return NULL;
1814
1815out_sock_release_nosk:
1816        sock_release(sock);
1817        return NULL;
1818}
1819EXPORT_SYMBOL(__netlink_kernel_create);
1820
1821void
1822netlink_kernel_release(struct sock *sk)
1823{
1824        sk_release_kernel(sk);
1825}
1826EXPORT_SYMBOL(netlink_kernel_release);
1827
1828int __netlink_change_ngroups(struct sock *sk, unsigned int groups)
1829{
1830        struct listeners *new, *old;
1831        struct netlink_table *tbl = &nl_table[sk->sk_protocol];
1832
1833        if (groups < 32)
1834                groups = 32;
1835
1836        if (NLGRPSZ(tbl->groups) < NLGRPSZ(groups)) {
1837                new = kzalloc(sizeof(*new) + NLGRPSZ(groups), GFP_ATOMIC);
1838                if (!new)
1839                        return -ENOMEM;
1840                old = nl_deref_protected(tbl->listeners);
1841                memcpy(new->masks, old->masks, NLGRPSZ(tbl->groups));
1842                rcu_assign_pointer(tbl->listeners, new);
1843
1844                kfree_rcu(old, rcu);
1845        }
1846        tbl->groups = groups;
1847
1848        return 0;
1849}
1850
1851/**
1852 * netlink_change_ngroups - change number of multicast groups
1853 *
1854 * This changes the number of multicast groups that are available
1855 * on a certain netlink family. Note that it is not possible to
1856 * change the number of groups to below 32. Also note that it does
1857 * not implicitly call netlink_clear_multicast_users() when the
1858 * number of groups is reduced.
1859 *
1860 * @sk: The kernel netlink socket, as returned by netlink_kernel_create().
1861 * @groups: The new number of groups.
1862 */
1863int netlink_change_ngroups(struct sock *sk, unsigned int groups)
1864{
1865        int err;
1866
1867        netlink_table_grab();
1868        err = __netlink_change_ngroups(sk, groups);
1869        netlink_table_ungrab();
1870
1871        return err;
1872}
1873
1874void __netlink_clear_multicast_users(struct sock *ksk, unsigned int group)
1875{
1876        struct sock *sk;
1877        struct netlink_table *tbl = &nl_table[ksk->sk_protocol];
1878
1879        sk_for_each_bound(sk, &tbl->mc_list)
1880                netlink_update_socket_mc(nlk_sk(sk), group, 0);
1881}
1882
1883struct nlmsghdr *
1884__nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, int type, int len, int flags)
1885{
1886        struct nlmsghdr *nlh;
1887        int size = nlmsg_msg_size(len);
1888
1889        nlh = (struct nlmsghdr *)skb_put(skb, NLMSG_ALIGN(size));
1890        nlh->nlmsg_type = type;
1891        nlh->nlmsg_len = size;
1892        nlh->nlmsg_flags = flags;
1893        nlh->nlmsg_pid = portid;
1894        nlh->nlmsg_seq = seq;
1895        if (!__builtin_constant_p(size) || NLMSG_ALIGN(size) - size != 0)
1896                memset(nlmsg_data(nlh) + len, 0, NLMSG_ALIGN(size) - size);
1897        return nlh;
1898}
1899EXPORT_SYMBOL(__nlmsg_put);
1900
1901/*
1902 * It looks a bit ugly.
1903 * It would be better to create kernel thread.
1904 */
1905
1906static int netlink_dump(struct sock *sk)
1907{
1908        struct netlink_sock *nlk = nlk_sk(sk);
1909        struct netlink_callback *cb;
1910        struct sk_buff *skb = NULL;
1911        struct nlmsghdr *nlh;
1912        struct module *module;
1913        int len, err = -ENOBUFS;
1914        int alloc_size;
1915
1916        mutex_lock(nlk->cb_mutex);
1917        if (!nlk->cb_running) {
1918                err = -EINVAL;
1919                goto errout_skb;
1920        }
1921
1922        cb = &nlk->cb;
1923        alloc_size = max_t(int, cb->min_dump_alloc, NLMSG_GOODSIZE);
1924
1925        if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
1926                goto errout_skb;
1927
1928        /* NLMSG_GOODSIZE is small to avoid high order allocations being
1929         * required, but it makes sense to _attempt_ a 16K bytes allocation
1930         * to reduce number of system calls on dump operations, if user
1931         * ever provided a big enough buffer.
1932         */
1933        if (alloc_size < nlk->max_recvmsg_len) {
1934                skb = netlink_alloc_skb(sk,
1935                                        nlk->max_recvmsg_len,
1936                                        nlk->portid,
1937                                        (GFP_KERNEL & ~__GFP_WAIT) |
1938                                        __GFP_NOWARN | __GFP_NORETRY);
1939                /* available room should be exact amount to avoid MSG_TRUNC */
1940                if (skb)
1941                        skb_reserve(skb, skb_tailroom(skb) -
1942                                         nlk->max_recvmsg_len);
1943        }
1944        if (!skb)
1945                skb = netlink_alloc_skb(sk, alloc_size, nlk->portid,
1946                                        (GFP_KERNEL & ~__GFP_WAIT));
1947        if (!skb)
1948                goto errout_skb;
1949        netlink_skb_set_owner_r(skb, sk);
1950
1951        len = cb->dump(skb, cb);
1952
1953        if (len > 0) {
1954                mutex_unlock(nlk->cb_mutex);
1955
1956                if (sk_filter(sk, skb))
1957                        kfree_skb(skb);
1958                else
1959                        __netlink_sendskb(sk, skb);
1960                return 0;
1961        }
1962
1963        nlh = nlmsg_put_answer(skb, cb, NLMSG_DONE, sizeof(len), NLM_F_MULTI);
1964        if (!nlh)
1965                goto errout_skb;
1966
1967        nl_dump_check_consistent(cb, nlh);
1968
1969        memcpy(nlmsg_data(nlh), &len, sizeof(len));
1970
1971        if (sk_filter(sk, skb))
1972                kfree_skb(skb);
1973        else
1974                __netlink_sendskb(sk, skb);
1975
1976        if (cb->done)
1977                cb->done(cb);
1978
1979        nlk->cb_running = false;
1980        module = cb->module;
1981        skb = cb->skb;
1982        mutex_unlock(nlk->cb_mutex);
1983        module_put(module);
1984        consume_skb(skb);
1985        return 0;
1986
1987errout_skb:
1988        mutex_unlock(nlk->cb_mutex);
1989        kfree_skb(skb);
1990        return err;
1991}
1992
1993int __netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
1994                         const struct nlmsghdr *nlh,
1995                         struct netlink_dump_control *control)
1996{
1997        struct netlink_callback *cb;
1998        struct sock *sk;
1999        struct netlink_sock *nlk;
2000        int ret;
2001
2002        atomic_inc(&skb->users);
2003
2004        sk = netlink_lookup(sock_net(ssk), ssk->sk_protocol, NETLINK_CB(skb).portid);
2005        if (sk == NULL) {
2006                ret = -ECONNREFUSED;
2007                goto error_free;
2008        }
2009
2010        nlk = nlk_sk(sk);
2011        mutex_lock(nlk->cb_mutex);
2012        /* A dump is in progress... */
2013        if (nlk->cb_running) {
2014                ret = -EBUSY;
2015                goto error_unlock;
2016        }
2017        /* add reference of module which cb->dump belongs to */
2018        if (!try_module_get(control->module)) {
2019                ret = -EPROTONOSUPPORT;
2020                goto error_unlock;
2021        }
2022
2023        cb = &nlk->cb;
2024        memset(cb, 0, sizeof(*cb));
2025        cb->dump = control->dump;
2026        cb->done = control->done;
2027        cb->nlh = nlh;
2028        cb->data = control->data;
2029        cb->module = control->module;
2030        cb->min_dump_alloc = control->min_dump_alloc;
2031        cb->skb = skb;
2032
2033        nlk->cb_running = true;
2034
2035        mutex_unlock(nlk->cb_mutex);
2036
2037        ret = netlink_dump(sk);
2038        sock_put(sk);
2039
2040        if (ret)
2041                return ret;
2042
2043        /* We successfully started a dump, by returning -EINTR we
2044         * signal not to send ACK even if it was requested.
2045         */
2046        return -EINTR;
2047
2048error_unlock:
2049        sock_put(sk);
2050        mutex_unlock(nlk->cb_mutex);
2051error_free:
2052        kfree_skb(skb);
2053        return ret;
2054}
2055EXPORT_SYMBOL(__netlink_dump_start);
2056
2057void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
2058{
2059        struct sk_buff *skb;
2060        struct nlmsghdr *rep;
2061        struct nlmsgerr *errmsg;
2062        size_t payload = sizeof(*errmsg);
2063
2064        /* error messages get the original request appened */
2065        if (err)
2066                payload += nlmsg_len(nlh);
2067
2068        skb = netlink_alloc_skb(in_skb->sk, nlmsg_total_size(payload),
2069                                NETLINK_CB(in_skb).portid, GFP_KERNEL);
2070        if (!skb) {
2071                struct sock *sk;
2072
2073                sk = netlink_lookup(sock_net(in_skb->sk),
2074                                    in_skb->sk->sk_protocol,
2075                                    NETLINK_CB(in_skb).portid);
2076                if (sk) {
2077                        sk->sk_err = ENOBUFS;
2078                        sk->sk_error_report(sk);
2079                        sock_put(sk);
2080                }
2081                return;
2082        }
2083
2084        rep = __nlmsg_put(skb, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
2085                          NLMSG_ERROR, payload, 0);
2086        errmsg = nlmsg_data(rep);
2087        errmsg->error = err;
2088        memcpy(&errmsg->msg, nlh, err ? nlh->nlmsg_len : sizeof(*nlh));
2089        netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).portid, MSG_DONTWAIT);
2090}
2091EXPORT_SYMBOL(netlink_ack);
2092
2093int netlink_rcv_skb(struct sk_buff *skb, int (*cb)(struct sk_buff *,
2094                                                     struct nlmsghdr *))
2095{
2096        struct nlmsghdr *nlh;
2097        int err;
2098
2099        while (skb->len >= nlmsg_total_size(0)) {
2100                int msglen;
2101
2102                nlh = nlmsg_hdr(skb);
2103                err = 0;
2104
2105                if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len)
2106                        return 0;
2107
2108                /* Only requests are handled by the kernel */
2109                if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
2110                        goto ack;
2111
2112                /* Skip control messages */
2113                if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
2114                        goto ack;
2115
2116                err = cb(skb, nlh);
2117                if (err == -EINTR)
2118                        goto skip;
2119
2120ack:
2121                if (nlh->nlmsg_flags & NLM_F_ACK || err)
2122                        netlink_ack(skb, nlh, err);
2123
2124skip:
2125                msglen = NLMSG_ALIGN(nlh->nlmsg_len);
2126                if (msglen > skb->len)
2127                        msglen = skb->len;
2128                skb_pull(skb, msglen);
2129        }
2130
2131        return 0;
2132}
2133EXPORT_SYMBOL(netlink_rcv_skb);
2134
2135/**
2136 * nlmsg_notify - send a notification netlink message
2137 * @sk: netlink socket to use
2138 * @skb: notification message
2139 * @portid: destination netlink portid for reports or 0
2140 * @group: destination multicast group or 0
2141 * @report: 1 to report back, 0 to disable
2142 * @flags: allocation flags
2143 */
2144int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
2145                 unsigned int group, int report, gfp_t flags)
2146{
2147        int err = 0;
2148
2149        if (group) {
2150                int exclude_portid = 0;
2151
2152                if (report) {
2153                        atomic_inc(&skb->users);
2154                        exclude_portid = portid;
2155                }
2156
2157                /* errors reported via destination sk->sk_err, but propagate
2158                 * delivery errors if NETLINK_BROADCAST_ERROR flag is set */
2159                err = nlmsg_multicast(sk, skb, exclude_portid, group, flags);
2160        }
2161
2162        if (report) {
2163                int err2;
2164
2165                err2 = nlmsg_unicast(sk, skb, portid);
2166                if (!err || err == -ESRCH)
2167                        err = err2;
2168        }
2169
2170        return err;
2171}
2172EXPORT_SYMBOL(nlmsg_notify);
2173
2174#ifdef CONFIG_PROC_FS
2175struct nl_seq_iter {
2176        struct seq_net_private p;
2177        int link;
2178        int hash_idx;
2179};
2180
2181static struct sock *netlink_seq_socket_idx(struct seq_file *seq, loff_t pos)
2182{
2183        struct nl_seq_iter *iter = seq->private;
2184        int i, j;
2185        struct netlink_sock *nlk;
2186        struct sock *s;
2187        loff_t off = 0;
2188
2189        for (i = 0; i < MAX_LINKS; i++) {
2190                struct rhashtable *ht = &nl_table[i].hash;
2191                const struct bucket_table *tbl = rht_dereference_rcu(ht->tbl, ht);
2192
2193                for (j = 0; j < tbl->size; j++) {
2194                        rht_for_each_entry_rcu(nlk, tbl->buckets[j], node) {
2195                                s = (struct sock *)nlk;
2196
2197                                if (sock_net(s) != seq_file_net(seq))
2198                                        continue;
2199                                if (off == pos) {
2200                                        iter->link = i;
2201                                        iter->hash_idx = j;
2202                                        return s;
2203                                }
2204                                ++off;
2205                        }
2206                }
2207        }
2208        return NULL;
2209}
2210
2211static void *netlink_seq_start(struct seq_file *seq, loff_t *pos)
2212        __acquires(nl_table_lock) __acquires(RCU)
2213{
2214        read_lock(&nl_table_lock);
2215        rcu_read_lock();
2216        return *pos ? netlink_seq_socket_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2217}
2218
2219static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2220{
2221        struct rhashtable *ht;
2222        struct netlink_sock *nlk;
2223        struct nl_seq_iter *iter;
2224        struct net *net;
2225        int i, j;
2226
2227        ++*pos;
2228
2229        if (v == SEQ_START_TOKEN)
2230                return netlink_seq_socket_idx(seq, 0);
2231
2232        net = seq_file_net(seq);
2233        iter = seq->private;
2234        nlk = v;
2235
2236        i = iter->link;
2237        ht = &nl_table[i].hash;
2238        rht_for_each_entry(nlk, nlk->node.next, ht, node)
2239                if (net_eq(sock_net((struct sock *)nlk), net))
2240                        return nlk;
2241
2242        j = iter->hash_idx + 1;
2243
2244        do {
2245                const struct bucket_table *tbl = rht_dereference_rcu(ht->tbl, ht);
2246
2247                for (; j < tbl->size; j++) {
2248                        rht_for_each_entry(nlk, tbl->buckets[j], ht, node) {
2249                                if (net_eq(sock_net((struct sock *)nlk), net)) {
2250                                        iter->link = i;
2251                                        iter->hash_idx = j;
2252                                        return nlk;
2253                                }
2254                        }
2255                }
2256
2257                j = 0;
2258        } while (++i < MAX_LINKS);
2259
2260        return NULL;
2261}
2262
2263static void netlink_seq_stop(struct seq_file *seq, void *v)
2264        __releases(RCU) __releases(nl_table_lock)
2265{
2266        rcu_read_unlock();
2267        read_unlock(&nl_table_lock);
2268}
2269
2270
2271static int netlink_seq_show(struct seq_file *seq, void *v)
2272{
2273        if (v == SEQ_START_TOKEN) {
2274                seq_puts(seq,
2275                         "sk       Eth Pid    Groups   "
2276                         "Rmem     Wmem     Dump     Locks     Drops     Inode\n");
2277        } else {
2278                struct sock *s = v;
2279                struct netlink_sock *nlk = nlk_sk(s);
2280
2281                seq_printf(seq, "%pK %-3d %-6u %08x %-8d %-8d %d %-8d %-8d %-8lu\n",
2282                           s,
2283                           s->sk_protocol,
2284                           nlk->portid,
2285                           nlk->groups ? (u32)nlk->groups[0] : 0,
2286                           sk_rmem_alloc_get(s),
2287                           sk_wmem_alloc_get(s),
2288                           nlk->cb_running,
2289                           atomic_read(&s->sk_refcnt),
2290                           atomic_read(&s->sk_drops),
2291                           sock_i_ino(s)
2292                        );
2293
2294        }
2295        return 0;
2296}
2297
2298static const struct seq_operations netlink_seq_ops = {
2299        .start  = netlink_seq_start,
2300        .next   = netlink_seq_next,
2301        .stop   = netlink_seq_stop,
2302        .show   = netlink_seq_show,
2303};
2304
2305
2306static int netlink_seq_open(struct inode *inode, struct file *file)
2307{
2308        return seq_open_net(inode, file, &netlink_seq_ops,
2309                                sizeof(struct nl_seq_iter));
2310}
2311
2312static const struct file_operations netlink_seq_fops = {
2313        .owner          = THIS_MODULE,
2314        .open           = netlink_seq_open,
2315        .read           = seq_read,
2316        .llseek         = seq_lseek,
2317        .release        = seq_release_net,
2318};
2319
2320#endif
2321
2322int netlink_register_notifier(struct notifier_block *nb)
2323{
2324        return atomic_notifier_chain_register(&netlink_chain, nb);
2325}
2326EXPORT_SYMBOL(netlink_register_notifier);
2327
2328int netlink_unregister_notifier(struct notifier_block *nb)
2329{
2330        return atomic_notifier_chain_unregister(&netlink_chain, nb);
2331}
2332EXPORT_SYMBOL(netlink_unregister_notifier);
2333
2334static const struct proto_ops netlink_ops = {
2335        .family =       PF_NETLINK,
2336        .owner =        THIS_MODULE,
2337        .release =      netlink_release,
2338        .bind =         netlink_bind,
2339        .connect =      netlink_connect,
2340        .socketpair =   sock_no_socketpair,
2341        .accept =       sock_no_accept,
2342        .getname =      netlink_getname,
2343        .poll =         datagram_poll,
2344        .ioctl =        sock_no_ioctl,
2345        .listen =       sock_no_listen,
2346        .shutdown =     sock_no_shutdown,
2347        .setsockopt =   netlink_setsockopt,
2348        .getsockopt =   netlink_getsockopt,
2349        .sendmsg =      netlink_sendmsg,
2350        .recvmsg =      netlink_recvmsg,
2351        .mmap =         sock_no_mmap,
2352        .sendpage =     sock_no_sendpage,
2353};
2354
2355static const struct net_proto_family netlink_family_ops = {
2356        .family = PF_NETLINK,
2357        .create = netlink_create,
2358        .owner  = THIS_MODULE,  /* for consistency 8) */
2359};
2360
2361static int __net_init netlink_net_init(struct net *net)
2362{
2363#ifdef CONFIG_PROC_FS
2364        if (!proc_create("netlink", 0, net->proc_net, &netlink_seq_fops))
2365                return -ENOMEM;
2366#endif
2367        return 0;
2368}
2369
2370static void __net_exit netlink_net_exit(struct net *net)
2371{
2372#ifdef CONFIG_PROC_FS
2373        remove_proc_entry("netlink", net->proc_net);
2374#endif
2375}
2376
2377static void __init netlink_add_usersock_entry(void)
2378{
2379        struct listeners *listeners;
2380        int groups = 32;
2381
2382        listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL);
2383        if (!listeners)
2384                panic("netlink_add_usersock_entry: Cannot allocate listeners\n");
2385
2386        netlink_table_grab();
2387
2388        nl_table[NETLINK_USERSOCK].groups = groups;
2389        rcu_assign_pointer(nl_table[NETLINK_USERSOCK].listeners, listeners);
2390        nl_table[NETLINK_USERSOCK].module = THIS_MODULE;
2391        nl_table[NETLINK_USERSOCK].registered = 1;
2392        nl_table[NETLINK_USERSOCK].flags = NL_CFG_F_NONROOT_SEND;
2393
2394        netlink_table_ungrab();
2395}
2396
2397static struct pernet_operations __net_initdata netlink_net_ops = {
2398        .init = netlink_net_init,
2399        .exit = netlink_net_exit,
2400};
2401
2402static int __init netlink_proto_init(void)
2403{
2404        int i;
2405        int err = proto_register(&netlink_proto, 0);
2406        struct rhashtable_params ht_params = {
2407                .head_offset = offsetof(struct netlink_sock, node),
2408                .key_offset = offsetof(struct netlink_sock, portid),
2409                .key_len = sizeof(u32), /* portid */
2410                .hashfn = jhash,
2411                .max_shift = 16, /* 64K */
2412                .grow_decision = rht_grow_above_75,
2413                .shrink_decision = rht_shrink_below_30,
2414                .mutex_is_held = lockdep_nl_sk_hash_is_held,
2415        };
2416
2417        if (err != 0)
2418                goto out;
2419
2420        BUILD_BUG_ON(sizeof(struct netlink_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb));
2421
2422        nl_table = kcalloc(MAX_LINKS, sizeof(*nl_table), GFP_KERNEL);
2423        if (!nl_table)
2424                goto panic;
2425
2426        for (i = 0; i < MAX_LINKS; i++) {
2427                if (rhashtable_init(&nl_table[i].hash, &ht_params) < 0) {
2428                        while (--i > 0)
2429                                rhashtable_destroy(&nl_table[i].hash);
2430                        kfree(nl_table);
2431                        goto panic;
2432                }
2433        }
2434
2435        INIT_LIST_HEAD(&netlink_tap_all);
2436
2437        netlink_add_usersock_entry();
2438
2439        sock_register(&netlink_family_ops);
2440        register_pernet_subsys(&netlink_net_ops);
2441        /* The netlink device handler may be needed early. */
2442        rtnetlink_init();
2443out:
2444        return err;
2445panic:
2446        panic("netlink_init: Cannot allocate nl_table\n");
2447}
2448
2449core_initcall(netlink_proto_init);
Note: See TracBrowser for help on using the repository browser.