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/list.h>
44 #include <asm/system.h>
45 #include <asm/uaccess.h>
47 #include <net/bluetooth/bluetooth.h>
48 #include <net/bluetooth/hci_core.h>
49 #include <net/bluetooth/sco.h>
53 static int disable_esco = 0;
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;
142 if (!(conn = hcon->sco_data))
145 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
148 if ((sk = sco_chan_get(conn))) {
150 sco_sock_clear_timer(sk);
151 sco_chan_del(sk, err);
156 hcon->sco_data = NULL;
161 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
169 __sco_chan_add(conn, sk, parent);
171 sco_conn_unlock(conn);
175 static int sco_connect(struct sock *sk)
177 bdaddr_t *src = &bt_sk(sk)->src;
178 bdaddr_t *dst = &bt_sk(sk)->dst;
179 struct sco_conn *conn;
180 struct hci_conn *hcon;
181 struct hci_dev *hdev;
184 BT_DBG("%s -> %s", batostr(src), batostr(dst));
186 if (!(hdev = hci_get_route(dst, src)))
187 return -EHOSTUNREACH;
189 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);
202 conn = sco_conn_add(hcon, 0);
208 /* Update source addr of the socket */
209 bacpy(src, conn->src);
211 err = sco_chan_add(conn, sk, NULL);
215 if (hcon->state == BT_CONNECTED) {
216 sco_sock_clear_timer(sk);
217 sk->sk_state = BT_CONNECTED;
219 sk->sk_state = BT_CONNECT;
220 sco_sock_set_timer(sk, sk->sk_sndtimeo);
224 hci_dev_unlock_bh(hdev);
229 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
231 struct sco_conn *conn = sco_pi(sk)->conn;
235 /* Check outgoing MTU */
239 BT_DBG("sk %p len %d", sk, len);
241 count = min_t(unsigned int, conn->mtu, len);
242 if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
245 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
250 if ((err = hci_send_sco(conn->hcon, skb)) < 0)
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))
280 /* -------- Socket interface ---------- */
281 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
284 struct hlist_node *node;
286 sk_for_each(sk, node, &sco_sk_list.head)
287 if (!bacmp(&bt_sk(sk)->src, ba))
294 /* Find socket listening on source bdaddr.
295 * Returns closest match.
297 static struct sock *sco_get_sock_listen(bdaddr_t *src)
299 struct sock *sk = NULL, *sk1 = NULL;
300 struct hlist_node *node;
302 read_lock(&sco_sk_list.lock);
304 sk_for_each(sk, node, &sco_sk_list.head) {
305 if (sk->sk_state != BT_LISTEN)
309 if (!bacmp(&bt_sk(sk)->src, src))
313 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
317 read_unlock(&sco_sk_list.lock);
319 return node ? sk : sk1;
322 static void sco_sock_destruct(struct sock *sk)
326 skb_queue_purge(&sk->sk_receive_queue);
327 skb_queue_purge(&sk->sk_write_queue);
330 static void sco_sock_cleanup_listen(struct sock *parent)
334 BT_DBG("parent %p", parent);
336 /* Close not yet accepted channels */
337 while ((sk = bt_accept_dequeue(parent, NULL))) {
342 parent->sk_state = BT_CLOSED;
343 sock_set_flag(parent, SOCK_ZAPPED);
346 /* Kill socket (only if zapped and orphan)
347 * Must be called on unlocked socket.
349 static void sco_sock_kill(struct sock *sk)
351 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
354 BT_DBG("sk %p state %d", sk, sk->sk_state);
356 /* Kill poor orphan */
357 bt_sock_unlink(&sco_sk_list, sk);
358 sock_set_flag(sk, SOCK_DEAD);
362 static void __sco_sock_close(struct sock *sk)
364 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
366 switch (sk->sk_state) {
368 sco_sock_cleanup_listen(sk);
375 sco_chan_del(sk, ECONNRESET);
379 sock_set_flag(sk, SOCK_ZAPPED);
384 /* Must be called on unlocked socket. */
385 static void sco_sock_close(struct sock *sk)
387 sco_sock_clear_timer(sk);
389 __sco_sock_close(sk);
394 static void sco_sock_init(struct sock *sk, struct sock *parent)
399 sk->sk_type = parent->sk_type;
402 static struct proto sco_proto = {
404 .owner = THIS_MODULE,
405 .obj_size = sizeof(struct sco_pinfo)
408 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
412 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
416 sock_init_data(sock, sk);
417 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
419 sk->sk_destruct = sco_sock_destruct;
420 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
422 sock_reset_flag(sk, SOCK_ZAPPED);
424 sk->sk_protocol = proto;
425 sk->sk_state = BT_OPEN;
427 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
429 bt_sock_link(&sco_sk_list, sk);
433 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32))
434 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
437 static int sco_sock_create(struct net *net, struct socket *sock, int protocol)
442 BT_DBG("sock %p", sock);
444 sock->state = SS_UNCONNECTED;
446 if (sock->type != SOCK_SEQPACKET)
447 return -ESOCKTNOSUPPORT;
449 sock->ops = &sco_sock_ops;
451 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
455 sco_sock_init(sk, NULL);
459 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
461 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
462 struct sock *sk = sock->sk;
463 bdaddr_t *src = &sa->sco_bdaddr;
466 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
468 if (!addr || addr->sa_family != AF_BLUETOOTH)
473 if (sk->sk_state != BT_OPEN) {
478 write_lock_bh(&sco_sk_list.lock);
480 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
483 /* Save source address */
484 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
485 sk->sk_state = BT_BOUND;
488 write_unlock_bh(&sco_sk_list.lock);
495 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
497 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
498 struct sock *sk = sock->sk;
504 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
507 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
510 if (sk->sk_type != SOCK_SEQPACKET)
515 /* Set destination address and psm */
516 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
518 if ((err = sco_connect(sk)))
521 err = bt_sock_wait_state(sk, BT_CONNECTED,
522 sock_sndtimeo(sk, flags & O_NONBLOCK));
529 static int sco_sock_listen(struct socket *sock, int backlog)
531 struct sock *sk = sock->sk;
534 BT_DBG("sk %p backlog %d", sk, backlog);
538 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
543 sk->sk_max_ack_backlog = backlog;
544 sk->sk_ack_backlog = 0;
545 sk->sk_state = BT_LISTEN;
552 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
554 DECLARE_WAITQUEUE(wait, current);
555 struct sock *sk = sock->sk, *ch;
561 if (sk->sk_state != BT_LISTEN) {
566 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
568 BT_DBG("sk %p timeo %ld", sk, timeo);
570 /* Wait for an incoming connection. (wake-one). */
571 add_wait_queue_exclusive(sk->sk_sleep, &wait);
572 while (!(ch = bt_accept_dequeue(sk, newsock))) {
573 set_current_state(TASK_INTERRUPTIBLE);
580 timeo = schedule_timeout(timeo);
583 if (sk->sk_state != BT_LISTEN) {
588 if (signal_pending(current)) {
589 err = sock_intr_errno(timeo);
593 set_current_state(TASK_RUNNING);
594 remove_wait_queue(sk->sk_sleep, &wait);
599 newsock->state = SS_CONNECTED;
601 BT_DBG("new socket %p", ch);
608 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
610 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
611 struct sock *sk = sock->sk;
613 BT_DBG("sock %p, sk %p", sock, sk);
615 addr->sa_family = AF_BLUETOOTH;
616 *len = sizeof(struct sockaddr_sco);
619 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
621 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
626 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
627 struct msghdr *msg, size_t len)
629 struct sock *sk = sock->sk;
632 BT_DBG("sock %p, sk %p", sock, sk);
634 err = sock_error(sk);
638 if (msg->msg_flags & MSG_OOB)
643 if (sk->sk_state == BT_CONNECTED)
644 err = sco_send_frame(sk, msg, len);
652 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
653 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
655 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, 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 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
713 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
715 len = min_t(unsigned int, len, sizeof(cinfo));
716 if (copy_to_user(optval, (char *)&cinfo, len))
730 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
732 struct sock *sk = sock->sk;
737 if (level == SOL_SCO)
738 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
740 if (get_user(len, optlen))
755 static int sco_sock_shutdown(struct socket *sock, int how)
757 struct sock *sk = sock->sk;
760 BT_DBG("sock %p, sk %p", sock, sk);
766 if (!sk->sk_shutdown) {
767 sk->sk_shutdown = SHUTDOWN_MASK;
768 sco_sock_clear_timer(sk);
769 __sco_sock_close(sk);
771 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
772 err = bt_sock_wait_state(sk, BT_CLOSED,
779 static int sco_sock_release(struct socket *sock)
781 struct sock *sk = sock->sk;
784 BT_DBG("sock %p, sk %p", sock, sk);
791 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
793 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
802 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
804 BT_DBG("conn %p", conn);
806 sco_pi(sk)->conn = conn;
810 bt_accept_enqueue(parent, sk);
814 * Must be called on the locked socket. */
815 static void sco_chan_del(struct sock *sk, int err)
817 struct sco_conn *conn;
819 conn = sco_pi(sk)->conn;
821 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
826 sco_pi(sk)->conn = NULL;
827 sco_conn_unlock(conn);
828 hci_conn_put(conn->hcon);
831 sk->sk_state = BT_CLOSED;
833 sk->sk_state_change(sk);
835 sock_set_flag(sk, SOCK_ZAPPED);
838 static void sco_conn_ready(struct sco_conn *conn)
840 struct sock *parent, *sk;
842 BT_DBG("conn %p", conn);
846 if ((sk = conn->sk)) {
847 sco_sock_clear_timer(sk);
849 sk->sk_state = BT_CONNECTED;
850 sk->sk_state_change(sk);
853 parent = sco_get_sock_listen(conn->src);
857 bh_lock_sock(parent);
859 sk = sco_sock_alloc(sock_net(parent), NULL, BTPROTO_SCO, GFP_ATOMIC);
861 bh_unlock_sock(parent);
865 sco_sock_init(sk, parent);
867 bacpy(&bt_sk(sk)->src, conn->src);
868 bacpy(&bt_sk(sk)->dst, conn->dst);
870 hci_conn_hold(conn->hcon);
871 __sco_chan_add(conn, sk, parent);
873 sk->sk_state = BT_CONNECTED;
876 parent->sk_data_ready(parent, 1);
878 bh_unlock_sock(parent);
882 sco_conn_unlock(conn);
885 /* ----- SCO interface with lower layer (HCI) ----- */
886 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
888 register struct sock *sk;
889 struct hlist_node *node;
892 if (type != SCO_LINK && type != ESCO_LINK)
895 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
897 /* Find listening sockets */
898 read_lock(&sco_sk_list.lock);
899 sk_for_each(sk, node, &sco_sk_list.head) {
900 if (sk->sk_state != BT_LISTEN)
903 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
904 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
909 read_unlock(&sco_sk_list.lock);
914 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
916 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
918 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
922 struct sco_conn *conn;
924 conn = sco_conn_add(hcon, status);
926 sco_conn_ready(conn);
928 sco_conn_del(hcon, bt_err(status));
933 static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
935 BT_DBG("hcon %p reason %d", hcon, reason);
937 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
940 sco_conn_del(hcon, bt_err(reason));
945 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
947 struct sco_conn *conn = hcon->sco_data;
952 BT_DBG("conn %p len %d", conn, skb->len);
955 sco_recv_frame(conn, skb);
964 static ssize_t sco_sysfs_show(struct class *dev,
965 struct class_attribute *attr,
969 struct hlist_node *node;
972 read_lock_bh(&sco_sk_list.lock);
974 sk_for_each(sk, node, &sco_sk_list.head) {
975 str += sprintf(str, "%s %s %d\n",
976 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
980 read_unlock_bh(&sco_sk_list.lock);
985 static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
987 static const struct proto_ops sco_sock_ops = {
988 .family = PF_BLUETOOTH,
989 .owner = THIS_MODULE,
990 .release = sco_sock_release,
991 .bind = sco_sock_bind,
992 .connect = sco_sock_connect,
993 .listen = sco_sock_listen,
994 .accept = sco_sock_accept,
995 .getname = sco_sock_getname,
996 .sendmsg = sco_sock_sendmsg,
997 .recvmsg = bt_sock_recvmsg,
998 .poll = bt_sock_poll,
999 .ioctl = bt_sock_ioctl,
1000 .mmap = sock_no_mmap,
1001 .socketpair = sock_no_socketpair,
1002 .shutdown = sco_sock_shutdown,
1003 .setsockopt = sco_sock_setsockopt,
1004 .getsockopt = sco_sock_getsockopt
1007 static const struct net_proto_family sco_sock_family_ops = {
1008 .family = PF_BLUETOOTH,
1009 .owner = THIS_MODULE,
1010 .create = sco_sock_create,
1013 static struct hci_proto sco_hci_proto = {
1015 .id = HCI_PROTO_SCO,
1016 .connect_ind = sco_connect_ind,
1017 .connect_cfm = sco_connect_cfm,
1018 .disconn_cfm = sco_disconn_cfm,
1019 .recv_scodata = sco_recv_scodata
1022 static int __init sco_init(void)
1026 err = proto_register(&sco_proto, 0);
1030 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1032 BT_ERR("SCO socket registration failed");
1036 err = hci_register_proto(&sco_hci_proto);
1038 BT_ERR("SCO protocol registration failed");
1039 bt_sock_unregister(BTPROTO_SCO);
1043 if (class_create_file(bt_class, &class_attr_sco) < 0)
1044 BT_ERR("Failed to create SCO info file");
1046 BT_INFO("SCO (Voice Link) ver %s", VERSION);
1047 BT_INFO("SCO socket layer initialized");
1052 proto_unregister(&sco_proto);
1056 static void __exit sco_exit(void)
1058 class_remove_file(bt_class, &class_attr_sco);
1060 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1061 BT_ERR("SCO socket unregistration failed");
1063 if (hci_unregister_proto(&sco_hci_proto) < 0)
1064 BT_ERR("SCO protocol unregistration failed");
1066 proto_unregister(&sco_proto);
1069 module_init(sco_init);
1070 module_exit(sco_exit);
1072 module_param(disable_esco, bool, 0644);
1073 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1075 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1076 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1077 MODULE_VERSION(VERSION);
1078 MODULE_LICENSE("GPL");
1079 MODULE_ALIAS("bt-proto-2");