git.oblomov.eu Git - linux-2.6/blob - net/ieee80211/ieee80211_tx.c

   1 /******************************************************************************
   2
   3   Copyright(c) 2003 - 2004 Intel Corporation. All rights reserved.
   4
   5   This program is free software; you can redistribute it and/or modify it
   6   under the terms of version 2 of the GNU General Public License as
   7   published by the Free Software Foundation.
   8
   9   This program is distributed in the hope that it will be useful, but WITHOUT
  10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12   more details.
  13
  14   You should have received a copy of the GNU General Public License along with
  15   this program; if not, write to the Free Software Foundation, Inc., 59
  16   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17
  18   The full GNU General Public License is included in this distribution in the
  19   file called LICENSE.
  20
  21   Contact Information:
  22   James P. Ketrenos <ipw2100-admin@linux.intel.com>
  23   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  24
  25 ******************************************************************************/
  26 #include <linux/compiler.h>
  27 #include <linux/config.h>
  28 #include <linux/errno.h>
  29 #include <linux/if_arp.h>
  30 #include <linux/in6.h>
  31 #include <linux/in.h>
  32 #include <linux/ip.h>
  33 #include <linux/kernel.h>
  34 #include <linux/module.h>
  35 #include <linux/netdevice.h>
  36 #include <linux/proc_fs.h>
  37 #include <linux/skbuff.h>
  38 #include <linux/slab.h>
  39 #include <linux/tcp.h>
  40 #include <linux/types.h>
  41 #include <linux/version.h>
  42 #include <linux/wireless.h>
  43 #include <linux/etherdevice.h>
  44 #include <asm/uaccess.h>
  45
  46 #include <net/ieee80211.h>
  47
  48
  49 /*
  50
  51
  52 802.11 Data Frame
  53
  54       ,-------------------------------------------------------------------.
  55 Bytes |  2   |  2   |    6    |    6    |    6    |  2   | 0..2312 |   4  |
  56       |------|------|---------|---------|---------|------|---------|------|
  57 Desc. | ctrl | dura |  DA/RA  |   TA    |    SA   | Sequ |  Frame  |  fcs |
  58       |      | tion | (BSSID) |         |         | ence |  data   |      |
  59       `--------------------------------------------------|         |------'
  60 Total: 28 non-data bytes                                 `----.----'
  61                                                               |
  62        .- 'Frame data' expands to <---------------------------'
  63        |
  64        V
  65       ,---------------------------------------------------.
  66 Bytes |  1   |  1   |    1    |    3     |  2   |  0-2304 |
  67       |------|------|---------|----------|------|---------|
  68 Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP      |
  69       | DSAP | SSAP |         |          |      | Packet  |
  70       | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8|      |         |
  71       `-----------------------------------------|         |
  72 Total: 8 non-data bytes                         `----.----'
  73                                                      |
  74        .- 'IP Packet' expands, if WEP enabled, to <--'
  75        |
  76        V
  77       ,-----------------------.
  78 Bytes |  4  |   0-2296  |  4  |
  79       |-----|-----------|-----|
  80 Desc. | IV  | Encrypted | ICV |
  81       |     | IP Packet |     |
  82       `-----------------------'
  83 Total: 8 non-data bytes
  84
  85
  86 802.3 Ethernet Data Frame
  87
  88       ,-----------------------------------------.
  89 Bytes |   6   |   6   |  2   |  Variable |   4  |
  90       |-------|-------|------|-----------|------|
  91 Desc. | Dest. | Source| Type | IP Packet |  fcs |
  92       |  MAC  |  MAC  |      |           |      |
  93       `-----------------------------------------'
  94 Total: 18 non-data bytes
  95
  96 In the event that fragmentation is required, the incoming payload is split into
  97 N parts of size ieee->fts.  The first fragment contains the SNAP header and the
  98 remaining packets are just data.
  99
 100 If encryption is enabled, each fragment payload size is reduced by enough space
 101 to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
 102 So if you have 1500 bytes of payload with ieee->fts set to 500 without
 103 encryption it will take 3 frames.  With WEP it will take 4 frames as the
 104 payload of each frame is reduced to 492 bytes.
 105
 106 * SKB visualization
 107 *
 108 *  ,- skb->data
 109 * |
 110 * |    ETHERNET HEADER        ,-<-- PAYLOAD
 111 * |                           |     14 bytes from skb->data
 112 * |  2 bytes for Type --> ,T. |     (sizeof ethhdr)
 113 * |                       | | |
 114 * |,-Dest.--. ,--Src.---. | | |
 115 * |  6 bytes| | 6 bytes | | | |
 116 * v         | |         | | | |
 117 * 0         | v       1 | v | v           2
 118 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
 119 *     ^     | ^         | ^ |
 120 *     |     | |         | | |
 121 *     |     | |         | `T' <---- 2 bytes for Type
 122 *     |     | |         |
 123 *     |     | '---SNAP--' <-------- 6 bytes for SNAP
 124 *     |     |
 125 *     `-IV--' <-------------------- 4 bytes for IV (WEP)
 126 *
 127 *      SNAP HEADER
 128 *
 129 */
 130
 131 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
 132 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
 133
 134 static inline int ieee80211_put_snap(u8 *data, u16 h_proto)
 135 {
 136         struct ieee80211_snap_hdr *snap;
 137         u8 *oui;
 138
 139         snap = (struct ieee80211_snap_hdr *)data;
 140         snap->dsap = 0xaa;
 141         snap->ssap = 0xaa;
 142         snap->ctrl = 0x03;
 143
 144         if (h_proto == 0x8137 || h_proto == 0x80f3)
 145                 oui = P802_1H_OUI;
 146         else
 147                 oui = RFC1042_OUI;
 148         snap->oui[0] = oui[0];
 149         snap->oui[1] = oui[1];
 150         snap->oui[2] = oui[2];
 151
 152         *(u16 *)(data + SNAP_SIZE) = htons(h_proto);
 153
 154         return SNAP_SIZE + sizeof(u16);
 155 }
 156
 157 static inline int ieee80211_encrypt_fragment(
 158         struct ieee80211_device *ieee,
 159         struct sk_buff *frag,
 160         int hdr_len)
 161 {
 162         struct ieee80211_crypt_data* crypt = ieee->crypt[ieee->tx_keyidx];
 163         int res;
 164
 165 #ifdef CONFIG_IEEE80211_CRYPT_TKIP
 166         struct ieee80211_hdr *header;
 167
 168         if (ieee->tkip_countermeasures &&
 169             crypt && crypt->ops && strcmp(crypt->ops->name, "TKIP") == 0) {
 170                 header = (struct ieee80211_hdr *) frag->data;
 171                 if (net_ratelimit()) {
 172                         printk(KERN_DEBUG "%s: TKIP countermeasures: dropped "
 173                                "TX packet to " MAC_FMT "\n",
 174                                ieee->dev->name, MAC_ARG(header->addr1));
 175                 }
 176                 return -1;
 177         }
 178 #endif
 179         /* To encrypt, frame format is:
 180          * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
 181
 182         // PR: FIXME: Copied from hostap. Check fragmentation/MSDU/MPDU encryption.
 183         /* Host-based IEEE 802.11 fragmentation for TX is not yet supported, so
 184          * call both MSDU and MPDU encryption functions from here. */
 185         atomic_inc(&crypt->refcnt);
 186         res = 0;
 187         if (crypt->ops->encrypt_msdu)
 188                 res = crypt->ops->encrypt_msdu(frag, hdr_len, crypt->priv);
 189         if (res == 0 && crypt->ops->encrypt_mpdu)
 190                 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
 191
 192         atomic_dec(&crypt->refcnt);
 193         if (res < 0) {
 194                 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
 195                        ieee->dev->name, frag->len);
 196                 ieee->ieee_stats.tx_discards++;
 197                 return -1;
 198         }
 199
 200         return 0;
 201 }
 202
 203
 204 void ieee80211_txb_free(struct ieee80211_txb *txb) {
 205         int i;
 206         if (unlikely(!txb))
 207                 return;
 208         for (i = 0; i < txb->nr_frags; i++)
 209                 if (txb->fragments[i])
 210                         dev_kfree_skb_any(txb->fragments[i]);
 211         kfree(txb);
 212 }
 213
 214 static struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
 215                                                  int gfp_mask)
 216 {
 217         struct ieee80211_txb *txb;
 218         int i;
 219         txb = kmalloc(
 220                 sizeof(struct ieee80211_txb) + (sizeof(u8*) * nr_frags),
 221                 gfp_mask);
 222         if (!txb)
 223                 return NULL;
 224
 225         memset(txb, 0, sizeof(struct ieee80211_txb));
 226         txb->nr_frags = nr_frags;
 227         txb->frag_size = txb_size;
 228
 229         for (i = 0; i < nr_frags; i++) {
 230                 txb->fragments[i] = dev_alloc_skb(txb_size);
 231                 if (unlikely(!txb->fragments[i])) {
 232                         i--;
 233                         break;
 234                 }
 235         }
 236         if (unlikely(i != nr_frags)) {
 237                 while (i >= 0)
 238                         dev_kfree_skb_any(txb->fragments[i--]);
 239                 kfree(txb);
 240                 return NULL;
 241         }
 242         return txb;
 243 }
 244
 245 /* SKBs are added to the ieee->tx_queue. */
 246 int ieee80211_xmit(struct sk_buff *skb,
 247                    struct net_device *dev)
 248 {
 249         struct ieee80211_device *ieee = netdev_priv(dev);
 250         struct ieee80211_txb *txb = NULL;
 251         struct ieee80211_hdr *frag_hdr;
 252         int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size;
 253         unsigned long flags;
 254         struct net_device_stats *stats = &ieee->stats;
 255         int ether_type, encrypt;
 256         int bytes, fc, hdr_len;
 257         struct sk_buff *skb_frag;
 258         struct ieee80211_hdr header = { /* Ensure zero initialized */
 259                 .duration_id = 0,
 260                 .seq_ctl = 0
 261         };
 262         u8 dest[ETH_ALEN], src[ETH_ALEN];
 263
 264         struct ieee80211_crypt_data* crypt;
 265
 266         spin_lock_irqsave(&ieee->lock, flags);
 267
 268         /* If there is no driver handler to take the TXB, dont' bother
 269          * creating it... */
 270         if (!ieee->hard_start_xmit) {
 271                 printk(KERN_WARNING "%s: No xmit handler.\n",
 272                        ieee->dev->name);
 273                 goto success;
 274         }
 275
 276         if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
 277                 printk(KERN_WARNING "%s: skb too small (%d).\n",
 278                        ieee->dev->name, skb->len);
 279                 goto success;
 280         }
 281
 282         ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
 283
 284         crypt = ieee->crypt[ieee->tx_keyidx];
 285
 286         encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
 287                 ieee->host_encrypt && crypt && crypt->ops;
 288
 289         if (!encrypt && ieee->ieee802_1x &&
 290             ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
 291                 stats->tx_dropped++;
 292                 goto success;
 293         }
 294
 295         /* Save source and destination addresses */
 296         memcpy(&dest, skb->data, ETH_ALEN);
 297         memcpy(&src, skb->data+ETH_ALEN, ETH_ALEN);
 298
 299         /* Advance the SKB to the start of the payload */
 300         skb_pull(skb, sizeof(struct ethhdr));
 301
 302         /* Determine total amount of storage required for TXB packets */
 303         bytes = skb->len + SNAP_SIZE + sizeof(u16);
 304
 305         if (encrypt)
 306                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
 307                         IEEE80211_FCTL_PROTECTED;
 308         else
 309                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
 310
 311         if (ieee->iw_mode == IW_MODE_INFRA) {
 312                 fc |= IEEE80211_FCTL_TODS;
 313                 /* To DS: Addr1 = BSSID, Addr2 = SA,
 314                    Addr3 = DA */
 315                 memcpy(&header.addr1, ieee->bssid, ETH_ALEN);
 316                 memcpy(&header.addr2, &src, ETH_ALEN);
 317                 memcpy(&header.addr3, &dest, ETH_ALEN);
 318         } else if (ieee->iw_mode == IW_MODE_ADHOC) {
 319                 /* not From/To DS: Addr1 = DA, Addr2 = SA,
 320                    Addr3 = BSSID */
 321                 memcpy(&header.addr1, dest, ETH_ALEN);
 322                 memcpy(&header.addr2, src, ETH_ALEN);
 323                 memcpy(&header.addr3, ieee->bssid, ETH_ALEN);
 324         }
 325         header.frame_ctl = cpu_to_le16(fc);
 326         hdr_len = IEEE80211_3ADDR_LEN;
 327
 328         /* Determine fragmentation size based on destination (multicast
 329          * and broadcast are not fragmented) */
 330         if (is_multicast_ether_addr(dest) ||
 331             is_broadcast_ether_addr(dest))
 332                 frag_size = MAX_FRAG_THRESHOLD;
 333         else
 334                 frag_size = ieee->fts;
 335
 336         /* Determine amount of payload per fragment.  Regardless of if
 337          * this stack is providing the full 802.11 header, one will
 338          * eventually be affixed to this fragment -- so we must account for
 339          * it when determining the amount of payload space. */
 340         bytes_per_frag = frag_size - IEEE80211_3ADDR_LEN;
 341         if (ieee->config &
 342             (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 343                 bytes_per_frag -= IEEE80211_FCS_LEN;
 344
 345         /* Each fragment may need to have room for encryptiong pre/postfix */
 346         if (encrypt)
 347                 bytes_per_frag -= crypt->ops->extra_prefix_len +
 348                         crypt->ops->extra_postfix_len;
 349
 350         /* Number of fragments is the total bytes_per_frag /
 351          * payload_per_fragment */
 352         nr_frags = bytes / bytes_per_frag;
 353         bytes_last_frag = bytes % bytes_per_frag;
 354         if (bytes_last_frag)
 355                 nr_frags++;
 356         else
 357                 bytes_last_frag = bytes_per_frag;
 358
 359         /* When we allocate the TXB we allocate enough space for the reserve
 360          * and full fragment bytes (bytes_per_frag doesn't include prefix,
 361          * postfix, header, FCS, etc.) */
 362         txb = ieee80211_alloc_txb(nr_frags, frag_size, GFP_ATOMIC);
 363         if (unlikely(!txb)) {
 364                 printk(KERN_WARNING "%s: Could not allocate TXB\n",
 365                        ieee->dev->name);
 366                 goto failed;
 367         }
 368         txb->encrypted = encrypt;
 369         txb->payload_size = bytes;
 370
 371         for (i = 0; i < nr_frags; i++) {
 372                 skb_frag = txb->fragments[i];
 373
 374                 if (encrypt)
 375                         skb_reserve(skb_frag, crypt->ops->extra_prefix_len);
 376
 377                 frag_hdr = (struct ieee80211_hdr *)skb_put(skb_frag, hdr_len);
 378                 memcpy(frag_hdr, &header, hdr_len);
 379
 380                 /* If this is not the last fragment, then add the MOREFRAGS
 381                  * bit to the frame control */
 382                 if (i != nr_frags - 1) {
 383                         frag_hdr->frame_ctl = cpu_to_le16(
 384                                 fc | IEEE80211_FCTL_MOREFRAGS);
 385                         bytes = bytes_per_frag;
 386                 } else {
 387                         /* The last fragment takes the remaining length */
 388                         bytes = bytes_last_frag;
 389                 }
 390
 391                 /* Put a SNAP header on the first fragment */
 392                 if (i == 0) {
 393                         ieee80211_put_snap(
 394                                 skb_put(skb_frag, SNAP_SIZE + sizeof(u16)),
 395                                 ether_type);
 396                         bytes -= SNAP_SIZE + sizeof(u16);
 397                 }
 398
 399                 memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
 400
 401                 /* Advance the SKB... */
 402                 skb_pull(skb, bytes);
 403
 404                 /* Encryption routine will move the header forward in order
 405                  * to insert the IV between the header and the payload */
 406                 if (encrypt)
 407                         ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
 408                 if (ieee->config &
 409                     (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 410                         skb_put(skb_frag, 4);
 411         }
 412
 413
 414  success:
 415         spin_unlock_irqrestore(&ieee->lock, flags);
 416
 417         dev_kfree_skb_any(skb);
 418
 419         if (txb) {
 420                 if ((*ieee->hard_start_xmit)(txb, dev) == 0) {
 421                         stats->tx_packets++;
 422                         stats->tx_bytes += txb->payload_size;
 423                         return 0;
 424                 }
 425                 ieee80211_txb_free(txb);
 426         }
 427
 428         return 0;
 429
 430  failed:
 431         spin_unlock_irqrestore(&ieee->lock, flags);
 432         netif_stop_queue(dev);
 433         stats->tx_errors++;
 434         return 1;
 435
 436 }
 437
 438 EXPORT_SYMBOL(ieee80211_txb_free);