mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
230 lines
5.8 KiB
230 lines
5.8 KiB
/* |
|
BNEP implementation for Linux Bluetooth stack (BlueZ). |
|
Copyright (C) 2001-2002 Inventel Systemes |
|
Written 2001-2002 by |
|
Clément Moreau <[email protected]> |
|
David Libault <[email protected]> |
|
|
|
Copyright (C) 2002 Maxim Krasnyansky <[email protected]> |
|
|
|
This program is free software; you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License version 2 as |
|
published by the Free Software Foundation; |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. |
|
IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY |
|
CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES |
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
|
|
ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, |
|
COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS |
|
SOFTWARE IS DISCLAIMED. |
|
*/ |
|
|
|
#include <linux/etherdevice.h> |
|
|
|
#include <net/bluetooth/bluetooth.h> |
|
#include <net/bluetooth/hci_core.h> |
|
#include <net/bluetooth/l2cap.h> |
|
|
|
#include "bnep.h" |
|
|
|
#define BNEP_TX_QUEUE_LEN 20 |
|
|
|
static int bnep_net_open(struct net_device *dev) |
|
{ |
|
netif_start_queue(dev); |
|
return 0; |
|
} |
|
|
|
static int bnep_net_close(struct net_device *dev) |
|
{ |
|
netif_stop_queue(dev); |
|
return 0; |
|
} |
|
|
|
static void bnep_net_set_mc_list(struct net_device *dev) |
|
{ |
|
#ifdef CONFIG_BT_BNEP_MC_FILTER |
|
struct bnep_session *s = netdev_priv(dev); |
|
struct sock *sk = s->sock->sk; |
|
struct bnep_set_filter_req *r; |
|
struct sk_buff *skb; |
|
int size; |
|
|
|
BT_DBG("%s mc_count %d", dev->name, netdev_mc_count(dev)); |
|
|
|
size = sizeof(*r) + (BNEP_MAX_MULTICAST_FILTERS + 1) * ETH_ALEN * 2; |
|
skb = alloc_skb(size, GFP_ATOMIC); |
|
if (!skb) { |
|
BT_ERR("%s Multicast list allocation failed", dev->name); |
|
return; |
|
} |
|
|
|
r = (void *) skb->data; |
|
__skb_put(skb, sizeof(*r)); |
|
|
|
r->type = BNEP_CONTROL; |
|
r->ctrl = BNEP_FILTER_MULTI_ADDR_SET; |
|
|
|
if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) { |
|
u8 start[ETH_ALEN] = { 0x01 }; |
|
|
|
/* Request all addresses */ |
|
__skb_put_data(skb, start, ETH_ALEN); |
|
__skb_put_data(skb, dev->broadcast, ETH_ALEN); |
|
r->len = htons(ETH_ALEN * 2); |
|
} else { |
|
struct netdev_hw_addr *ha; |
|
int i, len = skb->len; |
|
|
|
if (dev->flags & IFF_BROADCAST) { |
|
__skb_put_data(skb, dev->broadcast, ETH_ALEN); |
|
__skb_put_data(skb, dev->broadcast, ETH_ALEN); |
|
} |
|
|
|
/* FIXME: We should group addresses here. */ |
|
|
|
i = 0; |
|
netdev_for_each_mc_addr(ha, dev) { |
|
if (i == BNEP_MAX_MULTICAST_FILTERS) |
|
break; |
|
__skb_put_data(skb, ha->addr, ETH_ALEN); |
|
__skb_put_data(skb, ha->addr, ETH_ALEN); |
|
|
|
i++; |
|
} |
|
r->len = htons(skb->len - len); |
|
} |
|
|
|
skb_queue_tail(&sk->sk_write_queue, skb); |
|
wake_up_interruptible(sk_sleep(sk)); |
|
#endif |
|
} |
|
|
|
static int bnep_net_set_mac_addr(struct net_device *dev, void *arg) |
|
{ |
|
BT_DBG("%s", dev->name); |
|
return 0; |
|
} |
|
|
|
static void bnep_net_timeout(struct net_device *dev, unsigned int txqueue) |
|
{ |
|
BT_DBG("net_timeout"); |
|
netif_wake_queue(dev); |
|
} |
|
|
|
#ifdef CONFIG_BT_BNEP_MC_FILTER |
|
static int bnep_net_mc_filter(struct sk_buff *skb, struct bnep_session *s) |
|
{ |
|
struct ethhdr *eh = (void *) skb->data; |
|
|
|
if ((eh->h_dest[0] & 1) && !test_bit(bnep_mc_hash(eh->h_dest), (ulong *) &s->mc_filter)) |
|
return 1; |
|
return 0; |
|
} |
|
#endif |
|
|
|
#ifdef CONFIG_BT_BNEP_PROTO_FILTER |
|
/* Determine ether protocol. Based on eth_type_trans. */ |
|
static u16 bnep_net_eth_proto(struct sk_buff *skb) |
|
{ |
|
struct ethhdr *eh = (void *) skb->data; |
|
u16 proto = ntohs(eh->h_proto); |
|
|
|
if (proto >= ETH_P_802_3_MIN) |
|
return proto; |
|
|
|
if (get_unaligned((__be16 *) skb->data) == htons(0xFFFF)) |
|
return ETH_P_802_3; |
|
|
|
return ETH_P_802_2; |
|
} |
|
|
|
static int bnep_net_proto_filter(struct sk_buff *skb, struct bnep_session *s) |
|
{ |
|
u16 proto = bnep_net_eth_proto(skb); |
|
struct bnep_proto_filter *f = s->proto_filter; |
|
int i; |
|
|
|
for (i = 0; i < BNEP_MAX_PROTO_FILTERS && f[i].end; i++) { |
|
if (proto >= f[i].start && proto <= f[i].end) |
|
return 0; |
|
} |
|
|
|
BT_DBG("BNEP: filtered skb %p, proto 0x%.4x", skb, proto); |
|
return 1; |
|
} |
|
#endif |
|
|
|
static netdev_tx_t bnep_net_xmit(struct sk_buff *skb, |
|
struct net_device *dev) |
|
{ |
|
struct bnep_session *s = netdev_priv(dev); |
|
struct sock *sk = s->sock->sk; |
|
|
|
BT_DBG("skb %p, dev %p", skb, dev); |
|
|
|
#ifdef CONFIG_BT_BNEP_MC_FILTER |
|
if (bnep_net_mc_filter(skb, s)) { |
|
kfree_skb(skb); |
|
return NETDEV_TX_OK; |
|
} |
|
#endif |
|
|
|
#ifdef CONFIG_BT_BNEP_PROTO_FILTER |
|
if (bnep_net_proto_filter(skb, s)) { |
|
kfree_skb(skb); |
|
return NETDEV_TX_OK; |
|
} |
|
#endif |
|
|
|
/* |
|
* We cannot send L2CAP packets from here as we are potentially in a bh. |
|
* So we have to queue them and wake up session thread which is sleeping |
|
* on the sk_sleep(sk). |
|
*/ |
|
netif_trans_update(dev); |
|
skb_queue_tail(&sk->sk_write_queue, skb); |
|
wake_up_interruptible(sk_sleep(sk)); |
|
|
|
if (skb_queue_len(&sk->sk_write_queue) >= BNEP_TX_QUEUE_LEN) { |
|
BT_DBG("tx queue is full"); |
|
|
|
/* Stop queuing. |
|
* Session thread will do netif_wake_queue() */ |
|
netif_stop_queue(dev); |
|
} |
|
|
|
return NETDEV_TX_OK; |
|
} |
|
|
|
static const struct net_device_ops bnep_netdev_ops = { |
|
.ndo_open = bnep_net_open, |
|
.ndo_stop = bnep_net_close, |
|
.ndo_start_xmit = bnep_net_xmit, |
|
.ndo_validate_addr = eth_validate_addr, |
|
.ndo_set_rx_mode = bnep_net_set_mc_list, |
|
.ndo_set_mac_address = bnep_net_set_mac_addr, |
|
.ndo_tx_timeout = bnep_net_timeout, |
|
|
|
}; |
|
|
|
void bnep_net_setup(struct net_device *dev) |
|
{ |
|
|
|
eth_broadcast_addr(dev->broadcast); |
|
dev->addr_len = ETH_ALEN; |
|
|
|
ether_setup(dev); |
|
dev->min_mtu = 0; |
|
dev->max_mtu = ETH_MAX_MTU; |
|
dev->priv_flags &= ~IFF_TX_SKB_SHARING; |
|
dev->netdev_ops = &bnep_netdev_ops; |
|
|
|
dev->watchdog_timeo = HZ * 2; |
|
}
|
|
|