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>
40 #if defined(CONFIG_KMOD)
41 #include <linux/kmod.h>
44 #include <net/bluetooth/bluetooth.h>
46 #ifndef CONFIG_BT_SOCK_DEBUG
51 #define VERSION "2.11"
53 /* Bluetooth sockets */
54 #define BT_MAX_PROTO 8
55 static struct net_proto_family
*bt_proto
[BT_MAX_PROTO
];
56 static DEFINE_RWLOCK(bt_proto_lock
);
58 int bt_sock_register(int proto
, struct net_proto_family
*ops
)
62 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
65 write_lock(&bt_proto_lock
);
70 bt_proto
[proto
] = ops
;
72 write_unlock(&bt_proto_lock
);
76 EXPORT_SYMBOL(bt_sock_register
);
78 int bt_sock_unregister(int proto
)
82 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
85 write_lock(&bt_proto_lock
);
90 bt_proto
[proto
] = NULL
;
92 write_unlock(&bt_proto_lock
);
96 EXPORT_SYMBOL(bt_sock_unregister
);
98 static int bt_sock_create(struct socket
*sock
, int proto
)
102 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
105 #if defined(CONFIG_KMOD)
106 if (!bt_proto
[proto
]) {
107 request_module("bt-proto-%d", proto
);
111 err
= -EPROTONOSUPPORT
;
113 read_lock(&bt_proto_lock
);
115 if (bt_proto
[proto
] && try_module_get(bt_proto
[proto
]->owner
)) {
116 err
= bt_proto
[proto
]->create(sock
, proto
);
117 module_put(bt_proto
[proto
]->owner
);
120 read_unlock(&bt_proto_lock
);
125 void bt_sock_link(struct bt_sock_list
*l
, struct sock
*sk
)
127 write_lock_bh(&l
->lock
);
128 sk_add_node(sk
, &l
->head
);
129 write_unlock_bh(&l
->lock
);
131 EXPORT_SYMBOL(bt_sock_link
);
133 void bt_sock_unlink(struct bt_sock_list
*l
, struct sock
*sk
)
135 write_lock_bh(&l
->lock
);
136 sk_del_node_init(sk
);
137 write_unlock_bh(&l
->lock
);
139 EXPORT_SYMBOL(bt_sock_unlink
);
141 void bt_accept_enqueue(struct sock
*parent
, struct sock
*sk
)
143 BT_DBG("parent %p, sk %p", parent
, sk
);
146 list_add_tail(&bt_sk(sk
)->accept_q
, &bt_sk(parent
)->accept_q
);
147 bt_sk(sk
)->parent
= parent
;
148 parent
->sk_ack_backlog
++;
150 EXPORT_SYMBOL(bt_accept_enqueue
);
152 void bt_accept_unlink(struct sock
*sk
)
154 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
156 list_del_init(&bt_sk(sk
)->accept_q
);
157 bt_sk(sk
)->parent
->sk_ack_backlog
--;
158 bt_sk(sk
)->parent
= NULL
;
161 EXPORT_SYMBOL(bt_accept_unlink
);
163 struct sock
*bt_accept_dequeue(struct sock
*parent
, struct socket
*newsock
)
165 struct list_head
*p
, *n
;
168 BT_DBG("parent %p", parent
);
170 list_for_each_safe(p
, n
, &bt_sk(parent
)->accept_q
) {
171 sk
= (struct sock
*) list_entry(p
, struct bt_sock
, accept_q
);
175 /* FIXME: Is this check still needed */
176 if (sk
->sk_state
== BT_CLOSED
) {
178 bt_accept_unlink(sk
);
182 if (sk
->sk_state
== BT_CONNECTED
|| !newsock
) {
183 bt_accept_unlink(sk
);
185 sock_graft(sk
, newsock
);
194 EXPORT_SYMBOL(bt_accept_dequeue
);
196 int bt_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
197 struct msghdr
*msg
, size_t len
, int flags
)
199 int noblock
= flags
& MSG_DONTWAIT
;
200 struct sock
*sk
= sock
->sk
;
205 BT_DBG("sock %p sk %p len %d", sock
, sk
, len
);
207 if (flags
& (MSG_OOB
))
210 if (!(skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
))) {
211 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
216 msg
->msg_namelen
= 0;
220 msg
->msg_flags
|= MSG_TRUNC
;
224 skb_reset_transport_header(skb
);
225 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
227 skb_free_datagram(sk
, skb
);
229 return err
? : copied
;
231 EXPORT_SYMBOL(bt_sock_recvmsg
);
233 static inline unsigned int bt_accept_poll(struct sock
*parent
)
235 struct list_head
*p
, *n
;
238 list_for_each_safe(p
, n
, &bt_sk(parent
)->accept_q
) {
239 sk
= (struct sock
*) list_entry(p
, struct bt_sock
, accept_q
);
240 if (sk
->sk_state
== BT_CONNECTED
)
241 return POLLIN
| POLLRDNORM
;
247 unsigned int bt_sock_poll(struct file
* file
, struct socket
*sock
, poll_table
*wait
)
249 struct sock
*sk
= sock
->sk
;
250 unsigned int mask
= 0;
252 BT_DBG("sock %p, sk %p", sock
, sk
);
254 poll_wait(file
, sk
->sk_sleep
, wait
);
256 if (sk
->sk_state
== BT_LISTEN
)
257 return bt_accept_poll(sk
);
259 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
262 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
263 mask
|= POLLRDHUP
| POLLIN
| POLLRDNORM
;
265 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
268 if (!skb_queue_empty(&sk
->sk_receive_queue
))
269 mask
|= POLLIN
| POLLRDNORM
;
271 if (sk
->sk_state
== BT_CLOSED
)
274 if (sk
->sk_state
== BT_CONNECT
||
275 sk
->sk_state
== BT_CONNECT2
||
276 sk
->sk_state
== BT_CONFIG
)
279 if (sock_writeable(sk
))
280 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
282 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
286 EXPORT_SYMBOL(bt_sock_poll
);
288 int bt_sock_wait_state(struct sock
*sk
, int state
, unsigned long timeo
)
290 DECLARE_WAITQUEUE(wait
, current
);
295 add_wait_queue(sk
->sk_sleep
, &wait
);
296 while (sk
->sk_state
!= state
) {
297 set_current_state(TASK_INTERRUPTIBLE
);
304 if (signal_pending(current
)) {
305 err
= sock_intr_errno(timeo
);
310 timeo
= schedule_timeout(timeo
);
313 err
= sock_error(sk
);
317 set_current_state(TASK_RUNNING
);
318 remove_wait_queue(sk
->sk_sleep
, &wait
);
321 EXPORT_SYMBOL(bt_sock_wait_state
);
323 static struct net_proto_family bt_sock_family_ops
= {
324 .owner
= THIS_MODULE
,
325 .family
= PF_BLUETOOTH
,
326 .create
= bt_sock_create
,
329 static int __init
bt_init(void)
333 BT_INFO("Core ver %s", VERSION
);
335 err
= bt_sysfs_init();
339 err
= sock_register(&bt_sock_family_ops
);
345 BT_INFO("HCI device and connection manager initialized");
352 static void __exit
bt_exit(void)
356 sock_unregister(PF_BLUETOOTH
);
361 subsys_initcall(bt_init
);
362 module_exit(bt_exit
);
364 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
365 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION
);
366 MODULE_VERSION(VERSION
);
367 MODULE_LICENSE("GPL");
368 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH
);