Loading...
1#include <linux/slab.h>
2
3#include "hostap_80211.h"
4#include "hostap_common.h"
5#include "hostap_wlan.h"
6#include "hostap.h"
7#include "hostap_ap.h"
8
9/* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
10/* Ethernet-II snap header (RFC1042 for most EtherTypes) */
11static unsigned char rfc1042_header[] =
12{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
13/* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
14static unsigned char bridge_tunnel_header[] =
15{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
16/* No encapsulation header if EtherType < 0x600 (=length) */
17
18void hostap_dump_tx_80211(const char *name, struct sk_buff *skb)
19{
20 struct ieee80211_hdr *hdr;
21 u16 fc;
22
23 hdr = (struct ieee80211_hdr *) skb->data;
24
25 printk(KERN_DEBUG "%s: TX len=%d jiffies=%ld\n",
26 name, skb->len, jiffies);
27
28 if (skb->len < 2)
29 return;
30
31 fc = le16_to_cpu(hdr->frame_control);
32 printk(KERN_DEBUG " FC=0x%04x (type=%d:%d)%s%s",
33 fc, (fc & IEEE80211_FCTL_FTYPE) >> 2,
34 (fc & IEEE80211_FCTL_STYPE) >> 4,
35 fc & IEEE80211_FCTL_TODS ? " [ToDS]" : "",
36 fc & IEEE80211_FCTL_FROMDS ? " [FromDS]" : "");
37
38 if (skb->len < IEEE80211_DATA_HDR3_LEN) {
39 printk("\n");
40 return;
41 }
42
43 printk(" dur=0x%04x seq=0x%04x\n", le16_to_cpu(hdr->duration_id),
44 le16_to_cpu(hdr->seq_ctrl));
45
46 printk(KERN_DEBUG " A1=%pM", hdr->addr1);
47 printk(" A2=%pM", hdr->addr2);
48 printk(" A3=%pM", hdr->addr3);
49 if (skb->len >= 30)
50 printk(" A4=%pM", hdr->addr4);
51 printk("\n");
52}
53
54
55/* hard_start_xmit function for data interfaces (wlan#, wlan#wds#, wlan#sta)
56 * Convert Ethernet header into a suitable IEEE 802.11 header depending on
57 * device configuration. */
58netdev_tx_t hostap_data_start_xmit(struct sk_buff *skb,
59 struct net_device *dev)
60{
61 struct hostap_interface *iface;
62 local_info_t *local;
63 int need_headroom, need_tailroom = 0;
64 struct ieee80211_hdr hdr;
65 u16 fc, ethertype = 0;
66 enum {
67 WDS_NO = 0, WDS_OWN_FRAME, WDS_COMPLIANT_FRAME
68 } use_wds = WDS_NO;
69 u8 *encaps_data;
70 int hdr_len, encaps_len, skip_header_bytes;
71 int to_assoc_ap = 0;
72 struct hostap_skb_tx_data *meta;
73
74 iface = netdev_priv(dev);
75 local = iface->local;
76
77 if (skb->len < ETH_HLEN) {
78 printk(KERN_DEBUG "%s: hostap_data_start_xmit: short skb "
79 "(len=%d)\n", dev->name, skb->len);
80 kfree_skb(skb);
81 return NETDEV_TX_OK;
82 }
83
84 if (local->ddev != dev) {
85 use_wds = (local->iw_mode == IW_MODE_MASTER &&
86 !(local->wds_type & HOSTAP_WDS_STANDARD_FRAME)) ?
87 WDS_OWN_FRAME : WDS_COMPLIANT_FRAME;
88 if (dev == local->stadev) {
89 to_assoc_ap = 1;
90 use_wds = WDS_NO;
91 } else if (dev == local->apdev) {
92 printk(KERN_DEBUG "%s: prism2_tx: trying to use "
93 "AP device with Ethernet net dev\n", dev->name);
94 kfree_skb(skb);
95 return NETDEV_TX_OK;
96 }
97 } else {
98 if (local->iw_mode == IW_MODE_REPEAT) {
99 printk(KERN_DEBUG "%s: prism2_tx: trying to use "
100 "non-WDS link in Repeater mode\n", dev->name);
101 kfree_skb(skb);
102 return NETDEV_TX_OK;
103 } else if (local->iw_mode == IW_MODE_INFRA &&
104 (local->wds_type & HOSTAP_WDS_AP_CLIENT) &&
105 memcmp(skb->data + ETH_ALEN, dev->dev_addr,
106 ETH_ALEN) != 0) {
107 /* AP client mode: send frames with foreign src addr
108 * using 4-addr WDS frames */
109 use_wds = WDS_COMPLIANT_FRAME;
110 }
111 }
112
113 /* Incoming skb->data: dst_addr[6], src_addr[6], proto[2], payload
114 * ==>
115 * Prism2 TX frame with 802.11 header:
116 * txdesc (address order depending on used mode; includes dst_addr and
117 * src_addr), possible encapsulation (RFC1042/Bridge-Tunnel;
118 * proto[2], payload {, possible addr4[6]} */
119
120 ethertype = (skb->data[12] << 8) | skb->data[13];
121
122 memset(&hdr, 0, sizeof(hdr));
123
124 /* Length of data after IEEE 802.11 header */
125 encaps_data = NULL;
126 encaps_len = 0;
127 skip_header_bytes = ETH_HLEN;
128 if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) {
129 encaps_data = bridge_tunnel_header;
130 encaps_len = sizeof(bridge_tunnel_header);
131 skip_header_bytes -= 2;
132 } else if (ethertype >= 0x600) {
133 encaps_data = rfc1042_header;
134 encaps_len = sizeof(rfc1042_header);
135 skip_header_bytes -= 2;
136 }
137
138 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
139 hdr_len = IEEE80211_DATA_HDR3_LEN;
140
141 if (use_wds != WDS_NO) {
142 /* Note! Prism2 station firmware has problems with sending real
143 * 802.11 frames with four addresses; until these problems can
144 * be fixed or worked around, 4-addr frames needed for WDS are
145 * using incompatible format: FromDS flag is not set and the
146 * fourth address is added after the frame payload; it is
147 * assumed, that the receiving station knows how to handle this
148 * frame format */
149
150 if (use_wds == WDS_COMPLIANT_FRAME) {
151 fc |= IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS;
152 /* From&To DS: Addr1 = RA, Addr2 = TA, Addr3 = DA,
153 * Addr4 = SA */
154 skb_copy_from_linear_data_offset(skb, ETH_ALEN,
155 &hdr.addr4, ETH_ALEN);
156 hdr_len += ETH_ALEN;
157 } else {
158 /* bogus 4-addr format to workaround Prism2 station
159 * f/w bug */
160 fc |= IEEE80211_FCTL_TODS;
161 /* From DS: Addr1 = DA (used as RA),
162 * Addr2 = BSSID (used as TA), Addr3 = SA (used as DA),
163 */
164
165 /* SA from skb->data + ETH_ALEN will be added after
166 * frame payload; use hdr.addr4 as a temporary buffer
167 */
168 skb_copy_from_linear_data_offset(skb, ETH_ALEN,
169 &hdr.addr4, ETH_ALEN);
170 need_tailroom += ETH_ALEN;
171 }
172
173 /* send broadcast and multicast frames to broadcast RA, if
174 * configured; otherwise, use unicast RA of the WDS link */
175 if ((local->wds_type & HOSTAP_WDS_BROADCAST_RA) &&
176 skb->data[0] & 0x01)
177 memset(&hdr.addr1, 0xff, ETH_ALEN);
178 else if (iface->type == HOSTAP_INTERFACE_WDS)
179 memcpy(&hdr.addr1, iface->u.wds.remote_addr,
180 ETH_ALEN);
181 else
182 memcpy(&hdr.addr1, local->bssid, ETH_ALEN);
183 memcpy(&hdr.addr2, dev->dev_addr, ETH_ALEN);
184 skb_copy_from_linear_data(skb, &hdr.addr3, ETH_ALEN);
185 } else if (local->iw_mode == IW_MODE_MASTER && !to_assoc_ap) {
186 fc |= IEEE80211_FCTL_FROMDS;
187 /* From DS: Addr1 = DA, Addr2 = BSSID, Addr3 = SA */
188 skb_copy_from_linear_data(skb, &hdr.addr1, ETH_ALEN);
189 memcpy(&hdr.addr2, dev->dev_addr, ETH_ALEN);
190 skb_copy_from_linear_data_offset(skb, ETH_ALEN, &hdr.addr3,
191 ETH_ALEN);
192 } else if (local->iw_mode == IW_MODE_INFRA || to_assoc_ap) {
193 fc |= IEEE80211_FCTL_TODS;
194 /* To DS: Addr1 = BSSID, Addr2 = SA, Addr3 = DA */
195 memcpy(&hdr.addr1, to_assoc_ap ?
196 local->assoc_ap_addr : local->bssid, ETH_ALEN);
197 skb_copy_from_linear_data_offset(skb, ETH_ALEN, &hdr.addr2,
198 ETH_ALEN);
199 skb_copy_from_linear_data(skb, &hdr.addr3, ETH_ALEN);
200 } else if (local->iw_mode == IW_MODE_ADHOC) {
201 /* not From/To DS: Addr1 = DA, Addr2 = SA, Addr3 = BSSID */
202 skb_copy_from_linear_data(skb, &hdr.addr1, ETH_ALEN);
203 skb_copy_from_linear_data_offset(skb, ETH_ALEN, &hdr.addr2,
204 ETH_ALEN);
205 memcpy(&hdr.addr3, local->bssid, ETH_ALEN);
206 }
207
208 hdr.frame_control = cpu_to_le16(fc);
209
210 skb_pull(skb, skip_header_bytes);
211 need_headroom = local->func->need_tx_headroom + hdr_len + encaps_len;
212 if (skb_tailroom(skb) < need_tailroom) {
213 skb = skb_unshare(skb, GFP_ATOMIC);
214 if (skb == NULL) {
215 iface->stats.tx_dropped++;
216 return NETDEV_TX_OK;
217 }
218 if (pskb_expand_head(skb, need_headroom, need_tailroom,
219 GFP_ATOMIC)) {
220 kfree_skb(skb);
221 iface->stats.tx_dropped++;
222 return NETDEV_TX_OK;
223 }
224 } else if (skb_headroom(skb) < need_headroom) {
225 struct sk_buff *tmp = skb;
226 skb = skb_realloc_headroom(skb, need_headroom);
227 kfree_skb(tmp);
228 if (skb == NULL) {
229 iface->stats.tx_dropped++;
230 return NETDEV_TX_OK;
231 }
232 } else {
233 skb = skb_unshare(skb, GFP_ATOMIC);
234 if (skb == NULL) {
235 iface->stats.tx_dropped++;
236 return NETDEV_TX_OK;
237 }
238 }
239
240 if (encaps_data)
241 memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len);
242 memcpy(skb_push(skb, hdr_len), &hdr, hdr_len);
243 if (use_wds == WDS_OWN_FRAME) {
244 memcpy(skb_put(skb, ETH_ALEN), &hdr.addr4, ETH_ALEN);
245 }
246
247 iface->stats.tx_packets++;
248 iface->stats.tx_bytes += skb->len;
249
250 skb_reset_mac_header(skb);
251 meta = (struct hostap_skb_tx_data *) skb->cb;
252 memset(meta, 0, sizeof(*meta));
253 meta->magic = HOSTAP_SKB_TX_DATA_MAGIC;
254 if (use_wds)
255 meta->flags |= HOSTAP_TX_FLAGS_WDS;
256 meta->ethertype = ethertype;
257 meta->iface = iface;
258
259 /* Send IEEE 802.11 encapsulated frame using the master radio device */
260 skb->dev = local->dev;
261 dev_queue_xmit(skb);
262 return NETDEV_TX_OK;
263}
264
265
266/* hard_start_xmit function for hostapd wlan#ap interfaces */
267netdev_tx_t hostap_mgmt_start_xmit(struct sk_buff *skb,
268 struct net_device *dev)
269{
270 struct hostap_interface *iface;
271 local_info_t *local;
272 struct hostap_skb_tx_data *meta;
273 struct ieee80211_hdr *hdr;
274 u16 fc;
275
276 iface = netdev_priv(dev);
277 local = iface->local;
278
279 if (skb->len < 10) {
280 printk(KERN_DEBUG "%s: hostap_mgmt_start_xmit: short skb "
281 "(len=%d)\n", dev->name, skb->len);
282 kfree_skb(skb);
283 return NETDEV_TX_OK;
284 }
285
286 iface->stats.tx_packets++;
287 iface->stats.tx_bytes += skb->len;
288
289 meta = (struct hostap_skb_tx_data *) skb->cb;
290 memset(meta, 0, sizeof(*meta));
291 meta->magic = HOSTAP_SKB_TX_DATA_MAGIC;
292 meta->iface = iface;
293
294 if (skb->len >= IEEE80211_DATA_HDR3_LEN + sizeof(rfc1042_header) + 2) {
295 hdr = (struct ieee80211_hdr *) skb->data;
296 fc = le16_to_cpu(hdr->frame_control);
297 if (ieee80211_is_data(hdr->frame_control) &&
298 (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_DATA) {
299 u8 *pos = &skb->data[IEEE80211_DATA_HDR3_LEN +
300 sizeof(rfc1042_header)];
301 meta->ethertype = (pos[0] << 8) | pos[1];
302 }
303 }
304
305 /* Send IEEE 802.11 encapsulated frame using the master radio device */
306 skb->dev = local->dev;
307 dev_queue_xmit(skb);
308 return NETDEV_TX_OK;
309}
310
311
312/* Called only from software IRQ */
313static struct sk_buff * hostap_tx_encrypt(struct sk_buff *skb,
314 struct lib80211_crypt_data *crypt)
315{
316 struct hostap_interface *iface;
317 local_info_t *local;
318 struct ieee80211_hdr *hdr;
319 int prefix_len, postfix_len, hdr_len, res;
320
321 iface = netdev_priv(skb->dev);
322 local = iface->local;
323
324 if (skb->len < IEEE80211_DATA_HDR3_LEN) {
325 kfree_skb(skb);
326 return NULL;
327 }
328
329 if (local->tkip_countermeasures &&
330 strcmp(crypt->ops->name, "TKIP") == 0) {
331 hdr = (struct ieee80211_hdr *) skb->data;
332 if (net_ratelimit()) {
333 printk(KERN_DEBUG "%s: TKIP countermeasures: dropped "
334 "TX packet to %pM\n",
335 local->dev->name, hdr->addr1);
336 }
337 kfree_skb(skb);
338 return NULL;
339 }
340
341 skb = skb_unshare(skb, GFP_ATOMIC);
342 if (skb == NULL)
343 return NULL;
344
345 prefix_len = crypt->ops->extra_mpdu_prefix_len +
346 crypt->ops->extra_msdu_prefix_len;
347 postfix_len = crypt->ops->extra_mpdu_postfix_len +
348 crypt->ops->extra_msdu_postfix_len;
349 if ((skb_headroom(skb) < prefix_len ||
350 skb_tailroom(skb) < postfix_len) &&
351 pskb_expand_head(skb, prefix_len, postfix_len, GFP_ATOMIC)) {
352 kfree_skb(skb);
353 return NULL;
354 }
355
356 hdr = (struct ieee80211_hdr *) skb->data;
357 hdr_len = hostap_80211_get_hdrlen(hdr->frame_control);
358
359 /* Host-based IEEE 802.11 fragmentation for TX is not yet supported, so
360 * call both MSDU and MPDU encryption functions from here. */
361 atomic_inc(&crypt->refcnt);
362 res = 0;
363 if (crypt->ops->encrypt_msdu)
364 res = crypt->ops->encrypt_msdu(skb, hdr_len, crypt->priv);
365 if (res == 0 && crypt->ops->encrypt_mpdu)
366 res = crypt->ops->encrypt_mpdu(skb, hdr_len, crypt->priv);
367 atomic_dec(&crypt->refcnt);
368 if (res < 0) {
369 kfree_skb(skb);
370 return NULL;
371 }
372
373 return skb;
374}
375
376
377/* hard_start_xmit function for master radio interface wifi#.
378 * AP processing (TX rate control, power save buffering, etc.).
379 * Use hardware TX function to send the frame. */
380netdev_tx_t hostap_master_start_xmit(struct sk_buff *skb,
381 struct net_device *dev)
382{
383 struct hostap_interface *iface;
384 local_info_t *local;
385 netdev_tx_t ret = NETDEV_TX_BUSY;
386 u16 fc;
387 struct hostap_tx_data tx;
388 ap_tx_ret tx_ret;
389 struct hostap_skb_tx_data *meta;
390 int no_encrypt = 0;
391 struct ieee80211_hdr *hdr;
392
393 iface = netdev_priv(dev);
394 local = iface->local;
395
396 tx.skb = skb;
397 tx.sta_ptr = NULL;
398
399 meta = (struct hostap_skb_tx_data *) skb->cb;
400 if (meta->magic != HOSTAP_SKB_TX_DATA_MAGIC) {
401 printk(KERN_DEBUG "%s: invalid skb->cb magic (0x%08x, "
402 "expected 0x%08x)\n",
403 dev->name, meta->magic, HOSTAP_SKB_TX_DATA_MAGIC);
404 ret = NETDEV_TX_OK;
405 iface->stats.tx_dropped++;
406 goto fail;
407 }
408
409 if (local->host_encrypt) {
410 /* Set crypt to default algorithm and key; will be replaced in
411 * AP code if STA has own alg/key */
412 tx.crypt = local->crypt_info.crypt[local->crypt_info.tx_keyidx];
413 tx.host_encrypt = 1;
414 } else {
415 tx.crypt = NULL;
416 tx.host_encrypt = 0;
417 }
418
419 if (skb->len < 24) {
420 printk(KERN_DEBUG "%s: hostap_master_start_xmit: short skb "
421 "(len=%d)\n", dev->name, skb->len);
422 ret = NETDEV_TX_OK;
423 iface->stats.tx_dropped++;
424 goto fail;
425 }
426
427 /* FIX (?):
428 * Wi-Fi 802.11b test plan suggests that AP should ignore power save
429 * bit in authentication and (re)association frames and assume tha
430 * STA remains awake for the response. */
431 tx_ret = hostap_handle_sta_tx(local, &tx);
432 skb = tx.skb;
433 meta = (struct hostap_skb_tx_data *) skb->cb;
434 hdr = (struct ieee80211_hdr *) skb->data;
435 fc = le16_to_cpu(hdr->frame_control);
436 switch (tx_ret) {
437 case AP_TX_CONTINUE:
438 break;
439 case AP_TX_CONTINUE_NOT_AUTHORIZED:
440 if (local->ieee_802_1x &&
441 ieee80211_is_data(hdr->frame_control) &&
442 meta->ethertype != ETH_P_PAE &&
443 !(meta->flags & HOSTAP_TX_FLAGS_WDS)) {
444 printk(KERN_DEBUG "%s: dropped frame to unauthorized "
445 "port (IEEE 802.1X): ethertype=0x%04x\n",
446 dev->name, meta->ethertype);
447 hostap_dump_tx_80211(dev->name, skb);
448
449 ret = NETDEV_TX_OK; /* drop packet */
450 iface->stats.tx_dropped++;
451 goto fail;
452 }
453 break;
454 case AP_TX_DROP:
455 ret = NETDEV_TX_OK; /* drop packet */
456 iface->stats.tx_dropped++;
457 goto fail;
458 case AP_TX_RETRY:
459 goto fail;
460 case AP_TX_BUFFERED:
461 /* do not free skb here, it will be freed when the
462 * buffered frame is sent/timed out */
463 ret = NETDEV_TX_OK;
464 goto tx_exit;
465 }
466
467 /* Request TX callback if protocol version is 2 in 802.11 header;
468 * this version 2 is a special case used between hostapd and kernel
469 * driver */
470 if (((fc & IEEE80211_FCTL_VERS) == BIT(1)) &&
471 local->ap && local->ap->tx_callback_idx && meta->tx_cb_idx == 0) {
472 meta->tx_cb_idx = local->ap->tx_callback_idx;
473
474 /* remove special version from the frame header */
475 fc &= ~IEEE80211_FCTL_VERS;
476 hdr->frame_control = cpu_to_le16(fc);
477 }
478
479 if (!ieee80211_is_data(hdr->frame_control)) {
480 no_encrypt = 1;
481 tx.crypt = NULL;
482 }
483
484 if (local->ieee_802_1x && meta->ethertype == ETH_P_PAE && tx.crypt &&
485 !(fc & IEEE80211_FCTL_PROTECTED)) {
486 no_encrypt = 1;
487 PDEBUG(DEBUG_EXTRA2, "%s: TX: IEEE 802.1X - passing "
488 "unencrypted EAPOL frame\n", dev->name);
489 tx.crypt = NULL; /* no encryption for IEEE 802.1X frames */
490 }
491
492 if (tx.crypt && (!tx.crypt->ops || !tx.crypt->ops->encrypt_mpdu))
493 tx.crypt = NULL;
494 else if ((tx.crypt ||
495 local->crypt_info.crypt[local->crypt_info.tx_keyidx]) &&
496 !no_encrypt) {
497 /* Add ISWEP flag both for firmware and host based encryption
498 */
499 fc |= IEEE80211_FCTL_PROTECTED;
500 hdr->frame_control = cpu_to_le16(fc);
501 } else if (local->drop_unencrypted &&
502 ieee80211_is_data(hdr->frame_control) &&
503 meta->ethertype != ETH_P_PAE) {
504 if (net_ratelimit()) {
505 printk(KERN_DEBUG "%s: dropped unencrypted TX data "
506 "frame (drop_unencrypted=1)\n", dev->name);
507 }
508 iface->stats.tx_dropped++;
509 ret = NETDEV_TX_OK;
510 goto fail;
511 }
512
513 if (tx.crypt) {
514 skb = hostap_tx_encrypt(skb, tx.crypt);
515 if (skb == NULL) {
516 printk(KERN_DEBUG "%s: TX - encryption failed\n",
517 dev->name);
518 ret = NETDEV_TX_OK;
519 goto fail;
520 }
521 meta = (struct hostap_skb_tx_data *) skb->cb;
522 if (meta->magic != HOSTAP_SKB_TX_DATA_MAGIC) {
523 printk(KERN_DEBUG "%s: invalid skb->cb magic (0x%08x, "
524 "expected 0x%08x) after hostap_tx_encrypt\n",
525 dev->name, meta->magic,
526 HOSTAP_SKB_TX_DATA_MAGIC);
527 ret = NETDEV_TX_OK;
528 iface->stats.tx_dropped++;
529 goto fail;
530 }
531 }
532
533 if (local->func->tx == NULL || local->func->tx(skb, dev)) {
534 ret = NETDEV_TX_OK;
535 iface->stats.tx_dropped++;
536 } else {
537 ret = NETDEV_TX_OK;
538 iface->stats.tx_packets++;
539 iface->stats.tx_bytes += skb->len;
540 }
541
542 fail:
543 if (ret == NETDEV_TX_OK && skb)
544 dev_kfree_skb(skb);
545 tx_exit:
546 if (tx.sta_ptr)
547 hostap_handle_sta_release(tx.sta_ptr);
548 return ret;
549}
550
551
552EXPORT_SYMBOL(hostap_master_start_xmit);
1#include <linux/slab.h>
2#include <linux/export.h>
3
4#include "hostap_80211.h"
5#include "hostap_common.h"
6#include "hostap_wlan.h"
7#include "hostap.h"
8#include "hostap_ap.h"
9
10/* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
11/* Ethernet-II snap header (RFC1042 for most EtherTypes) */
12static unsigned char rfc1042_header[] =
13{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
14/* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
15static unsigned char bridge_tunnel_header[] =
16{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
17/* No encapsulation header if EtherType < 0x600 (=length) */
18
19void hostap_dump_tx_80211(const char *name, struct sk_buff *skb)
20{
21 struct ieee80211_hdr *hdr;
22 u16 fc;
23
24 hdr = (struct ieee80211_hdr *) skb->data;
25
26 printk(KERN_DEBUG "%s: TX len=%d jiffies=%ld\n",
27 name, skb->len, jiffies);
28
29 if (skb->len < 2)
30 return;
31
32 fc = le16_to_cpu(hdr->frame_control);
33 printk(KERN_DEBUG " FC=0x%04x (type=%d:%d)%s%s",
34 fc, (fc & IEEE80211_FCTL_FTYPE) >> 2,
35 (fc & IEEE80211_FCTL_STYPE) >> 4,
36 fc & IEEE80211_FCTL_TODS ? " [ToDS]" : "",
37 fc & IEEE80211_FCTL_FROMDS ? " [FromDS]" : "");
38
39 if (skb->len < IEEE80211_DATA_HDR3_LEN) {
40 printk("\n");
41 return;
42 }
43
44 printk(" dur=0x%04x seq=0x%04x\n", le16_to_cpu(hdr->duration_id),
45 le16_to_cpu(hdr->seq_ctrl));
46
47 printk(KERN_DEBUG " A1=%pM", hdr->addr1);
48 printk(" A2=%pM", hdr->addr2);
49 printk(" A3=%pM", hdr->addr3);
50 if (skb->len >= 30)
51 printk(" A4=%pM", hdr->addr4);
52 printk("\n");
53}
54
55
56/* hard_start_xmit function for data interfaces (wlan#, wlan#wds#, wlan#sta)
57 * Convert Ethernet header into a suitable IEEE 802.11 header depending on
58 * device configuration. */
59netdev_tx_t hostap_data_start_xmit(struct sk_buff *skb,
60 struct net_device *dev)
61{
62 struct hostap_interface *iface;
63 local_info_t *local;
64 int need_headroom, need_tailroom = 0;
65 struct ieee80211_hdr hdr;
66 u16 fc, ethertype = 0;
67 enum {
68 WDS_NO = 0, WDS_OWN_FRAME, WDS_COMPLIANT_FRAME
69 } use_wds = WDS_NO;
70 u8 *encaps_data;
71 int hdr_len, encaps_len, skip_header_bytes;
72 int to_assoc_ap = 0;
73 struct hostap_skb_tx_data *meta;
74
75 iface = netdev_priv(dev);
76 local = iface->local;
77
78 if (skb->len < ETH_HLEN) {
79 printk(KERN_DEBUG "%s: hostap_data_start_xmit: short skb "
80 "(len=%d)\n", dev->name, skb->len);
81 kfree_skb(skb);
82 return NETDEV_TX_OK;
83 }
84
85 if (local->ddev != dev) {
86 use_wds = (local->iw_mode == IW_MODE_MASTER &&
87 !(local->wds_type & HOSTAP_WDS_STANDARD_FRAME)) ?
88 WDS_OWN_FRAME : WDS_COMPLIANT_FRAME;
89 if (dev == local->stadev) {
90 to_assoc_ap = 1;
91 use_wds = WDS_NO;
92 } else if (dev == local->apdev) {
93 printk(KERN_DEBUG "%s: prism2_tx: trying to use "
94 "AP device with Ethernet net dev\n", dev->name);
95 kfree_skb(skb);
96 return NETDEV_TX_OK;
97 }
98 } else {
99 if (local->iw_mode == IW_MODE_REPEAT) {
100 printk(KERN_DEBUG "%s: prism2_tx: trying to use "
101 "non-WDS link in Repeater mode\n", dev->name);
102 kfree_skb(skb);
103 return NETDEV_TX_OK;
104 } else if (local->iw_mode == IW_MODE_INFRA &&
105 (local->wds_type & HOSTAP_WDS_AP_CLIENT) &&
106 memcmp(skb->data + ETH_ALEN, dev->dev_addr,
107 ETH_ALEN) != 0) {
108 /* AP client mode: send frames with foreign src addr
109 * using 4-addr WDS frames */
110 use_wds = WDS_COMPLIANT_FRAME;
111 }
112 }
113
114 /* Incoming skb->data: dst_addr[6], src_addr[6], proto[2], payload
115 * ==>
116 * Prism2 TX frame with 802.11 header:
117 * txdesc (address order depending on used mode; includes dst_addr and
118 * src_addr), possible encapsulation (RFC1042/Bridge-Tunnel;
119 * proto[2], payload {, possible addr4[6]} */
120
121 ethertype = (skb->data[12] << 8) | skb->data[13];
122
123 memset(&hdr, 0, sizeof(hdr));
124
125 /* Length of data after IEEE 802.11 header */
126 encaps_data = NULL;
127 encaps_len = 0;
128 skip_header_bytes = ETH_HLEN;
129 if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) {
130 encaps_data = bridge_tunnel_header;
131 encaps_len = sizeof(bridge_tunnel_header);
132 skip_header_bytes -= 2;
133 } else if (ethertype >= 0x600) {
134 encaps_data = rfc1042_header;
135 encaps_len = sizeof(rfc1042_header);
136 skip_header_bytes -= 2;
137 }
138
139 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
140 hdr_len = IEEE80211_DATA_HDR3_LEN;
141
142 if (use_wds != WDS_NO) {
143 /* Note! Prism2 station firmware has problems with sending real
144 * 802.11 frames with four addresses; until these problems can
145 * be fixed or worked around, 4-addr frames needed for WDS are
146 * using incompatible format: FromDS flag is not set and the
147 * fourth address is added after the frame payload; it is
148 * assumed, that the receiving station knows how to handle this
149 * frame format */
150
151 if (use_wds == WDS_COMPLIANT_FRAME) {
152 fc |= IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS;
153 /* From&To DS: Addr1 = RA, Addr2 = TA, Addr3 = DA,
154 * Addr4 = SA */
155 skb_copy_from_linear_data_offset(skb, ETH_ALEN,
156 &hdr.addr4, ETH_ALEN);
157 hdr_len += ETH_ALEN;
158 } else {
159 /* bogus 4-addr format to workaround Prism2 station
160 * f/w bug */
161 fc |= IEEE80211_FCTL_TODS;
162 /* From DS: Addr1 = DA (used as RA),
163 * Addr2 = BSSID (used as TA), Addr3 = SA (used as DA),
164 */
165
166 /* SA from skb->data + ETH_ALEN will be added after
167 * frame payload; use hdr.addr4 as a temporary buffer
168 */
169 skb_copy_from_linear_data_offset(skb, ETH_ALEN,
170 &hdr.addr4, ETH_ALEN);
171 need_tailroom += ETH_ALEN;
172 }
173
174 /* send broadcast and multicast frames to broadcast RA, if
175 * configured; otherwise, use unicast RA of the WDS link */
176 if ((local->wds_type & HOSTAP_WDS_BROADCAST_RA) &&
177 skb->data[0] & 0x01)
178 memset(&hdr.addr1, 0xff, ETH_ALEN);
179 else if (iface->type == HOSTAP_INTERFACE_WDS)
180 memcpy(&hdr.addr1, iface->u.wds.remote_addr,
181 ETH_ALEN);
182 else
183 memcpy(&hdr.addr1, local->bssid, ETH_ALEN);
184 memcpy(&hdr.addr2, dev->dev_addr, ETH_ALEN);
185 skb_copy_from_linear_data(skb, &hdr.addr3, ETH_ALEN);
186 } else if (local->iw_mode == IW_MODE_MASTER && !to_assoc_ap) {
187 fc |= IEEE80211_FCTL_FROMDS;
188 /* From DS: Addr1 = DA, Addr2 = BSSID, Addr3 = SA */
189 skb_copy_from_linear_data(skb, &hdr.addr1, ETH_ALEN);
190 memcpy(&hdr.addr2, dev->dev_addr, ETH_ALEN);
191 skb_copy_from_linear_data_offset(skb, ETH_ALEN, &hdr.addr3,
192 ETH_ALEN);
193 } else if (local->iw_mode == IW_MODE_INFRA || to_assoc_ap) {
194 fc |= IEEE80211_FCTL_TODS;
195 /* To DS: Addr1 = BSSID, Addr2 = SA, Addr3 = DA */
196 memcpy(&hdr.addr1, to_assoc_ap ?
197 local->assoc_ap_addr : local->bssid, ETH_ALEN);
198 skb_copy_from_linear_data_offset(skb, ETH_ALEN, &hdr.addr2,
199 ETH_ALEN);
200 skb_copy_from_linear_data(skb, &hdr.addr3, ETH_ALEN);
201 } else if (local->iw_mode == IW_MODE_ADHOC) {
202 /* not From/To DS: Addr1 = DA, Addr2 = SA, Addr3 = BSSID */
203 skb_copy_from_linear_data(skb, &hdr.addr1, ETH_ALEN);
204 skb_copy_from_linear_data_offset(skb, ETH_ALEN, &hdr.addr2,
205 ETH_ALEN);
206 memcpy(&hdr.addr3, local->bssid, ETH_ALEN);
207 }
208
209 hdr.frame_control = cpu_to_le16(fc);
210
211 skb_pull(skb, skip_header_bytes);
212 need_headroom = local->func->need_tx_headroom + hdr_len + encaps_len;
213 if (skb_tailroom(skb) < need_tailroom) {
214 skb = skb_unshare(skb, GFP_ATOMIC);
215 if (skb == NULL) {
216 iface->stats.tx_dropped++;
217 return NETDEV_TX_OK;
218 }
219 if (pskb_expand_head(skb, need_headroom, need_tailroom,
220 GFP_ATOMIC)) {
221 kfree_skb(skb);
222 iface->stats.tx_dropped++;
223 return NETDEV_TX_OK;
224 }
225 } else if (skb_headroom(skb) < need_headroom) {
226 struct sk_buff *tmp = skb;
227 skb = skb_realloc_headroom(skb, need_headroom);
228 kfree_skb(tmp);
229 if (skb == NULL) {
230 iface->stats.tx_dropped++;
231 return NETDEV_TX_OK;
232 }
233 } else {
234 skb = skb_unshare(skb, GFP_ATOMIC);
235 if (skb == NULL) {
236 iface->stats.tx_dropped++;
237 return NETDEV_TX_OK;
238 }
239 }
240
241 if (encaps_data)
242 memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len);
243 memcpy(skb_push(skb, hdr_len), &hdr, hdr_len);
244 if (use_wds == WDS_OWN_FRAME) {
245 memcpy(skb_put(skb, ETH_ALEN), &hdr.addr4, ETH_ALEN);
246 }
247
248 iface->stats.tx_packets++;
249 iface->stats.tx_bytes += skb->len;
250
251 skb_reset_mac_header(skb);
252 meta = (struct hostap_skb_tx_data *) skb->cb;
253 memset(meta, 0, sizeof(*meta));
254 meta->magic = HOSTAP_SKB_TX_DATA_MAGIC;
255 if (use_wds)
256 meta->flags |= HOSTAP_TX_FLAGS_WDS;
257 meta->ethertype = ethertype;
258 meta->iface = iface;
259
260 /* Send IEEE 802.11 encapsulated frame using the master radio device */
261 skb->dev = local->dev;
262 dev_queue_xmit(skb);
263 return NETDEV_TX_OK;
264}
265
266
267/* hard_start_xmit function for hostapd wlan#ap interfaces */
268netdev_tx_t hostap_mgmt_start_xmit(struct sk_buff *skb,
269 struct net_device *dev)
270{
271 struct hostap_interface *iface;
272 local_info_t *local;
273 struct hostap_skb_tx_data *meta;
274 struct ieee80211_hdr *hdr;
275 u16 fc;
276
277 iface = netdev_priv(dev);
278 local = iface->local;
279
280 if (skb->len < 10) {
281 printk(KERN_DEBUG "%s: hostap_mgmt_start_xmit: short skb "
282 "(len=%d)\n", dev->name, skb->len);
283 kfree_skb(skb);
284 return NETDEV_TX_OK;
285 }
286
287 iface->stats.tx_packets++;
288 iface->stats.tx_bytes += skb->len;
289
290 meta = (struct hostap_skb_tx_data *) skb->cb;
291 memset(meta, 0, sizeof(*meta));
292 meta->magic = HOSTAP_SKB_TX_DATA_MAGIC;
293 meta->iface = iface;
294
295 if (skb->len >= IEEE80211_DATA_HDR3_LEN + sizeof(rfc1042_header) + 2) {
296 hdr = (struct ieee80211_hdr *) skb->data;
297 fc = le16_to_cpu(hdr->frame_control);
298 if (ieee80211_is_data(hdr->frame_control) &&
299 (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_DATA) {
300 u8 *pos = &skb->data[IEEE80211_DATA_HDR3_LEN +
301 sizeof(rfc1042_header)];
302 meta->ethertype = (pos[0] << 8) | pos[1];
303 }
304 }
305
306 /* Send IEEE 802.11 encapsulated frame using the master radio device */
307 skb->dev = local->dev;
308 dev_queue_xmit(skb);
309 return NETDEV_TX_OK;
310}
311
312
313/* Called only from software IRQ */
314static struct sk_buff * hostap_tx_encrypt(struct sk_buff *skb,
315 struct lib80211_crypt_data *crypt)
316{
317 struct hostap_interface *iface;
318 local_info_t *local;
319 struct ieee80211_hdr *hdr;
320 int prefix_len, postfix_len, hdr_len, res;
321
322 iface = netdev_priv(skb->dev);
323 local = iface->local;
324
325 if (skb->len < IEEE80211_DATA_HDR3_LEN) {
326 kfree_skb(skb);
327 return NULL;
328 }
329
330 if (local->tkip_countermeasures &&
331 strcmp(crypt->ops->name, "TKIP") == 0) {
332 hdr = (struct ieee80211_hdr *) skb->data;
333 if (net_ratelimit()) {
334 printk(KERN_DEBUG "%s: TKIP countermeasures: dropped "
335 "TX packet to %pM\n",
336 local->dev->name, hdr->addr1);
337 }
338 kfree_skb(skb);
339 return NULL;
340 }
341
342 skb = skb_unshare(skb, GFP_ATOMIC);
343 if (skb == NULL)
344 return NULL;
345
346 prefix_len = crypt->ops->extra_mpdu_prefix_len +
347 crypt->ops->extra_msdu_prefix_len;
348 postfix_len = crypt->ops->extra_mpdu_postfix_len +
349 crypt->ops->extra_msdu_postfix_len;
350 if ((skb_headroom(skb) < prefix_len ||
351 skb_tailroom(skb) < postfix_len) &&
352 pskb_expand_head(skb, prefix_len, postfix_len, GFP_ATOMIC)) {
353 kfree_skb(skb);
354 return NULL;
355 }
356
357 hdr = (struct ieee80211_hdr *) skb->data;
358 hdr_len = hostap_80211_get_hdrlen(hdr->frame_control);
359
360 /* Host-based IEEE 802.11 fragmentation for TX is not yet supported, so
361 * call both MSDU and MPDU encryption functions from here. */
362 atomic_inc(&crypt->refcnt);
363 res = 0;
364 if (crypt->ops->encrypt_msdu)
365 res = crypt->ops->encrypt_msdu(skb, hdr_len, crypt->priv);
366 if (res == 0 && crypt->ops->encrypt_mpdu)
367 res = crypt->ops->encrypt_mpdu(skb, hdr_len, crypt->priv);
368 atomic_dec(&crypt->refcnt);
369 if (res < 0) {
370 kfree_skb(skb);
371 return NULL;
372 }
373
374 return skb;
375}
376
377
378/* hard_start_xmit function for master radio interface wifi#.
379 * AP processing (TX rate control, power save buffering, etc.).
380 * Use hardware TX function to send the frame. */
381netdev_tx_t hostap_master_start_xmit(struct sk_buff *skb,
382 struct net_device *dev)
383{
384 struct hostap_interface *iface;
385 local_info_t *local;
386 netdev_tx_t ret = NETDEV_TX_BUSY;
387 u16 fc;
388 struct hostap_tx_data tx;
389 ap_tx_ret tx_ret;
390 struct hostap_skb_tx_data *meta;
391 int no_encrypt = 0;
392 struct ieee80211_hdr *hdr;
393
394 iface = netdev_priv(dev);
395 local = iface->local;
396
397 tx.skb = skb;
398 tx.sta_ptr = NULL;
399
400 meta = (struct hostap_skb_tx_data *) skb->cb;
401 if (meta->magic != HOSTAP_SKB_TX_DATA_MAGIC) {
402 printk(KERN_DEBUG "%s: invalid skb->cb magic (0x%08x, "
403 "expected 0x%08x)\n",
404 dev->name, meta->magic, HOSTAP_SKB_TX_DATA_MAGIC);
405 ret = NETDEV_TX_OK;
406 iface->stats.tx_dropped++;
407 goto fail;
408 }
409
410 if (local->host_encrypt) {
411 /* Set crypt to default algorithm and key; will be replaced in
412 * AP code if STA has own alg/key */
413 tx.crypt = local->crypt_info.crypt[local->crypt_info.tx_keyidx];
414 tx.host_encrypt = 1;
415 } else {
416 tx.crypt = NULL;
417 tx.host_encrypt = 0;
418 }
419
420 if (skb->len < 24) {
421 printk(KERN_DEBUG "%s: hostap_master_start_xmit: short skb "
422 "(len=%d)\n", dev->name, skb->len);
423 ret = NETDEV_TX_OK;
424 iface->stats.tx_dropped++;
425 goto fail;
426 }
427
428 /* FIX (?):
429 * Wi-Fi 802.11b test plan suggests that AP should ignore power save
430 * bit in authentication and (re)association frames and assume tha
431 * STA remains awake for the response. */
432 tx_ret = hostap_handle_sta_tx(local, &tx);
433 skb = tx.skb;
434 meta = (struct hostap_skb_tx_data *) skb->cb;
435 hdr = (struct ieee80211_hdr *) skb->data;
436 fc = le16_to_cpu(hdr->frame_control);
437 switch (tx_ret) {
438 case AP_TX_CONTINUE:
439 break;
440 case AP_TX_CONTINUE_NOT_AUTHORIZED:
441 if (local->ieee_802_1x &&
442 ieee80211_is_data(hdr->frame_control) &&
443 meta->ethertype != ETH_P_PAE &&
444 !(meta->flags & HOSTAP_TX_FLAGS_WDS)) {
445 printk(KERN_DEBUG "%s: dropped frame to unauthorized "
446 "port (IEEE 802.1X): ethertype=0x%04x\n",
447 dev->name, meta->ethertype);
448 hostap_dump_tx_80211(dev->name, skb);
449
450 ret = NETDEV_TX_OK; /* drop packet */
451 iface->stats.tx_dropped++;
452 goto fail;
453 }
454 break;
455 case AP_TX_DROP:
456 ret = NETDEV_TX_OK; /* drop packet */
457 iface->stats.tx_dropped++;
458 goto fail;
459 case AP_TX_RETRY:
460 goto fail;
461 case AP_TX_BUFFERED:
462 /* do not free skb here, it will be freed when the
463 * buffered frame is sent/timed out */
464 ret = NETDEV_TX_OK;
465 goto tx_exit;
466 }
467
468 /* Request TX callback if protocol version is 2 in 802.11 header;
469 * this version 2 is a special case used between hostapd and kernel
470 * driver */
471 if (((fc & IEEE80211_FCTL_VERS) == BIT(1)) &&
472 local->ap && local->ap->tx_callback_idx && meta->tx_cb_idx == 0) {
473 meta->tx_cb_idx = local->ap->tx_callback_idx;
474
475 /* remove special version from the frame header */
476 fc &= ~IEEE80211_FCTL_VERS;
477 hdr->frame_control = cpu_to_le16(fc);
478 }
479
480 if (!ieee80211_is_data(hdr->frame_control)) {
481 no_encrypt = 1;
482 tx.crypt = NULL;
483 }
484
485 if (local->ieee_802_1x && meta->ethertype == ETH_P_PAE && tx.crypt &&
486 !(fc & IEEE80211_FCTL_PROTECTED)) {
487 no_encrypt = 1;
488 PDEBUG(DEBUG_EXTRA2, "%s: TX: IEEE 802.1X - passing "
489 "unencrypted EAPOL frame\n", dev->name);
490 tx.crypt = NULL; /* no encryption for IEEE 802.1X frames */
491 }
492
493 if (tx.crypt && (!tx.crypt->ops || !tx.crypt->ops->encrypt_mpdu))
494 tx.crypt = NULL;
495 else if ((tx.crypt ||
496 local->crypt_info.crypt[local->crypt_info.tx_keyidx]) &&
497 !no_encrypt) {
498 /* Add ISWEP flag both for firmware and host based encryption
499 */
500 fc |= IEEE80211_FCTL_PROTECTED;
501 hdr->frame_control = cpu_to_le16(fc);
502 } else if (local->drop_unencrypted &&
503 ieee80211_is_data(hdr->frame_control) &&
504 meta->ethertype != ETH_P_PAE) {
505 if (net_ratelimit()) {
506 printk(KERN_DEBUG "%s: dropped unencrypted TX data "
507 "frame (drop_unencrypted=1)\n", dev->name);
508 }
509 iface->stats.tx_dropped++;
510 ret = NETDEV_TX_OK;
511 goto fail;
512 }
513
514 if (tx.crypt) {
515 skb = hostap_tx_encrypt(skb, tx.crypt);
516 if (skb == NULL) {
517 printk(KERN_DEBUG "%s: TX - encryption failed\n",
518 dev->name);
519 ret = NETDEV_TX_OK;
520 goto fail;
521 }
522 meta = (struct hostap_skb_tx_data *) skb->cb;
523 if (meta->magic != HOSTAP_SKB_TX_DATA_MAGIC) {
524 printk(KERN_DEBUG "%s: invalid skb->cb magic (0x%08x, "
525 "expected 0x%08x) after hostap_tx_encrypt\n",
526 dev->name, meta->magic,
527 HOSTAP_SKB_TX_DATA_MAGIC);
528 ret = NETDEV_TX_OK;
529 iface->stats.tx_dropped++;
530 goto fail;
531 }
532 }
533
534 if (local->func->tx == NULL || local->func->tx(skb, dev)) {
535 ret = NETDEV_TX_OK;
536 iface->stats.tx_dropped++;
537 } else {
538 ret = NETDEV_TX_OK;
539 iface->stats.tx_packets++;
540 iface->stats.tx_bytes += skb->len;
541 }
542
543 fail:
544 if (ret == NETDEV_TX_OK && skb)
545 dev_kfree_skb(skb);
546 tx_exit:
547 if (tx.sta_ptr)
548 hostap_handle_sta_release(tx.sta_ptr);
549 return ret;
550}
551
552
553EXPORT_SYMBOL(hostap_master_start_xmit);