blob: 725e10d487f2fc7e767d0f024e365265b0869afd [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>
Paul Moore6230c9b2011-10-07 09:40:59 +000044#include <linux/security.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <net/sock.h>
46
47#include <asm/system.h>
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +020048#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50#include <net/bluetooth/bluetooth.h>
51#include <net/bluetooth/hci_core.h>
52#include <net/bluetooth/sco.h>
53
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +020054static int disable_esco;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Eric Dumazet90ddc4f2005-12-22 12:49:22 -080056static const struct proto_ops sco_sock_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
58static struct bt_sock_list sco_sk_list = {
Robert P. J. Dayd5fb2962008-03-28 16:17:38 -070059 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060};
61
62static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
63static void sco_chan_del(struct sock *sk, int err);
64
65static int sco_conn_del(struct hci_conn *conn, int err);
66
67static void sco_sock_close(struct sock *sk);
68static void sco_sock_kill(struct sock *sk);
69
70/* ---- SCO timers ---- */
71static void sco_sock_timeout(unsigned long arg)
72{
73 struct sock *sk = (struct sock *) arg;
74
75 BT_DBG("sock %p state %d", sk, sk->sk_state);
76
77 bh_lock_sock(sk);
78 sk->sk_err = ETIMEDOUT;
79 sk->sk_state_change(sk);
80 bh_unlock_sock(sk);
81
82 sco_sock_kill(sk);
83 sock_put(sk);
84}
85
86static void sco_sock_set_timer(struct sock *sk, long timeout)
87{
88 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
89 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
90}
91
92static void sco_sock_clear_timer(struct sock *sk)
93{
94 BT_DBG("sock %p state %d", sk, sk->sk_state);
95 sk_stop_timer(sk, &sk->sk_timer);
96}
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098/* ---- SCO connections ---- */
99static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
100{
101 struct hci_dev *hdev = hcon->hdev;
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200102 struct sco_conn *conn = hcon->sco_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200104 if (conn || status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 return conn;
106
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200107 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
108 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111 spin_lock_init(&conn->lock);
112
113 hcon->sco_data = conn;
114 conn->hcon = hcon;
115
116 conn->src = &hdev->bdaddr;
117 conn->dst = &hcon->dst;
118
119 if (hdev->sco_mtu > 0)
120 conn->mtu = hdev->sco_mtu;
121 else
122 conn->mtu = 60;
123
124 BT_DBG("hcon %p conn %p", hcon, conn);
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 return conn;
127}
128
129static inline struct sock *sco_chan_get(struct sco_conn *conn)
130{
131 struct sock *sk = NULL;
132 sco_conn_lock(conn);
133 sk = conn->sk;
134 sco_conn_unlock(conn);
135 return sk;
136}
137
138static int sco_conn_del(struct hci_conn *hcon, int err)
139{
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200140 struct sco_conn *conn = hcon->sco_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 struct sock *sk;
142
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200143 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 return 0;
145
146 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
147
148 /* Kill socket */
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200149 sk = sco_chan_get(conn);
150 if (sk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 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
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200188 hdev = hci_get_route(dst, src);
189 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 return -EHOSTUNREACH;
191
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300192 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Marcel Holtmann7cb127d2008-07-14 20:13:53 +0200194 if (lmp_esco_capable(hdev) && !disable_esco)
195 type = ESCO_LINK;
196 else
197 type = SCO_LINK;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200198
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100199 hcon = hci_connect(hdev, type, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
Ville Tervo30e76272011-02-22 16:10:53 -0300200 if (IS_ERR(hcon)) {
201 err = PTR_ERR(hcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 goto done;
Ville Tervo30e76272011-02-22 16:10:53 -0300203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
205 conn = sco_conn_add(hcon, 0);
206 if (!conn) {
207 hci_conn_put(hcon);
Ville Tervo30e76272011-02-22 16:10:53 -0300208 err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 goto done;
210 }
211
212 /* Update source addr of the socket */
213 bacpy(src, conn->src);
214
215 err = sco_chan_add(conn, sk, NULL);
216 if (err)
217 goto done;
218
219 if (hcon->state == BT_CONNECTED) {
220 sco_sock_clear_timer(sk);
221 sk->sk_state = BT_CONNECTED;
222 } else {
223 sk->sk_state = BT_CONNECT;
224 sco_sock_set_timer(sk, sk->sk_sndtimeo);
225 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227done:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300228 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 hci_dev_put(hdev);
230 return err;
231}
232
233static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
234{
235 struct sco_conn *conn = sco_pi(sk)->conn;
236 struct sk_buff *skb;
237 int err, count;
238
239 /* Check outgoing MTU */
240 if (len > conn->mtu)
241 return -EINVAL;
242
243 BT_DBG("sk %p len %d", sk, len);
244
245 count = min_t(unsigned int, conn->mtu, len);
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300246 skb = bt_skb_send_alloc(sk, count,
247 msg->msg_flags & MSG_DONTWAIT, &err);
248 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 return err;
250
251 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300252 kfree_skb(skb);
253 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 }
255
Gustavo F. Padovan0d861d82010-05-01 16:15:35 -0300256 hci_send_sco(conn->hcon, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
258 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259}
260
261static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
262{
263 struct sock *sk = sco_chan_get(conn);
264
265 if (!sk)
266 goto drop;
267
268 BT_DBG("sk %p len %d", sk, skb->len);
269
270 if (sk->sk_state != BT_CONNECTED)
271 goto drop;
272
273 if (!sock_queue_rcv_skb(sk, skb))
274 return;
275
276drop:
277 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278}
279
280/* -------- Socket interface ---------- */
281static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
282{
283 struct sock *sk;
284 struct hlist_node *node;
285
286 sk_for_each(sk, node, &sco_sk_list.head)
287 if (!bacmp(&bt_sk(sk)->src, ba))
288 goto found;
289 sk = NULL;
290found:
291 return sk;
292}
293
294/* Find socket listening on source bdaddr.
295 * Returns closest match.
296 */
297static struct sock *sco_get_sock_listen(bdaddr_t *src)
298{
299 struct sock *sk = NULL, *sk1 = NULL;
300 struct hlist_node *node;
301
302 read_lock(&sco_sk_list.lock);
303
304 sk_for_each(sk, node, &sco_sk_list.head) {
305 if (sk->sk_state != BT_LISTEN)
306 continue;
307
308 /* Exact match. */
309 if (!bacmp(&bt_sk(sk)->src, src))
310 break;
311
312 /* Closest match */
313 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
314 sk1 = sk;
315 }
316
317 read_unlock(&sco_sk_list.lock);
318
319 return node ? sk : sk1;
320}
321
322static void sco_sock_destruct(struct sock *sk)
323{
324 BT_DBG("sk %p", sk);
325
326 skb_queue_purge(&sk->sk_receive_queue);
327 skb_queue_purge(&sk->sk_write_queue);
328}
329
330static void sco_sock_cleanup_listen(struct sock *parent)
331{
332 struct sock *sk;
333
334 BT_DBG("parent %p", parent);
335
336 /* Close not yet accepted channels */
337 while ((sk = bt_accept_dequeue(parent, NULL))) {
338 sco_sock_close(sk);
339 sco_sock_kill(sk);
340 }
341
342 parent->sk_state = BT_CLOSED;
343 sock_set_flag(parent, SOCK_ZAPPED);
344}
345
346/* Kill socket (only if zapped and orphan)
347 * Must be called on unlocked socket.
348 */
349static void sco_sock_kill(struct sock *sk)
350{
351 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
352 return;
353
354 BT_DBG("sk %p state %d", sk, sk->sk_state);
355
356 /* Kill poor orphan */
357 bt_sock_unlink(&sco_sk_list, sk);
358 sock_set_flag(sk, SOCK_DEAD);
359 sock_put(sk);
360}
361
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200362static void __sco_sock_close(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363{
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200364 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
366 switch (sk->sk_state) {
367 case BT_LISTEN:
368 sco_sock_cleanup_listen(sk);
369 break;
370
371 case BT_CONNECTED:
372 case BT_CONFIG:
Luiz Augusto von Dentz4a777082011-05-12 11:13:15 +0300373 if (sco_pi(sk)->conn) {
374 sk->sk_state = BT_DISCONN;
375 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
376 hci_conn_put(sco_pi(sk)->conn->hcon);
377 sco_pi(sk)->conn->hcon = NULL;
378 } else
379 sco_chan_del(sk, ECONNRESET);
380 break;
381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 case BT_CONNECT:
383 case BT_DISCONN:
384 sco_chan_del(sk, ECONNRESET);
385 break;
386
387 default:
388 sock_set_flag(sk, SOCK_ZAPPED);
389 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700390 }
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200391}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200393/* Must be called on unlocked socket. */
394static void sco_sock_close(struct sock *sk)
395{
396 sco_sock_clear_timer(sk);
397 lock_sock(sk);
398 __sco_sock_close(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 sco_sock_kill(sk);
401}
402
403static void sco_sock_init(struct sock *sk, struct sock *parent)
404{
405 BT_DBG("sk %p", sk);
406
Paul Moore6230c9b2011-10-07 09:40:59 +0000407 if (parent) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 sk->sk_type = parent->sk_type;
Paul Moore6230c9b2011-10-07 09:40:59 +0000409 security_sk_clone(parent, sk);
410 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411}
412
413static struct proto sco_proto = {
414 .name = "SCO",
415 .owner = THIS_MODULE,
416 .obj_size = sizeof(struct sco_pinfo)
417};
418
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700419static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420{
421 struct sock *sk;
422
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700423 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 if (!sk)
425 return NULL;
426
427 sock_init_data(sock, sk);
428 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
429
430 sk->sk_destruct = sco_sock_destruct;
431 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
432
433 sock_reset_flag(sk, SOCK_ZAPPED);
434
435 sk->sk_protocol = proto;
436 sk->sk_state = BT_OPEN;
437
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800438 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
440 bt_sock_link(&sco_sk_list, sk);
441 return sk;
442}
443
Eric Paris3f378b62009-11-05 22:18:14 -0800444static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
445 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
447 struct sock *sk;
448
449 BT_DBG("sock %p", sock);
450
451 sock->state = SS_UNCONNECTED;
452
453 if (sock->type != SOCK_SEQPACKET)
454 return -ESOCKTNOSUPPORT;
455
456 sock->ops = &sco_sock_ops;
457
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700458 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
Marcel Holtmann74da6262006-10-15 17:31:14 +0200459 if (!sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 return -ENOMEM;
461
462 sco_sock_init(sk, NULL);
463 return 0;
464}
465
466static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
467{
468 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
469 struct sock *sk = sock->sk;
470 bdaddr_t *src = &sa->sco_bdaddr;
471 int err = 0;
472
473 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
474
475 if (!addr || addr->sa_family != AF_BLUETOOTH)
476 return -EINVAL;
477
478 lock_sock(sk);
479
480 if (sk->sk_state != BT_OPEN) {
481 err = -EBADFD;
482 goto done;
483 }
484
485 write_lock_bh(&sco_sk_list.lock);
486
487 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
488 err = -EADDRINUSE;
489 } else {
490 /* Save source address */
491 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
492 sk->sk_state = BT_BOUND;
493 }
494
495 write_unlock_bh(&sco_sk_list.lock);
496
497done:
498 release_sock(sk);
499 return err;
500}
501
502static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
503{
504 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
505 struct sock *sk = sock->sk;
506 int err = 0;
507
508
509 BT_DBG("sk %p", sk);
510
Changli Gao6503d962010-03-31 22:58:26 +0000511 if (alen < sizeof(struct sockaddr_sco) ||
512 addr->sa_family != AF_BLUETOOTH)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 return -EINVAL;
514
515 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
516 return -EBADFD;
517
518 if (sk->sk_type != SOCK_SEQPACKET)
519 return -EINVAL;
520
521 lock_sock(sk);
522
523 /* Set destination address and psm */
524 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
525
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200526 err = sco_connect(sk);
527 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 goto done;
529
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900530 err = bt_sock_wait_state(sk, BT_CONNECTED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 sock_sndtimeo(sk, flags & O_NONBLOCK));
532
533done:
534 release_sock(sk);
535 return err;
536}
537
538static int sco_sock_listen(struct socket *sock, int backlog)
539{
540 struct sock *sk = sock->sk;
541 int err = 0;
542
543 BT_DBG("sk %p backlog %d", sk, backlog);
544
545 lock_sock(sk);
546
547 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
548 err = -EBADFD;
549 goto done;
550 }
551
552 sk->sk_max_ack_backlog = backlog;
553 sk->sk_ack_backlog = 0;
554 sk->sk_state = BT_LISTEN;
555
556done:
557 release_sock(sk);
558 return err;
559}
560
561static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
562{
563 DECLARE_WAITQUEUE(wait, current);
564 struct sock *sk = sock->sk, *ch;
565 long timeo;
566 int err = 0;
567
568 lock_sock(sk);
569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
571
572 BT_DBG("sk %p timeo %ld", sk, timeo);
573
574 /* Wait for an incoming connection. (wake-one). */
Eric Dumazetaa395142010-04-20 13:03:51 +0000575 add_wait_queue_exclusive(sk_sleep(sk), &wait);
Peter Hurley552b0d32011-07-24 00:11:01 -0400576 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
579 if (sk->sk_state != BT_LISTEN) {
580 err = -EBADFD;
581 break;
582 }
583
Peter Hurley552b0d32011-07-24 00:11:01 -0400584 ch = bt_accept_dequeue(sk, newsock);
585 if (ch)
586 break;
587
588 if (!timeo) {
589 err = -EAGAIN;
590 break;
591 }
592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 if (signal_pending(current)) {
594 err = sock_intr_errno(timeo);
595 break;
596 }
Peter Hurley552b0d32011-07-24 00:11:01 -0400597
598 release_sock(sk);
599 timeo = schedule_timeout(timeo);
600 lock_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 }
Peter Hurley552b0d32011-07-24 00:11:01 -0400602 __set_current_state(TASK_RUNNING);
Eric Dumazetaa395142010-04-20 13:03:51 +0000603 remove_wait_queue(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
605 if (err)
606 goto done;
607
608 newsock->state = SS_CONNECTED;
609
610 BT_DBG("new socket %p", ch);
611
612done:
613 release_sock(sk);
614 return err;
615}
616
617static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
618{
619 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
620 struct sock *sk = sock->sk;
621
622 BT_DBG("sock %p, sk %p", sock, sk);
623
624 addr->sa_family = AF_BLUETOOTH;
625 *len = sizeof(struct sockaddr_sco);
626
627 if (peer)
628 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
629 else
630 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
631
632 return 0;
633}
634
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900635static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 struct msghdr *msg, size_t len)
637{
638 struct sock *sk = sock->sk;
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300639 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
641 BT_DBG("sock %p, sk %p", sock, sk);
642
Benjamin LaHaisec1cbe4b2005-12-13 23:22:19 -0800643 err = sock_error(sk);
644 if (err)
645 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647 if (msg->msg_flags & MSG_OOB)
648 return -EOPNOTSUPP;
649
650 lock_sock(sk);
651
652 if (sk->sk_state == BT_CONNECTED)
653 err = sco_send_frame(sk, msg, len);
654 else
655 err = -ENOTCONN;
656
657 release_sock(sk);
658 return err;
659}
660
David S. Millerb7058842009-09-30 16:12:20 -0700661static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662{
663 struct sock *sk = sock->sk;
664 int err = 0;
665
666 BT_DBG("sk %p", sk);
667
668 lock_sock(sk);
669
670 switch (optname) {
671 default:
672 err = -ENOPROTOOPT;
673 break;
674 }
675
676 release_sock(sk);
677 return err;
678}
679
Marcel Holtmannd58daf42009-01-15 21:52:14 +0100680static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681{
682 struct sock *sk = sock->sk;
683 struct sco_options opts;
684 struct sco_conninfo cinfo;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900685 int len, err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
687 BT_DBG("sk %p", sk);
688
689 if (get_user(len, optlen))
690 return -EFAULT;
691
692 lock_sock(sk);
693
694 switch (optname) {
695 case SCO_OPTIONS:
696 if (sk->sk_state != BT_CONNECTED) {
697 err = -ENOTCONN;
698 break;
699 }
700
701 opts.mtu = sco_pi(sk)->conn->mtu;
702
703 BT_DBG("mtu %d", opts.mtu);
704
705 len = min_t(unsigned int, len, sizeof(opts));
706 if (copy_to_user(optval, (char *)&opts, len))
707 err = -EFAULT;
708
709 break;
710
711 case SCO_CONNINFO:
712 if (sk->sk_state != BT_CONNECTED) {
713 err = -ENOTCONN;
714 break;
715 }
716
Vasiliy Kulikovc4c896e2011-02-14 13:54:26 +0300717 memset(&cinfo, 0, sizeof(cinfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
719 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
720
721 len = min_t(unsigned int, len, sizeof(cinfo));
722 if (copy_to_user(optval, (char *)&cinfo, len))
723 err = -EFAULT;
724
725 break;
726
727 default:
728 err = -ENOPROTOOPT;
729 break;
730 }
731
732 release_sock(sk);
733 return err;
734}
735
Marcel Holtmannd58daf42009-01-15 21:52:14 +0100736static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
737{
738 struct sock *sk = sock->sk;
739 int len, err = 0;
740
741 BT_DBG("sk %p", sk);
742
743 if (level == SOL_SCO)
744 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
745
746 if (get_user(len, optlen))
747 return -EFAULT;
748
749 lock_sock(sk);
750
751 switch (optname) {
752 default:
753 err = -ENOPROTOOPT;
754 break;
755 }
756
757 release_sock(sk);
758 return err;
759}
760
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200761static int sco_sock_shutdown(struct socket *sock, int how)
762{
763 struct sock *sk = sock->sk;
764 int err = 0;
765
766 BT_DBG("sock %p, sk %p", sock, sk);
767
768 if (!sk)
769 return 0;
770
771 lock_sock(sk);
772 if (!sk->sk_shutdown) {
773 sk->sk_shutdown = SHUTDOWN_MASK;
774 sco_sock_clear_timer(sk);
775 __sco_sock_close(sk);
776
777 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
778 err = bt_sock_wait_state(sk, BT_CLOSED,
779 sk->sk_lingertime);
780 }
781 release_sock(sk);
782 return err;
783}
784
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785static int sco_sock_release(struct socket *sock)
786{
787 struct sock *sk = sock->sk;
788 int err = 0;
789
790 BT_DBG("sock %p, sk %p", sock, sk);
791
792 if (!sk)
793 return 0;
794
795 sco_sock_close(sk);
796
797 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
798 lock_sock(sk);
799 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
800 release_sock(sk);
801 }
802
803 sock_orphan(sk);
804 sco_sock_kill(sk);
805 return err;
806}
807
808static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
809{
810 BT_DBG("conn %p", conn);
811
812 sco_pi(sk)->conn = conn;
813 conn->sk = sk;
814
815 if (parent)
816 bt_accept_enqueue(parent, sk);
817}
818
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900819/* Delete channel.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 * Must be called on the locked socket. */
821static void sco_chan_del(struct sock *sk, int err)
822{
823 struct sco_conn *conn;
824
825 conn = sco_pi(sk)->conn;
826
827 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
828
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900829 if (conn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 sco_conn_lock(conn);
831 conn->sk = NULL;
832 sco_pi(sk)->conn = NULL;
833 sco_conn_unlock(conn);
Luiz Augusto von Dentz4a777082011-05-12 11:13:15 +0300834
835 if (conn->hcon)
836 hci_conn_put(conn->hcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 }
838
839 sk->sk_state = BT_CLOSED;
840 sk->sk_err = err;
841 sk->sk_state_change(sk);
842
843 sock_set_flag(sk, SOCK_ZAPPED);
844}
845
846static void sco_conn_ready(struct sco_conn *conn)
847{
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200848 struct sock *parent;
849 struct sock *sk = conn->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
851 BT_DBG("conn %p", conn);
852
853 sco_conn_lock(conn);
854
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200855 if (sk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 sco_sock_clear_timer(sk);
857 bh_lock_sock(sk);
858 sk->sk_state = BT_CONNECTED;
859 sk->sk_state_change(sk);
860 bh_unlock_sock(sk);
861 } else {
862 parent = sco_get_sock_listen(conn->src);
863 if (!parent)
864 goto done;
865
866 bh_lock_sock(parent);
867
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300868 sk = sco_sock_alloc(sock_net(parent), NULL,
869 BTPROTO_SCO, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 if (!sk) {
871 bh_unlock_sock(parent);
872 goto done;
873 }
874
875 sco_sock_init(sk, parent);
876
877 bacpy(&bt_sk(sk)->src, conn->src);
878 bacpy(&bt_sk(sk)->dst, conn->dst);
879
880 hci_conn_hold(conn->hcon);
881 __sco_chan_add(conn, sk, parent);
882
883 sk->sk_state = BT_CONNECTED;
884
885 /* Wake up parent */
886 parent->sk_data_ready(parent, 1);
887
888 bh_unlock_sock(parent);
889 }
890
891done:
892 sco_conn_unlock(conn);
893}
894
895/* ----- SCO interface with lower layer (HCI) ----- */
896static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
897{
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +0100898 register struct sock *sk;
899 struct hlist_node *node;
900 int lm = 0;
901
902 if (type != SCO_LINK && type != ESCO_LINK)
Gustavo F. Padovanc89ad732010-11-01 19:08:50 +0000903 return -EINVAL;
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +0100904
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
906
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +0100907 /* Find listening sockets */
908 read_lock(&sco_sk_list.lock);
909 sk_for_each(sk, node, &sco_sk_list.head) {
910 if (sk->sk_state != BT_LISTEN)
911 continue;
912
913 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
914 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
915 lm |= HCI_LM_ACCEPT;
916 break;
917 }
918 }
919 read_unlock(&sco_sk_list.lock);
920
921 return lm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922}
923
924static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
925{
926 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
927
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200928 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
Gustavo F. Padovanc89ad732010-11-01 19:08:50 +0000929 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930
931 if (!status) {
932 struct sco_conn *conn;
933
934 conn = sco_conn_add(hcon, status);
935 if (conn)
936 sco_conn_ready(conn);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900937 } else
Joe Perchese1750722011-06-29 18:18:29 -0700938 sco_conn_del(hcon, bt_to_errno(status));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
940 return 0;
941}
942
Marcel Holtmann2950f212009-02-12 14:02:50 +0100943static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944{
945 BT_DBG("hcon %p reason %d", hcon, reason);
946
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200947 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
Gustavo F. Padovanc89ad732010-11-01 19:08:50 +0000948 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
Joe Perchese1750722011-06-29 18:18:29 -0700950 sco_conn_del(hcon, bt_to_errno(reason));
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200951
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 return 0;
953}
954
955static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
956{
957 struct sco_conn *conn = hcon->sco_data;
958
959 if (!conn)
960 goto drop;
961
962 BT_DBG("conn %p len %d", conn, skb->len);
963
964 if (skb->len) {
965 sco_recv_frame(conn, skb);
966 return 0;
967 }
968
969drop:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900970 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 return 0;
972}
973
Marcel Holtmannaef7d972010-03-21 05:27:45 +0100974static int sco_debugfs_show(struct seq_file *f, void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975{
976 struct sock *sk;
977 struct hlist_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
979 read_lock_bh(&sco_sk_list.lock);
980
Marcel Holtmannbe9d1222005-11-08 09:57:38 -0800981 sk_for_each(sk, node, &sco_sk_list.head) {
Marcel Holtmannaef7d972010-03-21 05:27:45 +0100982 seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
983 batostr(&bt_sk(sk)->dst), sk->sk_state);
Marcel Holtmannbe9d1222005-11-08 09:57:38 -0800984 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 read_unlock_bh(&sco_sk_list.lock);
Marcel Holtmannbe9d1222005-11-08 09:57:38 -0800987
Marcel Holtmannaef7d972010-03-21 05:27:45 +0100988 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989}
990
Marcel Holtmannaef7d972010-03-21 05:27:45 +0100991static int sco_debugfs_open(struct inode *inode, struct file *file)
992{
993 return single_open(file, sco_debugfs_show, inode->i_private);
994}
995
996static const struct file_operations sco_debugfs_fops = {
997 .open = sco_debugfs_open,
998 .read = seq_read,
999 .llseek = seq_lseek,
1000 .release = single_release,
1001};
1002
1003static struct dentry *sco_debugfs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08001005static const struct proto_ops sco_sock_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 .family = PF_BLUETOOTH,
1007 .owner = THIS_MODULE,
1008 .release = sco_sock_release,
1009 .bind = sco_sock_bind,
1010 .connect = sco_sock_connect,
1011 .listen = sco_sock_listen,
1012 .accept = sco_sock_accept,
1013 .getname = sco_sock_getname,
1014 .sendmsg = sco_sock_sendmsg,
1015 .recvmsg = bt_sock_recvmsg,
1016 .poll = bt_sock_poll,
Marcel Holtmann3241ad82008-07-14 20:13:50 +02001017 .ioctl = bt_sock_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 .mmap = sock_no_mmap,
1019 .socketpair = sock_no_socketpair,
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +02001020 .shutdown = sco_sock_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 .setsockopt = sco_sock_setsockopt,
1022 .getsockopt = sco_sock_getsockopt
1023};
1024
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +00001025static const struct net_proto_family sco_sock_family_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 .family = PF_BLUETOOTH,
1027 .owner = THIS_MODULE,
1028 .create = sco_sock_create,
1029};
1030
1031static struct hci_proto sco_hci_proto = {
1032 .name = "SCO",
1033 .id = HCI_PROTO_SCO,
1034 .connect_ind = sco_connect_ind,
1035 .connect_cfm = sco_connect_cfm,
Marcel Holtmann2950f212009-02-12 14:02:50 +01001036 .disconn_cfm = sco_disconn_cfm,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 .recv_scodata = sco_recv_scodata
1038};
1039
Gustavo F. Padovan64274512011-02-07 20:08:52 -02001040int __init sco_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041{
1042 int err;
1043
1044 err = proto_register(&sco_proto, 0);
1045 if (err < 0)
1046 return err;
1047
1048 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1049 if (err < 0) {
1050 BT_ERR("SCO socket registration failed");
1051 goto error;
1052 }
1053
1054 err = hci_register_proto(&sco_hci_proto);
1055 if (err < 0) {
1056 BT_ERR("SCO protocol registration failed");
1057 bt_sock_unregister(BTPROTO_SCO);
1058 goto error;
1059 }
1060
Marcel Holtmannaef7d972010-03-21 05:27:45 +01001061 if (bt_debugfs) {
1062 sco_debugfs = debugfs_create_file("sco", 0444,
1063 bt_debugfs, NULL, &sco_debugfs_fops);
1064 if (!sco_debugfs)
1065 BT_ERR("Failed to create SCO debug file");
1066 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 BT_INFO("SCO socket layer initialized");
1069
1070 return 0;
1071
1072error:
1073 proto_unregister(&sco_proto);
1074 return err;
1075}
1076
Gustavo F. Padovan64274512011-02-07 20:08:52 -02001077void __exit sco_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078{
Marcel Holtmannaef7d972010-03-21 05:27:45 +01001079 debugfs_remove(sco_debugfs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
1081 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1082 BT_ERR("SCO socket unregistration failed");
1083
1084 if (hci_unregister_proto(&sco_hci_proto) < 0)
1085 BT_ERR("SCO protocol unregistration failed");
1086
1087 proto_unregister(&sco_proto);
1088}
1089
Marcel Holtmann7cb127d2008-07-14 20:13:53 +02001090module_param(disable_esco, bool, 0644);
1091MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");