blob: 4767928a93d397b8716730a1f62c16bd3f3639db [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 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
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090015 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090020 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth SCO sockets. */
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
28
29#include <linux/types.h>
30#include <linux/errno.h>
31#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#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>
Marcel Holtmannbe9d1222005-11-08 09:57:38 -080040#include <linux/device.h>
Marcel Holtmannaef7d972010-03-21 05:27:45 +010041#include <linux/debugfs.h>
42#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/list.h>
44#include <net/sock.h>
45
46#include <asm/system.h>
47#include <asm/uaccess.h>
48
49#include <net/bluetooth/bluetooth.h>
50#include <net/bluetooth/hci_core.h>
51#include <net/bluetooth/sco.h>
52
Marcel Holtmann7cb127d2008-07-14 20:13:53 +020053#define VERSION "0.6"
54
55static int disable_esco = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Eric Dumazet90ddc4f2005-12-22 12:49:22 -080057static const struct proto_ops sco_sock_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59static struct bt_sock_list sco_sk_list = {
Robert P. J. Dayd5fb2962008-03-28 16:17:38 -070060 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061};
62
63static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
64static void sco_chan_del(struct sock *sk, int err);
65
66static int sco_conn_del(struct hci_conn *conn, int err);
67
68static void sco_sock_close(struct sock *sk);
69static void sco_sock_kill(struct sock *sk);
70
71/* ---- SCO timers ---- */
72static void sco_sock_timeout(unsigned long arg)
73{
74 struct sock *sk = (struct sock *) arg;
75
76 BT_DBG("sock %p state %d", sk, sk->sk_state);
77
78 bh_lock_sock(sk);
79 sk->sk_err = ETIMEDOUT;
80 sk->sk_state_change(sk);
81 bh_unlock_sock(sk);
82
83 sco_sock_kill(sk);
84 sock_put(sk);
85}
86
87static void sco_sock_set_timer(struct sock *sk, long timeout)
88{
89 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
90 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
91}
92
93static void sco_sock_clear_timer(struct sock *sk)
94{
95 BT_DBG("sock %p state %d", sk, sk->sk_state);
96 sk_stop_timer(sk, &sk->sk_timer);
97}
98
Linus Torvalds1da177e2005-04-16 15:20:36 -070099/* ---- SCO connections ---- */
100static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
101{
102 struct hci_dev *hdev = hcon->hdev;
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200103 struct sco_conn *conn = hcon->sco_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200105 if (conn || status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 return conn;
107
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200108 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
109 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112 spin_lock_init(&conn->lock);
113
114 hcon->sco_data = conn;
115 conn->hcon = hcon;
116
117 conn->src = &hdev->bdaddr;
118 conn->dst = &hcon->dst;
119
120 if (hdev->sco_mtu > 0)
121 conn->mtu = hdev->sco_mtu;
122 else
123 conn->mtu = 60;
124
125 BT_DBG("hcon %p conn %p", hcon, conn);
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 return conn;
128}
129
130static inline struct sock *sco_chan_get(struct sco_conn *conn)
131{
132 struct sock *sk = NULL;
133 sco_conn_lock(conn);
134 sk = conn->sk;
135 sco_conn_unlock(conn);
136 return sk;
137}
138
139static int sco_conn_del(struct hci_conn *hcon, int err)
140{
141 struct sco_conn *conn;
142 struct sock *sk;
143
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900144 if (!(conn = hcon->sco_data))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 return 0;
146
147 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
148
149 /* Kill socket */
150 if ((sk = sco_chan_get(conn))) {
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
163static 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);
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300168 if (conn->sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 err = -EBUSY;
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300170 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 __sco_chan_add(conn, sk, parent);
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 sco_conn_unlock(conn);
174 return err;
175}
176
177static int sco_connect(struct sock *sk)
178{
179 bdaddr_t *src = &bt_sk(sk)->src;
180 bdaddr_t *dst = &bt_sk(sk)->dst;
181 struct sco_conn *conn;
182 struct hci_conn *hcon;
183 struct hci_dev *hdev;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200184 int err, type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
186 BT_DBG("%s -> %s", batostr(src), batostr(dst));
187
188 if (!(hdev = hci_get_route(dst, src)))
189 return -EHOSTUNREACH;
190
191 hci_dev_lock_bh(hdev);
192
193 err = -ENOMEM;
194
Marcel Holtmann7cb127d2008-07-14 20:13:53 +0200195 if (lmp_esco_capable(hdev) && !disable_esco)
196 type = ESCO_LINK;
197 else
198 type = SCO_LINK;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200199
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100200 hcon = hci_connect(hdev, type, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 if (!hcon)
202 goto done;
203
204 conn = sco_conn_add(hcon, 0);
205 if (!conn) {
206 hci_conn_put(hcon);
207 goto done;
208 }
209
210 /* Update source addr of the socket */
211 bacpy(src, conn->src);
212
213 err = sco_chan_add(conn, sk, NULL);
214 if (err)
215 goto done;
216
217 if (hcon->state == BT_CONNECTED) {
218 sco_sock_clear_timer(sk);
219 sk->sk_state = BT_CONNECTED;
220 } else {
221 sk->sk_state = BT_CONNECT;
222 sco_sock_set_timer(sk, sk->sk_sndtimeo);
223 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225done:
226 hci_dev_unlock_bh(hdev);
227 hci_dev_put(hdev);
228 return err;
229}
230
231static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
232{
233 struct sco_conn *conn = sco_pi(sk)->conn;
234 struct sk_buff *skb;
235 int err, count;
236
237 /* Check outgoing MTU */
238 if (len > conn->mtu)
239 return -EINVAL;
240
241 BT_DBG("sk %p len %d", sk, len);
242
243 count = min_t(unsigned int, conn->mtu, len);
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300244 skb = bt_skb_send_alloc(sk, count,
245 msg->msg_flags & MSG_DONTWAIT, &err);
246 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 return err;
248
249 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300250 kfree_skb(skb);
251 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
253
Gustavo F. Padovan0d861d82010-05-01 16:15:35 -0300254 hci_send_sco(conn->hcon, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257}
258
259static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
260{
261 struct sock *sk = sco_chan_get(conn);
262
263 if (!sk)
264 goto drop;
265
266 BT_DBG("sk %p len %d", sk, skb->len);
267
268 if (sk->sk_state != BT_CONNECTED)
269 goto drop;
270
271 if (!sock_queue_rcv_skb(sk, skb))
272 return;
273
274drop:
275 kfree_skb(skb);
276 return;
277}
278
279/* -------- Socket interface ---------- */
280static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
281{
282 struct sock *sk;
283 struct hlist_node *node;
284
285 sk_for_each(sk, node, &sco_sk_list.head)
286 if (!bacmp(&bt_sk(sk)->src, ba))
287 goto found;
288 sk = NULL;
289found:
290 return sk;
291}
292
293/* Find socket listening on source bdaddr.
294 * Returns closest match.
295 */
296static struct sock *sco_get_sock_listen(bdaddr_t *src)
297{
298 struct sock *sk = NULL, *sk1 = NULL;
299 struct hlist_node *node;
300
301 read_lock(&sco_sk_list.lock);
302
303 sk_for_each(sk, node, &sco_sk_list.head) {
304 if (sk->sk_state != BT_LISTEN)
305 continue;
306
307 /* Exact match. */
308 if (!bacmp(&bt_sk(sk)->src, src))
309 break;
310
311 /* Closest match */
312 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
313 sk1 = sk;
314 }
315
316 read_unlock(&sco_sk_list.lock);
317
318 return node ? sk : sk1;
319}
320
321static void sco_sock_destruct(struct sock *sk)
322{
323 BT_DBG("sk %p", sk);
324
325 skb_queue_purge(&sk->sk_receive_queue);
326 skb_queue_purge(&sk->sk_write_queue);
327}
328
329static void sco_sock_cleanup_listen(struct sock *parent)
330{
331 struct sock *sk;
332
333 BT_DBG("parent %p", parent);
334
335 /* Close not yet accepted channels */
336 while ((sk = bt_accept_dequeue(parent, NULL))) {
337 sco_sock_close(sk);
338 sco_sock_kill(sk);
339 }
340
341 parent->sk_state = BT_CLOSED;
342 sock_set_flag(parent, SOCK_ZAPPED);
343}
344
345/* Kill socket (only if zapped and orphan)
346 * Must be called on unlocked socket.
347 */
348static void sco_sock_kill(struct sock *sk)
349{
350 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
351 return;
352
353 BT_DBG("sk %p state %d", sk, sk->sk_state);
354
355 /* Kill poor orphan */
356 bt_sock_unlink(&sco_sk_list, sk);
357 sock_set_flag(sk, SOCK_DEAD);
358 sock_put(sk);
359}
360
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200361static void __sco_sock_close(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200363 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
365 switch (sk->sk_state) {
366 case BT_LISTEN:
367 sco_sock_cleanup_listen(sk);
368 break;
369
370 case BT_CONNECTED:
371 case BT_CONFIG:
372 case BT_CONNECT:
373 case BT_DISCONN:
374 sco_chan_del(sk, ECONNRESET);
375 break;
376
377 default:
378 sock_set_flag(sk, SOCK_ZAPPED);
379 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700380 }
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200381}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200383/* Must be called on unlocked socket. */
384static void sco_sock_close(struct sock *sk)
385{
386 sco_sock_clear_timer(sk);
387 lock_sock(sk);
388 __sco_sock_close(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 sco_sock_kill(sk);
391}
392
393static void sco_sock_init(struct sock *sk, struct sock *parent)
394{
395 BT_DBG("sk %p", sk);
396
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900397 if (parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 sk->sk_type = parent->sk_type;
399}
400
401static struct proto sco_proto = {
402 .name = "SCO",
403 .owner = THIS_MODULE,
404 .obj_size = sizeof(struct sco_pinfo)
405};
406
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700407static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408{
409 struct sock *sk;
410
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700411 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 if (!sk)
413 return NULL;
414
415 sock_init_data(sock, sk);
416 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
417
418 sk->sk_destruct = sco_sock_destruct;
419 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
420
421 sock_reset_flag(sk, SOCK_ZAPPED);
422
423 sk->sk_protocol = proto;
424 sk->sk_state = BT_OPEN;
425
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800426 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
428 bt_sock_link(&sco_sk_list, sk);
429 return sk;
430}
431
Eric Paris3f378b62009-11-05 22:18:14 -0800432static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
433 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
435 struct sock *sk;
436
437 BT_DBG("sock %p", sock);
438
439 sock->state = SS_UNCONNECTED;
440
441 if (sock->type != SOCK_SEQPACKET)
442 return -ESOCKTNOSUPPORT;
443
444 sock->ops = &sco_sock_ops;
445
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700446 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
Marcel Holtmann74da6262006-10-15 17:31:14 +0200447 if (!sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return -ENOMEM;
449
450 sco_sock_init(sk, NULL);
451 return 0;
452}
453
454static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
455{
456 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
457 struct sock *sk = sock->sk;
458 bdaddr_t *src = &sa->sco_bdaddr;
459 int err = 0;
460
461 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
462
463 if (!addr || addr->sa_family != AF_BLUETOOTH)
464 return -EINVAL;
465
466 lock_sock(sk);
467
468 if (sk->sk_state != BT_OPEN) {
469 err = -EBADFD;
470 goto done;
471 }
472
473 write_lock_bh(&sco_sk_list.lock);
474
475 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
476 err = -EADDRINUSE;
477 } else {
478 /* Save source address */
479 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
480 sk->sk_state = BT_BOUND;
481 }
482
483 write_unlock_bh(&sco_sk_list.lock);
484
485done:
486 release_sock(sk);
487 return err;
488}
489
490static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
491{
492 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
493 struct sock *sk = sock->sk;
494 int err = 0;
495
496
497 BT_DBG("sk %p", sk);
498
Changli Gao6503d962010-03-31 22:58:26 +0000499 if (alen < sizeof(struct sockaddr_sco) ||
500 addr->sa_family != AF_BLUETOOTH)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 return -EINVAL;
502
503 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
504 return -EBADFD;
505
506 if (sk->sk_type != SOCK_SEQPACKET)
507 return -EINVAL;
508
509 lock_sock(sk);
510
511 /* Set destination address and psm */
512 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
513
514 if ((err = sco_connect(sk)))
515 goto done;
516
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900517 err = bt_sock_wait_state(sk, BT_CONNECTED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 sock_sndtimeo(sk, flags & O_NONBLOCK));
519
520done:
521 release_sock(sk);
522 return err;
523}
524
525static int sco_sock_listen(struct socket *sock, int backlog)
526{
527 struct sock *sk = sock->sk;
528 int err = 0;
529
530 BT_DBG("sk %p backlog %d", sk, backlog);
531
532 lock_sock(sk);
533
534 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
535 err = -EBADFD;
536 goto done;
537 }
538
539 sk->sk_max_ack_backlog = backlog;
540 sk->sk_ack_backlog = 0;
541 sk->sk_state = BT_LISTEN;
542
543done:
544 release_sock(sk);
545 return err;
546}
547
548static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
549{
550 DECLARE_WAITQUEUE(wait, current);
551 struct sock *sk = sock->sk, *ch;
552 long timeo;
553 int err = 0;
554
555 lock_sock(sk);
556
557 if (sk->sk_state != BT_LISTEN) {
558 err = -EBADFD;
559 goto done;
560 }
561
562 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
563
564 BT_DBG("sk %p timeo %ld", sk, timeo);
565
566 /* Wait for an incoming connection. (wake-one). */
Eric Dumazetaa395142010-04-20 13:03:51 +0000567 add_wait_queue_exclusive(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 while (!(ch = bt_accept_dequeue(sk, newsock))) {
569 set_current_state(TASK_INTERRUPTIBLE);
570 if (!timeo) {
571 err = -EAGAIN;
572 break;
573 }
574
575 release_sock(sk);
576 timeo = schedule_timeout(timeo);
577 lock_sock(sk);
578
579 if (sk->sk_state != BT_LISTEN) {
580 err = -EBADFD;
581 break;
582 }
583
584 if (signal_pending(current)) {
585 err = sock_intr_errno(timeo);
586 break;
587 }
588 }
589 set_current_state(TASK_RUNNING);
Eric Dumazetaa395142010-04-20 13:03:51 +0000590 remove_wait_queue(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
592 if (err)
593 goto done;
594
595 newsock->state = SS_CONNECTED;
596
597 BT_DBG("new socket %p", ch);
598
599done:
600 release_sock(sk);
601 return err;
602}
603
604static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
605{
606 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
607 struct sock *sk = sock->sk;
608
609 BT_DBG("sock %p, sk %p", sock, sk);
610
611 addr->sa_family = AF_BLUETOOTH;
612 *len = sizeof(struct sockaddr_sco);
613
614 if (peer)
615 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
616 else
617 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
618
619 return 0;
620}
621
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900622static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 struct msghdr *msg, size_t len)
624{
625 struct sock *sk = sock->sk;
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300626 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
628 BT_DBG("sock %p, sk %p", sock, sk);
629
Benjamin LaHaisec1cbe4b2005-12-13 23:22:19 -0800630 err = sock_error(sk);
631 if (err)
632 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
634 if (msg->msg_flags & MSG_OOB)
635 return -EOPNOTSUPP;
636
637 lock_sock(sk);
638
639 if (sk->sk_state == BT_CONNECTED)
640 err = sco_send_frame(sk, msg, len);
641 else
642 err = -ENOTCONN;
643
644 release_sock(sk);
645 return err;
646}
647
David S. Millerb7058842009-09-30 16:12:20 -0700648static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649{
650 struct sock *sk = sock->sk;
651 int err = 0;
652
653 BT_DBG("sk %p", sk);
654
655 lock_sock(sk);
656
657 switch (optname) {
658 default:
659 err = -ENOPROTOOPT;
660 break;
661 }
662
663 release_sock(sk);
664 return err;
665}
666
Marcel Holtmannd58daf42009-01-15 21:52:14 +0100667static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668{
669 struct sock *sk = sock->sk;
670 struct sco_options opts;
671 struct sco_conninfo cinfo;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900672 int len, err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
674 BT_DBG("sk %p", sk);
675
676 if (get_user(len, optlen))
677 return -EFAULT;
678
679 lock_sock(sk);
680
681 switch (optname) {
682 case SCO_OPTIONS:
683 if (sk->sk_state != BT_CONNECTED) {
684 err = -ENOTCONN;
685 break;
686 }
687
688 opts.mtu = sco_pi(sk)->conn->mtu;
689
690 BT_DBG("mtu %d", opts.mtu);
691
692 len = min_t(unsigned int, len, sizeof(opts));
693 if (copy_to_user(optval, (char *)&opts, len))
694 err = -EFAULT;
695
696 break;
697
698 case SCO_CONNINFO:
699 if (sk->sk_state != BT_CONNECTED) {
700 err = -ENOTCONN;
701 break;
702 }
703
704 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
705 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
706
707 len = min_t(unsigned int, len, sizeof(cinfo));
708 if (copy_to_user(optval, (char *)&cinfo, len))
709 err = -EFAULT;
710
711 break;
712
713 default:
714 err = -ENOPROTOOPT;
715 break;
716 }
717
718 release_sock(sk);
719 return err;
720}
721
Marcel Holtmannd58daf42009-01-15 21:52:14 +0100722static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
723{
724 struct sock *sk = sock->sk;
725 int len, err = 0;
726
727 BT_DBG("sk %p", sk);
728
729 if (level == SOL_SCO)
730 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
731
732 if (get_user(len, optlen))
733 return -EFAULT;
734
735 lock_sock(sk);
736
737 switch (optname) {
738 default:
739 err = -ENOPROTOOPT;
740 break;
741 }
742
743 release_sock(sk);
744 return err;
745}
746
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200747static int sco_sock_shutdown(struct socket *sock, int how)
748{
749 struct sock *sk = sock->sk;
750 int err = 0;
751
752 BT_DBG("sock %p, sk %p", sock, sk);
753
754 if (!sk)
755 return 0;
756
757 lock_sock(sk);
758 if (!sk->sk_shutdown) {
759 sk->sk_shutdown = SHUTDOWN_MASK;
760 sco_sock_clear_timer(sk);
761 __sco_sock_close(sk);
762
763 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
764 err = bt_sock_wait_state(sk, BT_CLOSED,
765 sk->sk_lingertime);
766 }
767 release_sock(sk);
768 return err;
769}
770
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771static int sco_sock_release(struct socket *sock)
772{
773 struct sock *sk = sock->sk;
774 int err = 0;
775
776 BT_DBG("sock %p, sk %p", sock, sk);
777
778 if (!sk)
779 return 0;
780
781 sco_sock_close(sk);
782
783 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
784 lock_sock(sk);
785 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
786 release_sock(sk);
787 }
788
789 sock_orphan(sk);
790 sco_sock_kill(sk);
791 return err;
792}
793
794static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
795{
796 BT_DBG("conn %p", conn);
797
798 sco_pi(sk)->conn = conn;
799 conn->sk = sk;
800
801 if (parent)
802 bt_accept_enqueue(parent, sk);
803}
804
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900805/* Delete channel.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 * Must be called on the locked socket. */
807static void sco_chan_del(struct sock *sk, int err)
808{
809 struct sco_conn *conn;
810
811 conn = sco_pi(sk)->conn;
812
813 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
814
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900815 if (conn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 sco_conn_lock(conn);
817 conn->sk = NULL;
818 sco_pi(sk)->conn = NULL;
819 sco_conn_unlock(conn);
820 hci_conn_put(conn->hcon);
821 }
822
823 sk->sk_state = BT_CLOSED;
824 sk->sk_err = err;
825 sk->sk_state_change(sk);
826
827 sock_set_flag(sk, SOCK_ZAPPED);
828}
829
830static void sco_conn_ready(struct sco_conn *conn)
831{
832 struct sock *parent, *sk;
833
834 BT_DBG("conn %p", conn);
835
836 sco_conn_lock(conn);
837
838 if ((sk = conn->sk)) {
839 sco_sock_clear_timer(sk);
840 bh_lock_sock(sk);
841 sk->sk_state = BT_CONNECTED;
842 sk->sk_state_change(sk);
843 bh_unlock_sock(sk);
844 } else {
845 parent = sco_get_sock_listen(conn->src);
846 if (!parent)
847 goto done;
848
849 bh_lock_sock(parent);
850
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300851 sk = sco_sock_alloc(sock_net(parent), NULL,
852 BTPROTO_SCO, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 if (!sk) {
854 bh_unlock_sock(parent);
855 goto done;
856 }
857
858 sco_sock_init(sk, parent);
859
860 bacpy(&bt_sk(sk)->src, conn->src);
861 bacpy(&bt_sk(sk)->dst, conn->dst);
862
863 hci_conn_hold(conn->hcon);
864 __sco_chan_add(conn, sk, parent);
865
866 sk->sk_state = BT_CONNECTED;
867
868 /* Wake up parent */
869 parent->sk_data_ready(parent, 1);
870
871 bh_unlock_sock(parent);
872 }
873
874done:
875 sco_conn_unlock(conn);
876}
877
878/* ----- SCO interface with lower layer (HCI) ----- */
879static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
880{
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +0100881 register struct sock *sk;
882 struct hlist_node *node;
883 int lm = 0;
884
885 if (type != SCO_LINK && type != ESCO_LINK)
886 return 0;
887
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
889
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +0100890 /* Find listening sockets */
891 read_lock(&sco_sk_list.lock);
892 sk_for_each(sk, node, &sco_sk_list.head) {
893 if (sk->sk_state != BT_LISTEN)
894 continue;
895
896 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
897 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
898 lm |= HCI_LM_ACCEPT;
899 break;
900 }
901 }
902 read_unlock(&sco_sk_list.lock);
903
904 return lm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905}
906
907static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
908{
909 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
910
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200911 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 return 0;
913
914 if (!status) {
915 struct sco_conn *conn;
916
917 conn = sco_conn_add(hcon, status);
918 if (conn)
919 sco_conn_ready(conn);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900920 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 sco_conn_del(hcon, bt_err(status));
922
923 return 0;
924}
925
Marcel Holtmann2950f212009-02-12 14:02:50 +0100926static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927{
928 BT_DBG("hcon %p reason %d", hcon, reason);
929
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200930 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 return 0;
932
933 sco_conn_del(hcon, bt_err(reason));
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200934
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 return 0;
936}
937
938static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
939{
940 struct sco_conn *conn = hcon->sco_data;
941
942 if (!conn)
943 goto drop;
944
945 BT_DBG("conn %p len %d", conn, skb->len);
946
947 if (skb->len) {
948 sco_recv_frame(conn, skb);
949 return 0;
950 }
951
952drop:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900953 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 return 0;
955}
956
Marcel Holtmannaef7d972010-03-21 05:27:45 +0100957static int sco_debugfs_show(struct seq_file *f, void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958{
959 struct sock *sk;
960 struct hlist_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
962 read_lock_bh(&sco_sk_list.lock);
963
Marcel Holtmannbe9d1222005-11-08 09:57:38 -0800964 sk_for_each(sk, node, &sco_sk_list.head) {
Marcel Holtmannaef7d972010-03-21 05:27:45 +0100965 seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
966 batostr(&bt_sk(sk)->dst), sk->sk_state);
Marcel Holtmannbe9d1222005-11-08 09:57:38 -0800967 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 read_unlock_bh(&sco_sk_list.lock);
Marcel Holtmannbe9d1222005-11-08 09:57:38 -0800970
Marcel Holtmannaef7d972010-03-21 05:27:45 +0100971 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972}
973
Marcel Holtmannaef7d972010-03-21 05:27:45 +0100974static int sco_debugfs_open(struct inode *inode, struct file *file)
975{
976 return single_open(file, sco_debugfs_show, inode->i_private);
977}
978
979static const struct file_operations sco_debugfs_fops = {
980 .open = sco_debugfs_open,
981 .read = seq_read,
982 .llseek = seq_lseek,
983 .release = single_release,
984};
985
986static struct dentry *sco_debugfs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987
Eric Dumazet90ddc4f2005-12-22 12:49:22 -0800988static const struct proto_ops sco_sock_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 .family = PF_BLUETOOTH,
990 .owner = THIS_MODULE,
991 .release = sco_sock_release,
992 .bind = sco_sock_bind,
993 .connect = sco_sock_connect,
994 .listen = sco_sock_listen,
995 .accept = sco_sock_accept,
996 .getname = sco_sock_getname,
997 .sendmsg = sco_sock_sendmsg,
998 .recvmsg = bt_sock_recvmsg,
999 .poll = bt_sock_poll,
Marcel Holtmann3241ad82008-07-14 20:13:50 +02001000 .ioctl = bt_sock_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 .mmap = sock_no_mmap,
1002 .socketpair = sock_no_socketpair,
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +02001003 .shutdown = sco_sock_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 .setsockopt = sco_sock_setsockopt,
1005 .getsockopt = sco_sock_getsockopt
1006};
1007
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +00001008static const struct net_proto_family sco_sock_family_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 .family = PF_BLUETOOTH,
1010 .owner = THIS_MODULE,
1011 .create = sco_sock_create,
1012};
1013
1014static struct hci_proto sco_hci_proto = {
1015 .name = "SCO",
1016 .id = HCI_PROTO_SCO,
1017 .connect_ind = sco_connect_ind,
1018 .connect_cfm = sco_connect_cfm,
Marcel Holtmann2950f212009-02-12 14:02:50 +01001019 .disconn_cfm = sco_disconn_cfm,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 .recv_scodata = sco_recv_scodata
1021};
1022
1023static int __init sco_init(void)
1024{
1025 int err;
1026
1027 err = proto_register(&sco_proto, 0);
1028 if (err < 0)
1029 return err;
1030
1031 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1032 if (err < 0) {
1033 BT_ERR("SCO socket registration failed");
1034 goto error;
1035 }
1036
1037 err = hci_register_proto(&sco_hci_proto);
1038 if (err < 0) {
1039 BT_ERR("SCO protocol registration failed");
1040 bt_sock_unregister(BTPROTO_SCO);
1041 goto error;
1042 }
1043
Marcel Holtmannaef7d972010-03-21 05:27:45 +01001044 if (bt_debugfs) {
1045 sco_debugfs = debugfs_create_file("sco", 0444,
1046 bt_debugfs, NULL, &sco_debugfs_fops);
1047 if (!sco_debugfs)
1048 BT_ERR("Failed to create SCO debug file");
1049 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
1051 BT_INFO("SCO (Voice Link) ver %s", VERSION);
1052 BT_INFO("SCO socket layer initialized");
1053
1054 return 0;
1055
1056error:
1057 proto_unregister(&sco_proto);
1058 return err;
1059}
1060
1061static void __exit sco_exit(void)
1062{
Marcel Holtmannaef7d972010-03-21 05:27:45 +01001063 debugfs_remove(sco_debugfs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
1065 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1066 BT_ERR("SCO socket unregistration failed");
1067
1068 if (hci_unregister_proto(&sco_hci_proto) < 0)
1069 BT_ERR("SCO protocol unregistration failed");
1070
1071 proto_unregister(&sco_proto);
1072}
1073
1074module_init(sco_init);
1075module_exit(sco_exit);
1076
Marcel Holtmann7cb127d2008-07-14 20:13:53 +02001077module_param(disable_esco, bool, 0644);
1078MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1079
Marcel Holtmann63fbd242008-08-18 13:23:53 +02001080MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1082MODULE_VERSION(VERSION);
1083MODULE_LICENSE("GPL");
1084MODULE_ALIAS("bt-proto-2");