Release 4.11 net/bluetooth/sco.c

/*
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

/* Bluetooth SCO sockets. */

#include <linux/module.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/sched/signal.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#include <net/bluetooth/sco.h>


static bool disable_esco;


static const struct proto_ops sco_sock_ops;


static struct bt_sock_list sco_sk_list = {
	.lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
};

/* ---- SCO connections ---- */

struct sco_conn {
	
struct hci_conn	*hcon;

	
spinlock_t	lock;
	
struct sock	*sk;

	
unsigned int    mtu;
};


#define sco_conn_lock(c)	spin_lock(&c->lock);

#define sco_conn_unlock(c)	spin_unlock(&c->lock);

static void sco_sock_close(struct sock *sk);
static void sco_sock_kill(struct sock *sk);

/* ----- SCO socket info ----- */

#define sco_pi(sk) ((struct sco_pinfo *) sk)


struct sco_pinfo {
	
struct bt_sock	bt;
	
bdaddr_t	src;
	
bdaddr_t	dst;
	
__u32		flags;
	
__u16		setting;
	
struct sco_conn	*conn;
};

/* ---- SCO timers ---- */

#define SCO_CONN_TIMEOUT	(HZ * 40)

#define SCO_DISCONN_TIMEOUT	(HZ * 2)



static void sco_sock_timeout(unsigned long arg)
{
	struct sock *sk = (struct sock *)arg;

	BT_DBG("sock %p state %d", sk, sk->sk_state);

	bh_lock_sock(sk);
	sk->sk_err = ETIMEDOUT;
	sk->sk_state_change(sk);
	bh_unlock_sock(sk);

	sco_sock_kill(sk);
	sock_put(sk);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
63
95.45%
1
50.00%
Arnaldo Carvalho de Melo
3
4.55%
1
50.00%
Total
66
100.00%
2
100.00%



static void sco_sock_set_timer(struct sock *sk, long timeout)
{
	BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
	sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
36
87.80%
1
33.33%
Arnaldo Carvalho de Melo
5
12.20%
2
66.67%
Total
41
100.00%
3
100.00%



static void sco_sock_clear_timer(struct sock *sk)
{
	BT_DBG("sock %p state %d", sk, sk->sk_state);
	sk_stop_timer(sk, &sk->sk_timer);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
28
87.50%
1
33.33%
Arnaldo Carvalho de Melo
4
12.50%
2
66.67%
Total
32
100.00%
3
100.00%

/* ---- SCO connections ---- */


static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
{
	struct hci_dev *hdev = hcon->hdev;
	struct sco_conn *conn = hcon->sco_data;

	if (conn)
		return conn;

	conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
	if (!conn)
		return NULL;

	spin_lock_init(&conn->lock);

	hcon->sco_data = conn;
	conn->hcon = hcon;

	if (hdev->sco_mtu > 0)
		conn->mtu = hdev->sco_mtu;
	else
		conn->mtu = 60;

	BT_DBG("hcon %p conn %p", hcon, conn);

	return conn;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
104
91.23%
1
33.33%
Marcel Holtmann
9
7.89%
1
33.33%
Claudio Takahasi
1
0.88%
1
33.33%
Total
114
100.00%
3
100.00%

/* Delete channel.
 * Must be called on the locked socket. */


static void sco_chan_del(struct sock *sk, int err)
{
	struct sco_conn *conn;

	conn = sco_pi(sk)->conn;

	BT_DBG("sk %p, conn %p, err %d", sk, conn, err);

	if (conn) {
		sco_conn_lock(conn);
		conn->sk = NULL;
		sco_pi(sk)->conn = NULL;
		sco_conn_unlock(conn);

		if (conn->hcon)
			hci_conn_drop(conn->hcon);
	}

	sk->sk_state = BT_CLOSED;
	sk->sk_err   = err;
	sk->sk_state_change(sk);

	sock_set_flag(sk, SOCK_ZAPPED);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
109
100.00%
1
100.00%
Total
109
100.00%
1
100.00%



static void sco_conn_del(struct hci_conn *hcon, int err)
{
	struct sco_conn *conn = hcon->sco_data;
	struct sock *sk;

	if (!conn)
		return;

	BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);

	/* Kill socket */
	sco_conn_lock(conn);
	sk = conn->sk;
	sco_conn_unlock(conn);

	if (sk) {
		sock_hold(sk);
		bh_lock_sock(sk);
		sco_sock_clear_timer(sk);
		sco_chan_del(sk, err);
		bh_unlock_sock(sk);
		sco_sock_kill(sk);
		sock_put(sk);
	}

	hcon->sco_data = NULL;
	kfree(conn);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
86
74.14%
1
20.00%
Kuba Pawlak
10
8.62%
1
20.00%
Marcel Holtmann
10
8.62%
1
20.00%
Andrei Emeltchenko
8
6.90%
1
20.00%
Nicholas Krause
2
1.72%
1
20.00%
Total
116
100.00%
5
100.00%



static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
			   struct sock *parent)
{
	BT_DBG("conn %p", conn);

	sco_pi(sk)->conn = conn;
	conn->sk = sk;

	if (parent)
		bt_accept_enqueue(parent, sk);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
54
100.00%
1
100.00%
Total
54
100.00%
1
100.00%



static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
			struct sock *parent)
{
	int err = 0;

	sco_conn_lock(conn);
	if (conn->sk)
		err = -EBUSY;
	else
		__sco_chan_add(conn, sk, parent);

	sco_conn_unlock(conn);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maxim Krasnyansky
60
100.00%
1
100.00%
Total
60
100.00%
1
100.00%



static int sco_connect(struct sock *sk)
{
	struct sco_conn *conn;
	struct hci_conn *hcon;
	struct hci_dev  *hdev;
	int err, type;

	BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);

	hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
	if (!hdev)
		return -EHOSTUNREACH;

	hci_dev_lock(hdev);

	if (lmp_esco_capable(hdev) && !disable_esco)
		type = ESCO_LINK;
	else
		type = SCO_LINK;

	if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
	    (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev))) {
		err = -EOPNOTSUPP;
		goto done;
	}

	hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
			       sco_pi(sk)->setting);
	if (IS_ERR(hcon)) {
		err = PTR_ERR(hcon);
		goto done;
	}

	conn = sco_conn_add(hcon);
	if (!conn) {
		hci_conn_drop(hcon);
		err = -ENOMEM;
		goto done;
	}

	/* Update source addr of the socket */
	bacpy(&sco_pi(sk)->src, &hcon->src);

	err = sco_chan_add(conn, sk, NULL);
	if (err)
		goto done;

	if (hcon->state == BT_CONNECTED) {
		sco_sock_clear_timer(sk);
		sk->sk_state = BT_CONNECTED;
	} else {
		sk->sk_state = BT_CONNECT;
		sco_sock_set_timer(sk, sk->sk_sndtimeo);
	}

done:
	hci_dev_unlock(hdev);
	hci_dev_put(hdev);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
167
55.30%
1
6.25%
Marcel Holtmann
61
20.20%
5
31.25%
Frédéric Dalleau
43
14.24%
3
18.75%
Ville Tervo
17
5.63%
1
6.25%
Andrei Emeltchenko
6
1.99%
2
12.50%
Arnaldo Carvalho de Melo
3
0.99%
1
6.25%
Gustavo Fernando Padovan
2
0.66%
1
6.25%
Johan Hedberg
2
0.66%
1
6.25%
David Herrmann
1
0.33%
1
6.25%
Total
302
100.00%
16
100.00%



static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
{
	struct sco_conn *conn = sco_pi(sk)->conn;
	struct sk_buff *skb;
	int err;

	/* Check outgoing MTU */
	if (len > conn->mtu)
		return -EINVAL;

	BT_DBG("sk %p len %d", sk, len);

	skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
	if (!skb)
		return err;

	if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
		kfree_skb(skb);
		return -EFAULT;
	}

	hci_send_sco(conn->hcon, skb);

	return len;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
108
85.71%
2
33.33%
Gustavo Fernando Padovan
13
10.32%
2
33.33%
Mikel Astiz
4
3.17%
1
16.67%
Al Viro
1
0.79%
1
16.67%
Total
126
100.00%
6
100.00%



static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
{
	struct sock *sk;

	sco_conn_lock(conn);
	sk = conn->sk;
	sco_conn_unlock(conn);

	if (!sk)
		goto drop;

	BT_DBG("sk %p len %d", sk, skb->len);

	if (sk->sk_state != BT_CONNECTED)
		goto drop;

	if (!sock_queue_rcv_skb(sk, skb))
		return;

drop:
	kfree_skb(skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
70
82.35%
1
33.33%
Marcel Holtmann
14
16.47%
1
33.33%
Arnaldo Carvalho de Melo
1
1.18%
1
33.33%
Total
85
100.00%
3
100.00%

/* -------- Socket interface ---------- */


static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
{
	struct sock *sk;

	sk_for_each(sk, &sco_sk_list.head) {
		if (sk->sk_state != BT_LISTEN)
			continue;

		if (!bacmp(&sco_pi(sk)->src, ba))
			return sk;
	}

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
30
53.57%
1
25.00%
Marcel Holtmann
18
32.14%
2
50.00%
Arnaldo Carvalho de Melo
8
14.29%
1
25.00%
Total
56
100.00%
4
100.00%

/* Find socket listening on source bdaddr.
 * Returns closest match.
 */


static struct sock *sco_get_sock_listen(bdaddr_t *src)
{
	struct sock *sk = NULL, *sk1 = NULL;

	read_lock(&sco_sk_list.lock);

	sk_for_each(sk, &sco_sk_list.head) {
		if (sk->sk_state != BT_LISTEN)
			continue;

		/* Exact match. */
		if (!bacmp(&sco_pi(sk)->src, src))
			break;

		/* Closest match */
		if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
			sk1 = sk;
	}

	read_unlock(&sco_sk_list.lock);

	return sk ? sk : sk1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
91
88.35%
1
20.00%
Arnaldo Carvalho de Melo
9
8.74%
2
40.00%
Marcel Holtmann
2
1.94%
1
20.00%
Sasha Levin
1
0.97%
1
20.00%
Total
103
100.00%
5
100.00%



static void sco_sock_destruct(struct sock *sk)
{
	BT_DBG("sk %p", sk);

	skb_queue_purge(&sk->sk_receive_queue);
	skb_queue_purge(&sk->sk_write_queue);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
32
94.12%
1
50.00%
Arnaldo Carvalho de Melo
2
5.88%
1
50.00%
Total
34
100.00%
2
100.00%



static void sco_sock_cleanup_listen(struct sock *parent)
{
	struct sock *sk;

	BT_DBG("parent %p", parent);

	/* Close not yet accepted channels */
	while ((sk = bt_accept_dequeue(parent, NULL))) {
		sco_sock_close(sk);
		sco_sock_kill(sk);
	}

	parent->sk_state  = BT_CLOSED;
	sock_set_flag(parent, SOCK_ZAPPED);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
55
88.71%
3
50.00%
Thomas Graf
5
8.06%
1
16.67%
Arnaldo Carvalho de Melo
1
1.61%
1
16.67%
David Woodhouse
1
1.61%
1
16.67%
Total
62
100.00%
6
100.00%

/* Kill socket (only if zapped and orphan)
 * Must be called on unlocked socket.
 */


static void sco_sock_kill(struct sock *sk)
{
	if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
		return;

	BT_DBG("sk %p state %d", sk, sk->sk_state);

	/* Kill poor orphan */
	bt_sock_unlink(&sco_sk_list, sk);
	sock_set_flag(sk, SOCK_DEAD);
	sock_put(sk);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
46
79.31%
2
33.33%
Arnaldo Carvalho de Melo
5
8.62%
2
33.33%
Thomas Graf
5
8.62%
1
16.67%
James Morris
2
3.45%
1
16.67%
Total
58
100.00%
6
100.00%



static void __sco_sock_close(struct sock *sk)
{
	BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);

	switch (sk->sk_state) {
	case BT_LISTEN:
		sco_sock_cleanup_listen(sk);
		break;

	case BT_CONNECTED:
	case BT_CONFIG:
		if (sco_pi(sk)->conn->hcon) {
			sk->sk_state = BT_DISCONN;
			sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
			sco_conn_lock(sco_pi(sk)->conn);
			hci_conn_drop(sco_pi(sk)->conn->hcon);
			sco_pi(sk)->conn->hcon = NULL;
			sco_conn_unlock(sco_pi(sk)->conn);
		} else
			sco_chan_del(sk, ECONNRESET);
		break;

	case BT_CONNECT2:
	case BT_CONNECT:
	case BT_DISCONN:
		sco_chan_del(sk, ECONNRESET);
		break;

	default:
		sock_set_flag(sk, SOCK_ZAPPED);
		break;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
61
39.87%
1
11.11%
Luiz Augusto von Dentz
55
35.95%
1
11.11%
Kuba Pawlak
20
13.07%
1
11.11%
Thomas Graf
5
3.27%
1
11.11%
Marcel Holtmann
3
1.96%
1
11.11%
Vinicius Costa Gomes
3
1.96%
1
11.11%
Arnaldo Carvalho de Melo
3
1.96%
1
11.11%
Gustavo Fernando Padovan
2
1.31%
1
11.11%
David Herrmann
1
0.65%
1
11.11%
Total
153
100.00%
9
100.00%

/* Must be called on unlocked socket. */


static void sco_sock_close(struct sock *sk)
{
	sco_sock_clear_timer(sk);
	lock_sock(sk);
	__sco_sock_close(sk);
	release_sock(sk);
	sco_sock_kill(sk);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
25
69.44%
1
50.00%
Maksim Krasnyanskiy
11
30.56%
1
50.00%
Total
36
100.00%
2
100.00%



static void sco_sock_init(struct sock *sk, struct sock *parent)
{
	BT_DBG("sk %p", sk);

	if (parent) {
		sk->sk_type = parent->sk_type;
		bt_sk(sk)->flags = bt_sk(parent)->flags;
		security_sk_clone(parent, sk);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
33
56.90%
1
25.00%
Frédéric Dalleau
14
24.14%
1
25.00%
Paul Moore
9
15.52%
1
25.00%
Arnaldo Carvalho de Melo
2
3.45%
1
25.00%
Total
58
100.00%
4
100.00%


static struct proto sco_proto = {
	.name		= "SCO",
	.owner		= THIS_MODULE,
	.obj_size	= sizeof(struct sco_pinfo)
};



static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
				   int proto, gfp_t prio, int kern)
{
	struct sock *sk;

	sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
	if (!sk)
		return NULL;

	sock_init_data(sock, sk);
	INIT_LIST_HEAD(&bt_sk(sk)->accept_q);

	sk->sk_destruct = sco_sock_destruct;
	sk->sk_sndtimeo = SCO_CONN_TIMEOUT;

	sock_reset_flag(sk, SOCK_ZAPPED);

	sk->sk_protocol = proto;
	sk->sk_state    = BT_OPEN;

	sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;

	setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);

	bt_sock_link(&sco_sk_list, sk);
	return sk;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
68
48.23%
2
20.00%
Marcel Holtmann
34
24.11%
1
10.00%
Pavel Emelyanov
12
8.51%
1
10.00%
Eric W. Biedermann
12
8.51%
2
20.00%
Frédéric Dalleau
9
6.38%
1
10.00%
Arnaldo Carvalho de Melo
5
3.55%
2
20.00%
Al Viro
1
0.71%
1
10.00%
Total
141
100.00%
10
100.00%



static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
			   int kern)
{
	struct sock *sk;

	BT_DBG("sock %p", sock);

	sock->state = SS_UNCONNECTED;

	if (sock->type != SOCK_SEQPACKET)
		return -ESOCKTNOSUPPORT;

	sock->ops = &sco_sock_ops;

	sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
	if (!sk)
		return -ENOMEM;

	sco_sock_init(sk, NULL);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
75
80.65%
1
20.00%
Eric W. Biedermann
9
9.68%
2
40.00%
Marcel Holtmann
6
6.45%
1
20.00%
Eric Paris
3
3.23%
1
20.00%
Total
93
100.00%
5
100.00%



static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
			 int addr_len)
{
	struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
	struct sock *sk = sock->sk;
	int err = 0;

	BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);

	if (!addr || addr->sa_family != AF_BLUETOOTH)
		return -EINVAL;

	if (addr_len < sizeof(struct sockaddr_sco))
		return -EINVAL;

	lock_sock(sk);

	if (sk->sk_state != BT_OPEN) {
		err = -EBADFD;
		goto done;
	}

	if (sk->sk_type != SOCK_SEQPACKET) {
		err = -EINVAL;
		goto done;
	}

	bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);

	sk->sk_state = BT_BOUND;

done:
	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
132
83.02%
1
16.67%
David S. Miller
14
8.81%
1
16.67%
Marcel Holtmann
10
6.29%
2
33.33%
Arnaldo Carvalho de Melo
2
1.26%
1
16.67%
Andrei Emeltchenko
1
0.63%
1
16.67%
Total
159
100.00%
6
100.00%



static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
{
	struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
	struct sock *sk = sock->sk;
	int err;

	BT_DBG("sk %p", sk);

	if (alen < sizeof(struct sockaddr_sco) ||
	    addr->sa_family != AF_BLUETOOTH)
		return -EINVAL;

	if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
		return -EBADFD;

	if (sk->sk_type != SOCK_SEQPACKET)
		return -EINVAL;

	lock_sock(sk);

	/* Set destination address and psm */
	bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);

	err = sco_connect(sk);
	if (err)
		goto done;

	err = bt_sock_wait_state(sk, BT_CONNECTED,
				 sock_sndtimeo(sk, flags & O_NONBLOCK));

done:
	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
153
91.62%
2
33.33%
Changli Gao
6
3.59%
1
16.67%
Andrei Emeltchenko
4
2.40%
1
16.67%
Arnaldo Carvalho de Melo
3
1.80%
1
16.67%
Marcel Holtmann
1
0.60%
1
16.67%
Total
167
100.00%
6
100.00%



static int sco_sock_listen(struct socket *sock, int backlog)
{
	struct sock *sk = sock->sk;
	bdaddr_t *src = &sco_pi(sk)->src;
	int err = 0;

	BT_DBG("sk %p backlog %d", sk, backlog);

	lock_sock(sk);

	if (sk->sk_state != BT_BOUND) {
		err = -EBADFD;
		goto done;
	}

	if (sk->sk_type != SOCK_SEQPACKET) {
		err = -EINVAL;
		goto done;
	}

	write_lock(&sco_sk_list.lock);

	if (__sco_get_sock_listen_by_addr(src)) {
		err = -EADDRINUSE;
		goto unlock;
	}

	sk->sk_max_ack_backlog = backlog;
	sk->sk_ack_backlog = 0;

	sk->sk_state = BT_LISTEN;

unlock:
	write_unlock(&sco_sk_list.lock);

done:
	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
85
55.56%
1
16.67%
Marcel Holtmann
64
41.83%
4
66.67%
Arnaldo Carvalho de Melo
4
2.61%
1
16.67%
Total
153
100.00%
6
100.00%



static int sco_sock_accept(struct socket *sock, struct socket *newsock,
			   int flags, bool kern)
{
	DEFINE_WAIT_FUNC(wait, woken_wake_function);
	struct sock *sk = sock->sk, *ch;
	long timeo;
	int err = 0;

	lock_sock(sk);

	timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);

	BT_DBG("sk %p timeo %ld", sk, timeo);

	/* Wait for an incoming connection. (wake-one). */
	add_wait_queue_exclusive(sk_sleep(sk), &wait);
	while (1) {
		if (sk->sk_state != BT_LISTEN) {
			err = -EBADFD;
			break;
		}

		ch = bt_accept_dequeue(sk, newsock);
		if (ch)
			break;

		if (!timeo) {
			err = -EAGAIN;
			break;
		}

		if (signal_pending(current)) {
			err = sock_intr_errno(timeo);
			break;
		}

		release_sock(sk);

		timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
		lock_sock(sk);
	}
	remove_wait_queue(sk_sleep(sk), &wait);

	if (err)
		goto done;

	newsock->state = SS_CONNECTED;

	BT_DBG("new socket %p", ch);

done:
	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
160
74.42%
1
14.29%
Peter Hurley
43
20.00%
2
28.57%
Eric Dumazet
6
2.79%
1
14.29%
David Howells
3
1.40%
1
14.29%
Arnaldo Carvalho de Melo
2
0.93%
1
14.29%
Marcel Holtmann
1
0.47%
1
14.29%
Total
215
100.00%
7
100.00%



static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
			    int *len, int peer)
{
	struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
	struct sock *sk = sock->sk;

	BT_DBG("sock %p, sk %p", sock, sk);

	addr->sa_family = AF_BLUETOOTH;
	*len = sizeof(struct sockaddr_sco);

	if (peer)
		bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
	else
		bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
106
98.15%
1
50.00%
Marcel Holtmann
2
1.85%
1
50.00%
Total
108
100.00%
2
100.00%



static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
			    size_t len)
{
	struct sock *sk = sock->sk;
	int