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