2 BNEP implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2001-2002 Inventel Systemes
5 Clément Moreau <clement.moreau@inventel.fr>
6 David Libault <david.libault@inventel.fr>
8 Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
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;
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.
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.
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>
34 #include <net/bluetooth/bluetooth.h>
35 #include <net/bluetooth/l2cap.h>
36 #include <net/bluetooth/hci_core.h>
42 static bool compress_src
= true;
43 static bool compress_dst
= true;
45 static LIST_HEAD(bnep_session_list
);
46 static DECLARE_RWSEM(bnep_session_sem
);
48 static struct bnep_session
*__bnep_get_session(u8
*dst
)
50 struct bnep_session
*s
;
54 list_for_each_entry(s
, &bnep_session_list
, list
)
55 if (ether_addr_equal(dst
, s
->eh
.h_source
))
61 static void __bnep_link_session(struct bnep_session
*s
)
63 list_add(&s
->list
, &bnep_session_list
);
66 static void __bnep_unlink_session(struct bnep_session
*s
)
71 static int bnep_send(struct bnep_session
*s
, void *data
, size_t len
)
73 struct socket
*sock
= s
->sock
;
74 struct kvec iv
= { data
, len
};
76 return kernel_sendmsg(sock
, &s
->msg
, &iv
, 1, len
);
79 static int bnep_send_rsp(struct bnep_session
*s
, u8 ctrl
, u16 resp
)
81 struct bnep_control_rsp rsp
;
82 rsp
.type
= BNEP_CONTROL
;
84 rsp
.resp
= htons(resp
);
85 return bnep_send(s
, &rsp
, sizeof(rsp
));
88 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
89 static inline void bnep_set_default_proto_filter(struct bnep_session
*s
)
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
;
98 s
->proto_filter
[2].start
= ETH_P_IPX
;
99 s
->proto_filter
[2].end
= ETH_P_IPV6
;
103 static int bnep_ctrl_set_netfilter(struct bnep_session
*s
, __be16
*data
, int len
)
110 n
= get_unaligned_be16(data
);
117 BT_DBG("filter len %d", n
);
119 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
121 if (n
<= BNEP_MAX_PROTO_FILTERS
) {
122 struct bnep_proto_filter
*f
= s
->proto_filter
;
125 for (i
= 0; i
< n
; i
++) {
126 f
[i
].start
= get_unaligned_be16(data
++);
127 f
[i
].end
= get_unaligned_be16(data
++);
129 BT_DBG("proto filter start %d end %d",
130 f
[i
].start
, f
[i
].end
);
133 if (i
< BNEP_MAX_PROTO_FILTERS
)
134 memset(f
+ i
, 0, sizeof(*f
));
137 bnep_set_default_proto_filter(s
);
139 bnep_send_rsp(s
, BNEP_FILTER_NET_TYPE_RSP
, BNEP_SUCCESS
);
141 bnep_send_rsp(s
, BNEP_FILTER_NET_TYPE_RSP
, BNEP_FILTER_LIMIT_REACHED
);
144 bnep_send_rsp(s
, BNEP_FILTER_NET_TYPE_RSP
, BNEP_FILTER_UNSUPPORTED_REQ
);
149 static int bnep_ctrl_set_mcfilter(struct bnep_session
*s
, u8
*data
, int len
)
156 n
= get_unaligned_be16(data
);
163 BT_DBG("filter len %d", n
);
165 #ifdef CONFIG_BT_BNEP_MC_FILTER
173 /* Always send broadcast */
174 set_bit(bnep_mc_hash(s
->dev
->broadcast
), (ulong
*) &s
->mc_filter
);
176 /* Add address ranges to the multicast hash */
180 memcpy(a1
, data
, ETH_ALEN
);
185 BT_DBG("mc filter %pMR -> %pMR", a1
, a2
);
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) {
192 while (i
>= 0 && ++a1
[i
--] == 0)
195 set_bit(bnep_mc_hash(a1
), (ulong
*) &s
->mc_filter
);
200 BT_DBG("mc filter hash 0x%llx", s
->mc_filter
);
202 bnep_send_rsp(s
, BNEP_FILTER_MULTI_ADDR_RSP
, BNEP_SUCCESS
);
204 bnep_send_rsp(s
, BNEP_FILTER_MULTI_ADDR_RSP
, BNEP_FILTER_UNSUPPORTED_REQ
);
209 static int bnep_rx_control(struct bnep_session
*s
, void *data
, int len
)
211 u8 cmd
= *(u8
*)data
;
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 */
225 case BNEP_FILTER_NET_TYPE_SET
:
226 err
= bnep_ctrl_set_netfilter(s
, data
, len
);
229 case BNEP_FILTER_MULTI_ADDR_SET
:
230 err
= bnep_ctrl_set_mcfilter(s
, data
, len
);
233 case BNEP_SETUP_CONN_REQ
:
234 err
= bnep_send_rsp(s
, BNEP_SETUP_CONN_RSP
, BNEP_CONN_NOT_ALLOWED
);
239 pkt
[0] = BNEP_CONTROL
;
240 pkt
[1] = BNEP_CMD_NOT_UNDERSTOOD
;
242 bnep_send(s
, pkt
, sizeof(pkt
));
250 static int bnep_rx_extension(struct bnep_session
*s
, struct sk_buff
*skb
)
252 struct bnep_ext_hdr
*h
;
256 h
= (void *) skb
->data
;
257 if (!skb_pull(skb
, sizeof(*h
))) {
262 BT_DBG("type 0x%x len %d", h
->type
, h
->len
);
264 switch (h
->type
& BNEP_TYPE_MASK
) {
265 case BNEP_EXT_CONTROL
:
266 bnep_rx_control(s
, skb
->data
, skb
->len
);
270 /* Unknown extension, skip it. */
274 if (!skb_pull(skb
, h
->len
)) {
278 } while (!err
&& (h
->type
& BNEP_EXT_HEADER
));
283 static u8 __bnep_rx_hlen
[] = {
284 ETH_HLEN
, /* BNEP_GENERAL */
285 0, /* BNEP_CONTROL */
286 2, /* BNEP_COMPRESSED */
287 ETH_ALEN
+ 2, /* BNEP_COMPRESSED_SRC_ONLY */
288 ETH_ALEN
+ 2 /* BNEP_COMPRESSED_DST_ONLY */
291 static int bnep_rx_frame(struct bnep_session
*s
, struct sk_buff
*skb
)
293 struct net_device
*dev
= s
->dev
;
294 struct sk_buff
*nskb
;
297 dev
->stats
.rx_bytes
+= skb
->len
;
299 type
= *(u8
*) skb
->data
;
302 if ((type
& BNEP_TYPE_MASK
) >= sizeof(__bnep_rx_hlen
))
305 if ((type
& BNEP_TYPE_MASK
) == BNEP_CONTROL
) {
306 bnep_rx_control(s
, skb
->data
, skb
->len
);
311 skb_reset_mac_header(skb
);
313 /* Verify and pull out header */
314 if (!skb_pull(skb
, __bnep_rx_hlen
[type
& BNEP_TYPE_MASK
]))
317 s
->eh
.h_proto
= get_unaligned((__be16
*) (skb
->data
- 2));
319 if (type
& BNEP_EXT_HEADER
) {
320 if (bnep_rx_extension(s
, skb
) < 0)
324 /* Strip 802.1p header */
325 if (ntohs(s
->eh
.h_proto
) == ETH_P_8021Q
) {
326 if (!skb_pull(skb
, 4))
328 s
->eh
.h_proto
= get_unaligned((__be16
*) (skb
->data
- 2));
331 /* We have to alloc new skb and copy data here :(. Because original skb
332 * may not be modified and because of the alignment requirements. */
333 nskb
= alloc_skb(2 + ETH_HLEN
+ skb
->len
, GFP_KERNEL
);
335 dev
->stats
.rx_dropped
++;
339 skb_reserve(nskb
, 2);
341 /* Decompress header and construct ether frame */
342 switch (type
& BNEP_TYPE_MASK
) {
343 case BNEP_COMPRESSED
:
344 memcpy(__skb_put(nskb
, ETH_HLEN
), &s
->eh
, ETH_HLEN
);
347 case BNEP_COMPRESSED_SRC_ONLY
:
348 memcpy(__skb_put(nskb
, ETH_ALEN
), s
->eh
.h_dest
, ETH_ALEN
);
349 memcpy(__skb_put(nskb
, ETH_ALEN
), skb_mac_header(skb
), ETH_ALEN
);
350 put_unaligned(s
->eh
.h_proto
, (__be16
*) __skb_put(nskb
, 2));
353 case BNEP_COMPRESSED_DST_ONLY
:
354 memcpy(__skb_put(nskb
, ETH_ALEN
), skb_mac_header(skb
),
356 memcpy(__skb_put(nskb
, ETH_ALEN
+ 2), s
->eh
.h_source
,
361 memcpy(__skb_put(nskb
, ETH_ALEN
* 2), skb_mac_header(skb
),
363 put_unaligned(s
->eh
.h_proto
, (__be16
*) __skb_put(nskb
, 2));
367 skb_copy_from_linear_data(skb
, __skb_put(nskb
, skb
->len
), skb
->len
);
370 dev
->stats
.rx_packets
++;
371 nskb
->ip_summed
= CHECKSUM_NONE
;
372 nskb
->protocol
= eth_type_trans(nskb
, dev
);
377 dev
->stats
.rx_errors
++;
382 static u8 __bnep_tx_types
[] = {
384 BNEP_COMPRESSED_SRC_ONLY
,
385 BNEP_COMPRESSED_DST_ONLY
,
389 static int bnep_tx_frame(struct bnep_session
*s
, struct sk_buff
*skb
)
391 struct ethhdr
*eh
= (void *) skb
->data
;
392 struct socket
*sock
= s
->sock
;
397 BT_DBG("skb %p dev %p type %d", skb
, skb
->dev
, skb
->pkt_type
);
400 /* Control frame sent by us */
404 iv
[il
++] = (struct kvec
) { &type
, 1 };
407 if (compress_src
&& ether_addr_equal(eh
->h_dest
, s
->eh
.h_source
))
410 if (compress_dst
&& ether_addr_equal(eh
->h_source
, s
->eh
.h_dest
))
414 skb_pull(skb
, ETH_ALEN
* 2);
416 type
= __bnep_tx_types
[type
];
418 case BNEP_COMPRESSED_SRC_ONLY
:
419 iv
[il
++] = (struct kvec
) { eh
->h_source
, ETH_ALEN
};
423 case BNEP_COMPRESSED_DST_ONLY
:
424 iv
[il
++] = (struct kvec
) { eh
->h_dest
, ETH_ALEN
};
430 iv
[il
++] = (struct kvec
) { skb
->data
, skb
->len
};
433 /* FIXME: linearize skb */
435 len
= kernel_sendmsg(sock
, &s
->msg
, iv
, il
, len
);
440 s
->dev
->stats
.tx_bytes
+= len
;
441 s
->dev
->stats
.tx_packets
++;
448 static int bnep_session(void *arg
)
450 struct bnep_session
*s
= arg
;
451 struct net_device
*dev
= s
->dev
;
452 struct sock
*sk
= s
->sock
->sk
;
458 set_user_nice(current
, -15);
460 init_waitqueue_entry(&wait
, current
);
461 add_wait_queue(sk_sleep(sk
), &wait
);
463 set_current_state(TASK_INTERRUPTIBLE
);
465 if (atomic_read(&s
->terminate
))
468 while ((skb
= skb_dequeue(&sk
->sk_receive_queue
))) {
470 if (!skb_linearize(skb
))
471 bnep_rx_frame(s
, skb
);
476 if (sk
->sk_state
!= BT_CONNECTED
)
480 while ((skb
= skb_dequeue(&sk
->sk_write_queue
)))
481 if (bnep_tx_frame(s
, skb
))
483 netif_wake_queue(dev
);
487 __set_current_state(TASK_RUNNING
);
488 remove_wait_queue(sk_sleep(sk
), &wait
);
490 /* Cleanup session */
491 down_write(&bnep_session_sem
);
493 /* Delete network device */
494 unregister_netdev(dev
);
496 /* Wakeup user-space polling for socket errors */
497 s
->sock
->sk
->sk_err
= EUNATCH
;
499 wake_up_interruptible(sk_sleep(s
->sock
->sk
));
501 /* Release the socket */
504 __bnep_unlink_session(s
);
506 up_write(&bnep_session_sem
);
508 module_put_and_exit(0);
512 static struct device
*bnep_get_device(struct bnep_session
*session
)
514 struct hci_conn
*conn
;
516 conn
= l2cap_pi(session
->sock
->sk
)->chan
->conn
->hcon
;
523 static struct device_type bnep_type
= {
527 int bnep_add_connection(struct bnep_connadd_req
*req
, struct socket
*sock
)
529 struct net_device
*dev
;
530 struct bnep_session
*s
, *ss
;
531 u8 dst
[ETH_ALEN
], src
[ETH_ALEN
];
536 baswap((void *) dst
, &l2cap_pi(sock
->sk
)->chan
->dst
);
537 baswap((void *) src
, &l2cap_pi(sock
->sk
)->chan
->src
);
539 /* session struct allocated as private part of net_device */
540 dev
= alloc_netdev(sizeof(struct bnep_session
),
541 (*req
->device
) ? req
->device
: "bnep%d",
547 down_write(&bnep_session_sem
);
549 ss
= __bnep_get_session(dst
);
550 if (ss
&& ss
->state
== BT_CONNECTED
) {
555 s
= netdev_priv(dev
);
557 /* This is rx header therefore addresses are swapped.
558 * ie. eh.h_dest is our local address. */
559 memcpy(s
->eh
.h_dest
, &src
, ETH_ALEN
);
560 memcpy(s
->eh
.h_source
, &dst
, ETH_ALEN
);
561 memcpy(dev
->dev_addr
, s
->eh
.h_dest
, ETH_ALEN
);
566 s
->state
= BT_CONNECTED
;
568 s
->msg
.msg_flags
= MSG_NOSIGNAL
;
570 #ifdef CONFIG_BT_BNEP_MC_FILTER
571 /* Set default mc filter */
572 set_bit(bnep_mc_hash(dev
->broadcast
), (ulong
*) &s
->mc_filter
);
575 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
576 /* Set default protocol filter */
577 bnep_set_default_proto_filter(s
);
580 SET_NETDEV_DEV(dev
, bnep_get_device(s
));
581 SET_NETDEV_DEVTYPE(dev
, &bnep_type
);
583 err
= register_netdev(dev
);
587 __bnep_link_session(s
);
589 __module_get(THIS_MODULE
);
590 s
->task
= kthread_run(bnep_session
, s
, "kbnepd %s", dev
->name
);
591 if (IS_ERR(s
->task
)) {
592 /* Session thread start failed, gotta cleanup. */
593 module_put(THIS_MODULE
);
594 unregister_netdev(dev
);
595 __bnep_unlink_session(s
);
596 err
= PTR_ERR(s
->task
);
600 up_write(&bnep_session_sem
);
601 strcpy(req
->device
, dev
->name
);
605 up_write(&bnep_session_sem
);
610 int bnep_del_connection(struct bnep_conndel_req
*req
)
612 struct bnep_session
*s
;
617 down_read(&bnep_session_sem
);
619 s
= __bnep_get_session(req
->dst
);
621 atomic_inc(&s
->terminate
);
622 wake_up_process(s
->task
);
626 up_read(&bnep_session_sem
);
630 static void __bnep_copy_ci(struct bnep_conninfo
*ci
, struct bnep_session
*s
)
632 memset(ci
, 0, sizeof(*ci
));
633 memcpy(ci
->dst
, s
->eh
.h_source
, ETH_ALEN
);
634 strcpy(ci
->device
, s
->dev
->name
);
635 ci
->flags
= s
->flags
;
636 ci
->state
= s
->state
;
640 int bnep_get_connlist(struct bnep_connlist_req
*req
)
642 struct bnep_session
*s
;
645 down_read(&bnep_session_sem
);
647 list_for_each_entry(s
, &bnep_session_list
, list
) {
648 struct bnep_conninfo ci
;
650 __bnep_copy_ci(&ci
, s
);
652 if (copy_to_user(req
->ci
, &ci
, sizeof(ci
))) {
657 if (++n
>= req
->cnum
)
664 up_read(&bnep_session_sem
);
668 int bnep_get_conninfo(struct bnep_conninfo
*ci
)
670 struct bnep_session
*s
;
673 down_read(&bnep_session_sem
);
675 s
= __bnep_get_session(ci
->dst
);
677 __bnep_copy_ci(ci
, s
);
681 up_read(&bnep_session_sem
);
685 static int __init
bnep_init(void)
689 #ifdef CONFIG_BT_BNEP_PROTO_FILTER
690 strcat(flt
, "protocol ");
693 #ifdef CONFIG_BT_BNEP_MC_FILTER
694 strcat(flt
, "multicast");
697 BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION
);
699 BT_INFO("BNEP filters: %s", flt
);
705 static void __exit
bnep_exit(void)
710 module_init(bnep_init
);
711 module_exit(bnep_exit
);
713 module_param(compress_src
, bool, 0644);
714 MODULE_PARM_DESC(compress_src
, "Compress sources headers");
716 module_param(compress_dst
, bool, 0644);
717 MODULE_PARM_DESC(compress_dst
, "Compress destination headers");
719 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
720 MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION
);
721 MODULE_VERSION(VERSION
);
722 MODULE_LICENSE("GPL");
723 MODULE_ALIAS("bt-proto-4");