Loading...
1/*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
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;
10
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.
19
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*/
24
25/* Bluetooth address family and sockets. */
26
27#include <linux/module.h>
28#include <linux/debugfs.h>
29#include <asm/ioctls.h>
30
31#include <net/bluetooth/bluetooth.h>
32#include <linux/proc_fs.h>
33
34#include "selftest.h"
35
36/* Bluetooth sockets */
37#define BT_MAX_PROTO 8
38static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
39static DEFINE_RWLOCK(bt_proto_lock);
40
41static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
42static const char *const bt_key_strings[BT_MAX_PROTO] = {
43 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
44 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
45 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
46 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
47 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
48 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
49 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
50 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
51};
52
53static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
54static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
55 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
56 "slock-AF_BLUETOOTH-BTPROTO_HCI",
57 "slock-AF_BLUETOOTH-BTPROTO_SCO",
58 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
59 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
60 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
61 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
62 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
63};
64
65void bt_sock_reclassify_lock(struct sock *sk, int proto)
66{
67 BUG_ON(!sk);
68 BUG_ON(sock_owned_by_user(sk));
69
70 sock_lock_init_class_and_name(sk,
71 bt_slock_key_strings[proto], &bt_slock_key[proto],
72 bt_key_strings[proto], &bt_lock_key[proto]);
73}
74EXPORT_SYMBOL(bt_sock_reclassify_lock);
75
76int bt_sock_register(int proto, const struct net_proto_family *ops)
77{
78 int err = 0;
79
80 if (proto < 0 || proto >= BT_MAX_PROTO)
81 return -EINVAL;
82
83 write_lock(&bt_proto_lock);
84
85 if (bt_proto[proto])
86 err = -EEXIST;
87 else
88 bt_proto[proto] = ops;
89
90 write_unlock(&bt_proto_lock);
91
92 return err;
93}
94EXPORT_SYMBOL(bt_sock_register);
95
96void bt_sock_unregister(int proto)
97{
98 if (proto < 0 || proto >= BT_MAX_PROTO)
99 return;
100
101 write_lock(&bt_proto_lock);
102 bt_proto[proto] = NULL;
103 write_unlock(&bt_proto_lock);
104}
105EXPORT_SYMBOL(bt_sock_unregister);
106
107static int bt_sock_create(struct net *net, struct socket *sock, int proto,
108 int kern)
109{
110 int err;
111
112 if (net != &init_net)
113 return -EAFNOSUPPORT;
114
115 if (proto < 0 || proto >= BT_MAX_PROTO)
116 return -EINVAL;
117
118 if (!bt_proto[proto])
119 request_module("bt-proto-%d", proto);
120
121 err = -EPROTONOSUPPORT;
122
123 read_lock(&bt_proto_lock);
124
125 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
126 err = bt_proto[proto]->create(net, sock, proto, kern);
127 if (!err)
128 bt_sock_reclassify_lock(sock->sk, proto);
129 module_put(bt_proto[proto]->owner);
130 }
131
132 read_unlock(&bt_proto_lock);
133
134 return err;
135}
136
137void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
138{
139 write_lock(&l->lock);
140 sk_add_node(sk, &l->head);
141 write_unlock(&l->lock);
142}
143EXPORT_SYMBOL(bt_sock_link);
144
145void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
146{
147 write_lock(&l->lock);
148 sk_del_node_init(sk);
149 write_unlock(&l->lock);
150}
151EXPORT_SYMBOL(bt_sock_unlink);
152
153void bt_accept_enqueue(struct sock *parent, struct sock *sk)
154{
155 BT_DBG("parent %p, sk %p", parent, sk);
156
157 sock_hold(sk);
158 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
159 bt_sk(sk)->parent = parent;
160 parent->sk_ack_backlog++;
161}
162EXPORT_SYMBOL(bt_accept_enqueue);
163
164void bt_accept_unlink(struct sock *sk)
165{
166 BT_DBG("sk %p state %d", sk, sk->sk_state);
167
168 list_del_init(&bt_sk(sk)->accept_q);
169 bt_sk(sk)->parent->sk_ack_backlog--;
170 bt_sk(sk)->parent = NULL;
171 sock_put(sk);
172}
173EXPORT_SYMBOL(bt_accept_unlink);
174
175struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
176{
177 struct bt_sock *s, *n;
178 struct sock *sk;
179
180 BT_DBG("parent %p", parent);
181
182 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
183 sk = (struct sock *)s;
184
185 lock_sock(sk);
186
187 /* FIXME: Is this check still needed */
188 if (sk->sk_state == BT_CLOSED) {
189 bt_accept_unlink(sk);
190 release_sock(sk);
191 continue;
192 }
193
194 if (sk->sk_state == BT_CONNECTED || !newsock ||
195 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
196 bt_accept_unlink(sk);
197 if (newsock)
198 sock_graft(sk, newsock);
199
200 release_sock(sk);
201 return sk;
202 }
203
204 release_sock(sk);
205 }
206
207 return NULL;
208}
209EXPORT_SYMBOL(bt_accept_dequeue);
210
211int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
212 int flags)
213{
214 int noblock = flags & MSG_DONTWAIT;
215 struct sock *sk = sock->sk;
216 struct sk_buff *skb;
217 size_t copied;
218 int err;
219
220 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
221
222 if (flags & MSG_OOB)
223 return -EOPNOTSUPP;
224
225 skb = skb_recv_datagram(sk, flags, noblock, &err);
226 if (!skb) {
227 if (sk->sk_shutdown & RCV_SHUTDOWN)
228 return 0;
229
230 return err;
231 }
232
233 copied = skb->len;
234 if (len < copied) {
235 msg->msg_flags |= MSG_TRUNC;
236 copied = len;
237 }
238
239 skb_reset_transport_header(skb);
240 err = skb_copy_datagram_msg(skb, 0, msg, copied);
241 if (err == 0) {
242 sock_recv_ts_and_drops(msg, sk, skb);
243
244 if (bt_sk(sk)->skb_msg_name)
245 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
246 &msg->msg_namelen);
247 }
248
249 skb_free_datagram(sk, skb);
250
251 return err ? : copied;
252}
253EXPORT_SYMBOL(bt_sock_recvmsg);
254
255static long bt_sock_data_wait(struct sock *sk, long timeo)
256{
257 DECLARE_WAITQUEUE(wait, current);
258
259 add_wait_queue(sk_sleep(sk), &wait);
260 for (;;) {
261 set_current_state(TASK_INTERRUPTIBLE);
262
263 if (!skb_queue_empty(&sk->sk_receive_queue))
264 break;
265
266 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
267 break;
268
269 if (signal_pending(current) || !timeo)
270 break;
271
272 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
273 release_sock(sk);
274 timeo = schedule_timeout(timeo);
275 lock_sock(sk);
276 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
277 }
278
279 __set_current_state(TASK_RUNNING);
280 remove_wait_queue(sk_sleep(sk), &wait);
281 return timeo;
282}
283
284int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
285 size_t size, int flags)
286{
287 struct sock *sk = sock->sk;
288 int err = 0;
289 size_t target, copied = 0;
290 long timeo;
291
292 if (flags & MSG_OOB)
293 return -EOPNOTSUPP;
294
295 BT_DBG("sk %p size %zu", sk, size);
296
297 lock_sock(sk);
298
299 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
300 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
301
302 do {
303 struct sk_buff *skb;
304 int chunk;
305
306 skb = skb_dequeue(&sk->sk_receive_queue);
307 if (!skb) {
308 if (copied >= target)
309 break;
310
311 err = sock_error(sk);
312 if (err)
313 break;
314 if (sk->sk_shutdown & RCV_SHUTDOWN)
315 break;
316
317 err = -EAGAIN;
318 if (!timeo)
319 break;
320
321 timeo = bt_sock_data_wait(sk, timeo);
322
323 if (signal_pending(current)) {
324 err = sock_intr_errno(timeo);
325 goto out;
326 }
327 continue;
328 }
329
330 chunk = min_t(unsigned int, skb->len, size);
331 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
332 skb_queue_head(&sk->sk_receive_queue, skb);
333 if (!copied)
334 copied = -EFAULT;
335 break;
336 }
337 copied += chunk;
338 size -= chunk;
339
340 sock_recv_ts_and_drops(msg, sk, skb);
341
342 if (!(flags & MSG_PEEK)) {
343 int skb_len = skb_headlen(skb);
344
345 if (chunk <= skb_len) {
346 __skb_pull(skb, chunk);
347 } else {
348 struct sk_buff *frag;
349
350 __skb_pull(skb, skb_len);
351 chunk -= skb_len;
352
353 skb_walk_frags(skb, frag) {
354 if (chunk <= frag->len) {
355 /* Pulling partial data */
356 skb->len -= chunk;
357 skb->data_len -= chunk;
358 __skb_pull(frag, chunk);
359 break;
360 } else if (frag->len) {
361 /* Pulling all frag data */
362 chunk -= frag->len;
363 skb->len -= frag->len;
364 skb->data_len -= frag->len;
365 __skb_pull(frag, frag->len);
366 }
367 }
368 }
369
370 if (skb->len) {
371 skb_queue_head(&sk->sk_receive_queue, skb);
372 break;
373 }
374 kfree_skb(skb);
375
376 } else {
377 /* put message back and return */
378 skb_queue_head(&sk->sk_receive_queue, skb);
379 break;
380 }
381 } while (size);
382
383out:
384 release_sock(sk);
385 return copied ? : err;
386}
387EXPORT_SYMBOL(bt_sock_stream_recvmsg);
388
389static inline unsigned int bt_accept_poll(struct sock *parent)
390{
391 struct bt_sock *s, *n;
392 struct sock *sk;
393
394 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
395 sk = (struct sock *)s;
396 if (sk->sk_state == BT_CONNECTED ||
397 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
398 sk->sk_state == BT_CONNECT2))
399 return POLLIN | POLLRDNORM;
400 }
401
402 return 0;
403}
404
405unsigned int bt_sock_poll(struct file *file, struct socket *sock,
406 poll_table *wait)
407{
408 struct sock *sk = sock->sk;
409 unsigned int mask = 0;
410
411 BT_DBG("sock %p, sk %p", sock, sk);
412
413 poll_wait(file, sk_sleep(sk), wait);
414
415 if (sk->sk_state == BT_LISTEN)
416 return bt_accept_poll(sk);
417
418 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
419 mask |= POLLERR |
420 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
421
422 if (sk->sk_shutdown & RCV_SHUTDOWN)
423 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
424
425 if (sk->sk_shutdown == SHUTDOWN_MASK)
426 mask |= POLLHUP;
427
428 if (!skb_queue_empty(&sk->sk_receive_queue))
429 mask |= POLLIN | POLLRDNORM;
430
431 if (sk->sk_state == BT_CLOSED)
432 mask |= POLLHUP;
433
434 if (sk->sk_state == BT_CONNECT ||
435 sk->sk_state == BT_CONNECT2 ||
436 sk->sk_state == BT_CONFIG)
437 return mask;
438
439 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
440 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
441 else
442 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
443
444 return mask;
445}
446EXPORT_SYMBOL(bt_sock_poll);
447
448int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
449{
450 struct sock *sk = sock->sk;
451 struct sk_buff *skb;
452 long amount;
453 int err;
454
455 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
456
457 switch (cmd) {
458 case TIOCOUTQ:
459 if (sk->sk_state == BT_LISTEN)
460 return -EINVAL;
461
462 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
463 if (amount < 0)
464 amount = 0;
465 err = put_user(amount, (int __user *) arg);
466 break;
467
468 case TIOCINQ:
469 if (sk->sk_state == BT_LISTEN)
470 return -EINVAL;
471
472 lock_sock(sk);
473 skb = skb_peek(&sk->sk_receive_queue);
474 amount = skb ? skb->len : 0;
475 release_sock(sk);
476 err = put_user(amount, (int __user *) arg);
477 break;
478
479 case SIOCGSTAMP:
480 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
481 break;
482
483 case SIOCGSTAMPNS:
484 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
485 break;
486
487 default:
488 err = -ENOIOCTLCMD;
489 break;
490 }
491
492 return err;
493}
494EXPORT_SYMBOL(bt_sock_ioctl);
495
496/* This function expects the sk lock to be held when called */
497int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
498{
499 DECLARE_WAITQUEUE(wait, current);
500 int err = 0;
501
502 BT_DBG("sk %p", sk);
503
504 add_wait_queue(sk_sleep(sk), &wait);
505 set_current_state(TASK_INTERRUPTIBLE);
506 while (sk->sk_state != state) {
507 if (!timeo) {
508 err = -EINPROGRESS;
509 break;
510 }
511
512 if (signal_pending(current)) {
513 err = sock_intr_errno(timeo);
514 break;
515 }
516
517 release_sock(sk);
518 timeo = schedule_timeout(timeo);
519 lock_sock(sk);
520 set_current_state(TASK_INTERRUPTIBLE);
521
522 err = sock_error(sk);
523 if (err)
524 break;
525 }
526 __set_current_state(TASK_RUNNING);
527 remove_wait_queue(sk_sleep(sk), &wait);
528 return err;
529}
530EXPORT_SYMBOL(bt_sock_wait_state);
531
532/* This function expects the sk lock to be held when called */
533int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
534{
535 DECLARE_WAITQUEUE(wait, current);
536 unsigned long timeo;
537 int err = 0;
538
539 BT_DBG("sk %p", sk);
540
541 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
542
543 add_wait_queue(sk_sleep(sk), &wait);
544 set_current_state(TASK_INTERRUPTIBLE);
545 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
546 if (!timeo) {
547 err = -EAGAIN;
548 break;
549 }
550
551 if (signal_pending(current)) {
552 err = sock_intr_errno(timeo);
553 break;
554 }
555
556 release_sock(sk);
557 timeo = schedule_timeout(timeo);
558 lock_sock(sk);
559 set_current_state(TASK_INTERRUPTIBLE);
560
561 err = sock_error(sk);
562 if (err)
563 break;
564 }
565 __set_current_state(TASK_RUNNING);
566 remove_wait_queue(sk_sleep(sk), &wait);
567
568 return err;
569}
570EXPORT_SYMBOL(bt_sock_wait_ready);
571
572#ifdef CONFIG_PROC_FS
573struct bt_seq_state {
574 struct bt_sock_list *l;
575};
576
577static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
578 __acquires(seq->private->l->lock)
579{
580 struct bt_seq_state *s = seq->private;
581 struct bt_sock_list *l = s->l;
582
583 read_lock(&l->lock);
584 return seq_hlist_start_head(&l->head, *pos);
585}
586
587static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
588{
589 struct bt_seq_state *s = seq->private;
590 struct bt_sock_list *l = s->l;
591
592 return seq_hlist_next(v, &l->head, pos);
593}
594
595static void bt_seq_stop(struct seq_file *seq, void *v)
596 __releases(seq->private->l->lock)
597{
598 struct bt_seq_state *s = seq->private;
599 struct bt_sock_list *l = s->l;
600
601 read_unlock(&l->lock);
602}
603
604static int bt_seq_show(struct seq_file *seq, void *v)
605{
606 struct bt_seq_state *s = seq->private;
607 struct bt_sock_list *l = s->l;
608
609 if (v == SEQ_START_TOKEN) {
610 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
611
612 if (l->custom_seq_show) {
613 seq_putc(seq, ' ');
614 l->custom_seq_show(seq, v);
615 }
616
617 seq_putc(seq, '\n');
618 } else {
619 struct sock *sk = sk_entry(v);
620 struct bt_sock *bt = bt_sk(sk);
621
622 seq_printf(seq,
623 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
624 sk,
625 atomic_read(&sk->sk_refcnt),
626 sk_rmem_alloc_get(sk),
627 sk_wmem_alloc_get(sk),
628 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
629 sock_i_ino(sk),
630 bt->parent? sock_i_ino(bt->parent): 0LU);
631
632 if (l->custom_seq_show) {
633 seq_putc(seq, ' ');
634 l->custom_seq_show(seq, v);
635 }
636
637 seq_putc(seq, '\n');
638 }
639 return 0;
640}
641
642static const struct seq_operations bt_seq_ops = {
643 .start = bt_seq_start,
644 .next = bt_seq_next,
645 .stop = bt_seq_stop,
646 .show = bt_seq_show,
647};
648
649static int bt_seq_open(struct inode *inode, struct file *file)
650{
651 struct bt_sock_list *sk_list;
652 struct bt_seq_state *s;
653
654 sk_list = PDE_DATA(inode);
655 s = __seq_open_private(file, &bt_seq_ops,
656 sizeof(struct bt_seq_state));
657 if (!s)
658 return -ENOMEM;
659
660 s->l = sk_list;
661 return 0;
662}
663
664static const struct file_operations bt_fops = {
665 .open = bt_seq_open,
666 .read = seq_read,
667 .llseek = seq_lseek,
668 .release = seq_release_private
669};
670
671int bt_procfs_init(struct net *net, const char *name,
672 struct bt_sock_list *sk_list,
673 int (* seq_show)(struct seq_file *, void *))
674{
675 sk_list->custom_seq_show = seq_show;
676
677 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
678 return -ENOMEM;
679 return 0;
680}
681
682void bt_procfs_cleanup(struct net *net, const char *name)
683{
684 remove_proc_entry(name, net->proc_net);
685}
686#else
687int bt_procfs_init(struct net *net, const char *name,
688 struct bt_sock_list *sk_list,
689 int (* seq_show)(struct seq_file *, void *))
690{
691 return 0;
692}
693
694void bt_procfs_cleanup(struct net *net, const char *name)
695{
696}
697#endif
698EXPORT_SYMBOL(bt_procfs_init);
699EXPORT_SYMBOL(bt_procfs_cleanup);
700
701static struct net_proto_family bt_sock_family_ops = {
702 .owner = THIS_MODULE,
703 .family = PF_BLUETOOTH,
704 .create = bt_sock_create,
705};
706
707struct dentry *bt_debugfs;
708EXPORT_SYMBOL_GPL(bt_debugfs);
709
710static int __init bt_init(void)
711{
712 int err;
713
714 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
715
716 BT_INFO("Core ver %s", BT_SUBSYS_VERSION);
717
718 err = bt_selftest();
719 if (err < 0)
720 return err;
721
722 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
723
724 err = bt_sysfs_init();
725 if (err < 0)
726 return err;
727
728 err = sock_register(&bt_sock_family_ops);
729 if (err < 0) {
730 bt_sysfs_cleanup();
731 return err;
732 }
733
734 BT_INFO("HCI device and connection manager initialized");
735
736 err = hci_sock_init();
737 if (err < 0)
738 goto error;
739
740 err = l2cap_init();
741 if (err < 0)
742 goto sock_err;
743
744 err = sco_init();
745 if (err < 0) {
746 l2cap_exit();
747 goto sock_err;
748 }
749
750 err = mgmt_init();
751 if (err < 0) {
752 sco_exit();
753 l2cap_exit();
754 goto sock_err;
755 }
756
757 return 0;
758
759sock_err:
760 hci_sock_cleanup();
761
762error:
763 sock_unregister(PF_BLUETOOTH);
764 bt_sysfs_cleanup();
765
766 return err;
767}
768
769static void __exit bt_exit(void)
770{
771 mgmt_exit();
772
773 sco_exit();
774
775 l2cap_exit();
776
777 hci_sock_cleanup();
778
779 sock_unregister(PF_BLUETOOTH);
780
781 bt_sysfs_cleanup();
782
783 debugfs_remove_recursive(bt_debugfs);
784}
785
786subsys_initcall(bt_init);
787module_exit(bt_exit);
788
789MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
790MODULE_DESCRIPTION("Bluetooth Core ver " BT_SUBSYS_VERSION);
791MODULE_VERSION(BT_SUBSYS_VERSION);
792MODULE_LICENSE("GPL");
793MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
1/*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
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;
10
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.
19
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*/
24
25/* Bluetooth address family and sockets. */
26
27#include <linux/module.h>
28
29#include <linux/types.h>
30#include <linux/list.h>
31#include <linux/errno.h>
32#include <linux/kernel.h>
33#include <linux/sched.h>
34#include <linux/skbuff.h>
35#include <linux/init.h>
36#include <linux/poll.h>
37#include <net/sock.h>
38#include <asm/ioctls.h>
39#include <linux/kmod.h>
40
41#include <net/bluetooth/bluetooth.h>
42
43#define VERSION "2.16"
44
45/* Bluetooth sockets */
46#define BT_MAX_PROTO 8
47static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
48static DEFINE_RWLOCK(bt_proto_lock);
49
50static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
51static const char *const bt_key_strings[BT_MAX_PROTO] = {
52 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
53 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
54 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
55 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
56 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
57 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
58 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
59 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
60};
61
62static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
63static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
64 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
65 "slock-AF_BLUETOOTH-BTPROTO_HCI",
66 "slock-AF_BLUETOOTH-BTPROTO_SCO",
67 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
68 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
69 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
70 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
71 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
72};
73
74void bt_sock_reclassify_lock(struct sock *sk, int proto)
75{
76 BUG_ON(!sk);
77 BUG_ON(sock_owned_by_user(sk));
78
79 sock_lock_init_class_and_name(sk,
80 bt_slock_key_strings[proto], &bt_slock_key[proto],
81 bt_key_strings[proto], &bt_lock_key[proto]);
82}
83EXPORT_SYMBOL(bt_sock_reclassify_lock);
84
85int bt_sock_register(int proto, const struct net_proto_family *ops)
86{
87 int err = 0;
88
89 if (proto < 0 || proto >= BT_MAX_PROTO)
90 return -EINVAL;
91
92 write_lock(&bt_proto_lock);
93
94 if (bt_proto[proto])
95 err = -EEXIST;
96 else
97 bt_proto[proto] = ops;
98
99 write_unlock(&bt_proto_lock);
100
101 return err;
102}
103EXPORT_SYMBOL(bt_sock_register);
104
105int bt_sock_unregister(int proto)
106{
107 int err = 0;
108
109 if (proto < 0 || proto >= BT_MAX_PROTO)
110 return -EINVAL;
111
112 write_lock(&bt_proto_lock);
113
114 if (!bt_proto[proto])
115 err = -ENOENT;
116 else
117 bt_proto[proto] = NULL;
118
119 write_unlock(&bt_proto_lock);
120
121 return err;
122}
123EXPORT_SYMBOL(bt_sock_unregister);
124
125static int bt_sock_create(struct net *net, struct socket *sock, int proto,
126 int kern)
127{
128 int err;
129
130 if (net != &init_net)
131 return -EAFNOSUPPORT;
132
133 if (proto < 0 || proto >= BT_MAX_PROTO)
134 return -EINVAL;
135
136 if (!bt_proto[proto])
137 request_module("bt-proto-%d", proto);
138
139 err = -EPROTONOSUPPORT;
140
141 read_lock(&bt_proto_lock);
142
143 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
144 err = bt_proto[proto]->create(net, sock, proto, kern);
145 if (!err)
146 bt_sock_reclassify_lock(sock->sk, proto);
147 module_put(bt_proto[proto]->owner);
148 }
149
150 read_unlock(&bt_proto_lock);
151
152 return err;
153}
154
155void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
156{
157 write_lock(&l->lock);
158 sk_add_node(sk, &l->head);
159 write_unlock(&l->lock);
160}
161EXPORT_SYMBOL(bt_sock_link);
162
163void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
164{
165 write_lock(&l->lock);
166 sk_del_node_init(sk);
167 write_unlock(&l->lock);
168}
169EXPORT_SYMBOL(bt_sock_unlink);
170
171void bt_accept_enqueue(struct sock *parent, struct sock *sk)
172{
173 BT_DBG("parent %p, sk %p", parent, sk);
174
175 sock_hold(sk);
176 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
177 bt_sk(sk)->parent = parent;
178 parent->sk_ack_backlog++;
179}
180EXPORT_SYMBOL(bt_accept_enqueue);
181
182void bt_accept_unlink(struct sock *sk)
183{
184 BT_DBG("sk %p state %d", sk, sk->sk_state);
185
186 list_del_init(&bt_sk(sk)->accept_q);
187 bt_sk(sk)->parent->sk_ack_backlog--;
188 bt_sk(sk)->parent = NULL;
189 sock_put(sk);
190}
191EXPORT_SYMBOL(bt_accept_unlink);
192
193struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
194{
195 struct list_head *p, *n;
196 struct sock *sk;
197
198 BT_DBG("parent %p", parent);
199
200 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
201 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
202
203 lock_sock(sk);
204
205 /* FIXME: Is this check still needed */
206 if (sk->sk_state == BT_CLOSED) {
207 release_sock(sk);
208 bt_accept_unlink(sk);
209 continue;
210 }
211
212 if (sk->sk_state == BT_CONNECTED || !newsock ||
213 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
214 bt_accept_unlink(sk);
215 if (newsock)
216 sock_graft(sk, newsock);
217
218 release_sock(sk);
219 return sk;
220 }
221
222 release_sock(sk);
223 }
224
225 return NULL;
226}
227EXPORT_SYMBOL(bt_accept_dequeue);
228
229int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
230 struct msghdr *msg, size_t len, int flags)
231{
232 int noblock = flags & MSG_DONTWAIT;
233 struct sock *sk = sock->sk;
234 struct sk_buff *skb;
235 size_t copied;
236 int err;
237
238 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
239
240 if (flags & (MSG_OOB))
241 return -EOPNOTSUPP;
242
243 skb = skb_recv_datagram(sk, flags, noblock, &err);
244 if (!skb) {
245 if (sk->sk_shutdown & RCV_SHUTDOWN)
246 return 0;
247 return err;
248 }
249
250 msg->msg_namelen = 0;
251
252 copied = skb->len;
253 if (len < copied) {
254 msg->msg_flags |= MSG_TRUNC;
255 copied = len;
256 }
257
258 skb_reset_transport_header(skb);
259 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
260 if (err == 0)
261 sock_recv_ts_and_drops(msg, sk, skb);
262
263 skb_free_datagram(sk, skb);
264
265 return err ? : copied;
266}
267EXPORT_SYMBOL(bt_sock_recvmsg);
268
269static long bt_sock_data_wait(struct sock *sk, long timeo)
270{
271 DECLARE_WAITQUEUE(wait, current);
272
273 add_wait_queue(sk_sleep(sk), &wait);
274 for (;;) {
275 set_current_state(TASK_INTERRUPTIBLE);
276
277 if (!skb_queue_empty(&sk->sk_receive_queue))
278 break;
279
280 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
281 break;
282
283 if (signal_pending(current) || !timeo)
284 break;
285
286 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
287 release_sock(sk);
288 timeo = schedule_timeout(timeo);
289 lock_sock(sk);
290 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
291 }
292
293 __set_current_state(TASK_RUNNING);
294 remove_wait_queue(sk_sleep(sk), &wait);
295 return timeo;
296}
297
298int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
299 struct msghdr *msg, size_t size, int flags)
300{
301 struct sock *sk = sock->sk;
302 int err = 0;
303 size_t target, copied = 0;
304 long timeo;
305
306 if (flags & MSG_OOB)
307 return -EOPNOTSUPP;
308
309 msg->msg_namelen = 0;
310
311 BT_DBG("sk %p size %zu", sk, size);
312
313 lock_sock(sk);
314
315 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
316 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
317
318 do {
319 struct sk_buff *skb;
320 int chunk;
321
322 skb = skb_dequeue(&sk->sk_receive_queue);
323 if (!skb) {
324 if (copied >= target)
325 break;
326
327 err = sock_error(sk);
328 if (err)
329 break;
330 if (sk->sk_shutdown & RCV_SHUTDOWN)
331 break;
332
333 err = -EAGAIN;
334 if (!timeo)
335 break;
336
337 timeo = bt_sock_data_wait(sk, timeo);
338
339 if (signal_pending(current)) {
340 err = sock_intr_errno(timeo);
341 goto out;
342 }
343 continue;
344 }
345
346 chunk = min_t(unsigned int, skb->len, size);
347 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
348 skb_queue_head(&sk->sk_receive_queue, skb);
349 if (!copied)
350 copied = -EFAULT;
351 break;
352 }
353 copied += chunk;
354 size -= chunk;
355
356 sock_recv_ts_and_drops(msg, sk, skb);
357
358 if (!(flags & MSG_PEEK)) {
359 int skb_len = skb_headlen(skb);
360
361 if (chunk <= skb_len) {
362 __skb_pull(skb, chunk);
363 } else {
364 struct sk_buff *frag;
365
366 __skb_pull(skb, skb_len);
367 chunk -= skb_len;
368
369 skb_walk_frags(skb, frag) {
370 if (chunk <= frag->len) {
371 /* Pulling partial data */
372 skb->len -= chunk;
373 skb->data_len -= chunk;
374 __skb_pull(frag, chunk);
375 break;
376 } else if (frag->len) {
377 /* Pulling all frag data */
378 chunk -= frag->len;
379 skb->len -= frag->len;
380 skb->data_len -= frag->len;
381 __skb_pull(frag, frag->len);
382 }
383 }
384 }
385
386 if (skb->len) {
387 skb_queue_head(&sk->sk_receive_queue, skb);
388 break;
389 }
390 kfree_skb(skb);
391
392 } else {
393 /* put message back and return */
394 skb_queue_head(&sk->sk_receive_queue, skb);
395 break;
396 }
397 } while (size);
398
399out:
400 release_sock(sk);
401 return copied ? : err;
402}
403EXPORT_SYMBOL(bt_sock_stream_recvmsg);
404
405static inline unsigned int bt_accept_poll(struct sock *parent)
406{
407 struct list_head *p, *n;
408 struct sock *sk;
409
410 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
411 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
412 if (sk->sk_state == BT_CONNECTED ||
413 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
414 sk->sk_state == BT_CONNECT2))
415 return POLLIN | POLLRDNORM;
416 }
417
418 return 0;
419}
420
421unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait)
422{
423 struct sock *sk = sock->sk;
424 unsigned int mask = 0;
425
426 BT_DBG("sock %p, sk %p", sock, sk);
427
428 poll_wait(file, sk_sleep(sk), wait);
429
430 if (sk->sk_state == BT_LISTEN)
431 return bt_accept_poll(sk);
432
433 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
434 mask |= POLLERR;
435
436 if (sk->sk_shutdown & RCV_SHUTDOWN)
437 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
438
439 if (sk->sk_shutdown == SHUTDOWN_MASK)
440 mask |= POLLHUP;
441
442 if (!skb_queue_empty(&sk->sk_receive_queue))
443 mask |= POLLIN | POLLRDNORM;
444
445 if (sk->sk_state == BT_CLOSED)
446 mask |= POLLHUP;
447
448 if (sk->sk_state == BT_CONNECT ||
449 sk->sk_state == BT_CONNECT2 ||
450 sk->sk_state == BT_CONFIG)
451 return mask;
452
453 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
454 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
455 else
456 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
457
458 return mask;
459}
460EXPORT_SYMBOL(bt_sock_poll);
461
462int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
463{
464 struct sock *sk = sock->sk;
465 struct sk_buff *skb;
466 long amount;
467 int err;
468
469 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
470
471 switch (cmd) {
472 case TIOCOUTQ:
473 if (sk->sk_state == BT_LISTEN)
474 return -EINVAL;
475
476 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
477 if (amount < 0)
478 amount = 0;
479 err = put_user(amount, (int __user *) arg);
480 break;
481
482 case TIOCINQ:
483 if (sk->sk_state == BT_LISTEN)
484 return -EINVAL;
485
486 lock_sock(sk);
487 skb = skb_peek(&sk->sk_receive_queue);
488 amount = skb ? skb->len : 0;
489 release_sock(sk);
490 err = put_user(amount, (int __user *) arg);
491 break;
492
493 case SIOCGSTAMP:
494 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
495 break;
496
497 case SIOCGSTAMPNS:
498 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
499 break;
500
501 default:
502 err = -ENOIOCTLCMD;
503 break;
504 }
505
506 return err;
507}
508EXPORT_SYMBOL(bt_sock_ioctl);
509
510int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
511{
512 DECLARE_WAITQUEUE(wait, current);
513 int err = 0;
514
515 BT_DBG("sk %p", sk);
516
517 add_wait_queue(sk_sleep(sk), &wait);
518 set_current_state(TASK_INTERRUPTIBLE);
519 while (sk->sk_state != state) {
520 if (!timeo) {
521 err = -EINPROGRESS;
522 break;
523 }
524
525 if (signal_pending(current)) {
526 err = sock_intr_errno(timeo);
527 break;
528 }
529
530 release_sock(sk);
531 timeo = schedule_timeout(timeo);
532 lock_sock(sk);
533 set_current_state(TASK_INTERRUPTIBLE);
534
535 err = sock_error(sk);
536 if (err)
537 break;
538 }
539 __set_current_state(TASK_RUNNING);
540 remove_wait_queue(sk_sleep(sk), &wait);
541 return err;
542}
543EXPORT_SYMBOL(bt_sock_wait_state);
544
545static struct net_proto_family bt_sock_family_ops = {
546 .owner = THIS_MODULE,
547 .family = PF_BLUETOOTH,
548 .create = bt_sock_create,
549};
550
551static int __init bt_init(void)
552{
553 int err;
554
555 BT_INFO("Core ver %s", VERSION);
556
557 err = bt_sysfs_init();
558 if (err < 0)
559 return err;
560
561 err = sock_register(&bt_sock_family_ops);
562 if (err < 0) {
563 bt_sysfs_cleanup();
564 return err;
565 }
566
567 BT_INFO("HCI device and connection manager initialized");
568
569 err = hci_sock_init();
570 if (err < 0)
571 goto error;
572
573 err = l2cap_init();
574 if (err < 0)
575 goto sock_err;
576
577 err = sco_init();
578 if (err < 0) {
579 l2cap_exit();
580 goto sock_err;
581 }
582
583 return 0;
584
585sock_err:
586 hci_sock_cleanup();
587
588error:
589 sock_unregister(PF_BLUETOOTH);
590 bt_sysfs_cleanup();
591
592 return err;
593}
594
595static void __exit bt_exit(void)
596{
597
598 sco_exit();
599
600 l2cap_exit();
601
602 hci_sock_cleanup();
603
604 sock_unregister(PF_BLUETOOTH);
605
606 bt_sysfs_cleanup();
607}
608
609subsys_initcall(bt_init);
610module_exit(bt_exit);
611
612MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
613MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
614MODULE_VERSION(VERSION);
615MODULE_LICENSE("GPL");
616MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);