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 #define VERSION "2.14"
46 /* Bluetooth sockets */
47 #define BT_MAX_PROTO 8
48 static struct net_proto_family *bt_proto[BT_MAX_PROTO];
49 static DEFINE_RWLOCK(bt_proto_lock);
51 #ifdef CONFIG_DEBUG_LOCK_ALLOC
52 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
53 static const char *bt_key_strings[BT_MAX_PROTO] = {
54 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
55 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
56 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
57 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
58 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
59 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
60 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
61 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
64 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
65 static const char *bt_slock_key_strings[BT_MAX_PROTO] = {
66 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
67 "slock-AF_BLUETOOTH-BTPROTO_HCI",
68 "slock-AF_BLUETOOTH-BTPROTO_SCO",
69 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
70 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
71 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
72 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
73 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
76 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
78 struct sock *sk = sock->sk;
83 BUG_ON(sock_owned_by_user(sk));
85 sock_lock_init_class_and_name(sk,
86 bt_slock_key_strings[proto], &bt_slock_key[proto],
87 bt_key_strings[proto], &bt_lock_key[proto]);
90 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
95 int bt_sock_register(int proto, struct net_proto_family *ops)
99 if (proto < 0 || proto >= BT_MAX_PROTO)
102 write_lock(&bt_proto_lock);
107 bt_proto[proto] = ops;
109 write_unlock(&bt_proto_lock);
113 EXPORT_SYMBOL(bt_sock_register);
115 int bt_sock_unregister(int proto)
119 if (proto < 0 || proto >= BT_MAX_PROTO)
122 write_lock(&bt_proto_lock);
124 if (!bt_proto[proto])
127 bt_proto[proto] = NULL;
129 write_unlock(&bt_proto_lock);
133 EXPORT_SYMBOL(bt_sock_unregister);
135 static int bt_sock_create(struct net *net, struct socket *sock, int proto)
139 if (net != &init_net)
140 return -EAFNOSUPPORT;
142 if (proto < 0 || proto >= BT_MAX_PROTO)
145 if (!bt_proto[proto])
146 request_module("bt-proto-%d", proto);
148 err = -EPROTONOSUPPORT;
150 read_lock(&bt_proto_lock);
152 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
153 err = bt_proto[proto]->create(net, sock, proto);
154 bt_sock_reclassify_lock(sock, proto);
155 module_put(bt_proto[proto]->owner);
158 read_unlock(&bt_proto_lock);
163 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
165 write_lock_bh(&l->lock);
166 sk_add_node(sk, &l->head);
167 write_unlock_bh(&l->lock);
169 EXPORT_SYMBOL(bt_sock_link);
171 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
173 write_lock_bh(&l->lock);
174 sk_del_node_init(sk);
175 write_unlock_bh(&l->lock);
177 EXPORT_SYMBOL(bt_sock_unlink);
179 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
181 BT_DBG("parent %p, sk %p", parent, sk);
184 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
185 bt_sk(sk)->parent = parent;
186 parent->sk_ack_backlog++;
188 EXPORT_SYMBOL(bt_accept_enqueue);
190 void bt_accept_unlink(struct sock *sk)
192 BT_DBG("sk %p state %d", sk, sk->sk_state);
194 list_del_init(&bt_sk(sk)->accept_q);
195 bt_sk(sk)->parent->sk_ack_backlog--;
196 bt_sk(sk)->parent = NULL;
199 EXPORT_SYMBOL(bt_accept_unlink);
201 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
203 struct list_head *p, *n;
206 BT_DBG("parent %p", parent);
208 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
209 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
213 /* FIXME: Is this check still needed */
214 if (sk->sk_state == BT_CLOSED) {
216 bt_accept_unlink(sk);
220 if (sk->sk_state == BT_CONNECTED || !newsock ||
221 bt_sk(parent)->defer_setup) {
222 bt_accept_unlink(sk);
224 sock_graft(sk, newsock);
233 EXPORT_SYMBOL(bt_accept_dequeue);
235 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
236 struct msghdr *msg, size_t len, int flags)
238 int noblock = flags & MSG_DONTWAIT;
239 struct sock *sk = sock->sk;
244 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
246 if (flags & (MSG_OOB))
249 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
250 if (sk->sk_shutdown & RCV_SHUTDOWN)
255 msg->msg_namelen = 0;
259 msg->msg_flags |= MSG_TRUNC;
263 skb_reset_transport_header(skb);
264 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
266 sock_recv_timestamp(msg, sk, skb);
268 skb_free_datagram(sk, skb);
270 return err ? : copied;
272 EXPORT_SYMBOL(bt_sock_recvmsg);
274 static inline unsigned int bt_accept_poll(struct sock *parent)
276 struct list_head *p, *n;
279 if (bt_sk(parent)->defer_setup)
280 return POLLIN | POLLRDNORM;
282 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
283 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
284 if (sk->sk_state == BT_CONNECTED)
285 return POLLIN | POLLRDNORM;
291 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
293 struct sock *sk = sock->sk;
294 unsigned int mask = 0;
296 BT_DBG("sock %p, sk %p", sock, sk);
298 poll_wait(file, sk->sk_sleep, wait);
300 if (sk->sk_state == BT_LISTEN)
301 return bt_accept_poll(sk);
303 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
306 if (sk->sk_shutdown & RCV_SHUTDOWN)
309 if (sk->sk_shutdown == SHUTDOWN_MASK)
312 if (!skb_queue_empty(&sk->sk_receive_queue) ||
313 (sk->sk_shutdown & RCV_SHUTDOWN))
314 mask |= POLLIN | POLLRDNORM;
316 if (sk->sk_state == BT_CLOSED)
319 if (sk->sk_state == BT_CONNECT ||
320 sk->sk_state == BT_CONNECT2 ||
321 sk->sk_state == BT_CONFIG)
324 if (sock_writeable(sk))
325 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
327 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
331 EXPORT_SYMBOL(bt_sock_poll);
333 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
335 struct sock *sk = sock->sk;
340 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
344 if (sk->sk_state == BT_LISTEN)
347 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
350 err = put_user(amount, (int __user *) arg);
354 if (sk->sk_state == BT_LISTEN)
358 skb = skb_peek(&sk->sk_receive_queue);
359 amount = skb ? skb->len : 0;
361 err = put_user(amount, (int __user *) arg);
365 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
369 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
379 EXPORT_SYMBOL(bt_sock_ioctl);
381 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
383 DECLARE_WAITQUEUE(wait, current);
388 add_wait_queue(sk->sk_sleep, &wait);
389 while (sk->sk_state != state) {
390 set_current_state(TASK_INTERRUPTIBLE);
397 if (signal_pending(current)) {
398 err = sock_intr_errno(timeo);
403 timeo = schedule_timeout(timeo);
406 err = sock_error(sk);
410 set_current_state(TASK_RUNNING);
411 remove_wait_queue(sk->sk_sleep, &wait);
414 EXPORT_SYMBOL(bt_sock_wait_state);
416 static struct net_proto_family bt_sock_family_ops = {
417 .owner = THIS_MODULE,
418 .family = PF_BLUETOOTH,
419 .create = bt_sock_create,
422 static int __init bt_init(void)
426 BT_INFO("Core ver %s", VERSION);
428 err = bt_sysfs_init();
432 err = sock_register(&bt_sock_family_ops);
438 BT_INFO("HCI device and connection manager initialized");
445 static void __exit bt_exit(void)
449 sock_unregister(PF_BLUETOOTH);
454 subsys_initcall(bt_init);
455 module_exit(bt_exit);
457 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
458 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
459 MODULE_VERSION(VERSION);
460 MODULE_LICENSE("GPL");
461 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);