blob: 062124cd89cf2a560cff39b80b7f3cbcdb66c1a3 [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 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
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090015 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090020 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth address family and sockets. */
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/skbuff.h>
35#include <linux/init.h>
36#include <linux/poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <net/sock.h>
Marcel Holtmann3241ad82008-07-14 20:13:50 +020038#include <asm/ioctls.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/kmod.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
41#include <net/bluetooth/bluetooth.h>
42
Gustavo F. Padovan64274512011-02-07 20:08:52 -020043#define VERSION "2.16"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45/* Bluetooth sockets */
46#define BT_MAX_PROTO 8
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +000047static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010048static DEFINE_RWLOCK(bt_proto_lock);
Dave Young68845cb2008-04-01 23:58:35 -070049
Dave Young68845cb2008-04-01 23:58:35 -070050static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -070051static const char *const bt_key_strings[BT_MAX_PROTO] = {
Dave Young68845cb2008-04-01 23:58:35 -070052 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
53 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
54 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
55 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
56 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
57 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
58 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
59 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
60};
61
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010062static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -070063static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
Dave Young68845cb2008-04-01 23:58:35 -070064 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
65 "slock-AF_BLUETOOTH-BTPROTO_HCI",
66 "slock-AF_BLUETOOTH-BTPROTO_SCO",
67 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
68 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
69 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
70 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
71 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
72};
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010073
74static inline void bt_sock_reclassify_lock(struct socket *sock, int proto)
75{
76 struct sock *sk = sock->sk;
77
78 if (!sk)
79 return;
80
81 BUG_ON(sock_owned_by_user(sk));
82
83 sock_lock_init_class_and_name(sk,
84 bt_slock_key_strings[proto], &bt_slock_key[proto],
85 bt_key_strings[proto], &bt_lock_key[proto]);
86}
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +000088int bt_sock_register(int proto, const struct net_proto_family *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -070089{
Marcel Holtmann74da6262006-10-15 17:31:14 +020090 int err = 0;
91
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 if (proto < 0 || proto >= BT_MAX_PROTO)
93 return -EINVAL;
94
Marcel Holtmann74da6262006-10-15 17:31:14 +020095 write_lock(&bt_proto_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Marcel Holtmann74da6262006-10-15 17:31:14 +020097 if (bt_proto[proto])
98 err = -EEXIST;
99 else
100 bt_proto[proto] = ops;
101
102 write_unlock(&bt_proto_lock);
103
104 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105}
106EXPORT_SYMBOL(bt_sock_register);
107
108int bt_sock_unregister(int proto)
109{
Marcel Holtmann74da6262006-10-15 17:31:14 +0200110 int err = 0;
111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 if (proto < 0 || proto >= BT_MAX_PROTO)
113 return -EINVAL;
114
Marcel Holtmann74da6262006-10-15 17:31:14 +0200115 write_lock(&bt_proto_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
Marcel Holtmann74da6262006-10-15 17:31:14 +0200117 if (!bt_proto[proto])
118 err = -ENOENT;
119 else
120 bt_proto[proto] = NULL;
121
122 write_unlock(&bt_proto_lock);
123
124 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125}
126EXPORT_SYMBOL(bt_sock_unregister);
127
Eric Paris3f378b62009-11-05 22:18:14 -0800128static int bt_sock_create(struct net *net, struct socket *sock, int proto,
129 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130{
Marcel Holtmann74da6262006-10-15 17:31:14 +0200131 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700133 if (net != &init_net)
134 return -EAFNOSUPPORT;
135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 if (proto < 0 || proto >= BT_MAX_PROTO)
137 return -EINVAL;
138
Johannes Berg95a5afc2008-10-16 15:24:51 -0700139 if (!bt_proto[proto])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 request_module("bt-proto-%d", proto);
Marcel Holtmann74da6262006-10-15 17:31:14 +0200141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 err = -EPROTONOSUPPORT;
Marcel Holtmann74da6262006-10-15 17:31:14 +0200143
144 read_lock(&bt_proto_lock);
145
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
Eric Paris3f378b62009-11-05 22:18:14 -0800147 err = bt_proto[proto]->create(net, sock, proto, kern);
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +0100148 bt_sock_reclassify_lock(sock, proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 module_put(bt_proto[proto]->owner);
150 }
Marcel Holtmann74da6262006-10-15 17:31:14 +0200151
152 read_unlock(&bt_proto_lock);
153
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900154 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155}
156
157void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
158{
159 write_lock_bh(&l->lock);
160 sk_add_node(sk, &l->head);
161 write_unlock_bh(&l->lock);
162}
163EXPORT_SYMBOL(bt_sock_link);
164
165void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
166{
167 write_lock_bh(&l->lock);
168 sk_del_node_init(sk);
169 write_unlock_bh(&l->lock);
170}
171EXPORT_SYMBOL(bt_sock_unlink);
172
173void bt_accept_enqueue(struct sock *parent, struct sock *sk)
174{
175 BT_DBG("parent %p, sk %p", parent, sk);
176
177 sock_hold(sk);
178 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
179 bt_sk(sk)->parent = parent;
180 parent->sk_ack_backlog++;
181}
182EXPORT_SYMBOL(bt_accept_enqueue);
183
184void bt_accept_unlink(struct sock *sk)
185{
186 BT_DBG("sk %p state %d", sk, sk->sk_state);
187
188 list_del_init(&bt_sk(sk)->accept_q);
189 bt_sk(sk)->parent->sk_ack_backlog--;
190 bt_sk(sk)->parent = NULL;
191 sock_put(sk);
192}
193EXPORT_SYMBOL(bt_accept_unlink);
194
195struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
196{
197 struct list_head *p, *n;
198 struct sock *sk;
199
200 BT_DBG("parent %p", parent);
201
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200202 local_bh_disable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
204 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
205
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200206 bh_lock_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
208 /* FIXME: Is this check still needed */
209 if (sk->sk_state == BT_CLOSED) {
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200210 bh_unlock_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 bt_accept_unlink(sk);
212 continue;
213 }
214
Marcel Holtmannc4f912e2009-01-15 21:52:16 +0100215 if (sk->sk_state == BT_CONNECTED || !newsock ||
216 bt_sk(parent)->defer_setup) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 bt_accept_unlink(sk);
218 if (newsock)
219 sock_graft(sk, newsock);
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200220
221 bh_unlock_sock(sk);
222 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 return sk;
224 }
225
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200226 bh_unlock_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 }
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200228 local_bh_enable();
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 return NULL;
231}
232EXPORT_SYMBOL(bt_accept_dequeue);
233
234int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
Marcel Holtmannc4f912e2009-01-15 21:52:16 +0100235 struct msghdr *msg, size_t len, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
237 int noblock = flags & MSG_DONTWAIT;
238 struct sock *sk = sock->sk;
239 struct sk_buff *skb;
240 size_t copied;
241 int err;
242
Marcel Holtmanna418b892008-11-30 12:17:28 +0100243 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245 if (flags & (MSG_OOB))
246 return -EOPNOTSUPP;
247
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200248 skb = skb_recv_datagram(sk, flags, noblock, &err);
249 if (!skb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 if (sk->sk_shutdown & RCV_SHUTDOWN)
251 return 0;
252 return err;
253 }
254
255 msg->msg_namelen = 0;
256
257 copied = skb->len;
258 if (len < copied) {
259 msg->msg_flags |= MSG_TRUNC;
260 copied = len;
261 }
262
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -0300263 skb_reset_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200265 if (err == 0)
Neil Horman3b885782009-10-12 13:26:31 -0700266 sock_recv_ts_and_drops(msg, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 skb_free_datagram(sk, skb);
269
270 return err ? : copied;
271}
272EXPORT_SYMBOL(bt_sock_recvmsg);
273
Mat Martineau796c86e2010-09-08 10:05:27 -0700274static long bt_sock_data_wait(struct sock *sk, long timeo)
275{
276 DECLARE_WAITQUEUE(wait, current);
277
278 add_wait_queue(sk_sleep(sk), &wait);
279 for (;;) {
280 set_current_state(TASK_INTERRUPTIBLE);
281
282 if (!skb_queue_empty(&sk->sk_receive_queue))
283 break;
284
285 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
286 break;
287
288 if (signal_pending(current) || !timeo)
289 break;
290
291 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
292 release_sock(sk);
293 timeo = schedule_timeout(timeo);
294 lock_sock(sk);
295 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
296 }
297
298 __set_current_state(TASK_RUNNING);
299 remove_wait_queue(sk_sleep(sk), &wait);
300 return timeo;
301}
302
303int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
304 struct msghdr *msg, size_t size, int flags)
305{
306 struct sock *sk = sock->sk;
307 int err = 0;
308 size_t target, copied = 0;
309 long timeo;
310
311 if (flags & MSG_OOB)
312 return -EOPNOTSUPP;
313
314 msg->msg_namelen = 0;
315
316 BT_DBG("sk %p size %zu", sk, size);
317
318 lock_sock(sk);
319
320 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
321 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
322
323 do {
324 struct sk_buff *skb;
325 int chunk;
326
327 skb = skb_dequeue(&sk->sk_receive_queue);
328 if (!skb) {
329 if (copied >= target)
330 break;
331
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200332 err = sock_error(sk);
333 if (err)
Mat Martineau796c86e2010-09-08 10:05:27 -0700334 break;
335 if (sk->sk_shutdown & RCV_SHUTDOWN)
336 break;
337
338 err = -EAGAIN;
339 if (!timeo)
340 break;
341
342 timeo = bt_sock_data_wait(sk, timeo);
343
344 if (signal_pending(current)) {
345 err = sock_intr_errno(timeo);
346 goto out;
347 }
348 continue;
349 }
350
351 chunk = min_t(unsigned int, skb->len, size);
Mat Martineau5b668eb2011-07-22 14:53:59 -0700352 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
Mat Martineau796c86e2010-09-08 10:05:27 -0700353 skb_queue_head(&sk->sk_receive_queue, skb);
354 if (!copied)
355 copied = -EFAULT;
356 break;
357 }
358 copied += chunk;
359 size -= chunk;
360
361 sock_recv_ts_and_drops(msg, sk, skb);
362
363 if (!(flags & MSG_PEEK)) {
Mat Martineau5b668eb2011-07-22 14:53:59 -0700364 int skb_len = skb_headlen(skb);
365
366 if (chunk <= skb_len) {
367 __skb_pull(skb, chunk);
368 } else {
369 struct sk_buff *frag;
370
371 __skb_pull(skb, skb_len);
372 chunk -= skb_len;
373
374 skb_walk_frags(skb, frag) {
375 if (chunk <= frag->len) {
376 /* Pulling partial data */
377 skb->len -= chunk;
378 skb->data_len -= chunk;
379 __skb_pull(frag, chunk);
380 break;
381 } else if (frag->len) {
382 /* Pulling all frag data */
383 chunk -= frag->len;
384 skb->len -= frag->len;
385 skb->data_len -= frag->len;
386 __skb_pull(frag, frag->len);
387 }
388 }
389 }
390
Mat Martineau796c86e2010-09-08 10:05:27 -0700391 if (skb->len) {
392 skb_queue_head(&sk->sk_receive_queue, skb);
393 break;
394 }
395 kfree_skb(skb);
396
397 } else {
398 /* put message back and return */
399 skb_queue_head(&sk->sk_receive_queue, skb);
400 break;
401 }
402 } while (size);
403
404out:
405 release_sock(sk);
406 return copied ? : err;
407}
408EXPORT_SYMBOL(bt_sock_stream_recvmsg);
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410static inline unsigned int bt_accept_poll(struct sock *parent)
411{
412 struct list_head *p, *n;
413 struct sock *sk;
414
415 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
416 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
Marcel Holtmannd5f2d2b2009-02-16 02:57:30 +0100417 if (sk->sk_state == BT_CONNECTED ||
418 (bt_sk(parent)->defer_setup &&
419 sk->sk_state == BT_CONNECT2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 return POLLIN | POLLRDNORM;
421 }
422
423 return 0;
424}
425
Gustavo F. Padovan8ffd8782011-02-17 19:24:05 -0300426unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427{
428 struct sock *sk = sock->sk;
429 unsigned int mask = 0;
430
431 BT_DBG("sock %p, sk %p", sock, sk);
432
Eric Dumazetaa395142010-04-20 13:03:51 +0000433 poll_wait(file, sk_sleep(sk), wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
435 if (sk->sk_state == BT_LISTEN)
436 return bt_accept_poll(sk);
437
438 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
439 mask |= POLLERR;
440
Davide Libenzif348d702006-03-25 03:07:39 -0800441 if (sk->sk_shutdown & RCV_SHUTDOWN)
Eric Dumazetdb409802010-09-06 11:13:50 +0000442 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
Davide Libenzif348d702006-03-25 03:07:39 -0800443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 if (sk->sk_shutdown == SHUTDOWN_MASK)
445 mask |= POLLHUP;
446
Eric Dumazetdb409802010-09-06 11:13:50 +0000447 if (!skb_queue_empty(&sk->sk_receive_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 mask |= POLLIN | POLLRDNORM;
449
450 if (sk->sk_state == BT_CLOSED)
451 mask |= POLLHUP;
452
453 if (sk->sk_state == BT_CONNECT ||
454 sk->sk_state == BT_CONNECT2 ||
455 sk->sk_state == BT_CONFIG)
456 return mask;
457
458 if (sock_writeable(sk))
459 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
460 else
461 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
462
463 return mask;
464}
465EXPORT_SYMBOL(bt_sock_poll);
466
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200467int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
468{
469 struct sock *sk = sock->sk;
Marcel Holtmann43cbeee2008-07-14 20:13:51 +0200470 struct sk_buff *skb;
471 long amount;
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200472 int err;
473
474 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
475
476 switch (cmd) {
Marcel Holtmann43cbeee2008-07-14 20:13:51 +0200477 case TIOCOUTQ:
478 if (sk->sk_state == BT_LISTEN)
479 return -EINVAL;
480
Eric Dumazet31e6d362009-06-17 19:05:41 -0700481 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
Marcel Holtmann43cbeee2008-07-14 20:13:51 +0200482 if (amount < 0)
483 amount = 0;
484 err = put_user(amount, (int __user *) arg);
485 break;
486
487 case TIOCINQ:
488 if (sk->sk_state == BT_LISTEN)
489 return -EINVAL;
490
491 lock_sock(sk);
492 skb = skb_peek(&sk->sk_receive_queue);
493 amount = skb ? skb->len : 0;
494 release_sock(sk);
495 err = put_user(amount, (int __user *) arg);
496 break;
497
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200498 case SIOCGSTAMP:
499 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
500 break;
501
502 case SIOCGSTAMPNS:
503 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
504 break;
505
506 default:
507 err = -ENOIOCTLCMD;
508 break;
509 }
510
511 return err;
512}
513EXPORT_SYMBOL(bt_sock_ioctl);
514
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
516{
517 DECLARE_WAITQUEUE(wait, current);
518 int err = 0;
519
520 BT_DBG("sk %p", sk);
521
Eric Dumazetaa395142010-04-20 13:03:51 +0000522 add_wait_queue(sk_sleep(sk), &wait);
Peter Hurley9be4e3f2011-07-24 00:10:46 -0400523 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 while (sk->sk_state != state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (!timeo) {
Marcel Holtmannb4c612a2006-09-23 09:54:38 +0200526 err = -EINPROGRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 break;
528 }
529
530 if (signal_pending(current)) {
531 err = sock_intr_errno(timeo);
532 break;
533 }
534
535 release_sock(sk);
536 timeo = schedule_timeout(timeo);
537 lock_sock(sk);
Peter Hurley9be4e3f2011-07-24 00:10:46 -0400538 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Benjamin LaHaisec1cbe4b2005-12-13 23:22:19 -0800540 err = sock_error(sk);
541 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 }
Peter Hurley9be4e3f2011-07-24 00:10:46 -0400544 __set_current_state(TASK_RUNNING);
Eric Dumazetaa395142010-04-20 13:03:51 +0000545 remove_wait_queue(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 return err;
547}
548EXPORT_SYMBOL(bt_sock_wait_state);
549
550static struct net_proto_family bt_sock_family_ops = {
551 .owner = THIS_MODULE,
552 .family = PF_BLUETOOTH,
553 .create = bt_sock_create,
554};
555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556static int __init bt_init(void)
557{
Marcel Holtmann27d35282006-07-03 10:02:37 +0200558 int err;
559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 BT_INFO("Core ver %s", VERSION);
561
Marcel Holtmann27d35282006-07-03 10:02:37 +0200562 err = bt_sysfs_init();
563 if (err < 0)
564 return err;
565
566 err = sock_register(&bt_sock_family_ops);
567 if (err < 0) {
568 bt_sysfs_cleanup();
569 return err;
570 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
572 BT_INFO("HCI device and connection manager initialized");
573
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200574 err = hci_sock_init();
575 if (err < 0)
576 goto error;
577
578 err = l2cap_init();
Anand Gadiyar0ed54da2011-02-22 12:43:26 +0530579 if (err < 0)
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200580 goto sock_err;
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200581
582 err = sco_init();
583 if (err < 0) {
584 l2cap_exit();
585 goto sock_err;
586 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 return 0;
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200589
590sock_err:
591 hci_sock_cleanup();
592
593error:
594 sock_unregister(PF_BLUETOOTH);
595 bt_sysfs_cleanup();
596
597 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598}
599
600static void __exit bt_exit(void)
601{
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200602
603 sco_exit();
604
605 l2cap_exit();
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 hci_sock_cleanup();
608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 sock_unregister(PF_BLUETOOTH);
Marcel Holtmann27d35282006-07-03 10:02:37 +0200610
611 bt_sysfs_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612}
613
614subsys_initcall(bt_init);
615module_exit(bt_exit);
616
Marcel Holtmann63fbd242008-08-18 13:23:53 +0200617MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
619MODULE_VERSION(VERSION);
620MODULE_LICENSE("GPL");
621MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);