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/errno.h>
31#include <linux/kernel.h>
32#include <linux/sched.h>
33#include <linux/slab.h>
34#include <linux/poll.h>
35#include <linux/fcntl.h>
36#include <linux/init.h>
37#include <linux/interrupt.h>
38#include <linux/socket.h>
39#include <linux/skbuff.h>
40#include <linux/device.h>
41#include <linux/list.h>
42#include <net/sock.h>
43
44#include <asm/system.h>
45#include <asm/uaccess.h>
46
47#include <net/bluetooth/bluetooth.h>
48#include <net/bluetooth/hci_core.h>
49#include <net/bluetooth/sco.h>
50
51#define VERSION "0.6"
52
53static int disable_esco = 0;
54
55static const struct proto_ops sco_sock_ops;
56
57static struct bt_sock_list sco_sk_list = {
58 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
59};
60
61static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
62static void sco_chan_del(struct sock *sk, int err);
63
64static int sco_conn_del(struct hci_conn *conn, int err);
65
66static void sco_sock_close(struct sock *sk);
67static void sco_sock_kill(struct sock *sk);
68
69
70static void sco_sock_timeout(unsigned long arg)
71{
72 struct sock *sk = (struct sock *) arg;
73
74 BT_DBG("sock %p state %d", sk, sk->sk_state);
75
76 bh_lock_sock(sk);
77 sk->sk_err = ETIMEDOUT;
78 sk->sk_state_change(sk);
79 bh_unlock_sock(sk);
80
81 sco_sock_kill(sk);
82 sock_put(sk);
83}
84
85static void sco_sock_set_timer(struct sock *sk, long timeout)
86{
87 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
88 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
89}
90
91static void sco_sock_clear_timer(struct sock *sk)
92{
93 BT_DBG("sock %p state %d", sk, sk->sk_state);
94 sk_stop_timer(sk, &sk->sk_timer);
95}
96
97
98static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
99{
100 struct hci_dev *hdev = hcon->hdev;
101 struct sco_conn *conn = hcon->sco_data;
102
103 if (conn || status)
104 return conn;
105
106 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
107 if (!conn)
108 return NULL;
109
110 spin_lock_init(&conn->lock);
111
112 hcon->sco_data = conn;
113 conn->hcon = hcon;
114
115 conn->src = &hdev->bdaddr;
116 conn->dst = &hcon->dst;
117
118 if (hdev->sco_mtu > 0)
119 conn->mtu = hdev->sco_mtu;
120 else
121 conn->mtu = 60;
122
123 BT_DBG("hcon %p conn %p", hcon, conn);
124
125 return conn;
126}
127
128static inline struct sock *sco_chan_get(struct sco_conn *conn)
129{
130 struct sock *sk = NULL;
131 sco_conn_lock(conn);
132 sk = conn->sk;
133 sco_conn_unlock(conn);
134 return sk;
135}
136
137static int sco_conn_del(struct hci_conn *hcon, int err)
138{
139 struct sco_conn *conn;
140 struct sock *sk;
141
142 if (!(conn = hcon->sco_data))
143 return 0;
144
145 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
146
147
148 if ((sk = sco_chan_get(conn))) {
149 bh_lock_sock(sk);
150 sco_sock_clear_timer(sk);
151 sco_chan_del(sk, err);
152 bh_unlock_sock(sk);
153 sco_sock_kill(sk);
154 }
155
156 hcon->sco_data = NULL;
157 kfree(conn);
158 return 0;
159}
160
161static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
162{
163 int err = 0;
164
165 sco_conn_lock(conn);
166 if (conn->sk) {
167 err = -EBUSY;
168 } else {
169 __sco_chan_add(conn, sk, parent);
170 }
171 sco_conn_unlock(conn);
172 return err;
173}
174
175static int sco_connect(struct sock *sk)
176{
177 bdaddr_t *src = &bt_sk(sk)->src;
178 bdaddr_t *dst = &bt_sk(sk)->dst;
179 struct sco_conn *conn;
180 struct hci_conn *hcon;
181 struct hci_dev *hdev;
182 int err, type;
183
184 BT_DBG("%s -> %s", batostr(src), batostr(dst));
185
186 if (!(hdev = hci_get_route(dst, src)))
187 return -EHOSTUNREACH;
188
189 hci_dev_lock_bh(hdev);
190
191 err = -ENOMEM;
192
193 if (lmp_esco_capable(hdev) && !disable_esco)
194 type = ESCO_LINK;
195 else
196 type = SCO_LINK;
197
198 hcon = hci_connect(hdev, type, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
199 if (!hcon)
200 goto done;
201
202 conn = sco_conn_add(hcon, 0);
203 if (!conn) {
204 hci_conn_put(hcon);
205 goto done;
206 }
207
208
209 bacpy(src, conn->src);
210
211 err = sco_chan_add(conn, sk, NULL);
212 if (err)
213 goto done;
214
215 if (hcon->state == BT_CONNECTED) {
216 sco_sock_clear_timer(sk);
217 sk->sk_state = BT_CONNECTED;
218 } else {
219 sk->sk_state = BT_CONNECT;
220 sco_sock_set_timer(sk, sk->sk_sndtimeo);
221 }
222
223done:
224 hci_dev_unlock_bh(hdev);
225 hci_dev_put(hdev);
226 return err;
227}
228
229static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
230{
231 struct sco_conn *conn = sco_pi(sk)->conn;
232 struct sk_buff *skb;
233 int err, count;
234
235
236 if (len > conn->mtu)
237 return -EINVAL;
238
239 BT_DBG("sk %p len %d", sk, len);
240
241 count = min_t(unsigned int, conn->mtu, len);
242 if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
243 return err;
244
245 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
246 err = -EFAULT;
247 goto fail;
248 }
249
250 if ((err = hci_send_sco(conn->hcon, skb)) < 0)
251 return err;
252
253 return count;
254
255fail:
256 kfree_skb(skb);
257 return err;
258}
259
260static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
261{
262 struct sock *sk = sco_chan_get(conn);
263
264 if (!sk)
265 goto drop;
266
267 BT_DBG("sk %p len %d", sk, skb->len);
268
269 if (sk->sk_state != BT_CONNECTED)
270 goto drop;
271
272 if (!sock_queue_rcv_skb(sk, skb))
273 return;
274
275drop:
276 kfree_skb(skb);
277 return;
278}
279
280
281static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
282{
283 struct sock *sk;
284 struct hlist_node *node;
285
286 sk_for_each(sk, node, &sco_sk_list.head)
287 if (!bacmp(&bt_sk(sk)->src, ba))
288 goto found;
289 sk = NULL;
290found:
291 return sk;
292}
293
294
295
296
297static struct sock *sco_get_sock_listen(bdaddr_t *src)
298{
299 struct sock *sk = NULL, *sk1 = NULL;
300 struct hlist_node *node;
301
302 read_lock(&sco_sk_list.lock);
303
304 sk_for_each(sk, node, &sco_sk_list.head) {
305 if (sk->sk_state != BT_LISTEN)
306 continue;
307
308
309 if (!bacmp(&bt_sk(sk)->src, src))
310 break;
311
312
313 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
314 sk1 = sk;
315 }
316
317 read_unlock(&sco_sk_list.lock);
318
319 return node ? sk : sk1;
320}
321
322static void sco_sock_destruct(struct sock *sk)
323{
324 BT_DBG("sk %p", sk);
325
326 skb_queue_purge(&sk->sk_receive_queue);
327 skb_queue_purge(&sk->sk_write_queue);
328}
329
330static void sco_sock_cleanup_listen(struct sock *parent)
331{
332 struct sock *sk;
333
334 BT_DBG("parent %p", parent);
335
336
337 while ((sk = bt_accept_dequeue(parent, NULL))) {
338 sco_sock_close(sk);
339 sco_sock_kill(sk);
340 }
341
342 parent->sk_state = BT_CLOSED;
343 sock_set_flag(parent, SOCK_ZAPPED);
344}
345
346
347
348
349static void sco_sock_kill(struct sock *sk)
350{
351 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
352 return;
353
354 BT_DBG("sk %p state %d", sk, sk->sk_state);
355
356
357 bt_sock_unlink(&sco_sk_list, sk);
358 sock_set_flag(sk, SOCK_DEAD);
359 sock_put(sk);
360}
361
362static void __sco_sock_close(struct sock *sk)
363{
364 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
365
366 switch (sk->sk_state) {
367 case BT_LISTEN:
368 sco_sock_cleanup_listen(sk);
369 break;
370
371 case BT_CONNECTED:
372 case BT_CONFIG:
373 case BT_CONNECT:
374 case BT_DISCONN:
375 sco_chan_del(sk, ECONNRESET);
376 break;
377
378 default:
379 sock_set_flag(sk, SOCK_ZAPPED);
380 break;
381 }
382}
383
384
385static void sco_sock_close(struct sock *sk)
386{
387 sco_sock_clear_timer(sk);
388 lock_sock(sk);
389 __sco_sock_close(sk);
390 release_sock(sk);
391 sco_sock_kill(sk);
392}
393
394static void sco_sock_init(struct sock *sk, struct sock *parent)
395{
396 BT_DBG("sk %p", sk);
397
398 if (parent)
399 sk->sk_type = parent->sk_type;
400}
401
402static struct proto sco_proto = {
403 .name = "SCO",
404 .owner = THIS_MODULE,
405 .obj_size = sizeof(struct sco_pinfo)
406};
407
408static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
409{
410 struct sock *sk;
411
412 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
413 if (!sk)
414 return NULL;
415
416 sock_init_data(sock, sk);
417 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
418
419 sk->sk_destruct = sco_sock_destruct;
420 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
421
422 sock_reset_flag(sk, SOCK_ZAPPED);
423
424 sk->sk_protocol = proto;
425 sk->sk_state = BT_OPEN;
426
427 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
428
429 bt_sock_link(&sco_sk_list, sk);
430 return sk;
431}
432
433static int sco_sock_create(struct net *net, struct socket *sock, int protocol)
434{
435 struct sock *sk;
436
437 BT_DBG("sock %p", sock);
438
439 sock->state = SS_UNCONNECTED;
440
441 if (sock->type != SOCK_SEQPACKET)
442 return -ESOCKTNOSUPPORT;
443
444 sock->ops = &sco_sock_ops;
445
446 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
447 if (!sk)
448 return -ENOMEM;
449
450 sco_sock_init(sk, NULL);
451 return 0;
452}
453
454static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
455{
456 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
457 struct sock *sk = sock->sk;
458 bdaddr_t *src = &sa->sco_bdaddr;
459 int err = 0;
460
461 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
462
463 if (!addr || addr->sa_family != AF_BLUETOOTH)
464 return -EINVAL;
465
466 lock_sock(sk);
467
468 if (sk->sk_state != BT_OPEN) {
469 err = -EBADFD;
470 goto done;
471 }
472
473 write_lock_bh(&sco_sk_list.lock);
474
475 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
476 err = -EADDRINUSE;
477 } else {
478
479 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
480 sk->sk_state = BT_BOUND;
481 }
482
483 write_unlock_bh(&sco_sk_list.lock);
484
485done:
486 release_sock(sk);
487 return err;
488}
489
490static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
491{
492 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
493 struct sock *sk = sock->sk;
494 int err = 0;
495
496
497 BT_DBG("sk %p", sk);
498
499 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
500 return -EINVAL;
501
502 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
503 return -EBADFD;
504
505 if (sk->sk_type != SOCK_SEQPACKET)
506 return -EINVAL;
507
508 lock_sock(sk);
509
510
511 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
512
513 if ((err = sco_connect(sk)))
514 goto done;
515
516 err = bt_sock_wait_state(sk, BT_CONNECTED,
517 sock_sndtimeo(sk, flags & O_NONBLOCK));
518
519done:
520 release_sock(sk);
521 return err;
522}
523
524static int sco_sock_listen(struct socket *sock, int backlog)
525{
526 struct sock *sk = sock->sk;
527 int err = 0;
528
529 BT_DBG("sk %p backlog %d", sk, backlog);
530
531 lock_sock(sk);
532
533 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
534 err = -EBADFD;
535 goto done;
536 }
537
538 sk->sk_max_ack_backlog = backlog;
539 sk->sk_ack_backlog = 0;
540 sk->sk_state = BT_LISTEN;
541
542done:
543 release_sock(sk);
544 return err;
545}
546
547static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
548{
549 DECLARE_WAITQUEUE(wait, current);
550 struct sock *sk = sock->sk, *ch;
551 long timeo;
552 int err = 0;
553
554 lock_sock(sk);
555
556 if (sk->sk_state != BT_LISTEN) {
557 err = -EBADFD;
558 goto done;
559 }
560
561 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
562
563 BT_DBG("sk %p timeo %ld", sk, timeo);
564
565
566 add_wait_queue_exclusive(sk->sk_sleep, &wait);
567 while (!(ch = bt_accept_dequeue(sk, newsock))) {
568 set_current_state(TASK_INTERRUPTIBLE);
569 if (!timeo) {
570 err = -EAGAIN;
571 break;
572 }
573
574 release_sock(sk);
575 timeo = schedule_timeout(timeo);
576 lock_sock(sk);
577
578 if (sk->sk_state != BT_LISTEN) {
579 err = -EBADFD;
580 break;
581 }
582
583 if (signal_pending(current)) {
584 err = sock_intr_errno(timeo);
585 break;
586 }
587 }
588 set_current_state(TASK_RUNNING);
589 remove_wait_queue(sk->sk_sleep, &wait);
590
591 if (err)
592 goto done;
593
594 newsock->state = SS_CONNECTED;
595
596 BT_DBG("new socket %p", ch);
597
598done:
599 release_sock(sk);
600 return err;
601}
602
603static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
604{
605 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
606 struct sock *sk = sock->sk;
607
608 BT_DBG("sock %p, sk %p", sock, sk);
609
610 addr->sa_family = AF_BLUETOOTH;
611 *len = sizeof(struct sockaddr_sco);
612
613 if (peer)
614 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
615 else
616 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
617
618 return 0;
619}
620
621static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
622 struct msghdr *msg, size_t len)
623{
624 struct sock *sk = sock->sk;
625 int err = 0;
626
627 BT_DBG("sock %p, sk %p", sock, sk);
628
629 err = sock_error(sk);
630 if (err)
631 return err;
632
633 if (msg->msg_flags & MSG_OOB)
634 return -EOPNOTSUPP;
635
636 lock_sock(sk);
637
638 if (sk->sk_state == BT_CONNECTED)
639 err = sco_send_frame(sk, msg, len);
640 else
641 err = -ENOTCONN;
642
643 release_sock(sk);
644 return err;
645}
646
647static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
648{
649 struct sock *sk = sock->sk;
650 int err = 0;
651
652 BT_DBG("sk %p", sk);
653
654 lock_sock(sk);
655
656 switch (optname) {
657 default:
658 err = -ENOPROTOOPT;
659 break;
660 }
661
662 release_sock(sk);
663 return err;
664}
665
666static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
667{
668 struct sock *sk = sock->sk;
669 struct sco_options opts;
670 struct sco_conninfo cinfo;
671 int len, err = 0;
672
673 BT_DBG("sk %p", sk);
674
675 if (get_user(len, optlen))
676 return -EFAULT;
677
678 lock_sock(sk);
679
680 switch (optname) {
681 case SCO_OPTIONS:
682 if (sk->sk_state != BT_CONNECTED) {
683 err = -ENOTCONN;
684 break;
685 }
686
687 opts.mtu = sco_pi(sk)->conn->mtu;
688
689 BT_DBG("mtu %d", opts.mtu);
690
691 len = min_t(unsigned int, len, sizeof(opts));
692 if (copy_to_user(optval, (char *)&opts, len))
693 err = -EFAULT;
694
695 break;
696
697 case SCO_CONNINFO:
698 if (sk->sk_state != BT_CONNECTED) {
699 err = -ENOTCONN;
700 break;
701 }
702
703 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
704 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
705
706 len = min_t(unsigned int, len, sizeof(cinfo));
707 if (copy_to_user(optval, (char *)&cinfo, len))
708 err = -EFAULT;
709
710 break;
711
712 default:
713 err = -ENOPROTOOPT;
714 break;
715 }
716
717 release_sock(sk);
718 return err;
719}
720
721static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
722{
723 struct sock *sk = sock->sk;
724 int len, err = 0;
725
726 BT_DBG("sk %p", sk);
727
728 if (level == SOL_SCO)
729 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
730
731 if (get_user(len, optlen))
732 return -EFAULT;
733
734 lock_sock(sk);
735
736 switch (optname) {
737 default:
738 err = -ENOPROTOOPT;
739 break;
740 }
741
742 release_sock(sk);
743 return err;
744}
745
746static int sco_sock_shutdown(struct socket *sock, int how)
747{
748 struct sock *sk = sock->sk;
749 int err = 0;
750
751 BT_DBG("sock %p, sk %p", sock, sk);
752
753 if (!sk)
754 return 0;
755
756 lock_sock(sk);
757 if (!sk->sk_shutdown) {
758 sk->sk_shutdown = SHUTDOWN_MASK;
759 sco_sock_clear_timer(sk);
760 __sco_sock_close(sk);
761
762 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
763 err = bt_sock_wait_state(sk, BT_CLOSED,
764 sk->sk_lingertime);
765 }
766 release_sock(sk);
767 return err;
768}
769
770static int sco_sock_release(struct socket *sock)
771{
772 struct sock *sk = sock->sk;
773 int err = 0;
774
775 BT_DBG("sock %p, sk %p", sock, sk);
776
777 if (!sk)
778 return 0;
779
780 sco_sock_close(sk);
781
782 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
783 lock_sock(sk);
784 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
785 release_sock(sk);
786 }
787
788 sock_orphan(sk);
789 sco_sock_kill(sk);
790 return err;
791}
792
793static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
794{
795 BT_DBG("conn %p", conn);
796
797 sco_pi(sk)->conn = conn;
798 conn->sk = sk;
799
800 if (parent)
801 bt_accept_enqueue(parent, sk);
802}
803
804
805
806static void sco_chan_del(struct sock *sk, int err)
807{
808 struct sco_conn *conn;
809
810 conn = sco_pi(sk)->conn;
811
812 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
813
814 if (conn) {
815 sco_conn_lock(conn);
816 conn->sk = NULL;
817 sco_pi(sk)->conn = NULL;
818 sco_conn_unlock(conn);
819 hci_conn_put(conn->hcon);
820 }
821
822 sk->sk_state = BT_CLOSED;
823 sk->sk_err = err;
824 sk->sk_state_change(sk);
825
826 sock_set_flag(sk, SOCK_ZAPPED);
827}
828
829static void sco_conn_ready(struct sco_conn *conn)
830{
831 struct sock *parent, *sk;
832
833 BT_DBG("conn %p", conn);
834
835 sco_conn_lock(conn);
836
837 if ((sk = conn->sk)) {
838 sco_sock_clear_timer(sk);
839 bh_lock_sock(sk);
840 sk->sk_state = BT_CONNECTED;
841 sk->sk_state_change(sk);
842 bh_unlock_sock(sk);
843 } else {
844 parent = sco_get_sock_listen(conn->src);
845 if (!parent)
846 goto done;
847
848 bh_lock_sock(parent);
849
850 sk = sco_sock_alloc(sock_net(parent), NULL, BTPROTO_SCO, GFP_ATOMIC);
851 if (!sk) {
852 bh_unlock_sock(parent);
853 goto done;
854 }
855
856 sco_sock_init(sk, parent);
857
858 bacpy(&bt_sk(sk)->src, conn->src);
859 bacpy(&bt_sk(sk)->dst, conn->dst);
860
861 hci_conn_hold(conn->hcon);
862 __sco_chan_add(conn, sk, parent);
863
864 sk->sk_state = BT_CONNECTED;
865
866
867 parent->sk_data_ready(parent, 1);
868
869 bh_unlock_sock(parent);
870 }
871
872done:
873 sco_conn_unlock(conn);
874}
875
876
877static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
878{
879 register struct sock *sk;
880 struct hlist_node *node;
881 int lm = 0;
882
883 if (type != SCO_LINK && type != ESCO_LINK)
884 return 0;
885
886 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
887
888
889 read_lock(&sco_sk_list.lock);
890 sk_for_each(sk, node, &sco_sk_list.head) {
891 if (sk->sk_state != BT_LISTEN)
892 continue;
893
894 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
895 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
896 lm |= HCI_LM_ACCEPT;
897 break;
898 }
899 }
900 read_unlock(&sco_sk_list.lock);
901
902 return lm;
903}
904
905static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
906{
907 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
908
909 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
910 return 0;
911
912 if (!status) {
913 struct sco_conn *conn;
914
915 conn = sco_conn_add(hcon, status);
916 if (conn)
917 sco_conn_ready(conn);
918 } else
919 sco_conn_del(hcon, bt_err(status));
920
921 return 0;
922}
923
924static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
925{
926 BT_DBG("hcon %p reason %d", hcon, reason);
927
928 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
929 return 0;
930
931 sco_conn_del(hcon, bt_err(reason));
932
933 return 0;
934}
935
936static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
937{
938 struct sco_conn *conn = hcon->sco_data;
939
940 if (!conn)
941 goto drop;
942
943 BT_DBG("conn %p len %d", conn, skb->len);
944
945 if (skb->len) {
946 sco_recv_frame(conn, skb);
947 return 0;
948 }
949
950drop:
951 kfree_skb(skb);
952 return 0;
953}
954
955static ssize_t sco_sysfs_show(struct class *dev, char *buf)
956{
957 struct sock *sk;
958 struct hlist_node *node;
959 char *str = buf;
960
961 read_lock_bh(&sco_sk_list.lock);
962
963 sk_for_each(sk, node, &sco_sk_list.head) {
964 str += sprintf(str, "%s %s %d\n",
965 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
966 sk->sk_state);
967 }
968
969 read_unlock_bh(&sco_sk_list.lock);
970
971 return (str - buf);
972}
973
974static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
975
976static const struct proto_ops sco_sock_ops = {
977 .family = PF_BLUETOOTH,
978 .owner = THIS_MODULE,
979 .release = sco_sock_release,
980 .bind = sco_sock_bind,
981 .connect = sco_sock_connect,
982 .listen = sco_sock_listen,
983 .accept = sco_sock_accept,
984 .getname = sco_sock_getname,
985 .sendmsg = sco_sock_sendmsg,
986 .recvmsg = bt_sock_recvmsg,
987 .poll = bt_sock_poll,
988 .ioctl = bt_sock_ioctl,
989 .mmap = sock_no_mmap,
990 .socketpair = sock_no_socketpair,
991 .shutdown = sco_sock_shutdown,
992 .setsockopt = sco_sock_setsockopt,
993 .getsockopt = sco_sock_getsockopt
994};
995
996static struct net_proto_family sco_sock_family_ops = {
997 .family = PF_BLUETOOTH,
998 .owner = THIS_MODULE,
999 .create = sco_sock_create,
1000};
1001
1002static struct hci_proto sco_hci_proto = {
1003 .name = "SCO",
1004 .id = HCI_PROTO_SCO,
1005 .connect_ind = sco_connect_ind,
1006 .connect_cfm = sco_connect_cfm,
1007 .disconn_cfm = sco_disconn_cfm,
1008 .recv_scodata = sco_recv_scodata
1009};
1010
1011static int __init sco_init(void)
1012{
1013 int err;
1014
1015 err = proto_register(&sco_proto, 0);
1016 if (err < 0)
1017 return err;
1018
1019 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1020 if (err < 0) {
1021 BT_ERR("SCO socket registration failed");
1022 goto error;
1023 }
1024
1025 err = hci_register_proto(&sco_hci_proto);
1026 if (err < 0) {
1027 BT_ERR("SCO protocol registration failed");
1028 bt_sock_unregister(BTPROTO_SCO);
1029 goto error;
1030 }
1031
1032 if (class_create_file(bt_class, &class_attr_sco) < 0)
1033 BT_ERR("Failed to create SCO info file");
1034
1035 BT_INFO("SCO (Voice Link) ver %s", VERSION);
1036 BT_INFO("SCO socket layer initialized");
1037
1038 return 0;
1039
1040error:
1041 proto_unregister(&sco_proto);
1042 return err;
1043}
1044
1045static void __exit sco_exit(void)
1046{
1047 class_remove_file(bt_class, &class_attr_sco);
1048
1049 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1050 BT_ERR("SCO socket unregistration failed");
1051
1052 if (hci_unregister_proto(&sco_hci_proto) < 0)
1053 BT_ERR("SCO protocol unregistration failed");
1054
1055 proto_unregister(&sco_proto);
1056}
1057
1058module_init(sco_init);
1059module_exit(sco_exit);
1060
1061module_param(disable_esco, bool, 0644);
1062MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1063
1064MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1065MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1066MODULE_VERSION(VERSION);
1067MODULE_LICENSE("GPL");
1068MODULE_ALIAS("bt-proto-2");
1069
