aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorJohannes Berg <johannes@sipsolutions.net>2009-02-15 06:44:28 -0500
committerJohn W. Linville <linville@tuxdriver.com>2009-02-27 14:51:42 -0500
commit469002983fc90c2ff0959e2b03335c0fe2e4d5a9 (patch)
treefdcf78dcdaeadba897abd86d39d0275e236803b3
parent96f5e66e8a79810e2982cdcfa28e554f3d97da21 (diff)
mac80211: split IBSS/managed code
This patch splits out the ibss code and data from managed (station) mode. The reason to do this is to better separate the state machines, and have the code be contained better so it gets easier to determine what exactly a given change will affect, that in turn makes it easier to understand. This is quite some churn, especially because I split sdata->u.sta into sdata->u.mgd and sdata->u.ibss, but I think it's easier to maintain that way. I've also shuffled around some code -- null function sending is only applicable to managed interfaces so put that into that file, some other functions are needed from various places so put them into util, and also rearranged the prototypes in ieee80211_i.h accordingly. Signed-off-by: Johannes Berg <johannes@sipsolutions.net> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat
-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-09-29 09:34:47 -0400