b04795e7aec599dfb8d527f738fde26b9d6b2e14
[android-sdk/kernel-video.git] / net / bluetooth / af_bluetooth.c
1 /*
2    BlueZ - Bluetooth protocol stack for Linux
3    Copyright (C) 2000-2001 Qualcomm Incorporated
5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License version 2 as
9    published by the Free Software Foundation;
11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22    SOFTWARE IS DISCLAIMED.
23 */
25 /* Bluetooth address family and sockets. */
27 #include <linux/module.h>
28 #include <asm/ioctls.h>
30 #include <net/bluetooth/bluetooth.h>
31 #include <linux/proc_fs.h>
33 #define VERSION "2.16"
35 /* Bluetooth sockets */
36 #define BT_MAX_PROTO    8
37 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
38 static DEFINE_RWLOCK(bt_proto_lock);
40 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
41 static const char *const bt_key_strings[BT_MAX_PROTO] = {
42         "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
43         "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
44         "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
45         "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
46         "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
47         "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
48         "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
49         "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
50 };
52 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
53 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
54         "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
55         "slock-AF_BLUETOOTH-BTPROTO_HCI",
56         "slock-AF_BLUETOOTH-BTPROTO_SCO",
57         "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
58         "slock-AF_BLUETOOTH-BTPROTO_BNEP",
59         "slock-AF_BLUETOOTH-BTPROTO_CMTP",
60         "slock-AF_BLUETOOTH-BTPROTO_HIDP",
61         "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
62 };
64 void bt_sock_reclassify_lock(struct sock *sk, int proto)
65 {
66         BUG_ON(!sk);
67         BUG_ON(sock_owned_by_user(sk));
69         sock_lock_init_class_and_name(sk,
70                         bt_slock_key_strings[proto], &bt_slock_key[proto],
71                                 bt_key_strings[proto], &bt_lock_key[proto]);
72 }
73 EXPORT_SYMBOL(bt_sock_reclassify_lock);
75 int bt_sock_register(int proto, const struct net_proto_family *ops)
76 {
77         int err = 0;
79         if (proto < 0 || proto >= BT_MAX_PROTO)
80                 return -EINVAL;
82         write_lock(&bt_proto_lock);
84         if (bt_proto[proto])
85                 err = -EEXIST;
86         else
87                 bt_proto[proto] = ops;
89         write_unlock(&bt_proto_lock);
91         return err;
92 }
93 EXPORT_SYMBOL(bt_sock_register);
95 int bt_sock_unregister(int proto)
96 {
97         int err = 0;
99         if (proto < 0 || proto >= BT_MAX_PROTO)
100                 return -EINVAL;
102         write_lock(&bt_proto_lock);
104         if (!bt_proto[proto])
105                 err = -ENOENT;
106         else
107                 bt_proto[proto] = NULL;
109         write_unlock(&bt_proto_lock);
111         return err;
113 EXPORT_SYMBOL(bt_sock_unregister);
115 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
116                           int kern)
118         int err;
120         if (net != &init_net)
121                 return -EAFNOSUPPORT;
123         if (proto < 0 || proto >= BT_MAX_PROTO)
124                 return -EINVAL;
126         if (!bt_proto[proto])
127                 request_module("bt-proto-%d", proto);
129         err = -EPROTONOSUPPORT;
131         read_lock(&bt_proto_lock);
133         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
134                 err = bt_proto[proto]->create(net, sock, proto, kern);
135                 if (!err)
136                         bt_sock_reclassify_lock(sock->sk, proto);
137                 module_put(bt_proto[proto]->owner);
138         }
140         read_unlock(&bt_proto_lock);
142         return err;
145 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
147         write_lock(&l->lock);
148         sk_add_node(sk, &l->head);
149         write_unlock(&l->lock);
151 EXPORT_SYMBOL(bt_sock_link);
153 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
155         write_lock(&l->lock);
156         sk_del_node_init(sk);
157         write_unlock(&l->lock);
159 EXPORT_SYMBOL(bt_sock_unlink);
161 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
163         BT_DBG("parent %p, sk %p", parent, sk);
165         sock_hold(sk);
166         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
167         bt_sk(sk)->parent = parent;
168         parent->sk_ack_backlog++;
170 EXPORT_SYMBOL(bt_accept_enqueue);
172 void bt_accept_unlink(struct sock *sk)
174         BT_DBG("sk %p state %d", sk, sk->sk_state);
176         list_del_init(&bt_sk(sk)->accept_q);
177         bt_sk(sk)->parent->sk_ack_backlog--;
178         bt_sk(sk)->parent = NULL;
179         sock_put(sk);
181 EXPORT_SYMBOL(bt_accept_unlink);
183 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
185         struct list_head *p, *n;
186         struct sock *sk;
188         BT_DBG("parent %p", parent);
190         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
191                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
193                 lock_sock(sk);
195                 /* FIXME: Is this check still needed */
196                 if (sk->sk_state == BT_CLOSED) {
197                         release_sock(sk);
198                         bt_accept_unlink(sk);
199                         continue;
200                 }
202                 if (sk->sk_state == BT_CONNECTED || !newsock ||
203                     test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
204                         bt_accept_unlink(sk);
205                         if (newsock)
206                                 sock_graft(sk, newsock);
208                         release_sock(sk);
209                         return sk;
210                 }
212                 release_sock(sk);
213         }
215         return NULL;
217 EXPORT_SYMBOL(bt_accept_dequeue);
219 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
220                                 struct msghdr *msg, size_t len, int flags)
222         int noblock = flags & MSG_DONTWAIT;
223         struct sock *sk = sock->sk;
224         struct sk_buff *skb;
225         size_t copied;
226         int err;
228         BT_DBG("sock %p sk %p len %zu", sock, sk, len);
230         if (flags & (MSG_OOB))
231                 return -EOPNOTSUPP;
233         msg->msg_namelen = 0;
235         skb = skb_recv_datagram(sk, flags, noblock, &err);
236         if (!skb) {
237                 if (sk->sk_shutdown & RCV_SHUTDOWN)
238                         return 0;
239                 return err;
240         }
242         copied = skb->len;
243         if (len < copied) {
244                 msg->msg_flags |= MSG_TRUNC;
245                 copied = len;
246         }
248         skb_reset_transport_header(skb);
249         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
250         if (err == 0)
251                 sock_recv_ts_and_drops(msg, sk, skb);
253         skb_free_datagram(sk, skb);
255         return err ? : copied;
257 EXPORT_SYMBOL(bt_sock_recvmsg);
259 static long bt_sock_data_wait(struct sock *sk, long timeo)
261         DECLARE_WAITQUEUE(wait, current);
263         add_wait_queue(sk_sleep(sk), &wait);
264         for (;;) {
265                 set_current_state(TASK_INTERRUPTIBLE);
267                 if (!skb_queue_empty(&sk->sk_receive_queue))
268                         break;
270                 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
271                         break;
273                 if (signal_pending(current) || !timeo)
274                         break;
276                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
277                 release_sock(sk);
278                 timeo = schedule_timeout(timeo);
279                 lock_sock(sk);
280                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
281         }
283         __set_current_state(TASK_RUNNING);
284         remove_wait_queue(sk_sleep(sk), &wait);
285         return timeo;
288 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
289                                struct msghdr *msg, size_t size, int flags)
291         struct sock *sk = sock->sk;
292         int err = 0;
293         size_t target, copied = 0;
294         long timeo;
296         if (flags & MSG_OOB)
297                 return -EOPNOTSUPP;
299         msg->msg_namelen = 0;
301         BT_DBG("sk %p size %zu", sk, size);
303         lock_sock(sk);
305         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
306         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
308         do {
309                 struct sk_buff *skb;
310                 int chunk;
312                 skb = skb_dequeue(&sk->sk_receive_queue);
313                 if (!skb) {
314                         if (copied >= target)
315                                 break;
317                         err = sock_error(sk);
318                         if (err)
319                                 break;
320                         if (sk->sk_shutdown & RCV_SHUTDOWN)
321                                 break;
323                         err = -EAGAIN;
324                         if (!timeo)
325                                 break;
327                         timeo = bt_sock_data_wait(sk, timeo);
329                         if (signal_pending(current)) {
330                                 err = sock_intr_errno(timeo);
331                                 goto out;
332                         }
333                         continue;
334                 }
336                 chunk = min_t(unsigned int, skb->len, size);
337                 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
338                         skb_queue_head(&sk->sk_receive_queue, skb);
339                         if (!copied)
340                                 copied = -EFAULT;
341                         break;
342                 }
343                 copied += chunk;
344                 size   -= chunk;
346                 sock_recv_ts_and_drops(msg, sk, skb);
348                 if (!(flags & MSG_PEEK)) {
349                         int skb_len = skb_headlen(skb);
351                         if (chunk <= skb_len) {
352                                 __skb_pull(skb, chunk);
353                         } else {
354                                 struct sk_buff *frag;
356                                 __skb_pull(skb, skb_len);
357                                 chunk -= skb_len;
359                                 skb_walk_frags(skb, frag) {
360                                         if (chunk <= frag->len) {
361                                                 /* Pulling partial data */
362                                                 skb->len -= chunk;
363                                                 skb->data_len -= chunk;
364                                                 __skb_pull(frag, chunk);
365                                                 break;
366                                         } else if (frag->len) {
367                                                 /* Pulling all frag data */
368                                                 chunk -= frag->len;
369                                                 skb->len -= frag->len;
370                                                 skb->data_len -= frag->len;
371                                                 __skb_pull(frag, frag->len);
372                                         }
373                                 }
374                         }
376                         if (skb->len) {
377                                 skb_queue_head(&sk->sk_receive_queue, skb);
378                                 break;
379                         }
380                         kfree_skb(skb);
382                 } else {
383                         /* put message back and return */
384                         skb_queue_head(&sk->sk_receive_queue, skb);
385                         break;
386                 }
387         } while (size);
389 out:
390         release_sock(sk);
391         return copied ? : err;
393 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
395 static inline unsigned int bt_accept_poll(struct sock *parent)
397         struct list_head *p, *n;
398         struct sock *sk;
400         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
401                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
402                 if (sk->sk_state == BT_CONNECTED ||
403                     (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
404                      sk->sk_state == BT_CONNECT2))
405                         return POLLIN | POLLRDNORM;
406         }
408         return 0;
411 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
412                           poll_table *wait)
414         struct sock *sk = sock->sk;
415         unsigned int mask = 0;
417         BT_DBG("sock %p, sk %p", sock, sk);
419         poll_wait(file, sk_sleep(sk), wait);
421         if (sk->sk_state == BT_LISTEN)
422                 return bt_accept_poll(sk);
424         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
425                 mask |= POLLERR;
427         if (sk->sk_shutdown & RCV_SHUTDOWN)
428                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
430         if (sk->sk_shutdown == SHUTDOWN_MASK)
431                 mask |= POLLHUP;
433         if (!skb_queue_empty(&sk->sk_receive_queue))
434                 mask |= POLLIN | POLLRDNORM;
436         if (sk->sk_state == BT_CLOSED)
437                 mask |= POLLHUP;
439         if (sk->sk_state == BT_CONNECT ||
440                         sk->sk_state == BT_CONNECT2 ||
441                         sk->sk_state == BT_CONFIG)
442                 return mask;
444         if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
445                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
446         else
447                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
449         return mask;
451 EXPORT_SYMBOL(bt_sock_poll);
453 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
455         struct sock *sk = sock->sk;
456         struct sk_buff *skb;
457         long amount;
458         int err;
460         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
462         switch (cmd) {
463         case TIOCOUTQ:
464                 if (sk->sk_state == BT_LISTEN)
465                         return -EINVAL;
467                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
468                 if (amount < 0)
469                         amount = 0;
470                 err = put_user(amount, (int __user *) arg);
471                 break;
473         case TIOCINQ:
474                 if (sk->sk_state == BT_LISTEN)
475                         return -EINVAL;
477                 lock_sock(sk);
478                 skb = skb_peek(&sk->sk_receive_queue);
479                 amount = skb ? skb->len : 0;
480                 release_sock(sk);
481                 err = put_user(amount, (int __user *) arg);
482                 break;
484         case SIOCGSTAMP:
485                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
486                 break;
488         case SIOCGSTAMPNS:
489                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
490                 break;
492         default:
493                 err = -ENOIOCTLCMD;
494                 break;
495         }
497         return err;
499 EXPORT_SYMBOL(bt_sock_ioctl);
501 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
503         DECLARE_WAITQUEUE(wait, current);
504         int err = 0;
506         BT_DBG("sk %p", sk);
508         add_wait_queue(sk_sleep(sk), &wait);
509         set_current_state(TASK_INTERRUPTIBLE);
510         while (sk->sk_state != state) {
511                 if (!timeo) {
512                         err = -EINPROGRESS;
513                         break;
514                 }
516                 if (signal_pending(current)) {
517                         err = sock_intr_errno(timeo);
518                         break;
519                 }
521                 release_sock(sk);
522                 timeo = schedule_timeout(timeo);
523                 lock_sock(sk);
524                 set_current_state(TASK_INTERRUPTIBLE);
526                 err = sock_error(sk);
527                 if (err)
528                         break;
529         }
530         __set_current_state(TASK_RUNNING);
531         remove_wait_queue(sk_sleep(sk), &wait);
532         return err;
534 EXPORT_SYMBOL(bt_sock_wait_state);
536 #ifdef CONFIG_PROC_FS
537 struct bt_seq_state {
538         struct bt_sock_list *l;
539 };
541 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
542         __acquires(seq->private->l->lock)
544         struct bt_seq_state *s = seq->private;
545         struct bt_sock_list *l = s->l;
547         read_lock(&l->lock);
548         return seq_hlist_start_head(&l->head, *pos);
551 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
553         struct bt_seq_state *s = seq->private;
554         struct bt_sock_list *l = s->l;
556         return seq_hlist_next(v, &l->head, pos);
559 static void bt_seq_stop(struct seq_file *seq, void *v)
560         __releases(seq->private->l->lock)
562         struct bt_seq_state *s = seq->private;
563         struct bt_sock_list *l = s->l;
565         read_unlock(&l->lock);
568 static int bt_seq_show(struct seq_file *seq, void *v)
570         struct bt_seq_state *s = seq->private;
571         struct bt_sock_list *l = s->l;
573         if (v == SEQ_START_TOKEN) {
574                 seq_puts(seq ,"sk               RefCnt Rmem   Wmem   User   Inode  Src Dst Parent");
576                 if (l->custom_seq_show) {
577                         seq_putc(seq, ' ');
578                         l->custom_seq_show(seq, v);
579                 }
581                 seq_putc(seq, '\n');
582         } else {
583                 struct sock *sk = sk_entry(v);
584                 struct bt_sock *bt = bt_sk(sk);
586                 seq_printf(seq,
587                            "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
588                            sk,
589                            atomic_read(&sk->sk_refcnt),
590                            sk_rmem_alloc_get(sk),
591                            sk_wmem_alloc_get(sk),
592                            from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
593                            sock_i_ino(sk),
594                            &bt->src,
595                            &bt->dst,
596                            bt->parent? sock_i_ino(bt->parent): 0LU);
598                 if (l->custom_seq_show) {
599                         seq_putc(seq, ' ');
600                         l->custom_seq_show(seq, v);
601                 }
603                 seq_putc(seq, '\n');
604         }
605         return 0;
608 static struct seq_operations bt_seq_ops = {
609         .start = bt_seq_start,
610         .next  = bt_seq_next,
611         .stop  = bt_seq_stop,
612         .show  = bt_seq_show,
613 };
615 static int bt_seq_open(struct inode *inode, struct file *file)
617         struct bt_sock_list *sk_list;
618         struct bt_seq_state *s;
620         sk_list = PDE(inode)->data;
621         s = __seq_open_private(file, &bt_seq_ops,
622                                sizeof(struct bt_seq_state));
623         if (!s)
624                 return -ENOMEM;
626         s->l = sk_list;
627         return 0;
630 int bt_procfs_init(struct module* module, struct net *net, const char *name,
631                    struct bt_sock_list* sk_list,
632                    int (* seq_show)(struct seq_file *, void *))
634         struct proc_dir_entry * pde;
636         sk_list->custom_seq_show = seq_show;
638         sk_list->fops.owner     = module;
639         sk_list->fops.open      = bt_seq_open;
640         sk_list->fops.read      = seq_read;
641         sk_list->fops.llseek    = seq_lseek;
642         sk_list->fops.release   = seq_release_private;
644         pde = proc_net_fops_create(net, name, 0, &sk_list->fops);
645         if (!pde)
646                 return -ENOMEM;
648         pde->data = sk_list;
650         return 0;
653 void bt_procfs_cleanup(struct net *net, const char *name)
655         proc_net_remove(net, name);
657 #else
658 int bt_procfs_init(struct module* module, struct net *net, const char *name,
659                    struct bt_sock_list* sk_list,
660                    int (* seq_show)(struct seq_file *, void *))
662         return 0;
665 void bt_procfs_cleanup(struct net *net, const char *name)
668 #endif
669 EXPORT_SYMBOL(bt_procfs_init);
670 EXPORT_SYMBOL(bt_procfs_cleanup);
672 static struct net_proto_family bt_sock_family_ops = {
673         .owner  = THIS_MODULE,
674         .family = PF_BLUETOOTH,
675         .create = bt_sock_create,
676 };
678 static int __init bt_init(void)
680         int err;
682         BT_INFO("Core ver %s", VERSION);
684         err = bt_sysfs_init();
685         if (err < 0)
686                 return err;
688         err = sock_register(&bt_sock_family_ops);
689         if (err < 0) {
690                 bt_sysfs_cleanup();
691                 return err;
692         }
694         BT_INFO("HCI device and connection manager initialized");
696         err = hci_sock_init();
697         if (err < 0)
698                 goto error;
700         err = l2cap_init();
701         if (err < 0)
702                 goto sock_err;
704         err = sco_init();
705         if (err < 0) {
706                 l2cap_exit();
707                 goto sock_err;
708         }
710         return 0;
712 sock_err:
713         hci_sock_cleanup();
715 error:
716         sock_unregister(PF_BLUETOOTH);
717         bt_sysfs_cleanup();
719         return err;
722 static void __exit bt_exit(void)
725         sco_exit();
727         l2cap_exit();
729         hci_sock_cleanup();
731         sock_unregister(PF_BLUETOOTH);
733         bt_sysfs_cleanup();
736 subsys_initcall(bt_init);
737 module_exit(bt_exit);
739 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
740 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
741 MODULE_VERSION(VERSION);
742 MODULE_LICENSE("GPL");
743 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);