2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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;
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.
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.
25 /* Bluetooth SCO sockets. */
27 #include <linux/module.h>
28 #include <linux/debugfs.h>
29 #include <linux/seq_file.h>
31 #include <net/bluetooth/bluetooth.h>
32 #include <net/bluetooth/hci_core.h>
33 #include <net/bluetooth/sco.h>
35 static bool disable_esco;
37 static const struct proto_ops sco_sock_ops;
39 static struct bt_sock_list sco_sk_list = {
40 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
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);
46 static void sco_sock_close(struct sock *sk);
47 static void sco_sock_kill(struct sock *sk);
49 /* ---- SCO timers ---- */
50 static void sco_sock_timeout(unsigned long arg)
52 struct sock *sk = (struct sock *) arg;
54 BT_DBG("sock %p state %d", sk, sk->sk_state);
57 sk->sk_err = ETIMEDOUT;
58 sk->sk_state_change(sk);
65 static void sco_sock_set_timer(struct sock *sk, long timeout)
67 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
68 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
71 static void sco_sock_clear_timer(struct sock *sk)
73 BT_DBG("sock %p state %d", sk, sk->sk_state);
74 sk_stop_timer(sk, &sk->sk_timer);
77 /* ---- SCO connections ---- */
78 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
80 struct hci_dev *hdev = hcon->hdev;
81 struct sco_conn *conn = hcon->sco_data;
86 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
90 spin_lock_init(&conn->lock);
92 hcon->sco_data = conn;
95 conn->src = &hdev->bdaddr;
96 conn->dst = &hcon->dst;
98 if (hdev->sco_mtu > 0)
99 conn->mtu = hdev->sco_mtu;
103 BT_DBG("hcon %p conn %p", hcon, conn);
108 static struct sock *sco_chan_get(struct sco_conn *conn)
110 struct sock *sk = NULL;
113 sco_conn_unlock(conn);
117 static int sco_conn_del(struct hci_conn *hcon, int err)
119 struct sco_conn *conn = hcon->sco_data;
125 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
128 sk = sco_chan_get(conn);
131 sco_sock_clear_timer(sk);
132 sco_chan_del(sk, err);
137 hcon->sco_data = NULL;
142 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
151 __sco_chan_add(conn, sk, parent);
153 sco_conn_unlock(conn);
157 static int sco_connect(struct sock *sk)
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;
166 BT_DBG("%s -> %s", batostr(src), batostr(dst));
168 hdev = hci_get_route(dst, src);
170 return -EHOSTUNREACH;
174 if (lmp_esco_capable(hdev) && !disable_esco)
179 hcon = hci_connect(hdev, type, dst, BDADDR_BREDR, BT_SECURITY_LOW,
186 conn = sco_conn_add(hcon);
193 /* Update source addr of the socket */
194 bacpy(src, conn->src);
196 err = sco_chan_add(conn, sk, NULL);
200 if (hcon->state == BT_CONNECTED) {
201 sco_sock_clear_timer(sk);
202 sk->sk_state = BT_CONNECTED;
204 sk->sk_state = BT_CONNECT;
205 sco_sock_set_timer(sk, sk->sk_sndtimeo);
209 hci_dev_unlock(hdev);
214 static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
216 struct sco_conn *conn = sco_pi(sk)->conn;
220 /* Check outgoing MTU */
224 BT_DBG("sk %p len %d", sk, len);
226 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
230 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
235 hci_send_sco(conn->hcon, skb);
240 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
242 struct sock *sk = sco_chan_get(conn);
247 BT_DBG("sk %p len %d", sk, skb->len);
249 if (sk->sk_state != BT_CONNECTED)
252 if (!sock_queue_rcv_skb(sk, skb))
259 /* -------- Socket interface ---------- */
260 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
262 struct hlist_node *node;
265 sk_for_each(sk, node, &sco_sk_list.head) {
266 if (sk->sk_state != BT_LISTEN)
269 if (!bacmp(&bt_sk(sk)->src, ba))
276 /* Find socket listening on source bdaddr.
277 * Returns closest match.
279 static struct sock *sco_get_sock_listen(bdaddr_t *src)
281 struct sock *sk = NULL, *sk1 = NULL;
282 struct hlist_node *node;
284 read_lock(&sco_sk_list.lock);
286 sk_for_each(sk, node, &sco_sk_list.head) {
287 if (sk->sk_state != BT_LISTEN)
291 if (!bacmp(&bt_sk(sk)->src, src))
295 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
299 read_unlock(&sco_sk_list.lock);
301 return node ? sk : sk1;
304 static void sco_sock_destruct(struct sock *sk)
308 skb_queue_purge(&sk->sk_receive_queue);
309 skb_queue_purge(&sk->sk_write_queue);
312 static void sco_sock_cleanup_listen(struct sock *parent)
316 BT_DBG("parent %p", parent);
318 /* Close not yet accepted channels */
319 while ((sk = bt_accept_dequeue(parent, NULL))) {
324 parent->sk_state = BT_CLOSED;
325 sock_set_flag(parent, SOCK_ZAPPED);
328 /* Kill socket (only if zapped and orphan)
329 * Must be called on unlocked socket.
331 static void sco_sock_kill(struct sock *sk)
333 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
336 BT_DBG("sk %p state %d", sk, sk->sk_state);
338 /* Kill poor orphan */
339 bt_sock_unlink(&sco_sk_list, sk);
340 sock_set_flag(sk, SOCK_DEAD);
344 static void __sco_sock_close(struct sock *sk)
346 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
348 switch (sk->sk_state) {
350 sco_sock_cleanup_listen(sk);
355 if (sco_pi(sk)->conn) {
356 sk->sk_state = BT_DISCONN;
357 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
358 hci_conn_put(sco_pi(sk)->conn->hcon);
359 sco_pi(sk)->conn->hcon = NULL;
361 sco_chan_del(sk, ECONNRESET);
366 sco_chan_del(sk, ECONNRESET);
370 sock_set_flag(sk, SOCK_ZAPPED);
375 /* Must be called on unlocked socket. */
376 static void sco_sock_close(struct sock *sk)
378 sco_sock_clear_timer(sk);
380 __sco_sock_close(sk);
385 static void sco_sock_init(struct sock *sk, struct sock *parent)
390 sk->sk_type = parent->sk_type;
391 security_sk_clone(parent, sk);
395 static struct proto sco_proto = {
397 .owner = THIS_MODULE,
398 .obj_size = sizeof(struct sco_pinfo)
401 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
405 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
409 sock_init_data(sock, sk);
410 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
412 sk->sk_destruct = sco_sock_destruct;
413 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
415 sock_reset_flag(sk, SOCK_ZAPPED);
417 sk->sk_protocol = proto;
418 sk->sk_state = BT_OPEN;
420 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
422 bt_sock_link(&sco_sk_list, sk);
426 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
431 BT_DBG("sock %p", sock);
433 sock->state = SS_UNCONNECTED;
435 if (sock->type != SOCK_SEQPACKET)
436 return -ESOCKTNOSUPPORT;
438 sock->ops = &sco_sock_ops;
440 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
444 sco_sock_init(sk, NULL);
448 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
450 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
451 struct sock *sk = sock->sk;
454 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
456 if (!addr || addr->sa_family != AF_BLUETOOTH)
461 if (sk->sk_state != BT_OPEN) {
466 if (sk->sk_type != SOCK_SEQPACKET) {
471 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
473 sk->sk_state = BT_BOUND;
480 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
482 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
483 struct sock *sk = sock->sk;
489 if (alen < sizeof(struct sockaddr_sco) ||
490 addr->sa_family != AF_BLUETOOTH)
493 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
496 if (sk->sk_type != SOCK_SEQPACKET)
501 /* Set destination address and psm */
502 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
504 err = sco_connect(sk);
508 err = bt_sock_wait_state(sk, BT_CONNECTED,
509 sock_sndtimeo(sk, flags & O_NONBLOCK));
516 static int sco_sock_listen(struct socket *sock, int backlog)
518 struct sock *sk = sock->sk;
519 bdaddr_t *src = &bt_sk(sk)->src;
522 BT_DBG("sk %p backlog %d", sk, backlog);
526 if (sk->sk_state != BT_BOUND) {
531 if (sk->sk_type != SOCK_SEQPACKET) {
536 write_lock(&sco_sk_list.lock);
538 if (__sco_get_sock_listen_by_addr(src)) {
543 sk->sk_max_ack_backlog = backlog;
544 sk->sk_ack_backlog = 0;
546 sk->sk_state = BT_LISTEN;
549 write_unlock(&sco_sk_list.lock);
556 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
558 DECLARE_WAITQUEUE(wait, current);
559 struct sock *sk = sock->sk, *ch;
565 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
567 BT_DBG("sk %p timeo %ld", sk, timeo);
569 /* Wait for an incoming connection. (wake-one). */
570 add_wait_queue_exclusive(sk_sleep(sk), &wait);
572 set_current_state(TASK_INTERRUPTIBLE);
574 if (sk->sk_state != BT_LISTEN) {
579 ch = bt_accept_dequeue(sk, newsock);
588 if (signal_pending(current)) {
589 err = sock_intr_errno(timeo);
594 timeo = schedule_timeout(timeo);
597 __set_current_state(TASK_RUNNING);
598 remove_wait_queue(sk_sleep(sk), &wait);
603 newsock->state = SS_CONNECTED;
605 BT_DBG("new socket %p", ch);
612 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
614 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
615 struct sock *sk = sock->sk;
617 BT_DBG("sock %p, sk %p", sock, sk);
619 addr->sa_family = AF_BLUETOOTH;
620 *len = sizeof(struct sockaddr_sco);
623 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
625 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
630 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
631 struct msghdr *msg, size_t len)
633 struct sock *sk = sock->sk;
636 BT_DBG("sock %p, sk %p", sock, sk);
638 err = sock_error(sk);
642 if (msg->msg_flags & MSG_OOB)
647 if (sk->sk_state == BT_CONNECTED)
648 err = sco_send_frame(sk, msg, len);
656 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
658 struct sock *sk = sock->sk;
675 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
677 struct sock *sk = sock->sk;
678 struct sco_options opts;
679 struct sco_conninfo cinfo;
684 if (get_user(len, optlen))
691 if (sk->sk_state != BT_CONNECTED) {
696 opts.mtu = sco_pi(sk)->conn->mtu;
698 BT_DBG("mtu %d", opts.mtu);
700 len = min_t(unsigned int, len, sizeof(opts));
701 if (copy_to_user(optval, (char *)&opts, len))
707 if (sk->sk_state != BT_CONNECTED) {
712 memset(&cinfo, 0, sizeof(cinfo));
713 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
714 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
716 len = min_t(unsigned int, len, sizeof(cinfo));
717 if (copy_to_user(optval, (char *)&cinfo, len))
731 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
733 struct sock *sk = sock->sk;
738 if (level == SOL_SCO)
739 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
741 if (get_user(len, optlen))
756 static int sco_sock_shutdown(struct socket *sock, int how)
758 struct sock *sk = sock->sk;
761 BT_DBG("sock %p, sk %p", sock, sk);
767 if (!sk->sk_shutdown) {
768 sk->sk_shutdown = SHUTDOWN_MASK;
769 sco_sock_clear_timer(sk);
770 __sco_sock_close(sk);
772 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
773 err = bt_sock_wait_state(sk, BT_CLOSED,
780 static int sco_sock_release(struct socket *sock)
782 struct sock *sk = sock->sk;
785 BT_DBG("sock %p, sk %p", sock, sk);
792 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
794 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
803 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
805 BT_DBG("conn %p", conn);
807 sco_pi(sk)->conn = conn;
811 bt_accept_enqueue(parent, sk);
815 * Must be called on the locked socket. */
816 static void sco_chan_del(struct sock *sk, int err)
818 struct sco_conn *conn;
820 conn = sco_pi(sk)->conn;
822 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
827 sco_pi(sk)->conn = NULL;
828 sco_conn_unlock(conn);
831 hci_conn_put(conn->hcon);
834 sk->sk_state = BT_CLOSED;
836 sk->sk_state_change(sk);
838 sock_set_flag(sk, SOCK_ZAPPED);
841 static void sco_conn_ready(struct sco_conn *conn)
844 struct sock *sk = conn->sk;
846 BT_DBG("conn %p", conn);
851 sco_sock_clear_timer(sk);
853 sk->sk_state = BT_CONNECTED;
854 sk->sk_state_change(sk);
857 parent = sco_get_sock_listen(conn->src);
861 bh_lock_sock(parent);
863 sk = sco_sock_alloc(sock_net(parent), NULL,
864 BTPROTO_SCO, GFP_ATOMIC);
866 bh_unlock_sock(parent);
870 sco_sock_init(sk, parent);
872 bacpy(&bt_sk(sk)->src, conn->src);
873 bacpy(&bt_sk(sk)->dst, conn->dst);
875 hci_conn_hold(conn->hcon);
876 __sco_chan_add(conn, sk, parent);
878 sk->sk_state = BT_CONNECTED;
881 parent->sk_data_ready(parent, 1);
883 bh_unlock_sock(parent);
887 sco_conn_unlock(conn);
890 /* ----- SCO interface with lower layer (HCI) ----- */
891 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr)
894 struct hlist_node *node;
897 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
899 /* Find listening sockets */
900 read_lock(&sco_sk_list.lock);
901 sk_for_each(sk, node, &sco_sk_list.head) {
902 if (sk->sk_state != BT_LISTEN)
905 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
906 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
911 read_unlock(&sco_sk_list.lock);
916 int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
918 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
920 struct sco_conn *conn;
922 conn = sco_conn_add(hcon);
924 sco_conn_ready(conn);
926 sco_conn_del(hcon, bt_to_errno(status));
931 int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
933 BT_DBG("hcon %p reason %d", hcon, reason);
935 sco_conn_del(hcon, bt_to_errno(reason));
939 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
941 struct sco_conn *conn = hcon->sco_data;
946 BT_DBG("conn %p len %d", conn, skb->len);
949 sco_recv_frame(conn, skb);
958 static int sco_debugfs_show(struct seq_file *f, void *p)
961 struct hlist_node *node;
963 read_lock(&sco_sk_list.lock);
965 sk_for_each(sk, node, &sco_sk_list.head) {
966 seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
967 batostr(&bt_sk(sk)->dst), sk->sk_state);
970 read_unlock(&sco_sk_list.lock);
975 static int sco_debugfs_open(struct inode *inode, struct file *file)
977 return single_open(file, sco_debugfs_show, inode->i_private);
980 static const struct file_operations sco_debugfs_fops = {
981 .open = sco_debugfs_open,
984 .release = single_release,
987 static struct dentry *sco_debugfs;
989 static const struct proto_ops sco_sock_ops = {
990 .family = PF_BLUETOOTH,
991 .owner = THIS_MODULE,
992 .release = sco_sock_release,
993 .bind = sco_sock_bind,
994 .connect = sco_sock_connect,
995 .listen = sco_sock_listen,
996 .accept = sco_sock_accept,
997 .getname = sco_sock_getname,
998 .sendmsg = sco_sock_sendmsg,
999 .recvmsg = bt_sock_recvmsg,
1000 .poll = bt_sock_poll,
1001 .ioctl = bt_sock_ioctl,
1002 .mmap = sock_no_mmap,
1003 .socketpair = sock_no_socketpair,
1004 .shutdown = sco_sock_shutdown,
1005 .setsockopt = sco_sock_setsockopt,
1006 .getsockopt = sco_sock_getsockopt
1009 static const struct net_proto_family sco_sock_family_ops = {
1010 .family = PF_BLUETOOTH,
1011 .owner = THIS_MODULE,
1012 .create = sco_sock_create,
1015 int __init sco_init(void)
1019 err = proto_register(&sco_proto, 0);
1023 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1025 BT_ERR("SCO socket registration failed");
1030 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1031 NULL, &sco_debugfs_fops);
1033 BT_ERR("Failed to create SCO debug file");
1036 BT_INFO("SCO socket layer initialized");
1041 proto_unregister(&sco_proto);
1045 void __exit sco_exit(void)
1047 debugfs_remove(sco_debugfs);
1049 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1050 BT_ERR("SCO socket unregistration failed");
1052 proto_unregister(&sco_proto);
1055 module_param(disable_esco, bool, 0644);
1056 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");