xref: /openbmc/linux/net/bluetooth/bnep/core.c (revision 7490ca1e) 
1 /*
2    BNEP implementation for Linux Bluetooth stack (BlueZ).
3    Copyright (C) 2001-2002 Inventel Systemes
4    Written 2001-2002 by
5 	Clément Moreau <clement.moreau@inventel.fr>
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
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
21    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22 
23    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
24    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
25    SOFTWARE IS DISCLAIMED.
26 */
27 
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>
35 #include <linux/freezer.h>
36 #include <linux/errno.h>
37 #include <linux/net.h>
38 #include <linux/slab.h>
39 #include <linux/kthread.h>
40 #include <net/sock.h>
41 
42 #include <linux/socket.h>
43 #include <linux/file.h>
44 
45 #include <linux/netdevice.h>
46 #include <linux/etherdevice.h>
47 #include <linux/skbuff.h>
48 
49 #include <asm/unaligned.h>
50 
51 #include <net/bluetooth/bluetooth.h>
52 #include <net/bluetooth/hci_core.h>
53 #include <net/bluetooth/l2cap.h>
54 
55 #include "bnep.h"
56 
57 #define VERSION "1.3"
58 
59 static bool compress_src = true;
60 static bool compress_dst = true;
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 
69 	BT_DBG("");
70 
71 	list_for_each_entry(s, &bnep_session_list, list)
72 		if (!compare_ether_addr(dst, s->eh.h_source))
73 			return s;
74 
75 	return NULL;
76 }
77 
78 static void __bnep_link_session(struct bnep_session *s)
79 {
80 	list_add(&s->list, &bnep_session_list);
81 }
82 
83 static void __bnep_unlink_session(struct bnep_session *s)
84 {
85 	list_del(&s->list);
86 }
87 
88 static int bnep_send(struct bnep_session *s, void *data, size_t len)
89 {
90 	struct socket *sock = s->sock;
91 	struct kvec iv = { data, len };
92 
93 	return kernel_sendmsg(sock, &s->msg, &iv, 1, len);
94 }
95 
96 static int bnep_send_rsp(struct bnep_session *s, u8 ctrl, u16 resp)
97 {
98 	struct bnep_control_rsp rsp;
99 	rsp.type = BNEP_CONTROL;
100 	rsp.ctrl = ctrl;
101 	rsp.resp = htons(resp);
102 	return bnep_send(s, &rsp, sizeof(rsp));
103 }
104 
105 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
106 static inline void bnep_set_default_proto_filter(struct bnep_session *s)
107 {
108 	/* (IPv4, ARP)  */
109 	s->proto_filter[0].start = ETH_P_IP;
110 	s->proto_filter[0].end   = ETH_P_ARP;
111 	/* (RARP, AppleTalk) */
112 	s->proto_filter[1].start = ETH_P_RARP;
113 	s->proto_filter[1].end   = ETH_P_AARP;
114 	/* (IPX, IPv6) */
115 	s->proto_filter[2].start = ETH_P_IPX;
116 	s->proto_filter[2].end   = ETH_P_IPV6;
117 }
118 #endif
119 
120 static int bnep_ctrl_set_netfilter(struct bnep_session *s, __be16 *data, int len)
121 {
122 	int n;
123 
124 	if (len < 2)
125 		return -EILSEQ;
126 
127 	n = get_unaligned_be16(data);
128 	data++;
129 	len -= 2;
130 
131 	if (len < n)
132 		return -EILSEQ;
133 
134 	BT_DBG("filter len %d", n);
135 
136 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
137 	n /= 4;
138 	if (n <= BNEP_MAX_PROTO_FILTERS) {
139 		struct bnep_proto_filter *f = s->proto_filter;
140 		int i;
141 
142 		for (i = 0; i < n; i++) {
143 			f[i].start = get_unaligned_be16(data++);
144 			f[i].end   = get_unaligned_be16(data++);
145 
146 			BT_DBG("proto filter start %d end %d",
147 				f[i].start, f[i].end);
148 		}
149 
150 		if (i < BNEP_MAX_PROTO_FILTERS)
151 			memset(f + i, 0, sizeof(*f));
152 
153 		if (n == 0)
154 			bnep_set_default_proto_filter(s);
155 
156 		bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_SUCCESS);
157 	} else {
158 		bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_LIMIT_REACHED);
159 	}
160 #else
161 	bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
162 #endif
163 	return 0;
164 }
165 
166 static int bnep_ctrl_set_mcfilter(struct bnep_session *s, u8 *data, int len)
167 {
168 	int n;
169 
170 	if (len < 2)
171 		return -EILSEQ;
172 
173 	n = get_unaligned_be16(data);
174 	data += 2;
175 	len -= 2;
176 
177 	if (len < n)
178 		return -EILSEQ;
179 
180 	BT_DBG("filter len %d", n);
181 
182 #ifdef CONFIG_BT_BNEP_MC_FILTER
183 	n /= (ETH_ALEN * 2);
184 
185 	if (n > 0) {
186 		int i;
187 
188 		s->mc_filter = 0;
189 
190 		/* Always send broadcast */
191 		set_bit(bnep_mc_hash(s->dev->broadcast), (ulong *) &s->mc_filter);
192 
193 		/* Add address ranges to the multicast hash */
194 		for (; n > 0; n--) {
195 			u8 a1[6], *a2;
196 
197 			memcpy(a1, data, ETH_ALEN);
198 			data += ETH_ALEN;
199 			a2 = data;
200 			data += ETH_ALEN;
201 
202 			BT_DBG("mc filter %s -> %s",
203 				batostr((void *) a1), batostr((void *) a2));
204 
205 			/* Iterate from a1 to a2 */
206 			set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
207 			while (memcmp(a1, a2, 6) < 0 && s->mc_filter != ~0LL) {
208 				/* Increment a1 */
209 				i = 5;
210 				while (i >= 0 && ++a1[i--] == 0)
211 					;
212 
213 				set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter);
214 			}
215 		}
216 	}
217 
218 	BT_DBG("mc filter hash 0x%llx", s->mc_filter);
219 
220 	bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_SUCCESS);
221 #else
222 	bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_FILTER_UNSUPPORTED_REQ);
223 #endif
224 	return 0;
225 }
226 
227 static int bnep_rx_control(struct bnep_session *s, void *data, int len)
228 {
229 	u8  cmd = *(u8 *)data;
230 	int err = 0;
231 
232 	data++;
233 	len--;
234 
235 	switch (cmd) {
236 	case BNEP_CMD_NOT_UNDERSTOOD:
237 	case BNEP_SETUP_CONN_RSP:
238 	case BNEP_FILTER_NET_TYPE_RSP:
239 	case BNEP_FILTER_MULTI_ADDR_RSP:
240 		/* Ignore these for now */
241 		break;
242 
243 	case BNEP_FILTER_NET_TYPE_SET:
244 		err = bnep_ctrl_set_netfilter(s, data, len);
245 		break;
246 
247 	case BNEP_FILTER_MULTI_ADDR_SET:
248 		err = bnep_ctrl_set_mcfilter(s, data, len);
249 		break;
250 
251 	case BNEP_SETUP_CONN_REQ:
252 		err = bnep_send_rsp(s, BNEP_SETUP_CONN_RSP, BNEP_CONN_NOT_ALLOWED);
253 		break;
254 
255 	default: {
256 			u8 pkt[3];
257 			pkt[0] = BNEP_CONTROL;
258 			pkt[1] = BNEP_CMD_NOT_UNDERSTOOD;
259 			pkt[2] = cmd;
260 			bnep_send(s, pkt, sizeof(pkt));
261 		}
262 		break;
263 	}
264 
265 	return err;
266 }
267 
268 static int bnep_rx_extension(struct bnep_session *s, struct sk_buff *skb)
269 {
270 	struct bnep_ext_hdr *h;
271 	int err = 0;
272 
273 	do {
274 		h = (void *) skb->data;
275 		if (!skb_pull(skb, sizeof(*h))) {
276 			err = -EILSEQ;
277 			break;
278 		}
279 
280 		BT_DBG("type 0x%x len %d", h->type, h->len);
281 
282 		switch (h->type & BNEP_TYPE_MASK) {
283 		case BNEP_EXT_CONTROL:
284 			bnep_rx_control(s, skb->data, skb->len);
285 			break;
286 
287 		default:
288 			/* Unknown extension, skip it. */
289 			break;
290 		}
291 
292 		if (!skb_pull(skb, h->len)) {
293 			err = -EILSEQ;
294 			break;
295 		}
296 	} while (!err && (h->type & BNEP_EXT_HEADER));
297 
298 	return err;
299 }
300 
301 static u8 __bnep_rx_hlen[] = {
302 	ETH_HLEN,     /* BNEP_GENERAL */
303 	0,            /* BNEP_CONTROL */
304 	2,            /* BNEP_COMPRESSED */
305 	ETH_ALEN + 2, /* BNEP_COMPRESSED_SRC_ONLY */
306 	ETH_ALEN + 2  /* BNEP_COMPRESSED_DST_ONLY */
307 };
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->stats.rx_bytes += skb->len;
316 
317 	type = *(u8 *) skb->data;
318 	skb_pull(skb, 1);
319 
320 	if ((type & BNEP_TYPE_MASK) >= sizeof(__bnep_rx_hlen))
321 		goto badframe;
322 
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 
329 	skb_reset_mac_header(skb);
330 
331 	/* Verify and pull out header */
332 	if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK]))
333 		goto badframe;
334 
335 	s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
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;
346 		s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
347 	}
348 
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 		dev->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;
364 
365 	case BNEP_COMPRESSED_SRC_ONLY:
366 		memcpy(__skb_put(nskb, ETH_ALEN), s->eh.h_dest, ETH_ALEN);
367 		memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb), ETH_ALEN);
368 		put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
369 		break;
370 
371 	case BNEP_COMPRESSED_DST_ONLY:
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);
376 		break;
377 
378 	case BNEP_GENERAL:
379 		memcpy(__skb_put(nskb, ETH_ALEN * 2), skb_mac_header(skb),
380 								ETH_ALEN * 2);
381 		put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
382 		break;
383 	}
384 
385 	skb_copy_from_linear_data(skb, __skb_put(nskb, skb->len), skb->len);
386 	kfree_skb(skb);
387 
388 	dev->stats.rx_packets++;
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 	dev->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 
425 	if (compress_src && !compare_ether_addr(eh->h_dest, s->eh.h_source))
426 		type |= 0x01;
427 
428 	if (compress_dst && !compare_ether_addr(eh->h_source, s->eh.h_dest))
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;
440 
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;
450 
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->dev->stats.tx_bytes += len;
459 		s->dev->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 
476 	set_user_nice(current, -15);
477 
478 	init_waitqueue_entry(&wait, current);
479 	add_wait_queue(sk_sleep(sk), &wait);
480 	while (1) {
481 		set_current_state(TASK_INTERRUPTIBLE);
482 
483 		if (atomic_read(&s->terminate))
484 			break;
485 		/* RX */
486 		while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
487 			skb_orphan(skb);
488 			if (!skb_linearize(skb))
489 				bnep_rx_frame(s, skb);
490 			else
491 				kfree_skb(skb);
492 		}
493 
494 		if (sk->sk_state != BT_CONNECTED)
495 			break;
496 
497 		/* TX */
498 		while ((skb = skb_dequeue(&sk->sk_write_queue)))
499 			if (bnep_tx_frame(s, skb))
500 				break;
501 		netif_wake_queue(dev);
502 
503 		schedule();
504 	}
505 	__set_current_state(TASK_RUNNING);
506 	remove_wait_queue(sk_sleep(sk), &wait);
507 
508 	/* Cleanup session */
509 	down_write(&bnep_session_sem);
510 
511 	/* Delete network device */
512 	unregister_netdev(dev);
513 
514 	/* Wakeup user-space polling for socket errors */
515 	s->sock->sk->sk_err = EUNATCH;
516 
517 	wake_up_interruptible(sk_sleep(s->sock->sk));
518 
519 	/* Release the socket */
520 	fput(s->sock->file);
521 
522 	__bnep_unlink_session(s);
523 
524 	up_write(&bnep_session_sem);
525 	free_netdev(dev);
526 	module_put_and_exit(0);
527 	return 0;
528 }
529 
530 static struct device *bnep_get_device(struct bnep_session *session)
531 {
532 	bdaddr_t *src = &bt_sk(session->sock->sk)->src;
533 	bdaddr_t *dst = &bt_sk(session->sock->sk)->dst;
534 	struct hci_dev *hdev;
535 	struct hci_conn *conn;
536 
537 	hdev = hci_get_route(dst, src);
538 	if (!hdev)
539 		return NULL;
540 
541 	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
542 
543 	hci_dev_put(hdev);
544 
545 	return conn ? &conn->dev : NULL;
546 }
547 
548 static struct device_type bnep_type = {
549 	.name	= "bluetooth",
550 };
551 
552 int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
553 {
554 	struct net_device *dev;
555 	struct bnep_session *s, *ss;
556 	u8 dst[ETH_ALEN], src[ETH_ALEN];
557 	int err;
558 
559 	BT_DBG("");
560 
561 	baswap((void *) dst, &bt_sk(sock->sk)->dst);
562 	baswap((void *) src, &bt_sk(sock->sk)->src);
563 
564 	/* session struct allocated as private part of net_device */
565 	dev = alloc_netdev(sizeof(struct bnep_session),
566 				(*req->device) ? req->device : "bnep%d",
567 				bnep_net_setup);
568 	if (!dev)
569 		return -ENOMEM;
570 
571 	down_write(&bnep_session_sem);
572 
573 	ss = __bnep_get_session(dst);
574 	if (ss && ss->state == BT_CONNECTED) {
575 		err = -EEXIST;
576 		goto failed;
577 	}
578 
579 	s = netdev_priv(dev);
580 
581 	/* This is rx header therefore addresses are swapped.
582 	 * ie. eh.h_dest is our local address. */
583 	memcpy(s->eh.h_dest,   &src, ETH_ALEN);
584 	memcpy(s->eh.h_source, &dst, ETH_ALEN);
585 	memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);
586 
587 	s->dev   = dev;
588 	s->sock  = sock;
589 	s->role  = req->role;
590 	s->state = BT_CONNECTED;
591 
592 	s->msg.msg_flags = MSG_NOSIGNAL;
593 
594 #ifdef CONFIG_BT_BNEP_MC_FILTER
595 	/* Set default mc filter */
596 	set_bit(bnep_mc_hash(dev->broadcast), (ulong *) &s->mc_filter);
597 #endif
598 
599 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
600 	/* Set default protocol filter */
601 	bnep_set_default_proto_filter(s);
602 #endif
603 
604 	SET_NETDEV_DEV(dev, bnep_get_device(s));
605 	SET_NETDEV_DEVTYPE(dev, &bnep_type);
606 
607 	err = register_netdev(dev);
608 	if (err)
609 		goto failed;
610 
611 	__bnep_link_session(s);
612 
613 	__module_get(THIS_MODULE);
614 	s->task = kthread_run(bnep_session, s, "kbnepd %s", dev->name);
615 	if (IS_ERR(s->task)) {
616 		/* Session thread start failed, gotta cleanup. */
617 		module_put(THIS_MODULE);
618 		unregister_netdev(dev);
619 		__bnep_unlink_session(s);
620 		err = PTR_ERR(s->task);
621 		goto failed;
622 	}
623 
624 	up_write(&bnep_session_sem);
625 	strcpy(req->device, dev->name);
626 	return 0;
627 
628 failed:
629 	up_write(&bnep_session_sem);
630 	free_netdev(dev);
631 	return err;
632 }
633 
634 int bnep_del_connection(struct bnep_conndel_req *req)
635 {
636 	struct bnep_session *s;
637 	int  err = 0;
638 
639 	BT_DBG("");
640 
641 	down_read(&bnep_session_sem);
642 
643 	s = __bnep_get_session(req->dst);
644 	if (s) {
645 		atomic_inc(&s->terminate);
646 		wake_up_process(s->task);
647 	} else
648 		err = -ENOENT;
649 
650 	up_read(&bnep_session_sem);
651 	return err;
652 }
653 
654 static void __bnep_copy_ci(struct bnep_conninfo *ci, struct bnep_session *s)
655 {
656 	memset(ci, 0, sizeof(*ci));
657 	memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
658 	strcpy(ci->device, s->dev->name);
659 	ci->flags = s->flags;
660 	ci->state = s->state;
661 	ci->role  = s->role;
662 }
663 
664 int bnep_get_connlist(struct bnep_connlist_req *req)
665 {
666 	struct bnep_session *s;
667 	int err = 0, n = 0;
668 
669 	down_read(&bnep_session_sem);
670 
671 	list_for_each_entry(s, &bnep_session_list, list) {
672 		struct bnep_conninfo ci;
673 
674 		__bnep_copy_ci(&ci, s);
675 
676 		if (copy_to_user(req->ci, &ci, sizeof(ci))) {
677 			err = -EFAULT;
678 			break;
679 		}
680 
681 		if (++n >= req->cnum)
682 			break;
683 
684 		req->ci++;
685 	}
686 	req->cnum = n;
687 
688 	up_read(&bnep_session_sem);
689 	return err;
690 }
691 
692 int bnep_get_conninfo(struct bnep_conninfo *ci)
693 {
694 	struct bnep_session *s;
695 	int err = 0;
696 
697 	down_read(&bnep_session_sem);
698 
699 	s = __bnep_get_session(ci->dst);
700 	if (s)
701 		__bnep_copy_ci(ci, s);
702 	else
703 		err = -ENOENT;
704 
705 	up_read(&bnep_session_sem);
706 	return err;
707 }
708 
709 static int __init bnep_init(void)
710 {
711 	char flt[50] = "";
712 
713 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
714 	strcat(flt, "protocol ");
715 #endif
716 
717 #ifdef CONFIG_BT_BNEP_MC_FILTER
718 	strcat(flt, "multicast");
719 #endif
720 
721 	BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION);
722 	if (flt[0])
723 		BT_INFO("BNEP filters: %s", flt);
724 
725 	bnep_sock_init();
726 	return 0;
727 }
728 
729 static void __exit bnep_exit(void)
730 {
731 	bnep_sock_cleanup();
732 }
733 
734 module_init(bnep_init);
735 module_exit(bnep_exit);
736 
737 module_param(compress_src, bool, 0644);
738 MODULE_PARM_DESC(compress_src, "Compress sources headers");
739 
740 module_param(compress_dst, bool, 0644);
741 MODULE_PARM_DESC(compress_dst, "Compress destination headers");
742 
743 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
744 MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION);
745 MODULE_VERSION(VERSION);
746 MODULE_LICENSE("GPL");
747 MODULE_ALIAS("bt-proto-4");
748