blob: 26838d903b9a962b2efb5f274cad5ef01c24c4fc [file] [log] [blame]
Jouni Malinen6039f6d2009-03-19 13:39:21 +02001/*
2 * cfg80211 MLME SAP interface
3 *
4 * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
5 */
6
7#include <linux/kernel.h>
8#include <linux/module.h>
9#include <linux/netdevice.h>
10#include <linux/nl80211.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090011#include <linux/slab.h>
Johannes Berga9a11622009-07-27 12:01:53 +020012#include <linux/wireless.h>
Jouni Malinen6039f6d2009-03-19 13:39:21 +020013#include <net/cfg80211.h>
Johannes Berga9a11622009-07-27 12:01:53 +020014#include <net/iw_handler.h>
Jouni Malinen6039f6d2009-03-19 13:39:21 +020015#include "core.h"
16#include "nl80211.h"
17
Johannes Bergcb0b4be2009-07-07 03:56:07 +020018void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len)
Jouni Malinen6039f6d2009-03-19 13:39:21 +020019{
Johannes Berg19957bb2009-07-02 17:20:43 +020020 struct wireless_dev *wdev = dev->ieee80211_ptr;
21 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen6039f6d2009-03-19 13:39:21 +020022 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg19957bb2009-07-02 17:20:43 +020023 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
24 u8 *bssid = mgmt->bssid;
25 int i;
26 u16 status = le16_to_cpu(mgmt->u.auth.status_code);
27 bool done = false;
28
Johannes Berg667503d2009-07-07 03:56:11 +020029 wdev_lock(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +020030
Johannes Berg19957bb2009-07-02 17:20:43 +020031 for (i = 0; i < MAX_AUTH_BSSES; i++) {
32 if (wdev->authtry_bsses[i] &&
33 memcmp(wdev->authtry_bsses[i]->pub.bssid, bssid,
34 ETH_ALEN) == 0) {
35 if (status == WLAN_STATUS_SUCCESS) {
36 wdev->auth_bsses[i] = wdev->authtry_bsses[i];
37 } else {
38 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
39 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
40 }
41 wdev->authtry_bsses[i] = NULL;
42 done = true;
43 break;
44 }
45 }
46
Johannes Berg643f82e2010-07-12 14:46:43 +020047 if (done) {
48 nl80211_send_rx_auth(rdev, dev, buf, len, GFP_KERNEL);
49 cfg80211_sme_rx_auth(dev, buf, len);
50 }
Johannes Berg667503d2009-07-07 03:56:11 +020051
52 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +020053}
54EXPORT_SYMBOL(cfg80211_send_rx_auth);
55
Johannes Bergcb0b4be2009-07-07 03:56:07 +020056void cfg80211_send_rx_assoc(struct net_device *dev, const u8 *buf, size_t len)
Jouni Malinen6039f6d2009-03-19 13:39:21 +020057{
Johannes Berg6829c872009-07-02 09:13:27 +020058 u16 status_code;
59 struct wireless_dev *wdev = dev->ieee80211_ptr;
60 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen6039f6d2009-03-19 13:39:21 +020061 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg6829c872009-07-02 09:13:27 +020062 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
63 u8 *ie = mgmt->u.assoc_resp.variable;
Johannes Berg19957bb2009-07-02 17:20:43 +020064 int i, ieoffs = offsetof(struct ieee80211_mgmt, u.assoc_resp.variable);
Johannes Bergdf7fc0f2009-07-29 11:23:49 +020065 struct cfg80211_internal_bss *bss = NULL;
Johannes Berg6829c872009-07-02 09:13:27 +020066
Johannes Berg667503d2009-07-07 03:56:11 +020067 wdev_lock(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +020068
Johannes Berg6829c872009-07-02 09:13:27 +020069 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
70
Johannes Bergf401a6f2009-08-07 14:51:05 +020071 /*
72 * This is a bit of a hack, we don't notify userspace of
73 * a (re-)association reply if we tried to send a reassoc
74 * and got a reject -- we only try again with an assoc
75 * frame instead of reassoc.
76 */
77 if (status_code != WLAN_STATUS_SUCCESS && wdev->conn &&
78 cfg80211_sme_failed_reassoc(wdev))
79 goto out;
80
Johannes Bergcb0b4be2009-07-07 03:56:07 +020081 nl80211_send_rx_assoc(rdev, dev, buf, len, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +020082
Johannes Berg19957bb2009-07-02 17:20:43 +020083 if (status_code == WLAN_STATUS_SUCCESS) {
Johannes Bergdf7fc0f2009-07-29 11:23:49 +020084 for (i = 0; i < MAX_AUTH_BSSES; i++) {
85 if (!wdev->auth_bsses[i])
86 continue;
87 if (memcmp(wdev->auth_bsses[i]->pub.bssid, mgmt->bssid,
88 ETH_ALEN) == 0) {
89 bss = wdev->auth_bsses[i];
Johannes Berg19957bb2009-07-02 17:20:43 +020090 wdev->auth_bsses[i] = NULL;
Johannes Bergdf7fc0f2009-07-29 11:23:49 +020091 /* additional reference to drop hold */
92 cfg80211_ref_bss(bss);
Johannes Berg19957bb2009-07-02 17:20:43 +020093 break;
94 }
95 }
96
Johannes Berg3bdb2d42009-12-23 13:12:05 +010097 /*
98 * We might be coming here because the driver reported
99 * a successful association at the same time as the
100 * user requested a deauth. In that case, we will have
101 * removed the BSS from the auth_bsses list due to the
102 * deauth request when the assoc response makes it. If
103 * the two code paths acquire the lock the other way
104 * around, that's just the standard situation of a
105 * deauth being requested while connected.
106 */
107 if (!bss)
108 goto out;
Johannes Berg7d930bc2009-10-20 15:08:53 +0900109 } else if (wdev->conn) {
110 cfg80211_sme_failed_assoc(wdev);
Johannes Berg7d930bc2009-10-20 15:08:53 +0900111 /*
112 * do not call connect_result() now because the
113 * sme will schedule work that does it later.
114 */
115 goto out;
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200116 }
117
Johannes Bergea416a72009-08-17 12:22:14 +0200118 if (!wdev->conn && wdev->sme_state == CFG80211_SME_IDLE) {
119 /*
120 * This is for the userspace SME, the CONNECTING
121 * state will be changed to CONNECTED by
122 * __cfg80211_connect_result() below.
123 */
124 wdev->sme_state = CFG80211_SME_CONNECTING;
125 }
126
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200127 /* this consumes one bss reference (unless bss is NULL) */
128 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, ie, len - ieoffs,
129 status_code,
130 status_code == WLAN_STATUS_SUCCESS,
131 bss ? &bss->pub : NULL);
132 /* drop hold now, and also reference acquired above */
133 if (bss) {
134 cfg80211_unhold_bss(bss);
135 cfg80211_put_bss(&bss->pub);
Johannes Berg19957bb2009-07-02 17:20:43 +0200136 }
Johannes Berg667503d2009-07-07 03:56:11 +0200137
Johannes Bergf401a6f2009-08-07 14:51:05 +0200138 out:
Johannes Berg667503d2009-07-07 03:56:11 +0200139 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200140}
141EXPORT_SYMBOL(cfg80211_send_rx_assoc);
142
Holger Schurigce470613c2009-10-13 13:28:13 +0200143void __cfg80211_send_deauth(struct net_device *dev,
Johannes Berg667503d2009-07-07 03:56:11 +0200144 const u8 *buf, size_t len)
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200145{
Johannes Berg6829c872009-07-02 09:13:27 +0200146 struct wireless_dev *wdev = dev->ieee80211_ptr;
147 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200148 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg6829c872009-07-02 09:13:27 +0200149 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
Johannes Berg19957bb2009-07-02 17:20:43 +0200150 const u8 *bssid = mgmt->bssid;
151 int i;
Johannes Berg3f3b6a82010-08-05 10:20:27 +0200152 bool found = false, was_current = false;
Johannes Berg6829c872009-07-02 09:13:27 +0200153
Johannes Berg667503d2009-07-07 03:56:11 +0200154 ASSERT_WDEV_LOCK(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200155
Johannes Berg19957bb2009-07-02 17:20:43 +0200156 if (wdev->current_bss &&
157 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
Johannes Berg19957bb2009-07-02 17:20:43 +0200158 cfg80211_unhold_bss(wdev->current_bss);
159 cfg80211_put_bss(&wdev->current_bss->pub);
160 wdev->current_bss = NULL;
Johannes Berg5fba4af2009-12-02 12:43:42 +0100161 found = true;
Johannes Berg3f3b6a82010-08-05 10:20:27 +0200162 was_current = true;
Johannes Berg19957bb2009-07-02 17:20:43 +0200163 } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
164 if (wdev->auth_bsses[i] &&
165 memcmp(wdev->auth_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
166 cfg80211_unhold_bss(wdev->auth_bsses[i]);
167 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
168 wdev->auth_bsses[i] = NULL;
Johannes Berg5fba4af2009-12-02 12:43:42 +0100169 found = true;
Johannes Berg19957bb2009-07-02 17:20:43 +0200170 break;
171 }
172 if (wdev->authtry_bsses[i] &&
173 memcmp(wdev->authtry_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
174 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
175 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
176 wdev->authtry_bsses[i] = NULL;
Johannes Berg5fba4af2009-12-02 12:43:42 +0100177 found = true;
Johannes Berg19957bb2009-07-02 17:20:43 +0200178 break;
179 }
180 }
Johannes Berg19957bb2009-07-02 17:20:43 +0200181
Johannes Berg5fba4af2009-12-02 12:43:42 +0100182 if (!found)
183 return;
184
185 nl80211_send_deauth(rdev, dev, buf, len, GFP_KERNEL);
186
Johannes Berg3f3b6a82010-08-05 10:20:27 +0200187 if (wdev->sme_state == CFG80211_SME_CONNECTED && was_current) {
Johannes Berg6829c872009-07-02 09:13:27 +0200188 u16 reason_code;
189 bool from_ap;
190
191 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
192
Johannes Berge458b8a2009-08-06 20:41:33 +0200193 from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
Johannes Berg667503d2009-07-07 03:56:11 +0200194 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
Johannes Berg6829c872009-07-02 09:13:27 +0200195 } else if (wdev->sme_state == CFG80211_SME_CONNECTING) {
Johannes Berg667503d2009-07-07 03:56:11 +0200196 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,
197 WLAN_STATUS_UNSPECIFIED_FAILURE,
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200198 false, NULL);
Johannes Berg667503d2009-07-07 03:56:11 +0200199 }
200}
Holger Schurigce470613c2009-10-13 13:28:13 +0200201EXPORT_SYMBOL(__cfg80211_send_deauth);
Johannes Berg667503d2009-07-07 03:56:11 +0200202
Holger Schurigce470613c2009-10-13 13:28:13 +0200203void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len)
Johannes Berg667503d2009-07-07 03:56:11 +0200204{
205 struct wireless_dev *wdev = dev->ieee80211_ptr;
206
Holger Schurigce470613c2009-10-13 13:28:13 +0200207 wdev_lock(wdev);
208 __cfg80211_send_deauth(dev, buf, len);
209 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200210}
Jouni Malinen53b46b82009-03-27 20:53:56 +0200211EXPORT_SYMBOL(cfg80211_send_deauth);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200212
Holger Schurigce470613c2009-10-13 13:28:13 +0200213void __cfg80211_send_disassoc(struct net_device *dev,
Johannes Berg667503d2009-07-07 03:56:11 +0200214 const u8 *buf, size_t len)
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200215{
Johannes Berg6829c872009-07-02 09:13:27 +0200216 struct wireless_dev *wdev = dev->ieee80211_ptr;
217 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200218 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg6829c872009-07-02 09:13:27 +0200219 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
Johannes Berg19957bb2009-07-02 17:20:43 +0200220 const u8 *bssid = mgmt->bssid;
221 int i;
222 u16 reason_code;
223 bool from_ap;
224 bool done = false;
Johannes Berg6829c872009-07-02 09:13:27 +0200225
Johannes Berg596a07c2009-07-11 00:17:32 +0200226 ASSERT_WDEV_LOCK(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200227
228 nl80211_send_disassoc(rdev, dev, buf, len, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +0200229
Johannes Berg596a07c2009-07-11 00:17:32 +0200230 if (wdev->sme_state != CFG80211_SME_CONNECTED)
231 return;
Johannes Berg6829c872009-07-02 09:13:27 +0200232
Johannes Berg19957bb2009-07-02 17:20:43 +0200233 if (wdev->current_bss &&
Pavel Roskinb935df02009-08-06 04:52:42 -0400234 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
Johannes Berg19957bb2009-07-02 17:20:43 +0200235 for (i = 0; i < MAX_AUTH_BSSES; i++) {
236 if (wdev->authtry_bsses[i] || wdev->auth_bsses[i])
237 continue;
238 wdev->auth_bsses[i] = wdev->current_bss;
239 wdev->current_bss = NULL;
240 done = true;
241 cfg80211_sme_disassoc(dev, i);
242 break;
243 }
244 WARN_ON(!done);
245 } else
246 WARN_ON(1);
Johannes Berg6829c872009-07-02 09:13:27 +0200247
Johannes Berg6829c872009-07-02 09:13:27 +0200248
Johannes Berg19957bb2009-07-02 17:20:43 +0200249 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
250
Johannes Berge458b8a2009-08-06 20:41:33 +0200251 from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
Johannes Berg667503d2009-07-07 03:56:11 +0200252 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
Johannes Berg667503d2009-07-07 03:56:11 +0200253}
Holger Schurigce470613c2009-10-13 13:28:13 +0200254EXPORT_SYMBOL(__cfg80211_send_disassoc);
Johannes Berg667503d2009-07-07 03:56:11 +0200255
Holger Schurigce470613c2009-10-13 13:28:13 +0200256void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len)
Johannes Berg667503d2009-07-07 03:56:11 +0200257{
258 struct wireless_dev *wdev = dev->ieee80211_ptr;
259
Holger Schurigce470613c2009-10-13 13:28:13 +0200260 wdev_lock(wdev);
261 __cfg80211_send_disassoc(dev, buf, len);
262 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200263}
Jouni Malinen53b46b82009-03-27 20:53:56 +0200264EXPORT_SYMBOL(cfg80211_send_disassoc);
Jouni Malinena3b8b052009-03-27 21:59:49 +0200265
Johannes Berga58ce432009-11-19 12:45:42 +0100266static void __cfg80211_auth_remove(struct wireless_dev *wdev, const u8 *addr)
Jouni Malinen1965c852009-04-22 21:38:25 +0300267{
Johannes Berg19957bb2009-07-02 17:20:43 +0200268 int i;
269 bool done = false;
270
Johannes Berga58ce432009-11-19 12:45:42 +0100271 ASSERT_WDEV_LOCK(wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200272
273 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
274 if (wdev->authtry_bsses[i] &&
275 memcmp(wdev->authtry_bsses[i]->pub.bssid,
276 addr, ETH_ALEN) == 0) {
277 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
278 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
279 wdev->authtry_bsses[i] = NULL;
280 done = true;
281 break;
282 }
283 }
284
285 WARN_ON(!done);
Johannes Berga58ce432009-11-19 12:45:42 +0100286}
287
288void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr)
289{
290 __cfg80211_auth_remove(dev->ieee80211_ptr, addr);
291}
292EXPORT_SYMBOL(__cfg80211_auth_canceled);
293
294void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr)
295{
296 struct wireless_dev *wdev = dev->ieee80211_ptr;
297 struct wiphy *wiphy = wdev->wiphy;
298 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
299
300 wdev_lock(wdev);
301
302 nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
303 if (wdev->sme_state == CFG80211_SME_CONNECTING)
304 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
305 WLAN_STATUS_UNSPECIFIED_FAILURE,
306 false, NULL);
307
308 __cfg80211_auth_remove(wdev, addr);
Johannes Berg667503d2009-07-07 03:56:11 +0200309
310 wdev_unlock(wdev);
Jouni Malinen1965c852009-04-22 21:38:25 +0300311}
312EXPORT_SYMBOL(cfg80211_send_auth_timeout);
313
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200314void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr)
Jouni Malinen1965c852009-04-22 21:38:25 +0300315{
Johannes Berg6829c872009-07-02 09:13:27 +0200316 struct wireless_dev *wdev = dev->ieee80211_ptr;
317 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen1965c852009-04-22 21:38:25 +0300318 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg19957bb2009-07-02 17:20:43 +0200319 int i;
320 bool done = false;
321
Johannes Berg667503d2009-07-07 03:56:11 +0200322 wdev_lock(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200323
324 nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +0200325 if (wdev->sme_state == CFG80211_SME_CONNECTING)
Johannes Berg667503d2009-07-07 03:56:11 +0200326 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
327 WLAN_STATUS_UNSPECIFIED_FAILURE,
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200328 false, NULL);
Johannes Berg19957bb2009-07-02 17:20:43 +0200329
330 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
331 if (wdev->auth_bsses[i] &&
332 memcmp(wdev->auth_bsses[i]->pub.bssid,
333 addr, ETH_ALEN) == 0) {
334 cfg80211_unhold_bss(wdev->auth_bsses[i]);
335 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
336 wdev->auth_bsses[i] = NULL;
337 done = true;
338 break;
339 }
340 }
341
342 WARN_ON(!done);
Johannes Berg667503d2009-07-07 03:56:11 +0200343
344 wdev_unlock(wdev);
Jouni Malinen1965c852009-04-22 21:38:25 +0300345}
346EXPORT_SYMBOL(cfg80211_send_assoc_timeout);
347
Jouni Malinena3b8b052009-03-27 21:59:49 +0200348void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
349 enum nl80211_key_type key_type, int key_id,
Johannes Berge6d6e342009-07-01 21:26:47 +0200350 const u8 *tsc, gfp_t gfp)
Jouni Malinena3b8b052009-03-27 21:59:49 +0200351{
352 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
353 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg3d23e342009-09-29 23:27:28 +0200354#ifdef CONFIG_CFG80211_WEXT
Johannes Bergf58d4ed2009-06-19 02:45:21 +0200355 union iwreq_data wrqu;
Johannes Berge6d6e342009-07-01 21:26:47 +0200356 char *buf = kmalloc(128, gfp);
Johannes Bergf58d4ed2009-06-19 02:45:21 +0200357
358 if (buf) {
359 sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
360 "keyid=%d %scast addr=%pM)", key_id,
361 key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
362 addr);
363 memset(&wrqu, 0, sizeof(wrqu));
364 wrqu.data.length = strlen(buf);
365 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
366 kfree(buf);
367 }
368#endif
369
Johannes Berge6d6e342009-07-01 21:26:47 +0200370 nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
Jouni Malinena3b8b052009-03-27 21:59:49 +0200371}
372EXPORT_SYMBOL(cfg80211_michael_mic_failure);
Johannes Berg19957bb2009-07-02 17:20:43 +0200373
374/* some MLME handling for userspace SME */
Johannes Berg667503d2009-07-07 03:56:11 +0200375int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
376 struct net_device *dev,
377 struct ieee80211_channel *chan,
378 enum nl80211_auth_type auth_type,
379 const u8 *bssid,
380 const u8 *ssid, int ssid_len,
Johannes Bergfffd0932009-07-08 14:22:54 +0200381 const u8 *ie, int ie_len,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300382 const u8 *key, int key_len, int key_idx,
383 bool local_state_change)
Johannes Berg19957bb2009-07-02 17:20:43 +0200384{
385 struct wireless_dev *wdev = dev->ieee80211_ptr;
386 struct cfg80211_auth_request req;
387 struct cfg80211_internal_bss *bss;
388 int i, err, slot = -1, nfree = 0;
389
Johannes Berg667503d2009-07-07 03:56:11 +0200390 ASSERT_WDEV_LOCK(wdev);
391
Johannes Bergfffd0932009-07-08 14:22:54 +0200392 if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
393 if (!key || !key_len || key_idx < 0 || key_idx > 4)
394 return -EINVAL;
395
Johannes Berg0a9b5e12009-07-02 18:26:18 +0200396 if (wdev->current_bss &&
397 memcmp(bssid, wdev->current_bss->pub.bssid, ETH_ALEN) == 0)
398 return -EALREADY;
399
400 for (i = 0; i < MAX_AUTH_BSSES; i++) {
401 if (wdev->authtry_bsses[i] &&
402 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid,
403 ETH_ALEN) == 0)
404 return -EALREADY;
405 if (wdev->auth_bsses[i] &&
406 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid,
407 ETH_ALEN) == 0)
408 return -EALREADY;
409 }
410
Johannes Berg19957bb2009-07-02 17:20:43 +0200411 memset(&req, 0, sizeof(req));
412
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300413 req.local_state_change = local_state_change;
Johannes Berg19957bb2009-07-02 17:20:43 +0200414 req.ie = ie;
415 req.ie_len = ie_len;
416 req.auth_type = auth_type;
417 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
418 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
Johannes Bergfffd0932009-07-08 14:22:54 +0200419 req.key = key;
420 req.key_len = key_len;
421 req.key_idx = key_idx;
Johannes Berg19957bb2009-07-02 17:20:43 +0200422 if (!req.bss)
423 return -ENOENT;
424
425 bss = bss_from_pub(req.bss);
426
427 for (i = 0; i < MAX_AUTH_BSSES; i++) {
Johannes Berg19957bb2009-07-02 17:20:43 +0200428 if (!wdev->auth_bsses[i] && !wdev->authtry_bsses[i]) {
429 slot = i;
430 nfree++;
431 }
432 }
433
434 /* we need one free slot for disassoc and one for this auth */
435 if (nfree < 2) {
436 err = -ENOSPC;
437 goto out;
438 }
439
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300440 if (local_state_change)
441 wdev->auth_bsses[slot] = bss;
442 else
443 wdev->authtry_bsses[slot] = bss;
Johannes Berg19957bb2009-07-02 17:20:43 +0200444 cfg80211_hold_bss(bss);
445
446 err = rdev->ops->auth(&rdev->wiphy, dev, &req);
447 if (err) {
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300448 if (local_state_change)
449 wdev->auth_bsses[slot] = NULL;
450 else
451 wdev->authtry_bsses[slot] = NULL;
Johannes Berg19957bb2009-07-02 17:20:43 +0200452 cfg80211_unhold_bss(bss);
453 }
454
455 out:
456 if (err)
457 cfg80211_put_bss(req.bss);
458 return err;
459}
460
Johannes Berg667503d2009-07-07 03:56:11 +0200461int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
462 struct net_device *dev, struct ieee80211_channel *chan,
463 enum nl80211_auth_type auth_type, const u8 *bssid,
464 const u8 *ssid, int ssid_len,
Johannes Bergfffd0932009-07-08 14:22:54 +0200465 const u8 *ie, int ie_len,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300466 const u8 *key, int key_len, int key_idx,
467 bool local_state_change)
Johannes Berg667503d2009-07-07 03:56:11 +0200468{
469 int err;
470
471 wdev_lock(dev->ieee80211_ptr);
472 err = __cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
Johannes Bergfffd0932009-07-08 14:22:54 +0200473 ssid, ssid_len, ie, ie_len,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300474 key, key_len, key_idx, local_state_change);
Johannes Berg667503d2009-07-07 03:56:11 +0200475 wdev_unlock(dev->ieee80211_ptr);
476
477 return err;
478}
479
480int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
481 struct net_device *dev,
482 struct ieee80211_channel *chan,
483 const u8 *bssid, const u8 *prev_bssid,
484 const u8 *ssid, int ssid_len,
485 const u8 *ie, int ie_len, bool use_mfp,
486 struct cfg80211_crypto_settings *crypt)
Johannes Berg19957bb2009-07-02 17:20:43 +0200487{
488 struct wireless_dev *wdev = dev->ieee80211_ptr;
489 struct cfg80211_assoc_request req;
490 struct cfg80211_internal_bss *bss;
491 int i, err, slot = -1;
Jouni Malinen24b6b152009-11-17 21:35:38 +0200492 bool was_connected = false;
Johannes Berg19957bb2009-07-02 17:20:43 +0200493
Johannes Berg667503d2009-07-07 03:56:11 +0200494 ASSERT_WDEV_LOCK(wdev);
495
Johannes Berg19957bb2009-07-02 17:20:43 +0200496 memset(&req, 0, sizeof(req));
497
Jouni Malinen24b6b152009-11-17 21:35:38 +0200498 if (wdev->current_bss && prev_bssid &&
499 memcmp(wdev->current_bss->pub.bssid, prev_bssid, ETH_ALEN) == 0) {
500 /*
501 * Trying to reassociate: Allow this to proceed and let the old
502 * association to be dropped when the new one is completed.
503 */
504 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
505 was_connected = true;
506 wdev->sme_state = CFG80211_SME_CONNECTING;
507 }
508 } else if (wdev->current_bss)
Johannes Berg19957bb2009-07-02 17:20:43 +0200509 return -EALREADY;
510
511 req.ie = ie;
512 req.ie_len = ie_len;
513 memcpy(&req.crypto, crypt, sizeof(req.crypto));
514 req.use_mfp = use_mfp;
Johannes Berg3e5d7642009-07-07 14:37:26 +0200515 req.prev_bssid = prev_bssid;
Johannes Berg19957bb2009-07-02 17:20:43 +0200516 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
517 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
Jouni Malinen24b6b152009-11-17 21:35:38 +0200518 if (!req.bss) {
519 if (was_connected)
520 wdev->sme_state = CFG80211_SME_CONNECTED;
Johannes Berg19957bb2009-07-02 17:20:43 +0200521 return -ENOENT;
Jouni Malinen24b6b152009-11-17 21:35:38 +0200522 }
Johannes Berg19957bb2009-07-02 17:20:43 +0200523
524 bss = bss_from_pub(req.bss);
525
526 for (i = 0; i < MAX_AUTH_BSSES; i++) {
527 if (bss == wdev->auth_bsses[i]) {
528 slot = i;
529 break;
530 }
531 }
532
533 if (slot < 0) {
534 err = -ENOTCONN;
535 goto out;
536 }
537
538 err = rdev->ops->assoc(&rdev->wiphy, dev, &req);
539 out:
Jouni Malinen24b6b152009-11-17 21:35:38 +0200540 if (err && was_connected)
541 wdev->sme_state = CFG80211_SME_CONNECTED;
Johannes Berg19957bb2009-07-02 17:20:43 +0200542 /* still a reference in wdev->auth_bsses[slot] */
543 cfg80211_put_bss(req.bss);
544 return err;
545}
546
Johannes Berg667503d2009-07-07 03:56:11 +0200547int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
548 struct net_device *dev,
549 struct ieee80211_channel *chan,
550 const u8 *bssid, const u8 *prev_bssid,
551 const u8 *ssid, int ssid_len,
552 const u8 *ie, int ie_len, bool use_mfp,
553 struct cfg80211_crypto_settings *crypt)
554{
555 struct wireless_dev *wdev = dev->ieee80211_ptr;
556 int err;
557
558 wdev_lock(wdev);
559 err = __cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
560 ssid, ssid_len, ie, ie_len, use_mfp, crypt);
561 wdev_unlock(wdev);
562
563 return err;
564}
565
566int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
567 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300568 const u8 *ie, int ie_len, u16 reason,
569 bool local_state_change)
Johannes Berg19957bb2009-07-02 17:20:43 +0200570{
571 struct wireless_dev *wdev = dev->ieee80211_ptr;
572 struct cfg80211_deauth_request req;
573 int i;
574
Johannes Berg667503d2009-07-07 03:56:11 +0200575 ASSERT_WDEV_LOCK(wdev);
576
Johannes Berg19957bb2009-07-02 17:20:43 +0200577 memset(&req, 0, sizeof(req));
578 req.reason_code = reason;
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300579 req.local_state_change = local_state_change;
Johannes Berg19957bb2009-07-02 17:20:43 +0200580 req.ie = ie;
581 req.ie_len = ie_len;
582 if (wdev->current_bss &&
583 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
584 req.bss = &wdev->current_bss->pub;
585 } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
586 if (wdev->auth_bsses[i] &&
587 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
588 req.bss = &wdev->auth_bsses[i]->pub;
589 break;
590 }
591 if (wdev->authtry_bsses[i] &&
592 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
593 req.bss = &wdev->authtry_bsses[i]->pub;
594 break;
595 }
596 }
597
598 if (!req.bss)
599 return -ENOTCONN;
600
Johannes Berg667503d2009-07-07 03:56:11 +0200601 return rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200602}
603
Johannes Berg667503d2009-07-07 03:56:11 +0200604int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
605 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300606 const u8 *ie, int ie_len, u16 reason,
607 bool local_state_change)
Johannes Berg667503d2009-07-07 03:56:11 +0200608{
609 struct wireless_dev *wdev = dev->ieee80211_ptr;
610 int err;
611
612 wdev_lock(wdev);
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300613 err = __cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason,
614 local_state_change);
Johannes Berg667503d2009-07-07 03:56:11 +0200615 wdev_unlock(wdev);
616
617 return err;
618}
619
620static int __cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
621 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300622 const u8 *ie, int ie_len, u16 reason,
623 bool local_state_change)
Johannes Berg19957bb2009-07-02 17:20:43 +0200624{
625 struct wireless_dev *wdev = dev->ieee80211_ptr;
626 struct cfg80211_disassoc_request req;
627
Johannes Berg667503d2009-07-07 03:56:11 +0200628 ASSERT_WDEV_LOCK(wdev);
629
Johannes Bergf9d6b402009-07-27 10:22:28 +0200630 if (wdev->sme_state != CFG80211_SME_CONNECTED)
631 return -ENOTCONN;
632
633 if (WARN_ON(!wdev->current_bss))
634 return -ENOTCONN;
635
Johannes Berg19957bb2009-07-02 17:20:43 +0200636 memset(&req, 0, sizeof(req));
637 req.reason_code = reason;
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300638 req.local_state_change = local_state_change;
Johannes Berg19957bb2009-07-02 17:20:43 +0200639 req.ie = ie;
640 req.ie_len = ie_len;
641 if (memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0)
642 req.bss = &wdev->current_bss->pub;
643 else
644 return -ENOTCONN;
645
Johannes Berg667503d2009-07-07 03:56:11 +0200646 return rdev->ops->disassoc(&rdev->wiphy, dev, &req, wdev);
647}
648
649int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
650 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300651 const u8 *ie, int ie_len, u16 reason,
652 bool local_state_change)
Johannes Berg667503d2009-07-07 03:56:11 +0200653{
654 struct wireless_dev *wdev = dev->ieee80211_ptr;
655 int err;
656
657 wdev_lock(wdev);
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300658 err = __cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason,
659 local_state_change);
Johannes Berg667503d2009-07-07 03:56:11 +0200660 wdev_unlock(wdev);
661
662 return err;
Johannes Berg19957bb2009-07-02 17:20:43 +0200663}
664
665void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
666 struct net_device *dev)
667{
668 struct wireless_dev *wdev = dev->ieee80211_ptr;
669 struct cfg80211_deauth_request req;
670 int i;
671
Johannes Berg667503d2009-07-07 03:56:11 +0200672 ASSERT_WDEV_LOCK(wdev);
673
Johannes Berg19957bb2009-07-02 17:20:43 +0200674 if (!rdev->ops->deauth)
675 return;
676
677 memset(&req, 0, sizeof(req));
678 req.reason_code = WLAN_REASON_DEAUTH_LEAVING;
679 req.ie = NULL;
680 req.ie_len = 0;
681
682 if (wdev->current_bss) {
683 req.bss = &wdev->current_bss->pub;
Johannes Berg667503d2009-07-07 03:56:11 +0200684 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200685 if (wdev->current_bss) {
686 cfg80211_unhold_bss(wdev->current_bss);
687 cfg80211_put_bss(&wdev->current_bss->pub);
688 wdev->current_bss = NULL;
689 }
690 }
691
692 for (i = 0; i < MAX_AUTH_BSSES; i++) {
693 if (wdev->auth_bsses[i]) {
694 req.bss = &wdev->auth_bsses[i]->pub;
Johannes Berg667503d2009-07-07 03:56:11 +0200695 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200696 if (wdev->auth_bsses[i]) {
697 cfg80211_unhold_bss(wdev->auth_bsses[i]);
698 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
699 wdev->auth_bsses[i] = NULL;
700 }
701 }
702 if (wdev->authtry_bsses[i]) {
703 req.bss = &wdev->authtry_bsses[i]->pub;
Johannes Berg667503d2009-07-07 03:56:11 +0200704 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200705 if (wdev->authtry_bsses[i]) {
706 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
707 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
708 wdev->authtry_bsses[i] = NULL;
709 }
710 }
711 }
712}
Jouni Malinen9588bbd2009-12-23 13:15:41 +0100713
714void cfg80211_ready_on_channel(struct net_device *dev, u64 cookie,
715 struct ieee80211_channel *chan,
716 enum nl80211_channel_type channel_type,
717 unsigned int duration, gfp_t gfp)
718{
719 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
720 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
721
722 nl80211_send_remain_on_channel(rdev, dev, cookie, chan, channel_type,
723 duration, gfp);
724}
725EXPORT_SYMBOL(cfg80211_ready_on_channel);
726
727void cfg80211_remain_on_channel_expired(struct net_device *dev,
728 u64 cookie,
729 struct ieee80211_channel *chan,
730 enum nl80211_channel_type channel_type,
731 gfp_t gfp)
732{
733 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
734 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
735
736 nl80211_send_remain_on_channel_cancel(rdev, dev, cookie, chan,
737 channel_type, gfp);
738}
739EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
Johannes Berg98b62182009-12-23 13:15:44 +0100740
741void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
742 struct station_info *sinfo, gfp_t gfp)
743{
744 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
745 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
746
747 nl80211_send_sta_event(rdev, dev, mac_addr, sinfo, gfp);
748}
749EXPORT_SYMBOL(cfg80211_new_sta);
Jouni Malinen026331c2010-02-15 12:53:10 +0200750
Johannes Berg2e161f72010-08-12 15:38:38 +0200751struct cfg80211_mgmt_registration {
Jouni Malinen026331c2010-02-15 12:53:10 +0200752 struct list_head list;
753
754 u32 nlpid;
755
756 int match_len;
757
Johannes Berg2e161f72010-08-12 15:38:38 +0200758 __le16 frame_type;
759
Jouni Malinen026331c2010-02-15 12:53:10 +0200760 u8 match[];
761};
762
Johannes Berg2e161f72010-08-12 15:38:38 +0200763int cfg80211_mlme_register_mgmt(struct wireless_dev *wdev, u32 snd_pid,
764 u16 frame_type, const u8 *match_data,
765 int match_len)
Jouni Malinen026331c2010-02-15 12:53:10 +0200766{
Johannes Berg271733c2010-10-13 12:06:23 +0200767 struct wiphy *wiphy = wdev->wiphy;
768 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg2e161f72010-08-12 15:38:38 +0200769 struct cfg80211_mgmt_registration *reg, *nreg;
Jouni Malinen026331c2010-02-15 12:53:10 +0200770 int err = 0;
Johannes Berg2e161f72010-08-12 15:38:38 +0200771 u16 mgmt_type;
772
773 if (!wdev->wiphy->mgmt_stypes)
774 return -EOPNOTSUPP;
775
776 if ((frame_type & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_MGMT)
777 return -EINVAL;
778
779 if (frame_type & ~(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE))
780 return -EINVAL;
781
782 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
783 if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].rx & BIT(mgmt_type)))
784 return -EINVAL;
Jouni Malinen026331c2010-02-15 12:53:10 +0200785
786 nreg = kzalloc(sizeof(*reg) + match_len, GFP_KERNEL);
787 if (!nreg)
788 return -ENOMEM;
789
Johannes Berg2e161f72010-08-12 15:38:38 +0200790 spin_lock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200791
Johannes Berg2e161f72010-08-12 15:38:38 +0200792 list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
Jouni Malinen026331c2010-02-15 12:53:10 +0200793 int mlen = min(match_len, reg->match_len);
794
Johannes Berg2e161f72010-08-12 15:38:38 +0200795 if (frame_type != le16_to_cpu(reg->frame_type))
796 continue;
797
Jouni Malinen026331c2010-02-15 12:53:10 +0200798 if (memcmp(reg->match, match_data, mlen) == 0) {
799 err = -EALREADY;
800 break;
801 }
802 }
803
804 if (err) {
805 kfree(nreg);
806 goto out;
807 }
808
809 memcpy(nreg->match, match_data, match_len);
810 nreg->match_len = match_len;
811 nreg->nlpid = snd_pid;
Johannes Berg2e161f72010-08-12 15:38:38 +0200812 nreg->frame_type = cpu_to_le16(frame_type);
813 list_add(&nreg->list, &wdev->mgmt_registrations);
Jouni Malinen026331c2010-02-15 12:53:10 +0200814
Johannes Berg271733c2010-10-13 12:06:23 +0200815 if (rdev->ops->mgmt_frame_register)
816 rdev->ops->mgmt_frame_register(wiphy, wdev->netdev,
817 frame_type, true);
818
Jouni Malinen026331c2010-02-15 12:53:10 +0200819 out:
Johannes Berg2e161f72010-08-12 15:38:38 +0200820 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Johannes Berg271733c2010-10-13 12:06:23 +0200821
Jouni Malinen026331c2010-02-15 12:53:10 +0200822 return err;
823}
824
Johannes Berg2e161f72010-08-12 15:38:38 +0200825void cfg80211_mlme_unregister_socket(struct wireless_dev *wdev, u32 nlpid)
Jouni Malinen026331c2010-02-15 12:53:10 +0200826{
Johannes Berg271733c2010-10-13 12:06:23 +0200827 struct wiphy *wiphy = wdev->wiphy;
828 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg2e161f72010-08-12 15:38:38 +0200829 struct cfg80211_mgmt_registration *reg, *tmp;
Jouni Malinen026331c2010-02-15 12:53:10 +0200830
Johannes Berg2e161f72010-08-12 15:38:38 +0200831 spin_lock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200832
Johannes Berg2e161f72010-08-12 15:38:38 +0200833 list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
Johannes Berg271733c2010-10-13 12:06:23 +0200834 if (reg->nlpid != nlpid)
835 continue;
836
837 if (rdev->ops->mgmt_frame_register) {
838 u16 frame_type = le16_to_cpu(reg->frame_type);
839
840 rdev->ops->mgmt_frame_register(wiphy, wdev->netdev,
841 frame_type, false);
Jouni Malinen026331c2010-02-15 12:53:10 +0200842 }
Johannes Berg271733c2010-10-13 12:06:23 +0200843
844 list_del(&reg->list);
845 kfree(reg);
Jouni Malinen026331c2010-02-15 12:53:10 +0200846 }
847
Johannes Berg2e161f72010-08-12 15:38:38 +0200848 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200849}
850
Johannes Berg2e161f72010-08-12 15:38:38 +0200851void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev)
Jouni Malinen026331c2010-02-15 12:53:10 +0200852{
Johannes Berg2e161f72010-08-12 15:38:38 +0200853 struct cfg80211_mgmt_registration *reg, *tmp;
Jouni Malinen026331c2010-02-15 12:53:10 +0200854
Johannes Berg2e161f72010-08-12 15:38:38 +0200855 spin_lock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200856
Johannes Berg2e161f72010-08-12 15:38:38 +0200857 list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
Jouni Malinen026331c2010-02-15 12:53:10 +0200858 list_del(&reg->list);
859 kfree(reg);
860 }
861
Johannes Berg2e161f72010-08-12 15:38:38 +0200862 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200863}
864
Johannes Berg2e161f72010-08-12 15:38:38 +0200865int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
866 struct net_device *dev,
867 struct ieee80211_channel *chan,
868 enum nl80211_channel_type channel_type,
869 bool channel_type_valid,
870 const u8 *buf, size_t len, u64 *cookie)
Jouni Malinen026331c2010-02-15 12:53:10 +0200871{
872 struct wireless_dev *wdev = dev->ieee80211_ptr;
873 const struct ieee80211_mgmt *mgmt;
Johannes Berg2e161f72010-08-12 15:38:38 +0200874 u16 stype;
Jouni Malinen026331c2010-02-15 12:53:10 +0200875
Johannes Berg2e161f72010-08-12 15:38:38 +0200876 if (!wdev->wiphy->mgmt_stypes)
Jouni Malinen026331c2010-02-15 12:53:10 +0200877 return -EOPNOTSUPP;
Johannes Berg2e161f72010-08-12 15:38:38 +0200878
879 if (!rdev->ops->mgmt_tx)
880 return -EOPNOTSUPP;
881
Jouni Malinen026331c2010-02-15 12:53:10 +0200882 if (len < 24 + 1)
883 return -EINVAL;
884
885 mgmt = (const struct ieee80211_mgmt *) buf;
Johannes Berg2e161f72010-08-12 15:38:38 +0200886
887 if (!ieee80211_is_mgmt(mgmt->frame_control))
Jouni Malinen026331c2010-02-15 12:53:10 +0200888 return -EINVAL;
Johannes Berg2e161f72010-08-12 15:38:38 +0200889
890 stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
891 if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].tx & BIT(stype >> 4)))
892 return -EINVAL;
893
894 if (ieee80211_is_action(mgmt->frame_control) &&
895 mgmt->u.action.category != WLAN_CATEGORY_PUBLIC) {
Johannes Berg663fcaf2010-09-30 21:06:09 +0200896 int err = 0;
897
Johannes Bergfe100ac2010-08-09 15:52:03 +0200898 wdev_lock(wdev);
899
Johannes Berg663fcaf2010-09-30 21:06:09 +0200900 switch (wdev->iftype) {
901 case NL80211_IFTYPE_ADHOC:
902 case NL80211_IFTYPE_STATION:
903 case NL80211_IFTYPE_P2P_CLIENT:
904 if (!wdev->current_bss) {
905 err = -ENOTCONN;
906 break;
907 }
Johannes Bergfe100ac2010-08-09 15:52:03 +0200908
Johannes Berg663fcaf2010-09-30 21:06:09 +0200909 if (memcmp(wdev->current_bss->pub.bssid,
910 mgmt->bssid, ETH_ALEN)) {
911 err = -ENOTCONN;
912 break;
913 }
914
915 /*
916 * check for IBSS DA must be done by driver as
917 * cfg80211 doesn't track the stations
918 */
919 if (wdev->iftype == NL80211_IFTYPE_ADHOC)
920 break;
921
922 /* for station, check that DA is the AP */
923 if (memcmp(wdev->current_bss->pub.bssid,
924 mgmt->da, ETH_ALEN)) {
925 err = -ENOTCONN;
926 break;
927 }
928 break;
929 case NL80211_IFTYPE_AP:
930 case NL80211_IFTYPE_P2P_GO:
931 case NL80211_IFTYPE_AP_VLAN:
932 if (memcmp(mgmt->bssid, dev->dev_addr, ETH_ALEN))
933 err = -EINVAL;
934 break;
935 default:
936 err = -EOPNOTSUPP;
937 break;
938 }
Johannes Bergfe100ac2010-08-09 15:52:03 +0200939 wdev_unlock(wdev);
Johannes Berg663fcaf2010-09-30 21:06:09 +0200940
941 if (err)
942 return err;
Jouni Malinen026331c2010-02-15 12:53:10 +0200943 }
944
945 if (memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0)
946 return -EINVAL;
947
948 /* Transmit the Action frame as requested by user space */
Johannes Berg2e161f72010-08-12 15:38:38 +0200949 return rdev->ops->mgmt_tx(&rdev->wiphy, dev, chan, channel_type,
950 channel_type_valid, buf, len, cookie);
Jouni Malinen026331c2010-02-15 12:53:10 +0200951}
952
Johannes Berg2e161f72010-08-12 15:38:38 +0200953bool cfg80211_rx_mgmt(struct net_device *dev, int freq, const u8 *buf,
954 size_t len, gfp_t gfp)
Jouni Malinen026331c2010-02-15 12:53:10 +0200955{
956 struct wireless_dev *wdev = dev->ieee80211_ptr;
957 struct wiphy *wiphy = wdev->wiphy;
958 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg2e161f72010-08-12 15:38:38 +0200959 struct cfg80211_mgmt_registration *reg;
960 const struct ieee80211_txrx_stypes *stypes =
961 &wiphy->mgmt_stypes[wdev->iftype];
962 struct ieee80211_mgmt *mgmt = (void *)buf;
963 const u8 *data;
964 int data_len;
Jouni Malinen026331c2010-02-15 12:53:10 +0200965 bool result = false;
Johannes Berg2e161f72010-08-12 15:38:38 +0200966 __le16 ftype = mgmt->frame_control &
967 cpu_to_le16(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE);
968 u16 stype;
Jouni Malinen026331c2010-02-15 12:53:10 +0200969
Johannes Berg2e161f72010-08-12 15:38:38 +0200970 stype = (le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE) >> 4;
Jouni Malinen026331c2010-02-15 12:53:10 +0200971
Johannes Berg2e161f72010-08-12 15:38:38 +0200972 if (!(stypes->rx & BIT(stype)))
973 return false;
Jouni Malinen026331c2010-02-15 12:53:10 +0200974
Johannes Berg2e161f72010-08-12 15:38:38 +0200975 data = buf + ieee80211_hdrlen(mgmt->frame_control);
976 data_len = len - ieee80211_hdrlen(mgmt->frame_control);
Jouni Malinen026331c2010-02-15 12:53:10 +0200977
Johannes Berg2e161f72010-08-12 15:38:38 +0200978 spin_lock_bh(&wdev->mgmt_registrations_lock);
979
980 list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
981 if (reg->frame_type != ftype)
Jouni Malinen026331c2010-02-15 12:53:10 +0200982 continue;
983
Johannes Berg2e161f72010-08-12 15:38:38 +0200984 if (reg->match_len > data_len)
985 continue;
986
987 if (memcmp(reg->match, data, reg->match_len))
Jouni Malinen026331c2010-02-15 12:53:10 +0200988 continue;
989
990 /* found match! */
991
992 /* Indicate the received Action frame to user space */
Johannes Berg2e161f72010-08-12 15:38:38 +0200993 if (nl80211_send_mgmt(rdev, dev, reg->nlpid, freq,
994 buf, len, gfp))
Jouni Malinen026331c2010-02-15 12:53:10 +0200995 continue;
996
997 result = true;
998 break;
999 }
1000
Johannes Berg2e161f72010-08-12 15:38:38 +02001001 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +02001002
1003 return result;
1004}
Johannes Berg2e161f72010-08-12 15:38:38 +02001005EXPORT_SYMBOL(cfg80211_rx_mgmt);
Jouni Malinen026331c2010-02-15 12:53:10 +02001006
Johannes Berg2e161f72010-08-12 15:38:38 +02001007void cfg80211_mgmt_tx_status(struct net_device *dev, u64 cookie,
1008 const u8 *buf, size_t len, bool ack, gfp_t gfp)
Jouni Malinen026331c2010-02-15 12:53:10 +02001009{
1010 struct wireless_dev *wdev = dev->ieee80211_ptr;
1011 struct wiphy *wiphy = wdev->wiphy;
1012 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
1013
1014 /* Indicate TX status of the Action frame to user space */
Johannes Berg2e161f72010-08-12 15:38:38 +02001015 nl80211_send_mgmt_tx_status(rdev, dev, cookie, buf, len, ack, gfp);
Jouni Malinen026331c2010-02-15 12:53:10 +02001016}
Johannes Berg2e161f72010-08-12 15:38:38 +02001017EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
Juuso Oikarinend6dc1a32010-03-23 09:02:33 +02001018
1019void cfg80211_cqm_rssi_notify(struct net_device *dev,
1020 enum nl80211_cqm_rssi_threshold_event rssi_event,
1021 gfp_t gfp)
1022{
1023 struct wireless_dev *wdev = dev->ieee80211_ptr;
1024 struct wiphy *wiphy = wdev->wiphy;
1025 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
1026
1027 /* Indicate roaming trigger event to user space */
1028 nl80211_send_cqm_rssi_notify(rdev, dev, rssi_event, gfp);
1029}
1030EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);