blob: eb90988bbd36d4396ed2ac2094565561c5131875 [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>
Felix Fietkauc6fb08a2012-03-18 22:58:04 +01009#include <linux/etherdevice.h>
Jouni Malinen6039f6d2009-03-19 13:39:21 +020010#include <linux/netdevice.h>
11#include <linux/nl80211.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090012#include <linux/slab.h>
Johannes Berga9a11622009-07-27 12:01:53 +020013#include <linux/wireless.h>
Jouni Malinen6039f6d2009-03-19 13:39:21 +020014#include <net/cfg80211.h>
Johannes Berga9a11622009-07-27 12:01:53 +020015#include <net/iw_handler.h>
Jouni Malinen6039f6d2009-03-19 13:39:21 +020016#include "core.h"
17#include "nl80211.h"
18
Johannes Bergcb0b4be2009-07-07 03:56:07 +020019void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len)
Jouni Malinen6039f6d2009-03-19 13:39:21 +020020{
Johannes Berg19957bb2009-07-02 17:20:43 +020021 struct wireless_dev *wdev = dev->ieee80211_ptr;
22 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen6039f6d2009-03-19 13:39:21 +020023 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg19957bb2009-07-02 17:20:43 +020024
Johannes Berg667503dd2009-07-07 03:56:11 +020025 wdev_lock(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +020026
Johannes Berg95de8172012-01-20 13:55:25 +010027 nl80211_send_rx_auth(rdev, dev, buf, len, GFP_KERNEL);
28 cfg80211_sme_rx_auth(dev, buf, len);
Johannes Berg667503dd2009-07-07 03:56:11 +020029
30 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +020031}
32EXPORT_SYMBOL(cfg80211_send_rx_auth);
33
Johannes Berg95de8172012-01-20 13:55:25 +010034void cfg80211_send_rx_assoc(struct net_device *dev, struct cfg80211_bss *bss,
35 const u8 *buf, size_t len)
Jouni Malinen6039f6d2009-03-19 13:39:21 +020036{
Johannes Berg6829c872009-07-02 09:13:27 +020037 u16 status_code;
38 struct wireless_dev *wdev = dev->ieee80211_ptr;
39 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen6039f6d2009-03-19 13:39:21 +020040 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg6829c872009-07-02 09:13:27 +020041 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
42 u8 *ie = mgmt->u.assoc_resp.variable;
Johannes Berg95de8172012-01-20 13:55:25 +010043 int ieoffs = offsetof(struct ieee80211_mgmt, u.assoc_resp.variable);
Johannes Berg6829c872009-07-02 09:13:27 +020044
Johannes Berg667503dd2009-07-07 03:56:11 +020045 wdev_lock(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +020046
Johannes Berg6829c872009-07-02 09:13:27 +020047 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
48
Johannes Bergf401a6f2009-08-07 14:51:05 +020049 /*
50 * This is a bit of a hack, we don't notify userspace of
51 * a (re-)association reply if we tried to send a reassoc
52 * and got a reject -- we only try again with an assoc
53 * frame instead of reassoc.
54 */
55 if (status_code != WLAN_STATUS_SUCCESS && wdev->conn &&
Johannes Berg95de8172012-01-20 13:55:25 +010056 cfg80211_sme_failed_reassoc(wdev)) {
57 cfg80211_put_bss(bss);
Johannes Bergf401a6f2009-08-07 14:51:05 +020058 goto out;
Johannes Berg95de8172012-01-20 13:55:25 +010059 }
Johannes Bergf401a6f2009-08-07 14:51:05 +020060
Johannes Bergcb0b4be2009-07-07 03:56:07 +020061 nl80211_send_rx_assoc(rdev, dev, buf, len, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +020062
Johannes Berg95de8172012-01-20 13:55:25 +010063 if (status_code != WLAN_STATUS_SUCCESS && wdev->conn) {
Johannes Berg7d930bc2009-10-20 15:08:53 +090064 cfg80211_sme_failed_assoc(wdev);
Johannes Berg7d930bc2009-10-20 15:08:53 +090065 /*
66 * do not call connect_result() now because the
67 * sme will schedule work that does it later.
68 */
Johannes Berg95de8172012-01-20 13:55:25 +010069 cfg80211_put_bss(bss);
Johannes Berg7d930bc2009-10-20 15:08:53 +090070 goto out;
Johannes Bergdf7fc0f2009-07-29 11:23:49 +020071 }
72
Johannes Bergea416a72009-08-17 12:22:14 +020073 if (!wdev->conn && wdev->sme_state == CFG80211_SME_IDLE) {
74 /*
75 * This is for the userspace SME, the CONNECTING
76 * state will be changed to CONNECTED by
77 * __cfg80211_connect_result() below.
78 */
79 wdev->sme_state = CFG80211_SME_CONNECTING;
80 }
81
Johannes Berg95de8172012-01-20 13:55:25 +010082 /* this consumes the bss reference */
Johannes Bergdf7fc0f2009-07-29 11:23:49 +020083 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, ie, len - ieoffs,
84 status_code,
Johannes Berg95de8172012-01-20 13:55:25 +010085 status_code == WLAN_STATUS_SUCCESS, bss);
Johannes Bergf401a6f2009-08-07 14:51:05 +020086 out:
Johannes Berg667503dd2009-07-07 03:56:11 +020087 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +020088}
89EXPORT_SYMBOL(cfg80211_send_rx_assoc);
90
Holger Schurigce470612009-10-13 13:28:13 +020091void __cfg80211_send_deauth(struct net_device *dev,
Johannes Berg667503dd2009-07-07 03:56:11 +020092 const u8 *buf, size_t len)
Jouni Malinen6039f6d2009-03-19 13:39:21 +020093{
Johannes Berg6829c872009-07-02 09:13:27 +020094 struct wireless_dev *wdev = dev->ieee80211_ptr;
95 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen6039f6d2009-03-19 13:39:21 +020096 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg6829c872009-07-02 09:13:27 +020097 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
Johannes Berg19957bb2009-07-02 17:20:43 +020098 const u8 *bssid = mgmt->bssid;
Johannes Berg95de8172012-01-20 13:55:25 +010099 bool was_current = false;
Johannes Berg6829c872009-07-02 09:13:27 +0200100
Johannes Berg667503dd2009-07-07 03:56:11 +0200101 ASSERT_WDEV_LOCK(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200102
Johannes Berg19957bb2009-07-02 17:20:43 +0200103 if (wdev->current_bss &&
Joe Perchesac422d32012-05-08 18:56:55 +0000104 ether_addr_equal(wdev->current_bss->pub.bssid, bssid)) {
Johannes Berg19957bb2009-07-02 17:20:43 +0200105 cfg80211_unhold_bss(wdev->current_bss);
106 cfg80211_put_bss(&wdev->current_bss->pub);
107 wdev->current_bss = NULL;
Johannes Berg3f3b6a82010-08-05 10:20:27 +0200108 was_current = true;
Johannes Berg19957bb2009-07-02 17:20:43 +0200109 }
Johannes Berg19957bb2009-07-02 17:20:43 +0200110
Johannes Berg5fba4af2009-12-02 12:43:42 +0100111 nl80211_send_deauth(rdev, dev, buf, len, GFP_KERNEL);
112
Johannes Berg3f3b6a82010-08-05 10:20:27 +0200113 if (wdev->sme_state == CFG80211_SME_CONNECTED && was_current) {
Johannes Berg6829c872009-07-02 09:13:27 +0200114 u16 reason_code;
115 bool from_ap;
116
117 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
118
Joe Perchesac422d32012-05-08 18:56:55 +0000119 from_ap = !ether_addr_equal(mgmt->sa, dev->dev_addr);
Johannes Berg667503dd2009-07-07 03:56:11 +0200120 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
Johannes Berg6829c872009-07-02 09:13:27 +0200121 } else if (wdev->sme_state == CFG80211_SME_CONNECTING) {
Johannes Berg667503dd2009-07-07 03:56:11 +0200122 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,
123 WLAN_STATUS_UNSPECIFIED_FAILURE,
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200124 false, NULL);
Johannes Berg667503dd2009-07-07 03:56:11 +0200125 }
126}
Holger Schurigce470612009-10-13 13:28:13 +0200127EXPORT_SYMBOL(__cfg80211_send_deauth);
Johannes Berg667503dd2009-07-07 03:56:11 +0200128
Holger Schurigce470612009-10-13 13:28:13 +0200129void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len)
Johannes Berg667503dd2009-07-07 03:56:11 +0200130{
131 struct wireless_dev *wdev = dev->ieee80211_ptr;
132
Holger Schurigce470612009-10-13 13:28:13 +0200133 wdev_lock(wdev);
134 __cfg80211_send_deauth(dev, buf, len);
135 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200136}
Jouni Malinen53b46b82009-03-27 20:53:56 +0200137EXPORT_SYMBOL(cfg80211_send_deauth);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200138
Holger Schurigce470612009-10-13 13:28:13 +0200139void __cfg80211_send_disassoc(struct net_device *dev,
Johannes Berg667503dd2009-07-07 03:56:11 +0200140 const u8 *buf, size_t len)
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200141{
Johannes Berg6829c872009-07-02 09:13:27 +0200142 struct wireless_dev *wdev = dev->ieee80211_ptr;
143 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200144 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg6829c872009-07-02 09:13:27 +0200145 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
Johannes Berg19957bb2009-07-02 17:20:43 +0200146 const u8 *bssid = mgmt->bssid;
Johannes Berg19957bb2009-07-02 17:20:43 +0200147 u16 reason_code;
148 bool from_ap;
Johannes Berg6829c872009-07-02 09:13:27 +0200149
Johannes Berg596a07c2009-07-11 00:17:32 +0200150 ASSERT_WDEV_LOCK(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200151
152 nl80211_send_disassoc(rdev, dev, buf, len, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +0200153
Johannes Berg596a07c2009-07-11 00:17:32 +0200154 if (wdev->sme_state != CFG80211_SME_CONNECTED)
155 return;
Johannes Berg6829c872009-07-02 09:13:27 +0200156
Johannes Berg19957bb2009-07-02 17:20:43 +0200157 if (wdev->current_bss &&
Joe Perchesac422d32012-05-08 18:56:55 +0000158 ether_addr_equal(wdev->current_bss->pub.bssid, bssid)) {
Johannes Berg95de8172012-01-20 13:55:25 +0100159 cfg80211_sme_disassoc(dev, wdev->current_bss);
160 cfg80211_unhold_bss(wdev->current_bss);
161 cfg80211_put_bss(&wdev->current_bss->pub);
162 wdev->current_bss = NULL;
Johannes Berg19957bb2009-07-02 17:20:43 +0200163 } else
164 WARN_ON(1);
Johannes Berg6829c872009-07-02 09:13:27 +0200165
Johannes Berg6829c872009-07-02 09:13:27 +0200166
Johannes Berg19957bb2009-07-02 17:20:43 +0200167 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
168
Joe Perchesac422d32012-05-08 18:56:55 +0000169 from_ap = !ether_addr_equal(mgmt->sa, dev->dev_addr);
Johannes Berg667503dd2009-07-07 03:56:11 +0200170 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
Johannes Berg667503dd2009-07-07 03:56:11 +0200171}
Holger Schurigce470612009-10-13 13:28:13 +0200172EXPORT_SYMBOL(__cfg80211_send_disassoc);
Johannes Berg667503dd2009-07-07 03:56:11 +0200173
Holger Schurigce470612009-10-13 13:28:13 +0200174void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len)
Johannes Berg667503dd2009-07-07 03:56:11 +0200175{
176 struct wireless_dev *wdev = dev->ieee80211_ptr;
177
Holger Schurigce470612009-10-13 13:28:13 +0200178 wdev_lock(wdev);
179 __cfg80211_send_disassoc(dev, buf, len);
180 wdev_unlock(wdev);
Jouni Malinen6039f6d2009-03-19 13:39:21 +0200181}
Jouni Malinen53b46b82009-03-27 20:53:56 +0200182EXPORT_SYMBOL(cfg80211_send_disassoc);
Jouni Malinena3b8b052009-03-27 21:59:49 +0200183
Jouni Malinencf4e5942010-12-16 00:52:40 +0200184void cfg80211_send_unprot_deauth(struct net_device *dev, const u8 *buf,
185 size_t len)
186{
187 struct wireless_dev *wdev = dev->ieee80211_ptr;
188 struct wiphy *wiphy = wdev->wiphy;
189 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
190
191 nl80211_send_unprot_deauth(rdev, dev, buf, len, GFP_ATOMIC);
192}
193EXPORT_SYMBOL(cfg80211_send_unprot_deauth);
194
195void cfg80211_send_unprot_disassoc(struct net_device *dev, const u8 *buf,
196 size_t len)
197{
198 struct wireless_dev *wdev = dev->ieee80211_ptr;
199 struct wiphy *wiphy = wdev->wiphy;
200 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
201
202 nl80211_send_unprot_disassoc(rdev, dev, buf, len, GFP_ATOMIC);
203}
204EXPORT_SYMBOL(cfg80211_send_unprot_disassoc);
205
Johannes Berga58ce432009-11-19 12:45:42 +0100206void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr)
207{
208 struct wireless_dev *wdev = dev->ieee80211_ptr;
209 struct wiphy *wiphy = wdev->wiphy;
210 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
211
212 wdev_lock(wdev);
213
214 nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
215 if (wdev->sme_state == CFG80211_SME_CONNECTING)
216 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
217 WLAN_STATUS_UNSPECIFIED_FAILURE,
218 false, NULL);
219
Johannes Berg667503dd2009-07-07 03:56:11 +0200220 wdev_unlock(wdev);
Jouni Malinen1965c852009-04-22 21:38:25 +0300221}
222EXPORT_SYMBOL(cfg80211_send_auth_timeout);
223
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200224void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr)
Jouni Malinen1965c852009-04-22 21:38:25 +0300225{
Johannes Berg6829c872009-07-02 09:13:27 +0200226 struct wireless_dev *wdev = dev->ieee80211_ptr;
227 struct wiphy *wiphy = wdev->wiphy;
Jouni Malinen1965c852009-04-22 21:38:25 +0300228 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg19957bb2009-07-02 17:20:43 +0200229
Johannes Berg667503dd2009-07-07 03:56:11 +0200230 wdev_lock(wdev);
Johannes Bergcb0b4be2009-07-07 03:56:07 +0200231
232 nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);
Johannes Berg6829c872009-07-02 09:13:27 +0200233 if (wdev->sme_state == CFG80211_SME_CONNECTING)
Johannes Berg667503dd2009-07-07 03:56:11 +0200234 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
235 WLAN_STATUS_UNSPECIFIED_FAILURE,
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200236 false, NULL);
Johannes Berg19957bb2009-07-02 17:20:43 +0200237
Johannes Berg667503dd2009-07-07 03:56:11 +0200238 wdev_unlock(wdev);
Jouni Malinen1965c852009-04-22 21:38:25 +0300239}
240EXPORT_SYMBOL(cfg80211_send_assoc_timeout);
241
Jouni Malinena3b8b052009-03-27 21:59:49 +0200242void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
243 enum nl80211_key_type key_type, int key_id,
Johannes Berge6d6e342009-07-01 21:26:47 +0200244 const u8 *tsc, gfp_t gfp)
Jouni Malinena3b8b052009-03-27 21:59:49 +0200245{
246 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
247 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg3d23e342009-09-29 23:27:28 +0200248#ifdef CONFIG_CFG80211_WEXT
Johannes Bergf58d4ed2009-06-19 02:45:21 +0200249 union iwreq_data wrqu;
Johannes Berge6d6e342009-07-01 21:26:47 +0200250 char *buf = kmalloc(128, gfp);
Johannes Bergf58d4ed2009-06-19 02:45:21 +0200251
252 if (buf) {
253 sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
254 "keyid=%d %scast addr=%pM)", key_id,
255 key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
256 addr);
257 memset(&wrqu, 0, sizeof(wrqu));
258 wrqu.data.length = strlen(buf);
259 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
260 kfree(buf);
261 }
262#endif
263
Johannes Berge6d6e342009-07-01 21:26:47 +0200264 nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
Jouni Malinena3b8b052009-03-27 21:59:49 +0200265}
266EXPORT_SYMBOL(cfg80211_michael_mic_failure);
Johannes Berg19957bb2009-07-02 17:20:43 +0200267
268/* some MLME handling for userspace SME */
Johannes Berg667503dd2009-07-07 03:56:11 +0200269int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
270 struct net_device *dev,
271 struct ieee80211_channel *chan,
272 enum nl80211_auth_type auth_type,
273 const u8 *bssid,
274 const u8 *ssid, int ssid_len,
Johannes Bergfffd0932009-07-08 14:22:54 +0200275 const u8 *ie, int ie_len,
Johannes Berg95de8172012-01-20 13:55:25 +0100276 const u8 *key, int key_len, int key_idx)
Johannes Berg19957bb2009-07-02 17:20:43 +0200277{
278 struct wireless_dev *wdev = dev->ieee80211_ptr;
279 struct cfg80211_auth_request req;
Johannes Berg95de8172012-01-20 13:55:25 +0100280 int err;
Johannes Berg19957bb2009-07-02 17:20:43 +0200281
Johannes Berg667503dd2009-07-07 03:56:11 +0200282 ASSERT_WDEV_LOCK(wdev);
283
Johannes Bergfffd0932009-07-08 14:22:54 +0200284 if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
285 if (!key || !key_len || key_idx < 0 || key_idx > 4)
286 return -EINVAL;
287
Johannes Berg0a9b5e12009-07-02 18:26:18 +0200288 if (wdev->current_bss &&
Joe Perchesac422d32012-05-08 18:56:55 +0000289 ether_addr_equal(bssid, wdev->current_bss->pub.bssid))
Johannes Berg0a9b5e12009-07-02 18:26:18 +0200290 return -EALREADY;
291
Johannes Berg19957bb2009-07-02 17:20:43 +0200292 memset(&req, 0, sizeof(req));
293
294 req.ie = ie;
295 req.ie_len = ie_len;
296 req.auth_type = auth_type;
297 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
298 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
Johannes Bergfffd0932009-07-08 14:22:54 +0200299 req.key = key;
300 req.key_len = key_len;
301 req.key_idx = key_idx;
Johannes Berg19957bb2009-07-02 17:20:43 +0200302 if (!req.bss)
303 return -ENOENT;
304
Johannes Berg19957bb2009-07-02 17:20:43 +0200305 err = rdev->ops->auth(&rdev->wiphy, dev, &req);
Johannes Berg19957bb2009-07-02 17:20:43 +0200306
Johannes Berg95de8172012-01-20 13:55:25 +0100307 cfg80211_put_bss(req.bss);
Johannes Berg19957bb2009-07-02 17:20:43 +0200308 return err;
309}
310
Johannes Berg667503dd2009-07-07 03:56:11 +0200311int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
312 struct net_device *dev, struct ieee80211_channel *chan,
313 enum nl80211_auth_type auth_type, const u8 *bssid,
314 const u8 *ssid, int ssid_len,
Johannes Bergfffd0932009-07-08 14:22:54 +0200315 const u8 *ie, int ie_len,
Johannes Berg95de8172012-01-20 13:55:25 +0100316 const u8 *key, int key_len, int key_idx)
Johannes Berg667503dd2009-07-07 03:56:11 +0200317{
318 int err;
319
320 wdev_lock(dev->ieee80211_ptr);
321 err = __cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
Johannes Bergfffd0932009-07-08 14:22:54 +0200322 ssid, ssid_len, ie, ie_len,
Johannes Berg95de8172012-01-20 13:55:25 +0100323 key, key_len, key_idx);
Johannes Berg667503dd2009-07-07 03:56:11 +0200324 wdev_unlock(dev->ieee80211_ptr);
325
326 return err;
327}
328
Ben Greear7e7c8922011-11-18 11:31:59 -0800329/* Do a logical ht_capa &= ht_capa_mask. */
330void cfg80211_oper_and_ht_capa(struct ieee80211_ht_cap *ht_capa,
331 const struct ieee80211_ht_cap *ht_capa_mask)
332{
333 int i;
334 u8 *p1, *p2;
335 if (!ht_capa_mask) {
336 memset(ht_capa, 0, sizeof(*ht_capa));
337 return;
338 }
339
340 p1 = (u8*)(ht_capa);
341 p2 = (u8*)(ht_capa_mask);
342 for (i = 0; i<sizeof(*ht_capa); i++)
343 p1[i] &= p2[i];
344}
345
Johannes Berg667503dd2009-07-07 03:56:11 +0200346int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
347 struct net_device *dev,
348 struct ieee80211_channel *chan,
349 const u8 *bssid, const u8 *prev_bssid,
350 const u8 *ssid, int ssid_len,
351 const u8 *ie, int ie_len, bool use_mfp,
Ben Greear7e7c8922011-11-18 11:31:59 -0800352 struct cfg80211_crypto_settings *crypt,
353 u32 assoc_flags, struct ieee80211_ht_cap *ht_capa,
354 struct ieee80211_ht_cap *ht_capa_mask)
Johannes Berg19957bb2009-07-02 17:20:43 +0200355{
356 struct wireless_dev *wdev = dev->ieee80211_ptr;
357 struct cfg80211_assoc_request req;
Johannes Berg95de8172012-01-20 13:55:25 +0100358 int err;
Jouni Malinen24b6b152009-11-17 21:35:38 +0200359 bool was_connected = false;
Johannes Berg19957bb2009-07-02 17:20:43 +0200360
Johannes Berg667503dd2009-07-07 03:56:11 +0200361 ASSERT_WDEV_LOCK(wdev);
362
Johannes Berg19957bb2009-07-02 17:20:43 +0200363 memset(&req, 0, sizeof(req));
364
Jouni Malinen24b6b152009-11-17 21:35:38 +0200365 if (wdev->current_bss && prev_bssid &&
Joe Perchesac422d32012-05-08 18:56:55 +0000366 ether_addr_equal(wdev->current_bss->pub.bssid, prev_bssid)) {
Jouni Malinen24b6b152009-11-17 21:35:38 +0200367 /*
368 * Trying to reassociate: Allow this to proceed and let the old
369 * association to be dropped when the new one is completed.
370 */
371 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
372 was_connected = true;
373 wdev->sme_state = CFG80211_SME_CONNECTING;
374 }
375 } else if (wdev->current_bss)
Johannes Berg19957bb2009-07-02 17:20:43 +0200376 return -EALREADY;
377
378 req.ie = ie;
379 req.ie_len = ie_len;
380 memcpy(&req.crypto, crypt, sizeof(req.crypto));
381 req.use_mfp = use_mfp;
Johannes Berg3e5d7642009-07-07 14:37:26 +0200382 req.prev_bssid = prev_bssid;
Ben Greear7e7c8922011-11-18 11:31:59 -0800383 req.flags = assoc_flags;
384 if (ht_capa)
385 memcpy(&req.ht_capa, ht_capa, sizeof(req.ht_capa));
386 if (ht_capa_mask)
387 memcpy(&req.ht_capa_mask, ht_capa_mask,
388 sizeof(req.ht_capa_mask));
389 cfg80211_oper_and_ht_capa(&req.ht_capa_mask,
390 rdev->wiphy.ht_capa_mod_mask);
391
Johannes Berg19957bb2009-07-02 17:20:43 +0200392 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
393 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
Jouni Malinen24b6b152009-11-17 21:35:38 +0200394 if (!req.bss) {
395 if (was_connected)
396 wdev->sme_state = CFG80211_SME_CONNECTED;
Johannes Berg19957bb2009-07-02 17:20:43 +0200397 return -ENOENT;
Jouni Malinen24b6b152009-11-17 21:35:38 +0200398 }
Johannes Berg19957bb2009-07-02 17:20:43 +0200399
Johannes Berg19957bb2009-07-02 17:20:43 +0200400 err = rdev->ops->assoc(&rdev->wiphy, dev, &req);
Johannes Berg95de8172012-01-20 13:55:25 +0100401
402 if (err) {
403 if (was_connected)
404 wdev->sme_state = CFG80211_SME_CONNECTED;
405 cfg80211_put_bss(req.bss);
406 }
407
Johannes Berg19957bb2009-07-02 17:20:43 +0200408 return err;
409}
410
Johannes Berg667503dd2009-07-07 03:56:11 +0200411int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
412 struct net_device *dev,
413 struct ieee80211_channel *chan,
414 const u8 *bssid, const u8 *prev_bssid,
415 const u8 *ssid, int ssid_len,
416 const u8 *ie, int ie_len, bool use_mfp,
Ben Greear7e7c8922011-11-18 11:31:59 -0800417 struct cfg80211_crypto_settings *crypt,
418 u32 assoc_flags, struct ieee80211_ht_cap *ht_capa,
419 struct ieee80211_ht_cap *ht_capa_mask)
Johannes Berg667503dd2009-07-07 03:56:11 +0200420{
421 struct wireless_dev *wdev = dev->ieee80211_ptr;
422 int err;
423
424 wdev_lock(wdev);
425 err = __cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
Ben Greear7e7c8922011-11-18 11:31:59 -0800426 ssid, ssid_len, ie, ie_len, use_mfp, crypt,
427 assoc_flags, ht_capa, ht_capa_mask);
Johannes Berg667503dd2009-07-07 03:56:11 +0200428 wdev_unlock(wdev);
429
430 return err;
431}
432
433int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
434 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300435 const u8 *ie, int ie_len, u16 reason,
436 bool local_state_change)
Johannes Berg19957bb2009-07-02 17:20:43 +0200437{
438 struct wireless_dev *wdev = dev->ieee80211_ptr;
Johannes Berg95de8172012-01-20 13:55:25 +0100439 struct cfg80211_deauth_request req = {
440 .bssid = bssid,
441 .reason_code = reason,
442 .ie = ie,
443 .ie_len = ie_len,
444 };
Johannes Berg19957bb2009-07-02 17:20:43 +0200445
Johannes Berg667503dd2009-07-07 03:56:11 +0200446 ASSERT_WDEV_LOCK(wdev);
447
Johannes Berg95de8172012-01-20 13:55:25 +0100448 if (local_state_change) {
449 if (wdev->current_bss &&
Joe Perchesac422d32012-05-08 18:56:55 +0000450 ether_addr_equal(wdev->current_bss->pub.bssid, bssid)) {
Johannes Berg95de8172012-01-20 13:55:25 +0100451 cfg80211_unhold_bss(wdev->current_bss);
452 cfg80211_put_bss(&wdev->current_bss->pub);
453 wdev->current_bss = NULL;
Johannes Berg19957bb2009-07-02 17:20:43 +0200454 }
Johannes Berg19957bb2009-07-02 17:20:43 +0200455
Johannes Berg95de8172012-01-20 13:55:25 +0100456 return 0;
457 }
Johannes Berg19957bb2009-07-02 17:20:43 +0200458
Johannes Berg63c9c5e2012-02-24 13:50:51 +0100459 return rdev->ops->deauth(&rdev->wiphy, dev, &req);
Johannes Berg19957bb2009-07-02 17:20:43 +0200460}
461
Johannes Berg667503dd2009-07-07 03:56:11 +0200462int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
463 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300464 const u8 *ie, int ie_len, u16 reason,
465 bool local_state_change)
Johannes Berg667503dd2009-07-07 03:56:11 +0200466{
467 struct wireless_dev *wdev = dev->ieee80211_ptr;
468 int err;
469
470 wdev_lock(wdev);
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300471 err = __cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason,
472 local_state_change);
Johannes Berg667503dd2009-07-07 03:56:11 +0200473 wdev_unlock(wdev);
474
475 return err;
476}
477
478static int __cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
479 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300480 const u8 *ie, int ie_len, u16 reason,
481 bool local_state_change)
Johannes Berg19957bb2009-07-02 17:20:43 +0200482{
483 struct wireless_dev *wdev = dev->ieee80211_ptr;
484 struct cfg80211_disassoc_request req;
485
Johannes Berg667503dd2009-07-07 03:56:11 +0200486 ASSERT_WDEV_LOCK(wdev);
487
Johannes Bergf9d6b402009-07-27 10:22:28 +0200488 if (wdev->sme_state != CFG80211_SME_CONNECTED)
489 return -ENOTCONN;
490
491 if (WARN_ON(!wdev->current_bss))
492 return -ENOTCONN;
493
Johannes Berg19957bb2009-07-02 17:20:43 +0200494 memset(&req, 0, sizeof(req));
495 req.reason_code = reason;
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300496 req.local_state_change = local_state_change;
Johannes Berg19957bb2009-07-02 17:20:43 +0200497 req.ie = ie;
498 req.ie_len = ie_len;
Joe Perchesac422d32012-05-08 18:56:55 +0000499 if (ether_addr_equal(wdev->current_bss->pub.bssid, bssid))
Johannes Berg19957bb2009-07-02 17:20:43 +0200500 req.bss = &wdev->current_bss->pub;
501 else
502 return -ENOTCONN;
503
Johannes Berg63c9c5e2012-02-24 13:50:51 +0100504 return rdev->ops->disassoc(&rdev->wiphy, dev, &req);
Johannes Berg667503dd2009-07-07 03:56:11 +0200505}
506
507int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
508 struct net_device *dev, const u8 *bssid,
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300509 const u8 *ie, int ie_len, u16 reason,
510 bool local_state_change)
Johannes Berg667503dd2009-07-07 03:56:11 +0200511{
512 struct wireless_dev *wdev = dev->ieee80211_ptr;
513 int err;
514
515 wdev_lock(wdev);
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300516 err = __cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason,
517 local_state_change);
Johannes Berg667503dd2009-07-07 03:56:11 +0200518 wdev_unlock(wdev);
519
520 return err;
Johannes Berg19957bb2009-07-02 17:20:43 +0200521}
522
523void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
524 struct net_device *dev)
525{
526 struct wireless_dev *wdev = dev->ieee80211_ptr;
527 struct cfg80211_deauth_request req;
Johannes Berg95de8172012-01-20 13:55:25 +0100528 u8 bssid[ETH_ALEN];
Johannes Berg19957bb2009-07-02 17:20:43 +0200529
Johannes Berg667503dd2009-07-07 03:56:11 +0200530 ASSERT_WDEV_LOCK(wdev);
531
Johannes Berg19957bb2009-07-02 17:20:43 +0200532 if (!rdev->ops->deauth)
533 return;
534
535 memset(&req, 0, sizeof(req));
536 req.reason_code = WLAN_REASON_DEAUTH_LEAVING;
537 req.ie = NULL;
538 req.ie_len = 0;
539
Johannes Berg95de8172012-01-20 13:55:25 +0100540 if (!wdev->current_bss)
541 return;
Johannes Berg19957bb2009-07-02 17:20:43 +0200542
Johannes Berg95de8172012-01-20 13:55:25 +0100543 memcpy(bssid, wdev->current_bss->pub.bssid, ETH_ALEN);
544 req.bssid = bssid;
Johannes Berg63c9c5e2012-02-24 13:50:51 +0100545 rdev->ops->deauth(&rdev->wiphy, dev, &req);
Johannes Berg95de8172012-01-20 13:55:25 +0100546
547 if (wdev->current_bss) {
548 cfg80211_unhold_bss(wdev->current_bss);
549 cfg80211_put_bss(&wdev->current_bss->pub);
550 wdev->current_bss = NULL;
Johannes Berg19957bb2009-07-02 17:20:43 +0200551 }
552}
Jouni Malinen9588bbd2009-12-23 13:15:41 +0100553
554void cfg80211_ready_on_channel(struct net_device *dev, u64 cookie,
555 struct ieee80211_channel *chan,
556 enum nl80211_channel_type channel_type,
557 unsigned int duration, gfp_t gfp)
558{
559 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
560 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
561
562 nl80211_send_remain_on_channel(rdev, dev, cookie, chan, channel_type,
563 duration, gfp);
564}
565EXPORT_SYMBOL(cfg80211_ready_on_channel);
566
567void cfg80211_remain_on_channel_expired(struct net_device *dev,
568 u64 cookie,
569 struct ieee80211_channel *chan,
570 enum nl80211_channel_type channel_type,
571 gfp_t gfp)
572{
573 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
574 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
575
576 nl80211_send_remain_on_channel_cancel(rdev, dev, cookie, chan,
577 channel_type, gfp);
578}
579EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
Johannes Berg98b62182009-12-23 13:15:44 +0100580
581void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
582 struct station_info *sinfo, gfp_t gfp)
583{
584 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
585 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
586
587 nl80211_send_sta_event(rdev, dev, mac_addr, sinfo, gfp);
588}
589EXPORT_SYMBOL(cfg80211_new_sta);
Jouni Malinen026331c2010-02-15 12:53:10 +0200590
Jouni Malinenec15e682011-03-23 15:29:52 +0200591void cfg80211_del_sta(struct net_device *dev, const u8 *mac_addr, gfp_t gfp)
592{
593 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
594 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
595
596 nl80211_send_sta_del_event(rdev, dev, mac_addr, gfp);
597}
598EXPORT_SYMBOL(cfg80211_del_sta);
599
Johannes Berg2e161f72010-08-12 15:38:38 +0200600struct cfg80211_mgmt_registration {
Jouni Malinen026331c2010-02-15 12:53:10 +0200601 struct list_head list;
602
603 u32 nlpid;
604
605 int match_len;
606
Johannes Berg2e161f72010-08-12 15:38:38 +0200607 __le16 frame_type;
608
Jouni Malinen026331c2010-02-15 12:53:10 +0200609 u8 match[];
610};
611
Johannes Berg2e161f72010-08-12 15:38:38 +0200612int cfg80211_mlme_register_mgmt(struct wireless_dev *wdev, u32 snd_pid,
613 u16 frame_type, const u8 *match_data,
614 int match_len)
Jouni Malinen026331c2010-02-15 12:53:10 +0200615{
Johannes Berg271733c2010-10-13 12:06:23 +0200616 struct wiphy *wiphy = wdev->wiphy;
617 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg2e161f72010-08-12 15:38:38 +0200618 struct cfg80211_mgmt_registration *reg, *nreg;
Jouni Malinen026331c2010-02-15 12:53:10 +0200619 int err = 0;
Johannes Berg2e161f72010-08-12 15:38:38 +0200620 u16 mgmt_type;
621
622 if (!wdev->wiphy->mgmt_stypes)
623 return -EOPNOTSUPP;
624
625 if ((frame_type & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_MGMT)
626 return -EINVAL;
627
628 if (frame_type & ~(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE))
629 return -EINVAL;
630
631 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
632 if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].rx & BIT(mgmt_type)))
633 return -EINVAL;
Jouni Malinen026331c2010-02-15 12:53:10 +0200634
635 nreg = kzalloc(sizeof(*reg) + match_len, GFP_KERNEL);
636 if (!nreg)
637 return -ENOMEM;
638
Johannes Berg2e161f72010-08-12 15:38:38 +0200639 spin_lock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200640
Johannes Berg2e161f72010-08-12 15:38:38 +0200641 list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
Jouni Malinen026331c2010-02-15 12:53:10 +0200642 int mlen = min(match_len, reg->match_len);
643
Johannes Berg2e161f72010-08-12 15:38:38 +0200644 if (frame_type != le16_to_cpu(reg->frame_type))
645 continue;
646
Jouni Malinen026331c2010-02-15 12:53:10 +0200647 if (memcmp(reg->match, match_data, mlen) == 0) {
648 err = -EALREADY;
649 break;
650 }
651 }
652
653 if (err) {
654 kfree(nreg);
655 goto out;
656 }
657
658 memcpy(nreg->match, match_data, match_len);
659 nreg->match_len = match_len;
660 nreg->nlpid = snd_pid;
Johannes Berg2e161f72010-08-12 15:38:38 +0200661 nreg->frame_type = cpu_to_le16(frame_type);
662 list_add(&nreg->list, &wdev->mgmt_registrations);
Jouni Malinen026331c2010-02-15 12:53:10 +0200663
Johannes Berg271733c2010-10-13 12:06:23 +0200664 if (rdev->ops->mgmt_frame_register)
665 rdev->ops->mgmt_frame_register(wiphy, wdev->netdev,
666 frame_type, true);
667
Jouni Malinen026331c2010-02-15 12:53:10 +0200668 out:
Johannes Berg2e161f72010-08-12 15:38:38 +0200669 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Johannes Berg271733c2010-10-13 12:06:23 +0200670
Jouni Malinen026331c2010-02-15 12:53:10 +0200671 return err;
672}
673
Johannes Berg2e161f72010-08-12 15:38:38 +0200674void cfg80211_mlme_unregister_socket(struct wireless_dev *wdev, u32 nlpid)
Jouni Malinen026331c2010-02-15 12:53:10 +0200675{
Johannes Berg271733c2010-10-13 12:06:23 +0200676 struct wiphy *wiphy = wdev->wiphy;
677 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg2e161f72010-08-12 15:38:38 +0200678 struct cfg80211_mgmt_registration *reg, *tmp;
Jouni Malinen026331c2010-02-15 12:53:10 +0200679
Johannes Berg2e161f72010-08-12 15:38:38 +0200680 spin_lock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200681
Johannes Berg2e161f72010-08-12 15:38:38 +0200682 list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
Johannes Berg271733c2010-10-13 12:06:23 +0200683 if (reg->nlpid != nlpid)
684 continue;
685
686 if (rdev->ops->mgmt_frame_register) {
687 u16 frame_type = le16_to_cpu(reg->frame_type);
688
689 rdev->ops->mgmt_frame_register(wiphy, wdev->netdev,
690 frame_type, false);
Jouni Malinen026331c2010-02-15 12:53:10 +0200691 }
Johannes Berg271733c2010-10-13 12:06:23 +0200692
693 list_del(&reg->list);
694 kfree(reg);
Jouni Malinen026331c2010-02-15 12:53:10 +0200695 }
696
Johannes Berg2e161f72010-08-12 15:38:38 +0200697 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Johannes Berg28946da2011-11-04 11:18:12 +0100698
699 if (nlpid == wdev->ap_unexpected_nlpid)
700 wdev->ap_unexpected_nlpid = 0;
Jouni Malinen026331c2010-02-15 12:53:10 +0200701}
702
Johannes Berg2e161f72010-08-12 15:38:38 +0200703void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev)
Jouni Malinen026331c2010-02-15 12:53:10 +0200704{
Johannes Berg2e161f72010-08-12 15:38:38 +0200705 struct cfg80211_mgmt_registration *reg, *tmp;
Jouni Malinen026331c2010-02-15 12:53:10 +0200706
Johannes Berg2e161f72010-08-12 15:38:38 +0200707 spin_lock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200708
Johannes Berg2e161f72010-08-12 15:38:38 +0200709 list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
Jouni Malinen026331c2010-02-15 12:53:10 +0200710 list_del(&reg->list);
711 kfree(reg);
712 }
713
Johannes Berg2e161f72010-08-12 15:38:38 +0200714 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200715}
716
Johannes Berg2e161f72010-08-12 15:38:38 +0200717int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
718 struct net_device *dev,
Johannes Bergf7ca38d2010-11-25 10:02:29 +0100719 struct ieee80211_channel *chan, bool offchan,
Johannes Berg2e161f72010-08-12 15:38:38 +0200720 enum nl80211_channel_type channel_type,
Johannes Bergf7ca38d2010-11-25 10:02:29 +0100721 bool channel_type_valid, unsigned int wait,
Rajkumar Manoharane9f935e2011-09-25 14:53:30 +0530722 const u8 *buf, size_t len, bool no_cck,
Johannes Berge247bd902011-11-04 11:18:21 +0100723 bool dont_wait_for_ack, u64 *cookie)
Jouni Malinen026331c2010-02-15 12:53:10 +0200724{
725 struct wireless_dev *wdev = dev->ieee80211_ptr;
726 const struct ieee80211_mgmt *mgmt;
Johannes Berg2e161f72010-08-12 15:38:38 +0200727 u16 stype;
Jouni Malinen026331c2010-02-15 12:53:10 +0200728
Johannes Berg2e161f72010-08-12 15:38:38 +0200729 if (!wdev->wiphy->mgmt_stypes)
Jouni Malinen026331c2010-02-15 12:53:10 +0200730 return -EOPNOTSUPP;
Johannes Berg2e161f72010-08-12 15:38:38 +0200731
732 if (!rdev->ops->mgmt_tx)
733 return -EOPNOTSUPP;
734
Jouni Malinen026331c2010-02-15 12:53:10 +0200735 if (len < 24 + 1)
736 return -EINVAL;
737
738 mgmt = (const struct ieee80211_mgmt *) buf;
Johannes Berg2e161f72010-08-12 15:38:38 +0200739
740 if (!ieee80211_is_mgmt(mgmt->frame_control))
Jouni Malinen026331c2010-02-15 12:53:10 +0200741 return -EINVAL;
Johannes Berg2e161f72010-08-12 15:38:38 +0200742
743 stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
744 if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].tx & BIT(stype >> 4)))
745 return -EINVAL;
746
747 if (ieee80211_is_action(mgmt->frame_control) &&
748 mgmt->u.action.category != WLAN_CATEGORY_PUBLIC) {
Johannes Berg663fcaf2010-09-30 21:06:09 +0200749 int err = 0;
750
Johannes Bergfe100ac2010-08-09 15:52:03 +0200751 wdev_lock(wdev);
752
Johannes Berg663fcaf2010-09-30 21:06:09 +0200753 switch (wdev->iftype) {
754 case NL80211_IFTYPE_ADHOC:
755 case NL80211_IFTYPE_STATION:
756 case NL80211_IFTYPE_P2P_CLIENT:
757 if (!wdev->current_bss) {
758 err = -ENOTCONN;
759 break;
760 }
Johannes Bergfe100ac2010-08-09 15:52:03 +0200761
Joe Perchesac422d32012-05-08 18:56:55 +0000762 if (!ether_addr_equal(wdev->current_bss->pub.bssid,
763 mgmt->bssid)) {
Johannes Berg663fcaf2010-09-30 21:06:09 +0200764 err = -ENOTCONN;
765 break;
766 }
767
768 /*
769 * check for IBSS DA must be done by driver as
770 * cfg80211 doesn't track the stations
771 */
772 if (wdev->iftype == NL80211_IFTYPE_ADHOC)
773 break;
774
775 /* for station, check that DA is the AP */
Joe Perchesac422d32012-05-08 18:56:55 +0000776 if (!ether_addr_equal(wdev->current_bss->pub.bssid,
777 mgmt->da)) {
Johannes Berg663fcaf2010-09-30 21:06:09 +0200778 err = -ENOTCONN;
779 break;
780 }
781 break;
782 case NL80211_IFTYPE_AP:
783 case NL80211_IFTYPE_P2P_GO:
784 case NL80211_IFTYPE_AP_VLAN:
Joe Perchesac422d32012-05-08 18:56:55 +0000785 if (!ether_addr_equal(mgmt->bssid, dev->dev_addr))
Johannes Berg663fcaf2010-09-30 21:06:09 +0200786 err = -EINVAL;
787 break;
Javier Cardona0778a6a2011-05-03 16:57:08 -0700788 case NL80211_IFTYPE_MESH_POINT:
Joe Perchesac422d32012-05-08 18:56:55 +0000789 if (!ether_addr_equal(mgmt->sa, mgmt->bssid)) {
Javier Cardona0778a6a2011-05-03 16:57:08 -0700790 err = -EINVAL;
791 break;
792 }
793 /*
794 * check for mesh DA must be done by driver as
795 * cfg80211 doesn't track the stations
796 */
797 break;
Johannes Berg663fcaf2010-09-30 21:06:09 +0200798 default:
799 err = -EOPNOTSUPP;
800 break;
801 }
Johannes Bergfe100ac2010-08-09 15:52:03 +0200802 wdev_unlock(wdev);
Johannes Berg663fcaf2010-09-30 21:06:09 +0200803
804 if (err)
805 return err;
Jouni Malinen026331c2010-02-15 12:53:10 +0200806 }
807
Joe Perchesac422d32012-05-08 18:56:55 +0000808 if (!ether_addr_equal(mgmt->sa, dev->dev_addr))
Jouni Malinen026331c2010-02-15 12:53:10 +0200809 return -EINVAL;
810
811 /* Transmit the Action frame as requested by user space */
Johannes Bergf7ca38d2010-11-25 10:02:29 +0100812 return rdev->ops->mgmt_tx(&rdev->wiphy, dev, chan, offchan,
813 channel_type, channel_type_valid,
Johannes Berge247bd902011-11-04 11:18:21 +0100814 wait, buf, len, no_cck, dont_wait_for_ack,
815 cookie);
Jouni Malinen026331c2010-02-15 12:53:10 +0200816}
817
Johannes Berg804483e2012-03-05 22:18:41 +0100818bool cfg80211_rx_mgmt(struct net_device *dev, int freq, int sig_mbm,
819 const u8 *buf, size_t len, gfp_t gfp)
Jouni Malinen026331c2010-02-15 12:53:10 +0200820{
821 struct wireless_dev *wdev = dev->ieee80211_ptr;
822 struct wiphy *wiphy = wdev->wiphy;
823 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg2e161f72010-08-12 15:38:38 +0200824 struct cfg80211_mgmt_registration *reg;
825 const struct ieee80211_txrx_stypes *stypes =
826 &wiphy->mgmt_stypes[wdev->iftype];
827 struct ieee80211_mgmt *mgmt = (void *)buf;
828 const u8 *data;
829 int data_len;
Jouni Malinen026331c2010-02-15 12:53:10 +0200830 bool result = false;
Johannes Berg2e161f72010-08-12 15:38:38 +0200831 __le16 ftype = mgmt->frame_control &
832 cpu_to_le16(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE);
833 u16 stype;
Jouni Malinen026331c2010-02-15 12:53:10 +0200834
Johannes Berg2e161f72010-08-12 15:38:38 +0200835 stype = (le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE) >> 4;
Jouni Malinen026331c2010-02-15 12:53:10 +0200836
Johannes Berg2e161f72010-08-12 15:38:38 +0200837 if (!(stypes->rx & BIT(stype)))
838 return false;
Jouni Malinen026331c2010-02-15 12:53:10 +0200839
Johannes Berg2e161f72010-08-12 15:38:38 +0200840 data = buf + ieee80211_hdrlen(mgmt->frame_control);
841 data_len = len - ieee80211_hdrlen(mgmt->frame_control);
Jouni Malinen026331c2010-02-15 12:53:10 +0200842
Johannes Berg2e161f72010-08-12 15:38:38 +0200843 spin_lock_bh(&wdev->mgmt_registrations_lock);
844
845 list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
846 if (reg->frame_type != ftype)
Jouni Malinen026331c2010-02-15 12:53:10 +0200847 continue;
848
Johannes Berg2e161f72010-08-12 15:38:38 +0200849 if (reg->match_len > data_len)
850 continue;
851
852 if (memcmp(reg->match, data, reg->match_len))
Jouni Malinen026331c2010-02-15 12:53:10 +0200853 continue;
854
855 /* found match! */
856
857 /* Indicate the received Action frame to user space */
Johannes Berg804483e2012-03-05 22:18:41 +0100858 if (nl80211_send_mgmt(rdev, dev, reg->nlpid,
859 freq, sig_mbm,
Johannes Berg2e161f72010-08-12 15:38:38 +0200860 buf, len, gfp))
Jouni Malinen026331c2010-02-15 12:53:10 +0200861 continue;
862
863 result = true;
864 break;
865 }
866
Johannes Berg2e161f72010-08-12 15:38:38 +0200867 spin_unlock_bh(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200868
869 return result;
870}
Johannes Berg2e161f72010-08-12 15:38:38 +0200871EXPORT_SYMBOL(cfg80211_rx_mgmt);
Jouni Malinen026331c2010-02-15 12:53:10 +0200872
Johannes Berg2e161f72010-08-12 15:38:38 +0200873void cfg80211_mgmt_tx_status(struct net_device *dev, u64 cookie,
874 const u8 *buf, size_t len, bool ack, gfp_t gfp)
Jouni Malinen026331c2010-02-15 12:53:10 +0200875{
876 struct wireless_dev *wdev = dev->ieee80211_ptr;
877 struct wiphy *wiphy = wdev->wiphy;
878 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
879
880 /* Indicate TX status of the Action frame to user space */
Johannes Berg2e161f72010-08-12 15:38:38 +0200881 nl80211_send_mgmt_tx_status(rdev, dev, cookie, buf, len, ack, gfp);
Jouni Malinen026331c2010-02-15 12:53:10 +0200882}
Johannes Berg2e161f72010-08-12 15:38:38 +0200883EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
Juuso Oikarinend6dc1a32010-03-23 09:02:33 +0200884
885void cfg80211_cqm_rssi_notify(struct net_device *dev,
886 enum nl80211_cqm_rssi_threshold_event rssi_event,
887 gfp_t gfp)
888{
889 struct wireless_dev *wdev = dev->ieee80211_ptr;
890 struct wiphy *wiphy = wdev->wiphy;
891 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
892
893 /* Indicate roaming trigger event to user space */
894 nl80211_send_cqm_rssi_notify(rdev, dev, rssi_event, gfp);
895}
896EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
Johannes Bergc063dbf2010-11-24 08:10:05 +0100897
898void cfg80211_cqm_pktloss_notify(struct net_device *dev,
899 const u8 *peer, u32 num_packets, gfp_t gfp)
900{
901 struct wireless_dev *wdev = dev->ieee80211_ptr;
902 struct wiphy *wiphy = wdev->wiphy;
903 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
904
905 /* Indicate roaming trigger event to user space */
906 nl80211_send_cqm_pktloss_notify(rdev, dev, peer, num_packets, gfp);
907}
908EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
Johannes Berge5497d72011-07-05 16:35:40 +0200909
910void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
911 const u8 *replay_ctr, gfp_t gfp)
912{
913 struct wireless_dev *wdev = dev->ieee80211_ptr;
914 struct wiphy *wiphy = wdev->wiphy;
915 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
916
917 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
918}
919EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
Jouni Malinenc9df56b2011-09-16 18:56:23 +0300920
921void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
922 const u8 *bssid, bool preauth, gfp_t gfp)
923{
924 struct wireless_dev *wdev = dev->ieee80211_ptr;
925 struct wiphy *wiphy = wdev->wiphy;
926 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
927
928 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
929}
930EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
Johannes Berg28946da2011-11-04 11:18:12 +0100931
Thomas Pedersen53145262012-04-06 13:35:47 -0700932void cfg80211_ch_switch_notify(struct net_device *dev, int freq,
933 enum nl80211_channel_type type)
934{
935 struct wireless_dev *wdev = dev->ieee80211_ptr;
936 struct wiphy *wiphy = wdev->wiphy;
937 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
938 struct ieee80211_channel *chan;
939
940 wdev_lock(wdev);
941
942 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
943 wdev->iftype != NL80211_IFTYPE_P2P_GO))
944 goto out;
945
946 chan = rdev_freq_to_chan(rdev, freq, type);
947 if (WARN_ON(!chan))
948 goto out;
949
950 wdev->channel = chan;
951
952 nl80211_ch_switch_notify(rdev, dev, freq, type, GFP_KERNEL);
953out:
954 wdev_unlock(wdev);
955 return;
956}
957EXPORT_SYMBOL(cfg80211_ch_switch_notify);
958
Johannes Berg28946da2011-11-04 11:18:12 +0100959bool cfg80211_rx_spurious_frame(struct net_device *dev,
960 const u8 *addr, gfp_t gfp)
961{
962 struct wireless_dev *wdev = dev->ieee80211_ptr;
963
964 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
965 wdev->iftype != NL80211_IFTYPE_P2P_GO))
966 return false;
967
968 return nl80211_unexpected_frame(dev, addr, gfp);
969}
970EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
Johannes Bergb92ab5d2011-11-04 11:18:19 +0100971
972bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
973 const u8 *addr, gfp_t gfp)
974{
975 struct wireless_dev *wdev = dev->ieee80211_ptr;
976
977 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
978 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
979 wdev->iftype != NL80211_IFTYPE_AP_VLAN))
980 return false;
981
982 return nl80211_unexpected_4addr_frame(dev, addr, gfp);
983}
984EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);