[deliverable/linux.git] / net / bluetooth / af_bluetooth.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 address family and sockets. */

#include <linux/module.h>
#include <asm/ioctls.h>

#include <net/bluetooth/bluetooth.h>
#include <linux/proc_fs.h>

#define VERSION "2.17"

/* Bluetooth sockets */
#define BT_MAX_PROTO	8
static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
static DEFINE_RWLOCK(bt_proto_lock);

static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
static const char *const bt_key_strings[BT_MAX_PROTO] = {
	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
};

static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
	"slock-AF_BLUETOOTH-BTPROTO_L2CAP",
	"slock-AF_BLUETOOTH-BTPROTO_HCI",
	"slock-AF_BLUETOOTH-BTPROTO_SCO",
	"slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	"slock-AF_BLUETOOTH-BTPROTO_BNEP",
	"slock-AF_BLUETOOTH-BTPROTO_CMTP",
	"slock-AF_BLUETOOTH-BTPROTO_HIDP",
	"slock-AF_BLUETOOTH-BTPROTO_AVDTP",
};

void bt_sock_reclassify_lock(struct sock *sk, int proto)
{
	BUG_ON(!sk);
	BUG_ON(sock_owned_by_user(sk));

	sock_lock_init_class_and_name(sk,
			bt_slock_key_strings[proto], &bt_slock_key[proto],
				bt_key_strings[proto], &bt_lock_key[proto]);
}
EXPORT_SYMBOL(bt_sock_reclassify_lock);

int bt_sock_register(int proto, const struct net_proto_family *ops)
{
	int err = 0;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	write_lock(&bt_proto_lock);

	if (bt_proto[proto])
		err = -EEXIST;
	else
		bt_proto[proto] = ops;

	write_unlock(&bt_proto_lock);

	return err;
}
EXPORT_SYMBOL(bt_sock_register);

void bt_sock_unregister(int proto)
{
	if (proto < 0 || proto >= BT_MAX_PROTO)
		return;

	write_lock(&bt_proto_lock);
	bt_proto[proto] = NULL;
	write_unlock(&bt_proto_lock);
}
EXPORT_SYMBOL(bt_sock_unregister);

static int bt_sock_create(struct net *net, struct socket *sock, int proto,
			  int kern)
{
	int err;

	if (net != &init_net)
		return -EAFNOSUPPORT;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	if (!bt_proto[proto])
		request_module("bt-proto-%d", proto);

	err = -EPROTONOSUPPORT;

	read_lock(&bt_proto_lock);

	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
		err = bt_proto[proto]->create(net, sock, proto, kern);
		if (!err)
			bt_sock_reclassify_lock(sock->sk, proto);
		module_put(bt_proto[proto]->owner);
	}

	read_unlock(&bt_proto_lock);

	return err;
}

void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
{
	write_lock(&l->lock);
	sk_add_node(sk, &l->head);
	write_unlock(&l->lock);
}
EXPORT_SYMBOL(bt_sock_link);

void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
{
	write_lock(&l->lock);
	sk_del_node_init(sk);
	write_unlock(&l->lock);
}
EXPORT_SYMBOL(bt_sock_unlink);

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

	sock_hold(sk);
	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	bt_sk(sk)->parent = parent;
	parent->sk_ack_backlog++;
}
EXPORT_SYMBOL(bt_accept_enqueue);

void bt_accept_unlink(struct sock *sk)
{
	BT_DBG("sk %p state %d", sk, sk->sk_state);

	list_del_init(&bt_sk(sk)->accept_q);
	bt_sk(sk)->parent->sk_ack_backlog--;
	bt_sk(sk)->parent = NULL;
	sock_put(sk);
}
EXPORT_SYMBOL(bt_accept_unlink);

struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
{
	struct list_head *p, *n;
	struct sock *sk;

	BT_DBG("parent %p", parent);

	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);

		lock_sock(sk);

		/* FIXME: Is this check still needed */
		if (sk->sk_state == BT_CLOSED) {
			release_sock(sk);
			bt_accept_unlink(sk);
			continue;
		}

		if (sk->sk_state == BT_CONNECTED || !newsock ||
		    test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
			bt_accept_unlink(sk);
			if (newsock)
				sock_graft(sk, newsock);

			release_sock(sk);
			return sk;
		}

		release_sock(sk);
	}

	return NULL;
}
EXPORT_SYMBOL(bt_accept_dequeue);

int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
				struct msghdr *msg, size_t len, int flags)
{
	int noblock = flags & MSG_DONTWAIT;
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	size_t copied;
	int err;

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

	if (flags & (MSG_OOB))
		return -EOPNOTSUPP;

	skb = skb_recv_datagram(sk, flags, noblock, &err);
	if (!skb) {
		if (sk->sk_shutdown & RCV_SHUTDOWN) {
			msg->msg_namelen = 0;
			return 0;
		}
		return err;
	}

	copied = skb->len;
	if (len < copied) {
		msg->msg_flags |= MSG_TRUNC;
		copied = len;
	}

	skb_reset_transport_header(skb);
	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	if (err == 0) {
		sock_recv_ts_and_drops(msg, sk, skb);

		if (bt_sk(sk)->skb_msg_name)
			bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
						&msg->msg_namelen);
		else
			msg->msg_namelen = 0;
	}

	skb_free_datagram(sk, skb);

	return err ? : copied;
}
EXPORT_SYMBOL(bt_sock_recvmsg);

static long bt_sock_data_wait(struct sock *sk, long timeo)
{
	DECLARE_WAITQUEUE(wait, current);

	add_wait_queue(sk_sleep(sk), &wait);
	for (;;) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (!skb_queue_empty(&sk->sk_receive_queue))
			break;

		if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
			break;

		if (signal_pending(current) || !timeo)
			break;

		set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);
		clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	}

	__set_current_state(TASK_RUNNING);
	remove_wait_queue(sk_sleep(sk), &wait);
	return timeo;
}

int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
			       struct msghdr *msg, size_t size, int flags)
{
	struct sock *sk = sock->sk;
	int err = 0;
	size_t target, copied = 0;
	long timeo;

	if (flags & MSG_OOB)
		return -EOPNOTSUPP;

	msg->msg_namelen = 0;

	BT_DBG("sk %p size %zu", sk, size);

	lock_sock(sk);

	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
	timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);

	do {
		struct sk_buff *skb;
		int chunk;

		skb = skb_dequeue(&sk->sk_receive_queue);
		if (!skb) {
			if (copied >= target)
				break;

			err = sock_error(sk);
			if (err)
				break;
			if (sk->sk_shutdown & RCV_SHUTDOWN)
				break;

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

			timeo = bt_sock_data_wait(sk, timeo);

			if (signal_pending(current)) {
				err = sock_intr_errno(timeo);
				goto out;
			}
			continue;
		}

		chunk = min_t(unsigned int, skb->len, size);
		if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
			skb_queue_head(&sk->sk_receive_queue, skb);
			if (!copied)
				copied = -EFAULT;
			break;
		}
		copied += chunk;
		size   -= chunk;

		sock_recv_ts_and_drops(msg, sk, skb);

		if (!(flags & MSG_PEEK)) {
			int skb_len = skb_headlen(skb);

			if (chunk <= skb_len) {
				__skb_pull(skb, chunk);
			} else {
				struct sk_buff *frag;

				__skb_pull(skb, skb_len);
				chunk -= skb_len;

				skb_walk_frags(skb, frag) {
					if (chunk <= frag->len) {
						/* Pulling partial data */
						skb->len -= chunk;
						skb->data_len -= chunk;
						__skb_pull(frag, chunk);
						break;
					} else if (frag->len) {
						/* Pulling all frag data */
						chunk -= frag->len;
						skb->len -= frag->len;
						skb->data_len -= frag->len;
						__skb_pull(frag, frag->len);
					}
				}
			}

			if (skb->len) {
				skb_queue_head(&sk->sk_receive_queue, skb);
				break;
			}
			kfree_skb(skb);

		} else {
			/* put message back and return */
			skb_queue_head(&sk->sk_receive_queue, skb);
			break;
		}
	} while (size);

out:
	release_sock(sk);
	return copied ? : err;
}
EXPORT_SYMBOL(bt_sock_stream_recvmsg);

static inline unsigned int bt_accept_poll(struct sock *parent)
{
	struct list_head *p, *n;
	struct sock *sk;

	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
		if (sk->sk_state == BT_CONNECTED ||
		    (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
		     sk->sk_state == BT_CONNECT2))
			return POLLIN | POLLRDNORM;
	}

	return 0;
}

unsigned int bt_sock_poll(struct file *file, struct socket *sock,
			  poll_table *wait)
{
	struct sock *sk = sock->sk;
	unsigned int mask = 0;

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

	poll_wait(file, sk_sleep(sk), wait);

	if (sk->sk_state == BT_LISTEN)
		return bt_accept_poll(sk);

	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
		mask |= POLLERR |
			(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);

	if (sk->sk_shutdown & RCV_SHUTDOWN)
		mask |= POLLRDHUP | POLLIN | POLLRDNORM;

	if (sk->sk_shutdown == SHUTDOWN_MASK)
		mask |= POLLHUP;

	if (!skb_queue_empty(&sk->sk_receive_queue))
		mask |= POLLIN | POLLRDNORM;

	if (sk->sk_state == BT_CLOSED)
		mask |= POLLHUP;

	if (sk->sk_state == BT_CONNECT ||
			sk->sk_state == BT_CONNECT2 ||
			sk->sk_state == BT_CONFIG)
		return mask;

	if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
		mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
	else
		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

	return mask;
}
EXPORT_SYMBOL(bt_sock_poll);

int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	long amount;
	int err;

	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);

	switch (cmd) {
	case TIOCOUTQ:
		if (sk->sk_state == BT_LISTEN)
			return -EINVAL;

		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
		if (amount < 0)
			amount = 0;
		err = put_user(amount, (int __user *) arg);
		break;

	case TIOCINQ:
		if (sk->sk_state == BT_LISTEN)
			return -EINVAL;

		lock_sock(sk);
		skb = skb_peek(&sk->sk_receive_queue);
		amount = skb ? skb->len : 0;
		release_sock(sk);
		err = put_user(amount, (int __user *) arg);
		break;

	case SIOCGSTAMP:
		err = sock_get_timestamp(sk, (struct timeval __user *) arg);
		break;

	case SIOCGSTAMPNS:
		err = sock_get_timestampns(sk, (struct timespec __user *) arg);
		break;

	default:
		err = -ENOIOCTLCMD;
		break;
	}

	return err;
}
EXPORT_SYMBOL(bt_sock_ioctl);

/* This function expects the sk lock to be held when called */
int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
{
	DECLARE_WAITQUEUE(wait, current);
	int err = 0;

	BT_DBG("sk %p", sk);

	add_wait_queue(sk_sleep(sk), &wait);
	set_current_state(TASK_INTERRUPTIBLE);
	while (sk->sk_state != state) {
		if (!timeo) {
			err = -EINPROGRESS;
			break;
		}

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

		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);
		set_current_state(TASK_INTERRUPTIBLE);

		err = sock_error(sk);
		if (err)
			break;
	}
	__set_current_state(TASK_RUNNING);
	remove_wait_queue(sk_sleep(sk), &wait);
	return err;
}
EXPORT_SYMBOL(bt_sock_wait_state);

/* This function expects the sk lock to be held when called */
int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
{
	DECLARE_WAITQUEUE(wait, current);
	unsigned long timeo;
	int err = 0;

	BT_DBG("sk %p", sk);

	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);

	add_wait_queue(sk_sleep(sk), &wait);
	set_current_state(TASK_INTERRUPTIBLE);
	while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
		if (!timeo) {
			err = -EAGAIN;
			break;
		}

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

		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);
		set_current_state(TASK_INTERRUPTIBLE);

		err = sock_error(sk);
		if (err)
			break;
	}
	__set_current_state(TASK_RUNNING);
	remove_wait_queue(sk_sleep(sk), &wait);

	return err;
}
EXPORT_SYMBOL(bt_sock_wait_ready);

#ifdef CONFIG_PROC_FS
struct bt_seq_state {
	struct bt_sock_list *l;
};

static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
	__acquires(seq->private->l->lock)
{
	struct bt_seq_state *s = seq->private;
	struct bt_sock_list *l = s->l;

	read_lock(&l->lock);
	return seq_hlist_start_head(&l->head, *pos);
}

static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct bt_seq_state *s = seq->private;
	struct bt_sock_list *l = s->l;

	return seq_hlist_next(v, &l->head, pos);
}

static void bt_seq_stop(struct seq_file *seq, void *v)
	__releases(seq->private->l->lock)
{
	struct bt_seq_state *s = seq->private;
	struct bt_sock_list *l = s->l;

	read_unlock(&l->lock);
}

static int bt_seq_show(struct seq_file *seq, void *v)
{
	struct bt_seq_state *s = seq->private;
	struct bt_sock_list *l = s->l;

	if (v == SEQ_START_TOKEN) {
		seq_puts(seq ,"sk               RefCnt Rmem   Wmem   User   Inode  Parent");

		if (l->custom_seq_show) {
			seq_putc(seq, ' ');
			l->custom_seq_show(seq, v);
		}

		seq_putc(seq, '\n');
	} else {
		struct sock *sk = sk_entry(v);
		struct bt_sock *bt = bt_sk(sk);

		seq_printf(seq,
			   "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
			   sk,
			   atomic_read(&sk->sk_refcnt),
			   sk_rmem_alloc_get(sk),
			   sk_wmem_alloc_get(sk),
			   from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
			   sock_i_ino(sk),
			   bt->parent? sock_i_ino(bt->parent): 0LU);

		if (l->custom_seq_show) {
			seq_putc(seq, ' ');
			l->custom_seq_show(seq, v);
		}

		seq_putc(seq, '\n');
	}
	return 0;
}

static struct seq_operations bt_seq_ops = {
	.start = bt_seq_start,
	.next  = bt_seq_next,
	.stop  = bt_seq_stop,
	.show  = bt_seq_show,
};

static int bt_seq_open(struct inode *inode, struct file *file)
{
	struct bt_sock_list *sk_list;
	struct bt_seq_state *s;

	sk_list = PDE_DATA(inode);
	s = __seq_open_private(file, &bt_seq_ops,
			       sizeof(struct bt_seq_state));
	if (!s)
		return -ENOMEM;

	s->l = sk_list;
	return 0;
}

static const struct file_operations bt_fops = {
	.open = bt_seq_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release_private
};

int bt_procfs_init(struct net *net, const char *name,
		   struct bt_sock_list* sk_list,
		   int (* seq_show)(struct seq_file *, void *))
{
	sk_list->custom_seq_show = seq_show;

	if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
		return -ENOMEM;
	return 0;
}

void bt_procfs_cleanup(struct net *net, const char *name)
{
	remove_proc_entry(name, net->proc_net);
}
#else
int bt_procfs_init(struct net *net, const char *name,
		   struct bt_sock_list* sk_list,
		   int (* seq_show)(struct seq_file *, void *))
{
	return 0;
}

void bt_procfs_cleanup(struct net *net, const char *name)
{
}
#endif
EXPORT_SYMBOL(bt_procfs_init);
EXPORT_SYMBOL(bt_procfs_cleanup);

static struct net_proto_family bt_sock_family_ops = {
	.owner	= THIS_MODULE,
	.family	= PF_BLUETOOTH,
	.create	= bt_sock_create,
};

static int __init bt_init(void)
{
	int err;

	BT_INFO("Core ver %s", VERSION);

	err = bt_sysfs_init();
	if (err < 0)
		return err;

	err = sock_register(&bt_sock_family_ops);
	if (err < 0) {
		bt_sysfs_cleanup();
		return err;
	}

	BT_INFO("HCI device and connection manager initialized");

	err = hci_sock_init();
	if (err < 0)
		goto error;

	err = l2cap_init();
	if (err < 0)
		goto sock_err;

	err = sco_init();
	if (err < 0) {
		l2cap_exit();
		goto sock_err;
	}

	return 0;

sock_err:
	hci_sock_cleanup();

error:
	sock_unregister(PF_BLUETOOTH);
	bt_sysfs_cleanup();

	return err;
}

static void __exit bt_exit(void)
{

	sco_exit();

	l2cap_exit();

	hci_sock_cleanup();

	sock_unregister(PF_BLUETOOTH);

	bt_sysfs_cleanup();
}

subsys_initcall(bt_init);
module_exit(bt_exit);

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	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
8e87d142 YH	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
1da177e4 LT	18	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	19
8e87d142 YH	20	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	21	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	22	SOFTWARE IS DISCLAIMED.
	23	*/
	24
	25	/* Bluetooth address family and sockets. */
	26
1da177e4	27	#include <linux/module.h>
3241ad82	28	#include <asm/ioctls.h>
1da177e4 LT	29
1da177e4 LT	30	#include <net/bluetooth/bluetooth.h>
256a06c8	31	#include <linux/proc_fs.h>
1da177e4	32
dcbc729e	33	#define VERSION "2.17"
1da177e4 LT	34
	35	/* Bluetooth sockets */
	36	#define BT_MAX_PROTO 8
ec1b4cf7	37	static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
db7aa1c2	38	static DEFINE_RWLOCK(bt_proto_lock);
68845cb2	39
68845cb2	40	static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
36cbd3dc	41	static const char *const bt_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	42	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
	43	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
	44	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
	45	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	46	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
	47	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
	48	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
	49	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
	50	};
	51
db7aa1c2	52	static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
36cbd3dc	53	static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	54	"slock-AF_BLUETOOTH-BTPROTO_L2CAP",
	55	"slock-AF_BLUETOOTH-BTPROTO_HCI",
	56	"slock-AF_BLUETOOTH-BTPROTO_SCO",
	57	"slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	58	"slock-AF_BLUETOOTH-BTPROTO_BNEP",
	59	"slock-AF_BLUETOOTH-BTPROTO_CMTP",
	60	"slock-AF_BLUETOOTH-BTPROTO_HIDP",
	61	"slock-AF_BLUETOOTH-BTPROTO_AVDTP",
	62	};
db7aa1c2	63
b5a30dda	64	void bt_sock_reclassify_lock(struct sock *sk, int proto)
db7aa1c2	65	{
b5a30dda	66	BUG_ON(!sk);
db7aa1c2 MH	67	BUG_ON(sock_owned_by_user(sk));
	68
	69	sock_lock_init_class_and_name(sk,
	70	bt_slock_key_strings[proto], &bt_slock_key[proto],
	71	bt_key_strings[proto], &bt_lock_key[proto]);
	72	}
b5a30dda	73	EXPORT_SYMBOL(bt_sock_reclassify_lock);
1da177e4	74
ec1b4cf7	75	int bt_sock_register(int proto, const struct net_proto_family *ops)
1da177e4	76	{
74da626a MH	77	int err = 0;
74da626a MH	78
1da177e4 LT	79	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	80	return -EINVAL;
	81
74da626a MH	82	write_lock(&bt_proto_lock);
74da626a MH	83
1da177e4	84	if (bt_proto[proto])
74da626a MH	85	err = -EEXIST;
	86	else
	87	bt_proto[proto] = ops;
	88
	89	write_unlock(&bt_proto_lock);
1da177e4	90
74da626a	91	return err;
1da177e4 LT	92	}
	93	EXPORT_SYMBOL(bt_sock_register);
	94
be9f97f0	95	void bt_sock_unregister(int proto)
1da177e4 LT	96	{
1da177e4 LT	97	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
be9f97f0	98	return;
1da177e4	99
74da626a	100	write_lock(&bt_proto_lock);
be9f97f0	101	bt_proto[proto] = NULL;
74da626a	102	write_unlock(&bt_proto_lock);
1da177e4 LT	103	}
	104	EXPORT_SYMBOL(bt_sock_unregister);
	105
3f378b68 EP	106	static int bt_sock_create(struct net net, struct socket sock, int proto,
3f378b68 EP	107	int kern)
1da177e4	108	{
74da626a	109	int err;
1da177e4	110
1b8d7ae4 EB	111	if (net != &init_net)
	112	return -EAFNOSUPPORT;
	113
1da177e4 LT	114	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	115	return -EINVAL;
	116
95a5afca	117	if (!bt_proto[proto])
1da177e4	118	request_module("bt-proto-%d", proto);
74da626a	119
1da177e4	120	err = -EPROTONOSUPPORT;
74da626a MH	121
	122	read_lock(&bt_proto_lock);
	123
1da177e4	124	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
3f378b68	125	err = bt_proto[proto]->create(net, sock, proto, kern);
b5a30dda OP	126	if (!err)
b5a30dda OP	127	bt_sock_reclassify_lock(sock->sk, proto);
1da177e4 LT	128	module_put(bt_proto[proto]->owner);
1da177e4 LT	129	}
74da626a MH	130
	131	read_unlock(&bt_proto_lock);
	132
8e87d142	133	return err;
1da177e4 LT	134	}
	135
	136	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	137	{
94f5bfb8	138	write_lock(&l->lock);
1da177e4	139	sk_add_node(sk, &l->head);
94f5bfb8	140	write_unlock(&l->lock);
1da177e4 LT	141	}
	142	EXPORT_SYMBOL(bt_sock_link);
	143
	144	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	145	{
94f5bfb8	146	write_lock(&l->lock);
1da177e4	147	sk_del_node_init(sk);
94f5bfb8	148	write_unlock(&l->lock);
1da177e4 LT	149	}
	150	EXPORT_SYMBOL(bt_sock_unlink);
	151
	152	void bt_accept_enqueue(struct sock parent, struct sock sk)
	153	{
	154	BT_DBG("parent %p, sk %p", parent, sk);
	155
	156	sock_hold(sk);
	157	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	158	bt_sk(sk)->parent = parent;
	159	parent->sk_ack_backlog++;
	160	}
	161	EXPORT_SYMBOL(bt_accept_enqueue);
	162
	163	void bt_accept_unlink(struct sock *sk)
	164	{
	165	BT_DBG("sk %p state %d", sk, sk->sk_state);
	166
	167	list_del_init(&bt_sk(sk)->accept_q);
	168	bt_sk(sk)->parent->sk_ack_backlog--;
	169	bt_sk(sk)->parent = NULL;
	170	sock_put(sk);
	171	}
	172	EXPORT_SYMBOL(bt_accept_unlink);
	173
	174	struct sock bt_accept_dequeue(struct sock parent, struct socket *newsock)
	175	{
	176	struct list_head p, n;
	177	struct sock *sk;
	178
	179	BT_DBG("parent %p", parent);
	180
	181	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	182	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	183
8a154a8f	184	lock_sock(sk);
1da177e4 LT	185
	186	/* FIXME: Is this check still needed */
	187	if (sk->sk_state == BT_CLOSED) {
8a154a8f	188	release_sock(sk);
1da177e4 LT	189	bt_accept_unlink(sk);
	190	continue;
	191	}
	192
c4f912e1	193	if (sk->sk_state == BT_CONNECTED \|\| !newsock \|\|
d060991f	194	test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
1da177e4 LT	195	bt_accept_unlink(sk);
	196	if (newsock)
	197	sock_graft(sk, newsock);
d37f50e1	198
8a154a8f	199	release_sock(sk);
1da177e4 LT	200	return sk;
	201	}
	202
8a154a8f	203	release_sock(sk);
1da177e4	204	}
d37f50e1	205
1da177e4 LT	206	return NULL;
	207	}
	208	EXPORT_SYMBOL(bt_accept_dequeue);
	209
	210	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
c4f912e1	211	struct msghdr *msg, size_t len, int flags)
1da177e4 LT	212	{
	213	int noblock = flags & MSG_DONTWAIT;
	214	struct sock *sk = sock->sk;
	215	struct sk_buff *skb;
	216	size_t copied;
	217	int err;
	218
a418b893	219	BT_DBG("sock %p sk %p len %zu", sock, sk, len);
1da177e4 LT	220
	221	if (flags & (MSG_OOB))
	222	return -EOPNOTSUPP;
	223
5a08ecce AE	224	skb = skb_recv_datagram(sk, flags, noblock, &err);
5a08ecce AE	225	if (!skb) {
d9763698 MH	226	if (sk->sk_shutdown & RCV_SHUTDOWN) {
d9763698 MH	227	msg->msg_namelen = 0;
1da177e4	228	return 0;
d9763698	229	}
1da177e4 LT	230	return err;
	231	}
	232
1da177e4 LT	233	copied = skb->len;
	234	if (len < copied) {
	235	msg->msg_flags \|= MSG_TRUNC;
	236	copied = len;
	237	}
	238
badff6d0	239	skb_reset_transport_header(skb);
1da177e4	240	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
d9763698	241	if (err == 0) {
3b885787	242	sock_recv_ts_and_drops(msg, sk, skb);
1da177e4	243
d9763698 MH	244	if (bt_sk(sk)->skb_msg_name)
	245	bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
	246	&msg->msg_namelen);
	247	else
	248	msg->msg_namelen = 0;
	249	}
	250
1da177e4 LT	251	skb_free_datagram(sk, skb);
	252
	253	return err ? : copied;
	254	}
	255	EXPORT_SYMBOL(bt_sock_recvmsg);
	256
796c86ee MM	257	static long bt_sock_data_wait(struct sock *sk, long timeo)
	258	{
	259	DECLARE_WAITQUEUE(wait, current);
	260
	261	add_wait_queue(sk_sleep(sk), &wait);
	262	for (;;) {
	263	set_current_state(TASK_INTERRUPTIBLE);
	264
	265	if (!skb_queue_empty(&sk->sk_receive_queue))
	266	break;
	267
	268	if (sk->sk_err \|\| (sk->sk_shutdown & RCV_SHUTDOWN))
	269	break;
	270
	271	if (signal_pending(current) \|\| !timeo)
	272	break;
	273
	274	set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	275	release_sock(sk);
	276	timeo = schedule_timeout(timeo);
	277	lock_sock(sk);
	278	clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	279	}
	280
	281	__set_current_state(TASK_RUNNING);
	282	remove_wait_queue(sk_sleep(sk), &wait);
	283	return timeo;
	284	}
	285
	286	int bt_sock_stream_recvmsg(struct kiocb iocb, struct socket sock,
	287	struct msghdr *msg, size_t size, int flags)
	288	{
	289	struct sock *sk = sock->sk;
	290	int err = 0;
	291	size_t target, copied = 0;
	292	long timeo;
	293
	294	if (flags & MSG_OOB)
	295	return -EOPNOTSUPP;
	296
	297	msg->msg_namelen = 0;
	298
	299	BT_DBG("sk %p size %zu", sk, size);
	300
	301	lock_sock(sk);
	302
	303	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
	304	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
	305
	306	do {
	307	struct sk_buff *skb;
	308	int chunk;
	309
	310	skb = skb_dequeue(&sk->sk_receive_queue);
	311	if (!skb) {
	312	if (copied >= target)
	313	break;
	314
5a08ecce AE	315	err = sock_error(sk);
5a08ecce AE	316	if (err)
796c86ee MM	317	break;
	318	if (sk->sk_shutdown & RCV_SHUTDOWN)
	319	break;
	320
	321	err = -EAGAIN;
	322	if (!timeo)
	323	break;
	324
	325	timeo = bt_sock_data_wait(sk, timeo);
	326
	327	if (signal_pending(current)) {
	328	err = sock_intr_errno(timeo);
	329	goto out;
	330	}
	331	continue;
	332	}
	333
	334	chunk = min_t(unsigned int, skb->len, size);
5b668eb3	335	if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
796c86ee MM	336	skb_queue_head(&sk->sk_receive_queue, skb);
	337	if (!copied)
	338	copied = -EFAULT;
	339	break;
	340	}
	341	copied += chunk;
	342	size -= chunk;
	343
	344	sock_recv_ts_and_drops(msg, sk, skb);
	345
	346	if (!(flags & MSG_PEEK)) {
5b668eb3 MM	347	int skb_len = skb_headlen(skb);
	348
	349	if (chunk <= skb_len) {
	350	__skb_pull(skb, chunk);
	351	} else {
	352	struct sk_buff *frag;
	353
	354	__skb_pull(skb, skb_len);
	355	chunk -= skb_len;
	356
	357	skb_walk_frags(skb, frag) {
	358	if (chunk <= frag->len) {
	359	/* Pulling partial data */
	360	skb->len -= chunk;
	361	skb->data_len -= chunk;
	362	__skb_pull(frag, chunk);
	363	break;
	364	} else if (frag->len) {
	365	/* Pulling all frag data */
	366	chunk -= frag->len;
	367	skb->len -= frag->len;
	368	skb->data_len -= frag->len;
	369	__skb_pull(frag, frag->len);
	370	}
	371	}
	372	}
	373
796c86ee MM	374	if (skb->len) {
	375	skb_queue_head(&sk->sk_receive_queue, skb);
	376	break;
	377	}
	378	kfree_skb(skb);
	379
	380	} else {
	381	/* put message back and return */
	382	skb_queue_head(&sk->sk_receive_queue, skb);
	383	break;
	384	}
	385	} while (size);
	386
	387	out:
	388	release_sock(sk);
	389	return copied ? : err;
	390	}
	391	EXPORT_SYMBOL(bt_sock_stream_recvmsg);
	392
1da177e4 LT	393	static inline unsigned int bt_accept_poll(struct sock *parent)
	394	{
	395	struct list_head p, n;
	396	struct sock *sk;
	397
	398	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	399	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be	400	if (sk->sk_state == BT_CONNECTED \|\|
c5daa683 GP	401	(test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
c5daa683 GP	402	sk->sk_state == BT_CONNECT2))
1da177e4 LT	403	return POLLIN \| POLLRDNORM;
	404	}
	405
	406	return 0;
	407	}
	408
8fc9ced3 GP	409	unsigned int bt_sock_poll(struct file file, struct socket sock,
8fc9ced3 GP	410	poll_table *wait)
1da177e4 LT	411	{
	412	struct sock *sk = sock->sk;
	413	unsigned int mask = 0;
	414
	415	BT_DBG("sock %p, sk %p", sock, sk);
	416
aa395145	417	poll_wait(file, sk_sleep(sk), wait);
1da177e4 LT	418
	419	if (sk->sk_state == BT_LISTEN)
	420	return bt_accept_poll(sk);
	421
	422	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
7d4c04fc	423	mask \|= POLLERR \|
8facd5fb	424	(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
1da177e4	425
f348d70a	426	if (sk->sk_shutdown & RCV_SHUTDOWN)
db40980f	427	mask \|= POLLRDHUP \| POLLIN \| POLLRDNORM;
f348d70a	428
1da177e4 LT	429	if (sk->sk_shutdown == SHUTDOWN_MASK)
	430	mask \|= POLLHUP;
	431
db40980f	432	if (!skb_queue_empty(&sk->sk_receive_queue))
1da177e4 LT	433	mask \|= POLLIN \| POLLRDNORM;
	434
	435	if (sk->sk_state == BT_CLOSED)
	436	mask \|= POLLHUP;
	437
	438	if (sk->sk_state == BT_CONNECT \|\|
	439	sk->sk_state == BT_CONNECT2 \|\|
	440	sk->sk_state == BT_CONFIG)
	441	return mask;
	442
c5daa683	443	if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
1da177e4 LT	444	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	445	else
	446	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	447
	448	return mask;
	449	}
	450	EXPORT_SYMBOL(bt_sock_poll);
	451
3241ad82 MH	452	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	453	{
	454	struct sock *sk = sock->sk;
43cbeee9 MH	455	struct sk_buff *skb;
43cbeee9 MH	456	long amount;
3241ad82 MH	457	int err;
	458
	459	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	460
	461	switch (cmd) {
43cbeee9 MH	462	case TIOCOUTQ:
	463	if (sk->sk_state == BT_LISTEN)
	464	return -EINVAL;
	465
31e6d363	466	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	467	if (amount < 0)
	468	amount = 0;
	469	err = put_user(amount, (int __user *) arg);
	470	break;
	471
	472	case TIOCINQ:
	473	if (sk->sk_state == BT_LISTEN)
	474	return -EINVAL;
	475
	476	lock_sock(sk);
	477	skb = skb_peek(&sk->sk_receive_queue);
	478	amount = skb ? skb->len : 0;
	479	release_sock(sk);
	480	err = put_user(amount, (int __user *) arg);
	481	break;
	482
3241ad82 MH	483	case SIOCGSTAMP:
	484	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	485	break;
	486
	487	case SIOCGSTAMPNS:
	488	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	489	break;
	490
	491	default:
	492	err = -ENOIOCTLCMD;
	493	break;
	494	}
	495
	496	return err;
	497	}
	498	EXPORT_SYMBOL(bt_sock_ioctl);
	499
0fba96f9	500	/* This function expects the sk lock to be held when called */
1da177e4 LT	501	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	502	{
	503	DECLARE_WAITQUEUE(wait, current);
	504	int err = 0;
	505
	506	BT_DBG("sk %p", sk);
	507
aa395145	508	add_wait_queue(sk_sleep(sk), &wait);
9be4e3fb	509	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	510	while (sk->sk_state != state) {
1da177e4	511	if (!timeo) {
b4c612a4	512	err = -EINPROGRESS;
1da177e4 LT	513	break;
	514	}
	515
	516	if (signal_pending(current)) {
	517	err = sock_intr_errno(timeo);
	518	break;
	519	}
	520
	521	release_sock(sk);
	522	timeo = schedule_timeout(timeo);
	523	lock_sock(sk);
9be4e3fb	524	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	525
c1cbe4b7 BL	526	err = sock_error(sk);
c1cbe4b7 BL	527	if (err)
1da177e4	528	break;
1da177e4	529	}
9be4e3fb	530	__set_current_state(TASK_RUNNING);
aa395145	531	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	532	return err;
	533	}
	534	EXPORT_SYMBOL(bt_sock_wait_state);
	535
e793dcf0 JH	536	/* This function expects the sk lock to be held when called */
	537	int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
	538	{
	539	DECLARE_WAITQUEUE(wait, current);
	540	unsigned long timeo;
	541	int err = 0;
	542
	543	BT_DBG("sk %p", sk);
	544
	545	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
	546
	547	add_wait_queue(sk_sleep(sk), &wait);
	548	set_current_state(TASK_INTERRUPTIBLE);
	549	while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
	550	if (!timeo) {
	551	err = -EAGAIN;
	552	break;
	553	}
	554
	555	if (signal_pending(current)) {
	556	err = sock_intr_errno(timeo);
	557	break;
	558	}
	559
	560	release_sock(sk);
	561	timeo = schedule_timeout(timeo);
	562	lock_sock(sk);
	563	set_current_state(TASK_INTERRUPTIBLE);
	564
	565	err = sock_error(sk);
	566	if (err)
	567	break;
	568	}
	569	__set_current_state(TASK_RUNNING);
	570	remove_wait_queue(sk_sleep(sk), &wait);
	571
	572	return err;
	573	}
	574	EXPORT_SYMBOL(bt_sock_wait_ready);
	575
256a06c8 MY	576	#ifdef CONFIG_PROC_FS
	577	struct bt_seq_state {
	578	struct bt_sock_list *l;
	579	};
	580
	581	static void bt_seq_start(struct seq_file seq, loff_t *pos)
	582	__acquires(seq->private->l->lock)
	583	{
	584	struct bt_seq_state *s = seq->private;
	585	struct bt_sock_list *l = s->l;
	586
	587	read_lock(&l->lock);
	588	return seq_hlist_start_head(&l->head, *pos);
	589	}
	590
	591	static void bt_seq_next(struct seq_file seq, void v, loff_t pos)
	592	{
	593	struct bt_seq_state *s = seq->private;
	594	struct bt_sock_list *l = s->l;
	595
	596	return seq_hlist_next(v, &l->head, pos);
	597	}
	598
	599	static void bt_seq_stop(struct seq_file seq, void v)
	600	__releases(seq->private->l->lock)
	601	{
	602	struct bt_seq_state *s = seq->private;
	603	struct bt_sock_list *l = s->l;
	604
	605	read_unlock(&l->lock);
	606	}
	607
	608	static int bt_seq_show(struct seq_file seq, void v)
	609	{
256a06c8 MY	610	struct bt_seq_state *s = seq->private;
256a06c8 MY	611	struct bt_sock_list *l = s->l;
256a06c8 MY	612
256a06c8 MY	613	if (v == SEQ_START_TOKEN) {
c5605755	614	seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
256a06c8 MY	615
	616	if (l->custom_seq_show) {
	617	seq_putc(seq, ' ');
	618	l->custom_seq_show(seq, v);
	619	}
	620
	621	seq_putc(seq, '\n');
	622	} else {
09d5d4aa AE	623	struct sock *sk = sk_entry(v);
09d5d4aa AE	624	struct bt_sock *bt = bt_sk(sk);
256a06c8	625
7028a886	626	seq_printf(seq,
5f6cd79f	627	"%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
256a06c8 MY	628	sk,
	629	atomic_read(&sk->sk_refcnt),
	630	sk_rmem_alloc_get(sk),
	631	sk_wmem_alloc_get(sk),
1bbb3095	632	from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
256a06c8	633	sock_i_ino(sk),
256a06c8 MY	634	bt->parent? sock_i_ino(bt->parent): 0LU);
	635
	636	if (l->custom_seq_show) {
	637	seq_putc(seq, ' ');
	638	l->custom_seq_show(seq, v);
	639	}
	640
	641	seq_putc(seq, '\n');
	642	}
	643	return 0;
	644	}
	645
	646	static struct seq_operations bt_seq_ops = {
	647	.start = bt_seq_start,
	648	.next = bt_seq_next,
	649	.stop = bt_seq_stop,
	650	.show = bt_seq_show,
	651	};
	652
	653	static int bt_seq_open(struct inode inode, struct file file)
	654	{
	655	struct bt_sock_list *sk_list;
	656	struct bt_seq_state *s;
	657
d9dda78b	658	sk_list = PDE_DATA(inode);
256a06c8 MY	659	s = __seq_open_private(file, &bt_seq_ops,
256a06c8 MY	660	sizeof(struct bt_seq_state));
31f47073	661	if (!s)
256a06c8 MY	662	return -ENOMEM;
	663
	664	s->l = sk_list;
	665	return 0;
	666	}
	667
14805359 AV	668	static const struct file_operations bt_fops = {
	669	.open = bt_seq_open,
	670	.read = seq_read,
	671	.llseek = seq_lseek,
	672	.release = seq_release_private
	673	};
	674
b0316615	675	int bt_procfs_init(struct net net, const char name,
256a06c8 MY	676	struct bt_sock_list* sk_list,
	677	int (* seq_show)(struct seq_file , void ))
	678	{
256a06c8 MY	679	sk_list->custom_seq_show = seq_show;
256a06c8 MY	680
4d006263	681	if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
256a06c8	682	return -ENOMEM;
256a06c8 MY	683	return 0;
	684	}
	685
	686	void bt_procfs_cleanup(struct net net, const char name)
	687	{
ece31ffd	688	remove_proc_entry(name, net->proc_net);
256a06c8 MY	689	}
256a06c8 MY	690	#else
b0316615	691	int bt_procfs_init(struct net net, const char name,
256a06c8 MY	692	struct bt_sock_list* sk_list,
	693	int (* seq_show)(struct seq_file , void ))
	694	{
	695	return 0;
	696	}
	697
	698	void bt_procfs_cleanup(struct net net, const char name)
	699	{
	700	}
	701	#endif
	702	EXPORT_SYMBOL(bt_procfs_init);
	703	EXPORT_SYMBOL(bt_procfs_cleanup);
	704
1da177e4 LT	705	static struct net_proto_family bt_sock_family_ops = {
	706	.owner = THIS_MODULE,
	707	.family = PF_BLUETOOTH,
	708	.create = bt_sock_create,
	709	};
	710
1da177e4 LT	711	static int __init bt_init(void)
1da177e4 LT	712	{
27d35284 MH	713	int err;
27d35284 MH	714
1da177e4 LT	715	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	716
27d35284 MH	717	err = bt_sysfs_init();
	718	if (err < 0)
	719	return err;
1da177e4	720
27d35284 MH	721	err = sock_register(&bt_sock_family_ops);
	722	if (err < 0) {
	723	bt_sysfs_cleanup();
	724	return err;
	725	}
1da177e4	726
27d35284	727	BT_INFO("HCI device and connection manager initialized");
1da177e4	728
64274518 GP	729	err = hci_sock_init();
	730	if (err < 0)
	731	goto error;
	732
	733	err = l2cap_init();
0ed54dad	734	if (err < 0)
64274518	735	goto sock_err;
64274518 GP	736
	737	err = sco_init();
	738	if (err < 0) {
	739	l2cap_exit();
	740	goto sock_err;
	741	}
1da177e4 LT	742
1da177e4 LT	743	return 0;
64274518 GP	744
	745	sock_err:
	746	hci_sock_cleanup();
	747
	748	error:
	749	sock_unregister(PF_BLUETOOTH);
	750	bt_sysfs_cleanup();
	751
	752	return err;
1da177e4 LT	753	}
	754
	755	static void __exit bt_exit(void)
	756	{
64274518 GP	757
	758	sco_exit();
	759
	760	l2cap_exit();
	761
1da177e4 LT	762	hci_sock_cleanup();
1da177e4 LT	763
1da177e4	764	sock_unregister(PF_BLUETOOTH);
27d35284 MH	765
27d35284 MH	766	bt_sysfs_cleanup();
1da177e4 LT	767	}
	768
	769	subsys_initcall(bt_init);
	770	module_exit(bt_exit);
	771
63fbd24e	772	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	773	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	774	MODULE_VERSION(VERSION);
	775	MODULE_LICENSE("GPL");
	776	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);