projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[NETFILTER]: Move ipv4 specific code from net/core/netfilter.c to net/ipv4/netfilter.c
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / netlink / af_netlink.c
CommitLineData
1da177e4
LT		 1/*
2 * NETLINK Kernel-user communication protocol.
3 *
4 * Authors: Alan Cox <alan@redhat.com>
5 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * Tue Jun 26 14:36:48 MEST 2001 Herbert "herp" Rosmanith
13 * added netlink_proto_exit
14 * Tue Jan 22 18:32:44 BRST 2002 Arnaldo C. de Melo <acme@conectiva.com.br>
15 * use nlk_sk, as sk->protinfo is on a diet 8)
16 *
17 */
18
19#include <linux/config.h>
20#include <linux/module.h>
21
22#include <linux/kernel.h>
23#include <linux/init.h>
1da177e4
LT		 24#include <linux/signal.h>
25#include <linux/sched.h>
26#include <linux/errno.h>
27#include <linux/string.h>
28#include <linux/stat.h>
29#include <linux/socket.h>
30#include <linux/un.h>
31#include <linux/fcntl.h>
32#include <linux/termios.h>
33#include <linux/sockios.h>
34#include <linux/net.h>
35#include <linux/fs.h>
36#include <linux/slab.h>
37#include <asm/uaccess.h>
38#include <linux/skbuff.h>
39#include <linux/netdevice.h>
40#include <linux/rtnetlink.h>
41#include <linux/proc_fs.h>
42#include <linux/seq_file.h>
43#include <linux/smp_lock.h>
44#include <linux/notifier.h>
45#include <linux/security.h>
46#include <linux/jhash.h>
47#include <linux/jiffies.h>
48#include <linux/random.h>
49#include <linux/bitops.h>
50#include <linux/mm.h>
51#include <linux/types.h>
54e0f520
AM		 52#include <linux/audit.h>
53
1da177e4
LT		 54#include <net/sock.h>
55#include <net/scm.h>
56
57#define Nprintk(a...)
58
59struct netlink_sock {
60 /* struct sock has to be the first member of netlink_sock */
61 struct sock sk;
62 u32 pid;
63 unsigned int groups;
64 u32 dst_pid;
65 unsigned int dst_groups;
66 unsigned long state;
67 wait_queue_head_t wait;
68 struct netlink_callback *cb;
69 spinlock_t cb_lock;
70 void (*data_ready)(struct sock *sk, int bytes);
71};
72
73static inline struct netlink_sock *nlk_sk(struct sock *sk)
74{
75 return (struct netlink_sock *)sk;
76}
77
78struct nl_pid_hash {
79 struct hlist_head *table;
80 unsigned long rehash_time;
81
82 unsigned int mask;
83 unsigned int shift;
84
85 unsigned int entries;
86 unsigned int max_shift;
87
88 u32 rnd;
89};
90
91struct netlink_table {
92 struct nl_pid_hash hash;
93 struct hlist_head mc_list;
94 unsigned int nl_nonroot;
95};
96
97static struct netlink_table *nl_table;
98
99static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);
100
101static int netlink_dump(struct sock *sk);
102static void netlink_destroy_callback(struct netlink_callback *cb);
103
104static DEFINE_RWLOCK(nl_table_lock);
105static atomic_t nl_table_users = ATOMIC_INIT(0);
106
107static struct notifier_block *netlink_chain;
108
109static struct hlist_head *nl_pid_hashfn(struct nl_pid_hash *hash, u32 pid)
110{
111 return &hash->table[jhash_1word(pid, hash->rnd) & hash->mask];
112}
113
114static void netlink_sock_destruct(struct sock *sk)
115{
116 skb_queue_purge(&sk->sk_receive_queue);
117
118 if (!sock_flag(sk, SOCK_DEAD)) {
119 printk("Freeing alive netlink socket %p\n", sk);
120 return;
121 }
122 BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
123 BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
124 BUG_TRAP(!nlk_sk(sk)->cb);
125}
126
127/* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on SMP.
128 * Look, when several writers sleep and reader wakes them up, all but one
129 * immediately hit write lock and grab all the cpus. Exclusive sleep solves
130 * this, _but_ remember, it adds useless work on UP machines.
131 */
132
133static void netlink_table_grab(void)
134{
135 write_lock_bh(&nl_table_lock);
136
137 if (atomic_read(&nl_table_users)) {
138 DECLARE_WAITQUEUE(wait, current);
139
140 add_wait_queue_exclusive(&nl_table_wait, &wait);
141 for(;;) {
142 set_current_state(TASK_UNINTERRUPTIBLE);
143 if (atomic_read(&nl_table_users) == 0)
144 break;
145 write_unlock_bh(&nl_table_lock);
146 schedule();
147 write_lock_bh(&nl_table_lock);
148 }
149
150 __set_current_state(TASK_RUNNING);
151 remove_wait_queue(&nl_table_wait, &wait);
152 }
153}
154
155static __inline__ void netlink_table_ungrab(void)
156{
157 write_unlock_bh(&nl_table_lock);
158 wake_up(&nl_table_wait);
159}
160
161static __inline__ void
162netlink_lock_table(void)
163{
164 /* read_lock() synchronizes us to netlink_table_grab */
165
166 read_lock(&nl_table_lock);
167 atomic_inc(&nl_table_users);
168 read_unlock(&nl_table_lock);
169}
170
171static __inline__ void
172netlink_unlock_table(void)
173{
174 if (atomic_dec_and_test(&nl_table_users))
175 wake_up(&nl_table_wait);
176}
177
178static __inline__ struct sock *netlink_lookup(int protocol, u32 pid)
179{
180 struct nl_pid_hash *hash = &nl_table[protocol].hash;
181 struct hlist_head *head;
182 struct sock *sk;
183 struct hlist_node *node;
184
185 read_lock(&nl_table_lock);
186 head = nl_pid_hashfn(hash, pid);
187 sk_for_each(sk, node, head) {
188 if (nlk_sk(sk)->pid == pid) {
189 sock_hold(sk);
190 goto found;
191 }
192 }
193 sk = NULL;
194found:
195 read_unlock(&nl_table_lock);
196 return sk;
197}
198
199static inline struct hlist_head *nl_pid_hash_alloc(size_t size)
200{
201 if (size <= PAGE_SIZE)
202 return kmalloc(size, GFP_ATOMIC);
203 else
204 return (struct hlist_head *)
205 __get_free_pages(GFP_ATOMIC, get_order(size));
206}
207
208static inline void nl_pid_hash_free(struct hlist_head *table, size_t size)
209{
210 if (size <= PAGE_SIZE)
211 kfree(table);
212 else
213 free_pages((unsigned long)table, get_order(size));
214}
215
216static int nl_pid_hash_rehash(struct nl_pid_hash *hash, int grow)
217{
218 unsigned int omask, mask, shift;
219 size_t osize, size;
220 struct hlist_head *otable, *table;
221 int i;
222
223 omask = mask = hash->mask;
224 osize = size = (mask + 1) * sizeof(*table);
225 shift = hash->shift;
226
227 if (grow) {
228 if (++shift > hash->max_shift)
229 return 0;
230 mask = mask * 2 + 1;
231 size *= 2;
232 }
233
234 table = nl_pid_hash_alloc(size);
235 if (!table)
236 return 0;
237
238 memset(table, 0, size);
239 otable = hash->table;
240 hash->table = table;
241 hash->mask = mask;
242 hash->shift = shift;
243 get_random_bytes(&hash->rnd, sizeof(hash->rnd));
244
245 for (i = 0; i <= omask; i++) {
246 struct sock *sk;
247 struct hlist_node *node, *tmp;
248
249 sk_for_each_safe(sk, node, tmp, &otable[i])
250 __sk_add_node(sk, nl_pid_hashfn(hash, nlk_sk(sk)->pid));
251 }
252
253 nl_pid_hash_free(otable, osize);
254 hash->rehash_time = jiffies + 10 * 60 * HZ;
255 return 1;
256}
257
258static inline int nl_pid_hash_dilute(struct nl_pid_hash *hash, int len)
259{
260 int avg = hash->entries >> hash->shift;
261
262 if (unlikely(avg > 1) && nl_pid_hash_rehash(hash, 1))
263 return 1;
264
265 if (unlikely(len > avg) && time_after(jiffies, hash->rehash_time)) {
266 nl_pid_hash_rehash(hash, 0);
267 return 1;
268 }
269
270 return 0;
271}
272
273static struct proto_ops netlink_ops;
274
275static int netlink_insert(struct sock *sk, u32 pid)
276{
277 struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
278 struct hlist_head *head;
279 int err = -EADDRINUSE;
280 struct sock *osk;
281 struct hlist_node *node;
282 int len;
283
284 netlink_table_grab();
285 head = nl_pid_hashfn(hash, pid);
286 len = 0;
287 sk_for_each(osk, node, head) {
288 if (nlk_sk(osk)->pid == pid)
289 break;
290 len++;
291 }
292 if (node)
293 goto err;
294
295 err = -EBUSY;
296 if (nlk_sk(sk)->pid)
297 goto err;
298
299 err = -ENOMEM;
300 if (BITS_PER_LONG > 32 && unlikely(hash->entries >= UINT_MAX))
301 goto err;
302
303 if (len && nl_pid_hash_dilute(hash, len))
304 head = nl_pid_hashfn(hash, pid);
305 hash->entries++;
306 nlk_sk(sk)->pid = pid;
307 sk_add_node(sk, head);
308 err = 0;
309
310err:
311 netlink_table_ungrab();
312 return err;
313}
314
315static void netlink_remove(struct sock *sk)
316{
317 netlink_table_grab();
d470e3b4
DM		 318 if (sk_del_node_init(sk))
319 nl_table[sk->sk_protocol].hash.entries--;
1da177e4
LT		 320 if (nlk_sk(sk)->groups)
321 __sk_del_bind_node(sk);
322 netlink_table_ungrab();
323}
324
325static struct proto netlink_proto = {
326 .name = "NETLINK",
327 .owner = THIS_MODULE,
328 .obj_size = sizeof(struct netlink_sock),
329};
330
331static int netlink_create(struct socket *sock, int protocol)
332{
333 struct sock *sk;
334 struct netlink_sock *nlk;
335
336 sock->state = SS_UNCONNECTED;
337
338 if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
339 return -ESOCKTNOSUPPORT;
340
341 if (protocol<0 || protocol >= MAX_LINKS)
342 return -EPROTONOSUPPORT;
343
344 sock->ops = &netlink_ops;
345
346 sk = sk_alloc(PF_NETLINK, GFP_KERNEL, &netlink_proto, 1);
347 if (!sk)
348 return -ENOMEM;
349
350 sock_init_data(sock, sk);
351
352 nlk = nlk_sk(sk);
353
354 spin_lock_init(&nlk->cb_lock);
355 init_waitqueue_head(&nlk->wait);
356 sk->sk_destruct = netlink_sock_destruct;
357
358 sk->sk_protocol = protocol;
359 return 0;
360}
361
362static int netlink_release(struct socket *sock)
363{
364 struct sock *sk = sock->sk;
365 struct netlink_sock *nlk;
366
367 if (!sk)
368 return 0;
369
370 netlink_remove(sk);
371 nlk = nlk_sk(sk);
372
373 spin_lock(&nlk->cb_lock);
374 if (nlk->cb) {
375 nlk->cb->done(nlk->cb);
376 netlink_destroy_callback(nlk->cb);
377 nlk->cb = NULL;
1da177e4
LT		 378 }
379 spin_unlock(&nlk->cb_lock);
380
381 /* OK. Socket is unlinked, and, therefore,
382 no new packets will arrive */
383
384 sock_orphan(sk);
385 sock->sk = NULL;
386 wake_up_interruptible_all(&nlk->wait);
387
388 skb_queue_purge(&sk->sk_write_queue);
389
390 if (nlk->pid && !nlk->groups) {
391 struct netlink_notify n = {
392 .protocol = sk->sk_protocol,
393 .pid = nlk->pid,
394 };
395 notifier_call_chain(&netlink_chain, NETLINK_URELEASE, &n);
396 }
397
398 sock_put(sk);
399 return 0;
400}
401
402static int netlink_autobind(struct socket *sock)
403{
404 struct sock *sk = sock->sk;
405 struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
406 struct hlist_head *head;
407 struct sock *osk;
408 struct hlist_node *node;
409 s32 pid = current->pid;
410 int err;
411 static s32 rover = -4097;
412
413retry:
414 cond_resched();
415 netlink_table_grab();
416 head = nl_pid_hashfn(hash, pid);
417 sk_for_each(osk, node, head) {
418 if (nlk_sk(osk)->pid == pid) {
419 /* Bind collision, search negative pid values. */
420 pid = rover--;
421 if (rover > -4097)
422 rover = -4097;
423 netlink_table_ungrab();
424 goto retry;
425 }
426 }
427 netlink_table_ungrab();
428
429 err = netlink_insert(sk, pid);
430 if (err == -EADDRINUSE)
431 goto retry;
d470e3b4
DM		 432
433 /* If 2 threads race to autobind, that is fine. */
434 if (err == -EBUSY)
435 err = 0;
436
437 return err;
1da177e4
LT		 438}
439
440static inline int netlink_capable(struct socket *sock, unsigned int flag)
441{
442 return (nl_table[sock->sk->sk_protocol].nl_nonroot & flag) ||
443 capable(CAP_NET_ADMIN);
444}
445
446static int netlink_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
447{
448 struct sock *sk = sock->sk;
449 struct netlink_sock *nlk = nlk_sk(sk);
450 struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
451 int err;
452
453 if (nladdr->nl_family != AF_NETLINK)
454 return -EINVAL;
455
456 /* Only superuser is allowed to listen multicasts */
457 if (nladdr->nl_groups && !netlink_capable(sock, NL_NONROOT_RECV))
458 return -EPERM;
459
460 if (nlk->pid) {
461 if (nladdr->nl_pid != nlk->pid)
462 return -EINVAL;
463 } else {
464 err = nladdr->nl_pid ?
465 netlink_insert(sk, nladdr->nl_pid) :
466 netlink_autobind(sock);
467 if (err)
468 return err;
469 }
470
471 if (!nladdr->nl_groups && !nlk->groups)
472 return 0;
473
474 netlink_table_grab();
475 if (nlk->groups && !nladdr->nl_groups)
476 __sk_del_bind_node(sk);
477 else if (!nlk->groups && nladdr->nl_groups)
478 sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list);
479 nlk->groups = nladdr->nl_groups;
480 netlink_table_ungrab();
481
482 return 0;
483}
484
485static int netlink_connect(struct socket *sock, struct sockaddr *addr,
486 int alen, int flags)
487{
488 int err = 0;
489 struct sock *sk = sock->sk;
490 struct netlink_sock *nlk = nlk_sk(sk);
491 struct sockaddr_nl *nladdr=(struct sockaddr_nl*)addr;
492
493 if (addr->sa_family == AF_UNSPEC) {
494 sk->sk_state = NETLINK_UNCONNECTED;
495 nlk->dst_pid = 0;
496 nlk->dst_groups = 0;
497 return 0;
498 }
499 if (addr->sa_family != AF_NETLINK)
500 return -EINVAL;
501
502 /* Only superuser is allowed to send multicasts */
503 if (nladdr->nl_groups && !netlink_capable(sock, NL_NONROOT_SEND))
504 return -EPERM;
505
506 if (!nlk->pid)
507 err = netlink_autobind(sock);
508
509 if (err == 0) {
510 sk->sk_state = NETLINK_CONNECTED;
511 nlk->dst_pid = nladdr->nl_pid;
512 nlk->dst_groups = nladdr->nl_groups;
513 }
514
515 return err;
516}
517
518static int netlink_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
519{
520 struct sock *sk = sock->sk;
521 struct netlink_sock *nlk = nlk_sk(sk);
522 struct sockaddr_nl *nladdr=(struct sockaddr_nl *)addr;
523
524 nladdr->nl_family = AF_NETLINK;
525 nladdr->nl_pad = 0;
526 *addr_len = sizeof(*nladdr);
527
528 if (peer) {
529 nladdr->nl_pid = nlk->dst_pid;
530 nladdr->nl_groups = nlk->dst_groups;
531 } else {
532 nladdr->nl_pid = nlk->pid;
533 nladdr->nl_groups = nlk->groups;
534 }
535 return 0;
536}
537
538static void netlink_overrun(struct sock *sk)
539{
540 if (!test_and_set_bit(0, &nlk_sk(sk)->state)) {
541 sk->sk_err = ENOBUFS;
542 sk->sk_error_report(sk);
543 }
544}
545
546static struct sock *netlink_getsockbypid(struct sock *ssk, u32 pid)
547{
548 int protocol = ssk->sk_protocol;
549 struct sock *sock;
550 struct netlink_sock *nlk;
551
552 sock = netlink_lookup(protocol, pid);
553 if (!sock)
554 return ERR_PTR(-ECONNREFUSED);
555
556 /* Don't bother queuing skb if kernel socket has no input function */
557 nlk = nlk_sk(sock);
558 if ((nlk->pid == 0 && !nlk->data_ready) ||
559 (sock->sk_state == NETLINK_CONNECTED &&
560 nlk->dst_pid != nlk_sk(ssk)->pid)) {
561 sock_put(sock);
562 return ERR_PTR(-ECONNREFUSED);
563 }
564 return sock;
565}
566
567struct sock *netlink_getsockbyfilp(struct file *filp)
568{
569 struct inode *inode = filp->f_dentry->d_inode;
570 struct sock *sock;
571
572 if (!S_ISSOCK(inode->i_mode))
573 return ERR_PTR(-ENOTSOCK);
574
575 sock = SOCKET_I(inode)->sk;
576 if (sock->sk_family != AF_NETLINK)
577 return ERR_PTR(-EINVAL);
578
579 sock_hold(sock);
580 return sock;
581}
582
583/*
584 * Attach a skb to a netlink socket.
585 * The caller must hold a reference to the destination socket. On error, the
586 * reference is dropped. The skb is not send to the destination, just all
587 * all error checks are performed and memory in the queue is reserved.
588 * Return values:
589 * < 0: error. skb freed, reference to sock dropped.
590 * 0: continue
591 * 1: repeat lookup - reference dropped while waiting for socket memory.
592 */
593int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock, long timeo)
594{
595 struct netlink_sock *nlk;
596
597 nlk = nlk_sk(sk);
598
599 if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
600 test_bit(0, &nlk->state)) {
601 DECLARE_WAITQUEUE(wait, current);
602 if (!timeo) {
603 if (!nlk->pid)
604 netlink_overrun(sk);
605 sock_put(sk);
606 kfree_skb(skb);
607 return -EAGAIN;
608 }
609
610 __set_current_state(TASK_INTERRUPTIBLE);
611 add_wait_queue(&nlk->wait, &wait);
612
613 if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
614 test_bit(0, &nlk->state)) &&
615 !sock_flag(sk, SOCK_DEAD))
616 timeo = schedule_timeout(timeo);
617
618 __set_current_state(TASK_RUNNING);
619 remove_wait_queue(&nlk->wait, &wait);
620 sock_put(sk);
621
622 if (signal_pending(current)) {
623 kfree_skb(skb);
624 return sock_intr_errno(timeo);
625 }
626 return 1;
627 }
628 skb_set_owner_r(skb, sk);
629 return 0;
630}
631
632int netlink_sendskb(struct sock *sk, struct sk_buff *skb, int protocol)
633{
634 struct netlink_sock *nlk;
635 int len = skb->len;
636
637 nlk = nlk_sk(sk);
638
639 skb_queue_tail(&sk->sk_receive_queue, skb);
640 sk->sk_data_ready(sk, len);
641 sock_put(sk);
642 return len;
643}
644
645void netlink_detachskb(struct sock *sk, struct sk_buff *skb)
646{
647 kfree_skb(skb);
648 sock_put(sk);
649}
650
37da647d
VF		 651static inline struct sk_buff *netlink_trim(struct sk_buff *skb,
652 unsigned int __nocast allocation)
1da177e4
LT		 653{
654 int delta;
655
656 skb_orphan(skb);
657
658 delta = skb->end - skb->tail;
659 if (delta * 2 < skb->truesize)
660 return skb;
661
662 if (skb_shared(skb)) {
663 struct sk_buff *nskb = skb_clone(skb, allocation);
664 if (!nskb)
665 return skb;
666 kfree_skb(skb);
667 skb = nskb;
668 }
669
670 if (!pskb_expand_head(skb, 0, -delta, allocation))
671 skb->truesize -= delta;
672
673 return skb;
674}
675
676int netlink_unicast(struct sock *ssk, struct sk_buff *skb, u32 pid, int nonblock)
677{
678 struct sock *sk;
679 int err;
680 long timeo;
681
682 skb = netlink_trim(skb, gfp_any());
683
684 timeo = sock_sndtimeo(ssk, nonblock);
685retry:
686 sk = netlink_getsockbypid(ssk, pid);
687 if (IS_ERR(sk)) {
688 kfree_skb(skb);
689 return PTR_ERR(sk);
690 }
691 err = netlink_attachskb(sk, skb, nonblock, timeo);
692 if (err == 1)
693 goto retry;
694 if (err)
695 return err;
696
697 return netlink_sendskb(sk, skb, ssk->sk_protocol);
698}
699
700static __inline__ int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb)
701{
702 struct netlink_sock *nlk = nlk_sk(sk);
703
704 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
705 !test_bit(0, &nlk->state)) {
706 skb_set_owner_r(skb, sk);
707 skb_queue_tail(&sk->sk_receive_queue, skb);
708 sk->sk_data_ready(sk, skb->len);
709 return atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf;
710 }
711 return -1;
712}
713
714struct netlink_broadcast_data {
715 struct sock *exclude_sk;
716 u32 pid;
717 u32 group;
718 int failure;
719 int congested;
720 int delivered;
37da647d 721 unsigned int allocation;
1da177e4
LT		 722 struct sk_buff *skb, *skb2;
723};
724
725static inline int do_one_broadcast(struct sock *sk,
726 struct netlink_broadcast_data *p)
727{
728 struct netlink_sock *nlk = nlk_sk(sk);
729 int val;
730
731 if (p->exclude_sk == sk)
732 goto out;
733
734 if (nlk->pid == p->pid || !(nlk->groups & p->group))
735 goto out;
736
737 if (p->failure) {
738 netlink_overrun(sk);
739 goto out;
740 }
741
742 sock_hold(sk);
743 if (p->skb2 == NULL) {
68acc024 744 if (skb_shared(p->skb)) {
1da177e4
LT		 745 p->skb2 = skb_clone(p->skb, p->allocation);
746 } else {
68acc024
TC		 747 p->skb2 = skb_get(p->skb);
748 /*
749 * skb ownership may have been set when
750 * delivered to a previous socket.
751 */
752 skb_orphan(p->skb2);
1da177e4
LT		 753 }
754 }
755 if (p->skb2 == NULL) {
756 netlink_overrun(sk);
757 /* Clone failed. Notify ALL listeners. */
758 p->failure = 1;
759 } else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0) {
760 netlink_overrun(sk);
761 } else {
762 p->congested |= val;
763 p->delivered = 1;
764 p->skb2 = NULL;
765 }
766 sock_put(sk);
767
768out:
769 return 0;
770}
771
772int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid,
773 u32 group, int allocation)
774{
775 struct netlink_broadcast_data info;
776 struct hlist_node *node;
777 struct sock *sk;
778
779 skb = netlink_trim(skb, allocation);
780
781 info.exclude_sk = ssk;
782 info.pid = pid;
783 info.group = group;
784 info.failure = 0;
785 info.congested = 0;
786 info.delivered = 0;
787 info.allocation = allocation;
788 info.skb = skb;
789 info.skb2 = NULL;
790
791 /* While we sleep in clone, do not allow to change socket list */
792
793 netlink_lock_table();
794
795 sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list)
796 do_one_broadcast(sk, &info);
797
aa1c6a6f
TC		 798 kfree_skb(skb);
799
1da177e4
LT		 800 netlink_unlock_table();
801
802 if (info.skb2)
803 kfree_skb(info.skb2);
1da177e4
LT		 804
805 if (info.delivered) {
806 if (info.congested && (allocation & __GFP_WAIT))
807 yield();
808 return 0;
809 }
810 if (info.failure)
811 return -ENOBUFS;
812 return -ESRCH;
813}
814
815struct netlink_set_err_data {
816 struct sock *exclude_sk;
817 u32 pid;
818 u32 group;
819 int code;
820};
821
822static inline int do_one_set_err(struct sock *sk,
823 struct netlink_set_err_data *p)
824{
825 struct netlink_sock *nlk = nlk_sk(sk);
826
827 if (sk == p->exclude_sk)
828 goto out;
829
830 if (nlk->pid == p->pid || !(nlk->groups & p->group))
831 goto out;
832
833 sk->sk_err = p->code;
834 sk->sk_error_report(sk);
835out:
836 return 0;
837}
838
839void netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code)
840{
841 struct netlink_set_err_data info;
842 struct hlist_node *node;
843 struct sock *sk;
844
845 info.exclude_sk = ssk;
846 info.pid = pid;
847 info.group = group;
848 info.code = code;
849
850 read_lock(&nl_table_lock);
851
852 sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list)
853 do_one_set_err(sk, &info);
854
855 read_unlock(&nl_table_lock);
856}
857
858static inline void netlink_rcv_wake(struct sock *sk)
859{
860 struct netlink_sock *nlk = nlk_sk(sk);
861
b03efcfb 862 if (skb_queue_empty(&sk->sk_receive_queue))
1da177e4
LT		 863 clear_bit(0, &nlk->state);
864 if (!test_bit(0, &nlk->state))
865 wake_up_interruptible(&nlk->wait);
866}
867
868static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
869 struct msghdr *msg, size_t len)
870{
871 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
872 struct sock *sk = sock->sk;
873 struct netlink_sock *nlk = nlk_sk(sk);
874 struct sockaddr_nl *addr=msg->msg_name;
875 u32 dst_pid;
876 u32 dst_groups;
877 struct sk_buff *skb;
878 int err;
879 struct scm_cookie scm;
880
881 if (msg->msg_flags&MSG_OOB)
882 return -EOPNOTSUPP;
883
884 if (NULL == siocb->scm)
885 siocb->scm = &scm;
886 err = scm_send(sock, msg, siocb->scm);
887 if (err < 0)
888 return err;
889
890 if (msg->msg_namelen) {
891 if (addr->nl_family != AF_NETLINK)
892 return -EINVAL;
893 dst_pid = addr->nl_pid;
894 dst_groups = addr->nl_groups;
895 if (dst_groups && !netlink_capable(sock, NL_NONROOT_SEND))
896 return -EPERM;
897 } else {
898 dst_pid = nlk->dst_pid;
899 dst_groups = nlk->dst_groups;
900 }
901
902 if (!nlk->pid) {
903 err = netlink_autobind(sock);
904 if (err)
905 goto out;
906 }
907
908 err = -EMSGSIZE;
909 if (len > sk->sk_sndbuf - 32)
910 goto out;
911 err = -ENOBUFS;
912 skb = alloc_skb(len, GFP_KERNEL);
913 if (skb==NULL)
914 goto out;
915
916 NETLINK_CB(skb).pid = nlk->pid;
917 NETLINK_CB(skb).groups = nlk->groups;
918 NETLINK_CB(skb).dst_pid = dst_pid;
919 NETLINK_CB(skb).dst_groups = dst_groups;
c94c257c 920 NETLINK_CB(skb).loginuid = audit_get_loginuid(current->audit_context);
1da177e4
LT		 921 memcpy(NETLINK_CREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
922
923 /* What can I do? Netlink is asynchronous, so that
924 we will have to save current capabilities to
925 check them, when this message will be delivered
926 to corresponding kernel module. --ANK (980802)
927 */
928
929 err = -EFAULT;
930 if (memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len)) {
931 kfree_skb(skb);
932 goto out;
933 }
934
935 err = security_netlink_send(sk, skb);
936 if (err) {
937 kfree_skb(skb);
938 goto out;
939 }
940
941 if (dst_groups) {
942 atomic_inc(&skb->users);
943 netlink_broadcast(sk, skb, dst_pid, dst_groups, GFP_KERNEL);
944 }
945 err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT);
946
947out:
948 return err;
949}
950
951static int netlink_recvmsg(struct kiocb *kiocb, struct socket *sock,
952 struct msghdr *msg, size_t len,
953 int flags)
954{
955 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
956 struct scm_cookie scm;
957 struct sock *sk = sock->sk;
958 struct netlink_sock *nlk = nlk_sk(sk);
959 int noblock = flags&MSG_DONTWAIT;
960 size_t copied;
961 struct sk_buff *skb;
962 int err;
963
964 if (flags&MSG_OOB)
965 return -EOPNOTSUPP;
966
967 copied = 0;
968
969 skb = skb_recv_datagram(sk,flags,noblock,&err);
970 if (skb==NULL)
971 goto out;
972
973 msg->msg_namelen = 0;
974
975 copied = skb->len;
976 if (len < copied) {
977 msg->msg_flags |= MSG_TRUNC;
978 copied = len;
979 }
980
981 skb->h.raw = skb->data;
982 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
983
984 if (msg->msg_name) {
985 struct sockaddr_nl *addr = (struct sockaddr_nl*)msg->msg_name;
986 addr->nl_family = AF_NETLINK;
987 addr->nl_pad = 0;
988 addr->nl_pid = NETLINK_CB(skb).pid;
989 addr->nl_groups = NETLINK_CB(skb).dst_groups;
990 msg->msg_namelen = sizeof(*addr);
991 }
992
993 if (NULL == siocb->scm) {
994 memset(&scm, 0, sizeof(scm));
995 siocb->scm = &scm;
996 }
997 siocb->scm->creds = *NETLINK_CREDS(skb);
998 skb_free_datagram(sk, skb);
999
1000 if (nlk->cb && atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2)
1001 netlink_dump(sk);
1002
1003 scm_recv(sock, msg, siocb->scm, flags);
1004
1005out:
1006 netlink_rcv_wake(sk);
1007 return err ? : copied;
1008}
1009
1010static void netlink_data_ready(struct sock *sk, int len)
1011{
1012 struct netlink_sock *nlk = nlk_sk(sk);
1013
1014 if (nlk->data_ready)
1015 nlk->data_ready(sk, len);
1016 netlink_rcv_wake(sk);
1017}
1018
1019/*
1020 * We export these functions to other modules. They provide a
1021 * complete set of kernel non-blocking support for message
1022 * queueing.
1023 */
1024
1025struct sock *
1026netlink_kernel_create(int unit, void (*input)(struct sock *sk, int len))
1027{
1028 struct socket *sock;
1029 struct sock *sk;
1030
1031 if (!nl_table)
1032 return NULL;
1033
1034 if (unit<0 || unit>=MAX_LINKS)
1035 return NULL;
1036
1037 if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
1038 return NULL;
1039
1040 if (netlink_create(sock, unit) < 0) {
1041 sock_release(sock);
1042 return NULL;
1043 }
1044 sk = sock->sk;
1045 sk->sk_data_ready = netlink_data_ready;
1046 if (input)
1047 nlk_sk(sk)->data_ready = input;
1048
1049 if (netlink_insert(sk, 0)) {
1050 sock_release(sock);
1051 return NULL;
1052 }
1053 return sk;
1054}
1055
1056void netlink_set_nonroot(int protocol, unsigned int flags)
1057{
1058 if ((unsigned int)protocol < MAX_LINKS)
1059 nl_table[protocol].nl_nonroot = flags;
1060}
1061
1062static void netlink_destroy_callback(struct netlink_callback *cb)
1063{
1064 if (cb->skb)
1065 kfree_skb(cb->skb);
1066 kfree(cb);
1067}
1068
1069/*
1070 * It looks a bit ugly.
1071 * It would be better to create kernel thread.
1072 */
1073
1074static int netlink_dump(struct sock *sk)
1075{
1076 struct netlink_sock *nlk = nlk_sk(sk);
1077 struct netlink_callback *cb;
1078 struct sk_buff *skb;
1079 struct nlmsghdr *nlh;
1080 int len;
1081
1082 skb = sock_rmalloc(sk, NLMSG_GOODSIZE, 0, GFP_KERNEL);
1083 if (!skb)
1084 return -ENOBUFS;
1085
1086 spin_lock(&nlk->cb_lock);
1087
1088 cb = nlk->cb;
1089 if (cb == NULL) {
1090 spin_unlock(&nlk->cb_lock);
1091 kfree_skb(skb);
1092 return -EINVAL;
1093 }
1094
1095 len = cb->dump(skb, cb);
1096
1097 if (len > 0) {
1098 spin_unlock(&nlk->cb_lock);
1099 skb_queue_tail(&sk->sk_receive_queue, skb);
1100 sk->sk_data_ready(sk, len);
1101 return 0;
1102 }
1103
1797754e 1104 nlh = NLMSG_NEW_ANSWER(skb, cb, NLMSG_DONE, sizeof(len), NLM_F_MULTI);
1da177e4
LT		 1105 memcpy(NLMSG_DATA(nlh), &len, sizeof(len));
1106 skb_queue_tail(&sk->sk_receive_queue, skb);
1107 sk->sk_data_ready(sk, skb->len);
1108
1109 cb->done(cb);
1110 nlk->cb = NULL;
1111 spin_unlock(&nlk->cb_lock);
1112
1113 netlink_destroy_callback(cb);
1da177e4 1114 return 0;
1797754e
TG		 1115
1116nlmsg_failure:
1117 return -ENOBUFS;
1da177e4
LT		 1118}
1119
1120int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
1121 struct nlmsghdr *nlh,
1122 int (*dump)(struct sk_buff *skb, struct netlink_callback*),
1123 int (*done)(struct netlink_callback*))
1124{
1125 struct netlink_callback *cb;
1126 struct sock *sk;
1127 struct netlink_sock *nlk;
1128
1129 cb = kmalloc(sizeof(*cb), GFP_KERNEL);
1130 if (cb == NULL)
1131 return -ENOBUFS;
1132
1133 memset(cb, 0, sizeof(*cb));
1134 cb->dump = dump;
1135 cb->done = done;
1136 cb->nlh = nlh;
1137 atomic_inc(&skb->users);
1138 cb->skb = skb;
1139
1140 sk = netlink_lookup(ssk->sk_protocol, NETLINK_CB(skb).pid);
1141 if (sk == NULL) {
1142 netlink_destroy_callback(cb);
1143 return -ECONNREFUSED;
1144 }
1145 nlk = nlk_sk(sk);
1146 /* A dump is in progress... */
1147 spin_lock(&nlk->cb_lock);
1148 if (nlk->cb) {
1149 spin_unlock(&nlk->cb_lock);
1150 netlink_destroy_callback(cb);
1151 sock_put(sk);
1152 return -EBUSY;
1153 }
1154 nlk->cb = cb;
1da177e4
LT		 1155 spin_unlock(&nlk->cb_lock);
1156
1157 netlink_dump(sk);
1158 sock_put(sk);
1159 return 0;
1160}
1161
1162void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
1163{
1164 struct sk_buff *skb;
1165 struct nlmsghdr *rep;
1166 struct nlmsgerr *errmsg;
1167 int size;
1168
1169 if (err == 0)
1170 size = NLMSG_SPACE(sizeof(struct nlmsgerr));
1171 else
1172 size = NLMSG_SPACE(4 + NLMSG_ALIGN(nlh->nlmsg_len));
1173
1174 skb = alloc_skb(size, GFP_KERNEL);
1175 if (!skb) {
1176 struct sock *sk;
1177
1178 sk = netlink_lookup(in_skb->sk->sk_protocol,
1179 NETLINK_CB(in_skb).pid);
1180 if (sk) {
1181 sk->sk_err = ENOBUFS;
1182 sk->sk_error_report(sk);
1183 sock_put(sk);
1184 }
1185 return;
1186 }
1187
1188 rep = __nlmsg_put(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
1797754e 1189 NLMSG_ERROR, sizeof(struct nlmsgerr), 0);
1da177e4
LT		 1190 errmsg = NLMSG_DATA(rep);
1191 errmsg->error = err;
1192 memcpy(&errmsg->msg, nlh, err ? nlh->nlmsg_len : sizeof(struct nlmsghdr));
1193 netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
1194}
1195
1196
1197#ifdef CONFIG_PROC_FS
1198struct nl_seq_iter {
1199 int link;
1200 int hash_idx;
1201};
1202
1203static struct sock *netlink_seq_socket_idx(struct seq_file *seq, loff_t pos)
1204{
1205 struct nl_seq_iter *iter = seq->private;
1206 int i, j;
1207 struct sock *s;
1208 struct hlist_node *node;
1209 loff_t off = 0;
1210
1211 for (i=0; i<MAX_LINKS; i++) {
1212 struct nl_pid_hash *hash = &nl_table[i].hash;
1213
1214 for (j = 0; j <= hash->mask; j++) {
1215 sk_for_each(s, node, &hash->table[j]) {
1216 if (off == pos) {
1217 iter->link = i;
1218 iter->hash_idx = j;
1219 return s;
1220 }
1221 ++off;
1222 }
1223 }
1224 }
1225 return NULL;
1226}
1227
1228static void *netlink_seq_start(struct seq_file *seq, loff_t *pos)
1229{
1230 read_lock(&nl_table_lock);
1231 return *pos ? netlink_seq_socket_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1232}
1233
1234static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1235{
1236 struct sock *s;
1237 struct nl_seq_iter *iter;
1238 int i, j;
1239
1240 ++*pos;
1241
1242 if (v == SEQ_START_TOKEN)
1243 return netlink_seq_socket_idx(seq, 0);
1244
1245 s = sk_next(v);
1246 if (s)
1247 return s;
1248
1249 iter = seq->private;
1250 i = iter->link;
1251 j = iter->hash_idx + 1;
1252
1253 do {
1254 struct nl_pid_hash *hash = &nl_table[i].hash;
1255
1256 for (; j <= hash->mask; j++) {
1257 s = sk_head(&hash->table[j]);
1258 if (s) {
1259 iter->link = i;
1260 iter->hash_idx = j;
1261 return s;
1262 }
1263 }
1264
1265 j = 0;
1266 } while (++i < MAX_LINKS);
1267
1268 return NULL;
1269}
1270
1271static void netlink_seq_stop(struct seq_file *seq, void *v)
1272{
1273 read_unlock(&nl_table_lock);
1274}
1275
1276
1277static int netlink_seq_show(struct seq_file *seq, void *v)
1278{
1279 if (v == SEQ_START_TOKEN)
1280 seq_puts(seq,
1281 "sk Eth Pid Groups "
1282 "Rmem Wmem Dump Locks\n");
1283 else {
1284 struct sock *s = v;
1285 struct netlink_sock *nlk = nlk_sk(s);
1286
1287 seq_printf(seq, "%p %-3d %-6d %08x %-8d %-8d %p %d\n",
1288 s,
1289 s->sk_protocol,
1290 nlk->pid,
1291 nlk->groups,
1292 atomic_read(&s->sk_rmem_alloc),
1293 atomic_read(&s->sk_wmem_alloc),
1294 nlk->cb,
1295 atomic_read(&s->sk_refcnt)
1296 );
1297
1298 }
1299 return 0;
1300}
1301
1302static struct seq_operations netlink_seq_ops = {
1303 .start = netlink_seq_start,
1304 .next = netlink_seq_next,
1305 .stop = netlink_seq_stop,
1306 .show = netlink_seq_show,
1307};
1308
1309
1310static int netlink_seq_open(struct inode *inode, struct file *file)
1311{
1312 struct seq_file *seq;
1313 struct nl_seq_iter *iter;
1314 int err;
1315
1316 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
1317 if (!iter)
1318 return -ENOMEM;
1319
1320 err = seq_open(file, &netlink_seq_ops);
1321 if (err) {
1322 kfree(iter);
1323 return err;
1324 }
1325
1326 memset(iter, 0, sizeof(*iter));
1327 seq = file->private_data;
1328 seq->private = iter;
1329 return 0;
1330}
1331
1332static struct file_operations netlink_seq_fops = {
1333 .owner = THIS_MODULE,
1334 .open = netlink_seq_open,
1335 .read = seq_read,
1336 .llseek = seq_lseek,
1337 .release = seq_release_private,
1338};
1339
1340#endif
1341
1342int netlink_register_notifier(struct notifier_block *nb)
1343{
1344 return notifier_chain_register(&netlink_chain, nb);
1345}
1346
1347int netlink_unregister_notifier(struct notifier_block *nb)
1348{
1349 return notifier_chain_unregister(&netlink_chain, nb);
1350}
1351
1352static struct proto_ops netlink_ops = {
1353 .family = PF_NETLINK,
1354 .owner = THIS_MODULE,
1355 .release = netlink_release,
1356 .bind = netlink_bind,
1357 .connect = netlink_connect,
1358 .socketpair = sock_no_socketpair,
1359 .accept = sock_no_accept,
1360 .getname = netlink_getname,
1361 .poll = datagram_poll,
1362 .ioctl = sock_no_ioctl,
1363 .listen = sock_no_listen,
1364 .shutdown = sock_no_shutdown,
1365 .setsockopt = sock_no_setsockopt,
1366 .getsockopt = sock_no_getsockopt,
1367 .sendmsg = netlink_sendmsg,
1368 .recvmsg = netlink_recvmsg,
1369 .mmap = sock_no_mmap,
1370 .sendpage = sock_no_sendpage,
1371};
1372
1373static struct net_proto_family netlink_family_ops = {
1374 .family = PF_NETLINK,
1375 .create = netlink_create,
1376 .owner = THIS_MODULE, /* for consistency 8) */
1377};
1378
1379extern void netlink_skb_parms_too_large(void);
1380
1381static int __init netlink_proto_init(void)
1382{
1383 struct sk_buff *dummy_skb;
1384 int i;
1385 unsigned long max;
1386 unsigned int order;
1387 int err = proto_register(&netlink_proto, 0);
1388
1389 if (err != 0)
1390 goto out;
1391
1392 if (sizeof(struct netlink_skb_parms) > sizeof(dummy_skb->cb))
1393 netlink_skb_parms_too_large();
1394
1395 nl_table = kmalloc(sizeof(*nl_table) * MAX_LINKS, GFP_KERNEL);
1396 if (!nl_table) {
1397enomem:
1398 printk(KERN_CRIT "netlink_init: Cannot allocate nl_table\n");
1399 return -ENOMEM;
1400 }
1401
1402 memset(nl_table, 0, sizeof(*nl_table) * MAX_LINKS);
1403
1404 if (num_physpages >= (128 * 1024))
1405 max = num_physpages >> (21 - PAGE_SHIFT);
1406 else
1407 max = num_physpages >> (23 - PAGE_SHIFT);
1408
1409 order = get_bitmask_order(max) - 1 + PAGE_SHIFT;
1410 max = (1UL << order) / sizeof(struct hlist_head);
1411 order = get_bitmask_order(max > UINT_MAX ? UINT_MAX : max) - 1;
1412
1413 for (i = 0; i < MAX_LINKS; i++) {
1414 struct nl_pid_hash *hash = &nl_table[i].hash;
1415
1416 hash->table = nl_pid_hash_alloc(1 * sizeof(*hash->table));
1417 if (!hash->table) {
1418 while (i-- > 0)
1419 nl_pid_hash_free(nl_table[i].hash.table,
1420 1 * sizeof(*hash->table));
1421 kfree(nl_table);
1422 goto enomem;
1423 }
1424 memset(hash->table, 0, 1 * sizeof(*hash->table));
1425 hash->max_shift = order;
1426 hash->shift = 0;
1427 hash->mask = 0;
1428 hash->rehash_time = jiffies;
1429 }
1430
1431 sock_register(&netlink_family_ops);
1432#ifdef CONFIG_PROC_FS
1433 proc_net_fops_create("netlink", 0, &netlink_seq_fops);
1434#endif
1435 /* The netlink device handler may be needed early. */
1436 rtnetlink_init();
1437out:
1438 return err;
1439}
1440
1441static void __exit netlink_proto_exit(void)
1442{
1443 sock_unregister(PF_NETLINK);
1444 proc_net_remove("netlink");
1445 kfree(nl_table);
1446 nl_table = NULL;
1447 proto_unregister(&netlink_proto);
1448}
1449
1450core_initcall(netlink_proto_init);
1451module_exit(netlink_proto_exit);
1452
1453MODULE_LICENSE("GPL");
1454
1455MODULE_ALIAS_NETPROTO(PF_NETLINK);
1456
1457EXPORT_SYMBOL(netlink_ack);
1458EXPORT_SYMBOL(netlink_broadcast);
1459EXPORT_SYMBOL(netlink_dump_start);
1460EXPORT_SYMBOL(netlink_kernel_create);
1461EXPORT_SYMBOL(netlink_register_notifier);
1462EXPORT_SYMBOL(netlink_set_err);
1463EXPORT_SYMBOL(netlink_set_nonroot);
1464EXPORT_SYMBOL(netlink_unicast);
1465EXPORT_SYMBOL(netlink_unregister_notifier);
1466
kernel source for telekom puls (alcatel/mediatek)