[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/kernel.h>
#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/init.h>
#include <linux/wait.h>
#include <linux/freezer.h>
#include <linux/errno.h>
#include <linux/net.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <net/sock.h>

#include <linux/socket.h>
#include <linux/file.h>

#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.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 int compress_src = 1;
static int compress_dst = 1;

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;
	struct list_head *p;

	BT_DBG("");

	list_for_each(p, &bnep_session_list) {
		s = list_entry(p, struct bnep_session, list);
		if (!compare_ether_addr(dst, s->eh.h_source))
			return s;
	}
	return NULL;
}

static void __bnep_link_session(struct bnep_session *s)
{
	/* It's safe to call __module_get() here because sessions are added
	   by the socket layer which has to hold the reference to this module.
	 */
	__module_get(THIS_MODULE);
	list_add(&s->list, &bnep_session_list);
}

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

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 inline 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) == 0x8100) {
		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 inline 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 && !compare_ether_addr(eh->h_dest, s->eh.h_source))
		type |= 0x01;

	if (compress_dst && !compare_ether_addr(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);
	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);

	s->task = kthread_run(bnep_session, s, "kbnepd %s", dev->name);
	if (IS_ERR(s->task)) {
		/* Session thread start failed, gotta cleanup. */
		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 list_head *p;
	int err = 0, n = 0;

	down_read(&bnep_session_sem);

	list_for_each(p, &bnep_session_list) {
		struct bnep_session *s;
		struct bnep_conninfo ci;

		s = list_entry(p, struct bnep_session, list);

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