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 <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",
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",
64 void bt_sock_reclassify_lock(struct sock *sk, int proto)
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]);
73 EXPORT_SYMBOL(bt_sock_reclassify_lock);
75 int bt_sock_register(int proto, const struct net_proto_family *ops)
79 if (proto < 0 || proto >= BT_MAX_PROTO)
82 write_lock(&bt_proto_lock);
87 bt_proto[proto] = ops;
89 write_unlock(&bt_proto_lock);
93 EXPORT_SYMBOL(bt_sock_register);
95 void bt_sock_unregister(int proto)
97 if (proto < 0 || proto >= BT_MAX_PROTO)
100 write_lock(&bt_proto_lock);
101 bt_proto[proto] = NULL;
102 write_unlock(&bt_proto_lock);
104 EXPORT_SYMBOL(bt_sock_unregister);
106 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
111 if (net != &init_net)
112 return -EAFNOSUPPORT;
114 if (proto < 0 || proto >= BT_MAX_PROTO)
117 if (!bt_proto[proto])
118 request_module("bt-proto-%d", proto);
120 err = -EPROTONOSUPPORT;
122 read_lock(&bt_proto_lock);
124 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
125 err = bt_proto[proto]->create(net, sock, proto, kern);
127 bt_sock_reclassify_lock(sock->sk, proto);
128 module_put(bt_proto[proto]->owner);
131 read_unlock(&bt_proto_lock);
136 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
138 write_lock(&l->lock);
139 sk_add_node(sk, &l->head);
140 write_unlock(&l->lock);
142 EXPORT_SYMBOL(bt_sock_link);
144 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
146 write_lock(&l->lock);
147 sk_del_node_init(sk);
148 write_unlock(&l->lock);
150 EXPORT_SYMBOL(bt_sock_unlink);
152 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
154 BT_DBG("parent %p, sk %p", parent, sk);
157 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
158 bt_sk(sk)->parent = parent;
159 parent->sk_ack_backlog++;
161 EXPORT_SYMBOL(bt_accept_enqueue);
163 void bt_accept_unlink(struct sock *sk)
165 BT_DBG("sk %p state %d", sk, sk->sk_state);
167 list_del_init(&bt_sk(sk)->accept_q);
168 bt_sk(sk)->parent->sk_ack_backlog--;
169 bt_sk(sk)->parent = NULL;
172 EXPORT_SYMBOL(bt_accept_unlink);
174 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
176 struct list_head *p, *n;
179 BT_DBG("parent %p", parent);
181 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
182 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
186 /* FIXME: Is this check still needed */
187 if (sk->sk_state == BT_CLOSED) {
189 bt_accept_unlink(sk);
193 if (sk->sk_state == BT_CONNECTED || !newsock ||
194 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
195 bt_accept_unlink(sk);
197 sock_graft(sk, newsock);
208 EXPORT_SYMBOL(bt_accept_dequeue);
210 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
211 struct msghdr *msg, size_t len, int flags)
213 int noblock = flags & MSG_DONTWAIT;
214 struct sock *sk = sock->sk;
219 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
221 if (flags & (MSG_OOB))
224 msg->msg_namelen = 0;
226 skb = skb_recv_datagram(sk, flags, noblock, &err);
228 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 skb_free_datagram(sk, skb);
246 return err ? : copied;
248 EXPORT_SYMBOL(bt_sock_recvmsg);
250 static long bt_sock_data_wait(struct sock *sk, long timeo)
252 DECLARE_WAITQUEUE(wait, current);
254 add_wait_queue(sk_sleep(sk), &wait);
256 set_current_state(TASK_INTERRUPTIBLE);
258 if (!skb_queue_empty(&sk->sk_receive_queue))
261 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
264 if (signal_pending(current) || !timeo)
267 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
269 timeo = schedule_timeout(timeo);
271 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
274 __set_current_state(TASK_RUNNING);
275 remove_wait_queue(sk_sleep(sk), &wait);
279 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
280 struct msghdr *msg, size_t size, int flags)
282 struct sock *sk = sock->sk;
284 size_t target, copied = 0;
290 msg->msg_namelen = 0;
292 BT_DBG("sk %p size %zu", sk, size);
296 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
297 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
303 skb = skb_dequeue(&sk->sk_receive_queue);
305 if (copied >= target)
308 err = sock_error(sk);
311 if (sk->sk_shutdown & RCV_SHUTDOWN)
318 timeo = bt_sock_data_wait(sk, timeo);
320 if (signal_pending(current)) {
321 err = sock_intr_errno(timeo);
327 chunk = min_t(unsigned int, skb->len, size);
328 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
329 skb_queue_head(&sk->sk_receive_queue, skb);
337 sock_recv_ts_and_drops(msg, sk, skb);
339 if (!(flags & MSG_PEEK)) {
340 int skb_len = skb_headlen(skb);
342 if (chunk <= skb_len) {
343 __skb_pull(skb, chunk);
345 struct sk_buff *frag;
347 __skb_pull(skb, skb_len);
350 skb_walk_frags(skb, frag) {
351 if (chunk <= frag->len) {
352 /* Pulling partial data */
354 skb->data_len -= chunk;
355 __skb_pull(frag, chunk);
357 } else if (frag->len) {
358 /* Pulling all frag data */
360 skb->len -= frag->len;
361 skb->data_len -= frag->len;
362 __skb_pull(frag, frag->len);
368 skb_queue_head(&sk->sk_receive_queue, skb);
374 /* put message back and return */
375 skb_queue_head(&sk->sk_receive_queue, skb);
382 return copied ? : err;
384 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
386 static inline unsigned int bt_accept_poll(struct sock *parent)
388 struct list_head *p, *n;
391 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
392 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
393 if (sk->sk_state == BT_CONNECTED ||
394 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
395 sk->sk_state == BT_CONNECT2))
396 return POLLIN | POLLRDNORM;
402 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
405 struct sock *sk = sock->sk;
406 unsigned int mask = 0;
408 BT_DBG("sock %p, sk %p", sock, sk);
410 poll_wait(file, sk_sleep(sk), wait);
412 if (sk->sk_state == BT_LISTEN)
413 return bt_accept_poll(sk);
415 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
417 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
419 if (sk->sk_shutdown & RCV_SHUTDOWN)
420 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
422 if (sk->sk_shutdown == SHUTDOWN_MASK)
425 if (!skb_queue_empty(&sk->sk_receive_queue))
426 mask |= POLLIN | POLLRDNORM;
428 if (sk->sk_state == BT_CLOSED)
431 if (sk->sk_state == BT_CONNECT ||
432 sk->sk_state == BT_CONNECT2 ||
433 sk->sk_state == BT_CONFIG)
436 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
437 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
439 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
443 EXPORT_SYMBOL(bt_sock_poll);
445 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
447 struct sock *sk = sock->sk;
452 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
456 if (sk->sk_state == BT_LISTEN)
459 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
462 err = put_user(amount, (int __user *) arg);
466 if (sk->sk_state == BT_LISTEN)
470 skb = skb_peek(&sk->sk_receive_queue);
471 amount = skb ? skb->len : 0;
473 err = put_user(amount, (int __user *) arg);
477 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
481 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
491 EXPORT_SYMBOL(bt_sock_ioctl);
493 /* This function expects the sk lock to be held when called */
494 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
496 DECLARE_WAITQUEUE(wait, current);
501 add_wait_queue(sk_sleep(sk), &wait);
502 set_current_state(TASK_INTERRUPTIBLE);
503 while (sk->sk_state != state) {
509 if (signal_pending(current)) {
510 err = sock_intr_errno(timeo);
515 timeo = schedule_timeout(timeo);
517 set_current_state(TASK_INTERRUPTIBLE);
519 err = sock_error(sk);
523 __set_current_state(TASK_RUNNING);
524 remove_wait_queue(sk_sleep(sk), &wait);
527 EXPORT_SYMBOL(bt_sock_wait_state);
529 /* This function expects the sk lock to be held when called */
530 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
532 DECLARE_WAITQUEUE(wait, current);
538 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
540 add_wait_queue(sk_sleep(sk), &wait);
541 set_current_state(TASK_INTERRUPTIBLE);
542 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
548 if (signal_pending(current)) {
549 err = sock_intr_errno(timeo);
554 timeo = schedule_timeout(timeo);
556 set_current_state(TASK_INTERRUPTIBLE);
558 err = sock_error(sk);
562 __set_current_state(TASK_RUNNING);
563 remove_wait_queue(sk_sleep(sk), &wait);
567 EXPORT_SYMBOL(bt_sock_wait_ready);
569 #ifdef CONFIG_PROC_FS
570 struct bt_seq_state {
571 struct bt_sock_list *l;
574 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
575 __acquires(seq->private->l->lock)
577 struct bt_seq_state *s = seq->private;
578 struct bt_sock_list *l = s->l;
581 return seq_hlist_start_head(&l->head, *pos);
584 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
586 struct bt_seq_state *s = seq->private;
587 struct bt_sock_list *l = s->l;
589 return seq_hlist_next(v, &l->head, pos);
592 static void bt_seq_stop(struct seq_file *seq, void *v)
593 __releases(seq->private->l->lock)
595 struct bt_seq_state *s = seq->private;
596 struct bt_sock_list *l = s->l;
598 read_unlock(&l->lock);
601 static int bt_seq_show(struct seq_file *seq, void *v)
603 struct bt_seq_state *s = seq->private;
604 struct bt_sock_list *l = s->l;
606 if (v == SEQ_START_TOKEN) {
607 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Src Dst Parent");
609 if (l->custom_seq_show) {
611 l->custom_seq_show(seq, v);
616 struct sock *sk = sk_entry(v);
617 struct bt_sock *bt = bt_sk(sk);
620 "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
622 atomic_read(&sk->sk_refcnt),
623 sk_rmem_alloc_get(sk),
624 sk_wmem_alloc_get(sk),
625 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
629 bt->parent? sock_i_ino(bt->parent): 0LU);
631 if (l->custom_seq_show) {
633 l->custom_seq_show(seq, v);
641 static struct seq_operations bt_seq_ops = {
642 .start = bt_seq_start,
648 static int bt_seq_open(struct inode *inode, struct file *file)
650 struct bt_sock_list *sk_list;
651 struct bt_seq_state *s;
653 sk_list = PDE_DATA(inode);
654 s = __seq_open_private(file, &bt_seq_ops,
655 sizeof(struct bt_seq_state));
663 static const struct file_operations bt_fops = {
667 .release = seq_release_private
670 int bt_procfs_init(struct net *net, const char *name,
671 struct bt_sock_list* sk_list,
672 int (* seq_show)(struct seq_file *, void *))
674 sk_list->custom_seq_show = seq_show;
676 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
681 void bt_procfs_cleanup(struct net *net, const char *name)
683 remove_proc_entry(name, net->proc_net);
686 int bt_procfs_init(struct net *net, const char *name,
687 struct bt_sock_list* sk_list,
688 int (* seq_show)(struct seq_file *, void *))
693 void bt_procfs_cleanup(struct net *net, const char *name)
697 EXPORT_SYMBOL(bt_procfs_init);
698 EXPORT_SYMBOL(bt_procfs_cleanup);
700 static struct net_proto_family bt_sock_family_ops = {
701 .owner = THIS_MODULE,
702 .family = PF_BLUETOOTH,
703 .create = bt_sock_create,
706 static int __init bt_init(void)
710 BT_INFO("Core ver %s", VERSION);
712 err = bt_sysfs_init();
716 err = sock_register(&bt_sock_family_ops);
722 BT_INFO("HCI device and connection manager initialized");
724 err = hci_sock_init();
744 sock_unregister(PF_BLUETOOTH);
750 static void __exit bt_exit(void)
759 sock_unregister(PF_BLUETOOTH);
764 subsys_initcall(bt_init);
765 module_exit(bt_exit);
767 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
768 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
769 MODULE_VERSION(VERSION);
770 MODULE_LICENSE("GPL");
771 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);