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 7
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 static 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;
178 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
180 struct list_head *p, *n;
183 BT_DBG("parent %p", parent);
185 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
186 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
189 if (sk->sk_state == BT_CLOSED) {
191 bt_accept_unlink(sk);
195 if (sk->sk_state == BT_CONNECTED || !newsock) {
196 bt_accept_unlink(sk);
198 sock_graft(sk, newsock);
206 EXPORT_SYMBOL(bt_accept_dequeue);
208 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
209 struct msghdr *msg, size_t len, int flags)
211 int noblock = flags & MSG_DONTWAIT;
212 struct sock *sk = sock->sk;
217 BT_DBG("sock %p sk %p len %d", sock, sk, len);
219 if (flags & (MSG_OOB))
222 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
223 if (sk->sk_shutdown & RCV_SHUTDOWN)
228 msg->msg_namelen = 0;
232 msg->msg_flags |= MSG_TRUNC;
236 skb->h.raw = skb->data;
237 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
239 skb_free_datagram(sk, skb);
241 return err ? : copied;
243 EXPORT_SYMBOL(bt_sock_recvmsg);
245 static inline unsigned int bt_accept_poll(struct sock *parent)
247 struct list_head *p, *n;
250 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
251 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
252 if (sk->sk_state == BT_CONNECTED)
253 return POLLIN | POLLRDNORM;
259 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
261 struct sock *sk = sock->sk;
262 unsigned int mask = 0;
264 BT_DBG("sock %p, sk %p", sock, sk);
266 poll_wait(file, sk->sk_sleep, wait);
268 if (sk->sk_state == BT_LISTEN)
269 return bt_accept_poll(sk);
271 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
274 if (sk->sk_shutdown == SHUTDOWN_MASK)
277 if (!skb_queue_empty(&sk->sk_receive_queue) ||
278 (sk->sk_shutdown & RCV_SHUTDOWN))
279 mask |= POLLIN | POLLRDNORM;
281 if (sk->sk_state == BT_CLOSED)
284 if (sk->sk_state == BT_CONNECT ||
285 sk->sk_state == BT_CONNECT2 ||
286 sk->sk_state == BT_CONFIG)
289 if (sock_writeable(sk))
290 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
292 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
296 EXPORT_SYMBOL(bt_sock_poll);
298 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
300 DECLARE_WAITQUEUE(wait, current);
305 add_wait_queue(sk->sk_sleep, &wait);
306 while (sk->sk_state != state) {
307 set_current_state(TASK_INTERRUPTIBLE);
314 if (signal_pending(current)) {
315 err = sock_intr_errno(timeo);
320 timeo = schedule_timeout(timeo);
324 err = sock_error(sk);
328 set_current_state(TASK_RUNNING);
329 remove_wait_queue(sk->sk_sleep, &wait);
332 EXPORT_SYMBOL(bt_sock_wait_state);
334 static struct net_proto_family bt_sock_family_ops = {
335 .owner = THIS_MODULE,
336 .family = PF_BLUETOOTH,
337 .create = bt_sock_create,
340 extern int hci_sock_init(void);
341 extern int hci_sock_cleanup(void);
343 extern int bt_sysfs_init(void);
344 extern int bt_sysfs_cleanup(void);
346 static int __init bt_init(void)
348 BT_INFO("Core ver %s", VERSION);
350 proc_bt = proc_mkdir("bluetooth", NULL);
352 proc_bt->owner = THIS_MODULE;
354 /* Init socket cache */
355 bt_sock_cache = kmem_cache_create("bt_sock",
356 sizeof(struct bt_sock), 0,
357 SLAB_HWCACHE_ALIGN, 0, 0);
359 if (!bt_sock_cache) {
360 BT_ERR("Socket cache creation failed");
364 sock_register(&bt_sock_family_ops);
366 BT_INFO("HCI device and connection manager initialized");
375 static void __exit bt_exit(void)
381 sock_unregister(PF_BLUETOOTH);
382 kmem_cache_destroy(bt_sock_cache);
384 remove_proc_entry("bluetooth", NULL);
387 subsys_initcall(bt_init);
388 module_exit(bt_exit);
390 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
391 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
392 MODULE_VERSION(VERSION);
393 MODULE_LICENSE("GPL");
394 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);