Lines Matching refs:rx
864 static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
866 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
867 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
899 rx->seqno_idx = seqno_idx;
900 rx->security_idx = security_idx;
903 rx->skb->priority = (tid > 7) ? 0 : tid;
931 static void ieee80211_verify_alignment(struct ieee80211_rx_data *rx)
934 WARN_ON_ONCE((unsigned long)rx->skb->data & 1);
939 /* rx handlers */
1034 static ieee80211_rx_result ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
1036 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1037 char *dev_addr = rx->sdata->vif.addr;
1058 if (!rx->sta || sta_plink_state(rx->sta) != NL80211_PLINK_ESTAB) {
1068 if (rx->skb->len < IEEE80211_MIN_ACTION_SIZE)
1347 static void ieee80211_rx_reorder_ampdu(struct ieee80211_rx_data *rx,
1350 struct sk_buff *skb = rx->skb;
1351 struct ieee80211_local *local = rx->local;
1353 struct sta_info *sta = rx->sta;
1363 * filter the QoS data rx stream according to
1377 !test_bit(tid, rx->sta->ampdu_mlme.agg_session_valid) &&
1378 !test_and_set_bit(tid, rx->sta->ampdu_mlme.unexpected_agg))
1379 ieee80211_send_delba(rx->sdata, rx->sta->sta.addr, tid,
1399 /* if this mpdu is fragmented - terminate rx aggregation session */
1402 skb_queue_tail(&rx->sdata->skb_queue, skb);
1403 ieee80211_queue_work(&local->hw, &rx->sdata->work);
1414 if (ieee80211_sta_manage_reorder_buf(rx->sdata, tid_agg_rx, skb,
1423 ieee80211_rx_h_check_dup(struct ieee80211_rx_data *rx)
1425 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1426 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
1436 if (rx->skb->len < 24)
1444 if (!rx->sta)
1448 rx->sta->last_seq_ctrl[rx->seqno_idx] == hdr->seq_ctrl)) {
1449 I802_DEBUG_INC(rx->local->dot11FrameDuplicateCount);
1450 rx->sta->rx_stats.num_duplicates++;
1453 rx->sta->last_seq_ctrl[rx->seqno_idx] = hdr->seq_ctrl;
1460 ieee80211_rx_h_check(struct ieee80211_rx_data *rx)
1462 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1473 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
1474 return ieee80211_rx_mesh_check(rx);
1478 rx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
1479 rx->sdata->vif.type != NL80211_IFTYPE_WDS &&
1480 rx->sdata->vif.type != NL80211_IFTYPE_OCB &&
1481 (!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_ASSOC)))) {
1487 if (rx->sta && rx->sdata->vif.type == NL80211_IFTYPE_STATION &&
1494 if (rx->skb->len < hdrlen + 8)
1497 skb_copy_bits(rx->skb, hdrlen + 6, ðertype, 2);
1498 if (ethertype == rx->sdata->control_port_protocol)
1502 if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
1503 cfg80211_rx_spurious_frame(rx->sdata->dev,
1516 ieee80211_rx_h_check_more_data(struct ieee80211_rx_data *rx)
1522 local = rx->local;
1523 skb = rx->skb;
1543 ieee80211_send_pspoll(local, rx->sdata);
1676 ieee80211_rx_h_uapsd_and_pspoll(struct ieee80211_rx_data *rx)
1678 struct ieee80211_sub_if_data *sdata = rx->sdata;
1679 struct ieee80211_hdr *hdr = (void *)rx->skb->data;
1680 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
1682 if (!rx->sta)
1702 if (!test_sta_flag(rx->sta, WLAN_STA_PS_STA))
1706 ieee80211_sta_pspoll(&rx->sta->sta);
1710 dev_kfree_skb(rx->skb);
1720 ieee80211_sta_uapsd_trigger(&rx->sta->sta, tid);
1727 ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
1729 struct sta_info *sta = rx->sta;
1730 struct sk_buff *skb = rx->skb;
1746 if (rx->sdata->vif.type == NL80211_IFTYPE_ADHOC) {
1747 u8 *bssid = ieee80211_get_bssid(hdr, rx->skb->len,
1749 if (ether_addr_equal(bssid, rx->sdata->u.ibss.bssid) &&
1757 } else if (rx->sdata->vif.type == NL80211_IFTYPE_OCB) {
1772 u64_stats_update_begin(&rx->sta->rx_stats.syncp);
1773 sta->rx_stats.bytes += rx->skb->len;
1774 u64_stats_update_end(&rx->sta->rx_stats.syncp);
1809 (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1810 rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) {
1821 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
1829 I802_DEBUG_INC(rx->local->rx_handlers_drop_nullfunc);
1838 (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1839 (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1840 !rx->sdata->u.vlan.sta))) {
1843 rx->sdata->dev, sta->sta.addr,
1852 dev_kfree_skb(rx->skb);
1860 ieee80211_rx_get_bigtk(struct ieee80211_rx_data *rx, int idx)
1863 struct ieee80211_sub_if_data *sdata = rx->sdata;
1882 if (rx->sta)
1883 key = rcu_dereference(rx->sta->gtk[idx]);
1886 if (!key && rx->sta)
1887 key = rcu_dereference(rx->sta->gtk[idx2]);
1895 ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
1897 struct sk_buff *skb = rx->skb;
1940 rx->key = NULL;
1943 if (rx->sta) {
1944 int keyid = rx->sta->ptk_idx;
1945 sta_ptk = rcu_dereference(rx->sta->ptk[keyid]);
1949 cs = rx->sta->cipher_scheme;
1950 keyid = ieee80211_get_keyid(rx->skb, cs);
1955 ptk_idx = rcu_dereference(rx->sta->ptk[keyid]);
1960 mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
1963 rx->key = ptk_idx ? ptk_idx : sta_ptk;
1979 if (rx->sdata->dev)
1980 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
1986 rx->key = ieee80211_rx_get_bigtk(rx, mmie_keyidx);
1987 if (!rx->key)
1998 if (rx->sta) {
2000 test_sta_flag(rx->sta, WLAN_STA_MFP))
2003 rx->key = rcu_dereference(rx->sta->gtk[mmie_keyidx]);
2005 if (!rx->key)
2006 rx->key = rcu_dereference(rx->sdata->keys[mmie_keyidx]);
2010 * need to set rx->key if there is a key that could have been
2015 struct ieee80211_sub_if_data *sdata = rx->sdata;
2019 key = ieee80211_rx_get_bigtk(rx, -1);
2022 key = rcu_dereference(rx->sdata->default_mgmt_key);
2024 if (rx->sta) {
2026 key = rcu_dereference(rx->sta->gtk[i]);
2040 rx->key = key;
2056 keyidx = ieee80211_get_keyid(rx->skb, cs);
2062 if (is_multicast_ether_addr(hdr->addr1) && rx->sta)
2063 rx->key = rcu_dereference(rx->sta->gtk[keyidx]);
2066 if (!rx->key) {
2067 rx->key = rcu_dereference(rx->sdata->keys[keyidx]);
2074 if (rx->key &&
2075 rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP40 &&
2076 rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP104 &&
2078 rx->key = NULL;
2082 if (rx->key) {
2083 if (unlikely(rx->key->flags & KEY_FLAG_TAINTED))
2091 switch (rx->key->conf.cipher) {
2094 result = ieee80211_crypto_wep_decrypt(rx);
2097 result = ieee80211_crypto_tkip_decrypt(rx);
2101 rx, IEEE80211_CCMP_MIC_LEN);
2105 rx, IEEE80211_CCMP_256_MIC_LEN);
2108 result = ieee80211_crypto_aes_cmac_decrypt(rx);
2111 result = ieee80211_crypto_aes_cmac_256_decrypt(rx);
2115 result = ieee80211_crypto_aes_gmac_decrypt(rx);
2119 result = ieee80211_crypto_gcmp_decrypt(rx);
2122 result = ieee80211_crypto_hw_decrypt(rx);
2131 rx->sdata->dev))
2132 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2224 static bool requires_sequential_pn(struct ieee80211_rx_data *rx, __le16 fc)
2226 return rx->key &&
2227 (rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP ||
2228 rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP_256 ||
2229 rx->key->conf.cipher == WLAN_CIPHER_SUITE_GCMP ||
2230 rx->key->conf.cipher == WLAN_CIPHER_SUITE_GCMP_256) &&
2235 ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
2237 struct ieee80211_fragment_cache *cache = &rx->sdata->frags;
2244 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
2246 hdr = (struct ieee80211_hdr *)rx->skb->data;
2255 if (rx->sta)
2256 cache = &rx->sta->frags;
2264 I802_DEBUG_INC(rx->local->rx_handlers_fragments);
2266 if (skb_linearize(rx->skb))
2274 hdr = (struct ieee80211_hdr *)rx->skb->data;
2280 rx->seqno_idx, &(rx->skb));
2281 if (requires_sequential_pn(rx, fc)) {
2282 int queue = rx->security_idx;
2289 entry->key_color = rx->key->color;
2291 rx->key->u.ccmp.rx_pn[queue],
2297 BUILD_BUG_ON(sizeof(rx->key->u.ccmp.rx_pn[queue]) !=
2298 sizeof(rx->key->u.gcmp.rx_pn[queue]));
2301 } else if (rx->key &&
2305 entry->key_color = rx->key->color;
2314 rx->seqno_idx, hdr);
2316 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
2329 if (!requires_sequential_pn(rx, fc))
2333 if (entry->key_color != rx->key->color)
2343 rpn = rx->ccm_gcm.pn;
2348 (!rx->key ||
2351 rx->key->color != entry->key_color)) {
2357 } else if (entry->is_protected && rx->key &&
2358 entry->key_color != rx->key->color &&
2363 skb_pull(rx->skb, ieee80211_hdrlen(fc));
2364 __skb_queue_tail(&entry->skb_list, rx->skb);
2366 entry->extra_len += rx->skb->len;
2368 rx->skb = NULL;
2372 rx->skb = __skb_dequeue(&entry->skb_list);
2373 if (skb_tailroom(rx->skb) < entry->extra_len) {
2374 I802_DEBUG_INC(rx->local->rx_expand_skb_head_defrag);
2375 if (unlikely(pskb_expand_head(rx->skb, 0, entry->extra_len,
2377 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
2383 skb_put_data(rx->skb, skb->data, skb->len);
2388 ieee80211_led_rx(rx->local);
2389 if (rx->sta)
2390 rx->sta->rx_stats.packets++;
2394 static int ieee80211_802_1x_port_control(struct ieee80211_rx_data *rx)
2396 if (unlikely(!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_AUTHORIZED)))
2402 static int ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc)
2404 struct ieee80211_hdr *hdr = (void *)rx->skb->data;
2405 struct sk_buff *skb = rx->skb;
2416 if (unlikely(rx->sta && ieee80211_vif_is_mesh(&rx->sdata->vif) &&
2423 if (!ether_addr_equal(hdr->addr1, rx->sdata->vif.addr))
2427 if (!pskb_may_pull(rx->skb, hdr_len + 6))
2434 if (skb_copy_bits(rx->skb, ethertype_offset, ðertype, 2) == 0 &&
2435 ethertype == rx->sdata->control_port_protocol)
2443 ieee80211_is_data(fc) && rx->key))
2449 static int ieee80211_drop_unencrypted_mgmt(struct ieee80211_rx_data *rx)
2451 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
2452 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
2462 if (rx->sta && test_sta_flag(rx->sta, WLAN_STA_MFP)) {
2464 ieee80211_is_unicast_robust_mgmt_frame(rx->skb) &&
2465 rx->key)) {
2468 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2469 rx->skb->data,
2470 rx->skb->len);
2474 if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb) &&
2475 ieee80211_get_mmie_keyidx(rx->skb) < 0)) {
2478 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2479 rx->skb->data,
2480 rx->skb->len);
2483 if (unlikely(ieee80211_is_beacon(fc) && rx->key &&
2484 ieee80211_get_mmie_keyidx(rx->skb) < 0)) {
2485 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2486 rx->skb->data,
2487 rx->skb->len);
2494 if (unlikely(ieee80211_is_action(fc) && !rx->key &&
2495 ieee80211_is_robust_mgmt_frame(rx->skb)))
2503 __ieee80211_data_to_8023(struct ieee80211_rx_data *rx, bool *port_control)
2505 struct ieee80211_sub_if_data *sdata = rx->sdata;
2506 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
2529 ret = ieee80211_data_to_8023(rx->skb, sdata->vif.addr, sdata->vif.type);
2533 ehdr = (struct ethhdr *) rx->skb->data;
2534 if (ehdr->h_proto == rx->sdata->control_port_protocol)
2543 * requires that rx->skb is a frame with ethernet header
2545 static bool ieee80211_frame_allowed(struct ieee80211_rx_data *rx, __le16 fc)
2549 struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
2556 if (unlikely(ehdr->h_proto == rx->sdata->control_port_protocol))
2557 return ether_addr_equal(ehdr->h_dest, rx->sdata->vif.addr) ||
2560 if (ieee80211_802_1x_port_control(rx) ||
2561 ieee80211_drop_unencrypted(rx, fc))
2568 struct ieee80211_rx_data *rx)
2570 struct ieee80211_sub_if_data *sdata = rx->sdata;
2606 if (rx->list)
2607 list_add_tail(&skb->list, rx->list);
2614 * requires that rx->skb is a frame with ethernet header
2617 ieee80211_deliver_skb(struct ieee80211_rx_data *rx)
2619 struct ieee80211_sub_if_data *sdata = rx->sdata;
2622 struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
2625 skb = rx->skb;
2630 if (rx->sta) {
2636 u64_stats_update_begin(&rx->sta->rx_stats.syncp);
2637 rx->sta->rx_stats.msdu[rx->seqno_idx]++;
2638 u64_stats_update_end(&rx->sta->rx_stats.syncp);
2644 ehdr->h_proto != rx->sdata->control_port_protocol &&
2700 ieee80211_deliver_skb_to_local_stack(skb, rx);
2718 __ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx, u8 data_offset)
2720 struct net_device *dev = rx->sdata->dev;
2721 struct sk_buff *skb = rx->skb;
2731 } else switch (rx->sdata->vif.type) {
2737 if (!rx->sta ||
2738 !test_sta_flag(rx->sta, WLAN_STA_TDLS_PEER))
2752 rx->sdata->vif.addr,
2753 rx->sdata->vif.type,
2758 rx->sdata->vif.type,
2759 rx->local->hw.extra_tx_headroom,
2763 rx->skb = __skb_dequeue(&frame_list);
2765 if (!ieee80211_frame_allowed(rx, fc)) {
2766 dev_kfree_skb(rx->skb);
2770 ieee80211_deliver_skb(rx);
2777 ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx)
2779 struct sk_buff *skb = rx->skb;
2794 switch (rx->sdata->vif.type) {
2796 if (!rx->sdata->u.vlan.sta)
2800 if (!rx->sdata->u.mgd.use_4addr)
2811 if (rx->key) {
2818 switch (rx->key->conf.cipher) {
2828 return __ieee80211_rx_h_amsdu(rx, 0);
2833 ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
2838 struct sk_buff *skb = rx->skb, *fwd_skb;
2839 struct ieee80211_local *local = rx->local;
2840 struct ieee80211_sub_if_data *sdata = rx->sdata;
2849 if (!pskb_may_pull(rx->skb, hdrlen + 6))
2855 if (!pskb_may_pull(rx->skb,
2863 if (ieee80211_drop_unencrypted(rx, hdr->frame_control))
2869 mesh_rmc_check(rx->sdata, hdr->addr3, mesh_hdr))
2946 info->control.vif = &rx->sdata->vif;
2977 ieee80211_rx_h_data(struct ieee80211_rx_data *rx)
2979 struct ieee80211_sub_if_data *sdata = rx->sdata;
2980 struct ieee80211_local *local = rx->local;
2982 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
2999 if (rx->sta &&
3000 !test_and_set_sta_flag(rx->sta, WLAN_STA_4ADDR_EVENT))
3002 rx->sdata->dev, rx->sta->sta.addr, GFP_ATOMIC);
3006 err = __ieee80211_data_to_8023(rx, &port_control);
3010 if (!ieee80211_frame_allowed(rx, fc))
3014 if (unlikely(((struct ethhdr *)rx->skb->data)->h_proto ==
3016 struct ieee80211_tdls_data *tf = (void *)rx->skb->data;
3018 if (pskb_may_pull(rx->skb,
3024 skb_queue_tail(&local->skb_queue_tdls_chsw, rx->skb);
3026 if (rx->sta)
3027 rx->sta->rx_stats.packets++;
3033 if (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
3038 rx->sdata = sdata;
3041 rx->skb->dev = dev;
3046 ((struct ethhdr *)rx->skb->data)->h_dest) &&
3052 ieee80211_deliver_skb(rx);
3058 ieee80211_rx_h_ctrl(struct ieee80211_rx_data *rx, struct sk_buff_head *frames)
3060 struct sk_buff *skb = rx->skb;
3077 if (!rx->sta)
3086 if (!test_bit(tid, rx->sta->ampdu_mlme.agg_session_valid) &&
3087 !test_and_set_bit(tid, rx->sta->ampdu_mlme.unexpected_agg))
3088 ieee80211_send_delba(rx->sdata, rx->sta->sta.addr, tid,
3092 tid_agg_rx = rcu_dereference(rx->sta->ampdu_mlme.tid_rx[tid]);
3099 event.u.ba.sta = &rx->sta->sta;
3108 ieee80211_release_reorder_frames(rx->sdata, tid_agg_rx,
3112 drv_event_callback(rx->local, rx->sdata, &event);
3172 ieee80211_rx_h_mgmt_check(struct ieee80211_rx_data *rx)
3174 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
3175 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3185 if (rx->skb->len < 24)
3191 if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
3193 !(rx->flags & IEEE80211_RX_BEACON_REPORTED)) {
3196 if (ieee80211_hw_check(&rx->local->hw, SIGNAL_DBM) &&
3200 cfg80211_report_obss_beacon_khz(rx->local->hw.wiphy,
3201 rx->skb->data, rx->skb->len,
3204 rx->flags |= IEEE80211_RX_BEACON_REPORTED;
3207 if (ieee80211_drop_unencrypted_mgmt(rx))
3214 ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
3216 struct ieee80211_local *local = rx->local;
3217 struct ieee80211_sub_if_data *sdata = rx->sdata;
3218 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
3219 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3220 int len = rx->skb->len;
3229 if (!rx->sta && mgmt->u.action.category != WLAN_CATEGORY_PUBLIC &&
3237 if (!rx->sta->sta.ht_cap.ht_supported)
3277 if (rx->sta->sta.smps_mode == smps_mode)
3279 rx->sta->sta.smps_mode = smps_mode;
3284 sband = rx->local->hw.wiphy->bands[status->band];
3286 rate_control_rate_update(local, sband, rx->sta,
3289 rx->sta->addr,
3301 if (!(rx->sta->sta.ht_cap.cap &
3308 max_bw = ieee80211_sta_cap_rx_bw(rx->sta);
3311 rx->sta->cur_max_bandwidth = max_bw;
3312 new_bw = ieee80211_sta_cur_vht_bw(rx->sta);
3314 if (rx->sta->sta.bandwidth == new_bw)
3317 rx->sta->sta.bandwidth = new_bw;
3318 sband = rx->local->hw.wiphy->bands[status->band];
3320 ieee80211_sta_rx_bw_to_chan_width(rx->sta);
3323 rate_control_rate_update(local, sband, rx->sta,
3326 rx->sta->addr,
3341 if (!rx->sta)
3502 if (rx->sta)
3503 rx->sta->rx_stats.packets++;
3504 dev_kfree_skb(rx->skb);
3508 skb_queue_tail(&sdata->skb_queue, rx->skb);
3510 if (rx->sta)
3511 rx->sta->rx_stats.packets++;
3516 ieee80211_rx_h_userspace_mgmt(struct ieee80211_rx_data *rx)
3518 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3532 if (ieee80211_hw_check(&rx->local->hw, SIGNAL_DBM) &&
3536 if (cfg80211_rx_mgmt_khz(&rx->sdata->wdev,
3538 rx->skb->data, rx->skb->len, 0)) {
3539 if (rx->sta)
3540 rx->sta->rx_stats.packets++;
3541 dev_kfree_skb(rx->skb);
3549 ieee80211_rx_h_action_post_userspace(struct ieee80211_rx_data *rx)
3551 struct ieee80211_sub_if_data *sdata = rx->sdata;
3552 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
3553 int len = rx->skb->len;
3577 if (rx->sta)
3578 rx->sta->rx_stats.packets++;
3579 dev_kfree_skb(rx->skb);
3584 ieee80211_rx_h_action_return(struct ieee80211_rx_data *rx)
3586 struct ieee80211_local *local = rx->local;
3587 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
3589 struct ieee80211_sub_if_data *sdata = rx->sdata;
3590 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3617 nskb = skb_copy_expand(rx->skb, local->hw.extra_tx_headroom, 0,
3624 memcpy(nmgmt->sa, rx->sdata->vif.addr, ETH_ALEN);
3628 if (rx->sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {
3639 __ieee80211_tx_skb_tid_band(rx->sdata, nskb, 7,
3642 dev_kfree_skb(rx->skb);
3647 ieee80211_rx_h_ext(struct ieee80211_rx_data *rx)
3649 struct ieee80211_sub_if_data *sdata = rx->sdata;
3650 struct ieee80211_hdr *hdr = (void *)rx->skb->data;
3659 skb_queue_tail(&sdata->skb_queue, rx->skb);
3660 ieee80211_queue_work(&rx->local->hw, &sdata->work);
3661 if (rx->sta)
3662 rx->sta->rx_stats.packets++;
3668 ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
3670 struct ieee80211_sub_if_data *sdata = rx->sdata;
3671 struct ieee80211_mgmt *mgmt = (void *)rx->skb->data;
3720 skb_queue_tail(&sdata->skb_queue, rx->skb);
3721 ieee80211_queue_work(&rx->local->hw, &sdata->work);
3722 if (rx->sta)
3723 rx->sta->rx_stats.packets++;
3728 static void ieee80211_rx_cooked_monitor(struct ieee80211_rx_data *rx,
3732 struct ieee80211_local *local = rx->local;
3733 struct sk_buff *skb = rx->skb, *skb2;
3742 if (rx->flags & IEEE80211_RX_CMNTR)
3744 rx->flags |= IEEE80211_RX_CMNTR;
3798 static void ieee80211_rx_handlers_result(struct ieee80211_rx_data *rx,
3803 I802_DEBUG_INC(rx->sdata->local->rx_handlers_drop);
3804 if (rx->sta)
3805 rx->sta->rx_stats.dropped++;
3812 status = IEEE80211_SKB_RXCB((rx->skb));
3814 sband = rx->local->hw.wiphy->bands[status->band];
3818 ieee80211_rx_cooked_monitor(rx, rate);
3822 I802_DEBUG_INC(rx->sdata->local->rx_handlers_drop);
3823 if (rx->sta)
3824 rx->sta->rx_stats.dropped++;
3825 dev_kfree_skb(rx->skb);
3828 I802_DEBUG_INC(rx->sdata->local->rx_handlers_queued);
3833 static void ieee80211_rx_handlers(struct ieee80211_rx_data *rx,
3841 res = rxh(rx); \
3852 spin_lock_bh(&rx->local->rx_path_lock);
3860 rx->skb = skb;
3870 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
3877 res = ieee80211_rx_h_ctrl(rx, frames);
3890 ieee80211_rx_handlers_result(rx, res);
3895 spin_unlock_bh(&rx->local->rx_path_lock);
3898 static void ieee80211_invoke_rx_handlers(struct ieee80211_rx_data *rx)
3907 res = rxh(rx); \
3915 ieee80211_rx_reorder_ampdu(rx, &reorder_release);
3917 ieee80211_rx_handlers(rx, &reorder_release);
3921 ieee80211_rx_handlers_result(rx, res);
3933 struct ieee80211_rx_data rx = {
3959 drv_event_callback(rx.local, rx.sdata, &event);
3962 ieee80211_rx_handlers(&rx, &frames);
3972 struct ieee80211_rx_data rx = {
3986 rx.sta = sta;
3987 rx.sdata = sta->sdata;
3988 rx.local = sta->local;
4037 ieee80211_rx_handlers(&rx, &frames);
4046 static bool ieee80211_accept_frame(struct ieee80211_rx_data *rx)
4048 struct ieee80211_sub_if_data *sdata = rx->sdata;
4049 struct sk_buff *skb = rx->skb;
4060 if (ieee80211_is_robust_mgmt_frame(skb) && !rx->sta)
4079 if (!rx->sta) {
4099 if (!rx->sta) {
4209 /* fast-rx doesn't do reordering */
4246 /* parallel-rx requires this, at least with calls to
4283 /* we don't want to deal with MMIC in fast-rx */
4356 static bool ieee80211_invoke_fast_rx(struct ieee80211_rx_data *rx,
4359 struct sk_buff *skb = rx->skb;
4362 struct sta_info *sta = rx->sta;
4379 /* for parallel-rx, we need to have DUP_VALIDATED, otherwise we write
4448 if (rx->key && !(status->flag & RX_FLAG_MIC_STRIPPED) &&
4478 if (rx->key && !ieee80211_has_protected(hdr->frame_control))
4482 if (__ieee80211_rx_h_amsdu(rx, snap_offs - hdrlen) !=
4513 stats->msdu[rx->seqno_idx]++;
4522 sta_info_get(rx->sdata, addrs.da)) {
4547 if (rx->list)
4548 list_add_tail(&skb->list, rx->list);
4565 static bool ieee80211_prepare_and_rx_handle(struct ieee80211_rx_data *rx,
4568 struct ieee80211_local *local = rx->local;
4569 struct ieee80211_sub_if_data *sdata = rx->sdata;
4571 rx->skb = skb;
4573 /* See if we can do fast-rx; if we have to copy we already lost,
4580 if (consume && rx->sta) {
4583 fast_rx = rcu_dereference(rx->sta->fast_rx);
4584 if (fast_rx && ieee80211_invoke_fast_rx(rx, fast_rx))
4588 if (!ieee80211_accept_frame(rx))
4601 rx->skb = skb;
4604 ieee80211_invoke_rx_handlers(rx);
4621 struct ieee80211_rx_data rx;
4627 memset(&rx, 0, sizeof(rx));
4628 rx.skb = skb;
4629 rx.local = local;
4630 rx.list = list;
4651 ieee80211_parse_qos(&rx);
4652 ieee80211_verify_alignment(&rx);
4663 rx.sta = container_of(pubsta, struct sta_info, sta);
4664 rx.sdata = rx.sta->sdata;
4665 if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
4678 rx.sta = prev_sta;
4679 rx.sdata = prev_sta->sdata;
4680 ieee80211_prepare_and_rx_handle(&rx, skb, false);
4686 rx.sta = prev_sta;
4687 rx.sdata = prev_sta->sdata;
4689 if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
4716 rx.sta = sta_info_get_bss(prev, hdr->addr2);
4717 rx.sdata = prev;
4718 ieee80211_prepare_and_rx_handle(&rx, skb, false);
4724 rx.sta = sta_info_get_bss(prev, hdr->addr2);
4725 rx.sdata = prev;
4727 if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
4881 /* This is a version of the rx handler that can be called from hard irq