aboutsummaryrefslogtreecommitdiffstats
path: root/net/mac80211
diff options
context:
space:
mode:
Diffstat (limited to 'net/mac80211')
-rw-r--r--net/mac80211/Makefile1
-rw-r--r--net/mac80211/agg-rx.c6
-rw-r--r--net/mac80211/agg-tx.c5
-rw-r--r--net/mac80211/cfg.c45
-rw-r--r--net/mac80211/debugfs_netdev.c48
-rw-r--r--net/mac80211/ht.c6
-rw-r--r--net/mac80211/ibss.c888
-rw-r--r--net/mac80211/ieee80211_i.h117
-rw-r--r--net/mac80211/iface.c76
-rw-r--r--net/mac80211/key.c2
-rw-r--r--net/mac80211/main.c9
-rw-r--r--net/mac80211/mlme.c1646
-rw-r--r--net/mac80211/rx.c37
-rw-r--r--net/mac80211/scan.c43
-rw-r--r--net/mac80211/spectmgmt.c26
-rw-r--r--net/mac80211/tx.c11
-rw-r--r--net/mac80211/util.c176
-rw-r--r--net/mac80211/wext.c141
18 files changed, 1803 insertions, 1480 deletions
diff --git a/net/mac80211/Makefile b/net/mac80211/Makefile
index 3503a3d21318..0e3ab88bb706 100644
--- a/net/mac80211/Makefile
+++ b/net/mac80211/Makefile
@@ -9,6 +9,7 @@ mac80211-y := \
9 wpa.o \ 9 wpa.o \
10 scan.o \ 10 scan.o \
11 ht.o agg-tx.o agg-rx.o \ 11 ht.o agg-tx.o agg-rx.o \
12 ibss.o \
12 mlme.o \ 13 mlme.o \
13 iface.o \ 14 iface.o \
14 rate.o \ 15 rate.o \
diff --git a/net/mac80211/agg-rx.c b/net/mac80211/agg-rx.c
index 3112bfd441b6..a95affc94629 100644
--- a/net/mac80211/agg-rx.c
+++ b/net/mac80211/agg-rx.c
@@ -129,7 +129,6 @@ static void ieee80211_send_addba_resp(struct ieee80211_sub_if_data *sdata, u8 *d
129 u8 dialog_token, u16 status, u16 policy, 129 u8 dialog_token, u16 status, u16 policy,
130 u16 buf_size, u16 timeout) 130 u16 buf_size, u16 timeout)
131{ 131{
132 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
133 struct ieee80211_local *local = sdata->local; 132 struct ieee80211_local *local = sdata->local;
134 struct sk_buff *skb; 133 struct sk_buff *skb;
135 struct ieee80211_mgmt *mgmt; 134 struct ieee80211_mgmt *mgmt;
@@ -151,8 +150,9 @@ static void ieee80211_send_addba_resp(struct ieee80211_sub_if_data *sdata, u8 *d
151 if (sdata->vif.type == NL80211_IFTYPE_AP || 150 if (sdata->vif.type == NL80211_IFTYPE_AP ||
152 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 151 sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
153 memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN); 152 memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN);
154 else 153 else if (sdata->vif.type == NL80211_IFTYPE_STATION)
155 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN); 154 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
155
156 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 156 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
157 IEEE80211_STYPE_ACTION); 157 IEEE80211_STYPE_ACTION);
158 158
diff --git a/net/mac80211/agg-tx.c b/net/mac80211/agg-tx.c
index 0217b68c47ca..1df116d4d6e7 100644
--- a/net/mac80211/agg-tx.c
+++ b/net/mac80211/agg-tx.c
@@ -49,7 +49,6 @@ static void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata,
49 u16 agg_size, u16 timeout) 49 u16 agg_size, u16 timeout)
50{ 50{
51 struct ieee80211_local *local = sdata->local; 51 struct ieee80211_local *local = sdata->local;
52 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
53 struct sk_buff *skb; 52 struct sk_buff *skb;
54 struct ieee80211_mgmt *mgmt; 53 struct ieee80211_mgmt *mgmt;
55 u16 capab; 54 u16 capab;
@@ -69,8 +68,8 @@ static void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata,
69 if (sdata->vif.type == NL80211_IFTYPE_AP || 68 if (sdata->vif.type == NL80211_IFTYPE_AP ||
70 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 69 sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
71 memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN); 70 memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN);
72 else 71 else if (sdata->vif.type == NL80211_IFTYPE_STATION)
73 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN); 72 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
74 73
75 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 74 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
76 IEEE80211_STYPE_ACTION); 75 IEEE80211_STYPE_ACTION);
diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index c8d969be440b..f453bb7c564b 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -1180,45 +1180,45 @@ static int set_mgmt_extra_ie_sta(struct ieee80211_sub_if_data *sdata,
1180 u8 subtype, u8 *ies, size_t ies_len) 1180 u8 subtype, u8 *ies, size_t ies_len)
1181{ 1181{
1182 struct ieee80211_local *local = sdata->local; 1182 struct ieee80211_local *local = sdata->local;
1183 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 1183 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1184 1184
1185 switch (subtype) { 1185 switch (subtype) {
1186 case IEEE80211_STYPE_PROBE_REQ >> 4: 1186 case IEEE80211_STYPE_PROBE_REQ >> 4:
1187 if (local->ops->hw_scan) 1187 if (local->ops->hw_scan)
1188 break; 1188 break;
1189 kfree(ifsta->ie_probereq); 1189 kfree(ifmgd->ie_probereq);
1190 ifsta->ie_probereq = ies; 1190 ifmgd->ie_probereq = ies;
1191 ifsta->ie_probereq_len = ies_len; 1191 ifmgd->ie_probereq_len = ies_len;
1192 return 0; 1192 return 0;
1193 case IEEE80211_STYPE_PROBE_RESP >> 4: 1193 case IEEE80211_STYPE_PROBE_RESP >> 4:
1194 kfree(ifsta->ie_proberesp); 1194 kfree(ifmgd->ie_proberesp);
1195 ifsta->ie_proberesp = ies; 1195 ifmgd->ie_proberesp = ies;
1196 ifsta->ie_proberesp_len = ies_len; 1196 ifmgd->ie_proberesp_len = ies_len;
1197 return 0; 1197 return 0;
1198 case IEEE80211_STYPE_AUTH >> 4: 1198 case IEEE80211_STYPE_AUTH >> 4:
1199 kfree(ifsta->ie_auth); 1199 kfree(ifmgd->ie_auth);
1200 ifsta->ie_auth = ies; 1200 ifmgd->ie_auth = ies;
1201 ifsta->ie_auth_len = ies_len; 1201 ifmgd->ie_auth_len = ies_len;
1202 return 0; 1202 return 0;
1203 case IEEE80211_STYPE_ASSOC_REQ >> 4: 1203 case IEEE80211_STYPE_ASSOC_REQ >> 4:
1204 kfree(ifsta->ie_assocreq); 1204 kfree(ifmgd->ie_assocreq);
1205 ifsta->ie_assocreq = ies; 1205 ifmgd->ie_assocreq = ies;
1206 ifsta->ie_assocreq_len = ies_len; 1206 ifmgd->ie_assocreq_len = ies_len;
1207 return 0; 1207 return 0;
1208 case IEEE80211_STYPE_REASSOC_REQ >> 4: 1208 case IEEE80211_STYPE_REASSOC_REQ >> 4:
1209 kfree(ifsta->ie_reassocreq); 1209 kfree(ifmgd->ie_reassocreq);
1210 ifsta->ie_reassocreq = ies; 1210 ifmgd->ie_reassocreq = ies;
1211 ifsta->ie_reassocreq_len = ies_len; 1211 ifmgd->ie_reassocreq_len = ies_len;
1212 return 0; 1212 return 0;
1213 case IEEE80211_STYPE_DEAUTH >> 4: 1213 case IEEE80211_STYPE_DEAUTH >> 4:
1214 kfree(ifsta->ie_deauth); 1214 kfree(ifmgd->ie_deauth);
1215 ifsta->ie_deauth = ies; 1215 ifmgd->ie_deauth = ies;
1216 ifsta->ie_deauth_len = ies_len; 1216 ifmgd->ie_deauth_len = ies_len;
1217 return 0; 1217 return 0;
1218 case IEEE80211_STYPE_DISASSOC >> 4: 1218 case IEEE80211_STYPE_DISASSOC >> 4:
1219 kfree(ifsta->ie_disassoc); 1219 kfree(ifmgd->ie_disassoc);
1220 ifsta->ie_disassoc = ies; 1220 ifmgd->ie_disassoc = ies;
1221 ifsta->ie_disassoc_len = ies_len; 1221 ifmgd->ie_disassoc_len = ies_len;
1222 return 0; 1222 return 0;
1223 } 1223 }
1224 1224
@@ -1248,7 +1248,6 @@ static int ieee80211_set_mgmt_extra_ie(struct wiphy *wiphy,
1248 1248
1249 switch (sdata->vif.type) { 1249 switch (sdata->vif.type) {
1250 case NL80211_IFTYPE_STATION: 1250 case NL80211_IFTYPE_STATION:
1251 case NL80211_IFTYPE_ADHOC:
1252 ret = set_mgmt_extra_ie_sta(sdata, params->subtype, 1251 ret = set_mgmt_extra_ie_sta(sdata, params->subtype,
1253 ies, ies_len); 1252 ies, ies_len);
1254 break; 1253 break;
diff --git a/net/mac80211/debugfs_netdev.c b/net/mac80211/debugfs_netdev.c
index c54219301724..e3420329f4e6 100644
--- a/net/mac80211/debugfs_netdev.c
+++ b/net/mac80211/debugfs_netdev.c
@@ -94,31 +94,31 @@ IEEE80211_IF_FILE(drop_unencrypted, drop_unencrypted, DEC);
94IEEE80211_IF_FILE(force_unicast_rateidx, force_unicast_rateidx, DEC); 94IEEE80211_IF_FILE(force_unicast_rateidx, force_unicast_rateidx, DEC);
95IEEE80211_IF_FILE(max_ratectrl_rateidx, max_ratectrl_rateidx, DEC); 95IEEE80211_IF_FILE(max_ratectrl_rateidx, max_ratectrl_rateidx, DEC);
96 96
97/* STA/IBSS attributes */ 97/* STA attributes */
98IEEE80211_IF_FILE(state, u.sta.state, DEC); 98IEEE80211_IF_FILE(state, u.mgd.state, DEC);
99IEEE80211_IF_FILE(bssid, u.sta.bssid, MAC); 99IEEE80211_IF_FILE(bssid, u.mgd.bssid, MAC);
100IEEE80211_IF_FILE(prev_bssid, u.sta.prev_bssid, MAC); 100IEEE80211_IF_FILE(prev_bssid, u.mgd.prev_bssid, MAC);
101IEEE80211_IF_FILE(ssid_len, u.sta.ssid_len, SIZE); 101IEEE80211_IF_FILE(ssid_len, u.mgd.ssid_len, SIZE);
102IEEE80211_IF_FILE(aid, u.sta.aid, DEC); 102IEEE80211_IF_FILE(aid, u.mgd.aid, DEC);
103IEEE80211_IF_FILE(ap_capab, u.sta.ap_capab, HEX); 103IEEE80211_IF_FILE(ap_capab, u.mgd.ap_capab, HEX);
104IEEE80211_IF_FILE(capab, u.sta.capab, HEX); 104IEEE80211_IF_FILE(capab, u.mgd.capab, HEX);
105IEEE80211_IF_FILE(extra_ie_len, u.sta.extra_ie_len, SIZE); 105IEEE80211_IF_FILE(extra_ie_len, u.mgd.extra_ie_len, SIZE);
106IEEE80211_IF_FILE(auth_tries, u.sta.auth_tries, DEC); 106IEEE80211_IF_FILE(auth_tries, u.mgd.auth_tries, DEC);
107IEEE80211_IF_FILE(assoc_tries, u.sta.assoc_tries, DEC); 107IEEE80211_IF_FILE(assoc_tries, u.mgd.assoc_tries, DEC);
108IEEE80211_IF_FILE(auth_algs, u.sta.auth_algs, HEX); 108IEEE80211_IF_FILE(auth_algs, u.mgd.auth_algs, HEX);
109IEEE80211_IF_FILE(auth_alg, u.sta.auth_alg, DEC); 109IEEE80211_IF_FILE(auth_alg, u.mgd.auth_alg, DEC);
110IEEE80211_IF_FILE(auth_transaction, u.sta.auth_transaction, DEC); 110IEEE80211_IF_FILE(auth_transaction, u.mgd.auth_transaction, DEC);
111 111
112static ssize_t ieee80211_if_fmt_flags( 112static ssize_t ieee80211_if_fmt_flags(
113 const struct ieee80211_sub_if_data *sdata, char *buf, int buflen) 113 const struct ieee80211_sub_if_data *sdata, char *buf, int buflen)
114{ 114{
115 return scnprintf(buf, buflen, "%s%s%s%s%s%s%s\n", 115 return scnprintf(buf, buflen, "%s%s%s%s%s%s%s\n",
116 sdata->u.sta.flags & IEEE80211_STA_SSID_SET ? "SSID\n" : "", 116 sdata->u.mgd.flags & IEEE80211_STA_SSID_SET ? "SSID\n" : "",
117 sdata->u.sta.flags & IEEE80211_STA_BSSID_SET ? "BSSID\n" : "", 117 sdata->u.mgd.flags & IEEE80211_STA_BSSID_SET ? "BSSID\n" : "",
118 sdata->u.sta.flags & IEEE80211_STA_PREV_BSSID_SET ? "prev BSSID\n" : "", 118 sdata->u.mgd.flags & IEEE80211_STA_PREV_BSSID_SET ? "prev BSSID\n" : "",
119 sdata->u.sta.flags & IEEE80211_STA_AUTHENTICATED ? "AUTH\n" : "", 119 sdata->u.mgd.flags & IEEE80211_STA_AUTHENTICATED ? "AUTH\n" : "",
120 sdata->u.sta.flags & IEEE80211_STA_ASSOCIATED ? "ASSOC\n" : "", 120 sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED ? "ASSOC\n" : "",
121 sdata->u.sta.flags & IEEE80211_STA_PROBEREQ_POLL ? "PROBEREQ POLL\n" : "", 121 sdata->u.mgd.flags & IEEE80211_STA_PROBEREQ_POLL ? "PROBEREQ POLL\n" : "",
122 sdata->vif.bss_conf.use_cts_prot ? "CTS prot\n" : ""); 122 sdata->vif.bss_conf.use_cts_prot ? "CTS prot\n" : "");
123} 123}
124__IEEE80211_IF_FILE(flags); 124__IEEE80211_IF_FILE(flags);
@@ -283,9 +283,11 @@ static void add_files(struct ieee80211_sub_if_data *sdata)
283#endif 283#endif
284 break; 284 break;
285 case NL80211_IFTYPE_STATION: 285 case NL80211_IFTYPE_STATION:
286 case NL80211_IFTYPE_ADHOC:
287 add_sta_files(sdata); 286 add_sta_files(sdata);
288 break; 287 break;
288 case NL80211_IFTYPE_ADHOC:
289 /* XXX */
290 break;
289 case NL80211_IFTYPE_AP: 291 case NL80211_IFTYPE_AP:
290 add_ap_files(sdata); 292 add_ap_files(sdata);
291 break; 293 break;
@@ -418,9 +420,11 @@ static void del_files(struct ieee80211_sub_if_data *sdata)
418#endif 420#endif
419 break; 421 break;
420 case NL80211_IFTYPE_STATION: 422 case NL80211_IFTYPE_STATION:
421 case NL80211_IFTYPE_ADHOC:
422 del_sta_files(sdata); 423 del_sta_files(sdata);
423 break; 424 break;
425 case NL80211_IFTYPE_ADHOC:
426 /* XXX */
427 break;
424 case NL80211_IFTYPE_AP: 428 case NL80211_IFTYPE_AP:
425 del_ap_files(sdata); 429 del_ap_files(sdata);
426 break; 430 break;
diff --git a/net/mac80211/ht.c b/net/mac80211/ht.c
index 82ea0b63a386..69b6e9a4df3d 100644
--- a/net/mac80211/ht.c
+++ b/net/mac80211/ht.c
@@ -169,7 +169,6 @@ void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
169 u16 initiator, u16 reason_code) 169 u16 initiator, u16 reason_code)
170{ 170{
171 struct ieee80211_local *local = sdata->local; 171 struct ieee80211_local *local = sdata->local;
172 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
173 struct sk_buff *skb; 172 struct sk_buff *skb;
174 struct ieee80211_mgmt *mgmt; 173 struct ieee80211_mgmt *mgmt;
175 u16 params; 174 u16 params;
@@ -190,8 +189,9 @@ void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
190 if (sdata->vif.type == NL80211_IFTYPE_AP || 189 if (sdata->vif.type == NL80211_IFTYPE_AP ||
191 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 190 sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
192 memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN); 191 memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN);
193 else 192 else if (sdata->vif.type == NL80211_IFTYPE_STATION)
194 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN); 193 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
194
195 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 195 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
196 IEEE80211_STYPE_ACTION); 196 IEEE80211_STYPE_ACTION);
197 197
diff --git a/net/mac80211/ibss.c b/net/mac80211/ibss.c
new file mode 100644
index 000000000000..1bbfc7029879
--- /dev/null
+++ b/net/mac80211/ibss.c
@@ -0,0 +1,888 @@
1/*
2 * IBSS mode implementation
3 * Copyright 2003-2008, Jouni Malinen <j@w1.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>
8 * Copyright 2009, Johannes Berg <johannes@sipsolutions.net>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15#include <linux/delay.h>
16#include <linux/if_ether.h>
17#include <linux/skbuff.h>
18#include <linux/if_arp.h>
19#include <linux/etherdevice.h>
20#include <linux/rtnetlink.h>
21#include <net/mac80211.h>
22#include <asm/unaligned.h>
23
24#include "ieee80211_i.h"
25#include "rate.h"
26
27#define IEEE80211_SCAN_INTERVAL (2 * HZ)
28#define IEEE80211_SCAN_INTERVAL_SLOW (15 * HZ)
29#define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ)
30
31#define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
32#define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
33
34#define IEEE80211_IBSS_MAX_STA_ENTRIES 128
35
36
37static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data *sdata,
38 struct ieee80211_mgmt *mgmt,
39 size_t len)
40{
41 u16 auth_alg, auth_transaction, status_code;
42
43 if (len < 24 + 6)
44 return;
45
46 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
47 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
48 status_code = le16_to_cpu(mgmt->u.auth.status_code);
49
50 /*
51 * IEEE 802.11 standard does not require authentication in IBSS
52 * networks and most implementations do not seem to use it.
53 * However, try to reply to authentication attempts if someone
54 * has actually implemented this.
55 */
56 if (auth_alg == WLAN_AUTH_OPEN && auth_transaction == 1)
57 ieee80211_send_auth(sdata, 2, WLAN_AUTH_OPEN, NULL, 0,
58 sdata->u.ibss.bssid, 0);
59}
60
61static int __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
62 const u8 *bssid, const int beacon_int,
63 const int freq,
64 const size_t supp_rates_len,
65 const u8 *supp_rates,
66 const u16 capability)
67{
68 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
69 struct ieee80211_local *local = sdata->local;
70 int res = 0, rates, i, j;
71 struct sk_buff *skb;
72 struct ieee80211_mgmt *mgmt;
73 u8 *pos;
74 struct ieee80211_supported_band *sband;
75 union iwreq_data wrqu;
76
77 if (local->ops->reset_tsf) {
78 /* Reset own TSF to allow time synchronization work. */
79 local->ops->reset_tsf(local_to_hw(local));
80 }
81
82 if ((ifibss->flags & IEEE80211_IBSS_PREV_BSSID_SET) &&
83 memcmp(ifibss->bssid, bssid, ETH_ALEN) == 0)
84 return res;
85
86 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
87 if (!skb) {
88 printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
89 "response\n", sdata->dev->name);
90 return -ENOMEM;
91 }
92
93 if (!(ifibss->flags & IEEE80211_IBSS_PREV_BSSID_SET)) {
94 /* Remove possible STA entries from other IBSS networks. */
95 sta_info_flush_delayed(sdata);
96 }
97
98 memcpy(ifibss->bssid, bssid, ETH_ALEN);
99 res = ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID);
100 if (res)
101 return res;
102
103 local->hw.conf.beacon_int = beacon_int >= 10 ? beacon_int : 10;
104
105 sdata->drop_unencrypted = capability &
106 WLAN_CAPABILITY_PRIVACY ? 1 : 0;
107
108 res = ieee80211_set_freq(sdata, freq);
109
110 if (res)
111 return res;
112
113 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
114
115 /* Build IBSS probe response */
116
117 skb_reserve(skb, local->hw.extra_tx_headroom);
118
119 mgmt = (struct ieee80211_mgmt *)
120 skb_put(skb, 24 + sizeof(mgmt->u.beacon));
121 memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
122 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
123 IEEE80211_STYPE_PROBE_RESP);
124 memset(mgmt->da, 0xff, ETH_ALEN);
125 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
126 memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
127 mgmt->u.beacon.beacon_int =
128 cpu_to_le16(local->hw.conf.beacon_int);
129 mgmt->u.beacon.capab_info = cpu_to_le16(capability);
130
131 pos = skb_put(skb, 2 + ifibss->ssid_len);
132 *pos++ = WLAN_EID_SSID;
133 *pos++ = ifibss->ssid_len;
134 memcpy(pos, ifibss->ssid, ifibss->ssid_len);
135
136 rates = supp_rates_len;
137 if (rates > 8)
138 rates = 8;
139 pos = skb_put(skb, 2 + rates);
140 *pos++ = WLAN_EID_SUPP_RATES;
141 *pos++ = rates;
142 memcpy(pos, supp_rates, rates);
143
144 if (sband->band == IEEE80211_BAND_2GHZ) {
145 pos = skb_put(skb, 2 + 1);
146 *pos++ = WLAN_EID_DS_PARAMS;
147 *pos++ = 1;
148 *pos++ = ieee80211_frequency_to_channel(freq);
149 }
150
151 pos = skb_put(skb, 2 + 2);
152 *pos++ = WLAN_EID_IBSS_PARAMS;
153 *pos++ = 2;
154 /* FIX: set ATIM window based on scan results */
155 *pos++ = 0;
156 *pos++ = 0;
157
158 if (supp_rates_len > 8) {
159 rates = supp_rates_len - 8;
160 pos = skb_put(skb, 2 + rates);
161 *pos++ = WLAN_EID_EXT_SUPP_RATES;
162 *pos++ = rates;
163 memcpy(pos, &supp_rates[8], rates);
164 }
165
166 ifibss->probe_resp = skb;
167
168 ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON |
169 IEEE80211_IFCC_BEACON_ENABLED);
170
171
172 rates = 0;
173 for (i = 0; i < supp_rates_len; i++) {
174 int bitrate = (supp_rates[i] & 0x7f) * 5;
175 for (j = 0; j < sband->n_bitrates; j++)
176 if (sband->bitrates[j].bitrate == bitrate)
177 rates |= BIT(j);
178 }
179
180 ieee80211_sta_def_wmm_params(sdata, supp_rates_len, supp_rates);
181
182 ifibss->flags |= IEEE80211_IBSS_PREV_BSSID_SET;
183 ifibss->state = IEEE80211_IBSS_MLME_JOINED;
184 mod_timer(&ifibss->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
185
186 memset(&wrqu, 0, sizeof(wrqu));
187 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
188 wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL);
189
190 return res;
191}
192
193static int ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
194 struct ieee80211_bss *bss)
195{
196 return __ieee80211_sta_join_ibss(sdata,
197 bss->cbss.bssid,
198 bss->cbss.beacon_interval,
199 bss->cbss.channel->center_freq,
200 bss->supp_rates_len, bss->supp_rates,
201 bss->cbss.capability);
202}
203
204static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
205 struct ieee80211_mgmt *mgmt,
206 size_t len,
207 struct ieee80211_rx_status *rx_status,
208 struct ieee802_11_elems *elems,
209 bool beacon)
210{
211 struct ieee80211_local *local = sdata->local;
212 int freq;
213 struct ieee80211_bss *bss;
214 struct sta_info *sta;
215 struct ieee80211_channel *channel;
216 u64 beacon_timestamp, rx_timestamp;
217 u32 supp_rates = 0;
218 enum ieee80211_band band = rx_status->band;
219
220 if (elems->ds_params && elems->ds_params_len == 1)
221 freq = ieee80211_channel_to_frequency(elems->ds_params[0]);
222 else
223 freq = rx_status->freq;
224
225 channel = ieee80211_get_channel(local->hw.wiphy, freq);
226
227 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
228 return;
229
230 if (sdata->vif.type == NL80211_IFTYPE_ADHOC && elems->supp_rates &&
231 memcmp(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN) == 0) {
232 supp_rates = ieee80211_sta_get_rates(local, elems, band);
233
234 rcu_read_lock();
235
236 sta = sta_info_get(local, mgmt->sa);
237 if (sta) {
238 u32 prev_rates;
239
240 prev_rates = sta->sta.supp_rates[band];
241 /* make sure mandatory rates are always added */
242 sta->sta.supp_rates[band] = supp_rates |
243 ieee80211_mandatory_rates(local, band);
244
245#ifdef CONFIG_MAC80211_IBSS_DEBUG
246 if (sta->sta.supp_rates[band] != prev_rates)
247 printk(KERN_DEBUG "%s: updated supp_rates set "
248 "for %pM based on beacon info (0x%llx | "
249 "0x%llx -> 0x%llx)\n",
250 sdata->dev->name,
251 sta->sta.addr,
252 (unsigned long long) prev_rates,
253 (unsigned long long) supp_rates,
254 (unsigned long long) sta->sta.supp_rates[band]);
255#endif
256 } else
257 ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, supp_rates);
258
259 rcu_read_unlock();
260 }
261
262 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
263 channel, beacon);
264 if (!bss)
265 return;
266
267 /* was just updated in ieee80211_bss_info_update */
268 beacon_timestamp = bss->cbss.tsf;
269
270 /* check if we need to merge IBSS */
271
272 /* merge only on beacons (???) */
273 if (!beacon)
274 goto put_bss;
275
276 /* we use a fixed BSSID */
277 if (sdata->u.ibss.flags & IEEE80211_IBSS_BSSID_SET)
278 goto put_bss;
279
280 /* not an IBSS */
281 if (!(bss->cbss.capability & WLAN_CAPABILITY_IBSS))
282 goto put_bss;
283
284 /* different channel */
285 if (bss->cbss.channel != local->oper_channel)
286 goto put_bss;
287
288 /* different SSID */
289 if (elems->ssid_len != sdata->u.ibss.ssid_len ||
290 memcmp(elems->ssid, sdata->u.ibss.ssid,
291 sdata->u.ibss.ssid_len))
292 goto put_bss;
293
294 if (rx_status->flag & RX_FLAG_TSFT) {
295 /*
296 * For correct IBSS merging we need mactime; since mactime is
297 * defined as the time the first data symbol of the frame hits
298 * the PHY, and the timestamp of the beacon is defined as "the
299 * time that the data symbol containing the first bit of the
300 * timestamp is transmitted to the PHY plus the transmitting
301 * STA's delays through its local PHY from the MAC-PHY
302 * interface to its interface with the WM" (802.11 11.1.2)
303 * - equals the time this bit arrives at the receiver - we have
304 * to take into account the offset between the two.
305 *
306 * E.g. at 1 MBit that means mactime is 192 usec earlier
307 * (=24 bytes * 8 usecs/byte) than the beacon timestamp.
308 */
309 int rate;
310
311 if (rx_status->flag & RX_FLAG_HT)
312 rate = 65; /* TODO: HT rates */
313 else
314 rate = local->hw.wiphy->bands[band]->
315 bitrates[rx_status->rate_idx].bitrate;
316
317 rx_timestamp = rx_status->mactime + (24 * 8 * 10 / rate);
318 } else if (local && local->ops && local->ops->get_tsf)
319 /* second best option: get current TSF */
320 rx_timestamp = local->ops->get_tsf(local_to_hw(local));
321 else
322 /* can't merge without knowing the TSF */
323 rx_timestamp = -1LLU;
324
325#ifdef CONFIG_MAC80211_IBSS_DEBUG
326 printk(KERN_DEBUG "RX beacon SA=%pM BSSID="
327 "%pM TSF=0x%llx BCN=0x%llx diff=%lld @%lu\n",
328 mgmt->sa, mgmt->bssid,
329 (unsigned long long)rx_timestamp,
330 (unsigned long long)beacon_timestamp,
331 (unsigned long long)(rx_timestamp - beacon_timestamp),
332 jiffies);
333#endif
334
335 if (beacon_timestamp > rx_timestamp) {
336#ifdef CONFIG_MAC80211_IBSS_DEBUG
337 printk(KERN_DEBUG "%s: beacon TSF higher than "
338 "local TSF - IBSS merge with BSSID %pM\n",
339 sdata->dev->name, mgmt->bssid);
340#endif
341 ieee80211_sta_join_ibss(sdata, bss);
342 ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, supp_rates);
343 }
344
345 put_bss:
346 ieee80211_rx_bss_put(local, bss);
347}
348
349/*
350 * Add a new IBSS station, will also be called by the RX code when,
351 * in IBSS mode, receiving a frame from a yet-unknown station, hence
352 * must be callable in atomic context.
353 */
354struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
355 u8 *bssid,u8 *addr, u32 supp_rates)
356{
357 struct ieee80211_local *local = sdata->local;
358 struct sta_info *sta;
359 int band = local->hw.conf.channel->band;
360
361 /* TODO: Could consider removing the least recently used entry and
362 * allow new one to be added. */
363 if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
364 if (net_ratelimit()) {
365 printk(KERN_DEBUG "%s: No room for a new IBSS STA "
366 "entry %pM\n", sdata->dev->name, addr);
367 }
368 return NULL;
369 }
370
371 if (compare_ether_addr(bssid, sdata->u.ibss.bssid))
372 return NULL;
373
374#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
375 printk(KERN_DEBUG "%s: Adding new IBSS station %pM (dev=%s)\n",
376 wiphy_name(local->hw.wiphy), addr, sdata->dev->name);
377#endif
378
379 sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
380 if (!sta)
381 return NULL;
382
383 set_sta_flags(sta, WLAN_STA_AUTHORIZED);
384
385 /* make sure mandatory rates are always added */
386 sta->sta.supp_rates[band] = supp_rates |
387 ieee80211_mandatory_rates(local, band);
388
389 rate_control_rate_init(sta);
390
391 if (sta_info_insert(sta))
392 return NULL;
393
394 return sta;
395}
396
397static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data *sdata)
398{
399 struct ieee80211_local *local = sdata->local;
400 int active = 0;
401 struct sta_info *sta;
402
403 rcu_read_lock();
404
405 list_for_each_entry_rcu(sta, &local->sta_list, list) {
406 if (sta->sdata == sdata &&
407 time_after(sta->last_rx + IEEE80211_IBSS_MERGE_INTERVAL,
408 jiffies)) {
409 active++;
410 break;
411 }
412 }
413
414 rcu_read_unlock();
415
416 return active;
417}
418
419
420static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata)
421{
422 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
423
424 mod_timer(&ifibss->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
425
426 ieee80211_sta_expire(sdata, IEEE80211_IBSS_INACTIVITY_LIMIT);
427 if (ieee80211_sta_active_ibss(sdata))
428 return;
429
430 if ((ifibss->flags & IEEE80211_IBSS_BSSID_SET) &&
431 (!(ifibss->flags & IEEE80211_IBSS_AUTO_CHANNEL_SEL)))
432 return;
433
434 printk(KERN_DEBUG "%s: No active IBSS STAs - trying to scan for other "
435 "IBSS networks with same SSID (merge)\n", sdata->dev->name);
436
437 /* XXX maybe racy? */
438 if (sdata->local->scan_req)
439 return;
440
441 memcpy(sdata->local->int_scan_req.ssids[0].ssid,
442 ifibss->ssid, IEEE80211_MAX_SSID_LEN);
443 sdata->local->int_scan_req.ssids[0].ssid_len = ifibss->ssid_len;
444 ieee80211_request_scan(sdata, &sdata->local->int_scan_req);
445}
446
447static int ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata)
448{
449 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
450 struct ieee80211_local *local = sdata->local;
451 struct ieee80211_supported_band *sband;
452 u8 *pos;
453 u8 bssid[ETH_ALEN];
454 u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
455 u16 capability;
456 int i;
457
458 if (ifibss->flags & IEEE80211_IBSS_BSSID_SET) {
459 memcpy(bssid, ifibss->bssid, ETH_ALEN);
460 } else {
461 /* Generate random, not broadcast, locally administered BSSID. Mix in
462 * own MAC address to make sure that devices that do not have proper
463 * random number generator get different BSSID. */
464 get_random_bytes(bssid, ETH_ALEN);
465 for (i = 0; i < ETH_ALEN; i++)
466 bssid[i] ^= sdata->dev->dev_addr[i];
467 bssid[0] &= ~0x01;
468 bssid[0] |= 0x02;
469 }
470
471 printk(KERN_DEBUG "%s: Creating new IBSS network, BSSID %pM\n",
472 sdata->dev->name, bssid);
473
474 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
475
476 if (local->hw.conf.beacon_int == 0)
477 local->hw.conf.beacon_int = 100;
478
479 capability = WLAN_CAPABILITY_IBSS;
480
481 if (sdata->default_key)
482 capability |= WLAN_CAPABILITY_PRIVACY;
483 else
484 sdata->drop_unencrypted = 0;
485
486 pos = supp_rates;
487 for (i = 0; i < sband->n_bitrates; i++) {
488 int rate = sband->bitrates[i].bitrate;
489 *pos++ = (u8) (rate / 5);
490 }
491
492 return __ieee80211_sta_join_ibss(sdata,
493 bssid, local->hw.conf.beacon_int,
494 local->hw.conf.channel->center_freq,
495 sband->n_bitrates, supp_rates,
496 capability);
497}
498
499static int ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
500{
501 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
502 struct ieee80211_local *local = sdata->local;
503 struct ieee80211_bss *bss;
504 const u8 *bssid = NULL;
505 int active_ibss;
506
507 if (ifibss->ssid_len == 0)
508 return -EINVAL;
509
510 active_ibss = ieee80211_sta_active_ibss(sdata);
511#ifdef CONFIG_MAC80211_IBSS_DEBUG
512 printk(KERN_DEBUG "%s: sta_find_ibss (active_ibss=%d)\n",
513 sdata->dev->name, active_ibss);
514#endif /* CONFIG_MAC80211_IBSS_DEBUG */
515
516 if (active_ibss)
517 return 0;
518
519 if (ifibss->flags & IEEE80211_IBSS_BSSID_SET)
520 bssid = ifibss->bssid;
521 bss = (void *)cfg80211_get_bss(local->hw.wiphy, NULL, bssid,
522 ifibss->ssid, ifibss->ssid_len,
523 WLAN_CAPABILITY_IBSS,
524 WLAN_CAPABILITY_IBSS);
525
526#ifdef CONFIG_MAC80211_IBSS_DEBUG
527 if (bss)
528 printk(KERN_DEBUG " sta_find_ibss: selected %pM current "
529 "%pM\n", bss->cbss.bssid, ifibss->bssid);
530#endif /* CONFIG_MAC80211_IBSS_DEBUG */
531
532 if (bss &&
533 (!(ifibss->flags & IEEE80211_IBSS_PREV_BSSID_SET) ||
534 memcmp(ifibss->bssid, bss->cbss.bssid, ETH_ALEN))) {
535 int ret;
536
537 printk(KERN_DEBUG "%s: Selected IBSS BSSID %pM"
538 " based on configured SSID\n",
539 sdata->dev->name, bss->cbss.bssid);
540
541 ret = ieee80211_sta_join_ibss(sdata, bss);
542 ieee80211_rx_bss_put(local, bss);
543 return ret;
544 } else if (bss)
545 ieee80211_rx_bss_put(local, bss);
546
547#ifdef CONFIG_MAC80211_IBSS_DEBUG
548 printk(KERN_DEBUG " did not try to join ibss\n");
549#endif /* CONFIG_MAC80211_IBSS_DEBUG */
550
551 /* Selected IBSS not found in current scan results - try to scan */
552 if (ifibss->state == IEEE80211_IBSS_MLME_JOINED &&
553 !ieee80211_sta_active_ibss(sdata)) {
554 mod_timer(&ifibss->timer, jiffies +
555 IEEE80211_IBSS_MERGE_INTERVAL);
556 } else if (time_after(jiffies, local->last_scan_completed +
557 IEEE80211_SCAN_INTERVAL)) {
558 printk(KERN_DEBUG "%s: Trigger new scan to find an IBSS to "
559 "join\n", sdata->dev->name);
560
561 /* XXX maybe racy? */
562 if (local->scan_req)
563 return -EBUSY;
564
565 memcpy(local->int_scan_req.ssids[0].ssid,
566 ifibss->ssid, IEEE80211_MAX_SSID_LEN);
567 local->int_scan_req.ssids[0].ssid_len = ifibss->ssid_len;
568 return ieee80211_request_scan(sdata, &local->int_scan_req);
569 } else if (ifibss->state != IEEE80211_IBSS_MLME_JOINED) {
570 int interval = IEEE80211_SCAN_INTERVAL;
571
572 if (time_after(jiffies, ifibss->ibss_join_req +
573 IEEE80211_IBSS_JOIN_TIMEOUT)) {
574 if (!(local->oper_channel->flags &
575 IEEE80211_CHAN_NO_IBSS))
576 return ieee80211_sta_create_ibss(sdata);
577 printk(KERN_DEBUG "%s: IBSS not allowed on"
578 " %d MHz\n", sdata->dev->name,
579 local->hw.conf.channel->center_freq);
580
581 /* No IBSS found - decrease scan interval and continue
582 * scanning. */
583 interval = IEEE80211_SCAN_INTERVAL_SLOW;
584 }
585
586 ifibss->state = IEEE80211_IBSS_MLME_SEARCH;
587 mod_timer(&ifibss->timer, jiffies + interval);
588 return 0;
589 }
590
591 return 0;
592}
593
594static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata,
595 struct ieee80211_mgmt *mgmt,
596 size_t len)
597{
598 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
599 struct ieee80211_local *local = sdata->local;
600 int tx_last_beacon;
601 struct sk_buff *skb;
602 struct ieee80211_mgmt *resp;
603 u8 *pos, *end;
604
605 if (ifibss->state != IEEE80211_IBSS_MLME_JOINED ||
606 len < 24 + 2 || !ifibss->probe_resp)
607 return;
608
609 if (local->ops->tx_last_beacon)
610 tx_last_beacon = local->ops->tx_last_beacon(local_to_hw(local));
611 else
612 tx_last_beacon = 1;
613
614#ifdef CONFIG_MAC80211_IBSS_DEBUG
615 printk(KERN_DEBUG "%s: RX ProbeReq SA=%pM DA=%pM BSSID=%pM"
616 " (tx_last_beacon=%d)\n",
617 sdata->dev->name, mgmt->sa, mgmt->da,
618 mgmt->bssid, tx_last_beacon);
619#endif /* CONFIG_MAC80211_IBSS_DEBUG */
620
621 if (!tx_last_beacon)
622 return;
623
624 if (memcmp(mgmt->bssid, ifibss->bssid, ETH_ALEN) != 0 &&
625 memcmp(mgmt->bssid, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0)
626 return;
627
628 end = ((u8 *) mgmt) + len;
629 pos = mgmt->u.probe_req.variable;
630 if (pos[0] != WLAN_EID_SSID ||
631 pos + 2 + pos[1] > end) {
632#ifdef CONFIG_MAC80211_IBSS_DEBUG
633 printk(KERN_DEBUG "%s: Invalid SSID IE in ProbeReq "
634 "from %pM\n",
635 sdata->dev->name, mgmt->sa);
636#endif
637 return;
638 }
639 if (pos[1] != 0 &&
640 (pos[1] != ifibss->ssid_len ||
641 memcmp(pos + 2, ifibss->ssid, ifibss->ssid_len) != 0)) {
642 /* Ignore ProbeReq for foreign SSID */
643 return;
644 }
645
646 /* Reply with ProbeResp */
647 skb = skb_copy(ifibss->probe_resp, GFP_KERNEL);
648 if (!skb)
649 return;
650
651 resp = (struct ieee80211_mgmt *) skb->data;
652 memcpy(resp->da, mgmt->sa, ETH_ALEN);
653#ifdef CONFIG_MAC80211_IBSS_DEBUG
654 printk(KERN_DEBUG "%s: Sending ProbeResp to %pM\n",
655 sdata->dev->name, resp->da);
656#endif /* CONFIG_MAC80211_IBSS_DEBUG */
657 ieee80211_tx_skb(sdata, skb, 0);
658}
659
660static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
661 struct ieee80211_mgmt *mgmt,
662 size_t len,
663 struct ieee80211_rx_status *rx_status)
664{
665 size_t baselen;
666 struct ieee802_11_elems elems;
667
668 if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
669 return; /* ignore ProbeResp to foreign address */
670
671 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
672 if (baselen > len)
673 return;
674
675 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
676 &elems);
677
678 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
679}
680
681static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
682 struct ieee80211_mgmt *mgmt,
683 size_t len,
684 struct ieee80211_rx_status *rx_status)
685{
686 size_t baselen;
687 struct ieee802_11_elems elems;
688
689 /* Process beacon from the current BSS */
690 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
691 if (baselen > len)
692 return;
693
694 ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems);
695
696 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, true);
697}
698
699static void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
700 struct sk_buff *skb)
701{
702 struct ieee80211_rx_status *rx_status;
703 struct ieee80211_mgmt *mgmt;
704 u16 fc;
705
706 rx_status = (struct ieee80211_rx_status *) skb->cb;
707 mgmt = (struct ieee80211_mgmt *) skb->data;
708 fc = le16_to_cpu(mgmt->frame_control);
709
710 switch (fc & IEEE80211_FCTL_STYPE) {
711 case IEEE80211_STYPE_PROBE_REQ:
712 ieee80211_rx_mgmt_probe_req(sdata, mgmt, skb->len);
713 break;
714 case IEEE80211_STYPE_PROBE_RESP:
715 ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len,
716 rx_status);
717 break;
718 case IEEE80211_STYPE_BEACON:
719 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
720 rx_status);
721 break;
722 case IEEE80211_STYPE_AUTH:
723 ieee80211_rx_mgmt_auth_ibss(sdata, mgmt, skb->len);
724 break;
725 }
726
727 kfree_skb(skb);
728}
729
730static void ieee80211_ibss_work(struct work_struct *work)
731{
732 struct ieee80211_sub_if_data *sdata =
733 container_of(work, struct ieee80211_sub_if_data, u.ibss.work);
734 struct ieee80211_local *local = sdata->local;
735 struct ieee80211_if_ibss *ifibss;
736 struct sk_buff *skb;
737
738 if (!netif_running(sdata->dev))
739 return;
740
741 if (local->sw_scanning || local->hw_scanning)
742 return;
743
744 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_ADHOC))
745 return;
746 ifibss = &sdata->u.ibss;
747
748 while ((skb = skb_dequeue(&ifibss->skb_queue)))
749 ieee80211_ibss_rx_queued_mgmt(sdata, skb);
750
751 if (!test_and_clear_bit(IEEE80211_IBSS_REQ_RUN, &ifibss->request))
752 return;
753
754 switch (ifibss->state) {
755 case IEEE80211_IBSS_MLME_SEARCH:
756 ieee80211_sta_find_ibss(sdata);
757 break;
758 case IEEE80211_IBSS_MLME_JOINED:
759 ieee80211_sta_merge_ibss(sdata);
760 break;
761 default:
762 WARN_ON(1);
763 break;
764 }
765}
766
767static void ieee80211_ibss_timer(unsigned long data)
768{
769 struct ieee80211_sub_if_data *sdata =
770 (struct ieee80211_sub_if_data *) data;
771 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
772 struct ieee80211_local *local = sdata->local;
773
774 set_bit(IEEE80211_IBSS_REQ_RUN, &ifibss->request);
775 queue_work(local->hw.workqueue, &ifibss->work);
776}
777
778void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata)
779{
780 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
781
782 INIT_WORK(&ifibss->work, ieee80211_ibss_work);
783 setup_timer(&ifibss->timer, ieee80211_ibss_timer,
784 (unsigned long) sdata);
785 skb_queue_head_init(&ifibss->skb_queue);
786
787 ifibss->flags |= IEEE80211_IBSS_AUTO_BSSID_SEL |
788 IEEE80211_IBSS_AUTO_CHANNEL_SEL;
789}
790
791int ieee80211_ibss_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len)
792{
793 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
794
795 if (len > IEEE80211_MAX_SSID_LEN)
796 return -EINVAL;
797
798 if (ifibss->ssid_len != len || memcmp(ifibss->ssid, ssid, len) != 0) {
799 memset(ifibss->ssid, 0, sizeof(ifibss->ssid));
800 memcpy(ifibss->ssid, ssid, len);
801 ifibss->ssid_len = len;
802 }
803
804 ifibss->flags &= ~IEEE80211_IBSS_PREV_BSSID_SET;
805
806 if (len)
807 ifibss->flags |= IEEE80211_IBSS_SSID_SET;
808 else
809 ifibss->flags &= ~IEEE80211_IBSS_SSID_SET;
810
811 ifibss->ibss_join_req = jiffies;
812 ifibss->state = IEEE80211_IBSS_MLME_SEARCH;
813 return ieee80211_sta_find_ibss(sdata);
814}
815
816int ieee80211_ibss_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len)
817{
818 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
819
820 memcpy(ssid, ifibss->ssid, ifibss->ssid_len);
821 *len = ifibss->ssid_len;
822
823 return 0;
824}
825
826int ieee80211_ibss_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid)
827{
828 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
829
830 if (is_valid_ether_addr(bssid)) {
831 memcpy(ifibss->bssid, bssid, ETH_ALEN);
832 ifibss->flags |= IEEE80211_IBSS_BSSID_SET;
833 } else {
834 memset(ifibss->bssid, 0, ETH_ALEN);
835 ifibss->flags &= ~IEEE80211_IBSS_BSSID_SET;
836 }
837
838 if (netif_running(sdata->dev)) {
839 if (ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID)) {
840 printk(KERN_DEBUG "%s: Failed to config new BSSID to "
841 "the low-level driver\n", sdata->dev->name);
842 }
843 }
844
845 return ieee80211_ibss_set_ssid(sdata, ifibss->ssid, ifibss->ssid_len);
846}
847
848/* scan finished notification */
849void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local)
850{
851 struct ieee80211_sub_if_data *sdata = local->scan_sdata;
852 struct ieee80211_if_ibss *ifibss;
853
854 if (sdata && sdata->vif.type == NL80211_IFTYPE_ADHOC) {
855 ifibss = &sdata->u.ibss;
856 if ((!(ifibss->flags & IEEE80211_IBSS_PREV_BSSID_SET)) ||
857 !ieee80211_sta_active_ibss(sdata))
858 ieee80211_sta_find_ibss(sdata);
859 }
860}
861
862ieee80211_rx_result
863ieee80211_ibss_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
864 struct ieee80211_rx_status *rx_status)
865{
866 struct ieee80211_local *local = sdata->local;
867 struct ieee80211_mgmt *mgmt;
868 u16 fc;
869
870 if (skb->len < 24)
871 return RX_DROP_MONITOR;
872
873 mgmt = (struct ieee80211_mgmt *) skb->data;
874 fc = le16_to_cpu(mgmt->frame_control);
875
876 switch (fc & IEEE80211_FCTL_STYPE) {
877 case IEEE80211_STYPE_PROBE_RESP:
878 case IEEE80211_STYPE_BEACON:
879 memcpy(skb->cb, rx_status, sizeof(*rx_status));
880 case IEEE80211_STYPE_PROBE_REQ:
881 case IEEE80211_STYPE_AUTH:
882 skb_queue_tail(&sdata->u.ibss.skb_queue, skb);
883 queue_work(local->hw.workqueue, &sdata->u.ibss.work);
884 return RX_QUEUED;
885 }
886
887 return RX_DROP_MONITOR;
888}
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index e2bbd3f11797..27d56414019d 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -239,7 +239,7 @@ struct mesh_preq_queue {
239 u8 flags; 239 u8 flags;
240}; 240};
241 241
242/* flags used in struct ieee80211_if_sta.flags */ 242/* flags used in struct ieee80211_if_managed.flags */
243#define IEEE80211_STA_SSID_SET BIT(0) 243#define IEEE80211_STA_SSID_SET BIT(0)
244#define IEEE80211_STA_BSSID_SET BIT(1) 244#define IEEE80211_STA_BSSID_SET BIT(1)
245#define IEEE80211_STA_PREV_BSSID_SET BIT(2) 245#define IEEE80211_STA_PREV_BSSID_SET BIT(2)
@@ -262,31 +262,30 @@ struct mesh_preq_queue {
262#define IEEE80211_STA_REQ_AUTH 2 262#define IEEE80211_STA_REQ_AUTH 2
263#define IEEE80211_STA_REQ_RUN 3 263#define IEEE80211_STA_REQ_RUN 3
264 264
265/* STA/IBSS MLME states */
266enum ieee80211_sta_mlme_state {
267 IEEE80211_STA_MLME_DISABLED,
268 IEEE80211_STA_MLME_DIRECT_PROBE,
269 IEEE80211_STA_MLME_AUTHENTICATE,
270 IEEE80211_STA_MLME_ASSOCIATE,
271 IEEE80211_STA_MLME_ASSOCIATED,
272 IEEE80211_STA_MLME_IBSS_SEARCH,
273 IEEE80211_STA_MLME_IBSS_JOINED,
274};
275
276/* bitfield of allowed auth algs */ 265/* bitfield of allowed auth algs */
277#define IEEE80211_AUTH_ALG_OPEN BIT(0) 266#define IEEE80211_AUTH_ALG_OPEN BIT(0)
278#define IEEE80211_AUTH_ALG_SHARED_KEY BIT(1) 267#define IEEE80211_AUTH_ALG_SHARED_KEY BIT(1)
279#define IEEE80211_AUTH_ALG_LEAP BIT(2) 268#define IEEE80211_AUTH_ALG_LEAP BIT(2)
280 269
281struct ieee80211_if_sta { 270struct ieee80211_if_managed {
282 struct timer_list timer; 271 struct timer_list timer;
283 struct timer_list chswitch_timer; 272 struct timer_list chswitch_timer;
284 struct work_struct work; 273 struct work_struct work;
285 struct work_struct chswitch_work; 274 struct work_struct chswitch_work;
275
286 u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN]; 276 u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
277
287 u8 ssid[IEEE80211_MAX_SSID_LEN]; 278 u8 ssid[IEEE80211_MAX_SSID_LEN];
288 enum ieee80211_sta_mlme_state state;
289 size_t ssid_len; 279 size_t ssid_len;
280
281 enum {
282 IEEE80211_STA_MLME_DISABLED,
283 IEEE80211_STA_MLME_DIRECT_PROBE,
284 IEEE80211_STA_MLME_AUTHENTICATE,
285 IEEE80211_STA_MLME_ASSOCIATE,
286 IEEE80211_STA_MLME_ASSOCIATED,
287 } state;
288
290 u16 aid; 289 u16 aid;
291 u16 ap_capab, capab; 290 u16 ap_capab, capab;
292 u8 *extra_ie; /* to be added to the end of AssocReq */ 291 u8 *extra_ie; /* to be added to the end of AssocReq */
@@ -319,10 +318,6 @@ struct ieee80211_if_sta {
319 IEEE80211_MFP_REQUIRED 318 IEEE80211_MFP_REQUIRED
320 } mfp; /* management frame protection */ 319 } mfp; /* management frame protection */
321 320
322 unsigned long ibss_join_req;
323 struct sk_buff *probe_resp; /* ProbeResp template for IBSS */
324 u32 supp_rates_bits[IEEE80211_NUM_BANDS];
325
326 int wmm_last_param_set; 321 int wmm_last_param_set;
327 322
328 /* Extra IE data for management frames */ 323 /* Extra IE data for management frames */
@@ -342,6 +337,42 @@ struct ieee80211_if_sta {
342 size_t ie_disassoc_len; 337 size_t ie_disassoc_len;
343}; 338};
344 339
340enum ieee80211_ibss_flags {
341 IEEE80211_IBSS_AUTO_CHANNEL_SEL = BIT(0),
342 IEEE80211_IBSS_AUTO_BSSID_SEL = BIT(1),
343 IEEE80211_IBSS_BSSID_SET = BIT(2),
344 IEEE80211_IBSS_PREV_BSSID_SET = BIT(3),
345 IEEE80211_IBSS_SSID_SET = BIT(4),
346};
347
348enum ieee80211_ibss_request {
349 IEEE80211_IBSS_REQ_RUN = 0,
350};
351
352struct ieee80211_if_ibss {
353 struct timer_list timer;
354 struct work_struct work;
355
356 struct sk_buff_head skb_queue;
357
358 u8 ssid[IEEE80211_MAX_SSID_LEN];
359 u8 ssid_len;
360
361 u32 flags;
362
363 u8 bssid[ETH_ALEN];
364
365 unsigned long request;
366
367 unsigned long ibss_join_req;
368 struct sk_buff *probe_resp; /* ProbeResp template for IBSS */
369
370 enum {
371 IEEE80211_IBSS_MLME_SEARCH,
372 IEEE80211_IBSS_MLME_JOINED,
373 } state;
374};
375
345struct ieee80211_if_mesh { 376struct ieee80211_if_mesh {
346 struct work_struct work; 377 struct work_struct work;
347 struct timer_list housekeeping_timer; 378 struct timer_list housekeeping_timer;
@@ -445,7 +476,8 @@ struct ieee80211_sub_if_data {
445 struct ieee80211_if_ap ap; 476 struct ieee80211_if_ap ap;
446 struct ieee80211_if_wds wds; 477 struct ieee80211_if_wds wds;
447 struct ieee80211_if_vlan vlan; 478 struct ieee80211_if_vlan vlan;
448 struct ieee80211_if_sta sta; 479 struct ieee80211_if_managed mgd;
480 struct ieee80211_if_ibss ibss;
449#ifdef CONFIG_MAC80211_MESH 481#ifdef CONFIG_MAC80211_MESH
450 struct ieee80211_if_mesh mesh; 482 struct ieee80211_if_mesh mesh;
451#endif 483#endif
@@ -892,34 +924,39 @@ void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
892void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 924void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
893 u32 changed); 925 u32 changed);
894void ieee80211_configure_filter(struct ieee80211_local *local); 926void ieee80211_configure_filter(struct ieee80211_local *local);
927u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
895 928
896/* wireless extensions */ 929/* wireless extensions */
897extern const struct iw_handler_def ieee80211_iw_handler_def; 930extern const struct iw_handler_def ieee80211_iw_handler_def;
898 931
899/* STA/IBSS code */ 932/* STA code */
900void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata); 933void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);
901void ieee80211_scan_work(struct work_struct *work); 934ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,
902void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb, 935 struct sk_buff *skb,
903 struct ieee80211_rx_status *rx_status); 936 struct ieee80211_rx_status *rx_status);
904int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len); 937int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len);
905int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len); 938int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len);
906int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid); 939int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid);
907void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata, 940void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata);
908 struct ieee80211_if_sta *ifsta);
909struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
910 u8 *bssid, u8 *addr, u32 supp_rates);
911int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason); 941int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason);
912int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason); 942int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason);
913u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
914u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
915 struct ieee802_11_elems *elems,
916 enum ieee80211_band band);
917void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
918 u8 *ssid, size_t ssid_len);
919void ieee80211_send_pspoll(struct ieee80211_local *local, 943void ieee80211_send_pspoll(struct ieee80211_local *local,
920 struct ieee80211_sub_if_data *sdata); 944 struct ieee80211_sub_if_data *sdata);
921 945
946/* IBSS code */
947int ieee80211_ibss_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len);
948int ieee80211_ibss_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len);
949int ieee80211_ibss_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid);
950void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local);
951void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata);
952ieee80211_rx_result
953ieee80211_ibss_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
954 struct ieee80211_rx_status *rx_status);
955struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
956 u8 *bssid, u8 *addr, u32 supp_rates);
957
922/* scan/BSS handling */ 958/* scan/BSS handling */
959void ieee80211_scan_work(struct work_struct *work);
923int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata, 960int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
924 struct cfg80211_scan_request *req); 961 struct cfg80211_scan_request *req);
925int ieee80211_scan_results(struct ieee80211_local *local, 962int ieee80211_scan_results(struct ieee80211_local *local,
@@ -1051,6 +1088,20 @@ void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
1051void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue, 1088void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
1052 enum queue_stop_reason reason); 1089 enum queue_stop_reason reason);
1053 1090
1091void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1092 u16 transaction, u16 auth_alg,
1093 u8 *extra, size_t extra_len,
1094 const u8 *bssid, int encrypt);
1095void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
1096 u8 *ssid, size_t ssid_len);
1097
1098void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
1099 const size_t supp_rates_len,
1100 const u8 *supp_rates);
1101u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
1102 struct ieee802_11_elems *elems,
1103 enum ieee80211_band band);
1104
1054#ifdef CONFIG_MAC80211_NOINLINE 1105#ifdef CONFIG_MAC80211_NOINLINE
1055#define debug_noinline noinline 1106#define debug_noinline noinline
1056#else 1107#else
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index e8221180b6c1..2acc416e77e1 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -236,7 +236,10 @@ static int ieee80211_open(struct net_device *dev)
236 break; 236 break;
237 case NL80211_IFTYPE_STATION: 237 case NL80211_IFTYPE_STATION:
238 case NL80211_IFTYPE_ADHOC: 238 case NL80211_IFTYPE_ADHOC:
239 sdata->u.sta.flags &= ~IEEE80211_STA_PREV_BSSID_SET; 239 if (sdata->vif.type == NL80211_IFTYPE_STATION)
240 sdata->u.mgd.flags &= ~IEEE80211_STA_PREV_BSSID_SET;
241 else
242 sdata->u.ibss.flags &= ~IEEE80211_IBSS_PREV_BSSID_SET;
240 /* fall through */ 243 /* fall through */
241 default: 244 default:
242 conf.vif = &sdata->vif; 245 conf.vif = &sdata->vif;
@@ -321,11 +324,10 @@ static int ieee80211_open(struct net_device *dev)
321 * yet be effective. Trigger execution of ieee80211_sta_work 324 * yet be effective. Trigger execution of ieee80211_sta_work
322 * to fix this. 325 * to fix this.
323 */ 326 */
324 if (sdata->vif.type == NL80211_IFTYPE_STATION || 327 if (sdata->vif.type == NL80211_IFTYPE_STATION)
325 sdata->vif.type == NL80211_IFTYPE_ADHOC) { 328 queue_work(local->hw.workqueue, &sdata->u.mgd.work);
326 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 329 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
327 queue_work(local->hw.workqueue, &ifsta->work); 330 queue_work(local->hw.workqueue, &sdata->u.ibss.work);
328 }
329 331
330 netif_tx_start_all_queues(dev); 332 netif_tx_start_all_queues(dev);
331 333
@@ -452,15 +454,13 @@ static int ieee80211_stop(struct net_device *dev)
452 netif_addr_unlock_bh(local->mdev); 454 netif_addr_unlock_bh(local->mdev);
453 break; 455 break;
454 case NL80211_IFTYPE_STATION: 456 case NL80211_IFTYPE_STATION:
455 case NL80211_IFTYPE_ADHOC:
456 /* Announce that we are leaving the network. */ 457 /* Announce that we are leaving the network. */
457 if (sdata->u.sta.state != IEEE80211_STA_MLME_DISABLED) 458 if (sdata->u.mgd.state != IEEE80211_STA_MLME_DISABLED)
458 ieee80211_sta_deauthenticate(sdata, 459 ieee80211_sta_deauthenticate(sdata,
459 WLAN_REASON_DEAUTH_LEAVING); 460 WLAN_REASON_DEAUTH_LEAVING);
460 461 memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
461 memset(sdata->u.sta.bssid, 0, ETH_ALEN); 462 del_timer_sync(&sdata->u.mgd.chswitch_timer);
462 del_timer_sync(&sdata->u.sta.chswitch_timer); 463 del_timer_sync(&sdata->u.mgd.timer);
463 del_timer_sync(&sdata->u.sta.timer);
464 /* 464 /*
465 * If the timer fired while we waited for it, it will have 465 * If the timer fired while we waited for it, it will have
466 * requeued the work. Now the work will be running again 466 * requeued the work. Now the work will be running again
@@ -468,8 +468,8 @@ static int ieee80211_stop(struct net_device *dev)
468 * whether the interface is running, which, at this point, 468 * whether the interface is running, which, at this point,
469 * it no longer is. 469 * it no longer is.
470 */ 470 */
471 cancel_work_sync(&sdata->u.sta.work); 471 cancel_work_sync(&sdata->u.mgd.work);
472 cancel_work_sync(&sdata->u.sta.chswitch_work); 472 cancel_work_sync(&sdata->u.mgd.chswitch_work);
473 /* 473 /*
474 * When we get here, the interface is marked down. 474 * When we get here, the interface is marked down.
475 * Call synchronize_rcu() to wait for the RX path 475 * Call synchronize_rcu() to wait for the RX path
@@ -477,13 +477,22 @@ static int ieee80211_stop(struct net_device *dev)
477 * frames at this very time on another CPU. 477 * frames at this very time on another CPU.
478 */ 478 */
479 synchronize_rcu(); 479 synchronize_rcu();
480 skb_queue_purge(&sdata->u.sta.skb_queue); 480 skb_queue_purge(&sdata->u.mgd.skb_queue);
481 481
482 sdata->u.sta.flags &= ~(IEEE80211_STA_PRIVACY_INVOKED | 482 sdata->u.mgd.flags &= ~(IEEE80211_STA_PRIVACY_INVOKED |
483 IEEE80211_STA_TKIP_WEP_USED); 483 IEEE80211_STA_TKIP_WEP_USED);
484 kfree(sdata->u.sta.extra_ie); 484 kfree(sdata->u.mgd.extra_ie);
485 sdata->u.sta.extra_ie = NULL; 485 sdata->u.mgd.extra_ie = NULL;
486 sdata->u.sta.extra_ie_len = 0; 486 sdata->u.mgd.extra_ie_len = 0;
487 /* fall through */
488 case NL80211_IFTYPE_ADHOC:
489 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
490 memset(sdata->u.ibss.bssid, 0, ETH_ALEN);
491 del_timer_sync(&sdata->u.ibss.timer);
492 cancel_work_sync(&sdata->u.ibss.work);
493 synchronize_rcu();
494 skb_queue_purge(&sdata->u.ibss.skb_queue);
495 }
487 /* fall through */ 496 /* fall through */
488 case NL80211_IFTYPE_MESH_POINT: 497 case NL80211_IFTYPE_MESH_POINT:
489 if (ieee80211_vif_is_mesh(&sdata->vif)) { 498 if (ieee80211_vif_is_mesh(&sdata->vif)) {
@@ -629,19 +638,20 @@ static void ieee80211_teardown_sdata(struct net_device *dev)
629 if (ieee80211_vif_is_mesh(&sdata->vif)) 638 if (ieee80211_vif_is_mesh(&sdata->vif))
630 mesh_rmc_free(sdata); 639 mesh_rmc_free(sdata);
631 break; 640 break;
632 case NL80211_IFTYPE_STATION:
633 case NL80211_IFTYPE_ADHOC: 641 case NL80211_IFTYPE_ADHOC:
634 kfree(sdata->u.sta.extra_ie); 642 kfree_skb(sdata->u.ibss.probe_resp);
635 kfree(sdata->u.sta.assocreq_ies); 643 break;
636 kfree(sdata->u.sta.assocresp_ies); 644 case NL80211_IFTYPE_STATION:
637 kfree_skb(sdata->u.sta.probe_resp); 645 kfree(sdata->u.mgd.extra_ie);
638 kfree(sdata->u.sta.ie_probereq); 646 kfree(sdata->u.mgd.assocreq_ies);
639 kfree(sdata->u.sta.ie_proberesp); 647 kfree(sdata->u.mgd.assocresp_ies);
640 kfree(sdata->u.sta.ie_auth); 648 kfree(sdata->u.mgd.ie_probereq);
641 kfree(sdata->u.sta.ie_assocreq); 649 kfree(sdata->u.mgd.ie_proberesp);
642 kfree(sdata->u.sta.ie_reassocreq); 650 kfree(sdata->u.mgd.ie_auth);
643 kfree(sdata->u.sta.ie_deauth); 651 kfree(sdata->u.mgd.ie_assocreq);
644 kfree(sdata->u.sta.ie_disassoc); 652 kfree(sdata->u.mgd.ie_reassocreq);
653 kfree(sdata->u.mgd.ie_deauth);
654 kfree(sdata->u.mgd.ie_disassoc);
645 break; 655 break;
646 case NL80211_IFTYPE_WDS: 656 case NL80211_IFTYPE_WDS:
647 case NL80211_IFTYPE_AP_VLAN: 657 case NL80211_IFTYPE_AP_VLAN:
@@ -708,9 +718,11 @@ static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
708 INIT_LIST_HEAD(&sdata->u.ap.vlans); 718 INIT_LIST_HEAD(&sdata->u.ap.vlans);
709 break; 719 break;
710 case NL80211_IFTYPE_STATION: 720 case NL80211_IFTYPE_STATION:
711 case NL80211_IFTYPE_ADHOC:
712 ieee80211_sta_setup_sdata(sdata); 721 ieee80211_sta_setup_sdata(sdata);
713 break; 722 break;
723 case NL80211_IFTYPE_ADHOC:
724 ieee80211_ibss_setup_sdata(sdata);
725 break;
714 case NL80211_IFTYPE_MESH_POINT: 726 case NL80211_IFTYPE_MESH_POINT:
715 if (ieee80211_vif_is_mesh(&sdata->vif)) 727 if (ieee80211_vif_is_mesh(&sdata->vif))
716 ieee80211_mesh_init_sdata(sdata); 728 ieee80211_mesh_init_sdata(sdata);
diff --git a/net/mac80211/key.c b/net/mac80211/key.c
index 19b480de4bbc..687acf23054d 100644
--- a/net/mac80211/key.c
+++ b/net/mac80211/key.c
@@ -400,7 +400,7 @@ void ieee80211_key_link(struct ieee80211_key *key,
400 */ 400 */
401 401
402 /* same here, the AP could be using QoS */ 402 /* same here, the AP could be using QoS */
403 ap = sta_info_get(key->local, key->sdata->u.sta.bssid); 403 ap = sta_info_get(key->local, key->sdata->u.mgd.bssid);
404 if (ap) { 404 if (ap) {
405 if (test_sta_flags(ap, WLAN_STA_WME)) 405 if (test_sta_flags(ap, WLAN_STA_WME))
406 key->conf.flags |= 406 key->conf.flags |=
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index e9181981adcd..fce9d08986e9 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -169,9 +169,10 @@ int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed)
169 169
170 memset(&conf, 0, sizeof(conf)); 170 memset(&conf, 0, sizeof(conf));
171 171
172 if (sdata->vif.type == NL80211_IFTYPE_STATION || 172 if (sdata->vif.type == NL80211_IFTYPE_STATION)
173 sdata->vif.type == NL80211_IFTYPE_ADHOC) 173 conf.bssid = sdata->u.mgd.bssid;
174 conf.bssid = sdata->u.sta.bssid; 174 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
175 conf.bssid = sdata->u.ibss.bssid;
175 else if (sdata->vif.type == NL80211_IFTYPE_AP) 176 else if (sdata->vif.type == NL80211_IFTYPE_AP)
176 conf.bssid = sdata->dev->dev_addr; 177 conf.bssid = sdata->dev->dev_addr;
177 else if (ieee80211_vif_is_mesh(&sdata->vif)) { 178 else if (ieee80211_vif_is_mesh(&sdata->vif)) {
@@ -210,7 +211,7 @@ int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed)
210 !!rcu_dereference(sdata->u.ap.beacon); 211 !!rcu_dereference(sdata->u.ap.beacon);
211 break; 212 break;
212 case NL80211_IFTYPE_ADHOC: 213 case NL80211_IFTYPE_ADHOC:
213 conf.enable_beacon = !!sdata->u.sta.probe_resp; 214 conf.enable_beacon = !!sdata->u.ibss.probe_resp;
214 break; 215 break;
215 case NL80211_IFTYPE_MESH_POINT: 216 case NL80211_IFTYPE_MESH_POINT:
216 conf.enable_beacon = true; 217 conf.enable_beacon = true;
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index bf872cbba096..ec5a0900cba0 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -15,11 +15,8 @@
15#include <linux/if_ether.h> 15#include <linux/if_ether.h>
16#include <linux/skbuff.h> 16#include <linux/skbuff.h>
17#include <linux/if_arp.h> 17#include <linux/if_arp.h>
18#include <linux/wireless.h>
19#include <linux/random.h>
20#include <linux/etherdevice.h> 18#include <linux/etherdevice.h>
21#include <linux/rtnetlink.h> 19#include <linux/rtnetlink.h>
22#include <net/iw_handler.h>
23#include <net/mac80211.h> 20#include <net/mac80211.h>
24#include <asm/unaligned.h> 21#include <asm/unaligned.h>
25 22
@@ -35,15 +32,6 @@
35#define IEEE80211_MONITORING_INTERVAL (2 * HZ) 32#define IEEE80211_MONITORING_INTERVAL (2 * HZ)
36#define IEEE80211_PROBE_INTERVAL (60 * HZ) 33#define IEEE80211_PROBE_INTERVAL (60 * HZ)
37#define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ) 34#define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ)
38#define IEEE80211_SCAN_INTERVAL (2 * HZ)
39#define IEEE80211_SCAN_INTERVAL_SLOW (15 * HZ)
40#define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ)
41
42#define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
43#define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
44
45#define IEEE80211_IBSS_MAX_STA_ENTRIES 128
46
47 35
48/* utils */ 36/* utils */
49static int ecw2cw(int ecw) 37static int ecw2cw(int ecw)
@@ -92,43 +80,6 @@ static int ieee80211_compatible_rates(struct ieee80211_bss *bss,
92 return count; 80 return count;
93} 81}
94 82
95/* also used by mesh code */
96u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
97 struct ieee802_11_elems *elems,
98 enum ieee80211_band band)
99{
100 struct ieee80211_supported_band *sband;
101 struct ieee80211_rate *bitrates;
102 size_t num_rates;
103 u32 supp_rates;
104 int i, j;
105 sband = local->hw.wiphy->bands[band];
106
107 if (!sband) {
108 WARN_ON(1);
109 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
110 }
111
112 bitrates = sband->bitrates;
113 num_rates = sband->n_bitrates;
114 supp_rates = 0;
115 for (i = 0; i < elems->supp_rates_len +
116 elems->ext_supp_rates_len; i++) {
117 u8 rate = 0;
118 int own_rate;
119 if (i < elems->supp_rates_len)
120 rate = elems->supp_rates[i];
121 else if (elems->ext_supp_rates)
122 rate = elems->ext_supp_rates
123 [i - elems->supp_rates_len];
124 own_rate = 5 * (rate & 0x7f);
125 for (j = 0; j < num_rates; j++)
126 if (bitrates[j].bitrate == own_rate)
127 supp_rates |= BIT(j);
128 }
129 return supp_rates;
130}
131
132/* frame sending functions */ 83/* frame sending functions */
133 84
134static void add_extra_ies(struct sk_buff *skb, u8 *ies, size_t ies_len) 85static void add_extra_ies(struct sk_buff *skb, u8 *ies, size_t ies_len)
@@ -137,113 +88,9 @@ static void add_extra_ies(struct sk_buff *skb, u8 *ies, size_t ies_len)
137 memcpy(skb_put(skb, ies_len), ies, ies_len); 88 memcpy(skb_put(skb, ies_len), ies, ies_len);
138} 89}
139 90
140/* also used by scanning code */ 91static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
141void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
142 u8 *ssid, size_t ssid_len)
143{
144 struct ieee80211_local *local = sdata->local;
145 struct ieee80211_supported_band *sband;
146 struct sk_buff *skb;
147 struct ieee80211_mgmt *mgmt;
148 u8 *pos, *supp_rates, *esupp_rates = NULL;
149 int i;
150
151 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200 +
152 sdata->u.sta.ie_probereq_len);
153 if (!skb) {
154 printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
155 "request\n", sdata->dev->name);
156 return;
157 }
158 skb_reserve(skb, local->hw.extra_tx_headroom);
159
160 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
161 memset(mgmt, 0, 24);
162 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
163 IEEE80211_STYPE_PROBE_REQ);
164 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
165 if (dst) {
166 memcpy(mgmt->da, dst, ETH_ALEN);
167 memcpy(mgmt->bssid, dst, ETH_ALEN);
168 } else {
169 memset(mgmt->da, 0xff, ETH_ALEN);
170 memset(mgmt->bssid, 0xff, ETH_ALEN);
171 }
172 pos = skb_put(skb, 2 + ssid_len);
173 *pos++ = WLAN_EID_SSID;
174 *pos++ = ssid_len;
175 memcpy(pos, ssid, ssid_len);
176
177 supp_rates = skb_put(skb, 2);
178 supp_rates[0] = WLAN_EID_SUPP_RATES;
179 supp_rates[1] = 0;
180 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
181
182 for (i = 0; i < sband->n_bitrates; i++) {
183 struct ieee80211_rate *rate = &sband->bitrates[i];
184 if (esupp_rates) {
185 pos = skb_put(skb, 1);
186 esupp_rates[1]++;
187 } else if (supp_rates[1] == 8) {
188 esupp_rates = skb_put(skb, 3);
189 esupp_rates[0] = WLAN_EID_EXT_SUPP_RATES;
190 esupp_rates[1] = 1;
191 pos = &esupp_rates[2];
192 } else {
193 pos = skb_put(skb, 1);
194 supp_rates[1]++;
195 }
196 *pos = rate->bitrate / 5;
197 }
198
199 add_extra_ies(skb, sdata->u.sta.ie_probereq,
200 sdata->u.sta.ie_probereq_len);
201
202 ieee80211_tx_skb(sdata, skb, 0);
203}
204
205static void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
206 struct ieee80211_if_sta *ifsta,
207 int transaction, u8 *extra, size_t extra_len,
208 int encrypt)
209{
210 struct ieee80211_local *local = sdata->local;
211 struct sk_buff *skb;
212 struct ieee80211_mgmt *mgmt;
213
214 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
215 sizeof(*mgmt) + 6 + extra_len +
216 sdata->u.sta.ie_auth_len);
217 if (!skb) {
218 printk(KERN_DEBUG "%s: failed to allocate buffer for auth "
219 "frame\n", sdata->dev->name);
220 return;
221 }
222 skb_reserve(skb, local->hw.extra_tx_headroom);
223
224 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
225 memset(mgmt, 0, 24 + 6);
226 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
227 IEEE80211_STYPE_AUTH);
228 if (encrypt)
229 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
230 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN);
231 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
232 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
233 mgmt->u.auth.auth_alg = cpu_to_le16(ifsta->auth_alg);
234 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
235 ifsta->auth_transaction = transaction + 1;
236 mgmt->u.auth.status_code = cpu_to_le16(0);
237 if (extra)
238 memcpy(skb_put(skb, extra_len), extra, extra_len);
239 add_extra_ies(skb, sdata->u.sta.ie_auth, sdata->u.sta.ie_auth_len);
240
241 ieee80211_tx_skb(sdata, skb, encrypt);
242}
243
244static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
245 struct ieee80211_if_sta *ifsta)
246{ 92{
93 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
247 struct ieee80211_local *local = sdata->local; 94 struct ieee80211_local *local = sdata->local;
248 struct sk_buff *skb; 95 struct sk_buff *skb;
249 struct ieee80211_mgmt *mgmt; 96 struct ieee80211_mgmt *mgmt;
@@ -256,17 +103,17 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
256 u32 rates = 0; 103 u32 rates = 0;
257 size_t e_ies_len; 104 size_t e_ies_len;
258 105
259 if (ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) { 106 if (ifmgd->flags & IEEE80211_IBSS_PREV_BSSID_SET) {
260 e_ies = sdata->u.sta.ie_reassocreq; 107 e_ies = sdata->u.mgd.ie_reassocreq;
261 e_ies_len = sdata->u.sta.ie_reassocreq_len; 108 e_ies_len = sdata->u.mgd.ie_reassocreq_len;
262 } else { 109 } else {
263 e_ies = sdata->u.sta.ie_assocreq; 110 e_ies = sdata->u.mgd.ie_assocreq;
264 e_ies_len = sdata->u.sta.ie_assocreq_len; 111 e_ies_len = sdata->u.mgd.ie_assocreq_len;
265 } 112 }
266 113
267 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 114 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
268 sizeof(*mgmt) + 200 + ifsta->extra_ie_len + 115 sizeof(*mgmt) + 200 + ifmgd->extra_ie_len +
269 ifsta->ssid_len + e_ies_len); 116 ifmgd->ssid_len + e_ies_len);
270 if (!skb) { 117 if (!skb) {
271 printk(KERN_DEBUG "%s: failed to allocate buffer for assoc " 118 printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
272 "frame\n", sdata->dev->name); 119 "frame\n", sdata->dev->name);
@@ -276,7 +123,7 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
276 123
277 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 124 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
278 125
279 capab = ifsta->capab; 126 capab = ifmgd->capab;
280 127
281 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) { 128 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {
282 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE)) 129 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
@@ -285,9 +132,9 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
285 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE; 132 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
286 } 133 }
287 134
288 bss = ieee80211_rx_bss_get(local, ifsta->bssid, 135 bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
289 local->hw.conf.channel->center_freq, 136 local->hw.conf.channel->center_freq,
290 ifsta->ssid, ifsta->ssid_len); 137 ifmgd->ssid, ifmgd->ssid_len);
291 if (bss) { 138 if (bss) {
292 if (bss->cbss.capability & WLAN_CAPABILITY_PRIVACY) 139 if (bss->cbss.capability & WLAN_CAPABILITY_PRIVACY)
293 capab |= WLAN_CAPABILITY_PRIVACY; 140 capab |= WLAN_CAPABILITY_PRIVACY;
@@ -312,18 +159,18 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
312 159
313 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 160 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
314 memset(mgmt, 0, 24); 161 memset(mgmt, 0, 24);
315 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN); 162 memcpy(mgmt->da, ifmgd->bssid, ETH_ALEN);
316 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); 163 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
317 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN); 164 memcpy(mgmt->bssid, ifmgd->bssid, ETH_ALEN);
318 165
319 if (ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) { 166 if (ifmgd->flags & IEEE80211_STA_PREV_BSSID_SET) {
320 skb_put(skb, 10); 167 skb_put(skb, 10);
321 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 168 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
322 IEEE80211_STYPE_REASSOC_REQ); 169 IEEE80211_STYPE_REASSOC_REQ);
323 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab); 170 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
324 mgmt->u.reassoc_req.listen_interval = 171 mgmt->u.reassoc_req.listen_interval =
325 cpu_to_le16(local->hw.conf.listen_interval); 172 cpu_to_le16(local->hw.conf.listen_interval);
326 memcpy(mgmt->u.reassoc_req.current_ap, ifsta->prev_bssid, 173 memcpy(mgmt->u.reassoc_req.current_ap, ifmgd->prev_bssid,
327 ETH_ALEN); 174 ETH_ALEN);
328 } else { 175 } else {
329 skb_put(skb, 4); 176 skb_put(skb, 4);
@@ -335,10 +182,10 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
335 } 182 }
336 183
337 /* SSID */ 184 /* SSID */
338 ies = pos = skb_put(skb, 2 + ifsta->ssid_len); 185 ies = pos = skb_put(skb, 2 + ifmgd->ssid_len);
339 *pos++ = WLAN_EID_SSID; 186 *pos++ = WLAN_EID_SSID;
340 *pos++ = ifsta->ssid_len; 187 *pos++ = ifmgd->ssid_len;
341 memcpy(pos, ifsta->ssid, ifsta->ssid_len); 188 memcpy(pos, ifmgd->ssid, ifmgd->ssid_len);
342 189
343 /* add all rates which were marked to be used above */ 190 /* add all rates which were marked to be used above */
344 supp_rates_len = rates_len; 191 supp_rates_len = rates_len;
@@ -393,12 +240,12 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
393 } 240 }
394 } 241 }
395 242
396 if (ifsta->extra_ie) { 243 if (ifmgd->extra_ie) {
397 pos = skb_put(skb, ifsta->extra_ie_len); 244 pos = skb_put(skb, ifmgd->extra_ie_len);
398 memcpy(pos, ifsta->extra_ie, ifsta->extra_ie_len); 245 memcpy(pos, ifmgd->extra_ie, ifmgd->extra_ie_len);
399 } 246 }
400 247
401 if (wmm && (ifsta->flags & IEEE80211_STA_WMM_ENABLED)) { 248 if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED)) {
402 pos = skb_put(skb, 9); 249 pos = skb_put(skb, 9);
403 *pos++ = WLAN_EID_VENDOR_SPECIFIC; 250 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
404 *pos++ = 7; /* len */ 251 *pos++ = 7; /* len */
@@ -418,11 +265,11 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
418 * mode (11a/b/g) if any one of these ciphers is 265 * mode (11a/b/g) if any one of these ciphers is
419 * configured as pairwise. 266 * configured as pairwise.
420 */ 267 */
421 if (wmm && (ifsta->flags & IEEE80211_STA_WMM_ENABLED) && 268 if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
422 sband->ht_cap.ht_supported && 269 sband->ht_cap.ht_supported &&
423 (ht_ie = ieee80211_bss_get_ie(bss, WLAN_EID_HT_INFORMATION)) && 270 (ht_ie = ieee80211_bss_get_ie(bss, WLAN_EID_HT_INFORMATION)) &&
424 ht_ie[1] >= sizeof(struct ieee80211_ht_info) && 271 ht_ie[1] >= sizeof(struct ieee80211_ht_info) &&
425 (!(ifsta->flags & IEEE80211_STA_TKIP_WEP_USED))) { 272 (!(ifmgd->flags & IEEE80211_STA_TKIP_WEP_USED))) {
426 struct ieee80211_ht_info *ht_info = 273 struct ieee80211_ht_info *ht_info =
427 (struct ieee80211_ht_info *)(ht_ie + 2); 274 (struct ieee80211_ht_info *)(ht_ie + 2);
428 u16 cap = sband->ht_cap.cap; 275 u16 cap = sband->ht_cap.cap;
@@ -459,11 +306,11 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
459 306
460 add_extra_ies(skb, e_ies, e_ies_len); 307 add_extra_ies(skb, e_ies, e_ies_len);
461 308
462 kfree(ifsta->assocreq_ies); 309 kfree(ifmgd->assocreq_ies);
463 ifsta->assocreq_ies_len = (skb->data + skb->len) - ies; 310 ifmgd->assocreq_ies_len = (skb->data + skb->len) - ies;
464 ifsta->assocreq_ies = kmalloc(ifsta->assocreq_ies_len, GFP_KERNEL); 311 ifmgd->assocreq_ies = kmalloc(ifmgd->assocreq_ies_len, GFP_KERNEL);
465 if (ifsta->assocreq_ies) 312 if (ifmgd->assocreq_ies)
466 memcpy(ifsta->assocreq_ies, ies, ifsta->assocreq_ies_len); 313 memcpy(ifmgd->assocreq_ies, ies, ifmgd->assocreq_ies_len);
467 314
468 ieee80211_tx_skb(sdata, skb, 0); 315 ieee80211_tx_skb(sdata, skb, 0);
469} 316}
@@ -473,18 +320,18 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
473 u16 stype, u16 reason) 320 u16 stype, u16 reason)
474{ 321{
475 struct ieee80211_local *local = sdata->local; 322 struct ieee80211_local *local = sdata->local;
476 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 323 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
477 struct sk_buff *skb; 324 struct sk_buff *skb;
478 struct ieee80211_mgmt *mgmt; 325 struct ieee80211_mgmt *mgmt;
479 u8 *ies; 326 u8 *ies;
480 size_t ies_len; 327 size_t ies_len;
481 328
482 if (stype == IEEE80211_STYPE_DEAUTH) { 329 if (stype == IEEE80211_STYPE_DEAUTH) {
483 ies = sdata->u.sta.ie_deauth; 330 ies = sdata->u.mgd.ie_deauth;
484 ies_len = sdata->u.sta.ie_deauth_len; 331 ies_len = sdata->u.mgd.ie_deauth_len;
485 } else { 332 } else {
486 ies = sdata->u.sta.ie_disassoc; 333 ies = sdata->u.mgd.ie_disassoc;
487 ies_len = sdata->u.sta.ie_disassoc_len; 334 ies_len = sdata->u.mgd.ie_disassoc_len;
488 } 335 }
489 336
490 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 337 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) +
@@ -498,9 +345,9 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
498 345
499 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 346 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
500 memset(mgmt, 0, 24); 347 memset(mgmt, 0, 24);
501 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN); 348 memcpy(mgmt->da, ifmgd->bssid, ETH_ALEN);
502 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); 349 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
503 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN); 350 memcpy(mgmt->bssid, ifmgd->bssid, ETH_ALEN);
504 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype); 351 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
505 skb_put(skb, 2); 352 skb_put(skb, 2);
506 /* u.deauth.reason_code == u.disassoc.reason_code */ 353 /* u.deauth.reason_code == u.disassoc.reason_code */
@@ -508,13 +355,13 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
508 355
509 add_extra_ies(skb, ies, ies_len); 356 add_extra_ies(skb, ies, ies_len);
510 357
511 ieee80211_tx_skb(sdata, skb, ifsta->flags & IEEE80211_STA_MFP_ENABLED); 358 ieee80211_tx_skb(sdata, skb, ifmgd->flags & IEEE80211_STA_MFP_ENABLED);
512} 359}
513 360
514void ieee80211_send_pspoll(struct ieee80211_local *local, 361void ieee80211_send_pspoll(struct ieee80211_local *local,
515 struct ieee80211_sub_if_data *sdata) 362 struct ieee80211_sub_if_data *sdata)
516{ 363{
517 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 364 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
518 struct ieee80211_pspoll *pspoll; 365 struct ieee80211_pspoll *pspoll;
519 struct sk_buff *skb; 366 struct sk_buff *skb;
520 u16 fc; 367 u16 fc;
@@ -531,43 +378,20 @@ void ieee80211_send_pspoll(struct ieee80211_local *local,
531 memset(pspoll, 0, sizeof(*pspoll)); 378 memset(pspoll, 0, sizeof(*pspoll));
532 fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM; 379 fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM;
533 pspoll->frame_control = cpu_to_le16(fc); 380 pspoll->frame_control = cpu_to_le16(fc);
534 pspoll->aid = cpu_to_le16(ifsta->aid); 381 pspoll->aid = cpu_to_le16(ifmgd->aid);
535 382
536 /* aid in PS-Poll has its two MSBs each set to 1 */ 383 /* aid in PS-Poll has its two MSBs each set to 1 */
537 pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14); 384 pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);
538 385
539 memcpy(pspoll->bssid, ifsta->bssid, ETH_ALEN); 386 memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);
540 memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN); 387 memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN);
541 388
542 ieee80211_tx_skb(sdata, skb, 0); 389 ieee80211_tx_skb(sdata, skb, 0);
543
544 return;
545} 390}
546 391
547/* MLME */ 392/* MLME */
548static void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
549 const size_t supp_rates_len,
550 const u8 *supp_rates)
551{
552 struct ieee80211_local *local = sdata->local;
553 int i, have_higher_than_11mbit = 0;
554
555 /* cf. IEEE 802.11 9.2.12 */
556 for (i = 0; i < supp_rates_len; i++)
557 if ((supp_rates[i] & 0x7f) * 5 > 110)
558 have_higher_than_11mbit = 1;
559
560 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
561 have_higher_than_11mbit)
562 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
563 else
564 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
565
566 ieee80211_set_wmm_default(sdata);
567}
568
569static void ieee80211_sta_wmm_params(struct ieee80211_local *local, 393static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
570 struct ieee80211_if_sta *ifsta, 394 struct ieee80211_if_managed *ifmgd,
571 u8 *wmm_param, size_t wmm_param_len) 395 u8 *wmm_param, size_t wmm_param_len)
572{ 396{
573 struct ieee80211_tx_queue_params params; 397 struct ieee80211_tx_queue_params params;
@@ -575,7 +399,7 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
575 int count; 399 int count;
576 u8 *pos; 400 u8 *pos;
577 401
578 if (!(ifsta->flags & IEEE80211_STA_WMM_ENABLED)) 402 if (!(ifmgd->flags & IEEE80211_STA_WMM_ENABLED))
579 return; 403 return;
580 404
581 if (!wmm_param) 405 if (!wmm_param)
@@ -584,9 +408,9 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
584 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1) 408 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
585 return; 409 return;
586 count = wmm_param[6] & 0x0f; 410 count = wmm_param[6] & 0x0f;
587 if (count == ifsta->wmm_last_param_set) 411 if (count == ifmgd->wmm_last_param_set)
588 return; 412 return;
589 ifsta->wmm_last_param_set = count; 413 ifmgd->wmm_last_param_set = count;
590 414
591 pos = wmm_param + 8; 415 pos = wmm_param + 8;
592 left = wmm_param_len - 8; 416 left = wmm_param_len - 8;
@@ -671,7 +495,7 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
671{ 495{
672 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf; 496 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
673#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 497#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
674 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 498 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
675#endif 499#endif
676 u32 changed = 0; 500 u32 changed = 0;
677 bool use_protection; 501 bool use_protection;
@@ -694,7 +518,7 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
694 printk(KERN_DEBUG "%s: CTS protection %s (BSSID=%pM)\n", 518 printk(KERN_DEBUG "%s: CTS protection %s (BSSID=%pM)\n",
695 sdata->dev->name, 519 sdata->dev->name,
696 use_protection ? "enabled" : "disabled", 520 use_protection ? "enabled" : "disabled",
697 ifsta->bssid); 521 ifmgd->bssid);
698 } 522 }
699#endif 523#endif
700 bss_conf->use_cts_prot = use_protection; 524 bss_conf->use_cts_prot = use_protection;
@@ -708,7 +532,7 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
708 " (BSSID=%pM)\n", 532 " (BSSID=%pM)\n",
709 sdata->dev->name, 533 sdata->dev->name,
710 use_short_preamble ? "short" : "long", 534 use_short_preamble ? "short" : "long",
711 ifsta->bssid); 535 ifmgd->bssid);
712 } 536 }
713#endif 537#endif
714 bss_conf->use_short_preamble = use_short_preamble; 538 bss_conf->use_short_preamble = use_short_preamble;
@@ -722,7 +546,7 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
722 " (BSSID=%pM)\n", 546 " (BSSID=%pM)\n",
723 sdata->dev->name, 547 sdata->dev->name,
724 use_short_slot ? "short" : "long", 548 use_short_slot ? "short" : "long",
725 ifsta->bssid); 549 ifmgd->bssid);
726 } 550 }
727#endif 551#endif
728 bss_conf->use_short_slot = use_short_slot; 552 bss_conf->use_short_slot = use_short_slot;
@@ -732,57 +556,57 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
732 return changed; 556 return changed;
733} 557}
734 558
735static void ieee80211_sta_send_apinfo(struct ieee80211_sub_if_data *sdata, 559static void ieee80211_sta_send_apinfo(struct ieee80211_sub_if_data *sdata)
736 struct ieee80211_if_sta *ifsta)
737{ 560{
738 union iwreq_data wrqu; 561 union iwreq_data wrqu;
562
739 memset(&wrqu, 0, sizeof(wrqu)); 563 memset(&wrqu, 0, sizeof(wrqu));
740 if (ifsta->flags & IEEE80211_STA_ASSOCIATED) 564 if (sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED)
741 memcpy(wrqu.ap_addr.sa_data, sdata->u.sta.bssid, ETH_ALEN); 565 memcpy(wrqu.ap_addr.sa_data, sdata->u.mgd.bssid, ETH_ALEN);
742 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 566 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
743 wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL); 567 wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL);
744} 568}
745 569
746static void ieee80211_sta_send_associnfo(struct ieee80211_sub_if_data *sdata, 570static void ieee80211_sta_send_associnfo(struct ieee80211_sub_if_data *sdata)
747 struct ieee80211_if_sta *ifsta)
748{ 571{
572 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
749 char *buf; 573 char *buf;
750 size_t len; 574 size_t len;
751 int i; 575 int i;
752 union iwreq_data wrqu; 576 union iwreq_data wrqu;
753 577
754 if (!ifsta->assocreq_ies && !ifsta->assocresp_ies) 578 if (!ifmgd->assocreq_ies && !ifmgd->assocresp_ies)
755 return; 579 return;
756 580
757 buf = kmalloc(50 + 2 * (ifsta->assocreq_ies_len + 581 buf = kmalloc(50 + 2 * (ifmgd->assocreq_ies_len +
758 ifsta->assocresp_ies_len), GFP_KERNEL); 582 ifmgd->assocresp_ies_len), GFP_KERNEL);
759 if (!buf) 583 if (!buf)
760 return; 584 return;
761 585
762 len = sprintf(buf, "ASSOCINFO("); 586 len = sprintf(buf, "ASSOCINFO(");
763 if (ifsta->assocreq_ies) { 587 if (ifmgd->assocreq_ies) {
764 len += sprintf(buf + len, "ReqIEs="); 588 len += sprintf(buf + len, "ReqIEs=");
765 for (i = 0; i < ifsta->assocreq_ies_len; i++) { 589 for (i = 0; i < ifmgd->assocreq_ies_len; i++) {
766 len += sprintf(buf + len, "%02x", 590 len += sprintf(buf + len, "%02x",
767 ifsta->assocreq_ies[i]); 591 ifmgd->assocreq_ies[i]);
768 } 592 }
769 } 593 }
770 if (ifsta->assocresp_ies) { 594 if (ifmgd->assocresp_ies) {
771 if (ifsta->assocreq_ies) 595 if (ifmgd->assocreq_ies)
772 len += sprintf(buf + len, " "); 596 len += sprintf(buf + len, " ");
773 len += sprintf(buf + len, "RespIEs="); 597 len += sprintf(buf + len, "RespIEs=");
774 for (i = 0; i < ifsta->assocresp_ies_len; i++) { 598 for (i = 0; i < ifmgd->assocresp_ies_len; i++) {
775 len += sprintf(buf + len, "%02x", 599 len += sprintf(buf + len, "%02x",
776 ifsta->assocresp_ies[i]); 600 ifmgd->assocresp_ies[i]);
777 } 601 }
778 } 602 }
779 len += sprintf(buf + len, ")"); 603 len += sprintf(buf + len, ")");
780 604
781 if (len > IW_CUSTOM_MAX) { 605 if (len > IW_CUSTOM_MAX) {
782 len = sprintf(buf, "ASSOCRESPIE="); 606 len = sprintf(buf, "ASSOCRESPIE=");
783 for (i = 0; i < ifsta->assocresp_ies_len; i++) { 607 for (i = 0; i < ifmgd->assocresp_ies_len; i++) {
784 len += sprintf(buf + len, "%02x", 608 len += sprintf(buf + len, "%02x",
785 ifsta->assocresp_ies[i]); 609 ifmgd->assocresp_ies[i]);
786 } 610 }
787 } 611 }
788 612
@@ -797,20 +621,20 @@ static void ieee80211_sta_send_associnfo(struct ieee80211_sub_if_data *sdata,
797 621
798 622
799static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata, 623static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
800 struct ieee80211_if_sta *ifsta,
801 u32 bss_info_changed) 624 u32 bss_info_changed)
802{ 625{
626 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
803 struct ieee80211_local *local = sdata->local; 627 struct ieee80211_local *local = sdata->local;
804 struct ieee80211_conf *conf = &local_to_hw(local)->conf; 628 struct ieee80211_conf *conf = &local_to_hw(local)->conf;
805 629
806 struct ieee80211_bss *bss; 630 struct ieee80211_bss *bss;
807 631
808 bss_info_changed |= BSS_CHANGED_ASSOC; 632 bss_info_changed |= BSS_CHANGED_ASSOC;
809 ifsta->flags |= IEEE80211_STA_ASSOCIATED; 633 ifmgd->flags |= IEEE80211_STA_ASSOCIATED;
810 634
811 bss = ieee80211_rx_bss_get(local, ifsta->bssid, 635 bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
812 conf->channel->center_freq, 636 conf->channel->center_freq,
813 ifsta->ssid, ifsta->ssid_len); 637 ifmgd->ssid, ifmgd->ssid_len);
814 if (bss) { 638 if (bss) {
815 /* set timing information */ 639 /* set timing information */
816 sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval; 640 sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval;
@@ -823,11 +647,11 @@ static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
823 ieee80211_rx_bss_put(local, bss); 647 ieee80211_rx_bss_put(local, bss);
824 } 648 }
825 649
826 ifsta->flags |= IEEE80211_STA_PREV_BSSID_SET; 650 ifmgd->flags |= IEEE80211_STA_PREV_BSSID_SET;
827 memcpy(ifsta->prev_bssid, sdata->u.sta.bssid, ETH_ALEN); 651 memcpy(ifmgd->prev_bssid, sdata->u.mgd.bssid, ETH_ALEN);
828 ieee80211_sta_send_associnfo(sdata, ifsta); 652 ieee80211_sta_send_associnfo(sdata);
829 653
830 ifsta->last_probe = jiffies; 654 ifmgd->last_probe = jiffies;
831 ieee80211_led_assoc(local, 1); 655 ieee80211_led_assoc(local, 1);
832 656
833 sdata->vif.bss_conf.assoc = 1; 657 sdata->vif.bss_conf.assoc = 1;
@@ -856,70 +680,74 @@ static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
856 netif_tx_start_all_queues(sdata->dev); 680 netif_tx_start_all_queues(sdata->dev);
857 netif_carrier_on(sdata->dev); 681 netif_carrier_on(sdata->dev);
858 682
859 ieee80211_sta_send_apinfo(sdata, ifsta); 683 ieee80211_sta_send_apinfo(sdata);
860} 684}
861 685
862static void ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata, 686static void ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata)
863 struct ieee80211_if_sta *ifsta)
864{ 687{
865 ifsta->direct_probe_tries++; 688 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
866 if (ifsta->direct_probe_tries > IEEE80211_AUTH_MAX_TRIES) { 689
690 ifmgd->direct_probe_tries++;
691 if (ifmgd->direct_probe_tries > IEEE80211_AUTH_MAX_TRIES) {
867 printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n", 692 printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",
868 sdata->dev->name, ifsta->bssid); 693 sdata->dev->name, ifmgd->bssid);
869 ifsta->state = IEEE80211_STA_MLME_DISABLED; 694 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
870 ieee80211_sta_send_apinfo(sdata, ifsta); 695 ieee80211_sta_send_apinfo(sdata);
871 696
872 /* 697 /*
873 * Most likely AP is not in the range so remove the 698 * Most likely AP is not in the range so remove the
874 * bss information associated to the AP 699 * bss information associated to the AP
875 */ 700 */
876 ieee80211_rx_bss_remove(sdata, ifsta->bssid, 701 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
877 sdata->local->hw.conf.channel->center_freq, 702 sdata->local->hw.conf.channel->center_freq,
878 ifsta->ssid, ifsta->ssid_len); 703 ifmgd->ssid, ifmgd->ssid_len);
879 return; 704 return;
880 } 705 }
881 706
882 printk(KERN_DEBUG "%s: direct probe to AP %pM try %d\n", 707 printk(KERN_DEBUG "%s: direct probe to AP %pM try %d\n",
883 sdata->dev->name, ifsta->bssid, 708 sdata->dev->name, ifmgd->bssid,
884 ifsta->direct_probe_tries); 709 ifmgd->direct_probe_tries);
885 710
886 ifsta->state = IEEE80211_STA_MLME_DIRECT_PROBE; 711 ifmgd->state = IEEE80211_STA_MLME_DIRECT_PROBE;
887 712
888 set_bit(IEEE80211_STA_REQ_DIRECT_PROBE, &ifsta->request); 713 set_bit(IEEE80211_STA_REQ_DIRECT_PROBE, &ifmgd->request);
889 714
890 /* Direct probe is sent to broadcast address as some APs 715 /* Direct probe is sent to broadcast address as some APs
891 * will not answer to direct packet in unassociated state. 716 * will not answer to direct packet in unassociated state.
892 */ 717 */
893 ieee80211_send_probe_req(sdata, NULL, 718 ieee80211_send_probe_req(sdata, NULL,
894 ifsta->ssid, ifsta->ssid_len); 719 ifmgd->ssid, ifmgd->ssid_len);
895 720
896 mod_timer(&ifsta->timer, jiffies + IEEE80211_AUTH_TIMEOUT); 721 mod_timer(&ifmgd->timer, jiffies + IEEE80211_AUTH_TIMEOUT);
897} 722}
898 723
899 724
900static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata, 725static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata)
901 struct ieee80211_if_sta *ifsta)
902{ 726{
903 ifsta->auth_tries++; 727 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
904 if (ifsta->auth_tries > IEEE80211_AUTH_MAX_TRIES) { 728
729 ifmgd->auth_tries++;
730 if (ifmgd->auth_tries > IEEE80211_AUTH_MAX_TRIES) {
905 printk(KERN_DEBUG "%s: authentication with AP %pM" 731 printk(KERN_DEBUG "%s: authentication with AP %pM"
906 " timed out\n", 732 " timed out\n",
907 sdata->dev->name, ifsta->bssid); 733 sdata->dev->name, ifmgd->bssid);
908 ifsta->state = IEEE80211_STA_MLME_DISABLED; 734 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
909 ieee80211_sta_send_apinfo(sdata, ifsta); 735 ieee80211_sta_send_apinfo(sdata);
910 ieee80211_rx_bss_remove(sdata, ifsta->bssid, 736 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
911 sdata->local->hw.conf.channel->center_freq, 737 sdata->local->hw.conf.channel->center_freq,
912 ifsta->ssid, ifsta->ssid_len); 738 ifmgd->ssid, ifmgd->ssid_len);
913 return; 739 return;
914 } 740 }
915 741
916 ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE; 742 ifmgd->state = IEEE80211_STA_MLME_AUTHENTICATE;
917 printk(KERN_DEBUG "%s: authenticate with AP %pM\n", 743 printk(KERN_DEBUG "%s: authenticate with AP %pM\n",
918 sdata->dev->name, ifsta->bssid); 744 sdata->dev->name, ifmgd->bssid);
919 745
920 ieee80211_send_auth(sdata, ifsta, 1, NULL, 0, 0); 746 ieee80211_send_auth(sdata, 1, ifmgd->auth_alg, NULL, 0,
747 ifmgd->bssid, 0);
748 ifmgd->auth_transaction = 2;
921 749
922 mod_timer(&ifsta->timer, jiffies + IEEE80211_AUTH_TIMEOUT); 750 mod_timer(&ifmgd->timer, jiffies + IEEE80211_AUTH_TIMEOUT);
923} 751}
924 752
925/* 753/*
@@ -927,27 +755,28 @@ static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata,
927 * if self disconnected or a reason code from the AP. 755 * if self disconnected or a reason code from the AP.
928 */ 756 */
929static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata, 757static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
930 struct ieee80211_if_sta *ifsta, bool deauth, 758 bool deauth, bool self_disconnected,
931 bool self_disconnected, u16 reason) 759 u16 reason)
932{ 760{
761 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
933 struct ieee80211_local *local = sdata->local; 762 struct ieee80211_local *local = sdata->local;
934 struct sta_info *sta; 763 struct sta_info *sta;
935 u32 changed = 0, config_changed = 0; 764 u32 changed = 0, config_changed = 0;
936 765
937 rcu_read_lock(); 766 rcu_read_lock();
938 767
939 sta = sta_info_get(local, ifsta->bssid); 768 sta = sta_info_get(local, ifmgd->bssid);
940 if (!sta) { 769 if (!sta) {
941 rcu_read_unlock(); 770 rcu_read_unlock();
942 return; 771 return;
943 } 772 }
944 773
945 if (deauth) { 774 if (deauth) {
946 ifsta->direct_probe_tries = 0; 775 ifmgd->direct_probe_tries = 0;
947 ifsta->auth_tries = 0; 776 ifmgd->auth_tries = 0;
948 } 777 }
949 ifsta->assoc_scan_tries = 0; 778 ifmgd->assoc_scan_tries = 0;
950 ifsta->assoc_tries = 0; 779 ifmgd->assoc_tries = 0;
951 780
952 netif_tx_stop_all_queues(sdata->dev); 781 netif_tx_stop_all_queues(sdata->dev);
953 netif_carrier_off(sdata->dev); 782 netif_carrier_off(sdata->dev);
@@ -963,20 +792,20 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
963 IEEE80211_STYPE_DISASSOC, reason); 792 IEEE80211_STYPE_DISASSOC, reason);
964 } 793 }
965 794
966 ifsta->flags &= ~IEEE80211_STA_ASSOCIATED; 795 ifmgd->flags &= ~IEEE80211_STA_ASSOCIATED;
967 changed |= ieee80211_reset_erp_info(sdata); 796 changed |= ieee80211_reset_erp_info(sdata);
968 797
969 ieee80211_led_assoc(local, 0); 798 ieee80211_led_assoc(local, 0);
970 changed |= BSS_CHANGED_ASSOC; 799 changed |= BSS_CHANGED_ASSOC;
971 sdata->vif.bss_conf.assoc = false; 800 sdata->vif.bss_conf.assoc = false;
972 801
973 ieee80211_sta_send_apinfo(sdata, ifsta); 802 ieee80211_sta_send_apinfo(sdata);
974 803
975 if (self_disconnected || reason == WLAN_REASON_DISASSOC_STA_HAS_LEFT) { 804 if (self_disconnected || reason == WLAN_REASON_DISASSOC_STA_HAS_LEFT) {
976 ifsta->state = IEEE80211_STA_MLME_DISABLED; 805 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
977 ieee80211_rx_bss_remove(sdata, ifsta->bssid, 806 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
978 sdata->local->hw.conf.channel->center_freq, 807 sdata->local->hw.conf.channel->center_freq,
979 ifsta->ssid, ifsta->ssid_len); 808 ifmgd->ssid, ifmgd->ssid_len);
980 } 809 }
981 810
982 rcu_read_unlock(); 811 rcu_read_unlock();
@@ -999,7 +828,7 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
999 828
1000 rcu_read_lock(); 829 rcu_read_lock();
1001 830
1002 sta = sta_info_get(local, ifsta->bssid); 831 sta = sta_info_get(local, ifmgd->bssid);
1003 if (!sta) { 832 if (!sta) {
1004 rcu_read_unlock(); 833 rcu_read_unlock();
1005 return; 834 return;
@@ -1020,27 +849,27 @@ static int ieee80211_sta_wep_configured(struct ieee80211_sub_if_data *sdata)
1020 return 1; 849 return 1;
1021} 850}
1022 851
1023static int ieee80211_privacy_mismatch(struct ieee80211_sub_if_data *sdata, 852static int ieee80211_privacy_mismatch(struct ieee80211_sub_if_data *sdata)
1024 struct ieee80211_if_sta *ifsta)
1025{ 853{
854 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1026 struct ieee80211_local *local = sdata->local; 855 struct ieee80211_local *local = sdata->local;
1027 struct ieee80211_bss *bss; 856 struct ieee80211_bss *bss;
1028 int bss_privacy; 857 int bss_privacy;
1029 int wep_privacy; 858 int wep_privacy;
1030 int privacy_invoked; 859 int privacy_invoked;
1031 860
1032 if (!ifsta || (ifsta->flags & IEEE80211_STA_MIXED_CELL)) 861 if (!ifmgd || (ifmgd->flags & IEEE80211_STA_MIXED_CELL))
1033 return 0; 862 return 0;
1034 863
1035 bss = ieee80211_rx_bss_get(local, ifsta->bssid, 864 bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
1036 local->hw.conf.channel->center_freq, 865 local->hw.conf.channel->center_freq,
1037 ifsta->ssid, ifsta->ssid_len); 866 ifmgd->ssid, ifmgd->ssid_len);
1038 if (!bss) 867 if (!bss)
1039 return 0; 868 return 0;
1040 869
1041 bss_privacy = !!(bss->cbss.capability & WLAN_CAPABILITY_PRIVACY); 870 bss_privacy = !!(bss->cbss.capability & WLAN_CAPABILITY_PRIVACY);
1042 wep_privacy = !!ieee80211_sta_wep_configured(sdata); 871 wep_privacy = !!ieee80211_sta_wep_configured(sdata);
1043 privacy_invoked = !!(ifsta->flags & IEEE80211_STA_PRIVACY_INVOKED); 872 privacy_invoked = !!(ifmgd->flags & IEEE80211_STA_PRIVACY_INVOKED);
1044 873
1045 ieee80211_rx_bss_put(local, bss); 874 ieee80211_rx_bss_put(local, bss);
1046 875
@@ -1050,41 +879,42 @@ static int ieee80211_privacy_mismatch(struct ieee80211_sub_if_data *sdata,
1050 return 1; 879 return 1;
1051} 880}
1052 881
1053static void ieee80211_associate(struct ieee80211_sub_if_data *sdata, 882static void ieee80211_associate(struct ieee80211_sub_if_data *sdata)
1054 struct ieee80211_if_sta *ifsta)
1055{ 883{
1056 ifsta->assoc_tries++; 884 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1057 if (ifsta->assoc_tries > IEEE80211_ASSOC_MAX_TRIES) { 885
886 ifmgd->assoc_tries++;
887 if (ifmgd->assoc_tries > IEEE80211_ASSOC_MAX_TRIES) {
1058 printk(KERN_DEBUG "%s: association with AP %pM" 888 printk(KERN_DEBUG "%s: association with AP %pM"
1059 " timed out\n", 889 " timed out\n",
1060 sdata->dev->name, ifsta->bssid); 890 sdata->dev->name, ifmgd->bssid);
1061 ifsta->state = IEEE80211_STA_MLME_DISABLED; 891 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
1062 ieee80211_sta_send_apinfo(sdata, ifsta); 892 ieee80211_sta_send_apinfo(sdata);
1063 ieee80211_rx_bss_remove(sdata, ifsta->bssid, 893 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
1064 sdata->local->hw.conf.channel->center_freq, 894 sdata->local->hw.conf.channel->center_freq,
1065 ifsta->ssid, ifsta->ssid_len); 895 ifmgd->ssid, ifmgd->ssid_len);
1066 return; 896 return;
1067 } 897 }
1068 898
1069 ifsta->state = IEEE80211_STA_MLME_ASSOCIATE; 899 ifmgd->state = IEEE80211_STA_MLME_ASSOCIATE;
1070 printk(KERN_DEBUG "%s: associate with AP %pM\n", 900 printk(KERN_DEBUG "%s: associate with AP %pM\n",
1071 sdata->dev->name, ifsta->bssid); 901 sdata->dev->name, ifmgd->bssid);
1072 if (ieee80211_privacy_mismatch(sdata, ifsta)) { 902 if (ieee80211_privacy_mismatch(sdata)) {
1073 printk(KERN_DEBUG "%s: mismatch in privacy configuration and " 903 printk(KERN_DEBUG "%s: mismatch in privacy configuration and "
1074 "mixed-cell disabled - abort association\n", sdata->dev->name); 904 "mixed-cell disabled - abort association\n", sdata->dev->name);
1075 ifsta->state = IEEE80211_STA_MLME_DISABLED; 905 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
1076 return; 906 return;
1077 } 907 }
1078 908
1079 ieee80211_send_assoc(sdata, ifsta); 909 ieee80211_send_assoc(sdata);
1080 910
1081 mod_timer(&ifsta->timer, jiffies + IEEE80211_ASSOC_TIMEOUT); 911 mod_timer(&ifmgd->timer, jiffies + IEEE80211_ASSOC_TIMEOUT);
1082} 912}
1083 913
1084 914
1085static void ieee80211_associated(struct ieee80211_sub_if_data *sdata, 915static void ieee80211_associated(struct ieee80211_sub_if_data *sdata)
1086 struct ieee80211_if_sta *ifsta)
1087{ 916{
917 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1088 struct ieee80211_local *local = sdata->local; 918 struct ieee80211_local *local = sdata->local;
1089 struct sta_info *sta; 919 struct sta_info *sta;
1090 int disassoc; 920 int disassoc;
@@ -1094,38 +924,38 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata,
1094 * for better APs. */ 924 * for better APs. */
1095 /* TODO: remove expired BSSes */ 925 /* TODO: remove expired BSSes */
1096 926
1097 ifsta->state = IEEE80211_STA_MLME_ASSOCIATED; 927 ifmgd->state = IEEE80211_STA_MLME_ASSOCIATED;
1098 928
1099 rcu_read_lock(); 929 rcu_read_lock();
1100 930
1101 sta = sta_info_get(local, ifsta->bssid); 931 sta = sta_info_get(local, ifmgd->bssid);
1102 if (!sta) { 932 if (!sta) {
1103 printk(KERN_DEBUG "%s: No STA entry for own AP %pM\n", 933 printk(KERN_DEBUG "%s: No STA entry for own AP %pM\n",
1104 sdata->dev->name, ifsta->bssid); 934 sdata->dev->name, ifmgd->bssid);
1105 disassoc = 1; 935 disassoc = 1;
1106 } else { 936 } else {
1107 disassoc = 0; 937 disassoc = 0;
1108 if (time_after(jiffies, 938 if (time_after(jiffies,
1109 sta->last_rx + IEEE80211_MONITORING_INTERVAL)) { 939 sta->last_rx + IEEE80211_MONITORING_INTERVAL)) {
1110 if (ifsta->flags & IEEE80211_STA_PROBEREQ_POLL) { 940 if (ifmgd->flags & IEEE80211_STA_PROBEREQ_POLL) {
1111 printk(KERN_DEBUG "%s: No ProbeResp from " 941 printk(KERN_DEBUG "%s: No ProbeResp from "
1112 "current AP %pM - assume out of " 942 "current AP %pM - assume out of "
1113 "range\n", 943 "range\n",
1114 sdata->dev->name, ifsta->bssid); 944 sdata->dev->name, ifmgd->bssid);
1115 disassoc = 1; 945 disassoc = 1;
1116 } else 946 } else
1117 ieee80211_send_probe_req(sdata, ifsta->bssid, 947 ieee80211_send_probe_req(sdata, ifmgd->bssid,
1118 ifsta->ssid, 948 ifmgd->ssid,
1119 ifsta->ssid_len); 949 ifmgd->ssid_len);
1120 ifsta->flags ^= IEEE80211_STA_PROBEREQ_POLL; 950 ifmgd->flags ^= IEEE80211_STA_PROBEREQ_POLL;
1121 } else { 951 } else {
1122 ifsta->flags &= ~IEEE80211_STA_PROBEREQ_POLL; 952 ifmgd->flags &= ~IEEE80211_STA_PROBEREQ_POLL;
1123 if (time_after(jiffies, ifsta->last_probe + 953 if (time_after(jiffies, ifmgd->last_probe +
1124 IEEE80211_PROBE_INTERVAL)) { 954 IEEE80211_PROBE_INTERVAL)) {
1125 ifsta->last_probe = jiffies; 955 ifmgd->last_probe = jiffies;
1126 ieee80211_send_probe_req(sdata, ifsta->bssid, 956 ieee80211_send_probe_req(sdata, ifmgd->bssid,
1127 ifsta->ssid, 957 ifmgd->ssid,
1128 ifsta->ssid_len); 958 ifmgd->ssid_len);
1129 } 959 }
1130 } 960 }
1131 } 961 }
@@ -1133,25 +963,25 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata,
1133 rcu_read_unlock(); 963 rcu_read_unlock();
1134 964
1135 if (disassoc) 965 if (disassoc)
1136 ieee80211_set_disassoc(sdata, ifsta, true, true, 966 ieee80211_set_disassoc(sdata, true, true,
1137 WLAN_REASON_PREV_AUTH_NOT_VALID); 967 WLAN_REASON_PREV_AUTH_NOT_VALID);
1138 else 968 else
1139 mod_timer(&ifsta->timer, jiffies + 969 mod_timer(&ifmgd->timer, jiffies +
1140 IEEE80211_MONITORING_INTERVAL); 970 IEEE80211_MONITORING_INTERVAL);
1141} 971}
1142 972
1143 973
1144static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata, 974static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata)
1145 struct ieee80211_if_sta *ifsta)
1146{ 975{
976 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
977
1147 printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name); 978 printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);
1148 ifsta->flags |= IEEE80211_STA_AUTHENTICATED; 979 ifmgd->flags |= IEEE80211_STA_AUTHENTICATED;
1149 ieee80211_associate(sdata, ifsta); 980 ieee80211_associate(sdata);
1150} 981}
1151 982
1152 983
1153static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata, 984static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
1154 struct ieee80211_if_sta *ifsta,
1155 struct ieee80211_mgmt *mgmt, 985 struct ieee80211_mgmt *mgmt,
1156 size_t len) 986 size_t len)
1157{ 987{
@@ -1162,59 +992,37 @@ static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
1162 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems); 992 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1163 if (!elems.challenge) 993 if (!elems.challenge)
1164 return; 994 return;
1165 ieee80211_send_auth(sdata, ifsta, 3, elems.challenge - 2, 995 ieee80211_send_auth(sdata, 3, sdata->u.mgd.auth_alg,
1166 elems.challenge_len + 2, 1); 996 elems.challenge - 2, elems.challenge_len + 2,
1167} 997 sdata->u.mgd.bssid, 1);
1168 998 sdata->u.mgd.auth_transaction = 4;
1169static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data *sdata,
1170 struct ieee80211_if_sta *ifsta,
1171 struct ieee80211_mgmt *mgmt,
1172 size_t len)
1173{
1174 u16 auth_alg, auth_transaction, status_code;
1175
1176 if (len < 24 + 6)
1177 return;
1178
1179 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
1180 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
1181 status_code = le16_to_cpu(mgmt->u.auth.status_code);
1182
1183 /*
1184 * IEEE 802.11 standard does not require authentication in IBSS
1185 * networks and most implementations do not seem to use it.
1186 * However, try to reply to authentication attempts if someone
1187 * has actually implemented this.
1188 */
1189 if (auth_alg == WLAN_AUTH_OPEN && auth_transaction == 1)
1190 ieee80211_send_auth(sdata, ifsta, 2, NULL, 0, 0);
1191} 999}
1192 1000
1193static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata, 1001static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1194 struct ieee80211_if_sta *ifsta,
1195 struct ieee80211_mgmt *mgmt, 1002 struct ieee80211_mgmt *mgmt,
1196 size_t len) 1003 size_t len)
1197{ 1004{
1005 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1198 u16 auth_alg, auth_transaction, status_code; 1006 u16 auth_alg, auth_transaction, status_code;
1199 1007
1200 if (ifsta->state != IEEE80211_STA_MLME_AUTHENTICATE) 1008 if (ifmgd->state != IEEE80211_STA_MLME_AUTHENTICATE)
1201 return; 1009 return;
1202 1010
1203 if (len < 24 + 6) 1011 if (len < 24 + 6)
1204 return; 1012 return;
1205 1013
1206 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0) 1014 if (memcmp(ifmgd->bssid, mgmt->sa, ETH_ALEN) != 0)
1207 return; 1015 return;
1208 1016
1209 if (memcmp(ifsta->bssid, mgmt->bssid, ETH_ALEN) != 0) 1017 if (memcmp(ifmgd->bssid, mgmt->bssid, ETH_ALEN) != 0)
1210 return; 1018 return;
1211 1019
1212 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg); 1020 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
1213 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction); 1021 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
1214 status_code = le16_to_cpu(mgmt->u.auth.status_code); 1022 status_code = le16_to_cpu(mgmt->u.auth.status_code);
1215 1023
1216 if (auth_alg != ifsta->auth_alg || 1024 if (auth_alg != ifmgd->auth_alg ||
1217 auth_transaction != ifsta->auth_transaction) 1025 auth_transaction != ifmgd->auth_transaction)
1218 return; 1026 return;
1219 1027
1220 if (status_code != WLAN_STATUS_SUCCESS) { 1028 if (status_code != WLAN_STATUS_SUCCESS) {
@@ -1223,15 +1031,15 @@ static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1223 const int num_algs = ARRAY_SIZE(algs); 1031 const int num_algs = ARRAY_SIZE(algs);
1224 int i, pos; 1032 int i, pos;
1225 algs[0] = algs[1] = algs[2] = 0xff; 1033 algs[0] = algs[1] = algs[2] = 0xff;
1226 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_OPEN) 1034 if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_OPEN)
1227 algs[0] = WLAN_AUTH_OPEN; 1035 algs[0] = WLAN_AUTH_OPEN;
1228 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY) 1036 if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY)
1229 algs[1] = WLAN_AUTH_SHARED_KEY; 1037 algs[1] = WLAN_AUTH_SHARED_KEY;
1230 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_LEAP) 1038 if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_LEAP)
1231 algs[2] = WLAN_AUTH_LEAP; 1039 algs[2] = WLAN_AUTH_LEAP;
1232 if (ifsta->auth_alg == WLAN_AUTH_OPEN) 1040 if (ifmgd->auth_alg == WLAN_AUTH_OPEN)
1233 pos = 0; 1041 pos = 0;
1234 else if (ifsta->auth_alg == WLAN_AUTH_SHARED_KEY) 1042 else if (ifmgd->auth_alg == WLAN_AUTH_SHARED_KEY)
1235 pos = 1; 1043 pos = 1;
1236 else 1044 else
1237 pos = 2; 1045 pos = 2;
@@ -1239,101 +1047,101 @@ static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1239 pos++; 1047 pos++;
1240 if (pos >= num_algs) 1048 if (pos >= num_algs)
1241 pos = 0; 1049 pos = 0;
1242 if (algs[pos] == ifsta->auth_alg || 1050 if (algs[pos] == ifmgd->auth_alg ||
1243 algs[pos] == 0xff) 1051 algs[pos] == 0xff)
1244 continue; 1052 continue;
1245 if (algs[pos] == WLAN_AUTH_SHARED_KEY && 1053 if (algs[pos] == WLAN_AUTH_SHARED_KEY &&
1246 !ieee80211_sta_wep_configured(sdata)) 1054 !ieee80211_sta_wep_configured(sdata))
1247 continue; 1055 continue;
1248 ifsta->auth_alg = algs[pos]; 1056 ifmgd->auth_alg = algs[pos];
1249 break; 1057 break;
1250 } 1058 }
1251 } 1059 }
1252 return; 1060 return;
1253 } 1061 }
1254 1062
1255 switch (ifsta->auth_alg) { 1063 switch (ifmgd->auth_alg) {
1256 case WLAN_AUTH_OPEN: 1064 case WLAN_AUTH_OPEN:
1257 case WLAN_AUTH_LEAP: 1065 case WLAN_AUTH_LEAP:
1258 ieee80211_auth_completed(sdata, ifsta); 1066 ieee80211_auth_completed(sdata);
1259 break; 1067 break;
1260 case WLAN_AUTH_SHARED_KEY: 1068 case WLAN_AUTH_SHARED_KEY:
1261 if (ifsta->auth_transaction == 4) 1069 if (ifmgd->auth_transaction == 4)
1262 ieee80211_auth_completed(sdata, ifsta); 1070 ieee80211_auth_completed(sdata);
1263 else 1071 else
1264 ieee80211_auth_challenge(sdata, ifsta, mgmt, len); 1072 ieee80211_auth_challenge(sdata, mgmt, len);
1265 break; 1073 break;
1266 } 1074 }
1267} 1075}
1268 1076
1269 1077
1270static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata, 1078static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
1271 struct ieee80211_if_sta *ifsta,
1272 struct ieee80211_mgmt *mgmt, 1079 struct ieee80211_mgmt *mgmt,
1273 size_t len) 1080 size_t len)
1274{ 1081{
1082 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1275 u16 reason_code; 1083 u16 reason_code;
1276 1084
1277 if (len < 24 + 2) 1085 if (len < 24 + 2)
1278 return; 1086 return;
1279 1087
1280 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN)) 1088 if (memcmp(ifmgd->bssid, mgmt->sa, ETH_ALEN))
1281 return; 1089 return;
1282 1090
1283 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code); 1091 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
1284 1092
1285 if (ifsta->flags & IEEE80211_STA_AUTHENTICATED) 1093 if (ifmgd->flags & IEEE80211_STA_AUTHENTICATED)
1286 printk(KERN_DEBUG "%s: deauthenticated (Reason: %u)\n", 1094 printk(KERN_DEBUG "%s: deauthenticated (Reason: %u)\n",
1287 sdata->dev->name, reason_code); 1095 sdata->dev->name, reason_code);
1288 1096
1289 if (ifsta->state == IEEE80211_STA_MLME_AUTHENTICATE || 1097 if (ifmgd->state == IEEE80211_STA_MLME_AUTHENTICATE ||
1290 ifsta->state == IEEE80211_STA_MLME_ASSOCIATE || 1098 ifmgd->state == IEEE80211_STA_MLME_ASSOCIATE ||
1291 ifsta->state == IEEE80211_STA_MLME_ASSOCIATED) { 1099 ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED) {
1292 ifsta->state = IEEE80211_STA_MLME_DIRECT_PROBE; 1100 ifmgd->state = IEEE80211_STA_MLME_DIRECT_PROBE;
1293 mod_timer(&ifsta->timer, jiffies + 1101 mod_timer(&ifmgd->timer, jiffies +
1294 IEEE80211_RETRY_AUTH_INTERVAL); 1102 IEEE80211_RETRY_AUTH_INTERVAL);
1295 } 1103 }
1296 1104
1297 ieee80211_set_disassoc(sdata, ifsta, true, false, 0); 1105 ieee80211_set_disassoc(sdata, true, false, 0);
1298 ifsta->flags &= ~IEEE80211_STA_AUTHENTICATED; 1106 ifmgd->flags &= ~IEEE80211_STA_AUTHENTICATED;
1299} 1107}
1300 1108
1301 1109
1302static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata, 1110static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
1303 struct ieee80211_if_sta *ifsta,
1304 struct ieee80211_mgmt *mgmt, 1111 struct ieee80211_mgmt *mgmt,
1305 size_t len) 1112 size_t len)
1306{ 1113{
1114 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1307 u16 reason_code; 1115 u16 reason_code;
1308 1116
1309 if (len < 24 + 2) 1117 if (len < 24 + 2)
1310 return; 1118 return;
1311 1119
1312 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN)) 1120 if (memcmp(ifmgd->bssid, mgmt->sa, ETH_ALEN))
1313 return; 1121 return;
1314 1122
1315 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code); 1123 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
1316 1124
1317 if (ifsta->flags & IEEE80211_STA_ASSOCIATED) 1125 if (ifmgd->flags & IEEE80211_STA_ASSOCIATED)
1318 printk(KERN_DEBUG "%s: disassociated (Reason: %u)\n", 1126 printk(KERN_DEBUG "%s: disassociated (Reason: %u)\n",
1319 sdata->dev->name, reason_code); 1127 sdata->dev->name, reason_code);
1320 1128
1321 if (ifsta->state == IEEE80211_STA_MLME_ASSOCIATED) { 1129 if (ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED) {
1322 ifsta->state = IEEE80211_STA_MLME_ASSOCIATE; 1130 ifmgd->state = IEEE80211_STA_MLME_ASSOCIATE;
1323 mod_timer(&ifsta->timer, jiffies + 1131 mod_timer(&ifmgd->timer, jiffies +
1324 IEEE80211_RETRY_AUTH_INTERVAL); 1132 IEEE80211_RETRY_AUTH_INTERVAL);
1325 } 1133 }
1326 1134
1327 ieee80211_set_disassoc(sdata, ifsta, false, false, reason_code); 1135 ieee80211_set_disassoc(sdata, false, false, reason_code);
1328} 1136}
1329 1137
1330 1138
1331static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata, 1139static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1332 struct ieee80211_if_sta *ifsta,
1333 struct ieee80211_mgmt *mgmt, 1140 struct ieee80211_mgmt *mgmt,
1334 size_t len, 1141 size_t len,
1335 int reassoc) 1142 int reassoc)
1336{ 1143{
1144 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1337 struct ieee80211_local *local = sdata->local; 1145 struct ieee80211_local *local = sdata->local;
1338 struct ieee80211_supported_band *sband; 1146 struct ieee80211_supported_band *sband;
1339 struct sta_info *sta; 1147 struct sta_info *sta;
@@ -1350,13 +1158,13 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1350 /* AssocResp and ReassocResp have identical structure, so process both 1158 /* AssocResp and ReassocResp have identical structure, so process both
1351 * of them in this function. */ 1159 * of them in this function. */
1352 1160
1353 if (ifsta->state != IEEE80211_STA_MLME_ASSOCIATE) 1161 if (ifmgd->state != IEEE80211_STA_MLME_ASSOCIATE)
1354 return; 1162 return;
1355 1163
1356 if (len < 24 + 6) 1164 if (len < 24 + 6)
1357 return; 1165 return;
1358 1166
1359 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0) 1167 if (memcmp(ifmgd->bssid, mgmt->sa, ETH_ALEN) != 0)
1360 return; 1168 return;
1361 1169
1362 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info); 1170 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
@@ -1381,7 +1189,7 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1381 "comeback duration %u TU (%u ms)\n", 1189 "comeback duration %u TU (%u ms)\n",
1382 sdata->dev->name, tu, ms); 1190 sdata->dev->name, tu, ms);
1383 if (ms > IEEE80211_ASSOC_TIMEOUT) 1191 if (ms > IEEE80211_ASSOC_TIMEOUT)
1384 mod_timer(&ifsta->timer, 1192 mod_timer(&ifmgd->timer,
1385 jiffies + msecs_to_jiffies(ms)); 1193 jiffies + msecs_to_jiffies(ms));
1386 return; 1194 return;
1387 } 1195 }
@@ -1392,7 +1200,7 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1392 /* if this was a reassociation, ensure we try a "full" 1200 /* if this was a reassociation, ensure we try a "full"
1393 * association next time. This works around some broken APs 1201 * association next time. This works around some broken APs
1394 * which do not correctly reject reassociation requests. */ 1202 * which do not correctly reject reassociation requests. */
1395 ifsta->flags &= ~IEEE80211_STA_PREV_BSSID_SET; 1203 ifmgd->flags &= ~IEEE80211_STA_PREV_BSSID_SET;
1396 return; 1204 return;
1397 } 1205 }
1398 1206
@@ -1408,23 +1216,23 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1408 } 1216 }
1409 1217
1410 printk(KERN_DEBUG "%s: associated\n", sdata->dev->name); 1218 printk(KERN_DEBUG "%s: associated\n", sdata->dev->name);
1411 ifsta->aid = aid; 1219 ifmgd->aid = aid;
1412 ifsta->ap_capab = capab_info; 1220 ifmgd->ap_capab = capab_info;
1413 1221
1414 kfree(ifsta->assocresp_ies); 1222 kfree(ifmgd->assocresp_ies);
1415 ifsta->assocresp_ies_len = len - (pos - (u8 *) mgmt); 1223 ifmgd->assocresp_ies_len = len - (pos - (u8 *) mgmt);
1416 ifsta->assocresp_ies = kmalloc(ifsta->assocresp_ies_len, GFP_KERNEL); 1224 ifmgd->assocresp_ies = kmalloc(ifmgd->assocresp_ies_len, GFP_KERNEL);
1417 if (ifsta->assocresp_ies) 1225 if (ifmgd->assocresp_ies)
1418 memcpy(ifsta->assocresp_ies, pos, ifsta->assocresp_ies_len); 1226 memcpy(ifmgd->assocresp_ies, pos, ifmgd->assocresp_ies_len);
1419 1227
1420 rcu_read_lock(); 1228 rcu_read_lock();
1421 1229
1422 /* Add STA entry for the AP */ 1230 /* Add STA entry for the AP */
1423 sta = sta_info_get(local, ifsta->bssid); 1231 sta = sta_info_get(local, ifmgd->bssid);
1424 if (!sta) { 1232 if (!sta) {
1425 newsta = true; 1233 newsta = true;
1426 1234
1427 sta = sta_info_alloc(sdata, ifsta->bssid, GFP_ATOMIC); 1235 sta = sta_info_alloc(sdata, ifmgd->bssid, GFP_ATOMIC);
1428 if (!sta) { 1236 if (!sta) {
1429 printk(KERN_DEBUG "%s: failed to alloc STA entry for" 1237 printk(KERN_DEBUG "%s: failed to alloc STA entry for"
1430 " the AP\n", sdata->dev->name); 1238 " the AP\n", sdata->dev->name);
@@ -1505,7 +1313,7 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1505 1313
1506 rate_control_rate_init(sta); 1314 rate_control_rate_init(sta);
1507 1315
1508 if (ifsta->flags & IEEE80211_STA_MFP_ENABLED) 1316 if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
1509 set_sta_flags(sta, WLAN_STA_MFP); 1317 set_sta_flags(sta, WLAN_STA_MFP);
1510 1318
1511 if (elems.wmm_param) 1319 if (elems.wmm_param)
@@ -1524,12 +1332,12 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1524 rcu_read_unlock(); 1332 rcu_read_unlock();
1525 1333
1526 if (elems.wmm_param) 1334 if (elems.wmm_param)
1527 ieee80211_sta_wmm_params(local, ifsta, elems.wmm_param, 1335 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
1528 elems.wmm_param_len); 1336 elems.wmm_param_len);
1529 1337
1530 if (elems.ht_info_elem && elems.wmm_param && 1338 if (elems.ht_info_elem && elems.wmm_param &&
1531 (ifsta->flags & IEEE80211_STA_WMM_ENABLED) && 1339 (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
1532 !(ifsta->flags & IEEE80211_STA_TKIP_WEP_USED)) 1340 !(ifmgd->flags & IEEE80211_STA_TKIP_WEP_USED))
1533 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem, 1341 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
1534 ap_ht_cap_flags); 1342 ap_ht_cap_flags);
1535 1343
@@ -1537,163 +1345,12 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1537 * ieee80211_set_associated() will tell the driver */ 1345 * ieee80211_set_associated() will tell the driver */
1538 bss_conf->aid = aid; 1346 bss_conf->aid = aid;
1539 bss_conf->assoc_capability = capab_info; 1347 bss_conf->assoc_capability = capab_info;
1540 ieee80211_set_associated(sdata, ifsta, changed); 1348 ieee80211_set_associated(sdata, changed);
1541 1349
1542 ieee80211_associated(sdata, ifsta); 1350 ieee80211_associated(sdata);
1543} 1351}
1544 1352
1545 1353
1546static int __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
1547 struct ieee80211_if_sta *ifsta,
1548 const u8 *bssid, const int beacon_int,
1549 const int freq,
1550 const size_t supp_rates_len,
1551 const u8 *supp_rates,
1552 const u16 capability)
1553{
1554 struct ieee80211_local *local = sdata->local;
1555 int res = 0, rates, i, j;
1556 struct sk_buff *skb;
1557 struct ieee80211_mgmt *mgmt;
1558 u8 *pos;
1559 struct ieee80211_supported_band *sband;
1560 union iwreq_data wrqu;
1561
1562 if (local->ops->reset_tsf) {
1563 /* Reset own TSF to allow time synchronization work. */
1564 local->ops->reset_tsf(local_to_hw(local));
1565 }
1566
1567 if ((ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) &&
1568 memcmp(ifsta->bssid, bssid, ETH_ALEN) == 0)
1569 return res;
1570
1571 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400 +
1572 sdata->u.sta.ie_proberesp_len);
1573 if (!skb) {
1574 printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
1575 "response\n", sdata->dev->name);
1576 return -ENOMEM;
1577 }
1578
1579 if (!(ifsta->flags & IEEE80211_STA_PREV_BSSID_SET)) {
1580 /* Remove possible STA entries from other IBSS networks. */
1581 sta_info_flush_delayed(sdata);
1582 }
1583
1584 memcpy(ifsta->bssid, bssid, ETH_ALEN);
1585 res = ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID);
1586 if (res)
1587 return res;
1588
1589 local->hw.conf.beacon_int = beacon_int >= 10 ? beacon_int : 10;
1590
1591 sdata->drop_unencrypted = capability &
1592 WLAN_CAPABILITY_PRIVACY ? 1 : 0;
1593
1594 res = ieee80211_set_freq(sdata, freq);
1595
1596 if (res)
1597 return res;
1598
1599 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
1600
1601 /* Build IBSS probe response */
1602
1603 skb_reserve(skb, local->hw.extra_tx_headroom);
1604
1605 mgmt = (struct ieee80211_mgmt *)
1606 skb_put(skb, 24 + sizeof(mgmt->u.beacon));
1607 memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
1608 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1609 IEEE80211_STYPE_PROBE_RESP);
1610 memset(mgmt->da, 0xff, ETH_ALEN);
1611 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
1612 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
1613 mgmt->u.beacon.beacon_int =
1614 cpu_to_le16(local->hw.conf.beacon_int);
1615 mgmt->u.beacon.capab_info = cpu_to_le16(capability);
1616
1617 pos = skb_put(skb, 2 + ifsta->ssid_len);
1618 *pos++ = WLAN_EID_SSID;
1619 *pos++ = ifsta->ssid_len;
1620 memcpy(pos, ifsta->ssid, ifsta->ssid_len);
1621
1622 rates = supp_rates_len;
1623 if (rates > 8)
1624 rates = 8;
1625 pos = skb_put(skb, 2 + rates);
1626 *pos++ = WLAN_EID_SUPP_RATES;
1627 *pos++ = rates;
1628 memcpy(pos, supp_rates, rates);
1629
1630 if (sband->band == IEEE80211_BAND_2GHZ) {
1631 pos = skb_put(skb, 2 + 1);
1632 *pos++ = WLAN_EID_DS_PARAMS;
1633 *pos++ = 1;
1634 *pos++ = ieee80211_frequency_to_channel(freq);
1635 }
1636
1637 pos = skb_put(skb, 2 + 2);
1638 *pos++ = WLAN_EID_IBSS_PARAMS;
1639 *pos++ = 2;
1640 /* FIX: set ATIM window based on scan results */
1641 *pos++ = 0;
1642 *pos++ = 0;
1643
1644 if (supp_rates_len > 8) {
1645 rates = supp_rates_len - 8;
1646 pos = skb_put(skb, 2 + rates);
1647 *pos++ = WLAN_EID_EXT_SUPP_RATES;
1648 *pos++ = rates;
1649 memcpy(pos, &supp_rates[8], rates);
1650 }
1651
1652 add_extra_ies(skb, sdata->u.sta.ie_proberesp,
1653 sdata->u.sta.ie_proberesp_len);
1654
1655 ifsta->probe_resp = skb;
1656
1657 ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON |
1658 IEEE80211_IFCC_BEACON_ENABLED);
1659
1660
1661 rates = 0;
1662 for (i = 0; i < supp_rates_len; i++) {
1663 int bitrate = (supp_rates[i] & 0x7f) * 5;
1664 for (j = 0; j < sband->n_bitrates; j++)
1665 if (sband->bitrates[j].bitrate == bitrate)
1666 rates |= BIT(j);
1667 }
1668 ifsta->supp_rates_bits[local->hw.conf.channel->band] = rates;
1669
1670 ieee80211_sta_def_wmm_params(sdata, supp_rates_len, supp_rates);
1671
1672 ifsta->flags |= IEEE80211_STA_PREV_BSSID_SET;
1673 ifsta->state = IEEE80211_STA_MLME_IBSS_JOINED;
1674 mod_timer(&ifsta->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
1675
1676 ieee80211_led_assoc(local, true);
1677
1678 memset(&wrqu, 0, sizeof(wrqu));
1679 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
1680 wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL);
1681
1682 return res;
1683}
1684
1685static int ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
1686 struct ieee80211_if_sta *ifsta,
1687 struct ieee80211_bss *bss)
1688{
1689 return __ieee80211_sta_join_ibss(sdata, ifsta,
1690 bss->cbss.bssid,
1691 bss->cbss.beacon_interval,
1692 bss->cbss.channel->center_freq,
1693 bss->supp_rates_len, bss->supp_rates,
1694 bss->cbss.capability);
1695}
1696
1697static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata, 1354static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1698 struct ieee80211_mgmt *mgmt, 1355 struct ieee80211_mgmt *mgmt,
1699 size_t len, 1356 size_t len,
@@ -1704,11 +1361,7 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1704 struct ieee80211_local *local = sdata->local; 1361 struct ieee80211_local *local = sdata->local;
1705 int freq; 1362 int freq;
1706 struct ieee80211_bss *bss; 1363 struct ieee80211_bss *bss;
1707 struct sta_info *sta;
1708 struct ieee80211_channel *channel; 1364 struct ieee80211_channel *channel;
1709 u64 beacon_timestamp, rx_timestamp;
1710 u32 supp_rates = 0;
1711 enum ieee80211_band band = rx_status->band;
1712 1365
1713 if (elems->ds_params && elems->ds_params_len == 1) 1366 if (elems->ds_params && elems->ds_params_len == 1)
1714 freq = ieee80211_channel_to_frequency(elems->ds_params[0]); 1367 freq = ieee80211_channel_to_frequency(elems->ds_params[0]);
@@ -1720,133 +1373,18 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1720 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) 1373 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
1721 return; 1374 return;
1722 1375
1723 if (sdata->vif.type == NL80211_IFTYPE_ADHOC && elems->supp_rates &&
1724 memcmp(mgmt->bssid, sdata->u.sta.bssid, ETH_ALEN) == 0) {
1725 supp_rates = ieee80211_sta_get_rates(local, elems, band);
1726
1727 rcu_read_lock();
1728
1729 sta = sta_info_get(local, mgmt->sa);
1730 if (sta) {
1731 u32 prev_rates;
1732
1733 prev_rates = sta->sta.supp_rates[band];
1734 /* make sure mandatory rates are always added */
1735 sta->sta.supp_rates[band] = supp_rates |
1736 ieee80211_mandatory_rates(local, band);
1737
1738#ifdef CONFIG_MAC80211_IBSS_DEBUG
1739 if (sta->sta.supp_rates[band] != prev_rates)
1740 printk(KERN_DEBUG "%s: updated supp_rates set "
1741 "for %pM based on beacon info (0x%llx | "
1742 "0x%llx -> 0x%llx)\n",
1743 sdata->dev->name,
1744 sta->sta.addr,
1745 (unsigned long long) prev_rates,
1746 (unsigned long long) supp_rates,
1747 (unsigned long long) sta->sta.supp_rates[band]);
1748#endif
1749 } else {
1750 ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, supp_rates);
1751 }
1752
1753 rcu_read_unlock();
1754 }
1755
1756 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems, 1376 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
1757 channel, beacon); 1377 channel, beacon);
1758 if (!bss) 1378 if (!bss)
1759 return; 1379 return;
1760 1380
1761 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) && 1381 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&
1762 (memcmp(mgmt->bssid, sdata->u.sta.bssid, ETH_ALEN) == 0)) { 1382 (memcmp(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN) == 0)) {
1763 struct ieee80211_channel_sw_ie *sw_elem = 1383 struct ieee80211_channel_sw_ie *sw_elem =
1764 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem; 1384 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
1765 ieee80211_process_chanswitch(sdata, sw_elem, bss); 1385 ieee80211_process_chanswitch(sdata, sw_elem, bss);
1766 } 1386 }
1767 1387
1768 /* was just updated in ieee80211_bss_info_update */
1769 beacon_timestamp = bss->cbss.tsf;
1770
1771 if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
1772 goto put_bss;
1773
1774 /* check if we need to merge IBSS */
1775
1776 /* merge only on beacons (???) */
1777 if (!beacon)
1778 goto put_bss;
1779
1780 /* we use a fixed BSSID */
1781 if (sdata->u.sta.flags & IEEE80211_STA_BSSID_SET)
1782 goto put_bss;
1783
1784 /* not an IBSS */
1785 if (!(bss->cbss.capability & WLAN_CAPABILITY_IBSS))
1786 goto put_bss;
1787
1788 /* different channel */
1789 if (bss->cbss.channel != local->oper_channel)
1790 goto put_bss;
1791
1792 /* different SSID */
1793 if (elems->ssid_len != sdata->u.sta.ssid_len ||
1794 memcmp(elems->ssid, sdata->u.sta.ssid,
1795 sdata->u.sta.ssid_len))
1796 goto put_bss;
1797
1798 if (rx_status->flag & RX_FLAG_TSFT) {
1799 /*
1800 * For correct IBSS merging we need mactime; since mactime is
1801 * defined as the time the first data symbol of the frame hits
1802 * the PHY, and the timestamp of the beacon is defined as "the
1803 * time that the data symbol containing the first bit of the
1804 * timestamp is transmitted to the PHY plus the transmitting
1805 * STA's delays through its local PHY from the MAC-PHY
1806 * interface to its interface with the WM" (802.11 11.1.2)
1807 * - equals the time this bit arrives at the receiver - we have
1808 * to take into account the offset between the two.
1809 *
1810 * E.g. at 1 MBit that means mactime is 192 usec earlier
1811 * (=24 bytes * 8 usecs/byte) than the beacon timestamp.
1812 */
1813 int rate;
1814
1815 if (rx_status->flag & RX_FLAG_HT)
1816 rate = 65; /* TODO: HT rates */
1817 else
1818 rate = local->hw.wiphy->bands[band]->
1819 bitrates[rx_status->rate_idx].bitrate;
1820
1821 rx_timestamp = rx_status->mactime + (24 * 8 * 10 / rate);
1822 } else if (local && local->ops && local->ops->get_tsf)
1823 /* second best option: get current TSF */
1824 rx_timestamp = local->ops->get_tsf(local_to_hw(local));
1825 else
1826 /* can't merge without knowing the TSF */
1827 rx_timestamp = -1LLU;
1828
1829#ifdef CONFIG_MAC80211_IBSS_DEBUG
1830 printk(KERN_DEBUG "RX beacon SA=%pM BSSID="
1831 "%pM TSF=0x%llx BCN=0x%llx diff=%lld @%lu\n",
1832 mgmt->sa, mgmt->bssid,
1833 (unsigned long long)rx_timestamp,
1834 (unsigned long long)beacon_timestamp,
1835 (unsigned long long)(rx_timestamp - beacon_timestamp),
1836 jiffies);
1837#endif
1838
1839 if (beacon_timestamp > rx_timestamp) {
1840#ifdef CONFIG_MAC80211_IBSS_DEBUG
1841 printk(KERN_DEBUG "%s: beacon TSF higher than "
1842 "local TSF - IBSS merge with BSSID %pM\n",
1843 sdata->dev->name, mgmt->bssid);
1844#endif
1845 ieee80211_sta_join_ibss(sdata, &sdata->u.sta, bss);
1846 ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, supp_rates);
1847 }
1848
1849 put_bss:
1850 ieee80211_rx_bss_put(local, bss); 1388 ieee80211_rx_bss_put(local, bss);
1851} 1389}
1852 1390
@@ -1858,7 +1396,6 @@ static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
1858{ 1396{
1859 size_t baselen; 1397 size_t baselen;
1860 struct ieee802_11_elems elems; 1398 struct ieee802_11_elems elems;
1861 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
1862 1399
1863 if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN)) 1400 if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
1864 return; /* ignore ProbeResp to foreign address */ 1401 return; /* ignore ProbeResp to foreign address */
@@ -1874,20 +1411,19 @@ static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
1874 1411
1875 /* direct probe may be part of the association flow */ 1412 /* direct probe may be part of the association flow */
1876 if (test_and_clear_bit(IEEE80211_STA_REQ_DIRECT_PROBE, 1413 if (test_and_clear_bit(IEEE80211_STA_REQ_DIRECT_PROBE,
1877 &ifsta->request)) { 1414 &sdata->u.mgd.request)) {
1878 printk(KERN_DEBUG "%s direct probe responded\n", 1415 printk(KERN_DEBUG "%s direct probe responded\n",
1879 sdata->dev->name); 1416 sdata->dev->name);
1880 ieee80211_authenticate(sdata, ifsta); 1417 ieee80211_authenticate(sdata);
1881 } 1418 }
1882} 1419}
1883 1420
1884
1885static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata, 1421static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1886 struct ieee80211_mgmt *mgmt, 1422 struct ieee80211_mgmt *mgmt,
1887 size_t len, 1423 size_t len,
1888 struct ieee80211_rx_status *rx_status) 1424 struct ieee80211_rx_status *rx_status)
1889{ 1425{
1890 struct ieee80211_if_sta *ifsta; 1426 struct ieee80211_if_managed *ifmgd;
1891 size_t baselen; 1427 size_t baselen;
1892 struct ieee802_11_elems elems; 1428 struct ieee802_11_elems elems;
1893 struct ieee80211_local *local = sdata->local; 1429 struct ieee80211_local *local = sdata->local;
@@ -1906,21 +1442,22 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1906 1442
1907 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1443 if (sdata->vif.type != NL80211_IFTYPE_STATION)
1908 return; 1444 return;
1909 ifsta = &sdata->u.sta;
1910 1445
1911 if (!(ifsta->flags & IEEE80211_STA_ASSOCIATED) || 1446 ifmgd = &sdata->u.mgd;
1912 memcmp(ifsta->bssid, mgmt->bssid, ETH_ALEN) != 0) 1447
1448 if (!(ifmgd->flags & IEEE80211_STA_ASSOCIATED) ||
1449 memcmp(ifmgd->bssid, mgmt->bssid, ETH_ALEN) != 0)
1913 return; 1450 return;
1914 1451
1915 if (rx_status->freq != local->hw.conf.channel->center_freq) 1452 if (rx_status->freq != local->hw.conf.channel->center_freq)
1916 return; 1453 return;
1917 1454
1918 ieee80211_sta_wmm_params(local, ifsta, elems.wmm_param, 1455 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
1919 elems.wmm_param_len); 1456 elems.wmm_param_len);
1920 1457
1921 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK && 1458 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK &&
1922 local->hw.conf.flags & IEEE80211_CONF_PS) { 1459 local->hw.conf.flags & IEEE80211_CONF_PS) {
1923 directed_tim = ieee80211_check_tim(&elems, ifsta->aid); 1460 directed_tim = ieee80211_check_tim(&elems, ifmgd->aid);
1924 1461
1925 if (directed_tim) { 1462 if (directed_tim) {
1926 if (local->hw.conf.dynamic_ps_timeout > 0) { 1463 if (local->hw.conf.dynamic_ps_timeout > 0) {
@@ -1956,14 +1493,14 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1956 1493
1957 1494
1958 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param && 1495 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&
1959 !(ifsta->flags & IEEE80211_STA_TKIP_WEP_USED)) { 1496 !(ifmgd->flags & IEEE80211_STA_TKIP_WEP_USED)) {
1960 struct sta_info *sta; 1497 struct sta_info *sta;
1961 struct ieee80211_supported_band *sband; 1498 struct ieee80211_supported_band *sband;
1962 u16 ap_ht_cap_flags; 1499 u16 ap_ht_cap_flags;
1963 1500
1964 rcu_read_lock(); 1501 rcu_read_lock();
1965 1502
1966 sta = sta_info_get(local, ifsta->bssid); 1503 sta = sta_info_get(local, ifmgd->bssid);
1967 if (!sta) { 1504 if (!sta) {
1968 rcu_read_unlock(); 1505 rcu_read_unlock();
1969 return; 1506 return;
@@ -1999,85 +1536,16 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1999 ieee80211_bss_info_change_notify(sdata, changed); 1536 ieee80211_bss_info_change_notify(sdata, changed);
2000} 1537}
2001 1538
2002 1539ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,
2003static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata, 1540 struct sk_buff *skb,
2004 struct ieee80211_if_sta *ifsta, 1541 struct ieee80211_rx_status *rx_status)
2005 struct ieee80211_mgmt *mgmt,
2006 size_t len)
2007{ 1542{
2008 struct ieee80211_local *local = sdata->local; 1543 struct ieee80211_local *local = sdata->local;
2009 int tx_last_beacon;
2010 struct sk_buff *skb;
2011 struct ieee80211_mgmt *resp;
2012 u8 *pos, *end;
2013
2014 if (ifsta->state != IEEE80211_STA_MLME_IBSS_JOINED ||
2015 len < 24 + 2 || !ifsta->probe_resp)
2016 return;
2017
2018 if (local->ops->tx_last_beacon)
2019 tx_last_beacon = local->ops->tx_last_beacon(local_to_hw(local));
2020 else
2021 tx_last_beacon = 1;
2022
2023#ifdef CONFIG_MAC80211_IBSS_DEBUG
2024 printk(KERN_DEBUG "%s: RX ProbeReq SA=%pM DA=%pM BSSID=%pM"
2025 " (tx_last_beacon=%d)\n",
2026 sdata->dev->name, mgmt->sa, mgmt->da,
2027 mgmt->bssid, tx_last_beacon);
2028#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2029
2030 if (!tx_last_beacon)
2031 return;
2032
2033 if (memcmp(mgmt->bssid, ifsta->bssid, ETH_ALEN) != 0 &&
2034 memcmp(mgmt->bssid, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0)
2035 return;
2036
2037 end = ((u8 *) mgmt) + len;
2038 pos = mgmt->u.probe_req.variable;
2039 if (pos[0] != WLAN_EID_SSID ||
2040 pos + 2 + pos[1] > end) {
2041#ifdef CONFIG_MAC80211_IBSS_DEBUG
2042 printk(KERN_DEBUG "%s: Invalid SSID IE in ProbeReq "
2043 "from %pM\n",
2044 sdata->dev->name, mgmt->sa);
2045#endif
2046 return;
2047 }
2048 if (pos[1] != 0 &&
2049 (pos[1] != ifsta->ssid_len ||
2050 memcmp(pos + 2, ifsta->ssid, ifsta->ssid_len) != 0)) {
2051 /* Ignore ProbeReq for foreign SSID */
2052 return;
2053 }
2054
2055 /* Reply with ProbeResp */
2056 skb = skb_copy(ifsta->probe_resp, GFP_KERNEL);
2057 if (!skb)
2058 return;
2059
2060 resp = (struct ieee80211_mgmt *) skb->data;
2061 memcpy(resp->da, mgmt->sa, ETH_ALEN);
2062#ifdef CONFIG_MAC80211_IBSS_DEBUG
2063 printk(KERN_DEBUG "%s: Sending ProbeResp to %pM\n",
2064 sdata->dev->name, resp->da);
2065#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2066 ieee80211_tx_skb(sdata, skb, 0);
2067}
2068
2069void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
2070 struct ieee80211_rx_status *rx_status)
2071{
2072 struct ieee80211_local *local = sdata->local;
2073 struct ieee80211_if_sta *ifsta;
2074 struct ieee80211_mgmt *mgmt; 1544 struct ieee80211_mgmt *mgmt;
2075 u16 fc; 1545 u16 fc;
2076 1546
2077 if (skb->len < 24) 1547 if (skb->len < 24)
2078 goto fail; 1548 return RX_DROP_MONITOR;
2079
2080 ifsta = &sdata->u.sta;
2081 1549
2082 mgmt = (struct ieee80211_mgmt *) skb->data; 1550 mgmt = (struct ieee80211_mgmt *) skb->data;
2083 fc = le16_to_cpu(mgmt->frame_control); 1551 fc = le16_to_cpu(mgmt->frame_control);
@@ -2092,147 +1560,68 @@ void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *
2092 case IEEE80211_STYPE_REASSOC_RESP: 1560 case IEEE80211_STYPE_REASSOC_RESP:
2093 case IEEE80211_STYPE_DEAUTH: 1561 case IEEE80211_STYPE_DEAUTH:
2094 case IEEE80211_STYPE_DISASSOC: 1562 case IEEE80211_STYPE_DISASSOC:
2095 skb_queue_tail(&ifsta->skb_queue, skb); 1563 skb_queue_tail(&sdata->u.mgd.skb_queue, skb);
2096 queue_work(local->hw.workqueue, &ifsta->work); 1564 queue_work(local->hw.workqueue, &sdata->u.mgd.work);
2097 return; 1565 return RX_QUEUED;
2098 } 1566 }
2099 1567
2100 fail: 1568 return RX_DROP_MONITOR;
2101 kfree_skb(skb);
2102} 1569}
2103 1570
2104static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 1571static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
2105 struct sk_buff *skb) 1572 struct sk_buff *skb)
2106{ 1573{
2107 struct ieee80211_rx_status *rx_status; 1574 struct ieee80211_rx_status *rx_status;
2108 struct ieee80211_if_sta *ifsta;
2109 struct ieee80211_mgmt *mgmt; 1575 struct ieee80211_mgmt *mgmt;
2110 u16 fc; 1576 u16 fc;
2111 1577
2112 ifsta = &sdata->u.sta;
2113
2114 rx_status = (struct ieee80211_rx_status *) skb->cb; 1578 rx_status = (struct ieee80211_rx_status *) skb->cb;
2115 mgmt = (struct ieee80211_mgmt *) skb->data; 1579 mgmt = (struct ieee80211_mgmt *) skb->data;
2116 fc = le16_to_cpu(mgmt->frame_control); 1580 fc = le16_to_cpu(mgmt->frame_control);
2117 1581
2118 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { 1582 switch (fc & IEEE80211_FCTL_STYPE) {
2119 switch (fc & IEEE80211_FCTL_STYPE) { 1583 case IEEE80211_STYPE_PROBE_RESP:
2120 case IEEE80211_STYPE_PROBE_REQ: 1584 ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len,
2121 ieee80211_rx_mgmt_probe_req(sdata, ifsta, mgmt, 1585 rx_status);
2122 skb->len); 1586 break;
2123 break; 1587 case IEEE80211_STYPE_BEACON:
2124 case IEEE80211_STYPE_PROBE_RESP: 1588 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
2125 ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len, 1589 rx_status);
2126 rx_status); 1590 break;
2127 break; 1591 case IEEE80211_STYPE_AUTH:
2128 case IEEE80211_STYPE_BEACON: 1592 ieee80211_rx_mgmt_auth(sdata, mgmt, skb->len);
2129 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, 1593 break;
2130 rx_status); 1594 case IEEE80211_STYPE_ASSOC_RESP:
2131 break; 1595 ieee80211_rx_mgmt_assoc_resp(sdata, mgmt, skb->len, 0);
2132 case IEEE80211_STYPE_AUTH: 1596 break;
2133 ieee80211_rx_mgmt_auth_ibss(sdata, ifsta, mgmt, 1597 case IEEE80211_STYPE_REASSOC_RESP:
2134 skb->len); 1598 ieee80211_rx_mgmt_assoc_resp(sdata, mgmt, skb->len, 1);
2135 break; 1599 break;
2136 } 1600 case IEEE80211_STYPE_DEAUTH:
2137 } else { /* NL80211_IFTYPE_STATION */ 1601 ieee80211_rx_mgmt_deauth(sdata, mgmt, skb->len);
2138 switch (fc & IEEE80211_FCTL_STYPE) { 1602 break;
2139 case IEEE80211_STYPE_PROBE_RESP: 1603 case IEEE80211_STYPE_DISASSOC:
2140 ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len, 1604 ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
2141 rx_status); 1605 break;
2142 break;
2143 case IEEE80211_STYPE_BEACON:
2144 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
2145 rx_status);
2146 break;
2147 case IEEE80211_STYPE_AUTH:
2148 ieee80211_rx_mgmt_auth(sdata, ifsta, mgmt, skb->len);
2149 break;
2150 case IEEE80211_STYPE_ASSOC_RESP:
2151 ieee80211_rx_mgmt_assoc_resp(sdata, ifsta, mgmt,
2152 skb->len, 0);
2153 break;
2154 case IEEE80211_STYPE_REASSOC_RESP:
2155 ieee80211_rx_mgmt_assoc_resp(sdata, ifsta, mgmt,
2156 skb->len, 1);
2157 break;
2158 case IEEE80211_STYPE_DEAUTH:
2159 ieee80211_rx_mgmt_deauth(sdata, ifsta, mgmt, skb->len);
2160 break;
2161 case IEEE80211_STYPE_DISASSOC:
2162 ieee80211_rx_mgmt_disassoc(sdata, ifsta, mgmt,
2163 skb->len);
2164 break;
2165 }
2166 } 1606 }
2167 1607
2168 kfree_skb(skb); 1608 kfree_skb(skb);
2169} 1609}
2170 1610
2171
2172static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data *sdata)
2173{
2174 struct ieee80211_local *local = sdata->local;
2175 int active = 0;
2176 struct sta_info *sta;
2177
2178 rcu_read_lock();
2179
2180 list_for_each_entry_rcu(sta, &local->sta_list, list) {
2181 if (sta->sdata == sdata &&
2182 time_after(sta->last_rx + IEEE80211_IBSS_MERGE_INTERVAL,
2183 jiffies)) {
2184 active++;
2185 break;
2186 }
2187 }
2188
2189 rcu_read_unlock();
2190
2191 return active;
2192}
2193
2194
2195static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata,
2196 struct ieee80211_if_sta *ifsta)
2197{
2198 mod_timer(&ifsta->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
2199
2200 ieee80211_sta_expire(sdata, IEEE80211_IBSS_INACTIVITY_LIMIT);
2201 if (ieee80211_sta_active_ibss(sdata))
2202 return;
2203
2204 if ((sdata->u.sta.flags & IEEE80211_STA_BSSID_SET) &&
2205 (!(sdata->u.sta.flags & IEEE80211_STA_AUTO_CHANNEL_SEL)))
2206 return;
2207
2208 printk(KERN_DEBUG "%s: No active IBSS STAs - trying to scan for other "
2209 "IBSS networks with same SSID (merge)\n", sdata->dev->name);
2210
2211 /* XXX maybe racy? */
2212 if (sdata->local->scan_req)
2213 return;
2214
2215 memcpy(sdata->local->int_scan_req.ssids[0].ssid,
2216 ifsta->ssid, IEEE80211_MAX_SSID_LEN);
2217 sdata->local->int_scan_req.ssids[0].ssid_len = ifsta->ssid_len;
2218 ieee80211_request_scan(sdata, &sdata->local->int_scan_req);
2219}
2220
2221
2222static void ieee80211_sta_timer(unsigned long data) 1611static void ieee80211_sta_timer(unsigned long data)
2223{ 1612{
2224 struct ieee80211_sub_if_data *sdata = 1613 struct ieee80211_sub_if_data *sdata =
2225 (struct ieee80211_sub_if_data *) data; 1614 (struct ieee80211_sub_if_data *) data;
2226 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 1615 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2227 struct ieee80211_local *local = sdata->local; 1616 struct ieee80211_local *local = sdata->local;
2228 1617
2229 set_bit(IEEE80211_STA_REQ_RUN, &ifsta->request); 1618 set_bit(IEEE80211_STA_REQ_RUN, &ifmgd->request);
2230 queue_work(local->hw.workqueue, &ifsta->work); 1619 queue_work(local->hw.workqueue, &ifmgd->work);
2231} 1620}
2232 1621
2233static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data *sdata, 1622static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data *sdata)
2234 struct ieee80211_if_sta *ifsta)
2235{ 1623{
1624 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2236 struct ieee80211_local *local = sdata->local; 1625 struct ieee80211_local *local = sdata->local;
2237 1626
2238 if (local->ops->reset_tsf) { 1627 if (local->ops->reset_tsf) {
@@ -2240,191 +1629,39 @@ static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data *sdata,
2240 local->ops->reset_tsf(local_to_hw(local)); 1629 local->ops->reset_tsf(local_to_hw(local));
2241 } 1630 }
2242 1631
2243 ifsta->wmm_last_param_set = -1; /* allow any WMM update */ 1632 ifmgd->wmm_last_param_set = -1; /* allow any WMM update */
2244 1633
2245 1634
2246 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_OPEN) 1635 if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_OPEN)
2247 ifsta->auth_alg = WLAN_AUTH_OPEN; 1636 ifmgd->auth_alg = WLAN_AUTH_OPEN;
2248 else if (ifsta->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY) 1637 else if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY)
2249 ifsta->auth_alg = WLAN_AUTH_SHARED_KEY; 1638 ifmgd->auth_alg = WLAN_AUTH_SHARED_KEY;
2250 else if (ifsta->auth_algs & IEEE80211_AUTH_ALG_LEAP) 1639 else if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_LEAP)
2251 ifsta->auth_alg = WLAN_AUTH_LEAP; 1640 ifmgd->auth_alg = WLAN_AUTH_LEAP;
2252 else 1641 else
2253 ifsta->auth_alg = WLAN_AUTH_OPEN; 1642 ifmgd->auth_alg = WLAN_AUTH_OPEN;
2254 ifsta->auth_transaction = -1; 1643 ifmgd->auth_transaction = -1;
2255 ifsta->flags &= ~IEEE80211_STA_ASSOCIATED; 1644 ifmgd->flags &= ~IEEE80211_STA_ASSOCIATED;
2256 ifsta->assoc_scan_tries = 0; 1645 ifmgd->assoc_scan_tries = 0;
2257 ifsta->direct_probe_tries = 0; 1646 ifmgd->direct_probe_tries = 0;
2258 ifsta->auth_tries = 0; 1647 ifmgd->auth_tries = 0;
2259 ifsta->assoc_tries = 0; 1648 ifmgd->assoc_tries = 0;
2260 netif_tx_stop_all_queues(sdata->dev); 1649 netif_tx_stop_all_queues(sdata->dev);
2261 netif_carrier_off(sdata->dev); 1650 netif_carrier_off(sdata->dev);
2262} 1651}
2263 1652
2264static int ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata, 1653static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata)
2265 struct ieee80211_if_sta *ifsta)
2266{
2267 struct ieee80211_local *local = sdata->local;
2268 struct ieee80211_supported_band *sband;
2269 u8 *pos;
2270 u8 bssid[ETH_ALEN];
2271 u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
2272 u16 capability;
2273 int i;
2274
2275 if (sdata->u.sta.flags & IEEE80211_STA_BSSID_SET) {
2276 memcpy(bssid, ifsta->bssid, ETH_ALEN);
2277 } else {
2278 /* Generate random, not broadcast, locally administered BSSID. Mix in
2279 * own MAC address to make sure that devices that do not have proper
2280 * random number generator get different BSSID. */
2281 get_random_bytes(bssid, ETH_ALEN);
2282 for (i = 0; i < ETH_ALEN; i++)
2283 bssid[i] ^= sdata->dev->dev_addr[i];
2284 bssid[0] &= ~0x01;
2285 bssid[0] |= 0x02;
2286 }
2287
2288 printk(KERN_DEBUG "%s: Creating new IBSS network, BSSID %pM\n",
2289 sdata->dev->name, bssid);
2290
2291 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
2292
2293 if (local->hw.conf.beacon_int == 0)
2294 local->hw.conf.beacon_int = 100;
2295
2296 capability = WLAN_CAPABILITY_IBSS;
2297
2298 if (sdata->default_key)
2299 capability |= WLAN_CAPABILITY_PRIVACY;
2300 else
2301 sdata->drop_unencrypted = 0;
2302
2303 pos = supp_rates;
2304 for (i = 0; i < sband->n_bitrates; i++) {
2305 int rate = sband->bitrates[i].bitrate;
2306 *pos++ = (u8) (rate / 5);
2307 }
2308
2309 return __ieee80211_sta_join_ibss(sdata, ifsta,
2310 bssid, local->hw.conf.beacon_int,
2311 local->hw.conf.channel->center_freq,
2312 sband->n_bitrates, supp_rates,
2313 capability);
2314}
2315
2316
2317static int ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata,
2318 struct ieee80211_if_sta *ifsta)
2319{ 1654{
1655 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2320 struct ieee80211_local *local = sdata->local; 1656 struct ieee80211_local *local = sdata->local;
2321 struct ieee80211_bss *bss; 1657 struct ieee80211_bss *bss;
2322 int active_ibss; 1658 u8 *bssid = ifmgd->bssid, *ssid = ifmgd->ssid;
2323 1659 u8 ssid_len = ifmgd->ssid_len;
2324 if (ifsta->ssid_len == 0)
2325 return -EINVAL;
2326
2327 active_ibss = ieee80211_sta_active_ibss(sdata);
2328#ifdef CONFIG_MAC80211_IBSS_DEBUG
2329 printk(KERN_DEBUG "%s: sta_find_ibss (active_ibss=%d)\n",
2330 sdata->dev->name, active_ibss);
2331#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2332
2333 if (active_ibss)
2334 return 0;
2335
2336 if (ifsta->flags & IEEE80211_STA_BSSID_SET)
2337 bss = ieee80211_rx_bss_get(local, ifsta->bssid, 0,
2338 ifsta->ssid, ifsta->ssid_len);
2339 else
2340 bss = (void *)cfg80211_get_ibss(local->hw.wiphy,
2341 NULL,
2342 ifsta->ssid, ifsta->ssid_len);
2343
2344#ifdef CONFIG_MAC80211_IBSS_DEBUG
2345 if (bss)
2346 printk(KERN_DEBUG " sta_find_ibss: selected %pM current "
2347 "%pM\n", bss->cbss.bssid, ifsta->bssid);
2348#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2349
2350 if (bss &&
2351 (!(ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) ||
2352 memcmp(ifsta->bssid, bss->cbss.bssid, ETH_ALEN))) {
2353 int ret;
2354
2355 printk(KERN_DEBUG "%s: Selected IBSS BSSID %pM"
2356 " based on configured SSID\n",
2357 sdata->dev->name, bss->cbss.bssid);
2358
2359 ret = ieee80211_sta_join_ibss(sdata, ifsta, bss);
2360 ieee80211_rx_bss_put(local, bss);
2361 return ret;
2362 } else if (bss)
2363 ieee80211_rx_bss_put(local, bss);
2364
2365#ifdef CONFIG_MAC80211_IBSS_DEBUG
2366 printk(KERN_DEBUG " did not try to join ibss\n");
2367#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2368
2369 /* Selected IBSS not found in current scan results - try to scan */
2370 if (ifsta->state == IEEE80211_STA_MLME_IBSS_JOINED &&
2371 !ieee80211_sta_active_ibss(sdata)) {
2372 mod_timer(&ifsta->timer, jiffies +
2373 IEEE80211_IBSS_MERGE_INTERVAL);
2374 } else if (time_after(jiffies, local->last_scan_completed +
2375 IEEE80211_SCAN_INTERVAL)) {
2376 printk(KERN_DEBUG "%s: Trigger new scan to find an IBSS to "
2377 "join\n", sdata->dev->name);
2378
2379 /* XXX maybe racy? */
2380 if (local->scan_req)
2381 return -EBUSY;
2382
2383 memcpy(local->int_scan_req.ssids[0].ssid,
2384 ifsta->ssid, IEEE80211_MAX_SSID_LEN);
2385 local->int_scan_req.ssids[0].ssid_len = ifsta->ssid_len;
2386 return ieee80211_request_scan(sdata, &local->int_scan_req);
2387 } else if (ifsta->state != IEEE80211_STA_MLME_IBSS_JOINED) {
2388 int interval = IEEE80211_SCAN_INTERVAL;
2389
2390 if (time_after(jiffies, ifsta->ibss_join_req +
2391 IEEE80211_IBSS_JOIN_TIMEOUT)) {
2392 if ((ifsta->flags & IEEE80211_STA_CREATE_IBSS) &&
2393 (!(local->oper_channel->flags &
2394 IEEE80211_CHAN_NO_IBSS)))
2395 return ieee80211_sta_create_ibss(sdata, ifsta);
2396 if (ifsta->flags & IEEE80211_STA_CREATE_IBSS) {
2397 printk(KERN_DEBUG "%s: IBSS not allowed on"
2398 " %d MHz\n", sdata->dev->name,
2399 local->hw.conf.channel->center_freq);
2400 }
2401
2402 /* No IBSS found - decrease scan interval and continue
2403 * scanning. */
2404 interval = IEEE80211_SCAN_INTERVAL_SLOW;
2405 }
2406
2407 ifsta->state = IEEE80211_STA_MLME_IBSS_SEARCH;
2408 mod_timer(&ifsta->timer, jiffies + interval);
2409 return 0;
2410 }
2411
2412 return 0;
2413}
2414
2415
2416static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2417 struct ieee80211_if_sta *ifsta)
2418{
2419 struct ieee80211_local *local = sdata->local;
2420 struct ieee80211_bss *bss;
2421 u8 *bssid = ifsta->bssid, *ssid = ifsta->ssid;
2422 u8 ssid_len = ifsta->ssid_len;
2423 u16 capa_mask = WLAN_CAPABILITY_ESS; 1660 u16 capa_mask = WLAN_CAPABILITY_ESS;
2424 u16 capa_val = WLAN_CAPABILITY_ESS; 1661 u16 capa_val = WLAN_CAPABILITY_ESS;
2425 struct ieee80211_channel *chan = local->oper_channel; 1662 struct ieee80211_channel *chan = local->oper_channel;
2426 1663
2427 if (ifsta->flags & (IEEE80211_STA_AUTO_SSID_SEL | 1664 if (ifmgd->flags & (IEEE80211_STA_AUTO_SSID_SEL |
2428 IEEE80211_STA_AUTO_BSSID_SEL | 1665 IEEE80211_STA_AUTO_BSSID_SEL |
2429 IEEE80211_STA_AUTO_CHANNEL_SEL)) { 1666 IEEE80211_STA_AUTO_CHANNEL_SEL)) {
2430 capa_mask |= WLAN_CAPABILITY_PRIVACY; 1667 capa_mask |= WLAN_CAPABILITY_PRIVACY;
@@ -2432,13 +1669,13 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2432 capa_val |= WLAN_CAPABILITY_PRIVACY; 1669 capa_val |= WLAN_CAPABILITY_PRIVACY;
2433 } 1670 }
2434 1671
2435 if (ifsta->flags & IEEE80211_STA_AUTO_CHANNEL_SEL) 1672 if (ifmgd->flags & IEEE80211_STA_AUTO_CHANNEL_SEL)
2436 chan = NULL; 1673 chan = NULL;
2437 1674
2438 if (ifsta->flags & IEEE80211_STA_AUTO_BSSID_SEL) 1675 if (ifmgd->flags & IEEE80211_STA_AUTO_BSSID_SEL)
2439 bssid = NULL; 1676 bssid = NULL;
2440 1677
2441 if (ifsta->flags & IEEE80211_STA_AUTO_SSID_SEL) { 1678 if (ifmgd->flags & IEEE80211_STA_AUTO_SSID_SEL) {
2442 ssid = NULL; 1679 ssid = NULL;
2443 ssid_len = 0; 1680 ssid_len = 0;
2444 } 1681 }
@@ -2449,16 +1686,16 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2449 1686
2450 if (bss) { 1687 if (bss) {
2451 ieee80211_set_freq(sdata, bss->cbss.channel->center_freq); 1688 ieee80211_set_freq(sdata, bss->cbss.channel->center_freq);
2452 if (!(ifsta->flags & IEEE80211_STA_SSID_SET)) 1689 if (!(ifmgd->flags & IEEE80211_STA_SSID_SET))
2453 ieee80211_sta_set_ssid(sdata, bss->ssid, 1690 ieee80211_sta_set_ssid(sdata, bss->ssid,
2454 bss->ssid_len); 1691 bss->ssid_len);
2455 ieee80211_sta_set_bssid(sdata, bss->cbss.bssid); 1692 ieee80211_sta_set_bssid(sdata, bss->cbss.bssid);
2456 ieee80211_sta_def_wmm_params(sdata, bss->supp_rates_len, 1693 ieee80211_sta_def_wmm_params(sdata, bss->supp_rates_len,
2457 bss->supp_rates); 1694 bss->supp_rates);
2458 if (sdata->u.sta.mfp == IEEE80211_MFP_REQUIRED) 1695 if (sdata->u.mgd.mfp == IEEE80211_MFP_REQUIRED)
2459 sdata->u.sta.flags |= IEEE80211_STA_MFP_ENABLED; 1696 sdata->u.mgd.flags |= IEEE80211_STA_MFP_ENABLED;
2460 else 1697 else
2461 sdata->u.sta.flags &= ~IEEE80211_STA_MFP_ENABLED; 1698 sdata->u.mgd.flags &= ~IEEE80211_STA_MFP_ENABLED;
2462 1699
2463 /* Send out direct probe if no probe resp was received or 1700 /* Send out direct probe if no probe resp was received or
2464 * the one we have is outdated 1701 * the one we have is outdated
@@ -2466,31 +1703,31 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2466 if (!bss->last_probe_resp || 1703 if (!bss->last_probe_resp ||
2467 time_after(jiffies, bss->last_probe_resp 1704 time_after(jiffies, bss->last_probe_resp
2468 + IEEE80211_SCAN_RESULT_EXPIRE)) 1705 + IEEE80211_SCAN_RESULT_EXPIRE))
2469 ifsta->state = IEEE80211_STA_MLME_DIRECT_PROBE; 1706 ifmgd->state = IEEE80211_STA_MLME_DIRECT_PROBE;
2470 else 1707 else
2471 ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE; 1708 ifmgd->state = IEEE80211_STA_MLME_AUTHENTICATE;
2472 1709
2473 ieee80211_rx_bss_put(local, bss); 1710 ieee80211_rx_bss_put(local, bss);
2474 ieee80211_sta_reset_auth(sdata, ifsta); 1711 ieee80211_sta_reset_auth(sdata);
2475 return 0; 1712 return 0;
2476 } else { 1713 } else {
2477 if (ifsta->assoc_scan_tries < IEEE80211_ASSOC_SCANS_MAX_TRIES) { 1714 if (ifmgd->assoc_scan_tries < IEEE80211_ASSOC_SCANS_MAX_TRIES) {
2478 ifsta->assoc_scan_tries++; 1715 ifmgd->assoc_scan_tries++;
2479 /* XXX maybe racy? */ 1716 /* XXX maybe racy? */
2480 if (local->scan_req) 1717 if (local->scan_req)
2481 return -1; 1718 return -1;
2482 memcpy(local->int_scan_req.ssids[0].ssid, 1719 memcpy(local->int_scan_req.ssids[0].ssid,
2483 ifsta->ssid, IEEE80211_MAX_SSID_LEN); 1720 ifmgd->ssid, IEEE80211_MAX_SSID_LEN);
2484 if (ifsta->flags & IEEE80211_STA_AUTO_SSID_SEL) 1721 if (ifmgd->flags & IEEE80211_STA_AUTO_SSID_SEL)
2485 local->int_scan_req.ssids[0].ssid_len = 0; 1722 local->int_scan_req.ssids[0].ssid_len = 0;
2486 else 1723 else
2487 local->int_scan_req.ssids[0].ssid_len = ifsta->ssid_len; 1724 local->int_scan_req.ssids[0].ssid_len = ifmgd->ssid_len;
2488 ieee80211_start_scan(sdata, &local->int_scan_req); 1725 ieee80211_start_scan(sdata, &local->int_scan_req);
2489 ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE; 1726 ifmgd->state = IEEE80211_STA_MLME_AUTHENTICATE;
2490 set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request); 1727 set_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request);
2491 } else { 1728 } else {
2492 ifsta->assoc_scan_tries = 0; 1729 ifmgd->assoc_scan_tries = 0;
2493 ifsta->state = IEEE80211_STA_MLME_DISABLED; 1730 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
2494 } 1731 }
2495 } 1732 }
2496 return -1; 1733 return -1;
@@ -2500,9 +1737,9 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2500static void ieee80211_sta_work(struct work_struct *work) 1737static void ieee80211_sta_work(struct work_struct *work)
2501{ 1738{
2502 struct ieee80211_sub_if_data *sdata = 1739 struct ieee80211_sub_if_data *sdata =
2503 container_of(work, struct ieee80211_sub_if_data, u.sta.work); 1740 container_of(work, struct ieee80211_sub_if_data, u.mgd.work);
2504 struct ieee80211_local *local = sdata->local; 1741 struct ieee80211_local *local = sdata->local;
2505 struct ieee80211_if_sta *ifsta; 1742 struct ieee80211_if_managed *ifmgd;
2506 struct sk_buff *skb; 1743 struct sk_buff *skb;
2507 1744
2508 if (!netif_running(sdata->dev)) 1745 if (!netif_running(sdata->dev))
@@ -2511,60 +1748,53 @@ static void ieee80211_sta_work(struct work_struct *work)
2511 if (local->sw_scanning || local->hw_scanning) 1748 if (local->sw_scanning || local->hw_scanning)
2512 return; 1749 return;
2513 1750
2514 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION && 1751 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2515 sdata->vif.type != NL80211_IFTYPE_ADHOC))
2516 return; 1752 return;
2517 ifsta = &sdata->u.sta; 1753 ifmgd = &sdata->u.mgd;
2518 1754
2519 while ((skb = skb_dequeue(&ifsta->skb_queue))) 1755 while ((skb = skb_dequeue(&ifmgd->skb_queue)))
2520 ieee80211_sta_rx_queued_mgmt(sdata, skb); 1756 ieee80211_sta_rx_queued_mgmt(sdata, skb);
2521 1757
2522 if (ifsta->state != IEEE80211_STA_MLME_DIRECT_PROBE && 1758 if (ifmgd->state != IEEE80211_STA_MLME_DIRECT_PROBE &&
2523 ifsta->state != IEEE80211_STA_MLME_AUTHENTICATE && 1759 ifmgd->state != IEEE80211_STA_MLME_AUTHENTICATE &&
2524 ifsta->state != IEEE80211_STA_MLME_ASSOCIATE && 1760 ifmgd->state != IEEE80211_STA_MLME_ASSOCIATE &&
2525 test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request)) { 1761 test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request)) {
2526 ieee80211_start_scan(sdata, local->scan_req); 1762 ieee80211_start_scan(sdata, local->scan_req);
2527 return; 1763 return;
2528 } 1764 }
2529 1765
2530 if (test_and_clear_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request)) { 1766 if (test_and_clear_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request)) {
2531 if (ieee80211_sta_config_auth(sdata, ifsta)) 1767 if (ieee80211_sta_config_auth(sdata))
2532 return; 1768 return;
2533 clear_bit(IEEE80211_STA_REQ_RUN, &ifsta->request); 1769 clear_bit(IEEE80211_STA_REQ_RUN, &ifmgd->request);
2534 } else if (!test_and_clear_bit(IEEE80211_STA_REQ_RUN, &ifsta->request)) 1770 } else if (!test_and_clear_bit(IEEE80211_STA_REQ_RUN, &ifmgd->request))
2535 return; 1771 return;
2536 1772
2537 switch (ifsta->state) { 1773 switch (ifmgd->state) {
2538 case IEEE80211_STA_MLME_DISABLED: 1774 case IEEE80211_STA_MLME_DISABLED:
2539 break; 1775 break;
2540 case IEEE80211_STA_MLME_DIRECT_PROBE: 1776 case IEEE80211_STA_MLME_DIRECT_PROBE:
2541 ieee80211_direct_probe(sdata, ifsta); 1777 ieee80211_direct_probe(sdata);
2542 break; 1778 break;
2543 case IEEE80211_STA_MLME_AUTHENTICATE: 1779 case IEEE80211_STA_MLME_AUTHENTICATE:
2544 ieee80211_authenticate(sdata, ifsta); 1780 ieee80211_authenticate(sdata);
2545 break; 1781 break;
2546 case IEEE80211_STA_MLME_ASSOCIATE: 1782 case IEEE80211_STA_MLME_ASSOCIATE:
2547 ieee80211_associate(sdata, ifsta); 1783 ieee80211_associate(sdata);
2548 break; 1784 break;
2549 case IEEE80211_STA_MLME_ASSOCIATED: 1785 case IEEE80211_STA_MLME_ASSOCIATED:
2550 ieee80211_associated(sdata, ifsta); 1786 ieee80211_associated(sdata);
2551 break;
2552 case IEEE80211_STA_MLME_IBSS_SEARCH:
2553 ieee80211_sta_find_ibss(sdata, ifsta);
2554 break;
2555 case IEEE80211_STA_MLME_IBSS_JOINED:
2556 ieee80211_sta_merge_ibss(sdata, ifsta);
2557 break; 1787 break;
2558 default: 1788 default:
2559 WARN_ON(1); 1789 WARN_ON(1);
2560 break; 1790 break;
2561 } 1791 }
2562 1792
2563 if (ieee80211_privacy_mismatch(sdata, ifsta)) { 1793 if (ieee80211_privacy_mismatch(sdata)) {
2564 printk(KERN_DEBUG "%s: privacy configuration mismatch and " 1794 printk(KERN_DEBUG "%s: privacy configuration mismatch and "
2565 "mixed-cell disabled - disassociate\n", sdata->dev->name); 1795 "mixed-cell disabled - disassociate\n", sdata->dev->name);
2566 1796
2567 ieee80211_set_disassoc(sdata, ifsta, false, true, 1797 ieee80211_set_disassoc(sdata, false, true,
2568 WLAN_REASON_UNSPECIFIED); 1798 WLAN_REASON_UNSPECIFIED);
2569 } 1799 }
2570} 1800}
@@ -2573,155 +1803,99 @@ static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
2573{ 1803{
2574 if (sdata->vif.type == NL80211_IFTYPE_STATION) 1804 if (sdata->vif.type == NL80211_IFTYPE_STATION)
2575 queue_work(sdata->local->hw.workqueue, 1805 queue_work(sdata->local->hw.workqueue,
2576 &sdata->u.sta.work); 1806 &sdata->u.mgd.work);
2577} 1807}
2578 1808
2579/* interface setup */ 1809/* interface setup */
2580void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata) 1810void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
2581{ 1811{
2582 struct ieee80211_if_sta *ifsta; 1812 struct ieee80211_if_managed *ifmgd;
2583 1813
2584 ifsta = &sdata->u.sta; 1814 ifmgd = &sdata->u.mgd;
2585 INIT_WORK(&ifsta->work, ieee80211_sta_work); 1815 INIT_WORK(&ifmgd->work, ieee80211_sta_work);
2586 INIT_WORK(&ifsta->chswitch_work, ieee80211_chswitch_work); 1816 INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
2587 setup_timer(&ifsta->timer, ieee80211_sta_timer, 1817 setup_timer(&ifmgd->timer, ieee80211_sta_timer,
2588 (unsigned long) sdata); 1818 (unsigned long) sdata);
2589 setup_timer(&ifsta->chswitch_timer, ieee80211_chswitch_timer, 1819 setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
2590 (unsigned long) sdata); 1820 (unsigned long) sdata);
2591 skb_queue_head_init(&ifsta->skb_queue); 1821 skb_queue_head_init(&ifmgd->skb_queue);
2592 1822
2593 ifsta->capab = WLAN_CAPABILITY_ESS; 1823 ifmgd->capab = WLAN_CAPABILITY_ESS;
2594 ifsta->auth_algs = IEEE80211_AUTH_ALG_OPEN | 1824 ifmgd->auth_algs = IEEE80211_AUTH_ALG_OPEN |
2595 IEEE80211_AUTH_ALG_SHARED_KEY; 1825 IEEE80211_AUTH_ALG_SHARED_KEY;
2596 ifsta->flags |= IEEE80211_STA_CREATE_IBSS | 1826 ifmgd->flags |= IEEE80211_STA_CREATE_IBSS |
2597 IEEE80211_STA_AUTO_BSSID_SEL | 1827 IEEE80211_STA_AUTO_BSSID_SEL |
2598 IEEE80211_STA_AUTO_CHANNEL_SEL; 1828 IEEE80211_STA_AUTO_CHANNEL_SEL;
2599 if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4) 1829 if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4)
2600 ifsta->flags |= IEEE80211_STA_WMM_ENABLED; 1830 ifmgd->flags |= IEEE80211_STA_WMM_ENABLED;
2601}
2602
2603/*
2604 * Add a new IBSS station, will also be called by the RX code when,
2605 * in IBSS mode, receiving a frame from a yet-unknown station, hence
2606 * must be callable in atomic context.
2607 */
2608struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
2609 u8 *bssid,u8 *addr, u32 supp_rates)
2610{
2611 struct ieee80211_local *local = sdata->local;
2612 struct sta_info *sta;
2613 int band = local->hw.conf.channel->band;
2614
2615 /* TODO: Could consider removing the least recently used entry and
2616 * allow new one to be added. */
2617 if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
2618 if (net_ratelimit()) {
2619 printk(KERN_DEBUG "%s: No room for a new IBSS STA "
2620 "entry %pM\n", sdata->dev->name, addr);
2621 }
2622 return NULL;
2623 }
2624
2625 if (compare_ether_addr(bssid, sdata->u.sta.bssid))
2626 return NULL;
2627
2628#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2629 printk(KERN_DEBUG "%s: Adding new IBSS station %pM (dev=%s)\n",
2630 wiphy_name(local->hw.wiphy), addr, sdata->dev->name);
2631#endif
2632
2633 sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
2634 if (!sta)
2635 return NULL;
2636
2637 set_sta_flags(sta, WLAN_STA_AUTHORIZED);
2638
2639 /* make sure mandatory rates are always added */
2640 sta->sta.supp_rates[band] = supp_rates |
2641 ieee80211_mandatory_rates(local, band);
2642
2643 rate_control_rate_init(sta);
2644
2645 if (sta_info_insert(sta))
2646 return NULL;
2647
2648 return sta;
2649} 1831}
2650 1832
2651/* configuration hooks */ 1833/* configuration hooks */
2652void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata, 1834void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata)
2653 struct ieee80211_if_sta *ifsta)
2654{ 1835{
1836 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2655 struct ieee80211_local *local = sdata->local; 1837 struct ieee80211_local *local = sdata->local;
2656 1838
2657 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1839 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2658 return; 1840 return;
2659 1841
2660 if ((ifsta->flags & (IEEE80211_STA_BSSID_SET | 1842 if ((ifmgd->flags & (IEEE80211_STA_BSSID_SET |
2661 IEEE80211_STA_AUTO_BSSID_SEL)) && 1843 IEEE80211_STA_AUTO_BSSID_SEL)) &&
2662 (ifsta->flags & (IEEE80211_STA_SSID_SET | 1844 (ifmgd->flags & (IEEE80211_STA_SSID_SET |
2663 IEEE80211_STA_AUTO_SSID_SEL))) { 1845 IEEE80211_STA_AUTO_SSID_SEL))) {
2664 1846
2665 if (ifsta->state == IEEE80211_STA_MLME_ASSOCIATED) 1847 if (ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED)
2666 ieee80211_set_disassoc(sdata, ifsta, true, true, 1848 ieee80211_set_disassoc(sdata, true, true,
2667 WLAN_REASON_DEAUTH_LEAVING); 1849 WLAN_REASON_DEAUTH_LEAVING);
2668 1850
2669 set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request); 1851 set_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request);
2670 queue_work(local->hw.workqueue, &ifsta->work); 1852 queue_work(local->hw.workqueue, &ifmgd->work);
2671 } 1853 }
2672} 1854}
2673 1855
2674int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len) 1856int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len)
2675{ 1857{
2676 struct ieee80211_if_sta *ifsta; 1858 struct ieee80211_if_managed *ifmgd;
2677 1859
2678 if (len > IEEE80211_MAX_SSID_LEN) 1860 if (len > IEEE80211_MAX_SSID_LEN)
2679 return -EINVAL; 1861 return -EINVAL;
2680 1862
2681 ifsta = &sdata->u.sta; 1863 ifmgd = &sdata->u.mgd;
2682 1864
2683 if (ifsta->ssid_len != len || memcmp(ifsta->ssid, ssid, len) != 0) { 1865 if (ifmgd->ssid_len != len || memcmp(ifmgd->ssid, ssid, len) != 0) {
2684 memset(ifsta->ssid, 0, sizeof(ifsta->ssid)); 1866 memset(ifmgd->ssid, 0, sizeof(ifmgd->ssid));
2685 memcpy(ifsta->ssid, ssid, len); 1867 memcpy(ifmgd->ssid, ssid, len);
2686 ifsta->ssid_len = len; 1868 ifmgd->ssid_len = len;
2687 } 1869 }
2688 1870
2689 ifsta->flags &= ~IEEE80211_STA_PREV_BSSID_SET; 1871 ifmgd->flags &= ~IEEE80211_STA_PREV_BSSID_SET;
2690 1872
2691 if (len) 1873 if (len)
2692 ifsta->flags |= IEEE80211_STA_SSID_SET; 1874 ifmgd->flags |= IEEE80211_STA_SSID_SET;
2693 else 1875 else
2694 ifsta->flags &= ~IEEE80211_STA_SSID_SET; 1876 ifmgd->flags &= ~IEEE80211_STA_SSID_SET;
2695
2696 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
2697 ifsta->ibss_join_req = jiffies;
2698 ifsta->state = IEEE80211_STA_MLME_IBSS_SEARCH;
2699 return ieee80211_sta_find_ibss(sdata, ifsta);
2700 }
2701 1877
2702 return 0; 1878 return 0;
2703} 1879}
2704 1880
2705int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len) 1881int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len)
2706{ 1882{
2707 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 1883 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2708 memcpy(ssid, ifsta->ssid, ifsta->ssid_len); 1884 memcpy(ssid, ifmgd->ssid, ifmgd->ssid_len);
2709 *len = ifsta->ssid_len; 1885 *len = ifmgd->ssid_len;
2710 return 0; 1886 return 0;
2711} 1887}
2712 1888
2713int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid) 1889int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid)
2714{ 1890{
2715 struct ieee80211_if_sta *ifsta; 1891 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2716
2717 ifsta = &sdata->u.sta;
2718 1892
2719 if (is_valid_ether_addr(bssid)) { 1893 if (is_valid_ether_addr(bssid)) {
2720 memcpy(ifsta->bssid, bssid, ETH_ALEN); 1894 memcpy(ifmgd->bssid, bssid, ETH_ALEN);
2721 ifsta->flags |= IEEE80211_STA_BSSID_SET; 1895 ifmgd->flags |= IEEE80211_STA_BSSID_SET;
2722 } else { 1896 } else {
2723 memset(ifsta->bssid, 0, ETH_ALEN); 1897 memset(ifmgd->bssid, 0, ETH_ALEN);
2724 ifsta->flags &= ~IEEE80211_STA_BSSID_SET; 1898 ifmgd->flags &= ~IEEE80211_STA_BSSID_SET;
2725 } 1899 }
2726 1900
2727 if (netif_running(sdata->dev)) { 1901 if (netif_running(sdata->dev)) {
@@ -2731,47 +1905,44 @@ int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid)
2731 } 1905 }
2732 } 1906 }
2733 1907
2734 return ieee80211_sta_set_ssid(sdata, ifsta->ssid, ifsta->ssid_len); 1908 return ieee80211_sta_set_ssid(sdata, ifmgd->ssid, ifmgd->ssid_len);
2735} 1909}
2736 1910
2737int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata, char *ie, size_t len) 1911int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata, char *ie, size_t len)
2738{ 1912{
2739 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 1913 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2740 1914
2741 kfree(ifsta->extra_ie); 1915 kfree(ifmgd->extra_ie);
2742 if (len == 0) { 1916 if (len == 0) {
2743 ifsta->extra_ie = NULL; 1917 ifmgd->extra_ie = NULL;
2744 ifsta->extra_ie_len = 0; 1918 ifmgd->extra_ie_len = 0;
2745 return 0; 1919 return 0;
2746 } 1920 }
2747 ifsta->extra_ie = kmalloc(len, GFP_KERNEL); 1921 ifmgd->extra_ie = kmalloc(len, GFP_KERNEL);
2748 if (!ifsta->extra_ie) { 1922 if (!ifmgd->extra_ie) {
2749 ifsta->extra_ie_len = 0; 1923 ifmgd->extra_ie_len = 0;
2750 return -ENOMEM; 1924 return -ENOMEM;
2751 } 1925 }
2752 memcpy(ifsta->extra_ie, ie, len); 1926 memcpy(ifmgd->extra_ie, ie, len);
2753 ifsta->extra_ie_len = len; 1927 ifmgd->extra_ie_len = len;
2754 return 0; 1928 return 0;
2755} 1929}
2756 1930
2757int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason) 1931int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason)
2758{ 1932{
2759 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
2760
2761 printk(KERN_DEBUG "%s: deauthenticating by local choice (reason=%d)\n", 1933 printk(KERN_DEBUG "%s: deauthenticating by local choice (reason=%d)\n",
2762 sdata->dev->name, reason); 1934 sdata->dev->name, reason);
2763 1935
2764 if (sdata->vif.type != NL80211_IFTYPE_STATION && 1936 if (sdata->vif.type != NL80211_IFTYPE_STATION)
2765 sdata->vif.type != NL80211_IFTYPE_ADHOC)
2766 return -EINVAL; 1937 return -EINVAL;
2767 1938
2768 ieee80211_set_disassoc(sdata, ifsta, true, true, reason); 1939 ieee80211_set_disassoc(sdata, true, true, reason);
2769 return 0; 1940 return 0;
2770} 1941}
2771 1942
2772int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason) 1943int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason)
2773{ 1944{
2774 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 1945 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2775 1946
2776 printk(KERN_DEBUG "%s: disassociating by local choice (reason=%d)\n", 1947 printk(KERN_DEBUG "%s: disassociating by local choice (reason=%d)\n",
2777 sdata->dev->name, reason); 1948 sdata->dev->name, reason);
@@ -2779,10 +1950,10 @@ int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason)
2779 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1950 if (sdata->vif.type != NL80211_IFTYPE_STATION)
2780 return -EINVAL; 1951 return -EINVAL;
2781 1952
2782 if (!(ifsta->flags & IEEE80211_STA_ASSOCIATED)) 1953 if (!(ifmgd->flags & IEEE80211_STA_ASSOCIATED))
2783 return -1; 1954 return -ENOLINK;
2784 1955
2785 ieee80211_set_disassoc(sdata, ifsta, false, true, reason); 1956 ieee80211_set_disassoc(sdata, false, true, reason);
2786 return 0; 1957 return 0;
2787} 1958}
2788 1959
@@ -2790,14 +1961,6 @@ int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason)
2790void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local) 1961void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
2791{ 1962{
2792 struct ieee80211_sub_if_data *sdata = local->scan_sdata; 1963 struct ieee80211_sub_if_data *sdata = local->scan_sdata;
2793 struct ieee80211_if_sta *ifsta;
2794
2795 if (sdata && sdata->vif.type == NL80211_IFTYPE_ADHOC) {
2796 ifsta = &sdata->u.sta;
2797 if ((!(ifsta->flags & IEEE80211_STA_PREV_BSSID_SET)) ||
2798 !ieee80211_sta_active_ibss(sdata))
2799 ieee80211_sta_find_ibss(sdata, ifsta);
2800 }
2801 1964
2802 /* Restart STA timers */ 1965 /* Restart STA timers */
2803 rcu_read_lock(); 1966 rcu_read_lock();
@@ -2844,3 +2007,36 @@ void ieee80211_dynamic_ps_timer(unsigned long data)
2844 2007
2845 queue_work(local->hw.workqueue, &local->dynamic_ps_enable_work); 2008 queue_work(local->hw.workqueue, &local->dynamic_ps_enable_work);
2846} 2009}
2010
2011void ieee80211_send_nullfunc(struct ieee80211_local *local,
2012 struct ieee80211_sub_if_data *sdata,
2013 int powersave)
2014{
2015 struct sk_buff *skb;
2016 struct ieee80211_hdr *nullfunc;
2017 __le16 fc;
2018
2019 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2020 return;
2021
2022 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
2023 if (!skb) {
2024 printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
2025 "frame\n", sdata->dev->name);
2026 return;
2027 }
2028 skb_reserve(skb, local->hw.extra_tx_headroom);
2029
2030 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
2031 memset(nullfunc, 0, 24);
2032 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
2033 IEEE80211_FCTL_TODS);
2034 if (powersave)
2035 fc |= cpu_to_le16(IEEE80211_FCTL_PM);
2036 nullfunc->frame_control = fc;
2037 memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
2038 memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
2039 memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
2040
2041 ieee80211_tx_skb(sdata, skb, 0);
2042}
diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
index 1327d424bf31..66f7ecf51b92 100644
--- a/net/mac80211/rx.c
+++ b/net/mac80211/rx.c
@@ -838,7 +838,7 @@ ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
838 if (rx->sdata->vif.type == NL80211_IFTYPE_ADHOC) { 838 if (rx->sdata->vif.type == NL80211_IFTYPE_ADHOC) {
839 u8 *bssid = ieee80211_get_bssid(hdr, rx->skb->len, 839 u8 *bssid = ieee80211_get_bssid(hdr, rx->skb->len,
840 NL80211_IFTYPE_ADHOC); 840 NL80211_IFTYPE_ADHOC);
841 if (compare_ether_addr(bssid, rx->sdata->u.sta.bssid) == 0) 841 if (compare_ether_addr(bssid, rx->sdata->u.ibss.bssid) == 0)
842 sta->last_rx = jiffies; 842 sta->last_rx = jiffies;
843 } else 843 } else
844 if (!is_multicast_ether_addr(hdr->addr1) || 844 if (!is_multicast_ether_addr(hdr->addr1) ||
@@ -1702,13 +1702,13 @@ static void ieee80211_process_sa_query_req(struct ieee80211_sub_if_data *sdata,
1702 return; 1702 return;
1703 } 1703 }
1704 1704
1705 if (compare_ether_addr(mgmt->sa, sdata->u.sta.bssid) != 0 || 1705 if (compare_ether_addr(mgmt->sa, sdata->u.mgd.bssid) != 0 ||
1706 compare_ether_addr(mgmt->bssid, sdata->u.sta.bssid) != 0) { 1706 compare_ether_addr(mgmt->bssid, sdata->u.mgd.bssid) != 0) {
1707 /* Not from the current AP. */ 1707 /* Not from the current AP. */
1708 return; 1708 return;
1709 } 1709 }
1710 1710
1711 if (sdata->u.sta.state == IEEE80211_STA_MLME_ASSOCIATE) { 1711 if (sdata->u.mgd.state == IEEE80211_STA_MLME_ASSOCIATE) {
1712 /* Association in progress; ignore SA Query */ 1712 /* Association in progress; ignore SA Query */
1713 return; 1713 return;
1714 } 1714 }
@@ -1727,7 +1727,7 @@ static void ieee80211_process_sa_query_req(struct ieee80211_sub_if_data *sdata,
1727 memset(resp, 0, 24); 1727 memset(resp, 0, 24);
1728 memcpy(resp->da, mgmt->sa, ETH_ALEN); 1728 memcpy(resp->da, mgmt->sa, ETH_ALEN);
1729 memcpy(resp->sa, sdata->dev->dev_addr, ETH_ALEN); 1729 memcpy(resp->sa, sdata->dev->dev_addr, ETH_ALEN);
1730 memcpy(resp->bssid, sdata->u.sta.bssid, ETH_ALEN); 1730 memcpy(resp->bssid, sdata->u.mgd.bssid, ETH_ALEN);
1731 resp->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 1731 resp->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1732 IEEE80211_STYPE_ACTION); 1732 IEEE80211_STYPE_ACTION);
1733 skb_put(skb, 1 + sizeof(resp->u.action.u.sa_query)); 1733 skb_put(skb, 1 + sizeof(resp->u.action.u.sa_query));
@@ -1745,7 +1745,6 @@ ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
1745{ 1745{
1746 struct ieee80211_local *local = rx->local; 1746 struct ieee80211_local *local = rx->local;
1747 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(rx->dev); 1747 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(rx->dev);
1748 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
1749 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data; 1748 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
1750 struct ieee80211_bss *bss; 1749 struct ieee80211_bss *bss;
1751 int len = rx->skb->len; 1750 int len = rx->skb->len;
@@ -1803,6 +1802,10 @@ ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
1803 case WLAN_CATEGORY_SPECTRUM_MGMT: 1802 case WLAN_CATEGORY_SPECTRUM_MGMT:
1804 if (local->hw.conf.channel->band != IEEE80211_BAND_5GHZ) 1803 if (local->hw.conf.channel->band != IEEE80211_BAND_5GHZ)
1805 return RX_DROP_MONITOR; 1804 return RX_DROP_MONITOR;
1805
1806 if (sdata->vif.type != NL80211_IFTYPE_STATION)
1807 return RX_DROP_MONITOR;
1808
1806 switch (mgmt->u.action.u.measurement.action_code) { 1809 switch (mgmt->u.action.u.measurement.action_code) {
1807 case WLAN_ACTION_SPCT_MSR_REQ: 1810 case WLAN_ACTION_SPCT_MSR_REQ:
1808 if (len < (IEEE80211_MIN_ACTION_SIZE + 1811 if (len < (IEEE80211_MIN_ACTION_SIZE +
@@ -1815,12 +1818,13 @@ ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
1815 sizeof(mgmt->u.action.u.chan_switch))) 1818 sizeof(mgmt->u.action.u.chan_switch)))
1816 return RX_DROP_MONITOR; 1819 return RX_DROP_MONITOR;
1817 1820
1818 if (memcmp(mgmt->bssid, ifsta->bssid, ETH_ALEN) != 0) 1821 if (memcmp(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN))
1819 return RX_DROP_MONITOR; 1822 return RX_DROP_MONITOR;
1820 1823
1821 bss = ieee80211_rx_bss_get(local, ifsta->bssid, 1824 bss = ieee80211_rx_bss_get(local, sdata->u.mgd.bssid,
1822 local->hw.conf.channel->center_freq, 1825 local->hw.conf.channel->center_freq,
1823 ifsta->ssid, ifsta->ssid_len); 1826 sdata->u.mgd.ssid,
1827 sdata->u.mgd.ssid_len);
1824 if (!bss) 1828 if (!bss)
1825 return RX_DROP_MONITOR; 1829 return RX_DROP_MONITOR;
1826 1830
@@ -1876,11 +1880,14 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
1876 sdata->vif.type != NL80211_IFTYPE_ADHOC) 1880 sdata->vif.type != NL80211_IFTYPE_ADHOC)
1877 return RX_DROP_MONITOR; 1881 return RX_DROP_MONITOR;
1878 1882
1879 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME)
1880 return RX_DROP_MONITOR;
1881 1883
1882 ieee80211_sta_rx_mgmt(sdata, rx->skb, rx->status); 1884 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
1883 return RX_QUEUED; 1885 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME)
1886 return RX_DROP_MONITOR;
1887 return ieee80211_sta_rx_mgmt(sdata, rx->skb, rx->status);
1888 }
1889
1890 return ieee80211_ibss_rx_mgmt(sdata, rx->skb, rx->status);
1884} 1891}
1885 1892
1886static void ieee80211_rx_michael_mic_report(struct net_device *dev, 1893static void ieee80211_rx_michael_mic_report(struct net_device *dev,
@@ -2083,7 +2090,7 @@ static int prepare_for_handlers(struct ieee80211_sub_if_data *sdata,
2083 case NL80211_IFTYPE_STATION: 2090 case NL80211_IFTYPE_STATION:
2084 if (!bssid) 2091 if (!bssid)
2085 return 0; 2092 return 0;
2086 if (!ieee80211_bssid_match(bssid, sdata->u.sta.bssid)) { 2093 if (!ieee80211_bssid_match(bssid, sdata->u.mgd.bssid)) {
2087 if (!(rx->flags & IEEE80211_RX_IN_SCAN)) 2094 if (!(rx->flags & IEEE80211_RX_IN_SCAN))
2088 return 0; 2095 return 0;
2089 rx->flags &= ~IEEE80211_RX_RA_MATCH; 2096 rx->flags &= ~IEEE80211_RX_RA_MATCH;
@@ -2101,7 +2108,7 @@ static int prepare_for_handlers(struct ieee80211_sub_if_data *sdata,
2101 if (ieee80211_is_beacon(hdr->frame_control)) { 2108 if (ieee80211_is_beacon(hdr->frame_control)) {
2102 return 1; 2109 return 1;
2103 } 2110 }
2104 else if (!ieee80211_bssid_match(bssid, sdata->u.sta.bssid)) { 2111 else if (!ieee80211_bssid_match(bssid, sdata->u.ibss.bssid)) {
2105 if (!(rx->flags & IEEE80211_RX_IN_SCAN)) 2112 if (!(rx->flags & IEEE80211_RX_IN_SCAN))
2106 return 0; 2113 return 0;
2107 rx->flags &= ~IEEE80211_RX_RA_MATCH; 2114 rx->flags &= ~IEEE80211_RX_RA_MATCH;
diff --git a/net/mac80211/scan.c b/net/mac80211/scan.c
index f883ab9f1e6e..08a1fc27ca10 100644
--- a/net/mac80211/scan.c
+++ b/net/mac80211/scan.c
@@ -207,36 +207,6 @@ ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
207 return RX_QUEUED; 207 return RX_QUEUED;
208} 208}
209 209
210void ieee80211_send_nullfunc(struct ieee80211_local *local,
211 struct ieee80211_sub_if_data *sdata,
212 int powersave)
213{
214 struct sk_buff *skb;
215 struct ieee80211_hdr *nullfunc;
216 __le16 fc;
217
218 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
219 if (!skb) {
220 printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
221 "frame\n", sdata->dev->name);
222 return;
223 }
224 skb_reserve(skb, local->hw.extra_tx_headroom);
225
226 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
227 memset(nullfunc, 0, 24);
228 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
229 IEEE80211_FCTL_TODS);
230 if (powersave)
231 fc |= cpu_to_le16(IEEE80211_FCTL_PM);
232 nullfunc->frame_control = fc;
233 memcpy(nullfunc->addr1, sdata->u.sta.bssid, ETH_ALEN);
234 memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
235 memcpy(nullfunc->addr3, sdata->u.sta.bssid, ETH_ALEN);
236
237 ieee80211_tx_skb(sdata, skb, 0);
238}
239
240void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted) 210void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
241{ 211{
242 struct ieee80211_local *local = hw_to_local(hw); 212 struct ieee80211_local *local = hw_to_local(hw);
@@ -287,7 +257,7 @@ void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
287 257
288 /* Tell AP we're back */ 258 /* Tell AP we're back */
289 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 259 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
290 if (sdata->u.sta.flags & IEEE80211_STA_ASSOCIATED) { 260 if (sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED) {
291 ieee80211_send_nullfunc(local, sdata, 0); 261 ieee80211_send_nullfunc(local, sdata, 0);
292 netif_tx_wake_all_queues(sdata->dev); 262 netif_tx_wake_all_queues(sdata->dev);
293 } 263 }
@@ -305,6 +275,7 @@ void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
305 275
306 done: 276 done:
307 ieee80211_mlme_notify_scan_completed(local); 277 ieee80211_mlme_notify_scan_completed(local);
278 ieee80211_ibss_notify_scan_completed(local);
308 ieee80211_mesh_notify_scan_completed(local); 279 ieee80211_mesh_notify_scan_completed(local);
309} 280}
310EXPORT_SYMBOL(ieee80211_scan_completed); 281EXPORT_SYMBOL(ieee80211_scan_completed);
@@ -442,7 +413,7 @@ int ieee80211_start_scan(struct ieee80211_sub_if_data *scan_sdata,
442 IEEE80211_IFCC_BEACON_ENABLED); 413 IEEE80211_IFCC_BEACON_ENABLED);
443 414
444 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 415 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
445 if (sdata->u.sta.flags & IEEE80211_STA_ASSOCIATED) { 416 if (sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED) {
446 netif_tx_stop_all_queues(sdata->dev); 417 netif_tx_stop_all_queues(sdata->dev);
447 ieee80211_send_nullfunc(local, sdata, 1); 418 ieee80211_send_nullfunc(local, sdata, 1);
448 } 419 }
@@ -477,7 +448,7 @@ int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
477 struct cfg80211_scan_request *req) 448 struct cfg80211_scan_request *req)
478{ 449{
479 struct ieee80211_local *local = sdata->local; 450 struct ieee80211_local *local = sdata->local;
480 struct ieee80211_if_sta *ifsta; 451 struct ieee80211_if_managed *ifmgd;
481 452
482 if (!req) 453 if (!req)
483 return -EINVAL; 454 return -EINVAL;
@@ -502,9 +473,9 @@ int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
502 return -EBUSY; 473 return -EBUSY;
503 } 474 }
504 475
505 ifsta = &sdata->u.sta; 476 ifmgd = &sdata->u.mgd;
506 set_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request); 477 set_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request);
507 queue_work(local->hw.workqueue, &ifsta->work); 478 queue_work(local->hw.workqueue, &ifmgd->work);
508 479
509 return 0; 480 return 0;
510} 481}
diff --git a/net/mac80211/spectmgmt.c b/net/mac80211/spectmgmt.c
index 47bb2aed2813..5f7a2624ed74 100644
--- a/net/mac80211/spectmgmt.c
+++ b/net/mac80211/spectmgmt.c
@@ -88,16 +88,16 @@ void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
88void ieee80211_chswitch_work(struct work_struct *work) 88void ieee80211_chswitch_work(struct work_struct *work)
89{ 89{
90 struct ieee80211_sub_if_data *sdata = 90 struct ieee80211_sub_if_data *sdata =
91 container_of(work, struct ieee80211_sub_if_data, u.sta.chswitch_work); 91 container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
92 struct ieee80211_bss *bss; 92 struct ieee80211_bss *bss;
93 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 93 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
94 94
95 if (!netif_running(sdata->dev)) 95 if (!netif_running(sdata->dev))
96 return; 96 return;
97 97
98 bss = ieee80211_rx_bss_get(sdata->local, ifsta->bssid, 98 bss = ieee80211_rx_bss_get(sdata->local, ifmgd->bssid,
99 sdata->local->hw.conf.channel->center_freq, 99 sdata->local->hw.conf.channel->center_freq,
100 ifsta->ssid, ifsta->ssid_len); 100 ifmgd->ssid, ifmgd->ssid_len);
101 if (!bss) 101 if (!bss)
102 goto exit; 102 goto exit;
103 103
@@ -108,7 +108,7 @@ void ieee80211_chswitch_work(struct work_struct *work)
108 108
109 ieee80211_rx_bss_put(sdata->local, bss); 109 ieee80211_rx_bss_put(sdata->local, bss);
110exit: 110exit:
111 ifsta->flags &= ~IEEE80211_STA_CSA_RECEIVED; 111 ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
112 ieee80211_wake_queues_by_reason(&sdata->local->hw, 112 ieee80211_wake_queues_by_reason(&sdata->local->hw,
113 IEEE80211_QUEUE_STOP_REASON_CSA); 113 IEEE80211_QUEUE_STOP_REASON_CSA);
114} 114}
@@ -117,9 +117,9 @@ void ieee80211_chswitch_timer(unsigned long data)
117{ 117{
118 struct ieee80211_sub_if_data *sdata = 118 struct ieee80211_sub_if_data *sdata =
119 (struct ieee80211_sub_if_data *) data; 119 (struct ieee80211_sub_if_data *) data;
120 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 120 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
121 121
122 queue_work(sdata->local->hw.workqueue, &ifsta->chswitch_work); 122 queue_work(sdata->local->hw.workqueue, &ifmgd->chswitch_work);
123} 123}
124 124
125void ieee80211_process_chanswitch(struct ieee80211_sub_if_data *sdata, 125void ieee80211_process_chanswitch(struct ieee80211_sub_if_data *sdata,
@@ -127,14 +127,14 @@ void ieee80211_process_chanswitch(struct ieee80211_sub_if_data *sdata,
127 struct ieee80211_bss *bss) 127 struct ieee80211_bss *bss)
128{ 128{
129 struct ieee80211_channel *new_ch; 129 struct ieee80211_channel *new_ch;
130 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 130 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
131 int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num); 131 int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num);
132 132
133 /* FIXME: Handle ADHOC later */ 133 /* FIXME: Handle ADHOC later */
134 if (sdata->vif.type != NL80211_IFTYPE_STATION) 134 if (sdata->vif.type != NL80211_IFTYPE_STATION)
135 return; 135 return;
136 136
137 if (ifsta->state != IEEE80211_STA_MLME_ASSOCIATED) 137 if (ifmgd->state != IEEE80211_STA_MLME_ASSOCIATED)
138 return; 138 return;
139 139
140 if (sdata->local->sw_scanning || sdata->local->hw_scanning) 140 if (sdata->local->sw_scanning || sdata->local->hw_scanning)
@@ -143,7 +143,7 @@ void ieee80211_process_chanswitch(struct ieee80211_sub_if_data *sdata,
143 /* Disregard subsequent beacons if we are already running a timer 143 /* Disregard subsequent beacons if we are already running a timer
144 processing a CSA */ 144 processing a CSA */
145 145
146 if (ifsta->flags & IEEE80211_STA_CSA_RECEIVED) 146 if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
147 return; 147 return;
148 148
149 new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq); 149 new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
@@ -153,12 +153,12 @@ void ieee80211_process_chanswitch(struct ieee80211_sub_if_data *sdata,
153 sdata->local->csa_channel = new_ch; 153 sdata->local->csa_channel = new_ch;
154 154
155 if (sw_elem->count <= 1) { 155 if (sw_elem->count <= 1) {
156 queue_work(sdata->local->hw.workqueue, &ifsta->chswitch_work); 156 queue_work(sdata->local->hw.workqueue, &ifmgd->chswitch_work);
157 } else { 157 } else {
158 ieee80211_stop_queues_by_reason(&sdata->local->hw, 158 ieee80211_stop_queues_by_reason(&sdata->local->hw,
159 IEEE80211_QUEUE_STOP_REASON_CSA); 159 IEEE80211_QUEUE_STOP_REASON_CSA);
160 ifsta->flags |= IEEE80211_STA_CSA_RECEIVED; 160 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
161 mod_timer(&ifsta->chswitch_timer, 161 mod_timer(&ifmgd->chswitch_timer,
162 jiffies + 162 jiffies +
163 msecs_to_jiffies(sw_elem->count * 163 msecs_to_jiffies(sw_elem->count *
164 bss->cbss.beacon_interval)); 164 bss->cbss.beacon_interval));
diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
index 6aca49897d55..c3f0e950125b 100644
--- a/net/mac80211/tx.c
+++ b/net/mac80211/tx.c
@@ -1633,7 +1633,7 @@ int ieee80211_subif_start_xmit(struct sk_buff *skb,
1633 case NL80211_IFTYPE_STATION: 1633 case NL80211_IFTYPE_STATION:
1634 fc |= cpu_to_le16(IEEE80211_FCTL_TODS); 1634 fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
1635 /* BSSID SA DA */ 1635 /* BSSID SA DA */
1636 memcpy(hdr.addr1, sdata->u.sta.bssid, ETH_ALEN); 1636 memcpy(hdr.addr1, sdata->u.mgd.bssid, ETH_ALEN);
1637 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN); 1637 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
1638 memcpy(hdr.addr3, skb->data, ETH_ALEN); 1638 memcpy(hdr.addr3, skb->data, ETH_ALEN);
1639 hdrlen = 24; 1639 hdrlen = 24;
@@ -1642,7 +1642,7 @@ int ieee80211_subif_start_xmit(struct sk_buff *skb,
1642 /* DA SA BSSID */ 1642 /* DA SA BSSID */
1643 memcpy(hdr.addr1, skb->data, ETH_ALEN); 1643 memcpy(hdr.addr1, skb->data, ETH_ALEN);
1644 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN); 1644 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
1645 memcpy(hdr.addr3, sdata->u.sta.bssid, ETH_ALEN); 1645 memcpy(hdr.addr3, sdata->u.ibss.bssid, ETH_ALEN);
1646 hdrlen = 24; 1646 hdrlen = 24;
1647 break; 1647 break;
1648 default: 1648 default:
@@ -1928,7 +1928,6 @@ struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
1928 struct ieee80211_tx_info *info; 1928 struct ieee80211_tx_info *info;
1929 struct ieee80211_sub_if_data *sdata = NULL; 1929 struct ieee80211_sub_if_data *sdata = NULL;
1930 struct ieee80211_if_ap *ap = NULL; 1930 struct ieee80211_if_ap *ap = NULL;
1931 struct ieee80211_if_sta *ifsta = NULL;
1932 struct beacon_data *beacon; 1931 struct beacon_data *beacon;
1933 struct ieee80211_supported_band *sband; 1932 struct ieee80211_supported_band *sband;
1934 enum ieee80211_band band = local->hw.conf.channel->band; 1933 enum ieee80211_band band = local->hw.conf.channel->band;
@@ -1980,13 +1979,13 @@ struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
1980 } else 1979 } else
1981 goto out; 1980 goto out;
1982 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { 1981 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
1982 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1983 struct ieee80211_hdr *hdr; 1983 struct ieee80211_hdr *hdr;
1984 ifsta = &sdata->u.sta;
1985 1984
1986 if (!ifsta->probe_resp) 1985 if (!ifibss->probe_resp)
1987 goto out; 1986 goto out;
1988 1987
1989 skb = skb_copy(ifsta->probe_resp, GFP_ATOMIC); 1988 skb = skb_copy(ifibss->probe_resp, GFP_ATOMIC);
1990 if (!skb) 1989 if (!skb)
1991 goto out; 1990 goto out;
1992 1991
diff --git a/net/mac80211/util.c b/net/mac80211/util.c
index 92ea1770461b..dee17e5cbb89 100644
--- a/net/mac80211/util.c
+++ b/net/mac80211/util.c
@@ -750,6 +750,27 @@ void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata)
750 local->ops->conf_tx(local_to_hw(local), i, &qparam); 750 local->ops->conf_tx(local_to_hw(local), i, &qparam);
751} 751}
752 752
753void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
754 const size_t supp_rates_len,
755 const u8 *supp_rates)
756{
757 struct ieee80211_local *local = sdata->local;
758 int i, have_higher_than_11mbit = 0;
759
760 /* cf. IEEE 802.11 9.2.12 */
761 for (i = 0; i < supp_rates_len; i++)
762 if ((supp_rates[i] & 0x7f) * 5 > 110)
763 have_higher_than_11mbit = 1;
764
765 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
766 have_higher_than_11mbit)
767 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
768 else
769 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
770
771 ieee80211_set_wmm_default(sdata);
772}
773
753void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb, 774void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
754 int encrypt) 775 int encrypt)
755{ 776{
@@ -816,3 +837,158 @@ u32 ieee80211_mandatory_rates(struct ieee80211_local *local,
816 mandatory_rates |= BIT(i); 837 mandatory_rates |= BIT(i);
817 return mandatory_rates; 838 return mandatory_rates;
818} 839}
840
841void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
842 u16 transaction, u16 auth_alg,
843 u8 *extra, size_t extra_len,
844 const u8 *bssid, int encrypt)
845{
846 struct ieee80211_local *local = sdata->local;
847 struct sk_buff *skb;
848 struct ieee80211_mgmt *mgmt;
849 const u8 *ie_auth = NULL;
850 int ie_auth_len = 0;
851
852 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
853 ie_auth_len = sdata->u.mgd.ie_auth_len;
854 ie_auth = sdata->u.mgd.ie_auth;
855 }
856
857 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
858 sizeof(*mgmt) + 6 + extra_len + ie_auth_len);
859 if (!skb) {
860 printk(KERN_DEBUG "%s: failed to allocate buffer for auth "
861 "frame\n", sdata->dev->name);
862 return;
863 }
864 skb_reserve(skb, local->hw.extra_tx_headroom);
865
866 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
867 memset(mgmt, 0, 24 + 6);
868 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
869 IEEE80211_STYPE_AUTH);
870 if (encrypt)
871 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
872 memcpy(mgmt->da, bssid, ETH_ALEN);
873 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
874 memcpy(mgmt->bssid, bssid, ETH_ALEN);
875 mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
876 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
877 mgmt->u.auth.status_code = cpu_to_le16(0);
878 if (extra)
879 memcpy(skb_put(skb, extra_len), extra, extra_len);
880 if (ie_auth)
881 memcpy(skb_put(skb, ie_auth_len), ie_auth, ie_auth_len);
882
883 ieee80211_tx_skb(sdata, skb, encrypt);
884}
885
886void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
887 u8 *ssid, size_t ssid_len)
888{
889 struct ieee80211_local *local = sdata->local;
890 struct ieee80211_supported_band *sband;
891 struct sk_buff *skb;
892 struct ieee80211_mgmt *mgmt;
893 u8 *pos, *supp_rates, *esupp_rates = NULL, *extra_preq_ie = NULL;
894 int i, extra_preq_ie_len = 0;
895
896 switch (sdata->vif.type) {
897 case NL80211_IFTYPE_STATION:
898 extra_preq_ie_len = sdata->u.mgd.ie_probereq_len;
899 extra_preq_ie = sdata->u.mgd.ie_probereq;
900 break;
901 default:
902 break;
903 }
904
905 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200 +
906 extra_preq_ie_len);
907 if (!skb) {
908 printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
909 "request\n", sdata->dev->name);
910 return;
911 }
912 skb_reserve(skb, local->hw.extra_tx_headroom);
913
914 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
915 memset(mgmt, 0, 24);
916 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
917 IEEE80211_STYPE_PROBE_REQ);
918 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
919 if (dst) {
920 memcpy(mgmt->da, dst, ETH_ALEN);
921 memcpy(mgmt->bssid, dst, ETH_ALEN);
922 } else {
923 memset(mgmt->da, 0xff, ETH_ALEN);
924 memset(mgmt->bssid, 0xff, ETH_ALEN);
925 }
926 pos = skb_put(skb, 2 + ssid_len);
927 *pos++ = WLAN_EID_SSID;
928 *pos++ = ssid_len;
929 memcpy(pos, ssid, ssid_len);
930
931 supp_rates = skb_put(skb, 2);
932 supp_rates[0] = WLAN_EID_SUPP_RATES;
933 supp_rates[1] = 0;
934 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
935
936 for (i = 0; i < sband->n_bitrates; i++) {
937 struct ieee80211_rate *rate = &sband->bitrates[i];
938 if (esupp_rates) {
939 pos = skb_put(skb, 1);
940 esupp_rates[1]++;
941 } else if (supp_rates[1] == 8) {
942 esupp_rates = skb_put(skb, 3);
943 esupp_rates[0] = WLAN_EID_EXT_SUPP_RATES;
944 esupp_rates[1] = 1;
945 pos = &esupp_rates[2];
946 } else {
947 pos = skb_put(skb, 1);
948 supp_rates[1]++;
949 }
950 *pos = rate->bitrate / 5;
951 }
952
953 if (extra_preq_ie)
954 memcpy(skb_put(skb, extra_preq_ie_len), extra_preq_ie,
955 extra_preq_ie_len);
956
957 ieee80211_tx_skb(sdata, skb, 0);
958}
959
960u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
961 struct ieee802_11_elems *elems,
962 enum ieee80211_band band)
963{
964 struct ieee80211_supported_band *sband;
965 struct ieee80211_rate *bitrates;
966 size_t num_rates;
967 u32 supp_rates;
968 int i, j;
969 sband = local->hw.wiphy->bands[band];
970
971 if (!sband) {
972 WARN_ON(1);
973 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
974 }
975
976 bitrates = sband->bitrates;
977 num_rates = sband->n_bitrates;
978 supp_rates = 0;
979 for (i = 0; i < elems->supp_rates_len +
980 elems->ext_supp_rates_len; i++) {
981 u8 rate = 0;
982 int own_rate;
983 if (i < elems->supp_rates_len)
984 rate = elems->supp_rates[i];
985 else if (elems->ext_supp_rates)
986 rate = elems->ext_supp_rates
987 [i - elems->supp_rates_len];
988 own_rate = 5 * (rate & 0x7f);
989 for (j = 0; j < num_rates; j++)
990 if (bitrates[j].bitrate == own_rate)
991 supp_rates |= BIT(j);
992 }
993 return supp_rates;
994}
diff --git a/net/mac80211/wext.c b/net/mac80211/wext.c
index 2b023dce8b24..8a76a979bc92 100644
--- a/net/mac80211/wext.c
+++ b/net/mac80211/wext.c
@@ -132,13 +132,12 @@ static int ieee80211_ioctl_siwgenie(struct net_device *dev,
132 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME) 132 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME)
133 return -EOPNOTSUPP; 133 return -EOPNOTSUPP;
134 134
135 if (sdata->vif.type == NL80211_IFTYPE_STATION || 135 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
136 sdata->vif.type == NL80211_IFTYPE_ADHOC) {
137 int ret = ieee80211_sta_set_extra_ie(sdata, extra, data->length); 136 int ret = ieee80211_sta_set_extra_ie(sdata, extra, data->length);
138 if (ret) 137 if (ret)
139 return ret; 138 return ret;
140 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL; 139 sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
141 ieee80211_sta_req_auth(sdata, &sdata->u.sta); 140 ieee80211_sta_req_auth(sdata);
142 return 0; 141 return 0;
143 } 142 }
144 143
@@ -255,16 +254,19 @@ static int ieee80211_ioctl_siwfreq(struct net_device *dev,
255{ 254{
256 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 255 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
257 256
258 if (sdata->vif.type == NL80211_IFTYPE_ADHOC || 257 if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
259 sdata->vif.type == NL80211_IFTYPE_STATION) 258 sdata->u.ibss.flags &= ~IEEE80211_IBSS_AUTO_CHANNEL_SEL;
260 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_CHANNEL_SEL; 259 else if (sdata->vif.type == NL80211_IFTYPE_STATION)
260 sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_CHANNEL_SEL;
261 261
262 /* freq->e == 0: freq->m = channel; otherwise freq = m * 10^e */ 262 /* freq->e == 0: freq->m = channel; otherwise freq = m * 10^e */
263 if (freq->e == 0) { 263 if (freq->e == 0) {
264 if (freq->m < 0) { 264 if (freq->m < 0) {
265 if (sdata->vif.type == NL80211_IFTYPE_ADHOC || 265 if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
266 sdata->vif.type == NL80211_IFTYPE_STATION) 266 sdata->u.ibss.flags |=
267 sdata->u.sta.flags |= 267 IEEE80211_IBSS_AUTO_CHANNEL_SEL;
268 else if (sdata->vif.type == NL80211_IFTYPE_STATION)
269 sdata->u.mgd.flags |=
268 IEEE80211_STA_AUTO_CHANNEL_SEL; 270 IEEE80211_STA_AUTO_CHANNEL_SEL;
269 return 0; 271 return 0;
270 } else 272 } else
@@ -301,32 +303,35 @@ static int ieee80211_ioctl_siwessid(struct net_device *dev,
301{ 303{
302 struct ieee80211_sub_if_data *sdata; 304 struct ieee80211_sub_if_data *sdata;
303 size_t len = data->length; 305 size_t len = data->length;
306 int ret;
304 307
305 /* iwconfig uses nul termination in SSID.. */ 308 /* iwconfig uses nul termination in SSID.. */
306 if (len > 0 && ssid[len - 1] == '\0') 309 if (len > 0 && ssid[len - 1] == '\0')
307 len--; 310 len--;
308 311
309 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 312 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
310 if (sdata->vif.type == NL80211_IFTYPE_STATION || 313 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
311 sdata->vif.type == NL80211_IFTYPE_ADHOC) {
312 int ret;
313 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME) { 314 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME) {
314 if (len > IEEE80211_MAX_SSID_LEN) 315 if (len > IEEE80211_MAX_SSID_LEN)
315 return -EINVAL; 316 return -EINVAL;
316 memcpy(sdata->u.sta.ssid, ssid, len); 317 memcpy(sdata->u.mgd.ssid, ssid, len);
317 sdata->u.sta.ssid_len = len; 318 sdata->u.mgd.ssid_len = len;
318 return 0; 319 return 0;
319 } 320 }
321
320 if (data->flags) 322 if (data->flags)
321 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_SSID_SEL; 323 sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_SSID_SEL;
322 else 324 else
323 sdata->u.sta.flags |= IEEE80211_STA_AUTO_SSID_SEL; 325 sdata->u.mgd.flags |= IEEE80211_STA_AUTO_SSID_SEL;
326
324 ret = ieee80211_sta_set_ssid(sdata, ssid, len); 327 ret = ieee80211_sta_set_ssid(sdata, ssid, len);
325 if (ret) 328 if (ret)
326 return ret; 329 return ret;
327 ieee80211_sta_req_auth(sdata, &sdata->u.sta); 330
331 ieee80211_sta_req_auth(sdata);
328 return 0; 332 return 0;
329 } 333 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
334 return ieee80211_ibss_set_ssid(sdata, ssid, len);
330 335
331 return -EOPNOTSUPP; 336 return -EOPNOTSUPP;
332} 337}
@@ -340,8 +345,7 @@ static int ieee80211_ioctl_giwessid(struct net_device *dev,
340 345
341 struct ieee80211_sub_if_data *sdata; 346 struct ieee80211_sub_if_data *sdata;
342 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 347 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
343 if (sdata->vif.type == NL80211_IFTYPE_STATION || 348 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
344 sdata->vif.type == NL80211_IFTYPE_ADHOC) {
345 int res = ieee80211_sta_get_ssid(sdata, ssid, &len); 349 int res = ieee80211_sta_get_ssid(sdata, ssid, &len);
346 if (res == 0) { 350 if (res == 0) {
347 data->length = len; 351 data->length = len;
@@ -349,6 +353,14 @@ static int ieee80211_ioctl_giwessid(struct net_device *dev,
349 } else 353 } else
350 data->flags = 0; 354 data->flags = 0;
351 return res; 355 return res;
356 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
357 int res = ieee80211_ibss_get_ssid(sdata, ssid, &len);
358 if (res == 0) {
359 data->length = len;
360 data->flags = 1;
361 } else
362 data->flags = 0;
363 return res;
352 } 364 }
353 365
354 return -EOPNOTSUPP; 366 return -EOPNOTSUPP;
@@ -362,26 +374,35 @@ static int ieee80211_ioctl_siwap(struct net_device *dev,
362 struct ieee80211_sub_if_data *sdata; 374 struct ieee80211_sub_if_data *sdata;
363 375
364 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 376 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
365 if (sdata->vif.type == NL80211_IFTYPE_STATION || 377 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
366 sdata->vif.type == NL80211_IFTYPE_ADHOC) {
367 int ret; 378 int ret;
368 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME) { 379 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME) {
369 memcpy(sdata->u.sta.bssid, (u8 *) &ap_addr->sa_data, 380 memcpy(sdata->u.mgd.bssid, (u8 *) &ap_addr->sa_data,
370 ETH_ALEN); 381 ETH_ALEN);
371 return 0; 382 return 0;
372 } 383 }
373 if (is_zero_ether_addr((u8 *) &ap_addr->sa_data)) 384 if (is_zero_ether_addr((u8 *) &ap_addr->sa_data))
374 sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL | 385 sdata->u.mgd.flags |= IEEE80211_STA_AUTO_BSSID_SEL |
375 IEEE80211_STA_AUTO_CHANNEL_SEL; 386 IEEE80211_STA_AUTO_CHANNEL_SEL;
376 else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data)) 387 else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data))
377 sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL; 388 sdata->u.mgd.flags |= IEEE80211_STA_AUTO_BSSID_SEL;
378 else 389 else
379 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL; 390 sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
380 ret = ieee80211_sta_set_bssid(sdata, (u8 *) &ap_addr->sa_data); 391 ret = ieee80211_sta_set_bssid(sdata, (u8 *) &ap_addr->sa_data);
381 if (ret) 392 if (ret)
382 return ret; 393 return ret;
383 ieee80211_sta_req_auth(sdata, &sdata->u.sta); 394 ieee80211_sta_req_auth(sdata);
384 return 0; 395 return 0;
396 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
397 if (is_zero_ether_addr((u8 *) &ap_addr->sa_data))
398 sdata->u.ibss.flags |= IEEE80211_IBSS_AUTO_BSSID_SEL |
399 IEEE80211_IBSS_AUTO_CHANNEL_SEL;
400 else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data))
401 sdata->u.ibss.flags |= IEEE80211_IBSS_AUTO_BSSID_SEL;
402 else
403 sdata->u.ibss.flags &= ~IEEE80211_IBSS_AUTO_BSSID_SEL;
404
405 return ieee80211_ibss_set_bssid(sdata, (u8 *) &ap_addr->sa_data);
385 } else if (sdata->vif.type == NL80211_IFTYPE_WDS) { 406 } else if (sdata->vif.type == NL80211_IFTYPE_WDS) {
386 /* 407 /*
387 * If it is necessary to update the WDS peer address 408 * If it is necessary to update the WDS peer address
@@ -410,17 +431,20 @@ static int ieee80211_ioctl_giwap(struct net_device *dev,
410 struct ieee80211_sub_if_data *sdata; 431 struct ieee80211_sub_if_data *sdata;
411 432
412 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 433 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
413 if (sdata->vif.type == NL80211_IFTYPE_STATION || 434 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
414 sdata->vif.type == NL80211_IFTYPE_ADHOC) { 435 if (sdata->u.mgd.state == IEEE80211_STA_MLME_ASSOCIATED) {
415 if (sdata->u.sta.state == IEEE80211_STA_MLME_ASSOCIATED ||
416 sdata->u.sta.state == IEEE80211_STA_MLME_IBSS_JOINED) {
417 ap_addr->sa_family = ARPHRD_ETHER; 436 ap_addr->sa_family = ARPHRD_ETHER;
418 memcpy(&ap_addr->sa_data, sdata->u.sta.bssid, ETH_ALEN); 437 memcpy(&ap_addr->sa_data, sdata->u.mgd.bssid, ETH_ALEN);
419 return 0; 438 } else
420 } else {
421 memset(&ap_addr->sa_data, 0, ETH_ALEN); 439 memset(&ap_addr->sa_data, 0, ETH_ALEN);
422 return 0; 440 return 0;
423 } 441 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
442 if (sdata->u.ibss.state == IEEE80211_IBSS_MLME_JOINED) {
443 ap_addr->sa_family = ARPHRD_ETHER;
444 memcpy(&ap_addr->sa_data, sdata->u.ibss.bssid, ETH_ALEN);
445 } else
446 memset(&ap_addr->sa_data, 0, ETH_ALEN);
447 return 0;
424 } else if (sdata->vif.type == NL80211_IFTYPE_WDS) { 448 } else if (sdata->vif.type == NL80211_IFTYPE_WDS) {
425 ap_addr->sa_family = ARPHRD_ETHER; 449 ap_addr->sa_family = ARPHRD_ETHER;
426 memcpy(&ap_addr->sa_data, sdata->u.wds.remote_addr, ETH_ALEN); 450 memcpy(&ap_addr->sa_data, sdata->u.wds.remote_addr, ETH_ALEN);
@@ -486,7 +510,7 @@ static int ieee80211_ioctl_giwrate(struct net_device *dev,
486 510
487 rcu_read_lock(); 511 rcu_read_lock();
488 512
489 sta = sta_info_get(local, sdata->u.sta.bssid); 513 sta = sta_info_get(local, sdata->u.mgd.bssid);
490 514
491 if (sta && !(sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)) 515 if (sta && !(sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS))
492 rate->value = sband->bitrates[sta->last_tx_rate.idx].bitrate; 516 rate->value = sband->bitrates[sta->last_tx_rate.idx].bitrate;
@@ -687,8 +711,7 @@ static int ieee80211_ioctl_siwmlme(struct net_device *dev,
687 struct iw_mlme *mlme = (struct iw_mlme *) extra; 711 struct iw_mlme *mlme = (struct iw_mlme *) extra;
688 712
689 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 713 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
690 if (sdata->vif.type != NL80211_IFTYPE_STATION && 714 if (!(sdata->vif.type == NL80211_IFTYPE_STATION))
691 sdata->vif.type != NL80211_IFTYPE_ADHOC)
692 return -EINVAL; 715 return -EINVAL;
693 716
694 switch (mlme->cmd) { 717 switch (mlme->cmd) {
@@ -784,8 +807,7 @@ static int ieee80211_ioctl_giwencode(struct net_device *dev,
784 erq->flags |= IW_ENCODE_ENABLED; 807 erq->flags |= IW_ENCODE_ENABLED;
785 808
786 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 809 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
787 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 810 switch (sdata->u.mgd.auth_alg) {
788 switch (ifsta->auth_alg) {
789 case WLAN_AUTH_OPEN: 811 case WLAN_AUTH_OPEN:
790 case WLAN_AUTH_LEAP: 812 case WLAN_AUTH_LEAP:
791 erq->flags |= IW_ENCODE_OPEN; 813 erq->flags |= IW_ENCODE_OPEN;
@@ -849,7 +871,7 @@ static int ieee80211_ioctl_siwpower(struct net_device *dev,
849 ret = ieee80211_hw_config(local, 871 ret = ieee80211_hw_config(local,
850 IEEE80211_CONF_CHANGE_DYNPS_TIMEOUT); 872 IEEE80211_CONF_CHANGE_DYNPS_TIMEOUT);
851 873
852 if (!(sdata->u.sta.flags & IEEE80211_STA_ASSOCIATED)) 874 if (!(sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED))
853 return ret; 875 return ret;
854 876
855 if (conf->dynamic_ps_timeout > 0 && 877 if (conf->dynamic_ps_timeout > 0 &&
@@ -908,10 +930,10 @@ static int ieee80211_ioctl_siwauth(struct net_device *dev,
908 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 930 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
909 if (data->value & (IW_AUTH_CIPHER_WEP40 | 931 if (data->value & (IW_AUTH_CIPHER_WEP40 |
910 IW_AUTH_CIPHER_WEP104 | IW_AUTH_CIPHER_TKIP)) 932 IW_AUTH_CIPHER_WEP104 | IW_AUTH_CIPHER_TKIP))
911 sdata->u.sta.flags |= 933 sdata->u.mgd.flags |=
912 IEEE80211_STA_TKIP_WEP_USED; 934 IEEE80211_STA_TKIP_WEP_USED;
913 else 935 else
914 sdata->u.sta.flags &= 936 sdata->u.mgd.flags &=
915 ~IEEE80211_STA_TKIP_WEP_USED; 937 ~IEEE80211_STA_TKIP_WEP_USED;
916 } 938 }
917 break; 939 break;
@@ -922,21 +944,20 @@ static int ieee80211_ioctl_siwauth(struct net_device *dev,
922 if (sdata->vif.type != NL80211_IFTYPE_STATION) 944 if (sdata->vif.type != NL80211_IFTYPE_STATION)
923 ret = -EINVAL; 945 ret = -EINVAL;
924 else { 946 else {
925 sdata->u.sta.flags &= ~IEEE80211_STA_PRIVACY_INVOKED; 947 sdata->u.mgd.flags &= ~IEEE80211_STA_PRIVACY_INVOKED;
926 /* 948 /*
927 * Privacy invoked by wpa_supplicant, store the 949 * Privacy invoked by wpa_supplicant, store the
928 * value and allow associating to a protected 950 * value and allow associating to a protected
929 * network without having a key up front. 951 * network without having a key up front.
930 */ 952 */
931 if (data->value) 953 if (data->value)
932 sdata->u.sta.flags |= 954 sdata->u.mgd.flags |=
933 IEEE80211_STA_PRIVACY_INVOKED; 955 IEEE80211_STA_PRIVACY_INVOKED;
934 } 956 }
935 break; 957 break;
936 case IW_AUTH_80211_AUTH_ALG: 958 case IW_AUTH_80211_AUTH_ALG:
937 if (sdata->vif.type == NL80211_IFTYPE_STATION || 959 if (sdata->vif.type == NL80211_IFTYPE_STATION)
938 sdata->vif.type == NL80211_IFTYPE_ADHOC) 960 sdata->u.mgd.auth_algs = data->value;
939 sdata->u.sta.auth_algs = data->value;
940 else 961 else
941 ret = -EOPNOTSUPP; 962 ret = -EOPNOTSUPP;
942 break; 963 break;
@@ -945,17 +966,16 @@ static int ieee80211_ioctl_siwauth(struct net_device *dev,
945 ret = -EOPNOTSUPP; 966 ret = -EOPNOTSUPP;
946 break; 967 break;
947 } 968 }
948 if (sdata->vif.type == NL80211_IFTYPE_STATION || 969 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
949 sdata->vif.type == NL80211_IFTYPE_ADHOC) {
950 switch (data->value) { 970 switch (data->value) {
951 case IW_AUTH_MFP_DISABLED: 971 case IW_AUTH_MFP_DISABLED:
952 sdata->u.sta.mfp = IEEE80211_MFP_DISABLED; 972 sdata->u.mgd.mfp = IEEE80211_MFP_DISABLED;
953 break; 973 break;
954 case IW_AUTH_MFP_OPTIONAL: 974 case IW_AUTH_MFP_OPTIONAL:
955 sdata->u.sta.mfp = IEEE80211_MFP_OPTIONAL; 975 sdata->u.mgd.mfp = IEEE80211_MFP_OPTIONAL;
956 break; 976 break;
957 case IW_AUTH_MFP_REQUIRED: 977 case IW_AUTH_MFP_REQUIRED:
958 sdata->u.sta.mfp = IEEE80211_MFP_REQUIRED; 978 sdata->u.mgd.mfp = IEEE80211_MFP_REQUIRED;
959 break; 979 break;
960 default: 980 default:
961 ret = -EINVAL; 981 ret = -EINVAL;
@@ -980,9 +1000,9 @@ static struct iw_statistics *ieee80211_get_wireless_stats(struct net_device *dev
980 1000
981 rcu_read_lock(); 1001 rcu_read_lock();
982 1002
983 if (sdata->vif.type == NL80211_IFTYPE_STATION || 1003 if (sdata->vif.type == NL80211_IFTYPE_STATION)
984 sdata->vif.type == NL80211_IFTYPE_ADHOC) 1004 sta = sta_info_get(local, sdata->u.mgd.bssid);
985 sta = sta_info_get(local, sdata->u.sta.bssid); 1005
986 if (!sta) { 1006 if (!sta) {
987 wstats->discard.fragment = 0; 1007 wstats->discard.fragment = 0;
988 wstats->discard.misc = 0; 1008 wstats->discard.misc = 0;
@@ -1011,9 +1031,8 @@ static int ieee80211_ioctl_giwauth(struct net_device *dev,
1011 1031
1012 switch (data->flags & IW_AUTH_INDEX) { 1032 switch (data->flags & IW_AUTH_INDEX) {
1013 case IW_AUTH_80211_AUTH_ALG: 1033 case IW_AUTH_80211_AUTH_ALG:
1014 if (sdata->vif.type == NL80211_IFTYPE_STATION || 1034 if (sdata->vif.type == NL80211_IFTYPE_STATION)
1015 sdata->vif.type == NL80211_IFTYPE_ADHOC) 1035 data->value = sdata->u.mgd.auth_algs;
1016 data->value = sdata->u.sta.auth_algs;
1017 else 1036 else
1018 ret = -EOPNOTSUPP; 1037 ret = -EOPNOTSUPP;
1019 break; 1038 break;
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-09 02:31:11 -0400