]> Git Repo - linux.git/blob - net/bluetooth/sco.c
x86/config: Fix warning for 'make ARCH=x86_64 tinyconfig'
[linux.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 <[email protected]>
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 #include <linux/sched/signal.h>
31
32 #include <net/bluetooth/bluetooth.h>
33 #include <net/bluetooth/hci_core.h>
34 #include <net/bluetooth/sco.h>
35
36 static bool disable_esco;
37
38 static const struct proto_ops sco_sock_ops;
39
40 static struct bt_sock_list sco_sk_list = {
41         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
42 };
43
44 /* ---- SCO connections ---- */
45 struct sco_conn {
46         struct hci_conn *hcon;
47
48         spinlock_t      lock;
49         struct sock     *sk;
50
51         struct delayed_work     timeout_work;
52
53         unsigned int    mtu;
54 };
55
56 #define sco_conn_lock(c)        spin_lock(&c->lock)
57 #define sco_conn_unlock(c)      spin_unlock(&c->lock)
58
59 static void sco_sock_close(struct sock *sk);
60 static void sco_sock_kill(struct sock *sk);
61
62 /* ----- SCO socket info ----- */
63 #define sco_pi(sk) ((struct sco_pinfo *) sk)
64
65 struct sco_pinfo {
66         struct bt_sock  bt;
67         bdaddr_t        src;
68         bdaddr_t        dst;
69         __u32           flags;
70         __u16           setting;
71         struct bt_codec codec;
72         struct sco_conn *conn;
73 };
74
75 /* ---- SCO timers ---- */
76 #define SCO_CONN_TIMEOUT        (HZ * 40)
77 #define SCO_DISCONN_TIMEOUT     (HZ * 2)
78
79 static void sco_sock_timeout(struct work_struct *work)
80 {
81         struct sco_conn *conn = container_of(work, struct sco_conn,
82                                              timeout_work.work);
83         struct sock *sk;
84
85         sco_conn_lock(conn);
86         sk = conn->sk;
87         if (sk)
88                 sock_hold(sk);
89         sco_conn_unlock(conn);
90
91         if (!sk)
92                 return;
93
94         BT_DBG("sock %p state %d", sk, sk->sk_state);
95
96         lock_sock(sk);
97         sk->sk_err = ETIMEDOUT;
98         sk->sk_state_change(sk);
99         release_sock(sk);
100         sock_put(sk);
101 }
102
103 static void sco_sock_set_timer(struct sock *sk, long timeout)
104 {
105         if (!sco_pi(sk)->conn)
106                 return;
107
108         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
109         cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
110         schedule_delayed_work(&sco_pi(sk)->conn->timeout_work, timeout);
111 }
112
113 static void sco_sock_clear_timer(struct sock *sk)
114 {
115         if (!sco_pi(sk)->conn)
116                 return;
117
118         BT_DBG("sock %p state %d", sk, sk->sk_state);
119         cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
120 }
121
122 /* ---- SCO connections ---- */
123 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
124 {
125         struct hci_dev *hdev = hcon->hdev;
126         struct sco_conn *conn = hcon->sco_data;
127
128         if (conn) {
129                 if (!conn->hcon)
130                         conn->hcon = hcon;
131                 return conn;
132         }
133
134         conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
135         if (!conn)
136                 return NULL;
137
138         spin_lock_init(&conn->lock);
139         INIT_DELAYED_WORK(&conn->timeout_work, sco_sock_timeout);
140
141         hcon->sco_data = conn;
142         conn->hcon = hcon;
143
144         if (hdev->sco_mtu > 0)
145                 conn->mtu = hdev->sco_mtu;
146         else
147                 conn->mtu = 60;
148
149         BT_DBG("hcon %p conn %p", hcon, conn);
150
151         return conn;
152 }
153
154 /* Delete channel.
155  * Must be called on the locked socket. */
156 static void sco_chan_del(struct sock *sk, int err)
157 {
158         struct sco_conn *conn;
159
160         conn = sco_pi(sk)->conn;
161
162         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
163
164         if (conn) {
165                 sco_conn_lock(conn);
166                 conn->sk = NULL;
167                 sco_pi(sk)->conn = NULL;
168                 sco_conn_unlock(conn);
169
170                 if (conn->hcon)
171                         hci_conn_drop(conn->hcon);
172         }
173
174         sk->sk_state = BT_CLOSED;
175         sk->sk_err   = err;
176         sk->sk_state_change(sk);
177
178         sock_set_flag(sk, SOCK_ZAPPED);
179 }
180
181 static void sco_conn_del(struct hci_conn *hcon, int err)
182 {
183         struct sco_conn *conn = hcon->sco_data;
184         struct sock *sk;
185
186         if (!conn)
187                 return;
188
189         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
190
191         /* Kill socket */
192         sco_conn_lock(conn);
193         sk = conn->sk;
194         if (sk)
195                 sock_hold(sk);
196         sco_conn_unlock(conn);
197
198         if (sk) {
199                 lock_sock(sk);
200                 sco_sock_clear_timer(sk);
201                 sco_chan_del(sk, err);
202                 release_sock(sk);
203                 sock_put(sk);
204         }
205
206         /* Ensure no more work items will run before freeing conn. */
207         cancel_delayed_work_sync(&conn->timeout_work);
208
209         hcon->sco_data = NULL;
210         kfree(conn);
211 }
212
213 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
214                            struct sock *parent)
215 {
216         BT_DBG("conn %p", conn);
217
218         sco_pi(sk)->conn = conn;
219         conn->sk = sk;
220
221         if (parent)
222                 bt_accept_enqueue(parent, sk, true);
223 }
224
225 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
226                         struct sock *parent)
227 {
228         int err = 0;
229
230         sco_conn_lock(conn);
231         if (conn->sk)
232                 err = -EBUSY;
233         else
234                 __sco_chan_add(conn, sk, parent);
235
236         sco_conn_unlock(conn);
237         return err;
238 }
239
240 static int sco_connect(struct sock *sk)
241 {
242         struct sco_conn *conn;
243         struct hci_conn *hcon;
244         struct hci_dev  *hdev;
245         int err, type;
246
247         BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
248
249         hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
250         if (!hdev)
251                 return -EHOSTUNREACH;
252
253         hci_dev_lock(hdev);
254
255         if (lmp_esco_capable(hdev) && !disable_esco)
256                 type = ESCO_LINK;
257         else
258                 type = SCO_LINK;
259
260         if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
261             (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev))) {
262                 err = -EOPNOTSUPP;
263                 goto unlock;
264         }
265
266         hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
267                                sco_pi(sk)->setting, &sco_pi(sk)->codec,
268                                sk->sk_sndtimeo);
269         if (IS_ERR(hcon)) {
270                 err = PTR_ERR(hcon);
271                 goto unlock;
272         }
273
274         conn = sco_conn_add(hcon);
275         if (!conn) {
276                 hci_conn_drop(hcon);
277                 err = -ENOMEM;
278                 goto unlock;
279         }
280
281         lock_sock(sk);
282
283         err = sco_chan_add(conn, sk, NULL);
284         if (err) {
285                 release_sock(sk);
286                 goto unlock;
287         }
288
289         /* Update source addr of the socket */
290         bacpy(&sco_pi(sk)->src, &hcon->src);
291
292         if (hcon->state == BT_CONNECTED) {
293                 sco_sock_clear_timer(sk);
294                 sk->sk_state = BT_CONNECTED;
295         } else {
296                 sk->sk_state = BT_CONNECT;
297                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
298         }
299
300         release_sock(sk);
301
302 unlock:
303         hci_dev_unlock(hdev);
304         hci_dev_put(hdev);
305         return err;
306 }
307
308 static int sco_send_frame(struct sock *sk, struct sk_buff *skb)
309 {
310         struct sco_conn *conn = sco_pi(sk)->conn;
311         int len = skb->len;
312
313         /* Check outgoing MTU */
314         if (len > conn->mtu)
315                 return -EINVAL;
316
317         BT_DBG("sk %p len %d", sk, len);
318
319         hci_send_sco(conn->hcon, skb);
320
321         return len;
322 }
323
324 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
325 {
326         struct sock *sk;
327
328         sco_conn_lock(conn);
329         sk = conn->sk;
330         sco_conn_unlock(conn);
331
332         if (!sk)
333                 goto drop;
334
335         BT_DBG("sk %p len %u", sk, skb->len);
336
337         if (sk->sk_state != BT_CONNECTED)
338                 goto drop;
339
340         if (!sock_queue_rcv_skb(sk, skb))
341                 return;
342
343 drop:
344         kfree_skb(skb);
345 }
346
347 /* -------- Socket interface ---------- */
348 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
349 {
350         struct sock *sk;
351
352         sk_for_each(sk, &sco_sk_list.head) {
353                 if (sk->sk_state != BT_LISTEN)
354                         continue;
355
356                 if (!bacmp(&sco_pi(sk)->src, ba))
357                         return sk;
358         }
359
360         return NULL;
361 }
362
363 /* Find socket listening on source bdaddr.
364  * Returns closest match.
365  */
366 static struct sock *sco_get_sock_listen(bdaddr_t *src)
367 {
368         struct sock *sk = NULL, *sk1 = NULL;
369
370         read_lock(&sco_sk_list.lock);
371
372         sk_for_each(sk, &sco_sk_list.head) {
373                 if (sk->sk_state != BT_LISTEN)
374                         continue;
375
376                 /* Exact match. */
377                 if (!bacmp(&sco_pi(sk)->src, src))
378                         break;
379
380                 /* Closest match */
381                 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
382                         sk1 = sk;
383         }
384
385         read_unlock(&sco_sk_list.lock);
386
387         return sk ? sk : sk1;
388 }
389
390 static void sco_sock_destruct(struct sock *sk)
391 {
392         BT_DBG("sk %p", sk);
393
394         skb_queue_purge(&sk->sk_receive_queue);
395         skb_queue_purge(&sk->sk_write_queue);
396 }
397
398 static void sco_sock_cleanup_listen(struct sock *parent)
399 {
400         struct sock *sk;
401
402         BT_DBG("parent %p", parent);
403
404         /* Close not yet accepted channels */
405         while ((sk = bt_accept_dequeue(parent, NULL))) {
406                 sco_sock_close(sk);
407                 sco_sock_kill(sk);
408         }
409
410         parent->sk_state  = BT_CLOSED;
411         sock_set_flag(parent, SOCK_ZAPPED);
412 }
413
414 /* Kill socket (only if zapped and orphan)
415  * Must be called on unlocked socket.
416  */
417 static void sco_sock_kill(struct sock *sk)
418 {
419         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
420                 return;
421
422         BT_DBG("sk %p state %d", sk, sk->sk_state);
423
424         /* Kill poor orphan */
425         bt_sock_unlink(&sco_sk_list, sk);
426         sock_set_flag(sk, SOCK_DEAD);
427         sock_put(sk);
428 }
429
430 static void __sco_sock_close(struct sock *sk)
431 {
432         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
433
434         switch (sk->sk_state) {
435         case BT_LISTEN:
436                 sco_sock_cleanup_listen(sk);
437                 break;
438
439         case BT_CONNECTED:
440         case BT_CONFIG:
441                 if (sco_pi(sk)->conn->hcon) {
442                         sk->sk_state = BT_DISCONN;
443                         sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
444                         sco_conn_lock(sco_pi(sk)->conn);
445                         hci_conn_drop(sco_pi(sk)->conn->hcon);
446                         sco_pi(sk)->conn->hcon = NULL;
447                         sco_conn_unlock(sco_pi(sk)->conn);
448                 } else
449                         sco_chan_del(sk, ECONNRESET);
450                 break;
451
452         case BT_CONNECT2:
453         case BT_CONNECT:
454         case BT_DISCONN:
455                 sco_chan_del(sk, ECONNRESET);
456                 break;
457
458         default:
459                 sock_set_flag(sk, SOCK_ZAPPED);
460                 break;
461         }
462
463 }
464
465 /* Must be called on unlocked socket. */
466 static void sco_sock_close(struct sock *sk)
467 {
468         lock_sock(sk);
469         sco_sock_clear_timer(sk);
470         __sco_sock_close(sk);
471         release_sock(sk);
472 }
473
474 static void sco_sock_init(struct sock *sk, struct sock *parent)
475 {
476         BT_DBG("sk %p", sk);
477
478         if (parent) {
479                 sk->sk_type = parent->sk_type;
480                 bt_sk(sk)->flags = bt_sk(parent)->flags;
481                 security_sk_clone(parent, sk);
482         }
483 }
484
485 static struct proto sco_proto = {
486         .name           = "SCO",
487         .owner          = THIS_MODULE,
488         .obj_size       = sizeof(struct sco_pinfo)
489 };
490
491 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
492                                    int proto, gfp_t prio, int kern)
493 {
494         struct sock *sk;
495
496         sk = bt_sock_alloc(net, sock, &sco_proto, proto, prio, kern);
497         if (!sk)
498                 return NULL;
499
500         sk->sk_destruct = sco_sock_destruct;
501         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
502
503         sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
504         sco_pi(sk)->codec.id = BT_CODEC_CVSD;
505         sco_pi(sk)->codec.cid = 0xffff;
506         sco_pi(sk)->codec.vid = 0xffff;
507         sco_pi(sk)->codec.data_path = 0x00;
508
509         bt_sock_link(&sco_sk_list, sk);
510         return sk;
511 }
512
513 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
514                            int kern)
515 {
516         struct sock *sk;
517
518         BT_DBG("sock %p", sock);
519
520         sock->state = SS_UNCONNECTED;
521
522         if (sock->type != SOCK_SEQPACKET)
523                 return -ESOCKTNOSUPPORT;
524
525         sock->ops = &sco_sock_ops;
526
527         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
528         if (!sk)
529                 return -ENOMEM;
530
531         sco_sock_init(sk, NULL);
532         return 0;
533 }
534
535 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
536                          int addr_len)
537 {
538         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
539         struct sock *sk = sock->sk;
540         int err = 0;
541
542         if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
543             addr->sa_family != AF_BLUETOOTH)
544                 return -EINVAL;
545
546         BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
547
548         lock_sock(sk);
549
550         if (sk->sk_state != BT_OPEN) {
551                 err = -EBADFD;
552                 goto done;
553         }
554
555         if (sk->sk_type != SOCK_SEQPACKET) {
556                 err = -EINVAL;
557                 goto done;
558         }
559
560         bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
561
562         sk->sk_state = BT_BOUND;
563
564 done:
565         release_sock(sk);
566         return err;
567 }
568
569 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
570 {
571         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
572         struct sock *sk = sock->sk;
573         int err;
574
575         BT_DBG("sk %p", sk);
576
577         if (alen < sizeof(struct sockaddr_sco) ||
578             addr->sa_family != AF_BLUETOOTH)
579                 return -EINVAL;
580
581         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
582                 return -EBADFD;
583
584         if (sk->sk_type != SOCK_SEQPACKET)
585                 err = -EINVAL;
586
587         lock_sock(sk);
588         /* Set destination address and psm */
589         bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
590         release_sock(sk);
591
592         err = sco_connect(sk);
593         if (err)
594                 return err;
595
596         lock_sock(sk);
597
598         err = bt_sock_wait_state(sk, BT_CONNECTED,
599                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
600
601         release_sock(sk);
602         return err;
603 }
604
605 static int sco_sock_listen(struct socket *sock, int backlog)
606 {
607         struct sock *sk = sock->sk;
608         bdaddr_t *src = &sco_pi(sk)->src;
609         int err = 0;
610
611         BT_DBG("sk %p backlog %d", sk, backlog);
612
613         lock_sock(sk);
614
615         if (sk->sk_state != BT_BOUND) {
616                 err = -EBADFD;
617                 goto done;
618         }
619
620         if (sk->sk_type != SOCK_SEQPACKET) {
621                 err = -EINVAL;
622                 goto done;
623         }
624
625         write_lock(&sco_sk_list.lock);
626
627         if (__sco_get_sock_listen_by_addr(src)) {
628                 err = -EADDRINUSE;
629                 goto unlock;
630         }
631
632         sk->sk_max_ack_backlog = backlog;
633         sk->sk_ack_backlog = 0;
634
635         sk->sk_state = BT_LISTEN;
636
637 unlock:
638         write_unlock(&sco_sk_list.lock);
639
640 done:
641         release_sock(sk);
642         return err;
643 }
644
645 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
646                            int flags, bool kern)
647 {
648         DEFINE_WAIT_FUNC(wait, woken_wake_function);
649         struct sock *sk = sock->sk, *ch;
650         long timeo;
651         int err = 0;
652
653         lock_sock(sk);
654
655         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
656
657         BT_DBG("sk %p timeo %ld", sk, timeo);
658
659         /* Wait for an incoming connection. (wake-one). */
660         add_wait_queue_exclusive(sk_sleep(sk), &wait);
661         while (1) {
662                 if (sk->sk_state != BT_LISTEN) {
663                         err = -EBADFD;
664                         break;
665                 }
666
667                 ch = bt_accept_dequeue(sk, newsock);
668                 if (ch)
669                         break;
670
671                 if (!timeo) {
672                         err = -EAGAIN;
673                         break;
674                 }
675
676                 if (signal_pending(current)) {
677                         err = sock_intr_errno(timeo);
678                         break;
679                 }
680
681                 release_sock(sk);
682
683                 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
684                 lock_sock(sk);
685         }
686         remove_wait_queue(sk_sleep(sk), &wait);
687
688         if (err)
689                 goto done;
690
691         newsock->state = SS_CONNECTED;
692
693         BT_DBG("new socket %p", ch);
694
695 done:
696         release_sock(sk);
697         return err;
698 }
699
700 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
701                             int peer)
702 {
703         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
704         struct sock *sk = sock->sk;
705
706         BT_DBG("sock %p, sk %p", sock, sk);
707
708         addr->sa_family = AF_BLUETOOTH;
709
710         if (peer)
711                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
712         else
713                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
714
715         return sizeof(struct sockaddr_sco);
716 }
717
718 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
719                             size_t len)
720 {
721         struct sock *sk = sock->sk;
722         struct sk_buff *skb;
723         int err;
724
725         BT_DBG("sock %p, sk %p", sock, sk);
726
727         err = sock_error(sk);
728         if (err)
729                 return err;
730
731         if (msg->msg_flags & MSG_OOB)
732                 return -EOPNOTSUPP;
733
734         skb = bt_skb_sendmsg(sk, msg, len, len, 0, 0);
735         if (IS_ERR(skb))
736                 return PTR_ERR(skb);
737
738         lock_sock(sk);
739
740         if (sk->sk_state == BT_CONNECTED)
741                 err = sco_send_frame(sk, skb);
742         else
743                 err = -ENOTCONN;
744
745         release_sock(sk);
746
747         if (err < 0)
748                 kfree_skb(skb);
749         return err;
750 }
751
752 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
753 {
754         struct hci_dev *hdev = conn->hdev;
755
756         BT_DBG("conn %p", conn);
757
758         conn->state = BT_CONFIG;
759
760         if (!lmp_esco_capable(hdev)) {
761                 struct hci_cp_accept_conn_req cp;
762
763                 bacpy(&cp.bdaddr, &conn->dst);
764                 cp.role = 0x00; /* Ignored */
765
766                 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
767         } else {
768                 struct hci_cp_accept_sync_conn_req cp;
769
770                 bacpy(&cp.bdaddr, &conn->dst);
771                 cp.pkt_type = cpu_to_le16(conn->pkt_type);
772
773                 cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
774                 cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
775                 cp.content_format = cpu_to_le16(setting);
776
777                 switch (setting & SCO_AIRMODE_MASK) {
778                 case SCO_AIRMODE_TRANSP:
779                         if (conn->pkt_type & ESCO_2EV3)
780                                 cp.max_latency = cpu_to_le16(0x0008);
781                         else
782                                 cp.max_latency = cpu_to_le16(0x000D);
783                         cp.retrans_effort = 0x02;
784                         break;
785                 case SCO_AIRMODE_CVSD:
786                         cp.max_latency = cpu_to_le16(0xffff);
787                         cp.retrans_effort = 0xff;
788                         break;
789                 default:
790                         /* use CVSD settings as fallback */
791                         cp.max_latency = cpu_to_le16(0xffff);
792                         cp.retrans_effort = 0xff;
793                         break;
794                 }
795
796                 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
797                              sizeof(cp), &cp);
798         }
799 }
800
801 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
802                             size_t len, int flags)
803 {
804         struct sock *sk = sock->sk;
805         struct sco_pinfo *pi = sco_pi(sk);
806
807         lock_sock(sk);
808
809         if (sk->sk_state == BT_CONNECT2 &&
810             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
811                 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
812                 sk->sk_state = BT_CONFIG;
813
814                 release_sock(sk);
815                 return 0;
816         }
817
818         release_sock(sk);
819
820         return bt_sock_recvmsg(sock, msg, len, flags);
821 }
822
823 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
824                                sockptr_t optval, unsigned int optlen)
825 {
826         struct sock *sk = sock->sk;
827         int len, err = 0;
828         struct bt_voice voice;
829         u32 opt;
830         struct bt_codecs *codecs;
831         struct hci_dev *hdev;
832         __u8 buffer[255];
833
834         BT_DBG("sk %p", sk);
835
836         lock_sock(sk);
837
838         switch (optname) {
839
840         case BT_DEFER_SETUP:
841                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
842                         err = -EINVAL;
843                         break;
844                 }
845
846                 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
847                         err = -EFAULT;
848                         break;
849                 }
850
851                 if (opt)
852                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
853                 else
854                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
855                 break;
856
857         case BT_VOICE:
858                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
859                     sk->sk_state != BT_CONNECT2) {
860                         err = -EINVAL;
861                         break;
862                 }
863
864                 voice.setting = sco_pi(sk)->setting;
865
866                 len = min_t(unsigned int, sizeof(voice), optlen);
867                 if (copy_from_sockptr(&voice, optval, len)) {
868                         err = -EFAULT;
869                         break;
870                 }
871
872                 /* Explicitly check for these values */
873                 if (voice.setting != BT_VOICE_TRANSPARENT &&
874                     voice.setting != BT_VOICE_CVSD_16BIT) {
875                         err = -EINVAL;
876                         break;
877                 }
878
879                 sco_pi(sk)->setting = voice.setting;
880                 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
881                                      BDADDR_BREDR);
882                 if (!hdev) {
883                         err = -EBADFD;
884                         break;
885                 }
886                 if (enhanced_sync_conn_capable(hdev) &&
887                     voice.setting == BT_VOICE_TRANSPARENT)
888                         sco_pi(sk)->codec.id = BT_CODEC_TRANSPARENT;
889                 hci_dev_put(hdev);
890                 break;
891
892         case BT_PKT_STATUS:
893                 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
894                         err = -EFAULT;
895                         break;
896                 }
897
898                 if (opt)
899                         set_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
900                 else
901                         clear_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
902                 break;
903
904         case BT_CODEC:
905                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
906                     sk->sk_state != BT_CONNECT2) {
907                         err = -EINVAL;
908                         break;
909                 }
910
911                 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
912                                      BDADDR_BREDR);
913                 if (!hdev) {
914                         err = -EBADFD;
915                         break;
916                 }
917
918                 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
919                         hci_dev_put(hdev);
920                         err = -EOPNOTSUPP;
921                         break;
922                 }
923
924                 if (!hdev->get_data_path_id) {
925                         hci_dev_put(hdev);
926                         err = -EOPNOTSUPP;
927                         break;
928                 }
929
930                 if (optlen < sizeof(struct bt_codecs) ||
931                     optlen > sizeof(buffer)) {
932                         hci_dev_put(hdev);
933                         err = -EINVAL;
934                         break;
935                 }
936
937                 if (copy_from_sockptr(buffer, optval, optlen)) {
938                         hci_dev_put(hdev);
939                         err = -EFAULT;
940                         break;
941                 }
942
943                 codecs = (void *)buffer;
944
945                 if (codecs->num_codecs > 1) {
946                         hci_dev_put(hdev);
947                         err = -EINVAL;
948                         break;
949                 }
950
951                 sco_pi(sk)->codec = codecs->codecs[0];
952                 hci_dev_put(hdev);
953                 break;
954
955         default:
956                 err = -ENOPROTOOPT;
957                 break;
958         }
959
960         release_sock(sk);
961         return err;
962 }
963
964 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
965                                    char __user *optval, int __user *optlen)
966 {
967         struct sock *sk = sock->sk;
968         struct sco_options opts;
969         struct sco_conninfo cinfo;
970         int len, err = 0;
971
972         BT_DBG("sk %p", sk);
973
974         if (get_user(len, optlen))
975                 return -EFAULT;
976
977         lock_sock(sk);
978
979         switch (optname) {
980         case SCO_OPTIONS:
981                 if (sk->sk_state != BT_CONNECTED &&
982                     !(sk->sk_state == BT_CONNECT2 &&
983                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
984                         err = -ENOTCONN;
985                         break;
986                 }
987
988                 opts.mtu = sco_pi(sk)->conn->mtu;
989
990                 BT_DBG("mtu %u", opts.mtu);
991
992                 len = min_t(unsigned int, len, sizeof(opts));
993                 if (copy_to_user(optval, (char *)&opts, len))
994                         err = -EFAULT;
995
996                 break;
997
998         case SCO_CONNINFO:
999                 if (sk->sk_state != BT_CONNECTED &&
1000                     !(sk->sk_state == BT_CONNECT2 &&
1001                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
1002                         err = -ENOTCONN;
1003                         break;
1004                 }
1005
1006                 memset(&cinfo, 0, sizeof(cinfo));
1007                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
1008                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
1009
1010                 len = min_t(unsigned int, len, sizeof(cinfo));
1011                 if (copy_to_user(optval, (char *)&cinfo, len))
1012                         err = -EFAULT;
1013
1014                 break;
1015
1016         default:
1017                 err = -ENOPROTOOPT;
1018                 break;
1019         }
1020
1021         release_sock(sk);
1022         return err;
1023 }
1024
1025 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
1026                                char __user *optval, int __user *optlen)
1027 {
1028         struct sock *sk = sock->sk;
1029         int len, err = 0;
1030         struct bt_voice voice;
1031         u32 phys;
1032         int buf_len;
1033         struct codec_list *c;
1034         u8 num_codecs, i, __user *ptr;
1035         struct hci_dev *hdev;
1036         struct hci_codec_caps *caps;
1037         struct bt_codec codec;
1038
1039         BT_DBG("sk %p", sk);
1040
1041         if (level == SOL_SCO)
1042                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
1043
1044         if (get_user(len, optlen))
1045                 return -EFAULT;
1046
1047         lock_sock(sk);
1048
1049         switch (optname) {
1050
1051         case BT_DEFER_SETUP:
1052                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
1053                         err = -EINVAL;
1054                         break;
1055                 }
1056
1057                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
1058                              (u32 __user *)optval))
1059                         err = -EFAULT;
1060
1061                 break;
1062
1063         case BT_VOICE:
1064                 voice.setting = sco_pi(sk)->setting;
1065
1066                 len = min_t(unsigned int, len, sizeof(voice));
1067                 if (copy_to_user(optval, (char *)&voice, len))
1068                         err = -EFAULT;
1069
1070                 break;
1071
1072         case BT_PHY:
1073                 if (sk->sk_state != BT_CONNECTED) {
1074                         err = -ENOTCONN;
1075                         break;
1076                 }
1077
1078                 phys = hci_conn_get_phy(sco_pi(sk)->conn->hcon);
1079
1080                 if (put_user(phys, (u32 __user *) optval))
1081                         err = -EFAULT;
1082                 break;
1083
1084         case BT_PKT_STATUS:
1085                 if (put_user(test_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags),
1086                              (int __user *)optval))
1087                         err = -EFAULT;
1088                 break;
1089
1090         case BT_SNDMTU:
1091         case BT_RCVMTU:
1092                 if (sk->sk_state != BT_CONNECTED) {
1093                         err = -ENOTCONN;
1094                         break;
1095                 }
1096
1097                 if (put_user(sco_pi(sk)->conn->mtu, (u32 __user *)optval))
1098                         err = -EFAULT;
1099                 break;
1100
1101         case BT_CODEC:
1102                 num_codecs = 0;
1103                 buf_len = 0;
1104
1105                 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
1106                 if (!hdev) {
1107                         err = -EBADFD;
1108                         break;
1109                 }
1110
1111                 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
1112                         hci_dev_put(hdev);
1113                         err = -EOPNOTSUPP;
1114                         break;
1115                 }
1116
1117                 if (!hdev->get_data_path_id) {
1118                         hci_dev_put(hdev);
1119                         err = -EOPNOTSUPP;
1120                         break;
1121                 }
1122
1123                 release_sock(sk);
1124
1125                 /* find total buffer size required to copy codec + caps */
1126                 hci_dev_lock(hdev);
1127                 list_for_each_entry(c, &hdev->local_codecs, list) {
1128                         if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1129                                 continue;
1130                         num_codecs++;
1131                         for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1132                                 buf_len += 1 + caps->len;
1133                                 caps = (void *)&caps->data[caps->len];
1134                         }
1135                         buf_len += sizeof(struct bt_codec);
1136                 }
1137                 hci_dev_unlock(hdev);
1138
1139                 buf_len += sizeof(struct bt_codecs);
1140                 if (buf_len > len) {
1141                         hci_dev_put(hdev);
1142                         return -ENOBUFS;
1143                 }
1144                 ptr = optval;
1145
1146                 if (put_user(num_codecs, ptr)) {
1147                         hci_dev_put(hdev);
1148                         return -EFAULT;
1149                 }
1150                 ptr += sizeof(num_codecs);
1151
1152                 /* Iterate all the codecs supported over SCO and populate
1153                  * codec data
1154                  */
1155                 hci_dev_lock(hdev);
1156                 list_for_each_entry(c, &hdev->local_codecs, list) {
1157                         if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1158                                 continue;
1159
1160                         codec.id = c->id;
1161                         codec.cid = c->cid;
1162                         codec.vid = c->vid;
1163                         err = hdev->get_data_path_id(hdev, &codec.data_path);
1164                         if (err < 0)
1165                                 break;
1166                         codec.num_caps = c->num_caps;
1167                         if (copy_to_user(ptr, &codec, sizeof(codec))) {
1168                                 err = -EFAULT;
1169                                 break;
1170                         }
1171                         ptr += sizeof(codec);
1172
1173                         /* find codec capabilities data length */
1174                         len = 0;
1175                         for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1176                                 len += 1 + caps->len;
1177                                 caps = (void *)&caps->data[caps->len];
1178                         }
1179
1180                         /* copy codec capabilities data */
1181                         if (len && copy_to_user(ptr, c->caps, len)) {
1182                                 err = -EFAULT;
1183                                 break;
1184                         }
1185                         ptr += len;
1186                 }
1187
1188                 hci_dev_unlock(hdev);
1189                 hci_dev_put(hdev);
1190
1191                 lock_sock(sk);
1192
1193                 if (!err && put_user(buf_len, optlen))
1194                         err = -EFAULT;
1195
1196                 break;
1197
1198         default:
1199                 err = -ENOPROTOOPT;
1200                 break;
1201         }
1202
1203         release_sock(sk);
1204         return err;
1205 }
1206
1207 static int sco_sock_shutdown(struct socket *sock, int how)
1208 {
1209         struct sock *sk = sock->sk;
1210         int err = 0;
1211
1212         BT_DBG("sock %p, sk %p", sock, sk);
1213
1214         if (!sk)
1215                 return 0;
1216
1217         sock_hold(sk);
1218         lock_sock(sk);
1219
1220         if (!sk->sk_shutdown) {
1221                 sk->sk_shutdown = SHUTDOWN_MASK;
1222                 sco_sock_clear_timer(sk);
1223                 __sco_sock_close(sk);
1224
1225                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1226                     !(current->flags & PF_EXITING))
1227                         err = bt_sock_wait_state(sk, BT_CLOSED,
1228                                                  sk->sk_lingertime);
1229         }
1230
1231         release_sock(sk);
1232         sock_put(sk);
1233
1234         return err;
1235 }
1236
1237 static int sco_sock_release(struct socket *sock)
1238 {
1239         struct sock *sk = sock->sk;
1240         int err = 0;
1241
1242         BT_DBG("sock %p, sk %p", sock, sk);
1243
1244         if (!sk)
1245                 return 0;
1246
1247         sco_sock_close(sk);
1248
1249         if (sock_flag(sk, SOCK_LINGER) && READ_ONCE(sk->sk_lingertime) &&
1250             !(current->flags & PF_EXITING)) {
1251                 lock_sock(sk);
1252                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1253                 release_sock(sk);
1254         }
1255
1256         sock_orphan(sk);
1257         sco_sock_kill(sk);
1258         return err;
1259 }
1260
1261 static void sco_conn_ready(struct sco_conn *conn)
1262 {
1263         struct sock *parent;
1264         struct sock *sk = conn->sk;
1265
1266         BT_DBG("conn %p", conn);
1267
1268         if (sk) {
1269                 lock_sock(sk);
1270                 sco_sock_clear_timer(sk);
1271                 sk->sk_state = BT_CONNECTED;
1272                 sk->sk_state_change(sk);
1273                 release_sock(sk);
1274         } else {
1275                 sco_conn_lock(conn);
1276
1277                 if (!conn->hcon) {
1278                         sco_conn_unlock(conn);
1279                         return;
1280                 }
1281
1282                 parent = sco_get_sock_listen(&conn->hcon->src);
1283                 if (!parent) {
1284                         sco_conn_unlock(conn);
1285                         return;
1286                 }
1287
1288                 lock_sock(parent);
1289
1290                 sk = sco_sock_alloc(sock_net(parent), NULL,
1291                                     BTPROTO_SCO, GFP_ATOMIC, 0);
1292                 if (!sk) {
1293                         release_sock(parent);
1294                         sco_conn_unlock(conn);
1295                         return;
1296                 }
1297
1298                 sco_sock_init(sk, parent);
1299
1300                 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1301                 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1302
1303                 hci_conn_hold(conn->hcon);
1304                 __sco_chan_add(conn, sk, parent);
1305
1306                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1307                         sk->sk_state = BT_CONNECT2;
1308                 else
1309                         sk->sk_state = BT_CONNECTED;
1310
1311                 /* Wake up parent */
1312                 parent->sk_data_ready(parent);
1313
1314                 release_sock(parent);
1315
1316                 sco_conn_unlock(conn);
1317         }
1318 }
1319
1320 /* ----- SCO interface with lower layer (HCI) ----- */
1321 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1322 {
1323         struct sock *sk;
1324         int lm = 0;
1325
1326         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1327
1328         /* Find listening sockets */
1329         read_lock(&sco_sk_list.lock);
1330         sk_for_each(sk, &sco_sk_list.head) {
1331                 if (sk->sk_state != BT_LISTEN)
1332                         continue;
1333
1334                 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1335                     !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1336                         lm |= HCI_LM_ACCEPT;
1337
1338                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1339                                 *flags |= HCI_PROTO_DEFER;
1340                         break;
1341                 }
1342         }
1343         read_unlock(&sco_sk_list.lock);
1344
1345         return lm;
1346 }
1347
1348 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1349 {
1350         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1351                 return;
1352
1353         BT_DBG("hcon %p bdaddr %pMR status %u", hcon, &hcon->dst, status);
1354
1355         if (!status) {
1356                 struct sco_conn *conn;
1357
1358                 conn = sco_conn_add(hcon);
1359                 if (conn)
1360                         sco_conn_ready(conn);
1361         } else
1362                 sco_conn_del(hcon, bt_to_errno(status));
1363 }
1364
1365 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1366 {
1367         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1368                 return;
1369
1370         BT_DBG("hcon %p reason %d", hcon, reason);
1371
1372         sco_conn_del(hcon, bt_to_errno(reason));
1373 }
1374
1375 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1376 {
1377         struct sco_conn *conn = hcon->sco_data;
1378
1379         if (!conn)
1380                 goto drop;
1381
1382         BT_DBG("conn %p len %u", conn, skb->len);
1383
1384         if (skb->len) {
1385                 sco_recv_frame(conn, skb);
1386                 return;
1387         }
1388
1389 drop:
1390         kfree_skb(skb);
1391 }
1392
1393 static struct hci_cb sco_cb = {
1394         .name           = "SCO",
1395         .connect_cfm    = sco_connect_cfm,
1396         .disconn_cfm    = sco_disconn_cfm,
1397 };
1398
1399 static int sco_debugfs_show(struct seq_file *f, void *p)
1400 {
1401         struct sock *sk;
1402
1403         read_lock(&sco_sk_list.lock);
1404
1405         sk_for_each(sk, &sco_sk_list.head) {
1406                 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1407                            &sco_pi(sk)->dst, sk->sk_state);
1408         }
1409
1410         read_unlock(&sco_sk_list.lock);
1411
1412         return 0;
1413 }
1414
1415 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1416
1417 static struct dentry *sco_debugfs;
1418
1419 static const struct proto_ops sco_sock_ops = {
1420         .family         = PF_BLUETOOTH,
1421         .owner          = THIS_MODULE,
1422         .release        = sco_sock_release,
1423         .bind           = sco_sock_bind,
1424         .connect        = sco_sock_connect,
1425         .listen         = sco_sock_listen,
1426         .accept         = sco_sock_accept,
1427         .getname        = sco_sock_getname,
1428         .sendmsg        = sco_sock_sendmsg,
1429         .recvmsg        = sco_sock_recvmsg,
1430         .poll           = bt_sock_poll,
1431         .ioctl          = bt_sock_ioctl,
1432         .gettstamp      = sock_gettstamp,
1433         .mmap           = sock_no_mmap,
1434         .socketpair     = sock_no_socketpair,
1435         .shutdown       = sco_sock_shutdown,
1436         .setsockopt     = sco_sock_setsockopt,
1437         .getsockopt     = sco_sock_getsockopt
1438 };
1439
1440 static const struct net_proto_family sco_sock_family_ops = {
1441         .family = PF_BLUETOOTH,
1442         .owner  = THIS_MODULE,
1443         .create = sco_sock_create,
1444 };
1445
1446 int __init sco_init(void)
1447 {
1448         int err;
1449
1450         BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1451
1452         err = proto_register(&sco_proto, 0);
1453         if (err < 0)
1454                 return err;
1455
1456         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1457         if (err < 0) {
1458                 BT_ERR("SCO socket registration failed");
1459                 goto error;
1460         }
1461
1462         err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1463         if (err < 0) {
1464                 BT_ERR("Failed to create SCO proc file");
1465                 bt_sock_unregister(BTPROTO_SCO);
1466                 goto error;
1467         }
1468
1469         BT_INFO("SCO socket layer initialized");
1470
1471         hci_register_cb(&sco_cb);
1472
1473         if (IS_ERR_OR_NULL(bt_debugfs))
1474                 return 0;
1475
1476         sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1477                                           NULL, &sco_debugfs_fops);
1478
1479         return 0;
1480
1481 error:
1482         proto_unregister(&sco_proto);
1483         return err;
1484 }
1485
1486 void sco_exit(void)
1487 {
1488         bt_procfs_cleanup(&init_net, "sco");
1489
1490         debugfs_remove(sco_debugfs);
1491
1492         hci_unregister_cb(&sco_cb);
1493
1494         bt_sock_unregister(BTPROTO_SCO);
1495
1496         proto_unregister(&sco_proto);
1497 }
1498
1499 module_param(disable_esco, bool, 0644);
1500 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
This page took 0.114899 seconds and 4 git commands to generate.