2 * cfg80211 MLME SAP interface
4 * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/netdevice.h>
10 #include <linux/nl80211.h>
11 #include <linux/wireless.h>
12 #include <net/cfg80211.h>
13 #include <net/iw_handler.h>
17 void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len)
19 struct wireless_dev *wdev = dev->ieee80211_ptr;
20 struct wiphy *wiphy = wdev->wiphy;
21 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
22 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
23 u8 *bssid = mgmt->bssid;
25 u16 status = le16_to_cpu(mgmt->u.auth.status_code);
30 for (i = 0; i < MAX_AUTH_BSSES; i++) {
31 if (wdev->authtry_bsses[i] &&
32 memcmp(wdev->authtry_bsses[i]->pub.bssid, bssid,
34 if (status == WLAN_STATUS_SUCCESS) {
35 wdev->auth_bsses[i] = wdev->authtry_bsses[i];
37 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
38 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
40 wdev->authtry_bsses[i] = NULL;
48 nl80211_send_rx_auth(rdev, dev, buf, len, GFP_KERNEL);
49 cfg80211_sme_rx_auth(dev, buf, len);
53 EXPORT_SYMBOL(cfg80211_send_rx_auth);
55 void cfg80211_send_rx_assoc(struct net_device *dev, const u8 *buf, size_t len)
58 struct wireless_dev *wdev = dev->ieee80211_ptr;
59 struct wiphy *wiphy = wdev->wiphy;
60 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
61 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
62 u8 *ie = mgmt->u.assoc_resp.variable;
63 int i, ieoffs = offsetof(struct ieee80211_mgmt, u.assoc_resp.variable);
64 struct cfg80211_internal_bss *bss = NULL;
68 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
71 * This is a bit of a hack, we don't notify userspace of
72 * a (re-)association reply if we tried to send a reassoc
73 * and got a reject -- we only try again with an assoc
74 * frame instead of reassoc.
76 if (status_code != WLAN_STATUS_SUCCESS && wdev->conn &&
77 cfg80211_sme_failed_reassoc(wdev))
80 nl80211_send_rx_assoc(rdev, dev, buf, len, GFP_KERNEL);
82 if (status_code == WLAN_STATUS_SUCCESS) {
83 for (i = 0; i < MAX_AUTH_BSSES; i++) {
84 if (!wdev->auth_bsses[i])
86 if (memcmp(wdev->auth_bsses[i]->pub.bssid, mgmt->bssid,
88 bss = wdev->auth_bsses[i];
89 wdev->auth_bsses[i] = NULL;
90 /* additional reference to drop hold */
91 cfg80211_ref_bss(bss);
97 * We might be coming here because the driver reported
98 * a successful association at the same time as the
99 * user requested a deauth. In that case, we will have
100 * removed the BSS from the auth_bsses list due to the
101 * deauth request when the assoc response makes it. If
102 * the two code paths acquire the lock the other way
103 * around, that's just the standard situation of a
104 * deauth being requested while connected.
108 } else if (wdev->conn) {
109 cfg80211_sme_failed_assoc(wdev);
111 * do not call connect_result() now because the
112 * sme will schedule work that does it later.
117 if (!wdev->conn && wdev->sme_state == CFG80211_SME_IDLE) {
119 * This is for the userspace SME, the CONNECTING
120 * state will be changed to CONNECTED by
121 * __cfg80211_connect_result() below.
123 wdev->sme_state = CFG80211_SME_CONNECTING;
126 /* this consumes one bss reference (unless bss is NULL) */
127 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, ie, len - ieoffs,
129 status_code == WLAN_STATUS_SUCCESS,
130 bss ? &bss->pub : NULL);
131 /* drop hold now, and also reference acquired above */
133 cfg80211_unhold_bss(bss);
134 cfg80211_put_bss(&bss->pub);
140 EXPORT_SYMBOL(cfg80211_send_rx_assoc);
142 void __cfg80211_send_deauth(struct net_device *dev,
143 const u8 *buf, size_t len)
145 struct wireless_dev *wdev = dev->ieee80211_ptr;
146 struct wiphy *wiphy = wdev->wiphy;
147 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
148 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
149 const u8 *bssid = mgmt->bssid;
153 ASSERT_WDEV_LOCK(wdev);
155 if (wdev->current_bss &&
156 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
157 cfg80211_unhold_bss(wdev->current_bss);
158 cfg80211_put_bss(&wdev->current_bss->pub);
159 wdev->current_bss = NULL;
161 } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
162 if (wdev->auth_bsses[i] &&
163 memcmp(wdev->auth_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
164 cfg80211_unhold_bss(wdev->auth_bsses[i]);
165 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
166 wdev->auth_bsses[i] = NULL;
170 if (wdev->authtry_bsses[i] &&
171 memcmp(wdev->authtry_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
172 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
173 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
174 wdev->authtry_bsses[i] = NULL;
183 nl80211_send_deauth(rdev, dev, buf, len, GFP_KERNEL);
185 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
189 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
191 from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
192 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
193 } else if (wdev->sme_state == CFG80211_SME_CONNECTING) {
194 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,
195 WLAN_STATUS_UNSPECIFIED_FAILURE,
199 EXPORT_SYMBOL(__cfg80211_send_deauth);
201 void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len)
203 struct wireless_dev *wdev = dev->ieee80211_ptr;
206 __cfg80211_send_deauth(dev, buf, len);
209 EXPORT_SYMBOL(cfg80211_send_deauth);
211 void __cfg80211_send_disassoc(struct net_device *dev,
212 const u8 *buf, size_t len)
214 struct wireless_dev *wdev = dev->ieee80211_ptr;
215 struct wiphy *wiphy = wdev->wiphy;
216 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
217 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
218 const u8 *bssid = mgmt->bssid;
224 ASSERT_WDEV_LOCK(wdev);
226 nl80211_send_disassoc(rdev, dev, buf, len, GFP_KERNEL);
228 if (wdev->sme_state != CFG80211_SME_CONNECTED)
231 if (wdev->current_bss &&
232 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
233 for (i = 0; i < MAX_AUTH_BSSES; i++) {
234 if (wdev->authtry_bsses[i] || wdev->auth_bsses[i])
236 wdev->auth_bsses[i] = wdev->current_bss;
237 wdev->current_bss = NULL;
239 cfg80211_sme_disassoc(dev, i);
247 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
249 from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
250 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
252 EXPORT_SYMBOL(__cfg80211_send_disassoc);
254 void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len)
256 struct wireless_dev *wdev = dev->ieee80211_ptr;
259 __cfg80211_send_disassoc(dev, buf, len);
262 EXPORT_SYMBOL(cfg80211_send_disassoc);
264 static void __cfg80211_auth_remove(struct wireless_dev *wdev, const u8 *addr)
269 ASSERT_WDEV_LOCK(wdev);
271 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
272 if (wdev->authtry_bsses[i] &&
273 memcmp(wdev->authtry_bsses[i]->pub.bssid,
274 addr, ETH_ALEN) == 0) {
275 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
276 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
277 wdev->authtry_bsses[i] = NULL;
286 void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr)
288 __cfg80211_auth_remove(dev->ieee80211_ptr, addr);
290 EXPORT_SYMBOL(__cfg80211_auth_canceled);
292 void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr)
294 struct wireless_dev *wdev = dev->ieee80211_ptr;
295 struct wiphy *wiphy = wdev->wiphy;
296 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
300 nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
301 if (wdev->sme_state == CFG80211_SME_CONNECTING)
302 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
303 WLAN_STATUS_UNSPECIFIED_FAILURE,
306 __cfg80211_auth_remove(wdev, addr);
310 EXPORT_SYMBOL(cfg80211_send_auth_timeout);
312 void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr)
314 struct wireless_dev *wdev = dev->ieee80211_ptr;
315 struct wiphy *wiphy = wdev->wiphy;
316 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
322 nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);
323 if (wdev->sme_state == CFG80211_SME_CONNECTING)
324 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
325 WLAN_STATUS_UNSPECIFIED_FAILURE,
328 for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
329 if (wdev->auth_bsses[i] &&
330 memcmp(wdev->auth_bsses[i]->pub.bssid,
331 addr, ETH_ALEN) == 0) {
332 cfg80211_unhold_bss(wdev->auth_bsses[i]);
333 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
334 wdev->auth_bsses[i] = NULL;
344 EXPORT_SYMBOL(cfg80211_send_assoc_timeout);
346 void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
347 enum nl80211_key_type key_type, int key_id,
348 const u8 *tsc, gfp_t gfp)
350 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
351 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
352 #ifdef CONFIG_CFG80211_WEXT
353 union iwreq_data wrqu;
354 char *buf = kmalloc(128, gfp);
357 sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
358 "keyid=%d %scast addr=%pM)", key_id,
359 key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
361 memset(&wrqu, 0, sizeof(wrqu));
362 wrqu.data.length = strlen(buf);
363 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
368 nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
370 EXPORT_SYMBOL(cfg80211_michael_mic_failure);
372 /* some MLME handling for userspace SME */
373 int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
374 struct net_device *dev,
375 struct ieee80211_channel *chan,
376 enum nl80211_auth_type auth_type,
378 const u8 *ssid, int ssid_len,
379 const u8 *ie, int ie_len,
380 const u8 *key, int key_len, int key_idx,
381 bool local_state_change)
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;
388 ASSERT_WDEV_LOCK(wdev);
390 if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
391 if (!key || !key_len || key_idx < 0 || key_idx > 4)
394 if (wdev->current_bss &&
395 memcmp(bssid, wdev->current_bss->pub.bssid, ETH_ALEN) == 0)
398 for (i = 0; i < MAX_AUTH_BSSES; i++) {
399 if (wdev->authtry_bsses[i] &&
400 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid,
403 if (wdev->auth_bsses[i] &&
404 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid,
409 memset(&req, 0, sizeof(req));
411 req.local_state_change = local_state_change;
414 req.auth_type = auth_type;
415 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
416 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
418 req.key_len = key_len;
419 req.key_idx = key_idx;
423 bss = bss_from_pub(req.bss);
425 for (i = 0; i < MAX_AUTH_BSSES; i++) {
426 if (!wdev->auth_bsses[i] && !wdev->authtry_bsses[i]) {
432 /* we need one free slot for disassoc and one for this auth */
438 if (local_state_change)
439 wdev->auth_bsses[slot] = bss;
441 wdev->authtry_bsses[slot] = bss;
442 cfg80211_hold_bss(bss);
444 err = rdev->ops->auth(&rdev->wiphy, dev, &req);
446 if (local_state_change)
447 wdev->auth_bsses[slot] = NULL;
449 wdev->authtry_bsses[slot] = NULL;
450 cfg80211_unhold_bss(bss);
455 cfg80211_put_bss(req.bss);
459 int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
460 struct net_device *dev, struct ieee80211_channel *chan,
461 enum nl80211_auth_type auth_type, const u8 *bssid,
462 const u8 *ssid, int ssid_len,
463 const u8 *ie, int ie_len,
464 const u8 *key, int key_len, int key_idx,
465 bool local_state_change)
469 wdev_lock(dev->ieee80211_ptr);
470 err = __cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
471 ssid, ssid_len, ie, ie_len,
472 key, key_len, key_idx, local_state_change);
473 wdev_unlock(dev->ieee80211_ptr);
478 int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
479 struct net_device *dev,
480 struct ieee80211_channel *chan,
481 const u8 *bssid, const u8 *prev_bssid,
482 const u8 *ssid, int ssid_len,
483 const u8 *ie, int ie_len, bool use_mfp,
484 struct cfg80211_crypto_settings *crypt)
486 struct wireless_dev *wdev = dev->ieee80211_ptr;
487 struct cfg80211_assoc_request req;
488 struct cfg80211_internal_bss *bss;
489 int i, err, slot = -1;
490 bool was_connected = false;
492 ASSERT_WDEV_LOCK(wdev);
494 memset(&req, 0, sizeof(req));
496 if (wdev->current_bss && prev_bssid &&
497 memcmp(wdev->current_bss->pub.bssid, prev_bssid, ETH_ALEN) == 0) {
499 * Trying to reassociate: Allow this to proceed and let the old
500 * association to be dropped when the new one is completed.
502 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
503 was_connected = true;
504 wdev->sme_state = CFG80211_SME_CONNECTING;
506 } else if (wdev->current_bss)
511 memcpy(&req.crypto, crypt, sizeof(req.crypto));
512 req.use_mfp = use_mfp;
513 req.prev_bssid = prev_bssid;
514 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
515 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
518 wdev->sme_state = CFG80211_SME_CONNECTED;
522 bss = bss_from_pub(req.bss);
524 for (i = 0; i < MAX_AUTH_BSSES; i++) {
525 if (bss == wdev->auth_bsses[i]) {
536 err = rdev->ops->assoc(&rdev->wiphy, dev, &req);
538 if (err && was_connected)
539 wdev->sme_state = CFG80211_SME_CONNECTED;
540 /* still a reference in wdev->auth_bsses[slot] */
541 cfg80211_put_bss(req.bss);
545 int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
546 struct net_device *dev,
547 struct ieee80211_channel *chan,
548 const u8 *bssid, const u8 *prev_bssid,
549 const u8 *ssid, int ssid_len,
550 const u8 *ie, int ie_len, bool use_mfp,
551 struct cfg80211_crypto_settings *crypt)
553 struct wireless_dev *wdev = dev->ieee80211_ptr;
557 err = __cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
558 ssid, ssid_len, ie, ie_len, use_mfp, crypt);
564 int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
565 struct net_device *dev, const u8 *bssid,
566 const u8 *ie, int ie_len, u16 reason,
567 bool local_state_change)
569 struct wireless_dev *wdev = dev->ieee80211_ptr;
570 struct cfg80211_deauth_request req;
573 ASSERT_WDEV_LOCK(wdev);
575 memset(&req, 0, sizeof(req));
576 req.reason_code = reason;
577 req.local_state_change = local_state_change;
580 if (wdev->current_bss &&
581 memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
582 req.bss = &wdev->current_bss->pub;
583 } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
584 if (wdev->auth_bsses[i] &&
585 memcmp(bssid, wdev->auth_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
586 req.bss = &wdev->auth_bsses[i]->pub;
589 if (wdev->authtry_bsses[i] &&
590 memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
591 req.bss = &wdev->authtry_bsses[i]->pub;
599 return rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
602 int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
603 struct net_device *dev, const u8 *bssid,
604 const u8 *ie, int ie_len, u16 reason,
605 bool local_state_change)
607 struct wireless_dev *wdev = dev->ieee80211_ptr;
611 err = __cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason,
618 static int __cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
619 struct net_device *dev, const u8 *bssid,
620 const u8 *ie, int ie_len, u16 reason,
621 bool local_state_change)
623 struct wireless_dev *wdev = dev->ieee80211_ptr;
624 struct cfg80211_disassoc_request req;
626 ASSERT_WDEV_LOCK(wdev);
628 if (wdev->sme_state != CFG80211_SME_CONNECTED)
631 if (WARN_ON(!wdev->current_bss))
634 memset(&req, 0, sizeof(req));
635 req.reason_code = reason;
636 req.local_state_change = local_state_change;
639 if (memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0)
640 req.bss = &wdev->current_bss->pub;
644 return rdev->ops->disassoc(&rdev->wiphy, dev, &req, wdev);
647 int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
648 struct net_device *dev, const u8 *bssid,
649 const u8 *ie, int ie_len, u16 reason,
650 bool local_state_change)
652 struct wireless_dev *wdev = dev->ieee80211_ptr;
656 err = __cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason,
663 void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
664 struct net_device *dev)
666 struct wireless_dev *wdev = dev->ieee80211_ptr;
667 struct cfg80211_deauth_request req;
670 ASSERT_WDEV_LOCK(wdev);
672 if (!rdev->ops->deauth)
675 memset(&req, 0, sizeof(req));
676 req.reason_code = WLAN_REASON_DEAUTH_LEAVING;
680 if (wdev->current_bss) {
681 req.bss = &wdev->current_bss->pub;
682 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
683 if (wdev->current_bss) {
684 cfg80211_unhold_bss(wdev->current_bss);
685 cfg80211_put_bss(&wdev->current_bss->pub);
686 wdev->current_bss = NULL;
690 for (i = 0; i < MAX_AUTH_BSSES; i++) {
691 if (wdev->auth_bsses[i]) {
692 req.bss = &wdev->auth_bsses[i]->pub;
693 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
694 if (wdev->auth_bsses[i]) {
695 cfg80211_unhold_bss(wdev->auth_bsses[i]);
696 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
697 wdev->auth_bsses[i] = NULL;
700 if (wdev->authtry_bsses[i]) {
701 req.bss = &wdev->authtry_bsses[i]->pub;
702 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
703 if (wdev->authtry_bsses[i]) {
704 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
705 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
706 wdev->authtry_bsses[i] = NULL;
712 void cfg80211_ready_on_channel(struct net_device *dev, u64 cookie,
713 struct ieee80211_channel *chan,
714 enum nl80211_channel_type channel_type,
715 unsigned int duration, gfp_t gfp)
717 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
718 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
720 nl80211_send_remain_on_channel(rdev, dev, cookie, chan, channel_type,
723 EXPORT_SYMBOL(cfg80211_ready_on_channel);
725 void cfg80211_remain_on_channel_expired(struct net_device *dev,
727 struct ieee80211_channel *chan,
728 enum nl80211_channel_type channel_type,
731 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
732 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
734 nl80211_send_remain_on_channel_cancel(rdev, dev, cookie, chan,
737 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
739 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
740 struct station_info *sinfo, gfp_t gfp)
742 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
743 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
745 nl80211_send_sta_event(rdev, dev, mac_addr, sinfo, gfp);
747 EXPORT_SYMBOL(cfg80211_new_sta);
749 struct cfg80211_action_registration {
750 struct list_head list;
759 int cfg80211_mlme_register_action(struct wireless_dev *wdev, u32 snd_pid,
760 const u8 *match_data, int match_len)
762 struct cfg80211_action_registration *reg, *nreg;
765 nreg = kzalloc(sizeof(*reg) + match_len, GFP_KERNEL);
769 spin_lock_bh(&wdev->action_registrations_lock);
771 list_for_each_entry(reg, &wdev->action_registrations, list) {
772 int mlen = min(match_len, reg->match_len);
774 if (memcmp(reg->match, match_data, mlen) == 0) {
785 memcpy(nreg->match, match_data, match_len);
786 nreg->match_len = match_len;
787 nreg->nlpid = snd_pid;
788 list_add(&nreg->list, &wdev->action_registrations);
791 spin_unlock_bh(&wdev->action_registrations_lock);
795 void cfg80211_mlme_unregister_actions(struct wireless_dev *wdev, u32 nlpid)
797 struct cfg80211_action_registration *reg, *tmp;
799 spin_lock_bh(&wdev->action_registrations_lock);
801 list_for_each_entry_safe(reg, tmp, &wdev->action_registrations, list) {
802 if (reg->nlpid == nlpid) {
803 list_del(®->list);
808 spin_unlock_bh(&wdev->action_registrations_lock);
811 void cfg80211_mlme_purge_actions(struct wireless_dev *wdev)
813 struct cfg80211_action_registration *reg, *tmp;
815 spin_lock_bh(&wdev->action_registrations_lock);
817 list_for_each_entry_safe(reg, tmp, &wdev->action_registrations, list) {
818 list_del(®->list);
822 spin_unlock_bh(&wdev->action_registrations_lock);
825 int cfg80211_mlme_action(struct cfg80211_registered_device *rdev,
826 struct net_device *dev,
827 struct ieee80211_channel *chan,
828 enum nl80211_channel_type channel_type,
829 const u8 *buf, size_t len, u64 *cookie)
831 struct wireless_dev *wdev = dev->ieee80211_ptr;
832 const struct ieee80211_mgmt *mgmt;
834 if (rdev->ops->action == NULL)
839 mgmt = (const struct ieee80211_mgmt *) buf;
840 if (!ieee80211_is_action(mgmt->frame_control))
842 if (mgmt->u.action.category != WLAN_CATEGORY_PUBLIC) {
843 /* Verify that we are associated with the destination AP */
844 if (!wdev->current_bss ||
845 memcmp(wdev->current_bss->pub.bssid, mgmt->bssid,
847 memcmp(wdev->current_bss->pub.bssid, mgmt->da,
852 if (memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0)
855 /* Transmit the Action frame as requested by user space */
856 return rdev->ops->action(&rdev->wiphy, dev, chan, channel_type,
860 bool cfg80211_rx_action(struct net_device *dev, int freq, const u8 *buf,
861 size_t len, gfp_t gfp)
863 struct wireless_dev *wdev = dev->ieee80211_ptr;
864 struct wiphy *wiphy = wdev->wiphy;
865 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
866 struct cfg80211_action_registration *reg;
867 const u8 *action_data;
871 /* frame length - min size excluding category */
872 action_data_len = len - (IEEE80211_MIN_ACTION_SIZE - 1);
874 /* action data starts with category */
875 action_data = buf + IEEE80211_MIN_ACTION_SIZE - 1;
877 spin_lock_bh(&wdev->action_registrations_lock);
879 list_for_each_entry(reg, &wdev->action_registrations, list) {
880 if (reg->match_len > action_data_len)
883 if (memcmp(reg->match, action_data, reg->match_len))
888 /* Indicate the received Action frame to user space */
889 if (nl80211_send_action(rdev, dev, reg->nlpid, freq,
897 spin_unlock_bh(&wdev->action_registrations_lock);
901 EXPORT_SYMBOL(cfg80211_rx_action);
903 void cfg80211_action_tx_status(struct net_device *dev, u64 cookie,
904 const u8 *buf, size_t len, bool ack, gfp_t gfp)
906 struct wireless_dev *wdev = dev->ieee80211_ptr;
907 struct wiphy *wiphy = wdev->wiphy;
908 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
910 /* Indicate TX status of the Action frame to user space */
911 nl80211_send_action_tx_status(rdev, dev, cookie, buf, len, ack, gfp);
913 EXPORT_SYMBOL(cfg80211_action_tx_status);
915 void cfg80211_cqm_rssi_notify(struct net_device *dev,
916 enum nl80211_cqm_rssi_threshold_event rssi_event,
919 struct wireless_dev *wdev = dev->ieee80211_ptr;
920 struct wiphy *wiphy = wdev->wiphy;
921 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
923 /* Indicate roaming trigger event to user space */
924 nl80211_send_cqm_rssi_notify(rdev, dev, rssi_event, gfp);
926 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);