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