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 skb = skb_recv_datagram(sk, flags, noblock, &err);
226 if (sk->sk_shutdown & RCV_SHUTDOWN)
231 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 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))
418 if (sk->sk_shutdown & RCV_SHUTDOWN)
419 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
421 if (sk->sk_shutdown == SHUTDOWN_MASK)
424 if (!skb_queue_empty(&sk->sk_receive_queue))
425 mask |= POLLIN | POLLRDNORM;
427 if (sk->sk_state == BT_CLOSED)
430 if (sk->sk_state == BT_CONNECT ||
431 sk->sk_state == BT_CONNECT2 ||
432 sk->sk_state == BT_CONFIG)
435 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
436 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
438 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
442 EXPORT_SYMBOL(bt_sock_poll);
444 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
446 struct sock *sk = sock->sk;
451 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
455 if (sk->sk_state == BT_LISTEN)
458 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
461 err = put_user(amount, (int __user *) arg);
465 if (sk->sk_state == BT_LISTEN)
469 skb = skb_peek(&sk->sk_receive_queue);
470 amount = skb ? skb->len : 0;
472 err = put_user(amount, (int __user *) arg);
476 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
480 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
490 EXPORT_SYMBOL(bt_sock_ioctl);
492 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
494 DECLARE_WAITQUEUE(wait, current);
499 add_wait_queue(sk_sleep(sk), &wait);
500 set_current_state(TASK_INTERRUPTIBLE);
501 while (sk->sk_state != state) {
507 if (signal_pending(current)) {
508 err = sock_intr_errno(timeo);
513 timeo = schedule_timeout(timeo);
515 set_current_state(TASK_INTERRUPTIBLE);
517 err = sock_error(sk);
521 __set_current_state(TASK_RUNNING);
522 remove_wait_queue(sk_sleep(sk), &wait);
525 EXPORT_SYMBOL(bt_sock_wait_state);
527 #ifdef CONFIG_PROC_FS
528 struct bt_seq_state {
529 struct bt_sock_list *l;
532 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
533 __acquires(seq->private->l->lock)
535 struct bt_seq_state *s = seq->private;
536 struct bt_sock_list *l = s->l;
539 return seq_hlist_start_head(&l->head, *pos);
542 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
544 struct bt_seq_state *s = seq->private;
545 struct bt_sock_list *l = s->l;
547 return seq_hlist_next(v, &l->head, pos);
550 static void bt_seq_stop(struct seq_file *seq, void *v)
551 __releases(seq->private->l->lock)
553 struct bt_seq_state *s = seq->private;
554 struct bt_sock_list *l = s->l;
556 read_unlock(&l->lock);
559 static int bt_seq_show(struct seq_file *seq, void *v)
561 struct bt_seq_state *s = seq->private;
562 struct bt_sock_list *l = s->l;
564 if (v == SEQ_START_TOKEN) {
565 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Src Dst Parent");
567 if (l->custom_seq_show) {
569 l->custom_seq_show(seq, v);
574 struct sock *sk = sk_entry(v);
575 struct bt_sock *bt = bt_sk(sk);
578 "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
580 atomic_read(&sk->sk_refcnt),
581 sk_rmem_alloc_get(sk),
582 sk_wmem_alloc_get(sk),
583 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
587 bt->parent? sock_i_ino(bt->parent): 0LU);
589 if (l->custom_seq_show) {
591 l->custom_seq_show(seq, v);
599 static struct seq_operations bt_seq_ops = {
600 .start = bt_seq_start,
606 static int bt_seq_open(struct inode *inode, struct file *file)
608 struct bt_sock_list *sk_list;
609 struct bt_seq_state *s;
611 sk_list = PDE(inode)->data;
612 s = __seq_open_private(file, &bt_seq_ops,
613 sizeof(struct bt_seq_state));
621 int bt_procfs_init(struct module* module, struct net *net, const char *name,
622 struct bt_sock_list* sk_list,
623 int (* seq_show)(struct seq_file *, void *))
625 struct proc_dir_entry * pde;
627 sk_list->custom_seq_show = seq_show;
629 sk_list->fops.owner = module;
630 sk_list->fops.open = bt_seq_open;
631 sk_list->fops.read = seq_read;
632 sk_list->fops.llseek = seq_lseek;
633 sk_list->fops.release = seq_release_private;
635 pde = proc_create(name, 0, net->proc_net, &sk_list->fops);
644 void bt_procfs_cleanup(struct net *net, const char *name)
646 remove_proc_entry(name, net->proc_net);
649 int bt_procfs_init(struct module* module, struct net *net, const char *name,
650 struct bt_sock_list* sk_list,
651 int (* seq_show)(struct seq_file *, void *))
656 void bt_procfs_cleanup(struct net *net, const char *name)
660 EXPORT_SYMBOL(bt_procfs_init);
661 EXPORT_SYMBOL(bt_procfs_cleanup);
663 static struct net_proto_family bt_sock_family_ops = {
664 .owner = THIS_MODULE,
665 .family = PF_BLUETOOTH,
666 .create = bt_sock_create,
669 static int __init bt_init(void)
673 BT_INFO("Core ver %s", VERSION);
675 err = bt_sysfs_init();
679 err = sock_register(&bt_sock_family_ops);
685 BT_INFO("HCI device and connection manager initialized");
687 err = hci_sock_init();
707 sock_unregister(PF_BLUETOOTH);
713 static void __exit bt_exit(void)
722 sock_unregister(PF_BLUETOOTH);
727 subsys_initcall(bt_init);
728 module_exit(bt_exit);
730 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
731 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
732 MODULE_VERSION(VERSION);
733 MODULE_LICENSE("GPL");
734 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);