projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cfg80211: always get BSS
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / wireless / sme.c
CommitLineData
b23aa676
SO		 1/*
2 * SME code for cfg80211's connect emulation.
3 *
4 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright (C) 2009 Intel Corporation. All rights reserved.
6 */
7
8#include <linux/etherdevice.h>
9#include <linux/if_arp.h>
10#include <linux/workqueue.h>
a9a11622
JB		 11#include <linux/wireless.h>
12#include <net/iw_handler.h>
b23aa676
SO		 13#include <net/cfg80211.h>
14#include <net/rtnetlink.h>
15#include "nl80211.h"
8b19e6ca 16#include "reg.h"
b23aa676 17
6829c878
JB		 18struct cfg80211_conn {
19 struct cfg80211_connect_params params;
20 /* these are sub-states of the _CONNECTING sme_state */
21 enum {
22 CFG80211_CONN_IDLE,
23 CFG80211_CONN_SCANNING,
24 CFG80211_CONN_SCAN_AGAIN,
25 CFG80211_CONN_AUTHENTICATE_NEXT,
26 CFG80211_CONN_AUTHENTICATING,
27 CFG80211_CONN_ASSOCIATE_NEXT,
28 CFG80211_CONN_ASSOCIATING,
29 } state;
f401a6f7 30 u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
6829c878
JB		 31 u8 *ie;
32 size_t ie_len;
f401a6f7 33 bool auto_auth, prev_bssid_valid;
6829c878
JB		 34};
35
36
37static int cfg80211_conn_scan(struct wireless_dev *wdev)
38{
79c97e97 39 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
6829c878
JB		 40 struct cfg80211_scan_request *request;
41 int n_channels, err;
42
43 ASSERT_RTNL();
79c97e97 44 ASSERT_RDEV_LOCK(rdev);
667503dd 45 ASSERT_WDEV_LOCK(wdev);
6829c878 46
79c97e97 47 if (rdev->scan_req)
6829c878
JB		 48 return -EBUSY;
49
50 if (wdev->conn->params.channel) {
51 n_channels = 1;
52 } else {
53 enum ieee80211_band band;
54 n_channels = 0;
55
56 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
57 if (!wdev->wiphy->bands[band])
58 continue;
59 n_channels += wdev->wiphy->bands[band]->n_channels;
60 }
61 }
62 request = kzalloc(sizeof(*request) + sizeof(request->ssids[0]) +
63 sizeof(request->channels[0]) * n_channels,
64 GFP_KERNEL);
65 if (!request)
66 return -ENOMEM;
67
6829c878
JB		 68 if (wdev->conn->params.channel)
69 request->channels[0] = wdev->conn->params.channel;
70 else {
71 int i = 0, j;
72 enum ieee80211_band band;
73
74 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
75 if (!wdev->wiphy->bands[band])
76 continue;
77 for (j = 0; j < wdev->wiphy->bands[band]->n_channels;
78 i++, j++)
79 request->channels[i] =
80 &wdev->wiphy->bands[band]->channels[j];
81 }
82 }
83 request->n_channels = n_channels;
5ba63533 84 request->ssids = (void *)&request->channels[n_channels];
6829c878
JB		 85 request->n_ssids = 1;
86
87 memcpy(request->ssids[0].ssid, wdev->conn->params.ssid,
88 wdev->conn->params.ssid_len);
89 request->ssids[0].ssid_len = wdev->conn->params.ssid_len;
90
463d0183 91 request->dev = wdev->netdev;
79c97e97 92 request->wiphy = &rdev->wiphy;
6829c878 93
79c97e97 94 rdev->scan_req = request;
6829c878 95
79c97e97 96 err = rdev->ops->scan(wdev->wiphy, wdev->netdev, request);
6829c878
JB		 97 if (!err) {
98 wdev->conn->state = CFG80211_CONN_SCANNING;
79c97e97 99 nl80211_send_scan_start(rdev, wdev->netdev);
463d0183 100 dev_hold(wdev->netdev);
6829c878 101 } else {
79c97e97 102 rdev->scan_req = NULL;
6829c878
JB		 103 kfree(request);
104 }
105 return err;
106}
107
108static int cfg80211_conn_do_work(struct wireless_dev *wdev)
109{
79c97e97 110 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
19957bb3 111 struct cfg80211_connect_params *params;
f401a6f7 112 const u8 *prev_bssid = NULL;
19957bb3 113 int err;
6829c878 114
667503dd
JB		 115 ASSERT_WDEV_LOCK(wdev);
116
6829c878
JB		 117 if (!wdev->conn)
118 return 0;
119
19957bb3
JB		 120 params = &wdev->conn->params;
121
6829c878
JB		 122 switch (wdev->conn->state) {
123 case CFG80211_CONN_SCAN_AGAIN:
124 return cfg80211_conn_scan(wdev);
125 case CFG80211_CONN_AUTHENTICATE_NEXT:
79c97e97 126 BUG_ON(!rdev->ops->auth);
19957bb3 127 wdev->conn->state = CFG80211_CONN_AUTHENTICATING;
79c97e97 128 return __cfg80211_mlme_auth(rdev, wdev->netdev,
667503dd
JB		 129 params->channel, params->auth_type,
130 params->bssid,
131 params->ssid, params->ssid_len,
fffd0934
JB		 132 NULL, 0,
133 params->key, params->key_len,
134 params->key_idx);
6829c878 135 case CFG80211_CONN_ASSOCIATE_NEXT:
79c97e97 136 BUG_ON(!rdev->ops->assoc);
19957bb3 137 wdev->conn->state = CFG80211_CONN_ASSOCIATING;
f401a6f7
JB		 138 if (wdev->conn->prev_bssid_valid)
139 prev_bssid = wdev->conn->prev_bssid;
79c97e97 140 err = __cfg80211_mlme_assoc(rdev, wdev->netdev,
667503dd 141 params->channel, params->bssid,
f401a6f7 142 prev_bssid,
667503dd
JB		 143 params->ssid, params->ssid_len,
144 params->ie, params->ie_len,
145 false, &params->crypto);
19957bb3 146 if (err)
79c97e97 147 __cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
667503dd
JB		 148 NULL, 0,
149 WLAN_REASON_DEAUTH_LEAVING);
19957bb3 150 return err;
6829c878
JB		 151 default:
152 return 0;
153 }
154}
155
156void cfg80211_conn_work(struct work_struct *work)
157{
79c97e97 158 struct cfg80211_registered_device *rdev =
6829c878
JB		 159 container_of(work, struct cfg80211_registered_device, conn_work);
160 struct wireless_dev *wdev;
161
162 rtnl_lock();
79c97e97
JB		 163 cfg80211_lock_rdev(rdev);
164 mutex_lock(&rdev->devlist_mtx);
6829c878 165
79c97e97 166 list_for_each_entry(wdev, &rdev->netdev_list, list) {
667503dd
JB		 167 wdev_lock(wdev);
168 if (!netif_running(wdev->netdev)) {
169 wdev_unlock(wdev);
6829c878 170 continue;
667503dd
JB		 171 }
172 if (wdev->sme_state != CFG80211_SME_CONNECTING) {
173 wdev_unlock(wdev);
6829c878 174 continue;
667503dd 175 }
6829c878 176 if (cfg80211_conn_do_work(wdev))
667503dd
JB		 177 __cfg80211_connect_result(
178 wdev->netdev,
179 wdev->conn->params.bssid,
180 NULL, 0, NULL, 0,
181 WLAN_STATUS_UNSPECIFIED_FAILURE,
df7fc0f9 182 false, NULL);
667503dd 183 wdev_unlock(wdev);
6829c878
JB		 184 }
185
79c97e97
JB		 186 mutex_unlock(&rdev->devlist_mtx);
187 cfg80211_unlock_rdev(rdev);
6829c878
JB		 188 rtnl_unlock();
189}
190
bbac31f4 191static struct cfg80211_bss *cfg80211_get_conn_bss(struct wireless_dev *wdev)
6829c878 192{
79c97e97 193 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
6829c878
JB		 194 struct cfg80211_bss *bss;
195 u16 capa = WLAN_CAPABILITY_ESS;
196
667503dd
JB		 197 ASSERT_WDEV_LOCK(wdev);
198
6829c878
JB		 199 if (wdev->conn->params.privacy)
200 capa |= WLAN_CAPABILITY_PRIVACY;
201
202 bss = cfg80211_get_bss(wdev->wiphy, NULL, wdev->conn->params.bssid,
203 wdev->conn->params.ssid,
204 wdev->conn->params.ssid_len,
205 WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_PRIVACY,
206 capa);
6829c878 207 if (!bss)
bbac31f4 208 return NULL;
6829c878
JB		 209
210 memcpy(wdev->conn->bssid, bss->bssid, ETH_ALEN);
211 wdev->conn->params.bssid = wdev->conn->bssid;
212 wdev->conn->params.channel = bss->channel;
213 wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
79c97e97 214 schedule_work(&rdev->conn_work);
6829c878 215
bbac31f4 216 return bss;
6829c878
JB		 217}
218
667503dd 219static void __cfg80211_sme_scan_done(struct net_device *dev)
6829c878
JB		 220{
221 struct wireless_dev *wdev = dev->ieee80211_ptr;
79c97e97 222 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
bbac31f4 223 struct cfg80211_bss *bss;
6829c878 224
667503dd
JB		 225 ASSERT_WDEV_LOCK(wdev);
226
6829c878
JB		 227 if (wdev->sme_state != CFG80211_SME_CONNECTING)
228 return;
229
d4b1a687 230 if (!wdev->conn)
6829c878
JB		 231 return;
232
233 if (wdev->conn->state != CFG80211_CONN_SCANNING &&
234 wdev->conn->state != CFG80211_CONN_SCAN_AGAIN)
235 return;
236
bbac31f4
JB		 237 bss = cfg80211_get_conn_bss(wdev);
238 if (bss) {
239 cfg80211_put_bss(bss);
240 } else {
6829c878
JB		 241 /* not found */
242 if (wdev->conn->state == CFG80211_CONN_SCAN_AGAIN)
79c97e97 243 schedule_work(&rdev->conn_work);
6829c878 244 else
667503dd
JB		 245 __cfg80211_connect_result(
246 wdev->netdev,
247 wdev->conn->params.bssid,
248 NULL, 0, NULL, 0,
249 WLAN_STATUS_UNSPECIFIED_FAILURE,
df7fc0f9 250 false, NULL);
6829c878
JB		 251 }
252}
253
667503dd
JB		 254void cfg80211_sme_scan_done(struct net_device *dev)
255{
256 struct wireless_dev *wdev = dev->ieee80211_ptr;
257
59bbb6f7 258 mutex_lock(&wiphy_to_dev(wdev->wiphy)->devlist_mtx);
667503dd
JB		 259 wdev_lock(wdev);
260 __cfg80211_sme_scan_done(dev);
261 wdev_unlock(wdev);
59bbb6f7 262 mutex_unlock(&wiphy_to_dev(wdev->wiphy)->devlist_mtx);
667503dd
JB		 263}
264
265void cfg80211_sme_rx_auth(struct net_device *dev,
266 const u8 *buf, size_t len)
6829c878
JB		 267{
268 struct wireless_dev *wdev = dev->ieee80211_ptr;
269 struct wiphy *wiphy = wdev->wiphy;
270 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
271 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
272 u16 status_code = le16_to_cpu(mgmt->u.auth.status_code);
273
667503dd
JB		 274 ASSERT_WDEV_LOCK(wdev);
275
6829c878
JB		 276 /* should only RX auth frames when connecting */
277 if (wdev->sme_state != CFG80211_SME_CONNECTING)
278 return;
279
280 if (WARN_ON(!wdev->conn))
281 return;
282
283 if (status_code == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG &&
284 wdev->conn->auto_auth &&
285 wdev->conn->params.auth_type != NL80211_AUTHTYPE_NETWORK_EAP) {
286 /* select automatically between only open, shared, leap */
287 switch (wdev->conn->params.auth_type) {
288 case NL80211_AUTHTYPE_OPEN_SYSTEM:
fffd0934
JB		 289 if (wdev->connect_keys)
290 wdev->conn->params.auth_type =
291 NL80211_AUTHTYPE_SHARED_KEY;
292 else
293 wdev->conn->params.auth_type =
294 NL80211_AUTHTYPE_NETWORK_EAP;
6829c878
JB		 295 break;
296 case NL80211_AUTHTYPE_SHARED_KEY:
297 wdev->conn->params.auth_type =
298 NL80211_AUTHTYPE_NETWORK_EAP;
299 break;
300 default:
301 /* huh? */
302 wdev->conn->params.auth_type =
303 NL80211_AUTHTYPE_OPEN_SYSTEM;
304 break;
305 }
306 wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
307 schedule_work(&rdev->conn_work);
19957bb3 308 } else if (status_code != WLAN_STATUS_SUCCESS) {
4bde0f7d 309 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,
df7fc0f9 310 status_code, false, NULL);
19957bb3 311 } else if (wdev->sme_state == CFG80211_SME_CONNECTING &&
6829c878
JB		 312 wdev->conn->state == CFG80211_CONN_AUTHENTICATING) {
313 wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
314 schedule_work(&rdev->conn_work);
315 }
316}
b23aa676 317
f401a6f7
JB		 318bool cfg80211_sme_failed_reassoc(struct wireless_dev *wdev)
319{
320 struct wiphy *wiphy = wdev->wiphy;
321 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
322
323 if (WARN_ON(!wdev->conn))
324 return false;
325
326 if (!wdev->conn->prev_bssid_valid)
327 return false;
328
329 /*
330 * Some stupid APs don't accept reassoc, so we
331 * need to fall back to trying regular assoc.
332 */
333 wdev->conn->prev_bssid_valid = false;
334 wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
335 schedule_work(&rdev->conn_work);
336
337 return true;
338}
339
667503dd
JB		 340void __cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
341 const u8 *req_ie, size_t req_ie_len,
342 const u8 *resp_ie, size_t resp_ie_len,
df7fc0f9
JB		 343 u16 status, bool wextev,
344 struct cfg80211_bss *bss)
b23aa676
SO		 345{
346 struct wireless_dev *wdev = dev->ieee80211_ptr;
8b19e6ca 347 u8 *country_ie;
b23aa676
SO		 348#ifdef CONFIG_WIRELESS_EXT
349 union iwreq_data wrqu;
350#endif
351
667503dd
JB		 352 ASSERT_WDEV_LOCK(wdev);
353
b23aa676
SO		 354 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
355 return;
356
f7969969 357 if (wdev->sme_state != CFG80211_SME_CONNECTING)
ea416a79
JB		 358 return;
359
360 nl80211_send_connect_result(wiphy_to_dev(wdev->wiphy), dev,
e45cd82a 361 bssid, req_ie, req_ie_len,
ea416a79
JB		 362 resp_ie, resp_ie_len,
363 status, GFP_KERNEL);
e45cd82a
JB		 364
365#ifdef CONFIG_WIRELESS_EXT
366 if (wextev) {
367 if (req_ie && status == WLAN_STATUS_SUCCESS) {
368 memset(&wrqu, 0, sizeof(wrqu));
369 wrqu.data.length = req_ie_len;
3409ff77 370 wireless_send_event(dev, IWEVASSOCREQIE, &wrqu, req_ie);
e45cd82a
JB		 371 }
372
373 if (resp_ie && status == WLAN_STATUS_SUCCESS) {
374 memset(&wrqu, 0, sizeof(wrqu));
375 wrqu.data.length = resp_ie_len;
376 wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, resp_ie);
377 }
378
379 memset(&wrqu, 0, sizeof(wrqu));
380 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
f401a6f7 381 if (bssid && status == WLAN_STATUS_SUCCESS) {
e45cd82a 382 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
f401a6f7
JB		 383 memcpy(wdev->wext.prev_bssid, bssid, ETH_ALEN);
384 wdev->wext.prev_bssid_valid = true;
385 }
e45cd82a
JB		 386 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
387 }
388#endif
389
df7fc0f9
JB		 390 if (wdev->current_bss) {
391 cfg80211_unhold_bss(wdev->current_bss);
392 cfg80211_put_bss(&wdev->current_bss->pub);
393 wdev->current_bss = NULL;
394 }
395
19957bb3
JB		 396 if (wdev->conn)
397 wdev->conn->state = CFG80211_CONN_IDLE;
398
fffd0934 399 if (status != WLAN_STATUS_SUCCESS) {
b23aa676 400 wdev->sme_state = CFG80211_SME_IDLE;
415ad1ef
DK		 401 if (wdev->conn)
402 kfree(wdev->conn->ie);
19957bb3
JB		 403 kfree(wdev->conn);
404 wdev->conn = NULL;
fffd0934
JB		 405 kfree(wdev->connect_keys);
406 wdev->connect_keys = NULL;
8dadadb7 407 wdev->ssid_len = 0;
fffd0934 408 return;
b23aa676 409 }
fffd0934 410
df7fc0f9
JB		 411 if (!bss)
412 bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
413 wdev->ssid, wdev->ssid_len,
414 WLAN_CAPABILITY_ESS,
415 WLAN_CAPABILITY_ESS);
fffd0934
JB		 416
417 if (WARN_ON(!bss))
418 return;
419
420 cfg80211_hold_bss(bss_from_pub(bss));
421 wdev->current_bss = bss_from_pub(bss);
422
fffd0934
JB		 423 wdev->sme_state = CFG80211_SME_CONNECTED;
424 cfg80211_upload_connect_keys(wdev);
8b19e6ca
LR		 425
426 country_ie = (u8 *) ieee80211_bss_get_ie(bss, WLAN_EID_COUNTRY);
427
428 if (!country_ie)
429 return;
430
431 /*
432 * ieee80211_bss_get_ie() ensures we can access:
433 * - country_ie + 2, the start of the country ie data, and
434 * - and country_ie[1] which is the IE length
435 */
436 regulatory_hint_11d(wdev->wiphy,
437 country_ie + 2,
438 country_ie[1]);
b23aa676 439}
f2129354
JB		 440
441void cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
442 const u8 *req_ie, size_t req_ie_len,
443 const u8 *resp_ie, size_t resp_ie_len,
444 u16 status, gfp_t gfp)
445{
667503dd
JB		 446 struct wireless_dev *wdev = dev->ieee80211_ptr;
447 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
448 struct cfg80211_event *ev;
449 unsigned long flags;
450
f7969969
JB		 451 CFG80211_DEV_WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTING);
452
667503dd
JB		 453 ev = kzalloc(sizeof(*ev) + req_ie_len + resp_ie_len, gfp);
454 if (!ev)
455 return;
456
457 ev->type = EVENT_CONNECT_RESULT;
16a832e7
ZY		 458 if (bssid)
459 memcpy(ev->cr.bssid, bssid, ETH_ALEN);
667503dd
JB		 460 ev->cr.req_ie = ((u8 *)ev) + sizeof(*ev);
461 ev->cr.req_ie_len = req_ie_len;
462 memcpy((void *)ev->cr.req_ie, req_ie, req_ie_len);
463 ev->cr.resp_ie = ((u8 *)ev) + sizeof(*ev) + req_ie_len;
464 ev->cr.resp_ie_len = resp_ie_len;
465 memcpy((void *)ev->cr.resp_ie, resp_ie, resp_ie_len);
466 ev->cr.status = status;
467
468 spin_lock_irqsave(&wdev->event_lock, flags);
469 list_add_tail(&ev->list, &wdev->event_list);
470 spin_unlock_irqrestore(&wdev->event_lock, flags);
471 schedule_work(&rdev->event_work);
f2129354 472}
b23aa676
SO		 473EXPORT_SYMBOL(cfg80211_connect_result);
474
667503dd
JB		 475void __cfg80211_roamed(struct wireless_dev *wdev, const u8 *bssid,
476 const u8 *req_ie, size_t req_ie_len,
477 const u8 *resp_ie, size_t resp_ie_len)
b23aa676 478{
b23aa676
SO		 479 struct cfg80211_bss *bss;
480#ifdef CONFIG_WIRELESS_EXT
481 union iwreq_data wrqu;
482#endif
483
667503dd
JB		 484 ASSERT_WDEV_LOCK(wdev);
485
b23aa676
SO		 486 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
487 return;
488
f7969969 489 if (wdev->sme_state != CFG80211_SME_CONNECTED)
b23aa676
SO		 490 return;
491
492 /* internal error -- how did we get to CONNECTED w/o BSS? */
493 if (WARN_ON(!wdev->current_bss)) {
494 return;
495 }
496
497 cfg80211_unhold_bss(wdev->current_bss);
19957bb3 498 cfg80211_put_bss(&wdev->current_bss->pub);
b23aa676
SO		 499 wdev->current_bss = NULL;
500
501 bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
502 wdev->ssid, wdev->ssid_len,
503 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
504
505 if (WARN_ON(!bss))
506 return;
507
19957bb3
JB		 508 cfg80211_hold_bss(bss_from_pub(bss));
509 wdev->current_bss = bss_from_pub(bss);
b23aa676 510
667503dd
JB		 511 nl80211_send_roamed(wiphy_to_dev(wdev->wiphy), wdev->netdev, bssid,
512 req_ie, req_ie_len, resp_ie, resp_ie_len,
513 GFP_KERNEL);
b23aa676
SO		 514
515#ifdef CONFIG_WIRELESS_EXT
516 if (req_ie) {
517 memset(&wrqu, 0, sizeof(wrqu));
518 wrqu.data.length = req_ie_len;
3409ff77 519 wireless_send_event(wdev->netdev, IWEVASSOCREQIE,
667503dd 520 &wrqu, req_ie);
b23aa676
SO		 521 }
522
523 if (resp_ie) {
524 memset(&wrqu, 0, sizeof(wrqu));
525 wrqu.data.length = resp_ie_len;
667503dd
JB		 526 wireless_send_event(wdev->netdev, IWEVASSOCRESPIE,
527 &wrqu, resp_ie);
b23aa676
SO		 528 }
529
530 memset(&wrqu, 0, sizeof(wrqu));
531 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
532 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
f401a6f7
JB		 533 memcpy(wdev->wext.prev_bssid, bssid, ETH_ALEN);
534 wdev->wext.prev_bssid_valid = true;
667503dd 535 wireless_send_event(wdev->netdev, SIOCGIWAP, &wrqu, NULL);
b23aa676
SO		 536#endif
537}
667503dd
JB		 538
539void cfg80211_roamed(struct net_device *dev, const u8 *bssid,
540 const u8 *req_ie, size_t req_ie_len,
541 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
542{
543 struct wireless_dev *wdev = dev->ieee80211_ptr;
544 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
545 struct cfg80211_event *ev;
546 unsigned long flags;
547
f7969969
JB		 548 CFG80211_DEV_WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED);
549
667503dd
JB		 550 ev = kzalloc(sizeof(*ev) + req_ie_len + resp_ie_len, gfp);
551 if (!ev)
552 return;
553
554 ev->type = EVENT_ROAMED;
555 memcpy(ev->rm.bssid, bssid, ETH_ALEN);
556 ev->rm.req_ie = ((u8 *)ev) + sizeof(*ev);
557 ev->rm.req_ie_len = req_ie_len;
558 memcpy((void *)ev->rm.req_ie, req_ie, req_ie_len);
559 ev->rm.resp_ie = ((u8 *)ev) + sizeof(*ev) + req_ie_len;
560 ev->rm.resp_ie_len = resp_ie_len;
561 memcpy((void *)ev->rm.resp_ie, resp_ie, resp_ie_len);
562
563 spin_lock_irqsave(&wdev->event_lock, flags);
564 list_add_tail(&ev->list, &wdev->event_list);
565 spin_unlock_irqrestore(&wdev->event_lock, flags);
566 schedule_work(&rdev->event_work);
567}
b23aa676
SO		 568EXPORT_SYMBOL(cfg80211_roamed);
569
667503dd 570void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
6829c878 571 size_t ie_len, u16 reason, bool from_ap)
b23aa676
SO		 572{
573 struct wireless_dev *wdev = dev->ieee80211_ptr;
fffd0934
JB		 574 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
575 int i;
b23aa676
SO		 576#ifdef CONFIG_WIRELESS_EXT
577 union iwreq_data wrqu;
578#endif
579
667503dd
JB		 580 ASSERT_WDEV_LOCK(wdev);
581
b23aa676
SO		 582 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
583 return;
584
f7969969 585 if (wdev->sme_state != CFG80211_SME_CONNECTED)
b23aa676
SO		 586 return;
587
588 if (wdev->current_bss) {
589 cfg80211_unhold_bss(wdev->current_bss);
19957bb3 590 cfg80211_put_bss(&wdev->current_bss->pub);
b23aa676
SO		 591 }
592
593 wdev->current_bss = NULL;
594 wdev->sme_state = CFG80211_SME_IDLE;
8dadadb7 595 wdev->ssid_len = 0;
b23aa676 596
6829c878 597 if (wdev->conn) {
b6f0b639
JB		 598 const u8 *bssid;
599 int ret;
600
6829c878
JB		 601 kfree(wdev->conn->ie);
602 wdev->conn->ie = NULL;
19957bb3
JB		 603 kfree(wdev->conn);
604 wdev->conn = NULL;
b6f0b639
JB		 605
606 /*
607 * If this disconnect was due to a disassoc, we
608 * we might still have an auth BSS around. For
609 * the userspace SME that's currently expected,
610 * but for the kernel SME (nl80211 CONNECT or
611 * wireless extensions) we want to clear up all
612 * state.
613 */
614 for (i = 0; i < MAX_AUTH_BSSES; i++) {
615 if (!wdev->auth_bsses[i])
616 continue;
617 bssid = wdev->auth_bsses[i]->pub.bssid;
618 ret = __cfg80211_mlme_deauth(rdev, dev, bssid, NULL, 0,
619 WLAN_REASON_DEAUTH_LEAVING);
620 WARN(ret, "deauth failed: %d\n", ret);
621 }
6829c878
JB		 622 }
623
fffd0934
JB		 624 nl80211_send_disconnected(rdev, dev, reason, ie, ie_len, from_ap);
625
626 /*
627 * Delete all the keys ... pairwise keys can't really
628 * exist any more anyway, but default keys might.
629 */
630 if (rdev->ops->del_key)
631 for (i = 0; i < 6; i++)
632 rdev->ops->del_key(wdev->wiphy, dev, i, NULL);
b23aa676
SO		 633
634#ifdef CONFIG_WIRELESS_EXT
635 memset(&wrqu, 0, sizeof(wrqu));
636 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
637 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
638#endif
639}
640
641void cfg80211_disconnected(struct net_device *dev, u16 reason,
642 u8 *ie, size_t ie_len, gfp_t gfp)
643{
667503dd
JB		 644 struct wireless_dev *wdev = dev->ieee80211_ptr;
645 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
646 struct cfg80211_event *ev;
647 unsigned long flags;
648
f7969969
JB		 649 CFG80211_DEV_WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED);
650
667503dd
JB		 651 ev = kzalloc(sizeof(*ev) + ie_len, gfp);
652 if (!ev)
653 return;
654
655 ev->type = EVENT_DISCONNECTED;
656 ev->dc.ie = ((u8 *)ev) + sizeof(*ev);
657 ev->dc.ie_len = ie_len;
658 memcpy((void *)ev->dc.ie, ie, ie_len);
659 ev->dc.reason = reason;
660
661 spin_lock_irqsave(&wdev->event_lock, flags);
662 list_add_tail(&ev->list, &wdev->event_list);
663 spin_unlock_irqrestore(&wdev->event_lock, flags);
664 schedule_work(&rdev->event_work);
b23aa676
SO		 665}
666EXPORT_SYMBOL(cfg80211_disconnected);
667
667503dd
JB		 668int __cfg80211_connect(struct cfg80211_registered_device *rdev,
669 struct net_device *dev,
fffd0934 670 struct cfg80211_connect_params *connect,
f401a6f7
JB		 671 struct cfg80211_cached_keys *connkeys,
672 const u8 *prev_bssid)
b23aa676 673{
b23aa676 674 struct wireless_dev *wdev = dev->ieee80211_ptr;
59bbb6f7 675 struct ieee80211_channel *chan;
bbac31f4 676 struct cfg80211_bss *bss = NULL;
667503dd
JB		 677 int err;
678
679 ASSERT_WDEV_LOCK(wdev);
b23aa676
SO		 680
681 if (wdev->sme_state != CFG80211_SME_IDLE)
682 return -EALREADY;
683
59bbb6f7
JB		 684 chan = rdev_fixed_channel(rdev, wdev);
685 if (chan && chan != connect->channel)
686 return -EBUSY;
687
fffd0934
JB		 688 if (WARN_ON(wdev->connect_keys)) {
689 kfree(wdev->connect_keys);
690 wdev->connect_keys = NULL;
691 }
692
693 if (connkeys && connkeys->def >= 0) {
694 int idx;
bcba8eae 695 u32 cipher;
fffd0934
JB		 696
697 idx = connkeys->def;
bcba8eae 698 cipher = connkeys->params[idx].cipher;
fffd0934 699 /* If given a WEP key we may need it for shared key auth */
bcba8eae
SO		 700 if (cipher == WLAN_CIPHER_SUITE_WEP40 ||
701 cipher == WLAN_CIPHER_SUITE_WEP104) {
fffd0934
JB		 702 connect->key_idx = idx;
703 connect->key = connkeys->params[idx].key;
704 connect->key_len = connkeys->params[idx].key_len;
bcba8eae
SO		 705
706 /*
707 * If ciphers are not set (e.g. when going through
708 * iwconfig), we have to set them appropriately here.
709 */
710 if (connect->crypto.cipher_group == 0)
711 connect->crypto.cipher_group = cipher;
712
713 if (connect->crypto.n_ciphers_pairwise == 0) {
714 connect->crypto.n_ciphers_pairwise = 1;
715 connect->crypto.ciphers_pairwise[0] = cipher;
716 }
fffd0934
JB		 717 }
718 }
719
b23aa676 720 if (!rdev->ops->connect) {
6829c878
JB		 721 if (!rdev->ops->auth || !rdev->ops->assoc)
722 return -EOPNOTSUPP;
723
19957bb3
JB		 724 if (WARN_ON(wdev->conn))
725 return -EINPROGRESS;
726
727 wdev->conn = kzalloc(sizeof(*wdev->conn), GFP_KERNEL);
728 if (!wdev->conn)
729 return -ENOMEM;
6829c878
JB		 730
731 /*
732 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
733 */
734 memcpy(&wdev->conn->params, connect, sizeof(*connect));
735 if (connect->bssid) {
736 wdev->conn->params.bssid = wdev->conn->bssid;
737 memcpy(wdev->conn->bssid, connect->bssid, ETH_ALEN);
738 }
739
740 if (connect->ie) {
741 wdev->conn->ie = kmemdup(connect->ie, connect->ie_len,
742 GFP_KERNEL);
743 wdev->conn->params.ie = wdev->conn->ie;
19957bb3
JB		 744 if (!wdev->conn->ie) {
745 kfree(wdev->conn);
746 wdev->conn = NULL;
6829c878 747 return -ENOMEM;
19957bb3 748 }
6829c878
JB		 749 }
750
751 if (connect->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
752 wdev->conn->auto_auth = true;
753 /* start with open system ... should mostly work */
754 wdev->conn->params.auth_type =
755 NL80211_AUTHTYPE_OPEN_SYSTEM;
756 } else {
757 wdev->conn->auto_auth = false;
758 }
759
760 memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
761 wdev->ssid_len = connect->ssid_len;
762 wdev->conn->params.ssid = wdev->ssid;
763 wdev->conn->params.ssid_len = connect->ssid_len;
764
8bb89485
JB		 765 /* see if we have the bss already */
766 bss = cfg80211_get_conn_bss(wdev);
6829c878
JB		 767
768 wdev->sme_state = CFG80211_SME_CONNECTING;
fffd0934 769 wdev->connect_keys = connkeys;
6829c878 770
f401a6f7
JB		 771 if (prev_bssid) {
772 memcpy(wdev->conn->prev_bssid, prev_bssid, ETH_ALEN);
773 wdev->conn->prev_bssid_valid = true;
774 }
775
bbac31f4
JB		 776 /* we're good if we have a matching bss struct */
777 if (bss) {
6829c878
JB		 778 wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
779 err = cfg80211_conn_do_work(wdev);
bbac31f4 780 cfg80211_put_bss(bss);
6829c878
JB		 781 } else {
782 /* otherwise we'll need to scan for the AP first */
783 err = cfg80211_conn_scan(wdev);
784 /*
785 * If we can't scan right now, then we need to scan again
786 * after the current scan finished, since the parameters
787 * changed (unless we find a good AP anyway).
788 */
789 if (err == -EBUSY) {
790 err = 0;
791 wdev->conn->state = CFG80211_CONN_SCAN_AGAIN;
792 }
793 }
19957bb3 794 if (err) {
415ad1ef 795 kfree(wdev->conn->ie);
19957bb3
JB		 796 kfree(wdev->conn);
797 wdev->conn = NULL;
6829c878 798 wdev->sme_state = CFG80211_SME_IDLE;
fffd0934 799 wdev->connect_keys = NULL;
8dadadb7 800 wdev->ssid_len = 0;
19957bb3 801 }
6829c878
JB		 802
803 return err;
b23aa676
SO		 804 } else {
805 wdev->sme_state = CFG80211_SME_CONNECTING;
fffd0934 806 wdev->connect_keys = connkeys;
b23aa676
SO		 807 err = rdev->ops->connect(&rdev->wiphy, dev, connect);
808 if (err) {
fffd0934 809 wdev->connect_keys = NULL;
b23aa676
SO		 810 wdev->sme_state = CFG80211_SME_IDLE;
811 return err;
812 }
b23aa676 813
6829c878
JB		 814 memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
815 wdev->ssid_len = connect->ssid_len;
b23aa676 816
6829c878
JB		 817 return 0;
818 }
b23aa676
SO		 819}
820
667503dd
JB		 821int cfg80211_connect(struct cfg80211_registered_device *rdev,
822 struct net_device *dev,
fffd0934
JB		 823 struct cfg80211_connect_params *connect,
824 struct cfg80211_cached_keys *connkeys)
667503dd
JB		 825{
826 int err;
827
59bbb6f7 828 mutex_lock(&rdev->devlist_mtx);
667503dd 829 wdev_lock(dev->ieee80211_ptr);
f401a6f7 830 err = __cfg80211_connect(rdev, dev, connect, connkeys, NULL);
667503dd 831 wdev_unlock(dev->ieee80211_ptr);
59bbb6f7 832 mutex_unlock(&rdev->devlist_mtx);
667503dd
JB		 833
834 return err;
835}
836
837int __cfg80211_disconnect(struct cfg80211_registered_device *rdev,
838 struct net_device *dev, u16 reason, bool wextev)
b23aa676 839{
6829c878 840 struct wireless_dev *wdev = dev->ieee80211_ptr;
b23aa676
SO		 841 int err;
842
667503dd
JB		 843 ASSERT_WDEV_LOCK(wdev);
844
6829c878
JB		 845 if (wdev->sme_state == CFG80211_SME_IDLE)
846 return -EINVAL;
847
fffd0934
JB		 848 kfree(wdev->connect_keys);
849 wdev->connect_keys = NULL;
850
b23aa676 851 if (!rdev->ops->disconnect) {
19957bb3
JB		 852 if (!rdev->ops->deauth)
853 return -EOPNOTSUPP;
6829c878 854
19957bb3
JB		 855 /* was it connected by userspace SME? */
856 if (!wdev->conn) {
857 cfg80211_mlme_down(rdev, dev);
858 return 0;
859 }
6829c878
JB		 860
861 if (wdev->sme_state == CFG80211_SME_CONNECTING &&
862 (wdev->conn->state == CFG80211_CONN_SCANNING ||
863 wdev->conn->state == CFG80211_CONN_SCAN_AGAIN)) {
864 wdev->sme_state = CFG80211_SME_IDLE;
415ad1ef 865 kfree(wdev->conn->ie);
19957bb3
JB		 866 kfree(wdev->conn);
867 wdev->conn = NULL;
8dadadb7 868 wdev->ssid_len = 0;
6829c878
JB		 869 return 0;
870 }
871
6829c878 872 /* wdev->conn->params.bssid must be set if > SCANNING */
667503dd
JB		 873 err = __cfg80211_mlme_deauth(rdev, dev,
874 wdev->conn->params.bssid,
875 NULL, 0, reason);
6829c878
JB		 876 if (err)
877 return err;
b23aa676
SO		 878 } else {
879 err = rdev->ops->disconnect(&rdev->wiphy, dev, reason);
880 if (err)
881 return err;
882 }
883
6829c878 884 if (wdev->sme_state == CFG80211_SME_CONNECTED)
667503dd 885 __cfg80211_disconnected(dev, NULL, 0, 0, false);
6829c878 886 else if (wdev->sme_state == CFG80211_SME_CONNECTING)
f2129354
JB		 887 __cfg80211_connect_result(dev, NULL, NULL, 0, NULL, 0,
888 WLAN_STATUS_UNSPECIFIED_FAILURE,
df7fc0f9 889 wextev, NULL);
b23aa676
SO		 890
891 return 0;
892}
19957bb3 893
667503dd
JB		 894int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
895 struct net_device *dev,
896 u16 reason, bool wextev)
897{
898 int err;
899
900 wdev_lock(dev->ieee80211_ptr);
901 err = __cfg80211_disconnect(rdev, dev, reason, wextev);
902 wdev_unlock(dev->ieee80211_ptr);
903
904 return err;
905}
906
19957bb3
JB		 907void cfg80211_sme_disassoc(struct net_device *dev, int idx)
908{
909 struct wireless_dev *wdev = dev->ieee80211_ptr;
910 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
911 u8 bssid[ETH_ALEN];
912
667503dd
JB		 913 ASSERT_WDEV_LOCK(wdev);
914
19957bb3
JB		 915 if (!wdev->conn)
916 return;
917
918 if (wdev->conn->state == CFG80211_CONN_IDLE)
919 return;
920
921 /*
922 * Ok, so the association was made by this SME -- we don't
923 * want it any more so deauthenticate too.
924 */
925
926 if (!wdev->auth_bsses[idx])
927 return;
928
929 memcpy(bssid, wdev->auth_bsses[idx]->pub.bssid, ETH_ALEN);
ec3f1490
JB		 930 if (__cfg80211_mlme_deauth(rdev, dev, bssid,
931 NULL, 0, WLAN_REASON_DEAUTH_LEAVING)) {
19957bb3
JB		 932 /* whatever -- assume gone anyway */
933 cfg80211_unhold_bss(wdev->auth_bsses[idx]);
934 cfg80211_put_bss(&wdev->auth_bsses[idx]->pub);
935 wdev->auth_bsses[idx] = NULL;
936 }
937}
kernel source for telekom puls (alcatel/mediatek)