[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/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("");

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