blob: 22139fa4611598810ae0d4c4a462996aeaa61583 [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
47 WARN_ON(!done);
Johannes Berg6829c872009-07-02 09:13:27 +020048
Johannes Bergcb0b4be2009-07-07 03:56:07 +020049 nl80211_send_rx_auth(rdev, dev, buf, len, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +020050 cfg80211_sme_rx_auth(dev, buf, len);
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 Berg5fba4af2009-12-02 12:43:42 +0100152 bool found = 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 Berg19957bb2009-07-02 17:20:43 +0200162 } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
163 if (wdev->auth_bsses[i] &&
164 memcmp(wdev->auth_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
165 cfg80211_unhold_bss(wdev->auth_bsses[i]);
166 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
167 wdev->auth_bsses[i] = NULL;
Johannes Berg5fba4af2009-12-02 12:43:42 +0100168 found = true;
Johannes Berg19957bb2009-07-02 17:20:43 +0200169 break;
170 }
171 if (wdev->authtry_bsses[i] &&
172 memcmp(wdev->authtry_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
173 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
174 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
175 wdev->authtry_bsses[i] = NULL;
Johannes Berg5fba4af2009-12-02 12:43:42 +0100176 found = true;
Johannes Berg19957bb2009-07-02 17:20:43 +0200177 break;
178 }
179 }
Johannes Berg19957bb2009-07-02 17:20:43 +0200180
Johannes Berg5fba4af2009-12-02 12:43:42 +0100181 if (!found)
182 return;
183
184 nl80211_send_deauth(rdev, dev, buf, len, GFP_KERNEL);
185
Johannes Berg6829c872009-07-02 09:13:27 +0200186 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
187 u16 reason_code;
188 bool from_ap;
189
190 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
191
Johannes Berge458b8a2009-08-06 20:41:33 +0200192 from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
Johannes Berg667503d2009-07-07 03:56:11 +0200193 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
Johannes Berg6829c872009-07-02 09:13:27 +0200194 } else if (wdev->sme_state == CFG80211_SME_CONNECTING) {
Johannes Berg667503d2009-07-07 03:56:11 +0200195 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,
196 WLAN_STATUS_UNSPECIFIED_FAILURE,
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200197 false, NULL);
Johannes Berg667503d2009-07-07 03:56:11 +0200198 }
199}
Holger Schurigce470613c2009-10-13 13:28:13 +0200200EXPORT_SYMBOL(__cfg80211_send_deauth);
Johannes Berg667503d2009-07-07 03:56:11 +0200201
Holger Schurigce470613c2009-10-13 13:28:13 +0200202void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len)
Johannes Berg667503d2009-07-07 03:56:11 +0200203{
204 struct wireless_dev *wdev = dev->ieee80211_ptr;
205
Holger Schurigce470613c2009-10-13 13:28:13 +0200206 wdev_lock(wdev);
207 __cfg80211_send_deauth(dev, buf, len);
208 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200209}
Jouni Malinen53b46b82009-03-27 20:53:56 +0200210EXPORT_SYMBOL(cfg80211_send_deauth);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200211
Holger Schurigce470613c2009-10-13 13:28:13 +0200212void __cfg80211_send_disassoc(struct net_device *dev,
Johannes Berg667503d2009-07-07 03:56:11 +0200213 const u8 *buf, size_t len)
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200214{
Johannes Berg6829c872009-07-02 09:13:27 +0200215 struct wireless_dev *wdev = dev->ieee80211_ptr;
216 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200217 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg6829c872009-07-02 09:13:27 +0200218 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
Johannes Berg19957bb2009-07-02 17:20:43 +0200219 const u8 *bssid = mgmt->bssid;
220 int i;
221 u16 reason_code;
222 bool from_ap;
223 bool done = false;
Johannes Berg6829c872009-07-02 09:13:27 +0200224
Johannes Berg596a07c2009-07-11 00:17:32 +0200225 ASSERT_WDEV_LOCK(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200226
227 nl80211_send_disassoc(rdev, dev, buf, len, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +0200228
Johannes Berg596a07c2009-07-11 00:17:32 +0200229 if (wdev->sme_state != CFG80211_SME_CONNECTED)
230 return;
Johannes Berg6829c872009-07-02 09:13:27 +0200231
Johannes Berg19957bb2009-07-02 17:20:43 +0200232 if (wdev->current_bss &&
Pavel Roskinb935df02009-08-06 04:52:42 -0400233 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
Johannes Berg19957bb2009-07-02 17:20:43 +0200234 for (i = 0; i < MAX_AUTH_BSSES; i++) {
235 if (wdev->authtry_bsses[i] || wdev->auth_bsses[i])
236 continue;
237 wdev->auth_bsses[i] = wdev->current_bss;
238 wdev->current_bss = NULL;
239 done = true;
240 cfg80211_sme_disassoc(dev, i);
241 break;
242 }
243 WARN_ON(!done);
244 } else
245 WARN_ON(1);
Johannes Berg6829c872009-07-02 09:13:27 +0200246
Johannes Berg6829c872009-07-02 09:13:27 +0200247
Johannes Berg19957bb2009-07-02 17:20:43 +0200248 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
249
Johannes Berge458b8a2009-08-06 20:41:33 +0200250 from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
Johannes Berg667503d2009-07-07 03:56:11 +0200251 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
Johannes Berg667503d2009-07-07 03:56:11 +0200252}
Holger Schurigce470613c2009-10-13 13:28:13 +0200253EXPORT_SYMBOL(__cfg80211_send_disassoc);
Johannes Berg667503d2009-07-07 03:56:11 +0200254
Holger Schurigce470613c2009-10-13 13:28:13 +0200255void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len)
Johannes Berg667503d2009-07-07 03:56:11 +0200256{
257 struct wireless_dev *wdev = dev->ieee80211_ptr;
258
Holger Schurigce470613c2009-10-13 13:28:13 +0200259 wdev_lock(wdev);
260 __cfg80211_send_disassoc(dev, buf, len);
261 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200262}
Jouni Malinen53b46b82009-03-27 20:53:56 +0200263EXPORT_SYMBOL(cfg80211_send_disassoc);
Jouni Malinena3b8b052009-03-27 21:59:49 +0200264
Johannes Berga58ce432009-11-19 12:45:42 +0100265static void __cfg80211_auth_remove(struct wireless_dev *wdev, const u8 *addr)
Jouni Malinen1965c852009-04-22 21:38:25 +0300266{
Johannes Berg19957bb2009-07-02 17:20:43 +0200267 int i;
268 bool done = false;
269
Johannes Berga58ce432009-11-19 12:45:42 +0100270 ASSERT_WDEV_LOCK(wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200271
272 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
273 if (wdev->authtry_bsses[i] &&
274 memcmp(wdev->authtry_bsses[i]->pub.bssid,
275 addr, ETH_ALEN) == 0) {
276 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
277 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
278 wdev->authtry_bsses[i] = NULL;
279 done = true;
280 break;
281 }
282 }
283
284 WARN_ON(!done);
Johannes Berga58ce432009-11-19 12:45:42 +0100285}
286
287void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr)
288{
289 __cfg80211_auth_remove(dev->ieee80211_ptr, addr);
290}
291EXPORT_SYMBOL(__cfg80211_auth_canceled);
292
293void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr)
294{
295 struct wireless_dev *wdev = dev->ieee80211_ptr;
296 struct wiphy *wiphy = wdev->wiphy;
297 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
298
299 wdev_lock(wdev);
300
301 nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
302 if (wdev->sme_state == CFG80211_SME_CONNECTING)
303 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
304 WLAN_STATUS_UNSPECIFIED_FAILURE,
305 false, NULL);
306
307 __cfg80211_auth_remove(wdev, addr);
Johannes Berg667503d2009-07-07 03:56:11 +0200308
309 wdev_unlock(wdev);
Jouni Malinen1965c852009-04-22 21:38:25 +0300310}
311EXPORT_SYMBOL(cfg80211_send_auth_timeout);
312
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200313void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr)
Jouni Malinen1965c852009-04-22 21:38:25 +0300314{
Johannes Berg6829c872009-07-02 09:13:27 +0200315 struct wireless_dev *wdev = dev->ieee80211_ptr;
316 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen1965c852009-04-22 21:38:25 +0300317 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg19957bb2009-07-02 17:20:43 +0200318 int i;
319 bool done = false;
320
Johannes Berg667503d2009-07-07 03:56:11 +0200321 wdev_lock(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200322
323 nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +0200324 if (wdev->sme_state == CFG80211_SME_CONNECTING)
Johannes Berg667503d2009-07-07 03:56:11 +0200325 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
326 WLAN_STATUS_UNSPECIFIED_FAILURE,
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200327 false, NULL);
Johannes Berg19957bb2009-07-02 17:20:43 +0200328
329 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
330 if (wdev->auth_bsses[i] &&
331 memcmp(wdev->auth_bsses[i]->pub.bssid,
332 addr, ETH_ALEN) == 0) {
333 cfg80211_unhold_bss(wdev->auth_bsses[i]);
334 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
335 wdev->auth_bsses[i] = NULL;
336 done = true;
337 break;
338 }
339 }
340
341 WARN_ON(!done);
Johannes Berg667503d2009-07-07 03:56:11 +0200342
343 wdev_unlock(wdev);
Jouni Malinen1965c852009-04-22 21:38:25 +0300344}
345EXPORT_SYMBOL(cfg80211_send_assoc_timeout);
346
Jouni Malinena3b8b052009-03-27 21:59:49 +0200347void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
348 enum nl80211_key_type key_type, int key_id,
Johannes Berge6d6e342009-07-01 21:26:47 +0200349 const u8 *tsc, gfp_t gfp)
Jouni Malinena3b8b052009-03-27 21:59:49 +0200350{
351 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
352 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg3d23e342009-09-29 23:27:28 +0200353#ifdef CONFIG_CFG80211_WEXT
Johannes Bergf58d4ed2009-06-19 02:45:21 +0200354 union iwreq_data wrqu;
Johannes Berge6d6e342009-07-01 21:26:47 +0200355 char *buf = kmalloc(128, gfp);
Johannes Bergf58d4ed2009-06-19 02:45:21 +0200356
357 if (buf) {
358 sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
359 "keyid=%d %scast addr=%pM)", key_id,
360 key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
361 addr);
362 memset(&wrqu, 0, sizeof(wrqu));
363 wrqu.data.length = strlen(buf);
364 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
365 kfree(buf);
366 }
367#endif
368
Johannes Berge6d6e342009-07-01 21:26:47 +0200369 nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
Jouni Malinena3b8b052009-03-27 21:59:49 +0200370}
371EXPORT_SYMBOL(cfg80211_michael_mic_failure);
Johannes Berg19957bb2009-07-02 17:20:43 +0200372
373/* some MLME handling for userspace SME */
Johannes Berg667503d2009-07-07 03:56:11 +0200374int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
375 struct net_device *dev,
376 struct ieee80211_channel *chan,
377 enum nl80211_auth_type auth_type,
378 const u8 *bssid,
379 const u8 *ssid, int ssid_len,
Johannes Bergfffd0932009-07-08 14:22:54 +0200380 const u8 *ie, int ie_len,
381 const u8 *key, int key_len, int key_idx)
Johannes Berg19957bb2009-07-02 17:20:43 +0200382{
383 struct wireless_dev *wdev = dev->ieee80211_ptr;
384 struct cfg80211_auth_request req;
385 struct cfg80211_internal_bss *bss;
386 int i, err, slot = -1, nfree = 0;
387
Johannes Berg667503d2009-07-07 03:56:11 +0200388 ASSERT_WDEV_LOCK(wdev);
389
Johannes Bergfffd0932009-07-08 14:22:54 +0200390 if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
391 if (!key || !key_len || key_idx < 0 || key_idx > 4)
392 return -EINVAL;
393
Johannes Berg0a9b5e12009-07-02 18:26:18 +0200394 if (wdev->current_bss &&
395 memcmp(bssid, wdev->current_bss->pub.bssid, ETH_ALEN) == 0)
396 return -EALREADY;
397
398 for (i = 0; i < MAX_AUTH_BSSES; i++) {
399 if (wdev->authtry_bsses[i] &&
400 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid,
401 ETH_ALEN) == 0)
402 return -EALREADY;
403 if (wdev->auth_bsses[i] &&
404 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid,
405 ETH_ALEN) == 0)
406 return -EALREADY;
407 }
408
Johannes Berg19957bb2009-07-02 17:20:43 +0200409 memset(&req, 0, sizeof(req));
410
411 req.ie = ie;
412 req.ie_len = ie_len;
413 req.auth_type = auth_type;
414 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
415 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
Johannes Bergfffd0932009-07-08 14:22:54 +0200416 req.key = key;
417 req.key_len = key_len;
418 req.key_idx = key_idx;
Johannes Berg19957bb2009-07-02 17:20:43 +0200419 if (!req.bss)
420 return -ENOENT;
421
422 bss = bss_from_pub(req.bss);
423
424 for (i = 0; i < MAX_AUTH_BSSES; i++) {
Johannes Berg19957bb2009-07-02 17:20:43 +0200425 if (!wdev->auth_bsses[i] && !wdev->authtry_bsses[i]) {
426 slot = i;
427 nfree++;
428 }
429 }
430
431 /* we need one free slot for disassoc and one for this auth */
432 if (nfree < 2) {
433 err = -ENOSPC;
434 goto out;
435 }
436
437 wdev->authtry_bsses[slot] = bss;
438 cfg80211_hold_bss(bss);
439
440 err = rdev->ops->auth(&rdev->wiphy, dev, &req);
441 if (err) {
442 wdev->authtry_bsses[slot] = NULL;
443 cfg80211_unhold_bss(bss);
444 }
445
446 out:
447 if (err)
448 cfg80211_put_bss(req.bss);
449 return err;
450}
451
Johannes Berg667503d2009-07-07 03:56:11 +0200452int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
453 struct net_device *dev, struct ieee80211_channel *chan,
454 enum nl80211_auth_type auth_type, const u8 *bssid,
455 const u8 *ssid, int ssid_len,
Johannes Bergfffd0932009-07-08 14:22:54 +0200456 const u8 *ie, int ie_len,
457 const u8 *key, int key_len, int key_idx)
Johannes Berg667503d2009-07-07 03:56:11 +0200458{
459 int err;
460
461 wdev_lock(dev->ieee80211_ptr);
462 err = __cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
Johannes Bergfffd0932009-07-08 14:22:54 +0200463 ssid, ssid_len, ie, ie_len,
464 key, key_len, key_idx);
Johannes Berg667503d2009-07-07 03:56:11 +0200465 wdev_unlock(dev->ieee80211_ptr);
466
467 return err;
468}
469
470int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
471 struct net_device *dev,
472 struct ieee80211_channel *chan,
473 const u8 *bssid, const u8 *prev_bssid,
474 const u8 *ssid, int ssid_len,
475 const u8 *ie, int ie_len, bool use_mfp,
476 struct cfg80211_crypto_settings *crypt)
Johannes Berg19957bb2009-07-02 17:20:43 +0200477{
478 struct wireless_dev *wdev = dev->ieee80211_ptr;
479 struct cfg80211_assoc_request req;
480 struct cfg80211_internal_bss *bss;
481 int i, err, slot = -1;
Jouni Malinen24b6b152009-11-17 21:35:38 +0200482 bool was_connected = false;
Johannes Berg19957bb2009-07-02 17:20:43 +0200483
Johannes Berg667503d2009-07-07 03:56:11 +0200484 ASSERT_WDEV_LOCK(wdev);
485
Johannes Berg19957bb2009-07-02 17:20:43 +0200486 memset(&req, 0, sizeof(req));
487
Jouni Malinen24b6b152009-11-17 21:35:38 +0200488 if (wdev->current_bss && prev_bssid &&
489 memcmp(wdev->current_bss->pub.bssid, prev_bssid, ETH_ALEN) == 0) {
490 /*
491 * Trying to reassociate: Allow this to proceed and let the old
492 * association to be dropped when the new one is completed.
493 */
494 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
495 was_connected = true;
496 wdev->sme_state = CFG80211_SME_CONNECTING;
497 }
498 } else if (wdev->current_bss)
Johannes Berg19957bb2009-07-02 17:20:43 +0200499 return -EALREADY;
500
501 req.ie = ie;
502 req.ie_len = ie_len;
503 memcpy(&req.crypto, crypt, sizeof(req.crypto));
504 req.use_mfp = use_mfp;
Johannes Berg3e5d7642009-07-07 14:37:26 +0200505 req.prev_bssid = prev_bssid;
Johannes Berg19957bb2009-07-02 17:20:43 +0200506 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
507 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
Jouni Malinen24b6b152009-11-17 21:35:38 +0200508 if (!req.bss) {
509 if (was_connected)
510 wdev->sme_state = CFG80211_SME_CONNECTED;
Johannes Berg19957bb2009-07-02 17:20:43 +0200511 return -ENOENT;
Jouni Malinen24b6b152009-11-17 21:35:38 +0200512 }
Johannes Berg19957bb2009-07-02 17:20:43 +0200513
514 bss = bss_from_pub(req.bss);
515
516 for (i = 0; i < MAX_AUTH_BSSES; i++) {
517 if (bss == wdev->auth_bsses[i]) {
518 slot = i;
519 break;
520 }
521 }
522
523 if (slot < 0) {
524 err = -ENOTCONN;
525 goto out;
526 }
527
528 err = rdev->ops->assoc(&rdev->wiphy, dev, &req);
529 out:
Jouni Malinen24b6b152009-11-17 21:35:38 +0200530 if (err && was_connected)
531 wdev->sme_state = CFG80211_SME_CONNECTED;
Johannes Berg19957bb2009-07-02 17:20:43 +0200532 /* still a reference in wdev->auth_bsses[slot] */
533 cfg80211_put_bss(req.bss);
534 return err;
535}
536
Johannes Berg667503d2009-07-07 03:56:11 +0200537int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
538 struct net_device *dev,
539 struct ieee80211_channel *chan,
540 const u8 *bssid, const u8 *prev_bssid,
541 const u8 *ssid, int ssid_len,
542 const u8 *ie, int ie_len, bool use_mfp,
543 struct cfg80211_crypto_settings *crypt)
544{
545 struct wireless_dev *wdev = dev->ieee80211_ptr;
546 int err;
547
548 wdev_lock(wdev);
549 err = __cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
550 ssid, ssid_len, ie, ie_len, use_mfp, crypt);
551 wdev_unlock(wdev);
552
553 return err;
554}
555
556int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
557 struct net_device *dev, const u8 *bssid,
558 const u8 *ie, int ie_len, u16 reason)
Johannes Berg19957bb2009-07-02 17:20:43 +0200559{
560 struct wireless_dev *wdev = dev->ieee80211_ptr;
561 struct cfg80211_deauth_request req;
562 int i;
563
Johannes Berg667503d2009-07-07 03:56:11 +0200564 ASSERT_WDEV_LOCK(wdev);
565
Johannes Berg19957bb2009-07-02 17:20:43 +0200566 memset(&req, 0, sizeof(req));
567 req.reason_code = reason;
568 req.ie = ie;
569 req.ie_len = ie_len;
570 if (wdev->current_bss &&
571 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
572 req.bss = &wdev->current_bss->pub;
573 } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
574 if (wdev->auth_bsses[i] &&
575 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
576 req.bss = &wdev->auth_bsses[i]->pub;
577 break;
578 }
579 if (wdev->authtry_bsses[i] &&
580 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
581 req.bss = &wdev->authtry_bsses[i]->pub;
582 break;
583 }
584 }
585
586 if (!req.bss)
587 return -ENOTCONN;
588
Johannes Berg667503d2009-07-07 03:56:11 +0200589 return rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200590}
591
Johannes Berg667503d2009-07-07 03:56:11 +0200592int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
593 struct net_device *dev, const u8 *bssid,
594 const u8 *ie, int ie_len, u16 reason)
595{
596 struct wireless_dev *wdev = dev->ieee80211_ptr;
597 int err;
598
599 wdev_lock(wdev);
600 err = __cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason);
601 wdev_unlock(wdev);
602
603 return err;
604}
605
606static int __cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
607 struct net_device *dev, const u8 *bssid,
608 const u8 *ie, int ie_len, u16 reason)
Johannes Berg19957bb2009-07-02 17:20:43 +0200609{
610 struct wireless_dev *wdev = dev->ieee80211_ptr;
611 struct cfg80211_disassoc_request req;
612
Johannes Berg667503d2009-07-07 03:56:11 +0200613 ASSERT_WDEV_LOCK(wdev);
614
Johannes Bergf9d6b402009-07-27 10:22:28 +0200615 if (wdev->sme_state != CFG80211_SME_CONNECTED)
616 return -ENOTCONN;
617
618 if (WARN_ON(!wdev->current_bss))
619 return -ENOTCONN;
620
Johannes Berg19957bb2009-07-02 17:20:43 +0200621 memset(&req, 0, sizeof(req));
622 req.reason_code = reason;
623 req.ie = ie;
624 req.ie_len = ie_len;
625 if (memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0)
626 req.bss = &wdev->current_bss->pub;
627 else
628 return -ENOTCONN;
629
Johannes Berg667503d2009-07-07 03:56:11 +0200630 return rdev->ops->disassoc(&rdev->wiphy, dev, &req, wdev);
631}
632
633int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
634 struct net_device *dev, const u8 *bssid,
635 const u8 *ie, int ie_len, u16 reason)
636{
637 struct wireless_dev *wdev = dev->ieee80211_ptr;
638 int err;
639
640 wdev_lock(wdev);
641 err = __cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason);
642 wdev_unlock(wdev);
643
644 return err;
Johannes Berg19957bb2009-07-02 17:20:43 +0200645}
646
647void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
648 struct net_device *dev)
649{
650 struct wireless_dev *wdev = dev->ieee80211_ptr;
651 struct cfg80211_deauth_request req;
652 int i;
653
Johannes Berg667503d2009-07-07 03:56:11 +0200654 ASSERT_WDEV_LOCK(wdev);
655
Johannes Berg19957bb2009-07-02 17:20:43 +0200656 if (!rdev->ops->deauth)
657 return;
658
659 memset(&req, 0, sizeof(req));
660 req.reason_code = WLAN_REASON_DEAUTH_LEAVING;
661 req.ie = NULL;
662 req.ie_len = 0;
663
664 if (wdev->current_bss) {
665 req.bss = &wdev->current_bss->pub;
Johannes Berg667503d2009-07-07 03:56:11 +0200666 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200667 if (wdev->current_bss) {
668 cfg80211_unhold_bss(wdev->current_bss);
669 cfg80211_put_bss(&wdev->current_bss->pub);
670 wdev->current_bss = NULL;
671 }
672 }
673
674 for (i = 0; i < MAX_AUTH_BSSES; i++) {
675 if (wdev->auth_bsses[i]) {
676 req.bss = &wdev->auth_bsses[i]->pub;
Johannes Berg667503d2009-07-07 03:56:11 +0200677 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200678 if (wdev->auth_bsses[i]) {
679 cfg80211_unhold_bss(wdev->auth_bsses[i]);
680 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
681 wdev->auth_bsses[i] = NULL;
682 }
683 }
684 if (wdev->authtry_bsses[i]) {
685 req.bss = &wdev->authtry_bsses[i]->pub;
Johannes Berg667503d2009-07-07 03:56:11 +0200686 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
Johannes Berg19957bb2009-07-02 17:20:43 +0200687 if (wdev->authtry_bsses[i]) {
688 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
689 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
690 wdev->authtry_bsses[i] = NULL;
691 }
692 }
693 }
694}
Jouni Malinen9588bbd2009-12-23 13:15:41 +0100695
696void cfg80211_ready_on_channel(struct net_device *dev, u64 cookie,
697 struct ieee80211_channel *chan,
698 enum nl80211_channel_type channel_type,
699 unsigned int duration, gfp_t gfp)
700{
701 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
702 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
703
704 nl80211_send_remain_on_channel(rdev, dev, cookie, chan, channel_type,
705 duration, gfp);
706}
707EXPORT_SYMBOL(cfg80211_ready_on_channel);
708
709void cfg80211_remain_on_channel_expired(struct net_device *dev,
710 u64 cookie,
711 struct ieee80211_channel *chan,
712 enum nl80211_channel_type channel_type,
713 gfp_t gfp)
714{
715 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
716 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
717
718 nl80211_send_remain_on_channel_cancel(rdev, dev, cookie, chan,
719 channel_type, gfp);
720}
721EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
Johannes Berg98b62182009-12-23 13:15:44 +0100722
723void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
724 struct station_info *sinfo, gfp_t gfp)
725{
726 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
727 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
728
729 nl80211_send_sta_event(rdev, dev, mac_addr, sinfo, gfp);
730}
731EXPORT_SYMBOL(cfg80211_new_sta);
Jouni Malinen026331c2010-02-15 12:53:10 +0200732
733struct cfg80211_action_registration {
734 struct list_head list;
735
736 u32 nlpid;
737
738 int match_len;
739
740 u8 match[];
741};
742
743int cfg80211_mlme_register_action(struct wireless_dev *wdev, u32 snd_pid,
744 const u8 *match_data, int match_len)
745{
746 struct cfg80211_action_registration *reg, *nreg;
747 int err = 0;
748
749 nreg = kzalloc(sizeof(*reg) + match_len, GFP_KERNEL);
750 if (!nreg)
751 return -ENOMEM;
752
753 spin_lock_bh(&wdev->action_registrations_lock);
754
755 list_for_each_entry(reg, &wdev->action_registrations, list) {
756 int mlen = min(match_len, reg->match_len);
757
758 if (memcmp(reg->match, match_data, mlen) == 0) {
759 err = -EALREADY;
760 break;
761 }
762 }
763
764 if (err) {
765 kfree(nreg);
766 goto out;
767 }
768
769 memcpy(nreg->match, match_data, match_len);
770 nreg->match_len = match_len;
771 nreg->nlpid = snd_pid;
772 list_add(&nreg->list, &wdev->action_registrations);
773
774 out:
775 spin_unlock_bh(&wdev->action_registrations_lock);
776 return err;
777}
778
779void cfg80211_mlme_unregister_actions(struct wireless_dev *wdev, u32 nlpid)
780{
781 struct cfg80211_action_registration *reg, *tmp;
782
783 spin_lock_bh(&wdev->action_registrations_lock);
784
785 list_for_each_entry_safe(reg, tmp, &wdev->action_registrations, list) {
786 if (reg->nlpid == nlpid) {
787 list_del(&reg->list);
788 kfree(reg);
789 }
790 }
791
792 spin_unlock_bh(&wdev->action_registrations_lock);
793}
794
795void cfg80211_mlme_purge_actions(struct wireless_dev *wdev)
796{
797 struct cfg80211_action_registration *reg, *tmp;
798
799 spin_lock_bh(&wdev->action_registrations_lock);
800
801 list_for_each_entry_safe(reg, tmp, &wdev->action_registrations, list) {
802 list_del(&reg->list);
803 kfree(reg);
804 }
805
806 spin_unlock_bh(&wdev->action_registrations_lock);
807}
808
809int cfg80211_mlme_action(struct cfg80211_registered_device *rdev,
810 struct net_device *dev,
811 struct ieee80211_channel *chan,
812 enum nl80211_channel_type channel_type,
813 const u8 *buf, size_t len, u64 *cookie)
814{
815 struct wireless_dev *wdev = dev->ieee80211_ptr;
816 const struct ieee80211_mgmt *mgmt;
817
818 if (rdev->ops->action == NULL)
819 return -EOPNOTSUPP;
820 if (len < 24 + 1)
821 return -EINVAL;
822
823 mgmt = (const struct ieee80211_mgmt *) buf;
824 if (!ieee80211_is_action(mgmt->frame_control))
825 return -EINVAL;
826 if (mgmt->u.action.category != WLAN_CATEGORY_PUBLIC) {
827 /* Verify that we are associated with the destination AP */
828 if (!wdev->current_bss ||
829 memcmp(wdev->current_bss->pub.bssid, mgmt->bssid,
830 ETH_ALEN) != 0 ||
831 memcmp(wdev->current_bss->pub.bssid, mgmt->da,
832 ETH_ALEN) != 0)
833 return -ENOTCONN;
834 }
835
836 if (memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0)
837 return -EINVAL;
838
839 /* Transmit the Action frame as requested by user space */
840 return rdev->ops->action(&rdev->wiphy, dev, chan, channel_type,
841 buf, len, cookie);
842}
843
844bool cfg80211_rx_action(struct net_device *dev, int freq, const u8 *buf,
845 size_t len, gfp_t gfp)
846{
847 struct wireless_dev *wdev = dev->ieee80211_ptr;
848 struct wiphy *wiphy = wdev->wiphy;
849 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
850 struct cfg80211_action_registration *reg;
851 const u8 *action_data;
852 int action_data_len;
853 bool result = false;
854
855 /* frame length - min size excluding category */
856 action_data_len = len - (IEEE80211_MIN_ACTION_SIZE - 1);
857
858 /* action data starts with category */
859 action_data = buf + IEEE80211_MIN_ACTION_SIZE - 1;
860
861 spin_lock_bh(&wdev->action_registrations_lock);
862
863 list_for_each_entry(reg, &wdev->action_registrations, list) {
864 if (reg->match_len > action_data_len)
865 continue;
866
867 if (memcmp(reg->match, action_data, reg->match_len))
868 continue;
869
870 /* found match! */
871
872 /* Indicate the received Action frame to user space */
873 if (nl80211_send_action(rdev, dev, reg->nlpid, freq,
874 buf, len, gfp))
875 continue;
876
877 result = true;
878 break;
879 }
880
881 spin_unlock_bh(&wdev->action_registrations_lock);
882
883 return result;
884}
885EXPORT_SYMBOL(cfg80211_rx_action);
886
887void cfg80211_action_tx_status(struct net_device *dev, u64 cookie,
888 const u8 *buf, size_t len, bool ack, gfp_t gfp)
889{
890 struct wireless_dev *wdev = dev->ieee80211_ptr;
891 struct wiphy *wiphy = wdev->wiphy;
892 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
893
894 /* Indicate TX status of the Action frame to user space */
895 nl80211_send_action_tx_status(rdev, dev, cookie, buf, len, ack, gfp);
896}
897EXPORT_SYMBOL(cfg80211_action_tx_status);