[Bluetooth] Consolidate maintainers information
[linux-2.6.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.12"
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         struct sk_buff *skb;
339         long amount;
340         int err;
341
342         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
343
344         switch (cmd) {
345         case TIOCOUTQ:
346                 if (sk->sk_state == BT_LISTEN)
347                         return -EINVAL;
348
349                 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
350                 if (amount < 0)
351                         amount = 0;
352                 err = put_user(amount, (int __user *) arg);
353                 break;
354
355         case TIOCINQ:
356                 if (sk->sk_state == BT_LISTEN)
357                         return -EINVAL;
358
359                 lock_sock(sk);
360                 skb = skb_peek(&sk->sk_receive_queue);
361                 amount = skb ? skb->len : 0;
362                 release_sock(sk);
363                 err = put_user(amount, (int __user *) arg);
364                 break;
365
366         case SIOCGSTAMP:
367                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
368                 break;
369
370         case SIOCGSTAMPNS:
371                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
372                 break;
373
374         default:
375                 err = -ENOIOCTLCMD;
376                 break;
377         }
378
379         return err;
380 }
381 EXPORT_SYMBOL(bt_sock_ioctl);
382
383 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
384 {
385         DECLARE_WAITQUEUE(wait, current);
386         int err = 0;
387
388         BT_DBG("sk %p", sk);
389
390         add_wait_queue(sk->sk_sleep, &wait);
391         while (sk->sk_state != state) {
392                 set_current_state(TASK_INTERRUPTIBLE);
393
394                 if (!timeo) {
395                         err = -EINPROGRESS;
396                         break;
397                 }
398
399                 if (signal_pending(current)) {
400                         err = sock_intr_errno(timeo);
401                         break;
402                 }
403
404                 release_sock(sk);
405                 timeo = schedule_timeout(timeo);
406                 lock_sock(sk);
407
408                 err = sock_error(sk);
409                 if (err)
410                         break;
411         }
412         set_current_state(TASK_RUNNING);
413         remove_wait_queue(sk->sk_sleep, &wait);
414         return err;
415 }
416 EXPORT_SYMBOL(bt_sock_wait_state);
417
418 static struct net_proto_family bt_sock_family_ops = {
419         .owner  = THIS_MODULE,
420         .family = PF_BLUETOOTH,
421         .create = bt_sock_create,
422 };
423
424 static int __init bt_init(void)
425 {
426         int err;
427
428         BT_INFO("Core ver %s", VERSION);
429
430         err = bt_sysfs_init();
431         if (err < 0)
432                 return err;
433
434         err = sock_register(&bt_sock_family_ops);
435         if (err < 0) {
436                 bt_sysfs_cleanup();
437                 return err;
438         }
439
440         BT_INFO("HCI device and connection manager initialized");
441
442         hci_sock_init();
443
444         return 0;
445 }
446
447 static void __exit bt_exit(void)
448 {
449         hci_sock_cleanup();
450
451         sock_unregister(PF_BLUETOOTH);
452
453         bt_sysfs_cleanup();
454 }
455
456 subsys_initcall(bt_init);
457 module_exit(bt_exit);
458
459 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
460 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
461 MODULE_VERSION(VERSION);
462 MODULE_LICENSE("GPL");
463 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);