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.17"
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 skb = skb_recv_datagram(sk, flags, noblock, &err);
226 if (sk->sk_shutdown & RCV_SHUTDOWN) {
227 msg->msg_namelen = 0;
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,
248 msg->msg_namelen = 0;
251 skb_free_datagram(sk, skb);
253 return err ? : copied;
255 EXPORT_SYMBOL(bt_sock_recvmsg);
257 static long bt_sock_data_wait(struct sock *sk, long timeo)
259 DECLARE_WAITQUEUE(wait, current);
261 add_wait_queue(sk_sleep(sk), &wait);
263 set_current_state(TASK_INTERRUPTIBLE);
265 if (!skb_queue_empty(&sk->sk_receive_queue))
268 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
271 if (signal_pending(current) || !timeo)
274 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
276 timeo = schedule_timeout(timeo);
278 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
281 __set_current_state(TASK_RUNNING);
282 remove_wait_queue(sk_sleep(sk), &wait);
286 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
287 struct msghdr *msg, size_t size, int flags)
289 struct sock *sk = sock->sk;
291 size_t target, copied = 0;
297 msg->msg_namelen = 0;
299 BT_DBG("sk %p size %zu", sk, size);
303 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
304 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
310 skb = skb_dequeue(&sk->sk_receive_queue);
312 if (copied >= target)
315 err = sock_error(sk);
318 if (sk->sk_shutdown & RCV_SHUTDOWN)
325 timeo = bt_sock_data_wait(sk, timeo);
327 if (signal_pending(current)) {
328 err = sock_intr_errno(timeo);
334 chunk = min_t(unsigned int, skb->len, size);
335 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
336 skb_queue_head(&sk->sk_receive_queue, skb);
344 sock_recv_ts_and_drops(msg, sk, skb);
346 if (!(flags & MSG_PEEK)) {
347 int skb_len = skb_headlen(skb);
349 if (chunk <= skb_len) {
350 __skb_pull(skb, chunk);
352 struct sk_buff *frag;
354 __skb_pull(skb, skb_len);
357 skb_walk_frags(skb, frag) {
358 if (chunk <= frag->len) {
359 /* Pulling partial data */
361 skb->data_len -= chunk;
362 __skb_pull(frag, chunk);
364 } else if (frag->len) {
365 /* Pulling all frag data */
367 skb->len -= frag->len;
368 skb->data_len -= frag->len;
369 __skb_pull(frag, frag->len);
375 skb_queue_head(&sk->sk_receive_queue, skb);
381 /* put message back and return */
382 skb_queue_head(&sk->sk_receive_queue, skb);
389 return copied ? : err;
391 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
393 static inline unsigned int bt_accept_poll(struct sock *parent)
395 struct list_head *p, *n;
398 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
399 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
400 if (sk->sk_state == BT_CONNECTED ||
401 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
402 sk->sk_state == BT_CONNECT2))
403 return POLLIN | POLLRDNORM;
409 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
412 struct sock *sk = sock->sk;
413 unsigned int mask = 0;
415 BT_DBG("sock %p, sk %p", sock, sk);
417 poll_wait(file, sk_sleep(sk), wait);
419 if (sk->sk_state == BT_LISTEN)
420 return bt_accept_poll(sk);
422 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
424 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
426 if (sk->sk_shutdown & RCV_SHUTDOWN)
427 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
429 if (sk->sk_shutdown == SHUTDOWN_MASK)
432 if (!skb_queue_empty(&sk->sk_receive_queue))
433 mask |= POLLIN | POLLRDNORM;
435 if (sk->sk_state == BT_CLOSED)
438 if (sk->sk_state == BT_CONNECT ||
439 sk->sk_state == BT_CONNECT2 ||
440 sk->sk_state == BT_CONFIG)
443 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
444 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
446 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
450 EXPORT_SYMBOL(bt_sock_poll);
452 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
454 struct sock *sk = sock->sk;
459 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
463 if (sk->sk_state == BT_LISTEN)
466 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
469 err = put_user(amount, (int __user *) arg);
473 if (sk->sk_state == BT_LISTEN)
477 skb = skb_peek(&sk->sk_receive_queue);
478 amount = skb ? skb->len : 0;
480 err = put_user(amount, (int __user *) arg);
484 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
488 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
498 EXPORT_SYMBOL(bt_sock_ioctl);
500 /* This function expects the sk lock to be held when called */
501 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
503 DECLARE_WAITQUEUE(wait, current);
508 add_wait_queue(sk_sleep(sk), &wait);
509 set_current_state(TASK_INTERRUPTIBLE);
510 while (sk->sk_state != state) {
516 if (signal_pending(current)) {
517 err = sock_intr_errno(timeo);
522 timeo = schedule_timeout(timeo);
524 set_current_state(TASK_INTERRUPTIBLE);
526 err = sock_error(sk);
530 __set_current_state(TASK_RUNNING);
531 remove_wait_queue(sk_sleep(sk), &wait);
534 EXPORT_SYMBOL(bt_sock_wait_state);
536 /* This function expects the sk lock to be held when called */
537 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
539 DECLARE_WAITQUEUE(wait, current);
545 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
547 add_wait_queue(sk_sleep(sk), &wait);
548 set_current_state(TASK_INTERRUPTIBLE);
549 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
555 if (signal_pending(current)) {
556 err = sock_intr_errno(timeo);
561 timeo = schedule_timeout(timeo);
563 set_current_state(TASK_INTERRUPTIBLE);
565 err = sock_error(sk);
569 __set_current_state(TASK_RUNNING);
570 remove_wait_queue(sk_sleep(sk), &wait);
574 EXPORT_SYMBOL(bt_sock_wait_ready);
576 #ifdef CONFIG_PROC_FS
577 struct bt_seq_state {
578 struct bt_sock_list *l;
581 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
582 __acquires(seq->private->l->lock)
584 struct bt_seq_state *s = seq->private;
585 struct bt_sock_list *l = s->l;
588 return seq_hlist_start_head(&l->head, *pos);
591 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
593 struct bt_seq_state *s = seq->private;
594 struct bt_sock_list *l = s->l;
596 return seq_hlist_next(v, &l->head, pos);
599 static void bt_seq_stop(struct seq_file *seq, void *v)
600 __releases(seq->private->l->lock)
602 struct bt_seq_state *s = seq->private;
603 struct bt_sock_list *l = s->l;
605 read_unlock(&l->lock);
608 static int bt_seq_show(struct seq_file *seq, void *v)
610 struct bt_seq_state *s = seq->private;
611 struct bt_sock_list *l = s->l;
613 if (v == SEQ_START_TOKEN) {
614 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
616 if (l->custom_seq_show) {
618 l->custom_seq_show(seq, v);
623 struct sock *sk = sk_entry(v);
624 struct bt_sock *bt = bt_sk(sk);
627 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
629 atomic_read(&sk->sk_refcnt),
630 sk_rmem_alloc_get(sk),
631 sk_wmem_alloc_get(sk),
632 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
634 bt->parent? sock_i_ino(bt->parent): 0LU);
636 if (l->custom_seq_show) {
638 l->custom_seq_show(seq, v);
646 static struct seq_operations bt_seq_ops = {
647 .start = bt_seq_start,
653 static int bt_seq_open(struct inode *inode, struct file *file)
655 struct bt_sock_list *sk_list;
656 struct bt_seq_state *s;
658 sk_list = PDE_DATA(inode);
659 s = __seq_open_private(file, &bt_seq_ops,
660 sizeof(struct bt_seq_state));
668 static const struct file_operations bt_fops = {
672 .release = seq_release_private
675 int bt_procfs_init(struct net *net, const char *name,
676 struct bt_sock_list* sk_list,
677 int (* seq_show)(struct seq_file *, void *))
679 sk_list->custom_seq_show = seq_show;
681 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
686 void bt_procfs_cleanup(struct net *net, const char *name)
688 remove_proc_entry(name, net->proc_net);
691 int bt_procfs_init(struct net *net, const char *name,
692 struct bt_sock_list* sk_list,
693 int (* seq_show)(struct seq_file *, void *))
698 void bt_procfs_cleanup(struct net *net, const char *name)
702 EXPORT_SYMBOL(bt_procfs_init);
703 EXPORT_SYMBOL(bt_procfs_cleanup);
705 static struct net_proto_family bt_sock_family_ops = {
706 .owner = THIS_MODULE,
707 .family = PF_BLUETOOTH,
708 .create = bt_sock_create,
711 static int __init bt_init(void)
715 BT_INFO("Core ver %s", VERSION);
717 err = bt_sysfs_init();
721 err = sock_register(&bt_sock_family_ops);
727 BT_INFO("HCI device and connection manager initialized");
729 err = hci_sock_init();
749 sock_unregister(PF_BLUETOOTH);
755 static void __exit bt_exit(void)
764 sock_unregister(PF_BLUETOOTH);
769 subsys_initcall(bt_init);
770 module_exit(bt_exit);
772 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
773 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
774 MODULE_VERSION(VERSION);
775 MODULE_LICENSE("GPL");
776 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);