[mirror_ubuntu-bionic-kernel.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 <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 = 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) {
		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);

	/* Wakeup user-space polling for socket errors */
	s->sock->sk->sk_err = EUNATCH;

	wake_up_interruptible(s->sock->sk->sk_sleep);

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