1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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/skbuff.h>
35#include <linux/init.h>
36#include <linux/poll.h>
37#include <net/sock.h>
38#include <asm/ioctls.h>
39#include <linux/kmod.h>
40
41#include <net/bluetooth/bluetooth.h>
42
43#define VERSION "2.16"
44
45
46#define BT_MAX_PROTO 8
47static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
48static DEFINE_RWLOCK(bt_proto_lock);
49
50static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
51static const char *const bt_key_strings[BT_MAX_PROTO] = {
52 "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
62static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
63static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
64 "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};
73
74void bt_sock_reclassify_lock(struct sock *sk, int proto)
75{
76 BUG_ON(!sk);
77 BUG_ON(sock_owned_by_user(sk));
78
79 sock_lock_init_class_and_name(sk,
80 bt_slock_key_strings[proto], &bt_slock_key[proto],
81 bt_key_strings[proto], &bt_lock_key[proto]);
82}
83EXPORT_SYMBOL(bt_sock_reclassify_lock);
84
85int bt_sock_register(int proto, const struct net_proto_family *ops)
86{
87 int err = 0;
88
89 if (proto < 0 || proto >= BT_MAX_PROTO)
90 return -EINVAL;
91
92 write_lock(&bt_proto_lock);
93
94 if (bt_proto[proto])
95 err = -EEXIST;
96 else
97 bt_proto[proto] = ops;
98
99 write_unlock(&bt_proto_lock);
100
101 return err;
102}
103EXPORT_SYMBOL(bt_sock_register);
104
105int bt_sock_unregister(int proto)
106{
107 int err = 0;
108
109 if (proto < 0 || proto >= BT_MAX_PROTO)
110 return -EINVAL;
111
112 write_lock(&bt_proto_lock);
113
114 if (!bt_proto[proto])
115 err = -ENOENT;
116 else
117 bt_proto[proto] = NULL;
118
119 write_unlock(&bt_proto_lock);
120
121 return err;
122}
123EXPORT_SYMBOL(bt_sock_unregister);
124
125static int bt_sock_create(struct net *net, struct socket *sock, int proto,
126 int kern)
127{
128 int err;
129
130 if (net != &init_net)
131 return -EAFNOSUPPORT;
132
133 if (proto < 0 || proto >= BT_MAX_PROTO)
134 return -EINVAL;
135
136 if (!bt_proto[proto])
137 request_module("bt-proto-%d", proto);
138
139 err = -EPROTONOSUPPORT;
140
141 read_lock(&bt_proto_lock);
142
143 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
144 err = bt_proto[proto]->create(net, sock, proto, kern);
145 if (!err)
146 bt_sock_reclassify_lock(sock->sk, proto);
147 module_put(bt_proto[proto]->owner);
148 }
149
150 read_unlock(&bt_proto_lock);
151
152 return err;
153}
154
155void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
156{
157 write_lock(&l->lock);
158 sk_add_node(sk, &l->head);
159 write_unlock(&l->lock);
160}
161EXPORT_SYMBOL(bt_sock_link);
162
163void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
164{
165 write_lock(&l->lock);
166 sk_del_node_init(sk);
167 write_unlock(&l->lock);
168}
169EXPORT_SYMBOL(bt_sock_unlink);
170
171void bt_accept_enqueue(struct sock *parent, struct sock *sk)
172{
173 BT_DBG("parent %p, sk %p", parent, sk);
174
175 sock_hold(sk);
176 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
177 bt_sk(sk)->parent = parent;
178 parent->sk_ack_backlog++;
179}
180EXPORT_SYMBOL(bt_accept_enqueue);
181
182void bt_accept_unlink(struct sock *sk)
183{
184 BT_DBG("sk %p state %d", sk, sk->sk_state);
185
186 list_del_init(&bt_sk(sk)->accept_q);
187 bt_sk(sk)->parent->sk_ack_backlog--;
188 bt_sk(sk)->parent = NULL;
189 sock_put(sk);
190}
191EXPORT_SYMBOL(bt_accept_unlink);
192
193struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
194{
195 struct list_head *p, *n;
196 struct sock *sk;
197
198 BT_DBG("parent %p", parent);
199
200 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
201 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
202
203 lock_sock(sk);
204
205
206 if (sk->sk_state == BT_CLOSED) {
207 release_sock(sk);
208 bt_accept_unlink(sk);
209 continue;
210 }
211
212 if (sk->sk_state == BT_CONNECTED || !newsock ||
213 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
214 bt_accept_unlink(sk);
215 if (newsock)
216 sock_graft(sk, newsock);
217
218 release_sock(sk);
219 return sk;
220 }
221
222 release_sock(sk);
223 }
224
225 return NULL;
226}
227EXPORT_SYMBOL(bt_accept_dequeue);
228
229int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
230 struct msghdr *msg, size_t len, int flags)
231{
232 int noblock = flags & MSG_DONTWAIT;
233 struct sock *sk = sock->sk;
234 struct sk_buff *skb;
235 size_t copied;
236 int err;
237
238 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
239
240 if (flags & (MSG_OOB))
241 return -EOPNOTSUPP;
242
243 skb = skb_recv_datagram(sk, flags, noblock, &err);
244 if (!skb) {
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}
267EXPORT_SYMBOL(bt_sock_recvmsg);
268
269static long bt_sock_data_wait(struct sock *sk, long timeo)
270{
271 DECLARE_WAITQUEUE(wait, current);
272
273 add_wait_queue(sk_sleep(sk), &wait);
274 for (;;) {
275 set_current_state(TASK_INTERRUPTIBLE);
276
277 if (!skb_queue_empty(&sk->sk_receive_queue))
278 break;
279
280 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
281 break;
282
283 if (signal_pending(current) || !timeo)
284 break;
285
286 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
287 release_sock(sk);
288 timeo = schedule_timeout(timeo);
289 lock_sock(sk);
290 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
291 }
292
293 __set_current_state(TASK_RUNNING);
294 remove_wait_queue(sk_sleep(sk), &wait);
295 return timeo;
296}
297
298int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
299 struct msghdr *msg, size_t size, int flags)
300{
301 struct sock *sk = sock->sk;
302 int err = 0;
303 size_t target, copied = 0;
304 long timeo;
305
306 if (flags & MSG_OOB)
307 return -EOPNOTSUPP;
308
309 msg->msg_namelen = 0;
310
311 BT_DBG("sk %p size %zu", sk, size);
312
313 lock_sock(sk);
314
315 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
316 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
317
318 do {
319 struct sk_buff *skb;
320 int chunk;
321
322 skb = skb_dequeue(&sk->sk_receive_queue);
323 if (!skb) {
324 if (copied >= target)
325 break;
326
327 err = sock_error(sk);
328 if (err)
329 break;
330 if (sk->sk_shutdown & RCV_SHUTDOWN)
331 break;
332
333 err = -EAGAIN;
334 if (!timeo)
335 break;
336
337 timeo = bt_sock_data_wait(sk, timeo);
338
339 if (signal_pending(current)) {
340 err = sock_intr_errno(timeo);
341 goto out;
342 }
343 continue;
344 }
345
346 chunk = min_t(unsigned int, skb->len, size);
347 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
348 skb_queue_head(&sk->sk_receive_queue, skb);
349 if (!copied)
350 copied = -EFAULT;
351 break;
352 }
353 copied += chunk;
354 size -= chunk;
355
356 sock_recv_ts_and_drops(msg, sk, skb);
357
358 if (!(flags & MSG_PEEK)) {
359 int skb_len = skb_headlen(skb);
360
361 if (chunk <= skb_len) {
362 __skb_pull(skb, chunk);
363 } else {
364 struct sk_buff *frag;
365
366 __skb_pull(skb, skb_len);
367 chunk -= skb_len;
368
369 skb_walk_frags(skb, frag) {
370 if (chunk <= frag->len) {
371
372 skb->len -= chunk;
373 skb->data_len -= chunk;
374 __skb_pull(frag, chunk);
375 break;
376 } else if (frag->len) {
377
378 chunk -= frag->len;
379 skb->len -= frag->len;
380 skb->data_len -= frag->len;
381 __skb_pull(frag, frag->len);
382 }
383 }
384 }
385
386 if (skb->len) {
387 skb_queue_head(&sk->sk_receive_queue, skb);
388 break;
389 }
390 kfree_skb(skb);
391
392 } else {
393
394 skb_queue_head(&sk->sk_receive_queue, skb);
395 break;
396 }
397 } while (size);
398
399out:
400 release_sock(sk);
401 return copied ? : err;
402}
403EXPORT_SYMBOL(bt_sock_stream_recvmsg);
404
405static inline unsigned int bt_accept_poll(struct sock *parent)
406{
407 struct list_head *p, *n;
408 struct sock *sk;
409
410 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
411 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
412 if (sk->sk_state == BT_CONNECTED ||
413 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
414 sk->sk_state == BT_CONNECT2))
415 return POLLIN | POLLRDNORM;
416 }
417
418 return 0;
419}
420
421unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait)
422{
423 struct sock *sk = sock->sk;
424 unsigned int mask = 0;
425
426 BT_DBG("sock %p, sk %p", sock, sk);
427
428 poll_wait(file, sk_sleep(sk), wait);
429
430 if (sk->sk_state == BT_LISTEN)
431 return bt_accept_poll(sk);
432
433 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
434 mask |= POLLERR;
435
436 if (sk->sk_shutdown & RCV_SHUTDOWN)
437 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
438
439 if (sk->sk_shutdown == SHUTDOWN_MASK)
440 mask |= POLLHUP;
441
442 if (!skb_queue_empty(&sk->sk_receive_queue))
443 mask |= POLLIN | POLLRDNORM;
444
445 if (sk->sk_state == BT_CLOSED)
446 mask |= POLLHUP;
447
448 if (sk->sk_state == BT_CONNECT ||
449 sk->sk_state == BT_CONNECT2 ||
450 sk->sk_state == BT_CONFIG)
451 return mask;
452
453 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
454 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
455 else
456 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
457
458 return mask;
459}
460EXPORT_SYMBOL(bt_sock_poll);
461
462int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
463{
464 struct sock *sk = sock->sk;
465 struct sk_buff *skb;
466 long amount;
467 int err;
468
469 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
470
471 switch (cmd) {
472 case TIOCOUTQ:
473 if (sk->sk_state == BT_LISTEN)
474 return -EINVAL;
475
476 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
477 if (amount < 0)
478 amount = 0;
479 err = put_user(amount, (int __user *) arg);
480 break;
481
482 case TIOCINQ:
483 if (sk->sk_state == BT_LISTEN)
484 return -EINVAL;
485
486 lock_sock(sk);
487 skb = skb_peek(&sk->sk_receive_queue);
488 amount = skb ? skb->len : 0;
489 release_sock(sk);
490 err = put_user(amount, (int __user *) arg);
491 break;
492
493 case SIOCGSTAMP:
494 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
495 break;
496
497 case SIOCGSTAMPNS:
498 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
499 break;
500
501 default:
502 err = -ENOIOCTLCMD;
503 break;
504 }
505
506 return err;
507}
508EXPORT_SYMBOL(bt_sock_ioctl);
509
510int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
511{
512 DECLARE_WAITQUEUE(wait, current);
513 int err = 0;
514
515 BT_DBG("sk %p", sk);
516
517 add_wait_queue(sk_sleep(sk), &wait);
518 set_current_state(TASK_INTERRUPTIBLE);
519 while (sk->sk_state != state) {
520 if (!timeo) {
521 err = -EINPROGRESS;
522 break;
523 }
524
525 if (signal_pending(current)) {
526 err = sock_intr_errno(timeo);
527 break;
528 }
529
530 release_sock(sk);
531 timeo = schedule_timeout(timeo);
532 lock_sock(sk);
533 set_current_state(TASK_INTERRUPTIBLE);
534
535 err = sock_error(sk);
536 if (err)
537 break;
538 }
539 __set_current_state(TASK_RUNNING);
540 remove_wait_queue(sk_sleep(sk), &wait);
541 return err;
542}
543EXPORT_SYMBOL(bt_sock_wait_state);
544
545static struct net_proto_family bt_sock_family_ops = {
546 .owner = THIS_MODULE,
547 .family = PF_BLUETOOTH,
548 .create = bt_sock_create,
549};
550
551static int __init bt_init(void)
552{
553 int err;
554
555 BT_INFO("Core ver %s", VERSION);
556
557 err = bt_sysfs_init();
558 if (err < 0)
559 return err;
560
561 err = sock_register(&bt_sock_family_ops);
562 if (err < 0) {
563 bt_sysfs_cleanup();
564 return err;
565 }
566
567 BT_INFO("HCI device and connection manager initialized");
568
569 err = hci_sock_init();
570 if (err < 0)
571 goto error;
572
573 err = l2cap_init();
574 if (err < 0)
575 goto sock_err;
576
577 err = sco_init();
578 if (err < 0) {
579 l2cap_exit();
580 goto sock_err;
581 }
582
583 return 0;
584
585sock_err:
586 hci_sock_cleanup();
587
588error:
589 sock_unregister(PF_BLUETOOTH);
590 bt_sysfs_cleanup();
591
592 return err;
593}
594
595static void __exit bt_exit(void)
596{
597
598 sco_exit();
599
600 l2cap_exit();
601
602 hci_sock_cleanup();
603
604 sock_unregister(PF_BLUETOOTH);
605
606 bt_sysfs_cleanup();
607}
608
609subsys_initcall(bt_init);
610module_exit(bt_exit);
611
612MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
613MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
614MODULE_VERSION(VERSION);
615MODULE_LICENSE("GPL");
616MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
617
