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>
29 #include <linux/types.h>
30 #include <linux/errno.h>
31 #include <linux/kernel.h>
32 #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>
40 #include <linux/device.h>
41 #include <linux/debugfs.h>
42 #include <linux/seq_file.h>
43 #include <linux/list.h>
46 #include <asm/system.h>
47 #include <linux/uaccess.h>
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
51 #include <net/bluetooth/sco.h>
53 static int disable_esco;
55 static const struct proto_ops sco_sock_ops;
57 static struct bt_sock_list sco_sk_list = {
58 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
61 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
62 static void sco_chan_del(struct sock *sk, int err);
64 static int sco_conn_del(struct hci_conn *conn, int err);
66 static void sco_sock_close(struct sock *sk);
67 static void sco_sock_kill(struct sock *sk);
69 /* ---- SCO timers ---- */
70 static void sco_sock_timeout(unsigned long arg)
72 struct sock *sk = (struct sock *) arg;
74 BT_DBG("sock %p state %d", sk, sk->sk_state);
77 sk->sk_err = ETIMEDOUT;
78 sk->sk_state_change(sk);
85 static void sco_sock_set_timer(struct sock *sk, long timeout)
87 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
88 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
91 static void sco_sock_clear_timer(struct sock *sk)
93 BT_DBG("sock %p state %d", sk, sk->sk_state);
94 sk_stop_timer(sk, &sk->sk_timer);
97 /* ---- SCO connections ---- */
98 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
100 struct hci_dev *hdev = hcon->hdev;
101 struct sco_conn *conn = hcon->sco_data;
106 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
110 spin_lock_init(&conn->lock);
112 hcon->sco_data = conn;
115 conn->src = &hdev->bdaddr;
116 conn->dst = &hcon->dst;
118 if (hdev->sco_mtu > 0)
119 conn->mtu = hdev->sco_mtu;
123 BT_DBG("hcon %p conn %p", hcon, conn);
128 static inline struct sock *sco_chan_get(struct sco_conn *conn)
130 struct sock *sk = NULL;
133 sco_conn_unlock(conn);
137 static int sco_conn_del(struct hci_conn *hcon, int err)
139 struct sco_conn *conn = hcon->sco_data;
145 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
148 sk = sco_chan_get(conn);
151 sco_sock_clear_timer(sk);
152 sco_chan_del(sk, err);
157 hcon->sco_data = NULL;
162 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
170 __sco_chan_add(conn, sk, parent);
172 sco_conn_unlock(conn);
176 static int sco_connect(struct sock *sk)
178 bdaddr_t *src = &bt_sk(sk)->src;
179 bdaddr_t *dst = &bt_sk(sk)->dst;
180 struct sco_conn *conn;
181 struct hci_conn *hcon;
182 struct hci_dev *hdev;
185 BT_DBG("%s -> %s", batostr(src), batostr(dst));
187 hdev = hci_get_route(dst, src);
189 return -EHOSTUNREACH;
191 hci_dev_lock_bh(hdev);
193 if (lmp_esco_capable(hdev) && !disable_esco)
198 hcon = hci_connect(hdev, type, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
204 conn = sco_conn_add(hcon, 0);
211 /* Update source addr of the socket */
212 bacpy(src, conn->src);
214 err = sco_chan_add(conn, sk, NULL);
218 if (hcon->state == BT_CONNECTED) {
219 sco_sock_clear_timer(sk);
220 sk->sk_state = BT_CONNECTED;
222 sk->sk_state = BT_CONNECT;
223 sco_sock_set_timer(sk, sk->sk_sndtimeo);
227 hci_dev_unlock_bh(hdev);
232 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
234 struct sco_conn *conn = sco_pi(sk)->conn;
238 /* Check outgoing MTU */
242 BT_DBG("sk %p len %d", sk, len);
244 count = min_t(unsigned int, conn->mtu, len);
245 skb = bt_skb_send_alloc(sk, count,
246 msg->msg_flags & MSG_DONTWAIT, &err);
250 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
255 hci_send_sco(conn->hcon, skb);
260 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
262 struct sock *sk = sco_chan_get(conn);
267 BT_DBG("sk %p len %d", sk, skb->len);
269 if (sk->sk_state != BT_CONNECTED)
272 if (!sock_queue_rcv_skb(sk, skb))
279 /* -------- Socket interface ---------- */
280 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
283 struct hlist_node *node;
285 sk_for_each(sk, node, &sco_sk_list.head)
286 if (!bacmp(&bt_sk(sk)->src, ba))
293 /* Find socket listening on source bdaddr.
294 * Returns closest match.
296 static struct sock *sco_get_sock_listen(bdaddr_t *src)
298 struct sock *sk = NULL, *sk1 = NULL;
299 struct hlist_node *node;
301 read_lock(&sco_sk_list.lock);
303 sk_for_each(sk, node, &sco_sk_list.head) {
304 if (sk->sk_state != BT_LISTEN)
308 if (!bacmp(&bt_sk(sk)->src, src))
312 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
316 read_unlock(&sco_sk_list.lock);
318 return node ? sk : sk1;
321 static void sco_sock_destruct(struct sock *sk)
325 skb_queue_purge(&sk->sk_receive_queue);
326 skb_queue_purge(&sk->sk_write_queue);
329 static void sco_sock_cleanup_listen(struct sock *parent)
333 BT_DBG("parent %p", parent);
335 /* Close not yet accepted channels */
336 while ((sk = bt_accept_dequeue(parent, NULL))) {
341 parent->sk_state = BT_CLOSED;
342 sock_set_flag(parent, SOCK_ZAPPED);
345 /* Kill socket (only if zapped and orphan)
346 * Must be called on unlocked socket.
348 static void sco_sock_kill(struct sock *sk)
350 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
353 BT_DBG("sk %p state %d", sk, sk->sk_state);
355 /* Kill poor orphan */
356 bt_sock_unlink(&sco_sk_list, sk);
357 sock_set_flag(sk, SOCK_DEAD);
361 static void __sco_sock_close(struct sock *sk)
363 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
365 switch (sk->sk_state) {
367 sco_sock_cleanup_listen(sk);
372 if (sco_pi(sk)->conn) {
373 sk->sk_state = BT_DISCONN;
374 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
375 hci_conn_put(sco_pi(sk)->conn->hcon);
376 sco_pi(sk)->conn = NULL;
378 sco_chan_del(sk, ECONNRESET);
383 sco_chan_del(sk, ECONNRESET);
387 sock_set_flag(sk, SOCK_ZAPPED);
392 /* Must be called on unlocked socket. */
393 static void sco_sock_close(struct sock *sk)
395 sco_sock_clear_timer(sk);
397 __sco_sock_close(sk);
402 static void sco_sock_init(struct sock *sk, struct sock *parent)
407 sk->sk_type = parent->sk_type;
410 static struct proto sco_proto = {
412 .owner = THIS_MODULE,
413 .obj_size = sizeof(struct sco_pinfo)
416 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
420 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
424 sock_init_data(sock, sk);
425 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
427 sk->sk_destruct = sco_sock_destruct;
428 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
430 sock_reset_flag(sk, SOCK_ZAPPED);
432 sk->sk_protocol = proto;
433 sk->sk_state = BT_OPEN;
435 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
437 bt_sock_link(&sco_sk_list, sk);
441 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
446 BT_DBG("sock %p", sock);
448 sock->state = SS_UNCONNECTED;
450 if (sock->type != SOCK_SEQPACKET)
451 return -ESOCKTNOSUPPORT;
453 sock->ops = &sco_sock_ops;
455 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
459 sco_sock_init(sk, NULL);
463 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
465 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
466 struct sock *sk = sock->sk;
467 bdaddr_t *src = &sa->sco_bdaddr;
470 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
472 if (!addr || addr->sa_family != AF_BLUETOOTH)
477 if (sk->sk_state != BT_OPEN) {
482 write_lock_bh(&sco_sk_list.lock);
484 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
487 /* Save source address */
488 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
489 sk->sk_state = BT_BOUND;
492 write_unlock_bh(&sco_sk_list.lock);
499 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
501 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
502 struct sock *sk = sock->sk;
508 if (alen < sizeof(struct sockaddr_sco) ||
509 addr->sa_family != AF_BLUETOOTH)
512 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
515 if (sk->sk_type != SOCK_SEQPACKET)
520 /* Set destination address and psm */
521 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
523 err = sco_connect(sk);
527 err = bt_sock_wait_state(sk, BT_CONNECTED,
528 sock_sndtimeo(sk, flags & O_NONBLOCK));
535 static int sco_sock_listen(struct socket *sock, int backlog)
537 struct sock *sk = sock->sk;
540 BT_DBG("sk %p backlog %d", sk, backlog);
544 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
549 sk->sk_max_ack_backlog = backlog;
550 sk->sk_ack_backlog = 0;
551 sk->sk_state = BT_LISTEN;
558 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
560 DECLARE_WAITQUEUE(wait, current);
561 struct sock *sk = sock->sk, *ch;
567 if (sk->sk_state != BT_LISTEN) {
572 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
574 BT_DBG("sk %p timeo %ld", sk, timeo);
576 /* Wait for an incoming connection. (wake-one). */
577 add_wait_queue_exclusive(sk_sleep(sk), &wait);
578 while (!(ch = bt_accept_dequeue(sk, newsock))) {
579 set_current_state(TASK_INTERRUPTIBLE);
586 timeo = schedule_timeout(timeo);
589 if (sk->sk_state != BT_LISTEN) {
594 if (signal_pending(current)) {
595 err = sock_intr_errno(timeo);
599 set_current_state(TASK_RUNNING);
600 remove_wait_queue(sk_sleep(sk), &wait);
605 newsock->state = SS_CONNECTED;
607 BT_DBG("new socket %p", ch);
614 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
616 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
617 struct sock *sk = sock->sk;
619 BT_DBG("sock %p, sk %p", sock, sk);
621 addr->sa_family = AF_BLUETOOTH;
622 *len = sizeof(struct sockaddr_sco);
625 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
627 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
632 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
633 struct msghdr *msg, size_t len)
635 struct sock *sk = sock->sk;
638 BT_DBG("sock %p, sk %p", sock, sk);
640 err = sock_error(sk);
644 if (msg->msg_flags & MSG_OOB)
649 if (sk->sk_state == BT_CONNECTED)
650 err = sco_send_frame(sk, msg, len);
658 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
660 struct sock *sk = sock->sk;
677 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
679 struct sock *sk = sock->sk;
680 struct sco_options opts;
681 struct sco_conninfo cinfo;
686 if (get_user(len, optlen))
693 if (sk->sk_state != BT_CONNECTED) {
698 opts.mtu = sco_pi(sk)->conn->mtu;
700 BT_DBG("mtu %d", opts.mtu);
702 len = min_t(unsigned int, len, sizeof(opts));
703 if (copy_to_user(optval, (char *)&opts, len))
709 if (sk->sk_state != BT_CONNECTED) {
714 memset(&cinfo, 0, sizeof(cinfo));
715 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
716 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
718 len = min_t(unsigned int, len, sizeof(cinfo));
719 if (copy_to_user(optval, (char *)&cinfo, len))
733 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
735 struct sock *sk = sock->sk;
740 if (level == SOL_SCO)
741 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
743 if (get_user(len, optlen))
758 static int sco_sock_shutdown(struct socket *sock, int how)
760 struct sock *sk = sock->sk;
763 BT_DBG("sock %p, sk %p", sock, sk);
769 if (!sk->sk_shutdown) {
770 sk->sk_shutdown = SHUTDOWN_MASK;
771 sco_sock_clear_timer(sk);
772 __sco_sock_close(sk);
774 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
775 err = bt_sock_wait_state(sk, BT_CLOSED,
782 static int sco_sock_release(struct socket *sock)
784 struct sock *sk = sock->sk;
787 BT_DBG("sock %p, sk %p", sock, sk);
794 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
796 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
805 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
807 BT_DBG("conn %p", conn);
809 sco_pi(sk)->conn = conn;
813 bt_accept_enqueue(parent, sk);
817 * Must be called on the locked socket. */
818 static void sco_chan_del(struct sock *sk, int err)
820 struct sco_conn *conn;
822 conn = sco_pi(sk)->conn;
824 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
829 sco_pi(sk)->conn = NULL;
830 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 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
893 register struct sock *sk;
894 struct hlist_node *node;
897 if (type != SCO_LINK && type != ESCO_LINK)
900 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
902 /* Find listening sockets */
903 read_lock(&sco_sk_list.lock);
904 sk_for_each(sk, node, &sco_sk_list.head) {
905 if (sk->sk_state != BT_LISTEN)
908 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
909 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
914 read_unlock(&sco_sk_list.lock);
919 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
921 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
923 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
927 struct sco_conn *conn;
929 conn = sco_conn_add(hcon, status);
931 sco_conn_ready(conn);
933 sco_conn_del(hcon, bt_err(status));
938 static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
940 BT_DBG("hcon %p reason %d", hcon, reason);
942 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
945 sco_conn_del(hcon, bt_err(reason));
950 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
952 struct sco_conn *conn = hcon->sco_data;
957 BT_DBG("conn %p len %d", conn, skb->len);
960 sco_recv_frame(conn, skb);
969 static int sco_debugfs_show(struct seq_file *f, void *p)
972 struct hlist_node *node;
974 read_lock_bh(&sco_sk_list.lock);
976 sk_for_each(sk, node, &sco_sk_list.head) {
977 seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
978 batostr(&bt_sk(sk)->dst), sk->sk_state);
981 read_unlock_bh(&sco_sk_list.lock);
986 static int sco_debugfs_open(struct inode *inode, struct file *file)
988 return single_open(file, sco_debugfs_show, inode->i_private);
991 static const struct file_operations sco_debugfs_fops = {
992 .open = sco_debugfs_open,
995 .release = single_release,
998 static struct dentry *sco_debugfs;
1000 static const struct proto_ops sco_sock_ops = {
1001 .family = PF_BLUETOOTH,
1002 .owner = THIS_MODULE,
1003 .release = sco_sock_release,
1004 .bind = sco_sock_bind,
1005 .connect = sco_sock_connect,
1006 .listen = sco_sock_listen,
1007 .accept = sco_sock_accept,
1008 .getname = sco_sock_getname,
1009 .sendmsg = sco_sock_sendmsg,
1010 .recvmsg = bt_sock_recvmsg,
1011 .poll = bt_sock_poll,
1012 .ioctl = bt_sock_ioctl,
1013 .mmap = sock_no_mmap,
1014 .socketpair = sock_no_socketpair,
1015 .shutdown = sco_sock_shutdown,
1016 .setsockopt = sco_sock_setsockopt,
1017 .getsockopt = sco_sock_getsockopt
1020 static const struct net_proto_family sco_sock_family_ops = {
1021 .family = PF_BLUETOOTH,
1022 .owner = THIS_MODULE,
1023 .create = sco_sock_create,
1026 static struct hci_proto sco_hci_proto = {
1028 .id = HCI_PROTO_SCO,
1029 .connect_ind = sco_connect_ind,
1030 .connect_cfm = sco_connect_cfm,
1031 .disconn_cfm = sco_disconn_cfm,
1032 .recv_scodata = sco_recv_scodata
1035 int __init sco_init(void)
1039 err = proto_register(&sco_proto, 0);
1043 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1045 BT_ERR("SCO socket registration failed");
1049 err = hci_register_proto(&sco_hci_proto);
1051 BT_ERR("SCO protocol registration failed");
1052 bt_sock_unregister(BTPROTO_SCO);
1057 sco_debugfs = debugfs_create_file("sco", 0444,
1058 bt_debugfs, NULL, &sco_debugfs_fops);
1060 BT_ERR("Failed to create SCO debug file");
1063 BT_INFO("SCO socket layer initialized");
1068 proto_unregister(&sco_proto);
1072 void __exit sco_exit(void)
1074 debugfs_remove(sco_debugfs);
1076 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1077 BT_ERR("SCO socket unregistration failed");
1079 if (hci_unregister_proto(&sco_hci_proto) < 0)
1080 BT_ERR("SCO protocol unregistration failed");
1082 proto_unregister(&sco_proto);
1085 module_param(disable_esco, bool, 0644);
1086 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");