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 #ifdef CONFIG_IEEE80211_DEBUG
 296         if (crypt && !encrypt && ether_type == ETH_P_PAE) {
 297                 struct eapol *eap = (struct eapol *)(skb->data +
 298                         sizeof(struct ethhdr) - SNAP_SIZE - sizeof(u16));
 299                 IEEE80211_DEBUG_EAP("TX: IEEE 802.11 EAPOL frame: %s\n",
 300                         eap_get_type(eap->type));
 301         }
 302 #endif
 303
 304         /* Save source and destination addresses */
 305         memcpy(&dest, skb->data, ETH_ALEN);
 306         memcpy(&src, skb->data+ETH_ALEN, ETH_ALEN);
 307
 308         /* Advance the SKB to the start of the payload */
 309         skb_pull(skb, sizeof(struct ethhdr));
 310
 311         /* Determine total amount of storage required for TXB packets */
 312         bytes = skb->len + SNAP_SIZE + sizeof(u16);
 313
 314         if (encrypt)
 315                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
 316                         IEEE80211_FCTL_WEP;
 317         else
 318                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
 319
 320         if (ieee->iw_mode == IW_MODE_INFRA) {
 321                 fc |= IEEE80211_FCTL_TODS;
 322                 /* To DS: Addr1 = BSSID, Addr2 = SA,
 323                    Addr3 = DA */
 324                 memcpy(&header.addr1, ieee->bssid, ETH_ALEN);
 325                 memcpy(&header.addr2, &src, ETH_ALEN);
 326                 memcpy(&header.addr3, &dest, ETH_ALEN);
 327         } else if (ieee->iw_mode == IW_MODE_ADHOC) {
 328                 /* not From/To DS: Addr1 = DA, Addr2 = SA,
 329                    Addr3 = BSSID */
 330                 memcpy(&header.addr1, dest, ETH_ALEN);
 331                 memcpy(&header.addr2, src, ETH_ALEN);
 332                 memcpy(&header.addr3, ieee->bssid, ETH_ALEN);
 333         }
 334         header.frame_ctl = cpu_to_le16(fc);
 335         hdr_len = IEEE80211_3ADDR_LEN;
 336
 337         /* Determine fragmentation size based on destination (multicast
 338          * and broadcast are not fragmented) */
 339         if (is_multicast_ether_addr(dest) ||
 340             is_broadcast_ether_addr(dest))
 341                 frag_size = MAX_FRAG_THRESHOLD;
 342         else
 343                 frag_size = ieee->fts;
 344
 345         /* Determine amount of payload per fragment.  Regardless of if
 346          * this stack is providing the full 802.11 header, one will
 347          * eventually be affixed to this fragment -- so we must account for
 348          * it when determining the amount of payload space. */
 349         bytes_per_frag = frag_size - IEEE80211_3ADDR_LEN;
 350         if (ieee->config &
 351             (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 352                 bytes_per_frag -= IEEE80211_FCS_LEN;
 353
 354         /* Each fragment may need to have room for encryptiong pre/postfix */
 355         if (encrypt)
 356                 bytes_per_frag -= crypt->ops->extra_prefix_len +
 357                         crypt->ops->extra_postfix_len;
 358
 359         /* Number of fragments is the total bytes_per_frag /
 360          * payload_per_fragment */
 361         nr_frags = bytes / bytes_per_frag;
 362         bytes_last_frag = bytes % bytes_per_frag;
 363         if (bytes_last_frag)
 364                 nr_frags++;
 365         else
 366                 bytes_last_frag = bytes_per_frag;
 367
 368         /* When we allocate the TXB we allocate enough space for the reserve
 369          * and full fragment bytes (bytes_per_frag doesn't include prefix,
 370          * postfix, header, FCS, etc.) */
 371         txb = ieee80211_alloc_txb(nr_frags, frag_size, GFP_ATOMIC);
 372         if (unlikely(!txb)) {
 373                 printk(KERN_WARNING "%s: Could not allocate TXB\n",
 374                        ieee->dev->name);
 375                 goto failed;
 376         }
 377         txb->encrypted = encrypt;
 378         txb->payload_size = bytes;
 379
 380         for (i = 0; i < nr_frags; i++) {
 381                 skb_frag = txb->fragments[i];
 382
 383                 if (encrypt)
 384                         skb_reserve(skb_frag, crypt->ops->extra_prefix_len);
 385
 386                 frag_hdr = (struct ieee80211_hdr *)skb_put(skb_frag, hdr_len);
 387                 memcpy(frag_hdr, &header, hdr_len);
 388
 389                 /* If this is not the last fragment, then add the MOREFRAGS
 390                  * bit to the frame control */
 391                 if (i != nr_frags - 1) {
 392                         frag_hdr->frame_ctl = cpu_to_le16(
 393                                 fc | IEEE80211_FCTL_MOREFRAGS);
 394                         bytes = bytes_per_frag;
 395                 } else {
 396                         /* The last fragment takes the remaining length */
 397                         bytes = bytes_last_frag;
 398                 }
 399
 400                 /* Put a SNAP header on the first fragment */
 401                 if (i == 0) {
 402                         ieee80211_put_snap(
 403                                 skb_put(skb_frag, SNAP_SIZE + sizeof(u16)),
 404                                 ether_type);
 405                         bytes -= SNAP_SIZE + sizeof(u16);
 406                 }
 407
 408                 memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
 409
 410                 /* Advance the SKB... */
 411                 skb_pull(skb, bytes);
 412
 413                 /* Encryption routine will move the header forward in order
 414                  * to insert the IV between the header and the payload */
 415                 if (encrypt)
 416                         ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
 417                 if (ieee->config &
 418                     (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 419                         skb_put(skb_frag, 4);
 420         }
 421
 422
 423  success:
 424         spin_unlock_irqrestore(&ieee->lock, flags);
 425
 426         dev_kfree_skb_any(skb);
 427
 428         if (txb) {
 429                 if ((*ieee->hard_start_xmit)(txb, dev) == 0) {
 430                         stats->tx_packets++;
 431                         stats->tx_bytes += txb->payload_size;
 432                         return 0;
 433                 }
 434                 ieee80211_txb_free(txb);
 435         }
 436
 437         return 0;
 438
 439  failed:
 440         spin_unlock_irqrestore(&ieee->lock, flags);
 441         netif_stop_queue(dev);
 442         stats->tx_errors++;
 443         return 1;
 444
 445 }
 446
 447 EXPORT_SYMBOL(ieee80211_txb_free);