[linux-2.6-block.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/hci_core.h>
#include <net/bluetooth/l2cap.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 %s -> %s",
				batostr((void *) a1), batostr((void *) 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("");

	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>
0a85b964	35	#include <net/bluetooth/hci_core.h>
1da177e4 LT	36	#include <net/bluetooth/l2cap.h>
	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
1da177e4 LT	185	BT_DBG("mc filter %s -> %s",
	186	batostr((void ) a1), batostr((void ) a2));
	187
1da177e4 LT	188	/* Iterate from a1 to a2 */
	189	set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
	190	while (memcmp(a1, a2, 6) < 0 && s->mc_filter != ~0LL) {
a3d9bd4c SJ	191	/* Increment a1 */
	192	i = 5;
	193	while (i >= 0 && ++a1[i--] == 0)
	194	;
	195
1da177e4 LT	196	set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
	197	}
	198	}
	199	}
	200
	201	BT_DBG("mc filter hash 0x%llx", s->mc_filter);
	202
	203	bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_SUCCESS);
	204	#else
	205	bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
	206	#endif
	207	return 0;
	208	}
	209
	210	static int bnep_rx_control(struct bnep_session s, void data, int len)
	211	{
	212	u8 cmd = (u8 )data;
	213	int err = 0;
	214
3aad75a1 SJ	215	data++;
3aad75a1 SJ	216	len--;
1da177e4 LT	217
	218	switch (cmd) {
	219	case BNEP_CMD_NOT_UNDERSTOOD:
1da177e4 LT	220	case BNEP_SETUP_CONN_RSP:
	221	case BNEP_FILTER_NET_TYPE_RSP:
	222	case BNEP_FILTER_MULTI_ADDR_RSP:
	223	/* Ignore these for now */
	224	break;
	225
	226	case BNEP_FILTER_NET_TYPE_SET:
	227	err = bnep_ctrl_set_netfilter(s, data, len);
	228	break;
	229
	230	case BNEP_FILTER_MULTI_ADDR_SET:
	231	err = bnep_ctrl_set_mcfilter(s, data, len);
	232	break;
	233
cde9f807 VK	234	case BNEP_SETUP_CONN_REQ:
	235	err = bnep_send_rsp(s, BNEP_SETUP_CONN_RSP, BNEP_CONN_NOT_ALLOWED);
	236	break;
	237
1da177e4 LT	238	default: {
	239	u8 pkt[3];
	240	pkt[0] = BNEP_CONTROL;
	241	pkt[1] = BNEP_CMD_NOT_UNDERSTOOD;
	242	pkt[2] = cmd;
	243	bnep_send(s, pkt, sizeof(pkt));
	244	}
	245	break;
	246	}
	247
	248	return err;
	249	}
	250
	251	static int bnep_rx_extension(struct bnep_session s, struct sk_buff skb)
	252	{
	253	struct bnep_ext_hdr *h;
	254	int err = 0;
	255
	256	do {
	257	h = (void *) skb->data;
	258	if (!skb_pull(skb, sizeof(*h))) {
	259	err = -EILSEQ;
	260	break;
	261	}
	262
	263	BT_DBG("type 0x%x len %d", h->type, h->len);
8e87d142	264
1da177e4 LT	265	switch (h->type & BNEP_TYPE_MASK) {
	266	case BNEP_EXT_CONTROL:
	267	bnep_rx_control(s, skb->data, skb->len);
	268	break;
	269
	270	default:
	271	/* Unknown extension, skip it. */
	272	break;
	273	}
	274
	275	if (!skb_pull(skb, h->len)) {
	276	err = -EILSEQ;
	277	break;
	278	}
	279	} while (!err && (h->type & BNEP_EXT_HEADER));
8e87d142	280
1da177e4 LT	281	return err;
	282	}
	283
	284	static u8 __bnep_rx_hlen[] = {
	285	ETH_HLEN, /* BNEP_GENERAL */
	286	0, /* BNEP_CONTROL */
	287	2, /* BNEP_COMPRESSED */
	288	ETH_ALEN + 2, /* BNEP_COMPRESSED_SRC_ONLY */
	289	ETH_ALEN + 2 /* BNEP_COMPRESSED_DST_ONLY */
	290	};
1da177e4	291
6039aa73	292	static int bnep_rx_frame(struct bnep_session s, struct sk_buff skb)
1da177e4 LT	293	{
	294	struct net_device *dev = s->dev;
	295	struct sk_buff *nskb;
	296	u8 type;
	297
b4d7f0a4	298	dev->stats.rx_bytes += skb->len;
1da177e4	299
3aad75a1 SJ	300	type = (u8 ) skb->data;
3aad75a1 SJ	301	skb_pull(skb, 1);
1da177e4	302
a3d9bd4c	303	if ((type & BNEP_TYPE_MASK) >= sizeof(__bnep_rx_hlen))
1da177e4	304	goto badframe;
8e87d142	305
1da177e4 LT	306	if ((type & BNEP_TYPE_MASK) == BNEP_CONTROL) {
	307	bnep_rx_control(s, skb->data, skb->len);
	308	kfree_skb(skb);
	309	return 0;
	310	}
	311
459a98ed	312	skb_reset_mac_header(skb);
1da177e4 LT	313
	314	/* Verify and pull out header */
	315	if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK]))
	316	goto badframe;
	317
1bc5d448	318	s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
1da177e4 LT	319
	320	if (type & BNEP_EXT_HEADER) {
	321	if (bnep_rx_extension(s, skb) < 0)
	322	goto badframe;
	323	}
	324
	325	/* Strip 802.1p header */
000092b0	326	if (ntohs(s->eh.h_proto) == ETH_P_8021Q) {
1da177e4 LT	327	if (!skb_pull(skb, 4))
1da177e4 LT	328	goto badframe;
1bc5d448	329	s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
1da177e4	330	}
8e87d142	331
1da177e4 LT	332	/* We have to alloc new skb and copy data here :(. Because original skb
	333	* may not be modified and because of the alignment requirements. */
	334	nskb = alloc_skb(2 + ETH_HLEN + skb->len, GFP_KERNEL);
	335	if (!nskb) {
b4d7f0a4	336	dev->stats.rx_dropped++;
1da177e4 LT	337	kfree_skb(skb);
	338	return -ENOMEM;
	339	}
	340	skb_reserve(nskb, 2);
	341
	342	/* Decompress header and construct ether frame */
	343	switch (type & BNEP_TYPE_MASK) {
	344	case BNEP_COMPRESSED:
	345	memcpy(__skb_put(nskb, ETH_HLEN), &s->eh, ETH_HLEN);
	346	break;
8e87d142	347
1da177e4 LT	348	case BNEP_COMPRESSED_SRC_ONLY:
1da177e4 LT	349	memcpy(__skb_put(nskb, ETH_ALEN), s->eh.h_dest, ETH_ALEN);
98e399f8	350	memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb), ETH_ALEN);
1bc5d448	351	put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
1da177e4 LT	352	break;
	353
	354	case BNEP_COMPRESSED_DST_ONLY:
98e399f8	355	memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb),
3aad75a1	356	ETH_ALEN);
98e399f8	357	memcpy(__skb_put(nskb, ETH_ALEN + 2), s->eh.h_source,
3aad75a1	358	ETH_ALEN + 2);
1da177e4 LT	359	break;
	360
	361	case BNEP_GENERAL:
98e399f8	362	memcpy(__skb_put(nskb, ETH_ALEN * 2), skb_mac_header(skb),
3aad75a1	363	ETH_ALEN * 2);
1bc5d448	364	put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
1da177e4 LT	365	break;
	366	}
	367
d626f62b	368	skb_copy_from_linear_data(skb, __skb_put(nskb, skb->len), skb->len);
1da177e4	369	kfree_skb(skb);
8e87d142	370
b4d7f0a4	371	dev->stats.rx_packets++;
1da177e4 LT	372	nskb->ip_summed = CHECKSUM_NONE;
	373	nskb->protocol = eth_type_trans(nskb, dev);
	374	netif_rx_ni(nskb);
	375	return 0;
	376
	377	badframe:
b4d7f0a4	378	dev->stats.rx_errors++;
1da177e4 LT	379	kfree_skb(skb);
	380	return 0;
	381	}
	382
	383	static u8 __bnep_tx_types[] = {
	384	BNEP_GENERAL,
	385	BNEP_COMPRESSED_SRC_ONLY,
	386	BNEP_COMPRESSED_DST_ONLY,
	387	BNEP_COMPRESSED
	388	};
	389
6039aa73	390	static int bnep_tx_frame(struct bnep_session s, struct sk_buff skb)
1da177e4 LT	391	{
	392	struct ethhdr eh = (void ) skb->data;
	393	struct socket *sock = s->sock;
	394	struct kvec iv[3];
	395	int len = 0, il = 0;
	396	u8 type = 0;
	397
	398	BT_DBG("skb %p dev %p type %d", skb, skb->dev, skb->pkt_type);
	399
	400	if (!skb->dev) {
	401	/* Control frame sent by us */
	402	goto send;
	403	}
	404
	405	iv[il++] = (struct kvec) { &type, 1 };
	406	len++;
	407
c47fc981	408	if (compress_src && ether_addr_equal(eh->h_dest, s->eh.h_source))
1da177e4 LT	409	type \|= 0x01;
1da177e4 LT	410
c47fc981	411	if (compress_dst && ether_addr_equal(eh->h_source, s->eh.h_dest))
1da177e4 LT	412	type \|= 0x02;
	413
	414	if (type)
	415	skb_pull(skb, ETH_ALEN * 2);
	416
	417	type = __bnep_tx_types[type];
	418	switch (type) {
	419	case BNEP_COMPRESSED_SRC_ONLY:
	420	iv[il++] = (struct kvec) { eh->h_source, ETH_ALEN };
	421	len += ETH_ALEN;
	422	break;
8e87d142	423
1da177e4 LT	424	case BNEP_COMPRESSED_DST_ONLY:
	425	iv[il++] = (struct kvec) { eh->h_dest, ETH_ALEN };
	426	len += ETH_ALEN;
	427	break;
	428	}
	429
	430	send:
	431	iv[il++] = (struct kvec) { skb->data, skb->len };
	432	len += skb->len;
8e87d142	433
1da177e4 LT	434	/* FIXME: linearize skb */
	435	{
	436	len = kernel_sendmsg(sock, &s->msg, iv, il, len);
	437	}
	438	kfree_skb(skb);
	439
	440	if (len > 0) {
b4d7f0a4 SH	441	s->dev->stats.tx_bytes += len;
b4d7f0a4 SH	442	s->dev->stats.tx_packets++;
1da177e4 LT	443	return 0;
	444	}
	445
	446	return len;
	447	}
	448
	449	static int bnep_session(void *arg)
	450	{
	451	struct bnep_session *s = arg;
	452	struct net_device *dev = s->dev;
	453	struct sock *sk = s->sock->sk;
	454	struct sk_buff *skb;
	455	wait_queue_t wait;
	456
	457	BT_DBG("");
	458
1da177e4	459	set_user_nice(current, -15);
1da177e4 LT	460
1da177e4 LT	461	init_waitqueue_entry(&wait, current);
aa395145	462	add_wait_queue(sk_sleep(sk), &wait);
38d57555	463	while (1) {
1da177e4 LT	464	set_current_state(TASK_INTERRUPTIBLE);
1da177e4 LT	465
751c10a5	466	if (atomic_read(&s->terminate))
38d57555	467	break;
3aad75a1	468	/* RX */
1da177e4 LT	469	while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
1da177e4 LT	470	skb_orphan(skb);
44935720 MM	471	if (!skb_linearize(skb))
	472	bnep_rx_frame(s, skb);
	473	else
	474	kfree_skb(skb);
1da177e4 LT	475	}
	476
	477	if (sk->sk_state != BT_CONNECTED)
	478	break;
8e87d142	479
3aad75a1	480	/* TX */
1da177e4 LT	481	while ((skb = skb_dequeue(&sk->sk_write_queue)))
	482	if (bnep_tx_frame(s, skb))
	483	break;
	484	netif_wake_queue(dev);
8e87d142	485
1da177e4 LT	486	schedule();
1da177e4 LT	487	}
38d57555	488	__set_current_state(TASK_RUNNING);
aa395145	489	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	490
	491	/* Cleanup session */
	492	down_write(&bnep_session_sem);
	493
	494	/* Delete network device */
	495	unregister_netdev(dev);
	496
ec8dab36 MH	497	/* Wakeup user-space polling for socket errors */
	498	s->sock->sk->sk_err = EUNATCH;
	499
aa395145	500	wake_up_interruptible(sk_sleep(s->sock->sk));
ec8dab36	501
1da177e4 LT	502	/* Release the socket */
	503	fput(s->sock->file);
	504
	505	__bnep_unlink_session(s);
	506
	507	up_write(&bnep_session_sem);
	508	free_netdev(dev);
9b338c3d	509	module_put_and_exit(0);
1da177e4 LT	510	return 0;
	511	}
	512
0a85b964 MH	513	static struct device bnep_get_device(struct bnep_session session)
	514	{
	515	bdaddr_t *src = &bt_sk(session->sock->sk)->src;
	516	bdaddr_t *dst = &bt_sk(session->sock->sk)->dst;
	517	struct hci_dev *hdev;
	518	struct hci_conn *conn;
	519
	520	hdev = hci_get_route(dst, src);
	521	if (!hdev)
	522	return NULL;
	523
	524	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
0a85b964 MH	525
	526	hci_dev_put(hdev);
	527
b2cfcd75	528	return conn ? &conn->dev : NULL;
0a85b964 MH	529	}
0a85b964 MH	530
384912ed MH	531	static struct device_type bnep_type = {
	532	.name = "bluetooth",
	533	};
	534
1da177e4 LT	535	int bnep_add_connection(struct bnep_connadd_req req, struct socket sock)
	536	{
	537	struct net_device *dev;
	538	struct bnep_session s, ss;
	539	u8 dst[ETH_ALEN], src[ETH_ALEN];
	540	int err;
	541
	542	BT_DBG("");
	543
	544	baswap((void *) dst, &bt_sk(sock->sk)->dst);
	545	baswap((void *) src, &bt_sk(sock->sk)->src);
	546
	547	/* session struct allocated as private part of net_device */
	548	dev = alloc_netdev(sizeof(struct bnep_session),
3aad75a1 SJ	549	(*req->device) ? req->device : "bnep%d",
3aad75a1 SJ	550	bnep_net_setup);
67b52e55 TK	551	if (!dev)
67b52e55 TK	552	return -ENOMEM;
1da177e4	553
1da177e4 LT	554	down_write(&bnep_session_sem);
	555
	556	ss = __bnep_get_session(dst);
	557	if (ss && ss->state == BT_CONNECTED) {
	558	err = -EEXIST;
	559	goto failed;
	560	}
	561
524ad0a7	562	s = netdev_priv(dev);
1da177e4 LT	563
1da177e4 LT	564	/* This is rx header therefore addresses are swapped.
3aad75a1	565	* ie. eh.h_dest is our local address. */
1da177e4 LT	566	memcpy(s->eh.h_dest, &src, ETH_ALEN);
	567	memcpy(s->eh.h_source, &dst, ETH_ALEN);
	568	memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);
	569
0a85b964	570	s->dev = dev;
1da177e4 LT	571	s->sock = sock;
	572	s->role = req->role;
	573	s->state = BT_CONNECTED;
8e87d142	574
1da177e4 LT	575	s->msg.msg_flags = MSG_NOSIGNAL;
	576
	577	#ifdef CONFIG_BT_BNEP_MC_FILTER
	578	/* Set default mc filter */
	579	set_bit(bnep_mc_hash(dev->broadcast), (ulong *) &s->mc_filter);
	580	#endif
	581
	582	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	583	/* Set default protocol filter */
	584	bnep_set_default_proto_filter(s);
	585	#endif
	586
0a85b964	587	SET_NETDEV_DEV(dev, bnep_get_device(s));
384912ed	588	SET_NETDEV_DEVTYPE(dev, &bnep_type);
0a85b964	589
1da177e4	590	err = register_netdev(dev);
3aad75a1	591	if (err)
1da177e4	592	goto failed;
1da177e4 LT	593
1da177e4 LT	594	__bnep_link_session(s);
8e87d142	595
9b338c3d	596	__module_get(THIS_MODULE);
f4d7cd4a SJ	597	s->task = kthread_run(bnep_session, s, "kbnepd %s", dev->name);
f4d7cd4a SJ	598	if (IS_ERR(s->task)) {
1da177e4	599	/* Session thread start failed, gotta cleanup. */
9b338c3d	600	module_put(THIS_MODULE);
1da177e4 LT	601	unregister_netdev(dev);
1da177e4 LT	602	__bnep_unlink_session(s);
f4d7cd4a	603	err = PTR_ERR(s->task);
1da177e4 LT	604	goto failed;
	605	}
	606
	607	up_write(&bnep_session_sem);
	608	strcpy(req->device, dev->name);
	609	return 0;
	610
	611	failed:
	612	up_write(&bnep_session_sem);
	613	free_netdev(dev);
	614	return err;
	615	}
	616
	617	int bnep_del_connection(struct bnep_conndel_req *req)
	618	{
	619	struct bnep_session *s;
	620	int err = 0;
	621
	622	BT_DBG("");
	623
	624	down_read(&bnep_session_sem);
	625
	626	s = __bnep_get_session(req->dst);
751c10a5 PH	627	if (s) {
	628	atomic_inc(&s->terminate);
	629	wake_up_process(s->task);
	630	} else
1da177e4 LT	631	err = -ENOENT;
	632
	633	up_read(&bnep_session_sem);
	634	return err;
	635	}
	636
	637	static void __bnep_copy_ci(struct bnep_conninfo ci, struct bnep_session s)
	638	{
5520d20f	639	memset(ci, 0, sizeof(*ci));
1da177e4 LT	640	memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
	641	strcpy(ci->device, s->dev->name);
	642	ci->flags = s->flags;
	643	ci->state = s->state;
	644	ci->role = s->role;
	645	}
	646
	647	int bnep_get_connlist(struct bnep_connlist_req *req)
	648	{
8035ded4	649	struct bnep_session *s;
1da177e4 LT	650	int err = 0, n = 0;
	651
	652	down_read(&bnep_session_sem);
	653
8035ded4	654	list_for_each_entry(s, &bnep_session_list, list) {
1da177e4 LT	655	struct bnep_conninfo ci;
1da177e4 LT	656
1da177e4	657	__bnep_copy_ci(&ci, s);
8e87d142	658
1da177e4 LT	659	if (copy_to_user(req->ci, &ci, sizeof(ci))) {
	660	err = -EFAULT;
	661	break;
	662	}
	663
	664	if (++n >= req->cnum)
	665	break;
	666
	667	req->ci++;
	668	}
	669	req->cnum = n;
	670
	671	up_read(&bnep_session_sem);
	672	return err;
	673	}
	674
	675	int bnep_get_conninfo(struct bnep_conninfo *ci)
	676	{
	677	struct bnep_session *s;
	678	int err = 0;
	679
	680	down_read(&bnep_session_sem);
	681
	682	s = __bnep_get_session(ci->dst);
	683	if (s)
	684	__bnep_copy_ci(ci, s);
	685	else
	686	err = -ENOENT;
	687
	688	up_read(&bnep_session_sem);
	689	return err;
	690	}
	691
	692	static int __init bnep_init(void)
8e87d142	693	{
1da177e4 LT	694	char flt[50] = "";
1da177e4 LT	695
1da177e4 LT	696	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	697	strcat(flt, "protocol ");
	698	#endif
	699
	700	#ifdef CONFIG_BT_BNEP_MC_FILTER
	701	strcat(flt, "multicast");
	702	#endif
	703
	704	BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION);
	705	if (flt[0])
	706	BT_INFO("BNEP filters: %s", flt);
	707
	708	bnep_sock_init();
	709	return 0;
	710	}
	711
	712	static void __exit bnep_exit(void)
	713	{
	714	bnep_sock_cleanup();
	715	}
	716
	717	module_init(bnep_init);
	718	module_exit(bnep_exit);
	719
28111eb2 MH	720	module_param(compress_src, bool, 0644);
	721	MODULE_PARM_DESC(compress_src, "Compress sources headers");
	722
	723	module_param(compress_dst, bool, 0644);
	724	MODULE_PARM_DESC(compress_dst, "Compress destination headers");
	725
63fbd24e	726	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	727	MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION);
	728	MODULE_VERSION(VERSION);
	729	MODULE_LICENSE("GPL");
	730	MODULE_ALIAS("bt-proto-4");