88afe25003d89cd42d4aa0306f3a55c96166b8aa
[pandora-kernel.git] / net / bluetooth / af_bluetooth.c
1 /*
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/module.h>
28
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>
38 #include <net/sock.h>
39 #include <asm/ioctls.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
52 #define VERSION "2.11"
53
54 /* Bluetooth sockets */
55 #define BT_MAX_PROTO    8
56 static struct net_proto_family *bt_proto[BT_MAX_PROTO];
57
58 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
59 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
60 static const char *bt_key_strings[BT_MAX_PROTO] = {
61         "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
62         "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
63         "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
64         "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
65         "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
66         "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
67         "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
68         "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
69 };
70
71 static const char *bt_slock_key_strings[BT_MAX_PROTO] = {
72         "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
73         "slock-AF_BLUETOOTH-BTPROTO_HCI",
74         "slock-AF_BLUETOOTH-BTPROTO_SCO",
75         "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
76         "slock-AF_BLUETOOTH-BTPROTO_BNEP",
77         "slock-AF_BLUETOOTH-BTPROTO_CMTP",
78         "slock-AF_BLUETOOTH-BTPROTO_HIDP",
79         "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
80 };
81 static DEFINE_RWLOCK(bt_proto_lock);
82
83 int bt_sock_register(int proto, struct net_proto_family *ops)
84 {
85         int err = 0;
86
87         if (proto < 0 || proto >= BT_MAX_PROTO)
88                 return -EINVAL;
89
90         write_lock(&bt_proto_lock);
91
92         if (bt_proto[proto])
93                 err = -EEXIST;
94         else
95                 bt_proto[proto] = ops;
96
97         write_unlock(&bt_proto_lock);
98
99         return err;
100 }
101 EXPORT_SYMBOL(bt_sock_register);
102
103 int bt_sock_unregister(int proto)
104 {
105         int err = 0;
106
107         if (proto < 0 || proto >= BT_MAX_PROTO)
108                 return -EINVAL;
109
110         write_lock(&bt_proto_lock);
111
112         if (!bt_proto[proto])
113                 err = -ENOENT;
114         else
115                 bt_proto[proto] = NULL;
116
117         write_unlock(&bt_proto_lock);
118
119         return err;
120 }
121 EXPORT_SYMBOL(bt_sock_unregister);
122
123 static void bt_reclassify_sock_lock(struct socket *sock, int proto)
124 {
125         struct sock *sk = sock->sk;
126
127         if (!sk)
128                 return;
129         BUG_ON(sock_owned_by_user(sk));
130
131         sock_lock_init_class_and_name(sk,
132                         bt_slock_key_strings[proto],
133                         &bt_slock_key[proto],
134                         bt_key_strings[proto],
135                         &bt_lock_key[proto]);
136 }
137
138 static int bt_sock_create(struct net *net, struct socket *sock, int proto)
139 {
140         int err;
141
142         if (net != &init_net)
143                 return -EAFNOSUPPORT;
144
145         if (proto < 0 || proto >= BT_MAX_PROTO)
146                 return -EINVAL;
147
148 #if defined(CONFIG_KMOD)
149         if (!bt_proto[proto]) {
150                 request_module("bt-proto-%d", proto);
151         }
152 #endif
153
154         err = -EPROTONOSUPPORT;
155
156         read_lock(&bt_proto_lock);
157
158         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
159                 err = bt_proto[proto]->create(net, sock, proto);
160                 bt_reclassify_sock_lock(sock, proto);
161                 module_put(bt_proto[proto]->owner);
162         }
163
164         read_unlock(&bt_proto_lock);
165
166         return err;
167 }
168
169 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
170 {
171         write_lock_bh(&l->lock);
172         sk_add_node(sk, &l->head);
173         write_unlock_bh(&l->lock);
174 }
175 EXPORT_SYMBOL(bt_sock_link);
176
177 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
178 {
179         write_lock_bh(&l->lock);
180         sk_del_node_init(sk);
181         write_unlock_bh(&l->lock);
182 }
183 EXPORT_SYMBOL(bt_sock_unlink);
184
185 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
186 {
187         BT_DBG("parent %p, sk %p", parent, sk);
188
189         sock_hold(sk);
190         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
191         bt_sk(sk)->parent = parent;
192         parent->sk_ack_backlog++;
193 }
194 EXPORT_SYMBOL(bt_accept_enqueue);
195
196 void bt_accept_unlink(struct sock *sk)
197 {
198         BT_DBG("sk %p state %d", sk, sk->sk_state);
199
200         list_del_init(&bt_sk(sk)->accept_q);
201         bt_sk(sk)->parent->sk_ack_backlog--;
202         bt_sk(sk)->parent = NULL;
203         sock_put(sk);
204 }
205 EXPORT_SYMBOL(bt_accept_unlink);
206
207 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
208 {
209         struct list_head *p, *n;
210         struct sock *sk;
211
212         BT_DBG("parent %p", parent);
213
214         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
215                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
216
217                 lock_sock(sk);
218
219                 /* FIXME: Is this check still needed */
220                 if (sk->sk_state == BT_CLOSED) {
221                         release_sock(sk);
222                         bt_accept_unlink(sk);
223                         continue;
224                 }
225
226                 if (sk->sk_state == BT_CONNECTED || !newsock) {
227                         bt_accept_unlink(sk);
228                         if (newsock)
229                                 sock_graft(sk, newsock);
230                         release_sock(sk);
231                         return sk;
232                 }
233
234                 release_sock(sk);
235         }
236         return NULL;
237 }
238 EXPORT_SYMBOL(bt_accept_dequeue);
239
240 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
241         struct msghdr *msg, size_t len, int flags)
242 {
243         int noblock = flags & MSG_DONTWAIT;
244         struct sock *sk = sock->sk;
245         struct sk_buff *skb;
246         size_t copied;
247         int err;
248
249         BT_DBG("sock %p sk %p len %d", sock, sk, len);
250
251         if (flags & (MSG_OOB))
252                 return -EOPNOTSUPP;
253
254         if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
255                 if (sk->sk_shutdown & RCV_SHUTDOWN)
256                         return 0;
257                 return err;
258         }
259
260         msg->msg_namelen = 0;
261
262         copied = skb->len;
263         if (len < copied) {
264                 msg->msg_flags |= MSG_TRUNC;
265                 copied = len;
266         }
267
268         skb_reset_transport_header(skb);
269         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
270         if (err == 0)
271                 sock_recv_timestamp(msg, sk, skb);
272
273         skb_free_datagram(sk, skb);
274
275         return err ? : copied;
276 }
277 EXPORT_SYMBOL(bt_sock_recvmsg);
278
279 static inline unsigned int bt_accept_poll(struct sock *parent)
280 {
281         struct list_head *p, *n;
282         struct sock *sk;
283
284         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
285                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
286                 if (sk->sk_state == BT_CONNECTED)
287                         return POLLIN | POLLRDNORM;
288         }
289
290         return 0;
291 }
292
293 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
294 {
295         struct sock *sk = sock->sk;
296         unsigned int mask = 0;
297
298         BT_DBG("sock %p, sk %p", sock, sk);
299
300         poll_wait(file, sk->sk_sleep, wait);
301
302         if (sk->sk_state == BT_LISTEN)
303                 return bt_accept_poll(sk);
304
305         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
306                 mask |= POLLERR;
307
308         if (sk->sk_shutdown & RCV_SHUTDOWN)
309                 mask |= POLLRDHUP;
310
311         if (sk->sk_shutdown == SHUTDOWN_MASK)
312                 mask |= POLLHUP;
313
314         if (!skb_queue_empty(&sk->sk_receive_queue) ||
315                         (sk->sk_shutdown & RCV_SHUTDOWN))
316                 mask |= POLLIN | POLLRDNORM;
317
318         if (sk->sk_state == BT_CLOSED)
319                 mask |= POLLHUP;
320
321         if (sk->sk_state == BT_CONNECT ||
322                         sk->sk_state == BT_CONNECT2 ||
323                         sk->sk_state == BT_CONFIG)
324                 return mask;
325
326         if (sock_writeable(sk))
327                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
328         else
329                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
330
331         return mask;
332 }
333 EXPORT_SYMBOL(bt_sock_poll);
334
335 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
336 {
337         struct sock *sk = sock->sk;
338         int err;
339
340         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
341
342         switch (cmd) {
343         case SIOCGSTAMP:
344                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
345                 break;
346
347         case SIOCGSTAMPNS:
348                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
349                 break;
350
351         default:
352                 err = -ENOIOCTLCMD;
353                 break;
354         }
355
356         return err;
357 }
358 EXPORT_SYMBOL(bt_sock_ioctl);
359
360 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
361 {
362         DECLARE_WAITQUEUE(wait, current);
363         int err = 0;
364
365         BT_DBG("sk %p", sk);
366
367         add_wait_queue(sk->sk_sleep, &wait);
368         while (sk->sk_state != state) {
369                 set_current_state(TASK_INTERRUPTIBLE);
370
371                 if (!timeo) {
372                         err = -EINPROGRESS;
373                         break;
374                 }
375
376                 if (signal_pending(current)) {
377                         err = sock_intr_errno(timeo);
378                         break;
379                 }
380
381                 release_sock(sk);
382                 timeo = schedule_timeout(timeo);
383                 lock_sock(sk);
384
385                 err = sock_error(sk);
386                 if (err)
387                         break;
388         }
389         set_current_state(TASK_RUNNING);
390         remove_wait_queue(sk->sk_sleep, &wait);
391         return err;
392 }
393 EXPORT_SYMBOL(bt_sock_wait_state);
394
395 static struct net_proto_family bt_sock_family_ops = {
396         .owner  = THIS_MODULE,
397         .family = PF_BLUETOOTH,
398         .create = bt_sock_create,
399 };
400
401 static int __init bt_init(void)
402 {
403         int err;
404
405         BT_INFO("Core ver %s", VERSION);
406
407         err = bt_sysfs_init();
408         if (err < 0)
409                 return err;
410
411         err = sock_register(&bt_sock_family_ops);
412         if (err < 0) {
413                 bt_sysfs_cleanup();
414                 return err;
415         }
416
417         BT_INFO("HCI device and connection manager initialized");
418
419         hci_sock_init();
420
421         return 0;
422 }
423
424 static void __exit bt_exit(void)
425 {
426         hci_sock_cleanup();
427
428         sock_unregister(PF_BLUETOOTH);
429
430         bt_sysfs_cleanup();
431 }
432
433 subsys_initcall(bt_init);
434 module_exit(bt_exit);
435
436 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
437 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
438 MODULE_VERSION(VERSION);
439 MODULE_LICENSE("GPL");
440 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);