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#include <asm/ioctls.h>
29
30#include <net/bluetooth/bluetooth.h>
31#include <linux/proc_fs.h>
32
33#define VERSION "2.16"
34
35
36#define BT_MAX_PROTO 8
37static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
38static DEFINE_RWLOCK(bt_proto_lock);
39
40static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
41static const char *const bt_key_strings[BT_MAX_PROTO] = {
42 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
43 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
44 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
45 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
46 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
47 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
48 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
49 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
50};
51
52static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
53static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
54 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
55 "slock-AF_BLUETOOTH-BTPROTO_HCI",
56 "slock-AF_BLUETOOTH-BTPROTO_SCO",
57 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
58 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
59 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
60 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
61 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
62};
63
64void bt_sock_reclassify_lock(struct sock *sk, int proto)
65{
66 BUG_ON(!sk);
67 BUG_ON(sock_owned_by_user(sk));
68
69 sock_lock_init_class_and_name(sk,
70 bt_slock_key_strings[proto], &bt_slock_key[proto],
71 bt_key_strings[proto], &bt_lock_key[proto]);
72}
73EXPORT_SYMBOL(bt_sock_reclassify_lock);
74
75int bt_sock_register(int proto, const struct net_proto_family *ops)
76{
77 int err = 0;
78
79 if (proto < 0 || proto >= BT_MAX_PROTO)
80 return -EINVAL;
81
82 write_lock(&bt_proto_lock);
83
84 if (bt_proto[proto])
85 err = -EEXIST;
86 else
87 bt_proto[proto] = ops;
88
89 write_unlock(&bt_proto_lock);
90
91 return err;
92}
93EXPORT_SYMBOL(bt_sock_register);
94
95void bt_sock_unregister(int proto)
96{
97 if (proto < 0 || proto >= BT_MAX_PROTO)
98 return;
99
100 write_lock(&bt_proto_lock);
101 bt_proto[proto] = NULL;
102 write_unlock(&bt_proto_lock);
103}
104EXPORT_SYMBOL(bt_sock_unregister);
105
106static int bt_sock_create(struct net *net, struct socket *sock, int proto,
107 int kern)
108{
109 int err;
110
111 if (net != &init_net)
112 return -EAFNOSUPPORT;
113
114 if (proto < 0 || proto >= BT_MAX_PROTO)
115 return -EINVAL;
116
117 if (!bt_proto[proto])
118 request_module("bt-proto-%d", proto);
119
120 err = -EPROTONOSUPPORT;
121
122 read_lock(&bt_proto_lock);
123
124 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
125 err = bt_proto[proto]->create(net, sock, proto, kern);
126 if (!err)
127 bt_sock_reclassify_lock(sock->sk, proto);
128 module_put(bt_proto[proto]->owner);
129 }
130
131 read_unlock(&bt_proto_lock);
132
133 return err;
134}
135
136void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
137{
138 write_lock(&l->lock);
139 sk_add_node(sk, &l->head);
140 write_unlock(&l->lock);
141}
142EXPORT_SYMBOL(bt_sock_link);
143
144void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
145{
146 write_lock(&l->lock);
147 sk_del_node_init(sk);
148 write_unlock(&l->lock);
149}
150EXPORT_SYMBOL(bt_sock_unlink);
151
152void bt_accept_enqueue(struct sock *parent, struct sock *sk)
153{
154 BT_DBG("parent %p, sk %p", parent, sk);
155
156 sock_hold(sk);
157 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
158 bt_sk(sk)->parent = parent;
159 parent->sk_ack_backlog++;
160}
161EXPORT_SYMBOL(bt_accept_enqueue);
162
163void bt_accept_unlink(struct sock *sk)
164{
165 BT_DBG("sk %p state %d", sk, sk->sk_state);
166
167 list_del_init(&bt_sk(sk)->accept_q);
168 bt_sk(sk)->parent->sk_ack_backlog--;
169 bt_sk(sk)->parent = NULL;
170 sock_put(sk);
171}
172EXPORT_SYMBOL(bt_accept_unlink);
173
174struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
175{
176 struct list_head *p, *n;
177 struct sock *sk;
178
179 BT_DBG("parent %p", parent);
180
181 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
182 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
183
184 lock_sock(sk);
185
186
187 if (sk->sk_state == BT_CLOSED) {
188 release_sock(sk);
189 bt_accept_unlink(sk);
190 continue;
191 }
192
193 if (sk->sk_state == BT_CONNECTED || !newsock ||
194 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
195 bt_accept_unlink(sk);
196 if (newsock)
197 sock_graft(sk, newsock);
198
199 release_sock(sk);
200 return sk;
201 }
202
203 release_sock(sk);
204 }
205
206 return NULL;
207}
208EXPORT_SYMBOL(bt_accept_dequeue);
209
210int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
211 struct msghdr *msg, size_t len, int flags)
212{
213 int noblock = flags & MSG_DONTWAIT;
214 struct sock *sk = sock->sk;
215 struct sk_buff *skb;
216 size_t copied;
217 int err;
218
219 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
220
221 if (flags & (MSG_OOB))
222 return -EOPNOTSUPP;
223
224 msg->msg_namelen = 0;
225
226 skb = skb_recv_datagram(sk, flags, noblock, &err);
227 if (!skb) {
228 if (sk->sk_shutdown & RCV_SHUTDOWN)
229 return 0;
230 return err;
231 }
232
233 copied = skb->len;
234 if (len < copied) {
235 msg->msg_flags |= MSG_TRUNC;
236 copied = len;
237 }
238
239 skb_reset_transport_header(skb);
240 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
241 if (err == 0)
242 sock_recv_ts_and_drops(msg, sk, skb);
243
244 skb_free_datagram(sk, skb);
245
246 return err ? : copied;
247}
248EXPORT_SYMBOL(bt_sock_recvmsg);
249
250static long bt_sock_data_wait(struct sock *sk, long timeo)
251{
252 DECLARE_WAITQUEUE(wait, current);
253
254 add_wait_queue(sk_sleep(sk), &wait);
255 for (;;) {
256 set_current_state(TASK_INTERRUPTIBLE);
257
258 if (!skb_queue_empty(&sk->sk_receive_queue))
259 break;
260
261 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
262 break;
263
264 if (signal_pending(current) || !timeo)
265 break;
266
267 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
268 release_sock(sk);
269 timeo = schedule_timeout(timeo);
270 lock_sock(sk);
271 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
272 }
273
274 __set_current_state(TASK_RUNNING);
275 remove_wait_queue(sk_sleep(sk), &wait);
276 return timeo;
277}
278
279int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
280 struct msghdr *msg, size_t size, int flags)
281{
282 struct sock *sk = sock->sk;
283 int err = 0;
284 size_t target, copied = 0;
285 long timeo;
286
287 if (flags & MSG_OOB)
288 return -EOPNOTSUPP;
289
290 msg->msg_namelen = 0;
291
292 BT_DBG("sk %p size %zu", sk, size);
293
294 lock_sock(sk);
295
296 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
297 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
298
299 do {
300 struct sk_buff *skb;
301 int chunk;
302
303 skb = skb_dequeue(&sk->sk_receive_queue);
304 if (!skb) {
305 if (copied >= target)
306 break;
307
308 err = sock_error(sk);
309 if (err)
310 break;
311 if (sk->sk_shutdown & RCV_SHUTDOWN)
312 break;
313
314 err = -EAGAIN;
315 if (!timeo)
316 break;
317
318 timeo = bt_sock_data_wait(sk, timeo);
319
320 if (signal_pending(current)) {
321 err = sock_intr_errno(timeo);
322 goto out;
323 }
324 continue;
325 }
326
327 chunk = min_t(unsigned int, skb->len, size);
328 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
329 skb_queue_head(&sk->sk_receive_queue, skb);
330 if (!copied)
331 copied = -EFAULT;
332 break;
333 }
334 copied += chunk;
335 size -= chunk;
336
337 sock_recv_ts_and_drops(msg, sk, skb);
338
339 if (!(flags & MSG_PEEK)) {
340 int skb_len = skb_headlen(skb);
341
342 if (chunk <= skb_len) {
343 __skb_pull(skb, chunk);
344 } else {
345 struct sk_buff *frag;
346
347 __skb_pull(skb, skb_len);
348 chunk -= skb_len;
349
350 skb_walk_frags(skb, frag) {
351 if (chunk <= frag->len) {
352
353 skb->len -= chunk;
354 skb->data_len -= chunk;
355 __skb_pull(frag, chunk);
356 break;
357 } else if (frag->len) {
358
359 chunk -= frag->len;
360 skb->len -= frag->len;
361 skb->data_len -= frag->len;
362 __skb_pull(frag, frag->len);
363 }
364 }
365 }
366
367 if (skb->len) {
368 skb_queue_head(&sk->sk_receive_queue, skb);
369 break;
370 }
371 kfree_skb(skb);
372
373 } else {
374
375 skb_queue_head(&sk->sk_receive_queue, skb);
376 break;
377 }
378 } while (size);
379
380out:
381 release_sock(sk);
382 return copied ? : err;
383}
384EXPORT_SYMBOL(bt_sock_stream_recvmsg);
385
386static inline unsigned int bt_accept_poll(struct sock *parent)
387{
388 struct list_head *p, *n;
389 struct sock *sk;
390
391 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
392 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
393 if (sk->sk_state == BT_CONNECTED ||
394 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
395 sk->sk_state == BT_CONNECT2))
396 return POLLIN | POLLRDNORM;
397 }
398
399 return 0;
400}
401
402unsigned int bt_sock_poll(struct file *file, struct socket *sock,
403 poll_table *wait)
404{
405 struct sock *sk = sock->sk;
406 unsigned int mask = 0;
407
408 BT_DBG("sock %p, sk %p", sock, sk);
409
410 poll_wait(file, sk_sleep(sk), wait);
411
412 if (sk->sk_state == BT_LISTEN)
413 return bt_accept_poll(sk);
414
415 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
416 mask |= POLLERR |
417 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
418
419 if (sk->sk_shutdown & RCV_SHUTDOWN)
420 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
421
422 if (sk->sk_shutdown == SHUTDOWN_MASK)
423 mask |= POLLHUP;
424
425 if (!skb_queue_empty(&sk->sk_receive_queue))
426 mask |= POLLIN | POLLRDNORM;
427
428 if (sk->sk_state == BT_CLOSED)
429 mask |= POLLHUP;
430
431 if (sk->sk_state == BT_CONNECT ||
432 sk->sk_state == BT_CONNECT2 ||
433 sk->sk_state == BT_CONFIG)
434 return mask;
435
436 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
437 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
438 else
439 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
440
441 return mask;
442}
443EXPORT_SYMBOL(bt_sock_poll);
444
445int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
446{
447 struct sock *sk = sock->sk;
448 struct sk_buff *skb;
449 long amount;
450 int err;
451
452 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
453
454 switch (cmd) {
455 case TIOCOUTQ:
456 if (sk->sk_state == BT_LISTEN)
457 return -EINVAL;
458
459 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
460 if (amount < 0)
461 amount = 0;
462 err = put_user(amount, (int __user *) arg);
463 break;
464
465 case TIOCINQ:
466 if (sk->sk_state == BT_LISTEN)
467 return -EINVAL;
468
469 lock_sock(sk);
470 skb = skb_peek(&sk->sk_receive_queue);
471 amount = skb ? skb->len : 0;
472 release_sock(sk);
473 err = put_user(amount, (int __user *) arg);
474 break;
475
476 case SIOCGSTAMP:
477 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
478 break;
479
480 case SIOCGSTAMPNS:
481 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
482 break;
483
484 default:
485 err = -ENOIOCTLCMD;
486 break;
487 }
488
489 return err;
490}
491EXPORT_SYMBOL(bt_sock_ioctl);
492
493int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
494{
495 DECLARE_WAITQUEUE(wait, current);
496 int err = 0;
497
498 BT_DBG("sk %p", sk);
499
500 add_wait_queue(sk_sleep(sk), &wait);
501 set_current_state(TASK_INTERRUPTIBLE);
502 while (sk->sk_state != state) {
503 if (!timeo) {
504 err = -EINPROGRESS;
505 break;
506 }
507
508 if (signal_pending(current)) {
509 err = sock_intr_errno(timeo);
510 break;
511 }
512
513 release_sock(sk);
514 timeo = schedule_timeout(timeo);
515 lock_sock(sk);
516 set_current_state(TASK_INTERRUPTIBLE);
517
518 err = sock_error(sk);
519 if (err)
520 break;
521 }
522 __set_current_state(TASK_RUNNING);
523 remove_wait_queue(sk_sleep(sk), &wait);
524 return err;
525}
526EXPORT_SYMBOL(bt_sock_wait_state);
527
528#ifdef CONFIG_PROC_FS
529struct bt_seq_state {
530 struct bt_sock_list *l;
531};
532
533static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
534 __acquires(seq->private->l->lock)
535{
536 struct bt_seq_state *s = seq->private;
537 struct bt_sock_list *l = s->l;
538
539 read_lock(&l->lock);
540 return seq_hlist_start_head(&l->head, *pos);
541}
542
543static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
544{
545 struct bt_seq_state *s = seq->private;
546 struct bt_sock_list *l = s->l;
547
548 return seq_hlist_next(v, &l->head, pos);
549}
550
551static void bt_seq_stop(struct seq_file *seq, void *v)
552 __releases(seq->private->l->lock)
553{
554 struct bt_seq_state *s = seq->private;
555 struct bt_sock_list *l = s->l;
556
557 read_unlock(&l->lock);
558}
559
560static int bt_seq_show(struct seq_file *seq, void *v)
561{
562 struct bt_seq_state *s = seq->private;
563 struct bt_sock_list *l = s->l;
564
565 if (v == SEQ_START_TOKEN) {
566 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Src Dst Parent");
567
568 if (l->custom_seq_show) {
569 seq_putc(seq, ' ');
570 l->custom_seq_show(seq, v);
571 }
572
573 seq_putc(seq, '\n');
574 } else {
575 struct sock *sk = sk_entry(v);
576 struct bt_sock *bt = bt_sk(sk);
577
578 seq_printf(seq,
579 "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
580 sk,
581 atomic_read(&sk->sk_refcnt),
582 sk_rmem_alloc_get(sk),
583 sk_wmem_alloc_get(sk),
584 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
585 sock_i_ino(sk),
586 &bt->src,
587 &bt->dst,
588 bt->parent? sock_i_ino(bt->parent): 0LU);
589
590 if (l->custom_seq_show) {
591 seq_putc(seq, ' ');
592 l->custom_seq_show(seq, v);
593 }
594
595 seq_putc(seq, '\n');
596 }
597 return 0;
598}
599
600static struct seq_operations bt_seq_ops = {
601 .start = bt_seq_start,
602 .next = bt_seq_next,
603 .stop = bt_seq_stop,
604 .show = bt_seq_show,
605};
606
607static int bt_seq_open(struct inode *inode, struct file *file)
608{
609 struct bt_sock_list *sk_list;
610 struct bt_seq_state *s;
611
612 sk_list = PDE_DATA(inode);
613 s = __seq_open_private(file, &bt_seq_ops,
614 sizeof(struct bt_seq_state));
615 if (!s)
616 return -ENOMEM;
617
618 s->l = sk_list;
619 return 0;
620}
621
622static const struct file_operations bt_fops = {
623 .open = bt_seq_open,
624 .read = seq_read,
625 .llseek = seq_lseek,
626 .release = seq_release_private
627};
628
629int bt_procfs_init(struct net *net, const char *name,
630 struct bt_sock_list* sk_list,
631 int (* seq_show)(struct seq_file *, void *))
632{
633 sk_list->custom_seq_show = seq_show;
634
635 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
636 return -ENOMEM;
637 return 0;
638}
639
640void bt_procfs_cleanup(struct net *net, const char *name)
641{
642 remove_proc_entry(name, net->proc_net);
643}
644#else
645int bt_procfs_init(struct net *net, const char *name,
646 struct bt_sock_list* sk_list,
647 int (* seq_show)(struct seq_file *, void *))
648{
649 return 0;
650}
651
652void bt_procfs_cleanup(struct net *net, const char *name)
653{
654}
655#endif
656EXPORT_SYMBOL(bt_procfs_init);
657EXPORT_SYMBOL(bt_procfs_cleanup);
658
659static struct net_proto_family bt_sock_family_ops = {
660 .owner = THIS_MODULE,
661 .family = PF_BLUETOOTH,
662 .create = bt_sock_create,
663};
664
665static int __init bt_init(void)
666{
667 int err;
668
669 BT_INFO("Core ver %s", VERSION);
670
671 err = bt_sysfs_init();
672 if (err < 0)
673 return err;
674
675 err = sock_register(&bt_sock_family_ops);
676 if (err < 0) {
677 bt_sysfs_cleanup();
678 return err;
679 }
680
681 BT_INFO("HCI device and connection manager initialized");
682
683 err = hci_sock_init();
684 if (err < 0)
685 goto error;
686
687 err = l2cap_init();
688 if (err < 0)
689 goto sock_err;
690
691 err = sco_init();
692 if (err < 0) {
693 l2cap_exit();
694 goto sock_err;
695 }
696
697 return 0;
698
699sock_err:
700 hci_sock_cleanup();
701
702error:
703 sock_unregister(PF_BLUETOOTH);
704 bt_sysfs_cleanup();
705
706 return err;
707}
708
709static void __exit bt_exit(void)
710{
711
712 sco_exit();
713
714 l2cap_exit();
715
716 hci_sock_cleanup();
717
718 sock_unregister(PF_BLUETOOTH);
719
720 bt_sysfs_cleanup();
721}
722
723subsys_initcall(bt_init);
724module_exit(bt_exit);
725
726MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
727MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
728MODULE_VERSION(VERSION);
729MODULE_LICENSE("GPL");
730MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
731
