[linux-block.git] / net / bluetooth / bnep / core.c

/*
   BNEP implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2001-2002 Inventel Systemes
   Written 2001-2002 by
	Clément Moreau <clement.moreau@inventel.fr>
	David Libault  <david.libault@inventel.fr>

   Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

/*
 * $Id: core.c,v 1.20 2002/08/04 21:23:58 maxk Exp $
 */

#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 <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"

#ifndef CONFIG_BT_BNEP_DEBUG
#undef  BT_DBG
#define BT_DBG(D...)
#endif

#define VERSION "1.2"

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 refference 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 = ntohs(get_unaligned(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 = ntohs(get_unaligned(data++));
			f[i].end   = ntohs(get_unaligned(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 = ntohs(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) {
		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));

			#define INCA(a) { int i = 5; while (i >=0 && ++a[i--] == 0); }

			/* 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) {
				INCA(a1);
				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_REQ:
	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;

	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 */
};
#define BNEP_RX_TYPES	(sizeof(__bnep_rx_hlen) - 1)

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->last_rx = jiffies;
	s->stats.rx_bytes += skb->len;

	type = *(u8 *) skb->data; skb_pull(skb, 1);

	if ((type & BNEP_TYPE_MASK) > BNEP_RX_TYPES)
		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) {
		s->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);

	s->stats.rx_packets++;
	nskb->ip_summed = CHECKSUM_NONE;
	nskb->protocol  = eth_type_trans(nskb, dev);
	netif_rx_ni(nskb);
	return 0;

badframe:
	s->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 (!compare_ether_addr(eh->h_dest, s->eh.h_source))
		type |= 0x01;

	if (!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->stats.tx_bytes += len;
		s->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->sk_sleep, &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->sk_sleep, &wait);

	/* Cleanup session */
	down_write(&bnep_session_sem);

	/* Delete network device */
	unregister_netdev(dev);

	/* 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;
}

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 = dev->priv;

	/* 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));

	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 untill we have shutdown in L2CAP */
		s->sock->sk->sk_err = EUNATCH;

		/* Kill session thread */
		atomic_inc(&s->killed);
		wake_up_interruptible(s->sock->sk->sk_sleep);
	} else
		err = -ENOENT;

	up_read(&bnep_session_sem);
	return err;
}

static void __bnep_copy_ci(struct bnep_conninfo *ci, struct bnep_session *s)
{
	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] = "";

	l2cap_load();

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