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

	daemonize("kbnepd %s", dev->name);
	set_user_nice(current, -15);

	init_waitqueue_entry(&wait, current);
	add_wait_queue(sk_sleep(sk), &wait);
	while (!atomic_read(&s->killed)) {
		set_current_state(TASK_INTERRUPTIBLE);

		/* RX */
		while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
			skb_orphan(skb);
			bnep_rx_frame(s, 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);

	err = kernel_thread(bnep_session, s, CLONE_KERNEL);
	if (err < 0) {
		/* Session thread start failed, gotta cleanup. */
		unregister_netdev(dev);
		__bnep_unlink_session(s);
		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) {
		/* Wakeup user-space which is polling for socket errors.
		 * This is temporary hack until we have shutdown in L2CAP */
		s->sock->sk->sk_err = EUNATCH;

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