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 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
495 DECLARE_WAITQUEUE(wait, current);
500 add_wait_queue(sk_sleep(sk), &wait);
501 set_current_state(TASK_INTERRUPTIBLE);
502 while (sk->sk_state != state) {
508 if (signal_pending(current)) {
509 err = sock_intr_errno(timeo);
514 timeo = schedule_timeout(timeo);
516 set_current_state(TASK_INTERRUPTIBLE);
518 err = sock_error(sk);
522 __set_current_state(TASK_RUNNING);
523 remove_wait_queue(sk_sleep(sk), &wait);
526 EXPORT_SYMBOL(bt_sock_wait_state);
528 /* This function expects the sk lock to be held when called */
529 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
531 DECLARE_WAITQUEUE(wait, current);
537 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
539 add_wait_queue(sk_sleep(sk), &wait);
540 set_current_state(TASK_INTERRUPTIBLE);
541 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
547 if (signal_pending(current)) {
548 err = sock_intr_errno(timeo);
553 timeo = schedule_timeout(timeo);
555 set_current_state(TASK_INTERRUPTIBLE);
557 err = sock_error(sk);
561 __set_current_state(TASK_RUNNING);
562 remove_wait_queue(sk_sleep(sk), &wait);
566 EXPORT_SYMBOL(bt_sock_wait_ready);
568 #ifdef CONFIG_PROC_FS
569 struct bt_seq_state {
570 struct bt_sock_list *l;
573 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
574 __acquires(seq->private->l->lock)
576 struct bt_seq_state *s = seq->private;
577 struct bt_sock_list *l = s->l;
580 return seq_hlist_start_head(&l->head, *pos);
583 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
585 struct bt_seq_state *s = seq->private;
586 struct bt_sock_list *l = s->l;
588 return seq_hlist_next(v, &l->head, pos);
591 static void bt_seq_stop(struct seq_file *seq, void *v)
592 __releases(seq->private->l->lock)
594 struct bt_seq_state *s = seq->private;
595 struct bt_sock_list *l = s->l;
597 read_unlock(&l->lock);
600 static int bt_seq_show(struct seq_file *seq, void *v)
602 struct bt_seq_state *s = seq->private;
603 struct bt_sock_list *l = s->l;
605 if (v == SEQ_START_TOKEN) {
606 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Src Dst Parent");
608 if (l->custom_seq_show) {
610 l->custom_seq_show(seq, v);
615 struct sock *sk = sk_entry(v);
616 struct bt_sock *bt = bt_sk(sk);
619 "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
621 atomic_read(&sk->sk_refcnt),
622 sk_rmem_alloc_get(sk),
623 sk_wmem_alloc_get(sk),
624 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
628 bt->parent? sock_i_ino(bt->parent): 0LU);
630 if (l->custom_seq_show) {
632 l->custom_seq_show(seq, v);
640 static struct seq_operations bt_seq_ops = {
641 .start = bt_seq_start,
647 static int bt_seq_open(struct inode *inode, struct file *file)
649 struct bt_sock_list *sk_list;
650 struct bt_seq_state *s;
652 sk_list = PDE_DATA(inode);
653 s = __seq_open_private(file, &bt_seq_ops,
654 sizeof(struct bt_seq_state));
662 static const struct file_operations bt_fops = {
666 .release = seq_release_private
669 int bt_procfs_init(struct net *net, const char *name,
670 struct bt_sock_list* sk_list,
671 int (* seq_show)(struct seq_file *, void *))
673 sk_list->custom_seq_show = seq_show;
675 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
680 void bt_procfs_cleanup(struct net *net, const char *name)
682 remove_proc_entry(name, net->proc_net);
685 int bt_procfs_init(struct net *net, const char *name,
686 struct bt_sock_list* sk_list,
687 int (* seq_show)(struct seq_file *, void *))
692 void bt_procfs_cleanup(struct net *net, const char *name)
696 EXPORT_SYMBOL(bt_procfs_init);
697 EXPORT_SYMBOL(bt_procfs_cleanup);
699 static struct net_proto_family bt_sock_family_ops = {
700 .owner = THIS_MODULE,
701 .family = PF_BLUETOOTH,
702 .create = bt_sock_create,
705 static int __init bt_init(void)
709 BT_INFO("Core ver %s", VERSION);
711 err = bt_sysfs_init();
715 err = sock_register(&bt_sock_family_ops);
721 BT_INFO("HCI device and connection manager initialized");
723 err = hci_sock_init();
743 sock_unregister(PF_BLUETOOTH);
749 static void __exit bt_exit(void)
758 sock_unregister(PF_BLUETOOTH);
763 subsys_initcall(bt_init);
764 module_exit(bt_exit);
766 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
767 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
768 MODULE_VERSION(VERSION);
769 MODULE_LICENSE("GPL");
770 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);