[GitHub/mt8127/android_kernel_alcatel_ttab.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>

#ifndef CONFIG_BT_SOCK_DEBUG
#undef  BT_DBG
#define BT_DBG(D...)
#endif

#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);

#ifdef CONFIG_PARANOID_NETWORK
static inline int current_has_bt_admin(void)
{
	return !current_euid();
}

static inline int current_has_bt(void)
{
	return current_has_bt_admin();
}
# else
static inline int current_has_bt_admin(void)
{
	return 1;
}

static inline int current_has_bt(void)
{
	return 1;
}
#endif

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

	if (proto == BTPROTO_RFCOMM || proto == BTPROTO_SCO ||
			proto == BTPROTO_L2CAP) {
		if (!current_has_bt())
			return -EPERM;
	} else if (!current_has_bt_admin())
		return -EPERM;

	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)
			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;

	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);

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);

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