Loading...
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 <asm/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
42static bool compress_src = true;
43static bool compress_dst = true;
44
45static LIST_HEAD(bnep_session_list);
46static DECLARE_RWSEM(bnep_session_sem);
47
48static 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
61static void __bnep_link_session(struct bnep_session *s)
62{
63 list_add(&s->list, &bnep_session_list);
64}
65
66static void __bnep_unlink_session(struct bnep_session *s)
67{
68 list_del(&s->list);
69}
70
71static 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
79static 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
89static 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
103static 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 %d end %d",
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
149static 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
209static 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
257static 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 %d", 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
290static 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
298static 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 /* Pull: ctrl type (1 b), len (2 b), data (len bytes) */
335 if (!skb_pull(skb, 3 + *(u16 *)(skb->data + 1) * 2))
336 goto badframe;
337 break;
338 default:
339 kfree_skb(skb);
340 return 0;
341 }
342 } else {
343 skb_reset_mac_header(skb);
344
345 /* Verify and pull out header */
346 if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK]))
347 goto badframe;
348
349 s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
350 }
351
352 if (type & BNEP_EXT_HEADER) {
353 if (bnep_rx_extension(s, skb) < 0)
354 goto badframe;
355 }
356
357 /* Strip 802.1p header */
358 if (ntohs(s->eh.h_proto) == ETH_P_8021Q) {
359 if (!skb_pull(skb, 4))
360 goto badframe;
361 s->eh.h_proto = get_unaligned((__be16 *) (skb->data - 2));
362 }
363
364 /* We have to alloc new skb and copy data here :(. Because original skb
365 * may not be modified and because of the alignment requirements. */
366 nskb = alloc_skb(2 + ETH_HLEN + skb->len, GFP_KERNEL);
367 if (!nskb) {
368 dev->stats.rx_dropped++;
369 kfree_skb(skb);
370 return -ENOMEM;
371 }
372 skb_reserve(nskb, 2);
373
374 /* Decompress header and construct ether frame */
375 switch (type & BNEP_TYPE_MASK) {
376 case BNEP_COMPRESSED:
377 memcpy(__skb_put(nskb, ETH_HLEN), &s->eh, ETH_HLEN);
378 break;
379
380 case BNEP_COMPRESSED_SRC_ONLY:
381 memcpy(__skb_put(nskb, ETH_ALEN), s->eh.h_dest, ETH_ALEN);
382 memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb), ETH_ALEN);
383 put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
384 break;
385
386 case BNEP_COMPRESSED_DST_ONLY:
387 memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb),
388 ETH_ALEN);
389 memcpy(__skb_put(nskb, ETH_ALEN + 2), s->eh.h_source,
390 ETH_ALEN + 2);
391 break;
392
393 case BNEP_GENERAL:
394 memcpy(__skb_put(nskb, ETH_ALEN * 2), skb_mac_header(skb),
395 ETH_ALEN * 2);
396 put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2));
397 break;
398 }
399
400 skb_copy_from_linear_data(skb, __skb_put(nskb, skb->len), skb->len);
401 kfree_skb(skb);
402
403 dev->stats.rx_packets++;
404 nskb->ip_summed = CHECKSUM_NONE;
405 nskb->protocol = eth_type_trans(nskb, dev);
406 netif_rx_ni(nskb);
407 return 0;
408
409badframe:
410 dev->stats.rx_errors++;
411 kfree_skb(skb);
412 return 0;
413}
414
415static u8 __bnep_tx_types[] = {
416 BNEP_GENERAL,
417 BNEP_COMPRESSED_SRC_ONLY,
418 BNEP_COMPRESSED_DST_ONLY,
419 BNEP_COMPRESSED
420};
421
422static int bnep_tx_frame(struct bnep_session *s, struct sk_buff *skb)
423{
424 struct ethhdr *eh = (void *) skb->data;
425 struct socket *sock = s->sock;
426 struct kvec iv[3];
427 int len = 0, il = 0;
428 u8 type = 0;
429
430 BT_DBG("skb %p dev %p type %d", skb, skb->dev, skb->pkt_type);
431
432 if (!skb->dev) {
433 /* Control frame sent by us */
434 goto send;
435 }
436
437 iv[il++] = (struct kvec) { &type, 1 };
438 len++;
439
440 if (compress_src && ether_addr_equal(eh->h_dest, s->eh.h_source))
441 type |= 0x01;
442
443 if (compress_dst && ether_addr_equal(eh->h_source, s->eh.h_dest))
444 type |= 0x02;
445
446 if (type)
447 skb_pull(skb, ETH_ALEN * 2);
448
449 type = __bnep_tx_types[type];
450 switch (type) {
451 case BNEP_COMPRESSED_SRC_ONLY:
452 iv[il++] = (struct kvec) { eh->h_source, ETH_ALEN };
453 len += ETH_ALEN;
454 break;
455
456 case BNEP_COMPRESSED_DST_ONLY:
457 iv[il++] = (struct kvec) { eh->h_dest, ETH_ALEN };
458 len += ETH_ALEN;
459 break;
460 }
461
462send:
463 iv[il++] = (struct kvec) { skb->data, skb->len };
464 len += skb->len;
465
466 /* FIXME: linearize skb */
467 {
468 len = kernel_sendmsg(sock, &s->msg, iv, il, len);
469 }
470 kfree_skb(skb);
471
472 if (len > 0) {
473 s->dev->stats.tx_bytes += len;
474 s->dev->stats.tx_packets++;
475 return 0;
476 }
477
478 return len;
479}
480
481static int bnep_session(void *arg)
482{
483 struct bnep_session *s = arg;
484 struct net_device *dev = s->dev;
485 struct sock *sk = s->sock->sk;
486 struct sk_buff *skb;
487 wait_queue_t wait;
488
489 BT_DBG("");
490
491 set_user_nice(current, -15);
492
493 init_waitqueue_entry(&wait, current);
494 add_wait_queue(sk_sleep(sk), &wait);
495 while (1) {
496 set_current_state(TASK_INTERRUPTIBLE);
497
498 if (atomic_read(&s->terminate))
499 break;
500 /* RX */
501 while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
502 skb_orphan(skb);
503 if (!skb_linearize(skb))
504 bnep_rx_frame(s, skb);
505 else
506 kfree_skb(skb);
507 }
508
509 if (sk->sk_state != BT_CONNECTED)
510 break;
511
512 /* TX */
513 while ((skb = skb_dequeue(&sk->sk_write_queue)))
514 if (bnep_tx_frame(s, skb))
515 break;
516 netif_wake_queue(dev);
517
518 schedule();
519 }
520 __set_current_state(TASK_RUNNING);
521 remove_wait_queue(sk_sleep(sk), &wait);
522
523 /* Cleanup session */
524 down_write(&bnep_session_sem);
525
526 /* Delete network device */
527 unregister_netdev(dev);
528
529 /* Wakeup user-space polling for socket errors */
530 s->sock->sk->sk_err = EUNATCH;
531
532 wake_up_interruptible(sk_sleep(s->sock->sk));
533
534 /* Release the socket */
535 fput(s->sock->file);
536
537 __bnep_unlink_session(s);
538
539 up_write(&bnep_session_sem);
540 free_netdev(dev);
541 module_put_and_exit(0);
542 return 0;
543}
544
545static struct device *bnep_get_device(struct bnep_session *session)
546{
547 struct l2cap_conn *conn = l2cap_pi(session->sock->sk)->chan->conn;
548
549 if (!conn || !conn->hcon)
550 return NULL;
551
552 return &conn->hcon->dev;
553}
554
555static struct device_type bnep_type = {
556 .name = "bluetooth",
557};
558
559int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
560{
561 u32 valid_flags = BIT(BNEP_SETUP_RESPONSE);
562 struct net_device *dev;
563 struct bnep_session *s, *ss;
564 u8 dst[ETH_ALEN], src[ETH_ALEN];
565 int err;
566
567 BT_DBG("");
568
569 if (!l2cap_is_socket(sock))
570 return -EBADFD;
571
572 if (req->flags & ~valid_flags)
573 return -EINVAL;
574
575 baswap((void *) dst, &l2cap_pi(sock->sk)->chan->dst);
576 baswap((void *) src, &l2cap_pi(sock->sk)->chan->src);
577
578 /* session struct allocated as private part of net_device */
579 dev = alloc_netdev(sizeof(struct bnep_session),
580 (*req->device) ? req->device : "bnep%d",
581 NET_NAME_UNKNOWN,
582 bnep_net_setup);
583 if (!dev)
584 return -ENOMEM;
585
586 down_write(&bnep_session_sem);
587
588 ss = __bnep_get_session(dst);
589 if (ss && ss->state == BT_CONNECTED) {
590 err = -EEXIST;
591 goto failed;
592 }
593
594 s = netdev_priv(dev);
595
596 /* This is rx header therefore addresses are swapped.
597 * ie. eh.h_dest is our local address. */
598 memcpy(s->eh.h_dest, &src, ETH_ALEN);
599 memcpy(s->eh.h_source, &dst, ETH_ALEN);
600 memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);
601
602 s->dev = dev;
603 s->sock = sock;
604 s->role = req->role;
605 s->state = BT_CONNECTED;
606 s->flags = req->flags;
607
608 s->msg.msg_flags = MSG_NOSIGNAL;
609
610#ifdef CONFIG_BT_BNEP_MC_FILTER
611 /* Set default mc filter to not filter out any mc addresses
612 * as defined in the BNEP specification (revision 0.95a)
613 * http://grouper.ieee.org/groups/802/15/Bluetooth/BNEP.pdf
614 */
615 s->mc_filter = ~0LL;
616#endif
617
618#ifdef CONFIG_BT_BNEP_PROTO_FILTER
619 /* Set default protocol filter */
620 bnep_set_default_proto_filter(s);
621#endif
622
623 SET_NETDEV_DEV(dev, bnep_get_device(s));
624 SET_NETDEV_DEVTYPE(dev, &bnep_type);
625
626 err = register_netdev(dev);
627 if (err)
628 goto failed;
629
630 __bnep_link_session(s);
631
632 __module_get(THIS_MODULE);
633 s->task = kthread_run(bnep_session, s, "kbnepd %s", dev->name);
634 if (IS_ERR(s->task)) {
635 /* Session thread start failed, gotta cleanup. */
636 module_put(THIS_MODULE);
637 unregister_netdev(dev);
638 __bnep_unlink_session(s);
639 err = PTR_ERR(s->task);
640 goto failed;
641 }
642
643 up_write(&bnep_session_sem);
644 strcpy(req->device, dev->name);
645 return 0;
646
647failed:
648 up_write(&bnep_session_sem);
649 free_netdev(dev);
650 return err;
651}
652
653int bnep_del_connection(struct bnep_conndel_req *req)
654{
655 u32 valid_flags = 0;
656 struct bnep_session *s;
657 int err = 0;
658
659 BT_DBG("");
660
661 if (req->flags & ~valid_flags)
662 return -EINVAL;
663
664 down_read(&bnep_session_sem);
665
666 s = __bnep_get_session(req->dst);
667 if (s) {
668 atomic_inc(&s->terminate);
669 wake_up_process(s->task);
670 } else
671 err = -ENOENT;
672
673 up_read(&bnep_session_sem);
674 return err;
675}
676
677static void __bnep_copy_ci(struct bnep_conninfo *ci, struct bnep_session *s)
678{
679 u32 valid_flags = BIT(BNEP_SETUP_RESPONSE);
680
681 memset(ci, 0, sizeof(*ci));
682 memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
683 strcpy(ci->device, s->dev->name);
684 ci->flags = s->flags & valid_flags;
685 ci->state = s->state;
686 ci->role = s->role;
687}
688
689int bnep_get_connlist(struct bnep_connlist_req *req)
690{
691 struct bnep_session *s;
692 int err = 0, n = 0;
693
694 down_read(&bnep_session_sem);
695
696 list_for_each_entry(s, &bnep_session_list, list) {
697 struct bnep_conninfo ci;
698
699 __bnep_copy_ci(&ci, s);
700
701 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
702 err = -EFAULT;
703 break;
704 }
705
706 if (++n >= req->cnum)
707 break;
708
709 req->ci++;
710 }
711 req->cnum = n;
712
713 up_read(&bnep_session_sem);
714 return err;
715}
716
717int bnep_get_conninfo(struct bnep_conninfo *ci)
718{
719 struct bnep_session *s;
720 int err = 0;
721
722 down_read(&bnep_session_sem);
723
724 s = __bnep_get_session(ci->dst);
725 if (s)
726 __bnep_copy_ci(ci, s);
727 else
728 err = -ENOENT;
729
730 up_read(&bnep_session_sem);
731 return err;
732}
733
734static int __init bnep_init(void)
735{
736 char flt[50] = "";
737
738#ifdef CONFIG_BT_BNEP_PROTO_FILTER
739 strcat(flt, "protocol ");
740#endif
741
742#ifdef CONFIG_BT_BNEP_MC_FILTER
743 strcat(flt, "multicast");
744#endif
745
746 BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION);
747 if (flt[0])
748 BT_INFO("BNEP filters: %s", flt);
749
750 bnep_sock_init();
751 return 0;
752}
753
754static void __exit bnep_exit(void)
755{
756 bnep_sock_cleanup();
757}
758
759module_init(bnep_init);
760module_exit(bnep_exit);
761
762module_param(compress_src, bool, 0644);
763MODULE_PARM_DESC(compress_src, "Compress sources headers");
764
765module_param(compress_dst, bool, 0644);
766MODULE_PARM_DESC(compress_dst, "Compress destination headers");
767
768MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
769MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION);
770MODULE_VERSION(VERSION);
771MODULE_LICENSE("GPL");
772MODULE_ALIAS("bt-proto-4");
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
59static int compress_src = 1;
60static int compress_dst = 1;
61
62static LIST_HEAD(bnep_session_list);
63static DECLARE_RWSEM(bnep_session_sem);
64
65static 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
80static 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
89static void __bnep_unlink_session(struct bnep_session *s)
90{
91 list_del(&s->list);
92 module_put(THIS_MODULE);
93}
94
95static 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
103static 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
113static 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
127static 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
173static 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
234static 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
275static 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
308static 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
316static 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
401badframe:
402 dev->stats.rx_errors++;
403 kfree_skb(skb);
404 return 0;
405}
406
407static u8 __bnep_tx_types[] = {
408 BNEP_GENERAL,
409 BNEP_COMPRESSED_SRC_ONLY,
410 BNEP_COMPRESSED_DST_ONLY,
411 BNEP_COMPRESSED
412};
413
414static 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
454send:
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
473static 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 bnep_rx_frame(s, skb);
496 }
497
498 if (sk->sk_state != BT_CONNECTED)
499 break;
500
501 /* TX */
502 while ((skb = skb_dequeue(&sk->sk_write_queue)))
503 if (bnep_tx_frame(s, skb))
504 break;
505 netif_wake_queue(dev);
506
507 schedule();
508 }
509 __set_current_state(TASK_RUNNING);
510 remove_wait_queue(sk_sleep(sk), &wait);
511
512 /* Cleanup session */
513 down_write(&bnep_session_sem);
514
515 /* Delete network device */
516 unregister_netdev(dev);
517
518 /* Wakeup user-space polling for socket errors */
519 s->sock->sk->sk_err = EUNATCH;
520
521 wake_up_interruptible(sk_sleep(s->sock->sk));
522
523 /* Release the socket */
524 fput(s->sock->file);
525
526 __bnep_unlink_session(s);
527
528 up_write(&bnep_session_sem);
529 free_netdev(dev);
530 return 0;
531}
532
533static struct device *bnep_get_device(struct bnep_session *session)
534{
535 bdaddr_t *src = &bt_sk(session->sock->sk)->src;
536 bdaddr_t *dst = &bt_sk(session->sock->sk)->dst;
537 struct hci_dev *hdev;
538 struct hci_conn *conn;
539
540 hdev = hci_get_route(dst, src);
541 if (!hdev)
542 return NULL;
543
544 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
545
546 hci_dev_put(hdev);
547
548 return conn ? &conn->dev : NULL;
549}
550
551static struct device_type bnep_type = {
552 .name = "bluetooth",
553};
554
555int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock)
556{
557 struct net_device *dev;
558 struct bnep_session *s, *ss;
559 u8 dst[ETH_ALEN], src[ETH_ALEN];
560 int err;
561
562 BT_DBG("");
563
564 baswap((void *) dst, &bt_sk(sock->sk)->dst);
565 baswap((void *) src, &bt_sk(sock->sk)->src);
566
567 /* session struct allocated as private part of net_device */
568 dev = alloc_netdev(sizeof(struct bnep_session),
569 (*req->device) ? req->device : "bnep%d",
570 bnep_net_setup);
571 if (!dev)
572 return -ENOMEM;
573
574 down_write(&bnep_session_sem);
575
576 ss = __bnep_get_session(dst);
577 if (ss && ss->state == BT_CONNECTED) {
578 err = -EEXIST;
579 goto failed;
580 }
581
582 s = netdev_priv(dev);
583
584 /* This is rx header therefore addresses are swapped.
585 * ie. eh.h_dest is our local address. */
586 memcpy(s->eh.h_dest, &src, ETH_ALEN);
587 memcpy(s->eh.h_source, &dst, ETH_ALEN);
588 memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN);
589
590 s->dev = dev;
591 s->sock = sock;
592 s->role = req->role;
593 s->state = BT_CONNECTED;
594
595 s->msg.msg_flags = MSG_NOSIGNAL;
596
597#ifdef CONFIG_BT_BNEP_MC_FILTER
598 /* Set default mc filter */
599 set_bit(bnep_mc_hash(dev->broadcast), (ulong *) &s->mc_filter);
600#endif
601
602#ifdef CONFIG_BT_BNEP_PROTO_FILTER
603 /* Set default protocol filter */
604 bnep_set_default_proto_filter(s);
605#endif
606
607 SET_NETDEV_DEV(dev, bnep_get_device(s));
608 SET_NETDEV_DEVTYPE(dev, &bnep_type);
609
610 err = register_netdev(dev);
611 if (err)
612 goto failed;
613
614 __bnep_link_session(s);
615
616 s->task = kthread_run(bnep_session, s, "kbnepd %s", dev->name);
617 if (IS_ERR(s->task)) {
618 /* Session thread start failed, gotta cleanup. */
619 unregister_netdev(dev);
620 __bnep_unlink_session(s);
621 err = PTR_ERR(s->task);
622 goto failed;
623 }
624
625 up_write(&bnep_session_sem);
626 strcpy(req->device, dev->name);
627 return 0;
628
629failed:
630 up_write(&bnep_session_sem);
631 free_netdev(dev);
632 return err;
633}
634
635int bnep_del_connection(struct bnep_conndel_req *req)
636{
637 struct bnep_session *s;
638 int err = 0;
639
640 BT_DBG("");
641
642 down_read(&bnep_session_sem);
643
644 s = __bnep_get_session(req->dst);
645 if (s) {
646 atomic_inc(&s->terminate);
647 wake_up_process(s->task);
648 } else
649 err = -ENOENT;
650
651 up_read(&bnep_session_sem);
652 return err;
653}
654
655static void __bnep_copy_ci(struct bnep_conninfo *ci, struct bnep_session *s)
656{
657 memset(ci, 0, sizeof(*ci));
658 memcpy(ci->dst, s->eh.h_source, ETH_ALEN);
659 strcpy(ci->device, s->dev->name);
660 ci->flags = s->flags;
661 ci->state = s->state;
662 ci->role = s->role;
663}
664
665int bnep_get_connlist(struct bnep_connlist_req *req)
666{
667 struct list_head *p;
668 int err = 0, n = 0;
669
670 down_read(&bnep_session_sem);
671
672 list_for_each(p, &bnep_session_list) {
673 struct bnep_session *s;
674 struct bnep_conninfo ci;
675
676 s = list_entry(p, struct bnep_session, list);
677
678 __bnep_copy_ci(&ci, s);
679
680 if (copy_to_user(req->ci, &ci, sizeof(ci))) {
681 err = -EFAULT;
682 break;
683 }
684
685 if (++n >= req->cnum)
686 break;
687
688 req->ci++;
689 }
690 req->cnum = n;
691
692 up_read(&bnep_session_sem);
693 return err;
694}
695
696int bnep_get_conninfo(struct bnep_conninfo *ci)
697{
698 struct bnep_session *s;
699 int err = 0;
700
701 down_read(&bnep_session_sem);
702
703 s = __bnep_get_session(ci->dst);
704 if (s)
705 __bnep_copy_ci(ci, s);
706 else
707 err = -ENOENT;
708
709 up_read(&bnep_session_sem);
710 return err;
711}
712
713static int __init bnep_init(void)
714{
715 char flt[50] = "";
716
717#ifdef CONFIG_BT_BNEP_PROTO_FILTER
718 strcat(flt, "protocol ");
719#endif
720
721#ifdef CONFIG_BT_BNEP_MC_FILTER
722 strcat(flt, "multicast");
723#endif
724
725 BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION);
726 if (flt[0])
727 BT_INFO("BNEP filters: %s", flt);
728
729 bnep_sock_init();
730 return 0;
731}
732
733static void __exit bnep_exit(void)
734{
735 bnep_sock_cleanup();
736}
737
738module_init(bnep_init);
739module_exit(bnep_exit);
740
741module_param(compress_src, bool, 0644);
742MODULE_PARM_DESC(compress_src, "Compress sources headers");
743
744module_param(compress_dst, bool, 0644);
745MODULE_PARM_DESC(compress_dst, "Compress destination headers");
746
747MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
748MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION);
749MODULE_VERSION(VERSION);
750MODULE_LICENSE("GPL");
751MODULE_ALIAS("bt-proto-4");