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