blob: 469eda0f0dfd713f0d998b5c830faaff2e9c71fd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
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;
10
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.
19
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.
23*/
24
25/* Bluetooth address family and sockets. */
26
27#include <linux/config.h>
28#include <linux/module.h>
29
30#include <linux/types.h>
31#include <linux/list.h>
32#include <linux/errno.h>
33#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/sched.h>
35#include <linux/slab.h>
36#include <linux/skbuff.h>
37#include <linux/init.h>
38#include <linux/poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <net/sock.h>
40
41#if defined(CONFIG_KMOD)
42#include <linux/kmod.h>
43#endif
44
45#include <net/bluetooth/bluetooth.h>
46
47#ifndef CONFIG_BT_SOCK_DEBUG
48#undef BT_DBG
49#define BT_DBG(D...)
50#endif
51
Marcel Holtmannbe9d1222005-11-08 09:57:38 -080052#define VERSION "2.8"
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54/* Bluetooth sockets */
55#define BT_MAX_PROTO 8
56static struct net_proto_family *bt_proto[BT_MAX_PROTO];
57
58int bt_sock_register(int proto, struct net_proto_family *ops)
59{
60 if (proto < 0 || proto >= BT_MAX_PROTO)
61 return -EINVAL;
62
63 if (bt_proto[proto])
64 return -EEXIST;
65
66 bt_proto[proto] = ops;
67 return 0;
68}
69EXPORT_SYMBOL(bt_sock_register);
70
71int bt_sock_unregister(int proto)
72{
73 if (proto < 0 || proto >= BT_MAX_PROTO)
74 return -EINVAL;
75
76 if (!bt_proto[proto])
77 return -ENOENT;
78
79 bt_proto[proto] = NULL;
80 return 0;
81}
82EXPORT_SYMBOL(bt_sock_unregister);
83
84static int bt_sock_create(struct socket *sock, int proto)
85{
86 int err = 0;
87
88 if (proto < 0 || proto >= BT_MAX_PROTO)
89 return -EINVAL;
90
91#if defined(CONFIG_KMOD)
92 if (!bt_proto[proto]) {
93 request_module("bt-proto-%d", proto);
94 }
95#endif
96 err = -EPROTONOSUPPORT;
97 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
98 err = bt_proto[proto]->create(sock, proto);
99 module_put(bt_proto[proto]->owner);
100 }
101 return err;
102}
103
104void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
105{
106 write_lock_bh(&l->lock);
107 sk_add_node(sk, &l->head);
108 write_unlock_bh(&l->lock);
109}
110EXPORT_SYMBOL(bt_sock_link);
111
112void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
113{
114 write_lock_bh(&l->lock);
115 sk_del_node_init(sk);
116 write_unlock_bh(&l->lock);
117}
118EXPORT_SYMBOL(bt_sock_unlink);
119
120void bt_accept_enqueue(struct sock *parent, struct sock *sk)
121{
122 BT_DBG("parent %p, sk %p", parent, sk);
123
124 sock_hold(sk);
125 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
126 bt_sk(sk)->parent = parent;
127 parent->sk_ack_backlog++;
128}
129EXPORT_SYMBOL(bt_accept_enqueue);
130
131void bt_accept_unlink(struct sock *sk)
132{
133 BT_DBG("sk %p state %d", sk, sk->sk_state);
134
135 list_del_init(&bt_sk(sk)->accept_q);
136 bt_sk(sk)->parent->sk_ack_backlog--;
137 bt_sk(sk)->parent = NULL;
138 sock_put(sk);
139}
140EXPORT_SYMBOL(bt_accept_unlink);
141
142struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
143{
144 struct list_head *p, *n;
145 struct sock *sk;
146
147 BT_DBG("parent %p", parent);
148
149 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
150 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
151
152 lock_sock(sk);
153
154 /* FIXME: Is this check still needed */
155 if (sk->sk_state == BT_CLOSED) {
156 release_sock(sk);
157 bt_accept_unlink(sk);
158 continue;
159 }
160
161 if (sk->sk_state == BT_CONNECTED || !newsock) {
162 bt_accept_unlink(sk);
163 if (newsock)
164 sock_graft(sk, newsock);
165 release_sock(sk);
166 return sk;
167 }
168
169 release_sock(sk);
170 }
171 return NULL;
172}
173EXPORT_SYMBOL(bt_accept_dequeue);
174
175int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
176 struct msghdr *msg, size_t len, int flags)
177{
178 int noblock = flags & MSG_DONTWAIT;
179 struct sock *sk = sock->sk;
180 struct sk_buff *skb;
181 size_t copied;
182 int err;
183
184 BT_DBG("sock %p sk %p len %d", sock, sk, len);
185
186 if (flags & (MSG_OOB))
187 return -EOPNOTSUPP;
188
189 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
190 if (sk->sk_shutdown & RCV_SHUTDOWN)
191 return 0;
192 return err;
193 }
194
195 msg->msg_namelen = 0;
196
197 copied = skb->len;
198 if (len < copied) {
199 msg->msg_flags |= MSG_TRUNC;
200 copied = len;
201 }
202
203 skb->h.raw = skb->data;
204 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
205
206 skb_free_datagram(sk, skb);
207
208 return err ? : copied;
209}
210EXPORT_SYMBOL(bt_sock_recvmsg);
211
212static inline unsigned int bt_accept_poll(struct sock *parent)
213{
214 struct list_head *p, *n;
215 struct sock *sk;
216
217 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
218 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
219 if (sk->sk_state == BT_CONNECTED)
220 return POLLIN | POLLRDNORM;
221 }
222
223 return 0;
224}
225
226unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
227{
228 struct sock *sk = sock->sk;
229 unsigned int mask = 0;
230
231 BT_DBG("sock %p, sk %p", sock, sk);
232
233 poll_wait(file, sk->sk_sleep, wait);
234
235 if (sk->sk_state == BT_LISTEN)
236 return bt_accept_poll(sk);
237
238 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
239 mask |= POLLERR;
240
Davide Libenzif348d702006-03-25 03:07:39 -0800241 if (sk->sk_shutdown & RCV_SHUTDOWN)
242 mask |= POLLRDHUP;
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 if (sk->sk_shutdown == SHUTDOWN_MASK)
245 mask |= POLLHUP;
246
247 if (!skb_queue_empty(&sk->sk_receive_queue) ||
248 (sk->sk_shutdown & RCV_SHUTDOWN))
249 mask |= POLLIN | POLLRDNORM;
250
251 if (sk->sk_state == BT_CLOSED)
252 mask |= POLLHUP;
253
254 if (sk->sk_state == BT_CONNECT ||
255 sk->sk_state == BT_CONNECT2 ||
256 sk->sk_state == BT_CONFIG)
257 return mask;
258
259 if (sock_writeable(sk))
260 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
261 else
262 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
263
264 return mask;
265}
266EXPORT_SYMBOL(bt_sock_poll);
267
268int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
269{
270 DECLARE_WAITQUEUE(wait, current);
271 int err = 0;
272
273 BT_DBG("sk %p", sk);
274
275 add_wait_queue(sk->sk_sleep, &wait);
276 while (sk->sk_state != state) {
277 set_current_state(TASK_INTERRUPTIBLE);
278
279 if (!timeo) {
280 err = -EAGAIN;
281 break;
282 }
283
284 if (signal_pending(current)) {
285 err = sock_intr_errno(timeo);
286 break;
287 }
288
289 release_sock(sk);
290 timeo = schedule_timeout(timeo);
291 lock_sock(sk);
292
Benjamin LaHaisec1cbe4b2005-12-13 23:22:19 -0800293 err = sock_error(sk);
294 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 }
297 set_current_state(TASK_RUNNING);
298 remove_wait_queue(sk->sk_sleep, &wait);
299 return err;
300}
301EXPORT_SYMBOL(bt_sock_wait_state);
302
303static struct net_proto_family bt_sock_family_ops = {
304 .owner = THIS_MODULE,
305 .family = PF_BLUETOOTH,
306 .create = bt_sock_create,
307};
308
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309static int __init bt_init(void)
310{
311 BT_INFO("Core ver %s", VERSION);
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 sock_register(&bt_sock_family_ops);
314
315 BT_INFO("HCI device and connection manager initialized");
316
317 bt_sysfs_init();
318
319 hci_sock_init();
320
321 return 0;
322}
323
324static void __exit bt_exit(void)
325{
326 hci_sock_cleanup();
327
328 bt_sysfs_cleanup();
329
330 sock_unregister(PF_BLUETOOTH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331}
332
333subsys_initcall(bt_init);
334module_exit(bt_exit);
335
336MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
337MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
338MODULE_VERSION(VERSION);
339MODULE_LICENSE("GPL");
340MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);