[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / bnep / core.c

/*
   BNEP implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2001-2002 Inventel Systemes
   Written 2001-2002 by
	Clément Moreau <clement.moreau@inventel.fr>
	David Libault  <david.libault@inventel.fr>

   Copyright (C) 2002 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.
*/

#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/file.h>
#include <linux/etherdevice.h>
#include <asm/unaligned.h>

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

#include "bnep.h"

#define VERSION "1.3"

static bool compress_src = true;
static bool compress_dst = true;

static LIST_HEAD(bnep_session_list);
static DECLARE_RWSEM(bnep_session_sem);

static struct bnep_session *__bnep_get_session(u8 *dst)
{
	struct bnep_session *s;

	BT_DBG("");

	list_for_each_entry(s, &bnep_session_list, list)
		if (ether_addr_equal(dst, s->eh.h_source))
			return s;

	return NULL;
}

static void __bnep_link_session(struct bnep_session *s)
{
	list_add(&s->list, &bnep_session_list);
}

static void __bnep_unlink_session(struct bnep_session *s)
{
	list_del(&s->list);
}

static int bnep_send(struct bnep_session *s, void *data, size_t len)
{
	struct socket *sock = s->sock;
	struct kvec iv = { data, len };

	return kernel_sendmsg(sock, &s->msg, &iv, 1, len);
}

static int bnep_send_rsp(struct bnep_session *s, u8 ctrl, u16 resp)
{
	struct bnep_control_rsp rsp;
	rsp.type = BNEP_CONTROL;
	rsp.ctrl = ctrl;
	rsp.resp = htons(resp);
	return bnep_send(s, &rsp, sizeof(rsp));
}

#ifdef CONFIG_BT_BNEP_PROTO_FILTER
static inline void bnep_set_default_proto_filter(struct bnep_session *s)
{
	/* (IPv4, ARP)  */
	s->proto_filter[0].start = ETH_P_IP;
	s->proto_filter[0].end   = ETH_P_ARP;
	/* (RARP, AppleTalk) */
	s->proto_filter[1].start = ETH_P_RARP;
	s->proto_filter[1].end   = ETH_P_AARP;
	/* (IPX, IPv6) */
	s->proto_filter[2].start = ETH_P_IPX;
	s->proto_filter[2].end   = ETH_P_IPV6;
}
#endif

static int bnep_ctrl_set_netfilter(struct bnep_session *s, __be16 *data, int len)
{
	int n;

	if (len < 2)
		return -EILSEQ;

	n = get_unaligned_be16(data);
	data++;
	len -= 2;

	if (len < n)
		return -EILSEQ;

	BT_DBG("filter len %d", n);

#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	n /= 4;
	if (n <= BNEP_MAX_PROTO_FILTERS) {
		struct bnep_proto_filter *f = s->proto_filter;
		int i;

		for (i = 0; i < n; i++) {
			f[i].start = get_unaligned_be16(data++);
			f[i].end   = get_unaligned_be16(data++);

			BT_DBG("proto filter start %d end %d",
				f[i].start, f[i].end);
		}

		if (i < BNEP_MAX_PROTO_FILTERS)
			memset(f + i, 0, sizeof(*f));

		if (n == 0)
			bnep_set_default_proto_filter(s);

		bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_SUCCESS);
	} else {
		bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_LIMIT_REACHED);
	}
#else
	bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
#endif
	return 0;
}

static int bnep_ctrl_set_mcfilter(struct bnep_session *s, u8 *data, int len)
{
	int n;

	if (len < 2)
		return -EILSEQ;

	n = get_unaligned_be16(data);
	data += 2;
	len -= 2;

	if (len < n)
		return -EILSEQ;

	BT_DBG("filter len %d", n);

#ifdef CONFIG_BT_BNEP_MC_FILTER
	n /= (ETH_ALEN * 2);

	if (n > 0) {
		int i;

		s->mc_filter = 0;

		/* Always send broadcast */
		set_bit(bnep_mc_hash(s->dev->broadcast), (ulong *) &s->mc_filter);

		/* Add address ranges to the multicast hash */
		for (; n > 0; n--) {
			u8 a1[6], *a2;

			memcpy(a1, data, ETH_ALEN);
			data += ETH_ALEN;
			a2 = data;
			data += ETH_ALEN;

			BT_DBG("mc filter %pMR -> %pMR", a1, a2);

			/* Iterate from a1 to a2 */
			set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
			while (memcmp(a1, a2, 6) < 0 && s->mc_filter != ~0LL) {
				/* Increment a1 */
				i = 5;
				while (i >= 0 && ++a1[i--] == 0)
					;

				set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
			}
		}
	}

	BT_DBG("mc filter hash 0x%llx", s->mc_filter);

	bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_SUCCESS);
#else
	bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
#endif
	return 0;
}

static int bnep_rx_control(struct bnep_session *s, void *data, int len)
{
	u8  cmd = *(u8 *)data;
	int err = 0;

	data++;
	len--;

	switch (cmd) {
	case BNEP_CMD_NOT_UNDERSTOOD:
	case BNEP_SETUP_CONN_RSP:
	case BNEP_FILTER_NET_TYPE_RSP:
	case BNEP_FILTER_MULTI_ADDR_RSP:
		/* Ignore these for now */
		break;

	case BNEP_FILTER_NET_TYPE_SET:
		err = bnep_ctrl_set_netfilter(s, data, len);
		break;

	case BNEP_FILTER_MULTI_ADDR_SET:
		err = bnep_ctrl_set_mcfilter(s, data, len);
		break;

	case BNEP_SETUP_CONN_REQ:
		err = bnep_send_rsp(s, BNEP_SETUP_CONN_RSP, BNEP_CONN_NOT_ALLOWED);
		break;

	default: {
			u8 pkt[3];
			pkt[0] = BNEP_CONTROL;
			pkt[1] = BNEP_CMD_NOT_UNDERSTOOD;
			pkt[2] = cmd;
			bnep_send(s, pkt, sizeof(pkt));
		}
		break;
	}

	return err;
}

static int bnep_rx_extension(struct bnep_session *s, struct sk_buff *skb)
{
	struct bnep_ext_hdr *h;
	int err = 0;

	do {
		h = (void *) skb->data;
		if (!skb_pull(skb, sizeof(*h))) {
			err = -EILSEQ;
			break;
		}

		BT_DBG("type 0x%x len %d", h->type, h->len);

		switch (h->type & BNEP_TYPE_MASK) {
		case BNEP_EXT_CONTROL:
			bnep_rx_control(s, skb->data, skb->len);
			break;

		default:
			/* Unknown extension, skip it. */
			break;
		}

		if (!skb_pull(skb, h->len)) {
			err = -EILSEQ;
			break;
		}
	} while (!err && (h->type & BNEP_EXT_HEADER));

	return err;
}

static u8 __bnep_rx_hlen[] = {
	ETH_HLEN,     /* BNEP_GENERAL */
	0,            /* BNEP_CONTROL */
	2,            /* BNEP_COMPRESSED */
	ETH_ALEN + 2, /* BNEP_COMPRESSED_SRC_ONLY */
	ETH_ALEN + 2  /* BNEP_COMPRESSED_DST_ONLY */
};

static int bnep_rx_frame(struct bnep_session *s, struct sk_buff *skb)
{
	struct net_device *dev = s->dev;
	struct sk_buff *nskb;
	u8 type;

	dev->stats.rx_bytes += skb->len;

	type = *(u8 *) skb->data;
	skb_pull(skb, 1);

	if ((type & BNEP_TYPE_MASK) >= sizeof(__bnep_rx_hlen))
		goto badframe;

	if ((type & BNEP_TYPE_MASK) == BNEP_CONTROL) {
		bnep_rx_control(s, skb->data, skb->len);
		kfree_skb(skb);
		return 0;
	}

	skb_reset_mac_header(skb);

	/* Verify and pull out header */
	if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK]))
		goto badframe;

	s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));

	if (type & BNEP_EXT_HEADER) {
		if (bnep_rx_extension(s, skb) < 0)
			goto badframe;
	}

	/* Strip 802.1p header */
	if (ntohs(s->eh.h_proto) == ETH_P_8021Q) {
		if (!skb_pull(skb, 4))
			goto badframe;
		s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
	}

	/* We have to alloc new skb and copy data here :(. Because original skb
	 * may not be modified and because of the alignment requirements. */
	nskb = alloc_skb(2 + ETH_HLEN + skb->len, GFP_KERNEL);
	if (!nskb) {
		dev->stats.rx_dropped++;
		kfree_skb(skb);
		return -ENOMEM;
	}
	skb_reserve(nskb, 2);

	/* Decompress header and construct ether frame */
	switch (type & BNEP_TYPE_MASK) {
	case BNEP_COMPRESSED:
		memcpy(__skb_put(nskb, ETH_HLEN), &s->eh, ETH_HLEN);
		break;

	case BNEP_COMPRESSED_SRC_ONLY:
		memcpy(__skb_put(nskb, ETH_ALEN), s->eh.h_dest, ETH_ALEN);
		memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb), ETH_ALEN);
		put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
		break;

	case BNEP_COMPRESSED_DST_ONLY:
		memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb),
								ETH_ALEN);
		memcpy(__skb_put(nskb, ETH_ALEN + 2), s->eh.h_source,
								ETH_ALEN + 2);
		break;

	case BNEP_GENERAL:
		memcpy(__skb_put(nskb, ETH_ALEN * 2), skb_mac_header(skb),
								ETH_ALEN * 2);
		put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
		break;
	}

	skb_copy_from_linear_data(skb, __skb_put(nskb, skb->len), skb->len);
	kfree_skb(skb);

	dev->stats.rx_packets++;
	nskb->ip_summed = CHECKSUM_NONE;
	nskb->protocol  = eth_type_trans(nskb, dev);
	netif_rx_ni(nskb);
	return 0;

badframe:
	dev->stats.rx_errors++;
	kfree_skb(skb);
	return 0;
}

static u8 __bnep_tx_types[] = {
	BNEP_GENERAL,
	BNEP_COMPRESSED_SRC_ONLY,
	BNEP_COMPRESSED_DST_ONLY,
	BNEP_COMPRESSED
};

static int bnep_tx_frame(struct bnep_session *s, struct sk_buff *skb)
{
	struct ethhdr *eh = (void *) skb->data;
	struct socket *sock = s->sock;
	struct kvec iv[3];
	int len = 0, il = 0;
	u8 type = 0;

	BT_DBG("skb %p dev %p type %d", skb, skb->dev, skb->pkt_type);

	if (!skb->dev) {
		/* Control frame sent by us */
		goto send;
	}

	iv[il++] = (struct kvec) { &type, 1 };
	len++;

	if (compress_src && ether_addr_equal(eh->h_dest, s->eh.h_source))
		type |= 0x01;

	if (compress_dst && ether_addr_equal(eh->h_source, s->eh.h_dest))
		type |= 0x02;

	if (type)
		skb_pull(skb, ETH_ALEN * 2);

	type = __bnep_tx_types[type];
	switch (type) {
	case BNEP_COMPRESSED_SRC_ONLY:
		iv[il++] = (struct kvec) { eh->h_source, ETH_ALEN };
		len += ETH_ALEN;
		break;

	case BNEP_COMPRESSED_DST_ONLY:
		iv[il++] = (struct kvec) { eh->h_dest, ETH_ALEN };
		len += ETH_ALEN;
		break;
	}

send:
	iv[il++] = (struct kvec) { skb->data, skb->len };
	len += skb->len;

	/* FIXME: linearize skb */
	{
		len = kernel_sendmsg(sock, &s->msg, iv, il, len);
	}
	kfree_skb(skb);

	if (len > 0) {
		s->dev->stats.tx_bytes += len;
		s->dev->stats.tx_packets++;
		return 0;
	}

	return len;
}

static int bnep_session(void *arg)
{
	struct bnep_session *s = arg;
	struct net_device *dev = s->dev;
	struct sock *sk = s->sock->sk;
	struct sk_buff *skb;
	wait_queue_t wait;

	BT_DBG("");

	set_user_nice(current, -15);

	init_waitqueue_entry(&wait, current);
	add_wait_queue(sk_sleep(sk), &wait);
	while (1) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (atomic_read(&s->terminate))
			break;
		/* RX */
		while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
			skb_orphan(skb);
			if (!skb_linearize(skb))
				bnep_rx_frame(s, skb);
			else
				kfree_skb(skb);
		}

		if (sk->sk_state != BT_CONNECTED)
			break;

		/* TX */
		while ((skb = skb_dequeue(&sk->sk_write_queue)))
			if (bnep_tx_frame(s, skb))
				break;
		netif_wake_queue(dev);

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

	/* Cleanup session */
	down_write(&bnep_session_sem);

	/* Delete network device */
	unregister_netdev(dev);

	/* Wakeup user-space polling for socket errors */
	s->sock->sk->sk_err = EUNATCH;

	wake_up_interruptible(sk_sleep(s->sock->sk));

	/* Release the socket */
	fput(s->sock->file);

	__bnep_unlink_session(s);

	up_write(&bnep_session_sem);
	free_netdev(dev);
	module_put_and_exit(0);
	return 0;
}

static struct device *bnep_get_device(struct bnep_session *session)
{
	bdaddr_t *src = &bt_sk(session->sock->sk)->src;
	bdaddr_t *dst = &bt_sk(session->sock->sk)->dst;
	struct hci_dev *hdev;
	struct hci_conn *conn;

	hdev = hci_get_route(dst, src);
	if (!hdev)
		return NULL;

	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);

	hci_dev_put(hdev);

	return conn ? &conn->dev : NULL;
}

static struct device_type bnep_type = {
	.name	= "bluetooth",
};

int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
{
	struct net_device *dev;
	struct bnep_session *s, *ss;
	u8 dst[ETH_ALEN], src[ETH_ALEN];
	int err;

	BT_DBG("");

	if (!l2cap_is_socket(sock))
		return -EBADFD;

	baswap((void *) dst, &bt_sk(sock->sk)->dst);
	baswap((void *) src, &bt_sk(sock->sk)->src);

	/* session struct allocated as private part of net_device */
	dev = alloc_netdev(sizeof(struct bnep_session),
				(*req->device) ? req->device : "bnep%d",
				bnep_net_setup);
	if (!dev)
		return -ENOMEM;

	down_write(&bnep_session_sem);

	ss = __bnep_get_session(dst);
	if (ss && ss->state == BT_CONNECTED) {
		err = -EEXIST;
		goto failed;
	}

	s = netdev_priv(dev);

	/* This is rx header therefore addresses are swapped.
	 * ie. eh.h_dest is our local address. */
	memcpy(s->eh.h_dest,   &src, ETH_ALEN);
	memcpy(s->eh.h_source, &dst, ETH_ALEN);
	memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);

	s->dev   = dev;
	s->sock  = sock;
	s->role  = req->role;
	s->state = BT_CONNECTED;

	s->msg.msg_flags = MSG_NOSIGNAL;

#ifdef CONFIG_BT_BNEP_MC_FILTER
	/* Set default mc filter */
	set_bit(bnep_mc_hash(dev->broadcast), (ulong *) &s->mc_filter);
#endif

#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	/* Set default protocol filter */
	bnep_set_default_proto_filter(s);
#endif

	SET_NETDEV_DEV(dev, bnep_get_device(s));
	SET_NETDEV_DEVTYPE(dev, &bnep_type);

	err = register_netdev(dev);
	if (err)
		goto failed;

	__bnep_link_session(s);

	__module_get(THIS_MODULE);
	s->task = kthread_run(bnep_session, s, "kbnepd %s", dev->name);
	if (IS_ERR(s->task)) {
		/* Session thread start failed, gotta cleanup. */
		module_put(THIS_MODULE);
		unregister_netdev(dev);
		__bnep_unlink_session(s);
		err = PTR_ERR(s->task);
		goto failed;
	}

	up_write(&bnep_session_sem);
	strcpy(req->device, dev->name);
	return 0;

failed:
	up_write(&bnep_session_sem);
	free_netdev(dev);
	return err;
}

int bnep_del_connection(struct bnep_conndel_req *req)
{
	struct bnep_session *s;
	int  err = 0;

	BT_DBG("");

	down_read(&bnep_session_sem);

	s = __bnep_get_session(req->dst);
	if (s) {
		atomic_inc(&s->terminate);
		wake_up_process(s->task);
	} else
		err = -ENOENT;

	up_read(&bnep_session_sem);
	return err;
}

static void __bnep_copy_ci(struct bnep_conninfo *ci, struct bnep_session *s)
{
	memset(ci, 0, sizeof(*ci));
	memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
	strcpy(ci->device, s->dev->name);
	ci->flags = s->flags;
	ci->state = s->state;
	ci->role  = s->role;
}

int bnep_get_connlist(struct bnep_connlist_req *req)
{
	struct bnep_session *s;
	int err = 0, n = 0;

	down_read(&bnep_session_sem);

	list_for_each_entry(s, &bnep_session_list, list) {
		struct bnep_conninfo ci;

		__bnep_copy_ci(&ci, s);

		if (copy_to_user(req->ci, &ci, sizeof(ci))) {
			err = -EFAULT;
			break;
		}

		if (++n >= req->cnum)
			break;

		req->ci++;
	}
	req->cnum = n;

	up_read(&bnep_session_sem);
	return err;
}

int bnep_get_conninfo(struct bnep_conninfo *ci)
{
	struct bnep_session *s;
	int err = 0;

	down_read(&bnep_session_sem);

	s = __bnep_get_session(ci->dst);
	if (s)
		__bnep_copy_ci(ci, s);
	else
		err = -ENOENT;

	up_read(&bnep_session_sem);
	return err;
}

static int __init bnep_init(void)
{
	char flt[50] = "";

#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	strcat(flt, "protocol ");
#endif

#ifdef CONFIG_BT_BNEP_MC_FILTER
	strcat(flt, "multicast");
#endif

	BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION);
	if (flt[0])
		BT_INFO("BNEP filters: %s", flt);

	bnep_sock_init();
	return 0;
}

static void __exit bnep_exit(void)
{
	bnep_sock_cleanup();
}

module_init(bnep_init);
module_exit(bnep_exit);

module_param(compress_src, bool, 0644);
MODULE_PARM_DESC(compress_src, "Compress sources headers");

module_param(compress_dst, bool, 0644);
MODULE_PARM_DESC(compress_dst, "Compress destination headers");

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_ALIAS("bt-proto-4");
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	BNEP implementation for Linux Bluetooth stack (BlueZ).
	3	Copyright (C) 2001-2002 Inventel Systemes
	4	Written 2001-2002 by
96de0e25	5	Clément Moreau <clement.moreau@inventel.fr>
1da177e4 LT	6	David Libault <david.libault@inventel.fr>
	7
	8	Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
	9
	10	This program is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License version 2 as
	12	published by the Free Software Foundation;
	13
	14	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	15	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	17	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142 YH	18	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	19	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	20	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4 LT	21	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	22
8e87d142 YH	23	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	24	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	25	SOFTWARE IS DISCLAIMED.
	26	*/
	27
1da177e4	28	#include <linux/module.h>
f4d7cd4a	29	#include <linux/kthread.h>
1da177e4	30	#include <linux/file.h>
1da177e4	31	#include <linux/etherdevice.h>
1da177e4 LT	32	#include <asm/unaligned.h>
	33
	34	#include <net/bluetooth/bluetooth.h>
b8d57eb2	35	#include <net/bluetooth/l2cap.h>
0a85b964	36	#include <net/bluetooth/hci_core.h>
1da177e4 LT	37
	38	#include "bnep.h"
	39
28111eb2 MH	40	#define VERSION "1.3"
28111eb2 MH	41
eb939922 RR	42	static bool compress_src = true;
eb939922 RR	43	static bool compress_dst = true;
1da177e4 LT	44
	45	static LIST_HEAD(bnep_session_list);
	46	static DECLARE_RWSEM(bnep_session_sem);
	47
	48	static struct bnep_session __bnep_get_session(u8 dst)
	49	{
	50	struct bnep_session *s;
1da177e4 LT	51
	52	BT_DBG("");
	53
8035ded4	54	list_for_each_entry(s, &bnep_session_list, list)
c47fc981	55	if (ether_addr_equal(dst, s->eh.h_source))
1da177e4	56	return s;
8035ded4	57
1da177e4 LT	58	return NULL;
	59	}
	60
	61	static void __bnep_link_session(struct bnep_session *s)
	62	{
8e87d142	63	list_add(&s->list, &bnep_session_list);
1da177e4 LT	64	}
	65
	66	static void __bnep_unlink_session(struct bnep_session *s)
	67	{
	68	list_del(&s->list);
1da177e4 LT	69	}
	70
	71	static int bnep_send(struct bnep_session s, void data, size_t len)
	72	{
	73	struct socket *sock = s->sock;
	74	struct kvec iv = { data, len };
	75
	76	return kernel_sendmsg(sock, &s->msg, &iv, 1, len);
	77	}
	78
	79	static int bnep_send_rsp(struct bnep_session *s, u8 ctrl, u16 resp)
	80	{
	81	struct bnep_control_rsp rsp;
	82	rsp.type = BNEP_CONTROL;
	83	rsp.ctrl = ctrl;
	84	rsp.resp = htons(resp);
	85	return bnep_send(s, &rsp, sizeof(rsp));
	86	}
	87
	88	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	89	static inline void bnep_set_default_proto_filter(struct bnep_session *s)
	90	{
	91	/* (IPv4, ARP) */
e41d2169 AV	92	s->proto_filter[0].start = ETH_P_IP;
e41d2169 AV	93	s->proto_filter[0].end = ETH_P_ARP;
1da177e4	94	/* (RARP, AppleTalk) */
e41d2169 AV	95	s->proto_filter[1].start = ETH_P_RARP;
e41d2169 AV	96	s->proto_filter[1].end = ETH_P_AARP;
1da177e4	97	/* (IPX, IPv6) */
e41d2169 AV	98	s->proto_filter[2].start = ETH_P_IPX;
e41d2169 AV	99	s->proto_filter[2].end = ETH_P_IPV6;
1da177e4 LT	100	}
	101	#endif
	102
1bc5d448	103	static int bnep_ctrl_set_netfilter(struct bnep_session s, __be16 data, int len)
1da177e4 LT	104	{
	105	int n;
	106
	107	if (len < 2)
	108	return -EILSEQ;
	109
83985319	110	n = get_unaligned_be16(data);
3aad75a1 SJ	111	data++;
3aad75a1 SJ	112	len -= 2;
1da177e4 LT	113
	114	if (len < n)
	115	return -EILSEQ;
	116
	117	BT_DBG("filter len %d", n);
	118
	119	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	120	n /= 4;
	121	if (n <= BNEP_MAX_PROTO_FILTERS) {
	122	struct bnep_proto_filter *f = s->proto_filter;
	123	int i;
	124
	125	for (i = 0; i < n; i++) {
83985319 HH	126	f[i].start = get_unaligned_be16(data++);
83985319 HH	127	f[i].end = get_unaligned_be16(data++);
1da177e4 LT	128
	129	BT_DBG("proto filter start %d end %d",
	130	f[i].start, f[i].end);
	131	}
	132
	133	if (i < BNEP_MAX_PROTO_FILTERS)
	134	memset(f + i, 0, sizeof(*f));
	135
	136	if (n == 0)
	137	bnep_set_default_proto_filter(s);
	138
	139	bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_SUCCESS);
	140	} else {
	141	bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_LIMIT_REACHED);
	142	}
	143	#else
	144	bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
	145	#endif
	146	return 0;
	147	}
	148
	149	static int bnep_ctrl_set_mcfilter(struct bnep_session s, u8 data, int len)
	150	{
	151	int n;
	152
	153	if (len < 2)
	154	return -EILSEQ;
	155
83985319	156	n = get_unaligned_be16(data);
3aad75a1 SJ	157	data += 2;
3aad75a1 SJ	158	len -= 2;
1da177e4 LT	159
	160	if (len < n)
	161	return -EILSEQ;
	162
	163	BT_DBG("filter len %d", n);
	164
	165	#ifdef CONFIG_BT_BNEP_MC_FILTER
	166	n /= (ETH_ALEN * 2);
	167
	168	if (n > 0) {
a3d9bd4c SJ	169	int i;
a3d9bd4c SJ	170
1da177e4 LT	171	s->mc_filter = 0;
	172
	173	/* Always send broadcast */
	174	set_bit(bnep_mc_hash(s->dev->broadcast), (ulong *) &s->mc_filter);
	175
	176	/* Add address ranges to the multicast hash */
	177	for (; n > 0; n--) {
	178	u8 a1[6], *a2;
	179
3aad75a1 SJ	180	memcpy(a1, data, ETH_ALEN);
	181	data += ETH_ALEN;
	182	a2 = data;
	183	data += ETH_ALEN;
8e87d142	184
6ed93dc6	185	BT_DBG("mc filter %pMR -> %pMR", a1, a2);
1da177e4	186
1da177e4 LT	187	/* Iterate from a1 to a2 */
	188	set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
	189	while (memcmp(a1, a2, 6) < 0 && s->mc_filter != ~0LL) {
a3d9bd4c SJ	190	/* Increment a1 */
	191	i = 5;
	192	while (i >= 0 && ++a1[i--] == 0)
	193	;
	194
1da177e4 LT	195	set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
	196	}
	197	}
	198	}
	199
	200	BT_DBG("mc filter hash 0x%llx", s->mc_filter);
	201
	202	bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_SUCCESS);
	203	#else
	204	bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
	205	#endif
	206	return 0;
	207	}
	208
	209	static int bnep_rx_control(struct bnep_session s, void data, int len)
	210	{
	211	u8 cmd = (u8 )data;
	212	int err = 0;
	213
3aad75a1 SJ	214	data++;
3aad75a1 SJ	215	len--;
1da177e4 LT	216
	217	switch (cmd) {
	218	case BNEP_CMD_NOT_UNDERSTOOD:
1da177e4 LT	219	case BNEP_SETUP_CONN_RSP:
	220	case BNEP_FILTER_NET_TYPE_RSP:
	221	case BNEP_FILTER_MULTI_ADDR_RSP:
	222	/* Ignore these for now */
	223	break;
	224
	225	case BNEP_FILTER_NET_TYPE_SET:
	226	err = bnep_ctrl_set_netfilter(s, data, len);
	227	break;
	228
	229	case BNEP_FILTER_MULTI_ADDR_SET:
	230	err = bnep_ctrl_set_mcfilter(s, data, len);
	231	break;
	232
cde9f807 VK	233	case BNEP_SETUP_CONN_REQ:
	234	err = bnep_send_rsp(s, BNEP_SETUP_CONN_RSP, BNEP_CONN_NOT_ALLOWED);
	235	break;
	236
1da177e4 LT	237	default: {
	238	u8 pkt[3];
	239	pkt[0] = BNEP_CONTROL;
	240	pkt[1] = BNEP_CMD_NOT_UNDERSTOOD;
	241	pkt[2] = cmd;
	242	bnep_send(s, pkt, sizeof(pkt));
	243	}
	244	break;
	245	}
	246
	247	return err;
	248	}
	249
	250	static int bnep_rx_extension(struct bnep_session s, struct sk_buff skb)
	251	{
	252	struct bnep_ext_hdr *h;
	253	int err = 0;
	254
	255	do {
	256	h = (void *) skb->data;
	257	if (!skb_pull(skb, sizeof(*h))) {
	258	err = -EILSEQ;
	259	break;
	260	}
	261
	262	BT_DBG("type 0x%x len %d", h->type, h->len);
8e87d142	263
1da177e4 LT	264	switch (h->type & BNEP_TYPE_MASK) {
	265	case BNEP_EXT_CONTROL:
	266	bnep_rx_control(s, skb->data, skb->len);
	267	break;
	268
	269	default:
	270	/* Unknown extension, skip it. */
	271	break;
	272	}
	273
	274	if (!skb_pull(skb, h->len)) {
	275	err = -EILSEQ;
	276	break;
	277	}
	278	} while (!err && (h->type & BNEP_EXT_HEADER));
8e87d142	279
1da177e4 LT	280	return err;
	281	}
	282
	283	static u8 __bnep_rx_hlen[] = {
	284	ETH_HLEN, /* BNEP_GENERAL */
	285	0, /* BNEP_CONTROL */
	286	2, /* BNEP_COMPRESSED */
	287	ETH_ALEN + 2, /* BNEP_COMPRESSED_SRC_ONLY */
	288	ETH_ALEN + 2 /* BNEP_COMPRESSED_DST_ONLY */
	289	};
1da177e4	290
6039aa73	291	static int bnep_rx_frame(struct bnep_session s, struct sk_buff skb)
1da177e4 LT	292	{
	293	struct net_device *dev = s->dev;
	294	struct sk_buff *nskb;
	295	u8 type;
	296
b4d7f0a4	297	dev->stats.rx_bytes += skb->len;
1da177e4	298
3aad75a1 SJ	299	type = (u8 ) skb->data;
3aad75a1 SJ	300	skb_pull(skb, 1);
1da177e4	301
a3d9bd4c	302	if ((type & BNEP_TYPE_MASK) >= sizeof(__bnep_rx_hlen))
1da177e4	303	goto badframe;
8e87d142	304
1da177e4 LT	305	if ((type & BNEP_TYPE_MASK) == BNEP_CONTROL) {
	306	bnep_rx_control(s, skb->data, skb->len);
	307	kfree_skb(skb);
	308	return 0;
	309	}
	310
459a98ed	311	skb_reset_mac_header(skb);
1da177e4 LT	312
	313	/* Verify and pull out header */
	314	if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK]))
	315	goto badframe;
	316
1bc5d448	317	s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
1da177e4 LT	318
	319	if (type & BNEP_EXT_HEADER) {
	320	if (bnep_rx_extension(s, skb) < 0)
	321	goto badframe;
	322	}
	323
	324	/* Strip 802.1p header */
000092b0	325	if (ntohs(s->eh.h_proto) == ETH_P_8021Q) {
1da177e4 LT	326	if (!skb_pull(skb, 4))
1da177e4 LT	327	goto badframe;
1bc5d448	328	s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
1da177e4	329	}
8e87d142	330
1da177e4 LT	331	/* We have to alloc new skb and copy data here :(. Because original skb
	332	* may not be modified and because of the alignment requirements. */
	333	nskb = alloc_skb(2 + ETH_HLEN + skb->len, GFP_KERNEL);
	334	if (!nskb) {
b4d7f0a4	335	dev->stats.rx_dropped++;
1da177e4 LT	336	kfree_skb(skb);
	337	return -ENOMEM;
	338	}
	339	skb_reserve(nskb, 2);
	340
	341	/* Decompress header and construct ether frame */
	342	switch (type & BNEP_TYPE_MASK) {
	343	case BNEP_COMPRESSED:
	344	memcpy(__skb_put(nskb, ETH_HLEN), &s->eh, ETH_HLEN);
	345	break;
8e87d142	346
1da177e4 LT	347	case BNEP_COMPRESSED_SRC_ONLY:
1da177e4 LT	348	memcpy(__skb_put(nskb, ETH_ALEN), s->eh.h_dest, ETH_ALEN);
98e399f8	349	memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb), ETH_ALEN);
1bc5d448	350	put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
1da177e4 LT	351	break;
	352
	353	case BNEP_COMPRESSED_DST_ONLY:
98e399f8	354	memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb),
3aad75a1	355	ETH_ALEN);
98e399f8	356	memcpy(__skb_put(nskb, ETH_ALEN + 2), s->eh.h_source,
3aad75a1	357	ETH_ALEN + 2);
1da177e4 LT	358	break;
	359
	360	case BNEP_GENERAL:
98e399f8	361	memcpy(__skb_put(nskb, ETH_ALEN * 2), skb_mac_header(skb),
3aad75a1	362	ETH_ALEN * 2);
1bc5d448	363	put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
1da177e4 LT	364	break;
	365	}
	366
d626f62b	367	skb_copy_from_linear_data(skb, __skb_put(nskb, skb->len), skb->len);
1da177e4	368	kfree_skb(skb);
8e87d142	369
b4d7f0a4	370	dev->stats.rx_packets++;
1da177e4 LT	371	nskb->ip_summed = CHECKSUM_NONE;
	372	nskb->protocol = eth_type_trans(nskb, dev);
	373	netif_rx_ni(nskb);
	374	return 0;
	375
	376	badframe:
b4d7f0a4	377	dev->stats.rx_errors++;
1da177e4 LT	378	kfree_skb(skb);
	379	return 0;
	380	}
	381
	382	static u8 __bnep_tx_types[] = {
	383	BNEP_GENERAL,
	384	BNEP_COMPRESSED_SRC_ONLY,
	385	BNEP_COMPRESSED_DST_ONLY,
	386	BNEP_COMPRESSED
	387	};
	388
6039aa73	389	static int bnep_tx_frame(struct bnep_session s, struct sk_buff skb)
1da177e4 LT	390	{
	391	struct ethhdr eh = (void ) skb->data;
	392	struct socket *sock = s->sock;
	393	struct kvec iv[3];
	394	int len = 0, il = 0;
	395	u8 type = 0;
	396
	397	BT_DBG("skb %p dev %p type %d", skb, skb->dev, skb->pkt_type);
	398
	399	if (!skb->dev) {
	400	/* Control frame sent by us */
	401	goto send;
	402	}
	403
	404	iv[il++] = (struct kvec) { &type, 1 };
	405	len++;
	406
c47fc981	407	if (compress_src && ether_addr_equal(eh->h_dest, s->eh.h_source))
1da177e4 LT	408	type \|= 0x01;
1da177e4 LT	409
c47fc981	410	if (compress_dst && ether_addr_equal(eh->h_source, s->eh.h_dest))
1da177e4 LT	411	type \|= 0x02;
	412
	413	if (type)
	414	skb_pull(skb, ETH_ALEN * 2);
	415
	416	type = __bnep_tx_types[type];
	417	switch (type) {
	418	case BNEP_COMPRESSED_SRC_ONLY:
	419	iv[il++] = (struct kvec) { eh->h_source, ETH_ALEN };
	420	len += ETH_ALEN;
	421	break;
8e87d142	422
1da177e4 LT	423	case BNEP_COMPRESSED_DST_ONLY:
	424	iv[il++] = (struct kvec) { eh->h_dest, ETH_ALEN };
	425	len += ETH_ALEN;
	426	break;
	427	}
	428
	429	send:
	430	iv[il++] = (struct kvec) { skb->data, skb->len };
	431	len += skb->len;
8e87d142	432
1da177e4 LT	433	/* FIXME: linearize skb */
	434	{
	435	len = kernel_sendmsg(sock, &s->msg, iv, il, len);
	436	}
	437	kfree_skb(skb);
	438
	439	if (len > 0) {
b4d7f0a4 SH	440	s->dev->stats.tx_bytes += len;
b4d7f0a4 SH	441	s->dev->stats.tx_packets++;
1da177e4 LT	442	return 0;
	443	}
	444
	445	return len;
	446	}
	447
	448	static int bnep_session(void *arg)
	449	{
	450	struct bnep_session *s = arg;
	451	struct net_device *dev = s->dev;
	452	struct sock *sk = s->sock->sk;
	453	struct sk_buff *skb;
	454	wait_queue_t wait;
	455
	456	BT_DBG("");
	457
1da177e4	458	set_user_nice(current, -15);
1da177e4 LT	459
1da177e4 LT	460	init_waitqueue_entry(&wait, current);
aa395145	461	add_wait_queue(sk_sleep(sk), &wait);
38d57555	462	while (1) {
1da177e4 LT	463	set_current_state(TASK_INTERRUPTIBLE);
1da177e4 LT	464
751c10a5	465	if (atomic_read(&s->terminate))
38d57555	466	break;
3aad75a1	467	/* RX */
1da177e4 LT	468	while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
1da177e4 LT	469	skb_orphan(skb);
44935720 MM	470	if (!skb_linearize(skb))
	471	bnep_rx_frame(s, skb);
	472	else
	473	kfree_skb(skb);
1da177e4 LT	474	}
	475
	476	if (sk->sk_state != BT_CONNECTED)
	477	break;
8e87d142	478
3aad75a1	479	/* TX */
1da177e4 LT	480	while ((skb = skb_dequeue(&sk->sk_write_queue)))
	481	if (bnep_tx_frame(s, skb))
	482	break;
	483	netif_wake_queue(dev);
8e87d142	484
1da177e4 LT	485	schedule();
1da177e4 LT	486	}
38d57555	487	__set_current_state(TASK_RUNNING);
aa395145	488	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	489
	490	/* Cleanup session */
	491	down_write(&bnep_session_sem);
	492
	493	/* Delete network device */
	494	unregister_netdev(dev);
	495
ec8dab36 MH	496	/* Wakeup user-space polling for socket errors */
	497	s->sock->sk->sk_err = EUNATCH;
	498
aa395145	499	wake_up_interruptible(sk_sleep(s->sock->sk));
ec8dab36	500
1da177e4 LT	501	/* Release the socket */
	502	fput(s->sock->file);
	503
	504	__bnep_unlink_session(s);
	505
	506	up_write(&bnep_session_sem);
	507	free_netdev(dev);
9b338c3d	508	module_put_and_exit(0);
1da177e4 LT	509	return 0;
	510	}
	511
0a85b964 MH	512	static struct device bnep_get_device(struct bnep_session session)
	513	{
	514	bdaddr_t *src = &bt_sk(session->sock->sk)->src;
	515	bdaddr_t *dst = &bt_sk(session->sock->sk)->dst;
	516	struct hci_dev *hdev;
	517	struct hci_conn *conn;
	518
	519	hdev = hci_get_route(dst, src);
	520	if (!hdev)
	521	return NULL;
	522
	523	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
0a85b964 MH	524
	525	hci_dev_put(hdev);
	526
b2cfcd75	527	return conn ? &conn->dev : NULL;
0a85b964 MH	528	}
0a85b964 MH	529
384912ed MH	530	static struct device_type bnep_type = {
	531	.name = "bluetooth",
	532	};
	533
1da177e4 LT	534	int bnep_add_connection(struct bnep_connadd_req req, struct socket sock)
	535	{
	536	struct net_device *dev;
	537	struct bnep_session s, ss;
	538	u8 dst[ETH_ALEN], src[ETH_ALEN];
	539	int err;
	540
	541	BT_DBG("");
	542
b8d57eb2 AV	543	if (!l2cap_is_socket(sock))
	544	return -EBADFD;
	545
1da177e4 LT	546	baswap((void *) dst, &bt_sk(sock->sk)->dst);
	547	baswap((void *) src, &bt_sk(sock->sk)->src);
	548
	549	/* session struct allocated as private part of net_device */
	550	dev = alloc_netdev(sizeof(struct bnep_session),
3aad75a1 SJ	551	(*req->device) ? req->device : "bnep%d",
3aad75a1 SJ	552	bnep_net_setup);
67b52e55 TK	553	if (!dev)
67b52e55 TK	554	return -ENOMEM;
1da177e4	555
1da177e4 LT	556	down_write(&bnep_session_sem);
	557
	558	ss = __bnep_get_session(dst);
	559	if (ss && ss->state == BT_CONNECTED) {
	560	err = -EEXIST;
	561	goto failed;
	562	}
	563
524ad0a7	564	s = netdev_priv(dev);
1da177e4 LT	565
1da177e4 LT	566	/* This is rx header therefore addresses are swapped.
3aad75a1	567	* ie. eh.h_dest is our local address. */
1da177e4 LT	568	memcpy(s->eh.h_dest, &src, ETH_ALEN);
	569	memcpy(s->eh.h_source, &dst, ETH_ALEN);
	570	memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);
	571
0a85b964	572	s->dev = dev;
1da177e4 LT	573	s->sock = sock;
	574	s->role = req->role;
	575	s->state = BT_CONNECTED;
8e87d142	576
1da177e4 LT	577	s->msg.msg_flags = MSG_NOSIGNAL;
	578
	579	#ifdef CONFIG_BT_BNEP_MC_FILTER
	580	/* Set default mc filter */
	581	set_bit(bnep_mc_hash(dev->broadcast), (ulong *) &s->mc_filter);
	582	#endif
	583
	584	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	585	/* Set default protocol filter */
	586	bnep_set_default_proto_filter(s);
	587	#endif
	588
0a85b964	589	SET_NETDEV_DEV(dev, bnep_get_device(s));
384912ed	590	SET_NETDEV_DEVTYPE(dev, &bnep_type);
0a85b964	591
1da177e4	592	err = register_netdev(dev);
3aad75a1	593	if (err)
1da177e4	594	goto failed;
1da177e4 LT	595
1da177e4 LT	596	__bnep_link_session(s);
8e87d142	597
9b338c3d	598	__module_get(THIS_MODULE);
f4d7cd4a SJ	599	s->task = kthread_run(bnep_session, s, "kbnepd %s", dev->name);
f4d7cd4a SJ	600	if (IS_ERR(s->task)) {
1da177e4	601	/* Session thread start failed, gotta cleanup. */
9b338c3d	602	module_put(THIS_MODULE);
1da177e4 LT	603	unregister_netdev(dev);
1da177e4 LT	604	__bnep_unlink_session(s);
f4d7cd4a	605	err = PTR_ERR(s->task);
1da177e4 LT	606	goto failed;
	607	}
	608
	609	up_write(&bnep_session_sem);
	610	strcpy(req->device, dev->name);
	611	return 0;
	612
	613	failed:
	614	up_write(&bnep_session_sem);
	615	free_netdev(dev);
	616	return err;
	617	}
	618
	619	int bnep_del_connection(struct bnep_conndel_req *req)
	620	{
	621	struct bnep_session *s;
	622	int err = 0;
	623
	624	BT_DBG("");
	625
	626	down_read(&bnep_session_sem);
	627
	628	s = __bnep_get_session(req->dst);
751c10a5 PH	629	if (s) {
	630	atomic_inc(&s->terminate);
	631	wake_up_process(s->task);
	632	} else
1da177e4 LT	633	err = -ENOENT;
	634
	635	up_read(&bnep_session_sem);
	636	return err;
	637	}
	638
	639	static void __bnep_copy_ci(struct bnep_conninfo ci, struct bnep_session s)
	640	{
5520d20f	641	memset(ci, 0, sizeof(*ci));
1da177e4 LT	642	memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
	643	strcpy(ci->device, s->dev->name);
	644	ci->flags = s->flags;
	645	ci->state = s->state;
	646	ci->role = s->role;
	647	}
	648
	649	int bnep_get_connlist(struct bnep_connlist_req *req)
	650	{
8035ded4	651	struct bnep_session *s;
1da177e4 LT	652	int err = 0, n = 0;
	653
	654	down_read(&bnep_session_sem);
	655
8035ded4	656	list_for_each_entry(s, &bnep_session_list, list) {
1da177e4 LT	657	struct bnep_conninfo ci;
1da177e4 LT	658
1da177e4	659	__bnep_copy_ci(&ci, s);
8e87d142	660
1da177e4 LT	661	if (copy_to_user(req->ci, &ci, sizeof(ci))) {
	662	err = -EFAULT;
	663	break;
	664	}
	665
	666	if (++n >= req->cnum)
	667	break;
	668
	669	req->ci++;
	670	}
	671	req->cnum = n;
	672
	673	up_read(&bnep_session_sem);
	674	return err;
	675	}
	676
	677	int bnep_get_conninfo(struct bnep_conninfo *ci)
	678	{
	679	struct bnep_session *s;
	680	int err = 0;
	681
	682	down_read(&bnep_session_sem);
	683
	684	s = __bnep_get_session(ci->dst);
	685	if (s)
	686	__bnep_copy_ci(ci, s);
	687	else
	688	err = -ENOENT;
	689
	690	up_read(&bnep_session_sem);
	691	return err;
	692	}
	693
	694	static int __init bnep_init(void)
8e87d142	695	{
1da177e4 LT	696	char flt[50] = "";
1da177e4 LT	697
1da177e4 LT	698	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	699	strcat(flt, "protocol ");
	700	#endif
	701
	702	#ifdef CONFIG_BT_BNEP_MC_FILTER
	703	strcat(flt, "multicast");
	704	#endif
	705
	706	BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION);
	707	if (flt[0])
	708	BT_INFO("BNEP filters: %s", flt);
	709
	710	bnep_sock_init();
	711	return 0;
	712	}
	713
	714	static void __exit bnep_exit(void)
	715	{
	716	bnep_sock_cleanup();
	717	}
	718
	719	module_init(bnep_init);
	720	module_exit(bnep_exit);
	721
28111eb2 MH	722	module_param(compress_src, bool, 0644);
	723	MODULE_PARM_DESC(compress_src, "Compress sources headers");
	724
	725	module_param(compress_dst, bool, 0644);
	726	MODULE_PARM_DESC(compress_dst, "Compress destination headers");
	727
63fbd24e	728	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	729	MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION);
	730	MODULE_VERSION(VERSION);
	731	MODULE_LICENSE("GPL");
	732	MODULE_ALIAS("bt-proto-4");