[deliverable/linux.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;
			err = 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)
{
	struct l2cap_conn *conn = l2cap_pi(session->sock->sk)->chan->conn;

	if (!conn || !conn->hcon)
		return NULL;

	return &conn->hcon->dev;
}

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

int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
{
	u32 valid_flags = 0;
	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;

	if (req->flags & ~valid_flags)
		return -EINVAL;

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

	/* session struct allocated as private part of net_device */
	dev = alloc_netdev(sizeof(struct bnep_session),
			   (*req->device) ? req->device : "bnep%d",
			   NET_NAME_UNKNOWN,
			   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)
{
	u32 valid_flags = 0;
	struct bnep_session *s;
	int  err = 0;

	BT_DBG("");

	if (req->flags & ~valid_flags)
		return -EINVAL;

	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)
{
	u32 valid_flags = 0;

	memset(ci, 0, sizeof(*ci));
	memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
	strcpy(ci->device, s->dev->name);
	ci->flags = s->flags & valid_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>
65f53e98	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;
e0fdbab1	242	err = bnep_send(s, pkt, sizeof(pkt));
1da177e4 LT	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)
0a85b964 MH	513	{
88d9077c	514	struct l2cap_conn *conn = l2cap_pi(session->sock->sk)->chan->conn;
0a85b964	515
88d9077c	516	if (!conn \|\| !conn->hcon)
0a85b964 MH	517	return NULL;
0a85b964 MH	518
88d9077c	519	return &conn->hcon->dev;
0a85b964 MH	520	}
0a85b964 MH	521
384912ed MH	522	static struct device_type bnep_type = {
	523	.name = "bluetooth",
	524	};
	525
1da177e4 LT	526	int bnep_add_connection(struct bnep_connadd_req req, struct socket sock)
1da177e4 LT	527	{
0151e426	528	u32 valid_flags = 0;
1da177e4 LT	529	struct net_device *dev;
	530	struct bnep_session s, ss;
	531	u8 dst[ETH_ALEN], src[ETH_ALEN];
	532	int err;
	533
	534	BT_DBG("");
	535
71bb99a0 AV	536	if (!l2cap_is_socket(sock))
	537	return -EBADFD;
	538
0151e426 MH	539	if (req->flags & ~valid_flags)
	540	return -EINVAL;
	541
65f53e98 MH	542	baswap((void *) dst, &l2cap_pi(sock->sk)->chan->dst);
65f53e98 MH	543	baswap((void *) src, &l2cap_pi(sock->sk)->chan->src);
1da177e4 LT	544
	545	/* session struct allocated as private part of net_device */
	546	dev = alloc_netdev(sizeof(struct bnep_session),
c835a677 TG	547	(*req->device) ? req->device : "bnep%d",
	548	NET_NAME_UNKNOWN,
	549	bnep_net_setup);
67b52e55 TK	550	if (!dev)
67b52e55 TK	551	return -ENOMEM;
1da177e4	552
1da177e4 LT	553	down_write(&bnep_session_sem);
	554
	555	ss = __bnep_get_session(dst);
	556	if (ss && ss->state == BT_CONNECTED) {
	557	err = -EEXIST;
	558	goto failed;
	559	}
	560
524ad0a7	561	s = netdev_priv(dev);
1da177e4 LT	562
1da177e4 LT	563	/* This is rx header therefore addresses are swapped.
3aad75a1	564	* ie. eh.h_dest is our local address. */
1da177e4 LT	565	memcpy(s->eh.h_dest, &src, ETH_ALEN);
	566	memcpy(s->eh.h_source, &dst, ETH_ALEN);
	567	memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);
	568
0a85b964	569	s->dev = dev;
1da177e4 LT	570	s->sock = sock;
	571	s->role = req->role;
	572	s->state = BT_CONNECTED;
8e87d142	573
1da177e4 LT	574	s->msg.msg_flags = MSG_NOSIGNAL;
	575
	576	#ifdef CONFIG_BT_BNEP_MC_FILTER
	577	/* Set default mc filter */
	578	set_bit(bnep_mc_hash(dev->broadcast), (ulong *) &s->mc_filter);
	579	#endif
	580
	581	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	582	/* Set default protocol filter */
	583	bnep_set_default_proto_filter(s);
	584	#endif
	585
0a85b964	586	SET_NETDEV_DEV(dev, bnep_get_device(s));
384912ed	587	SET_NETDEV_DEVTYPE(dev, &bnep_type);
0a85b964	588
1da177e4	589	err = register_netdev(dev);
3aad75a1	590	if (err)
1da177e4	591	goto failed;
1da177e4 LT	592
1da177e4 LT	593	__bnep_link_session(s);
8e87d142	594
9b338c3d	595	__module_get(THIS_MODULE);
f4d7cd4a SJ	596	s->task = kthread_run(bnep_session, s, "kbnepd %s", dev->name);
f4d7cd4a SJ	597	if (IS_ERR(s->task)) {
1da177e4	598	/* Session thread start failed, gotta cleanup. */
9b338c3d	599	module_put(THIS_MODULE);
1da177e4 LT	600	unregister_netdev(dev);
1da177e4 LT	601	__bnep_unlink_session(s);
f4d7cd4a	602	err = PTR_ERR(s->task);
1da177e4 LT	603	goto failed;
	604	}
	605
	606	up_write(&bnep_session_sem);
	607	strcpy(req->device, dev->name);
	608	return 0;
	609
	610	failed:
	611	up_write(&bnep_session_sem);
	612	free_netdev(dev);
	613	return err;
	614	}
	615
	616	int bnep_del_connection(struct bnep_conndel_req *req)
	617	{
0151e426	618	u32 valid_flags = 0;
1da177e4 LT	619	struct bnep_session *s;
	620	int err = 0;
	621
	622	BT_DBG("");
	623
0151e426 MH	624	if (req->flags & ~valid_flags)
	625	return -EINVAL;
	626
1da177e4 LT	627	down_read(&bnep_session_sem);
	628
	629	s = __bnep_get_session(req->dst);
751c10a5 PH	630	if (s) {
	631	atomic_inc(&s->terminate);
	632	wake_up_process(s->task);
	633	} else
1da177e4 LT	634	err = -ENOENT;
	635
	636	up_read(&bnep_session_sem);
	637	return err;
	638	}
	639
	640	static void __bnep_copy_ci(struct bnep_conninfo ci, struct bnep_session s)
	641	{
0151e426 MH	642	u32 valid_flags = 0;
0151e426 MH	643
5520d20f	644	memset(ci, 0, sizeof(*ci));
1da177e4 LT	645	memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
1da177e4 LT	646	strcpy(ci->device, s->dev->name);
0151e426	647	ci->flags = s->flags & valid_flags;
1da177e4 LT	648	ci->state = s->state;
	649	ci->role = s->role;
	650	}
	651
	652	int bnep_get_connlist(struct bnep_connlist_req *req)
	653	{
8035ded4	654	struct bnep_session *s;
1da177e4 LT	655	int err = 0, n = 0;
	656
	657	down_read(&bnep_session_sem);
	658
8035ded4	659	list_for_each_entry(s, &bnep_session_list, list) {
1da177e4 LT	660	struct bnep_conninfo ci;
1da177e4 LT	661
1da177e4	662	__bnep_copy_ci(&ci, s);
8e87d142	663
1da177e4 LT	664	if (copy_to_user(req->ci, &ci, sizeof(ci))) {
	665	err = -EFAULT;
	666	break;
	667	}
	668
	669	if (++n >= req->cnum)
	670	break;
	671
	672	req->ci++;
	673	}
	674	req->cnum = n;
	675
	676	up_read(&bnep_session_sem);
	677	return err;
	678	}
	679
	680	int bnep_get_conninfo(struct bnep_conninfo *ci)
	681	{
	682	struct bnep_session *s;
	683	int err = 0;
	684
	685	down_read(&bnep_session_sem);
	686
	687	s = __bnep_get_session(ci->dst);
	688	if (s)
	689	__bnep_copy_ci(ci, s);
	690	else
	691	err = -ENOENT;
	692
	693	up_read(&bnep_session_sem);
	694	return err;
	695	}
	696
	697	static int __init bnep_init(void)
8e87d142	698	{
1da177e4 LT	699	char flt[50] = "";
1da177e4 LT	700
1da177e4 LT	701	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	702	strcat(flt, "protocol ");
	703	#endif
	704
	705	#ifdef CONFIG_BT_BNEP_MC_FILTER
	706	strcat(flt, "multicast");
	707	#endif
	708
	709	BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION);
	710	if (flt[0])
	711	BT_INFO("BNEP filters: %s", flt);
	712
	713	bnep_sock_init();
	714	return 0;
	715	}
	716
	717	static void __exit bnep_exit(void)
	718	{
	719	bnep_sock_cleanup();
	720	}
	721
	722	module_init(bnep_init);
	723	module_exit(bnep_exit);
	724
28111eb2 MH	725	module_param(compress_src, bool, 0644);
	726	MODULE_PARM_DESC(compress_src, "Compress sources headers");
	727
	728	module_param(compress_dst, bool, 0644);
	729	MODULE_PARM_DESC(compress_dst, "Compress destination headers");
	730
63fbd24e	731	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	732	MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION);
	733	MODULE_VERSION(VERSION);
	734	MODULE_LICENSE("GPL");
	735	MODULE_ALIAS("bt-proto-4");