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>
34 #define VERSION "2.18"
36 /* Bluetooth sockets */
37 #define BT_MAX_PROTO 8
38 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
39 static DEFINE_RWLOCK(bt_proto_lock);
41 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
42 static 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",
53 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
54 static 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",
65 void bt_sock_reclassify_lock(struct sock *sk, int proto)
68 BUG_ON(sock_owned_by_user(sk));
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]);
74 EXPORT_SYMBOL(bt_sock_reclassify_lock);
76 int bt_sock_register(int proto, const struct net_proto_family *ops)
80 if (proto < 0 || proto >= BT_MAX_PROTO)
83 write_lock(&bt_proto_lock);
88 bt_proto[proto] = ops;
90 write_unlock(&bt_proto_lock);
94 EXPORT_SYMBOL(bt_sock_register);
96 void bt_sock_unregister(int proto)
98 if (proto < 0 || proto >= BT_MAX_PROTO)
101 write_lock(&bt_proto_lock);
102 bt_proto[proto] = NULL;
103 write_unlock(&bt_proto_lock);
105 EXPORT_SYMBOL(bt_sock_unregister);
107 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
112 if (net != &init_net)
113 return -EAFNOSUPPORT;
115 if (proto < 0 || proto >= BT_MAX_PROTO)
118 if (!bt_proto[proto])
119 request_module("bt-proto-%d", proto);
121 err = -EPROTONOSUPPORT;
123 read_lock(&bt_proto_lock);
125 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
126 err = bt_proto[proto]->create(net, sock, proto, kern);
128 bt_sock_reclassify_lock(sock->sk, proto);
129 module_put(bt_proto[proto]->owner);
132 read_unlock(&bt_proto_lock);
137 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
139 write_lock(&l->lock);
140 sk_add_node(sk, &l->head);
141 write_unlock(&l->lock);
143 EXPORT_SYMBOL(bt_sock_link);
145 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
147 write_lock(&l->lock);
148 sk_del_node_init(sk);
149 write_unlock(&l->lock);
151 EXPORT_SYMBOL(bt_sock_unlink);
153 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
155 BT_DBG("parent %p, sk %p", parent, 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++;
162 EXPORT_SYMBOL(bt_accept_enqueue);
164 void bt_accept_unlink(struct sock *sk)
166 BT_DBG("sk %p state %d", sk, sk->sk_state);
168 list_del_init(&bt_sk(sk)->accept_q);
169 bt_sk(sk)->parent->sk_ack_backlog--;
170 bt_sk(sk)->parent = NULL;
173 EXPORT_SYMBOL(bt_accept_unlink);
175 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
177 struct list_head *p, *n;
180 BT_DBG("parent %p", parent);
182 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
183 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
187 /* FIXME: Is this check still needed */
188 if (sk->sk_state == BT_CLOSED) {
190 bt_accept_unlink(sk);
194 if (sk->sk_state == BT_CONNECTED || !newsock ||
195 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
196 bt_accept_unlink(sk);
198 sock_graft(sk, newsock);
209 EXPORT_SYMBOL(bt_accept_dequeue);
211 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
212 struct msghdr *msg, size_t len, int flags)
214 int noblock = flags & MSG_DONTWAIT;
215 struct sock *sk = sock->sk;
220 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
222 if (flags & (MSG_OOB))
225 skb = skb_recv_datagram(sk, flags, noblock, &err);
227 if (sk->sk_shutdown & RCV_SHUTDOWN)
235 msg->msg_flags |= MSG_TRUNC;
239 skb_reset_transport_header(skb);
240 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
242 sock_recv_ts_and_drops(msg, sk, skb);
244 if (bt_sk(sk)->skb_msg_name)
245 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
249 skb_free_datagram(sk, skb);
251 return err ? : copied;
253 EXPORT_SYMBOL(bt_sock_recvmsg);
255 static long bt_sock_data_wait(struct sock *sk, long timeo)
257 DECLARE_WAITQUEUE(wait, current);
259 add_wait_queue(sk_sleep(sk), &wait);
261 set_current_state(TASK_INTERRUPTIBLE);
263 if (!skb_queue_empty(&sk->sk_receive_queue))
266 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
269 if (signal_pending(current) || !timeo)
272 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
274 timeo = schedule_timeout(timeo);
276 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
279 __set_current_state(TASK_RUNNING);
280 remove_wait_queue(sk_sleep(sk), &wait);
284 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
285 struct msghdr *msg, size_t size, int flags)
287 struct sock *sk = sock->sk;
289 size_t target, copied = 0;
295 BT_DBG("sk %p size %zu", sk, size);
299 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
300 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
306 skb = skb_dequeue(&sk->sk_receive_queue);
308 if (copied >= target)
311 err = sock_error(sk);
314 if (sk->sk_shutdown & RCV_SHUTDOWN)
321 timeo = bt_sock_data_wait(sk, timeo);
323 if (signal_pending(current)) {
324 err = sock_intr_errno(timeo);
330 chunk = min_t(unsigned int, skb->len, size);
331 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
332 skb_queue_head(&sk->sk_receive_queue, skb);
340 sock_recv_ts_and_drops(msg, sk, skb);
342 if (!(flags & MSG_PEEK)) {
343 int skb_len = skb_headlen(skb);
345 if (chunk <= skb_len) {
346 __skb_pull(skb, chunk);
348 struct sk_buff *frag;
350 __skb_pull(skb, skb_len);
353 skb_walk_frags(skb, frag) {
354 if (chunk <= frag->len) {
355 /* Pulling partial data */
357 skb->data_len -= chunk;
358 __skb_pull(frag, chunk);
360 } else if (frag->len) {
361 /* Pulling all frag data */
363 skb->len -= frag->len;
364 skb->data_len -= frag->len;
365 __skb_pull(frag, frag->len);
371 skb_queue_head(&sk->sk_receive_queue, skb);
377 /* put message back and return */
378 skb_queue_head(&sk->sk_receive_queue, skb);
385 return copied ? : err;
387 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
389 static inline unsigned int bt_accept_poll(struct sock *parent)
391 struct list_head *p, *n;
394 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
395 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
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;
405 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
408 struct sock *sk = sock->sk;
409 unsigned int mask = 0;
411 BT_DBG("sock %p, sk %p", sock, sk);
413 poll_wait(file, sk_sleep(sk), wait);
415 if (sk->sk_state == BT_LISTEN)
416 return bt_accept_poll(sk);
418 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
420 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
422 if (sk->sk_shutdown & RCV_SHUTDOWN)
423 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
425 if (sk->sk_shutdown == SHUTDOWN_MASK)
428 if (!skb_queue_empty(&sk->sk_receive_queue))
429 mask |= POLLIN | POLLRDNORM;
431 if (sk->sk_state == BT_CLOSED)
434 if (sk->sk_state == BT_CONNECT ||
435 sk->sk_state == BT_CONNECT2 ||
436 sk->sk_state == BT_CONFIG)
439 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
440 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
442 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
446 EXPORT_SYMBOL(bt_sock_poll);
448 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
450 struct sock *sk = sock->sk;
455 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
459 if (sk->sk_state == BT_LISTEN)
462 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
465 err = put_user(amount, (int __user *) arg);
469 if (sk->sk_state == BT_LISTEN)
473 skb = skb_peek(&sk->sk_receive_queue);
474 amount = skb ? skb->len : 0;
476 err = put_user(amount, (int __user *) arg);
480 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
484 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
494 EXPORT_SYMBOL(bt_sock_ioctl);
496 /* This function expects the sk lock to be held when called */
497 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
499 DECLARE_WAITQUEUE(wait, current);
504 add_wait_queue(sk_sleep(sk), &wait);
505 set_current_state(TASK_INTERRUPTIBLE);
506 while (sk->sk_state != state) {
512 if (signal_pending(current)) {
513 err = sock_intr_errno(timeo);
518 timeo = schedule_timeout(timeo);
520 set_current_state(TASK_INTERRUPTIBLE);
522 err = sock_error(sk);
526 __set_current_state(TASK_RUNNING);
527 remove_wait_queue(sk_sleep(sk), &wait);
530 EXPORT_SYMBOL(bt_sock_wait_state);
532 /* This function expects the sk lock to be held when called */
533 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
535 DECLARE_WAITQUEUE(wait, current);
541 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
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)) {
551 if (signal_pending(current)) {
552 err = sock_intr_errno(timeo);
557 timeo = schedule_timeout(timeo);
559 set_current_state(TASK_INTERRUPTIBLE);
561 err = sock_error(sk);
565 __set_current_state(TASK_RUNNING);
566 remove_wait_queue(sk_sleep(sk), &wait);
570 EXPORT_SYMBOL(bt_sock_wait_ready);
572 #ifdef CONFIG_PROC_FS
573 struct bt_seq_state {
574 struct bt_sock_list *l;
577 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
578 __acquires(seq->private->l->lock)
580 struct bt_seq_state *s = seq->private;
581 struct bt_sock_list *l = s->l;
584 return seq_hlist_start_head(&l->head, *pos);
587 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
589 struct bt_seq_state *s = seq->private;
590 struct bt_sock_list *l = s->l;
592 return seq_hlist_next(v, &l->head, pos);
595 static void bt_seq_stop(struct seq_file *seq, void *v)
596 __releases(seq->private->l->lock)
598 struct bt_seq_state *s = seq->private;
599 struct bt_sock_list *l = s->l;
601 read_unlock(&l->lock);
604 static int bt_seq_show(struct seq_file *seq, void *v)
606 struct bt_seq_state *s = seq->private;
607 struct bt_sock_list *l = s->l;
609 if (v == SEQ_START_TOKEN) {
610 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
612 if (l->custom_seq_show) {
614 l->custom_seq_show(seq, v);
619 struct sock *sk = sk_entry(v);
620 struct bt_sock *bt = bt_sk(sk);
623 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
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)),
630 bt->parent? sock_i_ino(bt->parent): 0LU);
632 if (l->custom_seq_show) {
634 l->custom_seq_show(seq, v);
642 static struct seq_operations bt_seq_ops = {
643 .start = bt_seq_start,
649 static int bt_seq_open(struct inode *inode, struct file *file)
651 struct bt_sock_list *sk_list;
652 struct bt_seq_state *s;
654 sk_list = PDE_DATA(inode);
655 s = __seq_open_private(file, &bt_seq_ops,
656 sizeof(struct bt_seq_state));
664 static const struct file_operations bt_fops = {
668 .release = seq_release_private
671 int bt_procfs_init(struct net *net, const char *name,
672 struct bt_sock_list* sk_list,
673 int (* seq_show)(struct seq_file *, void *))
675 sk_list->custom_seq_show = seq_show;
677 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
682 void bt_procfs_cleanup(struct net *net, const char *name)
684 remove_proc_entry(name, net->proc_net);
687 int bt_procfs_init(struct net *net, const char *name,
688 struct bt_sock_list* sk_list,
689 int (* seq_show)(struct seq_file *, void *))
694 void bt_procfs_cleanup(struct net *net, const char *name)
698 EXPORT_SYMBOL(bt_procfs_init);
699 EXPORT_SYMBOL(bt_procfs_cleanup);
701 static struct net_proto_family bt_sock_family_ops = {
702 .owner = THIS_MODULE,
703 .family = PF_BLUETOOTH,
704 .create = bt_sock_create,
707 struct dentry *bt_debugfs;
708 EXPORT_SYMBOL_GPL(bt_debugfs);
710 static int __init bt_init(void)
714 BT_INFO("Core ver %s", VERSION);
716 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
718 err = bt_sysfs_init();
722 err = sock_register(&bt_sock_family_ops);
728 BT_INFO("HCI device and connection manager initialized");
730 err = hci_sock_init();
750 sock_unregister(PF_BLUETOOTH);
756 static void __exit bt_exit(void)
764 sock_unregister(PF_BLUETOOTH);
768 debugfs_remove_recursive(bt_debugfs);
771 subsys_initcall(bt_init);
772 module_exit(bt_exit);
774 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
775 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
776 MODULE_VERSION(VERSION);
777 MODULE_LICENSE("GPL");
778 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);