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