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.
26 * Bluetooth address family and sockets.
28 * $Id: af_bluetooth.c,v 1.3 2002/04/17 17:37:15 maxk Exp $
32 #include <linux/config.h>
33 #include <linux/module.h>
35 #include <linux/types.h>
36 #include <linux/list.h>
37 #include <linux/errno.h>
38 #include <linux/kernel.h>
39 #include <linux/major.h>
40 #include <linux/sched.h>
41 #include <linux/slab.h>
42 #include <linux/skbuff.h>
43 #include <linux/init.h>
44 #include <linux/poll.h>
45 #include <linux/proc_fs.h>
48 #if defined(CONFIG_KMOD)
49 #include <linux/kmod.h>
52 #include <net/bluetooth/bluetooth.h>
54 #ifndef CONFIG_BT_SOCK_DEBUG
56 #define BT_DBG( A... )
59 struct proc_dir_entry *proc_bt;
61 /* Bluetooth sockets */
62 #define BT_MAX_PROTO 6
63 static struct net_proto_family *bt_proto[BT_MAX_PROTO];
65 static kmem_cache_t *bt_sock_cache;
67 int bt_sock_register(int proto, struct net_proto_family *ops)
69 if (proto >= BT_MAX_PROTO)
75 bt_proto[proto] = ops;
79 int bt_sock_unregister(int proto)
81 if (proto >= BT_MAX_PROTO)
87 bt_proto[proto] = NULL;
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;
140 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
142 write_lock_bh(&l->lock);
143 sk_add_node(sk, &l->head);
144 write_unlock_bh(&l->lock);
147 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
149 write_lock_bh(&l->lock);
150 sk_del_node_init(sk);
151 write_unlock_bh(&l->lock);
154 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
156 BT_DBG("parent %p, sk %p", parent, sk);
159 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
160 bt_sk(sk)->parent = parent;
161 parent->sk_ack_backlog++;
164 static void bt_accept_unlink(struct sock *sk)
166 BT_DBG("sk %p state %d", sk, sk->sk_state);
168 list_del_init(&bt_sk(sk)->accept_q);
169 bt_sk(sk)->parent->sk_ack_backlog--;
170 bt_sk(sk)->parent = NULL;
174 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
176 struct list_head *p, *n;
179 BT_DBG("parent %p", parent);
181 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
182 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
185 if (sk->sk_state == BT_CLOSED) {
187 bt_accept_unlink(sk);
191 if (sk->sk_state == BT_CONNECTED || !newsock) {
192 bt_accept_unlink(sk);
194 sock_graft(sk, newsock);
203 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
204 struct msghdr *msg, size_t len, int flags)
206 int noblock = flags & MSG_DONTWAIT;
207 struct sock *sk = sock->sk;
212 BT_DBG("sock %p sk %p len %d", sock, sk, len);
214 if (flags & (MSG_OOB))
217 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
218 if (sk->sk_shutdown & RCV_SHUTDOWN)
223 msg->msg_namelen = 0;
227 msg->msg_flags |= MSG_TRUNC;
231 skb->h.raw = skb->data;
232 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
234 skb_free_datagram(sk, skb);
236 return err ? : copied;
239 static inline unsigned int bt_accept_poll(struct sock *parent)
241 struct list_head *p, *n;
244 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
245 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
246 if (sk->sk_state == BT_CONNECTED)
247 return POLLIN | POLLRDNORM;
253 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
255 struct sock *sk = sock->sk;
256 unsigned int mask = 0;
258 BT_DBG("sock %p, sk %p", sock, sk);
260 poll_wait(file, sk->sk_sleep, wait);
262 if (sk->sk_state == BT_LISTEN)
263 return bt_accept_poll(sk);
265 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
268 if (sk->sk_shutdown == SHUTDOWN_MASK)
271 if (!skb_queue_empty(&sk->sk_receive_queue) ||
272 (sk->sk_shutdown & RCV_SHUTDOWN))
273 mask |= POLLIN | POLLRDNORM;
275 if (sk->sk_state == BT_CLOSED)
278 if (sk->sk_state == BT_CONNECT ||
279 sk->sk_state == BT_CONNECT2 ||
280 sk->sk_state == BT_CONFIG)
283 if (sock_writeable(sk))
284 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
286 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
291 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
293 DECLARE_WAITQUEUE(wait, current);
298 add_wait_queue(sk->sk_sleep, &wait);
299 while (sk->sk_state != state) {
300 set_current_state(TASK_INTERRUPTIBLE);
307 if (signal_pending(current)) {
308 err = sock_intr_errno(timeo);
313 timeo = schedule_timeout(timeo);
317 err = sock_error(sk);
321 set_current_state(TASK_RUNNING);
322 remove_wait_queue(sk->sk_sleep, &wait);
326 static struct net_proto_family bt_sock_family_ops = {
327 .owner = THIS_MODULE,
328 .family = PF_BLUETOOTH,
329 .create = bt_sock_create,
332 extern int hci_sock_init(void);
333 extern int hci_sock_cleanup(void);
335 extern int bt_sysfs_init(void);
336 extern int bt_sysfs_cleanup(void);
338 static int __init bt_init(void)
340 BT_INFO("Core ver %s", VERSION);
342 proc_bt = proc_mkdir("bluetooth", NULL);
344 proc_bt->owner = THIS_MODULE;
346 /* Init socket cache */
347 bt_sock_cache = kmem_cache_create("bt_sock",
348 sizeof(struct bt_sock), 0,
349 SLAB_HWCACHE_ALIGN, 0, 0);
351 if (!bt_sock_cache) {
352 BT_ERR("Socket cache creation failed");
356 sock_register(&bt_sock_family_ops);
358 BT_INFO("HCI device and connection manager initialized");
367 static void __exit bt_exit(void)
373 sock_unregister(PF_BLUETOOTH);
374 kmem_cache_destroy(bt_sock_cache);
376 remove_proc_entry("bluetooth", NULL);
379 subsys_initcall(bt_init);
380 module_exit(bt_exit);
382 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
383 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
384 MODULE_VERSION(VERSION);
385 MODULE_LICENSE("GPL");
386 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);