77f4153bdb5e5ebe434487497d1e8d3ed0253cbf
[linux-2.6.git] / net / bluetooth / sco.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 SCO sockets. */
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
53 static int disable_esco = 0;
54
55 static const struct proto_ops sco_sock_ops;
56
57 static struct bt_sock_list sco_sk_list = {
58         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
59 };
60
61 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
62 static void sco_chan_del(struct sock *sk, int err);
63
64 static int  sco_conn_del(struct hci_conn *conn, int err);
65
66 static void sco_sock_close(struct sock *sk);
67 static void sco_sock_kill(struct sock *sk);
68
69 /* ---- SCO timers ---- */
70 static 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
85 static 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
91 static 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 /* ---- SCO connections ---- */
98 static 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
128 static 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
137 static 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         /* Kill socket */
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
161 static 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
175 static 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         /* Update source addr of the socket */
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
223 done:
224         hci_dev_unlock_bh(hdev);
225         hci_dev_put(hdev);
226         return err;
227 }
228
229 static 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         /* Check outgoing MTU */
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
255 fail:
256         kfree_skb(skb);
257         return err;
258 }
259
260 static 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
275 drop:
276         kfree_skb(skb);
277         return;
278 }
279
280 /* -------- Socket interface ---------- */
281 static 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;
290 found:
291         return sk;
292 }
293
294 /* Find socket listening on source bdaddr.
295  * Returns closest match.
296  */
297 static 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                 /* Exact match. */
309                 if (!bacmp(&bt_sk(sk)->src, src))
310                         break;
311
312                 /* Closest match */
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
322 static 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
330 static void sco_sock_cleanup_listen(struct sock *parent)
331 {
332         struct sock *sk;
333
334         BT_DBG("parent %p", parent);
335
336         /* Close not yet accepted channels */
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 /* Kill socket (only if zapped and orphan)
347  * Must be called on unlocked socket.
348  */
349 static 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         /* Kill poor orphan */
357         bt_sock_unlink(&sco_sk_list, sk);
358         sock_set_flag(sk, SOCK_DEAD);
359         sock_put(sk);
360 }
361
362 static 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 /* Must be called on unlocked socket. */
385 static 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
394 static 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
402 static struct proto sco_proto = {
403         .name           = "SCO",
404         .owner          = THIS_MODULE,
405         .obj_size       = sizeof(struct sco_pinfo)
406 };
407
408 static 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
433 static 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
454 static 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                 /* Save source address */
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
485 done:
486         release_sock(sk);
487         return err;
488 }
489
490 static 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         /* Set destination address and psm */
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
519 done:
520         release_sock(sk);
521         return err;
522 }
523
524 static 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
542 done:
543         release_sock(sk);
544         return err;
545 }
546
547 static 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         /* Wait for an incoming connection. (wake-one). */
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
598 done:
599         release_sock(sk);
600         return err;
601 }
602
603 static 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
621 static 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
647 static 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
666 static 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
721 static 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
746 static 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
770 static 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
793 static 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 /* Delete channel.
805  * Must be called on the locked socket. */
806 static 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
829 static 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                 /* Wake up parent */
867                 parent->sk_data_ready(parent, 1);
868
869                 bh_unlock_sock(parent);
870         }
871
872 done:
873         sco_conn_unlock(conn);
874 }
875
876 /* ----- SCO interface with lower layer (HCI) ----- */
877 static 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         /* Find listening sockets */
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
905 static 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
924 static 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
936 static 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
950 drop:
951         kfree_skb(skb);
952         return 0;
953 }
954
955 static 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
974 static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
975
976 static 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
996 static struct net_proto_family sco_sock_family_ops = {
997         .family = PF_BLUETOOTH,
998         .owner  = THIS_MODULE,
999         .create = sco_sock_create,
1000 };
1001
1002 static 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
1011 static 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
1040 error:
1041         proto_unregister(&sco_proto);
1042         return err;
1043 }
1044
1045 static 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
1058 module_init(sco_init);
1059 module_exit(sco_exit);
1060
1061 module_param(disable_esco, bool, 0644);
1062 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1063
1064 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1065 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1066 MODULE_VERSION(VERSION);
1067 MODULE_LICENSE("GPL");
1068 MODULE_ALIAS("bt-proto-2");