Lines Matching refs:rx
875 static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
877 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
878 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
910 rx->seqno_idx = seqno_idx;
911 rx->security_idx = security_idx;
914 rx->skb->priority = (tid > 7) ? 0 : tid;
942 static void ieee80211_verify_alignment(struct ieee80211_rx_data *rx)
945 WARN_ON_ONCE((unsigned long)rx->skb->data & 1);
950 /* rx handlers */
1022 static ieee80211_rx_result ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
1024 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1025 char *dev_addr = rx->sdata->vif.addr;
1046 if (!rx->sta || sta_plink_state(rx->sta) != NL80211_PLINK_ESTAB) {
1056 if (rx->skb->len < IEEE80211_MIN_ACTION_SIZE)
1337 static void ieee80211_rx_reorder_ampdu(struct ieee80211_rx_data *rx,
1340 struct sk_buff *skb = rx->skb;
1342 struct sta_info *sta = rx->sta;
1352 * filter the QoS data rx stream according to
1366 !test_bit(tid, rx->sta->ampdu_mlme.agg_session_valid) &&
1367 !test_and_set_bit(tid, rx->sta->ampdu_mlme.unexpected_agg))
1368 ieee80211_send_delba(rx->sdata, rx->sta->sta.addr, tid,
1388 /* if this mpdu is fragmented - terminate rx aggregation session */
1391 ieee80211_queue_skb_to_iface(rx->sdata, rx->link_id, NULL, skb);
1402 if (ieee80211_sta_manage_reorder_buf(rx->sdata, tid_agg_rx, skb,
1411 ieee80211_rx_h_check_dup(struct ieee80211_rx_data *rx)
1413 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1414 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
1424 if (rx->skb->len < 24)
1432 if (!rx->sta)
1436 rx->sta->last_seq_ctrl[rx->seqno_idx] == hdr->seq_ctrl)) {
1437 I802_DEBUG_INC(rx->local->dot11FrameDuplicateCount);
1438 rx->link_sta->rx_stats.num_duplicates++;
1441 rx->sta->last_seq_ctrl[rx->seqno_idx] = hdr->seq_ctrl;
1448 ieee80211_rx_h_check(struct ieee80211_rx_data *rx)
1450 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1461 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
1462 return ieee80211_rx_mesh_check(rx);
1466 rx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
1467 rx->sdata->vif.type != NL80211_IFTYPE_OCB &&
1468 (!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_ASSOC)))) {
1474 if (rx->sta && rx->sdata->vif.type == NL80211_IFTYPE_STATION &&
1481 if (rx->skb->len < hdrlen + 8)
1484 skb_copy_bits(rx->skb, hdrlen + 6, ðertype, 2);
1485 if (ethertype == rx->sdata->control_port_protocol)
1489 if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
1490 cfg80211_rx_spurious_frame(rx->sdata->dev,
1503 ieee80211_rx_h_check_more_data(struct ieee80211_rx_data *rx)
1509 local = rx->local;
1510 skb = rx->skb;
1530 ieee80211_send_pspoll(local, rx->sdata);
1660 ieee80211_rx_h_uapsd_and_pspoll(struct ieee80211_rx_data *rx)
1662 struct ieee80211_sub_if_data *sdata = rx->sdata;
1663 struct ieee80211_hdr *hdr = (void *)rx->skb->data;
1664 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
1666 if (!rx->sta)
1686 if (!test_sta_flag(rx->sta, WLAN_STA_PS_STA))
1690 ieee80211_sta_pspoll(&rx->sta->sta);
1694 dev_kfree_skb(rx->skb);
1704 ieee80211_sta_uapsd_trigger(&rx->sta->sta, tid);
1711 ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
1713 struct sta_info *sta = rx->sta;
1714 struct link_sta_info *link_sta = rx->link_sta;
1715 struct sk_buff *skb = rx->skb;
1731 if (rx->sdata->vif.type == NL80211_IFTYPE_ADHOC) {
1732 u8 *bssid = ieee80211_get_bssid(hdr, rx->skb->len,
1734 if (ether_addr_equal(bssid, rx->sdata->u.ibss.bssid) &&
1742 } else if (rx->sdata->vif.type == NL80211_IFTYPE_OCB) {
1758 link_sta->rx_stats.bytes += rx->skb->len;
1795 (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1796 rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) {
1807 if (ieee80211_vif_is_mesh(&rx->sdata->vif))
1815 I802_DEBUG_INC(rx->local->rx_handlers_drop_nullfunc);
1824 (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
1825 (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1826 !rx->sdata->u.vlan.sta))) {
1829 rx->sdata->dev, sta->sta.addr,
1838 dev_kfree_skb(rx->skb);
1846 ieee80211_rx_get_bigtk(struct ieee80211_rx_data *rx, int idx)
1867 if (rx->link_sta)
1868 key = rcu_dereference(rx->link_sta->gtk[idx]);
1870 key = rcu_dereference(rx->link->gtk[idx]);
1871 if (!key && rx->link_sta)
1872 key = rcu_dereference(rx->link_sta->gtk[idx2]);
1874 key = rcu_dereference(rx->link->gtk[idx2]);
1880 ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
1882 struct sk_buff *skb = rx->skb;
1924 rx->key = NULL;
1927 if (rx->sta) {
1928 int keyid = rx->sta->ptk_idx;
1929 sta_ptk = rcu_dereference(rx->sta->ptk[keyid]);
1933 keyid = ieee80211_get_keyid(rx->skb);
1938 ptk_idx = rcu_dereference(rx->sta->ptk[keyid]);
1943 mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
1946 rx->key = ptk_idx ? ptk_idx : sta_ptk;
1962 if (rx->sdata->dev)
1963 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
1969 rx->key = ieee80211_rx_get_bigtk(rx, mmie_keyidx);
1970 if (!rx->key)
1981 if (rx->link_sta) {
1983 test_sta_flag(rx->sta, WLAN_STA_MFP))
1986 rx->key = rcu_dereference(rx->link_sta->gtk[mmie_keyidx]);
1988 if (!rx->key)
1989 rx->key = rcu_dereference(rx->link->gtk[mmie_keyidx]);
1993 * need to set rx->key if there is a key that could have been
2001 key = ieee80211_rx_get_bigtk(rx, -1);
2004 key = rcu_dereference(rx->link->default_mgmt_key);
2006 if (rx->link_sta) {
2008 key = rcu_dereference(rx->link_sta->gtk[i]);
2015 key = rcu_dereference(rx->link->gtk[i]);
2022 rx->key = key;
2038 keyidx = ieee80211_get_keyid(rx->skb);
2044 if (is_multicast_ether_addr(hdr->addr1) && rx->link_sta)
2045 rx->key = rcu_dereference(rx->link_sta->gtk[keyidx]);
2048 if (!rx->key) {
2050 rx->key = rcu_dereference(rx->link->gtk[keyidx]);
2051 if (!rx->key)
2052 rx->key = rcu_dereference(rx->sdata->keys[keyidx]);
2059 if (rx->key &&
2060 rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP40 &&
2061 rx->key->conf.cipher != WLAN_CIPHER_SUITE_WEP104 &&
2063 rx->key = NULL;
2067 if (rx->key) {
2068 if (unlikely(rx->key->flags & KEY_FLAG_TAINTED))
2076 switch (rx->key->conf.cipher) {
2079 result = ieee80211_crypto_wep_decrypt(rx);
2082 result = ieee80211_crypto_tkip_decrypt(rx);
2086 rx, IEEE80211_CCMP_MIC_LEN);
2090 rx, IEEE80211_CCMP_256_MIC_LEN);
2093 result = ieee80211_crypto_aes_cmac_decrypt(rx);
2096 result = ieee80211_crypto_aes_cmac_256_decrypt(rx);
2100 result = ieee80211_crypto_aes_gmac_decrypt(rx);
2104 result = ieee80211_crypto_gcmp_decrypt(rx);
2116 rx->sdata->dev))
2117 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2209 static bool requires_sequential_pn(struct ieee80211_rx_data *rx, __le16 fc)
2211 return rx->key &&
2212 (rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP ||
2213 rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP_256 ||
2214 rx->key->conf.cipher == WLAN_CIPHER_SUITE_GCMP ||
2215 rx->key->conf.cipher == WLAN_CIPHER_SUITE_GCMP_256) &&
2220 ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
2222 struct ieee80211_fragment_cache *cache = &rx->sdata->frags;
2229 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
2231 hdr = (struct ieee80211_hdr *)rx->skb->data;
2240 if (rx->sta)
2241 cache = &rx->sta->frags;
2249 I802_DEBUG_INC(rx->local->rx_handlers_fragments);
2251 if (skb_linearize(rx->skb))
2259 hdr = (struct ieee80211_hdr *)rx->skb->data;
2265 rx->seqno_idx, &(rx->skb));
2266 if (requires_sequential_pn(rx, fc)) {
2267 int queue = rx->security_idx;
2274 entry->key_color = rx->key->color;
2276 rx->key->u.ccmp.rx_pn[queue],
2282 BUILD_BUG_ON(sizeof(rx->key->u.ccmp.rx_pn[queue]) !=
2283 sizeof(rx->key->u.gcmp.rx_pn[queue]));
2286 } else if (rx->key &&
2290 entry->key_color = rx->key->color;
2299 rx->seqno_idx, hdr);
2301 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
2314 if (!requires_sequential_pn(rx, fc))
2318 if (entry->key_color != rx->key->color)
2328 rpn = rx->ccm_gcm.pn;
2333 (!rx->key ||
2336 rx->key->color != entry->key_color)) {
2342 } else if (entry->is_protected && rx->key &&
2343 entry->key_color != rx->key->color &&
2348 skb_pull(rx->skb, ieee80211_hdrlen(fc));
2349 __skb_queue_tail(&entry->skb_list, rx->skb);
2351 entry->extra_len += rx->skb->len;
2353 rx->skb = NULL;
2357 rx->skb = __skb_dequeue(&entry->skb_list);
2358 if (skb_tailroom(rx->skb) < entry->extra_len) {
2359 I802_DEBUG_INC(rx->local->rx_expand_skb_head_defrag);
2360 if (unlikely(pskb_expand_head(rx->skb, 0, entry->extra_len,
2362 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
2368 skb_put_data(rx->skb, skb->data, skb->len);
2373 ieee80211_led_rx(rx->local);
2374 if (rx->sta)
2375 rx->link_sta->rx_stats.packets++;
2379 static int ieee80211_802_1x_port_control(struct ieee80211_rx_data *rx)
2381 if (unlikely(!rx->sta || !test_sta_flag(rx->sta, WLAN_STA_AUTHORIZED)))
2387 static int ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc)
2389 struct sk_buff *skb = rx->skb;
2402 ieee80211_is_data(fc) && rx->key))
2408 static int ieee80211_drop_unencrypted_mgmt(struct ieee80211_rx_data *rx)
2410 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
2411 struct ieee80211_mgmt *mgmt = (void *)rx->skb->data;
2426 if (rx->sta && test_sta_flag(rx->sta, WLAN_STA_MFP)) {
2428 ieee80211_is_unicast_robust_mgmt_frame(rx->skb))) {
2435 if (!rx->key)
2438 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2439 rx->skb->data,
2440 rx->skb->len);
2445 if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb) &&
2446 ieee80211_get_mmie_keyidx(rx->skb) < 0)) {
2449 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2450 rx->skb->data,
2451 rx->skb->len);
2454 if (unlikely(ieee80211_is_beacon(fc) && rx->key &&
2455 ieee80211_get_mmie_keyidx(rx->skb) < 0)) {
2456 cfg80211_rx_unprot_mlme_mgmt(rx->sdata->dev,
2457 rx->skb->data,
2458 rx->skb->len);
2465 if (unlikely(ieee80211_is_action(fc) && !rx->key &&
2466 ieee80211_is_robust_mgmt_frame(rx->skb)))
2471 ieee80211_is_protected_dual_of_public_action(rx->skb))
2479 __ieee80211_data_to_8023(struct ieee80211_rx_data *rx, bool *port_control)
2481 struct ieee80211_sub_if_data *sdata = rx->sdata;
2482 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
2505 ret = ieee80211_data_to_8023(rx->skb, sdata->vif.addr, sdata->vif.type);
2509 ehdr = (struct ethhdr *) rx->skb->data;
2510 if (ehdr->h_proto == rx->sdata->control_port_protocol)
2548 * requires that rx->skb is a frame with ethernet header
2550 static bool ieee80211_frame_allowed(struct ieee80211_rx_data *rx, __le16 fc)
2554 struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
2561 if (unlikely(ehdr->h_proto == rx->sdata->control_port_protocol))
2562 return ieee80211_is_our_addr(rx->sdata, ehdr->h_dest, NULL) ||
2565 if (ieee80211_802_1x_port_control(rx) ||
2566 ieee80211_drop_unencrypted(rx, fc))
2573 struct ieee80211_rx_data *rx)
2575 struct ieee80211_sub_if_data *sdata = rx->sdata;
2585 cfg80211_rx_control_port(dev, skb, noencrypt, rx->link_id);
2612 if (rx->list)
2613 list_add_tail(&skb->list, rx->list);
2620 * requires that rx->skb is a frame with ethernet header
2623 ieee80211_deliver_skb(struct ieee80211_rx_data *rx)
2625 struct ieee80211_sub_if_data *sdata = rx->sdata;
2628 struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
2631 skb = rx->skb;
2636 if (rx->sta) {
2642 u64_stats_update_begin(&rx->link_sta->rx_stats.syncp);
2643 rx->link_sta->rx_stats.msdu[rx->seqno_idx]++;
2644 u64_stats_update_end(&rx->link_sta->rx_stats.syncp);
2650 ehdr->h_proto != rx->sdata->control_port_protocol &&
2706 ieee80211_deliver_skb_to_local_stack(skb, rx);
2966 __ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx, u8 data_offset)
2968 struct net_device *dev = rx->sdata->dev;
2969 struct sk_buff *skb = rx->skb;
2980 } else switch (rx->sdata->vif.type) {
2986 if (!rx->sta ||
2987 !test_sta_flag(rx->sta, WLAN_STA_TDLS_PEER))
3002 rx->sdata->vif.addr,
3003 rx->sdata->vif.type,
3007 if (rx->sta->amsdu_mesh_control < 0) {
3024 rx->sta->amsdu_mesh_control = valid;
3028 rx->sdata->vif.type,
3029 rx->local->hw.extra_tx_headroom,
3031 rx->sta->amsdu_mesh_control);
3034 rx->skb = __skb_dequeue(&frame_list);
3036 res = ieee80211_rx_mesh_data(rx->sdata, rx->sta, rx->skb);
3046 if (!ieee80211_frame_allowed(rx, fc))
3049 ieee80211_deliver_skb(rx);
3053 dev_kfree_skb(rx->skb);
3060 ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx)
3062 struct sk_buff *skb = rx->skb;
3077 switch (rx->sdata->vif.type) {
3079 if (!rx->sdata->u.vlan.sta)
3083 if (!rx->sdata->u.mgd.use_4addr)
3093 if (is_multicast_ether_addr(hdr->addr1) || !rx->sta)
3096 if (rx->key) {
3103 switch (rx->key->conf.cipher) {
3113 return __ieee80211_rx_h_amsdu(rx, 0);
3117 ieee80211_rx_h_data(struct ieee80211_rx_data *rx)
3119 struct ieee80211_sub_if_data *sdata = rx->sdata;
3120 struct ieee80211_local *local = rx->local;
3122 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
3140 if (rx->sta &&
3141 !test_and_set_sta_flag(rx->sta, WLAN_STA_4ADDR_EVENT))
3143 rx->sdata->dev, rx->sta->sta.addr, GFP_ATOMIC);
3147 err = __ieee80211_data_to_8023(rx, &port_control);
3151 res = ieee80211_rx_mesh_data(rx->sdata, rx->sta, rx->skb);
3155 if (!ieee80211_frame_allowed(rx, fc))
3159 if (unlikely(((struct ethhdr *)rx->skb->data)->h_proto ==
3161 struct ieee80211_tdls_data *tf = (void *)rx->skb->data;
3163 if (pskb_may_pull(rx->skb,
3169 rx->skb->protocol = cpu_to_be16(ETH_P_TDLS);
3170 __ieee80211_queue_skb_to_iface(sdata, rx->link_id,
3171 rx->sta, rx->skb);
3176 if (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
3181 rx->sdata = sdata;
3184 rx->skb->dev = dev;
3189 ((struct ethhdr *)rx->skb->data)->h_dest) &&
3195 ieee80211_deliver_skb(rx);
3201 ieee80211_rx_h_ctrl(struct ieee80211_rx_data *rx, struct sk_buff_head *frames)
3203 struct sk_buff *skb = rx->skb;
3220 if (!rx->sta)
3229 if (!test_bit(tid, rx->sta->ampdu_mlme.agg_session_valid) &&
3230 !test_and_set_bit(tid, rx->sta->ampdu_mlme.unexpected_agg))
3231 ieee80211_send_delba(rx->sdata, rx->sta->sta.addr, tid,
3235 tid_agg_rx = rcu_dereference(rx->sta->ampdu_mlme.tid_rx[tid]);
3242 event.u.ba.sta = &rx->sta->sta;
3251 ieee80211_release_reorder_frames(rx->sdata, tid_agg_rx,
3255 drv_event_callback(rx->local, rx->sdata, &event);
3315 ieee80211_rx_check_bss_color_collision(struct ieee80211_rx_data *rx)
3317 struct ieee80211_mgmt *mgmt = (void *)rx->skb->data;
3321 if (!wiphy_ext_feature_isset(rx->local->hw.wiphy,
3325 if (ieee80211_hw_check(&rx->local->hw, DETECTS_COLOR_COLLISION))
3328 if (rx->sdata->vif.bss_conf.csa_active)
3331 baselen = mgmt->u.beacon.variable - rx->skb->data;
3332 if (baselen > rx->skb->len)
3337 rx->skb->len - baselen);
3340 struct ieee80211_bss_conf *bss_conf = &rx->sdata->vif.bss_conf;
3352 ieee80211_obss_color_collision_notify(&rx->sdata->vif,
3359 ieee80211_rx_h_mgmt_check(struct ieee80211_rx_data *rx)
3361 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
3362 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3372 if (rx->skb->len < 24)
3380 rx->skb->len < IEEE80211_MIN_ACTION_SIZE)
3383 if (rx->sdata->vif.type == NL80211_IFTYPE_AP &&
3385 !(rx->flags & IEEE80211_RX_BEACON_REPORTED)) {
3389 ieee80211_rx_check_bss_color_collision(rx);
3391 if (ieee80211_hw_check(&rx->local->hw, SIGNAL_DBM) &&
3395 cfg80211_report_obss_beacon_khz(rx->local->hw.wiphy,
3396 rx->skb->data, rx->skb->len,
3399 rx->flags |= IEEE80211_RX_BEACON_REPORTED;
3402 if (ieee80211_drop_unencrypted_mgmt(rx))
3409 ieee80211_process_rx_twt_action(struct ieee80211_rx_data *rx)
3411 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)rx->skb->data;
3412 struct ieee80211_sub_if_data *sdata = rx->sdata;
3418 if (!rx->local->ops->add_twt_setup)
3424 if (!rx->sta)
3431 if (rx->skb->len < IEEE80211_MIN_ACTION_SIZE +
3441 if (rx->skb->len < IEEE80211_MIN_ACTION_SIZE +
3449 if (rx->skb->len < IEEE80211_MIN_ACTION_SIZE + 2)
3461 ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
3463 struct ieee80211_local *local = rx->local;
3464 struct ieee80211_sub_if_data *sdata = rx->sdata;
3465 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
3466 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3467 int len = rx->skb->len;
3472 if (!rx->sta && mgmt->u.action.category != WLAN_CATEGORY_PUBLIC &&
3480 if (!rx->link_sta->pub->ht_cap.ht_supported)
3520 if (rx->link_sta->pub->smps_mode == smps_mode)
3522 rx->link_sta->pub->smps_mode = smps_mode;
3527 sband = rx->local->hw.wiphy->bands[status->band];
3529 rate_control_rate_update(local, sband, rx->sta, 0,
3532 rx->sta->addr,
3544 if (!(rx->link_sta->pub->ht_cap.cap &
3551 max_bw = ieee80211_sta_cap_rx_bw(rx->link_sta);
3554 rx->link_sta->cur_max_bandwidth = max_bw;
3555 new_bw = ieee80211_sta_cur_vht_bw(rx->link_sta);
3557 if (rx->link_sta->pub->bandwidth == new_bw)
3560 rx->link_sta->pub->bandwidth = new_bw;
3561 sband = rx->local->hw.wiphy->bands[status->band];
3563 ieee80211_sta_rx_bw_to_chan_width(rx->link_sta);
3566 rate_control_rate_update(local, sband, rx->sta, 0,
3569 rx->sta->addr,
3584 if (!rx->sta)
3743 if (ieee80211_process_rx_twt_action(rx))
3760 if (rx->sta)
3761 rx->link_sta->rx_stats.packets++;
3762 dev_kfree_skb(rx->skb);
3766 ieee80211_queue_skb_to_iface(sdata, rx->link_id, rx->sta, rx->skb);
3771 ieee80211_rx_h_userspace_mgmt(struct ieee80211_rx_data *rx)
3773 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3776 .buf = rx->skb->data,
3777 .len = rx->skb->len,
3778 .link_id = rx->link_id,
3779 .have_link_id = rx->link_id >= 0,
3793 if (ieee80211_hw_check(&rx->local->hw, SIGNAL_DBM) &&
3797 if (ieee80211_is_timing_measurement(rx->skb) ||
3798 ieee80211_is_ftm(rx->skb)) {
3799 info.rx_tstamp = ktime_to_ns(skb_hwtstamps(rx->skb)->hwtstamp);
3803 if (cfg80211_rx_mgmt_ext(&rx->sdata->wdev, &info)) {
3804 if (rx->sta)
3805 rx->link_sta->rx_stats.packets++;
3806 dev_kfree_skb(rx->skb);
3814 ieee80211_rx_h_action_post_userspace(struct ieee80211_rx_data *rx)
3816 struct ieee80211_sub_if_data *sdata = rx->sdata;
3817 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
3818 int len = rx->skb->len;
3842 if (rx->sta)
3843 rx->link_sta->rx_stats.packets++;
3844 dev_kfree_skb(rx->skb);
3849 ieee80211_rx_h_action_return(struct ieee80211_rx_data *rx)
3851 struct ieee80211_local *local = rx->local;
3852 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
3854 struct ieee80211_sub_if_data *sdata = rx->sdata;
3855 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
3882 nskb = skb_copy_expand(rx->skb, local->hw.extra_tx_headroom, 0,
3889 memcpy(nmgmt->sa, rx->sdata->vif.addr, ETH_ALEN);
3893 if (rx->sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {
3904 __ieee80211_tx_skb_tid_band(rx->sdata, nskb, 7, -1,
3907 dev_kfree_skb(rx->skb);
3912 ieee80211_rx_h_ext(struct ieee80211_rx_data *rx)
3914 struct ieee80211_sub_if_data *sdata = rx->sdata;
3915 struct ieee80211_hdr *hdr = (void *)rx->skb->data;
3924 ieee80211_queue_skb_to_iface(sdata, rx->link_id, rx->sta, rx->skb);
3930 ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
3932 struct ieee80211_sub_if_data *sdata = rx->sdata;
3933 struct ieee80211_mgmt *mgmt = (void *)rx->skb->data;
3981 ieee80211_queue_skb_to_iface(sdata, rx->link_id, rx->sta, rx->skb);
3986 static void ieee80211_rx_cooked_monitor(struct ieee80211_rx_data *rx,
3991 struct ieee80211_local *local = rx->local;
3992 struct sk_buff *skb = rx->skb, *skb2;
4001 if (rx->flags & IEEE80211_RX_CMNTR)
4003 rx->flags |= IEEE80211_RX_CMNTR;
4055 static void ieee80211_rx_handlers_result(struct ieee80211_rx_data *rx,
4058 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
4063 I802_DEBUG_INC(rx->sdata->local->rx_handlers_queued);
4068 I802_DEBUG_INC(rx->sdata->local->rx_handlers_drop);
4069 if (rx->sta)
4070 rx->link_sta->rx_stats.dropped++;
4075 kfree_skb_reason(rx->skb, (__force u32)res);
4079 sband = rx->local->hw.wiphy->bands[status->band];
4083 ieee80211_rx_cooked_monitor(rx, rate, res);
4086 static void ieee80211_rx_handlers(struct ieee80211_rx_data *rx,
4094 res = rxh(rx); \
4105 spin_lock_bh(&rx->local->rx_path_lock);
4113 rx->skb = skb;
4115 if (WARN_ON_ONCE(!rx->link))
4129 res = ieee80211_rx_h_ctrl(rx, frames);
4142 ieee80211_rx_handlers_result(rx, res);
4147 spin_unlock_bh(&rx->local->rx_path_lock);
4150 static void ieee80211_invoke_rx_handlers(struct ieee80211_rx_data *rx)
4159 res = rxh(rx); \
4167 ieee80211_rx_reorder_ampdu(rx, &reorder_release);
4169 ieee80211_rx_handlers(rx, &reorder_release);
4173 ieee80211_rx_handlers_result(rx, res);
4184 static bool ieee80211_rx_data_set_link(struct ieee80211_rx_data *rx,
4187 rx->link_id = link_id;
4188 rx->link = rcu_dereference(rx->sdata->link[link_id]);
4190 if (!rx->sta)
4191 return rx->link;
4193 if (!ieee80211_rx_is_valid_sta_link_id(&rx->sta->sta, link_id))
4196 rx->link_sta = rcu_dereference(rx->sta->link[link_id]);
4198 return rx->link && rx->link_sta;
4201 static bool ieee80211_rx_data_set_sta(struct ieee80211_rx_data *rx,
4204 rx->link_id = link_id;
4205 rx->sta = sta;
4208 rx->local = sta->sdata->local;
4209 if (!rx->sdata)
4210 rx->sdata = sta->sdata;
4211 rx->link_sta = &sta->deflink;
4213 rx->link_sta = NULL;
4217 rx->link = &rx->sdata->deflink;
4218 else if (!ieee80211_rx_data_set_link(rx, link_id))
4231 struct ieee80211_rx_data rx = {
4243 if (!ieee80211_rx_data_set_sta(&rx, sta, link_id))
4262 drv_event_callback(rx.local, rx.sdata, &event);
4265 ieee80211_rx_handlers(&rx, &frames);
4276 struct ieee80211_rx_data rx = {
4295 if (!ieee80211_rx_data_set_sta(&rx, sta, -1))
4345 ieee80211_rx_handlers(&rx, &frames);
4360 static bool ieee80211_accept_frame(struct ieee80211_rx_data *rx)
4362 struct ieee80211_sub_if_data *sdata = rx->sdata;
4363 struct sk_buff *skb = rx->skb;
4375 ieee80211_is_robust_mgmt_frame(skb) && !rx->sta)
4379 return ieee80211_is_our_addr(sdata, hdr->addr1, &rx->link_id);
4394 if (!rx->sta) {
4414 if (!rx->sta) {
4434 &rx->link_id);
4446 &rx->link_id))
4526 /* fast-rx doesn't do reordering */
4563 /* parallel-rx requires this, at least with calls to
4606 /* we don't want to deal with MMIC in fast-rx */
4690 static void ieee80211_rx_8023(struct ieee80211_rx_data *rx,
4695 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
4696 struct sta_info *sta = rx->sta;
4698 struct sk_buff *skb = rx->skb;
4702 if (rx->link_id >= 0) {
4703 link_sta = rcu_dereference(sta->link[rx->link_id]);
4705 dev_kfree_skb(rx->skb);
4758 stats->msdu[rx->seqno_idx]++;
4767 sta_info_get(rx->sdata, da)) {
4791 ieee80211_deliver_skb_to_local_stack(skb, rx);
4794 static bool ieee80211_invoke_fast_rx(struct ieee80211_rx_data *rx,
4797 struct sk_buff *skb = rx->skb;
4814 /* for parallel-rx, we need to have DUP_VALIDATED, otherwise we write
4862 if (!ieee80211_vif_is_mesh(&rx->sdata->vif) &&
4884 if (rx->key && !(status->flag & RX_FLAG_MIC_STRIPPED) &&
4888 if (rx->key && !ieee80211_has_protected(hdr->frame_control))
4892 if (__ieee80211_rx_h_amsdu(rx, snap_offs - hdrlen) !=
4902 if (ieee80211_vif_is_mesh(&rx->sdata->vif)) {
4915 res = ieee80211_rx_mesh_data(rx->sdata, rx->sta, rx->skb);
4925 ieee80211_rx_8023(rx, fast_rx, orig_len);
4932 stats = this_cpu_ptr(rx->link_sta->pcpu_rx_stats);
4934 stats = &rx->link_sta->rx_stats;
4946 static bool ieee80211_prepare_and_rx_handle(struct ieee80211_rx_data *rx,
4949 struct ieee80211_local *local = rx->local;
4950 struct ieee80211_sub_if_data *sdata = rx->sdata;
4952 struct link_sta_info *link_sta = rx->link_sta;
4953 struct ieee80211_link_data *link = rx->link;
4955 rx->skb = skb;
4957 /* See if we can do fast-rx; if we have to copy we already lost,
4964 if (consume && rx->sta) {
4967 fast_rx = rcu_dereference(rx->sta->fast_rx);
4968 if (fast_rx && ieee80211_invoke_fast_rx(rx, fast_rx))
4972 if (!ieee80211_accept_frame(rx))
4978 rx->skb = skb_copy(skb, GFP_ATOMIC);
4979 if (!rx->skb) {
4990 shwt = skb_hwtstamps(rx->skb);
4994 hdr = (struct ieee80211_hdr *)rx->skb->data;
4997 if (unlikely(rx->sta && rx->sta->sta.mlo) &&
5003 ether_addr_copy(hdr->addr1, rx->sdata->vif.addr);
5005 ether_addr_copy(hdr->addr2, rx->sta->addr);
5010 ether_addr_copy(hdr->addr3, rx->sta->addr);
5012 ether_addr_copy(hdr->addr3, rx->sdata->vif.addr);
5017 ieee80211_invoke_rx_handlers(rx);
5029 struct ieee80211_rx_data rx;
5033 memset(&rx, 0, sizeof(rx));
5034 rx.skb = skb;
5035 rx.local = local;
5036 rx.list = list;
5037 rx.link_id = -1;
5059 if (!ieee80211_rx_data_set_sta(&rx, sta, link_id))
5062 fast_rx = rcu_dereference(rx.sta->fast_rx);
5066 ieee80211_rx_8023(&rx, fast_rx, skb->len);
5073 static bool ieee80211_rx_for_interface(struct ieee80211_rx_data *rx,
5087 link_sta = link_sta_info_get_bss(rx->sdata, hdr->addr2);
5094 sta = sta_info_get_bss(rx->sdata, hdr->addr2);
5099 if (!ieee80211_rx_data_set_sta(rx, sta, link_id))
5102 return ieee80211_prepare_and_rx_handle(rx, skb, consume);
5119 struct ieee80211_rx_data rx;
5125 memset(&rx, 0, sizeof(rx));
5126 rx.skb = skb;
5127 rx.local = local;
5128 rx.list = list;
5129 rx.link_id = -1;
5150 ieee80211_parse_qos(&rx);
5151 ieee80211_verify_alignment(&rx);
5167 if (!ieee80211_rx_data_set_sta(&rx, sta, link_id))
5182 link_sta = link_sta_info_get_bss(rx.sdata,
5187 ieee80211_rx_data_set_link(&rx, link_sta->link_id);
5190 if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
5203 rx.sdata = prev_sta->sdata;
5204 if (!ieee80211_rx_data_set_sta(&rx, prev_sta, link_id))
5210 ieee80211_prepare_and_rx_handle(&rx, skb, false);
5216 rx.sdata = prev_sta->sdata;
5217 if (!ieee80211_rx_data_set_sta(&rx, prev_sta, link_id))
5223 if (ieee80211_prepare_and_rx_handle(&rx, skb, true))
5250 rx.sdata = prev;
5251 ieee80211_rx_for_interface(&rx, skb, false);
5257 rx.sdata = prev;
5259 if (ieee80211_rx_for_interface(&rx, skb, true))
5432 /* This is a version of the rx handler that can be called from hard irq