blob: 493b939970cd6cbefbd7ebad18cbf6c4d1405ed5 [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
Jouni Malinencf4e5942010-12-16 00:52:40 +0200266void cfg80211_send_unprot_deauth(struct net_device *dev, const u8 *buf,
267 size_t len)
268{
269 struct wireless_dev *wdev = dev->ieee80211_ptr;
270 struct wiphy *wiphy = wdev->wiphy;
271 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
272
273 nl80211_send_unprot_deauth(rdev, dev, buf, len, GFP_ATOMIC);
274}
275EXPORT_SYMBOL(cfg80211_send_unprot_deauth);
276
277void cfg80211_send_unprot_disassoc(struct net_device *dev, const u8 *buf,
278 size_t len)
279{
280 struct wireless_dev *wdev = dev->ieee80211_ptr;
281 struct wiphy *wiphy = wdev->wiphy;
282 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
283
284 nl80211_send_unprot_disassoc(rdev, dev, buf, len, GFP_ATOMIC);
285}
286EXPORT_SYMBOL(cfg80211_send_unprot_disassoc);
287
Johannes Berga58ce432009-11-19 12:45:42 +0100288static void __cfg80211_auth_remove(struct wireless_dev *wdev, const u8 *addr)
Jouni Malinen1965c852009-04-22 21:38:25 +0300289{
Johannes Berg19957bb2009-07-02 17:20:43 +0200290 int i;
291 bool done = false;
292
Johannes Berga58ce432009-11-19 12:45:42 +0100293 ASSERT_WDEV_LOCK(wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200294
295 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
296 if (wdev->authtry_bsses[i] &&
297 memcmp(wdev->authtry_bsses[i]->pub.bssid,
298 addr, ETH_ALEN) == 0) {
299 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
300 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
301 wdev->authtry_bsses[i] = NULL;
302 done = true;
303 break;
304 }
305 }
306
307 WARN_ON(!done);
Johannes Berga58ce432009-11-19 12:45:42 +0100308}
309
310void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr)
311{
312 __cfg80211_auth_remove(dev->ieee80211_ptr, addr);
313}
314EXPORT_SYMBOL(__cfg80211_auth_canceled);
315
316void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr)
317{
318 struct wireless_dev *wdev = dev->ieee80211_ptr;
319 struct wiphy *wiphy = wdev->wiphy;
320 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
321
322 wdev_lock(wdev);
323
324 nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
325 if (wdev->sme_state == CFG80211_SME_CONNECTING)
326 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
327 WLAN_STATUS_UNSPECIFIED_FAILURE,
328 false, NULL);
329
330 __cfg80211_auth_remove(wdev, addr);
Johannes Berg667503d2009-07-07 03:56:11 +0200331
332 wdev_unlock(wdev);
Jouni Malinen1965c852009-04-22 21:38:25 +0300333}
334EXPORT_SYMBOL(cfg80211_send_auth_timeout);
335
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200336void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr)
Jouni Malinen1965c852009-04-22 21:38:25 +0300337{
Johannes Berg6829c872009-07-02 09:13:27 +0200338 struct wireless_dev *wdev = dev->ieee80211_ptr;
339 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen1965c852009-04-22 21:38:25 +0300340 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg19957bb2009-07-02 17:20:43 +0200341 int i;
342 bool done = false;
343
Johannes Berg667503d2009-07-07 03:56:11 +0200344 wdev_lock(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200345
346 nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +0200347 if (wdev->sme_state == CFG80211_SME_CONNECTING)
Johannes Berg667503d2009-07-07 03:56:11 +0200348 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
349 WLAN_STATUS_UNSPECIFIED_FAILURE,
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200350 false, NULL);
Johannes Berg19957bb2009-07-02 17:20:43 +0200351
352 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
353 if (wdev->auth_bsses[i] &&
354 memcmp(wdev->auth_bsses[i]->pub.bssid,
355 addr, ETH_ALEN) == 0) {
356 cfg80211_unhold_bss(wdev->auth_bsses[i]);
357 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
358 wdev->auth_bsses[i] = NULL;
359 done = true;
360 break;
361 }
362 }
363
364 WARN_ON(!done);
Johannes Berg667503d2009-07-07 03:56:11 +0200365
366 wdev_unlock(wdev);
Jouni Malinen1965c852009-04-22 21:38:25 +0300367}
368EXPORT_SYMBOL(cfg80211_send_assoc_timeout);
369
Jouni Malinena3b8b052009-03-27 21:59:49 +0200370void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
371 enum nl80211_key_type key_type, int key_id,
Johannes Berge6d6e342009-07-01 21:26:47 +0200372 const u8 *tsc, gfp_t gfp)
Jouni Malinena3b8b052009-03-27 21:59:49 +0200373{
374 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
375 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg3d23e342009-09-29 23:27:28 +0200376#ifdef CONFIG_CFG80211_WEXT
Johannes Bergf58d4ed2009-06-19 02:45:21 +0200377 union iwreq_data wrqu;
Johannes Berge6d6e342009-07-01 21:26:47 +0200378 char *buf = kmalloc(128, gfp);
Johannes Bergf58d4ed2009-06-19 02:45:21 +0200379
380 if (buf) {
381 sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
382 "keyid=%d %scast addr=%pM)", key_id,
383 key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
384 addr);
385 memset(&wrqu, 0, sizeof(wrqu));
386 wrqu.data.length = strlen(buf);
387 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
388 kfree(buf);
389 }
390#endif
391
Johannes Berge6d6e342009-07-01 21:26:47 +0200392 nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
Jouni Malinena3b8b052009-03-27 21:59:49 +0200393}
394EXPORT_SYMBOL(cfg80211_michael_mic_failure);
Johannes Berg19957bb2009-07-02 17:20:43 +0200395
396/* some MLME handling for userspace SME */
Johannes Berg667503d2009-07-07 03:56:11 +0200397int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
398 struct net_device *dev,
399 struct ieee80211_channel *chan,
400 enum nl80211_auth_type auth_type,
401 const u8 *bssid,
402 const u8 *ssid, int ssid_len,
Johannes Bergfffd0932009-07-08 14:22:54 +0200403 const u8 *ie, int ie_len,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300404 const u8 *key, int key_len, int key_idx,
405 bool local_state_change)
Johannes Berg19957bb2009-07-02 17:20:43 +0200406{
407 struct wireless_dev *wdev = dev->ieee80211_ptr;
408 struct cfg80211_auth_request req;
409 struct cfg80211_internal_bss *bss;
410 int i, err, slot = -1, nfree = 0;
411
Johannes Berg667503d2009-07-07 03:56:11 +0200412 ASSERT_WDEV_LOCK(wdev);
413
Johannes Bergfffd0932009-07-08 14:22:54 +0200414 if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
415 if (!key || !key_len || key_idx < 0 || key_idx > 4)
416 return -EINVAL;
417
Johannes Berg0a9b5e12009-07-02 18:26:18 +0200418 if (wdev->current_bss &&
419 memcmp(bssid, wdev->current_bss->pub.bssid, ETH_ALEN) == 0)
420 return -EALREADY;
421
422 for (i = 0; i < MAX_AUTH_BSSES; i++) {
423 if (wdev->authtry_bsses[i] &&
424 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid,
425 ETH_ALEN) == 0)
426 return -EALREADY;
427 if (wdev->auth_bsses[i] &&
428 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid,
429 ETH_ALEN) == 0)
430 return -EALREADY;
431 }
432
Johannes Berg19957bb2009-07-02 17:20:43 +0200433 memset(&req, 0, sizeof(req));
434
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300435 req.local_state_change = local_state_change;
Johannes Berg19957bb2009-07-02 17:20:43 +0200436 req.ie = ie;
437 req.ie_len = ie_len;
438 req.auth_type = auth_type;
439 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
440 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
Johannes Bergfffd0932009-07-08 14:22:54 +0200441 req.key = key;
442 req.key_len = key_len;
443 req.key_idx = key_idx;
Johannes Berg19957bb2009-07-02 17:20:43 +0200444 if (!req.bss)
445 return -ENOENT;
446
447 bss = bss_from_pub(req.bss);
448
449 for (i = 0; i < MAX_AUTH_BSSES; i++) {
Johannes Berg19957bb2009-07-02 17:20:43 +0200450 if (!wdev->auth_bsses[i] && !wdev->authtry_bsses[i]) {
451 slot = i;
452 nfree++;
453 }
454 }
455
456 /* we need one free slot for disassoc and one for this auth */
457 if (nfree < 2) {
458 err = -ENOSPC;
459 goto out;
460 }
461
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300462 if (local_state_change)
463 wdev->auth_bsses[slot] = bss;
464 else
465 wdev->authtry_bsses[slot] = bss;
Johannes Berg19957bb2009-07-02 17:20:43 +0200466 cfg80211_hold_bss(bss);
467
468 err = rdev->ops->auth(&rdev->wiphy, dev, &req);
469 if (err) {
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300470 if (local_state_change)
471 wdev->auth_bsses[slot] = NULL;
472 else
473 wdev->authtry_bsses[slot] = NULL;
Johannes Berg19957bb2009-07-02 17:20:43 +0200474 cfg80211_unhold_bss(bss);
475 }
476
477 out:
478 if (err)
479 cfg80211_put_bss(req.bss);
480 return err;
481}
482
Johannes Berg667503d2009-07-07 03:56:11 +0200483int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
484 struct net_device *dev, struct ieee80211_channel *chan,
485 enum nl80211_auth_type auth_type, const u8 *bssid,
486 const u8 *ssid, int ssid_len,
Johannes Bergfffd0932009-07-08 14:22:54 +0200487 const u8 *ie, int ie_len,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300488 const u8 *key, int key_len, int key_idx,
489 bool local_state_change)
Johannes Berg667503d2009-07-07 03:56:11 +0200490{
491 int err;
492
493 wdev_lock(dev->ieee80211_ptr);
494 err = __cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
Johannes Bergfffd0932009-07-08 14:22:54 +0200495 ssid, ssid_len, ie, ie_len,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300496 key, key_len, key_idx, local_state_change);
Johannes Berg667503d2009-07-07 03:56:11 +0200497 wdev_unlock(dev->ieee80211_ptr);
498
499 return err;
500}
501
502int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
503 struct net_device *dev,
504 struct ieee80211_channel *chan,
505 const u8 *bssid, const u8 *prev_bssid,
506 const u8 *ssid, int ssid_len,
507 const u8 *ie, int ie_len, bool use_mfp,
508 struct cfg80211_crypto_settings *crypt)
Johannes Berg19957bb2009-07-02 17:20:43 +0200509{
510 struct wireless_dev *wdev = dev->ieee80211_ptr;
511 struct cfg80211_assoc_request req;
512 struct cfg80211_internal_bss *bss;
513 int i, err, slot = -1;
Jouni Malinen24b6b152009-11-17 21:35:38 +0200514 bool was_connected = false;
Johannes Berg19957bb2009-07-02 17:20:43 +0200515
Johannes Berg667503d2009-07-07 03:56:11 +0200516 ASSERT_WDEV_LOCK(wdev);
517
Johannes Berg19957bb2009-07-02 17:20:43 +0200518 memset(&req, 0, sizeof(req));
519
Jouni Malinen24b6b152009-11-17 21:35:38 +0200520 if (wdev->current_bss && prev_bssid &&
521 memcmp(wdev->current_bss->pub.bssid, prev_bssid, ETH_ALEN) == 0) {
522 /*
523 * Trying to reassociate: Allow this to proceed and let the old
524 * association to be dropped when the new one is completed.
525 */
526 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
527 was_connected = true;
528 wdev->sme_state = CFG80211_SME_CONNECTING;
529 }
530 } else if (wdev->current_bss)
Johannes Berg19957bb2009-07-02 17:20:43 +0200531 return -EALREADY;
532
533 req.ie = ie;
534 req.ie_len = ie_len;
535 memcpy(&req.crypto, crypt, sizeof(req.crypto));
536 req.use_mfp = use_mfp;
Johannes Berg3e5d7642009-07-07 14:37:26 +0200537 req.prev_bssid = prev_bssid;
Johannes Berg19957bb2009-07-02 17:20:43 +0200538 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
539 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
Jouni Malinen24b6b152009-11-17 21:35:38 +0200540 if (!req.bss) {
541 if (was_connected)
542 wdev->sme_state = CFG80211_SME_CONNECTED;
Johannes Berg19957bb2009-07-02 17:20:43 +0200543 return -ENOENT;
Jouni Malinen24b6b152009-11-17 21:35:38 +0200544 }
Johannes Berg19957bb2009-07-02 17:20:43 +0200545
546 bss = bss_from_pub(req.bss);
547
548 for (i = 0; i < MAX_AUTH_BSSES; i++) {
549 if (bss == wdev->auth_bsses[i]) {
550 slot = i;
551 break;
552 }
553 }
554
555 if (slot < 0) {
556 err = -ENOTCONN;
557 goto out;
558 }
559
560 err = rdev->ops->assoc(&rdev->wiphy, dev, &req);
561 out:
Jouni Malinen24b6b152009-11-17 21:35:38 +0200562 if (err && was_connected)
563 wdev->sme_state = CFG80211_SME_CONNECTED;
Johannes Berg19957bb2009-07-02 17:20:43 +0200564 /* still a reference in wdev->auth_bsses[slot] */
565 cfg80211_put_bss(req.bss);
566 return err;
567}
568
Johannes Berg667503d2009-07-07 03:56:11 +0200569int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
570 struct net_device *dev,
571 struct ieee80211_channel *chan,
572 const u8 *bssid, const u8 *prev_bssid,
573 const u8 *ssid, int ssid_len,
574 const u8 *ie, int ie_len, bool use_mfp,
575 struct cfg80211_crypto_settings *crypt)
576{
577 struct wireless_dev *wdev = dev->ieee80211_ptr;
578 int err;
579
580 wdev_lock(wdev);
581 err = __cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
582 ssid, ssid_len, ie, ie_len, use_mfp, crypt);
583 wdev_unlock(wdev);
584
585 return err;
586}
587
588int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
589 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300590 const u8 *ie, int ie_len, u16 reason,
591 bool local_state_change)
Johannes Berg19957bb2009-07-02 17:20:43 +0200592{
593 struct wireless_dev *wdev = dev->ieee80211_ptr;
594 struct cfg80211_deauth_request req;
595 int i;
596
Johannes Berg667503d2009-07-07 03:56:11 +0200597 ASSERT_WDEV_LOCK(wdev);
598
Johannes Berg19957bb2009-07-02 17:20:43 +0200599 memset(&req, 0, sizeof(req));
600 req.reason_code = reason;
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300601 req.local_state_change = local_state_change;
Johannes Berg19957bb2009-07-02 17:20:43 +0200602 req.ie = ie;
603 req.ie_len = ie_len;
604 if (wdev->current_bss &&
605 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
606 req.bss = &wdev->current_bss->pub;
607 } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
608 if (wdev->auth_bsses[i] &&
609 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
610 req.bss = &wdev->auth_bsses[i]->pub;
611 break;
612 }
613 if (wdev->authtry_bsses[i] &&
614 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
615 req.bss = &wdev->authtry_bsses[i]->pub;
616 break;
617 }
618 }
619
620 if (!req.bss)
621 return -ENOTCONN;
622
Johannes Berg667503d2009-07-07 03:56:11 +0200623 return rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200624}
625
Johannes Berg667503d2009-07-07 03:56:11 +0200626int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
627 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300628 const u8 *ie, int ie_len, u16 reason,
629 bool local_state_change)
Johannes Berg667503d2009-07-07 03:56:11 +0200630{
631 struct wireless_dev *wdev = dev->ieee80211_ptr;
632 int err;
633
634 wdev_lock(wdev);
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300635 err = __cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason,
636 local_state_change);
Johannes Berg667503d2009-07-07 03:56:11 +0200637 wdev_unlock(wdev);
638
639 return err;
640}
641
642static int __cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
643 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300644 const u8 *ie, int ie_len, u16 reason,
645 bool local_state_change)
Johannes Berg19957bb2009-07-02 17:20:43 +0200646{
647 struct wireless_dev *wdev = dev->ieee80211_ptr;
648 struct cfg80211_disassoc_request req;
649
Johannes Berg667503d2009-07-07 03:56:11 +0200650 ASSERT_WDEV_LOCK(wdev);
651
Johannes Bergf9d6b402009-07-27 10:22:28 +0200652 if (wdev->sme_state != CFG80211_SME_CONNECTED)
653 return -ENOTCONN;
654
655 if (WARN_ON(!wdev->current_bss))
656 return -ENOTCONN;
657
Johannes Berg19957bb2009-07-02 17:20:43 +0200658 memset(&req, 0, sizeof(req));
659 req.reason_code = reason;
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300660 req.local_state_change = local_state_change;
Johannes Berg19957bb2009-07-02 17:20:43 +0200661 req.ie = ie;
662 req.ie_len = ie_len;
663 if (memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0)
664 req.bss = &wdev->current_bss->pub;
665 else
666 return -ENOTCONN;
667
Johannes Berg667503d2009-07-07 03:56:11 +0200668 return rdev->ops->disassoc(&rdev->wiphy, dev, &req, wdev);
669}
670
671int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
672 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300673 const u8 *ie, int ie_len, u16 reason,
674 bool local_state_change)
Johannes Berg667503d2009-07-07 03:56:11 +0200675{
676 struct wireless_dev *wdev = dev->ieee80211_ptr;
677 int err;
678
679 wdev_lock(wdev);
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300680 err = __cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason,
681 local_state_change);
Johannes Berg667503d2009-07-07 03:56:11 +0200682 wdev_unlock(wdev);
683
684 return err;
Johannes Berg19957bb2009-07-02 17:20:43 +0200685}
686
687void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
688 struct net_device *dev)
689{
690 struct wireless_dev *wdev = dev->ieee80211_ptr;
691 struct cfg80211_deauth_request req;
692 int i;
693
Johannes Berg667503d2009-07-07 03:56:11 +0200694 ASSERT_WDEV_LOCK(wdev);
695
Johannes Berg19957bb2009-07-02 17:20:43 +0200696 if (!rdev->ops->deauth)
697 return;
698
699 memset(&req, 0, sizeof(req));
700 req.reason_code = WLAN_REASON_DEAUTH_LEAVING;
701 req.ie = NULL;
702 req.ie_len = 0;
703
704 if (wdev->current_bss) {
705 req.bss = &wdev->current_bss->pub;
Johannes Berg667503d2009-07-07 03:56:11 +0200706 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200707 if (wdev->current_bss) {
708 cfg80211_unhold_bss(wdev->current_bss);
709 cfg80211_put_bss(&wdev->current_bss->pub);
710 wdev->current_bss = NULL;
711 }
712 }
713
714 for (i = 0; i < MAX_AUTH_BSSES; i++) {
715 if (wdev->auth_bsses[i]) {
716 req.bss = &wdev->auth_bsses[i]->pub;
Johannes Berg667503d2009-07-07 03:56:11 +0200717 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200718 if (wdev->auth_bsses[i]) {
719 cfg80211_unhold_bss(wdev->auth_bsses[i]);
720 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
721 wdev->auth_bsses[i] = NULL;
722 }
723 }
724 if (wdev->authtry_bsses[i]) {
725 req.bss = &wdev->authtry_bsses[i]->pub;
Johannes Berg667503d2009-07-07 03:56:11 +0200726 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200727 if (wdev->authtry_bsses[i]) {
728 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
729 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
730 wdev->authtry_bsses[i] = NULL;
731 }
732 }
733 }
734}
Jouni Malinen9588bbd2009-12-23 13:15:41 +0100735
736void cfg80211_ready_on_channel(struct net_device *dev, u64 cookie,
737 struct ieee80211_channel *chan,
738 enum nl80211_channel_type channel_type,
739 unsigned int duration, gfp_t gfp)
740{
741 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
742 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
743
744 nl80211_send_remain_on_channel(rdev, dev, cookie, chan, channel_type,
745 duration, gfp);
746}
747EXPORT_SYMBOL(cfg80211_ready_on_channel);
748
749void cfg80211_remain_on_channel_expired(struct net_device *dev,
750 u64 cookie,
751 struct ieee80211_channel *chan,
752 enum nl80211_channel_type channel_type,
753 gfp_t gfp)
754{
755 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
756 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
757
758 nl80211_send_remain_on_channel_cancel(rdev, dev, cookie, chan,
759 channel_type, gfp);
760}
761EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
Johannes Berg98b62182009-12-23 13:15:44 +0100762
763void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
764 struct station_info *sinfo, gfp_t gfp)
765{
766 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
767 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
768
769 nl80211_send_sta_event(rdev, dev, mac_addr, sinfo, gfp);
770}
771EXPORT_SYMBOL(cfg80211_new_sta);
Jouni Malinen026331c2010-02-15 12:53:10 +0200772
Jouni Malinenec15e682011-03-23 15:29:52 +0200773void cfg80211_del_sta(struct net_device *dev, const u8 *mac_addr, gfp_t gfp)
774{
775 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
776 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
777
778 nl80211_send_sta_del_event(rdev, dev, mac_addr, gfp);
779}
780EXPORT_SYMBOL(cfg80211_del_sta);
781
Johannes Berg2e161f72010-08-12 15:38:38 +0200782struct cfg80211_mgmt_registration {
Jouni Malinen026331c2010-02-15 12:53:10 +0200783 struct list_head list;
784
785 u32 nlpid;
786
787 int match_len;
788
Johannes Berg2e161f72010-08-12 15:38:38 +0200789 __le16 frame_type;
790
Jouni Malinen026331c2010-02-15 12:53:10 +0200791 u8 match[];
792};
793
Johannes Berg2e161f72010-08-12 15:38:38 +0200794int cfg80211_mlme_register_mgmt(struct wireless_dev *wdev, u32 snd_pid,
795 u16 frame_type, const u8 *match_data,
796 int match_len)
Jouni Malinen026331c2010-02-15 12:53:10 +0200797{
Johannes Berg271733c2010-10-13 12:06:23 +0200798 struct wiphy *wiphy = wdev->wiphy;
799 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg2e161f72010-08-12 15:38:38 +0200800 struct cfg80211_mgmt_registration *reg, *nreg;
Jouni Malinen026331c2010-02-15 12:53:10 +0200801 int err = 0;
Johannes Berg2e161f72010-08-12 15:38:38 +0200802 u16 mgmt_type;
803
804 if (!wdev->wiphy->mgmt_stypes)
805 return -EOPNOTSUPP;
806
807 if ((frame_type & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_MGMT)
808 return -EINVAL;
809
810 if (frame_type & ~(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE))
811 return -EINVAL;
812
813 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
814 if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].rx & BIT(mgmt_type)))
815 return -EINVAL;
Jouni Malinen026331c2010-02-15 12:53:10 +0200816
817 nreg = kzalloc(sizeof(*reg) + match_len, GFP_KERNEL);
818 if (!nreg)
819 return -ENOMEM;
820
Johannes Berg2e161f72010-08-12 15:38:38 +0200821 spin_lock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200822
Johannes Berg2e161f72010-08-12 15:38:38 +0200823 list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
Jouni Malinen026331c2010-02-15 12:53:10 +0200824 int mlen = min(match_len, reg->match_len);
825
Johannes Berg2e161f72010-08-12 15:38:38 +0200826 if (frame_type != le16_to_cpu(reg->frame_type))
827 continue;
828
Jouni Malinen026331c2010-02-15 12:53:10 +0200829 if (memcmp(reg->match, match_data, mlen) == 0) {
830 err = -EALREADY;
831 break;
832 }
833 }
834
835 if (err) {
836 kfree(nreg);
837 goto out;
838 }
839
840 memcpy(nreg->match, match_data, match_len);
841 nreg->match_len = match_len;
842 nreg->nlpid = snd_pid;
Johannes Berg2e161f72010-08-12 15:38:38 +0200843 nreg->frame_type = cpu_to_le16(frame_type);
844 list_add(&nreg->list, &wdev->mgmt_registrations);
Jouni Malinen026331c2010-02-15 12:53:10 +0200845
Johannes Berg271733c2010-10-13 12:06:23 +0200846 if (rdev->ops->mgmt_frame_register)
847 rdev->ops->mgmt_frame_register(wiphy, wdev->netdev,
848 frame_type, true);
849
Jouni Malinen026331c2010-02-15 12:53:10 +0200850 out:
Johannes Berg2e161f72010-08-12 15:38:38 +0200851 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Johannes Berg271733c2010-10-13 12:06:23 +0200852
Jouni Malinen026331c2010-02-15 12:53:10 +0200853 return err;
854}
855
Johannes Berg2e161f72010-08-12 15:38:38 +0200856void cfg80211_mlme_unregister_socket(struct wireless_dev *wdev, u32 nlpid)
Jouni Malinen026331c2010-02-15 12:53:10 +0200857{
Johannes Berg271733c2010-10-13 12:06:23 +0200858 struct wiphy *wiphy = wdev->wiphy;
859 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg2e161f72010-08-12 15:38:38 +0200860 struct cfg80211_mgmt_registration *reg, *tmp;
Jouni Malinen026331c2010-02-15 12:53:10 +0200861
Johannes Berg2e161f72010-08-12 15:38:38 +0200862 spin_lock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200863
Johannes Berg2e161f72010-08-12 15:38:38 +0200864 list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
Johannes Berg271733c2010-10-13 12:06:23 +0200865 if (reg->nlpid != nlpid)
866 continue;
867
868 if (rdev->ops->mgmt_frame_register) {
869 u16 frame_type = le16_to_cpu(reg->frame_type);
870
871 rdev->ops->mgmt_frame_register(wiphy, wdev->netdev,
872 frame_type, false);
Jouni Malinen026331c2010-02-15 12:53:10 +0200873 }
Johannes Berg271733c2010-10-13 12:06:23 +0200874
875 list_del(&reg->list);
876 kfree(reg);
Jouni Malinen026331c2010-02-15 12:53:10 +0200877 }
878
Johannes Berg2e161f72010-08-12 15:38:38 +0200879 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200880}
881
Johannes Berg2e161f72010-08-12 15:38:38 +0200882void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev)
Jouni Malinen026331c2010-02-15 12:53:10 +0200883{
Johannes Berg2e161f72010-08-12 15:38:38 +0200884 struct cfg80211_mgmt_registration *reg, *tmp;
Jouni Malinen026331c2010-02-15 12:53:10 +0200885
Johannes Berg2e161f72010-08-12 15:38:38 +0200886 spin_lock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200887
Johannes Berg2e161f72010-08-12 15:38:38 +0200888 list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
Jouni Malinen026331c2010-02-15 12:53:10 +0200889 list_del(&reg->list);
890 kfree(reg);
891 }
892
Johannes Berg2e161f72010-08-12 15:38:38 +0200893 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200894}
895
Johannes Berg2e161f72010-08-12 15:38:38 +0200896int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
897 struct net_device *dev,
Johannes Bergf7ca38d2010-11-25 10:02:29 +0100898 struct ieee80211_channel *chan, bool offchan,
Johannes Berg2e161f72010-08-12 15:38:38 +0200899 enum nl80211_channel_type channel_type,
Johannes Bergf7ca38d2010-11-25 10:02:29 +0100900 bool channel_type_valid, unsigned int wait,
Johannes Berg2e161f72010-08-12 15:38:38 +0200901 const u8 *buf, size_t len, u64 *cookie)
Jouni Malinen026331c2010-02-15 12:53:10 +0200902{
903 struct wireless_dev *wdev = dev->ieee80211_ptr;
904 const struct ieee80211_mgmt *mgmt;
Johannes Berg2e161f72010-08-12 15:38:38 +0200905 u16 stype;
Jouni Malinen026331c2010-02-15 12:53:10 +0200906
Johannes Berg2e161f72010-08-12 15:38:38 +0200907 if (!wdev->wiphy->mgmt_stypes)
Jouni Malinen026331c2010-02-15 12:53:10 +0200908 return -EOPNOTSUPP;
Johannes Berg2e161f72010-08-12 15:38:38 +0200909
910 if (!rdev->ops->mgmt_tx)
911 return -EOPNOTSUPP;
912
Jouni Malinen026331c2010-02-15 12:53:10 +0200913 if (len < 24 + 1)
914 return -EINVAL;
915
916 mgmt = (const struct ieee80211_mgmt *) buf;
Johannes Berg2e161f72010-08-12 15:38:38 +0200917
918 if (!ieee80211_is_mgmt(mgmt->frame_control))
Jouni Malinen026331c2010-02-15 12:53:10 +0200919 return -EINVAL;
Johannes Berg2e161f72010-08-12 15:38:38 +0200920
921 stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
922 if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].tx & BIT(stype >> 4)))
923 return -EINVAL;
924
925 if (ieee80211_is_action(mgmt->frame_control) &&
926 mgmt->u.action.category != WLAN_CATEGORY_PUBLIC) {
Johannes Berg663fcaf2010-09-30 21:06:09 +0200927 int err = 0;
928
Johannes Bergfe100ac2010-08-09 15:52:03 +0200929 wdev_lock(wdev);
930
Johannes Berg663fcaf2010-09-30 21:06:09 +0200931 switch (wdev->iftype) {
932 case NL80211_IFTYPE_ADHOC:
933 case NL80211_IFTYPE_STATION:
934 case NL80211_IFTYPE_P2P_CLIENT:
935 if (!wdev->current_bss) {
936 err = -ENOTCONN;
937 break;
938 }
Johannes Bergfe100ac2010-08-09 15:52:03 +0200939
Johannes Berg663fcaf2010-09-30 21:06:09 +0200940 if (memcmp(wdev->current_bss->pub.bssid,
941 mgmt->bssid, ETH_ALEN)) {
942 err = -ENOTCONN;
943 break;
944 }
945
946 /*
947 * check for IBSS DA must be done by driver as
948 * cfg80211 doesn't track the stations
949 */
950 if (wdev->iftype == NL80211_IFTYPE_ADHOC)
951 break;
952
953 /* for station, check that DA is the AP */
954 if (memcmp(wdev->current_bss->pub.bssid,
955 mgmt->da, ETH_ALEN)) {
956 err = -ENOTCONN;
957 break;
958 }
959 break;
960 case NL80211_IFTYPE_AP:
961 case NL80211_IFTYPE_P2P_GO:
962 case NL80211_IFTYPE_AP_VLAN:
963 if (memcmp(mgmt->bssid, dev->dev_addr, ETH_ALEN))
964 err = -EINVAL;
965 break;
Javier Cardona0778a6a2011-05-03 16:57:08 -0700966 case NL80211_IFTYPE_MESH_POINT:
967 if (memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN)) {
968 err = -EINVAL;
969 break;
970 }
971 /*
972 * check for mesh DA must be done by driver as
973 * cfg80211 doesn't track the stations
974 */
975 break;
Johannes Berg663fcaf2010-09-30 21:06:09 +0200976 default:
977 err = -EOPNOTSUPP;
978 break;
979 }
Johannes Bergfe100ac2010-08-09 15:52:03 +0200980 wdev_unlock(wdev);
Johannes Berg663fcaf2010-09-30 21:06:09 +0200981
982 if (err)
983 return err;
Jouni Malinen026331c2010-02-15 12:53:10 +0200984 }
985
986 if (memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0)
987 return -EINVAL;
988
989 /* Transmit the Action frame as requested by user space */
Johannes Bergf7ca38d2010-11-25 10:02:29 +0100990 return rdev->ops->mgmt_tx(&rdev->wiphy, dev, chan, offchan,
991 channel_type, channel_type_valid,
992 wait, buf, len, cookie);
Jouni Malinen026331c2010-02-15 12:53:10 +0200993}
994
Johannes Berg2e161f72010-08-12 15:38:38 +0200995bool cfg80211_rx_mgmt(struct net_device *dev, int freq, const u8 *buf,
996 size_t len, gfp_t gfp)
Jouni Malinen026331c2010-02-15 12:53:10 +0200997{
998 struct wireless_dev *wdev = dev->ieee80211_ptr;
999 struct wiphy *wiphy = wdev->wiphy;
1000 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg2e161f72010-08-12 15:38:38 +02001001 struct cfg80211_mgmt_registration *reg;
1002 const struct ieee80211_txrx_stypes *stypes =
1003 &wiphy->mgmt_stypes[wdev->iftype];
1004 struct ieee80211_mgmt *mgmt = (void *)buf;
1005 const u8 *data;
1006 int data_len;
Jouni Malinen026331c2010-02-15 12:53:10 +02001007 bool result = false;
Johannes Berg2e161f72010-08-12 15:38:38 +02001008 __le16 ftype = mgmt->frame_control &
1009 cpu_to_le16(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE);
1010 u16 stype;
Jouni Malinen026331c2010-02-15 12:53:10 +02001011
Johannes Berg2e161f72010-08-12 15:38:38 +02001012 stype = (le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE) >> 4;
Jouni Malinen026331c2010-02-15 12:53:10 +02001013
Johannes Berg2e161f72010-08-12 15:38:38 +02001014 if (!(stypes->rx & BIT(stype)))
1015 return false;
Jouni Malinen026331c2010-02-15 12:53:10 +02001016
Johannes Berg2e161f72010-08-12 15:38:38 +02001017 data = buf + ieee80211_hdrlen(mgmt->frame_control);
1018 data_len = len - ieee80211_hdrlen(mgmt->frame_control);
Jouni Malinen026331c2010-02-15 12:53:10 +02001019
Johannes Berg2e161f72010-08-12 15:38:38 +02001020 spin_lock_bh(&wdev->mgmt_registrations_lock);
1021
1022 list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
1023 if (reg->frame_type != ftype)
Jouni Malinen026331c2010-02-15 12:53:10 +02001024 continue;
1025
Johannes Berg2e161f72010-08-12 15:38:38 +02001026 if (reg->match_len > data_len)
1027 continue;
1028
1029 if (memcmp(reg->match, data, reg->match_len))
Jouni Malinen026331c2010-02-15 12:53:10 +02001030 continue;
1031
1032 /* found match! */
1033
1034 /* Indicate the received Action frame to user space */
Johannes Berg2e161f72010-08-12 15:38:38 +02001035 if (nl80211_send_mgmt(rdev, dev, reg->nlpid, freq,
1036 buf, len, gfp))
Jouni Malinen026331c2010-02-15 12:53:10 +02001037 continue;
1038
1039 result = true;
1040 break;
1041 }
1042
Johannes Berg2e161f72010-08-12 15:38:38 +02001043 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +02001044
1045 return result;
1046}
Johannes Berg2e161f72010-08-12 15:38:38 +02001047EXPORT_SYMBOL(cfg80211_rx_mgmt);
Jouni Malinen026331c2010-02-15 12:53:10 +02001048
Johannes Berg2e161f72010-08-12 15:38:38 +02001049void cfg80211_mgmt_tx_status(struct net_device *dev, u64 cookie,
1050 const u8 *buf, size_t len, bool ack, gfp_t gfp)
Jouni Malinen026331c2010-02-15 12:53:10 +02001051{
1052 struct wireless_dev *wdev = dev->ieee80211_ptr;
1053 struct wiphy *wiphy = wdev->wiphy;
1054 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
1055
1056 /* Indicate TX status of the Action frame to user space */
Johannes Berg2e161f72010-08-12 15:38:38 +02001057 nl80211_send_mgmt_tx_status(rdev, dev, cookie, buf, len, ack, gfp);
Jouni Malinen026331c2010-02-15 12:53:10 +02001058}
Johannes Berg2e161f72010-08-12 15:38:38 +02001059EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
Juuso Oikarinend6dc1a32010-03-23 09:02:33 +02001060
1061void cfg80211_cqm_rssi_notify(struct net_device *dev,
1062 enum nl80211_cqm_rssi_threshold_event rssi_event,
1063 gfp_t gfp)
1064{
1065 struct wireless_dev *wdev = dev->ieee80211_ptr;
1066 struct wiphy *wiphy = wdev->wiphy;
1067 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
1068
1069 /* Indicate roaming trigger event to user space */
1070 nl80211_send_cqm_rssi_notify(rdev, dev, rssi_event, gfp);
1071}
1072EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
Johannes Bergc063dbf2010-11-24 08:10:05 +01001073
1074void cfg80211_cqm_pktloss_notify(struct net_device *dev,
1075 const u8 *peer, u32 num_packets, gfp_t gfp)
1076{
1077 struct wireless_dev *wdev = dev->ieee80211_ptr;
1078 struct wiphy *wiphy = wdev->wiphy;
1079 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
1080
1081 /* Indicate roaming trigger event to user space */
1082 nl80211_send_cqm_pktloss_notify(rdev, dev, peer, num_packets, gfp);
1083}
1084EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);