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/slab.h>
35 #include <linux/skbuff.h>
36 #include <linux/init.h>
37 #include <linux/poll.h>
39 #include <asm/ioctls.h>
40 #include <linux/kmod.h>
42 #include <net/bluetooth/bluetooth.h>
44 #ifndef CONFIG_BT_SOCK_DEBUG
49 #define VERSION "2.13"
51 /* Bluetooth sockets */
52 #define BT_MAX_PROTO 8
53 static struct net_proto_family *bt_proto[BT_MAX_PROTO];
54 static DEFINE_RWLOCK(bt_proto_lock);
56 #ifdef CONFIG_DEBUG_LOCK_ALLOC
57 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
58 static const char *bt_key_strings[BT_MAX_PROTO] = {
59 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
60 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
61 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
62 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
63 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
64 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
65 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
66 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
69 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
70 static const char *bt_slock_key_strings[BT_MAX_PROTO] = {
71 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
72 "slock-AF_BLUETOOTH-BTPROTO_HCI",
73 "slock-AF_BLUETOOTH-BTPROTO_SCO",
74 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
75 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
76 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
77 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
78 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
81 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
83 struct sock *sk = sock->sk;
88 BUG_ON(sock_owned_by_user(sk));
90 sock_lock_init_class_and_name(sk,
91 bt_slock_key_strings[proto], &bt_slock_key[proto],
92 bt_key_strings[proto], &bt_lock_key[proto]);
95 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
100 int bt_sock_register(int proto, struct net_proto_family *ops)
104 if (proto < 0 || proto >= BT_MAX_PROTO)
107 write_lock(&bt_proto_lock);
112 bt_proto[proto] = ops;
114 write_unlock(&bt_proto_lock);
118 EXPORT_SYMBOL(bt_sock_register);
120 int bt_sock_unregister(int proto)
124 if (proto < 0 || proto >= BT_MAX_PROTO)
127 write_lock(&bt_proto_lock);
129 if (!bt_proto[proto])
132 bt_proto[proto] = NULL;
134 write_unlock(&bt_proto_lock);
138 EXPORT_SYMBOL(bt_sock_unregister);
140 static int bt_sock_create(struct net *net, struct socket *sock, int proto)
144 if (net != &init_net)
145 return -EAFNOSUPPORT;
147 if (proto < 0 || proto >= BT_MAX_PROTO)
150 if (!bt_proto[proto])
151 request_module("bt-proto-%d", proto);
153 err = -EPROTONOSUPPORT;
155 read_lock(&bt_proto_lock);
157 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
158 err = bt_proto[proto]->create(net, sock, proto);
159 bt_sock_reclassify_lock(sock, proto);
160 module_put(bt_proto[proto]->owner);
163 read_unlock(&bt_proto_lock);
168 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
170 write_lock_bh(&l->lock);
171 sk_add_node(sk, &l->head);
172 write_unlock_bh(&l->lock);
174 EXPORT_SYMBOL(bt_sock_link);
176 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
178 write_lock_bh(&l->lock);
179 sk_del_node_init(sk);
180 write_unlock_bh(&l->lock);
182 EXPORT_SYMBOL(bt_sock_unlink);
184 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
186 BT_DBG("parent %p, sk %p", parent, sk);
189 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
190 bt_sk(sk)->parent = parent;
191 parent->sk_ack_backlog++;
193 EXPORT_SYMBOL(bt_accept_enqueue);
195 void bt_accept_unlink(struct sock *sk)
197 BT_DBG("sk %p state %d", sk, sk->sk_state);
199 list_del_init(&bt_sk(sk)->accept_q);
200 bt_sk(sk)->parent->sk_ack_backlog--;
201 bt_sk(sk)->parent = NULL;
204 EXPORT_SYMBOL(bt_accept_unlink);
206 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
208 struct list_head *p, *n;
211 BT_DBG("parent %p", parent);
213 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
214 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
218 /* FIXME: Is this check still needed */
219 if (sk->sk_state == BT_CLOSED) {
221 bt_accept_unlink(sk);
225 if (sk->sk_state == BT_CONNECTED || !newsock) {
226 bt_accept_unlink(sk);
228 sock_graft(sk, newsock);
237 EXPORT_SYMBOL(bt_accept_dequeue);
239 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
240 struct msghdr *msg, size_t len, int flags)
242 int noblock = flags & MSG_DONTWAIT;
243 struct sock *sk = sock->sk;
248 BT_DBG("sock %p sk %p len %d", sock, sk, len);
250 if (flags & (MSG_OOB))
253 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
254 if (sk->sk_shutdown & RCV_SHUTDOWN)
259 msg->msg_namelen = 0;
263 msg->msg_flags |= MSG_TRUNC;
267 skb_reset_transport_header(skb);
268 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
270 sock_recv_timestamp(msg, sk, skb);
272 skb_free_datagram(sk, skb);
274 return err ? : copied;
276 EXPORT_SYMBOL(bt_sock_recvmsg);
278 static inline unsigned int bt_accept_poll(struct sock *parent)
280 struct list_head *p, *n;
283 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
284 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
285 if (sk->sk_state == BT_CONNECTED)
286 return POLLIN | POLLRDNORM;
292 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
294 struct sock *sk = sock->sk;
295 unsigned int mask = 0;
297 BT_DBG("sock %p, sk %p", sock, sk);
299 poll_wait(file, sk->sk_sleep, wait);
301 if (sk->sk_state == BT_LISTEN)
302 return bt_accept_poll(sk);
304 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
307 if (sk->sk_shutdown & RCV_SHUTDOWN)
310 if (sk->sk_shutdown == SHUTDOWN_MASK)
313 if (!skb_queue_empty(&sk->sk_receive_queue) ||
314 (sk->sk_shutdown & RCV_SHUTDOWN))
315 mask |= POLLIN | POLLRDNORM;
317 if (sk->sk_state == BT_CLOSED)
320 if (sk->sk_state == BT_CONNECT ||
321 sk->sk_state == BT_CONNECT2 ||
322 sk->sk_state == BT_CONFIG)
325 if (sock_writeable(sk))
326 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
328 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
332 EXPORT_SYMBOL(bt_sock_poll);
334 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
336 struct sock *sk = sock->sk;
341 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
345 if (sk->sk_state == BT_LISTEN)
348 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
351 err = put_user(amount, (int __user *) arg);
355 if (sk->sk_state == BT_LISTEN)
359 skb = skb_peek(&sk->sk_receive_queue);
360 amount = skb ? skb->len : 0;
362 err = put_user(amount, (int __user *) arg);
366 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
370 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
380 EXPORT_SYMBOL(bt_sock_ioctl);
382 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
384 DECLARE_WAITQUEUE(wait, current);
389 add_wait_queue(sk->sk_sleep, &wait);
390 while (sk->sk_state != state) {
391 set_current_state(TASK_INTERRUPTIBLE);
398 if (signal_pending(current)) {
399 err = sock_intr_errno(timeo);
404 timeo = schedule_timeout(timeo);
407 err = sock_error(sk);
411 set_current_state(TASK_RUNNING);
412 remove_wait_queue(sk->sk_sleep, &wait);
415 EXPORT_SYMBOL(bt_sock_wait_state);
417 static struct net_proto_family bt_sock_family_ops = {
418 .owner = THIS_MODULE,
419 .family = PF_BLUETOOTH,
420 .create = bt_sock_create,
423 static int __init bt_init(void)
427 BT_INFO("Core ver %s", VERSION);
429 err = bt_sysfs_init();
433 err = sock_register(&bt_sock_family_ops);
439 BT_INFO("HCI device and connection manager initialized");
446 static void __exit bt_exit(void)
450 sock_unregister(PF_BLUETOOTH);
455 subsys_initcall(bt_init);
456 module_exit(bt_exit);
458 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
459 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
460 MODULE_VERSION(VERSION);
461 MODULE_LICENSE("GPL");
462 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);