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
__bnep_get_session(u8 * dst)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
__bnep_link_session(struct bnep_session * s)61 static void __bnep_link_session(struct bnep_session *s)
62 {
63 list_add(&s->list, &bnep_session_list);
64 }
65
__bnep_unlink_session(struct bnep_session * s)66 static void __bnep_unlink_session(struct bnep_session *s)
67 {
68 list_del(&s->list);
69 }
70
bnep_send(struct bnep_session * s,void * data,size_t len)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
bnep_send_rsp(struct bnep_session * s,u8 ctrl,u16 resp)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
bnep_set_default_proto_filter(struct bnep_session * s)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
bnep_ctrl_set_netfilter(struct bnep_session * s,__be16 * data,int len)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
bnep_ctrl_set_mcfilter(struct bnep_session * s,u8 * data,int len)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
bnep_rx_control(struct bnep_session * s,void * data,int len)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
bnep_rx_extension(struct bnep_session * s,struct sk_buff * skb)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
bnep_rx_frame(struct bnep_session * s,struct sk_buff * skb)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
bnep_tx_frame(struct bnep_session * s,struct sk_buff * skb)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
bnep_session(void * arg)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
bnep_get_device(struct bnep_session * session)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
bnep_add_connection(struct bnep_connadd_req * req,struct socket * sock)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 up_write(&bnep_session_sem);
649 strcpy(req->device, dev->name);
650 return 0;
651
652 failed:
653 up_write(&bnep_session_sem);
654 free_netdev(dev);
655 return err;
656 }
657
bnep_del_connection(struct bnep_conndel_req * req)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
__bnep_copy_ci(struct bnep_conninfo * ci,struct bnep_session * s)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
bnep_get_connlist(struct bnep_connlist_req * req)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
bnep_get_conninfo(struct bnep_conninfo * ci)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
bnep_init(void)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
bnep_exit(void)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