[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.16"

/* 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;

	msg->msg_namelen = 0;

	skb = skb_recv_datagram(sk, flags, noblock, &err);
	if (!skb) {
		if (sk->sk_shutdown & RCV_SHUTDOWN)
			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);

	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  Src Dst 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 %pMR %pMR %-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->src,
			   &bt->dst,
			   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
64274518	33	#define VERSION "2.16"
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
4683f42f MK	224	msg->msg_namelen = 0;
4683f42f MK	225
5a08ecce AE	226	skb = skb_recv_datagram(sk, flags, noblock, &err);
5a08ecce AE	227	if (!skb) {
1da177e4 LT	228	if (sk->sk_shutdown & RCV_SHUTDOWN)
	229	return 0;
	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);
3241ad82	241	if (err == 0)
3b885787	242	sock_recv_ts_and_drops(msg, sk, skb);
1da177e4 LT	243
	244	skb_free_datagram(sk, skb);
	245
	246	return err ? : copied;
	247	}
	248	EXPORT_SYMBOL(bt_sock_recvmsg);
	249
796c86ee MM	250	static long bt_sock_data_wait(struct sock *sk, long timeo)
	251	{
	252	DECLARE_WAITQUEUE(wait, current);
	253
	254	add_wait_queue(sk_sleep(sk), &wait);
	255	for (;;) {
	256	set_current_state(TASK_INTERRUPTIBLE);
	257
	258	if (!skb_queue_empty(&sk->sk_receive_queue))
	259	break;
	260
	261	if (sk->sk_err \|\| (sk->sk_shutdown & RCV_SHUTDOWN))
	262	break;
	263
	264	if (signal_pending(current) \|\| !timeo)
	265	break;
	266
	267	set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	268	release_sock(sk);
	269	timeo = schedule_timeout(timeo);
	270	lock_sock(sk);
	271	clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	272	}
	273
	274	__set_current_state(TASK_RUNNING);
	275	remove_wait_queue(sk_sleep(sk), &wait);
	276	return timeo;
	277	}
	278
	279	int bt_sock_stream_recvmsg(struct kiocb iocb, struct socket sock,
	280	struct msghdr *msg, size_t size, int flags)
	281	{
	282	struct sock *sk = sock->sk;
	283	int err = 0;
	284	size_t target, copied = 0;
	285	long timeo;
	286
	287	if (flags & MSG_OOB)
	288	return -EOPNOTSUPP;
	289
	290	msg->msg_namelen = 0;
	291
	292	BT_DBG("sk %p size %zu", sk, size);
	293
	294	lock_sock(sk);
	295
	296	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
	297	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
	298
	299	do {
	300	struct sk_buff *skb;
	301	int chunk;
	302
	303	skb = skb_dequeue(&sk->sk_receive_queue);
	304	if (!skb) {
	305	if (copied >= target)
	306	break;
	307
5a08ecce AE	308	err = sock_error(sk);
5a08ecce AE	309	if (err)
796c86ee MM	310	break;
	311	if (sk->sk_shutdown & RCV_SHUTDOWN)
	312	break;
	313
	314	err = -EAGAIN;
	315	if (!timeo)
	316	break;
	317
	318	timeo = bt_sock_data_wait(sk, timeo);
	319
	320	if (signal_pending(current)) {
	321	err = sock_intr_errno(timeo);
	322	goto out;
	323	}
	324	continue;
	325	}
	326
	327	chunk = min_t(unsigned int, skb->len, size);
5b668eb3	328	if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
796c86ee MM	329	skb_queue_head(&sk->sk_receive_queue, skb);
	330	if (!copied)
	331	copied = -EFAULT;
	332	break;
	333	}
	334	copied += chunk;
	335	size -= chunk;
	336
	337	sock_recv_ts_and_drops(msg, sk, skb);
	338
	339	if (!(flags & MSG_PEEK)) {
5b668eb3 MM	340	int skb_len = skb_headlen(skb);
	341
	342	if (chunk <= skb_len) {
	343	__skb_pull(skb, chunk);
	344	} else {
	345	struct sk_buff *frag;
	346
	347	__skb_pull(skb, skb_len);
	348	chunk -= skb_len;
	349
	350	skb_walk_frags(skb, frag) {
	351	if (chunk <= frag->len) {
	352	/* Pulling partial data */
	353	skb->len -= chunk;
	354	skb->data_len -= chunk;
	355	__skb_pull(frag, chunk);
	356	break;
	357	} else if (frag->len) {
	358	/* Pulling all frag data */
	359	chunk -= frag->len;
	360	skb->len -= frag->len;
	361	skb->data_len -= frag->len;
	362	__skb_pull(frag, frag->len);
	363	}
	364	}
	365	}
	366
796c86ee MM	367	if (skb->len) {
	368	skb_queue_head(&sk->sk_receive_queue, skb);
	369	break;
	370	}
	371	kfree_skb(skb);
	372
	373	} else {
	374	/* put message back and return */
	375	skb_queue_head(&sk->sk_receive_queue, skb);
	376	break;
	377	}
	378	} while (size);
	379
	380	out:
	381	release_sock(sk);
	382	return copied ? : err;
	383	}
	384	EXPORT_SYMBOL(bt_sock_stream_recvmsg);
	385
1da177e4 LT	386	static inline unsigned int bt_accept_poll(struct sock *parent)
	387	{
	388	struct list_head p, n;
	389	struct sock *sk;
	390
	391	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	392	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be	393	if (sk->sk_state == BT_CONNECTED \|\|
c5daa683 GP	394	(test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
c5daa683 GP	395	sk->sk_state == BT_CONNECT2))
1da177e4 LT	396	return POLLIN \| POLLRDNORM;
	397	}
	398
	399	return 0;
	400	}
	401
8fc9ced3 GP	402	unsigned int bt_sock_poll(struct file file, struct socket sock,
8fc9ced3 GP	403	poll_table *wait)
1da177e4 LT	404	{
	405	struct sock *sk = sock->sk;
	406	unsigned int mask = 0;
	407
	408	BT_DBG("sock %p, sk %p", sock, sk);
	409
aa395145	410	poll_wait(file, sk_sleep(sk), wait);
1da177e4 LT	411
	412	if (sk->sk_state == BT_LISTEN)
	413	return bt_accept_poll(sk);
	414
	415	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
7d4c04fc	416	mask \|= POLLERR \|
8facd5fb	417	(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
1da177e4	418
f348d70a	419	if (sk->sk_shutdown & RCV_SHUTDOWN)
db40980f	420	mask \|= POLLRDHUP \| POLLIN \| POLLRDNORM;
f348d70a	421
1da177e4 LT	422	if (sk->sk_shutdown == SHUTDOWN_MASK)
	423	mask \|= POLLHUP;
	424
db40980f	425	if (!skb_queue_empty(&sk->sk_receive_queue))
1da177e4 LT	426	mask \|= POLLIN \| POLLRDNORM;
	427
	428	if (sk->sk_state == BT_CLOSED)
	429	mask \|= POLLHUP;
	430
	431	if (sk->sk_state == BT_CONNECT \|\|
	432	sk->sk_state == BT_CONNECT2 \|\|
	433	sk->sk_state == BT_CONFIG)
	434	return mask;
	435
c5daa683	436	if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
1da177e4 LT	437	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	438	else
	439	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	440
	441	return mask;
	442	}
	443	EXPORT_SYMBOL(bt_sock_poll);
	444
3241ad82 MH	445	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	446	{
	447	struct sock *sk = sock->sk;
43cbeee9 MH	448	struct sk_buff *skb;
43cbeee9 MH	449	long amount;
3241ad82 MH	450	int err;
	451
	452	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	453
	454	switch (cmd) {
43cbeee9 MH	455	case TIOCOUTQ:
	456	if (sk->sk_state == BT_LISTEN)
	457	return -EINVAL;
	458
31e6d363	459	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	460	if (amount < 0)
	461	amount = 0;
	462	err = put_user(amount, (int __user *) arg);
	463	break;
	464
	465	case TIOCINQ:
	466	if (sk->sk_state == BT_LISTEN)
	467	return -EINVAL;
	468
	469	lock_sock(sk);
	470	skb = skb_peek(&sk->sk_receive_queue);
	471	amount = skb ? skb->len : 0;
	472	release_sock(sk);
	473	err = put_user(amount, (int __user *) arg);
	474	break;
	475
3241ad82 MH	476	case SIOCGSTAMP:
	477	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	478	break;
	479
	480	case SIOCGSTAMPNS:
	481	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	482	break;
	483
	484	default:
	485	err = -ENOIOCTLCMD;
	486	break;
	487	}
	488
	489	return err;
	490	}
	491	EXPORT_SYMBOL(bt_sock_ioctl);
	492
0fba96f9	493	/* This function expects the sk lock to be held when called */
1da177e4 LT	494	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	495	{
	496	DECLARE_WAITQUEUE(wait, current);
	497	int err = 0;
	498
	499	BT_DBG("sk %p", sk);
	500
aa395145	501	add_wait_queue(sk_sleep(sk), &wait);
9be4e3fb	502	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	503	while (sk->sk_state != state) {
1da177e4	504	if (!timeo) {
b4c612a4	505	err = -EINPROGRESS;
1da177e4 LT	506	break;
	507	}
	508
	509	if (signal_pending(current)) {
	510	err = sock_intr_errno(timeo);
	511	break;
	512	}
	513
	514	release_sock(sk);
	515	timeo = schedule_timeout(timeo);
	516	lock_sock(sk);
9be4e3fb	517	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	518
c1cbe4b7 BL	519	err = sock_error(sk);
c1cbe4b7 BL	520	if (err)
1da177e4	521	break;
1da177e4	522	}
9be4e3fb	523	__set_current_state(TASK_RUNNING);
aa395145	524	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	525	return err;
	526	}
	527	EXPORT_SYMBOL(bt_sock_wait_state);
	528
e793dcf0 JH	529	/* This function expects the sk lock to be held when called */
	530	int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
	531	{
	532	DECLARE_WAITQUEUE(wait, current);
	533	unsigned long timeo;
	534	int err = 0;
	535
	536	BT_DBG("sk %p", sk);
	537
	538	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
	539
	540	add_wait_queue(sk_sleep(sk), &wait);
	541	set_current_state(TASK_INTERRUPTIBLE);
	542	while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
	543	if (!timeo) {
	544	err = -EAGAIN;
	545	break;
	546	}
	547
	548	if (signal_pending(current)) {
	549	err = sock_intr_errno(timeo);
	550	break;
	551	}
	552
	553	release_sock(sk);
	554	timeo = schedule_timeout(timeo);
	555	lock_sock(sk);
	556	set_current_state(TASK_INTERRUPTIBLE);
	557
	558	err = sock_error(sk);
	559	if (err)
	560	break;
	561	}
	562	__set_current_state(TASK_RUNNING);
	563	remove_wait_queue(sk_sleep(sk), &wait);
	564
	565	return err;
	566	}
	567	EXPORT_SYMBOL(bt_sock_wait_ready);
	568
256a06c8 MY	569	#ifdef CONFIG_PROC_FS
	570	struct bt_seq_state {
	571	struct bt_sock_list *l;
	572	};
	573
	574	static void bt_seq_start(struct seq_file seq, loff_t *pos)
	575	__acquires(seq->private->l->lock)
	576	{
	577	struct bt_seq_state *s = seq->private;
	578	struct bt_sock_list *l = s->l;
	579
	580	read_lock(&l->lock);
	581	return seq_hlist_start_head(&l->head, *pos);
	582	}
	583
	584	static void bt_seq_next(struct seq_file seq, void v, loff_t pos)
	585	{
	586	struct bt_seq_state *s = seq->private;
	587	struct bt_sock_list *l = s->l;
	588
	589	return seq_hlist_next(v, &l->head, pos);
	590	}
	591
	592	static void bt_seq_stop(struct seq_file seq, void v)
	593	__releases(seq->private->l->lock)
	594	{
	595	struct bt_seq_state *s = seq->private;
	596	struct bt_sock_list *l = s->l;
	597
	598	read_unlock(&l->lock);
	599	}
	600
	601	static int bt_seq_show(struct seq_file seq, void v)
	602	{
256a06c8 MY	603	struct bt_seq_state *s = seq->private;
256a06c8 MY	604	struct bt_sock_list *l = s->l;
256a06c8 MY	605
	606	if (v == SEQ_START_TOKEN) {
	607	seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Src Dst Parent");
	608
	609	if (l->custom_seq_show) {
	610	seq_putc(seq, ' ');
	611	l->custom_seq_show(seq, v);
	612	}
	613
	614	seq_putc(seq, '\n');
	615	} else {
09d5d4aa AE	616	struct sock *sk = sk_entry(v);
09d5d4aa AE	617	struct bt_sock *bt = bt_sk(sk);
256a06c8	618
7028a886 AE	619	seq_printf(seq,
7028a886 AE	620	"%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
256a06c8 MY	621	sk,
	622	atomic_read(&sk->sk_refcnt),
	623	sk_rmem_alloc_get(sk),
	624	sk_wmem_alloc_get(sk),
1bbb3095	625	from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
256a06c8	626	sock_i_ino(sk),
7028a886 AE	627	&bt->src,
7028a886 AE	628	&bt->dst,
256a06c8 MY	629	bt->parent? sock_i_ino(bt->parent): 0LU);
	630
	631	if (l->custom_seq_show) {
	632	seq_putc(seq, ' ');
	633	l->custom_seq_show(seq, v);
	634	}
	635
	636	seq_putc(seq, '\n');
	637	}
	638	return 0;
	639	}
	640
	641	static struct seq_operations bt_seq_ops = {
	642	.start = bt_seq_start,
	643	.next = bt_seq_next,
	644	.stop = bt_seq_stop,
	645	.show = bt_seq_show,
	646	};
	647
	648	static int bt_seq_open(struct inode inode, struct file file)
	649	{
	650	struct bt_sock_list *sk_list;
	651	struct bt_seq_state *s;
	652
d9dda78b	653	sk_list = PDE_DATA(inode);
256a06c8 MY	654	s = __seq_open_private(file, &bt_seq_ops,
256a06c8 MY	655	sizeof(struct bt_seq_state));
31f47073	656	if (!s)
256a06c8 MY	657	return -ENOMEM;
	658
	659	s->l = sk_list;
	660	return 0;
	661	}
	662
14805359 AV	663	static const struct file_operations bt_fops = {
	664	.open = bt_seq_open,
	665	.read = seq_read,
	666	.llseek = seq_lseek,
	667	.release = seq_release_private
	668	};
	669
b0316615	670	int bt_procfs_init(struct net net, const char name,
256a06c8 MY	671	struct bt_sock_list* sk_list,
	672	int (* seq_show)(struct seq_file , void ))
	673	{
256a06c8 MY	674	sk_list->custom_seq_show = seq_show;
256a06c8 MY	675
4d006263	676	if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
256a06c8	677	return -ENOMEM;
256a06c8 MY	678	return 0;
	679	}
	680
	681	void bt_procfs_cleanup(struct net net, const char name)
	682	{
ece31ffd	683	remove_proc_entry(name, net->proc_net);
256a06c8 MY	684	}
256a06c8 MY	685	#else
b0316615	686	int bt_procfs_init(struct net net, const char name,
256a06c8 MY	687	struct bt_sock_list* sk_list,
	688	int (* seq_show)(struct seq_file , void ))
	689	{
	690	return 0;
	691	}
	692
	693	void bt_procfs_cleanup(struct net net, const char name)
	694	{
	695	}
	696	#endif
	697	EXPORT_SYMBOL(bt_procfs_init);
	698	EXPORT_SYMBOL(bt_procfs_cleanup);
	699
1da177e4 LT	700	static struct net_proto_family bt_sock_family_ops = {
	701	.owner = THIS_MODULE,
	702	.family = PF_BLUETOOTH,
	703	.create = bt_sock_create,
	704	};
	705
1da177e4 LT	706	static int __init bt_init(void)
1da177e4 LT	707	{
27d35284 MH	708	int err;
27d35284 MH	709
1da177e4 LT	710	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	711
27d35284 MH	712	err = bt_sysfs_init();
	713	if (err < 0)
	714	return err;
1da177e4	715
27d35284 MH	716	err = sock_register(&bt_sock_family_ops);
	717	if (err < 0) {
	718	bt_sysfs_cleanup();
	719	return err;
	720	}
1da177e4	721
27d35284	722	BT_INFO("HCI device and connection manager initialized");
1da177e4	723
64274518 GP	724	err = hci_sock_init();
	725	if (err < 0)
	726	goto error;
	727
	728	err = l2cap_init();
0ed54dad	729	if (err < 0)
64274518	730	goto sock_err;
64274518 GP	731
	732	err = sco_init();
	733	if (err < 0) {
	734	l2cap_exit();
	735	goto sock_err;
	736	}
1da177e4 LT	737
1da177e4 LT	738	return 0;
64274518 GP	739
	740	sock_err:
	741	hci_sock_cleanup();
	742
	743	error:
	744	sock_unregister(PF_BLUETOOTH);
	745	bt_sysfs_cleanup();
	746
	747	return err;
1da177e4 LT	748	}
	749
	750	static void __exit bt_exit(void)
	751	{
64274518 GP	752
	753	sco_exit();
	754
	755	l2cap_exit();
	756
1da177e4 LT	757	hci_sock_cleanup();
1da177e4 LT	758
1da177e4	759	sock_unregister(PF_BLUETOOTH);
27d35284 MH	760
27d35284 MH	761	bt_sysfs_cleanup();
1da177e4 LT	762	}
	763
	764	subsys_initcall(bt_init);
	765	module_exit(bt_exit);
	766
63fbd24e	767	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	768	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	769	MODULE_VERSION(VERSION);
	770	MODULE_LICENSE("GPL");
	771	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);