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/config.h>
28 #include <linux/module.h>
30 #include <linux/types.h>
31 #include <linux/list.h>
32 #include <linux/errno.h>
33 #include <linux/kernel.h>
34 #include <linux/major.h>
35 #include <linux/sched.h>
36 #include <linux/slab.h>
37 #include <linux/skbuff.h>
38 #include <linux/init.h>
39 #include <linux/poll.h>
40 #include <linux/proc_fs.h>
43 #if defined(CONFIG_KMOD)
44 #include <linux/kmod.h>
47 #include <net/bluetooth/bluetooth.h>
49 #ifndef CONFIG_BT_SOCK_DEBUG
56 struct proc_dir_entry *proc_bt;
57 EXPORT_SYMBOL(proc_bt);
59 /* Bluetooth sockets */
60 #define BT_MAX_PROTO 8
61 static struct net_proto_family *bt_proto[BT_MAX_PROTO];
63 static kmem_cache_t *bt_sock_cache;
65 int bt_sock_register(int proto, struct net_proto_family *ops)
67 if (proto >= BT_MAX_PROTO)
73 bt_proto[proto] = ops;
76 EXPORT_SYMBOL(bt_sock_register);
78 int bt_sock_unregister(int proto)
80 if (proto >= BT_MAX_PROTO)
86 bt_proto[proto] = NULL;
89 EXPORT_SYMBOL(bt_sock_unregister);
91 static int bt_sock_create(struct socket *sock, int proto)
95 if (proto >= BT_MAX_PROTO)
98 #if defined(CONFIG_KMOD)
99 if (!bt_proto[proto]) {
100 request_module("bt-proto-%d", proto);
103 err = -EPROTONOSUPPORT;
104 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
105 err = bt_proto[proto]->create(sock, proto);
106 module_put(bt_proto[proto]->owner);
111 struct sock *bt_sock_alloc(struct socket *sock, int proto, int pi_size, int prio)
116 sk = sk_alloc(PF_BLUETOOTH, prio, sizeof(struct bt_sock), bt_sock_cache);
121 pi = kmalloc(pi_size, prio);
126 memset(pi, 0, pi_size);
127 sk->sk_protinfo = pi;
130 sock_init_data(sock, sk);
131 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
134 sk->sk_protocol = proto;
135 sk->sk_state = BT_OPEN;
139 EXPORT_SYMBOL(bt_sock_alloc);
141 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
143 write_lock_bh(&l->lock);
144 sk_add_node(sk, &l->head);
145 write_unlock_bh(&l->lock);
147 EXPORT_SYMBOL(bt_sock_link);
149 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
151 write_lock_bh(&l->lock);
152 sk_del_node_init(sk);
153 write_unlock_bh(&l->lock);
155 EXPORT_SYMBOL(bt_sock_unlink);
157 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
159 BT_DBG("parent %p, sk %p", parent, sk);
162 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
163 bt_sk(sk)->parent = parent;
164 parent->sk_ack_backlog++;
166 EXPORT_SYMBOL(bt_accept_enqueue);
168 void bt_accept_unlink(struct sock *sk)
170 BT_DBG("sk %p state %d", sk, sk->sk_state);
172 list_del_init(&bt_sk(sk)->accept_q);
173 bt_sk(sk)->parent->sk_ack_backlog--;
174 bt_sk(sk)->parent = NULL;
177 EXPORT_SYMBOL(bt_accept_unlink);
179 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
181 struct list_head *p, *n;
184 BT_DBG("parent %p", parent);
186 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
187 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
191 /* FIXME: Is this check still needed */
192 if (sk->sk_state == BT_CLOSED) {
194 bt_accept_unlink(sk);
198 if (sk->sk_state == BT_CONNECTED || !newsock) {
199 bt_accept_unlink(sk);
201 sock_graft(sk, newsock);
210 EXPORT_SYMBOL(bt_accept_dequeue);
212 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
213 struct msghdr *msg, size_t len, int flags)
215 int noblock = flags & MSG_DONTWAIT;
216 struct sock *sk = sock->sk;
221 BT_DBG("sock %p sk %p len %d", sock, sk, len);
223 if (flags & (MSG_OOB))
226 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
227 if (sk->sk_shutdown & RCV_SHUTDOWN)
232 msg->msg_namelen = 0;
236 msg->msg_flags |= MSG_TRUNC;
240 skb->h.raw = skb->data;
241 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
243 skb_free_datagram(sk, skb);
245 return err ? : copied;
247 EXPORT_SYMBOL(bt_sock_recvmsg);
249 static inline unsigned int bt_accept_poll(struct sock *parent)
251 struct list_head *p, *n;
254 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
255 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
256 if (sk->sk_state == BT_CONNECTED)
257 return POLLIN | POLLRDNORM;
263 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
265 struct sock *sk = sock->sk;
266 unsigned int mask = 0;
268 BT_DBG("sock %p, sk %p", sock, sk);
270 poll_wait(file, sk->sk_sleep, wait);
272 if (sk->sk_state == BT_LISTEN)
273 return bt_accept_poll(sk);
275 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
278 if (sk->sk_shutdown == SHUTDOWN_MASK)
281 if (!skb_queue_empty(&sk->sk_receive_queue) ||
282 (sk->sk_shutdown & RCV_SHUTDOWN))
283 mask |= POLLIN | POLLRDNORM;
285 if (sk->sk_state == BT_CLOSED)
288 if (sk->sk_state == BT_CONNECT ||
289 sk->sk_state == BT_CONNECT2 ||
290 sk->sk_state == BT_CONFIG)
293 if (sock_writeable(sk))
294 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
296 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
300 EXPORT_SYMBOL(bt_sock_poll);
302 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
304 DECLARE_WAITQUEUE(wait, current);
309 add_wait_queue(sk->sk_sleep, &wait);
310 while (sk->sk_state != state) {
311 set_current_state(TASK_INTERRUPTIBLE);
318 if (signal_pending(current)) {
319 err = sock_intr_errno(timeo);
324 timeo = schedule_timeout(timeo);
328 err = sock_error(sk);
332 set_current_state(TASK_RUNNING);
333 remove_wait_queue(sk->sk_sleep, &wait);
336 EXPORT_SYMBOL(bt_sock_wait_state);
338 static struct net_proto_family bt_sock_family_ops = {
339 .owner = THIS_MODULE,
340 .family = PF_BLUETOOTH,
341 .create = bt_sock_create,
344 extern int hci_sock_init(void);
345 extern int hci_sock_cleanup(void);
347 extern int bt_sysfs_init(void);
348 extern int bt_sysfs_cleanup(void);
350 static int __init bt_init(void)
352 BT_INFO("Core ver %s", VERSION);
354 proc_bt = proc_mkdir("bluetooth", NULL);
356 proc_bt->owner = THIS_MODULE;
358 /* Init socket cache */
359 bt_sock_cache = kmem_cache_create("bt_sock",
360 sizeof(struct bt_sock), 0,
361 SLAB_HWCACHE_ALIGN, NULL, NULL);
363 if (!bt_sock_cache) {
364 BT_ERR("Socket cache creation failed");
368 sock_register(&bt_sock_family_ops);
370 BT_INFO("HCI device and connection manager initialized");
379 static void __exit bt_exit(void)
385 sock_unregister(PF_BLUETOOTH);
386 kmem_cache_destroy(bt_sock_cache);
388 remove_proc_entry("bluetooth", NULL);
391 subsys_initcall(bt_init);
392 module_exit(bt_exit);
394 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
395 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
396 MODULE_VERSION(VERSION);
397 MODULE_LICENSE("GPL");
398 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);