2 * BSS client mode implementation
3 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
4 * Copyright 2004, Instant802 Networks, Inc.
5 * Copyright 2005, Devicescape Software, Inc.
6 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
7 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
15 * order BSS list by RSSI(?) ("quality of AP")
16 * scan result table filtering (by capability (privacy, IBSS/BSS, WPA/RSN IE,
19 #include <linux/delay.h>
20 #include <linux/if_ether.h>
21 #include <linux/skbuff.h>
22 #include <linux/netdevice.h>
23 #include <linux/if_arp.h>
24 #include <linux/wireless.h>
25 #include <linux/random.h>
26 #include <linux/etherdevice.h>
27 #include <net/iw_handler.h>
28 #include <asm/types.h>
30 #include <net/mac80211.h>
31 #include "ieee80211_i.h"
32 #include "ieee80211_rate.h"
33 #include "ieee80211_led.h"
35 #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
36 #define IEEE80211_AUTH_MAX_TRIES 3
37 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
38 #define IEEE80211_ASSOC_MAX_TRIES 3
39 #define IEEE80211_MONITORING_INTERVAL (2 * HZ)
40 #define IEEE80211_PROBE_INTERVAL (60 * HZ)
41 #define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ)
42 #define IEEE80211_SCAN_INTERVAL (2 * HZ)
43 #define IEEE80211_SCAN_INTERVAL_SLOW (15 * HZ)
44 #define IEEE80211_IBSS_JOIN_TIMEOUT (20 * HZ)
46 #define IEEE80211_PROBE_DELAY (HZ / 33)
47 #define IEEE80211_CHANNEL_TIME (HZ / 33)
48 #define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 5)
49 #define IEEE80211_SCAN_RESULT_EXPIRE (10 * HZ)
50 #define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
51 #define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
53 #define IEEE80211_IBSS_MAX_STA_ENTRIES 128
56 #define IEEE80211_FC(type, stype) cpu_to_le16(type | stype)
58 #define ERP_INFO_USE_PROTECTION BIT(1)
60 /* mgmt header + 1 byte action code */
61 #define IEEE80211_MIN_ACTION_SIZE (24 + 1)
63 #define IEEE80211_ADDBA_PARAM_POLICY_MASK 0x0002
64 #define IEEE80211_ADDBA_PARAM_TID_MASK 0x003C
65 #define IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK 0xFFA0
66 #define IEEE80211_DELBA_PARAM_TID_MASK 0xF000
67 #define IEEE80211_DELBA_PARAM_INITIATOR_MASK 0x0800
69 /* next values represent the buffer size for A-MPDU frame.
70 * According to IEEE802.11n spec size varies from 8K to 64K (in powers of 2) */
71 #define IEEE80211_MIN_AMPDU_BUF 0x8
72 #define IEEE80211_MAX_AMPDU_BUF 0x40
74 static void ieee80211_send_probe_req(struct net_device
*dev
, u8
*dst
,
75 u8
*ssid
, size_t ssid_len
);
76 static struct ieee80211_sta_bss
*
77 ieee80211_rx_bss_get(struct net_device
*dev
, u8
*bssid
, int channel
,
78 u8
*ssid
, u8 ssid_len
);
79 static void ieee80211_rx_bss_put(struct net_device
*dev
,
80 struct ieee80211_sta_bss
*bss
);
81 static int ieee80211_sta_find_ibss(struct net_device
*dev
,
82 struct ieee80211_if_sta
*ifsta
);
83 static int ieee80211_sta_wep_configured(struct net_device
*dev
);
84 static int ieee80211_sta_start_scan(struct net_device
*dev
,
85 u8
*ssid
, size_t ssid_len
);
86 static int ieee80211_sta_config_auth(struct net_device
*dev
,
87 struct ieee80211_if_sta
*ifsta
);
90 /* Parsed Information Elements */
91 struct ieee802_11_elems
{
109 /* length of them, respectively */
121 u8 ext_supp_rates_len
;
128 static void ieee802_11_parse_elems(u8
*start
, size_t len
,
129 struct ieee802_11_elems
*elems
)
134 memset(elems
, 0, sizeof(*elems
));
149 elems
->ssid_len
= elen
;
151 case WLAN_EID_SUPP_RATES
:
152 elems
->supp_rates
= pos
;
153 elems
->supp_rates_len
= elen
;
155 case WLAN_EID_FH_PARAMS
:
156 elems
->fh_params
= pos
;
157 elems
->fh_params_len
= elen
;
159 case WLAN_EID_DS_PARAMS
:
160 elems
->ds_params
= pos
;
161 elems
->ds_params_len
= elen
;
163 case WLAN_EID_CF_PARAMS
:
164 elems
->cf_params
= pos
;
165 elems
->cf_params_len
= elen
;
169 elems
->tim_len
= elen
;
171 case WLAN_EID_IBSS_PARAMS
:
172 elems
->ibss_params
= pos
;
173 elems
->ibss_params_len
= elen
;
175 case WLAN_EID_CHALLENGE
:
176 elems
->challenge
= pos
;
177 elems
->challenge_len
= elen
;
180 if (elen
>= 4 && pos
[0] == 0x00 && pos
[1] == 0x50 &&
182 /* Microsoft OUI (00:50:F2) */
184 /* OUI Type 1 - WPA IE */
186 elems
->wpa_len
= elen
;
187 } else if (elen
>= 5 && pos
[3] == 2) {
189 elems
->wmm_info
= pos
;
190 elems
->wmm_info_len
= elen
;
191 } else if (pos
[4] == 1) {
192 elems
->wmm_param
= pos
;
193 elems
->wmm_param_len
= elen
;
200 elems
->rsn_len
= elen
;
202 case WLAN_EID_ERP_INFO
:
203 elems
->erp_info
= pos
;
204 elems
->erp_info_len
= elen
;
206 case WLAN_EID_EXT_SUPP_RATES
:
207 elems
->ext_supp_rates
= pos
;
208 elems
->ext_supp_rates_len
= elen
;
210 case WLAN_EID_HT_CAPABILITY
:
211 elems
->ht_cap_elem
= pos
;
212 elems
->ht_cap_elem_len
= elen
;
214 case WLAN_EID_HT_EXTRA_INFO
:
215 elems
->ht_info_elem
= pos
;
216 elems
->ht_info_elem_len
= elen
;
228 static int ecw2cw(int ecw
)
238 static void ieee80211_sta_wmm_params(struct net_device
*dev
,
239 struct ieee80211_if_sta
*ifsta
,
240 u8
*wmm_param
, size_t wmm_param_len
)
242 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
243 struct ieee80211_tx_queue_params params
;
248 if (wmm_param_len
< 8 || wmm_param
[5] /* version */ != 1)
250 count
= wmm_param
[6] & 0x0f;
251 if (count
== ifsta
->wmm_last_param_set
)
253 ifsta
->wmm_last_param_set
= count
;
256 left
= wmm_param_len
- 8;
258 memset(¶ms
, 0, sizeof(params
));
260 if (!local
->ops
->conf_tx
)
264 for (; left
>= 4; left
-= 4, pos
+= 4) {
265 int aci
= (pos
[0] >> 5) & 0x03;
266 int acm
= (pos
[0] >> 4) & 0x01;
271 queue
= IEEE80211_TX_QUEUE_DATA3
;
273 local
->wmm_acm
|= BIT(0) | BIT(3);
277 queue
= IEEE80211_TX_QUEUE_DATA1
;
279 local
->wmm_acm
|= BIT(4) | BIT(5);
283 queue
= IEEE80211_TX_QUEUE_DATA0
;
285 local
->wmm_acm
|= BIT(6) | BIT(7);
290 queue
= IEEE80211_TX_QUEUE_DATA2
;
292 local
->wmm_acm
|= BIT(1) | BIT(2);
297 params
.aifs
= pos
[0] & 0x0f;
298 params
.cw_max
= ecw2cw((pos
[1] & 0xf0) >> 4);
299 params
.cw_min
= ecw2cw(pos
[1] & 0x0f);
300 /* TXOP is in units of 32 usec; burst_time in 0.1 ms */
301 params
.burst_time
= (pos
[2] | (pos
[3] << 8)) * 32 / 100;
302 printk(KERN_DEBUG
"%s: WMM queue=%d aci=%d acm=%d aifs=%d "
303 "cWmin=%d cWmax=%d burst=%d\n",
304 dev
->name
, queue
, aci
, acm
, params
.aifs
, params
.cw_min
,
305 params
.cw_max
, params
.burst_time
);
306 /* TODO: handle ACM (block TX, fallback to next lowest allowed
308 if (local
->ops
->conf_tx(local_to_hw(local
), queue
, ¶ms
)) {
309 printk(KERN_DEBUG
"%s: failed to set TX queue "
310 "parameters for queue %d\n", dev
->name
, queue
);
316 static u32
ieee80211_handle_erp_ie(struct ieee80211_sub_if_data
*sdata
,
319 struct ieee80211_bss_conf
*bss_conf
= &sdata
->bss_conf
;
320 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
321 bool use_protection
= (erp_value
& WLAN_ERP_USE_PROTECTION
) != 0;
322 bool preamble_mode
= (erp_value
& WLAN_ERP_BARKER_PREAMBLE
) != 0;
323 DECLARE_MAC_BUF(mac
);
326 if (use_protection
!= bss_conf
->use_cts_prot
) {
327 if (net_ratelimit()) {
328 printk(KERN_DEBUG
"%s: CTS protection %s (BSSID="
331 use_protection
? "enabled" : "disabled",
332 print_mac(mac
, ifsta
->bssid
));
334 bss_conf
->use_cts_prot
= use_protection
;
335 changed
|= BSS_CHANGED_ERP_CTS_PROT
;
338 if (preamble_mode
!= bss_conf
->use_short_preamble
) {
339 if (net_ratelimit()) {
340 printk(KERN_DEBUG
"%s: switched to %s barker preamble"
343 (preamble_mode
== WLAN_ERP_PREAMBLE_SHORT
) ?
345 print_mac(mac
, ifsta
->bssid
));
347 bss_conf
->use_short_preamble
= preamble_mode
;
348 changed
|= BSS_CHANGED_ERP_PREAMBLE
;
354 int ieee80211_ht_cap_ie_to_ht_info(struct ieee80211_ht_cap
*ht_cap_ie
,
355 struct ieee80211_ht_info
*ht_info
)
361 memset(ht_info
, 0, sizeof(*ht_info
));
364 u8 ampdu_info
= ht_cap_ie
->ampdu_params_info
;
366 ht_info
->ht_supported
= 1;
367 ht_info
->cap
= le16_to_cpu(ht_cap_ie
->cap_info
);
368 ht_info
->ampdu_factor
=
369 ampdu_info
& IEEE80211_HT_CAP_AMPDU_FACTOR
;
370 ht_info
->ampdu_density
=
371 (ampdu_info
& IEEE80211_HT_CAP_AMPDU_DENSITY
) >> 2;
372 memcpy(ht_info
->supp_mcs_set
, ht_cap_ie
->supp_mcs_set
, 16);
374 ht_info
->ht_supported
= 0;
379 int ieee80211_ht_addt_info_ie_to_ht_bss_info(
380 struct ieee80211_ht_addt_info
*ht_add_info_ie
,
381 struct ieee80211_ht_bss_info
*bss_info
)
383 if (bss_info
== NULL
)
386 memset(bss_info
, 0, sizeof(*bss_info
));
388 if (ht_add_info_ie
) {
390 op_mode
= le16_to_cpu(ht_add_info_ie
->operation_mode
);
392 bss_info
->primary_channel
= ht_add_info_ie
->control_chan
;
393 bss_info
->bss_cap
= ht_add_info_ie
->ht_param
;
394 bss_info
->bss_op_mode
= (u8
)(op_mode
& 0xff);
400 static void ieee80211_sta_send_associnfo(struct net_device
*dev
,
401 struct ieee80211_if_sta
*ifsta
)
406 union iwreq_data wrqu
;
408 if (!ifsta
->assocreq_ies
&& !ifsta
->assocresp_ies
)
411 buf
= kmalloc(50 + 2 * (ifsta
->assocreq_ies_len
+
412 ifsta
->assocresp_ies_len
), GFP_KERNEL
);
416 len
= sprintf(buf
, "ASSOCINFO(");
417 if (ifsta
->assocreq_ies
) {
418 len
+= sprintf(buf
+ len
, "ReqIEs=");
419 for (i
= 0; i
< ifsta
->assocreq_ies_len
; i
++) {
420 len
+= sprintf(buf
+ len
, "%02x",
421 ifsta
->assocreq_ies
[i
]);
424 if (ifsta
->assocresp_ies
) {
425 if (ifsta
->assocreq_ies
)
426 len
+= sprintf(buf
+ len
, " ");
427 len
+= sprintf(buf
+ len
, "RespIEs=");
428 for (i
= 0; i
< ifsta
->assocresp_ies_len
; i
++) {
429 len
+= sprintf(buf
+ len
, "%02x",
430 ifsta
->assocresp_ies
[i
]);
433 len
+= sprintf(buf
+ len
, ")");
435 if (len
> IW_CUSTOM_MAX
) {
436 len
= sprintf(buf
, "ASSOCRESPIE=");
437 for (i
= 0; i
< ifsta
->assocresp_ies_len
; i
++) {
438 len
+= sprintf(buf
+ len
, "%02x",
439 ifsta
->assocresp_ies
[i
]);
443 memset(&wrqu
, 0, sizeof(wrqu
));
444 wrqu
.data
.length
= len
;
445 wireless_send_event(dev
, IWEVCUSTOM
, &wrqu
, buf
);
451 static void ieee80211_set_associated(struct net_device
*dev
,
452 struct ieee80211_if_sta
*ifsta
,
455 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
456 struct ieee80211_local
*local
= sdata
->local
;
457 union iwreq_data wrqu
;
458 u32 changed
= BSS_CHANGED_ASSOC
;
461 struct ieee80211_sta_bss
*bss
;
463 ifsta
->flags
|= IEEE80211_STA_ASSOCIATED
;
465 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_STA
)
468 bss
= ieee80211_rx_bss_get(dev
, ifsta
->bssid
,
469 local
->hw
.conf
.channel
,
470 ifsta
->ssid
, ifsta
->ssid_len
);
472 if (bss
->has_erp_value
)
473 changed
|= ieee80211_handle_erp_ie(
474 sdata
, bss
->erp_value
);
475 ieee80211_rx_bss_put(dev
, bss
);
478 netif_carrier_on(dev
);
479 ifsta
->flags
|= IEEE80211_STA_PREV_BSSID_SET
;
480 memcpy(ifsta
->prev_bssid
, sdata
->u
.sta
.bssid
, ETH_ALEN
);
481 memcpy(wrqu
.ap_addr
.sa_data
, sdata
->u
.sta
.bssid
, ETH_ALEN
);
482 ieee80211_sta_send_associnfo(dev
, ifsta
);
484 ifsta
->flags
&= ~IEEE80211_STA_ASSOCIATED
;
486 netif_carrier_off(dev
);
487 ieee80211_reset_erp_info(dev
);
488 memset(wrqu
.ap_addr
.sa_data
, 0, ETH_ALEN
);
490 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
491 wireless_send_event(dev
, SIOCGIWAP
, &wrqu
, NULL
);
492 ifsta
->last_probe
= jiffies
;
493 ieee80211_led_assoc(local
, assoc
);
495 sdata
->bss_conf
.assoc
= assoc
;
496 ieee80211_bss_info_change_notify(sdata
, changed
);
499 static void ieee80211_set_disassoc(struct net_device
*dev
,
500 struct ieee80211_if_sta
*ifsta
, int deauth
)
503 ifsta
->auth_tries
= 0;
504 ifsta
->assoc_tries
= 0;
505 ieee80211_set_associated(dev
, ifsta
, 0);
508 static void ieee80211_sta_tx(struct net_device
*dev
, struct sk_buff
*skb
,
511 struct ieee80211_sub_if_data
*sdata
;
512 struct ieee80211_tx_packet_data
*pkt_data
;
514 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
515 skb
->dev
= sdata
->local
->mdev
;
516 skb_set_mac_header(skb
, 0);
517 skb_set_network_header(skb
, 0);
518 skb_set_transport_header(skb
, 0);
520 pkt_data
= (struct ieee80211_tx_packet_data
*) skb
->cb
;
521 memset(pkt_data
, 0, sizeof(struct ieee80211_tx_packet_data
));
522 pkt_data
->ifindex
= sdata
->dev
->ifindex
;
524 pkt_data
->flags
|= IEEE80211_TXPD_DO_NOT_ENCRYPT
;
530 static void ieee80211_send_auth(struct net_device
*dev
,
531 struct ieee80211_if_sta
*ifsta
,
532 int transaction
, u8
*extra
, size_t extra_len
,
535 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
537 struct ieee80211_mgmt
*mgmt
;
539 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+
540 sizeof(*mgmt
) + 6 + extra_len
);
542 printk(KERN_DEBUG
"%s: failed to allocate buffer for auth "
543 "frame\n", dev
->name
);
546 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
548 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24 + 6);
549 memset(mgmt
, 0, 24 + 6);
550 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
551 IEEE80211_STYPE_AUTH
);
553 mgmt
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
554 memcpy(mgmt
->da
, ifsta
->bssid
, ETH_ALEN
);
555 memcpy(mgmt
->sa
, dev
->dev_addr
, ETH_ALEN
);
556 memcpy(mgmt
->bssid
, ifsta
->bssid
, ETH_ALEN
);
557 mgmt
->u
.auth
.auth_alg
= cpu_to_le16(ifsta
->auth_alg
);
558 mgmt
->u
.auth
.auth_transaction
= cpu_to_le16(transaction
);
559 ifsta
->auth_transaction
= transaction
+ 1;
560 mgmt
->u
.auth
.status_code
= cpu_to_le16(0);
562 memcpy(skb_put(skb
, extra_len
), extra
, extra_len
);
564 ieee80211_sta_tx(dev
, skb
, encrypt
);
568 static void ieee80211_authenticate(struct net_device
*dev
,
569 struct ieee80211_if_sta
*ifsta
)
571 DECLARE_MAC_BUF(mac
);
574 if (ifsta
->auth_tries
> IEEE80211_AUTH_MAX_TRIES
) {
575 printk(KERN_DEBUG
"%s: authentication with AP %s"
577 dev
->name
, print_mac(mac
, ifsta
->bssid
));
578 ifsta
->state
= IEEE80211_DISABLED
;
582 ifsta
->state
= IEEE80211_AUTHENTICATE
;
583 printk(KERN_DEBUG
"%s: authenticate with AP %s\n",
584 dev
->name
, print_mac(mac
, ifsta
->bssid
));
586 ieee80211_send_auth(dev
, ifsta
, 1, NULL
, 0, 0);
588 mod_timer(&ifsta
->timer
, jiffies
+ IEEE80211_AUTH_TIMEOUT
);
592 static void ieee80211_send_assoc(struct net_device
*dev
,
593 struct ieee80211_if_sta
*ifsta
)
595 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
596 struct ieee80211_hw_mode
*mode
;
598 struct ieee80211_mgmt
*mgmt
;
602 struct ieee80211_sta_bss
*bss
;
605 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+
606 sizeof(*mgmt
) + 200 + ifsta
->extra_ie_len
+
609 printk(KERN_DEBUG
"%s: failed to allocate buffer for assoc "
610 "frame\n", dev
->name
);
613 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
615 mode
= local
->oper_hw_mode
;
616 capab
= ifsta
->capab
;
617 if (mode
->mode
== MODE_IEEE80211G
) {
618 capab
|= WLAN_CAPABILITY_SHORT_SLOT_TIME
|
619 WLAN_CAPABILITY_SHORT_PREAMBLE
;
621 bss
= ieee80211_rx_bss_get(dev
, ifsta
->bssid
, local
->hw
.conf
.channel
,
622 ifsta
->ssid
, ifsta
->ssid_len
);
624 if (bss
->capability
& WLAN_CAPABILITY_PRIVACY
)
625 capab
|= WLAN_CAPABILITY_PRIVACY
;
629 ieee80211_rx_bss_put(dev
, bss
);
632 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
634 memcpy(mgmt
->da
, ifsta
->bssid
, ETH_ALEN
);
635 memcpy(mgmt
->sa
, dev
->dev_addr
, ETH_ALEN
);
636 memcpy(mgmt
->bssid
, ifsta
->bssid
, ETH_ALEN
);
638 if (ifsta
->flags
& IEEE80211_STA_PREV_BSSID_SET
) {
640 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
641 IEEE80211_STYPE_REASSOC_REQ
);
642 mgmt
->u
.reassoc_req
.capab_info
= cpu_to_le16(capab
);
643 mgmt
->u
.reassoc_req
.listen_interval
= cpu_to_le16(1);
644 memcpy(mgmt
->u
.reassoc_req
.current_ap
, ifsta
->prev_bssid
,
648 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
649 IEEE80211_STYPE_ASSOC_REQ
);
650 mgmt
->u
.assoc_req
.capab_info
= cpu_to_le16(capab
);
651 mgmt
->u
.assoc_req
.listen_interval
= cpu_to_le16(1);
655 ies
= pos
= skb_put(skb
, 2 + ifsta
->ssid_len
);
656 *pos
++ = WLAN_EID_SSID
;
657 *pos
++ = ifsta
->ssid_len
;
658 memcpy(pos
, ifsta
->ssid
, ifsta
->ssid_len
);
660 len
= mode
->num_rates
;
663 pos
= skb_put(skb
, len
+ 2);
664 *pos
++ = WLAN_EID_SUPP_RATES
;
666 for (i
= 0; i
< len
; i
++) {
667 int rate
= mode
->rates
[i
].rate
;
668 *pos
++ = (u8
) (rate
/ 5);
671 if (mode
->num_rates
> len
) {
672 pos
= skb_put(skb
, mode
->num_rates
- len
+ 2);
673 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
674 *pos
++ = mode
->num_rates
- len
;
675 for (i
= len
; i
< mode
->num_rates
; i
++) {
676 int rate
= mode
->rates
[i
].rate
;
677 *pos
++ = (u8
) (rate
/ 5);
681 if (ifsta
->extra_ie
) {
682 pos
= skb_put(skb
, ifsta
->extra_ie_len
);
683 memcpy(pos
, ifsta
->extra_ie
, ifsta
->extra_ie_len
);
686 if (wmm
&& (ifsta
->flags
& IEEE80211_STA_WMM_ENABLED
)) {
687 pos
= skb_put(skb
, 9);
688 *pos
++ = WLAN_EID_VENDOR_SPECIFIC
;
689 *pos
++ = 7; /* len */
690 *pos
++ = 0x00; /* Microsoft OUI 00:50:F2 */
693 *pos
++ = 2; /* WME */
694 *pos
++ = 0; /* WME info */
695 *pos
++ = 1; /* WME ver */
698 /* wmm support is a must to HT */
699 if (wmm
&& mode
->ht_info
.ht_supported
) {
700 __le16 tmp
= cpu_to_le16(mode
->ht_info
.cap
);
701 pos
= skb_put(skb
, sizeof(struct ieee80211_ht_cap
)+2);
702 *pos
++ = WLAN_EID_HT_CAPABILITY
;
703 *pos
++ = sizeof(struct ieee80211_ht_cap
);
704 memset(pos
, 0, sizeof(struct ieee80211_ht_cap
));
705 memcpy(pos
, &tmp
, sizeof(u16
));
707 *pos
++ = (mode
->ht_info
.ampdu_factor
|
708 (mode
->ht_info
.ampdu_density
<< 2));
709 memcpy(pos
, mode
->ht_info
.supp_mcs_set
, 16);
712 kfree(ifsta
->assocreq_ies
);
713 ifsta
->assocreq_ies_len
= (skb
->data
+ skb
->len
) - ies
;
714 ifsta
->assocreq_ies
= kmalloc(ifsta
->assocreq_ies_len
, GFP_KERNEL
);
715 if (ifsta
->assocreq_ies
)
716 memcpy(ifsta
->assocreq_ies
, ies
, ifsta
->assocreq_ies_len
);
718 ieee80211_sta_tx(dev
, skb
, 0);
722 static void ieee80211_send_deauth(struct net_device
*dev
,
723 struct ieee80211_if_sta
*ifsta
, u16 reason
)
725 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
727 struct ieee80211_mgmt
*mgmt
;
729 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ sizeof(*mgmt
));
731 printk(KERN_DEBUG
"%s: failed to allocate buffer for deauth "
732 "frame\n", dev
->name
);
735 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
737 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
739 memcpy(mgmt
->da
, ifsta
->bssid
, ETH_ALEN
);
740 memcpy(mgmt
->sa
, dev
->dev_addr
, ETH_ALEN
);
741 memcpy(mgmt
->bssid
, ifsta
->bssid
, ETH_ALEN
);
742 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
743 IEEE80211_STYPE_DEAUTH
);
745 mgmt
->u
.deauth
.reason_code
= cpu_to_le16(reason
);
747 ieee80211_sta_tx(dev
, skb
, 0);
751 static void ieee80211_send_disassoc(struct net_device
*dev
,
752 struct ieee80211_if_sta
*ifsta
, u16 reason
)
754 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
756 struct ieee80211_mgmt
*mgmt
;
758 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ sizeof(*mgmt
));
760 printk(KERN_DEBUG
"%s: failed to allocate buffer for disassoc "
761 "frame\n", dev
->name
);
764 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
766 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
768 memcpy(mgmt
->da
, ifsta
->bssid
, ETH_ALEN
);
769 memcpy(mgmt
->sa
, dev
->dev_addr
, ETH_ALEN
);
770 memcpy(mgmt
->bssid
, ifsta
->bssid
, ETH_ALEN
);
771 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
772 IEEE80211_STYPE_DISASSOC
);
774 mgmt
->u
.disassoc
.reason_code
= cpu_to_le16(reason
);
776 ieee80211_sta_tx(dev
, skb
, 0);
780 static int ieee80211_privacy_mismatch(struct net_device
*dev
,
781 struct ieee80211_if_sta
*ifsta
)
783 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
784 struct ieee80211_sta_bss
*bss
;
789 if (!ifsta
|| (ifsta
->flags
& IEEE80211_STA_MIXED_CELL
))
792 bss
= ieee80211_rx_bss_get(dev
, ifsta
->bssid
, local
->hw
.conf
.channel
,
793 ifsta
->ssid
, ifsta
->ssid_len
);
797 bss_privacy
= !!(bss
->capability
& WLAN_CAPABILITY_PRIVACY
);
798 wep_privacy
= !!ieee80211_sta_wep_configured(dev
);
799 privacy_invoked
= !!(ifsta
->flags
& IEEE80211_STA_PRIVACY_INVOKED
);
801 ieee80211_rx_bss_put(dev
, bss
);
803 if ((bss_privacy
== wep_privacy
) || (bss_privacy
== privacy_invoked
))
810 static void ieee80211_associate(struct net_device
*dev
,
811 struct ieee80211_if_sta
*ifsta
)
813 DECLARE_MAC_BUF(mac
);
815 ifsta
->assoc_tries
++;
816 if (ifsta
->assoc_tries
> IEEE80211_ASSOC_MAX_TRIES
) {
817 printk(KERN_DEBUG
"%s: association with AP %s"
819 dev
->name
, print_mac(mac
, ifsta
->bssid
));
820 ifsta
->state
= IEEE80211_DISABLED
;
824 ifsta
->state
= IEEE80211_ASSOCIATE
;
825 printk(KERN_DEBUG
"%s: associate with AP %s\n",
826 dev
->name
, print_mac(mac
, ifsta
->bssid
));
827 if (ieee80211_privacy_mismatch(dev
, ifsta
)) {
828 printk(KERN_DEBUG
"%s: mismatch in privacy configuration and "
829 "mixed-cell disabled - abort association\n", dev
->name
);
830 ifsta
->state
= IEEE80211_DISABLED
;
834 ieee80211_send_assoc(dev
, ifsta
);
836 mod_timer(&ifsta
->timer
, jiffies
+ IEEE80211_ASSOC_TIMEOUT
);
840 static void ieee80211_associated(struct net_device
*dev
,
841 struct ieee80211_if_sta
*ifsta
)
843 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
844 struct sta_info
*sta
;
846 DECLARE_MAC_BUF(mac
);
848 /* TODO: start monitoring current AP signal quality and number of
849 * missed beacons. Scan other channels every now and then and search
851 /* TODO: remove expired BSSes */
853 ifsta
->state
= IEEE80211_ASSOCIATED
;
855 sta
= sta_info_get(local
, ifsta
->bssid
);
857 printk(KERN_DEBUG
"%s: No STA entry for own AP %s\n",
858 dev
->name
, print_mac(mac
, ifsta
->bssid
));
862 if (time_after(jiffies
,
863 sta
->last_rx
+ IEEE80211_MONITORING_INTERVAL
)) {
864 if (ifsta
->flags
& IEEE80211_STA_PROBEREQ_POLL
) {
865 printk(KERN_DEBUG
"%s: No ProbeResp from "
866 "current AP %s - assume out of "
868 dev
->name
, print_mac(mac
, ifsta
->bssid
));
872 ieee80211_send_probe_req(dev
, ifsta
->bssid
,
874 local
->scan_ssid_len
);
875 ifsta
->flags
^= IEEE80211_STA_PROBEREQ_POLL
;
877 ifsta
->flags
&= ~IEEE80211_STA_PROBEREQ_POLL
;
878 if (time_after(jiffies
, ifsta
->last_probe
+
879 IEEE80211_PROBE_INTERVAL
)) {
880 ifsta
->last_probe
= jiffies
;
881 ieee80211_send_probe_req(dev
, ifsta
->bssid
,
889 ifsta
->state
= IEEE80211_DISABLED
;
890 ieee80211_set_associated(dev
, ifsta
, 0);
892 mod_timer(&ifsta
->timer
, jiffies
+
893 IEEE80211_MONITORING_INTERVAL
);
898 static void ieee80211_send_probe_req(struct net_device
*dev
, u8
*dst
,
899 u8
*ssid
, size_t ssid_len
)
901 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
902 struct ieee80211_hw_mode
*mode
;
904 struct ieee80211_mgmt
*mgmt
;
905 u8
*pos
, *supp_rates
, *esupp_rates
= NULL
;
908 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ sizeof(*mgmt
) + 200);
910 printk(KERN_DEBUG
"%s: failed to allocate buffer for probe "
911 "request\n", dev
->name
);
914 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
916 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
918 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
919 IEEE80211_STYPE_PROBE_REQ
);
920 memcpy(mgmt
->sa
, dev
->dev_addr
, ETH_ALEN
);
922 memcpy(mgmt
->da
, dst
, ETH_ALEN
);
923 memcpy(mgmt
->bssid
, dst
, ETH_ALEN
);
925 memset(mgmt
->da
, 0xff, ETH_ALEN
);
926 memset(mgmt
->bssid
, 0xff, ETH_ALEN
);
928 pos
= skb_put(skb
, 2 + ssid_len
);
929 *pos
++ = WLAN_EID_SSID
;
931 memcpy(pos
, ssid
, ssid_len
);
933 supp_rates
= skb_put(skb
, 2);
934 supp_rates
[0] = WLAN_EID_SUPP_RATES
;
936 mode
= local
->oper_hw_mode
;
937 for (i
= 0; i
< mode
->num_rates
; i
++) {
938 struct ieee80211_rate
*rate
= &mode
->rates
[i
];
939 if (!(rate
->flags
& IEEE80211_RATE_SUPPORTED
))
942 pos
= skb_put(skb
, 1);
944 } else if (supp_rates
[1] == 8) {
945 esupp_rates
= skb_put(skb
, 3);
946 esupp_rates
[0] = WLAN_EID_EXT_SUPP_RATES
;
948 pos
= &esupp_rates
[2];
950 pos
= skb_put(skb
, 1);
953 *pos
= rate
->rate
/ 5;
956 ieee80211_sta_tx(dev
, skb
, 0);
960 static int ieee80211_sta_wep_configured(struct net_device
*dev
)
962 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
963 if (!sdata
|| !sdata
->default_key
||
964 sdata
->default_key
->conf
.alg
!= ALG_WEP
)
970 static void ieee80211_auth_completed(struct net_device
*dev
,
971 struct ieee80211_if_sta
*ifsta
)
973 printk(KERN_DEBUG
"%s: authenticated\n", dev
->name
);
974 ifsta
->flags
|= IEEE80211_STA_AUTHENTICATED
;
975 ieee80211_associate(dev
, ifsta
);
979 static void ieee80211_auth_challenge(struct net_device
*dev
,
980 struct ieee80211_if_sta
*ifsta
,
981 struct ieee80211_mgmt
*mgmt
,
985 struct ieee802_11_elems elems
;
987 printk(KERN_DEBUG
"%s: replying to auth challenge\n", dev
->name
);
988 pos
= mgmt
->u
.auth
.variable
;
989 ieee802_11_parse_elems(pos
, len
- (pos
- (u8
*) mgmt
), &elems
);
990 if (!elems
.challenge
) {
991 printk(KERN_DEBUG
"%s: no challenge IE in shared key auth "
992 "frame\n", dev
->name
);
995 ieee80211_send_auth(dev
, ifsta
, 3, elems
.challenge
- 2,
996 elems
.challenge_len
+ 2, 1);
999 static void ieee80211_send_addba_resp(struct net_device
*dev
, u8
*da
, u16 tid
,
1000 u8 dialog_token
, u16 status
, u16 policy
,
1001 u16 buf_size
, u16 timeout
)
1003 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1004 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
1005 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1006 struct sk_buff
*skb
;
1007 struct ieee80211_mgmt
*mgmt
;
1010 skb
= dev_alloc_skb(sizeof(*mgmt
) + local
->hw
.extra_tx_headroom
+ 1 +
1011 sizeof(mgmt
->u
.action
.u
.addba_resp
));
1013 printk(KERN_DEBUG
"%s: failed to allocate buffer "
1014 "for addba resp frame\n", dev
->name
);
1018 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
1019 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
1020 memset(mgmt
, 0, 24);
1021 memcpy(mgmt
->da
, da
, ETH_ALEN
);
1022 memcpy(mgmt
->sa
, dev
->dev_addr
, ETH_ALEN
);
1023 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_AP
)
1024 memcpy(mgmt
->bssid
, dev
->dev_addr
, ETH_ALEN
);
1026 memcpy(mgmt
->bssid
, ifsta
->bssid
, ETH_ALEN
);
1027 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
1028 IEEE80211_STYPE_ACTION
);
1030 skb_put(skb
, 1 + sizeof(mgmt
->u
.action
.u
.addba_resp
));
1031 mgmt
->u
.action
.category
= WLAN_CATEGORY_BACK
;
1032 mgmt
->u
.action
.u
.addba_resp
.action_code
= WLAN_ACTION_ADDBA_RESP
;
1033 mgmt
->u
.action
.u
.addba_resp
.dialog_token
= dialog_token
;
1035 capab
= (u16
)(policy
<< 1); /* bit 1 aggregation policy */
1036 capab
|= (u16
)(tid
<< 2); /* bit 5:2 TID number */
1037 capab
|= (u16
)(buf_size
<< 6); /* bit 15:6 max size of aggregation */
1039 mgmt
->u
.action
.u
.addba_resp
.capab
= cpu_to_le16(capab
);
1040 mgmt
->u
.action
.u
.addba_resp
.timeout
= cpu_to_le16(timeout
);
1041 mgmt
->u
.action
.u
.addba_resp
.status
= cpu_to_le16(status
);
1043 ieee80211_sta_tx(dev
, skb
, 0);
1048 void ieee80211_send_addba_request(struct net_device
*dev
, const u8
*da
,
1049 u16 tid
, u8 dialog_token
, u16 start_seq_num
,
1050 u16 agg_size
, u16 timeout
)
1052 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1053 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1054 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
1055 struct sk_buff
*skb
;
1056 struct ieee80211_mgmt
*mgmt
;
1059 skb
= dev_alloc_skb(sizeof(*mgmt
) + local
->hw
.extra_tx_headroom
+ 1 +
1060 sizeof(mgmt
->u
.action
.u
.addba_req
));
1064 printk(KERN_ERR
"%s: failed to allocate buffer "
1065 "for addba request frame\n", dev
->name
);
1068 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
1069 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
1070 memset(mgmt
, 0, 24);
1071 memcpy(mgmt
->da
, da
, ETH_ALEN
);
1072 memcpy(mgmt
->sa
, dev
->dev_addr
, ETH_ALEN
);
1073 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_AP
)
1074 memcpy(mgmt
->bssid
, dev
->dev_addr
, ETH_ALEN
);
1076 memcpy(mgmt
->bssid
, ifsta
->bssid
, ETH_ALEN
);
1078 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
1079 IEEE80211_STYPE_ACTION
);
1081 skb_put(skb
, 1 + sizeof(mgmt
->u
.action
.u
.addba_req
));
1083 mgmt
->u
.action
.category
= WLAN_CATEGORY_BACK
;
1084 mgmt
->u
.action
.u
.addba_req
.action_code
= WLAN_ACTION_ADDBA_REQ
;
1086 mgmt
->u
.action
.u
.addba_req
.dialog_token
= dialog_token
;
1087 capab
= (u16
)(1 << 1); /* bit 1 aggregation policy */
1088 capab
|= (u16
)(tid
<< 2); /* bit 5:2 TID number */
1089 capab
|= (u16
)(agg_size
<< 6); /* bit 15:6 max size of aggergation */
1091 mgmt
->u
.action
.u
.addba_req
.capab
= cpu_to_le16(capab
);
1093 mgmt
->u
.action
.u
.addba_req
.timeout
= cpu_to_le16(timeout
);
1094 mgmt
->u
.action
.u
.addba_req
.start_seq_num
=
1095 cpu_to_le16(start_seq_num
<< 4);
1097 ieee80211_sta_tx(dev
, skb
, 0);
1100 static void ieee80211_sta_process_addba_request(struct net_device
*dev
,
1101 struct ieee80211_mgmt
*mgmt
,
1104 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1105 struct ieee80211_hw
*hw
= &local
->hw
;
1106 struct ieee80211_conf
*conf
= &hw
->conf
;
1107 struct sta_info
*sta
;
1108 struct tid_ampdu_rx
*tid_agg_rx
;
1109 u16 capab
, tid
, timeout
, ba_policy
, buf_size
, start_seq_num
, status
;
1111 int ret
= -EOPNOTSUPP
;
1112 DECLARE_MAC_BUF(mac
);
1114 sta
= sta_info_get(local
, mgmt
->sa
);
1118 /* extract session parameters from addba request frame */
1119 dialog_token
= mgmt
->u
.action
.u
.addba_req
.dialog_token
;
1120 timeout
= le16_to_cpu(mgmt
->u
.action
.u
.addba_req
.timeout
);
1122 le16_to_cpu(mgmt
->u
.action
.u
.addba_req
.start_seq_num
) >> 4;
1124 capab
= le16_to_cpu(mgmt
->u
.action
.u
.addba_req
.capab
);
1125 ba_policy
= (capab
& IEEE80211_ADDBA_PARAM_POLICY_MASK
) >> 1;
1126 tid
= (capab
& IEEE80211_ADDBA_PARAM_TID_MASK
) >> 2;
1127 buf_size
= (capab
& IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK
) >> 6;
1129 status
= WLAN_STATUS_REQUEST_DECLINED
;
1131 /* sanity check for incoming parameters:
1132 * check if configuration can support the BA policy
1133 * and if buffer size does not exceeds max value */
1134 if (((ba_policy
!= 1)
1135 && (!(conf
->ht_conf
.cap
& IEEE80211_HT_CAP_DELAY_BA
)))
1136 || (buf_size
> IEEE80211_MAX_AMPDU_BUF
)) {
1137 status
= WLAN_STATUS_INVALID_QOS_PARAM
;
1138 #ifdef CONFIG_MAC80211_HT_DEBUG
1139 if (net_ratelimit())
1140 printk(KERN_DEBUG
"Block Ack Req with bad params from "
1141 "%s on tid %u. policy %d, buffer size %d\n",
1142 print_mac(mac
, mgmt
->sa
), tid
, ba_policy
,
1144 #endif /* CONFIG_MAC80211_HT_DEBUG */
1147 /* determine default buffer size */
1148 if (buf_size
== 0) {
1149 struct ieee80211_hw_mode
*mode
= conf
->mode
;
1150 buf_size
= IEEE80211_MIN_AMPDU_BUF
;
1151 buf_size
= buf_size
<< mode
->ht_info
.ampdu_factor
;
1154 tid_agg_rx
= &sta
->ampdu_mlme
.tid_rx
[tid
];
1156 /* examine state machine */
1157 spin_lock_bh(&sta
->ampdu_mlme
.ampdu_rx
);
1159 if (tid_agg_rx
->state
!= HT_AGG_STATE_IDLE
) {
1160 #ifdef CONFIG_MAC80211_HT_DEBUG
1161 if (net_ratelimit())
1162 printk(KERN_DEBUG
"unexpected Block Ack Req from "
1164 print_mac(mac
, mgmt
->sa
), tid
);
1165 #endif /* CONFIG_MAC80211_HT_DEBUG */
1169 /* prepare reordering buffer */
1170 tid_agg_rx
->reorder_buf
=
1171 kmalloc(buf_size
* sizeof(struct sk_buf
*), GFP_ATOMIC
);
1172 if (!tid_agg_rx
->reorder_buf
) {
1173 if (net_ratelimit())
1174 printk(KERN_ERR
"can not allocate reordering buffer "
1175 "to tid %d\n", tid
);
1178 memset(tid_agg_rx
->reorder_buf
, 0,
1179 buf_size
* sizeof(struct sk_buf
*));
1181 if (local
->ops
->ampdu_action
)
1182 ret
= local
->ops
->ampdu_action(hw
, IEEE80211_AMPDU_RX_START
,
1183 sta
->addr
, tid
, &start_seq_num
);
1184 #ifdef CONFIG_MAC80211_HT_DEBUG
1185 printk(KERN_DEBUG
"Rx A-MPDU on tid %d result %d", tid
, ret
);
1186 #endif /* CONFIG_MAC80211_HT_DEBUG */
1189 kfree(tid_agg_rx
->reorder_buf
);
1193 /* change state and send addba resp */
1194 tid_agg_rx
->state
= HT_AGG_STATE_OPERATIONAL
;
1195 tid_agg_rx
->dialog_token
= dialog_token
;
1196 tid_agg_rx
->ssn
= start_seq_num
;
1197 tid_agg_rx
->head_seq_num
= start_seq_num
;
1198 tid_agg_rx
->buf_size
= buf_size
;
1199 tid_agg_rx
->timeout
= timeout
;
1200 tid_agg_rx
->stored_mpdu_num
= 0;
1201 status
= WLAN_STATUS_SUCCESS
;
1203 spin_unlock_bh(&sta
->ampdu_mlme
.ampdu_rx
);
1206 ieee80211_send_addba_resp(sta
->dev
, sta
->addr
, tid
, dialog_token
,
1207 status
, 1, buf_size
, timeout
);
1211 static void ieee80211_sta_process_addba_resp(struct net_device
*dev
,
1212 struct ieee80211_mgmt
*mgmt
,
1215 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1216 struct ieee80211_hw
*hw
= &local
->hw
;
1217 struct sta_info
*sta
;
1222 sta
= sta_info_get(local
, mgmt
->sa
);
1226 capab
= le16_to_cpu(mgmt
->u
.action
.u
.addba_resp
.capab
);
1227 tid
= (capab
& IEEE80211_ADDBA_PARAM_TID_MASK
) >> 2;
1229 state
= &sta
->ampdu_mlme
.tid_tx
[tid
].state
;
1231 spin_lock_bh(&sta
->ampdu_mlme
.ampdu_tx
);
1233 if (mgmt
->u
.action
.u
.addba_resp
.dialog_token
!=
1234 sta
->ampdu_mlme
.tid_tx
[tid
].dialog_token
) {
1235 spin_unlock_bh(&sta
->ampdu_mlme
.ampdu_tx
);
1236 #ifdef CONFIG_MAC80211_HT_DEBUG
1237 printk(KERN_DEBUG
"wrong addBA response token, tid %d\n", tid
);
1238 #endif /* CONFIG_MAC80211_HT_DEBUG */
1243 del_timer_sync(&sta
->ampdu_mlme
.tid_tx
[tid
].addba_resp_timer
);
1244 #ifdef CONFIG_MAC80211_HT_DEBUG
1245 printk(KERN_DEBUG
"switched off addBA timer for tid %d \n", tid
);
1246 #endif /* CONFIG_MAC80211_HT_DEBUG */
1247 if (le16_to_cpu(mgmt
->u
.action
.u
.addba_resp
.status
)
1248 == WLAN_STATUS_SUCCESS
) {
1249 if (!(*state
& HT_ADDBA_REQUESTED_MSK
)) {
1250 spin_unlock_bh(&sta
->ampdu_mlme
.ampdu_tx
);
1251 printk(KERN_DEBUG
"state not HT_ADDBA_REQUESTED_MSK:"
1257 if (*state
& HT_ADDBA_RECEIVED_MSK
)
1258 printk(KERN_DEBUG
"double addBA response\n");
1260 *state
|= HT_ADDBA_RECEIVED_MSK
;
1261 sta
->ampdu_mlme
.tid_tx
[tid
].addba_req_num
= 0;
1263 if (*state
== HT_AGG_STATE_OPERATIONAL
) {
1264 printk(KERN_DEBUG
"Aggregation on for tid %d \n", tid
);
1265 ieee80211_wake_queue(hw
, sta
->tid_to_tx_q
[tid
]);
1268 spin_unlock_bh(&sta
->ampdu_mlme
.ampdu_tx
);
1269 printk(KERN_DEBUG
"recipient accepted agg: tid %d \n", tid
);
1271 printk(KERN_DEBUG
"recipient rejected agg: tid %d \n", tid
);
1273 sta
->ampdu_mlme
.tid_tx
[tid
].addba_req_num
++;
1274 /* this will allow the state check in stop_BA_session */
1275 *state
= HT_AGG_STATE_OPERATIONAL
;
1276 spin_unlock_bh(&sta
->ampdu_mlme
.ampdu_tx
);
1277 ieee80211_stop_tx_ba_session(hw
, sta
->addr
, tid
,
1278 WLAN_BACK_INITIATOR
);
1283 void ieee80211_send_delba(struct net_device
*dev
, const u8
*da
, u16 tid
,
1284 u16 initiator
, u16 reason_code
)
1286 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1287 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1288 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
1289 struct sk_buff
*skb
;
1290 struct ieee80211_mgmt
*mgmt
;
1293 skb
= dev_alloc_skb(sizeof(*mgmt
) + local
->hw
.extra_tx_headroom
+ 1 +
1294 sizeof(mgmt
->u
.action
.u
.delba
));
1297 printk(KERN_ERR
"%s: failed to allocate buffer "
1298 "for delba frame\n", dev
->name
);
1302 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
1303 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
1304 memset(mgmt
, 0, 24);
1305 memcpy(mgmt
->da
, da
, ETH_ALEN
);
1306 memcpy(mgmt
->sa
, dev
->dev_addr
, ETH_ALEN
);
1307 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_AP
)
1308 memcpy(mgmt
->bssid
, dev
->dev_addr
, ETH_ALEN
);
1310 memcpy(mgmt
->bssid
, ifsta
->bssid
, ETH_ALEN
);
1311 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
1312 IEEE80211_STYPE_ACTION
);
1314 skb_put(skb
, 1 + sizeof(mgmt
->u
.action
.u
.delba
));
1316 mgmt
->u
.action
.category
= WLAN_CATEGORY_BACK
;
1317 mgmt
->u
.action
.u
.delba
.action_code
= WLAN_ACTION_DELBA
;
1318 params
= (u16
)(initiator
<< 11); /* bit 11 initiator */
1319 params
|= (u16
)(tid
<< 12); /* bit 15:12 TID number */
1321 mgmt
->u
.action
.u
.delba
.params
= cpu_to_le16(params
);
1322 mgmt
->u
.action
.u
.delba
.reason_code
= cpu_to_le16(reason_code
);
1324 ieee80211_sta_tx(dev
, skb
, 0);
1327 void ieee80211_sta_stop_rx_ba_session(struct net_device
*dev
, u8
*ra
, u16 tid
,
1328 u16 initiator
, u16 reason
)
1330 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1331 struct ieee80211_hw
*hw
= &local
->hw
;
1332 struct sta_info
*sta
;
1335 sta
= sta_info_get(local
, ra
);
1339 /* check if TID is in operational state */
1340 spin_lock_bh(&sta
->ampdu_mlme
.ampdu_rx
);
1341 if (sta
->ampdu_mlme
.tid_rx
[tid
].state
1342 != HT_AGG_STATE_OPERATIONAL
) {
1343 spin_unlock_bh(&sta
->ampdu_mlme
.ampdu_rx
);
1347 sta
->ampdu_mlme
.tid_rx
[tid
].state
=
1348 HT_AGG_STATE_REQ_STOP_BA_MSK
|
1349 (initiator
<< HT_AGG_STATE_INITIATOR_SHIFT
);
1350 spin_unlock_bh(&sta
->ampdu_mlme
.ampdu_rx
);
1352 /* stop HW Rx aggregation. ampdu_action existence
1353 * already verified in session init so we add the BUG_ON */
1354 BUG_ON(!local
->ops
->ampdu_action
);
1356 ret
= local
->ops
->ampdu_action(hw
, IEEE80211_AMPDU_RX_STOP
,
1359 printk(KERN_DEBUG
"HW problem - can not stop rx "
1360 "aggergation for tid %d\n", tid
);
1362 /* shutdown timer has not expired */
1363 if (initiator
!= WLAN_BACK_TIMER
)
1364 del_timer_sync(&sta
->ampdu_mlme
.tid_rx
[tid
].
1367 /* check if this is a self generated aggregation halt */
1368 if (initiator
== WLAN_BACK_RECIPIENT
|| initiator
== WLAN_BACK_TIMER
)
1369 ieee80211_send_delba(dev
, ra
, tid
, 0, reason
);
1371 /* free the reordering buffer */
1372 for (i
= 0; i
< sta
->ampdu_mlme
.tid_rx
[tid
].buf_size
; i
++) {
1373 if (sta
->ampdu_mlme
.tid_rx
[tid
].reorder_buf
[i
]) {
1374 /* release the reordered frames */
1375 dev_kfree_skb(sta
->ampdu_mlme
.tid_rx
[tid
].reorder_buf
[i
]);
1376 sta
->ampdu_mlme
.tid_rx
[tid
].stored_mpdu_num
--;
1377 sta
->ampdu_mlme
.tid_rx
[tid
].reorder_buf
[i
] = NULL
;
1380 kfree(sta
->ampdu_mlme
.tid_rx
[tid
].reorder_buf
);
1382 sta
->ampdu_mlme
.tid_rx
[tid
].state
= HT_AGG_STATE_IDLE
;
1387 static void ieee80211_sta_process_delba(struct net_device
*dev
,
1388 struct ieee80211_mgmt
*mgmt
, size_t len
)
1390 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1391 struct sta_info
*sta
;
1394 DECLARE_MAC_BUF(mac
);
1396 sta
= sta_info_get(local
, mgmt
->sa
);
1400 params
= le16_to_cpu(mgmt
->u
.action
.u
.delba
.params
);
1401 tid
= (params
& IEEE80211_DELBA_PARAM_TID_MASK
) >> 12;
1402 initiator
= (params
& IEEE80211_DELBA_PARAM_INITIATOR_MASK
) >> 11;
1404 #ifdef CONFIG_MAC80211_HT_DEBUG
1405 if (net_ratelimit())
1406 printk(KERN_DEBUG
"delba from %s on tid %d reason code %d\n",
1407 print_mac(mac
, mgmt
->sa
), tid
,
1408 mgmt
->u
.action
.u
.delba
.reason_code
);
1409 #endif /* CONFIG_MAC80211_HT_DEBUG */
1411 if (initiator
== WLAN_BACK_INITIATOR
)
1412 ieee80211_sta_stop_rx_ba_session(dev
, sta
->addr
, tid
,
1413 WLAN_BACK_INITIATOR
, 0);
1418 * After sending add Block Ack request we activated a timer until
1419 * add Block Ack response will arrive from the recipient.
1420 * If this timer expires sta_addba_resp_timer_expired will be executed.
1422 void sta_addba_resp_timer_expired(unsigned long data
)
1424 /* not an elegant detour, but there is no choice as the timer passes
1425 * only one argument, and both sta_info and TID are needed, so init
1426 * flow in sta_info_add gives the TID as data, while the timer_to_id
1427 * array gives the sta through container_of */
1428 u16 tid
= *(int *)data
;
1429 struct sta_info
*temp_sta
= container_of((void *)data
,
1430 struct sta_info
, timer_to_tid
[tid
]);
1432 struct ieee80211_local
*local
= temp_sta
->local
;
1433 struct ieee80211_hw
*hw
= &local
->hw
;
1434 struct sta_info
*sta
;
1437 sta
= sta_info_get(local
, temp_sta
->addr
);
1441 state
= &sta
->ampdu_mlme
.tid_tx
[tid
].state
;
1442 /* check if the TID waits for addBA response */
1443 spin_lock_bh(&sta
->ampdu_mlme
.ampdu_tx
);
1444 if (!(*state
& HT_ADDBA_REQUESTED_MSK
)) {
1445 spin_unlock_bh(&sta
->ampdu_mlme
.ampdu_tx
);
1446 *state
= HT_AGG_STATE_IDLE
;
1447 printk(KERN_DEBUG
"timer expired on tid %d but we are not "
1448 "expecting addBA response there", tid
);
1449 goto timer_expired_exit
;
1452 printk(KERN_DEBUG
"addBA response timer expired on tid %d\n", tid
);
1454 /* go through the state check in stop_BA_session */
1455 *state
= HT_AGG_STATE_OPERATIONAL
;
1456 spin_unlock_bh(&sta
->ampdu_mlme
.ampdu_tx
);
1457 ieee80211_stop_tx_ba_session(hw
, temp_sta
->addr
, tid
,
1458 WLAN_BACK_INITIATOR
);
1465 * After receiving Block Ack Request (BAR) we activated a
1466 * timer after each frame arrives from the originator.
1467 * if this timer expires ieee80211_sta_stop_rx_ba_session will be executed.
1469 void sta_rx_agg_session_timer_expired(unsigned long data
)
1471 /* not an elegant detour, but there is no choice as the timer passes
1472 * only one argument, and verious sta_info are needed here, so init
1473 * flow in sta_info_add gives the TID as data, while the timer_to_id
1474 * array gives the sta through container_of */
1475 u8
*ptid
= (u8
*)data
;
1476 u8
*timer_to_id
= ptid
- *ptid
;
1477 struct sta_info
*sta
= container_of(timer_to_id
, struct sta_info
,
1480 printk(KERN_DEBUG
"rx session timer expired on tid %d\n", (u16
)*ptid
);
1481 ieee80211_sta_stop_rx_ba_session(sta
->dev
, sta
->addr
, (u16
)*ptid
,
1483 WLAN_REASON_QSTA_TIMEOUT
);
1487 static void ieee80211_rx_mgmt_auth(struct net_device
*dev
,
1488 struct ieee80211_if_sta
*ifsta
,
1489 struct ieee80211_mgmt
*mgmt
,
1492 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1493 u16 auth_alg
, auth_transaction
, status_code
;
1494 DECLARE_MAC_BUF(mac
);
1496 if (ifsta
->state
!= IEEE80211_AUTHENTICATE
&&
1497 sdata
->vif
.type
!= IEEE80211_IF_TYPE_IBSS
) {
1498 printk(KERN_DEBUG
"%s: authentication frame received from "
1499 "%s, but not in authenticate state - ignored\n",
1500 dev
->name
, print_mac(mac
, mgmt
->sa
));
1505 printk(KERN_DEBUG
"%s: too short (%zd) authentication frame "
1506 "received from %s - ignored\n",
1507 dev
->name
, len
, print_mac(mac
, mgmt
->sa
));
1511 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_IBSS
&&
1512 memcmp(ifsta
->bssid
, mgmt
->sa
, ETH_ALEN
) != 0) {
1513 printk(KERN_DEBUG
"%s: authentication frame received from "
1514 "unknown AP (SA=%s BSSID=%s) - "
1515 "ignored\n", dev
->name
, print_mac(mac
, mgmt
->sa
),
1516 print_mac(mac
, mgmt
->bssid
));
1520 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_IBSS
&&
1521 memcmp(ifsta
->bssid
, mgmt
->bssid
, ETH_ALEN
) != 0) {
1522 printk(KERN_DEBUG
"%s: authentication frame received from "
1523 "unknown BSSID (SA=%s BSSID=%s) - "
1524 "ignored\n", dev
->name
, print_mac(mac
, mgmt
->sa
),
1525 print_mac(mac
, mgmt
->bssid
));
1529 auth_alg
= le16_to_cpu(mgmt
->u
.auth
.auth_alg
);
1530 auth_transaction
= le16_to_cpu(mgmt
->u
.auth
.auth_transaction
);
1531 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
1533 printk(KERN_DEBUG
"%s: RX authentication from %s (alg=%d "
1534 "transaction=%d status=%d)\n",
1535 dev
->name
, print_mac(mac
, mgmt
->sa
), auth_alg
,
1536 auth_transaction
, status_code
);
1538 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_IBSS
) {
1539 /* IEEE 802.11 standard does not require authentication in IBSS
1540 * networks and most implementations do not seem to use it.
1541 * However, try to reply to authentication attempts if someone
1542 * has actually implemented this.
1543 * TODO: Could implement shared key authentication. */
1544 if (auth_alg
!= WLAN_AUTH_OPEN
|| auth_transaction
!= 1) {
1545 printk(KERN_DEBUG
"%s: unexpected IBSS authentication "
1546 "frame (alg=%d transaction=%d)\n",
1547 dev
->name
, auth_alg
, auth_transaction
);
1550 ieee80211_send_auth(dev
, ifsta
, 2, NULL
, 0, 0);
1553 if (auth_alg
!= ifsta
->auth_alg
||
1554 auth_transaction
!= ifsta
->auth_transaction
) {
1555 printk(KERN_DEBUG
"%s: unexpected authentication frame "
1556 "(alg=%d transaction=%d)\n",
1557 dev
->name
, auth_alg
, auth_transaction
);
1561 if (status_code
!= WLAN_STATUS_SUCCESS
) {
1562 printk(KERN_DEBUG
"%s: AP denied authentication (auth_alg=%d "
1563 "code=%d)\n", dev
->name
, ifsta
->auth_alg
, status_code
);
1564 if (status_code
== WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG
) {
1566 const int num_algs
= ARRAY_SIZE(algs
);
1568 algs
[0] = algs
[1] = algs
[2] = 0xff;
1569 if (ifsta
->auth_algs
& IEEE80211_AUTH_ALG_OPEN
)
1570 algs
[0] = WLAN_AUTH_OPEN
;
1571 if (ifsta
->auth_algs
& IEEE80211_AUTH_ALG_SHARED_KEY
)
1572 algs
[1] = WLAN_AUTH_SHARED_KEY
;
1573 if (ifsta
->auth_algs
& IEEE80211_AUTH_ALG_LEAP
)
1574 algs
[2] = WLAN_AUTH_LEAP
;
1575 if (ifsta
->auth_alg
== WLAN_AUTH_OPEN
)
1577 else if (ifsta
->auth_alg
== WLAN_AUTH_SHARED_KEY
)
1581 for (i
= 0; i
< num_algs
; i
++) {
1583 if (pos
>= num_algs
)
1585 if (algs
[pos
] == ifsta
->auth_alg
||
1588 if (algs
[pos
] == WLAN_AUTH_SHARED_KEY
&&
1589 !ieee80211_sta_wep_configured(dev
))
1591 ifsta
->auth_alg
= algs
[pos
];
1592 printk(KERN_DEBUG
"%s: set auth_alg=%d for "
1594 dev
->name
, ifsta
->auth_alg
);
1601 switch (ifsta
->auth_alg
) {
1602 case WLAN_AUTH_OPEN
:
1603 case WLAN_AUTH_LEAP
:
1604 ieee80211_auth_completed(dev
, ifsta
);
1606 case WLAN_AUTH_SHARED_KEY
:
1607 if (ifsta
->auth_transaction
== 4)
1608 ieee80211_auth_completed(dev
, ifsta
);
1610 ieee80211_auth_challenge(dev
, ifsta
, mgmt
, len
);
1616 static void ieee80211_rx_mgmt_deauth(struct net_device
*dev
,
1617 struct ieee80211_if_sta
*ifsta
,
1618 struct ieee80211_mgmt
*mgmt
,
1622 DECLARE_MAC_BUF(mac
);
1625 printk(KERN_DEBUG
"%s: too short (%zd) deauthentication frame "
1626 "received from %s - ignored\n",
1627 dev
->name
, len
, print_mac(mac
, mgmt
->sa
));
1631 if (memcmp(ifsta
->bssid
, mgmt
->sa
, ETH_ALEN
) != 0) {
1632 printk(KERN_DEBUG
"%s: deauthentication frame received from "
1633 "unknown AP (SA=%s BSSID=%s) - "
1634 "ignored\n", dev
->name
, print_mac(mac
, mgmt
->sa
),
1635 print_mac(mac
, mgmt
->bssid
));
1639 reason_code
= le16_to_cpu(mgmt
->u
.deauth
.reason_code
);
1641 printk(KERN_DEBUG
"%s: RX deauthentication from %s"
1643 dev
->name
, print_mac(mac
, mgmt
->sa
), reason_code
);
1645 if (ifsta
->flags
& IEEE80211_STA_AUTHENTICATED
) {
1646 printk(KERN_DEBUG
"%s: deauthenticated\n", dev
->name
);
1649 if (ifsta
->state
== IEEE80211_AUTHENTICATE
||
1650 ifsta
->state
== IEEE80211_ASSOCIATE
||
1651 ifsta
->state
== IEEE80211_ASSOCIATED
) {
1652 ifsta
->state
= IEEE80211_AUTHENTICATE
;
1653 mod_timer(&ifsta
->timer
, jiffies
+
1654 IEEE80211_RETRY_AUTH_INTERVAL
);
1657 ieee80211_set_disassoc(dev
, ifsta
, 1);
1658 ifsta
->flags
&= ~IEEE80211_STA_AUTHENTICATED
;
1662 static void ieee80211_rx_mgmt_disassoc(struct net_device
*dev
,
1663 struct ieee80211_if_sta
*ifsta
,
1664 struct ieee80211_mgmt
*mgmt
,
1668 DECLARE_MAC_BUF(mac
);
1671 printk(KERN_DEBUG
"%s: too short (%zd) disassociation frame "
1672 "received from %s - ignored\n",
1673 dev
->name
, len
, print_mac(mac
, mgmt
->sa
));
1677 if (memcmp(ifsta
->bssid
, mgmt
->sa
, ETH_ALEN
) != 0) {
1678 printk(KERN_DEBUG
"%s: disassociation frame received from "
1679 "unknown AP (SA=%s BSSID=%s) - "
1680 "ignored\n", dev
->name
, print_mac(mac
, mgmt
->sa
),
1681 print_mac(mac
, mgmt
->bssid
));
1685 reason_code
= le16_to_cpu(mgmt
->u
.disassoc
.reason_code
);
1687 printk(KERN_DEBUG
"%s: RX disassociation from %s"
1689 dev
->name
, print_mac(mac
, mgmt
->sa
), reason_code
);
1691 if (ifsta
->flags
& IEEE80211_STA_ASSOCIATED
)
1692 printk(KERN_DEBUG
"%s: disassociated\n", dev
->name
);
1694 if (ifsta
->state
== IEEE80211_ASSOCIATED
) {
1695 ifsta
->state
= IEEE80211_ASSOCIATE
;
1696 mod_timer(&ifsta
->timer
, jiffies
+
1697 IEEE80211_RETRY_AUTH_INTERVAL
);
1700 ieee80211_set_disassoc(dev
, ifsta
, 0);
1704 static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data
*sdata
,
1705 struct ieee80211_if_sta
*ifsta
,
1706 struct ieee80211_mgmt
*mgmt
,
1710 struct ieee80211_local
*local
= sdata
->local
;
1711 struct net_device
*dev
= sdata
->dev
;
1712 struct ieee80211_hw_mode
*mode
;
1713 struct sta_info
*sta
;
1715 u16 capab_info
, status_code
, aid
;
1716 struct ieee802_11_elems elems
;
1717 struct ieee80211_bss_conf
*bss_conf
= &sdata
->bss_conf
;
1720 DECLARE_MAC_BUF(mac
);
1722 /* AssocResp and ReassocResp have identical structure, so process both
1723 * of them in this function. */
1725 if (ifsta
->state
!= IEEE80211_ASSOCIATE
) {
1726 printk(KERN_DEBUG
"%s: association frame received from "
1727 "%s, but not in associate state - ignored\n",
1728 dev
->name
, print_mac(mac
, mgmt
->sa
));
1733 printk(KERN_DEBUG
"%s: too short (%zd) association frame "
1734 "received from %s - ignored\n",
1735 dev
->name
, len
, print_mac(mac
, mgmt
->sa
));
1739 if (memcmp(ifsta
->bssid
, mgmt
->sa
, ETH_ALEN
) != 0) {
1740 printk(KERN_DEBUG
"%s: association frame received from "
1741 "unknown AP (SA=%s BSSID=%s) - "
1742 "ignored\n", dev
->name
, print_mac(mac
, mgmt
->sa
),
1743 print_mac(mac
, mgmt
->bssid
));
1747 capab_info
= le16_to_cpu(mgmt
->u
.assoc_resp
.capab_info
);
1748 status_code
= le16_to_cpu(mgmt
->u
.assoc_resp
.status_code
);
1749 aid
= le16_to_cpu(mgmt
->u
.assoc_resp
.aid
);
1751 printk(KERN_DEBUG
"%s: RX %sssocResp from %s (capab=0x%x "
1752 "status=%d aid=%d)\n",
1753 dev
->name
, reassoc
? "Rea" : "A", print_mac(mac
, mgmt
->sa
),
1754 capab_info
, status_code
, (u16
)(aid
& ~(BIT(15) | BIT(14))));
1756 if (status_code
!= WLAN_STATUS_SUCCESS
) {
1757 printk(KERN_DEBUG
"%s: AP denied association (code=%d)\n",
1758 dev
->name
, status_code
);
1759 /* if this was a reassociation, ensure we try a "full"
1760 * association next time. This works around some broken APs
1761 * which do not correctly reject reassociation requests. */
1762 ifsta
->flags
&= ~IEEE80211_STA_PREV_BSSID_SET
;
1766 if ((aid
& (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
1767 printk(KERN_DEBUG
"%s: invalid aid value %d; bits 15:14 not "
1768 "set\n", dev
->name
, aid
);
1769 aid
&= ~(BIT(15) | BIT(14));
1771 pos
= mgmt
->u
.assoc_resp
.variable
;
1772 ieee802_11_parse_elems(pos
, len
- (pos
- (u8
*) mgmt
), &elems
);
1774 if (!elems
.supp_rates
) {
1775 printk(KERN_DEBUG
"%s: no SuppRates element in AssocResp\n",
1780 printk(KERN_DEBUG
"%s: associated\n", dev
->name
);
1782 ifsta
->ap_capab
= capab_info
;
1784 kfree(ifsta
->assocresp_ies
);
1785 ifsta
->assocresp_ies_len
= len
- (pos
- (u8
*) mgmt
);
1786 ifsta
->assocresp_ies
= kmalloc(ifsta
->assocresp_ies_len
, GFP_KERNEL
);
1787 if (ifsta
->assocresp_ies
)
1788 memcpy(ifsta
->assocresp_ies
, pos
, ifsta
->assocresp_ies_len
);
1790 /* set AID, ieee80211_set_associated() will tell the driver */
1791 bss_conf
->aid
= aid
;
1792 ieee80211_set_associated(dev
, ifsta
, 1);
1794 /* Add STA entry for the AP */
1795 sta
= sta_info_get(local
, ifsta
->bssid
);
1797 struct ieee80211_sta_bss
*bss
;
1798 sta
= sta_info_add(local
, dev
, ifsta
->bssid
, GFP_KERNEL
);
1800 printk(KERN_DEBUG
"%s: failed to add STA entry for the"
1801 " AP\n", dev
->name
);
1804 bss
= ieee80211_rx_bss_get(dev
, ifsta
->bssid
,
1805 local
->hw
.conf
.channel
,
1806 ifsta
->ssid
, ifsta
->ssid_len
);
1808 sta
->last_rssi
= bss
->rssi
;
1809 sta
->last_signal
= bss
->signal
;
1810 sta
->last_noise
= bss
->noise
;
1811 ieee80211_rx_bss_put(dev
, bss
);
1816 sta
->flags
|= WLAN_STA_AUTH
| WLAN_STA_ASSOC
| WLAN_STA_ASSOC_AP
;
1819 mode
= local
->oper_hw_mode
;
1820 for (i
= 0; i
< elems
.supp_rates_len
; i
++) {
1821 int rate
= (elems
.supp_rates
[i
] & 0x7f) * 5;
1822 for (j
= 0; j
< mode
->num_rates
; j
++)
1823 if (mode
->rates
[j
].rate
== rate
)
1826 for (i
= 0; i
< elems
.ext_supp_rates_len
; i
++) {
1827 int rate
= (elems
.ext_supp_rates
[i
] & 0x7f) * 5;
1828 for (j
= 0; j
< mode
->num_rates
; j
++)
1829 if (mode
->rates
[j
].rate
== rate
)
1832 sta
->supp_rates
= rates
;
1834 if (elems
.ht_cap_elem
&& elems
.ht_info_elem
&& elems
.wmm_param
&&
1835 local
->ops
->conf_ht
) {
1836 struct ieee80211_ht_bss_info bss_info
;
1838 ieee80211_ht_cap_ie_to_ht_info(
1839 (struct ieee80211_ht_cap
*)
1840 elems
.ht_cap_elem
, &sta
->ht_info
);
1841 ieee80211_ht_addt_info_ie_to_ht_bss_info(
1842 (struct ieee80211_ht_addt_info
*)
1843 elems
.ht_info_elem
, &bss_info
);
1844 ieee80211_hw_config_ht(local
, 1, &sta
->ht_info
, &bss_info
);
1847 rate_control_rate_init(sta
, local
);
1849 if (elems
.wmm_param
&& (ifsta
->flags
& IEEE80211_STA_WMM_ENABLED
)) {
1850 sta
->flags
|= WLAN_STA_WME
;
1851 ieee80211_sta_wmm_params(dev
, ifsta
, elems
.wmm_param
,
1852 elems
.wmm_param_len
);
1858 ieee80211_associated(dev
, ifsta
);
1862 /* Caller must hold local->sta_bss_lock */
1863 static void __ieee80211_rx_bss_hash_add(struct net_device
*dev
,
1864 struct ieee80211_sta_bss
*bss
)
1866 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1867 bss
->hnext
= local
->sta_bss_hash
[STA_HASH(bss
->bssid
)];
1868 local
->sta_bss_hash
[STA_HASH(bss
->bssid
)] = bss
;
1872 /* Caller must hold local->sta_bss_lock */
1873 static void __ieee80211_rx_bss_hash_del(struct net_device
*dev
,
1874 struct ieee80211_sta_bss
*bss
)
1876 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1877 struct ieee80211_sta_bss
*b
, *prev
= NULL
;
1878 b
= local
->sta_bss_hash
[STA_HASH(bss
->bssid
)];
1882 local
->sta_bss_hash
[STA_HASH(bss
->bssid
)] =
1885 prev
->hnext
= bss
->hnext
;
1894 static struct ieee80211_sta_bss
*
1895 ieee80211_rx_bss_add(struct net_device
*dev
, u8
*bssid
, int channel
,
1896 u8
*ssid
, u8 ssid_len
)
1898 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1899 struct ieee80211_sta_bss
*bss
;
1901 bss
= kzalloc(sizeof(*bss
), GFP_ATOMIC
);
1904 atomic_inc(&bss
->users
);
1905 atomic_inc(&bss
->users
);
1906 memcpy(bss
->bssid
, bssid
, ETH_ALEN
);
1907 bss
->channel
= channel
;
1908 if (ssid
&& ssid_len
<= IEEE80211_MAX_SSID_LEN
) {
1909 memcpy(bss
->ssid
, ssid
, ssid_len
);
1910 bss
->ssid_len
= ssid_len
;
1913 spin_lock_bh(&local
->sta_bss_lock
);
1914 /* TODO: order by RSSI? */
1915 list_add_tail(&bss
->list
, &local
->sta_bss_list
);
1916 __ieee80211_rx_bss_hash_add(dev
, bss
);
1917 spin_unlock_bh(&local
->sta_bss_lock
);
1922 static struct ieee80211_sta_bss
*
1923 ieee80211_rx_bss_get(struct net_device
*dev
, u8
*bssid
, int channel
,
1924 u8
*ssid
, u8 ssid_len
)
1926 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1927 struct ieee80211_sta_bss
*bss
;
1929 spin_lock_bh(&local
->sta_bss_lock
);
1930 bss
= local
->sta_bss_hash
[STA_HASH(bssid
)];
1932 if (!memcmp(bss
->bssid
, bssid
, ETH_ALEN
) &&
1933 bss
->channel
== channel
&&
1934 bss
->ssid_len
== ssid_len
&&
1935 (ssid_len
== 0 || !memcmp(bss
->ssid
, ssid
, ssid_len
))) {
1936 atomic_inc(&bss
->users
);
1941 spin_unlock_bh(&local
->sta_bss_lock
);
1946 static void ieee80211_rx_bss_free(struct ieee80211_sta_bss
*bss
)
1956 static void ieee80211_rx_bss_put(struct net_device
*dev
,
1957 struct ieee80211_sta_bss
*bss
)
1959 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1960 if (!atomic_dec_and_test(&bss
->users
))
1963 spin_lock_bh(&local
->sta_bss_lock
);
1964 __ieee80211_rx_bss_hash_del(dev
, bss
);
1965 list_del(&bss
->list
);
1966 spin_unlock_bh(&local
->sta_bss_lock
);
1967 ieee80211_rx_bss_free(bss
);
1971 void ieee80211_rx_bss_list_init(struct net_device
*dev
)
1973 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1974 spin_lock_init(&local
->sta_bss_lock
);
1975 INIT_LIST_HEAD(&local
->sta_bss_list
);
1979 void ieee80211_rx_bss_list_deinit(struct net_device
*dev
)
1981 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1982 struct ieee80211_sta_bss
*bss
, *tmp
;
1984 list_for_each_entry_safe(bss
, tmp
, &local
->sta_bss_list
, list
)
1985 ieee80211_rx_bss_put(dev
, bss
);
1989 static void ieee80211_rx_bss_info(struct net_device
*dev
,
1990 struct ieee80211_mgmt
*mgmt
,
1992 struct ieee80211_rx_status
*rx_status
,
1995 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
1996 struct ieee802_11_elems elems
;
1999 struct ieee80211_sta_bss
*bss
;
2000 struct sta_info
*sta
;
2001 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2003 DECLARE_MAC_BUF(mac
);
2004 DECLARE_MAC_BUF(mac2
);
2006 if (!beacon
&& memcmp(mgmt
->da
, dev
->dev_addr
, ETH_ALEN
))
2007 return; /* ignore ProbeResp to foreign address */
2010 printk(KERN_DEBUG
"%s: RX %s from %s to %s\n",
2011 dev
->name
, beacon
? "Beacon" : "Probe Response",
2012 print_mac(mac
, mgmt
->sa
), print_mac(mac2
, mgmt
->da
));
2015 baselen
= (u8
*) mgmt
->u
.beacon
.variable
- (u8
*) mgmt
;
2019 timestamp
= le64_to_cpu(mgmt
->u
.beacon
.timestamp
);
2021 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_IBSS
&& beacon
&&
2022 memcmp(mgmt
->bssid
, sdata
->u
.sta
.bssid
, ETH_ALEN
) == 0) {
2023 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2024 static unsigned long last_tsf_debug
= 0;
2026 if (local
->ops
->get_tsf
)
2027 tsf
= local
->ops
->get_tsf(local_to_hw(local
));
2030 if (time_after(jiffies
, last_tsf_debug
+ 5 * HZ
)) {
2031 printk(KERN_DEBUG
"RX beacon SA=%s BSSID="
2032 "%s TSF=0x%llx BCN=0x%llx diff=%lld "
2034 print_mac(mac
, mgmt
->sa
), print_mac(mac2
, mgmt
->bssid
),
2035 (unsigned long long)tsf
,
2036 (unsigned long long)timestamp
,
2037 (unsigned long long)(tsf
- timestamp
),
2039 last_tsf_debug
= jiffies
;
2041 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
2044 ieee802_11_parse_elems(mgmt
->u
.beacon
.variable
, len
- baselen
, &elems
);
2046 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_IBSS
&& elems
.supp_rates
&&
2047 memcmp(mgmt
->bssid
, sdata
->u
.sta
.bssid
, ETH_ALEN
) == 0 &&
2048 (sta
= sta_info_get(local
, mgmt
->sa
))) {
2049 struct ieee80211_hw_mode
*mode
;
2050 struct ieee80211_rate
*rates
;
2052 u32 supp_rates
, prev_rates
;
2055 mode
= local
->sta_sw_scanning
?
2056 local
->scan_hw_mode
: local
->oper_hw_mode
;
2058 if (local
->sta_hw_scanning
) {
2059 /* search for the correct mode matches the beacon */
2060 list_for_each_entry(mode
, &local
->modes_list
, list
)
2061 if (mode
->mode
== rx_status
->phymode
)
2065 mode
= local
->oper_hw_mode
;
2067 rates
= mode
->rates
;
2068 num_rates
= mode
->num_rates
;
2071 for (i
= 0; i
< elems
.supp_rates_len
+
2072 elems
.ext_supp_rates_len
; i
++) {
2075 if (i
< elems
.supp_rates_len
)
2076 rate
= elems
.supp_rates
[i
];
2077 else if (elems
.ext_supp_rates
)
2078 rate
= elems
.ext_supp_rates
2079 [i
- elems
.supp_rates_len
];
2080 own_rate
= 5 * (rate
& 0x7f);
2081 for (j
= 0; j
< num_rates
; j
++)
2082 if (rates
[j
].rate
== own_rate
)
2083 supp_rates
|= BIT(j
);
2086 prev_rates
= sta
->supp_rates
;
2087 sta
->supp_rates
&= supp_rates
;
2088 if (sta
->supp_rates
== 0) {
2089 /* No matching rates - this should not really happen.
2090 * Make sure that at least one rate is marked
2091 * supported to avoid issues with TX rate ctrl. */
2092 sta
->supp_rates
= sdata
->u
.sta
.supp_rates_bits
;
2094 if (sta
->supp_rates
!= prev_rates
) {
2095 printk(KERN_DEBUG
"%s: updated supp_rates set for "
2096 "%s based on beacon info (0x%x & 0x%x -> "
2098 dev
->name
, print_mac(mac
, sta
->addr
), prev_rates
,
2099 supp_rates
, sta
->supp_rates
);
2107 if (elems
.ds_params
&& elems
.ds_params_len
== 1)
2108 channel
= elems
.ds_params
[0];
2110 channel
= rx_status
->channel
;
2112 bss
= ieee80211_rx_bss_get(dev
, mgmt
->bssid
, channel
,
2113 elems
.ssid
, elems
.ssid_len
);
2115 bss
= ieee80211_rx_bss_add(dev
, mgmt
->bssid
, channel
,
2116 elems
.ssid
, elems
.ssid_len
);
2121 /* TODO: order by RSSI? */
2122 spin_lock_bh(&local
->sta_bss_lock
);
2123 list_move_tail(&bss
->list
, &local
->sta_bss_list
);
2124 spin_unlock_bh(&local
->sta_bss_lock
);
2128 if (bss
->probe_resp
&& beacon
) {
2129 /* Do not allow beacon to override data from Probe Response. */
2130 ieee80211_rx_bss_put(dev
, bss
);
2134 /* save the ERP value so that it is available at association time */
2135 if (elems
.erp_info
&& elems
.erp_info_len
>= 1) {
2136 bss
->erp_value
= elems
.erp_info
[0];
2137 bss
->has_erp_value
= 1;
2140 bss
->beacon_int
= le16_to_cpu(mgmt
->u
.beacon
.beacon_int
);
2141 bss
->capability
= le16_to_cpu(mgmt
->u
.beacon
.capab_info
);
2143 bss
->supp_rates_len
= 0;
2144 if (elems
.supp_rates
) {
2145 clen
= IEEE80211_MAX_SUPP_RATES
- bss
->supp_rates_len
;
2146 if (clen
> elems
.supp_rates_len
)
2147 clen
= elems
.supp_rates_len
;
2148 memcpy(&bss
->supp_rates
[bss
->supp_rates_len
], elems
.supp_rates
,
2150 bss
->supp_rates_len
+= clen
;
2152 if (elems
.ext_supp_rates
) {
2153 clen
= IEEE80211_MAX_SUPP_RATES
- bss
->supp_rates_len
;
2154 if (clen
> elems
.ext_supp_rates_len
)
2155 clen
= elems
.ext_supp_rates_len
;
2156 memcpy(&bss
->supp_rates
[bss
->supp_rates_len
],
2157 elems
.ext_supp_rates
, clen
);
2158 bss
->supp_rates_len
+= clen
;
2162 (!bss
->wpa_ie
|| bss
->wpa_ie_len
!= elems
.wpa_len
||
2163 memcmp(bss
->wpa_ie
, elems
.wpa
, elems
.wpa_len
))) {
2165 bss
->wpa_ie
= kmalloc(elems
.wpa_len
+ 2, GFP_ATOMIC
);
2167 memcpy(bss
->wpa_ie
, elems
.wpa
- 2, elems
.wpa_len
+ 2);
2168 bss
->wpa_ie_len
= elems
.wpa_len
+ 2;
2170 bss
->wpa_ie_len
= 0;
2171 } else if (!elems
.wpa
&& bss
->wpa_ie
) {
2174 bss
->wpa_ie_len
= 0;
2178 (!bss
->rsn_ie
|| bss
->rsn_ie_len
!= elems
.rsn_len
||
2179 memcmp(bss
->rsn_ie
, elems
.rsn
, elems
.rsn_len
))) {
2181 bss
->rsn_ie
= kmalloc(elems
.rsn_len
+ 2, GFP_ATOMIC
);
2183 memcpy(bss
->rsn_ie
, elems
.rsn
- 2, elems
.rsn_len
+ 2);
2184 bss
->rsn_ie_len
= elems
.rsn_len
+ 2;
2186 bss
->rsn_ie_len
= 0;
2187 } else if (!elems
.rsn
&& bss
->rsn_ie
) {
2190 bss
->rsn_ie_len
= 0;
2193 if (elems
.wmm_param
&&
2194 (!bss
->wmm_ie
|| bss
->wmm_ie_len
!= elems
.wmm_param_len
||
2195 memcmp(bss
->wmm_ie
, elems
.wmm_param
, elems
.wmm_param_len
))) {
2197 bss
->wmm_ie
= kmalloc(elems
.wmm_param_len
+ 2, GFP_ATOMIC
);
2199 memcpy(bss
->wmm_ie
, elems
.wmm_param
- 2,
2200 elems
.wmm_param_len
+ 2);
2201 bss
->wmm_ie_len
= elems
.wmm_param_len
+ 2;
2203 bss
->wmm_ie_len
= 0;
2204 } else if (!elems
.wmm_param
&& bss
->wmm_ie
) {
2207 bss
->wmm_ie_len
= 0;
2209 if (elems
.ht_cap_elem
&&
2210 (!bss
->ht_ie
|| bss
->ht_ie_len
!= elems
.ht_cap_elem_len
||
2211 memcmp(bss
->ht_ie
, elems
.ht_cap_elem
, elems
.ht_cap_elem_len
))) {
2213 bss
->ht_ie
= kmalloc(elems
.ht_cap_elem_len
+ 2, GFP_ATOMIC
);
2215 memcpy(bss
->ht_ie
, elems
.ht_cap_elem
- 2,
2216 elems
.ht_cap_elem_len
+ 2);
2217 bss
->ht_ie_len
= elems
.ht_cap_elem_len
+ 2;
2220 } else if (!elems
.ht_cap_elem
&& bss
->ht_ie
) {
2226 bss
->hw_mode
= rx_status
->phymode
;
2227 bss
->freq
= rx_status
->freq
;
2228 if (channel
!= rx_status
->channel
&&
2229 (bss
->hw_mode
== MODE_IEEE80211G
||
2230 bss
->hw_mode
== MODE_IEEE80211B
) &&
2231 channel
>= 1 && channel
<= 14) {
2232 static const int freq_list
[] = {
2233 2412, 2417, 2422, 2427, 2432, 2437, 2442,
2234 2447, 2452, 2457, 2462, 2467, 2472, 2484
2236 /* IEEE 802.11g/b mode can receive packets from neighboring
2237 * channels, so map the channel into frequency. */
2238 bss
->freq
= freq_list
[channel
- 1];
2240 bss
->timestamp
= timestamp
;
2241 bss
->last_update
= jiffies
;
2242 bss
->rssi
= rx_status
->ssi
;
2243 bss
->signal
= rx_status
->signal
;
2244 bss
->noise
= rx_status
->noise
;
2247 ieee80211_rx_bss_put(dev
, bss
);
2251 static void ieee80211_rx_mgmt_probe_resp(struct net_device
*dev
,
2252 struct ieee80211_mgmt
*mgmt
,
2254 struct ieee80211_rx_status
*rx_status
)
2256 ieee80211_rx_bss_info(dev
, mgmt
, len
, rx_status
, 0);
2260 static void ieee80211_rx_mgmt_beacon(struct net_device
*dev
,
2261 struct ieee80211_mgmt
*mgmt
,
2263 struct ieee80211_rx_status
*rx_status
)
2265 struct ieee80211_sub_if_data
*sdata
;
2266 struct ieee80211_if_sta
*ifsta
;
2268 struct ieee802_11_elems elems
;
2269 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2270 struct ieee80211_conf
*conf
= &local
->hw
.conf
;
2273 ieee80211_rx_bss_info(dev
, mgmt
, len
, rx_status
, 1);
2275 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2276 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_STA
)
2278 ifsta
= &sdata
->u
.sta
;
2280 if (!(ifsta
->flags
& IEEE80211_STA_ASSOCIATED
) ||
2281 memcmp(ifsta
->bssid
, mgmt
->bssid
, ETH_ALEN
) != 0)
2284 /* Process beacon from the current BSS */
2285 baselen
= (u8
*) mgmt
->u
.beacon
.variable
- (u8
*) mgmt
;
2289 ieee802_11_parse_elems(mgmt
->u
.beacon
.variable
, len
- baselen
, &elems
);
2291 if (elems
.erp_info
&& elems
.erp_info_len
>= 1)
2292 changed
|= ieee80211_handle_erp_ie(sdata
, elems
.erp_info
[0]);
2294 if (elems
.ht_cap_elem
&& elems
.ht_info_elem
&&
2295 elems
.wmm_param
&& local
->ops
->conf_ht
&&
2296 conf
->flags
& IEEE80211_CONF_SUPPORT_HT_MODE
) {
2297 struct ieee80211_ht_bss_info bss_info
;
2299 ieee80211_ht_addt_info_ie_to_ht_bss_info(
2300 (struct ieee80211_ht_addt_info
*)
2301 elems
.ht_info_elem
, &bss_info
);
2302 /* check if AP changed bss inforamation */
2303 if ((conf
->ht_bss_conf
.primary_channel
!=
2304 bss_info
.primary_channel
) ||
2305 (conf
->ht_bss_conf
.bss_cap
!= bss_info
.bss_cap
) ||
2306 (conf
->ht_bss_conf
.bss_op_mode
!= bss_info
.bss_op_mode
))
2307 ieee80211_hw_config_ht(local
, 1, &conf
->ht_conf
,
2311 if (elems
.wmm_param
&& (ifsta
->flags
& IEEE80211_STA_WMM_ENABLED
)) {
2312 ieee80211_sta_wmm_params(dev
, ifsta
, elems
.wmm_param
,
2313 elems
.wmm_param_len
);
2316 ieee80211_bss_info_change_notify(sdata
, changed
);
2320 static void ieee80211_rx_mgmt_probe_req(struct net_device
*dev
,
2321 struct ieee80211_if_sta
*ifsta
,
2322 struct ieee80211_mgmt
*mgmt
,
2324 struct ieee80211_rx_status
*rx_status
)
2326 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2327 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2329 struct sk_buff
*skb
;
2330 struct ieee80211_mgmt
*resp
;
2332 DECLARE_MAC_BUF(mac
);
2333 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2334 DECLARE_MAC_BUF(mac2
);
2335 DECLARE_MAC_BUF(mac3
);
2338 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_IBSS
||
2339 ifsta
->state
!= IEEE80211_IBSS_JOINED
||
2340 len
< 24 + 2 || !ifsta
->probe_resp
)
2343 if (local
->ops
->tx_last_beacon
)
2344 tx_last_beacon
= local
->ops
->tx_last_beacon(local_to_hw(local
));
2348 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2349 printk(KERN_DEBUG
"%s: RX ProbeReq SA=%s DA=%s BSSID="
2350 "%s (tx_last_beacon=%d)\n",
2351 dev
->name
, print_mac(mac
, mgmt
->sa
), print_mac(mac2
, mgmt
->da
),
2352 print_mac(mac3
, mgmt
->bssid
), tx_last_beacon
);
2353 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
2355 if (!tx_last_beacon
)
2358 if (memcmp(mgmt
->bssid
, ifsta
->bssid
, ETH_ALEN
) != 0 &&
2359 memcmp(mgmt
->bssid
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) != 0)
2362 end
= ((u8
*) mgmt
) + len
;
2363 pos
= mgmt
->u
.probe_req
.variable
;
2364 if (pos
[0] != WLAN_EID_SSID
||
2365 pos
+ 2 + pos
[1] > end
) {
2366 if (net_ratelimit()) {
2367 printk(KERN_DEBUG
"%s: Invalid SSID IE in ProbeReq "
2369 dev
->name
, print_mac(mac
, mgmt
->sa
));
2374 (pos
[1] != ifsta
->ssid_len
||
2375 memcmp(pos
+ 2, ifsta
->ssid
, ifsta
->ssid_len
) != 0)) {
2376 /* Ignore ProbeReq for foreign SSID */
2380 /* Reply with ProbeResp */
2381 skb
= skb_copy(ifsta
->probe_resp
, GFP_KERNEL
);
2385 resp
= (struct ieee80211_mgmt
*) skb
->data
;
2386 memcpy(resp
->da
, mgmt
->sa
, ETH_ALEN
);
2387 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2388 printk(KERN_DEBUG
"%s: Sending ProbeResp to %s\n",
2389 dev
->name
, print_mac(mac
, resp
->da
));
2390 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
2391 ieee80211_sta_tx(dev
, skb
, 0);
2394 static void ieee80211_rx_mgmt_action(struct net_device
*dev
,
2395 struct ieee80211_if_sta
*ifsta
,
2396 struct ieee80211_mgmt
*mgmt
,
2399 if (len
< IEEE80211_MIN_ACTION_SIZE
)
2402 switch (mgmt
->u
.action
.category
) {
2403 case WLAN_CATEGORY_BACK
:
2404 switch (mgmt
->u
.action
.u
.addba_req
.action_code
) {
2405 case WLAN_ACTION_ADDBA_REQ
:
2406 if (len
< (IEEE80211_MIN_ACTION_SIZE
+
2407 sizeof(mgmt
->u
.action
.u
.addba_req
)))
2409 ieee80211_sta_process_addba_request(dev
, mgmt
, len
);
2411 case WLAN_ACTION_ADDBA_RESP
:
2412 if (len
< (IEEE80211_MIN_ACTION_SIZE
+
2413 sizeof(mgmt
->u
.action
.u
.addba_resp
)))
2415 ieee80211_sta_process_addba_resp(dev
, mgmt
, len
);
2417 case WLAN_ACTION_DELBA
:
2418 if (len
< (IEEE80211_MIN_ACTION_SIZE
+
2419 sizeof(mgmt
->u
.action
.u
.delba
)))
2421 ieee80211_sta_process_delba(dev
, mgmt
, len
);
2424 if (net_ratelimit())
2425 printk(KERN_DEBUG
"%s: Rx unknown A-MPDU action\n",
2435 void ieee80211_sta_rx_mgmt(struct net_device
*dev
, struct sk_buff
*skb
,
2436 struct ieee80211_rx_status
*rx_status
)
2438 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2439 struct ieee80211_sub_if_data
*sdata
;
2440 struct ieee80211_if_sta
*ifsta
;
2441 struct ieee80211_mgmt
*mgmt
;
2447 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2448 ifsta
= &sdata
->u
.sta
;
2450 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
2451 fc
= le16_to_cpu(mgmt
->frame_control
);
2453 switch (fc
& IEEE80211_FCTL_STYPE
) {
2454 case IEEE80211_STYPE_PROBE_REQ
:
2455 case IEEE80211_STYPE_PROBE_RESP
:
2456 case IEEE80211_STYPE_BEACON
:
2457 memcpy(skb
->cb
, rx_status
, sizeof(*rx_status
));
2458 case IEEE80211_STYPE_AUTH
:
2459 case IEEE80211_STYPE_ASSOC_RESP
:
2460 case IEEE80211_STYPE_REASSOC_RESP
:
2461 case IEEE80211_STYPE_DEAUTH
:
2462 case IEEE80211_STYPE_DISASSOC
:
2463 case IEEE80211_STYPE_ACTION
:
2464 skb_queue_tail(&ifsta
->skb_queue
, skb
);
2465 queue_work(local
->hw
.workqueue
, &ifsta
->work
);
2468 printk(KERN_DEBUG
"%s: received unknown management frame - "
2469 "stype=%d\n", dev
->name
,
2470 (fc
& IEEE80211_FCTL_STYPE
) >> 4);
2479 static void ieee80211_sta_rx_queued_mgmt(struct net_device
*dev
,
2480 struct sk_buff
*skb
)
2482 struct ieee80211_rx_status
*rx_status
;
2483 struct ieee80211_sub_if_data
*sdata
;
2484 struct ieee80211_if_sta
*ifsta
;
2485 struct ieee80211_mgmt
*mgmt
;
2488 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2489 ifsta
= &sdata
->u
.sta
;
2491 rx_status
= (struct ieee80211_rx_status
*) skb
->cb
;
2492 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
2493 fc
= le16_to_cpu(mgmt
->frame_control
);
2495 switch (fc
& IEEE80211_FCTL_STYPE
) {
2496 case IEEE80211_STYPE_PROBE_REQ
:
2497 ieee80211_rx_mgmt_probe_req(dev
, ifsta
, mgmt
, skb
->len
,
2500 case IEEE80211_STYPE_PROBE_RESP
:
2501 ieee80211_rx_mgmt_probe_resp(dev
, mgmt
, skb
->len
, rx_status
);
2503 case IEEE80211_STYPE_BEACON
:
2504 ieee80211_rx_mgmt_beacon(dev
, mgmt
, skb
->len
, rx_status
);
2506 case IEEE80211_STYPE_AUTH
:
2507 ieee80211_rx_mgmt_auth(dev
, ifsta
, mgmt
, skb
->len
);
2509 case IEEE80211_STYPE_ASSOC_RESP
:
2510 ieee80211_rx_mgmt_assoc_resp(sdata
, ifsta
, mgmt
, skb
->len
, 0);
2512 case IEEE80211_STYPE_REASSOC_RESP
:
2513 ieee80211_rx_mgmt_assoc_resp(sdata
, ifsta
, mgmt
, skb
->len
, 1);
2515 case IEEE80211_STYPE_DEAUTH
:
2516 ieee80211_rx_mgmt_deauth(dev
, ifsta
, mgmt
, skb
->len
);
2518 case IEEE80211_STYPE_DISASSOC
:
2519 ieee80211_rx_mgmt_disassoc(dev
, ifsta
, mgmt
, skb
->len
);
2521 case IEEE80211_STYPE_ACTION
:
2522 ieee80211_rx_mgmt_action(dev
, ifsta
, mgmt
, skb
->len
);
2530 ieee80211_txrx_result
2531 ieee80211_sta_rx_scan(struct net_device
*dev
, struct sk_buff
*skb
,
2532 struct ieee80211_rx_status
*rx_status
)
2534 struct ieee80211_mgmt
*mgmt
;
2540 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
2541 fc
= le16_to_cpu(mgmt
->frame_control
);
2543 if ((fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_CTL
)
2544 return TXRX_CONTINUE
;
2549 if ((fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_MGMT
) {
2550 if ((fc
& IEEE80211_FCTL_STYPE
) == IEEE80211_STYPE_PROBE_RESP
) {
2551 ieee80211_rx_mgmt_probe_resp(dev
, mgmt
,
2552 skb
->len
, rx_status
);
2555 } else if ((fc
& IEEE80211_FCTL_STYPE
) == IEEE80211_STYPE_BEACON
) {
2556 ieee80211_rx_mgmt_beacon(dev
, mgmt
, skb
->len
,
2562 return TXRX_CONTINUE
;
2566 static int ieee80211_sta_active_ibss(struct net_device
*dev
)
2568 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2570 struct sta_info
*sta
;
2572 read_lock_bh(&local
->sta_lock
);
2573 list_for_each_entry(sta
, &local
->sta_list
, list
) {
2574 if (sta
->dev
== dev
&&
2575 time_after(sta
->last_rx
+ IEEE80211_IBSS_MERGE_INTERVAL
,
2581 read_unlock_bh(&local
->sta_lock
);
2587 static void ieee80211_sta_expire(struct net_device
*dev
)
2589 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2590 struct sta_info
*sta
, *tmp
;
2591 LIST_HEAD(tmp_list
);
2592 DECLARE_MAC_BUF(mac
);
2594 write_lock_bh(&local
->sta_lock
);
2595 list_for_each_entry_safe(sta
, tmp
, &local
->sta_list
, list
)
2596 if (time_after(jiffies
, sta
->last_rx
+
2597 IEEE80211_IBSS_INACTIVITY_LIMIT
)) {
2598 printk(KERN_DEBUG
"%s: expiring inactive STA %s\n",
2599 dev
->name
, print_mac(mac
, sta
->addr
));
2600 __sta_info_get(sta
);
2601 sta_info_remove(sta
);
2602 list_add(&sta
->list
, &tmp_list
);
2604 write_unlock_bh(&local
->sta_lock
);
2606 list_for_each_entry_safe(sta
, tmp
, &tmp_list
, list
) {
2613 static void ieee80211_sta_merge_ibss(struct net_device
*dev
,
2614 struct ieee80211_if_sta
*ifsta
)
2616 mod_timer(&ifsta
->timer
, jiffies
+ IEEE80211_IBSS_MERGE_INTERVAL
);
2618 ieee80211_sta_expire(dev
);
2619 if (ieee80211_sta_active_ibss(dev
))
2622 printk(KERN_DEBUG
"%s: No active IBSS STAs - trying to scan for other "
2623 "IBSS networks with same SSID (merge)\n", dev
->name
);
2624 ieee80211_sta_req_scan(dev
, ifsta
->ssid
, ifsta
->ssid_len
);
2628 void ieee80211_sta_timer(unsigned long data
)
2630 struct ieee80211_sub_if_data
*sdata
=
2631 (struct ieee80211_sub_if_data
*) data
;
2632 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
2633 struct ieee80211_local
*local
= wdev_priv(&sdata
->wdev
);
2635 set_bit(IEEE80211_STA_REQ_RUN
, &ifsta
->request
);
2636 queue_work(local
->hw
.workqueue
, &ifsta
->work
);
2640 void ieee80211_sta_work(struct work_struct
*work
)
2642 struct ieee80211_sub_if_data
*sdata
=
2643 container_of(work
, struct ieee80211_sub_if_data
, u
.sta
.work
);
2644 struct net_device
*dev
= sdata
->dev
;
2645 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2646 struct ieee80211_if_sta
*ifsta
;
2647 struct sk_buff
*skb
;
2649 if (!netif_running(dev
))
2652 if (local
->sta_sw_scanning
|| local
->sta_hw_scanning
)
2655 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_STA
&&
2656 sdata
->vif
.type
!= IEEE80211_IF_TYPE_IBSS
) {
2657 printk(KERN_DEBUG
"%s: ieee80211_sta_work: non-STA interface "
2658 "(type=%d)\n", dev
->name
, sdata
->vif
.type
);
2661 ifsta
= &sdata
->u
.sta
;
2663 while ((skb
= skb_dequeue(&ifsta
->skb_queue
)))
2664 ieee80211_sta_rx_queued_mgmt(dev
, skb
);
2666 if (ifsta
->state
!= IEEE80211_AUTHENTICATE
&&
2667 ifsta
->state
!= IEEE80211_ASSOCIATE
&&
2668 test_and_clear_bit(IEEE80211_STA_REQ_SCAN
, &ifsta
->request
)) {
2669 if (ifsta
->scan_ssid_len
)
2670 ieee80211_sta_start_scan(dev
, ifsta
->scan_ssid
, ifsta
->scan_ssid_len
);
2672 ieee80211_sta_start_scan(dev
, NULL
, 0);
2676 if (test_and_clear_bit(IEEE80211_STA_REQ_AUTH
, &ifsta
->request
)) {
2677 if (ieee80211_sta_config_auth(dev
, ifsta
))
2679 clear_bit(IEEE80211_STA_REQ_RUN
, &ifsta
->request
);
2680 } else if (!test_and_clear_bit(IEEE80211_STA_REQ_RUN
, &ifsta
->request
))
2683 switch (ifsta
->state
) {
2684 case IEEE80211_DISABLED
:
2686 case IEEE80211_AUTHENTICATE
:
2687 ieee80211_authenticate(dev
, ifsta
);
2689 case IEEE80211_ASSOCIATE
:
2690 ieee80211_associate(dev
, ifsta
);
2692 case IEEE80211_ASSOCIATED
:
2693 ieee80211_associated(dev
, ifsta
);
2695 case IEEE80211_IBSS_SEARCH
:
2696 ieee80211_sta_find_ibss(dev
, ifsta
);
2698 case IEEE80211_IBSS_JOINED
:
2699 ieee80211_sta_merge_ibss(dev
, ifsta
);
2702 printk(KERN_DEBUG
"ieee80211_sta_work: Unknown state %d\n",
2707 if (ieee80211_privacy_mismatch(dev
, ifsta
)) {
2708 printk(KERN_DEBUG
"%s: privacy configuration mismatch and "
2709 "mixed-cell disabled - disassociate\n", dev
->name
);
2711 ieee80211_send_disassoc(dev
, ifsta
, WLAN_REASON_UNSPECIFIED
);
2712 ieee80211_set_disassoc(dev
, ifsta
, 0);
2717 static void ieee80211_sta_reset_auth(struct net_device
*dev
,
2718 struct ieee80211_if_sta
*ifsta
)
2720 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2722 if (local
->ops
->reset_tsf
) {
2723 /* Reset own TSF to allow time synchronization work. */
2724 local
->ops
->reset_tsf(local_to_hw(local
));
2727 ifsta
->wmm_last_param_set
= -1; /* allow any WMM update */
2730 if (ifsta
->auth_algs
& IEEE80211_AUTH_ALG_OPEN
)
2731 ifsta
->auth_alg
= WLAN_AUTH_OPEN
;
2732 else if (ifsta
->auth_algs
& IEEE80211_AUTH_ALG_SHARED_KEY
)
2733 ifsta
->auth_alg
= WLAN_AUTH_SHARED_KEY
;
2734 else if (ifsta
->auth_algs
& IEEE80211_AUTH_ALG_LEAP
)
2735 ifsta
->auth_alg
= WLAN_AUTH_LEAP
;
2737 ifsta
->auth_alg
= WLAN_AUTH_OPEN
;
2738 printk(KERN_DEBUG
"%s: Initial auth_alg=%d\n", dev
->name
,
2740 ifsta
->auth_transaction
= -1;
2741 ifsta
->flags
&= ~IEEE80211_STA_ASSOCIATED
;
2742 ifsta
->auth_tries
= ifsta
->assoc_tries
= 0;
2743 netif_carrier_off(dev
);
2747 void ieee80211_sta_req_auth(struct net_device
*dev
,
2748 struct ieee80211_if_sta
*ifsta
)
2750 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2751 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2753 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_STA
)
2756 if ((ifsta
->flags
& (IEEE80211_STA_BSSID_SET
|
2757 IEEE80211_STA_AUTO_BSSID_SEL
)) &&
2758 (ifsta
->flags
& (IEEE80211_STA_SSID_SET
|
2759 IEEE80211_STA_AUTO_SSID_SEL
))) {
2760 set_bit(IEEE80211_STA_REQ_AUTH
, &ifsta
->request
);
2761 queue_work(local
->hw
.workqueue
, &ifsta
->work
);
2765 static int ieee80211_sta_match_ssid(struct ieee80211_if_sta
*ifsta
,
2766 const char *ssid
, int ssid_len
)
2768 int tmp
, hidden_ssid
;
2770 if (ssid_len
== ifsta
->ssid_len
&&
2771 !memcmp(ifsta
->ssid
, ssid
, ssid_len
))
2774 if (ifsta
->flags
& IEEE80211_STA_AUTO_BSSID_SEL
)
2780 if (ssid
[tmp
] != '\0') {
2786 if (hidden_ssid
&& ifsta
->ssid_len
== ssid_len
)
2789 if (ssid_len
== 1 && ssid
[0] == ' ')
2795 static int ieee80211_sta_config_auth(struct net_device
*dev
,
2796 struct ieee80211_if_sta
*ifsta
)
2798 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2799 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2800 struct ieee80211_sta_bss
*bss
, *selected
= NULL
;
2801 int top_rssi
= 0, freq
;
2803 if (!(ifsta
->flags
& (IEEE80211_STA_AUTO_SSID_SEL
|
2804 IEEE80211_STA_AUTO_BSSID_SEL
| IEEE80211_STA_AUTO_CHANNEL_SEL
))) {
2805 ifsta
->state
= IEEE80211_AUTHENTICATE
;
2806 ieee80211_sta_reset_auth(dev
, ifsta
);
2810 spin_lock_bh(&local
->sta_bss_lock
);
2811 freq
= local
->oper_channel
->freq
;
2812 list_for_each_entry(bss
, &local
->sta_bss_list
, list
) {
2813 if (!(bss
->capability
& WLAN_CAPABILITY_ESS
))
2816 if (!!(bss
->capability
& WLAN_CAPABILITY_PRIVACY
) ^
2817 !!sdata
->default_key
)
2820 if (!(ifsta
->flags
& IEEE80211_STA_AUTO_CHANNEL_SEL
) &&
2824 if (!(ifsta
->flags
& IEEE80211_STA_AUTO_BSSID_SEL
) &&
2825 memcmp(bss
->bssid
, ifsta
->bssid
, ETH_ALEN
))
2828 if (!(ifsta
->flags
& IEEE80211_STA_AUTO_SSID_SEL
) &&
2829 !ieee80211_sta_match_ssid(ifsta
, bss
->ssid
, bss
->ssid_len
))
2832 if (!selected
|| top_rssi
< bss
->rssi
) {
2834 top_rssi
= bss
->rssi
;
2838 atomic_inc(&selected
->users
);
2839 spin_unlock_bh(&local
->sta_bss_lock
);
2842 ieee80211_set_channel(local
, -1, selected
->freq
);
2843 if (!(ifsta
->flags
& IEEE80211_STA_SSID_SET
))
2844 ieee80211_sta_set_ssid(dev
, selected
->ssid
,
2845 selected
->ssid_len
);
2846 ieee80211_sta_set_bssid(dev
, selected
->bssid
);
2847 ieee80211_rx_bss_put(dev
, selected
);
2848 ifsta
->state
= IEEE80211_AUTHENTICATE
;
2849 ieee80211_sta_reset_auth(dev
, ifsta
);
2852 if (ifsta
->state
!= IEEE80211_AUTHENTICATE
) {
2853 if (ifsta
->flags
& IEEE80211_STA_AUTO_SSID_SEL
)
2854 ieee80211_sta_start_scan(dev
, NULL
, 0);
2856 ieee80211_sta_start_scan(dev
, ifsta
->ssid
,
2858 ifsta
->state
= IEEE80211_AUTHENTICATE
;
2859 set_bit(IEEE80211_STA_REQ_AUTH
, &ifsta
->request
);
2861 ifsta
->state
= IEEE80211_DISABLED
;
2866 static int ieee80211_sta_join_ibss(struct net_device
*dev
,
2867 struct ieee80211_if_sta
*ifsta
,
2868 struct ieee80211_sta_bss
*bss
)
2870 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
2871 int res
, rates
, i
, j
;
2872 struct sk_buff
*skb
;
2873 struct ieee80211_mgmt
*mgmt
;
2874 struct ieee80211_tx_control control
;
2875 struct ieee80211_hw_mode
*mode
;
2876 struct rate_selection ratesel
;
2878 struct ieee80211_sub_if_data
*sdata
;
2880 /* Remove possible STA entries from other IBSS networks. */
2881 sta_info_flush(local
, NULL
);
2883 if (local
->ops
->reset_tsf
) {
2884 /* Reset own TSF to allow time synchronization work. */
2885 local
->ops
->reset_tsf(local_to_hw(local
));
2887 memcpy(ifsta
->bssid
, bss
->bssid
, ETH_ALEN
);
2888 res
= ieee80211_if_config(dev
);
2892 local
->hw
.conf
.beacon_int
= bss
->beacon_int
>= 10 ? bss
->beacon_int
: 10;
2894 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
2895 sdata
->drop_unencrypted
= bss
->capability
&
2896 WLAN_CAPABILITY_PRIVACY
? 1 : 0;
2898 res
= ieee80211_set_channel(local
, -1, bss
->freq
);
2900 if (!(local
->oper_channel
->flag
& IEEE80211_CHAN_W_IBSS
)) {
2901 printk(KERN_DEBUG
"%s: IBSS not allowed on channel %d "
2902 "(%d MHz)\n", dev
->name
, local
->hw
.conf
.channel
,
2903 local
->hw
.conf
.freq
);
2907 /* Set beacon template based on scan results */
2908 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ 400);
2913 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
2915 mgmt
= (struct ieee80211_mgmt
*)
2916 skb_put(skb
, 24 + sizeof(mgmt
->u
.beacon
));
2917 memset(mgmt
, 0, 24 + sizeof(mgmt
->u
.beacon
));
2918 mgmt
->frame_control
= IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
2919 IEEE80211_STYPE_BEACON
);
2920 memset(mgmt
->da
, 0xff, ETH_ALEN
);
2921 memcpy(mgmt
->sa
, dev
->dev_addr
, ETH_ALEN
);
2922 memcpy(mgmt
->bssid
, ifsta
->bssid
, ETH_ALEN
);
2923 mgmt
->u
.beacon
.beacon_int
=
2924 cpu_to_le16(local
->hw
.conf
.beacon_int
);
2925 mgmt
->u
.beacon
.capab_info
= cpu_to_le16(bss
->capability
);
2927 pos
= skb_put(skb
, 2 + ifsta
->ssid_len
);
2928 *pos
++ = WLAN_EID_SSID
;
2929 *pos
++ = ifsta
->ssid_len
;
2930 memcpy(pos
, ifsta
->ssid
, ifsta
->ssid_len
);
2932 rates
= bss
->supp_rates_len
;
2935 pos
= skb_put(skb
, 2 + rates
);
2936 *pos
++ = WLAN_EID_SUPP_RATES
;
2938 memcpy(pos
, bss
->supp_rates
, rates
);
2940 pos
= skb_put(skb
, 2 + 1);
2941 *pos
++ = WLAN_EID_DS_PARAMS
;
2943 *pos
++ = bss
->channel
;
2945 pos
= skb_put(skb
, 2 + 2);
2946 *pos
++ = WLAN_EID_IBSS_PARAMS
;
2948 /* FIX: set ATIM window based on scan results */
2952 if (bss
->supp_rates_len
> 8) {
2953 rates
= bss
->supp_rates_len
- 8;
2954 pos
= skb_put(skb
, 2 + rates
);
2955 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
2957 memcpy(pos
, &bss
->supp_rates
[8], rates
);
2960 memset(&control
, 0, sizeof(control
));
2961 rate_control_get_rate(dev
, local
->oper_hw_mode
, skb
, &ratesel
);
2962 if (!ratesel
.rate
) {
2963 printk(KERN_DEBUG
"%s: Failed to determine TX rate "
2964 "for IBSS beacon\n", dev
->name
);
2967 control
.vif
= &sdata
->vif
;
2969 (sdata
->bss_conf
.use_short_preamble
&&
2970 (ratesel
.rate
->flags
& IEEE80211_RATE_PREAMBLE2
)) ?
2971 ratesel
.rate
->val2
: ratesel
.rate
->val
;
2972 control
.antenna_sel_tx
= local
->hw
.conf
.antenna_sel_tx
;
2973 control
.power_level
= local
->hw
.conf
.power_level
;
2974 control
.flags
|= IEEE80211_TXCTL_NO_ACK
;
2975 control
.retry_limit
= 1;
2977 ifsta
->probe_resp
= skb_copy(skb
, GFP_ATOMIC
);
2978 if (ifsta
->probe_resp
) {
2979 mgmt
= (struct ieee80211_mgmt
*)
2980 ifsta
->probe_resp
->data
;
2981 mgmt
->frame_control
=
2982 IEEE80211_FC(IEEE80211_FTYPE_MGMT
,
2983 IEEE80211_STYPE_PROBE_RESP
);
2985 printk(KERN_DEBUG
"%s: Could not allocate ProbeResp "
2986 "template for IBSS\n", dev
->name
);
2989 if (local
->ops
->beacon_update
&&
2990 local
->ops
->beacon_update(local_to_hw(local
),
2991 skb
, &control
) == 0) {
2992 printk(KERN_DEBUG
"%s: Configured IBSS beacon "
2993 "template based on scan results\n", dev
->name
);
2998 mode
= local
->oper_hw_mode
;
2999 for (i
= 0; i
< bss
->supp_rates_len
; i
++) {
3000 int bitrate
= (bss
->supp_rates
[i
] & 0x7f) * 5;
3001 for (j
= 0; j
< mode
->num_rates
; j
++)
3002 if (mode
->rates
[j
].rate
== bitrate
)
3005 ifsta
->supp_rates_bits
= rates
;
3009 printk(KERN_DEBUG
"%s: Failed to configure IBSS beacon "
3010 "template\n", dev
->name
);
3014 ifsta
->state
= IEEE80211_IBSS_JOINED
;
3015 mod_timer(&ifsta
->timer
, jiffies
+ IEEE80211_IBSS_MERGE_INTERVAL
);
3017 ieee80211_rx_bss_put(dev
, bss
);
3023 static int ieee80211_sta_create_ibss(struct net_device
*dev
,
3024 struct ieee80211_if_sta
*ifsta
)
3026 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3027 struct ieee80211_sta_bss
*bss
;
3028 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3029 struct ieee80211_hw_mode
*mode
;
3030 u8 bssid
[ETH_ALEN
], *pos
;
3032 DECLARE_MAC_BUF(mac
);
3035 /* Easier testing, use fixed BSSID. */
3036 memset(bssid
, 0xfe, ETH_ALEN
);
3038 /* Generate random, not broadcast, locally administered BSSID. Mix in
3039 * own MAC address to make sure that devices that do not have proper
3040 * random number generator get different BSSID. */
3041 get_random_bytes(bssid
, ETH_ALEN
);
3042 for (i
= 0; i
< ETH_ALEN
; i
++)
3043 bssid
[i
] ^= dev
->dev_addr
[i
];
3048 printk(KERN_DEBUG
"%s: Creating new IBSS network, BSSID %s\n",
3049 dev
->name
, print_mac(mac
, bssid
));
3051 bss
= ieee80211_rx_bss_add(dev
, bssid
, local
->hw
.conf
.channel
,
3052 sdata
->u
.sta
.ssid
, sdata
->u
.sta
.ssid_len
);
3056 mode
= local
->oper_hw_mode
;
3058 if (local
->hw
.conf
.beacon_int
== 0)
3059 local
->hw
.conf
.beacon_int
= 100;
3060 bss
->beacon_int
= local
->hw
.conf
.beacon_int
;
3061 bss
->hw_mode
= local
->hw
.conf
.phymode
;
3062 bss
->freq
= local
->hw
.conf
.freq
;
3063 bss
->last_update
= jiffies
;
3064 bss
->capability
= WLAN_CAPABILITY_IBSS
;
3065 if (sdata
->default_key
) {
3066 bss
->capability
|= WLAN_CAPABILITY_PRIVACY
;
3068 sdata
->drop_unencrypted
= 0;
3069 bss
->supp_rates_len
= mode
->num_rates
;
3070 pos
= bss
->supp_rates
;
3071 for (i
= 0; i
< mode
->num_rates
; i
++) {
3072 int rate
= mode
->rates
[i
].rate
;
3073 *pos
++ = (u8
) (rate
/ 5);
3076 return ieee80211_sta_join_ibss(dev
, ifsta
, bss
);
3080 static int ieee80211_sta_find_ibss(struct net_device
*dev
,
3081 struct ieee80211_if_sta
*ifsta
)
3083 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3084 struct ieee80211_sta_bss
*bss
;
3088 DECLARE_MAC_BUF(mac
);
3089 DECLARE_MAC_BUF(mac2
);
3091 if (ifsta
->ssid_len
== 0)
3094 active_ibss
= ieee80211_sta_active_ibss(dev
);
3095 #ifdef CONFIG_MAC80211_IBSS_DEBUG
3096 printk(KERN_DEBUG
"%s: sta_find_ibss (active_ibss=%d)\n",
3097 dev
->name
, active_ibss
);
3098 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
3099 spin_lock_bh(&local
->sta_bss_lock
);
3100 list_for_each_entry(bss
, &local
->sta_bss_list
, list
) {
3101 if (ifsta
->ssid_len
!= bss
->ssid_len
||
3102 memcmp(ifsta
->ssid
, bss
->ssid
, bss
->ssid_len
) != 0
3103 || !(bss
->capability
& WLAN_CAPABILITY_IBSS
))
3105 #ifdef CONFIG_MAC80211_IBSS_DEBUG
3106 printk(KERN_DEBUG
" bssid=%s found\n",
3107 print_mac(mac
, bss
->bssid
));
3108 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
3109 memcpy(bssid
, bss
->bssid
, ETH_ALEN
);
3111 if (active_ibss
|| memcmp(bssid
, ifsta
->bssid
, ETH_ALEN
) != 0)
3114 spin_unlock_bh(&local
->sta_bss_lock
);
3116 #ifdef CONFIG_MAC80211_IBSS_DEBUG
3117 printk(KERN_DEBUG
" sta_find_ibss: selected %s current "
3118 "%s\n", print_mac(mac
, bssid
), print_mac(mac2
, ifsta
->bssid
));
3119 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
3120 if (found
&& memcmp(ifsta
->bssid
, bssid
, ETH_ALEN
) != 0 &&
3121 (bss
= ieee80211_rx_bss_get(dev
, bssid
, local
->hw
.conf
.channel
,
3122 ifsta
->ssid
, ifsta
->ssid_len
))) {
3123 printk(KERN_DEBUG
"%s: Selected IBSS BSSID %s"
3124 " based on configured SSID\n",
3125 dev
->name
, print_mac(mac
, bssid
));
3126 return ieee80211_sta_join_ibss(dev
, ifsta
, bss
);
3128 #ifdef CONFIG_MAC80211_IBSS_DEBUG
3129 printk(KERN_DEBUG
" did not try to join ibss\n");
3130 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
3132 /* Selected IBSS not found in current scan results - try to scan */
3133 if (ifsta
->state
== IEEE80211_IBSS_JOINED
&&
3134 !ieee80211_sta_active_ibss(dev
)) {
3135 mod_timer(&ifsta
->timer
, jiffies
+
3136 IEEE80211_IBSS_MERGE_INTERVAL
);
3137 } else if (time_after(jiffies
, local
->last_scan_completed
+
3138 IEEE80211_SCAN_INTERVAL
)) {
3139 printk(KERN_DEBUG
"%s: Trigger new scan to find an IBSS to "
3140 "join\n", dev
->name
);
3141 return ieee80211_sta_req_scan(dev
, ifsta
->ssid
,
3143 } else if (ifsta
->state
!= IEEE80211_IBSS_JOINED
) {
3144 int interval
= IEEE80211_SCAN_INTERVAL
;
3146 if (time_after(jiffies
, ifsta
->ibss_join_req
+
3147 IEEE80211_IBSS_JOIN_TIMEOUT
)) {
3148 if ((ifsta
->flags
& IEEE80211_STA_CREATE_IBSS
) &&
3149 local
->oper_channel
->flag
& IEEE80211_CHAN_W_IBSS
)
3150 return ieee80211_sta_create_ibss(dev
, ifsta
);
3151 if (ifsta
->flags
& IEEE80211_STA_CREATE_IBSS
) {
3152 printk(KERN_DEBUG
"%s: IBSS not allowed on the"
3153 " configured channel %d (%d MHz)\n",
3154 dev
->name
, local
->hw
.conf
.channel
,
3155 local
->hw
.conf
.freq
);
3158 /* No IBSS found - decrease scan interval and continue
3160 interval
= IEEE80211_SCAN_INTERVAL_SLOW
;
3163 ifsta
->state
= IEEE80211_IBSS_SEARCH
;
3164 mod_timer(&ifsta
->timer
, jiffies
+ interval
);
3172 int ieee80211_sta_set_ssid(struct net_device
*dev
, char *ssid
, size_t len
)
3174 struct ieee80211_sub_if_data
*sdata
;
3175 struct ieee80211_if_sta
*ifsta
;
3176 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3178 if (len
> IEEE80211_MAX_SSID_LEN
)
3181 /* TODO: This should always be done for IBSS, even if IEEE80211_QOS is
3183 if (local
->ops
->conf_tx
) {
3184 struct ieee80211_tx_queue_params qparam
;
3187 memset(&qparam
, 0, sizeof(qparam
));
3188 /* TODO: are these ok defaults for all hw_modes? */
3191 local
->hw
.conf
.phymode
== MODE_IEEE80211B
? 31 : 15;
3192 qparam
.cw_max
= 1023;
3193 qparam
.burst_time
= 0;
3194 for (i
= IEEE80211_TX_QUEUE_DATA0
; i
< NUM_TX_DATA_QUEUES
; i
++)
3196 local
->ops
->conf_tx(local_to_hw(local
),
3197 i
+ IEEE80211_TX_QUEUE_DATA0
,
3200 /* IBSS uses different parameters for Beacon sending */
3204 local
->ops
->conf_tx(local_to_hw(local
),
3205 IEEE80211_TX_QUEUE_BEACON
, &qparam
);
3208 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3209 ifsta
= &sdata
->u
.sta
;
3211 if (ifsta
->ssid_len
!= len
|| memcmp(ifsta
->ssid
, ssid
, len
) != 0)
3212 ifsta
->flags
&= ~IEEE80211_STA_PREV_BSSID_SET
;
3213 memcpy(ifsta
->ssid
, ssid
, len
);
3214 memset(ifsta
->ssid
+ len
, 0, IEEE80211_MAX_SSID_LEN
- len
);
3215 ifsta
->ssid_len
= len
;
3218 ifsta
->flags
|= IEEE80211_STA_SSID_SET
;
3220 ifsta
->flags
&= ~IEEE80211_STA_SSID_SET
;
3221 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_IBSS
&&
3222 !(ifsta
->flags
& IEEE80211_STA_BSSID_SET
)) {
3223 ifsta
->ibss_join_req
= jiffies
;
3224 ifsta
->state
= IEEE80211_IBSS_SEARCH
;
3225 return ieee80211_sta_find_ibss(dev
, ifsta
);
3231 int ieee80211_sta_get_ssid(struct net_device
*dev
, char *ssid
, size_t *len
)
3233 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3234 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
3235 memcpy(ssid
, ifsta
->ssid
, ifsta
->ssid_len
);
3236 *len
= ifsta
->ssid_len
;
3241 int ieee80211_sta_set_bssid(struct net_device
*dev
, u8
*bssid
)
3243 struct ieee80211_sub_if_data
*sdata
;
3244 struct ieee80211_if_sta
*ifsta
;
3247 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3248 ifsta
= &sdata
->u
.sta
;
3250 if (memcmp(ifsta
->bssid
, bssid
, ETH_ALEN
) != 0) {
3251 memcpy(ifsta
->bssid
, bssid
, ETH_ALEN
);
3252 res
= ieee80211_if_config(dev
);
3254 printk(KERN_DEBUG
"%s: Failed to config new BSSID to "
3255 "the low-level driver\n", dev
->name
);
3260 if (is_valid_ether_addr(bssid
))
3261 ifsta
->flags
|= IEEE80211_STA_BSSID_SET
;
3263 ifsta
->flags
&= ~IEEE80211_STA_BSSID_SET
;
3269 static void ieee80211_send_nullfunc(struct ieee80211_local
*local
,
3270 struct ieee80211_sub_if_data
*sdata
,
3273 struct sk_buff
*skb
;
3274 struct ieee80211_hdr
*nullfunc
;
3277 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ 24);
3279 printk(KERN_DEBUG
"%s: failed to allocate buffer for nullfunc "
3280 "frame\n", sdata
->dev
->name
);
3283 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
3285 nullfunc
= (struct ieee80211_hdr
*) skb_put(skb
, 24);
3286 memset(nullfunc
, 0, 24);
3287 fc
= IEEE80211_FTYPE_DATA
| IEEE80211_STYPE_NULLFUNC
|
3288 IEEE80211_FCTL_TODS
;
3290 fc
|= IEEE80211_FCTL_PM
;
3291 nullfunc
->frame_control
= cpu_to_le16(fc
);
3292 memcpy(nullfunc
->addr1
, sdata
->u
.sta
.bssid
, ETH_ALEN
);
3293 memcpy(nullfunc
->addr2
, sdata
->dev
->dev_addr
, ETH_ALEN
);
3294 memcpy(nullfunc
->addr3
, sdata
->u
.sta
.bssid
, ETH_ALEN
);
3296 ieee80211_sta_tx(sdata
->dev
, skb
, 0);
3300 void ieee80211_scan_completed(struct ieee80211_hw
*hw
)
3302 struct ieee80211_local
*local
= hw_to_local(hw
);
3303 struct net_device
*dev
= local
->scan_dev
;
3304 struct ieee80211_sub_if_data
*sdata
;
3305 union iwreq_data wrqu
;
3307 local
->last_scan_completed
= jiffies
;
3308 memset(&wrqu
, 0, sizeof(wrqu
));
3309 wireless_send_event(dev
, SIOCGIWSCAN
, &wrqu
, NULL
);
3311 if (local
->sta_hw_scanning
) {
3312 local
->sta_hw_scanning
= 0;
3316 local
->sta_sw_scanning
= 0;
3317 if (ieee80211_hw_config(local
))
3318 printk(KERN_DEBUG
"%s: failed to restore operational "
3319 "channel after scan\n", dev
->name
);
3322 netif_tx_lock_bh(local
->mdev
);
3323 local
->filter_flags
&= ~FIF_BCN_PRBRESP_PROMISC
;
3324 local
->ops
->configure_filter(local_to_hw(local
),
3325 FIF_BCN_PRBRESP_PROMISC
,
3326 &local
->filter_flags
,
3327 local
->mdev
->mc_count
,
3328 local
->mdev
->mc_list
);
3330 netif_tx_unlock_bh(local
->mdev
);
3333 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
3335 /* No need to wake the master device. */
3336 if (sdata
->dev
== local
->mdev
)
3339 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_STA
) {
3340 if (sdata
->u
.sta
.flags
& IEEE80211_STA_ASSOCIATED
)
3341 ieee80211_send_nullfunc(local
, sdata
, 0);
3342 ieee80211_sta_timer((unsigned long)sdata
);
3345 netif_wake_queue(sdata
->dev
);
3350 sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3351 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_IBSS
) {
3352 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
3353 if (!(ifsta
->flags
& IEEE80211_STA_BSSID_SET
) ||
3354 (!ifsta
->state
== IEEE80211_IBSS_JOINED
&&
3355 !ieee80211_sta_active_ibss(dev
)))
3356 ieee80211_sta_find_ibss(dev
, ifsta
);
3359 EXPORT_SYMBOL(ieee80211_scan_completed
);
3361 void ieee80211_sta_scan_work(struct work_struct
*work
)
3363 struct ieee80211_local
*local
=
3364 container_of(work
, struct ieee80211_local
, scan_work
.work
);
3365 struct net_device
*dev
= local
->scan_dev
;
3366 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3367 struct ieee80211_hw_mode
*mode
;
3368 struct ieee80211_channel
*chan
;
3370 unsigned long next_delay
= 0;
3372 if (!local
->sta_sw_scanning
)
3375 switch (local
->scan_state
) {
3376 case SCAN_SET_CHANNEL
:
3377 mode
= local
->scan_hw_mode
;
3378 if (local
->scan_hw_mode
->list
.next
== &local
->modes_list
&&
3379 local
->scan_channel_idx
>= mode
->num_channels
) {
3380 ieee80211_scan_completed(local_to_hw(local
));
3383 skip
= !(local
->enabled_modes
& (1 << mode
->mode
));
3384 chan
= &mode
->channels
[local
->scan_channel_idx
];
3385 if (!(chan
->flag
& IEEE80211_CHAN_W_SCAN
) ||
3386 (sdata
->vif
.type
== IEEE80211_IF_TYPE_IBSS
&&
3387 !(chan
->flag
& IEEE80211_CHAN_W_IBSS
)) ||
3388 (local
->hw_modes
& local
->enabled_modes
&
3389 (1 << MODE_IEEE80211G
) && mode
->mode
== MODE_IEEE80211B
))
3394 printk(KERN_DEBUG
"%s: scan channel %d (%d MHz)\n",
3395 dev
->name
, chan
->chan
, chan
->freq
);
3398 local
->scan_channel
= chan
;
3399 if (ieee80211_hw_config(local
)) {
3400 printk(KERN_DEBUG
"%s: failed to set channel "
3401 "%d (%d MHz) for scan\n", dev
->name
,
3402 chan
->chan
, chan
->freq
);
3407 local
->scan_channel_idx
++;
3408 if (local
->scan_channel_idx
>= local
->scan_hw_mode
->num_channels
) {
3409 if (local
->scan_hw_mode
->list
.next
!= &local
->modes_list
) {
3410 local
->scan_hw_mode
= list_entry(local
->scan_hw_mode
->list
.next
,
3411 struct ieee80211_hw_mode
,
3413 local
->scan_channel_idx
= 0;
3420 next_delay
= IEEE80211_PROBE_DELAY
+
3421 usecs_to_jiffies(local
->hw
.channel_change_time
);
3422 local
->scan_state
= SCAN_SEND_PROBE
;
3424 case SCAN_SEND_PROBE
:
3425 if (local
->scan_channel
->flag
& IEEE80211_CHAN_W_ACTIVE_SCAN
) {
3426 ieee80211_send_probe_req(dev
, NULL
, local
->scan_ssid
,
3427 local
->scan_ssid_len
);
3428 next_delay
= IEEE80211_CHANNEL_TIME
;
3430 next_delay
= IEEE80211_PASSIVE_CHANNEL_TIME
;
3431 local
->scan_state
= SCAN_SET_CHANNEL
;
3435 if (local
->sta_sw_scanning
)
3436 queue_delayed_work(local
->hw
.workqueue
, &local
->scan_work
,
3441 static int ieee80211_sta_start_scan(struct net_device
*dev
,
3442 u8
*ssid
, size_t ssid_len
)
3444 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3445 struct ieee80211_sub_if_data
*sdata
;
3447 if (ssid_len
> IEEE80211_MAX_SSID_LEN
)
3450 /* MLME-SCAN.request (page 118) page 144 (11.1.3.1)
3451 * BSSType: INFRASTRUCTURE, INDEPENDENT, ANY_BSS
3454 * ScanType: ACTIVE, PASSIVE
3455 * ProbeDelay: delay (in microseconds) to be used prior to transmitting
3456 * a Probe frame during active scanning
3458 * MinChannelTime (>= ProbeDelay), in TU
3459 * MaxChannelTime: (>= MinChannelTime), in TU
3462 /* MLME-SCAN.confirm
3464 * ResultCode: SUCCESS, INVALID_PARAMETERS
3467 if (local
->sta_sw_scanning
|| local
->sta_hw_scanning
) {
3468 if (local
->scan_dev
== dev
)
3473 if (local
->ops
->hw_scan
) {
3474 int rc
= local
->ops
->hw_scan(local_to_hw(local
),
3477 local
->sta_hw_scanning
= 1;
3478 local
->scan_dev
= dev
;
3483 local
->sta_sw_scanning
= 1;
3486 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
) {
3488 /* Don't stop the master interface, otherwise we can't transmit
3490 if (sdata
->dev
== local
->mdev
)
3493 netif_stop_queue(sdata
->dev
);
3494 if (sdata
->vif
.type
== IEEE80211_IF_TYPE_STA
&&
3495 (sdata
->u
.sta
.flags
& IEEE80211_STA_ASSOCIATED
))
3496 ieee80211_send_nullfunc(local
, sdata
, 1);
3501 local
->scan_ssid_len
= ssid_len
;
3502 memcpy(local
->scan_ssid
, ssid
, ssid_len
);
3504 local
->scan_ssid_len
= 0;
3505 local
->scan_state
= SCAN_SET_CHANNEL
;
3506 local
->scan_hw_mode
= list_entry(local
->modes_list
.next
,
3507 struct ieee80211_hw_mode
,
3509 local
->scan_channel_idx
= 0;
3510 local
->scan_dev
= dev
;
3512 netif_tx_lock_bh(local
->mdev
);
3513 local
->filter_flags
|= FIF_BCN_PRBRESP_PROMISC
;
3514 local
->ops
->configure_filter(local_to_hw(local
),
3515 FIF_BCN_PRBRESP_PROMISC
,
3516 &local
->filter_flags
,
3517 local
->mdev
->mc_count
,
3518 local
->mdev
->mc_list
);
3519 netif_tx_unlock_bh(local
->mdev
);
3521 /* TODO: start scan as soon as all nullfunc frames are ACKed */
3522 queue_delayed_work(local
->hw
.workqueue
, &local
->scan_work
,
3523 IEEE80211_CHANNEL_TIME
);
3529 int ieee80211_sta_req_scan(struct net_device
*dev
, u8
*ssid
, size_t ssid_len
)
3531 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3532 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
3533 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3535 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_STA
)
3536 return ieee80211_sta_start_scan(dev
, ssid
, ssid_len
);
3538 if (local
->sta_sw_scanning
|| local
->sta_hw_scanning
) {
3539 if (local
->scan_dev
== dev
)
3544 ifsta
->scan_ssid_len
= ssid_len
;
3546 memcpy(ifsta
->scan_ssid
, ssid
, ssid_len
);
3547 set_bit(IEEE80211_STA_REQ_SCAN
, &ifsta
->request
);
3548 queue_work(local
->hw
.workqueue
, &ifsta
->work
);
3553 ieee80211_sta_scan_result(struct net_device
*dev
,
3554 struct ieee80211_sta_bss
*bss
,
3555 char *current_ev
, char *end_buf
)
3557 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3558 struct iw_event iwe
;
3560 if (time_after(jiffies
,
3561 bss
->last_update
+ IEEE80211_SCAN_RESULT_EXPIRE
))
3564 if (!(local
->enabled_modes
& (1 << bss
->hw_mode
)))
3567 memset(&iwe
, 0, sizeof(iwe
));
3568 iwe
.cmd
= SIOCGIWAP
;
3569 iwe
.u
.ap_addr
.sa_family
= ARPHRD_ETHER
;
3570 memcpy(iwe
.u
.ap_addr
.sa_data
, bss
->bssid
, ETH_ALEN
);
3571 current_ev
= iwe_stream_add_event(current_ev
, end_buf
, &iwe
,
3574 memset(&iwe
, 0, sizeof(iwe
));
3575 iwe
.cmd
= SIOCGIWESSID
;
3576 iwe
.u
.data
.length
= bss
->ssid_len
;
3577 iwe
.u
.data
.flags
= 1;
3578 current_ev
= iwe_stream_add_point(current_ev
, end_buf
, &iwe
,
3581 if (bss
->capability
& (WLAN_CAPABILITY_ESS
| WLAN_CAPABILITY_IBSS
)) {
3582 memset(&iwe
, 0, sizeof(iwe
));
3583 iwe
.cmd
= SIOCGIWMODE
;
3584 if (bss
->capability
& WLAN_CAPABILITY_ESS
)
3585 iwe
.u
.mode
= IW_MODE_MASTER
;
3587 iwe
.u
.mode
= IW_MODE_ADHOC
;
3588 current_ev
= iwe_stream_add_event(current_ev
, end_buf
, &iwe
,
3592 memset(&iwe
, 0, sizeof(iwe
));
3593 iwe
.cmd
= SIOCGIWFREQ
;
3594 iwe
.u
.freq
.m
= bss
->channel
;
3596 current_ev
= iwe_stream_add_event(current_ev
, end_buf
, &iwe
,
3598 iwe
.u
.freq
.m
= bss
->freq
* 100000;
3600 current_ev
= iwe_stream_add_event(current_ev
, end_buf
, &iwe
,
3603 memset(&iwe
, 0, sizeof(iwe
));
3605 iwe
.u
.qual
.qual
= bss
->signal
;
3606 iwe
.u
.qual
.level
= bss
->rssi
;
3607 iwe
.u
.qual
.noise
= bss
->noise
;
3608 iwe
.u
.qual
.updated
= local
->wstats_flags
;
3609 current_ev
= iwe_stream_add_event(current_ev
, end_buf
, &iwe
,
3612 memset(&iwe
, 0, sizeof(iwe
));
3613 iwe
.cmd
= SIOCGIWENCODE
;
3614 if (bss
->capability
& WLAN_CAPABILITY_PRIVACY
)
3615 iwe
.u
.data
.flags
= IW_ENCODE_ENABLED
| IW_ENCODE_NOKEY
;
3617 iwe
.u
.data
.flags
= IW_ENCODE_DISABLED
;
3618 iwe
.u
.data
.length
= 0;
3619 current_ev
= iwe_stream_add_point(current_ev
, end_buf
, &iwe
, "");
3621 if (bss
&& bss
->wpa_ie
) {
3622 memset(&iwe
, 0, sizeof(iwe
));
3623 iwe
.cmd
= IWEVGENIE
;
3624 iwe
.u
.data
.length
= bss
->wpa_ie_len
;
3625 current_ev
= iwe_stream_add_point(current_ev
, end_buf
, &iwe
,
3629 if (bss
&& bss
->rsn_ie
) {
3630 memset(&iwe
, 0, sizeof(iwe
));
3631 iwe
.cmd
= IWEVGENIE
;
3632 iwe
.u
.data
.length
= bss
->rsn_ie_len
;
3633 current_ev
= iwe_stream_add_point(current_ev
, end_buf
, &iwe
,
3637 if (bss
&& bss
->supp_rates_len
> 0) {
3638 /* display all supported rates in readable format */
3639 char *p
= current_ev
+ IW_EV_LCP_LEN
;
3642 memset(&iwe
, 0, sizeof(iwe
));
3643 iwe
.cmd
= SIOCGIWRATE
;
3644 /* Those two flags are ignored... */
3645 iwe
.u
.bitrate
.fixed
= iwe
.u
.bitrate
.disabled
= 0;
3647 for (i
= 0; i
< bss
->supp_rates_len
; i
++) {
3648 iwe
.u
.bitrate
.value
= ((bss
->supp_rates
[i
] &
3650 p
= iwe_stream_add_value(current_ev
, p
,
3651 end_buf
, &iwe
, IW_EV_PARAM_LEN
);
3658 buf
= kmalloc(30, GFP_ATOMIC
);
3660 memset(&iwe
, 0, sizeof(iwe
));
3661 iwe
.cmd
= IWEVCUSTOM
;
3662 sprintf(buf
, "tsf=%016llx", (unsigned long long)(bss
->timestamp
));
3663 iwe
.u
.data
.length
= strlen(buf
);
3664 current_ev
= iwe_stream_add_point(current_ev
, end_buf
,
3674 int ieee80211_sta_scan_results(struct net_device
*dev
, char *buf
, size_t len
)
3676 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3677 char *current_ev
= buf
;
3678 char *end_buf
= buf
+ len
;
3679 struct ieee80211_sta_bss
*bss
;
3681 spin_lock_bh(&local
->sta_bss_lock
);
3682 list_for_each_entry(bss
, &local
->sta_bss_list
, list
) {
3683 if (buf
+ len
- current_ev
<= IW_EV_ADDR_LEN
) {
3684 spin_unlock_bh(&local
->sta_bss_lock
);
3687 current_ev
= ieee80211_sta_scan_result(dev
, bss
, current_ev
,
3690 spin_unlock_bh(&local
->sta_bss_lock
);
3691 return current_ev
- buf
;
3695 int ieee80211_sta_set_extra_ie(struct net_device
*dev
, char *ie
, size_t len
)
3697 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3698 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
3699 kfree(ifsta
->extra_ie
);
3701 ifsta
->extra_ie
= NULL
;
3702 ifsta
->extra_ie_len
= 0;
3705 ifsta
->extra_ie
= kmalloc(len
, GFP_KERNEL
);
3706 if (!ifsta
->extra_ie
) {
3707 ifsta
->extra_ie_len
= 0;
3710 memcpy(ifsta
->extra_ie
, ie
, len
);
3711 ifsta
->extra_ie_len
= len
;
3716 struct sta_info
* ieee80211_ibss_add_sta(struct net_device
*dev
,
3717 struct sk_buff
*skb
, u8
*bssid
,
3720 struct ieee80211_local
*local
= wdev_priv(dev
->ieee80211_ptr
);
3721 struct sta_info
*sta
;
3722 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3723 DECLARE_MAC_BUF(mac
);
3725 /* TODO: Could consider removing the least recently used entry and
3726 * allow new one to be added. */
3727 if (local
->num_sta
>= IEEE80211_IBSS_MAX_STA_ENTRIES
) {
3728 if (net_ratelimit()) {
3729 printk(KERN_DEBUG
"%s: No room for a new IBSS STA "
3730 "entry %s\n", dev
->name
, print_mac(mac
, addr
));
3735 printk(KERN_DEBUG
"%s: Adding new IBSS station %s (dev=%s)\n",
3736 wiphy_name(local
->hw
.wiphy
), print_mac(mac
, addr
), dev
->name
);
3738 sta
= sta_info_add(local
, dev
, addr
, GFP_ATOMIC
);
3742 sta
->supp_rates
= sdata
->u
.sta
.supp_rates_bits
;
3744 rate_control_rate_init(sta
, local
);
3746 return sta
; /* caller will call sta_info_put() */
3750 int ieee80211_sta_deauthenticate(struct net_device
*dev
, u16 reason
)
3752 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3753 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
3755 printk(KERN_DEBUG
"%s: deauthenticate(reason=%d)\n",
3758 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_STA
&&
3759 sdata
->vif
.type
!= IEEE80211_IF_TYPE_IBSS
)
3762 ieee80211_send_deauth(dev
, ifsta
, reason
);
3763 ieee80211_set_disassoc(dev
, ifsta
, 1);
3768 int ieee80211_sta_disassociate(struct net_device
*dev
, u16 reason
)
3770 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
3771 struct ieee80211_if_sta
*ifsta
= &sdata
->u
.sta
;
3773 printk(KERN_DEBUG
"%s: disassociate(reason=%d)\n",
3776 if (sdata
->vif
.type
!= IEEE80211_IF_TYPE_STA
)
3779 if (!(ifsta
->flags
& IEEE80211_STA_ASSOCIATED
))
3782 ieee80211_send_disassoc(dev
, ifsta
, reason
);
3783 ieee80211_set_disassoc(dev
, ifsta
, 0);