~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/bluetooth/sco.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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_KERNEL);
 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_drop(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_drop(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;
485 
486         BT_DBG("sk %p", sk);
487 
488         if (alen < sizeof(struct sockaddr_sco) ||
489             addr->sa_family != AF_BLUETOOTH)
490                 return -EINVAL;
491 
492         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
493                 return -EBADFD;
494 
495         if (sk->sk_type != SOCK_SEQPACKET)
496                 return -EINVAL;
497 
498         lock_sock(sk);
499 
500         /* Set destination address and psm */
501         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
502 
503         err = sco_connect(sk);
504         if (err)
505                 goto done;
506 
507         err = bt_sock_wait_state(sk, BT_CONNECTED,
508                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
509 
510 done:
511         release_sock(sk);
512         return err;
513 }
514 
515 static int sco_sock_listen(struct socket *sock, int backlog)
516 {
517         struct sock *sk = sock->sk;
518         bdaddr_t *src = &bt_sk(sk)->src;
519         int err = 0;
520 
521         BT_DBG("sk %p backlog %d", sk, backlog);
522 
523         lock_sock(sk);
524 
525         if (sk->sk_state != BT_BOUND) {
526                 err = -EBADFD;
527                 goto done;
528         }
529 
530         if (sk->sk_type != SOCK_SEQPACKET) {
531                 err = -EINVAL;
532                 goto done;
533         }
534 
535         write_lock(&sco_sk_list.lock);
536 
537         if (__sco_get_sock_listen_by_addr(src)) {
538                 err = -EADDRINUSE;
539                 goto unlock;
540         }
541 
542         sk->sk_max_ack_backlog = backlog;
543         sk->sk_ack_backlog = 0;
544 
545         sk->sk_state = BT_LISTEN;
546 
547 unlock:
548         write_unlock(&sco_sk_list.lock);
549 
550 done:
551         release_sock(sk);
552         return err;
553 }
554 
555 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
556 {
557         DECLARE_WAITQUEUE(wait, current);
558         struct sock *sk = sock->sk, *ch;
559         long timeo;
560         int err = 0;
561 
562         lock_sock(sk);
563 
564         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
565 
566         BT_DBG("sk %p timeo %ld", sk, timeo);
567 
568         /* Wait for an incoming connection. (wake-one). */
569         add_wait_queue_exclusive(sk_sleep(sk), &wait);
570         while (1) {
571                 set_current_state(TASK_INTERRUPTIBLE);
572 
573                 if (sk->sk_state != BT_LISTEN) {
574                         err = -EBADFD;
575                         break;
576                 }
577 
578                 ch = bt_accept_dequeue(sk, newsock);
579                 if (ch)
580                         break;
581 
582                 if (!timeo) {
583                         err = -EAGAIN;
584                         break;
585                 }
586 
587                 if (signal_pending(current)) {
588                         err = sock_intr_errno(timeo);
589                         break;
590                 }
591 
592                 release_sock(sk);
593                 timeo = schedule_timeout(timeo);
594                 lock_sock(sk);
595         }
596         __set_current_state(TASK_RUNNING);
597         remove_wait_queue(sk_sleep(sk), &wait);
598 
599         if (err)
600                 goto done;
601 
602         newsock->state = SS_CONNECTED;
603 
604         BT_DBG("new socket %p", ch);
605 
606 done:
607         release_sock(sk);
608         return err;
609 }
610 
611 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
612 {
613         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
614         struct sock *sk = sock->sk;
615 
616         BT_DBG("sock %p, sk %p", sock, sk);
617 
618         addr->sa_family = AF_BLUETOOTH;
619         *len = sizeof(struct sockaddr_sco);
620 
621         if (peer)
622                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
623         else
624                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
625 
626         return 0;
627 }
628 
629 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
630                             struct msghdr *msg, size_t len)
631 {
632         struct sock *sk = sock->sk;
633         int err;
634 
635         BT_DBG("sock %p, sk %p", sock, sk);
636 
637         err = sock_error(sk);
638         if (err)
639                 return err;
640 
641         if (msg->msg_flags & MSG_OOB)
642                 return -EOPNOTSUPP;
643 
644         lock_sock(sk);
645 
646         if (sk->sk_state == BT_CONNECTED)
647                 err = sco_send_frame(sk, msg, len);
648         else
649                 err = -ENOTCONN;
650 
651         release_sock(sk);
652         return err;
653 }
654 
655 static void sco_conn_defer_accept(struct hci_conn *conn, int mask)
656 {
657         struct hci_dev *hdev = conn->hdev;
658 
659         BT_DBG("conn %p", conn);
660 
661         conn->state = BT_CONFIG;
662 
663         if (!lmp_esco_capable(hdev)) {
664                 struct hci_cp_accept_conn_req cp;
665 
666                 bacpy(&cp.bdaddr, &conn->dst);
667 
668                 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
669                         cp.role = 0x00; /* Become master */
670                 else
671                         cp.role = 0x01; /* Remain slave */
672 
673                 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
674         } else {
675                 struct hci_cp_accept_sync_conn_req cp;
676 
677                 bacpy(&cp.bdaddr, &conn->dst);
678                 cp.pkt_type = cpu_to_le16(conn->pkt_type);
679 
680                 cp.tx_bandwidth   = __constant_cpu_to_le32(0x00001f40);
681                 cp.rx_bandwidth   = __constant_cpu_to_le32(0x00001f40);
682                 cp.max_latency    = __constant_cpu_to_le16(0xffff);
683                 cp.content_format = cpu_to_le16(hdev->voice_setting);
684                 cp.retrans_effort = 0xff;
685 
686                 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
687                              sizeof(cp), &cp);
688         }
689 }
690 
691 static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
692                             struct msghdr *msg, size_t len, int flags)
693 {
694         struct sock *sk = sock->sk;
695         struct sco_pinfo *pi = sco_pi(sk);
696 
697         lock_sock(sk);
698 
699         if (sk->sk_state == BT_CONNECT2 &&
700             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
701                 sco_conn_defer_accept(pi->conn->hcon, 0);
702                 sk->sk_state = BT_CONFIG;
703                 msg->msg_namelen = 0;
704 
705                 release_sock(sk);
706                 return 0;
707         }
708 
709         release_sock(sk);
710 
711         return bt_sock_recvmsg(iocb, sock, msg, len, flags);
712 }
713 
714 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
715 {
716         struct sock *sk = sock->sk;
717         int err = 0;
718         u32 opt;
719 
720         BT_DBG("sk %p", sk);
721 
722         lock_sock(sk);
723 
724         switch (optname) {
725 
726         case BT_DEFER_SETUP:
727                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
728                         err = -EINVAL;
729                         break;
730                 }
731 
732                 if (get_user(opt, (u32 __user *) optval)) {
733                         err = -EFAULT;
734                         break;
735                 }
736 
737                 if (opt)
738                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
739                 else
740                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
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_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
753 {
754         struct sock *sk = sock->sk;
755         struct sco_options opts;
756         struct sco_conninfo cinfo;
757         int len, err = 0;
758 
759         BT_DBG("sk %p", sk);
760 
761         if (get_user(len, optlen))
762                 return -EFAULT;
763 
764         lock_sock(sk);
765 
766         switch (optname) {
767         case SCO_OPTIONS:
768                 if (sk->sk_state != BT_CONNECTED) {
769                         err = -ENOTCONN;
770                         break;
771                 }
772 
773                 opts.mtu = sco_pi(sk)->conn->mtu;
774 
775                 BT_DBG("mtu %d", opts.mtu);
776 
777                 len = min_t(unsigned int, len, sizeof(opts));
778                 if (copy_to_user(optval, (char *)&opts, len))
779                         err = -EFAULT;
780 
781                 break;
782 
783         case SCO_CONNINFO:
784                 if (sk->sk_state != BT_CONNECTED) {
785                         err = -ENOTCONN;
786                         break;
787                 }
788 
789                 memset(&cinfo, 0, sizeof(cinfo));
790                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
791                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
792 
793                 len = min_t(unsigned int, len, sizeof(cinfo));
794                 if (copy_to_user(optval, (char *)&cinfo, len))
795                         err = -EFAULT;
796 
797                 break;
798 
799         default:
800                 err = -ENOPROTOOPT;
801                 break;
802         }
803 
804         release_sock(sk);
805         return err;
806 }
807 
808 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
809 {
810         struct sock *sk = sock->sk;
811         int len, err = 0;
812 
813         BT_DBG("sk %p", sk);
814 
815         if (level == SOL_SCO)
816                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
817 
818         if (get_user(len, optlen))
819                 return -EFAULT;
820 
821         lock_sock(sk);
822 
823         switch (optname) {
824 
825         case BT_DEFER_SETUP:
826                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
827                         err = -EINVAL;
828                         break;
829                 }
830 
831                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
832                              (u32 __user *) optval))
833                         err = -EFAULT;
834 
835                 break;
836 
837         default:
838                 err = -ENOPROTOOPT;
839                 break;
840         }
841 
842         release_sock(sk);
843         return err;
844 }
845 
846 static int sco_sock_shutdown(struct socket *sock, int how)
847 {
848         struct sock *sk = sock->sk;
849         int err = 0;
850 
851         BT_DBG("sock %p, sk %p", sock, sk);
852 
853         if (!sk)
854                 return 0;
855 
856         lock_sock(sk);
857         if (!sk->sk_shutdown) {
858                 sk->sk_shutdown = SHUTDOWN_MASK;
859                 sco_sock_clear_timer(sk);
860                 __sco_sock_close(sk);
861 
862                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
863                         err = bt_sock_wait_state(sk, BT_CLOSED,
864                                                  sk->sk_lingertime);
865         }
866         release_sock(sk);
867         return err;
868 }
869 
870 static int sco_sock_release(struct socket *sock)
871 {
872         struct sock *sk = sock->sk;
873         int err = 0;
874 
875         BT_DBG("sock %p, sk %p", sock, sk);
876 
877         if (!sk)
878                 return 0;
879 
880         sco_sock_close(sk);
881 
882         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
883                 lock_sock(sk);
884                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
885                 release_sock(sk);
886         }
887 
888         sock_orphan(sk);
889         sco_sock_kill(sk);
890         return err;
891 }
892 
893 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
894 {
895         BT_DBG("conn %p", conn);
896 
897         sco_pi(sk)->conn = conn;
898         conn->sk = sk;
899 
900         if (parent)
901                 bt_accept_enqueue(parent, sk);
902 }
903 
904 /* Delete channel.
905  * Must be called on the locked socket. */
906 static void sco_chan_del(struct sock *sk, int err)
907 {
908         struct sco_conn *conn;
909 
910         conn = sco_pi(sk)->conn;
911 
912         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
913 
914         if (conn) {
915                 sco_conn_lock(conn);
916                 conn->sk = NULL;
917                 sco_pi(sk)->conn = NULL;
918                 sco_conn_unlock(conn);
919 
920                 if (conn->hcon)
921                         hci_conn_drop(conn->hcon);
922         }
923 
924         sk->sk_state = BT_CLOSED;
925         sk->sk_err   = err;
926         sk->sk_state_change(sk);
927 
928         sock_set_flag(sk, SOCK_ZAPPED);
929 }
930 
931 static void sco_conn_ready(struct sco_conn *conn)
932 {
933         struct sock *parent;
934         struct sock *sk = conn->sk;
935 
936         BT_DBG("conn %p", conn);
937 
938         if (sk) {
939                 sco_sock_clear_timer(sk);
940                 bh_lock_sock(sk);
941                 sk->sk_state = BT_CONNECTED;
942                 sk->sk_state_change(sk);
943                 bh_unlock_sock(sk);
944         } else {
945                 sco_conn_lock(conn);
946 
947                 parent = sco_get_sock_listen(conn->src);
948                 if (!parent) {
949                         sco_conn_unlock(conn);
950                         return;
951                 }
952 
953                 bh_lock_sock(parent);
954 
955                 sk = sco_sock_alloc(sock_net(parent), NULL,
956                                     BTPROTO_SCO, GFP_ATOMIC);
957                 if (!sk) {
958                         bh_unlock_sock(parent);
959                         sco_conn_unlock(conn);
960                         return;
961                 }
962 
963                 sco_sock_init(sk, parent);
964 
965                 bacpy(&bt_sk(sk)->src, conn->src);
966                 bacpy(&bt_sk(sk)->dst, conn->dst);
967 
968                 hci_conn_hold(conn->hcon);
969                 __sco_chan_add(conn, sk, parent);
970 
971                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
972                         sk->sk_state = BT_CONNECT2;
973                 else
974                         sk->sk_state = BT_CONNECTED;
975 
976                 /* Wake up parent */
977                 parent->sk_data_ready(parent, 1);
978 
979                 bh_unlock_sock(parent);
980 
981                 sco_conn_unlock(conn);
982         }
983 }
984 
985 /* ----- SCO interface with lower layer (HCI) ----- */
986 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
987 {
988         struct sock *sk;
989         int lm = 0;
990 
991         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
992 
993         /* Find listening sockets */
994         read_lock(&sco_sk_list.lock);
995         sk_for_each(sk, &sco_sk_list.head) {
996                 if (sk->sk_state != BT_LISTEN)
997                         continue;
998 
999                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
1000                     !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
1001                         lm |= HCI_LM_ACCEPT;
1002 
1003                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1004                                 *flags |= HCI_PROTO_DEFER;
1005                         break;
1006                 }
1007         }
1008         read_unlock(&sco_sk_list.lock);
1009 
1010         return lm;
1011 }
1012 
1013 void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1014 {
1015         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1016         if (!status) {
1017                 struct sco_conn *conn;
1018 
1019                 conn = sco_conn_add(hcon);
1020                 if (conn)
1021                         sco_conn_ready(conn);
1022         } else
1023                 sco_conn_del(hcon, bt_to_errno(status));
1024 }
1025 
1026 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1027 {
1028         BT_DBG("hcon %p reason %d", hcon, reason);
1029 
1030         sco_conn_del(hcon, bt_to_errno(reason));
1031 }
1032 
1033 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1034 {
1035         struct sco_conn *conn = hcon->sco_data;
1036 
1037         if (!conn)
1038                 goto drop;
1039 
1040         BT_DBG("conn %p len %d", conn, skb->len);
1041 
1042         if (skb->len) {
1043                 sco_recv_frame(conn, skb);
1044                 return 0;
1045         }
1046 
1047 drop:
1048         kfree_skb(skb);
1049         return 0;
1050 }
1051 
1052 static int sco_debugfs_show(struct seq_file *f, void *p)
1053 {
1054         struct sock *sk;
1055 
1056         read_lock(&sco_sk_list.lock);
1057 
1058         sk_for_each(sk, &sco_sk_list.head) {
1059                 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1060                            &bt_sk(sk)->dst, sk->sk_state);
1061         }
1062 
1063         read_unlock(&sco_sk_list.lock);
1064 
1065         return 0;
1066 }
1067 
1068 static int sco_debugfs_open(struct inode *inode, struct file *file)
1069 {
1070         return single_open(file, sco_debugfs_show, inode->i_private);
1071 }
1072 
1073 static const struct file_operations sco_debugfs_fops = {
1074         .open           = sco_debugfs_open,
1075         .read           = seq_read,
1076         .llseek         = seq_lseek,
1077         .release        = single_release,
1078 };
1079 
1080 static struct dentry *sco_debugfs;
1081 
1082 static const struct proto_ops sco_sock_ops = {
1083         .family         = PF_BLUETOOTH,
1084         .owner          = THIS_MODULE,
1085         .release        = sco_sock_release,
1086         .bind           = sco_sock_bind,
1087         .connect        = sco_sock_connect,
1088         .listen         = sco_sock_listen,
1089         .accept         = sco_sock_accept,
1090         .getname        = sco_sock_getname,
1091         .sendmsg        = sco_sock_sendmsg,
1092         .recvmsg        = sco_sock_recvmsg,
1093         .poll           = bt_sock_poll,
1094         .ioctl          = bt_sock_ioctl,
1095         .mmap           = sock_no_mmap,
1096         .socketpair     = sock_no_socketpair,
1097         .shutdown       = sco_sock_shutdown,
1098         .setsockopt     = sco_sock_setsockopt,
1099         .getsockopt     = sco_sock_getsockopt
1100 };
1101 
1102 static const struct net_proto_family sco_sock_family_ops = {
1103         .family = PF_BLUETOOTH,
1104         .owner  = THIS_MODULE,
1105         .create = sco_sock_create,
1106 };
1107 
1108 int __init sco_init(void)
1109 {
1110         int err;
1111 
1112         err = proto_register(&sco_proto, 0);
1113         if (err < 0)
1114                 return err;
1115 
1116         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1117         if (err < 0) {
1118                 BT_ERR("SCO socket registration failed");
1119                 goto error;
1120         }
1121 
1122         err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1123         if (err < 0) {
1124                 BT_ERR("Failed to create SCO proc file");
1125                 bt_sock_unregister(BTPROTO_SCO);
1126                 goto error;
1127         }
1128 
1129         if (bt_debugfs) {
1130                 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1131                                                   NULL, &sco_debugfs_fops);
1132                 if (!sco_debugfs)
1133                         BT_ERR("Failed to create SCO debug file");
1134         }
1135 
1136         BT_INFO("SCO socket layer initialized");
1137 
1138         return 0;
1139 
1140 error:
1141         proto_unregister(&sco_proto);
1142         return err;
1143 }
1144 
1145 void __exit sco_exit(void)
1146 {
1147         bt_procfs_cleanup(&init_net, "sco");
1148 
1149         debugfs_remove(sco_debugfs);
1150 
1151         bt_sock_unregister(BTPROTO_SCO);
1152 
1153         proto_unregister(&sco_proto);
1154 }
1155 
1156 module_param(disable_esco, bool, 0644);
1157 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1158 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp