linux/net/bluetooth/bnep/netdev.c
<<
>>
Prefs
   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/etherdevice.h>
  29
  30#include <net/bluetooth/bluetooth.h>
  31#include <net/bluetooth/hci_core.h>
  32#include <net/bluetooth/l2cap.h>
  33
  34#include "bnep.h"
  35
  36#define BNEP_TX_QUEUE_LEN 20
  37
  38static int bnep_net_open(struct net_device *dev)
  39{
  40        netif_start_queue(dev);
  41        return 0;
  42}
  43
  44static int bnep_net_close(struct net_device *dev)
  45{
  46        netif_stop_queue(dev);
  47        return 0;
  48}
  49
  50static void bnep_net_set_mc_list(struct net_device *dev)
  51{
  52#ifdef CONFIG_BT_BNEP_MC_FILTER
  53        struct bnep_session *s = netdev_priv(dev);
  54        struct sock *sk = s->sock->sk;
  55        struct bnep_set_filter_req *r;
  56        struct sk_buff *skb;
  57        int size;
  58
  59        BT_DBG("%s mc_count %d", dev->name, netdev_mc_count(dev));
  60
  61        size = sizeof(*r) + (BNEP_MAX_MULTICAST_FILTERS + 1) * ETH_ALEN * 2;
  62        skb  = alloc_skb(size, GFP_ATOMIC);
  63        if (!skb) {
  64                BT_ERR("%s Multicast list allocation failed", dev->name);
  65                return;
  66        }
  67
  68        r = (void *) skb->data;
  69        __skb_put(skb, sizeof(*r));
  70
  71        r->type = BNEP_CONTROL;
  72        r->ctrl = BNEP_FILTER_MULTI_ADDR_SET;
  73
  74        if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
  75                u8 start[ETH_ALEN] = { 0x01 };
  76
  77                /* Request all addresses */
  78                __skb_put_data(skb, start, ETH_ALEN);
  79                __skb_put_data(skb, dev->broadcast, ETH_ALEN);
  80                r->len = htons(ETH_ALEN * 2);
  81        } else {
  82                struct netdev_hw_addr *ha;
  83                int i, len = skb->len;
  84
  85                if (dev->flags & IFF_BROADCAST) {
  86                        __skb_put_data(skb, dev->broadcast, ETH_ALEN);
  87                        __skb_put_data(skb, dev->broadcast, ETH_ALEN);
  88                }
  89
  90                /* FIXME: We should group addresses here. */
  91
  92                i = 0;
  93                netdev_for_each_mc_addr(ha, dev) {
  94                        if (i == BNEP_MAX_MULTICAST_FILTERS)
  95                                break;
  96                        __skb_put_data(skb, ha->addr, ETH_ALEN);
  97                        __skb_put_data(skb, ha->addr, ETH_ALEN);
  98
  99                        i++;
 100                }
 101                r->len = htons(skb->len - len);
 102        }
 103
 104        skb_queue_tail(&sk->sk_write_queue, skb);
 105        wake_up_interruptible(sk_sleep(sk));
 106#endif
 107}
 108
 109static int bnep_net_set_mac_addr(struct net_device *dev, void *arg)
 110{
 111        BT_DBG("%s", dev->name);
 112        return 0;
 113}
 114
 115static void bnep_net_timeout(struct net_device *dev)
 116{
 117        BT_DBG("net_timeout");
 118        netif_wake_queue(dev);
 119}
 120
 121#ifdef CONFIG_BT_BNEP_MC_FILTER
 122static int bnep_net_mc_filter(struct sk_buff *skb, struct bnep_session *s)
 123{
 124        struct ethhdr *eh = (void *) skb->data;
 125
 126        if ((eh->h_dest[0] & 1) && !test_bit(bnep_mc_hash(eh->h_dest), (ulong *) &s->mc_filter))
 127                return 1;
 128        return 0;
 129}
 130#endif
 131
 132#ifdef CONFIG_BT_BNEP_PROTO_FILTER
 133/* Determine ether protocol. Based on eth_type_trans. */
 134static u16 bnep_net_eth_proto(struct sk_buff *skb)
 135{
 136        struct ethhdr *eh = (void *) skb->data;
 137        u16 proto = ntohs(eh->h_proto);
 138
 139        if (proto >= ETH_P_802_3_MIN)
 140                return proto;
 141
 142        if (get_unaligned((__be16 *) skb->data) == htons(0xFFFF))
 143                return ETH_P_802_3;
 144
 145        return ETH_P_802_2;
 146}
 147
 148static int bnep_net_proto_filter(struct sk_buff *skb, struct bnep_session *s)
 149{
 150        u16 proto = bnep_net_eth_proto(skb);
 151        struct bnep_proto_filter *f = s->proto_filter;
 152        int i;
 153
 154        for (i = 0; i < BNEP_MAX_PROTO_FILTERS && f[i].end; i++) {
 155                if (proto >= f[i].start && proto <= f[i].end)
 156                        return 0;
 157        }
 158
 159        BT_DBG("BNEP: filtered skb %p, proto 0x%.4x", skb, proto);
 160        return 1;
 161}
 162#endif
 163
 164static netdev_tx_t bnep_net_xmit(struct sk_buff *skb,
 165                                 struct net_device *dev)
 166{
 167        struct bnep_session *s = netdev_priv(dev);
 168        struct sock *sk = s->sock->sk;
 169
 170        BT_DBG("skb %p, dev %p", skb, dev);
 171
 172#ifdef CONFIG_BT_BNEP_MC_FILTER
 173        if (bnep_net_mc_filter(skb, s)) {
 174                kfree_skb(skb);
 175                return NETDEV_TX_OK;
 176        }
 177#endif
 178
 179#ifdef CONFIG_BT_BNEP_PROTO_FILTER
 180        if (bnep_net_proto_filter(skb, s)) {
 181                kfree_skb(skb);
 182                return NETDEV_TX_OK;
 183        }
 184#endif
 185
 186        /*
 187         * We cannot send L2CAP packets from here as we are potentially in a bh.
 188         * So we have to queue them and wake up session thread which is sleeping
 189         * on the sk_sleep(sk).
 190         */
 191        netif_trans_update(dev);
 192        skb_queue_tail(&sk->sk_write_queue, skb);
 193        wake_up_interruptible(sk_sleep(sk));
 194
 195        if (skb_queue_len(&sk->sk_write_queue) >= BNEP_TX_QUEUE_LEN) {
 196                BT_DBG("tx queue is full");
 197
 198                /* Stop queuing.
 199                 * Session thread will do netif_wake_queue() */
 200                netif_stop_queue(dev);
 201        }
 202
 203        return NETDEV_TX_OK;
 204}
 205
 206static const struct net_device_ops bnep_netdev_ops = {
 207        .ndo_open            = bnep_net_open,
 208        .ndo_stop            = bnep_net_close,
 209        .ndo_start_xmit      = bnep_net_xmit,
 210        .ndo_validate_addr   = eth_validate_addr,
 211        .ndo_set_rx_mode     = bnep_net_set_mc_list,
 212        .ndo_set_mac_address = bnep_net_set_mac_addr,
 213        .ndo_tx_timeout      = bnep_net_timeout,
 214
 215};
 216
 217void bnep_net_setup(struct net_device *dev)
 218{
 219
 220        eth_broadcast_addr(dev->broadcast);
 221        dev->addr_len = ETH_ALEN;
 222
 223        ether_setup(dev);
 224        dev->min_mtu = 0;
 225        dev->max_mtu = ETH_MAX_MTU;
 226        dev->priv_flags &= ~IFF_TX_SKB_SHARING;
 227        dev->netdev_ops = &bnep_netdev_ops;
 228
 229        dev->watchdog_timeo  = HZ * 2;
 230}
 231