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.
25 /* Bluetooth address family and sockets. */
27 #include <linux/module.h>
28 #include <linux/debugfs.h>
29 #include <asm/ioctls.h>
31 #include <net/bluetooth/bluetooth.h>
32 #include <linux/proc_fs.h>
36 #define VERSION "2.21"
38 /* Bluetooth sockets */
39 #define BT_MAX_PROTO 8
40 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
41 static DEFINE_RWLOCK(bt_proto_lock);
43 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
44 static const char *const bt_key_strings[BT_MAX_PROTO] = {
45 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
46 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
47 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
48 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
49 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
50 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
51 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
52 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
55 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
56 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
57 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
58 "slock-AF_BLUETOOTH-BTPROTO_HCI",
59 "slock-AF_BLUETOOTH-BTPROTO_SCO",
60 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
61 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
62 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
63 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
64 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
67 void bt_sock_reclassify_lock(struct sock *sk, int proto)
70 BUG_ON(sock_owned_by_user(sk));
72 sock_lock_init_class_and_name(sk,
73 bt_slock_key_strings[proto], &bt_slock_key[proto],
74 bt_key_strings[proto], &bt_lock_key[proto]);
76 EXPORT_SYMBOL(bt_sock_reclassify_lock);
78 int bt_sock_register(int proto, const struct net_proto_family *ops)
82 if (proto < 0 || proto >= BT_MAX_PROTO)
85 write_lock(&bt_proto_lock);
90 bt_proto[proto] = ops;
92 write_unlock(&bt_proto_lock);
96 EXPORT_SYMBOL(bt_sock_register);
98 void bt_sock_unregister(int proto)
100 if (proto < 0 || proto >= BT_MAX_PROTO)
103 write_lock(&bt_proto_lock);
104 bt_proto[proto] = NULL;
105 write_unlock(&bt_proto_lock);
107 EXPORT_SYMBOL(bt_sock_unregister);
109 #ifdef CONFIG_PARANOID_NETWORK
110 static inline int current_has_bt_admin(void)
112 return !current_euid();
115 static inline int current_has_bt(void)
117 return current_has_bt_admin();
120 static inline int current_has_bt_admin(void)
125 static inline int current_has_bt(void)
131 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
136 if (proto == BTPROTO_RFCOMM || proto == BTPROTO_SCO ||
137 proto == BTPROTO_L2CAP) {
138 if (!current_has_bt())
140 } else if (!current_has_bt_admin())
143 if (net != &init_net)
144 return -EAFNOSUPPORT;
146 if (proto < 0 || proto >= BT_MAX_PROTO)
149 if (!bt_proto[proto])
150 request_module("bt-proto-%d", proto);
152 err = -EPROTONOSUPPORT;
154 read_lock(&bt_proto_lock);
156 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
157 err = bt_proto[proto]->create(net, sock, proto, kern);
159 bt_sock_reclassify_lock(sock->sk, proto);
160 module_put(bt_proto[proto]->owner);
163 read_unlock(&bt_proto_lock);
168 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
170 write_lock(&l->lock);
171 sk_add_node(sk, &l->head);
172 write_unlock(&l->lock);
174 EXPORT_SYMBOL(bt_sock_link);
176 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
178 write_lock(&l->lock);
179 sk_del_node_init(sk);
180 write_unlock(&l->lock);
182 EXPORT_SYMBOL(bt_sock_unlink);
184 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
186 BT_DBG("parent %p, sk %p", parent, sk);
189 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
190 bt_sk(sk)->parent = parent;
191 parent->sk_ack_backlog++;
193 EXPORT_SYMBOL(bt_accept_enqueue);
195 void bt_accept_unlink(struct sock *sk)
197 BT_DBG("sk %p state %d", sk, sk->sk_state);
199 list_del_init(&bt_sk(sk)->accept_q);
200 bt_sk(sk)->parent->sk_ack_backlog--;
201 bt_sk(sk)->parent = NULL;
204 EXPORT_SYMBOL(bt_accept_unlink);
206 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
208 struct list_head *p, *n;
211 BT_DBG("parent %p", parent);
213 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
214 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
218 /* FIXME: Is this check still needed */
219 if (sk->sk_state == BT_CLOSED) {
221 bt_accept_unlink(sk);
225 if (sk->sk_state == BT_CONNECTED || !newsock ||
226 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
227 bt_accept_unlink(sk);
229 sock_graft(sk, newsock);
240 EXPORT_SYMBOL(bt_accept_dequeue);
242 int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
245 int noblock = flags & MSG_DONTWAIT;
246 struct sock *sk = sock->sk;
251 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
256 skb = skb_recv_datagram(sk, flags, noblock, &err);
258 if (sk->sk_shutdown & RCV_SHUTDOWN)
266 msg->msg_flags |= MSG_TRUNC;
270 skb_reset_transport_header(skb);
271 err = skb_copy_datagram_msg(skb, 0, msg, copied);
273 sock_recv_ts_and_drops(msg, sk, skb);
275 if (bt_sk(sk)->skb_msg_name)
276 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
280 skb_free_datagram(sk, skb);
282 return err ? : copied;
284 EXPORT_SYMBOL(bt_sock_recvmsg);
286 static long bt_sock_data_wait(struct sock *sk, long timeo)
288 DECLARE_WAITQUEUE(wait, current);
290 add_wait_queue(sk_sleep(sk), &wait);
292 set_current_state(TASK_INTERRUPTIBLE);
294 if (!skb_queue_empty(&sk->sk_receive_queue))
297 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
300 if (signal_pending(current) || !timeo)
303 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
305 timeo = schedule_timeout(timeo);
307 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
310 __set_current_state(TASK_RUNNING);
311 remove_wait_queue(sk_sleep(sk), &wait);
315 int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
316 size_t size, int flags)
318 struct sock *sk = sock->sk;
320 size_t target, copied = 0;
326 BT_DBG("sk %p size %zu", sk, size);
330 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
331 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
337 skb = skb_dequeue(&sk->sk_receive_queue);
339 if (copied >= target)
342 err = sock_error(sk);
345 if (sk->sk_shutdown & RCV_SHUTDOWN)
352 timeo = bt_sock_data_wait(sk, timeo);
354 if (signal_pending(current)) {
355 err = sock_intr_errno(timeo);
361 chunk = min_t(unsigned int, skb->len, size);
362 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
363 skb_queue_head(&sk->sk_receive_queue, skb);
371 sock_recv_ts_and_drops(msg, sk, skb);
373 if (!(flags & MSG_PEEK)) {
374 int skb_len = skb_headlen(skb);
376 if (chunk <= skb_len) {
377 __skb_pull(skb, chunk);
379 struct sk_buff *frag;
381 __skb_pull(skb, skb_len);
384 skb_walk_frags(skb, frag) {
385 if (chunk <= frag->len) {
386 /* Pulling partial data */
388 skb->data_len -= chunk;
389 __skb_pull(frag, chunk);
391 } else if (frag->len) {
392 /* Pulling all frag data */
394 skb->len -= frag->len;
395 skb->data_len -= frag->len;
396 __skb_pull(frag, frag->len);
402 skb_queue_head(&sk->sk_receive_queue, skb);
408 /* put message back and return */
409 skb_queue_head(&sk->sk_receive_queue, skb);
416 return copied ? : err;
418 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
420 static inline unsigned int bt_accept_poll(struct sock *parent)
422 struct list_head *p, *n;
425 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
426 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
427 if (sk->sk_state == BT_CONNECTED ||
428 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
429 sk->sk_state == BT_CONNECT2))
430 return POLLIN | POLLRDNORM;
436 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
439 struct sock *sk = sock->sk;
440 unsigned int mask = 0;
442 BT_DBG("sock %p, sk %p", sock, sk);
444 poll_wait(file, sk_sleep(sk), wait);
446 if (sk->sk_state == BT_LISTEN)
447 return bt_accept_poll(sk);
449 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
451 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
453 if (sk->sk_shutdown & RCV_SHUTDOWN)
454 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
456 if (sk->sk_shutdown == SHUTDOWN_MASK)
459 if (!skb_queue_empty(&sk->sk_receive_queue))
460 mask |= POLLIN | POLLRDNORM;
462 if (sk->sk_state == BT_CLOSED)
465 if (sk->sk_state == BT_CONNECT ||
466 sk->sk_state == BT_CONNECT2 ||
467 sk->sk_state == BT_CONFIG)
470 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
471 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
473 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
477 EXPORT_SYMBOL(bt_sock_poll);
479 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
481 struct sock *sk = sock->sk;
486 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
490 if (sk->sk_state == BT_LISTEN)
493 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
496 err = put_user(amount, (int __user *) arg);
500 if (sk->sk_state == BT_LISTEN)
504 skb = skb_peek(&sk->sk_receive_queue);
505 amount = skb ? skb->len : 0;
507 err = put_user(amount, (int __user *) arg);
511 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
515 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
525 EXPORT_SYMBOL(bt_sock_ioctl);
527 /* This function expects the sk lock to be held when called */
528 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
530 DECLARE_WAITQUEUE(wait, current);
535 add_wait_queue(sk_sleep(sk), &wait);
536 set_current_state(TASK_INTERRUPTIBLE);
537 while (sk->sk_state != state) {
543 if (signal_pending(current)) {
544 err = sock_intr_errno(timeo);
549 timeo = schedule_timeout(timeo);
551 set_current_state(TASK_INTERRUPTIBLE);
553 err = sock_error(sk);
557 __set_current_state(TASK_RUNNING);
558 remove_wait_queue(sk_sleep(sk), &wait);
561 EXPORT_SYMBOL(bt_sock_wait_state);
563 /* This function expects the sk lock to be held when called */
564 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
566 DECLARE_WAITQUEUE(wait, current);
572 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
574 add_wait_queue(sk_sleep(sk), &wait);
575 set_current_state(TASK_INTERRUPTIBLE);
576 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
582 if (signal_pending(current)) {
583 err = sock_intr_errno(timeo);
588 timeo = schedule_timeout(timeo);
590 set_current_state(TASK_INTERRUPTIBLE);
592 err = sock_error(sk);
596 __set_current_state(TASK_RUNNING);
597 remove_wait_queue(sk_sleep(sk), &wait);
601 EXPORT_SYMBOL(bt_sock_wait_ready);
603 #ifdef CONFIG_PROC_FS
604 struct bt_seq_state {
605 struct bt_sock_list *l;
608 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
609 __acquires(seq->private->l->lock)
611 struct bt_seq_state *s = seq->private;
612 struct bt_sock_list *l = s->l;
615 return seq_hlist_start_head(&l->head, *pos);
618 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
620 struct bt_seq_state *s = seq->private;
621 struct bt_sock_list *l = s->l;
623 return seq_hlist_next(v, &l->head, pos);
626 static void bt_seq_stop(struct seq_file *seq, void *v)
627 __releases(seq->private->l->lock)
629 struct bt_seq_state *s = seq->private;
630 struct bt_sock_list *l = s->l;
632 read_unlock(&l->lock);
635 static int bt_seq_show(struct seq_file *seq, void *v)
637 struct bt_seq_state *s = seq->private;
638 struct bt_sock_list *l = s->l;
640 if (v == SEQ_START_TOKEN) {
641 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
643 if (l->custom_seq_show) {
645 l->custom_seq_show(seq, v);
650 struct sock *sk = sk_entry(v);
651 struct bt_sock *bt = bt_sk(sk);
654 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
656 atomic_read(&sk->sk_refcnt),
657 sk_rmem_alloc_get(sk),
658 sk_wmem_alloc_get(sk),
659 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
661 bt->parent? sock_i_ino(bt->parent): 0LU);
663 if (l->custom_seq_show) {
665 l->custom_seq_show(seq, v);
673 static const struct seq_operations bt_seq_ops = {
674 .start = bt_seq_start,
680 static int bt_seq_open(struct inode *inode, struct file *file)
682 struct bt_sock_list *sk_list;
683 struct bt_seq_state *s;
685 sk_list = PDE_DATA(inode);
686 s = __seq_open_private(file, &bt_seq_ops,
687 sizeof(struct bt_seq_state));
695 static const struct file_operations bt_fops = {
699 .release = seq_release_private
702 int bt_procfs_init(struct net *net, const char *name,
703 struct bt_sock_list* sk_list,
704 int (* seq_show)(struct seq_file *, void *))
706 sk_list->custom_seq_show = seq_show;
708 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
713 void bt_procfs_cleanup(struct net *net, const char *name)
715 remove_proc_entry(name, net->proc_net);
718 int bt_procfs_init(struct net *net, const char *name,
719 struct bt_sock_list* sk_list,
720 int (* seq_show)(struct seq_file *, void *))
725 void bt_procfs_cleanup(struct net *net, const char *name)
729 EXPORT_SYMBOL(bt_procfs_init);
730 EXPORT_SYMBOL(bt_procfs_cleanup);
732 static struct net_proto_family bt_sock_family_ops = {
733 .owner = THIS_MODULE,
734 .family = PF_BLUETOOTH,
735 .create = bt_sock_create,
738 struct dentry *bt_debugfs;
739 EXPORT_SYMBOL_GPL(bt_debugfs);
741 static int __init bt_init(void)
745 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
747 BT_INFO("Core ver %s", VERSION);
753 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
755 err = bt_sysfs_init();
759 err = sock_register(&bt_sock_family_ops);
765 BT_INFO("HCI device and connection manager initialized");
767 err = hci_sock_init();
794 sock_unregister(PF_BLUETOOTH);
800 static void __exit bt_exit(void)
810 sock_unregister(PF_BLUETOOTH);
814 debugfs_remove_recursive(bt_debugfs);
817 subsys_initcall(bt_init);
818 module_exit(bt_exit);
820 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
821 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
822 MODULE_VERSION(VERSION);
823 MODULE_LICENSE("GPL");
824 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);