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