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