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>
29 #include <linux/types.h>
30 #include <linux/list.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/skbuff.h>
35 #include <linux/init.h>
36 #include <linux/poll.h>
38 #include <asm/ioctls.h>
39 #include <linux/kmod.h>
41 #include <net/bluetooth/bluetooth.h>
43 #ifdef CONFIG_ANDROID_PARANOID_NETWORK
44 #include <linux/android_aid.h>
47 #ifndef CONFIG_BT_SOCK_DEBUG
52 #define VERSION "2.16"
54 /* Bluetooth sockets */
55 #define BT_MAX_PROTO 8
56 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
57 static DEFINE_RWLOCK(bt_proto_lock);
59 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
60 static const char *const bt_key_strings[BT_MAX_PROTO] = {
61 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
62 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
63 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
64 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
65 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
66 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
67 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
68 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
71 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
72 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
73 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
74 "slock-AF_BLUETOOTH-BTPROTO_HCI",
75 "slock-AF_BLUETOOTH-BTPROTO_SCO",
76 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
77 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
78 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
79 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
80 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
83 void bt_sock_reclassify_lock(struct sock *sk, int proto)
86 BUG_ON(sock_owned_by_user(sk));
88 sock_lock_init_class_and_name(sk,
89 bt_slock_key_strings[proto], &bt_slock_key[proto],
90 bt_key_strings[proto], &bt_lock_key[proto]);
92 EXPORT_SYMBOL(bt_sock_reclassify_lock);
94 int bt_sock_register(int proto, const struct net_proto_family *ops)
98 if (proto < 0 || proto >= BT_MAX_PROTO)
101 write_lock(&bt_proto_lock);
106 bt_proto[proto] = ops;
108 write_unlock(&bt_proto_lock);
112 EXPORT_SYMBOL(bt_sock_register);
114 int bt_sock_unregister(int proto)
118 if (proto < 0 || proto >= BT_MAX_PROTO)
121 write_lock(&bt_proto_lock);
123 if (!bt_proto[proto])
126 bt_proto[proto] = NULL;
128 write_unlock(&bt_proto_lock);
132 EXPORT_SYMBOL(bt_sock_unregister);
134 #ifdef CONFIG_ANDROID_PARANOID_NETWORK
135 static inline int current_has_bt_admin(void)
137 return (!current_euid() || in_egroup_p(AID_NET_BT_ADMIN));
140 static inline int current_has_bt(void)
142 return (current_has_bt_admin() || in_egroup_p(AID_NET_BT));
145 static inline int current_has_bt_admin(void)
150 static inline int current_has_bt(void)
156 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
161 if (proto == BTPROTO_RFCOMM || proto == BTPROTO_SCO ||
162 proto == BTPROTO_L2CAP) {
163 if (!current_has_bt())
165 } else if (!current_has_bt_admin())
168 if (net != &init_net)
169 return -EAFNOSUPPORT;
171 if (proto < 0 || proto >= BT_MAX_PROTO)
174 if (!bt_proto[proto])
175 request_module("bt-proto-%d", proto);
177 err = -EPROTONOSUPPORT;
179 read_lock(&bt_proto_lock);
181 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
182 err = bt_proto[proto]->create(net, sock, proto, kern);
184 bt_sock_reclassify_lock(sock->sk, proto);
185 module_put(bt_proto[proto]->owner);
188 read_unlock(&bt_proto_lock);
193 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
195 write_lock(&l->lock);
196 sk_add_node(sk, &l->head);
197 write_unlock(&l->lock);
199 EXPORT_SYMBOL(bt_sock_link);
201 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
203 write_lock(&l->lock);
204 sk_del_node_init(sk);
205 write_unlock(&l->lock);
207 EXPORT_SYMBOL(bt_sock_unlink);
209 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
211 BT_DBG("parent %p, sk %p", parent, sk);
214 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
215 bt_sk(sk)->parent = parent;
216 parent->sk_ack_backlog++;
218 EXPORT_SYMBOL(bt_accept_enqueue);
220 void bt_accept_unlink(struct sock *sk)
222 BT_DBG("sk %p state %d", sk, sk->sk_state);
224 list_del_init(&bt_sk(sk)->accept_q);
225 bt_sk(sk)->parent->sk_ack_backlog--;
226 bt_sk(sk)->parent = NULL;
229 EXPORT_SYMBOL(bt_accept_unlink);
231 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
233 struct list_head *p, *n;
236 BT_DBG("parent %p", parent);
238 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
239 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
243 /* FIXME: Is this check still needed */
244 if (sk->sk_state == BT_CLOSED) {
246 bt_accept_unlink(sk);
250 if (sk->sk_state == BT_CONNECTED || !newsock ||
251 bt_sk(parent)->defer_setup) {
252 bt_accept_unlink(sk);
254 sock_graft(sk, newsock);
265 EXPORT_SYMBOL(bt_accept_dequeue);
267 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
268 struct msghdr *msg, size_t len, int flags)
270 int noblock = flags & MSG_DONTWAIT;
271 struct sock *sk = sock->sk;
276 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
278 if (flags & (MSG_OOB))
281 skb = skb_recv_datagram(sk, flags, noblock, &err);
283 if (sk->sk_shutdown & RCV_SHUTDOWN)
288 msg->msg_namelen = 0;
292 msg->msg_flags |= MSG_TRUNC;
296 skb_reset_transport_header(skb);
297 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
299 sock_recv_ts_and_drops(msg, sk, skb);
301 skb_free_datagram(sk, skb);
303 return err ? : copied;
305 EXPORT_SYMBOL(bt_sock_recvmsg);
307 static long bt_sock_data_wait(struct sock *sk, long timeo)
309 DECLARE_WAITQUEUE(wait, current);
311 add_wait_queue(sk_sleep(sk), &wait);
313 set_current_state(TASK_INTERRUPTIBLE);
315 if (!skb_queue_empty(&sk->sk_receive_queue))
318 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
321 if (signal_pending(current) || !timeo)
324 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
326 timeo = schedule_timeout(timeo);
328 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
331 __set_current_state(TASK_RUNNING);
332 remove_wait_queue(sk_sleep(sk), &wait);
336 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
337 struct msghdr *msg, size_t size, int flags)
339 struct sock *sk = sock->sk;
341 size_t target, copied = 0;
347 msg->msg_namelen = 0;
349 BT_DBG("sk %p size %zu", sk, size);
353 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
354 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
360 skb = skb_dequeue(&sk->sk_receive_queue);
362 if (copied >= target)
365 err = sock_error(sk);
368 if (sk->sk_shutdown & RCV_SHUTDOWN)
375 timeo = bt_sock_data_wait(sk, timeo);
377 if (signal_pending(current)) {
378 err = sock_intr_errno(timeo);
384 chunk = min_t(unsigned int, skb->len, size);
385 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
386 skb_queue_head(&sk->sk_receive_queue, skb);
394 sock_recv_ts_and_drops(msg, sk, skb);
396 if (!(flags & MSG_PEEK)) {
397 int skb_len = skb_headlen(skb);
399 if (chunk <= skb_len) {
400 __skb_pull(skb, chunk);
402 struct sk_buff *frag;
404 __skb_pull(skb, skb_len);
407 skb_walk_frags(skb, frag) {
408 if (chunk <= frag->len) {
409 /* Pulling partial data */
411 skb->data_len -= chunk;
412 __skb_pull(frag, chunk);
414 } else if (frag->len) {
415 /* Pulling all frag data */
417 skb->len -= frag->len;
418 skb->data_len -= frag->len;
419 __skb_pull(frag, frag->len);
425 skb_queue_head(&sk->sk_receive_queue, skb);
431 /* put message back and return */
432 skb_queue_head(&sk->sk_receive_queue, skb);
439 return copied ? : err;
441 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
443 static inline unsigned int bt_accept_poll(struct sock *parent)
445 struct list_head *p, *n;
448 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
449 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
450 if (sk->sk_state == BT_CONNECTED ||
451 (bt_sk(parent)->defer_setup &&
452 sk->sk_state == BT_CONNECT2))
453 return POLLIN | POLLRDNORM;
459 unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait)
461 struct sock *sk = sock->sk;
462 unsigned int mask = 0;
464 BT_DBG("sock %p, sk %p", sock, sk);
466 poll_wait(file, sk_sleep(sk), wait);
468 if (sk->sk_state == BT_LISTEN)
469 return bt_accept_poll(sk);
471 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
474 if (sk->sk_shutdown & RCV_SHUTDOWN)
475 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
477 if (sk->sk_shutdown == SHUTDOWN_MASK)
480 if (!skb_queue_empty(&sk->sk_receive_queue))
481 mask |= POLLIN | POLLRDNORM;
483 if (sk->sk_state == BT_CLOSED)
486 if (sk->sk_state == BT_CONNECT ||
487 sk->sk_state == BT_CONNECT2 ||
488 sk->sk_state == BT_CONFIG)
491 if (sock_writeable(sk))
492 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
494 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
498 EXPORT_SYMBOL(bt_sock_poll);
500 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
502 struct sock *sk = sock->sk;
507 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
511 if (sk->sk_state == BT_LISTEN)
514 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
517 err = put_user(amount, (int __user *) arg);
521 if (sk->sk_state == BT_LISTEN)
525 skb = skb_peek(&sk->sk_receive_queue);
526 amount = skb ? skb->len : 0;
528 err = put_user(amount, (int __user *) arg);
532 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
536 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
546 EXPORT_SYMBOL(bt_sock_ioctl);
548 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
550 DECLARE_WAITQUEUE(wait, current);
555 add_wait_queue(sk_sleep(sk), &wait);
556 set_current_state(TASK_INTERRUPTIBLE);
557 while (sk->sk_state != state) {
563 if (signal_pending(current)) {
564 err = sock_intr_errno(timeo);
569 timeo = schedule_timeout(timeo);
571 set_current_state(TASK_INTERRUPTIBLE);
573 err = sock_error(sk);
577 __set_current_state(TASK_RUNNING);
578 remove_wait_queue(sk_sleep(sk), &wait);
581 EXPORT_SYMBOL(bt_sock_wait_state);
583 static struct net_proto_family bt_sock_family_ops = {
584 .owner = THIS_MODULE,
585 .family = PF_BLUETOOTH,
586 .create = bt_sock_create,
589 static int __init bt_init(void)
593 BT_INFO("Core ver %s", VERSION);
595 err = bt_sysfs_init();
599 err = sock_register(&bt_sock_family_ops);
605 BT_INFO("HCI device and connection manager initialized");
607 err = hci_sock_init();
627 sock_unregister(PF_BLUETOOTH);
633 static void __exit bt_exit(void)
642 sock_unregister(PF_BLUETOOTH);
647 subsys_initcall(bt_init);
648 module_exit(bt_exit);
650 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
651 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
652 MODULE_VERSION(VERSION);
653 MODULE_LICENSE("GPL");
654 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);